df.c File Reference

#include "config.h"
#include "lib_mcu/usb/usb_drv.h"
#include "lib_mcu/spi/spi_drv.h"
#include "df.h"

Include dependency graph for df.c:

Go to the source code of this file.

Functions
static void	df_wait_busy (void)
	This function waits until the DataFlash is not busy.
static void	df_chipselect_current (void)
	This function physically selects the current addressed memory.
void	df_init (void)
	This function initializes the SPI bus over which the DF is controlled.
static void	df_chipselect_memzone (U8 memzone)
	This function selects a DF memory according to the sector pointer.
static U32	df_translate_addr (Uint32 log_sect_addr)
	This function translates the logical sector address to the physical byte address (1 logical sector = 512 bytes) In function of the memory configuration (number 1x/2x/4x, pages 512b/1024b) :.
Bool	df_mem_check (void)
	This function performs a memory check on all DF.
Bool	df_read_open (Uint32 pos)
	This function opens a DF memory in read mode at a given sector address.
void	df_read_close (void)
	This function unselects the current DF memory.
Bool	df_read_sector (Uint16 nb_sector)
	This function is optimized and writes nb-sector * 512 Bytes from DataFlash memory to USB controller.
Bool	df_write_open (Uint32 pos)
	This function opens a DF memory in write mode at a given sector address.
void	df_write_close (void)
	This function fills the end of the logical sector (512B) and launch page programming.
Bool	df_write_sector (Uint16 nb_sector)
	This function is optimized and writes nb-sector * 512 Bytes from USB controller to DataFlash memory.
bit	df_host_write_sector (Uint16 nb_sector)
	Funtions to link USB HOST flow with data flash.
bit	df_host_read_sector (Uint16 nb_sector)
Bool	df_read_sector_2_ram (U8 *ram)
	This function read one DF sector and load it into a ram buffer.
Bool	df_write_sector_from_ram (U8 *ram)
	This function write one DF sector from a ram buffer.
Variables
static U32	gl_ptr_mem
static U8	df_mem_busy
static U8	df_select

---

Detailed Description

This file contains the low-level dataflash routines - Compiler: IAR EWAVR and GNU GCC for AVR

• Supported devices: AT90USB1287, AT90USB1286, AT90USB647, AT90USB646

  Author:

  Atmel Corporation: http://www.atmel.com
  Support and FAQ: http://support.atmel.no/

Definition in file df.c.

---

Function Documentation

static void df_wait_busy

(

void

)

[static]

This function waits until the DataFlash is not busy.

Definition at line 222 of file df.c.

References df_chipselect_current(), Df_desel_all, DF_MEM_BUSY, DF_MSK_BIT_BUSY, DF_RD_STATUS, Spi_ack_write, Spi_read_data, and Spi_write_data.

Referenced by df_read_open(), and df_write_open().

