diff --git a/SPIFlash.cpp b/SPIFlash.cpp index f156b06..e250c17 100644 --- a/SPIFlash.cpp +++ b/SPIFlash.cpp @@ -1,22 +1,40 @@ -/* - * Copyright (c) 2013 by Felix Rusu - * SPI Flash memory library for arduino/moteino. - * This works with 256byte/page SPI flash memory - * For instance a 4MBit (512Kbyte) flash chip will have 2048 pages: 256*2048 = 524288 bytes (512Kbytes) - * Minimal modifications should allow chips that have different page size but modifications - * DEPENDS ON: Arduino SPI library - * - * Updated Jan. 5, 2015, TomWS1, modified writeBytes to allow blocks > 256 bytes and handle page misalignment. - * - * This file is free software; you can redistribute it and/or modify - * it under the terms of either the GNU General Public License version 2 - * or the GNU Lesser General Public License version 2.1, both as - * published by the Free Software Foundation. - */ +// Copyright (c) 2013-2015 by Felix Rusu, LowPowerLab.com +// SPI Flash memory library for arduino/moteino. +// This works with 256byte/page SPI flash memory +// For instance a 4MBit (512Kbyte) flash chip will have 2048 pages: 256*2048 = 524288 bytes (512Kbytes) +// Minimal modifications should allow chips that have different page size but modifications +// DEPENDS ON: Arduino SPI library +// > Updated Jan. 5, 2015, TomWS1, modified writeBytes to allow blocks > 256 bytes and handle page misalignment. +// > Updated Feb. 26, 2015 TomWS1, added support for SPI Transactions (Arduino 1.5.8 and above) +// > Selective merge by Felix after testing in IDE 1.0.6, 1.6.4 +// ********************************************************************************** +// License +// ********************************************************************************** +// 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 . +// +// Licence can be viewed at +// http://www.gnu.org/licenses/gpl-3.0.txt +// +// Please maintain this license information along with authorship +// and copyright notices in any redistribution of this code #include -byte SPIFlash::UNIQUEID[8]; +uint8_t SPIFlash::UNIQUEID[8]; /// IMPORTANT: NAND FLASH memory requires erase before write, because /// it can only transition from 1s to 0s and only the erase command can reset all 0s to 1s @@ -34,15 +52,22 @@ SPIFlash::SPIFlash(uint8_t slaveSelectPin, uint16_t jedecID) { /// Select the flash chip void SPIFlash::select() { - noInterrupts(); //save current SPI settings +#ifndef SPI_HAS_TRANSACTION + noInterrupts(); +#endif _SPCR = SPCR; _SPSR = SPSR; - //set FLASH chip SPI settings + +#ifdef SPI_HAS_TRANSACTION + SPI.beginTransaction(_settings); +#else + // set FLASH SPI settings SPI.setDataMode(SPI_MODE0); SPI.setBitOrder(MSBFIRST); SPI.setClockDivider(SPI_CLOCK_DIV4); //decided to slow down from DIV2 after SPI stalling in some instances, especially visible on mega1284p when RFM69 and FLASH chip both present SPI.begin(); +#endif digitalWrite(_slaveSelectPin, LOW); } @@ -50,9 +75,13 @@ void SPIFlash::select() { void SPIFlash::unselect() { digitalWrite(_slaveSelectPin, HIGH); //restore SPI settings to what they were before talking to the FLASH chip +#ifdef SPI_HAS_TRANSACTION + SPI.endTransaction(); +#else + interrupts(); +#endif SPCR = _SPCR; SPSR = _SPSR; - interrupts(); } /// setup SPI, read device ID etc... @@ -61,6 +90,10 @@ boolean SPIFlash::initialize() _SPCR = SPCR; _SPSR = SPSR; pinMode(_slaveSelectPin, OUTPUT); +#ifdef SPI_HAS_TRANSACTION + _settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); +#endif + unselect(); wakeup(); @@ -74,7 +107,7 @@ boolean SPIFlash::initialize() } /// Get the manufacturer and device ID bytes (as a short word) -word SPIFlash::readDeviceId() +uint16_t SPIFlash::readDeviceId() { #if defined(__AVR_ATmega32U4__) // Arduino Leonardo, MoteinoLeo command(SPIFLASH_IDREAD); // Read JEDEC ID @@ -82,7 +115,7 @@ word SPIFlash::readDeviceId() select(); SPI.transfer(SPIFLASH_IDREAD); #endif - word jedecid = SPI.transfer(0) << 8; + uint16_t jedecid = SPI.transfer(0) << 8; jedecid |= SPI.transfer(0); unselect(); return jedecid; @@ -91,47 +124,47 @@ word SPIFlash::readDeviceId() /// Get the 64 bit unique identifier, stores it in UNIQUEID[8]. Only needs to be called once, ie after initialize /// Returns the byte pointer to the UNIQUEID byte array /// Read UNIQUEID like this: -/// flash.readUniqueId(); for (byte i=0;i<8;i++) { Serial.print(flash.UNIQUEID[i], HEX); Serial.print(' '); } +/// flash.readUniqueId(); for (uint8_t i=0;i<8;i++) { Serial.print(flash.UNIQUEID[i], HEX); Serial.print(' '); } /// or like this: -/// flash.readUniqueId(); byte* MAC = flash.readUniqueId(); for (byte i=0;i<8;i++) { Serial.print(MAC[i], HEX); Serial.print(' '); } -byte* SPIFlash::readUniqueId() +/// flash.readUniqueId(); uint8_t* MAC = flash.readUniqueId(); for (uint8_t i=0;i<8;i++) { Serial.print(MAC[i], HEX); Serial.print(' '); } +uint8_t* SPIFlash::readUniqueId() { command(SPIFLASH_MACREAD); SPI.transfer(0); SPI.transfer(0); SPI.transfer(0); SPI.transfer(0); - for (byte i=0;i<8;i++) + for (uint8_t i=0;i<8;i++) UNIQUEID[i] = SPI.transfer(0); unselect(); return UNIQUEID; } /// read 1 byte from flash memory -byte SPIFlash::readByte(long addr) { +uint8_t SPIFlash::readByte(uint32_t addr) { command(SPIFLASH_ARRAYREADLOWFREQ); SPI.transfer(addr >> 16); SPI.transfer(addr >> 8); SPI.transfer(addr); - byte result = SPI.transfer(0); + uint8_t result = SPI.transfer(0); unselect(); return result; } /// read unlimited # of bytes -void SPIFlash::readBytes(long addr, void* buf, word len) { +void SPIFlash::readBytes(uint32_t addr, void* buf, uint16_t len) { command(SPIFLASH_ARRAYREAD); SPI.transfer(addr >> 16); SPI.transfer(addr >> 8); SPI.transfer(addr); SPI.transfer(0); //"dont care" - for (word i = 0; i < len; ++i) - ((byte*) buf)[i] = SPI.transfer(0); + for (uint16_t i = 0; i < len; ++i) + ((uint8_t*) buf)[i] = SPI.transfer(0); unselect(); } /// Send a command to the flash chip, pass TRUE for isWrite when its a write command -void SPIFlash::command(byte cmd, boolean isWrite){ +void SPIFlash::command(uint8_t cmd, boolean isWrite){ #if defined(__AVR_ATmega32U4__) // Arduino Leonardo, MoteinoLeo DDRB |= B00000001; // Make sure the SS pin (PB0 - used by RFM12B on MoteinoLeo R1) is set as output HIGH! PORTB |= B00000001; @@ -157,7 +190,7 @@ boolean SPIFlash::busy() /* select(); SPI.transfer(SPIFLASH_STATUSREAD); - byte status = SPI.transfer(0); + uint8_t status = SPI.transfer(0); unselect(); return status & 1; */ @@ -165,11 +198,11 @@ boolean SPIFlash::busy() } /// return the STATUS register -byte SPIFlash::readStatus() +uint8_t SPIFlash::readStatus() { select(); SPI.transfer(SPIFLASH_STATUSREAD); - byte status = SPI.transfer(0); + uint8_t status = SPI.transfer(0); unselect(); return status; } @@ -178,7 +211,7 @@ byte SPIFlash::readStatus() /// Write 1 byte to flash memory /// WARNING: you can only write to previously erased memory locations (see datasheet) /// use the block erase commands to first clear memory (write 0xFFs) -void SPIFlash::writeByte(long addr, uint8_t byt) { +void SPIFlash::writeByte(uint32_t addr, uint8_t byt) { command(SPIFLASH_BYTEPAGEPROGRAM, true); // Byte/Page Program SPI.transfer(addr >> 16); SPI.transfer(addr >> 8); @@ -192,7 +225,7 @@ void SPIFlash::writeByte(long addr, uint8_t byt) { /// use the block erase commands to first clear memory (write 0xFFs) /// This version handles both page alignment and data blocks larger than 256 bytes. /// -void SPIFlash::writeBytes(long addr, const void* buf, uint16_t len) { +void SPIFlash::writeBytes(uint32_t addr, const void* buf, uint16_t len) { uint16_t n; uint16_t maxBytes = 256-(addr%256); // force the first set of bytes to stay within the first page uint16_t offset = 0; @@ -205,7 +238,7 @@ void SPIFlash::writeBytes(long addr, const void* buf, uint16_t len) { SPI.transfer(addr); for (uint16_t i = 0; i < n; i++) - SPI.transfer(((byte*) buf)[offset + i]); + SPI.transfer(((uint8_t*) buf)[offset + i]); unselect(); addr+=n; // adjust the addresses and remaining bytes by what we've just transferred. @@ -227,7 +260,7 @@ void SPIFlash::chipErase() { } /// erase a 4Kbyte block -void SPIFlash::blockErase4K(long addr) { +void SPIFlash::blockErase4K(uint32_t addr) { command(SPIFLASH_BLOCKERASE_4K, true); // Block Erase SPI.transfer(addr >> 16); SPI.transfer(addr >> 8); @@ -236,7 +269,7 @@ void SPIFlash::blockErase4K(long addr) { } /// erase a 32Kbyte block -void SPIFlash::blockErase32K(long addr) { +void SPIFlash::blockErase32K(uint32_t addr) { command(SPIFLASH_BLOCKERASE_32K, true); // Block Erase SPI.transfer(addr >> 16); SPI.transfer(addr >> 8);