blob: 08c4dd896077b7199762821264c522cc721b065a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
22I. Board Compatibility
23
24This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
25Adapter.
26
27II. Board-specific settings
28
29None -- PC cards are autoconfigured.
30
31III. Driver operation
32
33The 3c574 uses a Boomerang-style interface, without the bus-master capability.
34See the Boomerang driver and documentation for most details.
35
36IV. Notes and chip documentation.
37
38Two added registers are used to enhance PIO performance, RunnerRdCtrl and
39RunnerWrCtrl. These are 11 bit down-counters that are preloaded with the
40count of word (16 bits) reads or writes the driver is about to do to the Rx
41or Tx FIFO. The chip is then able to hide the internal-PCI-bus to PC-card
42translation latency by buffering the I/O operations with an 8 word FIFO.
43Note: No other chip accesses are permitted when this buffer is used.
44
45A second enhancement is that both attribute and common memory space
460x0800-0x0fff can translated to the PIO FIFO. Thus memory operations (faster
47with *some* PCcard bridges) may be used instead of I/O operations.
48This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
49
50Some slow PC card bridges work better if they never see a WAIT signal.
51This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
52Only do this after testing that it is reliable and improves performance.
53
54The upper five bits of RunnerRdCtrl are used to window into PCcard
55configuration space registers. Window 0 is the regular Boomerang/Odie
56register set, 1-5 are various PC card control registers, and 16-31 are
57the (reversed!) CIS table.
58
59A final note: writing the InternalConfig register in window 3 with an
60invalid ramWidth is Very Bad.
61
62V. References
63
64http://www.scyld.com/expert/NWay.html
65http://www.national.com/pf/DP/DP83840.html
66
67Thanks to Terry Murphy of 3Com for providing development information for
68earlier 3Com products.
69
70*/
71
72#include <linux/module.h>
73#include <linux/kernel.h>
74#include <linux/init.h>
75#include <linux/slab.h>
76#include <linux/string.h>
77#include <linux/timer.h>
78#include <linux/interrupt.h>
79#include <linux/in.h>
80#include <linux/delay.h>
81#include <linux/netdevice.h>
82#include <linux/etherdevice.h>
83#include <linux/skbuff.h>
84#include <linux/if_arp.h>
85#include <linux/ioport.h>
86#include <linux/ethtool.h>
87#include <linux/bitops.h>
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#include <pcmcia/cs_types.h>
90#include <pcmcia/cs.h>
91#include <pcmcia/cistpl.h>
92#include <pcmcia/cisreg.h>
93#include <pcmcia/ciscode.h>
94#include <pcmcia/ds.h>
95#include <pcmcia/mem_op.h>
96
97#include <asm/uaccess.h>
98#include <asm/io.h>
99#include <asm/system.h>
100
101/*====================================================================*/
102
103/* Module parameters */
104
105MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
106MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
107MODULE_LICENSE("GPL");
108
109#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
110
111/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
112INT_MODULE_PARM(max_interrupt_work, 32);
113
114/* Force full duplex modes? */
115INT_MODULE_PARM(full_duplex, 0);
116
117/* Autodetect link polarity reversal? */
118INT_MODULE_PARM(auto_polarity, 1);
119
120#ifdef PCMCIA_DEBUG
121INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
122#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
123static char *version =
124"3c574_cs.c 1.65ac1 2003/04/07 Donald Becker/David Hinds, becker@scyld.com.\n";
125#else
126#define DEBUG(n, args...)
127#endif
128
129/*====================================================================*/
130
131/* Time in jiffies before concluding the transmitter is hung. */
132#define TX_TIMEOUT ((800*HZ)/1000)
133
134/* To minimize the size of the driver source and make the driver more
135 readable not all constants are symbolically defined.
136 You'll need the manual if you want to understand driver details anyway. */
137/* Offsets from base I/O address. */
138#define EL3_DATA 0x00
139#define EL3_CMD 0x0e
140#define EL3_STATUS 0x0e
141
142#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
143
144/* The top five bits written to EL3_CMD are a command, the lower
145 11 bits are the parameter, if applicable. */
146enum el3_cmds {
147 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
148 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
149 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
150 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
151 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
152 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
153 StatsDisable = 22<<11, StopCoax = 23<<11,
154};
155
156enum elxl_status {
157 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
158 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
159 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
160
161/* The SetRxFilter command accepts the following classes: */
162enum RxFilter {
163 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
164};
165
166enum Window0 {
167 Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
168 IntrStatus=0x0E, /* Valid in all windows. */
169};
170/* These assumes the larger EEPROM. */
171enum Win0_EEPROM_cmds {
172 EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
173 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
174 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
175};
176
177/* Register window 1 offsets, the window used in normal operation.
178 On the "Odie" this window is always mapped at offsets 0x10-0x1f.
179 Except for TxFree, which is overlapped by RunnerWrCtrl. */
180enum Window1 {
181 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
182 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
183 TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
184 RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
185};
186
187enum Window3 { /* Window 3: MAC/config bits. */
188 Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
189};
Al Virob6659822008-01-13 14:17:35 +0000190enum wn3_config {
191 Ram_size = 7,
192 Ram_width = 8,
193 Ram_speed = 0x30,
194 Rom_size = 0xc0,
195 Ram_split_shift = 16,
196 Ram_split = 3 << Ram_split_shift,
197 Xcvr_shift = 20,
198 Xcvr = 7 << Xcvr_shift,
199 Autoselect = 0x1000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200};
201
202enum Window4 { /* Window 4: Xcvr/media bits. */
203 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
204};
205
206#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
207
208struct el3_private {
Dominik Brodowskifd238232006-03-05 10:45:09 +0100209 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 dev_node_t node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 u16 advertising, partner; /* NWay media advertisement */
212 unsigned char phys; /* MII device address */
213 unsigned int autoselect:1, default_media:3; /* Read from the EEPROM/Wn3_Config. */
214 /* for transceiver monitoring */
215 struct timer_list media;
216 unsigned short media_status;
217 unsigned short fast_poll;
218 unsigned long last_irq;
219 spinlock_t window_lock; /* Guards the Window selection */
220};
221
222/* Set iff a MII transceiver on any interface requires mdio preamble.
223 This only set with the original DP83840 on older 3c905 boards, so the extra
224 code size of a per-interface flag is not worthwhile. */
225static char mii_preamble_required = 0;
226
227/* Index of functions. */
228
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200229static int tc574_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200230static void tc574_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Olof Johansson906da802008-02-04 22:27:35 -0800232static void mdio_sync(unsigned int ioaddr, int bits);
233static int mdio_read(unsigned int ioaddr, int phy_id, int location);
234static void mdio_write(unsigned int ioaddr, int phy_id, int location,
235 int value);
236static unsigned short read_eeprom(unsigned int ioaddr, int index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237static void tc574_wait_for_completion(struct net_device *dev, int cmd);
238
239static void tc574_reset(struct net_device *dev);
240static void media_check(unsigned long arg);
241static int el3_open(struct net_device *dev);
242static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100243static irqreturn_t el3_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244static void update_stats(struct net_device *dev);
245static struct net_device_stats *el3_get_stats(struct net_device *dev);
246static int el3_rx(struct net_device *dev, int worklimit);
247static int el3_close(struct net_device *dev);
248static void el3_tx_timeout(struct net_device *dev);
249static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
Jeff Garzik7282d492006-09-13 14:30:00 -0400250static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251static void set_rx_mode(struct net_device *dev);
252
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100253static void tc574_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255/*
256 tc574_attach() creates an "instance" of the driver, allocating
257 local data structures for one device. The device is registered
258 with Card Services.
259*/
260
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200261static int tc574_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 struct el3_private *lp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 DEBUG(0, "3c574_attach()\n");
267
268 /* Create the PC card device object. */
269 dev = alloc_etherdev(sizeof(struct el3_private));
270 if (!dev)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100271 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 link->priv = dev;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200274 lp->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 spin_lock_init(&lp->window_lock);
277 link->io.NumPorts1 = 32;
278 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
Komuro5e7bf8c2007-10-28 11:26:17 +0900279 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_HANDLE_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
281 link->irq.Handler = &el3_interrupt;
282 link->irq.Instance = dev;
283 link->conf.Attributes = CONF_ENABLE_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 link->conf.IntType = INT_MEMORY_AND_IO;
285 link->conf.ConfigIndex = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 /* The EL3-specific entries in the device structure. */
288 dev->hard_start_xmit = &el3_start_xmit;
289 dev->get_stats = &el3_get_stats;
290 dev->do_ioctl = &el3_ioctl;
291 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
292 dev->set_multicast_list = &set_rx_mode;
293 dev->open = &el3_open;
294 dev->stop = &el3_close;
295#ifdef HAVE_TX_TIMEOUT
296 dev->tx_timeout = el3_tx_timeout;
297 dev->watchdog_timeo = TX_TIMEOUT;
298#endif
299
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200300 return tc574_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301} /* tc574_attach */
302
303/*
304
305 This deletes a driver "instance". The device is de-registered
306 with Card Services. If it has been released, all local data
307 structures are freed. Otherwise, the structures will be freed
308 when the device is released.
309
310*/
311
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200312static void tc574_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
314 struct net_device *dev = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
316 DEBUG(0, "3c574_detach(0x%p)\n", link);
317
Dominik Brodowskifd238232006-03-05 10:45:09 +0100318 if (link->dev_node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 unregister_netdev(dev);
320
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100321 tc574_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 free_netdev(dev);
324} /* tc574_detach */
325
326/*
327 tc574_config() is scheduled to run after a CARD_INSERTION event
328 is received, to configure the PCMCIA socket, and to make the
329 ethernet device available to the system.
330*/
331
332#define CS_CHECK(fn, ret) \
333 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
334
Arjan van de Venf71e1302006-03-03 21:33:57 -0500335static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200337static int tc574_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 struct net_device *dev = link->priv;
340 struct el3_private *lp = netdev_priv(dev);
341 tuple_t tuple;
Al Virob1e247a2007-12-22 18:56:13 +0000342 __le16 buf[32];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 int last_fn, last_ret, i, j;
Olof Johansson906da802008-02-04 22:27:35 -0800344 unsigned int ioaddr;
Al Virob1e247a2007-12-22 18:56:13 +0000345 __be16 *phys_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 char *cardname;
Al Virob6659822008-01-13 14:17:35 +0000347 __u32 config;
Joe Perches0795af52007-10-03 17:59:30 -0700348 DECLARE_MAC_BUF(mac);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Al Virob1e247a2007-12-22 18:56:13 +0000350 phys_addr = (__be16 *)dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 DEBUG(0, "3c574_config(0x%p)\n", link);
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 link->io.IOAddrLines = 16;
355 for (i = j = 0; j < 0x400; j += 0x20) {
356 link->io.BasePort1 = j ^ 0x300;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200357 i = pcmcia_request_io(link, &link->io);
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200358 if (i == 0)
359 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 }
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200361 if (i != 0) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200362 cs_error(link, RequestIO, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 goto failed;
364 }
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200365 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
366 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 dev->irq = link->irq.AssignedIRQ;
369 dev->base_addr = link->io.BasePort1;
370
371 ioaddr = dev->base_addr;
372
373 /* The 3c574 normally uses an EEPROM for configuration info, including
374 the hardware address. The future products may include a modem chip
375 and put the address in the CIS. */
Dominik Brodowskiaf2b3b52006-10-25 21:49:27 -0400376 tuple.Attributes = 0;
377 tuple.TupleData = (cisdata_t *)buf;
378 tuple.TupleDataMax = 64;
379 tuple.TupleOffset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 tuple.DesiredTuple = 0x88;
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200381 if (pcmcia_get_first_tuple(link, &tuple) == 0) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200382 pcmcia_get_tuple_data(link, &tuple);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 for (i = 0; i < 3; i++)
Al Virob1e247a2007-12-22 18:56:13 +0000384 phys_addr[i] = htons(le16_to_cpu(buf[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 } else {
386 EL3WINDOW(0);
387 for (i = 0; i < 3; i++)
388 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
Al Virob1e247a2007-12-22 18:56:13 +0000389 if (phys_addr[0] == htons(0x6060)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
391 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
392 goto failed;
393 }
394 }
Dominik Brodowskia9606fd2006-06-04 18:06:13 +0200395 if (link->prod_id[1])
396 cardname = link->prod_id[1];
397 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 cardname = "3Com 3c574";
399
400 {
401 u_char mcr;
402 outw(2<<11, ioaddr + RunnerRdCtrl);
403 mcr = inb(ioaddr + 2);
404 outw(0<<11, ioaddr + RunnerRdCtrl);
405 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
406 EL3WINDOW(3);
Al Virob6659822008-01-13 14:17:35 +0000407 config = inl(ioaddr + Wn3_Config);
408 lp->default_media = (config & Xcvr) >> Xcvr_shift;
409 lp->autoselect = config & Autoselect ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 }
411
412 init_timer(&lp->media);
413
414 {
415 int phy;
416
417 /* Roadrunner only: Turn on the MII transceiver */
418 outw(0x8040, ioaddr + Wn3_Options);
419 mdelay(1);
420 outw(0xc040, ioaddr + Wn3_Options);
421 tc574_wait_for_completion(dev, TxReset);
422 tc574_wait_for_completion(dev, RxReset);
423 mdelay(1);
424 outw(0x8040, ioaddr + Wn3_Options);
425
426 EL3WINDOW(4);
427 for (phy = 1; phy <= 32; phy++) {
428 int mii_status;
429 mdio_sync(ioaddr, 32);
430 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
431 if (mii_status != 0xffff) {
432 lp->phys = phy & 0x1f;
433 DEBUG(0, " MII transceiver at index %d, status %x.\n",
434 phy, mii_status);
435 if ((mii_status & 0x0040) == 0)
436 mii_preamble_required = 1;
437 break;
438 }
439 }
440 if (phy > 32) {
441 printk(KERN_NOTICE " No MII transceivers found!\n");
442 goto failed;
443 }
444 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
445 mdio_write(ioaddr, lp->phys, 16, i);
446 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
447 if (full_duplex) {
448 /* Only advertise the FD media types. */
449 lp->advertising &= ~0x02a0;
450 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
451 }
452 }
453
Dominik Brodowskifd238232006-03-05 10:45:09 +0100454 link->dev_node = &lp->node;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200455 SET_NETDEV_DEV(dev, &handle_to_dev(link));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457 if (register_netdev(dev) != 0) {
458 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
Dominik Brodowskifd238232006-03-05 10:45:09 +0100459 link->dev_node = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 goto failed;
461 }
462
463 strcpy(lp->node.dev_name, dev->name);
464
Joe Perches0795af52007-10-03 17:59:30 -0700465 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, "
466 "hw_addr %s.\n",
467 dev->name, cardname, dev->base_addr, dev->irq,
468 print_mac(mac, dev->dev_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
Al Virob6659822008-01-13 14:17:35 +0000470 8 << config & Ram_size,
471 ram_split[(config & Ram_split) >> Ram_split_shift],
472 config & Autoselect ? "autoselect " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200474 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476cs_failed:
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200477 cs_error(link, last_fn, last_ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478failed:
479 tc574_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200480 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482} /* tc574_config */
483
484/*
485 After a card is removed, tc574_release() will unregister the net
486 device, and release the PCMCIA configuration. If the device is
487 still open, this will be postponed until it is closed.
488*/
489
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200490static void tc574_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200492 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493}
494
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200495static int tc574_suspend(struct pcmcia_device *link)
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100496{
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100497 struct net_device *dev = link->priv;
498
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100499 if (link->open)
Dominik Brodowski8661bb52006-03-02 00:02:33 +0100500 netif_device_detach(dev);
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100501
502 return 0;
503}
504
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200505static int tc574_resume(struct pcmcia_device *link)
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100506{
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100507 struct net_device *dev = link->priv;
508
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100509 if (link->open) {
Dominik Brodowski8661bb52006-03-02 00:02:33 +0100510 tc574_reset(dev);
511 netif_device_attach(dev);
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100512 }
513
514 return 0;
515}
516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517static void dump_status(struct net_device *dev)
518{
Olof Johansson906da802008-02-04 22:27:35 -0800519 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 EL3WINDOW(1);
521 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
522 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
523 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
524 inw(ioaddr+TxFree));
525 EL3WINDOW(4);
526 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
527 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
528 inw(ioaddr+0x08), inw(ioaddr+0x0a));
529 EL3WINDOW(1);
530}
531
532/*
533 Use this for commands that may take time to finish
534*/
535static void tc574_wait_for_completion(struct net_device *dev, int cmd)
536{
537 int i = 1500;
538 outw(cmd, dev->base_addr + EL3_CMD);
539 while (--i > 0)
540 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
541 if (i == 0)
542 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
543}
544
545/* Read a word from the EEPROM using the regular EEPROM access register.
546 Assume that we are in register window zero.
547 */
Olof Johansson906da802008-02-04 22:27:35 -0800548static unsigned short read_eeprom(unsigned int ioaddr, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
550 int timer;
551 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
552 /* Pause for at least 162 usec for the read to take place. */
553 for (timer = 1620; timer >= 0; timer--) {
554 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
555 break;
556 }
557 return inw(ioaddr + Wn0EepromData);
558}
559
560/* MII transceiver control section.
561 Read and write the MII registers using software-generated serial
562 MDIO protocol. See the MII specifications or DP83840A data sheet
563 for details.
564 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
565 slow PC card interface. */
566
567#define MDIO_SHIFT_CLK 0x01
568#define MDIO_DIR_WRITE 0x04
569#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
570#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
571#define MDIO_DATA_READ 0x02
572#define MDIO_ENB_IN 0x00
573
574/* Generate the preamble required for initial synchronization and
575 a few older transceivers. */
Olof Johansson906da802008-02-04 22:27:35 -0800576static void mdio_sync(unsigned int ioaddr, int bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
Olof Johansson906da802008-02-04 22:27:35 -0800578 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 /* Establish sync by sending at least 32 logic ones. */
581 while (-- bits >= 0) {
582 outw(MDIO_DATA_WRITE1, mdio_addr);
583 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
584 }
585}
586
Olof Johansson906da802008-02-04 22:27:35 -0800587static int mdio_read(unsigned int ioaddr, int phy_id, int location)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588{
589 int i;
590 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
591 unsigned int retval = 0;
Olof Johansson906da802008-02-04 22:27:35 -0800592 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
594 if (mii_preamble_required)
595 mdio_sync(ioaddr, 32);
596
597 /* Shift the read command bits out. */
598 for (i = 14; i >= 0; i--) {
599 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
600 outw(dataval, mdio_addr);
601 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
602 }
603 /* Read the two transition, 16 data, and wire-idle bits. */
604 for (i = 19; i > 0; i--) {
605 outw(MDIO_ENB_IN, mdio_addr);
606 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
607 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
608 }
609 return (retval>>1) & 0xffff;
610}
611
Olof Johansson906da802008-02-04 22:27:35 -0800612static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
614 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
Olof Johansson906da802008-02-04 22:27:35 -0800615 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 int i;
617
618 if (mii_preamble_required)
619 mdio_sync(ioaddr, 32);
620
621 /* Shift the command bits out. */
622 for (i = 31; i >= 0; i--) {
623 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
624 outw(dataval, mdio_addr);
625 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
626 }
627 /* Leave the interface idle. */
628 for (i = 1; i >= 0; i--) {
629 outw(MDIO_ENB_IN, mdio_addr);
630 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
631 }
632
633 return;
634}
635
636/* Reset and restore all of the 3c574 registers. */
637static void tc574_reset(struct net_device *dev)
638{
639 struct el3_private *lp = netdev_priv(dev);
640 int i;
Olof Johansson906da802008-02-04 22:27:35 -0800641 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 unsigned long flags;
643
644 tc574_wait_for_completion(dev, TotalReset|0x10);
645
646 spin_lock_irqsave(&lp->window_lock, flags);
647 /* Clear any transactions in progress. */
648 outw(0, ioaddr + RunnerWrCtrl);
649 outw(0, ioaddr + RunnerRdCtrl);
650
651 /* Set the station address and mask. */
652 EL3WINDOW(2);
653 for (i = 0; i < 6; i++)
654 outb(dev->dev_addr[i], ioaddr + i);
655 for (; i < 12; i+=2)
656 outw(0, ioaddr + i);
657
658 /* Reset config options */
659 EL3WINDOW(3);
660 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
661 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
662 ioaddr + Wn3_Config);
663 /* Roadrunner only: Turn on the MII transceiver. */
664 outw(0x8040, ioaddr + Wn3_Options);
665 mdelay(1);
666 outw(0xc040, ioaddr + Wn3_Options);
667 EL3WINDOW(1);
668 spin_unlock_irqrestore(&lp->window_lock, flags);
669
670 tc574_wait_for_completion(dev, TxReset);
671 tc574_wait_for_completion(dev, RxReset);
672 mdelay(1);
673 spin_lock_irqsave(&lp->window_lock, flags);
674 EL3WINDOW(3);
675 outw(0x8040, ioaddr + Wn3_Options);
676
677 /* Switch to the stats window, and clear all stats by reading. */
678 outw(StatsDisable, ioaddr + EL3_CMD);
679 EL3WINDOW(6);
680 for (i = 0; i < 10; i++)
681 inb(ioaddr + i);
682 inw(ioaddr + 10);
683 inw(ioaddr + 12);
684 EL3WINDOW(4);
685 inb(ioaddr + 12);
686 inb(ioaddr + 13);
687
688 /* .. enable any extra statistics bits.. */
689 outw(0x0040, ioaddr + Wn4_NetDiag);
690
691 EL3WINDOW(1);
692 spin_unlock_irqrestore(&lp->window_lock, flags);
693
694 /* .. re-sync MII and re-fill what NWay is advertising. */
695 mdio_sync(ioaddr, 32);
696 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
697 if (!auto_polarity) {
698 /* works for TDK 78Q2120 series MII's */
Richard Knutsson1569d9e2008-02-04 22:27:39 -0800699 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 mdio_write(ioaddr, lp->phys, 16, i);
701 }
702
703 spin_lock_irqsave(&lp->window_lock, flags);
704 /* Switch to register set 1 for normal use, just for TxFree. */
705 set_rx_mode(dev);
706 spin_unlock_irqrestore(&lp->window_lock, flags);
707 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
708 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
709 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
710 /* Allow status bits to be seen. */
711 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
712 /* Ack all pending events, and set active indicator mask. */
713 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
714 ioaddr + EL3_CMD);
715 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
716 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
717}
718
719static int el3_open(struct net_device *dev)
720{
721 struct el3_private *lp = netdev_priv(dev);
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200722 struct pcmcia_device *link = lp->p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
Dominik Brodowski9940ec32006-03-05 11:04:33 +0100724 if (!pcmcia_dev_present(link))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 return -ENODEV;
726
727 link->open++;
728 netif_start_queue(dev);
729
730 tc574_reset(dev);
731 lp->media.function = &media_check;
732 lp->media.data = (unsigned long) dev;
733 lp->media.expires = jiffies + HZ;
734 add_timer(&lp->media);
735
736 DEBUG(2, "%s: opened, status %4.4x.\n",
737 dev->name, inw(dev->base_addr + EL3_STATUS));
738
739 return 0;
740}
741
742static void el3_tx_timeout(struct net_device *dev)
743{
Olof Johansson906da802008-02-04 22:27:35 -0800744 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
747 dump_status(dev);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +0300748 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 dev->trans_start = jiffies;
750 /* Issue TX_RESET and TX_START commands. */
751 tc574_wait_for_completion(dev, TxReset);
752 outw(TxEnable, ioaddr + EL3_CMD);
753 netif_wake_queue(dev);
754}
755
756static void pop_tx_status(struct net_device *dev)
757{
Olof Johansson906da802008-02-04 22:27:35 -0800758 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 int i;
760
761 /* Clear the Tx status stack. */
762 for (i = 32; i > 0; i--) {
763 u_char tx_status = inb(ioaddr + TxStatus);
764 if (!(tx_status & 0x84))
765 break;
766 /* reset transmitter on jabber error or underrun */
767 if (tx_status & 0x30)
768 tc574_wait_for_completion(dev, TxReset);
769 if (tx_status & 0x38) {
770 DEBUG(1, "%s: transmit error: status 0x%02x\n",
771 dev->name, tx_status);
772 outw(TxEnable, ioaddr + EL3_CMD);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +0300773 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
775 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
776 }
777}
778
779static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
780{
Olof Johansson906da802008-02-04 22:27:35 -0800781 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 struct el3_private *lp = netdev_priv(dev);
783 unsigned long flags;
784
785 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
786 "status %4.4x.\n", dev->name, (long)skb->len,
787 inw(ioaddr + EL3_STATUS));
788
789 spin_lock_irqsave(&lp->window_lock, flags);
790 outw(skb->len, ioaddr + TX_FIFO);
791 outw(0, ioaddr + TX_FIFO);
792 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
793
794 dev->trans_start = jiffies;
795
796 /* TxFree appears only in Window 1, not offset 0x1c. */
797 if (inw(ioaddr + TxFree) <= 1536) {
798 netif_stop_queue(dev);
799 /* Interrupt us when the FIFO has room for max-sized packet.
800 The threshold is in units of dwords. */
801 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
802 }
803
804 pop_tx_status(dev);
805 spin_unlock_irqrestore(&lp->window_lock, flags);
806 dev_kfree_skb(skb);
807 return 0;
808}
809
810/* The EL3 interrupt handler. */
David Howells7d12e782006-10-05 14:55:46 +0100811static irqreturn_t el3_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
813 struct net_device *dev = (struct net_device *) dev_id;
814 struct el3_private *lp = netdev_priv(dev);
Olof Johansson906da802008-02-04 22:27:35 -0800815 unsigned int ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 unsigned status;
817 int work_budget = max_interrupt_work;
818 int handled = 0;
819
820 if (!netif_device_present(dev))
821 return IRQ_NONE;
822 ioaddr = dev->base_addr;
823
824 DEBUG(3, "%s: interrupt, status %4.4x.\n",
825 dev->name, inw(ioaddr + EL3_STATUS));
826
827 spin_lock(&lp->window_lock);
828
829 while ((status = inw(ioaddr + EL3_STATUS)) &
830 (IntLatch | RxComplete | RxEarly | StatsFull)) {
831 if (!netif_device_present(dev) ||
832 ((status & 0xe000) != 0x2000)) {
833 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
834 break;
835 }
836
837 handled = 1;
838
839 if (status & RxComplete)
840 work_budget = el3_rx(dev, work_budget);
841
842 if (status & TxAvailable) {
843 DEBUG(3, " TX room bit was handled.\n");
844 /* There's room in the FIFO for a full-sized packet. */
845 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
846 netif_wake_queue(dev);
847 }
848
849 if (status & TxComplete)
850 pop_tx_status(dev);
851
852 if (status & (AdapterFailure | RxEarly | StatsFull)) {
853 /* Handle all uncommon interrupts. */
854 if (status & StatsFull)
855 update_stats(dev);
856 if (status & RxEarly) {
857 work_budget = el3_rx(dev, work_budget);
858 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
859 }
860 if (status & AdapterFailure) {
861 u16 fifo_diag;
862 EL3WINDOW(4);
863 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
864 EL3WINDOW(1);
865 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
866 " register %04x.\n", dev->name, fifo_diag);
867 if (fifo_diag & 0x0400) {
868 /* Tx overrun */
869 tc574_wait_for_completion(dev, TxReset);
870 outw(TxEnable, ioaddr + EL3_CMD);
871 }
872 if (fifo_diag & 0x2000) {
873 /* Rx underrun */
874 tc574_wait_for_completion(dev, RxReset);
875 set_rx_mode(dev);
876 outw(RxEnable, ioaddr + EL3_CMD);
877 }
878 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
879 }
880 }
881
882 if (--work_budget < 0) {
883 DEBUG(0, "%s: Too much work in interrupt, "
884 "status %4.4x.\n", dev->name, status);
885 /* Clear all interrupts */
886 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
887 break;
888 }
889 /* Acknowledge the IRQ. */
890 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
891 }
892
893 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
894 dev->name, inw(ioaddr + EL3_STATUS));
895
896 spin_unlock(&lp->window_lock);
897 return IRQ_RETVAL(handled);
898}
899
900/*
901 This timer serves two purposes: to check for missed interrupts
902 (and as a last resort, poll the NIC for events), and to monitor
903 the MII, reporting changes in cable status.
904*/
905static void media_check(unsigned long arg)
906{
907 struct net_device *dev = (struct net_device *) arg;
908 struct el3_private *lp = netdev_priv(dev);
Olof Johansson906da802008-02-04 22:27:35 -0800909 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 unsigned long flags;
911 unsigned short /* cable, */ media, partner;
912
913 if (!netif_device_present(dev))
914 goto reschedule;
915
916 /* Check for pending interrupt with expired latency timer: with
917 this, we can limp along even if the interrupt is blocked */
918 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
919 if (!lp->fast_poll)
920 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
Komuroe363d132007-02-10 11:57:35 +0900921 el3_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 lp->fast_poll = HZ;
923 }
924 if (lp->fast_poll) {
925 lp->fast_poll--;
926 lp->media.expires = jiffies + 2*HZ/100;
927 add_timer(&lp->media);
928 return;
929 }
930
931 spin_lock_irqsave(&lp->window_lock, flags);
932 EL3WINDOW(4);
933 media = mdio_read(ioaddr, lp->phys, 1);
934 partner = mdio_read(ioaddr, lp->phys, 5);
935 EL3WINDOW(1);
936
937 if (media != lp->media_status) {
938 if ((media ^ lp->media_status) & 0x0004)
939 printk(KERN_INFO "%s: %s link beat\n", dev->name,
940 (lp->media_status & 0x0004) ? "lost" : "found");
941 if ((media ^ lp->media_status) & 0x0020) {
942 lp->partner = 0;
943 if (lp->media_status & 0x0020) {
944 printk(KERN_INFO "%s: autonegotiation restarted\n",
945 dev->name);
946 } else if (partner) {
947 partner &= lp->advertising;
948 lp->partner = partner;
949 printk(KERN_INFO "%s: autonegotiation complete: "
950 "%sbaseT-%cD selected\n", dev->name,
951 ((partner & 0x0180) ? "100" : "10"),
952 ((partner & 0x0140) ? 'F' : 'H'));
953 } else {
954 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
955 dev->name);
956 }
957
958 EL3WINDOW(3);
959 outb((partner & 0x0140 ? 0x20 : 0) |
960 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
961 EL3WINDOW(1);
962
963 }
964 if (media & 0x0010)
965 printk(KERN_INFO "%s: remote fault detected\n",
966 dev->name);
967 if (media & 0x0002)
968 printk(KERN_INFO "%s: jabber detected\n", dev->name);
969 lp->media_status = media;
970 }
971 spin_unlock_irqrestore(&lp->window_lock, flags);
972
973reschedule:
974 lp->media.expires = jiffies + HZ;
975 add_timer(&lp->media);
976}
977
978static struct net_device_stats *el3_get_stats(struct net_device *dev)
979{
980 struct el3_private *lp = netdev_priv(dev);
981
982 if (netif_device_present(dev)) {
983 unsigned long flags;
984 spin_lock_irqsave(&lp->window_lock, flags);
985 update_stats(dev);
986 spin_unlock_irqrestore(&lp->window_lock, flags);
987 }
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +0300988 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989}
990
991/* Update statistics.
992 Suprisingly this need not be run single-threaded, but it effectively is.
993 The counters clear when read, so the adds must merely be atomic.
994 */
995static void update_stats(struct net_device *dev)
996{
Olof Johansson906da802008-02-04 22:27:35 -0800997 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 u8 rx, tx, up;
999
1000 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1001
1002 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1003 return;
1004
1005 /* Unlike the 3c509 we need not turn off stats updates while reading. */
1006 /* Switch to the stats window, and read everything. */
1007 EL3WINDOW(6);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001008 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1009 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001011 dev->stats.collisions += inb(ioaddr + 3);
1012 dev->stats.tx_window_errors += inb(ioaddr + 4);
1013 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1014 dev->stats.tx_packets += inb(ioaddr + 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 up = inb(ioaddr + 9);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001016 dev->stats.tx_packets += (up&0x30) << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 /* Rx packets */ inb(ioaddr + 7);
1018 /* Tx deferrals */ inb(ioaddr + 8);
1019 rx = inw(ioaddr + 10);
1020 tx = inw(ioaddr + 12);
1021
1022 EL3WINDOW(4);
1023 /* BadSSD */ inb(ioaddr + 12);
1024 up = inb(ioaddr + 13);
1025
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001026 dev->stats.tx_bytes += tx + ((up & 0xf0) << 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
1028 EL3WINDOW(1);
1029}
1030
1031static int el3_rx(struct net_device *dev, int worklimit)
1032{
Olof Johansson906da802008-02-04 22:27:35 -08001033 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 short rx_status;
1035
1036 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1037 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1038 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1039 (--worklimit >= 0)) {
1040 if (rx_status & 0x4000) { /* Error, update stats. */
1041 short error = rx_status & 0x3800;
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001042 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 switch (error) {
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001044 case 0x0000: dev->stats.rx_over_errors++; break;
1045 case 0x0800: dev->stats.rx_length_errors++; break;
1046 case 0x1000: dev->stats.rx_frame_errors++; break;
1047 case 0x1800: dev->stats.rx_length_errors++; break;
1048 case 0x2000: dev->stats.rx_frame_errors++; break;
1049 case 0x2800: dev->stats.rx_crc_errors++; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 }
1051 } else {
1052 short pkt_len = rx_status & 0x7ff;
1053 struct sk_buff *skb;
1054
1055 skb = dev_alloc_skb(pkt_len+5);
1056
1057 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1058 pkt_len, rx_status);
1059 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 skb_reserve(skb, 2);
1061 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1062 ((pkt_len+3)>>2));
1063 skb->protocol = eth_type_trans(skb, dev);
1064 netif_rx(skb);
1065 dev->last_rx = jiffies;
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001066 dev->stats.rx_packets++;
1067 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 } else {
1069 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1070 " size %d.\n", dev->name, pkt_len);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001071 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
1073 }
1074 tc574_wait_for_completion(dev, RxDiscard);
1075 }
1076
1077 return worklimit;
1078}
1079
1080static void netdev_get_drvinfo(struct net_device *dev,
1081 struct ethtool_drvinfo *info)
1082{
1083 strcpy(info->driver, "3c574_cs");
1084}
1085
Jeff Garzik7282d492006-09-13 14:30:00 -04001086static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 .get_drvinfo = netdev_get_drvinfo,
1088};
1089
1090/* Provide ioctl() calls to examine the MII xcvr state. */
1091static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1092{
1093 struct el3_private *lp = netdev_priv(dev);
Olof Johansson906da802008-02-04 22:27:35 -08001094 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 u16 *data = (u16 *)&rq->ifr_ifru;
1096 int phy = lp->phys & 0x1f;
1097
1098 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1099 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1100 data[0], data[1], data[2], data[3]);
1101
1102 switch(cmd) {
1103 case SIOCGMIIPHY: /* Get the address of the PHY in use. */
1104 data[0] = phy;
1105 case SIOCGMIIREG: /* Read the specified MII register. */
1106 {
1107 int saved_window;
1108 unsigned long flags;
1109
1110 spin_lock_irqsave(&lp->window_lock, flags);
1111 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1112 EL3WINDOW(4);
1113 data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1114 EL3WINDOW(saved_window);
1115 spin_unlock_irqrestore(&lp->window_lock, flags);
1116 return 0;
1117 }
1118 case SIOCSMIIREG: /* Write the specified MII register */
1119 {
1120 int saved_window;
1121 unsigned long flags;
1122
1123 if (!capable(CAP_NET_ADMIN))
1124 return -EPERM;
1125 spin_lock_irqsave(&lp->window_lock, flags);
1126 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1127 EL3WINDOW(4);
1128 mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1129 EL3WINDOW(saved_window);
1130 spin_unlock_irqrestore(&lp->window_lock, flags);
1131 return 0;
1132 }
1133 default:
1134 return -EOPNOTSUPP;
1135 }
1136}
1137
1138/* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1139 documented. Until it is we revert to receiving all multicast frames when
1140 any multicast reception is desired.
1141 Note: My other drivers emit a log message whenever promiscuous mode is
1142 entered to help detect password sniffers. This is less desirable on
1143 typical PC card machines, so we omit the message.
1144 */
1145
1146static void set_rx_mode(struct net_device *dev)
1147{
Olof Johansson906da802008-02-04 22:27:35 -08001148 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
1150 if (dev->flags & IFF_PROMISC)
1151 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1152 ioaddr + EL3_CMD);
1153 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1154 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1155 else
1156 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1157}
1158
1159static int el3_close(struct net_device *dev)
1160{
Olof Johansson906da802008-02-04 22:27:35 -08001161 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 struct el3_private *lp = netdev_priv(dev);
Dominik Brodowskifba395e2006-03-31 17:21:06 +02001163 struct pcmcia_device *link = lp->p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1166
Dominik Brodowski9940ec32006-03-05 11:04:33 +01001167 if (pcmcia_dev_present(link)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 unsigned long flags;
1169
1170 /* Turn off statistics ASAP. We update lp->stats below. */
1171 outw(StatsDisable, ioaddr + EL3_CMD);
1172
1173 /* Disable the receiver and transmitter. */
1174 outw(RxDisable, ioaddr + EL3_CMD);
1175 outw(TxDisable, ioaddr + EL3_CMD);
1176
1177 /* Note: Switching to window 0 may disable the IRQ. */
1178 EL3WINDOW(0);
1179 spin_lock_irqsave(&lp->window_lock, flags);
1180 update_stats(dev);
1181 spin_unlock_irqrestore(&lp->window_lock, flags);
Daniel Ritzb9a6eaf2005-04-10 20:27:45 +02001182
1183 /* force interrupts off */
1184 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 }
1186
1187 link->open--;
1188 netif_stop_queue(dev);
1189 del_timer_sync(&lp->media);
1190
1191 return 0;
1192}
1193
Dominik Brodowski270b6e92005-06-27 16:28:18 -07001194static struct pcmcia_device_id tc574_ids[] = {
1195 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1196 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1197 PCMCIA_DEVICE_NULL,
1198};
1199MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1200
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201static struct pcmcia_driver tc574_driver = {
1202 .owner = THIS_MODULE,
1203 .drv = {
1204 .name = "3c574_cs",
1205 },
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02001206 .probe = tc574_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +01001207 .remove = tc574_detach,
Dominik Brodowski270b6e92005-06-27 16:28:18 -07001208 .id_table = tc574_ids,
Dominik Brodowski98e4c282005-11-14 21:21:18 +01001209 .suspend = tc574_suspend,
1210 .resume = tc574_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211};
1212
1213static int __init init_tc574(void)
1214{
1215 return pcmcia_register_driver(&tc574_driver);
1216}
1217
1218static void __exit exit_tc574(void)
1219{
1220 pcmcia_unregister_driver(&tc574_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221}
1222
1223module_init(init_tc574);
1224module_exit(exit_tc574);