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

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

VxWorks

开发平台：

C/C++

wamdmtd.c：源码内容
  2. /************************************************************************/
  3. /*                                                                      */
  4. /* FAT-FTL Lite Software Development Kit */
  5. /* Copyright (C) M-Systems Ltd. 1995-1996 */
  6. /* */
  7. /************************************************************************/
  8. /*                                                                      */
  9. /*                    16-bit AMD MTD                                    */
  10. /*                                                                      */
  11. /* This MTD is for flash media which is accessible in 16-bit mode only. */
  12. /* The following Flash technologies are supported:                      */
  13. /*                                                                      */
  14. /* - AMD     Am29F080   8-mbit devices                                  */
  15. /* - AMD     Am29LV080  8-mbit devices                                  */
  16. /* - AMD     Am29F016  16-mbit devices                                  */
  17. /* - Fujitsu MBM29F080  8-mbit devices                                  */
  18. /* */
  19. /************************************************************************/
  21. /*
  22.  * $Log:   V:/wamdmtd.c_v  $
  23.  * 
  24.  *    Rev 1.1   07 Oct 1997 14:58:32   ANDRY
  25.  * get rid of generic names, registration routine returns status
  26.  *
  27.  *    Rev 1.0   25 Aug 1997 12:00:00   ANDRY
  28.  * Initial revision.
  29.  */
  32. #include "flflash.h"
  33. #include "backgrnd.h"
  36. /* JEDEC ids for this MTD */
  37. #define Am29F040_FLASH       0x01a4
  38. #define Am29F080_FLASH       0x01d5
  39. #define Am29LV080_FLASH      0x0138
  40. #define Am29LV008_FLASH      0x0137
  41. #define Am29F016_FLASH       0x01ad
  42. #define Am29F016C_FLASH      0x013d
  43. #define Am29LV017_FLASH      0x01c8
  45. #define Fuj29F040_FLASH      0x04a4
  46. #define Fuj29F080_FLASH      0x04d5
  47. #define Fuj29LV080_FLASH     0x0438
  48. #define Fuj29LV008_FLASH     0x0437
  49. #define Fuj29F016_FLASH      0x04ad
  50. #define Fuj29F016C_FLASH     0x043d
  51. #define Fuj29LV017_FLASH     0x04c8
  53. /* commands for AMD flash */
  54. #define SETUP_ERASE          0x8080
  55. #define SETUP_WRITE          0xa0a0
  56. #define READ_ID              0x9090
  57. #define SUSPEND_ERASE        0xb0b0
  58. #define SECTOR_ERASE         0x3030
  59. #define RESUME_ERASE         0x3030
  60. #define READ_ARRAY           0xf0f0
  61. #define INTEL_READ_ARRAY     0xffff
  63. /* AMD unlocking sequence */
  64. #define UNLOCK_1             0xaaaa
  65. #define UNLOCK_2             0x5555
  66. #define UNLOCK_ADDR1         0x5555
  67. #define UNLOCK_ADDR2         0x2aaa
  69. /* AMD flash status bits */
  70. #define D2                   0x04    /* Toggles when erase suspended */
  71. #define D5                   0x20    /* Set when programming timeout */
  72. #define D6                   0x40    /* Toggles when programming     */
  74. #ifdef __cplusplus
  75.   #define wFlashPtr    ((FlashWPTR &) flashPtr)
  76.   #define wBuffer      ((const unsigned short FAR1 * &) buffer)
  77.   #define wUnlockAddr1 ((FlashWPTR &) unlockAddr1)
  78.   #define wUnlockAddr2 ((FlashWPTR &) unlockAddr2)
  79. #else
  80.   #define wFlashPtr    ((FlashWPTR) flashPtr)
  81.   #define wBuffer      ((const unsigned short FAR1 *) buffer)
  82.   #define wUnlockAddr1 ((FlashWPTR) unlockAddr1)
  83.   #define wUnlockAddr2 ((FlashWPTR) unlockAddr2)
  84. #endif
  88. /* -------------------------------------------------------------------- */
  89. /* AMD Flash specific data. Pointed by FLFlash.mtdVars                  */
  90. /* -------------------------------------------------------------------- */
  92. typedef struct
  93.         {
  94.           FlashWPTR  unlockAddr1;
  95.           FlashWPTR  unlockAddr2;
  96.         } Vars;
  98. static Vars  mtdVars[DRIVES];
  100. #define thisVars   ((Vars *) vol.mtdVars)
  104. /* -------------------------------------------------------------------- */
  105. /*               f l U p d a t e U n l o c k A d d r s                  */
  106. /* */
  107. /* Updates unlock addresses for AMD flash media.                        */
  108. /* */
  109. /* */
  110. /* Parameters:                                                          */
  111. /* vol : Pointer identifying drive */
  112. /*      basePtr         : flash pointer, could point anywhere in the    */
  113. /*                        memory window                                 */
  114. /* */
  115. /* -------------------------------------------------------------------- */
  117. static void flUpdateUnlockAddrs (FLFlash    vol,
  118.                                  FlashWPTR  basePtr)
  119. {
  120.   if ((vol.type == Am29F016C_FLASH) || (vol.type == Fuj29F016C_FLASH))
  121.     thisVars->unlockAddr1 = thisVars->unlockAddr2 = basePtr;
  122.   else
  123.   {
  124.     thisVars->unlockAddr1 = (FlashWPTR)(((long)basePtr & -0x10000l)) + 0x555;
  125.     thisVars->unlockAddr2 = (FlashWPTR)(((long)basePtr & -0x10000l)) + 0x2aa;
  126.   }
  127. }
  130. /*----------------------------------------------------------------------*/
  131. /*                   f l w A m d C o m m a n d                          */
  132. /* */
  133. /* Writes an AMD command with the required unlock sequence */
  134. /* */
  135. /* Parameters:                                                          */
  136. /* vol : Pointer identifying drive */
  137. /*      address : Card address at which to write command */
  138. /* command : command to write */
  139. /*                                                                      */
  140. /*----------------------------------------------------------------------*/
  142. static void flwAmdCommand (FLFlash         vol,
  143.                            CardAddress     address,
  144.                            unsigned short  command)
  145. {
  146.   if (thisVars->unlockAddr1)
  147.   {
  148.     thisVars->unlockAddr1[0] = UNLOCK_1;
  149.     thisVars->unlockAddr2[0] = UNLOCK_2;
  150.     thisVars->unlockAddr1[0] = command;
  151.   }
  152.   else
  153.   {
  154.     CardAddress  baseAddress  = address & (-0x10000l);
  156.     /* write AMD unlock sequence */
  157.     *(FlashWPTR) vol.map (&vol,
  158.                           baseAddress + 2 * UNLOCK_ADDR1,
  159.                           vol.interleaving) = UNLOCK_1;
  160.     *(FlashWPTR) vol.map (&vol,
  161.                           baseAddress + 2 * UNLOCK_ADDR2,
  162.                           vol.interleaving) = UNLOCK_2;
  164.     /* write flash command */
  165.     *(FlashWPTR) vol.map (&vol,
  166.                           baseAddress + 2 * UNLOCK_ADDR1,
  167.                           vol.interleaving) = command;
  169.     vol.map (&vol, address, vol.interleaving);
  170.   }
  171. }
  174. /*----------------------------------------------------------------------*/
  175. /*                f l w A m d M T D W r i t e                           */
  176. /* */
  177. /* Write a block of bytes to Flash */
  178. /* */
  179. /* This routine will be registered as FLFlash.write routine             */
  180. /* */
  181. /* Parameters:                                                          */
  182. /* vol : Pointer identifying drive */
  183. /*      address : Card address to write to */
  184. /*      buffer : Address of data to write */
  185. /* length : Number of bytes to write */
  186. /* overwrite : TRUE if overwriting old Flash contents */
  187. /*   FALSE if old contents are known to be erased */
  188. /*                                                                      */
  189. /* Returns:                                                             */
  190. /*      FLStatus        : 0 on success, failed otherwise                */
  191. /*----------------------------------------------------------------------*/
  193. static FLStatus flwAmdMTDWrite (FLFlash           vol,
  194.                                 CardAddress       address,
  195.                                 const void FAR1  *buffer,
  196.                                 int               length,
  197.                                 FLBoolean         overwrite)
  198. {
  199.   unsigned long writeTimeout;
  200.   int           cLength;
  201.   FlashWPTR     flashPtr,
  202.                 unlockAddr1 = thisVars->unlockAddr1,
  203.                 unlockAddr2 = thisVars->unlockAddr2;
  205.   if ( flWriteProtected(vol.socket) )
  206.     return flWriteProtect;
  208.   flashPtr = (FlashWPTR) vol.map (&vol, address, length);
  210.   /* set addresses for AMD unlock sequence */
  211.   flUpdateUnlockAddrs (&vol, flashPtr);
  212.   unlockAddr1 = thisVars->unlockAddr1;
  213.   unlockAddr2 = thisVars->unlockAddr2;
  215.   /* Set timeout to 5 seconds from now */
  216.   writeTimeout = flMsecCounter + 5000;
  218.   /* write the data */
  219.   cLength = length;
  220.   while (cLength >= 2)
  221.   {
  222.     /* AMD unlock sequence */
  223.     *wUnlockAddr1 = UNLOCK_1;
  224.     *wUnlockAddr2 = UNLOCK_2;
  226.     /* flash command */
  227.     *wUnlockAddr1 = SETUP_WRITE;
  229.     /* write user data word */
  230.     *wFlashPtr    = *wBuffer;
  232.     /* wait for ready */
  233.     while ((*wFlashPtr != *wBuffer)    && (flMsecCounter < writeTimeout))
  234.     {
  235.       if( ((*wFlashPtr &          D5)  && ((*wFlashPtr ^ *wBuffer) &   0xff))
  236.                  ||
  237.           ((*wFlashPtr & (0x100 * D5)) && ((*wFlashPtr ^ *wBuffer) & 0xff00)) )
  238.       {
  239.         *wFlashPtr = READ_ARRAY;
  240.         return flWriteFault;
  241.       }
  242.     }
  244.     cLength -= 2;
  245.     /* replaced wBuffer++; wFlashPtr++; */
  246.     buffer = (unsigned char *)buffer + sizeof(unsigned short);
  247.     flashPtr = (FlashWPTR)flashPtr + 1;
  248.   }
  250.   /* verify the written data */
  251.   /* replaced: wFlashPtr -= length/2; wBuffer -= length/2; */
  252.   flashPtr -= length / 2;
  253.   buffer = (unsigned short *)buffer - (length/2);
  255.   if (tffscmp((void FAR0 *)flashPtr, buffer, length))
  256.     return flWriteFault;
  258.   return flOK;
  259. }
  262. /*----------------------------------------------------------------------*/
  263. /*               f l w A m d M T D E r a s e                            */
  264. /* */
  265. /* Erase one or more contiguous Flash erasable blocks */
  266. /* */
  267. /* This routine will be registered as FLFlash.erase routine             */
  268. /* */
  269. /* Parameters:                                                          */
  270. /*      vol                : Pointer identifying drive                  */
  271. /*      firstBlock         : Number of first block to erase             */
  272. /*      numOfBlocks        : Number of blocks to erase                  */
  273. /*                                                                      */
  274. /* Returns:                                                             */
  275. /*      FLStatus           : 0 on success, failed otherwise             */
  276. /*----------------------------------------------------------------------*/
  278. static FLStatus flwAmdMTDErase (FLFlash  vol,
  279.                                 int      firstBlock,
  280.                                 int      numOfBlocks)
  281. {
  282.   FlashWPTR  flashPtr;
  283.   FLBoolean  finished;
  284.   int        iBlock;
  286.   if ( flWriteProtected(vol.socket) )
  287.     return flWriteProtect;
  289.   for (iBlock = 0;  iBlock < numOfBlocks;  iBlock++)
  290.   {
  291.     flashPtr = (FlashWPTR) vol.map( &vol,
  292.                                    (firstBlock + iBlock) * vol.erasableBlockSize,
  293.                                     vol.interleaving);
  295.     flUpdateUnlockAddrs (&vol, flashPtr);
  297.     flwAmdCommand (&vol, 0, SETUP_ERASE);
  298.     flwAmdCommand (&vol, 0, SECTOR_ERASE);
  300.     do {
  301. #ifdef BACKGROUND
  302.       while (flForeground(1) == BG_SUSPEND) { /* suspend */
  303.         for (i = 0; i < interleave; i++) {
  304.   flashPtr[i] = SUSPEND_ERASE;
  305.   /* Wait for D6 to stop toggling */
  306.   while ((flashPtr[i] ^ flashPtr[i]) & D6)
  307.     ;
  308. }
  309.       } /* while (foreground..) */
  310. #endif
  312.       finished = TRUE;
  313.       if (*wFlashPtr != 0xffff)
  314.       {
  315.         if( ((*wFlashPtr &   0xff &          D5)  && ((*wFlashPtr &   0xff) !=   0xff))
  316.                 ||
  317.             ((*wFlashPtr & 0xff00 & (0x100 * D5)) && ((*wFlashPtr & 0xff00) != 0xff00)) )
  318.         {
  319.           *wFlashPtr = READ_ARRAY;
  320.           return flWriteFault;
  321.         }
  323.         finished = FALSE;
  324.       }
  325.     } while (!finished);
  326.   }
  328.   return flOK;
  329. }
  332. /*----------------------------------------------------------------------*/
  333. /*                     f l w A m d I d e n t i f y                      */
  334. /* */
  335. /* Identify the AMD Flash media.                                        */
  336. /* Sets the value of flash.type (JEDEC id) & FLFlash.interleaving. */
  337. /* */
  338. /* Parameters:                                                          */
  339. /*      vol             : Pointer identifying drive                     */
  340. /* amdCmdRoutine : Routine to read-id AMD/Fujitsu style at */
  341. /*   a specific location. If null, Intel procedure */
  342. /*   is used.                                      */
  343. /*      idOffset : Chip offset to use for identification */
  344. /*                                                                      */
  345. /*----------------------------------------------------------------------*/
  347. void flwAmdIdentify (FLFlash      vol,
  348.                             void (*amdCmdRoutine)(FLFlash vol, CardAddress, unsigned short),
  349.                             CardAddress  idOffset)
  350. {
  351.   unsigned short  resetCmd  = amdCmdRoutine ? READ_ARRAY : INTEL_READ_ARRAY;
  352.   FlashWPTR       flashPtr  = (FlashWPTR) flMap (vol.socket, idOffset);
  354.   vol.noOfChips = 0;
  356.   flashPtr[0] = resetCmd;          /* Reset chips             */
  357.   flashPtr[0] = resetCmd;          /* Once again for luck     */
  359.   if (amdCmdRoutine)               /* use AMD unlock sequence */
  360.   {
  361.     flUpdateUnlockAddrs (&vol, flashPtr);
  362.     amdCmdRoutine (&vol, idOffset, READ_ID);
  363.   }
  364.   else
  365.     flashPtr[0] = READ_ID;         /* use Intel-style         */
  367.   vol.type = (FlashType) ((flashPtr[0] & 0xff00) | (flashPtr[1] & 0xff));
  369.   flashPtr[0] = resetCmd;
  370. }
  373. /*----------------------------------------------------------------------*/
  374. /*                       f l w A m d S i z e                            */
  375. /* */
  376. /* Identify the card size for AMD Flash.                                */
  377. /* Sets the value of flash.noOfChips. */
  378. /* */
  379. /* Parameters:                                                          */
  380. /* vol : Pointer identifying drive */
  381. /* amdCmdRoutine : Routine to read-id AMD/Fujitsu style at */
  382. /*   a specific location. If null, Intel procedure */
  383. /*   is used.                                      */
  384. /*      idOffset : Chip offset to use for identification */
  385. /*                                                                      */
  386. /* Returns:                                                             */
  387. /*      FLStatus        : 0 = OK, otherwise failed (invalid Flash array)*/
  388. /*----------------------------------------------------------------------*/
  390. FLStatus flwAmdSize (FLFlash      vol,
  391.                    void (*amdCmdRoutine)(FLFlash vol, CardAddress, unsigned short),
  392.                    CardAddress  idOffset)
  393. {
  394.   unsigned short  resetCmd = amdCmdRoutine ? READ_ARRAY : INTEL_READ_ARRAY;
  395.   FlashWPTR       flashPtr = (FlashWPTR) vol.map (&vol, idOffset, 0);
  397.   if (amdCmdRoutine)             /* use AMD unlock sequence      */
  398.   {
  399.     flUpdateUnlockAddrs(&vol, flashPtr);
  400.     amdCmdRoutine (&vol, idOffset, READ_ID);
  401.   }
  402.   else
  403.     flashPtr[0] = READ_ID;       /* use Intel-style              */
  405.   /* We left the first chip in Read ID mode, so that we can      */
  406.   /* discover an address wraparound.                             */
  407.   for (vol.noOfChips = 1;  vol.noOfChips < 2000;  vol.noOfChips++)
  408.   {
  409.     flashPtr = (FlashWPTR)
  410.                 vol.map (&vol, vol.noOfChips * vol.chipSize + idOffset, 0);
  412.     /* Read ID from the chips without issuing a READ_ID command. */
  413.     /* Check for address wraparound to the first chip.           */
  414.     if ((FlashType)((flashPtr[0] & 0xff00) | (flashPtr[1] & 0xff)) == vol.type)
  415.       break;                     /* wraparound to the first chip */
  417.     /* Check if chip displays the same JEDEC id and interleaving */
  418.     if (amdCmdRoutine)           /* AMD: use unlock sequence     */
  419.     {
  420.       flUpdateUnlockAddrs (&vol, flashPtr);
  421.       amdCmdRoutine (&vol,
  422.                      vol.noOfChips * vol.chipSize + idOffset,
  423.                      READ_ID);
  424.     }
  425.     else
  426.       flashPtr[0] = READ_ID;     /* use Intel-style              */
  428.     if ((FlashType) ((flashPtr[0] & 0xff00) | (flashPtr[1] & 0xff)) != vol.type)
  429.     {
  430.       /* This "chip" doesn't respond correctly, so we're done */
  431.       break;
  432.     }
  434.     flashPtr[0] = resetCmd;
  435.   }
  437.   flashPtr = (FlashWPTR) vol.map (&vol, idOffset, 0);
  438.   flashPtr[0] = resetCmd;        /* reset the original chip      */
  440.   return (vol.noOfChips == 0) ? flUnknownMedia : flOK;
  441. }
  445. /*----------------------------------------------------------------------*/
  446. /*              f l w A m d M T D I d e n t i f y                       */
  447. /* */
  448. /* Identifies AMD flash media accessible in 16-bit mode only.           */
  449. /* */
  450. /* This routine will be placed on the MTD list in CUSTOM.C. It must be  */
  451. /* an extern routine. */
  452. /* */
  453. /* On successful identification, the Flash structure is filled out and */
  454. /* the write and erase routines registered. */
  455. /* */
  456. /* Parameters:                                                          */
  457. /* vol : Pointer identifying drive */
  458. /*                                                                      */
  459. /* Returns:                                                             */
  460. /*      FLStatus        : 0 = OK, otherwise failed (invalid Flash array)*/
  461. /*----------------------------------------------------------------------*/
  463. FLStatus flwAmdMTDIdentify (FLFlash vol)
  464. {
  465.   FlashWPTR  baseFlashPtr;
  467.   flSetWindowBusWidth (vol.socket,16);      /* use 16-bits */
  468.   flSetWindowSpeed (vol.socket,120);        /* 120 nsec.   */
  470.   /* place to store all the AMD-specific flash parametes */
  471.   vol.mtdVars = &mtdVars[flSocketNoOf(vol.socket)];
  473.   thisVars->unlockAddr1 = NULL;
  475.   vol.interleaving = 2;
  477.   flwAmdIdentify (&vol, flwAmdCommand, 0);
  478.   if (vol.type == Am29F016_FLASH   || vol.type == Fuj29F016_FLASH  ||
  479.       vol.type == Am29F016C_FLASH  || vol.type == Fuj29F016C_FLASH ||
  480.       vol.type == Am29LV017_FLASH  || vol.type == Fuj29LV017_FLASH)
  481.     vol.chipSize = 0x200000l * vol.interleaving;
  482.   else
  483.   if (vol.type == Fuj29F080_FLASH  || vol.type == Am29F080_FLASH   ||
  484.       vol.type == Fuj29LV080_FLASH || vol.type == Am29LV080_FLASH  ||
  485.       vol.type == Fuj29LV008_FLASH || vol.type == Am29LV008_FLASH)
  486.     vol.chipSize = 0x100000l * vol.interleaving;
  487.   else
  488.   if (vol.type == Fuj29F040_FLASH  ||  vol.type == Am29F040_FLASH)
  489.     vol.chipSize = 0x80000l * vol.interleaving;
  490.   else
  491.     return flUnknownMedia;
  493.   /* find where the window is */
  494.   baseFlashPtr = (FlashWPTR)
  495.                   vol.map (&vol, (CardAddress)0, vol.interleaving);
  497.   flUpdateUnlockAddrs (&vol, baseFlashPtr);
  499.   checkStatus( flwAmdSize(&vol, flwAmdCommand, 0) );
  501.   vol.erasableBlockSize = 0x10000l * vol.interleaving;
  502.   vol.flags            |= SUSPEND_FOR_WRITE;
  504.   /* Register our flash handlers */
  505.   vol.write = flwAmdMTDWrite;
  506.   vol.erase = flwAmdMTDErase;
  508.   return flOK;
  509. }
  512. #if FALSE
  513. /*----------------------------------------------------------------------*/
  514. /*                 f l R e g i s t e r W A M D M T D                    */
  515. /* */
  516. /* Registers this MTD for use */
  517. /* */
  518. /* Parameters:                                                          */
  519. /* None */
  520. /*                                                                      */
  521. /*----------------------------------------------------------------------*/
  523. FLStatus  flRegisterWAMDMTD (void)
  524. {
  525.   if (noOfMTDs >= MTDS)
  526.     return flTooManyComponents;
  528.   mtdTable[noOfMTDs++] = flwAmdMTDIdentify;
  530.   return flOK;
  531. }
  532. #endif /* FALSE */