![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sun-obie.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / machine / sun|
Return to sun-obie.c CVS log | Up to [The Machine Emulator] / tme / machine / sun |
1.1 ! root 1: /* $Id: sun-obie.c,v 1.2 2005/02/17 12:37:25 fredette Exp $ */ ! 2: ! 3: /* machine/sun/sun-obie.c - classic Sun onboard Intel Ethernet implementation: */ ! 4: ! 5: /* ! 6: * Copyright (c) 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: sun-obie.c,v 1.2 2005/02/17 12:37:25 fredette Exp $"); ! 38: ! 39: /* includes: */ ! 40: #include <tme/element.h> ! 41: #undef TME_BUS_VERSION ! 42: #define TME_BUS_VERSION TME_X_VERSION(0, 0) ! 43: #include <tme/generic/bus.h> ! 44: #undef TME_I825X6_VERSION ! 45: #define TME_I825X6_VERSION TME_X_VERSION(0, 0) ! 46: #include <tme/ic/i825x6.h> ! 47: #include <tme/machine/sun.h> ! 48: ! 49: /* macros: */ ! 50: ! 51: /* register offsets and sizes: */ ! 52: #define TME_SUN_OBIE_REG_CSR (0) ! 53: #define TME_SUN_OBIE_SIZ_CSR (sizeof(tme_uint16_t)) ! 54: #define TME_SUN_OBIE_SIZ_REGS (TME_SUN_OBIE_REG_CSR + TME_SUN_OBIE_SIZ_CSR) ! 55: ! 56: /* the bits in the Control/Status Register: */ ! 57: #define TME_SUN_OBIE_CSR_NORESET (0x8000) ! 58: #define TME_SUN_OBIE_CSR_NOLOOP (0x4000) ! 59: #define TME_SUN_OBIE_CSR_CA (0x2000) ! 60: #define TME_SUN_OBIE_CSR_IE (0x1000) ! 61: /* 0x0800 unused */ ! 62: #define TME_SUN_OBIE_CSR_LEVEL2 (0x0400) ! 63: #define TME_SUN_OBIE_CSR_BUSERR (0x0200) ! 64: #define TME_SUN_OBIE_CSR_INTR (0x0100) ! 65: #define TME_SUN_OBIE_CSR_READONLY (0x0800 \ ! 66: | TME_SUN_OBIE_CSR_LEVEL2 \ ! 67: | TME_SUN_OBIE_CSR_BUSERR \ ! 68: | TME_SUN_OBIE_CSR_INTR) ! 69: ! 70: /* these get and put the CSR: */ ! 71: #define TME_SUN_OBIE_CSR_GET(sun_obie) \ ! 72: tme_betoh_u16(*((tme_uint16_t *) &(sun_obie)->tme_sun_obie_regs[TME_SUN_OBIE_REG_CSR])) ! 73: #define TME_SUN_OBIE_CSR_PUT(sun_obie, csr) \ ! 74: (*((tme_uint16_t *) &(sun_obie)->tme_sun_obie_regs[TME_SUN_OBIE_REG_CSR]) = tme_htobe_u16(csr)) ! 75: ! 76: /* the callout flags: */ ! 77: #define TME_SUN_OBIE_CALLOUT_CHECK (0) ! 78: #define TME_SUN_OBIE_CALLOUT_RUNNING TME_BIT(0) ! 79: #define TME_SUN_OBIE_CALLOUTS_MASK (-2) ! 80: #define TME_SUN_OBIE_CALLOUT_SIGNALS TME_BIT(1) ! 81: #define TME_SUN_OBIE_CALLOUT_INT TME_BIT(2) ! 82: ! 83: /* structures: */ ! 84: ! 85: /* the card: */ ! 86: struct tme_sun_obie { ! 87: ! 88: /* backpointer to our element: */ ! 89: struct tme_element *tme_sun_obie_element; ! 90: ! 91: /* the mutex protecting the card: */ ! 92: tme_mutex_t tme_sun_obie_mutex; ! 93: ! 94: /* the rwlock protecting the card: */ ! 95: tme_rwlock_t tme_sun_obie_rwlock; ! 96: ! 97: /* the bus connection for the card's registers: */ ! 98: struct tme_bus_connection *tme_sun_obie_conn_regs; ! 99: ! 100: /* the bus connection for the card's memory: */ ! 101: struct tme_bus_connection *tme_sun_obie_conn_memory; ! 102: ! 103: /* the bus connection for the card's i825x6 chip: */ ! 104: struct tme_bus_connection *tme_sun_obie_conn_i825x6; ! 105: ! 106: /* the callout flags: */ ! 107: int tme_sun_obie_callout_flags; ! 108: ! 109: /* if our interrupt line is currently asserted: */ ! 110: int tme_sun_obie_int_asserted; ! 111: ! 112: /* it's easiest to just model the board registers as a chunk of memory: */ ! 113: tme_uint8_t tme_sun_obie_regs[TME_SUN_OBIE_SIZ_REGS]; ! 114: ! 115: /* the i825x6 image of the CSR: */ ! 116: tme_uint16_t tme_sun_obie_csr_i825x6; ! 117: ! 118: #ifndef TME_NO_LOG ! 119: tme_uint16_t tme_sun_obie_last_log_csr; ! 120: #endif /* !TME_NO_LOG */ ! 121: }; ! 122: ! 123: /* a sun_obie internal bus connection: */ ! 124: struct tme_sun_obie_connection { ! 125: ! 126: /* the external bus connection: */ ! 127: struct tme_bus_connection tme_sun_obie_connection; ! 128: ! 129: /* this is nonzero if a TME_CONNECTION_BUS_GENERIC chip connection ! 130: is for the registers: */ ! 131: tme_uint8_t tme_sun_obie_connection_regs; ! 132: }; ! 133: ! 134: /* globals: */ ! 135: ! 136: /* our bus signals sets: */ ! 137: static const struct tme_bus_signals _tme_sun_obie_bus_signals_generic = TME_BUS_SIGNALS_GENERIC; ! 138: static const struct tme_bus_signals _tme_sun_obie_bus_signals_i825x6 = TME_BUS_SIGNALS_I825X6; ! 139: ! 140: /* the sun_obie callout function. it must be called with the mutex locked: */ ! 141: static void ! 142: _tme_sun_obie_callout(struct tme_sun_obie *sun_obie, int new_callouts) ! 143: { ! 144: struct tme_bus_connection *conn_i825x6; ! 145: struct tme_bus_connection *conn_bus; ! 146: tme_uint16_t csr, csr_diff; ! 147: unsigned int signal, level; ! 148: int callouts, later_callouts; ! 149: int rc; ! 150: int int_asserted; ! 151: ! 152: /* add in any new callouts: */ ! 153: sun_obie->tme_sun_obie_callout_flags |= new_callouts; ! 154: ! 155: /* if this function is already running in another thread, simply ! 156: return now. the other thread will do our work: */ ! 157: if (sun_obie->tme_sun_obie_callout_flags & TME_SUN_OBIE_CALLOUT_RUNNING) { ! 158: return; ! 159: } ! 160: ! 161: /* callouts are now running: */ ! 162: sun_obie->tme_sun_obie_callout_flags |= TME_SUN_OBIE_CALLOUT_RUNNING; ! 163: ! 164: /* assume that we won't need any later callouts: */ ! 165: later_callouts = 0; ! 166: ! 167: /* loop while callouts are needed: */ ! 168: for (; (callouts = sun_obie->tme_sun_obie_callout_flags) & TME_SUN_OBIE_CALLOUTS_MASK; ) { ! 169: ! 170: /* clear the needed callouts: */ ! 171: sun_obie->tme_sun_obie_callout_flags = callouts & ~TME_SUN_OBIE_CALLOUTS_MASK; ! 172: callouts &= TME_SUN_OBIE_CALLOUTS_MASK; ! 173: ! 174: /* if we need to call out one or more signals to the i825x6: */ ! 175: if (callouts & TME_SUN_OBIE_CALLOUT_SIGNALS) { ! 176: ! 177: /* get the current CSR value: */ ! 178: csr = TME_SUN_OBIE_CSR_GET(sun_obie); ! 179: ! 180: /* get the next signal to call out to the i825x6: */ ! 181: csr_diff = ((csr ! 182: ^ sun_obie->tme_sun_obie_csr_i825x6) ! 183: & (TME_SUN_OBIE_CSR_NORESET ! 184: | TME_SUN_OBIE_CSR_NOLOOP ! 185: | TME_SUN_OBIE_CSR_CA)); ! 186: csr_diff = (csr_diff ^ (csr_diff - 1)) & csr_diff; ! 187: ! 188: /* if there is a signal to call out: */ ! 189: if (csr_diff != 0) { ! 190: ! 191: /* assume that if the signal's bit is set in the CSR, it will ! 192: be asserted: */ ! 193: level = csr & csr_diff; ! 194: ! 195: /* assume that we're calling out an i825x6 signal: */ ! 196: signal = (_tme_sun_obie_bus_signals_generic.tme_bus_signals_first ! 197: + TME_BUS_SIGNAL_X(_tme_sun_obie_bus_signals_generic.tme_bus_signals_count)); ! 198: ! 199: /* dispatch on the CSR bit: */ ! 200: switch (csr_diff) { ! 201: default: ! 202: assert (FALSE); ! 203: case TME_SUN_OBIE_CSR_NORESET: ! 204: signal = TME_BUS_SIGNAL_RESET; ! 205: level = !level; ! 206: break; ! 207: case TME_SUN_OBIE_CSR_NOLOOP: ! 208: signal += TME_I825X6_SIGNAL_LOOP; ! 209: level = !level; ! 210: break; ! 211: case TME_SUN_OBIE_CSR_CA: ! 212: signal += TME_I825X6_SIGNAL_CA; ! 213: break; ! 214: } ! 215: ! 216: /* create a real signal level value: */ ! 217: level = (level ! 218: ? TME_BUS_SIGNAL_LEVEL_ASSERTED ! 219: : TME_BUS_SIGNAL_LEVEL_NEGATED); ! 220: ! 221: /* get this card's i825x6 connection: */ ! 222: conn_i825x6 = sun_obie->tme_sun_obie_conn_i825x6; ! 223: ! 224: /* unlock the mutex: */ ! 225: tme_mutex_unlock(&sun_obie->tme_sun_obie_mutex); ! 226: ! 227: /* do the callout: */ ! 228: rc = (conn_i825x6 != NULL ! 229: ? ((*conn_i825x6->tme_bus_signal) ! 230: (conn_i825x6, ! 231: signal | level)) ! 232: : TME_OK); ! 233: ! 234: /* lock the mutex: */ ! 235: tme_mutex_lock(&sun_obie->tme_sun_obie_mutex); ! 236: ! 237: /* if the callout was unsuccessful, remember that at some later ! 238: time this callout should be attempted again: */ ! 239: if (rc != TME_OK) { ! 240: later_callouts |= TME_SUN_OBIE_CALLOUT_SIGNALS; ! 241: } ! 242: ! 243: /* otherwise, the callout was successful: */ ! 244: else { ! 245: ! 246: /* update the i825x6 image of the CSR: */ ! 247: sun_obie->tme_sun_obie_csr_i825x6 = ! 248: ((sun_obie->tme_sun_obie_csr_i825x6 & ~csr_diff) ! 249: | (csr & csr_diff)); ! 250: ! 251: /* there may be more signals to call out, so attempt this ! 252: callout again now: */ ! 253: sun_obie->tme_sun_obie_callout_flags |= TME_SUN_OBIE_CALLOUT_SIGNALS; ! 254: } ! 255: } ! 256: } ! 257: ! 258: /* if we need to call out a possible change to our interrupt ! 259: signal: */ ! 260: if (callouts & TME_SUN_OBIE_CALLOUT_INT) { ! 261: ! 262: /* get the current CSR value: */ ! 263: csr = TME_SUN_OBIE_CSR_GET(sun_obie); ! 264: ! 265: /* see if the interrupt signal should be asserted or negated: */ ! 266: int_asserted = ((csr & (TME_SUN_OBIE_CSR_IE ! 267: | TME_SUN_OBIE_CSR_INTR)) ! 268: == (TME_SUN_OBIE_CSR_IE ! 269: | TME_SUN_OBIE_CSR_INTR)); ! 270: ! 271: /* if the interrupt signal doesn't already have the right state: */ ! 272: if (!int_asserted != !sun_obie->tme_sun_obie_int_asserted) { ! 273: ! 274: /* get our bus connection: */ ! 275: conn_bus = sun_obie->tme_sun_obie_conn_regs; ! 276: ! 277: /* unlock our mutex: */ ! 278: tme_mutex_unlock(&sun_obie->tme_sun_obie_mutex); ! 279: ! 280: /* call out the bus interrupt signal edge: */ ! 281: rc = (conn_bus != NULL ! 282: ? ((*conn_bus->tme_bus_signal) ! 283: (conn_bus, ! 284: TME_BUS_SIGNAL_INT_UNSPEC ! 285: | (int_asserted ! 286: ? TME_BUS_SIGNAL_LEVEL_ASSERTED ! 287: : TME_BUS_SIGNAL_LEVEL_NEGATED))) ! 288: : TME_OK); ! 289: ! 290: /* lock our mutex: */ ! 291: tme_mutex_lock(&sun_obie->tme_sun_obie_mutex); ! 292: ! 293: /* if this callout was successful, note the new state of the ! 294: interrupt signal: */ ! 295: if (rc == TME_OK) { ! 296: sun_obie->tme_sun_obie_int_asserted = int_asserted; ! 297: } ! 298: ! 299: /* otherwise, remember that at some later time this callout ! 300: should be attempted again: */ ! 301: else { ! 302: later_callouts |= TME_SUN_OBIE_CALLOUT_INT; ! 303: } ! 304: } ! 305: } ! 306: } ! 307: ! 308: /* put in any later callouts, and clear that callouts are running: */ ! 309: sun_obie->tme_sun_obie_callout_flags = later_callouts; ! 310: } ! 311: ! 312: /* the sun_obie bus cycle handler for the board registers: */ ! 313: static int ! 314: _tme_sun_obie_bus_cycle_regs(void *_sun_obie, ! 315: struct tme_bus_cycle *cycle_init) ! 316: { ! 317: struct tme_sun_obie *sun_obie; ! 318: tme_uint16_t csr_old, csr_new, csr_diff; ! 319: int new_callouts; ! 320: ! 321: /* recover our data structure: */ ! 322: sun_obie = (struct tme_sun_obie *) _sun_obie; ! 323: ! 324: /* assume we won't need any new callouts: */ ! 325: new_callouts = 0; ! 326: ! 327: /* lock the mutex: */ ! 328: tme_mutex_lock(&sun_obie->tme_sun_obie_mutex); ! 329: ! 330: /* get the previous CSR value: */ ! 331: csr_old = TME_SUN_OBIE_CSR_GET(sun_obie); ! 332: ! 333: /* run the cycle: */ ! 334: tme_bus_cycle_xfer_memory(cycle_init, ! 335: sun_obie->tme_sun_obie_regs, ! 336: TME_SUN_OBIE_SIZ_REGS - 1); ! 337: ! 338: /* get the current CSR value, and put back any bits that ! 339: software can't change: */ ! 340: csr_new = ((TME_SUN_OBIE_CSR_GET(sun_obie) ! 341: & ~TME_SUN_OBIE_CSR_READONLY) ! 342: | (csr_old ! 343: & TME_SUN_OBIE_CSR_READONLY)); ! 344: TME_SUN_OBIE_CSR_PUT(sun_obie, csr_new); ! 345: ! 346: /* get the sets of CSR bits that have changed: */ ! 347: csr_diff = (csr_old ^ csr_new); ! 348: ! 349: /* if this is a NORESET, NOLOOP or CA change, possibly call out the ! 350: appropriate signal change to the i825x6: */ ! 351: if (csr_diff & (TME_SUN_OBIE_CSR_NORESET ! 352: | TME_SUN_OBIE_CSR_NOLOOP ! 353: | TME_SUN_OBIE_CSR_CA)) { ! 354: new_callouts |= TME_SUN_OBIE_CALLOUT_SIGNALS; ! 355: } ! 356: ! 357: /* if this is an interrupt mask change, possibly call out an ! 358: interrupt signal change to the bus: */ ! 359: if (csr_diff & TME_SUN_OBIE_CSR_IE) { ! 360: new_callouts |= TME_SUN_OBIE_CALLOUT_INT; ! 361: } ! 362: ! 363: #ifndef TME_NO_LOG ! 364: if (csr_new != sun_obie->tme_sun_obie_last_log_csr) { ! 365: sun_obie->tme_sun_obie_last_log_csr = csr_new; ! 366: tme_log(&sun_obie->tme_sun_obie_element->tme_element_log_handle, ! 367: 1000, TME_OK, ! 368: (&sun_obie->tme_sun_obie_element->tme_element_log_handle, ! 369: "csr now 0x%04x", ! 370: csr_new)); ! 371: } ! 372: #endif /* !TME_NO_LOG */ ! 373: ! 374: /* make any new callouts: */ ! 375: _tme_sun_obie_callout(sun_obie, new_callouts); ! 376: ! 377: /* unlock the mutex: */ ! 378: tme_mutex_unlock(&sun_obie->tme_sun_obie_mutex); ! 379: ! 380: /* no faults: */ ! 381: return (TME_OK); ! 382: } ! 383: ! 384: /* the sun_obie bus signal handler: */ ! 385: static int ! 386: _tme_sun_obie_bus_signal(struct tme_bus_connection *conn_bus, ! 387: unsigned int signal) ! 388: { ! 389: struct tme_sun_obie *sun_obie; ! 390: ! 391: /* return now if this is not a generic bus signal: */ ! 392: if (TME_BUS_SIGNAL_INDEX(signal) ! 393: > _tme_sun_obie_bus_signals_generic.tme_bus_signals_count) { ! 394: return (TME_OK); ! 395: } ! 396: ! 397: /* recover our data structures: */ ! 398: sun_obie = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 399: ! 400: /* pass the i825x6's signal through to the obio bus: */ ! 401: conn_bus = sun_obie->tme_sun_obie_conn_regs; ! 402: return (conn_bus != NULL ! 403: ? (*conn_bus->tme_bus_signal)(conn_bus, signal) ! 404: : ENXIO); ! 405: } ! 406: ! 407: /* the sun_obie bus signals adder for the i825x6: */ ! 408: static int ! 409: _tme_sun_obie_bus_signals_add(struct tme_bus_connection *conn_bus, ! 410: struct tme_bus_signals *bus_signals_caller) ! 411: { ! 412: const struct tme_bus_signals *bus_signals; ! 413: tme_uint32_t signal_first; ! 414: ! 415: /* we only support the generic and i825x6 bus signals: */ ! 416: switch (bus_signals_caller->tme_bus_signals_id) { ! 417: case TME_BUS_SIGNALS_ID_GENERIC: ! 418: bus_signals = &_tme_sun_obie_bus_signals_generic; ! 419: signal_first = _tme_sun_obie_bus_signals_generic.tme_bus_signals_first; ! 420: break; ! 421: case TME_BUS_SIGNALS_ID_I825X6: ! 422: bus_signals = &_tme_sun_obie_bus_signals_i825x6; ! 423: signal_first = (_tme_sun_obie_bus_signals_generic.tme_bus_signals_first ! 424: + TME_BUS_SIGNAL_X(_tme_sun_obie_bus_signals_generic.tme_bus_signals_count)); ! 425: break; ! 426: default: ! 427: return (ENOENT); ! 428: } ! 429: ! 430: /* XXX we should check versions here: */ ! 431: *bus_signals_caller = *bus_signals; ! 432: bus_signals_caller->tme_bus_signals_first = signal_first; ! 433: return (TME_OK); ! 434: } ! 435: ! 436: /* the sun_obie TLB allocator for the i825x6: */ ! 437: static int ! 438: _tme_sun_obie_tlb_set_allocate(struct tme_bus_connection *conn_bus, ! 439: unsigned int count, unsigned int sizeof_one, ! 440: TME_ATOMIC_POINTER_TYPE(struct tme_bus_tlb *) _tlbs) ! 441: { ! 442: struct tme_sun_obie *sun_obie; ! 443: ! 444: /* recover our data structures: */ ! 445: sun_obie = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 446: ! 447: /* pass the i825x6's request through to the mainbus: */ ! 448: conn_bus = sun_obie->tme_sun_obie_conn_memory; ! 449: return (conn_bus != NULL ! 450: ? (*conn_bus->tme_bus_tlb_set_allocate)(conn_bus, ! 451: count, sizeof_one, ! 452: _tlbs) ! 453: : ENXIO); ! 454: } ! 455: ! 456: /* the sun_obie TLB filler for the memory: */ ! 457: static int ! 458: _tme_sun_obie_tlb_fill(struct tme_bus_connection *conn_bus, ! 459: struct tme_bus_tlb *tlb, ! 460: tme_bus_addr_t address, ! 461: unsigned int cycles) ! 462: { ! 463: struct tme_sun_obie *sun_obie; ! 464: ! 465: /* the address must be within range: */ ! 466: assert(address <= 0xffffff); ! 467: ! 468: /* recover our data structures: */ ! 469: sun_obie = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 470: ! 471: /* pass the i825x6's request through to the mainbus: */ ! 472: conn_bus = sun_obie->tme_sun_obie_conn_memory; ! 473: return (conn_bus != NULL ! 474: ? (*conn_bus->tme_bus_tlb_fill)(conn_bus, ! 475: tlb, ! 476: address, ! 477: cycles) ! 478: : ENXIO); ! 479: } ! 480: ! 481: /* the sun_obie TLB filler for the board registers: */ ! 482: static int ! 483: _tme_sun_obie_tlb_fill_regs(struct tme_bus_connection *conn_bus, ! 484: struct tme_bus_tlb *tlb, ! 485: tme_bus_addr_t address, unsigned int cycles) ! 486: { ! 487: struct tme_sun_obie *sun_obie; ! 488: ! 489: /* recover our data structures: */ ! 490: sun_obie = conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 491: ! 492: /* the address must be within range: */ ! 493: assert(address < TME_SUN_OBIE_SIZ_CSR); ! 494: ! 495: /* initialize the TLB entry: */ ! 496: tme_bus_tlb_initialize(tlb); ! 497: ! 498: /* this address falls in the CSR: */ ! 499: ! 500: /* this TLB entry covers this range: */ ! 501: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first, TME_SUN_OBIE_REG_CSR); ! 502: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last, (TME_SUN_OBIE_REG_CSR ! 503: + TME_SUN_OBIE_SIZ_CSR ! 504: - 1)); ! 505: ! 506: /* this TLB entry allows fast reading: */ ! 507: tlb->tme_bus_tlb_emulator_off_read = sun_obie->tme_sun_obie_regs; ! 508: ! 509: /* allow reading and writing: */ ! 510: tlb->tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ | TME_BUS_CYCLE_WRITE; ! 511: ! 512: /* our bus cycle handler: */ ! 513: tlb->tme_bus_tlb_cycle_private = sun_obie; ! 514: tlb->tme_bus_tlb_cycle = _tme_sun_obie_bus_cycle_regs; ! 515: ! 516: return (TME_OK); ! 517: } ! 518: ! 519: /* this scores a new connection: */ ! 520: static int ! 521: _tme_sun_obie_connection_score(struct tme_connection *conn, unsigned int *_score) ! 522: { ! 523: struct tme_sun_obie *sun_obie; ! 524: struct tme_sun_obie_connection *conn_sun_obie; ! 525: ! 526: /* both sides must be generic bus connections: */ ! 527: assert(conn->tme_connection_type == TME_CONNECTION_BUS_GENERIC); ! 528: assert(conn->tme_connection_other->tme_connection_type ! 529: == conn->tme_connection_type); ! 530: ! 531: /* recover our data structures: */ ! 532: sun_obie = conn->tme_connection_element->tme_element_private; ! 533: conn_sun_obie = (struct tme_sun_obie_connection *)conn; ! 534: ! 535: /* this is a generic bus connection, so just score it nonzero and ! 536: return. note that there's no good way to differentiate a ! 537: connection to a bus from a connection to just another chip, so we ! 538: always return a nonzero score here: */ ! 539: *_score = 1; ! 540: return (TME_OK); ! 541: } ! 542: ! 543: /* this makes a new connection: */ ! 544: static int ! 545: _tme_sun_obie_connection_make(struct tme_connection *conn, unsigned int state) ! 546: { ! 547: struct tme_sun_obie *sun_obie; ! 548: struct tme_sun_obie_connection *conn_sun_obie; ! 549: struct tme_bus_connection *conn_bus; ! 550: ! 551: /* both sides must be generic bus connections: */ ! 552: assert(conn->tme_connection_type == TME_CONNECTION_BUS_GENERIC); ! 553: assert(conn->tme_connection_other->tme_connection_type ! 554: == conn->tme_connection_type); ! 555: ! 556: /* recover our data structures: */ ! 557: sun_obie = conn->tme_connection_element->tme_element_private; ! 558: conn_sun_obie = (struct tme_sun_obie_connection *)conn; ! 559: conn_bus = &conn_sun_obie->tme_sun_obie_connection; ! 560: ! 561: /* we're always set up to answer calls across the connection, so we ! 562: only have to do work when the connection has gone full, namely ! 563: taking the other side of the connection: */ ! 564: if (state == TME_CONNECTION_FULL) { ! 565: ! 566: /* lock our mutex: */ ! 567: tme_mutex_lock(&sun_obie->tme_sun_obie_mutex); ! 568: ! 569: /* save our connection: */ ! 570: if (conn_bus->tme_bus_signals_add != NULL) { ! 571: sun_obie->tme_sun_obie_conn_i825x6 = (struct tme_bus_connection *) conn->tme_connection_other; ! 572: } ! 573: else if (conn_sun_obie->tme_sun_obie_connection_regs) { ! 574: sun_obie->tme_sun_obie_conn_regs = (struct tme_bus_connection *) conn->tme_connection_other; ! 575: } ! 576: else { ! 577: sun_obie->tme_sun_obie_conn_memory = (struct tme_bus_connection *) conn->tme_connection_other; ! 578: } ! 579: ! 580: /* unlock our mutex: */ ! 581: tme_mutex_unlock(&sun_obie->tme_sun_obie_mutex); ! 582: } ! 583: ! 584: return (TME_OK); ! 585: } ! 586: ! 587: /* this breaks a connection: */ ! 588: static int ! 589: _tme_sun_obie_connection_break(struct tme_connection *conn, unsigned int state) ! 590: { ! 591: abort(); ! 592: } ! 593: ! 594: /* this makes a new connection side for a sun_obie: */ ! 595: static int ! 596: _tme_sun_obie_connections_new(struct tme_element *element, ! 597: const char * const *args, ! 598: struct tme_connection **_conns, ! 599: char **_output) ! 600: { ! 601: struct tme_sun_obie *sun_obie; ! 602: struct tme_sun_obie_connection *conn_sun_obie; ! 603: struct tme_bus_connection *conn_bus; ! 604: struct tme_connection *conn; ! 605: unsigned int i825x6; ! 606: tme_uint8_t regs; ! 607: int usage; ! 608: int rc; ! 609: ! 610: /* recover our data structure: */ ! 611: sun_obie = (struct tme_sun_obie *) element->tme_element_private; ! 612: ! 613: /* we don't bother locking the mutex simply to check if connections ! 614: already exist: */ ! 615: ! 616: /* check our arguments: */ ! 617: usage = FALSE; ! 618: rc = 0; ! 619: i825x6 = FALSE; ! 620: regs = FALSE; ! 621: ! 622: /* if this connection is for the registers: */ ! 623: if (TME_ARG_IS(args[1], "csr")) { ! 624: ! 625: /* if we already have a register connection, complain: */ ! 626: if (sun_obie->tme_sun_obie_conn_regs != NULL) { ! 627: rc = EEXIST; ! 628: } ! 629: ! 630: /* otherwise, make the new connection: */ ! 631: else { ! 632: regs = TRUE; ! 633: } ! 634: } ! 635: ! 636: /* else, if this connection is for the memory: */ ! 637: else if (TME_ARG_IS(args[1], "memory")) { ! 638: ! 639: /* if we already have a memory connection, complain: */ ! 640: if (sun_obie->tme_sun_obie_conn_memory != NULL) { ! 641: rc = EEXIST; ! 642: } ! 643: } ! 644: ! 645: /* else, the connection must be for the i825x6: */ ! 646: else if (args[1] == NULL) { ! 647: ! 648: /* if we already have an i825x6 connection, complain: */ ! 649: if (sun_obie->tme_sun_obie_conn_i825x6 != NULL) { ! 650: rc = EEXIST; ! 651: } ! 652: ! 653: /* otherwise, make the new conection: */ ! 654: else { ! 655: i825x6 = TRUE; ! 656: } ! 657: } ! 658: ! 659: /* otherwise, this is a bad argument: */ ! 660: else { ! 661: tme_output_append_error(_output, ! 662: "%s %s, ", ! 663: args[1], ! 664: _("unexpected")); ! 665: usage = TRUE; ! 666: } ! 667: ! 668: if (usage) { ! 669: tme_output_append_error(_output, ! 670: "%s %s [ csr | memory ]", ! 671: _("usage:"), ! 672: args[0]); ! 673: rc = EINVAL; ! 674: } ! 675: ! 676: if (rc) { ! 677: return (rc); ! 678: } ! 679: ! 680: /* make a new connection: */ ! 681: conn_sun_obie = tme_new0(struct tme_sun_obie_connection, 1); ! 682: conn_bus = &conn_sun_obie->tme_sun_obie_connection; ! 683: conn = &conn_bus->tme_bus_connection; ! 684: ! 685: /* fill in the generic connection: */ ! 686: conn->tme_connection_next = *_conns; ! 687: conn->tme_connection_type = TME_CONNECTION_BUS_GENERIC; ! 688: conn->tme_connection_score = _tme_sun_obie_connection_score; ! 689: conn->tme_connection_make = _tme_sun_obie_connection_make; ! 690: conn->tme_connection_break = _tme_sun_obie_connection_break; ! 691: ! 692: /* fill in the generic bus connection: */ ! 693: conn_bus->tme_bus_subregions.tme_bus_subregion_address_first = 0; ! 694: conn_bus->tme_bus_subregions.tme_bus_subregion_next = NULL; ! 695: if (i825x6) { ! 696: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last = 0xffffff; ! 697: conn_bus->tme_bus_signals_add = _tme_sun_obie_bus_signals_add; ! 698: conn_bus->tme_bus_signal = _tme_sun_obie_bus_signal; ! 699: conn_bus->tme_bus_tlb_set_allocate = _tme_sun_obie_tlb_set_allocate; ! 700: conn_bus->tme_bus_tlb_fill = _tme_sun_obie_tlb_fill; ! 701: } ! 702: else if (regs) { ! 703: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last = TME_SUN_OBIE_SIZ_REGS - 1; ! 704: conn_bus->tme_bus_tlb_fill = _tme_sun_obie_tlb_fill_regs; ! 705: } ! 706: else { ! 707: conn_bus->tme_bus_subregions.tme_bus_subregion_address_last = 0; ! 708: } ! 709: ! 710: /* fill in the internal information: */ ! 711: conn_sun_obie->tme_sun_obie_connection_regs = regs; ! 712: ! 713: /* return the connection side possibility: */ ! 714: *_conns = conn; ! 715: return (TME_OK); ! 716: } ! 717: ! 718: /* the new sun_obie function: */ ! 719: int ! 720: tme_sun_obie(struct tme_element *element, const char * const *args, char **_output) ! 721: { ! 722: struct tme_sun_obie *sun_obie; ! 723: int arg_i; ! 724: int usage; ! 725: ! 726: /* check our arguments: */ ! 727: usage = 0; ! 728: arg_i = 1; ! 729: for (;;) { ! 730: ! 731: if (0) { ! 732: } ! 733: ! 734: /* if we ran out of arguments: */ ! 735: else if (args[arg_i] == NULL) { ! 736: ! 737: break; ! 738: } ! 739: ! 740: /* otherwise this is a bad argument: */ ! 741: else { ! 742: tme_output_append_error(_output, ! 743: "%s %s, ", ! 744: args[arg_i], ! 745: _("unexpected")); ! 746: usage = TRUE; ! 747: break; ! 748: } ! 749: } ! 750: ! 751: if (usage) { ! 752: tme_output_append_error(_output, ! 753: "%s %s", ! 754: _("usage:"), ! 755: args[0]); ! 756: return (EINVAL); ! 757: } ! 758: ! 759: /* start the sun_obie structure: */ ! 760: sun_obie = tme_new0(struct tme_sun_obie, 1); ! 761: sun_obie->tme_sun_obie_element = element; ! 762: TME_SUN_OBIE_CSR_PUT(sun_obie, ! 763: (TME_SUN_OBIE_CSR_NORESET ! 764: | TME_SUN_OBIE_CSR_NOLOOP)); ! 765: tme_mutex_init(&sun_obie->tme_sun_obie_mutex); ! 766: tme_rwlock_init(&sun_obie->tme_sun_obie_rwlock); ! 767: ! 768: /* fill the element: */ ! 769: element->tme_element_private = sun_obie; ! 770: element->tme_element_connections_new = _tme_sun_obie_connections_new; ! 771: ! 772: return (TME_OK); ! 773: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.