URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [common/] [common.c] - Blame information for rev 366

Go to most recent revision | Details | Compare with Previous | View Log


#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();
    }
 
}

Line No.	Rev	Author	Line
1	2	marcus.erl	`#include "common.h"`
2			`#include "uart.h"`
3			`#include "screen.h"`
4			`#include "support.h"`
5			`#include "keyboard.h"`
6	246	julius	`#include "spr-defs.h"`
7			`#include "spincursor.h"`
8	2	marcus.erl	`#include "int.h"`
9
10			`#include "build.h"`
11
12			`#define MAX_COMMANDS 100`
13
14	246	julius	`// Value from linker script`
15	2	marcus.erl	`extern unsigned long src_addr;`
16
17			`bd_t bd;`
18
19			`int num_commands = 0;`
20
21			`command_struct command[MAX_COMMANDS];`
22
23			`void putc (const char c)`
24			`{`
25			`debug ("putc %i, %i = %c\n", bd.bi_console_type, c, c);`
26			`switch (bd.bi_console_type) {`
27			`case CT_NONE:`
28			`break;`
29			`case CT_UART:`
30			`uart_putc (c);`
31			`break;`
32	140	julius	`#if CRT_ENABLED==1`
33	2	marcus.erl	`case CT_CRT:`
34			`screen_putc (c);`
35			`break;`
36	140	julius	`#endif`
37	2	marcus.erl	`case CT_SIM:`
38			`__printf ("%c", c);`
39			`break;`
40			`}`
41			`}`
42
43			`int getc ()`
44			`{`
45			`int ch = 0;`
46			`debug ("getc %i\n", bd.bi_console_type);`
47			`switch (bd.bi_console_type) {`
48	140	julius	`#if KBD_ENABLED==1`
49	2	marcus.erl	`case CT_CRT:`
50			`while ((volatile int)kbd_head == (volatile int)kbd_tail);`
51			`ch = kbd_buf[kbd_tail];`
52			`kbd_tail = (kbd_tail + 1) % KBDBUF_SIZE;`
53			`return ch;`
54			`#endif`
55			`case CT_UART:`
56			`return uart_getc ();`
57			`break;`
58			`case CT_NONE: /* just to satisfy the compiler */`
59			`case CT_SIM:`
60			`break;`
61			`}`
62			`return -1;`
63			`}`
64
65			`int testc ()`
66			`{`
67			`debug ("testc %i\n", bd.bi_console_type);`
68			`switch (bd.bi_console_type) {`
69			`#if KBD_ENABLED`
70			`case CT_CRT:`
71			`if (kbd_head == kbd_tail) return 0;`
72			`else return getc ();`
73			`#endif`
74			`case CT_UART:`
75			`return uart_testc ();`
76			`break;`
77			`case CT_NONE: /* just to satisfy the compiler */`
78			`case CT_SIM:`
79			`break;`
80			`}`
81			`return -1;`
82			`}`
83
84			`int ctrlc ()`
85			`{`
86			`if (testc ()) {`
87			`switch (getc ()) {`
88			`case 0x03: /* ^C - Control C */`
89			`return 1;`
90			`default:`
91			`break;`
92			`}`
93			`}`
94			`return 0;`
95			`}`
96
97	246	julius	`void`
98			`print_or1k_cache_info()`
99			`{`
100			`// Read out UPR, check what modules we have`
101			`unsigned long upr = mfspr(SPR_UPR);`
102			`printf("Instruction cache:\t");`
103			`if (upr & SPR_UPR_ICP)`
104			`{`
105			`// We have instruction cache, read out ICCFGR`
106
107			`unsigned long iccfgr = mfspr(SPR_ICCFGR);`
108			`unsigned int cbs; // cache block size`
109			`unsigned long ncs = 1 << ((iccfgr & SPR_ICCFGR_NCS) >> 3);`
110			`if (iccfgr & SPR_ICCFGR_CBS)`
111			`cbs = 32;`
112			`else`
113			`cbs = 16;`
114
115			`printf("%dkB (BS: %d Sets: %d)\n",`
116			`(cbs * ncs)/1024, cbs, ncs);`
117
118			`}`
119			`else`
120			`printf(" not present\n");`
121
122			`printf("Data cache:\t\t");`
123			`if (upr & SPR_UPR_DCP)`
124			`{`
125			`// We have instruction cache, read out DCCFGR`
126
127			`unsigned long iccfgr = mfspr(SPR_DCCFGR);`
128			`unsigned int cbs; // cache block size`
129			`unsigned long ncs = 1 << ((iccfgr & SPR_DCCFGR_NCS) >> 3);`
130			`if (iccfgr & SPR_DCCFGR_CBS)`
131			`cbs = 32;`
132			`else`
133			`cbs = 16;`
134
135			`printf("%dkB (BS: %d Sets: %d)\n",`
136			`(cbs * ncs)/1024, cbs, ncs);`
137
138			`}`
139			`else`
140			`printf(" not present\n");`
141
142			`}`
143
144	2	marcus.erl	`unsigned long parse_ip (char *ip)`
145			`{`
146			`unsigned long num;`
147			`num = strtoul (ip, &ip, 10) & 0xff;`
148			`if (*ip++ != '.') return 0;`
149			`num = (num << 8) \| (strtoul (ip, &ip, 10) & 0xff);`
150			`if (*ip++ != '.') return 0;`
151			`num = (num << 8) \| (strtoul (ip, &ip, 10) & 0xff);`
152			`if (*ip++ != '.') return 0;`
153			`num = (num << 8) \| (strtoul (ip, &ip, 10) & 0xff);`
154			`return num;`
155			`}`
156
157			`void change_console_type (enum bi_console_type_t con_type)`
158			`{`
159			`debug ("Console change %i -> %i\n", bd.bi_console_type, con_type);`
160			`/* Close previous */`
161			`switch (bd.bi_console_type) {`
162			`case CT_NONE:`
163			`case CT_UART:`
164			`case CT_CRT:`
165			`case CT_SIM:`
166			`break;`
167			`}`
168			`bd.bi_console_type = con_type;`
169			`/* Initialize new */`
170			`switch (bd.bi_console_type) {`
171			`case CT_NONE:`
172			`break;`
173			`case CT_UART:`
174			`uart_init ();`
175			`break;`
176			`case CT_CRT:`
177	140	julius	`#if CRT_ENABLED==1`
178	2	marcus.erl	`screen_init ();`
179			`#endif`
180			`#if KBD_ENABLED`
181			`kbd_init ();`
182			`#endif`
183			`break;`
184			`case CT_SIM:`
185			`break;`
186			`}`
187			`}`
188
189			`void register_command_func (const char name, const char params, const char help, int (func)(int argc, char *argv[]))`
190			`{`
191			`debug ("register_command '%s'\n", name);`
192			`if (num_commands < MAX_COMMANDS) {`
193			`command[num_commands].name = name;`
194			`command[num_commands].params = params;`
195			`command[num_commands].help = help;`
196			`command[num_commands].func = func;`
197			`num_commands++;`
198			`} else printf ("Command '%s' ignored; MAX_COMMANDS limit reached\n", name);`
199			`}`
200
201			`/* Process command and arguments by executing`
202			`specific function. */`
203			`void mon_command(void)`
204			`{`
205			`char c = '\0';`
206			`char str[1000];`
207			`char *pstr = str;`
208			`char *command_str;`
209			`char *argv[20];`
210			`int argc = 0;`
211	246	julius	`int chcnt = 0;`
212	2	marcus.erl
213			`/* Show prompt */`
214			`printf ("\n" BOARD_DEF_NAME"> ");`
215
216	246	julius	`while(1)`
217			`{`
218			`c=getc();`
219			`if (c == '\r' \|\| c == '\f' \|\| c == '\n')`
220			`{`
221			`// Mark end of string`
222			`*pstr = '\0';`
223			`putc('\n');`
224			`break;`
225			`}`
226			`else if (c == '\b') // Backspace`
227			`{`
228			`if (chcnt > 0)`
229			`{`
230			`putc(c);`
231			`putc(' '); // cover char with space`
232			`putc(c);`
233			`pstr--;`
234			`chcnt--;`
235			`}`
236			`}`
237			`else`
238			`{`
239			`putc(c);`
240			`*pstr++ = c;`
241			`chcnt++;`
242			`}`
243			`}`
244	2	marcus.erl
245			`/* Skip leading blanks */`
246			`pstr = str;`
247			`while (pstr == ' ' && pstr != '\0') pstr++;`
248
249			`/* Get command from the string */`
250			`command_str = pstr;`
251
252			`while (1) {`
253			`/* Go to next argument */`
254			`while (pstr != ' ' && pstr != '\0') pstr++;`
255			`if (*pstr) {`
256			`*pstr++ = '\0';`
257			`while (*pstr == ' ') pstr++;`
258			`argv[argc++] = pstr;`
259			`}`
260			`else`
261			`break;`
262			`}`
263
264			`{`
265			`int i, found = 0;`
266
267			`for (i = 0; i < num_commands; i++)`
268			`if (strcmp (command_str, command[i].name) == 0)`
269			`{`
270			`switch ( command[i].func(argc, &argv[0]) )`
271			`{`
272			`case -1:`
273	246	julius	`printf ("Missing/wrong parameters, usage: %s %s\n",`
274			`command[i].name, command[i].params);`
275	2	marcus.erl	`break;`
276			`}`
277
278			`found++;`
279			`break;`
280			`}`
281			`/* 'built-in' build command */`
282			`if(strcmp(command_str, "build") == 0) {`
283			`printf("Build tag: %s", BUILD_VERSION);`
284			`found++;`
285			`}`
286			`if (!found)`
287			`printf ("Unknown command. Type 'help' for help.\n");`
288			`}`
289
290			`}`
291
292			`#if HELP_ENABLED`
293	246	julius	`extern unsigned long src_addr; // Stack section ends here, will print it out`
294	2	marcus.erl	`/* Displays help screen */`
295			`int help_cmd (int argc, char *argv[])`
296			`{`
297			`int i;`
298			`for (i = 0; i < num_commands; i++)`
299			`printf ("%-10s %-20s - %s\n", command[i].name, command[i].params, command[i].help);`
300	140	julius
301			`// Build info....`
302			`printf("\n");`
303	246	julius	`printf("CPU info\n");`
304			`printf("Frequency\t\t%dMHz\n", IN_CLK/1000000);`
305			`print_or1k_cache_info();`
306			`printf("\n");`
307	140	julius	`printf("Info: Stack section addr 0x%x\n",(unsigned long) &src_addr);`
308			`printf("Build tag: %s", BUILD_VERSION);`
309
310	2	marcus.erl	`return 0;`
311			`}`
312			`#endif /* HELP_ENABLED */`
313
314			`void module_cpu_init (void);`
315			`void module_memory_init (void);`
316			`void module_eth_init (void);`
317			`void module_dhry_init (void);`
318	355	julius	`void module_coremark_init (void);`
319	2	marcus.erl	`void module_camera_init (void);`
320			`void module_load_init (void);`
321			`void tick_init(void);`
322			`void module_touch_init (void);`
323			`void module_ata_init (void);`
324			`void module_hdbug_init (void);`
325
326
327			`/* List of all initializations */`
328			`void mon_init (void)`
329			`{`
330			`/* Set defaults */`
331			`global.erase_method = 2; /* as needed */`
332			`global.src_addr = (unsigned long)&src_addr;`
333			`global.dst_addr = FLASH_BASE_ADDR;`
334			`global.eth_add[0] = ETH_MACADDR0;`
335			`global.eth_add[1] = ETH_MACADDR1;`
336			`global.eth_add[2] = ETH_MACADDR2;`
337			`global.eth_add[3] = ETH_MACADDR3;`
338			`global.eth_add[4] = ETH_MACADDR4;`
339			`global.eth_add[5] = ETH_MACADDR5;`
340			`global.ip = BOARD_DEF_IP;`
341			`global.gw_ip = BOARD_DEF_GW;`
342			`global.mask = BOARD_DEF_MASK;`
343	140	julius
344			`#define CPU_CMDS`
345			`#define MEM_CMDS`
346			`#define DHRY_CMDS`
347	355	julius	`#define COREMARK_CMDS`
348	140	julius	`//#define CAMERA_CMDS`
349			`#define LOAD_CMDS`
350			`//#define TOUCHSCREEN_CMDS`
351			`//#define ATA_CMDS`
352			`//#define HDBUG_CMDS`
353			`#define TICK_CMDS`
354			`#define ETH_CMDS`
355			`#define LOAD_CMDS`
356	2	marcus.erl
357			`/* Init modules */`
358	140	julius	`#ifdef CPU_CMDS`
359	2	marcus.erl	`module_cpu_init ();`
360	140	julius	`#endif`
361			`#ifdef MEM_CMDS`
362	2	marcus.erl	`module_memory_init ();`
363	140	julius	`#endif`
364			`#ifdef ETH_CMDS`
365	2	marcus.erl	`module_eth_init ();`
366	140	julius	`#endif`
367			`#ifdef DHRY_CMDS`
368	2	marcus.erl	`module_dhry_init ();`
369	140	julius	`#endif`
370	355	julius	`#ifdef COREMARK_CMDS`
371			`module_coremark_init ();`
372			`#endif`
373	140	julius	`#ifdef CAMERA_CMDS`
374	2	marcus.erl	`module_camera_init ();`
375	140	julius	`#endif`
376			`#ifdef LOAD_CMDS`
377	2	marcus.erl	`module_load_init ();`
378	140	julius	`#endif`
379			`#ifdef TOUCHSCREEN_CMDS`
380	2	marcus.erl	`module_touch_init ();`
381	140	julius	`#endif`
382			`#ifdef ATA_CMDS`
383	2	marcus.erl	`module_ata_init ();`
384	140	julius	`#endif`
385			`#ifdef HDBUG_CMDS`
386	2	marcus.erl	`module_hdbug_init ();`
387	140	julius	`#endif`
388	2	marcus.erl
389	246	julius	`#ifdef TICK_CMDS`
390			`#endif`
391	140	julius
392	2	marcus.erl	`}`
393	140	julius	`int tboot_cmd (int argc, char *argv[]);`
394	2	marcus.erl	`/* Main shell loop */`
395			`int main(int argc, char **argv)`
396			`{`
397			`extern unsigned long calc_mycrc32 (void);`
398	246	julius
399	2	marcus.erl	`#if 0`
400			`extern unsigned long mycrc32, mysize;`
401			`#endif`
402	246	julius
403	140	julius	`timestamp = 0; // clear timer counter`
404	2	marcus.erl
405			`int_init ();`
406	246	julius
407	2	marcus.erl	`change_console_type (CONSOLE_TYPE);`
408	246	julius
409	2	marcus.erl	`mtspr(SPR_SR, mfspr(SPR_SR) \| SPR_SR_IEE);`
410
411			`#if SELF_CHECK`
412			`printf ("Self check... ");`
413			`if ((t = calc_mycrc32 ()))`
414			`printf ("FAILED!!!\n");`
415			`else`
416			`printf ("OK\n");`
417			`#endif /* SELF_CHECK */`
418	246	julius
419	140	julius	`num_commands=0;`
420	2	marcus.erl	`mon_init ();`
421
422	246	julius	`disable_spincursor();`
423
424			`tick_init();`
425
426
427	2	marcus.erl	`if (HELP_ENABLED) register_command ("help", "", "shows this help", help_cmd);`
428
429	140	julius	`printf ("\n" BOARD_DEF_NAME " monitor (type 'help' for help)\n");`
430			`printf("\tbuild: %s", BUILD_VERSION);`
431	2	marcus.erl
432	246	julius	`// Loop forever, accepting commands`
433			`while(1)`
434			`{`
435			`mon_command();`
436			`}`
437
438	2	marcus.erl	`}`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [common/] [common.c] - Blame information for rev 366