Implementing the Driver The driver I will show you here is a DataFlash driver which lies over the AT91M55800 SPI driver, since the AT45DB011B an SPI device.





Fortunately, eCos provides a SPI driver for the AT91M55800 in its port, so we can just use it without any effort. Every eCos device driver must use two OS-provided macros to register itself, so its init function gets called every time the OS boots and its lookup function is called whenever the user application invokes cyg_io_lookup() to get the handler to the device, specifying the device name as an argument. These two macros are BLOCK_DEVIO_TABLE() and BLOCK_DEVTAB_ENTRY().
The eCos docs about the SPI driver say that we need to make sure a single SPI operation is taking part at that time, so a mutex is what we need to synchronize the ISP access:

cyg_mutex_t mutex;            // mutex used to synchronize the access

Every driver must export pointers to at least five mandatory functions:
- init function as mentioned before, called with the OS boot
- lookup function called each time the user application gets a handle to the device
- write and read functions used to actually transfer data
- set and get device configuration functions.

In our case the init function is only used to initialize the mutex and the SPI device handle:

cyg_mutex_init( &mutex );         // init the mutex we use
spi_device = cyg_spi_dataflash_dev0;

Later, the driver functions must lock the mutex on entry and release it on exit:

cyg_mutex_lock( &mutex );

cyg_mutex_unlock( &mutex );

Ok so far. Here comes the driver lookup function. This function typically sets up the device for actual use, turning on interrupts, configuring the controller, etc. But we will do nothing here because all the required work is done by the eCos SPI driver.

We will also need a function which will wait for the DataFlash to finish the previous internal operation. The idea is to poll the RDY flag for a predefined timeout period. This faces us for the first time with the issue of sending commands to the DataFlash chip. Every SPI device may send data while receiving, so when issuing a command we are going to use two data buffers, the first is for the outgoing data, in our case the command to the chip, and the second is the incoming data what the chip sends to us in the STATUS REGISTER READ command is the very status register value, which we will check

cyg_spi_transfer(spi_device, FLAG_POLLED, 2, tx_buff, rx_buff);

cyg_spi_transfer() function sends and receives given data via the SPI interface. The first argument is the handle to the interface, the second is the type of the transfer i.e. polled, not interrupt driven, follows the number of bytes to be sent/received and last are the TX and RX buffers.

The 7th bit of the status register, which is the second byte for the received data, is the RDY bit we are interested in, so let's check it:

if ( rx_buff[1] & 0x80 ) break;     // check if the chip is ready

The read and write driver functions are slightly different when working with the SPI interface: they use cyg_spi_transaction_begin(), cyg_spi_transaction_transfer() and     cyg_spi_transaction_end(), This is due to the complicated commands used to read:

// start SPI access
//=================
cyg_spi_transaction_begin( spi_device );

// send command
//=============
cyg_spi_transaction_transfer( spi_device, FLAG_POLLED, 8, cmd, NULL, 0);

// receive data
//=============
cyg_spi_transaction_transfer( spi_device, FLAG_POLLED, PAGE_SIZE, NULL, buffer, 0);

// end of SPI operation
//=====================
cyg_spi_transaction_end( spi_device );

In the driver write function, before every new page is written, the chip must have completed the previous write operation, so the chip status must be checked

We are almost done, but we need to implement the driver get/set configuration functions. There is not much to set the driver, so this function is kind of empty. I made the get config function to return the FlashData chip metrics:

int at45_get_config(cyg_io_handle_t handle, int key, void *buffer, cyg_uint32 *len)
{
    switch ( key )
    {
    case CYG_IO_CONFIG_SIZE:
      if (*len != sizeof(int)) return EINVAL;
       *((int*)buffer) = CHIP_SIZE;
       break;

    case CYG_IO_CONFIG_BLOCK_SIZE:
      if (*len != sizeof(int)) return EINVAL;
      *((int*)buffer) = PAGE_SIZE;
      break;

    default:
      return ENOSYS;
  }
  return ENOERR;
}