/home/mooz/bin/arduino-0009/lib/targets/libraries/at45db161d/at45db161d.cpp

Go to the documentation of this file.

#include "at45db161d.h"

ATD45DB161D::ATD45DB161D()
{}
ATD45DB161D::~ATD45DB161D()
{}

void ATD45DB161D::Init()
{
        uint8_t clr;
        
        /* Initialize pinout */
        pinMode(DATAOUT, OUTPUT);
        pinMode(DATAIN, INPUT);
        pinMode(SPICLOCK, OUTPUT);
        pinMode(SLAVESELECT, OUTPUT);
        pinMode(DATAIN, INPUT);
  
        /* Disable device */
        DF_CS_inactive;
  
        /* Setup SPI */
        SPCR = (1 << SPE) | (1 << MSTR) | (1 << CPOL) | (1 << CPHA);

        /* Cleanup registers */
        clr = SPSR;
        clr = SPDR;
}

uint8_t ATD45DB161D::ReadStatusRegister()
{
        uint8_t status;

        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */
  
    /* Send status read command */
        spi_transfer(AT45DB161D_STATUS_REGISTER_READ);
        /* Get result with a dummy write */
        status = spi_transfer(0x00);

        return status;
}

void ATD45DB161D::ReadManufacturerAndDeviceID(struct ATD45DB161D::ID *id)
{
        
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */
  
    /* Send status read command */
        spi_transfer(AT45DB161D_READ_MANUFACTURER_AND_DEVICE_ID);

        /* Manufacturer ID */
        id->manufacturer = spi_transfer(0xff);
        /* Device ID (part 1) */
        id->device[0] = spi_transfer(0xff);
        /* Device ID (part 2) */
        id->device[1] = spi_transfer(0xff);
        /* Extended Device Information String Length */
        id->extendedInfoLength = spi_transfer(0xff);
        
}

void ATD45DB161D::ReadMainMemoryPage(uint16_t page, uint16_t offset)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer(AT45DB161D_PAGE_READ);
        
        /* Address (page | offset)  */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)((page << 2) | (offset >> 8)));
        spi_transfer((uint8_t)(offset & 0xff));
        
        /* 4 "don't care" bytes */
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
        spi_transfer(0x00);
}

void ATD45DB161D::ContinuousArrayRead(uint16_t page, uint16_t offset, uint8_t low)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer( low ? AT45DB161D_CONTINUOUS_READ_LOW_FREQ :
                            AT45DB161D_CONTINUOUS_READ_HIGH_FREQ );

        /* Address (page | offset)  */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)((page << 2) | (offset >> 8)));
        spi_transfer((uint8_t)(offset & 0xff));
}


void ATD45DB161D::BufferRead(uint8_t bufferNum, uint16_t offset, uint8_t low)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        if(bufferNum == 1)
        {
                spi_transfer(low ? AT45DB161D_BUFFER_1_READ_LOW_FREQ :
                                   AT45DB161D_BUFFER_1_READ);
        }
        else
        {
                spi_transfer(low ? AT45DB161D_BUFFER_2_READ_LOW_FREQ :
                                   AT45DB161D_BUFFER_2_READ);

        }
        
        /* 14 "Don't care" bits */
        spi_transfer(0x00);
        /* Rest of the "don't care" bits + bits 8,9 of the offset */
        spi_transfer((uint8_t)(offset >> 8));
        /* bits 7-0 of the offset */
        spi_transfer((uint8_t)(offset & 0xff));
}

void ATD45DB161D::BufferWrite(uint8_t bufferNum, uint16_t offset)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        spi_transfer( (bufferNum == 1) ? AT45DB161D_BUFFER_1_WRITE :
                                         AT45DB161D_BUFFER_2_WRITE);
        
        /* 14 "Don't care" bits */
        spi_transfer(0x00);
        /* Rest of the "don't care" bits + bits 8,9 of the offset */
        spi_transfer((uint8_t)(offset >> 8));
        /* bits 7-0 of the offset */
        spi_transfer((uint8_t)(offset & 0xff));
}

void ATD45DB161D::BufferToPage(uint8_t bufferNum, uint16_t page, uint8_t erase)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Opcode */
        if(erase)
        {
                spi_transfer( (bufferNum == 1) ? AT45DB161D_BUFFER_1_TO_PAGE_WITH_ERASE :
                                             AT45DB161D_BUFFER_2_TO_PAGE_WITH_ERASE);
        }
        else
        {
                spi_transfer( (bufferNum == 1) ? AT45DB161D_BUFFER_1_TO_PAGE_WITHOUT_ERASE :
                                             AT45DB161D_BUFFER_2_TO_PAGE_WITHOUT_ERASE);
        }
        
        /*
         * 3 address bytes consist of :
         *     - 2 don’t care bits
         *     - 12 page address bits (PA11 - PA0) that specify the page in 
         *       the main memory to be written
         *     - 10 don’t care bits
         */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)(page << 2));
        spi_transfer(0x00);
        
        DF_CS_inactive;  /* Start transfer */
        DF_CS_active;    /* If erase was set, the page will first be erased */

        /* Wait for the end of the transfer */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

