![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to apricot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to apricot.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 ! root 1: /* apricot.c: An Apricot 82596 ethernet driver for linux. */ ! 2: /* ! 3: Apricot ! 4: Written 1994 by Mark Evans. ! 5: This driver is for the Apricot 82596 bus-master interface ! 6: ! 7: Modularised 12/94 Mark Evans ! 8: ! 9: Driver skeleton ! 10: Written 1993 by Donald Becker. ! 11: Copyright 1993 United States Government as represented by the Director, ! 12: National Security Agency. This software may only be used and distributed ! 13: according to the terms of the GNU Public License as modified by SRC, ! 14: incorporated herein by reference. ! 15: ! 16: The author may be reached as [email protected] or ! 17: C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715 ! 18: ! 19: ! 20: */ ! 21: ! 22: static const char *version = "apricot.c:v0.2 05/12/94\n"; ! 23: ! 24: #include <linux/module.h> ! 25: ! 26: #include <linux/kernel.h> ! 27: #include <linux/sched.h> ! 28: #include <linux/string.h> ! 29: #include <linux/ptrace.h> ! 30: #include <linux/errno.h> ! 31: #include <linux/ioport.h> ! 32: #include <linux/malloc.h> ! 33: #include <linux/interrupt.h> ! 34: #include <linux/netdevice.h> ! 35: #include <linux/etherdevice.h> ! 36: #include <linux/skbuff.h> ! 37: ! 38: #include <asm/bitops.h> ! 39: #include <asm/io.h> ! 40: #include <asm/dma.h> ! 41: ! 42: #ifndef HAVE_PORTRESERVE ! 43: #define check_region(addr, size) 0 ! 44: #define request_region(addr, size,name) do ; while(0) ! 45: #endif ! 46: ! 47: #ifndef HAVE_ALLOC_SKB ! 48: #define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority) ! 49: #define kfree_skbmem(buff, size) kfree_s(buff,size) ! 50: #endif ! 51: ! 52: #define APRICOT_DEBUG 1 ! 53: ! 54: #ifdef APRICOT_DEBUG ! 55: int i596_debug = APRICOT_DEBUG; ! 56: #else ! 57: int i596_debug = 1; ! 58: #endif ! 59: ! 60: #define APRICOT_TOTAL_SIZE 17 ! 61: ! 62: #define I596_NULL -1 ! 63: ! 64: #define CMD_EOL 0x8000 /* The last command of the list, stop. */ ! 65: #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */ ! 66: #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */ ! 67: ! 68: #define CMD_FLEX 0x0008 /* Enable flexible memory model */ ! 69: ! 70: enum commands { ! 71: CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3, ! 72: CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7}; ! 73: ! 74: #define STAT_C 0x8000 /* Set to 0 after execution */ ! 75: #define STAT_B 0x4000 /* Command being executed */ ! 76: #define STAT_OK 0x2000 /* Command executed ok */ ! 77: #define STAT_A 0x1000 /* Command aborted */ ! 78: ! 79: #define CUC_START 0x0100 ! 80: #define CUC_RESUME 0x0200 ! 81: #define CUC_SUSPEND 0x0300 ! 82: #define CUC_ABORT 0x0400 ! 83: #define RX_START 0x0010 ! 84: #define RX_RESUME 0x0020 ! 85: #define RX_SUSPEND 0x0030 ! 86: #define RX_ABORT 0x0040 ! 87: ! 88: struct i596_cmd { ! 89: unsigned short status; ! 90: unsigned short command; ! 91: struct i596_cmd *next; ! 92: }; ! 93: ! 94: #define EOF 0x8000 ! 95: #define SIZE_MASK 0x3fff ! 96: ! 97: struct i596_tbd { ! 98: unsigned short size; ! 99: unsigned short pad; ! 100: struct i596_tbd *next; ! 101: char *data; ! 102: }; ! 103: ! 104: struct tx_cmd { ! 105: struct i596_cmd cmd; ! 106: struct i596_tbd *tbd; ! 107: unsigned short size; ! 108: unsigned short pad; ! 109: }; ! 110: ! 111: struct i596_rfd { ! 112: unsigned short stat; ! 113: unsigned short cmd; ! 114: struct i596_rfd *next; ! 115: long rbd; ! 116: unsigned short count; ! 117: unsigned short size; ! 118: char data[1532]; ! 119: }; ! 120: ! 121: #define RX_RING_SIZE 8 ! 122: ! 123: struct i596_scb { ! 124: unsigned short status; ! 125: unsigned short command; ! 126: struct i596_cmd *cmd; ! 127: struct i596_rfd *rfd; ! 128: unsigned long crc_err; ! 129: unsigned long align_err; ! 130: unsigned long resource_err; ! 131: unsigned long over_err; ! 132: unsigned long rcvdt_err; ! 133: unsigned long short_err; ! 134: unsigned short t_on; ! 135: unsigned short t_off; ! 136: }; ! 137: ! 138: struct i596_iscp { ! 139: unsigned long stat; ! 140: struct i596_scb *scb; ! 141: }; ! 142: ! 143: struct i596_scp { ! 144: unsigned long sysbus; ! 145: unsigned long pad; ! 146: struct i596_iscp *iscp; ! 147: }; ! 148: ! 149: struct i596_private { ! 150: volatile struct i596_scp scp; ! 151: volatile struct i596_iscp iscp; ! 152: volatile struct i596_scb scb; ! 153: volatile struct i596_cmd set_add; ! 154: char eth_addr[8]; ! 155: volatile struct i596_cmd set_conf; ! 156: char i596_config[16]; ! 157: volatile struct i596_cmd tdr; ! 158: unsigned long stat; ! 159: int last_restart; ! 160: struct i596_rfd *rx_tail; ! 161: struct i596_cmd *cmd_tail; ! 162: struct i596_cmd *cmd_head; ! 163: int cmd_backlog; ! 164: unsigned long last_cmd; ! 165: struct enet_statistics stats; ! 166: }; ! 167: ! 168: char init_setup[] = { ! 169: 0x8E, /* length, prefetch on */ ! 170: 0xC8, /* fifo to 8, monitor off */ ! 171: 0x80, /* don't save bad frames */ ! 172: 0x2E, /* No source address insertion, 8 byte preamble */ ! 173: 0x00, /* priority and backoff defaults */ ! 174: 0x60, /* interframe spacing */ ! 175: 0x00, /* slot time LSB */ ! 176: 0xf2, /* slot time and retries */ ! 177: 0x00, /* promiscuous mode */ ! 178: 0x00, /* collision detect */ ! 179: 0x40, /* minimum frame length */ ! 180: 0xff, ! 181: 0x00, ! 182: 0x7f /* *multi IA */ }; ! 183: ! 184: static int i596_open(struct device *dev); ! 185: static int i596_start_xmit(struct sk_buff *skb, struct device *dev); ! 186: static void i596_interrupt(int irq, void *dev_id, struct pt_regs *regs); ! 187: static int i596_close(struct device *dev); ! 188: static struct enet_statistics *i596_get_stats(struct device *dev); ! 189: static void i596_add_cmd(struct device *dev, struct i596_cmd *cmd); ! 190: static void print_eth(char *); ! 191: static void set_multicast_list(struct device *dev); ! 192: ! 193: ! 194: static inline int ! 195: init_rx_bufs(struct device *dev, int num) ! 196: { ! 197: struct i596_private *lp = (struct i596_private *)dev->priv; ! 198: int i; ! 199: struct i596_rfd *rfd; ! 200: ! 201: lp->scb.rfd = (struct i596_rfd *)I596_NULL; ! 202: ! 203: if (i596_debug > 1) printk ("%s: init_rx_bufs %d.\n", dev->name, num); ! 204: ! 205: for (i = 0; i < num; i++) ! 206: { ! 207: if (!(rfd = (struct i596_rfd *)kmalloc(sizeof(struct i596_rfd), GFP_KERNEL))) ! 208: break; ! 209: ! 210: rfd->stat = 0x0000; ! 211: rfd->rbd = I596_NULL; ! 212: rfd->count = 0; ! 213: rfd->size = 1532; ! 214: if (i == 0) ! 215: { ! 216: rfd->cmd = CMD_EOL; ! 217: lp->rx_tail = rfd; ! 218: } ! 219: else ! 220: rfd->cmd = 0x0000; ! 221: ! 222: rfd->next = lp->scb.rfd; ! 223: lp->scb.rfd = rfd; ! 224: } ! 225: ! 226: if (i != 0) ! 227: lp->rx_tail->next = lp->scb.rfd; ! 228: ! 229: return (i); ! 230: } ! 231: ! 232: static inline void ! 233: remove_rx_bufs(struct device *dev) ! 234: { ! 235: struct i596_private *lp = (struct i596_private *)dev->priv; ! 236: struct i596_rfd *rfd = lp->scb.rfd; ! 237: ! 238: lp->rx_tail->next = (struct i596_rfd *)I596_NULL; ! 239: ! 240: do ! 241: { ! 242: lp->scb.rfd = rfd->next; ! 243: kfree_s(rfd, sizeof(struct i596_rfd)); ! 244: rfd = lp->scb.rfd; ! 245: } ! 246: while (rfd != lp->rx_tail); ! 247: } ! 248: ! 249: static inline void ! 250: init_i596_mem(struct device *dev) ! 251: { ! 252: struct i596_private *lp = (struct i596_private *)dev->priv; ! 253: short ioaddr = dev->base_addr; ! 254: int boguscnt = 100; ! 255: ! 256: /* change the scp address */ ! 257: outw(0, ioaddr); ! 258: outw(0, ioaddr); ! 259: outb(4, ioaddr+0xf); ! 260: outw(((((int)&lp->scp) & 0xffff) | 2), ioaddr); ! 261: outw((((int)&lp->scp)>>16) & 0xffff, ioaddr); ! 262: ! 263: lp->last_cmd = jiffies; ! 264: ! 265: lp->scp.sysbus = 0x00440000; ! 266: lp->scp.iscp = &(lp->iscp); ! 267: lp->iscp.scb = &(lp->scb); ! 268: lp->iscp.stat = 0x0001; ! 269: lp->cmd_backlog = 0; ! 270: ! 271: lp->cmd_head = lp->scb.cmd = (struct i596_cmd *) I596_NULL; ! 272: ! 273: if (i596_debug > 2) printk("%s: starting i82596.\n", dev->name); ! 274: ! 275: (void) inb (ioaddr+0x10); ! 276: outb(4, ioaddr+0xf); ! 277: outw(0, ioaddr+4); ! 278: ! 279: while (lp->iscp.stat) ! 280: if (--boguscnt == 0) ! 281: { ! 282: printk("%s: i82596 initialization timed out with status %4.4x, cmd %4.4x.\n", ! 283: dev->name, lp->scb.status, lp->scb.command); ! 284: break; ! 285: } ! 286: ! 287: lp->scb.command = 0; ! 288: ! 289: memcpy (lp->i596_config, init_setup, 14); ! 290: lp->set_conf.command = CmdConfigure; ! 291: i596_add_cmd(dev, &lp->set_conf); ! 292: ! 293: memcpy (lp->eth_addr, dev->dev_addr, 6); ! 294: lp->set_add.command = CmdSASetup; ! 295: i596_add_cmd(dev, &lp->set_add); ! 296: ! 297: lp->tdr.command = CmdTDR; ! 298: i596_add_cmd(dev, &lp->tdr); ! 299: ! 300: boguscnt = 200; ! 301: while (lp->scb.status, lp->scb.command) ! 302: if (--boguscnt == 0) ! 303: { ! 304: printk("%s: receive unit start timed out with status %4.4x, cmd %4.4x.\n", ! 305: dev->name, lp->scb.status, lp->scb.command); ! 306: break; ! 307: } ! 308: ! 309: lp->scb.command = RX_START; ! 310: outw(0, ioaddr+4); ! 311: ! 312: boguscnt = 200; ! 313: while (lp->scb.status, lp->scb.command) ! 314: if (--boguscnt == 0) ! 315: { ! 316: printk("i82596 init timed out with status %4.4x, cmd %4.4x.\n", ! 317: lp->scb.status, lp->scb.command); ! 318: break; ! 319: } ! 320: ! 321: return; ! 322: } ! 323: ! 324: static inline int ! 325: i596_rx(struct device *dev) ! 326: { ! 327: struct i596_private *lp = (struct i596_private *)dev->priv; ! 328: int frames = 0; ! 329: ! 330: if (i596_debug > 3) printk ("i596_rx()\n"); ! 331: ! 332: while ((lp->scb.rfd->stat) & STAT_C) ! 333: { ! 334: if (i596_debug >2) print_eth(lp->scb.rfd->data); ! 335: ! 336: if ((lp->scb.rfd->stat) & STAT_OK) ! 337: { ! 338: /* a good frame */ ! 339: int pkt_len = lp->scb.rfd->count & 0x3fff; ! 340: struct sk_buff *skb = dev_alloc_skb(pkt_len); ! 341: ! 342: frames++; ! 343: ! 344: if (skb == NULL) ! 345: { ! 346: printk ("%s: i596_rx Memory squeeze, dropping packet.\n", dev->name); ! 347: lp->stats.rx_dropped++; ! 348: break; ! 349: } ! 350: ! 351: skb->dev = dev; ! 352: memcpy(skb_put(skb,pkt_len), lp->scb.rfd->data, pkt_len); ! 353: ! 354: skb->protocol=eth_type_trans(skb,dev); ! 355: netif_rx(skb); ! 356: lp->stats.rx_packets++; ! 357: ! 358: if (i596_debug > 4) print_eth(skb->data); ! 359: } ! 360: else ! 361: { ! 362: lp->stats.rx_errors++; ! 363: if ((lp->scb.rfd->stat) & 0x0001) lp->stats.collisions++; ! 364: if ((lp->scb.rfd->stat) & 0x0080) lp->stats.rx_length_errors++; ! 365: if ((lp->scb.rfd->stat) & 0x0100) lp->stats.rx_over_errors++; ! 366: if ((lp->scb.rfd->stat) & 0x0200) lp->stats.rx_fifo_errors++; ! 367: if ((lp->scb.rfd->stat) & 0x0400) lp->stats.rx_frame_errors++; ! 368: if ((lp->scb.rfd->stat) & 0x0800) lp->stats.rx_crc_errors++; ! 369: if ((lp->scb.rfd->stat) & 0x1000) lp->stats.rx_length_errors++; ! 370: } ! 371: ! 372: lp->scb.rfd->stat = 0; ! 373: lp->rx_tail->cmd = 0; ! 374: lp->rx_tail = lp->scb.rfd; ! 375: lp->scb.rfd = lp->scb.rfd->next; ! 376: lp->rx_tail->count = 0; ! 377: lp->rx_tail->cmd = CMD_EOL; ! 378: ! 379: } ! 380: ! 381: if (i596_debug > 3) printk ("frames %d\n", frames); ! 382: ! 383: return 0; ! 384: } ! 385: ! 386: static inline void ! 387: i596_cleanup_cmd(struct i596_private *lp) ! 388: { ! 389: struct i596_cmd *ptr; ! 390: int boguscnt = 100; ! 391: ! 392: if (i596_debug > 4) printk ("i596_cleanup_cmd\n"); ! 393: ! 394: while (lp->cmd_head != (struct i596_cmd *) I596_NULL) ! 395: { ! 396: ptr = lp->cmd_head; ! 397: ! 398: lp->cmd_head = lp->cmd_head->next; ! 399: lp->cmd_backlog--; ! 400: ! 401: switch ((ptr->command) & 0x7) ! 402: { ! 403: case CmdTx: ! 404: { ! 405: struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr; ! 406: struct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1; ! 407: ! 408: dev_kfree_skb(skb, FREE_WRITE); ! 409: ! 410: lp->stats.tx_errors++; ! 411: lp->stats.tx_aborted_errors++; ! 412: ! 413: ptr->next = (struct i596_cmd * ) I596_NULL; ! 414: kfree_s((unsigned char *)tx_cmd, (sizeof (struct tx_cmd) + sizeof (struct i596_tbd))); ! 415: break; ! 416: } ! 417: case CmdMulticastList: ! 418: { ! 419: unsigned short count = *((unsigned short *) (ptr + 1)); ! 420: ! 421: ptr->next = (struct i596_cmd * ) I596_NULL; ! 422: kfree_s((unsigned char *)ptr, (sizeof (struct i596_cmd) + count + 2)); ! 423: break; ! 424: } ! 425: default: ! 426: ptr->next = (struct i596_cmd * ) I596_NULL; ! 427: } ! 428: } ! 429: ! 430: while (lp->scb.status, lp->scb.command) ! 431: if (--boguscnt == 0) ! 432: { ! 433: printk("i596_cleanup_cmd timed out with status %4.4x, cmd %4.4x.\n", ! 434: lp->scb.status, lp->scb.command); ! 435: break; ! 436: } ! 437: ! 438: lp->scb.cmd = lp->cmd_head; ! 439: } ! 440: ! 441: static inline void ! 442: i596_reset(struct device *dev, struct i596_private *lp, int ioaddr) ! 443: { ! 444: int boguscnt = 100; ! 445: ! 446: if (i596_debug > 4) printk ("i596_reset\n"); ! 447: ! 448: while (lp->scb.status, lp->scb.command) ! 449: if (--boguscnt == 0) ! 450: { ! 451: printk("i596_reset timed out with status %4.4x, cmd %4.4x.\n", ! 452: lp->scb.status, lp->scb.command); ! 453: break; ! 454: } ! 455: ! 456: dev->start = 0; ! 457: dev->tbusy = 1; ! 458: ! 459: lp->scb.command = CUC_ABORT|RX_ABORT; ! 460: outw(0, ioaddr+4); ! 461: ! 462: /* wait for shutdown */ ! 463: boguscnt = 400; ! 464: ! 465: while ((lp->scb.status, lp->scb.command) || lp->scb.command) ! 466: if (--boguscnt == 0) ! 467: { ! 468: printk("i596_reset 2 timed out with status %4.4x, cmd %4.4x.\n", ! 469: lp->scb.status, lp->scb.command); ! 470: break; ! 471: } ! 472: ! 473: i596_cleanup_cmd(lp); ! 474: i596_rx(dev); ! 475: ! 476: dev->start = 1; ! 477: dev->tbusy = 0; ! 478: dev->interrupt = 0; ! 479: init_i596_mem(dev); ! 480: } ! 481: ! 482: static void i596_add_cmd(struct device *dev, struct i596_cmd *cmd) ! 483: { ! 484: struct i596_private *lp = (struct i596_private *)dev->priv; ! 485: int ioaddr = dev->base_addr; ! 486: unsigned long flags; ! 487: int boguscnt = 100; ! 488: ! 489: if (i596_debug > 4) printk ("i596_add_cmd\n"); ! 490: ! 491: cmd->status = 0; ! 492: cmd->command |= (CMD_EOL|CMD_INTR); ! 493: cmd->next = (struct i596_cmd *) I596_NULL; ! 494: ! 495: save_flags(flags); ! 496: cli(); ! 497: if (lp->cmd_head != (struct i596_cmd *) I596_NULL) ! 498: lp->cmd_tail->next = cmd; ! 499: else ! 500: { ! 501: lp->cmd_head = cmd; ! 502: while (lp->scb.status, lp->scb.command) ! 503: if (--boguscnt == 0) ! 504: { ! 505: printk("i596_add_cmd timed out with status %4.4x, cmd %4.4x.\n", ! 506: lp->scb.status, lp->scb.command); ! 507: break; ! 508: } ! 509: ! 510: lp->scb.cmd = cmd; ! 511: lp->scb.command = CUC_START; ! 512: outw (0, ioaddr+4); ! 513: } ! 514: lp->cmd_tail = cmd; ! 515: lp->cmd_backlog++; ! 516: ! 517: lp->cmd_head = lp->scb.cmd; ! 518: restore_flags(flags); ! 519: ! 520: if (lp->cmd_backlog > 16) ! 521: { ! 522: int tickssofar = jiffies - lp->last_cmd; ! 523: ! 524: if (tickssofar < 25) return; ! 525: ! 526: printk("%s: command unit timed out, status resetting.\n", dev->name); ! 527: ! 528: i596_reset(dev, lp, ioaddr); ! 529: } ! 530: } ! 531: ! 532: static int ! 533: i596_open(struct device *dev) ! 534: { ! 535: int i; ! 536: ! 537: if (i596_debug > 1) ! 538: printk("%s: i596_open() irq %d.\n", dev->name, dev->irq); ! 539: ! 540: if (request_irq(dev->irq, &i596_interrupt, 0, "apricot", NULL)) ! 541: return -EAGAIN; ! 542: ! 543: irq2dev_map[dev->irq] = dev; ! 544: ! 545: i = init_rx_bufs(dev, RX_RING_SIZE); ! 546: ! 547: if ((i = init_rx_bufs(dev, RX_RING_SIZE)) < RX_RING_SIZE) ! 548: printk("%s: only able to allocate %d receive buffers\n", dev->name, i); ! 549: ! 550: if (i < 4) ! 551: { ! 552: free_irq(dev->irq, NULL); ! 553: irq2dev_map[dev->irq] = 0; ! 554: return -EAGAIN; ! 555: } ! 556: ! 557: dev->tbusy = 0; ! 558: dev->interrupt = 0; ! 559: dev->start = 1; ! 560: MOD_INC_USE_COUNT; ! 561: ! 562: /* Initialize the 82596 memory */ ! 563: init_i596_mem(dev); ! 564: ! 565: return 0; /* Always succeed */ ! 566: } ! 567: ! 568: static int ! 569: i596_start_xmit(struct sk_buff *skb, struct device *dev) ! 570: { ! 571: struct i596_private *lp = (struct i596_private *)dev->priv; ! 572: int ioaddr = dev->base_addr; ! 573: struct tx_cmd *tx_cmd; ! 574: ! 575: if (i596_debug > 2) printk ("%s: Apricot start xmit\n", dev->name); ! 576: ! 577: /* Transmitter timeout, serious problems. */ ! 578: if (dev->tbusy) { ! 579: int tickssofar = jiffies - dev->trans_start; ! 580: if (tickssofar < 5) ! 581: return 1; ! 582: printk("%s: transmit timed out, status resetting.\n", ! 583: dev->name); ! 584: lp->stats.tx_errors++; ! 585: /* Try to restart the adaptor */ ! 586: if (lp->last_restart == lp->stats.tx_packets) { ! 587: if (i596_debug > 1) printk ("Resetting board.\n"); ! 588: ! 589: /* Shutdown and restart */ ! 590: i596_reset(dev,lp, ioaddr); ! 591: } else { ! 592: /* Issue a channel attention signal */ ! 593: if (i596_debug > 1) printk ("Kicking board.\n"); ! 594: ! 595: lp->scb.command = CUC_START|RX_START; ! 596: outw(0, ioaddr+4); ! 597: ! 598: lp->last_restart = lp->stats.tx_packets; ! 599: } ! 600: dev->tbusy = 0; ! 601: dev->trans_start = jiffies; ! 602: } ! 603: ! 604: /* If some higher level thinks we've misses a tx-done interrupt ! 605: we are passed NULL. n.b. dev_tint handles the cli()/sti() ! 606: itself. */ ! 607: if (skb == NULL) { ! 608: dev_tint(dev); ! 609: return 0; ! 610: } ! 611: ! 612: /* shouldn't happen */ ! 613: if (skb->len <= 0) return 0; ! 614: ! 615: if (i596_debug > 3) printk("%s: i596_start_xmit() called\n", dev->name); ! 616: ! 617: /* Block a timer-based transmit from overlapping. This could better be ! 618: done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */ ! 619: if (set_bit(0, (void*)&dev->tbusy) != 0) ! 620: printk("%s: Transmitter access conflict.\n", dev->name); ! 621: else ! 622: { ! 623: short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; ! 624: dev->trans_start = jiffies; ! 625: ! 626: tx_cmd = (struct tx_cmd *) kmalloc ((sizeof (struct tx_cmd) + sizeof (struct i596_tbd)), GFP_ATOMIC); ! 627: if (tx_cmd == NULL) ! 628: { ! 629: printk ("%s: i596_xmit Memory squeeze, dropping packet.\n", dev->name); ! 630: lp->stats.tx_dropped++; ! 631: ! 632: dev_kfree_skb(skb, FREE_WRITE); ! 633: } ! 634: else ! 635: { ! 636: tx_cmd->tbd = (struct i596_tbd *) (tx_cmd + 1); ! 637: tx_cmd->tbd->next = (struct i596_tbd *) I596_NULL; ! 638: ! 639: tx_cmd->cmd.command = CMD_FLEX|CmdTx; ! 640: ! 641: tx_cmd->pad = 0; ! 642: tx_cmd->size = 0; ! 643: tx_cmd->tbd->pad = 0; ! 644: tx_cmd->tbd->size = EOF | length; ! 645: ! 646: tx_cmd->tbd->data = skb->data; ! 647: ! 648: if (i596_debug > 3) print_eth(skb->data); ! 649: ! 650: i596_add_cmd(dev, (struct i596_cmd *)tx_cmd); ! 651: ! 652: lp->stats.tx_packets++; ! 653: } ! 654: } ! 655: ! 656: dev->tbusy = 0; ! 657: ! 658: return 0; ! 659: } ! 660: ! 661: ! 662: static void print_eth(char *add) ! 663: { ! 664: int i; ! 665: ! 666: printk ("Dest "); ! 667: for (i = 0; i < 6; i++) ! 668: printk(" %2.2X", (unsigned char)add[i]); ! 669: printk ("\n"); ! 670: ! 671: printk ("Source"); ! 672: for (i = 0; i < 6; i++) ! 673: printk(" %2.2X", (unsigned char)add[i+6]); ! 674: printk ("\n"); ! 675: printk ("type %2.2X%2.2X\n", (unsigned char)add[12], (unsigned char)add[13]); ! 676: } ! 677: ! 678: int apricot_probe(struct device *dev) ! 679: { ! 680: int i; ! 681: struct i596_private *lp; ! 682: int checksum = 0; ! 683: int ioaddr = 0x300; ! 684: char eth_addr[6]; ! 685: ! 686: /* this is easy the ethernet interface can only be at 0x300 */ ! 687: /* first check nothing is already registered here */ ! 688: ! 689: if (check_region(ioaddr, APRICOT_TOTAL_SIZE)) ! 690: return ENODEV; ! 691: ! 692: for (i = 0; i < 8; i++) ! 693: { ! 694: eth_addr[i] = inb(ioaddr+8+i); ! 695: checksum += eth_addr[i]; ! 696: } ! 697: ! 698: /* checksum is a multiple of 0x100, got this wrong first time ! 699: some machines have 0x100, some 0x200. The DOS driver doesn't ! 700: even bother with the checksum */ ! 701: ! 702: if (checksum % 0x100) return ENODEV; ! 703: ! 704: /* Some other boards trip the checksum.. but then appear as ether ! 705: address 0. Trap these - AC */ ! 706: ! 707: if(memcmp(eth_addr,"\x00\x00\x49",3)!= 0) ! 708: return ENODEV; ! 709: ! 710: request_region(ioaddr, APRICOT_TOTAL_SIZE, "apricot"); ! 711: ! 712: dev->base_addr = ioaddr; ! 713: ether_setup(dev); ! 714: printk("%s: Apricot 82596 at %#3x,", dev->name, ioaddr); ! 715: ! 716: for (i = 0; i < 6; i++) ! 717: printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]); ! 718: ! 719: dev->base_addr = ioaddr; ! 720: dev->irq = 10; ! 721: printk(" IRQ %d.\n", dev->irq); ! 722: ! 723: if (i596_debug > 0) printk(version); ! 724: ! 725: /* The APRICOT-specific entries in the device structure. */ ! 726: dev->open = &i596_open; ! 727: dev->stop = &i596_close; ! 728: dev->hard_start_xmit = &i596_start_xmit; ! 729: dev->get_stats = &i596_get_stats; ! 730: dev->set_multicast_list = &set_multicast_list; ! 731: ! 732: dev->mem_start = (int)kmalloc(sizeof(struct i596_private)+ 0x0f, GFP_KERNEL); ! 733: /* align for scp */ ! 734: dev->priv = (void *)((dev->mem_start + 0xf) & 0xfffffff0); ! 735: ! 736: lp = (struct i596_private *)dev->priv; ! 737: memset((void *)lp, 0, sizeof(struct i596_private)); ! 738: lp->scb.command = 0; ! 739: lp->scb.cmd = (struct i596_cmd *) I596_NULL; ! 740: lp->scb.rfd = (struct i596_rfd *)I596_NULL; ! 741: ! 742: return 0; ! 743: } ! 744: ! 745: static void ! 746: i596_interrupt(int irq, void *dev_id, struct pt_regs *regs) ! 747: { ! 748: struct device *dev = (struct device *)(irq2dev_map[irq]); ! 749: struct i596_private *lp; ! 750: short ioaddr; ! 751: int boguscnt = 200; ! 752: unsigned short status, ack_cmd = 0; ! 753: ! 754: if (dev == NULL) { ! 755: printk ("i596_interrupt(): irq %d for unknown device.\n", irq); ! 756: return; ! 757: } ! 758: ! 759: if (i596_debug > 3) printk ("%s: i596_interrupt(): irq %d\n",dev->name, irq); ! 760: ! 761: if (dev->interrupt) ! 762: printk("%s: Re-entering the interrupt handler.\n", dev->name); ! 763: ! 764: dev->interrupt = 1; ! 765: ! 766: ioaddr = dev->base_addr; ! 767: ! 768: lp = (struct i596_private *)dev->priv; ! 769: ! 770: while (lp->scb.status, lp->scb.command) ! 771: if (--boguscnt == 0) ! 772: { ! 773: printk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command); ! 774: break; ! 775: } ! 776: status = lp->scb.status; ! 777: ! 778: if (i596_debug > 4) ! 779: printk("%s: i596 interrupt, status %4.4x.\n", dev->name, status); ! 780: ! 781: ack_cmd = status & 0xf000; ! 782: ! 783: if ((status & 0x8000) || (status & 0x2000)) ! 784: { ! 785: struct i596_cmd *ptr; ! 786: ! 787: if ((i596_debug > 4) && (status & 0x8000)) ! 788: printk("%s: i596 interrupt completed command.\n", dev->name); ! 789: if ((i596_debug > 4) && (status & 0x2000)) ! 790: printk("%s: i596 interrupt command unit inactive %x.\n", dev->name, status & 0x0700); ! 791: ! 792: while ((lp->cmd_head != (struct i596_cmd *) I596_NULL) && (lp->cmd_head->status & STAT_C)) ! 793: { ! 794: ptr = lp->cmd_head; ! 795: ! 796: lp->cmd_head = lp->cmd_head->next; ! 797: lp->cmd_backlog--; ! 798: ! 799: switch ((ptr->command) & 0x7) ! 800: { ! 801: case CmdTx: ! 802: { ! 803: struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr; ! 804: struct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1; ! 805: ! 806: dev_kfree_skb(skb, FREE_WRITE); ! 807: ! 808: if ((ptr->status) & STAT_OK) ! 809: { ! 810: if (i596_debug >2) print_eth(skb->data); ! 811: } ! 812: else ! 813: { ! 814: lp->stats.tx_errors++; ! 815: if ((ptr->status) & 0x0020) lp->stats.collisions++; ! 816: if (!((ptr->status) & 0x0040)) lp->stats.tx_heartbeat_errors++; ! 817: if ((ptr->status) & 0x0400) lp->stats.tx_carrier_errors++; ! 818: if ((ptr->status) & 0x0800) lp->stats.collisions++; ! 819: if ((ptr->status) & 0x1000) lp->stats.tx_aborted_errors++; ! 820: } ! 821: ! 822: ! 823: ptr->next = (struct i596_cmd * ) I596_NULL; ! 824: kfree_s((unsigned char *)tx_cmd, (sizeof (struct tx_cmd) + sizeof (struct i596_tbd))); ! 825: break; ! 826: } ! 827: case CmdMulticastList: ! 828: { ! 829: unsigned short count = *((unsigned short *) (ptr + 1)); ! 830: ! 831: ptr->next = (struct i596_cmd * ) I596_NULL; ! 832: kfree_s((unsigned char *)ptr, (sizeof (struct i596_cmd) + count + 2)); ! 833: break; ! 834: } ! 835: case CmdTDR: ! 836: { ! 837: unsigned long status = *((unsigned long *) (ptr + 1)); ! 838: ! 839: if (status & 0x8000) ! 840: { ! 841: if (i596_debug > 3) ! 842: printk("%s: link ok.\n", dev->name); ! 843: } ! 844: else ! 845: { ! 846: if (status & 0x4000) ! 847: printk("%s: Transceiver problem.\n", dev->name); ! 848: if (status & 0x2000) ! 849: printk("%s: Termination problem.\n", dev->name); ! 850: if (status & 0x1000) ! 851: printk("%s: Short circuit.\n", dev->name); ! 852: ! 853: printk("%s: Time %ld.\n", dev->name, status & 0x07ff); ! 854: } ! 855: } ! 856: default: ! 857: ptr->next = (struct i596_cmd * ) I596_NULL; ! 858: ! 859: lp->last_cmd = jiffies; ! 860: } ! 861: } ! 862: ! 863: ptr = lp->cmd_head; ! 864: while ((ptr != (struct i596_cmd *) I596_NULL) && (ptr != lp->cmd_tail)) ! 865: { ! 866: ptr->command &= 0x1fff; ! 867: ptr = ptr->next; ! 868: } ! 869: ! 870: if ((lp->cmd_head != (struct i596_cmd *) I596_NULL) && (dev->start)) ack_cmd |= CUC_START; ! 871: lp->scb.cmd = lp->cmd_head; ! 872: } ! 873: ! 874: if ((status & 0x1000) || (status & 0x4000)) ! 875: { ! 876: if ((i596_debug > 4) && (status & 0x4000)) ! 877: printk("%s: i596 interrupt received a frame.\n", dev->name); ! 878: if ((i596_debug > 4) && (status & 0x1000)) ! 879: printk("%s: i596 interrupt receive unit inactive %x.\n", dev->name, status & 0x0070); ! 880: ! 881: i596_rx(dev); ! 882: ! 883: if (dev->start) ack_cmd |= RX_START; ! 884: } ! 885: ! 886: /* acknowledge the interrupt */ ! 887: ! 888: /* ! 889: if ((lp->scb.cmd != (struct i596_cmd *) I596_NULL) && (dev->start)) ack_cmd | = CUC_START; ! 890: */ ! 891: boguscnt = 100; ! 892: while (lp->scb.status, lp->scb.command) ! 893: if (--boguscnt == 0) ! 894: { ! 895: printk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command); ! 896: break; ! 897: } ! 898: lp->scb.command = ack_cmd; ! 899: ! 900: (void) inb (ioaddr+0x10); ! 901: outb (4, ioaddr+0xf); ! 902: outw (0, ioaddr+4); ! 903: ! 904: if (i596_debug > 4) ! 905: printk("%s: exiting interrupt.\n", dev->name); ! 906: ! 907: dev->interrupt = 0; ! 908: return; ! 909: } ! 910: ! 911: static int ! 912: i596_close(struct device *dev) ! 913: { ! 914: int ioaddr = dev->base_addr; ! 915: struct i596_private *lp = (struct i596_private *)dev->priv; ! 916: int boguscnt = 200; ! 917: ! 918: dev->start = 0; ! 919: dev->tbusy = 1; ! 920: ! 921: if (i596_debug > 1) ! 922: printk("%s: Shutting down ethercard, status was %4.4x.\n", ! 923: dev->name, lp->scb.status); ! 924: ! 925: lp->scb.command = CUC_ABORT|RX_ABORT; ! 926: outw(0, ioaddr+4); ! 927: ! 928: i596_cleanup_cmd(lp); ! 929: ! 930: while (lp->scb.status, lp->scb.command) ! 931: if (--boguscnt == 0) ! 932: { ! 933: printk("%s: close timed out with status %4.4x, cmd %4.4x.\n", ! 934: dev->name, lp->scb.status, lp->scb.command); ! 935: break; ! 936: } ! 937: free_irq(dev->irq, NULL); ! 938: irq2dev_map[dev->irq] = 0; ! 939: remove_rx_bufs(dev); ! 940: MOD_DEC_USE_COUNT; ! 941: ! 942: return 0; ! 943: } ! 944: ! 945: static struct enet_statistics * ! 946: i596_get_stats(struct device *dev) ! 947: { ! 948: struct i596_private *lp = (struct i596_private *)dev->priv; ! 949: ! 950: return &lp->stats; ! 951: } ! 952: ! 953: /* ! 954: * Set or clear the multicast filter for this adaptor. ! 955: */ ! 956: ! 957: static void set_multicast_list(struct device *dev) ! 958: { ! 959: struct i596_private *lp = (struct i596_private *)dev->priv; ! 960: struct i596_cmd *cmd; ! 961: ! 962: if (i596_debug > 1) ! 963: printk ("%s: set multicast list %d\n", dev->name, dev->mc_count); ! 964: ! 965: if (dev->mc_count > 0) ! 966: { ! 967: struct dev_mc_list *dmi; ! 968: char *cp; ! 969: cmd = (struct i596_cmd *) kmalloc(sizeof(struct i596_cmd)+2+dev->mc_count*6, GFP_ATOMIC); ! 970: if (cmd == NULL) ! 971: { ! 972: printk ("%s: set_multicast Memory squeeze.\n", dev->name); ! 973: return; ! 974: } ! 975: cmd->command = CmdMulticastList; ! 976: *((unsigned short *) (cmd + 1)) = dev->mc_count * 6; ! 977: cp=((char *)(cmd + 1))+2; ! 978: for(dmi=dev->mc_list;dmi!=NULL;dmi=dmi->next) ! 979: { ! 980: memcpy(cp, dmi,6); ! 981: cp+=6; ! 982: } ! 983: print_eth (((char *)(cmd + 1)) + 2); ! 984: i596_add_cmd(dev, cmd); ! 985: } ! 986: else ! 987: { ! 988: if (lp->set_conf.next != (struct i596_cmd * ) I596_NULL) ! 989: return; ! 990: if (dev->mc_count == 0 && !(dev->flags&(IFF_PROMISC|IFF_ALLMULTI))) ! 991: { ! 992: if(dev->flags&IFF_ALLMULTI) ! 993: dev->flags|=IFF_PROMISC; ! 994: lp->i596_config[8] &= ~0x01; ! 995: } ! 996: else ! 997: lp->i596_config[8] |= 0x01; ! 998: ! 999: i596_add_cmd(dev, &lp->set_conf); ! 1000: } ! 1001: } ! 1002: ! 1003: #ifdef HAVE_DEVLIST ! 1004: static unsigned int apricot_portlist[] = {0x300, 0}; ! 1005: struct netdev_entry apricot_drv = ! 1006: {"apricot", apricot_probe, APRICOT_TOTAL_SIZE, apricot_portlist}; ! 1007: #endif ! 1008: ! 1009: #ifdef MODULE ! 1010: static char devicename[9] = { 0, }; ! 1011: static struct device dev_apricot = { ! 1012: devicename, /* device name inserted by /linux/drivers/net/net_init.c */ ! 1013: 0, 0, 0, 0, ! 1014: 0x300, 10, ! 1015: 0, 0, 0, NULL, apricot_probe }; ! 1016: ! 1017: static int io = 0x300; ! 1018: static int irq = 10; ! 1019: ! 1020: int ! 1021: init_module(void) ! 1022: { ! 1023: dev_apricot.base_addr = io; ! 1024: dev_apricot.irq = irq; ! 1025: if (register_netdev(&dev_apricot) != 0) ! 1026: return -EIO; ! 1027: return 0; ! 1028: } ! 1029: ! 1030: void ! 1031: cleanup_module(void) ! 1032: { ! 1033: unregister_netdev(&dev_apricot); ! 1034: kfree_s((void *)dev_apricot.mem_start, sizeof(struct i596_private) + 0xf); ! 1035: dev_apricot.priv = NULL; ! 1036: ! 1037: /* If we don't do this, we can't re-insmod it later. */ ! 1038: release_region(dev_apricot.base_addr, APRICOT_TOTAL_SIZE); ! 1039: } ! 1040: #endif /* MODULE */ ! 1041: ! 1042: /* ! 1043: * Local variables: ! 1044: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c apricot.c" ! 1045: * End: ! 1046: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.