avr/cmd_boot.c

   1
   2 /*
   3  * Misc boot support
   4  */
   5 #include "common.h"
   6 #include <stdlib.h>
   7 #include <util/atomic.h>
   8
   9 #include "command.h"
  10 #include "con-utils.h"
  11 #include "z80-if.h"
  12 #include "z180-serv.h"
  13 //#include "debug.h"
  14
  15 /* ugly hack to get Z180 loadfile into flash memory */
  16 #define const const FLASH
  17 #include "../z180/hdrom.h"
  18 #undef const
  19
  20
  21
  22 static void z80_load_mem(void)
  23 {
  24         unsigned sec = 0;
  25         uint32_t sec_base = hdrom_start;
  26
  27         printf_P(PSTR("Loading Z180 memory... \n"));
  28
  29         while (sec < hdrom_sections) {
  30                 printf_P(PSTR("   From: 0x%.5lX to: 0x%.5lX    (%5li bytes)\n"),
  31                                 hdrom_address[sec],
  32                                 hdrom_address[sec]+hdrom_length_of_sections[sec] - 1,
  33                                 hdrom_length_of_sections[sec]);
  34
  35                 z80_bus_cmd(Request);
  36                 z80_write_block((const FLASH unsigned char *) &hdrom[sec_base],  /* src */
  37                                 hdrom_address[sec],                  /* dest */
  38                                 hdrom_length_of_sections[sec]);      /* len */
  39                 z80_bus_cmd(Release);
  40                 sec_base+=hdrom_length_of_sections[sec];
  41                 sec++;
  42         }
  43 }
  44
  45 command_ret_t do_loadf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  46 {
  47         (void) cmdtp; (void) flag; (void) argc; (void) argv;
  48
  49         if (z80_bus_state() & ZST_RUNNING) {
  50                 printf_P(PSTR("## Can't load while CPU is running!\n"));
  51                 return CMD_RET_FAILURE;
  52         }
  53
  54         z80_load_mem();
  55
  56         return CMD_RET_SUCCESS;
  57 }
  58
  59
  60 command_ret_t do_busreq_pulse(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  61 {
  62         uint16_t count=1;
  63
  64         (void) cmdtp; (void) flag;
  65
  66         if (!(z80_bus_state() & ZST_RUNNING)) {
  67                 printf_P(PSTR("## CPU is not running!\n"));
  68                 return CMD_RET_FAILURE;
  69         }
  70
  71         if (argc > 1)
  72                 count = (uint16_t) strtoul(argv[2], NULL, 16);
  73
  74         z80_bus_cmd(Request);
  75         while (count--)
  76                 z80_bus_cmd(M_Cycle);
  77
  78         return CMD_RET_SUCCESS;
  79 }
  80
  81
  82 command_ret_t do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  83 {
  84         uint32_t addr;
  85
  86         (void) cmdtp; (void) flag;
  87
  88         if (argc < 2)
  89                 return CMD_RET_USAGE;
  90         addr = strtoul(argv[1], NULL, 16);
  91         if (addr >= (1UL<<16)) {
  92                 printf_P(PSTR("## Startaddress 0x%05lx too high.\n"
  93                         "   (Out of logical address space (0x00000-0x0ffff))\n"),
  94                         addr);
  95                 return CMD_RET_FAILURE;
  96         }
  97
  98         if (z80_bus_state() & ZST_RUNNING) {
  99                 printf_P(PSTR("## CPU allready running!\n"));
 100                 return CMD_RET_FAILURE;
 101         }
 102
 103         printf_P(PSTR("## Starting application at 0x%04lx ...\n"), addr);
 104
 105         if (addr != 0) {
 106                 uint8_t tmp[3];
 107                 uint_fast8_t i;
 108
 109                 z80_bus_cmd(Request);
 110                 for (i = 0; i < 3; i++)
 111                         tmp[i] = z80_read(i);
 112                 z80_write(0, 0xc3);
 113                 z80_write(1, addr);
 114                 z80_write(2, (addr >> 8));
 115
 116                 z80_bus_cmd(Run);
 117                 z80_bus_cmd(M_Cycle);
 118                 z80_bus_cmd(M_Cycle);
 119                 for (i = 0; i < 3; i++)
 120                         z80_write(i, tmp[i]);
 121         } else
 122                 z80_bus_cmd(Run);
 123
 124         z80_bus_cmd(Release);
 125
 126         return CMD_RET_SUCCESS;
 127 }
 128
 129 command_ret_t do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 130 {
 131         (void) cmdtp; (void) flag; (void) argc; (void) argv;
 132
 133         printf_P(PSTR("## CPU now in reset state.\n"));
 134
 135         restart_z180_serv();
 136         z80_bus_cmd(Reset);
 137         return CMD_RET_SUCCESS;
 138 }
 139
 140 command_ret_t do_restart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 141 {
 142         (void) cmdtp; (void) flag; (void) argc; (void) argv;
 143
 144         restart_z180_serv();
 145         z80_bus_cmd(Restart);
 146
 147         return CMD_RET_SUCCESS;
 148 }
 149
 150
 151 command_ret_t do_console(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 152 {
 153         int ch;
 154         uint8_t pending, state = 0;
 155
 156         (void) cmdtp; (void) flag; (void) argc; (void) argv;
 157
 158
 159         while (1) {
 160
 161                 ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
 162                         pending = (Stat & S_CON_PENDING) != 0;
 163                         Stat &= ~S_CON_PENDING;
 164                 }
 165                 if (pending)
 166                         while ((ch = z80_memfifo_getc(fifo_conout)) >= 0)
 167                                 putchar(ch);
 168
 169                 if ((ch = my_getchar(0)) >= 0) {
 170                         switch (state) {
 171                         case 0:
 172                                 if (ch == CONFIG_ESC_CHAR) {
 173                                         state = 1;
 174                                         /* TODO: Timer starten */
 175                                 } else {
 176                                         z80_memfifo_putc(fifo_conin, ch);
 177 //                                      serial_putc(ch);
 178 //                                      if (ch == '\r')
 179 //                                              serial_putc('\n');
 180                                 }
 181                                 break;
 182                         case 1:
 183                                 switch (ch) {
 184
 185                                 case 'r':
 186 //                                      z80_reset_pulse();
 187                                         break;
 188
 189                                 case 'b':
 190                                         break;
 191
 192                                 case 'e':
 193                                         break;
 194
 195                                 case 'q':
 196                                 case 'Q':
 197                                         printf_P(PSTR("\n"));
 198                                         goto quit;
 199                                         break;
 200
 201                                 case CONFIG_ESC_CHAR:
 202                                 default:
 203                                         z80_memfifo_putc(fifo_conin, ch);
 204 //                                      serial_putc(ch);
 205 //                                      if (ch == '\r')
 206 //                                              serial_putc('\n');
 207                                 }
 208                                 state = 0;
 209                                 break;
 210                         }
 211                 }
 212
 213         }
 214 quit:
 215
 216         return CMD_RET_SUCCESS;
 217 }
 218
 219