{
   // Read the status register until the DataFlash is not busy.
   df_chipselect_current();
   Spi_write_data(DF_RD_STATUS); // Send the read status register cmd
                                 // + 1st step to clear the SPIF bit
   Spi_write_data(0);            // dummy write that:
                                 // - finalize the clear of the SPIF bit (access to SPDR)
                                 // - get status register
                                 // - does the 1st step to clear the SPIF bit
   // Following Spi_read_data() finalize the clear of SPIF by accessing SPDR
   while ((Spi_read_data() & DF_MSK_BIT_BUSY) == DF_MEM_BUSY)
   {
      Spi_write_data(0);         // dummy write to get new status
                                 // + 1st step to clear the SPIF bit
   }
   Df_desel_all();               // unselect memory to leave STATUS request mode
   Spi_ack_write();              // Final step to clear the SPIF bit.
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void df_chipselect_current

(

void

)

[static]

This function physically selects the current addressed memory.

Definition at line 112 of file df.c.

References Df_desel_all, df_select, Df_select_0, and Df_select_1.

Referenced by df_mem_check(), df_read_open(), df_wait_busy(), and df_write_open().

{
   Df_desel_all();
   switch (df_select)
   {
      case 0:
      Df_select_0();
      break;
#if (DF_NB_MEM > 1)
      case 1:
      Df_select_1();
      break;
#endif
#if (DF_NB_MEM > 2)
      case 2:
      Df_select_2();
      break;
      case 3:
      Df_select_3();
      break;
#endif
   }
}

Here is the caller graph for this function:

void df_init

(

void

)

This function initializes the SPI bus over which the DF is controlled.

Definition at line 64 of file df.c.

Referenced by df_mem_init().

{
   // Init the SPI communication link between the DF and the DF driver.
   Df_init_spi();
   Spi_select_master();
   Spi_set_mode(SPI_MODE_3);
   Spi_init_bus();
   Spi_set_rate(SPI_RATE_0);  // SCK freq == fosc/2.
   Spi_disable_ss();
   Spi_enable();

   // Data Flash Controller init.
   df_mem_busy = 0;           // all memories ready
   df_select = 0;
}

Here is the caller graph for this function:

static void df_chipselect_memzone

(

U8

memzone

)

[static]

This function selects a DF memory according to the sector pointer.

//! The "df_select" variable contains the current memory addressed
//! Refer to the documentation of the function df_translate_addr() for more information about zones management
//! 

Definition at line 88 of file df.c.

References df_select.

Referenced by df_read_open(), and df_write_open().

{
#if (DF_NB_MEM == 1)
   df_select = 0;
#else
   #if (DF_NB_MEM == 2)
      #if (DF_PAGE_SIZE == 512)
   df_select = (memzone>>0)&0x01;
      #else
   df_select = (memzone>>1)&0x01;
      #endif
   #else
      #if (DF_PAGE_SIZE == 512)
   df_select = (memzone>>0)&0x03;
      #else
   df_select = (memzone>>1)&0x03;
      #endif
   #endif
#endif
}

Here is the caller graph for this function:

static U32 df_translate_addr

(

Uint32

log_sect_addr

)

[static]

This function translates the logical sector address to the physical byte address (1 logical sector = 512 bytes) In function of the memory configuration (number 1x/2x/4x, pages 512b/1024b) :.

MEMORIES WITH PAGES OF 512 BYTES : ================================== Consider the logical sector address as "xx..xxba", where 'b' and 'a' are the two last bits, and "xx..xx" an undefined number of more significant bits

• If 1 memory is used, this logical sector address directly matches with the physical sector address So the physical sector address is "xx..xxba"
• If 2 memories are used, the bit 'a' indicates the memory concerned, and the rest of the address indicates the physical address So the physical sector address is "xx...xxb"
• If 4 memories are used, the bits 'ba' indicates the memory concerned, and the rest of the address indicates the physical address So the physical sector address is "xx....xx"

MEMORIES WITH PAGES OF 1024 BYTES : ================================== Consider the logical sector address as "xx..xxcba", where 'c', 'b' and 'a' are the three last bits, and "xx..xx" an undefined number of more significant bits

• If 1 memory is used, this logical sector address directly matches with the physical sector address So the physical sector address is "xx..xxcba"
• If 2 memories are used, the bit 'b' indicates the memory concerned, and the rest of the address indicates the physical address So the physical sector address is "xx...xxca"
• If 4 memories are used, the bits 'cb' indicates the memory concerned, and the rest of the address indicates the physical address So the physical sector address is "xx....xxa"

Parameters:

log_sect_addr

logical sector address

Returns:

U32 physical byte address

Definition at line 165 of file df.c.

Referenced by df_read_open(), and df_write_open().

{
#if (DF_NB_MEM == 1)
   return (log_sect_addr << 9);  // this case if only one memory...
#else
   #if (DF_NB_MEM == 2)
      #if (DF_PAGE_SIZE == 512)
   return ((log_sect_addr&0xFFFFFFFE) << 8);
      #else
   return (((log_sect_addr&0xFFFFFFFC) << 8) | ((log_sect_addr&0x00000001) << 9));
      #endif
   #else
      #if (DF_PAGE_SIZE == 512)
   return ((log_sect_addr&0xFFFFFFFC) << 7);
      #else
   return (((log_sect_addr&0xFFFFFFF8) << 7) | ((log_sect_addr&0x00000001) << 9));
      #endif
   #endif
#endif
}

Here is the caller graph for this function:

Bool df_mem_check

(

void

)

This function performs a memory check on all DF.

Returns:

bit The memory is ready -> OK The memory check failed -> KO

Definition at line 194 of file df.c.

Referenced by df_test_unit_ready().

{
   // DF memory check.
   for(df_select=0; df_select<DF_NB_MEM; df_select++)
   {
      df_chipselect_current();
      Spi_write_data(DF_RD_STATUS); // Send the read status register cmd
                                    // + 1st step to clear the SPIF bit
      Spi_write_data(0);            // dummy write that:
                                    // - finalize the clear of the SPIF bit (access to SPDR)
                                    // - get status register
                                    // - does the 1st step to clear the SPIF bit 
      // Following Spi_read_data() finalize the clear of SPIF by accessing SPDR.
      // Check the DF density.
      if ((Spi_read_data() & DF_MSK_DENSITY) != DF_DENSITY)
      {   
        // Unexpected value.
        Df_desel_all();
        return (KO);
      }
      Df_desel_all();
   }
   return OK;
}

Here is the caller graph for this function:

Bool df_read_open

(

Uint32

pos

)

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).

