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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
cfiamd.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：47k
源码类别：

VxWorks

开发平台：

C/C++

cfiamd.c：源码内容
  1. /* cfiamd.c - MTD for AMD parts that comply with CFI */
  2.  
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /* FAT-FTL Lite Software Development Kit
  7.  * Copyright (C) M-Systems Ltd. 1995-2001       */
  9. /*
  10. modification history
  11. --------------------
  12. 01l,24jun02,nrv  fixing the condition where flashPtr[0x24] is checked twice
  13. 01k,30apr02,nrv  cleaned up the code by removing local var gif
  14. 01j,09apr02,yp   fixed SPR 75069. reworked write routines so status chek would work.
  15. 01i,28mar02,nrv  vol.mtdVars is dereferenced before the pointer is set in
  16.                  cfiAmdIdentify
  17. 01h,12feb02,yp   Written based on cfiscs.c
  18. */
  20. /*
  21. DESCRIPTION
  22. This library provides an MTD for devices that conform to the Common Flash 
  23. Interface (CFI) and the AMD/Fujitsu command set. The library provides 
  24. identification, erase and write routines for 8 and 16 bit devices in 
  25. native or byte mode. Support is also added for word width devices 
  26. interleaved word wide where bytes 0 and 1 would be on device one 
  27. and bytes 2 and 3 would be on device two, and so on. Support is also present 
  28. for configurations that only permit double word width writes.
  30. The identification process supports byte, word, and double word width devices 
  31. as specified by the CFI query process. Vendr specific extentions are made 
  32. available from an instance specific data structure, referred to in this file 
  33. as thisCFI. 
  35. In addition to supporting a boot code region through the format process this
  36. driver is also able to reserve the last erase block of each device in the array
  37. so the vxWorks may use this region as NVRAM if the macro SAVE_NVRAM_REGION is 
  38. defined.
  40. The low voltage devices that support boot blocks get no special treatment in 
  41. this driver. The asymmetric regions are regocgnized from the erase block region
  42. information retreaved during CFI identification. They can, therefore be used by 
  43. the the file system just like any other sector, if they are not used for boot 
  44. purposes. Since TrueFFS does not support uneven sector distribution, the size of 
  45. the largest sector is taken as the erase block size. When an erase request 
  46. corresponds to the boot block region, all sectors in the boot block are erased.
  47. As such, the NVRAM area saved on a top boot device is the entire boot block and 
  48. not just the last sector as one might expect.
  50. Based on the observation that CFI data on the sector distribution on AMD devices
  51. always describes bottom boot devices, this driver does an "autoselect" to 
  52. determine the boot block type for proper interpretation of the device geometry 
  53. data. The erase process assumes that bottom boot devices have the boot block 
  54. located in sector zero. The first erase block encountered in an erase request 
  55. that has a sector size other than vol.erasableBlockSize on top boot devices is 
  56. assumed to be the boot block anchor on top boot devices.
  59. NOMANUAL
  60. */
  62. #include <stdio.h>
  63. #include "tffs/flflash.h"
  64. #include "tffs/backgrnd.h"
  66. #define  MAXSECTORS 128 /* should work with any value */
  68. typedef enum
  69.     {
  70.     BOOTBLOCK_NONE,
  71.     BOOTBLOCK_TOP,
  72.     BOOTBLOCK_BOTTOM
  73.     }BOOTBLOCK;
  75. typedef union
  76.     {
  77.     UCHAR uchar[4];
  78.     UINT32 uint32;
  79.     } CFI_DWORD;
  81. typedef union
  82.     {
  83.     UCHAR uchar[2];
  84.     USHORT ushort;
  85.     } CFI_WORD;
  86.     
  87. /* Instance specific CFI data so that a system may have more than one CFI
  88.  * device. */
  89. typedef struct {
  91.   unsigned         commandSetId;            /* id of a specific command set. */
  92.   unsigned         altCommandSetId;         /* id of alternate command set.  */
  93.   FLBoolean        wordMode;                /* TRUE - word mode.             */
  94.     /* FALSE - byte mode.            */
  95.   int              multiplier;              /* the number of bytes between   */
  96.     /* 1st Q and 1st R in query      */
  97.   int    interleaveWidth;     /* 1 - byte 2 - word interleaved */
  98.   unsigned         maxBytesWrite;           /* maximum number of bytes       */
  99.     /* in multi-byte write.          */
  100.   FLBoolean        vpp;                     /* if = TRUE, need vpp.          */
  101.   long             optionalCommands;        /* optional commands supported   */
  102.     /* (1 = yes, 0 = no):            */
  103.     /* bit 0 - chip erase.           */
  104.     /* bit 1 - suspend erase.        */
  105.     /* bit 2 - suspend write         */
  106.     /* bit 3 - lock/unlock.          */
  107.     /* bit 4 - queued erase.         */
  108.   unsigned         afterSuspend;            /* functions supported after     */
  109.     /* suspend (1 = yes, 0 = no):    */
  110.     /* bit 0 - write after erase     */
  111.     /*         suspend.              */
  112.   int     sectorDefs;     /* Number of sector definitions  */
  113.   struct {     /* sector descriptions as found  */
  114.       long     secSize;     /* in CFI query.       */
  115.       int     numSecs;     /*      */
  116.   }secDesc[8];     /* assume 8 is enough      */
  117.   struct {     /*      */
  118.       long    sectorSize;     /* sector size       */
  119.       UINT32    sectorBaseAdrs;     /* base address of sector      */
  120.   } secInfo[MAXSECTORS];     /* per sector info      */
  121.   UINT32 unlockAddr1;     /* offset for first unlock      */
  122.   UINT32 unlockAddr2;     /* offset for 2nd unlock      */
  123.   int sectorsInCFI;     /* sector count for device      */
  124.   int bootBlockSectors;     /* sectors that makeup boot block*/
  125.   BOOTBLOCK bootBlockType;     /* Top, Bottom or None      */
  126.       
  127. } CFI;
  129. LOCAL CFI mtdVars[DRIVES];
  131. /* defines */
  133. /* Save the last erase block on each device discovered in the array 
  134.  * for NVRAM */
  135. #define SAVE_NVRAM_REGION
  137. /* disable debugging */
  138. #undef CFI_DEBUG
  140. #ifdef CFI_DEBUG
  141. #define DEBUG_PRINT    printf
  142. #else
  143. #undef DEBUG_PRINT
  144. #endif
  146. #ifndef _BYTE_ORDER
  147. #error "Error: _BYTE_ORDER needs to be #define'd.  Try #include "vxWorks.h" "
  148. #endif
  150. #if (_BYTE_ORDER == _BIG_ENDIAN)
  152. #define CFI_LONGSWAP(x) LONGSWAP(x) /* swap everything in a long word */
  153. #define CFI_WORDSWAP(x) WORDSWAP(x) /* swap the shorts in a long */
  154. #define CFI_BYTESWAP(x) ( ( (x & 0xff) << 8) | ( (x >> 8) & 0xff) )  /* Swap bytes in a short */
  156. #else
  158. #define CFI_LONGSWAP(x) (x) /* pass it as is */
  159. #define CFI_WORDSWAP(x) (x) /* pass it as is */
  160. #define CFI_BYTESWAP(x) (x) /* pass it as is */
  162. #endif /* _BYTE_ORDER == _BIG_ENDIAN */
  164. #define CFI_LONG_WRITE(addr, data)  (*(ULONG *)addr = (ULONG)(CFI_WORDSWAP(data)))
  165. #define CFI_WORD_WRITE(addr, data)  (*(USHORT *)addr = (USHORT)(CFI_BYTESWAP(data)))
  166. #define CFI_WORD_READ(addr)         (CFI_BYTESWAP(*(USHORT *)addr))
  167. #define CFI_LONG_READ(addr)         (CFI_WORDSWAP(*(ULONG *)addr))
  169. /* command set IDs */
  171. #define INTEL_COMMAND_SET      0x0001
  172. #define AMDFUJ_COMMAND_SET     0x0002
  173. #define INTEL_ALT_COMMAND_SET  0x0001
  174. #define AMDFUJ_ALT_COMMAND_SET 0x0004
  175. #define ALT_NOT_SUPPORTED      0x0000
  178. /* CFI identification strings */
  180. #define ID_STR_LENGTH      3
  181. #define QUERY_ID_STR       "QRY"
  182. #define PRIMARY_ID_STR     "PRI"
  183. #define ALTERNATE_ID_STR   "ALT"
  186. /* commands */
  188. #define AMD_SETUP_ERASE 0x80
  189. #define AMD_SETUP_WRITE 0xa0
  190. #define AMD_READ_ID  0x90
  191. #define AMD_SUSPEND_ERASE 0xb0
  192. #define AMD_SECTOR_ERASE 0x30
  193. #define AMD_RESUME_ERASE 0x30
  194. #define AMD_READ_ARRAY 0xf0
  196. #define AMD_NO_UNLOCK_ADDR 0xffffffffL
  198. #define AMD_UNLOCK_1 0xaa
  199. #define AMD_UNLOCK_2 0x55
  201. #define AMD_WW_UNLOCK_ADDR1 0x555u /* Word wide devices */
  202. #define AMD_WW_UNLOCK_ADDR2 0x2aau  /* Word wide devices */
  203. #define AMD_BW_UNLOCK_ADDR1 0xaaau  /* Byte wide devices */
  204. #define AMD_BW_UNLOCK_ADDR2 0x555u  /* Byte wide devices */
  206. #define AMD_D2 4 /* Toggles when erase suspended */
  207. #define AMD_D5 0x20 /* Set when programming timeout */
  208. #define AMD_D6 0x40 /* Toggles when programming */
  211. /* optional commands support */
  213. #define CHIP_ERASE_SUPPORT           0x0001
  214. #define SUSPEND_ERASE_SUPPORT        0x0002
  215. #define SUSPEND_WRITE_SUPPORT        0x0004
  216. #define LOCK_SUPPORT                 0x0008
  217. #define QUEUED_ERASE_SUPPORT         0x0010
  219. #define QUERY 0x98
  221. /* supported functions after suspend */
  223. #define WRITE_AFTER_SUSPEND_SUPPORT  0x0001
  225. #define thisCFI   ((CFI *)vol.mtdVars)
  227. /* JEDEC IDs */
  229. /* 1.8 volt devices */
  230. #if 0
  231. /* Leaving out this one since it will complicate driver  */
  232. #define Am39BDS643G_FLASH 0x017e /* top boot only 95 64KB, 4 16KB,
  233.   31 64KB, and 4 16KB sectors*/
  234. #endif
  235.  
  236. #define Am29DS163DT_FLASH 0x0195 /* 8 8KB, and 31 64KB sectors */
  237. #define Am29DS163DB_FLASH 0x0196 /* 8 8KB, and 31 64KB sectors */
  238. #define Am29DS323DT_FLASH 0x01b7 /* 8 8KB, and 63 64KB sectors */
  239. #define Am29DS323DB_FLASH 0x01b8 /* 8 8KB, and 63 64KB sectors */
  240. #define Am29PDS322DT_FLASH 0x0101 /* 8 8KB, and 63 64KB sectors */
  241. #define Am29PDS322DB_FLASH 0x0100 /* 8 8KB, and 63 64KB sectors */
  242. #define Am29SL160CT_FLASH 0x01e4 /* 8 8KB, and 31 64KB sectors */
  243. #define Am29SL160CB_FLASH 0x01e7 /* 8 8KB, and 31 64KB sectors */
  244. /* 3.0 volt devices */
  245. #define Am29LV160BT_FLASH 0x01c4 /* 31 64KB, 1 32KB, 2 8KB, and 1 16KB sectors */
  246. #define Am29LV160BB_FLASH       0x0149 /* 1 16KB, 2 8KB, 1 32KB, and 31 64KB sectors */
  247. #define Am29DL161DT_FLASH 0x0136 /* 8 8KB, and 31 64KB sectors */
  248. #define Am29DL161DB_FLASH 0x0139 /* 8 8KB, and 31 64KB sectors */
  249. #define Am29DL162DT_FLASH 0x012d /* 8 8KB, and 31 64KB sectors */
  250. #define Am29DL162DB_FLASH 0x012e /* 8 8KB, and 31 64KB sectors */
  251. #define Am29DL163DT_FLASH 0x0128 /* 8 8KB, and 31 64KB sectors */
  252. #define Am29DL163DB_FLASH 0x012b /* 8 8KB, and 31 64KB sectors */
  253. #define Am29DL164DT_FLASH 0x0133 /* 8 8KB, and 31 64KB sectors */
  254. #define Am29DL164DB_FLASH 0x0135 /* 8 8KB, and 31 64KB sectors */
  255. /* The DL32xG series has the same JEDEC IDs and sector architecture */
  256. #define Am29LV320DT_FLASH 0x01f6 /* 8 8KB, and 63 64KB sectors */
  257. #define Am29LV320DB_FLASH 0x01f9 /* 8 8KB, and 63 64KB sectors */
  258. #define Am29DL322DT_FLASH 0x0155 /* 8 8KB, and 63 64KB sectors */
  259. #define Am29DL322DB_FLASH 0x0156 /* 8 8KB, and 63 64KB sectors */
  260. #define Am29DL323DT_FLASH 0x0150 /* 8 8KB, and 63 64KB sectors */
  261. #define Am29DL323DB_FLASH 0x0153 /* 8 8KB, and 63 64KB sectors */
  262. #define Am29DL324DT_FLASH 0x015c /* 8 8KB, and 63 64KB sectors */
  263. #define Am29DL324DB_FLASH 0x015f /* 8 8KB, and 63 64KB sectors */
  264. #define Am29LV017D_FLASH        0x01c8 /* 32  64KB sectors */
  265. #define Am29LV033C_FLASH        0x01a3 /* 64  64KB sectors */
  266. #define Am29LV065D_FLASH        0x0193 /* 128 64KB sectors */
  267. #define Am29LV116DT_FLASH 0x01c7 /* 31 64KB, 1 32KB, 2 8KB, and 1 16KB 
  268.   sectors */
  269. #define Am29LV116DB_FLASH       0x014c /* 1 16KB, 2 8KB, 1 32KB, and 31 64KB 
  270.   sectors */
  271. #define Am29LV640D_FLASH 0x01d7 /* 128 64KB sectors */
  272. /* left out PDL series because of the double CE# lines and left out PDL 
  273.  * series since they are quite impractical WRT TrueFFS. Should add support
  274.  * for mirror bit devices as soon as data sheets become available.
  275.  */
  277. /* 5.0 volt devices */
  278. #define Am29F016D_FLASH 0x01ad /* 32 64KB uniform sectors */
  279. #define Am29F017D_FLASH 0x013d /* 32 64KB uniform sectors */
  280. #define Am29F160DT_FLASH 0x01d2 /* 31 64KB, 1 32KB, 2 8KB, and 1 16KB sectors */
  281. #define Am29F160DB_FLASH 0x01d8 /* 1 16KB, 2 8KB, 1 32KB, and 31 64KB sectors */
  284. #define Fuj29LV160TE_FLASH      0x04c4 /* 31 64KB, 1 32KB, 2 8KB, and 1 16KB sectors */
  285. #define Fuj29LV160BE_FLASH      0x0449 /* 1 16KB, 2 8KB, 1 32KB, and 31 64KB sectors */
  288. /******************************************************************************
  289.  * cfiAmdChipCountGet - return the number of chips in this array
  290.  *
  291.  * Leave the first chip (or set of interleaved chips) in READ_ARRAY
  292.  * mode and move forward by chip size (or interleaved chip size) until
  293.  * address wrap around is detected. The chip count is updated in 
  294.  * vol.noOfChips.
  295.  *
  296.  * NOMANUAL
  297.  *
  298.  */
  300. LOCAL FLStatus cfiAmdChipCountGet
  301.     (
  302.     FLFlash vol
  303.     )
  304.     {
  305.     UINT32 cmdBuffer;
  306.     int ix;
  307.     char queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
  309.     FlashPTR flashPtr = (FlashPTR) flMap(vol.socket, 0);
  311.     /* Switch first (interleaved) chip set to QUERY mode */
  312.     cmdBuffer = 0x0;
  313.     for (ix = 0; ix < thisCFI->multiplier; ix++)
  314. cmdBuffer |= QUERY << (8 * ix);
  315.     flashPtr[0x55 * thisCFI->multiplier] = cmdBuffer;
  317.     /* NOTE: The address wrap around technique used here works only if the flash
  318.      * size was declared correctly in the socket driver. At some point the MTD
  319.      * should be discovering flash size and exporting it to the socket driver. 
  320.      */
  322.     for (vol.noOfChips = 1 * vol.interleaving;       /* Scan the chips */
  323.          vol.noOfChips < 2000;  /* Big enough ? */
  324.          vol.noOfChips += vol.interleaving) 
  325.         {
  326. #ifdef SAVE_NVRAM_REGION
  327. /* Reinstate the NVRAM region */
  328. flashPtr = (FlashPTR) flMap(vol.socket, vol.noOfChips * 
  329. (vol.chipSize + (vol.erasableBlockSize / vol.interleaving)));
  330. #else
  331. flashPtr = (FlashPTR) flMap(vol.socket, vol.noOfChips * vol.chipSize);
  332. #endif
  334. #ifdef DEBUG_PRINT
  335. DEBUG_PRINT("Debug: Looking for Flash device at base 0x%xn", (UINT32) flashPtr);
  336. #endif
  337. if ((flashPtr[0x10 * thisCFI->multiplier]) 
  338.     == (unsigned char)queryIdStr[0] &&
  339.     (flashPtr[0x11 * thisCFI->multiplier]) 
  340.     == (unsigned char)queryIdStr[1] &&
  341.     (flashPtr[0x12 * thisCFI->multiplier]) 
  342.     == (unsigned char)queryIdStr[2])
  343.     {
  344.     goto noMoreChips;      /* Wrapped around */
  345.     }
  347. /* Confirm this is also a CFI part */
  348. *(UCHAR *)(flashPtr + (0x55 * thisCFI->multiplier))
  349.    = (UCHAR)(QUERY);
  350. if (flashPtr[0x10 * thisCFI->multiplier]
  351. != (unsigned char)queryIdStr[0] ||
  352.     flashPtr[0x11 * thisCFI->multiplier]
  353. != (unsigned char)queryIdStr[1] ||
  354.     flashPtr[0x12 * thisCFI->multiplier]
  355. != (unsigned char)queryIdStr[2])
  356.     {
  357.     /* Should not happen !! */
  358.     goto noMoreChips; /* Not a CFI Flash part */
  359.     }
  361. flashPtr[0x55 * thisCFI->multiplier] 
  362. = (UCHAR)(AMD_READ_ARRAY);
  363. }
  364.     /* We should never get here. */
  365. #ifdef DEBUG_PRINT
  366.     DEBUG_PRINT("Debug: Device count overflown");
  367. #endif  /* DEBUG_PRINT */
  368.     return flGeneralFailure;
  369.     
  370. noMoreChips:
  371.     flashPtr = (FlashPTR) flMap(vol.socket, 0);
  372.     /* Switch to READ_ARRAY mode */
  373.     cmdBuffer = 0x0;
  374.     for (ix = 0; ix < thisCFI->multiplier; ix++)
  375. cmdBuffer |= AMD_READ_ARRAY << (8 * ix);
  376.     flashPtr[0x55 * thisCFI->multiplier] = cmdBuffer;
  378.     return flOK;
  379.     }
  380. #if 0
  381. /******************************************************************************
  382.  * cfiAmdLeftoverBytesWrite - Write trailing bytes from aligned write
  383.  * 
  384.  * This is a helper routine to cfiAmdWrite(), which writes in chunks, 1, 2, and
  385.  * 4 bytes wide. The trailing bytes are written from here bye reading 4 bytes 
  386.  * from flash and OR-ing in the data to be written. Note that when programming 
  387.  * flash, a 1 can be tuned to 0 but a 0 cannot be turned to 1.
  388.  */
  390. LOCAL void cfiAmdLeftoverBytesWrite
  391.     (
  392.     FLFlash vol,
  393.     const void FAR1 *buffer,
  394.     FlashPTR flashPtr,
  395.     int length
  396.     )
  397.     {
  398.     /* data is a 1's mask, so we only try overwriting the
  399.      * bytes we desire ie. written a 1 should not change
  400.      * the state of an erase bit 
  401.      */
  402.     int byteCount;
  403.     ULONG data = 0xffffffff;
  405.     /* clear out the bytes we are going to overwrite */
  406.     for(byteCount = 0; byteCount<length; byteCount++)
  407.         data &= ~(0xff << (byteCount*8));
  409.     /* set the bits we dont want to clear in our data */
  410.     data |= CFI_LONGSWAP(* (ULONG *) buffer);
  411.     }
  412. #endif
  413. /******************************************************************************
  414.  * cfiAmdWrite - Write a block of bytes to Flash
  415.  *
  416.  * This routine will be registered as the MTD vol.write routine. Given a pointer 
  417.  * to a buffer that must be written, the write width determined from the 
  418.  * identification process is used the stepping stone to interate through the buffer.
  419.  *
  420.  * Parameters:                                         
  421.  * vol : Pointer identifying drive
  422.  *      address : Card address to write to
  423.  *      buffer : Address of data to write
  424.  * length : Number of bytes to write
  425.  * overwrite : TRUE if overwriting old Flash contents
  426.  *   FALSE if old contents are known to be erased
  427.  *                                                                     
  428.  * Returns:                                                           
  429.  * FLStatus : 0 on success, failed otherwise
  430.  */
  432. LOCAL FLStatus cfiAmdWrite
  433.     (
  434.     FLFlash vol,
  435.     CardAddress address,
  436.     const void FAR1 *buffer,
  437.     int length,
  438.     FLBoolean overwrite
  439.     )
  440.     {
  441.     /* Set timeout to 5 seconds from now */
  442.     unsigned long writeTimeout = flMsecCounter + 5000;
  443.     int cLength;
  444.     CardAddress cAddr = address;
  445.     FlashPTR base;
  446.     FlashPTR flashPtr;
  447.     UINT32 unlock1 = 0;
  448.     UINT32 unlock2 = 0;
  449.     UINT32 setup_write = 0;
  450.     UINT32 read_array = 0;
  451.     int i;
  452.     CFI_DWORD tmpDWord;
  453.     CFI_WORD  tmpWord;
  455. #define bFlashPtr  flashPtr
  456. #define bBuffer ((const unsigned char FAR1 *) buffer)
  457. #define wFlashPtr ((FlashWPTR) flashPtr)
  458. #define wBuffer ((const unsigned short FAR1 *) buffer)
  459. #define dFlashPtr ((FlashDPTR) flashPtr)
  460. #define dBuffer ((const unsigned long FAR1 *) buffer)
  462.     /* Setup the commands first */
  463.     for (i = 0; i < thisCFI->multiplier; i++)
  464. {
  465. unlock1  |= AMD_UNLOCK_1 << (i * 8);
  466. unlock2  |= AMD_UNLOCK_2 << (i * 8);
  467. setup_write |= AMD_SETUP_WRITE << (i * 8);
  468. read_array |= AMD_READ_ARRAY << (i * 8);
  469. }
  471.     if (flWriteProtected(vol.socket))
  472. return flWriteProtect;
  474.     i = 0; 
  475.     while ((thisCFI->secInfo[i].sectorBaseAdrs <= address) && (i < thisCFI->sectorsInCFI))
  476. i++;
  477.     i--;
  479.     base = (FlashPTR)
  480.   vol.map(&vol, thisCFI->secInfo[i].sectorBaseAdrs,
  481.     vol.interleaving * thisCFI->interleaveWidth);
  483.     flashPtr = (FlashPTR)
  484.   vol.map(&vol, address,
  485.     vol.interleaving * thisCFI->interleaveWidth);
  487.     cLength = length;
  488.     if (vol.interleaving * thisCFI->interleaveWidth == 1) 
  489. {
  490.         while (cLength >= 1) 
  491.        {
  492.     *(UCHAR *)(base + 
  493. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  494.          *(UCHAR *)(base + 
  495. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  496.          *(UCHAR *)(base + 
  497. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = setup_write;
  498.     *bFlashPtr = *bBuffer;
  499.     while (bFlashPtr[0] != bBuffer[0] && flMsecCounter < writeTimeout) 
  500.         {
  501.         if ((bFlashPtr[0] & AMD_D5) && bFlashPtr[0] != bBuffer[0]) 
  502.     {
  503.     bFlashPtr[0] = read_array;
  504. #ifdef DEBUG_PRINT
  505.     DEBUG_PRINT("Debug: write failed in AMD MTD.n");
  506. #endif
  507.     return flWriteFault;
  508.     }
  509.         }
  510.     cLength--;
  511.     cAddr++;
  512.     buffer++;
  513.     bFlashPtr++;
  514.     }
  515.         }
  516.     else if (vol.interleaving * thisCFI->interleaveWidth == 2)  
  517. {
  518. while (cLength >= 2) 
  519.     {
  520.     *(USHORT *)(base + 
  521. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  522.          *(USHORT *)(base + 
  523. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  524.          *(USHORT *)(base + 
  525. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = setup_write;
  526.     *wFlashPtr = *wBuffer;
  527.     while ((wFlashPtr[0] != wBuffer[0]) && 
  528.     (flMsecCounter < writeTimeout))
  529. {
  530. if (((wFlashPtr[0] & AMD_D5) && 
  531.     ((wFlashPtr[0] ^ wBuffer[0]) &   0xff)) ||
  532.     ((wFlashPtr[0] & (AMD_D5 * 0x100)) 
  533.      && ((wFlashPtr[0] ^ wBuffer[0]) & 0xff00))) 
  534.     {
  535.     wFlashPtr[0] = read_array;
  536. #ifdef DEBUG_PRINT
  537.             DEBUG_PRINT("Debug: write failed in AMD MTD.n");
  538. #endif
  539.     return flWriteFault;
  540.     }
  541. }
  542.     cLength -= 2;
  543.     cAddr += 2;
  544.     buffer += 2;
  545.     flashPtr += 2;
  546.     }
  547. if (cLength > 0)
  548.             {
  549.     /* copy data from flash to tmpWord */
  550.     tmpWord.ushort = wFlashPtr[0];
  552.     /* now fill in the left over byte */
  553.     tmpWord.uchar[0] = *(char *)buffer;
  555.     *(USHORT *)(base + 
  556. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  557.          *(USHORT *)(base + 
  558. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  559.          *(USHORT *)(base + 
  560. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = setup_write;
  561.     *wFlashPtr = tmpWord.ushort;
  562.  
  563.     while ((wFlashPtr[0] != tmpWord.ushort) && 
  564.     (flMsecCounter < writeTimeout))
  565. {
  566. if (((wFlashPtr[0] & AMD_D5) && 
  567.     ((wFlashPtr[0] ^ tmpWord.ushort) &   0xff)) ||
  568.     ((wFlashPtr[0] & (AMD_D5 * 0x100)) 
  569.      && ((wFlashPtr[0] ^ tmpWord.ushort) & 0xff00))) 
  570.     {
  571.     wFlashPtr[0] = read_array;
  572. #ifdef DEBUG_PRINT
  573.             DEBUG_PRINT("Debug: write failed in AMD MTD.n");
  574. #endif
  575.     return flWriteFault;
  576.     }
  577. }
  578.     cAddr += cLength;
  579.     buffer += cLength;
  580.     flashPtr += cLength;
  581.     cLength = 0;
  582.     }
  583.     /* cfiAmdLeftoverBytesWrite(&vol, buffer, flashPtr, cLength); */
  584. }
  585.     else /* if (vol.interleaving >= 4) */ 
  586. {
  587. while (cLength >= 4) 
  588.     {
  589.     *(UINT32 *)(base + 
  590. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  591.          *(UINT32 *)(base + 
  592. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  593.          *(UINT32 *)(base + 
  594. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = setup_write;
  595.     *dFlashPtr = *dBuffer;
  597.     while ((dFlashPtr[0] != dBuffer[0]) && 
  598.     (flMsecCounter < writeTimeout)) 
  599. {
  600. if (thisCFI-> interleaveWidth == 1)
  601.     {
  602.     /* We have 4 8 bit devices */
  603.     if (((dFlashPtr[0] & AMD_D5) && 
  604. ((dFlashPtr[0] ^ dBuffer[0]) & 0xff)) ||
  605. ((dFlashPtr[0] & (AMD_D5 * 0x100)) && 
  606. ((dFlashPtr[0] ^ dBuffer[0]) & 0xff00)) ||
  607. ((dFlashPtr[0] & (AMD_D5 * 0x10000lu)) && 
  608. ((dFlashPtr[0] ^ dBuffer[0]) & 0xff0000lu)) ||
  609. ((dFlashPtr[0] & (AMD_D5 * 0x1000000lu)) && 
  610. ((dFlashPtr[0] ^ dBuffer[0]) & 0xff000000lu))) 
  611.         {
  612. #ifdef DEBUG_PRINT
  613.   DEBUG_PRINT("Debug: write failed in AMD MTD.n");
  614. #endif
  615.         dFlashPtr[0] = read_array;
  616.         return flWriteFault;
  617.         }
  618.     }
  619. else
  620.     {
  621.     /* Here we assume that the only other option is 2 16 bit devices */
  622.     if (((dFlashPtr[0] & AMD_D5) && 
  623. ((dFlashPtr[0] ^ dBuffer[0]) & 0x0000ffff)) ||
  624.         ((dFlashPtr[0] & (AMD_D5 * 0x10000lu)) && 
  625. ((dFlashPtr[0] ^ dBuffer[0]) & 0xffff0000)))
  626. {
  627. #ifdef DEBUG_PRINT
  628.   DEBUG_PRINT("Debug4-1: write failed in AMD MTD.n");
  629. #endif
  630.         dFlashPtr[0] = read_array;
  631.         return flWriteFault;
  632.         }
  633.     }     
  635. }
  636.     cLength -= 4;
  637.     cAddr += 4;
  638.     buffer += 4;
  639.     flashPtr += 4;
  640.     }
  641. if (cLength > 0)
  642.             {
  644.     tmpDWord.uint32 = 0xffffffff;
  645.     /* read trailing bytes in to temp dword */
  646.     for (i = 0; i < cLength; i++)
  647. tmpDWord.uchar[i] = *((char *)buffer + i);
  649.     /* fill the rest from flash */
  650.     for (    ; i < 4; i++)
  651. tmpDWord.uchar[i] = *(flashPtr + i);
  653.     *(UINT32 *)(base + 
  654. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  655.          *(UINT32 *)(base + 
  656. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  657.          *(UINT32 *)(base + 
  658. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = setup_write;
  659.     *dFlashPtr = tmpDWord.uint32;
  661.     while ((dFlashPtr[0] != tmpDWord.uint32) && 
  662.     (flMsecCounter < writeTimeout)) 
  663. {
  664. if (thisCFI-> interleaveWidth == 1)
  665.     {
  666.     /* We have 4 8 bit devices */
  667.     if (((dFlashPtr[0] & AMD_D5) && 
  668. ((dFlashPtr[0] ^ tmpDWord.uint32) & 0xff)) ||
  669. ((dFlashPtr[0] & (AMD_D5 * 0x100)) && 
  670. ((dFlashPtr[0] ^ tmpDWord.uint32) & 0xff00)) ||
  671. ((dFlashPtr[0] & (AMD_D5 * 0x10000lu)) && 
  672. ((dFlashPtr[0] ^ tmpDWord.uint32) & 0xff0000lu)) ||
  673. ((dFlashPtr[0] & (AMD_D5 * 0x1000000lu)) && 
  674. ((dFlashPtr[0] ^ tmpDWord.uint32) & 0xff000000lu))) 
  675.         {
  676. #ifdef DEBUG_PRINT
  677.   DEBUG_PRINT("Debug: write failed in AMD MTD.n");
  678. #endif
  679.         dFlashPtr[0] = read_array;
  680.         return flWriteFault;
  681.         }
  682.     }
  683. else
  684.     {
  685.     /* Here we assume that the only other option is 16 devices */
  686.     if (((dFlashPtr[0] & AMD_D5) && 
  687. ((dFlashPtr[0] ^ tmpDWord.uint32) & 0x0000ffff)) ||
  688.         ((dFlashPtr[0] & (AMD_D5 * 0x10000lu)) && 
  689. ((dFlashPtr[0] ^ tmpDWord.uint32) & 0xffff0000)))
  690. {
  691. #ifdef DEBUG_PRINT
  692.   DEBUG_PRINT("Debug4-2: write failed in AMD MTD.n");
  693. #endif
  694.         dFlashPtr[0] = read_array;
  695.         return flWriteFault;
  696.         }
  697.     }     
  698. }
  700.     cAddr += cLength;
  701.     buffer += cLength;
  702.     flashPtr += cLength;
  703.     cLength = 0;
  704.     }
  705.     /* cfiAmdLeftoverBytesWrite(&vol, buffer, flashPtr, cLength); */
  706. }
  708.     flashPtr -= length;
  709.     buffer = (unsigned char *)buffer - length; /* bBuffer -= length; */
  711.     if (tffscmp((void FAR0 *) flashPtr,buffer,length)) 
  712. {
  713. #ifdef DEBUG_PRINT
  714. DEBUG_PRINT("Debug: write failed in AMD MTD on verification.n");
  715. #endif
  716. return flWriteFault;
  717. }
  719.     return flOK;
  720.     }
  722. /*******************************************************************************
  723.  * cfiAmdBootBlockErase - Erase sub blocks within boot block
  724.  *
  725.  * Use the boot block data discovered at CFI interrogation time and erase all 
  726.  * subsectors in the boot block.
  727.  *
  728.  * Parameters:                                         
  729.  * vol : Pointer identifying drive
  730.  *      firstErasableBlock : Sector number of start of boot block
  731.  *                                                             
  732.  * Returns:                                                   
  733.  * FLStatus : 0 on success, failed otherwise
  734.  */
  736. LOCAL FLStatus cfiAmdBootBlockErase
  737.     (
  738.     FLFlash vol,
  739.     int firstErasableBlock
  740.     )
  741.     {
  742.     int iBlock, i;
  743.     UINT32 unlock1 = 0;
  744.     UINT32 unlock2 = 0;
  745.     UINT32 erase_setup = 0;
  746.     UINT32 erase_sector = 0;
  748.     /* Setup the commands first */
  749.     for (i = 0; i < thisCFI->multiplier; i++)
  750. {
  751. unlock1  |= AMD_UNLOCK_1 << (i * 8);
  752. unlock2  |= AMD_UNLOCK_2 << (i * 8);
  753. erase_setup |= AMD_SETUP_ERASE << (i * 8);
  754. erase_sector  |= AMD_SECTOR_ERASE << (i * 8);
  755. }
  757.     for (iBlock = firstErasableBlock; 
  758. (iBlock - firstErasableBlock) < thisCFI->bootBlockSectors; 
  759. iBlock++) 
  760. {
  761. int i;
  762. FLBoolean finished;
  763. FlashPTR flashPtr;
  765. /* No need to call mapBase because we know we are on 
  766.  * a unit boundary 
  767.  */
  768. flashPtr = (FlashPTR)
  769.   vol.map(&vol, thisCFI->secInfo[iBlock].sectorBaseAdrs, 0);
  771.      *(UINT32 *)(flashPtr + 
  772. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  773.      *(UINT32 *)(flashPtr + 
  774. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  775.      *(UINT32 *)(flashPtr + 
  776. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = erase_setup;
  777.      *(UINT32 *)(flashPtr + 
  778. (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  779.      *(UINT32 *)(flashPtr + 
  780. (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  781.      *(UINT32 *)flashPtr = erase_sector;
  783. do 
  784.     {
  785.     finished = TRUE;
  786.     for (i = 0;i < thisCFI->multiplier;i += thisCFI->interleaveWidth) 
  787. {
  788. if (flashPtr[i] != 0xff) 
  789.     {
  790.     if ((flashPtr[i] & AMD_D5) && flashPtr[i] != 0xff) 
  791. {
  792. flashPtr[i] = AMD_READ_ARRAY;
  793. #ifdef DEBUG_PRINT
  794.      DEBUG_PRINT("Debug: erase failed in AMD MTD.n");
  795. #endif
  796. return flWriteFault;
  797. }
  798.     finished = FALSE;
  799.     }
  800. }
  801.     } while (!finished);
  802. }
  804.     return flOK;
  805.     }
  806. /*******************************************************************************
  807.  * cfiAmdErase - Erase one or more contiguous Flash erasable blocks
  808.  *
  809.  * This routine will be registered as the MTD vol.erase routine. Sector zero is 
  810.  * assumed to be the boot block anchor of the boot block on bottom boot devices,
  811.  * while the first sector of size not equal to vol.erasableBlockSize is assumed 
  812.  * to be the anchor for top boot devices.
  813.  *
  814.  * Parameters:                                         
  815.  * vol : Pointer identifying drive
  816.  *      firstErasableBlock : Number of first block to erase
  817.  * numOfErasableBlocks: Number of blocks to erase
  818.  *                                                             
  819.  * Returns:                                                   
  820.  * FLStatus : 0 on success, failed otherwise
  821.  */
  823. LOCAL  FLStatus cfiAmdErase
  824.     (
  825.     FLFlash vol,
  826.     int firstErasableBlock,
  827.     int numOfErasableBlocks
  828.     )
  829.     {
  830.     int i;
  831.     UINT32 unlock1 = 0;
  832.     UINT32 unlock2 = 0;
  833.     UINT32 erase_setup = 0;
  834.     UINT32 erase_sector = 0;
  835.     int thisSector = firstErasableBlock;
  836.     int sectorsToErase = numOfErasableBlocks;
  837.     UINT32 * unlockAddr1;
  838.     UINT32 * unlockAddr2;
  840.     if (flWriteProtected(vol.socket))
  841. return flWriteProtect;
  843.     if ((thisCFI->bootBlockType == BOOTBLOCK_BOTTOM) && 
  844.      (firstErasableBlock == 0))
  845. {
  846. #ifdef DEBUG_PRINT
  847. DEBUG_PRINT("Debug: Erasing bottom boot blockn");
  848. #endif
  849.     cfiAmdBootBlockErase(&vol, 0);
  850.     thisSector += thisCFI->bootBlockSectors;
  851. }
  852. /* Setup the commands first */
  853.     for (i = 0; i < thisCFI->multiplier; i++)
  854. {
  855. unlock1   |= AMD_UNLOCK_1 << (i * 8);
  856. unlock2   |= AMD_UNLOCK_2 << (i * 8);
  857. erase_setup  |= AMD_SETUP_ERASE << (i * 8);
  858. erase_sector |= AMD_SECTOR_ERASE << (i * 8);
  859. }
  860.     
  861.     for ( ; thisSector < firstErasableBlock + sectorsToErase; thisSector++) 
  862. {
  863. int i;
  864. FLBoolean finished;
  865. FlashPTR flashPtr;
  867. /* Check if we have hit a boot block region on a top 
  868.  * boot device. If so lets clean it up and move on with 
  869.  * the others
  870.  */
  871. if ((thisCFI->bootBlockType == BOOTBLOCK_TOP) &&
  872. (thisCFI->secInfo[thisSector].sectorSize != vol.erasableBlockSize))
  873.     {
  874. #ifdef DEBUG_PRINT
  875. DEBUG_PRINT("Debug: Erasing top boot blockn");
  876. #endif
  877.     cfiAmdBootBlockErase(&vol, thisSector);
  878.     break;
  879.     }
  881. #ifdef DEBUG_PRINT 
  882. DEBUG_PRINT("Clearing sector %dn", thisSector);
  883. #endif 
  885. /* we know we are on a unit boundary so mapBase is not necessary */
  886. flashPtr = (FlashPTR)
  887.   vol.map(&vol, thisCFI->secInfo[thisSector].sectorBaseAdrs, 0);
  889. unlockAddr1 = (UINT32 *)((long)flashPtr + (thisCFI->unlockAddr1 *thisCFI->multiplier));
  890. unlockAddr2 = (UINT32 *)((long)flashPtr + (thisCFI->unlockAddr2 *thisCFI->multiplier));
  892.     *unlockAddr1 = unlock1;
  893.      *unlockAddr2 = unlock2;
  894. *unlockAddr1 = erase_setup;
  895.      *unlockAddr1 = unlock1;
  896.      *unlockAddr2 = unlock2;
  897.      *(UINT32 *)flashPtr = erase_sector;
  899. do 
  900.     {
  901.     finished = TRUE;
  903.     for (i = 0;i < thisCFI->multiplier;i += thisCFI->interleaveWidth) 
  904. {
  905. if (flashPtr[i] != 0xff) 
  906.     {
  907.     if ((flashPtr[i] & AMD_D5) && flashPtr[i] != 0xff) 
  908. {
  909. int x;
  910. UINT32 c;
  912. for (x = 0, c = 0; x < thisCFI->multiplier; x++)
  913.          c |= AMD_READ_ARRAY << (x * 8);
  914. flashPtr[i] = c;
  915. #ifdef DEBUG_PRINT
  916.     DEBUG_PRINT("Debug: erase failed in AMD MTD.n");
  917. #endif
  918. return flWriteFault;
  919. }
  920.     finished = FALSE;
  921.     }
  922. }
  923.     } while (!finished);
  924. }
  925.     return flOK;
  926.     }
  929. /***************************************************************************
  930.  * cfiscsIdentify - Identification routine for devices conforming to CFI/SC
  931.  *
  932.  * Identifies media based on CFI and the AMD/Fujitsu command set and registers
  933.  * as an MTD for such. This routine should be placed on the MTD list in flcustom.h.
  934.  * It must be an extern routine. On successful identification, the Flash 
  935.  * structure is filled out and the write and erase routines registered. 
  936.  *
  937.  * Parameters:
  938.  *      vol             : Pointer identifying drive 
  939.  *
  940.  * Returns:
  941.  *      FLStatus        : 0 on positive identificaion, failed otherwise 
  942.  *
  943.  * http://www.amd.com/us-en/FlashMemory/ProductInformation/0,,37_1447_1451_1780%5E1834%5E1955,00.html
  944.  *
  945.  *
  946.  * NOMANUAL
  947.  *
  948.  */
  949. FLStatus cfiAmdIdentify
  950.     (
  951.     FLFlash vol
  952.     )
  953.     {
  954.     FlashPTR flashPtr = (FlashPTR) flMap(vol.socket, 0);
  955.     FlashWPTR flashWPtr = (FlashWPTR) flashPtr;
  956.     FlashDPTR flashDPtr = (FlashDPTR) flashPtr;
  957.     UINT32 unlock1 = 0;
  958.     UINT32 unlock2 = 0;
  959.     UINT32 readID = 0;
  960.     UINT32 readArray = 0;
  961.     int i;
  963.    unsigned primaryTable, secondaryTable;
  964.     FLBoolean eightBitMode = FALSE;
  965.     int thisSector = 0; /* running count of sectors for this CFI */
  966.     CardAddress sectorBaseAdrs = 0; /* base address of this sector */
  967.     int ix = 0;
  969. #ifdef DEBUG_PRINT
  970.     DEBUG_PRINT("Debug: entering CFIAMD identification routine.n");
  971. #endif
  974.     flSetWindowBusWidth(vol.socket, 16);/* use 16-bits */
  975.     flSetWindowSpeed(vol.socket, 120);  /* 120 nsec. */
  976.     flSetWindowSize(vol.socket, 2);       /* 8 KBytes */
  978.     vol.mtdVars = &mtdVars[flSocketNoOf(vol.socket)];
  979.     thisCFI->bootBlockSectors = 0;
  981.     /* Is this an 8 bit device */
  982.     flashPtr[0x55] = AMD_READ_ARRAY;
  983.     flashPtr[0x55] = QUERY;
  984.     
  985.     if (flashPtr[0x10] == 0x51 && /* 'Q' */
  986.         flashPtr[0x11] == 0x52 && /* 'R' */
  987.         flashPtr[0x12] == 0x59)   /* 'Y' */
  988.         {
  989. #ifdef DEBUG_PRINT
  990.         DEBUG_PRINT ("Debug: detected single 8 bit devicen");
  991. #endif
  992.         thisCFI->multiplier = 1;
  993. thisCFI->interleaveWidth = 1;
  994.         vol.interleaving = 1;
  995. eightBitMode = TRUE;
  997.         goto getCFI;
  998.         }
  1000.     /* Reset to READ_ARRAY and retry. Maybe 16 bit addressing 
  1001.      */
  1002.     flashPtr[0x55] = AMD_READ_ARRAY;
  1003.     flashWPtr[0x55] = (USHORT) ((QUERY << 8) | QUERY); 
  1005.     /* Check for two interleaved 8 bit parts */
  1006.     if (flashPtr[0x20] == 0x51 && /* 'Q' */
  1007.         flashPtr[0x21] == 0x51 && /* 'Q' */
  1008.         flashPtr[0x22] == 0x52 && /* 'R' */
  1009.         flashPtr[0x23] == 0x52 && /* 'R' */
  1010.         flashPtr[0x24] == 0x59 && /* 'Y' */
  1011.         flashPtr[0x25] == 0x59)   /* 'Y' */
  1012.      {
  1013. /* Let's try turning one off */
  1014. CFI_WORD_WRITE((FlashWPTR)(&flashPtr[0x55]), AMD_READ_ARRAY);
  1015. if (flashPtr[0x20] != 0x51) /* Turned off successfully */
  1016.     {
  1017.     thisCFI->multiplier = 2;
  1018.     thisCFI->interleaveWidth = 1;
  1019.     vol.interleaving =2;
  1020. #ifdef DEBUG_PRINT
  1021.     DEBUG_PRINT ("Debug: detected two 8 bit devicesn");
  1022. #endif
  1023.     eightBitMode = TRUE;
  1024.     goto getCFI;
  1025.     }
  1026. }
  1028.     /* a 16 bit device in 16 bit mode */
  1029.     if (flashWPtr[0x10] == 'Q' && 
  1030.         flashWPtr[0x11] == 'R' &&
  1031.         flashWPtr[0x12] == 'Y')
  1032.         {
  1033.         thisCFI->multiplier = 2;
  1034. thisCFI->interleaveWidth = 1;
  1035. vol.interleaving = 1;
  1036. #ifdef DEBUG_PRINT
  1037.         DEBUG_PRINT ("Debug: detected one 16 bit devicen");
  1038. #endif
  1039. goto getCFI;
  1040. }
  1042.     /* If we have a 16 bit device in 8 bit mode it should ID correctly */
  1043.     if (flashPtr[0x20] == 0x51 && /* 'Q' */
  1044.         flashPtr[0x21] == 0x51 && /* 'Q' */
  1045.         flashPtr[0x22] == 0x52 && /* 'R' */
  1046.         flashPtr[0x23] == 0x52 && /* 'R' */
  1047.         flashPtr[0x24] == 0x59 && /* 'Y' */
  1048.         flashPtr[0x25] == 0x59)   /* 'Y' */
  1049.         {
  1050. thisCFI->multiplier = 2;
  1051. #ifdef DEBUG_PRINT
  1052.         DEBUG_PRINT ("Debug: detected a 16 bit device in 8 bit moden");
  1053. #endif
  1054.      vol.interleaving =1;
  1055. thisCFI->interleaveWidth = 1;
  1056. eightBitMode = TRUE;
  1057. goto getCFI;
  1058.      }
  1060.     /* Reset to READ_ARRAY and retry. Maybe 32 bit addressing 
  1061.      */
  1062.     flashWPtr[0x55] = (USHORT) ((AMD_READ_ARRAY << 8) | AMD_READ_ARRAY); 
  1063.     flashDPtr[0x55] = (ULONG) (QUERY << 24| QUERY <<16 | QUERY << 8 | QUERY); 
  1065.     /* A 32 bit device in 8 bit mode and two 16 bit deivec in 8 bit mode will
  1066.      * appear the same to the querry process. The only way to make the
  1067.      * distinction is to try and set one device back to read array mode while
  1068.      * the other remains in query mode */
  1069.     if (flashPtr[0x40] == 0x51 && /* 'Q' */
  1070.         flashPtr[0x41] == 0x51 && /* 'Q' */
  1071.         flashPtr[0x42] == 0x51 && /* 'Q' */
  1072.         flashPtr[0x43] == 0x51 && /* 'Q' */
  1073.         flashPtr[0x44] == 0x52 && /* 'R' */
  1074.         flashPtr[0x45] == 0x52 && /* 'R' */
  1075.         flashPtr[0x46] == 0x52 && /* 'R' */
  1076.         flashPtr[0x47] == 0x52 && /* 'R' */
  1077.         flashPtr[0x48] == 0x59 && /* 'Y' */
  1078.         flashPtr[0x49] == 0x59 && /* 'Y' */
  1079.         flashPtr[0x4a] == 0x59 && /* 'Y' */
  1080.         flashPtr[0x4b] == 0x59)   /* 'Y' */
  1081.         {
  1082. /* See if we can turn one off */
  1083. flashPtr[0x154] = AMD_READ_ARRAY;
  1084. if ((flashPtr[0x40] != 0x51) && (flashPtr[0x41] == 0x51))
  1085.     { /* Turned one device off successfully */
  1086.     flashPtr[0x154] = QUERY;  /* turn it back on to querry mode */
  1087.     vol.interleaving = 2;
  1088. #ifdef DEBUG_PRINT
  1089.     DEBUG_PRINT ("Debug: detected two 16 bit device, 8 bit interleaved(2)n");
  1090. #endif
  1091.     }
  1092. else
  1093.     {
  1094.     vol.interleaving =1;
  1095. #ifdef DEBUG_PRINT
  1096.     DEBUG_PRINT ("Debug: detected a 32 bit device in 8 bit moden");
  1097. #endif
  1098.     }
  1099.         thisCFI->multiplier = 4;
  1100. thisCFI->interleaveWidth = 1;
  1101. eightBitMode = TRUE;
  1102. goto getCFI;
  1103. }
  1105.     /* Is it a single 32 bit device */
  1106.     if (flashDPtr[0x10] == 'Q' &&
  1107.         flashDPtr[0x11] == 'R' &&
  1108.         flashDPtr[0x12] == 'Y')
  1109.         {
  1110. #ifdef DEBUG_PRINT
  1111.         DEBUG_PRINT ("Debug: detected a 32 bit device in 32 bit moden");
  1112. #endif
  1113. thisCFI->multiplier = 4;
  1114. thisCFI->interleaveWidth = 1;
  1115. vol.interleaving = 1;
  1116. goto getCFI;
  1117. }
  1119.     /* Two 16 bit devices in 16 bit mode */
  1120.     if (flashWPtr[0x20] == 'Q' &&
  1121.         flashWPtr[0x21] == 'Q' &&
  1122.         flashWPtr[0x22] == 'R' &&
  1123.         flashWPtr[0x23] == 'R' &&
  1124.         flashWPtr[0x24] == 'Y' &&
  1125.         flashWPtr[0x25] == 'Y')
  1126.         {
  1127. #ifdef DEBUG_PRINT
  1128.         DEBUG_PRINT ("Debug: Detected two 16 bit devices in 16 bit mode(3)n");
  1129. #endif
  1130. thisCFI->multiplier = 4;
  1131. thisCFI->interleaveWidth = 2;
  1132. vol.interleaving = 2;
  1133. goto getCFI;
  1134. }
  1137.     /* If we get here the device is probably not CFI */
  1139. #ifdef DEBUG_PRINT
  1140.     DEBUG_PRINT ("Debug: Failed to identify CFI... n Exiting n");
  1141. #endif
  1143.     flashDPtr[0x55] = (ULONG) (AMD_READ_ARRAY << 24| AMD_READ_ARRAY <<16 
  1144.      | AMD_READ_ARRAY << 8 | AMD_READ_ARRAY); 
  1146.     return flUnknownMedia;
  1148. getCFI:
  1150.     if (!eightBitMode)
  1151. {
  1152. thisCFI->wordMode = TRUE; /* limitting ourselves to 8 an 16 bit devs */
  1153. thisCFI->unlockAddr1 = AMD_WW_UNLOCK_ADDR1;
  1154. thisCFI->unlockAddr2 = AMD_WW_UNLOCK_ADDR2;
  1155. #ifdef DEBUG_PRINT
  1156. DEBUG_PRINT("WORD MODE !!n");
  1157. #endif
  1158. }
  1159.     else
  1160. {
  1161. thisCFI->wordMode = FALSE;
  1162. thisCFI->unlockAddr1 = AMD_BW_UNLOCK_ADDR1;
  1163. thisCFI->unlockAddr2 = AMD_BW_UNLOCK_ADDR2;
  1164. #ifdef DEBUG_PRINT
  1165. DEBUG_PRINT("WORD MODE !!n");
  1166. #endif
  1167. }
  1169.     /* check the command set ID */
  1170.     /* NOTE: Not swapped */
  1171.     thisCFI->commandSetId = *(USHORT *)(&flashPtr[0x13 * thisCFI->multiplier]);
  1172. #ifdef DEBUG_PRINT
  1173.     DEBUG_PRINT ("Debug: Commandset ID is 0x%xn", thisCFI->commandSetId);
  1174. #endif
  1176.     /* Only support the AMD/Fujitsu Command set */
  1177.     if ( thisCFI->commandSetId != AMDFUJ_COMMAND_SET) 
  1178.         {
  1179. #ifdef DEBUG_PRINT
  1180.     DEBUG_PRINT("Debug: did not recognize command set.n");
  1181. #endif
  1182.         return flUnknownMedia;
  1183.         }
  1186.     /* get address for primary algorithm extended table. */
  1187.     primaryTable = CFI_WORD_READ(&flashPtr[0x15 * thisCFI->multiplier]);
  1189.     /* check alternate command set ID. */
  1190.     /* NOTE: not swapped */
  1191.     thisCFI->altCommandSetId = *(USHORT *)
  1192. (&flashPtr[0x17 * thisCFI->multiplier]);
  1193.     if (thisCFI->altCommandSetId != AMDFUJ_ALT_COMMAND_SET &&
  1194.         thisCFI->altCommandSetId != ALT_NOT_SUPPORTED)
  1195.         return flUnknownMedia;
  1197.     /* get address for secondary algorithm extended table. */
  1198.     secondaryTable = CFI_WORD_READ(&flashPtr[0x19 * thisCFI->multiplier]);
  1200.     thisCFI->vpp = flashPtr[0x1d * thisCFI->multiplier];
  1202.     /*Get the number of erase block descriptions for thei CFI*/
  1203.     if (eightBitMode)
  1204. thisCFI->sectorDefs = (int) (*(UCHAR *) 
  1205. (&flashPtr[0x2c * thisCFI->multiplier]));
  1206.     else
  1207. thisCFI->sectorDefs = (int) (*(USHORT *)
  1208.     (&flashPtr[0x2c * thisCFI->multiplier]));
  1210.     /* We should bail out if this is greater than 8 */
  1211. #ifdef DEBUG_PRINT
  1212.     DEBUG_PRINT ("Debug: Number of erase block descriptions is 0x%xn", 
  1213.     thisCFI->sectorDefs);
  1214. #endif
  1216.     vol.erasableBlockSize = 0;
  1217.     thisCFI->sectorsInCFI = 0;
  1219.     for ( ix = 0; ix < thisCFI->sectorDefs; ix++)
  1220. {
  1221. thisCFI->secDesc[ix].numSecs = (int) (*(USHORT *)
  1222. (&flashPtr[(0x2d + (ix * 4)) * thisCFI->multiplier]));
  1223. thisCFI->secDesc[ix].numSecs++;
  1225. #ifdef DEBUG_PRINT
  1226.     DEBUG_PRINT ("Debug: Num sectors in %d - %dn", ix, thisCFI->secDesc[ix].numSecs);
  1227. #endif
  1229. thisCFI->secDesc[ix].secSize = (long) ((*(USHORT *)
  1230. (&flashPtr[(0x2f + (ix * 4)) * thisCFI->multiplier])) +
  1231. (*(USHORT *)(&flashPtr[(0x30 + (ix * 4)) * 
  1232.        thisCFI->multiplier])) * 0x100L);
  1233. #ifdef DEBUG_PRINT
  1234.     DEBUG_PRINT ("Debug: Sector size is 0x%xn",
  1235. (UINT32) thisCFI->secDesc[ix].secSize);
  1236. #endif
  1238. /* TrueFFS does not support the flexible sector architecture so we 
  1239.  * take the largest sector size to be the erase block size.
  1240.  */ 
  1241. if (vol.erasableBlockSize < thisCFI->secDesc[ix].secSize)
  1242.     vol.erasableBlockSize = thisCFI->secDesc[ix].secSize;
  1244. /* Also track the number of sector on this device */
  1245. thisCFI->sectorsInCFI += thisCFI->secDesc[ix].numSecs;
  1246. }
  1248.     if (vol.erasableBlockSize == 0x00)
  1249. vol.erasableBlockSize = 0x80L;
  1250.     else
  1251. vol.erasableBlockSize *= 256;
  1253.     /* Get Device Size */
  1254.     if (eightBitMode)
  1255. vol.chipSize = (1L << flashPtr[0x27 * thisCFI->multiplier]);
  1256.     else
  1257. vol.chipSize = (1L << *(USHORT*)(&flashPtr[0x27 * thisCFI->multiplier]));
  1259.     vol.erasableBlockSize *= vol.interleaving;
  1260.     
  1261. #ifdef SAVE_NVRAM_REGION
  1262.     /* Top boot block devices will loose their entire boot block to NVRAM. Since 
  1263.      * TrueFFS cares not about the subdivisions we reserve an entire erase block
  1264.      * on each of the interleaved devices. 
  1265.      */
  1266.     vol.chipSize -= vol.erasableBlockSize;
  1267. #endif
  1269. #ifdef DEBUG_PRINT
  1270.     DEBUG_PRINT("Debug: %d sectors on devicen", thisCFI->sectorsInCFI);
  1271.     DEBUG_PRINT("Debug: Erasable block size is 0x%lxn", vol.erasableBlockSize);
  1272.     DEBUG_PRINT("Debug: Chip size is 0x%lxn", vol.chipSize);
  1273. #endif
  1274.     /* Since boot blocks happen to be subdevided erase blocks and TrueFFS does
  1275.      * not support the sub devision of erase blocks the MTD needs to be able
  1276.      * to detect the "sectors" that are sub devisions and erase all of them
  1277.      * (assuming that they are contiguous) together. Since the boot block can
  1278.      * appear either at the top or the bottom, the only way to keep track of
  1279.      * them is to read all sector descriptions and remember them for cross
  1280.      * reference. The size of the largest erase block is registered as the
  1281.      * eraseBlockSize for the volume.
  1282.      */
  1284.     /* Setup the commands first */
  1285.     for (i = 0; i < thisCFI->multiplier; i++)
  1286. {
  1287. unlock1   |= AMD_UNLOCK_1   << (i * 8);
  1288. unlock2   |= AMD_UNLOCK_2   << (i * 8);
  1289. readID    |= AMD_READ_ID    << (i * 8);
  1290. readArray   |= AMD_READ_ARRAY << (i * 8);
  1291. }
  1292.     
  1293.     /* Get JEDEC ID so we know if this is a top or bottom boot device */
  1295.     *(UINT32 *)(flashPtr + (thisCFI->unlockAddr1 * thisCFI->multiplier)) = unlock1;
  1296.     *(UINT32 *)(flashPtr + (thisCFI->unlockAddr2 * thisCFI->multiplier)) = unlock2;
  1297.     *(UINT32 *)(flashPtr + (thisCFI->unlockAddr1 * thisCFI->multiplier)) = readID;
  1300.     if (eightBitMode)
  1301.         vol.type = flashPtr[0] << 8 | flashPtr[thisCFI->interleaveWidth];
  1302.     else
  1303. vol.type = (*(USHORT *)(&flashPtr[0]) << 8) | 
  1304.     (*(USHORT *)(&flashPtr[thisCFI->multiplier]) & 0x00ff);
  1306.     /* Determine boot block type */
  1307.     if ((vol.type == Am29DS163DT_FLASH) ||
  1308. (vol.type == Am29DS323DT_FLASH) ||
  1309. (vol.type == Am29PDS322DT_FLASH)||
  1310. (vol.type == Am29SL160CT_FLASH) ||
  1311. (vol.type == Am29DL161DT_FLASH) ||
  1312. (vol.type == Am29DL162DT_FLASH) ||
  1313. (vol.type == Am29DL163DT_FLASH) ||
  1314. (vol.type == Am29DL164DT_FLASH) ||
  1315. (vol.type == Am29LV320DT_FLASH) ||
  1316. (vol.type == Am29DL322DT_FLASH) ||
  1317. (vol.type == Am29DL323DT_FLASH) ||
  1318. (vol.type == Am29DL324DT_FLASH) ||
  1319. (vol.type == Am29LV116DT_FLASH) ||
  1320. (vol.type == Am29F160DT_FLASH)  ||
  1321. (vol.type == Fuj29LV160TE_FLASH))
  1322. thisCFI->bootBlockType = BOOTBLOCK_TOP;
  1323.     else if ((vol.type == Am29DS163DT_FLASH) ||
  1324. (vol.type == Am29DS323DB_FLASH) ||
  1325. (vol.type == Am29PDS322DB_FLASH) ||
  1326. (vol.type == Am29SL160CB_FLASH) ||
  1327. (vol.type == Am29DL161DB_FLASH) ||
  1328. (vol.type == Am29DL162DB_FLASH) ||
  1329. (vol.type == Am29DL163DB_FLASH) ||
  1330. (vol.type == Am29DL164DB_FLASH) ||
  1331. (vol.type == Am29LV320DB_FLASH) ||
  1332. (vol.type == Am29DL322DB_FLASH) ||
  1333. (vol.type == Am29DL323DB_FLASH) ||
  1334. (vol.type == Am29DL324DB_FLASH) ||
  1335. (vol.type == Am29LV116DB_FLASH) ||
  1336. (vol.type == Am29F160DB_FLASH)  ||
  1337. (vol.type == Fuj29LV160BE_FLASH))
  1338. thisCFI->bootBlockType = BOOTBLOCK_BOTTOM;
  1339.     else if ((vol.type == Am29LV017D_FLASH) ||
  1340. (vol.type == Am29LV033C_FLASH) ||
  1341. (vol.type == Am29LV065D_FLASH) ||
  1342. (vol.type == Am29LV640D_FLASH) ||
  1343. (vol.type == Am29F016D_FLASH)  ||
  1344. (vol.type == Am29F017D_FLASH))
  1345. thisCFI->bootBlockType = BOOTBLOCK_NONE;
  1346.     else
  1347. {
  1348. /* Probably an unregistered device that needs to be added here */
  1349. #ifdef DEBUG_PRINT
  1350. DEBUG_PRINT ("Unknown device of type 0x%x n", vol.type);
  1351. #endif
  1352. /* set device back to read array */
  1353. *(UINT32 *) flashPtr = AMD_READ_ARRAY;
  1355. return flUnknownMedia;
  1356. }
  1358.     /* We now have all of the CFI info that we need. Now lets build up 
  1359.      * the sector map and register the erase block sizes. 
  1360.      */
  1362.     if (thisCFI->bootBlockType == BOOTBLOCK_NONE)
  1363. {
  1364. #ifdef DEBUG_PRINT
  1365. DEBUG_PRINT("Debug: Uniform device, no boot blockn");
  1366. #endif
  1367. /* Simplest case is the uniform sector device. Has only one 
  1368.  * sector desc. 
  1369.  */
  1370. for (; thisSector < thisCFI->secDesc[0].numSecs; thisSector++)
  1371.     {
  1372.     thisCFI->secInfo[thisSector].sectorSize = vol.erasableBlockSize;
  1373.     thisCFI->secInfo[thisSector].sectorBaseAdrs = sectorBaseAdrs;
  1374.     sectorBaseAdrs += (CardAddress) vol.erasableBlockSize;
  1375.     }
  1376. }
  1377.     else if (thisCFI->bootBlockType == BOOTBLOCK_BOTTOM)
  1378. {
  1379. #ifdef DEBUG_PRINT
  1380. DEBUG_PRINT("Debug: Bottom boot block devicen");
  1381. #endif
  1382. /* This is a hack but when looking at the data sheets for all of
  1383.  * these devices what comes across is that the CFI data always 
  1384.  * describes a botom boot device. There for we read the sector 
  1385.  * info in the exact order that it is provided in.
  1386.  */
  1387.      for ( ix = 0; ix < thisCFI->sectorDefs; ix++)
  1388.     {
  1389.     int iy;
  1391.             for (iy = 0; iy < thisCFI->secDesc[ix].numSecs; iy++, thisSector++)
  1392.                 {
  1393.      if (thisCFI->secDesc[ix].secSize != 0x00)
  1394.             thisCFI->secInfo[thisSector].sectorSize = 
  1395.     thisCFI->secDesc[ix].secSize * 0x100L;
  1396.      else
  1397.             thisCFI->secInfo[thisSector].sectorSize = 0x80L;
  1399. /* count boot blocks */
  1400. if (thisCFI->secInfo[thisSector].sectorSize != vol.erasableBlockSize)
  1401.     thisCFI->bootBlockSectors++;
  1403.      thisCFI->secInfo[thisSector].sectorBaseAdrs = sectorBaseAdrs;
  1404.      sectorBaseAdrs += (CardAddress) thisCFI->secInfo[thisSector].sectorSize;
  1405.      }
  1406.     }
  1407. }
  1408.     else /* Top boot device */
  1409. {
  1410. int secCount;
  1411. #ifdef DEBUG_PRINT
  1412. DEBUG_PRINT("Debug: Top boot block devicen");
  1413. #endif
  1414. /* First load the descriptions of the uniform sectors and 
  1415.  * then add the sub divisions 
  1416.  */
  1417.      for ( ix = 0; ix < thisCFI->sectorDefs; ix++)
  1418.     {
  1419.     int iy;
  1420.     /* We assume that the unform sectors will never be of the 
  1421.      * variety 128 bytes 
  1422.      */
  1423.     if (vol.erasableBlockSize == thisCFI->secDesc[ix].secSize * 0x100L * vol.interleaving)
  1424. {
  1425.              for (iy = 0; iy < thisCFI->secDesc[ix].numSecs; 
  1426. iy++, thisSector++)
  1427.                     {
  1428.     thisCFI->secInfo[thisSector].sectorSize = 
  1429. vol.erasableBlockSize;
  1430.     thisCFI->secInfo[thisSector].sectorBaseAdrs = 
  1431. sectorBaseAdrs;
  1432.          sectorBaseAdrs += (CardAddress) 
  1433.      thisCFI->secInfo[thisSector].sectorSize;
  1434.     }
  1435. break;
  1436.      }
  1437.     }
  1438. for ( ix = 0, secCount = 0; 
  1439. thisCFI->secDesc[ix].secSize * 0x100L * vol.interleaving
  1440.  != vol.erasableBlockSize; 
  1441. ix++)
  1442.     {
  1443.     int iy;
  1445.     for (iy = 0; iy < thisCFI->secDesc[ix].numSecs; iy++, secCount++)
  1446. {
  1447.      thisCFI->secInfo[(thisCFI->sectorsInCFI - 1) - secCount].sectorSize = 
  1448. thisCFI->secDesc[ix].secSize * 0x100L * vol.interleaving;
  1449. }
  1450.     }
  1452. for (; thisSector <= (thisCFI->sectorsInCFI -1); thisSector++)
  1453.     {
  1454.     thisCFI->secInfo[thisSector].sectorBaseAdrs = sectorBaseAdrs;
  1455.          sectorBaseAdrs += (CardAddress) thisCFI->secInfo[thisSector].sectorSize;
  1456.     thisCFI->bootBlockSectors++;
  1457.     }
  1458. }
  1459. #ifdef DEBUG_PRINT
  1460.     DEBUG_PRINT("Debug: Number of boot block sectors is %dn", thisCFI->bootBlockSectors);
  1461. #endif
  1462.     /* Make sure this comes at the end since the device is set to READ_ARRAY
  1463.      * mode prior to the return
  1464.      */
  1465.     if (cfiAmdChipCountGet(&vol) != flOK)
  1466. return flUnknownMedia;
  1467. #ifdef DEBUG_PRINT
  1468.     DEBUG_PRINT ("Debug: No of chips detected is %dn", vol.noOfChips);
  1469. #if 0
  1470.     for (ix = 0; ix < thisCFI->sectorsInCFI; ix++)
  1471. DEBUG_PRINT ("%2d:0x%x ---  0x%lxn", ix,
  1472. thisCFI->secInfo[ix].sectorBaseAdrs, 
  1473. thisCFI->secInfo[ix].sectorSize);
  1474. #endif
  1475. #endif
  1477.     vol.erase = cfiAmdErase;
  1478.     vol.write = cfiAmdWrite;
  1480.     /* Might have to do this on a bus width basis but for now it seems to
  1481.      * work with Intel devices.
  1482.      */
  1483.     flashPtr[0] = AMD_READ_ARRAY;
  1484.     flashPtr[1] = AMD_READ_ARRAY;
  1485.     flashPtr[2] = AMD_READ_ARRAY;
  1486.     flashPtr[3] = AMD_READ_ARRAY;
  1488.     return flOK;
  1489.     }