df_mem.h File Reference

#include "conf/conf_access.h"
#include "modules/control_access/ctrl_status.h"

Include dependency graph for df_mem.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	df_mem_init (void)
	This function initializes the hw/sw ressources required to drive the DF.
Ctrl_status	df_test_unit_ready (void)
	This function tests the state of the DF memory.
Ctrl_status	df_read_capacity (U32 _MEM_TYPE_SLOW_ *u32_nb_sector)
Bool	df_wr_protect (void)
	This function returns the write protected status of the memory.
Bool	df_removal (void)
	This function tells if the memory has been removed or not.
Ctrl_status	df_read_10 (U32 addr, U16 nb_sector)
	This function performs a read operation of n sectors from a given address to USB.
Ctrl_status	df_write_10 (U32 addr, U16 nb_sector)
	This function performs a write operation of n sectors to a given address from USB.
Ctrl_status	df_host_write_10 (U32 addr, U16 nb_sector)
	This fonction initialise the memory for a write operation in usb host mode.
Ctrl_status	df_host_read_10 (U32 addr, U16 nb_sector)
	This fonction initialise the memory for a read operation in usb host mode.
Ctrl_status	df_ram_2_df (U32 addr, U8 *ram)
	This function performs a write operation of 1 sector to a given address from RAM buffer.
Ctrl_status	df_df_2_ram (U32 addr, U8 *ram)
	This function performs a read operation of 1 sector from a given address to RAM buffer.

---

Detailed Description

This file contains the interface routines of Data Flash memory.

• 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_mem.h.

---

Function Documentation

void df_mem_init

(

void

)

This function initializes the hw/sw ressources required to drive the DF.

Definition at line 61 of file df_mem.c.

References df_init().

{
   df_init();        // Init the DF driver and its communication link.
}

Here is the call graph for this function:

Ctrl_status df_test_unit_ready

(

void

)

This function tests the state of the DF memory.

Returns:

Ctrl_status It is ready -> CTRL_GOOD Not initialize -> CTRL_BUSY Else -> CTRL_NO_PRESENT

Definition at line 74 of file df_mem.c.

References CTRL_BUSY, CTRL_GOOD, CTRL_NO_PRESENT, df_mem_check(), g_b_df_protected, g_b_df_protected_last, and OK.

{
   if( g_b_df_protected != g_b_df_protected_last )
   {
      g_b_df_protected_last = g_b_df_protected;
      return CTRL_BUSY;
   }
   return( (OK==df_mem_check()) ? CTRL_GOOD : CTRL_NO_PRESENT);
}

Here is the call graph for this function:

Ctrl_status df_read_capacity

(

U32 _MEM_TYPE_SLOW_ *

u32_nb_sector

)

This function gives the address of the last valid sector.

Parameters:

*u32_nb_sector

number of sector (sector = 512B)

Returns:

Ctrl_status It is ready -> CTRL_GOOD Not initialize -> CTRL_BUSY Else -> CTRL_NO_PRESENT

Definition at line 94 of file df_mem.c.

References DF_NB_MEM, and df_test_unit_ready().

{
#ifdef DF_4_MB              // AT45DB321 memories
   *u32_nb_sector = ((DF_NB_MEM*4*1024L*1024L)/512)-1;
#endif
#ifdef DF_8_MB              // AT45DB642 memories
   *u32_nb_sector = ((DF_NB_MEM*8*1024L*1024L)/512)-1;
#endif
   return df_test_unit_ready();
}

Here is the call graph for this function:

Bool df_wr_protect

(

void

)

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.

Returns:

FALSE, the memory is not write-protected

Definition at line 114 of file df_mem.c.

References g_b_df_protected.

{
   return g_b_df_protected;
}

Bool df_removal

(

void

)

This function tells if the memory has been removed or not.

Returns:

FALSE, The memory isn't removed

Definition at line 124 of file df_mem.c.

References FALSE.

{
   return FALSE;
}

Ctrl_status df_read_10	(	U32	addr,
		U16	nb_sector
	)

This function performs a read operation of n sectors from a given address to USB.

Parameters:

	addr	Sector address to start the read from
	nb_sector	Number of sectors to transfer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL

Definition at line 142 of file df_mem.c.

References CTRL_FAIL, CTRL_GOOD, df_read_close(), df_read_open(), df_read_sector(), KO, LSB0, and OK.