Parameters:

pos

Logical sector address

Returns:

bit The open succeeded -> OK

Definition at line 252 of file df.c.

Referenced by df_df_2_ram(), df_host_read_sector(), df_read_10(), and df_read_sector().

{
   // Set the global memory ptr at a Byte address.
   gl_ptr_mem = df_translate_addr(pos);
   
   // Select the DF that memory "pos" points to (the "df_select" variable will be updated)
   df_chipselect_memzone(LSB0(pos));
   
   // If the DF memory is busy, wait until it's not.
   if (is_df_busy(df_select))
   {
    df_release_busy(df_select);
    df_wait_busy();                              // wait end of programming
   }
   
   // Physically assert the selected dataflash
   df_chipselect_current();
   
   //#
   //# Initiate a page read at a given sector address.
   //#
   // Send read main command, + first step to clear the SPIF bit
   Spi_write_data(DF_RD_MAIN);
   // Final step to clear the SPIF bit will be done on the next write
   
   // Send the three address Bytes made of:
   // - the page-address(first xbits),
   // - the Byte-address within the page(last ybits).
   // (x and y depending on the DF type).
   // NOTE: the bits of gl_ptr_mem above the 24bits are not useful for the local
   // DF addressing. They are used for DF discrimination when there are several
   // DFs.
   Spi_write_data((MSB1(gl_ptr_mem) << DF_SHFT_B1) | (MSB2(gl_ptr_mem) >> DF_SHFT_B2));
   Spi_write_data(((MSB2(gl_ptr_mem) & ~DF_PAGE_MASK) << DF_SHFT_B1) | (MSB2(gl_ptr_mem) & DF_PAGE_MASK));
   Spi_write_data(MSB3(gl_ptr_mem));
   // Final step to clear the SPIF bit will be done on the next write
   
   // 4 dummy writes for reading delay
   Spi_write_data(0xFF);
   Spi_write_data(0xFF);
   Spi_write_data(0xFF);
   Spi_write_data(0xFF); // Tx 0xFF, first step to clear the SPIF bit
   Spi_ack_write();      // Final step to clear the SPIF bit.
   
   return OK;
}

Here is the caller graph for this function:

void df_read_close

(

void

)

This function unselects the current DF memory.

Definition at line 302 of file df.c.

Referenced by df_df_2_ram(), and df_read_10().

{
  Df_desel_all();   // Unselect memory
}

Here is the caller graph for this function:

Bool df_read_sector

(

Uint16

nb_sector

)

This function is optimized and writes nb-sector * 512 Bytes from DataFlash memory to USB controller.

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.

Parameters:

nb_sector

number of contiguous sectors to read [IN]

Returns:

The read succeeded -> OK

Definition at line 323 of file df.c.

Referenced by df_read_10().

{
   U8 i;
#ifdef DF_CODE_SIZE_OPTIMIZATION   
   U8 j;
#endif
   do
   {
      for (i = 8; i != 0; i--)
      {
         Disable_interrupt();    // Global disable.
         
         // Principle: send any Byte to get a Byte.
         // Spi_write_data(0): send any Byte + 1st step to clear the SPIF bit.
         // Spi_read_data(): get the Byte + final step to clear the SPIF bit.         
#ifdef DF_CODE_SIZE_OPTIMIZATION
         for(j=0;j<64;j++)
         {
            Spi_write_data(0); Usb_write_byte(Spi_read_data());
         }
#else         
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
         Spi_write_data(0); Usb_write_byte(Spi_read_data());
#endif
         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)
         {
            if(!Is_usb_endpoint_enabled())
               return KO; // USB Reset
         }         
      }
      gl_ptr_mem += 512;         // increment global address pointer
      nb_sector--;               // 1 more sector read
      #if (DF_NB_MEM == 1)       // end of page ?
         #if (DF_PAGE_SIZE == 512)
            Df_desel_all();
            if (nb_sector != 0)
              df_read_open(gl_ptr_mem>>9);
         #else
            if ((MSB2(gl_ptr_mem) & DF_PAGE_MASK) == 0x00)
            {
               Df_desel_all();
               if (nb_sector != 0)
                 df_read_open(gl_ptr_mem>>9);
            }
         #endif
      #endif
   }
   while (nb_sector != 0);

   return OK;
}

