btldr_ui.c~

针对德州仪器DM270开发板的bootloader,其实现了内核的下载以及文件系统的下载

          case 'u':
            io_change_con(USB);
            break;
#endif
        }
        break;
      case '8':
        util_printf("new val = ");
        util_gets(par->server_IP, par->MAX_STR_LEN);
        util_strip_CRLF(par->server_IP);
        break;
      case '9':
        util_printf("new val = ");
        util_gets(par->server_MAC, par->MAX_STR_LEN);
        util_strip_CRLF(par->server_MAC);
        break;
      case 'a':
        util_printf("new val = ");
        util_gets(par->device_IP, par->MAX_STR_LEN);
        util_strip_CRLF(par->device_IP);
        break;
      case '7':
        util_printf("new val = ");
        util_gets(par->device_MAC, par->MAX_STR_LEN);
        util_strip_CRLF(par->device_MAC);
        break;
      case 'b':
        util_printf("new val = ");
        util_gets(par->kernel_path, par->MAX_STR_LEN);
        util_strip_CRLF(par->kernel_path);
        break;
      case 'c':
        util_printf("new val = ");
        util_gets(par->filesys_path, par->MAX_STR_LEN);
        util_strip_CRLF(par->filesys_path);
        break;
      case '6':
        util_printf("new val = ");
        util_gets(par->kernel_cmdline, par->MAX_STR_LEN);
        util_strip_CRLF(par->kernel_cmdline);
        break;
#if defined(DSC24_OSD)
      // OSD Logo Items
      case 'd':
        util_printf("new val = ");
        util_gets(par->OSD_path, par->MAX_STR_LEN);
        util_strip_CRLF(par->OSD_path);
        break;
      case 'e':
        util_printf("new val = ");
        util_gets(par->OSD_enable, par->MAX_STR_LEN);
        util_strip_CRLF(par->OSD_enable);
        break;
#endif
      default :
        break;
    }
  }
}
#endif

#ifndef BSPCONF_BTLDR_NO_MENUS
/******************************
 Routine:
 Description:
 ******************************/
