开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
ssfdc.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：64k
源码类别：

VxWorks

开发平台：

C/C++

ssfdc.c：源码内容
  1. /*
  2.  * $Log:   V:/ssfdc.c_v  $
  3.  *
  4.  *    Rev 1.17   01 Mar 1998 12:59:30   amirban
  5.  * Add parameter to mapSector
  6.  *
  7.  *    Rev 1.16   29 Sep 1997 14:17:28   danig
  8.  * Call setBusy(OFF) from dismount function
  9.  *
  10.  *    Rev 1.15   18 Sep 1997 10:11:42   danig
  11.  * Warnings
  12.  *
  13.  *    Rev 1.14   10 Sep 1997 16:21:16   danig
  14.  * Got rid of generic names
  15.  *
  16.  *    Rev 1.13   10 Sep 1997 13:32:20   danig
  17.  * Limit number of virtual units
  18.  *
  19.  *    Rev 1.12   04 Sep 1997 15:52:46   danig
  20.  * Debug messages
  21.  *
  22.  *    Rev 1.11   04 Sep 1997 11:07:52   danig
  23.  * Share buffer with MTD
  24.  *
  25.  *    Rev 1.10   28 Jul 1997 15:13:34   danig
  26.  * volForCallback & moved standard typedefs to flbase.h
  27.  *
  28.  *    Rev 1.9   27 Jul 1997 14:04:18   danig
  29.  * FAR -> FAR0
  30.  *
  31.  *    Rev 1.8   24 Jul 1997 15:14:18   danig
  32.  * Fixed ECC on read
  33.  *
  34.  *    Rev 1.7   20 Jul 1997 11:01:52   danig
  35.  * Ver 2.0
  36.  *
  37.  *    Rev 1.6   13 Jul 1997 10:51:58   danig
  38.  * erasedSectors
  39.  *
  40.  *    Rev 1.5   01 Jul 1997 15:36:32   danig
  41.  * Changes to isErasedSector & isErasedUnit
  42.  *
  43.  *    Rev 1.4   29 Jun 1997 16:13:02   danig
  44.  * Comments
  45.  *
  46.  *    Rev 1.3   12 Jun 1997 17:41:54   danig
  47.  * ECC on read, use second address area.
  48.  *
  49.  *    Rev 1.2   08 Jun 1997 19:05:24   danig
  50.  * Delete sector bug & check for mount in setBusy()
  51.  *
  52.  *    Rev 1.1   01 Jun 1997 13:42:36   amirban
  53.  * Use ftllite.h I/F
  54.  *
  55.  *    Rev 1.0   15 Apr 1997 17:56:26   danig
  56.  * Initial revision.
  57.  */
  59. /************************************************************************/
  60. /*                                                                      */
  61. /* FAT-FTL Lite Software Development Kit */
  62. /* Copyright (C) M-Systems Ltd. 1995-1997 */
  63. /* */
  64. /************************************************************************/
  67. #include "fltl.h"
  68. #include "flflash.h"
  69. #include "flbuffer.h"
  71. /* VF: This macro is vital to supporting devices with 32 or more sectors per erase
  72.        unit.  Data types and code coming originally from M-Systems only provided
  73.        for up to 16 sectors per erase unit.  Some data types had bit fields that
  74.        depended on the number of sectors per erase unit not exceeding 16.
  75.        Several data type and code modifications have been made based on the value
  76.        of this macro to accomodate larger erase unit sized devices.
  77. */
  78. #define TFFS_SECTORS_PER_UNIT  32
  80. typedef long int VirtualAddress;
  82. /* VF: Updated PhysUnit storage type.  As used below in the Unit type,
  83.        a PhysUnit only provided 8 bits of storage:  The upper 3 bits were
  84.        used to bookkeep sector status, and the low 5 bits represented a count
  85.        of sectors free in the unit.  5 bits only counts up to 31.  We need more
  86.        bits for the count, hence the increase in size of this data type.
  87. */
  88. #if (TFFS_SECTORS_PER_UNIT < 32)
  89. typedef unsigned char PhysUnit;
  90. #else
  91. typedef unsigned short PhysUnit;
  92. #endif
  94. typedef unsigned short UnitNo;
  96. #define FORMAT_PATTERN 1, 3, 0xd9, 1, 0xff, 0x18, 2, 0xdf, 1, 0x20
  98. #define CIS_DATA 0x1, 0x3, 0xd9, 0x1, 0xff, 0x18, 0x2, 0xdf, 0x1, 
  99. 0x20, 0x4, 0x0, 0x0, 0x0, 0x0, 0x21, 0x2, 
  100. 0x4, 0x1, 0x22, 0x2, 0x1, 0x1, 0x22, 0x3, 
  101. 0x2, 0x4, 0x7, 0x1a, 0x5, 0x1, 0x3, 0x0, 
  102. 0x2, 0xf, 0x1b, 0x8, 0xc0, 0xc0, 0xa1, 0x1, 
  103. 0x55, 0x8, 0x0, 0x20, 0x1b, 0xa, 0xc1, 0x41, 
  104. 0x99, 0x1, 0x55, 0x64, 0xf0, 0xff, 0xff, 0x20, 
  105. 0x1b, 0xc, 0x82, 0x41, 0x18, 0xea, 0x61, 0xf0, 
  106. 0x1, 0x7, 0xf6, 0x3, 0x1, 0xee, 0x1b, 0xc, 
  107. 0x83, 0x41, 0x18, 0xea, 0x61, 0x70, 0x1, 0x7, 
  108. 0x76, 0x3, 0x1, 0xee, 0x15, 0x14, 0x5, 0x0, 
  109. 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0, 
  110. 0x20, 0x20, 0x20, 0x20, 0x0, 0x30, 0x2e, 0x30, 
  111. 0x0, 0xff, 0x14, 0x0, 0xff, 0x0, 0x0, 0x0, 
  112. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  113. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  114. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  115. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  116. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  117. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  118. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  119. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  120. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  121. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  122. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  123. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  124. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  125. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  126. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  127. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  128. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  129. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 
  130. 0x3, 0xd9, 0x1, 0xff, 0x18, 0x2, 0xdf, 0x1, 
  131. 0x20, 0x4, 0x0, 0x0, 0x0, 0x0, 0x21, 0x2, 
  132. 0x4, 0x1, 0x22, 0x2, 0x1, 0x1, 0x22, 0x3, 
  133. 0x2, 0x4, 0x7, 0x1a, 0x5, 0x1, 0x3, 0x0, 
  134. 0x2, 0xf, 0x1b, 0x8, 0xc0, 0xc0, 0xa1, 0x1, 
  135. 0x55, 0x8, 0x0, 0x20, 0x1b, 0xa, 0xc1, 0x41, 
  136. 0x99, 0x1, 0x55, 0x64, 0xf0, 0xff, 0xff, 0x20, 
  137. 0x1b, 0xc, 0x82, 0x41, 0x18, 0xea, 0x61, 0xf0, 
  138. 0x1, 0x7, 0xf6, 0x3, 0x1, 0xee, 0x1b, 0xc, 
  139. 0x83, 0x41, 0x18, 0xea, 0x61, 0x70, 0x1, 0x7, 
  140. 0x76, 0x3, 0x1, 0xee, 0x15, 0x14, 0x5, 0x0, 
  141. 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0, 
  142. 0x20, 0x20, 0x20, 0x20, 0x0, 0x30, 0x2e, 0x30, 
  143. 0x0, 0xff, 0x14, 0x0, 0xff, 0x0, 0x0, 0x0, 
  144. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  145. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  146. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  147. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  148. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  149. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  150. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  151. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  152. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  153. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  154. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  155. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  156. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  157. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  158. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  159. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  160. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
  161. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
  163. #define SECTOR_ERASED 1
  164. #define SECTOR_ALLOCATED        2
  165. #define SECTOR_REPLACED 3
  166. #define SECTOR_DELETED1 0x80
  167. #define SECTOR_DELETED2 0xf0
  169. #define SECTORS_PER_UNIT 16  /* default number of sectors per unit */
  171. /*#define ECC_ON_READ*/
  173. #define UNASSIGNED_ADDRESS 0xffffffffl
  175. /* VF: Due to the increase in size of PhysUnit above from 8 to 16 bits, these macros
  176.        must be adjusted accordingly to represent the upper 3 bits of a 16-bit quantity.
  177. */
  178. #if (TFFS_SECTORS_PER_UNIT < 32)
  179. #define UNIT_FREE 0xe0   /* unassigned unit */
  180. #define UNIT_AVAILABLE 0x80   /* assigned unit */
  181. #define UNIT_ERASED 0xc0   /* unit is erased */
  182. #define UNIT_BAD 0      /* unit is defective */
  183. #define STATUS_MASK 0xe0   /* the unit status is in the 3 MSBs */
  184. #else
  185. #define UNIT_FREE 0xe000   /* unassigned unit */
  186. #define UNIT_AVAILABLE 0x8000   /* assigned unit */
  187. #define UNIT_ERASED 0xc000   /* unit is erased */
  188. #define UNIT_BAD 0x0000   /* unit is defective */
  189. #define STATUS_MASK 0xe000   /* the unit status is in the 3 MSBs */
  190. #endif
  193. /* extra area of odd pages is read before extra area of even pages
  194.    when page size is 256 */
  195. #define STATUS_AREA_OFFSET      ((vol.flash.flags & BIG_PAGE) ? 4 : 12)
  196. #define BLOCK_ADDRESS_OFFSET1   ((vol.flash.flags & BIG_PAGE) ? 6 : 14)
  197. #define BLOCK_ADDRESS_OFFSET2   ((vol.flash.flags & BIG_PAGE) ? 11 : 3)
  198. #define CIS_DATA_OFFSET ((vol.flash.flags & BIG_PAGE) ? 4 : 12)
  199. #define ECC1 ((vol.flash.flags & BIG_PAGE) ? 13 : 5)
  200. #define ECC2 ((vol.flash.flags & BIG_PAGE) ? 8 : 0)
  202. #define OFFSET1 1
  203. #define OFFSET2 2
  205. #define INCORRECT_DATA 0
  206. #define CORRECT_DATA 0xff
  208. #define NO_UNIT 0xffff
  211. typedef struct {
  212.   PhysUnit unitStatus;             /* unit status in the 3 MSBs, unassigned */
  213.    /* sectors counter in the rest of the bits. */
  214. /* VF: Updated next line.  This is a bit-field, so we need 32 bits to represent sectors: */
  215. #if (TFFS_SECTORS_PER_UNIT < 32)
  216.   unsigned short erasedSectors;    /* if bit i=1, sector i in the unit is erased. */
  217. #else
  218.   unsigned long erasedSectors;     /* if bit i=1, sector i in the unit is erased. */
  219. #endif
  220. } Unit;
  223. typedef struct  {
  224.   unsigned char sectorStatus;
  225.   unsigned char unitStatus;
  226. } StatusArea;
  229. typedef enum {BAD_FORMAT, SSFDC_FORMAT, ANAND_FORMAT} FormatType;
  231. #ifndef MALLOC_TFFS
  233. #define HEAP_SIZE (0x100000l / ASSUMED_NFTL_UNIT_SIZE) *       
  234. (sizeof(UnitNo) + sizeof(Unit)) *  
  235. MAX_VOLUME_MBYTES + SECTORS_PER_UNIT
  237. #endif
  239. struct tTLrec {
  240.   FLBoolean     badFormat; /* true if TFFS format is bad */
  242.   UnitNo     CISblock;           /* Unit no. of CIS block */
  243.   unsigned int     erasableBlockSizeBits;  /* log2 of erasable block size */
  244.   UnitNo     noOfVirtualUnits;
  245.   UnitNo     freeUnits;              /* number of unassigned units */
  246.   unsigned long     unitOffsetMask;
  247.   unsigned int     sectorsPerUnit;
  248.   UnitNo     noOfUnits;
  249.   unsigned int     unitSizeBits;
  250.   SectorNo     virtualSectors;
  252.   UnitNo            roverUnit;          /* Starting point for allocation search */
  253.   UnitNo     transferUnit;
  254.   UnitNo     replacedUnit;
  255.   unsigned int     sectorsDeleted;     /* number of sector deleted in the
  256.    replaced unit */
  257.   Unit      *physicalUnits;  /* unit table by physical no. */
  258.   UnitNo     *virtualUnits;  /* unit table by logical no. */
  259.   unsigned char     *replacementSectors; /* a table of the sectors in the
  260.     replaced unit */
  261.   SectorNo      mappedSectorNo;
  262.   void FAR0         *mappedSector;
  263.   CardAddress     mappedSectorAddress;
  265.   FLFlash     flash;
  266.   FLBuffer          *buffer;
  268. #ifndef MALLOC_TFFS
  269.   char     heap[HEAP_SIZE];
  270. #endif
  271. };
  273. #define ssfdcBuffer  vol.buffer->data
  275. typedef TLrec SSFDC;
  277. static SSFDC vols[DRIVES];
  280. /********************** ECCEDC part ******************************/
  282. /*----------------------------------------------------------------------*/
  283. /*          c h a r P a r i t y */
  284. /* */
  285. /* Get odd parity of one byte. */
  286. /*                                                                      */
  287. /* Parameters:                                                          */
  288. /* c : One byte of data. */
  289. /*                                                                      */
  290. /* Returns:                                                             */
  291. /* Odd parity. */
  292. /*----------------------------------------------------------------------*/
  294. static unsigned char charParity(unsigned char c)
  295. {
  296.   unsigned char parityBit = 1;
  298.   for (; c; c >>= 1)
  299.     parityBit ^= c & 0x01;
  301.   return parityBit;
  302. }
  305. /*----------------------------------------------------------------------*/
  306. /*          c r e a t e E c c */
  307. /* */
  308. /* Calculate 22 bits Error correction  detection code for 256 bytes    */
  309. /* of data. 16 bits line parity, 6 bits column parity. ECC scheme  */
  310. /* according to SSFDC specification. */
  311. /*                                                                      */
  312. /* Parameters:                                                          */
  313. /* buf : 256 bytes of data. */
  314. /* code : 3 bytes of ECC. */
  315. /*                                                                      */
  316. /*----------------------------------------------------------------------*/
  318. static void createEcc(unsigned char FAR0 *buf, unsigned char FAR0 *code)
  319. {
  320.   unsigned char lineParity[16], columnParity[6], temp;
  321.   int i, k;
  323.   /* initialize to 1's, odd parity */
  324.   for (i = 0; i < 16; i++)
  325.     lineParity[i] = 0xff;
  326.   for (i = 0; i < 6; i++)
  327.     columnParity[i] = 1;
  329.   /* xor the lines */
  330.   for (i = 0; i < 256; i++)
  331.     for (k = 0; k < 8; k++)
  332.       if ((i / (1 << k)) % 2)
  333. lineParity[2 * k + 1] ^= buf[i];
  334.       else
  335. lineParity[2 * k] ^= buf[i];
  337.   temp = lineParity[0] ^ lineParity[1];  /* temp holds the xor of all the lines */
  339.   for(i = 0; i < 3; i++)
  340.     code[i] = 0;
  342.   /* get line parity */
  343.   for(i = 0; i < 16; i++)
  344.     if (charParity(lineParity[i]))
  345.       code[i / 8] |= (1 << (i % 8));
  347.   /* xor the columns */
  348.   for(i = 0; i < 8; i++)
  349.     for (k = 0; k < 3; k++)
  350.       if ((i / (1 << k)) % 2)
  351. columnParity[2 * k + 1] ^= (temp & (0xff >> (7 -  i))) >> i;
  352.       else
  353. columnParity[2 * k] ^= (temp & (0xff >> (7 -  i))) >> i;
  355.   code[2] |= 0x03;  /* bits 16 and 17 are always 1 */
  357.   /* get column parity */
  358.   for(i = 0; i < 6; i++)
  359.     if (columnParity[i])
  360.       code[2] |= 4 << i;
  361. }
  363. #ifdef ECC_ON_READ
  365. /*----------------------------------------------------------------------*/
  366. /*          i s F i x a b l e */
  367. /* */
  368. /* We know there is an error, Check if it is fixable (one bit error in  */
  369. /* 256 bytes of data is fixable). */
  370. /*                                                                      */
  371. /* Parameters:                                                          */
  372. /* diff : The difference between the read and  */
  373. /*   calculated ECC. */
  374. /* */
  375. /* Returns: */
  376. /* TRUE if the error is fixable, otherwise FALSE. */
  377. /*                                                                      */
  378. /*----------------------------------------------------------------------*/
  380. static FLBoolean isFixable (unsigned char FAR0 *diff)
  381. {
  382.   int i, j;
  383.   unsigned char mask;
  385.   /* data is fixable if for each pair of bits one is 0 and one is 1 */
  386.   for (i = 0; i < 3; i++)
  387.     for (j = 0, mask = 1; j < 4; j++, mask <<= 2) {
  388.       if ((i == 2) && (j == 0))
  389. continue;     /* the two lowest bits in the 3rd byte are always 1 */
  390.       /* xor two neighbouring bits */
  391.       if (!(((diff[i] & mask) >> (2 * j)) ^
  392.     ((diff[i] & (mask << 1)) >> (2 * j + 1))))
  393. return FALSE;
  394.     }
  396.   return TRUE;
  397. }
  400. /*----------------------------------------------------------------------*/
  401. /*          c h e c k A n d F i x */
  402. /* */
  403. /* Compare the calculated ECC and the one read from the device.  */
  404. /* If there is a difference, try to fix the error. If both codes */
  405. /* are the same, data is correct. */
  406. /*                                                                      */
  407. /* Parameters:                                                          */
  408. /* ecc1 : Calculated ECC. */
  409. /* ecc2 : Read ECC. */
  410. /*      sectorToFix : The data to fix. */
  411. /* */
  412. /* Returns: */
  413. /* TRUE if data is correct or error fixed, otherwise FALSE. */
  414. /*                                                                      */
  415. /*----------------------------------------------------------------------*/
  417. static FLBoolean checkAndFix(unsigned char FAR0 *ecc1, unsigned char FAR0 *ecc2,
  418.  unsigned char FAR0 *sectorToFix)
  419. {
  420.   if((ecc1[0] != ecc2[0]) ||
  421.      (ecc1[1] != ecc2[1]) ||
  422.      (ecc1[2] != ecc2[2])) {  /* ECC error, try to fix */
  423.     unsigned char diff[3];
  424.     int i;
  426.     for (i = 0; i < 3; i++)
  427.       diff[i] = ecc1[i] ^ ecc2[i];
  429.     if (isFixable(diff)) {
  430.       unsigned char line = 0, column = 0, mask;
  432.       /* push the lower bits to the right */
  433.       for (i = 0, mask = 2; i < 4; i++, mask <<= 2)
  434. line |= (diff[0] & mask) >> (i + 1);
  436.       /* push the upper bits to the left */
  437.       for (i = 0, mask = 0x80; i < 4; i++, mask >>= 2)
  438. line |= (diff[1] & mask) << i;
  440.       /* push to the right */
  441.       for (i = 0, mask = 8; i < 3; i++, mask <<= 2)
  442. column |= (diff[2] & mask) >> (i + 3);
  444.       sectorToFix[line] ^= 1 << column;  /* fix */
  445.       return TRUE;
  446.     }
  447.     else {
  448.     #ifdef DEBUG_PRINT
  449.       DEBUG_PRINT("Debug: ECC error in SSFDC.n");
  450.     #endif
  451.       return FALSE;
  452.     }
  453.   }
  454.   else
  455.     return TRUE;
  456. }
  459. /*----------------------------------------------------------------------*/
  460. /*          e c c O n R e a d */
  461. /* */
  462. /* Use ECCEDC for a sector of data. Do each half seperately. */
  463. /* If there is a fixable error, fix it. */
  464. /*                                                                      */
  465. /* Parameters:                                                          */
  466. /* vol : Pointer identifying drive */
  467. /* sectorAddress : Physical address of the sector to check. */
  468. /* */
  469. /* Returns: */
  470. /*  FALSE if there is an error that can't be fixed, otherwise  */
  471. /* return TRUE. */
  472. /*                                                                      */
  473. /*----------------------------------------------------------------------*/
  475. static FLBoolean eccOnRead(SSFDC vol, CardAddress sectorAddress)
  476. {
  477.   unsigned char calcEcc[3], readEcc[3];
  478.   unsigned char FAR0 *sectorToFix = (unsigned char FAR0 *)vol.mappedSector;
  480.   createEcc(sectorToFix, calcEcc);
  481.   vol.flash.read(&vol.flash, sectorAddress + ECC1, readEcc, sizeof readEcc, EXTRA);
  482.   if (checkAndFix(calcEcc, readEcc, sectorToFix)) {
  483.     /* success in the first half go for the second half */
  484.     createEcc(sectorToFix + SECTOR_SIZE / 2, calcEcc);
  485.     vol.flash.read(&vol.flash, sectorAddress + ECC2, readEcc, sizeof readEcc, EXTRA);
  486.     if (checkAndFix(calcEcc, readEcc, sectorToFix + SECTOR_SIZE / 2))
  487.       return TRUE;
  488.   }
  490.   return FALSE;
  491. }
  493. #endif /* ECC_ON_READ */
  495. /******************* end of ECCEDC part ********************************/
  497. /*----------------------------------------------------------------------*/
  498. /*          u n i t B a s e A d d r e s s */
  499. /* */
  500. /* Returns the physical address of a unit. */
  501. /*                                                                      */
  502. /* Parameters:                                                          */
  503. /* vol : Pointer identifying drive */
  504. /* unitNo : Physical unit number */
  505. /*                                                                      */
  506. /* Returns:                                                             */
  507. /* physical address of unitNo */
  508. /*----------------------------------------------------------------------*/
  510. static CardAddress unitBaseAddress(SSFDC vol, UnitNo unitNo)
  511. {
  512.   return (CardAddress)unitNo << vol.unitSizeBits;
  513. }
  516. /*----------------------------------------------------------------------*/
  517. /*          v i r t u a l 2 P h y s i c a l */
  518. /* */
  519. /* Translate virtual sector number to physical address. */
  520. /*                                                                      */
  521. /* Parameters:                                                          */
  522. /* vol : Pointer identifying drive */
  523. /* sectorNo : Virtual sector number */
  524. /*                                                                      */
  525. /* Returns:                                                             */
  526. /* physical address of sectorNo */
  527. /*----------------------------------------------------------------------*/
  529. static CardAddress virtual2Physical(SSFDC vol, SectorNo sectorNo)
  530. {
  531.   unsigned unitOffset = (sectorNo % vol.sectorsPerUnit) << SECTOR_SIZE_BITS;
  532.   UnitNo unitNo = vol.virtualUnits[sectorNo / vol.sectorsPerUnit];
  533.   StatusArea statusArea;
  535.   /* no physical unit is assigned to this virtual sector number */
  536.   if (unitNo == NO_UNIT)
  537.     return UNASSIGNED_ADDRESS;
  539.   /* check if this sector was replaced */
  540.   vol.flash.read(&vol.flash,
  541.  unitBaseAddress(&vol, unitNo) + unitOffset + STATUS_AREA_OFFSET,
  542.  &statusArea, sizeof statusArea, EXTRA);
  543.   if (statusArea.sectorStatus != 0xff) {
  544.     if (vol.replacedUnit == unitNo)
  545.       if (vol.replacementSectors[sectorNo % vol.sectorsPerUnit] == SECTOR_REPLACED)
  546. return unitBaseAddress(&vol, vol.transferUnit) + unitOffset; /* this sector was replaced */
  547.     return UNASSIGNED_ADDRESS;  /* this sector is bad or deleted */
  548.   }
  550.   return unitBaseAddress(&vol, unitNo) + unitOffset;
  551. }
  554. /*----------------------------------------------------------------------*/
  555. /*          p h y s i c a l 2 V i r t u a l */
  556. /* */
  557. /* Translate physical unit number to virtual unit number. Read virtual */
  558. /* unit number from first or second address area according to the  */
  559. /* parameter addressAreaNo. */
  560. /*                                                                      */
  561. /* Parameters:                                                          */
  562. /* vol : Pointer identifying drive */
  563. /* unitNo : Physical unit number */
  564. /* addressAreaNo : Specify which address area to use */
  565. /*                                                                      */
  566. /* Returns:                                                             */
  567. /* Virtual unit number of unitNo. */
  568. /*----------------------------------------------------------------------*/
  570. static UnitNo physical2Virtual(SSFDC vol, UnitNo unitNo, int addressAreaNo)
  571. {
  572.   unsigned char addressArea[2];
  573.   UnitNo virtualUnitNo;
  574.   int offset;
  576.   offset = (addressAreaNo == OFFSET1 ? BLOCK_ADDRESS_OFFSET1 : BLOCK_ADDRESS_OFFSET2);
  578.   /* get virtual unit no. from address area */
  579.   vol.flash.read(&vol.flash, unitBaseAddress(&vol, unitNo) + offset, addressArea,
  580.  sizeof addressArea, EXTRA);
  582.   /* trade places of byte 0 and byte 1 */
  583.   virtualUnitNo = ((UnitNo)addressArea[0] << 8) | addressArea[1];
  584.   /* virtual address is in bits 1 through 11 */
  585.   virtualUnitNo <<= 4;
  586.   virtualUnitNo >>= 5;
  588.   return virtualUnitNo;
  589. }
  592. /*----------------------------------------------------------------------*/
  593. /*               s e c t o r s I n V o l u m e */
  594. /* */
  595. /* Gets the total number of sectors in the volume */
  596. /* */
  597. /* Parameters:                                                          */
  598. /* vol : Pointer identifying drive */
  599. /*                                                                      */
  600. /* Returns:                                                             */
  601. /* Number of sectors in the volume */
  602. /*----------------------------------------------------------------------*/
  604. static SectorNo sectorsInVolume(SSFDC vol)
  605. {
  606.   return vol.virtualSectors;
  607. }
  610. /*----------------------------------------------------------------------*/
  611. /*               I d e n t i f y F o r m a t */
  612. /* */
  613. /* There are two different formats for nand devices, this function  */
  614. /* tries to identify one of them by reading its ID string. If format is */
  615. /* identified, bootBlock holds the number of the unit where the boot  */
  616. /* sector is.  */
  617. /* */
  618. /* Parameters:                                                          */
  619. /* vol : Pointer identifying drive */
  620. /* bootBlock : Receives the number of the block where the */
  621. /*   boot sector is. */
  622. /*                                                                      */
  623. /* Returns:                                                             */
  624. /* The type of the format idetified (SSFDC, NFTL, unknown) */
  625. /*----------------------------------------------------------------------*/
  627. static FormatType identifyFormat(SSFDC vol, UnitNo *bootBlock)
  628. {
  629.   int i;
  630.   unsigned char bootRecordId[10], invalidDataFlag;
  631.   unsigned char formatPattern[10] = {FORMAT_PATTERN};
  633.   for (*bootBlock = 0; *bootBlock < vol.noOfUnits; (*bootBlock)++) {
  634.     vol.flash.read(&vol.flash, unitBaseAddress(&vol, *bootBlock),
  635.    bootRecordId, sizeof bootRecordId, 0);
  636.     if (tffscmp(bootRecordId, "ANAND", 6) == 0)
  637.       return ANAND_FORMAT;
  638.     for (i = 0; (unsigned)i < vol.sectorsPerUnit; i++) {
  639.       vol.flash.read(&vol.flash, unitBaseAddress(&vol, *bootBlock) + (i << SECTOR_SIZE_BITS),
  640.      bootRecordId, sizeof bootRecordId, 0);
  641.       if (tffscmp(bootRecordId, formatPattern, sizeof formatPattern) == 0) {
  642. /* check that the data is valid */
  643. vol.flash.read(&vol.flash,
  644.        unitBaseAddress(&vol, *bootBlock) +
  645.        (i << SECTOR_SIZE_BITS) + CIS_DATA_OFFSET,
  646.        &invalidDataFlag, sizeof invalidDataFlag, EXTRA);
  647. if (invalidDataFlag == 0xff)
  648.   return SSFDC_FORMAT;
  649.       }
  650.     }
  651.   }
  653.   return BAD_FORMAT;
  654. }
  657. /*----------------------------------------------------------------------*/
  658. /*               i s E r a s e d s e c t o r  */
  659. /* */
  660. /* Check if a sector is erased. */
  661. /* */
  662. /* Parameters:                                                          */
  663. /* vol : Pointer identifying drive */
  664. /*  unitNo : The sector to check is in this unit. */
  665. /* offset : Offset of the sector in the unit. */
  666. /*                                                                      */
  667. /* Returns:                                                             */
  668. /* TRUE if the sector is erased, otherwise FALSE */
  669. /*----------------------------------------------------------------------*/
  671. static FLBoolean isErasedSector(SSFDC vol, UnitNo unitNo, unsigned offset)
  672. {
  673.   unsigned char *buf;
  674.   StatusArea statusArea;
  675.   int i;
  677.   buf = (unsigned char *)vol.flash.map(&vol.flash,
  678.        unitBaseAddress(&vol, unitNo) +
  679.        offset, SECTOR_SIZE);
  681.   /* check data area */
  682.   for (i = 0; i < SECTOR_SIZE; i++)
  683.     if (buf[i] != 0xff)
  684.       return FALSE;
  686.   /* check status area */
  687.   vol.flash.read(&vol.flash,
  688.  unitBaseAddress(&vol, unitNo) + offset + STATUS_AREA_OFFSET,
  689.  &statusArea, sizeof statusArea, EXTRA);
  690.   if (statusArea.sectorStatus != 0xff)
  691.     return FALSE;
  693.   return TRUE;
  694. }
  697. /*----------------------------------------------------------------------*/
  698. /*               w r i t e A n d C h e c k  */
  699. /* */
  700. /* Write one sector. If eccMode is TRUE, calculate and write ECC. */
  701. /* */
  702. /* Parameters:                                                          */
  703. /* vol : Pointer identifying drive */
  704. /* address : Physical address of the sector to write to */
  705. /* fromAddress : Buffer of data to write */
  706. /* eccMode : If TRUE, calculate and write ECC */
  707. /*                                                                      */
  708. /* Returns:                                                             */
  709. /*  FLStatus  : 0 on success, failed otherwise. */
  710. /*----------------------------------------------------------------------*/
  712. static FLStatus writeAndCheck(SSFDC vol,
  713.       CardAddress address,
  714.       void FAR1 *fromAddress,
  715.       int eccMode)
  716. {
  717.   int sectorInUnit;
  718.   FLStatus status = vol.flash.write(&vol.flash,address,fromAddress,SECTOR_SIZE,0);
  721.   if (eccMode) {  /* calculate and write ECC */
  722.     unsigned char ecc[3];
  724.     createEcc((unsigned char FAR1 *)fromAddress, ecc);
  725.     status = vol.flash.write(&vol.flash, address + ECC1, ecc, sizeof ecc, EXTRA);
  726.     createEcc((unsigned char FAR1 *)fromAddress + SECTOR_SIZE / 2, ecc);
  727.     status = vol.flash.write(&vol.flash, address + ECC2, ecc, sizeof ecc, EXTRA);
  728.   }
  730.   if (status == flWriteFault) {   /* write failed, sector doesn't hold valid data. */
  731.     StatusArea statusArea = {0, 0xff};
  732.     vol.flash.write(&vol.flash, address + STATUS_AREA_OFFSET, &statusArea,
  733.     sizeof statusArea,EXTRA);
  734.   }
  736.   /* mark sector as assigned and not erased */
  737.   vol.physicalUnits[address >> vol.unitSizeBits].unitStatus--;
  738.   sectorInUnit = (address % (1 << vol.unitSizeBits)) / SECTOR_SIZE;
  739.   vol.physicalUnits[address >> vol.unitSizeBits].erasedSectors &= ~(1 << sectorInUnit);
  740.   return status;
  741. }
  744. /*----------------------------------------------------------------------*/
  745. /*                    m a p S e c t o r */
  746. /* */
  747. /* Maps and returns location of a given sector no. */
  748. /* NOTE: This function is used in place of a read-sector operation. */
  749. /* */
  750. /* A one-sector cache is maintained to save on map operations. */
  751. /* */
  752. /* Parameters:                                                          */
  753. /* vol : Pointer identifying drive */
  754. /* sectorNo : Sector no. to read */
  755. /* physAddress : Optional pointer to receive sector address */
  756. /*                                                                      */
  757. /* Returns:                                                             */
  758. /* Pointer to physical sector location. NULL returned if sector */
  759. /* does not exist, or holds invalid data. */
  760. /*----------------------------------------------------------------------*/
  762. static const void FAR0 *mapSector(SSFDC vol, SectorNo sectorNo, CardAddress *physAddress)
  763. {
  764.   if (sectorNo != vol.mappedSectorNo || vol.flash.socket->remapped) {
  765.     if (sectorNo >= vol.virtualSectors)
  766.       vol.mappedSector = NULL;
  767.     else {
  768.       vol.mappedSectorAddress = virtual2Physical(&vol, sectorNo);
  770.       if (vol.mappedSectorAddress == UNASSIGNED_ADDRESS)
  771. vol.mappedSector = NULL; /* no such sector */
  772.       else {
  773. vol.mappedSector = vol.flash.map(&vol.flash, vol.mappedSectorAddress, SECTOR_SIZE);
  774. #ifdef ECC_ON_READ
  775. if (!eccOnRead(&vol, sectorAddress))  /* check and fix errors */
  776.   return NULL; /* a non-fixable error  */
  777. #endif
  778.       }
  779.     }
  780.     vol.mappedSectorNo = sectorNo;
  781.     vol.flash.socket->remapped = FALSE;
  782.   }
  784.   if (physAddress)
  785.     *physAddress = vol.mappedSectorAddress;
  787.   return vol.mappedSector;
  788. }
  791. /*----------------------------------------------------------------------*/
  792. /*           f o r m a t U n i t */
  793. /* */
  794. /* Format one unit. Erase the unit, and mark the physical units table.  */
  795. /*                                                                      */
  796. /* Parameters:                                                          */
  797. /* vol : Pointer identifying drive */
  798. /* unitNo : Unit to format */
  799. /*                                                                      */
  800. /* Returns:                                                             */
  801. /* FLStatus        : 0 on success, failed otherwise */
  802. /*----------------------------------------------------------------------*/
  804. static FLStatus formatUnit(SSFDC vol, UnitNo unitNo)
  805. {
  806.   if (!(vol.physicalUnits[unitNo].unitStatus & UNIT_AVAILABLE))
  807.     return flWriteFault;
  809.   if (((vol.physicalUnits[unitNo].unitStatus & STATUS_MASK) == UNIT_FREE) ||
  810.       ((vol.physicalUnits[unitNo].unitStatus & STATUS_MASK) == UNIT_ERASED))
  811.     vol.freeUnits--;
  813.   vol.physicalUnits[unitNo].unitStatus &= ~UNIT_AVAILABLE; /* protect the unit */
  815.   checkStatus(vol.flash.erase(&vol.flash,
  816.       unitNo << (vol.unitSizeBits - vol.erasableBlockSizeBits),
  817.       1 << (vol.unitSizeBits - vol.erasableBlockSizeBits)));
  819.   /* mark unit erased */
  820.   vol.physicalUnits[unitNo].unitStatus = UNIT_ERASED | vol.sectorsPerUnit;
  821. /* VF: Updated next line: */
  822. #if (TFFS_SECTORS_PER_UNIT < 32)  /* VF */
  823.   vol.physicalUnits[unitNo].erasedSectors = 0xffff;  /* all sectors are erased */
  824. #else
  825.   vol.physicalUnits[unitNo].erasedSectors = 0xffffffff;  /* all sectors are erased */
  826. #endif
  827.   vol.freeUnits++;
  829.   return flOK;
  830. }
  833. /*----------------------------------------------------------------------*/
  834. /*            a s s i g n U n i t */
  835. /* */
  836. /* Assigns a virtual unit no. to a unit */
  837. /*                                                                      */
  838. /* Parameters:                                                          */
  839. /* vol : Pointer identifying drive */
  840. /* unitNo : Physical unit number */
  841. /* virtualUnitNo : Virtual unit number to assign */
  842. /*                                                                      */
  843. /* Returns:                                                             */
  844. /* FLStatus : 0 on success, failed otherwise */
  845. /*----------------------------------------------------------------------*/
  847. static FLStatus assignUnit(SSFDC vol, UnitNo unitNo, UnitNo virtualUnitNo)
  848. {
  849.   unsigned char blockAddressArea[2], parityBit = 1; /* bit 12 is always 1 */
  850.   FLStatus status;
  851.   UnitNo un;
  852.   unsigned sector;
  854.   /* create the block address area */
  855.   /* calculate parity bit */
  856.   for (un = virtualUnitNo; un; un >>= 1)
  857.     parityBit ^= un & 0x01;
  858.   blockAddressArea[0] = (virtualUnitNo >> 7) | 0x10;
  859.   blockAddressArea[1] = (virtualUnitNo << 1) | parityBit;
  862.   /* write the block address to the block address areas in all the sectors
  863.      of the unit.*/
  864.   for (sector = 0; sector < vol.sectorsPerUnit; sector++) {
  865.     CardAddress sectorAddress;
  867.     sectorAddress = unitBaseAddress(&vol, unitNo) + (sector << SECTOR_SIZE_BITS);
  869.     /* write to first address area */
  870.     status = vol.flash.write(&vol.flash, sectorAddress + BLOCK_ADDRESS_OFFSET1,
  871.      &blockAddressArea, sizeof blockAddressArea, EXTRA);
  872.     if (status == flOK)
  873.       /* write to second address area */
  874.       status = vol.flash.write(&vol.flash, sectorAddress + BLOCK_ADDRESS_OFFSET2,
  875.        &blockAddressArea, sizeof blockAddressArea, EXTRA);
  877.     if (status != flOK) {  /* write failed, mark unit as bad */
  878.       vol.physicalUnits[unitNo].unitStatus &= ~STATUS_MASK;
  879.       vol.physicalUnits[unitNo].unitStatus |= UNIT_BAD;
  880.       vol.freeUnits--;
  881.       return status;
  882.     }
  883.   }
  885.   /* mark unit assigned */
  886.   vol.physicalUnits[unitNo].unitStatus &= ~STATUS_MASK;
  887.   vol.physicalUnits[unitNo].unitStatus |= UNIT_AVAILABLE;
  888.   vol.freeUnits--;
  889.   vol.virtualUnits[virtualUnitNo] = unitNo;
  891.   return flOK;
  892. }
  895. /*----------------------------------------------------------------------*/
  896. /*            f i n i s h U n i t T r a n s f e r */
  897. /* */
  898. /* Finish unit transfer from replaced unit to transfer unit. */
  899. /* copy all the sectors that were not replaced from the replaced unit   */
  900. /* to the transfer unit. This routine is called when either another */
  901. /* unit needs replacement, or we finished the current Flie function. */
  902. /*                                                                      */
  903. /* Parameters:                                                          */
  904. /* vol : Pointer identifying drive */
  905. /*                                                                      */
  906. /* Returns:                                                             */
  907. /* FLStatus : 0 on success, failed otherwise */
  908. /*----------------------------------------------------------------------*/
  910. static FLStatus finishUnitTransfer(SSFDC vol)
  911. {
  912.   unsigned char ecc[3];
  913.   UnitNo virtualUnitNo;
  914.   unsigned freeSectors = 0, sector;  /* count the number of free sectors */
  916.   if (vol.replacedUnit == NO_UNIT) /* no unit to fold */
  917.     return flOK;
  919.   for (sector = 0; sector < vol.sectorsPerUnit; sector++) {
  920.     if (vol.replacementSectors[sector] == SECTOR_ALLOCATED) { /* copy only sectors
  921.  that holds valid data */
  922.       CardAddress fromSectorAddress, toSectorAddress;
  924.       fromSectorAddress = unitBaseAddress(&vol, vol.replacedUnit) +
  925.   (sector << SECTOR_SIZE_BITS);
  926.       toSectorAddress = unitBaseAddress(&vol, vol.transferUnit) +
  927. (sector << SECTOR_SIZE_BITS);
  929.       vol.flash.read(&vol.flash, fromSectorAddress, ssfdcBuffer,SECTOR_SIZE,0);
  930.       vol.flash.socket->remapped = TRUE;
  931.       checkStatus(writeAndCheck(&vol, toSectorAddress, ssfdcBuffer, 0));
  932.       /* copy ecc fields instead of recalculating them */
  933.       vol.flash.read(&vol.flash, fromSectorAddress + ECC1, ecc, sizeof ecc, EXTRA);
  934.       checkStatus(vol.flash.write(&vol.flash, toSectorAddress + ECC1, ecc,
  935.   sizeof ecc, EXTRA));
  936.       vol.flash.read(&vol.flash, fromSectorAddress + ECC2, ecc, sizeof ecc, EXTRA);
  937.       checkStatus(vol.flash.write(&vol.flash, toSectorAddress + ECC2, ecc,
  938.   sizeof ecc, EXTRA));
  940.     }
  941.     if ((vol.replacementSectors[sector] == SECTOR_ERASED) ||
  942. (vol.replacementSectors[sector] == SECTOR_DELETED1))
  943.       freeSectors++;
  944.   }
  946.   /* the old transfer unit gets the virtual number of the replaced unit */
  947.   virtualUnitNo = physical2Virtual(&vol, vol.replacedUnit, OFFSET1);
  948.   if (virtualUnitNo >= vol.noOfVirtualUnits) {
  949.     /* first address area is not good try the second address area */
  950.     virtualUnitNo = physical2Virtual(&vol, vol.replacedUnit, OFFSET2);
  951.     if (virtualUnitNo >= vol.noOfVirtualUnits)
  952.       return flGeneralFailure;
  953.   }
  955.   if (freeSectors < vol.sectorsPerUnit) {
  956.     checkStatus(assignUnit(&vol, vol.transferUnit, virtualUnitNo));
  957.     checkStatus(formatUnit(&vol, vol.replacedUnit));
  958.     vol.transferUnit = vol.replacedUnit;  /* The old transfer unit is dead,
  959.      long live the new one */
  960.   }
  962.   vol.replacedUnit = NO_UNIT;
  964.   return flOK;
  965. }
  968. /*----------------------------------------------------------------------*/
  969. /*                    t l s e t B u s y */
  970. /* */
  971. /* Notifies the start and end of a file-system operation. */
  972. /* On exit, finish unit transfer (if necessary). */
  973. /* */
  974. /* Parameters:                                                          */
  975. /* vol : Pointer identifying drive */
  976. /*      state : TFFS_ON (1) = operation entry */
  977. /*   TFFS_OFF(0) = operation exit */
  978. /*                                                                      */
  979. /*----------------------------------------------------------------------*/
  981. static void tlSetBusy(SSFDC vol, FLBoolean state)
  982. {
  983.   if (state == TFFS_ON)
  984.     vol.replacedUnit = NO_UNIT;  /* in case we exit without doing anything */
  985.   else
  986.     finishUnitTransfer(&vol);  /* I ignore the returned status */
  987. }
  990. /*----------------------------------------------------------------------*/
  991. /*                    s e t R e p l a c e m e n t U n i t */
  992. /* */
  993. /* Set a replaced unit. From now on, if write inplace to this unit */
  994. /* is impossible, write to the transfer unit instead. this routine */
  995. /* reads the status of each sector in the unit and updates the replaced */
  996. /* sectors table. */
  997. /* */
  998. /* Parameters:                                                          */
  999. /* vol : Pointer identifying drive */
  1000. /*  unitNo : The new replaced unit */
  1001. /*                                                                      */
  1002. /*----------------------------------------------------------------------*/
  1004. static void setReplacementUnit(SSFDC vol, UnitNo unitNo)
  1005. {
  1006.   int iSector;
  1007.   StatusArea statusArea;
  1009.   vol.replacedUnit = unitNo;
  1010.   vol.sectorsDeleted = 0;
  1011.   for (iSector = 0; (unsigned)iSector < vol.sectorsPerUnit; iSector++) {
  1012.     vol.flash.read(&vol.flash, unitBaseAddress(&vol, unitNo) + (iSector << SECTOR_SIZE_BITS) +
  1013.    STATUS_AREA_OFFSET, &statusArea, sizeof statusArea, EXTRA);
  1014.     if (statusArea.sectorStatus != 0xff) {
  1015.       vol.replacementSectors[iSector] = SECTOR_DELETED1;
  1016.       vol.sectorsDeleted++;
  1017.       continue;
  1018.     }
  1020.     if (vol.physicalUnits[unitNo].erasedSectors & (1 << iSector))
  1021.       vol.replacementSectors[iSector] = SECTOR_ERASED;
  1022.     else
  1023.       vol.replacementSectors[iSector] = SECTOR_ALLOCATED;
  1024.   }
  1025. }
  1028. /*----------------------------------------------------------------------*/
  1029. /*                    m a r k S e c t o r D e l e t e d */
  1030. /* */
  1031. /* Mark a sector as deleted on the media, and update the unassigned */
  1032. /* sectors counter in the physical units table. */
  1033. /* */
  1034. /* Parameters:                                                          */
  1035. /* vol : Pointer identifying drive */
  1036. /*  unitNo : The sector is in this unit */
  1037. /* unitOffset : The offset of the sector in the unit */
  1038. /*                                                                      */
  1039. /* Returns: */
  1040. /* FLStatus        : 0 on success, failed otherwise */
  1041. /*----------------------------------------------------------------------*/
  1043. static FLStatus markSectorDeleted(SSFDC vol, UnitNo unitNo, unsigned unitOffset)
  1044. {
  1045.   StatusArea statusArea;
  1047.   /* check if this sector is already deleted or erased */
  1048.   vol.flash.read(&vol.flash, unitBaseAddress(&vol, unitNo) +
  1049.      unitOffset + STATUS_AREA_OFFSET,
  1050.  &statusArea, sizeof statusArea, EXTRA);
  1051.   if ((statusArea.sectorStatus != 0xff) ||
  1052.       (vol.physicalUnits[unitNo].erasedSectors & (1 << (unitOffset / SECTOR_SIZE))))
  1053.     return flOK;    /* sector is erased or already deleted */
  1055.   statusArea.sectorStatus = 0;
  1056.   statusArea.unitStatus = 0xff;
  1058.   vol.physicalUnits[unitNo].unitStatus++;
  1059.   return vol.flash.write(&vol.flash, unitBaseAddress(&vol, unitNo) +
  1060.      unitOffset + STATUS_AREA_OFFSET,
  1061.  &statusArea, sizeof statusArea, EXTRA);
  1062. }
  1065. /*----------------------------------------------------------------------*/
  1066. /*                    a l l o c a t e U n i t */
  1067. /* */
  1068. /* Find a free unit to allocate, erase it if necessary. */
  1069. /* */
  1070. /* Parameters:                                                          */
  1071. /* vol : Pointer identifying drive */
  1072. /*  unitNo : Receives the physical number of the allocated */
  1073. /*   unit  */
  1074. /* Returns: */
  1075. /* FLStatus : 0 on success, failed otherwise */
  1076. /*----------------------------------------------------------------------*/
  1078. static FLStatus allocateUnit(SSFDC vol, UnitNo *unitNo)
  1079. {
  1080.   UnitNo originalUnit = vol.roverUnit;
  1082.   if (vol.freeUnits > 1) {    /* the transfer unit is always free */
  1083.     do {
  1084. /* VF: Take 8- vs. 16-bit PhysUnit quantity into account: */
  1085. #if (TFFS_SECTORS_PER_UNIT < 32)
  1086.       unsigned char unitFlags;
  1087. #else
  1088.       unsigned short unitFlags;
  1089. #endif
  1091.       if (++vol.roverUnit == vol.transferUnit) /* we don't want to allocate this one */
  1092. vol.roverUnit++;
  1093.       if (vol.roverUnit >= vol.noOfUnits)  /* we got to the end, wrap around */
  1094. vol.roverUnit = vol.CISblock;
  1096.       unitFlags = vol.physicalUnits[vol.roverUnit].unitStatus;
  1098.       if (((unitFlags & STATUS_MASK) == UNIT_FREE) ||
  1099.   ((unitFlags & STATUS_MASK) == UNIT_ERASED)) {
  1100. if ((unitFlags & STATUS_MASK) == UNIT_FREE)
  1101.   checkStatus(formatUnit(&vol, vol.roverUnit));
  1103. *unitNo = vol.roverUnit;
  1104. return flOK;
  1105.       }
  1106.     } while (vol.roverUnit != originalUnit);
  1108.     return flGeneralFailure;  /* Didn't find the free units */
  1109.   }
  1111.   return flNotEnoughMemory;
  1112. }
  1115. #if defined(DEFRAGMENT_VOLUME) || defined(SINGLE_BUFFER)
  1117. /*----------------------------------------------------------------------*/
  1118. /*                   d e f r a g m e n t */
  1119. /* */
  1120. /* Performs unit allocations to arrange a minimum number of writable */
  1121. /* sectors.                                                             */
  1122. /* */
  1123. /* Parameters:                                                          */
  1124. /* vol : Pointer identifying drive */
  1125. /* sectorsNeeded : Minimum required sectors */
  1126. /*                                                                      */
  1127. /* Returns:                                                             */
  1128. /* FLStatus : 0 on success, failed otherwise */
  1129. /*----------------------------------------------------------------------*/
  1131. static FLStatus defragment(SSFDC vol, long FAR2 *sectorsNeeded)
  1132. {
  1133.   UnitNo erasedUnits = 0, dummyUnit;
  1135.   while (erasedUnits * vol.sectorsPerUnit < *sectorsNeeded) {
  1136.     if (vol.badFormat)
  1137.       return flBadFormat;
  1139.     checkStatus(allocateUnit(&vol, &dummyUnit));
  1140.     erasedUnits++;
  1141.   }
  1143.   *sectorsNeeded = erasedUnits * vol.sectorsPerUnit;
  1145.   return flOK;
  1146. }
  1148. #endif
  1151. /*----------------------------------------------------------------------*/
  1152. /*            a l l o c a t e A n d W r i t e S e c t o r */
  1153. /* */
  1154. /* Write to virtual sectorNo. If sectorsNo is not assigned to any  */
  1155. /* physical sector, allocate a new one and write it there. If sectorNo  */
  1156. /* is assigned, try to write in place, if impossible, replace this      */
  1157. /* sector in the transfer unit (finish the previous unit transfer       */
  1158. /* first).  */
  1159. /* */
  1160. /* Parameters:                                                          */
  1161. /* vol : Pointer identifying drive */
  1162. /* sectorNo : Virtual sector no. to write */
  1163. /* fromAddress : Address of sector data.  */
  1164. /*                                                                      */
  1165. /* Returns:                                                             */
  1166. /* FLStatus : 0 on success, failed otherwise */
  1167. /*----------------------------------------------------------------------*/
  1169. static FLStatus allocateAndWriteSector(SSFDC vol,
  1170.        SectorNo sectorNo,
  1171.        void FAR1 *fromAddress)
  1172. {
  1173.   UnitNo virtualUnitNo = sectorNo / vol.sectorsPerUnit;
  1174.   UnitNo unitNo = vol.virtualUnits[virtualUnitNo];
  1175.   unsigned sectorInUnit = sectorNo % vol.sectorsPerUnit;
  1176.   unsigned unitOffset = sectorInUnit << SECTOR_SIZE_BITS;
  1179.   /* Find a unit to write this sector */
  1180.   if ((unitNo != NO_UNIT) &&
  1181.       ((vol.physicalUnits[unitNo].unitStatus & STATUS_MASK) == UNIT_AVAILABLE)) {
  1182.     if (vol.replacedUnit == unitNo) {
  1183.       /* this unit is replaced by the transfer unit */
  1184.       if ((vol.replacementSectors[sectorInUnit] == SECTOR_REPLACED) ||
  1185.   (vol.replacementSectors[sectorInUnit] == SECTOR_DELETED2)) {
  1186. /* this sector was already replaced */
  1187. UnitNo oldTransferUnit = vol.transferUnit;
  1189. checkStatus(finishUnitTransfer(&vol));
  1190. setReplacementUnit(&vol, oldTransferUnit);
  1191.       }
  1193.       if (vol.replacementSectors[sectorInUnit] != SECTOR_ERASED)  {
  1194. /* write to the transfer unit, mark deleted in the replaced unit, and
  1195.    mark replaced in the replaced sectors table. */
  1196. checkStatus(writeAndCheck(&vol, unitBaseAddress(&vol, vol.transferUnit) +
  1197. unitOffset,
  1198.   fromAddress, 1))
  1199. checkStatus(markSectorDeleted(&vol, vol.replacedUnit, unitOffset));
  1200. vol.replacementSectors[sectorInUnit] = SECTOR_REPLACED;
  1201.       }
  1202.       else {   /* sector erased, write inplace */
  1203. checkStatus(writeAndCheck(&vol, unitBaseAddress(&vol, vol.replacedUnit) +
  1204. unitOffset,
  1205.   fromAddress, 1));
  1206. vol.replacementSectors[sectorInUnit] = SECTOR_ALLOCATED;
  1207.       }
  1208.     }
  1209.     else {
  1210.       if (vol.physicalUnits[unitNo].erasedSectors &
  1211.   (1 << (unitOffset / SECTOR_SIZE))) {
  1212. /* sector is erased, write inplace */
  1213. checkStatus(writeAndCheck(&vol, unitBaseAddress(&vol, unitNo) + unitOffset,
  1214.   fromAddress, 1));
  1215.       }
  1216.       else {
  1217. /* finish the previous transfer first */
  1218. checkStatus(finishUnitTransfer(&vol));
  1219. setReplacementUnit(&vol, unitNo);
  1220. /* write to the transfer unit, mark deleted in the replaced unit, and
  1221.    mark replaced in the replaced sectors table. */
  1222. checkStatus(writeAndCheck(&vol, unitBaseAddress(&vol, vol.transferUnit) +
  1223. unitOffset,
  1224.   fromAddress, 1))
  1225. checkStatus(markSectorDeleted(&vol, vol.replacedUnit, unitOffset));
  1226. vol.replacementSectors[sectorInUnit] = SECTOR_REPLACED;
  1227.       }
  1228.     }
  1229.   }
  1230.   else {
  1231.     /* this sector is unassigned, find a free unit and write the sector there */
  1232.     UnitNo toUnit;
  1234.     checkStatus(allocateUnit(&vol, &toUnit));
  1236.     checkStatus(writeAndCheck(&vol, unitBaseAddress(&vol, toUnit) + unitOffset,
  1237.       fromAddress, 1));
  1238.     checkStatus(assignUnit(&vol, toUnit, virtualUnitNo));
  1239.   }
  1241.   return flOK;
  1242. }
  1245. /*----------------------------------------------------------------------*/
  1246. /*                d e l e t e S e c t o r */
  1247. /* */
  1248. /* Marks contiguous sectors as deleted. */
  1249. /* Update unassigned sectors counter in physical units table, and */
  1250. /* deleted replaced sectors table. If all the sectors in a unit are     */
  1251. /* deleted, mark it as free. */
  1252. /* */
  1253. /* Parameters:                                                          */
  1254. /* vol : Pointer identifying drive */
  1255. /* sectorNo : First sector no. to delete */
  1256. /* noOfSectors : No. of sectors to delete */
  1257. /*                                                                      */
  1258. /* Returns:                                                             */
  1259. /* FLStatus : 0 on success, failed otherwise */
  1260. /*----------------------------------------------------------------------*/
  1262. static FLStatus deleteSector(SSFDC vol, SectorNo sectorNo, int noOfSectors)
  1263. {
  1264.   int iSector;
  1266.   if (vol.badFormat)
  1267.     return flBadFormat;
  1268.   if (sectorNo + noOfSectors > vol.virtualSectors)
  1269.     return flSectorNotFound;
  1271.   for (iSector = 0; iSector < noOfSectors; iSector++, sectorNo++) {
  1272.     unsigned sectorInUnit = sectorNo % vol.sectorsPerUnit;
  1273.     CardAddress sectorAddress = virtual2Physical(&vol, sectorNo);
  1275.     if (sectorAddress != UNASSIGNED_ADDRESS) {
  1276.       UnitNo virtualUnitNo = sectorNo / vol.sectorsPerUnit;
  1277.       UnitNo unitNo = vol.virtualUnits[virtualUnitNo];
  1279.       if (!(vol.physicalUnits[unitNo].unitStatus & UNIT_AVAILABLE) ||
  1280.   (unitNo == NO_UNIT))
  1281. return flSectorNotFound;
  1283.       if (unitNo == vol.replacedUnit) {
  1284. /* this sector was replaced, mark it in the transfer unit, and
  1285.    update the repleced sectors table. */
  1286. if (vol.replacementSectors[sectorInUnit] == SECTOR_REPLACED) {
  1287.   checkStatus(markSectorDeleted(&vol, vol.transferUnit,
  1288. sectorInUnit << SECTOR_SIZE_BITS));
  1289.   vol.replacementSectors[sectorInUnit] = SECTOR_DELETED2;
  1290. }
  1291. else {
  1292.   checkStatus(markSectorDeleted(&vol, unitNo,
  1293. sectorInUnit << SECTOR_SIZE_BITS));
  1294.   vol.replacementSectors[sectorInUnit] = SECTOR_DELETED1;
  1295. }
  1296. if (++vol.sectorsDeleted >= vol.sectorsPerUnit) {
  1297.   /* all the sectors in the replaced unit are deleted, no point
  1298.      to keep their deleted copy in the transfer unit. */
  1299.   checkStatus(formatUnit(&vol, vol.transferUnit));
  1300.   vol.physicalUnits[vol.replacedUnit].unitStatus &= ~STATUS_MASK;
  1301.   vol.physicalUnits[vol.replacedUnit].unitStatus |= UNIT_FREE;
  1302.   vol.virtualUnits[virtualUnitNo] = NO_UNIT;
  1303.   vol.replacedUnit = NO_UNIT;
  1304.   vol.freeUnits++;
  1305. }
  1306.       }
  1307.       else {  /* this sector is not in the replaced unit */
  1308. checkStatus(markSectorDeleted(&vol, unitNo,
  1309.       sectorInUnit << SECTOR_SIZE_BITS));
  1310. if ((vol.physicalUnits[unitNo].unitStatus & ~STATUS_MASK) ==
  1311.      (int)vol.sectorsPerUnit) {
  1312.   /* all the sectors in this unit are unassigned, it can be marked
  1313.      as free. */
  1314.   vol.physicalUnits[unitNo].unitStatus &= ~STATUS_MASK;
  1315.   vol.physicalUnits[unitNo].unitStatus |= UNIT_FREE;
  1316.   vol.freeUnits++;
  1317.   vol.virtualUnits[virtualUnitNo] = NO_UNIT;
  1318. }
  1319.       }
  1320.     }
  1321.   }
  1323.   return flOK;
  1324. }
  1327. /*----------------------------------------------------------------------*/
  1328. /*                 w r i t e S e c t o r */
  1329. /* */
  1330. /* Writes a sector. */
  1331. /* */
  1332. /* Parameters:                                                          */
  1333. /* vol : Pointer identifying drive */
  1334. /* sectorNo : Sector no. to write */
  1335. /* fromAddress : Data to write */
  1336. /*                                                                      */
  1337. /* Returns:                                                             */
  1338. /* FLStatus        : 0 on success, failed otherwise */
  1339. /*----------------------------------------------------------------------*/
  1341. static FLStatus writeSector(SSFDC vol,SectorNo sectorNo, void FAR1 *fromAddress)
  1342. {
  1343.   FLStatus status;
  1344.   int i;
  1346.   if (vol.badFormat)
  1347.     return flBadFormat;
  1348.   if (sectorNo > vol.virtualSectors)
  1349.     return flSectorNotFound;
  1351.   status = flWriteFault;
  1352.   for (i = 0; i < 4 && status == flWriteFault; i++) {
  1353.     if (vol.mappedSectorNo == sectorNo)
  1354.       vol.mappedSectorNo = UNASSIGNED_SECTOR;
  1355.     status = allocateAndWriteSector(&vol,sectorNo,fromAddress);
  1356.   }
  1358.   return status;
  1359. }
  1362. /*----------------------------------------------------------------------*/
  1363. /*            m o u n t U n i t */
  1364. /* */
  1365. /* Mount one unit. Get the unit status (assigned, free or bad) and  */
  1366. /* update the tables. */
  1367. /*                                                                      */
  1368. /* Parameters:                                                          */
  1369. /* vol : Pointer identifying drive */
  1370. /* unitNo : Unit to mount */
  1371. /*                                                                      */
  1372. /* Returns:                                                             */
  1373. /* FLStatus : 0 on success, failed otherwise */
  1374. /*----------------------------------------------------------------------*/
  1376. static FLStatus mountUnit(SSFDC vol, UnitNo unitNo)
  1377. {
  1378.   StatusArea statusArea;
  1379.   UnitNo virtualUnitNo;
  1381.   /* initialize unassigned sectors counter */
  1382.   vol.physicalUnits[unitNo].unitStatus &= STATUS_MASK;
  1384.   vol.flash.read(&vol.flash, unitBaseAddress(&vol, unitNo) + STATUS_AREA_OFFSET,
  1385.  &statusArea, sizeof statusArea, EXTRA);
  1387.   if (statusArea.unitStatus != 0xff) {
  1388.     vol.physicalUnits[unitNo].unitStatus &= ~STATUS_MASK;
  1389.     vol.physicalUnits[unitNo].unitStatus |= UNIT_BAD;
  1390.     return flOK;
  1391.   }
  1393.   virtualUnitNo = physical2Virtual(&vol, unitNo, OFFSET1);
  1395.   if (virtualUnitNo >= vol.noOfVirtualUnits) {
  1396.     vol.physicalUnits[unitNo].unitStatus = UNIT_FREE | vol.sectorsPerUnit;
  1397.     vol.freeUnits++;
  1398.   }
  1399.   else {
  1400.     if (vol.virtualUnits[virtualUnitNo] != NO_UNIT) {
  1401.     /* there is another unit with this virtual address */
  1402.       vol.physicalUnits[unitNo].unitStatus = UNIT_FREE | vol.sectorsPerUnit;
  1403.       vol.freeUnits++;
  1404.     }
  1405.     else {  /* this unit is assigned */
  1406.       CardAddress unitBase;
  1407.       unsigned sector;
  1409.       vol.physicalUnits[unitNo].unitStatus &= ~STATUS_MASK;
  1410.       vol.physicalUnits[unitNo].unitStatus |= UNIT_AVAILABLE;
  1411.       vol.virtualUnits[virtualUnitNo] = unitNo;
  1413.       /* count the number of unassigned sectors and mark erased sectors */
  1414.       vol.physicalUnits[unitNo].erasedSectors = 0;
  1415.       unitBase = unitBaseAddress(&vol, unitNo);
  1416.       for (sector = 0; sector < vol.sectorsPerUnit; sector++) {
  1417. vol.flash.read(&vol.flash, unitBase + (sector << SECTOR_SIZE_BITS) +
  1418.    STATUS_AREA_OFFSET,
  1419.        &statusArea, sizeof statusArea, EXTRA);
  1420. if (statusArea.sectorStatus != 0xff)
  1421.   vol.physicalUnits[unitNo].unitStatus++;
  1422. else if (isErasedSector(&vol, unitNo, sector << SECTOR_SIZE_BITS)) {
  1423.   vol.physicalUnits[unitNo].unitStatus++;
  1424.   vol.physicalUnits[unitNo].erasedSectors |= (1 << sector);
  1425. }
  1426.       }
  1428.       /* check if all the sectors are unassigned */
  1429.       if ((vol.physicalUnits[unitNo].unitStatus & ~STATUS_MASK) ==
  1430.    (int)vol.sectorsPerUnit) {
  1431. vol.physicalUnits[unitNo].unitStatus &= ~STATUS_MASK;
  1432. vol.physicalUnits[unitNo].unitStatus |= UNIT_FREE;
  1433. vol.virtualUnits[virtualUnitNo] = NO_UNIT;
  1434. vol.freeUnits++;
  1435.       }
  1436.     }
  1437.   }
  1440.   /* prepare a transfer unit */
  1441.   if (((vol.physicalUnits[unitNo].unitStatus & STATUS_MASK) == UNIT_FREE) &&
  1442.       (vol.transferUnit == NO_UNIT)) {
  1443.     checkStatus (formatUnit(&vol, unitNo));
  1444.     vol.transferUnit = unitNo;
  1445.   }
  1448.   return flOK;
  1449. }
  1452. /*----------------------------------------------------------------------*/
  1453. /*                        i n i t S S F D C */
  1454. /* */
  1455. /* Initializes essential volume data as a preparation for mount or */
  1456. /* format. */
  1457. /* */
  1458. /* Parameters:                                                          */
  1459. /* vol : Pointer identifying drive */
  1460. /*                                                                      */
  1461. /* Returns:                                                             */
  1462. /* FLStatus : 0 on success, failed otherwise */
  1463. /*----------------------------------------------------------------------*/
  1465. static FLStatus initSSFDC(SSFDC vol)
  1466. {
  1467.   long int size = 1;
  1469.   if (!(vol.flash.flags & NFTL_ENABLED)) {
  1470.   #ifdef DEBUG_PRINT
  1471.     DEBUG_PRINT("Debug: media is not fit for SSFDC format.n");
  1472.   #endif
  1473.     return flUnknownMedia;
  1474.   }
  1476.   vol.physicalUnits = NULL;
  1477.   vol.virtualUnits = NULL;
  1479.   for (vol.erasableBlockSizeBits = 0; size < vol.flash.erasableBlockSize;
  1480.        vol.erasableBlockSizeBits++, size <<= 1);
  1481.   vol.unitSizeBits = vol.erasableBlockSizeBits;
  1482.   vol.noOfUnits = (vol.flash.noOfChips * vol.flash.chipSize) >> vol.unitSizeBits;
  1484.   vol.badFormat = TRUE; /* until mount completes*/
  1485.   vol.mappedSectorNo = UNASSIGNED_SECTOR;
  1486.   /*get pointer to buffer (we assume SINGLE_BUFFER is not defined) */
  1487.   vol.buffer = flBufferOf(flSocketNoOf(vol.flash.socket));
  1489.   return flOK;
  1490. }
  1493. /*----------------------------------------------------------------------*/
  1494. /*                   i n i t T a b l e s */
  1495. /* */
  1496. /* Allocates and initializes the dynamic volume table, including the */
  1497. /* unit tables and secondary virtual map. */
  1498. /* */
  1499. /* Parameters:                                                          */
  1500. /* vol : Pointer identifying drive */
  1501. /*                                                                      */
  1502. /* Returns:                                                             */
  1503. /* FLStatus : 0 on success, failed otherwise */
  1504. /*----------------------------------------------------------------------*/
  1506. static FLStatus initTables(SSFDC vol)
  1507. {
  1508.   /* Allocate the conversion tables */
  1509. #ifdef MALLOC_TFFS
  1510.   vol.physicalUnits = (Unit *) MALLOC_TFFS(vol.noOfUnits * sizeof(Unit));
  1511.   vol.virtualUnits = (UnitNo *) MALLOC_TFFS(vol.noOfVirtualUnits * sizeof(UnitNo));
  1512.   vol.replacementSectors = (unsigned char *)
  1513.    MALLOC_TFFS(vol.sectorsPerUnit * sizeof(unsigned char));
  1515.   if (vol.physicalUnits == NULL ||
  1516.       vol.virtualUnits == NULL ||
  1517.       vol.replacementSectors == NULL) {
  1518.   #ifdef DEBUG_PRINT
  1519.     DEBUG_PRINT("Debug: Failed allocating conversion tables for SSFDC.n");
  1520.   #endif
  1521.     return flNotEnoughMemory;
  1522.   }
  1523. #else
  1524.   char *heapPtr;
  1526.   heapPtr = vol.heap;
  1527.   vol.physicalUnits = (Unit *) heapPtr;
  1528.   heapPtr += vol.noOfUnits * sizeof(Unit);
  1529.   vol.virtualUnits = (UnitNo *) heapPtr;
  1530.   heapPtr += vol.noOfVirtualUnits * sizeof(UnitNo);
  1531.   vol.replacementSectors = (unsigned char *) heapPtr;
  1532.   heapPtr += vol.sectorsPerUnit * sizeof(unsigned char);
  1534.   if (heapPtr > vol.heap + sizeof vol.heap) {
  1535.   #ifdef DEBUG_PRINT
  1536.     DEBUG_PRINT("Debug: Not enough memory for SSFDC conversion tables.n");
  1537.   #endif
  1538.     return flNotEnoughMemory;
  1539.   }
  1540. #endif
  1542.   return flOK;
  1543. }
  1545. /*----------------------------------------------------------------------*/
  1546. /*                d i s m o u n t S S F D C */
  1547. /* */
  1548. /* Dismount SSFDC volume */
  1549. /* */
  1550. /* Parameters:                                                          */
  1551. /* vol : Pointer identifying drive */
  1552. /* */
  1553. /*----------------------------------------------------------------------*/
  1555. static void dismountSSFDC(SSFDC vol)
  1556. {
  1557.   finishUnitTransfer(&vol);  /* copy replaced sectors if needed */
  1558. #ifdef MALLOC_TFFS
  1559.   FREE_TFFS(vol.physicalUnits);
  1560.   FREE_TFFS(vol.virtualUnits);
  1561.   FREE_TFFS(vol.replacementSectors);
  1562. #endif
  1563. }
  1566. /*----------------------------------------------------------------------*/
  1567. /*                      m o u n t S S F D C */
  1568. /* */
  1569. /* Mount the volume */
  1570. /* */
  1571. /* Parameters:                                                          */
  1572. /* flash : Flash media to mount */
  1573. /* tl : Mounted translation layer on exit */
  1574. /*      volForCallback : Pointer to FLFlash structure for power on */
  1575. /*   callback routine. */
  1576. /*                                                                      */
  1577. /* Returns:                                                             */
  1578. /* FLStatus : 0 on success, failed otherwise */
  1579. /*----------------------------------------------------------------------*/
  1581. /*static*/ FLStatus mountSSFDC(FLFlash *flash, TL *tl, FLFlash **volForCallback)
  1582. {
  1583.   SSFDC vol = &vols[flSocketNoOf(flash->socket)];
  1584.   UnitNo iUnit;
  1586. #ifdef DEBUG_PRINT
  1587.   DEBUG_PRINT("Debug: starting SSFDC mount.n");
  1588. #endif
  1589.   vol.replacedUnit = NO_UNIT; /* this is for finishUnitTransfer in case mount fails */
  1590.   vol.flash = *flash;
  1591.   *volForCallback = &vol.flash;
  1592.   checkStatus(initSSFDC(&vol));
  1594.   vol.sectorsPerUnit = 1 << (vol.unitSizeBits - SECTOR_SIZE_BITS);
  1596.   if (identifyFormat(&vol, &vol.CISblock) != SSFDC_FORMAT) {
  1597.   #ifdef DEBUG_PRINT
  1598.     DEBUG_PRINT("Debug: not SSFDC format.n");
  1599.   #endif
  1600.     return flUnknownMedia;
  1601.   }
  1603.   vol.virtualSectors = vol.sectorsPerUnit;
  1604.   if (vol.noOfUnits < 500)
  1605.     vol.virtualSectors *= 250;         /* 1 MByte chip        */
  1606.   else if (vol.noOfUnits < 1000)
  1607.     vol.virtualSectors *= 500;         /* 2 or 4 MByte chip   */
  1608.   else
  1609.     vol.virtualSectors *= 1000;        /* 8 0r 16 MByte chip  */
  1611.   vol.unitOffsetMask = (1L << vol.unitSizeBits) - 1;
  1613.   vol.noOfVirtualUnits = (vol.virtualSectors + vol.sectorsPerUnit - 1) /
  1614.  vol.sectorsPerUnit;
  1616.   if ((vol.virtualSectors >> (vol.unitSizeBits - SECTOR_SIZE_BITS)) >
  1617.       (unsigned long)(vol.noOfUnits - 1))
  1618.     return flBadFormat;
  1620.   checkStatus(initTables(&vol));
  1622.   vol.badFormat = FALSE;
  1623.   vol.transferUnit = NO_UNIT;
  1625.   for (iUnit = 0; iUnit < vol.noOfVirtualUnits; iUnit++)
  1626.     vol.virtualUnits[iUnit] = NO_UNIT;
  1628.   /* Mount all units */
  1629.   vol.freeUnits = 0;
  1630.   for (iUnit = vol.CISblock; iUnit < vol.noOfUnits; iUnit++) {
  1631.     if (iUnit == vol.CISblock)
  1632.       vol.physicalUnits[iUnit].unitStatus &= ~UNIT_AVAILABLE;
  1633.     else
  1634.       checkStatus(mountUnit(&vol, iUnit));
  1635.   }
  1638.   /* Initialize allocation rover */
  1639.   vol.roverUnit = vol.CISblock;
  1641.   tl->rec = &vol;
  1642.   tl->mapSector = mapSector;
  1643.   tl->writeSector = writeSector;
  1644.   tl->deleteSector = deleteSector;
  1645. #if defined(DEFRAGMENT_VOLUME) || defined(SINGLE_BUFFER)
  1646.   tl->defragment = defragment;
  1647. #endif
  1648. #ifdef FORMAT_VOLUME
  1649.   tl->sectorsInVolume = sectorsInVolume;
  1650. #endif
  1651.   tl->tlSetBusy = tlSetBusy;
  1652.   tl->dismount = dismountSSFDC;
  1654. #ifdef DEBUG_PRINT
  1655.   DEBUG_PRINT("Debug: finished SSFDC mount.n");
  1656. #endif
  1658.   return flOK;
  1659. }
  1662. #ifdef FORMAT_VOLUME
  1664. /*----------------------------------------------------------------------*/
  1665. /*                      i s E r a s e d U n i t */
  1666. /* */
  1667. /* Check if a unit is erased.                                           */
  1668. /* */
  1669. /* Parameters:                                                          */
  1670. /* vol : Pointer identifying drive */
  1671. /*                                                                      */
  1672. /* Returns:                                                             */
  1673. /* TRUE if unit is erased, FALSE otherwise */
  1674. /*----------------------------------------------------------------------*/
  1676. static FLBoolean isErasedUnit(SSFDC vol, UnitNo unitNo)
  1677. {
  1678.   CardAddress offset;
  1680.   for (offset = 0; (long)offset < (1L << vol.unitSizeBits); offset += SECTOR_SIZE)
  1681.     if (!(isErasedSector(&vol, unitNo, offset)))
  1682.       return FALSE;
  1684.   return TRUE;
  1685. }
  1688. /*----------------------------------------------------------------------*/
  1689. /*                     f o r m a t S S F D C */
  1690. /* */
  1691. /* Perform SSFDC Format. */
  1692. /* */
  1693. /* Parameters:                                                          */
  1694. /* flash : Flash media to format */
  1695. /* formatParams : Address of FormatParams structure to use */
  1696. /*                                                                      */
  1697. /* Returns:                                                             */
  1698. /* FLStatus : 0 on success, failed otherwise */
  1699. /*----------------------------------------------------------------------*/
  1701. /*static*/ FLStatus formatSSFDC(FLFlash *flash, FormatParams FAR1 *formatParams)
  1702. {
  1703.   SSFDC vol = &vols[flSocketNoOf(flash->socket)];
  1704.   long int unitSize;
  1705.   UnitNo iUnit;
  1706.   unsigned char CISblock[SECTOR_SIZE] = {CIS_DATA}, CISextra[16], ecc[3];
  1708. #ifdef DEBUG_PRINT
  1709.   DEBUG_PRINT("Debug: Starting SSFDC format.n");
  1710. #endif
  1712.   vol.replacedUnit = NO_UNIT; /* this is for finishUnitTransfer in case format fails */
  1713.   vol.flash = *flash;
  1714.   checkStatus(initSSFDC(&vol));
  1716.   vol.unitOffsetMask = (1L << vol.unitSizeBits) - 1;
  1717.   vol.sectorsPerUnit = 1 << (vol.unitSizeBits - SECTOR_SIZE_BITS);
  1719.   unitSize = 1L << vol.unitSizeBits;
  1721.   vol.virtualSectors = vol.sectorsPerUnit;
  1722.   if (vol.noOfUnits < 500)
  1723.     vol.virtualSectors *= 250;         /* 1 MByte chip        */
  1724.   else if (vol.noOfUnits < 1000)
  1725.     vol.virtualSectors *= 500;         /* 2 or 4 MByte chip   */
  1726.   else
  1727.     vol.virtualSectors *= 1000;        /* 8 0r 16 MByte chip  */
  1729.   vol.noOfVirtualUnits = (vol.virtualSectors + vol.sectorsPerUnit - 1) /
  1730.  vol.sectorsPerUnit;
  1732.   checkStatus(initTables(&vol));
  1734.   for (iUnit = 0; iUnit < vol.noOfVirtualUnits; iUnit++)
  1735.     vol.virtualUnits[iUnit] = NO_UNIT;
  1737.   /* Find the medium boot record and identify the format */
  1739.   if (identifyFormat(&vol, &vol.CISblock) != SSFDC_FORMAT) {
  1740.     /* not ssfdc format - scan it for bad blocks */
  1742.     /* Generate the bad unit table and find a place for the CIS */
  1743.     vol.CISblock = vol.noOfUnits;
  1744.     for (iUnit = 0; iUnit < vol.noOfUnits; iUnit++) {
  1745.       if (isErasedUnit(&vol, iUnit)) {
  1746. vol.physicalUnits[iUnit].unitStatus &= ~STATUS_MASK;
  1747. vol.physicalUnits[iUnit].unitStatus |= UNIT_ERASED;
  1748. if (vol.CISblock == vol.noOfUnits)
  1749.   vol.CISblock = iUnit;
  1750.       }
  1751.       else {
  1752. vol.physicalUnits[iUnit].unitStatus &= ~STATUS_MASK;
  1753. vol.physicalUnits[iUnit].unitStatus |= UNIT_BAD;
  1754.       }
  1755.     }
  1756.     if (vol.CISblock == vol.noOfUnits) {
  1757.     #ifdef DEBUG_PRINT
  1758.       DEBUG_PRINT("Debug: format failed, too many bad blocks.n");
  1759.     #endif
  1760.       return flGeneralFailure;
  1761.     }
  1762.   }
  1763.   else {  /* ssfdc format - read unit status from block status area */
  1764.     StatusArea statusArea;
  1766.     for (iUnit = 0; iUnit < vol.noOfUnits; iUnit++) {
  1767.       vol.flash.read(&vol.flash, unitBaseAddress(&vol, iUnit) + STATUS_AREA_OFFSET,
  1768.      &statusArea, sizeof statusArea, EXTRA);
  1769.       vol.physicalUnits[iUnit].unitStatus &= ~STATUS_MASK;
  1770.       vol.physicalUnits[iUnit].unitStatus |= (statusArea.unitStatus == 0xff)
  1771.     ? UNIT_FREE : UNIT_BAD;
  1772.     }
  1773.   }
  1775.   /* protect the CIS block */
  1776.   vol.physicalUnits[vol.CISblock].unitStatus &= ~UNIT_AVAILABLE;
  1778.   /* format all units */
  1779.   for (iUnit = vol.CISblock; iUnit < vol.noOfUnits; iUnit++) {
  1780.     FLStatus status = formatUnit(&vol, iUnit);
  1781.     if(status == flWriteFault) {
  1782.       if (iUnit != vol.CISblock)
  1783. if ((vol.physicalUnits[iUnit].unitStatus & STATUS_MASK) != UNIT_BAD) {
  1784.   vol.physicalUnits[iUnit].unitStatus &= ~STATUS_MASK;
  1785.   vol.physicalUnits[iUnit].unitStatus |= UNIT_BAD;
  1786. }
  1787.     }
  1788.     else if (status != flOK)
  1789.       return status;
  1790.   }
  1793.   /* Write the CIS block */
  1794.   vol.physicalUnits[vol.CISblock].unitStatus &= ~STATUS_MASK;
  1795.   vol.physicalUnits[vol.CISblock].unitStatus |= UNIT_FREE;     /* Unprotect it */
  1797.   checkStatus(formatUnit(&vol, vol.CISblock));
  1798.   checkStatus(vol.flash.write(&vol.flash, unitBaseAddress(&vol, vol.CISblock),
  1799.    CISblock, sizeof CISblock, 0));
  1801.   /* write extra bytes */
  1803.   createEcc(CISblock, ecc);
  1805.   tffsset(CISextra, 0xff, sizeof CISextra);
  1806.   CISextra[CIS_DATA_OFFSET+2] = CISextra[CIS_DATA_OFFSET+3] = 0;
  1807.   CISextra[ECC1] = CISextra[ECC2] = ecc[0];
  1808.   CISextra[ECC1+1] = CISextra[ECC2+1] = ecc[1];
  1809.   CISextra[ECC1+2] = CISextra[ECC2+2] = ecc[2];
  1810.   CISextra[ECC1-2] = CISextra[ECC1-1] = 0;
  1812.   checkStatus(vol.flash.write(&vol.flash, unitBaseAddress(&vol, vol.CISblock),
  1813.       CISextra, sizeof CISextra, EXTRA));
  1815.   /* Protect the CIS block */
  1816.   vol.physicalUnits[vol.CISblock].unitStatus &= ~UNIT_AVAILABLE;
  1818. #ifdef DEBUG_PRINT
  1819.   DEBUG_PRINT("Debug: finished SSFDC format.n");
  1820. #endif
  1821.   return flOK;
  1822. }
  1824. #endif /* FORMAT_VOLUME */
  1827. #if FLASE
  1828. /*----------------------------------------------------------------------*/
  1829. /*                f l R e g i s t e r S S F D C */
  1830. /* */
  1831. /* Register this translation layer */
  1832. /* */
  1833. /* Parameters:                                                          */
  1834. /* None */
  1835. /*                                                                      */
  1836. /* Returns: */
  1837. /* FLStatus : 0 on success, failed otherwise */
  1838. /*----------------------------------------------------------------------*/
  1840. FLStatus flRegisterSSFDC(void)
  1841. {
  1842.   if (noOfTLs >= TLS)
  1843.     return flTooManyComponents;
  1845.   tlTable[noOfTLs].mountRoutine = mountSSFDC;
  1846. #ifdef FORMAT_VOLUME
  1847.   tlTable[noOfTLs].formatRoutine = formatSSFDC;
  1848. #endif
  1849.   noOfTLs++;
  1851.   return flOK;
  1852. }
  1853. #endif /* FLASE */