ia64/linux-2.6.18-xen.hg

view drivers/net/3c515.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 Written 1997-1998 by Donald Becker.
4 This software may be used and distributed according to the terms
5 of the GNU General Public License, incorporated herein by reference.
7 This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
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
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.
19 2001/11/17 - Added ethtool support (jgarzik)
21 2002/10/28 - Locking updates for 2.5 (alan@redhat.com)
23 */
25 #define DRV_NAME "3c515"
26 #define DRV_VERSION "0.99t-ac"
27 #define DRV_RELDATE "28-Oct-2002"
29 static char *version =
30 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " becker@scyld.com and others\n";
32 #define CORKSCREW 1
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. */
37 static int rx_copybreak = 200;
39 /* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
40 static const int mtu = 1500;
42 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
43 static int max_interrupt_work = 20;
45 /* Enable the automatic media selection code -- usually set. */
46 #define AUTOMEDIA 1
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
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. */
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>
76 #include <asm/uaccess.h>
77 #include <asm/io.h>
78 #include <asm/dma.h>
80 #define NEW_MULTICAST
81 #include <linux/delay.h>
83 #define MAX_UNITS 8
85 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
86 MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
87 MODULE_LICENSE("GPL");
88 MODULE_VERSION(DRV_VERSION);
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. */
95 static int rx_nocopy, rx_copy, queued_packet;
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
101 /* Operational parameter that usually are not changed. */
102 #define TX_TIMEOUT 40 /* Time in jiffies before concluding Tx hung */
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
109 #ifdef DRIVER_DEBUG
110 static int corkscrew_debug = DRIVER_DEBUG;
111 #else
112 static int corkscrew_debug = 1;
113 #endif
115 #define CORKSCREW_ID 10
117 /*
118 Theory of Operation
120 I. Board Compatibility
122 This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
123 3Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout,
124 it's not practical to integrate this driver with the other EtherLink drivers.
126 II. Board-specific settings
128 The Corkscrew has an EEPROM for configuration, but no special settings are
129 needed for Linux.
131 III. Driver operation
133 The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
134 PCI cards, with the bus master interface extensively modified to work with
135 the ISA bus.
137 The card is capable of full-bus-master transfers with separate
138 lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
139 DEC Tulip and Intel Speedo3.
141 This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
142 receive buffer. This scheme allocates full-sized skbuffs as receive
143 buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is
144 chosen to trade-off the memory wasted by passing the full-sized skbuff to
145 the queue layer for all frames vs. the copying cost of copying a frame to a
146 correctly-sized skbuff.
149 IIIC. Synchronization
150 The driver runs as two independent, single-threaded flows of control. One
151 is the send-packet routine, which enforces single-threaded use by the netif
152 layer. The other thread is the interrupt handler, which is single
153 threaded by the hardware and other software.
155 IV. Notes
157 Thanks to Terry Murphy of 3Com for providing documentation and a development
158 board.
160 The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
161 project names. I use these names to eliminate confusion -- 3Com product
162 numbers and names are very similar and often confused.
164 The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
165 This driver only supports ethernet frames because of the recent MTU limit
166 of 1.5K, but the changes to support 4.5K are minimal.
167 */
169 /* Operational definitions.
170 These are not used by other compilation units and thus are not
171 exported in a ".h" file.
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
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. */
186 enum 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 };
199 /* The SetRxFilter command accepts the following classes: */
200 enum RxFilter {
201 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
202 };
204 /* Bits in the general status register. */
205 enum 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 };
214 /* Register window 1 offsets, the window used in normal operation.
215 On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
216 enum 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 };
221 enum 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 };
231 enum 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 };
237 /* EEPROM locations. */
238 enum eeprom_offset {
239 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
240 EtherLink3ID = 7,
241 };
243 enum Window3 { /* Window 3: MAC/config bits. */
244 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
245 };
246 union 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 };
256 enum Window4 {
257 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */
258 };
259 enum 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 };
265 enum Window7 { /* Window 7: Bus Master control. */
266 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
267 };
269 /* Boomerang-style bus master control registers. Note ISA aliases! */
270 enum MasterCtrl {
271 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
272 0x40c,
273 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
274 };
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[]. */
279 struct boom_rx_desc {
280 u32 next;
281 s32 status;
282 u32 addr;
283 s32 length;
284 };
286 /* Values for the Rx status entry. */
287 enum rx_desc_status {
288 RxDComplete = 0x00008000, RxDError = 0x4000,
289 /* See boomerang_rx() for actual error bits */
290 };
292 struct boom_tx_desc {
293 u32 next;
294 s32 status;
295 u32 addr;
296 s32 length;
297 };
299 struct 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 };
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 */
330 enum xcvr_types {
331 XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
332 XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
333 };
335 static 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 };
353 #ifdef __ISAPNP__
354 static 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 };
361 MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
363 static int nopnp;
364 #endif /* __ISAPNP__ */
366 static struct net_device *corkscrew_scan(int unit);
367 static int corkscrew_setup(struct net_device *dev, int ioaddr,
368 struct pnp_dev *idev, int card_number);
369 static int corkscrew_open(struct net_device *dev);
370 static void corkscrew_timer(unsigned long arg);
371 static int corkscrew_start_xmit(struct sk_buff *skb,
372 struct net_device *dev);
373 static int corkscrew_rx(struct net_device *dev);
374 static void corkscrew_timeout(struct net_device *dev);
375 static int boomerang_rx(struct net_device *dev);
376 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id,
377 struct pt_regs *regs);
378 static int corkscrew_close(struct net_device *dev);
379 static void update_stats(int addr, struct net_device *dev);
380 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
381 static void set_rx_mode(struct net_device *dev);
382 static struct ethtool_ops netdev_ethtool_ops;
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!! */
399 static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
401 #ifdef MODULE
402 static int debug = -1;
404 module_param(debug, int, 0);
405 module_param_array(options, int, NULL, 0);
406 module_param(rx_copybreak, int, 0);
407 module_param(max_interrupt_work, int, 0);
408 MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
409 MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
410 MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
411 MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
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 */
415 static LIST_HEAD(root_corkscrew_dev);
417 int 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 }
429 #else
430 struct net_device *tc515_probe(int unit)
431 {
432 struct net_device *dev = corkscrew_scan(unit);
433 static int printed;
435 if (!dev)
436 return ERR_PTR(-ENODEV);
438 if (corkscrew_debug > 0 && !printed) {
439 printed = 1;
440 printk(version);
441 }
443 return dev;
444 }
445 #endif /* not MODULE */
447 static int check_device(unsigned ioaddr)
448 {
449 int timer;
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 }
473 static 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 }
485 static 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
496 dev = alloc_etherdev(sizeof(struct corkscrew_private));
497 if (!dev)
498 return ERR_PTR(-ENOMEM);
500 if (unit >= 0) {
501 sprintf(dev->name, "eth%d", unit);
502 netdev_boot_setup_check(dev);
503 }
505 SET_MODULE_OWNER(dev);
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))) {
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 */
541 SET_NETDEV_DEV(dev, &idev->dev);
542 pnp_cards++;
543 err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
544 if (!err)
545 return dev;
546 cleanup_card(dev);
547 }
548 }
549 no_pnp:
550 #endif /* __ISAPNP__ */
552 /* Check all locations on the ISA bus -- evil! */
553 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
554 if (!check_device(ioaddr))
555 continue;
557 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
558 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
559 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
560 if (!err)
561 return dev;
562 cleanup_card(dev);
563 }
564 free_netdev(dev);
565 return NULL;
566 }
568 static int corkscrew_setup(struct net_device *dev, int ioaddr,
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;
576 if (idev) {
577 irq = pnp_irq(idev, 0);
578 vp->dev = &idev->dev;
579 } else {
580 irq = inw(ioaddr + 0x2002) & 15;
581 }
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;
590 if (!vp->options) {
591 if (card_number >= MAX_UNITS)
592 vp->options = -1;
593 else
594 vp->options = options[card_number];
595 }
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
612 printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
614 spin_lock_init(&vp->lock);
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");
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 }
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;
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;
692 return register_netdev(dev);
693 }
696 static 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;
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);
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;
721 if (corkscrew_debug > 1)
722 printk("%s: Initial media type %s.\n",
723 dev->name, media_tbl[dev->if_port].name);
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;
733 config.u.xcvr = dev->if_port;
734 outl(config.i, ioaddr + Wn3_Config);
736 if (corkscrew_debug > 1) {
737 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
738 dev->name, config.i);
739 }
741 outw(TxReset, ioaddr + EL3_CMD);
742 for (i = 20; i >= 0; i--)
743 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
744 break;
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;
752 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
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);
763 } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
764 vp->product_name, dev)) {
765 return -EAGAIN;
766 }
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 }
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);
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);
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);
801 /* Switch to register set 7 for normal use. */
802 EL3WINDOW(7);
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 */
824 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
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. */
841 netif_start_queue(dev);
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);
857 return 0;
858 }
860 static 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;
869 if (corkscrew_debug > 1)
870 printk("%s: Media selection timer tick happened, %s.\n",
871 dev->name, media_tbl[dev->if_port].name);
873 spin_lock_irqsave(&vp->lock, flags);
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);
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;
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));
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);
933 EL3WINDOW(3);
934 config.i = inl(ioaddr + Wn3_Config);
935 config.u.xcvr = dev->if_port;
936 outl(config.i, ioaddr + Wn3_Config);
938 outw(dev->if_port == 3 ? StartCoax : StopCoax,
939 ioaddr + EL3_CMD);
940 }
941 EL3WINDOW(old_window);
942 }
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);
949 #endif /* AUTOMEDIA */
950 return;
951 }
953 static 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;
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 }
992 static 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;
998 /* Block a timer-based transmit from overlapping. */
1000 netif_stop_queue(dev);
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;
1007 int i;
1009 if (vp->tx_full) /* No room to transmit with */
1010 return 1;
1011 if (vp->cur_tx != 0)
1012 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1013 else
1014 prev_entry = NULL;
1015 if (corkscrew_debug > 3)
1016 printk("%s: Trying to send a packet, Tx index %d.\n",
1017 dev->name, vp->cur_tx);
1018 /* vp->tx_full = 1; */
1019 vp->tx_skbuff[entry] = skb;
1020 vp->tx_ring[entry].next = 0;
1021 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1022 vp->tx_ring[entry].length = skb->len | 0x80000000;
1023 vp->tx_ring[entry].status = skb->len | 0x80000000;
1025 spin_lock_irqsave(&vp->lock, flags);
1026 outw(DownStall, ioaddr + EL3_CMD);
1027 /* Wait for the stall to complete. */
1028 for (i = 20; i >= 0; i--)
1029 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1030 break;
1031 if (prev_entry)
1032 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1033 if (inl(ioaddr + DownListPtr) == 0) {
1034 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1035 ioaddr + DownListPtr);
1036 queued_packet++;
1038 outw(DownUnstall, ioaddr + EL3_CMD);
1039 spin_unlock_irqrestore(&vp->lock, flags);
1041 vp->cur_tx++;
1042 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1043 vp->tx_full = 1;
1044 else { /* Clear previous interrupt enable. */
1045 if (prev_entry)
1046 prev_entry->status &= ~0x80000000;
1047 netif_wake_queue(dev);
1049 dev->trans_start = jiffies;
1050 return 0;
1052 /* Put out the doubleword header... */
1053 outl(skb->len, ioaddr + TX_FIFO);
1054 vp->stats.tx_bytes += skb->len;
1055 #ifdef VORTEX_BUS_MASTER
1056 if (vp->bus_master) {
1057 /* Set the bus-master controller to transfer the packet. */
1058 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1059 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1060 vp->tx_skb = skb;
1061 outw(StartDMADown, ioaddr + EL3_CMD);
1062 /* queue will be woken at the DMADone interrupt. */
1063 } else {
1064 /* ... and the packet rounded to a doubleword. */
1065 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1066 dev_kfree_skb(skb);
1067 if (inw(ioaddr + TxFree) > 1536) {
1068 netif_wake_queue(dev);
1069 } else
1070 /* Interrupt us when the FIFO has room for max-sized packet. */
1071 outw(SetTxThreshold + (1536 >> 2),
1072 ioaddr + EL3_CMD);
1074 #else
1075 /* ... and the packet rounded to a doubleword. */
1076 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1077 dev_kfree_skb(skb);
1078 if (inw(ioaddr + TxFree) > 1536) {
1079 netif_wake_queue(dev);
1080 } else
1081 /* Interrupt us when the FIFO has room for max-sized packet. */
1082 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1083 #endif /* bus master */
1085 dev->trans_start = jiffies;
1087 /* Clear the Tx status stack. */
1089 short tx_status;
1090 int i = 4;
1092 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1093 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1094 if (corkscrew_debug > 2)
1095 printk("%s: Tx error, status %2.2x.\n",
1096 dev->name, tx_status);
1097 if (tx_status & 0x04)
1098 vp->stats.tx_fifo_errors++;
1099 if (tx_status & 0x38)
1100 vp->stats.tx_aborted_errors++;
1101 if (tx_status & 0x30) {
1102 int j;
1103 outw(TxReset, ioaddr + EL3_CMD);
1104 for (j = 20; j >= 0; j--)
1105 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1106 break;
1108 outw(TxEnable, ioaddr + EL3_CMD);
1110 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1113 return 0;
1116 /* The interrupt handler does all of the Rx thread work and cleans up
1117 after the Tx thread. */
1119 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id,
1120 struct pt_regs *regs)
1122 /* Use the now-standard shared IRQ implementation. */
1123 struct net_device *dev = dev_id;
1124 struct corkscrew_private *lp = netdev_priv(dev);
1125 int ioaddr, status;
1126 int latency;
1127 int i = max_interrupt_work;
1129 ioaddr = dev->base_addr;
1130 latency = inb(ioaddr + Timer);
1132 spin_lock(&lp->lock);
1134 status = inw(ioaddr + EL3_STATUS);
1136 if (corkscrew_debug > 4)
1137 printk("%s: interrupt, status %4.4x, timer %d.\n",
1138 dev->name, status, latency);
1139 if ((status & 0xE000) != 0xE000) {
1140 static int donedidthis;
1141 /* Some interrupt controllers store a bogus interrupt from boot-time.
1142 Ignore a single early interrupt, but don't hang the machine for
1143 other interrupt problems. */
1144 if (donedidthis++ > 100) {
1145 printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1146 dev->name, status, netif_running(dev));
1147 free_irq(dev->irq, dev);
1148 dev->irq = -1;
1152 do {
1153 if (corkscrew_debug > 5)
1154 printk("%s: In interrupt loop, status %4.4x.\n",
1155 dev->name, status);
1156 if (status & RxComplete)
1157 corkscrew_rx(dev);
1159 if (status & TxAvailable) {
1160 if (corkscrew_debug > 5)
1161 printk(" TX room bit was handled.\n");
1162 /* There's room in the FIFO for a full-sized packet. */
1163 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1164 netif_wake_queue(dev);
1166 if (status & DownComplete) {
1167 unsigned int dirty_tx = lp->dirty_tx;
1169 while (lp->cur_tx - dirty_tx > 0) {
1170 int entry = dirty_tx % TX_RING_SIZE;
1171 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1172 break; /* It still hasn't been processed. */
1173 if (lp->tx_skbuff[entry]) {
1174 dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1175 lp->tx_skbuff[entry] = NULL;
1177 dirty_tx++;
1179 lp->dirty_tx = dirty_tx;
1180 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1181 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1182 lp->tx_full = 0;
1183 netif_wake_queue(dev);
1186 #ifdef VORTEX_BUS_MASTER
1187 if (status & DMADone) {
1188 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1189 dev_kfree_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1190 netif_wake_queue(dev);
1192 #endif
1193 if (status & UpComplete) {
1194 boomerang_rx(dev);
1195 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1197 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1198 /* Handle all uncommon interrupts at once. */
1199 if (status & RxEarly) { /* Rx early is unused. */
1200 corkscrew_rx(dev);
1201 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1203 if (status & StatsFull) { /* Empty statistics. */
1204 static int DoneDidThat;
1205 if (corkscrew_debug > 4)
1206 printk("%s: Updating stats.\n", dev->name);
1207 update_stats(ioaddr, dev);
1208 /* DEBUG HACK: Disable statistics as an interrupt source. */
1209 /* This occurs when we have the wrong media type! */
1210 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1211 int win, reg;
1212 printk("%s: Updating stats failed, disabling stats as an"
1213 " interrupt source.\n", dev->name);
1214 for (win = 0; win < 8; win++) {
1215 EL3WINDOW(win);
1216 printk("\n Vortex window %d:", win);
1217 for (reg = 0; reg < 16; reg++)
1218 printk(" %2.2x", inb(ioaddr + reg));
1220 EL3WINDOW(7);
1221 outw(SetIntrEnb | TxAvailable |
1222 RxComplete | AdapterFailure |
1223 UpComplete | DownComplete |
1224 TxComplete, ioaddr + EL3_CMD);
1225 DoneDidThat++;
1228 if (status & AdapterFailure) {
1229 /* Adapter failure requires Rx reset and reinit. */
1230 outw(RxReset, ioaddr + EL3_CMD);
1231 /* Set the Rx filter to the current state. */
1232 set_rx_mode(dev);
1233 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1234 outw(AckIntr | AdapterFailure,
1235 ioaddr + EL3_CMD);
1239 if (--i < 0) {
1240 printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x. "
1241 "Disabling functions (%4.4x).\n", dev->name,
1242 status, SetStatusEnb | ((~status) & 0x7FE));
1243 /* Disable all pending interrupts. */
1244 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1245 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1246 break;
1248 /* Acknowledge the IRQ. */
1249 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1251 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1253 spin_unlock(&lp->lock);
1255 if (corkscrew_debug > 4)
1256 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1257 return IRQ_HANDLED;
1260 static int corkscrew_rx(struct net_device *dev)
1262 struct corkscrew_private *vp = netdev_priv(dev);
1263 int ioaddr = dev->base_addr;
1264 int i;
1265 short rx_status;
1267 if (corkscrew_debug > 5)
1268 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1269 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1270 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1271 if (rx_status & 0x4000) { /* Error, update stats. */
1272 unsigned char rx_error = inb(ioaddr + RxErrors);
1273 if (corkscrew_debug > 2)
1274 printk(" Rx error: status %2.2x.\n",
1275 rx_error);
1276 vp->stats.rx_errors++;
1277 if (rx_error & 0x01)
1278 vp->stats.rx_over_errors++;
1279 if (rx_error & 0x02)
1280 vp->stats.rx_length_errors++;
1281 if (rx_error & 0x04)
1282 vp->stats.rx_frame_errors++;
1283 if (rx_error & 0x08)
1284 vp->stats.rx_crc_errors++;
1285 if (rx_error & 0x10)
1286 vp->stats.rx_length_errors++;
1287 } else {
1288 /* The packet length: up to 4.5K!. */
1289 short pkt_len = rx_status & 0x1fff;
1290 struct sk_buff *skb;
1292 skb = dev_alloc_skb(pkt_len + 5 + 2);
1293 if (corkscrew_debug > 4)
1294 printk("Receiving packet size %d status %4.4x.\n",
1295 pkt_len, rx_status);
1296 if (skb != NULL) {
1297 skb->dev = dev;
1298 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1299 /* 'skb_put()' points to the start of sk_buff data area. */
1300 insl(ioaddr + RX_FIFO,
1301 skb_put(skb, pkt_len),
1302 (pkt_len + 3) >> 2);
1303 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1304 skb->protocol = eth_type_trans(skb, dev);
1305 netif_rx(skb);
1306 dev->last_rx = jiffies;
1307 vp->stats.rx_packets++;
1308 vp->stats.rx_bytes += pkt_len;
1309 /* Wait a limited time to go to next packet. */
1310 for (i = 200; i >= 0; i--)
1311 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1312 break;
1313 continue;
1314 } else if (corkscrew_debug)
1315 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1317 outw(RxDiscard, ioaddr + EL3_CMD);
1318 vp->stats.rx_dropped++;
1319 /* Wait a limited time to skip this packet. */
1320 for (i = 200; i >= 0; i--)
1321 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1322 break;
1324 return 0;
1327 static int boomerang_rx(struct net_device *dev)
1329 struct corkscrew_private *vp = netdev_priv(dev);
1330 int entry = vp->cur_rx % RX_RING_SIZE;
1331 int ioaddr = dev->base_addr;
1332 int rx_status;
1334 if (corkscrew_debug > 5)
1335 printk(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1336 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1337 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1338 if (rx_status & RxDError) { /* Error, update stats. */
1339 unsigned char rx_error = rx_status >> 16;
1340 if (corkscrew_debug > 2)
1341 printk(" Rx error: status %2.2x.\n",
1342 rx_error);
1343 vp->stats.rx_errors++;
1344 if (rx_error & 0x01)
1345 vp->stats.rx_over_errors++;
1346 if (rx_error & 0x02)
1347 vp->stats.rx_length_errors++;
1348 if (rx_error & 0x04)
1349 vp->stats.rx_frame_errors++;
1350 if (rx_error & 0x08)
1351 vp->stats.rx_crc_errors++;
1352 if (rx_error & 0x10)
1353 vp->stats.rx_length_errors++;
1354 } else {
1355 /* The packet length: up to 4.5K!. */
1356 short pkt_len = rx_status & 0x1fff;
1357 struct sk_buff *skb;
1359 vp->stats.rx_bytes += pkt_len;
1360 if (corkscrew_debug > 4)
1361 printk("Receiving packet size %d status %4.4x.\n",
1362 pkt_len, rx_status);
1364 /* Check if the packet is long enough to just accept without
1365 copying to a properly sized skbuff. */
1366 if (pkt_len < rx_copybreak
1367 && (skb = dev_alloc_skb(pkt_len + 4)) != 0) {
1368 skb->dev = dev;
1369 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1370 /* 'skb_put()' points to the start of sk_buff data area. */
1371 memcpy(skb_put(skb, pkt_len),
1372 isa_bus_to_virt(vp->rx_ring[entry].
1373 addr), pkt_len);
1374 rx_copy++;
1375 } else {
1376 void *temp;
1377 /* Pass up the skbuff already on the Rx ring. */
1378 skb = vp->rx_skbuff[entry];
1379 vp->rx_skbuff[entry] = NULL;
1380 temp = skb_put(skb, pkt_len);
1381 /* Remove this checking code for final release. */
1382 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1383 printk("%s: Warning -- the skbuff addresses do not match"
1384 " in boomerang_rx: %p vs. %p / %p.\n",
1385 dev->name,
1386 isa_bus_to_virt(vp->
1387 rx_ring[entry].
1388 addr), skb->head,
1389 temp);
1390 rx_nocopy++;
1392 skb->protocol = eth_type_trans(skb, dev);
1393 netif_rx(skb);
1394 dev->last_rx = jiffies;
1395 vp->stats.rx_packets++;
1397 entry = (++vp->cur_rx) % RX_RING_SIZE;
1399 /* Refill the Rx ring buffers. */
1400 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1401 struct sk_buff *skb;
1402 entry = vp->dirty_rx % RX_RING_SIZE;
1403 if (vp->rx_skbuff[entry] == NULL) {
1404 skb = dev_alloc_skb(PKT_BUF_SZ);
1405 if (skb == NULL)
1406 break; /* Bad news! */
1407 skb->dev = dev; /* Mark as being used by this device. */
1408 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1409 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1410 vp->rx_skbuff[entry] = skb;
1412 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1414 return 0;
1417 static int corkscrew_close(struct net_device *dev)
1419 struct corkscrew_private *vp = netdev_priv(dev);
1420 int ioaddr = dev->base_addr;
1421 int i;
1423 netif_stop_queue(dev);
1425 if (corkscrew_debug > 1) {
1426 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1427 dev->name, inw(ioaddr + EL3_STATUS),
1428 inb(ioaddr + TxStatus));
1429 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1430 " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1431 queued_packet);
1434 del_timer(&vp->timer);
1436 /* Turn off statistics ASAP. We update lp->stats below. */
1437 outw(StatsDisable, ioaddr + EL3_CMD);
1439 /* Disable the receiver and transmitter. */
1440 outw(RxDisable, ioaddr + EL3_CMD);
1441 outw(TxDisable, ioaddr + EL3_CMD);
1443 if (dev->if_port == XCVR_10base2)
1444 /* Turn off thinnet power. Green! */
1445 outw(StopCoax, ioaddr + EL3_CMD);
1447 free_irq(dev->irq, dev);
1449 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1451 update_stats(ioaddr, dev);
1452 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1453 outl(0, ioaddr + UpListPtr);
1454 for (i = 0; i < RX_RING_SIZE; i++)
1455 if (vp->rx_skbuff[i]) {
1456 dev_kfree_skb(vp->rx_skbuff[i]);
1457 vp->rx_skbuff[i] = NULL;
1460 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1461 outl(0, ioaddr + DownListPtr);
1462 for (i = 0; i < TX_RING_SIZE; i++)
1463 if (vp->tx_skbuff[i]) {
1464 dev_kfree_skb(vp->tx_skbuff[i]);
1465 vp->tx_skbuff[i] = NULL;
1469 return 0;
1472 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1474 struct corkscrew_private *vp = netdev_priv(dev);
1475 unsigned long flags;
1477 if (netif_running(dev)) {
1478 spin_lock_irqsave(&vp->lock, flags);
1479 update_stats(dev->base_addr, dev);
1480 spin_unlock_irqrestore(&vp->lock, flags);
1482 return &vp->stats;
1485 /* Update statistics.
1486 Unlike with the EL3 we need not worry about interrupts changing
1487 the window setting from underneath us, but we must still guard
1488 against a race condition with a StatsUpdate interrupt updating the
1489 table. This is done by checking that the ASM (!) code generated uses
1490 atomic updates with '+='.
1491 */
1492 static void update_stats(int ioaddr, struct net_device *dev)
1494 struct corkscrew_private *vp = netdev_priv(dev);
1496 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1497 /* Switch to the stats window, and read everything. */
1498 EL3WINDOW(6);
1499 vp->stats.tx_carrier_errors += inb(ioaddr + 0);
1500 vp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1501 /* Multiple collisions. */ inb(ioaddr + 2);
1502 vp->stats.collisions += inb(ioaddr + 3);
1503 vp->stats.tx_window_errors += inb(ioaddr + 4);
1504 vp->stats.rx_fifo_errors += inb(ioaddr + 5);
1505 vp->stats.tx_packets += inb(ioaddr + 6);
1506 vp->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1507 /* 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);
1519 /* We change back to window 7 (not 1) with the Vortex. */
1520 EL3WINDOW(7);
1521 return;
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. */
1528 static void set_rx_mode(struct net_device *dev)
1530 int ioaddr = dev->base_addr;
1531 short new_mode;
1533 if (dev->flags & IFF_PROMISC) {
1534 if (corkscrew_debug > 3)
1535 printk("%s: Setting promiscuous mode.\n",
1536 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;
1543 outw(new_mode, ioaddr + EL3_CMD);
1546 static void netdev_get_drvinfo(struct net_device *dev,
1547 struct ethtool_drvinfo *info)
1549 strcpy(info->driver, DRV_NAME);
1550 strcpy(info->version, DRV_VERSION);
1551 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1554 static u32 netdev_get_msglevel(struct net_device *dev)
1556 return corkscrew_debug;
1559 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1561 corkscrew_debug = level;
1564 static struct ethtool_ops netdev_ethtool_ops = {
1565 .get_drvinfo = netdev_get_drvinfo,
1566 .get_msglevel = netdev_get_msglevel,
1567 .set_msglevel = netdev_set_msglevel,
1568 };
1571 #ifdef MODULE
1572 void cleanup_module(void)
1574 while (!list_empty(&root_corkscrew_dev)) {
1575 struct net_device *dev;
1576 struct corkscrew_private *vp;
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);
1586 #endif /* MODULE */
1588 /*
1589 * Local variables:
1590 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1591 * c-indent-level: 4
1592 * tab-width: 4
1593 * End:
1594 */