Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
3c515.c
Go to the documentation of this file.
1 /*
2  Written 1997-1998 by Donald Becker.
3 
4  This software may be used and distributed according to the terms
5  of the GNU General Public License, incorporated herein by reference.
6 
7  This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
8 
9  The author may be reached as [email protected], or C/O
10  Scyld Computing Corporation
11  410 Severn Ave., Suite 210
12  Annapolis MD 21403
13 
14 
15  2000/2/2- Added support for kernel-level ISAPnP
16  by Stephen Frost <[email protected]> and Alessandro Zummo
17  Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
18 
19  2001/11/17 - Added ethtool support (jgarzik)
20 
21  2002/10/28 - Locking updates for 2.5 ([email protected])
22 
23 */
24 
25 #define DRV_NAME "3c515"
26 #define DRV_VERSION "0.99t-ac"
27 #define DRV_RELDATE "28-Oct-2002"
28 
29 static char *version =
30 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " [email protected] and others\n";
31 
32 #define CORKSCREW 1
33 
34 /* "Knobs" that adjust features and parameters. */
35 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
36  Setting to > 1512 effectively disables this feature. */
37 static int rx_copybreak = 200;
38 
39 /* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
40 static const int mtu = 1500;
41 
42 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
43 static int max_interrupt_work = 20;
44 
45 /* Enable the automatic media selection code -- usually set. */
46 #define AUTOMEDIA 1
47 
48 /* Allow the use of fragment bus master transfers instead of only
49  programmed-I/O for Vortex cards. Full-bus-master transfers are always
50  enabled by default on Boomerang cards. If VORTEX_BUS_MASTER is defined,
51  the feature may be turned on using 'options'. */
52 #define VORTEX_BUS_MASTER
53 
54 /* A few values that may be tweaked. */
55 /* Keep the ring sizes a power of two for efficiency. */
56 #define TX_RING_SIZE 16
57 #define RX_RING_SIZE 16
58 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer. */
59 
60 #include <linux/module.h>
61 #include <linux/isapnp.h>
62 #include <linux/kernel.h>
63 #include <linux/netdevice.h>
64 #include <linux/string.h>
65 #include <linux/errno.h>
66 #include <linux/in.h>
67 #include <linux/ioport.h>
68 #include <linux/skbuff.h>
69 #include <linux/etherdevice.h>
70 #include <linux/interrupt.h>
71 #include <linux/timer.h>
72 #include <linux/ethtool.h>
73 #include <linux/bitops.h>
74 
75 #include <asm/uaccess.h>
76 #include <asm/io.h>
77 #include <asm/dma.h>
78 
79 #define NEW_MULTICAST
80 #include <linux/delay.h>
81 
82 #define MAX_UNITS 8
83 
84 MODULE_AUTHOR("Donald Becker <[email protected]>");
85 MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
86 MODULE_LICENSE("GPL");
88 
89 /* "Knobs" for adjusting internal parameters. */
90 /* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
91 #define DRIVER_DEBUG 1
92 /* Some values here only for performance evaluation and path-coverage
93  debugging. */
94 static int rx_nocopy, rx_copy, queued_packet;
95 
96 /* Number of times to check to see if the Tx FIFO has space, used in some
97  limited cases. */
98 #define WAIT_TX_AVAIL 200
99 
100 /* Operational parameter that usually are not changed. */
101 #define TX_TIMEOUT ((4*HZ)/10) /* Time in jiffies before concluding Tx hung */
102 
103 /* The size here is somewhat misleading: the Corkscrew also uses the ISA
104  aliased registers at <base>+0x400.
105  */
106 #define CORKSCREW_TOTAL_SIZE 0x20
107 
108 #ifdef DRIVER_DEBUG
109 static int corkscrew_debug = DRIVER_DEBUG;
110 #else
111 static int corkscrew_debug = 1;
112 #endif
113 
114 #define CORKSCREW_ID 10
115 
116 /*
117  Theory of Operation
118 
119 I. Board Compatibility
120 
121 This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
122 3Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout,
123 it's not practical to integrate this driver with the other EtherLink drivers.
124 
125 II. Board-specific settings
126 
127 The Corkscrew has an EEPROM for configuration, but no special settings are
128 needed for Linux.
129 
130 III. Driver operation
131 
132 The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
133 PCI cards, with the bus master interface extensively modified to work with
134 the ISA bus.
135 
136 The card is capable of full-bus-master transfers with separate
137 lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
138 DEC Tulip and Intel Speedo3.
139 
140 This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
141 receive buffer. This scheme allocates full-sized skbuffs as receive
142 buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is
143 chosen to trade-off the memory wasted by passing the full-sized skbuff to
144 the queue layer for all frames vs. the copying cost of copying a frame to a
145 correctly-sized skbuff.
146 
147 
148 IIIC. Synchronization
149 The driver runs as two independent, single-threaded flows of control. One
150 is the send-packet routine, which enforces single-threaded use by the netif
151 layer. The other thread is the interrupt handler, which is single
152 threaded by the hardware and other software.
153 
154 IV. Notes
155 
156 Thanks to Terry Murphy of 3Com for providing documentation and a development
157 board.
158 
159 The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
160 project names. I use these names to eliminate confusion -- 3Com product
161 numbers and names are very similar and often confused.
162 
163 The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
164 This driver only supports ethernet frames because of the recent MTU limit
165 of 1.5K, but the changes to support 4.5K are minimal.
166 */
167 
168 /* Operational definitions.
169  These are not used by other compilation units and thus are not
170  exported in a ".h" file.
171 
172  First the windows. There are eight register windows, with the command
173  and status registers available in each.
174  */
175 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
176 #define EL3_CMD 0x0e
177 #define EL3_STATUS 0x0e
178 
179 /* The top five bits written to EL3_CMD are a command, the lower
180  11 bits are the parameter, if applicable.
181  Note that 11 parameters bits was fine for ethernet, but the new chips
182  can handle FDDI length frames (~4500 octets) and now parameters count
183  32-bit 'Dwords' rather than octets. */
184 
186  TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
187  RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
188  UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
189  DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
190  TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
191  AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
192  SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
193  SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
194  StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
195  StatsDisable = 22 << 11, StopCoax = 23 << 11,
196 };
197 
198 /* The SetRxFilter command accepts the following classes: */
199 enum RxFilter {
201 };
202 
203 /* Bits in the general status register. */
205  IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
206  TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
207  IntReq = 0x0040, StatsFull = 0x0080,
208  DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
209  DMAInProgress = 1 << 11, /* DMA controller is still busy. */
210  CmdInProgress = 1 << 12, /* EL3_CMD is still busy. */
211 };
212 
213 /* Register window 1 offsets, the window used in normal operation.
214  On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
215 enum Window1 {
216  TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
217  RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
218  TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
219 };
220 enum Window0 {
221  Wn0IRQ = 0x08,
222 #if defined(CORKSCREW)
223  Wn0EepromCmd = 0x200A, /* Corkscrew EEPROM command register. */
224  Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */
225 #else
226  Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
227  Wn0EepromData = 12, /* Window 0: EEPROM results register. */
228 #endif
229 };
231  EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
232  EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
233  EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
234 };
235 
236 /* EEPROM locations. */
240 };
241 
242 enum Window3 { /* Window 3: MAC/config bits. */
244 };
246  Ram_size = 7,
248  Ram_speed = 0x30,
249  Rom_size = 0xc0,
253  Xcvr = 7 << Xcvr_shift,
254  Autoselect = 0x1000000,
255 };
256 
257 enum Window4 {
258  Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */
259 };
261  Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
262  Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
263  Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
264  Media_LnkBeat = 0x0800,
265 };
266 enum Window7 { /* Window 7: Bus Master control. */
268 };
269 
270 /* Boomerang-style bus master control registers. Note ISA aliases! */
272  PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
273  0x40c,
274  TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
275 };
276 
277 /* The Rx and Tx descriptor lists.
278  Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
279  alignment contraint on tx_ring[] and rx_ring[]. */
280 struct boom_rx_desc {
285 };
286 
287 /* Values for the Rx status entry. */
289  RxDComplete = 0x00008000, RxDError = 0x4000,
290  /* See boomerang_rx() for actual error bits */
291 };
292 
293 struct boom_tx_desc {
298 };
299 
301  const char *product_name;
302  struct list_head list;
304  /* The Rx and Tx rings are here to keep them quad-word-aligned. */
307  /* The addresses of transmit- and receive-in-place skbuffs. */
310  unsigned int cur_rx, cur_tx; /* The next free ring entry */
311  unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
312  struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
313  struct timer_list timer; /* Media selection timer. */
314  int capabilities ; /* Adapter capabilities word. */
315  int options; /* User-settable misc. driver options. */
316  int last_rx_packets; /* For media autoselection. */
317  unsigned int available_media:8, /* From Wn3_Options */
318  media_override:3, /* Passed-in media type. */
319  default_media:3, /* Read from the EEPROM. */
320  full_duplex:1, autoselect:1, bus_master:1, /* Vortex can only do a fragment bus-m. */
321  full_bus_master_tx:1, full_bus_master_rx:1, /* Boomerang */
322  tx_full:1;
324  struct device *dev;
325 };
326 
327 /* The action to take with a media selection timer tick.
328  Note that we deviate from the 3Com order by checking 10base2 before AUI.
329  */
333 };
334 
335 static struct media_table {
336  char *name;
337  unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */
338  mask:8, /* The transceiver-present bit in Wn3_Config. */
339  next:8; /* The media type to try next. */
340  short wait; /* Time before we check media status. */
341 } media_tbl[] = {
342  { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
343  { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
344  { "undefined", 0, 0x80, XCVR_10baseT, 10000},
345  { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
346  { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
347  { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
348  { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
349  { "undefined", 0, 0x01, XCVR_10baseT, 10000},
350  { "Default", 0, 0xFF, XCVR_10baseT, 10000},
351 };
352 
353 #ifdef __ISAPNP__
354 static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
356  ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
357  (long) "3Com Fast EtherLink ISA" },
358  { } /* terminate list */
359 };
360 
361 MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
362 
363 static int nopnp;
364 #endif /* __ISAPNP__ */
365 
366 static struct net_device *corkscrew_scan(int unit);
367 static int corkscrew_setup(struct net_device *dev, int ioaddr,
368  struct pnp_dev *idev, int card_number);
369 static int corkscrew_open(struct net_device *dev);
370 static void corkscrew_timer(unsigned long arg);
371 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
372  struct net_device *dev);
373 static int corkscrew_rx(struct net_device *dev);
374 static void corkscrew_timeout(struct net_device *dev);
375 static int boomerang_rx(struct net_device *dev);
376 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
377 static int corkscrew_close(struct net_device *dev);
378 static void update_stats(int addr, struct net_device *dev);
379 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
380 static void set_rx_mode(struct net_device *dev);
381 static const struct ethtool_ops netdev_ethtool_ops;
382 
383 
384 /*
385  Unfortunately maximizing the shared code between the integrated and
386  module version of the driver results in a complicated set of initialization
387  procedures.
388  init_module() -- modules / tc59x_init() -- built-in
389  The wrappers for corkscrew_scan()
390  corkscrew_scan() The common routine that scans for PCI and EISA cards
391  corkscrew_found_device() Allocate a device structure when we find a card.
392  Different versions exist for modules and built-in.
393  corkscrew_probe1() Fill in the device structure -- this is separated
394  so that the modules code can put it in dev->init.
395 */
396 /* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
397 /* Note: this is the only limit on the number of cards supported!! */
398 static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
399 
400 #ifdef MODULE
401 static int debug = -1;
402 
403 module_param(debug, int, 0);
404 module_param_array(options, int, NULL, 0);
405 module_param(rx_copybreak, int, 0);
406 module_param(max_interrupt_work, int, 0);
407 MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
408 MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
409 MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
410 MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
411 
412 /* A list of all installed Vortex devices, for removing the driver module. */
413 /* we will need locking (and refcounting) if we ever use it for more */
414 static LIST_HEAD(root_corkscrew_dev);
415 
416 int init_module(void)
417 {
418  int found = 0;
419  if (debug >= 0)
420  corkscrew_debug = debug;
421  if (corkscrew_debug)
422  pr_debug("%s", version);
423  while (corkscrew_scan(-1))
424  found++;
425  return found ? 0 : -ENODEV;
426 }
427 
428 #else
430 {
431  struct net_device *dev = corkscrew_scan(unit);
432  static int printed;
433 
434  if (!dev)
435  return ERR_PTR(-ENODEV);
436 
437  if (corkscrew_debug > 0 && !printed) {
438  printed = 1;
439  pr_debug("%s", version);
440  }
441 
442  return dev;
443 }
444 #endif /* not MODULE */
445 
446 static int check_device(unsigned ioaddr)
447 {
448  int timer;
449 
450  if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
451  return 0;
452  /* Check the resource configuration for a matching ioaddr. */
453  if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
455  return 0;
456  }
457  /* Verify by reading the device ID from the EEPROM. */
458  outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
459  /* Pause for at least 162 us. for the read to take place. */
460  for (timer = 4; timer >= 0; timer--) {
461  udelay(162);
462  if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
463  break;
464  }
465  if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
467  return 0;
468  }
469  return 1;
470 }
471 
472 static void cleanup_card(struct net_device *dev)
473 {
474  struct corkscrew_private *vp = netdev_priv(dev);
475  list_del_init(&vp->list);
476  if (dev->dma)
477  free_dma(dev->dma);
478  outw(TotalReset, dev->base_addr + EL3_CMD);
480  if (vp->dev)
482 }
483 
484 static struct net_device *corkscrew_scan(int unit)
485 {
486  struct net_device *dev;
487  static int cards_found = 0;
488  static int ioaddr;
489  int err;
490 #ifdef __ISAPNP__
491  short i;
492  static int pnp_cards;
493 #endif
494 
495  dev = alloc_etherdev(sizeof(struct corkscrew_private));
496  if (!dev)
497  return ERR_PTR(-ENOMEM);
498 
499  if (unit >= 0) {
500  sprintf(dev->name, "eth%d", unit);
502  }
503 
504 #ifdef __ISAPNP__
505  if(nopnp == 1)
506  goto no_pnp;
507  for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
508  struct pnp_dev *idev = NULL;
509  int irq;
510  while((idev = pnp_find_dev(NULL,
511  corkscrew_isapnp_adapters[i].vendor,
512  corkscrew_isapnp_adapters[i].function,
513  idev))) {
514 
515  if (pnp_device_attach(idev) < 0)
516  continue;
517  if (pnp_activate_dev(idev) < 0) {
518  pr_warning("pnp activate failed (out of resources?)\n");
519  pnp_device_detach(idev);
520  continue;
521  }
522  if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
523  pnp_device_detach(idev);
524  continue;
525  }
526  ioaddr = pnp_port_start(idev, 0);
527  irq = pnp_irq(idev, 0);
528  if (!check_device(ioaddr)) {
529  pnp_device_detach(idev);
530  continue;
531  }
532  if(corkscrew_debug)
533  pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
534  (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
535  pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
536  inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
537  /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
538  SET_NETDEV_DEV(dev, &idev->dev);
539  pnp_cards++;
540  err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
541  if (!err)
542  return dev;
543  cleanup_card(dev);
544  }
545  }
546 no_pnp:
547 #endif /* __ISAPNP__ */
548 
549  /* Check all locations on the ISA bus -- evil! */
550  for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
551  if (!check_device(ioaddr))
552  continue;
553 
554  pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
555  inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
556  err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
557  if (!err)
558  return dev;
559  cleanup_card(dev);
560  }
561  free_netdev(dev);
562  return NULL;
563 }
564 
565 
566 static const struct net_device_ops netdev_ops = {
567  .ndo_open = corkscrew_open,
568  .ndo_stop = corkscrew_close,
569  .ndo_start_xmit = corkscrew_start_xmit,
570  .ndo_tx_timeout = corkscrew_timeout,
571  .ndo_get_stats = corkscrew_get_stats,
572  .ndo_set_rx_mode = set_rx_mode,
573  .ndo_change_mtu = eth_change_mtu,
574  .ndo_set_mac_address = eth_mac_addr,
575  .ndo_validate_addr = eth_validate_addr,
576 };
577 
578 
579 static int corkscrew_setup(struct net_device *dev, int ioaddr,
580  struct pnp_dev *idev, int card_number)
581 {
582  struct corkscrew_private *vp = netdev_priv(dev);
583  unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
584  int i;
585  int irq;
586 
587 #ifdef __ISAPNP__
588  if (idev) {
589  irq = pnp_irq(idev, 0);
590  vp->dev = &idev->dev;
591  } else {
592  irq = inw(ioaddr + 0x2002) & 15;
593  }
594 #else
595  irq = inw(ioaddr + 0x2002) & 15;
596 #endif
597 
598  dev->base_addr = ioaddr;
599  dev->irq = irq;
600  dev->dma = inw(ioaddr + 0x2000) & 7;
601  vp->product_name = "3c515";
602  vp->options = dev->mem_start;
603  vp->our_dev = dev;
604 
605  if (!vp->options) {
606  if (card_number >= MAX_UNITS)
607  vp->options = -1;
608  else
609  vp->options = options[card_number];
610  }
611 
612  if (vp->options >= 0) {
613  vp->media_override = vp->options & 7;
614  if (vp->media_override == 2)
615  vp->media_override = 0;
616  vp->full_duplex = (vp->options & 8) ? 1 : 0;
617  vp->bus_master = (vp->options & 16) ? 1 : 0;
618  } else {
619  vp->media_override = 7;
620  vp->full_duplex = 0;
621  vp->bus_master = 0;
622  }
623 #ifdef MODULE
624  list_add(&vp->list, &root_corkscrew_dev);
625 #endif
626 
627  pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
628 
629  spin_lock_init(&vp->lock);
630 
631  /* Read the station address from the EEPROM. */
632  EL3WINDOW(0);
633  for (i = 0; i < 0x18; i++) {
634  __be16 *phys_addr = (__be16 *) dev->dev_addr;
635  int timer;
636  outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
637  /* Pause for at least 162 us. for the read to take place. */
638  for (timer = 4; timer >= 0; timer--) {
639  udelay(162);
640  if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
641  break;
642  }
643  eeprom[i] = inw(ioaddr + Wn0EepromData);
644  checksum ^= eeprom[i];
645  if (i < 3)
646  phys_addr[i] = htons(eeprom[i]);
647  }
648  checksum = (checksum ^ (checksum >> 8)) & 0xff;
649  if (checksum != 0x00)
650  pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
651  pr_cont(" %pM", dev->dev_addr);
652  if (eeprom[16] == 0x11c7) { /* Corkscrew */
653  if (request_dma(dev->dma, "3c515")) {
654  pr_cont(", DMA %d allocation failed", dev->dma);
655  dev->dma = 0;
656  } else
657  pr_cont(", DMA %d", dev->dma);
658  }
659  pr_cont(", IRQ %d\n", dev->irq);
660  /* Tell them about an invalid IRQ. */
661  if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
662  pr_warning(" *** Warning: this IRQ is unlikely to work! ***\n");
663 
664  {
665  static const char * const ram_split[] = {
666  "5:3", "3:1", "1:1", "3:5"
667  };
668  __u32 config;
669  EL3WINDOW(3);
670  vp->available_media = inw(ioaddr + Wn3_Options);
671  config = inl(ioaddr + Wn3_Config);
672  if (corkscrew_debug > 1)
673  pr_info(" Internal config register is %4.4x, transceivers %#x.\n",
674  config, inw(ioaddr + Wn3_Options));
675  pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
676  8 << config & Ram_size,
677  config & Ram_width ? "word" : "byte",
678  ram_split[(config & Ram_split) >> Ram_split_shift],
679  config & Autoselect ? "autoselect/" : "",
680  media_tbl[(config & Xcvr) >> Xcvr_shift].name);
681  vp->default_media = (config & Xcvr) >> Xcvr_shift;
682  vp->autoselect = config & Autoselect ? 1 : 0;
683  dev->if_port = vp->default_media;
684  }
685  if (vp->media_override != 7) {
686  pr_info(" Media override to transceiver type %d (%s).\n",
687  vp->media_override,
688  media_tbl[vp->media_override].name);
689  dev->if_port = vp->media_override;
690  }
691 
692  vp->capabilities = eeprom[16];
693  vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
694  /* Rx is broken at 10mbps, so we always disable it. */
695  /* vp->full_bus_master_rx = 0; */
696  vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
697 
698  /* The 3c51x-specific entries in the device structure. */
699  dev->netdev_ops = &netdev_ops;
700  dev->watchdog_timeo = (400 * HZ) / 1000;
701  dev->ethtool_ops = &netdev_ethtool_ops;
702 
703  return register_netdev(dev);
704 }
705 
706 
707 static int corkscrew_open(struct net_device *dev)
708 {
709  int ioaddr = dev->base_addr;
710  struct corkscrew_private *vp = netdev_priv(dev);
711  __u32 config;
712  int i;
713 
714  /* Before initializing select the active media port. */
715  EL3WINDOW(3);
716  if (vp->full_duplex)
717  outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
718  config = inl(ioaddr + Wn3_Config);
719 
720  if (vp->media_override != 7) {
721  if (corkscrew_debug > 1)
722  pr_info("%s: Media override to transceiver %d (%s).\n",
723  dev->name, vp->media_override,
724  media_tbl[vp->media_override].name);
725  dev->if_port = vp->media_override;
726  } else if (vp->autoselect) {
727  /* Find first available media type, starting with 100baseTx. */
728  dev->if_port = 4;
729  while (!(vp->available_media & media_tbl[dev->if_port].mask))
730  dev->if_port = media_tbl[dev->if_port].next;
731 
732  if (corkscrew_debug > 1)
733  pr_debug("%s: Initial media type %s.\n",
734  dev->name, media_tbl[dev->if_port].name);
735 
736  init_timer(&vp->timer);
737  vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
738  vp->timer.data = (unsigned long) dev;
739  vp->timer.function = corkscrew_timer; /* timer handler */
740  add_timer(&vp->timer);
741  } else
742  dev->if_port = vp->default_media;
743 
744  config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
745  outl(config, ioaddr + Wn3_Config);
746 
747  if (corkscrew_debug > 1) {
748  pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
749  dev->name, config);
750  }
751 
752  outw(TxReset, ioaddr + EL3_CMD);
753  for (i = 20; i >= 0; i--)
754  if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
755  break;
756 
757  outw(RxReset, ioaddr + EL3_CMD);
758  /* Wait a few ticks for the RxReset command to complete. */
759  for (i = 20; i >= 0; i--)
760  if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
761  break;
762 
763  outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
764 
765  /* Use the now-standard shared IRQ implementation. */
766  if (vp->capabilities == 0x11c7) {
767  /* Corkscrew: Cannot share ISA resources. */
768  if (dev->irq == 0 ||
769  dev->dma == 0 ||
770  request_irq(dev->irq, corkscrew_interrupt, 0,
771  vp->product_name, dev))
772  return -EAGAIN;
773  enable_dma(dev->dma);
775  } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
776  vp->product_name, dev)) {
777  return -EAGAIN;
778  }
779 
780  if (corkscrew_debug > 1) {
781  EL3WINDOW(4);
782  pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
783  dev->name, dev->irq, inw(ioaddr + Wn4_Media));
784  }
785 
786  /* Set the station address and mask in window 2 each time opened. */
787  EL3WINDOW(2);
788  for (i = 0; i < 6; i++)
789  outb(dev->dev_addr[i], ioaddr + i);
790  for (; i < 12; i += 2)
791  outw(0, ioaddr + i);
792 
793  if (dev->if_port == 3)
794  /* Start the thinnet transceiver. We should really wait 50ms... */
795  outw(StartCoax, ioaddr + EL3_CMD);
796  EL3WINDOW(4);
797  outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
798  media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
799 
800  /* Switch to the stats window, and clear all stats by reading. */
801  outw(StatsDisable, ioaddr + EL3_CMD);
802  EL3WINDOW(6);
803  for (i = 0; i < 10; i++)
804  inb(ioaddr + i);
805  inw(ioaddr + 10);
806  inw(ioaddr + 12);
807  /* New: On the Vortex we must also clear the BadSSD counter. */
808  EL3WINDOW(4);
809  inb(ioaddr + 12);
810  /* ..and on the Boomerang we enable the extra statistics bits. */
811  outw(0x0040, ioaddr + Wn4_NetDiag);
812 
813  /* Switch to register set 7 for normal use. */
814  EL3WINDOW(7);
815 
816  if (vp->full_bus_master_rx) { /* Boomerang bus master. */
817  vp->cur_rx = vp->dirty_rx = 0;
818  if (corkscrew_debug > 2)
819  pr_debug("%s: Filling in the Rx ring.\n", dev->name);
820  for (i = 0; i < RX_RING_SIZE; i++) {
821  struct sk_buff *skb;
822  if (i < (RX_RING_SIZE - 1))
823  vp->rx_ring[i].next =
824  isa_virt_to_bus(&vp->rx_ring[i + 1]);
825  else
826  vp->rx_ring[i].next = 0;
827  vp->rx_ring[i].status = 0; /* Clear complete bit. */
828  vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
829  skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
830  vp->rx_skbuff[i] = skb;
831  if (skb == NULL)
832  break; /* Bad news! */
833  skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
834  vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
835  }
836  if (i != 0)
837  vp->rx_ring[i - 1].next =
838  isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
839  outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
840  }
841  if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
842  vp->cur_tx = vp->dirty_tx = 0;
843  outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */
844  /* Clear the Tx ring. */
845  for (i = 0; i < TX_RING_SIZE; i++)
846  vp->tx_skbuff[i] = NULL;
847  outl(0, ioaddr + DownListPtr);
848  }
849  /* Set receiver mode: presumably accept b-case and phys addr only. */
850  set_rx_mode(dev);
851  outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
852 
853  netif_start_queue(dev);
854 
855  outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
856  outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
857  /* Allow status bits to be seen. */
861  (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
862  /* Ack all pending events, and set active indicator mask. */
864  ioaddr + EL3_CMD);
866  | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
867  ioaddr + EL3_CMD);
868 
869  return 0;
870 }
871 
872 static void corkscrew_timer(unsigned long data)
873 {
874 #ifdef AUTOMEDIA
875  struct net_device *dev = (struct net_device *) data;
876  struct corkscrew_private *vp = netdev_priv(dev);
877  int ioaddr = dev->base_addr;
878  unsigned long flags;
879  int ok = 0;
880 
881  if (corkscrew_debug > 1)
882  pr_debug("%s: Media selection timer tick happened, %s.\n",
883  dev->name, media_tbl[dev->if_port].name);
884 
885  spin_lock_irqsave(&vp->lock, flags);
886 
887  {
888  int old_window = inw(ioaddr + EL3_CMD) >> 13;
889  int media_status;
890  EL3WINDOW(4);
891  media_status = inw(ioaddr + Wn4_Media);
892  switch (dev->if_port) {
893  case 0:
894  case 4:
895  case 5: /* 10baseT, 100baseTX, 100baseFX */
896  if (media_status & Media_LnkBeat) {
897  ok = 1;
898  if (corkscrew_debug > 1)
899  pr_debug("%s: Media %s has link beat, %x.\n",
900  dev->name,
901  media_tbl[dev->if_port].name,
902  media_status);
903  } else if (corkscrew_debug > 1)
904  pr_debug("%s: Media %s is has no link beat, %x.\n",
905  dev->name,
906  media_tbl[dev->if_port].name,
907  media_status);
908 
909  break;
910  default: /* Other media types handled by Tx timeouts. */
911  if (corkscrew_debug > 1)
912  pr_debug("%s: Media %s is has no indication, %x.\n",
913  dev->name,
914  media_tbl[dev->if_port].name,
915  media_status);
916  ok = 1;
917  }
918  if (!ok) {
919  __u32 config;
920 
921  do {
922  dev->if_port =
923  media_tbl[dev->if_port].next;
924  }
925  while (!(vp->available_media & media_tbl[dev->if_port].mask));
926 
927  if (dev->if_port == 8) { /* Go back to default. */
928  dev->if_port = vp->default_media;
929  if (corkscrew_debug > 1)
930  pr_debug("%s: Media selection failing, using default %s port.\n",
931  dev->name,
932  media_tbl[dev->if_port].name);
933  } else {
934  if (corkscrew_debug > 1)
935  pr_debug("%s: Media selection failed, now trying %s port.\n",
936  dev->name,
937  media_tbl[dev->if_port].name);
938  vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
939  add_timer(&vp->timer);
940  }
941  outw((media_status & ~(Media_10TP | Media_SQE)) |
942  media_tbl[dev->if_port].media_bits,
943  ioaddr + Wn4_Media);
944 
945  EL3WINDOW(3);
946  config = inl(ioaddr + Wn3_Config);
947  config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
948  outl(config, ioaddr + Wn3_Config);
949 
950  outw(dev->if_port == 3 ? StartCoax : StopCoax,
951  ioaddr + EL3_CMD);
952  }
953  EL3WINDOW(old_window);
954  }
955 
956  spin_unlock_irqrestore(&vp->lock, flags);
957  if (corkscrew_debug > 1)
958  pr_debug("%s: Media selection timer finished, %s.\n",
959  dev->name, media_tbl[dev->if_port].name);
960 
961 #endif /* AUTOMEDIA */
962 }
963 
964 static void corkscrew_timeout(struct net_device *dev)
965 {
966  int i;
967  struct corkscrew_private *vp = netdev_priv(dev);
968  int ioaddr = dev->base_addr;
969 
970  pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
971  dev->name, inb(ioaddr + TxStatus),
972  inw(ioaddr + EL3_STATUS));
973  /* Slight code bloat to be user friendly. */
974  if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
975  pr_warning("%s: Transmitter encountered 16 collisions --"
976  " network cable problem?\n", dev->name);
977 #ifndef final_version
978  pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
979  vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
980  vp->cur_tx);
981  pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
982  &vp->tx_ring[0]);
983  for (i = 0; i < TX_RING_SIZE; i++) {
984  pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
985  &vp->tx_ring[i],
986  vp->tx_ring[i].length, vp->tx_ring[i].status);
987  }
988 #endif
989  /* Issue TX_RESET and TX_START commands. */
990  outw(TxReset, ioaddr + EL3_CMD);
991  for (i = 20; i >= 0; i--)
992  if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
993  break;
994  outw(TxEnable, ioaddr + EL3_CMD);
995  dev->trans_start = jiffies; /* prevent tx timeout */
996  dev->stats.tx_errors++;
997  dev->stats.tx_dropped++;
998  netif_wake_queue(dev);
999 }
1000 
1001 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1002  struct net_device *dev)
1003 {
1004  struct corkscrew_private *vp = netdev_priv(dev);
1005  int ioaddr = dev->base_addr;
1006 
1007  /* Block a timer-based transmit from overlapping. */
1008 
1009  netif_stop_queue(dev);
1010 
1011  if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
1012  /* Calculate the next Tx descriptor entry. */
1013  int entry = vp->cur_tx % TX_RING_SIZE;
1014  struct boom_tx_desc *prev_entry;
1015  unsigned long flags;
1016  int i;
1017 
1018  if (vp->tx_full) /* No room to transmit with */
1019  return NETDEV_TX_BUSY;
1020  if (vp->cur_tx != 0)
1021  prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1022  else
1023  prev_entry = NULL;
1024  if (corkscrew_debug > 3)
1025  pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1026  dev->name, vp->cur_tx);
1027  /* vp->tx_full = 1; */
1028  vp->tx_skbuff[entry] = skb;
1029  vp->tx_ring[entry].next = 0;
1030  vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1031  vp->tx_ring[entry].length = skb->len | 0x80000000;
1032  vp->tx_ring[entry].status = skb->len | 0x80000000;
1033 
1034  spin_lock_irqsave(&vp->lock, flags);
1035  outw(DownStall, ioaddr + EL3_CMD);
1036  /* Wait for the stall to complete. */
1037  for (i = 20; i >= 0; i--)
1038  if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1039  break;
1040  if (prev_entry)
1041  prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1042  if (inl(ioaddr + DownListPtr) == 0) {
1043  outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1044  ioaddr + DownListPtr);
1045  queued_packet++;
1046  }
1047  outw(DownUnstall, ioaddr + EL3_CMD);
1048  spin_unlock_irqrestore(&vp->lock, flags);
1049 
1050  vp->cur_tx++;
1051  if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1052  vp->tx_full = 1;
1053  else { /* Clear previous interrupt enable. */
1054  if (prev_entry)
1055  prev_entry->status &= ~0x80000000;
1056  netif_wake_queue(dev);
1057  }
1058  return NETDEV_TX_OK;
1059  }
1060  /* Put out the doubleword header... */
1061  outl(skb->len, ioaddr + TX_FIFO);
1062  dev->stats.tx_bytes += skb->len;
1063 #ifdef VORTEX_BUS_MASTER
1064  if (vp->bus_master) {
1065  /* Set the bus-master controller to transfer the packet. */
1066  outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1067  outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1068  vp->tx_skb = skb;
1069  outw(StartDMADown, ioaddr + EL3_CMD);
1070  /* queue will be woken at the DMADone interrupt. */
1071  } else {
1072  /* ... and the packet rounded to a doubleword. */
1073  outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1074  dev_kfree_skb(skb);
1075  if (inw(ioaddr + TxFree) > 1536) {
1076  netif_wake_queue(dev);
1077  } else
1078  /* Interrupt us when the FIFO has room for max-sized packet. */
1079  outw(SetTxThreshold + (1536 >> 2),
1080  ioaddr + EL3_CMD);
1081  }
1082 #else
1083  /* ... and the packet rounded to a doubleword. */
1084  outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1085  dev_kfree_skb(skb);
1086  if (inw(ioaddr + TxFree) > 1536) {
1087  netif_wake_queue(dev);
1088  } else
1089  /* Interrupt us when the FIFO has room for max-sized packet. */
1090  outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1091 #endif /* bus master */
1092 
1093 
1094  /* Clear the Tx status stack. */
1095  {
1096  short tx_status;
1097  int i = 4;
1098 
1099  while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1100  if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1101  if (corkscrew_debug > 2)
1102  pr_debug("%s: Tx error, status %2.2x.\n",
1103  dev->name, tx_status);
1104  if (tx_status & 0x04)
1105  dev->stats.tx_fifo_errors++;
1106  if (tx_status & 0x38)
1107  dev->stats.tx_aborted_errors++;
1108  if (tx_status & 0x30) {
1109  int j;
1110  outw(TxReset, ioaddr + EL3_CMD);
1111  for (j = 20; j >= 0; j--)
1112  if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1113  break;
1114  }
1115  outw(TxEnable, ioaddr + EL3_CMD);
1116  }
1117  outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1118  }
1119  }
1120  return NETDEV_TX_OK;
1121 }
1122 
1123 /* The interrupt handler does all of the Rx thread work and cleans up
1124  after the Tx thread. */
1125 
1126 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1127 {
1128  /* Use the now-standard shared IRQ implementation. */
1129  struct net_device *dev = dev_id;
1130  struct corkscrew_private *lp = netdev_priv(dev);
1131  int ioaddr, status;
1132  int latency;
1133  int i = max_interrupt_work;
1134 
1135  ioaddr = dev->base_addr;
1136  latency = inb(ioaddr + Timer);
1137 
1138  spin_lock(&lp->lock);
1139 
1140  status = inw(ioaddr + EL3_STATUS);
1141 
1142  if (corkscrew_debug > 4)
1143  pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1144  dev->name, status, latency);
1145  if ((status & 0xE000) != 0xE000) {
1146  static int donedidthis;
1147  /* Some interrupt controllers store a bogus interrupt from boot-time.
1148  Ignore a single early interrupt, but don't hang the machine for
1149  other interrupt problems. */
1150  if (donedidthis++ > 100) {
1151  pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1152  dev->name, status, netif_running(dev));
1153  free_irq(dev->irq, dev);
1154  dev->irq = -1;
1155  }
1156  }
1157 
1158  do {
1159  if (corkscrew_debug > 5)
1160  pr_debug("%s: In interrupt loop, status %4.4x.\n",
1161  dev->name, status);
1162  if (status & RxComplete)
1163  corkscrew_rx(dev);
1164 
1165  if (status & TxAvailable) {
1166  if (corkscrew_debug > 5)
1167  pr_debug(" TX room bit was handled.\n");
1168  /* There's room in the FIFO for a full-sized packet. */
1169  outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1170  netif_wake_queue(dev);
1171  }
1172  if (status & DownComplete) {
1173  unsigned int dirty_tx = lp->dirty_tx;
1174 
1175  while (lp->cur_tx - dirty_tx > 0) {
1176  int entry = dirty_tx % TX_RING_SIZE;
1177  if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1178  break; /* It still hasn't been processed. */
1179  if (lp->tx_skbuff[entry]) {
1180  dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1181  lp->tx_skbuff[entry] = NULL;
1182  }
1183  dirty_tx++;
1184  }
1185  lp->dirty_tx = dirty_tx;
1186  outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1187  if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1188  lp->tx_full = 0;
1189  netif_wake_queue(dev);
1190  }
1191  }
1192 #ifdef VORTEX_BUS_MASTER
1193  if (status & DMADone) {
1194  outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1195  dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1196  netif_wake_queue(dev);
1197  }
1198 #endif
1199  if (status & UpComplete) {
1200  boomerang_rx(dev);
1201  outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1202  }
1203  if (status & (AdapterFailure | RxEarly | StatsFull)) {
1204  /* Handle all uncommon interrupts at once. */
1205  if (status & RxEarly) { /* Rx early is unused. */
1206  corkscrew_rx(dev);
1207  outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1208  }
1209  if (status & StatsFull) { /* Empty statistics. */
1210  static int DoneDidThat;
1211  if (corkscrew_debug > 4)
1212  pr_debug("%s: Updating stats.\n", dev->name);
1213  update_stats(ioaddr, dev);
1214  /* DEBUG HACK: Disable statistics as an interrupt source. */
1215  /* This occurs when we have the wrong media type! */
1216  if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1217  int win, reg;
1218  pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1219  dev->name);
1220  for (win = 0; win < 8; win++) {
1221  EL3WINDOW(win);
1222  pr_notice("Vortex window %d:", win);
1223  for (reg = 0; reg < 16; reg++)
1224  pr_cont(" %2.2x", inb(ioaddr + reg));
1225  pr_cont("\n");
1226  }
1227  EL3WINDOW(7);
1228  outw(SetIntrEnb | TxAvailable |
1229  RxComplete | AdapterFailure |
1230  UpComplete | DownComplete |
1231  TxComplete, ioaddr + EL3_CMD);
1232  DoneDidThat++;
1233  }
1234  }
1235  if (status & AdapterFailure) {
1236  /* Adapter failure requires Rx reset and reinit. */
1237  outw(RxReset, ioaddr + EL3_CMD);
1238  /* Set the Rx filter to the current state. */
1239  set_rx_mode(dev);
1240  outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1241  outw(AckIntr | AdapterFailure,
1242  ioaddr + EL3_CMD);
1243  }
1244  }
1245 
1246  if (--i < 0) {
1247  pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1248  dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1249  /* Disable all pending interrupts. */
1250  outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1251  outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1252  break;
1253  }
1254  /* Acknowledge the IRQ. */
1255  outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1256 
1257  } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1258 
1259  spin_unlock(&lp->lock);
1260 
1261  if (corkscrew_debug > 4)
1262  pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1263  return IRQ_HANDLED;
1264 }
1265 
1266 static int corkscrew_rx(struct net_device *dev)
1267 {
1268  int ioaddr = dev->base_addr;
1269  int i;
1270  short rx_status;
1271 
1272  if (corkscrew_debug > 5)
1273  pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1274  inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1275  while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1276  if (rx_status & 0x4000) { /* Error, update stats. */
1277  unsigned char rx_error = inb(ioaddr + RxErrors);
1278  if (corkscrew_debug > 2)
1279  pr_debug(" Rx error: status %2.2x.\n",
1280  rx_error);
1281  dev->stats.rx_errors++;
1282  if (rx_error & 0x01)
1283  dev->stats.rx_over_errors++;
1284  if (rx_error & 0x02)
1285  dev->stats.rx_length_errors++;
1286  if (rx_error & 0x04)
1287  dev->stats.rx_frame_errors++;
1288  if (rx_error & 0x08)
1289  dev->stats.rx_crc_errors++;
1290  if (rx_error & 0x10)
1291  dev->stats.rx_length_errors++;
1292  } else {
1293  /* The packet length: up to 4.5K!. */
1294  short pkt_len = rx_status & 0x1fff;
1295  struct sk_buff *skb;
1296 
1297  skb = netdev_alloc_skb(dev, pkt_len + 5 + 2);
1298  if (corkscrew_debug > 4)
1299  pr_debug("Receiving packet size %d status %4.4x.\n",
1300  pkt_len, rx_status);
1301  if (skb != NULL) {
1302  skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1303  /* 'skb_put()' points to the start of sk_buff data area. */
1304  insl(ioaddr + RX_FIFO,
1305  skb_put(skb, pkt_len),
1306  (pkt_len + 3) >> 2);
1307  outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1308  skb->protocol = eth_type_trans(skb, dev);
1309  netif_rx(skb);
1310  dev->stats.rx_packets++;
1311  dev->stats.rx_bytes += pkt_len;
1312  /* Wait a limited time to go to next packet. */
1313  for (i = 200; i >= 0; i--)
1314  if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1315  break;
1316  continue;
1317  } else if (corkscrew_debug)
1318  pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1319  }
1320  outw(RxDiscard, ioaddr + EL3_CMD);
1321  dev->stats.rx_dropped++;
1322  /* Wait a limited time to skip this packet. */
1323  for (i = 200; i >= 0; i--)
1324  if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1325  break;
1326  }
1327  return 0;
1328 }
1329 
1330 static int boomerang_rx(struct net_device *dev)
1331 {
1332  struct corkscrew_private *vp = netdev_priv(dev);
1333  int entry = vp->cur_rx % RX_RING_SIZE;
1334  int ioaddr = dev->base_addr;
1335  int rx_status;
1336 
1337  if (corkscrew_debug > 5)
1338  pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1339  inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1340  while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1341  if (rx_status & RxDError) { /* Error, update stats. */
1342  unsigned char rx_error = rx_status >> 16;
1343  if (corkscrew_debug > 2)
1344  pr_debug(" Rx error: status %2.2x.\n",
1345  rx_error);
1346  dev->stats.rx_errors++;
1347  if (rx_error & 0x01)
1348  dev->stats.rx_over_errors++;
1349  if (rx_error & 0x02)
1350  dev->stats.rx_length_errors++;
1351  if (rx_error & 0x04)
1352  dev->stats.rx_frame_errors++;
1353  if (rx_error & 0x08)
1354  dev->stats.rx_crc_errors++;
1355  if (rx_error & 0x10)
1356  dev->stats.rx_length_errors++;
1357  } else {
1358  /* The packet length: up to 4.5K!. */
1359  short pkt_len = rx_status & 0x1fff;
1360  struct sk_buff *skb;
1361 
1362  dev->stats.rx_bytes += pkt_len;
1363  if (corkscrew_debug > 4)
1364  pr_debug("Receiving packet size %d status %4.4x.\n",
1365  pkt_len, rx_status);
1366 
1367  /* Check if the packet is long enough to just accept without
1368  copying to a properly sized skbuff. */
1369  if (pkt_len < rx_copybreak &&
1370  (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) {
1371  skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1372  /* 'skb_put()' points to the start of sk_buff data area. */
1373  memcpy(skb_put(skb, pkt_len),
1374  isa_bus_to_virt(vp->rx_ring[entry].
1375  addr), pkt_len);
1376  rx_copy++;
1377  } else {
1378  void *temp;
1379  /* Pass up the skbuff already on the Rx ring. */
1380  skb = vp->rx_skbuff[entry];
1381  vp->rx_skbuff[entry] = NULL;
1382  temp = skb_put(skb, pkt_len);
1383  /* Remove this checking code for final release. */
1384  if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1385  pr_warning("%s: Warning -- the skbuff addresses do not match"
1386  " in boomerang_rx: %p vs. %p / %p.\n",
1387  dev->name,
1388  isa_bus_to_virt(vp->
1389  rx_ring[entry].
1390  addr), skb->head,
1391  temp);
1392  rx_nocopy++;
1393  }
1394  skb->protocol = eth_type_trans(skb, dev);
1395  netif_rx(skb);
1396  dev->stats.rx_packets++;
1397  }
1398  entry = (++vp->cur_rx) % RX_RING_SIZE;
1399  }
1400  /* Refill the Rx ring buffers. */
1401  for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1402  struct sk_buff *skb;
1403  entry = vp->dirty_rx % RX_RING_SIZE;
1404  if (vp->rx_skbuff[entry] == NULL) {
1405  skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
1406  if (skb == NULL)
1407  break; /* Bad news! */
1408  skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1409  vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1410  vp->rx_skbuff[entry] = skb;
1411  }
1412  vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1413  }
1414  return 0;
1415 }
1416 
1417 static int corkscrew_close(struct net_device *dev)
1418 {
1419  struct corkscrew_private *vp = netdev_priv(dev);
1420  int ioaddr = dev->base_addr;
1421  int i;
1422 
1423  netif_stop_queue(dev);
1424 
1425  if (corkscrew_debug > 1) {
1426  pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1427  dev->name, inw(ioaddr + EL3_STATUS),
1428  inb(ioaddr + TxStatus));
1429  pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1430  dev->name, rx_nocopy, rx_copy, queued_packet);
1431  }
1432 
1433  del_timer(&vp->timer);
1434 
1435  /* Turn off statistics ASAP. We update lp->stats below. */
1436  outw(StatsDisable, ioaddr + EL3_CMD);
1437 
1438  /* Disable the receiver and transmitter. */
1439  outw(RxDisable, ioaddr + EL3_CMD);
1440  outw(TxDisable, ioaddr + EL3_CMD);
1441 
1442  if (dev->if_port == XCVR_10base2)
1443  /* Turn off thinnet power. Green! */
1444  outw(StopCoax, ioaddr + EL3_CMD);
1445 
1446  free_irq(dev->irq, dev);
1447 
1448  outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1449 
1450  update_stats(ioaddr, dev);
1451  if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1452  outl(0, ioaddr + UpListPtr);
1453  for (i = 0; i < RX_RING_SIZE; i++)
1454  if (vp->rx_skbuff[i]) {
1455  dev_kfree_skb(vp->rx_skbuff[i]);
1456  vp->rx_skbuff[i] = NULL;
1457  }
1458  }
1459  if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1460  outl(0, ioaddr + DownListPtr);
1461  for (i = 0; i < TX_RING_SIZE; i++)
1462  if (vp->tx_skbuff[i]) {
1463  dev_kfree_skb(vp->tx_skbuff[i]);
1464  vp->tx_skbuff[i] = NULL;
1465  }
1466  }
1467 
1468  return 0;
1469 }
1470 
1471 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1472 {
1473  struct corkscrew_private *vp = netdev_priv(dev);
1474  unsigned long flags;
1475 
1476  if (netif_running(dev)) {
1477  spin_lock_irqsave(&vp->lock, flags);
1478  update_stats(dev->base_addr, dev);
1479  spin_unlock_irqrestore(&vp->lock, flags);
1480  }
1481  return &dev->stats;
1482 }
1483 
1484 /* Update statistics.
1485  Unlike with the EL3 we need not worry about interrupts changing
1486  the window setting from underneath us, but we must still guard
1487  against a race condition with a StatsUpdate interrupt updating the
1488  table. This is done by checking that the ASM (!) code generated uses
1489  atomic updates with '+='.
1490  */
1491 static void update_stats(int ioaddr, struct net_device *dev)
1492 {
1493  /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1494  /* Switch to the stats window, and read everything. */
1495  EL3WINDOW(6);
1496  dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1497  dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1498  /* Multiple collisions. */ inb(ioaddr + 2);
1499  dev->stats.collisions += inb(ioaddr + 3);
1500  dev->stats.tx_window_errors += inb(ioaddr + 4);
1501  dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1502  dev->stats.tx_packets += inb(ioaddr + 6);
1503  dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1504  /* Rx packets */ inb(ioaddr + 7);
1505  /* Must read to clear */
1506  /* Tx deferrals */ inb(ioaddr + 8);
1507  /* Don't bother with register 9, an extension of registers 6&7.
1508  If we do use the 6&7 values the atomic update assumption above
1509  is invalid. */
1510  inw(ioaddr + 10); /* Total Rx and Tx octets. */
1511  inw(ioaddr + 12);
1512  /* New: On the Vortex we must also clear the BadSSD counter. */
1513  EL3WINDOW(4);
1514  inb(ioaddr + 12);
1515 
1516  /* We change back to window 7 (not 1) with the Vortex. */
1517  EL3WINDOW(7);
1518 }
1519 
1520 /* This new version of set_rx_mode() supports v1.4 kernels.
1521  The Vortex chip has no documented multicast filter, so the only
1522  multicast setting is to receive all multicast frames. At least
1523  the chip has a very clean way to set the mode, unlike many others. */
1524 static void set_rx_mode(struct net_device *dev)
1525 {
1526  int ioaddr = dev->base_addr;
1527  short new_mode;
1528 
1529  if (dev->flags & IFF_PROMISC) {
1530  if (corkscrew_debug > 3)
1531  pr_debug("%s: Setting promiscuous mode.\n",
1532  dev->name);
1533  new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1534  } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1535  new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1536  } else
1537  new_mode = SetRxFilter | RxStation | RxBroadcast;
1538 
1539  outw(new_mode, ioaddr + EL3_CMD);
1540 }
1541 
1542 static void netdev_get_drvinfo(struct net_device *dev,
1543  struct ethtool_drvinfo *info)
1544 {
1545  strcpy(info->driver, DRV_NAME);
1546  strcpy(info->version, DRV_VERSION);
1547  sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1548 }
1549 
1550 static u32 netdev_get_msglevel(struct net_device *dev)
1551 {
1552  return corkscrew_debug;
1553 }
1554 
1555 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1556 {
1557  corkscrew_debug = level;
1558 }
1559 
1560 static const struct ethtool_ops netdev_ethtool_ops = {
1561  .get_drvinfo = netdev_get_drvinfo,
1562  .get_msglevel = netdev_get_msglevel,
1563  .set_msglevel = netdev_set_msglevel,
1564 };
1565 
1566 
1567 #ifdef MODULE
1568 void cleanup_module(void)
1569 {
1570  while (!list_empty(&root_corkscrew_dev)) {
1571  struct net_device *dev;
1572  struct corkscrew_private *vp;
1573 
1574  vp = list_entry(root_corkscrew_dev.next,
1575  struct corkscrew_private, list);
1576  dev = vp->our_dev;
1577  unregister_netdev(dev);
1578  cleanup_card(dev);
1579  free_netdev(dev);
1580  }
1581 }
1582 #endif /* MODULE */