设为首页收藏本站
开启辅助访问 切换到窄版

DIY编程器网

 找回密码
 注册

QQ登录

只需一步，快速开始

扫一扫，访问微社区

DIY编程器网»首页 › -->DIY编程器 › UUprog编程器 › 芯片操作时序 › 39VF400A读写代码
返回列表 发新帖
查看: 3454|回复: 7
打印 上一主题 下一主题

39VF400A读写代码

[复制链接]
liyf
跳转到指定楼层
楼主
发表于 2012-10-29 07:55:20 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
Software
Drivers

39VF400A
4 Mbit Multi-Purpose Flash

September 2001


ABOUT THE SOFTWARE

This application note provides software driver examples for 39VF400A 4 Mbit
Multi-Purpose Flash, that can be used in any microprocessor based system.
Please note that the software driver for 39VF400A is the same as the driver
for 39VF400 except the part number has been changed. Software driver examples
used in this document utilize two programming languages: (a) high -level "C"
for broad platform support and (b) optimized x86 assembly language. In many
cases, software driver routines can be inserted "as is" into the main body of
code being developed by the system software developers. Extensive comments
are included in each routine to describe the function of each routine. The
driver in "C" language can be used with many microprocessors and
microcontrollers, while the x86 assembly language provides an optimized solution
for x86 microprocessors. A Code Segment base address equal to C000h was used in
this sample code.  Software designers shall assign the segment address
appropriate to their designs.

ABOUT THE 39VF400A

Companion product datasheet for the 39VF400A should be reviewed in conjunction
with this application note for a complete understanding of the device.

Both the C and x86 assembly code in the document contain the following routines,
in this order:

Name                    Function
------------------------------------------------------------------
Check_SST_39VF400A      Check manufacturer and device ID
CFI_Query               CFI Query Entry/Exit command sequence
Erase_One_Sector        Erase a sector of 2048 words
Erase_One_Block         Erase a block of 32K words
Erase_Entire_Chip       Erase the contents of the entire chip
Program_One_Word        Alter data in one word
Program_One_Sector      Alter data in 2048 word sector
Program_One_Block       Alter data in 32K word block
Check_Toggle_Ready      End of internal program or erase detection using
                        Toggle bit
Check_Data_Polling      End of internal program or erase detection using
                        Data# polling


