1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78#include <linux/kernel.h>
79#include <linux/string.h>
80#include <linux/errno.h>
81#include <linux/ioport.h>
82#include <linux/interrupt.h>
83#include <linux/delay.h>
84#include <linux/time.h>
85#include <linux/mca.h>
86#include <linux/module.h>
87#include <linux/netdevice.h>
88#include <linux/etherdevice.h>
89#include <linux/if_ether.h>
90#include <linux/skbuff.h>
91#include <linux/bitops.h>
92
93#include <asm/processor.h>
94#include <asm/io.h>
95
96#define _IBM_LANA_DRIVER_
97#include "ibmlana.h"
98
99#undef DEBUG
100
101#define DRV_NAME "ibmlana"
102
103
104
105
106
107
108static char *MediaNames[Media_Count] = {
109 "10BaseT", "10Base5", "Unknown", "10Base2"
110};
111
112
113
114
115
116#ifdef DEBUG
117
118
119static void dumpregs(struct net_device *dev)
120{
121 int z;
122
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}
131
132
133
134static void dumpmem(struct net_device *dev, u32 start, u32 len)
135{
136 ibmlana_priv *priv = netdev_priv(dev);
137 int z;
138
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}
150
151
152
153static void PrTime(void)
154{
155 struct timeval tv;
156
157 do_gettimeofday(&tv);
158 printk("%9d:%06d: ", (int) tv.tv_sec, (int) tv.tv_usec);
159}
160#endif
161
162
163
164static void getaddrs(struct mca_device *mdev, int *base, int *memlen,
165 int *iobase, int *irq, ibmlana_medium *medium)
166{
167 u_char pos0, pos1;
168
169 pos0 = mca_device_read_stored_pos(mdev, 2);
170 pos1 = mca_device_read_stored_pos(mdev, 3);
171
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}
191
192
193
194static int wait_timeout(struct net_device *dev, int regoffs, u16 mask,
195 u16 value, int timeout)
196{
197 unsigned long fin = jiffies + timeout;
198
199 while (time_before(jiffies,fin))
200 if ((inw(dev->base_addr + regoffs) & mask) == value)
201 return 1;
202
203 return 0;
204}
205
206
207
208
209static void ResetBoard(struct net_device *dev)
210{
211 unsigned char bcmval;
212
213
214
215 bcmval = inb(dev->base_addr + BCMREG);
216
217
218
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);
224
225
226
227 bcmval |= BCMREG_RAMEN | BCMREG_RAMWIN;
228 outb(bcmval, dev->base_addr + BCMREG);
229}
230
231
232
233static 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;
241
242
243
244 memset_io(priv->base, 0xaa,
245 dev->mem_start - dev->mem_start);
246
247
248
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 }
268
269
270
271 priv->rxbufcnt = (dev->mem_end - dev->mem_start - baddr) / (sizeof(rra_t) + sizeof(rda_t) + PKTSIZE);
272
273
274
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));
278
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));
285
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));
297
298 baddr += PKTSIZE;
299 raddr += sizeof(rra_t);
300 addr += sizeof(rda_t);
301 }
302
303
304
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}
312
313
314
315static int InitSONIC(struct net_device *dev)
316{
317 ibmlana_priv *priv = netdev_priv(dev);
318
319
320
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);
326
327
328
329 outw((PKTSIZE - 4) >> 1, dev->base_addr + SONIC_EOBC);
330
331
332
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 }
338
339
340
341 outw(0, dev->base_addr + SONIC_URDA);
342 outw(priv->rdastart, dev->base_addr + SONIC_CRDA);
343
344
345
346 outw(0, dev->base_addr + SONIC_UTDA);
347
348 return 1;
349}
350
351
352
353static void StopSONIC(struct net_device *dev)
354{
355
356
357 outb(inb(dev->base_addr + BCMREG) & (~BCMREG_IEN), dev->base_addr + BCMREG);
358 outb(0, dev->base_addr + SONIC_IMREG);
359
360
361
362 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
363 udelay(10);
364 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
365}
366
367
368
369static void putcam(camentry_t * cams, int *camcnt, char *addr)
370{
371 camentry_t *pcam = cams + (*camcnt);
372 u8 *uaddr = (u8 *) addr;
373
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}
380
381static 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 netdev_hw_addr *ha;
388 u16 rcrval;
389
390
391
392 outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
393 udelay(10);
394
395
396
397 outw(inw(dev->base_addr + SONIC_ISREG), dev->base_addr + SONIC_ISREG);
398
399
400
401
402 outw(DCREG_USR1 | DCREG_USR0 | DCREG_WC1 | DCREG_DW32, dev->base_addr + SONIC_DCREG);
403 outw(0, dev->base_addr + SONIC_DCREG2);
404
405
406
407 outw(0, dev->base_addr + SONIC_CMDREG);
408 udelay(10);
409
410
411
412 outw(0, dev->base_addr + SONIC_URRA);
413
414
415
416 camcnt = 0;
417 putcam(cams, &camcnt, dev->dev_addr);
418
419
420
421
422 netdev_for_each_mc_addr(ha, dev) {
423 putcam(cams, &camcnt, ha->addr);
424 if (camcnt == 16)
425 break;
426 }
427
428
429
430 cammask = (1 << camcnt) - 1;
431
432
433
434 memcpy_toio(priv->base, cams, sizeof(camentry_t) * camcnt);
435 memcpy_toio(priv->base + (sizeof(camentry_t) * camcnt), &cammask, sizeof(cammask));
436
437#ifdef DEBUG
438 printk("CAM setup:\n");
439 dumpmem(dev, 0, sizeof(camentry_t) * camcnt + sizeof(cammask));
440#endif
441
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
450
451 outw(ISREG_LCD, dev->base_addr + SONIC_ISREG);
452
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;
459
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 }
475
476 rcrval = RCREG_BRD | RCREG_LB_NONE;
477
478
479
480
481 if ((dev->flags & IFF_ALLMULTI) || netdev_mc_count(dev) > camcnt)
482 rcrval |= RCREG_AMC;
483
484
485
486 if (dev->flags & IFF_PROMISC)
487 rcrval |= RCREG_PRO;
488
489
490
491 outw(rcrval, dev->base_addr + SONIC_RCREG);
492#ifdef DEBUG
493 printk("\nRCRVAL: %04x\n", rcrval);
494#endif
495
496
497
498 InitDscrs(dev);
499 if (!InitSONIC(dev))
500 return;
501
502
503
504 outw(0xffff, dev->base_addr + SONIC_ISREG);
505
506
507
508 outw(CMDREG_RXEN, dev->base_addr + SONIC_CMDREG);
509 outw(IMREG_PRXEN | IMREG_RBEEN | IMREG_PTXEN | IMREG_TXEREN, dev->base_addr + SONIC_IMREG);
510
511
512
513 outb(inb(dev->base_addr + BCMREG) | BCMREG_IEN, dev->base_addr + BCMREG);
514
515#ifdef DEBUG
516 printk("Register dump after initialization:\n");
517 dumpregs(dev);
518#endif
519}
520
521
522
523static void StartTx(struct net_device *dev, int descr)
524{
525 ibmlana_priv *priv = netdev_priv(dev);
526 int addr;
527
528 addr = priv->tdastart + (descr * sizeof(tda_t));
529
530
531
532 outw(addr, dev->base_addr + SONIC_CTDA);
533
534
535
536 priv->currtxdescr = descr;
537 outw(CMDREG_TXP, dev->base_addr + SONIC_CMDREG);
538}
539
540
541
542
543
544
545
546static void irqrbe_handler(struct net_device *dev)
547{
548 ibmlana_priv *priv = netdev_priv(dev);
549
550
551
552 outw(priv->rrastart, dev->base_addr + SONIC_RRP);
553 outw(priv->rrastart, dev->base_addr + SONIC_RWP);
554}
555
556
557
558static void irqrx_handler(struct net_device *dev)
559{
560 ibmlana_priv *priv = netdev_priv(dev);
561 rda_t rda;
562 u32 rdaaddr, lrdaaddr;
563
564
565
566 while (1) {
567
568
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));
572
573
574
575
576 rda.status &= 0xffff;
577 rda.length &= 0xffff;
578 rda.startlo &= 0xffff;
579
580
581
582 if (rda.inuse)
583 break;
584
585
586
587 else if (rda.status & RCREG_PRX) {
588 struct sk_buff *skb;
589
590
591
592 skb = dev_alloc_skb(rda.length + 2);
593 if (skb == NULL)
594 dev->stats.rx_dropped++;
595 else {
596
597
598 memcpy_fromio(skb_put(skb, rda.length),
599 priv->base +
600 rda.startlo, rda.length);
601
602
603
604 skb->protocol = eth_type_trans(skb, dev);
605 skb_checksum_none_assert(skb);
606
607
608 dev->stats.rx_packets++;
609 dev->stats.rx_bytes += rda.length;
610
611
612 netif_rx(skb);
613 }
614 }
615
616
617
618 else {
619 dev->stats.rx_errors++;
620 if (rda.status & RCREG_FAER)
621 dev->stats.rx_frame_errors++;
622 if (rda.status & RCREG_CRCR)
623 dev->stats.rx_crc_errors++;
624 }
625
626
627
628 rda.link = 1;
629 rda.inuse = 1;
630 memcpy_toio(priv->base + rdaaddr, &rda,
631 sizeof(rda_t));
632
633
634
635
636
637 memcpy_toio(priv->base + lrdaaddr + 20, &rdaaddr, 4);
638
639
640
641 priv->lastrxdescr = priv->nextrxdescr;
642 if ((++priv->nextrxdescr) >= priv->rxbufcnt)
643 priv->nextrxdescr = 0;
644 }
645}
646
647
648
649static void irqtx_handler(struct net_device *dev)
650{
651 ibmlana_priv *priv = netdev_priv(dev);
652 tda_t tda;
653
654
655 memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
656
657
658 dev->stats.tx_packets++;
659 dev->stats.tx_bytes += tda.length;
660
661
662 priv->txused[priv->currtxdescr] = 0;
663 priv->txusedcnt--;
664
665
666 if (priv->txusedcnt > 0)
667 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
668
669
670 netif_wake_queue(dev);
671}
672
673static void irqtxerr_handler(struct net_device *dev)
674{
675 ibmlana_priv *priv = netdev_priv(dev);
676 tda_t tda;
677
678
679 memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
680
681
682 dev->stats.tx_errors++;
683 if (tda.status & (TCREG_NCRS | TCREG_CRSL))
684 dev->stats.tx_carrier_errors++;
685 if (tda.status & TCREG_EXC)
686 dev->stats.tx_aborted_errors++;
687 if (tda.status & TCREG_OWC)
688 dev->stats.tx_window_errors++;
689 if (tda.status & TCREG_FU)
690 dev->stats.tx_fifo_errors++;
691
692
693 priv->txused[priv->currtxdescr] = 0;
694 priv->txusedcnt--;
695
696
697 if (priv->txusedcnt > 0)
698 StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
699
700
701 netif_wake_queue(dev);
702}
703
704
705
706static irqreturn_t irq_handler(int dummy, void *device)
707{
708 struct net_device *dev = device;
709 u16 ival;
710
711
712 if (!(inb(dev->base_addr + BCMREG) & BCMREG_IPEND))
713 return IRQ_NONE;
714
715
716 while (1) {
717 ival = inw(dev->base_addr + SONIC_ISREG);
718
719 if (ival & ISREG_RBE) {
720 irqrbe_handler(dev);
721 outw(ISREG_RBE, dev->base_addr + SONIC_ISREG);
722 }
723 if (ival & ISREG_PKTRX) {
724 irqrx_handler(dev);
725 outw(ISREG_PKTRX, dev->base_addr + SONIC_ISREG);
726 }
727 if (ival & ISREG_TXDN) {
728 irqtx_handler(dev);
729 outw(ISREG_TXDN, dev->base_addr + SONIC_ISREG);
730 }
731 if (ival & ISREG_TXER) {
732 irqtxerr_handler(dev);
733 outw(ISREG_TXER, dev->base_addr + SONIC_ISREG);
734 }
735 break;
736 }
737 return IRQ_HANDLED;
738}
739
740
741
742
743
744
745
746#if 0
747static int ibmlana_getinfo(char *buf, int slot, void *d)
748{
749 int len = 0, i;
750 struct net_device *dev = (struct net_device *) d;
751 ibmlana_priv *priv;
752
753
754
755 if (dev == NULL)
756 return len;
757 priv = netdev_priv(dev);
758
759
760
761 len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
762 len += sprintf(buf + len, "I/O: %#lx\n", dev->base_addr);
763 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start, dev->mem_end - 1);
764 len += sprintf(buf + len, "Transceiver: %s\n", MediaNames[priv->medium]);
765 len += sprintf(buf + len, "Device: %s\n", dev->name);
766 len += sprintf(buf + len, "MAC address:");
767 for (i = 0; i < 6; i++)
768 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
769 buf[len++] = '\n';
770 buf[len] = 0;
771
772 return len;
773}
774#endif
775
776
777
778static int ibmlana_open(struct net_device *dev)
779{
780 int result;
781 ibmlana_priv *priv = netdev_priv(dev);
782
783
784
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;
791
792
793 InitBoard(dev);
794
795
796 netif_start_queue(dev);
797 return 0;
798}
799
800
801
802static int ibmlana_close(struct net_device *dev)
803{
804
805
806
807 if (dev->irq != 0)
808 free_irq(dev->irq, dev);
809 dev->irq = 0;
810 return 0;
811}
812
813
814
815static netdev_tx_t ibmlana_tx(struct sk_buff *skb, struct net_device *dev)
816{
817 ibmlana_priv *priv = netdev_priv(dev);
818 int tmplen, addr;
819 unsigned long flags;
820 tda_t tda;
821 int baddr;
822
823
824
825
826 if (priv->txusedcnt >= TXBUFCNT) {
827 dev->stats.tx_dropped++;
828 goto tx_done;
829 }
830
831
832 tmplen = skb->len;
833 if (tmplen < 60)
834 tmplen = 60;
835 baddr = priv->txbufstart + (priv->nexttxdescr * PKTSIZE);
836 memcpy_toio(priv->base + baddr, skb->data, skb->len);
837
838
839
840
841
842
843 if (tmplen > skb->len) {
844 char *fill = "NetBSD is a nice OS too! ";
845 unsigned int destoffs = skb->len, l = strlen(fill);
846
847 while (destoffs < tmplen) {
848 memcpy_toio(priv->base + baddr + destoffs, fill, l);
849 destoffs += l;
850 }
851 }
852
853
854 addr = priv->tdastart + (priv->nexttxdescr * sizeof(tda_t));
855 memcpy_fromio(&tda, priv->base + addr, sizeof(tda_t));
856 tda.length = tda.fraglength = tmplen;
857 memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
858
859
860 spin_lock_irqsave(&priv->lock, flags);
861
862 priv->txusedcnt++;
863 priv->txused[priv->nexttxdescr] = 1;
864
865
866 if (priv->txusedcnt >= TXBUFCNT)
867 netif_stop_queue(dev);
868
869 if (priv->txusedcnt == 1)
870 StartTx(dev, priv->nexttxdescr);
871 priv->nexttxdescr = (priv->nexttxdescr + 1) % TXBUFCNT;
872
873 spin_unlock_irqrestore(&priv->lock, flags);
874tx_done:
875 dev_kfree_skb(skb);
876 return NETDEV_TX_OK;
877}
878
879
880
881static void ibmlana_set_multicast_list(struct net_device *dev)
882{
883
884 StopSONIC(dev);
885
886 InitBoard(dev);
887}
888
889
890
891
892
893static int ibmlana_irq;
894static int ibmlana_io;
895static int startslot;
896
897static short ibmlana_adapter_ids[] __initdata = {
898 IBM_LANA_ID,
899 0x0000
900};
901
902static char *ibmlana_adapter_names[] __devinitdata = {
903 "IBM LAN Adapter/A",
904 NULL
905};
906
907
908static const struct net_device_ops ibmlana_netdev_ops = {
909 .ndo_open = ibmlana_open,
910 .ndo_stop = ibmlana_close,
911 .ndo_start_xmit = ibmlana_tx,
912 .ndo_set_multicast_list = ibmlana_set_multicast_list,
913 .ndo_change_mtu = eth_change_mtu,
914 .ndo_set_mac_address = eth_mac_addr,
915 .ndo_validate_addr = eth_validate_addr,
916};
917
918static int __devinit ibmlana_init_one(struct device *kdev)
919{
920 struct mca_device *mdev = to_mca_device(kdev);
921 struct net_device *dev;
922 int slot = mdev->slot, z, rc;
923 int base = 0, irq = 0, iobase = 0, memlen = 0;
924 ibmlana_priv *priv;
925 ibmlana_medium medium;
926
927 dev = alloc_etherdev(sizeof(ibmlana_priv));
928 if (!dev)
929 return -ENOMEM;
930
931 dev->irq = ibmlana_irq;
932 dev->base_addr = ibmlana_io;
933
934 base = dev->mem_start;
935 irq = dev->irq;
936
937
938 getaddrs(mdev, &base, &memlen, &iobase, &irq, &medium);
939
940
941 if (dev->irq && dev->irq != irq) {
942 rc = -ENODEV;
943 goto err_out;
944 }
945 if (dev->mem_start && dev->mem_start != base) {
946 rc = -ENODEV;
947 goto err_out;
948 }
949
950
951 printk(KERN_INFO "%s: IBM LAN Adapter/A found in slot %d\n", dev->name, slot + 1);
952
953
954 if (!request_region(iobase, IBM_LANA_IORANGE, DRV_NAME)) {
955 printk(KERN_ERR "%s: cannot allocate I/O range at %#x!\n", DRV_NAME, iobase);
956 startslot = slot + 1;
957 rc = -EBUSY;
958 goto err_out;
959 }
960
961 priv = netdev_priv(dev);
962 priv->slot = slot;
963 priv->realirq = mca_device_transform_irq(mdev, irq);
964 priv->medium = medium;
965 spin_lock_init(&priv->lock);
966
967
968
969 dev->irq = 0;
970 dev->mem_start = base;
971 dev->mem_end = base + memlen;
972 dev->base_addr = iobase;
973
974 priv->base = ioremap(base, memlen);
975 if (!priv->base) {
976 printk(KERN_ERR "%s: cannot remap memory!\n", DRV_NAME);
977 startslot = slot + 1;
978 rc = -EBUSY;
979 goto err_out_reg;
980 }
981
982 mca_device_set_name(mdev, ibmlana_adapter_names[mdev->index]);
983 mca_device_set_claim(mdev, 1);
984
985
986 dev->netdev_ops = &ibmlana_netdev_ops;
987 dev->flags |= IFF_MULTICAST;
988
989
990
991 for (z = 0; z < ETH_ALEN; z++)
992 dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
993
994
995
996 printk(KERN_INFO "%s: IRQ %d, I/O %#lx, memory %#lx-%#lx, "
997 "MAC address %pM.\n",
998 dev->name, priv->realirq, dev->base_addr,
999 dev->mem_start, dev->mem_end - 1,
1000 dev->dev_addr);
1001 printk(KERN_INFO "%s: %s medium\n", dev->name, MediaNames[priv->medium]);
1002
1003
1004
1005 ResetBoard(dev);
1006
1007
1008
1009 startslot = slot + 1;
1010
1011 rc = register_netdev(dev);
1012 if (rc)
1013 goto err_out_claimed;
1014
1015 dev_set_drvdata(kdev, dev);
1016 return 0;
1017
1018err_out_claimed:
1019 mca_device_set_claim(mdev, 0);
1020 iounmap(priv->base);
1021err_out_reg:
1022 release_region(iobase, IBM_LANA_IORANGE);
1023err_out:
1024 free_netdev(dev);
1025 return rc;
1026}
1027
1028static int ibmlana_remove_one(struct device *kdev)
1029{
1030 struct mca_device *mdev = to_mca_device(kdev);
1031 struct net_device *dev = dev_get_drvdata(kdev);
1032 ibmlana_priv *priv = netdev_priv(dev);
1033
1034 unregister_netdev(dev);
1035
1036 release_region(dev->base_addr, IBM_LANA_IORANGE);
1037 mca_device_set_claim(mdev, 0);
1038 iounmap(priv->base);
1039 free_netdev(dev);
1040 return 0;
1041}
1042
1043
1044
1045
1046
1047module_param_named(irq, ibmlana_irq, int, 0);
1048module_param_named(io, ibmlana_io, int, 0);
1049MODULE_PARM_DESC(irq, "IBM LAN/A IRQ number");
1050MODULE_PARM_DESC(io, "IBM LAN/A I/O base address");
1051MODULE_LICENSE("GPL");
1052
1053static struct mca_driver ibmlana_driver = {
1054 .id_table = ibmlana_adapter_ids,
1055 .driver = {
1056 .name = "ibmlana",
1057 .bus = &mca_bus_type,
1058 .probe = ibmlana_init_one,
1059 .remove = ibmlana_remove_one,
1060 },
1061};
1062
1063static int __init ibmlana_init_module(void)
1064{
1065 return mca_register_driver(&ibmlana_driver);
1066}
1067
1068static void __exit ibmlana_cleanup_module(void)
1069{
1070 mca_unregister_driver(&ibmlana_driver);
1071}
1072
1073module_init(ibmlana_init_module);
1074module_exit(ibmlana_cleanup_module);
1075