![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi-bus.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / scsi|
Return to scsi-bus.c CVS log | Up to [The Machine Emulator] / tme / scsi |
1.1 ! root 1: /* $Id: scsi-bus.c,v 1.4 2003/10/16 02:35:21 fredette Exp $ */ ! 2: ! 3: /* scsi/scsi-bus.c - a generic SCSI bus element: */ ! 4: ! 5: /* ! 6: * Copyright (c) 2003 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: scsi-bus.c,v 1.4 2003/10/16 02:35:21 fredette Exp $"); ! 38: ! 39: /* includes: */ ! 40: #include <tme/generic/scsi.h> ! 41: #ifdef HAVE_STDARG_H ! 42: #include <stdarg.h> ! 43: #else /* HAVE_STDARG_H */ ! 44: #include <varargs.h> ! 45: #endif /* HAVE_STDARG_H */ ! 46: ! 47: /* macros: */ ! 48: ! 49: /* the count of IDs: */ ! 50: #define TME_SCSI_BUS_ID_COUNT (sizeof(tme_scsi_data_t) * 8) ! 51: ! 52: /* the callout flags: */ ! 53: #define TME_SCSI_BUS_CALLOUT_CHECK (0) ! 54: #define TME_SCSI_BUS_CALLOUT_RUNNING TME_BIT(0) ! 55: #define TME_SCSI_BUS_CALLOUTS_MASK (-2) ! 56: #define TME_SCSI_BUS_CALLOUT_CYCLE TME_BIT(1) ! 57: ! 58: /* structures: */ ! 59: ! 60: /* a scsi bus: */ ! 61: struct tme_scsi_bus { ! 62: ! 63: /* backpointer to our element: */ ! 64: struct tme_element *tme_scsi_bus_element; ! 65: ! 66: /* our mutex: */ ! 67: tme_mutex_t tme_scsi_bus_mutex; ! 68: ! 69: /* our connections: */ ! 70: struct tme_connection *tme_scsi_bus_connections; ! 71: ! 72: /* the callout flags: */ ! 73: int tme_scsi_bus_callout_flags; ! 74: ! 75: /* the current bus state: */ ! 76: tme_scsi_control_t tme_scsi_bus_control; ! 77: tme_scsi_control_t tme_scsi_bus_data; ! 78: }; ! 79: ! 80: /* internal information about a SCSI connection: */ ! 81: struct tme_scsi_connection_int { ! 82: ! 83: /* the external SCSI connection: */ ! 84: struct tme_scsi_connection tme_scsi_connection_int; ! 85: ! 86: /* the control and data lines currently asserted by this connection: */ ! 87: tme_scsi_control_t tme_scsi_connection_int_control; ! 88: tme_scsi_data_t tme_scsi_connection_int_data; ! 89: ! 90: /* the SCSI bus state last reported to the connection: */ ! 91: tme_scsi_control_t tme_scsi_connection_int_last_control; ! 92: tme_scsi_control_t tme_scsi_connection_int_last_data; ! 93: ! 94: /* any sequence that this connection is running, and the step ! 95: within that sequence: */ ! 96: const struct tme_scsi_sequence *tme_scsi_connection_int_sequence; ! 97: unsigned int tme_scsi_connection_int_sequence_step; ! 98: ! 99: /* any DMA structure for this connection: */ ! 100: struct tme_scsi_dma *tme_scsi_connection_int_dma; ! 101: ! 102: /* specific callout flags for this connection: */ ! 103: int tme_scsi_connection_int_callout_flags; ! 104: }; ! 105: ! 106: /* the predefined sequence atom type: */ ! 107: typedef unsigned long tme_scsi_sequence_atom_t; ! 108: ! 109: /* globals: */ ! 110: ! 111: /* atoms representing the predefined sequences. the tme SCSI ! 112: interface allows a bus implementation to return predefined ! 113: sequences that are actually completely opaque - despite getting a ! 114: struct tme_scsi_sequence *, SCSI device implementations are not ! 115: allowed to even *dereference* a pointer returned by a bus ! 116: implementation's tme_scsi_connection_sequence_get method. we take ! 117: advantage of this here to make a partial, optimized implementation: */ ! 118: const struct { ! 119: tme_scsi_sequence_atom_t tme_scsi_sequence_info_dma_initiator; ! 120: tme_scsi_sequence_atom_t tme_scsi_sequence_info_dma_target; ! 121: tme_scsi_sequence_atom_t tme_scsi_sequence_wait_select_half[TME_SCSI_BUS_ID_COUNT]; ! 122: tme_scsi_sequence_atom_t tme_scsi_sequence_wait_select_full[TME_SCSI_BUS_ID_COUNT]; ! 123: tme_scsi_sequence_atom_t tme_scsi_sequence_wait_change; ! 124: } _tme_scsi_bus_sequences; ! 125: ! 126: /* the SCSI bus callout function. it must be called with the mutex locked: */ ! 127: static void ! 128: _tme_scsi_bus_callout(struct tme_scsi_bus *scsi_bus, int new_callouts) ! 129: { ! 130: struct tme_scsi_connection_int *conn_int; ! 131: struct tme_scsi_connection *conn_scsi; ! 132: int callouts, later_callouts; ! 133: tme_scsi_control_t control; ! 134: tme_scsi_data_t data; ! 135: int rc; ! 136: ! 137: /* add in any new callouts: */ ! 138: scsi_bus->tme_scsi_bus_callout_flags |= new_callouts; ! 139: ! 140: /* if this function is already running in another thread, simply ! 141: return now. the other thread will do our work: */ ! 142: if (scsi_bus->tme_scsi_bus_callout_flags ! 143: & TME_SCSI_BUS_CALLOUT_RUNNING) { ! 144: return; ! 145: } ! 146: ! 147: /* callouts are now running: */ ! 148: scsi_bus->tme_scsi_bus_callout_flags ! 149: |= TME_SCSI_BUS_CALLOUT_RUNNING; ! 150: ! 151: /* assume that we won't need any later callouts: */ ! 152: later_callouts = 0; ! 153: ! 154: /* loop while callouts are needed: */ ! 155: for (; ((callouts ! 156: = scsi_bus->tme_scsi_bus_callout_flags) ! 157: & TME_SCSI_BUS_CALLOUTS_MASK); ) { ! 158: ! 159: /* clear the needed callouts: */ ! 160: scsi_bus->tme_scsi_bus_callout_flags ! 161: = (callouts ! 162: & ~TME_SCSI_BUS_CALLOUTS_MASK); ! 163: callouts &= TME_SCSI_BUS_CALLOUTS_MASK; ! 164: ! 165: /* if we need to call out SCSI bus cycles: */ ! 166: if (callouts & TME_SCSI_BUS_CALLOUT_CYCLE) { ! 167: ! 168: /* loop over all devices on the bus: */ ! 169: for (conn_int ! 170: = ((struct tme_scsi_connection_int *) ! 171: scsi_bus->tme_scsi_bus_connections); ! 172: conn_int != NULL; ! 173: conn_int ! 174: = ((struct tme_scsi_connection_int *) ! 175: conn_int->tme_scsi_connection_int.tme_scsi_connection.tme_connection_next)) { ! 176: ! 177: /* if this device doesn't need a callout, continue: */ ! 178: if (!(conn_int->tme_scsi_connection_int_callout_flags ! 179: & TME_SCSI_BUS_CALLOUT_CYCLE)) { ! 180: continue; ! 181: } ! 182: ! 183: /* clear the callout flag on this device: */ ! 184: conn_int->tme_scsi_connection_int_callout_flags ! 185: &= ~TME_SCSI_BUS_CALLOUT_CYCLE; ! 186: ! 187: /* get the current state of the bus: */ ! 188: control = scsi_bus->tme_scsi_bus_control; ! 189: data = scsi_bus->tme_scsi_bus_data; ! 190: ! 191: /* remember this last bus state called out to this connection: */ ! 192: conn_int->tme_scsi_connection_int_last_control ! 193: = control; ! 194: conn_int->tme_scsi_connection_int_last_data ! 195: = data; ! 196: ! 197: /* unlock the mutex: */ ! 198: tme_mutex_unlock(&scsi_bus->tme_scsi_bus_mutex); ! 199: ! 200: /* do the callout: */ ! 201: conn_scsi ! 202: = ((struct tme_scsi_connection *) ! 203: conn_int->tme_scsi_connection_int.tme_scsi_connection.tme_connection_other); ! 204: rc = ((*conn_scsi->tme_scsi_connection_cycle) ! 205: (conn_scsi, ! 206: control, ! 207: data, ! 208: conn_int->tme_scsi_connection_int_sequence, ! 209: NULL)); ! 210: ! 211: /* lock the mutex: */ ! 212: tme_mutex_lock(&scsi_bus->tme_scsi_bus_mutex); ! 213: ! 214: /* if the callout was unsuccessful, remember that at some later ! 215: time this callout should be attempted again: */ ! 216: if (rc != TME_OK) { ! 217: conn_int->tme_scsi_connection_int_callout_flags ! 218: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 219: later_callouts ! 220: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 221: } ! 222: } ! 223: } ! 224: } ! 225: ! 226: /* put in any later callouts, and clear that callouts are running: */ ! 227: scsi_bus->tme_scsi_bus_callout_flags = later_callouts; ! 228: } ! 229: ! 230: /* this handles a SCSI bus cycle: */ ! 231: static int ! 232: _tme_scsi_bus_cycle(struct tme_scsi_connection *conn_scsi, ! 233: tme_scsi_control_t control, ! 234: tme_scsi_data_t data, ! 235: const struct tme_scsi_sequence *sequence_asker, ! 236: struct tme_scsi_dma *dma) ! 237: { ! 238: struct tme_scsi_bus *scsi_bus; ! 239: struct tme_scsi_connection_int *conn_int_asker, *conn_int; ! 240: const struct tme_scsi_sequence *sequence; ! 241: struct tme_scsi_connection_int *dma_initiator; ! 242: struct tme_scsi_connection_int *dma_target; ! 243: struct tme_scsi_dma *dma_in, *dma_out; ! 244: unsigned long count; ! 245: int bus_changed; ! 246: int new_callouts; ! 247: int again; ! 248: tme_scsi_data_t id; ! 249: ! 250: /* recover our bus and internal connection: */ ! 251: scsi_bus = conn_scsi->tme_scsi_connection.tme_connection_element->tme_element_private; ! 252: conn_int_asker = (struct tme_scsi_connection_int *) conn_scsi; ! 253: ! 254: /* assume we won't need any new callouts: */ ! 255: new_callouts = 0; ! 256: ! 257: /* lock the mutex: */ ! 258: tme_mutex_lock(&scsi_bus->tme_scsi_bus_mutex); ! 259: ! 260: /* update the signals that this device is asserting: */ ! 261: conn_int_asker->tme_scsi_connection_int_control = control; ! 262: conn_int_asker->tme_scsi_connection_int_data = data; ! 263: ! 264: /* update the sequence for this device: */ ! 265: if (sequence_asker != NULL) { ! 266: ! 267: /* being a partial implementation, we don't support device-defined ! 268: sequences - any sequence must be a predefined sequence that we ! 269: returned: */ ! 270: if ((sequence_asker ! 271: < (const struct tme_scsi_sequence *) (char *) &_tme_scsi_bus_sequences) ! 272: || (sequence_asker ! 273: >= (const struct tme_scsi_sequence *) (char *) (&_tme_scsi_bus_sequences + 1))) { ! 274: abort(); ! 275: } ! 276: } ! 277: conn_int_asker->tme_scsi_connection_int_sequence = sequence_asker; ! 278: conn_int_asker->tme_scsi_connection_int_sequence_step = 0; ! 279: ! 280: /* update the DMA structure for this device. being a partial ! 281: implementation, we only support 8-bit asynchronous DMA: */ ! 282: if (dma != NULL) { ! 283: if (((dma->tme_scsi_dma_flags ! 284: & TME_SCSI_DMA_WIDTH) ! 285: != TME_SCSI_DMA_8BIT) ! 286: || (dma->tme_scsi_dma_sync_offset ! 287: != 0)) { ! 288: abort(); ! 289: } ! 290: if (dma->tme_scsi_dma_resid == 0) { ! 291: conn_int_asker->tme_scsi_connection_int_callout_flags ! 292: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 293: conn_int_asker->tme_scsi_connection_int_sequence ! 294: = NULL; ! 295: new_callouts ! 296: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 297: dma = NULL; ! 298: } ! 299: } ! 300: conn_int_asker->tme_scsi_connection_int_dma = dma; ! 301: ! 302: /* if during any iteration of the below loop, we see or cause a ! 303: change on the bus, we want to call out cycles to all devices ! 304: waiting on a simple change: */ ! 305: bus_changed = FALSE; ! 306: ! 307: /* loop until things settle down: */ ! 308: for (again = TRUE; again; ) { ! 309: again = FALSE; ! 310: ! 311: /* get the current state of the bus: */ ! 312: control = 0; ! 313: data = 0; ! 314: for (conn_int ! 315: = ((struct tme_scsi_connection_int *) ! 316: scsi_bus->tme_scsi_bus_connections); ! 317: conn_int != NULL; ! 318: conn_int ! 319: = ((struct tme_scsi_connection_int *) ! 320: conn_int->tme_scsi_connection_int.tme_scsi_connection.tme_connection_next)) { ! 321: control |= conn_int->tme_scsi_connection_int_control; ! 322: data |= conn_int->tme_scsi_connection_int_data; ! 323: } ! 324: if ((control != scsi_bus->tme_scsi_bus_control) ! 325: || (data != scsi_bus->tme_scsi_bus_data)) { ! 326: bus_changed = TRUE; ! 327: } ! 328: scsi_bus->tme_scsi_bus_control = control; ! 329: scsi_bus->tme_scsi_bus_data = data; ! 330: ! 331: /* loop over all devices on the bus: */ ! 332: dma_initiator = NULL; ! 333: dma_target = NULL; ! 334: for (conn_int ! 335: = ((struct tme_scsi_connection_int *) ! 336: scsi_bus->tme_scsi_bus_connections); ! 337: conn_int != NULL; ! 338: conn_int ! 339: = ((struct tme_scsi_connection_int *) ! 340: conn_int->tme_scsi_connection_int.tme_scsi_connection.tme_connection_next)) { ! 341: ! 342: /* dispatch on this device's sequence: */ ! 343: sequence = conn_int->tme_scsi_connection_int_sequence; ! 344: #define SEQUENCE_IS(s, f) \ ! 345: (((s) \ ! 346: >= ((const struct tme_scsi_sequence *) \ ! 347: &_tme_scsi_bus_sequences.f)) \ ! 348: && ((s) \ ! 349: < ((const struct tme_scsi_sequence *) \ ! 350: (&_tme_scsi_bus_sequences.f \ ! 351: + 1)))) ! 352: #define SEQUENCE_INDEX(s, f) \ ! 353: (((const tme_scsi_sequence_atom_t *) (s)) \ ! 354: - &_tme_scsi_bus_sequences.f[0]) ! 355: ! 356: /* a device with no sequence is ignoring the bus completely: */ ! 357: if (sequence == NULL) { ! 358: /* nothing to do: */ ! 359: } ! 360: ! 361: /* a device in TME_SCSI_SEQUENCE_WAIT_CHANGE is waiting on any ! 362: change to the bus state: */ ! 363: else if (SEQUENCE_IS(sequence, tme_scsi_sequence_wait_change)) { ! 364: ! 365: /* if the bus has changed, callout a cycle on this device: */ ! 366: if (bus_changed ! 367: || (control != ! 368: conn_int->tme_scsi_connection_int_last_control) ! 369: || (data ! 370: != conn_int->tme_scsi_connection_int_last_data)) { ! 371: conn_int->tme_scsi_connection_int_callout_flags ! 372: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 373: conn_int->tme_scsi_connection_int_sequence ! 374: = NULL; ! 375: new_callouts ! 376: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 377: } ! 378: } ! 379: ! 380: /* a connection in TME_SCSI_SEQUENCE_WAIT_SELECT_HALF or ! 381: TME_SCSI_SEQUENCE_WAIT_SELECT_FULL is waiting to be selected: */ ! 382: else if (SEQUENCE_IS(sequence, ! 383: tme_scsi_sequence_wait_select_half) ! 384: || SEQUENCE_IS(sequence, ! 385: tme_scsi_sequence_wait_select_full)) { ! 386: ! 387: /* get the SCSI ID for the connection: */ ! 388: id = (SEQUENCE_IS(sequence, ! 389: tme_scsi_sequence_wait_select_half) ! 390: ? SEQUENCE_INDEX(sequence, ! 391: tme_scsi_sequence_wait_select_half) ! 392: : SEQUENCE_INDEX(sequence, ! 393: tme_scsi_sequence_wait_select_full)); ! 394: ! 395: /* dispatch on the sequence step: */ ! 396: switch (conn_int->tme_scsi_connection_int_sequence_step) { ! 397: ! 398: /* "In all systems, the target shall determine that it is ! 399: selected when SEL and its SCSI ID bit are true and BSY and ! 400: I/O are false for at least a bus settle delay." */ ! 401: case 0: ! 402: if (((control ! 403: & (TME_SCSI_SIGNAL_BSY ! 404: | TME_SCSI_SIGNAL_SEL ! 405: | TME_SCSI_SIGNAL_I_O)) ! 406: == TME_SCSI_SIGNAL_SEL) ! 407: && (data ! 408: & TME_BIT(id))) { ! 409: ! 410: /* this device is being selected: */ ! 411: ! 412: /* if this device is in ! 413: TME_SCSI_SEQUENCE_WAIT_SELECT_HALF, callout a cycle on ! 414: this device: */ ! 415: if (SEQUENCE_IS(sequence, ! 416: tme_scsi_sequence_wait_select_half)) { ! 417: conn_int->tme_scsi_connection_int_callout_flags ! 418: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 419: conn_int->tme_scsi_connection_int_sequence ! 420: = NULL; ! 421: new_callouts ! 422: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 423: } ! 424: ! 425: /* otherwise, this device is in ! 426: TME_SCSI_SEQUENCE_WAIT_SELECT_FULL. assert BSY on its ! 427: behalf and advance to the next state: */ ! 428: else { ! 429: conn_int->tme_scsi_connection_int_control ! 430: |= TME_SCSI_SIGNAL_BSY; ! 431: conn_int->tme_scsi_connection_int_sequence_step++; ! 432: again = TRUE; ! 433: bus_changed = TRUE; ! 434: } ! 435: } ! 436: break; ! 437: ! 438: /* "At least two deskew delays after the initiator detects ! 439: BSY is true, it shall release SEL and may change the DATA ! 440: BUS." ! 441: ! 442: as the target, we wait for SEL to be negated: */ ! 443: case 1: ! 444: if (!(control ! 445: & TME_SCSI_SIGNAL_SEL)) { ! 446: ! 447: /* callout a cycle on this device: */ ! 448: conn_int->tme_scsi_connection_int_callout_flags ! 449: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 450: conn_int->tme_scsi_connection_int_sequence ! 451: = NULL; ! 452: new_callouts ! 453: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 454: } ! 455: break; ! 456: } ! 457: } ! 458: ! 459: /* there can be at most one device in an initiator or target ! 460: information transfer phase DMA sequence: */ ! 461: else if (SEQUENCE_IS(sequence, tme_scsi_sequence_info_dma_initiator)) { ! 462: assert (dma_initiator == NULL); ! 463: dma_initiator = conn_int; ! 464: } ! 465: else if (SEQUENCE_IS(sequence, tme_scsi_sequence_info_dma_target)) { ! 466: assert (dma_target == NULL); ! 467: dma_target = conn_int; ! 468: } ! 469: } ! 470: ! 471: /* if we need to loop again, do so immediately: */ ! 472: if (again) { ! 473: continue; ! 474: } ! 475: ! 476: /* if a device is in the initiator information transfer phase DMA ! 477: sequence, but the information transfer phase has changed, ! 478: callout a cycle on this device: */ ! 479: if (dma_initiator != NULL ! 480: && (TME_SCSI_PHASE(control) ! 481: != TME_SCSI_PHASE(dma_initiator->tme_scsi_connection_int_last_control))) { ! 482: dma_initiator->tme_scsi_connection_int_callout_flags ! 483: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 484: dma_initiator->tme_scsi_connection_int_sequence ! 485: = NULL; ! 486: new_callouts ! 487: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 488: dma_initiator = NULL; ! 489: } ! 490: ! 491: /* if initiator and target are both in their respective DMA ! 492: sequences, we can do a bulk copy between them: */ ! 493: if (dma_initiator != NULL ! 494: && dma_target != NULL) { ! 495: ! 496: /* sort the devices' DMA structures into input and output: */ ! 497: if (control & TME_SCSI_SIGNAL_I_O) { ! 498: dma_in = dma_initiator->tme_scsi_connection_int_dma; ! 499: dma_out = dma_target->tme_scsi_connection_int_dma; ! 500: } ! 501: else { ! 502: dma_out = dma_initiator->tme_scsi_connection_int_dma; ! 503: dma_in = dma_target->tme_scsi_connection_int_dma; ! 504: } ! 505: assert (dma_out != NULL && dma_in != NULL); ! 506: ! 507: /* get the size of the bulk copy: */ ! 508: count = TME_MIN(dma_out->tme_scsi_dma_resid, ! 509: dma_in->tme_scsi_dma_resid); ! 510: assert (count > 0); ! 511: ! 512: /* do the bulk copy: */ ! 513: memcpy(dma_in->tme_scsi_dma_in, ! 514: dma_out->tme_scsi_dma_out, ! 515: count); ! 516: ! 517: /* advance the DMA pointers: */ ! 518: dma_in->tme_scsi_dma_in += count; ! 519: dma_out->tme_scsi_dma_out += count; ! 520: ! 521: /* if the target's DMA has been exhausted, be sure to negate ! 522: REQ, and callout a cycle on the device: */ ! 523: dma = dma_target->tme_scsi_connection_int_dma; ! 524: if ((dma->tme_scsi_dma_resid -= count) == 0) { ! 525: ! 526: /* negate REQ on the target's behalf: */ ! 527: dma_target->tme_scsi_connection_int_control ! 528: &= ~TME_SCSI_SIGNAL_REQ; ! 529: again = TRUE; ! 530: bus_changed = TRUE; ! 531: ! 532: /* request the callout: */ ! 533: dma_target->tme_scsi_connection_int_callout_flags ! 534: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 535: dma_target->tme_scsi_connection_int_sequence ! 536: = NULL; ! 537: new_callouts ! 538: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 539: ! 540: /* no device is currently in the target information phase ! 541: transfer DMA sequence: */ ! 542: dma_target = NULL; ! 543: } ! 544: ! 545: /* otherwise, the target's DMA has not been exhausted. be sure ! 546: that we return to state zero in the DMA target sequence: */ ! 547: else { ! 548: dma_target->tme_scsi_connection_int_sequence_step = 0; ! 549: } ! 550: ! 551: /* if the initiator's DMA has been exhausted, callout a cycle on ! 552: the device: */ ! 553: dma = dma_initiator->tme_scsi_connection_int_dma; ! 554: if ((dma->tme_scsi_dma_resid -= count) == 0) { ! 555: ! 556: /* request the callout: */ ! 557: dma_initiator->tme_scsi_connection_int_callout_flags ! 558: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 559: dma_initiator->tme_scsi_connection_int_sequence ! 560: = NULL; ! 561: new_callouts ! 562: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 563: ! 564: /* no device is currently in the initiator information phase ! 565: transfer DMA sequence: */ ! 566: dma_initiator = NULL; ! 567: } ! 568: ! 569: /* otherwise, the initiator's DMA has not been exhausted. be sure ! 570: that we return to state zero in the DMA initiator sequence: */ ! 571: else { ! 572: dma_initiator->tme_scsi_connection_int_sequence_step = 0; ! 573: } ! 574: } ! 575: ! 576: /* if we need to loop again, do so immediately: */ ! 577: if (again) { ! 578: continue; ! 579: } ! 580: ! 581: /* if a device is in the target information transfer phase DMA ! 582: sequence: */ ! 583: if (dma_target != NULL) { ! 584: ! 585: /* get this device's DMA structure: */ ! 586: dma = dma_target->tme_scsi_connection_int_dma; ! 587: assert (dma != NULL); ! 588: ! 589: /* dispatch on the sequence step: */ ! 590: switch (dma_target->tme_scsi_connection_int_sequence_step) { ! 591: ! 592: /* "If I/O is true (transfer to the initiator)... [after] ACK ! 593: is false the target may continue the transfer by driving ! 594: DB(7-0,P) and asserting REQ, as described above." ! 595: ! 596: "If I/O is false (transfer to the target)... [after ACK is ! 597: false the target] may continue the transfer by asserting ! 598: REQ, as described above." */ ! 599: case 2: ! 600: if (control & TME_SCSI_SIGNAL_ACK) { ! 601: break; ! 602: } ! 603: ! 604: /* if the DMA has been exhausted, callout a cycle on this ! 605: device: */ ! 606: if (control & TME_SCSI_SIGNAL_I_O) { ! 607: dma->tme_scsi_dma_out++; ! 608: } ! 609: else { ! 610: dma->tme_scsi_dma_in++; ! 611: } ! 612: if (--dma->tme_scsi_dma_resid == 0) { ! 613: dma_target->tme_scsi_connection_int_callout_flags ! 614: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 615: dma_target->tme_scsi_connection_int_sequence ! 616: = NULL; ! 617: new_callouts ! 618: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 619: break; ! 620: } ! 621: ! 622: /* FALLTHROUGH */ ! 623: ! 624: /* "If I/O is true (transfer to the initiator), the target shall ! 625: first drive DB(7-0,P) to their desired values, delay at least ! 626: one deskew delay plus a cable skew delay, then assert REQ." ! 627: ! 628: "If I/O is false (transfer to the target) the target shall request ! 629: information by asserting REQ. " */ ! 630: case 0: ! 631: ! 632: /* assert REQ on the target's behalf: */ ! 633: dma_target->tme_scsi_connection_int_control ! 634: |= TME_SCSI_SIGNAL_REQ; ! 635: again = TRUE; ! 636: bus_changed = TRUE; ! 637: ! 638: /* if I/O is asserted, assert the output data: */ ! 639: if (control & TME_SCSI_SIGNAL_I_O) { ! 640: dma_target->tme_scsi_connection_int_data ! 641: = *(dma->tme_scsi_dma_out); ! 642: } ! 643: ! 644: /* advance to step one: */ ! 645: dma_target->tme_scsi_connection_int_sequence_step = 1; ! 646: break; ! 647: ! 648: /* "If I/O is true (transfer to the initiator)... [when] ACK ! 649: becomes true at the target, the target may change or ! 650: release DB(7-0,P) and shall negate REQ." ! 651: ! 652: "If I/O is false (transfer to the target)... [when] ACK ! 653: becomes true at the target, the target shall read ! 654: DB(7-0,P), then negate REQ." */ ! 655: case 1: ! 656: if (control & TME_SCSI_SIGNAL_ACK) { ! 657: ! 658: /* if I/O is negated, read the input data: */ ! 659: if (!(control & TME_SCSI_SIGNAL_I_O)) { ! 660: *(dma->tme_scsi_dma_in) = data; ! 661: } ! 662: ! 663: /* negate REQ on the target's behalf: */ ! 664: dma_target->tme_scsi_connection_int_control ! 665: &= ~TME_SCSI_SIGNAL_REQ; ! 666: again = TRUE; ! 667: bus_changed = TRUE; ! 668: ! 669: /* advance to step two: */ ! 670: dma_target->tme_scsi_connection_int_sequence_step = 2; ! 671: } ! 672: break; ! 673: ! 674: default: assert (FALSE); ! 675: } ! 676: ! 677: /* if the bus is being reset: */ ! 678: if (control & TME_SCSI_SIGNAL_RST) { ! 679: ! 680: /* negate all signals on the target's behalf: */ ! 681: dma_target->tme_scsi_connection_int_control = 0; ! 682: dma_target->tme_scsi_connection_int_data = 0; ! 683: again = TRUE; ! 684: bus_changed = TRUE; ! 685: ! 686: /* callout a cycle on this device: */ ! 687: dma_target->tme_scsi_connection_int_callout_flags ! 688: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 689: dma_target->tme_scsi_connection_int_sequence ! 690: = NULL; ! 691: new_callouts ! 692: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 693: } ! 694: } ! 695: ! 696: /* if we need to loop again, do so immediately: */ ! 697: if (again) { ! 698: continue; ! 699: } ! 700: ! 701: /* if a device is in the initiator information transfer phase DMA ! 702: sequence: */ ! 703: if (dma_initiator != NULL) { ! 704: ! 705: /* get this device's DMA structure: */ ! 706: dma = dma_initiator->tme_scsi_connection_int_dma; ! 707: assert (dma != NULL); ! 708: ! 709: /* dispatch on the sequence step: */ ! 710: switch (dma_initiator->tme_scsi_connection_int_sequence_step) { ! 711: ! 712: /* "If I/O is true (transfer to the initiator)... [the] ! 713: initiator shall read DB(7-0,P) after REQ is true, then ! 714: signal its acceptance of the data by asserting ACK." ! 715: ! 716: "If I/O is false (transfer to the target)... [the] ! 717: initiator shall drive DB(7-0,P) to their desired values ! 718: [after REQ is true], delay at least one deskew delay plus a ! 719: cable skew delay and assert ACK." */ ! 720: case 0: ! 721: if (!(control & TME_SCSI_SIGNAL_REQ)) { ! 722: break; ! 723: } ! 724: ! 725: /* if I/O is true, read the data, else ! 726: write the data: */ ! 727: if (control & TME_SCSI_SIGNAL_I_O) { ! 728: *dma->tme_scsi_dma_in = data; ! 729: } ! 730: else { ! 731: dma_initiator->tme_scsi_connection_int_data ! 732: = *(dma->tme_scsi_dma_out); ! 733: } ! 734: ! 735: /* assert ACK on the initiator's behalf: */ ! 736: dma_initiator->tme_scsi_connection_int_control ! 737: |= TME_SCSI_SIGNAL_ACK; ! 738: again = TRUE; ! 739: bus_changed = TRUE; ! 740: ! 741: /* advance to step one: */ ! 742: dma_initiator->tme_scsi_connection_int_sequence_step = 1; ! 743: break; ! 744: ! 745: /* "If I/O is true (transfer to the initiator)... [after] ! 746: REQ is false the initiator shall then negate ACK." ! 747: ! 748: "If I/O is false (transfer to the target)... [when] ! 749: REQ becomes false at the initiator, the initiator may ! 750: change or release DB(7-0,P) and shall negate ACK." */ ! 751: case 1: ! 752: if (control & TME_SCSI_SIGNAL_REQ) { ! 753: break; ! 754: } ! 755: ! 756: /* negate ACK on the initiator's behalf: */ ! 757: dma_initiator->tme_scsi_connection_int_control ! 758: &= ~TME_SCSI_SIGNAL_ACK; ! 759: again = TRUE; ! 760: bus_changed = TRUE; ! 761: ! 762: /* if the DMA has been exhausted, callout a cycle on this ! 763: device: */ ! 764: if (control & TME_SCSI_SIGNAL_I_O) { ! 765: dma->tme_scsi_dma_in++; ! 766: } ! 767: else { ! 768: dma->tme_scsi_dma_out++; ! 769: } ! 770: if (--dma->tme_scsi_dma_resid == 0) { ! 771: dma_initiator->tme_scsi_connection_int_callout_flags ! 772: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 773: dma_initiator->tme_scsi_connection_int_sequence ! 774: = NULL; ! 775: new_callouts |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 776: } ! 777: ! 778: /* otherwise, advance to step zero: */ ! 779: else { ! 780: dma_initiator->tme_scsi_connection_int_sequence_step = 0; ! 781: } ! 782: break; ! 783: ! 784: default: ! 785: assert (FALSE); ! 786: } ! 787: ! 788: /* if the bus is being reset: */ ! 789: if (control & TME_SCSI_SIGNAL_RST) { ! 790: ! 791: /* negate all signals on the initiator's behalf: */ ! 792: dma_target->tme_scsi_connection_int_control = 0; ! 793: dma_target->tme_scsi_connection_int_data = 0; ! 794: again = TRUE; ! 795: bus_changed = TRUE; ! 796: ! 797: /* callout a cycle on this device: */ ! 798: dma_target->tme_scsi_connection_int_callout_flags ! 799: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 800: dma_target->tme_scsi_connection_int_sequence ! 801: = NULL; ! 802: new_callouts ! 803: |= TME_SCSI_BUS_CALLOUT_CYCLE; ! 804: } ! 805: } ! 806: } ! 807: ! 808: /* make any needed callouts: */ ! 809: _tme_scsi_bus_callout(scsi_bus, new_callouts); ! 810: ! 811: /* unlock the mutex: */ ! 812: tme_mutex_unlock(&scsi_bus->tme_scsi_bus_mutex); ! 813: ! 814: return (TME_OK); ! 815: } ! 816: ! 817: /* this returns a predefined SCSI sequence: */ ! 818: #ifdef HAVE_STDARG_H ! 819: static const struct tme_scsi_sequence * ! 820: _tme_scsi_bus_sequence_get(struct tme_scsi_connection *conn_scsi, ! 821: unsigned int sequence_type, ! 822: ...) ! 823: #else /* HAVE_STDARG_H */ ! 824: static const struct tme_scsi_sequence *_tme_scsi_bus_sequence_get(conn_scsi, sequence_type, va_alist) ! 825: struct tme_scsi_connection *conn_scsi; ! 826: unsigned int sequence_type; ! 827: va_dcl ! 828: #endif /* HAVE_STDARG_H */ ! 829: { ! 830: va_list sequence_args; ! 831: const struct tme_scsi_sequence *sequence; ! 832: tme_scsi_data_t id0; ! 833: ! 834: /* start the variable arguments: */ ! 835: #ifdef HAVE_STDARG_H ! 836: va_start(sequence_args, sequence_type); ! 837: #else /* HAVE_STDARG_H */ ! 838: va_start(sequence_args); ! 839: #endif /* HAVE_STDARG_H */ ! 840: ! 841: /* dispatch on the sequence type: */ ! 842: #define SEQUENCE(f) ((const struct tme_scsi_sequence *) &_tme_scsi_bus_sequences.f) ! 843: switch (sequence_type) { ! 844: case TME_SCSI_SEQUENCE_INFO_DMA_INITIATOR: ! 845: sequence = SEQUENCE(tme_scsi_sequence_info_dma_initiator); ! 846: break; ! 847: case TME_SCSI_SEQUENCE_INFO_DMA_TARGET: ! 848: sequence = SEQUENCE(tme_scsi_sequence_info_dma_target); ! 849: break; ! 850: case TME_SCSI_SEQUENCE_WAIT_SELECT_HALF: ! 851: id0 = va_arg(sequence_args, tme_scsi_data_t); ! 852: sequence = SEQUENCE(tme_scsi_sequence_wait_select_half[id0]); ! 853: break; ! 854: case TME_SCSI_SEQUENCE_WAIT_SELECT_FULL: ! 855: id0 = va_arg(sequence_args, tme_scsi_data_t); ! 856: sequence = SEQUENCE(tme_scsi_sequence_wait_select_full[id0]); ! 857: break; ! 858: case TME_SCSI_SEQUENCE_WAIT_CHANGE: ! 859: sequence = SEQUENCE(tme_scsi_sequence_wait_change); ! 860: break; ! 861: default: ! 862: abort(); ! 863: } ! 864: #undef SEQUENCE ! 865: ! 866: /* end the variable arguments: */ ! 867: va_end(sequence_args); ! 868: ! 869: return (sequence); ! 870: } ! 871: ! 872: /* this scores a new connection: */ ! 873: static int ! 874: _tme_scsi_bus_connection_score(struct tme_connection *conn, ! 875: unsigned int *_score) ! 876: { ! 877: struct tme_scsi_bus *scsi_bus; ! 878: struct tme_scsi_connection_int *conn_int_other; ! 879: ! 880: /* both sides must be SCSI connections: */ ! 881: assert (conn->tme_connection_type == TME_CONNECTION_SCSI); ! 882: assert (conn->tme_connection_other->tme_connection_type == TME_CONNECTION_SCSI); ! 883: ! 884: /* recover our bus and the other internal connection side: */ ! 885: scsi_bus = conn->tme_connection_element->tme_element_private; ! 886: conn_int_other = (struct tme_scsi_connection_int *) conn->tme_connection_other; ! 887: ! 888: /* you cannot connect a bus to a bus: */ ! 889: *_score ! 890: = (conn_int_other->tme_scsi_connection_int.tme_scsi_connection_sequence_get ! 891: == NULL); ! 892: return (TME_OK); ! 893: } ! 894: ! 895: /* this makes a new connection: */ ! 896: static int ! 897: _tme_scsi_bus_connection_make(struct tme_connection *conn, ! 898: unsigned int state) ! 899: { ! 900: struct tme_scsi_bus *scsi_bus; ! 901: struct tme_scsi_connection_int *conn_int; ! 902: ! 903: /* both sides must be SCSI connections: */ ! 904: assert (conn->tme_connection_type == TME_CONNECTION_SCSI); ! 905: assert (conn->tme_connection_other->tme_connection_type == TME_CONNECTION_SCSI); ! 906: ! 907: /* recover our bus and our internal connection side: */ ! 908: scsi_bus = conn->tme_connection_element->tme_element_private; ! 909: conn_int = (struct tme_scsi_connection_int *) conn; ! 910: ! 911: /* we're always set up to answer calls across the connection, ! 912: so we only have to do work when the connection has gone full, ! 913: namely taking the other side of the connection: */ ! 914: if (state == TME_CONNECTION_FULL) { ! 915: ! 916: /* lock the mutex: */ ! 917: tme_mutex_lock(&scsi_bus->tme_scsi_bus_mutex); ! 918: ! 919: /* add this connection to our list of connections: */ ! 920: conn->tme_connection_next = scsi_bus->tme_scsi_bus_connections; ! 921: scsi_bus->tme_scsi_bus_connections = conn; ! 922: ! 923: /* unlock the mutex: */ ! 924: tme_mutex_unlock(&scsi_bus->tme_scsi_bus_mutex); ! 925: } ! 926: ! 927: return (TME_OK); ! 928: } ! 929: ! 930: /* this breaks a connection: */ ! 931: static int ! 932: _tme_scsi_bus_connection_break(struct tme_connection *conn, ! 933: unsigned int state) ! 934: { ! 935: abort(); ! 936: } ! 937: ! 938: /* this returns the new connections possible: */ ! 939: static int ! 940: _tme_scsi_bus_connections_new(struct tme_element *element, ! 941: const char * const *args, ! 942: struct tme_connection **_conns, ! 943: char **_output) ! 944: { ! 945: struct tme_scsi_connection_int *conn_int; ! 946: struct tme_scsi_connection *conn_scsi; ! 947: struct tme_connection *conn; ! 948: ! 949: /* we never take any arguments: */ ! 950: if (args[1] != NULL) { ! 951: tme_output_append_error(_output, ! 952: "%s %s, ", ! 953: args[1], ! 954: _("unexpected")); ! 955: return (EINVAL); ! 956: } ! 957: ! 958: /* create our side of a SCSI connection: */ ! 959: conn_int = tme_new0(struct tme_scsi_connection_int, 1); ! 960: conn_scsi = &conn_int->tme_scsi_connection_int; ! 961: conn = &conn_scsi->tme_scsi_connection; ! 962: ! 963: /* fill in the generic connection: */ ! 964: conn->tme_connection_next = *_conns; ! 965: conn->tme_connection_type = TME_CONNECTION_SCSI; ! 966: conn->tme_connection_score = _tme_scsi_bus_connection_score; ! 967: conn->tme_connection_make = _tme_scsi_bus_connection_make; ! 968: conn->tme_connection_break = _tme_scsi_bus_connection_break; ! 969: ! 970: /* fill in the SCSI connection: */ ! 971: conn_scsi->tme_scsi_connection_cycle = _tme_scsi_bus_cycle; ! 972: conn_scsi->tme_scsi_connection_sequence_get = _tme_scsi_bus_sequence_get; ! 973: ! 974: /* return the connection side possibility: */ ! 975: *_conns = conn; ! 976: return (TME_OK); ! 977: } ! 978: ! 979: /* this creates a new SCSI bus element: */ ! 980: TME_ELEMENT_SUB_NEW_DECL(tme_scsi,bus) { ! 981: struct tme_scsi_bus *scsi_bus; ! 982: int usage; ! 983: int arg_i; ! 984: ! 985: /* check our arguments: */ ! 986: arg_i = 1; ! 987: usage = FALSE; ! 988: ! 989: /* loop reading our arguments: */ ! 990: for (;;) { ! 991: ! 992: if (0) { ! 993: } ! 994: ! 995: /* if we've run out of arguments: */ ! 996: else if (args[arg_i + 0] == NULL) { ! 997: ! 998: break; ! 999: } ! 1000: ! 1001: /* this is a bad argument: */ ! 1002: else { ! 1003: tme_output_append_error(_output, ! 1004: "%s %s", ! 1005: args[arg_i], ! 1006: _("unexpected")); ! 1007: usage = TRUE; ! 1008: break; ! 1009: } ! 1010: } ! 1011: ! 1012: if (usage) { ! 1013: tme_output_append_error(_output, ! 1014: "%s %s", ! 1015: _("usage:"), ! 1016: args[0]); ! 1017: return (EINVAL); ! 1018: } ! 1019: ! 1020: /* allocate and initialize the new SCSI bus: */ ! 1021: scsi_bus = tme_new0(struct tme_scsi_bus, 1); ! 1022: tme_mutex_init(&scsi_bus->tme_scsi_bus_mutex); ! 1023: ! 1024: /* fill the element: */ ! 1025: element->tme_element_private = scsi_bus; ! 1026: element->tme_element_connections_new = _tme_scsi_bus_connections_new; ! 1027: ! 1028: return (TME_OK); ! 1029: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.