avr/cmd_boot.c

   1 /*
   2  * (C) Copyright 2014-2016 Leo C. <erbl259-lmu@yahoo.de>
   3  *
   4  * (C) Copyright 2000-2003
   5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0
   8  */
   9
  10 /*
  11  * Misc boot support
  12  */
  13 #include "cmd_boot.h"
  14 #include <ctype.h>
  15 #include <util/atomic.h>
  16
  17 #include "cli_readline.h"       /* console_buffer[] */
  18 #include "cli.h"                        /* run_command() */
  19 #include "env.h"
  20 #include "eval_arg.h"
  21 #include "con-utils.h"
  22 #include "getopt-min.h"
  23 #include "z80-if.h"
  24 #include "z180-serv.h"  /* restart_z180_serv() */
  25 #include "debug.h"
  26
  27 /* ugly hack to get Z180 loadfile into flash memory */
  28 #define const const FLASH
  29 #include "../z180/hdrom.h"
  30 #include "../z180/cfboot.h"
  31 #undef const
  32
  33
  34 command_ret_t do_loadf(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
  35 {
  36         if (z80_bus_state() & ZST_RUNNING)
  37                 cmd_error(CMD_RET_FAILURE, ERUNNING, NULL);
  38         z80_bus_request_or_exit();
  39         z80_load_mem(2, hdrom,
  40                                 &hdrom_sections,
  41                                 hdrom_address,
  42                                 hdrom_length_of_sections);
  43
  44         z80_bus_cmd(Release);
  45
  46         return CMD_RET_SUCCESS;
  47 }
  48
  49
  50 void print_vars(char *title)
  51 {
  52         uint8_t buf[5];
  53         zstate_t state = z80_bus_state();
  54
  55         if((state & ZST_ACQUIRED) == 0)
  56                 z80_bus_cmd(Request);
  57
  58         z80_read_block(buf,     9, sizeof buf);
  59
  60         if((state & ZST_ACQUIRED) == 0)
  61                 z80_bus_cmd(Release);
  62
  63         printf_P(PSTR("%s: stage: %d, flag: 0x%.02x, result: %d, IDE stat/error: 0x%.02x/0x%.02x\n"),
  64                                 title, buf[0], buf[1], buf[2], buf[3], buf[4]);
  65 }
  66
  67
  68 /*
  69  *  bootcf [options]
  70  *
  71  *              -a      address                 (100h)
  72  *              -s      start sector    (0)
  73  *              -c      sector count    (7)
  74  *              -i      Partition id    (52)
  75  *              -n  load only
  76  *              -t      timeout                 (10000)
  77  *              -v      verbose
  78  */
  79
  80 command_ret_t do_bootcf(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
  81 {
  82         struct {
  83                 uint8_t  jr[2];
  84                 uint16_t loadaddr;
  85                 uint8_t  sec_start;
  86                 uint8_t  sec_cnt;
  87                 uint8_t  part_id;
  88                 uint16_t timeout;
  89                 uint8_t  stages;
  90         } boot_param;
  91
  92         struct {
  93                 uint8_t  stages;
  94                 uint8_t  done;
  95                 uint8_t  result;
  96                 uint8_t  ide_stat;
  97                 uint8_t  ide_error;
  98         } boot_res;
  99
 100         int_fast8_t verbosity = 0;
 101         uint8_t default_stages;
 102         uint32_t val;
 103         ERRNUM res = ESUCCESS;
 104
 105         /* get default values */
 106         memcpy_P(&boot_param, cfboot, sizeof boot_param);
 107         default_stages = boot_param.stages;
 108
 109         /* reset getopt() */
 110         optind = 0;
 111
 112         int opt;
 113         while ((opt = getopt(argc, argv, PSTR("vna:s:c:t:i:"))) != -1) {
 114                 switch (opt) {
 115                 case 'v':
 116                         verbosity++;
 117                         break;
 118                 case 'n':
 119                         if (boot_param.stages > 0)
 120                                 boot_param.stages--;
 121                         break;
 122                 case 'a':
 123                         val = eval_arg(optarg, NULL);
 124                         if (val < 0x100 || val > 0xFE00) {
 125                                 printf_P(PSTR("Address out of range: 0x%.4lX\n"), val);
 126                                 return CMD_RET_FAILURE;
 127                         }
 128                         boot_param.loadaddr = val;
 129                         break;
 130                 case 's':
 131                         val = eval_arg(optarg, NULL);
 132                         if (val > 255) {
 133                                 printf_P(PSTR("Start sector out of range: 0x%lX\n"), val);
 134                                 return CMD_RET_FAILURE;
 135                         }
 136                         boot_param.sec_start = val;
 137                         break;
 138                 case 'c':
 139                         val = eval_arg(optarg, NULL);
 140                         if (val > 127) {
 141                                 printf_P(PSTR("Sector count out of range: 0x%lX\n"), val);
 142                                 return CMD_RET_FAILURE;
 143                         }
 144                         boot_param.sec_cnt = val;
 145                         break;
 146                 case 't':
 147                         val = eval_arg(optarg, NULL);
 148                         if (val < 0x1 || val > 0xFFFF) {
 149                                 printf_P(PSTR("Timeout value out of range: 0x%lX\n"), val);
 150                                 return CMD_RET_FAILURE;
 151                         }
 152                         boot_param.timeout = val;
 153                         break;
 154                 case 'i':
 155                         val = eval_arg(optarg, NULL);
 156                         if (val < 0x01 || val > 0xFF) {
 157                                 printf_P(PSTR("Partition id out of range: 0x%lX\n"), val);
 158                                 return CMD_RET_FAILURE;
 159                         }
 160                         boot_param.part_id = val;
 161                         break;
 162                 default: /* '?' */
 163                         return CMD_RET_USAGE;
 164                 }
 165         }
 166
 167         /* remaining arguments */
 168         argc -= optind;
 169         if (argc) {
 170                 my_puts_P(PSTR("Argument error!\n"));
 171                 return CMD_RET_USAGE;
 172         }
 173
 174         if ((val = (uint32_t) boot_param.loadaddr + boot_param.sec_cnt * 512) >= 0xFF00) {
 175                 printf_P(PSTR("Top address out of range: 0x%.4lX\n"), val);
 176                 return CMD_RET_FAILURE;
 177         }
 178
 179         if (z80_bus_state() & ZST_RUNNING)
 180                 cmd_error(CMD_RET_FAILURE, ERUNNING, NULL);
 181         z80_bus_request_or_exit();
 182         z80_load_mem(verbosity, cfboot,
 183                                 &cfboot_sections,
 184                                 cfboot_address,
 185                                 cfboot_length_of_sections);
 186
 187         z80_write_block((const uint8_t *) &boot_param,
 188                                 cfboot_address[0], sizeof boot_param);
 189         z80_bus_cmd(Release);
 190
 191         if (boot_param.stages == 0) {
 192                 printf_P(PSTR("Bootloader loaded at: 0x%.4X\n"), (uint16_t) cfboot_address[0]);
 193         } else {
 194                 printf_P(PSTR("Executing %d of %d Bootloader stages...\n"),
 195                                 boot_param.stages, default_stages);
 196
 197                 z80_bus_cmd(Run);
 198                 z80_bus_cmd(Release);
 199
 200                 clear_ctrlc();          /* forget any previous Control C */
 201                 for (boot_res.done = 0; boot_res.done != 0xFF;) {
 202                         _delay_ms(8);
 203                         /* check for ctrl-c to abort... */
 204                         if (had_ctrlc() || ctrlc()) {
 205                                 break;
 206                         }
 207                         z80_bus_cmd(Request);
 208                         z80_read_block((uint8_t *) &boot_res,
 209                                         cfboot_address[0]+sizeof boot_param - 1, sizeof boot_res);
 210                         z80_bus_cmd(Release);
 211                 }
 212
 213                 if (boot_res.done != 0xFF) {
 214                         z80_bus_cmd(Reset);
 215                         my_puts_P(PSTR("Abort\n"));
 216                 } else {
 217                         if (boot_param.stages == default_stages &&
 218                                         boot_res.stages == 0 &&
 219                                         boot_res.result == 0) {
 220                                 my_puts_P(PSTR("Booting...\n"));
 221                         } else {
 222                                 z80_bus_cmd(Reset);
 223                                 boot_res.stages++;
 224                                 printf_P(PSTR("Bootloader stopped at stage %d, result: %d, IDE stat/error: 0x%.02x/0x%.02x\n"),
 225                                         boot_param.stages - boot_res.stages,
 226                                         boot_res.result, boot_res.ide_stat, boot_res.ide_error);
 227                         }
 228                 }
 229         }
 230
 231         return CMD_RET_SUCCESS;
 232 }
 233
 234 command_ret_t do_busreq_pulse(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 235 {
 236         uint16_t count=1;
 237
 238         if (!(z80_bus_state() & ZST_RUNNING)) {
 239                 printf_P(PSTR("## CPU is not running!\n"));
 240                 return CMD_RET_FAILURE;
 241         }
 242
 243         if (argc > 1)
 244                 count = (uint16_t) eval_arg(argv[1], NULL);
 245
 246         z80_bus_cmd(Request);
 247         while (count--)
 248                 z80_bus_cmd(M_Cycle);
 249
 250         return CMD_RET_SUCCESS;
 251 }
 252
 253
 254 command_ret_t do_go(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc, char * const argv[])
 255 {
 256         uint32_t addr;
 257
 258         if (argc < 2)
 259                 return CMD_RET_USAGE;
 260         addr = eval_arg(argv[1], NULL);
 261         if (addr >= (1UL<<16)) {
 262                 printf_P(PSTR("## Startaddress 0x%05lx too high.\n"
 263                         "   (Out of logical address space (0x00000-0x0ffff))\n"),
 264                         addr);
 265                 return CMD_RET_FAILURE;
 266         }
 267
 268         if (z80_bus_state() & ZST_RUNNING) {
 269                 printf_P(PSTR("## CPU already running!\n"));
 270                 return CMD_RET_FAILURE;
 271         }
 272
 273         printf_P(PSTR("## Starting application at 0x%04lx ...\n"), addr);
 274
 275         if (addr != 0) {
 276                 uint8_t tmp[3];
 277
 278                 z80_bus_cmd(Request);
 279                 z80_read_block (tmp, 0, 3);
 280                 z80_write(0, 0xc3);
 281                 z80_write(1, addr);
 282                 z80_write(2, (addr >> 8));
 283
 284                 z80_bus_cmd(Run);
 285                 z80_bus_cmd(M_Cycle);
 286                 z80_bus_cmd(M_Cycle);
 287                 z80_write_block(tmp, 0, 3);
 288         } else
 289                 z80_bus_cmd(Run);
 290
 291         z80_bus_cmd(Release);
 292
 293         return CMD_RET_SUCCESS;
 294 }
 295
 296 static
 297 void reset_cpu(bus_cmd_t mode)
 298 {
 299         restart_z180_serv();
 300         z80_bus_cmd(mode);
 301 }
 302
 303
 304 command_ret_t do_reset(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
 305 {
 306         printf_P(PSTR("CPU now in reset state.\n"));
 307
 308         reset_cpu(Reset);
 309         return CMD_RET_SUCCESS;
 310 }
 311
 312 command_ret_t do_restart(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
 313 {
 314         reset_cpu(Restart);
 315
 316         return CMD_RET_SUCCESS;
 317 }
 318
 319 static
 320 void print_con_usage(char esc)
 321 {       printf_P(PSTR("\n"
 322                 "------------------------------------------------\n"
 323                 " ?,H - This Help\n"
 324                 " Q,X - Return to command line\n"
 325                 " R   - Reset (Restart) CPU\n"
 326                 " :   - Execute monitor command\n"
 327                 " \\   - code input:\n"
 328                 "       \\nnn   3 decimal digits character code\n"
 329                 "       \\Xhh   2 hexadecimal digits character code\n"
 330                 " ^%c  - (Escape char) Type again to send itself\n"
 331                 "key>"
 332         ), esc + 0x40);
 333 }
 334
 335 command_ret_t do_console(cmd_tbl_t *cmdtp UNUSED, uint_fast8_t flag UNUSED, int argc UNUSED, char * const argv[] UNUSED)
 336 {
 337         int ch;
 338         uint8_t pending;
 339         uint8_t code = 0;
 340         uint8_t state = 0;
 341         char esc_char = (char) getenv_ulong(PSTR(ENV_ESC_CHAR), 16, CONFIG_ESC_CHAR);
 342
 343         printf_P(PSTR("Connecting to CPU. Escape character is '^%c'.\n"),
 344                                         esc_char + 0x40);
 345
 346         while (1) {
 347
 348                 ATOMIC_BLOCK(ATOMIC_FORCEON) {
 349                         pending = (Stat & S_CON_PENDING) != 0;
 350                         Stat &= ~S_CON_PENDING;
 351                 }
 352                 if (pending) {
 353                         uint8_t count = 100;
 354                         while ((ch = z80_memfifo_getc(fifo_conout)) >= 0 && --count)
 355                                 putchar(ch);
 356                 }
 357
 358                 if ((ch = my_getchar(0)) >= 0) {
 359                         switch (state) {
 360                         case 0:
 361                                 if (ch == esc_char) {
 362                                         state = 1;
 363                                         /* TODO: Timer starten */
 364                                 } else {
 365                                         z80_memfifo_putc(fifo_conin, ch);
 366                                 }
 367                                 break;
 368                         case 2:
 369                                 my_puts_P(PSTR("\n"
 370                                   "------------------------------------------------\n"));
 371                         case 1:
 372                                 state = 0;
 373                                 switch (toupper(ch)) {
 374
 375                                 case '?':
 376                                 case 'H':
 377                                         print_con_usage(esc_char);
 378                                         state = 2;
 379                                         break;
 380
 381                                 case 'R':
 382                                         reset_cpu(Restart);
 383                                         break;
 384
 385                                 case 'X':
 386                                 case 'Q':
 387                                         putchar('\n');
 388                                         goto quit;
 389                                         break;
 390
 391                                 case ':':
 392                                                 putchar('\n');
 393                                                 int cmdlen = cli_readline(PSTR(": "), 1);
 394                                                 if (cmdlen > 0)
 395                                                         run_command(console_buffer, 0);
 396                                         break;
 397
 398                                 case '\\':
 399                                         code = 0;
 400                                         state = 3;
 401                                         break;
 402
 403                                 default:
 404                                         if (ch == esc_char)
 405                                                 z80_memfifo_putc(fifo_conin, ch);
 406                                         break;
 407                                 }
 408                                 break;
 409                         case 3:
 410                                 if (toupper(ch) == 'X') {
 411                                         state = 6;
 412                                         break;
 413                                 }
 414                                 /* fall thru */
 415                         case 4:
 416                         case 5:
 417                                 if (isdigit(ch)) {
 418                                         code = code * 10 + ch - '0';
 419                                         state++;
 420                                 } else {
 421                                         if (state > 3)
 422                                                 z80_memfifo_putc(fifo_conin, code);
 423                                         z80_memfifo_putc(fifo_conin, ch);
 424                                         state = 0;
 425                                 }
 426                                 if (state > 5) {
 427                                         z80_memfifo_putc(fifo_conin, code);
 428                                         state = 0;
 429                                 }
 430                                 break;
 431                         case 6:
 432                         case 7:
 433                                 if (isxdigit(ch)) {
 434                                         ch = toupper(ch);
 435                                         if (ch >= 'A')
 436                                                 ch -= 'A' - 10;
 437                                         code = code * 16 + ch - '0';
 438                                         state++;
 439                                 }else {
 440                                         if (state > 6)
 441                                                 z80_memfifo_putc(fifo_conin, code);
 442                                         z80_memfifo_putc(fifo_conin, ch);
 443                                         state = 0;
 444                                 }
 445                                 if (state > 7) {
 446                                         z80_memfifo_putc(fifo_conin, code);
 447                                         state = 0;
 448                                 }
 449                                 break;
 450                         }
 451                 }
 452         }
 453 quit:
 454         return CMD_RET_SUCCESS;
 455 }