NXP

[分享][下载]EzPort驱动（K20测试通过）

2020-02-11 09:52发布

站内问答 / 51单片机
7574 19 19
本帖最后由 Gorgon_Meducer 于 2013-10-30 15:57 编辑

说在前面的话

这是之前做AtoM连线编程器时候的一个副产品，EzPort的驱动程序，用全状态机架构编写，
用起来也应该是蛮简单的。简单说明一下这个库的特点：

1、全状态机架构开发，非阻塞代码
2、硬件无关，库所依赖的IO口操作以及SPI的数据传输操作均通过“插入宏”的形式由外界
   提供，无需修改源代码本身。插入宏通过app_cfg.h提供。
3、遵循ESSF 2.x 编码规范

目录结构

    EzPort
        |
        - EzPort.h             Ezport的接口头文件，用于向外界输出接口信
        |
        - EzPort.c             EzPort的源文件 s
        |
        - app_cfg.h           EzPort的配置文件，该文件自动包含了上一级的app_cfg.h所以，
                                  用户并不需要直接修改该app_cfg.h，可以通过在文件夹外创建
                                  一个app_cfg.h来完成对配置信息的传递



使用说明(readme.txt)

1、解压缩后将此文件夹下的所有文件放置到工程目录中
2、将EzPort.c加入到工程中参与编译
3、在readme.txt相同目录下的app_cfg.h中加入对EzPort的配置信息
4、使用的时候，包含readme.txt相同目录下的EzPort.h，例如：
   #include "EzPort_driverezport.h"
5、具体有哪些接口可以使用，请参考EzPort文件夹下EzPort.h的内容
4、具体需要外部提供哪些支持，请参考编译时获得的错误提示。
相关下载

Ezport_driver.rar (40.79 KB, 下载次数: 25) 2013-10-30 15:56 上传 点击文件名下载附件


以下是接口头文件的内容，如果你只关心如何使用，那么应该专注于该头文件：
EzPort.h

  2. /***************************************************************************
  3. *   Copyright(C)2009-2012 by Gorgon Meducer<Embedded_zhuoran@hotmail.com> *
  4. *                                                                         *
  5. *   This program is free software; you can redistribute it and/or modify  *
  6. *   it under the terms of the GNU Lesser General Public License as        *
  7. *   published by the Free Software Foundation; either version 2 of the    *
  8. *   License, or (at your option) any later version.                       *
  9. *                                                                         *
  10. *   This program is distributed in the hope that it will be useful,       *
  11. *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12. *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13. *   GNU General Public License for more details.                          *
  14. *                                                                         *
  15. *   You should have received a copy of the GNU Lesser General Public      *
  16. *   License along with this program; if not, write to the                 *
  17. *   Free Software Foundation, Inc.,                                       *
  18. *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19. ***************************************************************************/

  21. #ifndef __COMPONENT_EZPORT_H__
  22. #define __COMPONENT_EZPORT_H__

  24. /*============================ INCLUDES ======================================*/
  25. #include ".app_cfg.h"

  27. #if USE_COMPONENT_EZPORT == ENABLED

  29. /*============================ MACROS ========================================*/
  30. /*============================ MACROFIED FUNCTIONS ===========================*/
  31. /*============================ TYPES =========================================*/
  32. /*============================ GLOBAL VARIABLES ==============================*/
  33. /*============================ LOCAL VARIABLES ===============================*/
  34. /*============================ PROTOTYPES ====================================*/
  35. /*! ote initialize EzPort
  36. *  param none
  37. *   eturn state-machine status
  38. */  
  39. extern fsm_rt_t ezport_initialize( void );

  41. /*! rief finalize ezport
  42. *! param none
  43. *! eturn fsm status
  44. */
  45. extern fsm_rt_t ezport_finalize(void);

  47. /*! rief enable EzPort mode
  48. *! param none
  49. *! eturn state machine status
  50. */
  51. extern fsm_rt_t ezport_enable( void );

  53. /*! rief disable ezport
  54. *! param none
  55. *! eturn fsm status
  56. */
  57. extern fsm_rt_t ezport_disable(void);

  59. /*! rief erase chip
  60. *! param none
  61. *! eturn fsm status
  62. */
  63. extern fsm_rt_t ezport_chip_erase(void);

  65. /*! rief read flash through Ezport
  66. *! param wAddress target address
  67. *! param pchStream data buffer
  68. *! param hwSize buffer size
  69. *! eturn fsm status
  70. */
  71. extern fsm_rt_t ezport_read(
  72.     uint32_t wAddress, uint8_t *pchStream, uint16_t hwSize);

  74. /*! rief read flash through Ezport
  75. *! param wAddress target address
  76. *! param pchStream data buffer
  77. *! param hwSize buffer size
  78. *! eturn fsm status
  79. */
  80. extern fsm_rt_t ezport_write(
  81.     uint32_t wAddress, uint8_t *pchStream, uint16_t hwSize);

  83. /*! rief verify flash through Ezport
  84. *! param wAddress target address
  85. *! param pchStream data buffer
  86. *! param hwSize buffer size
  87. *! eturn fsm status
  88. */
  89. extern fsm_rt_t ezport_verify(
  90.     uint32_t wAddress, uint8_t *pchStream, uint16_t hwSize);

  92. #endif

  94. #endif
  95. /* EOF */
