![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to axnet_cs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / clients|
Return to axnet_cs.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / clients |
1.1 ! root 1: /*====================================================================== ! 2: ! 3: A PCMCIA ethernet driver for Asix AX88190-based cards ! 4: ! 5: The Asix AX88190 is a NS8390-derived chipset with a few nasty ! 6: idiosyncracies that make it very inconvenient to support with a ! 7: standard 8390 driver. This driver is based on pcnet_cs, with the ! 8: tweaked 8390 code grafted on the end. Much of what I did was to ! 9: clean up and update a similar driver supplied by Asix, which was ! 10: adapted by William Lee, [email protected]. ! 11: ! 12: Copyright (C) 2001 David A. Hinds -- [email protected] ! 13: ! 14: axnet_cs.c 1.31 2003/08/25 15:57:40 ! 15: ! 16: The network driver code is based on Donald Becker's NE2000 code: ! 17: ! 18: Written 1992,1993 by Donald Becker. ! 19: Copyright 1993 United States Government as represented by the ! 20: Director, National Security Agency. This software may be used and ! 21: distributed according to the terms of the GNU General Public License, ! 22: incorporated herein by reference. ! 23: Donald Becker may be reached at [email protected] ! 24: ! 25: ======================================================================*/ ! 26: ! 27: #include <linux/kernel.h> ! 28: #include <linux/module.h> ! 29: #include <linux/init.h> ! 30: #include <linux/sched.h> ! 31: #include <linux/ptrace.h> ! 32: #include <linux/slab.h> ! 33: #include <linux/string.h> ! 34: #include <linux/timer.h> ! 35: #include <linux/delay.h> ! 36: #include <linux/spinlock.h> ! 37: #include <asm/io.h> ! 38: #include <asm/system.h> ! 39: #include <asm/byteorder.h> ! 40: #include <asm/uaccess.h> ! 41: ! 42: #include <linux/netdevice.h> ! 43: #include "ax8390.h" ! 44: ! 45: #include <pcmcia/version.h> ! 46: #include <pcmcia/cs_types.h> ! 47: #include <pcmcia/cs.h> ! 48: #include <pcmcia/cistpl.h> ! 49: #include <pcmcia/ciscode.h> ! 50: #include <pcmcia/ds.h> ! 51: #include <pcmcia/cisreg.h> ! 52: ! 53: #define AXNET_CMD 0x00 ! 54: #define AXNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */ ! 55: #define AXNET_RESET 0x1f /* Issue a read to reset, a write to clear. */ ! 56: #define AXNET_MII_EEP 0x14 /* Offset of MII access port */ ! 57: #define AXNET_TEST 0x15 /* Offset of TEST Register port */ ! 58: #define AXNET_GPIO 0x17 /* Offset of General Purpose Register Port */ ! 59: ! 60: #define AXNET_START_PG 0x40 /* First page of TX buffer */ ! 61: #define AXNET_STOP_PG 0x80 /* Last page +1 of RX ring */ ! 62: ! 63: #define AXNET_RDC_TIMEOUT 0x02 /* Max wait in jiffies for Tx RDC */ ! 64: ! 65: #define IS_AX88190 0x0001 ! 66: #define IS_AX88790 0x0002 ! 67: ! 68: /*====================================================================*/ ! 69: ! 70: /* Module parameters */ ! 71: ! 72: MODULE_AUTHOR("David Hinds <[email protected]>"); ! 73: MODULE_DESCRIPTION("Asix AX88190 PCMCIA ethernet driver"); ! 74: MODULE_LICENSE("GPL"); ! 75: ! 76: #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i") ! 77: ! 78: /* Bit map of interrupts to choose from */ ! 79: INT_MODULE_PARM(irq_mask, 0xdeb8); ! 80: static int irq_list[4] = { -1 }; ! 81: MODULE_PARM(irq_list, "1-4i"); ! 82: ! 83: #ifdef PCMCIA_DEBUG ! 84: INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG); ! 85: #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args) ! 86: static char *version = ! 87: "axnet_cs.c 1.31 2003/08/25 15:57:40 (David Hinds)"; ! 88: #else ! 89: #define DEBUG(n, args...) ! 90: #endif ! 91: ! 92: /*====================================================================*/ ! 93: ! 94: static void axnet_config(dev_link_t *link); ! 95: static void axnet_release(u_long arg); ! 96: static int axnet_event(event_t event, int priority, ! 97: event_callback_args_t *args); ! 98: static int axnet_open(struct net_device *dev); ! 99: static int axnet_close(struct net_device *dev); ! 100: static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); ! 101: static void ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs); ! 102: static void ei_watchdog(u_long arg); ! 103: static void axnet_reset_8390(struct net_device *dev); ! 104: ! 105: static int mdio_read(ioaddr_t addr, int phy_id, int loc); ! 106: static void mdio_write(ioaddr_t addr, int phy_id, int loc, int value); ! 107: ! 108: static void get_8390_hdr(struct net_device *, ! 109: struct e8390_pkt_hdr *, int); ! 110: static void block_input(struct net_device *dev, int count, ! 111: struct sk_buff *skb, int ring_offset); ! 112: static void block_output(struct net_device *dev, int count, ! 113: const u_char *buf, const int start_page); ! 114: ! 115: static dev_link_t *axnet_attach(void); ! 116: static void axnet_detach(dev_link_t *); ! 117: ! 118: static dev_info_t dev_info = "axnet_cs"; ! 119: static dev_link_t *dev_list; ! 120: ! 121: static int axdev_init(struct net_device *dev); ! 122: static void AX88190_init(struct net_device *dev, int startp); ! 123: static int ax_open(struct net_device *dev); ! 124: static int ax_close(struct net_device *dev); ! 125: static void ax_interrupt(int irq, void *dev_id, struct pt_regs *regs); ! 126: ! 127: /*====================================================================*/ ! 128: ! 129: typedef struct axnet_dev_t { ! 130: struct net_device dev; /* so &dev == &axnet_dev_t */ ! 131: dev_link_t link; ! 132: dev_node_t node; ! 133: caddr_t base; ! 134: struct timer_list watchdog; ! 135: int stale, fast_poll; ! 136: u_short link_status; ! 137: u_char duplex_flag; ! 138: int phy_id; ! 139: int flags; ! 140: } axnet_dev_t; ! 141: ! 142: /*====================================================================== ! 143: ! 144: This bit of code is used to avoid unregistering network devices ! 145: at inappropriate times. 2.2 and later kernels are fairly picky ! 146: about when this can happen. ! 147: ! 148: ======================================================================*/ ! 149: ! 150: static void flush_stale_links(void) ! 151: { ! 152: dev_link_t *link, *next; ! 153: for (link = dev_list; link; link = next) { ! 154: next = link->next; ! 155: if (link->state & DEV_STALE_LINK) ! 156: axnet_detach(link); ! 157: } ! 158: } ! 159: ! 160: /*====================================================================*/ ! 161: ! 162: static void cs_error(client_handle_t handle, int func, int ret) ! 163: { ! 164: error_info_t err = { func, ret }; ! 165: CardServices(ReportError, handle, &err); ! 166: } ! 167: ! 168: /*====================================================================== ! 169: ! 170: We never need to do anything when a axnet device is "initialized" ! 171: by the net software, because we only register already-found cards. ! 172: ! 173: ======================================================================*/ ! 174: ! 175: static int axnet_init(struct net_device *dev) ! 176: { ! 177: return 0; ! 178: } ! 179: ! 180: /*====================================================================== ! 181: ! 182: axnet_attach() creates an "instance" of the driver, allocating ! 183: local data structures for one device. The device is registered ! 184: with Card Services. ! 185: ! 186: ======================================================================*/ ! 187: ! 188: static dev_link_t *axnet_attach(void) ! 189: { ! 190: axnet_dev_t *info; ! 191: dev_link_t *link; ! 192: struct net_device *dev; ! 193: client_reg_t client_reg; ! 194: int i, ret; ! 195: ! 196: DEBUG(0, "axnet_attach()\n"); ! 197: flush_stale_links(); ! 198: ! 199: /* Create new ethernet device */ ! 200: info = kmalloc(sizeof(*info), GFP_KERNEL); ! 201: if (!info) return NULL; ! 202: memset(info, 0, sizeof(*info)); ! 203: link = &info->link; dev = &info->dev; ! 204: link->priv = info; ! 205: ! 206: init_timer(&link->release); ! 207: link->release.function = &axnet_release; ! 208: link->release.data = (u_long)link; ! 209: link->irq.Attributes = IRQ_TYPE_EXCLUSIVE; ! 210: link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID; ! 211: if (irq_list[0] == -1) ! 212: link->irq.IRQInfo2 = irq_mask; ! 213: else ! 214: for (i = 0; i < 4; i++) ! 215: link->irq.IRQInfo2 |= 1 << irq_list[i]; ! 216: link->conf.Attributes = CONF_ENABLE_IRQ; ! 217: link->conf.IntType = INT_MEMORY_AND_IO; ! 218: ! 219: axdev_init(dev); ! 220: init_dev_name(dev, info->node); ! 221: dev->init = &axnet_init; ! 222: dev->open = &axnet_open; ! 223: dev->stop = &axnet_close; ! 224: dev->do_ioctl = &axnet_ioctl; ! 225: ! 226: /* Register with Card Services */ ! 227: link->next = dev_list; ! 228: dev_list = link; ! 229: client_reg.dev_info = &dev_info; ! 230: client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE; ! 231: client_reg.EventMask = ! 232: CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | ! 233: CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | ! 234: CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME; ! 235: client_reg.event_handler = &axnet_event; ! 236: client_reg.Version = 0x0210; ! 237: client_reg.event_callback_args.client_data = link; ! 238: ret = CardServices(RegisterClient, &link->handle, &client_reg); ! 239: if (ret != CS_SUCCESS) { ! 240: cs_error(link->handle, RegisterClient, ret); ! 241: axnet_detach(link); ! 242: return NULL; ! 243: } ! 244: ! 245: return link; ! 246: } /* axnet_attach */ ! 247: ! 248: /*====================================================================== ! 249: ! 250: This deletes a driver "instance". The device is de-registered ! 251: with Card Services. If it has been released, all local data ! 252: structures are freed. Otherwise, the structures will be freed ! 253: when the device is released. ! 254: ! 255: ======================================================================*/ ! 256: ! 257: static void axnet_detach(dev_link_t *link) ! 258: { ! 259: axnet_dev_t *info = link->priv; ! 260: dev_link_t **linkp; ! 261: ! 262: DEBUG(0, "axnet_detach(0x%p)\n", link); ! 263: ! 264: /* Locate device structure */ ! 265: for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) ! 266: if (*linkp == link) break; ! 267: if (*linkp == NULL) ! 268: return; ! 269: ! 270: del_timer(&link->release); ! 271: if (link->state & DEV_CONFIG) { ! 272: axnet_release((u_long)link); ! 273: if (link->state & DEV_STALE_CONFIG) { ! 274: link->state |= DEV_STALE_LINK; ! 275: return; ! 276: } ! 277: } ! 278: ! 279: if (link->handle) ! 280: CardServices(DeregisterClient, link->handle); ! 281: ! 282: /* Unlink device structure, free bits */ ! 283: *linkp = link->next; ! 284: if (link->dev) ! 285: unregister_netdev(&info->dev); ! 286: kfree(info); ! 287: ! 288: } /* axnet_detach */ ! 289: ! 290: /*====================================================================== ! 291: ! 292: This probes for a card's hardware address by reading the PROM. ! 293: ! 294: ======================================================================*/ ! 295: ! 296: static int get_prom(dev_link_t *link) ! 297: { ! 298: struct net_device *dev = link->priv; ! 299: ioaddr_t ioaddr = dev->base_addr; ! 300: int i, j; ! 301: ! 302: /* This is based on drivers/net/ne.c */ ! 303: struct { ! 304: u_char value, offset; ! 305: } program_seq[] = { ! 306: {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/ ! 307: {0x01, EN0_DCFG}, /* Set word-wide access. */ ! 308: {0x00, EN0_RCNTLO}, /* Clear the count regs. */ ! 309: {0x00, EN0_RCNTHI}, ! 310: {0x00, EN0_IMR}, /* Mask completion irq. */ ! 311: {0xFF, EN0_ISR}, ! 312: {E8390_RXOFF|0x40, EN0_RXCR}, /* 0x60 Set to monitor */ ! 313: {E8390_TXOFF, EN0_TXCR}, /* 0x02 and loopback mode. */ ! 314: {0x10, EN0_RCNTLO}, ! 315: {0x00, EN0_RCNTHI}, ! 316: {0x00, EN0_RSARLO}, /* DMA starting at 0x0400. */ ! 317: {0x04, EN0_RSARHI}, ! 318: {E8390_RREAD+E8390_START, E8390_CMD}, ! 319: }; ! 320: ! 321: /* Not much of a test, but the alternatives are messy */ ! 322: if (link->conf.ConfigBase != 0x03c0) ! 323: return 0; ! 324: ! 325: axnet_reset_8390(dev); ! 326: mdelay(10); ! 327: ! 328: for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) ! 329: outb_p(program_seq[i].value, ioaddr + program_seq[i].offset); ! 330: ! 331: for (i = 0; i < 6; i += 2) { ! 332: j = inw(ioaddr + AXNET_DATAPORT); ! 333: dev->dev_addr[i] = j & 0xff; ! 334: dev->dev_addr[i+1] = j >> 8; ! 335: } ! 336: return 1; ! 337: } /* get_prom */ ! 338: ! 339: /*====================================================================== ! 340: ! 341: axnet_config() is scheduled to run after a CARD_INSERTION event ! 342: is received, to configure the PCMCIA socket, and to make the ! 343: ethernet device available to the system. ! 344: ! 345: ======================================================================*/ ! 346: ! 347: #define CS_CHECK(fn, args...) \ ! 348: while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed ! 349: ! 350: #define CFG_CHECK(fn, args...) \ ! 351: if (CardServices(fn, args) != 0) goto next_entry ! 352: ! 353: static int try_io_port(dev_link_t *link) ! 354: { ! 355: int j, ret; ! 356: if (link->io.NumPorts1 == 32) { ! 357: link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; ! 358: if (link->io.NumPorts2 > 0) { ! 359: /* for master/slave multifunction cards */ ! 360: link->io.Attributes2 = IO_DATA_PATH_WIDTH_8; ! 361: link->irq.Attributes = ! 362: IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED; ! 363: } ! 364: } else { ! 365: /* This should be two 16-port windows */ ! 366: link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; ! 367: link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; ! 368: } ! 369: if (link->io.BasePort1 == 0) { ! 370: link->io.IOAddrLines = 16; ! 371: for (j = 0; j < 0x400; j += 0x20) { ! 372: link->io.BasePort1 = j ^ 0x300; ! 373: link->io.BasePort2 = (j ^ 0x300) + 0x10; ! 374: ret = CardServices(RequestIO, link->handle, &link->io); ! 375: if (ret == CS_SUCCESS) return ret; ! 376: } ! 377: return ret; ! 378: } else { ! 379: return CardServices(RequestIO, link->handle, &link->io); ! 380: } ! 381: } ! 382: ! 383: static void axnet_config(dev_link_t *link) ! 384: { ! 385: client_handle_t handle = link->handle; ! 386: axnet_dev_t *info = link->priv; ! 387: struct net_device *dev = &info->dev; ! 388: tuple_t tuple; ! 389: cisparse_t parse; ! 390: int i, j, last_ret, last_fn; ! 391: u_short buf[64]; ! 392: config_info_t conf; ! 393: ! 394: DEBUG(0, "axnet_config(0x%p)\n", link); ! 395: ! 396: tuple.Attributes = 0; ! 397: tuple.TupleData = (cisdata_t *)buf; ! 398: tuple.TupleDataMax = sizeof(buf); ! 399: tuple.TupleOffset = 0; ! 400: tuple.DesiredTuple = CISTPL_CONFIG; ! 401: CS_CHECK(GetFirstTuple, handle, &tuple); ! 402: CS_CHECK(GetTupleData, handle, &tuple); ! 403: CS_CHECK(ParseTuple, handle, &tuple, &parse); ! 404: link->conf.ConfigBase = parse.config.base; ! 405: /* don't trust the CIS on this; Linksys got it wrong */ ! 406: link->conf.Present = 0x63; ! 407: ! 408: /* Configure card */ ! 409: link->state |= DEV_CONFIG; ! 410: ! 411: /* Look up current Vcc */ ! 412: CS_CHECK(GetConfigurationInfo, handle, &conf); ! 413: link->conf.Vcc = conf.Vcc; ! 414: ! 415: tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; ! 416: tuple.Attributes = 0; ! 417: CS_CHECK(GetFirstTuple, handle, &tuple); ! 418: while (last_ret == CS_SUCCESS) { ! 419: cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); ! 420: cistpl_io_t *io = &(parse.cftable_entry.io); ! 421: ! 422: CFG_CHECK(GetTupleData, handle, &tuple); ! 423: CFG_CHECK(ParseTuple, handle, &tuple, &parse); ! 424: if ((cfg->index == 0) || (cfg->io.nwin == 0)) ! 425: goto next_entry; ! 426: ! 427: link->conf.ConfigIndex = 0x05; ! 428: /* For multifunction cards, by convention, we configure the ! 429: network function with window 0, and serial with window 1 */ ! 430: if (io->nwin > 1) { ! 431: i = (io->win[1].len > io->win[0].len); ! 432: link->io.BasePort2 = io->win[1-i].base; ! 433: link->io.NumPorts2 = io->win[1-i].len; ! 434: } else { ! 435: i = link->io.NumPorts2 = 0; ! 436: } ! 437: link->io.BasePort1 = io->win[i].base; ! 438: link->io.NumPorts1 = io->win[i].len; ! 439: link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK; ! 440: if (link->io.NumPorts1 + link->io.NumPorts2 >= 32) { ! 441: last_ret = try_io_port(link); ! 442: if (last_ret == CS_SUCCESS) break; ! 443: } ! 444: next_entry: ! 445: last_ret = CardServices(GetNextTuple, handle, &tuple); ! 446: } ! 447: if (last_ret != CS_SUCCESS) { ! 448: cs_error(handle, RequestIO, last_ret); ! 449: goto failed; ! 450: } ! 451: ! 452: CS_CHECK(RequestIRQ, handle, &link->irq); ! 453: ! 454: if (link->io.NumPorts2 == 8) { ! 455: link->conf.Attributes |= CONF_ENABLE_SPKR; ! 456: link->conf.Status = CCSR_AUDIO_ENA; ! 457: } ! 458: ! 459: CS_CHECK(RequestConfiguration, handle, &link->conf); ! 460: dev->irq = link->irq.AssignedIRQ; ! 461: dev->base_addr = link->io.BasePort1; ! 462: if (register_netdev(dev) != 0) { ! 463: printk(KERN_NOTICE "axnet_cs: register_netdev() failed\n"); ! 464: goto failed; ! 465: } ! 466: ! 467: if (!get_prom(link)) { ! 468: printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n"); ! 469: printk(KERN_NOTICE "axnet_cs: use pcnet_cs instead.\n"); ! 470: unregister_netdev(dev); ! 471: goto failed; ! 472: } ! 473: ! 474: ei_status.name = "AX88190"; ! 475: ei_status.word16 = 1; ! 476: ei_status.tx_start_page = AXNET_START_PG; ! 477: ei_status.rx_start_page = AXNET_START_PG + TX_PAGES; ! 478: ei_status.stop_page = AXNET_STOP_PG; ! 479: ei_status.reset_8390 = &axnet_reset_8390; ! 480: ei_status.get_8390_hdr = &get_8390_hdr; ! 481: ei_status.block_input = &block_input; ! 482: ei_status.block_output = &block_output; ! 483: ! 484: copy_dev_name(info->node, dev); ! 485: link->dev = &info->node; ! 486: ! 487: if (inb(dev->base_addr + AXNET_TEST) != 0) ! 488: info->flags |= IS_AX88790; ! 489: else ! 490: info->flags |= IS_AX88190; ! 491: ! 492: printk(KERN_INFO "%s: Asix AX88%d90: io %#3lx, irq %d, hw_addr ", ! 493: dev->name, ((info->flags & IS_AX88790) ? 7 : 1), ! 494: dev->base_addr, dev->irq); ! 495: for (i = 0; i < 6; i++) ! 496: printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n")); ! 497: ! 498: if (info->flags & IS_AX88790) ! 499: outb(0x10, dev->base_addr + AXNET_GPIO); /* select Internal PHY */ ! 500: ! 501: for (i = 0; i < 32; i++) { ! 502: j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1); ! 503: if ((j != 0) && (j != 0xffff)) break; ! 504: } ! 505: ! 506: ! 507: /* Maybe PHY is in power down mode. (PPD_SET = 1) ! 508: Bit 2 of CCSR is active low. */ ! 509: if (i == 32) { ! 510: conf_reg_t reg = { 0, CS_WRITE, CISREG_CCSR, 0x04 }; ! 511: CardServices(AccessConfigurationRegister, link->handle, ®); ! 512: for (i = 0; i < 32; i++) { ! 513: j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1); ! 514: if ((j != 0) && (j != 0xffff)) break; ! 515: } ! 516: } ! 517: ! 518: info->phy_id = (i < 32) ? i : -1; ! 519: if (i < 32) { ! 520: DEBUG(0, " MII transceiver at index %d, status %x.\n", i, j); ! 521: } else { ! 522: printk(KERN_NOTICE " No MII transceivers found!\n"); ! 523: } ! 524: ! 525: link->state &= ~DEV_CONFIG_PENDING; ! 526: return; ! 527: ! 528: cs_failed: ! 529: cs_error(link->handle, last_fn, last_ret); ! 530: failed: ! 531: axnet_release((u_long)link); ! 532: link->state &= ~DEV_CONFIG_PENDING; ! 533: return; ! 534: } /* axnet_config */ ! 535: ! 536: /*====================================================================== ! 537: ! 538: After a card is removed, axnet_release() will unregister the net ! 539: device, and release the PCMCIA configuration. If the device is ! 540: still open, this will be postponed until it is closed. ! 541: ! 542: ======================================================================*/ ! 543: ! 544: static void axnet_release(u_long arg) ! 545: { ! 546: dev_link_t *link = (dev_link_t *)arg; ! 547: ! 548: DEBUG(0, "axnet_release(0x%p)\n", link); ! 549: ! 550: if (link->open) { ! 551: DEBUG(1, "axnet_cs: release postponed, '%s' still open\n", ! 552: ((axnet_dev_t *)(link->priv))->node.dev_name); ! 553: link->state |= DEV_STALE_CONFIG; ! 554: return; ! 555: } ! 556: ! 557: CardServices(ReleaseConfiguration, link->handle); ! 558: CardServices(ReleaseIO, link->handle, &link->io); ! 559: CardServices(ReleaseIRQ, link->handle, &link->irq); ! 560: ! 561: link->state &= ~DEV_CONFIG; ! 562: ! 563: } /* axnet_release */ ! 564: ! 565: /*====================================================================== ! 566: ! 567: The card status event handler. Mostly, this schedules other ! 568: stuff to run after an event is received. A CARD_REMOVAL event ! 569: also sets some flags to discourage the net drivers from trying ! 570: to talk to the card any more. ! 571: ! 572: ======================================================================*/ ! 573: ! 574: static int axnet_event(event_t event, int priority, ! 575: event_callback_args_t *args) ! 576: { ! 577: dev_link_t *link = args->client_data; ! 578: axnet_dev_t *info = link->priv; ! 579: ! 580: DEBUG(2, "axnet_event(0x%06x)\n", event); ! 581: ! 582: switch (event) { ! 583: case CS_EVENT_CARD_REMOVAL: ! 584: link->state &= ~DEV_PRESENT; ! 585: if (link->state & DEV_CONFIG) { ! 586: netif_device_detach(&info->dev); ! 587: mod_timer(&link->release, jiffies + HZ/20); ! 588: } ! 589: break; ! 590: case CS_EVENT_CARD_INSERTION: ! 591: link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; ! 592: axnet_config(link); ! 593: break; ! 594: case CS_EVENT_PM_SUSPEND: ! 595: link->state |= DEV_SUSPEND; ! 596: /* Fall through... */ ! 597: case CS_EVENT_RESET_PHYSICAL: ! 598: if (link->state & DEV_CONFIG) { ! 599: if (link->open) ! 600: netif_device_detach(&info->dev); ! 601: CardServices(ReleaseConfiguration, link->handle); ! 602: } ! 603: break; ! 604: case CS_EVENT_PM_RESUME: ! 605: link->state &= ~DEV_SUSPEND; ! 606: /* Fall through... */ ! 607: case CS_EVENT_CARD_RESET: ! 608: if (link->state & DEV_CONFIG) { ! 609: CardServices(RequestConfiguration, link->handle, &link->conf); ! 610: if (link->open) { ! 611: axnet_reset_8390(&info->dev); ! 612: AX88190_init(&info->dev, 1); ! 613: netif_device_attach(&info->dev); ! 614: } ! 615: } ! 616: break; ! 617: } ! 618: return 0; ! 619: } /* axnet_event */ ! 620: ! 621: /*====================================================================== ! 622: ! 623: MII interface support ! 624: ! 625: ======================================================================*/ ! 626: ! 627: #define MDIO_SHIFT_CLK 0x01 ! 628: #define MDIO_DATA_WRITE0 0x00 ! 629: #define MDIO_DATA_WRITE1 0x08 ! 630: #define MDIO_DATA_READ 0x04 ! 631: #define MDIO_MASK 0x0f ! 632: #define MDIO_ENB_IN 0x02 ! 633: ! 634: static void mdio_sync(ioaddr_t addr) ! 635: { ! 636: int bits; ! 637: for (bits = 0; bits < 32; bits++) { ! 638: outb_p(MDIO_DATA_WRITE1, addr); ! 639: outb_p(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr); ! 640: } ! 641: } ! 642: ! 643: static int mdio_read(ioaddr_t addr, int phy_id, int loc) ! 644: { ! 645: u_int cmd = (0xf6<<10)|(phy_id<<5)|loc; ! 646: int i, retval = 0; ! 647: ! 648: mdio_sync(addr); ! 649: for (i = 14; i >= 0; i--) { ! 650: int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0; ! 651: outb_p(dat, addr); ! 652: outb_p(dat | MDIO_SHIFT_CLK, addr); ! 653: } ! 654: for (i = 19; i > 0; i--) { ! 655: outb_p(MDIO_ENB_IN, addr); ! 656: retval = (retval << 1) | ((inb_p(addr) & MDIO_DATA_READ) != 0); ! 657: outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr); ! 658: } ! 659: return (retval>>1) & 0xffff; ! 660: } ! 661: ! 662: static void mdio_write(ioaddr_t addr, int phy_id, int loc, int value) ! 663: { ! 664: u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value; ! 665: int i; ! 666: ! 667: mdio_sync(addr); ! 668: for (i = 31; i >= 0; i--) { ! 669: int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0; ! 670: outb_p(dat, addr); ! 671: outb_p(dat | MDIO_SHIFT_CLK, addr); ! 672: } ! 673: for (i = 1; i >= 0; i--) { ! 674: outb_p(MDIO_ENB_IN, addr); ! 675: outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr); ! 676: } ! 677: } ! 678: ! 679: /*====================================================================*/ ! 680: ! 681: static int axnet_open(struct net_device *dev) ! 682: { ! 683: axnet_dev_t *info = (axnet_dev_t *)dev; ! 684: dev_link_t *link = &info->link; ! 685: ! 686: DEBUG(2, "axnet_open('%s')\n", dev->name); ! 687: ! 688: if (!DEV_OK(link)) ! 689: return -ENODEV; ! 690: ! 691: link->open++; ! 692: MOD_INC_USE_COUNT; ! 693: ! 694: request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev); ! 695: ! 696: info->link_status = 0x00; ! 697: info->watchdog.function = &ei_watchdog; ! 698: info->watchdog.data = (u_long)info; ! 699: info->watchdog.expires = jiffies + HZ; ! 700: add_timer(&info->watchdog); ! 701: ! 702: return ax_open(dev); ! 703: } /* axnet_open */ ! 704: ! 705: /*====================================================================*/ ! 706: ! 707: static int axnet_close(struct net_device *dev) ! 708: { ! 709: axnet_dev_t *info = (axnet_dev_t *)dev; ! 710: dev_link_t *link = &info->link; ! 711: ! 712: DEBUG(2, "axnet_close('%s')\n", dev->name); ! 713: ! 714: ax_close(dev); ! 715: free_irq(dev->irq, dev); ! 716: ! 717: link->open--; ! 718: netif_stop_queue(dev); ! 719: netif_mark_down(dev); ! 720: del_timer(&info->watchdog); ! 721: if (link->state & DEV_STALE_CONFIG) ! 722: mod_timer(&link->release, jiffies + HZ/20); ! 723: ! 724: MOD_DEC_USE_COUNT; ! 725: ! 726: return 0; ! 727: } /* axnet_close */ ! 728: ! 729: /*====================================================================== ! 730: ! 731: Hard reset the card. This used to pause for the same period that ! 732: a 8390 reset command required, but that shouldn't be necessary. ! 733: ! 734: ======================================================================*/ ! 735: ! 736: static void axnet_reset_8390(struct net_device *dev) ! 737: { ! 738: ioaddr_t nic_base = dev->base_addr; ! 739: int i; ! 740: ! 741: ei_status.txing = ei_status.dmaing = 0; ! 742: ! 743: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD); ! 744: ! 745: outb(inb(nic_base + AXNET_RESET), nic_base + AXNET_RESET); ! 746: ! 747: for (i = 0; i < 100; i++) { ! 748: if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0) ! 749: break; ! 750: udelay(100); ! 751: } ! 752: outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */ ! 753: ! 754: if (i == 100) ! 755: printk(KERN_ERR "%s: axnet_reset_8390() did not complete.\n", ! 756: dev->name); ! 757: ! 758: } /* axnet_reset_8390 */ ! 759: ! 760: /*====================================================================*/ ! 761: ! 762: static void ei_irq_wrapper(int irq, void *dev_id, struct pt_regs *regs) ! 763: { ! 764: axnet_dev_t *info = dev_id; ! 765: info->stale = 0; ! 766: ax_interrupt(irq, dev_id, regs); ! 767: } ! 768: ! 769: static void ei_watchdog(u_long arg) ! 770: { ! 771: axnet_dev_t *info = (axnet_dev_t *)(arg); ! 772: struct net_device *dev = &info->dev; ! 773: ioaddr_t nic_base = dev->base_addr; ! 774: ioaddr_t mii_addr = nic_base + AXNET_MII_EEP; ! 775: u_short link; ! 776: ! 777: if (!netif_device_present(dev)) goto reschedule; ! 778: ! 779: /* Check for pending interrupt with expired latency timer: with ! 780: this, we can limp along even if the interrupt is blocked */ ! 781: if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) { ! 782: if (!info->fast_poll) ! 783: printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name); ! 784: ei_irq_wrapper(dev->irq, dev, NULL); ! 785: info->fast_poll = HZ; ! 786: } ! 787: if (info->fast_poll) { ! 788: info->fast_poll--; ! 789: info->watchdog.expires = jiffies + 1; ! 790: add_timer(&info->watchdog); ! 791: return; ! 792: } ! 793: ! 794: if (info->phy_id < 0) ! 795: goto reschedule; ! 796: link = mdio_read(mii_addr, info->phy_id, 1); ! 797: if (!link || (link == 0xffff)) { ! 798: printk(KERN_INFO "%s: MII is missing!\n", dev->name); ! 799: info->phy_id = -1; ! 800: goto reschedule; ! 801: } ! 802: ! 803: link &= 0x0004; ! 804: if (link != info->link_status) { ! 805: u_short p = mdio_read(mii_addr, info->phy_id, 5); ! 806: printk(KERN_INFO "%s: %s link beat\n", dev->name, ! 807: (link) ? "found" : "lost"); ! 808: if (link) { ! 809: info->duplex_flag = (p & 0x0140) ? 0x80 : 0x00; ! 810: if (p) ! 811: printk(KERN_INFO "%s: autonegotiation complete: " ! 812: "%sbaseT-%cD selected\n", dev->name, ! 813: ((p & 0x0180) ? "100" : "10"), ! 814: ((p & 0x0140) ? 'F' : 'H')); ! 815: else ! 816: printk(KERN_INFO "%s: link partner did not autonegotiate\n", ! 817: dev->name); ! 818: AX88190_init(dev, 1); ! 819: } ! 820: info->link_status = link; ! 821: } ! 822: ! 823: reschedule: ! 824: info->watchdog.expires = jiffies + HZ; ! 825: add_timer(&info->watchdog); ! 826: } ! 827: ! 828: /*====================================================================*/ ! 829: ! 830: static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) ! 831: { ! 832: axnet_dev_t *info = (axnet_dev_t *)dev; ! 833: u16 *data = (u16 *)&rq->ifr_data; ! 834: ioaddr_t mii_addr = dev->base_addr + AXNET_MII_EEP; ! 835: switch (cmd) { ! 836: case SIOCDEVPRIVATE: ! 837: data[0] = info->phy_id; ! 838: case SIOCDEVPRIVATE+1: ! 839: data[3] = mdio_read(mii_addr, data[0], data[1] & 0x1f); ! 840: return 0; ! 841: case SIOCDEVPRIVATE+2: ! 842: if (!capable(CAP_NET_ADMIN)) ! 843: return -EPERM; ! 844: mdio_write(mii_addr, data[0], data[1] & 0x1f, data[2]); ! 845: return 0; ! 846: } ! 847: return -EOPNOTSUPP; ! 848: } ! 849: ! 850: /*====================================================================*/ ! 851: ! 852: static void get_8390_hdr(struct net_device *dev, ! 853: struct e8390_pkt_hdr *hdr, ! 854: int ring_page) ! 855: { ! 856: ioaddr_t nic_base = dev->base_addr; ! 857: ! 858: outb_p(0, nic_base + EN0_RSARLO); /* On page boundary */ ! 859: outb_p(ring_page, nic_base + EN0_RSARHI); ! 860: outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD); ! 861: ! 862: insw(nic_base + AXNET_DATAPORT, hdr, ! 863: sizeof(struct e8390_pkt_hdr)>>1); ! 864: /* Fix for big endian systems */ ! 865: hdr->count = le16_to_cpu(hdr->count); ! 866: ! 867: } ! 868: ! 869: /*====================================================================*/ ! 870: ! 871: static void block_input(struct net_device *dev, int count, ! 872: struct sk_buff *skb, int ring_offset) ! 873: { ! 874: ioaddr_t nic_base = dev->base_addr; ! 875: int xfer_count = count; ! 876: char *buf = skb->data; ! 877: ! 878: #ifdef PCMCIA_DEBUG ! 879: if ((ei_debug > 4) && (count != 4)) ! 880: printk(KERN_DEBUG "%s: [bi=%d]\n", dev->name, count+4); ! 881: #endif ! 882: outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO); ! 883: outb_p(ring_offset >> 8, nic_base + EN0_RSARHI); ! 884: outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD); ! 885: ! 886: insw(nic_base + AXNET_DATAPORT,buf,count>>1); ! 887: if (count & 0x01) ! 888: buf[count-1] = inb(nic_base + AXNET_DATAPORT), xfer_count++; ! 889: ! 890: } ! 891: ! 892: /*====================================================================*/ ! 893: ! 894: static void block_output(struct net_device *dev, int count, ! 895: const u_char *buf, const int start_page) ! 896: { ! 897: ioaddr_t nic_base = dev->base_addr; ! 898: ! 899: #ifdef PCMCIA_DEBUG ! 900: if (ei_debug > 4) ! 901: printk(KERN_DEBUG "%s: [bo=%d]\n", dev->name, count); ! 902: #endif ! 903: ! 904: /* Round the count up for word writes. Do we need to do this? ! 905: What effect will an odd byte count have on the 8390? ! 906: I should check someday. */ ! 907: if (count & 0x01) ! 908: count++; ! 909: ! 910: outb_p(0x00, nic_base + EN0_RSARLO); ! 911: outb_p(start_page, nic_base + EN0_RSARHI); ! 912: outb_p(E8390_RWRITE+E8390_START, nic_base + AXNET_CMD); ! 913: outsw(nic_base + AXNET_DATAPORT, buf, count>>1); ! 914: } ! 915: ! 916: /*====================================================================*/ ! 917: ! 918: static int __init init_axnet_cs(void) ! 919: { ! 920: servinfo_t serv; ! 921: DEBUG(0, "%s\n", version); ! 922: CardServices(GetCardServicesInfo, &serv); ! 923: if (serv.Revision != CS_RELEASE_CODE) { ! 924: printk(KERN_NOTICE "axnet_cs: Card Services release " ! 925: "does not match!\n"); ! 926: return -EINVAL; ! 927: } ! 928: register_pccard_driver(&dev_info, &axnet_attach, &axnet_detach); ! 929: return 0; ! 930: } ! 931: ! 932: static void __exit exit_axnet_cs(void) ! 933: { ! 934: DEBUG(0, "axnet_cs: unloading\n"); ! 935: unregister_pccard_driver(&dev_info); ! 936: while (dev_list != NULL) ! 937: axnet_detach(dev_list); ! 938: } ! 939: ! 940: module_init(init_axnet_cs); ! 941: module_exit(exit_axnet_cs); ! 942: ! 943: /*====================================================================*/ ! 944: ! 945: /* 8390.c: A general NS8390 ethernet driver core for linux. */ ! 946: /* ! 947: Written 1992-94 by Donald Becker. ! 948: ! 949: Copyright 1993 United States Government as represented by the ! 950: Director, National Security Agency. ! 951: ! 952: This software may be used and distributed according to the terms ! 953: of the GNU General Public License, incorporated herein by reference. ! 954: ! 955: The author may be reached as [email protected], or C/O ! 956: Scyld Computing Corporation ! 957: 410 Severn Ave., Suite 210 ! 958: Annapolis MD 21403 ! 959: ! 960: This is the chip-specific code for many 8390-based ethernet adaptors. ! 961: This is not a complete driver, it must be combined with board-specific ! 962: code such as ne.c, wd.c, 3c503.c, etc. ! 963: ! 964: Seeing how at least eight drivers use this code, (not counting the ! 965: PCMCIA ones either) it is easy to break some card by what seems like ! 966: a simple innocent change. Please contact me or Donald if you think ! 967: you have found something that needs changing. -- PG ! 968: ! 969: Changelog: ! 970: ! 971: Paul Gortmaker : remove set_bit lock, other cleanups. ! 972: Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to ! 973: ei_block_input() for eth_io_copy_and_sum(). ! 974: Paul Gortmaker : exchange static int ei_pingpong for a #define, ! 975: also add better Tx error handling. ! 976: Paul Gortmaker : rewrite Rx overrun handling as per NS specs. ! 977: Alexey Kuznetsov : use the 8390's six bit hash multicast filter. ! 978: Paul Gortmaker : tweak ANK's above multicast changes a bit. ! 979: Paul Gortmaker : update packet statistics for v2.1.x ! 980: Alan Cox : support arbitary stupid port mappings on the ! 981: 68K Macintosh. Support >16bit I/O spaces ! 982: Paul Gortmaker : add kmod support for auto-loading of the 8390 ! 983: module by all drivers that require it. ! 984: Alan Cox : Spinlocking work, added 'BUG_83C690' ! 985: Paul Gortmaker : Separate out Tx timeout code from Tx path. ! 986: ! 987: Sources: ! 988: The National Semiconductor LAN Databook, and the 3Com 3c503 databook. ! 989: ! 990: */ ! 991: ! 992: static const char *version_8390 = ! 993: "8390.c:v1.10cvs 9/23/94 Donald Becker ([email protected])\n"; ! 994: ! 995: #include <asm/uaccess.h> ! 996: #include <asm/bitops.h> ! 997: #include <asm/irq.h> ! 998: #include <linux/fcntl.h> ! 999: #include <linux/in.h> ! 1000: #include <linux/interrupt.h> ! 1001: ! 1002: #include <linux/etherdevice.h> ! 1003: ! 1004: #define BUG_83C690 ! 1005: ! 1006: /* These are the operational function interfaces to board-specific ! 1007: routines. ! 1008: void reset_8390(struct net_device *dev) ! 1009: Resets the board associated with DEV, including a hardware reset of ! 1010: the 8390. This is only called when there is a transmit timeout, and ! 1011: it is always followed by 8390_init(). ! 1012: void block_output(struct net_device *dev, int count, const unsigned char *buf, ! 1013: int start_page) ! 1014: Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The ! 1015: "page" value uses the 8390's 256-byte pages. ! 1016: void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page) ! 1017: Read the 4 byte, page aligned 8390 header. *If* there is a ! 1018: subsequent read, it will be of the rest of the packet. ! 1019: void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) ! 1020: Read COUNT bytes from the packet buffer into the skb data area. Start ! 1021: reading from RING_OFFSET, the address as the 8390 sees it. This will always ! 1022: follow the read of the 8390 header. ! 1023: */ ! 1024: #define ei_reset_8390 (ei_local->reset_8390) ! 1025: #define ei_block_output (ei_local->block_output) ! 1026: #define ei_block_input (ei_local->block_input) ! 1027: #define ei_get_8390_hdr (ei_local->get_8390_hdr) ! 1028: ! 1029: /* use 0 for production, 1 for verification, >2 for debug */ ! 1030: #ifndef ei_debug ! 1031: int ei_debug = 1; ! 1032: #endif ! 1033: ! 1034: /* Index to functions. */ ! 1035: static void ei_tx_intr(struct net_device *dev); ! 1036: static void ei_tx_err(struct net_device *dev); ! 1037: static void ei_tx_timeout(struct net_device *dev); ! 1038: static void ei_receive(struct net_device *dev); ! 1039: static void ei_rx_overrun(struct net_device *dev); ! 1040: ! 1041: /* Routines generic to NS8390-based boards. */ ! 1042: static void NS8390_trigger_send(struct net_device *dev, unsigned int length, ! 1043: int start_page); ! 1044: static void set_multicast_list(struct net_device *dev); ! 1045: static void do_set_multicast_list(struct net_device *dev); ! 1046: ! 1047: /* ! 1048: * SMP and the 8390 setup. ! 1049: * ! 1050: * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is ! 1051: * a page register that controls bank and packet buffer access. We guard ! 1052: * this with ei_local->page_lock. Nobody should assume or set the page other ! 1053: * than zero when the lock is not held. Lock holders must restore page 0 ! 1054: * before unlocking. Even pure readers must take the lock to protect in ! 1055: * page 0. ! 1056: * ! 1057: * To make life difficult the chip can also be very slow. We therefore can't ! 1058: * just use spinlocks. For the longer lockups we disable the irq the device ! 1059: * sits on and hold the lock. We must hold the lock because there is a dual ! 1060: * processor case other than interrupts (get stats/set multicast list in ! 1061: * parallel with each other and transmit). ! 1062: * ! 1063: * Note: in theory we can just disable the irq on the card _but_ there is ! 1064: * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs" ! 1065: * enter lock, take the queued irq. So we waddle instead of flying. ! 1066: * ! 1067: * Finally by special arrangement for the purpose of being generally ! 1068: * annoying the transmit function is called bh atomic. That places ! 1069: * restrictions on the user context callers as disable_irq won't save ! 1070: * them. ! 1071: */ ! 1072: ! 1073: /** ! 1074: * ax_open - Open/initialize the board. ! 1075: * @dev: network device to initialize ! 1076: * ! 1077: * This routine goes all-out, setting everything ! 1078: * up anew at each open, even though many of these registers should only ! 1079: * need to be set once at boot. ! 1080: */ ! 1081: static int ax_open(struct net_device *dev) ! 1082: { ! 1083: unsigned long flags; ! 1084: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1085: ! 1086: /* This can't happen unless somebody forgot to call axdev_init(). */ ! 1087: if (ei_local == NULL) ! 1088: { ! 1089: printk(KERN_EMERG "%s: ax_open passed a non-existent device!\n", dev->name); ! 1090: return -ENXIO; ! 1091: } ! 1092: ! 1093: #ifdef HAVE_TX_TIMEOUT ! 1094: /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout ! 1095: wrapper that does e.g. media check & then calls ei_tx_timeout. */ ! 1096: if (dev->tx_timeout == NULL) ! 1097: dev->tx_timeout = ei_tx_timeout; ! 1098: if (dev->watchdog_timeo <= 0) ! 1099: dev->watchdog_timeo = TX_TIMEOUT; ! 1100: #endif ! 1101: ! 1102: /* ! 1103: * Grab the page lock so we own the register set, then call ! 1104: * the init function. ! 1105: */ ! 1106: ! 1107: spin_lock_irqsave(&ei_local->page_lock, flags); ! 1108: AX88190_init(dev, 1); ! 1109: /* Set the flag before we drop the lock, That way the IRQ arrives ! 1110: after its set and we get no silly warnings */ ! 1111: netif_mark_up(dev); ! 1112: netif_start_queue(dev); ! 1113: spin_unlock_irqrestore(&ei_local->page_lock, flags); ! 1114: ei_local->irqlock = 0; ! 1115: return 0; ! 1116: } ! 1117: ! 1118: #define dev_lock(dev) (((struct ei_device *)(dev)->priv)->page_lock) ! 1119: ! 1120: /** ! 1121: * ax_close - shut down network device ! 1122: * @dev: network device to close ! 1123: * ! 1124: * Opposite of ax_open(). Only used when "ifconfig <devname> down" is done. ! 1125: */ ! 1126: int ax_close(struct net_device *dev) ! 1127: { ! 1128: unsigned long flags; ! 1129: ! 1130: /* ! 1131: * Hold the page lock during close ! 1132: */ ! 1133: ! 1134: spin_lock_irqsave(&dev_lock(dev), flags); ! 1135: AX88190_init(dev, 0); ! 1136: spin_unlock_irqrestore(&dev_lock(dev), flags); ! 1137: netif_stop_queue(dev); ! 1138: return 0; ! 1139: } ! 1140: ! 1141: /** ! 1142: * ei_tx_timeout - handle transmit time out condition ! 1143: * @dev: network device which has apparently fallen asleep ! 1144: * ! 1145: * Called by kernel when device never acknowledges a transmit has ! 1146: * completed (or failed) - i.e. never posted a Tx related interrupt. ! 1147: */ ! 1148: ! 1149: void ei_tx_timeout(struct net_device *dev) ! 1150: { ! 1151: long e8390_base = dev->base_addr; ! 1152: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1153: int txsr, isr, tickssofar = jiffies - dev->trans_start; ! 1154: unsigned long flags; ! 1155: ! 1156: ei_local->stat.tx_errors++; ! 1157: ! 1158: spin_lock_irqsave(&ei_local->page_lock, flags); ! 1159: txsr = inb(e8390_base+EN0_TSR); ! 1160: isr = inb(e8390_base+EN0_ISR); ! 1161: spin_unlock_irqrestore(&ei_local->page_lock, flags); ! 1162: ! 1163: printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n", ! 1164: dev->name, (txsr & ENTSR_ABT) ? "excess collisions." : ! 1165: (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar); ! 1166: ! 1167: if (!isr && !ei_local->stat.tx_packets) ! 1168: { ! 1169: /* The 8390 probably hasn't gotten on the cable yet. */ ! 1170: ei_local->interface_num ^= 1; /* Try a different xcvr. */ ! 1171: } ! 1172: ! 1173: /* Ugly but a reset can be slow, yet must be protected */ ! 1174: ! 1175: disable_irq_nosync(dev->irq); ! 1176: spin_lock(&ei_local->page_lock); ! 1177: ! 1178: /* Try to restart the card. Perhaps the user has fixed something. */ ! 1179: ei_reset_8390(dev); ! 1180: AX88190_init(dev, 1); ! 1181: ! 1182: spin_unlock(&ei_local->page_lock); ! 1183: enable_irq(dev->irq); ! 1184: netif_wake_queue(dev); ! 1185: } ! 1186: ! 1187: /** ! 1188: * ei_start_xmit - begin packet transmission ! 1189: * @skb: packet to be sent ! 1190: * @dev: network device to which packet is sent ! 1191: * ! 1192: * Sends a packet to an 8390 network device. ! 1193: */ ! 1194: ! 1195: static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev) ! 1196: { ! 1197: long e8390_base = dev->base_addr; ! 1198: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1199: int length, send_length, output_page; ! 1200: unsigned long flags; ! 1201: ! 1202: tx_timeout_check(dev, ei_tx_timeout); ! 1203: skb_tx_check(dev, skb); ! 1204: ! 1205: length = skb->len; ! 1206: ! 1207: /* Mask interrupts from the ethercard. ! 1208: SMP: We have to grab the lock here otherwise the IRQ handler ! 1209: on another CPU can flip window and race the IRQ mask set. We end ! 1210: up trashing the mcast filter not disabling irqs if we dont lock */ ! 1211: ! 1212: spin_lock_irqsave(&ei_local->page_lock, flags); ! 1213: outb_p(0x00, e8390_base + EN0_IMR); ! 1214: spin_unlock_irqrestore(&ei_local->page_lock, flags); ! 1215: ! 1216: /* ! 1217: * Slow phase with lock held. ! 1218: */ ! 1219: ! 1220: disable_irq_nosync(dev->irq); ! 1221: ! 1222: spin_lock(&ei_local->page_lock); ! 1223: ! 1224: ei_local->irqlock = 1; ! 1225: ! 1226: send_length = ETH_ZLEN < length ? length : ETH_ZLEN; ! 1227: ! 1228: /* ! 1229: * We have two Tx slots available for use. Find the first free ! 1230: * slot, and then perform some sanity checks. With two Tx bufs, ! 1231: * you get very close to transmitting back-to-back packets. With ! 1232: * only one Tx buf, the transmitter sits idle while you reload the ! 1233: * card, leaving a substantial gap between each transmitted packet. ! 1234: */ ! 1235: ! 1236: if (ei_local->tx1 == 0) ! 1237: { ! 1238: output_page = ei_local->tx_start_page; ! 1239: ei_local->tx1 = send_length; ! 1240: if (ei_debug && ei_local->tx2 > 0) ! 1241: printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n", ! 1242: dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing); ! 1243: } ! 1244: else if (ei_local->tx2 == 0) ! 1245: { ! 1246: output_page = ei_local->tx_start_page + TX_1X_PAGES; ! 1247: ei_local->tx2 = send_length; ! 1248: if (ei_debug && ei_local->tx1 > 0) ! 1249: printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n", ! 1250: dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing); ! 1251: } ! 1252: else ! 1253: { /* We should never get here. */ ! 1254: if (ei_debug) ! 1255: printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n", ! 1256: dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx); ! 1257: ei_local->irqlock = 0; ! 1258: netif_stop_queue(dev); ! 1259: outb_p(ENISR_ALL, e8390_base + EN0_IMR); ! 1260: spin_unlock(&ei_local->page_lock); ! 1261: enable_irq(dev->irq); ! 1262: ei_local->stat.tx_errors++; ! 1263: return 1; ! 1264: } ! 1265: ! 1266: /* ! 1267: * Okay, now upload the packet and trigger a send if the transmitter ! 1268: * isn't already sending. If it is busy, the interrupt handler will ! 1269: * trigger the send later, upon receiving a Tx done interrupt. ! 1270: */ ! 1271: ! 1272: ei_block_output(dev, length, skb->data, output_page); ! 1273: if (! ei_local->txing) ! 1274: { ! 1275: ei_local->txing = 1; ! 1276: NS8390_trigger_send(dev, send_length, output_page); ! 1277: dev->trans_start = jiffies; ! 1278: if (output_page == ei_local->tx_start_page) ! 1279: { ! 1280: ei_local->tx1 = -1; ! 1281: ei_local->lasttx = -1; ! 1282: } ! 1283: else ! 1284: { ! 1285: ei_local->tx2 = -1; ! 1286: ei_local->lasttx = -2; ! 1287: } ! 1288: } ! 1289: else ei_local->txqueue++; ! 1290: ! 1291: if (ei_local->tx1 && ei_local->tx2) ! 1292: netif_stop_queue(dev); ! 1293: else ! 1294: netif_start_queue(dev); ! 1295: ! 1296: /* Turn 8390 interrupts back on. */ ! 1297: ei_local->irqlock = 0; ! 1298: outb_p(ENISR_ALL, e8390_base + EN0_IMR); ! 1299: ! 1300: spin_unlock(&ei_local->page_lock); ! 1301: enable_irq(dev->irq); ! 1302: ! 1303: DEV_KFREE_SKB (skb); ! 1304: add_tx_bytes(&ei_local->stat, send_length); ! 1305: ! 1306: return 0; ! 1307: } ! 1308: ! 1309: /** ! 1310: * ax_interrupt - handle the interrupts from an 8390 ! 1311: * @irq: interrupt number ! 1312: * @dev_id: a pointer to the net_device ! 1313: * @regs: unused ! 1314: * ! 1315: * Handle the ether interface interrupts. We pull packets from ! 1316: * the 8390 via the card specific functions and fire them at the networking ! 1317: * stack. We also handle transmit completions and wake the transmit path if ! 1318: * neccessary. We also update the counters and do other housekeeping as ! 1319: * needed. ! 1320: */ ! 1321: ! 1322: static void ax_interrupt(int irq, void *dev_id, struct pt_regs * regs) ! 1323: { ! 1324: struct net_device *dev = dev_id; ! 1325: long e8390_base; ! 1326: int interrupts, nr_serviced = 0, i; ! 1327: struct ei_device *ei_local; ! 1328: ! 1329: if (dev == NULL) ! 1330: { ! 1331: printk ("net_interrupt(): irq %d for unknown device.\n", irq); ! 1332: return; ! 1333: } ! 1334: ! 1335: e8390_base = dev->base_addr; ! 1336: ei_local = (struct ei_device *) dev->priv; ! 1337: ! 1338: /* ! 1339: * Protect the irq test too. ! 1340: */ ! 1341: ! 1342: spin_lock(&ei_local->page_lock); ! 1343: ! 1344: if (ei_local->irqlock) ! 1345: { ! 1346: #if 1 /* This might just be an interrupt for a PCI device sharing this line */ ! 1347: /* The "irqlock" check is only for testing. */ ! 1348: printk(ei_local->irqlock ! 1349: ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n" ! 1350: : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n", ! 1351: dev->name, inb_p(e8390_base + EN0_ISR), ! 1352: inb_p(e8390_base + EN0_IMR)); ! 1353: #endif ! 1354: spin_unlock(&ei_local->page_lock); ! 1355: return; ! 1356: } ! 1357: ! 1358: if (ei_debug > 3) ! 1359: printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name, ! 1360: inb_p(e8390_base + EN0_ISR)); ! 1361: ! 1362: outb_p(0x00, e8390_base + EN0_ISR); ! 1363: ei_local->irqlock = 1; ! 1364: ! 1365: /* !!Assumption!! -- we stay in page 0. Don't break this. */ ! 1366: while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0 ! 1367: && ++nr_serviced < MAX_SERVICE) ! 1368: { ! 1369: if (!netif_running(dev) || (interrupts == 0xff)) { ! 1370: if (ei_debug > 1) ! 1371: printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name); ! 1372: outb_p(interrupts, e8390_base + EN0_ISR); ! 1373: interrupts = 0; ! 1374: break; ! 1375: } ! 1376: /* AX88190 bug fix. */ ! 1377: outb_p(interrupts, e8390_base + EN0_ISR); ! 1378: for (i = 0; i < 10; i++) { ! 1379: if (!(inb(e8390_base + EN0_ISR) & interrupts)) ! 1380: break; ! 1381: outb_p(0, e8390_base + EN0_ISR); ! 1382: outb_p(interrupts, e8390_base + EN0_ISR); ! 1383: } ! 1384: if (interrupts & ENISR_OVER) ! 1385: ei_rx_overrun(dev); ! 1386: else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) ! 1387: { ! 1388: /* Got a good (?) packet. */ ! 1389: ei_receive(dev); ! 1390: } ! 1391: /* Push the next to-transmit packet through. */ ! 1392: if (interrupts & ENISR_TX) ! 1393: ei_tx_intr(dev); ! 1394: else if (interrupts & ENISR_TX_ERR) ! 1395: ei_tx_err(dev); ! 1396: ! 1397: if (interrupts & ENISR_COUNTERS) ! 1398: { ! 1399: ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0); ! 1400: ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1); ! 1401: ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2); ! 1402: } ! 1403: } ! 1404: ! 1405: if (interrupts && ei_debug) ! 1406: { ! 1407: if (nr_serviced >= MAX_SERVICE) ! 1408: { ! 1409: /* 0xFF is valid for a card removal */ ! 1410: if(interrupts!=0xFF) ! 1411: printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n", ! 1412: dev->name, interrupts); ! 1413: outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */ ! 1414: } else { ! 1415: printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts); ! 1416: outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */ ! 1417: } ! 1418: } ! 1419: ! 1420: /* Turn 8390 interrupts back on. */ ! 1421: ei_local->irqlock = 0; ! 1422: outb_p(ENISR_ALL, e8390_base + EN0_IMR); ! 1423: ! 1424: spin_unlock(&ei_local->page_lock); ! 1425: return; ! 1426: } ! 1427: ! 1428: /** ! 1429: * ei_tx_err - handle transmitter error ! 1430: * @dev: network device which threw the exception ! 1431: * ! 1432: * A transmitter error has happened. Most likely excess collisions (which ! 1433: * is a fairly normal condition). If the error is one where the Tx will ! 1434: * have been aborted, we try and send another one right away, instead of ! 1435: * letting the failed packet sit and collect dust in the Tx buffer. This ! 1436: * is a much better solution as it avoids kernel based Tx timeouts, and ! 1437: * an unnecessary card reset. ! 1438: * ! 1439: * Called with lock held. ! 1440: */ ! 1441: ! 1442: static void ei_tx_err(struct net_device *dev) ! 1443: { ! 1444: long e8390_base = dev->base_addr; ! 1445: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1446: unsigned char txsr = inb_p(e8390_base+EN0_TSR); ! 1447: unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU); ! 1448: ! 1449: #ifdef VERBOSE_ERROR_DUMP ! 1450: printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr); ! 1451: if (txsr & ENTSR_ABT) ! 1452: printk("excess-collisions "); ! 1453: if (txsr & ENTSR_ND) ! 1454: printk("non-deferral "); ! 1455: if (txsr & ENTSR_CRS) ! 1456: printk("lost-carrier "); ! 1457: if (txsr & ENTSR_FU) ! 1458: printk("FIFO-underrun "); ! 1459: if (txsr & ENTSR_CDH) ! 1460: printk("lost-heartbeat "); ! 1461: printk("\n"); ! 1462: #endif ! 1463: ! 1464: if (tx_was_aborted) ! 1465: ei_tx_intr(dev); ! 1466: else ! 1467: { ! 1468: ei_local->stat.tx_errors++; ! 1469: if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++; ! 1470: if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++; ! 1471: if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++; ! 1472: } ! 1473: } ! 1474: ! 1475: /** ! 1476: * ei_tx_intr - transmit interrupt handler ! 1477: * @dev: network device for which tx intr is handled ! 1478: * ! 1479: * We have finished a transmit: check for errors and then trigger the next ! 1480: * packet to be sent. Called with lock held. ! 1481: */ ! 1482: ! 1483: static void ei_tx_intr(struct net_device *dev) ! 1484: { ! 1485: long e8390_base = dev->base_addr; ! 1486: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1487: int status = inb(e8390_base + EN0_TSR); ! 1488: ! 1489: /* ! 1490: * There are two Tx buffers, see which one finished, and trigger ! 1491: * the send of another one if it exists. ! 1492: */ ! 1493: ei_local->txqueue--; ! 1494: ! 1495: if (ei_local->tx1 < 0) ! 1496: { ! 1497: if (ei_local->lasttx != 1 && ei_local->lasttx != -1) ! 1498: printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n", ! 1499: ei_local->name, ei_local->lasttx, ei_local->tx1); ! 1500: ei_local->tx1 = 0; ! 1501: if (ei_local->tx2 > 0) ! 1502: { ! 1503: ei_local->txing = 1; ! 1504: NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6); ! 1505: dev->trans_start = jiffies; ! 1506: ei_local->tx2 = -1, ! 1507: ei_local->lasttx = 2; ! 1508: } ! 1509: else ei_local->lasttx = 20, ei_local->txing = 0; ! 1510: } ! 1511: else if (ei_local->tx2 < 0) ! 1512: { ! 1513: if (ei_local->lasttx != 2 && ei_local->lasttx != -2) ! 1514: printk("%s: bogus last_tx_buffer %d, tx2=%d.\n", ! 1515: ei_local->name, ei_local->lasttx, ei_local->tx2); ! 1516: ei_local->tx2 = 0; ! 1517: if (ei_local->tx1 > 0) ! 1518: { ! 1519: ei_local->txing = 1; ! 1520: NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page); ! 1521: dev->trans_start = jiffies; ! 1522: ei_local->tx1 = -1; ! 1523: ei_local->lasttx = 1; ! 1524: } ! 1525: else ! 1526: ei_local->lasttx = 10, ei_local->txing = 0; ! 1527: } ! 1528: // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n", ! 1529: // dev->name, ei_local->lasttx); ! 1530: ! 1531: /* Minimize Tx latency: update the statistics after we restart TXing. */ ! 1532: if (status & ENTSR_COL) ! 1533: ei_local->stat.collisions++; ! 1534: if (status & ENTSR_PTX) ! 1535: ei_local->stat.tx_packets++; ! 1536: else ! 1537: { ! 1538: ei_local->stat.tx_errors++; ! 1539: if (status & ENTSR_ABT) ! 1540: { ! 1541: ei_local->stat.tx_aborted_errors++; ! 1542: ei_local->stat.collisions += 16; ! 1543: } ! 1544: if (status & ENTSR_CRS) ! 1545: ei_local->stat.tx_carrier_errors++; ! 1546: if (status & ENTSR_FU) ! 1547: ei_local->stat.tx_fifo_errors++; ! 1548: if (status & ENTSR_CDH) ! 1549: ei_local->stat.tx_heartbeat_errors++; ! 1550: if (status & ENTSR_OWC) ! 1551: ei_local->stat.tx_window_errors++; ! 1552: } ! 1553: netif_wake_queue(dev); ! 1554: } ! 1555: ! 1556: /** ! 1557: * ei_receive - receive some packets ! 1558: * @dev: network device with which receive will be run ! 1559: * ! 1560: * We have a good packet(s), get it/them out of the buffers. ! 1561: * Called with lock held. ! 1562: */ ! 1563: ! 1564: static void ei_receive(struct net_device *dev) ! 1565: { ! 1566: long e8390_base = dev->base_addr; ! 1567: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1568: unsigned char rxing_page, this_frame, next_frame; ! 1569: unsigned short current_offset; ! 1570: int rx_pkt_count = 0; ! 1571: struct e8390_pkt_hdr rx_frame; ! 1572: ! 1573: while (++rx_pkt_count < 10) ! 1574: { ! 1575: int pkt_len, pkt_stat; ! 1576: ! 1577: /* Get the rx page (incoming packet pointer). */ ! 1578: rxing_page = inb_p(e8390_base + EN1_CURPAG -1); ! 1579: ! 1580: /* Remove one frame from the ring. Boundary is always a page behind. */ ! 1581: this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1; ! 1582: if (this_frame >= ei_local->stop_page) ! 1583: this_frame = ei_local->rx_start_page; ! 1584: ! 1585: /* Someday we'll omit the previous, iff we never get this message. ! 1586: (There is at least one clone claimed to have a problem.) ! 1587: ! 1588: Keep quiet if it looks like a card removal. One problem here ! 1589: is that some clones crash in roughly the same way. ! 1590: */ ! 1591: if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF)) ! 1592: printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n", ! 1593: dev->name, this_frame, ei_local->current_page); ! 1594: ! 1595: if (this_frame == rxing_page) /* Read all the frames? */ ! 1596: break; /* Done for now */ ! 1597: ! 1598: current_offset = this_frame << 8; ! 1599: ei_get_8390_hdr(dev, &rx_frame, this_frame); ! 1600: ! 1601: pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr); ! 1602: pkt_stat = rx_frame.status; ! 1603: ! 1604: next_frame = this_frame + 1 + ((pkt_len+4)>>8); ! 1605: ! 1606: if (pkt_len < 60 || pkt_len > 1518) ! 1607: { ! 1608: if (ei_debug) ! 1609: printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n", ! 1610: dev->name, rx_frame.count, rx_frame.status, ! 1611: rx_frame.next); ! 1612: ei_local->stat.rx_errors++; ! 1613: ei_local->stat.rx_length_errors++; ! 1614: } ! 1615: else if ((pkt_stat & 0x0F) == ENRSR_RXOK) ! 1616: { ! 1617: struct sk_buff *skb; ! 1618: ! 1619: skb = dev_alloc_skb(pkt_len+2); ! 1620: if (skb == NULL) ! 1621: { ! 1622: if (ei_debug > 1) ! 1623: printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n", ! 1624: dev->name, pkt_len); ! 1625: ei_local->stat.rx_dropped++; ! 1626: break; ! 1627: } ! 1628: else ! 1629: { ! 1630: skb_reserve(skb,2); /* IP headers on 16 byte boundaries */ ! 1631: skb->dev = dev; ! 1632: skb_put(skb, pkt_len); /* Make room */ ! 1633: ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame)); ! 1634: skb->protocol=eth_type_trans(skb,dev); ! 1635: netif_rx(skb); ! 1636: dev->last_rx = jiffies; ! 1637: ei_local->stat.rx_packets++; ! 1638: add_rx_bytes(&ei_local->stat, pkt_len); ! 1639: if (pkt_stat & ENRSR_PHY) ! 1640: ei_local->stat.multicast++; ! 1641: } ! 1642: } ! 1643: else ! 1644: { ! 1645: if (ei_debug) ! 1646: printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n", ! 1647: dev->name, rx_frame.status, rx_frame.next, ! 1648: rx_frame.count); ! 1649: ei_local->stat.rx_errors++; ! 1650: /* NB: The NIC counts CRC, frame and missed errors. */ ! 1651: if (pkt_stat & ENRSR_FO) ! 1652: ei_local->stat.rx_fifo_errors++; ! 1653: } ! 1654: next_frame = rx_frame.next; ! 1655: ! 1656: /* This _should_ never happen: it's here for avoiding bad clones. */ ! 1657: if (next_frame >= ei_local->stop_page) { ! 1658: printk("%s: next frame inconsistency, %#2x\n", dev->name, ! 1659: next_frame); ! 1660: next_frame = ei_local->rx_start_page; ! 1661: } ! 1662: ei_local->current_page = next_frame; ! 1663: outb_p(next_frame-1, e8390_base+EN0_BOUNDARY); ! 1664: } ! 1665: ! 1666: return; ! 1667: } ! 1668: ! 1669: /** ! 1670: * ei_rx_overrun - handle receiver overrun ! 1671: * @dev: network device which threw exception ! 1672: * ! 1673: * We have a receiver overrun: we have to kick the 8390 to get it started ! 1674: * again. Problem is that you have to kick it exactly as NS prescribes in ! 1675: * the updated datasheets, or "the NIC may act in an unpredictable manner." ! 1676: * This includes causing "the NIC to defer indefinitely when it is stopped ! 1677: * on a busy network." Ugh. ! 1678: * Called with lock held. Don't call this with the interrupts off or your ! 1679: * computer will hate you - it takes 10ms or so. ! 1680: */ ! 1681: ! 1682: static void ei_rx_overrun(struct net_device *dev) ! 1683: { ! 1684: axnet_dev_t *info = (axnet_dev_t *)dev; ! 1685: long e8390_base = dev->base_addr; ! 1686: unsigned char was_txing, must_resend = 0; ! 1687: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1688: ! 1689: /* ! 1690: * Record whether a Tx was in progress and then issue the ! 1691: * stop command. ! 1692: */ ! 1693: was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS; ! 1694: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); ! 1695: ! 1696: if (ei_debug > 1) ! 1697: printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name); ! 1698: ei_local->stat.rx_over_errors++; ! 1699: ! 1700: /* ! 1701: * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total. ! 1702: * Early datasheets said to poll the reset bit, but now they say that ! 1703: * it "is not a reliable indicator and subsequently should be ignored." ! 1704: * We wait at least 10ms. ! 1705: */ ! 1706: ! 1707: mdelay(10); ! 1708: ! 1709: /* ! 1710: * Reset RBCR[01] back to zero as per magic incantation. ! 1711: */ ! 1712: outb_p(0x00, e8390_base+EN0_RCNTLO); ! 1713: outb_p(0x00, e8390_base+EN0_RCNTHI); ! 1714: ! 1715: /* ! 1716: * See if any Tx was interrupted or not. According to NS, this ! 1717: * step is vital, and skipping it will cause no end of havoc. ! 1718: */ ! 1719: ! 1720: if (was_txing) ! 1721: { ! 1722: unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR); ! 1723: if (!tx_completed) ! 1724: must_resend = 1; ! 1725: } ! 1726: ! 1727: /* ! 1728: * Have to enter loopback mode and then restart the NIC before ! 1729: * you are allowed to slurp packets up off the ring. ! 1730: */ ! 1731: outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); ! 1732: outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD); ! 1733: ! 1734: /* ! 1735: * Clear the Rx ring of all the debris, and ack the interrupt. ! 1736: */ ! 1737: ei_receive(dev); ! 1738: ! 1739: /* ! 1740: * Leave loopback mode, and resend any packet that got stopped. ! 1741: */ ! 1742: outb_p(E8390_TXCONFIG | info->duplex_flag, e8390_base + EN0_TXCR); ! 1743: if (must_resend) ! 1744: outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD); ! 1745: } ! 1746: ! 1747: /* ! 1748: * Collect the stats. This is called unlocked and from several contexts. ! 1749: */ ! 1750: ! 1751: static struct net_device_stats *get_stats(struct net_device *dev) ! 1752: { ! 1753: long ioaddr = dev->base_addr; ! 1754: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1755: unsigned long flags; ! 1756: ! 1757: /* If the card is stopped, just return the present stats. */ ! 1758: if (!netif_running(dev)) ! 1759: return &ei_local->stat; ! 1760: ! 1761: spin_lock_irqsave(&ei_local->page_lock,flags); ! 1762: /* Read the counter registers, assuming we are in page 0. */ ! 1763: ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0); ! 1764: ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1); ! 1765: ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2); ! 1766: spin_unlock_irqrestore(&ei_local->page_lock, flags); ! 1767: ! 1768: return &ei_local->stat; ! 1769: } ! 1770: ! 1771: /** ! 1772: * do_set_multicast_list - set/clear multicast filter ! 1773: * @dev: net device for which multicast filter is adjusted ! 1774: * ! 1775: * Set or clear the multicast filter for this adaptor. May be called ! 1776: * from a BH in 2.1.x. Must be called with lock held. ! 1777: */ ! 1778: ! 1779: static void do_set_multicast_list(struct net_device *dev) ! 1780: { ! 1781: long e8390_base = dev->base_addr; ! 1782: ! 1783: if(dev->flags&IFF_PROMISC) ! 1784: outb_p(E8390_RXCONFIG | 0x58, e8390_base + EN0_RXCR); ! 1785: else if(dev->flags&IFF_ALLMULTI || dev->mc_list) ! 1786: outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR); ! 1787: else ! 1788: outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR); ! 1789: } ! 1790: ! 1791: /* ! 1792: * Called without lock held. This is invoked from user context and may ! 1793: * be parallel to just about everything else. Its also fairly quick and ! 1794: * not called too often. Must protect against both bh and irq users ! 1795: */ ! 1796: ! 1797: static void set_multicast_list(struct net_device *dev) ! 1798: { ! 1799: unsigned long flags; ! 1800: ! 1801: spin_lock_irqsave(&dev_lock(dev), flags); ! 1802: do_set_multicast_list(dev); ! 1803: spin_unlock_irqrestore(&dev_lock(dev), flags); ! 1804: } ! 1805: ! 1806: /** ! 1807: * axdev_init - init rest of 8390 device struct ! 1808: * @dev: network device structure to init ! 1809: * ! 1810: * Initialize the rest of the 8390 device structure. Do NOT __init ! 1811: * this, as it is used by 8390 based modular drivers too. ! 1812: */ ! 1813: ! 1814: static int axdev_init(struct net_device *dev) ! 1815: { ! 1816: if (ei_debug > 1) ! 1817: printk(version_8390); ! 1818: ! 1819: if (dev->priv == NULL) ! 1820: { ! 1821: struct ei_device *ei_local; ! 1822: ! 1823: dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL); ! 1824: if (dev->priv == NULL) ! 1825: return -ENOMEM; ! 1826: memset(dev->priv, 0, sizeof(struct ei_device)); ! 1827: ei_local = (struct ei_device *)dev->priv; ! 1828: spin_lock_init(&ei_local->page_lock); ! 1829: } ! 1830: ! 1831: dev->hard_start_xmit = &ei_start_xmit; ! 1832: dev->get_stats = get_stats; ! 1833: dev->set_multicast_list = &set_multicast_list; ! 1834: ! 1835: ether_setup(dev); ! 1836: ! 1837: return 0; ! 1838: } ! 1839: ! 1840: /* This page of functions should be 8390 generic */ ! 1841: /* Follow National Semi's recommendations for initializing the "NIC". */ ! 1842: ! 1843: /** ! 1844: * AX88190_init - initialize 8390 hardware ! 1845: * @dev: network device to initialize ! 1846: * @startp: boolean. non-zero value to initiate chip processing ! 1847: * ! 1848: * Must be called with lock held. ! 1849: */ ! 1850: ! 1851: static void AX88190_init(struct net_device *dev, int startp) ! 1852: { ! 1853: axnet_dev_t *info = (axnet_dev_t *)dev; ! 1854: long e8390_base = dev->base_addr; ! 1855: struct ei_device *ei_local = (struct ei_device *) dev->priv; ! 1856: int i; ! 1857: int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48; ! 1858: ! 1859: if(sizeof(struct e8390_pkt_hdr)!=4) ! 1860: panic("8390.c: header struct mispacked\n"); ! 1861: /* Follow National Semi's recommendations for initing the DP83902. */ ! 1862: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */ ! 1863: outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */ ! 1864: /* Clear the remote byte count registers. */ ! 1865: outb_p(0x00, e8390_base + EN0_RCNTLO); ! 1866: outb_p(0x00, e8390_base + EN0_RCNTHI); ! 1867: /* Set to monitor and loopback mode -- this is vital!. */ ! 1868: outb_p(E8390_RXOFF|0x40, e8390_base + EN0_RXCR); /* 0x60 */ ! 1869: outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */ ! 1870: /* Set the transmit page and receive ring. */ ! 1871: outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR); ! 1872: ei_local->tx1 = ei_local->tx2 = 0; ! 1873: outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG); ! 1874: outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/ ! 1875: ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */ ! 1876: outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG); ! 1877: /* Clear the pending interrupts and mask. */ ! 1878: outb_p(0xFF, e8390_base + EN0_ISR); ! 1879: outb_p(0x00, e8390_base + EN0_IMR); ! 1880: ! 1881: /* Copy the station address into the DS8390 registers. */ ! 1882: ! 1883: outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */ ! 1884: for(i = 0; i < 6; i++) ! 1885: { ! 1886: outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i)); ! 1887: if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i]) ! 1888: printk(KERN_ERR "Hw. address read/write mismap %d\n",i); ! 1889: } ! 1890: /* ! 1891: * Initialize the multicast list to accept-all. If we enable multicast ! 1892: * the higher levels can do the filtering. ! 1893: */ ! 1894: for (i = 0; i < 8; i++) ! 1895: outb_p(0xff, e8390_base + EN1_MULT + i); ! 1896: ! 1897: outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG); ! 1898: outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); ! 1899: ! 1900: netif_start_queue(dev); ! 1901: ei_local->tx1 = ei_local->tx2 = 0; ! 1902: ei_local->txing = 0; ! 1903: ! 1904: if (startp) ! 1905: { ! 1906: outb_p(0xff, e8390_base + EN0_ISR); ! 1907: outb_p(ENISR_ALL, e8390_base + EN0_IMR); ! 1908: outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD); ! 1909: outb_p(E8390_TXCONFIG | info->duplex_flag, ! 1910: e8390_base + EN0_TXCR); /* xmit on. */ ! 1911: /* 3c503 TechMan says rxconfig only after the NIC is started. */ ! 1912: outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR); /* rx on, */ ! 1913: do_set_multicast_list(dev); /* (re)load the mcast table */ ! 1914: } ! 1915: } ! 1916: ! 1917: /* Trigger a transmit start, assuming the length is valid. ! 1918: Always called with the page lock held */ ! 1919: ! 1920: static void NS8390_trigger_send(struct net_device *dev, unsigned int length, ! 1921: int start_page) ! 1922: { ! 1923: long e8390_base = dev->base_addr; ! 1924: struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) dev->priv; ! 1925: ! 1926: if (inb_p(e8390_base) & E8390_TRANS) ! 1927: { ! 1928: printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n", ! 1929: dev->name); ! 1930: return; ! 1931: } ! 1932: outb_p(length & 0xff, e8390_base + EN0_TCNTLO); ! 1933: outb_p(length >> 8, e8390_base + EN0_TCNTHI); ! 1934: outb_p(start_page, e8390_base + EN0_TPSR); ! 1935: outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD); ! 1936: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.