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[] __devinitdata =
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 static 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 static 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 static 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 static 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 static irqreturn_t tok_interrupt(int irq, void *dev_id);
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 static void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev);
205 static void tok_rerun(unsigned long dev_addr);
206 static void ibmtr_readlog(struct net_device *dev);
207 static struct net_device_stats *tok_get_stats(struct net_device *dev);
208 static 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 __devinitdata = 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 __iomem *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)
246 void __iomem *chanid;
248 unsigned char *tchanid, ctemp;
251 void __iomem *ram_mapped ;
253 if (turbo_searched == 1) return;
255 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
260 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
261 if (ram_mapped==NULL)
263 chanid=(CHANNEL_ID + ram_mapped);
265 ctemp=readb(chanid) & 0x0f;
266 if (ctemp != *tchanid) continue;
267 for (i=2,j=1; i<=46; i=i+2,j++) {
268 if ((readb(chanid+i) & 0x0f) != tchanid[j]){
273 if (!found_turbo) continue;
275 writeb(0x90, ram_mapped+0x1E01);
276 for(i=2; i<0x0f; i++) {
277 writeb(0x00, ram_mapped+0x1E01+i);
279 writeb(0x00, ram_mapped+0x1E01);
280 for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif););
281 intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN));
283 #if IBMTR_DEBUG_MESSAGES
284 printk("ibmtr::find_turbo_adapters, Turbo found at "
285 "ram_addr %x\n",ram_addr);
286 printk("ibmtr::find_turbo_adapters, interface_table ");
288 printk("%x:",readb(ram_addr+intf_tbl+i));
292 turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4));
293 turbo_irq[index]=readb(ram_mapped+intf_tbl+3);
294 outb(0, turbo_io[index] + ADAPTRESET);
295 for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif););
296 outb(0, turbo_io[index] + ADAPTRESETREL);
300 #if IBMTR_DEBUG_MESSAGES
301 printk("ibmtr::find_turbo_adapters, ibmtr card found at"
302 " %x but not a Turbo model\n",ram_addr);
304 iounmap(ram_mapped) ;
306 for(i=0; i<IBMTR_MAX_ADAPTERS; i++) {
307 if(!turbo_io[i]) break;
308 for (j=0; j<IBMTR_MAX_ADAPTERS; j++) {
309 if ( iolist[j] && iolist[j] != turbo_io[i]) continue;
310 iolist[j]=turbo_io[i];
316 static void ibmtr_cleanup_card(struct net_device *dev)
318 if (dev->base_addr) {
319 outb(0,dev->base_addr+ADAPTRESET);
321 schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
323 outb(0,dev->base_addr+ADAPTRESETREL);
327 free_irq(dev->irq, dev);
328 release_region(dev->base_addr, IBMTR_IO_EXTENT);
331 struct tok_info *ti = (struct tok_info *) dev->priv;
333 iounmap(ti->sram_virt);
338 int ibmtr_probe_card(struct net_device *dev)
340 int err = ibmtr_probe(dev);
342 err = register_netdev(dev);
344 ibmtr_cleanup_card(dev);
349 /****************************************************************************
350 * ibmtr_probe(): Routine specified in the network device structure
351 * to probe for an IBM Token Ring Adapter. Routine outline:
352 * I. Interrogate hardware to determine if an adapter exists
353 * and what the speeds and feeds are
354 * II. Setup data structures to control execution based upon
355 * adapter characteristics.
357 * We expect ibmtr_probe to be called once for each device entry
358 * which references it.
359 ****************************************************************************/
361 static int ibmtr_probe(struct net_device *dev)
364 int base_addr = dev->base_addr;
366 if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */
368 if (base_addr > 0x1ff) { /* Check a single specified location. */
369 if (!ibmtr_probe1(dev, base_addr)) return 0;
372 find_turbo_adapters(ibmtr_portlist);
373 for (i = 0; ibmtr_portlist[i]; i++) {
374 int ioaddr = ibmtr_portlist[i];
376 if (!ibmtr_probe1(dev, ioaddr)) return 0;
381 /*****************************************************************************/
383 static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
386 unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0;
387 void __iomem * t_mmio = NULL;
388 struct tok_info *ti = dev->priv;
389 void __iomem *cd_chanid;
390 unsigned char *tchanid, ctemp;
392 unsigned char t_irq=0;
393 unsigned long timeout;
394 static int version_printed;
397 /* Query the adapter PIO base port which will return
398 * indication of where MMIO was placed. We also have a
399 * coded interrupt number.
401 segment = inb(PIOaddr);
402 if (segment < 0x40 || segment > 0xe0) {
403 /* Out of range values so we'll assume non-existent IO device
404 * but this is not necessarily a problem, esp if a turbo
405 * adapter is being used. */
406 #if IBMTR_DEBUG_MESSAGES
407 DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, "
408 "Hardware Problem?\n",PIOaddr,segment);
413 * Compute the linear base address of the MMIO area
414 * as LINUX doesn't care about segments
416 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
418 DPRINTK("Cannot remap mmiobase memory area") ;
421 intr = segment & 0x03; /* low bits is coded interrupt # */
422 if (ibmtr_debug_trace & TRC_INIT)
423 DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n"
424 , PIOaddr, (int) segment, t_mmio, (int) intr);
427 * Now we will compare expected 'channelid' strings with
428 * what we is there to learn of ISA/MCA or not TR card
432 t_mmio = ti->mmio; /*BMS to get virtual address */
433 irq = ti->irq; /*BMS to display the irq! */
435 cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */
436 tchanid = pcchannelid;
437 cardpresent = TR_ISA; /* try ISA */
439 /* Suboptimize knowing first byte different */
440 ctemp = readb(cd_chanid) & 0x0f;
441 if (ctemp != *tchanid) { /* NOT ISA card, try MCA */
442 tchanid = mcchannelid;
443 cardpresent = TR_MCA;
444 if (ctemp != *tchanid) /* Neither ISA nor MCA */
447 if (cardpresent != NOTOK) {
448 /* Know presumed type, try rest of ID */
449 for (i = 2, j = 1; i <= 46; i = i + 2, j++) {
450 if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue;
451 /* match failed, not TR card */
457 * If we have an ISA board check for the ISA P&P version,
458 * as it has different IRQ settings
460 if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e))
461 cardpresent = TR_ISAPNP;
462 if (cardpresent == NOTOK) { /* "channel_id" did not match, report */
463 if (!(ibmtr_debug_trace & TRC_INIT)) {
469 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
471 DPRINTK("Expected for ISA: ");
472 PrtChanID(pcchannelid, 1);
474 /* BMS Note that this can be misleading, when hardware is flaky, because you
475 are reading it a second time here. So with my flaky hardware, I'll see my-
476 self in this block, with the HW ID matching the ISA ID exactly! */
477 HWPrtChanID(cd_chanid, 2);
478 DPRINTK("Expected for MCA: ");
479 PrtChanID(mcchannelid, 1);
481 /* Now, setup some of the pl0 buffers for this driver.. */
482 /* If called from PCMCIA, it is already set up, so no need to
483 waste the memory, just use the existing structure */
486 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
487 if (turbo_io[i] != PIOaddr)
489 #if IBMTR_DEBUG_MESSAGES
490 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
494 t_irq = turbo_irq[i];
497 ti->readlog_pending = 0;
498 init_waitqueue_head(&ti->wait_for_reset);
500 /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP
501 * depending which card is inserted. */
504 switch (cardpresent) {
506 if (intr == 0) irq = 9; /* irq2 really is irq9 */
507 if (intr == 1) irq = 3;
508 if (intr == 2) irq = 6;
509 if (intr == 3) irq = 7;
510 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
513 if (intr == 0) irq = 9;
514 if (intr == 1) irq = 3;
515 if (intr == 2) irq = 10;
516 if (intr == 3) irq = 11;
517 ti->global_int_enable = 0;
518 ti->adapter_int_enable = 0;
519 ti->sram_phys=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12;
523 if (intr == 0) irq = 9;
524 if (intr == 1) irq = 3;
525 if (intr == 2) irq = 10;
526 if (intr == 3) irq = 11;
529 timeout = jiffies + TR_SPIN_INTERVAL;
530 while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){
531 if (!time_after(jiffies, timeout)) continue;
532 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_phys=0x%x", ti->sram_phys);
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);
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);
677 } else { /* seems cool, record what we have figured out */
678 ti->sram_base = new_base >> 12;
679 ibmtr_mem_base = chk_base;
682 else ti->sram_base = ti->sram_phys >> 12;
684 /* The PCMCIA has already got the interrupt line and the io port,
685 so no chance of anybody else getting it - MLP */
686 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
687 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
692 /*?? Now, allocate some of the PIO PORTs for this driver.. */
693 /* record PIOaddr range as busy */
694 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
695 DPRINTK("Could not grab PIO range. Halting driver.\n");
696 free_irq(dev->irq, dev);
701 if (!version_printed++) {
705 DPRINTK("%s %s found\n",
706 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
707 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
708 irq, PIOaddr, ti->mapped_ram_size / 2);
709 DPRINTK("Hardware address : %02X:%02X:%02X:%02X:%02X:%02X\n",
710 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
711 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
713 DPRINTK("Shared RAM paging enabled. "
714 "Page size: %uK Shared Ram size %dK\n",
715 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
717 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
720 /* Calculate the maximum DHB we can use */
721 /* two cases where avail_shared_ram doesn't equal mapped_ram_size:
722 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical)
723 2. user has configured adapter for less than avail_shared_ram
724 but is not using paging (she should use paging, I believe)
726 if (!ti->page_mask) {
727 ti->avail_shared_ram=
728 min(ti->mapped_ram_size,ti->avail_shared_ram);
731 switch (ti->avail_shared_ram) {
732 case 16: /* 8KB shared RAM */
733 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
734 ti->rbuf_len4 = 1032;
736 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
737 ti->rbuf_len16 = 1032;
740 case 32: /* 16KB shared RAM */
741 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
742 ti->rbuf_len4 = 1032;
744 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
745 ti->rbuf_len16 = 1032; /*1024 usable */
748 case 64: /* 32KB shared RAM */
749 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
750 ti->rbuf_len4 = 1032;
752 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
753 ti->rbuf_len16 = 1032;
756 case 127: /* 63.5KB shared RAM */
757 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
758 ti->rbuf_len4 = 1032;
760 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
761 ti->rbuf_len16 = 1032;
764 case 128: /* 64KB shared RAM */
765 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
766 ti->rbuf_len4 = 1032;
768 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
769 ti->rbuf_len16 = 1032;
773 ti->dhb_size4mb = 2048;
774 ti->rbuf_len4 = 1032;
776 ti->dhb_size16mb = 2048;
777 ti->rbuf_len16 = 1032;
781 /* this formula is not smart enough for the paging case
782 ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE -
783 ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH -
784 DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB -
785 SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>;
787 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
788 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
789 /*BMS assuming 18 bytes of Routing Information (usually works) */
790 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
791 ti->maxmtu16, ti->maxmtu4);
793 dev->base_addr = PIOaddr; /* set the value for device */
794 dev->mem_start = ti->sram_base << 12;
795 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
797 return 0; /* Return 0 to indicate we have found a Token Ring card. */
798 } /*ibmtr_probe1() */
800 /*****************************************************************************/
802 /* query the adapter for the size of shared RAM */
803 /* the function returns the RAM size in units of 512 bytes */
805 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
807 unsigned char avail_sram_code;
808 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
810 'F' -- use RRR bits 3,2
811 'E' -- 8kb 'D' -- 16kb
812 'C' -- 32kb 'A' -- 64KB
813 'B' - 64KB less 512 bytes at top
814 (WARNING ... must zero top bytes in INIT */
816 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
817 if (avail_sram_code) return size_code[avail_sram_code];
818 else /* for code 'F', must compute size from RRR(3,2) bits */
820 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
823 /*****************************************************************************/
825 static int __devinit trdev_init(struct net_device *dev)
827 struct tok_info *ti = (struct tok_info *) dev->priv;
829 SET_PAGE(ti->srb_page);
830 ti->open_failure = NO ;
831 dev->open = tok_open;
832 dev->stop = tok_close;
833 dev->hard_start_xmit = tok_send_packet;
834 dev->get_stats = tok_get_stats;
835 dev->set_multicast_list = tok_set_multicast_list;
836 dev->change_mtu = ibmtr_change_mtu;
841 /*****************************************************************************/
843 static int tok_init_card(struct net_device *dev)
849 init_waitqueue_entry(&__wait, current);
851 PIOaddr = dev->base_addr;
852 ti = (struct tok_info *) dev->priv;
853 /* Special processing for first interrupt after reset */
854 ti->do_tok_int = FIRST_INT;
856 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
857 outb(0, PIOaddr + ADAPTRESET);
859 schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
861 add_wait_queue(&ti->wait_for_reset, &__wait);
862 set_current_state(TASK_UNINTERRUPTIBLE);
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 #warning pci posting bug
870 i = schedule_timeout(4 * HZ);
871 current->state = TASK_RUNNING;
872 remove_wait_queue(&ti->wait_for_reset, &__wait);
873 return i? 0 : -EAGAIN;
876 /*****************************************************************************/
877 static int tok_open(struct net_device *dev)
879 struct tok_info *ti = (struct tok_info *) dev->priv;
882 /*the case we were left in a failure state during a previous open */
883 if (ti->open_failure == YES) {
884 DPRINTK("Last time you were disconnected, how about now?\n");
885 printk("You can't insert with an ICS connector half-cocked.\n");
888 ti->open_status = CLOSED; /* CLOSED or OPEN */
889 ti->sap_status = CLOSED; /* CLOSED or OPEN */
890 ti->open_failure = NO; /* NO or YES */
891 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
893 ti->sram_phys &= ~1; /* to reverse what we do in tok_close */
894 /* init the spinlock */
895 spin_lock_init(&ti->lock);
896 init_timer(&ti->tr_timer);
898 i = tok_init_card(dev);
902 tok_open_adapter((unsigned long) dev);
903 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
904 /* sig catch: estimate opening adapter takes more than .5 sec*/
905 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
907 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
908 netif_start_queue(dev);
909 DPRINTK("Adapter is up and running\n");
912 i=schedule_timeout_interruptible(TR_RETRY_INTERVAL);
913 /* wait 30 seconds */
914 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
916 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
917 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
921 /*****************************************************************************/
923 #define COMMAND_OFST 0
924 #define OPEN_OPTIONS_OFST 8
925 #define NUM_RCV_BUF_OFST 24
926 #define RCV_BUF_LEN_OFST 26
927 #define DHB_LENGTH_OFST 28
928 #define NUM_DHB_OFST 30
929 #define DLC_MAX_SAP_OFST 32
930 #define DLC_MAX_STA_OFST 33
932 static void tok_open_adapter(unsigned long dev_addr)
934 struct net_device *dev = (struct net_device *) dev_addr;
938 ti = (struct tok_info *) dev->priv;
939 SET_PAGE(ti->init_srb_page);
940 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
941 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
942 writeb(0, ti->init_srb + i);
943 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
944 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
945 if (ti->ring_speed == 16) {
946 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
947 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
948 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
950 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
951 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
952 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
954 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
955 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
956 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
957 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
958 ti->srb_page = ti->init_srb_page;
959 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
960 readb(ti->init_srb + NUM_DHB_OFST),
961 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
962 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
963 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
964 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
965 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
968 /*****************************************************************************/
970 static void open_sap(unsigned char type, struct net_device *dev)
973 struct tok_info *ti = (struct tok_info *) dev->priv;
975 SET_PAGE(ti->srb_page);
976 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
977 writeb(0, ti->srb + i);
979 #define MAX_I_FIELD_OFST 14
980 #define SAP_VALUE_OFST 16
981 #define SAP_OPTIONS_OFST 17
982 #define STATION_COUNT_OFST 18
984 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
985 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
986 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
987 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
988 writeb(type, ti->srb + SAP_VALUE_OFST);
989 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
993 /*****************************************************************************/
995 static void tok_set_multicast_list(struct net_device *dev)
997 struct tok_info *ti = (struct tok_info *) dev->priv;
998 struct dev_mc_list *mclist;
999 unsigned char address[4];
1003 /*BMS the next line is CRUCIAL or you may be sad when you */
1004 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
1005 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
1006 address[0] = address[1] = address[2] = address[3] = 0;
1007 mclist = dev->mc_list;
1008 for (i = 0; i < dev->mc_count; i++) {
1009 address[0] |= mclist->dmi_addr[2];
1010 address[1] |= mclist->dmi_addr[3];
1011 address[2] |= mclist->dmi_addr[4];
1012 address[3] |= mclist->dmi_addr[5];
1013 mclist = mclist->next;
1015 SET_PAGE(ti->srb_page);
1016 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1017 writeb(0, ti->srb + i);
1019 #define FUNCT_ADDRESS_OFST 6
1021 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1022 for (i = 0; i < 4; i++)
1023 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1024 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1026 DPRINTK("Setting functional address: ");
1027 for (i=0;i<4;i++) printk("%02X ", address[i]);
1032 /*****************************************************************************/
1034 #define STATION_ID_OFST 4
1036 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev)
1038 struct tok_info *ti;
1039 unsigned long flags;
1040 ti = (struct tok_info *) dev->priv;
1042 netif_stop_queue(dev);
1044 /* lock against other CPUs */
1045 spin_lock_irqsave(&(ti->lock), flags);
1047 /* Save skb; we'll need it when the adapter asks for the data */
1048 ti->current_skb = skb;
1049 SET_PAGE(ti->srb_page);
1050 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1051 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1052 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1053 spin_unlock_irqrestore(&(ti->lock), flags);
1054 dev->trans_start = jiffies;
1058 /*****************************************************************************/
1060 static int tok_close(struct net_device *dev)
1062 struct tok_info *ti = (struct tok_info *) dev->priv;
1064 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1065 /* unloading the module from memory, and then if a timer pops, ouch */
1066 del_timer_sync(&ti->tr_timer);
1067 outb(0, dev->base_addr + ADAPTRESET);
1069 ti->open_status = CLOSED;
1071 netif_stop_queue(dev);
1072 DPRINTK("Adapter is closed.\n");
1076 /*****************************************************************************/
1078 #define RETCODE_OFST 2
1079 #define OPEN_ERROR_CODE_OFST 6
1080 #define ASB_ADDRESS_OFST 8
1081 #define SRB_ADDRESS_OFST 10
1082 #define ARB_ADDRESS_OFST 12
1083 #define SSB_ADDRESS_OFST 14
1085 static char *printphase[]= {"Lobe media test","Physical insertion",
1086 "Address verification","Roll call poll","Request Parameters"};
1087 static char *printerror[]={"Function failure","Signal loss","Reserved",
1088 "Frequency error","Timeout","Ring failure","Ring beaconing",
1089 "Duplicate node address",
1090 "Parameter request-retry count exceeded","Remove received",
1091 "IMPL force received","Duplicate modifier",
1092 "No monitor detected","Monitor contention failed for RPL"};
1094 static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page)
1096 if (ti->page_mask) {
1097 *page = (index >> 8) & ti->page_mask;
1098 index &= ~(ti->page_mask << 8);
1100 return ti->sram_virt + index;
1103 static void dir_open_adapter (struct net_device *dev)
1105 struct tok_info *ti = (struct tok_info *) dev->priv;
1106 unsigned char ret_code;
1109 ti->srb = map_address(ti,
1110 ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)),
1112 ti->ssb = map_address(ti,
1113 ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)),
1115 ti->arb = map_address(ti,
1116 ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)),
1118 ti->asb = map_address(ti,
1119 ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)),
1121 ti->current_skb = NULL;
1122 ret_code = readb(ti->init_srb + RETCODE_OFST);
1123 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1125 ti->open_status = OPEN; /* TR adapter is now available */
1126 if (ti->open_mode == AUTOMATIC) {
1127 DPRINTK("Adapter reopened.\n");
1129 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1130 open_sap(EXTENDED_SAP, dev);
1133 ti->open_failure = YES;
1136 if (!ti->auto_speedsave) {
1137 DPRINTK("Open failed: Adapter speed must match "
1138 "ring speed if Automatic Ring Speed Save is "
1140 ti->open_action = FAIL;
1142 DPRINTK("Retrying open to adjust to "
1144 } else if (err == 0x2d) {
1145 DPRINTK("Physical Insertion: No Monitor Detected, ");
1146 printk("retrying after %ds delay...\n",
1147 TR_RETRY_INTERVAL/HZ);
1148 } else if (err == 0x11) {
1149 DPRINTK("Lobe Media Function Failure (0x11), ");
1150 printk(" retrying after %ds delay...\n",
1151 TR_RETRY_INTERVAL/HZ);
1153 char **prphase = printphase;
1154 char **prerror = printerror;
1155 DPRINTK("TR Adapter misc open failure, error code = ");
1156 printk("0x%x, Phase: %s, Error: %s\n",
1157 err, prphase[err/16 -1], prerror[err%16 -1]);
1158 printk(" retrying after %ds delay...\n",
1159 TR_RETRY_INTERVAL/HZ);
1161 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1162 if (ti->open_action != FAIL) {
1163 if (ti->open_mode==AUTOMATIC){
1164 ti->open_action = REOPEN;
1165 ibmtr_reset_timer(&(ti->tr_timer), dev);
1168 wake_up(&ti->wait_for_reset);
1171 DPRINTK("FAILURE, CAPUT\n");
1174 /******************************************************************************/
1176 static irqreturn_t tok_interrupt(int irq, void *dev_id)
1178 unsigned char status;
1179 /* unsigned char status_even ; */
1180 struct tok_info *ti;
1181 struct net_device *dev;
1182 #ifdef ENABLE_PAGING
1183 unsigned char save_srpr;
1188 DPRINTK("Int from tok_driver, dev : %p irq%d\n", dev,irq);
1190 ti = (struct tok_info *) dev->priv;
1191 if (ti->sram_phys & 1)
1192 return IRQ_NONE; /* PCMCIA card extraction flag */
1193 spin_lock(&(ti->lock));
1194 #ifdef ENABLE_PAGING
1195 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1198 /* Disable interrupts till processing is finished */
1199 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1201 /* Reset interrupt for ISA boards */
1202 if (ti->adapter_int_enable)
1203 outb(0, ti->adapter_int_enable);
1204 else /* used for PCMCIA cards */
1205 outb(0, ti->global_int_enable);
1206 if (ti->do_tok_int == FIRST_INT){
1207 initial_tok_int(dev);
1208 #ifdef ENABLE_PAGING
1209 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1211 spin_unlock(&(ti->lock));
1214 /* Begin interrupt handler HERE inline to avoid the extra
1215 levels of logic and call depth for the original solution. */
1216 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1217 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1218 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1219 /*BMS status,status_even); */
1221 if (status & ADAP_CHK_INT) {
1223 void __iomem *check_reason;
1224 __u8 check_reason_page = 0;
1225 check_reason = map_address(ti,
1226 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN)),
1227 &check_reason_page);
1228 SET_PAGE(check_reason_page);
1230 DPRINTK("Adapter check interrupt\n");
1231 DPRINTK("8 reason bytes follow: ");
1232 for (i = 0; i < 8; i++, check_reason++)
1233 printk("%02X ", (int) readb(check_reason));
1235 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1236 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1237 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1238 ti->open_status = CLOSED;
1239 ti->sap_status = CLOSED;
1240 ti->open_mode = AUTOMATIC;
1241 netif_carrier_off(dev);
1242 netif_stop_queue(dev);
1243 ti->open_action = RESTART;
1244 outb(0, dev->base_addr + ADAPTRESET);
1245 ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/
1246 spin_unlock(&(ti->lock));
1249 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1250 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1251 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1252 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1253 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1254 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1255 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/
1256 DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/
1257 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1258 #ifdef ENABLE_PAGING
1259 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1261 spin_unlock(&(ti->lock));
1264 if (status & SRB_RESP_INT) { /* SRB response */
1265 SET_PAGE(ti->srb_page);
1267 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1268 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1270 switch (readb(ti->srb)) { /* SRB command check */
1271 case XMIT_DIR_FRAME:{
1272 unsigned char xmit_ret_code;
1273 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1274 if (xmit_ret_code == 0xff) break;
1275 DPRINTK("error on xmit_dir_frame request: %02X\n",
1277 if (ti->current_skb) {
1278 dev_kfree_skb_irq(ti->current_skb);
1279 ti->current_skb = NULL;
1282 netif_wake_queue(dev);
1283 if (ti->readlog_pending)
1287 case XMIT_UI_FRAME:{
1288 unsigned char xmit_ret_code;
1290 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1291 if (xmit_ret_code == 0xff) break;
1292 DPRINTK("error on xmit_ui_frame request: %02X\n",
1294 if (ti->current_skb) {
1295 dev_kfree_skb_irq(ti->current_skb);
1296 ti->current_skb = NULL;
1298 netif_wake_queue(dev);
1299 if (ti->readlog_pending)
1303 case DIR_OPEN_ADAPTER:
1304 dir_open_adapter(dev);
1307 if (readb(ti->srb + RETCODE_OFST)) {
1308 DPRINTK("open_sap failed: ret_code = %02X, "
1310 (int) readb(ti->srb + RETCODE_OFST));
1311 ti->open_action = REOPEN;
1312 ibmtr_reset_timer(&(ti->tr_timer), dev);
1315 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1316 ti->sap_status = OPEN;/* TR adapter is now available */
1317 if (ti->open_mode==MANUAL){
1318 wake_up(&ti->wait_for_reset);
1321 netif_wake_queue(dev);
1322 netif_carrier_on(dev);
1325 case DIR_MOD_OPEN_PARAMS:
1326 case DIR_SET_GRP_ADDR:
1327 case DIR_SET_FUNC_ADDR:
1329 if (readb(ti->srb + RETCODE_OFST))
1330 DPRINTK("error on %02X: %02X\n",
1331 (int) readb(ti->srb + COMMAND_OFST),
1332 (int) readb(ti->srb + RETCODE_OFST));
1335 if (readb(ti->srb + RETCODE_OFST)){
1336 DPRINTK("error on dir_read_log: %02X\n",
1337 (int) readb(ti->srb + RETCODE_OFST));
1338 netif_wake_queue(dev);
1341 #if IBMTR_DEBUG_MESSAGES
1343 #define LINE_ERRORS_OFST 0
1344 #define INTERNAL_ERRORS_OFST 1
1345 #define BURST_ERRORS_OFST 2
1346 #define AC_ERRORS_OFST 3
1347 #define ABORT_DELIMITERS_OFST 4
1348 #define LOST_FRAMES_OFST 6
1349 #define RECV_CONGEST_COUNT_OFST 7
1350 #define FRAME_COPIED_ERRORS_OFST 8
1351 #define FREQUENCY_ERRORS_OFST 9
1352 #define TOKEN_ERRORS_OFST 10
1354 DPRINTK("Line errors %02X, Internal errors %02X, "
1355 "Burst errors %02X\n" "A/C errors %02X, "
1356 "Abort delimiters %02X, Lost frames %02X\n"
1357 "Receive congestion count %02X, "
1358 "Frame copied errors %02X\nFrequency errors %02X, "
1359 "Token errors %02X\n",
1360 (int) readb(ti->srb + LINE_ERRORS_OFST),
1361 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1362 (int) readb(ti->srb + BURST_ERRORS_OFST),
1363 (int) readb(ti->srb + AC_ERRORS_OFST),
1364 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1365 (int) readb(ti->srb + LOST_FRAMES_OFST),
1366 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1367 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1368 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1369 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1371 netif_wake_queue(dev);
1374 DPRINTK("Unknown command %02X encountered\n",
1375 (int) readb(ti->srb));
1376 } /* end switch SRB command check */
1377 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1378 } /* if SRB response */
1379 if (status & ASB_FREE_INT) { /* ASB response */
1380 SET_PAGE(ti->asb_page);
1382 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1385 switch (readb(ti->asb)) { /* ASB command check */
1388 case XMIT_DIR_FRAME:
1391 DPRINTK("unknown command in asb %02X\n",
1392 (int) readb(ti->asb));
1393 } /* switch ASB command check */
1394 if (readb(ti->asb + 2) != 0xff) /* checks ret_code */
1395 DPRINTK("ASB error %02X in cmd %02X\n",
1396 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1397 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1398 } /* if ASB response */
1400 #define STATUS_OFST 6
1401 #define NETW_STATUS_OFST 6
1403 if (status & ARB_CMD_INT) { /* ARB response */
1404 SET_PAGE(ti->arb_page);
1406 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1409 switch (readb(ti->arb)) { /* ARB command check */
1411 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1412 ntohs(readw(ti->arb + STATUS_OFST)),
1413 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1418 case RING_STAT_CHANGE:{
1419 unsigned short ring_status;
1420 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1421 if (ibmtr_debug_trace & TRC_INIT)
1422 DPRINTK("Ring Status Change...(0x%x)\n",
1424 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1425 netif_stop_queue(dev);
1426 netif_carrier_off(dev);
1427 DPRINTK("Remove received, or Auto-removal error"
1428 ", or Lobe fault\n");
1429 DPRINTK("We'll try to reopen the closed adapter"
1430 " after a %d second delay.\n",
1431 TR_RETRY_INTERVAL/HZ);
1432 /*I was confused: I saw the TR reopening but */
1433 /*forgot:with an RJ45 in an RJ45/ICS adapter */
1434 /*but adapter not in the ring, the TR will */
1435 /* open, and then soon close and come here. */
1436 ti->open_mode = AUTOMATIC;
1437 ti->open_status = CLOSED; /*12/2000 BMS*/
1438 ti->open_action = REOPEN;
1439 ibmtr_reset_timer(&(ti->tr_timer), dev);
1440 } else if (ring_status & LOG_OVERFLOW) {
1441 if(netif_queue_stopped(dev))
1442 ti->readlog_pending = 1;
1452 DPRINTK("Unknown command %02X in arb\n",
1453 (int) readb(ti->arb));
1455 } /* switch ARB command check */
1456 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1457 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1458 } /* if ARB response */
1459 if (status & SSB_RESP_INT) { /* SSB response */
1460 unsigned char retcode;
1461 SET_PAGE(ti->ssb_page);
1463 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1464 readb(ti->ssb), readb(ti->ssb + 2));
1467 switch (readb(ti->ssb)) { /* SSB command check */
1468 case XMIT_DIR_FRAME:
1470 retcode = readb(ti->ssb + 2);
1471 if (retcode && (retcode != 0x22))/* checks ret_code */
1472 DPRINTK("xmit ret_code: %02X xmit error code: "
1474 (int)retcode, (int)readb(ti->ssb + 6));
1476 ti->tr_stats.tx_packets++;
1479 DPRINTK("xmit xid ret_code: %02X\n",
1480 (int) readb(ti->ssb + 2));
1482 DPRINTK("Unknown command %02X in ssb\n",
1483 (int) readb(ti->ssb));
1484 } /* SSB command check */
1485 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1486 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1487 } /* if SSB response */
1488 #ifdef ENABLE_PAGING
1489 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1491 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1492 spin_unlock(&(ti->lock));
1494 } /*tok_interrupt */
1496 /*****************************************************************************/
1498 #define INIT_STATUS_OFST 1
1499 #define INIT_STATUS_2_OFST 2
1500 #define ENCODED_ADDRESS_OFST 8
1502 static void initial_tok_int(struct net_device *dev)
1505 __u32 encoded_addr, hw_encoded_addr;
1506 struct tok_info *ti;
1507 unsigned char init_status; /*BMS 12/2000*/
1509 ti = (struct tok_info *) dev->priv;
1511 ti->do_tok_int = NOT_FIRST;
1513 /* we assign the shared-ram address for ISA devices */
1514 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1516 ti->sram_virt = ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1518 ti->init_srb = map_address(ti,
1519 ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN)),
1520 &ti->init_srb_page);
1521 if (ti->page_mask && ti->avail_shared_ram == 127) {
1522 void __iomem *last_512;
1523 __u8 last_512_page=0;
1525 last_512 = map_address(ti, 0xfe00, &last_512_page);
1526 /* initialize high section of ram (if necessary) */
1527 SET_PAGE(last_512_page);
1528 for (i = 0; i < 512; i++)
1529 writeb(0, last_512 + i);
1531 SET_PAGE(ti->init_srb_page);
1537 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1538 DPRINTK("init_srb(%p):", ti->init_srb );
1539 for (i = 0; i < 20; i++)
1540 printk("%02X ", (int) readb(ti->init_srb + i));
1545 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1546 encoded_addr = ntohs(hw_encoded_addr);
1547 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1548 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1549 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1550 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1551 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1552 ti->ring_speed, (unsigned int)dev->mem_start);
1553 ti->auto_speedsave=readb(ti->init_srb+INIT_STATUS_2_OFST)&4?TRUE:FALSE;
1555 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1556 else tok_open_adapter((unsigned long)dev);
1558 } /*initial_tok_int() */
1560 /*****************************************************************************/
1562 #define CMD_CORRELATE_OFST 1
1563 #define DHB_ADDRESS_OFST 6
1565 #define FRAME_LENGTH_OFST 6
1566 #define HEADER_LENGTH_OFST 8
1567 #define RSAP_VALUE_OFST 9
1569 static void tr_tx(struct net_device *dev)
1571 struct tok_info *ti = (struct tok_info *) dev->priv;
1572 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1573 unsigned int hdr_len;
1574 __u32 dhb=0,dhb_base;
1575 void __iomem *dhbuf = NULL;
1576 unsigned char xmit_command;
1577 int i,dhb_len=0x4000,src_len,src_offset;
1579 struct srb_xmit xsrb;
1583 SET_PAGE(ti->asb_page);
1585 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1587 /* in providing the transmit interrupts, is telling us it is ready for
1588 data and providing a shared memory address for us to stuff with data.
1589 Here we compute the effective address where we will place data.
1591 SET_PAGE(ti->arb_page);
1592 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1593 if (ti->page_mask) {
1594 dhb_page = (dhb_base >> 8) & ti->page_mask;
1595 dhb=dhb_base & ~(ti->page_mask << 8);
1597 dhbuf = ti->sram_virt + dhb;
1599 /* Figure out the size of the 802.5 header */
1600 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1601 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1603 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1604 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1606 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1608 llc_ssap = llc->ssap;
1609 SET_PAGE(ti->srb_page);
1610 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1611 SET_PAGE(ti->asb_page);
1612 xmit_command = xsrb.command;
1614 writeb(xmit_command, ti->asb + COMMAND_OFST);
1615 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1616 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1617 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1618 writeb(0, ti->asb + RETCODE_OFST);
1619 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1620 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1621 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1624 writeb(LLC_FRAME, dhbuf + 1);
1625 for (i = 0; i < TR_ALEN; i++)
1626 writeb((int) 0x0FF, dhbuf + i + 2);
1627 for (i = 0; i < TR_ALEN; i++)
1628 writeb(0, dhbuf + i + TR_ALEN + 2);
1629 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1633 * the token ring packet is copied from sk_buff to the adapter
1634 * buffer identified in the command data received with the interrupt.
1636 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1637 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1638 src_len=ti->current_skb->len;
1642 if (ti->page_mask) {
1643 dhb_page=(dhb >> 8) & ti->page_mask;
1644 dhb=dhb & ~(ti->page_mask << 8);
1645 dhb_len=0x4000-dhb; /* remaining size of this page */
1647 dhbuf = ti->sram_virt + dhb;
1649 if (src_len > dhb_len) {
1650 memcpy_toio(dhbuf,&ti->current_skb->data[src_offset],
1653 src_offset += dhb_len;
1658 memcpy_toio(dhbuf, &ti->current_skb->data[src_offset], src_len);
1661 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1662 ti->tr_stats.tx_bytes += ti->current_skb->len;
1663 dev_kfree_skb_irq(ti->current_skb);
1664 ti->current_skb = NULL;
1665 netif_wake_queue(dev);
1666 if (ti->readlog_pending)
1670 /*****************************************************************************/
1673 #define RECEIVE_BUFFER_OFST 6
1674 #define LAN_HDR_LENGTH_OFST 8
1675 #define DLC_HDR_LENGTH_OFST 9
1680 #define PROTID_OFST 3
1681 #define ETHERTYPE_OFST 6
1683 static void tr_rx(struct net_device *dev)
1685 struct tok_info *ti = (struct tok_info *) dev->priv;
1687 void __iomem *rbuf, *rbufdata, *llc;
1688 __u8 rbuffer_page = 0;
1689 unsigned char *data;
1690 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1691 unsigned char dlc_hdr_len;
1692 struct sk_buff *skb;
1693 unsigned int skb_size = 0;
1695 unsigned int chksum = 0;
1697 struct arb_rec_req rarb;
1699 SET_PAGE(ti->arb_page);
1700 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1701 rbuffer = ntohs(rarb.rec_buf_addr) ;
1702 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1704 SET_PAGE(ti->asb_page);
1706 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1708 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1709 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1710 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1712 lan_hdr_len = rarb.lan_hdr_len;
1713 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1714 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1716 } /*BMS I added this above just to be very safe */
1717 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1718 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1720 SET_PAGE(rbuffer_page);
1721 llc = rbuf + offsetof(struct rec_buf, data) + lan_hdr_len;
1724 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1725 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1726 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1727 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1728 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1729 "ethertype: %04X\n",
1730 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1731 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1732 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1733 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1735 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1736 SET_PAGE(ti->asb_page);
1737 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1738 ti->tr_stats.rx_dropped++;
1739 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1742 length = ntohs(rarb.frame_len);
1743 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1744 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1745 length >= hdr_len) IPv4_p = 1;
1747 #define SADDR_OFST 8
1748 #define DADDR_OFST 2
1752 void __iomem *trhhdr = rbuf + offsetof(struct rec_buf, data);
1754 DPRINTK("Probably non-IP frame received.\n");
1755 DPRINTK("ssap: %02X dsap: %02X "
1756 "saddr: %02X:%02X:%02X:%02X:%02X:%02X "
1757 "daddr: %02X:%02X:%02X:%02X:%02X:%02X\n",
1758 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1759 readb(trhhdr+SADDR_OFST), readb(trhhdr+ SADDR_OFST+1),
1760 readb(trhhdr+SADDR_OFST+2), readb(trhhdr+SADDR_OFST+3),
1761 readb(trhhdr+SADDR_OFST+4), readb(trhhdr+SADDR_OFST+5),
1762 readb(trhhdr+DADDR_OFST), readb(trhhdr+DADDR_OFST + 1),
1763 readb(trhhdr+DADDR_OFST+2), readb(trhhdr+DADDR_OFST+3),
1764 readb(trhhdr+DADDR_OFST+4), readb(trhhdr+DADDR_OFST+5));
1768 /*BMS handle the case she comes in with few hops but leaves with many */
1769 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1771 if (!(skb = dev_alloc_skb(skb_size))) {
1772 DPRINTK("out of memory. frame dropped.\n");
1773 ti->tr_stats.rx_dropped++;
1774 SET_PAGE(ti->asb_page);
1775 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1776 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1779 /*BMS again, if she comes in with few but leaves with many */
1780 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1781 skb_put(skb, length);
1784 rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len)));
1785 rbufdata = rbuf + offsetof(struct rec_buf, data);
1788 /* Copy the headers without checksumming */
1789 memcpy_fromio(data, rbufdata, hdr_len);
1791 /* Watch for padded packets and bogons */
1792 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1793 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1795 if ((ip_len <= length) && (ip_len > 7))
1798 rbuffer_len -= hdr_len;
1799 rbufdata += hdr_len;
1801 /* Copy the payload... */
1802 #define BUFFER_POINTER_OFST 2
1803 #define BUFFER_LENGTH_OFST 6
1805 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1806 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1807 length,rbuffer_len);
1809 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1810 data,length<rbuffer_len?length:rbuffer_len,chksum);
1812 memcpy_fromio(data, rbufdata, rbuffer_len);
1813 rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ;
1817 length -= rbuffer_len;
1818 data += rbuffer_len;
1819 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1820 SET_PAGE(rbuffer_page);
1821 rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST));
1822 rbufdata = rbuf + offsetof(struct rec_buf, data);
1825 SET_PAGE(ti->asb_page);
1826 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1828 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1830 ti->tr_stats.rx_bytes += skb->len;
1831 ti->tr_stats.rx_packets++;
1833 skb->protocol = tr_type_trans(skb, dev);
1836 skb->ip_summed = CHECKSUM_COMPLETE;
1839 dev->last_rx = jiffies;
1842 /*****************************************************************************/
1844 static void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1846 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1847 tmr->data = (unsigned long) dev;
1848 tmr->function = tok_rerun;
1853 /*****************************************************************************/
1855 void tok_rerun(unsigned long dev_addr){
1857 struct net_device *dev = (struct net_device *)dev_addr;
1858 struct tok_info *ti = (struct tok_info *) dev->priv;
1860 if ( ti->open_action == RESTART){
1861 ti->do_tok_int = FIRST_INT;
1862 outb(0, dev->base_addr + ADAPTRESETREL);
1863 #ifdef ENABLE_PAGING
1865 writeb(SRPR_ENABLE_PAGING,
1866 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1869 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1871 tok_open_adapter(dev_addr);
1874 /*****************************************************************************/
1876 static void ibmtr_readlog(struct net_device *dev)
1878 struct tok_info *ti;
1880 ti = (struct tok_info *) dev->priv;
1882 ti->readlog_pending = 0;
1883 SET_PAGE(ti->srb_page);
1884 writeb(DIR_READ_LOG, ti->srb);
1885 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1886 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1888 netif_stop_queue(dev);
1892 /*****************************************************************************/
1894 /* tok_get_stats(): Basically a scaffold routine which will return
1895 the address of the tr_statistics structure associated with
1896 this device -- the tr.... structure is an ethnet look-alike
1897 so at least for this iteration may suffice. */
1899 static struct net_device_stats *tok_get_stats(struct net_device *dev)
1902 struct tok_info *toki;
1903 toki = (struct tok_info *) dev->priv;
1904 return (struct net_device_stats *) &toki->tr_stats;
1907 /*****************************************************************************/
1909 static int ibmtr_change_mtu(struct net_device *dev, int mtu)
1911 struct tok_info *ti = (struct tok_info *) dev->priv;
1913 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1915 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1921 /*****************************************************************************/
1924 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1925 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1926 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1927 static int irq[IBMTR_MAX_ADAPTERS];
1928 static int mem[IBMTR_MAX_ADAPTERS];
1930 MODULE_LICENSE("GPL");
1932 module_param_array(io, int, NULL, 0);
1933 module_param_array(irq, int, NULL, 0);
1934 module_param_array(mem, int, NULL, 0);
1936 static int __init ibmtr_init(void)
1941 find_turbo_adapters(io);
1943 for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) {
1944 struct net_device *dev;
1947 dev = alloc_trdev(sizeof(struct tok_info));
1953 dev->base_addr = io[i];
1955 dev->mem_start = mem[i];
1957 if (ibmtr_probe_card(dev)) {
1964 if (count) return 0;
1965 printk("ibmtr: register_netdev() returned non-zero.\n");
1968 module_init(ibmtr_init);
1970 static void __exit ibmtr_cleanup(void)
1974 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1977 unregister_netdev(dev_ibmtr[i]);
1978 ibmtr_cleanup_card(dev_ibmtr[i]);
1979 free_netdev(dev_ibmtr[i]);
1982 module_exit(ibmtr_cleanup);