blob: 3bba835f1a214c875352c7335dd251b27e6286d6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 Written 1997-1998 by Donald Becker.
3
4 This software may be used and distributed according to the terms
5 of the GNU General Public License, incorporated herein by reference.
6
7 This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
8
9 The author may be reached as becker@scyld.com, or C/O
10 Scyld Computing Corporation
11 410 Severn Ave., Suite 210
12 Annapolis MD 21403
13
14
Jeff Garzik6aa20a22006-09-13 13:24:59 -040015 2000/2/2- Added support for kernel-level ISAPnP
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo
17 Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 2001/11/17 - Added ethtool support (jgarzik)
Jeff Garzik6aa20a22006-09-13 13:24:59 -040020
Alan Cox113aa832008-10-13 19:01:08 -070021 2002/10/28 - Locking updates for 2.5 (alan@lxorguk.ukuu.org.uk)
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23*/
24
25#define DRV_NAME "3c515"
26#define DRV_VERSION "0.99t-ac"
27#define DRV_RELDATE "28-Oct-2002"
28
29static char *version =
30DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " becker@scyld.com and others\n";
31
32#define CORKSCREW 1
33
34/* "Knobs" that adjust features and parameters. */
35/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
36 Setting to > 1512 effectively disables this feature. */
37static int rx_copybreak = 200;
38
39/* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
40static const int mtu = 1500;
41
42/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
43static int max_interrupt_work = 20;
44
45/* Enable the automatic media selection code -- usually set. */
46#define AUTOMEDIA 1
47
48/* Allow the use of fragment bus master transfers instead of only
49 programmed-I/O for Vortex cards. Full-bus-master transfers are always
50 enabled by default on Boomerang cards. If VORTEX_BUS_MASTER is defined,
51 the feature may be turned on using 'options'. */
52#define VORTEX_BUS_MASTER
53
54/* A few values that may be tweaked. */
55/* Keep the ring sizes a power of two for efficiency. */
56#define TX_RING_SIZE 16
57#define RX_RING_SIZE 16
58#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer. */
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#include <linux/module.h>
61#include <linux/isapnp.h>
62#include <linux/kernel.h>
63#include <linux/netdevice.h>
64#include <linux/string.h>
65#include <linux/errno.h>
66#include <linux/in.h>
67#include <linux/ioport.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/skbuff.h>
69#include <linux/etherdevice.h>
70#include <linux/interrupt.h>
71#include <linux/timer.h>
72#include <linux/ethtool.h>
73#include <linux/bitops.h>
74
75#include <asm/uaccess.h>
76#include <asm/io.h>
77#include <asm/dma.h>
78
79#define NEW_MULTICAST
80#include <linux/delay.h>
81
82#define MAX_UNITS 8
83
84MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
85MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
86MODULE_LICENSE("GPL");
87MODULE_VERSION(DRV_VERSION);
88
89/* "Knobs" for adjusting internal parameters. */
90/* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
91#define DRIVER_DEBUG 1
92/* Some values here only for performance evaluation and path-coverage
93 debugging. */
94static int rx_nocopy, rx_copy, queued_packet;
95
96/* Number of times to check to see if the Tx FIFO has space, used in some
97 limited cases. */
98#define WAIT_TX_AVAIL 200
99
100/* Operational parameter that usually are not changed. */
101#define TX_TIMEOUT 40 /* Time in jiffies before concluding Tx hung */
102
103/* The size here is somewhat misleading: the Corkscrew also uses the ISA
104 aliased registers at <base>+0x400.
105 */
106#define CORKSCREW_TOTAL_SIZE 0x20
107
108#ifdef DRIVER_DEBUG
109static int corkscrew_debug = DRIVER_DEBUG;
110#else
111static int corkscrew_debug = 1;
112#endif
113
114#define CORKSCREW_ID 10
115
116/*
117 Theory of Operation
118
119I. Board Compatibility
120
121This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
1223Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout,
123it's not practical to integrate this driver with the other EtherLink drivers.
124
125II. Board-specific settings
126
127The Corkscrew has an EEPROM for configuration, but no special settings are
128needed for Linux.
129
130III. Driver operation
131
132The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
133PCI cards, with the bus master interface extensively modified to work with
134the ISA bus.
135
136The card is capable of full-bus-master transfers with separate
137lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
138DEC Tulip and Intel Speedo3.
139
140This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
141receive buffer. This scheme allocates full-sized skbuffs as receive
142buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is
143chosen to trade-off the memory wasted by passing the full-sized skbuff to
144the queue layer for all frames vs. the copying cost of copying a frame to a
145correctly-sized skbuff.
146
147
148IIIC. Synchronization
149The driver runs as two independent, single-threaded flows of control. One
150is the send-packet routine, which enforces single-threaded use by the netif
151layer. The other thread is the interrupt handler, which is single
152threaded by the hardware and other software.
153
154IV. Notes
155
156Thanks to Terry Murphy of 3Com for providing documentation and a development
157board.
158
159The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
160project names. I use these names to eliminate confusion -- 3Com product
161numbers and names are very similar and often confused.
162
163The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
164This driver only supports ethernet frames because of the recent MTU limit
165of 1.5K, but the changes to support 4.5K are minimal.
166*/
167
168/* Operational definitions.
169 These are not used by other compilation units and thus are not
170 exported in a ".h" file.
171
172 First the windows. There are eight register windows, with the command
173 and status registers available in each.
174 */
175#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
176#define EL3_CMD 0x0e
177#define EL3_STATUS 0x0e
178
179/* The top five bits written to EL3_CMD are a command, the lower
180 11 bits are the parameter, if applicable.
181 Note that 11 parameters bits was fine for ethernet, but the new chips
182 can handle FDDI length frames (~4500 octets) and now parameters count
183 32-bit 'Dwords' rather than octets. */
184
185enum corkscrew_cmd {
186 TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
187 RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
188 UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400189 DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
190 TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
191 AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
193 SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
194 StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
195 StatsDisable = 22 << 11, StopCoax = 23 << 11,
196};
197
198/* The SetRxFilter command accepts the following classes: */
199enum RxFilter {
200 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
201};
202
203/* Bits in the general status register. */
204enum corkscrew_status {
205 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
206 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
207 IntReq = 0x0040, StatsFull = 0x0080,
208 DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
209 DMAInProgress = 1 << 11, /* DMA controller is still busy. */
210 CmdInProgress = 1 << 12, /* EL3_CMD is still busy. */
211};
212
213/* Register window 1 offsets, the window used in normal operation.
214 On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
215enum Window1 {
216 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
217 RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
218 TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
219};
220enum Window0 {
221 Wn0IRQ = 0x08,
222#if defined(CORKSCREW)
223 Wn0EepromCmd = 0x200A, /* Corkscrew EEPROM command register. */
224 Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */
225#else
226 Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
227 Wn0EepromData = 12, /* Window 0: EEPROM results register. */
228#endif
229};
230enum Win0_EEPROM_bits {
231 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
232 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
233 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
234};
235
236/* EEPROM locations. */
237enum eeprom_offset {
238 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
239 EtherLink3ID = 7,
240};
241
242enum Window3 { /* Window 3: MAC/config bits. */
243 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
244};
Al Virob6659822008-01-13 14:17:35 +0000245enum wn3_config {
246 Ram_size = 7,
247 Ram_width = 8,
248 Ram_speed = 0x30,
249 Rom_size = 0xc0,
250 Ram_split_shift = 16,
251 Ram_split = 3 << Ram_split_shift,
252 Xcvr_shift = 20,
253 Xcvr = 7 << Xcvr_shift,
254 Autoselect = 0x1000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255};
256
257enum Window4 {
258 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */
259};
260enum Win4_Media_bits {
261 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
262 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
263 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
264 Media_LnkBeat = 0x0800,
265};
266enum Window7 { /* Window 7: Bus Master control. */
267 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
268};
269
270/* Boomerang-style bus master control registers. Note ISA aliases! */
271enum MasterCtrl {
272 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
273 0x40c,
274 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
275};
276
277/* The Rx and Tx descriptor lists.
278 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
279 alignment contraint on tx_ring[] and rx_ring[]. */
280struct boom_rx_desc {
281 u32 next;
282 s32 status;
283 u32 addr;
284 s32 length;
285};
286
287/* Values for the Rx status entry. */
288enum rx_desc_status {
289 RxDComplete = 0x00008000, RxDError = 0x4000,
290 /* See boomerang_rx() for actual error bits */
291};
292
293struct boom_tx_desc {
294 u32 next;
295 s32 status;
296 u32 addr;
297 s32 length;
298};
299
300struct corkscrew_private {
301 const char *product_name;
302 struct list_head list;
303 struct net_device *our_dev;
304 /* The Rx and Tx rings are here to keep them quad-word-aligned. */
305 struct boom_rx_desc rx_ring[RX_RING_SIZE];
306 struct boom_tx_desc tx_ring[TX_RING_SIZE];
307 /* The addresses of transmit- and receive-in-place skbuffs. */
308 struct sk_buff *rx_skbuff[RX_RING_SIZE];
309 struct sk_buff *tx_skbuff[TX_RING_SIZE];
310 unsigned int cur_rx, cur_tx; /* The next free ring entry */
311 unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
313 struct timer_list timer; /* Media selection timer. */
314 int capabilities ; /* Adapter capabilities word. */
315 int options; /* User-settable misc. driver options. */
316 int last_rx_packets; /* For media autoselection. */
317 unsigned int available_media:8, /* From Wn3_Options */
318 media_override:3, /* Passed-in media type. */
319 default_media:3, /* Read from the EEPROM. */
320 full_duplex:1, autoselect:1, bus_master:1, /* Vortex can only do a fragment bus-m. */
321 full_bus_master_tx:1, full_bus_master_rx:1, /* Boomerang */
322 tx_full:1;
323 spinlock_t lock;
324 struct device *dev;
325};
326
327/* The action to take with a media selection timer tick.
328 Note that we deviate from the 3Com order by checking 10base2 before AUI.
329 */
330enum xcvr_types {
331 XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
332 XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
333};
334
335static struct media_table {
336 char *name;
337 unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */
338 mask:8, /* The transceiver-present bit in Wn3_Config. */
339 next:8; /* The media type to try next. */
340 short wait; /* Time before we check media status. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400341} media_tbl[] = {
342 { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
343 { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
344 { "undefined", 0, 0x80, XCVR_10baseT, 10000},
345 { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
346 { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
347 { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
348 { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
349 { "undefined", 0, 0x01, XCVR_10baseT, 10000},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 { "Default", 0, 0xFF, XCVR_10baseT, 10000},
351};
352
353#ifdef __ISAPNP__
354static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
355 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
356 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
357 (long) "3Com Fast EtherLink ISA" },
358 { } /* terminate list */
359};
360
361MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
362
363static int nopnp;
364#endif /* __ISAPNP__ */
365
366static struct net_device *corkscrew_scan(int unit);
b1fc5502005-05-12 20:11:55 -0400367static int corkscrew_setup(struct net_device *dev, int ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 struct pnp_dev *idev, int card_number);
369static int corkscrew_open(struct net_device *dev);
370static void corkscrew_timer(unsigned long arg);
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000371static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
372 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373static int corkscrew_rx(struct net_device *dev);
374static void corkscrew_timeout(struct net_device *dev);
375static int boomerang_rx(struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100376static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377static int corkscrew_close(struct net_device *dev);
378static void update_stats(int addr, struct net_device *dev);
379static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
380static void set_rx_mode(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400381static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400383
384/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 Unfortunately maximizing the shared code between the integrated and
386 module version of the driver results in a complicated set of initialization
387 procedures.
388 init_module() -- modules / tc59x_init() -- built-in
389 The wrappers for corkscrew_scan()
390 corkscrew_scan() The common routine that scans for PCI and EISA cards
391 corkscrew_found_device() Allocate a device structure when we find a card.
392 Different versions exist for modules and built-in.
393 corkscrew_probe1() Fill in the device structure -- this is separated
394 so that the modules code can put it in dev->init.
395*/
396/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
397/* Note: this is the only limit on the number of cards supported!! */
398static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
399
400#ifdef MODULE
401static int debug = -1;
402
403module_param(debug, int, 0);
404module_param_array(options, int, NULL, 0);
405module_param(rx_copybreak, int, 0);
406module_param(max_interrupt_work, int, 0);
407MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
408MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
409MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
410MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
411
412/* A list of all installed Vortex devices, for removing the driver module. */
413/* we will need locking (and refcounting) if we ever use it for more */
414static LIST_HEAD(root_corkscrew_dev);
415
416int init_module(void)
417{
418 int found = 0;
419 if (debug >= 0)
420 corkscrew_debug = debug;
421 if (corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000422 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 while (corkscrew_scan(-1))
424 found++;
425 return found ? 0 : -ENODEV;
426}
427
428#else
429struct net_device *tc515_probe(int unit)
430{
431 struct net_device *dev = corkscrew_scan(unit);
432 static int printed;
433
434 if (!dev)
435 return ERR_PTR(-ENODEV);
436
437 if (corkscrew_debug > 0 && !printed) {
438 printed = 1;
Alexander Beregalov39738e12009-05-26 12:35:26 +0000439 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441
442 return dev;
443}
444#endif /* not MODULE */
445
446static int check_device(unsigned ioaddr)
447{
448 int timer;
449
450 if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
451 return 0;
452 /* Check the resource configuration for a matching ioaddr. */
453 if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
454 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
455 return 0;
456 }
457 /* Verify by reading the device ID from the EEPROM. */
458 outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
459 /* Pause for at least 162 us. for the read to take place. */
460 for (timer = 4; timer >= 0; timer--) {
461 udelay(162);
462 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
463 break;
464 }
465 if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
466 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
467 return 0;
468 }
469 return 1;
470}
471
472static void cleanup_card(struct net_device *dev)
473{
474 struct corkscrew_private *vp = netdev_priv(dev);
475 list_del_init(&vp->list);
476 if (dev->dma)
477 free_dma(dev->dma);
478 outw(TotalReset, dev->base_addr + EL3_CMD);
479 release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
480 if (vp->dev)
481 pnp_device_detach(to_pnp_dev(vp->dev));
482}
483
484static struct net_device *corkscrew_scan(int unit)
485{
486 struct net_device *dev;
487 static int cards_found = 0;
488 static int ioaddr;
489 int err;
490#ifdef __ISAPNP__
491 short i;
492 static int pnp_cards;
493#endif
494
495 dev = alloc_etherdev(sizeof(struct corkscrew_private));
496 if (!dev)
497 return ERR_PTR(-ENOMEM);
498
499 if (unit >= 0) {
500 sprintf(dev->name, "eth%d", unit);
501 netdev_boot_setup_check(dev);
502 }
503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504#ifdef __ISAPNP__
505 if(nopnp == 1)
506 goto no_pnp;
507 for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
508 struct pnp_dev *idev = NULL;
509 int irq;
510 while((idev = pnp_find_dev(NULL,
511 corkscrew_isapnp_adapters[i].vendor,
512 corkscrew_isapnp_adapters[i].function,
513 idev))) {
514
515 if (pnp_device_attach(idev) < 0)
516 continue;
517 if (pnp_activate_dev(idev) < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000518 pr_warning("pnp activate failed (out of resources?)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 pnp_device_detach(idev);
520 continue;
521 }
522 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
523 pnp_device_detach(idev);
524 continue;
525 }
526 ioaddr = pnp_port_start(idev, 0);
527 irq = pnp_irq(idev, 0);
528 if (!check_device(ioaddr)) {
529 pnp_device_detach(idev);
530 continue;
531 }
532 if(corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000533 pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000535 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
537 /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 SET_NETDEV_DEV(dev, &idev->dev);
539 pnp_cards++;
b1fc5502005-05-12 20:11:55 -0400540 err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 if (!err)
542 return dev;
543 cleanup_card(dev);
544 }
545 }
546no_pnp:
547#endif /* __ISAPNP__ */
548
549 /* Check all locations on the ISA bus -- evil! */
550 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
551 if (!check_device(ioaddr))
552 continue;
553
Alexander Beregalov39738e12009-05-26 12:35:26 +0000554 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
b1fc5502005-05-12 20:11:55 -0400556 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 if (!err)
558 return dev;
559 cleanup_card(dev);
560 }
561 free_netdev(dev);
562 return NULL;
563}
564
Stephen Hemmingerf3701c22009-01-09 13:01:15 +0000565
566static const struct net_device_ops netdev_ops = {
567 .ndo_open = corkscrew_open,
568 .ndo_stop = corkscrew_close,
569 .ndo_start_xmit = corkscrew_start_xmit,
570 .ndo_tx_timeout = corkscrew_timeout,
571 .ndo_get_stats = corkscrew_get_stats,
572 .ndo_set_multicast_list = set_rx_mode,
573 .ndo_change_mtu = eth_change_mtu,
574 .ndo_set_mac_address = eth_mac_addr,
575 .ndo_validate_addr = eth_validate_addr,
576};
577
578
b1fc5502005-05-12 20:11:55 -0400579static int corkscrew_setup(struct net_device *dev, int ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 struct pnp_dev *idev, int card_number)
581{
582 struct corkscrew_private *vp = netdev_priv(dev);
583 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
584 int i;
585 int irq;
586
Randy Dunlap92fbc1c2008-05-16 10:35:24 -0700587#ifdef __ISAPNP__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (idev) {
589 irq = pnp_irq(idev, 0);
590 vp->dev = &idev->dev;
591 } else {
592 irq = inw(ioaddr + 0x2002) & 15;
593 }
Randy Dunlap92fbc1c2008-05-16 10:35:24 -0700594#else
595 irq = inw(ioaddr + 0x2002) & 15;
596#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 dev->base_addr = ioaddr;
599 dev->irq = irq;
600 dev->dma = inw(ioaddr + 0x2000) & 7;
601 vp->product_name = "3c515";
602 vp->options = dev->mem_start;
603 vp->our_dev = dev;
604
605 if (!vp->options) {
606 if (card_number >= MAX_UNITS)
607 vp->options = -1;
608 else
609 vp->options = options[card_number];
610 }
611
612 if (vp->options >= 0) {
613 vp->media_override = vp->options & 7;
614 if (vp->media_override == 2)
615 vp->media_override = 0;
616 vp->full_duplex = (vp->options & 8) ? 1 : 0;
617 vp->bus_master = (vp->options & 16) ? 1 : 0;
618 } else {
619 vp->media_override = 7;
620 vp->full_duplex = 0;
621 vp->bus_master = 0;
622 }
623#ifdef MODULE
624 list_add(&vp->list, &root_corkscrew_dev);
625#endif
626
Alexander Beregalov39738e12009-05-26 12:35:26 +0000627 pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 spin_lock_init(&vp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 /* Read the station address from the EEPROM. */
632 EL3WINDOW(0);
633 for (i = 0; i < 0x18; i++) {
Al Virob6659822008-01-13 14:17:35 +0000634 __be16 *phys_addr = (__be16 *) dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 int timer;
636 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
637 /* Pause for at least 162 us. for the read to take place. */
638 for (timer = 4; timer >= 0; timer--) {
639 udelay(162);
640 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
641 break;
642 }
643 eeprom[i] = inw(ioaddr + Wn0EepromData);
644 checksum ^= eeprom[i];
645 if (i < 3)
646 phys_addr[i] = htons(eeprom[i]);
647 }
648 checksum = (checksum ^ (checksum >> 8)) & 0xff;
649 if (checksum != 0x00)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000650 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
651 pr_cont(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 if (eeprom[16] == 0x11c7) { /* Corkscrew */
653 if (request_dma(dev->dma, "3c515")) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000654 pr_cont(", DMA %d allocation failed", dev->dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 dev->dma = 0;
656 } else
Alexander Beregalov39738e12009-05-26 12:35:26 +0000657 pr_cont(", DMA %d", dev->dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 }
Alexander Beregalov39738e12009-05-26 12:35:26 +0000659 pr_cont(", IRQ %d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 /* Tell them about an invalid IRQ. */
661 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
Alexander Beregalov39738e12009-05-26 12:35:26 +0000662 pr_warning(" *** Warning: this IRQ is unlikely to work! ***\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664 {
665 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
Al Virob6659822008-01-13 14:17:35 +0000666 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 EL3WINDOW(3);
668 vp->available_media = inw(ioaddr + Wn3_Options);
Al Virob6659822008-01-13 14:17:35 +0000669 config = inl(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000671 pr_info(" Internal config register is %4.4x, transceivers %#x.\n",
Al Virob6659822008-01-13 14:17:35 +0000672 config, inw(ioaddr + Wn3_Options));
Alexander Beregalov39738e12009-05-26 12:35:26 +0000673 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
Al Virob6659822008-01-13 14:17:35 +0000674 8 << config & Ram_size,
675 config & Ram_width ? "word" : "byte",
676 ram_split[(config & Ram_split) >> Ram_split_shift],
677 config & Autoselect ? "autoselect/" : "",
678 media_tbl[(config & Xcvr) >> Xcvr_shift].name);
679 vp->default_media = (config & Xcvr) >> Xcvr_shift;
680 vp->autoselect = config & Autoselect ? 1 : 0;
681 dev->if_port = vp->default_media;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 }
683 if (vp->media_override != 7) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000684 pr_info(" Media override to transceiver type %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 vp->media_override,
686 media_tbl[vp->media_override].name);
687 dev->if_port = vp->media_override;
688 }
689
690 vp->capabilities = eeprom[16];
691 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
692 /* Rx is broken at 10mbps, so we always disable it. */
693 /* vp->full_bus_master_rx = 0; */
694 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
695
696 /* The 3c51x-specific entries in the device structure. */
Stephen Hemmingerf3701c22009-01-09 13:01:15 +0000697 dev->netdev_ops = &netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 dev->watchdog_timeo = (400 * HZ) / 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 dev->ethtool_ops = &netdev_ethtool_ops;
b1fc5502005-05-12 20:11:55 -0400700
701 return register_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
705static int corkscrew_open(struct net_device *dev)
706{
707 int ioaddr = dev->base_addr;
708 struct corkscrew_private *vp = netdev_priv(dev);
Al Virob6659822008-01-13 14:17:35 +0000709 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 int i;
711
712 /* Before initializing select the active media port. */
713 EL3WINDOW(3);
714 if (vp->full_duplex)
715 outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
Al Virob6659822008-01-13 14:17:35 +0000716 config = inl(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
718 if (vp->media_override != 7) {
719 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000720 pr_info("%s: Media override to transceiver %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 dev->name, vp->media_override,
722 media_tbl[vp->media_override].name);
723 dev->if_port = vp->media_override;
724 } else if (vp->autoselect) {
725 /* Find first available media type, starting with 100baseTx. */
726 dev->if_port = 4;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400727 while (!(vp->available_media & media_tbl[dev->if_port].mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 dev->if_port = media_tbl[dev->if_port].next;
729
730 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000731 pr_debug("%s: Initial media type %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 dev->name, media_tbl[dev->if_port].name);
733
734 init_timer(&vp->timer);
735 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
736 vp->timer.data = (unsigned long) dev;
737 vp->timer.function = &corkscrew_timer; /* timer handler */
738 add_timer(&vp->timer);
739 } else
740 dev->if_port = vp->default_media;
741
Al Virob6659822008-01-13 14:17:35 +0000742 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
743 outl(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
745 if (corkscrew_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000746 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
Al Virob6659822008-01-13 14:17:35 +0000747 dev->name, config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
749
750 outw(TxReset, ioaddr + EL3_CMD);
751 for (i = 20; i >= 0; i--)
752 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
753 break;
754
755 outw(RxReset, ioaddr + EL3_CMD);
756 /* Wait a few ticks for the RxReset command to complete. */
757 for (i = 20; i >= 0; i--)
758 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
759 break;
760
761 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
762
763 /* Use the now-standard shared IRQ implementation. */
764 if (vp->capabilities == 0x11c7) {
765 /* Corkscrew: Cannot share ISA resources. */
Joe Perches8e95a202009-12-03 07:58:21 +0000766 if (dev->irq == 0 ||
767 dev->dma == 0 ||
768 request_irq(dev->irq, corkscrew_interrupt, 0,
769 vp->product_name, dev))
770 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 enable_dma(dev->dma);
772 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
Joe Perchesa0607fd2009-11-18 23:29:17 -0800773 } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 vp->product_name, dev)) {
775 return -EAGAIN;
776 }
777
778 if (corkscrew_debug > 1) {
779 EL3WINDOW(4);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000780 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 dev->name, dev->irq, inw(ioaddr + Wn4_Media));
782 }
783
784 /* Set the station address and mask in window 2 each time opened. */
785 EL3WINDOW(2);
786 for (i = 0; i < 6; i++)
787 outb(dev->dev_addr[i], ioaddr + i);
788 for (; i < 12; i += 2)
789 outw(0, ioaddr + i);
790
791 if (dev->if_port == 3)
792 /* Start the thinnet transceiver. We should really wait 50ms... */
793 outw(StartCoax, ioaddr + EL3_CMD);
794 EL3WINDOW(4);
795 outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
796 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
797
798 /* Switch to the stats window, and clear all stats by reading. */
799 outw(StatsDisable, ioaddr + EL3_CMD);
800 EL3WINDOW(6);
801 for (i = 0; i < 10; i++)
802 inb(ioaddr + i);
803 inw(ioaddr + 10);
804 inw(ioaddr + 12);
805 /* New: On the Vortex we must also clear the BadSSD counter. */
806 EL3WINDOW(4);
807 inb(ioaddr + 12);
808 /* ..and on the Boomerang we enable the extra statistics bits. */
809 outw(0x0040, ioaddr + Wn4_NetDiag);
810
811 /* Switch to register set 7 for normal use. */
812 EL3WINDOW(7);
813
814 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
815 vp->cur_rx = vp->dirty_rx = 0;
816 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000817 pr_debug("%s: Filling in the Rx ring.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 for (i = 0; i < RX_RING_SIZE; i++) {
819 struct sk_buff *skb;
820 if (i < (RX_RING_SIZE - 1))
821 vp->rx_ring[i].next =
822 isa_virt_to_bus(&vp->rx_ring[i + 1]);
823 else
824 vp->rx_ring[i].next = 0;
825 vp->rx_ring[i].status = 0; /* Clear complete bit. */
826 vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
827 skb = dev_alloc_skb(PKT_BUF_SZ);
828 vp->rx_skbuff[i] = skb;
829 if (skb == NULL)
830 break; /* Bad news! */
831 skb->dev = dev; /* Mark as being used by this device. */
832 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -0700833 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 }
roel kluin3d540152009-07-30 00:26:32 +0000835 if (i != 0)
836 vp->rx_ring[i - 1].next =
837 isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
839 }
840 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
841 vp->cur_tx = vp->dirty_tx = 0;
842 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */
843 /* Clear the Tx ring. */
844 for (i = 0; i < TX_RING_SIZE; i++)
845 vp->tx_skbuff[i] = NULL;
846 outl(0, ioaddr + DownListPtr);
847 }
848 /* Set receiver mode: presumably accept b-case and phys addr only. */
849 set_rx_mode(dev);
850 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
851
852 netif_start_queue(dev);
853
854 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
855 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
856 /* Allow status bits to be seen. */
857 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
858 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
859 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
860 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
861 /* Ack all pending events, and set active indicator mask. */
862 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
863 ioaddr + EL3_CMD);
864 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
865 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
866 ioaddr + EL3_CMD);
867
868 return 0;
869}
870
871static void corkscrew_timer(unsigned long data)
872{
873#ifdef AUTOMEDIA
874 struct net_device *dev = (struct net_device *) data;
875 struct corkscrew_private *vp = netdev_priv(dev);
876 int ioaddr = dev->base_addr;
877 unsigned long flags;
878 int ok = 0;
879
880 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000881 pr_debug("%s: Media selection timer tick happened, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 dev->name, media_tbl[dev->if_port].name);
883
884 spin_lock_irqsave(&vp->lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 {
887 int old_window = inw(ioaddr + EL3_CMD) >> 13;
888 int media_status;
889 EL3WINDOW(4);
890 media_status = inw(ioaddr + Wn4_Media);
891 switch (dev->if_port) {
892 case 0:
893 case 4:
894 case 5: /* 10baseT, 100baseTX, 100baseFX */
895 if (media_status & Media_LnkBeat) {
896 ok = 1;
897 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000898 pr_debug("%s: Media %s has link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 dev->name,
900 media_tbl[dev->if_port].name,
901 media_status);
902 } else if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000903 pr_debug("%s: Media %s is has no link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 dev->name,
905 media_tbl[dev->if_port].name,
906 media_status);
907
908 break;
909 default: /* Other media types handled by Tx timeouts. */
910 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000911 pr_debug("%s: Media %s is has no indication, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 dev->name,
913 media_tbl[dev->if_port].name,
914 media_status);
915 ok = 1;
916 }
917 if (!ok) {
Al Virob6659822008-01-13 14:17:35 +0000918 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920 do {
921 dev->if_port =
922 media_tbl[dev->if_port].next;
923 }
924 while (!(vp->available_media & media_tbl[dev->if_port].mask));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400925
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 if (dev->if_port == 8) { /* Go back to default. */
927 dev->if_port = vp->default_media;
928 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000929 pr_debug("%s: Media selection failing, using default %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 dev->name,
931 media_tbl[dev->if_port].name);
932 } else {
933 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000934 pr_debug("%s: Media selection failed, now trying %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 dev->name,
936 media_tbl[dev->if_port].name);
937 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
938 add_timer(&vp->timer);
939 }
940 outw((media_status & ~(Media_10TP | Media_SQE)) |
941 media_tbl[dev->if_port].media_bits,
942 ioaddr + Wn4_Media);
943
944 EL3WINDOW(3);
Al Virob6659822008-01-13 14:17:35 +0000945 config = inl(ioaddr + Wn3_Config);
946 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
947 outl(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948
949 outw(dev->if_port == 3 ? StartCoax : StopCoax,
950 ioaddr + EL3_CMD);
951 }
952 EL3WINDOW(old_window);
953 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 spin_unlock_irqrestore(&vp->lock, flags);
956 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000957 pr_debug("%s: Media selection timer finished, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 dev->name, media_tbl[dev->if_port].name);
959
960#endif /* AUTOMEDIA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961}
962
963static void corkscrew_timeout(struct net_device *dev)
964{
965 int i;
966 struct corkscrew_private *vp = netdev_priv(dev);
967 int ioaddr = dev->base_addr;
968
Alexander Beregalov39738e12009-05-26 12:35:26 +0000969 pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 dev->name, inb(ioaddr + TxStatus),
971 inw(ioaddr + EL3_STATUS));
972 /* Slight code bloat to be user friendly. */
973 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000974 pr_warning("%s: Transmitter encountered 16 collisions --"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 " network cable problem?\n", dev->name);
976#ifndef final_version
Alexander Beregalov39738e12009-05-26 12:35:26 +0000977 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
979 vp->cur_tx);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000980 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 &vp->tx_ring[0]);
982 for (i = 0; i < TX_RING_SIZE; i++) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000983 pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 &vp->tx_ring[i],
985 vp->tx_ring[i].length, vp->tx_ring[i].status);
986 }
987#endif
988 /* Issue TX_RESET and TX_START commands. */
989 outw(TxReset, ioaddr + EL3_CMD);
990 for (i = 20; i >= 0; i--)
991 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
992 break;
993 outw(TxEnable, ioaddr + EL3_CMD);
Eric Dumazet1ae5dc32010-05-10 05:01:31 -0700994 dev->trans_start = jiffies; /* prevent tx timeout */
Paulius Zaleckasdfd44152008-04-29 03:07:31 +0300995 dev->stats.tx_errors++;
996 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 netif_wake_queue(dev);
998}
999
Stephen Hemminger27a1de92009-08-31 19:50:54 +00001000static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1001 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002{
1003 struct corkscrew_private *vp = netdev_priv(dev);
1004 int ioaddr = dev->base_addr;
1005
1006 /* Block a timer-based transmit from overlapping. */
1007
1008 netif_stop_queue(dev);
1009
1010 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
1011 /* Calculate the next Tx descriptor entry. */
1012 int entry = vp->cur_tx % TX_RING_SIZE;
1013 struct boom_tx_desc *prev_entry;
Eric Sesterhenncb958182006-08-19 19:37:57 +02001014 unsigned long flags;
1015 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
1017 if (vp->tx_full) /* No room to transmit with */
Patrick McHardy5b548142009-06-12 06:22:29 +00001018 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 if (vp->cur_tx != 0)
1020 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1021 else
1022 prev_entry = NULL;
1023 if (corkscrew_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001024 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 dev->name, vp->cur_tx);
1026 /* vp->tx_full = 1; */
1027 vp->tx_skbuff[entry] = skb;
1028 vp->tx_ring[entry].next = 0;
1029 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1030 vp->tx_ring[entry].length = skb->len | 0x80000000;
1031 vp->tx_ring[entry].status = skb->len | 0x80000000;
1032
1033 spin_lock_irqsave(&vp->lock, flags);
1034 outw(DownStall, ioaddr + EL3_CMD);
1035 /* Wait for the stall to complete. */
1036 for (i = 20; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001037 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 break;
1039 if (prev_entry)
1040 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1041 if (inl(ioaddr + DownListPtr) == 0) {
1042 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1043 ioaddr + DownListPtr);
1044 queued_packet++;
1045 }
1046 outw(DownUnstall, ioaddr + EL3_CMD);
1047 spin_unlock_irqrestore(&vp->lock, flags);
1048
1049 vp->cur_tx++;
1050 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1051 vp->tx_full = 1;
1052 else { /* Clear previous interrupt enable. */
1053 if (prev_entry)
1054 prev_entry->status &= ~0x80000000;
1055 netif_wake_queue(dev);
1056 }
Patrick McHardy6ed10652009-06-23 06:03:08 +00001057 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 }
1059 /* Put out the doubleword header... */
1060 outl(skb->len, ioaddr + TX_FIFO);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001061 dev->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062#ifdef VORTEX_BUS_MASTER
1063 if (vp->bus_master) {
1064 /* Set the bus-master controller to transfer the packet. */
1065 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1066 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1067 vp->tx_skb = skb;
1068 outw(StartDMADown, ioaddr + EL3_CMD);
1069 /* queue will be woken at the DMADone interrupt. */
1070 } else {
1071 /* ... and the packet rounded to a doubleword. */
1072 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1073 dev_kfree_skb(skb);
1074 if (inw(ioaddr + TxFree) > 1536) {
1075 netif_wake_queue(dev);
1076 } else
1077 /* Interrupt us when the FIFO has room for max-sized packet. */
1078 outw(SetTxThreshold + (1536 >> 2),
1079 ioaddr + EL3_CMD);
1080 }
1081#else
1082 /* ... and the packet rounded to a doubleword. */
1083 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1084 dev_kfree_skb(skb);
1085 if (inw(ioaddr + TxFree) > 1536) {
1086 netif_wake_queue(dev);
1087 } else
1088 /* Interrupt us when the FIFO has room for max-sized packet. */
1089 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1090#endif /* bus master */
1091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
1093 /* Clear the Tx status stack. */
1094 {
1095 short tx_status;
1096 int i = 4;
1097
1098 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1099 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1100 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001101 pr_debug("%s: Tx error, status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 dev->name, tx_status);
1103 if (tx_status & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001104 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 if (tx_status & 0x38)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001106 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 if (tx_status & 0x30) {
1108 int j;
1109 outw(TxReset, ioaddr + EL3_CMD);
1110 for (j = 20; j >= 0; j--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001111 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 break;
1113 }
1114 outw(TxEnable, ioaddr + EL3_CMD);
1115 }
1116 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1117 }
1118 }
Patrick McHardy6ed10652009-06-23 06:03:08 +00001119 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120}
1121
1122/* The interrupt handler does all of the Rx thread work and cleans up
1123 after the Tx thread. */
1124
David Howells7d12e782006-10-05 14:55:46 +01001125static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126{
1127 /* Use the now-standard shared IRQ implementation. */
1128 struct net_device *dev = dev_id;
1129 struct corkscrew_private *lp = netdev_priv(dev);
1130 int ioaddr, status;
1131 int latency;
1132 int i = max_interrupt_work;
1133
1134 ioaddr = dev->base_addr;
1135 latency = inb(ioaddr + Timer);
1136
1137 spin_lock(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 status = inw(ioaddr + EL3_STATUS);
1140
1141 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001142 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 dev->name, status, latency);
1144 if ((status & 0xE000) != 0xE000) {
1145 static int donedidthis;
1146 /* Some interrupt controllers store a bogus interrupt from boot-time.
1147 Ignore a single early interrupt, but don't hang the machine for
1148 other interrupt problems. */
1149 if (donedidthis++ > 100) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001150 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 dev->name, status, netif_running(dev));
1152 free_irq(dev->irq, dev);
1153 dev->irq = -1;
1154 }
1155 }
1156
1157 do {
1158 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001159 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 dev->name, status);
1161 if (status & RxComplete)
1162 corkscrew_rx(dev);
1163
1164 if (status & TxAvailable) {
1165 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001166 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 /* There's room in the FIFO for a full-sized packet. */
1168 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1169 netif_wake_queue(dev);
1170 }
1171 if (status & DownComplete) {
1172 unsigned int dirty_tx = lp->dirty_tx;
1173
1174 while (lp->cur_tx - dirty_tx > 0) {
1175 int entry = dirty_tx % TX_RING_SIZE;
1176 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1177 break; /* It still hasn't been processed. */
1178 if (lp->tx_skbuff[entry]) {
1179 dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1180 lp->tx_skbuff[entry] = NULL;
1181 }
1182 dirty_tx++;
1183 }
1184 lp->dirty_tx = dirty_tx;
1185 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1186 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1187 lp->tx_full = 0;
1188 netif_wake_queue(dev);
1189 }
1190 }
1191#ifdef VORTEX_BUS_MASTER
1192 if (status & DMADone) {
1193 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1194 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1195 netif_wake_queue(dev);
1196 }
1197#endif
1198 if (status & UpComplete) {
1199 boomerang_rx(dev);
1200 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1201 }
1202 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1203 /* Handle all uncommon interrupts at once. */
1204 if (status & RxEarly) { /* Rx early is unused. */
1205 corkscrew_rx(dev);
1206 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1207 }
1208 if (status & StatsFull) { /* Empty statistics. */
1209 static int DoneDidThat;
1210 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001211 pr_debug("%s: Updating stats.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 update_stats(ioaddr, dev);
1213 /* DEBUG HACK: Disable statistics as an interrupt source. */
1214 /* This occurs when we have the wrong media type! */
1215 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1216 int win, reg;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001217 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1218 dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 for (win = 0; win < 8; win++) {
1220 EL3WINDOW(win);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001221 pr_notice("Vortex window %d:", win);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 for (reg = 0; reg < 16; reg++)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001223 pr_cont(" %2.2x", inb(ioaddr + reg));
1224 pr_cont("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 }
1226 EL3WINDOW(7);
1227 outw(SetIntrEnb | TxAvailable |
1228 RxComplete | AdapterFailure |
1229 UpComplete | DownComplete |
1230 TxComplete, ioaddr + EL3_CMD);
1231 DoneDidThat++;
1232 }
1233 }
1234 if (status & AdapterFailure) {
1235 /* Adapter failure requires Rx reset and reinit. */
1236 outw(RxReset, ioaddr + EL3_CMD);
1237 /* Set the Rx filter to the current state. */
1238 set_rx_mode(dev);
1239 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1240 outw(AckIntr | AdapterFailure,
1241 ioaddr + EL3_CMD);
1242 }
1243 }
1244
1245 if (--i < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001246 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1247 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 /* Disable all pending interrupts. */
1249 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1250 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1251 break;
1252 }
1253 /* Acknowledge the IRQ. */
1254 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1255
1256 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 spin_unlock(&lp->lock);
1259
1260 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001261 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 return IRQ_HANDLED;
1263}
1264
1265static int corkscrew_rx(struct net_device *dev)
1266{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 int ioaddr = dev->base_addr;
1268 int i;
1269 short rx_status;
1270
1271 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001272 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1274 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1275 if (rx_status & 0x4000) { /* Error, update stats. */
1276 unsigned char rx_error = inb(ioaddr + RxErrors);
1277 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001278 pr_debug(" Rx error: status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001280 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001282 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001284 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001286 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001288 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001290 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 } else {
1292 /* The packet length: up to 4.5K!. */
1293 short pkt_len = rx_status & 0x1fff;
1294 struct sk_buff *skb;
1295
1296 skb = dev_alloc_skb(pkt_len + 5 + 2);
1297 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001298 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 pkt_len, rx_status);
1300 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1302 /* 'skb_put()' points to the start of sk_buff data area. */
1303 insl(ioaddr + RX_FIFO,
1304 skb_put(skb, pkt_len),
1305 (pkt_len + 3) >> 2);
1306 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1307 skb->protocol = eth_type_trans(skb, dev);
1308 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001309 dev->stats.rx_packets++;
1310 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 /* Wait a limited time to go to next packet. */
1312 for (i = 200; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001313 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 break;
1315 continue;
1316 } else if (corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001317 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 }
1319 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001320 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 /* Wait a limited time to skip this packet. */
1322 for (i = 200; i >= 0; i--)
1323 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1324 break;
1325 }
1326 return 0;
1327}
1328
1329static int boomerang_rx(struct net_device *dev)
1330{
1331 struct corkscrew_private *vp = netdev_priv(dev);
1332 int entry = vp->cur_rx % RX_RING_SIZE;
1333 int ioaddr = dev->base_addr;
1334 int rx_status;
1335
1336 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001337 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1339 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1340 if (rx_status & RxDError) { /* Error, update stats. */
1341 unsigned char rx_error = rx_status >> 16;
1342 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001343 pr_debug(" Rx error: status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001345 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001347 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001349 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001351 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001353 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001355 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 } else {
1357 /* The packet length: up to 4.5K!. */
1358 short pkt_len = rx_status & 0x1fff;
1359 struct sk_buff *skb;
1360
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001361 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001363 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 pkt_len, rx_status);
1365
1366 /* Check if the packet is long enough to just accept without
1367 copying to a properly sized skbuff. */
Joe Perches8e95a202009-12-03 07:58:21 +00001368 if (pkt_len < rx_copybreak &&
1369 (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1371 /* 'skb_put()' points to the start of sk_buff data area. */
1372 memcpy(skb_put(skb, pkt_len),
1373 isa_bus_to_virt(vp->rx_ring[entry].
1374 addr), pkt_len);
1375 rx_copy++;
1376 } else {
1377 void *temp;
1378 /* Pass up the skbuff already on the Rx ring. */
1379 skb = vp->rx_skbuff[entry];
1380 vp->rx_skbuff[entry] = NULL;
1381 temp = skb_put(skb, pkt_len);
1382 /* Remove this checking code for final release. */
1383 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001384 pr_warning("%s: Warning -- the skbuff addresses do not match"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 " in boomerang_rx: %p vs. %p / %p.\n",
1386 dev->name,
1387 isa_bus_to_virt(vp->
1388 rx_ring[entry].
1389 addr), skb->head,
1390 temp);
1391 rx_nocopy++;
1392 }
1393 skb->protocol = eth_type_trans(skb, dev);
1394 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001395 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 }
1397 entry = (++vp->cur_rx) % RX_RING_SIZE;
1398 }
1399 /* Refill the Rx ring buffers. */
1400 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1401 struct sk_buff *skb;
1402 entry = vp->dirty_rx % RX_RING_SIZE;
1403 if (vp->rx_skbuff[entry] == NULL) {
1404 skb = dev_alloc_skb(PKT_BUF_SZ);
1405 if (skb == NULL)
1406 break; /* Bad news! */
1407 skb->dev = dev; /* Mark as being used by this device. */
1408 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -07001409 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 vp->rx_skbuff[entry] = skb;
1411 }
1412 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1413 }
1414 return 0;
1415}
1416
1417static int corkscrew_close(struct net_device *dev)
1418{
1419 struct corkscrew_private *vp = netdev_priv(dev);
1420 int ioaddr = dev->base_addr;
1421 int i;
1422
1423 netif_stop_queue(dev);
1424
1425 if (corkscrew_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001426 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 dev->name, inw(ioaddr + EL3_STATUS),
1428 inb(ioaddr + TxStatus));
Alexander Beregalov39738e12009-05-26 12:35:26 +00001429 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1430 dev->name, rx_nocopy, rx_copy, queued_packet);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 }
1432
1433 del_timer(&vp->timer);
1434
1435 /* Turn off statistics ASAP. We update lp->stats below. */
1436 outw(StatsDisable, ioaddr + EL3_CMD);
1437
1438 /* Disable the receiver and transmitter. */
1439 outw(RxDisable, ioaddr + EL3_CMD);
1440 outw(TxDisable, ioaddr + EL3_CMD);
1441
1442 if (dev->if_port == XCVR_10base2)
1443 /* Turn off thinnet power. Green! */
1444 outw(StopCoax, ioaddr + EL3_CMD);
1445
1446 free_irq(dev->irq, dev);
1447
1448 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1449
1450 update_stats(ioaddr, dev);
1451 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1452 outl(0, ioaddr + UpListPtr);
1453 for (i = 0; i < RX_RING_SIZE; i++)
1454 if (vp->rx_skbuff[i]) {
1455 dev_kfree_skb(vp->rx_skbuff[i]);
1456 vp->rx_skbuff[i] = NULL;
1457 }
1458 }
1459 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1460 outl(0, ioaddr + DownListPtr);
1461 for (i = 0; i < TX_RING_SIZE; i++)
1462 if (vp->tx_skbuff[i]) {
1463 dev_kfree_skb(vp->tx_skbuff[i]);
1464 vp->tx_skbuff[i] = NULL;
1465 }
1466 }
1467
1468 return 0;
1469}
1470
1471static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1472{
1473 struct corkscrew_private *vp = netdev_priv(dev);
1474 unsigned long flags;
1475
1476 if (netif_running(dev)) {
1477 spin_lock_irqsave(&vp->lock, flags);
1478 update_stats(dev->base_addr, dev);
1479 spin_unlock_irqrestore(&vp->lock, flags);
1480 }
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001481 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482}
1483
1484/* Update statistics.
1485 Unlike with the EL3 we need not worry about interrupts changing
1486 the window setting from underneath us, but we must still guard
1487 against a race condition with a StatsUpdate interrupt updating the
1488 table. This is done by checking that the ASM (!) code generated uses
1489 atomic updates with '+='.
1490 */
1491static void update_stats(int ioaddr, struct net_device *dev)
1492{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1494 /* Switch to the stats window, and read everything. */
1495 EL3WINDOW(6);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001496 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1497 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001499 dev->stats.collisions += inb(ioaddr + 3);
1500 dev->stats.tx_window_errors += inb(ioaddr + 4);
1501 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1502 dev->stats.tx_packets += inb(ioaddr + 6);
1503 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 /* Rx packets */ inb(ioaddr + 7);
1505 /* Must read to clear */
1506 /* Tx deferrals */ inb(ioaddr + 8);
1507 /* Don't bother with register 9, an extension of registers 6&7.
1508 If we do use the 6&7 values the atomic update assumption above
1509 is invalid. */
1510 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1511 inw(ioaddr + 12);
1512 /* New: On the Vortex we must also clear the BadSSD counter. */
1513 EL3WINDOW(4);
1514 inb(ioaddr + 12);
1515
1516 /* We change back to window 7 (not 1) with the Vortex. */
1517 EL3WINDOW(7);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518}
1519
1520/* This new version of set_rx_mode() supports v1.4 kernels.
1521 The Vortex chip has no documented multicast filter, so the only
1522 multicast setting is to receive all multicast frames. At least
1523 the chip has a very clean way to set the mode, unlike many others. */
1524static void set_rx_mode(struct net_device *dev)
1525{
1526 int ioaddr = dev->base_addr;
1527 short new_mode;
1528
1529 if (dev->flags & IFF_PROMISC) {
1530 if (corkscrew_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001531 pr_debug("%s: Setting promiscuous mode.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 dev->name);
1533 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
Jiri Pirko59ce25d2010-02-17 23:12:15 +00001534 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1536 } else
1537 new_mode = SetRxFilter | RxStation | RxBroadcast;
1538
1539 outw(new_mode, ioaddr + EL3_CMD);
1540}
1541
1542static void netdev_get_drvinfo(struct net_device *dev,
1543 struct ethtool_drvinfo *info)
1544{
1545 strcpy(info->driver, DRV_NAME);
1546 strcpy(info->version, DRV_VERSION);
1547 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1548}
1549
1550static u32 netdev_get_msglevel(struct net_device *dev)
1551{
1552 return corkscrew_debug;
1553}
1554
1555static void netdev_set_msglevel(struct net_device *dev, u32 level)
1556{
1557 corkscrew_debug = level;
1558}
1559
Jeff Garzik7282d492006-09-13 14:30:00 -04001560static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 .get_drvinfo = netdev_get_drvinfo,
1562 .get_msglevel = netdev_get_msglevel,
1563 .set_msglevel = netdev_set_msglevel,
1564};
1565
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001566
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567#ifdef MODULE
1568void cleanup_module(void)
1569{
1570 while (!list_empty(&root_corkscrew_dev)) {
1571 struct net_device *dev;
1572 struct corkscrew_private *vp;
1573
1574 vp = list_entry(root_corkscrew_dev.next,
1575 struct corkscrew_private, list);
1576 dev = vp->our_dev;
1577 unregister_netdev(dev);
1578 cleanup_card(dev);
1579 free_netdev(dev);
1580 }
1581}
1582#endif /* MODULE */