osd-contiki/cpu/avr/dev/usb/storage/avr_flash.c

/* This file has been prepared for Doxygen automatic documentation generation.*/
/*! \file avr_flash.c *********************************************************
 *
 * \brief
 *      This file writes/reads to/from flash memory internal to the AVR.
 *
 * \addtogroup usbstick
 *
 * \author
 *      Colin O'Flynn <coflynn@newae.com>
 ******************************************************************************/
/* 
   Copyright (c) 2008  Colin O'Flynn
   All rights reserved.

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:

   * Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution.
   * Neither the name of the copyright holders nor the names of
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
*/

/**
 \addtogroup usbstorage
 @{
*/

//_____  I N C L U D E S ___________________________________________________

#include "config.h"                         // system configuration
#include "storage/avr_flash.h"

#include <avr/pgmspace.h>
#include <avr/boot.h>

#ifndef SPM_PAGESIZE
#error SPM_PAGESIZE undefined!!!
#endif
 

//_____ M A C R O S ________________________________________________________
//_____ P R I V A T E    D E C L A R A T I O N _____________________________


//_____ D E F I N I T I O N ________________________________________________


#define MEM_BASE_ADDRESS       0x10000UL


DATA    U32  gl_ptr_mem;             /* memory data pointer */


/* Disk management  */
bit     reserved_disk_space = FALSE;    /* reserved space for application on disk */


U32 AVRF_DISK_SIZE = 111; /* 57 KB, some room at end saved for bootloader section */


void  avrf_check_init( void );


//_____ D E C L A R A T I O N ______________________________________________

//!
//! @brief This function initializes the hw/sw ressources required to drive the AVR Flash
//!
//! @warning Code:?? bytes (function code length)
//!
//!/
void avrf_mem_init(void)
{
  ;    
}


//!
//! @brief This function tests the state of the AVR Flash
//!
//! @warning Code:?? bytes (function code length)
//!
//! @return                Ctrl_status
//!   It is ready    ->    CTRL_GOOD
//!   Else           ->    CTRL_NO_PRESENT
//!/
Ctrl_status avrf_test_unit_ready(void)
{
   return CTRL_GOOD;
}


//!
//! @brief This function gives the address of the last valid sector.
//!
//! @warning Code:?? bytes (function code length)
//!
//! @param *u32_nb_sector  number of sector (sector = 512B). OUT
//!
//! @return                Ctrl_status
//!   It is ready    ->    CTRL_GOOD
//!/
Ctrl_status avrf_read_capacity( U32 *u32_nb_sector )
{
   *u32_nb_sector = AVRF_DISK_SIZE;
   return CTRL_GOOD;
}


//!
//! @brief This function returns the write protected status of the memory.
//!
//! Only used by memory removal with a HARDWARE SPECIFIC write protected detection
//! !!! The customer must unplug the memory to change this write protected status,
//! which cannot be for a DF.
//!
//! @warning Code:?? bytes (function code length)
//!
//! @return FALSE  -> the memory is not write-protected (always)
//!/
Bool  avrf_wr_protect(void)
{
   return FALSE;
}


//!
//! @brief This function tells if the memory has been removed or not.
//!
//! @warning Code:?? bytes (function code length)
//!
//! @return FALSE  -> The memory isn't removed
//!/
Bool  avrf_removal(void)
{
   return FALSE;
}



//------------ STANDARD FUNCTIONS to read/write the memory --------------------

//!
//! @brief This function performs a read operation of n sectors from a given address on.
//! (sector = 512B)
//!
//!         DATA FLOW is: AVRF => USB
//!
//!
//! @warning Code:?? bytes (function code length)
//!
//! @param addr         Sector address to start the read from
//! @param nb_sector    Number of sectors to transfer
//!
//! @return                Ctrl_status
//!   It is ready    ->    CTRL_GOOD
//!   A error occur  ->    CTRL_FAIL
//!
Ctrl_status avrf_read_10( U32 addr , U16 nb_sector )
{
   avrf_read_open(addr);                    // wait device is not busy, then send command & address
   avrf_read_sector(nb_sector);             // transfer data from memory to USB
   avrf_read_close();                    // unselect memory
   return CTRL_GOOD;
}


//! This fonction initialise the memory for a write operation
//!
//!         DATA FLOW is: USB => DF
//!
//!
//! (sector = 512B)
//! @param addr         Sector address to start write
//! @param nb_sector    Number of sectors to transfer
//!
//! @return                Ctrl_status
//!   It is ready    ->    CTRL_GOOD
//!   A error occur  ->    CTRL_FAIL
//!
Ctrl_status avrf_write_10( U32 addr , U16 nb_sector )
{

   avrf_write_open(addr);                    // wait device is not busy, then send command & address
   avrf_write_sector(nb_sector);             // transfer data from memory to USB
   avrf_write_close();                    // unselect memory
   return CTRL_GOOD;
}


