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