Subversion Repositories openrisc

#include "common.h"
#include "uart.h"
#include "screen.h"
#include "support.h"
#include "keyboard.h"
#include "spr-defs.h"
#include "spincursor.h"
#include "int.h"
 
#include "build.h"
 
#define MAX_COMMANDS  100
 
// Value from linker script
extern unsigned long src_addr;
 
bd_t bd;
 
int num_commands = 0;
 
command_struct command[MAX_COMMANDS];
 
void putc (const char c)
{
  debug ("putc %i, %i = %c\n", bd.bi_console_type, c, c);
  switch (bd.bi_console_type) {
  case CT_NONE:
    break;
  case CT_UART:
    uart_putc (c);
    break;
#if CRT_ENABLED==1
  case CT_CRT:
    screen_putc (c);
    break;
#endif
  case CT_SIM:
    __printf ("%c", c);
    break;
  }
}
 
int getc ()
{
  int ch = 0;
  debug ("getc %i\n", bd.bi_console_type);
  switch (bd.bi_console_type) {
#if KBD_ENABLED==1
  case CT_CRT:
    while ((volatile int)kbd_head == (volatile int)kbd_tail);
    ch = kbd_buf[kbd_tail];
    kbd_tail = (kbd_tail + 1) % KBDBUF_SIZE;
    return ch;
#endif
  case CT_UART:
    return uart_getc ();
    break;
  case CT_NONE: /* just to satisfy the compiler */
  case CT_SIM:
    break;
  }
  return -1;
}
 
int testc ()
{
  debug ("testc %i\n", bd.bi_console_type);
  switch (bd.bi_console_type) {
#if KBD_ENABLED
  case CT_CRT:
    if (kbd_head == kbd_tail) return 0;
    else return getc ();
#endif
  case CT_UART:
    return uart_testc ();
    break;
  case CT_NONE: /* just to satisfy the compiler */
  case CT_SIM:
    break;
  }
  return -1;
}
 
int ctrlc ()
{
  if (testc ()) {
    switch (getc ()) {
      case 0x03:    /* ^C - Control C */
        return 1;
      default:
        break;
    }
  }
  return 0;
}
 
void
print_or1k_cache_info()
{
  // Read out UPR, check what modules we have
  unsigned long upr = mfspr(SPR_UPR);
  printf("Instruction cache:\t");
  if (upr & SPR_UPR_ICP)
    {
      // We have instruction cache, read out ICCFGR
 
      unsigned long iccfgr = mfspr(SPR_ICCFGR);
      unsigned int cbs; // cache block size
      unsigned long ncs = 1 << ((iccfgr & SPR_ICCFGR_NCS) >> 3);
      if (iccfgr & SPR_ICCFGR_CBS)
	cbs = 32;
      else
	cbs = 16;
 
      printf("%dkB (BS: %d Sets: %d)\n",
	     (cbs * ncs)/1024, cbs, ncs);
 
    }
  else
    printf(" not present\n");
 
  printf("Data cache:\t\t");
  if (upr & SPR_UPR_DCP)
    {
      // We have instruction cache, read out DCCFGR
 
      unsigned long iccfgr = mfspr(SPR_DCCFGR);
      unsigned int cbs; // cache block size
      unsigned long ncs = 1 << ((iccfgr & SPR_DCCFGR_NCS) >> 3);
      if (iccfgr & SPR_DCCFGR_CBS)
	cbs = 32;
      else
	cbs = 16;
 
      printf("%dkB (BS: %d Sets: %d)\n",
	     (cbs * ncs)/1024, cbs, ncs);
 
    }
  else
    printf(" not present\n");
 
}
 
unsigned long parse_ip (char *ip)
{
  unsigned long num;
  num = strtoul (ip, &ip, 10) & 0xff;
  if (*ip++ != '.') return 0;
  num = (num << 8) | (strtoul (ip, &ip, 10) & 0xff);
  if (*ip++ != '.') return 0;
  num = (num << 8) | (strtoul (ip, &ip, 10) & 0xff);
  if (*ip++ != '.') return 0;
  num = (num << 8) | (strtoul (ip, &ip, 10) & 0xff);
  return num;
}
 
void change_console_type (enum bi_console_type_t con_type)
{
  debug ("Console change %i -> %i\n", bd.bi_console_type, con_type);
  /* Close previous */
  switch (bd.bi_console_type) {
  case CT_NONE:
  case CT_UART:
  case CT_CRT:
  case CT_SIM:
    break;
  }
  bd.bi_console_type = con_type;
  /* Initialize new */
  switch (bd.bi_console_type) {
  case CT_NONE:
    break;
  case CT_UART:
    uart_init ();
    break;
  case CT_CRT:
#if CRT_ENABLED==1
    screen_init ();
#endif
#if KBD_ENABLED
    kbd_init ();
#endif
    break;
  case CT_SIM:
    break;
  }
}
 
void register_command_func (const char *name, const char *params, const char *help, int (*func)(int argc, char *argv[]))
{
  debug ("register_command '%s'\n", name);
  if (num_commands < MAX_COMMANDS) {
    command[num_commands].name = name;
    command[num_commands].params = params;
    command[num_commands].help = help;
    command[num_commands].func = func;
    num_commands++;
  } else printf ("Command '%s' ignored; MAX_COMMANDS limit reached\n", name);
}
 
/* Process command and arguments by executing
   specific function. */
