at45dbx.h File Reference

---

Detailed Description

Management of the AT45DBX data flash controller through SPI.

This file manages the accesses to the AT45DBX data flash components.

• Compiler: IAR EWAVR32 and GNU GCC for AVR32
• Supported devices: All AVR32 devices with an SPI module can be used.
• AppNote:

Author:

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

Definition in file at45dbx.h.

#include "conf_access.h"
#include "spi.h"

Go to the source code of this file.

Defines
#define	AT45DBX_SECTOR_BITS   9
	Number of bits for addresses within sectors.
#define	AT45DBX_SECTOR_SIZE   (1 << AT45DBX_SECTOR_BITS)
	Sector size in bytes.
Available AT45DBX Sizes
Number of address bits of available AT45DBX data flash memories. Note: Only memories with page sizes of at least 512 bytes (sector size) are supported.
#define	AT45DBX_2MB   21
#define	AT45DBX_4MB   22
#define	AT45DBX_8MB   23
Functions
Control Functions
Bool	at45dbx_init (spi_options_t spiOptions, unsigned int pba_hz)
	Initializes the data flash controller and the SPI channel by which the DF is controlled.
Bool	at45dbx_mem_check (void)
	Performs a memory check on all DFs.
void	at45dbx_read_close (void)
	Unselects the current DF memory.
Bool	at45dbx_read_open (U32 sector)
	Opens a DF memory in read mode at a given sector.
void	at45dbx_write_close (void)
	Fills the end of the current logical sector and launches page programming.
Bool	at45dbx_write_open (U32 sector)
	This function opens a DF memory in write mode at a given sector.
Single-Byte Access Functions
U8	at45dbx_read_byte (void)
	Performs a single byte read from DF memory.
Bool	at45dbx_write_byte (U8 b)
	Performs a single byte write to DF memory.
Multiple-Sector Access Functions
Bool	at45dbx_read_multiple_sector (U16 nb_sector)
	Reads nb_sector sectors from DF memory.
void	at45dbx_read_multiple_sector_callback (const void *psector)
	Callback function invoked after each sector read during at45dbx_read_multiple_sector.
Bool	at45dbx_write_multiple_sector (U16 nb_sector)
	Writes nb_sector sectors to DF memory.
void	at45dbx_write_multiple_sector_callback (void *psector)
	Callback function invoked before each sector write during at45dbx_write_multiple_sector.
Single-Sector Access Functions
Bool	at45dbx_read_sector_2_ram (void *ram)
	Reads 1 DF sector to a RAM buffer.
Bool	at45dbx_write_sector_from_ram (const void *ram)
	Writes 1 DF sector from a RAM buffer.

---

Define Documentation

#define AT45DBX_2MB   21

Definition at line 72 of file at45dbx.h.

#define AT45DBX_4MB   22

Definition at line 73 of file at45dbx.h.

#define AT45DBX_8MB   23

Definition at line 74 of file at45dbx.h.

#define AT45DBX_SECTOR_BITS   9

Number of bits for addresses within sectors.

Definition at line 78 of file at45dbx.h.

Referenced by at45dbx_df_2_ram(), at45dbx_ram_2_df(), at45dbx_read_byte(), at45dbx_read_capacity(), at45dbx_read_open(), at45dbx_read_sector_2_ram(), at45dbx_usb_read_10(), at45dbx_usb_write_10(), at45dbx_write_byte(), at45dbx_write_open(), and at45dbx_write_sector_from_ram().

#define AT45DBX_SECTOR_SIZE   (1 << AT45DBX_SECTOR_BITS)

Sector size in bytes.

Definition at line 81 of file at45dbx.h.

Referenced by at45dbx_example_test_RAM_mem(), at45dbx_read_multiple_sector_callback(), at45dbx_read_sector_2_ram(), at45dbx_write_multiple_sector_callback(), and at45dbx_write_sector_from_ram().

---

Function Documentation

Bool at45dbx_init	(	spi_options_t	spiOptions,
		unsigned int	pba_hz
	)

Initializes the data flash controller and the SPI channel by which the DF is controlled.

Parameters:

	spiOptions	Initialization options of the DF SPI channel.
	pba_hz	SPI module input clock frequency (PBA clock, Hz).

