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/ip.h>
131 #include <linux/trdevice.h>
132 #include <linux/ibmtr.h>
134 #include <net/checksum.h>
138 #define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args)
139 #define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args)
141 /* version and credits */
143 static char version[] __initdata =
144 "\nibmtr.c: v1.3.57 8/ 7/94 Peter De Schrijver and Mark Swanson\n"
145 " v2.1.125 10/20/98 Paul Norton <pnorton@ieee.org>\n"
146 " v2.2.0 12/30/98 Joel Sloan <jjs@c-me.com>\n"
147 " v2.2.1 02/08/00 Mike Sullivan <sullivam@us.ibm.com>\n"
148 " v2.2.2 07/27/00 Burt Silverman <burts@us.ibm.com>\n"
149 " v2.4.0 03/01/01 Mike Sullivan <sullivan@us.ibm.com>\n";
152 /* this allows displaying full adapter information */
154 char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" };
156 static char pcchannelid[] __devinitdata = {
157 0x05, 0x00, 0x04, 0x09,
158 0x04, 0x03, 0x04, 0x0f,
159 0x03, 0x06, 0x03, 0x01,
160 0x03, 0x01, 0x03, 0x00,
161 0x03, 0x09, 0x03, 0x09,
162 0x03, 0x00, 0x02, 0x00
165 static char mcchannelid[] __devinitdata = {
166 0x04, 0x0d, 0x04, 0x01,
167 0x05, 0x02, 0x05, 0x03,
168 0x03, 0x06, 0x03, 0x03,
169 0x05, 0x08, 0x03, 0x04,
170 0x03, 0x05, 0x03, 0x01,
171 0x03, 0x08, 0x02, 0x00
174 char __devinit *adapter_def(char type)
177 case 0xF: return "PC Adapter | PC Adapter II | Adapter/A";
178 case 0xE: return "16/4 Adapter | 16/4 Adapter/A (long)";
179 case 0xD: return "16/4 Adapter/A (short) | 16/4 ISA-16 Adapter";
180 case 0xC: return "Auto 16/4 Adapter";
181 default: return "adapter (unknown type)";
185 #define TRC_INIT 0x01 /* Trace initialization & PROBEs */
186 #define TRC_INITV 0x02 /* verbose init trace points */
187 unsigned char ibmtr_debug_trace = 0;
189 static int ibmtr_probe(struct net_device *dev);
190 static int ibmtr_probe1(struct net_device *dev, int ioaddr);
191 static unsigned char get_sram_size(struct tok_info *adapt_info);
192 static int trdev_init(struct net_device *dev);
193 static int tok_open(struct net_device *dev);
194 static int tok_init_card(struct net_device *dev);
195 void tok_open_adapter(unsigned long dev_addr);
196 static void open_sap(unsigned char type, struct net_device *dev);
197 static void tok_set_multicast_list(struct net_device *dev);
198 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev);
199 static int tok_close(struct net_device *dev);
200 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs);
201 static void initial_tok_int(struct net_device *dev);
202 static void tr_tx(struct net_device *dev);
203 static void tr_rx(struct net_device *dev);
204 void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev);
205 static void tok_rerun(unsigned long dev_addr);
206 void ibmtr_readlog(struct net_device *dev);
207 static struct net_device_stats *tok_get_stats(struct net_device *dev);
208 int ibmtr_change_mtu(struct net_device *dev, int mtu);
209 static void find_turbo_adapters(int *iolist);
211 static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = {
212 0xa20, 0xa24, 0, 0, 0
214 static int __devinitdata turbo_io[IBMTR_MAX_ADAPTERS] = {0};
215 static int __devinitdata turbo_irq[IBMTR_MAX_ADAPTERS] = {0};
216 static int __devinitdata turbo_searched = 0;
219 static __u32 ibmtr_mem_base __initdata = 0xd0000;
222 static void __devinit PrtChanID(char *pcid, short stride)
225 for (i = 0, j = 0; i < 24; i++, j += stride)
226 printk("%1x", ((int) pcid[j]) & 0x0f);
230 static void __devinit HWPrtChanID(void * pcid, short stride)
233 for (i = 0, j = 0; i < 24; i++, j += stride)
234 printk("%1x", ((int) readb(pcid + j)) & 0x0f);
238 /* We have to ioremap every checked address, because isa_readb is
242 static void __devinit find_turbo_adapters(int *iolist) {
247 unsigned char *tchanid, ctemp;
252 if (turbo_searched == 1) return;
254 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
259 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
260 if (ram_mapped==NULL)
262 chanid=(CHANNEL_ID + ram_mapped);
264 ctemp=readb(chanid) & 0x0f;
265 if (ctemp != *tchanid) continue;
266 for (i=2,j=1; i<=46; i=i+2,j++) {
267 if ((readb(chanid+i) & 0x0f) != tchanid[j]){
272 if (!found_turbo) continue;
274 writeb(0x90, ram_mapped+0x1E01);
275 for(i=2; i<0x0f; i++) {
276 writeb(0x00, ram_mapped+0x1E01+i);
278 writeb(0x00, ram_mapped+0x1E01);
279 for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif););
280 intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN));
282 #if IBMTR_DEBUG_MESSAGES
283 printk("ibmtr::find_turbo_adapters, Turbo found at "
284 "ram_addr %x\n",ram_addr);
285 printk("ibmtr::find_turbo_adapters, interface_table ");
287 printk("%x:",readb(ram_addr+intf_tbl+i));
291 turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4));
292 turbo_irq[index]=readb(ram_mapped+intf_tbl+3);
293 outb(0, turbo_io[index] + ADAPTRESET);
294 for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif););
295 outb(0, turbo_io[index] + ADAPTRESETREL);
299 #if IBMTR_DEBUG_MESSAGES
300 printk("ibmtr::find_turbo_adapters, ibmtr card found at"
301 " %x but not a Turbo model\n",ram_addr);
303 iounmap(ram_mapped) ;
305 for(i=0; i<IBMTR_MAX_ADAPTERS; i++) {
306 if(!turbo_io[i]) break;
307 for (j=0; j<IBMTR_MAX_ADAPTERS; j++) {
308 if ( iolist[j] && iolist[j] != turbo_io[i]) continue;
309 iolist[j]=turbo_io[i];
315 static void ibmtr_cleanup_card(struct net_device *dev)
317 if (dev->base_addr) {
318 outb(0,dev->base_addr+ADAPTRESET);
320 schedule_timeout(TR_RST_TIME); /* wait 50ms */
322 outb(0,dev->base_addr+ADAPTRESETREL);
326 free_irq(dev->irq, dev);
327 release_region(dev->base_addr, IBMTR_IO_EXTENT);
330 struct tok_info *ti = (struct tok_info *) dev->priv;
331 iounmap((u32 *)ti->mmio);
332 iounmap((u32 *)ti->sram_virt);
337 int ibmtr_probe_card(struct net_device *dev)
339 int err = ibmtr_probe(dev);
341 err = register_netdev(dev);
343 ibmtr_cleanup_card(dev);
348 /****************************************************************************
349 * ibmtr_probe(): Routine specified in the network device structure
350 * to probe for an IBM Token Ring Adapter. Routine outline:
351 * I. Interrogate hardware to determine if an adapter exists
352 * and what the speeds and feeds are
353 * II. Setup data structures to control execution based upon
354 * adapter characteristics.
356 * We expect ibmtr_probe to be called once for each device entry
357 * which references it.
358 ****************************************************************************/
360 static int ibmtr_probe(struct net_device *dev)
363 int base_addr = dev->base_addr;
365 if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */
367 if (base_addr > 0x1ff) { /* Check a single specified location. */
368 if (!ibmtr_probe1(dev, base_addr)) return 0;
371 find_turbo_adapters(ibmtr_portlist);
372 for (i = 0; ibmtr_portlist[i]; i++) {
373 int ioaddr = ibmtr_portlist[i];
375 if (!ibmtr_probe1(dev, ioaddr)) return 0;
380 /*****************************************************************************/
382 static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
385 unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0;
386 void * t_mmio = NULL;
387 struct tok_info *ti = dev->priv;
389 unsigned char *tchanid, ctemp;
391 unsigned char t_irq=0;
392 unsigned long timeout;
393 static int version_printed;
396 /* Query the adapter PIO base port which will return
397 * indication of where MMIO was placed. We also have a
398 * coded interrupt number.
400 segment = inb(PIOaddr);
401 if (segment < 0x40 || segment > 0xe0) {
402 /* Out of range values so we'll assume non-existent IO device
403 * but this is not necessarily a problem, esp if a turbo
404 * adapter is being used. */
405 #if IBMTR_DEBUG_MESSAGES
406 DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, "
407 "Hardware Problem?\n",PIOaddr,segment);
412 * Compute the linear base address of the MMIO area
413 * as LINUX doesn't care about segments
415 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
417 DPRINTK("Cannot remap mmiobase memory area") ;
420 intr = segment & 0x03; /* low bits is coded interrupt # */
421 if (ibmtr_debug_trace & TRC_INIT)
422 DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n"
423 , PIOaddr, (int) segment, t_mmio, (int) intr);
426 * Now we will compare expected 'channelid' strings with
427 * what we is there to learn of ISA/MCA or not TR card
431 t_mmio = (void *)ti->mmio; /*BMS to get virtual address */
432 irq = ti->irq; /*BMS to display the irq! */
434 cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */
435 tchanid = pcchannelid;
436 cardpresent = TR_ISA; /* try ISA */
438 /* Suboptimize knowing first byte different */
439 ctemp = readb(cd_chanid) & 0x0f;
440 if (ctemp != *tchanid) { /* NOT ISA card, try MCA */
441 tchanid = mcchannelid;
442 cardpresent = TR_MCA;
443 if (ctemp != *tchanid) /* Neither ISA nor MCA */
446 if (cardpresent != NOTOK) {
447 /* Know presumed type, try rest of ID */
448 for (i = 2, j = 1; i <= 46; i = i + 2, j++) {
449 if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue;
450 /* match failed, not TR card */
456 * If we have an ISA board check for the ISA P&P version,
457 * as it has different IRQ settings
459 if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e))
460 cardpresent = TR_ISAPNP;
461 if (cardpresent == NOTOK) { /* "channel_id" did not match, report */
462 if (!(ibmtr_debug_trace & TRC_INIT)) {
468 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
470 DPRINTK("Expected for ISA: ");
471 PrtChanID(pcchannelid, 1);
473 /* BMS Note that this can be misleading, when hardware is flaky, because you
474 are reading it a second time here. So with my flaky hardware, I'll see my-
475 self in this block, with the HW ID matching the ISA ID exactly! */
476 HWPrtChanID(cd_chanid, 2);
477 DPRINTK("Expected for MCA: ");
478 PrtChanID(mcchannelid, 1);
480 /* Now, setup some of the pl0 buffers for this driver.. */
481 /* If called from PCMCIA, it is already set up, so no need to
482 waste the memory, just use the existing structure */
485 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
486 if (turbo_io[i] != PIOaddr)
488 #if IBMTR_DEBUG_MESSAGES
489 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
493 t_irq = turbo_irq[i];
496 ti->readlog_pending = 0;
497 init_waitqueue_head(&ti->wait_for_reset);
499 /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP
500 * depending which card is inserted. */
503 switch (cardpresent) {
505 if (intr == 0) irq = 9; /* irq2 really is irq9 */
506 if (intr == 1) irq = 3;
507 if (intr == 2) irq = 6;
508 if (intr == 3) irq = 7;
509 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
512 if (intr == 0) irq = 9;
513 if (intr == 1) irq = 3;
514 if (intr == 2) irq = 10;
515 if (intr == 3) irq = 11;
516 ti->global_int_enable = 0;
517 ti->adapter_int_enable = 0;
518 ti->sram_virt=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12;
522 if (intr == 0) irq = 9;
523 if (intr == 1) irq = 3;
524 if (intr == 2) irq = 10;
525 if (intr == 3) irq = 11;
528 timeout = jiffies + TR_SPIN_INTERVAL;
529 while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){
530 if (!time_after(jiffies, timeout)) continue;
531 DPRINTK( "Hardware timeout during initialization.\n");
537 ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12);
538 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
540 } /*end switch (cardpresent) */
541 #endif /*not PCMCIA */
543 if (ibmtr_debug_trace & TRC_INIT) { /* just report int */
544 DPRINTK("irq=%d", irq);
545 printk(", sram_virt=0x%x", ti->sram_virt);
546 if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */
547 DPRINTK(", ti->mmio=%p", ti->mmio);
548 printk(", segment=%02X", segment);
553 /* Get hw address of token ring card */
555 for (i = 0; i < 0x18; i = i + 2) {
556 /* technical reference states to do this */
557 temp = readb(ti->mmio + AIP + i) & 0x0f;
558 ti->hw_address[j] = temp;
560 dev->dev_addr[(j / 2)] =
561 ti->hw_address[j]+ (ti->hw_address[j - 1] << 4);
564 /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */
565 ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);
567 /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */
568 ti->data_rate = readb(ti->mmio + AIPDATARATE);
570 /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */
571 ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);
573 /* How much shared RAM is on adapter ? */
575 ti->avail_shared_ram=127;
577 ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */
579 /* We need to set or do a bunch of work here based on previous results*/
580 /* Support paging? What sizes?: F=no, E=16k, D=32k, C=16 & 32k */
581 ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE);
583 /* Available DHB 4Mb size: F=2048, E=4096, D=4464 */
584 switch (readb(ti->mmio + AIP4MBDHB)) {
585 case 0xe: ti->dhb_size4mb = 4096; break;
586 case 0xd: ti->dhb_size4mb = 4464; break;
587 default: ti->dhb_size4mb = 2048; break;
590 /* Available DHB 16Mb size: F=2048, E=4096, D=8192, C=16384, B=17960 */
591 switch (readb(ti->mmio + AIP16MBDHB)) {
592 case 0xe: ti->dhb_size16mb = 4096; break;
593 case 0xd: ti->dhb_size16mb = 8192; break;
594 case 0xc: ti->dhb_size16mb = 16384; break;
595 case 0xb: ti->dhb_size16mb = 17960; break;
596 default: ti->dhb_size16mb = 2048; break;
599 /* We must figure out how much shared memory space this adapter
600 * will occupy so that if there are two adapters we can fit both
601 * in. Given a choice, we will limit this adapter to 32K. The
602 * maximum space will will use for two adapters is 64K so if the
603 * adapter we are working on demands 64K (it also doesn't support
604 * paging), then only one adapter can be supported.
608 * determine how much of total RAM is mapped into PC space
610 ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/
611 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4);
613 if (ti->turbo) ti->page_mask=0xf0;
614 else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */
617 unsigned char pg_size = 0;
618 /* BMS: page size: PCMCIA, use configuration register;
619 ISAPNP, use LANAIDC config tool from www.ibm.com */
620 switch (ti->shared_ram_paging) {
624 ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0;
625 pg_size = 32; /* 16KB page size */
628 ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0;
629 pg_size = 64; /* 32KB page size */
632 switch (ti->mapped_ram_size) {
634 ti->page_mask = 0xc0;
638 ti->page_mask = 0x80;
644 DPRINTK("Unknown shared ram paging info %01X\n",
645 ti->shared_ram_paging);
650 } /*end switch shared_ram_paging */
652 if (ibmtr_debug_trace & TRC_INIT)
653 DPRINTK("Shared RAM paging code: %02X, "
654 "mapped RAM size: %dK, shared RAM size: %dK, "
655 "page mask: %02X\n:",
656 ti->shared_ram_paging, ti->mapped_ram_size / 2,
657 ti->avail_shared_ram / 2, ti->page_mask);
658 #endif /*ENABLE_PAGING */
662 /* finish figuring the shared RAM address */
663 if (cardpresent == TR_ISA) {
664 static __u32 ram_bndry_mask[] =
665 { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 };
666 __u32 new_base, rrr_32, chk_base, rbm;
668 rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03;
669 rbm = ram_bndry_mask[rrr_32];
670 new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */
671 chk_base = new_base + (ti->mapped_ram_size << 9);
672 if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) {
673 DPRINTK("Shared RAM for this adapter (%05x) exceeds "
674 "driver limit (%05x), adapter not started.\n",
675 chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
679 } else { /* seems cool, record what we have figured out */
680 ti->sram_base = new_base >> 12;
681 ibmtr_mem_base = chk_base;
684 else ti->sram_base = ti->sram_virt >> 12;
686 /* The PCMCIA has already got the interrupt line and the io port,
687 so no chance of anybody else getting it - MLP */
688 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
689 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
695 /*?? Now, allocate some of the PIO PORTs for this driver.. */
696 /* record PIOaddr range as busy */
697 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
698 DPRINTK("Could not grab PIO range. Halting driver.\n");
699 free_irq(dev->irq, dev);
705 if (!version_printed++) {
709 DPRINTK("%s %s found\n",
710 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
711 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
712 irq, PIOaddr, ti->mapped_ram_size / 2);
713 DPRINTK("Hardware address : %02X:%02X:%02X:%02X:%02X:%02X\n",
714 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
715 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
717 DPRINTK("Shared RAM paging enabled. "
718 "Page size: %uK Shared Ram size %dK\n",
719 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
721 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
724 /* Calculate the maximum DHB we can use */
725 /* two cases where avail_shared_ram doesn't equal mapped_ram_size:
726 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical)
727 2. user has configured adapter for less than avail_shared_ram
728 but is not using paging (she should use paging, I believe)
730 if (!ti->page_mask) {
731 ti->avail_shared_ram=
732 min(ti->mapped_ram_size,ti->avail_shared_ram);
735 switch (ti->avail_shared_ram) {
736 case 16: /* 8KB shared RAM */
737 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
738 ti->rbuf_len4 = 1032;
740 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
741 ti->rbuf_len16 = 1032;
744 case 32: /* 16KB shared RAM */
745 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
746 ti->rbuf_len4 = 1032;
748 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
749 ti->rbuf_len16 = 1032; /*1024 usable */
752 case 64: /* 32KB shared RAM */
753 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
754 ti->rbuf_len4 = 1032;
756 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
757 ti->rbuf_len16 = 1032;
760 case 127: /* 63.5KB shared RAM */
761 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
762 ti->rbuf_len4 = 1032;
764 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
765 ti->rbuf_len16 = 1032;
768 case 128: /* 64KB shared RAM */
769 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
770 ti->rbuf_len4 = 1032;
772 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
773 ti->rbuf_len16 = 1032;
777 ti->dhb_size4mb = 2048;
778 ti->rbuf_len4 = 1032;
780 ti->dhb_size16mb = 2048;
781 ti->rbuf_len16 = 1032;
785 /* this formula is not smart enough for the paging case
786 ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE -
787 ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH -
788 DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB -
789 SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>;
791 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
792 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
793 /*BMS assuming 18 bytes of Routing Information (usually works) */
794 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
795 ti->maxmtu16, ti->maxmtu4);
797 dev->base_addr = PIOaddr; /* set the value for device */
798 dev->mem_start = ti->sram_base << 12;
799 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
801 return 0; /* Return 0 to indicate we have found a Token Ring card. */
802 } /*ibmtr_probe1() */
804 /*****************************************************************************/
806 /* query the adapter for the size of shared RAM */
807 /* the function returns the RAM size in units of 512 bytes */
809 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
811 unsigned char avail_sram_code;
812 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
814 'F' -- use RRR bits 3,2
815 'E' -- 8kb 'D' -- 16kb
816 'C' -- 32kb 'A' -- 64KB
817 'B' - 64KB less 512 bytes at top
818 (WARNING ... must zero top bytes in INIT */
820 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
821 if (avail_sram_code) return size_code[avail_sram_code];
822 else /* for code 'F', must compute size from RRR(3,2) bits */
824 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
827 /*****************************************************************************/
829 static int __devinit trdev_init(struct net_device *dev)
831 struct tok_info *ti = (struct tok_info *) dev->priv;
833 SET_PAGE(ti->srb_page);
834 ti->open_failure = NO ;
835 dev->open = tok_open;
836 dev->stop = tok_close;
837 dev->hard_start_xmit = tok_send_packet;
838 dev->get_stats = tok_get_stats;
839 dev->set_multicast_list = tok_set_multicast_list;
840 dev->change_mtu = ibmtr_change_mtu;
845 /*****************************************************************************/
847 static int tok_init_card(struct net_device *dev)
853 init_waitqueue_entry(&__wait, current);
855 PIOaddr = dev->base_addr;
856 ti = (struct tok_info *) dev->priv;
857 /* Special processing for first interrupt after reset */
858 ti->do_tok_int = FIRST_INT;
860 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
861 outb(0, PIOaddr + ADAPTRESET);
863 current->state=TASK_UNINTERRUPTIBLE;
864 schedule_timeout(TR_RST_TIME); /* wait 50ms */
866 add_wait_queue(&ti->wait_for_reset, &__wait);
867 set_current_state(TASK_UNINTERRUPTIBLE);
868 outb(0, PIOaddr + ADAPTRESETREL);
871 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
873 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
874 #warning pci posting bug
875 i = schedule_timeout(4 * HZ);
876 current->state = TASK_RUNNING;
877 remove_wait_queue(&ti->wait_for_reset, &__wait);
878 return i? 0 : -EAGAIN;
881 /*****************************************************************************/
882 static int tok_open(struct net_device *dev)
884 struct tok_info *ti = (struct tok_info *) dev->priv;
887 /*the case we were left in a failure state during a previous open */
888 if (ti->open_failure == YES) {
889 DPRINTK("Last time you were disconnected, how about now?\n");
890 printk("You can't insert with an ICS connector half-cocked.\n");
893 ti->open_status = CLOSED; /* CLOSED or OPEN */
894 ti->sap_status = CLOSED; /* CLOSED or OPEN */
895 ti->open_failure = NO; /* NO or YES */
896 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
897 /* 12/2000 not typical Linux, but we can use RUNNING to let us know when
898 the network has crapped out or cables are disconnected. Useful because
899 the IFF_UP flag stays up the whole time, until ifconfig tr0 down.
901 dev->flags &= ~IFF_RUNNING;
903 ti->sram_virt &= ~1; /* to reverse what we do in tok_close */
904 /* init the spinlock */
905 ti->lock = (spinlock_t) SPIN_LOCK_UNLOCKED;
906 init_timer(&ti->tr_timer);
908 i = tok_init_card(dev);
912 tok_open_adapter((unsigned long) dev);
913 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
914 /* sig catch: estimate opening adapter takes more than .5 sec*/
915 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
917 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
918 netif_start_queue(dev);
919 DPRINTK("Adapter is up and running\n");
922 current->state=TASK_INTERRUPTIBLE;
923 i=schedule_timeout(TR_RETRY_INTERVAL); /* wait 30 seconds */
924 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
926 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
927 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
931 /*****************************************************************************/
933 #define COMMAND_OFST 0
934 #define OPEN_OPTIONS_OFST 8
935 #define NUM_RCV_BUF_OFST 24
936 #define RCV_BUF_LEN_OFST 26
937 #define DHB_LENGTH_OFST 28
938 #define NUM_DHB_OFST 30
939 #define DLC_MAX_SAP_OFST 32
940 #define DLC_MAX_STA_OFST 33
942 void tok_open_adapter(unsigned long dev_addr)
944 struct net_device *dev = (struct net_device *) dev_addr;
948 ti = (struct tok_info *) dev->priv;
949 SET_PAGE(ti->init_srb_page);
950 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
951 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
952 writeb(0, ti->init_srb + i);
953 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
954 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
955 if (ti->ring_speed == 16) {
956 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
957 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
958 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
960 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
961 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
962 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
964 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
965 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
966 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
967 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
968 ti->srb_page = ti->init_srb_page;
969 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
970 readb(ti->init_srb + NUM_DHB_OFST),
971 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
972 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
973 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
974 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
975 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
978 /*****************************************************************************/
980 static void open_sap(unsigned char type, struct net_device *dev)
983 struct tok_info *ti = (struct tok_info *) dev->priv;
985 SET_PAGE(ti->srb_page);
986 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
987 writeb(0, ti->srb + i);
989 #define MAX_I_FIELD_OFST 14
990 #define SAP_VALUE_OFST 16
991 #define SAP_OPTIONS_OFST 17
992 #define STATION_COUNT_OFST 18
994 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
995 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
996 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
997 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
998 writeb(type, ti->srb + SAP_VALUE_OFST);
999 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1003 /*****************************************************************************/
1005 static void tok_set_multicast_list(struct net_device *dev)
1007 struct tok_info *ti = (struct tok_info *) dev->priv;
1008 struct dev_mc_list *mclist;
1009 unsigned char address[4];
1013 /*BMS the next line is CRUCIAL or you may be sad when you */
1014 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
1015 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
1016 address[0] = address[1] = address[2] = address[3] = 0;
1017 mclist = dev->mc_list;
1018 for (i = 0; i < dev->mc_count; i++) {
1019 address[0] |= mclist->dmi_addr[2];
1020 address[1] |= mclist->dmi_addr[3];
1021 address[2] |= mclist->dmi_addr[4];
1022 address[3] |= mclist->dmi_addr[5];
1023 mclist = mclist->next;
1025 SET_PAGE(ti->srb_page);
1026 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1027 writeb(0, ti->srb + i);
1029 #define FUNCT_ADDRESS_OFST 6
1031 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1032 for (i = 0; i < 4; i++)
1033 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1034 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1036 DPRINTK("Setting functional address: ");
1037 for (i=0;i<4;i++) printk("%02X ", address[i]);
1042 /*****************************************************************************/
1044 #define STATION_ID_OFST 4
1046 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev)
1048 struct tok_info *ti;
1049 unsigned long flags;
1050 ti = (struct tok_info *) dev->priv;
1052 netif_stop_queue(dev);
1054 /* lock against other CPUs */
1055 spin_lock_irqsave(&(ti->lock), flags);
1057 /* Save skb; we'll need it when the adapter asks for the data */
1058 ti->current_skb = skb;
1059 SET_PAGE(ti->srb_page);
1060 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1061 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1062 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1063 spin_unlock_irqrestore(&(ti->lock), flags);
1064 dev->trans_start = jiffies;
1068 /*****************************************************************************/
1070 static int tok_close(struct net_device *dev)
1072 struct tok_info *ti = (struct tok_info *) dev->priv;
1074 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1075 /* unloading the module from memory, and then if a timer pops, ouch */
1076 del_timer_sync(&ti->tr_timer);
1077 outb(0, dev->base_addr + ADAPTRESET);
1079 ti->open_status = CLOSED;
1081 netif_stop_queue(dev);
1082 DPRINTK("Adapter is closed.\n");
1086 /*****************************************************************************/
1088 #define RETCODE_OFST 2
1089 #define OPEN_ERROR_CODE_OFST 6
1090 #define ASB_ADDRESS_OFST 8
1091 #define SRB_ADDRESS_OFST 10
1092 #define ARB_ADDRESS_OFST 12
1093 #define SSB_ADDRESS_OFST 14
1095 static char *printphase[]= {"Lobe media test","Physical insertion",
1096 "Address verification","Roll call poll","Request Parameters"};
1097 static char *printerror[]={"Function failure","Signal loss","Reserved",
1098 "Frequency error","Timeout","Ring failure","Ring beaconing",
1099 "Duplicate node address",
1100 "Parameter request-retry count exceeded","Remove received",
1101 "IMPL force received","Duplicate modifier",
1102 "No monitor detected","Monitor contention failed for RPL"};
1104 void dir_open_adapter (struct net_device *dev) {
1106 struct tok_info *ti = (struct tok_info *) dev->priv;
1107 unsigned char ret_code;
1110 ti->srb = ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST));
1111 ti->ssb = ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST));
1112 ti->arb = ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST));
1113 ti->asb = ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST));
1114 if (ti->page_mask) {
1115 ti->srb_page = (ti->srb >> 8) & ti->page_mask;
1116 ti->srb &= ~(ti->page_mask << 8);
1117 ti->ssb_page = (ti->ssb >> 8) & ti->page_mask;
1118 ti->ssb &= ~(ti->page_mask << 8);
1119 ti->arb_page = (ti->arb >> 8) & ti->page_mask;
1120 ti->arb &= ~(ti->page_mask << 8);
1121 ti->asb_page = (ti->asb >> 8) & ti->page_mask;
1122 ti->asb &= ~(ti->page_mask << 8);
1124 ti->srb += ti->sram_virt;
1125 ti->ssb += ti->sram_virt;
1126 ti->arb += ti->sram_virt;
1127 ti->asb += ti->sram_virt;
1128 ti->current_skb = NULL;
1129 ret_code = readb(ti->init_srb + RETCODE_OFST);
1130 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1132 ti->open_status = OPEN; /* TR adapter is now available */
1133 if (ti->open_mode == AUTOMATIC) {
1134 DPRINTK("Adapter reopened.\n");
1136 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1137 open_sap(EXTENDED_SAP, dev);
1140 ti->open_failure = YES;
1143 if (!ti->auto_speedsave) {
1144 DPRINTK("Open failed: Adapter speed must match "
1145 "ring speed if Automatic Ring Speed Save is "
1147 ti->open_action = FAIL;
1149 DPRINTK("Retrying open to adjust to "
1151 } else if (err == 0x2d) {
1152 DPRINTK("Physical Insertion: No Monitor Detected, ");
1153 printk("retrying after %ds delay...\n",
1154 TR_RETRY_INTERVAL/HZ);
1155 } else if (err == 0x11) {
1156 DPRINTK("Lobe Media Function Failure (0x11), ");
1157 printk(" retrying after %ds delay...\n",
1158 TR_RETRY_INTERVAL/HZ);
1160 char **prphase = printphase;
1161 char **prerror = printerror;
1162 DPRINTK("TR Adapter misc open failure, error code = ");
1163 printk("0x%x, Phase: %s, Error: %s\n",
1164 err, prphase[err/16 -1], prerror[err%16 -1]);
1165 printk(" retrying after %ds delay...\n",
1166 TR_RETRY_INTERVAL/HZ);
1168 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1169 if (ti->open_action != FAIL) {
1170 if (ti->open_mode==AUTOMATIC){
1171 ti->open_action = REOPEN;
1172 ibmtr_reset_timer(&(ti->tr_timer), dev);
1175 wake_up(&ti->wait_for_reset);
1178 DPRINTK("FAILURE, CAPUT\n");
1181 /******************************************************************************/
1183 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1185 unsigned char status;
1186 /* unsigned char status_even ; */
1187 struct tok_info *ti;
1188 struct net_device *dev;
1189 #ifdef ENABLE_PAGING
1190 unsigned char save_srpr;
1195 DPRINTK("Int from tok_driver, dev : %p irq%d regs=%p\n", dev,irq,regs);
1197 ti = (struct tok_info *) dev->priv;
1198 if (ti->sram_virt & 1)
1199 return IRQ_NONE; /* PCMCIA card extraction flag */
1200 spin_lock(&(ti->lock));
1201 #ifdef ENABLE_PAGING
1202 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1205 /* Disable interrupts till processing is finished */
1206 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1208 /* Reset interrupt for ISA boards */
1209 if (ti->adapter_int_enable)
1210 outb(0, ti->adapter_int_enable);
1211 else /* used for PCMCIA cards */
1212 outb(0, ti->global_int_enable);
1213 if (ti->do_tok_int == FIRST_INT){
1214 initial_tok_int(dev);
1215 #ifdef ENABLE_PAGING
1216 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1218 spin_unlock(&(ti->lock));
1221 /* Begin interrupt handler HERE inline to avoid the extra
1222 levels of logic and call depth for the original solution. */
1223 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1224 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1225 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1226 /*BMS status,status_even); */
1228 if (status & ADAP_CHK_INT) {
1231 __u8 check_reason_page = 0;
1233 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN));
1234 if (ti->page_mask) {
1235 check_reason_page = (check_reason >> 8) & ti->page_mask;
1236 check_reason &= ~(ti->page_mask << 8);
1238 check_reason += ti->sram_virt;
1239 SET_PAGE(check_reason_page);
1241 DPRINTK("Adapter check interrupt\n");
1242 DPRINTK("8 reason bytes follow: ");
1243 for (i = 0; i < 8; i++, check_reason++)
1244 printk("%02X ", (int) readb(check_reason));
1246 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1247 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1248 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1249 ti->open_status = CLOSED;
1250 ti->sap_status = CLOSED;
1251 ti->open_mode = AUTOMATIC;
1252 dev->flags &= ~IFF_RUNNING;
1253 netif_stop_queue(dev);
1254 ti->open_action = RESTART;
1255 outb(0, dev->base_addr + ADAPTRESET);
1256 ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/
1257 spin_unlock(&(ti->lock));
1260 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1261 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1262 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1263 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1264 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1265 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1266 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/
1267 DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/
1268 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1269 #ifdef ENABLE_PAGING
1270 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1272 spin_unlock(&(ti->lock));
1275 if (status & SRB_RESP_INT) { /* SRB response */
1276 SET_PAGE(ti->srb_page);
1278 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1279 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1281 switch (readb(ti->srb)) { /* SRB command check */
1282 case XMIT_DIR_FRAME:{
1283 unsigned char xmit_ret_code;
1284 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1285 if (xmit_ret_code == 0xff) break;
1286 DPRINTK("error on xmit_dir_frame request: %02X\n",
1288 if (ti->current_skb) {
1289 dev_kfree_skb_irq(ti->current_skb);
1290 ti->current_skb = NULL;
1293 netif_wake_queue(dev);
1294 if (ti->readlog_pending)
1298 case XMIT_UI_FRAME:{
1299 unsigned char xmit_ret_code;
1301 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1302 if (xmit_ret_code == 0xff) break;
1303 DPRINTK("error on xmit_ui_frame request: %02X\n",
1305 if (ti->current_skb) {
1306 dev_kfree_skb_irq(ti->current_skb);
1307 ti->current_skb = NULL;
1309 netif_wake_queue(dev);
1310 if (ti->readlog_pending)
1314 case DIR_OPEN_ADAPTER:
1315 dir_open_adapter(dev);
1318 if (readb(ti->srb + RETCODE_OFST)) {
1319 DPRINTK("open_sap failed: ret_code = %02X, "
1321 (int) readb(ti->srb + RETCODE_OFST));
1322 ti->open_action = REOPEN;
1323 ibmtr_reset_timer(&(ti->tr_timer), dev);
1326 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1327 ti->sap_status = OPEN;/* TR adapter is now available */
1328 if (ti->open_mode==MANUAL){
1329 wake_up(&ti->wait_for_reset);
1332 netif_wake_queue(dev);
1333 dev->flags |= IFF_RUNNING;/*BMS 12/2000*/
1336 case DIR_MOD_OPEN_PARAMS:
1337 case DIR_SET_GRP_ADDR:
1338 case DIR_SET_FUNC_ADDR:
1340 if (readb(ti->srb + RETCODE_OFST))
1341 DPRINTK("error on %02X: %02X\n",
1342 (int) readb(ti->srb + COMMAND_OFST),
1343 (int) readb(ti->srb + RETCODE_OFST));
1346 if (readb(ti->srb + RETCODE_OFST)){
1347 DPRINTK("error on dir_read_log: %02X\n",
1348 (int) readb(ti->srb + RETCODE_OFST));
1349 netif_wake_queue(dev);
1352 #if IBMTR_DEBUG_MESSAGES
1354 #define LINE_ERRORS_OFST 0
1355 #define INTERNAL_ERRORS_OFST 1
1356 #define BURST_ERRORS_OFST 2
1357 #define AC_ERRORS_OFST 3
1358 #define ABORT_DELIMITERS_OFST 4
1359 #define LOST_FRAMES_OFST 6
1360 #define RECV_CONGEST_COUNT_OFST 7
1361 #define FRAME_COPIED_ERRORS_OFST 8
1362 #define FREQUENCY_ERRORS_OFST 9
1363 #define TOKEN_ERRORS_OFST 10
1365 DPRINTK("Line errors %02X, Internal errors %02X, "
1366 "Burst errors %02X\n" "A/C errors %02X, "
1367 "Abort delimiters %02X, Lost frames %02X\n"
1368 "Receive congestion count %02X, "
1369 "Frame copied errors %02X\nFrequency errors %02X, "
1370 "Token errors %02X\n",
1371 (int) readb(ti->srb + LINE_ERRORS_OFST),
1372 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1373 (int) readb(ti->srb + BURST_ERRORS_OFST),
1374 (int) readb(ti->srb + AC_ERRORS_OFST),
1375 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1376 (int) readb(ti->srb + LOST_FRAMES_OFST),
1377 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1378 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1379 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1380 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1382 netif_wake_queue(dev);
1385 DPRINTK("Unknown command %02X encountered\n",
1386 (int) readb(ti->srb));
1387 } /* end switch SRB command check */
1388 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1389 } /* if SRB response */
1390 if (status & ASB_FREE_INT) { /* ASB response */
1391 SET_PAGE(ti->asb_page);
1393 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1396 switch (readb(ti->asb)) { /* ASB command check */
1399 case XMIT_DIR_FRAME:
1402 DPRINTK("unknown command in asb %02X\n",
1403 (int) readb(ti->asb));
1404 } /* switch ASB command check */
1405 if (readb(ti->asb + 2) != 0xff) /* checks ret_code */
1406 DPRINTK("ASB error %02X in cmd %02X\n",
1407 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1408 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1409 } /* if ASB response */
1411 #define STATUS_OFST 6
1412 #define NETW_STATUS_OFST 6
1414 if (status & ARB_CMD_INT) { /* ARB response */
1415 SET_PAGE(ti->arb_page);
1417 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1420 switch (readb(ti->arb)) { /* ARB command check */
1422 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1423 ntohs(readw(ti->arb + STATUS_OFST)),
1424 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1429 case RING_STAT_CHANGE:{
1430 unsigned short ring_status;
1431 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1432 if (ibmtr_debug_trace & TRC_INIT)
1433 DPRINTK("Ring Status Change...(0x%x)\n",
1435 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1436 netif_stop_queue(dev);
1437 dev->flags &= ~IFF_RUNNING;/*not typical Linux*/
1438 DPRINTK("Remove received, or Auto-removal error"
1439 ", or Lobe fault\n");
1440 DPRINTK("We'll try to reopen the closed adapter"
1441 " after a %d second delay.\n",
1442 TR_RETRY_INTERVAL/HZ);
1443 /*I was confused: I saw the TR reopening but */
1444 /*forgot:with an RJ45 in an RJ45/ICS adapter */
1445 /*but adapter not in the ring, the TR will */
1446 /* open, and then soon close and come here. */
1447 ti->open_mode = AUTOMATIC;
1448 ti->open_status = CLOSED; /*12/2000 BMS*/
1449 ti->open_action = REOPEN;
1450 ibmtr_reset_timer(&(ti->tr_timer), dev);
1451 } else if (ring_status & LOG_OVERFLOW) {
1452 if(netif_queue_stopped(dev))
1453 ti->readlog_pending = 1;
1463 DPRINTK("Unknown command %02X in arb\n",
1464 (int) readb(ti->arb));
1466 } /* switch ARB command check */
1467 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1468 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1469 } /* if ARB response */
1470 if (status & SSB_RESP_INT) { /* SSB response */
1471 unsigned char retcode;
1472 SET_PAGE(ti->ssb_page);
1474 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1475 readb(ti->ssb), readb(ti->ssb + 2));
1478 switch (readb(ti->ssb)) { /* SSB command check */
1479 case XMIT_DIR_FRAME:
1481 retcode = readb(ti->ssb + 2);
1482 if (retcode && (retcode != 0x22))/* checks ret_code */
1483 DPRINTK("xmit ret_code: %02X xmit error code: "
1485 (int)retcode, (int)readb(ti->ssb + 6));
1487 ti->tr_stats.tx_packets++;
1490 DPRINTK("xmit xid ret_code: %02X\n",
1491 (int) readb(ti->ssb + 2));
1493 DPRINTK("Unknown command %02X in ssb\n",
1494 (int) readb(ti->ssb));
1495 } /* SSB command check */
1496 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1497 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1498 } /* if SSB response */
1499 #ifdef ENABLE_PAGING
1500 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1502 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1503 spin_unlock(&(ti->lock));
1505 } /*tok_interrupt */
1507 /*****************************************************************************/
1509 #define INIT_STATUS_OFST 1
1510 #define INIT_STATUS_2_OFST 2
1511 #define ENCODED_ADDRESS_OFST 8
1513 static void initial_tok_int(struct net_device *dev)
1516 __u32 encoded_addr, hw_encoded_addr;
1517 struct tok_info *ti;
1518 unsigned char init_status; /*BMS 12/2000*/
1520 ti = (struct tok_info *) dev->priv;
1522 ti->do_tok_int = NOT_FIRST;
1524 /* we assign the shared-ram address for ISA devices */
1525 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1527 ti->sram_virt = (u32)ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1529 ti->init_srb = ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN));
1530 if (ti->page_mask) {
1531 ti->init_srb_page = (ti->init_srb >> 8) & ti->page_mask;
1532 ti->init_srb &= ~(ti->page_mask << 8);
1534 ti->init_srb += ti->sram_virt;
1535 if (ti->page_mask && ti->avail_shared_ram == 127) {
1536 int last_512 = 0xfe00, i;
1537 int last_512_page=0;
1538 last_512_page=(last_512>>8)&ti->page_mask;
1539 last_512 &= ~(ti->page_mask << 8);
1540 /* initialize high section of ram (if necessary) */
1541 SET_PAGE(last_512_page);
1542 for (i = 0; i < 512; i++)
1543 writeb(0, ti->sram_virt + last_512 + i);
1545 SET_PAGE(ti->init_srb_page);
1551 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1552 DPRINTK("init_srb(%x):", (ti->init_srb) );
1553 for (i = 0; i < 20; i++)
1554 printk("%02X ", (int) readb(ti->init_srb + i));
1559 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1560 encoded_addr = ntohs(hw_encoded_addr);
1561 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1562 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1563 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1564 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1565 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1566 ti->ring_speed, (unsigned int)dev->mem_start);
1567 ti->auto_speedsave=readb(ti->init_srb+INIT_STATUS_2_OFST)&4?TRUE:FALSE;
1569 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1570 else tok_open_adapter((unsigned long)dev);
1572 } /*initial_tok_int() */
1574 /*****************************************************************************/
1576 #define CMD_CORRELATE_OFST 1
1577 #define DHB_ADDRESS_OFST 6
1579 #define FRAME_LENGTH_OFST 6
1580 #define HEADER_LENGTH_OFST 8
1581 #define RSAP_VALUE_OFST 9
1583 static void tr_tx(struct net_device *dev)
1585 struct tok_info *ti = (struct tok_info *) dev->priv;
1586 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1587 unsigned int hdr_len;
1588 __u32 dhb=0,dhb_base;
1589 unsigned char xmit_command;
1590 int i,dhb_len=0x4000,src_len,src_offset;
1592 struct srb_xmit xsrb;
1596 SET_PAGE(ti->asb_page);
1598 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1600 /* in providing the transmit interrupts, is telling us it is ready for
1601 data and providing a shared memory address for us to stuff with data.
1602 Here we compute the effective address where we will place data.
1604 SET_PAGE(ti->arb_page);
1605 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1606 if (ti->page_mask) {
1607 dhb_page = (dhb_base >> 8) & ti->page_mask;
1608 dhb=dhb_base & ~(ti->page_mask << 8);
1610 dhb += ti->sram_virt;
1612 /* Figure out the size of the 802.5 header */
1613 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1614 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1616 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1617 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1619 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1621 llc_ssap = llc->ssap;
1622 SET_PAGE(ti->srb_page);
1623 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1624 SET_PAGE(ti->asb_page);
1625 xmit_command = xsrb.command;
1627 writeb(xmit_command, ti->asb + COMMAND_OFST);
1628 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1629 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1630 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1631 writeb(0, ti->asb + RETCODE_OFST);
1632 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1633 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1634 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1637 writeb(LLC_FRAME, dhb + 1);
1638 for (i = 0; i < TR_ALEN; i++)
1639 writeb((int) 0x0FF, dhb + i + 2);
1640 for (i = 0; i < TR_ALEN; i++)
1641 writeb(0, dhb + i + TR_ALEN + 2);
1642 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1646 * the token ring packet is copied from sk_buff to the adapter
1647 * buffer identified in the command data received with the interrupt.
1649 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1650 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1651 src_len=ti->current_skb->len;
1655 if (ti->page_mask) {
1656 dhb_page=(dhb >> 8) & ti->page_mask;
1657 dhb=dhb & ~(ti->page_mask << 8);
1658 dhb_len=0x4000-dhb; /* remaining size of this page */
1662 if (src_len > dhb_len) {
1663 memcpy_toio(dhb,&ti->current_skb->data[src_offset],
1666 src_offset += dhb_len;
1671 memcpy_toio(dhb, &ti->current_skb->data[src_offset], src_len);
1674 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1675 ti->tr_stats.tx_bytes += ti->current_skb->len;
1676 dev_kfree_skb_irq(ti->current_skb);
1677 ti->current_skb = NULL;
1678 netif_wake_queue(dev);
1679 if (ti->readlog_pending)
1683 /*****************************************************************************/
1686 #define RECEIVE_BUFFER_OFST 6
1687 #define LAN_HDR_LENGTH_OFST 8
1688 #define DLC_HDR_LENGTH_OFST 9
1693 #define PROTID_OFST 3
1694 #define ETHERTYPE_OFST 6
1696 static void tr_rx(struct net_device *dev)
1698 struct tok_info *ti = (struct tok_info *) dev->priv;
1699 __u32 rbuffer, rbufdata;
1700 __u8 rbuffer_page = 0;
1702 unsigned char *data;
1703 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1704 unsigned char dlc_hdr_len;
1705 struct sk_buff *skb;
1706 unsigned int skb_size = 0;
1708 unsigned int chksum = 0;
1710 struct arb_rec_req rarb;
1712 SET_PAGE(ti->arb_page);
1713 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1714 rbuffer = ntohs(rarb.rec_buf_addr) ;
1715 if (ti->page_mask) {
1716 rbuffer_page = (rbuffer >> 8) & ti->page_mask;
1717 rbuffer &= ~(ti->page_mask << 8);
1719 rbuffer += ti->sram_virt;
1721 SET_PAGE(ti->asb_page);
1723 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1725 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1726 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1727 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1729 lan_hdr_len = rarb.lan_hdr_len;
1730 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1731 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1733 } /*BMS I added this above just to be very safe */
1734 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1735 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1737 SET_PAGE(rbuffer_page);
1738 llc = (rbuffer + offsetof(struct rec_buf, data) + lan_hdr_len);
1741 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1742 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1743 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1744 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1745 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1746 "ethertype: %04X\n",
1747 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1748 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1749 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1750 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1752 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1753 SET_PAGE(ti->asb_page);
1754 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1755 ti->tr_stats.rx_dropped++;
1756 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1759 length = ntohs(rarb.frame_len);
1760 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1761 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1762 length >= hdr_len) IPv4_p = 1;
1764 #define SADDR_OFST 8
1765 #define DADDR_OFST 2
1771 trhhdr = (rbuffer + offsetof(struct rec_buf, data));
1773 DPRINTK("Probably non-IP frame received.\n");
1774 DPRINTK("ssap: %02X dsap: %02X "
1775 "saddr: %02X:%02X:%02X:%02X:%02X:%02X "
1776 "daddr: %02X:%02X:%02X:%02X:%02X:%02X\n",
1777 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1778 readb(trhhdr+SADDR_OFST), readb(trhhdr+ SADDR_OFST+1),
1779 readb(trhhdr+SADDR_OFST+2), readb(trhhdr+SADDR_OFST+3),
1780 readb(trhhdr+SADDR_OFST+4), readb(trhhdr+SADDR_OFST+5),
1781 readb(trhhdr+DADDR_OFST), readb(trhhdr+DADDR_OFST + 1),
1782 readb(trhhdr+DADDR_OFST+2), readb(trhhdr+DADDR_OFST+3),
1783 readb(trhhdr+DADDR_OFST+4), readb(trhhdr+DADDR_OFST+5));
1787 /*BMS handle the case she comes in with few hops but leaves with many */
1788 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1790 if (!(skb = dev_alloc_skb(skb_size))) {
1791 DPRINTK("out of memory. frame dropped.\n");
1792 ti->tr_stats.rx_dropped++;
1793 SET_PAGE(ti->asb_page);
1794 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1795 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1798 /*BMS again, if she comes in with few but leaves with many */
1799 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1800 skb_put(skb, length);
1803 rbuffer_len = ntohs(readw(rbuffer + offsetof(struct rec_buf, buf_len)));
1804 rbufdata = rbuffer + offsetof(struct rec_buf, data);
1807 /* Copy the headers without checksumming */
1808 memcpy_fromio(data, rbufdata, hdr_len);
1810 /* Watch for padded packets and bogons */
1811 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1812 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1814 if ((ip_len <= length) && (ip_len > 7))
1817 rbuffer_len -= hdr_len;
1818 rbufdata += hdr_len;
1820 /* Copy the payload... */
1821 #define BUFFER_POINTER_OFST 2
1822 #define BUFFER_LENGTH_OFST 6
1824 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1825 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1826 length,rbuffer_len);
1828 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1829 data,length<rbuffer_len?length:rbuffer_len,chksum);
1831 memcpy_fromio(data, rbufdata, rbuffer_len);
1832 rbuffer = ntohs(readw(rbuffer+BUFFER_POINTER_OFST)) ;
1836 length -= rbuffer_len;
1837 data += rbuffer_len;
1838 if (ti->page_mask) {
1839 rbuffer_page = (rbuffer >> 8) & ti->page_mask;
1840 rbuffer &= ~(ti->page_mask << 8);
1842 rbuffer += ti->sram_virt;
1843 SET_PAGE(rbuffer_page);
1844 rbuffer_len = ntohs(readw(rbuffer + BUFFER_LENGTH_OFST));
1845 rbufdata = rbuffer + offsetof(struct rec_buf, data);
1848 SET_PAGE(ti->asb_page);
1849 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1851 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1853 ti->tr_stats.rx_bytes += skb->len;
1854 ti->tr_stats.rx_packets++;
1856 skb->protocol = tr_type_trans(skb, dev);
1862 dev->last_rx = jiffies;
1865 /*****************************************************************************/
1867 void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1869 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1870 tmr->data = (unsigned long) dev;
1871 tmr->function = tok_rerun;
1876 /*****************************************************************************/
1878 void tok_rerun(unsigned long dev_addr){
1880 struct net_device *dev = (struct net_device *)dev_addr;
1881 struct tok_info *ti = (struct tok_info *) dev->priv;
1883 if ( ti->open_action == RESTART){
1884 ti->do_tok_int = FIRST_INT;
1885 outb(0, dev->base_addr + ADAPTRESETREL);
1886 #ifdef ENABLE_PAGING
1888 writeb(SRPR_ENABLE_PAGING,
1889 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1892 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1894 tok_open_adapter(dev_addr);
1897 /*****************************************************************************/
1899 void ibmtr_readlog(struct net_device *dev)
1901 struct tok_info *ti;
1903 ti = (struct tok_info *) dev->priv;
1905 ti->readlog_pending = 0;
1906 SET_PAGE(ti->srb_page);
1907 writeb(DIR_READ_LOG, ti->srb);
1908 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1909 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1911 netif_stop_queue(dev);
1915 /*****************************************************************************/
1917 /* tok_get_stats(): Basically a scaffold routine which will return
1918 the address of the tr_statistics structure associated with
1919 this device -- the tr.... structure is an ethnet look-alike
1920 so at least for this iteration may suffice. */
1922 static struct net_device_stats *tok_get_stats(struct net_device *dev)
1925 struct tok_info *toki;
1926 toki = (struct tok_info *) dev->priv;
1927 return (struct net_device_stats *) &toki->tr_stats;
1930 /*****************************************************************************/
1932 int ibmtr_change_mtu(struct net_device *dev, int mtu)
1934 struct tok_info *ti = (struct tok_info *) dev->priv;
1936 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1938 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1944 /*****************************************************************************/
1947 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1948 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1949 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1950 static int irq[IBMTR_MAX_ADAPTERS];
1951 static int mem[IBMTR_MAX_ADAPTERS];
1953 MODULE_LICENSE("GPL");
1955 MODULE_PARM(io, "1-" __MODULE_STRING(IBMTR_MAX_ADAPTERS) "i");
1956 MODULE_PARM(irq, "1-" __MODULE_STRING(IBMTR_MAX_ADAPTERS) "i");
1957 MODULE_PARM(mem, "1-" __MODULE_STRING(IBMTR_MAX_ADAPTERS) "i");
1959 static int __init ibmtr_init(void)
1964 find_turbo_adapters(io);
1966 for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) {
1967 struct net_device *dev;
1970 dev = alloc_trdev(sizeof(struct tok_info));
1976 dev->base_addr = io[i];
1978 dev->mem_start = mem[i];
1980 if (ibmtr_probe_card(dev)) {
1987 if (count) return 0;
1988 printk("ibmtr: register_netdev() returned non-zero.\n");
1991 module_init(ibmtr_init);
1993 static void __exit ibmtr_cleanup(void)
1997 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
2000 unregister_netdev(dev_ibmtr[i]);
2001 ibmtr_cleanup_card(dev_ibmtr[i]);
2002 free_netdev(dev_ibmtr[i]);
2005 module_exit(ibmtr_cleanup);