nf_unusual.c

mp3播放器

      {

         nfc_open_page_read( nf_block_2_page(i_block), NF_SPARE_POS);

         ACC         = Nfc_rd_data_fetch_next(); // Dummy read! The first byte is irrelevant
         block_valid = Nfc_rd_data_fetch_next();
         block_id    = Nfc_rd_data()           ;

         if ( block_valid!=0xFF )
         {
            continue; // The block is bad
         }

         if(( NFC_BLK_ID_SUBLUT==block_id )
         || ( NFC_BLK_ID_FBB   ==block_id ))
         {
            nfc_erase_block( nf_block_2_page(i_block), TRUE ) ;
            if ( FAIL==nfc_check_status() )
            {
               nfc_mark_bad_block( nf_block_2_page(i_block) );
            }
         }
      } // for( i_block...
   } // for( i_dev...
} // nf_cleanup_memory



//! Scan the memory and looks for sub-LUT, free-blocks block and recovery blocks
//!
//! @param none
//!
//! @return a status:
//!           PASS if the scan has been succesfully executed;
//!           FAIL if the scan encountered any problem
//!
static Status_bool nf_scan( void )
{
   U8          i_dev  =0;
   U16         i_block=0;
   U8          n_quarantine_blocks=0;
   U16         n_invalid_blocks=0;

   g_last_sub_lut_log_sz =(U16)-1;
   g_sub_lut_log_sz      =(U16)NF_SUBLUT_SIZE/NF_N_DEVICES;


   // Initialize the recovery structure. This should be done by the startup !
   //
   g_is_found_lut  =FALSE;
   g_is_found_fbb  =FALSE;
   g_fatal         =FALSE;
   g_n_real_sub_lut=0;

   // Scan all the devices and looks for:
   // - the sub-LUT blocks
   // - the recovery block
   // - the free-blocks block
   //
   for( i_dev=0 ; i_dev<NF_N_DEVICES ; i_dev++ )
   {
      n_invalid_blocks   = 0;
      n_quarantine_blocks= 0;
      g_curr_block_addr[i_dev]= G_N_BLOCKS -1; // points on the last block

      trace("Device "); trace_hex(i_dev); trace("\n\r");
      Nfc_action(NFC_ACT_DEV_SELECT, i_dev);

      for( i_block=g_nf_first_block ; i_block<G_N_BLOCKS ; i_block++ )
      {
         nfc_read_spare_byte( g_byte, 16, nf_block_2_page(i_block) );
         if ( g_byte[G_OFST_BLK_STATUS]!=0xFF )
         {
            n_invalid_blocks +=1 ;
            trace_hex16(i_block); trace(" ("); trace_u32(i_block); trace("): bad Block\n\r");
            continue; // The block is bad
         }

         if(( g_byte[NFC_SPARE_OFST_1_BLK_ID]!=NFC_BLK_ID_SUBLUT     )
         && ( g_byte[NFC_SPARE_OFST_1_BLK_ID]!=NFC_BLK_ID_FBB        )
         && ( g_byte[NFC_SPARE_OFST_1_BLK_ID]!=NFC_BLK_ID_QUARANTINE )
#if (ISP_VERSION>=0x04) // Static area length may vary
         && ( g_byte[NFC_SPARE_OFST_1_BLK_ID]!=NFC_BLK_ID_SYSTEM     )
#endif
         && ( g_byte[NFC_SPARE_OFST_1_BLK_ID]!=NFC_BLK_ID_DATA       ))
         {
            n_invalid_blocks +=1;
            trace_hex16(i_block); trace(" ("); trace_u32(i_block); trace("): Unknown\n\r");
            continue;
         }

#if (ISP_VERSION>=0x04) // Static area length may vary
         else if ( g_byte[NFC_SPARE_OFST_1_BLK_ID]==NFC_BLK_ID_SYSTEM )
         {
            n_invalid_blocks =0;
            n_quarantine_blocks =0;
            g_is_found_lut  =FALSE;
            g_is_found_fbb  =FALSE;
            trace_hex16(i_block); trace(" ("); trace_u32(i_block); trace("): System\n\r");
            g_nf_first_block= Upper(i_block, 8);
            i_block = g_nf_first_block-1 ; // "continue" statement will increment accordingly
            continue;
         }
#endif
         else if ( g_byte[NFC_SPARE_OFST_1_BLK_ID]==NFC_BLK_ID_QUARANTINE )
         {
            n_quarantine_blocks +=1;
            trace_hex16(i_block); trace(" ("); trace_u32(i_block); trace("): Quarantine\n\r");
            continue;
         }
         else if ( g_byte[NFC_SPARE_OFST_1_BLK_ID]==NFC_BLK_ID_SUBLUT )
         {
            n_invalid_blocks +=1;
            if ( i_dev==S_MNGT_DEV )
            {
               U8 sub_lut_id                   = g_byte[NFC_SPARE_OFST_2_BYTE_2];
               g_n_sub_lut                     = g_byte[NFC_SPARE_OFST_4_BYTE_4];
               g_is_found_lut = TRUE;
               g_n_real_sub_lut++;
               g_lut_block_addr[sub_lut_id] = i_block;
               if ( sub_lut_id==(g_n_sub_lut-1) )
               {
                  MSB(g_last_sub_lut_log_sz)= g_byte[NFC_SPARE_OFST_6_LBA  ];
                  LSB(g_last_sub_lut_log_sz)= g_byte[NFC_SPARE_OFST_6_LBA+1];
               }
               g_lut_block_index[sub_lut_id]= nf_refine_index(i_block, 1, NFC_BLK_ID_SUBLUT);
               trace_hex16(i_block); trace(" ("); trace_u32(i_block); trace("): SUB-LUT (id ");trace_hex(sub_lut_id);trace(" ofst "); trace_hex(g_lut_block_index[sub_lut_id]); trace(")\n\r");
               continue ;
            }
            else
            {  // LUT found on bad NF
               g_fatal=TRUE;
               break;
            }
         }

         else if ( g_byte[NFC_SPARE_OFST_1_BLK_ID]==NFC_BLK_ID_FBB )
         {
            n_invalid_blocks +=1;
            if ( i_dev==S_MNGT_DEV )
            {
               if ( TRUE==g_is_found_fbb )
               {
                  g_fatal=TRUE; // already found
                  break;
               }
               g_fbb_block_addr  = i_block;
               g_fbb_block_index = nf_refine_index(i_block, 1, NFC_BLK_ID_FBB);
               nfc_read_spare_byte( g_byte, 16, nf_block_2_page(i_block) + (U32)g_fbb_block_index );     // Reload
               if( NFC_OFST_6_FBB_VALID!=g_byte[NFC_SPARE_OFST_6_LBA] )
               {
                  g_fatal=TRUE; // FBB not valid. Force rebuild
                  break;
               }

               MSB(g_n_free_blocks)   = g_byte[NFC_SPARE_OFST_2_BYTE_2];
               LSB(g_n_free_blocks)   = g_byte[NFC_SPARE_OFST_3_BYTE_3];
               s_nfd_rev              = g_byte[NFC_SPARE_OFST_4_BYTE_4];
               MSB(g_n_export_blocks) = g_byte[NFC_SPARE_OFST_EXPORT];
               LSB(g_n_export_blocks) = g_byte[NFC_SPARE_OFST_EXPORT+1];
               trace("      g_n_free_blocks="); trace_hex16(g_n_free_blocks); trace_nl();
               trace("      g_n_export_blocks="); trace_hex16(g_n_export_blocks); trace_nl();
               g_is_found_fbb=TRUE;
               trace_hex16(i_block); trace(" ("); trace_u32(i_block); trace("): FBB (ofst "); trace_hex( g_fbb_block_index ); trace(")\n\r");
               continue ;
            }
            else
            {
               g_fatal=TRUE;
               break;
            }
         }
      } // for ( i_block

      // A fatal error on one device is enough to cleanup all the devices !
      //
      s_n_invalid_blocks[   i_dev]= n_invalid_blocks;
      s_n_quarantine_blocks[i_dev]= n_quarantine_blocks;

      if ( TRUE==g_fatal ) { break; }
   } // for ( i_dev

   return (g_fatal==TRUE) ? FAIL: PASS;
} // nf_scan



