![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stp22xx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / ic / stp22xx|
Return to stp22xx.c CVS log | Up to [The Machine Emulator] / tme / ic / stp22xx |
1.1 ! root 1: /* $Id: stp22xx.c,v 1.4 2009/09/07 15:03:19 fredette Exp $ */ ! 2: ! 3: /* ic/stp22xx.c - common STP2200, STP2202, STP2220, and STP2222 ! 4: emulation: */ ! 5: ! 6: /* ! 7: * Copyright (c) 2009 Matt Fredette ! 8: * All rights reserved. ! 9: * ! 10: * Redistribution and use in source and binary forms, with or without ! 11: * modification, are permitted provided that the following conditions ! 12: * are met: ! 13: * 1. Redistributions of source code must retain the above copyright ! 14: * notice, this list of conditions and the following disclaimer. ! 15: * 2. Redistributions in binary form must reproduce the above copyright ! 16: * notice, this list of conditions and the following disclaimer in the ! 17: * documentation and/or other materials provided with the distribution. ! 18: * 3. All advertising materials mentioning features or use of this software ! 19: * must display the following acknowledgement: ! 20: * This product includes software developed by Matt Fredette. ! 21: * 4. The name of the author may not be used to endorse or promote products ! 22: * derived from this software without specific prior written permission. ! 23: * ! 24: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ! 25: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 26: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 27: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, ! 28: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ! 29: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 30: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ! 32: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ! 33: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ! 34: * POSSIBILITY OF SUCH DAMAGE. ! 35: */ ! 36: ! 37: #include <tme/common.h> ! 38: _TME_RCSID("$Id: stp22xx.c,v 1.4 2009/09/07 15:03:19 fredette Exp $"); ! 39: ! 40: /* includes: */ ! 41: #include "stp22xx-impl.h" ! 42: ! 43: /* this busies a generic bus connection: */ ! 44: struct tme_bus_connection * ! 45: tme_stp22xx_busy_bus(struct tme_stp22xx *stp22xx, ! 46: tme_uint32_t conn_index) ! 47: { ! 48: struct tme_bus_connection *conn_bus; ! 49: ! 50: /* if the connection index is valid: */ ! 51: conn_bus = NULL; ! 52: if (__tme_predict_true(conn_index != stp22xx->tme_stp22xx_conn_index_null)) { ! 53: ! 54: /* if there is a connection at this index: */ ! 55: conn_bus = stp22xx->tme_stp22xx_conns[conn_index].tme_stp22xx_conn_bus; ! 56: if (__tme_predict_true(conn_bus != NULL)) { ! 57: ! 58: } ! 59: } ! 60: ! 61: return (conn_bus); ! 62: } ! 63: ! 64: /* this unbusies a generic bus connection: */ ! 65: void ! 66: tme_stp22xx_unbusy_bus(struct tme_stp22xx *stp22xx, ! 67: struct tme_bus_connection *conn_bus) ! 68: { ! 69: ! 70: /* the connection must be valid: */ ! 71: assert (conn_bus != NULL); ! 72: } ! 73: ! 74: /* this busies a slave generic bus connection: */ ! 75: struct tme_bus_connection * ! 76: tme_stp22xx_slave_busy_bus(struct tme_stp22xx *stp22xx, ! 77: tme_uint32_t slave_conn_index) ! 78: { ! 79: struct tme_bus_connection *slave_conn_bus; ! 80: ! 81: /* if the connection index is valid: */ ! 82: slave_conn_bus = tme_stp22xx_busy_bus(stp22xx, slave_conn_index); ! 83: if (__tme_predict_true(slave_conn_bus != NULL)) { ! 84: ! 85: /* this is now the busy slave connection: */ ! 86: assert (stp22xx->tme_stp22xx_slave_conn_bus == NULL); ! 87: stp22xx->tme_stp22xx_slave_conn_bus = slave_conn_bus; ! 88: } ! 89: return (slave_conn_bus); ! 90: } ! 91: ! 92: /* this unbusies a slave generic bus connection: */ ! 93: void ! 94: tme_stp22xx_slave_unbusy(struct tme_stp22xx *stp22xx) ! 95: { ! 96: ! 97: /* unbusy the slave connection: */ ! 98: tme_stp22xx_unbusy_bus(stp22xx, stp22xx->tme_stp22xx_slave_conn_bus); ! 99: ! 100: /* there is now no busy slave connection: */ ! 101: stp22xx->tme_stp22xx_slave_conn_bus = NULL; ! 102: } ! 103: ! 104: /* this enters without locking the mutex: */ ! 105: static struct tme_stp22xx * ! 106: _tme_stp22xx_enter_locked(struct tme_stp22xx *stp22xx) ! 107: { ! 108: signed long completion_i; ! 109: struct tme_completion *completion; ! 110: _tme_stp22xx_completion_handler_t handler; ! 111: ! 112: /* loop over the completions: */ ! 113: completion_i = TME_STP22XX_COMPLETIONS_MAX - 1; ! 114: completion = &stp22xx->tme_stp22xx_completions[completion_i]; ! 115: do { ! 116: ! 117: /* if this completion is valid: */ ! 118: if (tme_completion_is_valid(completion)) { ! 119: ! 120: /* make a read-before-read barrier: */ ! 121: tme_memory_barrier(stp22xx, stp22xx->tme_stp22xx_sizeof, TME_MEMORY_BARRIER_WRITE_BEFORE_WRITE); ! 122: ! 123: /* invalidate the completion: */ ! 124: tme_completion_invalidate(completion); ! 125: ! 126: /* call the completion handler: */ ! 127: handler = stp22xx->tme_stp22xx_completion_handlers[completion_i]; ! 128: assert (handler != NULL); ! 129: stp22xx->tme_stp22xx_completion_handlers[completion_i] = NULL; ! 130: (*handler)(stp22xx, ! 131: completion, ! 132: stp22xx->tme_stp22xx_completion_args[completion_i]); ! 133: } ! 134: ! 135: completion--; ! 136: } while (--completion_i >= 0); ! 137: ! 138: return (stp22xx); ! 139: } ! 140: ! 141: /* this enters: */ ! 142: struct tme_stp22xx * ! 143: tme_stp22xx_enter(struct tme_stp22xx *stp22xx) ! 144: { ! 145: ! 146: /* lock the mutex: */ ! 147: tme_mutex_lock(&stp22xx->tme_stp22xx_mutex); ! 148: ! 149: /* finish the enter: */ ! 150: return (_tme_stp22xx_enter_locked(stp22xx)); ! 151: } ! 152: ! 153: /* this enters as the bus master: */ ! 154: struct tme_stp22xx * ! 155: tme_stp22xx_enter_master(struct tme_bus_connection *master_conn_bus) ! 156: { ! 157: struct tme_stp22xx *stp22xx; ! 158: ! 159: #if TME_STP22XX_BUS_TRANSITION ! 160: signed long completion_i; ! 161: struct tme_completion *completion; ! 162: ! 163: /* if the bus master was making a callout through the bus: */ ! 164: #if !TME_THREADS_COOPERATIVE ! 165: #error "preemptive threads not supported yet" ! 166: #endif /* !TME_THREADS_COOPERATIVE */ ! 167: stp22xx = master_conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 168: if (stp22xx->tme_stp22xx_master_completion != NULL) { ! 169: ! 170: /* find the completion for that callout and force it to be valid. ! 171: this is necessary since we may be reentered by a new master ! 172: before the original callout returns: */ ! 173: completion_i = TME_STP22XX_COMPLETIONS_MAX - 1; ! 174: for (;;) { ! 175: if (stp22xx->tme_stp22xx_completion_handlers[completion_i] ! 176: == tme_stp22xx_complete_master) { ! 177: break; ! 178: } ! 179: --completion_i; ! 180: assert (completion_i >= 0); ! 181: } ! 182: assert (stp22xx->tme_stp22xx_completion_args[completion_i] ! 183: == stp22xx->tme_stp22xx_master_completion); ! 184: completion = &stp22xx->tme_stp22xx_completions[completion_i]; ! 185: if (!tme_completion_is_valid(completion)) { ! 186: tme_completion_validate(completion); ! 187: } ! 188: } ! 189: ! 190: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 191: ! 192: /* enter: */ ! 193: stp22xx = tme_stp22xx_enter(master_conn_bus->tme_bus_connection.tme_connection_element->tme_element_private); ! 194: ! 195: /* only the bus master can cause a callout through the bus, and the ! 196: bus master can only cause one such callout at a time: */ ! 197: assert (stp22xx->tme_stp22xx_master_completion == NULL); ! 198: ! 199: return (stp22xx); ! 200: } ! 201: ! 202: /* this runs: */ ! 203: static void ! 204: _tme_stp22xx_run(struct tme_stp22xx *stp22xx) ! 205: { ! 206: ! 207: /* if the run function is not running: */ ! 208: if (!stp22xx->tme_stp22xx_running) { ! 209: ! 210: /* the run function is now running: */ ! 211: stp22xx->tme_stp22xx_running = TRUE; ! 212: ! 213: /* call the run function: */ ! 214: (*stp22xx->tme_stp22xx_run)(stp22xx); ! 215: ! 216: /* the run function is not running: */ ! 217: stp22xx->tme_stp22xx_running = FALSE; ! 218: } ! 219: } ! 220: ! 221: /* this leaves: */ ! 222: void ! 223: tme_stp22xx_leave(struct tme_stp22xx *stp22xx) ! 224: { ! 225: signed long completion_i; ! 226: struct tme_completion *completion; ! 227: struct tme_completion *completions_delayed[TME_STP22XX_COMPLETIONS_DELAYED_MAX]; ! 228: ! 229: /* run: */ ! 230: _tme_stp22xx_run(stp22xx); ! 231: ! 232: /* get any completions whose validations were delayed: */ ! 233: for (completion_i = 0;; completion_i++) { ! 234: completion = stp22xx->tme_stp22xx_completions_delayed[completion_i]; ! 235: if (completion == NULL) { ! 236: break; ! 237: } ! 238: stp22xx->tme_stp22xx_completions_delayed[completion_i] = NULL; ! 239: completions_delayed[completion_i] = completion; ! 240: } ! 241: ! 242: /* unlock the mutex: */ ! 243: tme_mutex_unlock(&stp22xx->tme_stp22xx_mutex); ! 244: ! 245: /* validate any completions: */ ! 246: for (; --completion_i >= 0; ) { ! 247: tme_completion_validate(completions_delayed[completion_i]); ! 248: } ! 249: } ! 250: ! 251: /* this waits on a condition, with an optional sleep time: */ ! 252: void ! 253: tme_stp22xx_cond_sleep_yield(struct tme_stp22xx *stp22xx, ! 254: struct tme_stp22xx_cond *cond, ! 255: const struct timeval *sleep) ! 256: { ! 257: signed long completion_i; ! 258: struct tme_completion *completion; ! 259: ! 260: /* this condition must be idle: */ ! 261: assert (cond->tme_stp22xx_cond_state == TME_STP22XX_COND_STATE_IDLE); ! 262: ! 263: /* we are now running, before waiting on this condition: */ ! 264: cond->tme_stp22xx_cond_state = TME_STP22XX_COND_STATE_RUNNING; ! 265: ! 266: /* run: */ ! 267: _tme_stp22xx_run(stp22xx); ! 268: ! 269: /* if this condition was notified while we were running: */ ! 270: if (cond->tme_stp22xx_cond_state == TME_STP22XX_COND_STATE_NOTIFIED) { ! 271: ! 272: /* this condition is idle again: */ ! 273: cond->tme_stp22xx_cond_state = TME_STP22XX_COND_STATE_IDLE; ! 274: ! 275: return; ! 276: } ! 277: ! 278: /* the condition must still be running: */ ! 279: assert (cond->tme_stp22xx_cond_state == TME_STP22XX_COND_STATE_RUNNING); ! 280: ! 281: /* make a total write-after-write barrier, to force writes to the ! 282: completion states to happen before validation: */ ! 283: tme_memory_barrier(0, 0, TME_MEMORY_BARRIER_WRITE_BEFORE_WRITE); ! 284: ! 285: /* validate any completions whose validations were delayed: */ ! 286: for (completion_i = 0;; completion_i++) { ! 287: completion = stp22xx->tme_stp22xx_completions_delayed[completion_i]; ! 288: if (completion == NULL) { ! 289: break; ! 290: } ! 291: stp22xx->tme_stp22xx_completions_delayed[completion_i] = NULL; ! 292: tme_completion_validate(completion); ! 293: } ! 294: ! 295: /* we are now waiting on this condition, unless threading is ! 296: cooperative, in which case the condition will be idle again the ! 297: next time this thread runs: */ ! 298: cond->tme_stp22xx_cond_state ! 299: = (TME_THREADS_COOPERATIVE ! 300: ? TME_STP22XX_COND_STATE_IDLE ! 301: : TME_STP22XX_COND_STATE_WAITING); ! 302: ! 303: /* sleep or wait on the condition variable: */ ! 304: if (sleep != NULL) { ! 305: tme_cond_sleep_yield(&cond->tme_stp22xx_cond_cond, ! 306: &stp22xx->tme_stp22xx_mutex, ! 307: sleep); ! 308: } ! 309: else { ! 310: tme_cond_wait_yield(&cond->tme_stp22xx_cond_cond, ! 311: &stp22xx->tme_stp22xx_mutex); ! 312: } ! 313: ! 314: /* this condition is idle again: */ ! 315: cond->tme_stp22xx_cond_state = TME_STP22XX_COND_STATE_IDLE; ! 316: ! 317: /* reenter: */ ! 318: _tme_stp22xx_enter_locked(stp22xx); ! 319: } ! 320: ! 321: /* this validates a completion: */ ! 322: /* NB: completion may be NULL: */ ! 323: void ! 324: tme_stp22xx_completion_validate(struct tme_stp22xx *stp22xx, ! 325: struct tme_completion *completion) ! 326: { ! 327: unsigned long completion_i; ! 328: ! 329: /* we delay validating completions: */ ! 330: for (completion_i = 0;; completion_i++) { ! 331: assert (completion_i < TME_STP22XX_COMPLETIONS_DELAYED_MAX); ! 332: if (stp22xx->tme_stp22xx_completions_delayed[completion_i] == NULL) { ! 333: break; ! 334: } ! 335: } ! 336: stp22xx->tme_stp22xx_completions_delayed[completion_i] = completion; ! 337: } ! 338: ! 339: /* this allocates a completion: */ ! 340: struct tme_completion * ! 341: tme_stp22xx_completion_alloc(struct tme_stp22xx *stp22xx, ! 342: _tme_stp22xx_completion_handler_t handler, ! 343: void *arg) ! 344: { ! 345: signed long completion_i; ! 346: struct tme_completion *completion; ! 347: ! 348: /* find a free completion: */ ! 349: completion_i = TME_STP22XX_COMPLETIONS_MAX - 1; ! 350: for (; stp22xx->tme_stp22xx_completion_handlers[completion_i] != NULL; ) { ! 351: completion_i--; ! 352: assert (completion_i >= 0); ! 353: } ! 354: ! 355: /* allocate this completion: */ ! 356: stp22xx->tme_stp22xx_completion_handlers[completion_i] = handler; ! 357: stp22xx->tme_stp22xx_completion_args[completion_i] = arg; ! 358: ! 359: /* the completion can't still (or already) be valid: */ ! 360: completion = &stp22xx->tme_stp22xx_completions[completion_i]; ! 361: assert (!tme_completion_is_valid(completion)); ! 362: ! 363: /* return the completion: */ ! 364: return (completion); ! 365: } ! 366: ! 367: /* this calls out a bus signal to a connection: */ ! 368: void ! 369: tme_stp22xx_callout_signal(struct tme_stp22xx *stp22xx, ! 370: tme_uint32_t conn_index, ! 371: unsigned int signal, ! 372: _tme_stp22xx_completion_handler_t handler) ! 373: { ! 374: struct tme_bus_connection *conn_bus; ! 375: struct tme_completion completion_buffer; ! 376: struct tme_completion *completion; ! 377: struct tme_bus_connection *conn_bus_other; ! 378: ! 379: /* if there is a connection at this index: */ ! 380: conn_bus = tme_stp22xx_busy_bus(stp22xx, conn_index); ! 381: if (conn_bus != NULL) { ! 382: ! 383: /* if the connection at this index doesn't care about bus ! 384: signals: */ ! 385: conn_bus_other = (struct tme_bus_connection *) conn_bus->tme_bus_connection.tme_connection_other; ! 386: if (conn_bus_other->tme_bus_signal == NULL) { ! 387: ! 388: /* unbusy the bus connection: */ ! 389: tme_stp22xx_unbusy_bus(stp22xx, conn_bus); ! 390: ! 391: /* behave as if there is no connection at this index: */ ! 392: conn_bus = NULL; ! 393: } ! 394: } ! 395: ! 396: /* if there is no connection at this index: */ ! 397: if (conn_bus == NULL) { ! 398: ! 399: /* call the completion handler directly: */ ! 400: completion_buffer.tme_completion_error = TME_OK; ! 401: (*handler)(stp22xx, &completion_buffer, (void *) NULL); ! 402: return; ! 403: } ! 404: ! 405: /* allocate a completion: */ ! 406: completion = tme_stp22xx_completion_alloc(stp22xx, handler, (void *) NULL); ! 407: ! 408: /* leave: */ ! 409: tme_stp22xx_leave(stp22xx); ! 410: ! 411: /* call out the bus signal: */ ! 412: conn_bus_other = (struct tme_bus_connection *) conn_bus->tme_bus_connection.tme_connection_other; ! 413: #if TME_STP22XX_BUS_TRANSITION ! 414: completion->tme_completion_error = ! 415: (*conn_bus_other->tme_bus_signal) ! 416: (conn_bus_other, ! 417: signal); ! 418: tme_completion_validate(completion); ! 419: #else /* !TME_STP22XX_BUS_TRANSITION */ ! 420: #error WRITEME ! 421: #endif /* !TME_STP22XX_BUS_TRANSITION */ ! 422: ! 423: /* reenter: */ ! 424: tme_stp22xx_enter(stp22xx); ! 425: ! 426: /* unbusy the bus connection: */ ! 427: tme_stp22xx_unbusy_bus(stp22xx, conn_bus); ! 428: } ! 429: ! 430: /* this completes a bus operation between master and slave: */ ! 431: void ! 432: tme_stp22xx_complete_master(struct tme_stp22xx *stp22xx, ! 433: struct tme_completion *completion, ! 434: void *__master_completion) ! 435: { ! 436: struct tme_completion **_master_completion; ! 437: struct tme_completion *master_completion; ! 438: ! 439: /* unbusy the slave connection: */ ! 440: tme_stp22xx_slave_unbusy(stp22xx); ! 441: ! 442: /* if this bus operation was not aborted: */ ! 443: _master_completion = (struct tme_completion **) __master_completion; ! 444: if (stp22xx->tme_stp22xx_master_completion == _master_completion) { ! 445: ! 446: /* pass any slave error and scalar return value back to the master: */ ! 447: master_completion = *_master_completion; ! 448: master_completion->tme_completion_error = completion->tme_completion_error; ! 449: master_completion->tme_completion_scalar = completion->tme_completion_scalar; ! 450: ! 451: /* this bus operation is completed: */ ! 452: stp22xx->tme_stp22xx_master_completion = NULL; ! 453: ! 454: /* validate the completion: */ ! 455: tme_stp22xx_completion_validate(stp22xx, master_completion); ! 456: } ! 457: } ! 458: ! 459: /* this completes a bus grant: */ ! 460: void ! 461: tme_stp22xx_complete_bg(struct tme_stp22xx *stp22xx, ! 462: struct tme_completion *completion, ! 463: void *arg) ! 464: { ! 465: stp22xx->tme_stp22xx_master_conn_index ! 466: = stp22xx->tme_stp22xx_master_conn_index_pending; ! 467: stp22xx->tme_stp22xx_master_conn_index_pending = stp22xx->tme_stp22xx_conn_index_null; ! 468: ! 469: /* unused: */ ! 470: completion = 0; ! 471: arg = 0; ! 472: } ! 473: ! 474: /* this is a no-op completion: */ ! 475: void ! 476: tme_stp22xx_complete_nop(struct tme_stp22xx *stp22xx, ! 477: struct tme_completion *completion, ! 478: void *arg) ! 479: { ! 480: /* unused: */ ! 481: stp22xx = 0; ! 482: completion = 0; ! 483: arg = 0; ! 484: } ! 485: ! 486: /* this runs a slave bus cycle: */ ! 487: void ! 488: tme_stp22xx_slave_cycle(struct tme_bus_connection *master_conn_bus, ! 489: tme_uint32_t slave_conn_index, ! 490: struct tme_bus_cycle *master_cycle, ! 491: tme_uint32_t *_master_fast_cycle_types, ! 492: struct tme_completion **_master_completion) ! 493: { ! 494: struct tme_stp22xx *stp22xx; ! 495: struct tme_bus_connection *slave_conn_bus; ! 496: int completion_error; ! 497: #if TME_STP22XX_BUS_TRANSITION ! 498: struct tme_bus_tlb tlb_local; ! 499: int rc; ! 500: tme_uint8_t *memory; ! 501: tme_bus_addr_t tlb_cycle_address; ! 502: int shift; ! 503: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 504: struct tme_completion *completion; ! 505: struct tme_bus_connection *slave_conn_bus_other; ! 506: struct tme_completion *master_completion; ! 507: ! 508: /* recover our data structure: */ ! 509: stp22xx = master_conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 510: ! 511: /* this cycle must not have been aborted: */ ! 512: assert (stp22xx->tme_stp22xx_master_completion == _master_completion); ! 513: ! 514: /* busy the connection to any slave: */ ! 515: slave_conn_bus = tme_stp22xx_slave_busy_bus(stp22xx, slave_conn_index); ! 516: ! 517: /* if the connection index is invalid, or if there is no slave at ! 518: this connection index: */ ! 519: if (__tme_predict_false(slave_conn_bus == NULL)) { ! 520: ! 521: /* complete with an error: */ ! 522: completion_error = ENOENT; ! 523: } ! 524: ! 525: /* otherwise, if the master is trying a cycle to itself: */ ! 526: else if (__tme_predict_false(slave_conn_bus == master_conn_bus)) { ! 527: ! 528: /* unbusy the connection to the slave: */ ! 529: tme_stp22xx_slave_unbusy(stp22xx); ! 530: ! 531: /* complete with an error: */ ! 532: completion_error = EIO; ! 533: } ! 534: ! 535: /* otherwise, we can run this cycle: */ ! 536: else { ! 537: ! 538: #if TME_STP22XX_BUS_TRANSITION ! 539: ! 540: /* fill a TLB entry for this address: */ ! 541: tlb_local.tme_bus_tlb_token = &stp22xx->tme_stp22xx_slave_cycle_tlb_token; ! 542: slave_conn_bus_other = (struct tme_bus_connection *) slave_conn_bus->tme_bus_connection.tme_connection_other; ! 543: rc = ((*slave_conn_bus_other->tme_bus_tlb_fill) ! 544: (slave_conn_bus_other, ! 545: &tlb_local, ! 546: master_cycle->tme_bus_cycle_address, ! 547: master_cycle->tme_bus_cycle_type)); ! 548: assert (rc == TME_OK); ! 549: ! 550: /* the master can't do any fast transfers that this TLB entry ! 551: doesn't allow: */ ! 552: if (tlb_local.tme_bus_tlb_emulator_off_read == TME_EMULATOR_OFF_UNDEF) { ! 553: *_master_fast_cycle_types &= ~TME_BUS_CYCLE_READ; ! 554: } ! 555: if (tlb_local.tme_bus_tlb_emulator_off_write == TME_EMULATOR_OFF_UNDEF) { ! 556: *_master_fast_cycle_types &= ~TME_BUS_CYCLE_WRITE; ! 557: } ! 558: ! 559: /* if this cycle can be done fast: */ ! 560: /* NB: this breaks tme_shared and const: */ ! 561: memory ! 562: = (master_cycle->tme_bus_cycle_type == TME_BUS_CYCLE_READ ! 563: ? (tme_uint8_t *) tlb_local.tme_bus_tlb_emulator_off_read ! 564: : (tme_uint8_t *) tlb_local.tme_bus_tlb_emulator_off_write); ! 565: if (memory != TME_EMULATOR_OFF_UNDEF) { ! 566: ! 567: /* do the fast transfer: */ ! 568: tme_bus_cycle_xfer_memory(master_cycle, memory, tlb_local.tme_bus_tlb_addr_last); ! 569: ! 570: /* unbusy the connection to the slave: */ ! 571: tme_stp22xx_slave_unbusy(stp22xx); ! 572: ! 573: /* complete with success: */ ! 574: master_completion = *_master_completion; ! 575: master_completion->tme_completion_error = TME_OK; ! 576: tme_stp22xx_completion_validate(stp22xx, master_completion); ! 577: stp22xx->tme_stp22xx_master_completion = NULL; ! 578: return; ! 579: } ! 580: ! 581: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 582: ! 583: /* when we complete, we will will complete for the master: */ ! 584: completion ! 585: = tme_stp22xx_completion_alloc(stp22xx, ! 586: tme_stp22xx_complete_master, ! 587: _master_completion); ! 588: ! 589: /* leave: */ ! 590: tme_stp22xx_leave(stp22xx); ! 591: ! 592: /* run this cycle: */ ! 593: #if TME_STP22XX_BUS_TRANSITION ! 594: tlb_cycle_address = tlb_local.tme_bus_tlb_addr_offset + master_cycle->tme_bus_cycle_address; ! 595: shift = tlb_local.tme_bus_tlb_addr_shift; ! 596: if (shift < 0) { ! 597: tlb_cycle_address <<= (0 - shift); ! 598: } ! 599: else if (shift > 0) { ! 600: tlb_cycle_address >>= shift; ! 601: } ! 602: master_cycle->tme_bus_cycle_address = tlb_cycle_address; ! 603: /* NB: we may be reentered before this cycle callout returns, ! 604: usually by this slave device immediately turning around to ! 605: become a master. unfortunately, this means that ! 606: tme_stp22xx_enter_master() will have to validate the first ! 607: master's completion itself, before we would normally do it ! 608: here. this means that we also have to predict how the cycle ! 609: will complete - and we assume that if the slave does turn ! 610: around to become a master, that the cycle completed ! 611: successfully: */ ! 612: completion->tme_completion_error = TME_OK; ! 613: rc ! 614: = ((*tlb_local.tme_bus_tlb_cycle) ! 615: (tlb_local.tme_bus_tlb_cycle_private, ! 616: master_cycle)); ! 617: if (stp22xx->tme_stp22xx_master_completion != _master_completion) { ! 618: assert (rc == TME_OK); ! 619: } ! 620: else { ! 621: completion->tme_completion_error = rc; ! 622: tme_completion_validate(completion); ! 623: } ! 624: #else /* !TME_STP22XX_BUS_TRANSITION */ ! 625: #error WRITEME ! 626: #endif /* !TME_STP22XX_BUS_TRANSITION */ ! 627: ! 628: /* reenter: */ ! 629: tme_stp22xx_enter(stp22xx); ! 630: ! 631: return; ! 632: } ! 633: ! 634: /* complete with the error: */ ! 635: master_completion = *_master_completion; ! 636: master_completion->tme_completion_error = completion_error; ! 637: tme_stp22xx_completion_validate(stp22xx, master_completion); ! 638: stp22xx->tme_stp22xx_master_completion = NULL; ! 639: *_master_fast_cycle_types = 0; ! 640: } ! 641: ! 642: /* this fills a TLB entry: */ ! 643: void ! 644: tme_stp22xx_tlb_fill(struct tme_bus_connection *agent_conn_bus, ! 645: struct tme_bus_tlb *tlb, ! 646: tme_uint32_t slave_conn_index, ! 647: tme_bus_addr64_t slave_address, ! 648: unsigned int cycle_type) ! 649: { ! 650: struct tme_stp22xx *stp22xx; ! 651: struct tme_bus_connection *slave_conn_bus; ! 652: struct tme_bus_connection *slave_conn_bus_other; ! 653: #if TME_STP22XX_BUS_TRANSITION ! 654: int rc; ! 655: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 656: ! 657: /* recover our data structure: */ ! 658: stp22xx = agent_conn_bus->tme_bus_connection.tme_connection_element->tme_element_private; ! 659: ! 660: /* busy the connection to any slave: */ ! 661: slave_conn_bus = tme_stp22xx_busy_bus(stp22xx, slave_conn_index); ! 662: ! 663: /* if the connection index is invalid, or if there is no slave at ! 664: this connection index, or if the agent is filling a TLB for an ! 665: address in itself: */ ! 666: if (__tme_predict_false(slave_conn_bus == NULL ! 667: || slave_conn_bus == agent_conn_bus)) { ! 668: ! 669: /* unbusy any connection to the slave: */ ! 670: if (slave_conn_bus != NULL) { ! 671: tme_stp22xx_unbusy_bus(stp22xx, slave_conn_bus); ! 672: } ! 673: ! 674: /* initialize the TLB entry: */ ! 675: tme_bus_tlb_initialize(tlb); ! 676: ! 677: /* our caller will map this TLB entry from covering all addresses ! 678: to only covering a region's addresses: */ ! 679: tlb->tme_bus_tlb_addr_first = 0; ! 680: tlb->tme_bus_tlb_addr_last = 0 - (tme_bus_addr_t) 1; ! 681: } ! 682: ! 683: /* otherwise, the slave can fill this TLB entry: */ ! 684: else { ! 685: ! 686: /* leave: */ ! 687: tme_stp22xx_leave(stp22xx); ! 688: ! 689: /* fill this TLB entry: */ ! 690: slave_conn_bus_other = (struct tme_bus_connection *) slave_conn_bus->tme_bus_connection.tme_connection_other; ! 691: #if TME_STP22XX_BUS_TRANSITION ! 692: rc = ! 693: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 694: (*slave_conn_bus_other->tme_bus_tlb_fill) ! 695: (slave_conn_bus_other, ! 696: tlb, ! 697: slave_address, ! 698: cycle_type); ! 699: #if TME_STP22XX_BUS_TRANSITION ! 700: assert (rc == TME_OK); ! 701: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 702: ! 703: /* reenter: */ ! 704: tme_stp22xx_enter(stp22xx); ! 705: ! 706: /* unbusy the connection to the slave: */ ! 707: tme_stp22xx_unbusy_bus(stp22xx, slave_conn_bus); ! 708: } ! 709: } ! 710: ! 711: #if TME_STP22XX_BUS_TRANSITION ! 712: ! 713: /* this is the bus TLB set add transition glue: */ ! 714: #undef tme_stp22xx_tlb_set_add ! 715: int ! 716: tme_stp22xx_tlb_set_add_transition(struct tme_bus_connection *agent_conn_bus, ! 717: struct tme_bus_tlb_set_info *tlb_set_info) ! 718: { ! 719: struct tme_completion completion_buffer; ! 720: tme_completion_init(&completion_buffer); ! 721: tme_stp22xx_tlb_set_add(agent_conn_bus, ! 722: tlb_set_info, ! 723: &completion_buffer); ! 724: return (completion_buffer.tme_completion_error); ! 725: } ! 726: ! 727: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 728: ! 729: /* this adds a TLB set: */ ! 730: void ! 731: tme_stp22xx_tlb_set_add(struct tme_bus_connection *agent_conn_bus, ! 732: struct tme_bus_tlb_set_info *tlb_set_info, ! 733: struct tme_completion *agent_completion) ! 734: { ! 735: struct tme_stp22xx *stp22xx; ! 736: ! 737: /* enter: */ ! 738: stp22xx = tme_stp22xx_enter((struct tme_stp22xx *) agent_conn_bus->tme_bus_connection.tme_connection_element->tme_element_private); ! 739: ! 740: /* if this TLB set provides a bus context register: */ ! 741: if (tlb_set_info->tme_bus_tlb_set_info_bus_context != NULL) { ! 742: ! 743: /* this bus only has one context: */ ! 744: *tlb_set_info->tme_bus_tlb_set_info_bus_context = 0; ! 745: tlb_set_info->tme_bus_tlb_set_info_bus_context_max = 0; ! 746: } ! 747: ! 748: /* leave: */ ! 749: agent_completion->tme_completion_error = TME_OK; ! 750: tme_stp22xx_completion_validate(stp22xx, agent_completion); ! 751: tme_stp22xx_leave(stp22xx); ! 752: } ! 753: ! 754: /* this notifies a condition: */ ! 755: void ! 756: tme_stp22xx_cond_notify(struct tme_stp22xx_cond *cond) ! 757: { ! 758: ! 759: /* if threading is cooperative, and this condition is idle: */ ! 760: if (TME_THREADS_COOPERATIVE ! 761: && cond->tme_stp22xx_cond_state == TME_STP22XX_COND_STATE_IDLE) { ! 762: ! 763: /* we have to assume that a thread has yielded waiting on this ! 764: condition, but because threading is cooperative, has already ! 765: set the condition back to idle. we can't mark the condition as ! 766: notified, since it would never get set back to idle: */ ! 767: } ! 768: ! 769: /* otherwise, threading is not cooperative, or the condition is not ! 770: idle: */ ! 771: else { ! 772: ! 773: /* this condition must be either running before waiting, or ! 774: waiting: */ ! 775: assert (cond->tme_stp22xx_cond_state == TME_STP22XX_COND_STATE_RUNNING ! 776: || cond->tme_stp22xx_cond_state == TME_STP22XX_COND_STATE_WAITING); ! 777: ! 778: /* this condition has been notified: */ ! 779: cond->tme_stp22xx_cond_state = TME_STP22XX_COND_STATE_NOTIFIED; ! 780: } ! 781: ! 782: /* notify the real condition: */ ! 783: tme_cond_notify(&cond->tme_stp22xx_cond_cond, FALSE); ! 784: } ! 785: ! 786: /* this initializes a condition: */ ! 787: void ! 788: tme_stp22xx_cond_init(struct tme_stp22xx_cond *cond) ! 789: { ! 790: /* this condition is idle: */ ! 791: cond->tme_stp22xx_cond_state = TME_STP22XX_COND_STATE_IDLE; ! 792: tme_cond_init(&cond->tme_stp22xx_cond_cond); ! 793: } ! 794: ! 795: /* this initializes an stp22xx: */ ! 796: void ! 797: tme_stp22xx_init(struct tme_stp22xx *stp22xx, ! 798: unsigned long _sizeof, ! 799: tme_uint32_t conn_index_null) ! 800: { ! 801: unsigned long completion_i; ! 802: ! 803: /* initialize the mutex: */ ! 804: tme_mutex_init(&stp22xx->tme_stp22xx_mutex); ! 805: ! 806: /* set the size of the structure: */ ! 807: stp22xx->tme_stp22xx_sizeof = _sizeof; ! 808: ! 809: /* set the undefined connection index: */ ! 810: stp22xx->tme_stp22xx_conn_index_null = conn_index_null; ! 811: ! 812: /* initialize the completions: */ ! 813: for (completion_i = 0; completion_i < TME_STP22XX_COMPLETIONS_MAX; completion_i++) { ! 814: tme_completion_init(&stp22xx->tme_stp22xx_completions[completion_i]); ! 815: stp22xx->tme_stp22xx_completion_handlers[completion_i] = NULL; ! 816: } ! 817: ! 818: /* initialize the delayed completions: */ ! 819: for (completion_i = 0; completion_i < TME_STP22XX_COMPLETIONS_DELAYED_MAX; completion_i++) { ! 820: stp22xx->tme_stp22xx_completions_delayed[completion_i] = NULL; ! 821: } ! 822: ! 823: /* there is no current bus master: */ ! 824: stp22xx->tme_stp22xx_master_conn_index = conn_index_null; ! 825: ! 826: #if TME_STP22XX_BUS_TRANSITION ! 827: /* initialize the token for filling TLB entries for slave cycles: */ ! 828: tme_token_init(&stp22xx->tme_stp22xx_slave_cycle_tlb_token); ! 829: #endif /* TME_STP22XX_BUS_TRANSITION */ ! 830: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.