Giuliano Zaro
4 years ago
committed by
GitHub
GitHub
41 changed files with 413 additions and 179 deletions
@ -0,0 +1,78 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(QSPI_EEPROM) |
|||
|
|||
#include "QSPIFlash.h" |
|||
|
|||
#define INVALID_ADDR 0xffffffff |
|||
#define SECTOR_OF(a) (a & ~(SFLASH_SECTOR_SIZE - 1)) |
|||
#define OFFSET_OF(a) (a & (SFLASH_SECTOR_SIZE - 1)) |
|||
|
|||
Adafruit_SPIFlashBase * QSPIFlash::_flashBase = nullptr; |
|||
uint8_t QSPIFlash::_buf[SFLASH_SECTOR_SIZE]; |
|||
uint32_t QSPIFlash::_addr = INVALID_ADDR; |
|||
|
|||
void QSPIFlash::begin() { |
|||
if (_flashBase != nullptr) return; |
|||
|
|||
_flashBase = new Adafruit_SPIFlashBase(new Adafruit_FlashTransport_QSPI()); |
|||
_flashBase->begin(NULL); |
|||
} |
|||
|
|||
size_t QSPIFlash::size() { |
|||
return _flashBase->size(); |
|||
} |
|||
|
|||
uint8_t QSPIFlash::readByte(const uint32_t address) { |
|||
if (SECTOR_OF(address) == _addr) return _buf[OFFSET_OF(address)]; |
|||
|
|||
return _flashBase->read8(address); |
|||
} |
|||
|
|||
void QSPIFlash::writeByte(const uint32_t address, const uint8_t value) { |
|||
uint32_t const sector_addr = SECTOR_OF(address); |
|||
|
|||
// Page changes, flush old and update new cache
|
|||
if (sector_addr != _addr) { |
|||
flush(); |
|||
_addr = sector_addr; |
|||
|
|||
// read a whole page from flash
|
|||
_flashBase->readBuffer(sector_addr, _buf, SFLASH_SECTOR_SIZE); |
|||
} |
|||
|
|||
_buf[OFFSET_OF(address)] = value; |
|||
} |
|||
|
|||
void QSPIFlash::flush() { |
|||
if (_addr == INVALID_ADDR) return; |
|||
|
|||
_flashBase->eraseSector(_addr / SFLASH_SECTOR_SIZE); |
|||
_flashBase->writeBuffer(_addr, _buf, SFLASH_SECTOR_SIZE); |
|||
|
|||
_addr = INVALID_ADDR; |
|||
} |
|||
|
|||
#endif // QSPI_EEPROM
|
|||
@ -0,0 +1,51 @@ |
|||
/**
|
|||
* @file QSPIFlash.h |
|||
* |
|||
* The MIT License (MIT) |
|||
* |
|||
* Copyright (c) 2019 Ha Thach and Dean Miller for Adafruit Industries LLC |
|||
* |
|||
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
* of this software and associated documentation files (the "Software"), to deal |
|||
* in the Software without restriction, including without limitation the rights |
|||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
* copies of the Software, and to permit persons to whom the Software is |
|||
* furnished to do so, subject to the following conditions: |
|||
* |
|||
* The above copyright notice and this permission notice shall be included in |
|||
* all copies or substantial portions of the Software. |
|||
* |
|||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|||
* THE SOFTWARE. |
|||
* |
|||
* Derived from Adafruit_SPIFlash class with no SdFat references |
|||
* |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include "Adafruit_SPIFlashBase.h" |
|||
|
|||
// This class extends Adafruit_SPIFlashBase by adding caching support.
|
|||
//
|
|||
// This class will use 4096 Bytes of RAM as a block cache.
|
|||
class QSPIFlash { |
|||
public: |
|||
static void begin(); |
|||
static size_t size(); |
|||
static uint8_t readByte(const uint32_t address); |
|||
static void writeByte(const uint32_t address, const uint8_t v); |
|||
static void flush(); |
|||
|
|||
private: |
|||
static Adafruit_SPIFlashBase * _flashBase; |
|||
static uint8_t _buf[SFLASH_SECTOR_SIZE]; |
|||
static uint32_t _addr; |
|||
}; |
|||
|
|||
extern QSPIFlash qspi; |
|||
@ -0,0 +1,66 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* SAMD51 HAL developed by Giuliano Zaro (AKA GMagician) |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#ifdef __SAMD51__ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(EEPROM_SETTINGS) && NONE(QSPI_EEPROM, FLASH_EEPROM_EMULATION) |
|||
|
|||
#include "../shared/eeprom_api.h" |
|||
|
|||
size_t PersistentStore::capacity() { return E2END + 1; } |
|||
|
|||
bool PersistentStore::access_start() { return true; } |
|||
bool PersistentStore::access_finish() { return true; } |
|||
|
|||
bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) { |
|||
while (size--) { |
|||
const uint8_t v = *value; |
|||
uint8_t * const p = (uint8_t * const)pos; |
|||
if (v != eeprom_read_byte(p)) { |
|||
eeprom_write_byte(p, v); |
|||
delay(2); |
|||
if (eeprom_read_byte(p) != v) { |
|||
SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE); |
|||
return true; |
|||
} |
|||
} |
|||
crc16(crc, &v, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) { |
|||
while (size--) { |
|||
uint8_t c = eeprom_read_byte((uint8_t*)pos); |
|||
if (writing) *value = c; |
|||
crc16(crc, &c, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
#endif // EEPROM_SETTINGS && !(QSPI_EEPROM || FLASH_EEPROM_EMULATION)
|
|||
#endif // __SAMD51__
|
|||
@ -0,0 +1,96 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* SAMD51 HAL developed by Giuliano Zaro (AKA GMagician) |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#ifdef __SAMD51__ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
|
|||
#include "../shared/eeprom_api.h" |
|||
|
|||
#define NVMCTRL_CMD(c) do{ \ |
|||
SYNC(!NVMCTRL->STATUS.bit.READY); \ |
|||
NVMCTRL->INTFLAG.bit.DONE = true; \ |
|||
NVMCTRL->CTRLB.reg = c | NVMCTRL_CTRLB_CMDEX_KEY; \ |
|||
SYNC(NVMCTRL->INTFLAG.bit.DONE); \ |
|||
}while(0) |
|||
#define NVMCTRL_FLUSH() do{ \ |
|||
if (NVMCTRL->SEESTAT.bit.LOAD) \ |
|||
NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_SEEFLUSH); \ |
|||
}while(0) |
|||
|
|||
size_t PersistentStore::capacity() { |
|||
const uint8_t psz = NVMCTRL->SEESTAT.bit.PSZ, |
|||
sblk = NVMCTRL->SEESTAT.bit.SBLK; |
|||
|
|||
return (!psz && !sblk) ? 0 |
|||
: (psz <= 2) ? (0x200 << psz) |
|||
: (sblk == 1 || psz == 3) ? 4096 |
|||
: (sblk == 2 || psz == 4) ? 8192 |
|||
: (sblk <= 4 || psz == 5) ? 16384 |
|||
: (sblk >= 9 && psz == 7) ? 65536 |
|||
: 32768; |
|||
} |
|||
|
|||
bool PersistentStore::access_start() { |
|||
NVMCTRL->SEECFG.reg = NVMCTRL_SEECFG_WMODE_BUFFERED; // Buffered mode and segment reallocation active
|
|||
if (NVMCTRL->SEESTAT.bit.RLOCK) |
|||
NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_USEE); // Unlock E2P data write access
|
|||
return true; |
|||
} |
|||
|
|||
bool PersistentStore::access_finish() { |
|||
NVMCTRL_FLUSH(); |
|||
if (!NVMCTRL->SEESTAT.bit.LOCK) |
|||
NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_LSEE); // Lock E2P data write access
|
|||
return true; |
|||
} |
|||
|
|||
bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) { |
|||
while (size--) { |
|||
const uint8_t v = *value; |
|||
SYNC(NVMCTRL->SEESTAT.bit.BUSY); |
|||
if (NVMCTRL->INTFLAG.bit.SEESFULL) |
|||
NVMCTRL_FLUSH(); // Next write will trigger a sector reallocation. I need to flush 'pagebuffer'
|
|||
((volatile uint8_t *)SEEPROM_ADDR)[pos] = v; |
|||
SYNC(!NVMCTRL->INTFLAG.bit.SEEWRC); |
|||
crc16(crc, &v, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) { |
|||
while (size--) { |
|||
SYNC(NVMCTRL->SEESTAT.bit.BUSY); |
|||
uint8_t c = ((volatile uint8_t *)SEEPROM_ADDR)[pos]; |
|||
if (writing) *value = c; |
|||
crc16(crc, &c, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
#endif // FLASH_EEPROM_EMULATION
|
|||
#endif // __SAMD51__
|
|||
@ -0,0 +1,71 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* SAMD51 HAL developed by Giuliano Zaro (AKA GMagician) |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#ifdef __SAMD51__ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(QSPI_EEPROM) |
|||
|
|||
#include "../shared/eeprom_api.h" |
|||
|
|||
#include "QSPIFlash.h" |
|||
|
|||
static bool initialized; |
|||
|
|||
size_t PersistentStore::capacity() { return qspi.size(); } |
|||
|
|||
bool PersistentStore::access_start() { |
|||
if (!initialized) { |
|||
qspi.begin(); |
|||
initialized = true; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
bool PersistentStore::access_finish() { |
|||
qspi.flush(); |
|||
return true; |
|||
} |
|||
|
|||
bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) { |
|||
while (size--) { |
|||
const uint8_t v = *value; |
|||
qspi.writeByte(pos, v); |
|||
crc16(crc, &v, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) { |
|||
while (size--) { |
|||
uint8_t c = qspi.readByte(pos); |
|||
if (writing) *value = c; |
|||
crc16(crc, &c, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
#endif // QSPI_EEPROM
|
|||
#endif // __SAMD51__
|
|||
@ -1,129 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* SAMD51 HAL developed by Giuliano Zaro (AKA GMagician) |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#ifdef __SAMD51__ |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(EEPROM_SETTINGS) |
|||
|
|||
#include "../shared/persistent_store_api.h" |
|||
|
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
#define NVMCTRL_CMD(c) do{ \ |
|||
SYNC(!NVMCTRL->STATUS.bit.READY); \ |
|||
NVMCTRL->INTFLAG.bit.DONE = true; \ |
|||
NVMCTRL->CTRLB.reg = c | NVMCTRL_CTRLB_CMDEX_KEY; \ |
|||
SYNC(NVMCTRL->INTFLAG.bit.DONE); \ |
|||
}while(0) |
|||
#define NVMCTRL_FLUSH() do{ \ |
|||
if (NVMCTRL->SEESTAT.bit.LOAD) \ |
|||
NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_SEEFLUSH); \ |
|||
}while(0) |
|||
#endif |
|||
|
|||
bool PersistentStore::access_start() { |
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
NVMCTRL->SEECFG.reg = NVMCTRL_SEECFG_WMODE_BUFFERED; // Buffered mode and segment reallocation active
|
|||
#endif |
|||
|
|||
return true; |
|||
} |
|||
|
|||
bool PersistentStore::access_finish() { |
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
NVMCTRL_FLUSH(); |
|||
if (!NVMCTRL->SEESTAT.bit.LOCK) |
|||
NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_LSEE); // Lock E2P data write access
|
|||
#endif |
|||
|
|||
return true; |
|||
} |
|||
|
|||
bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) { |
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
if (NVMCTRL->SEESTAT.bit.RLOCK) |
|||
NVMCTRL_CMD(NVMCTRL_CTRLB_CMD_USEE); // Unlock E2P data write access
|
|||
#endif |
|||
|
|||
while (size--) { |
|||
const uint8_t v = *value; |
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
SYNC(NVMCTRL->SEESTAT.bit.BUSY); |
|||
if (NVMCTRL->INTFLAG.bit.SEESFULL) |
|||
NVMCTRL_FLUSH(); // Next write will trigger a sector reallocation. I need to flush 'pagebuffer'
|
|||
((volatile uint8_t *)SEEPROM_ADDR)[pos] = v; |
|||
SYNC(!NVMCTRL->INTFLAG.bit.SEEWRC); |
|||
#else |
|||
uint8_t * const p = (uint8_t * const)pos; |
|||
if (v != eeprom_read_byte(p)) { |
|||
eeprom_write_byte(p, v); |
|||
delay(2); |
|||
if (eeprom_read_byte(p) != v) { |
|||
SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE); |
|||
return true; |
|||
} |
|||
} |
|||
#endif |
|||
crc16(crc, &v, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) { |
|||
while (size--) { |
|||
uint8_t c; |
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
SYNC(NVMCTRL->SEESTAT.bit.BUSY); |
|||
c = ((volatile uint8_t *)SEEPROM_ADDR)[pos]; |
|||
#else |
|||
c = eeprom_read_byte((uint8_t*)pos); |
|||
#endif |
|||
if (writing) *value = c; |
|||
crc16(crc, &c, 1); |
|||
pos++; |
|||
value++; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
size_t PersistentStore::capacity() { |
|||
#if ENABLED(FLASH_EEPROM_EMULATION) |
|||
const uint8_t psz = NVMCTRL->SEESTAT.bit.PSZ, |
|||
sblk = NVMCTRL->SEESTAT.bit.SBLK; |
|||
|
|||
if (!psz && !sblk) return 0; |
|||
else if (psz <= 2) return (0x200 << psz); |
|||
else if (sblk == 1 || psz == 3) return 4096; |
|||
else if (sblk == 2 || psz == 4) return 8192; |
|||
else if (sblk <= 4 || psz == 5) return 16384; |
|||
else if (sblk >= 9 && psz == 7) return 65536; |
|||
else return 32768; |
|||
#else |
|||
return E2END + 1; |
|||
#endif |
|||
} |
|||
|
|||
#endif // EEPROM_SETTINGS
|
|||
|
|||
#endif // __SAMD51__
|
|||
Loading…
Reference in new issue