1 /* ibmtr.c: A shared-memory IBM Token Ring 16/4 driver for linux
3 * Written 1993 by Mark Swanson and Peter De Schrijver.
4 * This software may be used and distributed according to the terms
5 * of the GNU General Public License, incorporated herein by reference.
7 * This device driver should work with Any IBM Token Ring Card that does
10 * I used Donald Becker's (becker@scyld.com) device driver work
11 * as a base for most of my initial work.
13 * Changes by Peter De Schrijver
14 * (Peter.Deschrijver@linux.cc.kuleuven.ac.be) :
16 * + changed name to ibmtr.c in anticipation of other tr boards.
17 * + changed reset code and adapter open code.
18 * + added SAP open code.
19 * + a first attempt to write interrupt, transmit and receive routines.
21 * Changes by David W. Morris (dwm@shell.portal.com) :
22 * 941003 dwm: - Restructure tok_probe for multiple adapters, devices.
23 * + Add comments, misc reorg for clarity.
24 * + Flatten interrupt handler levels.
26 * Changes by Farzad Farid (farzy@zen.via.ecp.fr)
27 * and Pascal Andre (andre@chimay.via.ecp.fr) (March 9 1995) :
28 * + multi ring support clean up.
29 * + RFC1042 compliance enhanced.
31 * Changes by Pascal Andre (andre@chimay.via.ecp.fr) (September 7 1995) :
32 * + bug correction in tr_tx
33 * + removed redundant information display
34 * + some code reworking
36 * Changes by Michel Lespinasse (walken@via.ecp.fr),
37 * Yann Doussot (doussot@via.ecp.fr) and Pascal Andre (andre@via.ecp.fr)
38 * (February 18, 1996) :
39 * + modified shared memory and mmio access port the driver to
40 * alpha platform (structure access -> readb/writeb)
42 * Changes by Steve Kipisz (bungy@ibm.net or kipisz@vnet.ibm.com)
44 * + swapped WWOR and WWCR in ibmtr.h
45 * + moved some init code from tok_probe into trdev_init. The
46 * PCMCIA code can call trdev_init to complete initializing
48 * + added -DPCMCIA to support PCMCIA
49 * + detecting PCMCIA Card Removal in interrupt handler. If
50 * ISRP is FF, then a PCMCIA card has been removed
51 * 10/2000 Burt needed a new method to avoid crashing the OS
53 * Changes by Paul Norton (pnorton@cts.com) :
54 * + restructured the READ.LOG logic to prevent the transmit SRB
55 * from being rudely overwritten before the transmit cycle is
56 * complete. (August 15 1996)
57 * + completed multiple adapter support. (November 20 1996)
58 * + implemented csum_partial_copy in tr_rx and increased receive
59 * buffer size and count. Minor fixes. (March 15, 1997)
61 * Changes by Christopher Turcksin <wabbit@rtfc.demon.co.uk>
62 * + Now compiles ok as a module again.
64 * Changes by Paul Norton (pnorton@ieee.org) :
65 * + moved the header manipulation code in tr_tx and tr_rx to
66 * net/802/tr.c. (July 12 1997)
67 * + add retry and timeout on open if cable disconnected. (May 5 1998)
68 * + lifted 2000 byte mtu limit. now depends on shared-RAM size.
70 * + can't allocate 2k recv buff at 8k shared-RAM. (20 October 1998)
72 * Changes by Joel Sloan (jjs@c-me.com) :
73 * + disable verbose debug messages by default - to enable verbose
74 * debugging, edit the IBMTR_DEBUG_MESSAGES define below
76 * Changes by Mike Phillips <phillim@amtrak.com> :
77 * + Added extra #ifdef's to work with new PCMCIA Token Ring Code.
78 * The PCMCIA code now just sets up the card so it can be recognized
79 * by ibmtr_probe. Also checks allocated memory vs. on-board memory
80 * for correct figure to use.
82 * Changes by Tim Hockin (thockin@isunix.it.ilstu.edu) :
83 * + added spinlocks for SMP sanity (10 March 1999)
85 * Changes by Jochen Friedrich to enable RFC1469 Option 2 multicasting
86 * i.e. using functional address C0 00 00 04 00 00 to transmit and
87 * receive multicast packets.
89 * Changes by Mike Sullivan (based on original sram patch by Dave Grothe
90 * to support windowing into on adapter shared ram.
91 * i.e. Use LANAID to setup a PnP configuration with 16K RAM. Paging
92 * will shift this 16K window over the entire available shared RAM.
94 * Changes by Peter De Schrijver (p2@mind.be) :
95 * + fixed a problem with PCMCIA card removal
97 * Change by Mike Sullivan et al.:
98 * + added turbo card support. No need to use lanaid to configure
99 * the adapter into isa compatiblity mode.
101 * Changes by Burt Silverman to allow the computer to behave nicely when
102 * a cable is pulled or not in place, or a PCMCIA card is removed hot.
105 /* change the define of IBMTR_DEBUG_MESSAGES to a nonzero value
106 in the event that chatty debug messages are desired - jjs 12/30/98 */
108 #define IBMTR_DEBUG_MESSAGES 0
110 #include <linux/module.h>
112 #ifdef PCMCIA /* required for ibmtr_cs.c to build */
113 #undef MODULE /* yes, really */
116 #define ENABLE_PAGING 1
120 #define TRUE (!FALSE)
122 /* changes the output format of driver initialization */
125 /* some 95 OS send many non UI frame; this allow removing the warning */
126 #define TR_FILTERNONUI 1
128 #include <linux/ioport.h>
129 #include <linux/netdevice.h>
130 #include <linux/trdevice.h>
131 #include <linux/ibmtr.h>
133 #include <net/checksum.h>
137 #define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args)
138 #define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args)
140 /* version and credits */
142 static char version[] __initdata =
143 "\nibmtr.c: v1.3.57 8/ 7/94 Peter De Schrijver and Mark Swanson\n"
144 " v2.1.125 10/20/98 Paul Norton <pnorton@ieee.org>\n"
145 " v2.2.0 12/30/98 Joel Sloan <jjs@c-me.com>\n"
146 " v2.2.1 02/08/00 Mike Sullivan <sullivam@us.ibm.com>\n"
147 " v2.2.2 07/27/00 Burt Silverman <burts@us.ibm.com>\n"
148 " v2.4.0 03/01/01 Mike Sullivan <sullivan@us.ibm.com>\n";
151 /* this allows displaying full adapter information */
153 char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" };
155 static char pcchannelid[] __devinitdata = {
156 0x05, 0x00, 0x04, 0x09,
157 0x04, 0x03, 0x04, 0x0f,
158 0x03, 0x06, 0x03, 0x01,
159 0x03, 0x01, 0x03, 0x00,
160 0x03, 0x09, 0x03, 0x09,
161 0x03, 0x00, 0x02, 0x00
164 static char mcchannelid[] __devinitdata = {
165 0x04, 0x0d, 0x04, 0x01,
166 0x05, 0x02, 0x05, 0x03,
167 0x03, 0x06, 0x03, 0x03,
168 0x05, 0x08, 0x03, 0x04,
169 0x03, 0x05, 0x03, 0x01,
170 0x03, 0x08, 0x02, 0x00
173 char __devinit *adapter_def(char type)
176 case 0xF: return "PC Adapter | PC Adapter II | Adapter/A";
177 case 0xE: return "16/4 Adapter | 16/4 Adapter/A (long)";
178 case 0xD: return "16/4 Adapter/A (short) | 16/4 ISA-16 Adapter";
179 case 0xC: return "Auto 16/4 Adapter";
180 default: return "adapter (unknown type)";
184 #define TRC_INIT 0x01 /* Trace initialization & PROBEs */
185 #define TRC_INITV 0x02 /* verbose init trace points */
186 unsigned char ibmtr_debug_trace = 0;
188 static int ibmtr_probe(struct net_device *dev);
189 static int ibmtr_probe1(struct net_device *dev, int ioaddr);
190 static unsigned char get_sram_size(struct tok_info *adapt_info);
191 static int trdev_init(struct net_device *dev);
192 static int tok_open(struct net_device *dev);
193 static int tok_init_card(struct net_device *dev);
194 void tok_open_adapter(unsigned long dev_addr);
195 static void open_sap(unsigned char type, struct net_device *dev);
196 static void tok_set_multicast_list(struct net_device *dev);
197 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev);
198 static int tok_close(struct net_device *dev);
199 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs);
200 static void initial_tok_int(struct net_device *dev);
201 static void tr_tx(struct net_device *dev);
202 static void tr_rx(struct net_device *dev);
203 void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev);
204 static void tok_rerun(unsigned long dev_addr);
205 void ibmtr_readlog(struct net_device *dev);
206 static struct net_device_stats *tok_get_stats(struct net_device *dev);
207 int ibmtr_change_mtu(struct net_device *dev, int mtu);
208 static void find_turbo_adapters(int *iolist);
210 static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = {
211 0xa20, 0xa24, 0, 0, 0
213 static int __devinitdata turbo_io[IBMTR_MAX_ADAPTERS] = {0};
214 static int __devinitdata turbo_irq[IBMTR_MAX_ADAPTERS] = {0};
215 static int __devinitdata turbo_searched = 0;
218 static __u32 ibmtr_mem_base __initdata = 0xd0000;
221 static void __devinit PrtChanID(char *pcid, short stride)
224 for (i = 0, j = 0; i < 24; i++, j += stride)
225 printk("%1x", ((int) pcid[j]) & 0x0f);
229 static void __devinit HWPrtChanID(void * pcid, short stride)
232 for (i = 0, j = 0; i < 24; i++, j += stride)
233 printk("%1x", ((int) readb(pcid + j)) & 0x0f);
237 /* We have to ioremap every checked address, because isa_readb is
241 static void __devinit find_turbo_adapters(int *iolist) {
246 unsigned char *tchanid, ctemp;
251 if (turbo_searched == 1) return;
253 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
258 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
259 if (ram_mapped==NULL)
261 chanid=(CHANNEL_ID + ram_mapped);
263 ctemp=readb(chanid) & 0x0f;
264 if (ctemp != *tchanid) continue;
265 for (i=2,j=1; i<=46; i=i+2,j++) {
266 if ((readb(chanid+i) & 0x0f) != tchanid[j]){
271 if (!found_turbo) continue;
273 writeb(0x90, ram_mapped+0x1E01);
274 for(i=2; i<0x0f; i++) {
275 writeb(0x00, ram_mapped+0x1E01+i);
277 writeb(0x00, ram_mapped+0x1E01);
278 for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif););
279 intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN));
281 #if IBMTR_DEBUG_MESSAGES
282 printk("ibmtr::find_turbo_adapters, Turbo found at "
283 "ram_addr %x\n",ram_addr);
284 printk("ibmtr::find_turbo_adapters, interface_table ");
286 printk("%x:",readb(ram_addr+intf_tbl+i));
290 turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4));
291 turbo_irq[index]=readb(ram_mapped+intf_tbl+3);
292 outb(0, turbo_io[index] + ADAPTRESET);
293 for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif););
294 outb(0, turbo_io[index] + ADAPTRESETREL);
298 #if IBMTR_DEBUG_MESSAGES
299 printk("ibmtr::find_turbo_adapters, ibmtr card found at"
300 " %x but not a Turbo model\n",ram_addr);
302 iounmap(ram_mapped) ;
304 for(i=0; i<IBMTR_MAX_ADAPTERS; i++) {
305 if(!turbo_io[i]) break;
306 for (j=0; j<IBMTR_MAX_ADAPTERS; j++) {
307 if ( iolist[j] && iolist[j] != turbo_io[i]) continue;
308 iolist[j]=turbo_io[i];
314 static void ibmtr_cleanup_card(struct net_device *dev)
316 if (dev->base_addr) {
317 outb(0,dev->base_addr+ADAPTRESET);
319 schedule_timeout(TR_RST_TIME); /* wait 50ms */
321 outb(0,dev->base_addr+ADAPTRESETREL);
325 free_irq(dev->irq, dev);
326 release_region(dev->base_addr, IBMTR_IO_EXTENT);
329 struct tok_info *ti = (struct tok_info *) dev->priv;
330 iounmap((u32 *)ti->mmio);
331 iounmap((u32 *)ti->sram_virt);
336 int ibmtr_probe_card(struct net_device *dev)
338 int err = ibmtr_probe(dev);
340 err = register_netdev(dev);
342 ibmtr_cleanup_card(dev);
347 /****************************************************************************
348 * ibmtr_probe(): Routine specified in the network device structure
349 * to probe for an IBM Token Ring Adapter. Routine outline:
350 * I. Interrogate hardware to determine if an adapter exists
351 * and what the speeds and feeds are
352 * II. Setup data structures to control execution based upon
353 * adapter characteristics.
355 * We expect ibmtr_probe to be called once for each device entry
356 * which references it.
357 ****************************************************************************/
359 static int ibmtr_probe(struct net_device *dev)
362 int base_addr = dev->base_addr;
364 if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */
366 if (base_addr > 0x1ff) { /* Check a single specified location. */
367 if (!ibmtr_probe1(dev, base_addr)) return 0;
370 find_turbo_adapters(ibmtr_portlist);
371 for (i = 0; ibmtr_portlist[i]; i++) {
372 int ioaddr = ibmtr_portlist[i];
374 if (!ibmtr_probe1(dev, ioaddr)) return 0;
379 /*****************************************************************************/
381 static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
384 unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0;
386 struct tok_info *ti = dev->priv;
388 unsigned char *tchanid, ctemp;
390 unsigned char t_irq=0;
391 unsigned long timeout;
392 static int version_printed;
395 /* Query the adapter PIO base port which will return
396 * indication of where MMIO was placed. We also have a
397 * coded interrupt number.
399 segment = inb(PIOaddr);
400 if (segment < 0x40 || segment > 0xe0) {
401 /* Out of range values so we'll assume non-existent IO device
402 * but this is not necessarily a problem, esp if a turbo
403 * adapter is being used. */
404 #if IBMTR_DEBUG_MESSAGES
405 DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, "
406 "Hardware Problem?\n",PIOaddr,segment);
411 * Compute the linear base address of the MMIO area
412 * as LINUX doesn't care about segments
414 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
416 DPRINTK("Cannot remap mmiobase memory area") ;
419 intr = segment & 0x03; /* low bits is coded interrupt # */
420 if (ibmtr_debug_trace & TRC_INIT)
421 DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n"
422 , PIOaddr, (int) segment, t_mmio, (int) intr);
425 * Now we will compare expected 'channelid' strings with
426 * what we is there to learn of ISA/MCA or not TR card
430 t_mmio = (void *)ti->mmio; /*BMS to get virtual address */
431 irq = ti->irq; /*BMS to display the irq! */
433 cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */
434 tchanid = pcchannelid;
435 cardpresent = TR_ISA; /* try ISA */
437 /* Suboptimize knowing first byte different */
438 ctemp = readb(cd_chanid) & 0x0f;
439 if (ctemp != *tchanid) { /* NOT ISA card, try MCA */
440 tchanid = mcchannelid;
441 cardpresent = TR_MCA;
442 if (ctemp != *tchanid) /* Neither ISA nor MCA */
445 if (cardpresent != NOTOK) {
446 /* Know presumed type, try rest of ID */
447 for (i = 2, j = 1; i <= 46; i = i + 2, j++) {
448 if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue;
449 /* match failed, not TR card */
455 * If we have an ISA board check for the ISA P&P version,
456 * as it has different IRQ settings
458 if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e))
459 cardpresent = TR_ISAPNP;
460 if (cardpresent == NOTOK) { /* "channel_id" did not match, report */
461 if (!(ibmtr_debug_trace & TRC_INIT)) {
467 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
469 DPRINTK("Expected for ISA: ");
470 PrtChanID(pcchannelid, 1);
472 /* BMS Note that this can be misleading, when hardware is flaky, because you
473 are reading it a second time here. So with my flaky hardware, I'll see my-
474 self in this block, with the HW ID matching the ISA ID exactly! */
475 HWPrtChanID(cd_chanid, 2);
476 DPRINTK("Expected for MCA: ");
477 PrtChanID(mcchannelid, 1);
479 /* Now, setup some of the pl0 buffers for this driver.. */
480 /* If called from PCMCIA, it is already set up, so no need to
481 waste the memory, just use the existing structure */
484 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
485 if (turbo_io[i] != PIOaddr)
487 #if IBMTR_DEBUG_MESSAGES
488 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
492 t_irq = turbo_irq[i];
495 ti->readlog_pending = 0;
496 init_waitqueue_head(&ti->wait_for_reset);
498 /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP
499 * depending which card is inserted. */
502 switch (cardpresent) {
504 if (intr == 0) irq = 9; /* irq2 really is irq9 */
505 if (intr == 1) irq = 3;
506 if (intr == 2) irq = 6;
507 if (intr == 3) irq = 7;
508 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
511 if (intr == 0) irq = 9;
512 if (intr == 1) irq = 3;
513 if (intr == 2) irq = 10;
514 if (intr == 3) irq = 11;
515 ti->global_int_enable = 0;
516 ti->adapter_int_enable = 0;
517 ti->sram_virt=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12;
521 if (intr == 0) irq = 9;
522 if (intr == 1) irq = 3;
523 if (intr == 2) irq = 10;
524 if (intr == 3) irq = 11;
527 timeout = jiffies + TR_SPIN_INTERVAL;
528 while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){
529 if (!time_after(jiffies, timeout)) continue;
530 DPRINTK( "Hardware timeout during initialization.\n");
536 ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12);
537 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
539 } /*end switch (cardpresent) */
540 #endif /*not PCMCIA */
542 if (ibmtr_debug_trace & TRC_INIT) { /* just report int */
543 DPRINTK("irq=%d", irq);
544 printk(", sram_virt=0x%x", ti->sram_virt);
545 if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */
546 DPRINTK(", ti->mmio=%p", ti->mmio);
547 printk(", segment=%02X", segment);
552 /* Get hw address of token ring card */
554 for (i = 0; i < 0x18; i = i + 2) {
555 /* technical reference states to do this */
556 temp = readb(ti->mmio + AIP + i) & 0x0f;
557 ti->hw_address[j] = temp;
559 dev->dev_addr[(j / 2)] =
560 ti->hw_address[j]+ (ti->hw_address[j - 1] << 4);
563 /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */
564 ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);
566 /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */
567 ti->data_rate = readb(ti->mmio + AIPDATARATE);
569 /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */
570 ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);
572 /* How much shared RAM is on adapter ? */
574 ti->avail_shared_ram=127;
576 ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */
578 /* We need to set or do a bunch of work here based on previous results*/
579 /* Support paging? What sizes?: F=no, E=16k, D=32k, C=16 & 32k */
580 ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE);
582 /* Available DHB 4Mb size: F=2048, E=4096, D=4464 */
583 switch (readb(ti->mmio + AIP4MBDHB)) {
584 case 0xe: ti->dhb_size4mb = 4096; break;
585 case 0xd: ti->dhb_size4mb = 4464; break;
586 default: ti->dhb_size4mb = 2048; break;
589 /* Available DHB 16Mb size: F=2048, E=4096, D=8192, C=16384, B=17960 */
590 switch (readb(ti->mmio + AIP16MBDHB)) {
591 case 0xe: ti->dhb_size16mb = 4096; break;
592 case 0xd: ti->dhb_size16mb = 8192; break;
593 case 0xc: ti->dhb_size16mb = 16384; break;
594 case 0xb: ti->dhb_size16mb = 17960; break;
595 default: ti->dhb_size16mb = 2048; break;
598 /* We must figure out how much shared memory space this adapter
599 * will occupy so that if there are two adapters we can fit both
600 * in. Given a choice, we will limit this adapter to 32K. The
601 * maximum space will will use for two adapters is 64K so if the
602 * adapter we are working on demands 64K (it also doesn't support
603 * paging), then only one adapter can be supported.
607 * determine how much of total RAM is mapped into PC space
609 ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/
610 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4);
612 if (ti->turbo) ti->page_mask=0xf0;
613 else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */
616 unsigned char pg_size = 0;
617 /* BMS: page size: PCMCIA, use configuration register;
618 ISAPNP, use LANAIDC config tool from www.ibm.com */
619 switch (ti->shared_ram_paging) {
623 ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0;
624 pg_size = 32; /* 16KB page size */
627 ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0;
628 pg_size = 64; /* 32KB page size */
631 switch (ti->mapped_ram_size) {
633 ti->page_mask = 0xc0;
637 ti->page_mask = 0x80;
643 DPRINTK("Unknown shared ram paging info %01X\n",
644 ti->shared_ram_paging);
649 } /*end switch shared_ram_paging */
651 if (ibmtr_debug_trace & TRC_INIT)
652 DPRINTK("Shared RAM paging code: %02X, "
653 "mapped RAM size: %dK, shared RAM size: %dK, "
654 "page mask: %02X\n:",
655 ti->shared_ram_paging, ti->mapped_ram_size / 2,
656 ti->avail_shared_ram / 2, ti->page_mask);
657 #endif /*ENABLE_PAGING */
661 /* finish figuring the shared RAM address */
662 if (cardpresent == TR_ISA) {
663 static __u32 ram_bndry_mask[] =
664 { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 };
665 __u32 new_base, rrr_32, chk_base, rbm;
667 rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03;
668 rbm = ram_bndry_mask[rrr_32];
669 new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */
670 chk_base = new_base + (ti->mapped_ram_size << 9);
671 if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) {
672 DPRINTK("Shared RAM for this adapter (%05x) exceeds "
673 "driver limit (%05x), adapter not started.\n",
674 chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
678 } else { /* seems cool, record what we have figured out */
679 ti->sram_base = new_base >> 12;
680 ibmtr_mem_base = chk_base;
683 else ti->sram_base = ti->sram_virt >> 12;
685 /* The PCMCIA has already got the interrupt line and the io port,
686 so no chance of anybody else getting it - MLP */
687 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
688 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
694 /*?? Now, allocate some of the PIO PORTs for this driver.. */
695 /* record PIOaddr range as busy */
696 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
697 DPRINTK("Could not grab PIO range. Halting driver.\n");
698 free_irq(dev->irq, dev);
704 if (!version_printed++) {
708 DPRINTK("%s %s found\n",
709 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
710 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
711 irq, PIOaddr, ti->mapped_ram_size / 2);
712 DPRINTK("Hardware address : %02X:%02X:%02X:%02X:%02X:%02X\n",
713 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
714 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
716 DPRINTK("Shared RAM paging enabled. "
717 "Page size: %uK Shared Ram size %dK\n",
718 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
720 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
723 /* Calculate the maximum DHB we can use */
724 /* two cases where avail_shared_ram doesn't equal mapped_ram_size:
725 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical)
726 2. user has configured adapter for less than avail_shared_ram
727 but is not using paging (she should use paging, I believe)
729 if (!ti->page_mask) {
730 ti->avail_shared_ram=
731 min(ti->mapped_ram_size,ti->avail_shared_ram);
734 switch (ti->avail_shared_ram) {
735 case 16: /* 8KB shared RAM */
736 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
737 ti->rbuf_len4 = 1032;
739 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
740 ti->rbuf_len16 = 1032;
743 case 32: /* 16KB shared RAM */
744 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
745 ti->rbuf_len4 = 1032;
747 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
748 ti->rbuf_len16 = 1032; /*1024 usable */
751 case 64: /* 32KB shared RAM */
752 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
753 ti->rbuf_len4 = 1032;
755 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
756 ti->rbuf_len16 = 1032;
759 case 127: /* 63.5KB shared RAM */
760 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
761 ti->rbuf_len4 = 1032;
763 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
764 ti->rbuf_len16 = 1032;
767 case 128: /* 64KB shared RAM */
768 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
769 ti->rbuf_len4 = 1032;
771 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
772 ti->rbuf_len16 = 1032;
776 ti->dhb_size4mb = 2048;
777 ti->rbuf_len4 = 1032;
779 ti->dhb_size16mb = 2048;
780 ti->rbuf_len16 = 1032;
784 /* this formula is not smart enough for the paging case
785 ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE -
786 ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH -
787 DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB -
788 SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>;
790 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
791 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
792 /*BMS assuming 18 bytes of Routing Information (usually works) */
793 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
794 ti->maxmtu16, ti->maxmtu4);
796 dev->base_addr = PIOaddr; /* set the value for device */
797 dev->mem_start = ti->sram_base << 12;
798 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
800 return 0; /* Return 0 to indicate we have found a Token Ring card. */
801 } /*ibmtr_probe1() */
803 /*****************************************************************************/
805 /* query the adapter for the size of shared RAM */
806 /* the function returns the RAM size in units of 512 bytes */
808 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
810 unsigned char avail_sram_code;
811 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
813 'F' -- use RRR bits 3,2
814 'E' -- 8kb 'D' -- 16kb
815 'C' -- 32kb 'A' -- 64KB
816 'B' - 64KB less 512 bytes at top
817 (WARNING ... must zero top bytes in INIT */
819 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
820 if (avail_sram_code) return size_code[avail_sram_code];
821 else /* for code 'F', must compute size from RRR(3,2) bits */
823 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
826 /*****************************************************************************/
828 static int __devinit trdev_init(struct net_device *dev)
830 struct tok_info *ti = (struct tok_info *) dev->priv;
832 SET_PAGE(ti->srb_page);
833 ti->open_failure = NO ;
834 dev->open = tok_open;
835 dev->stop = tok_close;
836 dev->hard_start_xmit = tok_send_packet;
837 dev->get_stats = tok_get_stats;
838 dev->set_multicast_list = tok_set_multicast_list;
839 dev->change_mtu = ibmtr_change_mtu;
844 /*****************************************************************************/
846 static int tok_init_card(struct net_device *dev)
852 PIOaddr = dev->base_addr;
853 ti = (struct tok_info *) dev->priv;
854 /* Special processing for first interrupt after reset */
855 ti->do_tok_int = FIRST_INT;
857 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
858 outb(0, PIOaddr + ADAPTRESET);
860 current->state=TASK_UNINTERRUPTIBLE;
861 schedule_timeout(TR_RST_TIME); /* wait 50ms */
863 outb(0, PIOaddr + ADAPTRESETREL);
866 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
868 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
869 i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ);
870 return i? 0 : -EAGAIN;
873 /*****************************************************************************/
874 static int tok_open(struct net_device *dev)
876 struct tok_info *ti = (struct tok_info *) dev->priv;
879 /*the case we were left in a failure state during a previous open */
880 if (ti->open_failure == YES) {
881 DPRINTK("Last time you were disconnected, how about now?\n");
882 printk("You can't insert with an ICS connector half-cocked.\n");
885 ti->open_status = CLOSED; /* CLOSED or OPEN */
886 ti->sap_status = CLOSED; /* CLOSED or OPEN */
887 ti->open_failure = NO; /* NO or YES */
888 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
889 /* 12/2000 not typical Linux, but we can use RUNNING to let us know when
890 the network has crapped out or cables are disconnected. Useful because
891 the IFF_UP flag stays up the whole time, until ifconfig tr0 down.
893 dev->flags &= ~IFF_RUNNING;
895 ti->sram_virt &= ~1; /* to reverse what we do in tok_close */
896 /* init the spinlock */
897 ti->lock = (spinlock_t) SPIN_LOCK_UNLOCKED;
898 init_timer(&ti->tr_timer);
900 i = tok_init_card(dev);
904 tok_open_adapter((unsigned long) dev);
905 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
906 /* sig catch: estimate opening adapter takes more than .5 sec*/
907 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
909 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
910 netif_start_queue(dev);
911 DPRINTK("Adapter is up and running\n");
914 current->state=TASK_INTERRUPTIBLE;
915 i=schedule_timeout(TR_RETRY_INTERVAL); /* wait 30 seconds */
916 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
918 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
919 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
923 /*****************************************************************************/
925 #define COMMAND_OFST 0
926 #define OPEN_OPTIONS_OFST 8
927 #define NUM_RCV_BUF_OFST 24
928 #define RCV_BUF_LEN_OFST 26
929 #define DHB_LENGTH_OFST 28
930 #define NUM_DHB_OFST 30
931 #define DLC_MAX_SAP_OFST 32
932 #define DLC_MAX_STA_OFST 33
934 void tok_open_adapter(unsigned long dev_addr)
936 struct net_device *dev = (struct net_device *) dev_addr;
940 ti = (struct tok_info *) dev->priv;
941 SET_PAGE(ti->init_srb_page);
942 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
943 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
944 writeb(0, ti->init_srb + i);
945 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
946 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
947 if (ti->ring_speed == 16) {
948 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
949 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
950 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
952 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
953 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
954 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
956 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
957 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
958 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
959 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
960 ti->srb_page = ti->init_srb_page;
961 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
962 readb(ti->init_srb + NUM_DHB_OFST),
963 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
964 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
965 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
966 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
967 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
970 /*****************************************************************************/
972 static void open_sap(unsigned char type, struct net_device *dev)
975 struct tok_info *ti = (struct tok_info *) dev->priv;
977 SET_PAGE(ti->srb_page);
978 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
979 writeb(0, ti->srb + i);
981 #define MAX_I_FIELD_OFST 14
982 #define SAP_VALUE_OFST 16
983 #define SAP_OPTIONS_OFST 17
984 #define STATION_COUNT_OFST 18
986 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
987 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
988 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
989 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
990 writeb(type, ti->srb + SAP_VALUE_OFST);
991 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
995 /*****************************************************************************/
997 static void tok_set_multicast_list(struct net_device *dev)
999 struct tok_info *ti = (struct tok_info *) dev->priv;
1000 struct dev_mc_list *mclist;
1001 unsigned char address[4];
1005 /*BMS the next line is CRUCIAL or you may be sad when you */
1006 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
1007 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
1008 address[0] = address[1] = address[2] = address[3] = 0;
1009 mclist = dev->mc_list;
1010 for (i = 0; i < dev->mc_count; i++) {
1011 address[0] |= mclist->dmi_addr[2];
1012 address[1] |= mclist->dmi_addr[3];
1013 address[2] |= mclist->dmi_addr[4];
1014 address[3] |= mclist->dmi_addr[5];
1015 mclist = mclist->next;
1017 SET_PAGE(ti->srb_page);
1018 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1019 writeb(0, ti->srb + i);
1021 #define FUNCT_ADDRESS_OFST 6
1023 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1024 for (i = 0; i < 4; i++)
1025 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1026 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1028 DPRINTK("Setting functional address: ");
1029 for (i=0;i<4;i++) printk("%02X ", address[i]);
1034 /*****************************************************************************/
1036 #define STATION_ID_OFST 4
1038 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev)
1040 struct tok_info *ti;
1041 unsigned long flags;
1042 ti = (struct tok_info *) dev->priv;
1044 netif_stop_queue(dev);
1046 /* lock against other CPUs */
1047 spin_lock_irqsave(&(ti->lock), flags);
1049 /* Save skb; we'll need it when the adapter asks for the data */
1050 ti->current_skb = skb;
1051 SET_PAGE(ti->srb_page);
1052 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1053 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1054 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1055 spin_unlock_irqrestore(&(ti->lock), flags);
1056 dev->trans_start = jiffies;
1060 /*****************************************************************************/
1062 static int tok_close(struct net_device *dev)
1064 struct tok_info *ti = (struct tok_info *) dev->priv;
1066 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1067 /* unloading the module from memory, and then if a timer pops, ouch */
1068 del_timer_sync(&ti->tr_timer);
1069 outb(0, dev->base_addr + ADAPTRESET);
1071 ti->open_status = CLOSED;
1073 netif_stop_queue(dev);
1074 DPRINTK("Adapter is closed.\n");
1078 /*****************************************************************************/
1080 #define RETCODE_OFST 2
1081 #define OPEN_ERROR_CODE_OFST 6
1082 #define ASB_ADDRESS_OFST 8
1083 #define SRB_ADDRESS_OFST 10
1084 #define ARB_ADDRESS_OFST 12
1085 #define SSB_ADDRESS_OFST 14
1087 static char *printphase[]= {"Lobe media test","Physical insertion",
1088 "Address verification","Roll call poll","Request Parameters"};
1089 static char *printerror[]={"Function failure","Signal loss","Reserved",
1090 "Frequency error","Timeout","Ring failure","Ring beaconing",
1091 "Duplicate node address",
1092 "Parameter request-retry count exceeded","Remove received",
1093 "IMPL force received","Duplicate modifier",
1094 "No monitor detected","Monitor contention failed for RPL"};
1096 void dir_open_adapter (struct net_device *dev) {
1098 struct tok_info *ti = (struct tok_info *) dev->priv;
1099 unsigned char ret_code;
1102 ti->srb = ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST));
1103 ti->ssb = ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST));
1104 ti->arb = ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST));
1105 ti->asb = ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST));
1106 if (ti->page_mask) {
1107 ti->srb_page = (ti->srb >> 8) & ti->page_mask;
1108 ti->srb &= ~(ti->page_mask << 8);
1109 ti->ssb_page = (ti->ssb >> 8) & ti->page_mask;
1110 ti->ssb &= ~(ti->page_mask << 8);
1111 ti->arb_page = (ti->arb >> 8) & ti->page_mask;
1112 ti->arb &= ~(ti->page_mask << 8);
1113 ti->asb_page = (ti->asb >> 8) & ti->page_mask;
1114 ti->asb &= ~(ti->page_mask << 8);
1116 ti->srb += ti->sram_virt;
1117 ti->ssb += ti->sram_virt;
1118 ti->arb += ti->sram_virt;
1119 ti->asb += ti->sram_virt;
1120 ti->current_skb = NULL;
1121 ret_code = readb(ti->init_srb + RETCODE_OFST);
1122 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1124 ti->open_status = OPEN; /* TR adapter is now available */
1125 if (ti->open_mode == AUTOMATIC) {
1126 DPRINTK("Adapter reopened.\n");
1128 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1129 open_sap(EXTENDED_SAP, dev);
1132 ti->open_failure = YES;
1135 if (!ti->auto_speedsave) {
1136 DPRINTK("Open failed: Adapter speed must match "
1137 "ring speed if Automatic Ring Speed Save is "
1139 ti->open_action = FAIL;
1141 DPRINTK("Retrying open to adjust to "
1143 } else if (err == 0x2d) {
1144 DPRINTK("Physical Insertion: No Monitor Detected, ");
1145 printk("retrying after %ds delay...\n",
1146 TR_RETRY_INTERVAL/HZ);
1147 } else if (err == 0x11) {
1148 DPRINTK("Lobe Media Function Failure (0x11), ");
1149 printk(" retrying after %ds delay...\n",
1150 TR_RETRY_INTERVAL/HZ);
1152 char **prphase = printphase;
1153 char **prerror = printerror;
1154 DPRINTK("TR Adapter misc open failure, error code = ");
1155 printk("0x%x, Phase: %s, Error: %s\n",
1156 err, prphase[err/16 -1], prerror[err%16 -1]);
1157 printk(" retrying after %ds delay...\n",
1158 TR_RETRY_INTERVAL/HZ);
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);
1167 wake_up(&ti->wait_for_reset);
1170 DPRINTK("FAILURE, CAPUT\n");
1173 /******************************************************************************/
1175 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1177 unsigned char status;
1178 /* unsigned char status_even ; */
1179 struct tok_info *ti;
1180 struct net_device *dev;
1181 #ifdef ENABLE_PAGING
1182 unsigned char save_srpr;
1187 DPRINTK("Int from tok_driver, dev : %p irq%d regs=%p\n", dev,irq,regs);
1189 ti = (struct tok_info *) dev->priv;
1190 if (ti->sram_virt & 1)
1191 return IRQ_NONE; /* PCMCIA card extraction flag */
1192 spin_lock(&(ti->lock));
1193 #ifdef ENABLE_PAGING
1194 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1197 /* Disable interrupts till processing is finished */
1198 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1200 /* Reset interrupt for ISA boards */
1201 if (ti->adapter_int_enable)
1202 outb(0, ti->adapter_int_enable);
1203 else /* used for PCMCIA cards */
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);
1210 spin_unlock(&(ti->lock));
1213 /* Begin interrupt handler HERE inline to avoid the extra
1214 levels of logic and call depth for the original solution. */
1215 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1216 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1217 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1218 /*BMS status,status_even); */
1220 if (status & ADAP_CHK_INT) {
1223 __u8 check_reason_page = 0;
1225 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN));
1226 if (ti->page_mask) {
1227 check_reason_page = (check_reason >> 8) & ti->page_mask;
1228 check_reason &= ~(ti->page_mask << 8);
1230 check_reason += ti->sram_virt;
1231 SET_PAGE(check_reason_page);
1233 DPRINTK("Adapter check interrupt\n");
1234 DPRINTK("8 reason bytes follow: ");
1235 for (i = 0; i < 8; i++, check_reason++)
1236 printk("%02X ", (int) readb(check_reason));
1238 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1239 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1240 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1241 ti->open_status = CLOSED;
1242 ti->sap_status = CLOSED;
1243 ti->open_mode = AUTOMATIC;
1244 dev->flags &= ~IFF_RUNNING;
1245 netif_stop_queue(dev);
1246 ti->open_action = RESTART;
1247 outb(0, dev->base_addr + ADAPTRESET);
1248 ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/
1249 spin_unlock(&(ti->lock));
1252 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1253 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1254 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1255 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1256 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1257 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1258 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/
1259 DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/
1260 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1261 #ifdef ENABLE_PAGING
1262 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1264 spin_unlock(&(ti->lock));
1267 if (status & SRB_RESP_INT) { /* SRB response */
1268 SET_PAGE(ti->srb_page);
1270 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1271 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1273 switch (readb(ti->srb)) { /* SRB command check */
1274 case XMIT_DIR_FRAME:{
1275 unsigned char xmit_ret_code;
1276 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1277 if (xmit_ret_code == 0xff) break;
1278 DPRINTK("error on xmit_dir_frame request: %02X\n",
1280 if (ti->current_skb) {
1281 dev_kfree_skb_irq(ti->current_skb);
1282 ti->current_skb = NULL;
1285 netif_wake_queue(dev);
1286 if (ti->readlog_pending)
1290 case XMIT_UI_FRAME:{
1291 unsigned char xmit_ret_code;
1293 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1294 if (xmit_ret_code == 0xff) break;
1295 DPRINTK("error on xmit_ui_frame request: %02X\n",
1297 if (ti->current_skb) {
1298 dev_kfree_skb_irq(ti->current_skb);
1299 ti->current_skb = NULL;
1301 netif_wake_queue(dev);
1302 if (ti->readlog_pending)
1306 case DIR_OPEN_ADAPTER:
1307 dir_open_adapter(dev);
1310 if (readb(ti->srb + RETCODE_OFST)) {
1311 DPRINTK("open_sap failed: ret_code = %02X, "
1313 (int) readb(ti->srb + RETCODE_OFST));
1314 ti->open_action = REOPEN;
1315 ibmtr_reset_timer(&(ti->tr_timer), dev);
1318 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1319 ti->sap_status = OPEN;/* TR adapter is now available */
1320 if (ti->open_mode==MANUAL){
1321 wake_up(&ti->wait_for_reset);
1324 netif_wake_queue(dev);
1325 dev->flags |= IFF_RUNNING;/*BMS 12/2000*/
1328 case DIR_MOD_OPEN_PARAMS:
1329 case DIR_SET_GRP_ADDR:
1330 case DIR_SET_FUNC_ADDR:
1332 if (readb(ti->srb + RETCODE_OFST))
1333 DPRINTK("error on %02X: %02X\n",
1334 (int) readb(ti->srb + COMMAND_OFST),
1335 (int) readb(ti->srb + RETCODE_OFST));
1338 if (readb(ti->srb + RETCODE_OFST)){
1339 DPRINTK("error on dir_read_log: %02X\n",
1340 (int) readb(ti->srb + RETCODE_OFST));
1341 netif_wake_queue(dev);
1344 #if IBMTR_DEBUG_MESSAGES
1346 #define LINE_ERRORS_OFST 0
1347 #define INTERNAL_ERRORS_OFST 1
1348 #define BURST_ERRORS_OFST 2
1349 #define AC_ERRORS_OFST 3
1350 #define ABORT_DELIMITERS_OFST 4
1351 #define LOST_FRAMES_OFST 6
1352 #define RECV_CONGEST_COUNT_OFST 7
1353 #define FRAME_COPIED_ERRORS_OFST 8
1354 #define FREQUENCY_ERRORS_OFST 9
1355 #define TOKEN_ERRORS_OFST 10
1357 DPRINTK("Line errors %02X, Internal errors %02X, "
1358 "Burst errors %02X\n" "A/C errors %02X, "
1359 "Abort delimiters %02X, Lost frames %02X\n"
1360 "Receive congestion count %02X, "
1361 "Frame copied errors %02X\nFrequency errors %02X, "
1362 "Token errors %02X\n",
1363 (int) readb(ti->srb + LINE_ERRORS_OFST),
1364 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1365 (int) readb(ti->srb + BURST_ERRORS_OFST),
1366 (int) readb(ti->srb + AC_ERRORS_OFST),
1367 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1368 (int) readb(ti->srb + LOST_FRAMES_OFST),
1369 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1370 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1371 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1372 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1374 netif_wake_queue(dev);
1377 DPRINTK("Unknown command %02X encountered\n",
1378 (int) readb(ti->srb));
1379 } /* end switch SRB command check */
1380 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1381 } /* if SRB response */
1382 if (status & ASB_FREE_INT) { /* ASB response */
1383 SET_PAGE(ti->asb_page);
1385 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1388 switch (readb(ti->asb)) { /* ASB command check */
1391 case XMIT_DIR_FRAME:
1394 DPRINTK("unknown command in asb %02X\n",
1395 (int) readb(ti->asb));
1396 } /* switch ASB command check */
1397 if (readb(ti->asb + 2) != 0xff) /* checks ret_code */
1398 DPRINTK("ASB error %02X in cmd %02X\n",
1399 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1400 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1401 } /* if ASB response */
1403 #define STATUS_OFST 6
1404 #define NETW_STATUS_OFST 6
1406 if (status & ARB_CMD_INT) { /* ARB response */
1407 SET_PAGE(ti->arb_page);
1409 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1412 switch (readb(ti->arb)) { /* ARB command check */
1414 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1415 ntohs(readw(ti->arb + STATUS_OFST)),
1416 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1421 case RING_STAT_CHANGE:{
1422 unsigned short ring_status;
1423 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1424 if (ibmtr_debug_trace & TRC_INIT)
1425 DPRINTK("Ring Status Change...(0x%x)\n",
1427 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1428 netif_stop_queue(dev);
1429 dev->flags &= ~IFF_RUNNING;/*not typical Linux*/
1430 DPRINTK("Remove received, or Auto-removal error"
1431 ", or Lobe fault\n");
1432 DPRINTK("We'll try to reopen the closed adapter"
1433 " after a %d second delay.\n",
1434 TR_RETRY_INTERVAL/HZ);
1435 /*I was confused: I saw the TR reopening but */
1436 /*forgot:with an RJ45 in an RJ45/ICS adapter */
1437 /*but adapter not in the ring, the TR will */
1438 /* open, and then soon close and come here. */
1439 ti->open_mode = AUTOMATIC;
1440 ti->open_status = CLOSED; /*12/2000 BMS*/
1441 ti->open_action = REOPEN;
1442 ibmtr_reset_timer(&(ti->tr_timer), dev);
1443 } else if (ring_status & LOG_OVERFLOW) {
1444 if(netif_queue_stopped(dev))
1445 ti->readlog_pending = 1;
1455 DPRINTK("Unknown command %02X in arb\n",
1456 (int) readb(ti->arb));
1458 } /* switch ARB command check */
1459 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1460 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1461 } /* if ARB response */
1462 if (status & SSB_RESP_INT) { /* SSB response */
1463 unsigned char retcode;
1464 SET_PAGE(ti->ssb_page);
1466 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1467 readb(ti->ssb), readb(ti->ssb + 2));
1470 switch (readb(ti->ssb)) { /* SSB command check */
1471 case XMIT_DIR_FRAME:
1473 retcode = readb(ti->ssb + 2);
1474 if (retcode && (retcode != 0x22))/* checks ret_code */
1475 DPRINTK("xmit ret_code: %02X xmit error code: "
1477 (int)retcode, (int)readb(ti->ssb + 6));
1479 ti->tr_stats.tx_packets++;
1482 DPRINTK("xmit xid ret_code: %02X\n",
1483 (int) readb(ti->ssb + 2));
1485 DPRINTK("Unknown command %02X in ssb\n",
1486 (int) readb(ti->ssb));
1487 } /* SSB command check */
1488 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1489 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1490 } /* if SSB response */
1491 #ifdef ENABLE_PAGING
1492 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1494 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1495 spin_unlock(&(ti->lock));
1497 } /*tok_interrupt */
1499 /*****************************************************************************/
1501 #define INIT_STATUS_OFST 1
1502 #define INIT_STATUS_2_OFST 2
1503 #define ENCODED_ADDRESS_OFST 8
1505 static void initial_tok_int(struct net_device *dev)
1508 __u32 encoded_addr, hw_encoded_addr;
1509 struct tok_info *ti;
1510 unsigned char init_status; /*BMS 12/2000*/
1512 ti = (struct tok_info *) dev->priv;
1514 ti->do_tok_int = NOT_FIRST;
1516 /* we assign the shared-ram address for ISA devices */
1517 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1519 ti->sram_virt = (u32)ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1521 ti->init_srb = ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN));
1522 if (ti->page_mask) {
1523 ti->init_srb_page = (ti->init_srb >> 8) & ti->page_mask;
1524 ti->init_srb &= ~(ti->page_mask << 8);
1526 ti->init_srb += ti->sram_virt;
1527 if (ti->page_mask && ti->avail_shared_ram == 127) {
1528 int last_512 = 0xfe00, i;
1529 int last_512_page=0;
1530 last_512_page=(last_512>>8)&ti->page_mask;
1531 last_512 &= ~(ti->page_mask << 8);
1532 /* initialize high section of ram (if necessary) */
1533 SET_PAGE(last_512_page);
1534 for (i = 0; i < 512; i++)
1535 writeb(0, ti->sram_virt + last_512 + i);
1537 SET_PAGE(ti->init_srb_page);
1543 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1544 DPRINTK("init_srb(%x):", (ti->init_srb) );
1545 for (i = 0; i < 20; i++)
1546 printk("%02X ", (int) readb(ti->init_srb + i));
1551 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1552 encoded_addr = ntohs(hw_encoded_addr);
1553 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1554 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1555 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1556 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1557 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1558 ti->ring_speed, (unsigned int)dev->mem_start);
1559 ti->auto_speedsave=readb(ti->init_srb+INIT_STATUS_2_OFST)&4?TRUE:FALSE;
1561 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1562 else tok_open_adapter((unsigned long)dev);
1564 } /*initial_tok_int() */
1566 /*****************************************************************************/
1568 #define CMD_CORRELATE_OFST 1
1569 #define DHB_ADDRESS_OFST 6
1571 #define FRAME_LENGTH_OFST 6
1572 #define HEADER_LENGTH_OFST 8
1573 #define RSAP_VALUE_OFST 9
1575 static void tr_tx(struct net_device *dev)
1577 struct tok_info *ti = (struct tok_info *) dev->priv;
1578 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1579 unsigned int hdr_len;
1580 __u32 dhb=0,dhb_base;
1581 unsigned char xmit_command;
1582 int i,dhb_len=0x4000,src_len,src_offset;
1584 struct srb_xmit xsrb;
1588 SET_PAGE(ti->asb_page);
1590 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1592 /* in providing the transmit interrupts, is telling us it is ready for
1593 data and providing a shared memory address for us to stuff with data.
1594 Here we compute the effective address where we will place data.
1596 SET_PAGE(ti->arb_page);
1597 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1598 if (ti->page_mask) {
1599 dhb_page = (dhb_base >> 8) & ti->page_mask;
1600 dhb=dhb_base & ~(ti->page_mask << 8);
1602 dhb += ti->sram_virt;
1604 /* Figure out the size of the 802.5 header */
1605 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1606 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1608 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1609 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1611 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1613 llc_ssap = llc->ssap;
1614 SET_PAGE(ti->srb_page);
1615 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1616 SET_PAGE(ti->asb_page);
1617 xmit_command = xsrb.command;
1619 writeb(xmit_command, ti->asb + COMMAND_OFST);
1620 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1621 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1622 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1623 writeb(0, ti->asb + RETCODE_OFST);
1624 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1625 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1626 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1629 writeb(LLC_FRAME, dhb + 1);
1630 for (i = 0; i < TR_ALEN; i++)
1631 writeb((int) 0x0FF, dhb + i + 2);
1632 for (i = 0; i < TR_ALEN; i++)
1633 writeb(0, dhb + i + TR_ALEN + 2);
1634 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1638 * the token ring packet is copied from sk_buff to the adapter
1639 * buffer identified in the command data received with the interrupt.
1641 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1642 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1643 src_len=ti->current_skb->len;
1647 if (ti->page_mask) {
1648 dhb_page=(dhb >> 8) & ti->page_mask;
1649 dhb=dhb & ~(ti->page_mask << 8);
1650 dhb_len=0x4000-dhb; /* remaining size of this page */
1654 if (src_len > dhb_len) {
1655 memcpy_toio(dhb,&ti->current_skb->data[src_offset],
1658 src_offset += dhb_len;
1663 memcpy_toio(dhb, &ti->current_skb->data[src_offset], src_len);
1666 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1667 ti->tr_stats.tx_bytes += ti->current_skb->len;
1668 dev_kfree_skb_irq(ti->current_skb);
1669 ti->current_skb = NULL;
1670 netif_wake_queue(dev);
1671 if (ti->readlog_pending)
1675 /*****************************************************************************/
1678 #define RECEIVE_BUFFER_OFST 6
1679 #define LAN_HDR_LENGTH_OFST 8
1680 #define DLC_HDR_LENGTH_OFST 9
1685 #define PROTID_OFST 3
1686 #define ETHERTYPE_OFST 6
1688 static void tr_rx(struct net_device *dev)
1690 struct tok_info *ti = (struct tok_info *) dev->priv;
1691 __u32 rbuffer, rbufdata;
1692 __u8 rbuffer_page = 0;
1694 unsigned char *data;
1695 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1696 unsigned char dlc_hdr_len;
1697 struct sk_buff *skb;
1698 unsigned int skb_size = 0;
1700 unsigned int chksum = 0;
1702 struct arb_rec_req rarb;
1704 SET_PAGE(ti->arb_page);
1705 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1706 rbuffer = ntohs(rarb.rec_buf_addr) ;
1707 if (ti->page_mask) {
1708 rbuffer_page = (rbuffer >> 8) & ti->page_mask;
1709 rbuffer &= ~(ti->page_mask << 8);
1711 rbuffer += ti->sram_virt;
1713 SET_PAGE(ti->asb_page);
1715 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1717 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1718 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1719 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1721 lan_hdr_len = rarb.lan_hdr_len;
1722 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1723 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1725 } /*BMS I added this above just to be very safe */
1726 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1727 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1729 SET_PAGE(rbuffer_page);
1730 llc = (rbuffer + offsetof(struct rec_buf, data) + lan_hdr_len);
1733 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1734 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1735 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1736 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1737 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1738 "ethertype: %04X\n",
1739 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1740 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1741 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1742 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1744 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1745 SET_PAGE(ti->asb_page);
1746 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1747 ti->tr_stats.rx_dropped++;
1748 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1751 length = ntohs(rarb.frame_len);
1752 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1753 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1754 length >= hdr_len) IPv4_p = 1;
1756 #define SADDR_OFST 8
1757 #define DADDR_OFST 2
1763 trhhdr = (rbuffer + offsetof(struct rec_buf, data));
1765 DPRINTK("Probably non-IP frame received.\n");
1766 DPRINTK("ssap: %02X dsap: %02X "
1767 "saddr: %02X:%02X:%02X:%02X:%02X:%02X "
1768 "daddr: %02X:%02X:%02X:%02X:%02X:%02X\n",
1769 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1770 readb(trhhdr+SADDR_OFST), readb(trhhdr+ SADDR_OFST+1),
1771 readb(trhhdr+SADDR_OFST+2), readb(trhhdr+SADDR_OFST+3),
1772 readb(trhhdr+SADDR_OFST+4), readb(trhhdr+SADDR_OFST+5),
1773 readb(trhhdr+DADDR_OFST), readb(trhhdr+DADDR_OFST + 1),
1774 readb(trhhdr+DADDR_OFST+2), readb(trhhdr+DADDR_OFST+3),
1775 readb(trhhdr+DADDR_OFST+4), readb(trhhdr+DADDR_OFST+5));
1779 /*BMS handle the case she comes in with few hops but leaves with many */
1780 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1782 if (!(skb = dev_alloc_skb(skb_size))) {
1783 DPRINTK("out of memory. frame dropped.\n");
1784 ti->tr_stats.rx_dropped++;
1785 SET_PAGE(ti->asb_page);
1786 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1787 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1790 /*BMS again, if she comes in with few but leaves with many */
1791 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1792 skb_put(skb, length);
1795 rbuffer_len = ntohs(readw(rbuffer + offsetof(struct rec_buf, buf_len)));
1796 rbufdata = rbuffer + offsetof(struct rec_buf, data);
1799 /* Copy the headers without checksumming */
1800 memcpy_fromio(data, rbufdata, hdr_len);
1802 /* Watch for padded packets and bogons */
1803 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1804 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1806 if ((ip_len <= length) && (ip_len > 7))
1809 rbuffer_len -= hdr_len;
1810 rbufdata += hdr_len;
1812 /* Copy the payload... */
1813 #define BUFFER_POINTER_OFST 2
1814 #define BUFFER_LENGTH_OFST 6
1816 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1817 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1818 length,rbuffer_len);
1820 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1821 data,length<rbuffer_len?length:rbuffer_len,chksum);
1823 memcpy_fromio(data, rbufdata, rbuffer_len);
1824 rbuffer = ntohs(readw(rbuffer+BUFFER_POINTER_OFST)) ;
1828 length -= rbuffer_len;
1829 data += rbuffer_len;
1830 if (ti->page_mask) {
1831 rbuffer_page = (rbuffer >> 8) & ti->page_mask;
1832 rbuffer &= ~(ti->page_mask << 8);
1834 rbuffer += ti->sram_virt;
1835 SET_PAGE(rbuffer_page);
1836 rbuffer_len = ntohs(readw(rbuffer + BUFFER_LENGTH_OFST));
1837 rbufdata = rbuffer + offsetof(struct rec_buf, data);
1840 SET_PAGE(ti->asb_page);
1841 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1843 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1845 ti->tr_stats.rx_bytes += skb->len;
1846 ti->tr_stats.rx_packets++;
1848 skb->protocol = tr_type_trans(skb, dev);
1854 dev->last_rx = jiffies;
1857 /*****************************************************************************/
1859 void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1861 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1862 tmr->data = (unsigned long) dev;
1863 tmr->function = tok_rerun;
1868 /*****************************************************************************/
1870 void tok_rerun(unsigned long dev_addr){
1872 struct net_device *dev = (struct net_device *)dev_addr;
1873 struct tok_info *ti = (struct tok_info *) dev->priv;
1875 if ( ti->open_action == RESTART){
1876 ti->do_tok_int = FIRST_INT;
1877 outb(0, dev->base_addr + ADAPTRESETREL);
1878 #ifdef ENABLE_PAGING
1880 writeb(SRPR_ENABLE_PAGING,
1881 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1884 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1886 tok_open_adapter(dev_addr);
1889 /*****************************************************************************/
1891 void ibmtr_readlog(struct net_device *dev)
1893 struct tok_info *ti;
1895 ti = (struct tok_info *) dev->priv;
1897 ti->readlog_pending = 0;
1898 SET_PAGE(ti->srb_page);
1899 writeb(DIR_READ_LOG, ti->srb);
1900 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1901 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1903 netif_stop_queue(dev);
1907 /*****************************************************************************/
1909 /* tok_get_stats(): Basically a scaffold routine which will return
1910 the address of the tr_statistics structure associated with
1911 this device -- the tr.... structure is an ethnet look-alike
1912 so at least for this iteration may suffice. */
1914 static struct net_device_stats *tok_get_stats(struct net_device *dev)
1917 struct tok_info *toki;
1918 toki = (struct tok_info *) dev->priv;
1919 return (struct net_device_stats *) &toki->tr_stats;
1922 /*****************************************************************************/
1924 int ibmtr_change_mtu(struct net_device *dev, int mtu)
1926 struct tok_info *ti = (struct tok_info *) dev->priv;
1928 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1930 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1936 /*****************************************************************************/
1939 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1940 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1941 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1942 static int irq[IBMTR_MAX_ADAPTERS];
1943 static int mem[IBMTR_MAX_ADAPTERS];
1945 MODULE_LICENSE("GPL");
1947 MODULE_PARM(io, "1-" __MODULE_STRING(IBMTR_MAX_ADAPTERS) "i");
1948 MODULE_PARM(irq, "1-" __MODULE_STRING(IBMTR_MAX_ADAPTERS) "i");
1949 MODULE_PARM(mem, "1-" __MODULE_STRING(IBMTR_MAX_ADAPTERS) "i");
1951 static int __init ibmtr_init(void)
1956 find_turbo_adapters(io);
1958 for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) {
1959 struct net_device *dev;
1962 dev = alloc_trdev(sizeof(struct tok_info));
1968 dev->base_addr = io[i];
1970 dev->mem_start = mem[i];
1972 if (ibmtr_probe_card(dev)) {
1979 if (count) return 0;
1980 printk("ibmtr: register_netdev() returned non-zero.\n");
1983 module_init(ibmtr_init);
1985 static void __exit ibmtr_cleanup(void)
1989 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1992 unregister_netdev(dev_ibmtr[i]);
1993 ibmtr_cleanup_card(dev_ibmtr[i]);
1994 free_netdev(dev_ibmtr[i]);
1997 module_exit(ibmtr_cleanup);