Return values:

	OK	Success.
	KO	Failure.

Definition at line 211 of file at45dbx.c.

References at45dbx_busy, AT45DBX_MEM_CNT, AT45DBX_SPI_FIRST_NPCS, spi_options_t::reg, SPI_OK, and spi_setupChipReg().

Referenced by at45dbx_resources_init().

{
  // Setup SPI registers according to spiOptions.
  for (spiOptions.reg = AT45DBX_SPI_FIRST_NPCS;
       spiOptions.reg < AT45DBX_SPI_FIRST_NPCS + AT45DBX_MEM_CNT;
       spiOptions.reg++)
  {
    if (spi_setupChipReg(AT45DBX_SPI, &spiOptions, pba_hz) != SPI_OK) return KO;
  }

  // Memory ready.
  at45dbx_busy = FALSE;

  return OK;
}

Bool at45dbx_mem_check

(

void

)

Performs a memory check on all DFs.

Return values:

	OK	Success.
	KO	Failure.

Definition at line 248 of file at45dbx.c.

References at45dbx_chipselect_df(), AT45DBX_CMDC_RD_STATUS_REG, AT45DBX_MEM_CNT, AT45DBX_MSK_DENSITY, spi_read(), spi_write(), and spi_write_dummy.

Referenced by at45dbx_example_check_mem(), and at45dbx_test_unit_ready().

{
  U8 df;
  U16 status = 0;

  // DF memory check.
  for (df = 0; df < AT45DBX_MEM_CNT; df++)
  {
    // Select the DF memory to check.
    at45dbx_chipselect_df(df, TRUE);

    // Send the Status Register Read command.
    spi_write(AT45DBX_SPI, AT45DBX_CMDC_RD_STATUS_REG);

    // Send a dummy byte to read the status register.
    spi_write_dummy();
    spi_read(AT45DBX_SPI, &status);

    // Unselect the checked DF memory.
    at45dbx_chipselect_df(df, FALSE);

    // Unexpected device density value.
    if ((status & AT45DBX_MSK_DENSITY) < AT45DBX_DENSITY) return KO;
  }

  return OK;
}

U8 at45dbx_read_byte

(

void

)

Performs a single byte read from DF memory.

Returns:

The read byte.

Note:

First call must be preceded by a call to the at45dbx_read_open function.

Definition at line 440 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_BYTE, at45dbx_read_open(), AT45DBX_SECTOR_BITS, gl_ptr_mem, spi_read(), and spi_write_dummy.

Referenced by at45dbx_example_test_byte_mem().

{
  U16 data;

  // Memory busy.
  if (at45dbx_busy)
  {
    // Being here, we know that we previously finished a page read.
    // => We have to access the next page.

    // Memory ready.
    at45dbx_busy = FALSE;

    // Eventually select the next DF and open the next page.
    // NOTE: at45dbx_read_open input parameter is a sector.
    at45dbx_read_open(gl_ptr_mem >> AT45DBX_SECTOR_BITS); // gl_ptr_mem / AT45DBX_SECTOR_SIZE.
  }

  // Send a dummy byte to read the next data byte.
  spi_write_dummy();
  spi_read(AT45DBX_SPI, &data);
  gl_ptr_mem++;

  // If end of page reached,
  if (!Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_BYTE))
  {
    // unselect the DF memory gl_ptr_mem points to.
    at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

    // Memory busy.
    at45dbx_busy = TRUE;
  }

  return data;
}

void at45dbx_read_close

(

void

)

Unselects the current DF memory.

Definition at line 343 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_MEM_SIZE, and gl_ptr_mem.

Referenced by at45dbx_df_2_ram(), at45dbx_example_test_byte_mem(), at45dbx_example_test_multiple_sector(), at45dbx_example_test_RAM_mem(), and at45dbx_usb_read_10().

{
  // Unselect the DF memory gl_ptr_mem points to.
  at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

  // Memory ready.
  at45dbx_busy = FALSE;
}

Bool at45dbx_read_multiple_sector

(

U16

nb_sector

)

Reads nb_sector sectors from DF memory.

Data flow is: DF -> callback.

Parameters:

