Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wd.c
Go to the documentation of this file.
1 /* wd.c: A WD80x3 ethernet driver for linux. */
2 /*
3  Written 1993-94 by Donald Becker.
4 
5  Copyright 1993 United States Government as represented by the
6  Director, National Security Agency.
7 
8  This software may be used and distributed according to the terms
9  of the GNU General Public License, incorporated herein by reference.
10 
11  The author may be reached as [email protected], or C/O
12  Scyld Computing Corporation
13  410 Severn Ave., Suite 210
14  Annapolis MD 21403
15 
16  This is a driver for WD8003 and WD8013 "compatible" ethercards.
17 
18  Thanks to Russ Nelson ([email protected]) for loaning me a WD8013.
19 
20  Changelog:
21 
22  Paul Gortmaker : multiple card support for module users, support
23  for non-standard memory sizes.
24 
25 
26 */
27 
28 static const char version[] =
29  "wd.c:v1.10 9/23/94 Donald Becker ([email protected])\n";
30 
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/string.h>
35 #include <linux/init.h>
36 #include <linux/interrupt.h>
37 #include <linux/delay.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 
41 #include <asm/io.h>
42 
43 #include "8390.h"
44 
45 #define DRV_NAME "wd"
46 
47 /* A zero-terminated list of I/O addresses to be probed. */
48 static unsigned int wd_portlist[] __initdata =
49 {0x300, 0x280, 0x380, 0x240, 0};
50 
51 static int wd_probe1(struct net_device *dev, int ioaddr);
52 
53 static int wd_open(struct net_device *dev);
54 static void wd_reset_8390(struct net_device *dev);
55 static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
56  int ring_page);
57 static void wd_block_input(struct net_device *dev, int count,
58  struct sk_buff *skb, int ring_offset);
59 static void wd_block_output(struct net_device *dev, int count,
60  const unsigned char *buf, int start_page);
61 static int wd_close(struct net_device *dev);
62 
63 
64 #define WD_START_PG 0x00 /* First page of TX buffer */
65 #define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */
66 #define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */
67 
68 #define WD_CMDREG 0 /* Offset to ASIC command register. */
69 #define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */
70 #define WD_MEMENB 0x40 /* Enable the shared memory. */
71 #define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */
72 #define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */
73 #define NIC16 0x40 /* Enable 16 bit access from the 8390. */
74 #define WD_NIC_OFFSET 16 /* Offset to the 8390 from the base_addr. */
75 #define WD_IO_EXTENT 32
76 
77 
78 /* Probe for the WD8003 and WD8013. These cards have the station
79  address PROM at I/O ports <base>+8 to <base>+13, with a checksum
80  following. A Soundblaster can have the same checksum as an WDethercard,
81  so we have an extra exclusionary check for it.
82 
83  The wd_probe1() routine initializes the card and fills the
84  station address field. */
85 
86 static int __init do_wd_probe(struct net_device *dev)
87 {
88  int i;
89  struct resource *r;
90  int base_addr = dev->base_addr;
91  int irq = dev->irq;
92  int mem_start = dev->mem_start;
93  int mem_end = dev->mem_end;
94 
95  if (base_addr > 0x1ff) { /* Check a user specified location. */
96  r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
97  if ( r == NULL)
98  return -EBUSY;
99  i = wd_probe1(dev, base_addr);
100  if (i != 0)
101  release_region(base_addr, WD_IO_EXTENT);
102  else
103  r->name = dev->name;
104  return i;
105  }
106  else if (base_addr != 0) /* Don't probe at all. */
107  return -ENXIO;
108 
109  for (i = 0; wd_portlist[i]; i++) {
110  int ioaddr = wd_portlist[i];
111  r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
112  if (r == NULL)
113  continue;
114  if (wd_probe1(dev, ioaddr) == 0) {
115  r->name = dev->name;
116  return 0;
117  }
118  release_region(ioaddr, WD_IO_EXTENT);
119  dev->irq = irq;
120  dev->mem_start = mem_start;
121  dev->mem_end = mem_end;
122  }
123 
124  return -ENODEV;
125 }
126 
127 #ifndef MODULE
128 struct net_device * __init wd_probe(int unit)
129 {
130  struct net_device *dev = alloc_ei_netdev();
131  int err;
132 
133  if (!dev)
134  return ERR_PTR(-ENOMEM);
135 
136  sprintf(dev->name, "eth%d", unit);
137  netdev_boot_setup_check(dev);
138 
139  err = do_wd_probe(dev);
140  if (err)
141  goto out;
142  return dev;
143 out:
144  free_netdev(dev);
145  return ERR_PTR(err);
146 }
147 #endif
148 
149 static const struct net_device_ops wd_netdev_ops = {
150  .ndo_open = wd_open,
151  .ndo_stop = wd_close,
152  .ndo_start_xmit = ei_start_xmit,
153  .ndo_tx_timeout = ei_tx_timeout,
154  .ndo_get_stats = ei_get_stats,
155  .ndo_set_rx_mode = ei_set_multicast_list,
156  .ndo_validate_addr = eth_validate_addr,
157  .ndo_set_mac_address = eth_mac_addr,
158  .ndo_change_mtu = eth_change_mtu,
159 #ifdef CONFIG_NET_POLL_CONTROLLER
160  .ndo_poll_controller = ei_poll,
161 #endif
162 };
163 
164 static int __init wd_probe1(struct net_device *dev, int ioaddr)
165 {
166  int i;
167  int err;
168  int checksum = 0;
169  int ancient = 0; /* An old card without config registers. */
170  int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
171  const char *model_name;
172  static unsigned version_printed;
173 
174  for (i = 0; i < 8; i++)
175  checksum += inb(ioaddr + 8 + i);
176  if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
177  || inb(ioaddr + 9) == 0xff
178  || (checksum & 0xff) != 0xFF)
179  return -ENODEV;
180 
181  /* Check for semi-valid mem_start/end values if supplied. */
182  if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
183  printk(KERN_WARNING "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
184  dev->mem_start = 0;
185  dev->mem_end = 0;
186  }
187 
188  if (ei_debug && version_printed++ == 0)
189  printk(version);
190 
191  for (i = 0; i < 6; i++)
192  dev->dev_addr[i] = inb(ioaddr + 8 + i);
193 
194  printk("%s: WD80x3 at %#3x, %pM",
195  dev->name, ioaddr, dev->dev_addr);
196 
197  /* The following PureData probe code was contributed by
198  Mike Jagdis <[email protected]>. Puredata does software
199  configuration differently from others so we have to check for them.
200  This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
201  */
202  if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
203  unsigned char reg5 = inb(ioaddr+5);
204 
205  switch (inb(ioaddr+2)) {
206  case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
207  case 0x05: word16 = 0; model_name = "PDUC8023"; break;
208  case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
209  /* Either 0x01 (dumb) or they've released a new version. */
210  default: word16 = 0; model_name = "PDI8023"; break;
211  }
212  dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
213  dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
214  } else { /* End of PureData probe */
215  /* This method of checking for a 16-bit board is borrowed from the
216  we.c driver. A simpler method is just to look in ASIC reg. 0x03.
217  I'm comparing the two method in alpha test to make certain they
218  return the same result. */
219  /* Check for the old 8 bit board - it has register 0/8 aliasing.
220  Do NOT check i>=6 here -- it hangs the old 8003 boards! */
221  for (i = 0; i < 6; i++)
222  if (inb(ioaddr+i) != inb(ioaddr+8+i))
223  break;
224  if (i >= 6) {
225  ancient = 1;
226  model_name = "WD8003-old";
227  word16 = 0;
228  } else {
229  int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
230  outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
231  if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
232  && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
233  int asic_reg5 = inb(ioaddr+WD_CMDREG5);
234  /* Magic to set ASIC to word-wide mode. */
235  outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
236  outb(tmp, ioaddr+1);
237  model_name = "WD8013";
238  word16 = 1; /* We have a 16bit board here! */
239  } else {
240  model_name = "WD8003";
241  word16 = 0;
242  }
243  outb(tmp, ioaddr+1); /* Restore original reg1 value. */
244  }
245 #ifndef final_version
246  if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
247  printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
248  word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8);
249 #endif
250  }
251 
252 #if defined(WD_SHMEM) && WD_SHMEM > 0x80000
253  /* Allow a compile-time override. */
254  dev->mem_start = WD_SHMEM;
255 #else
256  if (dev->mem_start == 0) {
257  /* Sanity and old 8003 check */
258  int reg0 = inb(ioaddr);
259  if (reg0 == 0xff || reg0 == 0) {
260  /* Future plan: this could check a few likely locations first. */
261  dev->mem_start = 0xd0000;
262  printk(" assigning address %#lx", dev->mem_start);
263  } else {
264  int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
265  /* Some boards don't have the register 5 -- it returns 0xff. */
266  if (high_addr_bits == 0x1f || word16 == 0)
267  high_addr_bits = 0x01;
268  dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
269  }
270  }
271 #endif
272 
273  /* The 8390 isn't at the base address -- the ASIC regs are there! */
274  dev->base_addr = ioaddr+WD_NIC_OFFSET;
275 
276  if (dev->irq < 2) {
277  static const int irqmap[] = {9, 3, 5, 7, 10, 11, 15, 4};
278  int reg1 = inb(ioaddr+1);
279  int reg4 = inb(ioaddr+4);
280  if (ancient || reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
281  short nic_addr = ioaddr+WD_NIC_OFFSET;
282  unsigned long irq_mask;
283 
284  /* We have an old-style ethercard that doesn't report its IRQ
285  line. Do autoirq to find the IRQ line. Note that this IS NOT
286  a reliable way to trigger an interrupt. */
287  outb_p(E8390_NODMA + E8390_STOP, nic_addr);
288  outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
289 
290  irq_mask = probe_irq_on();
291  outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
292  outb_p(0x00, nic_addr + EN0_RCNTLO);
293  outb_p(0x00, nic_addr + EN0_RCNTHI);
294  outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
295  mdelay(20);
296  dev->irq = probe_irq_off(irq_mask);
297 
298  outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
299 
300  if (ei_debug > 2)
301  printk(" autoirq is %d", dev->irq);
302  if (dev->irq < 2)
303  dev->irq = word16 ? 10 : 5;
304  } else
305  dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
306  } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
307  dev->irq = 9;
308 
309  /* Snarf the interrupt now. There's no point in waiting since we cannot
310  share and the board will usually be enabled. */
311  i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
312  if (i) {
313  printk (" unable to get IRQ %d.\n", dev->irq);
314  return i;
315  }
316 
317  /* OK, were are certain this is going to work. Setup the device. */
318  ei_status.name = model_name;
319  ei_status.word16 = word16;
320  ei_status.tx_start_page = WD_START_PG;
321  ei_status.rx_start_page = WD_START_PG + TX_PAGES;
322 
323  /* Don't map in the shared memory until the board is actually opened. */
324 
325  /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
326  if (dev->mem_end != 0) {
327  ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
328  ei_status.priv = dev->mem_end - dev->mem_start;
329  } else {
330  ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
331  dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
332  ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
333  }
334 
335  ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
336  if (!ei_status.mem) {
337  free_irq(dev->irq, dev);
338  return -ENOMEM;
339  }
340 
341  printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
342  model_name, dev->irq, dev->mem_start, dev->mem_end-1);
343 
344  ei_status.reset_8390 = wd_reset_8390;
345  ei_status.block_input = wd_block_input;
346  ei_status.block_output = wd_block_output;
347  ei_status.get_8390_hdr = wd_get_8390_hdr;
348 
349  dev->netdev_ops = &wd_netdev_ops;
350  NS8390_init(dev, 0);
351 
352 #if 1
353  /* Enable interrupt generation on softconfig cards -- M.U */
354  /* .. but possibly potentially unsafe - Donald */
355  if (inb(ioaddr+14) & 0x20)
356  outb(inb(ioaddr+4)|0x80, ioaddr+4);
357 #endif
358 
359  err = register_netdev(dev);
360  if (err) {
361  free_irq(dev->irq, dev);
362  iounmap(ei_status.mem);
363  }
364  return err;
365 }
366 
367 static int
368 wd_open(struct net_device *dev)
369 {
370  int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
371 
372  /* Map in the shared memory. Always set register 0 last to remain
373  compatible with very old boards. */
374  ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
375  ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
376 
377  if (ei_status.word16)
378  outb(ei_status.reg5, ioaddr+WD_CMDREG5);
379  outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
380 
381  return ei_open(dev);
382 }
383 
384 static void
385 wd_reset_8390(struct net_device *dev)
386 {
387  int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
388 
389  outb(WD_RESET, wd_cmd_port);
390  if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies);
391  ei_status.txing = 0;
392 
393  /* Set up the ASIC registers, just in case something changed them. */
394  outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
395  if (ei_status.word16)
396  outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
397 
398  if (ei_debug > 1) printk("reset done\n");
399 }
400 
401 /* Grab the 8390 specific header. Similar to the block_input routine, but
402  we don't need to be concerned with ring wrap as the header will be at
403  the start of a page, so we optimize accordingly. */
404 
405 static void
406 wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
407 {
408 
409  int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
410  void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
411 
412  /* We'll always get a 4 byte header read followed by a packet read, so
413  we enable 16 bit mode before the header, and disable after the body. */
414  if (ei_status.word16)
415  outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
416 
417 #ifdef __BIG_ENDIAN
418  /* Officially this is what we are doing, but the readl() is faster */
419  /* unfortunately it isn't endian aware of the struct */
420  memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
421  hdr->count = le16_to_cpu(hdr->count);
422 #else
423  ((unsigned int*)hdr)[0] = readl(hdr_start);
424 #endif
425 }
426 
427 /* Block input and output are easy on shared memory ethercards, and trivial
428  on the Western digital card where there is no choice of how to do it.
429  The only complications are that the ring buffer wraps, and need to map
430  switch between 8- and 16-bit modes. */
431 
432 static void
433 wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
434 {
435  int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
436  unsigned long offset = ring_offset - (WD_START_PG<<8);
437  void __iomem *xfer_start = ei_status.mem + offset;
438 
439  if (offset + count > ei_status.priv) {
440  /* We must wrap the input move. */
441  int semi_count = ei_status.priv - offset;
442  memcpy_fromio(skb->data, xfer_start, semi_count);
443  count -= semi_count;
444  memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
445  } else {
446  /* Packet is in one chunk -- we can copy + cksum. */
447  memcpy_fromio(skb->data, xfer_start, count);
448  }
449 
450  /* Turn off 16 bit access so that reboot works. ISA brain-damage */
451  if (ei_status.word16)
452  outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
453 }
454 
455 static void
456 wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
457  int start_page)
458 {
459  int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
460  void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
461 
462 
463  if (ei_status.word16) {
464  /* Turn on and off 16 bit access so that reboot works. */
465  outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
466  memcpy_toio(shmem, buf, count);
467  outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
468  } else
469  memcpy_toio(shmem, buf, count);
470 }
471 
472 
473 static int
474 wd_close(struct net_device *dev)
475 {
476  int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
477 
478  if (ei_debug > 1)
479  printk("%s: Shutting down ethercard.\n", dev->name);
480  ei_close(dev);
481 
482  /* Change from 16-bit to 8-bit shared memory so reboot works. */
483  if (ei_status.word16)
484  outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
485 
486  /* And disable the shared memory. */
487  outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
488 
489  return 0;
490 }
491 
492 
493 #ifdef MODULE
494 #define MAX_WD_CARDS 4 /* Max number of wd cards per module */
495 static struct net_device *dev_wd[MAX_WD_CARDS];
496 static int io[MAX_WD_CARDS];
497 static int irq[MAX_WD_CARDS];
498 static int mem[MAX_WD_CARDS];
499 static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */
500 
501 module_param_array(io, int, NULL, 0);
502 module_param_array(irq, int, NULL, 0);
503 module_param_array(mem, int, NULL, 0);
504 module_param_array(mem_end, int, NULL, 0);
505 MODULE_PARM_DESC(io, "I/O base address(es)");
506 MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
507 MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
508 MODULE_PARM_DESC(mem_end, "memory end address(es)");
509 MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
510 MODULE_LICENSE("GPL");
511 
512 /* This is set up so that only a single autoprobe takes place per call.
513 ISA device autoprobes on a running machine are not recommended. */
514 
515 int __init init_module(void)
516 {
517  struct net_device *dev;
518  int this_dev, found = 0;
519 
520  for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
521  if (io[this_dev] == 0) {
522  if (this_dev != 0) break; /* only autoprobe 1st one */
523  printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
524  }
525  dev = alloc_ei_netdev();
526  if (!dev)
527  break;
528  dev->irq = irq[this_dev];
529  dev->base_addr = io[this_dev];
530  dev->mem_start = mem[this_dev];
531  dev->mem_end = mem_end[this_dev];
532  if (do_wd_probe(dev) == 0) {
533  dev_wd[found++] = dev;
534  continue;
535  }
536  free_netdev(dev);
537  printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
538  break;
539  }
540  if (found)
541  return 0;
542  return -ENXIO;
543 }
544 
545 static void cleanup_card(struct net_device *dev)
546 {
547  free_irq(dev->irq, dev);
548  release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
549  iounmap(ei_status.mem);
550 }
551 
552 void __exit
553 cleanup_module(void)
554 {
555  int this_dev;
556 
557  for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
558  struct net_device *dev = dev_wd[this_dev];
559  if (dev) {
560  unregister_netdev(dev);
561  cleanup_card(dev);
562  free_netdev(dev);
563  }
564  }
565 }
566 #endif /* MODULE */
Generated on Thu Jan 10 2013 13:54:57 for Linux Kernel by   doxygen 1.8.2