{
   U8 status = OK;
#if   (DF_NB_MEM == 1)     // 1 DATAFLASH
   df_read_open(addr);                    // wait device is not busy, then send command & address
   status = df_read_sector(nb_sector);             // transfer data from memory to USB
   
#else                      // 2 or 4 DATAFLASH
   U32   next_sector_addr = addr;
   U16   nb_sectors_remaining = nb_sector;
   
   #ifdef DF_4_MB             // 512B PAGES
   while( (nb_sectors_remaining != 0) && (status == OK))
   {
      df_read_open(next_sector_addr);     // wait device is not busy, then send command & address
      status = df_read_sector(1);                  // transfer the page from memory to USB
      df_read_close();
      nb_sectors_remaining--;
      next_sector_addr++;
   }
   #else                      // 1024B PAGES
   while( (nb_sectors_remaining != 0) && (status == OK))
   {
      df_read_open(next_sector_addr);     // wait device is not busy, then send command & address
      if ((LSB0(next_sector_addr)&0x01) == 0)
      {
        if (nb_sectors_remaining == 1)
        {
           status = df_read_sector(1);
           df_read_close();
           nb_sectors_remaining--;
           next_sector_addr++;
        }
        else
        {
          status = df_read_sector(2);
          df_read_close();
          nb_sectors_remaining -= 2;
          next_sector_addr += 2;
        }
      }
      else
      {
        status = df_read_sector(1);
        df_read_close();
        nb_sectors_remaining--;
        next_sector_addr++;
      }
   }
   #endif
#endif
   
   df_read_close();
   if(status == KO)
      return CTRL_FAIL;
   return CTRL_GOOD;
}

Here is the call graph for this function:

Ctrl_status df_write_10	(	U32	addr,
		U16	nb_sector
	)

This function performs a write operation of n sectors to a given address from USB.

Parameters:

	addr	Sector address to start write
	nb_sector	Number of sectors to transfer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL

Definition at line 210 of file df_mem.c.

References CTRL_FAIL, CTRL_GOOD, df_mem_init(), df_write_close(), df_write_open(), df_write_sector(), g_b_df_protected, KO, and LSB0.

{
#if   (DF_NB_MEM != 1)                 // if more than 1 memory, variables are needed for zones mangement
   U32   next_sector_addr = addr;
   U16   nb_sectors_remaining = nb_sector;
#endif

   if( g_b_df_protected ) return CTRL_FAIL;

#if      (DF_NB_MEM == 1)  /* 1 DATAFLASH */
   df_write_open(addr);                    // wait device is not busy, then send command & address
   if( KO == df_write_sector(nb_sector) )  // transfer data from memory to USB
   {
      df_mem_init();
      return CTRL_FAIL;
   }
#else                      /* 2 or 4 DATAFLASH */
   #ifdef DF_4_MB       // 512B PAGES
   while (nb_sectors_remaining != 0)
   {
      df_write_open(next_sector_addr);     // wait device is not busy, then send command & address
      if( KO == df_write_sector(1))        // transfer the page from memory to USB
      {
         df_mem_init();
         return CTRL_FAIL;
      }
      df_write_close();
      nb_sectors_remaining--;
      next_sector_addr++;
   }
   #else                // 1024B PAGES
   while (nb_sectors_remaining != 0)
   {
      df_write_open(next_sector_addr);     // wait device is not busy, then send command & address
      if ((LSB0(next_sector_addr)&0x01) == 0)
      {
        if (nb_sectors_remaining == 1)
        {
          if( KO == df_write_sector(1))    // transfer the page from memory to USB
          {
             df_mem_init();
             return CTRL_FAIL;
          }
          df_write_close();
          nb_sectors_remaining--;
          next_sector_addr++;
        }
        else
        {
          if( KO == df_write_sector(2))    // transfer the page from memory to USB
          {
             df_mem_init();
             return CTRL_FAIL;
          }
          df_write_close();
          nb_sectors_remaining -= 2;
          next_sector_addr += 2;
        }
      }
      else
      {
        if( KO == df_write_sector(1))      // transfer the page from memory to USB
        {
           df_mem_init();
           return CTRL_FAIL;
        }
        df_write_close();
        nb_sectors_remaining--;
        next_sector_addr++;
      }
   }
   #endif
#endif
   df_write_close();                    // unselect memory
   return CTRL_GOOD;
}

Here is the call graph for this function:

Ctrl_status df_host_write_10	(	U32	addr,
		U16	nb_sector
	)

This fonction initialise the memory for a write operation in usb host mode.

DATA FLOW is: DF => USB

(sector = 512B)

Parameters:

	addr	Sector address to start write
	nb_sector	Number of sectors to transfer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL Write_10 in host mode means reading the DF

Definition at line 305 of file df_mem.c.