static void copy_to_flash_menu(void)
{
  int ret = 0;
  while (1) {
    clear();
    util_printf(  "Store RAM [comp] to Flash\n");
    util_printf(  "-------------------------\n");
    util_printf(  "  0. --to MAIN--\n"           );
    util_printf(  "  1. Store [Bootloader]\n"    );
    util_printf(  "  2. Store [Params]\n"        );
    util_printf(  "  3. Store [Kernel]\n"        );
    util_printf(  "  4. Store [FileSystem]\n"    ); 
#ifdef REPLACE_VECTOR_TABLE
    util_printf(  "  5. Store [Vector table]\n"  ); 
#endif
    util_printf(  "\n"                           );
    util_printf(  "  Which? "                    );

    meter_line_len = 0;
    util_gets(cmd,CMDMAX);
    switch (cmd[0]) {
      case '0': return; break;
      case '1': ret = cmd_copy_comp(c_BOOTLDR,sd_SRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
      case '2': ret = cmd_copy_comp(c_PARAMS, sd_SRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
//      case '1': ret = cmd_copy_comp(c_BOOTLDR,sd_SDRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
//      case '2': ret = cmd_copy_comp(c_PARAMS, sd_SDRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
      case '3': ret = cmd_copy_comp(c_KERNEL, sd_SDRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
      case '4': ret = cmd_copy_comp(c_FILESYS,sd_SDRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
#ifdef REPLACE_VECTOR_TABLE
      case '5': ret = cmd_copy_comp(c_VECTORS,sd_SDRAM,sd_FLASH,f_NA,progress_meter,METER_INTERV); break;
#endif
      default : break;
    }

    if (ret != 0) {
       util_printf("\nWarning: flash write error - flash not erased; Aborting\n");
       util_printf("Press <Enter>....\n");
       util_gets(cmd,CMDMAX);
    }
  }
}
#endif

#ifndef BSPCONF_BTLDR_NO_MENUS
/******************************
 Routine:
 Description:
 ******************************/
static void copy_to_SDRAM_menu1(void)
{
  port_format_t format;
  src_dest_t src_port;
  switch (par->PORT_FIELD[0]) {
    case 'S':
    case 's':
      src_port = sd_SERPORT;
      break;
    case 'P':
    case 'p':
      src_port = sd_PARPORT;
      break;
    case 'E':
    case 'e':
      src_port = sd_TFTP;
      break;
    case 'F':
    case 'f':
      src_port = sd_FLASH;
      break;
    case 'R':
    case 'r':
      src_port = sd_SRAM;
      break;
/*    case 'r':
      src_port = sd_SDRAM;
      break;*/
    default:
      src_port = sd_SERPORT;
      break;
  }
  switch (par->FORMAT_FIELD[0]) {
   case 'R':
   case 'r':
      format = f_RR_BINARY;
      break;
   case 'S':
   case 's':
      format = f_SREC;
      break;
   default :
      format = f_SREC;
      break;
  }
  while (1) {
    clear();
    util_printf(  "Load [comp] from -%s- I/O\n",par->PORT_FIELD);
    util_printf(  "---------------------------------\n");
    util_printf(  "  0. --to MAIN--\n"                 );
    util_printf(  "  1. Load [Kernel]\n"               );
    util_printf(  "  2. Load [FileSystem]\n"           );
#if defined(DSC24_OSD)
    util_printf(  "  3. Load [OSD Logo] (part of params)\n"           );
#endif
    util_printf(  "\n"                                 );
    util_printf(  "  Which? "                          );

    meter_line_len = 0;
    util_gets(cmd,CMDMAX);
    switch (cmd[0]) {
      case '0': return; break;
      case '1':
        cmd_copy_comp(c_KERNEL,src_port,sd_SDRAM,format,progress_meter,METER_INTERV);
        break;
      case '2':
        cmd_copy_comp(c_FILESYS,src_port,sd_SDRAM,format,progress_meter,METER_INTERV);
        break;
#if defined(DSC24_OSD)
      case '3':
        cmd_copy_comp(c_PARAMS,src_port,sd_SDRAM,format,progress_meter,METER_INTERV);
        break;
#endif
      default : break;
    }
  }
}
#endif

#ifdef BSPCONF_BTLDR_MEMORY_DEBUG
/******************************
 Routine:     cmd_verify_comp
 Description: verifies the contentes of SDRAM against flash
 ******************************/

void cmd_verify_comp(comp_t c)        //component
{
  int flash_addr;
  int sdram_addr;
  int len;
  int dummy;
  int err=0;
  int ret;
  char addrstr[11];
  int i, text_addr, etext_addr, text_offset;

  ret = get_flash_comp_addresses(c, &flash_addr, &dummy, &dummy);

  if ( ! ret ) {
     util_printf( "Error: Component is not flash resident\n" );
     return;
  }

  ret = get_sdram_comp_addresses(c, &sdram_addr, &dummy, &dummy);
  if ( ! ret ) {
     util_printf( "Error: Component is not SDRAM resident\n" );
     return;
  }

  /* Make adjustments so we only compare the .text region */

  for (i = 0; i < sizeof(addrstr); i++) {
    addrstr[i] = 0;
  }
  util_printf( "Enter value of _text  symbol in System.map: " );
  util_gets(addrstr, sizeof(addrstr) - 1);
  util_strip_CRLF(addrstr);
  i = (addrstr[1] == 'x') ? 2 : 0; /* skip the '0x' if it's there */
  util_hexstrtoint(addrstr + i, &text_addr);

  for (i = 0; i < sizeof(addrstr); i++) {
    addrstr[i] = 0;
  }
  util_printf( "Enter value of _etext symbol in System.map: " );
  util_gets(addrstr, sizeof(addrstr) - 1);
  util_strip_CRLF(addrstr);
  i = (addrstr[1] == 'x') ? 2 : 0; /* skip the '0x' if it's there */
  util_hexstrtoint(addrstr + i, &etext_addr);

  len = etext_addr - text_addr;
  text_offset = text_addr - sdram_addr;
  flash_addr += text_offset;
  sdram_addr += text_offset;

  flash_addr += 16; /*skip flash header */

  util_printf( "Starting flash address: %X\n", flash_addr );
  util_printf( "Starting SDRAM address: %X\n", sdram_addr );
  util_printf( "       Number of bytes: %X\n\n", len );

  while (len--) {
    /* would be faster to change this to a 32 bit compare */
    if ( *((char *)flash_addr) != *((char *)sdram_addr) ) {
      if (err < 25) {
	util_printf("   Verify error flash %X=%b SDRAM %X=%b\n",
		    flash_addr, *((char *)flash_addr), 
		    sdram_addr, *((char *)sdram_addr));
      }
      err++;
    }
    flash_addr++;
    sdram_addr++;
  }
  
  if (err) {
    util_printf("   %d errors encountered (not all may be shown)\n", err);
  }
  else {
    util_printf("   No errors encountered");
  }
}

/******************************
 Routine:      verify_sdram_menu
 Description:  Verifies component loaded into SDRAM is intact
 ******************************/
static void verify_sdram_menu(void)
{
  while (1) {
    clear();
    util_printf(  "Verify SDRAM Image\n"         );
    util_printf(  "------------------\n"         );
    util_printf(  "  0. --to MAIN--\n"           );
    util_printf(  "  1. Verfiy [Kernel]\n"       );
    util_printf(  "  2. Verify [FileSystem]\n"   ); 
    util_printf(  "\n"                           );
    util_printf(  "  Which? "                    );

    meter_line_len = 0;
    util_gets(cmd,CMDMAX);
    switch (cmd[0]) {
      case '0': 
	return; 
	break;
      case '1': 
	cmd_verify_comp(c_KERNEL);
	break;
      case '2':
	cmd_verify_comp(c_FILESYS);
	break;
      default: 
	break;
    }
  }
}
#endif

/******************************
 Routine:
 Description: prints a region
   of CS8900A memory
 ******************************/

#ifdef BSPCONF_BTLDR_CS8900_DEBUG

extern unsigned short readreg_silent(unsigned short reg_offset);

static void print_rows(unsigned short start_addr, unsigned short end_addr)
{
  unsigned short i;
  int j;

  i=start_addr;
  j=3;

  while (i<end_addr) {
    if (j==3) {
      util_printf("\n%x = %x", i, readreg_silent(i));
      j=0;
    }
    else {
      util_printf(" %x", readreg_silent(i));
      j++;
    }
    i+=2;
  }
}
#endif

/******************************
 Routine:
 Description: prints contents
   of CS8900A memory
 ******************************/

#ifdef BSPCONF_BTLDR_CS8900_DEBUG
static void print_cs8900_memory(void)
{
  clear();
  util_printf("CS8900A Memory Dump\n");
  util_printf("-------------------");

  print_rows(0x0000, 0x0003);
  print_rows(0x0020, 0x0037);
  print_rows(0x0040, 0x0043);
  print_rows(0x0050, 0x0051);
  print_rows(0x0100, 0x013F);
  print_rows(0x0144, 0x0147);
  print_rows(0x0150, 0x015D);

  util_printf("\n\n");
  util_printf("Hit any key to continue");
  util_gets(cmd, CMDMAX);
}
#endif

/******************************
 Routine:
 Description: prints adresses where
   various components are located
 ******************************/

#ifdef BSPCONF_BTLDR_MEMMAP_DEBUG
static void print_memory_map(void)
{
  char cmd[2];
  int is_flash_resident;
  unsigned int start_addr;
  unsigned int size;
  unsigned int max_addr;

  clear();
  util_printf("Flash Memory Map\n");
  util_printf("----------------\n");
  util_printf("   Flash hardware: %X - %X \n",
	      BSPCONF_FLASH_BASE, BSPCONF_FLASH_BASE+BSPCONF_FLASH_SIZE-1);
  is_flash_resident = get_flash_comp_addresses(c_BOOTLDR, &start_addr, &size, &max_addr);
  if (is_flash_resident) {
    util_printf("           rrload: %X - %X   (max %X)\n", 
		start_addr, start_addr + size, max_addr); 
  } else {
    util_printf("           rrload: %X - not loaded (max %X)\n", 
		start_addr, start_addr + size, max_addr); 
  }

  (void)get_flash_comp_addresses(c_PARAMS, &start_addr, &size, &max_addr);
  util_printf("rrload parameters: %X - %X   (max %X)\n",
	      start_addr, start_addr + sizeof(params_t), max_addr); 

  is_flash_resident = get_flash_comp_addresses(c_KERNEL, &start_addr, &size, &max_addr);

  if (is_flash_resident) {
    util_printf("           kernel: %X - %X   (max %X)\n",
		start_addr, start_addr + size, max_addr); 
  } else {
    util_printf("           kernel: %X - not loaded (max %X)\n",
		start_addr, max_addr); 
  }

  is_flash_resident = get_flash_comp_addresses(c_FILESYS, &start_addr, &size, &max_addr);
  if (is_flash_resident) {
    util_printf("      file system: %X - %X   (max %X)\n",
		start_addr, start_addr + size, max_addr); 
  } else {
    util_printf("      file system: %X - not loaded (max %X)\n",
		start_addr, max_addr); 
  }

  util_printf("\n");
  util_printf("\n");
  util_printf("RAM Memory Map\n");
  util_printf("--------------\n");
  util_printf("\n");
  util_printf("\n");

  
  util_printf("Hit any key to continue");
  util_gets(cmd, CMDMAX);
}
#endif

/******************************
 Routine:
 Description: prints information
   about the installed flash chip
 ******************************/

#ifdef BSPCONF_BTLDR_FLASH_DEBUG
static void print_flash_info(void)
{
#define SECTOR_MAP_SIZE 256

  char cmd[2];
  unsigned long flash_id;
  int ret;
  unsigned short cfi_array[CFI_END_ADDR+1];
  unsigned int sector_map[SECTOR_MAP_SIZE];
  int sector_count;
  int i, j;
  int ext_table;

  clear();
  util_printf("Flash Chip Information\n");
  util_printf("----------------------\n");

  ret = read_device_codes(&flash_id);
  if (!ret)
    {
      util_printf("   ERROR: flash chip did not respond to CFI query\n");
    }
  else
    {
      util_printf("   Flash manufacturer / device ID: %X\n", flash_id);

      (void)read_cfi_array(cfi_array, CFI_END_ADDR + 1);
      util_printf("   Flash size (Mbytes): %d\n", 1 << (cfi_array[0x27]-20)); 
      util_printf("   Command Set: %d\n", cfi_array[0x13]);
      ext_table = (cfi_array[0x16] << 8) + cfi_array[0x15];
      util_printf("   Primary Extended table address: %x\n", ext_table); 

      if ( (ext_table > 0) &&
           (cfi_array[ext_table+0] == 'P') &&
           (cfi_array[ext_table+1] == 'R') &&
           (cfi_array[ext_table+2] == 'I') )
      {
              util_printf("   Primary Extended table version: %c.%c\n", 
                          cfi_array[ext_table+0x03], cfi_array[ext_table+0x04]); 
              if (((cfi_array[ext_table+0x03] << 8) | cfi_array[ext_table+0x04] ) >=  0x3131 )
              {
                      util_printf("   Top / Bottom boot flag: %d\n", 
                                  cfi_array[ext_table+0x0F]); 
              }
      }

      util_printf("\n   Common Flash Interface data");