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

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

VxWorks

开发平台：

C/C++

cfiscs.c：源码内容
  1. /* cfiscs.c - MTD for devices that comply with CFI and the Intel SCS */
  3. /* Copyright 1984-2001 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. 01h,24jun02,nrv  fixing the condition where flashPtr[0x24] is checked twice
  13. 01g,12dec01,yp   removing assumption that the InterleavedWordWrite call might
  14.                  have to support 16 bit commands. reworked identification of
  15.                  two 16 bit devices and single 32 bit device. made erase
  16.                  routines mutually exclusive at compile time. removed dataWidth
  17.  and deviceWidth members from CFI structure. removed unused 
  18.  MakeCmd function.
  19. 01f,11dec01,nrv  fixed build error
  20. 01e,29oct01,yp   Converting to WRS coding convention. Adding support for double
  21.  word width devices. Converting identification process to byte 
  22.  offsets. Providing alternative write mechanism for none 
  23.  functional WRITE_TO_BUFFER paltforms.
  24. 01d,.......,vf   Added for debugging of this MTD.
  25. 01c,06apr99,vf   Try to make endian-safe.  LONGSWAP and WORDSWAP are 
  26.  #define'd in vxWorks.h.
  27. 01b,09jan99,an   Added support for machines that require a full 32bit write to 
  28.  access fall correctly. Also fixed code to correctly compute 
  29.  total Flash size, virtual block size, and combined write buffer
  30.  size when interleaved parts are detected.
  31. 01a,27may97,msys original version from M-Systems
  32. */
  34. /* Original CVS history
  35.  * $Log: cfiscs.c,v $
  36.  * Revision 1.1  2000/07/13 01:46:37  caluml
  37.  * Added TFFS and bootParams stuff
  38.  *
  39.  * Revision 1.1.1.1  2000/05/31 00:09:33  caluml
  40.  * T201 Arm Ugl2
  41.  *
  42.  * Revision 1.1  2000/04/14 16:26:14  caluml
  43.  * This version is for the Assabet board with 32Mb of StrataFlash memory
  44.  *
  45.  *
  46.  *    Rev 1.20   11 Nov 1997 15:26:00   ANDRY
  47.  * get rid of compiler warnings
  48.  *
  49.  *    Rev 1.19   06 Oct 1997  9:53:30   danig
  50.  * VPP functions under #ifdef
  51.  *
  52.  *    Rev 1.18   18 Sep 1997 10:05:40   danig
  53.  * Warnings
  54.  *
  55.  *    Rev 1.17   10 Sep 1997 16:31:16   danig
  56.  * Got rid of generic names
  57.  *
  58.  *    Rev 1.16   04 Sep 1997 18:19:34   danig
  59.  * Debug messages
  60.  *
  61.  *    Rev 1.15   31 Aug 1997 14:50:52   danig
  62.  * Registration routine return status
  63.  *
  64.  *    Rev 1.14   27 Jul 1997 15:00:38   danig
  65.  * FAR -> FAR0
  66.  *
  67.  *    Rev 1.13   21 Jul 1997 19:58:24   danig
  68.  * No watchDogTimer
  69.  *
  70.  *    Rev 1.12   15 Jul 1997 19:18:32   danig
  71.  * Ver 2.0
  72.  *
  73.  *    Rev 1.11   09 Jul 1997 10:58:52   danig
  74.  * Fixed byte erase bug & changed identification routines
  75.  *
  76.  *    Rev 1.10   20 May 1997 14:48:02   danig
  77.  * Changed overwrite to mode in write routines
  78.  *
  79.  *    Rev 1.9   18 May 1997 13:54:58   danig
  80.  * JEDEC ID independent
  81.  *
  82.  *    Rev 1.8   13 May 1997 16:43:10   danig
  83.  * Added getMultiplier.
  84.  *
  85.  *    Rev 1.7   08 May 1997 19:56:12   danig
  86.  * Added cfiscsByteSize
  87.  *
  88.  *    Rev 1.6   04 May 1997 14:01:16   danig
  89.  * Changed cfiscsByteErase and added multiplier
  90.  *
  91.  *    Rev 1.4   15 Apr 1997 11:38:52   danig
  92.  * Changed word identification and IDs.
  93.  *
  94.  *    Rev 1.3   15 Jan 1997 18:21:40   danig
  95.  * Bigger ID string buffers and removed unused definitions.
  96.  *
  97.  *    Rev 1.2   08 Jan 1997 14:54:06   danig
  98.  * Changes in specification
  99.  *
  100.  *    Rev 1.1   25 Dec 1996 18:21:44   danig
  101.  * Initial revision
  102.  */
  104. /*
  105. DESCRIPTION
  106. This library provides an MTD for devices that conform to the Common Flash 
  107. Interface (CFI) and the Intel Scalable Command Set (SCS). The library provides 
  108. identification, erase and write routines for 8, 16, and 32 bit devices in 
  109. native or byte mode. Support is also added for word width devices 
  110. interleaved in word width mode where bytes 0 and 1 would be on device one 
  111. and bytes 2 and 3 would be on device two. Support is also present for 
  112. configurations thatonly permit double word width writes.
  114. The identification process supports byte, word, and double word width devices 
  115. as specified by the CFI query process. Vendr specific extentions are made 
  116. available from an instance specific data structure, referred to in this file 
  117. as thisCFI. However, the driver remains vendor nutral in the hope that it 
  118. will be applicable to a larger range of devices.
  120. In addition to supporting a boot code region this driver is also able to 
  121. reserve the last erase block of each device in the array so the vxWorks may
  122. use this region as NVRAM if the macro SAVE_NVRAM_REGION is defined.
  124. Some hardware using word width interleaved devices permit only 32 bit writes.
  125. In these environments the macro INTERLEAVED_MODE_REQUIRES_32BIT_WRITES must 
  126. be defined. The erase routine in particular and some of the write routines are 
  127. impacted by this. 
  129. BSPs tested:
  131. BSP Device Socket Defines
  132. Assabet StrataFlash RFA 32_BIT_WRITES
  133. SAVE_NVRAM
  134. ddb5476 StrataFlash RFA
  135. pcPentum3 StrataFlash PCMCIA
  136. ads860 StrataFlash PCMCIA
  137. prpm800 StrataFlash RFA BUFFER_WRITE_BROKEN
  138. integrator StrataFlash RFA SAVE_NVRAM
  139. (720/920)
  141. NOMANUAL
  142. */
  144. #include <stdio.h>
  145. #include "tffs/flflash.h"
  146. #include "tffs/backgrnd.h"
  148. /* Instance specific CFI data so that a system may have more than one CFI
  149.  * device. */
  150. typedef struct {
  152.   unsigned         commandSetId;            /* id of a specific command set. */
  153.   unsigned         altCommandSetId;         /* id of alternate command set.  */
  154.   FLBoolean        wordMode;                /* TRUE - word mode.             */
  155.     /* FALSE - byte mode.            */
  156.   int              multiplier;              /* the number of bytes in       */
  157.     /* addressing scheme      */
  158.   int    interleaveFactor;     /* Number of bytes interleaved   */
  159.   unsigned         maxBytesWrite;           /* maximum number of bytes       */
  160.     /* in multi-byte write.          */
  161.   FLBoolean        vpp;                     /* if = TRUE, need vpp.          */
  162.   long             optionalCommands;        /* optional commands supported   */
  163.     /* (1 = yes, 0 = no):            */
  164.     /* bit 0 - chip erase.           */
  165.     /* bit 1 - suspend erase.        */
  166.     /* bit 2 - suspend write         */
  167.     /* bit 3 - lock/unlock.          */
  168.     /* bit 4 - queued erase.         */
  169.   unsigned         afterSuspend;            /* functions supported after     */
  170.     /* suspend (1 = yes, 0 = no):    */
  171.     /* bit 0 - write after erase     */
  172.     /*         suspend.              */
  173. } CFI;
  175. LOCAL CFI mtdVars[DRIVES];
  178. /* defines */
  180. /* 
  181.  * define the following if the target requires interleaves to be 
  182.  * full 32 bit write accesses when erasing blocks. The Assabet BSP
  183.  * is the onlyone requiring this so far.
  184.  */
  185. #undef INTERLEAVED_MODE_REQUIRES_32BIT_WRITES
  187. /* Save the last erase block on each device discovered in the array 
  188.  * for NVRAM */
  189. #define SAVE_NVRAM_REGION
  191. /* disable debugging */
  192. #define CFI_DEBUG
  194. #ifdef CFI_DEBUG
  195. #define DEBUG_PRINT    printf
  196. #else
  197. #undef DEBUG_PRINT
  198. #endif
  200. /* define the following if the WRITE_TO_BUFFER command does not work
  201.  * The value of maxBytesWrite is then forced to 1, resulting in either 
  202.  * byte or word writes being used
  203.  */
  204. #undef  BUFFERED_WRITE_BROKEN
  206. #ifndef _BYTE_ORDER
  207. #error "Error: _BYTE_ORDER needs to be #define'd.  Try #include "vxWorks.h" "
  208. #endif
  210. #if (_BYTE_ORDER == _BIG_ENDIAN)
  212. #define CFI_LONGSWAP(x) LONGSWAP(x) /* swap everything in a long word */
  213. #define CFI_WORDSWAP(x) WORDSWAP(x) /* swap the shorts in a long */
  214. #define CFI_BYTESWAP(x) ( ( (x & 0xff) << 8) | ( (x >> 8) & 0xff) )  /* Swap bytes in a short */
  216. #else
  218. #define CFI_LONGSWAP(x) (x) /* pass it as is */
  219. #define CFI_WORDSWAP(x) (x) /* pass it as is */
  220. #define CFI_BYTESWAP(x) (x) /* pass it as is */
  222. #endif /* _BYTE_ORDER == _BIG_ENDIAN */
  224. #define CFI_LONG_WRITE(addr, data)  (*(ULONG *)addr = (ULONG)(CFI_LONGSWAP(data)))
  225. #define CFI_WORD_WRITE(addr, data)  (*(USHORT *)addr = (USHORT)(CFI_WORDSWAP(data)))
  226. #define CFI_WORD_READ(addr)         (CFI_BYTESWAP(*(USHORT *)addr))
  227. #define CFI_LONG_READ(addr)         (CFI_WORDSWAP(*(ULONG *)addr))
  229. /* JEDEC-IDs */
  231. #define VOYAGER_ID              0x8915
  232. #define KING_COBRA_ID           0xb0d0
  234. /* command set IDs */
  236. #define INTEL_COMMAND_SET      0x0001
  237. #define AMDFUJ_COMMAND_SET     0x0002
  238. #define INTEL_ALT_COMMAND_SET  0x0001
  239. #define AMDFUJ_ALT_COMMAND_SET 0x0004
  240. #define ALT_NOT_SUPPORTED      0x0000
  243. /* CFI identification strings */
  245. #define ID_STR_LENGTH      3
  246. #define QUERY_ID_STR       "QRY"
  247. #define PRIMARY_ID_STR     "PRI"
  248. #define ALTERNATE_ID_STR   "ALT"
  251. /* commands */
  253. #define CONFIRM_SET_LOCK_BIT    0x01
  254. #define PROGRAM_WORD            0x10
  255. #define SETUP_BLOCK_ERASE       0x20
  256. #define SETUP_QUEUE_ERASE       0x28
  257. #define SETUP_CHIP_ERASE        0x30
  258. #define PROGRAM                 0x40
  259. #define CLEAR_STATUS            0x50
  260. #define SET_LOCK_BIT            0x60
  261. #define CLEAR_LOCK_BIT          0x60
  262. #define READ_STATUS             0x70
  263. #define READ_ID                 0x90
  264. #define QUERY                   0x98
  265. #define SUSPEND_WRITE           0xb0
  266. #define SUSPEND_ERASE           0xb0
  267. #define CONFIG                  0xb8
  268. #define CONFIRM_WRITE           0xd0
  269. #define RESUME_WRITE            0xd0
  270. #define CONFIRM_ERASE           0xd0
  271. #define RESUME_ERASE            0xd0
  272. #define CONFIRM_CLEAR_LOCK_BIT  0xd0
  273. #define WRITE_TO_BUFFER         0xe8
  274. #define READ_ARRAY              0xff
  277. /* status register bits */
  279. #define WSM_ERROR               0x3a
  280. #define SR_BLOCK_LOCK           0x02
  281. #define SR_WRITE_SUSPEND        0x04
  282. #define SR_VPP_ERROR            0x08
  283. #define SR_WRITE_ERROR          0x10
  284. #define SR_LOCK_SET_ERROR       0x10
  285. #define SR_ERASE_ERROR          0x20
  286. #define SR_LOCK_RESET_ERROR     0x20
  287. #define SR_ERASE_SUSPEND        0x40
  288. #define SR_READY                0x80
  291. /* optional commands support */
  293. #define CHIP_ERASE_SUPPORT           0x0001
  294. #define SUSPEND_ERASE_SUPPORT        0x0002
  295. #define SUSPEND_WRITE_SUPPORT        0x0004
  296. #define LOCK_SUPPORT                 0x0008
  297. #define QUEUED_ERASE_SUPPORT         0x0010
  300. /* supported functions after suspend */
  302. #define WRITE_AFTER_SUSPEND_SUPPORT  0x0001
  304. #define thisCFI   ((CFI *)vol.mtdVars)
  307. /******************************************************************************
  308.  * cfiscsGetChipCount - return the number of chips in this array
  309.  *
  310.  * Leave the first chip (or set of interleaved chips) in READ_ARRAY
  311.  * mode and move forward by chip size (or interleaved chip size) until
  312.  * address wrap around is detected. The chip count is updated in 
  313.  * vol.noOfChips.
  314.  *
  315.  * NOMANUAL
  316.  *
  317.  */
  319. LOCAL FLStatus cfiscsGetChipCount
  320.     (
  321.     FLFlash vol
  322.     )
  323.     {
  324.     UINT32 cmdBuffer;
  325.     int ix;
  326.     char queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
  328.     FlashPTR flashPtr = (FlashPTR) flMap(vol.socket, 0);
  330.     /* Switch first (interleaved) chip set to QUERY mode */
  331.     cmdBuffer = 0x0;
  332.     for (ix = 0; ix < thisCFI->multiplier; ix++)
  333. cmdBuffer |= QUERY << (8 * ix);
  334.     flashPtr[0x55 * thisCFI->multiplier] = cmdBuffer;
  336.     /* NOTE: The address wrap around technique used here works only if the flash
  337.      * size was declared correctly in the socket driver. At some point the MTD
  338.      * should be discovering flash size and exporting it to the socket driver. 
  339.      */
  341.     for (vol.noOfChips = 1 * vol.interleaving;       /* Scan the chips */
  342.          vol.noOfChips < 2000;  /* Big enough ? */
  343.          vol.noOfChips += vol.interleaving) 
  344.         {
  345. #ifdef SAVE_NVRAM_REGION
  346. /* Reinstate the NVRAM region */
  347. flashPtr = (FlashPTR) flMap(vol.socket, vol.noOfChips * 
  348. (vol.chipSize + (vol.erasableBlockSize / vol.interleaving)));
  349. #else
  350. flashPtr = (FlashPTR) flMap(vol.socket, vol.noOfChips * vol.chipSize);
  351. #endif
  353. #ifdef DEBUG_PRINT
  354. DEBUG_PRINT("Debug: Looking for Flash device at base 0x%xn", (UINT32) flashPtr);
  355. #endif
  356. if ((flashPtr[0x10 * thisCFI->multiplier]) 
  357.     == (unsigned char)queryIdStr[0] &&
  358.     (flashPtr[0x11 * thisCFI->multiplier]) 
  359.     == (unsigned char)queryIdStr[1] &&
  360.     (flashPtr[0x12 * thisCFI->multiplier]) 
  361.     == (unsigned char)queryIdStr[2])
  362.     {
  363.     goto noMoreChips;      /* Wrapped around */
  364.     }
  366. /* Confirm this is also a CFI part */
  367. *(UCHAR *)(flashPtr + (0x55 * thisCFI->multiplier))
  368.    = (UCHAR)(QUERY);
  369. if (flashPtr[0x10 * thisCFI->multiplier]
  370. != (unsigned char)queryIdStr[0] ||
  371.     flashPtr[0x11 * thisCFI->multiplier]
  372. != (unsigned char)queryIdStr[1] ||
  373.     flashPtr[0x12 * thisCFI->multiplier]
  374. != (unsigned char)queryIdStr[2])
  375.     {
  376.     /* Should not happen !! */
  377.     goto noMoreChips; /* Not a CFI Flash part */
  378.     }
  380. flashPtr[0x55 * thisCFI->multiplier] 
  381. = (UCHAR)(CLEAR_STATUS);
  382. flashPtr[0x55 * thisCFI->multiplier] 
  383. = (UCHAR)(READ_ARRAY);
  384. }
  385.     /* We should never get here. */
  386. #ifdef DEBUG_PRINT
  387.     DEBUG_PRINT("Debug: Device count overflown");
  388. #endif  /* DEBUG_PRINT */
  389.     return flGeneralFailure;
  390.     
  391. noMoreChips:
  392.     flashPtr = (FlashPTR) flMap(vol.socket, 0);
  393.     /* Switch to READ_ARRAY mode */
  394.     cmdBuffer = 0x0;
  395.     for (ix = 0; ix < thisCFI->multiplier; ix++)
  396. cmdBuffer |= READ_ARRAY << (8 * ix);
  397.     flashPtr[0x55 * thisCFI->multiplier] = cmdBuffer;
  399.     return flOK;
  400.     }
  402. /******************************************************************************
  403.  * cfiscsByteWrite - byte write routine
  404.  *
  405.  * This routine is intended to be registered as the write routine in systems
  406.  * that have byte wide devices interleaved or devices that are in byte mode.
  407.  *
  408.  * NOMANUAL
  409.  *
  410.  */
  412. LOCAL FLStatus cfiscsByteWrite
  413.     (
  414.     FLFlash vol,
  415.     CardAddress address,
  416.     const void FAR1 *buffer,
  417.     int length,
  418.     int mode
  419.     )
  420.     {
  421.     FLStatus status = flOK;
  422.     FlashPTR flashPtr;
  423.     unsigned int i, from, eachWrite;
  424.     const char FAR1 *temp = (const char FAR1 *)buffer;
  425.     /* Set timeout to 5 seconds from now */
  426.     unsigned long writeTimeout = flMsecCounter + 5000;
  428.     if (flWriteProtected(vol.socket))
  429. return flWriteProtect;
  431. #ifdef SOCKET_12_VOLTS
  432.     if (thisCFI->vpp)
  433. checkStatus(flNeedVpp(vol.socket));
  434. #endif
  436.     if (thisCFI->maxBytesWrite > 1) /* multi-byte write supported */
  437. eachWrite = thisCFI->maxBytesWrite * vol.interleaving;
  438.     else
  439. eachWrite = vol.interleaving;
  441.     for (from = 0; (int)from < length && status == flOK; from += eachWrite) 
  442. {
  443. int thisLength = length - from;
  444. FlashPTR currPtr;
  445. unsigned tailBytes, lengthByte;
  447. if (thisLength > (int)eachWrite)
  448.     thisLength = eachWrite;
  450. lengthByte = thisLength / vol.interleaving;
  451. tailBytes = thisLength % vol.interleaving;
  453. flashPtr = (FlashPTR) flMap(vol.socket, address + from);
  455. for (i = 0, currPtr = flashPtr;
  456.     ((int)i < vol.interleaving) && ((int)i < thisLength);
  457.     i++, currPtr++) 
  458.     {
  459.     do 
  460. {
  461. *currPtr = WRITE_TO_BUFFER;
  462. } while (!(*currPtr & SR_READY) && 
  463. (flMsecCounter < writeTimeout));
  464.     if (!(*currPtr & SR_READY)) 
  465. {
  466. #ifdef DEBUG_PRINT
  467. DEBUG_PRINT("Debug: timeout error in CFISCS write.n");
  468. #endif
  469. status = flWriteFault;
  470. }
  471.     *currPtr = i < tailBytes ? lengthByte : lengthByte - 1;
  472.     }
  474. tffscpy((unsigned long FAR0 *) flashPtr,temp + from,thisLength);
  476. for (i = 0, currPtr = flashPtr;
  477. ((int)i < vol.interleaving) && ((int)i < thisLength);
  478. i++, currPtr++)
  479.     *currPtr = CONFIRM_WRITE;
  481. for (i = 0, currPtr = flashPtr;
  482. ((int)i < vol.interleaving) && ((int)i < thisLength);
  483. i++, currPtr++) 
  484.     {
  485.     while (!(*currPtr & SR_READY) && (flMsecCounter < writeTimeout))
  486. ;
  487.     if (!(*currPtr & SR_READY)) 
  488. {
  489. #ifdef DEBUG_PRINT
  490. DEBUG_PRINT("Debug: timeout error in CFISCS write.n");
  491. #endif
  492. status = flWriteFault;
  493. }
  494.     if (*currPtr & WSM_ERROR) 
  495. {
  496. #ifdef DEBUG_PRINT
  497. DEBUG_PRINT("Debug: error in CFISCS write.n");
  498. #endif
  499. status = (*currPtr & SR_VPP_ERROR) ? 
  500.     flVppFailure : flWriteFault;
  501. *currPtr = CLEAR_STATUS;
  502. }
  503.     *currPtr = READ_ARRAY;
  504.     }
  505. }
  507. #ifdef SOCKET_12_VOLTS
  508.     if (thisCFI->vpp)
  509.      flDontNeedVpp(vol.socket);
  510. #endif
  512.     flashPtr = (FlashPTR) flMap(vol.socket, address);
  513.     /* verify the data */
  514.     if (status == flOK && tffscmp((void FAR0 *) flashPtr,buffer,length)) 
  515.      {
  516. #ifdef DEBUG_PRINT
  517.      DEBUG_PRINT("Debug: CFISCS write failed in verification.n");
  518. #endif
  519.      status = flWriteFault;
  520.      }
  522.     return status;
  524.     }
  526. /*****************************************************************************
  527.  * cfiscsWordWrite - write routine for 16 bit devices 
  528.  *                                                                     
  529.  * Write a block of bytes to Flash in a word-mode.                    
  530.  *                                                                   
  531.  * This routine will be registered as the MTD flash.write routine   
  532.  *                                                                 
  533.  * Parameters:                                                    
  534.  *      vol             : Pointer identifying drive              
  535.  *      address         : Card address to write to              
  536.  *      buffer          : Address of data to write             
  537.  *      length          : Number of bytes to write            
  538.  *      mode            : write mode (overwrite yes/no)      
  539.  *                                                          
  540.  * Returns:                                                
  541.  *      FLStatus        : 0 on success, failed otherwise  
  542.  *
  543.  * NOMANUAL
  544.  *
  545.  */
  546. LOCAL FLStatus cfiscsWordWrite
  547.     (
  548.     FLFlash vol,
  549.     CardAddress address,
  550.     const void FAR1 *buffer,
  551.     int length,
  552.     int mode
  553.     )
  554.     {
  555.     FLStatus status = flOK;
  556.     FlashWPTR flashPtr;
  557.     int from, eachWrite;
  558.     const char FAR1 *temp = (const char FAR1 *)buffer;
  559.     /* Set timeout to 5 seconds from now */
  560.     unsigned long writeTimeout = flMsecCounter + 5000;
  562.     if (flWriteProtected(vol.socket))
  563. return flWriteProtect;
  565.     if ((length & 1) || (address & 1)) /* Only write words on word-boundary */
  566. return flBadParameter;
  568. #ifdef SOCKET_12_VOLTS
  569.     if (thisCFI->vpp)
  570. checkStatus(flNeedVpp(vol.socket));
  571. #endif
  573.     if (thisCFI->maxBytesWrite > 1) /* multi-byte write supported */
  574. eachWrite = thisCFI->maxBytesWrite / 2;   /* we are counting words */
  575.     else
  576. eachWrite = 1;
  578.     /* we assume that the interleaving is 1. */
  579.     for (from = 0; (from < length / 2) && (status == flOK); from += eachWrite) 
  580. {
  581. int thisLength = (length / 2) - from;
  583. if (thisLength > eachWrite)
  584.     thisLength = eachWrite;
  586. flashPtr = (FlashWPTR)flMap(vol.socket, address + from * 2);
  588. if (thisLength == 1) 
  589.     {
  590.     *flashPtr = PROGRAM ;
  591.     *flashPtr = * ( (FlashWPTR) (temp + from * 2) ) ;
  592.     } 
  593. else 
  594.     {
  595.     /* count > 1 so do a multiple write */
  596.     do 
  597. {
  598. *flashPtr = WRITE_TO_BUFFER;
  599. } while (!(*flashPtr & SR_READY) && (flMsecCounter < writeTimeout));
  600.     if (!(*flashPtr & SR_READY)) 
  601. {
  602. #ifdef DEBUG_PRINT
  603. DEBUG_PRINT("Debug: timeout error in CFISCS write.n");
  604. #endif
  605. status = flWriteFault;
  606. }
  607.     *flashPtr = thisLength - 1;
  609.     tffscpyWords((unsigned long FAR0 *) flashPtr, temp + from * 2, thisLength * 2);
  611.     *flashPtr = CONFIRM_WRITE;
  612.     }
  613. while (!(*flashPtr & SR_READY) && (flMsecCounter < writeTimeout))
  614.       ;
  615. if (!(*flashPtr & SR_READY)) 
  616.     {
  617. #ifdef DEBUG_PRINT
  618.     DEBUG_PRINT("Debug: timeout error in CFISCS write.n");
  619. #endif
  620.     status = flWriteFault;
  621.     }
  622. if (*flashPtr & WSM_ERROR) 
  623.     {
  624. #ifdef DEBUG_PRINT
  625.     DEBUG_PRINT("Debug: CFISCS write error.n");
  626. #endif
  627.     status = (*flashPtr & SR_VPP_ERROR) ? flVppFailure : flWriteFault;
  628.     *flashPtr = CLEAR_STATUS;
  629.     }
  630. *flashPtr = READ_ARRAY;
  631.         }
  633. #ifdef SOCKET_12_VOLTS
  634.     if (thisCFI->vpp)
  635. flDontNeedVpp(vol.socket);
  636. #endif
  638.     flashPtr = (FlashWPTR) flMap(vol.socket, address);
  639.     /* verify the data */
  640.     if (status == flOK && tffscmp((void FAR0 *) flashPtr,buffer,length)) 
  641. {
  642. #ifdef DEBUG_PRINT
  643. DEBUG_PRINT("Debug: CFISCS write failed in verification.n");
  644. #endif
  645. status = flWriteFault;
  646. }
  648.     return status;
  649.     }
  651. /******************************************************************************
  652.  * cfiscsInterleavedWordWrite - write routine 16 bit interleaved devices
  653.  *                                                                 
  654.  * This routine will be registered as the MTD flash.write routine      
  655.  *                                                                    
  656.  * Parameters:                                                       
  657.  *      vol             : Pointer identifying drive                 
  658.  *      address         : Card address to write to                 
  659.  *      buffer          : Address of data to write                
  660.  *      length          : Number of bytes to write               
  661.  *      mode            : write mode (overwrite yes/no)         
  662.  *                                                             
  663.  * Returns:                                                   
  664.  *      FLStatus        : 0 on success, failed otherwise     
  665.  *
  666.  * NOMANUAL
  667.  *
  668.  */
  669. LOCAL FLStatus cfiscsInterleavedWordWrite
  670.     (
  671.     FLFlash vol,
  672.     CardAddress address,
  673.     const void FAR1 *buffer,
  674.     int length,
  675.     int mode
  676.     )
  677.     {
  678.     FLStatus status = flOK;
  679.     FlashWPTR flashPtr;
  680.     unsigned long maxWordsPerWrite,  /* Number of words per WRITE/WRITE_BUFFER 
  681. command. */
  682.                 wordsWritten,      /* total written so far */
  683.                 wordsRemaining,    /* number of words left to go */
  684.                 wordsThisWrite;    /* number of words */
  685.  
  686.     if (flWriteProtected(vol.socket))
  687. return flWriteProtect;
  689.     if ((length & 1) || (address & 1))  /* Only write whole words, 
  690.    only on word-boundary */
  691. return flBadParameter;
  693. #ifdef SOCKET_12_VOLTS
  694.     if (thisCFI->vpp)
  695. checkStatus(flNeedVpp(vol.socket));
  696. #endif
  698.     if (thisCFI->maxBytesWrite > 1) /* multi-byte write supported? */
  699.         maxWordsPerWrite = thisCFI->maxBytesWrite;
  700.     else
  701. maxWordsPerWrite = 1;  /* Part can only handle single-byte writes. */
  703.     flashPtr = (FlashWPTR)flMap(vol.socket, address);
  705.     /* Now program the part: */
  706.     if (maxWordsPerWrite > 1)  /* Part can handle writes of multiple 
  707.   words to buffer */
  708. {
  709.         wordsWritten = 0;
  710.         wordsRemaining = length / 2;  /* Number of words left to program into 
  711.  a part, convert bytes to words. */
  712.         while (wordsRemaining > 0)
  713.     {
  714.     /* Figure out how many words we need to write.  This will either 
  715.      * be the max allowed (maxWordsPerWrite), or what's left over at 
  716.      * the end (wordsRemaining).  Make it extra-cryptic with the
  717.      * ?: operator.
  718.      */
  719.      wordsThisWrite = (wordsRemaining > maxWordsPerWrite) 
  720.  ? maxWordsPerWrite : wordsRemaining;
  721.   
  722.     /* if we dont have enough aligned data to use a buffered write 
  723.      * we just use a normal write */
  724.     if ( (wordsThisWrite <2 ) && (wordsThisWrite > 0))
  725. {
  726. /* data is a 1's mask, so we only try overwriting the 
  727.  * bytes we desire ie. written a 1 should not change 
  728.  * the state of an erase bit */
  729. int byteCount;
  730.         ULONG data = 0xffffffff; 
  731.         /* clear out the bytes we are going to overwrite */
  732. for(byteCount = 0; byteCount<length; byteCount++)
  733.     data &= ~(0xff << (byteCount*8));
  734. /* set the bits we dont want to clear in our data */
  735. data |= CFI_LONGSWAP(* (ULONG *) buffer);
  736. CFI_LONG_WRITE(flashPtr, (ULONG) (PROGRAM<<16) |PROGRAM);
  737. CFI_LONG_WRITE(flashPtr, (ULONG) data);
  738. /* Flow diagram says to check that status register says 
  739.  * everything is copacetic. */
  740. while ( (!(CFI_WORD_READ(flashPtr) & SR_READY)) ||
  741.       (!(CFI_WORD_READ((flashPtr + 1)) & SR_READY)) );  
  742. CFI_LONG_WRITE(flashPtr, (ULONG) (READ_ARRAY<<16) |READ_ARRAY); 
  744. #ifdef DEBUG_PRINT
  745.   DEBUG_PRINT("Debug: mtd: Using NON-buffered write to program %ld words at addr 0x%lxn", 
  746.       wordsThisWrite, (ULONG) flashPtr);
  747. #endif
  748. }
  749.     else
  750. {
  751.                 CFI_LONG_WRITE(flashPtr, (ULONG) ((CLEAR_STATUS<<16)
  752.                         |CLEAR_STATUS));
  753. CFI_LONG_WRITE(flashPtr, (ULONG) (WRITE_TO_BUFFER<<16) 
  754. |WRITE_TO_BUFFER);  /* both parts */
  755.       
  756. /* At this point, we must wait for XSR to indicate a buffer is 
  757.  * available. We will spin on this, but only for a maximum of 5 
  758.  * seconds.  We do the timing by taking advantage of the 
  759.  * ever-incrementing flMsecCounter.
  760.  */
  761.  while ((!(CFI_WORD_READ((FlashWPTR)(flashPtr)) & SR_READY)) ||
  762.       (!(CFI_WORD_READ((FlashWPTR)(flashPtr + 1)) & SR_READY)))
  763.      ;
  764.       
  765.  /* Check to see if either part timed out: */
  766.  if ( (!(CFI_WORD_READ(&flashPtr[0x0])     & SR_READY)) ||
  767.     (!(CFI_WORD_READ((&flashPtr[0x1])) & SR_READY)) )
  768.     {
  769.     /* Send read-array command to both parts, abort. */
  770.     CFI_LONG_WRITE(flashPtr, (ULONG) (READ_ARRAY<<16) |READ_ARRAY);
  771.     return(flWriteFault);
  772.     }
  773.       
  774.  /* Now we must write the count value (zero-based, so 0 => 1 word,
  775.   * 1 => 2 words, etc.) for the number of words we intend to 
  776.   * write.  Note that this code always assumes an even number of 
  777.   * words > 0.  Half the words go in the even part, half go in the 
  778.   * odd part.
  779.   */
  780.   CFI_LONG_WRITE(flashPtr, (ULONG)(((wordsThisWrite / 2)  - 1)
  781.   <<16) | ((wordsThisWrite / 2) - 1));  /* both parts */
  782.       
  783.   /* Finally, write the data.  This is easy, because now the 
  784.    * flash parts are seen as memory addresses.
  785.    */
  786.   /* FIXME: This is suboptimal.  It is only writing half the 
  787.    * maximum words that could be written to each part in buffered 
  788.    * write mode. If we double the assignments for wordsWritten & 
  789.    * wordsThisWrite, and halve the assignment for wordsRemaining 
  790.    * each iteration, we can probably make this work optimally.
  791.    * Then we should probably rename some of the variables to 
  792.    * "longsxxx".
  793.    */
  794.   /* last arguement is expected in bytes */
  795.   tffscpyLongs(&((long *)flashPtr)[wordsWritten/2], 
  796.   &((long *)buffer)[wordsWritten/2], wordsThisWrite*2);
  797.       
  798.   /* Now send CONFIRM_WRITE command. */
  799.   CFI_LONG_WRITE(flashPtr, (ULONG) (CONFIRM_WRITE<<16) 
  800.     | CONFIRM_WRITE);  /* both parts */
  801.   /* Flow diagram says to check that status register says 
  802.    * everything is copacetic. */
  803.   while ( (!(CFI_WORD_READ(flashPtr)     & SR_READY)) ||
  804. (!(CFI_WORD_READ((flashPtr + 1)) & SR_READY)) ); 
  805.   
  806.   /* Check to see if either part timed out: */
  807.   if ( (!(CFI_WORD_READ(flashPtr)     & SR_READY)) ||
  808.      (!(CFI_WORD_READ((flashPtr + 1)) & SR_READY)) )
  809.      {
  810.      /* Send read-array command to both parts, abort. */
  811.      CFI_LONG_WRITE(flashPtr, (ULONG)(READ_ARRAY<<16) 
  812.     | READ_ARRAY);
  813.      return(flWriteFault);
  814.      }
  815.   else
  816.      {
  817.      CFI_LONG_WRITE(flashPtr, (ULONG)(READ_ARRAY<<16) 
  818. | READ_ARRAY);
  819.      }
  820.        /* Now verify the write. */
  821.        if (tffscmpWords(&((long *)flashPtr)[wordsWritten/2],
  822.        &((long *)buffer)[wordsWritten/2], wordsThisWrite*2))
  823.    {
  824. #ifdef DEBUG_PRINT
  825.    DEBUG_PRINT("Debug: mtd: Buffer write verification failed (interleaved word mode)n");
  826. #endif
  827.    return flWriteFault;
  828.    }
  829.       else
  830.    {
  831. #ifdef DEBUG_PRINT
  832.   DEBUG_PRINT("Debug: mtd: Buffer write verification passed (interleaved word mode) at addr 0x%lxn", 
  833.   (ULONG) flashPtr);
  834. #endif
  835.    }
  836. }
  837.       wordsRemaining  -= wordsThisWrite;  /* That many fewer words 
  838.    * to go. */
  839.       wordsWritten    += wordsThisWrite;  /* That many more done. */
  840.       
  841.     }
  842. }
  843.     else   /* Part cannot handle writes to buffer, must write one byte at a time. */
  844. {
  845. }
  846.  
  847.   /* Put both devices back into read mode: */
  848.        CFI_LONG_WRITE(flashPtr, (ULONG) (READ_ARRAY<<16) | READ_ARRAY); 
  849.       return status;
  850.      }
  852. /***************************************************************************
  853.  * cfiscsDWordWrite - Write routine for devices on 32 bit bus.
  854.  *
  855.  * This code has not been tested since we have not had 32 bit devices we have
  856.  * had to support. It is provided for consistancy in the hope that it will
  857.  * reduce the effort needed by the folks who have to support such devices. To
  858.  * avoid endianness issues commands are written to all four bytes of the
  859.  * double word. 
  860.  *
  861.  * NOMANUAL
  862.  *
  863.  */
  865. LOCAL FLStatus cfiscsDWordWrite
  866.     (
  867.     FLFlash vol,
  868.     CardAddress address,
  869.     const void FAR1 *buffer,
  870.     int length,
  871.     int mode
  872.     )
  873.     {
  874.     FLStatus status = flOK;
  875.     FlashPTR flashPtr;
  876.     unsigned int from, eachWrite;
  877.     const char FAR1 *temp = (const char FAR1 *)buffer;
  878.     /* Set timeout to 5 seconds from now */
  879.     unsigned long writeTimeout = flMsecCounter + 5000;
  881.     /* Check if address and length are double word aligned */
  882.     if ((address & 0x3) || (length & 0x3))
  883. {
  884. #ifdef DEBUG_PRINT
  885. DEBUG_PRINT("Debug: Unaligned data - addr 0x%x - len 0x%xn",(UINT32) address, length);
  886. #endif
  887. return flBadParameter;
  888. }
  890.     if (flWriteProtected(vol.socket))
  891. return flWriteProtect;
  893. #ifdef SOCKET_12_VOLTS
  894.     if (thisCFI->vpp)
  895. checkStatus(flNeedVpp(vol.socket));
  896. #endif
  898.     if (thisCFI->maxBytesWrite > 1) /* multi-byte write supported */
  899. eachWrite = thisCFI->maxBytesWrite * vol.interleaving;
  900.     else
  901. eachWrite = 4; /* Max bus width */
  903.     for (from = 0; (int)from < length && status == flOK; from += eachWrite) 
  904.         {
  905. int thisLength = length - from;
  907. if (thisLength > (int)eachWrite)
  908.     thisLength = eachWrite;
  910. flashPtr = (FlashPTR) flMap(vol.socket, address + from);
  912.      do 
  913.          {
  914.     if ((thisCFI->maxBytesWrite > 1) && 
  915.     ((thisCFI->maxBytesWrite & 0x3) == 0))
  916. *(UINT32 *)flashPtr = (UINT32) ((WRITE_TO_BUFFER << 24) |
  917.       (WRITE_TO_BUFFER << 16) |
  918.       (WRITE_TO_BUFFER << 8)  |
  919.        WRITE_TO_BUFFER);
  920.     else
  921. *(UINT32 *)flashPtr = (UINT32) ((PROGRAM_WORD << 24) |
  922.       (PROGRAM_WORD << 16) |
  923.       (PROGRAM_WORD << 8)  |
  924.        PROGRAM_WORD);
  926.          } while (!(*flashPtr & SR_READY) && (flMsecCounter < writeTimeout));
  927. if (!(*flashPtr & SR_READY)) 
  928.          {
  929. #ifdef DEBUG_PRINT
  930.     DEBUG_PRINT("Debug: timeout error in CFISCS write.n");
  931. #endif
  932.     status = flWriteFault;
  933.     }
  935. /* If we are using the WRITE_TO_BUFFER command then we must program
  936.  * the buffer length
  937.  */
  938. if ((thisCFI->maxBytesWrite > 1) && 
  939.     ((thisCFI->maxBytesWrite & 0x3) == 0))
  940.     *flashPtr = (thisLength << 24 | thisLength << 16 
  941.  | thisLength << 8 | thisLength);
  943. tffscpyLongs(flashPtr,temp + from,thisLength);
  945. *(UINT32 *)flashPtr = (UINT32) ((CONFIRM_WRITE << 24) |
  946.       (CONFIRM_WRITE << 16) |
  947.       (CONFIRM_WRITE << 8)  |
  948.        CONFIRM_WRITE);
  949. *(UINT32 *)flashPtr = (UINT32) ((CONFIRM_WRITE << 24) |
  950.       (CONFIRM_WRITE << 16) |
  951.       (CONFIRM_WRITE << 8)  |
  952.        CONFIRM_WRITE);
  954. while (!(*(FlashDPTR) flashPtr & (SR_READY << 24)) && 
  955.         (flMsecCounter < writeTimeout))
  956.     ;
  958. if (!(flMsecCounter < writeTimeout)) 
  959.     {
  960. #ifdef DEBUG_PRINT
  961.     DEBUG_PRINT("Debug: timeout error in CFISCS write.n");
  962. #endif
  963.     status = flWriteFault;
  964.     }
  965. if (*flashPtr & WSM_ERROR) 
  966.     {
  967. #ifdef DEBUG_PRINT
  968.     DEBUG_PRINT("Debug: error in CFISCS write.n");
  969. #endif
  970.     status = (*flashPtr & SR_VPP_ERROR) ? flVppFailure : flWriteFault;
  971.     *(UINT32 *)flashPtr = (UINT32) ((CLEAR_STATUS << 24) |
  972.   (CLEAR_STATUS << 16) |
  973.   (CLEAR_STATUS << 8)  |
  974.    CLEAR_STATUS);
  975.     }
  977. *(UINT32 *)flashPtr = (UINT32) ((READ_ARRAY << 24) |
  978.             (READ_ARRAY << 16) |
  979.       (READ_ARRAY << 8)  |
  980.        READ_ARRAY);
  981. }
  983. #ifdef SOCKET_12_VOLTS
  984.     if (thisCFI->vpp)
  985. flDontNeedVpp(vol.socket);
  986. #endif
  988.     flashPtr = (FlashPTR) flMap(vol.socket, address);
  989.     /* verify the data */
  991.     if (status == flOK && tffscmpWords((void FAR0 *) flashPtr, (void FAR1 *) buffer,length)) 
  992. {
  993. #ifdef DEBUG_PRINT
  994.     DEBUG_PRINT("Debug: CFISCS write failed in verification.n");
  995. #endif
  996. status = flWriteFault;
  997. }
  999.     return status;
  1000.     }
  1002. #ifdef INTERLEAVED_MODE_REQUIRES_32BIT_WRITES
  1003. /***************************************************************************
  1004.  * cfiscsInterleavedWordErase - Erase specified number of blocks
  1005.  *
  1006.  * Given the first block and number of contiguous blocks to erase, this 
  1007.  * routine will erase the content of the specified region. The routine does
  1008.  * not support featurees like "Suspend Erase" or "Queued Erase" so the device
  1009.  * stays busy until all specified blocks have been erased. These features need
  1010.  * to be supported by the TrueFFS core to be applicable here.
  1011.  *
  1012.  * NOMANUAL
  1013.  *
  1014.  */
  1015. LOCAL FLStatus cfiscsInterleavedWordErase
  1016.     (
  1017.     FLFlash vol,
  1018.     int firstEraseBlock,
  1019.     int numberOfEraseBlocks
  1020.     )
  1021.     {
  1022.     FLStatus status = flOK;       /* unless proven otherwise */
  1023.     int iBlock;
  1025.     if (flWriteProtected(vol.socket))
  1026.         return flWriteProtect;
  1028. #ifdef SOCKET_12_VOLTS
  1029.     if (thisCFI->vpp)
  1030.         checkStatus(flNeedVpp(vol.socket));
  1031. #endif
  1032.     
  1033.     for (iBlock = firstEraseBlock; 
  1034.  iBlock < firstEraseBlock + numberOfEraseBlocks && status == flOK;
  1035.  iBlock++) 
  1036.         {
  1037.         FLBoolean finished;
  1039. FlashWPTR flashPtr = (FlashWPTR) flMap(vol.socket,
  1040. iBlock * vol.erasableBlockSize);
  1042. CFI_LONG_WRITE(flashPtr, (ULONG) (SETUP_BLOCK_ERASE <<16)|SETUP_BLOCK_ERASE);
  1043. CFI_LONG_WRITE(flashPtr, (ULONG) (CONFIRM_ERASE <<16)|CONFIRM_ERASE);
  1045. /*   while (flashPtr[ix * thisCFI->interleaveFactor] != 0x80); */
  1047. do 
  1048.     {
  1049.     finished = FALSE;
  1051.     if ((flashPtr[0] == SR_READY) &&
  1052.     (flashPtr[1] == SR_READY))
  1053. {
  1054. finished = TRUE;
  1055. if (CFI_WORD_READ(flashPtr) & WSM_ERROR) 
  1056.     {
  1057. #ifdef DEBUG_PRINT
  1058.   DEBUG_PRINT("Debug: CFISCS erase error on device onen");
  1059. #endif
  1060.     status = (CFI_WORD_READ(flashPtr) & SR_VPP_ERROR) 
  1061.     ?  flVppFailure : flWriteFault;
  1062.     CFI_LONG_WRITE(flashPtr, (ULONG) CLEAR_STATUS);
  1063.     }
  1064. else if (CFI_WORD_READ(&flashPtr[1]) & WSM_ERROR) 
  1065.     {
  1066. #ifdef DEBUG_PRINT
  1067.   DEBUG_PRINT("Debug: CFISCS erase error on device twon");
  1068. #endif
  1069.     status = ((CFI_WORD_READ(&flashPtr[1])) & (SR_VPP_ERROR)) 
  1070.     ?  flVppFailure : flWriteFault;
  1071.     CFI_LONG_WRITE(flashPtr, (ULONG) (CLEAR_STATUS <<16) & 0xffff0000);
  1072.     }
  1073. CFI_LONG_WRITE(flashPtr, (ULONG) (READ_ARRAY <<16)|READ_ARRAY);
  1074. }
  1075.     } while (!finished);
  1076.         }
  1077. #ifdef SOCKET_12_VOLTS
  1078.     if (thisCFI->vpp)
  1079.         flDontNeedVpp(vol.socket);
  1080. #endif
  1082.     return status;
  1083.     }
  1084. #else /* !INTERLEAVED_MODE_REQUIRES_32BIT_WRITES */
  1086. /***************************************************************************
  1087.  * cfiscsErase - Erase specified number of blocks
  1088.  *
  1089.  * Given the first block and number of contiguous blocks to erase, this 
  1090.  * routine will erase the content of the specified region. The routine does
  1091.  * not support featurees like "Suspend Erase" or "Queued Erase" so the device
  1092.  * stays busy until all specified blocks have been erased. These features need
  1093.  * to be supported by the TrueFFS core to be applicable here.
  1094.  *
  1095.  * Each interleaved device is erased independently. The core does not
  1096.  * compensate for interleaving and expects interleaving to be handled here.
  1097.  *
  1098.  * NOMANUAL
  1099.  *
  1100.  */
  1101. LOCAL FLStatus cfiscsErase
  1102.     (
  1103.     FLFlash vol,
  1104.     int firstEraseBlock,
  1105.     int numberOfEraseBlocks
  1106.     )
  1107.     {
  1108.     FLStatus status = flOK;       /* unless proven otherwise */
  1109.     int iBlock;
  1111.     if (flWriteProtected(vol.socket))
  1112.         return flWriteProtect;
  1114. #ifdef SOCKET_12_VOLTS
  1115.     if (thisCFI->vpp)
  1116.         checkStatus(flNeedVpp(vol.socket));
  1117. #endif
  1118.     
  1119.     for (iBlock = firstEraseBlock; 
  1120.  iBlock < firstEraseBlock + numberOfEraseBlocks && status == flOK;
  1121.  iBlock++) 
  1122.         {
  1123. int ix;
  1124.         FLBoolean finished;
  1126. FlashPTR flashPtr = (FlashPTR) flMap(vol.socket,
  1127. iBlock * vol.erasableBlockSize);
  1128. for(ix=0; ix < vol.interleaving; ix++)
  1129.     {
  1130.     flashPtr[ix * thisCFI->interleaveFactor] = SETUP_BLOCK_ERASE;
  1131.     flashPtr[ix * thisCFI->interleaveFactor] = CONFIRM_ERASE;
  1132.     flashPtr[ix * thisCFI->interleaveFactor] = CONFIRM_ERASE;
  1134.     while (flashPtr[ix * thisCFI->interleaveFactor] != 0x80);
  1136.     do 
  1137. {
  1138. finished = TRUE;
  1140. if (!(flashPtr[ix * thisCFI->interleaveFactor] & SR_READY))
  1141. finished = FALSE;
  1142. else 
  1143.     {
  1144.     if (flashPtr[ix * thisCFI->interleaveFactor] & WSM_ERROR) 
  1145. {
  1146. #ifdef DEBUG_PRINT
  1147.   DEBUG_PRINT("Debug: CFISCS erase error on device %d.n", ix);
  1148. #endif
  1149. status = (flashPtr[ix * thisCFI->interleaveFactor] 
  1150.  & SR_VPP_ERROR) ?  flVppFailure : flWriteFault;
  1151. flashPtr[ix * thisCFI->interleaveFactor] = CLEAR_STATUS;
  1152. }
  1153.     flashPtr[ix * thisCFI->interleaveFactor] = READ_ARRAY;
  1154.     }
  1155. } while (!finished);
  1156.     }
  1157. }
  1158. #ifdef SOCKET_12_VOLTS
  1159.     if (thisCFI->vpp)
  1160.         flDontNeedVpp(vol.socket);
  1161. #endif
  1163.     return status;
  1164.     }
  1165. #endif /* INTERLEAVED_MODE_REQUIRES_32BIT_WRITES */
  1167. /***************************************************************************
  1168.  * cfiscsIdentify - Identification routine for devices conforming to CFI/SC
  1169.  *
  1170.  * Identifies media based on SCS/CFI and registers as an MTD for such.
  1171.  * This routine will be placed on the MTD list in custom.h. It must be an 
  1172.  * extern routine. On successful identification, the Flash structure is filled 
  1173.  * out and the write and erase routines registered. 
  1174.  *
  1175.  * Parameters:
  1176.  *      vol             : Pointer identifying drive 
  1177.  *
  1178.  * Returns:
  1179.  *      FLStatus        : 0 on positive identificaion, failed otherwise 
  1180.  *
  1181.  * URL:http://developer.intel.com/design/flcomp/applnots/29220404.pdf 
  1182.  *
  1183.  * NOMANUAL
  1184.  *
  1185.  */
  1186. FLStatus cfiscsIdentify
  1187.     (
  1188.     FLFlash vol
  1189.     )
  1190.     {
  1191.     FlashPTR flashPtr = (FlashPTR) flMap(vol.socket, 0);
  1192.     FlashWPTR flashWPtr = (FlashWPTR) flashPtr;
  1193.     FlashDPTR flashDPtr = (FlashDPTR) flashPtr;
  1195.     unsigned primaryTable, secondaryTable;
  1196.     char priIdStr[ID_STR_LENGTH + 1] = PRIMARY_ID_STR;
  1198. #ifdef DEBUG_PRINT
  1199.     DEBUG_PRINT("Debug: entering CFISCS identification routine.n");
  1200. #endif
  1202.     flSetWindowBusWidth(vol.socket, 16);/* use 16-bits */
  1203.     flSetWindowSpeed(vol.socket, 120);  /* 120 nsec. */
  1204.     flSetWindowSize(vol.socket, 2);       /* 8 KBytes */
  1206.     vol.mtdVars = &mtdVars[flSocketNoOf(vol.socket)];
  1208.     /* Is this an 8 bit device */
  1209.     flashPtr[0x55] = READ_ARRAY;
  1210.     flashPtr[0x55] = QUERY;
  1211.     
  1212.     if (flashPtr[0x10] == 0x51 && /* 'Q' */
  1213.         flashPtr[0x11] == 0x52 && /* 'R' */
  1214.         flashPtr[0x12] == 0x59)   /* 'Y' */
  1215.         {
  1216. #ifdef DEBUG_PRINT
  1217.         DEBUG_PRINT ("Debug: detected single 8 bit devicen");
  1218. #endif
  1219.         thisCFI->multiplier = 1;
  1220. thisCFI->interleaveFactor = 1;
  1221.         vol.interleaving = 1;
  1222. vol.type = (FlashType) ((flashPtr[0] << 8) | flashWPtr[1]);
  1223. vol.write = cfiscsByteWrite;
  1225.         goto getCFI;
  1226.         }
  1228.     /* Reset to READ_ARRAY and retry. Maybe 16 bit addressing 
  1229.      */
  1230.     flashPtr[0x55] = READ_ARRAY;
  1231.     flashWPtr[0x55] = (USHORT) ((QUERY << 8) | QUERY); 
  1233.     /* Check for two interleaved 8 bit parts */
  1234.     if (flashPtr[0x20] == 0x51 && /* 'Q' */
  1235.         flashPtr[0x21] == 0x51 && /* 'Q' */
  1236.         flashPtr[0x22] == 0x52 && /* 'R' */
  1237.         flashPtr[0x23] == 0x52 && /* 'R' */
  1238.         flashPtr[0x24] == 0x59 && /* 'Y' */
  1239.         flashPtr[0x25] == 0x59)   /* 'Y' */
  1240.      {
  1241. /* Let's try turning one off */
  1242. CFI_WORD_WRITE((FlashWPTR)(&flashPtr[0x55]), READ_ARRAY);
  1243. if (flashPtr[0x20] != 0x51) /* Turned off successfully */
  1244.     {
  1245.     thisCFI->multiplier = 2;
  1246.     thisCFI->interleaveFactor = 1;
  1247.     vol.interleaving =2;
  1248.     vol.type = (FlashType) ((flashWPtr[0] << 8) | flashWPtr[1]);
  1249.     vol.write = cfiscsByteWrite;
  1250. #ifdef DEBUG_PRINT
  1251.     DEBUG_PRINT ("Debug: detected two 8 bit devicesn");
  1252. #endif
  1253.     goto getCFI;
  1254.     }
  1255. }
  1257.     /* a 16 bit device in 16 bit mode */
  1258.     if (flashPtr[0x20] == 0x51 && /* 'Q' */
  1259.         flashPtr[0x21] == 0x00 && /* NUL */
  1260.         flashPtr[0x22] == 0x52 && /* 'R' */
  1261.         flashPtr[0x23] == 0x00 && /* NUL */
  1262.         flashPtr[0x24] == 0x59 && /* 'Y' */
  1263.         flashPtr[0x25] == 0x00)   /* NUL */
  1264.         {
  1265.         thisCFI->multiplier = 2;
  1266. thisCFI->interleaveFactor = 1;
  1267. vol.interleaving = 1;
  1268. vol.type = (FlashType) ((flashWPtr[0] << 8) | (flashWPtr[1]));
  1269. vol.write = cfiscsWordWrite;
  1270. #ifdef DEBUG_PRINT
  1271.         DEBUG_PRINT ("Debug: detected one 16 bit devicen");
  1272. #endif
  1273. goto getCFI;
  1274. }
  1276.     /* If we have a 16 bit device in 8 bit mode it should ID correctly */
  1277.     if (flashPtr[0x20] == 0x51 && /* 'Q' */
  1278.         flashPtr[0x21] == 0x51 && /* 'Q' */
  1279.         flashPtr[0x22] == 0x52 && /* 'R' */
  1280.         flashPtr[0x23] == 0x52 && /* 'R' */
  1281.         flashPtr[0x24] == 0x59 && /* 'Y' */
  1282.         flashPtr[0x25] == 0x59)   /* 'Y' */
  1283.         {
  1284. thisCFI->multiplier = 2;
  1285. #ifdef DEBUG_PRINT
  1286.         DEBUG_PRINT ("Debug: detected a 16 bit device in 8 bit moden");
  1287. #endif
  1288.      vol.interleaving =1;
  1289. thisCFI->interleaveFactor = 1;
  1290. vol.type = (FlashType) ((flashWPtr[0] << 8) | flashWPtr[1]);
  1291. vol.write = cfiscsByteWrite;
  1292. goto getCFI;
  1293.      }
  1295.     /* Reset to READ_ARRAY and retry. Maybe 32 bit addressing 
  1296.      */
  1297.     flashWPtr[0x55] = (USHORT) ((READ_ARRAY << 8) | READ_ARRAY); 
  1298.     flashDPtr[0x55] = (ULONG) (QUERY << 24| QUERY <<16 | QUERY << 8 | QUERY); 
  1300.     /* A 32 bit device in 8 bit mode and two 16 bit deivec in 8 bit mode will
  1301.      * appear the same to the querry process. The only way to make the
  1302.      * distinction is to try and set one device back to read array mode while
  1303.      * the other remains in query mode */
  1304.     if (flashPtr[0x40] == 0x51 && /* 'Q' */
  1305.         flashPtr[0x41] == 0x51 && /* 'Q' */
  1306.         flashPtr[0x42] == 0x51 && /* 'Q' */
  1307.         flashPtr[0x43] == 0x51 && /* 'Q' */
  1308.         flashPtr[0x44] == 0x52 && /* 'R' */
  1309.         flashPtr[0x45] == 0x52 && /* 'R' */
  1310.         flashPtr[0x46] == 0x52 && /* 'R' */
  1311.         flashPtr[0x47] == 0x52 && /* 'R' */
  1312.         flashPtr[0x48] == 0x59 && /* 'Y' */
  1313.         flashPtr[0x49] == 0x59 && /* 'Y' */
  1314.         flashPtr[0x4a] == 0x59 && /* 'Y' */
  1315.         flashPtr[0x4b] == 0x59)   /* 'Y' */
  1316.         {
  1317. /* See if we can turn one off */
  1318. flashPtr[0x154] = READ_ARRAY;
  1319. if ((flashPtr[0x40] != 0x51) && (flashPtr[0x41] == 0x51))
  1320.     { /* Turned one device off successfully */
  1321.     flashPtr[0x154] = QUERY;  /* turn it back on to querry mode */
  1322.     vol.interleaving = 2;
  1323.     vol.type = (FlashType) ((flashWPtr[0] << 8) | (flashWPtr[4]));
  1324. #ifdef DEBUG_PRINT
  1325.     DEBUG_PRINT ("Debug: detected two 16 bit device, 8 bit interleaved(2)n");
  1326. #endif
  1327.     }
  1328. else
  1329.     {
  1330.     vol.interleaving =1;
  1331. #ifdef DEBUG_PRINT
  1332.     DEBUG_PRINT ("Debug: detected a 32 bit device in 8 bit moden");
  1333. #endif
  1334.     vol.type = (FlashType) ((flashDPtr[0] << 8) | flashDPtr[1]);
  1335.     }
  1336.         thisCFI->multiplier = 4;
  1337. thisCFI->interleaveFactor = 1;
  1338. vol.write = cfiscsByteWrite;
  1340. goto getCFI;
  1341. }
  1343.     /* Is it a single 32 bit device */
  1344.     if (flashPtr[0x40] == 0x51 && /* 'Q' */
  1345.         flashPtr[0x41] == 0x00 && /* NUL */
  1346.         flashPtr[0x42] == 0x00 && /* NUL */
  1347.         flashPtr[0x43] == 0x00 && /* NUL */
  1348.         flashPtr[0x44] == 0x52 && /* 'R' */
  1349.         flashPtr[0x45] == 0x00 && /* NUL */
  1350.         flashPtr[0x46] == 0x00 && /* NUL */
  1351.         flashPtr[0x47] == 0x00 && /* NUL */
  1352.         flashPtr[0x48] == 0x59 && /* 'Y' */
  1353.         flashPtr[0x49] == 0x00 && /* NUL */
  1354.         flashPtr[0x4a] == 0x00 && /* NUL */
  1355.         flashPtr[0x4b] == 0x00)   /* NUL */
  1356.         {
  1357. #ifdef DEBUG_PRINT
  1358.         DEBUG_PRINT ("Debug: detected a 32 bit device in 32 bit moden");
  1359. #endif
  1360. thisCFI->multiplier = 4;
  1361. thisCFI->interleaveFactor = 1;
  1362. vol.interleaving = 1;
  1363. vol.type = (FlashType) ((flashDPtr[0] << 8) | flashDPtr[1]);
  1364. vol.write = cfiscsDWordWrite;
  1365. goto getCFI;
  1366. }
  1367.     /* Two 16 bit devices in 16 bit mode */
  1368.     if (flashPtr[0x40] == 0x51 && /* 'Q' */
  1369.         flashPtr[0x41] == 0x00 && /* NUL */
  1370.         flashPtr[0x42] == 0x51 && /* 'Q' */
  1371.         flashPtr[0x43] == 0x00 && /* NUL */
  1372.         flashPtr[0x44] == 0x52 && /* 'R' */
  1373.         flashPtr[0x45] == 0x00 && /* NUL */
  1374.         flashPtr[0x46] == 0x52 && /* 'R' */
  1375.         flashPtr[0x47] == 0x00 && /* NUL */
  1376.         flashPtr[0x48] == 0x59 && /* 'Y' */
  1377.         flashPtr[0x49] == 0x00 && /* NUL */
  1378.         flashPtr[0x4a] == 0x59 && /* 'Y' */
  1379.         flashPtr[0x4b] == 0x00)   /* NUL */
  1380.         {
  1381. #ifdef DEBUG_PRINT
  1382.         DEBUG_PRINT ("Debug: Detected two 16 bit devices in 16 bit mode(3)n");
  1383. #endif
  1384. thisCFI->multiplier = 4;
  1385. thisCFI->interleaveFactor = 2;
  1386. vol.interleaving = 2;
  1387. vol.type = (FlashType) (flashPtr[0] << 8 | 
  1388. flashPtr[thisCFI->multiplier]);
  1389. vol.write = cfiscsInterleavedWordWrite;
  1390. goto getCFI;
  1391. }
  1393.     /* If we get here the device is probably not CFI */
  1395. #ifdef DEBUG_PRINT
  1396.     DEBUG_PRINT ("Debug: Failed to identify CFI... n Exiting n");
  1397. #endif
  1399.     flashDPtr[0x55] = (ULONG) (READ_ARRAY << 24| READ_ARRAY <<16 
  1400.      | READ_ARRAY << 8 | READ_ARRAY); 
  1402.     return flUnknownMedia;
  1404. getCFI:
  1406.     /* check the command set ID */
  1407.     thisCFI->commandSetId = flashPtr[0x13 * thisCFI->multiplier] | 
  1408. ((unsigned)flashPtr[0x14 * thisCFI->multiplier] << 8);
  1409.     if (thisCFI->commandSetId != INTEL_COMMAND_SET &&
  1410.       thisCFI->commandSetId != AMDFUJ_COMMAND_SET) 
  1411.         {
  1412. #ifdef DEBUG_PRINT
  1413.     DEBUG_PRINT("Debug: did not recognize command set.n");
  1414. #endif
  1415.         return flUnknownMedia;
  1416.         }
  1417.     /* get address for primary algorithm extended table. */
  1418.     primaryTable = flashPtr[0x15 * thisCFI->multiplier] |
  1419.  ((unsigned)flashPtr[0x16 * thisCFI->multiplier] << 8);
  1421.     /* check alternate command set ID. */
  1422.     thisCFI->altCommandSetId = flashPtr[0x17 * thisCFI->multiplier] | 
  1423. ((unsigned)flashPtr[0x18 * thisCFI->multiplier] << 8);
  1424.     if (thisCFI->altCommandSetId != INTEL_ALT_COMMAND_SET &&
  1425.         thisCFI->altCommandSetId != AMDFUJ_ALT_COMMAND_SET &&
  1426.         thisCFI->altCommandSetId != ALT_NOT_SUPPORTED)
  1427.         return flUnknownMedia;
  1429.     /* get address for secondary algorithm extended table. */
  1430.     secondaryTable = flashPtr[0x19 * thisCFI->multiplier] |
  1431.    ((unsigned)flashPtr[0x1a * thisCFI->multiplier] << 8);
  1433.     thisCFI->vpp = flashPtr[0x1d * thisCFI->multiplier];
  1435.     vol.erasableBlockSize = (flashPtr[0x2f * thisCFI->multiplier] |
  1436.  ((unsigned)flashPtr[0x30 * thisCFI->multiplier]) << 8) *
  1437.   0x100L;
  1439.     /* we reserve one erase block for NVRAM usage */
  1440. #ifdef SAVE_NVRAM_REGION
  1441.     vol.chipSize = (1L << flashPtr[0x27 * thisCFI->multiplier]) - 
  1442. vol.erasableBlockSize;
  1443. #else
  1444.     vol.chipSize = (1L << flashPtr[0x27 * thisCFI->multiplier]);
  1445. #endif
  1446.     vol.erasableBlockSize *= vol.interleaving;
  1448. #ifdef BUFFERED_WRITE_BROKEN
  1449.     thisCFI->maxBytesWrite = 1;
  1450. #else
  1451.     thisCFI->maxBytesWrite = 1L << (flashPtr[0x2a * thisCFI->multiplier] |
  1452.    ((unsigned)flashPtr[0x2b * thisCFI->multiplier] << 8));
  1453. #endif /* BUFFERED_WRITE_BROKEN */
  1455.     /* In this part we access the primary extended table implemented by Intel.
  1456.      * If the device uses a different extended table, it should be accessed
  1457.      * according to the vendor specifications. 
  1458.      */
  1459.     if ((primaryTable) && (thisCFI->commandSetId == INTEL_COMMAND_SET)) 
  1460.         {
  1461.         /* look for the primary table identification string "PRI" */
  1462.         if (priIdStr[0] != flashPtr[primaryTable * thisCFI->multiplier] ||
  1463.     priIdStr[1] != flashPtr[(primaryTable + 1) * thisCFI->multiplier] ||
  1464.     priIdStr[2] != flashPtr[(primaryTable + 2) * thisCFI->multiplier])
  1465.     {
  1466. #ifdef DEBUG_PRINT
  1467.     DEBUG_PRINT ("Debug: No primary ID @ offset 0x%xn", primaryTable);
  1468. #endif
  1469.             return flUnknownMedia;
  1470.     }
  1472.     thisCFI->optionalCommands = flashPtr[(primaryTable + 5) * thisCFI->multiplier] |
  1473. ((long)flashPtr[(primaryTable + 6) *
  1474.   thisCFI->multiplier] << 8) |
  1475. ((long)flashPtr[(primaryTable + 7) *
  1476.   thisCFI->multiplier] << 16) |
  1477. ((long)flashPtr[(primaryTable + 8) *
  1478.   thisCFI->multiplier] << 24);
  1480.     thisCFI->afterSuspend = flashPtr[(primaryTable + 9) * thisCFI->multiplier];
  1481. }
  1482.     else 
  1483.         {
  1484. thisCFI->optionalCommands = 0;
  1485. thisCFI->afterSuspend = 0;
  1486. }
  1487.     /* Make sure this comes at the end since the device is set to READ_ARRAY
  1488.      * mode prior to the return
  1489.      */
  1490.     if (cfiscsGetChipCount(&vol) != flOK)
  1491. return flUnknownMedia;
  1492. #ifdef DEBUG_PRINT
  1493.     DEBUG_PRINT ("Debug: No of chips detected is %dn", vol.noOfChips);
  1494. #endif
  1496. #ifdef INTERLEAVED_MODE_REQUIRES_32BIT_WRITES
  1497.     vol.erase = cfiscsInterleavedWordErase;
  1498. #else  /* !INTERLEAVED_MODE_REQUIRES_32BIT_WRITES */
  1499.     vol.erase = cfiscsErase;
  1500. #endif /* INTERLEAVED_MODE_REQUIRES_32BIT_WRITES */
  1502.     /* Might have to do this on a bus width basis but for now it seems to
  1503.      * work with Intel devices.
  1504.      */
  1505.     flashPtr[0] = READ_ARRAY;
  1506.     flashPtr[1] = READ_ARRAY;
  1507.     flashPtr[2] = READ_ARRAY;
  1508.     flashPtr[3] = READ_ARRAY;
  1510.     return flOK;
  1511.     }