"C" LANGUAGE DRIVERS

  1. /***********************************************************************/
  2. /* Copyright Silicon Storage Technology, Inc. (SST), 1994-2001         */
  3. /* Example "C" language Driver of 39VF400A 4 Mbit Multi-Purpose Flash  */
  4. /* Nelson Wang, Silicon Storage Technology, Inc.                       */
  5. /*                                                                     */
  6. /* Revision 1.0, Sept. 12, 2001                                     */
  7. /*                                                                     */
  8. /* This file requires these external "timing"  routines:               */
  9. /*                                                                     */
  10. /*      1.)  Delay_150_Nano_Seconds                                    */
  11. /*      2.)  Delay_25_Milli_Seconds                                    */
  12. /*      3.)  Delay_100_Milli_Seconds                                   */
  13. /***********************************************************************/

  15. #define FALSE                   0
  16. #define TRUE                    1

  18. #define SECTOR_SIZE             2048    /* Must be 2048 words for 39VF400A */
  19. #define BLOCK_SIZE              32768   /* Must be 32K words for 39VF400A  */

  21. #define SST_ID                  0x00BF  /* SST Manufacturer's ID code   */
  22. #define SST_39VF400A            0x2780  /* SST39VF400A device code      */
  23.                                         /* same device code as SST39VF400 */

  25. typedef unsigned char           BYTE;
  26. typedef unsigned int            WORD;

  28. /* -------------------------------------------------------------------- */
  29. /*                       EXTERNAL ROUTINES                              */
  30. /* -------------------------------------------------------------------- */

  32. extern void     Delay_150_Nano_Seconds();
  33. extern void     Delay_25_Milli_Seconds();
  34. extern void     Delay_100_Milli_Seconds();


  37. /************************************************************************/
  38. /* PROCEDURE:   Check_SST_39VF400A                                      */
  39. /*                                                                      */
  40. /* This procedure decides whether a physical hardware device has a      */
  41. /* SST39VF400A 4 Mbit Multi-Purpose Flash installed or not.             */
  42. /*                                                                      */
  43. /* Input:                                                               */
  44. /*          None                                                        */
  45. /*                                                                      */
  46. /* Output:                                                              */
  47. /*          return TRUE:  indicates a SST39VF400A                       */
  48. /*          return FALSE: indicates not a SST39VF400A                   */
  49. /************************************************************************/

  51. int Check_SST_39VF400A()              /* same device code as SST39VF400 */
  52. {
  53.         WORD far *Temp;
  54.         WORD SST_id1;
  55.         WORD far *Temp1;
  56.         WORD SST_id2;
  57.         int  ReturnStatus;

  59.         /*  Issue the Software Product ID code to 39VF400A   */

  61.         Temp1 = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  62.         *Temp1= 0xAAAA;                 /* write data 0xAAAA to the address */
  63.         Temp1 = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  64.         *Temp1= 0x5555;                 /* write data 0x5555 to the address */
  65.         Temp1 = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  66.         *Temp1= 0x9090;                 /* write data 0x9090 to the address */

  68.         Delay_150_Nano_Seconds();       /* insert delay time = Tida         */

  70.         /* Read the product ID from 39VF400A */

  72.         Temp  = (WORD far *)0xC0000000; /* set up address to be C000:0000h */
  73.         SST_id1  =  *Temp;              /* get first ID word               */
  74.         SST_id1  =  SST_id1 & 0xFF;     /* mask of higher byte             */
  75.         Temp1 = (WORD far *)0xC0000001; /* set up address to be C000:0001h */
  76.         SST_id2  =  *Temp1;             /* get second ID word              */

  78.         /* Determine whether there is a SST39VF400A installed or not */

  80.         if ((SST_id1 == SST_ID) && (SST_id2 ==SST_39VF400A))
  81.                 ReturnStatus = TRUE;
  82.         else
  83.                 ReturnStatus = FALSE;

  85.         /* Issue the Soffware Product ID Exit code thus returning the 39VF400A*/
  86.         /* to the read operating mode                                         */

  88.         Temp1  = (WORD far *)0xC0005555; /* set up address to be C000:5555h   */
  89.         *Temp1 = 0xAAAA;                 /* write data 0xAAAA to the address  */
  90.         Temp1  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh   */
  91.         *Temp1 = 0x5555;                 /* write data 0x5555 to the address  */
  92.         Temp1  = (WORD far *)0xC0005555; /* set up address to be C000:5555h   */
  93.         *Temp1 = 0xF0F0;                 /* write data 0xF0F0 to the address  */

  95.         Delay_150_Nano_Seconds();        /* insert delay time = Tida          */

  97.         return(ReturnStatus);
  98. }


  101. /************************************************************************/
  102. /* PROCEDURE:   CFI_Query                                               */
  103. /*                                                                      */
  104. /* This procedure should be used to query for CFI information           */
  105. /*                                                                      */
  106. /* Input:                                                               */
  107. /*          None                                                        */
  108. /*                                                                      */
  109. /* Output:                                                              */
  110. /*          None                                                        */
  111. /************************************************************************/

  113. int CFI_Query()
  114. {
  115.         WORD far *Temp1;

  117.         /*  Issue the Software Product ID code to 39VF400A   */

  119.         Temp1 = (WORD far *)0xC0005555; /* set up address to be C000:5555h    */
  120.         *Temp1= 0xAAAA;                 /* write data 0xAAAA to the address   */
  121.         Temp1 = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh    */
  122.         *Temp1= 0x5555;                 /* write data 0x5555 to the address   */
  123.         Temp1 = (WORD far *)0xC0005555; /* set up address to be C000:5555h    */
  124.         *Temp1= 0x9898;                 /* write data 0x9898 to the address   */

  126.         Delay_150_Nano_Seconds();       /* insert delay time = Tida           */

  128.         /* --------------------------------- */
  129.         /*  Perform all CFI operations here  */
  130.         /*  NOTE:  no sample code provided   */
  131.         /* --------------------------------- */


  134.         /* Issue the CFI Exit code thus returning the 39VF400A */
  135.         /* to the read operating mode                          */

  137.         Temp1  = (WORD far *)0xC0005555; /* set up address to be C000:5555h   */
  138.         *Temp1 = 0xAAAA;                 /* write data 0xAAAA to the address  */
  139.         Temp1  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh   */
  140.         *Temp1 = 0x5555;                 /* write data 0x5555 to the address  */
  141.         Temp1  = (WORD far *)0xC0005555; /* set up address to be C000:5555h   */
  142.         *Temp1 = 0xF0F0;                 /* write data 0xF0F0 to the address  */

  144.         Delay_150_Nano_Seconds();        /* insert delay time = Tida          */
  145. }


  148. /************************************************************************/
  149. /* PROCEDURE:   Erase_One_Sector                                        */
  150. /*                                                                      */
  151. /* This procedure can be used to erase a total of 2048 words.           */
  152. /*                                                                      */
  153. /* Input:                                                               */
  154. /*      Dst     DESTINATION address where the erase operation starts    */
  155. /*                                                                      */
  156. /* Output:                                                              */
  157. /*      NONE                                                            */
  158. /************************************************************************/

  160. int Erase_One_Sector (WORD far *Dst)
  161. {
  162.         WORD far *Temp;

  164.         /*  Issue the Sector Erase command to 39VF400A  */

  166.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  167.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  168.         Temp  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  169.         *Temp = 0x5555;                 /* write data 0x5555 to the address */
  170.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  171.         *Temp = 0x8080;                 /* write data 0x8080 to the address */
  172.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  173.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  174.         Temp  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  175.         *Temp = 0x5555;                 /* write data 0x5555 to the address */

  177.         Temp  = Dst;                  /* set up starting address to be erased */
  178.         *Temp = 0x3030;                 /* write data 0x3030 to the address */
  179.         Delay_25_Milli_Seconds();       /* Delay time = Tse                 */
  180. }


  183. /************************************************************************/
  184. /* PROCEDURE:   Erase_One_Block                                         */
  185. /*                                                                      */
  186. /* This procedure can be used to erase a total of 32K words.            */
  187. /*                                                                      */
  188. /* Input:                                                               */
  189. /*      Dst     DESTINATION address where the erase operation starts    */
  190. /*                                                                      */
  191. /* Output:                                                              */
  192. /*      NONE                                                            */
  193. /************************************************************************/

  195. int Erase_One_Block (WORD far *Dst)
  196. {
  197.         WORD far *Temp;

  199.         /*  Issue the Sector Erase command to 39VF400A  */

  201.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  202.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  203.         Temp  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  204.         *Temp = 0x5555;                 /* write data 0x5555 to the address */
  205.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  206.         *Temp = 0x8080;                 /* write data 0x8080 to the address */
  207.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  208.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  209.         Temp  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  210.         *Temp = 0x5555;                 /* write data 0x5555 to the address */

  212.         Temp  = Dst;                  /* set up starting address to be erased */
  213.         *Temp = 0x5050;                 /* write data 0x5050 to the address */
  214.         Delay_25_Milli_Seconds();       /* Delay time = Tbe                 */
  215. }


  218. /************************************************************************/
  219. /* PROCEDURE:   Erase_Entire_Chip                                       */
  220. /*                                                                      */
  221. /* This procedure can be used to erase the entire chip.                 */
  222. /*                                                                      */
  223. /* Input:                                                               */
  224. /*      NONE                                                            */
  225. /*                                                                      */
  226. /* Output:                                                              */
  227. /*      NONE                                                            */
  228. /************************************************************************/

  230. int Erase_Entire_Chip()
  231. {
  232.         WORD far *Temp;

  234.         /*  Issue the Chip Erase command to 39VF400A  */

  236.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  237.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  238.         Temp  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  239.         *Temp = 0x5555;                 /* write data 0x5555 to the address */
  240.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  241.         *Temp = 0x8080;                 /* write data 0x8080 to the address */
  242.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  243.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  244.         Temp  = (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  245.         *Temp = 0x5555;                 /* write data 0x5555 to the address */
  246.         Temp  = (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  247.         *Temp = 0x1010;                 /* write data 0x1010 to the address */
  248.         Delay_100_Milli_Seconds();      /* Delay Tsce time                  */
  249. }


  252. /************************************************************************/
  253. /* PROCEDURE:   Program_One_Word                                        */
  254. /*                                                                      */
  255. /* This procedure can be used to program ONE word of data to the        */
  256. /* 39VF400.                                                             */
  257. /*                                                                      */
  258. /* NOTE:  It is necessary to first erase the sector containing the      */
  259. /*        word to be programmed.                                            */
  260. /*                                                                      */
  261. /* Input:                                                               */
  262. /*           SrcWord The WORD which will be written to the 39VF400A     */
  263. /*           Dst     DESTINATION address which will be written with the */
  264. /*                   data passed in from Src                            */
  265. /*                                                                      */
  266. /* Output:                                                              */
  267. /*           None                                                       */
  268. /************************************************************************/

  270. void Program_One_Word (WORD SrcWord,    WORD far *Dst)
  271. {
  272.     WORD far *Temp;
  273.         WORD far *SourceBuf;
  274.         WORD far *DestBuf;
  275.         int Index;

  277.         DestBuf = Dst;

  279.         Temp =  (WORD far *)0xC0005555; /* set up address to be C000:555h   */
  280.         *Temp = 0xAAAA;                 /* write data 0xAAAA to the address */
  281.         Temp =  (WORD far *)0xC0002AAA; /* set up address to be C000:2AAAh  */
  282.         *Temp = 0x5555;                 /* write data 0x5555 to the address */
  283.         Temp =  (WORD far *)0xC0005555; /* set up address to be C000:5555h  */
  284.         *Temp = 0xA0A0;                 /* write data 0xA0A0 to the address */
  285.         *DestBuf = SrcWord;             /* transfer the byte to destination */
  286.         Check_Toggle_Ready(DestBuf);    /* wait for TOGGLE bit to get ready */
  287. }


  290. /************************************************************************/
  291. /* PROCEDURE:   Program_One_Sector                                      */
  292. /*                                                                      */
  293. /* This procedure can be used to program a total of 2048 words of data  */
  294. /* to the SST39VF400A.                                                  */
  295. /*                                                                      */
  296. /* Input:                                                               */
  297. /*           Src     SOURCE address containing the data which will be   */
  298. /*                   written to the 39VF400A                            */
  299. /*           Dst     DESTINATION address which will be written with the */
  300. /*                   data passed in from Src                            */
  301. /*                                                                      */
  302. /* Output:                                                              */
  303. /*           None                                                       */
  304. /************************************************************************/

  306. void Program_One_Sector (WORD far *Src,    WORD far *Dst)
  307. {
  308.         WORD far *Temp;
  309.         WORD far *SourceBuf;
  310.         WORD far *DestBuf;
  311.         int Index;

  313.         SourceBuf = Src;
  314.         DestBuf = Dst;

  316.         Erase_One_Sector(Dst);          /* erase the sector first */

  318.         for (Index = 0; Index < SECTOR_SIZE; Index++)
  319.         {
  320.             Temp =  (WORD far *)0xC0005555;
  321.             /* set up address to be C000:555h           */
  322.             *Temp = 0xAAAA;
  323.             /* write data 0xAAAA to the address         */
  324.             Temp =  (WORD far *)0xC0002AAA;
  325.             /* set up address to be C000:2AAAh          */
  326.             *Temp = 0x5555;
  327.             /* write data 0x5555 to the address         */
  328.             Temp =  (WORD far *)0xC0005555;
  329.             /* set up address to be C000:5555h          */
  330.             *Temp = 0xA0A0;
  331.             /* write data 0xA0A0 to the address         */
  332.             Temp = DestBuf;
  333.             /* save the original Destination address    */
  334.             *DestBuf++ = *SourceBuf++;
  335.             /* transfer data from source to destination */
  336.             Check_Toggle_Ready(Temp);
  337.             /* wait for TOGGLE bit to get ready         */
  338.         }
  339. }


  342. /************************************************************************/
  343. /* PROCEDURE:   Program_One_Block                                       */
  344. /*                                                                      */
  345. /* This procedure can be used to program a total of 32k words of data   */
  346. /* to the SST39VF400A.                                                  */
  347. /*                                                                      */
  348. /* Input:                                                               */
  349. /*           Src     SOURCE address containing the data which will be   */
  350. /*                   written to the 39VF400A                            */
  351. /*           Dst     DESTINATION address which will be written with the */
  352. /*                   data passed in from Src                            */
  353. /*                                                                      */
  354. /* Output:                                                              */
  355. /*           None                                                       */
  356. /************************************************************************/

  358. void Program_One_Block (WORD far *Src,    WORD far *Dst)
  359. {
  360.         WORD far *Temp;
  361.         WORD far *SourceBuf;
  362.         WORD far *DestBuf;
  363.         int Index;

  365.         SourceBuf = Src;
  366.         DestBuf = Dst;

  368.         Erase_One_Block(Dst);          /* erase the sector first */

  370.         for (Index = 0; Index < BLOCK_SIZE; Index++)
  371.         {
  372.             Temp =  (WORD far *)0xC0005555;
  373.             /* set up address to be C000:555h           */
  374.             *Temp = 0xAAAA;
  375.             /* write data 0xAAAA to the address         */
  376.             Temp =  (WORD far *)0xC0002AAA;
  377.             /* set up address to be C000:2AAAh          */
  378.             *Temp = 0x5555;
  379.             /* write data 0x5555 to the address         */
  380.             Temp =  (WORD far *)0xC0005555;
  381.             /* set up address to be C000:5555h          */
  382.             *Temp = 0xA0A0;
  383.             /* write data 0xA0A0 to the address         */
  384.             Temp = DestBuf;
  385.             /* save the original Destination address    */
  386.             *DestBuf++ = *SourceBuf++;
  387.             /* transfer data from source to destination */
  388.             Check_Toggle_Ready(Temp);
  389.             /* wait for TOGGLE bit to get ready         */
  390.         }
  391. }


  394. /************************************************************************/
  395. /* PROCEDURE:    Check_Toggle_Ready                                     */
  396. /*                                                                      */
  397. /* During the internal program cycle, any consecutive read operation    */
  398. /* on DQ6 will produce alternating 0's and 1's (i.e. toggling between   */
  399. /* 0 and 1). When the program cycle is completed, DQ6 of the data will  */
  400. /* stop toggling. After the DQ6 data bit stops toggling, the device is  */
  401. /* ready for next operation.                                            */
  402. /*                                                                      */
  403. /* Input:                                                               */
  404. /*           Dst        must already be set-up by the caller            */
  405. /*                                                                      */
  406. /* Output:                                                              */
  407. /*           None                                                       */
  408. /************************************************************************/

  410. void Check_Toggle_Ready (WORD far  *Dst)
  411. {
  412.         BYTE Loop = TRUE;
  413.         WORD PreData;
  414.         WORD CurrData;
  415.         unsigned long TimeOut = 0;

  417.         PreData = *Dst;
  418.         PreData = PreData & 0x4040;
  419.         while ((TimeOut< 0x07FFFFFF) && (Loop))
  420.         {
  421.             CurrData = *Dst;
  422.             CurrData = CurrData & 0x4040;
  423.             if (PreData == CurrData)
  424.                     Loop = FALSE;   /* ready to exit the while loop */
  425.             PreData = CurrData;
  426.             TimeOut++;
  427.         }
  428. }


  431. /************************************************************************/
  432. /* PROCEDURE:   Check_Data_Polling                                      */
  433. /*                                                                      */
  434. /* During the internal program cycle, any attempt to read DQ7 of the    */
  435. /* last byte loaded during the page/byte-load cycle will receive the    */
  436. /* complement of the true data.  Once the program cycle is completed,   */
  437. /* DQ7 will show true data.                                             */
  438. /*                                                                      */
  439. /* Input:                                                               */
  440. /*           Dst        must already be set-up by the caller            */
  441. /*           True       Data is the original (true) data                */
  442. /*                                                                      */
  443. /* Output:                                                              */
  444. /*           None                                                       */
  445. /************************************************************************/

  447. void Check_Data_Polling (WORD far  *Dst,       WORD TrueData)
  448. {
  449.         BYTE Loop = TRUE;
  450.         WORD CurrData;
  451.         unsigned long TimeOut = 0;

  453.         TrueData = TrueData &  0x8080;
  454.         while ((TimeOut< 0x07FFFFFF) && (Loop))
  455.         {
  456.                 CurrData = *Dst;
  457.                 CurrData = CurrData & 0x8080;
  458.                 if (TrueData == CurrData)
  459.                         Loop = FALSE;   /* ready to exit the while loop  */
  460.                 TimeOut++;
  461.         }
  462. }
复制代码




8086 ASSEMBLY LANGUAGE DRIVERS

  1. ; ======================================================================
  2. ; Copyright Silicon Storage Technology, Inc. (SST), 1994-2001
  3. ; EXAMPLE 8086 assembly Drivers for SST39VF400A 4 Mbit MultiPurpose Flash
  4. ; Frank Cirimele,  Silicon Storage Technology, Inc.
  5. ;
  6. ; Revision 1.0,  Sept. 12, 2001
  7. ;
  8. ; This file requires these external "timing" routines:
  9. ;
  10. ;       1.)  Delay_150_Nano_Seconds
  11. ;       2.)  Delay_25_Milli_Seconds
  12. ;       3.)  Delay_100_Milli_Seconds
  13. ; ======================================================================

  15. SECTOR_SIZE             EQU     2048    ; Must be 4096 bytes for SST39VF400A
  16. BLOCK_SIZE              EQU     32768

  18. SST_ID                  EQU     00BFh  ; SST Manufacturer's ID code
  19. SST_SST39VF400A         EQU     2780h  ; SST SST39VF400A internal code, and
  20.                                        ;  is same device code as SST39VF400
  21. ABS_SEGMENT     EQU     0C000h

  23. extrn   Delay_150_Nano_Seconds:near
  24. extrn   Delay_25_Milli_Seconds:near
  25. extrn   Delay_100_Milli_Seconds:near


  28. ;=======================================================================
  29. ; PROCEDURE:    Check_SST_SST39VF400A
  30. ;
  31. ; This procedure decides whether a physical hardware device has a
  32. ; SST39VF400A 4 Mbit Multi-Purpose Flash installed or not.
  33. ;
  34. ; Input:
  35. ;       None
  36. ;
  37. ; Output:
  38. ;       carry bit:   CLEARED means a SST39VF400A is installed
  39. ;       carry bit:   SET means a SST39VF400A is NOT installed
  40. ;
  41. ;=======================================================================

  43. Check_SST_SST39VF400A       proc    near

  45.         push    ax                              ; save registers
  46.         push    ds
  47.     pushf                    ; save interrupt state

  49.     ; It is mandatory to maintain pushf as the last push instruction.

  51.         cli                                     ; disable interrupts
  52.         mov     ax, ABS_SEGMENT                 ; set up data segment
  53.         mov     ds, ax

  55.         mov     ds:word ptr [5555h], 0AAAAh     ; issue the 3-byte product ID
  56.         mov     ds:word ptr [2AAAh], 05555h     ;  command to the SST39VF400A
  57.         mov     ds:word ptr [5555h], 09090h

  59.         call    Delay_150_Nano_Seconds          ; insert delay = Tida

  61.         mov     ax, ds:[0]
  62.         cmp     ax, SST_ID                      ; is this a SST part?
  63.         jne     CSC5                            ; NO, then return Carry set
  64.         mov     ax, ds:[1]
  65.         cmp     ax, SST_SST39VF400A             ; is it a SST39VF400A?
  66.         jne     CSC5                            ; NO, then Non-SST part and
  67.                                                 ; set Carry flag
  68. CSC4:
  69.     pop    ax                ; get flags from stack
  70.     and    ax, 0FFFEh            ; and clear carry flag
  71.         jmp     short CSC6

  73. CSC5:
  74.     pop    ax                ; get flags from stack
  75.     or     ax, 0001h            ; and set carry flag

  77. CSC6:
  78.     push    ax                ; return flags to stack

  80. ;
  81. ; Issue the Software Product ID Exit code thus returning the SST39VF400A
  82. ; to the read operation mode.
  83. ;

  85.         mov     ds:word ptr [5555h], 0AAAAh     ; issue the 3-byte product ID
  86.         mov     ds:word ptr [2AAAh], 05555h     ;  exit command to the
  87.         mov     ds:word ptr [5555h], 0F0F0h    ;  SST39VF400A

  89.         call    Delay_150_Nano_Seconds        ; insert delay = Tida

  91.         popf                                    ; restore flags
  92.         pop     ds                              ; restore registers
  93.         pop     ax

  95.         ret

  97. Check_SST_SST39VF400A endp


  100. ;=======================================================================
  101. ; PROCEDURE:    CFI_Query
  102. ;
  103. ; This procedure provides access to the CFI information embedded within
  104. ; the SST39VF400A 4 Mbit Multi-Purpose Flash device.
  105. ;
  106. ; Input:
  107. ;       None
  108. ;
  109. ; Output:
  110. ;       None
  111. ;
  112. ;=======================================================================

  114. CFI_Query       proc    near

  116.     pushf                    ; save interrupt state
  117.     push    ax                              ; save registers
  118.         push    ds

  120.         cli                                     ; disable interrupts
  121.         mov     ax, ABS_SEGMENT                 ; set up the ds register
  122.         mov     ds, ax

  124.         mov     ds:word ptr [5555h], 0AAAAh     ; issue the 3-byte product ID
  125.         mov     ds:word ptr [2AAAh], 05555h     ;  command to the SST39VF400A
  126.         mov     ds:word ptr [5555h], 09898h

  128.         call    Delay_150_Nano_Seconds        ; insert delay = Tida

  130. ; -----------------------------------
  131. ;   Perform all CFI operations here
  132. ;   NOTE:  NO sample code provided
  133. ; -----------------------------------


  136.         mov     ds:word ptr [5555h], 0AAAAh    ; issue the 3-byte product ID
  137.         mov     ds:word ptr [2AAAh], 05555h    ; exit command to the SST39VF400A
  138.         mov     ds:word ptr [5555h], 0F0F0h

  140.         call    Delay_150_Nano_Seconds        ; insert delay = Tida

  142.         pop     ds                              ; restore registers
  143.         pop     ax
  144.     popf                    ; restore flags

  146.         ret

  148. CFI_Query       endp


  151. ; =====================================================================
  152. ; PROCEDURE:    Erase_One_Sector
  153. ;
  154. ; This procedure can be used to erase a sector, or total of 2048 bytes,
  155. ; in the SST39VF400A.
  156. ;
  157. ; Input:
  158. ;       es:di   points to the beginning address of the "Destination"
  159. ;               sector which will be erased.
  160. ;               ==> Note: The address MUST be on a sector boundary,
  161. ;                         that is, a multiple of 2048.
  162. ;
  163. ; Output:
  164. ;       None
  165. ; =====================================================================

  167. Erase_One_Sector        proc    near

  169.         push    ax                              ; save register

  171.         mov     es:word ptr [5555h], 0AAAAh    ; send 6-byte code for
  172.         mov     es:word ptr [2AAAh], 05555h    ; sector erase
  173.         mov     es:word ptr [5555h], 08080h
  174.         mov     es:word ptr [5555h], 0AAAAh
  175.         mov     es:word ptr [2AAAh], 05555h
  176.         mov     ax, 03030h
  177.         mov     word ptr es:[di], ax

  179.         call    Delay_25_Milli_Seconds        ; insert delay = Tse

  181.         pop     ax                              ; restore register

  183.         ret

  185. Erase_One_Sector        endp


  188. ; =====================================================================
  189. ; PROCEDURE:    Erase_One_Block
  190. ;
  191. ; This procedure can be used to erase a block, or total of 32K words,
  192. ; in the SST39VF400A.
  193. ;
  194. ; Input:
  195. ;       es:di   points to the beginning address of the "Destination"
  196. ;               block which will be erased.
  197. ;               ==> Note: The address MUST be on a block boundary,
  198. ;                         that is, a multiple of 32K.
  199. ;
  200. ; Output:
  201. ;       None
  202. ; =====================================================================

  204. Erase_One_Block         proc    near

  206.         push    ax                              ; save register

  208.         mov     es:word ptr [5555h], 0AAAAh    ; send 6-byte code for
  209.         mov     es:word ptr [2AAAh], 05555h    ; block erase
  210.         mov     es:word ptr [5555h], 08080h
  211.         mov     es:word ptr [5555h], 0AAAAh
  212.         mov     es:word ptr [2AAAh], 05555h
  213.         mov     ax, 05050h
  214.         mov     word ptr es:[di], ax

  216.         call    Delay_25_Milli_Seconds        ; insert delay = Tbe

  218.         pop     ax                              ; restore register

  220.         ret

  222. Erase_One_Block         endp


  225. ; =====================================================================
  226. ; PROCEDURE:    Erase_Entire_Chip
  227. ;
  228. ; This procedure can be used to erase the entire contents of
  229. ; SST's SST39VF400A.
  230. ;
  231. ; Input:
  232. ;       none
  233. ;
  234. ; Output:
  235. ;       None
  236. ; =====================================================================

  238. Erase_Entire_Chip       proc    near

  240.         mov     es:word ptr [5555h], 0AAAAh    ; send 6-byte code for
  241.         mov     es:word ptr [2AAAh], 05555h    ; chip erase
  242.         mov     es:word ptr [5555h], 08080h
  243.         mov     es:word ptr [5555h], 0AAAAh
  244.         mov     es:word ptr [2AAAh], 05555h
  245.         mov     es:word ptr [5555h], 01010h

  247.         call    Delay_100_Milli_Seconds        ; insert delay = Tsce

  249.         ret

  251. Erase_Entire_Chip       endp


  254. ; =====================================================================
  255. ; PROCEDURE:    Program_One_Word
  256. ;
  257. ; This procedure can be used to program ONE word of data to the SST39VF400A.
  258. ;
  259. ; NOTE:  It is necessary to first erase the sector containing the word to
  260. ;        be programmed.
  261. ;
  262. ;
  263. ; Input:
  264. ;       ax      WORD which will be written into the SST39VF400A.
  265. ;       es:di   DESTINATION address which will be written with the
  266. ;               data input in ax.
  267. ;
  268. ; Output:
  269. ;       None
  270. ;       SI, DI:  Contain their original values
  271. ; =====================================================================

  273. Program_One_Word          proc    near

  275.         push    ax                              ; save registers
  276.         push    ds
  277.         mov     ax, ABS_SEGMENT                 ; set up the ds register
  278.         mov     ds, ax
  279.         mov     ds:word ptr [5555h], 0AAAAh     ; send 3 byte data protection
  280.         mov     ds:word ptr [2AAAh], 05555h     ;  sequence to the chip
  281.         mov     ds:word ptr [5555h], 0A0A0h
  282.         pop     ds                              ; restore the byte to be
  283.         pop     ax                             ;  programmed from stack
  284.         mov     word ptr es:[di], ax            ; program the byte
  285.         call    check_Toggle_Ready              ; wait for valid TOGGLE bit

  287.         ret

  289. Program_One_Word          endp


  292. ; =====================================================================
  293. ; PROCEDURE:    Program_One_Sector
  294. ;
  295. ; This procedure can be used to program a memory sector, or total of
  296. ; 2048 words, of the SST39VF400A.
  297. ;
  298. ; Input:
  299. ;       ds:si   SOURCE address containing the data which will be
  300. ;               written into the SST39VF400A.
  301. ;       es:di   DESTINATION address which will be written with the
  302. ;               data passed in for ds:si
  303. ;
  304. ; Output:
  305. ;       None
  306. ;       SI, DI:  Contain their original values
  307. ; =====================================================================

  309. Program_One_Sector        proc    near

  311.         push    ax              ; save registers
  312.         push    bx
  313.         push    di
  314.         push    si
  315.         pushf                   ; preserve the "Direction" flag
  316.         cld                     ; clear "Direction" flag to
  317.                                 ;  auto-increment SI and DI
  318. ;
  319. ; Erase the sector before programming.  Each erase command will erase a total
  320. ; of 2048 words for the SST39VF400A
  321. ;
  322.         call    Erase_One_Sector
  323. ;
  324. ; The following loop will program a total of 2048 words to the SST39VF400A
  325. ;
  326.         mov     cx, SECTOR_SIZE
  327. POS1:
  328.         push    ds
  329.         mov     ax, ABS_SEGMENT
  330.         mov     ds, ax
  331.         mov     ds:word ptr [5555h], 0AAAAh    ; send 3-byte SDP sequence
  332.         mov     ds:word ptr [2AAAh], 05555h
  333.         mov     ds:word ptr [5555h], 0A0A0h
  334.         pop     ds

  336.         lodsw                           ; get the word to be programmed
  337.         mov     bx, di                  ; preserve original DI temporarily
  338.         stosw                           ; program the word
  339.         push    di                      ; preserve incremented DI temporarily
  340.         mov     di, bx            ; restore original DI
  341.         call    check_Toggle_Ready      ; wait for TOGGLE bit to get ready
  342.         pop     di                      ; retrieve the updated DI
  343.         loop    POS1                    ; continue program more words until done
  344. ;
  345. ; Restore the registers' value from the stack
  346. ;
  347.         popf                            ; restore original direction flag
  348.         pop     si                      ; restore registers
  349.         pop     di
  350.         pop     bx
  351.         pop     ax

  353.         ret

  355. Program_One_Sector        endp


  358. ; =====================================================================
  359. ; PROCEDURE:    Program_One_Block
  360. ;
  361. ; This procedure can be used to program a memory block, or a total of
  362. ; 32K words, of the SST39VF400A.
  363. ;
  364. ; Input:
  365. ;       ds:si   SOURCE address containing the data which will be
  366. ;               written into the SST39VF400A.
  367. ;       es:di   DESTINATION address which will be written with the
  368. ;               data passed in for ds:si
  369. ;
  370. ; Output:
  371. ;       None
  372. ;       SI, DI:  Contain their original values
  373. ; =====================================================================

  375. Program_One_Block         proc    near

  377.         push    ax              ; save registers
  378.         push    bx
  379.         push    di
  380.         push    si
  381.         pushf                   ; preserve the "Direction" flag
  382.         cld                     ; clear "Direction" flag to
  383.                                 ;  auto-increment SI and DI
  384. ;
  385. ; Erase the block before programming.  Each erase command will erase a total
  386. ; of 32K words of the SST39VF400A.
  387. ;
  388.         call    Erase_One_Block
  389. ;
  390. ; The following loop will program a total of 32K words to SST's SST39VF400A
  391. ;
  392.         mov     cx, BLOCK_SIZE
  393. POB1:
  394.         push    ds
  395.         mov     ax, ABS_SEGMENT
  396.         mov     ds, ax
  397.         mov     ds:word ptr [5555h], 0AAAAh     ; send 3-byte SDP sequence
  398.         mov     ds:word ptr [2AAAh], 05555h     
  399.         mov     ds:word ptr [5555h], 0A0A0h
  400.         pop     ds

  402.         lodsw                           ; get the word to be programmed
  403.         mov     bx, di                  ; preserve DI temporarily
  404.         stosw                           ; program the word
  405.         push    di                      ; preserve incremented DI temporarily
  406.         mov     di, bx            ; restore original DI
  407.         call    check_Toggle_Ready      ; wait for TOGGLE bit to get ready
  408.         pop     di                      ; retrieve the updated DI
  409.         loop    POB1                    ; continue program more words until done

  411.         popf                            ; restore original direction flag
  412.         pop     si                      ; restore registers
  413.         pop     di
  414.         pop     bx
  415.         pop     ax

  417.         ret

  419. Program_One_Block         endp


  422. ;======================================================================
  423. ; PROCEDURE:                    Check_Toggle_Ready
  424. ;
  425. ; During the internal program cycle, any consecutive read operation
  426. ; on DQ6 will produce alternating 0抯 and 1抯, i.e. toggling between
  427. ; 0 and 1. When the program cycle is completed, the DQ6 data will
  428. ; stop toggling. After the DQ6 data stops toggling, the device is ready
  429. ; for the next operation.
  430. ;
  431. ; Input:
  432. ;       es:di   must already be set-up by the caller
  433. ;
  434. ; Output:
  435. ;       None
  436. ;======================================================================

  438. Check_Toggle_Ready      proc    near

  440.         push    ax              ; save registers
  441.         push    bx

  443.         mov     ax, es:[di]     ; read a word from the chip
  444.         and     ax, 4040h       ; mask out the TOGGLE bit (DQ6)
  445. CTR_Tog2:
  446.         mov     bx, es:[di]     ; read the same word from the chip again
  447.         and     bx, 4040h       ; mask out the TOGGLE bit (DQ6)
  448.         cmp     ax, bx          ; is DQ6 still toggling?
  449.         je      CTR_Tog3        ; No, then the write operation is done
  450.         xchg    ax, bx          ; YES, then continue checking...
  451.         jmp     short CTR_Tog2
  452. CTR_Tog3:
  453.         pop     bx              ; restore registers
  454.         pop     ax

  456.         ret

  458. Check_Toggle_Ready      endp


  461. ;=======================================================================
  462. ; PROCEDURE:                    Check_Data_Polling
  463. ;
  464. ; During the internal program cycle, any attempt to read DQ7 of the last
  465. ; byte loaded during the page/byte-load cycle will receive the complement
  466. ; of the true data.  Once the program cycle is completed, DQ7 will show
  467. ; true data.
  468. ;
  469. ; Input:
  470. ;       es:di   must already be set-up by the caller
  471. ;       bx      contains the original (true) data
  472. ;
  473. ; Output:
  474. ;       None
  475. ;
  476. ;=======================================================================

  478. Check_Data_Polling      proc    near

  480.         push    ax              ; save registers
  481.         push    bx

  483.         and     bx, 8080h       ; mask out the DQ7 bit
  484. CDP_Tog2:
  485.         mov     ax, es:[di]     ; read a word from the chip
  486.         and     ax, 8080h       ; mask out the DQ7 bit
  487.         cmp     ax, bx          ; is DQ7 still complementing?
  488.         jne     CDP_Tog2

  490.         pop     bx              ; restore registers
  491.         pop     ax

  493.         ret

  495. Check_Data_Polling      endp
