blob: 4adcb950f5f1446b59dad15c0bf1149d8e286007 [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. */
767 if (dev->irq == 0
768 || dev->dma == 0
769 || request_irq(dev->irq, &corkscrew_interrupt, 0,
770 vp->product_name, dev)) return -EAGAIN;
771 enable_dma(dev->dma);
772 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700773 } 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 */
961 return;
962}
963
964static void corkscrew_timeout(struct net_device *dev)
965{
966 int i;
967 struct corkscrew_private *vp = netdev_priv(dev);
968 int ioaddr = dev->base_addr;
969
Alexander Beregalov39738e12009-05-26 12:35:26 +0000970 pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 dev->name, inb(ioaddr + TxStatus),
972 inw(ioaddr + EL3_STATUS));
973 /* Slight code bloat to be user friendly. */
974 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
Alexander Beregalov39738e12009-05-26 12:35:26 +0000975 pr_warning("%s: Transmitter encountered 16 collisions --"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 " network cable problem?\n", dev->name);
977#ifndef final_version
Alexander Beregalov39738e12009-05-26 12:35:26 +0000978 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
980 vp->cur_tx);
Alexander Beregalov39738e12009-05-26 12:35:26 +0000981 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 &vp->tx_ring[0]);
983 for (i = 0; i < TX_RING_SIZE; i++) {
Alexander Beregalov39738e12009-05-26 12:35:26 +0000984 pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 &vp->tx_ring[i],
986 vp->tx_ring[i].length, vp->tx_ring[i].status);
987 }
988#endif
989 /* Issue TX_RESET and TX_START commands. */
990 outw(TxReset, ioaddr + EL3_CMD);
991 for (i = 20; i >= 0; i--)
992 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
993 break;
994 outw(TxEnable, ioaddr + EL3_CMD);
995 dev->trans_start = jiffies;
Paulius Zaleckasdfd44152008-04-29 03:07:31 +0300996 dev->stats.tx_errors++;
997 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 netif_wake_queue(dev);
999}
1000
Stephen Hemminger27a1de92009-08-31 19:50:54 +00001001static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1002 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003{
1004 struct corkscrew_private *vp = netdev_priv(dev);
1005 int ioaddr = dev->base_addr;
1006
1007 /* Block a timer-based transmit from overlapping. */
1008
1009 netif_stop_queue(dev);
1010
1011 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
1012 /* Calculate the next Tx descriptor entry. */
1013 int entry = vp->cur_tx % TX_RING_SIZE;
1014 struct boom_tx_desc *prev_entry;
Eric Sesterhenncb958182006-08-19 19:37:57 +02001015 unsigned long flags;
1016 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017
1018 if (vp->tx_full) /* No room to transmit with */
Patrick McHardy5b548142009-06-12 06:22:29 +00001019 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 if (vp->cur_tx != 0)
1021 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1022 else
1023 prev_entry = NULL;
1024 if (corkscrew_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001025 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 dev->name, vp->cur_tx);
1027 /* vp->tx_full = 1; */
1028 vp->tx_skbuff[entry] = skb;
1029 vp->tx_ring[entry].next = 0;
1030 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1031 vp->tx_ring[entry].length = skb->len | 0x80000000;
1032 vp->tx_ring[entry].status = skb->len | 0x80000000;
1033
1034 spin_lock_irqsave(&vp->lock, flags);
1035 outw(DownStall, ioaddr + EL3_CMD);
1036 /* Wait for the stall to complete. */
1037 for (i = 20; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001038 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 break;
1040 if (prev_entry)
1041 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1042 if (inl(ioaddr + DownListPtr) == 0) {
1043 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1044 ioaddr + DownListPtr);
1045 queued_packet++;
1046 }
1047 outw(DownUnstall, ioaddr + EL3_CMD);
1048 spin_unlock_irqrestore(&vp->lock, flags);
1049
1050 vp->cur_tx++;
1051 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1052 vp->tx_full = 1;
1053 else { /* Clear previous interrupt enable. */
1054 if (prev_entry)
1055 prev_entry->status &= ~0x80000000;
1056 netif_wake_queue(dev);
1057 }
1058 dev->trans_start = jiffies;
Patrick McHardy6ed10652009-06-23 06:03:08 +00001059 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061 /* Put out the doubleword header... */
1062 outl(skb->len, ioaddr + TX_FIFO);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001063 dev->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064#ifdef VORTEX_BUS_MASTER
1065 if (vp->bus_master) {
1066 /* Set the bus-master controller to transfer the packet. */
1067 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1068 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1069 vp->tx_skb = skb;
1070 outw(StartDMADown, ioaddr + EL3_CMD);
1071 /* queue will be woken at the DMADone interrupt. */
1072 } else {
1073 /* ... and the packet rounded to a doubleword. */
1074 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1075 dev_kfree_skb(skb);
1076 if (inw(ioaddr + TxFree) > 1536) {
1077 netif_wake_queue(dev);
1078 } else
1079 /* Interrupt us when the FIFO has room for max-sized packet. */
1080 outw(SetTxThreshold + (1536 >> 2),
1081 ioaddr + EL3_CMD);
1082 }
1083#else
1084 /* ... and the packet rounded to a doubleword. */
1085 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1086 dev_kfree_skb(skb);
1087 if (inw(ioaddr + TxFree) > 1536) {
1088 netif_wake_queue(dev);
1089 } else
1090 /* Interrupt us when the FIFO has room for max-sized packet. */
1091 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1092#endif /* bus master */
1093
1094 dev->trans_start = jiffies;
1095
1096 /* Clear the Tx status stack. */
1097 {
1098 short tx_status;
1099 int i = 4;
1100
1101 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1102 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1103 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001104 pr_debug("%s: Tx error, status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 dev->name, tx_status);
1106 if (tx_status & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001107 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 if (tx_status & 0x38)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001109 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 if (tx_status & 0x30) {
1111 int j;
1112 outw(TxReset, ioaddr + EL3_CMD);
1113 for (j = 20; j >= 0; j--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001114 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 break;
1116 }
1117 outw(TxEnable, ioaddr + EL3_CMD);
1118 }
1119 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1120 }
1121 }
Patrick McHardy6ed10652009-06-23 06:03:08 +00001122 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
1125/* The interrupt handler does all of the Rx thread work and cleans up
1126 after the Tx thread. */
1127
David Howells7d12e782006-10-05 14:55:46 +01001128static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
1130 /* Use the now-standard shared IRQ implementation. */
1131 struct net_device *dev = dev_id;
1132 struct corkscrew_private *lp = netdev_priv(dev);
1133 int ioaddr, status;
1134 int latency;
1135 int i = max_interrupt_work;
1136
1137 ioaddr = dev->base_addr;
1138 latency = inb(ioaddr + Timer);
1139
1140 spin_lock(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 status = inw(ioaddr + EL3_STATUS);
1143
1144 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001145 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 dev->name, status, latency);
1147 if ((status & 0xE000) != 0xE000) {
1148 static int donedidthis;
1149 /* Some interrupt controllers store a bogus interrupt from boot-time.
1150 Ignore a single early interrupt, but don't hang the machine for
1151 other interrupt problems. */
1152 if (donedidthis++ > 100) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001153 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 dev->name, status, netif_running(dev));
1155 free_irq(dev->irq, dev);
1156 dev->irq = -1;
1157 }
1158 }
1159
1160 do {
1161 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001162 pr_debug("%s: In interrupt loop, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 dev->name, status);
1164 if (status & RxComplete)
1165 corkscrew_rx(dev);
1166
1167 if (status & TxAvailable) {
1168 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001169 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 /* There's room in the FIFO for a full-sized packet. */
1171 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1172 netif_wake_queue(dev);
1173 }
1174 if (status & DownComplete) {
1175 unsigned int dirty_tx = lp->dirty_tx;
1176
1177 while (lp->cur_tx - dirty_tx > 0) {
1178 int entry = dirty_tx % TX_RING_SIZE;
1179 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1180 break; /* It still hasn't been processed. */
1181 if (lp->tx_skbuff[entry]) {
1182 dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1183 lp->tx_skbuff[entry] = NULL;
1184 }
1185 dirty_tx++;
1186 }
1187 lp->dirty_tx = dirty_tx;
1188 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1189 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1190 lp->tx_full = 0;
1191 netif_wake_queue(dev);
1192 }
1193 }
1194#ifdef VORTEX_BUS_MASTER
1195 if (status & DMADone) {
1196 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1197 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1198 netif_wake_queue(dev);
1199 }
1200#endif
1201 if (status & UpComplete) {
1202 boomerang_rx(dev);
1203 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1204 }
1205 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1206 /* Handle all uncommon interrupts at once. */
1207 if (status & RxEarly) { /* Rx early is unused. */
1208 corkscrew_rx(dev);
1209 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1210 }
1211 if (status & StatsFull) { /* Empty statistics. */
1212 static int DoneDidThat;
1213 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001214 pr_debug("%s: Updating stats.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 update_stats(ioaddr, dev);
1216 /* DEBUG HACK: Disable statistics as an interrupt source. */
1217 /* This occurs when we have the wrong media type! */
1218 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1219 int win, reg;
Alexander Beregalov39738e12009-05-26 12:35:26 +00001220 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1221 dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 for (win = 0; win < 8; win++) {
1223 EL3WINDOW(win);
Alexander Beregalov39738e12009-05-26 12:35:26 +00001224 pr_notice("Vortex window %d:", win);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 for (reg = 0; reg < 16; reg++)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001226 pr_cont(" %2.2x", inb(ioaddr + reg));
1227 pr_cont("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 }
1229 EL3WINDOW(7);
1230 outw(SetIntrEnb | TxAvailable |
1231 RxComplete | AdapterFailure |
1232 UpComplete | DownComplete |
1233 TxComplete, ioaddr + EL3_CMD);
1234 DoneDidThat++;
1235 }
1236 }
1237 if (status & AdapterFailure) {
1238 /* Adapter failure requires Rx reset and reinit. */
1239 outw(RxReset, ioaddr + EL3_CMD);
1240 /* Set the Rx filter to the current state. */
1241 set_rx_mode(dev);
1242 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1243 outw(AckIntr | AdapterFailure,
1244 ioaddr + EL3_CMD);
1245 }
1246 }
1247
1248 if (--i < 0) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001249 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1250 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 /* Disable all pending interrupts. */
1252 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1253 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1254 break;
1255 }
1256 /* Acknowledge the IRQ. */
1257 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1258
1259 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 spin_unlock(&lp->lock);
1262
1263 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001264 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 return IRQ_HANDLED;
1266}
1267
1268static int corkscrew_rx(struct net_device *dev)
1269{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 int ioaddr = dev->base_addr;
1271 int i;
1272 short rx_status;
1273
1274 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001275 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1277 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1278 if (rx_status & 0x4000) { /* Error, update stats. */
1279 unsigned char rx_error = inb(ioaddr + RxErrors);
1280 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001281 pr_debug(" Rx error: status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001283 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001285 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001287 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001289 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001291 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001293 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 } else {
1295 /* The packet length: up to 4.5K!. */
1296 short pkt_len = rx_status & 0x1fff;
1297 struct sk_buff *skb;
1298
1299 skb = dev_alloc_skb(pkt_len + 5 + 2);
1300 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001301 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 pkt_len, rx_status);
1303 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1305 /* 'skb_put()' points to the start of sk_buff data area. */
1306 insl(ioaddr + RX_FIFO,
1307 skb_put(skb, pkt_len),
1308 (pkt_len + 3) >> 2);
1309 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1310 skb->protocol = eth_type_trans(skb, dev);
1311 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001312 dev->stats.rx_packets++;
1313 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 /* Wait a limited time to go to next packet. */
1315 for (i = 200; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001316 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 break;
1318 continue;
1319 } else if (corkscrew_debug)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001320 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 }
1322 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001323 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 /* Wait a limited time to skip this packet. */
1325 for (i = 200; i >= 0; i--)
1326 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1327 break;
1328 }
1329 return 0;
1330}
1331
1332static int boomerang_rx(struct net_device *dev)
1333{
1334 struct corkscrew_private *vp = netdev_priv(dev);
1335 int entry = vp->cur_rx % RX_RING_SIZE;
1336 int ioaddr = dev->base_addr;
1337 int rx_status;
1338
1339 if (corkscrew_debug > 5)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001340 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1342 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1343 if (rx_status & RxDError) { /* Error, update stats. */
1344 unsigned char rx_error = rx_status >> 16;
1345 if (corkscrew_debug > 2)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001346 pr_debug(" Rx error: status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001348 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001350 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001352 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001354 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001356 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001358 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 } else {
1360 /* The packet length: up to 4.5K!. */
1361 short pkt_len = rx_status & 0x1fff;
1362 struct sk_buff *skb;
1363
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001364 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (corkscrew_debug > 4)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001366 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 pkt_len, rx_status);
1368
1369 /* Check if the packet is long enough to just accept without
1370 copying to a properly sized skbuff. */
1371 if (pkt_len < rx_copybreak
Al Viro79ea13c2008-01-24 02:06:46 -08001372 && (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1374 /* 'skb_put()' points to the start of sk_buff data area. */
1375 memcpy(skb_put(skb, pkt_len),
1376 isa_bus_to_virt(vp->rx_ring[entry].
1377 addr), pkt_len);
1378 rx_copy++;
1379 } else {
1380 void *temp;
1381 /* Pass up the skbuff already on the Rx ring. */
1382 skb = vp->rx_skbuff[entry];
1383 vp->rx_skbuff[entry] = NULL;
1384 temp = skb_put(skb, pkt_len);
1385 /* Remove this checking code for final release. */
1386 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001387 pr_warning("%s: Warning -- the skbuff addresses do not match"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 " in boomerang_rx: %p vs. %p / %p.\n",
1389 dev->name,
1390 isa_bus_to_virt(vp->
1391 rx_ring[entry].
1392 addr), skb->head,
1393 temp);
1394 rx_nocopy++;
1395 }
1396 skb->protocol = eth_type_trans(skb, dev);
1397 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001398 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 }
1400 entry = (++vp->cur_rx) % RX_RING_SIZE;
1401 }
1402 /* Refill the Rx ring buffers. */
1403 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1404 struct sk_buff *skb;
1405 entry = vp->dirty_rx % RX_RING_SIZE;
1406 if (vp->rx_skbuff[entry] == NULL) {
1407 skb = dev_alloc_skb(PKT_BUF_SZ);
1408 if (skb == NULL)
1409 break; /* Bad news! */
1410 skb->dev = dev; /* Mark as being used by this device. */
1411 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -07001412 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 vp->rx_skbuff[entry] = skb;
1414 }
1415 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1416 }
1417 return 0;
1418}
1419
1420static int corkscrew_close(struct net_device *dev)
1421{
1422 struct corkscrew_private *vp = netdev_priv(dev);
1423 int ioaddr = dev->base_addr;
1424 int i;
1425
1426 netif_stop_queue(dev);
1427
1428 if (corkscrew_debug > 1) {
Alexander Beregalov39738e12009-05-26 12:35:26 +00001429 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 dev->name, inw(ioaddr + EL3_STATUS),
1431 inb(ioaddr + TxStatus));
Alexander Beregalov39738e12009-05-26 12:35:26 +00001432 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1433 dev->name, rx_nocopy, rx_copy, queued_packet);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 }
1435
1436 del_timer(&vp->timer);
1437
1438 /* Turn off statistics ASAP. We update lp->stats below. */
1439 outw(StatsDisable, ioaddr + EL3_CMD);
1440
1441 /* Disable the receiver and transmitter. */
1442 outw(RxDisable, ioaddr + EL3_CMD);
1443 outw(TxDisable, ioaddr + EL3_CMD);
1444
1445 if (dev->if_port == XCVR_10base2)
1446 /* Turn off thinnet power. Green! */
1447 outw(StopCoax, ioaddr + EL3_CMD);
1448
1449 free_irq(dev->irq, dev);
1450
1451 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1452
1453 update_stats(ioaddr, dev);
1454 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1455 outl(0, ioaddr + UpListPtr);
1456 for (i = 0; i < RX_RING_SIZE; i++)
1457 if (vp->rx_skbuff[i]) {
1458 dev_kfree_skb(vp->rx_skbuff[i]);
1459 vp->rx_skbuff[i] = NULL;
1460 }
1461 }
1462 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1463 outl(0, ioaddr + DownListPtr);
1464 for (i = 0; i < TX_RING_SIZE; i++)
1465 if (vp->tx_skbuff[i]) {
1466 dev_kfree_skb(vp->tx_skbuff[i]);
1467 vp->tx_skbuff[i] = NULL;
1468 }
1469 }
1470
1471 return 0;
1472}
1473
1474static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1475{
1476 struct corkscrew_private *vp = netdev_priv(dev);
1477 unsigned long flags;
1478
1479 if (netif_running(dev)) {
1480 spin_lock_irqsave(&vp->lock, flags);
1481 update_stats(dev->base_addr, dev);
1482 spin_unlock_irqrestore(&vp->lock, flags);
1483 }
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001484 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485}
1486
1487/* Update statistics.
1488 Unlike with the EL3 we need not worry about interrupts changing
1489 the window setting from underneath us, but we must still guard
1490 against a race condition with a StatsUpdate interrupt updating the
1491 table. This is done by checking that the ASM (!) code generated uses
1492 atomic updates with '+='.
1493 */
1494static void update_stats(int ioaddr, struct net_device *dev)
1495{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1497 /* Switch to the stats window, and read everything. */
1498 EL3WINDOW(6);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001499 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1500 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001502 dev->stats.collisions += inb(ioaddr + 3);
1503 dev->stats.tx_window_errors += inb(ioaddr + 4);
1504 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1505 dev->stats.tx_packets += inb(ioaddr + 6);
1506 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 /* Rx packets */ inb(ioaddr + 7);
1508 /* Must read to clear */
1509 /* Tx deferrals */ inb(ioaddr + 8);
1510 /* Don't bother with register 9, an extension of registers 6&7.
1511 If we do use the 6&7 values the atomic update assumption above
1512 is invalid. */
1513 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1514 inw(ioaddr + 12);
1515 /* New: On the Vortex we must also clear the BadSSD counter. */
1516 EL3WINDOW(4);
1517 inb(ioaddr + 12);
1518
1519 /* We change back to window 7 (not 1) with the Vortex. */
1520 EL3WINDOW(7);
1521 return;
1522}
1523
1524/* This new version of set_rx_mode() supports v1.4 kernels.
1525 The Vortex chip has no documented multicast filter, so the only
1526 multicast setting is to receive all multicast frames. At least
1527 the chip has a very clean way to set the mode, unlike many others. */
1528static void set_rx_mode(struct net_device *dev)
1529{
1530 int ioaddr = dev->base_addr;
1531 short new_mode;
1532
1533 if (dev->flags & IFF_PROMISC) {
1534 if (corkscrew_debug > 3)
Alexander Beregalov39738e12009-05-26 12:35:26 +00001535 pr_debug("%s: Setting promiscuous mode.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 dev->name);
1537 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1538 } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1539 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1540 } else
1541 new_mode = SetRxFilter | RxStation | RxBroadcast;
1542
1543 outw(new_mode, ioaddr + EL3_CMD);
1544}
1545
1546static void netdev_get_drvinfo(struct net_device *dev,
1547 struct ethtool_drvinfo *info)
1548{
1549 strcpy(info->driver, DRV_NAME);
1550 strcpy(info->version, DRV_VERSION);
1551 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1552}
1553
1554static u32 netdev_get_msglevel(struct net_device *dev)
1555{
1556 return corkscrew_debug;
1557}
1558
1559static void netdev_set_msglevel(struct net_device *dev, u32 level)
1560{
1561 corkscrew_debug = level;
1562}
1563
Jeff Garzik7282d492006-09-13 14:30:00 -04001564static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 .get_drvinfo = netdev_get_drvinfo,
1566 .get_msglevel = netdev_get_msglevel,
1567 .set_msglevel = netdev_set_msglevel,
1568};
1569
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001570
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571#ifdef MODULE
1572void cleanup_module(void)
1573{
1574 while (!list_empty(&root_corkscrew_dev)) {
1575 struct net_device *dev;
1576 struct corkscrew_private *vp;
1577
1578 vp = list_entry(root_corkscrew_dev.next,
1579 struct corkscrew_private, list);
1580 dev = vp->our_dev;
1581 unregister_netdev(dev);
1582 cleanup_card(dev);
1583 free_netdev(dev);
1584 }
1585}
1586#endif /* MODULE */