{
#if   (DF_NB_MEM != 1)                 // if more than 1 memory, variables are needed for zones mangement
   U32   next_sector_addr = addr;
   U16   nb_sectors_remaining = nb_sector;
#endif

#if   (DF_NB_MEM == 1)     /* 1 DATAFLASH */
   df_read_open(addr);                    // wait device is not busy, then send command & address
   df_host_read_sector(nb_sector);             // transfer data from memory to USB
#else                      /* 2 or 4 DATAFLASH */
   #ifdef DF_4_MB             // 512B PAGES
   while (nb_sectors_remaining != 0)
   {
      df_read_open(next_sector_addr);     // wait device is not busy, then send command & address
      df_host_read_sector(1);                  // transfer the page from memory to USB
      df_read_close();
      nb_sectors_remaining--;
      next_sector_addr++;
   }
   #else                      // 1024B PAGES
   while (nb_sectors_remaining != 0)
   {
      df_read_open(next_sector_addr);     // wait device is not busy, then send command & address
      if ((LSB0(next_sector_addr)&0x01) == 0)
      {
        if (nb_sectors_remaining == 1)
        {
           df_host_read_sector(1);
           df_read_close();
           nb_sectors_remaining--;
           next_sector_addr++;
        }
        else
        {
          df_host_read_sector(2);
          df_read_close();
          nb_sectors_remaining -= 2;
          next_sector_addr += 2;
        }
      }
      else
      {
        df_host_read_sector(1);
        df_read_close();
        nb_sectors_remaining--;
        next_sector_addr++;
      }
   }
   #endif
#endif
   df_read_close();                    // unselect memory
   return CTRL_GOOD;
}

Ctrl_status df_host_read_10	(	U32	addr,
		U16	nb_sector
	)

This fonction initialise the memory for a read operation in usb host mode.

DATA FLOW is: USB => DF

(sector = 512B)

Parameters:

	addr	Sector address to start write
	nb_sector	Number of sectors to transfer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL Read_10 in host mode means writing the DF

Definition at line 374 of file df_mem.c.

References CTRL_GOOD, df_host_write_sector(), df_write_close(), df_write_open(), and LSB0.

{
#if   (DF_NB_MEM != 1)                 // if more than 1 memory, variables are needed for zones mangement
   U32   next_sector_addr = addr;
   U16   nb_sectors_remaining = nb_sector;
#endif

#if      (DF_NB_MEM == 1)  /* 1 DATAFLASH */
   df_write_open(addr);                    // wait device is not busy, then send command & address
   df_host_write_sector(nb_sector);             // transfer data from memory to USB
#else                      /* 2 or 4 DATAFLASH */
   #ifdef DF_4_MB       // 512B PAGES
   while (nb_sectors_remaining != 0)
   {
      df_write_open(next_sector_addr);     // wait device is not busy, then send command & address
      df_host_write_sector(1);                  // transfer the page from memory to USB
      df_write_close();
      nb_sectors_remaining--;
      next_sector_addr++;
   }
   #else                // 1024B PAGES
   while (nb_sectors_remaining != 0)
   {
      df_write_open(next_sector_addr);     // wait device is not busy, then send command & address
      if ((LSB0(next_sector_addr)&0x01) == 0)
      {
        if (nb_sectors_remaining == 1)
        {
          df_host_write_sector(1);
          df_write_close();
          nb_sectors_remaining--;
          next_sector_addr++;
        }
        else
        {
          df_host_write_sector(2);
          df_write_close();
          nb_sectors_remaining -= 2;
          next_sector_addr += 2;
        }
      }
      else
      {
        df_host_write_sector(1);
        df_write_close();
        nb_sectors_remaining--;
        next_sector_addr++;
      }
   }
   #endif
#endif
   df_write_close();                    // unselect memory
   return CTRL_GOOD;
}

Here is the call graph for this function:

Ctrl_status df_ram_2_df	(	U32	addr,
		U8 *	ram
	)

This function performs a write operation of 1 sector to a given address from RAM buffer.

Parameters:

	addr	Sector address to write
	ram	Ram buffer pointer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL

Definition at line 461 of file df_mem.c.

References CTRL_GOOD, df_write_close(), df_write_open(), and df_write_sector_from_ram().

{
   df_write_open(addr);
   df_write_sector_from_ram(ram);
   df_write_close();
   return CTRL_GOOD;
}

Here is the call graph for this function:

Ctrl_status df_df_2_ram	(	U32	addr,
		U8 *	ram
	)

This function performs a read operation of 1 sector from a given address to RAM buffer.

Parameters:

	addr	Sector address to read
	ram	Ram buffer pointer

Returns:

Ctrl_status It is ready -> CTRL_GOOD A error occur -> CTRL_FAIL

Definition at line 443 of file df_mem.c.

References CTRL_GOOD, df_read_close(), df_read_open(), and df_read_sector_2_ram().

{
   df_read_open(addr);
   df_read_sector_2_ram(ram);
   df_read_close();
   return CTRL_GOOD;
}

Here is the call graph for this function:

---