_fs_flashio.c

keil arm flash fs 最新版 在Ｋｅｉｌ ａｒｍ下使用

} /* end of fs_BlockFull */


/*----------------------------------------------------------------------------
 *  Allocate next available Block
 *    Parameter:      fcb:  file control block
 *    Return Value:   __TRUE  - allocated
 *                    __FALSE - error, not allocated
 *---------------------------------------------------------------------------*/

BOOL fs_AllocBlock (IOB *fcb) {
   U32 i,bl,adr,bflag;

   bl = fcb->_fblock;
   for (i = 0; i < fcb->NumSect; i++) {
      adr = fs_adr_sig (bl, fcb);
      adr = fs_rd_sig (adr, &bflag);
      if (bflag == fcb->InitVal) {
         /* Free Flash Block allocated */
         fcb->_fblock = bl;
         fcb->_fbot = 0;
         fcb->_ftop = (adr & ~1) - ((DEVCONF *)fcb->DevCfg)[bl].bStart;
         bflag ^= BlockUSED;
         fs_WriteBlock ((adr & ~1) + 8, &bflag, 4, fcb);
         return (__TRUE);
      }
      if ((bflag ^ BlockUSED) == fcb->InitVal) {
         /* Check if a file already opened for writing in this Block */
         if (fs_check_fwopen (bl, fcb) == __FALSE) {
            /* Try already used Flash Block and check for free space */
            if (fs_get_freeMem (bl, fcb) > 0) {
               fcb->_fblock = bl; 
               fs_mark_freeMem (fcb);
               return (__TRUE);
            }
            bflag = fcb->InitVal ^ BlockFULL;
            fs_WriteBlock ((adr & ~1) + 8, &bflag, 4, fcb);
         }
      }
      if (++bl == fcb->NumSect) {
         bl = 0;
      }
   } 
   return (__FALSE);
} /* end of fs_AllocBlock */


/*----------------------------------------------------------------------------
 *  Check if all stored file data in a Flash Block is invalid
 *    Parameter:      block:  block index
 *    Return Value:   __FALSE - valid file blocks found
 *                    __TRUE  - all data is invalidated
 *---------------------------------------------------------------------------*/

BOOL fs_BlockInvalid (U32 block, IOB *fcb)  {
   FALLOC fa;
   U32 adr;
   U16 invalid;

   invalid = ~fcb->InitVal;
   /* Check if this Flash Block is all invalided */
   adr = fs_adr_sig (block, fcb) - 8;
   for (;;) {
      adr = fs_rd_alloc (adr, &fa);
      if (fa.end == fcb->InitVal) break;
      if (fa.fileID != invalid) {
         /* A valid file block found */
         return (__FALSE);
      }
   }
   return (__TRUE);
} /* end of fs_BlockInvalid */


/*----------------------------------------------------------------------------
 *  Initialize a Flash/Ram Block
 *    Parameter: block:  block index
 *               fcb:    file control block
 *    Return Value:   __TRUE  - erase successfull
 *                    __FALSE - erase failed
 *---------------------------------------------------------------------------*/

BOOL fs_InitBlock (U32 block, IOB *fcb)  {
   U32 adr,enda;

   switch (fcb->drive) {
      case DRV_FLASH:
         adr = FlashDev[block].bStart;
         fs_EraseSector (adr);
         break;
      case DRV_SPI:
         adr = SpiDev[block].bStart;
         fs_spi_EraseSector (adr);
         break;
      case DRV_RAM:
         enda = RamDev[block].bEnd;
         for (adr = RamDev[block].bStart; adr <= enda; adr += 4) {
            MVAR (U32, adr) = 0x00;
         }
         break;
   }
   return (__TRUE);
} /* end of fs_InitBlock */


/*----------------------------------------------------------------------------
 *  Write a Flash/Ram Block
 *    Parameter: adr:  write address
 *               buf:  pointer to data buffer
 *               cnt:  number of bytes to write
 *               fcb:  file control block
 *    Return Value:   __TRUE  - write successfull
 *                    __FALSE - write failed
 *---------------------------------------------------------------------------*/