nb_sector

Number of contiguous sectors to read.

Return values:

	OK	Success.
	KO	Failure.

Note:

First call must be preceded by a call to the at45dbx_read_open function.

As AT45DBX_PAGE_SIZE is always a multiple of AT45DBX_SECTOR_SIZE, there is no need to check page end for each byte.

Definition at line 516 of file at45dbx.c.

References at45dbx_read_multiple_sector_callback(), at45dbx_read_sector_2_ram(), and sector_buf.

Referenced by at45dbx_example_test_multiple_sector(), and at45dbx_usb_read_10().

{
  while (nb_sector--)
  {
    // Read the next sector.
    at45dbx_read_sector_2_ram(sector_buf);
    at45dbx_read_multiple_sector_callback(sector_buf);
  }

  return OK;
}

void at45dbx_read_multiple_sector_callback

(

const void *

psector

)

Callback function invoked after each sector read during at45dbx_read_multiple_sector.

Parameters:

psector

Pointer to read sector.

Definition at line 129 of file at45dbx_mem.c.

References at45dbx_example_error_cnt, AT45DBX_SECTOR_SIZE, and PATTERN_MULTIPLE_SECTOR.

Referenced by at45dbx_read_multiple_sector().

{
  U16 data_to_transfer = AT45DBX_SECTOR_SIZE;

  // Transfer read sector to the USB interface.
  while (data_to_transfer)
  {
    while (!Is_usb_in_ready(g_scsi_ep_ms_in))
    {
      if(!Is_usb_endpoint_enabled(g_scsi_ep_ms_in))
         return; // USB Reset
    }         

    Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_in);
    data_to_transfer = usb_write_ep_txpacket(g_scsi_ep_ms_in, psector,
                                             data_to_transfer, &psector);
    Usb_ack_in_ready_send(g_scsi_ep_ms_in);
  }
}

Bool at45dbx_read_open

(

U32

sector

)

Opens a DF memory in read mode at a given sector.

Parameters:

sector

Start sector.

Return values:

	OK	Success.
	KO	Failure.

Note:

Sector may be page-unaligned (depending on the DF page size).

Definition at line 302 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_CMDA_RD_PAGE, AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_BYTE, AT45DBX_MSK_PTR_PAGE, AT45DBX_SECTOR_BITS, at45dbx_wait_ready(), gl_ptr_mem, spi_write(), and spi_write_dummy.

Referenced by at45dbx_df_2_ram(), at45dbx_example_test_byte_mem(), at45dbx_example_test_multiple_sector(), at45dbx_example_test_RAM_mem(), at45dbx_read_byte(), at45dbx_read_sector_2_ram(), and at45dbx_usb_read_10().

{
  U32 addr;

  // Set the global memory pointer to a byte address.
  gl_ptr_mem = sector << AT45DBX_SECTOR_BITS; // gl_ptr_mem = sector * AT45DBX_SECTOR_SIZE.

  // If the DF memory is busy, wait until it's ready.
  if (at45dbx_busy) at45dbx_wait_ready();
  at45dbx_busy = FALSE;

  // Select the DF memory gl_ptr_mem points to.
  at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, TRUE);

  // Initiate a page read at a given sector.

  // Send the Main Memory Page Read command.
  spi_write(AT45DBX_SPI, AT45DBX_CMDA_RD_PAGE);

  // Send the three address bytes, which comprise:
  //  - (24 - (AT45DBX_PAGE_ADDR_BITS + AT45DBX_BYTE_ADDR_BITS)) reserved bits;
  //  - then AT45DBX_PAGE_ADDR_BITS bits specifying the page in main memory to be read;
  //  - then AT45DBX_BYTE_ADDR_BITS bits specifying the starting byte address within that page.
  // NOTE: The bits of gl_ptr_mem above the AT45DBX_MEM_SIZE bits are useless for the local
  // DF addressing. They are used for DF discrimination when there are several DFs.
  addr = (Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_PAGE) << AT45DBX_BYTE_ADDR_BITS) |
         Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_BYTE);
  spi_write(AT45DBX_SPI, LSB2W(addr));
  spi_write(AT45DBX_SPI, LSB1W(addr));
  spi_write(AT45DBX_SPI, LSB0W(addr));

  // Send 32 don't care clock cycles to initialize the read operation.
  spi_write_dummy();
  spi_write_dummy();
  spi_write_dummy();
  spi_write_dummy();

  return OK;
}

