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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
flash.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：42k
源码类别：

DVD

开发平台：

C/C++

flash.c：源码内容
  1. /****************************************************************************
  3. File Name   : tt_flash.c
  5. Description : Testtool FLASH Commands
  7. Copyright (C) 2004, ST Microelectronics
  9. ****************************************************************************/
  11. /* Includes --------------------------------------------------------------- */
  12. /* Standard Includes */
  13. #include <stdio.h>
  14. #include <stddef.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <debug.h>
  18. #include "stack.h"
  19. #include "stlite.h"
  20. #include "stddefs.h"
  21. #include "stdevice.h"
  23. /* STAPI Includes */
  24. #include "stflash.h"
  25. #include "sttbx.h"
  27. #include "flash.h"
  28. //#include "tt_flash.h"
  30. /* Private Types ------------------------------------------------------ */
  32. typedef struct {
  33.     U8  Bank;           /* Bank number */
  34.     U32 Address;        /* Block start address */
  35.     U32 Length;         /* Length of block */
  36. } BlockInfo_t;
  38. typedef struct {
  39.     U8  Block;          /* Block number */
  40.     U32 Address;        /* flash address */
  41.     U32 Offset;         /* offset into readbuffer */
  42.     U32 Size;           /* number of bytes */
  43. } SectionInfo_t;
  45. /* Private Constants -------------------------------------------------- */
  48. /* Definitions for Flash */
  49. #define STFLASH_BANK_0_BASE     FLASH_BANK_0_BASE_ADDRESS
  51. #define STFLASH_VPP_0_ENABLE    0x45200000
  54. /* if BANK_1 defined it is available */
  55. #if defined(FLASH_BANK_1_BASE_ADDRESS)
  56.     #define STFLASH_BANK_1_BASE     FLASH_BANK_1_BASE_ADDRESS
  57.     #define NUM_BANKS               2
  58. #else
  59.     #define NUM_BANKS               1
  60. #endif
  62. /* if VPP not defined it is not needed */
  63. #if !defined(STFLASH_VPP_0_ENABLE)
  64.     #define STFLASH_VPP_0_ENABLE    (U32)NULL
  65. #endif
  67. #if !defined(STFLASH_VPP_1_ENABLE)
  68.     #define STFLASH_VPP_1_ENABLE    (U32)NULL
  69. #endif
  73. #define DEVICE_TYPE              STFLASH_M29W320DT /*8MB*/
  74. #define MIN_ACCESS_WIDTH         STFLASH_ACCESS_16_BITS
  75. #define MAX_ACCESS_WIDTH         STFLASH_ACCESS_16_BITS
  76. #define NUM_BLOCKS               135
  77. #define STFLASH_MAIN_0_SIZE      STFLASH_MAIN_SIZE
  78. #define STFLASH_MAIN_1_SIZE      STFLASH_MAIN_SIZE
  79. #define STFLASH_MAIN00_SIZE      0x00010000  /* 64Kb */
  80. #define STFLASH_MAIN01_SIZE    0x00008000  /* 32Kb */
  81. #define STFLASH_PARA_0_SIZE     0x00002000  /* 8Kb */
  82. #define STFLASH_BOOT_0_SIZE      0x00004000  /* 16Kb */
  84. #define NUM_SECTIONS             NUM_BLOCKS//80
  85. #define TOTAL_BLOCKS             (NUM_BANKS * NUM_BLOCKS)
  87. #define CR                      13
  88. #define LF                      10
  91. STFLASH_Block_t      BlockData_s[NUM_BLOCKS] =
  92.  {
  93.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  94.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  95.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  96.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  97.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  98.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  99.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  100.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  101.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  102.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  103.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  104.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  105.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  106.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  107.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  108.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  109.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  110.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  111.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  112.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  113.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  114.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  115.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  116.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  117.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  118.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  119.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  120.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  121.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  122.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 30 */
  123.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  124.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  125.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  126.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  127.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  128.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  129.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  130.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  131.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  132.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  133.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  134.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  135.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  136.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  137.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  138.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  139.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  140.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  141.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  142.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  143.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  144.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  145.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  146.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  147.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  148.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  149.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  150.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  151.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  152.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 60 */
  153.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  154.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  155.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  156.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  157.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  158.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  159.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  160.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  161.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  162.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  163.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  164.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  165.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  166.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  167.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  168.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  169.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  170.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  171.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  172.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  173.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  174.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  175.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  176.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  177.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  178.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  179.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  180.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  181.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  182.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 90 */
  183.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  184.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  185.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  186.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  187.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  188.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  189.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  190.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  191.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  192.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  193.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  194.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  195.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  196.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  197.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  198.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  199.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  200.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  201.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  202.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  203.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  204.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  205.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  206.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  207.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  208.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  209.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  210.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  211.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  212.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 120 */
  213.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  214.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  215.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  216.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  217.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  218.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  219.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  220.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 8 */
  221.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 9 */
  222.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 10 */
  223.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 11 */
  224.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 12 */
  225.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 13 */
  226.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 14 */
  227.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }  /* 135 */
  228.  };
  234.  
  236. static U32              FlashSize = 0;          /* Non-zero = file converted */
  237. static char             *FlashData_p = NULL;
  238. static SectionInfo_t    SectionInfo[NUM_SECTIONS];
  239. static BlockInfo_t      BlockInfo[TOTAL_BLOCKS + 1];
  240. static U32              BaseAddress[NUM_BANKS];
  241. static STFLASH_Block_t  GetBlkDat_s[NUM_BLOCKS];
  243. /* Private Macros ----------------------------------------------------- */
  245. /* Global Variables ------------------------------------------------------- */
  247. STFLASH_Handle_t        FLASHHndl[2];
  248. ST_DeviceName_t         FLASHDeviceName[2] = {"Bank0", "Bank1"};
  251. extern ST_Partition_t  *SystemPartition;
  253. /*-------------------------------------------------------------------------
  254.  * Function : FLASH_Close
  255.  *            close FLASH
  256.  * Input    : None
  257.  * Output   :
  258.  * Return   : TRUE if error, FALSE if success
  259.  * ----------------------------------------------------------------------*/
  260. ST_ErrorCode_t FLASH_Close( U8 BankNum )
  261. {
  262.     ST_ErrorCode_t          ErrCode;
  264.     ErrCode = STFLASH_Close(FLASHHndl[BankNum]);
  267.     return ( ErrCode );
  269. } /* end FLASH_Close */
  271. /*-------------------------------------------------------------------------
  272.  * Function : FLASH_GetParams
  273.  *            Get Flash Parameters
  274.  * Input    : None
  275.  * Output   :
  276.  * Return   : TRUE if error, FALSE if success
  277.  * ----------------------------------------------------------------------*/
  278. ST_ErrorCode_t FLASH_GetParams( U8 BankNum, STFLASH_Params_t *FLASHParams_p )
  279. {
  280.     ST_ErrorCode_t      ErrCode;
  282.     /* assign structure for returning data */
  283.     FLASHParams_p->InitParams.Blocks = GetBlkDat_s;
  284.     ErrCode = STFLASH_GetParams(FLASHHndl[BankNum], FLASHParams_p );
  287.     return ( ErrCode );
  289. } /* end FLASH_Close */
  291. /*-------------------------------------------------------------------------
  292.  * Function : FLASH_Init
  293.  *            Initialise FLASH
  294.  * Input    : None
  295.  * Output   :
  296.  * Return   : TRUE if error, FALSE if success
  297.  * ----------------------------------------------------------------------*/
  298. ST_ErrorCode_t FLASH_Init( U8 BankNum )
  299. {
  300.     ST_ErrorCode_t          ErrCode;
  301.     STFLASH_InitParams_t    InitParams;
  303.     InitParams.DeviceType = DEVICE_TYPE;
  305. #if defined (SELECT_DEVICE_STB5118)
  306.     if ( BankNum == BANK0 )
  307.     {
  308.         InitParams.BaseAddress = (U32*)STFLASH_BANK_0_BASE;
  309.         InitParams.VppAddress  = (U32*)NULL;
  310.     }
  311.     else
  312.     {
  313.         #if defined(STFLASH_BANK_1_BASE)
  314.             InitParams.BaseAddress = (U32*)STFLASH_BANK_1_BASE;
  315.             InitParams.VppAddress  = (U32*)NULL;
  316.         #else
  317.             return ST_ERROR_FEATURE_NOT_SUPPORTED;
  318.         #endif
  319.     }
  320. #else
  321.     if ( BankNum == BANK0 )
  322.     {
  323.         InitParams.BaseAddress = (U32*)STFLASH_BANK_0_BASE;
  324.         InitParams.VppAddress  = (U32*)STFLASH_VPP_0_ENABLE;
  325.     }
  326.     else
  327.     {
  328.         #if defined(STFLASH_BANK_1_BASE)
  329.             InitParams.BaseAddress = (U32*)STFLASH_BANK_1_BASE;
  330.             InitParams.VppAddress  = (U32*)STFLASH_VPP_1_ENABLE;
  331.         #else
  332.             return ST_ERROR_FEATURE_NOT_SUPPORTED;
  333.         #endif
  334.     }
  335. #endif
  337.     InitParams.MinAccessWidth  = MIN_ACCESS_WIDTH;
  338.     InitParams.MaxAccessWidth  = MAX_ACCESS_WIDTH;
  339.     InitParams.NumberOfBlocks  = NUM_BLOCKS;
  340.     InitParams.Blocks          = BlockData_s;
  341.     InitParams.DriverPartition = SystemPartition;
  342.     //InitParams.IsSerialFlash   = FALSE;
  344.     ErrCode = STFLASH_Init(FLASHDeviceName[BankNum], &InitParams );
  347.     return ( ErrCode );
  349. } /* end FLASH_Init */
  351. /*-------------------------------------------------------------------------
  352.  * Function : FLASH_Open
  353.  *            Open FLASH
  354.  * Input    : None
  355.  * Output   :
  356.  * Return   : TRUE if error, FALSE if success
  357.  * ----------------------------------------------------------------------*/
  358. ST_ErrorCode_t FLASH_Open( U8 BankNum )
  359. {
  360.     ST_ErrorCode_t          ErrCode;
  361.     STFLASH_OpenParams_t    OpenParams;
  363.     memset((char*)&OpenParams,0,sizeof(STFLASH_OpenParams_t));
  365.     ErrCode = STFLASH_Open(FLASHDeviceName[BankNum], &OpenParams, &FLASHHndl[BankNum]);
  368.     return ( ErrCode );
  370. } /* end FLASH_Open */
  372. /*-------------------------------------------------------------------------
  373.  * Function : FLASH_Term
  374.  *            Terminate FLASH
  375.  * Input    : ForceTerminate
  376.  * Output   :
  377.  * Return   : TRUE if error, FALSE if success
  378.  * ----------------------------------------------------------------------*/
  379. ST_ErrorCode_t FLASH_Term(  BOOL ForceTerminate, U8 BankNum )
  380. {
  381.     ST_ErrorCode_t          ErrCode;
  382.     STFLASH_TermParams_t    TermParams;
  384.     TermParams.ForceTerminate = ForceTerminate;
  386.     ErrCode = STFLASH_Term(FLASHDeviceName[BankNum], &TermParams);
  389.     return ( ErrCode );
  391. } /* end FLASH_Term */
  393. /*-------------------------------------------------------------------------
  394.  * Function : FLASH_SetupBlockInfo
  395.  *            Setup Block Info structure
  396.  * Input    :
  397.  * Output   :
  398.  * Return   : Error Code
  399.  * ----------------------------------------------------------------------*/
  400. ST_ErrorCode_t FLASH_SetupBlockInfo( void )
  401. {
  402.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  403.     STFLASH_Params_t    FLASHParams;
  404.     U8  Bank=0, Block=0;
  405.     U32 BlockStart = 0;
  406.     static U8 Section = 0;
  408.     memset((char*)&FLASHParams,0,sizeof(STFLASH_Params_t));
  410.     if ( Section == 0 )
  411.     {
  412.         /*
  413.         **  Set the address for each section
  414.         */
  415.         for ( Bank = 0; ( Bank < NUM_BANKS ) && ( ErrCode == ST_NO_ERROR ); Bank ++ )
  416.         {
  417.             ErrCode = FLASH_Init( Bank );                /* Init Bank */
  418.             if ( ErrCode == ST_NO_ERROR )
  419.             {
  420.                 ErrCode = FLASH_Open( Bank );
  421.                 if ( ErrCode == ST_NO_ERROR )
  422.                     ErrCode = FLASH_GetParams( Bank, &FLASHParams );
  424.                 if ( ErrCode == ST_NO_ERROR )
  425.                 {
  426.                     BlockStart = BaseAddress[Bank] = (U32) FLASHParams.InitParams.BaseAddress;
  427.                     for ( Block = 0; Block < FLASHParams.InitParams.NumberOfBlocks; Block ++)
  428.                     {
  429.                         BlockInfo[Section].Bank    = Bank;
  430.                         BlockInfo[Section].Address = BlockStart;
  431.                         BlockInfo[Section].Length  = FLASHParams.InitParams.Blocks[Block].Length;
  432.                         #ifdef DEBUG_OUTPUT
  433.                             printf("Block %2d (%d) 0x%08x 0x%08x (%6d) bytesn",
  434.                                          Block, Section,
  435.                                          BlockInfo[Section].Address,
  436.                                          BlockInfo[Section].Length,
  437.                                          BlockInfo[Section].Length );
  438.                         #endif
  439.                         Section ++;
  440.                         BlockStart += FLASHParams.InitParams.Blocks[Block].Length;
  441.                     }
  442.                 }
  443.                 ErrCode = FLASH_Term( TRUE, Bank );
  444.             }
  445.         }
  446.         BlockInfo[Section].Address = BlockStart;
  447.     }
  449.     if ( ErrCode == ST_NO_ERROR )
  450.         printf("Flash setup Ok (%d blocks)n", Section );
  452.     return( ErrCode );
  454. } /* end of FLASH_SetupBlockInfo */
  456. /*-------------------------------------------------------------------------
  457.  * Function : FLASH_Setup
  458.  *            Setup Block Info structure
  459.  * Input    :
  460.  * Output   :
  461.  * Return   : Error Code
  462.  * ----------------------------------------------------------------------*/
  463. ST_ErrorCode_t FLASH_Setup( void )
  464. {
  465.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  466.     U8  Bank;
  468.     /*    **  Set the address for each section*/
  470.         for ( Bank = 0; ( Bank < NUM_BANKS ) && ( ErrCode == ST_NO_ERROR ); Bank ++ )
  471.         {
  472.             ErrCode = FLASH_Init( Bank );                /* Init Bank */
  473.             if ( ErrCode == ST_NO_ERROR )
  474.             {
  475.                 ErrCode = FLASH_Open( Bank );
  476.             }
  477.             if ( ErrCode == ST_NO_ERROR )
  478.             printf("Flash setup Ok.....n" );
  479.         }
  480.     return( ErrCode );
  482. } /* end of Flash_Setup */
  484. /*-------------------------------------------------------------------------
  485.  * Function : FreeFileDataBuffer
  486.  *            as is
  487.  * Input    :
  488.  * Output   :
  489.  * Return   : None
  490.  * ----------------------------------------------------------------------*/
  491. static void FreeFileDataBuffer(void)
  492. {
  493.     /* deallocate File data buffer */
  494.     if ( FlashData_p != NULL )
  495.         memory_deallocate( SystemPartition, FlashData_p );
  497. } /* end of FreeFileDataBuffer() */
  499. /*-------------------------------------------------------------------------
  500.  * Function : GetBlockNumber
  501.  *            Get block number from address
  502.  * Input    :
  503.  * Output   :
  504.  * Return   : Block number of address
  505.  * ----------------------------------------------------------------------*/
  506. static U8 GetBlockNumber( U32 Address )
  507. {
  508.     U8  Block;
  510.     /* find the block this address is in */
  511.     for ( Block = 0; Block < TOTAL_BLOCKS; Block++ )
  512.     {
  513.         if (( Address >= BlockInfo[Block].Address ) &&
  514.             ( Address < (BlockInfo[Block].Address+BlockInfo[Block].Length)))
  515.         {
  516.             break;
  517.         }
  518.     }
  519.     return Block;
  521. } /* end GetBlockNumber */
  523. /*-------------------------------------------------------------------------
  524.  * Function : ConvertMemory
  525.  *            Convert Raw Hex file into memory buffer suitable to write to
  526.  *            flash copying created data over data read from filem, the
  527.  *            created data will be smaller as each byte takes three bytes
  528.  *            in the Hex file.
  529.  * Input    :
  530.  * Output   :
  531.  * Return   : size of data in buffer
  532.  * ----------------------------------------------------------------------*/
  533. static U32 ConvertMemory( long unsigned int MemSize )
  534. {
  535.     char                *OldPtr, *NewPtr;
  536.     int                 Section;
  537.     U32                 InOffset;
  538.     U32                 OutOffset;
  539.     U32                 BlockOffset;
  540.     U32                 Value=0;
  541.     U8                  Count=0 , Block=0;
  543.     for ( Section = 0; Section < NUM_SECTIONS; Section ++ )
  544.     {
  545.         SectionInfo[Section].Block = 0xff;
  546.         SectionInfo[Section].Address = 0;
  547.         SectionInfo[Section].Offset = 0;
  548.         SectionInfo[Section].Size = 0;
  549.     }
  551.     /* Convert File */
  553.     Section = 0;
  554.     OldPtr = FlashData_p;
  555.     NewPtr = (char*) NULL;
  557.     for ( InOffset = 0, OutOffset = 0; InOffset < MemSize; )
  558.     {
  559.         /* Line format =
  560.         ** Address  Data  (both in hex)
  561.         ** 12345678 11 22 33 44 55 etc. CR/LF
  562.         */
  563.         Value = (U32) strtol( OldPtr, &NewPtr, 16 );
  564.         if ( NewPtr != OldPtr ) /* if conversion possible */
  565.         {
  566.             if ( Value > 255 )  /* which means it is an address */
  567.             {
  568.                 if (( Block = GetBlockNumber( Value )) == TOTAL_BLOCKS )/*changed temp*/
  569.                 {
  570.                     printf("Invalid address 0x%xn", Value );
  571.                     break;
  572.                 }
  573.                 else
  574.                 {
  575.                     /*
  576.                     ** check if the address is non-contiguous
  577.                     ** or if it is a new block
  578.                     */
  579.                     if ((( SectionInfo[Section].Address + SectionInfo[Section].Size ) != Value ) ||
  580.                         ( SectionInfo[Section].Block != Block ))
  581.                     {
  582.                         Section ++;
  583.                     }
  585.                     /* Start New Block */
  586.                     if ( SectionInfo[Section].Block == 0xff )
  587.                     {
  588.                         SectionInfo[Section].Address = Value;
  589.                         SectionInfo[Section].Block = Block;
  590.                         SectionInfo[Section].Offset = OutOffset;
  591.                         SectionInfo[Section].Size = 0;
  592.                     }
  593.                 }
  594.             }
  595.             else
  596.             {
  597.                 BlockOffset = OutOffset;
  598.                 for ( Count = 0; Count < Section; Count++ )
  599.                     BlockOffset -= SectionInfo[Count].Size;
  601.                 if (( BlockOffset+1 ) > BlockInfo[SectionInfo[Section].Block].Length )
  602.                 {
  603.                     Section++;
  604.                 }
  606.                 /* Start New Block */
  607.                 if ( SectionInfo[Section].Block == 0xff )
  608.                 {
  609.                     SectionInfo[Section].Address = BlockInfo[Block].Address + BlockOffset;
  610.                     SectionInfo[Section].Block = GetBlockNumber(SectionInfo[Section].Address);
  611.                     SectionInfo[Section].Offset = OutOffset;
  612.                     SectionInfo[Section].Size = 0;
  613.                 }
  615.                 SectionInfo[Section].Size ++;
  616.                 FlashData_p[OutOffset++] = (char) Value;
  617.              }
  619.             InOffset += (U32)( NewPtr - OldPtr );
  620.             OldPtr = NewPtr;
  622.             if ( Section > NUM_SECTIONS )
  623.             {
  624.                 printf("Program Limitationn");
  625.                 exit(0);
  626.             }
  628.        }
  629.         else
  630.             break;
  631.     } /* end of for loop */
  633.     printf("n");
  635.     /* display the first few bytes of each section */
  636.     for ( Section = 0; Section < NUM_SECTIONS; Section ++ )
  637.     {
  638.         if ( SectionInfo[Section].Block != 0xFF )
  639.         {
  640.             printf("Section %2d, Block %3d, Addr 0x%08x, Offset 0x%08x, Size %6dn",
  641.                          Section,
  642.                          SectionInfo[Section].Block,
  643.                          SectionInfo[Section].Address,
  644.                          SectionInfo[Section].Offset,
  645.                          SectionInfo[Section].Size );
  647.             #ifdef DEBUG_INFO
  648.                 for ( InOffset = 0;
  649.                       ( InOffset < 32 ) && ( InOffset < SectionInfo[Section].Size );
  650.                       InOffset ++ )
  651.                 {
  652.                     printf(" %02x", FlashData_p[ SectionInfo[Section].Offset + InOffset ] );
  653.                 }
  654.                 printf("n");
  655.             #endif
  656.         }
  657.     }
  658.     return ( OutOffset );
  660. } /* end ConvertMemory */
  662. /*-------------------------------------------------------------------------
  663.  * Function : ReadFile
  664.  *            Read HEX file into memory
  665.  * Input    :
  666.  * Output   :
  667.  * Return   : File size
  668.  * ----------------------------------------------------------------------*/
  669. U32 FLASH_ReadFile( char *Filename )
  670. {
  671.     long int    HexFile_p=0;            /* datafile descriptor          */
  672.     long int    HexFileSize=0;          /* size in bytes of the file    */
  674.     /* Open and Read file into memory */
  675.     HexFile_p = debugopen(Filename, "rb");
  676.     printf("HexFile_p = 0x%8xn",HexFile_p);
  678.     if(HexFile_p < 0)
  679.     {
  680.         printf("Error opening file '%s'n", Filename );
  681.         return (0);
  682.     }
  683.     else
  684.     {
  685.         HexFileSize = debugfilesize(HexFile_p);
  686.         printf("HexFileSize = 0x%8xn",HexFileSize);
  687.         /* allocate File data buffer */
  688.         FreeFileDataBuffer();
  689.         FlashData_p = (char*) memory_allocate( SystemPartition, (U32) HexFileSize );
  690.         if ( FlashData_p != NULL )
  691.         {
  692.             printf("Loading '%s' into memory, wait .. ", Filename );
  693.             debugread(HexFile_p, FlashData_p, (size_t) HexFileSize);
  694.             printf("%d bytesn", HexFileSize );
  695.         }
  696.         else
  697.         {
  698.             printf("Not enough memory for HEX file (%d bytes)n", HexFileSize);
  699.             HexFileSize = 0;
  700.         }
  702.         debugclose(HexFile_p);
  703.     }
  705.     if ( HexFileSize > 0 )
  706.     {
  707.         /* convert buffer to binary and resize memory */
  708.         printf("Converting file in memory, wait .. ");
  709.         FlashSize = ConvertMemory( HexFileSize );
  710.         if ( FlashSize > 0 )
  711.         {
  712.             printf("%d bytesn", FlashSize );
  713.             FlashData_p = (char*) memory_reallocate( SystemPartition, FlashData_p, FlashSize );
  714.         }
  715.         else
  716.             printf("Invalid filen");
  717.     }
  719.     return( FlashSize );
  721. } /* end of FLASH_ReadFile */
  723. /*-------------------------------------------------------------------------
  724.  * Function : EraseFlash
  725.  *            Function to Read Hex file and erase areas required
  726.  * Input    : EraseAll
  727.  * Output   :
  728.  * Return   : EraseFailed = TRUE else FALSE
  729.  * ----------------------------------------------------------------------*/
  730. BOOL EraseFlash( BOOL EraseAll )
  731. {
  732.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  733.     U8   Section, Bank;
  734.     U32  EraseOffset;
  735.     BOOL EraseFailed = TRUE;
  737.     /* check data size */
  738.     if (( FlashSize != 0 ) || EraseAll )
  739.     {
  740.         EraseFailed = FALSE;
  741.         printf("tt+------------+------------+n");
  743.         if ( EraseAll )
  744.         {
  745.             for ( Section = 0;( Section < TOTAL_BLOCKS ) && ( ErrCode == ST_NO_ERROR ); Section ++)
  746.             {
  747.                 Bank = BlockInfo[Section].Bank;
  748.                 EraseOffset = BlockInfo[Section].Address - BaseAddress[Bank];
  749.                 printf("%d block %2dt| 0x%08x | 0x%08x | ",
  750.                              Bank, Section,
  751.                              BlockInfo[Section].Address,
  752.                              BlockInfo[Section].Address + BlockInfo[Section].Length - 1 );
  754.                 ErrCode = STFLASH_Erase( FLASHHndl[Bank],
  755.                                          EraseOffset,
  756.                                          BlockInfo[Section].Length );
  757.                 if ( ErrCode != ST_NO_ERROR )
  758.                 {
  759.                     printf("Erase FAILEDn");
  760.                     EraseFailed = TRUE;
  761.                 }
  762.                 else
  763.                     printf("ERASEDn");
  764.             }
  765.         }
  766.         else
  767.         {
  768.             /* Find out which blocks are to be Erased */
  770.             for ( Section = 0; ( Section < NUM_SECTIONS ) && ( EraseFailed == FALSE ); Section ++ )
  771.             {
  772.                 if ( SectionInfo[Section].Block != 0xFF )
  773.                 {
  774.                     /*
  775.                     ** Erase = erase whole block, valid parameters are block base address & block size
  776.                     */
  777.                     Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  778.                     EraseOffset = BlockInfo[ SectionInfo[Section].Block ].Address - BaseAddress[Bank];
  780.                     printf("block %2dt| 0x%08x | 0x%08x | ",
  781.                                  SectionInfo[Section].Block,
  782.                                  BlockInfo[ SectionInfo[Section].Block ].Address,
  783.                                  BlockInfo[ SectionInfo[Section].Block ].Address +
  784.                                  BlockInfo[ SectionInfo[Section].Block ].Length - 1 );
  786.                     ErrCode = STFLASH_Erase( FLASHHndl[Bank],
  787.                                              EraseOffset,
  788.                                              BlockInfo[ SectionInfo[Section].Block ].Length );
  790.                     if ( ErrCode != ST_NO_ERROR )
  791.                     {
  792.                         printf("ErrCode = 0x%8xn",ErrCode);
  793.                         printf("Erase FAILEDn");
  794.                         printf("FLASHHndl[Bank] = 0x%8Xn",FLASHHndl[Bank]);
  795.                         EraseFailed = TRUE;
  796.                     }
  797.                     else
  798.                         printf("ERASEDn");
  799.                 }
  800.             }
  801.         }
  802.         printf("tt+------------+------------+n");
  803.     }
  805.     if ( EraseFailed == TRUE )
  806.     {
  807.         FreeFileDataBuffer();
  808.         printf("!!!! ERASE Failed !!!!n");
  809.         return TRUE;
  810.     }
  812.     return EraseFailed;
  814. } /* end ProgramFlash */
  816. /*-------------------------------------------------------------------------
  817.  * Function : ProgramFlash
  818.  *            Function to Read Hex file and program flash with contents
  819.  * Input    :
  820.  * Output   :
  821.  * Return   : None
  822.  * ----------------------------------------------------------------------*/
  823. BOOL ProgramFlash( void )
  824. {
  825.     ST_ErrorCode_t      ErrCode;
  826.     int                 Section, Bank;
  827.     U32                 NumberOfBytes;
  828.     BOOL                ProgramFailed;
  830. FlashSize=0x2000;
  831.     /* check data size */
  832.     if ( FlashSize == 0 )
  833.         ProgramFailed = TRUE;
  834.     else
  835.     {
  836.         ProgramFailed = FALSE;
  837.         printf("tt+------------+------------+n");
  838.     }
  840.     /* Find out which blocks are to be written to */
  841.     /* Write the data to the Flash */
  842.     /*printf("Printing the contents of BlockInfo n"));
  843.     for ( Section = 0; ( Section < NUM_SECTIONS ) ; Section ++ )
  844.     {
  845.         printf("Section=%dt", Section ));
  846.         printf("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  847.         printf("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  848.         printf("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  849.     }*/
  851.     for ( Section = 0; ( Section < NUM_SECTIONS ) && ( ProgramFailed == FALSE ); Section ++ )
  852.     {
  853.         if ( SectionInfo[Section].Block != 0xFF )
  854.         {
  855.             U32  WriteOffset;
  857.             /*
  858.             ** Write = write bytes from Offset
  859.             */
  860.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  861.             printf("Section=%dt", Section );
  862.             printf("SectionInfo[Section]=%dn", SectionInfo[Section] );
  863.             printf("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block );
  864.             printf("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank);
  865.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  866.             /*SectionInfo[Section].Address += 0x4; Tara*/
  867.             printf("block %2dt| 0x%08x | 0x%08x | ",
  868.                          SectionInfo[Section].Block,
  869.                          SectionInfo[Section].Address,
  870.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 );
  872.             ErrCode = STFLASH_Write( FLASHHndl[Bank],
  873.                                      WriteOffset,
  874.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  875.                                      SectionInfo[Section].Size,
  876.                                      &NumberOfBytes );
  878.             if ( ErrCode != ST_NO_ERROR )
  879.             {
  880.                 printf("Program FAILEDn");
  881.                 ProgramFailed = TRUE;
  882.             }
  883.             else
  884.                 printf("PROGRAMMEDn");
  885.         }
  886.     }
  888.     if ( ProgramFailed == TRUE )
  889.     {
  890.         FreeFileDataBuffer();
  891.         printf("!!!! PROGRAM Failed !!!!n");
  892.         return TRUE;
  893.     }
  894.     else
  895.     {
  896.         printf("tt+------------+------------+n");
  897.         return FALSE;
  898.     }
  900. } /* end ProgramFlash */
  903. /*-------------------------------------------------------------------------
  904.  * Function : VerifyFlash
  905.  *            Function to Read Hex file and verify flash with contents
  906.  * Input    :
  907.  * Output   :
  908.  * Return   : None
  909.  * ----------------------------------------------------------------------*/
  910. BOOL VerifyFlash( void )
  911. {
  912.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  913.     int                 Section, Bank;
  914.     U32                 Length;
  915.     U32                 ReadOffset;
  916.     U32                 NumberOfBytes;
  917.     U8                  *Buffer_p;
  918.     BOOL                VerifyFailed;
  920.     /* check data size */
  921.     if ( FlashSize == 0 )
  922.         VerifyFailed = TRUE;
  923.     else
  924.     {
  925.         VerifyFailed = FALSE;
  926.         printf("tt+------------+------------+n");
  927.     }
  929.     /* Find out which blocks are to be verified */
  930.     /* Read the data and compare */
  932.     for ( Section = 0; ( Section < NUM_SECTIONS ) && ( VerifyFailed == FALSE ); Section ++ )
  933.     {
  934.         if ( SectionInfo[Section].Block != 0xFF )
  935.         {
  936.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  937.             Length = BlockInfo[ SectionInfo[Section].Block ].Length;
  938.             ReadOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  940.             /* allocate temp buffer to put flash data in */
  941.             Buffer_p = memory_allocate( SystemPartition, Length );
  942.             if ( Buffer_p != NULL )
  943.             {
  944.                 printf("block %2dt| 0x%08x | 0x%08x | ",
  945.                          SectionInfo[Section].Block,
  946.                          SectionInfo[Section].Address,
  947.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 );
  949.                 ErrCode = STFLASH_Read( FLASHHndl[Bank],
  950.                                         ReadOffset,
  951.                                         Buffer_p,
  952.                                         SectionInfo[Section].Size,
  953.                                         &NumberOfBytes );
  954.                 if(ErrCode != ST_NO_ERROR)
  955.                 {
  956.                 }
  958.                 if ( memcmp( Buffer_p,(U8*)&FlashData_p[SectionInfo[Section].Offset],
  959.                              SectionInfo[Section].Size ) != 0 )
  960.                 {
  961.                     printf("Verify FAILEDn");
  962.                     VerifyFailed = TRUE;
  963.                 }
  964.                 else
  965.                     printf("VERIFIEDn");
  967.                 /* deallocate temp buffer */
  968.                 memory_deallocate( SystemPartition, Buffer_p );
  969.             }
  970.         }
  971.     }
  973.     FreeFileDataBuffer();
  975.     if ( VerifyFailed == TRUE )
  976.     {
  977.         printf("!!!! VERIFY Failed !!!!n");
  978.         return TRUE;
  979.     }
  980.     else
  981.     {
  982.         printf("tt+------------+------------+n");
  983.         return FALSE;
  984.     }
  986. } /* end VerifyFlash */
  991. //---------------------------------------------------------------------------------------
  992. //
  993. //上面接口用于烧录应用程序
  994. //
  995. //下面接口用于应用程序调用
  996. //
  997. //---------------------------------------------------------------------------------------
  998. ST_ErrorCode_t KB_FLASHSetupBlockInfo( void )
  999. {
  1000.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  1001.     STFLASH_Params_t    FLASHParams;
  1002.     U8  Bank=0, Block=0;
  1003.     U32 BlockStart = 0;
  1004.     static U8 Section = 0;
  1006.     memset((char*)&FLASHParams,0,sizeof(STFLASH_Params_t));
  1008.     if ( Section == 0 )
  1009.     {
  1010.         /*
  1011.         **  Set the address for each section
  1012.         */
  1013.         for ( Bank = 0; ( Bank < NUM_BANKS ) && ( ErrCode == ST_NO_ERROR ); Bank ++ )
  1014.         {
  1015.             ErrCode = FLASH_Init( Bank );                /* Init Bank */
  1016.             if ( ErrCode == ST_NO_ERROR )
  1017.             {
  1018.                 ErrCode = FLASH_Open( Bank );
  1019.                 if ( ErrCode == ST_NO_ERROR )
  1020.                     ErrCode = FLASH_GetParams( Bank, &FLASHParams );
  1022.                 if ( ErrCode == ST_NO_ERROR )
  1023.                 {
  1024.                     BlockStart = BaseAddress[Bank] = (U32) FLASHParams.InitParams.BaseAddress;
  1025.                     for ( Block = 0; Block < FLASHParams.InitParams.NumberOfBlocks; Block ++)
  1026.                     {
  1027.                         BlockInfo[Section].Bank    = Bank;
  1028.                         BlockInfo[Section].Address = BlockStart;
  1029.                         BlockInfo[Section].Length  = FLASHParams.InitParams.Blocks[Block].Length;
  1030.                         #ifdef DEBUG_OUTPUT
  1031.                             printf("Block %2d (%d) 0x%08x 0x%08x (%6d) bytesn",
  1032.                                          Block, Section,
  1033.                                          BlockInfo[Section].Address,
  1034.                                          BlockInfo[Section].Length,
  1035.                                          BlockInfo[Section].Length );
  1036.                         #endif
  1037.                         Section ++;
  1038.                         BlockStart += FLASHParams.InitParams.Blocks[Block].Length;
  1039.                     }
  1040.                 }
  1041.                 ErrCode = FLASH_Term( TRUE, Bank );
  1042.             }
  1043.         }
  1044.         BlockInfo[Section].Address = BlockStart;
  1045.     }
  1047.     if ( ErrCode == ST_NO_ERROR )
  1048.         printf("Flash setup Ok (%d blocks)n", Section );
  1050.     return( ErrCode );
  1052. }
  1055. void test_FlashInit(void )
  1056. {
  1058. #if 1
  1059. KB_FLASHSetupBlockInfo();
  1061. FLASH_Setup();
  1062. #else //or OK
  1063.      ST_ErrorCode_t          ErrCode;
  1065.     if ( ErrCode == ST_NO_ERROR )
  1066.         ErrCode  = FLASH_SetupBlockInfo();
  1068.     if ( ErrCode == ST_NO_ERROR )
  1069.         {
  1070.             ErrCode = FLASH_Init(BANK0);
  1071.             if ( ErrCode == ST_NO_ERROR )
  1072.             ErrCode = FLASH_Open(BANK0);
  1073.         }
  1075.     #ifdef STFLASH_BANK_1_BASE
  1076.         if ( ErrCode == ST_NO_ERROR )
  1077.         {
  1078.             ErrCode = FLASH_Init(BANK1);
  1079.             if ( ErrCode == ST_NO_ERROR )
  1080.                 ErrCode = FLASH_Open(BANK1);
  1081.         }
  1082.     #endif
  1083. #endif
  1085. }
  1086. #if 1
  1087. RetValue KB_FLASHInit(void)
  1088. {
  1089.      ST_ErrorCode_t ErrCode;
  1091. KB_FLASHSetupBlockInfo();
  1093. FLASH_Setup();
  1095. return RETOK;
  1096. }
  1098. RetValue KB_FlashErase(UINT32 secID)
  1099. {
  1100. ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1101.      int Bank;
  1102. U32 EraseOffset;
  1104.        Bank = BlockInfo[secID].Bank;
  1105.        EraseOffset = BlockInfo[secID].Address - BaseAddress[Bank];
  1106.      //printf("n[Flash]:Erase address[0x%x] len[0x%x].",BlockInfo[secID].Address,BlockInfo[secID].Length);
  1108.        ErrCode = STFLASH_Erase( FLASHHndl[Bank],EraseOffset,BlockInfo[secID].Length );
  1109.       if ( ErrCode != ST_NO_ERROR )
  1110.       {
  1111.           printf("n[Flash]:Erase failed[0x%x].",ErrCode);
  1112. return RETFIAL1;
  1113.       }
  1114.       else
  1115.       {
  1116.             //printf("n[Flash]:Erase success.");
  1117. return RETOK;
  1118.       }
  1119. }
  1121. RetValue KB_FlashWrite(UINT32 secID,UINT32 Offset,UINT8 *Buffer,UINT32 NumberToWrite)
  1122. {
  1123. ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1124.      int Bank;
  1125. U32 numWrited,WriteOffset;
  1127.    if ( SectionInfo[secID].Block != 0xFF )
  1128.        {
  1129. KB_FlashErase(secID);
  1131.            Bank = BlockInfo[ SectionInfo[secID].Block ].Bank;
  1132.              WriteOffset = BlockInfo[secID].Address - BaseAddress[Bank];
  1133.              //printf("n[Flash]:Write address[0x%x] WriteOffset[0x%x] NumberToWrite[0x%x].",BlockInfo[secID].Address,WriteOffset,NumberToWrite);
  1134. //printf("nSectionInfo address[0x%x] base address[0x%x] WriteOffset[0x%x]",SectionInfo[secID].Address,BaseAddress[Bank],WriteOffset);
  1135.              ErrCode = STFLASH_Write( FLASHHndl[Bank],WriteOffset,(U8*)Buffer,NumberToWrite,&numWrited );
  1137.              if ( ErrCode != ST_NO_ERROR )
  1138.              {
  1139.                  printf("n[Flash]:Write failed[0x%x].",ErrCode);
  1140. return RETFIAL1;
  1141.              }
  1142.              else
  1143.              {
  1144.                  //printf("n[Flash]:Write success.");
  1145. return RETOK;
  1146.              }
  1147.      }
  1148. else
  1149. {
  1150. printf("n[Flash]:Write section block error[0x%x].",SectionInfo[secID].Block);
  1151. return RETFIAL1;
  1152. }
  1153. }
  1155. RetValue KB_FlashRead( UINT32 secID,UINT32 Offset,UINT8 *Buffer,UINT32 NumberToRead)
  1156. {
  1157. ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1158.      int Bank;
  1159. U32 numReaded,ReadOffset;
  1161.    if ( SectionInfo[secID].Block != 0xFF )
  1162.        {
  1163.            Bank = BlockInfo[ SectionInfo[secID].Block ].Bank;
  1164.              ReadOffset = BlockInfo[secID].Address - BaseAddress[Bank];
  1165.              //printf("n[Flash]:Read address[0x%x] ReadOffset[0x%x] NumberToRead[0x%x].",BlockInfo[secID].Address,ReadOffset,NumberToRead);
  1166. //printf("nSectionInfo address[0x%x] base address[0x%x] WriteOffset[0x%x]",SectionInfo[secID].Address,BaseAddress[Bank],WriteOffset);
  1167.              ErrCode = STFLASH_Read( FLASHHndl[Bank],ReadOffset,(U8*)Buffer,NumberToRead,&numReaded );
  1169.              if ( ErrCode != ST_NO_ERROR )
  1170.              {
  1171.                  printf("n[Flash]:Read failed[0x%x].",ErrCode);
  1172. return RETFIAL1;
  1173.              }
  1174.              else
  1175.              {
  1176.                  //printf("n[Flash]:Read success.");
  1177. return RETOK;
  1178.              }
  1179.      }
  1180. else
  1181. {
  1182. printf("n[Flash]:Read section block error[0x%x].",SectionInfo[secID].Block);
  1183. return RETFIAL1;
  1184. }
  1185. }
  1187. UINT8 *KB_FlashGetSectorAddr(UINT32 secID)
  1188. {
  1189. UINT8 *addr;
  1191. addr=(UINT8 *)BlockInfo[secID].Address;
  1193. return addr;
  1194. }
  1195. #endif
  1197. /* EOF --------------------------------------------------------------------- */