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

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

DVD

开发平台：

C/C++

wts_flash.c：源码内容
  1. /****************************************************************************
  3. File Name   : tt_flash.c
  5. Description : Testtool FLASH Commands
  7. Copyright (C) 2004, ST Microelectronics
  8.  
  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"
  26. #include "testtool.h"
  28. /* Local Includes */
  29. #include "wts_app_data.h"
  30. #include "wts_flash.h"
  33. /* Private Types ------------------------------------------------------ */
  35. /* Private Constants -------------------------------------------------- */
  37. /* Definitions for Flash */
  38. #if 0
  39. #define FLASH_BANK_0_BASE_ADDRESS_LOCAL 0x40000000 /* check this as it should be 7f80000 */
  40. #define STFLASH_BANK_0_BASE     FLASH_BANK_0_BASE_ADDRESS_LOCAL  /*FLASH_BANK_0_BASE_ADDRESS*/
  41. #endif
  43. #define STFLASH_MAIN_0_SIZE     STFLASH_MAIN_SIZE
  44. #define STFLASH_MAIN_1_SIZE     STFLASH_MAIN_SIZE
  45. #ifdef ST_5105
  46. #define STFLASH_VPP_0_ENABLE    0x45200000
  47. #elif defined(ST_5100)
  48. #define STFLASH_VPP_0_ENABLE    0x41400000
  49. #endif
  52. /* if BANK_1 defined it is available */
  53. #if defined(FLASH_BANK_1_BASE_ADDRESS)
  54.     #define STFLASH_BANK_1_BASE     FLASH_BANK_1_BASE_ADDRESS
  55.     #define NUM_BANKS               2
  56. #else
  57.     #define NUM_BANKS               1
  58. #endif
  60. /* if VPP not defined it is not needed */
  61. #if !defined(STFLASH_VPP_0_ENABLE)
  62.     #define STFLASH_VPP_0_ENABLE    (U32)NULL
  63. #endif
  65. #if !defined(STFLASH_VPP_1_ENABLE)
  66.     #define STFLASH_VPP_1_ENABLE    (U32)NULL
  67. #endif
  69. /***********leslie***********/
  70. /*M29W160DT*/
  71. #define DEVICE_TYPE             STFLASH_M29W320DT /*STFLASH_M29W800T*/
  72. #define MIN_ACCESS_WIDTH        STFLASH_ACCESS_16_BITS
  73. #define MAX_ACCESS_WIDTH        STFLASH_ACCESS_16_BITS
  74. #define NUM_BLOCKS              135
  76. /**********************/
  77. #define STFLASH_MAIN00_SIZE             0x00010000  /* 64Kb */
  78. #define STFLASH_MAIN01_SIZE             0x00008000  /* 32Kb */
  79. #define STFLASH_PARA_0_SIZE             0x00002000  /* 8Kb */
  80. #define STFLASH_BOOT_0_SIZE             0x00004000  /* 16Kb */
  82. #define NUM_SECTIONS            NUM_BLOCKS
  83. #define TOTAL_BLOCKS            (NUM_BANKS * NUM_BLOCKS)
  86. #ifdef rayf
  87. #define CODE_SECTIONS 0
  88. #define LANG_SECTIONS 16
  89. #define LNB_SECTIONS 24
  90. #define LOGO_SECTIONS 31
  93. #define CODE_BLOCKS 16
  94. #define FIRST_CODE_BLOCK 0
  96. #define LANG_BLOCKS 8
  97. #define FIRST_LANG_BLOCK 16
  99. #define LNB_BLOCKS 2
  100. #define FIRST_LNB_BLOCK 24
  102. #define LOGO_BLOCKS 1
  103. #define FIRST_LOGO_BLOCK 31
  105. #endif
  107. #define CR                      13
  108. #define LF                      10
  110. /* Private Variables -------------------------------------------------- */
  116. /* Bank sizes (bytes) */
  117. /* Each device is configured as 512kb x 16 bits */ STFLASH_Block_t      wts_BlockData_s[NUM_BLOCKS] =
  118.  {
  119.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  120.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  121.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  122.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  123.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  124.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  125.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  126.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  127.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  128.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  129.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  130.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  131.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  132.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  133.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  134.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  135.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  136.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  137.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  138.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  139.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  140.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  141.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  142.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  143.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  144.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  145.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  146.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  147.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  148.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 30 */
  149.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  150.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  151.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  152.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  153.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  154.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  155.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  156.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  157.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  158.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  159.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  160.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  161.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  162.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  163.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  164.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  165.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  166.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  167.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  168.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  169.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  170.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  171.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  172.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  173.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  174.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  175.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  176.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  177.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  178.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 60 */
  179.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  180.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  181.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  182.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  183.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  184.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  185.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  186.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  187.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  188.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  189.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  190.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  191.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  192.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  193.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  194.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  195.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  196.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  197.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  198.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  199.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  200.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  201.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  202.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  203.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  204.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  205.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  206.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  207.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  208.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 90 */
  209.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  210.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  211.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  212.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  213.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  214.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  215.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  216.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 8 */
  217.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 9 */
  218.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 10 */
  219.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 11 */
  220.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 12 */
  221.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 13 */
  222.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 14 */
  223.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 15 */
  224.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 16 */
  225.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 17 */
  226.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 18 */
  227.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 19 */
  228.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 20 */
  229.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 21 */
  230.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 22 */
  231.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 23 */
  232.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 24 */
  233.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 25 */
  234.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 26 */
  235.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 27 */
  236.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 28 */
  237.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 29 */
  238.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 120 */
  239.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 1 */
  240.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 2 */
  241.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 3 */
  242.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 4 */
  243.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 5 */
  244.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 6 */
  245.   {STFLASH_MAIN00_SIZE  , STFLASH_MAIN_BLOCK }, /* 7 */
  246.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 8 */
  247.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 9 */
  248.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 10 */
  249.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 11 */
  250.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 12 */
  251.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 13 */
  252.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }, /* 14 */
  253.   {STFLASH_PARA_0_SIZE  , STFLASH_PARAMETER_BLOCK }  /* 135 */
  254.  };  /* 34 */
  257. /****************************/      
  259. static U32              FlashSize = 0;          /* Non-zero = file converted */
  260. static char             *FlashData_p = NULL;
  261. static SectionInfo_t    SectionInfo[NUM_SECTIONS];
  262. static BlockInfo_t      BlockInfo[TOTAL_BLOCKS + 1];
  263. static U32              BaseAddress[NUM_BANKS];
  264. static STFLASH_Block_t  GetBlkDat_s[NUM_BLOCKS];
  266. /* Private Macros ----------------------------------------------------- */
  267. extern U32 wtFlashBankBaseAddr;
  269. #define WTFLASH_BASE_ADDR2 wtFlashBankBaseAddr
  271. /* Global Variables ------------------------------------------------------- */
  273. STFLASH_Handle_t        wts_FLASHHndl[2];
  274. ST_DeviceName_t         wts_FLASHDeviceName[2] = {"Bank0", "Bank1"};
  276. /* Private Function prototypes ---------------------------------------- */
  278. /* Functions ---------------------------------------------------------- */
  280. /*-------------------------------------------------------------------------
  281.  * Function : wts_FLASH_Close
  282.  *            close FLASH
  283.  * Input    : None
  284.  * Output   :
  285.  * Return   : TRUE if error, FALSE if success
  286.  * ----------------------------------------------------------------------*/
  287. ST_ErrorCode_t wts_FLASH_Close( U8 BankNum )
  288. {
  289.     ST_ErrorCode_t          ErrCode;
  291.     ErrCode = STFLASH_Close(wts_FLASHHndl[BankNum]);
  293.     STTBX_Print(("STFLASH_Close()=%sn", wts_GetErrorText(ErrCode) ));
  295.     return ( ErrCode );
  297. } /* end wts_FLASH_Close */
  299. /*-------------------------------------------------------------------------
  300.  * Function : wts_FLASH_GetParams
  301.  *            Get Flash Parameters
  302.  * Input    : None
  303.  * Output   :
  304.  * Return   : TRUE if error, FALSE if success
  305.  * ----------------------------------------------------------------------*/
  306. ST_ErrorCode_t wts_FLASH_GetParams( U8 BankNum, STFLASH_Params_t *FLASHParams_p )
  307. {
  308.     ST_ErrorCode_t      ErrCode;
  309.     
  310.     /* assign structure for returning data */
  311.     FLASHParams_p->InitParams.Blocks = GetBlkDat_s;    
  312.     ErrCode = STFLASH_GetParams(wts_FLASHHndl[BankNum], FLASHParams_p );
  314.     STTBX_Print(("STFLASH_GetParams(%d)=%sn", BankNum, wts_GetErrorText(ErrCode)));
  316.     return ( ErrCode );
  318. } /* end wts_FLASH_Close */
  320. /*-------------------------------------------------------------------------
  321.  * Function : wts_FLASH_Init
  322.  *            Initialise FLASH
  323.  * Input    : None
  324.  * Output   :
  325.  * Return   : TRUE if error, FALSE if success
  326.  * ----------------------------------------------------------------------*/
  327. ST_ErrorCode_t wts_FLASH_Init( U8 BankNum )
  328. {
  329.     ST_ErrorCode_t          ErrCode;
  330.     STFLASH_InitParams_t    InitParams;
  333.     InitParams.DeviceType = DEVICE_TYPE;
  334.     if ( BankNum == BANK0 )
  335.     {
  336. #if 0
  337.         InitParams.BaseAddress = (U32*)STFLASH_BANK_0_BASE;
  338. #else
  339.         InitParams.BaseAddress = (U32*)WTFLASH_BASE_ADDR2;
  340. STTBX_Print(("nBaseAddress=[0x%x]n",InitParams.BaseAddress));
  341. #endif
  342.         InitParams.VppAddress  = (U32*)STFLASH_VPP_0_ENABLE;
  343.     }
  344.     else
  345.     {
  346.         #if defined(STFLASH_BANK_1_BASE)
  347.             InitParams.BaseAddress = (U32*)STFLASH_BANK_1_BASE;
  348.             InitParams.VppAddress  = (U32*)STFLASH_VPP_1_ENABLE;
  349.         #else
  350.             return ST_ERROR_FEATURE_NOT_SUPPORTED;
  351.         #endif
  352.     }
  354.     InitParams.MinAccessWidth  = MIN_ACCESS_WIDTH;
  355.     InitParams.MaxAccessWidth  = MAX_ACCESS_WIDTH;
  356.     InitParams.NumberOfBlocks  = NUM_BLOCKS;
  357.     InitParams.Blocks          = wts_BlockData_s;
  358.     InitParams.DriverPartition = SystemPartition;
  360.     ErrCode = STFLASH_Init(wts_FLASHDeviceName[BankNum], &InitParams );
  362.     STTBX_Print(("STFLASH_Init(%s)=%sn", wts_FLASHDeviceName[BankNum], wts_GetErrorText(ErrCode) ));
  364.     return ( ErrCode );
  366. } /* end wts_FLASH_Init */
  368. /*-------------------------------------------------------------------------
  369.  * Function : wts_FLASH_Open
  370.  *            Open FLASH
  371.  * Input    : None
  372.  * Output   :
  373.  * Return   : TRUE if error, FALSE if success
  374.  * ----------------------------------------------------------------------*/
  375. ST_ErrorCode_t wts_FLASH_Open( U8 BankNum )
  376. {
  377.     ST_ErrorCode_t          ErrCode;
  378.     STFLASH_OpenParams_t    OpenParams;
  379.     
  380.     memset((char*)&OpenParams,0,sizeof(STFLASH_OpenParams_t));
  381.     
  382.     ErrCode = STFLASH_Open(wts_FLASHDeviceName[BankNum], &OpenParams, &wts_FLASHHndl[BankNum]);
  384.     STTBX_Print(("STFLASH_Open(%s)=%sn", wts_FLASHDeviceName[BankNum], wts_GetErrorText(ErrCode) ));
  386.     return ( ErrCode );
  388. } /* end wts_FLASH_Open */
  390. /*-------------------------------------------------------------------------
  391.  * Function : wts_FLASH_Term
  392.  *            Terminate FLASH
  393.  * Input    : ForceTerminate
  394.  * Output   :
  395.  * Return   : TRUE if error, FALSE if success
  396.  * ----------------------------------------------------------------------*/
  397. ST_ErrorCode_t wts_FLASH_Term(  BOOL ForceTerminate, U8 BankNum )
  398. {
  399.     ST_ErrorCode_t          ErrCode;
  400.     STFLASH_TermParams_t    TermParams;
  402.     TermParams.ForceTerminate = ForceTerminate;
  404.     ErrCode = STFLASH_Term(wts_FLASHDeviceName[BankNum], &TermParams);
  406.     STTBX_Print(("STFLASH_Term(%s)=%sn", wts_FLASHDeviceName[BankNum], wts_GetErrorText(ErrCode) ));
  408.     return ( ErrCode );
  410. } /* end wts_FLASH_Term */
  412. /*-------------------------------------------------------------------------
  413.  * Function : wts_FLASH_SetupBlockInfo
  414.  *            Setup Block Info structure
  415.  * Input    :
  416.  * Output   :
  417.  * Return   : Error Code
  418.  * ----------------------------------------------------------------------*/
  419. ST_ErrorCode_t wts_FLASH_SetupBlockInfo( void )
  420. {
  421.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  422.     STFLASH_Params_t    FLASHParams;
  423.     U8  Bank=0, Block=0;
  424.     U32 BlockStart = 0;
  425.     static U8 Section = 0;
  426.     
  427.     memset((char*)&FLASHParams,0,sizeof(STFLASH_Params_t));
  429.     if ( Section == 0 )
  430.     {
  431.         /*
  432.         **  Set the address for each section
  433.         */
  434.         for ( Bank = 0; ( Bank < NUM_BANKS ) && ( ErrCode == ST_NO_ERROR ); Bank ++ )
  435.         {
  436.             ErrCode = wts_FLASH_Init( Bank );                /* Init Bank */
  437.             if ( ErrCode == ST_NO_ERROR )
  438.             {
  439.                 ErrCode = wts_FLASH_Open( Bank );
  440.                 if ( ErrCode == ST_NO_ERROR )
  441.                     ErrCode = wts_FLASH_GetParams( Bank, &FLASHParams );
  443.                 if ( ErrCode == ST_NO_ERROR )
  444.                 {
  445.                     BlockStart = BaseAddress[Bank] = (U32) FLASHParams.InitParams.BaseAddress;
  446.                     for ( Block = 0; Block < FLASHParams.InitParams.NumberOfBlocks; Block ++)
  447.                     {
  448.                         BlockInfo[Section].Bank    = Bank;
  449.                         BlockInfo[Section].Address = BlockStart;
  450.                         BlockInfo[Section].Length  = FLASHParams.InitParams.Blocks[Block].Length;
  451.                         #ifdef DEBUG_OUTPUT
  452.                             STTBX_Print(("Block %2d (%d) 0x%08x 0x%08x (%6d) bytesn",
  453.                                          Block, Section,
  454.                                          BlockInfo[Section].Address,
  455.                                          BlockInfo[Section].Length,
  456.                                          BlockInfo[Section].Length ));
  457.                         #endif
  458.                         Section ++;
  459.                         BlockStart += FLASHParams.InitParams.Blocks[Block].Length;
  460.                     }
  461.                 }
  462.                 ErrCode = wts_FLASH_Term( TRUE, Bank );
  463.             }
  464.         }
  465.         BlockInfo[Section].Address = BlockStart;
  466.     }
  468.     if ( ErrCode == ST_NO_ERROR )
  469.         STTBX_Print(("Flash setup Ok (%d blocks)n", Section ));
  471.     return( ErrCode );
  473. } /* end of wts_FLASH_SetupBlockInfo */
  475. /*-------------------------------------------------------------------------
  476.  * Function : wts_FLASH_Setup
  477.  *            Setup Block Info structure
  478.  * Input    :
  479.  * Output   :
  480.  * Return   : Error Code
  481.  * ----------------------------------------------------------------------*/
  482. ST_ErrorCode_t wts_FLASH_Setup( void )
  483. {
  484.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  485.     U8  Bank;
  486.     
  487.     /*    **  Set the address for each section*/
  488.        
  489.         for ( Bank = 0; ( Bank < NUM_BANKS ) && ( ErrCode == ST_NO_ERROR ); Bank ++ )
  490.         {
  491.             ErrCode = wts_FLASH_Init( Bank );                /* Init Bank */
  492.             if ( ErrCode == ST_NO_ERROR )
  493.             {
  494.                 ErrCode = wts_FLASH_Open( Bank );
  495.             }
  496.             if ( ErrCode == ST_NO_ERROR )
  497.             STTBX_Print(("Flash setup Ok.....n" ));        
  498.         }
  499.     return( ErrCode );
  501. } /* end of Flash_Setup */
  503. /*-------------------------------------------------------------------------
  504.  * Function : wts_FreeFileDataBuffer
  505.  *            as is
  506.  * Input    :
  507.  * Output   :
  508.  * Return   : None
  509.  * ----------------------------------------------------------------------*/
  510. static void wts_FreeFileDataBuffer(void)
  511. {
  512.     /* deallocate File data buffer */
  513.     if ( FlashData_p != NULL )
  514.         memory_deallocate( SystemPartition, FlashData_p );
  516. } /* end of wts_FreeFileDataBuffer() */
  518. /*-------------------------------------------------------------------------
  519.  * Function : wts_GetBlockNumber
  520.  *            Get block number from address
  521.  * Input    :
  522.  * Output   :
  523.  * Return   : Block number of address
  524.  * ----------------------------------------------------------------------*/
  525. static U8 wts_GetBlockNumber( U32 Address )
  526. {
  527.     U8  Block;
  529.     /* find the block this address is in */
  530.     for ( Block = 0; Block < TOTAL_BLOCKS; Block++ )
  531.     {
  532.         if (( Address >= BlockInfo[Block].Address ) &&
  533.             ( Address < (BlockInfo[Block].Address+BlockInfo[Block].Length)))
  534.         {
  535.             break;
  536.         }
  537.     }
  538.     return Block;
  540. } /* end wts_GetBlockNumber */
  542. /*-------------------------------------------------------------------------
  543.  * Function : wts_ConvertTotalMemory
  544.  *            Convert Raw Hex file into memory buffer suitable to write to
  545.  *            flash copying created data over data read from filem, the
  546.  *            created data will be smaller as each byte takes three bytes
  547.  *            in the Hex file.
  548.  * Input    :
  549.  * Output   :
  550.  * Return   : size of data in buffer
  551.  * ----------------------------------------------------------------------*/
  552. static U32 wts_ConvertTotalMemory( long unsigned int MemSize )
  553. {
  554.     char                *OldPtr, *NewPtr;
  555.     int                 Section;
  556.     U32                 InOffset;
  557.     U32                 OutOffset;
  558.     U32                 BlockOffset;
  559.     U32                 Value=0;
  560.     U8                  Count=0 , Block=0;
  561.     
  562.     for ( Section = 0; Section < NUM_BLOCKS; Section ++ )
  563.     {
  564.         SectionInfo[Section].Block = 0xff;
  565.         SectionInfo[Section].Address = 0;
  566.         SectionInfo[Section].Offset = 0;
  567.         SectionInfo[Section].Size = 0;
  568.     }
  570.     /* Convert File */
  572.     Section = 0;
  573.     OldPtr = FlashData_p;
  574.     NewPtr = (char*) NULL;
  575.     
  576.     for ( InOffset = 0, OutOffset = 0; InOffset < MemSize; )
  577.     {
  578.         /* Line format =
  579.         ** Address  Data  (both in hex)
  580.         ** 12345678 11 22 33 44 55 etc. CR/LF
  581.         */
  582.         Value = (U32) strtol( OldPtr, &NewPtr, 16 );
  583.         if ( NewPtr != OldPtr ) /* if conversion possible */
  584.         {
  585.             
  586.                 BlockOffset = OutOffset;
  587.                 for ( Count = 0; Count < Section; Count++ )
  588.                     BlockOffset -= SectionInfo[Count].Size;
  590.                 if (( BlockOffset+1 ) > BlockInfo[SectionInfo[Section].Block].Length )
  591.                 {
  592.                     Section++;
  593.                 }
  595.                 /* Start New Block */
  596.                 if ( SectionInfo[Section].Block == 0xff )
  597.                 {
  598.                     SectionInfo[Section].Address = BlockInfo[Block].Address + BlockOffset;
  599.                     SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  600.                     SectionInfo[Section].Offset = OutOffset;
  601.                     SectionInfo[Section].Size = 0;
  602.                 }
  604.                 SectionInfo[Section].Size ++;
  605.                 FlashData_p[OutOffset++] = (char) Value;
  607.             InOffset += (U32)( NewPtr - OldPtr );
  608.             OldPtr = NewPtr;
  610.             if ( Section > NUM_BLOCKS )
  611.             {
  612.                 STTBX_Print(("Program Limitationn"));
  613.                 exit(0);
  614.             }
  616.        }
  617.         else
  618.             break;
  619.     } /* end of for loop */
  621.     STTBX_Print(("n"));
  622.     /* display the first few bytes of each section */
  623.     for ( Section = 0; Section < NUM_BLOCKS; Section ++ )
  624.     {
  625.         if ( SectionInfo[Section].Block != 0xFF )
  626.         {
  627.             STTBX_Print(("Section %2d, Block %3d, Addr 0x%08x, Offset 0x%08x, Size %6dn",
  628.                          Section,
  629.                          SectionInfo[Section].Block,
  630.                          SectionInfo[Section].Address,
  631.                          SectionInfo[Section].Offset,
  632.                          SectionInfo[Section].Size ));
  634.             #ifdef DEBUG_INFO
  635.                 for ( InOffset = 0;
  636.                       ( InOffset < 32 ) && ( InOffset < SectionInfo[Section].Size );
  637.                       InOffset ++ )
  638.                 {
  639.                     STTBX_Print((" %02x", FlashData_p[ SectionInfo[Section].Offset + InOffset ] ));
  640.                 }
  641.                 STTBX_Print(("n"));
  642.             #endif
  643.         }
  644.     }
  645.     return ( OutOffset );
  647. } /* end wts_ConvertTotalMemory */
  649. /*-------------------------------------------------------------------------
  650.  * Function : wts_ConvertMemory
  651.  *            Convert Raw Hex file into memory buffer suitable to write to
  652.  *            flash copying created data over data read from filem, the
  653.  *            created data will be smaller as each byte takes three bytes
  654.  *            in the Hex file.
  655.  * Input    :
  656.  * Output   :
  657.  * Return   : size of data in buffer
  658.  * ----------------------------------------------------------------------*/
  659. static U32 wts_ConvertMemory( long unsigned int MemSize )
  660. {
  661.     char                *OldPtr, *NewPtr;
  662.     int                 Section;
  663.     U32                 InOffset;
  664.     U32                 OutOffset;
  665.     U32                 BlockOffset;
  666.     U32                 Value=0;
  667.     U8                  Count=0 , Block=0;
  668.     
  669.     for ( Section = 0; Section < NUM_SECTIONS; Section ++ )
  670.     {
  671.         SectionInfo[Section].Block = 0xff;
  672.         SectionInfo[Section].Address = 0;
  673.         SectionInfo[Section].Offset = 0;
  674.         SectionInfo[Section].Size = 0;
  675.     }
  677.     /* Convert File */
  679. /*ray    Section = 0;*/
  680.     Section = 0;
  681.     OldPtr = FlashData_p;
  682.     NewPtr = (char*) NULL;
  683.     
  684.     for ( InOffset = 0, OutOffset = 0; InOffset < MemSize; )
  685.     {
  686.         /* Line format =
  687.         ** Address  Data  (both in hex)
  688.         ** 12345678 11 22 33 44 55 etc. CR/LF
  689.         */
  690.         Value = (U32) strtol( OldPtr, &NewPtr, 16 );
  691.         if ( NewPtr != OldPtr ) /* if conversion possible */
  692.         {
  693.             if ( Value > 255 )  /* which means it is an address */
  694.             {
  695.                 if (( Block = wts_GetBlockNumber( Value )) == TOTAL_BLOCKS )/*changed temp*/
  696.                 {
  697.                     STTBX_Print(("Invalid address 0x%xn", Value ));
  698.                     break;
  699.                 }
  700.                 else
  701.                 {
  702.                     /*
  703.                     ** check if the address is non-contiguous
  704.                     ** or if it is a new block
  705.                     */
  706.                     if ((( SectionInfo[Section].Address + SectionInfo[Section].Size ) != Value ) ||
  707.                         ( SectionInfo[Section].Block != Block ))
  708.                     {
  709.                         Section ++;
  710.                     }
  712.                     /* Start New Block */
  713.                     if ( SectionInfo[Section].Block == 0xff )
  714.                     {
  715.                         SectionInfo[Section].Address = Value;
  716.                         SectionInfo[Section].Block = Block;
  717.                         SectionInfo[Section].Offset = OutOffset;
  718.                         SectionInfo[Section].Size = 0;
  719.                     }
  720.                 }
  721.             }
  722.             else
  723.             {
  724.                 BlockOffset = OutOffset;
  725.                 for ( Count = 0; Count < Section; Count++ )
  726.                     BlockOffset -= SectionInfo[Count].Size;
  728.                 if (( BlockOffset+1 ) > BlockInfo[SectionInfo[Section].Block].Length )
  729.                 {
  730.                     Section++;
  731.                 }
  733.                 /* Start New Block */
  734.                 if ( SectionInfo[Section].Block == 0xff )
  735.                 {
  736.                     SectionInfo[Section].Address = BlockInfo[Block].Address + BlockOffset;
  737.                     SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  738.                     SectionInfo[Section].Offset = OutOffset;
  739.                     SectionInfo[Section].Size = 0;
  740.                 }
  742.                 SectionInfo[Section].Size ++;
  743.                 FlashData_p[OutOffset++] = (char) Value;
  744.              }
  746.             InOffset += (U32)( NewPtr - OldPtr );
  747.             OldPtr = NewPtr;
  749.             if ( Section > NUM_SECTIONS )
  750.             {
  751.                 STTBX_Print(("Program Limitationn"));
  752.                 exit(0);
  753.             }
  755.        }
  756.         else
  757.             break;
  758.     } /* end of for loop */
  760.     STTBX_Print(("n"));
  762.     /* display the first few bytes of each section */
  763.     for ( Section = 0; Section < NUM_SECTIONS; Section ++ )
  764.     {
  765.         if ( SectionInfo[Section].Block != 0xFF )
  766.         {
  767.             STTBX_Print(("Section %2d, Block %3d, Addr 0x%08x, Offset 0x%08x, Size %6dn",
  768.                          Section,
  769.                          SectionInfo[Section].Block,
  770.                          SectionInfo[Section].Address,
  771.                          SectionInfo[Section].Offset,
  772.                          SectionInfo[Section].Size ));
  774.             #ifdef DEBUG_INFO
  775.                 for ( InOffset = 0;
  776.                       ( InOffset < 32 ) && ( InOffset < SectionInfo[Section].Size );
  777.                       InOffset ++ )
  778.                 {
  779.                     STTBX_Print((" %02x", FlashData_p[ SectionInfo[Section].Offset + InOffset ] ));
  780.                 }
  781.                 STTBX_Print(("n"));
  782.             #endif
  783.         }
  784.     }
  785.     return ( OutOffset );
  787. } /* end wts_ConvertMemory */
  790. /*-------------------------------------------------------------------------
  791.  * Function : wts_ConvertMemory
  792.  *            Convert Raw Hex file into memory buffer suitable to write to
  793.  *            flash copying created data over data read from filem, the
  794.  *            created data will be smaller as each byte takes three bytes
  795.  *            in the Hex file.
  796.  * Input    :
  797.  * Output   :
  798.  * Return   : size of data in buffer
  799.  * ----------------------------------------------------------------------*/
  800. static U32 wts_BinConvertMemory( long unsigned int MemSize )
  801. {
  802.     char                *OldPtr, *NewPtr;
  803.     int                 Section;
  804.     U32                 InOffset;
  805.     U32                 OutOffset;
  806.     U32                 BlockOffset;
  807.     U32                 Value=0;
  808.     U8                  Count=0 , Block=0;
  809.     
  810.     for ( Section = 0; Section < NUM_SECTIONS; Section ++ )
  811.     {
  812.         SectionInfo[Section].Block = 0xff;
  813.         SectionInfo[Section].Address = 0;
  814.         SectionInfo[Section].Offset = 0;
  815.         SectionInfo[Section].Size = 0;
  816.     }
  818.     /* Convert File */
  820. /*ray    Section = 0;*/
  821.     Section = 0;
  822.     OldPtr = FlashData_p;
  823.     NewPtr = (char*) NULL;
  824.     
  825.     for ( InOffset = 0, OutOffset = 0; InOffset < MemSize; )
  826.     {
  827.                 BlockOffset = OutOffset;
  828.                 for ( Count = 0; Count < Section; Count++ )
  829.                     BlockOffset -= SectionInfo[Count].Size;
  831.                 if (( BlockOffset+1 ) > BlockInfo[SectionInfo[Section].Block].Length )
  832.                 {
  833.                     Section++;
  834.                 }
  836.                 /* Start New Block */
  837.                 if ( SectionInfo[Section].Block == 0xff )
  838.                 {
  839.                     SectionInfo[Section].Address = BlockInfo[Block].Address + BlockOffset;
  840.                     SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  841.                     SectionInfo[Section].Offset = OutOffset;
  842.                     SectionInfo[Section].Size = 0;
  843.                 }
  845.                 SectionInfo[Section].Size ++;
  846.                 FlashData_p[OutOffset++] = (char) Value;
  848.             InOffset += (U32)STFLASH_MAIN00_SIZE; /*( NewPtr - OldPtr );*/
  849.             OldPtr = NewPtr;
  851.             if ( Section > NUM_SECTIONS )
  852.             {
  853.                 STTBX_Print(("Program Limitationn"));
  854.                 exit(0);
  855.             }
  857.     } /* end of for loop */
  859.     STTBX_Print(("n"));
  861.     /* display the first few bytes of each section */
  862.     for ( Section = 0; Section < NUM_SECTIONS; Section ++ )
  863.     {
  864.         if ( SectionInfo[Section].Block != 0xFF )
  865.         {
  866.             STTBX_Print(("Section %2d, Block %3d, Addr 0x%08x, Offset 0x%08x, Size %6dn",
  867.                          Section,
  868.                          SectionInfo[Section].Block,
  869.                          SectionInfo[Section].Address,
  870.                          SectionInfo[Section].Offset,
  871.                          SectionInfo[Section].Size ));
  873.             #ifdef DEBUG_INFO
  874.                 for ( InOffset = 0;
  875.                       ( InOffset < 32 ) && ( InOffset < SectionInfo[Section].Size );
  876.                       InOffset ++ )
  877.                 {
  878.                     STTBX_Print((" %02x", FlashData_p[ SectionInfo[Section].Offset + InOffset ] ));
  879.                 }
  880.                 STTBX_Print(("n"));
  881.             #endif
  882.         }
  883.     }
  884.     return ( OutOffset );
  886. } /* end wts_ConvertMemory */
  888. #if 0 /*def rayf*/
  890. /*-------------------------------------------------------------------------
  891.  * Function : ReadFile
  892.  *            Read HEX file into memory
  893.  * Input    :
  894.  * Output   :
  895.  * Return   : File size
  896.  * ----------------------------------------------------------------------*/
  897. U32 wts_FLASH_ReadFile( char *Filename )
  898. {
  899. long int    ReadFile_p=0;            /* datafile descriptor          */
  900. long int    FileSize=0;          /* size in bytes of the file    */
  901. int            nameLength ;
  903.   nameLength = strlen( Filename ) ;
  904.   if (Filename[nameLength-1]=='n' &&
  905.     Filename[nameLength-2]=='i' &&
  906.     Filename[nameLength-3]=='b' &&
  907.     Filename[nameLength-4]=='.' ) {
  908.     binFile = TRUE ;
  909.   } else {
  910.     binFile = FALSE ;
  911.   }
  913.     /* Open and Read file into memory */
  914.     ReadFile_p = debugopen(Filename, "rb");
  915.     STTBX_Print(("ReadFile_p = 0x%8xn",ReadFile_p));
  916.     
  917.     if(ReadFile_p < 0)
  918.     {
  919.         STTBX_Print(("Error opening file '%s'n", Filename ));
  920.         return (0);
  921.     }
  922.     else
  923.     {
  924.         FileSize = debugfilesize(ReadFile_p);
  925.         STTBX_Print(("FileSize = 0x%8xn",FileSize));
  926.         /* allocate File data buffer */
  927.         wts_FreeFileDataBuffer();
  928.         FlashData_p = (char*) memory_allocate( SystemPartition, (U32) FileSize );
  929.         if ( FlashData_p != NULL )
  930.         {
  931.             STTBX_Print(("Loading '%s' into memory, wait .. ", Filename ));
  932.             debugread(ReadFile_p, FlashData_p, (size_t) FileSize);
  933.             STTBX_Print(("%d bytesn", FileSize ));
  934.         }
  935.         else
  936.         {
  937.             STTBX_Print(("Not enough memory for HEX file (%d bytes)n", FileSize));
  938.             FileSize = 0;
  939.         }
  941.         debugclose(ReadFile_p);
  942.     }
  944.     if ( FileSize > 0 )
  945.     {
  946.         /* convert buffer to binary and resize memory */
  947.         STTBX_Print(("Converting file in memory, wait .. "));
  949. if(binFile)
  950. FlashSize = (U32)FileSize;
  951. else
  952. FlashSize = wts_ConvertMemory( FileSize );
  954.         if ( FlashSize > 0 )
  955.         {
  956.             STTBX_Print(("%d bytesn", FlashSize ));
  957.             FlashData_p = (char*) memory_reallocate( SystemPartition, FlashData_p, FlashSize );
  958.         }
  959.         else
  960.             STTBX_Print(("Invalid filen"));
  961.     }
  963.     return( FlashSize );
  965. } /* end of wts_FLASH_ReadFile */
  967. #else
  969. /*-------------------------------------------------------------------------
  970.  * Function : ReadFile
  971.  *            Read HEX file into memory
  972.  * Input    :
  973.  * Output   :
  974.  * Return   : File size
  975.  * ----------------------------------------------------------------------*/
  976. U32 wts_FLASH_ReadFile( char *Filename )
  977. {
  978.     long int    HexFile_p=0;            /* datafile descriptor          */
  979.     long int    HexFileSize=0;          /* size in bytes of the file    */
  981.     /* Open and Read file into memory */
  982.     HexFile_p = debugopen(Filename, "rb");
  983.     STTBX_Print(("HexFile_p = 0x%8xn",HexFile_p));
  984.     
  985.     if(HexFile_p < 0)
  986.     {
  987.         STTBX_Print(("Error opening file '%s'n", Filename ));
  988.         return (0);
  989.     }
  990.     else
  991.     {
  992.         HexFileSize = debugfilesize(HexFile_p);
  993.         STTBX_Print(("HexFileSize = 0x%8xn",HexFileSize));
  994.         /* allocate File data buffer */
  995.         wts_FreeFileDataBuffer();
  996.         FlashData_p = (char*) memory_allocate( SystemPartition, (U32) HexFileSize );
  997.         if ( FlashData_p != NULL )
  998.         {
  999.             STTBX_Print(("Loading '%s' into memory, wait .. ", Filename ));
  1000.             debugread(HexFile_p, FlashData_p, (size_t) HexFileSize);
  1001.             STTBX_Print(("%d bytesn", HexFileSize ));
  1002.         }
  1003.         else
  1004.         {
  1005.             STTBX_Print(("Not enough memory for HEX file (%d bytes)n", HexFileSize));
  1006.             HexFileSize = 0;
  1007.         }
  1009.         debugclose(HexFile_p);
  1010.     }
  1012.     if ( HexFileSize > 0 )
  1013.     {
  1014.         /* convert buffer to binary and resize memory */
  1015.         STTBX_Print(("Converting file in memory, wait .. "));
  1016.         FlashSize = wts_ConvertMemory( HexFileSize );
  1017.         if ( FlashSize > 0 )
  1018.         {
  1019.             STTBX_Print(("%d bytesn", FlashSize ));
  1020.             FlashData_p = (char*) memory_reallocate( SystemPartition, FlashData_p, FlashSize );
  1021.         }
  1022.         else
  1023.             STTBX_Print(("Invalid filen"));
  1024.     }
  1026.     return( FlashSize );
  1028. } /* end of wts_FLASH_ReadFile */
  1029. #endif
  1031. /*-------------------------------------------------------------------------
  1032.  * Function : wts_EraseFlash
  1033.  *            Function to Read Hex file and erase areas required
  1034.  * Input    : EraseAll 
  1035.  * Output   :
  1036.  * Return   : EraseFailed = TRUE else FALSE
  1037.  * ----------------------------------------------------------------------*/
  1038. BOOL wts_EraseFlash( BOOL EraseAll )
  1039. {
  1040.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1041.     U8   Section, Bank;
  1042.     U32  EraseOffset;
  1043.     BOOL EraseFailed = TRUE;
  1045.     /* check data size */
  1046.     if (( FlashSize != 0 ) || EraseAll )
  1047.     {
  1048.         EraseFailed = FALSE;
  1049.         STTBX_Print(("tt+------------+------------+n"));
  1051.         if ( EraseAll )
  1052.         {
  1053.             for ( /*Section = 0*/Section = 0;( Section < TOTAL_BLOCKS ) && ( ErrCode == ST_NO_ERROR ); Section ++)
  1054.             {
  1055.                 Bank = BlockInfo[Section].Bank;
  1056.                 EraseOffset = BlockInfo[Section].Address - BaseAddress[Bank];
  1057.                 STTBX_Print(("%d block %2dt| 0x%08x | 0x%08x | ",
  1058.                              Bank, Section,
  1059.                              BlockInfo[Section].Address,
  1060.                              BlockInfo[Section].Address + BlockInfo[Section].Length - 1 ));
  1062.                 ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1063.                                          EraseOffset,
  1064.                                          BlockInfo[Section].Length );
  1065.                 if ( ErrCode != ST_NO_ERROR )
  1066.                 {
  1067.                     STTBX_Print(("Erase FAILEDn"));
  1068.                     EraseFailed = TRUE;
  1069.                 }
  1070.                 else
  1071.                     STTBX_Print(("ERASEDn"));
  1072.             }
  1073.         }
  1074.         else
  1075.         {
  1076.             /* Find out which blocks are to be Erased */
  1078.             for ( /*Section = 0*/Section = 0; ( Section < NUM_SECTIONS ) && ( EraseFailed == FALSE ); Section ++ )
  1079.             {
  1080.                 if ( SectionInfo[Section].Block != 0xFF )
  1081.                 {
  1082.                     /*
  1083.                     ** Erase = erase whole block, valid parameters are block base address & block size
  1084.                     */
  1085.                     Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  1086.                     EraseOffset = BlockInfo[ SectionInfo[Section].Block ].Address - BaseAddress[Bank];
  1088.                     STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  1089.                                  SectionInfo[Section].Block,
  1090.                                  BlockInfo[ SectionInfo[Section].Block ].Address,
  1091.                                  BlockInfo[ SectionInfo[Section].Block ].Address +
  1092.                                  BlockInfo[ SectionInfo[Section].Block ].Length - 1 ));
  1093.                                  
  1094.                     ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1095.                                              EraseOffset,
  1096.                                              BlockInfo[ SectionInfo[Section].Block ].Length );
  1098.                     if ( ErrCode != ST_NO_ERROR )
  1099.                     {
  1100.                         STTBX_Print(("ErrCode = 0x%8xn",ErrCode));
  1101.                         STTBX_Print(("Erase FAILEDn"));
  1102.                         STTBX_Print(("wts_FLASHHndl[Bank] = 0x%8Xn",wts_FLASHHndl[Bank]));
  1103.                         EraseFailed = TRUE;
  1104.                     }
  1105.                     else
  1106.                         STTBX_Print(("ERASEDn"));
  1107.                 }
  1108.             }
  1109.         }
  1110.         STTBX_Print(("tt+------------+------------+n"));
  1111.     }
  1113.     if ( EraseFailed == TRUE )
  1114.     {
  1115.         wts_FreeFileDataBuffer();
  1116.         STTBX_Print(("!!!! ERASE Failed !!!!n"));
  1117.         return TRUE;
  1118.     }
  1120.     return EraseFailed;
  1122. } /* end wts_ProgramFlash */
  1124. /*-------------------------------------------------------------------------
  1125.  * Function : wts_ProgramFlash
  1126.  *            Function to Read Hex file and program flash with contents
  1127.  * Input    :
  1128.  * Output   :
  1129.  * Return   : None
  1130.  * ----------------------------------------------------------------------*/
  1131. BOOL wts_ProgramFlash( void )
  1132. {
  1133.     ST_ErrorCode_t      ErrCode;
  1134.     int                 Section, Bank;
  1135.     U32                 NumberOfBytes;
  1136.     BOOL                ProgramFailed;
  1138.     /* check data size */
  1139.     if ( FlashSize == 0 )
  1140.         ProgramFailed = TRUE;
  1141.     else
  1142.     {
  1143.         ProgramFailed = FALSE;
  1144.         STTBX_Print(("tt+------------+------------+n"));
  1145.     }
  1147.     /* Find out which blocks are to be written to */
  1148.     /* Write the data to the Flash */
  1149.     /*STTBX_Print(("Printing the contents of BlockInfo n"));
  1150.     for ( Section = 0; ( Section < NUM_SECTIONS ) ; Section ++ )
  1151.     {
  1152.         STTBX_Print(("Section=%dt", Section ));
  1153.         STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  1154.         STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  1155.         STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  1156.     }*/
  1158.     for ( Section = 0; ( Section < NUM_SECTIONS ) && ( ProgramFailed == FALSE ); Section ++ )
  1159.     {
  1160.         if ( SectionInfo[Section].Block != 0xFF )
  1161.         {
  1162.             U32  WriteOffset;
  1164.             /*
  1165.             ** Write = write bytes from Offset
  1166.             */
  1167.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  1168.             STTBX_Print(("Section=%dt", Section ));
  1169.             STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  1170.             STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  1171.             STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  1172.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  1173.             /*SectionInfo[Section].Address += 0x4; Tara*/
  1174.             STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  1175.                          SectionInfo[Section].Block,
  1176.                          SectionInfo[Section].Address,
  1177.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  1179.             ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  1180.                                      WriteOffset,
  1181.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  1182.                                      SectionInfo[Section].Size,
  1183.                                      &NumberOfBytes );
  1185.             if ( ErrCode != ST_NO_ERROR )
  1186.             {
  1187.                 STTBX_Print(("Program FAILEDn"));
  1188.                 ProgramFailed = TRUE;
  1189.             }
  1190.             else
  1191.                 STTBX_Print(("PROGRAMMEDn"));
  1192.         }
  1193.     }
  1195.     if ( ProgramFailed == TRUE )
  1196.     {
  1197.         wts_FreeFileDataBuffer();
  1198.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  1199.         return TRUE;
  1200.     }
  1201.     else
  1202.     {
  1203.         STTBX_Print(("tt+------------+------------+n"));
  1204.         return FALSE;
  1205.     }
  1207. } /* end wts_ProgramFlash */
  1210. /*-------------------------------------------------------------------------
  1211.  * Function : wts_ProgramFlash
  1212.  *            Function to Read Hex file and program flash with contents
  1213.  * Input    :
  1214.  * Output   :
  1215.  * Return   : None
  1216.  * ----------------------------------------------------------------------*/
  1217. BOOL wts_BinProgramFlash( void )
  1218. {
  1219.     ST_ErrorCode_t      ErrCode;
  1220.     int                 Section, Bank=0;
  1221.     U32                 NumberOfBytes;
  1222.     BOOL                ProgramFailed;
  1224. U32 FlashOffset=0;
  1226.     /* check data size */
  1227.     if ( FlashSize == 0 )
  1228.         ProgramFailed = TRUE;
  1229.     else
  1230.     {
  1231.         ProgramFailed = FALSE;
  1232.         STTBX_Print(("tt+------------+------------+n"));
  1233.     }
  1235. if(binFile){
  1237. ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  1238.                                      FlashOffset,
  1239.                                      (U8*)&FlashData_p,
  1240.                                      FlashSize,
  1241.                                      &NumberOfBytes );
  1243.             if ( ErrCode != ST_NO_ERROR )
  1244.             {
  1245.                 STTBX_Print(("Program FAILEDn"));
  1246.                 ProgramFailed = TRUE;
  1247.             }
  1248.             else
  1249.                 STTBX_Print(("PROGRAMMEDn"));
  1251. }
  1252. else{
  1254.     for ( Section = 0; ( Section < NUM_SECTIONS ) && ( ProgramFailed == FALSE ); Section ++ )
  1255.     {
  1256.         if ( SectionInfo[Section].Block != 0xFF )
  1257.         {
  1258.             U32  WriteOffset;
  1260.             /*
  1261.             ** Write = write bytes from Offset
  1262.             */
  1263.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  1264.             STTBX_Print(("Section=%dt", Section ));
  1265.             STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  1266.             STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  1267.             STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  1268.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  1269.             /*SectionInfo[Section].Address += 0x4; Tara*/
  1270.             STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  1271.                          SectionInfo[Section].Block,
  1272.                          SectionInfo[Section].Address,
  1273.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  1275.             ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  1276.                                      WriteOffset,
  1277.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  1278.                                      SectionInfo[Section].Size,
  1279.                                      &NumberOfBytes );
  1281.             if ( ErrCode != ST_NO_ERROR )
  1282.             {
  1283.                 STTBX_Print(("Program FAILEDn"));
  1284.                 ProgramFailed = TRUE;
  1285.             }
  1286.             else
  1287.                 STTBX_Print(("PROGRAMMEDn"));
  1288.         }
  1289.     }
  1290. }
  1292.     if ( ProgramFailed == TRUE )
  1293.     {
  1294.         wts_FreeFileDataBuffer();
  1295.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  1296.         return TRUE;
  1297.     }
  1298.     else
  1299.     {
  1300.         STTBX_Print(("tt+------------+------------+n"));
  1301.         return FALSE;
  1302.     }
  1304. } /* end wts_ProgramFlash */
  1306. /*-------------------------------------------------------------------------
  1307.  * Function : wts_VerifyFlash
  1308.  *            Function to Read Hex file and verify flash with contents
  1309.  * Input    :
  1310.  * Output   :
  1311.  * Return   : None
  1312.  * ----------------------------------------------------------------------*/
  1313. BOOL wts_VerifyFlash( void )
  1314. {
  1315.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  1316.     int                 Section, Bank;
  1317.     U32                 Length;
  1318.     U32                 ReadOffset;
  1319.     U32                 NumberOfBytes;
  1320.     U8                  *Buffer_p;
  1321.     BOOL                VerifyFailed;
  1323.     /* check data size */
  1324.     if ( FlashSize == 0 )
  1325.         VerifyFailed = TRUE;
  1326.     else
  1327.     {
  1328.         VerifyFailed = FALSE;
  1329.         STTBX_Print(("tt+------------+------------+n"));
  1330.     }
  1332.     /* Find out which blocks are to be verified */
  1333.     /* Read the data and compare */
  1335.     for ( /*Section = 0*/Section = 0; ( Section < NUM_SECTIONS ) && ( VerifyFailed == FALSE ); Section ++ )
  1336.     {
  1337.         if ( SectionInfo[Section].Block != 0xFF )
  1338.         {
  1339.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  1340.             Length = BlockInfo[ SectionInfo[Section].Block ].Length;
  1341.             ReadOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  1343.             /* allocate temp buffer to put flash data in */
  1344.             Buffer_p = memory_allocate( SystemPartition, Length );
  1345.             if ( Buffer_p != NULL )
  1346.             {
  1347.                 STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  1348.                          SectionInfo[Section].Block,
  1349.                          SectionInfo[Section].Address,
  1350.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  1352.                 ErrCode = STFLASH_Read( wts_FLASHHndl[Bank],
  1353.                                         ReadOffset,
  1354.                                         Buffer_p,
  1355.                                         SectionInfo[Section].Size,
  1356.                                         &NumberOfBytes );
  1357.                 if(ErrCode != ST_NO_ERROR)
  1358.                 {
  1359.                     STTBX_Print(("STFLASH_Read %sn",wts_GetErrorText(ErrCode)));
  1360.                 }
  1362.                 if ( memcmp( Buffer_p,(U8*)&FlashData_p[SectionInfo[Section].Offset],
  1363.                              SectionInfo[Section].Size ) != 0 )
  1364.                 {
  1365.                     STTBX_Print(("Verify FAILEDn"));
  1366.                     VerifyFailed = TRUE;
  1367.                 }
  1368.                 else
  1369.                     STTBX_Print(("VERIFIEDn"));
  1371.                 /* deallocate temp buffer */
  1372.                 memory_deallocate( SystemPartition, Buffer_p );
  1373.             }
  1374.         }
  1375.     }
  1377.     wts_FreeFileDataBuffer();
  1378.     
  1379.     if ( VerifyFailed == TRUE )
  1380.     {
  1381.         STTBX_Print(("!!!! VERIFY Failed !!!!n"));
  1382.         return TRUE;
  1383.     }
  1384.     else
  1385.     {
  1386.         STTBX_Print(("tt+------------+------------+n"));
  1387.         return FALSE;
  1388.     }
  1390. } /* end wts_VerifyFlash */
  1393. #ifdef rayf
  1395. BOOL wts_ReadProgram(char *Filename ,U32 StartAddress ,U32 Length )
  1396. {
  1397.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  1398.     int                 Section, Bank;
  1399.     U32                 ReadOffset;
  1400.     U32                 NumberOfBytes;
  1401.     U8                  *Buffer_p;
  1402.     int            nameLength,numBytes ;
  1403.     long int    ReadFile_p=0;            /* datafile descriptor          */
  1405.   volatile char    *ptr_to_m;
  1407.   nameLength = strlen( Filename ) ;
  1408.   if (Filename[nameLength-1]=='n' &&
  1409.     Filename[nameLength-2]=='i' &&
  1410.     Filename[nameLength-3]=='b' &&
  1411.     Filename[nameLength-4]=='.' ) {
  1412.     binFile = TRUE ;
  1413.     ReadFile_p = debugopen(Filename, "wb");
  1414.   } else {
  1415.    Filename[nameLength  ]= '.' ;
  1416.     Filename[nameLength+1]= 'b' ;
  1417.     Filename[nameLength+2]= 'i' ;
  1418.     Filename[nameLength+3]= 'n' ;
  1419.     binFile = FALSE ;
  1420.     ReadFile_p = debugopen(Filename, "wb");
  1421.   }
  1422.   if (ReadFile_p<=0) {
  1423.         STTBX_Print(("nCannot Create data file '%s'n", Filename ));
  1424.         return FALSE;
  1425.   }
  1428.     /* Read the data and compare */
  1430.             Bank = BlockInfo[ SectionInfo[0].Block ].Bank;
  1431.             ReadOffset = StartAddress - BaseAddress[Bank];
  1433.             /* allocate temp buffer to put flash data in */
  1434.             Buffer_p = memory_allocate( SystemPartition, Length );
  1435.             if ( Buffer_p != NULL )
  1436.             {
  1437.                 STTBX_Print(("Address t| 0x%08x | 0x%08x |ReadOffset = 0x%08x |n ",
  1438.                          StartAddress,
  1439.                          StartAddress + Length-1,
  1440.                          ReadOffset));
  1441.                 ErrCode = STFLASH_Read( wts_FLASHHndl[Bank],
  1442.                                         ReadOffset,
  1443.                                         Buffer_p,
  1444.                                         Length,
  1445.                                         &NumberOfBytes );
  1446.                 if(ErrCode != ST_NO_ERROR)
  1447.                 {
  1448.                     STTBX_Print(("STFLASH_Read %sn",wts_GetErrorText(ErrCode)));
  1449.                     return FALSE;
  1450.                 }
  1452.          numBytes = (int) debugwrite( (long int)ReadFile_p, (void*)Buffer_p, Length);
  1453.                STTBX_Print(("write file size  = %d bytesn", numBytes ));
  1454. #if 0
  1455.   /* ===================== check whether array is erased================== */
  1457.   ptr_to_m = (char *)0x40000000;           /* point to lowest _add in FlashROM     */
  1458.   *ptr_to_m = (char) 0xf0f0;         /* read_array command                   */
  1460.     for(ptr_to_m = (char *)0x40000000;      /* point to flash_start and change type */
  1461.        ptr_to_m < (char *)0x40200000;     /* point to flash_end and change type   */
  1462.        ptr_to_m++,Buffer_p++) {                    /* inc pointer                          */
  1464.        *Buffer_p =  *ptr_to_m;
  1466.          if (*ptr_to_m != *Buffer_p){             /* check all bits are set to 1          */
  1467.             debugmessage("ROMTOOL>  ERROR!!! EPROM not erased properlyn");
  1468.             return 0;
  1469.             }
  1470.        }
  1471.   
  1472.   /* ===================== check whether array is erased================== */
  1473.          numBytes = (int) debugwrite( (long int)ReadFile_p, (U8 *)Buffer_p, Length);
  1474.                STTBX_Print(("write file size  = %d bytesn", numBytes ));
  1475. #endif
  1476.                 /* deallocate temp buffer */
  1477.                 memory_deallocate( SystemPartition, Buffer_p );
  1478.             }
  1480.         STTBX_Print(("!!!! Read file successfully!!!!n"));
  1481.         return TRUE;
  1483. }
  1485. BOOL wts_EraseLogoFlash( BOOL Erase )
  1486. {
  1487.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1488.     U8   Section, Bank;
  1489.     U32  EraseOffset;
  1490.     BOOL EraseFailed = TRUE;
  1492.     /* check data size */
  1493.     if ( Erase )
  1494.     {
  1495.         EraseFailed = FALSE;
  1497.         STTBX_Print(("tt+------------+------------+n"));
  1498.         if ( Erase )
  1499.         {
  1500.             for ( Section = FIRST_LOGO_BLOCK;( Section < FIRST_LOGO_BLOCK+LOGO_BLOCKS ) && ( ErrCode == ST_NO_ERROR ); Section ++)
  1501.             {
  1502.                 Bank = BlockInfo[Section].Bank;
  1503. #ifdef DEBUG
  1504.                 STTBX_Print(("tBaseAddress[Bank]=0x%08x n",BaseAddress[Bank]));
  1505.                 STTBX_Print(("tBlockInfo[Section].Address=0x%08x n",BlockInfo[Section].Address));
  1506. #endif
  1507.                 EraseOffset = BlockInfo[Section].Address - BaseAddress[Bank];
  1508.                 STTBX_Print(("bank %d block %2dt| 0x%08x | 0x%08x | ",
  1509.                              Bank, Section,
  1510.                              BlockInfo[Section].Address,
  1511.                              BlockInfo[Section].Address + BlockInfo[Section].Length - 1 ));
  1513.                 ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1514.                                          EraseOffset,
  1515.                                          BlockInfo[Section].Length );
  1516.                 if ( ErrCode != ST_NO_ERROR )
  1517.                 {
  1518.                     STTBX_Print(("Erase FAILEDn"));
  1519.                     EraseFailed = TRUE;
  1520.                 }
  1521.                 else
  1522.                     STTBX_Print(("ERASEDn"));
  1523.             }
  1524.         }
  1525.         
  1526.         STTBX_Print(("tt+------------+------------+n"));
  1527.     }
  1529.     if ( EraseFailed == TRUE )
  1530.     {
  1531.         wts_FreeFileDataBuffer();
  1532.         STTBX_Print(("!!!! ERASE Failed !!!!n"));
  1533.         return TRUE;
  1534.     }
  1536.     return EraseFailed;
  1538. }
  1539. BOOL wts_EraseLanguageFlash( BOOL Erase )
  1540. {
  1541.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1542.     U8   Section, Bank;
  1543.     U32  EraseOffset;
  1544.     BOOL EraseFailed = TRUE;
  1546.     /* check data size */
  1547.     if ( Erase )
  1548.     {
  1549.         EraseFailed = FALSE;
  1551.         STTBX_Print(("tt+------------+------------+n"));
  1552.         if ( Erase )
  1553.         {
  1554.             for ( Section = FIRST_LANG_BLOCK;( Section < FIRST_LANG_BLOCK+LANG_BLOCKS ) && ( ErrCode == ST_NO_ERROR ); Section ++)
  1555.             {
  1556.                 Bank = BlockInfo[Section].Bank;
  1557. #ifdef DEBUG
  1558.                 STTBX_Print(("tBaseAddress[Bank]=0x%08x n",BaseAddress[Bank]));
  1559.                 STTBX_Print(("tBlockInfo[Section].Address=0x%08x n",BlockInfo[Section].Address));
  1560. #endif
  1561.                 EraseOffset = BlockInfo[Section].Address - BaseAddress[Bank];
  1562.                 STTBX_Print(("bank %d block %2dt| 0x%08x | 0x%08x | ",
  1563.                              Bank, Section,
  1564.                              BlockInfo[Section].Address,
  1565.                              BlockInfo[Section].Address + BlockInfo[Section].Length - 1 ));
  1567.                 ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1568.                                          EraseOffset,
  1569.                                          BlockInfo[Section].Length );
  1570.                 if ( ErrCode != ST_NO_ERROR )
  1571.                 {
  1572.                     STTBX_Print(("Erase FAILEDn"));
  1573.                     EraseFailed = TRUE;
  1574.                 }
  1575.                 else
  1576.                     STTBX_Print(("ERASEDn"));
  1577.             }
  1578.         }
  1579.         
  1580.         STTBX_Print(("tt+------------+------------+n"));
  1581.     }
  1583.     if ( EraseFailed == TRUE )
  1584.     {
  1585.         wts_FreeFileDataBuffer();
  1586.         STTBX_Print(("!!!! ERASE Failed !!!!n"));
  1587.         return TRUE;
  1588.     }
  1590.     return EraseFailed;
  1592. }
  1593. /*-------------------------------------------------------------------------
  1594.  * Function : wts_EraseLNBFlash
  1595.  *            Function to Read Hex file and erase areas required
  1596.  * Input    : EraselLNB 
  1597.  * Output   :
  1598.  * Return   : EraseFailed = TRUE else FALSE
  1599.  * ----------------------------------------------------------------------*/
  1600. BOOL wts_EraseLNBFlash( BOOL Erase )
  1601. {
  1602.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1603.     U8   Section, Bank;
  1604.     U32  EraseOffset;
  1605.     BOOL EraseFailed = TRUE;
  1607.     /* check data size */
  1608.     if ( Erase )
  1609.     {
  1610.         EraseFailed = FALSE;
  1612.         STTBX_Print(("tt+------------+------------+n"));
  1613.         if ( Erase )
  1614.         {
  1615.             for ( Section = FIRST_LNB_BLOCK;( Section < FIRST_LNB_BLOCK+LNB_BLOCKS ) && ( ErrCode == ST_NO_ERROR ); Section ++)
  1616.             {
  1617.                 Bank = BlockInfo[Section].Bank;
  1618. #ifdef DEBUG
  1619.                 STTBX_Print(("tBaseAddress[Bank]=0x%08x n",BaseAddress[Bank]));
  1620.                 STTBX_Print(("tBlockInfo[Section].Address=0x%08x n",BlockInfo[Section].Address));
  1621. #endif
  1622.                 EraseOffset = BlockInfo[Section].Address - BaseAddress[Bank];
  1623.                 STTBX_Print(("bank %d block %2dt| 0x%08x | 0x%08x | ",
  1624.                              Bank, Section,
  1625.                              BlockInfo[Section].Address,
  1626.                              BlockInfo[Section].Address + BlockInfo[Section].Length - 1 ));
  1628.                 ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1629.                                          EraseOffset,
  1630.                                          BlockInfo[Section].Length );
  1631.                 if ( ErrCode != ST_NO_ERROR )
  1632.                 {
  1633.                     STTBX_Print(("Erase FAILEDn"));
  1634.                     EraseFailed = TRUE;
  1635.                 }
  1636.                 else
  1637.                     STTBX_Print(("ERASEDn"));
  1638.             }
  1639.         }
  1640.         
  1641.         STTBX_Print(("tt+------------+------------+n"));
  1642.     }
  1644.     if ( EraseFailed == TRUE )
  1645.     {
  1646.         wts_FreeFileDataBuffer();
  1647.         STTBX_Print(("!!!! ERASE Failed !!!!n"));
  1648.         return TRUE;
  1649.     }
  1651.     return EraseFailed;
  1653. } /* end wts_ProgramFlash */
  1656. /*-------------------------------------------------------------------------
  1657.  * Function : wts_EraseCodeFlash
  1658.  *            Function to Read Hex file and erase areas required
  1659.  * Input    : EraseCode 
  1660.  * Output   :
  1661.  * Return   : EraseFailed = TRUE else FALSE
  1662.  * ----------------------------------------------------------------------*/
  1663. BOOL wts_EraseCodeFlash( BOOL EraseCode )
  1664. {
  1665.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  1666.     U8   Section, Bank;
  1667.     U32  EraseOffset;
  1668.     BOOL EraseFailed = TRUE;
  1670.     /* check data size */
  1671.     if ( EraseCode )
  1672.     {
  1673.         EraseFailed = FALSE;
  1675.         STTBX_Print(("tt+------------+------------+n"));
  1676.         if ( EraseCode )
  1677.         {
  1678.             for ( Section = FIRST_CODE_BLOCK;( Section < FIRST_CODE_BLOCK+CODE_BLOCKS ) && ( ErrCode == ST_NO_ERROR ); Section ++)
  1679.             {
  1680.                 Bank = BlockInfo[Section].Bank;
  1681. #ifdef DEBUG
  1682.                 STTBX_Print(("tBaseAddress[Bank]=0x%08x n",BaseAddress[Bank]));
  1683.                 STTBX_Print(("tBlockInfo[Section].Address=0x%08x n",BlockInfo[Section].Address));
  1684. #endif
  1685.                 EraseOffset = BlockInfo[Section].Address - BaseAddress[Bank];
  1686.                 STTBX_Print(("bank %d block %2dt| 0x%08x | 0x%08x | ",
  1687.                              Bank, Section,
  1688.                              BlockInfo[Section].Address,
  1689.                              BlockInfo[Section].Address + BlockInfo[Section].Length - 1 ));
  1691.                 ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1692.                                          EraseOffset,
  1693.                                          BlockInfo[Section].Length );
  1694.                 if ( ErrCode != ST_NO_ERROR )
  1695.                 {
  1696.                     STTBX_Print(("Erase FAILEDn"));
  1697.                     EraseFailed = TRUE;
  1698.                 }
  1699.                 else
  1700.                     STTBX_Print(("ERASEDn"));
  1701.             }
  1702.         }
  1703.         
  1704.         STTBX_Print(("tt+------------+------------+n"));
  1705.     }
  1707.     if ( EraseFailed == TRUE )
  1708.     {
  1709.         wts_FreeFileDataBuffer();
  1710.         STTBX_Print(("!!!! ERASE Failed !!!!n"));
  1711.         return TRUE;
  1712.     }
  1714.     return EraseFailed;
  1716. } /* end wts_ProgramFlash */
  1718. /*-------------------------------------------------------------------------
  1719.  * Function : wts_ConvertMemory
  1720.  *            Convert Raw Hex file into memory buffer suitable to write to
  1721.  *            flash copying created data over data read from filem, the
  1722.  *            created data will be smaller as each byte takes three bytes
  1723.  *            in the Hex file.
  1724.  * Input    :
  1725.  * Output   :
  1726.  * Return   : size of data in buffer
  1727.  * ----------------------------------------------------------------------*/
  1728. static U32 wts_LogoConvertMemory( long unsigned int MemSize )
  1729. {
  1730.     int                 Section;
  1731.     U32                 InOffset;
  1732.     
  1733.     for ( Section = 31; Section < NUM_SECTIONS; Section ++ )
  1734.     {
  1735.         SectionInfo[Section].Block = 0xff;
  1736.         SectionInfo[Section].Address = 0;
  1737.         SectionInfo[Section].Offset = 0;
  1738.         SectionInfo[Section].Size = 0;
  1739.     }
  1741.     /* Convert File */
  1743.     Section = 31;
  1744.     
  1745.     for ( InOffset = 0;InOffset < MemSize; )
  1746.     {
  1748. InOffset += 0x8000;
  1750. if(InOffset < MemSize){
  1751. SectionInfo[Section].Address = wtFlashBankBaseAddr + 0x10000*Section;
  1752. SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  1753. SectionInfo[Section].Offset = InOffset - 0x8000; /*0x10000*Section;*/
  1754. SectionInfo[Section].Size = 0x8000;
  1755. }
  1756. else{
  1757. SectionInfo[Section].Address = wtFlashBankBaseAddr + 0x10000*Section;
  1758. SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  1759. SectionInfo[Section].Offset = InOffset - 0x8000; /*0x10000*Section;*/
  1760. SectionInfo[Section].Size = MemSize - (InOffset - 0x8000);
  1761. }
  1763.        STTBX_Print(("Section %2d, Block %3d, Addr 0x%08x, Offset 0x%08x, Size %6dn",
  1764.                          Section,
  1765.                          SectionInfo[Section].Block,
  1766.                          SectionInfo[Section].Address,
  1767.                          SectionInfo[Section].Offset,
  1768.                          SectionInfo[Section].Size ));
  1770. Section++;
  1771.     }
  1773. return MemSize;
  1775. } /* end wts_ConvertMemory */
  1777. BOOL wts_ProgramLogoFlash( void)
  1779. {
  1781.     ST_ErrorCode_t      ErrCode;
  1782.     long int    File_p=0;            /* datafile descriptor          */
  1783.     long int    FileSize=0;          /* size in bytes of the file    */
  1784.     BOOL                ProgramFailed;
  1786.     U32                 NumberOfBytes;
  1787.     int                 Section, Bank;
  1789.     U32  EraseOffset;
  1790.     BOOL EraseFailed = FALSE;
  1792. char Filename[] = "logo.bin";
  1794.     U32  EarLength = 0x5000;
  1796.     U32  WriteOffset =  0x401F0000;
  1798.     /* Open and Read file into memory */
  1799.     File_p = debugopen(Filename, "rb");
  1800.     STTBX_Print(("File_p = 0x%8xn",File_p));
  1801.     
  1802.     if(File_p < 0)
  1803.     {
  1804.         STTBX_Print(("Error opening file '%s'n", Filename ));
  1805.         return (0);
  1806.     }
  1807.     else
  1808.     {
  1809.         FileSize = debugfilesize(File_p);
  1810.         STTBX_Print(("FileSize = 0x%8xn",FileSize));
  1811.         /* allocate File data buffer */
  1812.              STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  1813.         wts_FreeFileDataBuffer();
  1814.               STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  1815.        FlashData_p = (char*) memory_allocate( SystemPartition, (U32) FileSize );
  1816.                STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  1817.       if ( FlashData_p != NULL )
  1818.         {
  1819.             STTBX_Print(("Loading '%s' into memory, wait .. ", Filename ));
  1820.             debugread(File_p, FlashData_p, (size_t) FileSize);
  1821.             STTBX_Print(("%d bytesn", FileSize ));
  1823.              STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  1824.         }
  1825.         else
  1826.         {
  1827.             STTBX_Print(("Not enough memory for bin file (%d bytes)n", FileSize));
  1828.             FileSize = 0;
  1829.         }
  1830.         debugclose(File_p);
  1832.     }
  1834.     if ( FileSize > 0 )
  1835.     {
  1836.         /* convert buffer to binary and resize memory */
  1837.         STTBX_Print(("Converting file in memory, wait .. nn"));
  1838.         FlashSize = wts_LogoConvertMemory( FileSize );
  1839.         if ( FlashSize > 0 )
  1840.         {
  1841.             STTBX_Print(("%d bytesn", FlashSize ));
  1842.             FlashData_p = (char*) memory_reallocate( SystemPartition, FlashData_p, FlashSize );
  1843.         }
  1844.         else
  1845.             STTBX_Print(("Invalid filen"));
  1846.     }
  1849.             for ( Section = 31; ( Section < NUM_SECTIONS ) && ( EraseFailed == FALSE ); Section ++ )
  1850.             {
  1851.                 if ( SectionInfo[Section].Block != 0xFF )
  1852.                 {
  1853.                     /*
  1854.                     ** Erase = erase whole block, valid parameters are block base address & block size
  1855.                     */
  1856.                     Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  1857.                     EraseOffset = BlockInfo[ SectionInfo[Section].Block ].Address - BaseAddress[Bank];
  1859.                     STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  1860.                                  SectionInfo[Section].Block,
  1861.                                  BlockInfo[ SectionInfo[Section].Block ].Address,
  1862.                                  BlockInfo[ SectionInfo[Section].Block ].Address +
  1863.                                  BlockInfo[ SectionInfo[Section].Block ].Length - 1 ));
  1864.                                  
  1865.                     ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  1866.                                              EraseOffset,
  1867.                                              BlockInfo[ SectionInfo[Section].Block ].Length );
  1869.                     if ( ErrCode != ST_NO_ERROR )
  1870.                     {
  1871.                         STTBX_Print(("ErrCode = 0x%8xn",ErrCode));
  1872.                         STTBX_Print(("Erase FAILEDn"));
  1873.                         STTBX_Print(("wts_FLASHHndl[Bank] = 0x%8Xn",wts_FLASHHndl[Bank]));
  1874.                         EraseFailed = TRUE;
  1875.                     }
  1876.                     else
  1877.                         STTBX_Print(("ERASEDn"));
  1878.                 }
  1879.             }
  1883.  
  1884.     /* check data size */
  1885.     if ( FlashSize == 0 )
  1886.         ProgramFailed = TRUE;
  1887.     else
  1888.     {
  1889.         ProgramFailed = FALSE;
  1890.         STTBX_Print(("tt+------------+------------+n"));
  1891.     }
  1893.     /* Find out which blocks are to be written to */
  1894.     /* Write the data to the Flash */
  1895.     /*STTBX_Print(("Printing the contents of BlockInfo n"));
  1896.     for ( Section = 0; ( Section < NUM_SECTIONS ) ; Section ++ )
  1897.     {
  1898.         STTBX_Print(("Section=%dt", Section ));
  1899.         STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  1900.         STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  1901.         STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  1902.     }*/
  1904.     for ( Section = 31; ( Section < NUM_SECTIONS ) && ( ProgramFailed == FALSE ); Section ++ )
  1905.     {
  1906.         if ( SectionInfo[Section].Block != 0xFF )
  1907.         {
  1909.             /*
  1910.             ** Write = write bytes from Offset
  1911.             */
  1912.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  1913.             STTBX_Print(("Section=%dt", Section ));
  1914.             STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  1915.             STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  1916.             STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  1917.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  1918.             /*SectionInfo[Section].Address += 0x4; Tara*/
  1919.             STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  1920.                          SectionInfo[Section].Block,
  1921.                          SectionInfo[Section].Address,
  1922.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  1924.             ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  1925.                                      WriteOffset,
  1926.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  1927.                                      SectionInfo[Section].Size,
  1928.                                      &NumberOfBytes );
  1930.             if ( ErrCode != ST_NO_ERROR )
  1931.             {
  1932.                 STTBX_Print(("Program FAILEDn"));
  1933.                 ProgramFailed = TRUE;
  1934.             }
  1935.             else
  1936.                 STTBX_Print(("PROGRAMMEDn"));
  1937.         }
  1938.     }
  1940.     if ( ProgramFailed == TRUE )
  1941.     {
  1942.         wts_FreeFileDataBuffer();
  1943.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  1944.         return TRUE;
  1945.     }
  1946.     else
  1947.     {
  1948.         STTBX_Print(("tt+------------+------------+n"));
  1949.         return FALSE;
  1950.     }
  1953. }
  1956. #if 1
  1958. /*-------------------------------------------------------------------------
  1959.  * Function : wts_ConvertMemory
  1960.  *            Convert Raw Hex file into memory buffer suitable to write to
  1961.  *            flash copying created data over data read from filem, the
  1962.  *            created data will be smaller as each byte takes three bytes
  1963.  *            in the Hex file.
  1964.  * Input    :
  1965.  * Output   :
  1966.  * Return   : size of data in buffer
  1967.  * ----------------------------------------------------------------------*/
  1968. static U32 wts_LangConvertMemory( long unsigned int MemSize )
  1969. {
  1970.     int                 Section;
  1971.     U32                 InOffset;
  1972.     
  1973.     for ( Section = 16; Section < NUM_SECTIONS; Section ++ )
  1974.     {
  1975.         SectionInfo[Section].Block = 0xff;
  1976.         SectionInfo[Section].Address = 0;
  1977.         SectionInfo[Section].Offset = 0;
  1978.         SectionInfo[Section].Size = 0;
  1979.     }
  1981.     /* Convert File */
  1983.     Section = 16;
  1984.     
  1985.     for ( InOffset = 0;InOffset < MemSize; )
  1986.     {
  1988. InOffset += 0x10000;
  1990. if(InOffset < MemSize){
  1991. SectionInfo[Section].Address = wtFlashBankBaseAddr + 0x10000*Section;
  1992. SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  1993. SectionInfo[Section].Offset = InOffset - 0x10000; /*0x10000*Section;*/
  1994. SectionInfo[Section].Size = 0x10000;
  1995. }
  1996. else{
  1997. SectionInfo[Section].Address = wtFlashBankBaseAddr + 0x10000*Section;
  1998. SectionInfo[Section].Block = wts_GetBlockNumber(SectionInfo[Section].Address);
  1999. SectionInfo[Section].Offset = InOffset - 0x10000; /*0x10000*Section;*/
  2000. SectionInfo[Section].Size = MemSize - (InOffset - 0x10000);
  2001. }
  2003.        STTBX_Print(("Section %2d, Block %3d, Addr 0x%08x, Offset 0x%08x, Size %6dn",
  2004.                          Section,
  2005.                          SectionInfo[Section].Block,
  2006.                          SectionInfo[Section].Address,
  2007.                          SectionInfo[Section].Offset,
  2008.                          SectionInfo[Section].Size ));
  2010. Section++;
  2011.     }
  2013. return MemSize;
  2015. } /* end wts_ConvertMemory */
  2017. BOOL wts_ProgramLanguageFlash(  char *Filename )
  2018. {
  2020.     ST_ErrorCode_t      ErrCode;
  2021.     long int    File_p=0;            /* datafile descriptor          */
  2022.     long int    FileSize=0;          /* size in bytes of the file    */
  2023.     BOOL                ProgramFailed;
  2025.     U32                 NumberOfBytes;
  2026.     int                 Section, Bank;
  2028.     U32  EraseOffset;
  2029.     BOOL EraseFailed = FALSE;
  2031.     U32  EarLength = 0x80000;
  2033.     U32  WriteOffset =  0x40100000;
  2035.     /* Open and Read file into memory */
  2036.     File_p = debugopen(Filename, "rb");
  2037.     STTBX_Print(("File_p = 0x%8xn",File_p));
  2038.     
  2039.     if(File_p < 0)
  2040.     {
  2041.         STTBX_Print(("Error opening file '%s'n", Filename ));
  2042.         return (0);
  2043.     }
  2044.     else
  2045.     {
  2046.         FileSize = debugfilesize(File_p);
  2047.         STTBX_Print(("FileSize = 0x%8xn",FileSize));
  2048.         /* allocate File data buffer */
  2049.              STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  2050.         wts_FreeFileDataBuffer();
  2051.               STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  2052.        FlashData_p = (char*) memory_allocate( SystemPartition, (U32) FileSize );
  2053.                STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  2054.       if ( FlashData_p != NULL )
  2055.         {
  2056.             STTBX_Print(("Loading '%s' into memory, wait .. ", Filename ));
  2057.             debugread(File_p, FlashData_p, (size_t) FileSize);
  2058.             STTBX_Print(("%d bytesn", FileSize ));
  2060.              STTBX_Print(("FlashData_p addr 0x%x ,FlashSize = %d !n",FlashData_p,FileSize));
  2061.         }
  2062.         else
  2063.         {
  2064.             STTBX_Print(("Not enough memory for bin file (%d bytes)n", FileSize));
  2065.             FileSize = 0;
  2066.         }
  2067.         debugclose(File_p);
  2069.     }
  2071.     if ( FileSize > 0 )
  2072.     {
  2073.         /* convert buffer to binary and resize memory */
  2074.         STTBX_Print(("Converting file in memory, wait .. nn"));
  2075.         FlashSize = wts_LangConvertMemory( FileSize );
  2076.         if ( FlashSize > 0 )
  2077.         {
  2078.             STTBX_Print(("%d bytesn", FlashSize ));
  2079.             FlashData_p = (char*) memory_reallocate( SystemPartition, FlashData_p, FlashSize );
  2080.         }
  2081.         else
  2082.             STTBX_Print(("Invalid filen"));
  2083.     }
  2086.             for ( Section = 16; ( Section < NUM_SECTIONS ) && ( EraseFailed == FALSE ); Section ++ )
  2087.             {
  2088.                 if ( SectionInfo[Section].Block != 0xFF )
  2089.                 {
  2090.                     /*
  2091.                     ** Erase = erase whole block, valid parameters are block base address & block size
  2092.                     */
  2093.                     Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  2094.                     EraseOffset = BlockInfo[ SectionInfo[Section].Block ].Address - BaseAddress[Bank];
  2096.                     STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  2097.                                  SectionInfo[Section].Block,
  2098.                                  BlockInfo[ SectionInfo[Section].Block ].Address,
  2099.                                  BlockInfo[ SectionInfo[Section].Block ].Address +
  2100.                                  BlockInfo[ SectionInfo[Section].Block ].Length - 1 ));
  2101.                                  
  2102.                     ErrCode = STFLASH_Erase( wts_FLASHHndl[Bank],
  2103.                                              EraseOffset,
  2104.                                              BlockInfo[ SectionInfo[Section].Block ].Length );
  2106.                     if ( ErrCode != ST_NO_ERROR )
  2107.                     {
  2108.                         STTBX_Print(("ErrCode = 0x%8xn",ErrCode));
  2109.                         STTBX_Print(("Erase FAILEDn"));
  2110.                         STTBX_Print(("wts_FLASHHndl[Bank] = 0x%8Xn",wts_FLASHHndl[Bank]));
  2111.                         EraseFailed = TRUE;
  2112.                     }
  2113.                     else
  2114.                         STTBX_Print(("ERASEDn"));
  2115.                 }
  2116.             }
  2120.  
  2121.     /* check data size */
  2122.     if ( FlashSize == 0 )
  2123.         ProgramFailed = TRUE;
  2124.     else
  2125.     {
  2126.         ProgramFailed = FALSE;
  2127.         STTBX_Print(("tt+------------+------------+n"));
  2128.     }
  2130.     /* Find out which blocks are to be written to */
  2131.     /* Write the data to the Flash */
  2132.     /*STTBX_Print(("Printing the contents of BlockInfo n"));
  2133.     for ( Section = 0; ( Section < NUM_SECTIONS ) ; Section ++ )
  2134.     {
  2135.         STTBX_Print(("Section=%dt", Section ));
  2136.         STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  2137.         STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  2138.         STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  2139.     }*/
  2141.     for ( Section = 16; ( Section < NUM_SECTIONS ) && ( ProgramFailed == FALSE ); Section ++ )
  2142.     {
  2143.         if ( SectionInfo[Section].Block != 0xFF )
  2144.         {
  2146.             /*
  2147.             ** Write = write bytes from Offset
  2148.             */
  2149.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  2150.             STTBX_Print(("Section=%dt", Section ));
  2151.             STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  2152.             STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  2153.             STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  2154.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  2155.             /*SectionInfo[Section].Address += 0x4; Tara*/
  2156.             STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  2157.                          SectionInfo[Section].Block,
  2158.                          SectionInfo[Section].Address,
  2159.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  2161.             ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  2162.                                      WriteOffset,
  2163.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  2164.                                      SectionInfo[Section].Size,
  2165.                                      &NumberOfBytes );
  2167.             if ( ErrCode != ST_NO_ERROR )
  2168.             {
  2169.                 STTBX_Print(("Program FAILEDn"));
  2170.                 ProgramFailed = TRUE;
  2171.             }
  2172.             else
  2173.                 STTBX_Print(("PROGRAMMEDn"));
  2174.         }
  2175.     }
  2177.     if ( ProgramFailed == TRUE )
  2178.     {
  2179.         wts_FreeFileDataBuffer();
  2180.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  2181.         return TRUE;
  2182.     }
  2183.     else
  2184.     {
  2185.         STTBX_Print(("tt+------------+------------+n"));
  2186.         return FALSE;
  2187.     }
  2190. }
  2193. #else
  2195. BOOL wts_ProgramLanguageFlash( char *Filename )
  2196. {
  2197.     int            nameLength ;
  2198.     BOOL           binFile,ProgramFailed ;
  2200.     ST_ErrorCode_t      ErrCode;
  2201. long int    ReadFile_p=0;            /* datafile descriptor          */
  2202. U32   FileSize=0;          /* size in bytes of the file    */
  2204. U32 WriteOffset = 0x40100000;
  2205.     U32                 NumberOfBytes;
  2207.     nameLength = strlen( Filename ) ;
  2208.     if (Filename[nameLength-1]=='n' && Filename[nameLength-2]=='i' &&
  2209.         Filename[nameLength-3]=='b' && Filename[nameLength-4]=='.' )
  2210.     {
  2211.         binFile = TRUE ;
  2212.     }    
  2213.     /* Open and Read file into memory */
  2214.     ReadFile_p = debugopen(Filename, "rb");
  2215.     STTBX_Print(("ReadFile_p = 0x%8xn",ReadFile_p));
  2216.     
  2217.     if(ReadFile_p < 0)
  2218.     {
  2219.         STTBX_Print(("Error opening file '%s'n", Filename ));
  2220.         return (0);
  2221.     }
  2222.     else
  2223.     {
  2224.         FileSize = debugfilesize(ReadFile_p);
  2225.         STTBX_Print(("FileSize = 0x%8xn",FileSize));
  2226.         /* allocate File data buffer */
  2227.         wts_FreeFileDataBuffer();
  2228.         FlashData_p = (char*) memory_allocate( SystemPartition, FileSize );
  2229.         if ( FlashData_p != NULL )
  2230.         {
  2231.             STTBX_Print(("Loading '%s' into memory, wait .. ", Filename ));
  2232.             debugread(ReadFile_p, FlashData_p, (size_t) FileSize);
  2233.             STTBX_Print(("%d bytesn", FileSize ));
  2234.         }
  2235.         else
  2236.         {
  2237.             STTBX_Print(("Not enough memory for HEX file (%d bytes)n", FileSize));
  2238.             FileSize = 0;
  2239.         }
  2241.             FlashData_p = (char*) memory_reallocate( SystemPartition, FlashData_p, FileSize );
  2242.                 STTBX_Print(("FlashData_p memory_reallocaten"));
  2244.         debugclose(ReadFile_p);
  2245.     }
  2247. if(FileSize > 0){
  2248.             ErrCode = STFLASH_Write( wts_FLASHHndl[BANK0],
  2249.                                      WriteOffset,
  2250.                                      (U8*)FlashData_p,
  2251.                                      FileSize,
  2252.                                      &NumberOfBytes );
  2254.             if ( ErrCode != ST_NO_ERROR )
  2255.             {
  2256.                 STTBX_Print(("Program FAILEDn"));
  2257.                 ProgramFailed = TRUE;
  2258.             }
  2259.             else
  2260.                 STTBX_Print(("PROGRAMMEDn"));
  2261.         }
  2262. else
  2263. return 0;
  2265.     if ( ProgramFailed == TRUE )
  2266.     {
  2267.         wts_FreeFileDataBuffer();
  2268.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  2269.         return TRUE;
  2270.     }
  2271.     else
  2272.     {
  2273.         STTBX_Print(("tt+------------+------------+n"));
  2274.         return FALSE;
  2275.     }
  2276.  
  2277.     /* loop thru the data file */
  2278.     return 1;
  2279. }
  2280. #endif
  2282. #if 0
  2283. BOOL wts_ProgramLanguageFlash( void )
  2284. {
  2285. ST_ErrorCode_t      ErrCode;
  2286.     int                 Section, Bank=0;
  2287.     U32                 NumberOfBytes;
  2288.     BOOL                ProgramFailed;
  2290. U32 FlashOffset=0;
  2292.     /* check data size */
  2293.     if ( FlashSize == 0 )
  2294.         ProgramFailed = TRUE;
  2295.     else
  2296.     {
  2297.         ProgramFailed = FALSE;
  2298.         STTBX_Print(("tt+------------+------------+n"));
  2299.     }
  2301. FlashOffset = (U32)0x40100000;
  2302. ErrCode = STFLASH_Write( wts_FLASHHndl[1],
  2303.                                      FlashOffset,
  2304.                                      (U8 *)FlashData_p,
  2305.                                      FlashSize,
  2306.                                      &NumberOfBytes );
  2308.             if ( ErrCode != ST_NO_ERROR )
  2309.             {
  2310.                 STTBX_Print(("Program FAILEDn"));
  2311.                 ProgramFailed = TRUE;
  2312.             }
  2313.             else
  2314.                 STTBX_Print(("PROGRAMMEDn"));
  2317.     if ( ProgramFailed == TRUE )
  2318.     {
  2319.         wts_FreeFileDataBuffer();
  2320.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  2321.         return TRUE;
  2322.     }
  2323.     else
  2324.     {
  2325.         STTBX_Print(("tt+------------+------------+n"));
  2326.         return FALSE;
  2327.     }
  2329. } /* end wts_ProgramFlash */
  2331. #endif
  2333. /*-------------------------------------------------------------------------
  2334.  * Function : wts_ProgramAllFlash
  2335.  *            Function to Read Hex file and program flash with contents
  2336.  * Input    :
  2337.  * Output   :
  2338.  * Return   : None
  2339.  * ----------------------------------------------------------------------*/
  2340. BOOL wts_ProgramAllFlash( void )
  2341. {
  2342.     ST_ErrorCode_t      ErrCode;
  2343.     int                 Section, Bank;
  2344.     U32                 NumberOfBytes;
  2345.     BOOL                ProgramFailed;
  2347.     /* check data size */
  2348.     if ( FlashSize == 0 )
  2349.         ProgramFailed = TRUE;
  2350.     else
  2351.     {
  2352.         ProgramFailed = FALSE;
  2353.         STTBX_Print(("tt+------------+------------+n"));
  2354.     }
  2356.     /* Find out which blocks are to be written to */
  2357.     /* Write the data to the Flash */
  2358.     /*STTBX_Print(("Printing the contents of BlockInfo n"));
  2359.     for ( Section = 0; ( Section < NUM_SECTIONS ) ; Section ++ )
  2360.     {
  2361.         STTBX_Print(("Section=%dt", Section ));
  2362.         STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  2363.         STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  2364.         STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  2365.     }*/
  2367.     for ( Section = 0; ( Section < TOTAL_BLOCKS ) && ( ProgramFailed == FALSE ); Section ++ )
  2368.     {
  2369.         if ( SectionInfo[Section].Block != 0xFF )
  2370.         {
  2371.             U32  WriteOffset;
  2373.             /*
  2374.             ** Write = write bytes from Offset
  2375.             */
  2376.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  2377. #ifdef DEBUG
  2378.             STTBX_Print(("Section=%dt", Section ));
  2379.             STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  2380.             STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  2381.             STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  2382. #endif
  2383.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  2384.             /*SectionInfo[Section].Address += 0x4; Tara*/
  2385.             STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  2386.                          SectionInfo[Section].Block,
  2387.                          SectionInfo[Section].Address,
  2388.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  2390.             ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  2391.                                      WriteOffset,
  2392.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  2393.                                      SectionInfo[Section].Size,
  2394.                                      &NumberOfBytes );
  2396.             if ( ErrCode != ST_NO_ERROR )
  2397.             {
  2398.                 STTBX_Print(("Program FAILEDn"));
  2399.                 ProgramFailed = TRUE;
  2400.             }
  2401.             else
  2402.                 STTBX_Print(("PROGRAMMEDn"));
  2403.         }
  2404.     }
  2406.     if ( ProgramFailed == TRUE )
  2407.     {
  2408.         wts_FreeFileDataBuffer();
  2409.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  2410.         return TRUE;
  2411.     }
  2412.     else
  2413.     {
  2414.         STTBX_Print(("tt+------------+------------+n"));
  2415.         return FALSE;
  2416.     }
  2418. } /* end wts_ProgramAllFlash */
  2421. /*-------------------------------------------------------------------------
  2422.  * Function : wts_ProgramLNBFlash
  2423.  *            Function to Read Hex file and program flash with contents
  2424.  * Input    :
  2425.  * Output   :
  2426.  * Return   : None
  2427.  * ----------------------------------------------------------------------*/
  2428. BOOL wts_ProgramLNBFlash( void )
  2429. {
  2430.     ST_ErrorCode_t      ErrCode;
  2431.     int                 Section, Bank;
  2432.     U32                 NumberOfBytes;
  2433.     BOOL                ProgramFailed;
  2435.     /* check data size */
  2436.     if ( FlashSize == 0 )
  2437.         ProgramFailed = TRUE;
  2438.     else
  2439.     {
  2440.         ProgramFailed = FALSE;
  2441.         STTBX_Print(("tt+------------+------------+n"));
  2442.     }
  2444.     /* Find out which blocks are to be written to */
  2445.     /* Write the data to the Flash */
  2446.     /*STTBX_Print(("Printing the contents of BlockInfo n"));
  2447.     for ( Section = 0; ( Section < NUM_SECTIONS ) ; Section ++ )
  2448.     {
  2449.         STTBX_Print(("Section=%dt", Section ));
  2450.         STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  2451.         STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  2452.         STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  2453.     }*/
  2455.     for ( Section = CODE_BLOCKS; ( Section < TOTAL_BLOCKS ) && ( ProgramFailed == FALSE ); Section ++ )
  2456.     {
  2457.         if ( SectionInfo[Section].Block != 0xFF )
  2458.         {
  2459.             U32  WriteOffset;
  2461.             /*
  2462.             ** Write = write bytes from Offset
  2463.             */
  2464.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  2465. #ifdef DEBUG
  2466.             STTBX_Print(("Section=%dt", Section ));
  2467.             STTBX_Print(("SectionInfo[Section]=%dn", SectionInfo[Section] ));
  2468.             STTBX_Print(("SectionInfo[Section].Block=%dt", SectionInfo[Section].Block ));
  2469.             STTBX_Print(("BlockInfo[ SectionInfo[Section].Block ].Bank=%dn",BlockInfo[ SectionInfo[Section].Block ].Bank));
  2470. #endif
  2471.             WriteOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  2472.             /*SectionInfo[Section].Address += 0x4; Tara*/
  2473.             STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  2474.                          SectionInfo[Section].Block,
  2475.                          SectionInfo[Section].Address,
  2476.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  2478.             ErrCode = STFLASH_Write( wts_FLASHHndl[Bank],
  2479.                                      WriteOffset,
  2480.                                      (U8*)&FlashData_p[SectionInfo[Section].Offset],
  2481.                                      SectionInfo[Section].Size,
  2482.                                      &NumberOfBytes );
  2484.             if ( ErrCode != ST_NO_ERROR )
  2485.             {
  2486.                 STTBX_Print(("Program FAILEDn"));
  2487.                 ProgramFailed = TRUE;
  2488.             }
  2489.             else
  2490.                 STTBX_Print(("PROGRAMMEDn"));
  2491.         }
  2492.     }
  2494.     if ( ProgramFailed == TRUE )
  2495.     {
  2496.         wts_FreeFileDataBuffer();
  2497.         STTBX_Print(("!!!! PROGRAM Failed !!!!n"));
  2498.         return TRUE;
  2499.     }
  2500.     else
  2501.     {
  2502.         STTBX_Print(("tt+------------+------------+n"));
  2503.         return FALSE;
  2504.     }
  2506. } /* end wts_ProgramLNBFlash */
  2509. BOOL wts_VerifyLogoFlash( void )
  2510. {}
  2512. BOOL wts_VerifyLanguageFlash( void )
  2513. {}
  2515. /*-------------------------------------------------------------------------
  2516.  * Function : wts_VerifyAllFlash
  2517.  *            Function to Read Hex file and verify flash with contents
  2518.  * Input    :
  2519.  * Output   :
  2520.  * Return   : None
  2521.  * ----------------------------------------------------------------------*/
  2522. BOOL wts_VerifyAllFlash( void )
  2523. {
  2524.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  2525.     int                 Section, Bank;
  2526.     U32                 Length;
  2527.     U32                 ReadOffset;
  2528.     U32                 NumberOfBytes;
  2529.     U8                  *Buffer_p;
  2530.     BOOL                VerifyFailed;
  2532.     /* check data size */
  2533.     if ( FlashSize == 0 )
  2534.         VerifyFailed = TRUE;
  2535.     else
  2536.     {
  2537.         VerifyFailed = FALSE;
  2538.         STTBX_Print(("tt+------------+------------+n"));
  2539.     }
  2541.     /* Find out which blocks are to be verified */
  2542.     /* Read the data and compare */
  2544.     for ( Section = 0; ( Section < TOTAL_BLOCKS ) && ( VerifyFailed == FALSE ); Section ++ )
  2545.     {
  2546.         if ( SectionInfo[Section].Block != 0xFF )
  2547.         {
  2548.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  2549.             Length = BlockInfo[ SectionInfo[Section].Block ].Length;
  2550.             ReadOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  2552.             /* allocate temp buffer to put flash data in */
  2553.             Buffer_p = memory_allocate( SystemPartition, Length );
  2554.             if ( Buffer_p != NULL )
  2555.             {
  2556.                 STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  2557.                          SectionInfo[Section].Block,
  2558.                          SectionInfo[Section].Address,
  2559.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  2561.                 ErrCode = STFLASH_Read( wts_FLASHHndl[Bank],
  2562.                                         ReadOffset,
  2563.                                         Buffer_p,
  2564.                                         SectionInfo[Section].Size,
  2565.                                         &NumberOfBytes );
  2566.                 if(ErrCode != ST_NO_ERROR)
  2567.                 {
  2568.                     STTBX_Print(("STFLASH_Read %sn",wts_GetErrorText(ErrCode)));
  2569.                 }
  2571.                 if ( memcmp( Buffer_p,(U8*)&FlashData_p[SectionInfo[Section].Offset],
  2572.                              SectionInfo[Section].Size ) != 0 )
  2573.                 {
  2574.                     STTBX_Print(("Verify FAILEDn"));
  2575.                     VerifyFailed = TRUE;
  2576.                 }
  2577.                 else
  2578.                     STTBX_Print(("VERIFIEDn"));
  2580.                 /* deallocate temp buffer */
  2581.                 memory_deallocate( SystemPartition, Buffer_p );
  2582.             }
  2583.         }
  2584.     }
  2586.     wts_FreeFileDataBuffer();
  2587.     
  2588.     if ( VerifyFailed == TRUE )
  2589.     {
  2590.         STTBX_Print(("!!!! VERIFY Failed !!!!n"));
  2591.         return TRUE;
  2592.     }
  2593.     else
  2594.     {
  2595.         STTBX_Print(("tt+------------+------------+n"));
  2596.         return FALSE;
  2597.     }
  2599. } /* end wts_VerifyAllFlash */
  2602. /*-------------------------------------------------------------------------
  2603.  * Function : wts_VerifyLNBFlash
  2604.  *            Function to Read Hex file and verify flash with contents
  2605.  * Input    :
  2606.  * Output   :
  2607.  * Return   : None
  2608.  * ----------------------------------------------------------------------*/
  2609. BOOL wts_VerifyLNBFlash( void )
  2610. {
  2611.     ST_ErrorCode_t      ErrCode = ST_NO_ERROR;
  2612.     int                 Section, Bank;
  2613.     U32                 Length;
  2614.     U32                 ReadOffset;
  2615.     U32                 NumberOfBytes;
  2616.     U8                  *Buffer_p;
  2617.     BOOL                VerifyFailed;
  2619.     /* check data size */
  2620.     if ( FlashSize == 0 )
  2621.         VerifyFailed = TRUE;
  2622.     else
  2623.     {
  2624.         VerifyFailed = FALSE;
  2625.         STTBX_Print(("tt+------------+------------+n"));
  2626.     }
  2628.     /* Find out which blocks are to be verified */
  2629.     /* Read the data and compare */
  2631.     for ( Section = CODE_BLOCKS; ( Section < TOTAL_BLOCKS ) && ( VerifyFailed == FALSE ); Section ++ )
  2632.     {
  2633.         if ( SectionInfo[Section].Block != 0xFF )
  2634.         {
  2635.             Bank = BlockInfo[ SectionInfo[Section].Block ].Bank;
  2636.             Length = BlockInfo[ SectionInfo[Section].Block ].Length;
  2637.             ReadOffset = SectionInfo[Section].Address - BaseAddress[Bank];
  2639.             /* allocate temp buffer to put flash data in */
  2640.             Buffer_p = memory_allocate( SystemPartition, Length );
  2641.             if ( Buffer_p != NULL )
  2642.             {
  2643.                 STTBX_Print(("block %2dt| 0x%08x | 0x%08x | ",
  2644.                          SectionInfo[Section].Block,
  2645.                          SectionInfo[Section].Address,
  2646.                          SectionInfo[Section].Address + SectionInfo[Section].Size - 1 ));
  2648.                 ErrCode = STFLASH_Read( wts_FLASHHndl[Bank],
  2649.                                         ReadOffset,
  2650.                                         Buffer_p,
  2651.                                         SectionInfo[Section].Size,
  2652.                                         &NumberOfBytes );
  2653.                 if(ErrCode != ST_NO_ERROR)
  2654.                 {
  2655.                     STTBX_Print(("STFLASH_Read %sn",wts_GetErrorText(ErrCode)));
  2656.                 }
  2658.                 if ( memcmp( Buffer_p,(U8*)&FlashData_p[SectionInfo[Section].Offset],
  2659.                              SectionInfo[Section].Size ) != 0 )
  2660.                 {
  2661.                     STTBX_Print(("Verify FAILEDn"));
  2662.                     VerifyFailed = TRUE;
  2663.                 }
  2664.                 else
  2665.                     STTBX_Print(("VERIFIEDn"));
  2667.                 /* deallocate temp buffer */
  2668.                 memory_deallocate( SystemPartition, Buffer_p );
  2669.             }
  2670.         }
  2671.     }
  2673.     wts_FreeFileDataBuffer();
  2674.     
  2675.     if ( VerifyFailed == TRUE )
  2676.     {
  2677.         STTBX_Print(("!!!! VERIFY Failed !!!!n"));
  2678.         return TRUE;
  2679.     }
  2680.     else
  2681.     {
  2682.         STTBX_Print(("tt+------------+------------+n"));
  2683.         return FALSE;
  2684.     }
  2686. } /* end wts_VerifyLNBFlash */
  2689. #endif
  2691. /* Testtool Functions --------------------------------------------------- */
  2693. #ifdef TESTTOOL
  2694. /*-------------------------------------------------------------------------
  2695.  * Function : wts_TTFLASH_GetParams
  2696.  *            
  2697.  * Input    : *pars_p, *result_sym_p
  2698.  * Output   :
  2699.  * Return   : TRUE if error, FALSE if success
  2700.  * ----------------------------------------------------------------------*/
  2701. static BOOL wts_TTFLASH_GetParams( STTST_Parse_t *pars_p, char *Result )
  2702. {
  2703.     ST_ErrorCode_t      ErrCode;
  2704.     STFLASH_Params_t    FLASHParams;
  2705.     STFLASH_Params_t    *FLASHParams_p;
  2706.     U8                  BankNum;
  2707.     U8                  Block;
  2708.     U32                 BlockStart;
  2710.     /* Get Flash bank parameter from command line */
  2711.     STTST_GetInteger( pars_p, BANK0, (S32 *)&BankNum );
  2713.     ErrCode = wts_FLASH_GetParams(BankNum, &FLASHParams);
  2715.     FLASHParams_p = &FLASHParams;
  2716.     BlockStart = (U32) FLASHParams_p->InitParams.BaseAddress;
  2718.     STTBX_Print(("Bank %d, Blocks %dn", BankNum,
  2719.                  FLASHParams_p->InitParams.NumberOfBlocks ));
  2720.     STTBX_Print(("Base Address      0x%08xn", FLASHParams_p->InitParams.BaseAddress ));
  2721.     STTBX_Print(("VppAddress        0x%08xn",FLASHParams_p->InitParams.VppAddress ));
  2722.     STTBX_Print(("Manufacturer Code 0x%08Xn", FLASHParams_p->ManufactCode ));
  2723.     STTBX_Print(("Device Code       0x%08Xn", FLASHParams_p->DeviceCode ));
  2724.     STTBX_Print(("AccessWidths      Min %d, Max %dn",
  2725.                  FLASHParams_p->InitParams.MinAccessWidth,
  2726.                  FLASHParams_p->InitParams.MaxAccessWidth ));
  2728.     STTBX_Print(("Block Start      Size     Typen"));
  2729.     for ( Block = 0; Block < FLASHParams_p->InitParams.NumberOfBlocks; Block ++)
  2730.     {
  2731.         STTBX_Print(("%5d 0x%08x %8d ",
  2732.                      Block,
  2733.                      BlockStart,
  2734.                      FLASHParams_p->InitParams.Blocks[Block].Length ));
  2735.         switch( FLASHParams_p->InitParams.Blocks[Block].Type )
  2736.         {
  2737.         case STFLASH_EMPTY_BLOCK:
  2738.             STTBX_Print(("Emptyn"));
  2739.             break;
  2741.         case STFLASH_BOOT_BLOCK:
  2742.             STTBX_Print(("Bootn"));
  2743.             break;
  2745.         case STFLASH_PARAMETER_BLOCK:
  2746.             STTBX_Print(("Parametern"));
  2747.             break;
  2749.         case STFLASH_MAIN_BLOCK:
  2750.             STTBX_Print(("Mainn"));
  2751.             break;
  2753.         default:
  2754.             STTBX_Print(("Unknownn"));
  2755.             break;
  2756.             
  2757.         }
  2758.         BlockStart += FLASHParams_p->InitParams.Blocks[Block].Length;
  2759.     }
  2761.     return ( ErrCode == ST_NO_ERROR ? FALSE : TRUE);
  2763. } /* end wts_TTFLASH_GetParams */
  2765. /*-------------------------------------------------------------------------
  2766.  * Function : wts_TT_SetupBlockInfo
  2767.  *            Setup FLASH Block Info
  2768.  * Input    :
  2769.  * Output   :
  2770.  * Return   : None
  2771.  * ----------------------------------------------------------------------*/
  2772. static BOOL wts_TT_SetupBlockInfo( STTST_Parse_t *pars_p, char *Result )
  2773. {
  2774.     ST_ErrorCode_t      ErrCode;
  2775.     
  2776.     ErrCode = wts_FLASH_SetupBlockInfo();
  2777.     
  2778.     return ( ErrCode != ST_NO_ERROR ? TRUE : FALSE );
  2779. }
  2781. /*-------------------------------------------------------------------------
  2782.  * Function : wts_TT_FlashSetup
  2783.  *            Setup FLASH Block Info
  2784.  * Input    :
  2785.  * Output   :
  2786.  * Return   : None
  2787.  * ----------------------------------------------------------------------*/
  2788. static BOOL wts_TT_FlashSetup( STTST_Parse_t *pars_p, char *Result )
  2789. {
  2790.     ST_ErrorCode_t      ErrCode;
  2791.     
  2792.     ErrCode = wts_FLASH_Setup();
  2793.     
  2794.     return ( ErrCode != ST_NO_ERROR ? TRUE : FALSE );
  2795. }
  2798. /*-------------------------------------------------------------------------
  2799.  * Function : wts_TT_ReadFile
  2800.  *            Function to Read Hex file
  2801.  * Input    :
  2802.  * Output   :
  2803.  * Return   : None
  2804.  * ----------------------------------------------------------------------*/
  2805. static BOOL wts_TT_ReadFile( STTST_Parse_t *pars_p, char *Result )
  2806. {
  2807.     char        Filename[81];
  2809.     STTST_GetString( pars_p, "flash.hex", Filename, 80 );
  2811.     /* Read File */
  2812.     /* Convert from file format to memory format */
  2813.     
  2814.     STTBX_Print(("filename = %sn",Filename));
  2816.     if ( FlashSize == 0 )
  2817.         FlashSize = wts_FLASH_ReadFile( Filename );
  2818.     
  2819.     return ( FlashSize == 0 ? TRUE : FALSE );
  2820. }
  2822. /*-------------------------------------------------------------------------
  2823.  * Function : wts_TT_EraseFlash
  2824.  *            Function to erase flash for loaded data
  2825.  * Input    :
  2826.  * Output   :
  2827.  * Return   : None
  2828.  * ----------------------------------------------------------------------*/
  2829. static BOOL wts_TT_EraseFlash( STTST_Parse_t *pars_p, char *Result )
  2830. {
  2831.     char        Text[11];
  2832.     BOOL        EraseAll;
  2834.     STTST_GetString( pars_p, "", Text, 10 );
  2835.     if ( strcmp( Text, "ALL" ) == 0 )
  2836.     {
  2837.         EraseAll = TRUE;
  2838.         STTBX_Print(("EraseAll = TRUEn"));
  2839.     }
  2840.     else
  2841.     {
  2842.         EraseAll = FALSE;
  2843.         STTBX_Print(("EraseAll = FALSEn"));
  2844.     }    
  2845.     return wts_EraseFlash( EraseAll );
  2846. }
  2848. /*-------------------------------------------------------------------------
  2849.  * Function : wts_TT_ProgramFlash
  2850.  *            Function to program flash with loaded data
  2851.  * Input    :
  2852.  * Output   :
  2853.  * Return   : None
  2854.  * ----------------------------------------------------------------------*/
  2855. static BOOL wts_TT_ProgramFlash( STTST_Parse_t *pars_p, char *Result )
  2856. {
  2857.     return wts_ProgramFlash();
  2858. }
  2860. /*-------------------------------------------------------------------------
  2861.  * Function : wts_TT_VerifyFlash
  2862.  *            Function to verify flash with loaded data
  2863.  * Input    :
  2864.  * Output   :
  2865.  * Return   : None
  2866.  * ----------------------------------------------------------------------*/
  2867. static BOOL wts_TT_VerifyFlash( STTST_Parse_t *pars_p, char *Result )
  2868. {
  2869.     return wts_VerifyFlash();
  2870. }
  2872. #endif /* TESTTOOL */
  2874. /*-------------------------------------------------------------------------
  2875.  * Function : FLASH_InitCommands
  2876.  *            Definition of the macros
  2877.  *            (commands and constants to be used with Testtool)
  2878.  * Input    :
  2879.  * Output   :
  2880.  * Return   : TRUE if error, FALSE if success
  2881.  * ----------------------------------------------------------------------*/
  2882. BOOL wts_FLASH_InitCommand( void )
  2883. {
  2884.     BOOL RetErr;
  2886.     RetErr = FALSE;
  2887.     
  2888.   #ifdef TESTTOOL  
  2889.     RetErr |= STTST_RegisterCommand("FLASH_GETPARMS", wts_TTFLASH_GetParams, "Get FLASH Parameters");
  2890.     RetErr |= STTST_RegisterCommand("FLASH_BLOCKINFO",    wts_TT_SetupBlockInfo, "Get Flash Block Data");
  2891.     RetErr |= STTST_RegisterCommand("FLASH_SETUP",    wts_TT_FlashSetup, "Setup Flash Bank(Init&Open) Data");
  2892.     RetErr |= STTST_RegisterCommand("FLASH_ERASE",    wts_TT_EraseFlash, "<ALL> Erase Flash");
  2893.     RetErr |= STTST_RegisterCommand("FLASH_PROGRAM",  wts_TT_ProgramFlash, "Program Flash");
  2894.     RetErr |= STTST_RegisterCommand("FLASH_READ", wts_TT_ReadFile, "<Filename> Read Flash Data");
  2895.     RetErr |= STTST_RegisterCommand("FLASH_VERIFY",   wts_TT_VerifyFlash, "Verify Flash");
  2896.   #endif
  2897.     
  2898.     return( RetErr );
  2899. } /* end wts_FLASH_InitCommand */
  2901. /* EOF --------------------------------------------------------------------- */