Bool at45dbx_read_sector_2_ram

(

void *

ram

)

Reads 1 DF sector to a RAM buffer.

Data flow is: DF -> RAM.

Parameters:

ram

Pointer to RAM buffer.

Return values:

	OK	Success.
	KO	Failure.

Note:

First call must be preceded by a call to the at45dbx_read_open function.

Definition at line 550 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_BYTE, at45dbx_read_open(), AT45DBX_SECTOR_BITS, AT45DBX_SECTOR_SIZE, gl_ptr_mem, spi_read(), and spi_write_dummy.

Referenced by at45dbx_df_2_ram(), at45dbx_example_test_RAM_mem(), and at45dbx_read_multiple_sector().

{
  U8 *_ram = ram;
  U16 i;
  U16 data;

  // Memory busy.
  if (at45dbx_busy)
  {
    // Being here, we know that we previously finished a page read.
    // => We have to access the next page.

    // Memory ready.
    at45dbx_busy = FALSE;

    // Eventually select the next DF and open the next page.
    // NOTE: at45dbx_read_open input parameter is a sector.
    at45dbx_read_open(gl_ptr_mem >> AT45DBX_SECTOR_BITS); // gl_ptr_mem / AT45DBX_SECTOR_SIZE.
  }

  // Read the next sector.
  for (i = AT45DBX_SECTOR_SIZE; i; i--)
  {
    // Send a dummy byte to read the next data byte.
    spi_write_dummy();
    spi_read(AT45DBX_SPI, &data);
    *_ram++ = data;
  }

  // Update the memory pointer.
  gl_ptr_mem += AT45DBX_SECTOR_SIZE;

#if AT45DBX_PAGE_SIZE > AT45DBX_SECTOR_SIZE
  // If end of page reached,
  if (!Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_BYTE))
#endif
  {
    // unselect the DF memory gl_ptr_mem points to.
    at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

    // Memory busy.
    at45dbx_busy = TRUE;
  }

  return OK;
}

Bool at45dbx_write_byte

(

U8

b

)

Performs a single byte write to DF memory.

Parameters:

b

The byte to write.

Return values:

	OK	Success.
	KO	Failure.

Note:

First call must be preceded by a call to the at45dbx_write_open function.

Definition at line 477 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_BYTE, AT45DBX_SECTOR_BITS, at45dbx_write_open(), gl_ptr_mem, and spi_write().

Referenced by at45dbx_example_test_byte_mem().

{
  // Memory busy.
  if (at45dbx_busy)
  {
    // Being here, we know that we previously launched a page programming.
    // => We have to access the next page.

    // Eventually select the next DF and open the next page.
    // NOTE: at45dbx_write_open input parameter is a sector.
    at45dbx_write_open(gl_ptr_mem >> AT45DBX_SECTOR_BITS); // gl_ptr_mem / AT45DBX_SECTOR_SIZE.
  }

  // Write the next data byte.
  spi_write(AT45DBX_SPI, b);
  gl_ptr_mem++;

  // If end of page reached,
  if (!Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_BYTE))
  {
    // unselect the DF memory gl_ptr_mem points to in order to program the page.
    at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

    // Memory busy.
    at45dbx_busy = TRUE;
  }

  return OK;
}

void at45dbx_write_close

(

void

)

Fills the end of the current logical sector and launches page programming.

Definition at line 415 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_SECTOR, gl_ptr_mem, and spi_write().

Referenced by at45dbx_example_test_byte_mem(), at45dbx_example_test_multiple_sector(), at45dbx_example_test_RAM_mem(), at45dbx_ram_2_df(), and at45dbx_usb_write_10().

{
  // While end of logical sector not reached, zero-fill remaining memory bytes.
  while (Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_SECTOR))
  {
    spi_write(AT45DBX_SPI, 0x00);
    gl_ptr_mem++;
  }

  // Unselect the DF memory gl_ptr_mem points to.
  at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

  // Memory busy.
  at45dbx_busy = TRUE;
}