复制代码
EzPort.c

  2. /***************************************************************************
  3. *   Copyright(C)2009-2012 by Gorgon Meducer<Embedded_zhuoran@hotmail.com> *
  4. *                                                                         *
  5. *   This program is free software; you can redistribute it and/or modify  *
  6. *   it under the terms of the GNU Lesser General Public License as        *
  7. *   published by the Free Software Foundation; either version 2 of the    *
  8. *   License, or (at your option) any later version.                       *
  9. *                                                                         *
  10. *   This program is distributed in the hope that it will be useful,       *
  11. *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12. *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13. *   GNU General Public License for more details.                          *
  14. *                                                                         *
  15. *   You should have received a copy of the GNU Lesser General Public      *
  16. *   License along with this program; if not, write to the                 *
  17. *   Free Software Foundation, Inc.,                                       *
  18. *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19. ***************************************************************************/

  21. /*============================ INCLUDES ======================================*/
  22. #include ".app_cfg.h"

  24. #if USE_COMPONENT_EZPORT == ENABLED
  25. /*============================ MACROS ========================================*/

  27. //! ESP_STATUS register bit definition
  28. //! @{
  29. #define WIP         0       //!< Write in progress
  30. #define WEN         1       //!< Write Enabled
  31. #define BEDIS       2       //!< Bulk erase disabled
  32. #define FLEXRAM     3       //!< FlexRAM Mode
  33. #define WEF         6       //!< Write Error Flag
  34. #define FS          7       //!< Flash Security
  35. //! @}

  37. /*============================ MACROFIED FUNCTIONS ===========================*/

  39. //! rief check macros for target device reset control
  40. #ifndef EZP_SET_RESET
  41. #error No defined macro EZP_SET_RESET for releasing target device reset pin.
  42. #endif
  43. #ifndef EZP_CLR_RESET
  44. #error No defined macro EZP_CLR_RESET for clearing target device reset pin.
  45. #endif

  47. //! rief check macros for EZP_CS control
  48. #ifndef EZP_SET_CS
  49. #error No defined macro EZP_SET_CS() for setting EZP_CS pin.
  50. #endif
  51. #ifndef EZP_CLR_CS
  52. #error No defined macro EZP_CLR_CS() for clearing EZP_CS pin
  53. #endif

  55. //! rief check macro for spi initialization
  56. #ifndef EZP_SPI_INIT
  57. #error No defined macro EZP_SPI_INIT() for spi initialization.
  58. #endif

  60. //! rief check macro for spi data exchange
  61. #ifndef EZP_SPI_DATA_EXCHANGE
  62. #error No defined macro EZP_SPI_DATA_EXCHANGE(__OUTPUT, __INPUT, __LENGTH) for
  63.        spi data exchange.
  64. #endif

  66. //! rief check macro for enabling spi
  67. #ifndef EZP_SPI_ENABLE
  68. #error No defined macro EZP_SPI_ENABLE for enabling spi interface
  69. #endif

  71. //! rief check macro for disabling spi
  72. #ifndef EZP_SPI_DISABLE
  73. #error No defined macro EZP_SPI_DISABLE for disabling spi interface
  74. #endif

  76. #ifndef EZP_FLASH_SECTOR_SIZE
  77. #error No defined flash sector size : EZP_FLASH_SECTOR_SIZE
  78. #endif

  80. /*============================ TYPES =========================================*/

  82. //! ame EzPort Command
  83. //! @{
  84. enum {
  85.     EZP_WREN            = 0x06, //!< Enable write
  86.     EZP_WRDI            = 0x04, //!< Disable write
  87.     EZP_RDSR            = 0x05, //!< Read Status Register
  88.     EZP_READ            = 0x03, //!< Read Flash Data
  89.     EZP_FAST_READ       = 0x0B, //!< Fast-Read Flash Data
  90.     EZP_SP              = 0x02, //!< Program Flash Section
  91.     EZP_SE              = 0xD8, //!< Erase Flash Sector
  92.     EZP_BE              = 0xC7, //!< Erase Flash Bulk
  93.     EZP_RESET           = 0xB9, //!< Reset Target Chip
  94.     EZP_WRFCCOB         = 0xBA, //!< Write FCCOB Registers
  95.     EZP_FAST_WRFCCOB    = 0xBB, //!< Read FCCOB register at high speed
  96.     EZP_WRFLEXRAM       = 0xBC, //!< Write FlexRAM
  97.     EZP_RDFLEXRAM       = 0xBD, //!< Read FlexRAM
  98.     EZP_FAST_RDFLEXRAM  = 0xBE, //!< Read FlexRAM at high speed
  99. };
  100. //! @}


  103. /*============================ GLOBAL VARIABLES ==============================*/
  104. /*============================ LOCAL VARIABLES ===============================*/
  105. //! rief command buffer
  106. NO_INIT static uint8_t s_chCMDBuffer[5];
  107. static bool s_bEzPortEnabled = false;
  108. static bool s_bChipErased = false;

  110. /*============================ PROTOTYPES ====================================*/
  111. static fsm_rt_t read_status(uint8_t *pchStatus);
  112. static fsm_rt_t check_status(bool bIgnoreFS);
  113. static fsm_rt_t write_cmd(uint8_t chCMD, bool bIgnoreFS);
  114. static fsm_rt_t send_command( uint8_t *pchOutput, uint_fast16_t hwOSize,
  115.      uint8_t *pchInput, uint_fast16_t hwISize, uint8_t chCS);

  117. /*============================ IMPLEMENTATION ================================*/

  119. #define EZP_CMD_START           0
  120. #define EZP_CMD_WRITE           1
  121. #define EZP_CMD_READ            2
  122. #define EZP_CMD_FINALIZE        3
  123. #define EZP_CMD_RESET()         do {s_chState = 0;} while(false)

  125. /*! rief Function for issuing EzPort Command
  126. *! param pchOutput output buffer
  127. *! param hwOSize output buffer size
  128. *! param pchInput input buffer
  129. *! param hwISize input buffer size
  130. *! param chCS CS control bits:
  131. *!        BIT0 - disable assertion, BIT1 - disable negation
  132. *! eturn fsm status
  133. */
  134. static fsm_rt_t send_command( uint8_t *pchOutput, uint_fast16_t hwOSize,
  135.      uint8_t *pchInput, uint_fast16_t hwISize, uint8_t chCS)
  136. {
  137.     static uint8_t s_chState = 0;
  138.    
  139.     //! validate command
  140.     if (NULL == pchOutput || 0 == hwOSize) {
  141.         return fsm_rt_cpl;
  142.     }

  144.     switch (s_chState) {
  145.         case EZP_CMD_START:
  146.             EZP_SPI_ENABLE();                       //!< enable spi
  147.             if (!(chCS & _BV(0))) {
  148.                 EZP_CLR_CS();                       //!< assert EZP_CS
  149.             }
  150.             s_chState = EZP_CMD_WRITE;              //!< transfer to next state

  152.         case EZP_CMD_WRITE:
  153.             //! write command
  154.             if (fsm_rt_on_going == EZP_SPI_DATA_EXCHANGE(pchOutput, NULL, hwOSize)) {
  155.                 break;
  156.             }
  157.             if (NULL == pchInput || 0 == hwISize) {
  158.                 s_chState = EZP_CMD_FINALIZE;
  159.                 break;
  160.             }
  161.             s_chState = EZP_CMD_READ;               //!< transfer to next state

  163.         case EZP_CMD_READ:
  164.             //! read content back
  165.             if (fsm_rt_on_going == EZP_SPI_DATA_EXCHANGE(NULL, pchInput, hwISize)) {
  166.                 break;
  167.             }
  168.             s_chState = EZP_CMD_FINALIZE;

  170.         case EZP_CMD_FINALIZE:
  171.         default:
  172.             
  173.             if (!(chCS & _BV(1))) {
  174.                 EZP_SET_CS();                       //!< negate EZP_CS
  175.             }
  176.             EZP_CMD_RESET();                        //!< reset statemachine
  177.             EZP_SPI_DISABLE();                      //!< disable spi
  178.             return fsm_rt_cpl;
  179.             break;
  180.     }

  182.     return fsm_rt_on_going;
  183. }

  185. #define EZP_RDSR_START          0
  186. #define EZP_RDSR_SND_CMD        1
  187. #define EZP_RDSR_RESET()        do { s_chState = 0; } while(0)

  189. /*! rief read EzPort status
  190. *! param pchStatus status buffer
  191. *! eturn fsm status
  192. */
  193. ROOT static fsm_rt_t read_status(uint8_t *pchStatus)
  194. {
  195.     static uint8_t s_chState = 0;
  196.     fsm_rt_t tfsm;

  198.     switch (s_chState) {
  199.         case EZP_RDSR_START:
  200.             s_chCMDBuffer[0] = EZP_RDSR;   //!< read status command
  201.             s_chState = EZP_RDSR_SND_CMD;

  203.         case EZP_RDSR_SND_CMD:
  204.             tfsm = send_command(s_chCMDBuffer, 1, pchStatus, 1 , 0);
  205.             if (IS_FSM_ERR(tfsm)) {
  206.                 EZP_RDSR_RESET();
  207.                 return tfsm;
  208.             } else if (fsm_rt_cpl != tfsm) {
  209.                 break;
  210.             }
  211.             EZP_RDSR_RESET();
  212.             return fsm_rt_cpl;
  213.     }

  215.     return fsm_rt_on_going;
  216. }

  218. static fsm_rt_t check_status(bool bIgnoreFS)
  219. {
  220.     NO_INIT static uint8_t s_chEzPortStatus;
  221.     do {
  222.         fsm_rt_t tfsm = read_status(&s_chEzPortStatus);
  223.         if (IS_FSM_ERR(tfsm)) {
  224.             return tfsm;
  225.         } else if (fsm_rt_cpl != tfsm) {
  226.             break;
  227.         } else if (s_chEzPortStatus & (_BV(WEF) | _BV(WIP))) {
  228.             //! keep pulling the status
  229.             break;
  230.         } else if (s_chEzPortStatus & _BV(FS) && !bIgnoreFS) {
  231.             return fsm_rt_err;
  232.         }
  233.         return fsm_rt_cpl;
  234.     } while (false);

  236.     return fsm_rt_on_going;
  237. }

  239. #define EZP_WCMD_START          0
  240. #define EZP_WCMD_SND_CMD        1
  241. #define EZP_WCMD_RESET()        do { s_chState = 0; } while(0)

  243. /*! rief write simple command
  244. *! param pchStatus status buffer
  245. *! eturn fsm status
  246. */
  247. static fsm_rt_t write_cmd(uint8_t chCMD, bool bIgnoreFS)
  248. {
  249.     static uint8_t s_chState = 0;
  250.     fsm_rt_t tfsm;

  252.     switch (s_chState) {
  253.         case EZP_WCMD_START:
  254.             tfsm = check_status(bIgnoreFS);
  255.             if (IS_FSM_ERR(tfsm)) {
  256.                 EZP_WCMD_RESET();
  257.                 return tfsm;
  258.             } else if (tfsm != fsm_rt_cpl) {
  259.                 //! on going
  260.                 break;
  261.             }
  262.             s_chCMDBuffer[0] = chCMD;   //!< read status command
  263.             s_chState = EZP_WCMD_SND_CMD;

  265.         case EZP_WCMD_SND_CMD:
  266.             tfsm = send_command(s_chCMDBuffer, 1, NULL, 0 , 0);
  267.             if (IS_FSM_ERR(tfsm)) {
  268.                 EZP_WCMD_RESET();
  269.                 return tfsm;
  270.             }
  271.             if (fsm_rt_cpl != tfsm) {
  272.                 break;
  273.             }
  274.             EZP_WCMD_RESET();
  275.             return fsm_rt_cpl;
  276.     }

  278.     return fsm_rt_on_going;
  279. }


  282. #define EZP_RST_START           0
  283. #define EZP_RST_DELAY_A         1
  284. #define EZP_RST_RELEASE_RST     2
  285. #define EZP_RST_DELAY_B         3
  286. #define EZP_RST_RESET()         do {s_chState = 0;} while(0)

  288. /*! rief enable EzPort mode
  289. *! param none
  290. *! eturn state machine status
  291. */
  292. ROOT fsm_rt_t ezport_enable(void)
  293. {
  294.     static uint8_t s_chState = 0;
  295.     NO_INIT static uint32_t s_wDelay;

  297.     switch (s_chState) {
  298.         case EZP_RST_START:
  299.             EZP_CLR_RESET();                //!< pull-down reset pin
  300.             EZP_CLR_CS();                   //!< assert EZP_CS pin
  301.             s_wDelay = 50 * 1000;           //!< delay > 1ms
  302.             s_chState = EZP_RST_DELAY_A;

  304.         case EZP_RST_DELAY_A:
  305.             if (s_wDelay) {
  306.                 s_wDelay--;
  307.                 break;
  308.             }
  309.             s_chState = EZP_RST_RELEASE_RST;

  311.         case EZP_RST_RELEASE_RST:
  312.             EZP_SET_RESET();                //!< set reset pin
  313.             s_wDelay = 50 * 1000;           //!< delay > 1ms
  314.             s_chState = EZP_RST_DELAY_B;
  315.    
  316.         case EZP_RST_DELAY_B:
  317.             if (s_wDelay) {
  318.                 s_wDelay--;
  319.                 break;
  320.             }
  321.             EZP_SET_CS();                   //!< negate EZP_CS pin
  322.             EZP_RST_RESET();                //!< reset state-machine
  323.             s_bEzPortEnabled = true;
  324.             return fsm_rt_cpl;
  325.     }

  327.     return fsm_rt_on_going;
  328. }


  331. /*! rief disable ezport
  332. *! param none
  333. *! eturn fsm status
  334. */
  335. fsm_rt_t ezport_disable(void)
  336. {
  337.     if (!s_bEzPortEnabled) {
  338.         return fsm_rt_cpl;
  339.     }
  340.     fsm_rt_t tfsm = write_cmd(EZP_RESET, true);
  341.     if (fsm_rt_cpl == tfsm) {
  342.         s_bEzPortEnabled = false;
  343.         s_bChipErased = false;
  344.     }

  346.     return tfsm;
  347. }


  350. /*! ote initialize EzPort
  351. *  param none
  352. *   eturn state-machine status
  353. */  
  354. fsm_rt_t ezport_initialize( void )
  355. {
  356.     return EZP_SPI_INIT();              //!< initialize SPI
  357. }

  359. fsm_rt_t ezport_finalize( void )
  360. {
  361.     return ezport_disable();            //!< disable EzPort
  362. }


  365. #define EZP_ERASE_START         0
  366. #define EZP_ERASE_CHIP_ERASE    1
  367. #define EZP_ERASE_CHECK_RESULT  2
  368. #define EZP_ERASE_DEMO          3
  369. #define EZP_ERASE_DEMO_A        4
  370. #define EZP_ERASE_RESET()       do { s_chState = 0; } while(0)

  372. /*! rief erase chip
  373. *! param none
  374. *! eturn fsm status
  375. */
  376. fsm_rt_t ezport_chip_erase(void)
  377. {
  378.     static uint8_t s_chState = 0;
  379.     fsm_rt_t tfsm;

  381.     switch (s_chState) {
  382.         case EZP_ERASE_START:
  383.             tfsm = write_cmd(EZP_WREN, true);         //!< enable write
  384.             if (IS_FSM_ERR(tfsm)) {
  385.                 EZP_ERASE_RESET();
  386.                 return tfsm;
  387.             } else if (fsm_rt_cpl != tfsm) {
  388.                 break;
  389.             }
  390.             s_chState = EZP_ERASE_CHIP_ERASE;

  392.         case EZP_ERASE_CHIP_ERASE:
  393.             tfsm = write_cmd(EZP_BE, true);           //!< chip erase
  394.             if (IS_FSM_ERR(tfsm)) {
  395.                 EZP_ERASE_RESET();
  396.                 return tfsm;
  397.             } else if (fsm_rt_cpl != tfsm) {
  398.                 break;
  399.             }
  400.             s_chState = EZP_ERASE_CHECK_RESULT;

  402. //        case EZP_ERASE_CHIP_ERASE:
  403. //            //tfsm = write_cmd(EZP_BE, true);           //!< chip erase
  404. //            static uint8_t s_chTemp;
  405. //            tfsm = read_status(&s_chTemp);
  406. //            if (IS_FSM_ERR(tfsm)) {
  407. //                EZP_ERASE_RESET();
  408. //                return tfsm;
  409. //            } else if (fsm_rt_cpl != tfsm) {
  410. //                break;
  411. //            }
  412. //            s_chState = EZP_ERASE_DEMO;
  413. //   
  414. //            s_chCMDBuffer[0] = EZP_WRDI;   //!< read status command
  415. //     
  416. //        case EZP_ERASE_DEMO:
  417. //            tfsm = send_command(s_chCMDBuffer, 1, NULL, 0 , 0);
  418. //            if (IS_FSM_ERR(tfsm)) {
  419. //                EZP_ERASE_RESET();
  420. //                return tfsm;
  421. //            } else if (fsm_rt_cpl != tfsm) {
  422. //                break;
  423. //            }
  424. //            s_chState = EZP_ERASE_DEMO_A;
  425. //
  426. //
  427. //        case EZP_ERASE_DEMO_A:
  428. //            //static uint8_t s_chTemp;
  429. //            tfsm = read_status(&s_chTemp);
  430. //            if (IS_FSM_ERR(tfsm)) {
  431. //                EZP_ERASE_RESET();
  432. //                return tfsm;
  433. //            } else if (fsm_rt_cpl != tfsm) {
  434. //                break;
  435. //            }
  436. //            s_chState = EZP_ERASE_CHECK_RESULT;

  438.         case EZP_ERASE_CHECK_RESULT:
  439.             tfsm = write_cmd(EZP_WRDI, false);         //!< disable write
  440.             if (IS_FSM_ERR(tfsm)) {
  441.                 EZP_ERASE_RESET();
  442.                 return tfsm;
  443.             } else if (fsm_rt_cpl != tfsm) {
  444.                 break;
  445.             }
  446.             s_bChipErased = true;
  447.             EZP_ERASE_RESET();
  448.             return fsm_rt_cpl;
  449.     }

  451.     return fsm_rt_on_going;
  452. }

  454. #define EZP_READ_START          0
  455. #define EZP_READ_STATUS         1
  456. #define EZP_READ_SND_CMD        2
  457. #define EZP_READ_RESET()        do { s_chStatus = 0; } while(0)

  459. /*! rief read flash through Ezport
  460. *! param wAddress target address
  461. *! param pchStream data buffer
  462. *! param hwSize buffer size
  463. *! eturn fsm status
  464. */
  465. fsm_rt_t ezport_read(uint32_t wAddress, uint8_t *pchStream, uint16_t hwSize)
  466. {
  467.     static uint8_t s_chStatus = 0;
  468.     fsm_rt_t tfsm;
  469.    
  470.     if (0 == hwSize) {
  471.         //! nothing need to read
  472.         return fsm_rt_cpl;
  473.     } else if (NULL == pchStream) {
  474.         //! illegal PTR
  475.         return fsm_rt_err;
  476.     }

  478.     switch (s_chStatus) {
  479.         case EZP_READ_START:
  480.             if (    (wAddress > (((uint32_t)1<<24) - 1))
  481.                 ||  (wAddress & 0x03))  {       //!< the two LSBs must be zero.
  482.                 return fsm_rt_err;
  483.             }
  484.             s_chStatus = EZP_READ_STATUS;

  486.         case EZP_READ_STATUS:
  487.             tfsm = check_status(false);
  488.             if (IS_FSM_ERR(tfsm)) {
  489.                 EZP_READ_RESET();
  490.                 return tfsm;
  491.             } else if (tfsm != fsm_rt_cpl) {
  492.                 //! on going
  493.                 break;
  494.             }
  495.             s_chCMDBuffer[0] = EZP_FAST_READ;   //!< fast read command
  496.             TYPE_CONVERT(&s_chCMDBuffer[1], uint32_t) = wAddress;
  497.             s_chStatus = EZP_READ_SND_CMD;
  498.         
  499.         case EZP_READ_SND_CMD:
  500.             tfsm = send_command(s_chCMDBuffer, 5, pchStream, hwSize, 0);
  501.             if (IS_FSM_ERR(tfsm)) {
  502.                 EZP_READ_RESET();
  503.                 return tfsm;
  504.             } else if (tfsm != fsm_rt_cpl) {
  505.                 break;
  506.             }
  507.             EZP_READ_RESET();
  508.             return fsm_rt_cpl;
  509.     }

  511.     return fsm_rt_on_going;
  512. }

  514. #define EZP_ERASE_SECTOR_START          0
  515. #define EZP_ERASE_SECTOR_CHECK_STATUS   1
  516. #define EZP_ERASE_SECTOR_ERASE          2
  517. #define EZP_ERASE_SECTOR_CHECK_RESULT   3
  518. #define EZP_ERASE_SECTOR_RESET()        do { s_chStatus = 0; } while(0)

  520. /*! rief erase specified sector
  521. *! param wAddress target address
  522. *! eturn fsm status
  523. */
  524. static fsm_rt_t erase_sector(uint32_t wAddress)
  525. {
  526.     static uint8_t s_chStatus = 0;

  528.     fsm_rt_t tfsm;

  530.     switch (s_chStatus) {
  531.         case EZP_ERASE_SECTOR_START:
  532.             tfsm = write_cmd(EZP_WREN, true);         //!< enable write
  533.             if (IS_FSM_ERR(tfsm)) {
  534.                 EZP_ERASE_SECTOR_RESET();
  535.                 return tfsm;
  536.             } else if (fsm_rt_cpl != tfsm) {
  537.                 break;
  538.             }
  539.             
  540.             s_chStatus = EZP_ERASE_SECTOR_CHECK_STATUS;

  542.         case EZP_ERASE_SECTOR_CHECK_STATUS:
  543.             tfsm = check_status(false);              //!< chip erase
  544.             if (IS_FSM_ERR(tfsm)) {
  545.                 EZP_ERASE_SECTOR_RESET();
  546.                 return tfsm;
  547.             } else if (fsm_rt_cpl != tfsm) {
  548.                 break;
  549.             }
  550.             s_chCMDBuffer[0] = EZP_SE;
  551.             TYPE_CONVERT(&s_chCMDBuffer[1], uint32_t) = wAddress & ~0x07;
  552.             s_chStatus = EZP_ERASE_SECTOR_ERASE;
  553.         
  554.         case EZP_ERASE_SECTOR_ERASE:
  555.             tfsm = send_command(s_chCMDBuffer, 4, NULL, 0, 0);
  556.             if (IS_FSM_ERR(tfsm)) {
  557.                 EZP_ERASE_SECTOR_RESET();
  558.                 return tfsm;
  559.             } else if (fsm_rt_cpl != tfsm) {
  560.                 break;
  561.             }
  562.             s_chStatus = EZP_ERASE_SECTOR_CHECK_RESULT;

  564.         case EZP_ERASE_SECTOR_CHECK_RESULT:
  565.             tfsm = write_cmd(EZP_WRDI,true);         //!< disable write
  566.             if (IS_FSM_ERR(tfsm)) {
  567.                 EZP_ERASE_SECTOR_RESET();
  568.                 return tfsm;
  569.             } else if (fsm_rt_cpl != tfsm) {
  570.                 break;
  571.             }
  572.             EZP_ERASE_SECTOR_RESET();
  573.             return fsm_rt_cpl;
  574.     }

  576.     return fsm_rt_on_going;
  577. }

  579. #define EZP_WRITE_START                 0
  580. #define EZP_WRITE_CHECK_CONTENT         1
  581. #define EZP_WRITE_READ_SECTOR           2
  582. #define EZP_WRITE_ERASE_SECTOR          3
  583. #define EZP_WRITE_CHECK_STATUS          4
  584. #define EZP_WRITE_ENABLE_WRITE          5
  585. #define EZP_WRITE_WRITE_SECTOR_CMD      6
  586. #define EZP_WRITE_WRITE_SECTOR_DATA     7
  587. #define EZP_WRITE_VERIFY_SECTOR_DATA    8
  588. #define EZP_WRITE_DISABLE_WRITE         9
  589. #define EZP_WRITE_RESET()               do { s_chStatus = 0; } while(0)

  591. /*! rief read flash through Ezport
  592. *! param wAddress target address
  593. *! param pchStream data buffer
  594. *! param hwSize buffer size
  595. *! eturn fsm status
  596. */
  597. fsm_rt_t ezport_write(uint32_t wAddress, uint8_t *pchStream, uint16_t hwSize)
  598. {
  599.     static uint8_t s_chStatus = 0;
  600.     NO_INIT static uint32_t s_wAddress;
  601.     NO_INIT static uint32_t s_wSectorAddress;
  602.     NO_INIT static uint16_t s_hwSize;
  603.     NO_INIT static uint8_t  *s_pchSrc;
  604.     NO_INIT static uint8_t  *s_pchVerify;
  605.     NO_INIT static uint16_t s_hwLength;
  606.     NO_INIT static uint8_t s_chSectorBuffer[EZP_FLASH_SECTOR_SIZE];

  608.     fsm_rt_t tfsm;

  610.     if (0 == hwSize) {
  611.         return fsm_rt_cpl;
  612.     } else if (NULL == pchStream) {
  613.         return fsm_rt_err;
  614.     }

  616.     switch (s_chStatus) {
  617.         case EZP_WRITE_START:
  618.             if (    (wAddress > (((uint32_t)1<<24) - 1))
  619.                 ||  (wAddress & 0x07))  {       //!< the three LSBs must be zero.
  620.                 return fsm_rt_err;
  621.             }
  622.             
  623.             s_wAddress = wAddress;
  624.             s_hwSize = hwSize;
  625.             s_pchSrc = pchStream;
  626.             s_pchVerify = pchStream;
  627.             s_chStatus = EZP_WRITE_CHECK_CONTENT;

  629.         
  630.         case EZP_WRITE_CHECK_CONTENT:
  631.             tfsm = check_status(false);
  632.             if (IS_FSM_ERR(tfsm)) {
  633.                 EZP_WRITE_RESET();
  634.                 return tfsm;
  635.             } else if (fsm_rt_cpl != tfsm) {
  636.                 break;
  637.             }

  639.             if (!s_hwSize) {
  640.                 //! all data has been written
  641.                 s_chStatus = EZP_WRITE_DISABLE_WRITE;
  642.                 break;
  643.             }
  644.             s_wSectorAddress = s_wAddress & ~(EZP_FLASH_SECTOR_SIZE - 1);
  645.             s_chStatus = EZP_WRITE_READ_SECTOR;

  647. //            do {
  648. //                uint_fast16_t hwLength = sizeof(s_chSectorBuffer);
  649. //                uint8_t *pchSrc = s_chSectorBuffer;
  650. //                do {
  651. //                    *pchSrc++ = 0;
  652. //                } while(--hwLength);
  653. //            } while (false);


  656.         case EZP_WRITE_READ_SECTOR:
  657.             //! read block
  658.             tfsm = ezport_read(
  659.                 s_wSectorAddress, s_chSectorBuffer, sizeof(s_chSectorBuffer));
  660.             if (IS_FSM_ERR(tfsm)) {
  661.                 EZP_WRITE_RESET();
  662.                 return tfsm;
  663.             } else if (fsm_rt_cpl != tfsm) {
  664.                 break;
  665.             }
  666.             
  667.             //! fill sector
  668.             do {
  669.                 uint_fast16_t hwStart = s_wAddress & (EZP_FLASH_SECTOR_SIZE - 1);
  670.                 uint_fast16_t hwLength;
  671.                 s_hwLength = sizeof(s_chSectorBuffer) - hwStart;
  672.                 uint8_t *pchDes = s_chSectorBuffer + hwStart;
  673.                 s_hwLength = MIN(s_hwLength, s_hwSize);
  674.                 hwLength = s_hwLength;
  675.                 do {
  676.                     *pchDes++ = *s_pchSrc++;
  677.                 } while (--hwLength);
  678.             } while (false);

  680. //            if (s_bChipErased) {
  681. //                s_chStatus =  EZP_WRITE_CHECK_STATUS;
  682. //            } else {
  683. //                s_chStatus = EZP_WRITE_ERASE_SECTOR;
  684. //            }
  685.             s_chStatus = EZP_WRITE_ERASE_SECTOR;
  686.             break;                              

  688.         case EZP_WRITE_ERASE_SECTOR:
  689.             tfsm = erase_sector(s_wSectorAddress);
  690.             if (IS_FSM_ERR(tfsm)) {
  691.                 EZP_WRITE_RESET();
  692.                 return tfsm;
  693.             } else if (fsm_rt_cpl != tfsm) {
  694.                 break;
  695.             }
  696.             //! check status
  697.             s_chStatus =  EZP_WRITE_CHECK_STATUS;

  699.         case EZP_WRITE_CHECK_STATUS:
  700.             tfsm = check_status(false);
  701.             if (IS_FSM_ERR(tfsm)) {
  702.                 EZP_WRITE_RESET();
  703.                 return tfsm;
  704.             } else if (fsm_rt_cpl != tfsm) {
  705.                 break;
  706.             }
  707.             //! transfer to next state
  708.             s_chStatus = EZP_WRITE_ENABLE_WRITE;

  710.         case EZP_WRITE_ENABLE_WRITE:
  711.             tfsm = write_cmd(EZP_WREN,false);         //!< enable write
  712.             if (IS_FSM_ERR(tfsm)) {
  713.                 EZP_WRITE_RESET();
  714.                 return tfsm;
  715.             } else if (fsm_rt_cpl != tfsm) {
  716.                 break;
  717.             }
  718.             //!< program flash command
  719.             s_chCMDBuffer[0] = EZP_SP;         
  720.             TYPE_CONVERT(&s_chCMDBuffer[1], uint32_t) = s_wSectorAddress;

  722.             s_chStatus = EZP_WRITE_WRITE_SECTOR_CMD;

  724.         case EZP_WRITE_WRITE_SECTOR_CMD:
  725.             //!< write command, disable EZP_CS signal negation
  726.             tfsm = send_command(s_chCMDBuffer, 4, NULL, 0, _BV(1));
  727.             if (IS_FSM_ERR(tfsm)) {
  728.                 EZP_WRITE_RESET();
  729.                 return tfsm;
  730.             } else if (fsm_rt_cpl != tfsm) {
  731.                 break;
  732.             }
  733.             s_chStatus = EZP_WRITE_WRITE_SECTOR_DATA;

  735.         case EZP_WRITE_WRITE_SECTOR_DATA:
  736.             //! write data, disable EZP_CS signal assertion
  737.             tfsm = send_command(s_chSectorBuffer, sizeof(s_chSectorBuffer), NULL, 0, _BV(0));
  738.             if (IS_FSM_ERR(tfsm)) {
  739.                 EZP_WRITE_RESET();
  740.                 return tfsm;
  741.             } else if (fsm_rt_cpl != tfsm) {
  742.                 break;
  743.             }
  744. //            do {
  745. //                uint_fast16_t hwLength = sizeof(s_chSectorBuffer);
  746. //                uint8_t *pchSrc = s_chSectorBuffer;
  747. //                do {
  748. //                    *pchSrc++ = 0;
  749. //                } while(--hwLength);
  750. //            } while (false);
  751.             s_chStatus = EZP_WRITE_VERIFY_SECTOR_DATA;
  752.             break;

  754.         case EZP_WRITE_VERIFY_SECTOR_DATA:
  755.             //! verify data
  756.             tfsm = ezport_read(
  757.                 s_wSectorAddress, s_chSectorBuffer, sizeof(s_chSectorBuffer));
  758.             if (IS_FSM_ERR(tfsm)) {
  759.                 EZP_WRITE_RESET();
  760.                 return tfsm;
  761.             } else if (fsm_rt_cpl != tfsm) {
  762.                 break;
  763.             }
  764.             //! fill sector
  765.             do {
  766.                 uint_fast16_t hwStart = s_wAddress & (EZP_FLASH_SECTOR_SIZE - 1);
  767.                 uint_fast16_t hwLength = s_hwLength;
  768.                 s_hwSize -= hwLength;           //!< update size
  769.                 s_wAddress += hwLength;         //!< update address
  770.                 uint8_t *pchDes = s_chSectorBuffer + hwStart;
  771.                 do {
  772.                     if (*pchDes++ != *s_pchVerify++) {
  773.                         EZP_WRITE_RESET();
  774.                         return fsm_rt_err;
  775.                     }
  776.                 } while (--hwLength);
  777.             } while (false);
  778.             s_chStatus = EZP_WRITE_CHECK_CONTENT;

  780.         case EZP_WRITE_DISABLE_WRITE:
  781.             tfsm = write_cmd(EZP_WRDI,true);         //!< disable write
  782.             if (IS_FSM_ERR(tfsm)) {
  783.                 EZP_WRITE_RESET();
  784.                 return tfsm;
  785.             } else if (fsm_rt_cpl != tfsm) {
  786.                 break;
  787.             }
  788.             EZP_WRITE_RESET();
  789.             return fsm_rt_cpl;
  790.     }
  791.    
  792.     return fsm_rt_on_going;
  793. }

  795. #endif
  796.   
  797. /* EOF */
复制代码
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
19条回答
sblpp
2020-02-12 20:32
 精彩回答 2  元偷偷看……0人看过

一周热门 更多>