//------------ AVR FLASH LOWER LEVEL ROUTIENS -----------------------------------------

//!
//! @brief This function opens a DF memory in read mode at a given sector address.
//!
//! NOTE: Address may not be synchronized on the beginning of a page (depending on the DF page size).
//!
//! @warning Code:?? bytes (function code length)
//!
//! @param  pos   Logical sector address
//!
//! @return bit
//!   The open succeeded      -> OK
//!/
bit avrf_read_open (Uint32 pos)
{
  // Set the global memory ptr at a Byte address.
  gl_ptr_mem = (pos * 512) + MEM_BASE_ADDRESS;

  return OK;
}


//!
//! @brief This function unselects the current DF memory.
//!
//! @warning Code:?? bytes (function code length)
//!
//!/
void avrf_read_close (void)
{
  ;
}



//!
//! @brief This function is optimized and writes nb-sector * 512 Bytes from
//! DataFlash memory to USB controller
//!
//!         DATA FLOW is: DF => USB
//!
//!
//! NOTE:
//!   - First call must be preceded by a call to the df_read_open() function,
//!   - The USB EPIN must have been previously selected,
//!   - USB ping-pong buffers are free,
//!   - As 512 is always a sub-multiple of page size, there is no need to check
//!     page end for each Bytes,
//!   - Interrupts are disabled during transfer to avoid timer interrupt,
//!   - nb_sector always >= 1, cannot be zero.
//!
//! @warning code:?? bytes (function code length)
//!
//! @param nb_sector    number of contiguous sectors to read [IN]
//!
//! @return bit
//!   The read succeeded   -> OK
//!/
bit avrf_read_sector (Uint16 nb_sector)
{
   U8 i,j;
   do
   {
      for (i = 8; i != 0; i--)
      {
         Disable_interrupt();    // Global disable.

		 for (j = 0; j < 64; j++) {
         	Usb_write_byte(pgm_read_byte_far(gl_ptr_mem++));
		 }
         

         //# Send the USB FIFO IN content to the USB Host.
         Usb_send_in();       // Send the FIFO IN content to the USB Host.

         Enable_interrupt();     // Global interrupt re-enable.

         // Wait until the tx is done so that we may write to the FIFO IN again.
         while(Is_usb_write_enabled()==FALSE);
      }    
      nb_sector--;            // 1 more sector read
   }
   while (nb_sector != 0);

  return OK;   // Read done.
}


//!
//! @brief This function opens a DF memory in write mode at a given sector
//! address.
//!
//! NOTE: If page buffer > 512 bytes, page content is first loaded in buffer to
//! be partially updated by write_byte or write64 functions.
//!
//! @warning Code:?? bytes (function code length)
//!
//! @param  pos   Sector address
//!
//! @return bit
//!   The open succeeded      -> OK
//!/
bit avrf_write_open (Uint32 pos)
{
  // Set the global memory ptr at a Byte address.
  gl_ptr_mem = (pos * 512) + MEM_BASE_ADDRESS;

  return OK;
}


//!
//! @brief This function fills the end of the logical sector (512B) and launch
//! page programming.
//!
//! @warning Code:?? bytes (function code length)
//!
//!/
void avrf_write_close (void)
{
	;
}



/* This code can be setup to work with the DFU bootloader, which comes with the AT90USB1287. However I haven't
   had time to test it with such */
#define LAST_BOOT_ENTRY 0xFFFE


void dfuclone_boot_buffer_write(uint16_t dummy, uint32_t baseaddr, uint16_t pageaddr, uint16_t word);
void dfuclone_boot_page_erase(uint32_t dummy1, uint16_t dummy2, uint32_t address);
void dfuclone_boot_page_write(uint32_t dummy1, uint16_t dummy2, uint32_t address);


/* Enable the use of the AVR DFU bootloader by defining "USE_AVRDFU_BOOTLOADER", it will
then call the low-level routines already in the bootloader. */
#ifdef USE_AVRDFU_BOOTLOADER

#error UNTESTED/UNSUPPORTED AT THIS TIME

// These functions pointers are used to call functions entry points in bootloader
void (*dfu_boot_buffer_write) (uint16_t dummy, uint32_t baseaddr, uint16_t pageaddr, uint16_t word)=
       (void (*)(uint16_t, uint32_t, uint16_t, uint16_t))(LAST_BOOT_ENTRY-6);

void (*dfu_boot_page_write) (uint32_t dummy1, uint16_t dummy2, uint32_t address)=
       (void (*)(uint32_t, uint16_t, uint32_t))(LAST_BOOT_ENTRY-4);

void (*dfu_boot_page_erase) (uint32_t dummy1, uint16_t dummy2, uint32_t address)=
       (void (*)(uint32_t, uint16_t, uint32_t))(LAST_BOOT_ENTRY-2);

