bootldr.c

strongarm的bootloader

    len = hdrp->a_bss;
    if (len) {
	memset(start, 0x00, len);
    }
    
}
#endif /* ZBSS */

extern char HEX_TO_ASCII_TABLE[16];

void dwordtodecimal(char *buf, unsigned long x)
{
  int i = 0;
  int j = 0;
  char localbuf[16];

  while (x > 0) {
    unsigned long rem = x % 10;
    localbuf[i++] = HEX_TO_ASCII_TABLE[rem];
    x /= 10;
  }
  /* now reverse the characters into buf */
  while (i > 0) {
    i--;
    buf[j++] = localbuf[i];
  }
}

void binarytohex(char *buf, long x, int nbytes)
{
  int i;
  int s = 4*(2*nbytes - 1);
  if (HEX_TO_ASCII_TABLE[0] != '0')
     putstr("HEX_TO_ASCII_TABLE corrupted\n");
  for (i = 0; i < 2*nbytes; i++) {
    buf[i] = HEX_TO_ASCII_TABLE[(x >> s) & 0xf];
    s -= 4;
  }
  buf[2*nbytes] = 0;
}

byte strtoul_err;
unsigned long strtoul(const char *str, char **endptr, int requestedbase)
{
   unsigned long num = 0;
   int i;
   char c;
   byte digit;
   int base = 10;
   int nchars = 0;
   int leadingZero = 0;

   strtoul_err = 0;

   while ((c = *str) != 0) {
      if (nchars == 0 && c == '0') {
         leadingZero = 1;
         if (0) putLabeledWord("strtoul: leadingZero nchars=", nchars);
         goto step;
      } else if (leadingZero && nchars == 1) {
         if (c == 'x') {
            base = 16;
            if (0) putLabeledWord("strtoul: base16 nchars=", nchars);
            goto step;
         } else if (c = 'o') {
            base = 8;
            if (0) putLabeledWord("strtoul: base8 nchars=", nchars);
            goto step;
         }
      }
      if (0) putLabeledWord("strtoul: c=", c);
      if (c >= '0' && c <= '9') {
         digit = c - '0';
      } else if (c >= 'a' && c <= 'z') {
         digit = c - 'a' + 10;
      } else if (c >= 'A' && c <= 'Z') {
         digit = c - 'A' + 10;
      } else {
         strtoul_err = 3;
         return 0;
      }
      if (digit >= base) {
         strtoul_err = 4;
         return 0;
      }
      num *= base;
      num += digit;
   step:
      str++;
      nchars++;
   }
   return num;
}

void putLabeledWord(const char *msg, unsigned long value)
{
   char buf[9];
   binarytohex(buf,value,4);
   putstr(msg);
   putstr(buf);
   putstr("\r\n");
}

void putHexInt32(unsigned long value)
{
  char buf[9];
  binarytohex(buf,value,4);
  putstr(buf);
}

void putHexInt16(word value)
{
  char buf[9];
  binarytohex(buf,value,2);
  putstr(buf);
}

void putHexInt8(byte value)
{
  char buf[3];
  binarytohex(buf,value,1);
  putstr(buf);
}
  
static struct ebsaboot bootinfo = {
   BT_MAGIC_NUMBER,	/* boot info magic number */
   0x20000000,		/* virtual addr of arg page */
   0x20000000,		/* physical addr of arg page */
   NULL,		/* kernel args string pointer */
   (pd_entry_t *)MMU_TABLE_START,	/* active L1 page table */
   0,		        /* start of physical memory */
   DRAM_SIZE,		/* end of physical memory */
   SZ_2M+SZ_1M,         /* start of avail phys memory */
   48000000,		/* fclk frequency */
   UART_BAUD_RATE,    	/* baudrate of serial console */
   1 			/* n stop bits */
};

