load.c

TDK 6521 SOC 芯片 DEMO程序

/***************************************************************************
 * This code and information is provided "as is" without warranty of any   *
 * kind, either expressed or implied, including but not limited to the     *
 * implied warranties of merchantability and/or fitness for a particular   *
 * purpose.                                                                *
 *                                                                         *
 * Copyright (C) 2005 Teridian Semiconductor Corp. All Rights Reserved.     *
 *                                                                         *
 ***************************************************************************/
//**************************************************************************
//  DESCRIPTION: 71M652x POWER METER - Load Routines.
// 
//  AUTHOR:  MTF
//
//  HISTORY: See end of file 
//**************************************************************************
// File:  LOAD.C
//               
#include "options.h"
#if LOAD && CLI && (SERIAL0_CLI || SERIAL1_CLI)
#include "ce.h"
#include "ce_ce.h"
#include "ce_dat.h"
#include "cli.h"
#include "eeprom.h"
#include "io.h"
#include "main.h"
#include "sercli.h"
#include "serial.h"
#include "stm.h"
#include <string.h>
#include <ctype.h>
#include <setjmp.h>

#define VERIFY                          // Do flash verify.  

/*** Public variables declared within this module ***/
// None.

/*** Private functions declared within this module ***/
static uint8_t ask_Y_or_N (void);
static uint8_t ctoh (uint8_t c);

static void Download (void);
static int32_t get_addr (uint8x_t *width);
static int32_t get_data (uint8x_t *width);
static int32_t get_hex_long (uint8_t c, uint8x_t *width);

static void Upload (void);
static uint8x_t *put_hex_data (uint8x_t *p, uint8x_t *c, uint8_t width);
static uint8x_t *put_hex (uint8x_t *p, uint8_t c);

/*** Private variables declared within this module ***/
enum eLOAD_DIR { NOLOAD, UPLOAD, DOWNLOAD };
static enum eLOAD_DIR load_direction;

enum eLOAD 
{ LOAD_CE_CODE_DEFAULT, LOAD_CE_DATA_DEFAULT,
  LOAD_CE_CODE,         LOAD_CE_DATA,
  LOAD_EEPROM,          LOAD_FLASH,           LOAD_MPU_DATA,
  LOAD_CE_DATA_MONITOR, LOAD_MPU_MONITOR };

static enum eLOAD load;

void cmd_download (void)
{
    uint8_t idata c;

    cli_index--;
    c = '\0';
    put_char (&c);                       // Overlay '@'.

    if (DOWNLOAD == load_direction)
    {
       if (CE_ACTIVE && (LOAD_CE_CODE == load))
       {
          start_tx_rslt ("\r\nCE Active, can not write CE code space\r\n");
          cli_index--;          
       }
       else
          Download ();
    }
    else if (UPLOAD == load_direction)
    {
       Upload ();
    }
    else
       cmd_error ();
}

#define NUM_PAGES_CE_CODE (0x1000 / FPAGE_SIZE)

#if TRACE10
#define NUM_PAGES_CE_DATA (0x0400 / FPAGE_SIZE)
#elif M6520
#define NUM_PAGES_CE_DATA (0x0200 / FPAGE_SIZE)
#endif

static uint8r_t Warning[]        = "\r\n*** W A R N I N G ***\r\n";
static uint8r_t Erase[]          = "You are about to Erase ";
static uint8r_t Code_Defaults[]  = "CE Code Defaults ";
static uint8r_t Data_Defaults[]  = "CE Data Defaults ";
static uint8r_t Y_or_N[]         = "\r\nAre you sure? Y or N "; 
static uint8r_t Erased[]         = " Erased\r\n";
static uint8r_t Not_Erased[]     = " Not Erased\r\n";

