?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] USB: Rename hcd->hub_suspend to hcd->bus_suspend
[linux/fpc-iii.git] / drivers / net / tokenring / ibmtr.c
blob9f491563944e917efc754b3d9c59645cefbc24a6
1 /* ibmtr.c: A shared-memory IBM Token Ring 16/4 driver for linux
2 *
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.
6 *
7 * This device driver should work with Any IBM Token Ring Card that does
8 * not use DMA.
9 *
10 * I used Donald Becker's (becker@scyld.com) device driver work
11 * as a base for most of my initial work.
12 *
13 * Changes by Peter De Schrijver
14 * (Peter.Deschrijver@linux.cc.kuleuven.ac.be) :
15 *
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.
20 *
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.
25 *
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.
30 *
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
35 *
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)
41 *
42 * Changes by Steve Kipisz (bungy@ibm.net or kipisz@vnet.ibm.com)
43 * (January 18 1996):
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
47 * the driver.
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
52 *
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)
60 *
61 * Changes by Christopher Turcksin <wabbit@rtfc.demon.co.uk>
62 * + Now compiles ok as a module again.
63 *
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.
69 * May 25 1998)
70 * + can't allocate 2k recv buff at 8k shared-RAM. (20 October 1998)
71 *
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
75 *
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.
81 *
82 * Changes by Tim Hockin (thockin@isunix.it.ilstu.edu) :
83 * + added spinlocks for SMP sanity (10 March 1999)
84 *
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.
88 *
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.
93 *
94 * Changes by Peter De Schrijver (p2@mind.be) :
95 * + fixed a problem with PCMCIA card removal
96 *
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.
100 *
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.
103 */
104
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 */
107
108 #define IBMTR_DEBUG_MESSAGES 0
109
110 #include <linux/module.h>
111
112 #ifdef PCMCIA /* required for ibmtr_cs.c to build */
113 #undef MODULE /* yes, really */
114 #undef ENABLE_PAGING
115 #else
116 #define ENABLE_PAGING 1
117 #endif
118
119 #define FALSE 0
120 #define TRUE (!FALSE)
121
122 /* changes the output format of driver initialization */
123 #define TR_VERBOSE 0
124
125 /* some 95 OS send many non UI frame; this allow removing the warning */
126 #define TR_FILTERNONUI 1
127
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>
133
134 #include <net/checksum.h>
135
136 #include <asm/io.h>
137
138 #define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args)
139 #define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args)
140
141 /* version and credits */
142 #ifndef PCMCIA
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";
150 #endif
151
152 /* this allows displaying full adapter information */
153
154 static char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" };
155
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
163 };
164
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
172 };
173
174 static char __devinit *adapter_def(char type)
175 {
176 switch (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)";
182 };
183 };
184
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;
188
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, 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 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);
210
211 static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = {
212 0xa20, 0xa24, 0, 0, 0
213 };
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;
217
218 #ifndef PCMCIA
219 static __u32 ibmtr_mem_base __initdata = 0xd0000;
220 #endif
221
222 static void __devinit PrtChanID(char *pcid, short stride)
223 {
224 short i, j;
225 for (i = 0, j = 0; i < 24; i++, j += stride)
226 printk("%1x", ((int) pcid[j]) & 0x0f);
227 printk("\n");
228 }
229
230 static void __devinit HWPrtChanID(void __iomem *pcid, short stride)
231 {
232 short i, j;
233 for (i = 0, j = 0; i < 24; i++, j += stride)
234 printk("%1x", ((int) readb(pcid + j)) & 0x0f);
235 printk("\n");
236 }
237
238 /* We have to ioremap every checked address, because isa_readb is
239 * going away.
240 */
241
242 static void __devinit find_turbo_adapters(int *iolist)
243 {
244 int ram_addr;
245 int index=0;
246 void __iomem *chanid;
247 int found_turbo=0;
248 unsigned char *tchanid, ctemp;
249 int i, j;
250 unsigned long jif;
251 void __iomem *ram_mapped ;
252
253 if (turbo_searched == 1) return;
254 turbo_searched=1;
255 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
256
257 __u32 intf_tbl=0;
258
259 found_turbo=1;
260 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
261 if (ram_mapped==NULL)
262 continue ;
263 chanid=(CHANNEL_ID + ram_mapped);
264 tchanid=pcchannelid;
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]){
269 found_turbo=0;
270 break;
271 }
272 }
273 if (!found_turbo) continue;
274
275 writeb(0x90, ram_mapped+0x1E01);
276 for(i=2; i<0x0f; i++) {
277 writeb(0x00, ram_mapped+0x1E01+i);
278 }
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));
282 if (intf_tbl) {
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 ");
287 for(i=0; i<6; i++) {
288 printk("%x:",readb(ram_addr+intf_tbl+i));
289 }
290 printk("\n");
291 #endif
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);
297 index++;
298 continue;
299 }
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);
303 #endif
304 iounmap(ram_mapped) ;
305 } /* for */
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];
311 break;
312 }
313 }
314 }
315
316 static void ibmtr_cleanup_card(struct net_device *dev)
317 {
318 if (dev->base_addr) {
319 outb(0,dev->base_addr+ADAPTRESET);
320
321 schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
322
323 outb(0,dev->base_addr+ADAPTRESETREL);
324 }
325
326 #ifndef PCMCIA
327 free_irq(dev->irq, dev);
328 release_region(dev->base_addr, IBMTR_IO_EXTENT);
329
330 {
331 struct tok_info *ti = (struct tok_info *) dev->priv;
332 iounmap(ti->mmio);
333 iounmap(ti->sram_virt);
334 }
335 #endif
336 }
337
338 int ibmtr_probe_card(struct net_device *dev)
339 {
340 int err = ibmtr_probe(dev);
341 if (!err) {
342 err = register_netdev(dev);
343 if (err)
344 ibmtr_cleanup_card(dev);
345 }
346 return err;
347 }
348
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.
356 *
357 * We expect ibmtr_probe to be called once for each device entry
358 * which references it.
359 ****************************************************************************/
360
361 static int ibmtr_probe(struct net_device *dev)
362 {
363 int i;
364 int base_addr = dev->base_addr;
365
366 if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */
367 return -ENXIO;
368 if (base_addr > 0x1ff) { /* Check a single specified location. */
369 if (!ibmtr_probe1(dev, base_addr)) return 0;
370 return -ENODEV;
371 }
372 find_turbo_adapters(ibmtr_portlist);
373 for (i = 0; ibmtr_portlist[i]; i++) {
374 int ioaddr = ibmtr_portlist[i];
375
376 if (!ibmtr_probe1(dev, ioaddr)) return 0;
377 }
378 return -ENODEV;
379 }
380
381 /*****************************************************************************/
382
383 static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
384 {
385
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;
391 #ifndef PCMCIA
392 unsigned char t_irq=0;
393 unsigned long timeout;
394 static int version_printed;
395 #endif
396
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.
400 */
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);
409 #endif
410 return -ENODEV;
411 }
412 /*
413 * Compute the linear base address of the MMIO area
414 * as LINUX doesn't care about segments
415 */
416 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
417 if (!t_mmio) {
418 DPRINTK("Cannot remap mmiobase memory area") ;
419 return -ENODEV ;
420 }
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);
425
426 /*
427 * Now we will compare expected 'channelid' strings with
428 * what we is there to learn of ISA/MCA or not TR card
429 */
430 #ifdef PCMCIA
431 iounmap(t_mmio);
432 t_mmio = ti->mmio; /*BMS to get virtual address */
433 irq = ti->irq; /*BMS to display the irq! */
434 #endif
435 cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */
436 tchanid = pcchannelid;
437 cardpresent = TR_ISA; /* try ISA */
438
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 */
445 cardpresent = NOTOK;
446 }
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 */
452 cardpresent = NOTOK;
453 break;
454 }
455 }
456 /*
457 * If we have an ISA board check for the ISA P&P version,
458 * as it has different IRQ settings
459 */
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)) {
464 #ifndef PCMCIA
465 iounmap(t_mmio);
466 #endif
467 return -ENODEV;
468 }
469 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
470 PIOaddr);
471 DPRINTK("Expected for ISA: ");
472 PrtChanID(pcchannelid, 1);
473 DPRINTK(" found: ");
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);
480 }
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 */
484 #ifndef PCMCIA
485 ti->mmio = t_mmio;
486 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
487 if (turbo_io[i] != PIOaddr)
488 continue;
489 #if IBMTR_DEBUG_MESSAGES
490 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
491 PIOaddr);
492 #endif
493 ti->turbo = 1;
494 t_irq = turbo_irq[i];
495 }
496 #endif /* !PCMCIA */
497 ti->readlog_pending = 0;
498 init_waitqueue_head(&ti->wait_for_reset);
499
500 /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP
501 * depending which card is inserted. */
502
503 #ifndef PCMCIA
504 switch (cardpresent) {
505 case TR_ISA:
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;
511 break;
512 case TR_MCA:
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;
520 break;
521 case TR_ISAPNP:
522 if (!t_irq) {
523 if (intr == 0) irq = 9;
524 if (intr == 1) irq = 3;
525 if (intr == 2) irq = 10;
526 if (intr == 3) irq = 11;
527 } else
528 irq=t_irq;
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");
533 iounmap(t_mmio);
534 return -ENODEV;
535 }
536 ti->sram_phys =
537 ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12);
538 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
539 break;
540 } /*end switch (cardpresent) */
541 #endif /*not PCMCIA */
542
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);
549 }
550 printk(".\n");
551 }
552
553 /* Get hw address of token ring card */
554 j = 0;
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;
559 if (j & 1)
560 dev->dev_addr[(j / 2)] =
561 ti->hw_address[j]+ (ti->hw_address[j - 1] << 4);
562 ++j;
563 }
564 /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */
565 ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);
566
567 /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */
568 ti->data_rate = readb(ti->mmio + AIPDATARATE);
569
570 /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */
571 ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);
572
573 /* How much shared RAM is on adapter ? */
574 if (ti->turbo) {
575 ti->avail_shared_ram=127;
576 } else {
577 ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */
578 }
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);
582
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;
588 }
589
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;
597 }
598
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.
605 */
606
607 /*
608 * determine how much of total RAM is mapped into PC space
609 */
610 ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/
611 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4);
612 ti->page_mask = 0;
613 if (ti->turbo) ti->page_mask=0xf0;
614 else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */
615 else {
616 #ifdef ENABLE_PAGING
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) {
621 case 0xf:
622 break;
623 case 0xe:
624 ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0;
625 pg_size = 32; /* 16KB page size */
626 break;
627 case 0xd:
628 ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0;
629 pg_size = 64; /* 32KB page size */
630 break;
631 case 0xc:
632 switch (ti->mapped_ram_size) {
633 case 32:
634 ti->page_mask = 0xc0;
635 pg_size = 32;
636 break;
637 case 64:
638 ti->page_mask = 0x80;
639 pg_size = 64;
640 break;
641 }
642 break;
643 default:
644 DPRINTK("Unknown shared ram paging info %01X\n",
645 ti->shared_ram_paging);
646 iounmap(t_mmio);
647 return -ENODEV;
648 break;
649 } /*end switch shared_ram_paging */
650
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 */
658 }
659
660 #ifndef PCMCIA
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;
666
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);
675 iounmap(t_mmio);
676 return -ENODEV;
677 } else { /* seems cool, record what we have figured out */
678 ti->sram_base = new_base >> 12;
679 ibmtr_mem_base = chk_base;
680 }
681 }
682 else ti->sram_base = ti->sram_phys >> 12;
683
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",
688 irq);
689 iounmap(t_mmio);
690 return -ENODEV;
691 }
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);
697 iounmap(t_mmio);
698 return -EBUSY;
699 }
700
701 if (!version_printed++) {
702 printk(version);
703 }
704 #endif /* !PCMCIA */
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]);
712 if (ti->page_mask)
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);
716 else
717 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
718 ti->page_mask);
719
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)
725 */
726 if (!ti->page_mask) {
727 ti->avail_shared_ram=
728 min(ti->mapped_ram_size,ti->avail_shared_ram);
729 }
730
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;
735 ti->rbuf_cnt4=2;
736 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
737 ti->rbuf_len16 = 1032;
738 ti->rbuf_cnt16=2;
739 break;
740 case 32: /* 16KB shared RAM */
741 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
742 ti->rbuf_len4 = 1032;
743 ti->rbuf_cnt4=4;
744 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
745 ti->rbuf_len16 = 1032; /*1024 usable */
746 ti->rbuf_cnt16=4;
747 break;
748 case 64: /* 32KB shared RAM */
749 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
750 ti->rbuf_len4 = 1032;
751 ti->rbuf_cnt4=6;
752 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
753 ti->rbuf_len16 = 1032;
754 ti->rbuf_cnt16=6;
755 break;
756 case 127: /* 63.5KB shared RAM */
757 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
758 ti->rbuf_len4 = 1032;
759 ti->rbuf_cnt4=6;
760 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
761 ti->rbuf_len16 = 1032;
762 ti->rbuf_cnt16=16;
763 break;
764 case 128: /* 64KB shared RAM */
765 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
766 ti->rbuf_len4 = 1032;
767 ti->rbuf_cnt4=6;
768 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
769 ti->rbuf_len16 = 1032;
770 ti->rbuf_cnt16=16;
771 break;
772 default:
773 ti->dhb_size4mb = 2048;
774 ti->rbuf_len4 = 1032;
775 ti->rbuf_cnt4=2;
776 ti->dhb_size16mb = 2048;
777 ti->rbuf_len16 = 1032;
778 ti->rbuf_cnt16=2;
779 break;
780 }
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>;
786 */
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);
792
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;
796 trdev_init(dev);
797 return 0; /* Return 0 to indicate we have found a Token Ring card. */
798 } /*ibmtr_probe1() */
799
800 /*****************************************************************************/
801
802 /* query the adapter for the size of shared RAM */
803 /* the function returns the RAM size in units of 512 bytes */
804
805 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
806 {
807 unsigned char avail_sram_code;
808 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
809 /* Adapter gives
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 */
815
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 */
819 return 1 <<
820 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
821 }
822
823 /*****************************************************************************/
824
825 static int __devinit trdev_init(struct net_device *dev)
826 {
827 struct tok_info *ti = (struct tok_info *) dev->priv;
828
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;
837
838 return 0;
839 }
840
841 /*****************************************************************************/
842
843 static int tok_init_card(struct net_device *dev)
844 {
845 struct tok_info *ti;
846 short PIOaddr;
847 unsigned long i;
848
849 PIOaddr = dev->base_addr;
850 ti = (struct tok_info *) dev->priv;
851 /* Special processing for first interrupt after reset */
852 ti->do_tok_int = FIRST_INT;
853 /* Reset adapter */
854 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
855 outb(0, PIOaddr + ADAPTRESET);
856
857 schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
858
859 outb(0, PIOaddr + ADAPTRESETREL);
860 #ifdef ENABLE_PAGING
861 if (ti->page_mask)
862 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
863 #endif
864 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
865 i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ);
866 return i? 0 : -EAGAIN;
867 }
868
869 /*****************************************************************************/
870 static int tok_open(struct net_device *dev)
871 {
872 struct tok_info *ti = (struct tok_info *) dev->priv;
873 int i;
874
875 /*the case we were left in a failure state during a previous open */
876 if (ti->open_failure == YES) {
877 DPRINTK("Last time you were disconnected, how about now?\n");
878 printk("You can't insert with an ICS connector half-cocked.\n");
879 }
880
881 ti->open_status = CLOSED; /* CLOSED or OPEN */
882 ti->sap_status = CLOSED; /* CLOSED or OPEN */
883 ti->open_failure = NO; /* NO or YES */
884 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
885
886 ti->sram_phys &= ~1; /* to reverse what we do in tok_close */
887 /* init the spinlock */
888 spin_lock_init(&ti->lock);
889 init_timer(&ti->tr_timer);
890
891 i = tok_init_card(dev);
892 if (i) return i;
893
894 while (1){
895 tok_open_adapter((unsigned long) dev);
896 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
897 /* sig catch: estimate opening adapter takes more than .5 sec*/
898 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
899 if (i==0) break;
900 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
901 netif_start_queue(dev);
902 DPRINTK("Adapter is up and running\n");
903 return 0;
904 }
905 i=schedule_timeout_interruptible(TR_RETRY_INTERVAL);
906 /* wait 30 seconds */
907 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
908 }
909 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
910 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
911 return -EAGAIN;
912 }
913
914 /*****************************************************************************/
915
916 #define COMMAND_OFST 0
917 #define OPEN_OPTIONS_OFST 8
918 #define NUM_RCV_BUF_OFST 24
919 #define RCV_BUF_LEN_OFST 26
920 #define DHB_LENGTH_OFST 28
921 #define NUM_DHB_OFST 30
922 #define DLC_MAX_SAP_OFST 32
923 #define DLC_MAX_STA_OFST 33
924
925 static void tok_open_adapter(unsigned long dev_addr)
926 {
927 struct net_device *dev = (struct net_device *) dev_addr;
928 struct tok_info *ti;
929 int i;
930
931 ti = (struct tok_info *) dev->priv;
932 SET_PAGE(ti->init_srb_page);
933 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
934 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
935 writeb(0, ti->init_srb + i);
936 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
937 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
938 if (ti->ring_speed == 16) {
939 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
940 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
941 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
942 } else {
943 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
944 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
945 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
946 }
947 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
948 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
949 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
950 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
951 ti->srb_page = ti->init_srb_page;
952 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
953 readb(ti->init_srb + NUM_DHB_OFST),
954 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
955 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
956 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
957 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
958 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
959 }
960
961 /*****************************************************************************/
962
963 static void open_sap(unsigned char type, struct net_device *dev)
964 {
965 int i;
966 struct tok_info *ti = (struct tok_info *) dev->priv;
967
968 SET_PAGE(ti->srb_page);
969 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
970 writeb(0, ti->srb + i);
971
972 #define MAX_I_FIELD_OFST 14
973 #define SAP_VALUE_OFST 16
974 #define SAP_OPTIONS_OFST 17
975 #define STATION_COUNT_OFST 18
976
977 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
978 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
979 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
980 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
981 writeb(type, ti->srb + SAP_VALUE_OFST);
982 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
983 }
984
985
986 /*****************************************************************************/
987
988 static void tok_set_multicast_list(struct net_device *dev)
989 {
990 struct tok_info *ti = (struct tok_info *) dev->priv;
991 struct dev_mc_list *mclist;
992 unsigned char address[4];
993
994 int i;
995
996 /*BMS the next line is CRUCIAL or you may be sad when you */
997 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
998 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
999 address[0] = address[1] = address[2] = address[3] = 0;
1000 mclist = dev->mc_list;
1001 for (i = 0; i < dev->mc_count; i++) {
1002 address[0] |= mclist->dmi_addr[2];
1003 address[1] |= mclist->dmi_addr[3];
1004 address[2] |= mclist->dmi_addr[4];
1005 address[3] |= mclist->dmi_addr[5];
1006 mclist = mclist->next;
1007 }
1008 SET_PAGE(ti->srb_page);
1009 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1010 writeb(0, ti->srb + i);
1011
1012 #define FUNCT_ADDRESS_OFST 6
1013
1014 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1015 for (i = 0; i < 4; i++)
1016 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1017 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1018 #if TR_VERBOSE
1019 DPRINTK("Setting functional address: ");
1020 for (i=0;i<4;i++) printk("%02X ", address[i]);
1021 printk("\n");
1022 #endif
1023 }
1024
1025 /*****************************************************************************/
1026
1027 #define STATION_ID_OFST 4
1028
1029 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev)
1030 {
1031 struct tok_info *ti;
1032 unsigned long flags;
1033 ti = (struct tok_info *) dev->priv;
1034
1035 netif_stop_queue(dev);
1036
1037 /* lock against other CPUs */
1038 spin_lock_irqsave(&(ti->lock), flags);
1039
1040 /* Save skb; we'll need it when the adapter asks for the data */
1041 ti->current_skb = skb;
1042 SET_PAGE(ti->srb_page);
1043 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1044 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1045 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1046 spin_unlock_irqrestore(&(ti->lock), flags);
1047 dev->trans_start = jiffies;
1048 return 0;
1049 }
1050
1051 /*****************************************************************************/
1052
1053 static int tok_close(struct net_device *dev)
1054 {
1055 struct tok_info *ti = (struct tok_info *) dev->priv;
1056
1057 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1058 /* unloading the module from memory, and then if a timer pops, ouch */
1059 del_timer_sync(&ti->tr_timer);
1060 outb(0, dev->base_addr + ADAPTRESET);
1061 ti->sram_phys |= 1;
1062 ti->open_status = CLOSED;
1063
1064 netif_stop_queue(dev);
1065 DPRINTK("Adapter is closed.\n");
1066 return 0;
1067 }
1068
1069 /*****************************************************************************/
1070
1071 #define RETCODE_OFST 2
1072 #define OPEN_ERROR_CODE_OFST 6
1073 #define ASB_ADDRESS_OFST 8
1074 #define SRB_ADDRESS_OFST 10
1075 #define ARB_ADDRESS_OFST 12
1076 #define SSB_ADDRESS_OFST 14
1077
1078 static char *printphase[]= {"Lobe media test","Physical insertion",
1079 "Address verification","Roll call poll","Request Parameters"};
1080 static char *printerror[]={"Function failure","Signal loss","Reserved",
1081 "Frequency error","Timeout","Ring failure","Ring beaconing",
1082 "Duplicate node address",
1083 "Parameter request-retry count exceeded","Remove received",
1084 "IMPL force received","Duplicate modifier",
1085 "No monitor detected","Monitor contention failed for RPL"};
1086
1087 static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page)
1088 {
1089 if (ti->page_mask) {
1090 *page = (index >> 8) & ti->page_mask;
1091 index &= ~(ti->page_mask << 8);
1092 }
1093 return ti->sram_virt + index;
1094 }
1095
1096 static void dir_open_adapter (struct net_device *dev)
1097 {
1098 struct tok_info *ti = (struct tok_info *) dev->priv;
1099 unsigned char ret_code;
1100 __u16 err;
1101
1102 ti->srb = map_address(ti,
1103 ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)),
1104 &ti->srb_page);
1105 ti->ssb = map_address(ti,
1106 ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)),
1107 &ti->ssb_page);
1108 ti->arb = map_address(ti,
1109 ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)),
1110 &ti->arb_page);
1111 ti->asb = map_address(ti,
1112 ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)),
1113 &ti->asb_page);
1114 ti->current_skb = NULL;
1115 ret_code = readb(ti->init_srb + RETCODE_OFST);
1116 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1117 if (!ret_code) {
1118 ti->open_status = OPEN; /* TR adapter is now available */
1119 if (ti->open_mode == AUTOMATIC) {
1120 DPRINTK("Adapter reopened.\n");
1121 }
1122 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1123 open_sap(EXTENDED_SAP, dev);
1124 return;
1125 }
1126 ti->open_failure = YES;
1127 if (ret_code == 7){
1128 if (err == 0x24) {
1129 if (!ti->auto_speedsave) {
1130 DPRINTK("Open failed: Adapter speed must match "
1131 "ring speed if Automatic Ring Speed Save is "
1132 "disabled.\n");
1133 ti->open_action = FAIL;
1134 }else
1135 DPRINTK("Retrying open to adjust to "
1136 "ring speed, ");
1137 } else if (err == 0x2d) {
1138 DPRINTK("Physical Insertion: No Monitor Detected, ");
1139 printk("retrying after %ds delay...\n",
1140 TR_RETRY_INTERVAL/HZ);
1141 } else if (err == 0x11) {
1142 DPRINTK("Lobe Media Function Failure (0x11), ");
1143 printk(" retrying after %ds delay...\n",
1144 TR_RETRY_INTERVAL/HZ);
1145 } else {
1146 char **prphase = printphase;
1147 char **prerror = printerror;
1148 DPRINTK("TR Adapter misc open failure, error code = ");
1149 printk("0x%x, Phase: %s, Error: %s\n",
1150 err, prphase[err/16 -1], prerror[err%16 -1]);
1151 printk(" retrying after %ds delay...\n",
1152 TR_RETRY_INTERVAL/HZ);
1153 }
1154 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1155 if (ti->open_action != FAIL) {
1156 if (ti->open_mode==AUTOMATIC){
1157 ti->open_action = REOPEN;
1158 ibmtr_reset_timer(&(ti->tr_timer), dev);
1159 return;
1160 }
1161 wake_up(&ti->wait_for_reset);
1162 return;
1163 }
1164 DPRINTK("FAILURE, CAPUT\n");
1165 }
1166
1167 /******************************************************************************/
1168
1169 static irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1170 {
1171 unsigned char status;
1172 /* unsigned char status_even ; */
1173 struct tok_info *ti;
1174 struct net_device *dev;
1175 #ifdef ENABLE_PAGING
1176 unsigned char save_srpr;
1177 #endif
1178
1179 dev = dev_id;
1180 #if TR_VERBOSE
1181 DPRINTK("Int from tok_driver, dev : %p irq%d regs=%p\n", dev,irq,regs);
1182 #endif
1183 ti = (struct tok_info *) dev->priv;
1184 if (ti->sram_phys & 1)
1185 return IRQ_NONE; /* PCMCIA card extraction flag */
1186 spin_lock(&(ti->lock));
1187 #ifdef ENABLE_PAGING
1188 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1189 #endif
1190
1191 /* Disable interrupts till processing is finished */
1192 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1193
1194 /* Reset interrupt for ISA boards */
1195 if (ti->adapter_int_enable)
1196 outb(0, ti->adapter_int_enable);
1197 else /* used for PCMCIA cards */
1198 outb(0, ti->global_int_enable);
1199 if (ti->do_tok_int == FIRST_INT){
1200 initial_tok_int(dev);
1201 #ifdef ENABLE_PAGING
1202 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1203 #endif
1204 spin_unlock(&(ti->lock));
1205 return IRQ_HANDLED;
1206 }
1207 /* Begin interrupt handler HERE inline to avoid the extra
1208 levels of logic and call depth for the original solution. */
1209 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1210 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1211 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1212 /*BMS status,status_even); */
1213
1214 if (status & ADAP_CHK_INT) {
1215 int i;
1216 void __iomem *check_reason;
1217 __u8 check_reason_page = 0;
1218 check_reason = map_address(ti,
1219 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN)),
1220 &check_reason_page);
1221 SET_PAGE(check_reason_page);
1222
1223 DPRINTK("Adapter check interrupt\n");
1224 DPRINTK("8 reason bytes follow: ");
1225 for (i = 0; i < 8; i++, check_reason++)
1226 printk("%02X ", (int) readb(check_reason));
1227 printk("\n");
1228 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1229 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1230 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1231 ti->open_status = CLOSED;
1232 ti->sap_status = CLOSED;
1233 ti->open_mode = AUTOMATIC;
1234 netif_carrier_off(dev);
1235 netif_stop_queue(dev);
1236 ti->open_action = RESTART;
1237 outb(0, dev->base_addr + ADAPTRESET);
1238 ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/
1239 spin_unlock(&(ti->lock));
1240 return IRQ_HANDLED;
1241 }
1242 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1243 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1244 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1245 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1246 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1247 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1248 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/
1249 DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/
1250 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1251 #ifdef ENABLE_PAGING
1252 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1253 #endif
1254 spin_unlock(&(ti->lock));
1255 return IRQ_HANDLED;
1256 }
1257 if (status & SRB_RESP_INT) { /* SRB response */
1258 SET_PAGE(ti->srb_page);
1259 #if TR_VERBOSE
1260 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1261 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1262 #endif
1263 switch (readb(ti->srb)) { /* SRB command check */
1264 case XMIT_DIR_FRAME:{
1265 unsigned char xmit_ret_code;
1266 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1267 if (xmit_ret_code == 0xff) break;
1268 DPRINTK("error on xmit_dir_frame request: %02X\n",
1269 xmit_ret_code);
1270 if (ti->current_skb) {
1271 dev_kfree_skb_irq(ti->current_skb);
1272 ti->current_skb = NULL;
1273 }
1274 /*dev->tbusy = 0;*/
1275 netif_wake_queue(dev);
1276 if (ti->readlog_pending)
1277 ibmtr_readlog(dev);
1278 break;
1279 }
1280 case XMIT_UI_FRAME:{
1281 unsigned char xmit_ret_code;
1282
1283 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1284 if (xmit_ret_code == 0xff) break;
1285 DPRINTK("error on xmit_ui_frame request: %02X\n",
1286 xmit_ret_code);
1287 if (ti->current_skb) {
1288 dev_kfree_skb_irq(ti->current_skb);
1289 ti->current_skb = NULL;
1290 }
1291 netif_wake_queue(dev);
1292 if (ti->readlog_pending)
1293 ibmtr_readlog(dev);
1294 break;
1295 }
1296 case DIR_OPEN_ADAPTER:
1297 dir_open_adapter(dev);
1298 break;
1299 case DLC_OPEN_SAP:
1300 if (readb(ti->srb + RETCODE_OFST)) {
1301 DPRINTK("open_sap failed: ret_code = %02X, "
1302 "retrying\n",
1303 (int) readb(ti->srb + RETCODE_OFST));
1304 ti->open_action = REOPEN;
1305 ibmtr_reset_timer(&(ti->tr_timer), dev);
1306 break;
1307 }
1308 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1309 ti->sap_status = OPEN;/* TR adapter is now available */
1310 if (ti->open_mode==MANUAL){
1311 wake_up(&ti->wait_for_reset);
1312 break;
1313 }
1314 netif_wake_queue(dev);
1315 netif_carrier_on(dev);
1316 break;
1317 case DIR_INTERRUPT:
1318 case DIR_MOD_OPEN_PARAMS:
1319 case DIR_SET_GRP_ADDR:
1320 case DIR_SET_FUNC_ADDR:
1321 case DLC_CLOSE_SAP:
1322 if (readb(ti->srb + RETCODE_OFST))
1323 DPRINTK("error on %02X: %02X\n",
1324 (int) readb(ti->srb + COMMAND_OFST),
1325 (int) readb(ti->srb + RETCODE_OFST));
1326 break;
1327 case DIR_READ_LOG:
1328 if (readb(ti->srb + RETCODE_OFST)){
1329 DPRINTK("error on dir_read_log: %02X\n",
1330 (int) readb(ti->srb + RETCODE_OFST));
1331 netif_wake_queue(dev);
1332 break;
1333 }
1334 #if IBMTR_DEBUG_MESSAGES
1335
1336 #define LINE_ERRORS_OFST 0
1337 #define INTERNAL_ERRORS_OFST 1
1338 #define BURST_ERRORS_OFST 2
1339 #define AC_ERRORS_OFST 3
1340 #define ABORT_DELIMITERS_OFST 4
1341 #define LOST_FRAMES_OFST 6
1342 #define RECV_CONGEST_COUNT_OFST 7
1343 #define FRAME_COPIED_ERRORS_OFST 8
1344 #define FREQUENCY_ERRORS_OFST 9
1345 #define TOKEN_ERRORS_OFST 10
1346
1347 DPRINTK("Line errors %02X, Internal errors %02X, "
1348 "Burst errors %02X\n" "A/C errors %02X, "
1349 "Abort delimiters %02X, Lost frames %02X\n"
1350 "Receive congestion count %02X, "
1351 "Frame copied errors %02X\nFrequency errors %02X, "
1352 "Token errors %02X\n",
1353 (int) readb(ti->srb + LINE_ERRORS_OFST),
1354 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1355 (int) readb(ti->srb + BURST_ERRORS_OFST),
1356 (int) readb(ti->srb + AC_ERRORS_OFST),
1357 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1358 (int) readb(ti->srb + LOST_FRAMES_OFST),
1359 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1360 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1361 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1362 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1363 #endif
1364 netif_wake_queue(dev);
1365 break;
1366 default:
1367 DPRINTK("Unknown command %02X encountered\n",
1368 (int) readb(ti->srb));
1369 } /* end switch SRB command check */
1370 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1371 } /* if SRB response */
1372 if (status & ASB_FREE_INT) { /* ASB response */
1373 SET_PAGE(ti->asb_page);
1374 #if TR_VERBOSE
1375 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1376 #endif
1377
1378 switch (readb(ti->asb)) { /* ASB command check */
1379 case REC_DATA:
1380 case XMIT_UI_FRAME:
1381 case XMIT_DIR_FRAME:
1382 break;
1383 default:
1384 DPRINTK("unknown command in asb %02X\n",
1385 (int) readb(ti->asb));
1386 } /* switch ASB command check */
1387 if (readb(ti->asb + 2) != 0xff) /* checks ret_code */
1388 DPRINTK("ASB error %02X in cmd %02X\n",
1389 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1390 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1391 } /* if ASB response */
1392
1393 #define STATUS_OFST 6
1394 #define NETW_STATUS_OFST 6
1395
1396 if (status & ARB_CMD_INT) { /* ARB response */
1397 SET_PAGE(ti->arb_page);
1398 #if TR_VERBOSE
1399 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1400 #endif
1401
1402 switch (readb(ti->arb)) { /* ARB command check */
1403 case DLC_STATUS:
1404 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1405 ntohs(readw(ti->arb + STATUS_OFST)),
1406 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1407 break;
1408 case REC_DATA:
1409 tr_rx(dev);
1410 break;
1411 case RING_STAT_CHANGE:{
1412 unsigned short ring_status;
1413 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1414 if (ibmtr_debug_trace & TRC_INIT)
1415 DPRINTK("Ring Status Change...(0x%x)\n",
1416 ring_status);
1417 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1418 netif_stop_queue(dev);
1419 netif_carrier_off(dev);
1420 DPRINTK("Remove received, or Auto-removal error"
1421 ", or Lobe fault\n");
1422 DPRINTK("We'll try to reopen the closed adapter"
1423 " after a %d second delay.\n",
1424 TR_RETRY_INTERVAL/HZ);
1425 /*I was confused: I saw the TR reopening but */
1426 /*forgot:with an RJ45 in an RJ45/ICS adapter */
1427 /*but adapter not in the ring, the TR will */
1428 /* open, and then soon close and come here. */
1429 ti->open_mode = AUTOMATIC;
1430 ti->open_status = CLOSED; /*12/2000 BMS*/
1431 ti->open_action = REOPEN;
1432 ibmtr_reset_timer(&(ti->tr_timer), dev);
1433 } else if (ring_status & LOG_OVERFLOW) {
1434 if(netif_queue_stopped(dev))
1435 ti->readlog_pending = 1;
1436 else
1437 ibmtr_readlog(dev);
1438 }
1439 break;
1440 }
1441 case XMIT_DATA_REQ:
1442 tr_tx(dev);
1443 break;
1444 default:
1445 DPRINTK("Unknown command %02X in arb\n",
1446 (int) readb(ti->arb));
1447 break;
1448 } /* switch ARB command check */
1449 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1450 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1451 } /* if ARB response */
1452 if (status & SSB_RESP_INT) { /* SSB response */
1453 unsigned char retcode;
1454 SET_PAGE(ti->ssb_page);
1455 #if TR_VERBOSE
1456 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1457 readb(ti->ssb), readb(ti->ssb + 2));
1458 #endif
1459
1460 switch (readb(ti->ssb)) { /* SSB command check */
1461 case XMIT_DIR_FRAME:
1462 case XMIT_UI_FRAME:
1463 retcode = readb(ti->ssb + 2);
1464 if (retcode && (retcode != 0x22))/* checks ret_code */
1465 DPRINTK("xmit ret_code: %02X xmit error code: "
1466 "%02X\n",
1467 (int)retcode, (int)readb(ti->ssb + 6));
1468 else
1469 ti->tr_stats.tx_packets++;
1470 break;
1471 case XMIT_XID_CMD:
1472 DPRINTK("xmit xid ret_code: %02X\n",
1473 (int) readb(ti->ssb + 2));
1474 default:
1475 DPRINTK("Unknown command %02X in ssb\n",
1476 (int) readb(ti->ssb));
1477 } /* SSB command check */
1478 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1479 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1480 } /* if SSB response */
1481 #ifdef ENABLE_PAGING
1482 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1483 #endif
1484 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1485 spin_unlock(&(ti->lock));
1486 return IRQ_HANDLED;
1487 } /*tok_interrupt */
1488
1489 /*****************************************************************************/
1490
1491 #define INIT_STATUS_OFST 1
1492 #define INIT_STATUS_2_OFST 2
1493 #define ENCODED_ADDRESS_OFST 8
1494
1495 static void initial_tok_int(struct net_device *dev)
1496 {
1497
1498 __u32 encoded_addr, hw_encoded_addr;
1499 struct tok_info *ti;
1500 unsigned char init_status; /*BMS 12/2000*/
1501
1502 ti = (struct tok_info *) dev->priv;
1503
1504 ti->do_tok_int = NOT_FIRST;
1505
1506 /* we assign the shared-ram address for ISA devices */
1507 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1508 #ifndef PCMCIA
1509 ti->sram_virt = ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1510 #endif
1511 ti->init_srb = map_address(ti,
1512 ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN)),
1513 &ti->init_srb_page);
1514 if (ti->page_mask && ti->avail_shared_ram == 127) {
1515 void __iomem *last_512;
1516 __u8 last_512_page=0;
1517 int i;
1518 last_512 = map_address(ti, 0xfe00, &last_512_page);
1519 /* initialize high section of ram (if necessary) */
1520 SET_PAGE(last_512_page);
1521 for (i = 0; i < 512; i++)
1522 writeb(0, last_512 + i);
1523 }
1524 SET_PAGE(ti->init_srb_page);
1525
1526 #if TR_VERBOSE
1527 {
1528 int i;
1529
1530 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1531 DPRINTK("init_srb(%p):", ti->init_srb );
1532 for (i = 0; i < 20; i++)
1533 printk("%02X ", (int) readb(ti->init_srb + i));
1534 printk("\n");
1535 }
1536 #endif
1537
1538 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1539 encoded_addr = ntohs(hw_encoded_addr);
1540 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1541 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1542 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1543 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1544 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1545 ti->ring_speed, (unsigned int)dev->mem_start);
1546 ti->auto_speedsave=readb(ti->init_srb+INIT_STATUS_2_OFST)&4?TRUE:FALSE;
1547
1548 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1549 else tok_open_adapter((unsigned long)dev);
1550
1551 } /*initial_tok_int() */
1552
1553 /*****************************************************************************/
1554
1555 #define CMD_CORRELATE_OFST 1
1556 #define DHB_ADDRESS_OFST 6
1557
1558 #define FRAME_LENGTH_OFST 6
1559 #define HEADER_LENGTH_OFST 8
1560 #define RSAP_VALUE_OFST 9
1561
1562 static void tr_tx(struct net_device *dev)
1563 {
1564 struct tok_info *ti = (struct tok_info *) dev->priv;
1565 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1566 unsigned int hdr_len;
1567 __u32 dhb=0,dhb_base;
1568 void __iomem *dhbuf = NULL;
1569 unsigned char xmit_command;
1570 int i,dhb_len=0x4000,src_len,src_offset;
1571 struct trllc *llc;
1572 struct srb_xmit xsrb;
1573 __u8 dhb_page = 0;
1574 __u8 llc_ssap;
1575
1576 SET_PAGE(ti->asb_page);
1577
1578 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1579
1580 /* in providing the transmit interrupts, is telling us it is ready for
1581 data and providing a shared memory address for us to stuff with data.
1582 Here we compute the effective address where we will place data.
1583 */
1584 SET_PAGE(ti->arb_page);
1585 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1586 if (ti->page_mask) {
1587 dhb_page = (dhb_base >> 8) & ti->page_mask;
1588 dhb=dhb_base & ~(ti->page_mask << 8);
1589 }
1590 dhbuf = ti->sram_virt + dhb;
1591
1592 /* Figure out the size of the 802.5 header */
1593 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1594 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1595 else
1596 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1597 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1598
1599 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1600
1601 llc_ssap = llc->ssap;
1602 SET_PAGE(ti->srb_page);
1603 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1604 SET_PAGE(ti->asb_page);
1605 xmit_command = xsrb.command;
1606
1607 writeb(xmit_command, ti->asb + COMMAND_OFST);
1608 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1609 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1610 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1611 writeb(0, ti->asb + RETCODE_OFST);
1612 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1613 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1614 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1615 SET_PAGE(dhb_page);
1616 writeb(AC, dhbuf);
1617 writeb(LLC_FRAME, dhbuf + 1);
1618 for (i = 0; i < TR_ALEN; i++)
1619 writeb((int) 0x0FF, dhbuf + i + 2);
1620 for (i = 0; i < TR_ALEN; i++)
1621 writeb(0, dhbuf + i + TR_ALEN + 2);
1622 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1623 return;
1624 }
1625 /*
1626 * the token ring packet is copied from sk_buff to the adapter
1627 * buffer identified in the command data received with the interrupt.
1628 */
1629 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1630 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1631 src_len=ti->current_skb->len;
1632 src_offset=0;
1633 dhb=dhb_base;
1634 while(1) {
1635 if (ti->page_mask) {
1636 dhb_page=(dhb >> 8) & ti->page_mask;
1637 dhb=dhb & ~(ti->page_mask << 8);
1638 dhb_len=0x4000-dhb; /* remaining size of this page */
1639 }
1640 dhbuf = ti->sram_virt + dhb;
1641 SET_PAGE(dhb_page);
1642 if (src_len > dhb_len) {
1643 memcpy_toio(dhbuf,&ti->current_skb->data[src_offset],
1644 dhb_len);
1645 src_len -= dhb_len;
1646 src_offset += dhb_len;
1647 dhb_base+=dhb_len;
1648 dhb=dhb_base;
1649 continue;
1650 }
1651 memcpy_toio(dhbuf, &ti->current_skb->data[src_offset], src_len);
1652 break;
1653 }
1654 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1655 ti->tr_stats.tx_bytes += ti->current_skb->len;
1656 dev_kfree_skb_irq(ti->current_skb);
1657 ti->current_skb = NULL;
1658 netif_wake_queue(dev);
1659 if (ti->readlog_pending)
1660 ibmtr_readlog(dev);
1661 } /*tr_tx */
1662
1663 /*****************************************************************************/
1664
1665
1666 #define RECEIVE_BUFFER_OFST 6
1667 #define LAN_HDR_LENGTH_OFST 8
1668 #define DLC_HDR_LENGTH_OFST 9
1669
1670 #define DSAP_OFST 0
1671 #define SSAP_OFST 1
1672 #define LLC_OFST 2
1673 #define PROTID_OFST 3
1674 #define ETHERTYPE_OFST 6
1675
1676 static void tr_rx(struct net_device *dev)
1677 {
1678 struct tok_info *ti = (struct tok_info *) dev->priv;
1679 __u32 rbuffer;
1680 void __iomem *rbuf, *rbufdata, *llc;
1681 __u8 rbuffer_page = 0;
1682 unsigned char *data;
1683 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1684 unsigned char dlc_hdr_len;
1685 struct sk_buff *skb;
1686 unsigned int skb_size = 0;
1687 int IPv4_p = 0;
1688 unsigned int chksum = 0;
1689 struct iphdr *iph;
1690 struct arb_rec_req rarb;
1691
1692 SET_PAGE(ti->arb_page);
1693 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1694 rbuffer = ntohs(rarb.rec_buf_addr) ;
1695 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1696
1697 SET_PAGE(ti->asb_page);
1698
1699 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1700
1701 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1702 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1703 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1704
1705 lan_hdr_len = rarb.lan_hdr_len;
1706 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1707 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1708 return;
1709 } /*BMS I added this above just to be very safe */
1710 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1711 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1712
1713 SET_PAGE(rbuffer_page);
1714 llc = rbuf + offsetof(struct rec_buf, data) + lan_hdr_len;
1715
1716 #if TR_VERBOSE
1717 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1718 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1719 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1720 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1721 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1722 "ethertype: %04X\n",
1723 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1724 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1725 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1726 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1727 #endif
1728 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1729 SET_PAGE(ti->asb_page);
1730 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1731 ti->tr_stats.rx_dropped++;
1732 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1733 return;
1734 }
1735 length = ntohs(rarb.frame_len);
1736 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1737 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1738 length >= hdr_len) IPv4_p = 1;
1739 #if TR_VERBOSE
1740 #define SADDR_OFST 8
1741 #define DADDR_OFST 2
1742
1743 if (!IPv4_p) {
1744
1745 void __iomem *trhhdr = rbuf + offsetof(struct rec_buf, data);
1746
1747 DPRINTK("Probably non-IP frame received.\n");
1748 DPRINTK("ssap: %02X dsap: %02X "
1749 "saddr: %02X:%02X:%02X:%02X:%02X:%02X "
1750 "daddr: %02X:%02X:%02X:%02X:%02X:%02X\n",
1751 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1752 readb(trhhdr+SADDR_OFST), readb(trhhdr+ SADDR_OFST+1),
1753 readb(trhhdr+SADDR_OFST+2), readb(trhhdr+SADDR_OFST+3),
1754 readb(trhhdr+SADDR_OFST+4), readb(trhhdr+SADDR_OFST+5),
1755 readb(trhhdr+DADDR_OFST), readb(trhhdr+DADDR_OFST + 1),
1756 readb(trhhdr+DADDR_OFST+2), readb(trhhdr+DADDR_OFST+3),
1757 readb(trhhdr+DADDR_OFST+4), readb(trhhdr+DADDR_OFST+5));
1758 }
1759 #endif
1760
1761 /*BMS handle the case she comes in with few hops but leaves with many */
1762 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1763
1764 if (!(skb = dev_alloc_skb(skb_size))) {
1765 DPRINTK("out of memory. frame dropped.\n");
1766 ti->tr_stats.rx_dropped++;
1767 SET_PAGE(ti->asb_page);
1768 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1769 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1770 return;
1771 }
1772 /*BMS again, if she comes in with few but leaves with many */
1773 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1774 skb_put(skb, length);
1775 skb->dev = dev;
1776 data = skb->data;
1777 rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len)));
1778 rbufdata = rbuf + offsetof(struct rec_buf, data);
1779
1780 if (IPv4_p) {
1781 /* Copy the headers without checksumming */
1782 memcpy_fromio(data, rbufdata, hdr_len);
1783
1784 /* Watch for padded packets and bogons */
1785 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1786 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1787 length -= hdr_len;
1788 if ((ip_len <= length) && (ip_len > 7))
1789 length = ip_len;
1790 data += hdr_len;
1791 rbuffer_len -= hdr_len;
1792 rbufdata += hdr_len;
1793 }
1794 /* Copy the payload... */
1795 #define BUFFER_POINTER_OFST 2
1796 #define BUFFER_LENGTH_OFST 6
1797 for (;;) {
1798 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1799 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1800 length,rbuffer_len);
1801 if (IPv4_p)
1802 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1803 data,length<rbuffer_len?length:rbuffer_len,chksum);
1804 else
1805 memcpy_fromio(data, rbufdata, rbuffer_len);
1806 rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ;
1807 if (!rbuffer)
1808 break;
1809 rbuffer -= 2;
1810 length -= rbuffer_len;
1811 data += rbuffer_len;
1812 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1813 SET_PAGE(rbuffer_page);
1814 rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST));
1815 rbufdata = rbuf + offsetof(struct rec_buf, data);
1816 }
1817
1818 SET_PAGE(ti->asb_page);
1819 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1820
1821 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1822
1823 ti->tr_stats.rx_bytes += skb->len;
1824 ti->tr_stats.rx_packets++;
1825
1826 skb->protocol = tr_type_trans(skb, dev);
1827 if (IPv4_p) {
1828 skb->csum = chksum;
1829 skb->ip_summed = 1;
1830 }
1831 netif_rx(skb);
1832 dev->last_rx = jiffies;
1833 } /*tr_rx */
1834
1835 /*****************************************************************************/
1836
1837 static void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1838 {
1839 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1840 tmr->data = (unsigned long) dev;
1841 tmr->function = tok_rerun;
1842 init_timer(tmr);
1843 add_timer(tmr);
1844 }
1845
1846 /*****************************************************************************/
1847
1848 void tok_rerun(unsigned long dev_addr){
1849
1850 struct net_device *dev = (struct net_device *)dev_addr;
1851 struct tok_info *ti = (struct tok_info *) dev->priv;
1852
1853 if ( ti->open_action == RESTART){
1854 ti->do_tok_int = FIRST_INT;
1855 outb(0, dev->base_addr + ADAPTRESETREL);
1856 #ifdef ENABLE_PAGING
1857 if (ti->page_mask)
1858 writeb(SRPR_ENABLE_PAGING,
1859 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1860 #endif
1861
1862 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1863 } else
1864 tok_open_adapter(dev_addr);
1865 }
1866
1867 /*****************************************************************************/
1868
1869 static void ibmtr_readlog(struct net_device *dev)
1870 {
1871 struct tok_info *ti;
1872
1873 ti = (struct tok_info *) dev->priv;
1874
1875 ti->readlog_pending = 0;
1876 SET_PAGE(ti->srb_page);
1877 writeb(DIR_READ_LOG, ti->srb);
1878 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1879 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1880
1881 netif_stop_queue(dev);
1882
1883 }
1884
1885 /*****************************************************************************/
1886
1887 /* tok_get_stats(): Basically a scaffold routine which will return
1888 the address of the tr_statistics structure associated with
1889 this device -- the tr.... structure is an ethnet look-alike
1890 so at least for this iteration may suffice. */
1891
1892 static struct net_device_stats *tok_get_stats(struct net_device *dev)
1893 {
1894
1895 struct tok_info *toki;
1896 toki = (struct tok_info *) dev->priv;
1897 return (struct net_device_stats *) &toki->tr_stats;
1898 }
1899
1900 /*****************************************************************************/
1901
1902 static int ibmtr_change_mtu(struct net_device *dev, int mtu)
1903 {
1904 struct tok_info *ti = (struct tok_info *) dev->priv;
1905
1906 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1907 return -EINVAL;
1908 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1909 return -EINVAL;
1910 dev->mtu = mtu;
1911 return 0;
1912 }
1913
1914 /*****************************************************************************/
1915 #ifdef MODULE
1916
1917 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1918 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1919 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1920 static int irq[IBMTR_MAX_ADAPTERS];
1921 static int mem[IBMTR_MAX_ADAPTERS];
1922
1923 MODULE_LICENSE("GPL");
1924
1925 module_param_array(io, int, NULL, 0);
1926 module_param_array(irq, int, NULL, 0);
1927 module_param_array(mem, int, NULL, 0);
1928
1929 static int __init ibmtr_init(void)
1930 {
1931 int i;
1932 int count=0;
1933
1934 find_turbo_adapters(io);
1935
1936 for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) {
1937 struct net_device *dev;
1938 irq[i] = 0;
1939 mem[i] = 0;
1940 dev = alloc_trdev(sizeof(struct tok_info));
1941 if (dev == NULL) {
1942 if (i == 0)
1943 return -ENOMEM;
1944 break;
1945 }
1946 dev->base_addr = io[i];
1947 dev->irq = irq[i];
1948 dev->mem_start = mem[i];
1949
1950 if (ibmtr_probe_card(dev)) {
1951 free_netdev(dev);
1952 continue;
1953 }
1954 dev_ibmtr[i] = dev;
1955 count++;
1956 }
1957 if (count) return 0;
1958 printk("ibmtr: register_netdev() returned non-zero.\n");
1959 return -EIO;
1960 }
1961 module_init(ibmtr_init);
1962
1963 static void __exit ibmtr_cleanup(void)
1964 {
1965 int i;
1966
1967 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1968 if (!dev_ibmtr[i])
1969 continue;
1970 unregister_netdev(dev_ibmtr[i]);
1971 ibmtr_cleanup_card(dev_ibmtr[i]);
1972 free_netdev(dev_ibmtr[i]);
1973 }
1974 }
1975 module_exit(ibmtr_cleanup);
1976 #endif
Linux with added FPC-III support