Here is the caller graph for this function:

Bool df_write_open

(

Uint32

pos

)

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.

Parameters:

pos

Sector address

Returns:

The open succeeded -> OK

Definition at line 452 of file df.c.

Referenced by df_host_read_10(), df_host_write_sector(), df_ram_2_df(), df_write_10(), and df_write_sector().

{
   // Set the global memory ptr at a Byte address.
   gl_ptr_mem = df_translate_addr(pos);
   
   // Select the DF that memory "pos" points to
   df_chipselect_memzone(LSB0(pos));
   
   // If the DF memory is busy, wait until it's not.
   if (is_df_busy(df_select))
   {
    df_release_busy(df_select);
    df_wait_busy();                              // wait end of programming
   }
   
#if DF_PAGE_SIZE > 512
   // Physically assert the selected dataflash
   df_chipselect_current();
   
   //#
   //# Transfer the current page content in buffer1.
   //#
   // Send Main Mem page to Buffer1 command, + first step to clear the SPIF bit
   Spi_write_data(DF_TF_BUF_1);
   // Final step to clear the SPIF bit will be done on the next write
   
   // Send the three address Bytes made of:
   // - the page-address(first xbits),
   // - remaining don't care bits(last ybits).
   // (x and y depending on the DF type).
   // NOTE: the bits of gl_ptr_mem above the 24bits are not useful for the local
   // DF addressing. They are used for DF discrimination when there are several
   // DFs.
   Spi_write_data((MSB1(gl_ptr_mem) << DF_SHFT_B1) | (MSB2(gl_ptr_mem) >> DF_SHFT_B2));
   Spi_write_data(MSB2(gl_ptr_mem) << DF_SHFT_B1);
   Spi_write_data(0);       // Remaining don't care bits.
   Spi_ack_write();         // Final step to clear the SPIF bit.
   
   Df_desel_all();          // Unselect memory to validate the command
   
   df_wait_busy();               // Wait end of page transfer
#endif
   
   // Physically assert the selected dataflash
   df_chipselect_current();
   
   //#
   //# Initiate a page write at a given sector address.
   //#
   // Send Main Memory Page Program Through Buffer1 command,
   // + first step to clear the SPIF bit
   Spi_write_data(DF_PG_BUF_1);
   // Final step to clear the SPIF bit will be done on the next write
   
   // Send the three address Bytes made of:
   //  (.) the page-address(first xbits),
   //  (.) the Byte-address within the page(last ybits).
   // (x and y depending on the DF type).
   // NOTE: the bits of gl_ptr_mem above the 24bits are not useful for the local
   // DF addressing. They are used for DF discrimination when there are several
   // DFs.
   Spi_write_data((MSB1(gl_ptr_mem) << DF_SHFT_B1) | (MSB2(gl_ptr_mem) >> DF_SHFT_B2));
   Spi_write_data(((MSB2(gl_ptr_mem) & ~DF_PAGE_MASK) << DF_SHFT_B1) | (MSB2(gl_ptr_mem) & DF_PAGE_MASK));
   Spi_write_data(MSB3(gl_ptr_mem));
   Spi_ack_write();         // Final step to clear the SPIF bit.
   
   return OK;
}

Here is the caller graph for this function:

void df_write_close

(

void

)

This function fills the end of the logical sector (512B) and launch page programming.

Definition at line 524 of file df.c.

Referenced by df_host_read_10(), df_ram_2_df(), and df_write_10().

{
   //#
   //# While end of logical sector (512B) not reached, zero-fill the remaining
   //# memory Bytes.
   //#
   while ((MSB3(gl_ptr_mem) != 0x00) || ((MSB2(gl_ptr_mem) & 0x01) != 0x00))
   {
      Spi_write_data(0x00);   // - Final step to clear the SPIF bit,
                              // - Write 0x00
                              // - first step to clear the SPIF bit.
      gl_ptr_mem++;
   }
   Spi_ack_write();           // Final step to clear the SPIF bit.
   
   Df_desel_all();            // Launch page programming (or simply unselect memory
                              // if the while loop was not performed).
   df_set_busy(df_select);    // Current memory is busy
}