//! Scan the static area of the memory and find its limit
//!
//! @param none
//!
//! @return none
//!
#if (ISP_VERSION<0x04) // Static area with fixed length
static void nf_scan_static_area( void )
{
   U16 i_block;

   g_nf_first_block = 0;
   Nfc_action(NFC_ACT_DEV_SELECT, 0);
   for( i_block=0 ; i_block<G_N_BLOCKS ; i_block++ )
   {
      nfc_read_spare_byte( g_byte, 16, nf_block_2_page(i_block) );
      if ( g_byte[G_OFST_BLK_STATUS]==0xFF )
      {  // The block is not bad
         g_nf_first_block++;
         if( g_nf_first_block==NF_N_GOOD_STATIC_BLOCK ) break;
      }
   }

   g_nf_first_block= Align_up(g_nf_first_block, 8);

   // Protect
   nfc_put_conf( NF_N_DEVICES,TRUE, g_nf_first_block-1 );   // NF is locked (system zone only)
} // nf_scan_static_area
#endif



//! @brief Test if the memory needs to be rebuilt.
//!
//! @param recovery_params  internal structure used to hold the last pointer position
//!
//! @return a status:
//!           TRUE if the memory has to be rebuilt;
//!           FALSE if the memory holds all the management blocks
//!
static Bool is_nf_invalid ( void )
{
   if( // If we do not find everything
      ( FALSE==g_is_found_lut )
   || ( FALSE==g_is_found_fbb )
   ) {
      g_fatal=TRUE;
   }

   // Test LUT coherency
   //
   if(( TRUE       ==g_is_found_lut   )
   && ( g_n_sub_lut!=g_n_real_sub_lut ))
   {
      g_fatal=TRUE;
   }

//#error se proteger si le nombre de devices changent alors que lut, recovery et free blocs sont d閖