Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/net/ethernet/3com/3c574_cs.c

  1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
  2 
  3         Written 1993-1998 by
  4         Donald Becker, becker@scyld.com, (driver core) and
  5         David Hinds, dahinds@users.sourceforge.net (from his PC card code).
  6         Locking fixes (C) Copyright 2003 Red Hat Inc
  7 
  8         This software may be used and distributed according to the terms of
  9         the GNU General Public License, incorporated herein by reference.
 10 
 11         This driver derives from Donald Becker's 3c509 core, which has the
 12         following copyright:
 13         Copyright 1993 United States Government as represented by the
 14         Director, National Security Agency.
 15         
 16 
 17 */
 18 
 19 /*
 20                                 Theory of Operation
 21 
 22 I. Board Compatibility
 23 
 24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
 25 Adapter.
 26 
 27 II. Board-specific settings
 28 
 29 None -- PC cards are autoconfigured.
 30 
 31 III. Driver operation
 32 
 33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
 34 See the Boomerang driver and documentation for most details.
 35 
 36 IV. Notes and chip documentation.
 37 
 38 Two added registers are used to enhance PIO performance, RunnerRdCtrl and
 39 RunnerWrCtrl.  These are 11 bit down-counters that are preloaded with the
 40 count of word (16 bits) reads or writes the driver is about to do to the Rx
 41 or Tx FIFO.  The chip is then able to hide the internal-PCI-bus to PC-card
 42 translation latency by buffering the I/O operations with an 8 word FIFO.
 43 Note: No other chip accesses are permitted when this buffer is used.
 44 
 45 A second enhancement is that both attribute and common memory space
 46 0x0800-0x0fff can translated to the PIO FIFO.  Thus memory operations (faster
 47 with *some* PCcard bridges) may be used instead of I/O operations.
 48 This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
 49 
 50 Some slow PC card bridges work better if they never see a WAIT signal.
 51 This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
 52 Only do this after testing that it is reliable and improves performance.
 53 
 54 The upper five bits of RunnerRdCtrl are used to window into PCcard
 55 configuration space registers.  Window 0 is the regular Boomerang/Odie
 56 register set, 1-5 are various PC card control registers, and 16-31 are
 57 the (reversed!) CIS table.
 58 
 59 A final note: writing the InternalConfig register in window 3 with an
 60 invalid ramWidth is Very Bad.
 61 
 62 V. References
 63 
 64 http://www.scyld.com/expert/NWay.html
 65 http://www.national.com/opf/DP/DP83840A.html
 66 
 67 Thanks to Terry Murphy of 3Com for providing development information for
 68 earlier 3Com products.
 69 
 70 */
 71 
 72 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 73 
 74 #include <linux/module.h>
 75 #include <linux/kernel.h>
 76 #include <linux/slab.h>
 77 #include <linux/string.h>
 78 #include <linux/timer.h>
 79 #include <linux/interrupt.h>
 80 #include <linux/in.h>
 81 #include <linux/delay.h>
 82 #include <linux/netdevice.h>
 83 #include <linux/etherdevice.h>
 84 #include <linux/skbuff.h>
 85 #include <linux/if_arp.h>
 86 #include <linux/ioport.h>
 87 #include <linux/bitops.h>
 88 #include <linux/mii.h>
 89 
 90 #include <pcmcia/cistpl.h>
 91 #include <pcmcia/cisreg.h>
 92 #include <pcmcia/ciscode.h>
 93 #include <pcmcia/ds.h>
 94 
 95 #include <linux/uaccess.h>
 96 #include <asm/io.h>
 97 
 98 /*====================================================================*/
 99 
