![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 3c400.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / bus / multibus|
Return to 3c400.c CVS log | Up to [The Machine Emulator] / tme / bus / multibus |
1.1 ! root 1: /* $Id: 3c400.c,v 1.6 2003/05/18 00:05:12 fredette Exp $ */ ! 2: ! 3: /* bus/multibus/3c400.c - implementation of the Multibus 3c400 emulation: */ ! 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: 3c400.c,v 1.6 2003/05/18 00:05:12 fredette Exp $"); ! 38: ! 39: /* includes: */ ! 40: #include <tme/generic/bus-device.h> ! 41: #include <tme/generic/ethernet.h> ! 42: ! 43: /* macros: */ ! 44: ! 45: /* register offsets and sizes: */ ! 46: #define TME_3C400_REG_CSR (0) ! 47: #define TME_3C400_SIZ_CSR (sizeof(tme_uint16_t)) ! 48: #define TME_3C400_REG_BACKOFF (2) ! 49: #define TME_3C400_SIZ_BACKOFF (sizeof(tme_uint16_t)) ! 50: #define TME_3C400_REG_AROM (1024) ! 51: #define TME_3C400_SIZ_AROM (TME_ETHERNET_ADDR_SIZE) ! 52: #define TME_3C400_REG_ARAM (1536) ! 53: #define TME_3C400_SIZ_ARAM (TME_ETHERNET_ADDR_SIZE) ! 54: #define TME_3C400_REG_TBUF (2048) ! 55: #define TME_3C400_SIZ_BUF (2048) ! 56: #define TME_3C400_REG_ABUF (TME_3C400_REG_TBUF + TME_3C400_SIZ_BUF) ! 57: #define TME_3C400_REG_BBUF (TME_3C400_REG_ABUF + TME_3C400_SIZ_BUF) ! 58: #define TME_3C400_SIZ_CARD (TME_3C400_REG_BBUF + TME_3C400_SIZ_BUF) ! 59: ! 60: /* the bits in the Control/Status Register. software can set and ! 61: clear bits covered by TME_3C400_CSR_INTPA. software can set, but ! 62: not clear, bits not covered by TME_3C400_CSR_INTPA: */ ! 63: #define TME_3C400_CSR_BBSW (0x8000) /* B buffer empty (belongs to card) */ ! 64: #define TME_3C400_CSR_ABSW (0x4000) /* A buffer empty (belongs to card) */ ! 65: #define TME_3C400_CSR_TBSW (0x2000) /* T buffer full (belongs to card) */ ! 66: #define TME_3C400_CSR_JAM (0x1000) /* Ethernet jammed (collision) */ ! 67: #define TME_3C400_CSR_AMSW (0x0800) /* address RAM belongs to ether */ ! 68: #define TME_3C400_CSR_RBBA (0x0400) /* B buffer received before A */ ! 69: #define TME_3C400_CSR_RESET (0x0100) /* reset the card */ ! 70: #define TME_3C400_CSR_INTPA (0x00ff) /* mask for interrupt and PA fields */ ! 71: #define TME_3C400_CSR_BINT (0x0080) /* B buffer interrupt enable */ ! 72: #define TME_3C400_CSR_AINT (0x0040) /* A buffer interrupt enable */ ! 73: #define TME_3C400_CSR_TINT (0x0020) /* T buffer interrupt enable */ ! 74: #define TME_3C400_CSR_JINT (0x0010) /* jam interrupt enable */ ! 75: #define TME_3C400_CSR_PAMASK (0x000f) /* PA field */ ! 76: #define TME_3C400_CSR_PA (0x0007) /* receive mine+broadcast-errors */ ! 77: #define TME_3C400_CSR_PROMISC (0x0001) /* receive all-errors */ ! 78: ! 79: /* the first 16 bits of all buffers are a status word: */ ! 80: #define TME_3C400_SIZ_BUF_STATUS (sizeof(tme_uint16_t)) ! 81: ! 82: /* the bits of a receive buffer status word: */ ! 83: /* Frame Check Sequence (CRC) error */ ! 84: #define TME_3C400_RBUF_FCSERR (0x8000) ! 85: /* this packet was broadcast: */ ! 86: #define TME_3C400_RBUF_BROADCAST (0x4000) ! 87: /* this packet had a "range error": */ ! 88: #define TME_3C400_RBUF_RGERR (0x2000) ! 89: /* this packet matched our address: */ ! 90: #define TME_3C400_RBUF_ADDRMATCH (0x1000) ! 91: /* this packet had a framing error: */ ! 92: #define TME_3C400_RBUF_FRERR (0x0800) ! 93: /* the first byte after the frame in the buffer: */ ! 94: #define TME_3C400_RBUF_DOFF_MASK (0x07ff) ! 95: ! 96: /* these get and put the CSR: */ ! 97: #define TME_3C400_CSR_GET(_3c400) \ ! 98: tme_betoh_u16(*((tme_uint16_t *) &(_3c400)->tme_3c400_card[TME_3C400_REG_CSR])) ! 99: #define TME_3C400_CSR_PUT(_3c400, csr) \ ! 100: (*((tme_uint16_t *) &(_3c400)->tme_3c400_card[TME_3C400_REG_CSR]) = tme_betoh_u16(csr)) ! 101: ! 102: /* the callout flags: */ ! 103: #define TME_3C400_CALLOUT_CHECK (0) ! 104: #define TME_3C400_CALLOUT_RUNNING TME_BIT(0) ! 105: #define TME_3C400_CALLOUTS_MASK (-2) ! 106: #define TME_3C400_CALLOUT_CTRL TME_BIT(1) ! 107: #define TME_3C400_CALLOUT_CONFIG TME_BIT(2) ! 108: #define TME_3C400_CALLOUT_READ TME_BIT(3) ! 109: #define TME_3C400_CALLOUT_INT TME_BIT(4) ! 110: ! 111: /* structures: */ ! 112: ! 113: /* the card: */ ! 114: struct tme_3c400 { ! 115: ! 116: /* our simple bus device header: */ ! 117: struct tme_bus_device tme_3c400_device; ! 118: #define tme_3c400_element tme_3c400_device.tme_bus_device_element ! 119: ! 120: /* the mutex protecting the card: */ ! 121: tme_mutex_t tme_3c400_mutex; ! 122: ! 123: /* the rwlock protecting the card: */ ! 124: tme_rwlock_t tme_3c400_rwlock; ! 125: ! 126: /* the Ethernet connection: */ ! 127: struct tme_ethernet_connection *tme_3c400_eth_connection; ! 128: ! 129: /* the callout flags: */ ! 130: int tme_3c400_callout_flags; ! 131: ! 132: /* if our interrupt line is currently asserted: */ ! 133: int tme_3c400_int_asserted; ! 134: ! 135: /* it's easiest to just model the card as a chunk of memory: */ ! 136: tme_uint8_t tme_3c400_card[TME_3C400_SIZ_CARD]; ! 137: ! 138: #ifndef TME_NO_LOG ! 139: tme_uint16_t tme_3c400_last_log_csr; ! 140: #endif /* !TME_NO_LOG */ ! 141: }; ! 142: ! 143: /* this resets the card: */ ! 144: static void ! 145: _tme_3c400_reset(struct tme_3c400 *_3c400) ! 146: { ! 147: tme_uint16_t csr; ! 148: ! 149: /* the reset CSR value: */ ! 150: csr = 0; ! 151: ! 152: /* set the CSR: */ ! 153: TME_3C400_CSR_PUT(_3c400, csr); ! 154: ! 155: /* clear all pending callouts: */ ! 156: _3c400->tme_3c400_callout_flags &= TME_3C400_CALLOUTS_MASK; ! 157: ! 158: /* if the interrupt line is currently asserted, negate it: */ ! 159: if (_3c400->tme_3c400_int_asserted) { ! 160: _3c400->tme_3c400_callout_flags |= TME_3C400_CALLOUT_INT; ! 161: } ! 162: } ! 163: ! 164: /* the _3c400 callout function. it must be called with the mutex locked: */ ! 165: static void ! 166: _tme_3c400_callout(struct tme_3c400 *_3c400, int new_callouts) ! 167: { ! 168: struct tme_ethernet_connection *conn_eth; ! 169: struct tme_bus_connection *conn_bus; ! 170: tme_uint16_t csr, csr_rbba, recv_buffer; ! 171: int callouts, later_callouts; ! 172: unsigned int ctrl; ! 173: struct tme_ethernet_config config; ! 174: int rc; ! 175: const tme_uint8_t *addrs[2]; ! 176: tme_ethernet_fid_t frame_id; ! 177: tme_uint8_t *rbuf; ! 178: tme_uint16_t status; ! 179: struct tme_ethernet_frame_chunk *frame_chunk, frame_chunk_buffer; ! 180: int int_asserted; ! 181: ! 182: /* add in any new callouts: */ ! 183: _3c400->tme_3c400_callout_flags |= new_callouts; ! 184: ! 185: /* if this function is already running in another thread, simply ! 186: return now. the other thread will do our work: */ ! 187: if (_3c400->tme_3c400_callout_flags & TME_3C400_CALLOUT_RUNNING) { ! 188: return; ! 189: } ! 190: ! 191: /* callouts are now running: */ ! 192: _3c400->tme_3c400_callout_flags |= TME_3C400_CALLOUT_RUNNING; ! 193: ! 194: /* assume that we won't need any later callouts: */ ! 195: later_callouts = 0; ! 196: ! 197: /* loop while callouts are needed: */ ! 198: for (; (callouts = _3c400->tme_3c400_callout_flags) & TME_3C400_CALLOUTS_MASK; ) { ! 199: ! 200: /* clear the needed callouts: */ ! 201: _3c400->tme_3c400_callout_flags = callouts & ~TME_3C400_CALLOUTS_MASK; ! 202: callouts &= TME_3C400_CALLOUTS_MASK; ! 203: ! 204: /* get this card's connection: */ ! 205: conn_eth = _3c400->tme_3c400_eth_connection; ! 206: ! 207: /* if we need to call out new control information: */ ! 208: if (callouts & TME_3C400_CALLOUT_CTRL) { ! 209: ! 210: /* get the current CSR value: */ ! 211: csr = TME_3C400_CSR_GET(_3c400); ! 212: ! 213: /* form the new ctrl: */ ! 214: ctrl = 0; ! 215: if (csr & TME_3C400_CSR_TBSW) { ! 216: ctrl |= TME_ETHERNET_CTRL_OK_READ; ! 217: } ! 218: ! 219: /* unlock the mutex: */ ! 220: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 221: ! 222: /* do the callout: */ ! 223: rc = (conn_eth != NULL ! 224: ? ((*conn_eth->tme_ethernet_connection_ctrl) ! 225: (conn_eth, ! 226: ctrl)) ! 227: : TME_OK); ! 228: ! 229: /* lock the mutex: */ ! 230: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 231: ! 232: /* if the callout was unsuccessful, remember that at some later ! 233: time this callout should be attempted again: */ ! 234: if (rc != TME_OK) { ! 235: later_callouts |= TME_3C400_CALLOUT_CTRL; ! 236: } ! 237: } ! 238: ! 239: /* if we need to call out new config information: */ ! 240: if (callouts & TME_3C400_CALLOUT_CONFIG) { ! 241: ! 242: /* get the current CSR value: */ ! 243: csr = TME_3C400_CSR_GET(_3c400); ! 244: ! 245: /* form the new config: */ ! 246: memset(&config, 0, sizeof(config)); ! 247: ! 248: /* our Ethernet address: */ ! 249: config.tme_ethernet_config_addr_count = 0; ! 250: addrs[config.tme_ethernet_config_addr_count++] ! 251: = tme_ethernet_addr_broadcast; ! 252: if (csr & TME_3C400_CSR_AMSW) { ! 253: addrs[config.tme_ethernet_config_addr_count++] ! 254: = &_3c400->tme_3c400_card[TME_3C400_REG_ARAM]; ! 255: } ! 256: config.tme_ethernet_config_addrs = addrs; ! 257: ! 258: /* our config flags: */ ! 259: config.tme_ethernet_config_flags = TME_ETHERNET_CONFIG_NORMAL; ! 260: switch (csr & TME_3C400_CSR_PAMASK) { ! 261: case 0: ! 262: config.tme_ethernet_config_addr_count = 0; ! 263: break; ! 264: case TME_3C400_CSR_PA: ! 265: break; ! 266: case TME_3C400_CSR_PROMISC: ! 267: config.tme_ethernet_config_flags |= TME_ETHERNET_CONFIG_PROMISC; ! 268: break; ! 269: default: abort(); ! 270: } ! 271: ! 272: /* unlock the mutex: */ ! 273: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 274: ! 275: /* do the callout: */ ! 276: rc = (conn_eth == NULL ! 277: ? TME_OK ! 278: : ((*conn_eth->tme_ethernet_connection_config) ! 279: (conn_eth, ! 280: &config))); ! 281: ! 282: /* lock the mutex: */ ! 283: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 284: ! 285: /* if the callout was unsuccessful, remember that at some later ! 286: time this callout should be attempted again: */ ! 287: if (rc != TME_OK) { ! 288: later_callouts |= TME_3C400_CALLOUT_CONFIG; ! 289: } ! 290: } ! 291: ! 292: /* if the Ethernet is readable: */ ! 293: if (callouts & TME_3C400_CALLOUT_READ) { ! 294: ! 295: /* get the current CSR value: */ ! 296: csr = TME_3C400_CSR_GET(_3c400); ! 297: ! 298: /* try to find an empty buffer: */ ! 299: switch (csr & (TME_3C400_CSR_BBSW | TME_3C400_CSR_ABSW)) { ! 300: default: ! 301: /* both buffers are full: */ ! 302: recv_buffer = 0; ! 303: csr_rbba = (csr & TME_3C400_CSR_RBBA); ! 304: break; ! 305: case TME_3C400_CSR_BBSW: ! 306: /* the A buffer is full but the B buffer is empty: */ ! 307: recv_buffer = TME_3C400_CSR_BBSW; ! 308: csr_rbba = 0; ! 309: break; ! 310: case TME_3C400_CSR_ABSW: ! 311: /* the B buffer is full but the A buffer is empty: */ ! 312: recv_buffer = TME_3C400_CSR_ABSW; ! 313: csr_rbba = TME_3C400_CSR_RBBA; ! 314: break; ! 315: case TME_3C400_CSR_ABSW | TME_3C400_CSR_BBSW: ! 316: /* both buffers are empty: */ ! 317: recv_buffer = TME_3C400_CSR_ABSW; ! 318: csr_rbba = 0; ! 319: break; ! 320: } ! 321: ! 322: /* unlock the mutex: */ ! 323: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 324: ! 325: /* make a frame chunk to receive this frame. remember that the ! 326: first two bytes of our card's buffers are a status word: */ ! 327: if (recv_buffer == 0) { ! 328: rbuf = NULL; ! 329: frame_chunk = NULL; ! 330: } ! 331: else { ! 332: rbuf = ! 333: &_3c400->tme_3c400_card[(recv_buffer == TME_3C400_CSR_ABSW ! 334: ? TME_3C400_REG_ABUF ! 335: : TME_3C400_REG_BBUF)]; ! 336: frame_chunk_buffer.tme_ethernet_frame_chunk_next = NULL; ! 337: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes ! 338: = rbuf + TME_3C400_SIZ_BUF_STATUS; ! 339: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes_count ! 340: = TME_3C400_SIZ_BUF; ! 341: frame_chunk = &frame_chunk_buffer; ! 342: } ! 343: ! 344: /* do the callout: */ ! 345: rc = (conn_eth == NULL ! 346: ? TME_OK ! 347: : ((*conn_eth->tme_ethernet_connection_read) ! 348: (conn_eth, ! 349: &frame_id, ! 350: frame_chunk, ! 351: TME_ETHERNET_READ_NEXT))); ! 352: ! 353: /* lock the mutex: */ ! 354: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 355: ! 356: /* get the current CSR value: */ ! 357: csr = TME_3C400_CSR_GET(_3c400); ! 358: ! 359: /* if the read was successful: */ ! 360: if (rc > 0) { ! 361: ! 362: /* if this frame was received into a buffer: */ ! 363: if (recv_buffer != 0) { ! 364: ! 365: /* form the status word for this buffer: */ ! 366: status = 0; ! 367: ! 368: /* the first thing in the frame is the destination address, ! 369: which we check against our address and the broadcast ! 370: address: */ ! 371: if (memcmp(rbuf + TME_3C400_SIZ_BUF_STATUS, ! 372: &_3c400->tme_3c400_card[TME_3C400_REG_ARAM], ! 373: TME_ETHERNET_ADDR_SIZE) == 0) { ! 374: status |= TME_3C400_RBUF_ADDRMATCH; ! 375: } ! 376: else if (memcmp(rbuf + TME_3C400_SIZ_BUF_STATUS, ! 377: tme_ethernet_addr_broadcast, ! 378: TME_ETHERNET_ADDR_SIZE) == 0) { ! 379: status |= TME_3C400_RBUF_BROADCAST; ! 380: } ! 381: ! 382: /* put in the offset of the first free byte in the status. ! 383: make sure we present a packet that is at least as big ! 384: as the smallest Ethernet frame: */ ! 385: rc = TME_MAX(rc, TME_ETHERNET_FRAME_MIN - TME_ETHERNET_CRC_SIZE); ! 386: status |= TME_3C400_SIZ_BUF_STATUS + rc; ! 387: ! 388: /* put in the status: */ ! 389: *((tme_uint16_t *) rbuf) = tme_htobe_u16(status); ! 390: ! 391: /* update the CSR to reflect the new packet: */ ! 392: csr = (csr & ~(recv_buffer | TME_3C400_CSR_RBBA)) | csr_rbba; ! 393: TME_3C400_CSR_PUT(_3c400, csr); ! 394: ! 395: /* if interrupts are enabled on this buffer, mark that we need ! 396: to callout an interrupt: */ ! 397: if (csr & (recv_buffer >> 8)) { ! 398: _3c400->tme_3c400_callout_flags |= TME_3C400_CALLOUT_INT; ! 399: } ! 400: } ! 401: ! 402: /* mark that we need to loop to callout to read more frames: */ ! 403: _3c400->tme_3c400_callout_flags |= TME_3C400_CALLOUT_READ; ! 404: } ! 405: ! 406: /* otherwise, the read failed. convention dictates that we ! 407: forget that the connection was readable, which we already ! 408: have done by clearing the CALLOUT_READ flag: */ ! 409: } ! 410: ! 411: /* if we need to call out a possible change to our interrupt ! 412: signal: */ ! 413: if (callouts & TME_3C400_CALLOUT_INT) { ! 414: ! 415: /* get the current CSR value: */ ! 416: csr = TME_3C400_CSR_GET(_3c400); ! 417: ! 418: /* see if the interrupt signal should be asserted or negated: */ ! 419: int_asserted = ((~(csr & (TME_3C400_CSR_BBSW ! 420: | TME_3C400_CSR_ABSW ! 421: | TME_3C400_CSR_TBSW))) ! 422: & ((csr & (TME_3C400_CSR_BINT ! 423: | TME_3C400_CSR_AINT ! 424: | TME_3C400_CSR_TINT)) << 8)); ! 425: ! 426: /* if the interrupt signal doesn't already have the right state: */ ! 427: if (!int_asserted != !_3c400->tme_3c400_int_asserted) { ! 428: ! 429: /* unlock our mutex: */ ! 430: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 431: ! 432: /* get our bus connection: */ ! 433: conn_bus = TME_ATOMIC_READ(struct tme_bus_connection *, ! 434: _3c400->tme_3c400_device.tme_bus_device_connection); ! 435: ! 436: /* call out the bus interrupt signal edge: */ ! 437: rc = (*conn_bus->tme_bus_signal) ! 438: (conn_bus, ! 439: TME_BUS_SIGNAL_INT_UNSPEC ! 440: | (int_asserted ! 441: ? TME_BUS_SIGNAL_LEVEL_ASSERTED ! 442: : TME_BUS_SIGNAL_LEVEL_NEGATED) ! 443: | TME_BUS_SIGNAL_EDGE); ! 444: ! 445: /* lock our mutex: */ ! 446: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 447: ! 448: /* if this callout was successful, note the new state of the ! 449: interrupt signal: */ ! 450: if (rc == TME_OK) { ! 451: _3c400->tme_3c400_int_asserted = int_asserted; ! 452: } ! 453: ! 454: /* otherwise, remember that at some later time this callout ! 455: should be attempted again: */ ! 456: else { ! 457: later_callouts |= TME_3C400_CALLOUT_INT; ! 458: } ! 459: } ! 460: } ! 461: } ! 462: ! 463: /* put in any later callouts, and clear that callouts are running: */ ! 464: _3c400->tme_3c400_callout_flags = later_callouts; ! 465: } ! 466: ! 467: /* the _3c400 bus cycle handler: */ ! 468: static int ! 469: _tme_3c400_bus_cycle(void *__3c400, struct tme_bus_cycle *cycle_init) ! 470: { ! 471: struct tme_3c400 *_3c400; ! 472: tme_uint16_t csr_old, csr_new, csr_diff; ! 473: int new_callouts; ! 474: ! 475: /* recover our data structure: */ ! 476: _3c400 = (struct tme_3c400 *) __3c400; ! 477: ! 478: /* assume we won't need any new callouts: */ ! 479: new_callouts = 0; ! 480: ! 481: /* lock the mutex: */ ! 482: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 483: ! 484: /* get the changed CSR value - there are bits that software can only ! 485: set, and not clear: */ ! 486: csr_old = TME_3C400_CSR_GET(_3c400); ! 487: ! 488: /* unless this address falls within the address ROM, run the cycle: */ ! 489: if ((cycle_init->tme_bus_cycle_address ! 490: < TME_3C400_REG_AROM) ! 491: || (cycle_init->tme_bus_cycle_address ! 492: >= TME_3C400_REG_ARAM)) { ! 493: tme_bus_cycle_xfer_memory(cycle_init, ! 494: _3c400->tme_3c400_card, ! 495: _3c400->tme_3c400_device.tme_bus_device_address_last); ! 496: } ! 497: ! 498: /* get the new CSR value, and put back any bits that software ! 499: cannot clear: */ ! 500: csr_new = TME_3C400_CSR_GET(_3c400); ! 501: csr_new |= (csr_old & ~TME_3C400_CSR_INTPA); ! 502: ! 503: /* get the set of bits that has changed: */ ! 504: csr_diff = (csr_old ^ csr_new); ! 505: ! 506: /* if this is a reset: */ ! 507: if (csr_diff & TME_3C400_CSR_RESET) { ! 508: _tme_3c400_reset(_3c400); ! 509: } ! 510: ! 511: /* otherwise: */ ! 512: else { ! 513: ! 514: /* if the transmit buffer now belongs to the card, call out ! 515: that we are now readable: */ ! 516: if (csr_diff & TME_3C400_CSR_TBSW) { ! 517: new_callouts |= TME_3C400_CALLOUT_CTRL; ! 518: } ! 519: ! 520: /* if the address RAM now belongs to the card, or if the address ! 521: filter configuration has changed, call out the config change: */ ! 522: if ((csr_diff & TME_3C400_CSR_AMSW) ! 523: || (csr_diff & TME_3C400_CSR_PAMASK) != 0) { ! 524: new_callouts |= TME_3C400_CALLOUT_CONFIG; ! 525: } ! 526: ! 527: /* if any interrupt enable status bits have changed, ! 528: call out the interrupt signal change: */ ! 529: if (csr_diff & (TME_3C400_CSR_BINT ! 530: | TME_3C400_CSR_AINT ! 531: | TME_3C400_CSR_TINT)) { ! 532: new_callouts |= TME_3C400_CALLOUT_INT; ! 533: } ! 534: ! 535: /* set the current CSR value: */ ! 536: TME_3C400_CSR_PUT(_3c400, csr_new); ! 537: ! 538: #ifndef TME_NO_LOG ! 539: if (csr_new != _3c400->tme_3c400_last_log_csr) { ! 540: _3c400->tme_3c400_last_log_csr = csr_new; ! 541: tme_log(&_3c400->tme_3c400_element->tme_element_log_handle, ! 542: 1000, TME_OK, ! 543: (&_3c400->tme_3c400_element->tme_element_log_handle, ! 544: "csr now 0x%04x", ! 545: csr_new)); ! 546: } ! 547: #endif /* !TME_NO_LOG */ ! 548: } ! 549: ! 550: /* make any new callouts: */ ! 551: _tme_3c400_callout(_3c400, new_callouts); ! 552: ! 553: /* unlock the mutex: */ ! 554: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 555: ! 556: /* no faults: */ ! 557: return (TME_OK); ! 558: } ! 559: ! 560: /* this is called when a device changes its configuration: */ ! 561: static int ! 562: _tme_3c400_config(struct tme_ethernet_connection *conn_eth, ! 563: struct tme_ethernet_config *config) ! 564: { ! 565: /* we don't care when other devices on the Ethernet ! 566: reconfigure themselves: */ ! 567: return (TME_OK); ! 568: } ! 569: ! 570: /* this is called when control lines change: */ ! 571: static int ! 572: _tme_3c400_ctrl(struct tme_ethernet_connection *conn_eth, ! 573: unsigned int ctrl) ! 574: { ! 575: struct tme_3c400 *_3c400; ! 576: int new_callouts; ! 577: ! 578: /* recover our data structures: */ ! 579: _3c400 = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private; ! 580: ! 581: /* assume that we won't need any new callouts: */ ! 582: new_callouts = 0; ! 583: ! 584: /* lock the mutex: */ ! 585: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 586: ! 587: /* if this connection is readable, call out a read: */ ! 588: if (ctrl & TME_ETHERNET_CTRL_OK_READ) { ! 589: new_callouts |= TME_3C400_CALLOUT_READ; ! 590: } ! 591: ! 592: /* make any new callouts: */ ! 593: _tme_3c400_callout(_3c400, new_callouts); ! 594: ! 595: /* unlock the mutex: */ ! 596: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 597: ! 598: return (TME_OK); ! 599: } ! 600: ! 601: /* this is called to read frames (from the 3c400 perspective, to transmit them): */ ! 602: static int ! 603: _tme_3c400_read(struct tme_ethernet_connection *conn_eth, ! 604: tme_ethernet_fid_t *_frame_id, ! 605: struct tme_ethernet_frame_chunk *frame_chunks, ! 606: unsigned int flags) ! 607: { ! 608: struct tme_3c400 *_3c400; ! 609: struct tme_ethernet_frame_chunk frame_chunk_buffer; ! 610: tme_uint16_t csr, count; ! 611: int new_callouts; ! 612: int rc; ! 613: ! 614: /* recover our data structures: */ ! 615: _3c400 = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private; ! 616: ! 617: /* assume that we won't need any new callouts: */ ! 618: new_callouts = 0; ! 619: ! 620: /* lock our mutex: */ ! 621: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 622: ! 623: /* get the current CSR value: */ ! 624: csr = TME_3C400_CSR_GET(_3c400); ! 625: ! 626: /* if the transmit buffer is full: */ ! 627: if (csr & TME_3C400_CSR_TBSW) { ! 628: ! 629: /* get the count of bytes in the frame: */ ! 630: count = (TME_3C400_SIZ_BUF ! 631: - (tme_betoh_u16(*((tme_uint16_t *) ! 632: &_3c400->tme_3c400_card[TME_3C400_REG_TBUF])) ! 633: & TME_3C400_RBUF_DOFF_MASK)); ! 634: ! 635: /* form the single frame chunk: */ ! 636: frame_chunk_buffer.tme_ethernet_frame_chunk_next = NULL; ! 637: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes ! 638: = (&_3c400->tme_3c400_card[TME_3C400_REG_TBUF] ! 639: + TME_3C400_SIZ_BUF ! 640: - count); ! 641: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes_count ! 642: = count; ! 643: ! 644: /* copy out the frame: */ ! 645: count = tme_ethernet_chunks_copy(frame_chunks, &frame_chunk_buffer); ! 646: ! 647: /* if this isn't a peek: */ ! 648: if (!(flags & TME_ETHERNET_READ_PEEK)) { ! 649: ! 650: /* mark the transmit buffer as empty: */ ! 651: csr &= ~TME_3C400_CSR_TBSW; ! 652: TME_3C400_CSR_PUT(_3c400, csr); ! 653: ! 654: /* if transmit buffer interrupts are enabled, call out ! 655: an interrupt: */ ! 656: if (csr & TME_3C400_CSR_TINT) { ! 657: new_callouts |= TME_3C400_CALLOUT_INT; ! 658: } ! 659: } ! 660: ! 661: /* success: */ ! 662: rc = count; ! 663: } ! 664: ! 665: /* if the transmit buffer is empty, return an error: */ ! 666: else { ! 667: rc = -ENOENT; ! 668: } ! 669: ! 670: /* make any new callouts: */ ! 671: _tme_3c400_callout(_3c400, new_callouts); ! 672: ! 673: /* unlock our mutex: */ ! 674: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 675: ! 676: /* done: */ ! 677: return (rc); ! 678: } ! 679: ! 680: /* the _3c400 TLB filler: */ ! 681: static int ! 682: _tme_3c400_tlb_fill(void *__3c400, struct tme_bus_tlb *tlb, ! 683: tme_bus_addr_t address, unsigned int cycles) ! 684: { ! 685: struct tme_3c400 *_3c400; ! 686: ! 687: /* recover our data structure: */ ! 688: _3c400 = (struct tme_3c400 *) __3c400; ! 689: ! 690: /* the address must be within range: */ ! 691: assert(address < TME_3C400_SIZ_CARD); ! 692: ! 693: /* initialize the TLB entry: */ ! 694: tme_bus_tlb_initialize(tlb); ! 695: ! 696: /* if the address falls from the CSR to the address ROM: */ ! 697: if (TME_3C400_REG_CSR <= address ! 698: && address < TME_3C400_REG_AROM) { ! 699: ! 700: /* this TLB entry covers this range: */ ! 701: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first, TME_3C400_REG_CSR); ! 702: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last, TME_3C400_REG_AROM - 1); ! 703: } ! 704: ! 705: /* if this address falls from the address ROM to the address RAM: */ ! 706: else if (TME_3C400_REG_AROM <= address ! 707: && address < TME_3C400_REG_ARAM) { ! 708: ! 709: /* this TLB entry covers this range: */ ! 710: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first, TME_3C400_REG_AROM); ! 711: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last, TME_3C400_REG_ARAM - 1); ! 712: } ! 713: ! 714: /* anything else covers the remainder of the device: */ ! 715: else { ! 716: ! 717: /* this TLB entry can cover from the address RAM to the end of the card: */ ! 718: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_first, TME_3C400_REG_ARAM); ! 719: TME_ATOMIC_WRITE(tme_bus_addr_t, tlb->tme_bus_tlb_addr_last, TME_3C400_SIZ_CARD - 1); ! 720: ! 721: /* this TLB entry allows fast writing: */ ! 722: tlb->tme_bus_tlb_emulator_off_write = &_3c400->tme_3c400_card[0]; ! 723: } ! 724: ! 725: /* all address ranges allow fast reading: */ ! 726: tlb->tme_bus_tlb_emulator_off_read = &_3c400->tme_3c400_card[0]; ! 727: tlb->tme_bus_tlb_rwlock = &_3c400->tme_3c400_rwlock; ! 728: ! 729: /* allow reading and writing: */ ! 730: tlb->tme_bus_tlb_cycles_ok = TME_BUS_CYCLE_READ | TME_BUS_CYCLE_WRITE; ! 731: ! 732: /* our bus cycle handler: */ ! 733: tlb->tme_bus_tlb_cycle_private = _3c400; ! 734: tlb->tme_bus_tlb_cycle = _tme_3c400_bus_cycle; ! 735: ! 736: return (TME_OK); ! 737: } ! 738: ! 739: /* this makes a new Ethernet connection: */ ! 740: static int ! 741: _tme_3c400_connection_make(struct tme_connection *conn, unsigned int state) ! 742: { ! 743: struct tme_3c400 *_3c400; ! 744: struct tme_ethernet_connection *conn_eth; ! 745: struct tme_ethernet_connection *conn_eth_other; ! 746: ! 747: /* recover our data structures: */ ! 748: _3c400 = conn->tme_connection_element->tme_element_private; ! 749: conn_eth = (struct tme_ethernet_connection *) conn; ! 750: conn_eth_other = (struct tme_ethernet_connection *) conn->tme_connection_other; ! 751: ! 752: /* both sides must be Ethernet connections: */ ! 753: assert(conn->tme_connection_type == TME_CONNECTION_ETHERNET); ! 754: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_ETHERNET); ! 755: ! 756: /* we're always set up to answer calls across the connection, so we ! 757: only have to do work when the connection has gone full, namely ! 758: taking the other side of the connection: */ ! 759: if (state == TME_CONNECTION_FULL) { ! 760: ! 761: /* lock our mutex: */ ! 762: tme_mutex_lock(&_3c400->tme_3c400_mutex); ! 763: ! 764: /* save our connection: */ ! 765: _3c400->tme_3c400_eth_connection = conn_eth_other; ! 766: ! 767: /* unlock our mutex: */ ! 768: tme_mutex_unlock(&_3c400->tme_3c400_mutex); ! 769: } ! 770: ! 771: return (TME_OK); ! 772: } ! 773: ! 774: /* this breaks a connection: */ ! 775: static int ! 776: _tme_3c400_connection_break(struct tme_connection *conn, unsigned int state) ! 777: { ! 778: abort(); ! 779: } ! 780: ! 781: /* this makes a new connection side for a 3c400: */ ! 782: static int ! 783: _tme_3c400_connections_new(struct tme_element *element, ! 784: const char * const *args, ! 785: struct tme_connection **_conns, ! 786: char **_output) ! 787: { ! 788: struct tme_3c400 *_3c400; ! 789: struct tme_ethernet_connection *conn_eth; ! 790: struct tme_connection *conn; ! 791: int rc; ! 792: ! 793: /* recover our data structure: */ ! 794: _3c400 = (struct tme_3c400 *) element->tme_element_private; ! 795: ! 796: /* make the generic bus device connection side: */ ! 797: rc = tme_bus_device_connections_new(element, args, _conns, _output); ! 798: if (rc != TME_OK) { ! 799: return (rc); ! 800: } ! 801: ! 802: /* if we don't have an Ethernet connection, make one: */ ! 803: if (_3c400->tme_3c400_eth_connection == NULL) { ! 804: ! 805: /* allocate the new Ethernet connection: */ ! 806: conn_eth = tme_new0(struct tme_ethernet_connection, 1); ! 807: conn = &conn_eth->tme_ethernet_connection; ! 808: ! 809: /* fill in the generic connection: */ ! 810: conn->tme_connection_next = *_conns; ! 811: conn->tme_connection_type = TME_CONNECTION_ETHERNET; ! 812: conn->tme_connection_score = tme_ethernet_connection_score; ! 813: conn->tme_connection_make = _tme_3c400_connection_make; ! 814: conn->tme_connection_break = _tme_3c400_connection_break; ! 815: ! 816: /* fill in the Ethernet connection: */ ! 817: conn_eth->tme_ethernet_connection_config = _tme_3c400_config; ! 818: conn_eth->tme_ethernet_connection_ctrl = _tme_3c400_ctrl; ! 819: conn_eth->tme_ethernet_connection_read = _tme_3c400_read; ! 820: ! 821: /* return the connection side possibility: */ ! 822: *_conns = conn; ! 823: } ! 824: ! 825: /* done: */ ! 826: return (TME_OK); ! 827: } ! 828: ! 829: /* the new _3c400 function: */ ! 830: TME_ELEMENT_SUB_NEW_DECL(tme_bus_multibus,3c400) { ! 831: struct tme_3c400 *_3c400; ! 832: tme_uint8_t arom[TME_ETHERNET_ADDR_SIZE]; ! 833: int arom_ok; ! 834: int arg_i; ! 835: int usage; ! 836: ! 837: /* check our arguments: */ ! 838: usage = 0; ! 839: arom_ok = FALSE; ! 840: arg_i = 1; ! 841: for (;;) { ! 842: ! 843: /* our Ethernet address ROM: */ ! 844: if (TME_ARG_IS(args[arg_i], "ether") ! 845: && tme_ethernet_addr_parse(args[arg_i + 1], arom) == TME_OK) { ! 846: arom_ok = TRUE; ! 847: arg_i += 2; ! 848: } ! 849: ! 850: /* if we ran out of arguments: */ ! 851: else if (args[arg_i] == NULL) { ! 852: ! 853: /* we must have been given our Ethernet address ROM: */ ! 854: if (!arom_ok) { ! 855: usage = TRUE; ! 856: } ! 857: break; ! 858: } ! 859: ! 860: /* otherwise this is a bad argument: */ ! 861: else { ! 862: tme_output_append_error(_output, ! 863: "%s %s, ", ! 864: args[arg_i], ! 865: _("unexpected")); ! 866: usage = TRUE; ! 867: break; ! 868: } ! 869: } ! 870: ! 871: if (usage) { ! 872: tme_output_append_error(_output, ! 873: "%s %s ether %s", ! 874: _("usage:"), ! 875: args[0], ! 876: _("ETHERNET-ADDRESS")); ! 877: return (EINVAL); ! 878: } ! 879: ! 880: /* start the _3c400 structure: */ ! 881: _3c400 = tme_new0(struct tme_3c400, 1); ! 882: _3c400->tme_3c400_element = element; ! 883: tme_mutex_init(&_3c400->tme_3c400_mutex); ! 884: tme_rwlock_init(&_3c400->tme_3c400_rwlock); ! 885: memcpy(_3c400->tme_3c400_card + TME_3C400_REG_AROM, ! 886: arom, ! 887: sizeof(arom)); ! 888: ! 889: /* initialize our simple bus device descriptor: */ ! 890: assert((TME_3C400_SIZ_CARD & (TME_3C400_SIZ_CARD - 1)) == 0); ! 891: _3c400->tme_3c400_device.tme_bus_device_element = element; ! 892: _3c400->tme_3c400_device.tme_bus_device_tlb_fill = _tme_3c400_tlb_fill; ! 893: _3c400->tme_3c400_device.tme_bus_device_address_last = TME_3C400_SIZ_CARD - 1; ! 894: ! 895: /* fill the element: */ ! 896: element->tme_element_private = _3c400; ! 897: element->tme_element_connections_new = _tme_3c400_connections_new; ! 898: ! 899: return (TME_OK); ! 900: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.