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