]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - sim/erc32/erc32.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial creation of sourceware repository
[thirdparty/binutils-gdb.git] / sim / erc32 / erc32.c
1 /*
2 * This file is part of SIS.
3 *
4 * SIS, SPARC instruction simulator V2.5 Copyright (C) 1995 Jiri Gaisler,
5 * European Space Agency
6 *
7 * This program is free software; you can redistribute it and/or modify it under
8 * the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 675
19 * Mass Ave, Cambridge, MA 02139, USA.
20 *
21 */
22
23 /* The control space devices */
24
25 #include <sys/types.h>
26 #include <stdio.h>
27 #include <termios.h>
28 #include <sys/fcntl.h>
29 #include <sys/file.h>
30 #include <unistd.h>
31 #include "sis.h"
32 #include "end.h"
33 #include "sim-config.h"
34
35 extern int ctrl_c;
36 extern int32 sis_verbose;
37 extern int32 sparclite, sparclite_board;
38 extern int rom8,wrp,uben;
39 extern char uart_dev1[], uart_dev2[];
40
41 int dumbio = 0; /* normal, smart, terminal oriented IO by default */
42
43 /* MEC registers */
44 #define MEC_START 0x01f80000
45 #define MEC_END 0x01f80100
46
47 /* Memory exception waitstates */
48 #define MEM_EX_WS 1
49
50 /* ERC32 always adds one waitstate during RAM std */
51 #define STD_WS 1
52
53 #ifdef ERRINJ
54 extern int errmec;
55 #endif
56
57 /* The target's byte order is big-endian by default until we load a
58 little-endian program. */
59
60 int current_target_byte_order = BIG_ENDIAN;
61
62 #define MEC_WS 0 /* Waitstates per MEC access (0 ws) */
63 #define MOK 0
64
65 /* MEC register addresses */
66
67 #define MEC_MCR 0x000
68 #define MEC_SFR 0x004
69 #define MEC_PWDR 0x008
70 #define MEC_MEMCFG 0x010
71 #define MEC_IOCR 0x014
72 #define MEC_WCR 0x018
73
74 #define MEC_MAR0 0x020
75 #define MEC_MAR1 0x024
76
77 #define MEC_SSA1 0x020
78 #define MEC_SEA1 0x024
79 #define MEC_SSA2 0x028
80 #define MEC_SEA2 0x02C
81 #define MEC_ISR 0x044
82 #define MEC_IPR 0x048
83 #define MEC_IMR 0x04C
84 #define MEC_ICR 0x050
85 #define MEC_IFR 0x054
86 #define MEC_WDOG 0x060
87 #define MEC_TRAPD 0x064
88 #define MEC_RTC_COUNTER 0x080
89 #define MEC_RTC_RELOAD 0x080
90 #define MEC_RTC_SCALER 0x084
91 #define MEC_GPT_COUNTER 0x088
92 #define MEC_GPT_RELOAD 0x088
93 #define MEC_GPT_SCALER 0x08C
94 #define MEC_TIMER_CTRL 0x098
95 #define MEC_SFSR 0x0A0
96 #define MEC_FFAR 0x0A4
97 #define MEC_ERSR 0x0B0
98 #define MEC_DBG 0x0C0
99 #define MEC_TCR 0x0D0
100
101 #define MEC_BRK 0x0C4
102 #define MEC_WPR 0x0C8
103
104 #define MEC_UARTA 0x0E0
105 #define MEC_UARTB 0x0E4
106 #define MEC_UART_CTRL 0x0E8
107 #define SIM_LOAD 0x0F0
108
109 /* Memory exception causes */
110 #define PROT_EXC 0x3
111 #define UIMP_ACC 0x4
112 #define MEC_ACC 0x6
113 #define WATCH_EXC 0xa
114 #define BREAK_EXC 0xb
115
116 /* Size of UART buffers (bytes) */
117 #define UARTBUF 1024
118
119 /* Number of simulator ticks between flushing the UARTS. */
120 /* For good performance, keep above 1000 */
121 #define UART_FLUSH_TIME 3000
122
123 /* MEC timer control register bits */
124 #define TCR_GACR 1
125 #define TCR_GACL 2
126 #define TCR_GASE 4
127 #define TCR_GASL 8
128 #define TCR_TCRCR 0x100
129 #define TCR_TCRCL 0x200
130 #define TCR_TCRSE 0x400
131 #define TCR_TCRSL 0x800
132
133 /* New uart defines */
134 #define UART_TX_TIME 1000
135 #define UART_RX_TIME 1000
136 #define UARTA_DR 0x1
137 #define UARTA_SRE 0x2
138 #define UARTA_HRE 0x4
139 #define UARTA_OR 0x40
140 #define UARTA_CLR 0x80
141 #define UARTB_DR 0x10000
142 #define UARTB_SRE 0x20000
143 #define UARTB_HRE 0x40000
144 #define UARTB_OR 0x400000
145 #define UARTB_CLR 0x800000
146
147 #define UART_DR 0x100
148 #define UART_TSE 0x200
149 #define UART_THE 0x400
150
151 /* MEC registers */
152
153 static char fname[256];
154 static int32 find = 0;
155 static uint32 mec_ssa[2]; /* Write protection start address */
156 static uint32 mec_sea[2]; /* Write protection end address */
157 static uint32 mec_wpr[2]; /* Write protection control fields */
158 static uint32 mec_sfsr;
159 static uint32 mec_ffar;
160 static uint32 mec_ipr;
161 static uint32 mec_imr;
162 static uint32 mec_isr;
163 static uint32 mec_icr;
164 static uint32 mec_ifr;
165 static uint32 mec_mcr; /* MEC control register */
166 static uint32 mec_memcfg; /* Memory control register */
167 static uint32 mec_wcr; /* MEC waitstate register */
168 static uint32 mec_iocr; /* MEC IO control register */
169 static uint32 posted_irq;
170 static uint32 mec_ersr; /* MEC error and status register */
171 static uint32 mec_tcr; /* MEC test comtrol register */
172
173 static uint32 rtc_counter;
174 static uint32 rtc_reload;
175 static uint32 rtc_scaler;
176 static uint32 rtc_scaler_start;
177 static uint32 rtc_enabled;
178 static uint32 rtc_cr;
179 static uint32 rtc_se;
180
181 static uint32 gpt_counter;
182 static uint32 gpt_reload;
183 static uint32 gpt_scaler;
184 static uint32 gpt_scaler_start;
185 static uint32 gpt_enabled;
186 static uint32 gpt_cr;
187 static uint32 gpt_se;
188
189 static uint32 wdog_scaler;
190 static uint32 wdog_counter;
191 static uint32 wdog_rst_delay;
192 static uint32 wdog_rston;
193
194 enum wdog_type {
195 init, disabled, enabled, stopped
196 };
197
198 static enum wdog_type wdog_status;
199
200
201 /* ROM size 1024 Kbyte */
202 #define ROM_SZ 0x100000
203 #define ROM_MASK 0x0fffff
204
205 /* RAM size 4 Mbyte */
206 #define RAM_START 0x02000000
207 #define RAM_END 0x02400000
208 #define RAM_MASK 0x003fffff
209
210 /* SPARClite boards all seem to have RAM at the same place. */
211 #define RAM_START_SLITE 0x40000000
212 #define RAM_END_SLITE 0x40400000
213 #define RAM_MASK_SLITE 0x003fffff
214
215 /* Memory support variables */
216
217 static uint32 mem_ramr_ws; /* RAM read waitstates */
218 static uint32 mem_ramw_ws; /* RAM write waitstates */
219 static uint32 mem_romr_ws; /* ROM read waitstates */
220 static uint32 mem_romw_ws; /* ROM write waitstates */
221 static uint32 mem_ramstart; /* RAM start */
222 static uint32 mem_ramend; /* RAM end */
223 static uint32 mem_rammask; /* RAM address mask */
224 static uint32 mem_ramsz; /* RAM size */
225 static uint32 mem_romsz; /* ROM size */
226 static uint32 mem_accprot; /* RAM write protection enabled */
227 static uint32 mem_blockprot; /* RAM block write protection enabled */
228
229 static unsigned char romb[ROM_SZ];
230 static unsigned char ramb[RAM_END - RAM_START];
231
232
233 /* UART support variables */
234
235 static int32 fd1, fd2; /* file descriptor for input file */
236 static int32 Ucontrol; /* UART status register */
237 static unsigned char aq[UARTBUF], bq[UARTBUF];
238 static int32 anum, aind = 0;
239 static int32 bnum, bind = 0;
240 static char wbufa[UARTBUF], wbufb[UARTBUF];
241 static unsigned wnuma;
242 static unsigned wnumb;
243 static FILE *f1in, *f1out, *f2in, *f2out;
244 static struct termios ioc1, ioc2, iocold1, iocold2;
245 static int f1open = 0, f2open = 0;
246
247 static char uarta_sreg, uarta_hreg, uartb_sreg, uartb_hreg;
248 static uint32 uart_stat_reg;
249 static uint32 uarta_data, uartb_data;
250
251 #ifdef ERA
252 int era = 0;
253 int erareg;
254 #endif
255
256 /* Forward declarations */
257
258 static void decode_ersr PARAMS ((void));
259 #ifdef ERRINJ
260 static void iucomperr PARAMS ((void));
261 #endif
262 static void mecparerror PARAMS ((void));
263 static void decode_memcfg PARAMS ((void));
264 static void decode_wcr PARAMS ((void));
265 static void decode_mcr PARAMS ((void));
266 static void close_port PARAMS ((void));
267 static void mec_reset PARAMS ((void));
268 static void mec_intack PARAMS ((int32 level));
269 static void chk_irq PARAMS ((void));
270 static void mec_irq PARAMS ((int32 level));
271 static void set_sfsr PARAMS ((uint32 fault, uint32 addr,
272 uint32 asi, uint32 read));
273 static int32 mec_read PARAMS ((uint32 addr, uint32 asi, uint32 *data));
274 static int mec_write PARAMS ((uint32 addr, uint32 data));
275 static void port_init PARAMS ((void));
276 static uint32 read_uart PARAMS ((uint32 addr));
277 static void write_uart PARAMS ((uint32 addr, uint32 data));
278 static void flush_uart PARAMS ((void));
279 static void uarta_tx PARAMS ((void));
280 static void uartb_tx PARAMS ((void));
281 static void uart_rx PARAMS ((caddr_t arg));
282 static void uart_intr PARAMS ((caddr_t arg));
283 static void uart_irq_start PARAMS ((void));
284 static void wdog_intr PARAMS ((caddr_t arg));
285 static void wdog_start PARAMS ((void));
286 static void rtc_intr PARAMS ((caddr_t arg));
287 static void rtc_start PARAMS ((void));
288 static uint32 rtc_counter_read PARAMS ((void));
289 static void rtc_scaler_set PARAMS ((uint32 val));
290 static void rtc_reload_set PARAMS ((uint32 val));
291 static void gpt_intr PARAMS ((caddr_t arg));
292 static void gpt_start PARAMS ((void));
293 static uint32 gpt_counter_read PARAMS ((void));
294 static void gpt_scaler_set PARAMS ((uint32 val));
295 static void gpt_reload_set PARAMS ((uint32 val));
296 static void timer_ctrl PARAMS ((uint32 val));
297 static unsigned char *
298 get_mem_ptr PARAMS ((uint32 addr, uint32 size));
299
300 static void fetch_bytes PARAMS ((int asi, unsigned char *mem,
301 uint32 *data, int sz));
302
303 static void store_bytes PARAMS ((unsigned char *mem, uint32 *data, int sz));
304
305 extern int ext_irl;
306
307
308 /* One-time init */
309
310 void
311 init_sim()
312 {
313 port_init();
314 }
315
316 /* Power-on reset init */
317
318 void
319 reset()
320 {
321 mec_reset();
322 uart_irq_start();
323 wdog_start();
324 }
325
326 static void
327 decode_ersr()
328 {
329 if (mec_ersr & 0x01) {
330 if (!(mec_mcr & 0x20)) {
331 if (mec_mcr & 0x40) {
332 sys_reset();
333 mec_ersr = 0x8000;
334 if (sis_verbose)
335 printf("Error manager reset - IU in error mode\n");
336 } else {
337 sys_halt();
338 mec_ersr |= 0x2000;
339 if (sis_verbose)
340 printf("Error manager halt - IU in error mode\n");
341 }
342 } else
343 mec_irq(1);
344 }
345 if (mec_ersr & 0x04) {
346 if (!(mec_mcr & 0x200)) {
347 if (mec_mcr & 0x400) {
348 sys_reset();
349 mec_ersr = 0x8000;
350 if (sis_verbose)
351 printf("Error manager reset - IU comparison error\n");
352 } else {
353 sys_halt();
354 mec_ersr |= 0x2000;
355 if (sis_verbose)
356 printf("Error manager halt - IU comparison error\n");
357 }
358 } else
359 mec_irq(1);
360 }
361 if (mec_ersr & 0x20) {
362 if (!(mec_mcr & 0x2000)) {
363 if (mec_mcr & 0x4000) {
364 sys_reset();
365 mec_ersr = 0x8000;
366 if (sis_verbose)
367 printf("Error manager reset - MEC hardware error\n");
368 } else {
369 sys_halt();
370 mec_ersr |= 0x2000;
371 if (sis_verbose)
372 printf("Error manager halt - MEC hardware error\n");
373 }
374 } else
375 mec_irq(1);
376 }
377 }
378
379 #ifdef ERRINJ
380 static void
381 iucomperr()
382 {
383 mec_ersr |= 0x04;
384 decode_ersr();
385 }
386 #endif
387
388 static void
389 mecparerror()
390 {
391 mec_ersr |= 0x20;
392 decode_ersr();
393 }
394
395
396 /* IU error mode manager */
397
398 void
399 error_mode(pc)
400 uint32 pc;
401 {
402
403 mec_ersr |= 0x1;
404 decode_ersr();
405 }
406
407
408 /* Check memory settings */
409
410 static void
411 decode_memcfg()
412 {
413 if (rom8) mec_memcfg &= ~0x20000;
414 else mec_memcfg |= 0x20000;
415
416 mem_ramsz = (256 * 1024) << ((mec_memcfg >> 10) & 7);
417 mem_romsz = (128 * 1024) << ((mec_memcfg >> 18) & 7);
418
419 if (sparclite_board) {
420 mem_ramstart = RAM_START_SLITE;
421 mem_ramend = RAM_END_SLITE;
422 mem_rammask = RAM_MASK_SLITE;
423 }
424 else {
425 mem_ramstart = RAM_START;
426 mem_ramend = RAM_END;
427 mem_rammask = RAM_MASK;
428 }
429 if (sis_verbose)
430 printf("RAM start: 0x%x, RAM size: %d K, ROM size: %d K\n",
431 mem_ramstart, mem_ramsz >> 10, mem_romsz >> 10);
432 }
433
434 static void
435 decode_wcr()
436 {
437 mem_ramr_ws = mec_wcr & 3;
438 mem_ramw_ws = (mec_wcr >> 2) & 3;
439 mem_romr_ws = (mec_wcr >> 4) & 0x0f;
440 if (rom8) {
441 if (mem_romr_ws > 0 ) mem_romr_ws--;
442 mem_romr_ws = 5 + (4*mem_romr_ws);
443 }
444 mem_romw_ws = (mec_wcr >> 8) & 0x0f;
445 if (sis_verbose)
446 printf("Waitstates = RAM read: %d, RAM write: %d, ROM read: %d, ROM write: %d\n",
447 mem_ramr_ws, mem_ramw_ws, mem_romr_ws, mem_romw_ws);
448 }
449
450 static void
451 decode_mcr()
452 {
453 mem_accprot = (mec_wpr[0] | mec_wpr[1]);
454 mem_blockprot = (mec_mcr >> 3) & 1;
455 if (sis_verbose && mem_accprot)
456 printf("Memory block write protection enabled\n");
457 if (mec_mcr & 0x08000) {
458 mec_ersr |= 0x20;
459 decode_ersr();
460 }
461 if (sis_verbose && (mec_mcr & 2))
462 printf("Software reset enabled\n");
463 if (sis_verbose && (mec_mcr & 1))
464 printf("Power-down mode enabled\n");
465 }
466
467 /* Flush ports when simulator stops */
468
469 void
470 sim_halt()
471 {
472 #ifdef FAST_UART
473 flush_uart();
474 #endif
475 }
476
477 int
478 sim_stop(SIM_DESC sd)
479 {
480 ctrl_c = 1;
481 return 1;
482 }
483
484 static void
485 close_port()
486 {
487 if (f1open && f1in != stdin)
488 fclose(f1in);
489 if (f2open && f2in != stdin)
490 fclose(f2in);
491 }
492
493 void
494 exit_sim()
495 {
496 close_port();
497 }
498
499 static void
500 mec_reset()
501 {
502 int i;
503
504 find = 0;
505 for (i = 0; i < 2; i++)
506 mec_ssa[i] = mec_sea[i] = mec_wpr[i] = 0;
507 mec_mcr = 0x01350014;
508 mec_iocr = 0;
509 mec_sfsr = 0x078;
510 mec_ffar = 0;
511 mec_ipr = 0;
512 mec_imr = 0x7ffe;
513 mec_isr = 0;
514 mec_icr = 0;
515 mec_ifr = 0;
516 mec_memcfg = 0x10000;
517 mec_wcr = -1;
518 mec_ersr = 0; /* MEC error and status register */
519 mec_tcr = 0; /* MEC test comtrol register */
520
521 decode_memcfg();
522 decode_wcr();
523 decode_mcr();
524
525 posted_irq = 0;
526 wnuma = wnumb = 0;
527 anum = aind = bnum = bind = 0;
528
529 uart_stat_reg = UARTA_SRE | UARTA_HRE | UARTB_SRE | UARTB_HRE;
530 uarta_data = uartb_data = UART_THE | UART_TSE;
531
532 rtc_counter = 0xffffffff;
533 rtc_reload = 0xffffffff;
534 rtc_scaler = 0xff;
535 rtc_enabled = 0;
536 rtc_cr = 0;
537 rtc_se = 0;
538
539 gpt_counter = 0xffffffff;
540 gpt_reload = 0xffffffff;
541 gpt_scaler = 0xffff;
542 gpt_enabled = 0;
543 gpt_cr = 0;
544 gpt_se = 0;
545
546 wdog_scaler = 255;
547 wdog_rst_delay = 255;
548 wdog_counter = 0xffff;
549 wdog_rston = 0;
550 wdog_status = init;
551
552 #ifdef ERA
553 erareg = 0;
554 #endif
555
556 }
557
558
559
560 static void
561 mec_intack(level)
562 int32 level;
563 {
564 int irq_test;
565
566 if (sis_verbose)
567 printf("interrupt %d acknowledged\n", level);
568 irq_test = mec_tcr & 0x80000;
569 if ((irq_test) && (mec_ifr & (1 << level)))
570 mec_ifr &= ~(1 << level);
571 else
572 mec_ipr &= ~(1 << level);
573 chk_irq();
574 }
575
576 static void
577 chk_irq()
578 {
579 int32 i;
580 uint32 itmp;
581 int old_irl;
582
583 old_irl = ext_irl;
584 if (mec_tcr & 0x80000) itmp = mec_ifr;
585 else itmp = 0;
586 itmp = ((mec_ipr | itmp) & ~mec_imr) & 0x0fffe;
587 ext_irl = 0;
588 if (itmp != 0) {
589 for (i = 15; i > 0; i--) {
590 if (((itmp >> i) & 1) != 0) {
591 if ((sis_verbose) && (i > old_irl))
592 printf("IU irl: %d\n", i);
593 ext_irl = i;
594 set_int(i, mec_intack, i);
595 break;
596 }
597 }
598 }
599 }
600
601 static void
602 mec_irq(level)
603 int32 level;
604 {
605 mec_ipr |= (1 << level);
606 chk_irq();
607 }
608
609 static void
610 set_sfsr(fault, addr, asi, read)
611 uint32 fault;
612 uint32 addr;
613 uint32 asi;
614 uint32 read;
615 {
616 if ((asi == 0xa) || (asi == 0xb)) {
617 mec_ffar = addr;
618 mec_sfsr = (fault << 3) | (!read << 15);
619 mec_sfsr |= ((mec_sfsr & 1) ^ 1) | (mec_sfsr & 1);
620 switch (asi) {
621 case 0xa:
622 mec_sfsr |= 0x0004;
623 break;
624 case 0xb:
625 mec_sfsr |= 0x1004;
626 break;
627 }
628 }
629 }
630
631 static int32
632 mec_read(addr, asi, data)
633 uint32 addr;
634 uint32 asi;
635 uint32 *data;
636 {
637
638 switch (addr & 0x0ff) {
639
640 case MEC_MCR: /* 0x00 */
641 *data = mec_mcr;
642 break;
643
644 case MEC_MEMCFG: /* 0x10 */
645 *data = mec_memcfg;
646 break;
647
648 case MEC_IOCR:
649 *data = mec_iocr; /* 0x14 */
650 break;
651
652 case MEC_SSA1: /* 0x20 */
653 *data = mec_ssa[0] | (mec_wpr[0] << 23);
654 break;
655 case MEC_SEA1: /* 0x24 */
656 *data = mec_sea[0];
657 break;
658 case MEC_SSA2: /* 0x28 */
659 *data = mec_ssa[1] | (mec_wpr[1] << 23);
660 break;
661 case MEC_SEA2: /* 0x2c */
662 *data = mec_sea[1];
663 break;
664
665 case MEC_ISR: /* 0x44 */
666 *data = mec_isr;
667 break;
668
669 case MEC_IPR: /* 0x48 */
670 *data = mec_ipr;
671 break;
672
673 case MEC_IMR: /* 0x4c */
674 *data = mec_imr;
675 break;
676
677 case MEC_IFR: /* 0x54 */
678 *data = mec_ifr;
679 break;
680
681 case MEC_RTC_COUNTER: /* 0x80 */
682 *data = rtc_counter_read();
683 break;
684 case MEC_RTC_SCALER: /* 0x84 */
685 if (rtc_enabled)
686 *data = rtc_scaler - (now() - rtc_scaler_start);
687 else
688 *data = rtc_scaler;
689 break;
690
691 case MEC_GPT_COUNTER: /* 0x88 */
692 *data = gpt_counter_read();
693 break;
694
695 case MEC_GPT_SCALER: /* 0x8c */
696 if (rtc_enabled)
697 *data = gpt_scaler - (now() - gpt_scaler_start);
698 else
699 *data = gpt_scaler;
700 break;
701
702
703 case MEC_SFSR: /* 0xA0 */
704 *data = mec_sfsr;
705 break;
706
707 case MEC_FFAR: /* 0xA4 */
708 *data = mec_ffar;
709 break;
710
711 case SIM_LOAD:
712 fname[find] = 0;
713 if (find == 0)
714 strcpy(fname, "simload");
715 find = bfd_load(fname);
716 if (find == -1)
717 *data = 0;
718 else
719 *data = 1;
720 find = 0;
721 break;
722
723 case MEC_ERSR: /* 0xB0 */
724 *data = mec_ersr;
725 break;
726
727 case MEC_TCR: /* 0xD0 */
728 *data = mec_tcr;
729 break;
730
731 case MEC_UARTA: /* 0xE0 */
732 case MEC_UARTB: /* 0xE4 */
733 if (asi != 0xb) {
734 set_sfsr(MEC_ACC, addr, asi, 1);
735 return (1);
736 }
737 *data = read_uart(addr);
738 break;
739
740 case MEC_UART_CTRL: /* 0xE8 */
741
742 *data = read_uart(addr);
743 break;
744
745 default:
746 set_sfsr(MEC_ACC, addr, asi, 1);
747 return (1);
748 break;
749 }
750 return (MOK);
751 }
752
753 static int
754 mec_write(addr, data)
755 uint32 addr;
756 uint32 data;
757 {
758 if (sis_verbose > 1)
759 printf("MEC write a: %08x, d: %08x\n",addr,data);
760 switch (addr & 0x0ff) {
761
762 case MEC_MCR:
763 mec_mcr = data;
764 decode_mcr();
765 if (mec_mcr & 0x08000) mecparerror();
766 break;
767
768 case MEC_SFR:
769 if (mec_mcr & 0x2) {
770 sys_reset();
771 mec_ersr = 0x4000;
772 if (sis_verbose)
773 printf(" Software reset issued\n");
774 }
775 break;
776
777 case MEC_IOCR:
778 mec_iocr = data;
779 if (mec_iocr & 0xC0C0C0C0) mecparerror();
780 break;
781
782 case MEC_SSA1: /* 0x20 */
783 if (data & 0xFE000000) mecparerror();
784 mec_ssa[0] = data & 0x7fffff;
785 mec_wpr[0] = (data >> 23) & 0x03;
786 mem_accprot = mec_wpr[0] || mec_wpr[1];
787 if (sis_verbose && mec_wpr[0])
788 printf("Segment 1 memory protection enabled (0x02%06x - 0x02%06x)\n",
789 mec_ssa[0] << 2, mec_sea[0] << 2);
790 break;
791 case MEC_SEA1: /* 0x24 */
792 if (data & 0xFF800000) mecparerror();
793 mec_sea[0] = data & 0x7fffff;
794 break;
795 case MEC_SSA2: /* 0x28 */
796 if (data & 0xFE000000) mecparerror();
797 mec_ssa[1] = data & 0x7fffff;
798 mec_wpr[1] = (data >> 23) & 0x03;
799 mem_accprot = mec_wpr[0] || mec_wpr[1];
800 if (sis_verbose && mec_wpr[1])
801 printf("Segment 2 memory protection enabled (0x02%06x - 0x02%06x)\n",
802 mec_ssa[1] << 2, mec_sea[1] << 2);
803 break;
804 case MEC_SEA2: /* 0x2c */
805 if (data & 0xFF800000) mecparerror();
806 mec_sea[1] = data & 0x7fffff;
807 break;
808
809 case MEC_UARTA:
810 case MEC_UARTB:
811 if (data & 0xFFFFFF00) mecparerror();
812 case MEC_UART_CTRL:
813 if (data & 0xFF00FF00) mecparerror();
814 write_uart(addr, data);
815 break;
816
817 case MEC_GPT_RELOAD:
818 gpt_reload_set(data);
819 break;
820
821 case MEC_GPT_SCALER:
822 if (data & 0xFFFF0000) mecparerror();
823 gpt_scaler_set(data);
824 break;
825
826 case MEC_TIMER_CTRL:
827 if (data & 0xFFFFF0F0) mecparerror();
828 timer_ctrl(data);
829 break;
830
831 case MEC_RTC_RELOAD:
832 rtc_reload_set(data);
833 break;
834
835 case MEC_RTC_SCALER:
836 if (data & 0xFFFFFF00) mecparerror();
837 rtc_scaler_set(data);
838 break;
839
840 case MEC_SFSR: /* 0xA0 */
841 if (data & 0xFFFF0880) mecparerror();
842 mec_sfsr = 0x78;
843 break;
844
845 case MEC_ISR:
846 if (data & 0xFFFFE000) mecparerror();
847 mec_isr = data;
848 break;
849
850 case MEC_IMR: /* 0x4c */
851
852 if (data & 0xFFFF8001) mecparerror();
853 mec_imr = data & 0x7ffe;
854 chk_irq();
855 break;
856
857 case MEC_ICR: /* 0x50 */
858
859 if (data & 0xFFFF0001) mecparerror();
860 mec_ipr &= ~data & 0x0fffe;
861 chk_irq();
862 break;
863
864 case MEC_IFR: /* 0x54 */
865
866 if (mec_tcr & 0x080000) {
867 if (data & 0xFFFF0001) mecparerror();
868 mec_ifr = data & 0xfffe;
869 chk_irq();
870 }
871 break;
872 case SIM_LOAD:
873 fname[find++] = (char) data;
874 break;
875
876
877 case MEC_MEMCFG: /* 0x10 */
878 if (data & 0xC0E08000) mecparerror();
879 mec_memcfg = data;
880 decode_memcfg();
881 if (mec_memcfg & 0xc0e08000)
882 mecparerror();
883 break;
884
885 case MEC_WCR: /* 0x18 */
886 mec_wcr = data;
887 decode_wcr();
888 break;
889
890 case MEC_ERSR: /* 0xB0 */
891 if (mec_tcr & 0x100000)
892 if (data & 0xFFFFEFC0) mecparerror();
893 mec_ersr = data & 0x103f;
894 break;
895
896 case MEC_TCR: /* 0xD0 */
897 if (data & 0xFFE1FFC0) mecparerror();
898 mec_tcr = data & 0x1e003f;
899 break;
900
901 case MEC_WDOG: /* 0x60 */
902 wdog_scaler = (data >> 16) & 0x0ff;
903 wdog_counter = data & 0x0ffff;
904 wdog_rst_delay = data >> 24;
905 wdog_rston = 0;
906 if (wdog_status == stopped)
907 wdog_start();
908 wdog_status = enabled;
909 break;
910
911 case MEC_TRAPD: /* 0x64 */
912 if (wdog_status == init) {
913 wdog_status = disabled;
914 if (sis_verbose)
915 printf("Watchdog disabled\n");
916 }
917 break;
918
919 case MEC_PWDR:
920 if (mec_mcr & 1)
921 wait_for_irq();
922 break;
923
924 default:
925 set_sfsr(MEC_ACC, addr, 0xb, 0);
926 return (1);
927 break;
928 }
929 return (MOK);
930 }
931
932
933 /* MEC UARTS */
934
935 static int ifd1 = -1, ifd2 = -1, ofd1 = -1, ofd2 = -1;
936
937 void
938 init_stdio()
939 {
940 if (dumbio)
941 return; /* do nothing */
942 if (!ifd1)
943 tcsetattr(0, TCSANOW, &ioc1);
944 if (!ifd2)
945 tcsetattr(0, TCSANOW, &ioc2);
946 }
947
948 void
949 restore_stdio()
950 {
951 if (dumbio)
952 return; /* do nothing */
953 if (!ifd1)
954 tcsetattr(0, TCSANOW, &iocold1);
955 if (!ifd2)
956 tcsetattr(0, TCSANOW, &iocold2);
957 }
958
959 #define DO_STDIO_READ( _fd_, _buf_, _len_ ) \
960 ( dumbio \
961 ? (0) /* no bytes read, no delay */ \
962 : read( _fd_, _buf_, _len_ ) )
963
964
965 static void
966 port_init()
967 {
968
969 if (uben) {
970 f2in = stdin;
971 f1in = NULL;
972 f2out = stdout;
973 f1out = NULL;
974 } else {
975 f1in = stdin;
976 f2in = NULL;
977 f1out = stdout;
978 f2out = NULL;
979 }
980 if (uart_dev1[0] != 0)
981 if ((fd1 = open(uart_dev1, O_RDWR | O_NONBLOCK)) < 0) {
982 printf("Warning, couldn't open output device %s\n", uart_dev1);
983 } else {
984 if (sis_verbose)
985 printf("serial port A on %s\n", uart_dev1);
986 f1in = f1out = fdopen(fd1, "r+");
987 setbuf(f1out, NULL);
988 f1open = 1;
989 }
990 if (f1in) ifd1 = fileno(f1in);
991 if (ifd1 == 0) {
992 if (sis_verbose)
993 printf("serial port A on stdin/stdout\n");
994 if (!dumbio) {
995 tcgetattr(ifd1, &ioc1);
996 iocold1 = ioc1;
997 ioc1.c_lflag &= ~(ICANON | ECHO);
998 ioc1.c_cc[VMIN] = 0;
999 ioc1.c_cc[VTIME] = 0;
1000 }
1001 f1open = 1;
1002 }
1003
1004 if (f1out) {
1005 ofd1 = fileno(f1out);
1006 if (!dumbio && ofd1 == 1) setbuf(f1out, NULL);
1007 }
1008
1009 if (uart_dev2[0] != 0)
1010 if ((fd2 = open(uart_dev2, O_RDWR | O_NONBLOCK)) < 0) {
1011 printf("Warning, couldn't open output device %s\n", uart_dev2);
1012 } else {
1013 if (sis_verbose)
1014 printf("serial port B on %s\n", uart_dev2);
1015 f2in = f2out = fdopen(fd2, "r+");
1016 setbuf(f2out, NULL);
1017 f2open = 1;
1018 }
1019 if (f2in) ifd2 = fileno(f2in);
1020 if (ifd2 == 0) {
1021 if (sis_verbose)
1022 printf("serial port B on stdin/stdout\n");
1023 if (!dumbio) {
1024 tcgetattr(ifd2, &ioc2);
1025 iocold2 = ioc2;
1026 ioc2.c_lflag &= ~(ICANON | ECHO);
1027 ioc2.c_cc[VMIN] = 0;
1028 ioc2.c_cc[VTIME] = 0;
1029 }
1030 f2open = 1;
1031 }
1032
1033 if (f2out) {
1034 ofd2 = fileno(f2out);
1035 if (!dumbio && ofd2 == 1) setbuf(f2out, NULL);
1036 }
1037
1038 wnuma = wnumb = 0;
1039
1040 }
1041
1042 static uint32
1043 read_uart(addr)
1044 uint32 addr;
1045 {
1046
1047 unsigned tmp;
1048
1049 tmp = 0;
1050 switch (addr & 0xff) {
1051
1052 case 0xE0: /* UART 1 */
1053 #ifndef _WIN32
1054 #ifdef FAST_UART
1055
1056 if (aind < anum) {
1057 if ((aind + 1) < anum)
1058 mec_irq(4);
1059 return (0x700 | (uint32) aq[aind++]);
1060 } else {
1061 if (f1open) {
1062 anum = DO_STDIO_READ(ifd1, aq, UARTBUF);
1063 }
1064 if (anum > 0) {
1065 aind = 0;
1066 if ((aind + 1) < anum)
1067 mec_irq(4);
1068 return (0x700 | (uint32) aq[aind++]);
1069 } else {
1070 return (0x600 | (uint32) aq[aind]);
1071 }
1072
1073 }
1074 #else
1075 tmp = uarta_data;
1076 uarta_data &= ~UART_DR;
1077 uart_stat_reg &= ~UARTA_DR;
1078 return tmp;
1079 #endif
1080 #else
1081 return(0);
1082 #endif
1083 break;
1084
1085 case 0xE4: /* UART 2 */
1086 #ifndef _WIN32
1087 #ifdef FAST_UART
1088 if (bind < bnum) {
1089 if ((bind + 1) < bnum)
1090 mec_irq(5);
1091 return (0x700 | (uint32) bq[bind++]);
1092 } else {
1093 if (f2open) {
1094 bnum = DO_STDIO_READ(ifd2, bq, UARTBUF);
1095 }
1096 if (bnum > 0) {
1097 bind = 0;
1098 if ((bind + 1) < bnum)
1099 mec_irq(5);
1100 return (0x700 | (uint32) bq[bind++]);
1101 } else {
1102 return (0x600 | (uint32) bq[bind]);
1103 }
1104
1105 }
1106 #else
1107 tmp = uartb_data;
1108 uartb_data &= ~UART_DR;
1109 uart_stat_reg &= ~UARTB_DR;
1110 return tmp;
1111 #endif
1112 #else
1113 return(0);
1114 #endif
1115 break;
1116
1117 case 0xE8: /* UART status register */
1118 #ifndef _WIN32
1119 #ifdef FAST_UART
1120
1121 Ucontrol = 0;
1122 if (aind < anum) {
1123 Ucontrol |= 0x00000001;
1124 } else {
1125 if (f1open) {
1126 anum = DO_STDIO_READ(ifd1, aq, UARTBUF);
1127 }
1128 if (anum > 0) {
1129 Ucontrol |= 0x00000001;
1130 aind = 0;
1131 mec_irq(4);
1132 }
1133 }
1134 if (bind < bnum) {
1135 Ucontrol |= 0x00010000;
1136 } else {
1137 if (f2open) {
1138 bnum = DO_STDIO_READ(ifd2, bq, UARTBUF);
1139 }
1140 if (bnum > 0) {
1141 Ucontrol |= 0x00010000;
1142 bind = 0;
1143 mec_irq(5);
1144 }
1145 }
1146
1147 Ucontrol |= 0x00060006;
1148 return (Ucontrol);
1149 #else
1150 return (uart_stat_reg);
1151 #endif
1152 #else
1153 return(0x00060006);
1154 #endif
1155 break;
1156 default:
1157 if (sis_verbose)
1158 printf("Read from unimplemented MEC register (%x)\n", addr);
1159
1160 }
1161 return (0);
1162 }
1163
1164 static void
1165 write_uart(addr, data)
1166 uint32 addr;
1167 uint32 data;
1168 {
1169 unsigned char c;
1170
1171 c = (unsigned char) data;
1172 switch (addr & 0xff) {
1173
1174 case 0xE0: /* UART A */
1175 #ifdef FAST_UART
1176 if (f1open) {
1177 if (wnuma < UARTBUF)
1178 wbufa[wnuma++] = c;
1179 else {
1180 while (wnuma)
1181 wnuma -= fwrite(wbufa, 1, wnuma, f1out);
1182 wbufa[wnuma++] = c;
1183 }
1184 }
1185 mec_irq(4);
1186 #else
1187 if (uart_stat_reg & UARTA_SRE) {
1188 uarta_sreg = c;
1189 uart_stat_reg &= ~UARTA_SRE;
1190 event(uarta_tx, 0, UART_TX_TIME);
1191 } else {
1192 uarta_hreg = c;
1193 uart_stat_reg &= ~UARTA_HRE;
1194 }
1195 #endif
1196 break;
1197
1198 case 0xE4: /* UART B */
1199 #ifdef FAST_UART
1200 if (f2open) {
1201 if (wnumb < UARTBUF)
1202 wbufb[wnumb++] = c;
1203 else {
1204 while (wnumb)
1205 wnumb -= fwrite(wbufb, 1, wnumb, f2out);
1206 wbufb[wnumb++] = c;
1207 }
1208 }
1209 mec_irq(5);
1210 #else
1211 if (uart_stat_reg & UARTB_SRE) {
1212 uartb_sreg = c;
1213 uart_stat_reg &= ~UARTB_SRE;
1214 event(uartb_tx, 0, UART_TX_TIME);
1215 } else {
1216 uartb_hreg = c;
1217 uart_stat_reg &= ~UARTB_HRE;
1218 }
1219 #endif
1220 break;
1221 case 0xE8: /* UART status register */
1222 #ifndef FAST_UART
1223 if (data & UARTA_CLR) {
1224 uart_stat_reg &= 0xFFFF0000;
1225 uart_stat_reg |= UARTA_SRE | UARTA_HRE;
1226 }
1227 if (data & UARTB_CLR) {
1228 uart_stat_reg &= 0x0000FFFF;
1229 uart_stat_reg |= UARTB_SRE | UARTB_HRE;
1230 }
1231 #endif
1232 break;
1233 default:
1234 if (sis_verbose)
1235 printf("Write to unimplemented MEC register (%x)\n", addr);
1236
1237 }
1238 }
1239
1240 static void
1241 flush_uart()
1242 {
1243 while (wnuma && f1open)
1244 wnuma -= fwrite(wbufa, 1, wnuma, f1out);
1245 while (wnumb && f2open)
1246 wnumb -= fwrite(wbufb, 1, wnumb, f2out);
1247 }
1248
1249
1250
1251 static void
1252 uarta_tx()
1253 {
1254
1255 while (f1open && fwrite(&uarta_sreg, 1, 1, f1out) != 1);
1256 if (uart_stat_reg & UARTA_HRE) {
1257 uart_stat_reg |= UARTA_SRE;
1258 } else {
1259 uarta_sreg = uarta_hreg;
1260 uart_stat_reg |= UARTA_HRE;
1261 event(uarta_tx, 0, UART_TX_TIME);
1262 }
1263 mec_irq(4);
1264 }
1265
1266 static void
1267 uartb_tx()
1268 {
1269 while (f2open && fwrite(&uartb_sreg, 1, 1, f2out) != 1);
1270 if (uart_stat_reg & UARTB_HRE) {
1271 uart_stat_reg |= UARTB_SRE;
1272 } else {
1273 uartb_sreg = uartb_hreg;
1274 uart_stat_reg |= UARTB_HRE;
1275 event(uartb_tx, 0, UART_TX_TIME);
1276 }
1277 mec_irq(5);
1278 }
1279
1280 static void
1281 uart_rx(arg)
1282 caddr_t arg;
1283 {
1284 int32 rsize;
1285 char rxd;
1286
1287
1288 rsize = 0;
1289 if (f1open)
1290 rsize = DO_STDIO_READ(ifd1, &rxd, 1);
1291 if (rsize > 0) {
1292 uarta_data = UART_DR | rxd;
1293 if (uart_stat_reg & UARTA_HRE)
1294 uarta_data |= UART_THE;
1295 if (uart_stat_reg & UARTA_SRE)
1296 uarta_data |= UART_TSE;
1297 if (uart_stat_reg & UARTA_DR) {
1298 uart_stat_reg |= UARTA_OR;
1299 mec_irq(7); /* UART error interrupt */
1300 }
1301 uart_stat_reg |= UARTA_DR;
1302 mec_irq(4);
1303 }
1304 rsize = 0;
1305 if (f2open)
1306 rsize = DO_STDIO_READ(ifd2, &rxd, 1);
1307 if (rsize) {
1308 uartb_data = UART_DR | rxd;
1309 if (uart_stat_reg & UARTB_HRE)
1310 uartb_data |= UART_THE;
1311 if (uart_stat_reg & UARTB_SRE)
1312 uartb_data |= UART_TSE;
1313 if (uart_stat_reg & UARTB_DR) {
1314 uart_stat_reg |= UARTB_OR;
1315 mec_irq(7); /* UART error interrupt */
1316 }
1317 uart_stat_reg |= UARTB_DR;
1318 mec_irq(5);
1319 }
1320 event(uart_rx, 0, UART_RX_TIME);
1321 }
1322
1323 static void
1324 uart_intr(arg)
1325 caddr_t arg;
1326 {
1327 read_uart(0xE8); /* Check for UART interrupts every 1000 clk */
1328 flush_uart(); /* Flush UART ports */
1329 event(uart_intr, 0, UART_FLUSH_TIME);
1330 }
1331
1332
1333 static void
1334 uart_irq_start()
1335 {
1336 #ifdef FAST_UART
1337 event(uart_intr, 0, UART_FLUSH_TIME);
1338 #else
1339 #ifndef _WIN32
1340 event(uart_rx, 0, UART_RX_TIME);
1341 #endif
1342 #endif
1343 }
1344
1345 /* Watch-dog */
1346
1347 static void
1348 wdog_intr(arg)
1349 caddr_t arg;
1350 {
1351 if (wdog_status == disabled) {
1352 wdog_status = stopped;
1353 } else {
1354
1355 if (wdog_counter) {
1356 wdog_counter--;
1357 event(wdog_intr, 0, wdog_scaler + 1);
1358 } else {
1359 if (wdog_rston) {
1360 printf("Watchdog reset!\n");
1361 sys_reset();
1362 mec_ersr = 0xC000;
1363 } else {
1364 mec_irq(15);
1365 wdog_rston = 1;
1366 wdog_counter = wdog_rst_delay;
1367 event(wdog_intr, 0, wdog_scaler + 1);
1368 }
1369 }
1370 }
1371 }
1372
1373 static void
1374 wdog_start()
1375 {
1376 event(wdog_intr, 0, wdog_scaler + 1);
1377 if (sis_verbose)
1378 printf("Watchdog started, scaler = %d, counter = %d\n",
1379 wdog_scaler, wdog_counter);
1380 }
1381
1382
1383 /* MEC timers */
1384
1385
1386 static void
1387 rtc_intr(arg)
1388 caddr_t arg;
1389 {
1390 if (rtc_counter == 0) {
1391
1392 mec_irq(13);
1393 if (rtc_cr)
1394 rtc_counter = rtc_reload;
1395 else
1396 rtc_se = 0;
1397 } else
1398 rtc_counter -= 1;
1399 if (rtc_se) {
1400 event(rtc_intr, 0, rtc_scaler + 1);
1401 rtc_scaler_start = now();
1402 rtc_enabled = 1;
1403 } else {
1404 if (sis_verbose)
1405 printf("RTC stopped\n\r");
1406 rtc_enabled = 0;
1407 }
1408 }
1409
1410 static void
1411 rtc_start()
1412 {
1413 if (sis_verbose)
1414 printf("RTC started (period %d)\n\r", rtc_scaler + 1);
1415 event(rtc_intr, 0, rtc_scaler + 1);
1416 rtc_scaler_start = now();
1417 rtc_enabled = 1;
1418 }
1419
1420 static uint32
1421 rtc_counter_read()
1422 {
1423 return (rtc_counter);
1424 }
1425
1426 static void
1427 rtc_scaler_set(val)
1428 uint32 val;
1429 {
1430 rtc_scaler = val & 0x0ff; /* eight-bit scaler only */
1431 }
1432
1433 static void
1434 rtc_reload_set(val)
1435 uint32 val;
1436 {
1437 rtc_reload = val;
1438 }
1439
1440 static void
1441 gpt_intr(arg)
1442 caddr_t arg;
1443 {
1444 if (gpt_counter == 0) {
1445 mec_irq(12);
1446 if (gpt_cr)
1447 gpt_counter = gpt_reload;
1448 else
1449 gpt_se = 0;
1450 } else
1451 gpt_counter -= 1;
1452 if (gpt_se) {
1453 event(gpt_intr, 0, gpt_scaler + 1);
1454 gpt_scaler_start = now();
1455 gpt_enabled = 1;
1456 } else {
1457 if (sis_verbose)
1458 printf("GPT stopped\n\r");
1459 gpt_enabled = 0;
1460 }
1461 }
1462
1463 static void
1464 gpt_start()
1465 {
1466 if (sis_verbose)
1467 printf("GPT started (period %d)\n\r", gpt_scaler + 1);
1468 event(gpt_intr, 0, gpt_scaler + 1);
1469 gpt_scaler_start = now();
1470 gpt_enabled = 1;
1471 }
1472
1473 static uint32
1474 gpt_counter_read()
1475 {
1476 return (gpt_counter);
1477 }
1478
1479 static void
1480 gpt_scaler_set(val)
1481 uint32 val;
1482 {
1483 gpt_scaler = val & 0x0ffff; /* 16-bit scaler */
1484 }
1485
1486 static void
1487 gpt_reload_set(val)
1488 uint32 val;
1489 {
1490 gpt_reload = val;
1491 }
1492
1493 static void
1494 timer_ctrl(val)
1495 uint32 val;
1496 {
1497
1498 rtc_cr = ((val & TCR_TCRCR) != 0);
1499 if (val & TCR_TCRCL) {
1500 rtc_counter = rtc_reload;
1501 }
1502 if (val & TCR_TCRSL) {
1503 }
1504 rtc_se = ((val & TCR_TCRSE) != 0);
1505 if (rtc_se && (rtc_enabled == 0))
1506 rtc_start();
1507
1508 gpt_cr = (val & TCR_GACR);
1509 if (val & TCR_GACL) {
1510 gpt_counter = gpt_reload;
1511 }
1512 if (val & TCR_GACL) {
1513 }
1514 gpt_se = (val & TCR_GASE) >> 2;
1515 if (gpt_se && (gpt_enabled == 0))
1516 gpt_start();
1517 }
1518
1519
1520 /* Retrieve data from target memory. MEM points to location from which
1521 to read the data; DATA points to words where retrieved data will be
1522 stored in host byte order. SZ contains log(2) of the number of bytes
1523 to retrieve, and can be 0 (1 byte), 1 (one half-word), 2 (one word),
1524 or 3 (two words). */
1525
1526 static void
1527 fetch_bytes (asi, mem, data, sz)
1528 int asi;
1529 unsigned char *mem;
1530 uint32 *data;
1531 int sz;
1532 {
1533 if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN
1534 || asi == 8 || asi == 9) {
1535 switch (sz) {
1536 case 3:
1537 data[1] = (((uint32) mem[7]) & 0xff) |
1538 ((((uint32) mem[6]) & 0xff) << 8) |
1539 ((((uint32) mem[5]) & 0xff) << 16) |
1540 ((((uint32) mem[4]) & 0xff) << 24);
1541 /* Fall through to 2 */
1542 case 2:
1543 data[0] = (((uint32) mem[3]) & 0xff) |
1544 ((((uint32) mem[2]) & 0xff) << 8) |
1545 ((((uint32) mem[1]) & 0xff) << 16) |
1546 ((((uint32) mem[0]) & 0xff) << 24);
1547 break;
1548 case 1:
1549 data[0] = (((uint32) mem[1]) & 0xff) |
1550 ((((uint32) mem[0]) & 0xff) << 8);
1551 break;
1552 case 0:
1553 data[0] = mem[0] & 0xff;
1554 break;
1555
1556 }
1557 } else {
1558 switch (sz) {
1559 case 3:
1560 data[1] = ((((uint32) mem[7]) & 0xff) << 24) |
1561 ((((uint32) mem[6]) & 0xff) << 16) |
1562 ((((uint32) mem[5]) & 0xff) << 8) |
1563 (((uint32) mem[4]) & 0xff);
1564 /* Fall through to 4 */
1565 case 2:
1566 data[0] = ((((uint32) mem[3]) & 0xff) << 24) |
1567 ((((uint32) mem[2]) & 0xff) << 16) |
1568 ((((uint32) mem[1]) & 0xff) << 8) |
1569 (((uint32) mem[0]) & 0xff);
1570 break;
1571 case 1:
1572 data[0] = ((((uint32) mem[1]) & 0xff) << 8) |
1573 (((uint32) mem[0]) & 0xff);
1574 break;
1575 case 0:
1576 data[0] = mem[0] & 0xff;
1577 break;
1578 }
1579 }
1580 }
1581
1582
1583 /* Store data in target byte order. MEM points to location to store data;
1584 DATA points to words in host byte order to be stored. SZ contains log(2)
1585 of the number of bytes to retrieve, and can be 0 (1 byte), 1 (one half-word),
1586 2 (one word), or 3 (two words). */
1587
1588 static void
1589 store_bytes (mem, data, sz)
1590 unsigned char *mem;
1591 uint32 *data;
1592 int sz;
1593 {
1594 if (CURRENT_TARGET_BYTE_ORDER == LITTLE_ENDIAN) {
1595 switch (sz) {
1596 case 3:
1597 mem[7] = (data[1] >> 24) & 0xff;
1598 mem[6] = (data[1] >> 16) & 0xff;
1599 mem[5] = (data[1] >> 8) & 0xff;
1600 mem[4] = data[1] & 0xff;
1601 /* Fall through to 2 */
1602 case 2:
1603 mem[3] = (data[0] >> 24) & 0xff;
1604 mem[2] = (data[0] >> 16) & 0xff;
1605 /* Fall through to 1 */
1606 case 1:
1607 mem[1] = (data[0] >> 8) & 0xff;
1608 /* Fall through to 0 */
1609 case 0:
1610 mem[0] = data[0] & 0xff;
1611 break;
1612 }
1613 } else {
1614 switch (sz) {
1615 case 3:
1616 mem[7] = data[1] & 0xff;
1617 mem[6] = (data[1] >> 8) & 0xff;
1618 mem[5] = (data[1] >> 16) & 0xff;
1619 mem[4] = (data[1] >> 24) & 0xff;
1620 /* Fall through to 2 */
1621 case 2:
1622 mem[3] = data[0] & 0xff;
1623 mem[2] = (data[0] >> 8) & 0xff;
1624 mem[1] = (data[0] >> 16) & 0xff;
1625 mem[0] = (data[0] >> 24) & 0xff;
1626 break;
1627 case 1:
1628 mem[1] = data[0] & 0xff;
1629 mem[0] = (data[0] >> 8) & 0xff;
1630 break;
1631 case 0:
1632 mem[0] = data[0] & 0xff;
1633 break;
1634
1635 }
1636 }
1637 }
1638
1639
1640 /* Memory emulation */
1641
1642 int
1643 memory_read(asi, addr, data, sz, ws)
1644 int32 asi;
1645 uint32 addr;
1646 uint32 *data;
1647 int32 sz;
1648 int32 *ws;
1649 {
1650 int32 mexc;
1651
1652 #ifdef ERRINJ
1653 if (errmec) {
1654 if (sis_verbose)
1655 printf("Inserted MEC error %d\n",errmec);
1656 set_sfsr(errmec, addr, asi, 1);
1657 if (errmec == 5) mecparerror();
1658 if (errmec == 6) iucomperr();
1659 errmec = 0;
1660 return(1);
1661 }
1662 #endif;
1663
1664 if ((addr >= mem_ramstart) && (addr < (mem_ramstart + mem_ramsz))) {
1665 fetch_bytes (asi, &ramb[addr & mem_rammask], data, sz);
1666 *ws = mem_ramr_ws;
1667 return (0);
1668 } else if ((addr >= MEC_START) && (addr < MEC_END)) {
1669 mexc = mec_read(addr, asi, data);
1670 if (mexc) {
1671 set_sfsr(MEC_ACC, addr, asi, 1);
1672 *ws = MEM_EX_WS;
1673 } else {
1674 *ws = 0;
1675 }
1676 return (mexc);
1677
1678 #ifdef ERA
1679
1680 } else if (era) {
1681 if ((addr < 0x100000) ||
1682 ((addr>= 0x80000000) && (addr < 0x80100000))) {
1683 fetch_bytes (asi, &romb[addr & ROM_MASK], data, sz);
1684 *ws = 4;
1685 return (0);
1686 } else if ((addr >= 0x10000000) &&
1687 (addr < (0x10000000 + (512 << (mec_iocr & 0x0f)))) &&
1688 (mec_iocr & 0x10)) {
1689 *data = erareg;
1690 return (0);
1691 }
1692
1693 } else if (addr < mem_romsz) {
1694 fetch_bytes (asi, &romb[addr], data, sz);
1695 *ws = mem_romr_ws;
1696 return (0);
1697
1698 #else
1699 } else if (addr < mem_romsz) {
1700 fetch_bytes (asi, &romb[addr], data, sz);
1701 *ws = mem_romr_ws;
1702 return (0);
1703 #endif
1704
1705 }
1706
1707 printf("Memory exception at %x (illegal address)\n", addr);
1708 set_sfsr(UIMP_ACC, addr, asi, 1);
1709 *ws = MEM_EX_WS;
1710 return (1);
1711 }
1712
1713 int
1714 memory_write(asi, addr, data, sz, ws)
1715 int32 asi;
1716 uint32 addr;
1717 uint32 *data;
1718 int32 sz;
1719 int32 *ws;
1720 {
1721 uint32 byte_addr;
1722 uint32 byte_mask;
1723 uint32 waddr;
1724 uint32 *ram;
1725 int32 mexc;
1726 int i;
1727 int wphit[2];
1728
1729 #ifdef ERRINJ
1730 if (errmec) {
1731 if (sis_verbose)
1732 printf("Inserted MEC error %d\n",errmec);
1733 set_sfsr(errmec, addr, asi, 0);
1734 if (errmec == 5) mecparerror();
1735 if (errmec == 6) iucomperr();
1736 errmec = 0;
1737 return(1);
1738 }
1739 #endif;
1740
1741 if ((addr >= mem_ramstart) && (addr < (mem_ramstart + mem_ramsz))) {
1742 if (mem_accprot) {
1743
1744 waddr = (addr & 0x7fffff) >> 2;
1745 for (i = 0; i < 2; i++)
1746 wphit[i] =
1747 (((asi == 0xa) && (mec_wpr[i] & 1)) ||
1748 ((asi == 0xb) && (mec_wpr[i] & 2))) &&
1749 ((waddr >= mec_ssa[i]) && ((waddr | (sz == 3)) < mec_sea[i]));
1750
1751 if (((mem_blockprot) && (wphit[0] || wphit[1])) ||
1752 ((!mem_blockprot) &&
1753 !((mec_wpr[0] && wphit[0]) || (mec_wpr[1] && wphit[1]))
1754 )) {
1755 if (sis_verbose)
1756 printf("Memory access protection error at 0x%08x\n", addr);
1757 set_sfsr(PROT_EXC, addr, asi, 0);
1758 *ws = MEM_EX_WS;
1759 return (1);
1760 }
1761 }
1762
1763 store_bytes (&ramb[addr & mem_rammask], data, sz);
1764
1765 switch (sz) {
1766 case 0:
1767 case 1:
1768 *ws = mem_ramw_ws + 3;
1769 break;
1770 case 2:
1771 *ws = mem_ramw_ws;
1772 break;
1773 case 3:
1774 *ws = 2 * mem_ramw_ws + STD_WS;
1775 break;
1776 }
1777 return (0);
1778 } else if ((addr >= MEC_START) && (addr < MEC_END)) {
1779 if ((sz != 2) || (asi != 0xb)) {
1780 set_sfsr(MEC_ACC, addr, asi, 0);
1781 *ws = MEM_EX_WS;
1782 return (1);
1783 }
1784 mexc = mec_write(addr, *data);
1785 if (mexc) {
1786 set_sfsr(MEC_ACC, addr, asi, 0);
1787 *ws = MEM_EX_WS;
1788 } else {
1789 *ws = 0;
1790 }
1791 return (mexc);
1792
1793 #ifdef ERA
1794
1795 } else if (era) {
1796 if ((erareg & 2) &&
1797 ((addr < 0x100000) || ((addr >= 0x80000000) && (addr < 0x80100000)))) {
1798 addr &= ROM_MASK;
1799 *ws = sz == 3 ? 8 : 4;
1800 store_bytes (&romb[addr], data, sz);
1801 return (0);
1802 } else if ((addr >= 0x10000000) &&
1803 (addr < (0x10000000 + (512 << (mec_iocr & 0x0f)))) &&
1804 (mec_iocr & 0x10)) {
1805 erareg = *data & 0x0e;
1806 return (0);
1807 }
1808
1809 } else if ((addr < mem_romsz) && (mec_memcfg & 0x10000) && (wrp) &&
1810 (((mec_memcfg & 0x20000) && (sz > 1)) ||
1811 (!(mec_memcfg & 0x20000) && (sz == 0)))) {
1812
1813 *ws = mem_romw_ws + 1;
1814 if (sz == 3)
1815 *ws += mem_romw_ws + STD_WS;
1816 store_bytes (&romb[addr], data, sz);
1817 return (0);
1818
1819 #else
1820 } else if ((addr < mem_romsz) && (mec_memcfg & 0x10000) && (wrp) &&
1821 (((mec_memcfg & 0x20000) && (sz > 1)) ||
1822 (!(mec_memcfg & 0x20000) && (sz == 0)))) {
1823
1824 *ws = mem_romw_ws + 1;
1825 if (sz == 3)
1826 *ws += mem_romw_ws + STD_WS;
1827 store_bytes (&romb[addr], data, sz);
1828 return (0);
1829
1830 #endif
1831
1832 }
1833
1834 *ws = MEM_EX_WS;
1835 set_sfsr(UIMP_ACC, addr, asi, 0);
1836 return (1);
1837 }
1838
1839 static unsigned char *
1840 get_mem_ptr(addr, size)
1841 uint32 addr;
1842 uint32 size;
1843 {
1844 if ((addr + size) < ROM_SZ) {
1845 return (&romb[addr]);
1846 } else if ((addr >= mem_ramstart) && ((addr + size) < mem_ramend)) {
1847 return (&ramb[addr & mem_rammask]);
1848 }
1849
1850 #ifdef ERA
1851 else if ((era) && ((addr <0x100000) ||
1852 ((addr >= (unsigned) 0x80000000) && ((addr + size) < (unsigned) 0x80100000)))) {
1853 return (&romb[addr & ROM_MASK]);
1854 }
1855 #endif
1856
1857 return ((char *) -1);
1858 }
1859
1860 int
1861 sis_memory_write(addr, data, length)
1862 uint32 addr;
1863 char *data;
1864 uint32 length;
1865 {
1866 char *mem;
1867
1868 if ((mem = get_mem_ptr(addr, length)) == ((char *) -1))
1869 return (0);
1870
1871 memcpy(mem, data, length);
1872 return (length);
1873 }
1874
1875 int
1876 sis_memory_read(addr, data, length)
1877 uint32 addr;
1878 char *data;
1879 uint32 length;
1880 {
1881 char *mem;
1882
1883 if ((mem = get_mem_ptr(addr, length)) == ((char *) -1))
1884 return (0);
1885
1886 memcpy(data, mem, length);
1887 return (length);
1888 }
A mirror of the official binutils-gdb repository