source: buchla-68k/rom/romp.c@ c59409e

Last change on this file since c59409e was c59409e, checked in by Thomas Lopatic <thomas@…>, 7 years ago

Volatile hardware accesses.
  • Property mode set to 100644
File size: 68.5 KB
Line 
1/*
2 ============================================================================
3 romp.c -- ROMP debug monitor
4 (c) Copyright 1987,1988 -- D.N. Lynx Crowe
5
6 See ROMPVER, below, for version number and date.
7
8 CAUTION: This code is designed to live in PROM, so initialized
9 variables are PERMANENTLY initialized, since the compiler assigns
10 initialized variables to the data segment, which ends up in PROM.
11
12 Un-initialized variables go into the bss segment, which ends up in RAM.
13
14 Set ON_B700 non-zero to get a Buchla 700 PROM,
15 or zero to get a NASA 3D Helmet Display PROM.
16 ============================================================================
17*/
18
19#define ROMPVER "22.00 -- 1988-06-20"
20
21#define TINYMSG 0 /* 1 for short messages, 0 for normal ones */
22
23#define ON_B700 1 /* 1 for Buchla 700, 0 for NASA */
24#define ONEMEG 1 /* 1 if 1024K, 0 if 512K RAM space (Buchla 700) */
25
26#include "rom.h"
27
28#if ON_B700
29#define USER_RAM 0x00010000L /* Start of user RAM (TPA) */
30#if ONEMEG
31#define RAM_TOP 0x000FFFFEL /* Default top word of memory */
32#define ISTACK 0x000FFFFEL /* Default initial stack */
33#else
34#define RAM_TOP 0x0007FFFEL /* Default top word of memory */
35#define ISTACK 0x0007FFFEL /* Default initial stack */
36#endif
37#define KB_EI 2 /* Enable level for panel */
38#define DEFIPL 2 /* Default internal processor level */
39#define INITSR 0x2200 /* Default initial status register */
40#define BOOTFILE "midas.abs" /* Boot file name */
41#define BOOTKEY 39 /* Boot panel key */
42#define ROMPKEY 40 /* ROMP panel key */
43#define FIFOLIM 60000 /* FIFO clear limit */
44#define I_TABX 53 /* Tablet X */
45#define I_TABY 54 /* Tablet Y */
46#define I_CURX 55 /* Cursor X */
47#define I_CURY 56 /* Cursor Y */
48#define I_LONGL 57 /* LongPot Left */
49#define I_LONGR 58 /* LongPot Right */
50#define I_SCROLL 59 /* Scroll */
51#define I_TEMPO 73 /* Tempo Multiplier */
52#define I_TIME 74 /* Time Scaling */
53#define I_TUNE 75 /* Fine Tuning */
54#define I_LEVEL 76 /* Amplitude */
55#define BARBASE 5120L /* Base of bars in VSDD RAM */
56#define SWBASE 38400L /* Base of switches in VSDD RAM */
57#define MARGIN 4 /* Offset from left edge of screen */
58#else
59#define DEFIPL 3
60#define USER_RAM 0x00008000L
61#define RAM_TOP 0x0001FFFEL
62#define ISTACK 0x0001FFFEL
63#define INITSR 0x2300
64#endif
65
66#define ROMADDR 0x00100000L
67
68#define PRM_DATE 0x0100008L
69#define PRM_VERS 0x0100002L
70
71#define BPINST 0x4E4F /* breakpoint instruction */
72
73#define CRLF "\r\n"
74
75#define TACK "K\r" /* good response from load command */
76#define NACK "?\r" /* bad response from load command */
77
78#define SREC9 "04000000FB" /* tail of a type 9 Motorola S-Record */
79
80#define MON_C 1 /* monitor character code */
81#define MON_S 2 /* monitor short code */
82#define MON_L 4 /* monitor long code */
83
84/*
85 ============================================================================
86 error message string definitions
87 ============================================================================
88*/
89
90#define EMSG1 "\r\n** Command error **\r\n"
91#define EMSG2 "\r\n** Invalid parameter **\r\n"
92#define EMSG3 "\r\n** Unrecognized command **\r\n"
93
94#define EMSG5 "\r\n** Command not repeatable **\r\n"
95#define EMSG6 "\r\n** Invalid line terminator **\r\n"
96#define EMSG7 "\r\n** do_cmd() switch failed **\r\n"
97
98#define CANNED "\r\n----- Cancelled -----\r\n"
99
100/*
101 ============================================================================
102 initialized variables (These end up in the data segment in PROM)
103 ============================================================================
104*/
105
106struct cmdent { /* command table entry */
107
108 int8_t *cname; /* command name pointer */
109 int16_t (*cp)(void); /* command parser function pointer */
110 int16_t (*cx)(void); /* command execution function pointer */
111 int8_t *hstr; /* help string pointer */
112};
113
114static struct cmdent cmtab[] = {
115
116#if ON_B700
117 {"adisp", cp_null, cx_adsp, ""},
118 {"boot", cp_boot, cx_boot, ""},
119 {"bpb", cp_null, cx_bpb, ""},
120#endif
121
122 {"check", cp_chek, cx_chek, "start,end"},
123 {"copy", cp_copy, cx_copy, "from,to,len"},
124
125#if ON_B700
126 {"crash", cp_null, cx_crsh, ""},
127 {"dinit", cp_null, cx_dini, ""},
128#endif
129
130 {"dump", cp_dump, cx_dump, "from[,[to=from][,width=16]]"},
131 {"exit", cp_null, cx_exit, ""},
132 {"fill", cp_fill, cx_fill, "loc,count,byte"},
133 {"go", cp_go, cx_go, "[addr][,[brk1][,brk2]]"},
134 {"help", cp_null, cx_help, ""},
135 {"ipl", cp_ilev, cx_ilev, "level"},
136 {"ldump", cp_ldmp, cx_ldmp, "from[,[to=from][,width=4]]"},
137 {"load", cp_null, cx_load, ""},
138
139#if ON_B700
140 {"midas", cp_null, cx_mlod, ""},
141#endif
142
143 {"monc", cp_monc, cx_mon, "addr"},
144 {"mons", cp_mons, cx_mon, "addr"},
145 {"monl", cp_monl, cx_mon, "addr"},
146 {"mset", cp_mset, cx_mset, "addr,b1[,...,bn]"},
147 {"mtest", cp_mtst, cx_mtst, hs_mtst},
148 {"next", cp_null, cx_next, ""},
149 {"obmap", cp_null, cx_omap, ""},
150
151#if ON_B700
152 {"read", cp_read, cx_read, "sector,buffer,count"},
153#endif
154
155 {"regs", cp_null, cx_regs, ""},
156 {"reset", cp_null, cx_rest, ""},
157 {"rset", cp_rset, cx_rset, "register,value"},
158 {"vregs", cp_null, cx_vreg, ""},
159 {"vrset", cp_vrst, cx_vrst, "register,value"},
160 {"wdump", cp_wdmp, cx_wdmp, "from[,[to=from][,width=8]]"},
161 {"wfill", cp_wfil, cx_wfil, "loc,count,word"},
162
163#if ON_B700
164 {"write", cp_read, cx_writ, "sector,buffer,count"},
165#endif
166
167 {"wset", cp_wset, cx_wset, "addr,w1[,...,wn]"},
168 {"zap", cp_null, cx_zap, ""}
169};
170
171#define NCMDS ((sizeof cmtab) / (sizeof cmtab[0]))
172
173int8_t ahex[] = "0123456789abcdefABCDEF";
174
175int8_t *rlist[] = { /* register name list */
176
177 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
178 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
179 "sr", "pc", "sp",
180 (int8_t *)0
181};
182
183int8_t *vrlist[] = { /* video register name list */
184
185 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
186 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
187 "h0", "h1", "h2", "h3", "v0", "v1", "v2", "v3",
188 (int8_t *)0
189};
190
191#if ON_B700
192int16_t sigadr[] = { /* display offsets for signals */
193
194 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, /* keys */
195 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
196 4, 4, 4, 4,
197 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, /* sliders */
198 9, 9, 9, 9,
199 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, /* switches */
200 14, 14, 14, 14,
201 17, 17, /* tablet */
202 20, 20, /* cursor */
203 23, 23, /* longpot */
204 26, /* scrollpot */
205 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, /* digits */
206 32, 32, 32, /* x, e, m */
207 35, 35, 35, 35, /* pots */
208 37, 37, /* pedals */
209 39, 39, 39, 39 /* analog in */
210};
211#endif
212
213/*
214 ============================================================================
215 un-initialized variables (These end up in the bss segment in RAM)
216 ============================================================================
217*/
218
219int8_t argsep; /* argument separator */
220
221int8_t *aptr, /* argument pointer */
222 *monptr, /* monitored variable pointer */
223 *d_cur, /* dump current from */
224 *d_next, /* dump next from */
225 *d_last, /* dump next to */
226 *p_end, /* end parameter */
227 *p_from, /* from parameter */
228 *p_to, /* to parameter */
229 *sptr; /* string scan pointer */
230
231int16_t argln, /* argument length */
232 b0flag, /* breakpoint 0 flag */
233 b1flag, /* breakpoint 1 flag */
234 cmdunit, /* command unit */
235 dflag, /* dump limit flag */
236 exflag, /* exit do_cmd flag */
237 first1, /* first time flag */
238 goflag, /* pc set flag */
239 ilast, /* index of last command */
240 inext, /* command index for "next" command */
241 iplev, /* ROMP IPL level */
242 monsw, /* monitor switch */
243 redo, /* re-doable command flag */
244 rnum, /* register number */
245 vrnum; /* video register number */
246
247#if ON_B700
248int16_t asig, /* signal number */
249 aval, /* signal value */
250 astat, /* signal status */
251 aflag, /* signal activity flag */
252 baseled, /* base LED for scan */
253 ledcntr; /* LED scan counter */
254
255int16_t sigtab[128][2]; /* signal table */
256
257int32_t afi, /* analog FIFO input */
258 ftimer; /* analog FIFO clear timer */
259
260uint16_t baron, /* bar 'on' color */
261 baroff, /* bar 'off' color */
262 swon, /* switch 'on' color */
263 swoff, /* switch 'off' color */
264 *obj0; /* object pointer */
265#endif
266
267uint16_t *tba0, /* breakpoint 0 temporary */
268 *tba1; /* breakpoint 1 temporary */
269
270uint16_t p_bv0, /* breakpoint 0 value */
271 p_bv1; /* breakpoint 1 value */
272
273uint16_t *p_ba0, /* breakpoint 0 address */
274 *p_ba1; /* breakpoint 1 address */
275
276jmp_buf restart; /* jmp environment */
277
278int32_t p_goto, /* goto parameter */
279 p_len, /* length parameter */
280 p_value, /* value parameter */
281 p_width; /* width parameter */
282
283struct regs *regptr; /* register save area pointer */
284
285int8_t argstr[MAXARGLN+1], /* argument string */
286 cmdline[MAXCMDLN+1], /* command line */
287 bfname[MAXFNLN+1], /* boot file name */
288 hs_mtst[MAXHS+1], /* mtest help string */
289 idbuf[MAXID+1], /* ID string */
290 promdate[PDATELN+1]; /* PROM date area */
291
292/*
293 ============================================================================
294 cx_exit -- restart ROMP
295 ============================================================================
296*/
297
298int16_t cx_exit(void)
299{
300 longjmp(&restart, 1); /* restart ROMP */
301 return(TRUE); /* not reached */
302}
303
304/*
305 ============================================================================
306 cx_rest -- execute the reset command
307 ============================================================================
308*/
309
310int16_t cx_rest(void)
311{
312 rjumpto((void *)ROMADDR);
313 return(TRUE); /* not reached */
314}
315
316/*
317 ============================================================================
318 cx_mlod() -- execute the midas command
319 ============================================================================
320*/
321
322int16_t cx_mlod(void)
323{
324 register int16_t i;
325
326 B_log_s = TRUE;
327 B_dbg_s = FALSE;
328 redo = FALSE;
329
330 hdvini();
331 _bpbin = FALSE;
332
333 if (booter("midas.abs", 0L)) {
334
335 return(FALSE);
336
337 } else {
338
339 for (i = 0; i < 8; i++) /* clear d0..d7 */
340 regptr->d_reg[i] = 0L;
341
342 for (i = 0; i < 7; i++) /* clear a0..a6 */
343 regptr->a_reg[i] = 0L;
344
345 regptr->a_reg[7] = ISTACK; /* setup initial stack */
346
347 regptr->reg_sr = INITSR; /* setup sr */
348 regptr->reg_pc = (uint32_t)B_buf_a; /* setup pc */
349
350 return(TRUE);
351 }
352}
353
354/*
355 ============================================================================
356 cp_boot() -- parse boot command
357 ============================================================================
358*/
359
360int16_t cp_boot(void)
361{
362 register int16_t i;
363 register int8_t endc;
364
365 redo = FALSE;
366
367 for (;;) {
368
369 writeln(cmdunit, "File name: ");
370 endc = (int8_t)getln(cmdunit, MAXFNLN+1, bfname);
371 writeln(cmdunit, CRLF);
372
373 if (endc EQ A_CR)
374 break;
375
376 if (endc EQ CTL('X')) {
377
378 writeln(cmdunit, CANNED);
379 return(FALSE);
380 }
381
382 if (endc EQ ERR01)
383 writeln(cmdunit, EMSG2);
384 }
385
386 for (i = 0; i < MAXFNLN+1; i++)
387 if (bfname[i] EQ A_CR)
388 bfname[i] = '\0';
389
390 return(TRUE);
391}
392
393/*
394 ============================================================================
395 cx_boot() -- execute boot command
396 ============================================================================
397*/
398
399int16_t cx_boot(void)
400{
401 register int16_t i;
402
403 B_log_s = TRUE;
404 B_dbg_s = FALSE;
405
406 hdvini();
407 _bpbin = FALSE;
408
409 if (booter(bfname, 0L)) {
410
411 return(FALSE);
412
413 } else {
414
415 for (i = 0; i < 8; i++) /* clear d0..d7 */
416 regptr->d_reg[i] = 0L;
417
418 for (i = 0; i < 7; i++) /* clear a0..a6 */
419 regptr->a_reg[i] = 0L;
420
421 regptr->a_reg[7] = ISTACK; /* setup initial stack */
422
423 regptr->reg_sr = INITSR; /* setup sr */
424 regptr->reg_pc = (uint32_t)B_buf_a; /* setup pc */
425
426 return(TRUE);
427 }
428}
429
430/*
431 =============================================================================
432 dobar(nb, bv) -- draw bar 'nb' with value 'bv'
433 =============================================================================
434*/
435
436void dobar(int16_t nb, int16_t bv)
437{
438 register uint16_t *bp;
439 register int16_t i;
440
441 if ((nb LT 1) OR (nb GT 82))
442 return;
443
444 --nb;
445 bp = obj0 + BARBASE + (int32_t)(sigadr[nb] + MARGIN + nb);
446
447 for (i = 127; i GE 0; --i) {
448
449 if (i GT bv) {
450
451 *bp = baroff;
452 bp += 128L;
453 *bp = baroff;
454
455 } else {
456
457 *bp = baron;
458 bp += 128L;
459 *bp = baron;
460 }
461
462 bp += 128L;
463 }
464}
465
466/*
467 =============================================================================
468 dosw(nb, sv) -- display value 'sv' of switch 'nb'
469 =============================================================================
470*/
471
472void dosw(int16_t nb, int16_t sv)
473{
474 register uint16_t *bp, j;
475 register int16_t i;
476
477 if ((nb LT 1) OR (nb GT 82))
478 return;
479
480 --nb;
481 bp = obj0 + SWBASE + (int32_t)(sigadr[nb] + MARGIN + nb);
482
483 if (sv)
484 j = swon;
485 else
486 j = swoff;
487
488 for (i = 0; i < 8; i++) {
489
490 *bp = j;
491 bp += 128L;
492 }
493}
494
495/*
496 =============================================================================
497 exp_c() -- expand a 4 bit color into a 16 bit word
498 =============================================================================
499*/
500
501uint16_t exp_c(uint16_t c)
502{
503 c &= 0x000F;
504 c |= c << 4;
505 c |= c << 8;
506
507 return(c);
508}
509
510/*
511 =============================================================================
512 cx_adsp() -- display values of analog processor variables as a bar graph
513 =============================================================================
514*/
515
516int16_t cx_adsp(void)
517{
518 register int16_t xasig, xastat, xaval;
519 register int32_t xafi;
520 register int32_t lc;
521 register uint16_t *bp;
522 int16_t i, j, k;
523 int16_t oldi;
524
525 memsetw(sigtab, 0, sizeof sigtab / 2);
526
527 VHinit();
528 VSinit();
529 vsndpal(dfltpal);
530
531 obj0 = (uint16_t *)0x200400L;
532
533 SetObj(0, 0, 0, obj0, 512, 350, 0, 0, (V_RES3 | V_TDE), -1);
534
535 bp = obj0;
536
537 for (lc = 0; lc < 44800; lc++)
538 *bp++ = 0x0000;
539
540 baron = 0x0FFF & exp_c(P_WHT);
541 baroff = 0x0FFF & exp_c(P_DKGRY);
542 swon = 0x0FFF & exp_c(P_YEL);
543 swoff = 0x0FFF & exp_c(P_DKGRY);
544
545 SetPri(0, 7);
546
547 for (i = 1; i < 83; i++) {
548
549 dobar(i, 0);
550 dosw(i, 0);
551 }
552
553 oldi = setipl(2);
554
555 while (0L EQ BIOS(B_RDAV, CON_DEV)) {
556
557 if (-1L NE (xafi = XBIOS(X_ANALOG))) {
558
559 xasig = 0x007F & (xafi >> 8);
560 xastat = 0x0001 & (xafi >> 7);
561 xaval = 0x007F & xafi;
562
563 if (xasig) {
564
565 sigtab[xasig][0] = xaval;
566 sigtab[xasig][1] = xastat;
567
568 if (xasig LT 83) {
569
570 dobar(xasig, xaval);
571 dosw(xasig, xastat);
572 }
573
574 } else {
575
576 for (i = 0; i < 83; i++)
577 sigtab[i][1] = 0;
578 }
579 }
580 }
581
582 BIOS(B_GETC, CON_DEV);
583
584 for (j = 1; j < 83; j++) {
585
586 dobar(j, sigtab[j][0]);
587 dosw(j, sigtab[j][1]);
588 }
589
590 k = 0;
591
592 printf("\n");
593 printf(" x0 x1 x2 x3 x4 x5 x6 x7 x8 x9\r\n");
594 printf(" ----- ----- ----- ----- ----- ----- ----- ----- ----- -----\r\n");
595
596 for (i = 0; i < 9; i++ ) {
597
598 printf("%01dx ", k/10);
599
600 for (j = 0; j < 10; j++) {
601
602 if (k)
603 printf("%1d:%3d ", sigtab[k][1], sigtab[k][0]);
604 else
605 printf(" ");
606
607 if (++k EQ 83)
608 goto outofit;
609 }
610
611 printf("\n");
612 }
613
614outofit:
615
616 printf("\nTempo = %3d, Time = %3d, Tuning = %3d, Level = %3d\n",
617 sigtab[I_TEMPO][0], sigtab[I_TIME][0],
618 sigtab[I_TUNE][0], sigtab[I_LEVEL][0]);
619
620 printf("LongPot L = %3d, LongPot R = %3d, Scroll = %3d\n",
621 sigtab[I_LONGL][0], sigtab[I_LONGR][0],
622 sigtab[I_SCROLL][0]);
623
624 printf("Tablet X = %3d, Tablet Y = %3d\n",
625 sigtab[I_TABX][0], sigtab[I_TABY][0]);
626
627 printf("Cursor X = %3d, Cursor Y = %3d\n",
628 sigtab[I_CURX][0], sigtab[I_CURY][0]);
629
630 setipl(oldi);
631 return(TRUE);
632}
633
634/*
635 =============================================================================
636 waitcr2() -- wait for a CR from CON_DEV
637 Returns: 0 = continue
638 1 = ^G hit - abort
639 =============================================================================
640*/
641
642int16_t waitcr2(void)
643{
644 int8_t c;
645
646 BIOS(B_PUTC, CON_DEV, '\007');
647
648 while ('\r' NE (c = (0x7F & BIOS(B_GETC, CON_DEV)))) {
649
650 if (c EQ '\007')
651 return(1);
652 }
653
654 return(0);
655}
656
657/*
658 ============================================================================
659 xdtoi -- convert hex ASCII to an int digit
660 ============================================================================
661*/
662
663int16_t xdtoi(int16_t c)
664{
665 register int16_t i;
666 register int8_t *ap = &ahex[0];
667
668 for (i = 0; i < 22; i++)
669 if (c EQ *ap++) {
670 if (i >15)
671 return(i - 6);
672 else
673 return(i);
674 }
675
676 return(-1);
677}
678
679/*
680 ============================================================================
681 getcmd -- parse command from input line
682 ============================================================================
683*/
684
685int16_t getcmd(void)
686{
687 register int16_t c;
688
689 sptr = cmdline;
690 argln = 0;
691 aptr = argstr;
692 memset(argstr, 0, MAXARGLN+1);
693
694 do {
695
696 switch (c = 0x00FF & *sptr) {
697
698 case '\0':
699 case A_CR:
700 case A_LF:
701
702 argsep = (int8_t)c;
703 return(argln);
704
705 case ' ':
706
707 ++sptr;
708
709 while (*sptr EQ ' ')
710 ++sptr;
711
712 if (*sptr EQ A_CR OR *sptr EQ A_LF OR *sptr EQ '\0')
713 c = 0x00FF & *sptr;
714
715 argsep = (int8_t)c;
716 return(argln);
717
718 default:
719
720 if (isupper(c))
721 c = _tolower(c);
722
723 *aptr++ = (int8_t)c;
724 ++sptr;
725 ++argln;
726 }
727
728 } while (*sptr);
729
730 argsep = 0;
731 return(argln);
732}
733
734/*
735 ============================================================================
736 getarg -- parse out an argument to analyze
737 ============================================================================
738*/
739
740int16_t getarg(void)
741{
742 register int16_t c;
743
744 argln = 0;
745 aptr = argstr;
746 memset(argstr, 0, MAXARGLN+1);
747
748 do {
749
750 switch (c = 0x00FF & *sptr) {
751
752 case '\0':
753 case A_CR:
754 case A_LF:
755
756 argsep = (int8_t)c;
757 return(argln);
758
759 case ' ':
760
761 ++sptr;
762
763 while (*sptr EQ ' ')
764 ++sptr;
765
766 if (*sptr EQ A_CR OR *sptr EQ A_LF OR *sptr EQ '\0')
767 c = 0x00FF & *sptr;
768
769 argsep = (int8_t)c;
770 return(argln);
771
772 case ',':
773
774 ++sptr;
775 argsep = (int8_t)c;
776 return(argln);
777
778 default:
779
780 *aptr++ = (int8_t)c;
781 ++sptr;
782 ++argln;
783 }
784
785 } while (*sptr);
786
787 argsep = 0;
788 return(argln);
789}
790
791/*
792 ============================================================================
793 getlong -- get a long integer (either hex or decimal)
794 ============================================================================
795*/
796
797int16_t getlong(int32_t *var)
798{
799 register int32_t temp = 0L;
800 register int16_t csw = FALSE,
801 c;
802
803 if (*aptr EQ '$') {
804
805 ++aptr;
806
807 while (isxdigit(c = *aptr++)) {
808
809 temp = (temp << 4) + xdtoi(c);
810 csw = TRUE;
811 }
812
813 } else {
814
815 while (isdigit(c = *aptr++)) {
816
817 temp = (temp * 10) + (c - '0');
818 csw = TRUE;
819 }
820 }
821
822 if (csw)
823 *var = temp;
824
825 return(c);
826}
827
828/*
829 ============================================================================
830 setvar -- parse an expression and set a long variable
831 ============================================================================
832*/
833
834int16_t setvar(int32_t *var, int32_t deflt)
835{
836 int16_t rc;
837 int32_t temp;
838
839 *var = deflt;
840 aptr = argstr;
841
842 rc = getlong(var);
843
844 if (rc) {
845
846 do {
847
848 switch (rc) {
849
850 case '+':
851
852 temp = 0L;
853 rc = getlong(&temp);
854 *var = *var + temp;
855 continue;
856
857 case '-':
858
859 temp = 0L;
860 rc = getlong(&temp);
861 *var = *var - temp;
862 continue;
863
864 default:
865
866 *var = deflt;
867 return(FALSE);
868 }
869
870 } while (rc);
871
872 return(TRUE);
873 }
874
875 return(TRUE);
876}
877
878/*
879 ============================================================================
880 setp -- parse an expression and set a pointer variable
881 ============================================================================
882*/
883
884int16_t setp(void *var, void *deflt)
885{
886 return setvar((int32_t *)var, (int32_t)deflt);
887}
888
889/*
890 ============================================================================
891 putn -- output a decimal number
892 ============================================================================
893*/
894
895void putn(uint32_t num, int16_t cw, int16_t unit)
896{
897 register int16_t d;
898
899 if (!cw)
900 return;
901
902 putn(num/10, cw-1, unit);
903
904 d = (int16_t)(num % 10);
905
906 BIOS(B_PUTC, unit, (d + '0'));
907
908 return;
909}
910
911/*
912 ============================================================================
913 puthn -- output a hex number
914 ============================================================================
915*/
916
917void puthn(uint32_t num, int16_t cw, int16_t unit)
918{
919 register int16_t d;
920
921 if (!cw)
922 return;
923
924 puthn(num >> 4, cw-1, unit);
925
926 d = 0x0F & num;
927
928 if (d > 9)
929 BIOS(B_PUTC, unit, (d - 10 + 'A'));
930 else
931 BIOS(B_PUTC, unit, (d + '0'));
932
933 return;
934}
935
936/*
937 ============================================================================
938 ddump -- do the hex portion of a dump
939 ============================================================================
940*/
941
942int16_t ddump(int8_t *loc, int8_t *lastloc, int16_t nwide, int16_t unit)
943{
944 while (nwide--) {
945
946 puthn((uint32_t)(0xFF & *loc), 2, unit);
947 BIOS(B_PUTC, unit, ' ');
948
949 if (BIOS(B_RDAV, unit)) {
950
951 BIOS(B_GETC, unit);
952 return(TRUE);
953 }
954
955 if (loc EQ lastloc) {
956
957 dflag = TRUE;
958 return(FALSE);
959 }
960
961 ++loc;
962 }
963
964
965 return(FALSE);
966}
967
968/*
969 ============================================================================
970 padr -- print dump address
971 ============================================================================
972*/
973
974void padr(void *adr, int16_t unit)
975{
976 puthn((uint32_t)adr, 8, unit);
977 BIOS(B_PUTC, unit, ' ');
978 BIOS(B_PUTC, unit, '-');
979 BIOS(B_PUTC, unit, ' ');
980}
981
982/*
983 ============================================================================
984 dtext -- do the text portion of a dump
985 ============================================================================
986*/
987
988int16_t dtext(int8_t *loc, int8_t *lastloc, int16_t nwide, int16_t unit)
989{
990 register int16_t c;
991
992 BIOS(B_PUTC, unit, ' ');
993 BIOS(B_PUTC, unit, '|');
994
995 while (nwide--) {
996
997 c = 0xFF & *loc;
998
999 if (isascii(c) AND isprint(c))
1000 BIOS(B_PUTC, unit, c);
1001 else
1002 BIOS(B_PUTC, unit, '.');
1003
1004 if (BIOS(B_RDAV, unit)) {
1005
1006 BIOS(B_GETC, unit);
1007 BIOS(B_PUTC, unit, '|');
1008 return(TRUE);
1009 }
1010
1011 if (loc EQ lastloc) {
1012
1013 BIOS(B_PUTC, unit, '|');
1014 return(FALSE);
1015 }
1016
1017 ++loc;
1018 }
1019
1020 BIOS(B_PUTC, unit, '|');
1021 return(FALSE);
1022}
1023
1024/*
1025 ============================================================================
1026 cp_mset -- parse parameters for mset command
1027 ============================================================================
1028*/
1029
1030int16_t cp_mset(void)
1031{
1032 redo = FALSE;
1033
1034 if (0 EQ getarg())
1035 return(FALSE);
1036
1037 if (argsep NE ',')
1038 return(FALSE);
1039
1040 if (setp(&p_from, p_from) EQ FALSE)
1041 return(FALSE);
1042
1043 return(TRUE);
1044}
1045
1046/*
1047 ============================================================================
1048 cx_mset -- execute the mset command
1049 ============================================================================
1050*/
1051
1052int16_t cx_mset(void)
1053{
1054 while (TRUE) {
1055
1056 if (getarg())
1057 if (setvar(&p_value, p_value) EQ FALSE)
1058 return(FALSE);
1059
1060 if (p_value & ~0xFFL)
1061 return(FALSE);
1062
1063 *p_from++ = (int8_t)(0xFF & p_value);
1064
1065 if (argsep EQ A_CR)
1066 return(TRUE);
1067 }
1068}
1069
1070/*
1071 ============================================================================
1072 cp_wset -- parse parameters for wset command
1073 ============================================================================
1074*/
1075
1076int16_t cp_wset(void)
1077{
1078 redo = FALSE;
1079
1080 if (0 EQ getarg())
1081 return(FALSE);
1082
1083 if (argsep NE ',')
1084 return(FALSE);
1085
1086 if (setp(&p_from, p_from) EQ FALSE)
1087 return(FALSE);
1088
1089 if ((int32_t)p_from & 1L)
1090 return(FALSE);
1091
1092 return(TRUE);
1093}
1094
1095/*
1096 ============================================================================
1097 cx_wset -- execute the wset command
1098 ============================================================================
1099*/
1100
1101int16_t cx_wset(void)
1102{
1103 uint16_t *p_uint;
1104
1105 p_uint = (uint16_t *)p_from;
1106
1107 while (TRUE) {
1108
1109 if (getarg())
1110 if (setvar(&p_value, p_value) EQ FALSE)
1111 return(FALSE);
1112
1113 if (p_value & ~0xFFFFL)
1114 return(FALSE);
1115
1116 *p_uint++ = (uint16_t)(0xFFFF & p_value);
1117
1118 if (argsep EQ A_CR)
1119 return(TRUE);
1120 }
1121}
1122
1123/*
1124 ============================================================================
1125 cp_mtst -- parse mtest command arguments
1126 ============================================================================
1127*/
1128
1129int16_t cp_mtst(void)
1130{
1131 inext = ilast;
1132
1133 if (argsep EQ A_CR OR argsep EQ '\0') {
1134
1135 p_from = (int8_t *)0x00000008L;
1136 p_to = (int8_t *)USER_RAM - 2L;
1137 return(TRUE);
1138 }
1139
1140 if (getarg())
1141 if (setp(&p_from, (int8_t *)USER_RAM) EQ FALSE)
1142 return(FALSE);
1143
1144 if (argsep NE ',')
1145 return(FALSE);
1146
1147 if (getarg())
1148 if (setp(&p_to, (int8_t *)RAM_TOP) EQ FALSE)
1149 return(FALSE);
1150
1151 if ((int32_t)p_from & 1L)
1152 return(FALSE);
1153
1154 if ((int32_t)p_to & 1L)
1155 return(FALSE);
1156
1157 if (p_from GT p_to)
1158 return(FALSE);
1159
1160 return(TRUE);
1161}
1162
1163/*
1164 ============================================================================
1165 cx_mtst -- execute the mtest command
1166 ============================================================================
1167*/
1168
1169int16_t cx_mtst(void)
1170{
1171 register int16_t mask, was, *loc, *eloc, *oldloc;
1172
1173 mask = 0x0001;
1174 loc = (int16_t *)p_from;
1175 eloc = (int16_t *)p_to;
1176 oldloc = loc;
1177
1178 if (p_from LT (int8_t *)USER_RAM)
1179 setipl(7);
1180
1181 do {
1182
1183 while (mask) {
1184
1185 *loc = mask;
1186
1187 if (mask NE (was = *loc)) {
1188 if (p_from LT (int8_t *)USER_RAM)
1189 halt();
1190 else
1191 printf("%08lX was %04X, expected %04X\r\n",
1192 loc, was, mask);
1193 }
1194
1195 *loc = ~mask;
1196
1197 if (~mask NE (was = *loc)) {
1198 if (p_from LT (int8_t *)USER_RAM)
1199 halt();
1200 else
1201 printf("%08lX was %04X, expected %04X\r\n",
1202 loc, was, ~mask);
1203 }
1204
1205 mask <<= 1;
1206 }
1207
1208 mask = 0x0001;
1209 loc++;
1210
1211 } while (loc LE eloc);
1212
1213 if (oldloc LT (int16_t *)USER_RAM)
1214 rjumpto((void *)ROMADDR);
1215
1216 return(TRUE);
1217}
1218
1219/*
1220 ============================================================================
1221 cp_go -- parse parameters for go command
1222 ============================================================================
1223*/
1224
1225int16_t cp_go(void)
1226{
1227 redo = FALSE;
1228 b0flag = FALSE;
1229 b1flag = FALSE;
1230 goflag = FALSE;
1231
1232 if (getarg()) {
1233
1234 if (setvar(&p_goto, p_goto) EQ FALSE)
1235 return(FALSE);
1236
1237 if (1L & p_goto)
1238 return(FALSE);
1239
1240 goflag = TRUE;
1241
1242 }
1243
1244 if (getarg()) {
1245
1246 if (setp(&tba0, NULL) EQ FALSE)
1247 return(FALSE);
1248
1249 if (1L & (int32_t)tba0)
1250 return(FALSE);
1251
1252 b0flag = TRUE;
1253 }
1254
1255 if (getarg()) {
1256
1257 if (setp(&tba1, NULL) EQ FALSE)
1258 return(FALSE);
1259
1260 if (1L & (int32_t)tba1)
1261 return(FALSE);
1262
1263 b1flag = TRUE;
1264 }
1265
1266 return(TRUE);
1267}
1268
1269#if ON_B700
1270
1271/*
1272 ============================================================================
1273 cx_dini() -- execute the dinit command
1274 ============================================================================
1275*/
1276
1277int16_t cx_dini(void)
1278{
1279 redo = TRUE;
1280 hdvini();
1281 return(TRUE);
1282}
1283
1284#endif
1285
1286/*
1287 ============================================================================
1288 cx_zap -- execute the zap command
1289 ============================================================================
1290*/
1291
1292int16_t cx_zap(void)
1293{
1294 register int16_t *p, *q;
1295
1296 p = (int16_t *)USER_RAM;
1297 q = (int16_t *)RAM_TOP;
1298
1299 setipl(7);
1300
1301 while (p LE q)
1302 *p++ = 0;
1303
1304 rjumpto((void *)ROMADDR);
1305 return(TRUE); /* not reached */
1306}
1307
1308/*
1309 ============================================================================
1310 cx_omap() -- execute the omap command
1311 ============================================================================
1312*/
1313
1314int16_t cx_omap(void)
1315{
1316 register int16_t i, width, xloc;
1317
1318 printf("Pr B/C Locn Wd Xloc Flags\r\n");
1319
1320 for (i = 0; i < 16; i++) {
1321
1322 xloc = (int16_t)(v_odtab[i][1] & 0x03FF);
1323
1324 if (xloc & 0x0200) /* sign extend xloc */
1325 xloc = xloc - 0x400;
1326
1327 width = (int16_t)((v_odtab[i][1] >> 10) & 0x003F);
1328
1329 printf("%2d %s ",
1330 i, ((v_odtab[i][0] & V_CBS) ? "Chr" : "Bit"));
1331
1332 printf("$%08lX %2d %4d ",
1333 ((int32_t)v_odtab[i][2] << 1), width, xloc);
1334
1335 printf("$%04X\r\n", v_odtab[i][0]);
1336 }
1337
1338 return(TRUE);
1339}
1340
1341/*
1342 ============================================================================
1343 cx_help -- execute the help command
1344 ============================================================================
1345*/
1346
1347int16_t cx_help(void)
1348{
1349 int16_t i, j;
1350
1351 j = 0;
1352
1353 writeln(cmdunit, CRLF);
1354
1355 for (i = 0; i < (int16_t)NCMDS; i++) {
1356
1357 if (j++ EQ 22) {
1358
1359 j = 0;
1360
1361 if (waitcr2())
1362 return(TRUE);
1363 }
1364
1365 writeln(cmdunit, " ");
1366 writeln(cmdunit, cmtab[i].cname);
1367 writeln(cmdunit, " ");
1368 writeln(cmdunit, cmtab[i].hstr);
1369 writeln(cmdunit, CRLF);
1370 }
1371
1372 writeln(cmdunit, CRLF);
1373 return(TRUE);
1374}
1375
1376/*
1377 ============================================================================
1378 cx_bpb -- execute bpb command
1379 ============================================================================
1380*/
1381
1382int16_t cx_bpb(void)
1383{
1384 register struct bpb *bpp;
1385
1386 if (0L EQ (bpp = (struct bpb *)BIOS(B_GBPB, 0) ) ) {
1387
1388 writeln(cmdunit, "\r\n\nERROR -- Unable to read BPB\r\n\n");
1389 return(FALSE);
1390
1391 } else {
1392
1393 writeln(cmdunit, "\r\n\nBPB values:\r\n");
1394 writeln(cmdunit, "\r\n recsiz ");
1395 putn((uint32_t)bpp->recsiz, 5, cmdunit);
1396 writeln(cmdunit, "\r\n clsiz ");
1397 putn((uint32_t)bpp->clsiz, 4, cmdunit);
1398 writeln(cmdunit, "\r\n clsizb ");
1399 putn((uint32_t)bpp->clsizb, 5, cmdunit);
1400 writeln(cmdunit, "\r\n rdlen ");
1401 putn((uint32_t)bpp->rdlen, 4, cmdunit);
1402 writeln(cmdunit, "\r\n fsiz ");
1403 putn((uint32_t)bpp->fsiz, 4, cmdunit);
1404 writeln(cmdunit, "\r\n fatrec ");
1405 putn((uint32_t)bpp->fatrec, 5, cmdunit);
1406 writeln(cmdunit, "\r\n datrec ");
1407 putn((uint32_t)bpp->datrec, 5, cmdunit);
1408 writeln(cmdunit, "\r\n numcl ");
1409 putn((uint32_t)bpp->numcl, 5, cmdunit);
1410 writeln(cmdunit, "\r\n bflags ");
1411 puthn((uint32_t)bpp->bflags, 4, cmdunit);
1412 writeln(cmdunit, "\r\n ntracks ");
1413 putn((uint32_t)bpp->ntracks, 4, cmdunit);
1414 writeln(cmdunit, "\r\n nsides ");
1415 putn((uint32_t)bpp->nsides, 4, cmdunit);
1416 writeln(cmdunit, "\r\n sec/cyl ");
1417 putn((uint32_t)bpp->dspc, 5, cmdunit);
1418 writeln(cmdunit, "\r\n sec/trk ");
1419 putn((uint32_t)bpp->dspt, 5, cmdunit);
1420 writeln(cmdunit, "\r\n hidden ");
1421 putn((uint32_t)bpp->hidden, 4, cmdunit);
1422 writeln(cmdunit, "\r\n\n");
1423 return(TRUE);
1424 }
1425}
1426
1427/*
1428 ============================================================================
1429 cx_go -- execute the go command
1430 ============================================================================
1431*/
1432
1433int16_t cx_go(void)
1434{
1435 redo = FALSE;
1436 exflag = TRUE;
1437 wzcrsh = FALSE;
1438
1439 if (goflag)
1440 regptr->reg_pc = (uint32_t)p_goto;
1441
1442 if (b0flag ) {
1443
1444 if (p_ba0) {
1445
1446 if (*p_ba0 NE (uint16_t)BPINST) {
1447
1448 writeln(cmdunit, "\r\n\n** Breakpoint 0 at ");
1449 puthn((uint32_t)p_ba0, 8, cmdunit);
1450 writeln(cmdunit, " was ");
1451 puthn(0xFFFFL & (uint32_t)(*p_ba0), 4, cmdunit);
1452 writeln(cmdunit, " instead of ");
1453 puthn(0xFFFFL & (uint32_t)BPINST, 4, cmdunit);
1454 writeln(cmdunit, " **\r\n\n");
1455 }
1456
1457 *p_ba0 = p_bv0;
1458 }
1459
1460 p_ba0 = tba0;
1461 p_bv0 = *p_ba0;
1462 *p_ba0 = (uint16_t)BPINST;
1463 }
1464
1465 if (b1flag ) {
1466
1467 if (p_ba1) {
1468
1469 if (*p_ba1 NE (uint16_t)BPINST) {
1470
1471 writeln(cmdunit, "\r\n\n** Breakpoint 1 at ");
1472 puthn((uint32_t)p_ba1, 8, cmdunit);
1473 writeln(cmdunit, " was ");
1474 puthn(0xFFFFL & (uint32_t)(*p_ba1), 4, cmdunit);
1475 writeln(cmdunit, " instead of ");
1476 puthn(0xFFFFL & (uint32_t)BPINST, 4, cmdunit);
1477 writeln(cmdunit, " **\r\n\n");
1478 }
1479
1480 *p_ba1 = p_bv1;
1481 }
1482
1483 p_ba1 = tba1;
1484 p_bv1 = *p_ba1;
1485 *p_ba1 = (uint16_t)BPINST;
1486 }
1487
1488 return(TRUE);
1489}
1490
1491/*
1492 ============================================================================
1493 cp_dump -- parse dump parameters
1494 ============================================================================
1495*/
1496
1497int16_t cp_dump(void)
1498{
1499 inext = ilast;
1500
1501 if (getarg())
1502 if (setp(&p_from, p_from) EQ FALSE) {
1503
1504 redo = FALSE;
1505 return(FALSE);
1506 }
1507
1508 if (argsep EQ A_CR OR argsep EQ '\0') {
1509
1510 p_to = p_from;
1511 p_width = 16L;
1512 redo = TRUE;
1513 return(TRUE);
1514 }
1515
1516 if (getarg())
1517 if (setp(&p_to, p_to) EQ FALSE) {
1518
1519 redo = FALSE;
1520 return(FALSE);
1521 }
1522
1523 if (argsep EQ A_CR OR argsep EQ '\0') {
1524
1525 p_width = 16L;
1526 redo = TRUE;
1527 return(TRUE);
1528 }
1529
1530 if (getarg())
1531 if (setvar(&p_width, p_width) EQ FALSE) {
1532
1533 redo = FALSE;
1534 return(FALSE);
1535 }
1536
1537 if ((p_width LE 0L) OR (p_width GT 16L)) {
1538
1539 p_width = 16L;
1540 redo = FALSE;
1541 return(FALSE);
1542 }
1543
1544 redo = TRUE;
1545 return(TRUE);
1546}
1547
1548/*
1549 ============================================================================
1550 cp_fill -- parse parameters for fill command
1551 ============================================================================
1552*/
1553
1554int16_t cp_fill(void)
1555{
1556 redo = FALSE;
1557
1558 if (getarg())
1559 if (setp(&p_from, p_from) EQ FALSE)
1560 return(FALSE);
1561
1562 if (getarg())
1563 if (setvar(&p_len, p_len) EQ FALSE)
1564 return(FALSE);
1565
1566 if (getarg())
1567 if (setvar(&p_value, p_value) EQ FALSE)
1568 return(FALSE);
1569
1570 if (p_value & ~0xFFL)
1571 return(FALSE);
1572
1573 return(TRUE);
1574}
1575
1576/*
1577 ============================================================================
1578 cp_wfil -- parse parameters for wfill command
1579 ============================================================================
1580*/
1581
1582int16_t cp_wfil(void)
1583{
1584 redo = FALSE;
1585
1586 if (getarg())
1587 if (setp(&p_from, p_from) EQ FALSE)
1588 return(FALSE);
1589
1590 if (getarg())
1591 if (setvar(&p_len, p_len) EQ FALSE)
1592 return(FALSE);
1593
1594 if (getarg())
1595 if (setvar(&p_value, p_value) EQ FALSE)
1596 return(FALSE);
1597
1598 if ((int32_t)p_from & 1L)
1599 return(FALSE);
1600
1601 if (p_value & ~0xFFFFL)
1602 return(FALSE);
1603
1604 return(TRUE);
1605}
1606
1607/*
1608 ============================================================================
1609 cp_copy -- parse parameters for copy command
1610 ============================================================================
1611*/
1612
1613int16_t cp_copy(void)
1614{
1615 redo = FALSE;
1616
1617 if (getarg())
1618 if (setp(&p_from, p_from) EQ FALSE)
1619 return(FALSE);
1620
1621 if (getarg())
1622 if (setp(&p_to, p_to) EQ FALSE)
1623 return(FALSE);
1624
1625 if (getarg())
1626 if (setvar(&p_len, p_len) EQ FALSE)
1627 return(FALSE);
1628
1629 return(TRUE);
1630}
1631
1632/*
1633 ============================================================================
1634 cp_chek -- parse parameters for chek command
1635 ============================================================================
1636*/
1637
1638int16_t cp_chek(void)
1639{
1640 redo = FALSE;
1641
1642 if (getarg())
1643 if (setp(&p_from, p_from) EQ FALSE)
1644 return(FALSE);
1645
1646 if (getarg())
1647 if (setp(&p_to, p_to) EQ FALSE)
1648 return(FALSE);
1649
1650 return(TRUE);
1651}
1652
1653/*
1654 ============================================================================
1655 cp_read -- parse parameters for read command
1656 ============================================================================
1657*/
1658
1659int16_t cp_read(void)
1660{
1661 redo = FALSE;
1662
1663 if (getarg())
1664 if (setp(&p_from, p_from) EQ FALSE)
1665 return(FALSE);
1666
1667 if (getarg())
1668 if (setp(&p_to, p_to) EQ FALSE)
1669 return(FALSE);
1670
1671 if (getarg())
1672 if (setvar(&p_len, p_len) EQ FALSE)
1673 return(FALSE);
1674
1675 if ((~0x7FFFL) & p_len)
1676 return(FALSE);
1677
1678 if ((~0xFFFFL) & (int32_t)p_from)
1679 return(FALSE);
1680
1681 return(TRUE);
1682}
1683
1684/*
1685 ============================================================================
1686 cp_null -- parse null parameter line
1687 ============================================================================
1688*/
1689
1690int16_t cp_null(void)
1691{
1692 return(TRUE);
1693}
1694
1695/*
1696 ============================================================================
1697 cp_rset -- parse rset command parameters
1698 ============================================================================
1699*/
1700
1701int16_t cp_rset(void)
1702{
1703 int16_t rc;
1704
1705 rc = 0;
1706 redo = FALSE;
1707
1708 if (0 EQ getarg())
1709 return(FALSE);
1710
1711 str2lc(argstr);
1712
1713 if (0 EQ (rc = strlcmp(argstr, rlist)))
1714 return(FALSE);
1715
1716 if (0 EQ getarg())
1717 return(FALSE);
1718
1719 if (FALSE EQ setvar(&p_value, 0L))
1720 return(FALSE);
1721
1722 rnum = rc;
1723 return(TRUE);
1724}
1725
1726
1727/*
1728 ============================================================================
1729 cx_chek -- process chek command
1730 ============================================================================
1731*/
1732
1733int16_t cx_chek(void)
1734{
1735 register int32_t csum;
1736 register int8_t *cp;
1737
1738 redo = FALSE;
1739 csum = 0L;
1740
1741 for (cp = p_from; cp LE p_to; cp++)
1742 csum += 0x000000FFL & *cp;
1743
1744 printf("Checksum = 0x%08lX\r\n", csum);
1745
1746 return(TRUE);
1747}
1748
1749/*
1750 ============================================================================
1751 cx_rset -- process rset command
1752 ============================================================================
1753*/
1754
1755int16_t cx_rset(void)
1756{
1757 redo = FALSE;
1758
1759 if (rnum < 1)
1760 return(FALSE);
1761
1762 if (rnum < 9) { /* d0..d7 -- data register */
1763
1764 regptr->d_reg[rnum-1] = (uint32_t)p_value;
1765 return(TRUE);
1766 }
1767
1768 if (rnum < 17) { /* a0..a7 -- address register */
1769
1770 regptr->a_reg[rnum-9] = (uint32_t)p_value;
1771 return(TRUE);
1772 }
1773
1774 if (rnum EQ 17) { /* sr -- status register */
1775
1776 if ((~0xFFFFL) & p_value)
1777 return(FALSE);
1778
1779 regptr->reg_sr = (uint16_t)p_value;
1780 return(TRUE);
1781 }
1782
1783 if (rnum EQ 18) { /* pc -- program counter */
1784
1785 if (1L & p_value)
1786 return(FALSE);
1787
1788 regptr->reg_pc = (uint32_t)p_value;
1789 return(TRUE);
1790 }
1791
1792 if (rnum EQ 19) { /* sp -- stack pointer */
1793
1794 if (1L & p_value)
1795 return(FALSE);
1796
1797 regptr->a_reg[7] = (uint32_t)p_value;
1798 return(TRUE);
1799 }
1800
1801 return(FALSE);
1802}
1803
1804/*
1805 ============================================================================
1806 cp_vrst -- parse vrset command parameters
1807 ============================================================================
1808*/
1809
1810int16_t cp_vrst(void)
1811{
1812 int16_t rc;
1813
1814 rc = 0;
1815 redo = FALSE;
1816
1817 if (0 EQ getarg())
1818 return(FALSE);
1819
1820 str2lc(argstr);
1821
1822 if (0 EQ (rc = strlcmp(argstr, vrlist)))
1823 return(FALSE);
1824
1825 if (0 EQ getarg())
1826 return(FALSE);
1827
1828 if (FALSE EQ setvar(&p_value, 0L))
1829 return(FALSE);
1830
1831 if (vrnum < 17) { /* complete register */
1832
1833 vrnum = rc;
1834 return(TRUE);
1835 }
1836
1837 if (vrnum < 21) { /* horizontal register */
1838
1839 if (p_value & ~0x003F)
1840 return(FALSE);
1841
1842 vrnum = rc;
1843 return(TRUE);
1844 }
1845
1846 if (vrnum < 25) { /* vertical register */
1847
1848 if (p_value & ~0x03FF)
1849 return(FALSE);
1850
1851 vrnum = rc;
1852 return(TRUE);
1853 }
1854
1855 return(FALSE);
1856}
1857
1858/*
1859 ============================================================================
1860 cx_vrst -- process vrset command
1861 ============================================================================
1862*/
1863
1864int16_t cx_vrst(void)
1865{
1866 redo = FALSE;
1867
1868 if (vrnum < 1)
1869 return(FALSE);
1870
1871 if (vrnum < 17) { /* 1..16 -- r0..r15 -- complete register */
1872
1873 v_regs[vrnum-1] = (uint16_t)p_value;
1874 return(TRUE);
1875 }
1876
1877 if (vrnum < 21) { /* 17..20 -- h0..h3 -- horizontal register */
1878
1879 v_regs[vrnum-5] = (v_regs[vrnum-5] & 0x03FF) |
1880 (((uint16_t)p_value << 10) & 0xFC00);
1881 return(TRUE);
1882 }
1883
1884 if (vrnum < 25) { /* 21..24 -- v0..v3 -- vertical register */
1885
1886 v_regs[vrnum-9] = (v_regs[vrnum-9] & 0xFC00) | (uint16_t)p_value;
1887 return(TRUE);
1888 }
1889
1890 return(FALSE);
1891}
1892
1893/*
1894 ============================================================================
1895 cx_vreg -- process vregs command
1896 ============================================================================
1897*/
1898
1899int16_t cx_vreg(void)
1900{
1901 int16_t i, j, k, l;
1902 volatile uint16_t *rp;
1903
1904 rp = &v_regs[0];
1905 l = 0;
1906
1907 for (i = 0; i < 2; i++) {
1908
1909 for (j = 0; j < 2; j++) {
1910
1911 for (k = 0; k < 4; k++) {
1912
1913 writeln(cmdunit, " ");
1914 putn((uint32_t)l++, 2, cmdunit);
1915 writeln(cmdunit, ":");
1916 puthn((uint32_t)*rp++, 4, cmdunit);
1917 }
1918
1919 writeln(cmdunit, " ");
1920 }
1921
1922 writeln(cmdunit, "\r\n");
1923 }
1924
1925 return(TRUE);
1926}
1927
1928/*
1929 ============================================================================
1930 do_srec -- load a Motorola S record
1931 ============================================================================
1932*/
1933
1934int16_t do_srec(int8_t *line)
1935{
1936 register int8_t *ldadr;
1937 register int16_t c, i, len;
1938 register uint16_t val, csum;
1939
1940 if ('S' NE (c = *line++))
1941 return(-1); /* error 1 = missing initial S */
1942
1943 switch (c = *line++) {
1944
1945 case '2':
1946
1947 csum = 0;
1948
1949 if (isxdigit(c = *line++))
1950 len = xdtoi(c);
1951 else
1952 return(-2); /* error 2 = bad length byte */
1953
1954 if (isxdigit(c = *line++))
1955 len = (len << 4) + xdtoi(c);
1956 else
1957 return(-2);
1958
1959 csum += (len & 0xFF);
1960 ldadr = (int8_t *)0;
1961 len -= 4;
1962
1963 for (i = 0; i < 3; i++) {
1964
1965 if (isxdigit(c = *line++))
1966 val = (uint16_t)xdtoi(c);
1967 else
1968 return(-3); /* error 3 = bad address byte */
1969
1970 if (isxdigit(c = *line++))
1971 val = (val << 4) + (uint16_t)xdtoi(c);
1972 else
1973 return(-3);
1974
1975 ldadr = (int8_t *)(((int32_t)ldadr << 8) + (int32_t)val);
1976 csum += (val & 0xFF);
1977 }
1978
1979 for (i = 0; i < len; i++) {
1980
1981 if (isxdigit(c = *line++))
1982 val = (uint16_t)xdtoi(c);
1983 else
1984 return(-4); /* error 4 = bad data byte */
1985
1986 if (isxdigit(c = *line++))
1987 val = (val << 4) + (uint16_t)xdtoi(c);
1988 else
1989 return(-4);
1990
1991 csum += (val & 0xFF);
1992 *ldadr = (int8_t)(val & 0xFF);
1993
1994 if ((*ldadr & 0xFF) NE (val & 0xFF))
1995 return(-5); /* error 5 = store failed */
1996
1997 ldadr++;
1998 }
1999
2000 csum = 0xFF & ~csum;
2001
2002 if (isxdigit(c = *line++))
2003 val = (uint16_t)xdtoi(c);
2004 else
2005 return(-6); /* error 6 = bad checksum byte */
2006
2007 if (isxdigit(c = *line++))
2008 val = (val << 4) + (uint16_t)xdtoi(c);
2009 else
2010 return(-6);
2011
2012 if (csum NE (val & 0xFF))
2013 return(-7); /* error 7 = bad checksum */
2014
2015 return(1);
2016
2017 case '9':
2018
2019 if (memcmpu(line, SREC9, 10) EQ 0)
2020 return(0);
2021 else
2022 return(-8); /* error 8 = bad end record */
2023
2024 default:
2025
2026 return(-9); /* error 9 = unknown s type */
2027 }
2028
2029 return(-10); /* error 10 = switch failed */
2030}
2031
2032/*
2033 ============================================================================
2034 cx_load -- process load command
2035 ============================================================================
2036*/
2037
2038int16_t cx_load(void)
2039{
2040 register int16_t rc;
2041
2042 do {
2043
2044 rc = getrln(cmdunit, MAXCMDLN, cmdline);
2045
2046 switch (rc) {
2047
2048 case A_CR:
2049
2050 rc = do_srec(cmdline);
2051
2052 if (rc LT 0) {
2053
2054 rc = -rc;
2055 writeln(cmdunit, NACK);
2056 writeln(cmdunit, "** Load error ");
2057 putn((uint32_t)rc, 3, cmdunit);
2058 writeln(cmdunit, " **\r\n\n");
2059 return(FALSE);
2060
2061 } else {
2062
2063 writeln(cmdunit, TACK);
2064 }
2065
2066 continue;
2067
2068 case CTL('X'):
2069
2070 rc = 1;
2071 writeln(cmdunit, TACK);
2072 continue;
2073
2074 default:
2075
2076 writeln(cmdunit, NACK);
2077 writeln(cmdunit, "** Load aborted on ");
2078 puthn((uint32_t)rc, 2, cmdunit);
2079 writeln(cmdunit, " **\r\n\n");
2080 return(FALSE);
2081 }
2082
2083 } while (rc);
2084
2085 return(TRUE);
2086}
2087
2088/*
2089 ============================================================================
2090 cx_fill -- execute the fill command
2091 ============================================================================
2092*/
2093
2094int16_t cx_fill(void)
2095{
2096 register int8_t *cp = p_from;
2097 register int32_t count;
2098
2099 redo = FALSE;
2100
2101 for (count = p_len; count > 0L; count--) {
2102
2103 *cp = (int8_t)(0xFFL & p_value);
2104
2105 if (*cp NE (int8_t)(0xFFL & p_value)) {
2106
2107 writeln(cmdunit, "\r\n** FILL failed at ");
2108 puthn((uint32_t)cp, 8, cmdunit);
2109 writeln(cmdunit, " **\r\n");
2110 return(FALSE);
2111 }
2112
2113 ++cp;
2114 }
2115
2116 return(TRUE);
2117}
2118
2119/*
2120 ============================================================================
2121 cx_wfill -- execute the wfill command
2122 ============================================================================
2123*/
2124
2125int16_t cx_wfil(void)
2126{
2127 register uint16_t *cp = (uint16_t *)p_from;
2128 register int32_t count;
2129
2130 redo = FALSE;
2131
2132 for (count = p_len; count > 0L; count--)
2133 *cp++ = (uint16_t)(0xFFFFL & p_value);
2134
2135 return(TRUE);
2136}
2137
2138/*
2139 ============================================================================
2140 cx_copy -- execute the copy command
2141 ============================================================================
2142*/
2143
2144int16_t cx_copy(void)
2145{
2146 register int8_t *from = p_from,
2147 *to = p_to;
2148 register int32_t count = p_len;
2149
2150 redo = FALSE;
2151
2152 if (to GT from) {
2153
2154 from = from + count;
2155 to = to + count;
2156
2157 while (count--) {
2158
2159 --from;
2160 --to;
2161 *to = *from;
2162
2163 if (*from NE *to) {
2164
2165 writeln(cmdunit, "\r\n** COPY failed from ");
2166 puthn((uint32_t)from, 8, cmdunit);
2167 writeln(cmdunit, " to ");
2168 puthn((uint32_t)to, 8, cmdunit);
2169 writeln(cmdunit, " with (from) = ");
2170 puthn((uint32_t)(*from), 2, cmdunit);
2171 writeln(cmdunit, " and (to) = ");
2172 puthn((uint32_t)(*to), 2, cmdunit);
2173 writeln(cmdunit, " **\r\n");
2174 return(FALSE);
2175 }
2176 }
2177
2178 } else {
2179
2180 while (count--) {
2181
2182 *to = *from;
2183
2184 if (*from NE *to) {
2185
2186 writeln(cmdunit, "\r\n** COPY failed from ");
2187 puthn((uint32_t)from, 8, cmdunit);
2188 writeln(cmdunit, " to ");
2189 puthn((uint32_t)to, 8, cmdunit);
2190 writeln(cmdunit, " with (from) = ");
2191 puthn((uint32_t)(*from), 2, cmdunit);
2192 writeln(cmdunit, " and (to) = ");
2193 puthn((uint32_t)(*to), 2, cmdunit);
2194 writeln(cmdunit, " **\r\n");
2195 return(FALSE);
2196 }
2197
2198 ++from;
2199 ++to;
2200 }
2201 }
2202
2203 return(TRUE);
2204}
2205
2206
2207/*
2208 ============================================================================
2209 cx_dump -- execute the dump command
2210 ============================================================================
2211*/
2212
2213int16_t cx_dump(void)
2214{
2215 register int16_t nw, rc;
2216
2217 redo= TRUE;
2218 d_cur = p_from;
2219 d_next = p_to + 1;
2220 d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
2221 nw = (int16_t)p_width;
2222 rc = TRUE;
2223
2224 do {
2225
2226 writeln(cmdunit, CRLF);
2227 padr(p_from, cmdunit);
2228
2229 dflag = FALSE;
2230
2231 if (ddump(p_from, p_to, nw, cmdunit))
2232 rc = FALSE;
2233
2234 if (rc)
2235 if (dtext(p_from, p_to, nw, cmdunit))
2236 rc = FALSE;
2237
2238 p_from = p_from + p_width;
2239
2240 if (dflag)
2241 rc = FALSE;
2242
2243 } while (rc);
2244
2245 p_from = d_cur;
2246
2247 writeln(cmdunit, CRLF);
2248 writeln(cmdunit, CRLF);
2249
2250 return(TRUE);
2251}
2252
2253/*
2254 ============================================================================
2255 wdump -- dump words in hex (no ASCII)
2256 ============================================================================
2257*/
2258
2259int16_t wdump(uint16_t *loc, uint16_t *lastloc, int16_t nwide, int16_t unit)
2260{
2261 while (nwide--) {
2262
2263 puthn((uint32_t)(0xFFFFL & *loc), 4, unit);
2264 BIOS(B_PUTC,unit, ' ');
2265
2266 if (BIOS(B_RDAV, unit))
2267 return(TRUE);
2268
2269 if (loc EQ lastloc) {
2270
2271 dflag = TRUE;
2272 return(FALSE);
2273 }
2274
2275 ++loc;
2276 }
2277
2278 return(FALSE);
2279}
2280
2281/*
2282 ============================================================================
2283 ldump -- dump longs in hex (no ASCII)
2284 ============================================================================
2285*/
2286
2287int16_t ldump(uint32_t *loc, uint32_t *lastloc, int16_t nwide, int16_t unit)
2288{
2289 while (nwide--) {
2290
2291 puthn(*loc, 8, unit);
2292 BIOS(B_PUTC,unit, ' ');
2293
2294 if (BIOS(B_RDAV, unit))
2295 return(TRUE);
2296
2297 if (loc EQ lastloc) {
2298
2299 dflag = TRUE;
2300 return(FALSE);
2301 }
2302
2303 ++loc;
2304 }
2305
2306 return(FALSE);
2307}
2308
2309/*
2310 ============================================================================
2311 cp_wdmp -- process parameters for wdump command
2312 ============================================================================
2313*/
2314
2315int16_t cp_wdmp(void)
2316{
2317 inext = ilast;
2318
2319 if (getarg())
2320 if (setp(&p_from, p_from) EQ FALSE) {
2321
2322 redo = FALSE;
2323 return(FALSE);
2324 }
2325
2326 if ((int32_t)p_from & 1L) {
2327
2328 redo = FALSE;
2329 return(FALSE);
2330 }
2331
2332 if (argsep EQ A_CR OR argsep EQ '\0') {
2333
2334 p_to = p_from;
2335 p_width = 8;
2336 redo = TRUE;
2337 return(TRUE);
2338 }
2339
2340 if (getarg())
2341 if (setp(&p_to, p_to) EQ FALSE) {
2342
2343 redo = FALSE;
2344 return(FALSE);
2345 }
2346
2347 if ((int32_t)p_to & 1L) {
2348
2349 redo = FALSE;
2350 return(FALSE);
2351 }
2352
2353 if (argsep EQ A_CR OR argsep EQ '\0') {
2354
2355 p_width = 8;
2356 redo = TRUE;
2357 return(TRUE);
2358 }
2359
2360 if (getarg())
2361 if (setvar(&p_width, p_width) EQ FALSE) {
2362
2363 redo = FALSE;
2364 return(FALSE);
2365 }
2366
2367 redo = TRUE;
2368 return(TRUE);
2369}
2370
2371/*
2372 ============================================================================
2373 cp_ldmp -- process parameters for ldump command
2374 ============================================================================
2375*/
2376
2377int16_t cp_ldmp(void)
2378{
2379 inext = ilast;
2380
2381 if (getarg())
2382 if (setp(&p_from, p_from) EQ FALSE) {
2383
2384 redo = FALSE;
2385 return(FALSE);
2386 }
2387
2388 if ((int32_t)p_from & 1L) {
2389
2390 redo = FALSE;
2391 return(FALSE);
2392 }
2393
2394 if (argsep EQ A_CR OR argsep EQ '\0') {
2395
2396 p_to = p_from;
2397 p_width = 4;
2398 redo = TRUE;
2399 return(TRUE);
2400 }
2401
2402 if (getarg())
2403 if (setp(&p_to, p_to) EQ FALSE) {
2404
2405 redo = FALSE;
2406 return(FALSE);
2407 }
2408
2409 if ((int32_t)p_to & 1L) {
2410
2411 redo = FALSE;
2412 return(FALSE);
2413 }
2414
2415 if (argsep EQ A_CR OR argsep EQ '\0') {
2416
2417 p_width = 4;
2418 redo = TRUE;
2419 return(TRUE);
2420 }
2421
2422 if (getarg())
2423 if (setvar(&p_width, p_width) EQ FALSE) {
2424
2425 redo = FALSE;
2426 return(FALSE);
2427 }
2428
2429 redo = TRUE;
2430 return(TRUE);
2431}
2432
2433/*
2434 ============================================================================
2435 cp_ilev -- parse the ipl command
2436 ============================================================================
2437*/
2438
2439int16_t cp_ilev(void)
2440{
2441 int32_t iplevl;
2442
2443 if (argsep EQ A_CR OR argsep EQ '\0')
2444 return(TRUE);
2445
2446 if (getarg())
2447 if (setvar(&iplevl, iplevl) EQ FALSE)
2448 return(FALSE);
2449
2450 if (iplevl GT 7)
2451 return(FALSE);
2452
2453 iplev = (int16_t)iplevl;
2454
2455 return(TRUE);
2456}
2457
2458/*
2459 ============================================================================
2460 cx_ilev -- execute ipl command
2461 ============================================================================
2462*/
2463
2464int16_t cx_ilev(void)
2465{
2466 if (-1 EQ setipl(iplev)) {
2467
2468 printf("ERROR -- Could not set IPL to %d\r\n", iplev);
2469 return(FALSE);
2470 } else
2471 printf("ROMP IPL now set to %d\r\n", iplev);
2472
2473 return(TRUE);
2474}
2475
2476/*
2477 ============================================================================
2478 cp_monc() -- parse the monc command
2479 ============================================================================
2480*/
2481
2482int16_t cp_monc(void)
2483{
2484 if (getarg())
2485 if (setp(&monptr, monptr) EQ FALSE)
2486 return(FALSE);
2487
2488 monsw = MON_C;
2489 redo = TRUE;
2490 return(TRUE);
2491}
2492
2493/*
2494 ============================================================================
2495 cp_mons() -- parse the mons command
2496 ============================================================================
2497*/
2498
2499int16_t cp_mons(void)
2500{
2501 if (getarg())
2502 if (setp(&monptr, monptr) EQ FALSE)
2503 return(FALSE);
2504
2505 monsw = MON_S;
2506 redo = TRUE;
2507 return(TRUE);
2508}
2509
2510/*
2511 ============================================================================
2512 cp_monl() -- parse the monl command
2513 ============================================================================
2514*/
2515
2516int16_t cp_monl(void)
2517{
2518 if (getarg())
2519 if (setp(&monptr, monptr) EQ FALSE)
2520 return(FALSE);
2521
2522 monsw = MON_L;
2523 redo = TRUE;
2524 return(TRUE);
2525}
2526
2527/*
2528 ============================================================================
2529 cx_mon() -- process the mon commands
2530 ============================================================================
2531*/
2532
2533int16_t cx_mon(void)
2534{
2535 register int8_t vc, vcc;
2536 register int16_t vs, vss, *vsp;
2537 register int32_t vl, vll, *vlp;
2538
2539 switch (monsw) {
2540
2541 case MON_C:
2542
2543 vc = (int8_t)(*monptr & 0x0FF);
2544 puthn((uint32_t)vc, 2, cmdunit);
2545 writeln(cmdunit, "\r\n");
2546
2547 while (!(0xFFFFL & BIOS(B_RDAV, CON_DEV))) {
2548
2549 vcc = (int8_t)(*monptr & 0x0FF);
2550
2551 if (vc NE vcc) {
2552
2553 vc = vcc;
2554 puthn((uint32_t)vc, 2, cmdunit);
2555 writeln(cmdunit, "\r\n");
2556 }
2557 }
2558
2559 BIOS(B_GETC, CON_DEV);
2560 return(TRUE);
2561
2562 case MON_S:
2563
2564 vsp = (int16_t *)monptr;
2565 vs = *vsp;
2566 puthn((uint32_t)vs, 4, cmdunit);
2567 writeln(cmdunit, "\r\n");
2568
2569 while (!(0xFFFFL & BIOS(B_RDAV, CON_DEV))) {
2570
2571 vss = *vsp;
2572
2573 if (vs NE vss) {
2574
2575 vs = vss;
2576 puthn((uint32_t)vs, 4, cmdunit);
2577 writeln(cmdunit, "\r\n");
2578 }
2579 }
2580
2581 BIOS(B_GETC, CON_DEV);
2582 return(TRUE);
2583
2584
2585 case MON_L:
2586
2587 vlp = (int32_t *)monptr;
2588 vl = *vlp;
2589 puthn((uint32_t)vl, 8, cmdunit);
2590 writeln(cmdunit, "\r\n");
2591
2592 while (!(0xFFFFL & BIOS(B_RDAV, CON_DEV))) {
2593
2594 vll = *vlp;
2595
2596 if (vl NE vll) {
2597
2598 vl = vll;
2599 puthn((uint32_t)vl, 8, cmdunit);
2600 writeln(cmdunit, "\r\n");
2601 }
2602 }
2603
2604 BIOS(B_GETC, CON_DEV);
2605 return(TRUE);
2606
2607 default:
2608 return(FALSE);
2609 }
2610}
2611
2612
2613/*
2614 ============================================================================
2615 cx_wdmp -- process wdump command
2616 ============================================================================
2617*/
2618
2619int16_t cx_wdmp(void)
2620{
2621 int16_t nw, rc;
2622
2623 d_cur = p_from;
2624 d_next = p_to + 2;
2625 d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
2626 nw = (int16_t)p_width;
2627 rc = TRUE;
2628
2629 do {
2630
2631 writeln(cmdunit, CRLF);
2632 padr(p_from, cmdunit);
2633 dflag = FALSE;
2634
2635 if (wdump((uint16_t *)p_from, (uint16_t *)p_to, nw, cmdunit))
2636 rc = FALSE;
2637
2638 p_from = p_from + (p_width << 1);
2639
2640 if (dflag)
2641 rc = FALSE;
2642
2643 } while (rc);
2644
2645 p_from = d_cur;
2646
2647 writeln(cmdunit, CRLF);
2648 writeln(cmdunit, CRLF);
2649 return(TRUE);
2650}
2651
2652/*
2653 ============================================================================
2654 cx_ldmp -- process ldump command
2655 ============================================================================
2656*/
2657
2658int16_t cx_ldmp(void)
2659{
2660 int16_t nw, rc;
2661
2662 d_cur = p_from;
2663 d_next = p_to + 4;
2664 d_last = ((int32_t)p_to - (int32_t)p_from) + d_next;
2665 nw = (int16_t)p_width;
2666 rc = TRUE;
2667
2668 do {
2669
2670 writeln(cmdunit, CRLF);
2671 padr(p_from, cmdunit);
2672 dflag = FALSE;
2673
2674 if (ldump((uint32_t *)p_from, (uint32_t *)p_to, nw, cmdunit))
2675 rc = FALSE;
2676
2677 p_from = p_from + (p_width << 2);
2678
2679 if (dflag)
2680 rc = FALSE;
2681
2682 } while (rc);
2683
2684 p_from = d_cur;
2685
2686 writeln(cmdunit, CRLF);
2687 writeln(cmdunit, CRLF);
2688 return(TRUE);
2689}
2690
2691/*
2692 ============================================================================
2693 do_cmd -- process a command line
2694 ============================================================================
2695*/
2696
2697void do_cmd(void)
2698{
2699 int16_t rc, i;
2700
2701 /* prompt for a command line */
2702
2703#if TINYMSG
2704 writeln(cmdunit, "R: ");
2705#else
2706 writeln(cmdunit, "ROMP: ");
2707#endif
2708
2709 /* get a command line */
2710
2711 rc = getln(cmdunit, MAXCMDLN, cmdline);
2712
2713 /* dispatch based on rc */
2714
2715 switch (rc) {
2716
2717 case A_CR:
2718
2719 writeln(cmdunit, CRLF);
2720
2721 if (getcmd()) {
2722
2723 for (i = 0; i < (int16_t)NCMDS; i++) {
2724
2725 if (0 EQ strcmp(argstr, cmtab[i].cname)) {
2726
2727 ilast = i;
2728
2729 if ((*cmtab[i].cp)()) {
2730
2731 if (FALSE EQ (*cmtab[i].cx)())
2732 writeln(cmdunit, EMSG1);
2733
2734 } else {
2735
2736 writeln(cmdunit, EMSG2);
2737 }
2738
2739 return;
2740 }
2741 }
2742
2743 writeln(cmdunit, EMSG3);
2744 return;
2745
2746 } else {
2747
2748 if (redo) {
2749
2750 if (FALSE EQ (*cmtab[ilast].cx)())
2751 writeln(cmdunit, EMSG1);
2752
2753 } else {
2754
2755 writeln(cmdunit, EMSG5);
2756 }
2757
2758 return;
2759 }
2760
2761 case CTL('X'):
2762
2763 writeln(cmdunit, CANNED);
2764 return;
2765
2766 default:
2767
2768 writeln(cmdunit, EMSG6);
2769 return;
2770 }
2771
2772 writeln(cmdunit, EMSG7);
2773 return;
2774}
2775
2776/*
2777 ============================================================================
2778 cx_next -- process the next command
2779 ============================================================================
2780*/
2781
2782int16_t cx_next(void)
2783{
2784 p_to = d_last;
2785 p_from = d_next;
2786 return((*cmtab[inext].cx)());
2787}
2788
2789/*
2790 ============================================================================
2791 cx_read() -- process the read command
2792 ============================================================================
2793*/
2794
2795int16_t cx_read(void)
2796{
2797 int32_t rc;
2798 int16_t ns, recno;
2799
2800 ns = p_len & 0x7FFFL;
2801 recno = (int16_t)((int32_t)p_from & 0xFFFFL);
2802
2803 rc = BIOS(B_RDWR, 2, p_to, ns, recno, 0);
2804
2805 if (rc & 0xFFFFL) {
2806
2807 writeln(cmdunit, "\r\nERROR reading disk: ");
2808 puthn((uint32_t)rc, 8, cmdunit);
2809 writeln(cmdunit, "\r\n\n");
2810 return(FALSE);
2811
2812 } else {
2813
2814 return(TRUE);
2815 }
2816}
2817
2818/*
2819 ============================================================================
2820 cx_writ() -- process the write command
2821 ============================================================================
2822*/
2823
2824int16_t cx_writ(void)
2825{
2826 int32_t rc;
2827 int16_t ns, recno;
2828
2829 ns = p_len & 0x7FFFL;
2830 recno = (int16_t)((int32_t)p_from & 0xFFFFL);
2831
2832 rc = BIOS(B_RDWR, 3, p_to, ns, recno, 0);
2833
2834 if (rc & 0xFFFFL) {
2835
2836 writeln(cmdunit, "\r\nERROR writing disk: ");
2837 puthn((uint32_t)rc, 8, cmdunit);
2838 writeln(cmdunit, "\r\n\n");
2839 return(FALSE);
2840
2841 } else {
2842
2843 return(TRUE);
2844 }
2845}
2846
2847/*
2848 ============================================================================
2849 showrs() -- show registers
2850 ============================================================================
2851*/
2852
2853void showrs(struct regs *rp)
2854{
2855 int16_t i;
2856 uint16_t srtemp;
2857
2858 writeln(cmdunit, " ");
2859
2860 for (i = 0; i < 8; i++) {
2861
2862 BIOS(B_PUTC, cmdunit, ' ');
2863 BIOS(B_PUTC, cmdunit, '0'+i);
2864 writeln(cmdunit, "_______");
2865 }
2866
2867 writeln(cmdunit, "\r\nd0..d7 ");
2868
2869 for (i = 0; i < 8; i++) {
2870
2871 BIOS(B_PUTC, cmdunit, ' ');
2872 puthn(rp->d_reg[i], 8, cmdunit);
2873 }
2874
2875 writeln(cmdunit, "\r\na0..a7 ");
2876
2877 for (i = 0; i < 8; i++) {
2878
2879 BIOS(B_PUTC, cmdunit, ' ');
2880 puthn(rp->a_reg[i], 8, cmdunit);
2881 }
2882
2883 writeln(cmdunit, "\r\nPC = ");
2884 puthn((uint32_t)rp->reg_pc, 8, cmdunit);
2885
2886 srtemp = rp->reg_sr;
2887 writeln(cmdunit, ", SR = ");
2888 puthn((uint32_t)srtemp & 0xFFFFL, 4, cmdunit);
2889
2890 writeln(cmdunit, " (IPL = ");
2891 puthn((uint32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
2892 writeln(cmdunit, ", ");
2893
2894 if (srtemp & 0x8000)
2895 BIOS(B_PUTC, cmdunit, 'T');
2896 else
2897 BIOS(B_PUTC, cmdunit, '-');
2898
2899 if (srtemp & 0x2000)
2900 BIOS(B_PUTC, cmdunit, 'S');
2901 else
2902 BIOS(B_PUTC, cmdunit, '-');
2903
2904 BIOS(B_PUTC, cmdunit, ' ');
2905
2906 if (srtemp & 0x10)
2907 BIOS(B_PUTC, cmdunit, 'X');
2908 else
2909 BIOS(B_PUTC, cmdunit, '-');
2910
2911 if (srtemp & 0x8)
2912 BIOS(B_PUTC, cmdunit, 'N');
2913 else
2914 BIOS(B_PUTC, cmdunit, '-');
2915
2916 if (srtemp & 0x4)
2917 BIOS(B_PUTC, cmdunit, 'Z');
2918 else
2919 BIOS(B_PUTC, cmdunit, '-');
2920
2921 if (srtemp & 0x2)
2922 BIOS(B_PUTC, cmdunit, 'V');
2923 else
2924 BIOS(B_PUTC, cmdunit, '-');
2925
2926 if (srtemp & 0x1)
2927 BIOS(B_PUTC, cmdunit, 'C');
2928 else
2929 BIOS(B_PUTC, cmdunit, '-');
2930
2931 writeln(cmdunit, " )\r\n");
2932}
2933
2934/*
2935 ============================================================================
2936 showcr() -- show crash registers
2937 ============================================================================
2938*/
2939
2940void showcr(void)
2941{
2942 register int16_t i;
2943 register int8_t *cause;
2944 register uint16_t srtemp;
2945
2946 writeln(cmdunit, "BIOS Crash Area Dump\r\n");
2947 writeln(cmdunit, " ");
2948
2949 for (i = 0; i < 8; i++) {
2950
2951 BIOS(B_PUTC, cmdunit, ' ');
2952 BIOS(B_PUTC, cmdunit, '0'+i);
2953 writeln(cmdunit, "_______");
2954 }
2955
2956 writeln(cmdunit, "\r\nd0..d7 ");
2957
2958 for (i = 0; i < 8; i++) {
2959
2960 BIOS(B_PUTC, cmdunit, ' ');
2961 puthn(crshrg[i], 8, cmdunit);
2962 }
2963
2964 writeln(cmdunit, "\r\na0..a7 ");
2965
2966 for (i = 8; i < 16; i++) {
2967
2968 BIOS(B_PUTC, cmdunit, ' ');
2969 puthn(crshrg[i], 8, cmdunit);
2970 }
2971
2972 writeln(cmdunit, "\r\n\nPC = ");
2973 puthn(crshpc, 8, cmdunit);
2974
2975 srtemp = crshsr;
2976 writeln(cmdunit, ", SR = ");
2977 puthn((uint32_t)srtemp & 0xFFFFL, 4, cmdunit);
2978
2979 writeln(cmdunit, " (IPL = ");
2980 puthn((uint32_t)(srtemp >> 8) & 0x7L, 1, cmdunit);
2981 writeln(cmdunit, ", ");
2982
2983 if (srtemp & 0x8000)
2984 BIOS(B_PUTC, cmdunit, 'T');
2985 else
2986 BIOS(B_PUTC, cmdunit, '-');
2987
2988 if (srtemp & 0x2000)
2989 BIOS(B_PUTC, cmdunit, 'S');
2990 else
2991 BIOS(B_PUTC, cmdunit, '-');
2992
2993 BIOS(B_PUTC, cmdunit, ' ');
2994
2995 if (srtemp & 0x10)
2996 BIOS(B_PUTC, cmdunit, 'X');
2997 else
2998 BIOS(B_PUTC, cmdunit, '-');
2999
3000 if (srtemp & 0x8)
3001 BIOS(B_PUTC, cmdunit, 'N');
3002 else
3003 BIOS(B_PUTC, cmdunit, '-');
3004
3005 if (srtemp & 0x4)
3006 BIOS(B_PUTC, cmdunit, 'Z');
3007 else
3008 BIOS(B_PUTC, cmdunit, '-');
3009
3010 if (srtemp & 0x2)
3011 BIOS(B_PUTC, cmdunit, 'V');
3012 else
3013 BIOS(B_PUTC, cmdunit, '-');
3014
3015 if (srtemp & 0x1)
3016 BIOS(B_PUTC, cmdunit, 'C');
3017 else
3018 BIOS(B_PUTC, cmdunit, '-');
3019
3020 writeln(cmdunit, " )\r\n");
3021
3022
3023 writeln(cmdunit, "TRAP vector number = ");
3024 putn((uint32_t)crshvc[0], 2, cmdunit);
3025
3026 cause = " (no handler for interrupt)";
3027
3028 switch (crshvc[0] & 0xFF) {
3029
3030 case 2: /* 2: bus error */
3031
3032 cause = " (Bus error)";
3033 break;
3034
3035 case 3: /* 3: address error */
3036
3037 cause = " (Address error)";
3038 break;
3039
3040 case 4: /* 4: illegal instruction */
3041
3042 cause = " (Illegal instruction)";
3043 break;
3044
3045 case 5: /* 5: zero divide */
3046
3047 cause = " (Zero divide)";
3048 break;
3049
3050 case 6: /* 6: CHK instruction */
3051
3052 cause = " (CHK instruction)";
3053 break;
3054
3055 case 7: /* 7: TRAPV instruction */
3056
3057 cause = " (TRAPV instruction)";
3058 break;
3059
3060 case 8: /* 8: privilege violation */
3061
3062 cause = " (Privilege violation)";
3063 break;
3064
3065 case 9: /* 9: trace */
3066
3067 cause = " (Trace -- not implemented)";
3068 break;
3069
3070 case 10: /* 10: line 1010 emulator */
3071
3072 cause = " (Line 1010 Emulator -- not implemented)";
3073 break;
3074
3075 case 11: /* 11: line 1111 emulator */
3076
3077 cause = " (Line 1111 Emulator -- not implemented";
3078 break;
3079
3080 case 15: /* 15: uninitialized interrupt vector */
3081
3082 cause = " (Uninitialized interrupt)";
3083 break;
3084
3085 case 24: /* 24: spurious interrupt */
3086
3087 cause = " (Spurious interrupt)";
3088 break;
3089
3090 case 25: /* 25: Autovector Level 1*/
3091
3092 cause = " (Level 1 Interrupt -- unimplmented)";
3093 break;
3094
3095 case 26: /* 26: Autovector Level 2 */
3096
3097 cause = " (Level 2 Interrupt -- unimplmented)";
3098 break;
3099
3100 case 27: /* 27: Autovector Level 3 */
3101
3102 cause = " (Level 3 Interrupt -- unimplmented)";
3103 break;
3104
3105 case 28: /* 28: Autovector Level 4 */
3106
3107 cause = " (Level 4 Interrupt -- unimplmented)";
3108 break;
3109
3110 case 29: /* 29: Autovector Level 5 */
3111
3112 cause = " (Level 5 Interrupt -- unimplmented)";
3113 break;
3114
3115 case 30: /* 30: Autovector Level 6 */
3116
3117 cause = " (Level 6 Interrupt -- unimplmented)";
3118 break;
3119
3120 case 31: /* 31: Autovector Level 7 */
3121
3122 cause = " (Level 7 Interrupt -- unimplmented)";
3123 break;
3124
3125 }
3126
3127 writeln(cmdunit, cause);
3128 writeln(cmdunit, "\r\n");
3129}
3130
3131/*
3132 ============================================================================
3133 cx_crsh -- process the crash command
3134 ============================================================================
3135*/
3136
3137int16_t cx_crsh(void)
3138{
3139 if (!wzcrsh)
3140 printf("** Crash switch NOT set **\r\n");
3141
3142 redo = FALSE;
3143 showcr();
3144 return(TRUE);
3145}
3146
3147/*
3148 ============================================================================
3149 bphit -- clear breakpoints, see if any were hit
3150 ============================================================================
3151*/
3152
3153int16_t bphit(void)
3154{
3155 int16_t rc;
3156
3157 rc = FALSE;
3158
3159 if ((uint32_t)p_ba0 EQ regptr->reg_pc) {
3160
3161 if (*p_ba0 EQ BPINST) {
3162
3163 *p_ba0 = p_bv0;
3164 p_ba0 = 0L;
3165 p_bv0 = BPINST;
3166 rc = TRUE;
3167
3168 } else {
3169
3170 writeln(cmdunit, "** Breakpoint word at ");
3171 puthn((uint32_t)p_ba0, 8 , cmdunit);
3172 writeln(cmdunit, " was ");
3173 puthn(0xFFFFL & (uint32_t)(*p_ba0), 4, cmdunit);
3174 writeln(cmdunit, " instead of ");
3175 puthn((uint32_t)BPINST, 4, cmdunit);
3176 writeln(cmdunit, " **\r\n\n");
3177 rc = TRUE;
3178 }
3179 }
3180
3181 if ((uint32_t)p_ba1 EQ regptr->reg_pc) {
3182
3183 if (*p_ba1 EQ BPINST) {
3184
3185 *p_ba1 = p_bv1;
3186 p_ba1 = 0L;
3187 p_bv1 = BPINST;
3188 rc = TRUE;
3189
3190 } else {
3191
3192 writeln(cmdunit, "** Breakpoint word at ");
3193 puthn((uint32_t)p_ba0, 8 , cmdunit);
3194 writeln(cmdunit, " was ");
3195 puthn(0xFFFFL & (uint32_t)(*p_ba1), 4, cmdunit);
3196 writeln(cmdunit, " instead of ");
3197 puthn((uint32_t)BPINST, 4, cmdunit);
3198 writeln(cmdunit, " **\r\n\n");
3199 rc = TRUE;
3200 }
3201 }
3202
3203 if (p_ba0) {
3204
3205 if (*p_ba0 EQ BPINST) {
3206
3207 *p_ba0 = p_bv0;
3208 p_ba0 = 0L;
3209 p_bv0 = BPINST;
3210 rc = TRUE;
3211
3212 } else {
3213
3214 writeln(cmdunit, "** Breakpoint word at ");
3215 puthn((uint32_t)p_ba0, 8 , cmdunit);
3216 writeln(cmdunit, " was ");
3217 puthn(0xFFFFL & (uint32_t)(*p_ba0), 4, cmdunit);
3218 writeln(cmdunit, " instead of ");
3219 puthn((uint32_t)BPINST, 4, cmdunit);
3220 writeln(cmdunit, " **\r\n\n");
3221 rc = TRUE;
3222 }
3223 }
3224
3225 if (p_ba1) {
3226
3227 if (*p_ba1 EQ BPINST) {
3228
3229 *p_ba1 = p_bv1;
3230 p_ba1 = 0L;
3231 p_bv1 = BPINST;
3232 rc = TRUE;
3233
3234 } else {
3235
3236 writeln(cmdunit, "** Breakpoint word at ");
3237 puthn((uint32_t)p_ba0, 8 , cmdunit);
3238 writeln(cmdunit, " was ");
3239 puthn(0xFFFFL & (uint32_t)(*p_ba1), 4, cmdunit);
3240 writeln(cmdunit, " instead of ");
3241 puthn((uint32_t)BPINST, 4, cmdunit);
3242 writeln(cmdunit, " **\r\n\n");
3243 rc = TRUE;
3244 }
3245 }
3246
3247 if (rc)
3248 return(rc);
3249
3250 writeln(cmdunit, "\r\n** Program invoked ROMP trap **\r\n");
3251 return(FALSE);
3252}
3253
3254/*
3255 ============================================================================
3256 cx_regs() -- process the regs command
3257 ============================================================================
3258*/
3259
3260int16_t cx_regs(void)
3261{
3262 showrs(regptr);
3263 return(TRUE);
3264}
3265
3266/*
3267 ============================================================================
3268 rompbp() -- process a breakpoint for ROMP
3269 ============================================================================
3270*/
3271
3272void rompbp(uint32_t d0, ...)
3273{
3274 register int16_t i;
3275
3276 regptr = (struct regs *)&d0; /* make registers accessable */
3277 regptr->reg_pc -= 2L; /* adjust pc */
3278
3279 if (-1 EQ setipl(iplev)) /* enable interrupts */
3280 writeln(cmdunit, "\r\n\n***** setipl() failed *****\r\n\n");
3281
3282 if (first1) { /* initial entry from xtrap15() */
3283
3284 for (i = 0; i < 8; i++) /* clear d0..d7 */
3285 regptr->d_reg[i] = 0L;
3286
3287 for (i = 0; i < 7; i++) /* clear a0..a6 */
3288 regptr->a_reg[i] = 0L;
3289
3290 regptr->a_reg[7] = ISTACK; /* setup initial stack */
3291
3292 regptr->reg_sr = INITSR; /* setup sr */
3293 regptr->reg_pc += 2L; /* adjust pc past TRAP 15 */
3294
3295 } else { /* breakpoint */
3296
3297 writeln(cmdunit, "\r\n\n** ROMP Breakpoint TRAP **\r\n");
3298
3299 showrs(regptr); /* show registers */
3300
3301 if (bphit() EQ FALSE) /* fixup breakpoints */
3302 regptr->reg_pc += 2L; /* and maybe the pc */
3303
3304 }
3305
3306 first1 = FALSE; /* not first time any more */
3307 exflag = FALSE; /* clear exit flag */
3308
3309 do {
3310
3311 do_cmd(); /* process commands ... */
3312
3313 } while (!exflag); /* ... until exit flag is set */
3314
3315 return; /* return to xtrap15 */
3316}
3317
3318/*
3319 ============================================================================
3320 progid() -- identify the program
3321 ============================================================================
3322*/
3323
3324void progid(void)
3325{
3326 register int8_t *pcptr;
3327
3328#if TINYMSG
3329
3330#if ON_B700
3331 writeln(cmdunit, "\r\n\nB\r\n");
3332#else
3333 writeln(cmdunit, "\r\n\nN\r\n");
3334#endif
3335
3336#else
3337
3338#if ON_B700
3339 writeln(cmdunit, "\r\n\nBuchla 700 BIOS / Debug PROM\r\n");
3340#else
3341 writeln(cmdunit, "\r\n\nNASA 3D Helmet Display BIOS / Debug PROM\r\n");
3342#endif
3343
3344 writeln(cmdunit, " ROMP Version ");
3345 writeln(cmdunit, ROMPVER);
3346
3347 writeln(cmdunit, "\r\n BIOS Version ");
3348 pcptr = (int8_t *)PRM_VERS;
3349 putn((uint32_t)*pcptr++, 2, cmdunit);
3350 BIOS(B_PUTC, cmdunit, '.');
3351 putn((uint32_t)*pcptr++, 2, cmdunit);
3352 writeln(cmdunit, promdate);
3353
3354#endif
3355}
3356
3357#if ON_B700
3358
3359
3360/*
3361 ============================================================================
3362 pclr() -- clear the panel FIFO
3363 ============================================================================
3364*/
3365
3366int16_t pclr(void)
3367{
3368 register int16_t i;
3369
3370 ftimer = FIFOLIM;
3371
3372 while (-1L NE (afi = XBIOS(X_ANALOG))) { /* check panel inputs */
3373
3374 asig = 0x007F & (afi >> 8); /* signal number */
3375
3376 if (0 EQ asig) {
3377
3378 /* all keys up */
3379
3380 for (i = 0; i < 128; i++) {
3381
3382 sigtab[i][0] = 0;
3383 sigtab[i][1] = 0;
3384 }
3385
3386 break;
3387 }
3388
3389 if (ftimer-- < 0)
3390 return(FAILURE);
3391 }
3392
3393 return(SUCCESS);
3394}
3395
3396/*
3397 ============================================================================
3398 pscan() -- scan the panel and maybe even load a program from diskette
3399 ============================================================================
3400*/
3401
3402int16_t pscan(void)
3403{
3404 register int16_t i, c;
3405
3406 if (0 EQ ledcntr--) {
3407
3408 if ((baseled + 3) > 23) /* turn on a LED */
3409 io_leds = (uint8_t)(baseled - 21);
3410 else
3411 io_leds = (uint8_t)(baseled + 3);
3412
3413 io_leds = (uint8_t)(0x80 + baseled); /* turn off a LED */
3414
3415 if (++baseled > 23) /* update LED number */
3416 baseled = 0;
3417
3418 ledcntr = 200;
3419 }
3420
3421 aflag = FALSE;
3422
3423 if (-1L NE (afi = XBIOS(X_ANALOG))) { /* check panel inputs */
3424
3425 asig = 0x007F & (afi >> 8); /* signal number */
3426 astat = 0x0001 & (afi >> 7); /* status */
3427 aval = 0x007F & afi; /* value */
3428
3429 if (asig) { /* active signal */
3430
3431 aflag = TRUE;
3432
3433 sigtab[asig][0] = aval;
3434 sigtab[asig][1] = astat;
3435
3436 } else { /* all keys up */
3437
3438 aflag = FALSE;
3439
3440 for (i = 0; i < 128; i++)
3441 sigtab[i][1] = 0;
3442 }
3443 }
3444
3445 if (aflag) { /* anything changed ? */
3446
3447 if (astat AND (asig EQ BOOTKEY)) { /* BOOT key */
3448
3449 for (i = 0; i < 24; i++) /* turn off LEDs */
3450 io_leds = (uint8_t)(0x80 + i);
3451
3452 io_leds = 0x1F; /* turn off LCD lamp */
3453
3454 /* load and run BOOTFILE */
3455
3456 B_log_s = FALSE;
3457 B_dbg_s = FALSE;
3458
3459 hdvini();
3460 _bpbin = FALSE;
3461
3462 if (booter(BOOTFILE, 0L))
3463 return(FALSE);
3464 else
3465 sjumpto((void *)B_buf_a, (void *)ISTACK);
3466
3467 } else if (astat AND (asig EQ ROMPKEY)) { /* ROMP key */
3468
3469 for (i = 0; i < 24; i++) /* turn off LEDs */
3470 io_leds = (uint8_t)(0x80 + i);
3471
3472 return(TRUE);
3473 }
3474 }
3475
3476 if (BIOS(B_RDAV, CON_DEV)) {
3477
3478 c = 0x007F & BIOS(B_GETC, CON_DEV);
3479
3480 if ((c EQ 'r') OR (c EQ 'R'))
3481 return(TRUE);
3482 }
3483
3484 return(FALSE);
3485}
3486#endif
3487
3488/*
3489 ============================================================================
3490 romp main routine
3491 ============================================================================
3492*/
3493
3494void main(void)
3495{
3496 register int16_t i;
3497 register int8_t *pdptr, *pcptr;
3498
3499 /* unpack PROM date */
3500
3501 pcptr = (int8_t *)PRM_DATE; /* prom date: yyyymmdd */
3502 pdptr = promdate; /* -- yyyy-mm-dd */
3503 *pdptr++ = ' ';
3504 *pdptr++ = '-';
3505 *pdptr++ = '-';
3506 *pdptr++ = ' ';
3507 *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
3508 *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
3509 *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
3510 *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
3511 *pdptr++ = '-';
3512 *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
3513 *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
3514 *pdptr++ = '-';
3515 *pdptr++ = (int8_t)(((*pcptr >> 4) & 0x0F) + '0');
3516 *pdptr++ = (int8_t)((*pcptr++ & 0x0F) + '0');
3517 *pdptr++ = '\0';
3518
3519 /* initialize variables */
3520
3521 sprintf(hs_mtst, "[[start=$%lX],[end=$%lx]] (or $8..$%lX)",
3522 USER_RAM, RAM_TOP, (USER_RAM - 2L));
3523
3524 cmdunit = CON_DEV;
3525
3526 ilast = 0;
3527 inext = 0;
3528 iplev = DEFIPL;
3529
3530 dflag = FALSE;
3531 exflag = FALSE;
3532 redo = FALSE;
3533 goflag = FALSE;
3534 b0flag = FALSE;
3535 b1flag = FALSE;
3536
3537 p_goto = ROMADDR;
3538 p_len = 0L;
3539 p_width = 16L;
3540 p_value = 0L;
3541
3542 p_ba0 = 0L;
3543 p_bv0 = BPINST;
3544
3545 p_ba1 = 0L;
3546 p_bv1 = BPINST;
3547
3548 tba0 = 0L;
3549 tba1 = 0L;
3550
3551 inext = 0;
3552
3553 tsetup(); /* patch the timer interrupt code */
3554
3555#if ON_B700
3556 baseled = 21; /* setup LED scan */
3557 ledcntr = 0; /* ... */
3558 io_leds = 0x9F; /* turn on LCD lamp */
3559 GLCinit(); /* reset LCD display */
3560
3561 GLCtext(0, 1, "Load GoTo");
3562 GLCtext(1, 1, "Disk ROMP");
3563
3564 GLCtext(3, 15, "Buchla 700 -- BIOS/ROMP Firmware by D.N. Lynx Crowe");
3565
3566 sprintf(idbuf, "BIOS Version %02d.%02d%s",
3567 *(int8_t *)PRM_VERS, *(int8_t *)(PRM_VERS+1), promdate);
3568 GLCtext(5, 30, idbuf);
3569
3570 sprintf(idbuf, "ROMP Version %s", ROMPVER);
3571 GLCtext(6, 30, idbuf);
3572 GLCcrc(0, 0);
3573
3574 BIOS(B_SETV, 47, trap15); /* set ROMP trap vec */
3575
3576 for (i = 0; i < 128; i++) {
3577
3578 sigtab[i][0] = 0;
3579 sigtab[i][1] = 0;
3580 }
3581
3582 XBIOS(X_CLRAFI); /* clear the panel FIFO */
3583 setipl(KB_EI); /* enable interrupts */
3584 pclr(); /* empty the panel FIFO */
3585 XBIOS(X_CLRAFI); /* clear the panel FIFO */
3586
3587 while (FALSE EQ pscan()) ; /* do the panel scan */
3588#endif
3589
3590
3591 if (setjmp(&restart)) /* setup restart point */
3592 writeln(cmdunit, "\r\n***** ROMP Re-starting *****\r\n\n");
3593
3594 tsetup(); /* patch the timer interrupt code */
3595 progid(); /* identify the program */
3596
3597 BIOS(B_SETV, 47, trap15); /* set ROMP trap vec */
3598 writeln(cmdunit, "\r\n\n");
3599
3600 /* process commands */
3601
3602 first1 = TRUE; /* set break init flag */
3603
3604 while (TRUE) {
3605
3606 xtrap15(); /* trap into ROMP bp processor */
3607 writeln(cmdunit, "\r\n** xtrap15() returned to ROMP **\r\n\n");
3608 }
3609}
3610
Note: See TracBrowser for help on using the repository browser.