void mon_command(void)
{
  char c = '\0';
  char str[1000];
  char *pstr = str;
  char *command_str;
  char *argv[20];
  int argc = 0;
  int chcnt = 0;
 
  /* Show prompt */
  printf ("\n" BOARD_DEF_NAME"> ");
 
  while(1)
    {
      c=getc();
      if (c == '\r' || c == '\f' || c == '\n')
	{
	  // Mark end of string
	  *pstr = '\0';
	  putc('\n');
	  break;
	}
      else if (c == '\b') // Backspace
	{
	  if (chcnt > 0)
	    {
	      putc(c);
	      putc(' '); // cover char with space
	      putc(c);
	      pstr--;
	      chcnt--;
	    }
	}
      else
	{
	  putc(c);
	  *pstr++ = c;
	  chcnt++;
	}
    }
 
  /* Skip leading blanks */
  pstr = str;
  while (*pstr == ' ' && *pstr != '\0') pstr++;
 
  /* Get command from the string */
  command_str = pstr;
 
  while (1) {
    /* Go to next argument */
    while (*pstr != ' ' && *pstr != '\0') pstr++;
    if (*pstr) {
      *pstr++ = '\0';
      while (*pstr == ' ') pstr++;
      argv[argc++] = pstr;
    }
    else
      break;
  }
 
  {
    int i, found = 0;
 
    for (i = 0; i < num_commands; i++)
      if (strcmp (command_str, command[i].name) == 0)
      {
        switch ( command[i].func(argc, &argv[0]) )
        {
          case -1:
            printf ("Missing/wrong parameters, usage: %s %s\n", 
		    command[i].name, command[i].params);
            break;
        }
 
        found++;
        break;
      }
    /* 'built-in' build command */
    if(strcmp(command_str, "build") == 0) {
      printf("Build tag: %s", BUILD_VERSION);
      found++;
    }
    if (!found)
      printf ("Unknown command. Type 'help' for help.\n");
  }
 
}
 
#if HELP_ENABLED
extern unsigned long src_addr; // Stack section ends here, will print it out
/* Displays help screen */
int help_cmd (int argc, char *argv[])
{
  int i;
  for (i = 0; i < num_commands; i++)
    printf ("%-10s %-20s - %s\n", command[i].name, command[i].params, command[i].help);
 
  // Build info....
  printf("\n");
  printf("CPU info\n");
  printf("Frequency\t\t%dMHz\n", IN_CLK/1000000);
  print_or1k_cache_info();
  printf("\n");
  printf("Info: Stack section addr 0x%x\n",(unsigned long) &src_addr);
  printf("Build tag: %s", BUILD_VERSION);
 
  return 0;
}
#endif /* HELP_ENABLED */
 
void module_cpu_init (void);
void module_memory_init (void);
void module_eth_init (void);
void module_dhry_init (void);
void module_coremark_init (void);
void module_camera_init (void);
void module_load_init (void);
void tick_init(void);
void module_touch_init (void);
void module_ata_init (void);
void module_hdbug_init (void);
 
 
/* List of all initializations */
void mon_init (void)
{
  /* Set defaults */
  global.erase_method = 2; /* as needed */
  global.src_addr = (unsigned long)&src_addr;
  global.dst_addr = FLASH_BASE_ADDR;
  global.eth_add[0] = ETH_MACADDR0;
  global.eth_add[1] = ETH_MACADDR1;
  global.eth_add[2] = ETH_MACADDR2;
  global.eth_add[3] = ETH_MACADDR3;
  global.eth_add[4] = ETH_MACADDR4;
  global.eth_add[5] = ETH_MACADDR5;
  global.ip = BOARD_DEF_IP;
  global.gw_ip = BOARD_DEF_GW;
  global.mask = BOARD_DEF_MASK;
 
#define CPU_CMDS
#define MEM_CMDS
#define DHRY_CMDS
#define COREMARK_CMDS
  //#define CAMERA_CMDS
#define LOAD_CMDS
    //#define TOUCHSCREEN_CMDS
    //#define ATA_CMDS
    //#define HDBUG_CMDS
#define TICK_CMDS
#define ETH_CMDS
#define LOAD_CMDS
 
  /* Init modules */
#ifdef CPU_CMDS
  module_cpu_init ();
#endif
#ifdef MEM_CMDS
  module_memory_init ();
#endif
#ifdef ETH_CMDS
  module_eth_init ();
#endif
#ifdef DHRY_CMDS
  module_dhry_init ();
#endif
#ifdef COREMARK_CMDS
  module_coremark_init ();
#endif
#ifdef CAMERA_CMDS
  module_camera_init ();
#endif
#ifdef LOAD_CMDS
  module_load_init ();
#endif
#ifdef TOUCHSCREEN_CMDS
  module_touch_init ();
#endif
#ifdef ATA_CMDS
  module_ata_init ();
#endif
#ifdef HDBUG_CMDS
  module_hdbug_init ();
#endif
 
#ifdef TICK_CMDS
#endif
 
}
int tboot_cmd (int argc, char *argv[]);
/* Main shell loop */
int main(int argc, char **argv)
{
  extern unsigned long calc_mycrc32 (void);
 
#if 0
  extern unsigned long mycrc32, mysize;
#endif
 
  timestamp = 0; // clear timer counter
 
  int_init ();
 
  change_console_type (CONSOLE_TYPE);
 
  mtspr(SPR_SR, mfspr(SPR_SR) | SPR_SR_IEE);
 
#if SELF_CHECK
  printf ("Self check... ");
  if ((t = calc_mycrc32 ()))
      printf ("FAILED!!!\n");
  else
      printf ("OK\n");
#endif /* SELF_CHECK */
 
  num_commands=0;
  mon_init ();
 
  disable_spincursor();
 
  tick_init();
 
 
  if (HELP_ENABLED) register_command ("help", "", "shows this help", help_cmd);
 
  printf ("\n" BOARD_DEF_NAME " monitor (type 'help' for help)\n");
  printf("\tbuild: %s", BUILD_VERSION);
 
  // Loop forever, accepting commands
  while(1) 
    {
      mon_command();
    }
 
}