Here is the caller graph for this function:

Bool df_write_sector

(

Uint16

nb_sector

)

This function is optimized and writes nb-sector * 512 Bytes from USB controller to DataFlash memory.

Funtions to link USB DEVICE flow with data flash.

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.

Parameters:

nb_sector

number of contiguous sectors to write [IN]

Returns:

The write succeeded -> OK

Definition at line 559 of file df.c.

Referenced by df_write_10().

{
   U8 i;
#ifdef DF_CODE_SIZE_OPTIMIZATION   
   U8 j;
#endif
   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())
         {
            if(!Is_usb_endpoint_enabled())
              return KO; // USB Reset
         }
   
         Disable_interrupt();    // Global disable.

         // SPI write principle: send a Byte then clear the SPIF flag.
         // Spi_write_data(Usb_read_byte()): (.) Final step to clear the SPIF bit,
         //                                  (.) send a Byte read from USB,
         //                                  (.) 1st step to clear the SPIF bit.
#ifdef DF_CODE_SIZE_OPTIMIZATION
         for(j=0;j<64;j++)
         {
            Spi_write_data(Usb_read_byte());
         }
#else
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
         Spi_write_data(Usb_read_byte());
#endif
         Spi_ack_write();        // Final step to clear the SPIF bit.
   
         Usb_ack_receive_out();  // USB EPOUT read acknowledgement.
   
         Enable_interrupt();     // Global re-enable.
      } // for (i = 8; i != 0; i--)

      gl_ptr_mem += 512;         // Update the memory pointer.
      nb_sector--;               // 1 more sector written

      //# Launch page programming if end of page.
      //#
      #if DF_PAGE_SIZE > 512
         // Check if end of 1024b page.
         if ((MSB2(gl_ptr_mem) & DF_PAGE_MASK) == 0x00)
         {
            Df_desel_all();               // Launch page programming
            df_set_busy(df_select);       // memory is busy
            #if (DF_NB_MEM == 1)
               if (nb_sector != 0)
                 df_write_open(gl_ptr_mem>>9);
            #endif
         }
      #else
         // Always end of page.
         Df_desel_all();                  // Launch page programming
         df_set_busy(df_select);          // memory is busy
         #if (DF_NB_MEM == 1)
            if (nb_sector != 0)
              df_write_open(gl_ptr_mem>>9);
         #endif
      #endif
   }
   while (nb_sector != 0);

   return OK;                  // Write done
}

Here is the caller graph for this function:

bit df_host_write_sector

(

Uint16

nb_sector

)

Funtions to link USB HOST flow with data flash.

This function is optimized and writes nb-sector * 512 Bytes from USB HOST controller to DataFlash memory DATA FLOW is: USB => DF NOTE:

• This function should be used only when using the USB controller in HOST mode
• 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 PIPE OUT 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)

Parameters:

nb_sector

number of contiguous sectors to write [IN]

Returns:

bit The write succeeded -> OK /

Definition at line 717 of file df.c.

Referenced by df_host_read_10().

{
  Byte i;

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

      Disable_interrupt();    // Global disable.

      // SPI write principle: send a Byte then clear the SPIF flag.
      // Spi_write_data(Usb_read_byte()): (.) Final step to clear the SPIF bit,
      //                                  (.) send a Byte read from USB,
      //                                  (.) 1st step to clear the SPIF bit.
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_write_data(Usb_read_byte());
      Spi_ack_write();        // Final step to clear the SPIF bit.
      Host_ack_in_received();  // USB PIPE IN read acknowledgement.

      Enable_interrupt();     // Global re-enable.
    } // for (i = 8; i != 0; i--)

      gl_ptr_mem += 512;        // Update the memory pointer.
      nb_sector--;              // 1 more sector written

      //# Launch page programming if end of page.
      //#
      #if DF_PAGE_SIZE > 512
         // Check if end of 1024b page.
         if ((MSB2(gl_ptr_mem) & DF_PAGE_MASK) == 0x00)
         {
            Df_desel_all();         // Launch page programming
            df_set_busy(df_select);     // memory is busy
            #if (DF_NB_MEM == 1)
               if (nb_sector != 0)
                 df_write_open(gl_ptr_mem>>9);
            #endif
         }
      #else
         // Always end of page.
         Df_desel_all();           // Launch page programming
         df_set_busy(df_select);     // memory is busy
         #if (DF_NB_MEM == 1)
            if (nb_sector != 0)
              df_write_open(gl_ptr_mem>>9);
         #endif
      #endif
   }
   while (nb_sector != 0);

  return OK;                  // Write done
}

