]>
git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - sim/erc32/erc32.c
1 /* This file is part of SIS (SPARC instruction simulator)
3 Copyright (C) 1995-2024 Free Software Foundation, Inc.
4 Contributed by Jiri Gaisler, European Space Agency
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 /* The control space devices */
21 /* This must come before any other includes. */
24 #include <sys/types.h>
30 #include <sys/fcntl.h>
34 #include "sim-config.h"
37 extern int32_t sis_verbose
;
38 extern int32_t sparclite
, sparclite_board
;
39 extern int rom8
,wrp
,uben
;
40 extern char uart_dev1
[], uart_dev2
[];
42 int dumbio
= 0; /* normal, smart, terminal oriented IO by default */
45 #define MEC_START 0x01f80000
46 #define MEC_END 0x01f80100
48 /* Memory exception waitstates */
51 /* ERC32 always adds one waitstate during RAM std */
58 #define MEC_WS 0 /* Waitstates per MEC access (0 ws) */
61 /* MEC register addresses */
65 #define MEC_PWDR 0x008
66 #define MEC_MEMCFG 0x010
67 #define MEC_IOCR 0x014
70 #define MEC_MAR0 0x020
71 #define MEC_MAR1 0x024
73 #define MEC_SSA1 0x020
74 #define MEC_SEA1 0x024
75 #define MEC_SSA2 0x028
76 #define MEC_SEA2 0x02C
82 #define MEC_WDOG 0x060
83 #define MEC_TRAPD 0x064
84 #define MEC_RTC_COUNTER 0x080
85 #define MEC_RTC_RELOAD 0x080
86 #define MEC_RTC_SCALER 0x084
87 #define MEC_GPT_COUNTER 0x088
88 #define MEC_GPT_RELOAD 0x088
89 #define MEC_GPT_SCALER 0x08C
90 #define MEC_TIMER_CTRL 0x098
91 #define MEC_SFSR 0x0A0
92 #define MEC_FFAR 0x0A4
93 #define MEC_ERSR 0x0B0
100 #define MEC_UARTA 0x0E0
101 #define MEC_UARTB 0x0E4
102 #define MEC_UART_CTRL 0x0E8
103 #define SIM_LOAD 0x0F0
105 /* Memory exception causes */
109 #define WATCH_EXC 0xa
110 #define BREAK_EXC 0xb
112 /* Size of UART buffers (bytes) */
115 /* Number of simulator ticks between flushing the UARTS. */
116 /* For good performance, keep above 1000 */
117 #define UART_FLUSH_TIME 3000
119 /* MEC timer control register bits */
124 #define TCR_TCRCR 0x100
125 #define TCR_TCRCL 0x200
126 #define TCR_TCRSE 0x400
127 #define TCR_TCRSL 0x800
129 /* New uart defines */
130 #define UART_TX_TIME 1000
131 #define UART_RX_TIME 1000
133 #define UARTA_SRE 0x2
134 #define UARTA_HRE 0x4
135 #define UARTA_OR 0x40
136 #define UARTA_CLR 0x80
137 #define UARTB_DR 0x10000
138 #define UARTB_SRE 0x20000
139 #define UARTB_HRE 0x40000
140 #define UARTB_OR 0x400000
141 #define UARTB_CLR 0x800000
143 #define UART_DR 0x100
144 #define UART_TSE 0x200
145 #define UART_THE 0x400
149 static char fname
[256];
150 static int32_t find
= 0;
151 static uint32_t mec_ssa
[2]; /* Write protection start address */
152 static uint32_t mec_sea
[2]; /* Write protection end address */
153 static uint32_t mec_wpr
[2]; /* Write protection control fields */
154 static uint32_t mec_sfsr
;
155 static uint32_t mec_ffar
;
156 static uint32_t mec_ipr
;
157 static uint32_t mec_imr
;
158 static uint32_t mec_isr
;
159 static uint32_t mec_icr
;
160 static uint32_t mec_ifr
;
161 static uint32_t mec_mcr
; /* MEC control register */
162 static uint32_t mec_memcfg
; /* Memory control register */
163 static uint32_t mec_wcr
; /* MEC waitstate register */
164 static uint32_t mec_iocr
; /* MEC IO control register */
165 static uint32_t posted_irq
;
166 static uint32_t mec_ersr
; /* MEC error and status register */
167 static uint32_t mec_tcr
; /* MEC test comtrol register */
169 static uint32_t rtc_counter
;
170 static uint32_t rtc_reload
;
171 static uint32_t rtc_scaler
;
172 static uint32_t rtc_scaler_start
;
173 static uint32_t rtc_enabled
;
174 static uint32_t rtc_cr
;
175 static uint32_t rtc_se
;
177 static uint32_t gpt_counter
;
178 static uint32_t gpt_reload
;
179 static uint32_t gpt_scaler
;
180 static uint32_t gpt_scaler_start
;
181 static uint32_t gpt_enabled
;
182 static uint32_t gpt_cr
;
183 static uint32_t gpt_se
;
185 static uint32_t wdog_scaler
;
186 static uint32_t wdog_counter
;
187 static uint32_t wdog_rst_delay
;
188 static uint32_t wdog_rston
;
191 init
, disabled
, enabled
, stopped
194 static enum wdog_type wdog_status
;
197 /* ROM size 1024 Kbyte */
198 #define ROM_SZ 0x100000
199 #define ROM_MASK 0x0fffff
201 /* RAM size 4 Mbyte */
202 #define RAM_START 0x02000000
203 #define RAM_END 0x02400000
204 #define RAM_MASK 0x003fffff
206 /* SPARClite boards all seem to have RAM at the same place. */
207 #define RAM_START_SLITE 0x40000000
208 #define RAM_END_SLITE 0x40400000
209 #define RAM_MASK_SLITE 0x003fffff
211 /* Memory support variables */
213 static uint32_t mem_ramr_ws
; /* RAM read waitstates */
214 static uint32_t mem_ramw_ws
; /* RAM write waitstates */
215 static uint32_t mem_romr_ws
; /* ROM read waitstates */
216 static uint32_t mem_romw_ws
; /* ROM write waitstates */
217 static uint32_t mem_ramstart
; /* RAM start */
218 static uint32_t mem_ramend
; /* RAM end */
219 static uint32_t mem_rammask
; /* RAM address mask */
220 static uint32_t mem_ramsz
; /* RAM size */
221 static uint32_t mem_romsz
; /* ROM size */
222 static uint32_t mem_accprot
; /* RAM write protection enabled */
223 static uint32_t mem_blockprot
; /* RAM block write protection enabled */
225 static unsigned char romb
[ROM_SZ
];
226 static unsigned char ramb
[RAM_END
- RAM_START
];
229 /* UART support variables */
231 static int32_t fd1
, fd2
; /* file descriptor for input file */
232 static int32_t Ucontrol
; /* UART status register */
233 static unsigned char aq
[UARTBUF
], bq
[UARTBUF
];
234 static int32_t anum
, aind
= 0;
235 static int32_t bnum
, bind
= 0;
236 static char wbufa
[UARTBUF
], wbufb
[UARTBUF
];
237 static unsigned wnuma
;
238 static unsigned wnumb
;
239 static FILE *f1in
, *f1out
, *f2in
, *f2out
;
240 #ifdef HAVE_TERMIOS_H
241 static struct termios ioc1
, ioc2
, iocold1
, iocold2
;
243 static int f1open
= 0, f2open
= 0;
245 static char uarta_sreg
, uarta_hreg
, uartb_sreg
, uartb_hreg
;
246 static uint32_t uart_stat_reg
;
247 static uint32_t uarta_data
, uartb_data
;
254 /* Forward declarations */
256 static void decode_ersr (void);
258 static void iucomperr (void);
260 static void mecparerror (void);
261 static void decode_memcfg (void);
262 static void decode_wcr (void);
263 static void decode_mcr (void);
264 static void close_port (void);
265 static void mec_reset (void);
266 static void mec_intack (int32_t level
);
267 static void chk_irq (void);
268 static void mec_irq (int32_t level
);
269 static void set_sfsr (uint32_t fault
, uint32_t addr
,
270 uint32_t asi
, uint32_t read
);
271 static int32_t mec_read (uint32_t addr
, uint32_t asi
, uint32_t *data
);
272 static int mec_write (uint32_t addr
, uint32_t data
);
273 static void port_init (void);
274 static uint32_t read_uart (uint32_t addr
);
275 static void write_uart (uint32_t addr
, uint32_t data
);
276 static void flush_uart (void);
277 static void uarta_tx (int32_t);
278 static void uartb_tx (int32_t);
279 static void uart_rx (int32_t);
280 static void uart_intr (int32_t);
281 static void uart_irq_start (void);
282 static void wdog_intr (int32_t);
283 static void wdog_start (void);
284 static void rtc_intr (int32_t);
285 static void rtc_start (void);
286 static uint32_t rtc_counter_read (void);
287 static void rtc_scaler_set (uint32_t val
);
288 static void rtc_reload_set (uint32_t val
);
289 static void gpt_intr (int32_t);
290 static void gpt_start (void);
291 static uint32_t gpt_counter_read (void);
292 static void gpt_scaler_set (uint32_t val
);
293 static void gpt_reload_set (uint32_t val
);
294 static void timer_ctrl (uint32_t val
);
295 static void * get_mem_ptr (uint32_t addr
, uint32_t size
);
296 static void store_bytes (unsigned char *mem
, uint32_t waddr
,
297 uint32_t *data
, int sz
, int32_t *ws
);
310 /* Power-on reset init */
323 if (mec_ersr
& 0x01) {
324 if (!(mec_mcr
& 0x20)) {
325 if (mec_mcr
& 0x40) {
329 printf("Error manager reset - IU in error mode\n");
334 printf("Error manager halt - IU in error mode\n");
339 if (mec_ersr
& 0x04) {
340 if (!(mec_mcr
& 0x200)) {
341 if (mec_mcr
& 0x400) {
345 printf("Error manager reset - IU comparison error\n");
350 printf("Error manager halt - IU comparison error\n");
355 if (mec_ersr
& 0x20) {
356 if (!(mec_mcr
& 0x2000)) {
357 if (mec_mcr
& 0x4000) {
361 printf("Error manager reset - MEC hardware error\n");
366 printf("Error manager halt - MEC hardware error\n");
390 /* IU error mode manager */
393 error_mode(uint32_t pc
)
401 /* Check memory settings */
406 if (rom8
) mec_memcfg
&= ~0x20000;
407 else mec_memcfg
|= 0x20000;
409 mem_ramsz
= (256 * 1024) << ((mec_memcfg
>> 10) & 7);
410 mem_romsz
= (128 * 1024) << ((mec_memcfg
>> 18) & 7);
412 if (sparclite_board
) {
413 mem_ramstart
= RAM_START_SLITE
;
414 mem_ramend
= RAM_END_SLITE
;
415 mem_rammask
= RAM_MASK_SLITE
;
418 mem_ramstart
= RAM_START
;
419 mem_ramend
= RAM_END
;
420 mem_rammask
= RAM_MASK
;
423 printf("RAM start: 0x%x, RAM size: %d K, ROM size: %d K\n",
424 mem_ramstart
, mem_ramsz
>> 10, mem_romsz
>> 10);
430 mem_ramr_ws
= mec_wcr
& 3;
431 mem_ramw_ws
= (mec_wcr
>> 2) & 3;
432 mem_romr_ws
= (mec_wcr
>> 4) & 0x0f;
434 if (mem_romr_ws
> 0 ) mem_romr_ws
--;
435 mem_romr_ws
= 5 + (4*mem_romr_ws
);
437 mem_romw_ws
= (mec_wcr
>> 8) & 0x0f;
439 printf("Waitstates = RAM read: %d, RAM write: %d, ROM read: %d, ROM write: %d\n",
440 mem_ramr_ws
, mem_ramw_ws
, mem_romr_ws
, mem_romw_ws
);
446 mem_accprot
= (mec_wpr
[0] | mec_wpr
[1]);
447 mem_blockprot
= (mec_mcr
>> 3) & 1;
448 if (sis_verbose
&& mem_accprot
)
449 printf("Memory block write protection enabled\n");
450 if (mec_mcr
& 0x08000) {
454 if (sis_verbose
&& (mec_mcr
& 2))
455 printf("Software reset enabled\n");
456 if (sis_verbose
&& (mec_mcr
& 1))
457 printf("Power-down mode enabled\n");
460 /* Flush ports when simulator stops */
471 sim_stop(SIM_DESC sd
)
480 if (f1open
&& f1in
!= stdin
)
482 if (f2open
&& f2in
!= stdin
)
498 for (i
= 0; i
< 2; i
++)
499 mec_ssa
[i
] = mec_sea
[i
] = mec_wpr
[i
] = 0;
500 mec_mcr
= 0x01350014;
509 mec_memcfg
= 0x10000;
511 mec_ersr
= 0; /* MEC error and status register */
512 mec_tcr
= 0; /* MEC test comtrol register */
520 anum
= aind
= bnum
= bind
= 0;
522 uart_stat_reg
= UARTA_SRE
| UARTA_HRE
| UARTB_SRE
| UARTB_HRE
;
523 uarta_data
= uartb_data
= UART_THE
| UART_TSE
;
525 rtc_counter
= 0xffffffff;
526 rtc_reload
= 0xffffffff;
532 gpt_counter
= 0xffffffff;
533 gpt_reload
= 0xffffffff;
540 wdog_rst_delay
= 255;
541 wdog_counter
= 0xffff;
554 mec_intack(int32_t level
)
559 printf("interrupt %d acknowledged\n", level
);
560 irq_test
= mec_tcr
& 0x80000;
561 if ((irq_test
) && (mec_ifr
& (1 << level
)))
562 mec_ifr
&= ~(1 << level
);
564 mec_ipr
&= ~(1 << level
);
576 if (mec_tcr
& 0x80000) itmp
= mec_ifr
;
578 itmp
= ((mec_ipr
| itmp
) & ~mec_imr
) & 0x0fffe;
581 for (i
= 15; i
> 0; i
--) {
582 if (((itmp
>> i
) & 1) != 0) {
583 if ((sis_verbose
) && (i
> old_irl
))
584 printf("IU irl: %d\n", i
);
586 set_int(i
, mec_intack
, i
);
594 mec_irq(int32_t level
)
596 mec_ipr
|= (1 << level
);
601 set_sfsr(uint32_t fault
, uint32_t addr
, uint32_t asi
, uint32_t read
)
603 if ((asi
== 0xa) || (asi
== 0xb)) {
605 mec_sfsr
= (fault
<< 3) | (!read
<< 15);
606 mec_sfsr
|= ((mec_sfsr
& 1) ^ 1) | (mec_sfsr
& 1);
619 mec_read(uint32_t addr
, uint32_t asi
, uint32_t *data
)
622 switch (addr
& 0x0ff) {
624 case MEC_MCR
: /* 0x00 */
628 case MEC_MEMCFG
: /* 0x10 */
633 *data
= mec_iocr
; /* 0x14 */
636 case MEC_SSA1
: /* 0x20 */
637 *data
= mec_ssa
[0] | (mec_wpr
[0] << 23);
639 case MEC_SEA1
: /* 0x24 */
642 case MEC_SSA2
: /* 0x28 */
643 *data
= mec_ssa
[1] | (mec_wpr
[1] << 23);
645 case MEC_SEA2
: /* 0x2c */
649 case MEC_ISR
: /* 0x44 */
653 case MEC_IPR
: /* 0x48 */
657 case MEC_IMR
: /* 0x4c */
661 case MEC_IFR
: /* 0x54 */
665 case MEC_RTC_COUNTER
: /* 0x80 */
666 *data
= rtc_counter_read();
668 case MEC_RTC_SCALER
: /* 0x84 */
670 *data
= rtc_scaler
- (now() - rtc_scaler_start
);
675 case MEC_GPT_COUNTER
: /* 0x88 */
676 *data
= gpt_counter_read();
679 case MEC_GPT_SCALER
: /* 0x8c */
681 *data
= gpt_scaler
- (now() - gpt_scaler_start
);
687 case MEC_SFSR
: /* 0xA0 */
691 case MEC_FFAR
: /* 0xA4 */
698 strcpy(fname
, "simload");
699 find
= bfd_load(fname
);
707 case MEC_ERSR
: /* 0xB0 */
711 case MEC_TCR
: /* 0xD0 */
715 case MEC_UARTA
: /* 0xE0 */
716 case MEC_UARTB
: /* 0xE4 */
718 set_sfsr(MEC_ACC
, addr
, asi
, 1);
721 *data
= read_uart(addr
);
724 case MEC_UART_CTRL
: /* 0xE8 */
726 *data
= read_uart(addr
);
729 case 0xF4: /* simulator RAM size in bytes */
733 case 0xF8: /* simulator ROM size in bytes */
738 set_sfsr(MEC_ACC
, addr
, asi
, 1);
746 mec_write(uint32_t addr
, uint32_t data
)
749 printf("MEC write a: %08x, d: %08x\n",addr
,data
);
750 switch (addr
& 0x0ff) {
755 if (mec_mcr
& 0x08000) mecparerror();
763 printf(" Software reset issued\n");
769 if (mec_iocr
& 0xC0C0C0C0) mecparerror();
772 case MEC_SSA1
: /* 0x20 */
773 if (data
& 0xFE000000) mecparerror();
774 mec_ssa
[0] = data
& 0x7fffff;
775 mec_wpr
[0] = (data
>> 23) & 0x03;
776 mem_accprot
= mec_wpr
[0] || mec_wpr
[1];
777 if (sis_verbose
&& mec_wpr
[0])
778 printf("Segment 1 memory protection enabled (0x02%06x - 0x02%06x)\n",
779 mec_ssa
[0] << 2, mec_sea
[0] << 2);
781 case MEC_SEA1
: /* 0x24 */
782 if (data
& 0xFF800000) mecparerror();
783 mec_sea
[0] = data
& 0x7fffff;
785 case MEC_SSA2
: /* 0x28 */
786 if (data
& 0xFE000000) mecparerror();
787 mec_ssa
[1] = data
& 0x7fffff;
788 mec_wpr
[1] = (data
>> 23) & 0x03;
789 mem_accprot
= mec_wpr
[0] || mec_wpr
[1];
790 if (sis_verbose
&& mec_wpr
[1])
791 printf("Segment 2 memory protection enabled (0x02%06x - 0x02%06x)\n",
792 mec_ssa
[1] << 2, mec_sea
[1] << 2);
794 case MEC_SEA2
: /* 0x2c */
795 if (data
& 0xFF800000) mecparerror();
796 mec_sea
[1] = data
& 0x7fffff;
801 if (data
& 0xFFFFFF00) mecparerror();
802 ATTRIBUTE_FALLTHROUGH
;
804 if (data
& 0xFF00FF00) mecparerror();
805 write_uart(addr
, data
);
809 gpt_reload_set(data
);
813 if (data
& 0xFFFF0000) mecparerror();
814 gpt_scaler_set(data
);
818 if (data
& 0xFFFFF0F0) mecparerror();
823 rtc_reload_set(data
);
827 if (data
& 0xFFFFFF00) mecparerror();
828 rtc_scaler_set(data
);
831 case MEC_SFSR
: /* 0xA0 */
832 if (data
& 0xFFFF0880) mecparerror();
837 if (data
& 0xFFFFE000) mecparerror();
841 case MEC_IMR
: /* 0x4c */
843 if (data
& 0xFFFF8001) mecparerror();
844 mec_imr
= data
& 0x7ffe;
848 case MEC_ICR
: /* 0x50 */
850 if (data
& 0xFFFF0001) mecparerror();
851 mec_ipr
&= ~data
& 0x0fffe;
855 case MEC_IFR
: /* 0x54 */
857 if (mec_tcr
& 0x080000) {
858 if (data
& 0xFFFF0001) mecparerror();
859 mec_ifr
= data
& 0xfffe;
864 fname
[find
++] = (char) data
;
868 case MEC_MEMCFG
: /* 0x10 */
869 if (data
& 0xC0E08000) mecparerror();
872 if (mec_memcfg
& 0xc0e08000)
876 case MEC_WCR
: /* 0x18 */
881 case MEC_ERSR
: /* 0xB0 */
882 if (mec_tcr
& 0x100000)
883 if (data
& 0xFFFFEFC0) mecparerror();
884 mec_ersr
= data
& 0x103f;
887 case MEC_TCR
: /* 0xD0 */
888 if (data
& 0xFFE1FFC0) mecparerror();
889 mec_tcr
= data
& 0x1e003f;
892 case MEC_WDOG
: /* 0x60 */
893 wdog_scaler
= (data
>> 16) & 0x0ff;
894 wdog_counter
= data
& 0x0ffff;
895 wdog_rst_delay
= data
>> 24;
897 if (wdog_status
== stopped
)
899 wdog_status
= enabled
;
902 case MEC_TRAPD
: /* 0x64 */
903 if (wdog_status
== init
) {
904 wdog_status
= disabled
;
906 printf("Watchdog disabled\n");
916 set_sfsr(MEC_ACC
, addr
, 0xb, 0);
926 static int ifd1
= -1, ifd2
= -1, ofd1
= -1, ofd2
= -1;
932 return; /* do nothing */
933 #ifdef HAVE_TERMIOS_H
935 tcsetattr(0, TCSANOW
, &ioc1
);
937 tcsetattr(0, TCSANOW
, &ioc2
);
945 return; /* do nothing */
946 #ifdef HAVE_TERMIOS_H
948 tcsetattr(0, TCSANOW
, &iocold1
);
950 tcsetattr(0, TCSANOW
, &iocold2
);
954 #define DO_STDIO_READ( _fd_, _buf_, _len_ ) \
956 ? (0) /* no bytes read, no delay */ \
957 : read( _fd_, _buf_, _len_ ) )
975 if (uart_dev1
[0] != 0) {
976 if ((fd1
= open(uart_dev1
, O_RDWR
| O_NONBLOCK
)) < 0) {
977 printf("Warning, couldn't open output device %s\n", uart_dev1
);
980 printf("serial port A on %s\n", uart_dev1
);
981 f1in
= f1out
= fdopen(fd1
, "r+");
986 if (f1in
) ifd1
= fileno(f1in
);
989 printf("serial port A on stdin/stdout\n");
991 #ifdef HAVE_TERMIOS_H
992 tcgetattr(ifd1
, &ioc1
);
994 ioc1
.c_lflag
&= ~(ICANON
| ECHO
);
996 ioc1
.c_cc
[VTIME
] = 0;
1003 ofd1
= fileno(f1out
);
1004 if (!dumbio
&& ofd1
== 1) setbuf(f1out
, NULL
);
1007 if (uart_dev2
[0] != 0) {
1008 if ((fd2
= open(uart_dev2
, O_RDWR
| O_NONBLOCK
)) < 0) {
1009 printf("Warning, couldn't open output device %s\n", uart_dev2
);
1012 printf("serial port B on %s\n", uart_dev2
);
1013 f2in
= f2out
= fdopen(fd2
, "r+");
1014 setbuf(f2out
, NULL
);
1018 if (f2in
) ifd2
= fileno(f2in
);
1021 printf("serial port B on stdin/stdout\n");
1023 #ifdef HAVE_TERMIOS_H
1024 tcgetattr(ifd2
, &ioc2
);
1026 ioc2
.c_lflag
&= ~(ICANON
| ECHO
);
1027 ioc2
.c_cc
[VMIN
] = 0;
1028 ioc2
.c_cc
[VTIME
] = 0;
1035 ofd2
= fileno(f2out
);
1036 if (!dumbio
&& ofd2
== 1) setbuf(f2out
, NULL
);
1044 read_uart(uint32_t addr
)
1046 switch (addr
& 0xff) {
1048 case 0xE0: /* UART 1 */
1053 if ((aind
+ 1) < anum
)
1055 return (0x700 | (uint32_t) aq
[aind
++]);
1058 anum
= DO_STDIO_READ(ifd1
, aq
, UARTBUF
);
1062 if ((aind
+ 1) < anum
)
1064 return (0x700 | (uint32_t) aq
[aind
++]);
1066 return (0x600 | (uint32_t) aq
[aind
]);
1071 unsigned tmp
= uarta_data
;
1072 uarta_data
&= ~UART_DR
;
1073 uart_stat_reg
&= ~UARTA_DR
;
1081 case 0xE4: /* UART 2 */
1085 if ((bind
+ 1) < bnum
)
1087 return (0x700 | (uint32_t) bq
[bind
++]);
1090 bnum
= DO_STDIO_READ(ifd2
, bq
, UARTBUF
);
1094 if ((bind
+ 1) < bnum
)
1096 return (0x700 | (uint32_t) bq
[bind
++]);
1098 return (0x600 | (uint32_t) bq
[bind
]);
1103 unsigned tmp
= uartb_data
;
1104 uartb_data
&= ~UART_DR
;
1105 uart_stat_reg
&= ~UARTB_DR
;
1113 case 0xE8: /* UART status register */
1119 Ucontrol
|= 0x00000001;
1122 anum
= DO_STDIO_READ(ifd1
, aq
, UARTBUF
);
1125 Ucontrol
|= 0x00000001;
1131 Ucontrol
|= 0x00010000;
1134 bnum
= DO_STDIO_READ(ifd2
, bq
, UARTBUF
);
1137 Ucontrol
|= 0x00010000;
1143 Ucontrol
|= 0x00060006;
1146 return uart_stat_reg
;
1154 printf("Read from unimplemented MEC register (%x)\n", addr
);
1161 write_uart(uint32_t addr
, uint32_t data
)
1165 c
= (unsigned char) data
;
1166 switch (addr
& 0xff) {
1168 case 0xE0: /* UART A */
1171 if (wnuma
< UARTBUF
)
1175 wnuma
-= fwrite(wbufa
, 1, wnuma
, f1out
);
1181 if (uart_stat_reg
& UARTA_SRE
) {
1183 uart_stat_reg
&= ~UARTA_SRE
;
1184 event(uarta_tx
, 0, UART_TX_TIME
);
1187 uart_stat_reg
&= ~UARTA_HRE
;
1192 case 0xE4: /* UART B */
1195 if (wnumb
< UARTBUF
)
1199 wnumb
-= fwrite(wbufb
, 1, wnumb
, f2out
);
1205 if (uart_stat_reg
& UARTB_SRE
) {
1207 uart_stat_reg
&= ~UARTB_SRE
;
1208 event(uartb_tx
, 0, UART_TX_TIME
);
1211 uart_stat_reg
&= ~UARTB_HRE
;
1215 case 0xE8: /* UART status register */
1217 if (data
& UARTA_CLR
) {
1218 uart_stat_reg
&= 0xFFFF0000;
1219 uart_stat_reg
|= UARTA_SRE
| UARTA_HRE
;
1221 if (data
& UARTB_CLR
) {
1222 uart_stat_reg
&= 0x0000FFFF;
1223 uart_stat_reg
|= UARTB_SRE
| UARTB_HRE
;
1229 printf("Write to unimplemented MEC register (%x)\n", addr
);
1237 while (wnuma
&& f1open
)
1238 wnuma
-= fwrite(wbufa
, 1, wnuma
, f1out
);
1239 while (wnumb
&& f2open
)
1240 wnumb
-= fwrite(wbufb
, 1, wnumb
, f2out
);
1245 uarta_tx(int32_t arg ATTRIBUTE_UNUSED
)
1248 while (f1open
&& fwrite(&uarta_sreg
, 1, 1, f1out
) != 1);
1249 if (uart_stat_reg
& UARTA_HRE
) {
1250 uart_stat_reg
|= UARTA_SRE
;
1252 uarta_sreg
= uarta_hreg
;
1253 uart_stat_reg
|= UARTA_HRE
;
1254 event(uarta_tx
, 0, UART_TX_TIME
);
1261 uartb_tx(int32_t arg ATTRIBUTE_UNUSED
)
1263 while (f2open
&& fwrite(&uartb_sreg
, 1, 1, f2out
) != 1);
1264 if (uart_stat_reg
& UARTB_HRE
) {
1265 uart_stat_reg
|= UARTB_SRE
;
1267 uartb_sreg
= uartb_hreg
;
1268 uart_stat_reg
|= UARTB_HRE
;
1269 event(uartb_tx
, 0, UART_TX_TIME
);
1276 uart_rx(int32_t arg ATTRIBUTE_UNUSED
)
1284 rsize
= DO_STDIO_READ(ifd1
, &rxd
, 1);
1286 uarta_data
= UART_DR
| rxd
;
1287 if (uart_stat_reg
& UARTA_HRE
)
1288 uarta_data
|= UART_THE
;
1289 if (uart_stat_reg
& UARTA_SRE
)
1290 uarta_data
|= UART_TSE
;
1291 if (uart_stat_reg
& UARTA_DR
) {
1292 uart_stat_reg
|= UARTA_OR
;
1293 mec_irq(7); /* UART error interrupt */
1295 uart_stat_reg
|= UARTA_DR
;
1300 rsize
= DO_STDIO_READ(ifd2
, &rxd
, 1);
1302 uartb_data
= UART_DR
| rxd
;
1303 if (uart_stat_reg
& UARTB_HRE
)
1304 uartb_data
|= UART_THE
;
1305 if (uart_stat_reg
& UARTB_SRE
)
1306 uartb_data
|= UART_TSE
;
1307 if (uart_stat_reg
& UARTB_DR
) {
1308 uart_stat_reg
|= UARTB_OR
;
1309 mec_irq(7); /* UART error interrupt */
1311 uart_stat_reg
|= UARTB_DR
;
1314 event(uart_rx
, 0, UART_RX_TIME
);
1318 uart_intr(int32_t arg ATTRIBUTE_UNUSED
)
1320 read_uart(0xE8); /* Check for UART interrupts every 1000 clk */
1321 flush_uart(); /* Flush UART ports */
1322 event(uart_intr
, 0, UART_FLUSH_TIME
);
1327 uart_irq_start(void)
1330 event(uart_intr
, 0, UART_FLUSH_TIME
);
1333 event(uart_rx
, 0, UART_RX_TIME
);
1341 wdog_intr(int32_t arg ATTRIBUTE_UNUSED
)
1343 if (wdog_status
== disabled
) {
1344 wdog_status
= stopped
;
1349 event(wdog_intr
, 0, wdog_scaler
+ 1);
1352 printf("Watchdog reset!\n");
1358 wdog_counter
= wdog_rst_delay
;
1359 event(wdog_intr
, 0, wdog_scaler
+ 1);
1368 event(wdog_intr
, 0, wdog_scaler
+ 1);
1370 printf("Watchdog started, scaler = %d, counter = %d\n",
1371 wdog_scaler
, wdog_counter
);
1379 rtc_intr(int32_t arg ATTRIBUTE_UNUSED
)
1381 if (rtc_counter
== 0) {
1385 rtc_counter
= rtc_reload
;
1391 event(rtc_intr
, 0, rtc_scaler
+ 1);
1392 rtc_scaler_start
= now();
1396 printf("RTC stopped\n\r");
1405 printf("RTC started (period %d)\n\r", rtc_scaler
+ 1);
1406 event(rtc_intr
, 0, rtc_scaler
+ 1);
1407 rtc_scaler_start
= now();
1412 rtc_counter_read(void)
1418 rtc_scaler_set(uint32_t val
)
1420 rtc_scaler
= val
& 0x0ff; /* eight-bit scaler only */
1424 rtc_reload_set(uint32_t val
)
1430 gpt_intr(int32_t arg ATTRIBUTE_UNUSED
)
1432 if (gpt_counter
== 0) {
1435 gpt_counter
= gpt_reload
;
1441 event(gpt_intr
, 0, gpt_scaler
+ 1);
1442 gpt_scaler_start
= now();
1446 printf("GPT stopped\n\r");
1455 printf("GPT started (period %d)\n\r", gpt_scaler
+ 1);
1456 event(gpt_intr
, 0, gpt_scaler
+ 1);
1457 gpt_scaler_start
= now();
1462 gpt_counter_read(void)
1468 gpt_scaler_set(uint32_t val
)
1470 gpt_scaler
= val
& 0x0ffff; /* 16-bit scaler */
1474 gpt_reload_set(uint32_t val
)
1480 timer_ctrl(uint32_t val
)
1483 rtc_cr
= ((val
& TCR_TCRCR
) != 0);
1484 if (val
& TCR_TCRCL
) {
1485 rtc_counter
= rtc_reload
;
1487 if (val
& TCR_TCRSL
) {
1489 rtc_se
= ((val
& TCR_TCRSE
) != 0);
1490 if (rtc_se
&& (rtc_enabled
== 0))
1493 gpt_cr
= (val
& TCR_GACR
);
1494 if (val
& TCR_GACL
) {
1495 gpt_counter
= gpt_reload
;
1497 if (val
& TCR_GACL
) {
1499 gpt_se
= (val
& TCR_GASE
) >> 2;
1500 if (gpt_se
&& (gpt_enabled
== 0))
1504 /* Store data in host byte order. MEM points to the beginning of the
1505 emulated memory; WADDR contains the index the emulated memory,
1506 DATA points to words in host byte order to be stored. SZ contains log(2)
1507 of the number of bytes to retrieve, and can be 0 (1 byte), 1 (one half-word),
1508 2 (one word), or 3 (two words); WS should return the number of
1512 store_bytes (unsigned char *mem
, uint32_t waddr
, uint32_t *data
, int32_t sz
,
1518 mem
[waddr
] = *data
& 0x0ff;
1519 *ws
= mem_ramw_ws
+ 3;
1522 #ifdef HOST_LITTLE_ENDIAN
1525 memcpy (&mem
[waddr
], data
, 2);
1526 *ws
= mem_ramw_ws
+ 3;
1529 memcpy (&mem
[waddr
], data
, 4);
1533 memcpy (&mem
[waddr
], data
, 8);
1534 *ws
= 2 * mem_ramw_ws
+ STD_WS
;
1540 /* Memory emulation */
1543 memory_iread (uint32_t addr
, uint32_t *data
, uint32_t *ws
)
1546 if ((addr
>= mem_ramstart
) && (addr
< (mem_ramstart
+ mem_ramsz
))) {
1547 memcpy (data
, &ramb
[addr
& mem_rammask
& ~3], 4);
1550 } else if (addr
< mem_romsz
) {
1551 memcpy (data
, &romb
[addr
& ~3], 4);
1557 printf ("Memory exception at %x (illegal address)\n", addr
);
1558 if (sregs
.psr
& 0x080)
1562 set_sfsr (UIMP_ACC
, addr
, asi
, 1);
1568 memory_read(int32_t asi
, uint32_t addr
, void *data
, int32_t sz
, int32_t *ws
)
1575 printf("Inserted MEC error %d\n",errmec
);
1576 set_sfsr(errmec
, addr
, asi
, 1);
1577 if (errmec
== 5) mecparerror();
1578 if (errmec
== 6) iucomperr();
1584 if ((addr
>= mem_ramstart
) && (addr
< (mem_ramstart
+ mem_ramsz
))) {
1585 memcpy (data
, &ramb
[addr
& mem_rammask
& ~3], 4);
1588 } else if ((addr
>= MEC_START
) && (addr
< MEC_END
)) {
1589 mexc
= mec_read(addr
, asi
, data
);
1591 set_sfsr(MEC_ACC
, addr
, asi
, 1);
1601 if ((addr
< 0x100000) ||
1602 ((addr
>= 0x80000000) && (addr
< 0x80100000))) {
1603 memcpy (data
, &romb
[addr
& ROM_MASK
& ~3], 4);
1606 } else if ((addr
>= 0x10000000) &&
1607 (addr
< (0x10000000 + (512 << (mec_iocr
& 0x0f)))) &&
1608 (mec_iocr
& 0x10)) {
1609 memcpy (data
, &erareg
, 4);
1613 } else if (addr
< mem_romsz
) {
1614 memcpy (data
, &romb
[addr
& ~3], 4);
1618 } else if (addr
< mem_romsz
) {
1619 memcpy (data
, &romb
[addr
& ~3], 4);
1627 printf ("Memory exception at %x (illegal address)\n", addr
);
1628 set_sfsr(UIMP_ACC
, addr
, asi
, 1);
1634 memory_write(int32_t asi
, uint32_t addr
, uint32_t *data
, int32_t sz
, int32_t *ws
)
1644 printf("Inserted MEC error %d\n",errmec
);
1645 set_sfsr(errmec
, addr
, asi
, 0);
1646 if (errmec
== 5) mecparerror();
1647 if (errmec
== 6) iucomperr();
1653 if ((addr
>= mem_ramstart
) && (addr
< (mem_ramstart
+ mem_ramsz
))) {
1656 waddr
= (addr
& 0x7fffff) >> 2;
1657 for (i
= 0; i
< 2; i
++)
1659 (((asi
== 0xa) && (mec_wpr
[i
] & 1)) ||
1660 ((asi
== 0xb) && (mec_wpr
[i
] & 2))) &&
1661 ((waddr
>= mec_ssa
[i
]) && ((waddr
| (sz
== 3)) < mec_sea
[i
]));
1663 if (((mem_blockprot
) && (wphit
[0] || wphit
[1])) ||
1664 ((!mem_blockprot
) &&
1665 !((mec_wpr
[0] && wphit
[0]) || (mec_wpr
[1] && wphit
[1]))
1668 printf("Memory access protection error at 0x%08x\n", addr
);
1669 set_sfsr(PROT_EXC
, addr
, asi
, 0);
1674 waddr
= addr
& mem_rammask
;
1675 store_bytes (ramb
, waddr
, data
, sz
, ws
);
1677 } else if ((addr
>= MEC_START
) && (addr
< MEC_END
)) {
1678 if ((sz
!= 2) || (asi
!= 0xb)) {
1679 set_sfsr(MEC_ACC
, addr
, asi
, 0);
1683 mexc
= mec_write(addr
, *data
);
1685 set_sfsr(MEC_ACC
, addr
, asi
, 0);
1696 ((addr
< 0x100000) || ((addr
>= 0x80000000) && (addr
< 0x80100000)))) {
1698 *ws
= sz
== 3 ? 8 : 4;
1699 store_bytes (romb
, addr
, data
, sz
, ws
);
1701 } else if ((addr
>= 0x10000000) &&
1702 (addr
< (0x10000000 + (512 << (mec_iocr
& 0x0f)))) &&
1703 (mec_iocr
& 0x10)) {
1704 erareg
= *data
& 0x0e;
1708 } else if ((addr
< mem_romsz
) && (mec_memcfg
& 0x10000) && (wrp
) &&
1709 (((mec_memcfg
& 0x20000) && (sz
> 1)) ||
1710 (!(mec_memcfg
& 0x20000) && (sz
== 0)))) {
1712 *ws
= mem_romw_ws
+ 1;
1714 *ws
+= mem_romw_ws
+ STD_WS
;
1715 store_bytes (romb
, addr
, data
, sz
, ws
);
1719 } else if ((addr
< mem_romsz
) && (mec_memcfg
& 0x10000) && (wrp
) &&
1720 (((mec_memcfg
& 0x20000) && (sz
> 1)) ||
1721 (!(mec_memcfg
& 0x20000) && (sz
== 0)))) {
1723 *ws
= mem_romw_ws
+ 1;
1725 *ws
+= mem_romw_ws
+ STD_WS
;
1726 store_bytes (romb
, addr
, data
, sz
, ws
);
1734 set_sfsr(UIMP_ACC
, addr
, asi
, 0);
1739 get_mem_ptr(uint32_t addr
, uint32_t size
)
1741 if ((addr
+ size
) < ROM_SZ
) {
1743 } else if ((addr
>= mem_ramstart
) && ((addr
+ size
) < mem_ramend
)) {
1744 return &ramb
[addr
& mem_rammask
];
1748 else if ((era
) && ((addr
<0x100000) ||
1749 ((addr
>= (unsigned) 0x80000000) && ((addr
+ size
) < (unsigned) 0x80100000)))) {
1750 return &romb
[addr
& ROM_MASK
];
1758 sis_memory_write(uint32_t addr
, const void *data
, uint32_t length
)
1762 if ((mem
= get_mem_ptr(addr
, length
)) == ((void *) -1))
1765 memcpy(mem
, data
, length
);
1770 sis_memory_read(uint32_t addr
, void *data
, uint32_t length
)
1774 if ((mem
= get_mem_ptr(addr
, length
)) == ((void *) -1))
1777 memcpy(data
, mem
, length
);
1781 extern struct pstate sregs
;
1786 mec_write(MEC_WCR
, 0); /* zero waitstates */
1787 mec_write(MEC_TRAPD
, 0); /* turn off watch-dog */
1788 mec_write(MEC_RTC_SCALER
, sregs
.freq
- 1); /* generate 1 MHz RTC tick */
1789 mec_write(MEC_MEMCFG
, (3 << 18) | (4 << 10)); /* 1 MB ROM, 4 MB RAM */
1791 sregs
.psr
= 0x110010e0;
1792 sregs
.r
[30] = RAM_END
;
1793 sregs
.r
[14] = sregs
.r
[30] - 96 * 4;
1794 mec_mcr
|= 1; /* power-down enabled */