#else 

// These functions pointers are used to call functions entry points in bootloader
void (*dfu_boot_buffer_write) (uint16_t dummy, uint32_t baseaddr, uint16_t pageaddr, uint16_t word)=
       dfuclone_boot_buffer_write;

void (*dfu_boot_page_write) (uint32_t dummy1, uint16_t dummy2, uint32_t address)=
       dfuclone_boot_page_write;

void (*dfu_boot_page_erase) (uint32_t dummy1, uint16_t dummy2, uint32_t address)=
       dfuclone_boot_page_erase;



#endif

//!
//! @brief This function is optimized and writes nb-sector * 512 Bytes from
//! USB controller to DataFlash memory
//!
//!         DATA FLOW is: USB => DF
//!
//!
//! NOTE:
//!   - First call must be preceded by a call to the df_write_open() function,
//!   - As 512 is always a sub-multiple of page size, there is no need to check
//!     page end for each Bytes,
//!   - The USB EPOUT must have been previously selected,
//!   - Interrupts are disabled during transfer to avoid timer interrupt,
//!   - nb_sector always >= 1, cannot be zero.
//!
//! @warning code:?? bytes (function code length)
//!
//! @param nb_sector    number of contiguous sectors to write [IN]
//!
//! @return bit
//!   The write succeeded  -> OK
//!/
bit avrf_write_sector (Uint16 nb_sector)
{
  Byte i, j;
  U16 w; 
  
  U16 pgindex = 0;
  U16 sector_bytecounter = 0;


   do
   {
    //# Write 8x64b = 512b from the USB FIFO OUT.
    for (i = 8; i != 0; i--)
    {
      // Wait end of rx in USB EPOUT.
      while(Is_usb_read_enabled()==FALSE);

  	  Disable_interrupt();    // Global disable.

      //If start of page, erase it! 
	  if (pgindex == 0) {
  	  	 (*dfu_boot_page_erase)(0, 0, gl_ptr_mem);
	  }

      //For all the data in the endpoint, write to flash temp page
	  for (j = 0; j < 32; j++) {
	      w = Usb_read_byte();
	      w += Usb_read_byte() << 8;	
		  (*dfu_boot_buffer_write)(0, gl_ptr_mem, pgindex, w);
		  pgindex += 2;
	  }

      Usb_ack_receive_out();  // USB EPOUT read acknowledgement.

      //If we have filled flash page, write that sucker to memory
	  if (pgindex == SPM_PAGESIZE) {
		  
		  (*dfu_boot_page_write)(0,0, gl_ptr_mem);

		  Enable_interrupt();    // Global enable again
		  
		  gl_ptr_mem += SPM_PAGESIZE;   // Update the memory pointer.
		  pgindex = 0;

		  sector_bytecounter += SPM_PAGESIZE;

		  if(sector_bytecounter == 512) {
      		nb_sector--;                  // 1 more sector written
	  		sector_bytecounter = 0;
		  }

	  }

    } // for (i = 8; i != 0; i--)

   }
   while (nb_sector != 0);

  return OK;                  // Write done
}


#ifndef USE_AVRDFU_BOOTLOADER
/* Perform read/write of FLASH, using same calling convention as low-level routines in AVR DFU bootloader */

BOOTLOADER_SECTION void dfuclone_boot_buffer_write(uint16_t dummy, uint32_t baseaddr, uint16_t pageaddr, uint16_t word)
{
	boot_page_fill(baseaddr + pageaddr, word);
	return;
}


BOOTLOADER_SECTION void dfuclone_boot_page_erase(uint32_t dummy1, uint16_t dummy2, uint32_t address)
{
	boot_page_erase(address);
  	boot_spm_busy_wait();
	boot_rww_enable();
	return;
}

BOOTLOADER_SECTION void dfuclone_boot_page_write(uint32_t dummy1, uint16_t dummy2, uint32_t address)
{
	boot_page_write(address);
    boot_spm_busy_wait();
	boot_rww_enable();
	return;
}
#endif //USE_AVRDFU_BOOTLOADER

//------------ SPECIFIC FONCTION USB TRANSFER -----------------------------------------

//** If your device transfer have a specific transfer for USB (Particularity of Chejudo product, or bootloader)
// !!! In this case the driver must be know the USB access

//! This fonction transfer the memory data (programed in scsi_read_10) directly to the usb interface
//!
//! @return                Ctrl_status
//!   It is ready    ->    CTRL_GOOD
//!
Ctrl_status avrf_usb_read()
{
   return CTRL_GOOD;
}


//! This fonction transfer the usb data (programed in scsi_write_10) directly to the memory data
//!
//! @return                Ctrl_status
//!   It is ready    ->    CTRL_GOOD
//!
Ctrl_status avrf_usb_write( void )
{
   return CTRL_GOOD;
}

/** @} */