Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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 <asm/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_change_mtu         = eth_change_mtu,
258         .ndo_set_mac_address    = eth_mac_addr,
259         .ndo_validate_addr      = eth_validate_addr,
260 };
261 
262 static int tc574_probe(struct pcmcia_device *link)
263 {
264         struct el3_private *lp;
265         struct net_device *dev;
266 
267         dev_dbg(&link->dev, "3c574_attach()\n");
268 
269         /* Create the PC card device object. */
270         dev = alloc_etherdev(sizeof(struct el3_private));
271         if (!dev)
272                 return -ENOMEM;
273         lp = netdev_priv(dev);
274         link->priv = dev;
275         lp->p_dev = link;
276 
277         spin_lock_init(&lp->window_lock);
278         link->resource[0]->end = 32;
279         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
280         link->config_flags |= CONF_ENABLE_IRQ;
281         link->config_index = 1;
282 
283         dev->netdev_ops = &el3_netdev_ops;
284         dev->watchdog_timeo = TX_TIMEOUT;
285 
286         return tc574_config(link);
287 }
288 
289 static void tc574_detach(struct pcmcia_device *link)
290 {
291         struct net_device *dev = link->priv;
292 
293         dev_dbg(&link->dev, "3c574_detach()\n");
294 
295         unregister_netdev(dev);
296 
297         tc574_release(link);
298 
299         free_netdev(dev);
300 } /* tc574_detach */
301 
302 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
303 
304 static int tc574_config(struct pcmcia_device *link)
305 {
306         struct net_device *dev = link->priv;
307         struct el3_private *lp = netdev_priv(dev);
308         int ret, i, j;
309         unsigned int ioaddr;
310         __be16 *phys_addr;
311         char *cardname;
312         __u32 config;
313         u8 *buf;
314         size_t len;
315 
316         phys_addr = (__be16 *)dev->dev_addr;
317 
318         dev_dbg(&link->dev, "3c574_config()\n");
319 
320         link->io_lines = 16;
321 
322         for (i = j = 0; j < 0x400; j += 0x20) {
323                 link->resource[0]->start = j ^ 0x300;
324                 i = pcmcia_request_io(link);
325                 if (i == 0)
326                         break;
327         }
328         if (i != 0)
329                 goto failed;
330 
331         ret = pcmcia_request_irq(link, el3_interrupt);
332         if (ret)
333                 goto failed;
334 
335         ret = pcmcia_enable_device(link);
336         if (ret)
337                 goto failed;
338 
339         dev->irq = link->irq;
340         dev->base_addr = link->resource[0]->start;
341 
342         ioaddr = dev->base_addr;
343 
344         /* The 3c574 normally uses an EEPROM for configuration info, including
345            the hardware address.  The future products may include a modem chip
346            and put the address in the CIS. */
347 
348         len = pcmcia_get_tuple(link, 0x88, &buf);
349         if (buf && len >= 6) {
350                 for (i = 0; i < 3; i++)
351                         phys_addr[i] = htons(le16_to_cpu(buf[i * 2]));
352                 kfree(buf);
353         } else {
354                 kfree(buf); /* 0 < len < 6 */
355                 EL3WINDOW(0);
356                 for (i = 0; i < 3; i++)
357                         phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
358                 if (phys_addr[0] == htons(0x6060)) {
359                         pr_notice("IO port conflict at 0x%03lx-0x%03lx\n",
360                                   dev->base_addr, dev->base_addr+15);
361                         goto failed;
362                 }
363         }
364         if (link->prod_id[1])
365                 cardname = link->prod_id[1];
366         else
367                 cardname = "3Com 3c574";
368 
369         {
370                 u_char mcr;
371                 outw(2<<11, ioaddr + RunnerRdCtrl);
372                 mcr = inb(ioaddr + 2);
373                 outw(0<<11, ioaddr + RunnerRdCtrl);
374                 pr_info("  ASIC rev %d,", mcr>>3);
375                 EL3WINDOW(3);
376                 config = inl(ioaddr + Wn3_Config);
377                 lp->default_media = (config & Xcvr) >> Xcvr_shift;
378                 lp->autoselect = config & Autoselect ? 1 : 0;
379         }
380 
381         init_timer(&lp->media);
382 
383         {
384                 int phy;
385                 
386                 /* Roadrunner only: Turn on the MII transceiver */
387                 outw(0x8040, ioaddr + Wn3_Options);
388                 mdelay(1);
389                 outw(0xc040, ioaddr + Wn3_Options);
390                 tc574_wait_for_completion(dev, TxReset);
391                 tc574_wait_for_completion(dev, RxReset);
392                 mdelay(1);
393                 outw(0x8040, ioaddr + Wn3_Options);
394                 
395                 EL3WINDOW(4);
396                 for (phy = 1; phy <= 32; phy++) {
397                         int mii_status;
398                         mdio_sync(ioaddr, 32);
399                         mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
400                         if (mii_status != 0xffff) {
401                                 lp->phys = phy & 0x1f;
402                                 dev_dbg(&link->dev, "  MII transceiver at "
403                                         "index %d, status %x.\n",
404                                           phy, mii_status);
405                                 if ((mii_status & 0x0040) == 0)
406                                         mii_preamble_required = 1;
407                                 break;
408                         }
409                 }
410                 if (phy > 32) {
411                         pr_notice("  No MII transceivers found!\n");
412                         goto failed;
413                 }
414                 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
415                 mdio_write(ioaddr, lp->phys, 16, i);
416                 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
417                 if (full_duplex) {
418                         /* Only advertise the FD media types. */
419                         lp->advertising &= ~0x02a0;
420                         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
421                 }
422         }
423 
424         SET_NETDEV_DEV(dev, &link->dev);
425 
426         if (register_netdev(dev) != 0) {
427                 pr_notice("register_netdev() failed\n");
428                 goto failed;
429         }
430 
431         netdev_info(dev, "%s at io %#3lx, irq %d, hw_addr %pM\n",
432                     cardname, dev->base_addr, dev->irq, dev->dev_addr);
433         netdev_info(dev, " %dK FIFO split %s Rx:Tx, %sMII interface.\n",
434                     8 << (config & Ram_size),
435                     ram_split[(config & Ram_split) >> Ram_split_shift],
436                     config & Autoselect ? "autoselect " : "");
437 
438         return 0;
439 
440 failed:
441         tc574_release(link);
442         return -ENODEV;
443 
444 } /* tc574_config */
445 
446 static void tc574_release(struct pcmcia_device *link)
447 {
448         pcmcia_disable_device(link);
449 }
450 
451 static int tc574_suspend(struct pcmcia_device *link)
452 {
453         struct net_device *dev = link->priv;
454 
455         if (link->open)
456                 netif_device_detach(dev);
457 
458         return 0;
459 }
460 
461 static int tc574_resume(struct pcmcia_device *link)
462 {
463         struct net_device *dev = link->priv;
464 
465         if (link->open) {
466                 tc574_reset(dev);
467                 netif_device_attach(dev);
468         }
469 
470         return 0;
471 }
472 
473 static void dump_status(struct net_device *dev)
474 {
475         unsigned int ioaddr = dev->base_addr;
476         EL3WINDOW(1);
477         netdev_info(dev, "  irq status %04x, rx status %04x, tx status %02x, tx free %04x\n",
478                     inw(ioaddr+EL3_STATUS),
479                     inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
480                     inw(ioaddr+TxFree));
481         EL3WINDOW(4);
482         netdev_info(dev, "  diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
483                     inw(ioaddr+0x04), inw(ioaddr+0x06),
484                     inw(ioaddr+0x08), inw(ioaddr+0x0a));
485         EL3WINDOW(1);
486 }
487 
488 /*
489   Use this for commands that may take time to finish
490 */
491 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
492 {
493         int i = 1500;
494         outw(cmd, dev->base_addr + EL3_CMD);
495         while (--i > 0)
496                 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
497         if (i == 0)
498                 netdev_notice(dev, "command 0x%04x did not complete!\n", cmd);
499 }
500 
501 /* Read a word from the EEPROM using the regular EEPROM access register.
502    Assume that we are in register window zero.
503  */
504 static unsigned short read_eeprom(unsigned int ioaddr, int index)
505 {
506         int timer;
507         outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
508         /* Pause for at least 162 usec for the read to take place. */
509         for (timer = 1620; timer >= 0; timer--) {
510                 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
511                         break;
512         }
513         return inw(ioaddr + Wn0EepromData);
514 }
515 
516 /* MII transceiver control section.
517    Read and write the MII registers using software-generated serial
518    MDIO protocol.  See the MII specifications or DP83840A data sheet
519    for details.
520    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
521    slow PC card interface. */
522 
523 #define MDIO_SHIFT_CLK  0x01
524 #define MDIO_DIR_WRITE  0x04
525 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
526 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
527 #define MDIO_DATA_READ  0x02
528 #define MDIO_ENB_IN             0x00
529 
530 /* Generate the preamble required for initial synchronization and
531    a few older transceivers. */
532 static void mdio_sync(unsigned int ioaddr, int bits)
533 {
534         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
535 
536         /* Establish sync by sending at least 32 logic ones. */
537         while (-- bits >= 0) {
538                 outw(MDIO_DATA_WRITE1, mdio_addr);
539                 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
540         }
541 }
542 
543 static int mdio_read(unsigned int ioaddr, int phy_id, int location)
544 {
545         int i;
546         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
547         unsigned int retval = 0;
548         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
549 
550         if (mii_preamble_required)
551                 mdio_sync(ioaddr, 32);
552 
553         /* Shift the read command bits out. */
554         for (i = 14; i >= 0; i--) {
555                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
556                 outw(dataval, mdio_addr);
557                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
558         }
559         /* Read the two transition, 16 data, and wire-idle bits. */
560         for (i = 19; i > 0; i--) {
561                 outw(MDIO_ENB_IN, mdio_addr);
562                 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
563                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
564         }
565         return (retval>>1) & 0xffff;
566 }
567 
568 static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
569 {
570         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
571         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
572         int i;
573 
574         if (mii_preamble_required)
575                 mdio_sync(ioaddr, 32);
576 
577         /* Shift the command bits out. */
578         for (i = 31; i >= 0; i--) {
579                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
580                 outw(dataval, mdio_addr);
581                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
582         }
583         /* Leave the interface idle. */
584         for (i = 1; i >= 0; i--) {
585                 outw(MDIO_ENB_IN, mdio_addr);
586                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
587         }
588 }
589 
590 /* Reset and restore all of the 3c574 registers. */
591 static void tc574_reset(struct net_device *dev)
592 {
593         struct el3_private *lp = netdev_priv(dev);
594         int i;
595         unsigned int ioaddr = dev->base_addr;
596         unsigned long flags;
597 
598         tc574_wait_for_completion(dev, TotalReset|0x10);
599 
600         spin_lock_irqsave(&lp->window_lock, flags);
601         /* Clear any transactions in progress. */
602         outw(0, ioaddr + RunnerWrCtrl);
603         outw(0, ioaddr + RunnerRdCtrl);
604 
605         /* Set the station address and mask. */
606         EL3WINDOW(2);
607         for (i = 0; i < 6; i++)
608                 outb(dev->dev_addr[i], ioaddr + i);
609         for (; i < 12; i+=2)
610                 outw(0, ioaddr + i);
611 
612         /* Reset config options */
613         EL3WINDOW(3);
614         outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
615         outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
616                  ioaddr + Wn3_Config);
617         /* Roadrunner only: Turn on the MII transceiver. */
618         outw(0x8040, ioaddr + Wn3_Options);
619         mdelay(1);
620         outw(0xc040, ioaddr + Wn3_Options);
621         EL3WINDOW(1);
622         spin_unlock_irqrestore(&lp->window_lock, flags);
623         
624         tc574_wait_for_completion(dev, TxReset);
625         tc574_wait_for_completion(dev, RxReset);
626         mdelay(1);
627         spin_lock_irqsave(&lp->window_lock, flags);
628         EL3WINDOW(3);
629         outw(0x8040, ioaddr + Wn3_Options);
630 
631         /* Switch to the stats window, and clear all stats by reading. */
632         outw(StatsDisable, ioaddr + EL3_CMD);
633         EL3WINDOW(6);
634         for (i = 0; i < 10; i++)
635                 inb(ioaddr + i);
636         inw(ioaddr + 10);
637         inw(ioaddr + 12);
638         EL3WINDOW(4);
639         inb(ioaddr + 12);
640         inb(ioaddr + 13);
641 
642         /* .. enable any extra statistics bits.. */
643         outw(0x0040, ioaddr + Wn4_NetDiag);
644         
645         EL3WINDOW(1);
646         spin_unlock_irqrestore(&lp->window_lock, flags);
647         
648         /* .. re-sync MII and re-fill what NWay is advertising. */
649         mdio_sync(ioaddr, 32);
650         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
651         if (!auto_polarity) {
652                 /* works for TDK 78Q2120 series MII's */
653                 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
654                 mdio_write(ioaddr, lp->phys, 16, i);
655         }
656 
657         spin_lock_irqsave(&lp->window_lock, flags);
658         /* Switch to register set 1 for normal use, just for TxFree. */
659         set_rx_mode(dev);
660         spin_unlock_irqrestore(&lp->window_lock, flags);
661         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
662         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
663         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
664         /* Allow status bits to be seen. */
665         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
666         /* Ack all pending events, and set active indicator mask. */
667         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
668                  ioaddr + EL3_CMD);
669         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
670                  | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
671 }
672 
673 static int el3_open(struct net_device *dev)
674 {
675         struct el3_private *lp = netdev_priv(dev);
676         struct pcmcia_device *link = lp->p_dev;
677 
678         if (!pcmcia_dev_present(link))
679                 return -ENODEV;
680         
681         link->open++;
682         netif_start_queue(dev);
683         
684         tc574_reset(dev);
685         lp->media.function = media_check;
686         lp->media.data = (unsigned long) dev;
687         lp->media.expires = jiffies + HZ;
688         add_timer(&lp->media);
689         
690         dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
691                   dev->name, inw(dev->base_addr + EL3_STATUS));
692         
693         return 0;
694 }
695 
696 static void el3_tx_timeout(struct net_device *dev)
697 {
698         unsigned int ioaddr = dev->base_addr;
699         
700         netdev_notice(dev, "Transmit timed out!\n");
701         dump_status(dev);
702         dev->stats.tx_errors++;
703         dev->trans_start = jiffies; /* prevent tx timeout */
704         /* Issue TX_RESET and TX_START commands. */
705         tc574_wait_for_completion(dev, TxReset);
706         outw(TxEnable, ioaddr + EL3_CMD);
707         netif_wake_queue(dev);
708 }
709 
710 static void pop_tx_status(struct net_device *dev)
711 {
712         unsigned int ioaddr = dev->base_addr;
713         int i;
714     
715         /* Clear the Tx status stack. */
716         for (i = 32; i > 0; i--) {
717                 u_char tx_status = inb(ioaddr + TxStatus);
718                 if (!(tx_status & 0x84))
719                         break;
720                 /* reset transmitter on jabber error or underrun */
721                 if (tx_status & 0x30)
722                         tc574_wait_for_completion(dev, TxReset);
723                 if (tx_status & 0x38) {
724                         pr_debug("%s: transmit error: status 0x%02x\n",
725                                   dev->name, tx_status);
726                         outw(TxEnable, ioaddr + EL3_CMD);
727                         dev->stats.tx_aborted_errors++;
728                 }
729                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
730         }
731 }
732 
733 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
734                                         struct net_device *dev)
735 {
736         unsigned int ioaddr = dev->base_addr;
737         struct el3_private *lp = netdev_priv(dev);
738         unsigned long flags;
739 
740         pr_debug("%s: el3_start_xmit(length = %ld) called, "
741                   "status %4.4x.\n", dev->name, (long)skb->len,
742                   inw(ioaddr + EL3_STATUS));
743 
744         spin_lock_irqsave(&lp->window_lock, flags);
745 
746         dev->stats.tx_bytes += skb->len;
747 
748         /* Put out the doubleword header... */
749         outw(skb->len, ioaddr + TX_FIFO);
750         outw(0, ioaddr + TX_FIFO);
751         /* ... and the packet rounded to a doubleword. */
752         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
753 
754         /* TxFree appears only in Window 1, not offset 0x1c. */
755         if (inw(ioaddr + TxFree) <= 1536) {
756                 netif_stop_queue(dev);
757                 /* Interrupt us when the FIFO has room for max-sized packet. 
758                    The threshold is in units of dwords. */
759                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
760         }
761 
762         pop_tx_status(dev);
763         spin_unlock_irqrestore(&lp->window_lock, flags);
764         dev_kfree_skb(skb);
765         return NETDEV_TX_OK;
766 }
767 
768 /* The EL3 interrupt handler. */
769 static irqreturn_t el3_interrupt(int irq, void *dev_id)
770 {
771         struct net_device *dev = (struct net_device *) dev_id;
772         struct el3_private *lp = netdev_priv(dev);
773         unsigned int ioaddr;
774         unsigned status;
775         int work_budget = max_interrupt_work;
776         int handled = 0;
777 
778         if (!netif_device_present(dev))
779                 return IRQ_NONE;
780         ioaddr = dev->base_addr;
781 
782         pr_debug("%s: interrupt, status %4.4x.\n",
783                   dev->name, inw(ioaddr + EL3_STATUS));
784 
785         spin_lock(&lp->window_lock);
786         
787         while ((status = inw(ioaddr + EL3_STATUS)) &
788                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
789                 if (!netif_device_present(dev) ||
790                         ((status & 0xe000) != 0x2000)) {
791                         pr_debug("%s: Interrupt from dead card\n", dev->name);
792                         break;
793                 }
794 
795                 handled = 1;
796 
797                 if (status & RxComplete)
798                         work_budget = el3_rx(dev, work_budget);
799 
800                 if (status & TxAvailable) {
801                         pr_debug("  TX room bit was handled.\n");
802                         /* There's room in the FIFO for a full-sized packet. */
803                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
804                         netif_wake_queue(dev);
805                 }
806 
807                 if (status & TxComplete)
808                         pop_tx_status(dev);
809 
810                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
811                         /* Handle all uncommon interrupts. */
812                         if (status & StatsFull)
813                                 update_stats(dev);
814                         if (status & RxEarly) {
815                                 work_budget = el3_rx(dev, work_budget);
816                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
817                         }
818                         if (status & AdapterFailure) {
819                                 u16 fifo_diag;
820                                 EL3WINDOW(4);
821                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
822                                 EL3WINDOW(1);
823                                 netdev_notice(dev, "adapter failure, FIFO diagnostic register %04x\n",
824                                               fifo_diag);
825                                 if (fifo_diag & 0x0400) {
826                                         /* Tx overrun */
827                                         tc574_wait_for_completion(dev, TxReset);
828                                         outw(TxEnable, ioaddr + EL3_CMD);
829                                 }
830                                 if (fifo_diag & 0x2000) {
831                                         /* Rx underrun */
832                                         tc574_wait_for_completion(dev, RxReset);
833                                         set_rx_mode(dev);
834                                         outw(RxEnable, ioaddr + EL3_CMD);
835                                 }
836                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
837                         }
838                 }
839 
840                 if (--work_budget < 0) {
841                         pr_debug("%s: Too much work in interrupt, "
842                                   "status %4.4x.\n", dev->name, status);
843                         /* Clear all interrupts */
844                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
845                         break;
846                 }
847                 /* Acknowledge the IRQ. */
848                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
849         }
850 
851         pr_debug("%s: exiting interrupt, status %4.4x.\n",
852                   dev->name, inw(ioaddr + EL3_STATUS));
853                   
854         spin_unlock(&lp->window_lock);
855         return IRQ_RETVAL(handled);
856 }
857 
858 /*
859     This timer serves two purposes: to check for missed interrupts
860         (and as a last resort, poll the NIC for events), and to monitor
861         the MII, reporting changes in cable status.
862 */
863 static void media_check(unsigned long arg)
864 {
865         struct net_device *dev = (struct net_device *) arg;
866         struct el3_private *lp = netdev_priv(dev);
867         unsigned int ioaddr = dev->base_addr;
868         unsigned long flags;
869         unsigned short /* cable, */ media, partner;
870 
871         if (!netif_device_present(dev))
872                 goto reschedule;
873         
874         /* Check for pending interrupt with expired latency timer: with
875            this, we can limp along even if the interrupt is blocked */
876         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
877                 if (!lp->fast_poll)
878                         netdev_info(dev, "interrupt(s) dropped!\n");
879 
880                 local_irq_save(flags);
881                 el3_interrupt(dev->irq, dev);
882                 local_irq_restore(flags);
883 
884                 lp->fast_poll = HZ;
885         }
886         if (lp->fast_poll) {
887                 lp->fast_poll--;
888                 lp->media.expires = jiffies + 2*HZ/100;
889                 add_timer(&lp->media);
890                 return;
891         }
892 
893         spin_lock_irqsave(&lp->window_lock, flags);
894         EL3WINDOW(4);
895         media = mdio_read(ioaddr, lp->phys, 1);
896         partner = mdio_read(ioaddr, lp->phys, 5);
897         EL3WINDOW(1);
898         
899         if (media != lp->media_status) {
900                 if ((media ^ lp->media_status) & 0x0004)
901                         netdev_info(dev, "%s link beat\n",
902                                     (lp->media_status & 0x0004) ? "lost" : "found");
903                 if ((media ^ lp->media_status) & 0x0020) {
904                         lp->partner = 0;
905                         if (lp->media_status & 0x0020) {
906                                 netdev_info(dev, "autonegotiation restarted\n");
907                         } else if (partner) {
908                                 partner &= lp->advertising;
909                                 lp->partner = partner;
910                                 netdev_info(dev, "autonegotiation complete: "
911                                             "%dbaseT-%cD selected\n",
912                                             (partner & 0x0180) ? 100 : 10,
913                                             (partner & 0x0140) ? 'F' : 'H');
914                         } else {
915                                 netdev_info(dev, "link partner did not autonegotiate\n");
916                         }
917 
918                         EL3WINDOW(3);
919                         outb((partner & 0x0140 ? 0x20 : 0) |
920                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
921                         EL3WINDOW(1);
922 
923                 }
924                 if (media & 0x0010)
925                         netdev_info(dev, "remote fault detected\n");
926                 if (media & 0x0002)
927                         netdev_info(dev, "jabber detected\n");
928                 lp->media_status = media;
929         }
930         spin_unlock_irqrestore(&lp->window_lock, flags);
931 
932 reschedule:
933         lp->media.expires = jiffies + HZ;
934         add_timer(&lp->media);
935 }
936 
937 static struct net_device_stats *el3_get_stats(struct net_device *dev)
938 {
939         struct el3_private *lp = netdev_priv(dev);
940 
941         if (netif_device_present(dev)) {
942                 unsigned long flags;
943                 spin_lock_irqsave(&lp->window_lock, flags);
944                 update_stats(dev);
945                 spin_unlock_irqrestore(&lp->window_lock, flags);
946         }
947         return &dev->stats;
948 }
949 
950 /*  Update statistics.
951         Surprisingly this need not be run single-threaded, but it effectively is.
952         The counters clear when read, so the adds must merely be atomic.
953  */
954 static void update_stats(struct net_device *dev)
955 {
956         unsigned int ioaddr = dev->base_addr;
957         u8 rx, tx, up;
958 
959         pr_debug("%s: updating the statistics.\n", dev->name);
960 
961         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
962                 return;
963                 
964         /* Unlike the 3c509 we need not turn off stats updates while reading. */
965         /* Switch to the stats window, and read everything. */
966         EL3WINDOW(6);
967         dev->stats.tx_carrier_errors            += inb(ioaddr + 0);
968         dev->stats.tx_heartbeat_errors          += inb(ioaddr + 1);
969         /* Multiple collisions. */              inb(ioaddr + 2);
970         dev->stats.collisions                   += inb(ioaddr + 3);
971         dev->stats.tx_window_errors             += inb(ioaddr + 4);
972         dev->stats.rx_fifo_errors               += inb(ioaddr + 5);
973         dev->stats.tx_packets                   += inb(ioaddr + 6);
974         up                                       = inb(ioaddr + 9);
975         dev->stats.tx_packets                   += (up&0x30) << 4;
976         /* Rx packets   */                         inb(ioaddr + 7);
977         /* Tx deferrals */                         inb(ioaddr + 8);
978         rx                                       = inw(ioaddr + 10);
979         tx                                       = inw(ioaddr + 12);
980 
981         EL3WINDOW(4);
982         /* BadSSD */                               inb(ioaddr + 12);
983         up                                       = inb(ioaddr + 13);
984 
985         EL3WINDOW(1);
986 }
987 
988 static int el3_rx(struct net_device *dev, int worklimit)
989 {
990         unsigned int ioaddr = dev->base_addr;
991         short rx_status;
992         
993         pr_debug("%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
994                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
995         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
996                         worklimit > 0) {
997                 worklimit--;
998                 if (rx_status & 0x4000) { /* Error, update stats. */
999                         short error = rx_status & 0x3800;
1000                         dev->stats.rx_errors++;
1001                         switch (error) {
1002                         case 0x0000:    dev->stats.rx_over_errors++; break;
1003                         case 0x0800:    dev->stats.rx_length_errors++; break;
1004                         case 0x1000:    dev->stats.rx_frame_errors++; break;
1005                         case 0x1800:    dev->stats.rx_length_errors++; break;
1006                         case 0x2000:    dev->stats.rx_frame_errors++; break;
1007                         case 0x2800:    dev->stats.rx_crc_errors++; break;
1008                         }
1009                 } else {
1010                         short pkt_len = rx_status & 0x7ff;
1011                         struct sk_buff *skb;
1012 
1013                         skb = netdev_alloc_skb(dev, pkt_len + 5);
1014 
1015                         pr_debug("  Receiving packet size %d status %4.4x.\n",
1016                                   pkt_len, rx_status);
1017                         if (skb != NULL) {
1018                                 skb_reserve(skb, 2);
1019                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1020                                                 ((pkt_len+3)>>2));
1021                                 skb->protocol = eth_type_trans(skb, dev);
1022                                 netif_rx(skb);
1023                                 dev->stats.rx_packets++;
1024                                 dev->stats.rx_bytes += pkt_len;
1025                         } else {
1026                                 pr_debug("%s: couldn't allocate a sk_buff of"
1027                                           " size %d.\n", dev->name, pkt_len);
1028                                 dev->stats.rx_dropped++;
1029                         }
1030                 }
1031                 tc574_wait_for_completion(dev, RxDiscard);
1032         }
1033 
1034         return worklimit;
1035 }
1036 
1037 /* Provide ioctl() calls to examine the MII xcvr state. */
1038 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1039 {
1040         struct el3_private *lp = netdev_priv(dev);
1041         unsigned int ioaddr = dev->base_addr;
1042         struct mii_ioctl_data *data = if_mii(rq);
1043         int phy = lp->phys & 0x1f;
1044 
1045         pr_debug("%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1046                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1047                   data->phy_id, data->reg_num, data->val_in, data->val_out);
1048 
1049         switch(cmd) {
1050         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1051                 data->phy_id = phy;
1052         case SIOCGMIIREG:               /* Read the specified MII register. */
1053                 {
1054                         int saved_window;
1055                         unsigned long flags;
1056 
1057                         spin_lock_irqsave(&lp->window_lock, flags);
1058                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1059                         EL3WINDOW(4);
1060                         data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1061                                                   data->reg_num & 0x1f);
1062                         EL3WINDOW(saved_window);
1063                         spin_unlock_irqrestore(&lp->window_lock, flags);
1064                         return 0;
1065                 }
1066         case SIOCSMIIREG:               /* Write the specified MII register */
1067                 {
1068                         int saved_window;
1069                        unsigned long flags;
1070 
1071                         spin_lock_irqsave(&lp->window_lock, flags);
1072                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1073                         EL3WINDOW(4);
1074                         mdio_write(ioaddr, data->phy_id & 0x1f,
1075                                    data->reg_num & 0x1f, data->val_in);
1076                         EL3WINDOW(saved_window);
1077                         spin_unlock_irqrestore(&lp->window_lock, flags);
1078                         return 0;
1079                 }
1080         default:
1081                 return -EOPNOTSUPP;
1082         }
1083 }
1084 
1085 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1086    documented.  Until it is we revert to receiving all multicast frames when
1087    any multicast reception is desired.
1088    Note: My other drivers emit a log message whenever promiscuous mode is
1089    entered to help detect password sniffers.  This is less desirable on
1090    typical PC card machines, so we omit the message.
1091    */
1092 
1093 static void set_rx_mode(struct net_device *dev)
1094 {
1095         unsigned int ioaddr = dev->base_addr;
1096 
1097         if (dev->flags & IFF_PROMISC)
1098                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1099                          ioaddr + EL3_CMD);
1100         else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
1101                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1102         else
1103                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1104 }
1105 
1106 static void set_multicast_list(struct net_device *dev)
1107 {
1108         struct el3_private *lp = netdev_priv(dev);
1109         unsigned long flags;
1110 
1111         spin_lock_irqsave(&lp->window_lock, flags);
1112         set_rx_mode(dev);
1113         spin_unlock_irqrestore(&lp->window_lock, flags);
1114 }
1115 
1116 static int el3_close(struct net_device *dev)
1117 {
1118         unsigned int ioaddr = dev->base_addr;
1119         struct el3_private *lp = netdev_priv(dev);
1120         struct pcmcia_device *link = lp->p_dev;
1121 
1122         dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
1123         
1124         if (pcmcia_dev_present(link)) {
1125                 unsigned long flags;
1126 
1127                 /* Turn off statistics ASAP.  We update lp->stats below. */
1128                 outw(StatsDisable, ioaddr + EL3_CMD);
1129                 
1130                 /* Disable the receiver and transmitter. */
1131                 outw(RxDisable, ioaddr + EL3_CMD);
1132                 outw(TxDisable, ioaddr + EL3_CMD);
1133                 
1134                 /* Note: Switching to window 0 may disable the IRQ. */
1135                 EL3WINDOW(0);
1136                 spin_lock_irqsave(&lp->window_lock, flags);
1137                 update_stats(dev);
1138                 spin_unlock_irqrestore(&lp->window_lock, flags);
1139 
1140                 /* force interrupts off */
1141                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1142         }
1143 
1144         link->open--;
1145         netif_stop_queue(dev);
1146         del_timer_sync(&lp->media);
1147 
1148         return 0;
1149 }
1150 
1151 static const struct pcmcia_device_id tc574_ids[] = {
1152         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1153         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1154         PCMCIA_DEVICE_NULL,
1155 };
1156 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1157 
1158 static struct pcmcia_driver tc574_driver = {
1159         .owner          = THIS_MODULE,
1160         .name           = "3c574_cs",
1161         .probe          = tc574_probe,
1162         .remove         = tc574_detach,
1163         .id_table       = tc574_ids,
1164         .suspend        = tc574_suspend,
1165         .resume         = tc574_resume,
1166 };
1167 module_pcmcia_driver(tc574_driver);
1168 

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