![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun4-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 / sun4|
Return to sun4-mainbus.c CVS log | Up to [The Machine Emulator] / tme / machine / sun4 |
1.1.1.2 ! root 1: /* $Id: sun4-mainbus.c,v 1.6 2009/08/30 14:03:11 fredette Exp $ */ 1.1 root 2: 3: /* machine/sun4/sun4-mainbus.c - implementation of Sun 4 emulation: */ 4: 5: /* 6: * Copyright (c) 2003, 2004, 2006 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> 1.1.1.2 ! root 37: _TME_RCSID("$Id: sun4-mainbus.c,v 1.6 2009/08/30 14:03:11 fredette Exp $"); 1.1 root 38: 39: /* includes: */ 40: #include "sun4-impl.h" 41: #include <tme/ic/z8530.h> 42: #include <tme/ic/isil7170.h> 43: #include <tme/ic/mk48txx.h> 44: #include <stdio.h> 45: 46: /* this possibly updates that the interrupt priority level driven to the CPU: */ 47: int 48: _tme_sun4_ipl_check(struct tme_sun4 *sun4) 49: { 50: unsigned int ipl; 51: unsigned int ipl_index; 52: tme_uint8_t ipl_mask; 53: tme_uint32_t interreg; 54: int rc; 55: 56: /* find the highest ipl now asserted on the buses, that is enabled 57: to the CPU: */ 58: ipl = TME_SPARC_IPL_MAX; 59: ipl_index = ipl / 8; 60: ipl_mask = TME_BIT(ipl % 8); 61: do { 62: 63: /* if this ipl is asserted: */ 64: if ((sun4->tme_sun4_int_signals[ipl_index] & ipl_mask) != 0) { 65: 66: /* if this ipl is not disabled: */ 67: if (TME_SUN4_IS_SUN44C(sun4) 68: ? ((sun4->tme_sun44c_ints & TME_SUN44C_IREG_INTS_ENAB) 69: && (ipl != 10 || (sun4->tme_sun44c_ints & TME_SUN44C_IREG_COUNTER_L10)) 70: && (ipl != 14 || (sun4->tme_sun44c_ints & TME_SUN44C_IREG_COUNTER_L14))) 71: : TRUE) { 72: 73: /* stop now: */ 74: break; 75: } 76: } 77: 78: /* advance to the next ipl: */ 79: ipl--; 80: ipl_mask >>= 1; 81: if (ipl_mask == 0) { 82: ipl_mask = 0x80; 83: ipl_index--; 84: } 85: } while (ipl != TME_SPARC_IPL_NONE); 86: 87: /* if this is a sun4 or sun4c: */ 88: if (TME_SUN4_IS_SUN44C(sun4)) { 89: 90: /* get the sun4/4c interrupt register: */ 91: interreg = sun4->tme_sun44c_ints; 92: 93: /* if interrupts are enabled: */ 94: if (interreg & TME_SUN44C_IREG_INTS_ENAB) { 95: 96: /* check the soft interrupts: */ 97: if (interreg & TME_SUN44C_IREG_SOFT_INT_L6) { 98: ipl = TME_MAX(ipl, 6); 99: } 100: else if (interreg & TME_SUN44C_IREG_SOFT_INT_L4) { 101: ipl = TME_MAX(ipl, 4); 102: } 103: else if (interreg & TME_SUN44C_IREG_SOFT_INT_L1) { 104: ipl = TME_MAX(ipl, 1); 105: } 106: } 107: } 108: 109: /* possibly update the CPU: */ 110: if (ipl != sun4->tme_sun4_int_ipl_last) { 111: sun4->tme_sun4_int_ipl_last = ipl; 112: rc = ((*sun4->tme_sun4_sparc->tme_sparc_bus_interrupt) 113: (sun4->tme_sun4_sparc, ipl)); 114: assert (rc == TME_OK); 115: } 116: 117: /* return nonzero if any interrupt is pending: */ 118: return (ipl != TME_SPARC_IPL_NONE); 119: } 120: 121: /* our mainbus signal handler: */ 122: static int 123: _tme_sun4_bus_signal(struct tme_bus_connection *conn_bus_raiser, unsigned int signal) 124: { 125: struct tme_sun4 *sun4; 126: int signal_asserted; 127: unsigned int ipl, ipl_index; 128: tme_uint8_t ipl_mask; 129: 130: /* recover our sun4: */ 131: sun4 = (struct tme_sun4 *) conn_bus_raiser->tme_bus_connection.tme_connection_element->tme_element_private; 132: 133: /* see whether the signal is asserted or negated: */ 134: signal_asserted = TRUE; 135: switch (signal & TME_BUS_SIGNAL_LEVEL_MASK) { 136: case TME_BUS_SIGNAL_LEVEL_NEGATED: 137: signal_asserted = FALSE; 138: case TME_BUS_SIGNAL_LEVEL_ASSERTED: 139: break; 140: default: 141: abort(); 142: } 143: signal = TME_BUS_SIGNAL_WHICH(signal); 144: 145: /* dispatch on the signal: */ 146: 147: /* halt: */ 148: if (signal == TME_BUS_SIGNAL_HALT) { 149: abort(); 150: } 151: 152: /* reset: */ 153: else if (signal == TME_BUS_SIGNAL_RESET) { 154: /* XXX reset is just ignored for now: */ 155: } 156: 157: /* an interrupt signal: */ 158: else if (TME_BUS_SIGNAL_IS_INT(signal)) { 159: ipl = TME_BUS_SIGNAL_INDEX_INT(signal); 160: if (ipl >= TME_SPARC_IPL_MIN 161: && ipl <= TME_SPARC_IPL_MAX) { 162: 163: /* update this ipl in the byte array: */ 164: ipl_index = ipl / 8; 165: ipl_mask = TME_BIT(ipl % 8); 166: sun4->tme_sun4_int_signals[ipl_index] 167: = ((sun4->tme_sun4_int_signals[ipl_index] 168: & ~ipl_mask) 169: | (signal_asserted 170: ? ipl_mask 171: : 0)); 172: 173: /* possibly update the ipl being driven to the CPU: */ 174: _tme_sun4_ipl_check(sun4); 175: return (TME_OK); 176: } 177: } 178: 179: /* an unknown signal: */ 180: else { 181: abort(); 182: } 183: 184: return (TME_OK); 185: } 186: 187: /* this handles a CPU interrupt acknowledge: */ 188: static int 189: _tme_sun4_bus_intack(struct tme_bus_connection *conn_sparc, unsigned int ipl, int *vector) 190: { 191: struct tme_sun4 *sun4; 192: tme_uint32_t interreg; 193: unsigned int signal; 194: int rc; 195: 196: /* recover our sun4: */ 197: sun4 = (struct tme_sun4 *) conn_sparc->tme_bus_connection.tme_connection_element->tme_element_private; 198: 199: /* acknowledge any soft interrupt: */ 200: if (TME_SUN4_IS_SUN44C(sun4)) { 201: interreg = sun4->tme_sun44c_ints; 202: if ((ipl == 6 203: && (interreg & TME_SUN44C_IREG_SOFT_INT_L6)) 204: || (ipl == 4 205: && (interreg & TME_SUN44C_IREG_SOFT_INT_L4)) 206: || (ipl == 1 207: && (interreg & TME_SUN44C_IREG_SOFT_INT_L1))) { 208: *vector = TME_BUS_INTERRUPT_VECTOR_UNDEF; 209: return (TME_OK); 210: } 211: } 212: 213: /* turn the ipl into a bus signal number: */ 214: signal = TME_BUS_SIGNAL_INT(ipl); 215: 216: /* try the acknowledge on these buses, in order: */ 217: 218: /* obio: */ 219: rc = (*sun4->tme_sun4_32_obio->tme_bus_intack) 220: (sun4->tme_sun4_32_obio, signal, vector); 221: if (rc != ENOENT) { 222: return (rc); 223: } 224: /* obmem: */ 225: if (!TME_SUN4_IS_SUN4C(sun4)) { 226: rc = (*sun4->tme_sun4_32_obmem->tme_bus_intack) 227: (sun4->tme_sun4_32_obmem, signal, vector); 228: if (rc != ENOENT) { 229: return (rc); 230: } 231: } 232: /* VMEbus: */ 233: if (TME_SUN4_IS_SUN4(sun4)) { 234: rc = (*sun4->tme_sun4_vmebus->tme_bus_intack) 235: (sun4->tme_sun4_vmebus, signal, vector); 236: if (rc != ENOENT) { 237: return (rc); 238: } 239: } 240: 241: /* done: */ 242: return (rc); 243: } 244: 245: /* this resets the board: */ 246: int 247: _tme_sun4_reset(struct tme_sun4 *sun4, int soft) 248: { 249: 250: /* clear the sun4/4c enable register: */ 251: sun4->tme_sun44c_enable = 0; 252: 253: /* clear the sun4/4c interrupt register: */ 254: sun4->tme_sun44c_ints = 0; 255: 256: /* clear any NMI: */ 257: sun4->tme_sun4_int_signals[TME_SPARC_IPL_NMI / 8] &= ~TME_BIT(TME_SPARC_IPL_NMI % 8); 258: 259: /* reset the CPU: */ 260: (*sun4->tme_sun4_sparc->tme_sparc_bus_connection.tme_bus_signal) 261: (&sun4->tme_sun4_sparc->tme_sparc_bus_connection, 262: TME_BUS_SIGNAL_RESET 263: | TME_BUS_SIGNAL_LEVEL_NEGATED 264: | TME_BUS_SIGNAL_EDGE); 265: 266: /* reset all busses: */ 267: (*sun4->tme_sun4_32_obio->tme_bus_signal) 268: (sun4->tme_sun4_32_obio, 269: TME_BUS_SIGNAL_RESET 270: | TME_BUS_SIGNAL_LEVEL_NEGATED 271: | TME_BUS_SIGNAL_EDGE); 272: if (!TME_SUN4_IS_SUN4C(sun4)) { 273: (*sun4->tme_sun4_32_obmem->tme_bus_signal) 274: (sun4->tme_sun4_32_obmem, 275: TME_BUS_SIGNAL_RESET 276: | TME_BUS_SIGNAL_LEVEL_NEGATED 277: | TME_BUS_SIGNAL_EDGE); 278: } 279: if (TME_SUN4_IS_SUN4(sun4)) { 280: (*sun4->tme_sun4_vmebus->tme_bus_signal) 281: (sun4->tme_sun4_vmebus, 282: TME_BUS_SIGNAL_RESET 283: | TME_BUS_SIGNAL_LEVEL_NEGATED 284: | TME_BUS_SIGNAL_EDGE); 285: } 286: 287: /* in case this reset was caused by a bus cycle, be sure to tell the 288: initiator to check for a synchronous event: */ 289: return (TME_BUS_CYCLE_SYNCHRONOUS_EVENT); 290: } 291: 292: /* our command function: */ 293: static int 294: _tme_sun4_command(struct tme_element *element, const char * const * args, char **_output) 295: { 296: struct tme_sun4 *sun4; 297: int do_reset; 298: 299: /* recover our sun4: */ 300: sun4 = (struct tme_sun4 *) element->tme_element_private; 301: 302: /* assume no reset: */ 303: do_reset = FALSE; 304: 305: /* the "power" command: */ 306: if (TME_ARG_IS(args[1], "power")) { 307: 308: if (TME_ARG_IS(args[2], "up") 309: && args[3] == NULL) { 310: do_reset = TRUE; 311: } 312: 313: else if (TME_ARG_IS(args[2], "down") 314: && args[3] == NULL) { 315: /* nothing */ 316: } 317: 318: /* return an error: */ 319: else { 320: tme_output_append_error(_output, 321: "%s %s power [ up | down ]", 322: _("usage:"), 323: args[0]); 324: return (EINVAL); 325: } 326: } 327: 328: /* the "diag-switch" command: */ 329: else if (TME_SUN4_IS_SUN4(sun4) 330: && TME_ARG_IS(args[1], "diag-switch")) { 331: 332: if (args[2] == NULL) { 333: tme_output_append_error(_output, 334: "diag-switch %s", 335: (sun4->tme_sun44c_enable & TME_SUN4_ENA_DIAG 336: ? "true" 337: : "false")); 338: } 339: 340: else if (TME_ARG_IS(args[2], "true") 341: && args[3] == NULL) { 342: sun4->tme_sun44c_enable |= TME_SUN4_ENA_DIAG; 343: } 344: 345: else if (TME_ARG_IS(args[2], "false") 346: && args[3] == NULL) { 347: sun4->tme_sun44c_enable &= ~TME_SUN4_ENA_DIAG; 348: } 349: 350: /* return an error: */ 351: else { 352: tme_output_append_error(_output, 353: "%s %s diag-switch [ true | false ]", 354: _("usage:"), 355: args[0]); 356: return (EINVAL); 357: } 358: } 359: 360: /* any other command: */ 361: else { 362: if (args[1] != NULL) { 363: tme_output_append_error(_output, 364: "%s '%s', ", 365: _("unknown command"), 366: args[1]); 367: } 368: tme_output_append_error(_output, 369: _("available %s commands: %s%s"), 370: args[0], 371: "power", 372: (TME_SUN4_IS_SUN4(sun4) 373: ? "diag-switch" 374: : "")); 375: return (EINVAL); 376: } 377: 378: if (do_reset) { 379: _tme_sun4_reset(sun4, FALSE); 380: } 381: 382: return (TME_OK); 383: } 384: 385: /* the connection scorer: */ 386: static int 387: _tme_sun4_connection_score(struct tme_connection *conn, unsigned int *_score) 388: { 389: struct tme_sparc_bus_connection *conn_sparc; 390: struct tme_sun4_bus_connection *conn_sun4; 391: struct tme_bus_connection *conn_bus; 392: struct tme_sun4 *sun4; 393: unsigned int score; 394: 395: /* recover our sun4: */ 396: sun4 = (struct tme_sun4 *) conn->tme_connection_element->tme_element_private; 397: 398: /* assume that this connection is useless: */ 399: score = 0; 400: 401: /* dispatch on the connection type: */ 402: conn_sparc = (struct tme_sparc_bus_connection *) conn->tme_connection_other; 403: conn_sun4 = (struct tme_sun4_bus_connection *) conn; 404: conn_bus = (struct tme_bus_connection *) conn->tme_connection_other; 405: switch (conn->tme_connection_type) { 406: 407: /* this must be an SPARC chip, and not another bus: */ 408: case TME_CONNECTION_BUS_SPARC: 1.1.1.2 ! root 409: if (conn_bus->tme_bus_tlb_set_add == NULL 1.1 root 410: && conn_sparc->tme_sparc_bus_tlb_fill == NULL 411: && conn_sparc->tme_sparc_bus_fpu_strict != NULL) { 412: score = 10; 413: } 414: break; 415: 416: /* this must be a bus, and not a chip, and the bus must still be 417: free: */ 418: case TME_CONNECTION_BUS_GENERIC: 1.1.1.2 ! root 419: if ((conn_bus->tme_bus_tlb_set_add != NULL 1.1 root 420: && conn_bus->tme_bus_tlb_fill != NULL) 421: && (conn_sun4->tme_sun4_bus_connection_which >= TME_SUN4_32_CONN_BUS_COUNT 422: || sun4->tme_sun4_buses[conn_sun4->tme_sun4_bus_connection_which] == NULL)) { 423: score = 1; 424: } 425: break; 426: 427: default: abort(); 428: } 429: 430: *_score = score; 431: return (TME_OK); 432: } 433: 434: /* this makes a new connection: */ 435: static int 436: _tme_sun4_connection_make(struct tme_connection *conn, unsigned int state) 437: { 438: struct tme_sun4 *sun4; 439: struct tme_sparc_bus_connection *conn_sparc; 440: struct tme_sun4_bus_connection *conn_sun4; 441: struct tme_bus_connection *conn_bus; 442: struct tme_connection *conn_other; 443: 444: /* recover our sun4: */ 445: sun4 = (struct tme_sun4 *) conn->tme_connection_element->tme_element_private; 446: 447: /* dispatch on the connection type: */ 448: conn_other = conn->tme_connection_other; 449: conn_sparc = (struct tme_sparc_bus_connection *) conn_other; 450: conn_sun4 = (struct tme_sun4_bus_connection *) conn; 451: conn_bus = (struct tme_bus_connection *) conn_other; 452: switch (conn->tme_connection_type) { 453: 454: case TME_CONNECTION_BUS_SPARC: 455: sun4->tme_sun4_sparc = conn_sparc; 456: break; 457: 458: case TME_CONNECTION_BUS_GENERIC: 459: 460: /* remember the connection to this bus: */ 461: if (state == TME_CONNECTION_FULL) { 462: assert (sun4->tme_sun4_buses[conn_sun4->tme_sun4_bus_connection_which] == NULL); 463: sun4->tme_sun4_buses[conn_sun4->tme_sun4_bus_connection_which] = conn_bus; 464: } 465: break; 466: 467: default: 468: assert(FALSE); 469: break; 470: } 471: return (TME_OK); 472: } 473: 474: /* this breaks a connection: */ 475: static int 476: _tme_sun4_connection_break(struct tme_connection *conn, unsigned int state) 477: { 478: abort(); 479: } 480: 481: /* this makes new connection sides: */ 482: static int 483: _tme_sun4_connections_new(struct tme_element *element, const char * const *args, struct tme_connection **_conns, char **_output) 484: { 485: struct tme_sparc_bus_connection *conn_sparc; 486: struct tme_sun4_bus_connection *conn_sun4; 487: struct tme_bus_connection *conn_bus; 488: struct tme_connection *conn; 489: struct tme_sun4 *sun4; 490: char *free_buses; 491: int which_conn; 492: 493: /* recover our sun4: */ 494: sun4 = (struct tme_sun4 *) element->tme_element_private; 495: 496: /* if we have no arguments, and we don't have a CPU yet, we can take 497: a SPARC bus connection: */ 498: if (args[1] == NULL 499: && sun4->tme_sun4_sparc == NULL) { 500: 501: /* create our side of a SPARC bus connection: */ 502: conn_sparc = tme_new0(struct tme_sparc_bus_connection, 1); 503: conn_bus = &conn_sparc->tme_sparc_bus_connection; 504: conn = &conn_bus->tme_bus_connection; 505: conn->tme_connection_next = *_conns; 506: 507: /* fill in the generic connection: */ 508: conn->tme_connection_type = TME_CONNECTION_BUS_SPARC; 509: conn->tme_connection_score = _tme_sun4_connection_score; 510: conn->tme_connection_make = _tme_sun4_connection_make; 511: conn->tme_connection_break = _tme_sun4_connection_break; 512: 513: /* fill in the generic bus connection: */ 514: conn_bus->tme_bus_signal = _tme_sun4_bus_signal; 515: conn_bus->tme_bus_intack = _tme_sun4_bus_intack; 1.1.1.2 ! root 516: conn_bus->tme_bus_tlb_set_add 1.1 root 517: = (TME_SUN4_IS_SUN44C(sun4) 1.1.1.2 ! root 518: ? _tme_sun44c_mmu_tlb_set_add 1.1 root 519: : NULL); 520: 521: /* full in the SPARC bus connection: */ 522: conn_sparc->tme_sparc_bus_tlb_fill 523: = (TME_SUN4_IS_SUN44C(sun4) 524: ? _tme_sun44c_tlb_fill_sparc 525: : NULL); 526: 527: /* add in this connection side possibility: */ 528: *_conns = conn; 529: } 530: 531: /* create our side of a generic bus connection: */ 532: conn_sun4 = tme_new0(struct tme_sun4_bus_connection, 1); 533: conn_bus = &conn_sun4->tme_sun4_bus_connection; 534: conn = &conn_bus->tme_bus_connection; 535: conn->tme_connection_next = *_conns; 536: 537: /* fill in the generic connection: */ 538: conn->tme_connection_type = TME_CONNECTION_BUS_GENERIC; 539: conn->tme_connection_score = _tme_sun4_connection_score; 540: conn->tme_connection_make = _tme_sun4_connection_make; 541: conn->tme_connection_break = _tme_sun4_connection_break; 542: 543: /* fill in the generic bus connection: */ 544: conn_bus->tme_bus_signal = _tme_sun4_bus_signal; 545: conn_bus->tme_bus_intack = NULL; 546: if (TME_SUN4_IS_SUN44C(sun4)) { 547: conn_bus->tme_bus_tlb_fill = _tme_sun44c_tlb_fill_bus; 548: } 549: else { 550: abort(); 551: } 552: 553: /* if we have no argument: */ 554: if (args[1] == NULL) { 555: 556: /* return no more connections: */ 557: tme_free(conn_sun4); 558: return (TME_OK); 559: } 560: 561: /* otherwise, we have at least one argument: */ 562: else { 563: 564: /* we must have no other arguments: */ 565: if (args[2] != NULL) { 566: tme_output_append_error(_output, 567: "%s %s", 568: args[2], 569: _("unexpected")); 570: tme_free(conn_sun4); 571: return (EINVAL); 572: } 573: 574: /* start the list of buses that we don't have yet: */ 575: free_buses = NULL; 576: 577: /* poison the which connection: */ 578: which_conn = -1; 579: 580: /* check each bus: */ 581: 582: /* obio: */ 583: if (sun4->tme_sun4_32_obio == NULL) { 584: tme_output_append(&free_buses, 585: (TME_SUN4_IS_SUN4C(sun4) 586: ? " sbus" 587: : " obio")); 588: } 589: if (TME_ARG_IS(args[1], 590: (TME_SUN4_IS_SUN4C(sun4) 591: ? "sbus" 592: : "obio"))) { 593: which_conn = TME_SUN4_32_CONN_BUS_OBIO; 594: } 595: 596: /* obmem: */ 597: if (!TME_SUN4_IS_SUN4C(sun4)) { 598: if (sun4->tme_sun4_32_obmem == NULL) { 599: tme_output_append(&free_buses, " obmem"); 600: } 601: if (TME_ARG_IS(args[1], "obmem")) { 602: which_conn = TME_SUN4_32_CONN_BUS_OBMEM; 603: } 604: } 605: 606: /* VMEbus: */ 607: if (TME_SUN4_IS_SUN4(sun4)) { 608: if (sun4->tme_sun4_vmebus == NULL) { 609: tme_output_append(&free_buses, " vme"); 610: } 611: if (TME_ARG_IS(args[1], "vme")) { 612: which_conn = TME_SUN4_CONN_BUS_VME; 613: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last 614: = TME_SUN4_DVMA_SIZE_VME; 615: } 616: } 617: 618: /* random connections: */ 619: 620: if (TME_ARG_IS(args[1], "timer")) { 621: which_conn = TME_SUN4_32_CONN_REG_TIMER; 622: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last 623: = TME_SUN44C_TIMER_SIZ_REG * 2; 624: } 625: else if (TME_ARG_IS(args[1], "memerr")) { 626: which_conn = TME_SUN4_32_CONN_REG_MEMERR; 627: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last 628: = (TME_SUN4_IS_MODEL(sun4, TME_SUN_IDPROM_TYPE_CODE_CALVIN) 629: ? (TME_SUN44C_MEMERR_SIZ_REG * 2) 630: : TME_SUN44C_MEMERR_SIZ_REG); 631: } 632: else if (TME_ARG_IS(args[1], "intreg")) { 633: which_conn = TME_SUN4_32_CONN_REG_INTREG; 634: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last 635: = sizeof(sun4->tme_sun44c_ints); 636: } 637: else if (TME_SUN4_IS_SUN4C4M(sun4) 638: && TME_ARG_IS(args[1], "auxreg")) { 639: which_conn = TME_SUN4C4M_CONN_REG_AUXREG; 640: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last 641: = sizeof(sun4->tme_sun4c4m_aux); 642: } 643: 644: /* if the which connection is still poison, or if this is trying 645: to connect a bus that we already have, complain: */ 646: if (which_conn < 0 647: || (which_conn < TME_SUN4_32_CONN_BUS_COUNT 648: && sun4->tme_sun4_buses[which_conn] != NULL)) { 649: if (which_conn < 0) { 650: tme_output_append_error(_output, 651: "%s %s ", 652: _("unknown bus or register:"), 653: args[1]); 654: } 655: if (free_buses != NULL) { 656: tme_output_append_error(_output, 657: "%s %s", 658: _("remaining buses:"), 659: free_buses); 660: tme_free(free_buses); 661: } 662: else { 663: tme_output_append_error(_output, _("all buses present")); 664: } 665: tme_free(conn_sun4); 666: return (EINVAL); 667: } 668: 669: /* free the remaining bus list: */ 670: if (free_buses != NULL) { 671: tme_free(free_buses); 672: } 673: 674: /* fill in the sun4 connection: */ 675: conn_sun4->tme_sun4_bus_connection_which = which_conn; 676: 677: /* fill in the generic bus connection for a bus: */ 678: if (which_conn < TME_SUN4_32_CONN_BUS_COUNT) { 1.1.1.2 ! root 679: conn_bus->tme_bus_tlb_set_add = _tme_sun44c_mmu_tlb_set_add; 1.1 root 680: } 681: } 682: 683: /* add in this connection side possibility: */ 684: *_conns = conn; 685: 686: /* done: */ 687: return (TME_OK); 688: } 689: 690: /* this creates a new sun4 element: */ 691: TME_ELEMENT_NEW_DECL(tme_machine_sun4) { 692: int usage; 693: struct tme_sun4 *sun4; 694: const char *idprom_filename; 695: FILE *idprom_fp; 696: tme_uint8_t idprom[TME_SUN_IDPROM_SIZE]; 697: int arg_i; 698: 699: arg_i = 1; 700: usage = FALSE; 701: 702: /* if we've been given an IDPROM filename: */ 703: idprom_filename = NULL; 704: if (TME_ARG_IS(args[arg_i], "idprom")) { 705: arg_i++; 706: idprom_filename = args[arg_i]; 707: if (idprom_filename == NULL) { 708: usage = TRUE; 709: } 710: else { 711: arg_i++; 712: } 713: } 714: 715: /* otherwise, if we've been given a board name: */ 716: else if (TME_ARG_IS(args[arg_i], "name")) { 717: arg_i++; 718: if (TME_ARG_IS(args[arg_i], "Calvin")) { 719: idprom[TME_SUN_IDPROM_OFF_MACHTYPE] = TME_SUN_IDPROM_TYPE_CODE_CALVIN; 720: arg_i++; 721: } 722: else if (args[arg_i] != NULL) { 723: tme_output_append_error(_output, 724: "%s %s, ", 725: _("unknown name"), 726: args[arg_i]); 727: usage = TRUE; 728: } 729: else { 730: tme_output_append_error(_output, 731: "%s, ", 732: _("missing name")); 733: usage = TRUE; 734: } 735: } 736: 737: /* we must have no more arguments: */ 738: if (args[arg_i] != NULL) { 739: tme_output_append_error(_output, 740: "%s %s, ", 741: args[arg_i], 742: _("unexpected")); 743: usage = TRUE; 744: } 745: 746: /* if our usage was bad: */ 747: if (usage) { 748: tme_output_append_error(_output, 749: "%s %s { idprom IDPROM%s | name { Calvin } } ", 750: _("usage:"), 751: args[0], 752: _("-FILENAME")); 753: return (EINVAL); 754: } 755: 756: /* if we've been given an IDPROM filename, try to read it in: */ 757: if (idprom_filename != NULL) { 758: idprom_fp = fopen(idprom_filename, "r"); 759: if (idprom_fp == NULL) { 760: tme_output_append_error(_output, idprom_filename); 761: return (errno); 762: } 763: if (fread(idprom, sizeof(tme_uint8_t), sizeof(idprom), idprom_fp) != sizeof(idprom)) { 764: tme_output_append_error(_output, idprom_filename); 765: fclose(idprom_fp); 766: return (ENOEXEC); 767: } 768: fclose(idprom_fp); 769: } 770: 771: /* allocate and initialize the new sun4: */ 772: sun4 = tme_new0(struct tme_sun4, 1); 773: sun4->tme_sun4_element = element; 774: tme_mutex_init(&sun4->tme_sun4_mutex); 775: 776: /* set the IDPROM: */ 777: memcpy(sun4->tme_sun4_idprom_contents, idprom, sizeof(idprom)); 778: 779: /* the MMU: */ 780: if (TME_SUN4_IS_SUN44C(sun4)) { 781: _tme_sun44c_mmu_new(sun4); 782: sun4->tme_sun4_tlb_fill = _tme_sun44c_tlb_fill_mmu; 783: } 784: else { 785: abort(); 786: } 787: 788: /* the cache: */ 789: if (TME_SUN4_IS_SUN44C(sun4)) { 790: _tme_sun44c_cache_new(sun4); 791: } 792: else { 793: abort(); 794: } 795: 796: /* the control ASIs: */ 797: sun4->tme_sun4_asis[TME_SUN4_32_ASI_CONTROL].tme_sun4_asi_sun4 = sun4; 798: if (TME_SUN4_IS_SUN44C(sun4)) { 799: sun4->tme_sun4_asis[TME_SUN44C_ASI_SEGMAP].tme_sun4_asi_sun4 = sun4; 800: sun4->tme_sun4_asis[TME_SUN44C_ASI_PGMAP].tme_sun4_asi_sun4 = sun4; 801: sun4->tme_sun4_asis[TME_SUN4C_ASI_HW_FLUSH_SEG /* TME_SUN4_ASI_COPY */].tme_sun4_asi_sun4 = sun4; 802: sun4->tme_sun4_asis[TME_SUN4C_ASI_HW_FLUSH_PG /* TME_SUN4_ASI_REGMAP */].tme_sun4_asi_sun4 = sun4; 803: sun4->tme_sun4_asis[TME_SUN4C_ASI_HW_FLUSH_CONTEXT /* TME_SUN4_ASI_FLUSH_REG */].tme_sun4_asi_sun4 = sun4; 804: sun4->tme_sun4_asis[TME_SUN44C_ASI_FLUSH_SEG].tme_sun4_asi_sun4 = sun4; 805: sun4->tme_sun4_asis[TME_SUN44C_ASI_FLUSH_PG].tme_sun4_asi_sun4 = sun4; 806: sun4->tme_sun4_asis[TME_SUN44C_ASI_FLUSH_CONTEXT].tme_sun4_asi_sun4 = sun4; 807: sun4->tme_sun4_asis[TME_SUN4C_ASI_HW_FLUSH_ALL /* TME_SUN4_ASI_FLUSH_USER */].tme_sun4_asi_sun4 = sun4; 808: } 809: else { 810: abort(); 811: } 812: 813: /* the timers: */ 814: _tme_sun4_timer_new(sun4); 815: 816: /* fill the element: */ 817: element->tme_element_private = sun4; 818: element->tme_element_connections_new = _tme_sun4_connections_new; 819: element->tme_element_command = _tme_sun4_command; 820: 821: return (TME_OK); 822: } 823: 824: /* this creates a new Sun-4 isil7170: */ 825: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun4,oclock) { 826: struct tme_isil7170_socket socket; 827: const char *sub_args[4]; 828: int arg_i; 829: 830: /* create the isil7170 socket: */ 831: memset (&socket, 0, sizeof(socket)); 832: socket.tme_isil7170_socket_version = TME_ISIL7170_SOCKET_0; 833: socket.tme_isil7170_socket_addr_shift = 0; 834: socket.tme_isil7170_socket_port_least_lane = 3; /* D31-D24 */ 835: socket.tme_isil7170_socket_clock_basic = TME_ISIL7170_FREQ_32K; 836: socket.tme_isil7170_socket_int_signal = TME_BUS_SIGNAL_INT_UNSPEC; 837: 838: /* create the isil7170. we allow at most two arguments to pass 839: through, which is an awful hack: */ 840: sub_args[0] = "tme/ic/isil7170"; 841: for (arg_i = 1;; arg_i++) { 842: if (arg_i == TME_ARRAY_ELS(sub_args)) { 843: abort(); 844: } 845: sub_args[arg_i] = args[arg_i]; 846: if (args[arg_i] == NULL) { 847: break; 848: } 849: } 850: return (tme_element_new(element, (const char * const *) sub_args, &socket, _output)); 851: } 852: 853: /* this creates a new Sun-4 mk48txx: */ 854: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun4,clock) { 855: struct tme_mk48txx_socket socket; 856: 857: /* create the mk48txx socket: */ 858: memset (&socket, 0, sizeof(socket)); 859: socket.tme_mk48txx_socket_version = TME_MK48TXX_SOCKET_0; 860: socket.tme_mk48txx_socket_addr_shift = 0; 861: socket.tme_mk48txx_socket_port_least_lane = 3; /* D31-D24 */ 862: socket.tme_mk48txx_socket_year_zero = 1968; 863: 864: if (!TME_ARG_IS(args[1], "type") 865: || args[2] == NULL) { 866: tme_output_append_error(_output, 867: "%s %s type CLOCK-%s", 868: _("usage:"), 869: args[0], 870: _("TYPE")); 871: return (EINVAL); 872: } 873: 874: return (tme_element_new(element, args + 2, &socket, _output)); 875: } 876: 877: /* this creates a new Sun-4 z8530: */ 878: TME_ELEMENT_SUB_NEW_DECL(tme_machine_sun4,zs) { 879: struct tme_z8530_socket socket = TME_SUN_Z8530_SOCKET_INIT; 880: char *sub_args[2]; 881: 882: /* create the z8530: */ 883: sub_args[0] = "tme/ic/z8530"; 884: sub_args[1] = NULL; 885: return (tme_element_new(element, (const char * const *) sub_args, &socket, _output)); 886: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.