nf.c

MP3播放器详细设计方案

/*C**************************************************************************
* NAME:         nf.c
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-refd-nf-3_0_0      
* REVISION:     1.18     
*----------------------------------------------------------------------------
* PURPOSE:
* This file contains the high level NF routines
*****************************************************************************/
 
/*_____ I N C L U D E S ____________________________________________________*/

#include "config.h"                         /* system configuration */
#include FILE_BOARD_H                       /* board definition */
#include "lib_mcu\usb\usb_drv.h"            /* usb driver definition */
#include "lib_mem\nf\nf.h"                  /* NF definition */


/*_____ M A C R O S ________________________________________________________*/


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

xdata Byte nf_send_cmd At(NF_CMD_LATCH_ENABLE_ADD); /* Command */
xdata Byte nf_send_add At(NF_ADD_LATCH_ENABLE_ADD); /* Address */
xdata Byte volatile nf_data At(NF_ADDRESS_CMD_DATA);/* Data    */

/* Card Identification System definition */
code Byte nf_cis_table[]=
  {
  0x01, 0x03, 0xD9, 0x01, 0xFF, 0x18, 0x02, 0xDF, 0x01, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x21,
  0x02, 0x04, 0x01, 0x22, 0x02, 0x01, 0x01, 0x22, 0x03, 0x02, 0x04, 0x07, 0x1A, 0x05, 0x01, 0x03,
  0x00, 0x02, 0x0F, 0x1B, 0x08, 0xC0, 0xC0, 0xA1, 0x01, 0x55, 0x08, 0x00, 0x20, 0x1B, 0x0A, 0xC1,
  0x41, 0x99, 0x01, 0x55, 0x64, 0xF0, 0xFF, 0xFF, 0x20, 0x1B, 0x0C, 0x82, 0x41, 0x18, 0xEA, 0x61,
  0xF0, 0x01, 0x07, 0xF6, 0x03, 0x01, 0xEE, 0x1B, 0x0C, 0x83, 0x41, 0x18, 0xEA, 0x61, 0x70, 0x01,
  0x07, 0x76, 0x03, 0x01, 0xEE, 0x15, 0x14, 0x05, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
  0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x30, 0x2E, 0x30, 0x00, 0xFF, 0x14, 0x00, 0xFF, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  };


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

extern  data    Uint32  gl_ptr_mem;         /* memory data pointer */
extern  pdata   Byte gl_buffer[];

data  Uint32 nf_current_physical_sector_addr; /* give the address of the current sector */  
data  Uint32 gl_address;                    /* general address variable */
data  Uint16 nf_look_up_table_block;        /* look up table address (block) */
data  Byte nf_zone;                         /* current zone number */
data  Byte nf_gl_buf_idx;
data  Byte gl_buf_free_idx ;

bdata bit nf_block_used;                    /* Set when a block was used */
bdata bit nf_busy;                          /* indicate that nand flash is busy */
bdata bit nf_lut_modified;                  /* indicate that LUT have been modified */

xdata Uint16 nf_logical_block;              /* Current logical block value */
xdata Uint16 nf_lut_block[NF_ZONE_MAX];     /* LUT address (block value) */
xdata Uint16 nf_buf_free[24];               /* contain free physical block address */
xdata Uint16 nf_spare_block;                /* number of free block */
xdata Uint16 nf_block_to_be_deleted;        /* give the address of the next deleted block */
xdata Uint16 nf_block_min;                  /* address of the first block in the buffer */
xdata Uint16 nf_block_max;                  /* address of the last block in the buffer */
xdata Union16 nf_buf[NF_BUFFER_SIZE];       /* Buffer for write operation */
xdata Byte    nf_old_zone;                  /* for zone change */  
xdata Byte    nf_lut_index[NF_ZONE_MAX];    /* give the index for updating LUT */
xdata Byte nf_spare_block_number[NF_ZONE_MAX];/* Number of free spare block in each zone */


idata Byte nf_gl_buf_idx_max;               /* max index for updating LUT */
idata Uint16  gl_cpt_page;                  /* internal page counter (byte access) */

code Uint32 nf_mem_size = NF_DISK_SIZE;


