?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / net / tokenring / ibmtr.c
blobc098863bdd9d408a7b0ca4cd176c83a9e1516774
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 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 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 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 void tok_open_adapter(unsigned long dev_addr);
196 static void open_sap(unsigned char type, struct net_device *dev);
197 static void tok_set_multicast_list(struct net_device *dev);
198 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev);
199 static int tok_close(struct net_device *dev);
200 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs);
201 static void initial_tok_int(struct net_device *dev);
202 static void tr_tx(struct net_device *dev);
203 static void tr_rx(struct net_device *dev);
204 void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev);
205 static void tok_rerun(unsigned long dev_addr);
206 void ibmtr_readlog(struct net_device *dev);
207 static struct net_device_stats *tok_get_stats(struct net_device *dev);
208 int ibmtr_change_mtu(struct net_device *dev, int mtu);
209 static void find_turbo_adapters(int *iolist);
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(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 kfree(ti);
535 return -ENODEV;
536 }
537 ti->sram_phys =
538 ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12);
539 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
540 break;
541 } /*end switch (cardpresent) */
542 #endif /*not PCMCIA */
543
544 if (ibmtr_debug_trace & TRC_INIT) { /* just report int */
545 DPRINTK("irq=%d", irq);
546 printk(", sram_phys=0x%x", ti->sram_phys);
547 if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */
548 DPRINTK(", ti->mmio=%p", ti->mmio);
549 printk(", segment=%02X", segment);
550 }
551 printk(".\n");
552 }
553
554 /* Get hw address of token ring card */
555 j = 0;
556 for (i = 0; i < 0x18; i = i + 2) {
557 /* technical reference states to do this */
558 temp = readb(ti->mmio + AIP + i) & 0x0f;
559 ti->hw_address[j] = temp;
560 if (j & 1)
561 dev->dev_addr[(j / 2)] =
562 ti->hw_address[j]+ (ti->hw_address[j - 1] << 4);
563 ++j;
564 }
565 /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */
566 ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);
567
568 /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */
569 ti->data_rate = readb(ti->mmio + AIPDATARATE);
570
571 /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */
572 ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);
573
574 /* How much shared RAM is on adapter ? */
575 if (ti->turbo) {
576 ti->avail_shared_ram=127;
577 } else {
578 ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */
579 }
580 /* We need to set or do a bunch of work here based on previous results*/
581 /* Support paging? What sizes?: F=no, E=16k, D=32k, C=16 & 32k */
582 ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE);
583
584 /* Available DHB 4Mb size: F=2048, E=4096, D=4464 */
585 switch (readb(ti->mmio + AIP4MBDHB)) {
586 case 0xe: ti->dhb_size4mb = 4096; break;
587 case 0xd: ti->dhb_size4mb = 4464; break;
588 default: ti->dhb_size4mb = 2048; break;
589 }
590
591 /* Available DHB 16Mb size: F=2048, E=4096, D=8192, C=16384, B=17960 */
592 switch (readb(ti->mmio + AIP16MBDHB)) {
593 case 0xe: ti->dhb_size16mb = 4096; break;
594 case 0xd: ti->dhb_size16mb = 8192; break;
595 case 0xc: ti->dhb_size16mb = 16384; break;
596 case 0xb: ti->dhb_size16mb = 17960; break;
597 default: ti->dhb_size16mb = 2048; break;
598 }
599
600 /* We must figure out how much shared memory space this adapter
601 * will occupy so that if there are two adapters we can fit both
602 * in. Given a choice, we will limit this adapter to 32K. The
603 * maximum space will will use for two adapters is 64K so if the
604 * adapter we are working on demands 64K (it also doesn't support
605 * paging), then only one adapter can be supported.
606 */
607
608 /*
609 * determine how much of total RAM is mapped into PC space
610 */
611 ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/
612 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4);
613 ti->page_mask = 0;
614 if (ti->turbo) ti->page_mask=0xf0;
615 else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */
616 else {
617 #ifdef ENABLE_PAGING
618 unsigned char pg_size = 0;
619 /* BMS: page size: PCMCIA, use configuration register;
620 ISAPNP, use LANAIDC config tool from www.ibm.com */
621 switch (ti->shared_ram_paging) {
622 case 0xf:
623 break;
624 case 0xe:
625 ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0;
626 pg_size = 32; /* 16KB page size */
627 break;
628 case 0xd:
629 ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0;
630 pg_size = 64; /* 32KB page size */
631 break;
632 case 0xc:
633 switch (ti->mapped_ram_size) {
634 case 32:
635 ti->page_mask = 0xc0;
636 pg_size = 32;
637 break;
638 case 64:
639 ti->page_mask = 0x80;
640 pg_size = 64;
641 break;
642 }
643 break;
644 default:
645 DPRINTK("Unknown shared ram paging info %01X\n",
646 ti->shared_ram_paging);
647 iounmap(t_mmio);
648 kfree(ti);
649 return -ENODEV;
650 break;
651 } /*end switch shared_ram_paging */
652
653 if (ibmtr_debug_trace & TRC_INIT)
654 DPRINTK("Shared RAM paging code: %02X, "
655 "mapped RAM size: %dK, shared RAM size: %dK, "
656 "page mask: %02X\n:",
657 ti->shared_ram_paging, ti->mapped_ram_size / 2,
658 ti->avail_shared_ram / 2, ti->page_mask);
659 #endif /*ENABLE_PAGING */
660 }
661
662 #ifndef PCMCIA
663 /* finish figuring the shared RAM address */
664 if (cardpresent == TR_ISA) {
665 static __u32 ram_bndry_mask[] =
666 { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 };
667 __u32 new_base, rrr_32, chk_base, rbm;
668
669 rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03;
670 rbm = ram_bndry_mask[rrr_32];
671 new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */
672 chk_base = new_base + (ti->mapped_ram_size << 9);
673 if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) {
674 DPRINTK("Shared RAM for this adapter (%05x) exceeds "
675 "driver limit (%05x), adapter not started.\n",
676 chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
677 iounmap(t_mmio);
678 kfree(ti);
679 return -ENODEV;
680 } else { /* seems cool, record what we have figured out */
681 ti->sram_base = new_base >> 12;
682 ibmtr_mem_base = chk_base;
683 }
684 }
685 else ti->sram_base = ti->sram_phys >> 12;
686
687 /* The PCMCIA has already got the interrupt line and the io port,
688 so no chance of anybody else getting it - MLP */
689 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
690 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
691 irq);
692 iounmap(t_mmio);
693 kfree(ti);
694 return -ENODEV;
695 }
696 /*?? Now, allocate some of the PIO PORTs for this driver.. */
697 /* record PIOaddr range as busy */
698 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
699 DPRINTK("Could not grab PIO range. Halting driver.\n");
700 free_irq(dev->irq, dev);
701 iounmap(t_mmio);
702 kfree(ti);
703 return -EBUSY;
704 }
705
706 if (!version_printed++) {
707 printk(version);
708 }
709 #endif /* !PCMCIA */
710 DPRINTK("%s %s found\n",
711 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
712 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
713 irq, PIOaddr, ti->mapped_ram_size / 2);
714 DPRINTK("Hardware address : %02X:%02X:%02X:%02X:%02X:%02X\n",
715 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
716 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
717 if (ti->page_mask)
718 DPRINTK("Shared RAM paging enabled. "
719 "Page size: %uK Shared Ram size %dK\n",
720 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
721 else
722 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
723 ti->page_mask);
724
725 /* Calculate the maximum DHB we can use */
726 /* two cases where avail_shared_ram doesn't equal mapped_ram_size:
727 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical)
728 2. user has configured adapter for less than avail_shared_ram
729 but is not using paging (she should use paging, I believe)
730 */
731 if (!ti->page_mask) {
732 ti->avail_shared_ram=
733 min(ti->mapped_ram_size,ti->avail_shared_ram);
734 }
735
736 switch (ti->avail_shared_ram) {
737 case 16: /* 8KB shared RAM */
738 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
739 ti->rbuf_len4 = 1032;
740 ti->rbuf_cnt4=2;
741 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
742 ti->rbuf_len16 = 1032;
743 ti->rbuf_cnt16=2;
744 break;
745 case 32: /* 16KB shared RAM */
746 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
747 ti->rbuf_len4 = 1032;
748 ti->rbuf_cnt4=4;
749 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
750 ti->rbuf_len16 = 1032; /*1024 usable */
751 ti->rbuf_cnt16=4;
752 break;
753 case 64: /* 32KB shared RAM */
754 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
755 ti->rbuf_len4 = 1032;
756 ti->rbuf_cnt4=6;
757 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
758 ti->rbuf_len16 = 1032;
759 ti->rbuf_cnt16=6;
760 break;
761 case 127: /* 63.5KB shared RAM */
762 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
763 ti->rbuf_len4 = 1032;
764 ti->rbuf_cnt4=6;
765 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
766 ti->rbuf_len16 = 1032;
767 ti->rbuf_cnt16=16;
768 break;
769 case 128: /* 64KB shared RAM */
770 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
771 ti->rbuf_len4 = 1032;
772 ti->rbuf_cnt4=6;
773 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
774 ti->rbuf_len16 = 1032;
775 ti->rbuf_cnt16=16;
776 break;
777 default:
778 ti->dhb_size4mb = 2048;
779 ti->rbuf_len4 = 1032;
780 ti->rbuf_cnt4=2;
781 ti->dhb_size16mb = 2048;
782 ti->rbuf_len16 = 1032;
783 ti->rbuf_cnt16=2;
784 break;
785 }
786 /* this formula is not smart enough for the paging case
787 ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE -
788 ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH -
789 DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB -
790 SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>;
791 */
792 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
793 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
794 /*BMS assuming 18 bytes of Routing Information (usually works) */
795 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
796 ti->maxmtu16, ti->maxmtu4);
797
798 dev->base_addr = PIOaddr; /* set the value for device */
799 dev->mem_start = ti->sram_base << 12;
800 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
801 trdev_init(dev);
802 return 0; /* Return 0 to indicate we have found a Token Ring card. */
803 } /*ibmtr_probe1() */
804
805 /*****************************************************************************/
806
807 /* query the adapter for the size of shared RAM */
808 /* the function returns the RAM size in units of 512 bytes */
809
810 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
811 {
812 unsigned char avail_sram_code;
813 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
814 /* Adapter gives
815 'F' -- use RRR bits 3,2
816 'E' -- 8kb 'D' -- 16kb
817 'C' -- 32kb 'A' -- 64KB
818 'B' - 64KB less 512 bytes at top
819 (WARNING ... must zero top bytes in INIT */
820
821 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
822 if (avail_sram_code) return size_code[avail_sram_code];
823 else /* for code 'F', must compute size from RRR(3,2) bits */
824 return 1 <<
825 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
826 }
827
828 /*****************************************************************************/
829
830 static int __devinit trdev_init(struct net_device *dev)
831 {
832 struct tok_info *ti = (struct tok_info *) dev->priv;
833
834 SET_PAGE(ti->srb_page);
835 ti->open_failure = NO ;
836 dev->open = tok_open;
837 dev->stop = tok_close;
838 dev->hard_start_xmit = tok_send_packet;
839 dev->get_stats = tok_get_stats;
840 dev->set_multicast_list = tok_set_multicast_list;
841 dev->change_mtu = ibmtr_change_mtu;
842
843 return 0;
844 }
845
846 /*****************************************************************************/
847
848 static int tok_init_card(struct net_device *dev)
849 {
850 struct tok_info *ti;
851 short PIOaddr;
852 unsigned long i;
853
854 PIOaddr = dev->base_addr;
855 ti = (struct tok_info *) dev->priv;
856 /* Special processing for first interrupt after reset */
857 ti->do_tok_int = FIRST_INT;
858 /* Reset adapter */
859 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
860 outb(0, PIOaddr + ADAPTRESET);
861
862 current->state=TASK_UNINTERRUPTIBLE;
863 schedule_timeout(TR_RST_TIME); /* wait 50ms */
864
865 outb(0, PIOaddr + ADAPTRESETREL);
866 #ifdef ENABLE_PAGING
867 if (ti->page_mask)
868 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
869 #endif
870 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
871 i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ);
872 return i? 0 : -EAGAIN;
873 }
874
875 /*****************************************************************************/
876 static int tok_open(struct net_device *dev)
877 {
878 struct tok_info *ti = (struct tok_info *) dev->priv;
879 int i;
880
881 /*the case we were left in a failure state during a previous open */
882 if (ti->open_failure == YES) {
883 DPRINTK("Last time you were disconnected, how about now?\n");
884 printk("You can't insert with an ICS connector half-cocked.\n");
885 }
886
887 ti->open_status = CLOSED; /* CLOSED or OPEN */
888 ti->sap_status = CLOSED; /* CLOSED or OPEN */
889 ti->open_failure = NO; /* NO or YES */
890 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
891 /* 12/2000 not typical Linux, but we can use RUNNING to let us know when
892 the network has crapped out or cables are disconnected. Useful because
893 the IFF_UP flag stays up the whole time, until ifconfig tr0 down.
894 */
895 dev->flags &= ~IFF_RUNNING;
896
897 ti->sram_phys &= ~1; /* to reverse what we do in tok_close */
898 /* init the spinlock */
899 spin_lock_init(&ti->lock);
900 init_timer(&ti->tr_timer);
901
902 i = tok_init_card(dev);
903 if (i) return i;
904
905 while (1){
906 tok_open_adapter((unsigned long) dev);
907 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
908 /* sig catch: estimate opening adapter takes more than .5 sec*/
909 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
910 if (i==0) break;
911 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
912 netif_start_queue(dev);
913 DPRINTK("Adapter is up and running\n");
914 return 0;
915 }
916 current->state=TASK_INTERRUPTIBLE;
917 i=schedule_timeout(TR_RETRY_INTERVAL); /* wait 30 seconds */
918 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
919 }
920 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
921 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
922 return -EAGAIN;
923 }
924
925 /*****************************************************************************/
926
927 #define COMMAND_OFST 0
928 #define OPEN_OPTIONS_OFST 8
929 #define NUM_RCV_BUF_OFST 24
930 #define RCV_BUF_LEN_OFST 26
931 #define DHB_LENGTH_OFST 28
932 #define NUM_DHB_OFST 30
933 #define DLC_MAX_SAP_OFST 32
934 #define DLC_MAX_STA_OFST 33
935
936 void tok_open_adapter(unsigned long dev_addr)
937 {
938 struct net_device *dev = (struct net_device *) dev_addr;
939 struct tok_info *ti;
940 int i;
941
942 ti = (struct tok_info *) dev->priv;
943 SET_PAGE(ti->init_srb_page);
944 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
945 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
946 writeb(0, ti->init_srb + i);
947 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
948 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
949 if (ti->ring_speed == 16) {
950 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
951 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
952 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
953 } else {
954 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
955 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
956 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
957 }
958 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
959 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
960 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
961 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
962 ti->srb_page = ti->init_srb_page;
963 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
964 readb(ti->init_srb + NUM_DHB_OFST),
965 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
966 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
967 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
968 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
969 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
970 }
971
972 /*****************************************************************************/
973
974 static void open_sap(unsigned char type, struct net_device *dev)
975 {
976 int i;
977 struct tok_info *ti = (struct tok_info *) dev->priv;
978
979 SET_PAGE(ti->srb_page);
980 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
981 writeb(0, ti->srb + i);
982
983 #define MAX_I_FIELD_OFST 14
984 #define SAP_VALUE_OFST 16
985 #define SAP_OPTIONS_OFST 17
986 #define STATION_COUNT_OFST 18
987
988 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
989 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
990 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
991 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
992 writeb(type, ti->srb + SAP_VALUE_OFST);
993 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
994 }
995
996
997 /*****************************************************************************/
998
999 static void tok_set_multicast_list(struct net_device *dev)
1000 {
1001 struct tok_info *ti = (struct tok_info *) dev->priv;
1002 struct dev_mc_list *mclist;
1003 unsigned char address[4];
1004
1005 int i;
1006
1007 /*BMS the next line is CRUCIAL or you may be sad when you */
1008 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
1009 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
1010 address[0] = address[1] = address[2] = address[3] = 0;
1011 mclist = dev->mc_list;
1012 for (i = 0; i < dev->mc_count; i++) {
1013 address[0] |= mclist->dmi_addr[2];
1014 address[1] |= mclist->dmi_addr[3];
1015 address[2] |= mclist->dmi_addr[4];
1016 address[3] |= mclist->dmi_addr[5];
1017 mclist = mclist->next;
1018 }
1019 SET_PAGE(ti->srb_page);
1020 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1021 writeb(0, ti->srb + i);
1022
1023 #define FUNCT_ADDRESS_OFST 6
1024
1025 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1026 for (i = 0; i < 4; i++)
1027 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1028 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1029 #if TR_VERBOSE
1030 DPRINTK("Setting functional address: ");
1031 for (i=0;i<4;i++) printk("%02X ", address[i]);
1032 printk("\n");
1033 #endif
1034 }
1035
1036 /*****************************************************************************/
1037
1038 #define STATION_ID_OFST 4
1039
1040 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev)
1041 {
1042 struct tok_info *ti;
1043 unsigned long flags;
1044 ti = (struct tok_info *) dev->priv;
1045
1046 netif_stop_queue(dev);
1047
1048 /* lock against other CPUs */
1049 spin_lock_irqsave(&(ti->lock), flags);
1050
1051 /* Save skb; we'll need it when the adapter asks for the data */
1052 ti->current_skb = skb;
1053 SET_PAGE(ti->srb_page);
1054 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1055 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1056 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1057 spin_unlock_irqrestore(&(ti->lock), flags);
1058 dev->trans_start = jiffies;
1059 return 0;
1060 }
1061
1062 /*****************************************************************************/
1063
1064 static int tok_close(struct net_device *dev)
1065 {
1066 struct tok_info *ti = (struct tok_info *) dev->priv;
1067
1068 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1069 /* unloading the module from memory, and then if a timer pops, ouch */
1070 del_timer_sync(&ti->tr_timer);
1071 outb(0, dev->base_addr + ADAPTRESET);
1072 ti->sram_phys |= 1;
1073 ti->open_status = CLOSED;
1074
1075 netif_stop_queue(dev);
1076 DPRINTK("Adapter is closed.\n");
1077 return 0;
1078 }
1079
1080 /*****************************************************************************/
1081
1082 #define RETCODE_OFST 2
1083 #define OPEN_ERROR_CODE_OFST 6
1084 #define ASB_ADDRESS_OFST 8
1085 #define SRB_ADDRESS_OFST 10
1086 #define ARB_ADDRESS_OFST 12
1087 #define SSB_ADDRESS_OFST 14
1088
1089 static char *printphase[]= {"Lobe media test","Physical insertion",
1090 "Address verification","Roll call poll","Request Parameters"};
1091 static char *printerror[]={"Function failure","Signal loss","Reserved",
1092 "Frequency error","Timeout","Ring failure","Ring beaconing",
1093 "Duplicate node address",
1094 "Parameter request-retry count exceeded","Remove received",
1095 "IMPL force received","Duplicate modifier",
1096 "No monitor detected","Monitor contention failed for RPL"};
1097
1098 static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page)
1099 {
1100 if (ti->page_mask) {
1101 *page = (index >> 8) & ti->page_mask;
1102 index &= ~(ti->page_mask << 8);
1103 }
1104 return ti->sram_virt + index;
1105 }
1106
1107 void dir_open_adapter (struct net_device *dev)
1108 {
1109 struct tok_info *ti = (struct tok_info *) dev->priv;
1110 unsigned char ret_code;
1111 __u16 err;
1112
1113 ti->srb = map_address(ti,
1114 ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)),
1115 &ti->srb_page);
1116 ti->ssb = map_address(ti,
1117 ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)),
1118 &ti->ssb_page);
1119 ti->arb = map_address(ti,
1120 ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)),
1121 &ti->arb_page);
1122 ti->asb = map_address(ti,
1123 ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)),
1124 &ti->asb_page);
1125 ti->current_skb = NULL;
1126 ret_code = readb(ti->init_srb + RETCODE_OFST);
1127 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1128 if (!ret_code) {
1129 ti->open_status = OPEN; /* TR adapter is now available */
1130 if (ti->open_mode == AUTOMATIC) {
1131 DPRINTK("Adapter reopened.\n");
1132 }
1133 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1134 open_sap(EXTENDED_SAP, dev);
1135 return;
1136 }
1137 ti->open_failure = YES;
1138 if (ret_code == 7){
1139 if (err == 0x24) {
1140 if (!ti->auto_speedsave) {
1141 DPRINTK("Open failed: Adapter speed must match "
1142 "ring speed if Automatic Ring Speed Save is "
1143 "disabled.\n");
1144 ti->open_action = FAIL;
1145 }else
1146 DPRINTK("Retrying open to adjust to "
1147 "ring speed, ");
1148 } else if (err == 0x2d) {
1149 DPRINTK("Physical Insertion: No Monitor Detected, ");
1150 printk("retrying after %ds delay...\n",
1151 TR_RETRY_INTERVAL/HZ);
1152 } else if (err == 0x11) {
1153 DPRINTK("Lobe Media Function Failure (0x11), ");
1154 printk(" retrying after %ds delay...\n",
1155 TR_RETRY_INTERVAL/HZ);
1156 } else {
1157 char **prphase = printphase;
1158 char **prerror = printerror;
1159 DPRINTK("TR Adapter misc open failure, error code = ");
1160 printk("0x%x, Phase: %s, Error: %s\n",
1161 err, prphase[err/16 -1], prerror[err%16 -1]);
1162 printk(" retrying after %ds delay...\n",
1163 TR_RETRY_INTERVAL/HZ);
1164 }
1165 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1166 if (ti->open_action != FAIL) {
1167 if (ti->open_mode==AUTOMATIC){
1168 ti->open_action = REOPEN;
1169 ibmtr_reset_timer(&(ti->tr_timer), dev);
1170 return;
1171 }
1172 wake_up(&ti->wait_for_reset);
1173 return;
1174 }
1175 DPRINTK("FAILURE, CAPUT\n");
1176 }
1177
1178 /******************************************************************************/
1179
1180 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1181 {
1182 unsigned char status;
1183 /* unsigned char status_even ; */
1184 struct tok_info *ti;
1185 struct net_device *dev;
1186 #ifdef ENABLE_PAGING
1187 unsigned char save_srpr;
1188 #endif
1189
1190 dev = dev_id;
1191 #if TR_VERBOSE
1192 DPRINTK("Int from tok_driver, dev : %p irq%d regs=%p\n", dev,irq,regs);
1193 #endif
1194 ti = (struct tok_info *) dev->priv;
1195 if (ti->sram_phys & 1)
1196 return IRQ_NONE; /* PCMCIA card extraction flag */
1197 spin_lock(&(ti->lock));
1198 #ifdef ENABLE_PAGING
1199 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1200 #endif
1201
1202 /* Disable interrupts till processing is finished */
1203 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1204
1205 /* Reset interrupt for ISA boards */
1206 if (ti->adapter_int_enable)
1207 outb(0, ti->adapter_int_enable);
1208 else /* used for PCMCIA cards */
1209 outb(0, ti->global_int_enable);
1210 if (ti->do_tok_int == FIRST_INT){
1211 initial_tok_int(dev);
1212 #ifdef ENABLE_PAGING
1213 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1214 #endif
1215 spin_unlock(&(ti->lock));
1216 return IRQ_HANDLED;
1217 }
1218 /* Begin interrupt handler HERE inline to avoid the extra
1219 levels of logic and call depth for the original solution. */
1220 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1221 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1222 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1223 /*BMS status,status_even); */
1224
1225 if (status & ADAP_CHK_INT) {
1226 int i;
1227 void __iomem *check_reason;
1228 __u8 check_reason_page = 0;
1229 check_reason = map_address(ti,
1230 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN)),
1231 &check_reason_page);
1232 SET_PAGE(check_reason_page);
1233
1234 DPRINTK("Adapter check interrupt\n");
1235 DPRINTK("8 reason bytes follow: ");
1236 for (i = 0; i < 8; i++, check_reason++)
1237 printk("%02X ", (int) readb(check_reason));
1238 printk("\n");
1239 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1240 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1241 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1242 ti->open_status = CLOSED;
1243 ti->sap_status = CLOSED;
1244 ti->open_mode = AUTOMATIC;
1245 dev->flags &= ~IFF_RUNNING;
1246 netif_stop_queue(dev);
1247 ti->open_action = RESTART;
1248 outb(0, dev->base_addr + ADAPTRESET);
1249 ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/
1250 spin_unlock(&(ti->lock));
1251 return IRQ_HANDLED;
1252 }
1253 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1254 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1255 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1256 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1257 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1258 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1259 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/
1260 DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/
1261 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1262 #ifdef ENABLE_PAGING
1263 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1264 #endif
1265 spin_unlock(&(ti->lock));
1266 return IRQ_HANDLED;
1267 }
1268 if (status & SRB_RESP_INT) { /* SRB response */
1269 SET_PAGE(ti->srb_page);
1270 #if TR_VERBOSE
1271 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1272 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1273 #endif
1274 switch (readb(ti->srb)) { /* SRB command check */
1275 case XMIT_DIR_FRAME:{
1276 unsigned char xmit_ret_code;
1277 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1278 if (xmit_ret_code == 0xff) break;
1279 DPRINTK("error on xmit_dir_frame request: %02X\n",
1280 xmit_ret_code);
1281 if (ti->current_skb) {
1282 dev_kfree_skb_irq(ti->current_skb);
1283 ti->current_skb = NULL;
1284 }
1285 /*dev->tbusy = 0;*/
1286 netif_wake_queue(dev);
1287 if (ti->readlog_pending)
1288 ibmtr_readlog(dev);
1289 break;
1290 }
1291 case XMIT_UI_FRAME:{
1292 unsigned char xmit_ret_code;
1293
1294 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1295 if (xmit_ret_code == 0xff) break;
1296 DPRINTK("error on xmit_ui_frame request: %02X\n",
1297 xmit_ret_code);
1298 if (ti->current_skb) {
1299 dev_kfree_skb_irq(ti->current_skb);
1300 ti->current_skb = NULL;
1301 }
1302 netif_wake_queue(dev);
1303 if (ti->readlog_pending)
1304 ibmtr_readlog(dev);
1305 break;
1306 }
1307 case DIR_OPEN_ADAPTER:
1308 dir_open_adapter(dev);
1309 break;
1310 case DLC_OPEN_SAP:
1311 if (readb(ti->srb + RETCODE_OFST)) {
1312 DPRINTK("open_sap failed: ret_code = %02X, "
1313 "retrying\n",
1314 (int) readb(ti->srb + RETCODE_OFST));
1315 ti->open_action = REOPEN;
1316 ibmtr_reset_timer(&(ti->tr_timer), dev);
1317 break;
1318 }
1319 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1320 ti->sap_status = OPEN;/* TR adapter is now available */
1321 if (ti->open_mode==MANUAL){
1322 wake_up(&ti->wait_for_reset);
1323 break;
1324 }
1325 netif_wake_queue(dev);
1326 dev->flags |= IFF_RUNNING;/*BMS 12/2000*/
1327 break;
1328 case DIR_INTERRUPT:
1329 case DIR_MOD_OPEN_PARAMS:
1330 case DIR_SET_GRP_ADDR:
1331 case DIR_SET_FUNC_ADDR:
1332 case DLC_CLOSE_SAP:
1333 if (readb(ti->srb + RETCODE_OFST))
1334 DPRINTK("error on %02X: %02X\n",
1335 (int) readb(ti->srb + COMMAND_OFST),
1336 (int) readb(ti->srb + RETCODE_OFST));
1337 break;
1338 case DIR_READ_LOG:
1339 if (readb(ti->srb + RETCODE_OFST)){
1340 DPRINTK("error on dir_read_log: %02X\n",
1341 (int) readb(ti->srb + RETCODE_OFST));
1342 netif_wake_queue(dev);
1343 break;
1344 }
1345 #if IBMTR_DEBUG_MESSAGES
1346
1347 #define LINE_ERRORS_OFST 0
1348 #define INTERNAL_ERRORS_OFST 1
1349 #define BURST_ERRORS_OFST 2
1350 #define AC_ERRORS_OFST 3
1351 #define ABORT_DELIMITERS_OFST 4
1352 #define LOST_FRAMES_OFST 6
1353 #define RECV_CONGEST_COUNT_OFST 7
1354 #define FRAME_COPIED_ERRORS_OFST 8
1355 #define FREQUENCY_ERRORS_OFST 9
1356 #define TOKEN_ERRORS_OFST 10
1357
1358 DPRINTK("Line errors %02X, Internal errors %02X, "
1359 "Burst errors %02X\n" "A/C errors %02X, "
1360 "Abort delimiters %02X, Lost frames %02X\n"
1361 "Receive congestion count %02X, "
1362 "Frame copied errors %02X\nFrequency errors %02X, "
1363 "Token errors %02X\n",
1364 (int) readb(ti->srb + LINE_ERRORS_OFST),
1365 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1366 (int) readb(ti->srb + BURST_ERRORS_OFST),
1367 (int) readb(ti->srb + AC_ERRORS_OFST),
1368 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1369 (int) readb(ti->srb + LOST_FRAMES_OFST),
1370 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1371 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1372 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1373 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1374 #endif
1375 netif_wake_queue(dev);
1376 break;
1377 default:
1378 DPRINTK("Unknown command %02X encountered\n",
1379 (int) readb(ti->srb));
1380 } /* end switch SRB command check */
1381 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1382 } /* if SRB response */
1383 if (status & ASB_FREE_INT) { /* ASB response */
1384 SET_PAGE(ti->asb_page);
1385 #if TR_VERBOSE
1386 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1387 #endif
1388
1389 switch (readb(ti->asb)) { /* ASB command check */
1390 case REC_DATA:
1391 case XMIT_UI_FRAME:
1392 case XMIT_DIR_FRAME:
1393 break;
1394 default:
1395 DPRINTK("unknown command in asb %02X\n",
1396 (int) readb(ti->asb));
1397 } /* switch ASB command check */
1398 if (readb(ti->asb + 2) != 0xff) /* checks ret_code */
1399 DPRINTK("ASB error %02X in cmd %02X\n",
1400 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1401 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1402 } /* if ASB response */
1403
1404 #define STATUS_OFST 6
1405 #define NETW_STATUS_OFST 6
1406
1407 if (status & ARB_CMD_INT) { /* ARB response */
1408 SET_PAGE(ti->arb_page);
1409 #if TR_VERBOSE
1410 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1411 #endif
1412
1413 switch (readb(ti->arb)) { /* ARB command check */
1414 case DLC_STATUS:
1415 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1416 ntohs(readw(ti->arb + STATUS_OFST)),
1417 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1418 break;
1419 case REC_DATA:
1420 tr_rx(dev);
1421 break;
1422 case RING_STAT_CHANGE:{
1423 unsigned short ring_status;
1424 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1425 if (ibmtr_debug_trace & TRC_INIT)
1426 DPRINTK("Ring Status Change...(0x%x)\n",
1427 ring_status);
1428 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1429 netif_stop_queue(dev);
1430 dev->flags &= ~IFF_RUNNING;/*not typical Linux*/
1431 DPRINTK("Remove received, or Auto-removal error"
1432 ", or Lobe fault\n");
1433 DPRINTK("We'll try to reopen the closed adapter"
1434 " after a %d second delay.\n",
1435 TR_RETRY_INTERVAL/HZ);
1436 /*I was confused: I saw the TR reopening but */
1437 /*forgot:with an RJ45 in an RJ45/ICS adapter */
1438 /*but adapter not in the ring, the TR will */
1439 /* open, and then soon close and come here. */
1440 ti->open_mode = AUTOMATIC;
1441 ti->open_status = CLOSED; /*12/2000 BMS*/
1442 ti->open_action = REOPEN;
1443 ibmtr_reset_timer(&(ti->tr_timer), dev);
1444 } else if (ring_status & LOG_OVERFLOW) {
1445 if(netif_queue_stopped(dev))
1446 ti->readlog_pending = 1;
1447 else
1448 ibmtr_readlog(dev);
1449 }
1450 break;
1451 }
1452 case XMIT_DATA_REQ:
1453 tr_tx(dev);
1454 break;
1455 default:
1456 DPRINTK("Unknown command %02X in arb\n",
1457 (int) readb(ti->arb));
1458 break;
1459 } /* switch ARB command check */
1460 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1461 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1462 } /* if ARB response */
1463 if (status & SSB_RESP_INT) { /* SSB response */
1464 unsigned char retcode;
1465 SET_PAGE(ti->ssb_page);
1466 #if TR_VERBOSE
1467 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1468 readb(ti->ssb), readb(ti->ssb + 2));
1469 #endif
1470
1471 switch (readb(ti->ssb)) { /* SSB command check */
1472 case XMIT_DIR_FRAME:
1473 case XMIT_UI_FRAME:
1474 retcode = readb(ti->ssb + 2);
1475 if (retcode && (retcode != 0x22))/* checks ret_code */
1476 DPRINTK("xmit ret_code: %02X xmit error code: "
1477 "%02X\n",
1478 (int)retcode, (int)readb(ti->ssb + 6));
1479 else
1480 ti->tr_stats.tx_packets++;
1481 break;
1482 case XMIT_XID_CMD:
1483 DPRINTK("xmit xid ret_code: %02X\n",
1484 (int) readb(ti->ssb + 2));
1485 default:
1486 DPRINTK("Unknown command %02X in ssb\n",
1487 (int) readb(ti->ssb));
1488 } /* SSB command check */
1489 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1490 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1491 } /* if SSB response */
1492 #ifdef ENABLE_PAGING
1493 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1494 #endif
1495 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1496 spin_unlock(&(ti->lock));
1497 return IRQ_HANDLED;
1498 } /*tok_interrupt */
1499
1500 /*****************************************************************************/
1501
1502 #define INIT_STATUS_OFST 1
1503 #define INIT_STATUS_2_OFST 2
1504 #define ENCODED_ADDRESS_OFST 8
1505
1506 static void initial_tok_int(struct net_device *dev)
1507 {
1508
1509 __u32 encoded_addr, hw_encoded_addr;
1510 struct tok_info *ti;
1511 unsigned char init_status; /*BMS 12/2000*/
1512
1513 ti = (struct tok_info *) dev->priv;
1514
1515 ti->do_tok_int = NOT_FIRST;
1516
1517 /* we assign the shared-ram address for ISA devices */
1518 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1519 #ifndef PCMCIA
1520 ti->sram_virt = ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1521 #endif
1522 ti->init_srb = map_address(ti,
1523 ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN)),
1524 &ti->init_srb_page);
1525 if (ti->page_mask && ti->avail_shared_ram == 127) {
1526 void __iomem *last_512;
1527 __u8 last_512_page=0;
1528 int i;
1529 last_512 = map_address(ti, 0xfe00, &last_512_page);
1530 /* initialize high section of ram (if necessary) */
1531 SET_PAGE(last_512_page);
1532 for (i = 0; i < 512; i++)
1533 writeb(0, last_512 + i);
1534 }
1535 SET_PAGE(ti->init_srb_page);
1536
1537 #if TR_VERBOSE
1538 {
1539 int i;
1540
1541 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1542 DPRINTK("init_srb(%p):", ti->init_srb );
1543 for (i = 0; i < 20; i++)
1544 printk("%02X ", (int) readb(ti->init_srb + i));
1545 printk("\n");
1546 }
1547 #endif
1548
1549 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1550 encoded_addr = ntohs(hw_encoded_addr);
1551 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1552 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1553 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1554 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1555 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1556 ti->ring_speed, (unsigned int)dev->mem_start);
1557 ti->auto_speedsave=readb(ti->init_srb+INIT_STATUS_2_OFST)&4?TRUE:FALSE;
1558
1559 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1560 else tok_open_adapter((unsigned long)dev);
1561
1562 } /*initial_tok_int() */
1563
1564 /*****************************************************************************/
1565
1566 #define CMD_CORRELATE_OFST 1
1567 #define DHB_ADDRESS_OFST 6
1568
1569 #define FRAME_LENGTH_OFST 6
1570 #define HEADER_LENGTH_OFST 8
1571 #define RSAP_VALUE_OFST 9
1572
1573 static void tr_tx(struct net_device *dev)
1574 {
1575 struct tok_info *ti = (struct tok_info *) dev->priv;
1576 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1577 unsigned int hdr_len;
1578 __u32 dhb=0,dhb_base;
1579 void __iomem *dhbuf = NULL;
1580 unsigned char xmit_command;
1581 int i,dhb_len=0x4000,src_len,src_offset;
1582 struct trllc *llc;
1583 struct srb_xmit xsrb;
1584 __u8 dhb_page = 0;
1585 __u8 llc_ssap;
1586
1587 SET_PAGE(ti->asb_page);
1588
1589 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1590
1591 /* in providing the transmit interrupts, is telling us it is ready for
1592 data and providing a shared memory address for us to stuff with data.
1593 Here we compute the effective address where we will place data.
1594 */
1595 SET_PAGE(ti->arb_page);
1596 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1597 if (ti->page_mask) {
1598 dhb_page = (dhb_base >> 8) & ti->page_mask;
1599 dhb=dhb_base & ~(ti->page_mask << 8);
1600 }
1601 dhbuf = ti->sram_virt + dhb;
1602
1603 /* Figure out the size of the 802.5 header */
1604 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1605 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1606 else
1607 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1608 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1609
1610 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1611
1612 llc_ssap = llc->ssap;
1613 SET_PAGE(ti->srb_page);
1614 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1615 SET_PAGE(ti->asb_page);
1616 xmit_command = xsrb.command;
1617
1618 writeb(xmit_command, ti->asb + COMMAND_OFST);
1619 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1620 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1621 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1622 writeb(0, ti->asb + RETCODE_OFST);
1623 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1624 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1625 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1626 SET_PAGE(dhb_page);
1627 writeb(AC, dhbuf);
1628 writeb(LLC_FRAME, dhbuf + 1);
1629 for (i = 0; i < TR_ALEN; i++)
1630 writeb((int) 0x0FF, dhbuf + i + 2);
1631 for (i = 0; i < TR_ALEN; i++)
1632 writeb(0, dhbuf + i + TR_ALEN + 2);
1633 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1634 return;
1635 }
1636 /*
1637 * the token ring packet is copied from sk_buff to the adapter
1638 * buffer identified in the command data received with the interrupt.
1639 */
1640 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1641 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1642 src_len=ti->current_skb->len;
1643 src_offset=0;
1644 dhb=dhb_base;
1645 while(1) {
1646 if (ti->page_mask) {
1647 dhb_page=(dhb >> 8) & ti->page_mask;
1648 dhb=dhb & ~(ti->page_mask << 8);
1649 dhb_len=0x4000-dhb; /* remaining size of this page */
1650 }
1651 dhbuf = ti->sram_virt + dhb;
1652 SET_PAGE(dhb_page);
1653 if (src_len > dhb_len) {
1654 memcpy_toio(dhbuf,&ti->current_skb->data[src_offset],
1655 dhb_len);
1656 src_len -= dhb_len;
1657 src_offset += dhb_len;
1658 dhb_base+=dhb_len;
1659 dhb=dhb_base;
1660 continue;
1661 }
1662 memcpy_toio(dhbuf, &ti->current_skb->data[src_offset], src_len);
1663 break;
1664 }
1665 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1666 ti->tr_stats.tx_bytes += ti->current_skb->len;
1667 dev_kfree_skb_irq(ti->current_skb);
1668 ti->current_skb = NULL;
1669 netif_wake_queue(dev);
1670 if (ti->readlog_pending)
1671 ibmtr_readlog(dev);
1672 } /*tr_tx */
1673
1674 /*****************************************************************************/
1675
1676
1677 #define RECEIVE_BUFFER_OFST 6
1678 #define LAN_HDR_LENGTH_OFST 8
1679 #define DLC_HDR_LENGTH_OFST 9
1680
1681 #define DSAP_OFST 0
1682 #define SSAP_OFST 1
1683 #define LLC_OFST 2
1684 #define PROTID_OFST 3
1685 #define ETHERTYPE_OFST 6
1686
1687 static void tr_rx(struct net_device *dev)
1688 {
1689 struct tok_info *ti = (struct tok_info *) dev->priv;
1690 __u32 rbuffer;
1691 void __iomem *rbuf, *rbufdata, *llc;
1692 __u8 rbuffer_page = 0;
1693 unsigned char *data;
1694 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1695 unsigned char dlc_hdr_len;
1696 struct sk_buff *skb;
1697 unsigned int skb_size = 0;
1698 int IPv4_p = 0;
1699 unsigned int chksum = 0;
1700 struct iphdr *iph;
1701 struct arb_rec_req rarb;
1702
1703 SET_PAGE(ti->arb_page);
1704 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1705 rbuffer = ntohs(rarb.rec_buf_addr) ;
1706 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1707
1708 SET_PAGE(ti->asb_page);
1709
1710 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1711
1712 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1713 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1714 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1715
1716 lan_hdr_len = rarb.lan_hdr_len;
1717 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1718 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1719 return;
1720 } /*BMS I added this above just to be very safe */
1721 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1722 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1723
1724 SET_PAGE(rbuffer_page);
1725 llc = rbuf + offsetof(struct rec_buf, data) + lan_hdr_len;
1726
1727 #if TR_VERBOSE
1728 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1729 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1730 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1731 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1732 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1733 "ethertype: %04X\n",
1734 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1735 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1736 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1737 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1738 #endif
1739 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1740 SET_PAGE(ti->asb_page);
1741 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1742 ti->tr_stats.rx_dropped++;
1743 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1744 return;
1745 }
1746 length = ntohs(rarb.frame_len);
1747 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1748 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1749 length >= hdr_len) IPv4_p = 1;
1750 #if TR_VERBOSE
1751 #define SADDR_OFST 8
1752 #define DADDR_OFST 2
1753
1754 if (!IPv4_p) {
1755
1756 void __iomem *trhhdr = rbuf + offsetof(struct rec_buf, data);
1757
1758 DPRINTK("Probably non-IP frame received.\n");
1759 DPRINTK("ssap: %02X dsap: %02X "
1760 "saddr: %02X:%02X:%02X:%02X:%02X:%02X "
1761 "daddr: %02X:%02X:%02X:%02X:%02X:%02X\n",
1762 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1763 readb(trhhdr+SADDR_OFST), readb(trhhdr+ SADDR_OFST+1),
1764 readb(trhhdr+SADDR_OFST+2), readb(trhhdr+SADDR_OFST+3),
1765 readb(trhhdr+SADDR_OFST+4), readb(trhhdr+SADDR_OFST+5),
1766 readb(trhhdr+DADDR_OFST), readb(trhhdr+DADDR_OFST + 1),
1767 readb(trhhdr+DADDR_OFST+2), readb(trhhdr+DADDR_OFST+3),
1768 readb(trhhdr+DADDR_OFST+4), readb(trhhdr+DADDR_OFST+5));
1769 }
1770 #endif
1771
1772 /*BMS handle the case she comes in with few hops but leaves with many */
1773 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1774
1775 if (!(skb = dev_alloc_skb(skb_size))) {
1776 DPRINTK("out of memory. frame dropped.\n");
1777 ti->tr_stats.rx_dropped++;
1778 SET_PAGE(ti->asb_page);
1779 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1780 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1781 return;
1782 }
1783 /*BMS again, if she comes in with few but leaves with many */
1784 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1785 skb_put(skb, length);
1786 skb->dev = dev;
1787 data = skb->data;
1788 rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len)));
1789 rbufdata = rbuf + offsetof(struct rec_buf, data);
1790
1791 if (IPv4_p) {
1792 /* Copy the headers without checksumming */
1793 memcpy_fromio(data, rbufdata, hdr_len);
1794
1795 /* Watch for padded packets and bogons */
1796 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1797 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1798 length -= hdr_len;
1799 if ((ip_len <= length) && (ip_len > 7))
1800 length = ip_len;
1801 data += hdr_len;
1802 rbuffer_len -= hdr_len;
1803 rbufdata += hdr_len;
1804 }
1805 /* Copy the payload... */
1806 #define BUFFER_POINTER_OFST 2
1807 #define BUFFER_LENGTH_OFST 6
1808 for (;;) {
1809 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1810 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1811 length,rbuffer_len);
1812 if (IPv4_p)
1813 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1814 data,length<rbuffer_len?length:rbuffer_len,chksum);
1815 else
1816 memcpy_fromio(data, rbufdata, rbuffer_len);
1817 rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ;
1818 if (!rbuffer)
1819 break;
1820 rbuffer -= 2;
1821 length -= rbuffer_len;
1822 data += rbuffer_len;
1823 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1824 SET_PAGE(rbuffer_page);
1825 rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST));
1826 rbufdata = rbuf + offsetof(struct rec_buf, data);
1827 }
1828
1829 SET_PAGE(ti->asb_page);
1830 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1831
1832 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1833
1834 ti->tr_stats.rx_bytes += skb->len;
1835 ti->tr_stats.rx_packets++;
1836
1837 skb->protocol = tr_type_trans(skb, dev);
1838 if (IPv4_p) {
1839 skb->csum = chksum;
1840 skb->ip_summed = 1;
1841 }
1842 netif_rx(skb);
1843 dev->last_rx = jiffies;
1844 } /*tr_rx */
1845
1846 /*****************************************************************************/
1847
1848 void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1849 {
1850 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1851 tmr->data = (unsigned long) dev;
1852 tmr->function = tok_rerun;
1853 init_timer(tmr);
1854 add_timer(tmr);
1855 }
1856
1857 /*****************************************************************************/
1858
1859 void tok_rerun(unsigned long dev_addr){
1860
1861 struct net_device *dev = (struct net_device *)dev_addr;
1862 struct tok_info *ti = (struct tok_info *) dev->priv;
1863
1864 if ( ti->open_action == RESTART){
1865 ti->do_tok_int = FIRST_INT;
1866 outb(0, dev->base_addr + ADAPTRESETREL);
1867 #ifdef ENABLE_PAGING
1868 if (ti->page_mask)
1869 writeb(SRPR_ENABLE_PAGING,
1870 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1871 #endif
1872
1873 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1874 } else
1875 tok_open_adapter(dev_addr);
1876 }
1877
1878 /*****************************************************************************/
1879
1880 void ibmtr_readlog(struct net_device *dev)
1881 {
1882 struct tok_info *ti;
1883
1884 ti = (struct tok_info *) dev->priv;
1885
1886 ti->readlog_pending = 0;
1887 SET_PAGE(ti->srb_page);
1888 writeb(DIR_READ_LOG, ti->srb);
1889 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1890 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1891
1892 netif_stop_queue(dev);
1893
1894 }
1895
1896 /*****************************************************************************/
1897
1898 /* tok_get_stats(): Basically a scaffold routine which will return
1899 the address of the tr_statistics structure associated with
1900 this device -- the tr.... structure is an ethnet look-alike
1901 so at least for this iteration may suffice. */
1902
1903 static struct net_device_stats *tok_get_stats(struct net_device *dev)
1904 {
1905
1906 struct tok_info *toki;
1907 toki = (struct tok_info *) dev->priv;
1908 return (struct net_device_stats *) &toki->tr_stats;
1909 }
1910
1911 /*****************************************************************************/
1912
1913 int ibmtr_change_mtu(struct net_device *dev, int mtu)
1914 {
1915 struct tok_info *ti = (struct tok_info *) dev->priv;
1916
1917 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1918 return -EINVAL;
1919 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1920 return -EINVAL;
1921 dev->mtu = mtu;
1922 return 0;
1923 }
1924
1925 /*****************************************************************************/
1926 #ifdef MODULE
1927
1928 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1929 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1930 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1931 static int irq[IBMTR_MAX_ADAPTERS];
1932 static int mem[IBMTR_MAX_ADAPTERS];
1933
1934 MODULE_LICENSE("GPL");
1935
1936 module_param_array(io, int, NULL, 0);
1937 module_param_array(irq, int, NULL, 0);
1938 module_param_array(mem, int, NULL, 0);
1939
1940 static int __init ibmtr_init(void)
1941 {
1942 int i;
1943 int count=0;
1944
1945 find_turbo_adapters(io);
1946
1947 for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) {
1948 struct net_device *dev;
1949 irq[i] = 0;
1950 mem[i] = 0;
1951 dev = alloc_trdev(sizeof(struct tok_info));
1952 if (dev == NULL) {
1953 if (i == 0)
1954 return -ENOMEM;
1955 break;
1956 }
1957 dev->base_addr = io[i];
1958 dev->irq = irq[i];
1959 dev->mem_start = mem[i];
1960
1961 if (ibmtr_probe_card(dev)) {
1962 free_netdev(dev);
1963 continue;
1964 }
1965 dev_ibmtr[i] = dev;
1966 count++;
1967 }
1968 if (count) return 0;
1969 printk("ibmtr: register_netdev() returned non-zero.\n");
1970 return -EIO;
1971 }
1972 module_init(ibmtr_init);
1973
1974 static void __exit ibmtr_cleanup(void)
1975 {
1976 int i;
1977
1978 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1979 if (!dev_ibmtr[i])
1980 continue;
1981 unregister_netdev(dev_ibmtr[i]);
1982 ibmtr_cleanup_card(dev_ibmtr[i]);
1983 free_netdev(dev_ibmtr[i]);
1984 }
1985 }
1986 module_exit(ibmtr_cleanup);
1987 #endif
Verdex Pro support