/*C**************************************************************************
* NAME:         nf_drv.c
*----------------------------------------------------------------------------
* Copyright (c) 2003 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-refd-nf-4_0_3      
* REVISION:     1.4     
*----------------------------------------------------------------------------
* PURPOSE: 
* This file contains the NF driver routines for 2 NF slots
*
*****************************************************************************/

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


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


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

#ifndef NF_CAPACITY_AUTO_DETECT
  #error  NF_CAPACITY_AUTO_DETECT must be defined in board.h
#endif

#if NF_CONFIG != NF_2X_512B
  #error NF_CONFIG must be defined with NF_2X_512B in config.h
#endif

#ifndef NF_FULL_CHIP_ERASE
  #error NF_FULL_CHIP_ERASE  must be set to TRUE or FALSE in config.h
#endif

#ifndef MEM_RESERVED_SIZE
  #error MEM_RESERVED_SIZE must be defined in config.h
#endif
/*_____ D E F I N I T I O N ________________________________________________*/

                                  

/*_____ 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[];                          /* 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 xdata  Uint16  nf_block_to_be_deleted_odd;
extern xdata  Uint16  nf_block_to_be_deleted_even;
extern idata  Uint16  nf_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];

extern  xdata Uint32  nf_reserved_space_start;

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

#if (NF_CAPACITY_AUTO_DETECT == TRUE)                         /* If autodetect capacity nand flash is active */
  extern  xdata Byte    nf_zone_max;                          /* nf_zone_max definition   */
  extern  xdata Byte    nf_device_type;                       /* nf_device_type definition */
  extern  bdata bit     nf_4_cycle_address;                   /* nf_4_cycle_address definition */
  extern  bdata bit     nf_copy_back;                         /* copy back command available */
#endif

/*F**************************************************************************
* NAME:     nf_check_status
*----------------------------------------------------------------------------
* PARAMS:   
*
* RETURN: NF 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;
  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;
 
  for (j = (((Byte*)&gl_ptr_mem)[3] & 0x3F); j != 0 ; j--)
  {
    if (!state)
    {
      Nf_CS_EVEN();          
      Nf_wait_busy_even();
      Nf_write_open_C_area_even(nf_current_physical_sector_addr_even,0x00); /* open spare data area */
      nf_update_spare_data();                                               /* update spare data    */
      Nf_send_command_even (NF_PAGE_PROGRAM_CMD);                           /* send program command */ 
      ((Byte*)&nf_current_physical_sector_addr_even)[3]++;
    }