bootldr.c

strongarm的bootloader

            putLabeledWord("  flash=", dstwords[i]);
            putstr("not checking any more locations\r\n");
            goto clear_VPPEN;
         }
      }
   }
   putstr("done.\r\n");

 clear_VPPEN:
   CLR_VPPEN();
}

static void command_load_flash_region(const char *regionName, unsigned long regionBase, unsigned long regionSize, int flags)
{
   unsigned long img_size = 0; /* size of data */
   unsigned long hdr_size = 0; /* size of header */
   unsigned long img_dest = VKERNEL_BASE + 1024; /* just a temporary holding area */
   unsigned long i;
   long xmodem = 0;
  
   putstr("loading flash region "); putstr(regionName); putstr("\r\n");

   get_param_value("xmodem", &xmodem);

#ifdef CONFIG_XYMODEM
   if (xmodem) {
#endif
      putstr("using xmodem\r\n");
      img_size = modem_receive((char*)img_dest, regionSize);
#ifdef CONFIG_XYMODEM
   } else {
      putstr("using xymodem\r\n");
      img_size = xymodem_receive((char*)img_dest, regionSize);
   }
#endif
   if (!img_size) {
      putstr("download error. aborting.\r\n");
      return;
   }
    
   putHexInt32(img_size);
   putLabeledWord(" bytes loaded to ",img_dest);
   if ((img_size % 4) != 0) {
      putstr("img_size is not a multiple of 4 -- are we sure that's OK?\r\n");
   }

   program_flash_region(regionName, regionBase, regionSize, img_dest, img_size, flags);
}

void command_load_bootldr(int argc, const char **argv)
{
  command_load_flash_region("bootldr", flashDescriptor->bootldr.base, flashDescriptor->bootldr.size, flashDescriptor->bootldr.flags);
}

void command_load_params(int argc, const char **argv)
{
  command_load_flash_region("params", flashDescriptor->params.base, flashDescriptor->params.size, flashDescriptor->params.flags);
}

void command_load_usercode(int argc, const char **argv)
{
  command_load_flash_region("usercode", flashDescriptor->usercode.base, flashDescriptor->usercode.size, flashDescriptor->usercode.flags);
}

void command_load_ramdisk(int argc, const char **argv)
{
  command_load_flash_region("ramdisk", flashDescriptor->ramdisk.base, flashDescriptor->ramdisk.size, flashDescriptor->ramdisk.flags);
}

static void load_kernel(const char *kernel_region_name, 
                        unsigned long kernel_region_start, unsigned long kernel_region_size)
{
   unsigned long img_size = 0;
   unsigned long img_dest = VKERNEL_BASE;
   unsigned long i;
  
   img_size = modem_receive((char*)img_dest+12, kernel_region_size);

   if (!img_size) {
      putstr("error occured during download. aborting.\r\n");
      return;
   }
    
   putHexInt32(img_size);
   putLabeledWord(" bytes loaded to ",img_dest);
   if ((img_size % 4) != 0) {
      putstr("img_size is not a multiple of 4 -- are we sure that's OK?\r\n");
   }
   if ((img_size+12) > kernel_region_size) {
      putLabeledWord("kernel too large for region, but programming anyway.  Size=", kernel_region_size);
#if FIXME
      return;
#endif
   }

   /* set up the header */
   {
      /* the magic number.. */
      *(unsigned long *)(img_dest + 0x0) = KERNELIMG_MAGIC;
      /* the actual kernel image size */
      *(unsigned long *)(img_dest + 0x4) = img_size;
      /* where to copy the image before boot */
      *(unsigned long *)(img_dest + 0x8) = VKERNEL_BASE;
   }
   /* now program flash */
   program_flash_region(kernel_region_name, kernel_region_start, kernel_region_size,
                        img_dest, img_size, 0);
   putstr("done.\r\n");
}


void command_load_kernel(int argc, const char **argv)
{
   load_kernel("kernel", flashDescriptor->kernel.base, flashDescriptor->kernel.size);
}

#ifdef BOOT_ALTKERNEL
void command_load_altkernel(int argc, const char **argv)
{
   load_kernel("altkernel", flashDescriptor->altkernel.base, flashDescriptor->altkernel.size);
}
#endif

void command_load_debugger(int argc, const char **argv)
{
   command_load_flash_region("debugger", flashDescriptor->debugger.base, flashDescriptor->debugger.size, flashDescriptor->debugger.flags);
}

void command_peek(int argc, const char **argv)
{
   execcmd(peek_commands,argc-1,argv+1);
}