Bool at45dbx_write_multiple_sector

(

U16

nb_sector

)

Writes nb_sector sectors to DF memory.

Data flow is: callback -> DF.

Parameters:

nb_sector

Number of contiguous sectors to write.

Return values:

	OK	Success.
	KO	Failure.

Note:

First call must be preceded by a call to the at45dbx_write_open function.

As AT45DBX_PAGE_SIZE is always a multiple of AT45DBX_SECTOR_SIZE, there is no need to check page end for each byte.

Definition at line 529 of file at45dbx.c.

References at45dbx_write_multiple_sector_callback(), at45dbx_write_sector_from_ram(), and sector_buf.

Referenced by at45dbx_example_test_multiple_sector(), and at45dbx_usb_write_10().

{
  while (nb_sector--)
  {
    // Write the next sector.
    at45dbx_write_multiple_sector_callback(sector_buf);
    at45dbx_write_sector_from_ram(sector_buf);
  }

  return OK;
}

void at45dbx_write_multiple_sector_callback

(

void *

psector

)

Callback function invoked before each sector write during at45dbx_write_multiple_sector.

Parameters:

psector

Pointer to sector to write.

Definition at line 166 of file at45dbx_mem.c.

References AT45DBX_SECTOR_SIZE, and PATTERN_MULTIPLE_SECTOR.

Referenced by at45dbx_write_multiple_sector().

{
  U16 data_to_transfer = AT45DBX_SECTOR_SIZE;

  // Transfer sector to write from the USB interface.
  while (data_to_transfer)
  {
    while (!Is_usb_out_received(g_scsi_ep_ms_out))
    {
      if(!Is_usb_endpoint_enabled(g_scsi_ep_ms_out))
         return; // USB Reset
    }         

    Usb_reset_endpoint_fifo_access(g_scsi_ep_ms_out);
    data_to_transfer = usb_read_ep_rxpacket(g_scsi_ep_ms_out, psector,
                                            data_to_transfer, &psector);
    Usb_ack_out_received_free(g_scsi_ep_ms_out);
  }
}

Bool at45dbx_write_open

(

U32

sector

)

This function opens a DF memory in write mode at a given sector.

Parameters:

sector

Start sector.

Return values:

	OK	Success.
	KO	Failure.

Note:

Sector may be page-unaligned (depending on the DF page size).

If AT45DBX_PAGE_SIZE > AT45DBX_SECTOR_SIZE, page content is first loaded in buffer to then be partially updated by write byte or write sector functions.

Definition at line 353 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_CMDB_PR_PAGE_TH_BUF1, AT45DBX_CMDB_XFR_PAGE_TO_BUF1, AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_BYTE, AT45DBX_MSK_PTR_PAGE, AT45DBX_SECTOR_BITS, at45dbx_wait_ready(), gl_ptr_mem, and spi_write().

Referenced by at45dbx_example_test_byte_mem(), at45dbx_example_test_multiple_sector(), at45dbx_example_test_RAM_mem(), at45dbx_ram_2_df(), at45dbx_usb_write_10(), at45dbx_write_byte(), and at45dbx_write_sector_from_ram().

{
  U32 addr;

  // Set the global memory pointer to a byte address.
  gl_ptr_mem = sector << AT45DBX_SECTOR_BITS; // gl_ptr_mem = sector * AT45DBX_SECTOR_SIZE.

  // If the DF memory is busy, wait until it's ready.
  if (at45dbx_busy) at45dbx_wait_ready();
  at45dbx_busy = FALSE;

#if AT45DBX_PAGE_SIZE > AT45DBX_SECTOR_SIZE
  // Select the DF memory gl_ptr_mem points to.
  at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, TRUE);

  // Transfer the content of the current page to buffer 1.

  // Send the Main Memory Page to Buffer 1 Transfer command.
  spi_write(AT45DBX_SPI, AT45DBX_CMDB_XFR_PAGE_TO_BUF1);

  // Send the three address bytes, which comprise:
  //  - (24 - (AT45DBX_PAGE_ADDR_BITS + AT45DBX_BYTE_ADDR_BITS)) reserved bits;
  //  - then AT45DBX_PAGE_ADDR_BITS bits specifying the page in main memory to be read;
  //  - then AT45DBX_BYTE_ADDR_BITS don't care bits.
  // NOTE: The bits of gl_ptr_mem above the AT45DBX_MEM_SIZE bits are useless for the local
  // DF addressing. They are used for DF discrimination when there are several DFs.
  addr = Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_PAGE) << AT45DBX_BYTE_ADDR_BITS;
  spi_write(AT45DBX_SPI, LSB2W(addr));
  spi_write(AT45DBX_SPI, LSB1W(addr));
  spi_write(AT45DBX_SPI, LSB0W(addr));

  // Unselect the DF memory gl_ptr_mem points to.
  at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

  // Wait for end of page transfer.
  at45dbx_wait_ready();
