avr/cmd_boot.c

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