/*C**************************************************************************
* NAME:         nf.c
*----------------------------------------------------------------------------
* Copyright (c) 2003 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-refd-nf-4_0_3      
* REVISION:     1.7     
*----------------------------------------------------------------------------
* PURPOSE:
* This file contains the high level 2x NF with 2Kb page routines
*****************************************************************************/
 
/*_____ I N C L U D E S ____________________________________________________*/


#include "config.h"                           /* system configuration */
#include "board.h"                            /* board definition  */
#include "lib_mcu\usb\usb_drv.h"              /* usb driver definition */
#include "nf.h"                               /* NF 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_2KB
  #error NF_CONFIG must be defined with NF_2X_2KB 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 ________________________________________________*/

xdata Byte nf_send_cmd_even At(NF_CMD_LATCH_ENABLE_ADD_EVEN);   /* Command */
xdata Byte nf_send_add_even At(NF_ADD_LATCH_ENABLE_ADD_EVEN);   /* Address */
xdata Byte volatile nf_data_even At(NF_ADDRESS_CMD_DATA_EVEN);  /* Data    */
xdata Byte nf_send_cmd_odd At(NF_CMD_LATCH_ENABLE_ADD_ODD);     /* Command */
xdata Byte nf_send_add_odd At(NF_ADD_LATCH_ENABLE_ADD_ODD);     /* Address */
xdata Byte volatile nf_data_odd At(NF_ADDRESS_CMD_DATA_ODD);    /* Data    */


/*_____ 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[];
extern          bit reserved_disk_space;

data  Uint32  nf_current_physical_sector_addr_even;   /* give the address of the current sector     */  
data  Uint32  nf_current_physical_sector_addr_odd;    /* give the address of the current sector     */  
data  Uint32  gl_address;                             /* general address variable                   */
data  Byte    nf_zone;                                /* current zone number                        */
data  Byte    nf_gl_buf_idx;
data  Byte    gl_buf_free_idx ;
data  Uint16  gl_cpt_page;                            /* internal page counter (byte access)        */

idata Uint16  nf_look_up_table_block;                 /* look up table address (block)              */
idata Byte    nf_gl_buf_idx_max;                      /* max index for updating LUT                 */

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       */
bdata bit nf_wr_open;                                 /* indicate that a write command is required  */ 
bdata bit nf_parity_bit;
bdata bit nf_write_advanced;
bdata bit nf_close_write_session;
bdata bit nf_reserved_space = FALSE;

xdata Uint32  nf_mem_size;
xdata Uint32  nf_reserved_space_start;
xdata Uint32  save_gl_ptr_mem;
xdata Uint32  save_physical_sector_odd;
xdata Uint32  save_physical_sector_even;
xdata Uint16  nf_logical_block;                   /* Current logical block value                */
xdata Uint16  nf_lut_block[NF_ZONE_MAX];          /* LUT address (block value)                  */
xdata Uint16  nf_spare_block;                     /* number of free block                       */
xdata Uint16  nf_block_to_be_deleted_even;        /* give the address of the next deleted block */
xdata Uint16  nf_block_to_be_deleted_odd;         /* 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 Byte    nf_old_zone;                        /* for zone change                            */  
xdata t_lut   nf_buf[NF_BUFFER_SIZE];             /* Buffer for write operation                 */
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    */
xdata t_free_blocks  nf_buf_free[24];             /* contain free physical block address        */



#if (NF_CAPACITY_AUTO_DETECT == TRUE)   /* If autodetect capacity nand flash is active  */
  xdata Byte    nf_zone_max;            /* nf_zone_max definition                       */
  xdata Byte    nf_device_type;         /* nf_device_type definition                    */
  bdata bit     NF_5_CYCLE_ADDRESS_BIT; /* NF_5_CYCLE_ADDRESS_BIT definition            */
#endif


/**************************************************************************************
manufacturer code :
            0x98                Toshiba
            0xEC                Samsung


supported   |  device |  capacity |     |manufacturer | Copy back
by this     |   code  |           |     |S : Samsung  | supported
driver      |         |           |     |T : Toshiba  |
------------------------------------------------------------------------------------
  no        |   0x39  |    8MB    | 512 |S    (1,8V)  | no
  no        |   0xE6  |    8MB    | 512 |S - T(3,3V)  | no
  no        |   0x73  |   16MB    | 512 |S - T(3,3V)  | no
  no        |   0x33  |   16MB    | 512 |S    (1,8V)  | no
  no        |   0x75  |   32MB    | 512 |S    (3,3V)  | yes
  no        |   0x75  |   32MB    | 512 |T    (3,3V)  | no
  no        |   0x76  |   64MB    | 512 |S    (3,3V)  | yes
  no        |   0x76  |   64MB    | 512 |T    (3,3V)  | no
  no        |   0x79  |  128MB    | 512 |S    (3,3V)  | yes
  no        |   0x79  |  128MB    | 512 |T    (3,3V)  | no
  yes       |   0xA1  |  128MB    |2048 |S    (1,8V)  | yes
  yes       |   0xF1  |  128MB    |2048 |S    (3,3V)  | yes
  yes       |   0xAA  |  256MB    |2048 |S    (1,8V)  | yes
  yes       |   0xDA  |  256MB    |2048 |S    (3,3V)  | yes
**************************************************************************************/