//-------------------------------------------------------------------//
void cmd_load (void)
{
    uint8_t xdata cb;
    uint8_t xdata page;
    uint8_t  data c, d;

    if (!done (&c))
    {
       c = toupper (c);

       switch (c)
       {
          case 'C':
             switch (c = toupper (get_char_d (&d)))
             {
                case 'D':
                   if ('=' == (c = get_char ()))
                      load_direction = DOWNLOAD;
                   else if ('?' == c)
                      load_direction = UPLOAD;
                   else
                      load_direction = NOLOAD;
                
                   if (DOWNLOAD == load_direction)
                   {
                      start_tx_rslt (Warning);
                      start_tx_rslt (Erase);
                      start_tx_rslt (Code_Defaults);
                      cb = ask_Y_or_N ();
                      start_tx_rslt (Code_Defaults);

                      if ('Y' == toupper (cb))
                      {
                         c = NUM_PAGES_CE_CODE;
                         page = (uint16_t) CeCode >> 8;

                         while (c--)
                         {
                            EA = FALSE;                   // Turn OFF all interrupts.
                            FPAGE = page;                 // Set Flash Page Erase Enable.
                            ERASE = PAGE_ERASE_;          // Initiate page erase.
                            EA = TRUE;                    // Turn interrupts back ON.
                            page += 2;
                            main_background ();
                         }

                         start_tx_rslt (Erased);
                         load = LOAD_CE_CODE_DEFAULT;
                         start_tx_rslt ("Commence CE Code Default Download\r\n");
                      }
                      else
                         start_tx_rslt (Not_Erased);
                   }
                   else if (UPLOAD == load_direction)
                   {
                      load = LOAD_CE_CODE_DEFAULT;
                      start_tx_rslt ("//CE Program Image File (Verilog Hex) Upload\r\n");
                   }
                   else
                      cmd_error ();
                   break;

                default:
                   cli_index = d;
                   load = LOAD_CE_CODE;
                   start_tx_rslt ("Commence CE Code ");
                   break;
             }
             break;

          case 'D':
             switch (c = toupper (get_char_d (&d)))
             {
                case 'D':
                   if ('=' == (c = get_char ()))
                      load_direction = DOWNLOAD;
                   else if ('?' == c)
                      load_direction = UPLOAD;
                   else
                      load_direction = NOLOAD;
                
                   if (DOWNLOAD == load_direction)
                   {
                      start_tx_rslt (Warning);
                      start_tx_rslt (Erase);
                      start_tx_rslt (Data_Defaults);
                      cb = ask_Y_or_N ();
                      start_tx_rslt (Data_Defaults);

                      if ('Y' == toupper (cb))
                      {
                         c = NUM_PAGES_CE_DATA;
                         page = (uint16_t) CeData >> 8;

                         while (c--)
                         {
                            EA = FALSE;                   // Turn OFF all interrupts.
                            FPAGE = page;                 // Set Flash Page Erase Enable.
                            ERASE = PAGE_ERASE_;          // Initiate page erase.
                            EA = TRUE;                    // Turn interrupts back ON.
                            page += 2;
                            main_background ();
                         }

                         start_tx_rslt (Erased);
                         load = LOAD_CE_DATA_DEFAULT;
                         start_tx_rslt ("Commence CE Data Default Download\r\n");
                      }
                      else
                         start_tx_rslt (Not_Erased);
                   }
                   else if (UPLOAD == load_direction)
                   {
                      load = LOAD_CE_DATA_DEFAULT;
                      start_tx_rslt ("Commence CE Data Default Upload\r\n");
                   }
                   else
                      cmd_error ();

                   break;

                case 'M':            // Monitor CE data locations.
                   load_direction = UPLOAD;
                   load = LOAD_CE_DATA_MONITOR;
                   start_tx_rslt ("Commence CE Data Monitor\r\n");
                   start_tx_rslt ("Hit any key to abort\r\n");
                   return;           // Exit early.

                default:
                   cli_index = d;
                   load = LOAD_CE_DATA;
                   start_tx_rslt ("Commence CE Data ");
                   break;
             }
             break;

          case 'E':
             load = LOAD_EEPROM;
             start_tx_rslt ("Commence Serial EEProm ");
             break;

          case 'F':
             load = LOAD_FLASH;
             start_tx_rslt ("Commence Flash ");
             break;

          case 'X':
             switch (c = toupper (get_char_d (&d)))
             {
                case 'M':
                   load_direction = UPLOAD;
                   load = LOAD_MPU_MONITOR;
                   start_tx_rslt ("Commence MPU Monitor\r\n");
                   start_tx_rslt ("Hit any key to abort\r\n");
                   return;           // Exit early.

                default:
                   load = LOAD_MPU_DATA;
                   start_tx_rslt ("Commence MPU ");
                   break;
             }
             break;

          default:
             break;
       }     

       if (!done (&c))
       {
          if ('=' == c)
             load_direction = DOWNLOAD;
          else if ('?' == c)
             load_direction = UPLOAD;
          else
             load_direction = NOLOAD;

          if (DOWNLOAD == load_direction)
             start_tx_rslt ("Download\r\n");          
          else if (UPLOAD == load_direction)
             start_tx_rslt ("Upload\r\n");          
       }
    }
}

static uint8_t ask_Y_or_N (void)
{
    uint8_t xdata cb;

    start_tx_rslt (Y_or_N);

    do
    {
       main_background ();
    } while (Serial_CRx (port, &cb, 1) < 1);

    if ('Y' == toupper (cb))
       start_tx_rslt ("Y");
    else
       start_tx_rslt ("N");

    send_crlf ();
    return (cb);
}

