File: /usr/src/linux/drivers/net/ibmlana.c
1 /*
2 net-3-driver for the IBM LAN Adapter/A
3
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.
6
7 Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de, aarnold@elsa.de)
8
9 This driver is based both on the SK_MCA driver, which is itself based on the
10 SK_G16 and 3C523 driver.
11
12 paper sources:
13 'PC Hardware: Aufbau, Funktionsweise, Programmierung' by
14 Hans-Peter Messmer for the basic Microchannel stuff
15
16 'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
17 for help on Ethernet driver programming
18
19 'DP83934CVUL-20/25 MHz SONIC-T Ethernet Controller Datasheet' by National
20 Semiconductor for info on the MAC chip
21
22 'LAN Technical Reference Ethernet Adapter Interface Version 1 Release 1.0
23 Document Number SC30-3661-00' by IBM for info on the adapter itself
24
25 Also see http://www.natsemi.com/
26
27 special acknowledgements to:
28 - Bob Eager for helping me out with documentation from IBM
29 - Jim Shorney for his endless patience with me while I was using
30 him as a beta tester to trace down the address filter bug ;-)
31
32 Missing things:
33
34 -> set debug level via ioctl instead of compile-time switches
35 -> I didn't follow the development of the 2.1.x kernels, so my
36 assumptions about which things changed with which kernel version
37 are probably nonsense
38
39 History:
40 Nov 6th, 1999
41 startup from SK_MCA driver
42 Dec 6th, 1999
43 finally got docs about the card. A big thank you to Bob Eager!
44 Dec 12th, 1999
45 first packet received
46 Dec 13th, 1999
47 recv queue done, tcpdump works
48 Dec 15th, 1999
49 transmission part works
50 Dec 28th, 1999
51 added usage of the isa_functions for Linux 2.3 . Things should
52 still work with 2.0.x....
53 Jan 28th, 2000
54 in Linux 2.2.13, the version.h file mysteriously didn't get
55 included. Added a workaround for this. Futhermore, it now
56 not only compiles as a modules ;-)
57 Jan 30th, 2000
58 newer kernels automatically probe more than one board, so the
59 'startslot' as a variable is also needed here
60 Apr 12th, 2000
61 the interrupt mask register is not set 'hard' instead of individually
62 setting registers, since this seems to set bits that shouldn't be
63 set
64 May 21st, 2000
65 reset interrupt status immediately after CAM load
66 add a recovery delay after releasing the chip's reset line
67 May 24th, 2000
68 finally found the bug in the address filter setup - damned signed
69 chars!
70 June 1st, 2000
71 corrected version codes, added support for the latest 2.3 changes
72
73 *************************************************************************/
74
75 #include <linux/version.h>
76 #include <linux/kernel.h>
77 #include <linux/sched.h>
78 #include <linux/string.h>
79 #include <linux/errno.h>
80 #include <linux/ioport.h>
81 #include <linux/slab.h>
82 #include <linux/interrupt.h>
83 #include <linux/delay.h>
84 #include <linux/time.h>
85 #include <linux/mca.h>
86 #include <asm/processor.h>
87 #include <asm/bitops.h>
88 #include <asm/io.h>
89
90 #include <linux/module.h>
91
92 #include <linux/netdevice.h>
93 #include <linux/etherdevice.h>
94 #include <linux/skbuff.h>
95
96 #define _IBM_LANA_DRIVER_
97 #include "ibmlana.h"
98
99 #undef DEBUG
100
101 /* ------------------------------------------------------------------------
102 * global static data - not more since we can handle multiple boards and
103 * have to pack all state info into the device struct!
104 * ------------------------------------------------------------------------ */
105
106 static char *MediaNames[Media_Count] =
107 { "10BaseT", "10Base5", "Unknown", "10Base2" };
108
109 /* ------------------------------------------------------------------------
110 * private subfunctions
111 * ------------------------------------------------------------------------ */
112
113 #ifdef DEBUG
114 /* dump all registers */
115
116 static void dumpregs(struct IBMLANA_NETDEV *dev)
117 {
118 int z;
119
120 for (z = 0; z < 160; z += 2) {
121 if (!(z & 15))
122 printk("REGS: %04x:", z);
123 printk(" %04x", inw(dev->base_addr + z));
124 if ((z & 15) == 14)
125 printk("\n");
126 }
127 }
128
129 /* dump parts of shared memory - only needed during debugging */
130
131 static void dumpmem(struct IBMLANA_NETDEV *dev, u32 start, u32 len)
132 {
133 int z;
134
135 printk("Address %04x:\n", start);
136 for (z = 0; z < len; z++) {
137 if ((z & 15) == 0)
138 printk("%04x:", z);
139 printk(" %02x", IBMLANA_READB(dev->mem_start + start + z));
140 if ((z & 15) == 15)
141 printk("\n");
142 }
143 if ((z & 15) != 0)
144 printk("\n");
145 }
146
147 /* print exact time - ditto */
148
149 static void PrTime(void)
150 {
151 struct timeval tv;
152
153 do_gettimeofday(&tv);
154 printk("%9d:%06d: ", (int) tv.tv_sec, (int) tv.tv_usec);
155 }
156 #endif /* DEBUG */
157
158 /* deduce resources out of POS registers */
159
160 static void getaddrs(int slot, int *base, int *memlen, int *iobase,
161 int *irq, ibmlana_medium * medium)
162 {
163 u_char pos0, pos1;
164
165 pos0 = mca_read_stored_pos(slot, 2);
166 pos1 = mca_read_stored_pos(slot, 3);
167
168 *base = 0xc0000 + ((pos1 & 0xf0) << 9);
169 *memlen = (pos1 & 0x01) ? 0x8000 : 0x4000;
170 *iobase = (pos0 & 0xe0) << 7;
171 switch (pos0 & 0x06) {
172 case 0:
173 *irq = 5;
174 break;
175 case 2:
176 *irq = 15;
177 break;
178 case 4:
179 *irq = 10;
180 break;
181 case 6:
182 *irq = 11;
183 break;
184 }
185 *medium = (pos0 & 0x18) >> 3;
186 }
187
188 /* wait on register value with mask and timeout */
189
190 static int wait_timeout(struct IBMLANA_NETDEV *dev, int regoffs, u16 mask,
191 u16 value, int timeout)
192 {
193 unsigned long fin = jiffies + timeout;
194
195 while (jiffies != fin)
196 if ((inw(dev->base_addr + regoffs) & mask) == value)
197 return 1;
198
199 return 0;
200 }
201
202
203 /* reset the whole board */
204
205 static void ResetBoard(struct IBMLANA_NETDEV *dev)
206 {
207 unsigned char bcmval;
208
209 /* read original board control value */
210
211 bcmval = inb(dev->base_addr + BCMREG);
212
213 /* set reset bit for a while */
214
215 bcmval |= BCMREG_RESET;
216 outb(bcmval, dev->base_addr + BCMREG);
217 udelay(10);
218 bcmval &= ~BCMREG_RESET;
219 outb(bcmval, dev->base_addr + BCMREG);
220
221 /* switch over to RAM again */
222
223 bcmval |= BCMREG_RAMEN | BCMREG_RAMWIN;
224 outb(bcmval, dev->base_addr + BCMREG);
225 }
226
227 /* calculate RAM layout & set up descriptors in RAM */
228
229 static void InitDscrs(struct IBMLANA_NETDEV *dev)
230 {
231 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
232 u32 addr, baddr, raddr;
233 int z;
234 tda_t tda;
235 rda_t rda;
236 rra_t rra;
237
238 /* initialize RAM */
239
240 IBMLANA_SETIO(dev->mem_start, 0xaa,
241 dev->mem_start - dev->mem_start);
242
243 /* setup n TX descriptors - independent of RAM size */
244
245 priv->tdastart = addr = 0;
246 priv->txbufstart = baddr = sizeof(tda_t) * TXBUFCNT;
247 for (z = 0; z < TXBUFCNT; z++) {
248 tda.status = 0;
249 tda.config = 0;
250 tda.length = 0;
251 tda.fragcount = 1;
252 tda.startlo = baddr;
253 tda.starthi = 0;
254 tda.fraglength = 0;
255 if (z == TXBUFCNT - 1)
256 tda.link = priv->tdastart;
257 else
258 tda.link = addr + sizeof(tda_t);
259 tda.link |= 1;
260 IBMLANA_TOIO(dev->mem_start + addr, &tda, sizeof(tda_t));
261 addr += sizeof(tda_t);
262 baddr += PKTSIZE;
263 }
264
265 /* calculate how many receive buffers fit into remaining memory */
266
267 priv->rxbufcnt = (dev->mem_end - dev->mem_start - baddr) /
268 (sizeof(rra_t) + sizeof(rda_t) + PKTSIZE);
269
270 /* calculate receive addresses */
271
272 priv->rrastart = raddr = priv->txbufstart + (TXBUFCNT * PKTSIZE);
273 priv->rdastart = addr =
274 priv->rrastart + (priv->rxbufcnt * sizeof(rra_t));
275 priv->rxbufstart = baddr =
276 priv->rdastart + (priv->rxbufcnt * sizeof(rda_t));
277 for (z = 0; z < priv->rxbufcnt; z++) {
278 rra.startlo = baddr;
279 rra.starthi = 0;
280 rra.cntlo = PKTSIZE >> 1;
281 rra.cnthi = 0;
282 IBMLANA_TOIO(dev->mem_start + raddr, &rra, sizeof(rra_t));
283
284 rda.status = 0;
285 rda.length = 0;
286 rda.startlo = 0;
287 rda.starthi = 0;
288 rda.seqno = 0;
289 if (z < priv->rxbufcnt - 1)
290 rda.link = addr + sizeof(rda_t);
291 else
292 rda.link = 1;
293 rda.inuse = 1;
294 IBMLANA_TOIO(dev->mem_start + addr, &rda, sizeof(rda_t));
295
296 baddr += PKTSIZE;
297 raddr += sizeof(rra_t);
298 addr += sizeof(rda_t);
299 }
300
301 /* initialize current pointers */
302
303 priv->nextrxdescr = 0;
304 priv->lastrxdescr = priv->rxbufcnt - 1;
305 priv->nexttxdescr = 0;
306 priv->currtxdescr = 0;
307 priv->txusedcnt = 0;
308 memset(priv->txused, 0, sizeof(priv->txused));
309 }
310
311 /* set up Rx + Tx descriptors in SONIC */
312
313 static int InitSONIC(struct IBMLANA_NETDEV *dev)
314 {
315 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
316
317 /* set up start & end of resource area */
318
319 outw(0, SONIC_URRA);
320 outw(priv->rrastart, dev->base_addr + SONIC_RSA);
321 outw(priv->rrastart + (priv->rxbufcnt * sizeof(rra_t)),
322 dev->base_addr + SONIC_REA);
323 outw(priv->rrastart, dev->base_addr + SONIC_RRP);
324 outw(priv->rrastart, dev->base_addr + SONIC_RWP);
325
326 /* set EOBC so that only one packet goes into one buffer */
327
328 outw((PKTSIZE - 4) >> 1, dev->base_addr + SONIC_EOBC);
329
330 /* let SONIC read the first RRA descriptor */
331
332 outw(CMDREG_RRRA, dev->base_addr + SONIC_CMDREG);
333 if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_RRRA, 0, 2)) {
334 printk
335 ("%s: SONIC did not respond on RRRA command - giving up.",
336 dev->name);
337 return 0;
338 }
339
340 /* point SONIC to the first RDA */
341
342 outw(0, dev->base_addr + SONIC_URDA);
343 outw(priv->rdastart, dev->base_addr + SONIC_CRDA);
344
345 /* set upper half of TDA address */
346
347 outw(0, dev->base_addr + SONIC_UTDA);
348
349 return 1;
350 }
351
352 /* stop SONIC so we can reinitialize it */
353
354 static void StopSONIC(struct IBMLANA_NETDEV *dev)
355 {
356 /* disable interrupts */
357
358 outb(inb(dev->base_addr + BCMREG) & (~BCMREG_IEN),
359 dev->base_addr + BCMREG);
360 outb(0, dev->base_addr + SONIC_IMREG);
361
362 /* reset the SONIC */
363
364 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
365 udelay(10);
366 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
367 }
368
369 /* initialize card and SONIC for proper operation */
370
371 static void putcam(camentry_t * cams, int *camcnt, char *addr)
372 {
373 camentry_t *pcam = cams + (*camcnt);
374 u8 *uaddr = (u8 *) addr;
375
376 pcam->index = *camcnt;
377 pcam->addr0 = (((u16) uaddr[1]) << 8) | uaddr[0];
378 pcam->addr1 = (((u16) uaddr[3]) << 8) | uaddr[2];
379 pcam->addr2 = (((u16) uaddr[5]) << 8) | uaddr[4];
380 (*camcnt)++;
381 }
382
383 static void InitBoard(struct IBMLANA_NETDEV *dev)
384 {
385 int camcnt;
386 camentry_t cams[16];
387 u32 cammask;
388 struct dev_mc_list *mcptr;
389 u16 rcrval;
390
391 /* reset the SONIC */
392
393 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
394 udelay(10);
395
396 /* clear all spurious interrupts */
397
398 outw(inw(dev->base_addr + SONIC_ISREG),
399 dev->base_addr + SONIC_ISREG);
400
401 /* set up the SONIC's bus interface - constant for this adapter -
402 must be done while the SONIC is in reset */
403
404 outw(DCREG_USR1 | DCREG_USR0 | DCREG_WC1 | DCREG_DW32,
405 dev->base_addr + SONIC_DCREG);
406 outw(0, dev->base_addr + SONIC_DCREG2);
407
408 /* remove reset form the SONIC */
409
410 outw(0, dev->base_addr + SONIC_CMDREG);
411 udelay(10);
412
413 /* data sheet requires URRA to be programmed before setting up the CAM contents */
414
415 outw(0, dev->base_addr + SONIC_URRA);
416
417 /* program the CAM entry 0 to the device address */
418
419 camcnt = 0;
420 putcam(cams, &camcnt, dev->dev_addr);
421
422 /* start putting the multicast addresses into the CAM list. Stop if
423 it is full. */
424
425 for (mcptr = dev->mc_list; mcptr != NULL; mcptr = mcptr->next) {
426 putcam(cams, &camcnt, mcptr->dmi_addr);
427 if (camcnt == 16)
428 break;
429 }
430
431 /* calculate CAM mask */
432
433 cammask = (1 << camcnt) - 1;
434
435 /* feed CDA into SONIC, initialize RCR value (always get broadcasts) */
436
437 IBMLANA_TOIO(dev->mem_start, cams, sizeof(camentry_t) * camcnt);
438 IBMLANA_TOIO(dev->mem_start + (sizeof(camentry_t) * camcnt),
439 &cammask, sizeof(cammask));
440
441 #ifdef DEBUG
442 printk("CAM setup:\n");
443 dumpmem(dev, 0, sizeof(camentry_t) * camcnt + sizeof(cammask));
444 #endif
445
446 outw(0, dev->base_addr + SONIC_CAMPTR);
447 outw(camcnt, dev->base_addr + SONIC_CAMCNT);
448 outw(CMDREG_LCAM, dev->base_addr + SONIC_CMDREG);
449 if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_LCAM, 0, 2)) {
450 printk
451 ("%s:SONIC did not respond on LCAM command - giving up.",
452 dev->name);
453 return;
454 } else {
455 /* clear interrupt condition */
456
457 outw(ISREG_LCD, dev->base_addr + SONIC_ISREG);
458
459 #ifdef DEBUG
460 printk("Loading CAM done, address pointers %04x:%04x\n",
461 inw(dev->base_addr + SONIC_URRA),
462 inw(dev->base_addr + SONIC_CAMPTR));
463 {
464 int z;
465
466 printk("\n-->CAM: PTR %04x CNT %04x\n",
467 inw(dev->base_addr + SONIC_CAMPTR),
468 inw(dev->base_addr + SONIC_CAMCNT));
469 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
470 for (z = 0; z < camcnt; z++) {
471 outw(z, dev->base_addr + SONIC_CAMEPTR);
472 printk("Entry %d: %04x %04x %04x\n", z,
473 inw(dev->base_addr +
474 SONIC_CAMADDR0),
475 inw(dev->base_addr +
476 SONIC_CAMADDR1),
477 inw(dev->base_addr +
478 SONIC_CAMADDR2));
479 }
480 outw(0, dev->base_addr + SONIC_CMDREG);
481 }
482 #endif
483 }
484
485 rcrval = RCREG_BRD | RCREG_LB_NONE;
486
487 /* if still multicast addresses left or ALLMULTI is set, set the multicast
488 enable bit */
489
490 if ((dev->flags & IFF_ALLMULTI) || (mcptr != NULL))
491 rcrval |= RCREG_AMC;
492
493 /* promiscous mode ? */
494
495 if (dev->flags & IFF_PROMISC)
496 rcrval |= RCREG_PRO;
497
498 /* program receive mode */
499
500 outw(rcrval, dev->base_addr + SONIC_RCREG);
501 #ifdef DEBUG
502 printk("\nRCRVAL: %04x\n", rcrval);
503 #endif
504
505 /* set up descriptors in shared memory + feed them into SONIC registers */
506
507 InitDscrs(dev);
508 if (!InitSONIC(dev))
509 return;
510
511 /* reset all pending interrupts */
512
513 outw(0xffff, dev->base_addr + SONIC_ISREG);
514
515 /* enable transmitter + receiver interrupts */
516
517 outw(CMDREG_RXEN, dev->base_addr + SONIC_CMDREG);
518 outw(IMREG_PRXEN | IMREG_RBEEN | IMREG_PTXEN | IMREG_TXEREN,
519 dev->base_addr + SONIC_IMREG);
520
521 /* turn on card interrupts */
522
523 outb(inb(dev->base_addr + BCMREG) | BCMREG_IEN,
524 dev->base_addr + BCMREG);
525
526 #ifdef DEBUG
527 printk("Register dump after initialization:\n");
528 dumpregs(dev);
529 #endif
530 }
531
532 /* start transmission of a descriptor */
533
534 static void StartTx(struct IBMLANA_NETDEV *dev, int descr)
535 {
536 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
537 int addr;
538
539 addr = priv->tdastart + (descr * sizeof(tda_t));
540
541 /* put descriptor address into SONIC */
542
543 outw(addr, dev->base_addr + SONIC_CTDA);
544
545 /* trigger transmitter */
546
547 priv->currtxdescr = descr;
548 outw(CMDREG_TXP, dev->base_addr + SONIC_CMDREG);
549 }
550
551 /* ------------------------------------------------------------------------
552 * interrupt handler(s)
553 * ------------------------------------------------------------------------ */
554
555 /* receive buffer area exhausted */
556
557 static void irqrbe_handler(struct IBMLANA_NETDEV *dev)
558 {
559 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
560
561 /* point the SONIC back to the RRA start */
562
563 outw(priv->rrastart, dev->base_addr + SONIC_RRP);
564 outw(priv->rrastart, dev->base_addr + SONIC_RWP);
565 }
566
567 /* receive interrupt */
568
569 static void irqrx_handler(struct IBMLANA_NETDEV *dev)
570 {
571 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
572 rda_t rda;
573 u32 rdaaddr, lrdaaddr;
574
575 /* loop until ... */
576
577 while (1) {
578 /* read descriptor that was next to be filled by SONIC */
579
580 rdaaddr =
581 priv->rdastart + (priv->nextrxdescr * sizeof(rda_t));
582 lrdaaddr =
583 priv->rdastart + (priv->lastrxdescr * sizeof(rda_t));
584 IBMLANA_FROMIO(&rda, dev->mem_start + rdaaddr,
585 sizeof(rda_t));
586
587 /* iron out upper word halves of fields we use - SONIC will duplicate
588 bits 0..15 to 16..31 */
589
590 rda.status &= 0xffff;
591 rda.length &= 0xffff;
592 rda.startlo &= 0xffff;
593
594 /* stop if the SONIC still owns it, i.e. there is no data for us */
595
596 if (rda.inuse)
597 break;
598
599 /* good packet? */
600
601 else if (rda.status & RCREG_PRX) {
602 struct sk_buff *skb;
603
604 /* fetch buffer */
605
606 skb = dev_alloc_skb(rda.length + 2);
607 if (skb == NULL)
608 priv->stat.rx_dropped++;
609 else {
610 /* copy out data */
611
612 IBMLANA_FROMIO(skb_put(skb, rda.length),
613 dev->mem_start +
614 rda.startlo, rda.length);
615
616 /* set up skb fields */
617
618 skb->dev = dev;
619 skb->protocol = eth_type_trans(skb, dev);
620 skb->ip_summed = CHECKSUM_NONE;
621
622 /* bookkeeping */
623
624 dev->last_rx = jiffies;
625 priv->stat.rx_packets++;
626 #if (LINUX_VERSION_CODE >= 0x20119) /* byte counters for kernel >= 2.1.25 */
627 priv->stat.rx_bytes += rda.length;
628 #endif
629
630 /* pass to the upper layers */
631
632 netif_rx(skb);
633 }
634 }
635
636 /* otherwise check error status bits and increase statistics */
637
638 else {
639 priv->stat.rx_errors++;
640
641 if (rda.status & RCREG_FAER)
642 priv->stat.rx_frame_errors++;
643
644 if (rda.status & RCREG_CRCR)
645 priv->stat.rx_crc_errors++;
646 }
647
648 /* descriptor processed, will become new last descriptor in queue */
649
650 rda.link = 1;
651 rda.inuse = 1;
652 IBMLANA_TOIO(dev->mem_start + rdaaddr, &rda,
653 sizeof(rda_t));
654
655 /* set up link and EOL = 0 in currently last descriptor. Only write
656 the link field since the SONIC may currently already access the
657 other fields. */
658
659 IBMLANA_TOIO(dev->mem_start + lrdaaddr + 20, &rdaaddr, 4);
660
661 /* advance indices */
662
663 priv->lastrxdescr = priv->nextrxdescr;
664 if ((++priv->nextrxdescr) >= priv->rxbufcnt)
665 priv->nextrxdescr = 0;
666 }
667 }
668
669 /* transmit interrupt */
670
671 static void irqtx_handler(struct IBMLANA_NETDEV *dev)
672 {
673 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
674 tda_t tda;
675
676 /* fetch descriptor (we forgot the size ;-) */
677
678 IBMLANA_FROMIO(&tda,
679 dev->mem_start + priv->tdastart +
680 (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
681
682 /* update statistics */
683
684 priv->stat.tx_packets++;
685 #if (LINUX_VERSION_CODE >= 0x020119)
686 priv->stat.tx_bytes += tda.length;
687 #endif
688
689 /* update our pointers */
690
691 priv->txused[priv->currtxdescr] = 0;
692 priv->txusedcnt--;
693
694 /* if there are more descriptors present in RAM, start them */
695
696 if (priv->txusedcnt > 0)
697 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
698
699 /* tell the upper layer we can go on transmitting */
700
701 #if LINUX_VERSION_CODE >= 0x02032a
702 netif_wake_queue(dev);
703 #else
704 dev->tbusy = 0;
705 mark_bh(NET_BH);
706 #endif
707 }
708
709 static void irqtxerr_handler(struct IBMLANA_NETDEV *dev)
710 {
711 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
712 tda_t tda;
713
714 /* fetch descriptor to check status */
715
716 IBMLANA_FROMIO(&tda,
717 dev->mem_start + priv->tdastart +
718 (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
719
720 /* update statistics */
721
722 priv->stat.tx_errors++;
723 if (tda.status & (TCREG_NCRS | TCREG_CRSL))
724 priv->stat.tx_carrier_errors++;
725 if (tda.status & TCREG_EXC)
726 priv->stat.tx_aborted_errors++;
727 if (tda.status & TCREG_OWC)
728 priv->stat.tx_window_errors++;
729 if (tda.status & TCREG_FU)
730 priv->stat.tx_fifo_errors++;
731
732 /* update our pointers */
733
734 priv->txused[priv->currtxdescr] = 0;
735 priv->txusedcnt--;
736
737 /* if there are more descriptors present in RAM, start them */
738
739 if (priv->txusedcnt > 0)
740 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
741
742 /* tell the upper layer we can go on transmitting */
743
744 #if LINUX_VERSION_CODE >= 0x02032a
745 netif_wake_queue(dev);
746 #else
747 dev->tbusy = 0;
748 mark_bh(NET_BH);
749 #endif
750 }
751
752 /* general interrupt entry */
753
754 static void irq_handler(int irq, void *device, struct pt_regs *regs)
755 {
756 struct IBMLANA_NETDEV *dev = (struct IBMLANA_NETDEV *) device;
757 u16 ival;
758
759 /* in case we're not meant... */
760
761 if (!(inb(dev->base_addr + BCMREG) & BCMREG_IPEND))
762 return;
763
764 #if (LINUX_VERSION_CODE >= 0x02032a)
765 #if 0
766 set_bit(LINK_STATE_RXSEM, &dev->state);
767 #endif
768 #else
769 dev->interrupt = 1;
770 #endif
771
772 /* loop through the interrupt bits until everything is clear */
773
774 while (1) {
775 ival = inw(dev->base_addr + SONIC_ISREG);
776
777 if (ival & ISREG_RBE) {
778 irqrbe_handler(dev);
779 outw(ISREG_RBE, dev->base_addr + SONIC_ISREG);
780 }
781
782 if (ival & ISREG_PKTRX) {
783 irqrx_handler(dev);
784 outw(ISREG_PKTRX, dev->base_addr + SONIC_ISREG);
785 }
786
787 if (ival & ISREG_TXDN) {
788 irqtx_handler(dev);
789 outw(ISREG_TXDN, dev->base_addr + SONIC_ISREG);
790 }
791
792 if (ival & ISREG_TXER) {
793 irqtxerr_handler(dev);
794 outw(ISREG_TXER, dev->base_addr + SONIC_ISREG);
795 }
796
797 break;
798 }
799
800 #if (LINUX_VERSION_CODE >= 0x02032a)
801 #if 0
802 clear_bit(LINK_STATE_RXSEM, &dev->state);
803 #endif
804 #else
805 dev->interrupt = 0;
806 #endif
807 }
808
809 /* ------------------------------------------------------------------------
810 * driver methods
811 * ------------------------------------------------------------------------ */
812
813 /* MCA info */
814
815 static int ibmlana_getinfo(char *buf, int slot, void *d)
816 {
817 int len = 0, i;
818 struct IBMLANA_NETDEV *dev = (struct IBMLANA_NETDEV *) d;
819 ibmlana_priv *priv;
820
821 /* can't say anything about an uninitialized device... */
822
823 if (dev == NULL)
824 return len;
825 if (dev->priv == NULL)
826 return len;
827 priv = (ibmlana_priv *) dev->priv;
828
829 /* print info */
830
831 len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
832 len += sprintf(buf + len, "I/O: %#lx\n", dev->base_addr);
833 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
834 dev->mem_end - 1);
835 len +=
836 sprintf(buf + len, "Transceiver: %s\n",
837 MediaNames[priv->medium]);
838 len += sprintf(buf + len, "Device: %s\n", dev->name);
839 len += sprintf(buf + len, "MAC address:");
840 for (i = 0; i < 6; i++)
841 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
842 buf[len++] = '\n';
843 buf[len] = 0;
844
845 return len;
846 }
847
848 /* open driver. Means also initialization and start of LANCE */
849
850 static int ibmlana_open(struct IBMLANA_NETDEV *dev)
851 {
852 int result;
853 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
854
855 /* register resources - only necessary for IRQ */
856
857 result =
858 request_irq(priv->realirq, irq_handler,
859 SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
860 if (result != 0) {
861 printk("%s: failed to register irq %d\n", dev->name,
862 dev->irq);
863 return result;
864 }
865 dev->irq = priv->realirq;
866
867 /* set up the card and SONIC */
868
869 InitBoard(dev);
870
871 /* initialize operational flags */
872
873 #if (LINUX_VERSION_CODE >= 0x02032a)
874 netif_start_queue(dev);
875 #else
876 dev->interrupt = 0;
877 dev->tbusy = 0;
878 dev->start = 1;
879 MOD_INC_USE_COUNT;
880 #endif
881
882 return 0;
883 }
884
885 /* close driver. Shut down board and free allocated resources */
886
887 static int ibmlana_close(struct IBMLANA_NETDEV *dev)
888 {
889 /* turn off board */
890
891 /* release resources */
892 if (dev->irq != 0)
893 free_irq(dev->irq, dev);
894 dev->irq = 0;
895
896 #if (LINUX_VERSION_CODE < 0x02032a)
897 MOD_DEC_USE_COUNT;
898 #endif
899
900 return 0;
901 }
902
903 /* transmit a block. */
904
905 static int ibmlana_tx(struct sk_buff *skb, struct IBMLANA_NETDEV *dev)
906 {
907 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
908 int retval = 0, tmplen, addr;
909 unsigned long flags;
910 tda_t tda;
911 int baddr;
912
913 /* if we get called with a NULL descriptor, the Ethernet layer thinks
914 our card is stuck an we should reset it. We'll do this completely: */
915
916 if (skb == NULL) {
917 printk("%s: Resetting SONIC\n", dev->name);
918 StopSONIC(dev);
919 InitBoard(dev);
920 return 0; /* don't try to free the block here ;-) */
921 }
922
923 /* find out if there are free slots for a frame to transmit. If not,
924 the upper layer is in deep desperation and we simply ignore the frame. */
925
926 if (priv->txusedcnt >= TXBUFCNT) {
927 retval = -EIO;
928 priv->stat.tx_dropped++;
929 goto tx_done;
930 }
931
932 /* copy the frame data into the next free transmit buffer - fillup missing */
933
934 tmplen = skb->len;
935 if (tmplen < 60)
936 tmplen = 60;
937 baddr = priv->txbufstart + (priv->nexttxdescr * PKTSIZE);
938 IBMLANA_TOIO(dev->mem_start + baddr, skb->data, skb->len);
939
940 /* copy filler into RAM - in case we're filling up...
941 we're filling a bit more than necessary, but that doesn't harm
942 since the buffer is far larger...
943 Sorry Linus for the filler string but I couldn't resist ;-) */
944
945 if (tmplen > skb->len) {
946 char *fill = "NetBSD is a nice OS too! ";
947 unsigned int destoffs = skb->len, l = strlen(fill);
948
949 while (destoffs < tmplen) {
950 IBMLANA_TOIO(dev->mem_start + baddr + destoffs,
951 fill, l);
952 destoffs += l;
953 }
954 }
955
956 /* set up the new frame descriptor */
957
958 addr = priv->tdastart + (priv->nexttxdescr * sizeof(tda_t));
959 IBMLANA_FROMIO(&tda, dev->mem_start + addr, sizeof(tda_t));
960 tda.length = tda.fraglength = tmplen;
961 IBMLANA_TOIO(dev->mem_start + addr, &tda, sizeof(tda_t));
962
963 /* if there were no active descriptors, trigger the SONIC */
964
965 save_flags(flags);
966 cli();
967
968 priv->txusedcnt++;
969 priv->txused[priv->nexttxdescr] = 1;
970
971 /* are all transmission slots used up ? */
972
973 if (priv->txusedcnt >= TXBUFCNT)
974 #if (LINUX_VERSION_CODE >= 0x02032a)
975 netif_stop_queue(dev);
976 #else
977 dev->tbusy = 1;
978 #endif
979
980 if (priv->txusedcnt == 1)
981 StartTx(dev, priv->nexttxdescr);
982 priv->nexttxdescr = (priv->nexttxdescr + 1) % TXBUFCNT;
983
984 restore_flags(flags);
985
986 tx_done:
987
988 /* When did that change exactly ? */
989
990 #if (LINUX_VERSION_CODE >= 0x20200)
991 dev_kfree_skb(skb);
992 #else
993 dev_kfree_skb(skb, FREE_WRITE);
994 #endif
995 return retval;
996 }
997
998 /* return pointer to Ethernet statistics */
999
1000 static struct net_device_stats *ibmlana_stats(struct IBMLANA_NETDEV *dev)
1001 {
1002 ibmlana_priv *priv = (ibmlana_priv *) dev->priv;
1003
1004 return &(priv->stat);
1005 }
1006
1007 /* we don't support runtime reconfiguration, since am MCA card can
1008 be unambigously identified by its POS registers. */
1009
1010 static int ibmlana_config(struct IBMLANA_NETDEV *dev, struct ifmap *map)
1011 {
1012 return 0;
1013 }
1014
1015 /* switch receiver mode. */
1016
1017 static void ibmlana_set_multicast_list(struct IBMLANA_NETDEV *dev)
1018 {
1019 /* first stop the SONIC... */
1020
1021 StopSONIC(dev);
1022
1023 /* ...then reinit it with the new flags */
1024
1025 InitBoard(dev);
1026 }
1027
1028 /* ------------------------------------------------------------------------
1029 * hardware check
1030 * ------------------------------------------------------------------------ */
1031
1032 static int startslot; /* counts through slots when probing multiple devices */
1033
1034 int ibmlana_probe(struct IBMLANA_NETDEV *dev)
1035 {
1036 int force_detect = 0;
1037 int slot, z;
1038 int base = 0, irq = 0, iobase = 0, memlen = 0;
1039 ibmlana_priv *priv;
1040 ibmlana_medium medium;
1041
1042 #if (LINUX_VERSION_CODE >= 0x02032a)
1043 SET_MODULE_OWNER(dev);
1044 #endif
1045
1046 /* can't work without an MCA bus ;-) */
1047
1048 if (MCA_bus == 0)
1049 return -ENODEV;
1050
1051 /* start address of 1 --> forced detection */
1052
1053 if (dev->mem_start == 1)
1054 force_detect = 1;
1055
1056 /* search through slots */
1057
1058 if (dev != NULL) {
1059 base = dev->mem_start;
1060 irq = dev->irq;
1061 }
1062 slot = mca_find_adapter(IBM_LANA_ID, startslot);
1063
1064 while (slot != -1) {
1065 /* deduce card addresses */
1066
1067 getaddrs(slot, &base, &memlen, &iobase, &irq, &medium);
1068
1069 #if (LINUX_VERSION_CODE >= 0x20300)
1070 /* slot already in use ? */
1071
1072 if (mca_is_adapter_used(slot)) {
1073 slot = mca_find_adapter(IBM_LANA_ID, slot + 1);
1074 continue;
1075 }
1076 #endif
1077
1078 /* were we looking for something different ? */
1079
1080 if ((dev->irq != 0) || (dev->mem_start != 0)) {
1081 if ((dev->irq != 0) && (dev->irq != irq)) {
1082 slot =
1083 mca_find_adapter(IBM_LANA_ID,
1084 slot + 1);
1085 continue;
1086 }
1087 if ((dev->mem_start != 0)
1088 && (dev->mem_start != base)) {
1089 slot =
1090 mca_find_adapter(IBM_LANA_ID,
1091 slot + 1);
1092 continue;
1093 }
1094 }
1095
1096 /* found something that matches */
1097
1098 break;
1099 }
1100
1101 /* nothing found ? */
1102
1103 if (slot == -1)
1104 return ((base != 0) || (irq != 0)) ? -ENXIO : -ENODEV;
1105
1106 /* announce success */
1107 printk("%s: IBM LAN Adapter/A found in slot %d\n", dev->name,
1108 slot + 1);
1109
1110 /* try to obtain I/O range */
1111 if (!request_region(iobase, IBM_LANA_IORANGE, dev->name)) {
1112 printk("%s: cannot allocate I/O range at %#x!\n", dev->name, iobase);
1113 startslot = slot + 1;
1114 return -EBUSY;
1115 }
1116
1117 /* make procfs entries */
1118
1119 mca_set_adapter_name(slot, "IBM LAN Adapter/A");
1120 mca_set_adapter_procfn(slot, (MCA_ProcFn) ibmlana_getinfo, dev);
1121
1122 #if (LINUX_VERSION_CODE >= 0x20200)
1123 mca_mark_as_used(slot);
1124 #endif
1125
1126 /* allocate structure */
1127
1128 priv = dev->priv =
1129 (ibmlana_priv *) kmalloc(sizeof(ibmlana_priv), GFP_KERNEL);
1130 if (!priv) {
1131 release_region(iobase, IBM_LANA_IORANGE);
1132 return -ENOMEM;
1133 }
1134 priv->slot = slot;
1135 priv->realirq = irq;
1136 priv->medium = medium;
1137 memset(&(priv->stat), 0, sizeof(struct net_device_stats));
1138
1139 /* set base + irq for this device (irq not allocated so far) */
1140
1141 dev->irq = 0;
1142 dev->mem_start = base;
1143 dev->mem_end = base + memlen;
1144 dev->base_addr = iobase;
1145
1146 /* set methods */
1147
1148 dev->open = ibmlana_open;
1149 dev->stop = ibmlana_close;
1150 dev->set_config = ibmlana_config;
1151 dev->hard_start_xmit = ibmlana_tx;
1152 dev->do_ioctl = NULL;
1153 dev->get_stats = ibmlana_stats;
1154 dev->set_multicast_list = ibmlana_set_multicast_list;
1155 dev->flags |= IFF_MULTICAST;
1156
1157 /* generic setup */
1158
1159 ether_setup(dev);
1160
1161 /* copy out MAC address */
1162
1163 for (z = 0; z < sizeof(dev->dev_addr); z++)
1164 dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
1165
1166 /* print config */
1167
1168 printk("%s: IRQ %d, I/O %#lx, memory %#lx-%#lx, "
1169 "MAC address %02x:%02x:%02x:%02x:%02x:%02x.\n",
1170 dev->name, priv->realirq, dev->base_addr,
1171 dev->mem_start, dev->mem_end - 1,
1172 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1173 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1174 printk("%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1175
1176 /* reset board */
1177
1178 ResetBoard(dev);
1179
1180 /* next probe will start at next slot */
1181
1182 startslot = slot + 1;
1183
1184 return 0;
1185 }
1186
1187 /* ------------------------------------------------------------------------
1188 * modularization support
1189 * ------------------------------------------------------------------------ */
1190
1191 #ifdef MODULE
1192
1193 #define DEVMAX 5
1194
1195 static struct IBMLANA_NETDEV moddevs[DEVMAX];
1196 static int irq;
1197 static int io;
1198 MODULE_PARM(irq, "i");
1199 MODULE_PARM(io, "i");
1200 MODULE_PARM_DESC(irq, "IBM LAN/A IRQ number");
1201 MODULE_PARM_DESC(io, "IBM LAN/A I/O base address");
1202
1203 int init_module(void)
1204 {
1205 int z, res;
1206
1207 startslot = 0;
1208 for (z = 0; z < DEVMAX; z++) {
1209 moddevs[z].init = ibmlana_probe;
1210 moddevs[z].irq = irq;
1211 moddevs[z].base_addr = io;
1212 res = register_netdev(moddevs + z);
1213 if (res != 0)
1214 return (z > 0) ? 0 : -EIO;
1215 }
1216
1217 return 0;
1218 }
1219
1220 void cleanup_module(void)
1221 {
1222 struct IBMLANA_NETDEV *dev;
1223 ibmlana_priv *priv;
1224 int z;
1225
1226 if (MOD_IN_USE) {
1227 printk("cannot unload, module in use\n");
1228 return;
1229 }
1230
1231 for (z = 0; z < DEVMAX; z++) {
1232 dev = moddevs + z;
1233 if (dev->priv != NULL) {
1234 priv = (ibmlana_priv *) dev->priv;
1235 /*DeinitBoard(dev); */
1236 if (dev->irq != 0)
1237 free_irq(dev->irq, dev);
1238 dev->irq = 0;
1239 release_region(dev->base_addr, IBM_LANA_IORANGE);
1240 unregister_netdev(dev);
1241 #if (LINUX_VERSION_CODE >= 0x20200)
1242 mca_mark_as_unused(priv->slot);
1243 #endif
1244 mca_set_adapter_name(priv->slot, "");
1245 mca_set_adapter_procfn(priv->slot, NULL, NULL);
1246 kfree(dev->priv);
1247 dev->priv = NULL;
1248 }
1249 }
1250 }
1251 #endif /* MODULE */
1252