复制代码



分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友 微信微信
收藏收藏1 分享分享 支持支持 反对反对
回复

使用道具 举报

program
沙发
发表于 2012-10-29 09:14:47 | 只看该作者
这是官网上面copy 的吗
回复 支持 反对

使用道具 举报

program
板凳
发表于 2013-9-22 10:48:21 | 只看该作者
mark!         
回复 支持 反对

使用道具 举报

a50180
地板
发表于 2014-5-24 15:36:34 | 只看该作者
官网会给烧写代码吗？
回复 支持 反对

使用道具 举报

liyf
5#
 楼主| 发表于 2014-5-24 16:04:32 | 只看该作者
这是别人能用的代码，单片机操作该型号芯片
回复 支持 反对

使用道具 举报

liyf
7#
 楼主| 发表于 2014-9-29 15:18:24 | 只看该作者
jy11 发表于 2014-9-29 12:51
c与汇编？？？

函数实现部分都是汇编的
回复 支持 反对

使用道具 举报

jy11
8#
发表于 2014-10-17 17:27:40 | 只看该作者
真牛 ，也不 晕 。
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

小黑屋|文字版|手机版|DIY编程器网 ( 桂ICP备14005565号-1 )

GMT+8, 2024-12-23 15:10 , 耗时 0.097001 秒, 17 个查询请求 , Gzip 开启.

各位嘉宾言论仅代表个人观点，非属DIY编程器网立场。

桂公网安备 45031202000115号

DIY编程器群(超员)：41210778 DIY编程器

DIY编程器群1(满员)：3044634 DIY编程器1

diy编程器群2：551025008 diy编程器群2

QQ：28000622；Email：libyoufer@sina.com

本站由桂林市临桂区技兴电子商务经营部独家赞助。旨在技术交流，请自觉遵守国家法律法规，一旦发现将做封号删号处理。

快速回复 返回顶部 返回列表