![[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.