nf_drv.c

ATMEL 89c51sndc mp3外接硬盘源码

/*C**************************************************************************
* NAME:         nf_drv.c
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-demo-hdd-0_2_0      
* REVISION:     1.1     
*----------------------------------------------------------------------------
* PURPOSE: 
* This file contains the NF driver routines
*
*****************************************************************************/

/*_____ I N C L U D E S ____________________________________________________*/


#include "config.h"                         /* system configuration         */
#include "lib_demob\board.h"                /* board definition */
#include "nf_drv.h"                         /* nf driver definition         */


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




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

                                  

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


extern code   Byte    nf_cis_table[];                 /* CIS table */
extern data   Uint32  gl_ptr_mem;                  /* memory data pointer */

extern pdata  Byte    gl_buffer[];                    /* global buffer of 256 bytes */
extern xdata  Byte    volatile nf_data_odd;               /* Data */
extern xdata  Byte    nf_send_cmd_odd;                    /* Command */
extern xdata  Byte    nf_send_add_odd;                    /* Address */
extern xdata  Byte    volatile nf_data_even;               /* Data */
extern xdata  Byte    nf_send_cmd_even;                    /* Command */
extern xdata  Byte    nf_send_add_even;                    /* Address */

extern bdata  bit     rx_bank;
extern bdata  bit     nf_busy;
extern bdata  bit     nf_parity_bit;

extern data   Uint32  gl_address;                        /* general address variable                   */
extern data   Uint32  nf_current_physical_sector_addr_odd;   /* give the address of the current sector in odd nf    */ 
extern data   Uint32  nf_current_physical_sector_addr_even;   /* give the address of the current sector in even nf    */ 

extern idata  Byte    nf_gl_buf_free_idx ;
extern idata  Byte    nf_zone;
extern idata  Byte    nf_gl_buf_idx_max;
extern idata  Uint16  nf_look_up_table_block;            /* Look up table block address  */
extern idata  Uint16  nf_logical_block;
extern idata  Uint16  nf_block_to_be_deleted_odd;
extern idata  Uint16  nf_block_to_be_deleted_even;
extern idata  Uint16  block_min;
extern idata  Byte    nf_spare_block;

extern xdata  Uint16 lut_block[NF_ZONE_MAX];    /* LUT address in block value */
extern xdata  t_lut buf[NF_BUFFER_SIZE];                   /* Buffer for write operation : contains physical block address */
extern xdata  Byte nf_spare_block_number[NF_ZONE_MAX];      /* Number of free spare block in each zone */
extern xdata  Byte   lut_index[NF_ZONE_MAX];
extern xdata  t_free_blocks buf_free[24];

idata  Uint16  nf_redundant_logical_block_value;  /* Logical block value in the redundant area */


/*F**************************************************************************
* NAME:     nf_check_status
*----------------------------------------------------------------------------
* PARAMS:   
*
* RETURN: SMARTMEDIA status
*
*----------------------------------------------------------------------------
* PURPOSE:  Check the status of the device after a program or an erase
*           operation
*
*****************************************************************************
* NOTE: 
*       
*
*****************************************************************************/
bit nf_check_status(void)
{
  if (nf_parity_bit == NF_ODD)
  {
    Nf_wait_busy_odd();
  
    /* Status Type Command */
    Nf_send_command_odd(NF_READ_STATUS_CMD);
  
    if ( (Nf_rd_byte_odd() & 0x01) == 0x00)
    {  
      return OK;
    }
    else
    {
      return KO;
    }
  }
  else
  {
    Nf_wait_busy_even();
  
    /* Status Type Command */
    Nf_send_command_even(NF_READ_STATUS_CMD);
  
    if ( (Nf_rd_byte_even() & 0x01) == 0x00)
    {  
      return OK;
    }
    else
    {
      return KO;
    }
   
  }
}  

/*F**************************************************************************
* NAME:     nf_calc_logical_block
*----------------------------------------------------------------------------
* PARAMS:   
*           
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  This function calculate the logical block value (used in spare 
*           data area)
*
*****************************************************************************
* NOTE:     
*           
*
*****************************************************************************/
void nf_calc_logical_block()
{
volatile Byte dummy;
bdata bit parity_bit;

  nf_redundant_logical_block_value = (nf_logical_block << 1) + 0x1000;
  /* Parity bit calculation */
  dummy = nf_redundant_logical_block_value;
  parity_bit = P;
  dummy = ((Byte*)&nf_redundant_logical_block_value)[0];
  if (P) parity_bit = ~parity_bit;

  if (parity_bit)
    nf_redundant_logical_block_value++;
}

/*F**************************************************************************
* NAME:     nf_update_spare_data
*----------------------------------------------------------------------------
* PARAMS:   
*           
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  This function update the value of the logical block on the spare
*           data area
*
*****************************************************************************
* NOTE:     
*           
*
*****************************************************************************/
void nf_update_spare_data(void)
{
  if (nf_parity_bit == NF_ODD)
  {
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(nf_redundant_logical_block_value >> 8);
    Nf_wr_byte_odd(nf_redundant_logical_block_value );
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(nf_redundant_logical_block_value >> 8 );
    Nf_wr_byte_odd(nf_redundant_logical_block_value );
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
    Nf_wr_byte_odd(0xFF);
  }
  else
  {
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(nf_redundant_logical_block_value >> 8);
    Nf_wr_byte_even(nf_redundant_logical_block_value );
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(nf_redundant_logical_block_value >> 8 );
    Nf_wr_byte_even(nf_redundant_logical_block_value );
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
    Nf_wr_byte_even(0xFF);
  }
}



/*F**************************************************************************
* NAME:     nf_init_buffer
*----------------------------------------------------------------------------
* PARAMS:   
*           
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  This function initialize the global buffer at 0xFF
*          
*
*****************************************************************************
* NOTE:     
*           
*
*****************************************************************************/
void nf_init_buffer(void)
{
Byte i;
Byte pdata *ptr = gl_buffer;

  for (i = 4; i != 0; i--)
  { 
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;
    *(ptr++) = 0xFF;

  }                     
  
}



/*F**************************************************************************
* NAME:     nf_init_spare
*----------------------------------------------------------------------------
* PARAMS:   
*
* RETURN:
*
*----------------------------------------------------------------------------
* PURPOSE:  Init logical value in redundant data when a block is opened for 
*           the first time and the sector inside the block is not 0.
*
*****************************************************************************
* NOTE:     
*           
*
*****************************************************************************/
void nf_init_spare(void)
{
Byte j;
bit state = 0;
 
  /* Calculate the current physical sector */
  for (j = (gl_ptr_mem & 0x3F); j != 0 ; j--) /* gl_ptr_mem & 0x3F = gl_ptr_mem % 64 */
  {
    if (!state)
    {
      Nf_CS_EVEN();          
      Nf_wait_busy_even();
      Nf_write_open_C_area_even(nf_current_physical_sector_addr_even,0x00); /* Write open on spare data area */
      nf_update_spare_data();                                            /* Update spare data */
      Nf_send_command_even (NF_PAGE_PROGRAM_CMD);                        /* Send program command */ 
      nf_current_physical_sector_addr_even++;
    }
    else
    {
      Nf_CS_ODD();          
      Nf_wait_busy_odd();
      Nf_write_open_C_area_odd(nf_current_physical_sector_addr_odd,0x00);  /* Write open on spare data area */