#endif

  // Select the DF memory gl_ptr_mem points to.
  at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, TRUE);

  // Initiate a page write at a given sector.

  // Send the Main Memory Page Program through Buffer 1 command.
  spi_write(AT45DBX_SPI, AT45DBX_CMDB_PR_PAGE_TH_BUF1);

  // Send the three address bytes, which comprise:
  //  - (24 - (AT45DBX_PAGE_ADDR_BITS + AT45DBX_BYTE_ADDR_BITS)) reserved bits;
  //  - then AT45DBX_PAGE_ADDR_BITS bits specifying the page in main memory to be written;
  //  - then AT45DBX_BYTE_ADDR_BITS bits specifying the starting byte address within that page.
  // NOTE: The bits of gl_ptr_mem above the AT45DBX_MEM_SIZE bits are useless for the local
  // DF addressing. They are used for DF discrimination when there are several DFs.
  addr = (Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_PAGE) << AT45DBX_BYTE_ADDR_BITS) |
         Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_BYTE);
  spi_write(AT45DBX_SPI, LSB2W(addr));
  spi_write(AT45DBX_SPI, LSB1W(addr));
  spi_write(AT45DBX_SPI, LSB0W(addr));

  return OK;
}

Bool at45dbx_write_sector_from_ram

(

const void *

ram

)

Writes 1 DF sector from a RAM buffer.

Data flow is: RAM -> DF.

Parameters:

ram

Pointer to RAM buffer.

Return values:

	OK	Success.
	KO	Failure.

Note:

First call must be preceded by a call to the at45dbx_write_open function.

Definition at line 598 of file at45dbx.c.

References at45dbx_busy, at45dbx_chipselect_df(), AT45DBX_MEM_SIZE, AT45DBX_MSK_PTR_BYTE, AT45DBX_SECTOR_BITS, AT45DBX_SECTOR_SIZE, at45dbx_write_open(), gl_ptr_mem, and spi_write().

Referenced by at45dbx_example_test_RAM_mem(), at45dbx_ram_2_df(), and at45dbx_write_multiple_sector().

{
  const U8 *_ram = ram;
  U16 i;

  // Memory busy.
  if (at45dbx_busy)
  {
    // Being here, we know that we previously launched a page programming.
    // => We have to access the next page.

    // Eventually select the next DF and open the next page.
    // NOTE: at45dbx_write_open input parameter is a sector.
    at45dbx_write_open(gl_ptr_mem >> AT45DBX_SECTOR_BITS); // gl_ptr_mem / AT45DBX_SECTOR_SIZE.
  }

  // Write the next sector.
  for (i = AT45DBX_SECTOR_SIZE; i; i--)
  {
    // Write the next data byte.
    spi_write(AT45DBX_SPI, *_ram++);
  }

  // Update the memory pointer.
  gl_ptr_mem += AT45DBX_SECTOR_SIZE;

#if AT45DBX_PAGE_SIZE > AT45DBX_SECTOR_SIZE
  // If end of page reached,
  if (!Rd_bitfield(gl_ptr_mem, AT45DBX_MSK_PTR_BYTE))
#endif
  {
    // unselect the DF memory gl_ptr_mem points to in order to program the page.
    at45dbx_chipselect_df(gl_ptr_mem >> AT45DBX_MEM_SIZE, FALSE);

    // Memory busy.
    at45dbx_busy = TRUE;
  }

  return OK;
}