![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun3-mainbus.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / machine / sun3|
Return to sun3-mainbus.c CVS log | Up to [The Machine Emulator] / tme / machine / sun3 |
1.1 root 1: /* $Id: sun3-mainbus.c,v 1.4 2005/05/11 00:14:30 fredette Exp $ */
2:
3: /* machine/sun3/sun3-mainbus.c - implementation of Sun 3 emulation: */
4:
5: /*
6: * Copyright (c) 2003, 2004 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: sun3-mainbus.c,v 1.4 2005/05/11 00:14:30 fredette Exp $");
38:
39: /* includes: */
40: #include "sun3-impl.h"
41: #include <tme/ic/z8530.h>
42: #include <tme/ic/isil7170.h>
43: #include <stdio.h>
44:
45: /* macros: */
46: #define TME_BUS_SIGNAL_INT_CLOCK TME_BUS_SIGNAL_INT(8)
47:
48: /* this possibly updates that the interrupt priority level driven to the CPU: */
49: int
50: _tme_sun3_ipl_check(struct tme_sun3 *sun3)
51: {
52: tme_uint8_t interreg;
53: unsigned int ipl, ipl_index;
54: tme_uint8_t ipl_mask;
55:
56: /* get the interrupt register: */
57: interreg = sun3->tme_sun3_ints;
58:
59: /* assume that interrupts are completely masked: */
60: ipl = TME_M68K_IPL_NONE;
61:
62: /* if interrupts are enabled: */
63: if (interreg & TME_SUN3_IREG_INTS_ENAB) {
64:
65: /* find the highest ipl now asserted on the buses: */
66: for (ipl = TME_M68K_IPL_MAX;
67: ipl > TME_M68K_IPL_NONE;
68: ipl--) {
69: ipl_index = ipl >> 3;
70: ipl_mask = TME_BIT(ipl & 7);
71: if (sun3->tme_sun3_int_signals[ipl_index] & ipl_mask) {
72: break;
73: }
74: }
75:
76: /* check the soft interrupts: */
77: if (interreg & TME_SUN3_IREG_SOFT_INT_3) {
78: ipl = TME_MAX(ipl, 3);
79: }
80: else if (interreg & TME_SUN3_IREG_SOFT_INT_2) {
81: ipl = TME_MAX(ipl, 2);
82: }
83: else if (interreg & TME_SUN3_IREG_SOFT_INT_1) {
84: ipl = TME_MAX(ipl, 1);
85: }
86: }
87:
88: /* possibly update the CPU: */
89: if (ipl != sun3->tme_sun3_int_ipl_last) {
90: sun3->tme_sun3_int_ipl_last = ipl;
91: return ((*sun3->tme_sun3_m68k->tme_m68k_bus_interrupt)
92: (sun3->tme_sun3_m68k, ipl));
93: }
94: return (TME_OK);
95: }
96:
97: /* our mainbus signal handler: */
98: static int
99: _tme_sun3_bus_signal(struct tme_bus_connection *conn_bus_raiser, unsigned int signal)
100: {
101: struct tme_sun3 *sun3;
102: int signal_asserted;
103: unsigned int ipl, ipl_index;
104: tme_uint8_t ipl_mask;
105:
106: /* recover our sun3: */
107: sun3 = (struct tme_sun3 *) conn_bus_raiser->tme_bus_connection.tme_connection_element->tme_element_private;
108:
109: /* see whether the signal is asserted or negated: */
110: signal_asserted = TRUE;
111: switch (signal & TME_BUS_SIGNAL_LEVEL_MASK) {
112: case TME_BUS_SIGNAL_LEVEL_NEGATED:
113: signal_asserted = FALSE;
114: case TME_BUS_SIGNAL_LEVEL_ASSERTED:
115: break;
116: default:
117: abort();
118: }
119: signal = TME_BUS_SIGNAL_WHICH(signal);
120:
121: /* ipl 8 doesn't really exist - it's the interrupt signal from the
122: isil7170. we must map it into either ipl 7 (NMI) or ipl 5
123: (clock) depending on the state of the interrupt register: */
124: if (signal == TME_BUS_SIGNAL_INT_CLOCK) {
125:
126: /* if the signal is being asserted: */
127: if (signal_asserted) {
128:
129: /* map the interrupt signal: */
130: if (sun3->tme_sun3_ints & TME_SUN3_IREG_CLOCK_ENAB_5) {
131: signal = TME_BUS_SIGNAL_INT(5);
132: }
133: else if (sun3->tme_sun3_ints & TME_SUN3_IREG_CLOCK_ENAB_7) {
134: signal = TME_BUS_SIGNAL_INT(7);
135: }
136: else {
137: /* the clock interrupt isn't connected to any ipl: */
138: signal = TME_BUS_SIGNAL_INT_UNSPEC;
139: }
140:
141: /* remember the last clock interrupt signal: */
142: sun3->tme_sun3_int_signal_clock_last = signal;
143: }
144:
145: else {
146:
147: /* recover the last clock interrupt signal: */
148: signal = sun3->tme_sun3_int_signal_clock_last;
149: }
150:
151: /* if we're supposed to ignore this signal: */
152: if (signal == TME_BUS_SIGNAL_INT_UNSPEC) {
153: return (TME_OK);
154: }
155: }
156:
157: /* dispatch on the signal: */
158:
159: /* halt: */
160: if (signal == TME_BUS_SIGNAL_HALT) {
161: abort();
162: }
163:
164: /* reset: */
165: else if (signal == TME_BUS_SIGNAL_RESET) {
166: /* XXX reset is just ignored for now: */
167: }
168:
169: /* an interrupt signal: */
170: else if (TME_BUS_SIGNAL_IS_INT(signal)) {
171: ipl = TME_BUS_SIGNAL_INDEX_INT(signal);
172: if (ipl >= TME_M68K_IPL_MIN
173: && ipl <= TME_M68K_IPL_MAX) {
174:
175: /* update this ipl in the byte array: */
176: ipl_index = ipl >> 3;
177: ipl_mask = TME_BIT(ipl & 7);
178: sun3->tme_sun3_int_signals[ipl_index]
179: = ((sun3->tme_sun3_int_signals[ipl_index]
180: & ~ipl_mask)
181: | (signal_asserted
182: ? ipl_mask
183: : 0));
184:
185: /* possibly update the ipl being driven to the CPU: */
186: return (_tme_sun3_ipl_check(sun3));
187: }
188: }
189:
190: /* an unknown signal: */
191: else {
192: abort();
193: }
194:
195: return (TME_OK);
196: }
197:
198: /* this handles a CPU interrupt acknowledge: */
199: static int
200: _tme_sun3_bus_intack(struct tme_bus_connection *conn_m68k, unsigned int ipl, int *vector)
201: {
202: struct tme_sun3 *sun3;
203: tme_uint8_t interreg;
204: unsigned int signal;
205: int rc;
206:
207: /* recover our sun3: */
208: sun3 = (struct tme_sun3 *) conn_m68k->tme_bus_connection.tme_connection_element->tme_element_private;
209:
210: /* acknowledge any soft interrupt: */
211: interreg = sun3->tme_sun3_ints;
212: if ((ipl == 3
213: && (interreg & TME_SUN3_IREG_SOFT_INT_3))
214: || (ipl == 2
215: && (interreg & TME_SUN3_IREG_SOFT_INT_2))
216: || (ipl == 1
217: && (interreg & TME_SUN3_IREG_SOFT_INT_1))) {
218: *vector = TME_BUS_INTERRUPT_VECTOR_UNDEF;
219: return (TME_OK);
220: }
221:
222: /* turn the ipl into a bus signal number: */
223: signal = TME_BUS_SIGNAL_INT(ipl);
224:
225: /* try the acknowledge on these buses, in order: */
226:
227: /* obio: */
228: rc = (*sun3->tme_sun3_obio->tme_bus_intack)
229: (sun3->tme_sun3_obio, signal, vector);
230: if (rc == ENOENT
231: && signal == sun3->tme_sun3_int_signal_clock_last) {
232: rc = (*sun3->tme_sun3_obio->tme_bus_intack)
233: (sun3->tme_sun3_obio, TME_BUS_SIGNAL_INT_CLOCK, vector);
234: }
235: if (rc != ENOENT) {
236: return (rc);
237: }
238: /* obmem: */
239: rc = (*sun3->tme_sun3_obmem->tme_bus_intack)
240: (sun3->tme_sun3_obmem, signal, vector);
241: if (rc != ENOENT) {
242: return (rc);
243: }
244: /* VMEbus: */
245: rc = (*sun3->tme_sun3_vmebus->tme_bus_intack)
246: (sun3->tme_sun3_vmebus, signal, vector);
247: if (rc != ENOENT) {
248: return (rc);
249: }
250:
251: /* done: */
252: return (rc);
253: }
254:
255: /* our command function: */
256: static int
257: _tme_sun3_command(struct tme_element *element, const char * const * args, char **_output)
258: {
259: struct tme_sun3 *sun3;
260: int do_reset;
261:
262: /* recover our sun3: */
263: sun3 = (struct tme_sun3 *) element->tme_element_private;
264:
265: /* assume no reset: */
266: do_reset = FALSE;
267:
268: /* the "power" command: */
269: if (TME_ARG_IS(args[1], "power")) {
270:
271: if (TME_ARG_IS(args[2], "up")
272: && args[3] == NULL) {
273: do_reset = TRUE;
274: }
275:
276: else if (TME_ARG_IS(args[2], "down")
277: && args[3] == NULL) {
278: /* nothing */
279: }
280:
281: /* return an error: */
282: else {
283: tme_output_append_error(_output,
284: "%s %s power [ up | down ]",
285: _("usage:"),
286: args[0]);
287: return (EINVAL);
288: }
289: }
290:
291: /* the "diag-switch" command: */
292: else if (TME_ARG_IS(args[1], "diag-switch")) {
293:
294: if (args[2] == NULL) {
295: tme_output_append_error(_output,
296: "diag-switch %s",
297: (sun3->tme_sun3_enable & TME_SUN3_ENA_DIAG
298: ? "true"
299: : "false"));
300: }
301:
302: else if (TME_ARG_IS(args[2], "true")
303: && args[3] == NULL) {
304: sun3->tme_sun3_enable |= TME_SUN3_ENA_DIAG;
305: }
306:
307: else if (TME_ARG_IS(args[2], "false")
308: && args[3] == NULL) {
309: sun3->tme_sun3_enable &= ~TME_SUN3_ENA_DIAG;
310: }
311:
312: /* return an error: */
313: else {
314: tme_output_append_error(_output,
315: "%s %s diag-switch [ true | false ]",
316: _("usage:"),
317: args[0]);
318: return (EINVAL);
319: }
320: }
321:
322: /* any other command: */
323: else {
324: if (args[1] != NULL) {
325: tme_output_append_error(_output,
326: "%s '%s', ",
327: _("unknown command"),
328: args[1]);
329: }
330: tme_output_append_error(_output,
331: _("available %s commands: %s"),
332: args[0],
333: "power");
334: return (EINVAL);
335: }
336:
337: if (do_reset) {
338:
339: /* reset the CPU: */
340: (*sun3->tme_sun3_m68k->tme_m68k_bus_connection.tme_bus_signal)
341: (&sun3->tme_sun3_m68k->tme_m68k_bus_connection,
342: TME_BUS_SIGNAL_RESET
343: | TME_BUS_SIGNAL_LEVEL_NEGATED
344: | TME_BUS_SIGNAL_EDGE);
345:
346: /* reset all busses: */
347: (*sun3->tme_sun3_obio->tme_bus_signal)
348: (sun3->tme_sun3_obio,
349: TME_BUS_SIGNAL_RESET
350: | TME_BUS_SIGNAL_LEVEL_NEGATED
351: | TME_BUS_SIGNAL_EDGE);
352: (*sun3->tme_sun3_obmem->tme_bus_signal)
353: (sun3->tme_sun3_obmem,
354: TME_BUS_SIGNAL_RESET
355: | TME_BUS_SIGNAL_LEVEL_NEGATED
356: | TME_BUS_SIGNAL_EDGE);
357: (*sun3->tme_sun3_vmebus->tme_bus_signal)
358: (sun3->tme_sun3_obmem,
359: TME_BUS_SIGNAL_RESET
360: | TME_BUS_SIGNAL_LEVEL_NEGATED
361: | TME_BUS_SIGNAL_EDGE);
362: }
363:
364: return (TME_OK);
365: }
366:
367: /* the connection scorer: */
368: static int
369: _tme_sun3_connection_score(struct tme_connection *conn, unsigned int *_score)
370: {
371: struct tme_m68k_bus_connection *conn_m68k;
372: struct tme_sun3_bus_connection *conn_sun3;
373: struct tme_bus_connection *conn_bus;
374: struct tme_sun3 *sun3;
375: unsigned int score;
376:
377: /* recover our sun3: */
378: sun3 = (struct tme_sun3 *) conn->tme_connection_element->tme_element_private;
379:
380: /* assume that this connection is useless: */
381: score = 0;
382:
383: /* dispatch on the connection type: */
384: conn_m68k = (struct tme_m68k_bus_connection *) conn->tme_connection_other;
385: conn_sun3 = (struct tme_sun3_bus_connection *) conn;
386: conn_bus = (struct tme_bus_connection *) conn->tme_connection_other;
387: switch (conn->tme_connection_type) {
388:
389: /* this must be an m68k chip, and not another bus: */
390: case TME_CONNECTION_BUS_M68K:
391: if (conn_bus->tme_bus_tlb_set_allocate == NULL
392: && conn_m68k->tme_m68k_bus_tlb_fill == NULL
393: && conn_m68k->tme_m68k_bus_m6888x_enable != NULL) {
394: score = 10;
395: }
396: break;
397:
398: /* if this connection is not for an obio master, this must be a bus,
399: and not a chip, and vice versa. if this connection is for a bus,
400: the bus must still be free: */
401: case TME_CONNECTION_BUS_GENERIC:
402: if (((conn_sun3->tme_sun3_bus_connection_which != TME_SUN3_CONN_OBIO_MASTER)
403: == (conn_bus->tme_bus_tlb_set_allocate != NULL
404: && conn_bus->tme_bus_tlb_fill != NULL))
405: && (conn_sun3->tme_sun3_bus_connection_which >= TME_SUN3_CONN_BUS_COUNT
406: || sun3->tme_sun3_buses[conn_sun3->tme_sun3_bus_connection_which] == NULL)) {
407: score = 1;
408: }
409: break;
410:
411: default: abort();
412: }
413:
414: *_score = score;
415: return (TME_OK);
416: }
417:
418: /* this makes a new connection: */
419: static int
420: _tme_sun3_connection_make(struct tme_connection *conn, unsigned int state)
421: {
422: struct tme_sun3 *sun3;
423: struct tme_m68k_bus_connection *conn_m68k;
424: struct tme_sun3_bus_connection *conn_sun3;
425: struct tme_bus_connection *conn_bus;
426: struct tme_connection *conn_other;
427:
428: /* recover our sun3: */
429: sun3 = (struct tme_sun3 *) conn->tme_connection_element->tme_element_private;
430:
431: /* dispatch on the connection type: */
432: conn_other = conn->tme_connection_other;
433: conn_m68k = (struct tme_m68k_bus_connection *) conn_other;
434: conn_sun3 = (struct tme_sun3_bus_connection *) conn;
435: conn_bus = (struct tme_bus_connection *) conn_other;
436: switch (conn->tme_connection_type) {
437:
438: case TME_CONNECTION_BUS_M68K:
439: sun3->tme_sun3_m68k = conn_m68k;
440: break;
441:
442: case TME_CONNECTION_BUS_GENERIC:
443:
444: /* if this connection is for a bus: */
445: if (conn_sun3->tme_sun3_bus_connection_which < TME_SUN3_CONN_BUS_COUNT) {
446:
447: /* remember the connection to this bus: */
448: sun3->tme_sun3_buses[conn_sun3->tme_sun3_bus_connection_which] = conn_bus;
449: }
450:
451: /* otherwise, if this connection is for the memory error register: */
452: else if (conn_sun3->tme_sun3_bus_connection_which == TME_SUN3_CONN_REG_MEMERR) {
453:
454: /* remember the memory error register's bus connection: */
455: sun3->tme_sun3_memerr_bus = conn_bus;
456: }
457:
458: break;
459:
460: default:
461: assert(FALSE);
462: break;
463: }
464: return (TME_OK);
465: }
466:
467: /* this breaks a connection: */
468: static int
469: _tme_sun3_connection_break(struct tme_connection *conn, unsigned int state)
470: {
471: abort();
472: }
473:
474: /* this makes new connection sides: */
475: static int
476: _tme_sun3_connections_new(struct tme_element *element, const char * const *args, struct tme_connection **_conns, char **_output)
477: {
478: struct tme_m68k_bus_connection *conn_m68k;
479: struct tme_sun3_bus_connection *conn_sun3;
480: struct tme_bus_connection *conn_bus;
481: struct tme_connection *conn;
482: struct tme_sun3 *sun3;
483: char *free_buses;
484: int which_conn;
485:
486: /* recover our sun3: */
487: sun3 = (struct tme_sun3 *) element->tme_element_private;
488:
489: /* if we have no arguments, and we don't have a CPU yet, we can take
490: an m68k bus connection: */
491: if (args[1] == NULL
492: && sun3->tme_sun3_m68k == NULL) {
493:
494: /* create our side of an m68k bus connection: */
495: conn_m68k = tme_new0(struct tme_m68k_bus_connection, 1);
496: conn_bus = &conn_m68k->tme_m68k_bus_connection;
497: conn = &conn_bus->tme_bus_connection;
498: conn->tme_connection_next = *_conns;
499:
500: /* fill in the generic connection: */
501: conn->tme_connection_type = TME_CONNECTION_BUS_M68K;
502: conn->tme_connection_score = _tme_sun3_connection_score;
503: conn->tme_connection_make = _tme_sun3_connection_make;
504: conn->tme_connection_break = _tme_sun3_connection_break;
505:
506: /* fill in the generic bus connection: */
507: conn_bus->tme_bus_signal = _tme_sun3_bus_signal;
508: conn_bus->tme_bus_intack = _tme_sun3_bus_intack;
509: conn_bus->tme_bus_tlb_set_allocate = _tme_sun3_mmu_tlb_set_allocate;
510:
511: /* full in the m68k bus connection: */
512: conn_m68k->tme_m68k_bus_tlb_fill = _tme_sun3_m68k_tlb_fill;
513:
514: /* add in this connection side possibility: */
515: *_conns = conn;
516: }
517:
518: /* create our side of a generic bus connection: */
519: conn_sun3 = tme_new0(struct tme_sun3_bus_connection, 1);
520: conn_bus = &conn_sun3->tme_sun3_bus_connection;
521: conn = &conn_bus->tme_bus_connection;
522: conn->tme_connection_next = *_conns;
523:
524: /* fill in the generic connection: */
525: conn->tme_connection_type = TME_CONNECTION_BUS_GENERIC;
526: conn->tme_connection_score = _tme_sun3_connection_score;
527: conn->tme_connection_make = _tme_sun3_connection_make;
528: conn->tme_connection_break = _tme_sun3_connection_break;
529:
530: /* fill in the generic bus connection: */
531: conn_bus->tme_bus_signal = _tme_sun3_bus_signal;
532: conn_bus->tme_bus_intack = NULL;
533: conn_bus->tme_bus_tlb_set_allocate = _tme_sun3_mmu_tlb_set_allocate;
534: conn_bus->tme_bus_tlb_fill = _tme_sun3_bus_tlb_fill;
535:
536: /* if we have no argument: */
537: if (args[1] == NULL) {
538:
539: /* make this connection for an obio master: */
540: conn_sun3->tme_sun3_bus_connection_which = TME_SUN3_CONN_OBIO_MASTER;
541: }
542:
543: /* otherwise, we have at least one argument: */
544: else {
545:
546: /* we must have no other arguments: */
547: if (args[2] != NULL) {
548: tme_output_append_error(_output,
549: "%s %s",
550: args[2],
551: _("unexpected"));
552: tme_free(conn_sun3);
553: return (EINVAL);
554: }
555:
556: /* start the list of buses that we don't have yet: */
557: free_buses = NULL;
558:
559: /* poison the which connection: */
560: which_conn = -1;
561:
562: /* check each bus: */
563:
564: /* obio: */
565: if (sun3->tme_sun3_obio == NULL) {
566: tme_output_append(&free_buses, " obio");
567: }
568: if (TME_ARG_IS(args[1], "obio")) {
569: which_conn = TME_SUN3_CONN_BUS_OBIO;
570: }
571:
572: /* obmem: */
573: if (sun3->tme_sun3_obmem == NULL) {
574: tme_output_append(&free_buses, " obmem");
575: }
576: if (TME_ARG_IS(args[1], "obmem")) {
577: which_conn = TME_SUN3_CONN_BUS_OBMEM;
578: }
579:
580: /* VMEbus: */
581: if (sun3->tme_sun3_vmebus == NULL) {
582: tme_output_append(&free_buses, " vme");
583: }
584: if (TME_ARG_IS(args[1], "vme")) {
585: which_conn = TME_SUN3_CONN_BUS_VME;
586: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last
587: = TME_SUN3_DVMA_SIZE_VME;
588: }
589:
590: /* random connections: */
591:
592: if (TME_ARG_IS(args[1], "memerr")) {
593: which_conn = TME_SUN3_CONN_REG_MEMERR;
594: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last
595: = TME_SUN3_MEMERR_SIZ_REG;
596: }
597: else if (TME_ARG_IS(args[1], "intreg")) {
598: which_conn = TME_SUN3_CONN_REG_INTREG;
599: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last
600: = sizeof(sun3->tme_sun3_ints);
601: }
602:
603: /* if the which connection is still poison, or if this is trying
604: to connect a bus that we already have, complain: */
605: if (which_conn < 0
606: || (which_conn < TME_SUN3_CONN_BUS_COUNT
607: && sun3->tme_sun3_buses[which_conn] != NULL)) {
608: if (which_conn < 0) {
609: tme_output_append_error(_output,
610: "%s %s",
611: _("unknown bus or register:"),
612: args[1]);
613: }
614: if (free_buses != NULL) {
615: tme_output_append_error(_output,
616: "%s %s",
617: _("remaining buses:"),
618: free_buses);
619: tme_free(free_buses);
620: }
621: else {
622: tme_output_append_error(_output, _("all buses present"));
623: }
624: tme_free(conn_sun3);
625: return (EINVAL);
626: }
627:
628: /* free the remaining bus list: */
629: if (free_buses != NULL) {
630: tme_free(free_buses);
631: }
632:
633: /* fill in the sun3 connection: */
634: conn_sun3->tme_sun3_bus_connection_which = which_conn;
635: }
636:
637: /* add in this connection side possibility: */
638: *_conns = conn;
639:
640: /* done: */
641: return (TME_OK);
642: }
643:
644: /* this creates a new sun3 element: */
645: TME_ELEMENT_NEW_DECL(tme_machine_sun3) {
646: int usage;
647: struct tme_sun3 *sun3;
648: const char *idprom_filename;
649: FILE *idprom_fp;
650: tme_uint8_t idprom[TME_SUN_IDPROM_SIZE];
651: int arg_i;
652:
653: arg_i = 1;
654: usage = FALSE;
655:
656: /* our first argument is the filename to load our IDPROM contents from: */
657: idprom_filename = args[arg_i++];
658: if (idprom_filename == NULL) {
659: usage = TRUE;
660: }
661:
662: /* we must have no more arguments: */
663: if (args[arg_i] != NULL) {
664: tme_output_append_error(_output,
665: "%s %s, ",
666: args[arg_i],
667: _("unexpected"));
668: usage = TRUE;
669: }
670:
671: /* if our usage was bad: */
672: if (usage) {
673: tme_output_append_error(_output,
674: "%s %s IDPROM%s",
675: _("usage:"),
676: args[0],
677: _("-FILENAME"));
678: return (EINVAL);
679: }
680:
681: /* try to read in the IDPROM: */
682: idprom_fp = fopen(idprom_filename, "r");
683: if (idprom_fp == NULL) {
684: tme_output_append_error(_output, idprom_filename);
685: return (errno);
686: }
687: if (fread(idprom, sizeof(tme_uint8_t), sizeof(idprom), idprom_fp) != sizeof(idprom)) {
688: tme_output_append_error(_output, idprom_filename);
689: fclose(idprom_fp);
690: return (ENOEXEC);
691: }
692: fclose(idprom_fp);
693:
694: /* allocate and initialize the new sun3: */
695: sun3 = tme_new0(struct tme_sun3, 1);
696: sun3->tme_sun3_element = element;
697:
698: /* set the IDPROM: */
699: memcpy(sun3->tme_sun3_idprom_contents, idprom, sizeof(idprom));
700:
701: /* the context register: */
702: sun3->tme_sun3_context = 0;
703:
704: /* the diagnostics register: */
705: sun3->tme_sun3_diag = 0;
706:
707: /* the bus error register: */
708: sun3->tme_sun3_buserr = 0;
709:
710: /* the enable register: */
711: sun3->tme_sun3_enable = 0;
712:
713: /* the memory error register: */
714: sun3->tme_sun3_memerr_csr = 0;
715: sun3->tme_sun3_memerr_vaddr = 0;
716:
717: /* the interrupt register: */
718: sun3->tme_sun3_ints = 0;
719:
720: /* the MMU: */
721: _tme_sun3_mmu_new(sun3);
722:
723: /* the busses: */
724: sun3->tme_sun3_obio = NULL;
725: sun3->tme_sun3_obmem = NULL;
726: sun3->tme_sun3_vmebus = NULL;
727:
728: /* the last clock interrupt signal: */
729: sun3->tme_sun3_int_signal_clock_last = TME_BUS_SIGNAL_INT_UNSPEC;
730:
731: /* fill the element: */
732: element->tme_element_private = sun3;
733: element->tme_element_connections_new = _tme_sun3_connections_new;
734: element->tme_element_command = _tme_sun3_command;
735:
736: return (TME_OK);
737: }
738:
739: /* this creates a new Sun-3 isil7170: */
740: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,clock) {
741: struct tme_isil7170_socket socket;
742: const char *sub_args[4];
743: int arg_i;
744:
745: /* create the isil7170 socket: */
746: memset (&socket, 0, sizeof(socket));
747: socket.tme_isil7170_socket_version = TME_ISIL7170_SOCKET_0;
748: socket.tme_isil7170_socket_addr_shift = 0;
749: socket.tme_isil7170_socket_port_least_lane = 3; /* D31-D24 */
750: socket.tme_isil7170_socket_clock_basic = TME_ISIL7170_FREQ_32K;
751: socket.tme_isil7170_socket_int_signal = TME_BUS_SIGNAL_INT_CLOCK;
752:
753: /* create the isil7170. we allow at most two arguments to pass
754: through, which is an awful hack: */
755: sub_args[0] = "tme/ic/isil7170";
756: for (arg_i = 1;; arg_i++) {
757: if (arg_i == TME_ARRAY_ELS(sub_args)) {
758: abort();
759: }
760: sub_args[arg_i] = args[arg_i];
761: if (args[arg_i] == NULL) {
762: break;
763: }
764: }
765: return (tme_element_new(element, (const char * const *) sub_args, &socket, _output));
766: }
767:
768: /* this creates a new Sun-3 z8530: */
769: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,zs) {
770: struct tme_z8530_socket socket = TME_SUN_Z8530_SOCKET_INIT;
771: char *sub_args[2];
772:
773: /* create the z8530: */
774: sub_args[0] = "tme/ic/z8530";
775: sub_args[1] = NULL;
776: return (tme_element_new(element, (const char * const *) sub_args, &socket, _output));
777: }
778:
779: /* this creates a new Sun-3 obie: */
780: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,obie) {
781: return (tme_sun_obie(element, args, _output));
782: }
783:
784: /* this creates a new Sun-3 bwtwo: */
785: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,bwtwo) {
786: return (tme_sun_bwtwo(element, args, _output));
787: }
788:
789: /* this creates a new Sun-3 si: */
790: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,si) {
791: return (tme_sun_si(element, args, _output));
792: }
793:
794: /* this creates a new Sun-3 cgtwo: */
795: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun3,cgtwo) {
796: return (tme_sun_cgtwo(element, args, _output));
797: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.