void print_banner(void)
{
  long armrev = 0;
  long corelogicrev = 0;
  long cpsr = 0;
  __asm__("mrc p15, 0, %0, c0, c0, 0" : "=r" (armrev));
  __asm__("mrs %0, cpsr" : "=r" (cpsr));
#ifdef CONFIG_SKIFF
  corelogicrev = *(volatile unsigned long *)(DC21285_ARMCSR_BASE + PCI_VENDOR_ID);
#endif

  putstr("\r\n");
  putstr(">> ");
  putstr(bootprog_name);
  putstr(", Rev ");
  putHexInt8(VERSION_MAJOR); putstr("."); putHexInt8(VERSION_MINOR); putstr("."); putHexInt8(VERSION_MICRO);
  putstr("\r\n");

  putstr(">> ");
  putstr(bootprog_date);
  putstr("\r\n");
  putLabeledWord(">>  ARM Processor Rev=", armrev);
#if CONFIG_SKIFF
  putLabeledWord(">>  Corelogic Rev=", corelogicrev);
  if (get_param("mem_fclk_21285") != NULL)
    putLabeledWord(">>  Corelogic fclk=", get_param("mem_fclk_21285")->value);
#endif
  putLabeledWord(">>  CPSR=", cpsr);

  putstr(">> (c) 2000 Compaq Cambridge Research Laboratory\r\n");
  putstr("Press Return to start the OS now, any other key for monitor menu\r\n");
}

/*
 * Reads and returns a character from the serial port
 *  - Times out after delay iterations checking for presence of character
 *  - Sets *error_p to UART error bits or -1 on timeout
 *  - On timeout, sets *error_p to -1 and returns 0
 */
byte awaitkey(unsigned long delay, int *error_p)
{
  unsigned long i = delay;
  byte c;
  int errors = 0;

  while (1) {
    i = delay;
#ifdef CONFIG_SKIFF
    while (((CSR_READ_BYTE(UARTFLG_REG) & UART_RX_FIFO_EMPTY)) && i)
	i--;
#else
    {
       while ((!((*(volatile long *)SA1100_UART3_UTSR1) & SA1100_UTSR1_RNE)) && i)
          i--;
    }
#endif
    
    if (i) {
      errors = 0;
#ifdef CONFIG_SKIFF
      c = CSR_READ_BYTE(UARTDR_REG);
      errors = CSR_READ_BYTE(RXSTAT_REG);
#else
      c = *(volatile long *)SA1100_UART3_UTDR;
      errors = (*(volatile long *)SA1100_UART3_UTSR1) & SA1100_UTSR1_ERROR_MASK;
#endif
      if (!errors) /* if no receive errors found.. */
	break; /* get out of here */
    } else {
      c = 0; /* no one pressed a key. return a NULL and get out of here */
      errors = -1;
      break;
    }
  }
  if (error_p != NULL)
    *error_p = errors;
  return(c);
}

int getc_verbose_errors = 1;
int getc_errno = 0;
byte getc(void) {
   byte c, rxstat;
   getc_errno = 0; /* reset errno */
#ifdef CONFIG_SKIFF
   while ((CSR_READ_BYTE(UARTFLG_REG) & UART_RX_FIFO_EMPTY));
   /* must read UARTDR_REG before RXSTAT_REG */
   c =  CSR_READ_BYTE(UARTDR_REG);
   rxstat = CSR_READ_BYTE(RXSTAT_REG);
#elif defined(CONFIG_BITSY)
   while ((!((*(volatile long *)SA1100_UART3_UTSR1) & SA1100_UTSR1_RNE)))
     /* spin wait */;
   c = *(volatile byte *)SA1100_UART3_UTDR;
   rxstat = (*(volatile byte *)SA1100_UART3_UTSR1) & SA1100_UTSR1_ERROR_MASK;
#else
#error no architecture defined for getc
#endif
   if (rxstat) {
      getc_errno = rxstat;
      if (getc_verbose_errors) {
         putLabeledWord("RXSTAT error: ", rxstat);
      }
   }
   return(c);
}


#define CMDBUFSIZE 256
char cmdBuffer[CMDBUFSIZE];
void getcmd(void) {
   byte curpos = 0; /* curpos position - index into cmdBuffer */
   byte c;
   byte noreturn = 1;

   /* first clear out the buffer.. */
   memset(cmdBuffer, 0, CMDBUFSIZE);

   /* here we go..*/

   while (noreturn) {
      c = getc();
      switch (c)
         {
	 case 0x08:
         case 0x06:
         case 0x07:
         case 0x7E:
         case 0x7F: /* backspace / delete */
            if (curpos) { /* we're not at the beginning of the line */
               curpos--;
               putc(0x08); /* go backwards.. */
               putc(' ');  /* overwrite the char */
               putc(0x08); /* go back again */
            }
            cmdBuffer[curpos] = '\0';
            break;
         case '\r':
         case '\n':
         case '\0':
            noreturn = 0;
            putc('\r');
            putc('\n');
            break;
         default:
            if (curpos < CMDBUFSIZE) {
               cmdBuffer[curpos] = c;
               /* echo it back out to the screen */
               putc(c);
               curpos++;
            }
            break;
         }
   }
   /*
     putstr("COMMAND: ");
     putstr(cmdBuffer);
     for (c=0;c<CMDBUFSIZE;c++) {
       putHexInt8(cmdBuffer[c]);
       putc(' ');
     }
     putstr("\r\n");
   */

}

