ia64/linux-2.6.18-xen.hg

view drivers/net/3c505.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 * Linux Ethernet device driver for the 3Com Etherlink Plus (3C505)
3 * By Craig Southeren, Juha Laiho and Philip Blundell
4 *
5 * 3c505.c This module implements an interface to the 3Com
6 * Etherlink Plus (3c505) Ethernet card. Linux device
7 * driver interface reverse engineered from the Linux 3C509
8 * device drivers. Some 3C505 information gleaned from
9 * the Crynwr packet driver. Still this driver would not
10 * be here without 3C505 technical reference provided by
11 * 3Com.
12 *
13 * $Id: 3c505.c,v 1.10 1996/04/16 13:06:27 phil Exp $
14 *
15 * Authors: Linux 3c505 device driver by
16 * Craig Southeren, <craigs@ineluki.apana.org.au>
17 * Final debugging by
18 * Andrew Tridgell, <tridge@nimbus.anu.edu.au>
19 * Auto irq/address, tuning, cleanup and v1.1.4+ kernel mods by
20 * Juha Laiho, <jlaiho@ichaos.nullnet.fi>
21 * Linux 3C509 driver by
22 * Donald Becker, <becker@super.org>
23 * (Now at <becker@scyld.com>)
24 * Crynwr packet driver by
25 * Krishnan Gopalan and Gregg Stefancik,
26 * Clemson University Engineering Computer Operations.
27 * Portions of the code have been adapted from the 3c505
28 * driver for NCSA Telnet by Bruce Orchard and later
29 * modified by Warren Van Houten and krus@diku.dk.
30 * 3C505 technical information provided by
31 * Terry Murphy, of 3Com Network Adapter Division
32 * Linux 1.3.0 changes by
33 * Alan Cox <Alan.Cox@linux.org>
34 * More debugging, DMA support, currently maintained by
35 * Philip Blundell <philb@gnu.org>
36 * Multicard/soft configurable dma channel/rev 2 hardware support
37 * by Christopher Collins <ccollins@pcug.org.au>
38 * Ethtool support (jgarzik), 11/17/2001
39 */
41 #define DRV_NAME "3c505"
42 #define DRV_VERSION "1.10a"
45 /* Theory of operation:
46 *
47 * The 3c505 is quite an intelligent board. All communication with it is done
48 * by means of Primary Command Blocks (PCBs); these are transferred using PIO
49 * through the command register. The card has 256k of on-board RAM, which is
50 * used to buffer received packets. It might seem at first that more buffers
51 * are better, but in fact this isn't true. From my tests, it seems that
52 * more than about 10 buffers are unnecessary, and there is a noticeable
53 * performance hit in having more active on the card. So the majority of the
54 * card's memory isn't, in fact, used. Sadly, the card only has one transmit
55 * buffer and, short of loading our own firmware into it (which is what some
56 * drivers resort to) there's nothing we can do about this.
57 *
58 * We keep up to 4 "receive packet" commands active on the board at a time.
59 * When a packet comes in, so long as there is a receive command active, the
60 * board will send us a "packet received" PCB and then add the data for that
61 * packet to the DMA queue. If a DMA transfer is not already in progress, we
62 * set one up to start uploading the data. We have to maintain a list of
63 * backlogged receive packets, because the card may decide to tell us about
64 * a newly-arrived packet at any time, and we may not be able to start a DMA
65 * transfer immediately (ie one may already be going on). We can't NAK the
66 * PCB, because then it would throw the packet away.
67 *
68 * Trying to send a PCB to the card at the wrong moment seems to have bad
69 * effects. If we send it a transmit PCB while a receive DMA is happening,
70 * it will just NAK the PCB and so we will have wasted our time. Worse, it
71 * sometimes seems to interrupt the transfer. The majority of the low-level
72 * code is protected by one huge semaphore -- "busy" -- which is set whenever
73 * it probably isn't safe to do anything to the card. The receive routine
74 * must gain a lock on "busy" before it can start a DMA transfer, and the
75 * transmit routine must gain a lock before it sends the first PCB to the card.
76 * The send_pcb() routine also has an internal semaphore to protect it against
77 * being re-entered (which would be disastrous) -- this is needed because
78 * several things can happen asynchronously (re-priming the receiver and
79 * asking the card for statistics, for example). send_pcb() will also refuse
80 * to talk to the card at all if a DMA upload is happening. The higher-level
81 * networking code will reschedule a later retry if some part of the driver
82 * is blocked. In practice, this doesn't seem to happen very often.
83 */
85 /* This driver may now work with revision 2.x hardware, since all the read
86 * operations on the HCR have been removed (we now keep our own softcopy).
87 * But I don't have an old card to test it on.
88 *
89 * This has had the bad effect that the autoprobe routine is now a bit
90 * less friendly to other devices. However, it was never very good.
91 * before, so I doubt it will hurt anybody.
92 */
94 /* The driver is a mess. I took Craig's and Juha's code, and hacked it firstly
95 * to make it more reliable, and secondly to add DMA mode. Many things could
96 * probably be done better; the concurrency protection is particularly awful.
97 */
99 #include <linux/module.h>
100 #include <linux/kernel.h>
101 #include <linux/string.h>
102 #include <linux/interrupt.h>
103 #include <linux/errno.h>
104 #include <linux/in.h>
105 #include <linux/slab.h>
106 #include <linux/ioport.h>
107 #include <linux/spinlock.h>
108 #include <linux/ethtool.h>
109 #include <linux/delay.h>
110 #include <linux/bitops.h>
112 #include <asm/uaccess.h>
113 #include <asm/io.h>
114 #include <asm/dma.h>
116 #include <linux/netdevice.h>
117 #include <linux/etherdevice.h>
118 #include <linux/skbuff.h>
119 #include <linux/init.h>
121 #include "3c505.h"
123 /*********************************************************
124 *
125 * define debug messages here as common strings to reduce space
126 *
127 *********************************************************/
129 static const char filename[] = __FILE__;
131 static const char timeout_msg[] = "*** timeout at %s:%s (line %d) ***\n";
132 #define TIMEOUT_MSG(lineno) \
133 printk(timeout_msg, filename,__FUNCTION__,(lineno))
135 static const char invalid_pcb_msg[] =
136 "*** invalid pcb length %d at %s:%s (line %d) ***\n";
137 #define INVALID_PCB_MSG(len) \
138 printk(invalid_pcb_msg, (len),filename,__FUNCTION__,__LINE__)
140 static char search_msg[] __initdata = KERN_INFO "%s: Looking for 3c505 adapter at address %#x...";
142 static char stilllooking_msg[] __initdata = "still looking...";
144 static char found_msg[] __initdata = "found.\n";
146 static char notfound_msg[] __initdata = "not found (reason = %d)\n";
148 static char couldnot_msg[] __initdata = KERN_INFO "%s: 3c505 not found\n";
150 /*********************************************************
151 *
152 * various other debug stuff
153 *
154 *********************************************************/
156 #ifdef ELP_DEBUG
157 static int elp_debug = ELP_DEBUG;
158 #else
159 static int elp_debug;
160 #endif
161 #define debug elp_debug
163 /*
164 * 0 = no messages (well, some)
165 * 1 = messages when high level commands performed
166 * 2 = messages when low level commands performed
167 * 3 = messages when interrupts received
168 */
170 /*****************************************************************
171 *
172 * useful macros
173 *
174 *****************************************************************/
176 #ifndef TRUE
177 #define TRUE 1
178 #endif
180 #ifndef FALSE
181 #define FALSE 0
182 #endif
185 /*****************************************************************
186 *
187 * List of I/O-addresses we try to auto-sense
188 * Last element MUST BE 0!
189 *****************************************************************/
191 static int addr_list[] __initdata = {0x300, 0x280, 0x310, 0};
193 /* Dma Memory related stuff */
195 static unsigned long dma_mem_alloc(int size)
196 {
197 int order = get_order(size);
198 return __get_dma_pages(GFP_KERNEL, order);
199 }
202 /*****************************************************************
203 *
204 * Functions for I/O (note the inline !)
205 *
206 *****************************************************************/
208 static inline unsigned char inb_status(unsigned int base_addr)
209 {
210 return inb(base_addr + PORT_STATUS);
211 }
213 static inline int inb_command(unsigned int base_addr)
214 {
215 return inb(base_addr + PORT_COMMAND);
216 }
218 static inline void outb_control(unsigned char val, struct net_device *dev)
219 {
220 outb(val, dev->base_addr + PORT_CONTROL);
221 ((elp_device *)(dev->priv))->hcr_val = val;
222 }
224 #define HCR_VAL(x) (((elp_device *)((x)->priv))->hcr_val)
226 static inline void outb_command(unsigned char val, unsigned int base_addr)
227 {
228 outb(val, base_addr + PORT_COMMAND);
229 }
231 static inline unsigned int backlog_next(unsigned int n)
232 {
233 return (n + 1) % BACKLOG_SIZE;
234 }
236 /*****************************************************************
237 *
238 * useful functions for accessing the adapter
239 *
240 *****************************************************************/
242 /*
243 * use this routine when accessing the ASF bits as they are
244 * changed asynchronously by the adapter
245 */
247 /* get adapter PCB status */
248 #define GET_ASF(addr) \
249 (get_status(addr)&ASF_PCB_MASK)
251 static inline int get_status(unsigned int base_addr)
252 {
253 unsigned long timeout = jiffies + 10*HZ/100;
254 register int stat1;
255 do {
256 stat1 = inb_status(base_addr);
257 } while (stat1 != inb_status(base_addr) && time_before(jiffies, timeout));
258 if (time_after_eq(jiffies, timeout))
259 TIMEOUT_MSG(__LINE__);
260 return stat1;
261 }
263 static inline void set_hsf(struct net_device *dev, int hsf)
264 {
265 elp_device *adapter = dev->priv;
266 unsigned long flags;
268 spin_lock_irqsave(&adapter->lock, flags);
269 outb_control((HCR_VAL(dev) & ~HSF_PCB_MASK) | hsf, dev);
270 spin_unlock_irqrestore(&adapter->lock, flags);
271 }
273 static int start_receive(struct net_device *, pcb_struct *);
275 static inline void adapter_reset(struct net_device *dev)
276 {
277 unsigned long timeout;
278 elp_device *adapter = dev->priv;
279 unsigned char orig_hcr = adapter->hcr_val;
281 outb_control(0, dev);
283 if (inb_status(dev->base_addr) & ACRF) {
284 do {
285 inb_command(dev->base_addr);
286 timeout = jiffies + 2*HZ/100;
287 while (time_before_eq(jiffies, timeout) && !(inb_status(dev->base_addr) & ACRF));
288 } while (inb_status(dev->base_addr) & ACRF);
289 set_hsf(dev, HSF_PCB_NAK);
290 }
291 outb_control(adapter->hcr_val | ATTN | DIR, dev);
292 mdelay(10);
293 outb_control(adapter->hcr_val & ~ATTN, dev);
294 mdelay(10);
295 outb_control(adapter->hcr_val | FLSH, dev);
296 mdelay(10);
297 outb_control(adapter->hcr_val & ~FLSH, dev);
298 mdelay(10);
300 outb_control(orig_hcr, dev);
301 if (!start_receive(dev, &adapter->tx_pcb))
302 printk(KERN_ERR "%s: start receive command failed \n", dev->name);
303 }
305 /* Check to make sure that a DMA transfer hasn't timed out. This should
306 * never happen in theory, but seems to occur occasionally if the card gets
307 * prodded at the wrong time.
308 */
309 static inline void check_3c505_dma(struct net_device *dev)
310 {
311 elp_device *adapter = dev->priv;
312 if (adapter->dmaing && time_after(jiffies, adapter->current_dma.start_time + 10)) {
313 unsigned long flags, f;
314 printk(KERN_ERR "%s: DMA %s timed out, %d bytes left\n", dev->name, adapter->current_dma.direction ? "download" : "upload", get_dma_residue(dev->dma));
315 spin_lock_irqsave(&adapter->lock, flags);
316 adapter->dmaing = 0;
317 adapter->busy = 0;
319 f=claim_dma_lock();
320 disable_dma(dev->dma);
321 release_dma_lock(f);
323 if (adapter->rx_active)
324 adapter->rx_active--;
325 outb_control(adapter->hcr_val & ~(DMAE | TCEN | DIR), dev);
326 spin_unlock_irqrestore(&adapter->lock, flags);
327 }
328 }
330 /* Primitive functions used by send_pcb() */
331 static inline unsigned int send_pcb_slow(unsigned int base_addr, unsigned char byte)
332 {
333 unsigned long timeout;
334 outb_command(byte, base_addr);
335 for (timeout = jiffies + 5*HZ/100; time_before(jiffies, timeout);) {
336 if (inb_status(base_addr) & HCRE)
337 return FALSE;
338 }
339 printk(KERN_WARNING "3c505: send_pcb_slow timed out\n");
340 return TRUE;
341 }
343 static inline unsigned int send_pcb_fast(unsigned int base_addr, unsigned char byte)
344 {
345 unsigned int timeout;
346 outb_command(byte, base_addr);
347 for (timeout = 0; timeout < 40000; timeout++) {
348 if (inb_status(base_addr) & HCRE)
349 return FALSE;
350 }
351 printk(KERN_WARNING "3c505: send_pcb_fast timed out\n");
352 return TRUE;
353 }
355 /* Check to see if the receiver needs restarting, and kick it if so */
356 static inline void prime_rx(struct net_device *dev)
357 {
358 elp_device *adapter = dev->priv;
359 while (adapter->rx_active < ELP_RX_PCBS && netif_running(dev)) {
360 if (!start_receive(dev, &adapter->itx_pcb))
361 break;
362 }
363 }
365 /*****************************************************************
366 *
367 * send_pcb
368 * Send a PCB to the adapter.
369 *
370 * output byte to command reg --<--+
371 * wait until HCRE is non zero |
372 * loop until all bytes sent -->--+
373 * set HSF1 and HSF2 to 1
374 * output pcb length
375 * wait until ASF give ACK or NAK
376 * set HSF1 and HSF2 to 0
377 *
378 *****************************************************************/
380 /* This can be quite slow -- the adapter is allowed to take up to 40ms
381 * to respond to the initial interrupt.
382 *
383 * We run initially with interrupts turned on, but with a semaphore set
384 * so that nobody tries to re-enter this code. Once the first byte has
385 * gone through, we turn interrupts off and then send the others (the
386 * timeout is reduced to 500us).
387 */
389 static int send_pcb(struct net_device *dev, pcb_struct * pcb)
390 {
391 int i;
392 unsigned long timeout;
393 elp_device *adapter = dev->priv;
394 unsigned long flags;
396 check_3c505_dma(dev);
398 if (adapter->dmaing && adapter->current_dma.direction == 0)
399 return FALSE;
401 /* Avoid contention */
402 if (test_and_set_bit(1, &adapter->send_pcb_semaphore)) {
403 if (elp_debug >= 3) {
404 printk(KERN_DEBUG "%s: send_pcb entered while threaded\n", dev->name);
405 }
406 return FALSE;
407 }
408 /*
409 * load each byte into the command register and
410 * wait for the HCRE bit to indicate the adapter
411 * had read the byte
412 */
413 set_hsf(dev, 0);
415 if (send_pcb_slow(dev->base_addr, pcb->command))
416 goto abort;
418 spin_lock_irqsave(&adapter->lock, flags);
420 if (send_pcb_fast(dev->base_addr, pcb->length))
421 goto sti_abort;
423 for (i = 0; i < pcb->length; i++) {
424 if (send_pcb_fast(dev->base_addr, pcb->data.raw[i]))
425 goto sti_abort;
426 }
428 outb_control(adapter->hcr_val | 3, dev); /* signal end of PCB */
429 outb_command(2 + pcb->length, dev->base_addr);
431 /* now wait for the acknowledgement */
432 spin_unlock_irqrestore(&adapter->lock, flags);
434 for (timeout = jiffies + 5*HZ/100; time_before(jiffies, timeout);) {
435 switch (GET_ASF(dev->base_addr)) {
436 case ASF_PCB_ACK:
437 adapter->send_pcb_semaphore = 0;
438 return TRUE;
440 case ASF_PCB_NAK:
441 #ifdef ELP_DEBUG
442 printk(KERN_DEBUG "%s: send_pcb got NAK\n", dev->name);
443 #endif
444 goto abort;
445 }
446 }
448 if (elp_debug >= 1)
449 printk(KERN_DEBUG "%s: timeout waiting for PCB acknowledge (status %02x)\n", dev->name, inb_status(dev->base_addr));
450 goto abort;
452 sti_abort:
453 spin_unlock_irqrestore(&adapter->lock, flags);
454 abort:
455 adapter->send_pcb_semaphore = 0;
456 return FALSE;
457 }
460 /*****************************************************************
461 *
462 * receive_pcb
463 * Read a PCB from the adapter
464 *
465 * wait for ACRF to be non-zero ---<---+
466 * input a byte |
467 * if ASF1 and ASF2 were not both one |
468 * before byte was read, loop --->---+
469 * set HSF1 and HSF2 for ack
470 *
471 *****************************************************************/
473 static int receive_pcb(struct net_device *dev, pcb_struct * pcb)
474 {
475 int i, j;
476 int total_length;
477 int stat;
478 unsigned long timeout;
479 unsigned long flags;
481 elp_device *adapter = dev->priv;
483 set_hsf(dev, 0);
485 /* get the command code */
486 timeout = jiffies + 2*HZ/100;
487 while (((stat = get_status(dev->base_addr)) & ACRF) == 0 && time_before(jiffies, timeout));
488 if (time_after_eq(jiffies, timeout)) {
489 TIMEOUT_MSG(__LINE__);
490 return FALSE;
491 }
492 pcb->command = inb_command(dev->base_addr);
494 /* read the data length */
495 timeout = jiffies + 3*HZ/100;
496 while (((stat = get_status(dev->base_addr)) & ACRF) == 0 && time_before(jiffies, timeout));
497 if (time_after_eq(jiffies, timeout)) {
498 TIMEOUT_MSG(__LINE__);
499 printk(KERN_INFO "%s: status %02x\n", dev->name, stat);
500 return FALSE;
501 }
502 pcb->length = inb_command(dev->base_addr);
504 if (pcb->length > MAX_PCB_DATA) {
505 INVALID_PCB_MSG(pcb->length);
506 adapter_reset(dev);
507 return FALSE;
508 }
509 /* read the data */
510 spin_lock_irqsave(&adapter->lock, flags);
511 i = 0;
512 do {
513 j = 0;
514 while (((stat = get_status(dev->base_addr)) & ACRF) == 0 && j++ < 20000);
515 pcb->data.raw[i++] = inb_command(dev->base_addr);
516 if (i > MAX_PCB_DATA)
517 INVALID_PCB_MSG(i);
518 } while ((stat & ASF_PCB_MASK) != ASF_PCB_END && j < 20000);
519 spin_unlock_irqrestore(&adapter->lock, flags);
520 if (j >= 20000) {
521 TIMEOUT_MSG(__LINE__);
522 return FALSE;
523 }
524 /* woops, the last "data" byte was really the length! */
525 total_length = pcb->data.raw[--i];
527 /* safety check total length vs data length */
528 if (total_length != (pcb->length + 2)) {
529 if (elp_debug >= 2)
530 printk(KERN_WARNING "%s: mangled PCB received\n", dev->name);
531 set_hsf(dev, HSF_PCB_NAK);
532 return FALSE;
533 }
535 if (pcb->command == CMD_RECEIVE_PACKET_COMPLETE) {
536 if (test_and_set_bit(0, (void *) &adapter->busy)) {
537 if (backlog_next(adapter->rx_backlog.in) == adapter->rx_backlog.out) {
538 set_hsf(dev, HSF_PCB_NAK);
539 printk(KERN_WARNING "%s: PCB rejected, transfer in progress and backlog full\n", dev->name);
540 pcb->command = 0;
541 return TRUE;
542 } else {
543 pcb->command = 0xff;
544 }
545 }
546 }
547 set_hsf(dev, HSF_PCB_ACK);
548 return TRUE;
549 }
551 /******************************************************
552 *
553 * queue a receive command on the adapter so we will get an
554 * interrupt when a packet is received.
555 *
556 ******************************************************/
558 static int start_receive(struct net_device *dev, pcb_struct * tx_pcb)
559 {
560 int status;
561 elp_device *adapter = dev->priv;
563 if (elp_debug >= 3)
564 printk(KERN_DEBUG "%s: restarting receiver\n", dev->name);
565 tx_pcb->command = CMD_RECEIVE_PACKET;
566 tx_pcb->length = sizeof(struct Rcv_pkt);
567 tx_pcb->data.rcv_pkt.buf_seg
568 = tx_pcb->data.rcv_pkt.buf_ofs = 0; /* Unused */
569 tx_pcb->data.rcv_pkt.buf_len = 1600;
570 tx_pcb->data.rcv_pkt.timeout = 0; /* set timeout to zero */
571 status = send_pcb(dev, tx_pcb);
572 if (status)
573 adapter->rx_active++;
574 return status;
575 }
577 /******************************************************
578 *
579 * extract a packet from the adapter
580 * this routine is only called from within the interrupt
581 * service routine, so no cli/sti calls are needed
582 * note that the length is always assumed to be even
583 *
584 ******************************************************/
586 static void receive_packet(struct net_device *dev, int len)
587 {
588 int rlen;
589 elp_device *adapter = dev->priv;
590 void *target;
591 struct sk_buff *skb;
592 unsigned long flags;
594 rlen = (len + 1) & ~1;
595 skb = dev_alloc_skb(rlen + 2);
597 if (!skb) {
598 printk(KERN_WARNING "%s: memory squeeze, dropping packet\n", dev->name);
599 target = adapter->dma_buffer;
600 adapter->current_dma.target = NULL;
601 /* FIXME: stats */
602 return;
603 }
605 skb_reserve(skb, 2);
606 target = skb_put(skb, rlen);
607 if ((unsigned long)(target + rlen) >= MAX_DMA_ADDRESS) {
608 adapter->current_dma.target = target;
609 target = adapter->dma_buffer;
610 } else {
611 adapter->current_dma.target = NULL;
612 }
614 /* if this happens, we die */
615 if (test_and_set_bit(0, (void *) &adapter->dmaing))
616 printk(KERN_ERR "%s: rx blocked, DMA in progress, dir %d\n", dev->name, adapter->current_dma.direction);
618 skb->dev = dev;
619 adapter->current_dma.direction = 0;
620 adapter->current_dma.length = rlen;
621 adapter->current_dma.skb = skb;
622 adapter->current_dma.start_time = jiffies;
624 outb_control(adapter->hcr_val | DIR | TCEN | DMAE, dev);
626 flags=claim_dma_lock();
627 disable_dma(dev->dma);
628 clear_dma_ff(dev->dma);
629 set_dma_mode(dev->dma, 0x04); /* dma read */
630 set_dma_addr(dev->dma, isa_virt_to_bus(target));
631 set_dma_count(dev->dma, rlen);
632 enable_dma(dev->dma);
633 release_dma_lock(flags);
635 if (elp_debug >= 3) {
636 printk(KERN_DEBUG "%s: rx DMA transfer started\n", dev->name);
637 }
639 if (adapter->rx_active)
640 adapter->rx_active--;
642 if (!adapter->busy)
643 printk(KERN_WARNING "%s: receive_packet called, busy not set.\n", dev->name);
644 }
646 /******************************************************
647 *
648 * interrupt handler
649 *
650 ******************************************************/
652 static irqreturn_t elp_interrupt(int irq, void *dev_id, struct pt_regs *reg_ptr)
653 {
654 int len;
655 int dlen;
656 int icount = 0;
657 struct net_device *dev;
658 elp_device *adapter;
659 unsigned long timeout;
661 dev = dev_id;
662 adapter = (elp_device *) dev->priv;
664 spin_lock(&adapter->lock);
666 do {
667 /*
668 * has a DMA transfer finished?
669 */
670 if (inb_status(dev->base_addr) & DONE) {
671 if (!adapter->dmaing) {
672 printk(KERN_WARNING "%s: phantom DMA completed\n", dev->name);
673 }
674 if (elp_debug >= 3) {
675 printk(KERN_DEBUG "%s: %s DMA complete, status %02x\n", dev->name, adapter->current_dma.direction ? "tx" : "rx", inb_status(dev->base_addr));
676 }
678 outb_control(adapter->hcr_val & ~(DMAE | TCEN | DIR), dev);
679 if (adapter->current_dma.direction) {
680 dev_kfree_skb_irq(adapter->current_dma.skb);
681 } else {
682 struct sk_buff *skb = adapter->current_dma.skb;
683 if (skb) {
684 if (adapter->current_dma.target) {
685 /* have already done the skb_put() */
686 memcpy(adapter->current_dma.target, adapter->dma_buffer, adapter->current_dma.length);
687 }
688 skb->protocol = eth_type_trans(skb,dev);
689 adapter->stats.rx_bytes += skb->len;
690 netif_rx(skb);
691 dev->last_rx = jiffies;
692 }
693 }
694 adapter->dmaing = 0;
695 if (adapter->rx_backlog.in != adapter->rx_backlog.out) {
696 int t = adapter->rx_backlog.length[adapter->rx_backlog.out];
697 adapter->rx_backlog.out = backlog_next(adapter->rx_backlog.out);
698 if (elp_debug >= 2)
699 printk(KERN_DEBUG "%s: receiving backlogged packet (%d)\n", dev->name, t);
700 receive_packet(dev, t);
701 } else {
702 adapter->busy = 0;
703 }
704 } else {
705 /* has one timed out? */
706 check_3c505_dma(dev);
707 }
709 /*
710 * receive a PCB from the adapter
711 */
712 timeout = jiffies + 3*HZ/100;
713 while ((inb_status(dev->base_addr) & ACRF) != 0 && time_before(jiffies, timeout)) {
714 if (receive_pcb(dev, &adapter->irx_pcb)) {
715 switch (adapter->irx_pcb.command)
716 {
717 case 0:
718 break;
719 /*
720 * received a packet - this must be handled fast
721 */
722 case 0xff:
723 case CMD_RECEIVE_PACKET_COMPLETE:
724 /* if the device isn't open, don't pass packets up the stack */
725 if (!netif_running(dev))
726 break;
727 len = adapter->irx_pcb.data.rcv_resp.pkt_len;
728 dlen = adapter->irx_pcb.data.rcv_resp.buf_len;
729 if (adapter->irx_pcb.data.rcv_resp.timeout != 0) {
730 printk(KERN_ERR "%s: interrupt - packet not received correctly\n", dev->name);
731 } else {
732 if (elp_debug >= 3) {
733 printk(KERN_DEBUG "%s: interrupt - packet received of length %i (%i)\n", dev->name, len, dlen);
734 }
735 if (adapter->irx_pcb.command == 0xff) {
736 if (elp_debug >= 2)
737 printk(KERN_DEBUG "%s: adding packet to backlog (len = %d)\n", dev->name, dlen);
738 adapter->rx_backlog.length[adapter->rx_backlog.in] = dlen;
739 adapter->rx_backlog.in = backlog_next(adapter->rx_backlog.in);
740 } else {
741 receive_packet(dev, dlen);
742 }
743 if (elp_debug >= 3)
744 printk(KERN_DEBUG "%s: packet received\n", dev->name);
745 }
746 break;
748 /*
749 * 82586 configured correctly
750 */
751 case CMD_CONFIGURE_82586_RESPONSE:
752 adapter->got[CMD_CONFIGURE_82586] = 1;
753 if (elp_debug >= 3)
754 printk(KERN_DEBUG "%s: interrupt - configure response received\n", dev->name);
755 break;
757 /*
758 * Adapter memory configuration
759 */
760 case CMD_CONFIGURE_ADAPTER_RESPONSE:
761 adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 1;
762 if (elp_debug >= 3)
763 printk(KERN_DEBUG "%s: Adapter memory configuration %s.\n", dev->name,
764 adapter->irx_pcb.data.failed ? "failed" : "succeeded");
765 break;
767 /*
768 * Multicast list loading
769 */
770 case CMD_LOAD_MULTICAST_RESPONSE:
771 adapter->got[CMD_LOAD_MULTICAST_LIST] = 1;
772 if (elp_debug >= 3)
773 printk(KERN_DEBUG "%s: Multicast address list loading %s.\n", dev->name,
774 adapter->irx_pcb.data.failed ? "failed" : "succeeded");
775 break;
777 /*
778 * Station address setting
779 */
780 case CMD_SET_ADDRESS_RESPONSE:
781 adapter->got[CMD_SET_STATION_ADDRESS] = 1;
782 if (elp_debug >= 3)
783 printk(KERN_DEBUG "%s: Ethernet address setting %s.\n", dev->name,
784 adapter->irx_pcb.data.failed ? "failed" : "succeeded");
785 break;
788 /*
789 * received board statistics
790 */
791 case CMD_NETWORK_STATISTICS_RESPONSE:
792 adapter->stats.rx_packets += adapter->irx_pcb.data.netstat.tot_recv;
793 adapter->stats.tx_packets += adapter->irx_pcb.data.netstat.tot_xmit;
794 adapter->stats.rx_crc_errors += adapter->irx_pcb.data.netstat.err_CRC;
795 adapter->stats.rx_frame_errors += adapter->irx_pcb.data.netstat.err_align;
796 adapter->stats.rx_fifo_errors += adapter->irx_pcb.data.netstat.err_ovrrun;
797 adapter->stats.rx_over_errors += adapter->irx_pcb.data.netstat.err_res;
798 adapter->got[CMD_NETWORK_STATISTICS] = 1;
799 if (elp_debug >= 3)
800 printk(KERN_DEBUG "%s: interrupt - statistics response received\n", dev->name);
801 break;
803 /*
804 * sent a packet
805 */
806 case CMD_TRANSMIT_PACKET_COMPLETE:
807 if (elp_debug >= 3)
808 printk(KERN_DEBUG "%s: interrupt - packet sent\n", dev->name);
809 if (!netif_running(dev))
810 break;
811 switch (adapter->irx_pcb.data.xmit_resp.c_stat) {
812 case 0xffff:
813 adapter->stats.tx_aborted_errors++;
814 printk(KERN_INFO "%s: transmit timed out, network cable problem?\n", dev->name);
815 break;
816 case 0xfffe:
817 adapter->stats.tx_fifo_errors++;
818 printk(KERN_INFO "%s: transmit timed out, FIFO underrun\n", dev->name);
819 break;
820 }
821 netif_wake_queue(dev);
822 break;
824 /*
825 * some unknown PCB
826 */
827 default:
828 printk(KERN_DEBUG "%s: unknown PCB received - %2.2x\n", dev->name, adapter->irx_pcb.command);
829 break;
830 }
831 } else {
832 printk(KERN_WARNING "%s: failed to read PCB on interrupt\n", dev->name);
833 adapter_reset(dev);
834 }
835 }
837 } while (icount++ < 5 && (inb_status(dev->base_addr) & (ACRF | DONE)));
839 prime_rx(dev);
841 /*
842 * indicate no longer in interrupt routine
843 */
844 spin_unlock(&adapter->lock);
845 return IRQ_HANDLED;
846 }
849 /******************************************************
850 *
851 * open the board
852 *
853 ******************************************************/
855 static int elp_open(struct net_device *dev)
856 {
857 elp_device *adapter;
858 int retval;
860 adapter = dev->priv;
862 if (elp_debug >= 3)
863 printk(KERN_DEBUG "%s: request to open device\n", dev->name);
865 /*
866 * make sure we actually found the device
867 */
868 if (adapter == NULL) {
869 printk(KERN_ERR "%s: Opening a non-existent physical device\n", dev->name);
870 return -EAGAIN;
871 }
872 /*
873 * disable interrupts on the board
874 */
875 outb_control(0, dev);
877 /*
878 * clear any pending interrupts
879 */
880 inb_command(dev->base_addr);
881 adapter_reset(dev);
883 /*
884 * no receive PCBs active
885 */
886 adapter->rx_active = 0;
888 adapter->busy = 0;
889 adapter->send_pcb_semaphore = 0;
890 adapter->rx_backlog.in = 0;
891 adapter->rx_backlog.out = 0;
893 spin_lock_init(&adapter->lock);
895 /*
896 * install our interrupt service routine
897 */
898 if ((retval = request_irq(dev->irq, &elp_interrupt, 0, dev->name, dev))) {
899 printk(KERN_ERR "%s: could not allocate IRQ%d\n", dev->name, dev->irq);
900 return retval;
901 }
902 if ((retval = request_dma(dev->dma, dev->name))) {
903 free_irq(dev->irq, dev);
904 printk(KERN_ERR "%s: could not allocate DMA%d channel\n", dev->name, dev->dma);
905 return retval;
906 }
907 adapter->dma_buffer = (void *) dma_mem_alloc(DMA_BUFFER_SIZE);
908 if (!adapter->dma_buffer) {
909 printk(KERN_ERR "%s: could not allocate DMA buffer\n", dev->name);
910 free_dma(dev->dma);
911 free_irq(dev->irq, dev);
912 return -ENOMEM;
913 }
914 adapter->dmaing = 0;
916 /*
917 * enable interrupts on the board
918 */
919 outb_control(CMDE, dev);
921 /*
922 * configure adapter memory: we need 10 multicast addresses, default==0
923 */
924 if (elp_debug >= 3)
925 printk(KERN_DEBUG "%s: sending 3c505 memory configuration command\n", dev->name);
926 adapter->tx_pcb.command = CMD_CONFIGURE_ADAPTER_MEMORY;
927 adapter->tx_pcb.data.memconf.cmd_q = 10;
928 adapter->tx_pcb.data.memconf.rcv_q = 20;
929 adapter->tx_pcb.data.memconf.mcast = 10;
930 adapter->tx_pcb.data.memconf.frame = 20;
931 adapter->tx_pcb.data.memconf.rcv_b = 20;
932 adapter->tx_pcb.data.memconf.progs = 0;
933 adapter->tx_pcb.length = sizeof(struct Memconf);
934 adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 0;
935 if (!send_pcb(dev, &adapter->tx_pcb))
936 printk(KERN_ERR "%s: couldn't send memory configuration command\n", dev->name);
937 else {
938 unsigned long timeout = jiffies + TIMEOUT;
939 while (adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] == 0 && time_before(jiffies, timeout));
940 if (time_after_eq(jiffies, timeout))
941 TIMEOUT_MSG(__LINE__);
942 }
945 /*
946 * configure adapter to receive broadcast messages and wait for response
947 */
948 if (elp_debug >= 3)
949 printk(KERN_DEBUG "%s: sending 82586 configure command\n", dev->name);
950 adapter->tx_pcb.command = CMD_CONFIGURE_82586;
951 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
952 adapter->tx_pcb.length = 2;
953 adapter->got[CMD_CONFIGURE_82586] = 0;
954 if (!send_pcb(dev, &adapter->tx_pcb))
955 printk(KERN_ERR "%s: couldn't send 82586 configure command\n", dev->name);
956 else {
957 unsigned long timeout = jiffies + TIMEOUT;
958 while (adapter->got[CMD_CONFIGURE_82586] == 0 && time_before(jiffies, timeout));
959 if (time_after_eq(jiffies, timeout))
960 TIMEOUT_MSG(__LINE__);
961 }
963 /* enable burst-mode DMA */
964 /* outb(0x1, dev->base_addr + PORT_AUXDMA); */
966 /*
967 * queue receive commands to provide buffering
968 */
969 prime_rx(dev);
970 if (elp_debug >= 3)
971 printk(KERN_DEBUG "%s: %d receive PCBs active\n", dev->name, adapter->rx_active);
973 /*
974 * device is now officially open!
975 */
977 netif_start_queue(dev);
978 return 0;
979 }
982 /******************************************************
983 *
984 * send a packet to the adapter
985 *
986 ******************************************************/
988 static int send_packet(struct net_device *dev, struct sk_buff *skb)
989 {
990 elp_device *adapter = dev->priv;
991 unsigned long target;
992 unsigned long flags;
994 /*
995 * make sure the length is even and no shorter than 60 bytes
996 */
997 unsigned int nlen = (((skb->len < 60) ? 60 : skb->len) + 1) & (~1);
999 if (test_and_set_bit(0, (void *) &adapter->busy)) {
1000 if (elp_debug >= 2)
1001 printk(KERN_DEBUG "%s: transmit blocked\n", dev->name);
1002 return FALSE;
1005 adapter->stats.tx_bytes += nlen;
1007 /*
1008 * send the adapter a transmit packet command. Ignore segment and offset
1009 * and make sure the length is even
1010 */
1011 adapter->tx_pcb.command = CMD_TRANSMIT_PACKET;
1012 adapter->tx_pcb.length = sizeof(struct Xmit_pkt);
1013 adapter->tx_pcb.data.xmit_pkt.buf_ofs
1014 = adapter->tx_pcb.data.xmit_pkt.buf_seg = 0; /* Unused */
1015 adapter->tx_pcb.data.xmit_pkt.pkt_len = nlen;
1017 if (!send_pcb(dev, &adapter->tx_pcb)) {
1018 adapter->busy = 0;
1019 return FALSE;
1021 /* if this happens, we die */
1022 if (test_and_set_bit(0, (void *) &adapter->dmaing))
1023 printk(KERN_DEBUG "%s: tx: DMA %d in progress\n", dev->name, adapter->current_dma.direction);
1025 adapter->current_dma.direction = 1;
1026 adapter->current_dma.start_time = jiffies;
1028 if ((unsigned long)(skb->data + nlen) >= MAX_DMA_ADDRESS || nlen != skb->len) {
1029 memcpy(adapter->dma_buffer, skb->data, nlen);
1030 memset(adapter->dma_buffer+skb->len, 0, nlen-skb->len);
1031 target = isa_virt_to_bus(adapter->dma_buffer);
1033 else {
1034 target = isa_virt_to_bus(skb->data);
1036 adapter->current_dma.skb = skb;
1038 flags=claim_dma_lock();
1039 disable_dma(dev->dma);
1040 clear_dma_ff(dev->dma);
1041 set_dma_mode(dev->dma, 0x48); /* dma memory -> io */
1042 set_dma_addr(dev->dma, target);
1043 set_dma_count(dev->dma, nlen);
1044 outb_control(adapter->hcr_val | DMAE | TCEN, dev);
1045 enable_dma(dev->dma);
1046 release_dma_lock(flags);
1048 if (elp_debug >= 3)
1049 printk(KERN_DEBUG "%s: DMA transfer started\n", dev->name);
1051 return TRUE;
1054 /*
1055 * The upper layer thinks we timed out
1056 */
1058 static void elp_timeout(struct net_device *dev)
1060 elp_device *adapter = dev->priv;
1061 int stat;
1063 stat = inb_status(dev->base_addr);
1064 printk(KERN_WARNING "%s: transmit timed out, lost %s?\n", dev->name, (stat & ACRF) ? "interrupt" : "command");
1065 if (elp_debug >= 1)
1066 printk(KERN_DEBUG "%s: status %#02x\n", dev->name, stat);
1067 dev->trans_start = jiffies;
1068 adapter->stats.tx_dropped++;
1069 netif_wake_queue(dev);
1072 /******************************************************
1074 * start the transmitter
1075 * return 0 if sent OK, else return 1
1077 ******************************************************/
1079 static int elp_start_xmit(struct sk_buff *skb, struct net_device *dev)
1081 unsigned long flags;
1082 elp_device *adapter = dev->priv;
1084 spin_lock_irqsave(&adapter->lock, flags);
1085 check_3c505_dma(dev);
1087 if (elp_debug >= 3)
1088 printk(KERN_DEBUG "%s: request to send packet of length %d\n", dev->name, (int) skb->len);
1090 netif_stop_queue(dev);
1092 /*
1093 * send the packet at skb->data for skb->len
1094 */
1095 if (!send_packet(dev, skb)) {
1096 if (elp_debug >= 2) {
1097 printk(KERN_DEBUG "%s: failed to transmit packet\n", dev->name);
1099 spin_unlock_irqrestore(&adapter->lock, flags);
1100 return 1;
1102 if (elp_debug >= 3)
1103 printk(KERN_DEBUG "%s: packet of length %d sent\n", dev->name, (int) skb->len);
1105 /*
1106 * start the transmit timeout
1107 */
1108 dev->trans_start = jiffies;
1110 prime_rx(dev);
1111 spin_unlock_irqrestore(&adapter->lock, flags);
1112 netif_start_queue(dev);
1113 return 0;
1116 /******************************************************
1118 * return statistics on the board
1120 ******************************************************/
1122 static struct net_device_stats *elp_get_stats(struct net_device *dev)
1124 elp_device *adapter = (elp_device *) dev->priv;
1126 if (elp_debug >= 3)
1127 printk(KERN_DEBUG "%s: request for stats\n", dev->name);
1129 /* If the device is closed, just return the latest stats we have,
1130 - we cannot ask from the adapter without interrupts */
1131 if (!netif_running(dev))
1132 return &adapter->stats;
1134 /* send a get statistics command to the board */
1135 adapter->tx_pcb.command = CMD_NETWORK_STATISTICS;
1136 adapter->tx_pcb.length = 0;
1137 adapter->got[CMD_NETWORK_STATISTICS] = 0;
1138 if (!send_pcb(dev, &adapter->tx_pcb))
1139 printk(KERN_ERR "%s: couldn't send get statistics command\n", dev->name);
1140 else {
1141 unsigned long timeout = jiffies + TIMEOUT;
1142 while (adapter->got[CMD_NETWORK_STATISTICS] == 0 && time_before(jiffies, timeout));
1143 if (time_after_eq(jiffies, timeout)) {
1144 TIMEOUT_MSG(__LINE__);
1145 return &adapter->stats;
1149 /* statistics are now up to date */
1150 return &adapter->stats;
1154 static void netdev_get_drvinfo(struct net_device *dev,
1155 struct ethtool_drvinfo *info)
1157 strcpy(info->driver, DRV_NAME);
1158 strcpy(info->version, DRV_VERSION);
1159 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1162 static u32 netdev_get_msglevel(struct net_device *dev)
1164 return debug;
1167 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1169 debug = level;
1172 static struct ethtool_ops netdev_ethtool_ops = {
1173 .get_drvinfo = netdev_get_drvinfo,
1174 .get_msglevel = netdev_get_msglevel,
1175 .set_msglevel = netdev_set_msglevel,
1176 };
1178 /******************************************************
1180 * close the board
1182 ******************************************************/
1184 static int elp_close(struct net_device *dev)
1186 elp_device *adapter;
1188 adapter = dev->priv;
1190 if (elp_debug >= 3)
1191 printk(KERN_DEBUG "%s: request to close device\n", dev->name);
1193 netif_stop_queue(dev);
1195 /* Someone may request the device statistic information even when
1196 * the interface is closed. The following will update the statistics
1197 * structure in the driver, so we'll be able to give current statistics.
1198 */
1199 (void) elp_get_stats(dev);
1201 /*
1202 * disable interrupts on the board
1203 */
1204 outb_control(0, dev);
1206 /*
1207 * release the IRQ
1208 */
1209 free_irq(dev->irq, dev);
1211 free_dma(dev->dma);
1212 free_pages((unsigned long) adapter->dma_buffer, get_order(DMA_BUFFER_SIZE));
1214 return 0;
1218 /************************************************************
1220 * Set multicast list
1221 * num_addrs==0: clear mc_list
1222 * num_addrs==-1: set promiscuous mode
1223 * num_addrs>0: set mc_list
1225 ************************************************************/
1227 static void elp_set_mc_list(struct net_device *dev)
1229 elp_device *adapter = (elp_device *) dev->priv;
1230 struct dev_mc_list *dmi = dev->mc_list;
1231 int i;
1232 unsigned long flags;
1234 if (elp_debug >= 3)
1235 printk(KERN_DEBUG "%s: request to set multicast list\n", dev->name);
1237 spin_lock_irqsave(&adapter->lock, flags);
1239 if (!(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1240 /* send a "load multicast list" command to the board, max 10 addrs/cmd */
1241 /* if num_addrs==0 the list will be cleared */
1242 adapter->tx_pcb.command = CMD_LOAD_MULTICAST_LIST;
1243 adapter->tx_pcb.length = 6 * dev->mc_count;
1244 for (i = 0; i < dev->mc_count; i++) {
1245 memcpy(adapter->tx_pcb.data.multicast[i], dmi->dmi_addr, 6);
1246 dmi = dmi->next;
1248 adapter->got[CMD_LOAD_MULTICAST_LIST] = 0;
1249 if (!send_pcb(dev, &adapter->tx_pcb))
1250 printk(KERN_ERR "%s: couldn't send set_multicast command\n", dev->name);
1251 else {
1252 unsigned long timeout = jiffies + TIMEOUT;
1253 while (adapter->got[CMD_LOAD_MULTICAST_LIST] == 0 && time_before(jiffies, timeout));
1254 if (time_after_eq(jiffies, timeout)) {
1255 TIMEOUT_MSG(__LINE__);
1258 if (dev->mc_count)
1259 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD | RECV_MULTI;
1260 else /* num_addrs == 0 */
1261 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
1262 } else
1263 adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_PROMISC;
1264 /*
1265 * configure adapter to receive messages (as specified above)
1266 * and wait for response
1267 */
1268 if (elp_debug >= 3)
1269 printk(KERN_DEBUG "%s: sending 82586 configure command\n", dev->name);
1270 adapter->tx_pcb.command = CMD_CONFIGURE_82586;
1271 adapter->tx_pcb.length = 2;
1272 adapter->got[CMD_CONFIGURE_82586] = 0;
1273 if (!send_pcb(dev, &adapter->tx_pcb))
1275 spin_unlock_irqrestore(&adapter->lock, flags);
1276 printk(KERN_ERR "%s: couldn't send 82586 configure command\n", dev->name);
1278 else {
1279 unsigned long timeout = jiffies + TIMEOUT;
1280 spin_unlock_irqrestore(&adapter->lock, flags);
1281 while (adapter->got[CMD_CONFIGURE_82586] == 0 && time_before(jiffies, timeout));
1282 if (time_after_eq(jiffies, timeout))
1283 TIMEOUT_MSG(__LINE__);
1287 /************************************************************
1289 * A couple of tests to see if there's 3C505 or not
1290 * Called only by elp_autodetect
1291 ************************************************************/
1293 static int __init elp_sense(struct net_device *dev)
1295 int addr = dev->base_addr;
1296 const char *name = dev->name;
1297 byte orig_HSR;
1299 if (!request_region(addr, ELP_IO_EXTENT, "3c505"))
1300 return -ENODEV;
1302 orig_HSR = inb_status(addr);
1304 if (elp_debug > 0)
1305 printk(search_msg, name, addr);
1307 if (orig_HSR == 0xff) {
1308 if (elp_debug > 0)
1309 printk(notfound_msg, 1);
1310 goto out;
1313 /* Wait for a while; the adapter may still be booting up */
1314 if (elp_debug > 0)
1315 printk(stilllooking_msg);
1317 if (orig_HSR & DIR) {
1318 /* If HCR.DIR is up, we pull it down. HSR.DIR should follow. */
1319 outb(0, dev->base_addr + PORT_CONTROL);
1320 msleep(300);
1321 if (inb_status(addr) & DIR) {
1322 if (elp_debug > 0)
1323 printk(notfound_msg, 2);
1324 goto out;
1326 } else {
1327 /* If HCR.DIR is down, we pull it up. HSR.DIR should follow. */
1328 outb(DIR, dev->base_addr + PORT_CONTROL);
1329 msleep(300);
1330 if (!(inb_status(addr) & DIR)) {
1331 if (elp_debug > 0)
1332 printk(notfound_msg, 3);
1333 goto out;
1336 /*
1337 * It certainly looks like a 3c505.
1338 */
1339 if (elp_debug > 0)
1340 printk(found_msg);
1342 return 0;
1343 out:
1344 release_region(addr, ELP_IO_EXTENT);
1345 return -ENODEV;
1348 /*************************************************************
1350 * Search through addr_list[] and try to find a 3C505
1351 * Called only by eplus_probe
1352 *************************************************************/
1354 static int __init elp_autodetect(struct net_device *dev)
1356 int idx = 0;
1358 /* if base address set, then only check that address
1359 otherwise, run through the table */
1360 if (dev->base_addr != 0) { /* dev->base_addr == 0 ==> plain autodetect */
1361 if (elp_sense(dev) == 0)
1362 return dev->base_addr;
1363 } else
1364 while ((dev->base_addr = addr_list[idx++])) {
1365 if (elp_sense(dev) == 0)
1366 return dev->base_addr;
1369 /* could not find an adapter */
1370 if (elp_debug > 0)
1371 printk(couldnot_msg, dev->name);
1373 return 0; /* Because of this, the layer above will return -ENODEV */
1377 /******************************************************
1379 * probe for an Etherlink Plus board at the specified address
1381 ******************************************************/
1383 /* There are three situations we need to be able to detect here:
1385 * a) the card is idle
1386 * b) the card is still booting up
1387 * c) the card is stuck in a strange state (some DOS drivers do this)
1389 * In case (a), all is well. In case (b), we wait 10 seconds to see if the
1390 * card finishes booting, and carry on if so. In case (c), we do a hard reset,
1391 * loop round, and hope for the best.
1393 * This is all very unpleasant, but hopefully avoids the problems with the old
1394 * probe code (which had a 15-second delay if the card was idle, and didn't
1395 * work at all if it was in a weird state).
1396 */
1398 static int __init elplus_setup(struct net_device *dev)
1400 elp_device *adapter = dev->priv;
1401 int i, tries, tries1, okay;
1402 unsigned long timeout;
1403 unsigned long cookie = 0;
1404 int err = -ENODEV;
1406 SET_MODULE_OWNER(dev);
1408 /*
1409 * setup adapter structure
1410 */
1412 dev->base_addr = elp_autodetect(dev);
1413 if (!dev->base_addr)
1414 return -ENODEV;
1416 adapter->send_pcb_semaphore = 0;
1418 for (tries1 = 0; tries1 < 3; tries1++) {
1419 outb_control((adapter->hcr_val | CMDE) & ~DIR, dev);
1420 /* First try to write just one byte, to see if the card is
1421 * responding at all normally.
1422 */
1423 timeout = jiffies + 5*HZ/100;
1424 okay = 0;
1425 while (time_before(jiffies, timeout) && !(inb_status(dev->base_addr) & HCRE));
1426 if ((inb_status(dev->base_addr) & HCRE)) {
1427 outb_command(0, dev->base_addr); /* send a spurious byte */
1428 timeout = jiffies + 5*HZ/100;
1429 while (time_before(jiffies, timeout) && !(inb_status(dev->base_addr) & HCRE));
1430 if (inb_status(dev->base_addr) & HCRE)
1431 okay = 1;
1433 if (!okay) {
1434 /* Nope, it's ignoring the command register. This means that
1435 * either it's still booting up, or it's died.
1436 */
1437 printk(KERN_ERR "%s: command register wouldn't drain, ", dev->name);
1438 if ((inb_status(dev->base_addr) & 7) == 3) {
1439 /* If the adapter status is 3, it *could* still be booting.
1440 * Give it the benefit of the doubt for 10 seconds.
1441 */
1442 printk("assuming 3c505 still starting\n");
1443 timeout = jiffies + 10*HZ;
1444 while (time_before(jiffies, timeout) && (inb_status(dev->base_addr) & 7));
1445 if (inb_status(dev->base_addr) & 7) {
1446 printk(KERN_ERR "%s: 3c505 failed to start\n", dev->name);
1447 } else {
1448 okay = 1; /* It started */
1450 } else {
1451 /* Otherwise, it must just be in a strange
1452 * state. We probably need to kick it.
1453 */
1454 printk("3c505 is sulking\n");
1457 for (tries = 0; tries < 5 && okay; tries++) {
1459 /*
1460 * Try to set the Ethernet address, to make sure that the board
1461 * is working.
1462 */
1463 adapter->tx_pcb.command = CMD_STATION_ADDRESS;
1464 adapter->tx_pcb.length = 0;
1465 cookie = probe_irq_on();
1466 if (!send_pcb(dev, &adapter->tx_pcb)) {
1467 printk(KERN_ERR "%s: could not send first PCB\n", dev->name);
1468 probe_irq_off(cookie);
1469 continue;
1471 if (!receive_pcb(dev, &adapter->rx_pcb)) {
1472 printk(KERN_ERR "%s: could not read first PCB\n", dev->name);
1473 probe_irq_off(cookie);
1474 continue;
1476 if ((adapter->rx_pcb.command != CMD_ADDRESS_RESPONSE) ||
1477 (adapter->rx_pcb.length != 6)) {
1478 printk(KERN_ERR "%s: first PCB wrong (%d, %d)\n", dev->name, adapter->rx_pcb.command, adapter->rx_pcb.length);
1479 probe_irq_off(cookie);
1480 continue;
1482 goto okay;
1484 /* It's broken. Do a hard reset to re-initialise the board,
1485 * and try again.
1486 */
1487 printk(KERN_INFO "%s: resetting adapter\n", dev->name);
1488 outb_control(adapter->hcr_val | FLSH | ATTN, dev);
1489 outb_control(adapter->hcr_val & ~(FLSH | ATTN), dev);
1491 printk(KERN_ERR "%s: failed to initialise 3c505\n", dev->name);
1492 goto out;
1494 okay:
1495 if (dev->irq) { /* Is there a preset IRQ? */
1496 int rpt = probe_irq_off(cookie);
1497 if (dev->irq != rpt) {
1498 printk(KERN_WARNING "%s: warning, irq %d configured but %d detected\n", dev->name, dev->irq, rpt);
1500 /* if dev->irq == probe_irq_off(cookie), all is well */
1501 } else /* No preset IRQ; just use what we can detect */
1502 dev->irq = probe_irq_off(cookie);
1503 switch (dev->irq) { /* Legal, sane? */
1504 case 0:
1505 printk(KERN_ERR "%s: IRQ probe failed: check 3c505 jumpers.\n",
1506 dev->name);
1507 goto out;
1508 case 1:
1509 case 6:
1510 case 8:
1511 case 13:
1512 printk(KERN_ERR "%s: Impossible IRQ %d reported by probe_irq_off().\n",
1513 dev->name, dev->irq);
1514 goto out;
1516 /*
1517 * Now we have the IRQ number so we can disable the interrupts from
1518 * the board until the board is opened.
1519 */
1520 outb_control(adapter->hcr_val & ~CMDE, dev);
1522 /*
1523 * copy Ethernet address into structure
1524 */
1525 for (i = 0; i < 6; i++)
1526 dev->dev_addr[i] = adapter->rx_pcb.data.eth_addr[i];
1528 /* find a DMA channel */
1529 if (!dev->dma) {
1530 if (dev->mem_start) {
1531 dev->dma = dev->mem_start & 7;
1533 else {
1534 printk(KERN_WARNING "%s: warning, DMA channel not specified, using default\n", dev->name);
1535 dev->dma = ELP_DMA;
1539 /*
1540 * print remainder of startup message
1541 */
1542 printk(KERN_INFO "%s: 3c505 at %#lx, irq %d, dma %d, ",
1543 dev->name, dev->base_addr, dev->irq, dev->dma);
1544 printk("addr %02x:%02x:%02x:%02x:%02x:%02x, ",
1545 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1546 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1548 /*
1549 * read more information from the adapter
1550 */
1552 adapter->tx_pcb.command = CMD_ADAPTER_INFO;
1553 adapter->tx_pcb.length = 0;
1554 if (!send_pcb(dev, &adapter->tx_pcb) ||
1555 !receive_pcb(dev, &adapter->rx_pcb) ||
1556 (adapter->rx_pcb.command != CMD_ADAPTER_INFO_RESPONSE) ||
1557 (adapter->rx_pcb.length != 10)) {
1558 printk("not responding to second PCB\n");
1560 printk("rev %d.%d, %dk\n", adapter->rx_pcb.data.info.major_vers, adapter->rx_pcb.data.info.minor_vers, adapter->rx_pcb.data.info.RAM_sz);
1562 /*
1563 * reconfigure the adapter memory to better suit our purposes
1564 */
1565 adapter->tx_pcb.command = CMD_CONFIGURE_ADAPTER_MEMORY;
1566 adapter->tx_pcb.length = 12;
1567 adapter->tx_pcb.data.memconf.cmd_q = 8;
1568 adapter->tx_pcb.data.memconf.rcv_q = 8;
1569 adapter->tx_pcb.data.memconf.mcast = 10;
1570 adapter->tx_pcb.data.memconf.frame = 10;
1571 adapter->tx_pcb.data.memconf.rcv_b = 10;
1572 adapter->tx_pcb.data.memconf.progs = 0;
1573 if (!send_pcb(dev, &adapter->tx_pcb) ||
1574 !receive_pcb(dev, &adapter->rx_pcb) ||
1575 (adapter->rx_pcb.command != CMD_CONFIGURE_ADAPTER_RESPONSE) ||
1576 (adapter->rx_pcb.length != 2)) {
1577 printk(KERN_ERR "%s: could not configure adapter memory\n", dev->name);
1579 if (adapter->rx_pcb.data.configure) {
1580 printk(KERN_ERR "%s: adapter configuration failed\n", dev->name);
1583 dev->open = elp_open; /* local */
1584 dev->stop = elp_close; /* local */
1585 dev->get_stats = elp_get_stats; /* local */
1586 dev->hard_start_xmit = elp_start_xmit; /* local */
1587 dev->tx_timeout = elp_timeout; /* local */
1588 dev->watchdog_timeo = 10*HZ;
1589 dev->set_multicast_list = elp_set_mc_list; /* local */
1590 dev->ethtool_ops = &netdev_ethtool_ops; /* local */
1592 memset(&(adapter->stats), 0, sizeof(struct net_device_stats));
1593 dev->mem_start = dev->mem_end = 0;
1595 err = register_netdev(dev);
1596 if (err)
1597 goto out;
1599 return 0;
1600 out:
1601 release_region(dev->base_addr, ELP_IO_EXTENT);
1602 return err;
1605 #ifndef MODULE
1606 struct net_device * __init elplus_probe(int unit)
1608 struct net_device *dev = alloc_etherdev(sizeof(elp_device));
1609 int err;
1610 if (!dev)
1611 return ERR_PTR(-ENOMEM);
1613 sprintf(dev->name, "eth%d", unit);
1614 netdev_boot_setup_check(dev);
1616 err = elplus_setup(dev);
1617 if (err) {
1618 free_netdev(dev);
1619 return ERR_PTR(err);
1621 return dev;
1624 #else
1625 static struct net_device *dev_3c505[ELP_MAX_CARDS];
1626 static int io[ELP_MAX_CARDS];
1627 static int irq[ELP_MAX_CARDS];
1628 static int dma[ELP_MAX_CARDS];
1629 module_param_array(io, int, NULL, 0);
1630 module_param_array(irq, int, NULL, 0);
1631 module_param_array(dma, int, NULL, 0);
1632 MODULE_PARM_DESC(io, "EtherLink Plus I/O base address(es)");
1633 MODULE_PARM_DESC(irq, "EtherLink Plus IRQ number(s) (assigned)");
1634 MODULE_PARM_DESC(dma, "EtherLink Plus DMA channel(s)");
1636 int __init init_module(void)
1638 int this_dev, found = 0;
1640 for (this_dev = 0; this_dev < ELP_MAX_CARDS; this_dev++) {
1641 struct net_device *dev = alloc_etherdev(sizeof(elp_device));
1642 if (!dev)
1643 break;
1645 dev->irq = irq[this_dev];
1646 dev->base_addr = io[this_dev];
1647 if (dma[this_dev]) {
1648 dev->dma = dma[this_dev];
1649 } else {
1650 dev->dma = ELP_DMA;
1651 printk(KERN_WARNING "3c505.c: warning, using default DMA channel,\n");
1653 if (io[this_dev] == 0) {
1654 if (this_dev) {
1655 free_netdev(dev);
1656 break;
1658 printk(KERN_NOTICE "3c505.c: module autoprobe not recommended, give io=xx.\n");
1660 if (elplus_setup(dev) != 0) {
1661 printk(KERN_WARNING "3c505.c: Failed to register card at 0x%x.\n", io[this_dev]);
1662 free_netdev(dev);
1663 break;
1665 dev_3c505[this_dev] = dev;
1666 found++;
1668 if (!found)
1669 return -ENODEV;
1670 return 0;
1673 void cleanup_module(void)
1675 int this_dev;
1677 for (this_dev = 0; this_dev < ELP_MAX_CARDS; this_dev++) {
1678 struct net_device *dev = dev_3c505[this_dev];
1679 if (dev) {
1680 unregister_netdev(dev);
1681 release_region(dev->base_addr, ELP_IO_EXTENT);
1682 free_netdev(dev);
1687 #endif /* MODULE */
1688 MODULE_LICENSE("GPL");