| PDL for FM0+ Version1.0 Peripheral Driverl Library for FM0+

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

C:/pdl_v10/library/utility/s25fl127s/csio_int_s25fl127s.c
Go to the documentation of this file.

    00001 /*******************************************************************************
    00002 * Copyright (C) 2013 Spansion LLC. All Rights Reserved.
    00003 *
    00004 * This software is owned and published by:
    00005 * Spansion LLC, 915 DeGuigne Dr. Sunnyvale, CA  94088-3453 ("Spansion").
    00006 *
    00007 * BY DOWNLOADING, INSTALLING OR USING THIS SOFTWARE, YOU AGREE TO BE BOUND
    00008 * BY ALL THE TERMS AND CONDITIONS OF THIS AGREEMENT.
    00009 *
    00010 * This software contains source code for use with Spansion
    00011 * components. This software is licensed by Spansion to be adapted only
    00012 * for use in systems utilizing Spansion components. Spansion shall not be
    00013 * responsible for misuse or illegal use of this software for devices not
    00014 * supported herein.  Spansion is providing this software "AS IS" and will
    00015 * not be responsible for issues arising from incorrect user implementation
    00016 * of the software.
    00017 *
    00018 * SPANSION MAKES NO WARRANTY, EXPRESS OR IMPLIED, ARISING BY LAW OR OTHERWISE,
    00019 * REGARDING THE SOFTWARE (INCLUDING ANY ACOOMPANYING WRITTEN MATERIALS),
    00020 * ITS PERFORMANCE OR SUITABILITY FOR YOUR INTENDED USE, INCLUDING,
    00021 * WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, THE IMPLIED
    00022 * WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE OR USE, AND THE IMPLIED
    00023 * WARRANTY OF NONINFRINGEMENT.
    00024 * SPANSION SHALL HAVE NO LIABILITY (WHETHER IN CONTRACT, WARRANTY, TORT,
    00025 * NEGLIGENCE OR OTHERWISE) FOR ANY DAMAGES WHATSOEVER (INCLUDING, WITHOUT
    00026 * LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION,
    00027 * LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) ARISING FROM USE OR
    00028 * INABILITY TO USE THE SOFTWARE, INCLUDING, WITHOUT LIMITATION, ANY DIRECT,
    00029 * INDIRECT, INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOSS OF DATA,
    00030 * SAVINGS OR PROFITS,
    00031 * EVEN IF SPANSION HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
    00032 * YOU ASSUME ALL RESPONSIBILITIES FOR SELECTION OF THE SOFTWARE TO ACHIEVE YOUR
    00033 * INTENDED RESULTS, AND FOR THE INSTALLATION OF, USE OF, AND RESULTS OBTAINED
    00034 * FROM, THE SOFTWARE.
    00035 *
    00036 * This software may be replicated in part or whole for the licensed use,
    00037 * with the restriction that this Disclaimer and Copyright notice must be
    00038 * included with each copy of this software, whether used in part or whole,
    00039 * at all times.
    00040 */
    00041 /******************************************************************************/
    00052 /******************************************************************************/
    00053 /* Include files                                                              */
    00054 /******************************************************************************/
    00055 #include "csio_int_s25fl127s.h"
    00056
    00057 #if (PDL_UTILITY_ENABLE_CSIO_INT_S25FL127S == PDL_ON)
    00058
    00059 /*****************************************************************************/
    00060 /* Local pre-processor symbols/macros ('#define')                            */
    00061 /*****************************************************************************/
    00062 /*****************************************************************************/
    00063 /* Global variable definitions (declared in header file with 'extern')       */
    00064 /*****************************************************************************/
    00065 /*****************************************************************************/
    00066 /* Local type definitions ('typedef')                                        */
    00067 /*****************************************************************************/
    00072 typedef enum en_flash_cmd
    00073 {
    00074     CmdReadId           = 0x90u,
    00075     CmdReadStatusReg1   = 0x05u,
    00076     CmdWriteEnable      = 0x06u,
    00077     CmdWriteDisable     = 0x04u,
    00078     CmdBulkErase        = 0x60u,
    00079     Cmd4kSectorErase    = 0x20u,
    00080     CmdSectorErase      = 0xD8u,
    00081     CmdPagePgm          = 0x02u,
    00082     CmdRead             = 0x03u,
    00083     CmdFastRead         = 0x0Bu,
    00084
    00085 }en_flash_cmd_t;
    00086
    00091 typedef struct stc_csio_info
    00092 {
    00093     uint8_t*  pu8TxData;
    00094     uint32_t  u8TxSize;
    00095     uint8_t*  pu8RxData;
    00096     uint32_t  u8RxSize;
    00097     uint32_t  u32Cnt;
    00098     boolean_t bTxFinish;
    00099     boolean_t bRxFinish;
    00100     boolean_t bRwSyncFlag;
    00101
    00102 }stc_csio_info_t;
    00103
    00104 /*****************************************************************************/
    00105 /* Local function prototypes ('static')                                      */
    00106 /*****************************************************************************/
    00107 static void Delay(uint32_t u32Cnt);
    00108 static void CsioMasterTxIntCallback(void);
    00109 static void CsioMasterRxIntCallback(void);
    00110 static en_result_t CsioTxData(uint8_t u8Cmd,    uint8_t u8CmdSize,
    00111                               uint32_t u32Addr,  uint8_t u8AddrSize,
    00112                               uint8_t* pu8Data, uint32_t u32DataSize);
    00113 static en_result_t CsioRxData(uint8_t u8Cmd,    uint8_t u8CmdSize,
    00114                               uint32_t u32Addr,  uint8_t u8AddrSize,
    00115                               uint8_t* pu8Data, uint32_t u32DataSize);
    00116 static en_result_t CsioRxReg(uint8_t u8Cmd,      uint8_t u8CmdSize,
    00117                              uint8_t* pRegValue, uint8_t u8RegSize);
    00118 static en_result_t CsioTxCmd(uint8_t u8Cmd,      uint8_t u8CmdSize);
    00119 static en_result_t CsioTxCmdAddr(uint8_t u8Cmd,      uint8_t u8CmdSize,
    00120                                  uint32_t u32Addr,   uint8_t u8AddrSize);
    00121
    00122
    00123 /*****************************************************************************/
    00124 /* Local variable definitions ('static')                                     */
    00125 /*****************************************************************************/
    00126 stc_csio_int_sel_t stcCsio1IntSel;
    00127 stc_csio_int_cb_t stcCsio1IntCb;
    00128 stc_csio_info_t stcCsioInfo;
    00129
    00134 static void Delay(uint32_t u32Cnt)
    00135 {
    00136     while(u32Cnt--);
    00137 }
    00138
    00143 static void CsioMasterTxIntCallback(void)
    00144 {
    00145     if(stcCsioInfo.u32Cnt >= stcCsioInfo.u8TxSize)
    00146     {
    00147         /* Disable interrupt */
    00148         PDL_ZERO_STRUCT(stcCsio1IntSel);
    00149         stcCsio1IntSel.bTxInt = TRUE;
    00150         Mfs_Csio_DisableInt(FLASH_CSIO_CH, &stcCsio1IntSel);
    00151
    00152         stcCsioInfo.bTxFinish = TRUE;
    00153
    00154         return;
    00155     }
    00156
    00157     Mfs_Csio_SendData(FLASH_CSIO_CH, *stcCsioInfo.pu8TxData, TRUE);
    00158     stcCsioInfo.u32Cnt++;
    00159     stcCsioInfo.pu8TxData++;
    00160
    00161     stcCsioInfo.bRwSyncFlag = FALSE;
    00162 }
    00163
    00164
    00169 static void CsioMasterRxIntCallback(void)
    00170 {
    00171     *stcCsioInfo.pu8RxData = Mfs_Csio_ReceiveData(FLASH_CSIO_CH);
    00172
    00173     stcCsioInfo.u32Cnt++;
    00174     stcCsioInfo.pu8RxData++;
    00175
    00176     stcCsioInfo.bRwSyncFlag = TRUE;
    00177
    00178     if(stcCsioInfo.u32Cnt >= stcCsioInfo.u8RxSize)
    00179     {
    00180         /* Disable interrupt */
    00181         PDL_ZERO_STRUCT(stcCsio1IntSel);
    00182         stcCsio1IntSel.bRxInt = TRUE;
    00183         Mfs_Csio_DisableInt(FLASH_CSIO_CH, &stcCsio1IntSel);
    00184
    00185         stcCsioInfo.bRxFinish = TRUE;
    00186
    00187         return;
    00188     }
    00189 }
    00190
    00204 static en_result_t CsioTxData(uint8_t u8Cmd,    uint8_t u8CmdSize,
    00205                               uint32_t u32Addr,  uint8_t u8AddrSize,
    00206                               uint8_t* pu8Data, uint32_t u32DataSize)
    00207 {
    00208     uint8_t u8Times = 0, u8Offset = 0;
    00209     uint8_t u8i;
    00210
    00211     /* Enable TX function of CSIO1   */
    00212     Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioTx);
    00213
    00214     Mfs_Csio_SetCsHoldStatus(FLASH_CSIO_CH, TRUE);
    00215     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8CmdSize);
    00216
    00217     /* Send command */
    00218     stcCsioInfo.pu8TxData = &u8Cmd;
    00219     stcCsioInfo.u8TxSize = u8CmdSize;
    00220     stcCsioInfo.u32Cnt = 0;
    00221     stcCsioInfo.bTxFinish = FALSE;
    00222
    00223     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00224     stcCsio1IntSel.bTxInt = TRUE;
    00225     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00226     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00227
    00228     /* Wait until receive finish */
    00229     while(stcCsioInfo.bTxFinish != TRUE)
    00230     {
    00231         ;
    00232     }
    00233
    00234     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8AddrSize);
    00235
    00236     /* Send address */
    00237     stcCsioInfo.pu8TxData = (uint8_t*)&u32Addr;
    00238     stcCsioInfo.u8TxSize = u8AddrSize;
    00239     stcCsioInfo.u32Cnt = 0;
    00240     stcCsioInfo.bTxFinish = FALSE;
    00241
    00242     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00243     stcCsio1IntSel.bTxInt = TRUE;
    00244     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00245     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00246
    00247     /* Wait until receive finish */
    00248     while(stcCsioInfo.bTxFinish != TRUE)
    00249     {
    00250         ;
    00251     }
    00252
    00253     /* Send data */
    00254     u8Times = u32DataSize/255u;
    00255     u8Offset = u32DataSize%255u;
    00256     u8i = 0;
    00257
    00258     if(u8Times > 0)
    00259     {
    00260         while(u8i != u8Times)
    00261         {
    00262             Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, 255u);
    00263
    00264             stcCsioInfo.pu8TxData = pu8Data + 255u*u8i;
    00265             stcCsioInfo.u8TxSize = 255u;
    00266             stcCsioInfo.u32Cnt = 0;
    00267             stcCsioInfo.bTxFinish = FALSE;
    00268
    00269             PDL_ZERO_STRUCT(stcCsio1IntSel);
    00270             stcCsio1IntSel.bTxInt = TRUE;
    00271             stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00272             Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00273
    00274             /* Wait until receive finish */
    00275             while(stcCsioInfo.bTxFinish != TRUE)
    00276             {
    00277                 ;
    00278             }
    00279
    00280             u8i++;
    00281         }
    00282     }
    00283
    00284     if(u8Offset > 0)
    00285     {
    00286         Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8Offset);
    00287
    00288         stcCsioInfo.pu8TxData = pu8Data + 255u*u8i;
    00289         stcCsioInfo.u8TxSize = u8Offset;
    00290         stcCsioInfo.u32Cnt = 0;
    00291         stcCsioInfo.bTxFinish = FALSE;
    00292
    00293         PDL_ZERO_STRUCT(stcCsio1IntSel);
    00294         stcCsio1IntSel.bTxInt = TRUE;
    00295         stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00296         Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00297
    00298         /* Wait until receive finish */
    00299         while(stcCsioInfo.bTxFinish != TRUE)
    00300         {
    00301             ;
    00302         }
    00303     }
    00304
    00305     Mfs_Csio_SetCsHoldStatus(FLASH_CSIO_CH, FALSE);
    00306     while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxIdle));
    00307
    00308     /* Disable TX function of CSIO0   */
    00309     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioTx);
    00310
    00311     return Ok;
    00312 }
    00313
    00327 static en_result_t CsioRxData(uint8_t u8Cmd,    uint8_t u8CmdSize,
    00328                               uint32_t u32Addr,  uint8_t u8AddrSize,
    00329                               uint8_t* pu8Data, uint32_t u32DataSize)
    00330 {
    00331     uint8_t u8Times = 0, u8Offset = 0;
    00332     uint8_t u8i,u8j;
    00333
    00334     /* Enable TX function of CSIO1   */
    00335     Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioTx);
    00336
    00337     Mfs_Csio_SetCsHoldStatus(FLASH_CSIO_CH, TRUE);
    00338     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8CmdSize);
    00339
    00340     /* Send command */
    00341     stcCsioInfo.pu8TxData = &u8Cmd;
    00342     stcCsioInfo.u8TxSize = u8CmdSize;
    00343     stcCsioInfo.bTxFinish = FALSE;
    00344     stcCsioInfo.u32Cnt = 0;
    00345
    00346     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00347     stcCsio1IntSel.bTxInt = TRUE;
    00348     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00349     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00350
    00351     /* Wait until send finish */
    00352     while(stcCsioInfo.bTxFinish != TRUE)
    00353     {
    00354         ;
    00355     }
    00356
    00357     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8AddrSize);
    00358     /* Send address */
    00359     stcCsioInfo.pu8TxData = (uint8_t*)&u32Addr;
    00360     stcCsioInfo.u8TxSize = u8AddrSize;
    00361     stcCsioInfo.bTxFinish = FALSE;
    00362     stcCsioInfo.u32Cnt = 0;
    00363
    00364     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00365     stcCsio1IntSel.bTxInt = TRUE;
    00366     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00367     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00368
    00369     /* Wait until send finish */
    00370     while(stcCsioInfo.bTxFinish != TRUE)
    00371     {
    00372         ;
    00373     }
    00374
    00375     Delay(100);
    00376
    00377     /* Read data */
    00378     u8Times = u32DataSize/255u;
    00379     u8Offset = u32DataSize%255u;
    00380     u8i = 0;
    00381
    00382     if(u8Times > 0)
    00383     {
    00384         while(u8i < u8Times)
    00385         {
    00386             stcCsioInfo.pu8RxData = pu8Data + 255*u8i;
    00387             stcCsioInfo.u8RxSize = 255u;
    00388             stcCsioInfo.bRxFinish = FALSE;
    00389             stcCsioInfo.u32Cnt = 0;
    00390
    00391             Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioRx);
    00392
    00393             Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, 255u);
    00394
    00395             PDL_ZERO_STRUCT(stcCsio1IntSel);
    00396             stcCsio1IntSel.bRxInt = TRUE;
    00397             stcCsio1IntCb.pfnRxIntCb = CsioMasterRxIntCallback;
    00398             Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00399
    00400              /* Send dummy data and wait until receive finish */
    00401             u8j = 255u;
    00402             while(u8j--)
    00403             {
    00404                 while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxEmpty));
    00405                 Mfs_Csio_SendData(FLASH_CSIO_CH, 0x00u, FALSE);   /* Dummy write */
    00406             }
    00407
    00408             while(stcCsioInfo.bRxFinish != TRUE)
    00409             {
    00410                 ;
    00411             }
    00412
    00413             u8i++;
    00414         }
    00415     }
    00416
    00417     if(u8Offset > 0)
    00418     {
    00419         stcCsioInfo.pu8RxData = pu8Data + 255*u8i;
    00420         stcCsioInfo.u8RxSize = u8Offset;
    00421         stcCsioInfo.bRxFinish = FALSE;
    00422         stcCsioInfo.u32Cnt = 0;
    00423
    00424         Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioRx);
    00425
    00426         Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8Offset);
    00427
    00428         PDL_ZERO_STRUCT(stcCsio1IntSel);
    00429         stcCsio1IntSel.bRxInt = TRUE;
    00430         stcCsio1IntCb.pfnRxIntCb = CsioMasterRxIntCallback;
    00431         Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00432
    00433          /* Send dummy data and wait until receive finish */
    00434         u8j = u8Offset;
    00435         while(u8j--)
    00436         {
    00437             while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxEmpty));
    00438             Mfs_Csio_SendData(FLASH_CSIO_CH, 0x00u, FALSE);   /* Dummy write */
    00439         }
    00440
    00441         while(stcCsioInfo.bRxFinish != TRUE)
    00442         {
    00443             ;
    00444         }
    00445
    00446     }
    00447
    00448     Mfs_Csio_SetCsHoldStatus(FLASH_CSIO_CH, FALSE);
    00449     while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxIdle));
    00450
    00451     /* Disable TX function of CSIO0   */
    00452     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioTx);
    00453     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioRx);
    00454
    00455     return Ok;
    00456 }
    00457
    00469 static en_result_t CsioRxReg(uint8_t u8Cmd,      uint8_t u8CmdSize,
    00470                              uint8_t* pRegValue, uint8_t u8RegSize)
    00471 {
    00472     /* Enable TX function of CSIO1   */
    00473     Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioTx);
    00474
    00475     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, (u8CmdSize+u8RegSize));
    00476
    00477     /* Send command */
    00478     stcCsioInfo.pu8TxData = &u8Cmd;
    00479     stcCsioInfo.u8TxSize = u8CmdSize;
    00480     stcCsioInfo.bTxFinish = FALSE;
    00481     stcCsioInfo.u32Cnt = 0;
    00482
    00483     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00484     stcCsio1IntSel.bTxInt = TRUE;
    00485     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00486     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00487
    00488     /* Wait until send finish */
    00489     while(stcCsioInfo.bTxFinish != TRUE)
    00490     {
    00491         ;
    00492     }
    00493
    00494     /* Read data */
    00495     stcCsioInfo.pu8RxData = pRegValue;
    00496     stcCsioInfo.u8RxSize = u8RegSize;
    00497     stcCsioInfo.bRxFinish = FALSE;
    00498     stcCsioInfo.u32Cnt = 0;
    00499
    00500     Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioRx);
    00501
    00502     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00503     stcCsio1IntSel.bRxInt = TRUE;
    00504     stcCsio1IntCb.pfnRxIntCb = CsioMasterRxIntCallback;
    00505     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00506
    00507      /* Send dummy data and wait until receive finish */
    00508     while(u8RegSize--)
    00509     {
    00510         while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxEmpty));
    00511         Mfs_Csio_SendData(FLASH_CSIO_CH, 0x00u, FALSE);   /* Dummy write */
    00512     }
    00513
    00514     while(stcCsioInfo.bRxFinish != TRUE)
    00515     {
    00516         ;
    00517     }
    00518
    00519     /* Disable TX function of CSIO0   */
    00520     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioTx);
    00521     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioRx);
    00522
    00523     return Ok;
    00524 }
    00525
    00535 static en_result_t CsioTxCmd(uint8_t u8Cmd,      uint8_t u8CmdSize)
    00536 {
    00537     /* Enable TX function of CSIO1   */
    00538     Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioTx);
    00539
    00540     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, u8CmdSize);
    00541
    00542     /* Send command */
    00543     stcCsioInfo.pu8TxData = &u8Cmd;
    00544     stcCsioInfo.u8TxSize = u8CmdSize;
    00545     stcCsioInfo.bTxFinish = FALSE;
    00546     stcCsioInfo.u32Cnt = 0;
    00547
    00548     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00549     stcCsio1IntSel.bTxInt = TRUE;
    00550     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00551     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00552
    00553     /* Wait until send finish */
    00554     while(stcCsioInfo.bTxFinish != TRUE)
    00555     {
    00556         ;
    00557     }
    00558
    00559     while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxIdle));
    00560
    00561     /* Disable TX function of CSIO0   */
    00562     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioTx);
    00563
    00564     return Ok;
    00565 }
    00566
    00578 static en_result_t CsioTxCmdAddr(uint8_t u8Cmd,      uint8_t u8CmdSize,
    00579                                  uint32_t u32Addr,   uint8_t u8AddrSize)
    00580 {
    00581     /* Enable TX function of CSIO1   */
    00582     Mfs_Csio_EnableFunc(FLASH_CSIO_CH, CsioTx);
    00583
    00584     Mfs_Csio_SetCsTransferByteCount(FLASH_CSIO_CH, CsPinScs0, (u8CmdSize+u8AddrSize));
    00585
    00586     /* Send command */
    00587     stcCsioInfo.pu8TxData = &u8Cmd;
    00588     stcCsioInfo.u8TxSize = u8CmdSize;
    00589     stcCsioInfo.bTxFinish = FALSE;
    00590     stcCsioInfo.u32Cnt = 0;
    00591
    00592     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00593     stcCsio1IntSel.bTxInt = TRUE;
    00594     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00595     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00596
    00597     /* Wait until send finish */
    00598     while(stcCsioInfo.bTxFinish != TRUE)
    00599     {
    00600         ;
    00601     }
    00602
    00603     /* Send address */
    00604     stcCsioInfo.pu8TxData = (uint8_t*)&u32Addr;
    00605     stcCsioInfo.u8TxSize = u8AddrSize;
    00606     stcCsioInfo.bTxFinish = FALSE;
    00607     stcCsioInfo.u32Cnt = 0;
    00608
    00609     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00610     stcCsio1IntSel.bTxInt = TRUE;
    00611     stcCsio1IntCb.pfnTxIntCb = CsioMasterTxIntCallback;
    00612     Mfs_Csio_EnableInt(FLASH_CSIO_CH, &stcCsio1IntSel, &stcCsio1IntCb);
    00613
    00614     /* Wait until send finish */
    00615     while(stcCsioInfo.bTxFinish != TRUE)
    00616     {
    00617         ;
    00618     }
    00619
    00620     while(TRUE != Mfs_Csio_GetStatus(FLASH_CSIO_CH, CsioTxIdle));
    00621
    00622     /* Disable TX function of CSIO0   */
    00623     Mfs_Csio_DisableFunc(FLASH_CSIO_CH, CsioTx);
    00624
    00625     return Ok;
    00626 }
    00627
    00632 en_result_t S25fl127s_Init(void)
    00633 {
    00634     stc_mfs_csio_config_t stcCsio1Config;
    00635
    00636     /* Clear configuration structure */
    00637     PDL_ZERO_STRUCT(stcCsio1Config);
    00638     PDL_ZERO_STRUCT(stcCsio1IntSel);
    00639     PDL_ZERO_STRUCT(stcCsio1IntCb);
    00640
    00641     /* Initialize CSIO function I/O */
    00642     InitCsioIo();
    00643
    00644     /* Initialize CSIO master  */
    00645     stcCsio1Config.enMsMode = CsioMaster;
    00646     stcCsio1Config.enActMode = CsioActNormalMode;
    00647     stcCsio1Config.bInvertClk = FALSE;
    00648     stcCsio1Config.u32BaudRate = 500000;
    00649     stcCsio1Config.enDataLength = CsioEightBits;
    00650     stcCsio1Config.enBitDirection = CsioDataMsbFirst;
    00651     stcCsio1Config.enSyncWaitTime = CsioSyncWaitZero;
    00652     stcCsio1Config.bEnableFifo = FALSE;
    00653
    00654     stcCsio1Config.bEnChipSelection = TRUE;
    00655     stcCsio1Config.stcCsConfig.enCsStartPin = CsPinScs0;
    00656     stcCsio1Config.stcCsConfig.enCsEndPin = CsPinScs0;
    00657     stcCsio1Config.stcCsConfig.enClkDiv = CsClkNoDiv;
    00658     stcCsio1Config.stcCsConfig.bActiveHold = FALSE;
    00659     stcCsio1Config.stcCsConfig.enLevel = CsLowActive;
    00660     stcCsio1Config.stcCsConfig.u8CsSetupDelayTime = 200u;
    00661     stcCsio1Config.stcCsConfig.u8CsHoldDelayTime = 200u;
    00662     stcCsio1Config.stcCsConfig.u16CsDeselectTime = 2000u;
    00663     stcCsio1Config.stcCsConfig.u8Scs0TransferByteCnt = 0;
    00664     stcCsio1Config.stcCsConfig.u8Scs1TransferByteCnt = 0;
    00665     stcCsio1Config.stcCsConfig.u8Scs2TransferByteCnt = 0;
    00666     stcCsio1Config.stcCsConfig.u8Scs3TransferByteCnt = 0;
    00667     stcCsio1Config.stcCsConfig.bScs0En = TRUE;
    00668     stcCsio1Config.stcCsConfig.bScs1En = FALSE;
    00669     stcCsio1Config.stcCsConfig.bScs2En = FALSE;
    00670     stcCsio1Config.stcCsConfig.bScs3En = FALSE;
    00671
    00672     stcCsio1Config.bEnSyncTransfer = FALSE;
    00673
    00674     if(Ok != Mfs_Csio_Init(FLASH_CSIO_CH, &stcCsio1Config))
    00675     {
    00676         return Error;
    00677     }
    00678
    00679     return Ok;
    00680 }
    00681
    00682
    00692 en_result_t S25fl127s_ReadId(uint8_t* pManufactureId, uint8_t* pDeviceId)
    00693 {
    00694     uint8_t u8RxData[2];
    00695
    00696     CsioRxData(CmdReadId, 1, 0x000000u, 3, u8RxData, 2);
    00697
    00698     *pManufactureId = u8RxData[0];
    00699     *pDeviceId = u8RxData[1];
    00700
    00701     return Ok;
    00702 }
    00703
    00711 en_result_t S25fl127s_BulkErase(void)
    00712 {
    00713     uint8_t u8Status;
    00714     boolean_t bError = FALSE;
    00715
    00716     CsioTxCmd(CmdWriteEnable, 1);
    00717
    00718     CsioTxCmd(CmdBulkErase, 1);
    00719
    00720     while(1)
    00721     {
    00722         CsioRxReg(CmdReadStatusReg1, 1, &u8Status, 1);
    00723
    00724         if((u8Status & 0x40u) == 0x40u)
    00725         {
    00726             bError = TRUE;
    00727             break;
    00728         }
    00729
    00730         if((u8Status & 0x01u) == 0x00u) /* Wait until write finish */
    00731         {
    00732             break;
    00733         }
    00734     }
    00735
    00736     CsioTxCmd(CmdWriteDisable, 1);
    00737
    00738     if(bError == TRUE)
    00739     {
    00740         return Error;
    00741     }
    00742
    00743     return Ok;
    00744 }
    00745
    00755 en_result_t S25fl127s_4kSectorErase(uint32_t u32Addr)
    00756 {
    00757     uint8_t u8Status;
    00758     boolean_t bError = FALSE;
    00759
    00760     CsioTxCmd(CmdWriteEnable, 1);
    00761
    00762     CsioTxCmdAddr(Cmd4kSectorErase, 1, u32Addr, 3);
    00763
    00764     while(1)
    00765     {
    00766         CsioRxReg(CmdReadStatusReg1, 1, &u8Status, 1);
    00767
    00768         if((u8Status & 0x40u) == 0x40u)
    00769         {
    00770             bError = TRUE;
    00771             break;
    00772         }
    00773
    00774         if((u8Status & 0x01u) == 0x00u) /* Wait until write finish */
    00775         {
    00776             break;
    00777         }
    00778     }
    00779
    00780     CsioTxCmd(CmdWriteDisable, 1);
    00781
    00782     if(bError == TRUE)
    00783     {
    00784         return Error;
    00785     }
    00786
    00787     return Ok;
    00788 }
    00789
    00799 en_result_t S25fl127s_SectorErase(uint32_t u32Addr)
    00800 {
    00801     uint8_t u8Status;
    00802     boolean_t bError = FALSE;
    00803
    00804     CsioTxCmd(CmdWriteEnable, 1);
    00805
    00806     CsioTxCmdAddr(CmdSectorErase, 1, u32Addr, 3);
    00807
    00808     while(1)
    00809     {
    00810         CsioRxReg(CmdReadStatusReg1, 1, &u8Status, 1);
    00811
    00812         if((u8Status & 0x40u) == 0x40u)
    00813         {
    00814             bError = TRUE;
    00815             break;
    00816         }
    00817
    00818         if((u8Status & 0x01u) == 0x00u) /* Wait until write finish */
    00819         {
    00820             break;
    00821         }
    00822     }
    00823
    00824     CsioTxCmd(CmdWriteDisable, 1);
    00825
    00826     if(bError == TRUE)
    00827     {
    00828         return Error;
    00829     }
    00830
    00831     return Ok;
    00832 }
    00833
    00851 en_result_t S25fl127s_PageProgram(uint32_t u32Addr, uint8_t* pu8Data, uint16_t u16Size)
    00852 {
    00853     uint8_t u8Status;
    00854     boolean_t bError = FALSE;
    00855
    00856     if((u16Size > S25FL127S_DEFAULT_PAGE_SIZE) || (pu8Data == NULL))
    00857     {
    00858         return ErrorInvalidParameter;
    00859     }
    00860
    00861     CsioTxCmd(CmdWriteEnable, 1);
    00862     CsioTxData(CmdPagePgm, 1, u32Addr, 3, pu8Data, u16Size);
    00863
    00864     while(1)
    00865     {
    00866         CsioRxReg(CmdReadStatusReg1, 1, &u8Status, 1);
    00867
    00868         if((u8Status & 0x40u) == 0x40u)
    00869         {
    00870             bError = TRUE;
    00871             break;
    00872         }
    00873
    00874         if((u8Status & 0x01u) == 0x00u) /* Wait until write finish */
    00875         {
    00876             break;
    00877         }
    00878     }
    00879
    00880     CsioTxCmd(CmdWriteDisable, 1);
    00881
    00882     if(bError == TRUE)
    00883     {
    00884         return Error;
    00885     }
    00886
    00887     return Ok;
    00888
    00889 }
    00890
    00902 en_result_t S25fl127s_Read(uint32_t u32Addr, uint8_t* pu8Data, uint32_t u32Size)
    00903 {
    00904     if(pu8Data == NULL)
    00905     {
    00906         return ErrorInvalidParameter;
    00907     }
    00908
    00909     CsioRxData(CmdRead, 1, u32Addr, 3, pu8Data, u32Size);
    00910
    00911     return Ok;
    00912
    00913 }
    00914
    00915 #endif
    00916
    00917 /******************************************************************************/
    00918 /* EOF (not truncated)                                                        */
    00919 /******************************************************************************/