/*F**************************************************************************
* NAME: nf_force_write_close
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   End of write close function.
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void nf_force_write_close(void)
{
  /* Copy last part of a block if the block was assigned */
  if (nf_block_used)
  {
    if ( (((Byte*)&gl_ptr_mem)[3] & 0x7F) || (gl_cpt_page != 0) ) 
      nf_copy_block_tail(FALSE);
    Nf_CS_EVEN();
    nf_block_erase((Uint32)(nf_block_to_be_deleted_even) << NF_SHIFT_SECTOR_BLOCK);    /* Erase old block */
    Nf_CS_ODD();
    nf_block_erase((Uint32)(nf_block_to_be_deleted_odd) << NF_SHIFT_SECTOR_BLOCK);    /* Erase old block */
  }
}


/*F**************************************************************************
* NAME: nf_read_spare_byte
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   OK : LUT construction complete
*   KO : pb for LUT
*----------------------------------------------------------------------------
* PURPOSE:
*   read spare data byte and construct the look up table.
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit nf_read_spare_byte(void)
{
Byte byte_5;
Byte byte_6;
Uint16 block;
Uint16 j;                       /* counter */
Uint16 i;                       /* counter */
Uint16 start;                   /* start value for the construction of the LUT */
Uint16 end;                     /* final value */
xdata Uint16 free_bloc_pos_even;
xdata Uint16 free_bloc_pos_odd;
Union16 block2;
bit   block_valid;
bit   bit_double_block_odd;
Uint32 temp_address;              
xdata Uint16 last_physical_used_block_even[NF_ZONE_MAX]; /* last physical block used for even nf */
xdata Uint16 last_physical_used_block_odd[NF_ZONE_MAX]; /* last physical block used for odd nf */
xdata Byte tmp_spare;
xdata Byte save_gl_cpt_page_odd;
xdata Byte save_gl_cpt_page_even;
xdata Byte lut_is_present;
xdata Byte page;

#define NF_PAGE_BY_LUT    2
  Nf_CS_EVEN();

  lut_is_present      = 0x00;         
  nf_close_write_session = FALSE;
  for (i = 0; i < NF_ZONE_MAX; i++)
  {
    nf_lut_index[i] = 0;                /* LUT index                */
  }

  /***************************************************/
  /* For each zone, this following lines :           */
  /*   Search bad block                              */
  /*   Determine if a LUT is present                 */
  /*   Determine the last physical block             */ 
  /***************************************************/
  gl_address = 0;
  Nf_wait_busy_even();
                                      
  for (i = 0; i < NF_ZONE_MAX_CPT; i++)                                     /* for each zone */
  {
    nf_spare_block_number[i] = 23;                                          /* Initialize the spare block table */
    last_physical_used_block_even[i] = (Uint16)(i) << NF_SHIFT_BLOCK_ZONE;  /* Initialize the last used physical block value */
    for (j = NF_BLOCK_PER_ZONE; j != 0; j--)        
    {
      Nf_read_open_spare_area_even(gl_address, 0x05);
      if ( Nf_rd_byte_even() != 0xFF )                                /* block status : valid/invalid */
      {
        nf_spare_block_number[i]--;                                   /* Defect block                 */
        if (nf_spare_block_number[i] < 5)
          return KO;
      }
      else                                                            /* Block is valid */
      {
        byte_6 = Nf_rd_byte_even();                                   /* Determine is the block is a specific block */
        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 */
          if (nf_spare_block_number[i] < 5)
            return KO;
        }
        else
        {
          if (byte_6 == 0xE8)                                         /* look up table ? */
          {
              lut_is_present |= (0x01) << i;
              nf_lut_block[i] = gl_address >> NF_SHIFT_SECTOR_BLOCK;
          }

          if ( (byte_6 & 0xF8) == 0x10)                               /* Determine the last physical used block */
          {
            last_physical_used_block_even[i] = gl_address >> NF_SHIFT_SECTOR_BLOCK;
          }
        }

      }
      gl_address += NF_PAGE_PER_BLOCK;
    }
  }

  Nf_CS_ODD();
  Nf_wait_busy_odd();
  gl_address = 0;
  for (i = 0; i < NF_ZONE_MAX_CPT; i++)                                     /* for each zone */
  {
    tmp_spare = 23;                                                        /* Initialize the spare block table */
    last_physical_used_block_odd[i] = (Uint16)(i) << NF_SHIFT_BLOCK_ZONE;  /* Initialize the last used physical block value */
    for (j = NF_BLOCK_PER_ZONE; j != 0; j--)        
    {
      Nf_read_open_spare_area_odd(gl_address, 0x05);
      if ( Nf_rd_byte_odd() != 0xFF )                                 /* block status : valid/invalid */
      {
        tmp_spare--;                                                  /* Defect block                 */
        if (tmp_spare < 5)
          return KO;
      }
      else                                                            /* Block is valid */
      {
        byte_6 = Nf_rd_byte_odd();                                    /* Determine is the block is a specific block */
        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 */
           )
        { 
          tmp_spare--;                                                /* specific or invalid block */
          if (tmp_spare < 5)
            return KO;
        }
        else
        {
          if (byte_6 == 0xE8)                                         /* look up table ? */
          {
            nf_block_erase(gl_address);
            byte_6 = 0xFF;
            Nf_wait_busy_odd();
          }

          if ( (byte_6 & 0xF8) == 0x10)                               /* Determine the last physical used block */
          {
            last_physical_used_block_odd[i] = gl_address >> NF_SHIFT_SECTOR_BLOCK;
          }
        }