blob: 8f3872b8985d10fd72c51498c1cd987166fcb49b [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*/
Stephen Hemmingerfb72e2f2009-03-20 19:36:02 +0000260static const struct net_device_ops el3_netdev_ops = {
261 .ndo_open = el3_open,
262 .ndo_stop = el3_close,
263 .ndo_start_xmit = el3_start_xmit,
264 .ndo_tx_timeout = el3_tx_timeout,
265 .ndo_get_stats = el3_get_stats,
266 .ndo_do_ioctl = el3_ioctl,
267 .ndo_set_multicast_list = set_rx_mode,
268 .ndo_change_mtu = eth_change_mtu,
269 .ndo_set_mac_address = eth_mac_addr,
270 .ndo_validate_addr = eth_validate_addr,
271};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200273static int tc574_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
275 struct el3_private *lp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 DEBUG(0, "3c574_attach()\n");
279
280 /* Create the PC card device object. */
281 dev = alloc_etherdev(sizeof(struct el3_private));
282 if (!dev)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100283 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 link->priv = dev;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200286 lp->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 spin_lock_init(&lp->window_lock);
289 link->io.NumPorts1 = 32;
290 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
Komuro5e7bf8c2007-10-28 11:26:17 +0900291 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_HANDLE_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
293 link->irq.Handler = &el3_interrupt;
294 link->irq.Instance = dev;
295 link->conf.Attributes = CONF_ENABLE_IRQ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 link->conf.IntType = INT_MEMORY_AND_IO;
297 link->conf.ConfigIndex = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Stephen Hemmingerfb72e2f2009-03-20 19:36:02 +0000299 dev->netdev_ops = &el3_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 dev->watchdog_timeo = TX_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200303 return tc574_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304} /* tc574_attach */
305
306/*
307
308 This deletes a driver "instance". The device is de-registered
309 with Card Services. If it has been released, all local data
310 structures are freed. Otherwise, the structures will be freed
311 when the device is released.
312
313*/
314
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200315static void tc574_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
317 struct net_device *dev = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
319 DEBUG(0, "3c574_detach(0x%p)\n", link);
320
Dominik Brodowskifd238232006-03-05 10:45:09 +0100321 if (link->dev_node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 unregister_netdev(dev);
323
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100324 tc574_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 free_netdev(dev);
327} /* tc574_detach */
328
329/*
330 tc574_config() is scheduled to run after a CARD_INSERTION event
331 is received, to configure the PCMCIA socket, and to make the
332 ethernet device available to the system.
333*/
334
335#define CS_CHECK(fn, ret) \
336 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
337
Arjan van de Venf71e1302006-03-03 21:33:57 -0500338static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200340static int tc574_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct net_device *dev = link->priv;
343 struct el3_private *lp = netdev_priv(dev);
344 tuple_t tuple;
Al Virob1e247a2007-12-22 18:56:13 +0000345 __le16 buf[32];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 int last_fn, last_ret, i, j;
Olof Johansson906da802008-02-04 22:27:35 -0800347 unsigned int ioaddr;
Al Virob1e247a2007-12-22 18:56:13 +0000348 __be16 *phys_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 char *cardname;
Al Virob6659822008-01-13 14:17:35 +0000350 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Al Virob1e247a2007-12-22 18:56:13 +0000352 phys_addr = (__be16 *)dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 DEBUG(0, "3c574_config(0x%p)\n", link);
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 link->io.IOAddrLines = 16;
357 for (i = j = 0; j < 0x400; j += 0x20) {
358 link->io.BasePort1 = j ^ 0x300;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200359 i = pcmcia_request_io(link, &link->io);
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200360 if (i == 0)
361 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200363 if (i != 0) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200364 cs_error(link, RequestIO, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 goto failed;
366 }
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200367 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
368 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 dev->irq = link->irq.AssignedIRQ;
371 dev->base_addr = link->io.BasePort1;
372
373 ioaddr = dev->base_addr;
374
375 /* The 3c574 normally uses an EEPROM for configuration info, including
376 the hardware address. The future products may include a modem chip
377 and put the address in the CIS. */
Dominik Brodowskiaf2b3b52006-10-25 21:49:27 -0400378 tuple.Attributes = 0;
379 tuple.TupleData = (cisdata_t *)buf;
380 tuple.TupleDataMax = 64;
381 tuple.TupleOffset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 tuple.DesiredTuple = 0x88;
Dominik Brodowski4c89e882008-08-03 10:07:45 +0200383 if (pcmcia_get_first_tuple(link, &tuple) == 0) {
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200384 pcmcia_get_tuple_data(link, &tuple);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 for (i = 0; i < 3; i++)
Al Virob1e247a2007-12-22 18:56:13 +0000386 phys_addr[i] = htons(le16_to_cpu(buf[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 } else {
388 EL3WINDOW(0);
389 for (i = 0; i < 3; i++)
390 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
Al Virob1e247a2007-12-22 18:56:13 +0000391 if (phys_addr[0] == htons(0x6060)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
393 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
394 goto failed;
395 }
396 }
Dominik Brodowskia9606fd2006-06-04 18:06:13 +0200397 if (link->prod_id[1])
398 cardname = link->prod_id[1];
399 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 cardname = "3Com 3c574";
401
402 {
403 u_char mcr;
404 outw(2<<11, ioaddr + RunnerRdCtrl);
405 mcr = inb(ioaddr + 2);
406 outw(0<<11, ioaddr + RunnerRdCtrl);
407 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
408 EL3WINDOW(3);
Al Virob6659822008-01-13 14:17:35 +0000409 config = inl(ioaddr + Wn3_Config);
410 lp->default_media = (config & Xcvr) >> Xcvr_shift;
411 lp->autoselect = config & Autoselect ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413
414 init_timer(&lp->media);
415
416 {
417 int phy;
418
419 /* Roadrunner only: Turn on the MII transceiver */
420 outw(0x8040, ioaddr + Wn3_Options);
421 mdelay(1);
422 outw(0xc040, ioaddr + Wn3_Options);
423 tc574_wait_for_completion(dev, TxReset);
424 tc574_wait_for_completion(dev, RxReset);
425 mdelay(1);
426 outw(0x8040, ioaddr + Wn3_Options);
427
428 EL3WINDOW(4);
429 for (phy = 1; phy <= 32; phy++) {
430 int mii_status;
431 mdio_sync(ioaddr, 32);
432 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
433 if (mii_status != 0xffff) {
434 lp->phys = phy & 0x1f;
435 DEBUG(0, " MII transceiver at index %d, status %x.\n",
436 phy, mii_status);
437 if ((mii_status & 0x0040) == 0)
438 mii_preamble_required = 1;
439 break;
440 }
441 }
442 if (phy > 32) {
443 printk(KERN_NOTICE " No MII transceivers found!\n");
444 goto failed;
445 }
446 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
447 mdio_write(ioaddr, lp->phys, 16, i);
448 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
449 if (full_duplex) {
450 /* Only advertise the FD media types. */
451 lp->advertising &= ~0x02a0;
452 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
453 }
454 }
455
Dominik Brodowskifd238232006-03-05 10:45:09 +0100456 link->dev_node = &lp->node;
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200457 SET_NETDEV_DEV(dev, &handle_to_dev(link));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
459 if (register_netdev(dev) != 0) {
460 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
Dominik Brodowskifd238232006-03-05 10:45:09 +0100461 link->dev_node = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 goto failed;
463 }
464
465 strcpy(lp->node.dev_name, dev->name);
466
Joe Perches0795af52007-10-03 17:59:30 -0700467 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, "
Johannes Berge1749612008-10-27 15:59:26 -0700468 "hw_addr %pM.\n",
Joe Perches0795af52007-10-03 17:59:30 -0700469 dev->name, cardname, dev->base_addr, dev->irq,
Johannes Berge1749612008-10-27 15:59:26 -0700470 dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
Al Virob6659822008-01-13 14:17:35 +0000472 8 << config & Ram_size,
473 ram_split[(config & Ram_split) >> Ram_split_shift],
474 config & Autoselect ? "autoselect " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200476 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478cs_failed:
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200479 cs_error(link, last_fn, last_ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480failed:
481 tc574_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200482 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484} /* tc574_config */
485
486/*
487 After a card is removed, tc574_release() will unregister the net
488 device, and release the PCMCIA configuration. If the device is
489 still open, this will be postponed until it is closed.
490*/
491
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200492static void tc574_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493{
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200494 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495}
496
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200497static int tc574_suspend(struct pcmcia_device *link)
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100498{
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100499 struct net_device *dev = link->priv;
500
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100501 if (link->open)
Dominik Brodowski8661bb52006-03-02 00:02:33 +0100502 netif_device_detach(dev);
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100503
504 return 0;
505}
506
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200507static int tc574_resume(struct pcmcia_device *link)
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100508{
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100509 struct net_device *dev = link->priv;
510
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100511 if (link->open) {
Dominik Brodowski8661bb52006-03-02 00:02:33 +0100512 tc574_reset(dev);
513 netif_device_attach(dev);
Dominik Brodowski98e4c282005-11-14 21:21:18 +0100514 }
515
516 return 0;
517}
518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519static void dump_status(struct net_device *dev)
520{
Olof Johansson906da802008-02-04 22:27:35 -0800521 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 EL3WINDOW(1);
523 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
524 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
525 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
526 inw(ioaddr+TxFree));
527 EL3WINDOW(4);
528 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
529 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
530 inw(ioaddr+0x08), inw(ioaddr+0x0a));
531 EL3WINDOW(1);
532}
533
534/*
535 Use this for commands that may take time to finish
536*/
537static void tc574_wait_for_completion(struct net_device *dev, int cmd)
538{
539 int i = 1500;
540 outw(cmd, dev->base_addr + EL3_CMD);
541 while (--i > 0)
542 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
543 if (i == 0)
544 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
545}
546
547/* Read a word from the EEPROM using the regular EEPROM access register.
548 Assume that we are in register window zero.
549 */
Olof Johansson906da802008-02-04 22:27:35 -0800550static unsigned short read_eeprom(unsigned int ioaddr, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
552 int timer;
553 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
554 /* Pause for at least 162 usec for the read to take place. */
555 for (timer = 1620; timer >= 0; timer--) {
556 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
557 break;
558 }
559 return inw(ioaddr + Wn0EepromData);
560}
561
562/* MII transceiver control section.
563 Read and write the MII registers using software-generated serial
564 MDIO protocol. See the MII specifications or DP83840A data sheet
565 for details.
566 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
567 slow PC card interface. */
568
569#define MDIO_SHIFT_CLK 0x01
570#define MDIO_DIR_WRITE 0x04
571#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
572#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
573#define MDIO_DATA_READ 0x02
574#define MDIO_ENB_IN 0x00
575
576/* Generate the preamble required for initial synchronization and
577 a few older transceivers. */
Olof Johansson906da802008-02-04 22:27:35 -0800578static void mdio_sync(unsigned int ioaddr, int bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
Olof Johansson906da802008-02-04 22:27:35 -0800580 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 /* Establish sync by sending at least 32 logic ones. */
583 while (-- bits >= 0) {
584 outw(MDIO_DATA_WRITE1, mdio_addr);
585 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
586 }
587}
588
Olof Johansson906da802008-02-04 22:27:35 -0800589static int mdio_read(unsigned int ioaddr, int phy_id, int location)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590{
591 int i;
592 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
593 unsigned int retval = 0;
Olof Johansson906da802008-02-04 22:27:35 -0800594 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596 if (mii_preamble_required)
597 mdio_sync(ioaddr, 32);
598
599 /* Shift the read command bits out. */
600 for (i = 14; i >= 0; i--) {
601 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
602 outw(dataval, mdio_addr);
603 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
604 }
605 /* Read the two transition, 16 data, and wire-idle bits. */
606 for (i = 19; i > 0; i--) {
607 outw(MDIO_ENB_IN, mdio_addr);
608 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
609 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
610 }
611 return (retval>>1) & 0xffff;
612}
613
Olof Johansson906da802008-02-04 22:27:35 -0800614static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615{
616 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
Olof Johansson906da802008-02-04 22:27:35 -0800617 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 int i;
619
620 if (mii_preamble_required)
621 mdio_sync(ioaddr, 32);
622
623 /* Shift the command bits out. */
624 for (i = 31; i >= 0; i--) {
625 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
626 outw(dataval, mdio_addr);
627 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
628 }
629 /* Leave the interface idle. */
630 for (i = 1; i >= 0; i--) {
631 outw(MDIO_ENB_IN, mdio_addr);
632 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
633 }
634
635 return;
636}
637
638/* Reset and restore all of the 3c574 registers. */
639static void tc574_reset(struct net_device *dev)
640{
641 struct el3_private *lp = netdev_priv(dev);
642 int i;
Olof Johansson906da802008-02-04 22:27:35 -0800643 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 unsigned long flags;
645
646 tc574_wait_for_completion(dev, TotalReset|0x10);
647
648 spin_lock_irqsave(&lp->window_lock, flags);
649 /* Clear any transactions in progress. */
650 outw(0, ioaddr + RunnerWrCtrl);
651 outw(0, ioaddr + RunnerRdCtrl);
652
653 /* Set the station address and mask. */
654 EL3WINDOW(2);
655 for (i = 0; i < 6; i++)
656 outb(dev->dev_addr[i], ioaddr + i);
657 for (; i < 12; i+=2)
658 outw(0, ioaddr + i);
659
660 /* Reset config options */
661 EL3WINDOW(3);
662 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
663 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
664 ioaddr + Wn3_Config);
665 /* Roadrunner only: Turn on the MII transceiver. */
666 outw(0x8040, ioaddr + Wn3_Options);
667 mdelay(1);
668 outw(0xc040, ioaddr + Wn3_Options);
669 EL3WINDOW(1);
670 spin_unlock_irqrestore(&lp->window_lock, flags);
671
672 tc574_wait_for_completion(dev, TxReset);
673 tc574_wait_for_completion(dev, RxReset);
674 mdelay(1);
675 spin_lock_irqsave(&lp->window_lock, flags);
676 EL3WINDOW(3);
677 outw(0x8040, ioaddr + Wn3_Options);
678
679 /* Switch to the stats window, and clear all stats by reading. */
680 outw(StatsDisable, ioaddr + EL3_CMD);
681 EL3WINDOW(6);
682 for (i = 0; i < 10; i++)
683 inb(ioaddr + i);
684 inw(ioaddr + 10);
685 inw(ioaddr + 12);
686 EL3WINDOW(4);
687 inb(ioaddr + 12);
688 inb(ioaddr + 13);
689
690 /* .. enable any extra statistics bits.. */
691 outw(0x0040, ioaddr + Wn4_NetDiag);
692
693 EL3WINDOW(1);
694 spin_unlock_irqrestore(&lp->window_lock, flags);
695
696 /* .. re-sync MII and re-fill what NWay is advertising. */
697 mdio_sync(ioaddr, 32);
698 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
699 if (!auto_polarity) {
700 /* works for TDK 78Q2120 series MII's */
Richard Knutsson1569d9e2008-02-04 22:27:39 -0800701 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 mdio_write(ioaddr, lp->phys, 16, i);
703 }
704
705 spin_lock_irqsave(&lp->window_lock, flags);
706 /* Switch to register set 1 for normal use, just for TxFree. */
707 set_rx_mode(dev);
708 spin_unlock_irqrestore(&lp->window_lock, flags);
709 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
710 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
711 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
712 /* Allow status bits to be seen. */
713 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
714 /* Ack all pending events, and set active indicator mask. */
715 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
716 ioaddr + EL3_CMD);
717 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
718 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
719}
720
721static int el3_open(struct net_device *dev)
722{
723 struct el3_private *lp = netdev_priv(dev);
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200724 struct pcmcia_device *link = lp->p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Dominik Brodowski9940ec32006-03-05 11:04:33 +0100726 if (!pcmcia_dev_present(link))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return -ENODEV;
728
729 link->open++;
730 netif_start_queue(dev);
731
732 tc574_reset(dev);
733 lp->media.function = &media_check;
734 lp->media.data = (unsigned long) dev;
735 lp->media.expires = jiffies + HZ;
736 add_timer(&lp->media);
737
738 DEBUG(2, "%s: opened, status %4.4x.\n",
739 dev->name, inw(dev->base_addr + EL3_STATUS));
740
741 return 0;
742}
743
744static void el3_tx_timeout(struct net_device *dev)
745{
Olof Johansson906da802008-02-04 22:27:35 -0800746 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
749 dump_status(dev);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +0300750 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 dev->trans_start = jiffies;
752 /* Issue TX_RESET and TX_START commands. */
753 tc574_wait_for_completion(dev, TxReset);
754 outw(TxEnable, ioaddr + EL3_CMD);
755 netif_wake_queue(dev);
756}
757
758static void pop_tx_status(struct net_device *dev)
759{
Olof Johansson906da802008-02-04 22:27:35 -0800760 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 int i;
762
763 /* Clear the Tx status stack. */
764 for (i = 32; i > 0; i--) {
765 u_char tx_status = inb(ioaddr + TxStatus);
766 if (!(tx_status & 0x84))
767 break;
768 /* reset transmitter on jabber error or underrun */
769 if (tx_status & 0x30)
770 tc574_wait_for_completion(dev, TxReset);
771 if (tx_status & 0x38) {
772 DEBUG(1, "%s: transmit error: status 0x%02x\n",
773 dev->name, tx_status);
774 outw(TxEnable, ioaddr + EL3_CMD);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +0300775 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 }
777 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
778 }
779}
780
781static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
782{
Olof Johansson906da802008-02-04 22:27:35 -0800783 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 struct el3_private *lp = netdev_priv(dev);
785 unsigned long flags;
786
787 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
788 "status %4.4x.\n", dev->name, (long)skb->len,
789 inw(ioaddr + EL3_STATUS));
790
791 spin_lock_irqsave(&lp->window_lock, flags);
792 outw(skb->len, ioaddr + TX_FIFO);
793 outw(0, ioaddr + TX_FIFO);
794 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
795
796 dev->trans_start = jiffies;
797
798 /* TxFree appears only in Window 1, not offset 0x1c. */
799 if (inw(ioaddr + TxFree) <= 1536) {
800 netif_stop_queue(dev);
801 /* Interrupt us when the FIFO has room for max-sized packet.
802 The threshold is in units of dwords. */
803 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
804 }
805
806 pop_tx_status(dev);
807 spin_unlock_irqrestore(&lp->window_lock, flags);
808 dev_kfree_skb(skb);
809 return 0;
810}
811
812/* The EL3 interrupt handler. */
David Howells7d12e782006-10-05 14:55:46 +0100813static irqreturn_t el3_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
815 struct net_device *dev = (struct net_device *) dev_id;
816 struct el3_private *lp = netdev_priv(dev);
Olof Johansson906da802008-02-04 22:27:35 -0800817 unsigned int ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 unsigned status;
819 int work_budget = max_interrupt_work;
820 int handled = 0;
821
822 if (!netif_device_present(dev))
823 return IRQ_NONE;
824 ioaddr = dev->base_addr;
825
826 DEBUG(3, "%s: interrupt, status %4.4x.\n",
827 dev->name, inw(ioaddr + EL3_STATUS));
828
829 spin_lock(&lp->window_lock);
830
831 while ((status = inw(ioaddr + EL3_STATUS)) &
832 (IntLatch | RxComplete | RxEarly | StatsFull)) {
833 if (!netif_device_present(dev) ||
834 ((status & 0xe000) != 0x2000)) {
835 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
836 break;
837 }
838
839 handled = 1;
840
841 if (status & RxComplete)
842 work_budget = el3_rx(dev, work_budget);
843
844 if (status & TxAvailable) {
845 DEBUG(3, " TX room bit was handled.\n");
846 /* There's room in the FIFO for a full-sized packet. */
847 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
848 netif_wake_queue(dev);
849 }
850
851 if (status & TxComplete)
852 pop_tx_status(dev);
853
854 if (status & (AdapterFailure | RxEarly | StatsFull)) {
855 /* Handle all uncommon interrupts. */
856 if (status & StatsFull)
857 update_stats(dev);
858 if (status & RxEarly) {
859 work_budget = el3_rx(dev, work_budget);
860 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
861 }
862 if (status & AdapterFailure) {
863 u16 fifo_diag;
864 EL3WINDOW(4);
865 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
866 EL3WINDOW(1);
867 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
868 " register %04x.\n", dev->name, fifo_diag);
869 if (fifo_diag & 0x0400) {
870 /* Tx overrun */
871 tc574_wait_for_completion(dev, TxReset);
872 outw(TxEnable, ioaddr + EL3_CMD);
873 }
874 if (fifo_diag & 0x2000) {
875 /* Rx underrun */
876 tc574_wait_for_completion(dev, RxReset);
877 set_rx_mode(dev);
878 outw(RxEnable, ioaddr + EL3_CMD);
879 }
880 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
881 }
882 }
883
884 if (--work_budget < 0) {
885 DEBUG(0, "%s: Too much work in interrupt, "
886 "status %4.4x.\n", dev->name, status);
887 /* Clear all interrupts */
888 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
889 break;
890 }
891 /* Acknowledge the IRQ. */
892 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
893 }
894
895 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
896 dev->name, inw(ioaddr + EL3_STATUS));
897
898 spin_unlock(&lp->window_lock);
899 return IRQ_RETVAL(handled);
900}
901
902/*
903 This timer serves two purposes: to check for missed interrupts
904 (and as a last resort, poll the NIC for events), and to monitor
905 the MII, reporting changes in cable status.
906*/
907static void media_check(unsigned long arg)
908{
909 struct net_device *dev = (struct net_device *) arg;
910 struct el3_private *lp = netdev_priv(dev);
Olof Johansson906da802008-02-04 22:27:35 -0800911 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 unsigned long flags;
913 unsigned short /* cable, */ media, partner;
914
915 if (!netif_device_present(dev))
916 goto reschedule;
917
918 /* Check for pending interrupt with expired latency timer: with
919 this, we can limp along even if the interrupt is blocked */
920 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
921 if (!lp->fast_poll)
922 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
Komuroe363d132007-02-10 11:57:35 +0900923 el3_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 lp->fast_poll = HZ;
925 }
926 if (lp->fast_poll) {
927 lp->fast_poll--;
928 lp->media.expires = jiffies + 2*HZ/100;
929 add_timer(&lp->media);
930 return;
931 }
932
933 spin_lock_irqsave(&lp->window_lock, flags);
934 EL3WINDOW(4);
935 media = mdio_read(ioaddr, lp->phys, 1);
936 partner = mdio_read(ioaddr, lp->phys, 5);
937 EL3WINDOW(1);
938
939 if (media != lp->media_status) {
940 if ((media ^ lp->media_status) & 0x0004)
941 printk(KERN_INFO "%s: %s link beat\n", dev->name,
942 (lp->media_status & 0x0004) ? "lost" : "found");
943 if ((media ^ lp->media_status) & 0x0020) {
944 lp->partner = 0;
945 if (lp->media_status & 0x0020) {
946 printk(KERN_INFO "%s: autonegotiation restarted\n",
947 dev->name);
948 } else if (partner) {
949 partner &= lp->advertising;
950 lp->partner = partner;
951 printk(KERN_INFO "%s: autonegotiation complete: "
952 "%sbaseT-%cD selected\n", dev->name,
953 ((partner & 0x0180) ? "100" : "10"),
954 ((partner & 0x0140) ? 'F' : 'H'));
955 } else {
956 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
957 dev->name);
958 }
959
960 EL3WINDOW(3);
961 outb((partner & 0x0140 ? 0x20 : 0) |
962 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
963 EL3WINDOW(1);
964
965 }
966 if (media & 0x0010)
967 printk(KERN_INFO "%s: remote fault detected\n",
968 dev->name);
969 if (media & 0x0002)
970 printk(KERN_INFO "%s: jabber detected\n", dev->name);
971 lp->media_status = media;
972 }
973 spin_unlock_irqrestore(&lp->window_lock, flags);
974
975reschedule:
976 lp->media.expires = jiffies + HZ;
977 add_timer(&lp->media);
978}
979
980static struct net_device_stats *el3_get_stats(struct net_device *dev)
981{
982 struct el3_private *lp = netdev_priv(dev);
983
984 if (netif_device_present(dev)) {
985 unsigned long flags;
986 spin_lock_irqsave(&lp->window_lock, flags);
987 update_stats(dev);
988 spin_unlock_irqrestore(&lp->window_lock, flags);
989 }
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +0300990 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991}
992
993/* Update statistics.
994 Suprisingly this need not be run single-threaded, but it effectively is.
995 The counters clear when read, so the adds must merely be atomic.
996 */
997static void update_stats(struct net_device *dev)
998{
Olof Johansson906da802008-02-04 22:27:35 -0800999 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 u8 rx, tx, up;
1001
1002 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1003
1004 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1005 return;
1006
1007 /* Unlike the 3c509 we need not turn off stats updates while reading. */
1008 /* Switch to the stats window, and read everything. */
1009 EL3WINDOW(6);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001010 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1011 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001013 dev->stats.collisions += inb(ioaddr + 3);
1014 dev->stats.tx_window_errors += inb(ioaddr + 4);
1015 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1016 dev->stats.tx_packets += inb(ioaddr + 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 up = inb(ioaddr + 9);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001018 dev->stats.tx_packets += (up&0x30) << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 /* Rx packets */ inb(ioaddr + 7);
1020 /* Tx deferrals */ inb(ioaddr + 8);
1021 rx = inw(ioaddr + 10);
1022 tx = inw(ioaddr + 12);
1023
1024 EL3WINDOW(4);
1025 /* BadSSD */ inb(ioaddr + 12);
1026 up = inb(ioaddr + 13);
1027
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001028 dev->stats.tx_bytes += tx + ((up & 0xf0) << 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030 EL3WINDOW(1);
1031}
1032
1033static int el3_rx(struct net_device *dev, int worklimit)
1034{
Olof Johansson906da802008-02-04 22:27:35 -08001035 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 short rx_status;
1037
1038 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1039 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1040 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
Roel Kluinb9bdcd92009-03-04 00:05:56 -08001041 worklimit > 0) {
1042 worklimit--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 if (rx_status & 0x4000) { /* Error, update stats. */
1044 short error = rx_status & 0x3800;
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001045 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 switch (error) {
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001047 case 0x0000: dev->stats.rx_over_errors++; break;
1048 case 0x0800: dev->stats.rx_length_errors++; break;
1049 case 0x1000: dev->stats.rx_frame_errors++; break;
1050 case 0x1800: dev->stats.rx_length_errors++; break;
1051 case 0x2000: dev->stats.rx_frame_errors++; break;
1052 case 0x2800: dev->stats.rx_crc_errors++; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 }
1054 } else {
1055 short pkt_len = rx_status & 0x7ff;
1056 struct sk_buff *skb;
1057
1058 skb = dev_alloc_skb(pkt_len+5);
1059
1060 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1061 pkt_len, rx_status);
1062 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 skb_reserve(skb, 2);
1064 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1065 ((pkt_len+3)>>2));
1066 skb->protocol = eth_type_trans(skb, dev);
1067 netif_rx(skb);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001068 dev->stats.rx_packets++;
1069 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 } else {
1071 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1072 " size %d.\n", dev->name, pkt_len);
Paulius Zaleckas2e8d31d2008-04-30 01:08:26 +03001073 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075 }
1076 tc574_wait_for_completion(dev, RxDiscard);
1077 }
1078
1079 return worklimit;
1080}
1081
1082static void netdev_get_drvinfo(struct net_device *dev,
1083 struct ethtool_drvinfo *info)
1084{
1085 strcpy(info->driver, "3c574_cs");
1086}
1087
Jeff Garzik7282d492006-09-13 14:30:00 -04001088static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 .get_drvinfo = netdev_get_drvinfo,
1090};
1091
1092/* Provide ioctl() calls to examine the MII xcvr state. */
1093static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1094{
1095 struct el3_private *lp = netdev_priv(dev);
Olof Johansson906da802008-02-04 22:27:35 -08001096 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 u16 *data = (u16 *)&rq->ifr_ifru;
1098 int phy = lp->phys & 0x1f;
1099
1100 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1101 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1102 data[0], data[1], data[2], data[3]);
1103
1104 switch(cmd) {
1105 case SIOCGMIIPHY: /* Get the address of the PHY in use. */
1106 data[0] = phy;
1107 case SIOCGMIIREG: /* Read the specified MII register. */
1108 {
1109 int saved_window;
1110 unsigned long flags;
1111
1112 spin_lock_irqsave(&lp->window_lock, flags);
1113 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1114 EL3WINDOW(4);
1115 data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1116 EL3WINDOW(saved_window);
1117 spin_unlock_irqrestore(&lp->window_lock, flags);
1118 return 0;
1119 }
1120 case SIOCSMIIREG: /* Write the specified MII register */
1121 {
1122 int saved_window;
1123 unsigned long flags;
1124
1125 if (!capable(CAP_NET_ADMIN))
1126 return -EPERM;
1127 spin_lock_irqsave(&lp->window_lock, flags);
1128 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1129 EL3WINDOW(4);
1130 mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1131 EL3WINDOW(saved_window);
1132 spin_unlock_irqrestore(&lp->window_lock, flags);
1133 return 0;
1134 }
1135 default:
1136 return -EOPNOTSUPP;
1137 }
1138}
1139
1140/* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1141 documented. Until it is we revert to receiving all multicast frames when
1142 any multicast reception is desired.
1143 Note: My other drivers emit a log message whenever promiscuous mode is
1144 entered to help detect password sniffers. This is less desirable on
1145 typical PC card machines, so we omit the message.
1146 */
1147
1148static void set_rx_mode(struct net_device *dev)
1149{
Olof Johansson906da802008-02-04 22:27:35 -08001150 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
1152 if (dev->flags & IFF_PROMISC)
1153 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1154 ioaddr + EL3_CMD);
1155 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1156 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1157 else
1158 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1159}
1160
1161static int el3_close(struct net_device *dev)
1162{
Olof Johansson906da802008-02-04 22:27:35 -08001163 unsigned int ioaddr = dev->base_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 struct el3_private *lp = netdev_priv(dev);
Dominik Brodowskifba395e2006-03-31 17:21:06 +02001165 struct pcmcia_device *link = lp->p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
1167 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1168
Dominik Brodowski9940ec32006-03-05 11:04:33 +01001169 if (pcmcia_dev_present(link)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 unsigned long flags;
1171
1172 /* Turn off statistics ASAP. We update lp->stats below. */
1173 outw(StatsDisable, ioaddr + EL3_CMD);
1174
1175 /* Disable the receiver and transmitter. */
1176 outw(RxDisable, ioaddr + EL3_CMD);
1177 outw(TxDisable, ioaddr + EL3_CMD);
1178
1179 /* Note: Switching to window 0 may disable the IRQ. */
1180 EL3WINDOW(0);
1181 spin_lock_irqsave(&lp->window_lock, flags);
1182 update_stats(dev);
1183 spin_unlock_irqrestore(&lp->window_lock, flags);
Daniel Ritzb9a6eaf2005-04-10 20:27:45 +02001184
1185 /* force interrupts off */
1186 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 }
1188
1189 link->open--;
1190 netif_stop_queue(dev);
1191 del_timer_sync(&lp->media);
1192
1193 return 0;
1194}
1195
Dominik Brodowski270b6e92005-06-27 16:28:18 -07001196static struct pcmcia_device_id tc574_ids[] = {
1197 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1198 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1199 PCMCIA_DEVICE_NULL,
1200};
1201MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203static struct pcmcia_driver tc574_driver = {
1204 .owner = THIS_MODULE,
1205 .drv = {
1206 .name = "3c574_cs",
1207 },
Dominik Brodowski15b99ac2006-03-31 17:26:06 +02001208 .probe = tc574_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +01001209 .remove = tc574_detach,
Dominik Brodowski270b6e92005-06-27 16:28:18 -07001210 .id_table = tc574_ids,
Dominik Brodowski98e4c282005-11-14 21:21:18 +01001211 .suspend = tc574_suspend,
1212 .resume = tc574_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213};
1214
1215static int __init init_tc574(void)
1216{
1217 return pcmcia_register_driver(&tc574_driver);
1218}
1219
1220static void __exit exit_tc574(void)
1221{
1222 pcmcia_unregister_driver(&tc574_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
1224
1225module_init(init_tc574);
1226module_exit(exit_tc574);