int argc;

enum ParseState {
   PS_WHITESPACE,
   PS_TOKEN,
   PS_STRING,
   PS_ESCAPE
};

enum ParseState stackedState;

void parseargs(char *argstr, int *argc_p, char **argv)
{
  const char *whitespace = " \t";
  int argc = 0;
  char c;
  enum ParseState lastState = PS_WHITESPACE;
   
  /* tokenize the argstr */
  while ((c = *argstr) != 0) {
    enum ParseState newState;
      
    if (lastState == PS_ESCAPE) {
      newState = stackedState;
    } else if (lastState == PS_STRING) {
      if (c == '"') {
        newState = PS_WHITESPACE;
        *argstr = 0;
      } else {
        newState = PS_STRING;
      }
    } else if ((c == ' ') || (c == '\t')) {
      /* whitespace character */
      *argstr = 0;
      newState = PS_WHITESPACE;
    } else if (c == '"') {
      newState = PS_STRING;
      *argstr++ = 0;
      argv[argc++] = argstr;
    } else if (c == '\\') {
      stackedState = lastState;
      newState = PS_ESCAPE;
    } else {
      /* token */
      if (lastState == PS_WHITESPACE) {
        argv[argc++] = argstr;
      }      
      newState = PS_TOKEN;
    }

    lastState = newState;
    argstr++;
  }

  if (0) { 
    int i;
    putLabeledWord("parseargs: argc=", argc);
    for (i = 0; i < argc; i++) {
      putstr("   ");
      putstr(argv[i]);
      putstr("\r\n");
    }
  }

  argv[argc] = NULL;
  if (argc_p != NULL)
    *argc_p = argc;
}

void unparseargs(char *argstr, int argc, const char **argv)
{
   int i;
   for (i = 0; i < argc; i++) {
     if (argv[i] != NULL) {
       strcat(argstr, " ");
       strcat(argstr, argv[i]);
     }
   }
}

int parsecmd(struct bootblk_command *cmdlist, int argc, const char **argv)
{
   /* find the command name */
   const char *cmdname = argv[0];
   int cmdnum = 0;

   if (argc < 1)
      return -1;
   /* do a string compare for the first offset characters of cmdstr
      against each member of the cmdlist */
   while (cmdlist[cmdnum].cmdstr != NULL) {
      if (strcmp(cmdlist[cmdnum].cmdstr, cmdname) == 0)
         return(cmdnum);
     cmdnum++;
   }
   return(-1);
}

void execcmd(struct bootblk_command *cmdlist, int argc, const char **argv)
{
   int cmdnum = parsecmd(cmdlist, argc, argv);

   if (0) {
      putstr("execcmd: argv[0]="); putstr(argv[0]); putstr("\r\n");
      putLabeledWord("  argc=", argc);
      putLabeledWord("  cmdnum=", cmdnum);
   }
   if (cmdnum >= 0) {
      (*cmdlist[cmdnum].cmdfunc)(argc, argv);
   } else if (strcmp(argv[1], "help") == 0) {
      print_help_on_commands(cmdlist);
   } else {
#if 1
      print_help_on_commands(cmdlist);
#else
      /* default to the first command and insert it into the head of argv */
      int i;
      for (i = argc; i >= 0; i--) {
         argv[i+1] = argv[i];
      }
      argc++;
      argv[0] = cmdlist[0].cmdstr;
      (*cmdlist[0].cmdfunc)(argc, argv);
#endif
   }
}

void bootmenu(void)
{
  int cmdnum;
  char *cmdpos;
  int argc;
  char *argv[128];

  while (1) {
    putstr("boot> ");
    getcmd();
    if (!cmdBuffer[0])
	continue;		/* empty line, ignore */
    
    memset(argv, 0, sizeof(argv));
    parseargs(cmdBuffer, &argc, argv);
    if (argc > 0) {
       execcmd(commands, argc, (const char **)argv);
    } else {
       print_help_on_commands(commands);
    }
  }
}