Here is the caller graph for this function:

bit df_host_read_sector

(

Uint16

nb_sector

)

This function is optimized and writes nb-sector * 512 Bytes from DataFlash memory to USB HOST controller DATA FLOW is: DF => USB NOTE:

• This function should ne used only when using the USB controller in HOST mode
• First call must be preceded by a call to the df_read_open() function,
• The USB PIPE IN 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)

Parameters:

nb_sector

number of contiguous sectors to read [IN]

Returns:

bit The read succeeded -> OK /

Definition at line 861 of file df.c.

{
   U8 i;
   do
   {
      for (i = 8; i != 0; i--)
    {
      Disable_interrupt();    // Global disable.

      // Principle: send any Byte to get a Byte.
      // Spi_write_data(0): send any Byte + 1st step to clear the SPIF bit.
      // Spi_read_data(): get the Byte + final step to clear the SPIF bit.
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());
      Spi_write_data(0); Usb_write_byte(Spi_read_data());

      Enable_interrupt();     // Global re-enable.

      //#
      //# Send the USB FIFO IN content to the USB Host.
      //#
      Host_send_out();       // Send the FIFO from the USB Host.
      Host_unfreeze_pipe();
      // Wait until the tx is done so that we may write to the FIFO IN again.
      while(Is_host_out_sent()==FALSE);
      Host_ack_out_sent();
      }
      gl_ptr_mem += 512;      // increment global address pointer
      nb_sector--;            // 1 more sector read
      #if (DF_NB_MEM == 1)    // end of page ?
         #if (DF_PAGE_SIZE == 512)
            Df_desel_all();
            if (nb_sector != 0)
              df_read_open(gl_ptr_mem>>9);
         #else
            if ((MSB2(gl_ptr_mem) & DF_PAGE_MASK) == 0x00)
            {
               Df_desel_all();
               if (nb_sector != 0)
                 df_read_open(gl_ptr_mem>>9);
            }
         #endif
      #endif
   }
   while (nb_sector != 0);

  return OK;   // Read done.
}

Bool df_read_sector_2_ram

(

U8 *

ram

)

This function read one DF sector and load it into a ram buffer.

Functions to read/write one sector (512btes) with ram buffer pointer.

NOTE:

• First call must be preceded by a call to the df_read_open() function,

Parameters:

*ram

pointer to ram buffer

Returns:

The read succeeded -> OK

Definition at line 981 of file df.c.

Referenced by df_df_2_ram().

{
   U16 i;
   for(i=0;i<512;i++)
   {
      Spi_write_data(0);
      *ram=Spi_read_data();
      ram++;
   }
   gl_ptr_mem += 512;     // Update the memory pointer.
   return OK;
}

Here is the caller graph for this function:

Bool df_write_sector_from_ram

(

U8 *

ram

)

This function write one DF sector from a ram buffer.

NOTE:

• First call must be preceded by a call to the df_write_open() function,

Parameters:

*ram

pointer to ram buffer

Returns:

The read succeeded -> OK

Definition at line 1004 of file df.c.

Referenced by df_ram_2_df().

{
   U16 i;
   for(i=0;i<512;i++)
   {
      Spi_write_data(*ram);
      ram++;
   }
   Spi_ack_write();        // Final step to clear the SPIF bit.
   gl_ptr_mem += 512;      // Update the memory pointer.
   return OK;
}

Here is the caller graph for this function:

---

Variable Documentation

U32 gl_ptr_mem [static]

Definition at line 51 of file df.c.

Referenced by df_host_read_sector(), df_host_write_sector(), df_read_open(), df_read_sector(), df_read_sector_2_ram(), df_write_close(), df_write_open(), df_write_sector(), and df_write_sector_from_ram().

U8 df_mem_busy [static]

Definition at line 52 of file df.c.

Referenced by df_init().

U8 df_select [static]

Definition at line 53 of file df.c.

Referenced by df_chipselect_current(), df_chipselect_memzone(), df_host_write_sector(), df_init(), df_mem_check(), df_read_open(), df_write_close(), df_write_open(), and df_write_sector().

---