void command_peek_ram(int argc, const char **argv)
{
  unsigned long addr = 0;
  unsigned long result = 0;
  unsigned long offset = 0;
  
  if (argc < 2) { /* default to first command */
    putstr("peek ram requires arguments!\r\n");
  } else {
    addr = strtoul(argv[1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing addr\r\n");
      return;
    }

    if (strcmp(argv[0], "byte") == 0)
       result = *(unsigned char *)(addr);
    else if (strcmp(argv[0], "short") == 0)
       result = *(unsigned short *)(addr);
    else if (strcmp(argv[0], "int") == 0)
       result = *(int *)(addr);
    else if (strcmp(argv[0], "flash") == 0)
       result = flashword[(addr&flash_address_mask) >> 2];
    else if (strcmp(argv[0], "gpio") == 0)
       /* read from the gpio read port */
       result = *(int *)(0x21800008 + addr);
    else 
       result = *(unsigned long *)(addr);

    putLabeledWord("  addr  = ",addr);
    putLabeledWord("  value = ",result);
  }
}

void command_poke(int argc, const char **argv)
{
   execcmd(poke_commands,argc-1,argv+1);
}

void command_poke_ram(int argc, const char **argv)
{
  unsigned long addr = 0;
  unsigned long value = 0;
  unsigned long offset = 0;
  
  if (argc < 3) { /* default to first command */
    putstr("poke ram requires arguments!\r\n");
  } else {

    addr = strtoul(argv[1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing addr\r\n");
      return;
    }

    value = strtoul(argv[2], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing value\r\n");
      return;
    }

    putstr("poke ram: \r\n");
    putLabeledWord(" addr=", addr);
    putLabeledWord(" value=", value);

    if (strcmp(argv[0], "byte") == 0) {
       *(unsigned char *)(addr) = value;
    } else if (strcmp(argv[0], "short") == 0) {
       *(unsigned short *)(addr) = value;
    } else if (strcmp(argv[0], "int") == 0) {
       *(int *)addr = value;
    } else if (strcmp(argv[0], "gpio") == 0) {
       /* write to the gpio write port */
       *(int *)(0x21800000 + addr) = value;
    } else if (strcmp(argv[0], "flash") == 0) {
       if (programFlashWord(addr & flash_address_mask, value))
          putstr("flash write failed!\r\n");
    } else {
       *(unsigned long *)(addr) = value;
    }
  }
}


#ifdef CONFIG_BITSY
extern unsigned long delayedBreakpointPC;
void command_breakpoint(int argc, const char **argv)
{
  if (argv[1] != NULL) {
    const char *pcstr = NULL;
    unsigned long pc;
    int delayed = 0;
    if (strcmp(argv[1], "delayed") == 0) {
      delayed = 1;
      pcstr = argv[2];
    } else {
      pcstr = argv[1];
    }
    pc = strtoul(pcstr, NULL, 0);
    pc &= 0xFFFFFFFC;
    pc |= 1;
    if (delayed) {
      putLabeledWord("PC breakpoint will be set after kernel unzip at: ", pc);
      delayedBreakpointPC = pc;
    } else {
      putLabeledWord("Setting hardware PC breakpoint at: ", pc);
      __asm__ ("mcr     p15, 0, %0, c14, c8, 0" : : "r" (pc));
    }
  } else {
    unsigned long pc = 0;
    putstr("Clearing PC breakpoint");
    __asm__ ("mcr     p15, 0, %0, c14, c8, 0" : : "r" (pc));
  }
}
#endif

void command_qflash(int argc, const char **argv)
{
  unsigned long addr = 0;
  unsigned long result = 0;
  unsigned long offset = 0;
  
  if (argc < 2) { /* default to first command */
    putstr("qflash requires arguments!\r\n");
  } else {
    addr = strtoul(argv[argc-1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing addr\r\n");
      return;
    }

    if (strcmp(argv[1], "id") == 0) {
       result = queryFlashID(addr);
    } else if (strcmp(argv[1], "security") == 0) {
       result = queryFlashSecurity(addr);
    } else {
       result = queryFlash(addr);
    }
    putLabeledWord("value = ",result);
  }
}

void command_eflash(int argc, const char **argv)
{
  unsigned long addr = 0;
  unsigned long result = 0;
  unsigned long offset = 0;
  
  if (argc < 2) { /* default to first command */
    putstr("eflash requires arguments: <addr>|chip!\r\n");
  } else {
    if (strncmp(argv[1], "chip", 4) == 0) {
       putstr("erasing flash chip\r\n");
       SET_VPPEN();
       eraseFlashChip();
       CLR_VPPEN();
       return;
    }
    addr = strtoul(argv[1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing addr: "); putstr(argv[1]); putstr("\r\n");
    }
    putLabeledWord("addr=", addr);

    SET_VPPEN();
    result = eraseFlashSector(addr);
    CLR_VPPEN();
  }
}

void command_pflash(int argc, const char **argv)
{
  unsigned long addr = 0;
  unsigned long len = 0;
  unsigned long protect = 0;
  
  if (argc < 4) { /* default to first command */
    putstr("pflash requires arguments: <addr> <len> 0/1  (1 -> protect, 0 -> unprotect all)!\r\n");
  } else {
    addr = strtoul(argv[1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing addr: "); putstr(argv[1]); putstr("\r\n");
    }
    len = strtoul(argv[2], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing len: "); putstr(argv[2]); putstr("\r\n");
    }
    protect = strtoul(argv[3], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing protect: "); putstr(argv[3]); putstr("\r\n");
    }
    putLabeledWord("  addr=", addr);
    putLabeledWord("  len=", len);
    putLabeledWord("  protect=", protect);

    SET_VPPEN();
    protectFlashRange(addr, len, protect);
    CLR_VPPEN();
  }
}

#if 0
void command_reboot(int argc, const char **argv)
{
  if (argc < 1) {
    reboot();
  } else {
    putstr("reboot does not need arguments!\r\n");
  }
}
#endif

void command_call(int argc, const char **argv)
{
  void (*fcn)(long a0, long a1, long a2, long a3) = NULL;
  int offset;
  
  if (argc < 2) {
    putstr("usage: call <addr>\r\n");
  } else {
    long a0 = 0;
    long a1 = 0;
    long a2 = 0;
    long a3 = 0;
    fcn = (void*)strtoul(argv[1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing vaddr\r\n");
      return;
    }
    if (argc > 2) {
      a0 = strtoul(argv[2], NULL, 0);
    }
    if (argc > 3) {
      a1 = strtoul(argv[3], NULL, 0);
    }
    if (argc > 4) {
      a2 = strtoul(argv[4], NULL, 0);
    }
    if (argc > 5) {
      a3 = strtoul(argv[5], NULL, 0);
    }
    flush_caches();
    putLabeledWord("Calling fcn=", (long)fcn);
    putLabeledWord("  a0=", a0);
    putLabeledWord("  a1=", a1);
    putLabeledWord("  a2=", a2);
    putLabeledWord("  a3=", a3);
    fcn(a0, a1, a2, a3);
  }
}

void command_physaddr(int argc, const char **argv)
{
  unsigned long vaddr = 0;
  int offset;
  
  if (argc < 2) { /* default to first command */
    putstr("physaddr requires vaddr argument!\r\n");
  } else {
    vaddr = strtoul(argv[1], NULL, 0);
    if (strtoul_err) {
      putstr("error parsing vaddr\r\n");
      return;
    }
    {
      unsigned long mmu_table_entry = mmu_table[vaddr >> 20];
      unsigned long paddr = mmu_table_entry & ~((1L << 20) - 1);
      unsigned long sectionDescriptor = mmu_table_entry & ((1L << 20) - 1);
      putLabeledWord("vaddr=", vaddr);
      putLabeledWord("paddr=", paddr);
      putLabeledWord("sectionDescriptor=", sectionDescriptor);
    }
  }
}

void command_set(int argc, const char **argv)
{
   struct bootblk_param *param = bootldr_params;
   const char *paramValueString = argv[2];
   if (paramValueString == NULL)
      paramValueString = "";
   while (param->name != NULL) {
      int namelen = strlen(param->name);
      if (strncmp(argv[1], param->name, namelen) == 0) {
         long value;
         int paramValueLen = strlen(paramValueString);
         putstr("  setting param=");
         putstr(param->name);
         putstr(" to value=");
         putstr(paramValueString);
         putstr("\r\n");
         switch (param->paramFormat) {
         case PF_STRING: {
            if (paramValueLen == 0) {
               value = 0;
            } else {
               char *newstr = malloc(paramValueLen+1);
               memcpy(newstr, paramValueString, paramValueLen+1);
               value = (long)newstr;
            }
            break;
         }
         case PF_DECIMAL:
         case PF_HEX:
         default:
            value = strtoul(paramValueString, NULL, 0);
         }
         param->value = value;
         if (param->update != NULL) {
            (param->update)(param);
         }
      }
      param++;
   }
}

void command_params_show(int argc, const char **argv)
{
   struct bootblk_param *params = bootl