switch (comp) {#ifdef REPLACE_VECTOR_TABLE  case c_VECTORS:      if (TRUE == comp_info[comp].is_SDRAM_resident) {        ret |= flash_write(comp_flash_info[comp].START_OFFSET,                    (unsigned short *) (comp_info[comp].fheader.load_addr),                    comp_info[comp].fheader.num_bytes, NULL);        if (ret == 0) {                comp_info[comp].is_FLASH_resident = TRUE;        }      }      break;#endif    case c_BOOTLDR:       if (TRUE == comp_info[comp].is_SRAM_resident) {//      if (TRUE == comp_info[comp].is_SDRAM_resident) {        ret |= flash_write(comp_flash_info[comp].START_OFFSET,                    (unsigned short *) (comp_info[comp].fheader.load_addr),                    comp_info[comp].fheader.num_bytes,                    get_val_from_addr);        if (ret == 0) {                comp_info[comp].is_FLASH_resident = TRUE;        }      }      break;    case c_PARAMS:        if (TRUE == comp_info[comp].is_SRAM_resident) {//      if (TRUE == comp_info[comp].is_SDRAM_resident) {        ret |= flash_write(comp_flash_info[comp].START_OFFSET,                    (unsigned short *) &(comp_flash_info[comp].MAGIC_NUM),                    sizeof(MAGIC_t),NULL);        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t),                    (unsigned short *) &current_params,                    sizeof(current_params),NULL);#if defined(DSC24_OSD)        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t) + sizeof(current_params),                    (unsigned short *) &(comp_info[comp].fheader),                    sizeof(FHEADER_t),                    NULL);        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t) + sizeof(current_params) + sizeof(FHEADER_t),                    (unsigned short *) (comp_info[comp].fheader.load_addr),                    comp_info[comp].fheader.num_bytes,                    get_val_from_addr);#endif        if (ret == 0) {                comp_info[comp].is_FLASH_resident = TRUE;        }      }      break;    case c_KERNEL:       if (TRUE == comp_info[comp].is_SDRAM_resident) {        ret |= flash_write(comp_flash_info[comp].START_OFFSET,                    (unsigned short *) &(comp_flash_info[comp].MAGIC_NUM),                    sizeof(MAGIC_t),                    NULL);        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t),                    (unsigned short *) &(comp_info[comp].fheader),                    sizeof(FHEADER_t),                    NULL);        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t) + sizeof(FHEADER_t),                    (unsigned short *) (comp_info[comp].fheader.load_addr),                    comp_info[comp].fheader.num_bytes,                    get_val_from_addr);        if (ret == 0) {                comp_info[comp].is_FLASH_resident = TRUE;        }	/* If the kernel is compressed, then "remove" the 	   compressed kernel from RAM, so rrload boot	   logic will store the decompressed image there */#if ( BSPCONF_KERNEL_COMPRESSED == 1 ) ||  ( BSPCONF_FS_COMPRESSED == 1 )	if (image_is_compressed((char *)comp_info[comp].fheader.load_addr)) {	  comp_info[comp].is_SDRAM_resident = FALSE;	}#endif      }      break;    case c_FILESYS:      // util_printf("flashing -- load_addr 0x%X, entry_addr 0x%X, num_bytes 0x%X, offset 0x%X\n",      //              comp_info[comp].fheader.load_addr,      //              comp_info[comp].fheader.entry_addr,      //              comp_info[comp].fheader.num_bytes,      //              comp_flash_info[comp].START_OFFSET); // *debug* temp.      if (TRUE == comp_info[comp].is_SDRAM_resident) {#if !defined(OMAP1510)        ret |= flash_write(comp_flash_info[comp].START_OFFSET,                    (unsigned short *) &(comp_flash_info[comp].MAGIC_NUM),                    sizeof(MAGIC_t),                    NULL);        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t),                    (unsigned short *) &(comp_info[comp].fheader),                    sizeof(FHEADER_t),                    NULL);        ret |= flash_write(comp_flash_info[comp].START_OFFSET + sizeof(MAGIC_t) + sizeof(FHEADER_t),                    (unsigned short *) (comp_info[comp].fheader.load_addr),                    comp_info[comp].fheader.num_bytes,                    get_val_from_addr);#else        // JFFS2 cannot handle the header info.         // REVISIT - DG: Now that we are leaving out the header, what bad things happen?        ret |= flash_write(comp_flash_info[comp].START_OFFSET,                    (unsigned short *) (comp_info[comp].fheader.load_addr),                    comp_info[comp].fheader.num_bytes,                    get_val_from_addr);#endif        if (ret == 0) {                comp_info[comp].is_FLASH_resident = TRUE;        }	/* If the file system is compressed, then "remove" the 	   compressed file system from RAM, so rrload boot	   logic will store the decompressed image there */#if ( BSPCONF_KERNEL_COMPRESSED == 1 ) ||  ( BSPCONF_FS_COMPRESSED == 1 )	if (image_is_compressed((char *)comp_info[comp].fheader.load_addr)) {	  comp_info[comp].is_SDRAM_resident = FALSE;	}#endif      }      break;    default:      SYSTEM_FATAL("Logic Error");      break;  }  status = flash_flush();  if (status >= 0) {    util_printf("Flash Write error at offset %d\n",status);    return -1;  }  return ret;}/****************************** Routine: Description:   Note: See btldr_pi.h for description. ******************************/int cmd_copy_comp(comp_t c,        //component                   src_dest_t s,    //src                   src_dest_t d,    //dest                   port_format_t f, //format                   progress_meter_CBack_t CBack,                   int strobe_interval){  int ret = 0;   // !!!!!!!!!!!  // Note:  // Of all the possible combinations of s and d parameters  // only the following are currently supported by this particular  // bootloader. Other bootloaders implementing the btldr_pi.h  // interface may chose to support more combinations.  //   //   1. copy from port to sdram  //   2. copy from flash to sdram  //   3. copy from sdram to flash  //   4. copy from sram to flash  // !!!!!!!!!!!      prog_strobe = CBack;  strobe_delta = strobe_interval;  strobe_cnt = 0;  switch (d) {    default:      // The d parameter is totally ignored since all      // the currently supported modes can be deduced by      // testing the s param only.      break;  }  switch (s) {    // Note: | Again, with the specified source (s) we'll assume the    //       | destination -- independent of the dest (d) parameter.    case sd_SDRAM:      ret |= push_to_flash(c);      break;    case sd_SRAM:      ret |= push_to_flash(c);      break;    case sd_FLASH:      pull_from_flash(c);      break;    case sd_TFTP:      if (c_KERNEL == c) {        connect_tftp(current_params.device_IP,                     current_params.server_IP,                     current_params.device_MAC,                     current_params.server_MAC,                     current_params.kernel_path);      }      else if (c_FILESYS == c) {        connect_tftp(current_params.device_IP,                     current_params.server_IP,                     current_params.device_MAC,                     current_params.server_MAC,                     current_params.filesys_path);              } #if defined(DSC24_OSD)      else if (c_PARAMS == c) {        connect_tftp(current_params.device_IP,                     current_params.server_IP,                     current_params.device_MAC,                     current_params.server_MAC,                     current_params.OSD_path);              } #endif      ret |= load(c,s,f);      disconnect_tftp();      break;    case sd_PARPORT:    case sd_SERPORT:      ret |= load(c,s,f);      break;    default:      SYSTEM_FATAL("Logic Error");      break;  }  return ret;}/****************************** Routine: Description:   Note: See btldr_pi.h for description. ******************************/params_t *cmd_get_params(void){  return &current_params;}/****************************** Routine: Description:   Note: See btldr_pi.h for description. ******************************/void cmd_boot_kernel(int auto_xfer, // TRUE or FALSE,                     progress_meter_CBack_t CBack,                     int strobe_interval){//  struct tag *params = (struct tag *)0x000000FC; if (auto_xfer) {    // Next, Check to see if the components needed for a    // kernel boot are already in RAM. If not there    // already then move the image to RAM *if* it needs    // to go there before use. Data recorded with the    // image indicates our course of action. If the    // image is intended to be used *directly* from flash    // then the following calls have no effect.    if ((comp_info[c_KERNEL].is_FLASH_resident)&(!comp_info[c_KERNEL].is_SDRAM_resident)) {      cmd_copy_comp(c_KERNEL,sd_FLASH,sd_SDRAM,f_NA,CBack,strobe_interval);    }    if ((comp_info[c_FILESYS].is_FLASH_resident)&(!comp_info[c_FILESYS].is_SDRAM_resident)) {      cmd_copy_comp(c_FILESYS,sd_FLASH,sd_SDRAM,f_NA,CBack,strobe_interval);    }  }    if (comp_info[c_KERNEL].is_SDRAM_resident ) {//  if (comp_info[c_KERNEL].is_SDRAM_resident) {//      comp_info[c_KERNEL].is_FLASH_resident) {    // Next, Put our device ethernet MAC in the special memory location    //       which the kernel will reference when initializing its    //       ethernet driver.    // First write a magic string that gives validity to this area of SDRAM.    // The kernel will test validity prior to using the command line we are    // going to deposit.//    util_strcpy((unsigned char *)&__EtherMACMagicStr,"etherMAC-->");//    *((unsigned char *)&__EtherMAC) = (unsigned char) 0;//    util_strcpy((unsigned char *)&__EtherMAC,current_params.device_MAC);     // Next, Put our kernel command line overrides in the special    //       memory location which the kernel will reference on boot.    // First write a magic string that gives validity to this area of SDRAM.    // The kernel will test validity prior to using the command line we are    // going to deposit.//    util_strcpy((unsigned char *)&__KernCommandLineMagicStr,"kcmdline-->");//    *((unsigned char *)&__KernCommandLineOverride) = (unsigned char) 0;//    util_strcpy((unsigned char *)&__KernCommandLineOverride,current_params.kernel_cmdline);//    util_printf("\nCommand line overrides = %s\n",(unsigned char *)&__KernCommandLineOverride);    util_printf("Jumping to 0x%X\n",comp_info[c_KERNEL].fheader.entry_addr);    io_delay(100); // kill some time to allow printf chars to get out                   // the i/o port before we jump to the kernel.#if 0    *((unsigned int*)0xffff2800) = 0;	// turn off power/status LED#endif    lock_flash(); // We'll keep flash unlocked the whole                  // time the bootloader is running until                  // it is time to transfer control to the                   // kernel at which time we first lock                  // flash. Hopefully this will prevent                  // corrupted flash that might otherwise                  // result in a run-away program randomly                  // jumping into the flash logic of the                  // bootloader image still laying around                  // in ram from a prior run.    // Make sure the cache doesn't have any bad data    icache_disable();    icache_clear();//    params->hdr.tag = ATAG_CORE;//    params->hdr.size = tag_size(tag_core);//    params->u.core.flags = 0;//    params->u.core.pagesize = PAGE_SIZE;//    params->u.core.rootdev = RAMDISK_MAJOR << 8 | 0;//    params = tag_next(params);//    params->hdr.tag = ATAG_MEM;//    params->hdr.size = tag_size(tag_mem32);//    params->u.mem.start = 0x00900000;//    params->u.mem.size  = 64 * 1024 * 1024;//    params = tag_next(params);//    if (util_strlen(current_params.kernel_cmdline)) {//        params->hdr.tag = ATAG_CMDLINE;//        params->hdr.size = (sizeof(struct tag_header) +//                           util_strlen(current_params.kernel_cmdline) +//                           3) >> 2;//        util_strcpy(params->u.cmdline.cmdline, current_params.kernel_cmdline);//        util_printf("\nCommand line overrides = %s\n",//                    params->u.cmdline.cmdline);//        params = tag_next(params);//    }//    params->hdr.tag = ATAG_NONE;//    params->hdr.size = 0;    // Next, jump to it...#if defined(OMAP1510)    // Note we set r0=0 and r1=171 on entry to kernel.     (*((KERN_SIG)(comp_info[c_KERNEL].fheader.entry_addr)))(0,171);#elif defined(DM310)    // Invalidate the DM310 instruction cache    invalidate_cache();    // Note we set r0=0 and r1=172 on entry to kernel.     (*((KERN_SIG)(comp_info[c_KERNEL].fheader.entry_addr)))(0,172);/*#elif defined(DM270)     // Note r0 and r1 values don't matter on entry.    (*((KERN_SIG)(comp_info[c_KERNEL].fheader.entry_addr)))(0,621);*/#else     (*((KERN_SIG)(comp_info[c_KERNEL].fheader.entry_addr)))(0,0);#endif    }}/****************************** Routine: Description:   Note: See btldr_pi.h for description. ******************************/void erase_comp(comp_t c){  flash_erase_range((comp_flash_info[c].START_OFFSET)+BSPCONF_FLASH_BASE,                    (comp_flash_info[c].END_OFFSET)+BSPCONF_FLASH_BASE);  comp_info[c].is_FLASH_resident = FALSE;}/****************************** Routine: Description:   Note: See btldr_pi.h for description. ******************************/void lock_flash(void){  FlashLockMode = 0x00000000;}/****************************** Routine: Description:   Note: See btldr_pi.h for description. ******************************/void unlock_flash(void){  // Place a special pattern in a special  // memory location. The idea here is that  // stray program code running amock from  // the kernel or a kernel driver that happens  // to run itself into the flash logic of  // bootloader (still left over in memory)  // will not succeed in corrupting flash  // since the low level routines will test  // for this special pattern before modifying  // any flash contents. In normal bootloader  // operation the flash will remain unlocked  // and then locked whenever it transfers  // control to another program (e.g. the kernel)  FlashLockMode = 0xBEEFFEED;}