projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] irq-flags: drivers/net: Use the new IRQF_ constants
[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / drivers / net / 3c515.c
CommitLineData
1da177e4
LT		 1/*
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
15 2000/2/2- Added support for kernel-level ISAPnP
16 by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo
17 Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
18
19 2001/11/17 - Added ethtool support (jgarzik)
20
21 2002/10/28 - Locking updates for 2.5 (alan@redhat.com)
22
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
1da177e4
LT		 60#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,
190 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,
193 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};
246union wn3_config {
247 int i;
248 struct w3_config_fields {
249 unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
250 int pad8:8;
251 unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
252 int pad24:7;
253 } u;
254};
255
256enum Window4 {
257 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */
258};
259enum Win4_Media_bits {
260 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
261 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
262 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
263 Media_LnkBeat = 0x0800,
264};
265enum Window7 { /* Window 7: Bus Master control. */
266 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
267};
268
269/* Boomerang-style bus master control registers. Note ISA aliases! */
270enum MasterCtrl {
271 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
272 0x40c,
273 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
274};
275
276/* The Rx and Tx descriptor lists.
277 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
278 alignment contraint on tx_ring[] and rx_ring[]. */
279struct boom_rx_desc {
280 u32 next;
281 s32 status;
282 u32 addr;
283 s32 length;
284};
285
286/* Values for the Rx status entry. */
287enum rx_desc_status {
288 RxDComplete = 0x00008000, RxDError = 0x4000,
289 /* See boomerang_rx() for actual error bits */
290};
291
292struct boom_tx_desc {
293 u32 next;
294 s32 status;
295 u32 addr;
296 s32 length;
297};
298
299struct corkscrew_private {
300 const char *product_name;
301 struct list_head list;
302 struct net_device *our_dev;
303 /* The Rx and Tx rings are here to keep them quad-word-aligned. */
304 struct boom_rx_desc rx_ring[RX_RING_SIZE];
305 struct boom_tx_desc tx_ring[TX_RING_SIZE];
306 /* The addresses of transmit- and receive-in-place skbuffs. */
307 struct sk_buff *rx_skbuff[RX_RING_SIZE];
308 struct sk_buff *tx_skbuff[TX_RING_SIZE];
309 unsigned int cur_rx, cur_tx; /* The next free ring entry */
310 unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
311 struct net_device_stats stats;
312 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */
313 struct timer_list timer; /* Media selection timer. */
314 int capabilities ; /* Adapter capabilities word. */
315 int options; /* User-settable misc. driver options. */
316 int last_rx_packets; /* For media autoselection. */
317 unsigned int available_media:8, /* From Wn3_Options */
318 media_override:3, /* Passed-in media type. */
319 default_media:3, /* Read from the EEPROM. */
320 full_duplex:1, autoselect:1, bus_master:1, /* Vortex can only do a fragment bus-m. */
321 full_bus_master_tx:1, full_bus_master_rx:1, /* Boomerang */
322 tx_full:1;
323 spinlock_t lock;
324 struct device *dev;
325};
326
327/* The action to take with a media selection timer tick.
328 Note that we deviate from the 3Com order by checking 10base2 before AUI.
329 */
330enum xcvr_types {
331 XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
332 XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
333};
334
335static struct media_table {
336 char *name;
337 unsigned int media_bits:16, /* Bits to set in Wn4_Media register. */
338 mask:8, /* The transceiver-present bit in Wn3_Config. */
339 next:8; /* The media type to try next. */
340 short wait; /* Time before we check media status. */
341} media_tbl[] = {
342 { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
343 { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
344 { "undefined", 0, 0x80, XCVR_10baseT, 10000},
345 { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
346 { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
347 { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
348 { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
349 { "undefined", 0, 0x01, XCVR_10baseT, 10000},
350 { "Default", 0, 0xFF, XCVR_10baseT, 10000},
351};
352
353#ifdef __ISAPNP__
354static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
355 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
356 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
357 (long) "3Com Fast EtherLink ISA" },
358 { } /* terminate list */
359};
360
361MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
362
363static int nopnp;
364#endif /* __ISAPNP__ */
365
366static struct net_device *corkscrew_scan(int unit);
b1fc5505 367static int corkscrew_setup(struct net_device *dev, int ioaddr,
1da177e4
LT		 368 struct pnp_dev *idev, int card_number);
369static int corkscrew_open(struct net_device *dev);
370static void corkscrew_timer(unsigned long arg);
371static int corkscrew_start_xmit(struct sk_buff *skb,
372 struct net_device *dev);
373static int corkscrew_rx(struct net_device *dev);
374static void corkscrew_timeout(struct net_device *dev);
375static int boomerang_rx(struct net_device *dev);
376static irqreturn_t corkscrew_interrupt(int irq, void *dev_id,
377 struct pt_regs *regs);
378static 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);
382static struct ethtool_ops netdev_ethtool_ops;
383\f
384
385/*
386 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)
423 printk(version);
424 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;
440 printk(version);
441 }
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
505 SET_MODULE_OWNER(dev);
506
507#ifdef __ISAPNP__
508 if(nopnp == 1)
509 goto no_pnp;
510 for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
511 struct pnp_dev *idev = NULL;
512 int irq;
513 while((idev = pnp_find_dev(NULL,
514 corkscrew_isapnp_adapters[i].vendor,
515 corkscrew_isapnp_adapters[i].function,
516 idev))) {
517
518 if (pnp_device_attach(idev) < 0)
519 continue;
520 if (pnp_activate_dev(idev) < 0) {
521 printk("pnp activate failed (out of resources?)\n");
522 pnp_device_detach(idev);
523 continue;
524 }
525 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
526 pnp_device_detach(idev);
527 continue;
528 }
529 ioaddr = pnp_port_start(idev, 0);
530 irq = pnp_irq(idev, 0);
531 if (!check_device(ioaddr)) {
532 pnp_device_detach(idev);
533 continue;
534 }
535 if(corkscrew_debug)
536 printk ("ISAPNP reports %s at i/o 0x%x, irq %d\n",
537 (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
538 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
539 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
540 /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
1da177e4
LT		 541 SET_NETDEV_DEV(dev, &idev->dev);
542 pnp_cards++;
b1fc5505 543 err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
1da177e4
LT		 544 if (!err)
545 return dev;
546 cleanup_card(dev);
547 }
548 }
549no_pnp:
550#endif /* __ISAPNP__ */
551
552 /* Check all locations on the ISA bus -- evil! */
553 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
554 if (!check_device(ioaddr))
555 continue;
556
557 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
558 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
b1fc5505 559 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
1da177e4
LT		 560 if (!err)
561 return dev;
562 cleanup_card(dev);
563 }
564 free_netdev(dev);
565 return NULL;
566}
567
b1fc5505 568static int corkscrew_setup(struct net_device *dev, int ioaddr,
1da177e4
LT		 569 struct pnp_dev *idev, int card_number)
570{
571 struct corkscrew_private *vp = netdev_priv(dev);
572 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
573 int i;
574 int irq;
575
576 if (idev) {
577 irq = pnp_irq(idev, 0);
578 vp->dev = &idev->dev;
579 } else {
580 irq = inw(ioaddr + 0x2002) & 15;
581 }
582
583 dev->base_addr = ioaddr;
584 dev->irq = irq;
585 dev->dma = inw(ioaddr + 0x2000) & 7;
586 vp->product_name = "3c515";
587 vp->options = dev->mem_start;
588 vp->our_dev = dev;
589
590 if (!vp->options) {
591 if (card_number >= MAX_UNITS)
592 vp->options = -1;
593 else
594 vp->options = options[card_number];
595 }
596
597 if (vp->options >= 0) {
598 vp->media_override = vp->options & 7;
599 if (vp->media_override == 2)
600 vp->media_override = 0;
601 vp->full_duplex = (vp->options & 8) ? 1 : 0;
602 vp->bus_master = (vp->options & 16) ? 1 : 0;
603 } else {
604 vp->media_override = 7;
605 vp->full_duplex = 0;
606 vp->bus_master = 0;
607 }
608#ifdef MODULE
609 list_add(&vp->list, &root_corkscrew_dev);
610#endif
611
612 printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
613
614 spin_lock_init(&vp->lock);
615
616 /* Read the station address from the EEPROM. */
617 EL3WINDOW(0);
618 for (i = 0; i < 0x18; i++) {
619 short *phys_addr = (short *) dev->dev_addr;
620 int timer;
621 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
622 /* Pause for at least 162 us. for the read to take place. */
623 for (timer = 4; timer >= 0; timer--) {
624 udelay(162);
625 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
626 break;
627 }
628 eeprom[i] = inw(ioaddr + Wn0EepromData);
629 checksum ^= eeprom[i];
630 if (i < 3)
631 phys_addr[i] = htons(eeprom[i]);
632 }
633 checksum = (checksum ^ (checksum >> 8)) & 0xff;
634 if (checksum != 0x00)
635 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
636 for (i = 0; i < 6; i++)
637 printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
638 if (eeprom[16] == 0x11c7) { /* Corkscrew */
639 if (request_dma(dev->dma, "3c515")) {
640 printk(", DMA %d allocation failed", dev->dma);
641 dev->dma = 0;
642 } else
643 printk(", DMA %d", dev->dma);
644 }
645 printk(", IRQ %d\n", dev->irq);
646 /* Tell them about an invalid IRQ. */
647 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
648 printk(KERN_WARNING " *** Warning: this IRQ is unlikely to work! ***\n");
649
650 {
651 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
652 union wn3_config config;
653 EL3WINDOW(3);
654 vp->available_media = inw(ioaddr + Wn3_Options);
655 config.i = inl(ioaddr + Wn3_Config);
656 if (corkscrew_debug > 1)
657 printk(KERN_INFO " Internal config register is %4.4x, transceivers %#x.\n",
658 config.i, inw(ioaddr + Wn3_Options));
659 printk(KERN_INFO " %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
660 8 << config.u.ram_size,
661 config.u.ram_width ? "word" : "byte",
662 ram_split[config.u.ram_split],
663 config.u.autoselect ? "autoselect/" : "",
664 media_tbl[config.u.xcvr].name);
665 dev->if_port = config.u.xcvr;
666 vp->default_media = config.u.xcvr;
667 vp->autoselect = config.u.autoselect;
668 }
669 if (vp->media_override != 7) {
670 printk(KERN_INFO " Media override to transceiver type %d (%s).\n",
671 vp->media_override,
672 media_tbl[vp->media_override].name);
673 dev->if_port = vp->media_override;
674 }
675
676 vp->capabilities = eeprom[16];
677 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
678 /* Rx is broken at 10mbps, so we always disable it. */
679 /* vp->full_bus_master_rx = 0; */
680 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
681
682 /* The 3c51x-specific entries in the device structure. */
683 dev->open = &corkscrew_open;
684 dev->hard_start_xmit = &corkscrew_start_xmit;
685 dev->tx_timeout = &corkscrew_timeout;
686 dev->watchdog_timeo = (400 * HZ) / 1000;
687 dev->stop = &corkscrew_close;
688 dev->get_stats = &corkscrew_get_stats;
689 dev->set_multicast_list = &set_rx_mode;
690 dev->ethtool_ops = &netdev_ethtool_ops;
b1fc5505
HX		 691
692 return register_netdev(dev);
1da177e4
LT		 693}
694\f
695
696static int corkscrew_open(struct net_device *dev)
697{
698 int ioaddr = dev->base_addr;
699 struct corkscrew_private *vp = netdev_priv(dev);
700 union wn3_config config;
701 int i;
702
703 /* Before initializing select the active media port. */
704 EL3WINDOW(3);
705 if (vp->full_duplex)
706 outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
707 config.i = inl(ioaddr + Wn3_Config);
708
709 if (vp->media_override != 7) {
710 if (corkscrew_debug > 1)
711 printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
712 dev->name, vp->media_override,
713 media_tbl[vp->media_override].name);
714 dev->if_port = vp->media_override;
715 } else if (vp->autoselect) {
716 /* Find first available media type, starting with 100baseTx. */
717 dev->if_port = 4;
718 while (!(vp->available_media & media_tbl[dev->if_port].mask))
719 dev->if_port = media_tbl[dev->if_port].next;
720
721 if (corkscrew_debug > 1)
722 printk("%s: Initial media type %s.\n",
723 dev->name, media_tbl[dev->if_port].name);
724
725 init_timer(&vp->timer);
726 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
727 vp->timer.data = (unsigned long) dev;
728 vp->timer.function = &corkscrew_timer; /* timer handler */
729 add_timer(&vp->timer);
730 } else
731 dev->if_port = vp->default_media;
732
733 config.u.xcvr = dev->if_port;
734 outl(config.i, ioaddr + Wn3_Config);
735
736 if (corkscrew_debug > 1) {
737 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
738 dev->name, config.i);
739 }
740
741 outw(TxReset, ioaddr + EL3_CMD);
742 for (i = 20; i >= 0; i--)
743 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
744 break;
745
746 outw(RxReset, ioaddr + EL3_CMD);
747 /* Wait a few ticks for the RxReset command to complete. */
748 for (i = 20; i >= 0; i--)
749 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
750 break;
751
752 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
753
754 /* Use the now-standard shared IRQ implementation. */
755 if (vp->capabilities == 0x11c7) {
756 /* Corkscrew: Cannot share ISA resources. */
757 if (dev->irq == 0
758 || dev->dma == 0
759 || request_irq(dev->irq, &corkscrew_interrupt, 0,
760 vp->product_name, dev)) return -EAGAIN;
761 enable_dma(dev->dma);
762 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
1fb9df5d 763 } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
1da177e4
LT		 764 vp->product_name, dev)) {
765 return -EAGAIN;
766 }
767
768 if (corkscrew_debug > 1) {
769 EL3WINDOW(4);
770 printk("%s: corkscrew_open() irq %d media status %4.4x.\n",
771 dev->name, dev->irq, inw(ioaddr + Wn4_Media));
772 }
773
774 /* Set the station address and mask in window 2 each time opened. */
775 EL3WINDOW(2);
776 for (i = 0; i < 6; i++)
777 outb(dev->dev_addr[i], ioaddr + i);
778 for (; i < 12; i += 2)
779 outw(0, ioaddr + i);
780
781 if (dev->if_port == 3)
782 /* Start the thinnet transceiver. We should really wait 50ms... */
783 outw(StartCoax, ioaddr + EL3_CMD);
784 EL3WINDOW(4);
785 outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
786 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
787
788 /* Switch to the stats window, and clear all stats by reading. */
789 outw(StatsDisable, ioaddr + EL3_CMD);
790 EL3WINDOW(6);
791 for (i = 0; i < 10; i++)
792 inb(ioaddr + i);
793 inw(ioaddr + 10);
794 inw(ioaddr + 12);
795 /* New: On the Vortex we must also clear the BadSSD counter. */
796 EL3WINDOW(4);
797 inb(ioaddr + 12);
798 /* ..and on the Boomerang we enable the extra statistics bits. */
799 outw(0x0040, ioaddr + Wn4_NetDiag);
800
801 /* Switch to register set 7 for normal use. */
802 EL3WINDOW(7);
803
804 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
805 vp->cur_rx = vp->dirty_rx = 0;
806 if (corkscrew_debug > 2)
807 printk("%s: Filling in the Rx ring.\n",
808 dev->name);
809 for (i = 0; i < RX_RING_SIZE; i++) {
810 struct sk_buff *skb;
811 if (i < (RX_RING_SIZE - 1))
812 vp->rx_ring[i].next =
813 isa_virt_to_bus(&vp->rx_ring[i + 1]);
814 else
815 vp->rx_ring[i].next = 0;
816 vp->rx_ring[i].status = 0; /* Clear complete bit. */
817 vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
818 skb = dev_alloc_skb(PKT_BUF_SZ);
819 vp->rx_skbuff[i] = skb;
820 if (skb == NULL)
821 break; /* Bad news! */
822 skb->dev = dev; /* Mark as being used by this device. */
823 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
689be439 824 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
1da177e4
LT		 825 }
826 vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
827 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
828 }
829 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
830 vp->cur_tx = vp->dirty_tx = 0;
831 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */
832 /* Clear the Tx ring. */
833 for (i = 0; i < TX_RING_SIZE; i++)
834 vp->tx_skbuff[i] = NULL;
835 outl(0, ioaddr + DownListPtr);
836 }
837 /* Set receiver mode: presumably accept b-case and phys addr only. */
838 set_rx_mode(dev);
839 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
840
841 netif_start_queue(dev);
842
843 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
844 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
845 /* Allow status bits to be seen. */
846 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
847 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
848 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
849 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
850 /* Ack all pending events, and set active indicator mask. */
851 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
852 ioaddr + EL3_CMD);
853 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
854 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
855 ioaddr + EL3_CMD);
856
857 return 0;
858}
859
860static void corkscrew_timer(unsigned long data)
861{
862#ifdef AUTOMEDIA
863 struct net_device *dev = (struct net_device *) data;
864 struct corkscrew_private *vp = netdev_priv(dev);
865 int ioaddr = dev->base_addr;
866 unsigned long flags;
867 int ok = 0;
868
869 if (corkscrew_debug > 1)
870 printk("%s: Media selection timer tick happened, %s.\n",
871 dev->name, media_tbl[dev->if_port].name);
872
873 spin_lock_irqsave(&vp->lock, flags);
874
875 {
876 int old_window = inw(ioaddr + EL3_CMD) >> 13;
877 int media_status;
878 EL3WINDOW(4);
879 media_status = inw(ioaddr + Wn4_Media);
880 switch (dev->if_port) {
881 case 0:
882 case 4:
883 case 5: /* 10baseT, 100baseTX, 100baseFX */
884 if (media_status & Media_LnkBeat) {
885 ok = 1;
886 if (corkscrew_debug > 1)
887 printk("%s: Media %s has link beat, %x.\n",
888 dev->name,
889 media_tbl[dev->if_port].name,
890 media_status);
891 } else if (corkscrew_debug > 1)
892 printk("%s: Media %s is has no link beat, %x.\n",
893 dev->name,
894 media_tbl[dev->if_port].name,
895 media_status);
896
897 break;
898 default: /* Other media types handled by Tx timeouts. */
899 if (corkscrew_debug > 1)
900 printk("%s: Media %s is has no indication, %x.\n",
901 dev->name,
902 media_tbl[dev->if_port].name,
903 media_status);
904 ok = 1;
905 }
906 if (!ok) {
907 union wn3_config config;
908
909 do {
910 dev->if_port =
911 media_tbl[dev->if_port].next;
912 }
913 while (!(vp->available_media & media_tbl[dev->if_port].mask));
914
915 if (dev->if_port == 8) { /* Go back to default. */
916 dev->if_port = vp->default_media;
917 if (corkscrew_debug > 1)
918 printk("%s: Media selection failing, using default %s port.\n",
919 dev->name,
920 media_tbl[dev->if_port].name);
921 } else {
922 if (corkscrew_debug > 1)
923 printk("%s: Media selection failed, now trying %s port.\n",
924 dev->name,
925 media_tbl[dev->if_port].name);
926 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
927 add_timer(&vp->timer);
928 }
929 outw((media_status & ~(Media_10TP | Media_SQE)) |
930 media_tbl[dev->if_port].media_bits,
931 ioaddr + Wn4_Media);
932
933 EL3WINDOW(3);
934 config.i = inl(ioaddr + Wn3_Config);
935 config.u.xcvr = dev->if_port;
936 outl(config.i, ioaddr + Wn3_Config);
937
938 outw(dev->if_port == 3 ? StartCoax : StopCoax,
939 ioaddr + EL3_CMD);
940 }
941 EL3WINDOW(old_window);
942 }
943
944 spin_unlock_irqrestore(&vp->lock, flags);
945 if (corkscrew_debug > 1)
946 printk("%s: Media selection timer finished, %s.\n",
947 dev->name, media_tbl[dev->if_port].name);
948
949#endif /* AUTOMEDIA */
950 return;
951}
952
953static void corkscrew_timeout(struct net_device *dev)
954{
955 int i;
956 struct corkscrew_private *vp = netdev_priv(dev);
957 int ioaddr = dev->base_addr;
958
959 printk(KERN_WARNING
960 "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
961 dev->name, inb(ioaddr + TxStatus),
962 inw(ioaddr + EL3_STATUS));
963 /* Slight code bloat to be user friendly. */
964 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
965 printk(KERN_WARNING
966 "%s: Transmitter encountered 16 collisions -- network"
967 " network cable problem?\n", dev->name);
968#ifndef final_version
969 printk(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
970 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
971 vp->cur_tx);
972 printk(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
973 &vp->tx_ring[0]);
974 for (i = 0; i < TX_RING_SIZE; i++) {
975 printk(" %d: %p length %8.8x status %8.8x\n", i,
976 &vp->tx_ring[i],
977 vp->tx_ring[i].length, vp->tx_ring[i].status);
978 }
979#endif
980 /* Issue TX_RESET and TX_START commands. */
981 outw(TxReset, ioaddr + EL3_CMD);
982 for (i = 20; i >= 0; i--)
983 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
984 break;
985 outw(TxEnable, ioaddr + EL3_CMD);
986 dev->trans_start = jiffies;
987 vp->stats.tx_errors++;
988 vp->stats.tx_dropped++;
989 netif_wake_queue(dev);
990}
991
992static int corkscrew_start_xmit(struct sk_buff *skb,
993 struct net_device *dev)
994{
995 struct corkscrew_private *vp = netdev_priv(dev);
996 int ioaddr = dev->base_addr;
997
998 /* Block a timer-based transmit from overlapping. */
999
1000 netif_stop_queue(dev);
1001
1002 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
1003 /* Calculate the next Tx descriptor entry. */
1004 int entry = vp->cur_tx % TX_RING_SIZE;
1005 struct boom_tx_desc *prev_entry;
1006 unsigned long flags, i;
1007
1008 if (vp->tx_full) /* No room to transmit with */
1009 return 1;
1010 if (vp->cur_tx != 0)
1011 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1012 else
1013 prev_entry = NULL;
1014 if (corkscrew_debug > 3)
1015 printk("%s: Trying to send a packet, Tx index %d.\n",
1016 dev->name, vp->cur_tx);
1017 /* vp->tx_full = 1; */
1018 vp->tx_skbuff[entry] = skb;
1019 vp->tx_ring[entry].next = 0;
1020 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1021 vp->tx_ring[entry].length = skb->len | 0x80000000;
1022 vp->tx_ring[entry].status = skb->len | 0x80000000;
1023
1024 spin_lock_irqsave(&vp->lock, flags);
1025 outw(DownStall, ioaddr + EL3_CMD);
1026 /* Wait for the stall to complete. */
1027 for (i = 20; i >= 0; i--)
1028 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1029 break;
1030 if (prev_entry)
1031 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1032 if (inl(ioaddr + DownListPtr) == 0) {
1033 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1034 ioaddr + DownListPtr);
1035 queued_packet++;
1036 }
1037 outw(DownUnstall, ioaddr + EL3_CMD);
1038 spin_unlock_irqrestore(&vp->lock, flags);
1039
1040 vp->cur_tx++;
1041 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1042 vp->tx_full = 1;
1043 else { /* Clear previous interrupt enable. */
1044 if (prev_entry)
1045 prev_entry->status &= ~0x80000000;
1046 netif_wake_queue(dev);
1047 }
1048 dev->trans_start = jiffies;
1049 return 0;
1050 }
1051 /* Put out the doubleword header... */
1052 outl(skb->len, ioaddr + TX_FIFO);
1053 vp->stats.tx_bytes += skb->len;
1054#ifdef VORTEX_BUS_MASTER
1055 if (vp->bus_master) {
1056 /* Set the bus-master controller to transfer the packet. */
1057 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1058 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1059 vp->tx_skb = skb;
1060 outw(StartDMADown, ioaddr + EL3_CMD);
1061 /* queue will be woken at the DMADone interrupt. */
1062 } else {
1063 /* ... and the packet rounded to a doubleword. */
1064 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1065 dev_kfree_skb(skb);
1066 if (inw(ioaddr + TxFree) > 1536) {
1067 netif_wake_queue(dev);
1068 } else
1069 /* Interrupt us when the FIFO has room for max-sized packet. */
1070 outw(SetTxThreshold + (1536 >> 2),
1071 ioaddr + EL3_CMD);
1072 }
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), ioaddr + EL3_CMD);
1082#endif /* bus master */
1083
1084 dev->trans_start = jiffies;
1085
1086 /* Clear the Tx status stack. */
1087 {
1088 short tx_status;
1089 int i = 4;
1090
1091 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1092 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1093 if (corkscrew_debug > 2)
1094 printk("%s: Tx error, status %2.2x.\n",
1095 dev->name, tx_status);
1096 if (tx_status & 0x04)
1097 vp->stats.tx_fifo_errors++;
1098 if (tx_status & 0x38)
1099 vp->stats.tx_aborted_errors++;
1100 if (tx_status & 0x30) {
1101 int j;
1102 outw(TxReset, ioaddr + EL3_CMD);
1103 for (j = 20; j >= 0; j--)
1104 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1105 break;
1106 }
1107 outw(TxEnable, ioaddr + EL3_CMD);
1108 }
1109 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1110 }
1111 }
1112 return 0;
1113}
1114
1115/* The interrupt handler does all of the Rx thread work and cleans up
1116 after the Tx thread. */
1117
1118static irqreturn_t corkscrew_interrupt(int irq, void *dev_id,
1119 struct pt_regs *regs)
1120{
1121 /* Use the now-standard shared IRQ implementation. */
1122 struct net_device *dev = dev_id;
1123 struct corkscrew_private *lp = netdev_priv(dev);
1124 int ioaddr, status;
1125 int latency;
1126 int i = max_interrupt_work;
1127
1128 ioaddr = dev->base_addr;
1129 latency = inb(ioaddr + Timer);
1130
1131 spin_lock(&lp->lock);
1132
1133 status = inw(ioaddr + EL3_STATUS);
1134
1135 if (corkscrew_debug > 4)
1136 printk("%s: interrupt, status %4.4x, timer %d.\n",
1137 dev->name, status, latency);
1138 if ((status & 0xE000) != 0xE000) {
1139 static int donedidthis;
1140 /* Some interrupt controllers store a bogus interrupt from boot-time.
1141 Ignore a single early interrupt, but don't hang the machine for
1142 other interrupt problems. */
1143 if (donedidthis++ > 100) {
1144 printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1145 dev->name, status, netif_running(dev));
1146 free_irq(dev->irq, dev);
1147 dev->irq = -1;
1148 }
1149 }
1150
1151 do {
1152 if (corkscrew_debug > 5)
1153 printk("%s: In interrupt loop, status %4.4x.\n",
1154 dev->name, status);
1155 if (status & RxComplete)
1156 corkscrew_rx(dev);
1157
1158 if (status & TxAvailable) {
1159 if (corkscrew_debug > 5)
1160 printk(" TX room bit was handled.\n");
1161 /* There's room in the FIFO for a full-sized packet. */
1162 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1163 netif_wake_queue(dev);
1164 }
1165 if (status & DownComplete) {
1166 unsigned int dirty_tx = lp->dirty_tx;
1167
1168 while (lp->cur_tx - dirty_tx > 0) {
1169 int entry = dirty_tx % TX_RING_SIZE;
1170 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1171 break; /* It still hasn't been processed. */
1172 if (lp->tx_skbuff[entry]) {
1173 dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1174 lp->tx_skbuff[entry] = NULL;
1175 }
1176 dirty_tx++;
1177 }
1178 lp->dirty_tx = dirty_tx;
1179 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1180 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1181 lp->tx_full = 0;
1182 netif_wake_queue(dev);
1183 }
1184 }
1185#ifdef VORTEX_BUS_MASTER
1186 if (status & DMADone) {
1187 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1188 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1189 netif_wake_queue(dev);
1190 }
1191#endif
1192 if (status & UpComplete) {
1193 boomerang_rx(dev);
1194 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1195 }
1196 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1197 /* Handle all uncommon interrupts at once. */
1198 if (status & RxEarly) { /* Rx early is unused. */
1199 corkscrew_rx(dev);
1200 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1201 }
1202 if (status & StatsFull) { /* Empty statistics. */
1203 static int DoneDidThat;
1204 if (corkscrew_debug > 4)
1205 printk("%s: Updating stats.\n", dev->name);
1206 update_stats(ioaddr, dev);
1207 /* DEBUG HACK: Disable statistics as an interrupt source. */
1208 /* This occurs when we have the wrong media type! */
1209 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1210 int win, reg;
1211 printk("%s: Updating stats failed, disabling stats as an"
1212 " interrupt source.\n", dev->name);
1213 for (win = 0; win < 8; win++) {
1214 EL3WINDOW(win);
1215 printk("\n Vortex window %d:", win);
1216 for (reg = 0; reg < 16; reg++)
1217 printk(" %2.2x", inb(ioaddr + reg));
1218 }
1219 EL3WINDOW(7);
1220 outw(SetIntrEnb | TxAvailable |
1221 RxComplete | AdapterFailure |
1222 UpComplete | DownComplete |
1223 TxComplete, ioaddr + EL3_CMD);
1224 DoneDidThat++;
1225 }
1226 }
1227 if (status & AdapterFailure) {
1228 /* Adapter failure requires Rx reset and reinit. */
1229 outw(RxReset, ioaddr + EL3_CMD);
1230 /* Set the Rx filter to the current state. */
1231 set_rx_mode(dev);
1232 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1233 outw(AckIntr | AdapterFailure,
1234 ioaddr + EL3_CMD);
1235 }
1236 }
1237
1238 if (--i < 0) {
1239 printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x. "
1240 "Disabling functions (%4.4x).\n", dev->name,
1241 status, SetStatusEnb | ((~status) & 0x7FE));
1242 /* Disable all pending interrupts. */
1243 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1244 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1245 break;
1246 }
1247 /* Acknowledge the IRQ. */
1248 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1249
1250 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1251
1252 spin_unlock(&lp->lock);
1253
1254 if (corkscrew_debug > 4)
1255 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1256 return IRQ_HANDLED;
1257}
1258
1259static int corkscrew_rx(struct net_device *dev)
1260{
1261 struct corkscrew_private *vp = netdev_priv(dev);
1262 int ioaddr = dev->base_addr;
1263 int i;
1264 short rx_status;
1265
1266 if (corkscrew_debug > 5)
1267 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1268 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1269 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1270 if (rx_status & 0x4000) { /* Error, update stats. */
1271 unsigned char rx_error = inb(ioaddr + RxErrors);
1272 if (corkscrew_debug > 2)
1273 printk(" Rx error: status %2.2x.\n",
1274 rx_error);
1275 vp->stats.rx_errors++;
1276 if (rx_error & 0x01)
1277 vp->stats.rx_over_errors++;
1278 if (rx_error & 0x02)
1279 vp->stats.rx_length_errors++;
1280 if (rx_error & 0x04)
1281 vp->stats.rx_frame_errors++;
1282 if (rx_error & 0x08)
1283 vp->stats.rx_crc_errors++;
1284 if (rx_error & 0x10)
1285 vp->stats.rx_length_errors++;
1286 } else {
1287 /* The packet length: up to 4.5K!. */
1288 short pkt_len = rx_status & 0x1fff;
1289 struct sk_buff *skb;
1290
1291 skb = dev_alloc_skb(pkt_len + 5 + 2);
1292 if (corkscrew_debug > 4)
1293 printk("Receiving packet size %d status %4.4x.\n",
1294 pkt_len, rx_status);
1295 if (skb != NULL) {
1296 skb->dev = dev;
1297 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1298 /* 'skb_put()' points to the start of sk_buff data area. */
1299 insl(ioaddr + RX_FIFO,
1300 skb_put(skb, pkt_len),
1301 (pkt_len + 3) >> 2);
1302 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1303 skb->protocol = eth_type_trans(skb, dev);
1304 netif_rx(skb);
1305 dev->last_rx = jiffies;
1306 vp->stats.rx_packets++;
1307 vp->stats.rx_bytes += pkt_len;
1308 /* Wait a limited time to go to next packet. */
1309 for (i = 200; i >= 0; i--)
1310 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1311 break;
1312 continue;
1313 } else if (corkscrew_debug)
1314 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1315 }
1316 outw(RxDiscard, ioaddr + EL3_CMD);
1317 vp->stats.rx_dropped++;
1318 /* Wait a limited time to skip this packet. */
1319 for (i = 200; i >= 0; i--)
1320 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1321 break;
1322 }
1323 return 0;
1324}
1325
1326static int boomerang_rx(struct net_device *dev)
1327{
1328 struct corkscrew_private *vp = netdev_priv(dev);
1329 int entry = vp->cur_rx % RX_RING_SIZE;
1330 int ioaddr = dev->base_addr;
1331 int rx_status;
1332
1333 if (corkscrew_debug > 5)
1334 printk(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1335 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1336 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1337 if (rx_status & RxDError) { /* Error, update stats. */
1338 unsigned char rx_error = rx_status >> 16;
1339 if (corkscrew_debug > 2)
1340 printk(" Rx error: status %2.2x.\n",
1341 rx_error);
1342 vp->stats.rx_errors++;
1343 if (rx_error & 0x01)
1344 vp->stats.rx_over_errors++;
1345 if (rx_error & 0x02)
1346 vp->stats.rx_length_errors++;
1347 if (rx_error & 0x04)
1348 vp->stats.rx_frame_errors++;
1349 if (rx_error & 0x08)
1350 vp->stats.rx_crc_errors++;
1351 if (rx_error & 0x10)
1352 vp->stats.rx_length_errors++;
1353 } else {
1354 /* The packet length: up to 4.5K!. */
1355 short pkt_len = rx_status & 0x1fff;
1356 struct sk_buff *skb;
1357
1358 vp->stats.rx_bytes += pkt_len;
1359 if (corkscrew_debug > 4)
1360 printk("Receiving packet size %d status %4.4x.\n",
1361 pkt_len, rx_status);
1362
1363 /* Check if the packet is long enough to just accept without
1364 copying to a properly sized skbuff. */
1365 if (pkt_len < rx_copybreak
1366 && (skb = dev_alloc_skb(pkt_len + 4)) != 0) {
1367 skb->dev = dev;
1368 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1369 /* 'skb_put()' points to the start of sk_buff data area. */
1370 memcpy(skb_put(skb, pkt_len),
1371 isa_bus_to_virt(vp->rx_ring[entry].
1372 addr), pkt_len);
1373 rx_copy++;
1374 } else {
1375 void *temp;
1376 /* Pass up the skbuff already on the Rx ring. */
1377 skb = vp->rx_skbuff[entry];
1378 vp->rx_skbuff[entry] = NULL;
1379 temp = skb_put(skb, pkt_len);
1380 /* Remove this checking code for final release. */
1381 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1382 printk("%s: Warning -- the skbuff addresses do not match"
1383 " in boomerang_rx: %p vs. %p / %p.\n",
1384 dev->name,
1385 isa_bus_to_virt(vp->
1386 rx_ring[entry].
1387 addr), skb->head,
1388 temp);
1389 rx_nocopy++;
1390 }
1391 skb->protocol = eth_type_trans(skb, dev);
1392 netif_rx(skb);
1393 dev->last_rx = jiffies;
1394 vp->stats.rx_packets++;
1395 }
1396 entry = (++vp->cur_rx) % RX_RING_SIZE;
1397 }
1398 /* Refill the Rx ring buffers. */
1399 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1400 struct sk_buff *skb;
1401 entry = vp->dirty_rx % RX_RING_SIZE;
1402 if (vp->rx_skbuff[entry] == NULL) {
1403 skb = dev_alloc_skb(PKT_BUF_SZ);
1404 if (skb == NULL)
1405 break; /* Bad news! */
1406 skb->dev = dev; /* Mark as being used by this device. */
1407 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
689be439 1408 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1da177e4
LT		 1409 vp->rx_skbuff[entry] = skb;
1410 }
1411 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1412 }
1413 return 0;
1414}
1415
1416static int corkscrew_close(struct net_device *dev)
1417{
1418 struct corkscrew_private *vp = netdev_priv(dev);
1419 int ioaddr = dev->base_addr;
1420 int i;
1421
1422 netif_stop_queue(dev);
1423
1424 if (corkscrew_debug > 1) {
1425 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1426 dev->name, inw(ioaddr + EL3_STATUS),
1427 inb(ioaddr + TxStatus));
1428 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1429 " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1430 queued_packet);
1431 }
1432
1433 del_timer(&vp->timer);
1434
1435 /* Turn off statistics ASAP. We update lp->stats below. */
1436 outw(StatsDisable, ioaddr + EL3_CMD);
1437
1438 /* Disable the receiver and transmitter. */
1439 outw(RxDisable, ioaddr + EL3_CMD);
1440 outw(TxDisable, ioaddr + EL3_CMD);
1441
1442 if (dev->if_port == XCVR_10base2)
1443 /* Turn off thinnet power. Green! */
1444 outw(StopCoax, ioaddr + EL3_CMD);
1445
1446 free_irq(dev->irq, dev);
1447
1448 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1449
1450 update_stats(ioaddr, dev);
1451 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1452 outl(0, ioaddr + UpListPtr);
1453 for (i = 0; i < RX_RING_SIZE; i++)
1454 if (vp->rx_skbuff[i]) {
1455 dev_kfree_skb(vp->rx_skbuff[i]);
1456 vp->rx_skbuff[i] = NULL;
1457 }
1458 }
1459 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1460 outl(0, ioaddr + DownListPtr);
1461 for (i = 0; i < TX_RING_SIZE; i++)
1462 if (vp->tx_skbuff[i]) {
1463 dev_kfree_skb(vp->tx_skbuff[i]);
1464 vp->tx_skbuff[i] = NULL;
1465 }
1466 }
1467
1468 return 0;
1469}
1470
1471static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1472{
1473 struct corkscrew_private *vp = netdev_priv(dev);
1474 unsigned long flags;
1475
1476 if (netif_running(dev)) {
1477 spin_lock_irqsave(&vp->lock, flags);
1478 update_stats(dev->base_addr, dev);
1479 spin_unlock_irqrestore(&vp->lock, flags);
1480 }
1481 return &vp->stats;
1482}
1483
1484/* Update statistics.
1485 Unlike with the EL3 we need not worry about interrupts changing
1486 the window setting from underneath us, but we must still guard
1487 against a race condition with a StatsUpdate interrupt updating the
1488 table. This is done by checking that the ASM (!) code generated uses
1489 atomic updates with '+='.
1490 */
1491static void update_stats(int ioaddr, struct net_device *dev)
1492{
1493 struct corkscrew_private *vp = netdev_priv(dev);
1494
1495 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1496 /* Switch to the stats window, and read everything. */
1497 EL3WINDOW(6);
1498 vp->stats.tx_carrier_errors += inb(ioaddr + 0);
1499 vp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1500 /* Multiple collisions. */ inb(ioaddr + 2);
1501 vp->stats.collisions += inb(ioaddr + 3);
1502 vp->stats.tx_window_errors += inb(ioaddr + 4);
1503 vp->stats.rx_fifo_errors += inb(ioaddr + 5);
1504 vp->stats.tx_packets += inb(ioaddr + 6);
1505 vp->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1506 /* Rx packets */ inb(ioaddr + 7);
1507 /* Must read to clear */
1508 /* Tx deferrals */ inb(ioaddr + 8);
1509 /* Don't bother with register 9, an extension of registers 6&7.
1510 If we do use the 6&7 values the atomic update assumption above
1511 is invalid. */
1512 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1513 inw(ioaddr + 12);
1514 /* New: On the Vortex we must also clear the BadSSD counter. */
1515 EL3WINDOW(4);
1516 inb(ioaddr + 12);
1517
1518 /* We change back to window 7 (not 1) with the Vortex. */
1519 EL3WINDOW(7);
1520 return;
1521}
1522
1523/* This new version of set_rx_mode() supports v1.4 kernels.
1524 The Vortex chip has no documented multicast filter, so the only
1525 multicast setting is to receive all multicast frames. At least
1526 the chip has a very clean way to set the mode, unlike many others. */
1527static void set_rx_mode(struct net_device *dev)
1528{
1529 int ioaddr = dev->base_addr;
1530 short new_mode;
1531
1532 if (dev->flags & IFF_PROMISC) {
1533 if (corkscrew_debug > 3)
1534 printk("%s: Setting promiscuous mode.\n",
1535 dev->name);
1536 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1537 } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1538 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1539 } else
1540 new_mode = SetRxFilter | RxStation | RxBroadcast;
1541
1542 outw(new_mode, ioaddr + EL3_CMD);
1543}
1544
1545static void netdev_get_drvinfo(struct net_device *dev,
1546 struct ethtool_drvinfo *info)
1547{
1548 strcpy(info->driver, DRV_NAME);
1549 strcpy(info->version, DRV_VERSION);
1550 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1551}
1552
1553static u32 netdev_get_msglevel(struct net_device *dev)
1554{
1555 return corkscrew_debug;
1556}
1557
1558static void netdev_set_msglevel(struct net_device *dev, u32 level)
1559{
1560 corkscrew_debug = level;
1561}
1562
1563static struct ethtool_ops netdev_ethtool_ops = {
1564 .get_drvinfo = netdev_get_drvinfo,
1565 .get_msglevel = netdev_get_msglevel,
1566 .set_msglevel = netdev_set_msglevel,
1567};
1568
1569\f
1570#ifdef MODULE
1571void cleanup_module(void)
1572{
1573 while (!list_empty(&root_corkscrew_dev)) {
1574 struct net_device *dev;
1575 struct corkscrew_private *vp;
1576
1577 vp = list_entry(root_corkscrew_dev.next,
1578 struct corkscrew_private, list);
1579 dev = vp->our_dev;
1580 unregister_netdev(dev);
1581 cleanup_card(dev);
1582 free_netdev(dev);
1583 }
1584}
1585#endif /* MODULE */
1586\f
1587/*
1588 * Local variables:
1589 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1590 * c-indent-level: 4
1591 * tab-width: 4
1592 * End:
1593 */