100 /* Module parameters */
101 
102 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
103 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
104 MODULE_LICENSE("GPL");
105 
106 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
107 
108 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
109 INT_MODULE_PARM(max_interrupt_work, 32);
110 
111 /* Force full duplex modes? */
112 INT_MODULE_PARM(full_duplex, 0);
113 
114 /* Autodetect link polarity reversal? */
115 INT_MODULE_PARM(auto_polarity, 1);
116 
117 
118 /*====================================================================*/
119 
120 /* Time in jiffies before concluding the transmitter is hung. */
121 #define TX_TIMEOUT  ((800*HZ)/1000)
122 
123 /* To minimize the size of the driver source and make the driver more
124    readable not all constants are symbolically defined.
125    You'll need the manual if you want to understand driver details anyway. */
126 /* Offsets from base I/O address. */
127 #define EL3_DATA        0x00
128 #define EL3_CMD         0x0e
129 #define EL3_STATUS      0x0e
130 
131 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
132 
133 /* The top five bits written to EL3_CMD are a command, the lower
134    11 bits are the parameter, if applicable. */
135 enum el3_cmds {
136         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
137         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
138         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
139         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
140         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
141         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
142         StatsDisable = 22<<11, StopCoax = 23<<11,
143 };
144 
145 enum elxl_status {
146         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
147         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
148         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
149 
150 /* The SetRxFilter command accepts the following classes: */
151 enum RxFilter {
152         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
153 };
154 
155 enum Window0 {
156         Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
157         IntrStatus=0x0E,                /* Valid in all windows. */
158 };
159 /* These assumes the larger EEPROM. */
160 enum Win0_EEPROM_cmds {
161         EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
162         EEPROM_EWENB = 0x30,            /* Enable erasing/writing for 10 msec. */
163         EEPROM_EWDIS = 0x00,            /* Disable EWENB before 10 msec timeout. */
164 };
165 
166 /* Register window 1 offsets, the window used in normal operation.
167    On the "Odie" this window is always mapped at offsets 0x10-0x1f.
168    Except for TxFree, which is overlapped by RunnerWrCtrl. */
169 enum Window1 {
170         TX_FIFO = 0x10,  RX_FIFO = 0x10,  RxErrors = 0x14,
171         RxStatus = 0x18,  Timer=0x1A, TxStatus = 0x1B,
172         TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
173         RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
174 };
175 
176 enum Window3 {                  /* Window 3: MAC/config bits. */
177         Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
178 };
179 enum wn3_config {
180         Ram_size = 7,
181         Ram_width = 8,
182         Ram_speed = 0x30,
183         Rom_size = 0xc0,
184         Ram_split_shift = 16,
185         Ram_split = 3 << Ram_split_shift,
186         Xcvr_shift = 20,
187         Xcvr = 7 << Xcvr_shift,
188         Autoselect = 0x1000000,
189 };
190 
191 enum Window4 {          /* Window 4: Xcvr/media bits. */
192         Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
193 };
194 
195 #define MEDIA_TP        0x00C0  /* Enable link beat and jabber for 10baseT. */
196 
197 struct el3_private {
198         struct pcmcia_device    *p_dev;
199         u16 advertising, partner;               /* NWay media advertisement */
200         unsigned char phys;                     /* MII device address */
201         unsigned int autoselect:1, default_media:3;     /* Read from the EEPROM/Wn3_Config. */
202         /* for transceiver monitoring */
203         struct timer_list media;
204         unsigned short media_status;
205         unsigned short fast_poll;
206         unsigned long last_irq;
207         spinlock_t window_lock;                 /* Guards the Window selection */
208 };
209 
210 /* Set iff a MII transceiver on any interface requires mdio preamble.
211    This only set with the original DP83840 on older 3c905 boards, so the extra
212    code size of a per-interface flag is not worthwhile. */
213 static char mii_preamble_required = 0;
214 
215 /* Index of functions. */
216 
217 static int tc574_config(struct pcmcia_device *link);
218 static void tc574_release(struct pcmcia_device *link);
219 
220 static void mdio_sync(unsigned int ioaddr, int bits);
221 static int mdio_read(unsigned int ioaddr, int phy_id, int location);
222 static void mdio_write(unsigned int ioaddr, int phy_id, int location,
223                        int value);
224 static unsigned short read_eeprom(unsigned int ioaddr, int index);
225 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
226 
227 static void tc574_reset(struct net_device *dev);
228 static void media_check(unsigned long arg);
229 static int el3_open(struct net_device *dev);
230 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
231                                         struct net_device *dev);
232 static irqreturn_t el3_interrupt(int irq, void *dev_id);
233 static void update_stats(struct net_device *dev);
234 static struct net_device_stats *el3_get_stats(struct net_device *dev);
235 static int el3_rx(struct net_device *dev, int worklimit);
236 static int el3_close(struct net_device *dev);
237 static void el3_tx_timeout(struct net_device *dev);
238 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
239 static void set_rx_mode(struct net_device *dev);
240 static void set_multicast_list(struct net_device *dev);
241 
242 static void tc574_detach(struct pcmcia_device *p_dev);
243 
244 /*
245         tc574_attach() creates an "instance" of the driver, allocating
246         local data structures for one device.  The device is registered
247         with Card Services.
248 */
249 static const struct net_device_ops el3_netdev_ops = {
250         .ndo_open               = el3_open,
251         .ndo_stop               = el3_close,
252         .ndo_start_xmit         = el3_start_xmit,
253         .ndo_tx_timeout         = el3_tx_timeout,
254         .ndo_get_stats          = el3_get_stats,
255         .ndo_do_ioctl           = el3_ioctl,
256         .ndo_set_rx_mode        = set_multicast_list,
257         .ndo_set_mac_address    = eth_mac_addr,
258         .ndo_validate_addr      = eth_validate_addr,
259 };
260 
261 static int tc574_probe(struct pcmcia_device *link)
262 {
263         struct el3_private *lp;
264         struct net_device *dev;
265 
266         dev_dbg(&link->dev, "3c574_attach()\n");
267 
268         /* Create the PC card device object. */
269         dev = alloc_etherdev(sizeof(struct el3_private));
270         if (!dev)
271                 return -ENOMEM;
272         lp = netdev_priv(dev);
273         link->priv = dev;
274         lp->p_dev = link;
275 
276         spin_lock_init(&lp->window_lock);
277         link->resource[0]->end = 32;
278         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
279         link->config_flags |= CONF_ENABLE_IRQ;
280         link->config_index = 1;
281 
282         dev->netdev_ops = &el3_netdev_ops;
283         dev->watchdog_timeo = TX_TIMEOUT;
284 
285         return tc574_config(link);
286 }
287 
288 static void tc574_detach(struct pcmcia_device *link)
289 {
290         struct net_device *dev = link->priv;
291 
292         dev_dbg(&link->dev, "3c574_detach()\n");
293 
294         unregister_netdev(dev);
295 
296         tc574_release(link);
297 
298         free_netdev(dev);
299 } /* tc574_detach */
300 
301 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
302 
303 static int tc574_config(struct pcmcia_device *link)
304 {
305         struct net_device *dev = link->priv;
306         struct el3_private *lp = netdev_priv(dev);
307         int ret, i, j;
308         unsigned int ioaddr;
309         __be16 *phys_addr;
310         char *cardname;
311         __u32 config;
312         u8 *buf;
313         size_t len;
314 
315         phys_addr = (__be16 *)dev->dev_addr;
316 
317         dev_dbg(&link->dev, "3c574_config()\n");
318 
319         link->io_lines = 16;
320 
321         for (i = j = 0; j < 0x400; j += 0x20) {
322                 link->resource[0]->start = j ^ 0x300;
323                 i = pcmcia_request_io(link);
324                 if (i == 0)
325                         break;
326         }
327         if (i != 0)
328                 goto failed;
329 
330         ret = pcmcia_request_irq(link, el3_interrupt);
331         if (ret)
332                 goto failed;
333 
334         ret = pcmcia_enable_device(link);
335         if (ret)
336                 goto failed;
337 
338         dev->irq = link->irq;
339         dev->base_addr = link->resource[0]->start;
340 
341         ioaddr = dev->base_addr;
342 
343         /* The 3c574 normally uses an EEPROM for configuration info, including
344            the hardware address.  The future products may include a modem chip
345            and put the address in the CIS. */
346 
347         len = pcmcia_get_tuple(link, 0x88, &buf);
348         if (buf && len >= 6) {
349                 for (i = 0; i < 3; i++)
350                         phys_addr[i] = htons(le16_to_cpu(buf[i * 2]));
351                 kfree(buf);
352         } else {
353                 kfree(buf); /* 0 < len < 6 */
354                 EL3WINDOW(0);
355                 for (i = 0; i < 3; i++)
356                         phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
357                 if (phys_addr[0] == htons(0x6060)) {
358                         pr_notice("IO port conflict at 0x%03lx-0x%03lx\n",
359                                   dev->base_addr, dev->base_addr+15);
360                         goto failed;
361                 }
362         }
363         if (link->prod_id[1])
364                 cardname = link->prod_id[1];
365         else
366                 cardname = "3Com 3c574";
367 
368         {
369                 u_char mcr;
370                 outw(2<<11, ioaddr + RunnerRdCtrl);
371                 mcr = inb(ioaddr + 2);
372                 outw(0<<11, ioaddr + RunnerRdCtrl);
373                 pr_info("  ASIC rev %d,", mcr>>3);
374                 EL3WINDOW(3);
375                 config = inl(ioaddr + Wn3_Config);
376                 lp->default_media = (config & Xcvr) >> Xcvr_shift;
377                 lp->autoselect = config & Autoselect ? 1 : 0;
378         }
379 
380         init_timer(&lp->media);
381 
382         {
383                 int phy;
384                 
385                 /* Roadrunner only: Turn on the MII transceiver */
386                 outw(0x8040, ioaddr + Wn3_Options);
387                 mdelay(1);
388                 outw(0xc040, ioaddr + Wn3_Options);
389                 tc574_wait_for_completion(dev, TxReset);
390                 tc574_wait_for_completion(dev, RxReset);
391                 mdelay(1);
392                 outw(0x8040, ioaddr + Wn3_Options);
393                 
394                 EL3WINDOW(4);
395                 for (phy = 1; phy <= 32; phy++) {
396                         int mii_status;
397                         mdio_sync(ioaddr, 32);
398                         mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
399                         if (mii_status != 0xffff) {
400                                 lp->phys = phy & 0x1f;
401                                 dev_dbg(&link->dev, "  MII transceiver at "
402                                         "index %d, status %x.\n",
403                                           phy, mii_status);
404                                 if ((mii_status & 0x0040) == 0)
405                                         mii_preamble_required = 1;
406                                 break;
407                         }
408                 }
409                 if (phy > 32) {
410                         pr_notice("  No MII transceivers found!\n");
411                         goto failed;
412                 }
413                 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
414                 mdio_write(ioaddr, lp->phys, 16, i);
415                 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
416                 if (full_duplex) {
417                         /* Only advertise the FD media types. */
418                         lp->advertising &= ~0x02a0;
419                         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
420                 }
421         }
422 
423         SET_NETDEV_DEV(dev, &link->dev);
424 
425         if (register_netdev(dev) != 0) {
426                 pr_notice("register_netdev() failed\n");
427                 goto failed;
428         }
429 
430         netdev_info(dev, "%s at io %#3lx, irq %d, hw_addr %pM\n",
431                     cardname, dev->base_addr, dev->irq, dev->dev_addr);
432         netdev_info(dev, " %dK FIFO split %s Rx:Tx, %sMII interface.\n",
433                     8 << (config & Ram_size),
434                     ram_split[(config & Ram_split) >> Ram_split_shift],
435                     config & Autoselect ? "autoselect " : "");
436 
437         return 0;
438 
439 failed:
440         tc574_release(link);
441         return -ENODEV;
442 
443 } /* tc574_config */
444 
445 static void tc574_release(struct pcmcia_device *link)
446 {
447         pcmcia_disable_device(link);
448 }
449 
450 static int tc574_suspend(struct pcmcia_device *link)
451 {
452         struct net_device *dev = link->priv;
453 
454         if (link->open)
455                 netif_device_detach(dev);
456 
457         return 0;
458 }
459 
460 static int tc574_resume(struct pcmcia_device *link)
461 {
462         struct net_device *dev = link->priv;
463 
464         if (link->open) {
465                 tc574_reset(dev);
466                 netif_device_attach(dev);
467         }
468 
469         return 0;
470 }
471 
472 static void dump_status(struct net_device *dev)
473 {
474         unsigned int ioaddr = dev->base_addr;
475         EL3WINDOW(1);
476         netdev_info(dev, "  irq status %04x, rx status %04x, tx status %02x, tx free %04x\n",
477                     inw(ioaddr+EL3_STATUS),
478                     inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
479                     inw(ioaddr+TxFree));
480         EL3WINDOW(4);
481         netdev_info(dev, "  diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
482                     inw(ioaddr+0x04), inw(ioaddr+0x06),
483                     inw(ioaddr+0x08), inw(ioaddr+0x0a));
484         EL3WINDOW(1);
485 }
486 
487 /*
488   Use this for commands that may take time to finish
489 */
490 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
491 {
492         int i = 1500;
493         outw(cmd, dev->base_addr + EL3_CMD);
494         while (--i > 0)
495                 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
496         if (i == 0)
497                 netdev_notice(dev, "command 0x%04x did not complete!\n", cmd);
498 }
499 
500 /* Read a word from the EEPROM using the regular EEPROM access register.
501    Assume that we are in register window zero.
502  */
503 static unsigned short read_eeprom(unsigned int ioaddr, int index)
504 {
505         int timer;
506         outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
507         /* Pause for at least 162 usec for the read to take place. */
508         for (timer = 1620; timer >= 0; timer--) {
509                 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
510                         break;
511         }
512         return inw(ioaddr + Wn0EepromData);
513 }
514 
515 /* MII transceiver control section.
516    Read and write the MII registers using software-generated serial
517    MDIO protocol.  See the MII specifications or DP83840A data sheet
518    for details.
519    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
520    slow PC card interface. */
521 
522 #define MDIO_SHIFT_CLK  0x01
523 #define MDIO_DIR_WRITE  0x04
524 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
525 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
526 #define MDIO_DATA_READ  0x02
527 #define MDIO_ENB_IN             0x00
528 
529 /* Generate the preamble required for initial synchronization and
530    a few older transceivers. */
531 static void mdio_sync(unsigned int ioaddr, int bits)
532 {
533         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
534 
535         /* Establish sync by sending at least 32 logic ones. */
536         while (-- bits >= 0) {
537                 outw(MDIO_DATA_WRITE1, mdio_addr);
538                 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
539         }
540 }
541 
542 static int mdio_read(unsigned int ioaddr, int phy_id, int location)
543 {
544         int i;
545         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
546         unsigned int retval = 0;
547         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
548 
549         if (mii_preamble_required)
550                 mdio_sync(ioaddr, 32);
551 
552         /* Shift the read command bits out. */
553         for (i = 14; i >= 0; i--) {
554                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
555                 outw(dataval, mdio_addr);
556                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
557         }
558         /* Read the two transition, 16 data, and wire-idle bits. */
559         for (i = 19; i > 0; i--) {
560                 outw(MDIO_ENB_IN, mdio_addr);
561                 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
562                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
563         }
564         return (retval>>1) & 0xffff;
565 }
566 
567 static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
568 {
569         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
570         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
571         int i;
572 
573         if (mii_preamble_required)
574                 mdio_sync(ioaddr, 32);
575 
576         /* Shift the command bits out. */
577         for (i = 31; i >= 0; i--) {
578                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
579                 outw(dataval, mdio_addr);
580                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
581         }
582         /* Leave the interface idle. */
583         for (i = 1; i >= 0; i--) {
584                 outw(MDIO_ENB_IN, mdio_addr);
585                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
586         }
587 }
588 
589 /* Reset and restore all of the 3c574 registers. */
590 static void tc574_reset(struct net_device *dev)
591 {
592         struct el3_private *lp = netdev_priv(dev);
593         int i;
594         unsigned int ioaddr = dev->base_addr;
595         unsigned long flags;
596 
597         tc574_wait_for_completion(dev, TotalReset|0x10);
598 
599         spin_lock_irqsave(&lp->window_lock, flags);
600         /* Clear any transactions in progress. */
601         outw(0, ioaddr + RunnerWrCtrl);
602         outw(0, ioaddr + RunnerRdCtrl);
603 
604         /* Set the station address and mask. */
605         EL3WINDOW(2);
606         for (i = 0; i < 6; i++)
607                 outb(dev->dev_addr[i], ioaddr + i);
608         for (; i < 12; i+=2)
609                 outw(0, ioaddr + i);
610 
611         /* Reset config options */
612         EL3WINDOW(3);
613         outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
614         outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
615                  ioaddr + Wn3_Config);
616         /* Roadrunner only: Turn on the MII transceiver. */
617         outw(0x8040, ioaddr + Wn3_Options);
618         mdelay(1);
619         outw(0xc040, ioaddr + Wn3_Options);
620         EL3WINDOW(1);
621         spin_unlock_irqrestore(&lp->window_lock, flags);
622         
623         tc574_wait_for_completion(dev, TxReset);
624         tc574_wait_for_completion(dev, RxReset);
625         mdelay(1);
626         spin_lock_irqsave(&lp->window_lock, flags);
627         EL3WINDOW(3);
628         outw(0x8040, ioaddr + Wn3_Options);
629 
630         /* Switch to the stats window, and clear all stats by reading. */
631         outw(StatsDisable, ioaddr + EL3_CMD);
632         EL3WINDOW(6);
633         for (i = 0; i < 10; i++)
634                 inb(ioaddr + i);
635         inw(ioaddr + 10);
636         inw(ioaddr + 12);
637         EL3WINDOW(4);
638         inb(ioaddr + 12);
639         inb(ioaddr + 13);
640 
641         /* .. enable any extra statistics bits.. */
642         outw(0x0040, ioaddr + Wn4_NetDiag);
643         
644         EL3WINDOW(1);
645         spin_unlock_irqrestore(&lp->window_lock, flags);
646         
647         /* .. re-sync MII and re-fill what NWay is advertising. */
648         mdio_sync(ioaddr, 32);
649         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
650         if (!auto_polarity) {
651                 /* works for TDK 78Q2120 series MII's */
652                 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
653                 mdio_write(ioaddr, lp->phys, 16, i);
654         }
655 
656         spin_lock_irqsave(&lp->window_lock, flags);
657         /* Switch to register set 1 for normal use, just for TxFree. */
658         set_rx_mode(dev);
659         spin_unlock_irqrestore(&lp->window_lock, flags);
660         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
661         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
662         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
663         /* Allow status bits to be seen. */
664         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
665         /* Ack all pending events, and set active indicator mask. */
666         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
667                  ioaddr + EL3_CMD);
668         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
669                  | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
670 }
671 
672 static int el3_open(struct net_device *dev)
673 {
674         struct el3_private *lp = netdev_priv(dev);
675         struct pcmcia_device *link = lp->p_dev;
676 
677         if (!pcmcia_dev_present(link))
678                 return -ENODEV;
679         
680         link->open++;
681         netif_start_queue(dev);
682         
683         tc574_reset(dev);
684         lp->media.function = media_check;
685         lp->media.data = (unsigned long) dev;
686         lp->media.expires = jiffies + HZ;
687         add_timer(&lp->media);
688         
689         dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
690                   dev->name, inw(dev->base_addr + EL3_STATUS));
691         
692         return 0;
693 }
694 
695 static void el3_tx_timeout(struct net_device *dev)
696 {
697         unsigned int ioaddr = dev->base_addr;
698         
699         netdev_notice(dev, "Transmit timed out!\n");
700         dump_status(dev);
701         dev->stats.tx_errors++;
702         netif_trans_update(dev); /* prevent tx timeout */
703         /* Issue TX_RESET and TX_START commands. */
704         tc574_wait_for_completion(dev, TxReset);
705         outw(TxEnable, ioaddr + EL3_CMD);
706         netif_wake_queue(dev);
707 }
708 
709 static void pop_tx_status(struct net_device *dev)
710 {
711         unsigned int ioaddr = dev->base_addr;
712         int i;
713     
714         /* Clear the Tx status stack. */
715         for (i = 32; i > 0; i--) {
716                 u_char tx_status = inb(ioaddr + TxStatus);
717                 if (!(tx_status & 0x84))
718                         break;
719                 /* reset transmitter on jabber error or underrun */
720                 if (tx_status & 0x30)
721                         tc574_wait_for_completion(dev, TxReset);
722                 if (tx_status & 0x38) {
723                         pr_debug("%s: transmit error: status 0x%02x\n",
724                                   dev->name, tx_status);
725                         outw(TxEnable, ioaddr + EL3_CMD);
726                         dev->stats.tx_aborted_errors++;
727                 }
728                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
729         }
730 }
731 
732 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
733                                         struct net_device *dev)
734 {
735         unsigned int ioaddr = dev->base_addr;
736         struct el3_private *lp = netdev_priv(dev);
737         unsigned long flags;
738 
739         pr_debug("%s: el3_start_xmit(length = %ld) called, "
740                   "status %4.4x.\n", dev->name, (long)skb->len,
741                   inw(ioaddr + EL3_STATUS));
742 
743         spin_lock_irqsave(&lp->window_lock, flags);
744 
745         dev->stats.tx_bytes += skb->len;
746 
747         /* Put out the doubleword header... */
748         outw(skb->len, ioaddr + TX_FIFO);
749         outw(0, ioaddr + TX_FIFO);
750         /* ... and the packet rounded to a doubleword. */
751         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
752 
753         /* TxFree appears only in Window 1, not offset 0x1c. */
754         if (inw(ioaddr + TxFree) <= 1536) {
755                 netif_stop_queue(dev);
756                 /* Interrupt us when the FIFO has room for max-sized packet. 
757                    The threshold is in units of dwords. */
758                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
759         }
760 
761         pop_tx_status(dev);
762         spin_unlock_irqrestore(&lp->window_lock, flags);
763         dev_kfree_skb(skb);
764         return NETDEV_TX_OK;
765 }
766 
767 /* The EL3 interrupt handler. */
768 static irqreturn_t el3_interrupt(int irq, void *dev_id)
769 {
770         struct net_device *dev = (struct net_device *) dev_id;
771         struct el3_private *lp = netdev_priv(dev);
772         unsigned int ioaddr;
773         unsigned status;
774         int work_budget = max_interrupt_work;
775         int handled = 0;
776 
777         if (!netif_device_present(dev))
778                 return IRQ_NONE;
779         ioaddr = dev->base_addr;
780 
781         pr_debug("%s: interrupt, status %4.4x.\n",
782                   dev->name, inw(ioaddr + EL3_STATUS));
783 
784         spin_lock(&lp->window_lock);
785         
786         while ((status = inw(ioaddr + EL3_STATUS)) &
787                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
788                 if (!netif_device_present(dev) ||
789                         ((status & 0xe000) != 0x2000)) {
790                         pr_debug("%s: Interrupt from dead card\n", dev->name);
791                         break;
792                 }
793 
794                 handled = 1;
795 
796                 if (status & RxComplete)
797                         work_budget = el3_rx(dev, work_budget);
798 
799                 if (status & TxAvailable) {
800                         pr_debug("  TX room bit was handled.\n");
801                         /* There's room in the FIFO for a full-sized packet. */
802                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
803                         netif_wake_queue(dev);
804                 }
805 
806                 if (status & TxComplete)
807                         pop_tx_status(dev);
808 
809                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
810                         /* Handle all uncommon interrupts. */
811                         if (status & StatsFull)
812                                 update_stats(dev);
813                         if (status & RxEarly) {
814                                 work_budget = el3_rx(dev, work_budget);
815                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
816                         }
817                         if (status & AdapterFailure) {
818                                 u16 fifo_diag;
819                                 EL3WINDOW(4);
820                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
821                                 EL3WINDOW(1);
822                                 netdev_notice(dev, "adapter failure, FIFO diagnostic register %04x\n",
823                                               fifo_diag);
824                                 if (fifo_diag & 0x0400) {
825                                         /* Tx overrun */
826                                         tc574_wait_for_completion(dev, TxReset);
827                                         outw(TxEnable, ioaddr + EL3_CMD);
828                                 }
829                                 if (fifo_diag & 0x2000) {
830                                         /* Rx underrun */
831                                         tc574_wait_for_completion(dev, RxReset);
832                                         set_rx_mode(dev);
833                                         outw(RxEnable, ioaddr + EL3_CMD);
834                                 }
835                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
836                         }
837                 }
838 
839                 if (--work_budget < 0) {
840                         pr_debug("%s: Too much work in interrupt, "
841                                   "status %4.4x.\n", dev->name, status);
842                         /* Clear all interrupts */
843                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
844                         break;
845                 }
846                 /* Acknowledge the IRQ. */
847                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
848         }
849 
850         pr_debug("%s: exiting interrupt, status %4.4x.\n",
851                   dev->name, inw(ioaddr + EL3_STATUS));
852                   
853         spin_unlock(&lp->window_lock);
854         return IRQ_RETVAL(handled);
855 }
856 
857 /*
858     This timer serves two purposes: to check for missed interrupts
859         (and as a last resort, poll the NIC for events), and to monitor
860         the MII, reporting changes in cable status.
861 */
862 static void media_check(unsigned long arg)
863 {
864         struct net_device *dev = (struct net_device *) arg;
865         struct el3_private *lp = netdev_priv(dev);
866         unsigned int ioaddr = dev->base_addr;
867         unsigned long flags;
868         unsigned short /* cable, */ media, partner;
869 
870         if (!netif_device_present(dev))
871                 goto reschedule;
872         
873         /* Check for pending interrupt with expired latency timer: with
874            this, we can limp along even if the interrupt is blocked */
875         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
876                 if (!lp->fast_poll)
877                         netdev_info(dev, "interrupt(s) dropped!\n");
878 
879                 local_irq_save(flags);
880                 el3_interrupt(dev->irq, dev);
881                 local_irq_restore(flags);
882 
883                 lp->fast_poll = HZ;
884         }
885         if (lp->fast_poll) {
886                 lp->fast_poll--;
887                 lp->media.expires = jiffies + 2*HZ/100;
888                 add_timer(&lp->media);
889                 return;
890         }
891 
892         spin_lock_irqsave(&lp->window_lock, flags);
893         EL3WINDOW(4);
894         media = mdio_read(ioaddr, lp->phys, 1);
895         partner = mdio_read(ioaddr, lp->phys, 5);
896         EL3WINDOW(1);
897         
898         if (media != lp->media_status) {
899                 if ((media ^ lp->media_status) & 0x0004)
900                         netdev_info(dev, "%s link beat\n",
901                                     (lp->media_status & 0x0004) ? "lost" : "found");
902                 if ((media ^ lp->media_status) & 0x0020) {
903                         lp->partner = 0;
904                         if (lp->media_status & 0x0020) {
905                                 netdev_info(dev, "autonegotiation restarted\n");
906                         } else if (partner) {
907                                 partner &= lp->advertising;
908                                 lp->partner = partner;
909                                 netdev_info(dev, "autonegotiation complete: "
910                                             "%dbaseT-%cD selected\n",
911                                             (partner & 0x0180) ? 100 : 10,
912                                             (partner & 0x0140) ? 'F' : 'H');
913                         } else {
914                                 netdev_info(dev, "link partner did not autonegotiate\n");
915                         }
916 
917                         EL3WINDOW(3);
918                         outb((partner & 0x0140 ? 0x20 : 0) |
919                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
920                         EL3WINDOW(1);
921 
922                 }
923                 if (media & 0x0010)
924                         netdev_info(dev, "remote fault detected\n");
925                 if (media & 0x0002)
926                         netdev_info(dev, "jabber detected\n");
927                 lp->media_status = media;
928         }
929         spin_unlock_irqrestore(&lp->window_lock, flags);
930 
931 reschedule:
932         lp->media.expires = jiffies + HZ;
933         add_timer(&lp->media);
934 }
935 
936 static struct net_device_stats *el3_get_stats(struct net_device *dev)
937 {
938         struct el3_private *lp = netdev_priv(dev);
939 
940         if (netif_device_present(dev)) {
941                 unsigned long flags;
942                 spin_lock_irqsave(&lp->window_lock, flags);
943                 update_stats(dev);
944                 spin_unlock_irqrestore(&lp->window_lock, flags);
945         }
946         return &dev->stats;
947 }
948 
949 /*  Update statistics.
950         Surprisingly this need not be run single-threaded, but it effectively is.
951         The counters clear when read, so the adds must merely be atomic.
952  */
953 static void update_stats(struct net_device *dev)
954 {
955         unsigned int ioaddr = dev->base_addr;
956         u8 rx, tx, up;
957 
958         pr_debug("%s: updating the statistics.\n", dev->name);
959 
960         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
961                 return;
962                 
963         /* Unlike the 3c509 we need not turn off stats updates while reading. */
964         /* Switch to the stats window, and read everything. */
965         EL3WINDOW(6);
966         dev->stats.tx_carrier_errors            += inb(ioaddr + 0);
967         dev->stats.tx_heartbeat_errors          += inb(ioaddr + 1);
968         /* Multiple collisions. */              inb(ioaddr + 2);
969         dev->stats.collisions                   += inb(ioaddr + 3);
970         dev->stats.tx_window_errors             += inb(ioaddr + 4);
971         dev->stats.rx_fifo_errors               += inb(ioaddr + 5);
972         dev->stats.tx_packets                   += inb(ioaddr + 6);
973         up                                       = inb(ioaddr + 9);
974         dev->stats.tx_packets                   += (up&0x30) << 4;
975         /* Rx packets   */                         inb(ioaddr + 7);
976         /* Tx deferrals */                         inb(ioaddr + 8);
977         rx                                       = inw(ioaddr + 10);
978         tx                                       = inw(ioaddr + 12);
979 
980         EL3WINDOW(4);
981         /* BadSSD */                               inb(ioaddr + 12);
982         up                                       = inb(ioaddr + 13);
983 
984         EL3WINDOW(1);
985 }
986 
987 static int el3_rx(struct net_device *dev, int worklimit)
988 {
989         unsigned int ioaddr = dev->base_addr;
990         short rx_status;
991         
992         pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
993                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
994         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
995                         worklimit > 0) {
996                 worklimit--;
997                 if (rx_status & 0x4000) { /* Error, update stats. */
998                         short error = rx_status & 0x3800;
999                         dev->stats.rx_errors++;
1000                         switch (error) {
1001                         case 0x0000:    dev->stats.rx_over_errors++; break;
1002                         case 0x0800:    dev->stats.rx_length_errors++; break;
1003                         case 0x1000:    dev->stats.rx_frame_errors++; break;
1004                         case 0x1800:    dev->stats.rx_length_errors++; break;
1005                         case 0x2000:    dev->stats.rx_frame_errors++; break;
1006                         case 0x2800:    dev->stats.rx_crc_errors++; break;
1007                         }
1008                 } else {
1009                         short pkt_len = rx_status & 0x7ff;
1010                         struct sk_buff *skb;
1011 
1012                         skb = netdev_alloc_skb(dev, pkt_len + 5);
1013 
1014                         pr_debug("  Receiving packet size %d status %4.4x.\n",
1015                                   pkt_len, rx_status);
1016                         if (skb != NULL) {
1017                                 skb_reserve(skb, 2);
1018                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1019                                                 ((pkt_len+3)>>2));
1020                                 skb->protocol = eth_type_trans(skb, dev);
1021                                 netif_rx(skb);
1022                                 dev->stats.rx_packets++;
1023                                 dev->stats.rx_bytes += pkt_len;
1024                         } else {
1025                                 pr_debug("%s: couldn't allocate a sk_buff of"
1026                                           " size %d.\n", dev->name, pkt_len);
1027                                 dev->stats.rx_dropped++;
1028                         }
1029                 }
1030                 tc574_wait_for_completion(dev, RxDiscard);
1031         }
1032 
1033         return worklimit;
1034 }
1035 
1036 /* Provide ioctl() calls to examine the MII xcvr state. */
1037 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1038 {
1039         struct el3_private *lp = netdev_priv(dev);
1040         unsigned int ioaddr = dev->base_addr;
1041         struct mii_ioctl_data *data = if_mii(rq);
1042         int phy = lp->phys & 0x1f;
1043 
1044         pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1045                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1046                   data->phy_id, data->reg_num, data->val_in, data->val_out);
1047 
1048         switch(cmd) {
1049         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1050                 data->phy_id = phy;
1051         case SIOCGMIIREG:               /* Read the specified MII register. */
1052                 {
1053                         int saved_window;
1054                         unsigned long flags;
1055 
1056                         spin_lock_irqsave(&lp->window_lock, flags);
1057                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1058                         EL3WINDOW(4);
1059                         data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1060                                                   data->reg_num & 0x1f);
1061                         EL3WINDOW(saved_window);
1062                         spin_unlock_irqrestore(&lp->window_lock, flags);
1063                         return 0;
1064                 }
1065         case SIOCSMIIREG:               /* Write the specified MII register */
1066                 {
1067                         int saved_window;
1068                        unsigned long flags;
1069 
1070                         spin_lock_irqsave(&lp->window_lock, flags);
1071                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1072                         EL3WINDOW(4);
1073                         mdio_write(ioaddr, data->phy_id & 0x1f,
1074                                    data->reg_num & 0x1f, data->val_in);
1075                         EL3WINDOW(saved_window);
1076                         spin_unlock_irqrestore(&lp->window_lock, flags);
1077                         return 0;
1078                 }
1079         default:
1080                 return -EOPNOTSUPP;
1081         }
1082 }
1083 
1084 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1085    documented.  Until it is we revert to receiving all multicast frames when
1086    any multicast reception is desired.
1087    Note: My other drivers emit a log message whenever promiscuous mode is
1088    entered to help detect password sniffers.  This is less desirable on
1089    typical PC card machines, so we omit the message.
1090    */
1091 
1092 static void set_rx_mode(struct net_device *dev)
1093 {
1094         unsigned int ioaddr = dev->base_addr;
1095 
1096         if (dev->flags & IFF_PROMISC)
1097                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1098                          ioaddr + EL3_CMD);
1099         else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1100                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1101         else
1102                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1103 }
1104 
1105 static void set_multicast_list(struct net_device *dev)
1106 {
1107         struct el3_private *lp = netdev_priv(dev);
1108         unsigned long flags;
1109 
1110         spin_lock_irqsave(&lp->window_lock, flags);
1111         set_rx_mode(dev);
1112         spin_unlock_irqrestore(&lp->window_lock, flags);
1113 }
1114 
1115 static int el3_close(struct net_device *dev)
1116 {
1117         unsigned int ioaddr = dev->base_addr;
1118         struct el3_private *lp = netdev_priv(dev);
1119         struct pcmcia_device *link = lp->p_dev;
1120 
1121         dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1122         
1123         if (pcmcia_dev_present(link)) {
1124                 unsigned long flags;
1125 
1126                 /* Turn off statistics ASAP.  We update lp->stats below. */
1127                 outw(StatsDisable, ioaddr + EL3_CMD);
1128                 
1129                 /* Disable the receiver and transmitter. */
1130                 outw(RxDisable, ioaddr + EL3_CMD);
1131                 outw(TxDisable, ioaddr + EL3_CMD);
1132                 
1133                 /* Note: Switching to window 0 may disable the IRQ. */
1134                 EL3WINDOW(0);
1135                 spin_lock_irqsave(&lp->window_lock, flags);
1136                 update_stats(dev);
1137                 spin_unlock_irqrestore(&lp->window_lock, flags);
1138 
1139                 /* force interrupts off */
1140                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1141         }
1142 
1143         link->open--;
1144         netif_stop_queue(dev);
1145         del_timer_sync(&lp->media);
1146 
1147         return 0;
1148 }
1149 
1150 static const struct pcmcia_device_id tc574_ids[] = {
1151         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1152         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1153         PCMCIA_DEVICE_NULL,
1154 };
1155 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1156 
1157 static struct pcmcia_driver tc574_driver = {
1158         .owner          = THIS_MODULE,
1159         .name           = "3c574_cs",
1160         .probe          = tc574_probe,
1161         .remove         = tc574_detach,
1162         .id_table       = tc574_ids,
1163         .suspend        = tc574_suspend,
1164         .resume         = tc574_resume,
1165 };
1166 module_pcmcia_driver(tc574_driver);
1167 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us