blob: 063b049ffe558f1c787b6344a62df500dc308f82 [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>
68#include <linux/slab.h>
69#include <linux/skbuff.h>
70#include <linux/etherdevice.h>
71#include <linux/interrupt.h>
72#include <linux/timer.h>
73#include <linux/ethtool.h>
74#include <linux/bitops.h>
75
76#include <asm/uaccess.h>
77#include <asm/io.h>
78#include <asm/dma.h>
79
80#define NEW_MULTICAST
81#include <linux/delay.h>
82
83#define MAX_UNITS 8
84
85MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
86MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
87MODULE_LICENSE("GPL");
88MODULE_VERSION(DRV_VERSION);
89
90/* "Knobs" for adjusting internal parameters. */
91/* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
92#define DRIVER_DEBUG 1
93/* Some values here only for performance evaluation and path-coverage
94 debugging. */
95static int rx_nocopy, rx_copy, queued_packet;
96
97/* Number of times to check to see if the Tx FIFO has space, used in some
98 limited cases. */
99#define WAIT_TX_AVAIL 200
100
101/* Operational parameter that usually are not changed. */
102#define TX_TIMEOUT 40 /* Time in jiffies before concluding Tx hung */
103
104/* The size here is somewhat misleading: the Corkscrew also uses the ISA
105 aliased registers at <base>+0x400.
106 */
107#define CORKSCREW_TOTAL_SIZE 0x20
108
109#ifdef DRIVER_DEBUG
110static int corkscrew_debug = DRIVER_DEBUG;
111#else
112static int corkscrew_debug = 1;
113#endif
114
115#define CORKSCREW_ID 10
116
117/*
118 Theory of Operation
119
120I. Board Compatibility
121
122This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
1233Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout,
124it's not practical to integrate this driver with the other EtherLink drivers.
125
126II. Board-specific settings
127
128The Corkscrew has an EEPROM for configuration, but no special settings are
129needed for Linux.
130
131III. Driver operation
132
133The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
134PCI cards, with the bus master interface extensively modified to work with
135the ISA bus.
136
137The card is capable of full-bus-master transfers with separate
138lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
139DEC Tulip and Intel Speedo3.
140
141This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
142receive buffer. This scheme allocates full-sized skbuffs as receive
143buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is
144chosen to trade-off the memory wasted by passing the full-sized skbuff to
145the queue layer for all frames vs. the copying cost of copying a frame to a
146correctly-sized skbuff.
147
148
149IIIC. Synchronization
150The driver runs as two independent, single-threaded flows of control. One
151is the send-packet routine, which enforces single-threaded use by the netif
152layer. The other thread is the interrupt handler, which is single
153threaded by the hardware and other software.
154
155IV. Notes
156
157Thanks to Terry Murphy of 3Com for providing documentation and a development
158board.
159
160The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
161project names. I use these names to eliminate confusion -- 3Com product
162numbers and names are very similar and often confused.
163
164The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
165This driver only supports ethernet frames because of the recent MTU limit
166of 1.5K, but the changes to support 4.5K are minimal.
167*/
168
169/* Operational definitions.
170 These are not used by other compilation units and thus are not
171 exported in a ".h" file.
172
173 First the windows. There are eight register windows, with the command
174 and status registers available in each.
175 */
176#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
177#define EL3_CMD 0x0e
178#define EL3_STATUS 0x0e
179
180/* The top five bits written to EL3_CMD are a command, the lower
181 11 bits are the parameter, if applicable.
182 Note that 11 parameters bits was fine for ethernet, but the new chips
183 can handle FDDI length frames (~4500 octets) and now parameters count
184 32-bit 'Dwords' rather than octets. */
185
186enum corkscrew_cmd {
187 TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
188 RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
189 UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400190 DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
191 TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
192 AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
194 SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
195 StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
196 StatsDisable = 22 << 11, StopCoax = 23 << 11,
197};
198
199/* The SetRxFilter command accepts the following classes: */
200enum RxFilter {
201 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
202};
203
204/* Bits in the general status register. */
205enum corkscrew_status {
206 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
207 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
208 IntReq = 0x0040, StatsFull = 0x0080,
209 DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
210 DMAInProgress = 1 << 11, /* DMA controller is still busy. */
211 CmdInProgress = 1 << 12, /* EL3_CMD is still busy. */
212};
213
214/* Register window 1 offsets, the window used in normal operation.
215 On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
216enum Window1 {
217 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
218 RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
219 TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
220};
221enum Window0 {
222 Wn0IRQ = 0x08,
223#if defined(CORKSCREW)
224 Wn0EepromCmd = 0x200A, /* Corkscrew EEPROM command register. */
225 Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */
226#else
227 Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
228 Wn0EepromData = 12, /* Window 0: EEPROM results register. */
229#endif
230};
231enum Win0_EEPROM_bits {
232 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
233 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
234 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
235};
236
237/* EEPROM locations. */
238enum eeprom_offset {
239 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
240 EtherLink3ID = 7,
241};
242
243enum Window3 { /* Window 3: MAC/config bits. */
244 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
245};
Al Virob6659822008-01-13 14:17:35 +0000246enum wn3_config {
247 Ram_size = 7,
248 Ram_width = 8,
249 Ram_speed = 0x30,
250 Rom_size = 0xc0,
251 Ram_split_shift = 16,
252 Ram_split = 3 << Ram_split_shift,
253 Xcvr_shift = 20,
254 Xcvr = 7 << Xcvr_shift,
255 Autoselect = 0x1000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256};
257
258enum Window4 {
259 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */
260};
261enum Win4_Media_bits {
262 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
263 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
264 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
265 Media_LnkBeat = 0x0800,
266};
267enum Window7 { /* Window 7: Bus Master control. */
268 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
269};
270
271/* Boomerang-style bus master control registers. Note ISA aliases! */
272enum MasterCtrl {
273 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
274 0x40c,
275 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
276};
277
278/* The Rx and Tx descriptor lists.
279 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
280 alignment contraint on tx_ring[] and rx_ring[]. */
281struct boom_rx_desc {
282 u32 next;
283 s32 status;
284 u32 addr;
285 s32 length;
286};
287
288/* Values for the Rx status entry. */
289enum rx_desc_status {
290 RxDComplete = 0x00008000, RxDError = 0x4000,
291 /* See boomerang_rx() for actual error bits */
292};
293
294struct boom_tx_desc {
295 u32 next;
296 s32 status;
297 u32 addr;
298 s32 length;
299};
300
301struct corkscrew_private {
302 const char *product_name;
303 struct list_head list;
304 struct net_device *our_dev;
305 /* The Rx and Tx rings are here to keep them quad-word-aligned. */
306 struct boom_rx_desc rx_ring[RX_RING_SIZE];
307 struct boom_tx_desc tx_ring[TX_RING_SIZE];
308 /* The addresses of transmit- and receive-in-place skbuffs. */
309 struct sk_buff *rx_skbuff[RX_RING_SIZE];
310 struct sk_buff *tx_skbuff[TX_RING_SIZE];
311 unsigned int cur_rx, cur_tx; /* The next free ring entry */
312 unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
314 struct timer_list timer; /* Media selection timer. */
315 int capabilities ; /* Adapter capabilities word. */
316 int options; /* User-settable misc. driver options. */
317 int last_rx_packets; /* For media autoselection. */
318 unsigned int available_media:8, /* From Wn3_Options */
319 media_override:3, /* Passed-in media type. */
320 default_media:3, /* Read from the EEPROM. */
321 full_duplex:1, autoselect:1, bus_master:1, /* Vortex can only do a fragment bus-m. */
322 full_bus_master_tx:1, full_bus_master_rx:1, /* Boomerang */
323 tx_full:1;
324 spinlock_t lock;
325 struct device *dev;
326};
327
328/* The action to take with a media selection timer tick.
329 Note that we deviate from the 3Com order by checking 10base2 before AUI.
330 */
331enum xcvr_types {
332 XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
333 XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
334};
335
336static struct media_table {
337 char *name;
338 unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */
339 mask:8, /* The transceiver-present bit in Wn3_Config. */
340 next:8; /* The media type to try next. */
341 short wait; /* Time before we check media status. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400342} media_tbl[] = {
343 { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
344 { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
345 { "undefined", 0, 0x80, XCVR_10baseT, 10000},
346 { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
347 { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
348 { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
349 { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
350 { "undefined", 0, 0x01, XCVR_10baseT, 10000},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 { "Default", 0, 0xFF, XCVR_10baseT, 10000},
352};
353
354#ifdef __ISAPNP__
355static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
356 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
357 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
358 (long) "3Com Fast EtherLink ISA" },
359 { } /* terminate list */
360};
361
362MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
363
364static int nopnp;
365#endif /* __ISAPNP__ */
366
367static struct net_device *corkscrew_scan(int unit);
b1fc5502005-05-12 20:11:55 -0400368static int corkscrew_setup(struct net_device *dev, int ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 struct pnp_dev *idev, int card_number);
370static int corkscrew_open(struct net_device *dev);
371static void corkscrew_timer(unsigned long arg);
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000372static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
373 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374static int corkscrew_rx(struct net_device *dev);
375static void corkscrew_timeout(struct net_device *dev);
376static int boomerang_rx(struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100377static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378static int corkscrew_close(struct net_device *dev);
379static void update_stats(int addr, struct net_device *dev);
380static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
381static void set_rx_mode(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400382static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400384
385/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 Unfortunately maximizing the shared code between the integrated and
387 module version of the driver results in a complicated set of initialization
388 procedures.
389 init_module() -- modules / tc59x_init() -- built-in
390 The wrappers for corkscrew_scan()
391 corkscrew_scan() The common routine that scans for PCI and EISA cards
392 corkscrew_found_device() Allocate a device structure when we find a card.
393 Different versions exist for modules and built-in.
394 corkscrew_probe1() Fill in the device structure -- this is separated
395 so that the modules code can put it in dev->init.
396*/
397/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
398/* Note: this is the only limit on the number of cards supported!! */
399static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
400
401#ifdef MODULE
402static int debug = -1;
403
404module_param(debug, int, 0);
405module_param_array(options, int, NULL, 0);
406module_param(rx_copybreak, int, 0);
407module_param(max_interrupt_work, int, 0);
408MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
409MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
410MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
411MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
412
413/* A list of all installed Vortex devices, for removing the driver module. */
414/* we will need locking (and refcounting) if we ever use it for more */
415static LIST_HEAD(root_corkscrew_dev);
416
417int init_module(void)
418{
419 int found = 0;
420 if (debug >= 0)
421 corkscrew_debug = debug;
422 if (corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000423 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 while (corkscrew_scan(-1))
425 found++;
426 return found ? 0 : -ENODEV;
427}
428
429#else
430struct net_device *tc515_probe(int unit)
431{
432 struct net_device *dev = corkscrew_scan(unit);
433 static int printed;
434
435 if (!dev)
436 return ERR_PTR(-ENODEV);
437
438 if (corkscrew_debug > 0 && !printed) {
439 printed = 1;
Alexander Beregalov39738e12009-05-26 12:35:26 +0000440 pr_debug("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 }
442
443 return dev;
444}
445#endif /* not MODULE */
446
447static int check_device(unsigned ioaddr)
448{
449 int timer;
450
451 if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
452 return 0;
453 /* Check the resource configuration for a matching ioaddr. */
454 if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
455 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
456 return 0;
457 }
458 /* Verify by reading the device ID from the EEPROM. */
459 outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
460 /* Pause for at least 162 us. for the read to take place. */
461 for (timer = 4; timer >= 0; timer--) {
462 udelay(162);
463 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
464 break;
465 }
466 if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
467 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
468 return 0;
469 }
470 return 1;
471}
472
473static void cleanup_card(struct net_device *dev)
474{
475 struct corkscrew_private *vp = netdev_priv(dev);
476 list_del_init(&vp->list);
477 if (dev->dma)
478 free_dma(dev->dma);
479 outw(TotalReset, dev->base_addr + EL3_CMD);
480 release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
481 if (vp->dev)
482 pnp_device_detach(to_pnp_dev(vp->dev));
483}
484
485static struct net_device *corkscrew_scan(int unit)
486{
487 struct net_device *dev;
488 static int cards_found = 0;
489 static int ioaddr;
490 int err;
491#ifdef __ISAPNP__
492 short i;
493 static int pnp_cards;
494#endif
495
496 dev = alloc_etherdev(sizeof(struct corkscrew_private));
497 if (!dev)
498 return ERR_PTR(-ENOMEM);
499
500 if (unit >= 0) {
501 sprintf(dev->name, "eth%d", unit);
502 netdev_boot_setup_check(dev);
503 }
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505#ifdef __ISAPNP__
506 if(nopnp == 1)
507 goto no_pnp;
508 for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
509 struct pnp_dev *idev = NULL;
510 int irq;
511 while((idev = pnp_find_dev(NULL,
512 corkscrew_isapnp_adapters[i].vendor,
513 corkscrew_isapnp_adapters[i].function,
514 idev))) {
515
516 if (pnp_device_attach(idev) < 0)
517 continue;
518 if (pnp_activate_dev(idev) < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000519 pr_warning("pnp activate failed (out of resources?)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 pnp_device_detach(idev);
521 continue;
522 }
523 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
524 pnp_device_detach(idev);
525 continue;
526 }
527 ioaddr = pnp_port_start(idev, 0);
528 irq = pnp_irq(idev, 0);
529 if (!check_device(ioaddr)) {
530 pnp_device_detach(idev);
531 continue;
532 }
533 if(corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000534 pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000536 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
538 /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 SET_NETDEV_DEV(dev, &idev->dev);
540 pnp_cards++;
b1fc5502005-05-12 20:11:55 -0400541 err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 if (!err)
543 return dev;
544 cleanup_card(dev);
545 }
546 }
547no_pnp:
548#endif /* __ISAPNP__ */
549
550 /* Check all locations on the ISA bus -- evil! */
551 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
552 if (!check_device(ioaddr))
553 continue;
554
Alexander Beregalov39738e12009-05-26 12:35:26 +0000555 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
b1fc5502005-05-12 20:11:55 -0400557 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 if (!err)
559 return dev;
560 cleanup_card(dev);
561 }
562 free_netdev(dev);
563 return NULL;
564}
565
Stephen Hemmingerf3701c22009-01-09 13:01:15 +0000566
567static const struct net_device_ops netdev_ops = {
568 .ndo_open = corkscrew_open,
569 .ndo_stop = corkscrew_close,
570 .ndo_start_xmit = corkscrew_start_xmit,
571 .ndo_tx_timeout = corkscrew_timeout,
572 .ndo_get_stats = corkscrew_get_stats,
573 .ndo_set_multicast_list = set_rx_mode,
574 .ndo_change_mtu = eth_change_mtu,
575 .ndo_set_mac_address = eth_mac_addr,
576 .ndo_validate_addr = eth_validate_addr,
577};
578
579
b1fc5502005-05-12 20:11:55 -0400580static int corkscrew_setup(struct net_device *dev, int ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 struct pnp_dev *idev, int card_number)
582{
583 struct corkscrew_private *vp = netdev_priv(dev);
584 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
585 int i;
586 int irq;
587
Randy Dunlap92fbc1c2008-05-16 10:35:24 -0700588#ifdef __ISAPNP__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 if (idev) {
590 irq = pnp_irq(idev, 0);
591 vp->dev = &idev->dev;
592 } else {
593 irq = inw(ioaddr + 0x2002) & 15;
594 }
Randy Dunlap92fbc1c2008-05-16 10:35:24 -0700595#else
596 irq = inw(ioaddr + 0x2002) & 15;
597#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599 dev->base_addr = ioaddr;
600 dev->irq = irq;
601 dev->dma = inw(ioaddr + 0x2000) & 7;
602 vp->product_name = "3c515";
603 vp->options = dev->mem_start;
604 vp->our_dev = dev;
605
606 if (!vp->options) {
607 if (card_number >= MAX_UNITS)
608 vp->options = -1;
609 else
610 vp->options = options[card_number];
611 }
612
613 if (vp->options >= 0) {
614 vp->media_override = vp->options & 7;
615 if (vp->media_override == 2)
616 vp->media_override = 0;
617 vp->full_duplex = (vp->options & 8) ? 1 : 0;
618 vp->bus_master = (vp->options & 16) ? 1 : 0;
619 } else {
620 vp->media_override = 7;
621 vp->full_duplex = 0;
622 vp->bus_master = 0;
623 }
624#ifdef MODULE
625 list_add(&vp->list, &root_corkscrew_dev);
626#endif
627
Alexander Beregalov39738e12009-05-26 12:35:26 +0000628 pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630 spin_lock_init(&vp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 /* Read the station address from the EEPROM. */
633 EL3WINDOW(0);
634 for (i = 0; i < 0x18; i++) {
Al Virob6659822008-01-13 14:17:35 +0000635 __be16 *phys_addr = (__be16 *) dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 int timer;
637 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
638 /* Pause for at least 162 us. for the read to take place. */
639 for (timer = 4; timer >= 0; timer--) {
640 udelay(162);
641 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
642 break;
643 }
644 eeprom[i] = inw(ioaddr + Wn0EepromData);
645 checksum ^= eeprom[i];
646 if (i < 3)
647 phys_addr[i] = htons(eeprom[i]);
648 }
649 checksum = (checksum ^ (checksum >> 8)) & 0xff;
650 if (checksum != 0x00)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000651 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
652 pr_cont(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (eeprom[16] == 0x11c7) { /* Corkscrew */
654 if (request_dma(dev->dma, "3c515")) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000655 pr_cont(", DMA %d allocation failed", dev->dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 dev->dma = 0;
657 } else
Alexander Beregalov39738e12009-05-26 12:35:26 +0000658 pr_cont(", DMA %d", dev->dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 }
Alexander Beregalov39738e12009-05-26 12:35:26 +0000660 pr_cont(", IRQ %d\n", dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 /* Tell them about an invalid IRQ. */
662 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
Alexander Beregalov39738e12009-05-26 12:35:26 +0000663 pr_warning(" *** Warning: this IRQ is unlikely to work! ***\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 {
666 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
Al Virob6659822008-01-13 14:17:35 +0000667 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 EL3WINDOW(3);
669 vp->available_media = inw(ioaddr + Wn3_Options);
Al Virob6659822008-01-13 14:17:35 +0000670 config = inl(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000672 pr_info(" Internal config register is %4.4x, transceivers %#x.\n",
Al Virob6659822008-01-13 14:17:35 +0000673 config, inw(ioaddr + Wn3_Options));
Alexander Beregalov39738e12009-05-26 12:35:26 +0000674 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
Al Virob6659822008-01-13 14:17:35 +0000675 8 << config & Ram_size,
676 config & Ram_width ? "word" : "byte",
677 ram_split[(config & Ram_split) >> Ram_split_shift],
678 config & Autoselect ? "autoselect/" : "",
679 media_tbl[(config & Xcvr) >> Xcvr_shift].name);
680 vp->default_media = (config & Xcvr) >> Xcvr_shift;
681 vp->autoselect = config & Autoselect ? 1 : 0;
682 dev->if_port = vp->default_media;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 }
684 if (vp->media_override != 7) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000685 pr_info(" Media override to transceiver type %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 vp->media_override,
687 media_tbl[vp->media_override].name);
688 dev->if_port = vp->media_override;
689 }
690
691 vp->capabilities = eeprom[16];
692 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
693 /* Rx is broken at 10mbps, so we always disable it. */
694 /* vp->full_bus_master_rx = 0; */
695 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
696
697 /* The 3c51x-specific entries in the device structure. */
Stephen Hemmingerf3701c22009-01-09 13:01:15 +0000698 dev->netdev_ops = &netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 dev->watchdog_timeo = (400 * HZ) / 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 dev->ethtool_ops = &netdev_ethtool_ops;
b1fc5502005-05-12 20:11:55 -0400701
702 return register_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
706static int corkscrew_open(struct net_device *dev)
707{
708 int ioaddr = dev->base_addr;
709 struct corkscrew_private *vp = netdev_priv(dev);
Al Virob6659822008-01-13 14:17:35 +0000710 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 int i;
712
713 /* Before initializing select the active media port. */
714 EL3WINDOW(3);
715 if (vp->full_duplex)
716 outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
Al Virob6659822008-01-13 14:17:35 +0000717 config = inl(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 if (vp->media_override != 7) {
720 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000721 pr_info("%s: Media override to transceiver %d (%s).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 dev->name, vp->media_override,
723 media_tbl[vp->media_override].name);
724 dev->if_port = vp->media_override;
725 } else if (vp->autoselect) {
726 /* Find first available media type, starting with 100baseTx. */
727 dev->if_port = 4;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400728 while (!(vp->available_media & media_tbl[dev->if_port].mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 dev->if_port = media_tbl[dev->if_port].next;
730
731 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000732 pr_debug("%s: Initial media type %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 dev->name, media_tbl[dev->if_port].name);
734
735 init_timer(&vp->timer);
736 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
737 vp->timer.data = (unsigned long) dev;
738 vp->timer.function = &corkscrew_timer; /* timer handler */
739 add_timer(&vp->timer);
740 } else
741 dev->if_port = vp->default_media;
742
Al Virob6659822008-01-13 14:17:35 +0000743 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
744 outl(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746 if (corkscrew_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000747 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
Al Virob6659822008-01-13 14:17:35 +0000748 dev->name, config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 }
750
751 outw(TxReset, ioaddr + EL3_CMD);
752 for (i = 20; i >= 0; i--)
753 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
754 break;
755
756 outw(RxReset, ioaddr + EL3_CMD);
757 /* Wait a few ticks for the RxReset command to complete. */
758 for (i = 20; i >= 0; i--)
759 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
760 break;
761
762 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
763
764 /* Use the now-standard shared IRQ implementation. */
765 if (vp->capabilities == 0x11c7) {
766 /* Corkscrew: Cannot share ISA resources. */
Joe Perches8e95a202009-12-03 07:58:21 +0000767 if (dev->irq == 0 ||
768 dev->dma == 0 ||
769 request_irq(dev->irq, corkscrew_interrupt, 0,
770 vp->product_name, dev))
771 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 enable_dma(dev->dma);
773 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
Joe Perchesa0607fd2009-11-18 23:29:17 -0800774 } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 vp->product_name, dev)) {
776 return -EAGAIN;
777 }
778
779 if (corkscrew_debug > 1) {
780 EL3WINDOW(4);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000781 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 dev->name, dev->irq, inw(ioaddr + Wn4_Media));
783 }
784
785 /* Set the station address and mask in window 2 each time opened. */
786 EL3WINDOW(2);
787 for (i = 0; i < 6; i++)
788 outb(dev->dev_addr[i], ioaddr + i);
789 for (; i < 12; i += 2)
790 outw(0, ioaddr + i);
791
792 if (dev->if_port == 3)
793 /* Start the thinnet transceiver. We should really wait 50ms... */
794 outw(StartCoax, ioaddr + EL3_CMD);
795 EL3WINDOW(4);
796 outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
797 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
798
799 /* Switch to the stats window, and clear all stats by reading. */
800 outw(StatsDisable, ioaddr + EL3_CMD);
801 EL3WINDOW(6);
802 for (i = 0; i < 10; i++)
803 inb(ioaddr + i);
804 inw(ioaddr + 10);
805 inw(ioaddr + 12);
806 /* New: On the Vortex we must also clear the BadSSD counter. */
807 EL3WINDOW(4);
808 inb(ioaddr + 12);
809 /* ..and on the Boomerang we enable the extra statistics bits. */
810 outw(0x0040, ioaddr + Wn4_NetDiag);
811
812 /* Switch to register set 7 for normal use. */
813 EL3WINDOW(7);
814
815 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
816 vp->cur_rx = vp->dirty_rx = 0;
817 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000818 pr_debug("%s: Filling in the Rx ring.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 for (i = 0; i < RX_RING_SIZE; i++) {
820 struct sk_buff *skb;
821 if (i < (RX_RING_SIZE - 1))
822 vp->rx_ring[i].next =
823 isa_virt_to_bus(&vp->rx_ring[i + 1]);
824 else
825 vp->rx_ring[i].next = 0;
826 vp->rx_ring[i].status = 0; /* Clear complete bit. */
827 vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
828 skb = dev_alloc_skb(PKT_BUF_SZ);
829 vp->rx_skbuff[i] = skb;
830 if (skb == NULL)
831 break; /* Bad news! */
832 skb->dev = dev; /* Mark as being used by this device. */
833 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -0700834 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 }
roel kluin3d540152009-07-30 00:26:32 +0000836 if (i != 0)
837 vp->rx_ring[i - 1].next =
838 isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
840 }
841 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
842 vp->cur_tx = vp->dirty_tx = 0;
843 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */
844 /* Clear the Tx ring. */
845 for (i = 0; i < TX_RING_SIZE; i++)
846 vp->tx_skbuff[i] = NULL;
847 outl(0, ioaddr + DownListPtr);
848 }
849 /* Set receiver mode: presumably accept b-case and phys addr only. */
850 set_rx_mode(dev);
851 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
852
853 netif_start_queue(dev);
854
855 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
856 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
857 /* Allow status bits to be seen. */
858 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
859 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
860 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
861 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
862 /* Ack all pending events, and set active indicator mask. */
863 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
864 ioaddr + EL3_CMD);
865 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
866 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
867 ioaddr + EL3_CMD);
868
869 return 0;
870}
871
872static void corkscrew_timer(unsigned long data)
873{
874#ifdef AUTOMEDIA
875 struct net_device *dev = (struct net_device *) data;
876 struct corkscrew_private *vp = netdev_priv(dev);
877 int ioaddr = dev->base_addr;
878 unsigned long flags;
879 int ok = 0;
880
881 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000882 pr_debug("%s: Media selection timer tick happened, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 dev->name, media_tbl[dev->if_port].name);
884
885 spin_lock_irqsave(&vp->lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 {
888 int old_window = inw(ioaddr + EL3_CMD) >> 13;
889 int media_status;
890 EL3WINDOW(4);
891 media_status = inw(ioaddr + Wn4_Media);
892 switch (dev->if_port) {
893 case 0:
894 case 4:
895 case 5: /* 10baseT, 100baseTX, 100baseFX */
896 if (media_status & Media_LnkBeat) {
897 ok = 1;
898 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000899 pr_debug("%s: Media %s has link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 dev->name,
901 media_tbl[dev->if_port].name,
902 media_status);
903 } else if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000904 pr_debug("%s: Media %s is has no link beat, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 dev->name,
906 media_tbl[dev->if_port].name,
907 media_status);
908
909 break;
910 default: /* Other media types handled by Tx timeouts. */
911 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000912 pr_debug("%s: Media %s is has no indication, %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 dev->name,
914 media_tbl[dev->if_port].name,
915 media_status);
916 ok = 1;
917 }
918 if (!ok) {
Al Virob6659822008-01-13 14:17:35 +0000919 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 do {
922 dev->if_port =
923 media_tbl[dev->if_port].next;
924 }
925 while (!(vp->available_media & media_tbl[dev->if_port].mask));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 if (dev->if_port == 8) { /* Go back to default. */
928 dev->if_port = vp->default_media;
929 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000930 pr_debug("%s: Media selection failing, using default %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 dev->name,
932 media_tbl[dev->if_port].name);
933 } else {
934 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000935 pr_debug("%s: Media selection failed, now trying %s port.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 dev->name,
937 media_tbl[dev->if_port].name);
938 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
939 add_timer(&vp->timer);
940 }
941 outw((media_status & ~(Media_10TP | Media_SQE)) |
942 media_tbl[dev->if_port].media_bits,
943 ioaddr + Wn4_Media);
944
945 EL3WINDOW(3);
Al Virob6659822008-01-13 14:17:35 +0000946 config = inl(ioaddr + Wn3_Config);
947 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
948 outl(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 outw(dev->if_port == 3 ? StartCoax : StopCoax,
951 ioaddr + EL3_CMD);
952 }
953 EL3WINDOW(old_window);
954 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 spin_unlock_irqrestore(&vp->lock, flags);
957 if (corkscrew_debug > 1)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000958 pr_debug("%s: Media selection timer finished, %s.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 dev->name, media_tbl[dev->if_port].name);
960
961#endif /* AUTOMEDIA */
962 return;
963}
964
965static void corkscrew_timeout(struct net_device *dev)
966{
967 int i;
968 struct corkscrew_private *vp = netdev_priv(dev);
969 int ioaddr = dev->base_addr;
970
Alexander Beregalov39738e12009-05-26 12:35:26 +0000971 pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 dev->name, inb(ioaddr + TxStatus),
973 inw(ioaddr + EL3_STATUS));
974 /* Slight code bloat to be user friendly. */
975 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000976 pr_warning("%s: Transmitter encountered 16 collisions --"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 " network cable problem?\n", dev->name);
978#ifndef final_version
Alexander Beregalov39738e12009-05-26 12:35:26 +0000979 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
981 vp->cur_tx);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000982 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 &vp->tx_ring[0]);
984 for (i = 0; i < TX_RING_SIZE; i++) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000985 pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 &vp->tx_ring[i],
987 vp->tx_ring[i].length, vp->tx_ring[i].status);
988 }
989#endif
990 /* Issue TX_RESET and TX_START commands. */
991 outw(TxReset, ioaddr + EL3_CMD);
992 for (i = 20; i >= 0; i--)
993 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
994 break;
995 outw(TxEnable, ioaddr + EL3_CMD);
996 dev->trans_start = jiffies;
Paulius Zaleckasdfd44152008-04-29 03:07:31 +0300997 dev->stats.tx_errors++;
998 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 netif_wake_queue(dev);
1000}
1001
Stephen Hemminger27a1de92009-08-31 19:50:54 +00001002static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1003 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004{
1005 struct corkscrew_private *vp = netdev_priv(dev);
1006 int ioaddr = dev->base_addr;
1007
1008 /* Block a timer-based transmit from overlapping. */
1009
1010 netif_stop_queue(dev);
1011
1012 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
1013 /* Calculate the next Tx descriptor entry. */
1014 int entry = vp->cur_tx % TX_RING_SIZE;
1015 struct boom_tx_desc *prev_entry;
Eric Sesterhenncb958182006-08-19 19:37:57 +02001016 unsigned long flags;
1017 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
1019 if (vp->tx_full) /* No room to transmit with */
Patrick McHardy5b548142009-06-12 06:22:29 +00001020 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 if (vp->cur_tx != 0)
1022 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1023 else
1024 prev_entry = NULL;
1025 if (corkscrew_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001026 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 dev->name, vp->cur_tx);
1028 /* vp->tx_full = 1; */
1029 vp->tx_skbuff[entry] = skb;
1030 vp->tx_ring[entry].next = 0;
1031 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1032 vp->tx_ring[entry].length = skb->len | 0x80000000;
1033 vp->tx_ring[entry].status = skb->len | 0x80000000;
1034
1035 spin_lock_irqsave(&vp->lock, flags);
1036 outw(DownStall, ioaddr + EL3_CMD);
1037 /* Wait for the stall to complete. */
1038 for (i = 20; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001039 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 break;
1041 if (prev_entry)
1042 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1043 if (inl(ioaddr + DownListPtr) == 0) {
1044 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1045 ioaddr + DownListPtr);
1046 queued_packet++;
1047 }
1048 outw(DownUnstall, ioaddr + EL3_CMD);
1049 spin_unlock_irqrestore(&vp->lock, flags);
1050
1051 vp->cur_tx++;
1052 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1053 vp->tx_full = 1;
1054 else { /* Clear previous interrupt enable. */
1055 if (prev_entry)
1056 prev_entry->status &= ~0x80000000;
1057 netif_wake_queue(dev);
1058 }
1059 dev->trans_start = jiffies;
Patrick McHardy6ed10652009-06-23 06:03:08 +00001060 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 }
1062 /* Put out the doubleword header... */
1063 outl(skb->len, ioaddr + TX_FIFO);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001064 dev->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065#ifdef VORTEX_BUS_MASTER
1066 if (vp->bus_master) {
1067 /* Set the bus-master controller to transfer the packet. */
1068 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1069 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1070 vp->tx_skb = skb;
1071 outw(StartDMADown, ioaddr + EL3_CMD);
1072 /* queue will be woken at the DMADone interrupt. */
1073 } else {
1074 /* ... and the packet rounded to a doubleword. */
1075 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1076 dev_kfree_skb(skb);
1077 if (inw(ioaddr + TxFree) > 1536) {
1078 netif_wake_queue(dev);
1079 } else
1080 /* Interrupt us when the FIFO has room for max-sized packet. */
1081 outw(SetTxThreshold + (1536 >> 2),
1082 ioaddr + EL3_CMD);
1083 }
1084#else
1085 /* ... and the packet rounded to a doubleword. */
1086 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1087 dev_kfree_skb(skb);
1088 if (inw(ioaddr + TxFree) > 1536) {
1089 netif_wake_queue(dev);
1090 } else
1091 /* Interrupt us when the FIFO has room for max-sized packet. */
1092 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1093#endif /* bus master */
1094
1095 dev->trans_start = jiffies;
1096
1097 /* Clear the Tx status stack. */
1098 {
1099 short tx_status;
1100 int i = 4;
1101
1102 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1103 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1104 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001105 pr_debug("%s: Tx error, status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 dev->name, tx_status);
1107 if (tx_status & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001108 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 if (tx_status & 0x38)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001110 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 if (tx_status & 0x30) {
1112 int j;
1113 outw(TxReset, ioaddr + EL3_CMD);
1114 for (j = 20; j >= 0; j--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001115 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 break;
1117 }
1118 outw(TxEnable, ioaddr + EL3_CMD);
1119 }
1120 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1121 }
1122 }
Patrick McHardy6ed10652009-06-23 06:03:08 +00001123 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124}
1125
1126/* The interrupt handler does all of the Rx thread work and cleans up
1127 after the Tx thread. */
1128
David Howells7d12e782006-10-05 14:55:46 +01001129static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
1131 /* Use the now-standard shared IRQ implementation. */
1132 struct net_device *dev = dev_id;
1133 struct corkscrew_private *lp = netdev_priv(dev);
1134 int ioaddr, status;
1135 int latency;
1136 int i = max_interrupt_work;
1137
1138 ioaddr = dev->base_addr;
1139 latency = inb(ioaddr + Timer);
1140
1141 spin_lock(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 status = inw(ioaddr + EL3_STATUS);
1144
1145 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001146 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 dev->name, status, latency);
1148 if ((status & 0xE000) != 0xE000) {
1149 static int donedidthis;
1150 /* Some interrupt controllers store a bogus interrupt from boot-time.
1151 Ignore a single early interrupt, but don't hang the machine for
1152 other interrupt problems. */
1153 if (donedidthis++ > 100) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001154 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 dev->name, status, netif_running(dev));
1156 free_irq(dev->irq, dev);
1157 dev->irq = -1;
1158 }
1159 }
1160
1161 do {
1162 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001163 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 dev->name, status);
1165 if (status & RxComplete)
1166 corkscrew_rx(dev);
1167
1168 if (status & TxAvailable) {
1169 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001170 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 /* There's room in the FIFO for a full-sized packet. */
1172 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1173 netif_wake_queue(dev);
1174 }
1175 if (status & DownComplete) {
1176 unsigned int dirty_tx = lp->dirty_tx;
1177
1178 while (lp->cur_tx - dirty_tx > 0) {
1179 int entry = dirty_tx % TX_RING_SIZE;
1180 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1181 break; /* It still hasn't been processed. */
1182 if (lp->tx_skbuff[entry]) {
1183 dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1184 lp->tx_skbuff[entry] = NULL;
1185 }
1186 dirty_tx++;
1187 }
1188 lp->dirty_tx = dirty_tx;
1189 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1190 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1191 lp->tx_full = 0;
1192 netif_wake_queue(dev);
1193 }
1194 }
1195#ifdef VORTEX_BUS_MASTER
1196 if (status & DMADone) {
1197 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1198 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1199 netif_wake_queue(dev);
1200 }
1201#endif
1202 if (status & UpComplete) {
1203 boomerang_rx(dev);
1204 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1205 }
1206 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1207 /* Handle all uncommon interrupts at once. */
1208 if (status & RxEarly) { /* Rx early is unused. */
1209 corkscrew_rx(dev);
1210 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1211 }
1212 if (status & StatsFull) { /* Empty statistics. */
1213 static int DoneDidThat;
1214 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001215 pr_debug("%s: Updating stats.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 update_stats(ioaddr, dev);
1217 /* DEBUG HACK: Disable statistics as an interrupt source. */
1218 /* This occurs when we have the wrong media type! */
1219 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1220 int win, reg;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001221 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1222 dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 for (win = 0; win < 8; win++) {
1224 EL3WINDOW(win);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001225 pr_notice("Vortex window %d:", win);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 for (reg = 0; reg < 16; reg++)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001227 pr_cont(" %2.2x", inb(ioaddr + reg));
1228 pr_cont("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
1230 EL3WINDOW(7);
1231 outw(SetIntrEnb | TxAvailable |
1232 RxComplete | AdapterFailure |
1233 UpComplete | DownComplete |
1234 TxComplete, ioaddr + EL3_CMD);
1235 DoneDidThat++;
1236 }
1237 }
1238 if (status & AdapterFailure) {
1239 /* Adapter failure requires Rx reset and reinit. */
1240 outw(RxReset, ioaddr + EL3_CMD);
1241 /* Set the Rx filter to the current state. */
1242 set_rx_mode(dev);
1243 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1244 outw(AckIntr | AdapterFailure,
1245 ioaddr + EL3_CMD);
1246 }
1247 }
1248
1249 if (--i < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001250 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1251 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 /* Disable all pending interrupts. */
1253 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1254 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1255 break;
1256 }
1257 /* Acknowledge the IRQ. */
1258 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1259
1260 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 spin_unlock(&lp->lock);
1263
1264 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001265 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 return IRQ_HANDLED;
1267}
1268
1269static int corkscrew_rx(struct net_device *dev)
1270{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 int ioaddr = dev->base_addr;
1272 int i;
1273 short rx_status;
1274
1275 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001276 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1278 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1279 if (rx_status & 0x4000) { /* Error, update stats. */
1280 unsigned char rx_error = inb(ioaddr + RxErrors);
1281 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001282 pr_debug(" Rx error: status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001284 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001286 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001288 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001290 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001292 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001294 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 } else {
1296 /* The packet length: up to 4.5K!. */
1297 short pkt_len = rx_status & 0x1fff;
1298 struct sk_buff *skb;
1299
1300 skb = dev_alloc_skb(pkt_len + 5 + 2);
1301 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001302 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 pkt_len, rx_status);
1304 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1306 /* 'skb_put()' points to the start of sk_buff data area. */
1307 insl(ioaddr + RX_FIFO,
1308 skb_put(skb, pkt_len),
1309 (pkt_len + 3) >> 2);
1310 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1311 skb->protocol = eth_type_trans(skb, dev);
1312 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001313 dev->stats.rx_packets++;
1314 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 /* Wait a limited time to go to next packet. */
1316 for (i = 200; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001317 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 break;
1319 continue;
1320 } else if (corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001321 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 }
1323 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001324 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 /* Wait a limited time to skip this packet. */
1326 for (i = 200; i >= 0; i--)
1327 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1328 break;
1329 }
1330 return 0;
1331}
1332
1333static int boomerang_rx(struct net_device *dev)
1334{
1335 struct corkscrew_private *vp = netdev_priv(dev);
1336 int entry = vp->cur_rx % RX_RING_SIZE;
1337 int ioaddr = dev->base_addr;
1338 int rx_status;
1339
1340 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001341 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1343 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1344 if (rx_status & RxDError) { /* Error, update stats. */
1345 unsigned char rx_error = rx_status >> 16;
1346 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001347 pr_debug(" Rx error: status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001349 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001351 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001353 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001355 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001357 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001359 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 } else {
1361 /* The packet length: up to 4.5K!. */
1362 short pkt_len = rx_status & 0x1fff;
1363 struct sk_buff *skb;
1364
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001365 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001367 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 pkt_len, rx_status);
1369
1370 /* Check if the packet is long enough to just accept without
1371 copying to a properly sized skbuff. */
Joe Perches8e95a202009-12-03 07:58:21 +00001372 if (pkt_len < rx_copybreak &&
1373 (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1375 /* 'skb_put()' points to the start of sk_buff data area. */
1376 memcpy(skb_put(skb, pkt_len),
1377 isa_bus_to_virt(vp->rx_ring[entry].
1378 addr), pkt_len);
1379 rx_copy++;
1380 } else {
1381 void *temp;
1382 /* Pass up the skbuff already on the Rx ring. */
1383 skb = vp->rx_skbuff[entry];
1384 vp->rx_skbuff[entry] = NULL;
1385 temp = skb_put(skb, pkt_len);
1386 /* Remove this checking code for final release. */
1387 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001388 pr_warning("%s: Warning -- the skbuff addresses do not match"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 " in boomerang_rx: %p vs. %p / %p.\n",
1390 dev->name,
1391 isa_bus_to_virt(vp->
1392 rx_ring[entry].
1393 addr), skb->head,
1394 temp);
1395 rx_nocopy++;
1396 }
1397 skb->protocol = eth_type_trans(skb, dev);
1398 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001399 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 }
1401 entry = (++vp->cur_rx) % RX_RING_SIZE;
1402 }
1403 /* Refill the Rx ring buffers. */
1404 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1405 struct sk_buff *skb;
1406 entry = vp->dirty_rx % RX_RING_SIZE;
1407 if (vp->rx_skbuff[entry] == NULL) {
1408 skb = dev_alloc_skb(PKT_BUF_SZ);
1409 if (skb == NULL)
1410 break; /* Bad news! */
1411 skb->dev = dev; /* Mark as being used by this device. */
1412 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -07001413 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 vp->rx_skbuff[entry] = skb;
1415 }
1416 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1417 }
1418 return 0;
1419}
1420
1421static int corkscrew_close(struct net_device *dev)
1422{
1423 struct corkscrew_private *vp = netdev_priv(dev);
1424 int ioaddr = dev->base_addr;
1425 int i;
1426
1427 netif_stop_queue(dev);
1428
1429 if (corkscrew_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001430 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 dev->name, inw(ioaddr + EL3_STATUS),
1432 inb(ioaddr + TxStatus));
Alexander Beregalov39738e12009-05-26 12:35:26 +00001433 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1434 dev->name, rx_nocopy, rx_copy, queued_packet);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 }
1436
1437 del_timer(&vp->timer);
1438
1439 /* Turn off statistics ASAP. We update lp->stats below. */
1440 outw(StatsDisable, ioaddr + EL3_CMD);
1441
1442 /* Disable the receiver and transmitter. */
1443 outw(RxDisable, ioaddr + EL3_CMD);
1444 outw(TxDisable, ioaddr + EL3_CMD);
1445
1446 if (dev->if_port == XCVR_10base2)
1447 /* Turn off thinnet power. Green! */
1448 outw(StopCoax, ioaddr + EL3_CMD);
1449
1450 free_irq(dev->irq, dev);
1451
1452 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1453
1454 update_stats(ioaddr, dev);
1455 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1456 outl(0, ioaddr + UpListPtr);
1457 for (i = 0; i < RX_RING_SIZE; i++)
1458 if (vp->rx_skbuff[i]) {
1459 dev_kfree_skb(vp->rx_skbuff[i]);
1460 vp->rx_skbuff[i] = NULL;
1461 }
1462 }
1463 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1464 outl(0, ioaddr + DownListPtr);
1465 for (i = 0; i < TX_RING_SIZE; i++)
1466 if (vp->tx_skbuff[i]) {
1467 dev_kfree_skb(vp->tx_skbuff[i]);
1468 vp->tx_skbuff[i] = NULL;
1469 }
1470 }
1471
1472 return 0;
1473}
1474
1475static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1476{
1477 struct corkscrew_private *vp = netdev_priv(dev);
1478 unsigned long flags;
1479
1480 if (netif_running(dev)) {
1481 spin_lock_irqsave(&vp->lock, flags);
1482 update_stats(dev->base_addr, dev);
1483 spin_unlock_irqrestore(&vp->lock, flags);
1484 }
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001485 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486}
1487
1488/* Update statistics.
1489 Unlike with the EL3 we need not worry about interrupts changing
1490 the window setting from underneath us, but we must still guard
1491 against a race condition with a StatsUpdate interrupt updating the
1492 table. This is done by checking that the ASM (!) code generated uses
1493 atomic updates with '+='.
1494 */
1495static void update_stats(int ioaddr, struct net_device *dev)
1496{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1498 /* Switch to the stats window, and read everything. */
1499 EL3WINDOW(6);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001500 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1501 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001503 dev->stats.collisions += inb(ioaddr + 3);
1504 dev->stats.tx_window_errors += inb(ioaddr + 4);
1505 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1506 dev->stats.tx_packets += inb(ioaddr + 6);
1507 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 /* Rx packets */ inb(ioaddr + 7);
1509 /* Must read to clear */
1510 /* Tx deferrals */ inb(ioaddr + 8);
1511 /* Don't bother with register 9, an extension of registers 6&7.
1512 If we do use the 6&7 values the atomic update assumption above
1513 is invalid. */
1514 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1515 inw(ioaddr + 12);
1516 /* New: On the Vortex we must also clear the BadSSD counter. */
1517 EL3WINDOW(4);
1518 inb(ioaddr + 12);
1519
1520 /* We change back to window 7 (not 1) with the Vortex. */
1521 EL3WINDOW(7);
1522 return;
1523}
1524
1525/* This new version of set_rx_mode() supports v1.4 kernels.
1526 The Vortex chip has no documented multicast filter, so the only
1527 multicast setting is to receive all multicast frames. At least
1528 the chip has a very clean way to set the mode, unlike many others. */
1529static void set_rx_mode(struct net_device *dev)
1530{
1531 int ioaddr = dev->base_addr;
1532 short new_mode;
1533
1534 if (dev->flags & IFF_PROMISC) {
1535 if (corkscrew_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001536 pr_debug("%s: Setting promiscuous mode.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 dev->name);
1538 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1539 } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1540 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1541 } else
1542 new_mode = SetRxFilter | RxStation | RxBroadcast;
1543
1544 outw(new_mode, ioaddr + EL3_CMD);
1545}
1546
1547static void netdev_get_drvinfo(struct net_device *dev,
1548 struct ethtool_drvinfo *info)
1549{
1550 strcpy(info->driver, DRV_NAME);
1551 strcpy(info->version, DRV_VERSION);
1552 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1553}
1554
1555static u32 netdev_get_msglevel(struct net_device *dev)
1556{
1557 return corkscrew_debug;
1558}
1559
1560static void netdev_set_msglevel(struct net_device *dev, u32 level)
1561{
1562 corkscrew_debug = level;
1563}
1564
Jeff Garzik7282d492006-09-13 14:30:00 -04001565static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 .get_drvinfo = netdev_get_drvinfo,
1567 .get_msglevel = netdev_get_msglevel,
1568 .set_msglevel = netdev_set_msglevel,
1569};
1570
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001571
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572#ifdef MODULE
1573void cleanup_module(void)
1574{
1575 while (!list_empty(&root_corkscrew_dev)) {
1576 struct net_device *dev;
1577 struct corkscrew_private *vp;
1578
1579 vp = list_entry(root_corkscrew_dev.next,
1580 struct corkscrew_private, list);
1581 dev = vp->our_dev;
1582 unregister_netdev(dev);
1583 cleanup_card(dev);
1584 free_netdev(dev);
1585 }
1586}
1587#endif /* MODULE */