/*F**************************************************************************
* NAME: read_spare_byte
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   read spare data byte and construct the look up table.
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void read_spare_byte(void)
{
Byte byte_5;
Byte byte_6;
Byte lut_is_present;
Uint16 block;
Uint16 j;                       /* counter */
Uint16 i;                       /* counter */
Uint16 start;                   /* start value for the construction of the LUT */
Uint16 end;                     /* final value */
Uint16 free_bloc_pos;
Union16 block2;
bit   block_valid;
Uint32 temp_address;              
xdata Uint16 last_physical_used_block[NF_ZONE_MAX]; /* Last physical block used */

  Nf_CS_ON();
  Nf_wait_busy();
  /* Global media initialization */
  nf_block_min = 0xFFFF;                    /* Starting buffer value */
  nf_gl_buf_idx_max = 0;                    /* Max index in the buffer */
  nf_lut_modified = FALSE;                  /* Buffer change flag */
  nf_gl_buf_idx = 0;                        /* Main buffer index */
  gl_buf_free_idx = 0;                      /* Free physical buffer idx */
  nf_old_zone = 0xFF;                       /* Previous zone number */
  for (i = 0; i < NF_ZONE_MAX; i++)
  {
    nf_lut_index[i] = 0;                    /* LUT index */
  }
  lut_is_present = 0x00;

  /***************************************************/
  /* For each zone, this following lines :           */
  /*   Search bad block                              */
  /*   Determine if a LUT is present                 */
  /*   Determine the last physical block             */ 
  /***************************************************/
  gl_address = 0;                           /* Start from physical sector 0 */
  for (i = 0; i < NF_ZONE_MAX; i++)         /* for each zone */

  {
    nf_spare_block_number[i] = 23;          /* Initialize the spare block table */
    last_physical_used_block[i] = (Uint16)(i) << 10;/* Initialize the last used physical block value */

    for (j = NF_BLOCK_PER_ZONE; j != 0; j--)/* for each block */ 
    {
      Nf_read_open_C_area(gl_address, 0x05);
      if ( Nf_rd_byte() != 0xFF )           /* block status data : valid/invalid block */
      {
        nf_spare_block_number[i]--;         /* Defect block */
      }
      else                                  /* Block is valid */
      {
                                            /* Determine if the block is a specific block */
        byte_6 = Nf_rd_byte();
        if ((byte_6 == 0x00) ||                                /* 0x00 = specific block */
            ((byte_6 != 0xFF) && ((byte_6 & 0xF8) != 0x10) && /* Value in redundant spare area not correct */
            (byte_6 != 0xE8))                /* Don't care about LUT block */
           )
        { 
          nf_spare_block_number[i]--;        /* specific or invalid block */
        }
        else
        {
          /* Determine if the block is the look up table */ 
          if (byte_6 == 0xE8)                 /* look up table ? */
          {
              lut_is_present |= (0x01) << i;
              nf_lut_block[i] = gl_address >> 5;
 
          }
          /* Determine the last physical used block */
          if ((byte_6 & 0xF8) == 0x10)         /* Used block */
          {
            last_physical_used_block[i] = gl_address >> 5;
          }
        }
      }
      gl_address += 32;
    }
  }

  for (i = 0; i < NF_ZONE_MAX; i++)
  { /* Determine the index for each correct lut */
    if ((lut_is_present & (0x01 << i)))
    {
      gl_address = (Uint32)(nf_lut_block[i]) << 5;
      do
      {
        Nf_read_open_C_area(gl_address, 0x06);
        nf_lut_index[i]++;
        gl_address+=4;
      }
      while (Nf_rd_byte() == 0xE8);
      nf_lut_index[i]-=2;
      gl_address = gl_address - 8;
      Nf_read_open_C_area(gl_address, 0x00);
      if (Nf_rd_byte() != 0xFF)             /* LUT has been modified */
      {
        nf_block_erase(gl_address);
        lut_is_present &= ~((0x01) << i);   /* Reset bit */
        nf_lut_index[i] = 0;
        Nf_wait_busy();
      }
    }
  }
  /*****************************************************************/
  /*          Find free physical block for LUT for each zone       */
  /*****************************************************************/
  for (i = 0; i < NF_ZONE_MAX; i++)
  {
    if (!(lut_is_present & (0x01 << i)))
    {
      block = last_physical_used_block[i];
      start = (Uint16)(i) << 10;            /* starting value for each zone */
      if (block == start)                   /* starting block for scan */
      {
        block = start + 1023;
      }
      block_valid = FALSE;                  /* init flag block valid */
      Nf_wait_busy();
      do
      {
        gl_address = (Uint32)(block) << 5;
        Nf_read_open_C_area(gl_address, 0x05);
        byte_5 = Nf_rd_byte();
        byte_6 = Nf_rd_byte();
  
        if ((byte_5 == 0xFF) && (byte_6 == 0xFF)) /* not assigned and valid block */
        {
          block_valid = TRUE;               /* find a correct block */
        }
        else                                /* else decrease block number */
        {
          if (block == start)                       
          {
            block = start + 1023;
          }
          else
          {
            block--;
          }
        }
      }
      while (!block_valid );
  
      nf_lut_block[i] = block;              /* Update look up table address */
    }
  }

  /**********************************************************/
  /* Create the look-up table                               */
  /* Process is done zone per zone and by step of 256 blocks*/
  /* ********************************************************/
  for (nf_zone = 0; nf_zone < NF_ZONE_MAX; nf_zone++)   /* for each zone */
  {
    if (!(lut_is_present & (0x01 << nf_zone)))  /* If not LUT */
    {
      start = 0x00;
      end   = 0x80;     /* 256 bytes for gl_buffer <-> 128 blocks */                            
      free_bloc_pos = (Uint16)(last_physical_used_block[nf_zone]);
      gl_address       = (Uint32)(nf_lut_block[nf_zone]) << 5;        
      do
      {
        nf_init_buffer();                         /* Reinitialize the buffer */
        temp_address = (Uint32)(nf_zone) << 15;   /* We start at the beginning */
        block    = (Uint16)(nf_zone) << 10;
        Nf_wait_busy();
        for (j = NF_BLOCK_PER_ZONE; j != 0 ; j--) /* for each block */
        { 
          Nf_read_open_C_area(temp_address, 0x05);
          byte_5 = Nf_rd_byte();            /* Block status byte */
          if (byte_5 == 0xFF)               /* If not a bad block */
          {
            block2.b[0] = Nf_rd_byte();     /* Read logical block address */
            block2.b[1] = Nf_rd_byte();
            if ((block2.b[0] & 0xF8) == 0x10)
            {
              
              block2.w = (block2.w & 0x0FFF) >> 1;          
              if ((block2.w < end) && (block2.w >= start)) 
              { /* Save logical block value in the buffer */
                gl_buffer[2 * block2.b[1]] = block >> 8;
                gl_buffer[2 * block2.b[1] + 1] = block;
              }
            }
          }
          temp_address += 32; 
          block++;
        }
          
        /* affect to the free physical block a fictive logical block */
        /* free physical block => gl_buffer[x] = 0xFF */
        temp_address = (Uint32)(free_bloc_pos) << 5;
        for (i = 0; i <= 0xFE; i+=2)
        {
          if (gl_buffer[i] == 0xFF)
          {
            do                              /* Search free physical block */
            {
              temp_address += 32;
              if (temp_address >= ((Uint32)(nf_zone + 1) << 15))
                  temp_address = (Uint32)(nf_zone) << 15;
    
              Nf_read_open_C_area(temp_address, 0x05);
              
              byte_5 = Nf_rd_byte();        /* Invalid/Valid block */
              byte_6 = Nf_rd_byte();        /* Used/Unused block */
            }
            while (((byte_6 != 0xFF) && (byte_6 != 0xE8)) || (byte_5 != 0xFF));
  
            free_bloc_pos = temp_address >> 5;
            gl_buffer[i] = (free_bloc_pos >> 8) + 0x80;
            gl_buffer[i + 1] = free_bloc_pos;
          }
        }
    
        /* Write first part of LUT */
        Nf_write_open_A_area(gl_address, 0x00);
      
        /* Write 256 bytes from the buffer */
        nf_download_buffer();
      
        /* Valid the page programmation */
        Nf_send_command(NF_PAGE_PROGRAM_CMD);
    
        nf_init_buffer();                   /* reinitialize the global buffer */
        start    += 0x80;                   /* process next 128 logical block */
        end      += 0x80;
        block    = (Uint16)(nf_zone) << 10;
        temp_address = (Uint32)(nf_zone) << 15; /* restart from the begin of zone */
        Nf_wait_busy();