static void Download (void)
{
    bool Ok;
    uint8_t xdata width;
    uint8_t xdata width_data;
    int32_t xdata addr;
    uint8_16_32_t xdata d;
	uint8_t idata c;

    uint8x_t  * xdata p_1byte;
    uint16x_t * xdata p_2byte;
    int32x_t  * xdata p_4byte;

	#if CLI_EEPROM
    struct EEPROM_t xdata eeWrite;
	#endif

    addr = get_addr (&width);
    d.l  = get_data (&width_data);       
    width = width_data;
    
    if (width_data)
    {
       switch (load)
       {
          #if TRACE10
          case LOAD_CE_CODE:
             p_2byte = (uint16x_t *) (CE_CODE_BASE + (addr << 1));
             break;
          #endif

          case LOAD_CE_CODE_DEFAULT:
             p_2byte = (uint16x_t *) (CeCode + addr);    // Pointer addition used.
             break;

          case LOAD_CE_DATA:
             p_4byte = (int32x_t *) (CE_DATA_BASE + (addr << 2));
             break;

          case LOAD_CE_DATA_DEFAULT:
             p_4byte = (int32x_t *) (CeData + addr);    // Pointer addition used.
             break;

          case LOAD_EEPROM:
             break;

          case LOAD_FLASH:
          case LOAD_MPU_DATA:
             switch (width_data)
             {
                case 1:  p_1byte = (uint8x_t  *) (0 + addr);         break;
                case 2:  p_2byte = (uint16x_t *) (0 + (addr << 1));  break;
                case 4:  p_4byte =  (int32x_t *) (0 + (addr << 2));  break;
             }
             break;
       }
    }

    while (width)
    {
       switch (load)
       {
          case LOAD_CE_CODE_DEFAULT:
             EA = FALSE;
             FCTRL = PWE_;   *(p_1byte + 0) = d.c[2];	FCTRL = 0;	
             FCTRL = PWE_;   *(p_1byte + 1) = d.c[3];	FCTRL = 0;	
             EA = TRUE;

#ifdef VERIFY
             if (* (uint16r_t *) p_2byte != d.i[1])
             {
                start_tx_rslt ("\r\nBAD VERIFY\r\n");
                Ok = FALSE;
             }
#endif
             p_1byte += 2;  p_2byte++;
             break;

          case LOAD_CE_DATA_DEFAULT:
             EA = FALSE;
             FCTRL |= PWE_;  *(p_1byte + 0) = d.c[0];	FCTRL = 0;	
             FCTRL |= PWE_;  *(p_1byte + 1) = d.c[1];	FCTRL = 0;	
             FCTRL |= PWE_;  *(p_1byte + 2) = d.c[2];	FCTRL = 0;	
             FCTRL |= PWE_;  *(p_1byte + 3) = d.c[3];	FCTRL = 0;	
             EA = TRUE;
#ifdef VERIFY
             if (* (int32r_t *) p_4byte != d.l)
             {
                start_tx_rslt ("\r\nBAD VERIFY\r\n");
                Ok = FALSE;
             }
#endif
              p_1byte += 4; p_4byte++;
             break;

          #if TRACE10
          case LOAD_CE_CODE:
             *p_2byte++ = d.i[1];
             break;
          #endif

          case LOAD_CE_DATA:
             *p_4byte++ = memget_ce ((int32x_t *) &d.l);
             break;

		  #if CLI_EEPROM
          case LOAD_EEPROM:
             eeWrite.addr = addr;    
             eeWrite.len = width_data;

             switch (width_data)
             {
                case 1:  eeWrite.buffer = (uint8x_t *) &d.c[3];  addr += 1;  break;
                case 2:  eeWrite.buffer = (uint8x_t *) &d.i[1];  addr += 2;  break;
                case 4:  eeWrite.buffer = (uint8x_t *) &d.l;     addr += 4;  break;
             }

             do 
             {
                main_background ();
                eeWrite.status = memcpy_prx (eeWrite.addr, eeWrite.buffer, eeWrite.len);
             } while (_ERR_PENDING == *eeWrite.status);
             break;
		  #endif	

          case LOAD_FLASH:
             switch (width_data)
             {
                case 1: // FLASH WRITE
                   EA = FALSE;
                   FCTRL |= PWE_;  *p_1byte = d.c[3];	FCTRL = 0;	
                   EA = FALSE;
                   p_1byte++;
                   break;

                case 2: // FLASH WRITE
                   EA = FALSE;