BOOL fs_WriteBlock (U32 adr, void *buf, U32 cnt, IOB *fcb)  {
   int r = 1;

   /* 'adr' is always 4-byte aligned. */
   cnt = (cnt + 3) & ~3;
   switch (fcb->drive) {
      case DRV_FLASH:
         r = fs_ProgramPage (adr, cnt, buf);
         break;
      case DRV_SPI:
         r = fs_spi_ProgramPage (adr, cnt, buf);
         break;
      case DRV_RAM:
         r = fs_WriteData (adr, cnt, buf);
         break;
   }
   if (r) return (__FALSE);
   return (__TRUE);
} /* end of fs_WriteBlock */


/*----------------------------------------------------------------------------
 *  Read Block from Flash Memory
 *    Parameter:      adr:  block start address
 *                    buf:  pointer to data buffer
 *                    cnt:  number of words to read
 *    Return Value:   0 - read OK
 *                    1 - read failed
 *---------------------------------------------------------------------------*/

BOOL fs_ReadBlock (U32 adr, void *buf, U32 cnt, IOB *fcb)  {

   /* Both 'adr' and 'buf' may be unaligned. */
   if (fcb->drive == DRV_SPI) {
      /* Read from SPI Flash. */
      fs_spi_ReadData (adr, cnt, buf);
      return (__TRUE);
   }

   /* Read from RAM or Parallel Flash */
   fs_ReadData (adr, cnt, buf);
   return (__TRUE);
} /* end of fs_ReadBlock */


/*----------------------------------------------------------------------------
 *  Get address of the Signature word from allocation area
 *    Parameter:      bl:   Flash Block (=sector) index
 *                    fcb:  File Control Block
 *    Return Value:   adr:  of Signature Word
 *---------------------------------------------------------------------------*/

U32 fs_adr_sig (U32 bl, IOB *fcb) {
   U32 adr;

   adr = (U32)((DEVCONF *)fcb->DevCfg)[bl].bEnd;
   if (fcb->drive == DRV_SPI) {
      adr |= 0x01;
   }
   return (adr);
}

/*----------------------------------------------------------------------------
 *  Read File Allocation Record
 *    Parameter:      adr:  data address 
 *                          (adr is always 4-byte aligned,
 *                           bit 0 is a flag for SPI access)
 *                    fa:   pointer to Allocation Record
 *    Return Value:   adr:  of the next Allocation Record
 *---------------------------------------------------------------------------*/

U32 fs_rd_alloc (U32 adr, FALLOC *fa) {
   U32 *pa;

   if (adr & 0x01) {
      /* SPI Flash access. */
      fs_spi_ReadData ((adr & ~1), 8, (U8 *)fa);
   }
   else {
      /* Embedded Flash/RAM access. */
      pa = (U32 *)fa;
      pa[0] = MVAR (U32, adr);
      pa[1] = MVAR (U32, adr+4);
   }
   return (adr - 8);
}

/*----------------------------------------------------------------------------
 *  Read Block Signature (=usage)
 *    Parameter:      adr:  signature address
 *                          (adr is always 4-byte aligned,
 *                           bit 0 is a flag for SPI access)
 *                    sig:  return sig value
 *    Return Value:   adr:  of the first Allocation Record
 *---------------------------------------------------------------------------*/

U32 fs_rd_sig (U32 adr, U32 *sig) {

   if (adr & 0x01) {
      /* SPI Flash access. */
      fs_spi_ReadData ((adr & ~1), 4, (U8 *)sig);
   }
   else {
      /* Embedded Flash/RAM access. */
      *sig = MVAR (U32, adr);
   }
   return (adr - 8);
}

/*----------------------------------------------------------------------------
 * end of file
 *---------------------------------------------------------------------------*/