void ATD45DB161D::PageToBuffer(uint16_t page, uint8_t bufferNum)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */
 
        /* Send opcode */
        spi_transfer((bufferNum == 1) ? AT45DB161D_TRANSFER_PAGE_TO_BUFFER_1 :
                                        AT45DB161D_TRANSFER_PAGE_TO_BUFFER_2);

        /*
         * 3 address bytes consist of :
         *     - 2 don’t care bits
         *     - 12 page address bits (PA11 - PA0) that specify the page in 
         *       the main memory to be written
         *     - 10 don’t care bits
         */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)(page << 2));
        spi_transfer(0x00);
                
        DF_CS_inactive;  /* Start page transfer */
        DF_CS_active;

        /* Wait for the end of the transfer */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

void ATD45DB161D::PageErase(uint16_t page)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer(AT45DB161D_PAGE_ERASE);
        
        /*
         * 3 address bytes consist of :
         *     - 2 don’t care bits
         *     - 12 page address bits (PA11 - PA0) that specify the page in 
         *       the main memory to be written
         *     - 10 don’t care bits
         */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)(page << 2));
        spi_transfer(0x00);
                
        DF_CS_inactive;  /* Start block erase */
        DF_CS_active;

        /* Wait for the end of the block erase operation */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

void ATD45DB161D::BlockErase(uint16_t block)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer(AT45DB161D_BLOCK_ERASE);
        
        /*
         * 3 address bytes consist of :
         *     - 2 don’t care bits
         *     - 9 block address bits (PA11 - PA3)
         *     - 13 don’t care bits
         */
        spi_transfer((uint8_t)(block >> 3));
        spi_transfer((uint8_t)(block << 5));
        spi_transfer(0x00);
                
        DF_CS_inactive;  /* Start block erase */
        DF_CS_active;

        /* Wait for the end of the block erase operation */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

void ATD45DB161D::SectoreErase(uint8_t sector)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer(AT45DB161D_SECTOR_ERASE);
        
        /*
         * 3 address bytes consist of :
         */
        if((sector == 0x0a) || (sector == 0x0b))
        {
                /*
                 *  - 11 don’t care bits
                 *  - 
                 *  - 12 don’t care bits
                 */
                spi_transfer(0x00);
                spi_transfer(((sector & 0x01) << 4));
                spi_transfer(0x00);
        }
        else
        {
                /*
                 *  - 2 don't care bits 
                 *  - 4 sector number bits
                 *  - 18 don't care bits 
                 */
                spi_transfer(sector << 1);
                spi_transfer(0x00);
                spi_transfer(0x00);
        }
                                
        DF_CS_inactive;  /* Start block erase */
        DF_CS_active;

        /* Wait for the end of the block erase operation */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

void ATD45DB161D::ChipErase()
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send chip erase sequence */
        spi_transfer(AT45DB161D_CHIP_ERASE_0);
        spi_transfer(AT45DB161D_CHIP_ERASE_1);
        spi_transfer(AT45DB161D_CHIP_ERASE_2);
        spi_transfer(AT45DB161D_CHIP_ERASE_3);
                                
        DF_CS_inactive;  /* Start chip erase */
        DF_CS_active;

        /* Wait for the end of the chip erase operation */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

void ATD45DB161D::BeginPageWriteThroughBuffer(uint16_t page, uint16_t offset, uint8_t bufferNum)
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer((bufferNum == 1) ? AT45DB161D_PAGE_THROUGH_BUFFER_1 :
                                        AT45DB161D_PAGE_THROUGH_BUFFER_2);

        /* Address */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)((page << 2) | (offset >> 8)));
        spi_transfer((uint8_t)offset);
}

void ATD45DB161D::EndAndWait()
{
        DF_CS_inactive;  /* End current operation */
        DF_CS_active;    /* Some internal operation may occur
                          * (buffer to page transfer, page erase, etc... ) */

        /* Wait for the chip to be ready */
        while(!(ReadStatusRegister() & READY_BUSY))
        {}
}

int8_t ATD45DB161D::ComparePageToBuffer(uint16_t page, uint8_t bufferNum)
{
        uint8_t status;
        
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */

        /* Send opcode */
        spi_transfer((bufferNum == 1) ? AT45DB161D_COMPARE_PAGE_TO_BUFFER_1 :
                                        AT45DB161D_COMPARE_PAGE_TO_BUFFER_2);
        
        /* Page address */
        spi_transfer((uint8_t)(page >> 6));
        spi_transfer((uint8_t)(page << 2));
        spi_transfer(0x00);
        
        DF_CS_inactive;  /* Start comparaison */
        DF_CS_active;

        /* Wait for the end of the comparaison and get the result */
        while(!((status = ReadStatusRegister()) & READY_BUSY))
        {}
                
        return ((status & COMPARE) == COMPARE);
}

void ATD45DB161D::DeepPowerDown()
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */
        
        /* Send opcode */
        spi_transfer(AT45DB161D_DEEP_POWER_DOWN);
        
        /* Enter Deep Power-Down mode */
        DF_CS_inactive;
        
        /* Safety delay */
        delay(100);
}

void ATD45DB161D::ResumeFromDeepPowerDown()
{
        DF_CS_inactive;    /* Make sure to toggle CS signal in order */
        DF_CS_active;      /* to reset Dataflash command decoder     */
        
        /* Send opcode */
        spi_transfer(AT45DB161D_RESUME_FROM_DEEP_POWER_DOWN);
        
        /* Resume device */
        DF_CS_inactive;
        
        /* The CS pin must stay high during t_RDPD microseconds before the device
         * can receive any commands.
         * On the at45db161D t_RDPD = 35 microseconds. But we will wait 100
         * (just to be sure). */
        delay(100);
}
 

---