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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108#define IBMTR_DEBUG_MESSAGES 0
109
110#include <linux/module.h>
111#include <linux/sched.h>
112
113#ifdef PCMCIA
114#undef MODULE
115#undef ENABLE_PAGING
116#else
117#define ENABLE_PAGING 1
118#endif
119
120
121#define TR_VERBOSE 0
122
123
124#define TR_FILTERNONUI 1
125
126#include <linux/ioport.h>
127#include <linux/netdevice.h>
128#include <linux/ip.h>
129#include <linux/trdevice.h>
130#include <linux/ibmtr.h>
131
132#include <net/checksum.h>
133
134#include <asm/io.h>
135
136#define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args)
137#define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args)
138
139
140#ifndef PCMCIA
141static char version[] __devinitdata =
142 "\nibmtr.c: v1.3.57 8/ 7/94 Peter De Schrijver and Mark Swanson\n"
143 " v2.1.125 10/20/98 Paul Norton <pnorton@ieee.org>\n"
144 " v2.2.0 12/30/98 Joel Sloan <jjs@c-me.com>\n"
145 " v2.2.1 02/08/00 Mike Sullivan <sullivam@us.ibm.com>\n"
146 " v2.2.2 07/27/00 Burt Silverman <burts@us.ibm.com>\n"
147 " v2.4.0 03/01/01 Mike Sullivan <sullivan@us.ibm.com>\n";
148#endif
149
150
151
152static char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" };
153
154static char pcchannelid[] __devinitdata = {
155 0x05, 0x00, 0x04, 0x09,
156 0x04, 0x03, 0x04, 0x0f,
157 0x03, 0x06, 0x03, 0x01,
158 0x03, 0x01, 0x03, 0x00,
159 0x03, 0x09, 0x03, 0x09,
160 0x03, 0x00, 0x02, 0x00
161};
162
163static char mcchannelid[] __devinitdata = {
164 0x04, 0x0d, 0x04, 0x01,
165 0x05, 0x02, 0x05, 0x03,
166 0x03, 0x06, 0x03, 0x03,
167 0x05, 0x08, 0x03, 0x04,
168 0x03, 0x05, 0x03, 0x01,
169 0x03, 0x08, 0x02, 0x00
170};
171
172static char __devinit *adapter_def(char type)
173{
174 switch (type) {
175 case 0xF: return "PC Adapter | PC Adapter II | Adapter/A";
176 case 0xE: return "16/4 Adapter | 16/4 Adapter/A (long)";
177 case 0xD: return "16/4 Adapter/A (short) | 16/4 ISA-16 Adapter";
178 case 0xC: return "Auto 16/4 Adapter";
179 default: return "adapter (unknown type)";
180 };
181};
182
183#define TRC_INIT 0x01
184#define TRC_INITV 0x02
185static unsigned char ibmtr_debug_trace = 0;
186
187static int ibmtr_probe1(struct net_device *dev, int ioaddr);
188static unsigned char get_sram_size(struct tok_info *adapt_info);
189static int trdev_init(struct net_device *dev);
190static int tok_open(struct net_device *dev);
191static int tok_init_card(struct net_device *dev);
192static void tok_open_adapter(unsigned long dev_addr);
193static void open_sap(unsigned char type, struct net_device *dev);
194static void tok_set_multicast_list(struct net_device *dev);
195static netdev_tx_t tok_send_packet(struct sk_buff *skb,
196 struct net_device *dev);
197static int tok_close(struct net_device *dev);
198static irqreturn_t tok_interrupt(int irq, void *dev_id);
199static void initial_tok_int(struct net_device *dev);
200static void tr_tx(struct net_device *dev);
201static void tr_rx(struct net_device *dev);
202static void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev);
203static void tok_rerun(unsigned long dev_addr);
204static void ibmtr_readlog(struct net_device *dev);
205static int ibmtr_change_mtu(struct net_device *dev, int mtu);
206static void find_turbo_adapters(int *iolist);
207
208static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = {
209 0xa20, 0xa24, 0, 0, 0
210};
211static int __devinitdata turbo_io[IBMTR_MAX_ADAPTERS] = {0};
212static int __devinitdata turbo_irq[IBMTR_MAX_ADAPTERS] = {0};
213static int __devinitdata turbo_searched = 0;
214
215#ifndef PCMCIA
216static __u32 ibmtr_mem_base __devinitdata = 0xd0000;
217#endif
218
219static void __devinit PrtChanID(char *pcid, short stride)
220{
221 short i, j;
222 for (i = 0, j = 0; i < 24; i++, j += stride)
223 printk("%1x", ((int) pcid[j]) & 0x0f);
224 printk("\n");
225}
226
227static void __devinit HWPrtChanID(void __iomem *pcid, short stride)
228{
229 short i, j;
230 for (i = 0, j = 0; i < 24; i++, j += stride)
231 printk("%1x", ((int) readb(pcid + j)) & 0x0f);
232 printk("\n");
233}
234
235
236
237
238
239static void __devinit find_turbo_adapters(int *iolist)
240{
241 int ram_addr;
242 int index=0;
243 void __iomem *chanid;
244 int found_turbo=0;
245 unsigned char *tchanid, ctemp;
246 int i, j;
247 unsigned long jif;
248 void __iomem *ram_mapped ;
249
250 if (turbo_searched == 1) return;
251 turbo_searched=1;
252 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
253
254 __u32 intf_tbl=0;
255
256 found_turbo=1;
257 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
258 if (ram_mapped==NULL)
259 continue ;
260 chanid=(CHANNEL_ID + ram_mapped);
261 tchanid=pcchannelid;
262 ctemp=readb(chanid) & 0x0f;
263 if (ctemp != *tchanid) continue;
264 for (i=2,j=1; i<=46; i=i+2,j++) {
265 if ((readb(chanid+i) & 0x0f) != tchanid[j]){
266 found_turbo=0;
267 break;
268 }
269 }
270 if (!found_turbo) continue;
271
272 writeb(0x90, ram_mapped+0x1E01);
273 for(i=2; i<0x0f; i++) {
274 writeb(0x00, ram_mapped+0x1E01+i);
275 }
276 writeb(0x00, ram_mapped+0x1E01);
277 for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif););
278 intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN));
279 if (intf_tbl) {
280#if IBMTR_DEBUG_MESSAGES
281 printk("ibmtr::find_turbo_adapters, Turbo found at "
282 "ram_addr %x\n",ram_addr);
283 printk("ibmtr::find_turbo_adapters, interface_table ");
284 for(i=0; i<6; i++) {
285 printk("%x:",readb(ram_addr+intf_tbl+i));
286 }
287 printk("\n");
288#endif
289 turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4));
290 turbo_irq[index]=readb(ram_mapped+intf_tbl+3);
291 outb(0, turbo_io[index] + ADAPTRESET);
292 for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif););
293 outb(0, turbo_io[index] + ADAPTRESETREL);
294 index++;
295 continue;
296 }
297#if IBMTR_DEBUG_MESSAGES
298 printk("ibmtr::find_turbo_adapters, ibmtr card found at"
299 " %x but not a Turbo model\n",ram_addr);
300#endif
301 iounmap(ram_mapped) ;
302 }
303 for(i=0; i<IBMTR_MAX_ADAPTERS; i++) {
304 if(!turbo_io[i]) break;
305 for (j=0; j<IBMTR_MAX_ADAPTERS; j++) {
306 if ( iolist[j] && iolist[j] != turbo_io[i]) continue;
307 iolist[j]=turbo_io[i];
308 break;
309 }
310 }
311}
312
313static void ibmtr_cleanup_card(struct net_device *dev)
314{
315 if (dev->base_addr) {
316 outb(0,dev->base_addr+ADAPTRESET);
317
318 schedule_timeout_uninterruptible(TR_RST_TIME);
319
320 outb(0,dev->base_addr+ADAPTRESETREL);
321 }
322
323#ifndef PCMCIA
324 free_irq(dev->irq, dev);
325 release_region(dev->base_addr, IBMTR_IO_EXTENT);
326
327 {
328 struct tok_info *ti = netdev_priv(dev);
329 iounmap(ti->mmio);
330 iounmap(ti->sram_virt);
331 }
332#endif
333}
334
335
336
337
338
339
340
341
342
343
344
345
346
347static int __devinit ibmtr_probe(struct net_device *dev)
348{
349 int i;
350 int base_addr = dev->base_addr;
351
352 if (base_addr && base_addr <= 0x1ff)
353 return -ENXIO;
354 if (base_addr > 0x1ff) {
355 if (!ibmtr_probe1(dev, base_addr)) return 0;
356 return -ENODEV;
357 }
358 find_turbo_adapters(ibmtr_portlist);
359 for (i = 0; ibmtr_portlist[i]; i++) {
360 int ioaddr = ibmtr_portlist[i];
361
362 if (!ibmtr_probe1(dev, ioaddr)) return 0;
363 }
364 return -ENODEV;
365}
366
367int __devinit ibmtr_probe_card(struct net_device *dev)
368{
369 int err = ibmtr_probe(dev);
370 if (!err) {
371 err = register_netdev(dev);
372 if (err)
373 ibmtr_cleanup_card(dev);
374 }
375 return err;
376}
377
378
379
380static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
381{
382
383 unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0;
384 void __iomem * t_mmio = NULL;
385 struct tok_info *ti = netdev_priv(dev);
386 void __iomem *cd_chanid;
387 unsigned char *tchanid, ctemp;
388#ifndef PCMCIA
389 unsigned char t_irq=0;
390 unsigned long timeout;
391 static int version_printed;
392#endif
393
394
395
396
397
398 segment = inb(PIOaddr);
399 if (segment < 0x40 || segment > 0xe0) {
400
401
402
403#if IBMTR_DEBUG_MESSAGES
404 DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, "
405 "Hardware Problem?\n",PIOaddr,segment);
406#endif
407 return -ENODEV;
408 }
409
410
411
412
413 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
414 if (!t_mmio) {
415 DPRINTK("Cannot remap mmiobase memory area") ;
416 return -ENODEV ;
417 }
418 intr = segment & 0x03;
419 if (ibmtr_debug_trace & TRC_INIT)
420 DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n"
421 , PIOaddr, (int) segment, t_mmio, (int) intr);
422
423
424
425
426
427#ifdef PCMCIA
428 iounmap(t_mmio);
429 t_mmio = ti->mmio;
430 irq = ti->irq;
431#endif
432 cd_chanid = (CHANNEL_ID + t_mmio);
433 tchanid = pcchannelid;
434 cardpresent = TR_ISA;
435
436
437 ctemp = readb(cd_chanid) & 0x0f;
438 if (ctemp != *tchanid) {
439 tchanid = mcchannelid;
440 cardpresent = TR_MCA;
441 if (ctemp != *tchanid)
442 cardpresent = NOTOK;
443 }
444 if (cardpresent != NOTOK) {
445
446 for (i = 2, j = 1; i <= 46; i = i + 2, j++) {
447 if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue;
448
449 cardpresent = NOTOK;
450 break;
451 }
452 }
453
454
455
456
457 if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e))
458 cardpresent = TR_ISAPNP;
459 if (cardpresent == NOTOK) {
460 if (!(ibmtr_debug_trace & TRC_INIT)) {
461#ifndef PCMCIA
462 iounmap(t_mmio);
463#endif
464 return -ENODEV;
465 }
466 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
467 PIOaddr);
468 DPRINTK("Expected for ISA: ");
469 PrtChanID(pcchannelid, 1);
470 DPRINTK(" found: ");
471
472
473
474 HWPrtChanID(cd_chanid, 2);
475 DPRINTK("Expected for MCA: ");
476 PrtChanID(mcchannelid, 1);
477 }
478
479
480
481#ifndef PCMCIA
482 ti->mmio = t_mmio;
483 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
484 if (turbo_io[i] != PIOaddr)
485 continue;
486#if IBMTR_DEBUG_MESSAGES
487 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
488 PIOaddr);
489#endif
490 ti->turbo = 1;
491 t_irq = turbo_irq[i];
492 }
493#endif
494 ti->readlog_pending = 0;
495 init_waitqueue_head(&ti->wait_for_reset);
496
497
498
499
500#ifndef PCMCIA
501 switch (cardpresent) {
502 case TR_ISA:
503 if (intr == 0) irq = 9;
504 if (intr == 1) irq = 3;
505 if (intr == 2) irq = 6;
506 if (intr == 3) irq = 7;
507 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
508 break;
509 case TR_MCA:
510 if (intr == 0) irq = 9;
511 if (intr == 1) irq = 3;
512 if (intr == 2) irq = 10;
513 if (intr == 3) irq = 11;
514 ti->global_int_enable = 0;
515 ti->adapter_int_enable = 0;
516 ti->sram_phys=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12;
517 break;
518 case TR_ISAPNP:
519 if (!t_irq) {
520 if (intr == 0) irq = 9;
521 if (intr == 1) irq = 3;
522 if (intr == 2) irq = 10;
523 if (intr == 3) irq = 11;
524 } else
525 irq=t_irq;
526 timeout = jiffies + TR_SPIN_INTERVAL;
527 while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){
528 if (!time_after(jiffies, timeout)) continue;
529 DPRINTK( "Hardware timeout during initialization.\n");
530 iounmap(t_mmio);
531 return -ENODEV;
532 }
533 ti->sram_phys =
534 ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12);
535 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
536 break;
537 }
538#endif
539
540 if (ibmtr_debug_trace & TRC_INIT) {
541 DPRINTK("irq=%d", irq);
542 printk(", sram_phys=0x%x", ti->sram_phys);
543 if(ibmtr_debug_trace&TRC_INITV){
544 DPRINTK(", ti->mmio=%p", ti->mmio);
545 printk(", segment=%02X", segment);
546 }
547 printk(".\n");
548 }
549
550
551 j = 0;
552 for (i = 0; i < 0x18; i = i + 2) {
553
554 temp = readb(ti->mmio + AIP + i) & 0x0f;
555 ti->hw_address[j] = temp;
556 if (j & 1)
557 dev->dev_addr[(j / 2)] =
558 ti->hw_address[j]+ (ti->hw_address[j - 1] << 4);
559 ++j;
560 }
561
562 ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);
563
564
565 ti->data_rate = readb(ti->mmio + AIPDATARATE);
566
567
568 ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);
569
570
571 if (ti->turbo) {
572 ti->avail_shared_ram=127;
573 } else {
574 ti->avail_shared_ram = get_sram_size(ti);
575 }
576
577
578 ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE);
579
580
581 switch (readb(ti->mmio + AIP4MBDHB)) {
582 case 0xe: ti->dhb_size4mb = 4096; break;
583 case 0xd: ti->dhb_size4mb = 4464; break;
584 default: ti->dhb_size4mb = 2048; break;
585 }
586
587
588 switch (readb(ti->mmio + AIP16MBDHB)) {
589 case 0xe: ti->dhb_size16mb = 4096; break;
590 case 0xd: ti->dhb_size16mb = 8192; break;
591 case 0xc: ti->dhb_size16mb = 16384; break;
592 case 0xb: ti->dhb_size16mb = 17960; break;
593 default: ti->dhb_size16mb = 2048; break;
594 }
595
596
597
598
599
600
601
602
603
604
605
606
607 ti->mapped_ram_size=
608 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4);
609 ti->page_mask = 0;
610 if (ti->turbo) ti->page_mask=0xf0;
611 else if (ti->shared_ram_paging == 0xf);
612 else {
613#ifdef ENABLE_PAGING
614 unsigned char pg_size = 0;
615
616
617 switch (ti->shared_ram_paging) {
618 case 0xf:
619 break;
620 case 0xe:
621 ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0;
622 pg_size = 32;
623 break;
624 case 0xd:
625 ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0;
626 pg_size = 64;
627 break;
628 case 0xc:
629 switch (ti->mapped_ram_size) {
630 case 32:
631 ti->page_mask = 0xc0;
632 pg_size = 32;
633 break;
634 case 64:
635 ti->page_mask = 0x80;
636 pg_size = 64;
637 break;
638 }
639 break;
640 default:
641 DPRINTK("Unknown shared ram paging info %01X\n",
642 ti->shared_ram_paging);
643 iounmap(t_mmio);
644 return -ENODEV;
645 break;
646 }
647
648 if (ibmtr_debug_trace & TRC_INIT)
649 DPRINTK("Shared RAM paging code: %02X, "
650 "mapped RAM size: %dK, shared RAM size: %dK, "
651 "page mask: %02X\n:",
652 ti->shared_ram_paging, ti->mapped_ram_size / 2,
653 ti->avail_shared_ram / 2, ti->page_mask);
654#endif
655 }
656
657#ifndef PCMCIA
658
659 if (cardpresent == TR_ISA) {
660 static __u32 ram_bndry_mask[] =
661 { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 };
662 __u32 new_base, rrr_32, chk_base, rbm;
663
664 rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03;
665 rbm = ram_bndry_mask[rrr_32];
666 new_base = (ibmtr_mem_base + (~rbm)) & rbm;
667 chk_base = new_base + (ti->mapped_ram_size << 9);
668 if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) {
669 DPRINTK("Shared RAM for this adapter (%05x) exceeds "
670 "driver limit (%05x), adapter not started.\n",
671 chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
672 iounmap(t_mmio);
673 return -ENODEV;
674 } else {
675 ti->sram_base = new_base >> 12;
676 ibmtr_mem_base = chk_base;
677 }
678 }
679 else ti->sram_base = ti->sram_phys >> 12;
680
681
682
683 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
684 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
685 irq);
686 iounmap(t_mmio);
687 return -ENODEV;
688 }
689
690
691 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
692 DPRINTK("Could not grab PIO range. Halting driver.\n");
693 free_irq(dev->irq, dev);
694 iounmap(t_mmio);
695 return -EBUSY;
696 }
697
698 if (!version_printed++) {
699 printk(version);
700 }
701#endif
702 DPRINTK("%s %s found\n",
703 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
704 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
705 irq, PIOaddr, ti->mapped_ram_size / 2);
706 DPRINTK("Hardware address : %pM\n", dev->dev_addr);
707 if (ti->page_mask)
708 DPRINTK("Shared RAM paging enabled. "
709 "Page size: %uK Shared Ram size %dK\n",
710 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
711 else
712 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
713 ti->page_mask);
714
715
716
717
718
719
720
721 if (!ti->page_mask) {
722 ti->avail_shared_ram=
723 min(ti->mapped_ram_size,ti->avail_shared_ram);
724 }
725
726 switch (ti->avail_shared_ram) {
727 case 16:
728 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
729 ti->rbuf_len4 = 1032;
730 ti->rbuf_cnt4=2;
731 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
732 ti->rbuf_len16 = 1032;
733 ti->rbuf_cnt16=2;
734 break;
735 case 32:
736 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
737 ti->rbuf_len4 = 1032;
738 ti->rbuf_cnt4=4;
739 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
740 ti->rbuf_len16 = 1032;
741 ti->rbuf_cnt16=4;
742 break;
743 case 64:
744 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
745 ti->rbuf_len4 = 1032;
746 ti->rbuf_cnt4=6;
747 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
748 ti->rbuf_len16 = 1032;
749 ti->rbuf_cnt16=6;
750 break;
751 case 127:
752 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
753 ti->rbuf_len4 = 1032;
754 ti->rbuf_cnt4=6;
755 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
756 ti->rbuf_len16 = 1032;
757 ti->rbuf_cnt16=16;
758 break;
759 case 128:
760 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
761 ti->rbuf_len4 = 1032;
762 ti->rbuf_cnt4=6;
763 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
764 ti->rbuf_len16 = 1032;
765 ti->rbuf_cnt16=16;
766 break;
767 default:
768 ti->dhb_size4mb = 2048;
769 ti->rbuf_len4 = 1032;
770 ti->rbuf_cnt4=2;
771 ti->dhb_size16mb = 2048;
772 ti->rbuf_len16 = 1032;
773 ti->rbuf_cnt16=2;
774 break;
775 }
776
777
778
779
780
781
782 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
783 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
784
785 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
786 ti->maxmtu16, ti->maxmtu4);
787
788 dev->base_addr = PIOaddr;
789 dev->mem_start = ti->sram_base << 12;
790 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
791 trdev_init(dev);
792 return 0;
793}
794
795
796
797
798
799
800static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
801{
802 unsigned char avail_sram_code;
803 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
804
805
806
807
808
809
810
811 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
812 if (avail_sram_code) return size_code[avail_sram_code];
813 else
814 return 1 <<
815 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
816}
817
818
819
820static const struct net_device_ops trdev_netdev_ops = {
821 .ndo_open = tok_open,
822 .ndo_stop = tok_close,
823 .ndo_start_xmit = tok_send_packet,
824 .ndo_set_multicast_list = tok_set_multicast_list,
825 .ndo_change_mtu = ibmtr_change_mtu,
826};
827
828static int __devinit trdev_init(struct net_device *dev)
829{
830 struct tok_info *ti = netdev_priv(dev);
831
832 SET_PAGE(ti->srb_page);
833 ti->open_failure = NO ;
834 dev->netdev_ops = &trdev_netdev_ops;
835
836 return 0;
837}
838
839
840
841static int tok_init_card(struct net_device *dev)
842{
843 struct tok_info *ti;
844 short PIOaddr;
845 unsigned long i;
846
847 PIOaddr = dev->base_addr;
848 ti = netdev_priv(dev);
849
850 ti->do_tok_int = FIRST_INT;
851
852 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
853 outb(0, PIOaddr + ADAPTRESET);
854
855 schedule_timeout_uninterruptible(TR_RST_TIME);
856
857 outb(0, PIOaddr + ADAPTRESETREL);
858#ifdef ENABLE_PAGING
859 if (ti->page_mask)
860 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
861#endif
862 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
863 i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ);
864 return i? 0 : -EAGAIN;
865}
866
867
868static int tok_open(struct net_device *dev)
869{
870 struct tok_info *ti = netdev_priv(dev);
871 int i;
872
873
874 if (ti->open_failure == YES) {
875 DPRINTK("Last time you were disconnected, how about now?\n");
876 printk("You can't insert with an ICS connector half-cocked.\n");
877 }
878
879 ti->open_status = CLOSED;
880 ti->sap_status = CLOSED;
881 ti->open_failure = NO;
882 ti->open_mode = MANUAL;
883
884 ti->sram_phys &= ~1;
885
886 spin_lock_init(&ti->lock);
887 init_timer(&ti->tr_timer);
888
889 i = tok_init_card(dev);
890 if (i) return i;
891
892 while (1){
893 tok_open_adapter((unsigned long) dev);
894 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
895
896 if (i>(245*HZ)/10) break;
897 if (i==0) break;
898 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
899 netif_start_queue(dev);
900 DPRINTK("Adapter is up and running\n");
901 return 0;
902 }
903 i=schedule_timeout_interruptible(TR_RETRY_INTERVAL);
904
905 if(i!=0) break;
906 }
907 outb(0, dev->base_addr + ADAPTRESET);
908 DPRINTK("TERMINATED via signal\n");
909 return -EAGAIN;
910}
911
912
913
914#define COMMAND_OFST 0
915#define OPEN_OPTIONS_OFST 8
916#define NUM_RCV_BUF_OFST 24
917#define RCV_BUF_LEN_OFST 26
918#define DHB_LENGTH_OFST 28
919#define NUM_DHB_OFST 30
920#define DLC_MAX_SAP_OFST 32
921#define DLC_MAX_STA_OFST 33
922
923static void tok_open_adapter(unsigned long dev_addr)
924{
925 struct net_device *dev = (struct net_device *) dev_addr;
926 struct tok_info *ti;
927 int i;
928
929 ti = netdev_priv(dev);
930 SET_PAGE(ti->init_srb_page);
931 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
932 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
933 writeb(0, ti->init_srb + i);
934 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
935 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
936 if (ti->ring_speed == 16) {
937 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
938 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
939 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
940 } else {
941 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
942 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
943 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
944 }
945 writeb(NUM_DHB, ti->init_srb + NUM_DHB_OFST);
946 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
947 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
948 ti->srb = ti->init_srb;
949 ti->srb_page = ti->init_srb_page;
950 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
951 readb(ti->init_srb + NUM_DHB_OFST),
952 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
953 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
954 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
955 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
956 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
957}
958
959
960
961static void open_sap(unsigned char type, struct net_device *dev)
962{
963 int i;
964 struct tok_info *ti = netdev_priv(dev);
965
966 SET_PAGE(ti->srb_page);
967 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
968 writeb(0, ti->srb + i);
969
970#define MAX_I_FIELD_OFST 14
971#define SAP_VALUE_OFST 16
972#define SAP_OPTIONS_OFST 17
973#define STATION_COUNT_OFST 18
974
975 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
976 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
977 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
978 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
979 writeb(type, ti->srb + SAP_VALUE_OFST);
980 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
981}
982
983
984
985
986static void tok_set_multicast_list(struct net_device *dev)
987{
988 struct tok_info *ti = netdev_priv(dev);
989 struct dev_mc_list *mclist;
990 unsigned char address[4];
991
992 int i;
993
994
995
996 if ( ti->open_status != OPEN) return;
997 address[0] = address[1] = address[2] = address[3] = 0;
998 mclist = dev->mc_list;
999 for (i = 0; i < dev->mc_count; i++) {
1000 address[0] |= mclist->dmi_addr[2];
1001 address[1] |= mclist->dmi_addr[3];
1002 address[2] |= mclist->dmi_addr[4];
1003 address[3] |= mclist->dmi_addr[5];
1004 mclist = mclist->next;
1005 }
1006 SET_PAGE(ti->srb_page);
1007 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1008 writeb(0, ti->srb + i);
1009
1010#define FUNCT_ADDRESS_OFST 6
1011
1012 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1013 for (i = 0; i < 4; i++)
1014 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1015 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1016#if TR_VERBOSE
1017 DPRINTK("Setting functional address: ");
1018 for (i=0;i<4;i++) printk("%02X ", address[i]);
1019 printk("\n");
1020#endif
1021}
1022
1023
1024
1025#define STATION_ID_OFST 4
1026
1027static netdev_tx_t tok_send_packet(struct sk_buff *skb,
1028 struct net_device *dev)
1029{
1030 struct tok_info *ti;
1031 unsigned long flags;
1032 ti = netdev_priv(dev);
1033
1034 netif_stop_queue(dev);
1035
1036
1037 spin_lock_irqsave(&(ti->lock), flags);
1038
1039
1040 ti->current_skb = skb;
1041 SET_PAGE(ti->srb_page);
1042 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1043 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1044 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1045 spin_unlock_irqrestore(&(ti->lock), flags);
1046 dev->trans_start = jiffies;
1047 return NETDEV_TX_OK;
1048}
1049
1050
1051
1052static int tok_close(struct net_device *dev)
1053{
1054 struct tok_info *ti = netdev_priv(dev);
1055
1056
1057
1058 del_timer_sync(&ti->tr_timer);
1059 outb(0, dev->base_addr + ADAPTRESET);
1060 ti->sram_phys |= 1;
1061 ti->open_status = CLOSED;
1062
1063 netif_stop_queue(dev);
1064 DPRINTK("Adapter is closed.\n");
1065 return 0;
1066}
1067
1068
1069
1070#define RETCODE_OFST 2
1071#define OPEN_ERROR_CODE_OFST 6
1072#define ASB_ADDRESS_OFST 8
1073#define SRB_ADDRESS_OFST 10
1074#define ARB_ADDRESS_OFST 12
1075#define SSB_ADDRESS_OFST 14
1076
1077static char *printphase[]= {"Lobe media test","Physical insertion",
1078 "Address verification","Roll call poll","Request Parameters"};
1079static char *printerror[]={"Function failure","Signal loss","Reserved",
1080 "Frequency error","Timeout","Ring failure","Ring beaconing",
1081 "Duplicate node address",
1082 "Parameter request-retry count exceeded","Remove received",
1083 "IMPL force received","Duplicate modifier",
1084 "No monitor detected","Monitor contention failed for RPL"};
1085
1086static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page)
1087{
1088 if (ti->page_mask) {
1089 *page = (index >> 8) & ti->page_mask;
1090 index &= ~(ti->page_mask << 8);
1091 }
1092 return ti->sram_virt + index;
1093}
1094
1095static void dir_open_adapter (struct net_device *dev)
1096{
1097 struct tok_info *ti = netdev_priv(dev);
1098 unsigned char ret_code;
1099 __u16 err;
1100
1101 ti->srb = map_address(ti,
1102 ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)),
1103 &ti->srb_page);
1104 ti->ssb = map_address(ti,
1105 ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)),
1106 &ti->ssb_page);
1107 ti->arb = map_address(ti,
1108 ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)),
1109 &ti->arb_page);
1110 ti->asb = map_address(ti,
1111 ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)),
1112 &ti->asb_page);
1113 ti->current_skb = NULL;
1114 ret_code = readb(ti->init_srb + RETCODE_OFST);
1115 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1116 if (!ret_code) {
1117 ti->open_status = OPEN;
1118 if (ti->open_mode == AUTOMATIC) {
1119 DPRINTK("Adapter reopened.\n");
1120 }
1121 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1122 open_sap(EXTENDED_SAP, dev);
1123 return;
1124 }
1125 ti->open_failure = YES;
1126 if (ret_code == 7){
1127 if (err == 0x24) {
1128 if (!ti->auto_speedsave) {
1129 DPRINTK("Open failed: Adapter speed must match "
1130 "ring speed if Automatic Ring Speed Save is "
1131 "disabled.\n");
1132 ti->open_action = FAIL;
1133 }else
1134 DPRINTK("Retrying open to adjust to "
1135 "ring speed, ");
1136 } else if (err == 0x2d) {
1137 DPRINTK("Physical Insertion: No Monitor Detected, ");
1138 printk("retrying after %ds delay...\n",
1139 TR_RETRY_INTERVAL/HZ);
1140 } else if (err == 0x11) {
1141 DPRINTK("Lobe Media Function Failure (0x11), ");
1142 printk(" retrying after %ds delay...\n",
1143 TR_RETRY_INTERVAL/HZ);
1144 } else {
1145 char **prphase = printphase;
1146 char **prerror = printerror;
1147 int pnr = err / 16 - 1;
1148 int enr = err % 16 - 1;
1149 DPRINTK("TR Adapter misc open failure, error code = ");
1150 if (pnr < 0 || pnr >= ARRAY_SIZE(printphase) ||
1151 enr < 0 ||
1152 enr >= ARRAY_SIZE(printerror))
1153 printk("0x%x, invalid Phase/Error.", err);
1154 else
1155 printk("0x%x, Phase: %s, Error: %s\n", err,
1156 prphase[pnr], prerror[enr]);
1157 printk(" retrying after %ds delay...\n",
1158 TR_RETRY_INTERVAL/HZ);
1159 }
1160 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1161 if (ti->open_action != FAIL) {
1162 if (ti->open_mode==AUTOMATIC){
1163 ti->open_action = REOPEN;
1164 ibmtr_reset_timer(&(ti->tr_timer), dev);
1165 return;
1166 }
1167 wake_up(&ti->wait_for_reset);
1168 return;
1169 }
1170 DPRINTK("FAILURE, CAPUT\n");
1171}
1172
1173
1174
1175static irqreturn_t tok_interrupt(int irq, void *dev_id)
1176{
1177 unsigned char status;
1178
1179 struct tok_info *ti;
1180 struct net_device *dev;
1181#ifdef ENABLE_PAGING
1182 unsigned char save_srpr;
1183#endif
1184
1185 dev = dev_id;
1186#if TR_VERBOSE
1187 DPRINTK("Int from tok_driver, dev : %p irq%d\n", dev,irq);
1188#endif
1189 ti = netdev_priv(dev);
1190 if (ti->sram_phys & 1)
1191 return IRQ_NONE;
1192 spin_lock(&(ti->lock));
1193#ifdef ENABLE_PAGING
1194 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1195#endif
1196
1197
1198 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1199
1200
1201 if (ti->adapter_int_enable)
1202 outb(0, ti->adapter_int_enable);
1203 else
1204 outb(0, ti->global_int_enable);
1205 if (ti->do_tok_int == FIRST_INT){
1206 initial_tok_int(dev);
1207#ifdef ENABLE_PAGING
1208 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1209#endif
1210 spin_unlock(&(ti->lock));
1211 return IRQ_HANDLED;
1212 }
1213
1214
1215 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1216
1217
1218
1219
1220 if (status & ADAP_CHK_INT) {
1221 int i;
1222 void __iomem *check_reason;
1223 __u8 check_reason_page = 0;
1224 check_reason = map_address(ti,
1225 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN)),
1226 &check_reason_page);
1227 SET_PAGE(check_reason_page);
1228
1229 DPRINTK("Adapter check interrupt\n");
1230 DPRINTK("8 reason bytes follow: ");
1231 for (i = 0; i < 8; i++, check_reason++)
1232 printk("%02X ", (int) readb(check_reason));
1233 printk("\n");
1234 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1235 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1236 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1237 ti->open_status = CLOSED;
1238 ti->sap_status = CLOSED;
1239 ti->open_mode = AUTOMATIC;
1240 netif_carrier_off(dev);
1241 netif_stop_queue(dev);
1242 ti->open_action = RESTART;
1243 outb(0, dev->base_addr + ADAPTRESET);
1244 ibmtr_reset_timer(&(ti->tr_timer), dev);
1245 spin_unlock(&(ti->lock));
1246 return IRQ_HANDLED;
1247 }
1248 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1249 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1250 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1251 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1252 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1253 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1254 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);
1255 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1256 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1257#ifdef ENABLE_PAGING
1258 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1259#endif
1260 spin_unlock(&(ti->lock));
1261 return IRQ_HANDLED;
1262 }
1263 if (status & SRB_RESP_INT) {
1264 SET_PAGE(ti->srb_page);
1265#if TR_VERBOSE
1266 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1267 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1268#endif
1269 switch (readb(ti->srb)) {
1270 case XMIT_DIR_FRAME:{
1271 unsigned char xmit_ret_code;
1272 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1273 if (xmit_ret_code == 0xff) break;
1274 DPRINTK("error on xmit_dir_frame request: %02X\n",
1275 xmit_ret_code);
1276 if (ti->current_skb) {
1277 dev_kfree_skb_irq(ti->current_skb);
1278 ti->current_skb = NULL;
1279 }
1280
1281 netif_wake_queue(dev);
1282 if (ti->readlog_pending)
1283 ibmtr_readlog(dev);
1284 break;
1285 }
1286 case XMIT_UI_FRAME:{
1287 unsigned char xmit_ret_code;
1288
1289 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1290 if (xmit_ret_code == 0xff) break;
1291 DPRINTK("error on xmit_ui_frame request: %02X\n",
1292 xmit_ret_code);
1293 if (ti->current_skb) {
1294 dev_kfree_skb_irq(ti->current_skb);
1295 ti->current_skb = NULL;
1296 }
1297 netif_wake_queue(dev);
1298 if (ti->readlog_pending)
1299 ibmtr_readlog(dev);
1300 break;
1301 }
1302 case DIR_OPEN_ADAPTER:
1303 dir_open_adapter(dev);
1304 break;
1305 case DLC_OPEN_SAP:
1306 if (readb(ti->srb + RETCODE_OFST)) {
1307 DPRINTK("open_sap failed: ret_code = %02X, "
1308 "retrying\n",
1309 (int) readb(ti->srb + RETCODE_OFST));
1310 ti->open_action = REOPEN;
1311 ibmtr_reset_timer(&(ti->tr_timer), dev);
1312 break;
1313 }
1314 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1315 ti->sap_status = OPEN;
1316 if (ti->open_mode==MANUAL){
1317 wake_up(&ti->wait_for_reset);
1318 break;
1319 }
1320 netif_wake_queue(dev);
1321 netif_carrier_on(dev);
1322 break;
1323 case DIR_INTERRUPT:
1324 case DIR_MOD_OPEN_PARAMS:
1325 case DIR_SET_GRP_ADDR:
1326 case DIR_SET_FUNC_ADDR:
1327 case DLC_CLOSE_SAP:
1328 if (readb(ti->srb + RETCODE_OFST))
1329 DPRINTK("error on %02X: %02X\n",
1330 (int) readb(ti->srb + COMMAND_OFST),
1331 (int) readb(ti->srb + RETCODE_OFST));
1332 break;
1333 case DIR_READ_LOG:
1334 if (readb(ti->srb + RETCODE_OFST)){
1335 DPRINTK("error on dir_read_log: %02X\n",
1336 (int) readb(ti->srb + RETCODE_OFST));
1337 netif_wake_queue(dev);
1338 break;
1339 }
1340#if IBMTR_DEBUG_MESSAGES
1341
1342#define LINE_ERRORS_OFST 0
1343#define INTERNAL_ERRORS_OFST 1
1344#define BURST_ERRORS_OFST 2
1345#define AC_ERRORS_OFST 3
1346#define ABORT_DELIMITERS_OFST 4
1347#define LOST_FRAMES_OFST 6
1348#define RECV_CONGEST_COUNT_OFST 7
1349#define FRAME_COPIED_ERRORS_OFST 8
1350#define FREQUENCY_ERRORS_OFST 9
1351#define TOKEN_ERRORS_OFST 10
1352
1353 DPRINTK("Line errors %02X, Internal errors %02X, "
1354 "Burst errors %02X\n" "A/C errors %02X, "
1355 "Abort delimiters %02X, Lost frames %02X\n"
1356 "Receive congestion count %02X, "
1357 "Frame copied errors %02X\nFrequency errors %02X, "
1358 "Token errors %02X\n",
1359 (int) readb(ti->srb + LINE_ERRORS_OFST),
1360 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1361 (int) readb(ti->srb + BURST_ERRORS_OFST),
1362 (int) readb(ti->srb + AC_ERRORS_OFST),
1363 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1364 (int) readb(ti->srb + LOST_FRAMES_OFST),
1365 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1366 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1367 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1368 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1369#endif
1370 netif_wake_queue(dev);
1371 break;
1372 default:
1373 DPRINTK("Unknown command %02X encountered\n",
1374 (int) readb(ti->srb));
1375 }
1376 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1377 }
1378 if (status & ASB_FREE_INT) {
1379 SET_PAGE(ti->asb_page);
1380#if TR_VERBOSE
1381 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1382#endif
1383
1384 switch (readb(ti->asb)) {
1385 case REC_DATA:
1386 case XMIT_UI_FRAME:
1387 case XMIT_DIR_FRAME:
1388 break;
1389 default:
1390 DPRINTK("unknown command in asb %02X\n",
1391 (int) readb(ti->asb));
1392 }
1393 if (readb(ti->asb + 2) != 0xff)
1394 DPRINTK("ASB error %02X in cmd %02X\n",
1395 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1396 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1397 }
1398
1399#define STATUS_OFST 6
1400#define NETW_STATUS_OFST 6
1401
1402 if (status & ARB_CMD_INT) {
1403 SET_PAGE(ti->arb_page);
1404#if TR_VERBOSE
1405 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1406#endif
1407
1408 switch (readb(ti->arb)) {
1409 case DLC_STATUS:
1410 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1411 ntohs(readw(ti->arb + STATUS_OFST)),
1412 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1413 break;
1414 case REC_DATA:
1415 tr_rx(dev);
1416 break;
1417 case RING_STAT_CHANGE:{
1418 unsigned short ring_status;
1419 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1420 if (ibmtr_debug_trace & TRC_INIT)
1421 DPRINTK("Ring Status Change...(0x%x)\n",
1422 ring_status);
1423 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1424 netif_stop_queue(dev);
1425 netif_carrier_off(dev);
1426 DPRINTK("Remove received, or Auto-removal error"
1427 ", or Lobe fault\n");
1428 DPRINTK("We'll try to reopen the closed adapter"
1429 " after a %d second delay.\n",
1430 TR_RETRY_INTERVAL/HZ);
1431
1432
1433
1434
1435 ti->open_mode = AUTOMATIC;
1436 ti->open_status = CLOSED;
1437 ti->open_action = REOPEN;
1438 ibmtr_reset_timer(&(ti->tr_timer), dev);
1439 } else if (ring_status & LOG_OVERFLOW) {
1440 if(netif_queue_stopped(dev))
1441 ti->readlog_pending = 1;
1442 else
1443 ibmtr_readlog(dev);
1444 }
1445 break;
1446 }
1447 case XMIT_DATA_REQ:
1448 tr_tx(dev);
1449 break;
1450 default:
1451 DPRINTK("Unknown command %02X in arb\n",
1452 (int) readb(ti->arb));
1453 break;
1454 }
1455 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1456 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1457 }
1458 if (status & SSB_RESP_INT) {
1459 unsigned char retcode;
1460 SET_PAGE(ti->ssb_page);
1461#if TR_VERBOSE
1462 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1463 readb(ti->ssb), readb(ti->ssb + 2));
1464#endif
1465
1466 switch (readb(ti->ssb)) {
1467 case XMIT_DIR_FRAME:
1468 case XMIT_UI_FRAME:
1469 retcode = readb(ti->ssb + 2);
1470 if (retcode && (retcode != 0x22))
1471 DPRINTK("xmit ret_code: %02X xmit error code: "
1472 "%02X\n",
1473 (int)retcode, (int)readb(ti->ssb + 6));
1474 else
1475 dev->stats.tx_packets++;
1476 break;
1477 case XMIT_XID_CMD:
1478 DPRINTK("xmit xid ret_code: %02X\n",
1479 (int) readb(ti->ssb + 2));
1480 default:
1481 DPRINTK("Unknown command %02X in ssb\n",
1482 (int) readb(ti->ssb));
1483 }
1484 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1485 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1486 }
1487#ifdef ENABLE_PAGING
1488 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1489#endif
1490 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1491 spin_unlock(&(ti->lock));
1492 return IRQ_HANDLED;
1493}
1494
1495
1496
1497#define INIT_STATUS_OFST 1
1498#define INIT_STATUS_2_OFST 2
1499#define ENCODED_ADDRESS_OFST 8
1500
1501static void initial_tok_int(struct net_device *dev)
1502{
1503
1504 __u32 encoded_addr, hw_encoded_addr;
1505 struct tok_info *ti;
1506 unsigned char init_status;
1507
1508 ti = netdev_priv(dev);
1509
1510 ti->do_tok_int = NOT_FIRST;
1511
1512
1513 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1514#ifndef PCMCIA
1515 ti->sram_virt = ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1516#endif
1517 ti->init_srb = map_address(ti,
1518 ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN)),
1519 &ti->init_srb_page);
1520 if (ti->page_mask && ti->avail_shared_ram == 127) {
1521 void __iomem *last_512;
1522 __u8 last_512_page=0;
1523 int i;
1524 last_512 = map_address(ti, 0xfe00, &last_512_page);
1525
1526 SET_PAGE(last_512_page);
1527 for (i = 0; i < 512; i++)
1528 writeb(0, last_512 + i);
1529 }
1530 SET_PAGE(ti->init_srb_page);
1531
1532#if TR_VERBOSE
1533 {
1534 int i;
1535
1536 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1537 DPRINTK("init_srb(%p):", ti->init_srb );
1538 for (i = 0; i < 20; i++)
1539 printk("%02X ", (int) readb(ti->init_srb + i));
1540 printk("\n");
1541 }
1542#endif
1543
1544 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1545 encoded_addr = ntohs(hw_encoded_addr);
1546 init_status=
1547 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1548
1549 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1550 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1551 ti->ring_speed, (unsigned int)dev->mem_start);
1552 ti->auto_speedsave = (readb(ti->init_srb+INIT_STATUS_2_OFST) & 4) != 0;
1553
1554 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1555 else tok_open_adapter((unsigned long)dev);
1556
1557}
1558
1559
1560
1561#define CMD_CORRELATE_OFST 1
1562#define DHB_ADDRESS_OFST 6
1563
1564#define FRAME_LENGTH_OFST 6
1565#define HEADER_LENGTH_OFST 8
1566#define RSAP_VALUE_OFST 9
1567
1568static void tr_tx(struct net_device *dev)
1569{
1570 struct tok_info *ti = netdev_priv(dev);
1571 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1572 unsigned int hdr_len;
1573 __u32 dhb=0,dhb_base;
1574 void __iomem *dhbuf = NULL;
1575 unsigned char xmit_command;
1576 int i,dhb_len=0x4000,src_len,src_offset;
1577 struct trllc *llc;
1578 struct srb_xmit xsrb;
1579 __u8 dhb_page = 0;
1580 __u8 llc_ssap;
1581
1582 SET_PAGE(ti->asb_page);
1583
1584 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1585
1586
1587
1588
1589
1590 SET_PAGE(ti->arb_page);
1591 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1592 if (ti->page_mask) {
1593 dhb_page = (dhb_base >> 8) & ti->page_mask;
1594 dhb=dhb_base & ~(ti->page_mask << 8);
1595 }
1596 dhbuf = ti->sram_virt + dhb;
1597
1598
1599 if (!(trhdr->saddr[0] & 0x80))
1600 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1601 else
1602 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1603 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1604
1605 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1606
1607 llc_ssap = llc->ssap;
1608 SET_PAGE(ti->srb_page);
1609 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1610 SET_PAGE(ti->asb_page);
1611 xmit_command = xsrb.command;
1612
1613 writeb(xmit_command, ti->asb + COMMAND_OFST);
1614 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1615 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1616 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1617 writeb(0, ti->asb + RETCODE_OFST);
1618 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1619 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1620 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1621 SET_PAGE(dhb_page);
1622 writeb(AC, dhbuf);
1623 writeb(LLC_FRAME, dhbuf + 1);
1624 for (i = 0; i < TR_ALEN; i++)
1625 writeb((int) 0x0FF, dhbuf + i + 2);
1626 for (i = 0; i < TR_ALEN; i++)
1627 writeb(0, dhbuf + i + TR_ALEN + 2);
1628 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1629 return;
1630 }
1631
1632
1633
1634
1635 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1636 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1637 src_len=ti->current_skb->len;
1638 src_offset=0;
1639 dhb=dhb_base;
1640 while(1) {
1641 if (ti->page_mask) {
1642 dhb_page=(dhb >> 8) & ti->page_mask;
1643 dhb=dhb & ~(ti->page_mask << 8);
1644 dhb_len=0x4000-dhb;
1645 }
1646 dhbuf = ti->sram_virt + dhb;
1647 SET_PAGE(dhb_page);
1648 if (src_len > dhb_len) {
1649 memcpy_toio(dhbuf,&ti->current_skb->data[src_offset],
1650 dhb_len);
1651 src_len -= dhb_len;
1652 src_offset += dhb_len;
1653 dhb_base+=dhb_len;
1654 dhb=dhb_base;
1655 continue;
1656 }
1657 memcpy_toio(dhbuf, &ti->current_skb->data[src_offset], src_len);
1658 break;
1659 }
1660 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1661 dev->stats.tx_bytes += ti->current_skb->len;
1662 dev_kfree_skb_irq(ti->current_skb);
1663 ti->current_skb = NULL;
1664 netif_wake_queue(dev);
1665 if (ti->readlog_pending)
1666 ibmtr_readlog(dev);
1667}
1668
1669
1670
1671
1672#define RECEIVE_BUFFER_OFST 6
1673#define LAN_HDR_LENGTH_OFST 8
1674#define DLC_HDR_LENGTH_OFST 9
1675
1676#define DSAP_OFST 0
1677#define SSAP_OFST 1
1678#define LLC_OFST 2
1679#define PROTID_OFST 3
1680#define ETHERTYPE_OFST 6
1681
1682static void tr_rx(struct net_device *dev)
1683{
1684 struct tok_info *ti = netdev_priv(dev);
1685 __u32 rbuffer;
1686 void __iomem *rbuf, *rbufdata, *llc;
1687 __u8 rbuffer_page = 0;
1688 unsigned char *data;
1689 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1690 unsigned char dlc_hdr_len;
1691 struct sk_buff *skb;
1692 unsigned int skb_size = 0;
1693 int IPv4_p = 0;
1694 unsigned int chksum = 0;
1695 struct iphdr *iph;
1696 struct arb_rec_req rarb;
1697
1698 SET_PAGE(ti->arb_page);
1699 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1700 rbuffer = ntohs(rarb.rec_buf_addr) ;
1701 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1702
1703 SET_PAGE(ti->asb_page);
1704
1705 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1706
1707 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1708 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1709 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1710
1711 lan_hdr_len = rarb.lan_hdr_len;
1712 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1713 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1714 return;
1715 }
1716 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1717 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1718
1719 SET_PAGE(rbuffer_page);
1720 llc = rbuf + offsetof(struct rec_buf, data) + lan_hdr_len;
1721
1722#if TR_VERBOSE
1723 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1724 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1725 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1726 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1727 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1728 "ethertype: %04X\n",
1729 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1730 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1731 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1732 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1733#endif
1734 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1735 SET_PAGE(ti->asb_page);
1736 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1737 dev->stats.rx_dropped++;
1738 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1739 return;
1740 }
1741 length = ntohs(rarb.frame_len);
1742 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1743 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1744 length >= hdr_len) IPv4_p = 1;
1745#if TR_VERBOSE
1746#define SADDR_OFST 8
1747#define DADDR_OFST 2
1748
1749 if (!IPv4_p) {
1750
1751 void __iomem *trhhdr = rbuf + offsetof(struct rec_buf, data);
1752 u8 saddr[6];
1753 u8 daddr[6];
1754 int i;
1755 for (i = 0 ; i < 6 ; i++)
1756 saddr[i] = readb(trhhdr + SADDR_OFST + i);
1757 for (i = 0 ; i < 6 ; i++)
1758 daddr[i] = readb(trhhdr + DADDR_OFST + i);
1759 DPRINTK("Probably non-IP frame received.\n");
1760 DPRINTK("ssap: %02X dsap: %02X "
1761 "saddr: %pM daddr: %pM\n",
1762 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1763 saddr, daddr);
1764 }
1765#endif
1766
1767
1768 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1769
1770 if (!(skb = dev_alloc_skb(skb_size))) {
1771 DPRINTK("out of memory. frame dropped.\n");
1772 dev->stats.rx_dropped++;
1773 SET_PAGE(ti->asb_page);
1774 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1775 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1776 return;
1777 }
1778
1779 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1780 skb_put(skb, length);
1781 data = skb->data;
1782 rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len)));
1783 rbufdata = rbuf + offsetof(struct rec_buf, data);
1784
1785 if (IPv4_p) {
1786
1787 memcpy_fromio(data, rbufdata, hdr_len);
1788
1789
1790 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1791 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1792 length -= hdr_len;
1793 if ((ip_len <= length) && (ip_len > 7))
1794 length = ip_len;
1795 data += hdr_len;
1796 rbuffer_len -= hdr_len;
1797 rbufdata += hdr_len;
1798 }
1799
1800#define BUFFER_POINTER_OFST 2
1801#define BUFFER_LENGTH_OFST 6
1802 for (;;) {
1803 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1804 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1805 length,rbuffer_len);
1806 if (IPv4_p)
1807 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1808 data,length<rbuffer_len?length:rbuffer_len,chksum);
1809 else
1810 memcpy_fromio(data, rbufdata, rbuffer_len);
1811 rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ;
1812 if (!rbuffer)
1813 break;
1814 rbuffer -= 2;
1815 length -= rbuffer_len;
1816 data += rbuffer_len;
1817 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1818 SET_PAGE(rbuffer_page);
1819 rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST));
1820 rbufdata = rbuf + offsetof(struct rec_buf, data);
1821 }
1822
1823 SET_PAGE(ti->asb_page);
1824 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1825
1826 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1827
1828 dev->stats.rx_bytes += skb->len;
1829 dev->stats.rx_packets++;
1830
1831 skb->protocol = tr_type_trans(skb, dev);
1832 if (IPv4_p) {
1833 skb->csum = chksum;
1834 skb->ip_summed = CHECKSUM_COMPLETE;
1835 }
1836 netif_rx(skb);
1837}
1838
1839
1840
1841static void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1842{
1843 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1844 tmr->data = (unsigned long) dev;
1845 tmr->function = tok_rerun;
1846 init_timer(tmr);
1847 add_timer(tmr);
1848}
1849
1850
1851
1852static void tok_rerun(unsigned long dev_addr)
1853{
1854 struct net_device *dev = (struct net_device *)dev_addr;
1855 struct tok_info *ti = netdev_priv(dev);
1856
1857 if ( ti->open_action == RESTART){
1858 ti->do_tok_int = FIRST_INT;
1859 outb(0, dev->base_addr + ADAPTRESETREL);
1860#ifdef ENABLE_PAGING
1861 if (ti->page_mask)
1862 writeb(SRPR_ENABLE_PAGING,
1863 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1864#endif
1865
1866 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1867 } else
1868 tok_open_adapter(dev_addr);
1869}
1870
1871
1872
1873static void ibmtr_readlog(struct net_device *dev)
1874{
1875 struct tok_info *ti;
1876
1877 ti = netdev_priv(dev);
1878
1879 ti->readlog_pending = 0;
1880 SET_PAGE(ti->srb_page);
1881 writeb(DIR_READ_LOG, ti->srb);
1882 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1883 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1884
1885 netif_stop_queue(dev);
1886
1887}
1888
1889
1890
1891static int ibmtr_change_mtu(struct net_device *dev, int mtu)
1892{
1893 struct tok_info *ti = netdev_priv(dev);
1894
1895 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1896 return -EINVAL;
1897 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1898 return -EINVAL;
1899 dev->mtu = mtu;
1900 return 0;
1901}
1902
1903
1904#ifdef MODULE
1905
1906
1907static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1908static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1909static int irq[IBMTR_MAX_ADAPTERS];
1910static int mem[IBMTR_MAX_ADAPTERS];
1911
1912MODULE_LICENSE("GPL");
1913
1914module_param_array(io, int, NULL, 0);
1915module_param_array(irq, int, NULL, 0);
1916module_param_array(mem, int, NULL, 0);
1917
1918static int __init ibmtr_init(void)
1919{
1920 int i;
1921 int count=0;
1922
1923 find_turbo_adapters(io);
1924
1925 for (i = 0; i < IBMTR_MAX_ADAPTERS && io[i]; i++) {
1926 struct net_device *dev;
1927 irq[i] = 0;
1928 mem[i] = 0;
1929 dev = alloc_trdev(sizeof(struct tok_info));
1930 if (dev == NULL) {
1931 if (i == 0)
1932 return -ENOMEM;
1933 break;
1934 }
1935 dev->base_addr = io[i];
1936 dev->irq = irq[i];
1937 dev->mem_start = mem[i];
1938
1939 if (ibmtr_probe_card(dev)) {
1940 free_netdev(dev);
1941 continue;
1942 }
1943 dev_ibmtr[i] = dev;
1944 count++;
1945 }
1946 if (count) return 0;
1947 printk("ibmtr: register_netdev() returned non-zero.\n");
1948 return -EIO;
1949}
1950module_init(ibmtr_init);
1951
1952static void __exit ibmtr_cleanup(void)
1953{
1954 int i;
1955
1956 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1957 if (!dev_ibmtr[i])
1958 continue;
1959 unregister_netdev(dev_ibmtr[i]);
1960 ibmtr_cleanup_card(dev_ibmtr[i]);
1961 free_netdev(dev_ibmtr[i]);
1962 }
1963}
1964module_exit(ibmtr_cleanup);
1965#endif
1966