mirror of
https://github.com/thelsing/knx.git
synced 2024-10-20 20:07:45 +02:00
235 lines
6.5 KiB
C++
235 lines
6.5 KiB
C++
#include "samd_platform.h"
|
|
|
|
#ifdef ARDUINO_ARCH_SAMD
|
|
#include <knx/bits.h>
|
|
|
|
#include <Arduino.h>
|
|
#ifdef USE_SAMD_EEPROM_EMULATION
|
|
#include <FlashAsEEPROM.h>
|
|
#endif
|
|
|
|
#if KNX_FLASH_SIZE % 1024
|
|
#error "KNX_FLASH_SIZE must be multiple of 1024"
|
|
#endif
|
|
|
|
#ifndef KNX_SERIAL
|
|
#define KNX_SERIAL Serial1
|
|
#endif
|
|
|
|
SamdPlatform::SamdPlatform()
|
|
#ifndef KNX_NO_DEFAULT_UART
|
|
: ArduinoPlatform(&KNX_SERIAL)
|
|
#endif
|
|
{
|
|
#ifndef USE_SAMD_EEPROM_EMULATION
|
|
init();
|
|
#endif
|
|
}
|
|
|
|
SamdPlatform::SamdPlatform( HardwareSerial* s) : ArduinoPlatform(s)
|
|
{
|
|
#ifndef USE_SAMD_EEPROM_EMULATION
|
|
init();
|
|
#endif
|
|
}
|
|
|
|
uint32_t SamdPlatform::uniqueSerialNumber()
|
|
{
|
|
#if defined (__SAMD51__)
|
|
// SAMD51 from section 9.6 of the datasheet
|
|
#define SERIAL_NUMBER_WORD_0 *(volatile uint32_t*)(0x008061FC)
|
|
#define SERIAL_NUMBER_WORD_1 *(volatile uint32_t*)(0x00806010)
|
|
#define SERIAL_NUMBER_WORD_2 *(volatile uint32_t*)(0x00806014)
|
|
#define SERIAL_NUMBER_WORD_3 *(volatile uint32_t*)(0x00806018)
|
|
#else
|
|
//#elif defined (__SAMD21E17A__) || defined(__SAMD21G18A__) || defined(__SAMD21E18A__) || defined(__SAMD21J18A__)
|
|
// SAMD21 from section 9.3.3 of the datasheet
|
|
#define SERIAL_NUMBER_WORD_0 *(volatile uint32_t*)(0x0080A00C)
|
|
#define SERIAL_NUMBER_WORD_1 *(volatile uint32_t*)(0x0080A040)
|
|
#define SERIAL_NUMBER_WORD_2 *(volatile uint32_t*)(0x0080A044)
|
|
#define SERIAL_NUMBER_WORD_3 *(volatile uint32_t*)(0x0080A048)
|
|
#endif
|
|
|
|
return SERIAL_NUMBER_WORD_0 ^ SERIAL_NUMBER_WORD_1 ^ SERIAL_NUMBER_WORD_2 ^ SERIAL_NUMBER_WORD_3;
|
|
}
|
|
|
|
void SamdPlatform::restart()
|
|
{
|
|
println("restart");
|
|
NVIC_SystemReset();
|
|
}
|
|
|
|
#ifdef USE_SAMD_EEPROM_EMULATION
|
|
#pragma warning "Using EEPROM Simulation"
|
|
uint8_t* SamdPlatform::getEepromBuffer(uint32_t size)
|
|
{
|
|
//EEPROM.begin(size);
|
|
if(size > EEPROM_EMULATION_SIZE)
|
|
fatalError();
|
|
|
|
return EEPROM.getDataPtr();
|
|
}
|
|
|
|
void SamdPlatform::commitToEeprom()
|
|
{
|
|
EEPROM.commit();
|
|
}
|
|
#else
|
|
|
|
extern uint32_t __etext;
|
|
extern uint32_t __data_start__;
|
|
extern uint32_t __data_end__;
|
|
|
|
static const uint32_t pageSizes[] = {8, 16, 32, 64, 128, 256, 512, 1024};
|
|
|
|
void SamdPlatform::init()
|
|
{
|
|
_memoryType = Flash;
|
|
_pageSize = pageSizes[NVMCTRL->PARAM.bit.PSZ];
|
|
_pageCnt = NVMCTRL->PARAM.bit.NVMP;
|
|
_rowSize = PAGES_PER_ROW * _pageSize;
|
|
|
|
// find end of program flash and set limit to next row
|
|
uint32_t endEddr = (uint32_t)(&__etext + (&__data_end__ - &__data_start__)); // text + data MemoryBlock
|
|
#ifdef KNX_FLASH_OFFSET
|
|
_MemoryStart = KNX_FLASH_OFFSET;
|
|
_MemoryEnd = KNX_FLASH_OFFSET + KNX_FLASH_SIZE;
|
|
#else
|
|
_MemoryStart = getRowAddr(_pageSize * _pageCnt - KNX_FLASH_SIZE - 1); // 23295
|
|
_MemoryEnd = getRowAddr(_pageSize * _pageCnt - 1);
|
|
#endif
|
|
// chosen flash size is not available anymore
|
|
if (_MemoryStart < endEddr) {
|
|
println("KNX_FLASH_SIZE is not available (possible too much flash use by firmware)");
|
|
fatalError();
|
|
}
|
|
}
|
|
|
|
size_t SamdPlatform::flashEraseBlockSize()
|
|
{
|
|
return PAGES_PER_ROW;
|
|
}
|
|
|
|
size_t SamdPlatform::flashPageSize()
|
|
{
|
|
return _pageSize;
|
|
}
|
|
|
|
uint8_t* SamdPlatform::userFlashStart()
|
|
{
|
|
return (uint8_t*)_MemoryStart;
|
|
}
|
|
|
|
size_t SamdPlatform::userFlashSizeEraseBlocks()
|
|
{
|
|
if (KNX_FLASH_SIZE <= 0)
|
|
return 0;
|
|
else
|
|
return ((KNX_FLASH_SIZE - 1) / (flashPageSize() * flashEraseBlockSize())) + 1;
|
|
}
|
|
|
|
void SamdPlatform::flashErase(uint16_t eraseBlockNum)
|
|
{
|
|
noInterrupts();
|
|
|
|
eraseRow((void *)(_MemoryStart + eraseBlockNum * _rowSize));
|
|
// flash_range_erase(KNX_FLASH_OFFSET + eraseBlockNum * flashPageSize() * flashEraseBlockSize(), flashPageSize() * flashEraseBlockSize());
|
|
|
|
interrupts();
|
|
}
|
|
|
|
void SamdPlatform::flashWritePage(uint16_t pageNumber, uint8_t* data)
|
|
{
|
|
noInterrupts();
|
|
|
|
write((void *)(_MemoryStart + pageNumber * _pageSize), data, _pageSize);
|
|
// flash_range_program(KNX_FLASH_OFFSET + pageNumber * flashPageSize(), data, flashPageSize());
|
|
|
|
interrupts();
|
|
}
|
|
|
|
void SamdPlatform::writeBufferedEraseBlock()
|
|
{
|
|
if (_bufferedEraseblockNumber > -1 && _bufferedEraseblockDirty)
|
|
{
|
|
noInterrupts();
|
|
|
|
eraseRow((void *)(_MemoryStart + _bufferedEraseblockNumber * _rowSize));
|
|
write((void *)(_MemoryStart + _bufferedEraseblockNumber * _rowSize), _eraseblockBuffer, _rowSize);
|
|
// flash_range_erase(KNX_FLASH_OFFSET + _bufferedEraseblockNumber * flashPageSize() * flashEraseBlockSize(), flashPageSize() * flashEraseBlockSize());
|
|
// flash_range_program(KNX_FLASH_OFFSET + _bufferedEraseblockNumber * flashPageSize() * flashEraseBlockSize(), _eraseblockBuffer, flashPageSize() * flashEraseBlockSize());
|
|
|
|
interrupts();
|
|
|
|
_bufferedEraseblockDirty = false;
|
|
}
|
|
}
|
|
|
|
uint32_t SamdPlatform::getRowAddr(uint32_t flasAddr)
|
|
{
|
|
return flasAddr & ~(_rowSize - 1);
|
|
}
|
|
|
|
void SamdPlatform::write(const volatile void *flash_ptr, const void *data, uint32_t size)
|
|
{
|
|
// Calculate data boundaries
|
|
size = (size + 3) / 4;
|
|
volatile uint32_t *src_addr = (volatile uint32_t *)data;
|
|
volatile uint32_t *dst_addr = (volatile uint32_t *)flash_ptr;
|
|
// volatile uint32_t *dst_addr = (volatile uint32_t *)flash_ptr;
|
|
// const uint8_t *src_addr = (uint8_t *)data;
|
|
|
|
// Disable automatic page write
|
|
NVMCTRL->CTRLB.bit.MANW = 1;
|
|
|
|
// Do writes in pages
|
|
while (size)
|
|
{
|
|
// Execute "PBC" Page Buffer Clear
|
|
NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_PBC;
|
|
while (NVMCTRL->INTFLAG.bit.READY == 0)
|
|
{
|
|
}
|
|
|
|
// Fill page buffer
|
|
uint32_t i;
|
|
for (i = 0; i < (_pageSize / 4) && size; i++)
|
|
{
|
|
*dst_addr = *src_addr;
|
|
src_addr++;
|
|
dst_addr++;
|
|
size--;
|
|
}
|
|
|
|
// Execute "WP" Write Page
|
|
NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_WP;
|
|
while (NVMCTRL->INTFLAG.bit.READY == 0)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
void SamdPlatform::erase(const volatile void *flash_ptr, uint32_t size)
|
|
{
|
|
const uint8_t *ptr = (const uint8_t *)flash_ptr;
|
|
while (size > _rowSize)
|
|
{
|
|
eraseRow(ptr);
|
|
ptr += _rowSize;
|
|
size -= _rowSize;
|
|
}
|
|
eraseRow(ptr);
|
|
}
|
|
|
|
void SamdPlatform::eraseRow(const volatile void *flash_ptr)
|
|
{
|
|
NVMCTRL->ADDR.reg = ((uint32_t)flash_ptr) / 2;
|
|
NVMCTRL->CTRLA.reg = NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_ER;
|
|
while (!NVMCTRL->INTFLAG.bit.READY)
|
|
{
|
|
}
|
|
}
|
|
|
|
#endif
|
|
#endif
|