ia64/linux-2.6.18-xen.hg

view drivers/net/ibmlana.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 net-3-driver for the IBM LAN Adapter/A
4 This is an extension to the Linux operating system, and is covered by the
5 same GNU General Public License that covers that work.
7 Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de,
8 alfred.arnold@lancom.de)
10 This driver is based both on the SK_MCA driver, which is itself based on the
11 SK_G16 and 3C523 driver.
13 paper sources:
14 'PC Hardware: Aufbau, Funktionsweise, Programmierung' by
15 Hans-Peter Messmer for the basic Microchannel stuff
17 'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
18 for help on Ethernet driver programming
20 'DP83934CVUL-20/25 MHz SONIC-T Ethernet Controller Datasheet' by National
21 Semiconductor for info on the MAC chip
23 'LAN Technical Reference Ethernet Adapter Interface Version 1 Release 1.0
24 Document Number SC30-3661-00' by IBM for info on the adapter itself
26 Also see http://www.natsemi.com/
28 special acknowledgements to:
29 - Bob Eager for helping me out with documentation from IBM
30 - Jim Shorney for his endless patience with me while I was using
31 him as a beta tester to trace down the address filter bug ;-)
33 Missing things:
35 -> set debug level via ioctl instead of compile-time switches
36 -> I didn't follow the development of the 2.1.x kernels, so my
37 assumptions about which things changed with which kernel version
38 are probably nonsense
40 History:
41 Nov 6th, 1999
42 startup from SK_MCA driver
43 Dec 6th, 1999
44 finally got docs about the card. A big thank you to Bob Eager!
45 Dec 12th, 1999
46 first packet received
47 Dec 13th, 1999
48 recv queue done, tcpdump works
49 Dec 15th, 1999
50 transmission part works
51 Dec 28th, 1999
52 added usage of the isa_functions for Linux 2.3 . Things should
53 still work with 2.0.x....
54 Jan 28th, 2000
55 in Linux 2.2.13, the version.h file mysteriously didn't get
56 included. Added a workaround for this. Futhermore, it now
57 not only compiles as a modules ;-)
58 Jan 30th, 2000
59 newer kernels automatically probe more than one board, so the
60 'startslot' as a variable is also needed here
61 Apr 12th, 2000
62 the interrupt mask register is not set 'hard' instead of individually
63 setting registers, since this seems to set bits that shouldn't be
64 set
65 May 21st, 2000
66 reset interrupt status immediately after CAM load
67 add a recovery delay after releasing the chip's reset line
68 May 24th, 2000
69 finally found the bug in the address filter setup - damned signed
70 chars!
71 June 1st, 2000
72 corrected version codes, added support for the latest 2.3 changes
73 Oct 28th, 2002
74 cleaned up for the 2.5 tree <alan@redhat.com>
76 *************************************************************************/
78 #include <linux/kernel.h>
79 #include <linux/string.h>
80 #include <linux/errno.h>
81 #include <linux/ioport.h>
82 #include <linux/slab.h>
83 #include <linux/interrupt.h>
84 #include <linux/delay.h>
85 #include <linux/time.h>
86 #include <linux/mca-legacy.h>
87 #include <linux/module.h>
88 #include <linux/netdevice.h>
89 #include <linux/etherdevice.h>
90 #include <linux/skbuff.h>
91 #include <linux/bitops.h>
93 #include <asm/processor.h>
94 #include <asm/io.h>
96 #define _IBM_LANA_DRIVER_
97 #include "ibmlana.h"
99 #undef DEBUG
101 #define DRV_NAME "ibmlana"
103 /* ------------------------------------------------------------------------
104 * global static data - not more since we can handle multiple boards and
105 * have to pack all state info into the device struct!
106 * ------------------------------------------------------------------------ */
108 static char *MediaNames[Media_Count] = {
109 "10BaseT", "10Base5", "Unknown", "10Base2"
110 };
112 /* ------------------------------------------------------------------------
113 * private subfunctions
114 * ------------------------------------------------------------------------ */
116 #ifdef DEBUG
117 /* dump all registers */
119 static void dumpregs(struct net_device *dev)
120 {
121 int z;
123 for (z = 0; z < 160; z += 2) {
124 if (!(z & 15))
125 printk("REGS: %04x:", z);
126 printk(" %04x", inw(dev->base_addr + z));
127 if ((z & 15) == 14)
128 printk("\n");
129 }
130 }
132 /* dump parts of shared memory - only needed during debugging */
134 static void dumpmem(struct net_device *dev, u32 start, u32 len)
135 {
136 ibmlana_priv *priv = netdev_priv(dev);
137 int z;
139 printk("Address %04x:\n", start);
140 for (z = 0; z < len; z++) {
141 if ((z & 15) == 0)
142 printk("%04x:", z);
143 printk(" %02x", readb(priv->base + start + z));
144 if ((z & 15) == 15)
145 printk("\n");
146 }
147 if ((z & 15) != 0)
148 printk("\n");
149 }
151 /* print exact time - ditto */
153 static void PrTime(void)
154 {
155 struct timeval tv;
157 do_gettimeofday(&tv);
158 printk("%9d:%06d: ", (int) tv.tv_sec, (int) tv.tv_usec);
159 }
160 #endif /* DEBUG */
162 /* deduce resources out of POS registers */
164 static void getaddrs(int slot, int *base, int *memlen, int *iobase,
165 int *irq, ibmlana_medium * medium)
166 {
167 u_char pos0, pos1;
169 pos0 = mca_read_stored_pos(slot, 2);
170 pos1 = mca_read_stored_pos(slot, 3);
172 *base = 0xc0000 + ((pos1 & 0xf0) << 9);
173 *memlen = (pos1 & 0x01) ? 0x8000 : 0x4000;
174 *iobase = (pos0 & 0xe0) << 7;
175 switch (pos0 & 0x06) {
176 case 0:
177 *irq = 5;
178 break;
179 case 2:
180 *irq = 15;
181 break;
182 case 4:
183 *irq = 10;
184 break;
185 case 6:
186 *irq = 11;
187 break;
188 }
189 *medium = (pos0 & 0x18) >> 3;
190 }
192 /* wait on register value with mask and timeout */
194 static int wait_timeout(struct net_device *dev, int regoffs, u16 mask,
195 u16 value, int timeout)
196 {
197 unsigned long fin = jiffies + timeout;
199 while (time_before(jiffies,fin))
200 if ((inw(dev->base_addr + regoffs) & mask) == value)
201 return 1;
203 return 0;
204 }
207 /* reset the whole board */
209 static void ResetBoard(struct net_device *dev)
210 {
211 unsigned char bcmval;
213 /* read original board control value */
215 bcmval = inb(dev->base_addr + BCMREG);
217 /* set reset bit for a while */
219 bcmval |= BCMREG_RESET;
220 outb(bcmval, dev->base_addr + BCMREG);
221 udelay(10);
222 bcmval &= ~BCMREG_RESET;
223 outb(bcmval, dev->base_addr + BCMREG);
225 /* switch over to RAM again */
227 bcmval |= BCMREG_RAMEN | BCMREG_RAMWIN;
228 outb(bcmval, dev->base_addr + BCMREG);
229 }
231 /* calculate RAM layout & set up descriptors in RAM */
233 static void InitDscrs(struct net_device *dev)
234 {
235 ibmlana_priv *priv = netdev_priv(dev);
236 u32 addr, baddr, raddr;
237 int z;
238 tda_t tda;
239 rda_t rda;
240 rra_t rra;
242 /* initialize RAM */
244 memset_io(priv->base, 0xaa,
245 dev->mem_start - dev->mem_start); /* XXX: typo? */
247 /* setup n TX descriptors - independent of RAM size */
249 priv->tdastart = addr = 0;
250 priv->txbufstart = baddr = sizeof(tda_t) * TXBUFCNT;
251 for (z = 0; z < TXBUFCNT; z++) {
252 tda.status = 0;
253 tda.config = 0;
254 tda.length = 0;
255 tda.fragcount = 1;
256 tda.startlo = baddr;
257 tda.starthi = 0;
258 tda.fraglength = 0;
259 if (z == TXBUFCNT - 1)
260 tda.link = priv->tdastart;
261 else
262 tda.link = addr + sizeof(tda_t);
263 tda.link |= 1;
264 memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
265 addr += sizeof(tda_t);
266 baddr += PKTSIZE;
267 }
269 /* calculate how many receive buffers fit into remaining memory */
271 priv->rxbufcnt = (dev->mem_end - dev->mem_start - baddr) / (sizeof(rra_t) + sizeof(rda_t) + PKTSIZE);
273 /* calculate receive addresses */
275 priv->rrastart = raddr = priv->txbufstart + (TXBUFCNT * PKTSIZE);
276 priv->rdastart = addr = priv->rrastart + (priv->rxbufcnt * sizeof(rra_t));
277 priv->rxbufstart = baddr = priv->rdastart + (priv->rxbufcnt * sizeof(rda_t));
279 for (z = 0; z < priv->rxbufcnt; z++) {
280 rra.startlo = baddr;
281 rra.starthi = 0;
282 rra.cntlo = PKTSIZE >> 1;
283 rra.cnthi = 0;
284 memcpy_toio(priv->base + raddr, &rra, sizeof(rra_t));
286 rda.status = 0;
287 rda.length = 0;
288 rda.startlo = 0;
289 rda.starthi = 0;
290 rda.seqno = 0;
291 if (z < priv->rxbufcnt - 1)
292 rda.link = addr + sizeof(rda_t);
293 else
294 rda.link = 1;
295 rda.inuse = 1;
296 memcpy_toio(priv->base + addr, &rda, sizeof(rda_t));
298 baddr += PKTSIZE;
299 raddr += sizeof(rra_t);
300 addr += sizeof(rda_t);
301 }
303 /* initialize current pointers */
305 priv->nextrxdescr = 0;
306 priv->lastrxdescr = priv->rxbufcnt - 1;
307 priv->nexttxdescr = 0;
308 priv->currtxdescr = 0;
309 priv->txusedcnt = 0;
310 memset(priv->txused, 0, sizeof(priv->txused));
311 }
313 /* set up Rx + Tx descriptors in SONIC */
315 static int InitSONIC(struct net_device *dev)
316 {
317 ibmlana_priv *priv = netdev_priv(dev);
319 /* set up start & end of resource area */
321 outw(0, SONIC_URRA);
322 outw(priv->rrastart, dev->base_addr + SONIC_RSA);
323 outw(priv->rrastart + (priv->rxbufcnt * sizeof(rra_t)), dev->base_addr + SONIC_REA);
324 outw(priv->rrastart, dev->base_addr + SONIC_RRP);
325 outw(priv->rrastart, dev->base_addr + SONIC_RWP);
327 /* set EOBC so that only one packet goes into one buffer */
329 outw((PKTSIZE - 4) >> 1, dev->base_addr + SONIC_EOBC);
331 /* let SONIC read the first RRA descriptor */
333 outw(CMDREG_RRRA, dev->base_addr + SONIC_CMDREG);
334 if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_RRRA, 0, 2)) {
335 printk(KERN_ERR "%s: SONIC did not respond on RRRA command - giving up.", dev->name);
336 return 0;
337 }
339 /* point SONIC to the first RDA */
341 outw(0, dev->base_addr + SONIC_URDA);
342 outw(priv->rdastart, dev->base_addr + SONIC_CRDA);
344 /* set upper half of TDA address */
346 outw(0, dev->base_addr + SONIC_UTDA);
348 return 1;
349 }
351 /* stop SONIC so we can reinitialize it */
353 static void StopSONIC(struct net_device *dev)
354 {
355 /* disable interrupts */
357 outb(inb(dev->base_addr + BCMREG) & (~BCMREG_IEN), dev->base_addr + BCMREG);
358 outb(0, dev->base_addr + SONIC_IMREG);
360 /* reset the SONIC */
362 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
363 udelay(10);
364 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
365 }
367 /* initialize card and SONIC for proper operation */
369 static void putcam(camentry_t * cams, int *camcnt, char *addr)
370 {
371 camentry_t *pcam = cams + (*camcnt);
372 u8 *uaddr = (u8 *) addr;
374 pcam->index = *camcnt;
375 pcam->addr0 = (((u16) uaddr[1]) << 8) | uaddr[0];
376 pcam->addr1 = (((u16) uaddr[3]) << 8) | uaddr[2];
377 pcam->addr2 = (((u16) uaddr[5]) << 8) | uaddr[4];
378 (*camcnt)++;
379 }
381 static void InitBoard(struct net_device *dev)
382 {
383 ibmlana_priv *priv = netdev_priv(dev);
384 int camcnt;
385 camentry_t cams[16];
386 u32 cammask;
387 struct dev_mc_list *mcptr;
388 u16 rcrval;
390 /* reset the SONIC */
392 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
393 udelay(10);
395 /* clear all spurious interrupts */
397 outw(inw(dev->base_addr + SONIC_ISREG), dev->base_addr + SONIC_ISREG);
399 /* set up the SONIC's bus interface - constant for this adapter -
400 must be done while the SONIC is in reset */
402 outw(DCREG_USR1 | DCREG_USR0 | DCREG_WC1 | DCREG_DW32, dev->base_addr + SONIC_DCREG);
403 outw(0, dev->base_addr + SONIC_DCREG2);
405 /* remove reset form the SONIC */
407 outw(0, dev->base_addr + SONIC_CMDREG);
408 udelay(10);
410 /* data sheet requires URRA to be programmed before setting up the CAM contents */
412 outw(0, dev->base_addr + SONIC_URRA);
414 /* program the CAM entry 0 to the device address */
416 camcnt = 0;
417 putcam(cams, &camcnt, dev->dev_addr);
419 /* start putting the multicast addresses into the CAM list. Stop if
420 it is full. */
422 for (mcptr = dev->mc_list; mcptr != NULL; mcptr = mcptr->next) {
423 putcam(cams, &camcnt, mcptr->dmi_addr);
424 if (camcnt == 16)
425 break;
426 }
428 /* calculate CAM mask */
430 cammask = (1 << camcnt) - 1;
432 /* feed CDA into SONIC, initialize RCR value (always get broadcasts) */
434 memcpy_toio(priv->base, cams, sizeof(camentry_t) * camcnt);
435 memcpy_toio(priv->base + (sizeof(camentry_t) * camcnt), &cammask, sizeof(cammask));
437 #ifdef DEBUG
438 printk("CAM setup:\n");
439 dumpmem(dev, 0, sizeof(camentry_t) * camcnt + sizeof(cammask));
440 #endif
442 outw(0, dev->base_addr + SONIC_CAMPTR);
443 outw(camcnt, dev->base_addr + SONIC_CAMCNT);
444 outw(CMDREG_LCAM, dev->base_addr + SONIC_CMDREG);
445 if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_LCAM, 0, 2)) {
446 printk(KERN_ERR "%s:SONIC did not respond on LCAM command - giving up.", dev->name);
447 return;
448 } else {
449 /* clear interrupt condition */
451 outw(ISREG_LCD, dev->base_addr + SONIC_ISREG);
453 #ifdef DEBUG
454 printk("Loading CAM done, address pointers %04x:%04x\n",
455 inw(dev->base_addr + SONIC_URRA),
456 inw(dev->base_addr + SONIC_CAMPTR));
457 {
458 int z;
460 printk("\n-->CAM: PTR %04x CNT %04x\n",
461 inw(dev->base_addr + SONIC_CAMPTR),
462 inw(dev->base_addr + SONIC_CAMCNT));
463 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
464 for (z = 0; z < camcnt; z++) {
465 outw(z, dev->base_addr + SONIC_CAMEPTR);
466 printk("Entry %d: %04x %04x %04x\n", z,
467 inw(dev->base_addr + SONIC_CAMADDR0),
468 inw(dev->base_addr + SONIC_CAMADDR1),
469 inw(dev->base_addr + SONIC_CAMADDR2));
470 }
471 outw(0, dev->base_addr + SONIC_CMDREG);
472 }
473 #endif
474 }
476 rcrval = RCREG_BRD | RCREG_LB_NONE;
478 /* if still multicast addresses left or ALLMULTI is set, set the multicast
479 enable bit */
481 if ((dev->flags & IFF_ALLMULTI) || (mcptr != NULL))
482 rcrval |= RCREG_AMC;
484 /* promiscous mode ? */
486 if (dev->flags & IFF_PROMISC)
487 rcrval |= RCREG_PRO;
489 /* program receive mode */
491 outw(rcrval, dev->base_addr + SONIC_RCREG);
492 #ifdef DEBUG
493 printk("\nRCRVAL: %04x\n", rcrval);
494 #endif
496 /* set up descriptors in shared memory + feed them into SONIC registers */
498 InitDscrs(dev);
499 if (!InitSONIC(dev))
500 return;
502 /* reset all pending interrupts */
504 outw(0xffff, dev->base_addr + SONIC_ISREG);
506 /* enable transmitter + receiver interrupts */
508 outw(CMDREG_RXEN, dev->base_addr + SONIC_CMDREG);
509 outw(IMREG_PRXEN | IMREG_RBEEN | IMREG_PTXEN | IMREG_TXEREN, dev->base_addr + SONIC_IMREG);
511 /* turn on card interrupts */
513 outb(inb(dev->base_addr + BCMREG) | BCMREG_IEN, dev->base_addr + BCMREG);
515 #ifdef DEBUG
516 printk("Register dump after initialization:\n");
517 dumpregs(dev);
518 #endif
519 }
521 /* start transmission of a descriptor */
523 static void StartTx(struct net_device *dev, int descr)
524 {
525 ibmlana_priv *priv = netdev_priv(dev);
526 int addr;
528 addr = priv->tdastart + (descr * sizeof(tda_t));
530 /* put descriptor address into SONIC */
532 outw(addr, dev->base_addr + SONIC_CTDA);
534 /* trigger transmitter */
536 priv->currtxdescr = descr;
537 outw(CMDREG_TXP, dev->base_addr + SONIC_CMDREG);
538 }
540 /* ------------------------------------------------------------------------
541 * interrupt handler(s)
542 * ------------------------------------------------------------------------ */
544 /* receive buffer area exhausted */
546 static void irqrbe_handler(struct net_device *dev)
547 {
548 ibmlana_priv *priv = netdev_priv(dev);
550 /* point the SONIC back to the RRA start */
552 outw(priv->rrastart, dev->base_addr + SONIC_RRP);
553 outw(priv->rrastart, dev->base_addr + SONIC_RWP);
554 }
556 /* receive interrupt */
558 static void irqrx_handler(struct net_device *dev)
559 {
560 ibmlana_priv *priv = netdev_priv(dev);
561 rda_t rda;
562 u32 rdaaddr, lrdaaddr;
564 /* loop until ... */
566 while (1) {
567 /* read descriptor that was next to be filled by SONIC */
569 rdaaddr = priv->rdastart + (priv->nextrxdescr * sizeof(rda_t));
570 lrdaaddr = priv->rdastart + (priv->lastrxdescr * sizeof(rda_t));
571 memcpy_fromio(&rda, priv->base + rdaaddr, sizeof(rda_t));
573 /* iron out upper word halves of fields we use - SONIC will duplicate
574 bits 0..15 to 16..31 */
576 rda.status &= 0xffff;
577 rda.length &= 0xffff;
578 rda.startlo &= 0xffff;
580 /* stop if the SONIC still owns it, i.e. there is no data for us */
582 if (rda.inuse)
583 break;
585 /* good packet? */
587 else if (rda.status & RCREG_PRX) {
588 struct sk_buff *skb;
590 /* fetch buffer */
592 skb = dev_alloc_skb(rda.length + 2);
593 if (skb == NULL)
594 priv->stat.rx_dropped++;
595 else {
596 /* copy out data */
598 memcpy_fromio(skb_put(skb, rda.length),
599 priv->base +
600 rda.startlo, rda.length);
602 /* set up skb fields */
604 skb->dev = dev;
605 skb->protocol = eth_type_trans(skb, dev);
606 skb->ip_summed = CHECKSUM_NONE;
608 /* bookkeeping */
609 dev->last_rx = jiffies;
610 priv->stat.rx_packets++;
611 priv->stat.rx_bytes += rda.length;
613 /* pass to the upper layers */
614 netif_rx(skb);
615 }
616 }
618 /* otherwise check error status bits and increase statistics */
620 else {
621 priv->stat.rx_errors++;
622 if (rda.status & RCREG_FAER)
623 priv->stat.rx_frame_errors++;
624 if (rda.status & RCREG_CRCR)
625 priv->stat.rx_crc_errors++;
626 }
628 /* descriptor processed, will become new last descriptor in queue */
630 rda.link = 1;
631 rda.inuse = 1;
632 memcpy_toio(priv->base + rdaaddr, &rda,
633 sizeof(rda_t));
635 /* set up link and EOL = 0 in currently last descriptor. Only write
636 the link field since the SONIC may currently already access the
637 other fields. */
639 memcpy_toio(priv->base + lrdaaddr + 20, &rdaaddr, 4);
641 /* advance indices */
643 priv->lastrxdescr = priv->nextrxdescr;
644 if ((++priv->nextrxdescr) >= priv->rxbufcnt)
645 priv->nextrxdescr = 0;
646 }
647 }
649 /* transmit interrupt */
651 static void irqtx_handler(struct net_device *dev)
652 {
653 ibmlana_priv *priv = netdev_priv(dev);
654 tda_t tda;
656 /* fetch descriptor (we forgot the size ;-) */
657 memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
659 /* update statistics */
660 priv->stat.tx_packets++;
661 priv->stat.tx_bytes += tda.length;
663 /* update our pointers */
664 priv->txused[priv->currtxdescr] = 0;
665 priv->txusedcnt--;
667 /* if there are more descriptors present in RAM, start them */
668 if (priv->txusedcnt > 0)
669 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
671 /* tell the upper layer we can go on transmitting */
672 netif_wake_queue(dev);
673 }
675 static void irqtxerr_handler(struct net_device *dev)
676 {
677 ibmlana_priv *priv = netdev_priv(dev);
678 tda_t tda;
680 /* fetch descriptor to check status */
681 memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
683 /* update statistics */
684 priv->stat.tx_errors++;
685 if (tda.status & (TCREG_NCRS | TCREG_CRSL))
686 priv->stat.tx_carrier_errors++;
687 if (tda.status & TCREG_EXC)
688 priv->stat.tx_aborted_errors++;
689 if (tda.status & TCREG_OWC)
690 priv->stat.tx_window_errors++;
691 if (tda.status & TCREG_FU)
692 priv->stat.tx_fifo_errors++;
694 /* update our pointers */
695 priv->txused[priv->currtxdescr] = 0;
696 priv->txusedcnt--;
698 /* if there are more descriptors present in RAM, start them */
699 if (priv->txusedcnt > 0)
700 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
702 /* tell the upper layer we can go on transmitting */
703 netif_wake_queue(dev);
704 }
706 /* general interrupt entry */
708 static irqreturn_t irq_handler(int irq, void *device, struct pt_regs *regs)
709 {
710 struct net_device *dev = (struct net_device *) device;
711 u16 ival;
713 /* in case we're not meant... */
714 if (!(inb(dev->base_addr + BCMREG) & BCMREG_IPEND))
715 return IRQ_NONE;
717 /* loop through the interrupt bits until everything is clear */
718 while (1) {
719 ival = inw(dev->base_addr + SONIC_ISREG);
721 if (ival & ISREG_RBE) {
722 irqrbe_handler(dev);
723 outw(ISREG_RBE, dev->base_addr + SONIC_ISREG);
724 }
725 if (ival & ISREG_PKTRX) {
726 irqrx_handler(dev);
727 outw(ISREG_PKTRX, dev->base_addr + SONIC_ISREG);
728 }
729 if (ival & ISREG_TXDN) {
730 irqtx_handler(dev);
731 outw(ISREG_TXDN, dev->base_addr + SONIC_ISREG);
732 }
733 if (ival & ISREG_TXER) {
734 irqtxerr_handler(dev);
735 outw(ISREG_TXER, dev->base_addr + SONIC_ISREG);
736 }
737 break;
738 }
739 return IRQ_HANDLED;
740 }
742 /* ------------------------------------------------------------------------
743 * driver methods
744 * ------------------------------------------------------------------------ */
746 /* MCA info */
748 static int ibmlana_getinfo(char *buf, int slot, void *d)
749 {
750 int len = 0, i;
751 struct net_device *dev = (struct net_device *) d;
752 ibmlana_priv *priv;
754 /* can't say anything about an uninitialized device... */
756 if (dev == NULL)
757 return len;
758 priv = netdev_priv(dev);
760 /* print info */
762 len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
763 len += sprintf(buf + len, "I/O: %#lx\n", dev->base_addr);
764 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start, dev->mem_end - 1);
765 len += sprintf(buf + len, "Transceiver: %s\n", MediaNames[priv->medium]);
766 len += sprintf(buf + len, "Device: %s\n", dev->name);
767 len += sprintf(buf + len, "MAC address:");
768 for (i = 0; i < 6; i++)
769 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
770 buf[len++] = '\n';
771 buf[len] = 0;
773 return len;
774 }
776 /* open driver. Means also initialization and start of LANCE */
778 static int ibmlana_open(struct net_device *dev)
779 {
780 int result;
781 ibmlana_priv *priv = netdev_priv(dev);
783 /* register resources - only necessary for IRQ */
785 result = request_irq(priv->realirq, irq_handler, IRQF_SHARED | IRQF_SAMPLE_RANDOM, dev->name, dev);
786 if (result != 0) {
787 printk(KERN_ERR "%s: failed to register irq %d\n", dev->name, dev->irq);
788 return result;
789 }
790 dev->irq = priv->realirq;
792 /* set up the card and SONIC */
793 InitBoard(dev);
795 /* initialize operational flags */
796 netif_start_queue(dev);
797 return 0;
798 }
800 /* close driver. Shut down board and free allocated resources */
802 static int ibmlana_close(struct net_device *dev)
803 {
804 /* turn off board */
806 /* release resources */
807 if (dev->irq != 0)
808 free_irq(dev->irq, dev);
809 dev->irq = 0;
810 return 0;
811 }
813 /* transmit a block. */
815 static int ibmlana_tx(struct sk_buff *skb, struct net_device *dev)
816 {
817 ibmlana_priv *priv = netdev_priv(dev);
818 int retval = 0, tmplen, addr;
819 unsigned long flags;
820 tda_t tda;
821 int baddr;
823 /* find out if there are free slots for a frame to transmit. If not,
824 the upper layer is in deep desperation and we simply ignore the frame. */
826 if (priv->txusedcnt >= TXBUFCNT) {
827 retval = -EIO;
828 priv->stat.tx_dropped++;
829 goto tx_done;
830 }
832 /* copy the frame data into the next free transmit buffer - fillup missing */
833 tmplen = skb->len;
834 if (tmplen < 60)
835 tmplen = 60;
836 baddr = priv->txbufstart + (priv->nexttxdescr * PKTSIZE);
837 memcpy_toio(priv->base + baddr, skb->data, skb->len);
839 /* copy filler into RAM - in case we're filling up...
840 we're filling a bit more than necessary, but that doesn't harm
841 since the buffer is far larger...
842 Sorry Linus for the filler string but I couldn't resist ;-) */
844 if (tmplen > skb->len) {
845 char *fill = "NetBSD is a nice OS too! ";
846 unsigned int destoffs = skb->len, l = strlen(fill);
848 while (destoffs < tmplen) {
849 memcpy_toio(priv->base + baddr + destoffs, fill, l);
850 destoffs += l;
851 }
852 }
854 /* set up the new frame descriptor */
855 addr = priv->tdastart + (priv->nexttxdescr * sizeof(tda_t));
856 memcpy_fromio(&tda, priv->base + addr, sizeof(tda_t));
857 tda.length = tda.fraglength = tmplen;
858 memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
860 /* if there were no active descriptors, trigger the SONIC */
861 spin_lock_irqsave(&priv->lock, flags);
863 priv->txusedcnt++;
864 priv->txused[priv->nexttxdescr] = 1;
866 /* are all transmission slots used up ? */
867 if (priv->txusedcnt >= TXBUFCNT)
868 netif_stop_queue(dev);
870 if (priv->txusedcnt == 1)
871 StartTx(dev, priv->nexttxdescr);
872 priv->nexttxdescr = (priv->nexttxdescr + 1) % TXBUFCNT;
874 spin_unlock_irqrestore(&priv->lock, flags);
875 tx_done:
876 dev_kfree_skb(skb);
877 return retval;
878 }
880 /* return pointer to Ethernet statistics */
882 static struct net_device_stats *ibmlana_stats(struct net_device *dev)
883 {
884 ibmlana_priv *priv = netdev_priv(dev);
885 return &priv->stat;
886 }
888 /* switch receiver mode. */
890 static void ibmlana_set_multicast_list(struct net_device *dev)
891 {
892 /* first stop the SONIC... */
893 StopSONIC(dev);
894 /* ...then reinit it with the new flags */
895 InitBoard(dev);
896 }
898 /* ------------------------------------------------------------------------
899 * hardware check
900 * ------------------------------------------------------------------------ */
902 static int startslot; /* counts through slots when probing multiple devices */
904 static int ibmlana_probe(struct net_device *dev)
905 {
906 int slot, z;
907 int base = 0, irq = 0, iobase = 0, memlen = 0;
908 ibmlana_priv *priv;
909 ibmlana_medium medium;
911 SET_MODULE_OWNER(dev);
913 /* can't work without an MCA bus ;-) */
914 if (MCA_bus == 0)
915 return -ENODEV;
917 base = dev->mem_start;
918 irq = dev->irq;
920 for (slot = startslot; (slot = mca_find_adapter(IBM_LANA_ID, slot)) != -1; slot++) {
921 /* deduce card addresses */
922 getaddrs(slot, &base, &memlen, &iobase, &irq, &medium);
924 /* slot already in use ? */
925 if (mca_is_adapter_used(slot))
926 continue;
927 /* were we looking for something different ? */
928 if (dev->irq && dev->irq != irq)
929 continue;
930 if (dev->mem_start && dev->mem_start != base)
931 continue;
932 /* found something that matches */
933 break;
934 }
936 /* nothing found ? */
937 if (slot == -1)
938 return (base != 0 || irq != 0) ? -ENXIO : -ENODEV;
940 /* announce success */
941 printk(KERN_INFO "%s: IBM LAN Adapter/A found in slot %d\n", dev->name, slot + 1);
943 /* try to obtain I/O range */
944 if (!request_region(iobase, IBM_LANA_IORANGE, DRV_NAME)) {
945 printk(KERN_ERR "%s: cannot allocate I/O range at %#x!\n", DRV_NAME, iobase);
946 startslot = slot + 1;
947 return -EBUSY;
948 }
950 priv = netdev_priv(dev);
951 priv->slot = slot;
952 priv->realirq = irq;
953 priv->medium = medium;
954 spin_lock_init(&priv->lock);
957 /* set base + irq for this device (irq not allocated so far) */
959 dev->irq = 0;
960 dev->mem_start = base;
961 dev->mem_end = base + memlen;
962 dev->base_addr = iobase;
964 priv->base = ioremap(base, memlen);
965 if (!priv->base) {
966 printk(KERN_ERR "%s: cannot remap memory!\n", DRV_NAME);
967 startslot = slot + 1;
968 release_region(iobase, IBM_LANA_IORANGE);
969 return -EBUSY;
970 }
972 /* make procfs entries */
973 mca_set_adapter_name(slot, "IBM LAN Adapter/A");
974 mca_set_adapter_procfn(slot, (MCA_ProcFn) ibmlana_getinfo, dev);
976 mca_mark_as_used(slot);
978 /* set methods */
980 dev->open = ibmlana_open;
981 dev->stop = ibmlana_close;
982 dev->hard_start_xmit = ibmlana_tx;
983 dev->do_ioctl = NULL;
984 dev->get_stats = ibmlana_stats;
985 dev->set_multicast_list = ibmlana_set_multicast_list;
986 dev->flags |= IFF_MULTICAST;
988 /* copy out MAC address */
990 for (z = 0; z < sizeof(dev->dev_addr); z++)
991 dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
993 /* print config */
995 printk(KERN_INFO "%s: IRQ %d, I/O %#lx, memory %#lx-%#lx, "
996 "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
997 dev->name, priv->realirq, dev->base_addr,
998 dev->mem_start, dev->mem_end - 1,
999 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1000 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1001 printk(KERN_INFO "%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1003 /* reset board */
1005 ResetBoard(dev);
1007 /* next probe will start at next slot */
1009 startslot = slot + 1;
1011 return 0;
1014 /* ------------------------------------------------------------------------
1015 * modularization support
1016 * ------------------------------------------------------------------------ */
1018 #ifdef MODULE
1020 #define DEVMAX 5
1022 static struct net_device *moddevs[DEVMAX];
1023 static int irq;
1024 static int io;
1026 module_param(irq, int, 0);
1027 module_param(io, int, 0);
1028 MODULE_PARM_DESC(irq, "IBM LAN/A IRQ number");
1029 MODULE_PARM_DESC(io, "IBM LAN/A I/O base address");
1030 MODULE_LICENSE("GPL");
1032 int init_module(void)
1034 int z;
1036 startslot = 0;
1037 for (z = 0; z < DEVMAX; z++) {
1038 struct net_device *dev = alloc_etherdev(sizeof(ibmlana_priv));
1039 if (!dev)
1040 break;
1041 dev->irq = irq;
1042 dev->base_addr = io;
1043 if (ibmlana_probe(dev)) {
1044 free_netdev(dev);
1045 break;
1047 if (register_netdev(dev)) {
1048 ibmlana_priv *priv = netdev_priv(dev);
1049 release_region(dev->base_addr, IBM_LANA_IORANGE);
1050 mca_mark_as_unused(priv->slot);
1051 mca_set_adapter_name(priv->slot, "");
1052 mca_set_adapter_procfn(priv->slot, NULL, NULL);
1053 iounmap(priv->base);
1054 free_netdev(dev);
1055 break;
1057 moddevs[z] = dev;
1059 return (z > 0) ? 0 : -EIO;
1062 void cleanup_module(void)
1064 int z;
1065 for (z = 0; z < DEVMAX; z++) {
1066 struct net_device *dev = moddevs[z];
1067 if (dev) {
1068 ibmlana_priv *priv = netdev_priv(dev);
1069 unregister_netdev(dev);
1070 /*DeinitBoard(dev); */
1071 release_region(dev->base_addr, IBM_LANA_IORANGE);
1072 mca_mark_as_unused(priv->slot);
1073 mca_set_adapter_name(priv->slot, "");
1074 mca_set_adapter_procfn(priv->slot, NULL, NULL);
1075 iounmap(priv->base);
1076 free_netdev(dev);
1080 #endif /* MODULE */