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 * 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 int ram_addr;
244 int index=0;
245 void *chanid;
246 int found_turbo=0;
247 unsigned char *tchanid, ctemp;
248 int i, j;
249 unsigned long jif;
250 void *ram_mapped ;
251
252 if (turbo_searched == 1) return;
253 turbo_searched=1;
254 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
255
256 __u32 intf_tbl=0;
257
258 found_turbo=1;
259 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
260 if (ram_mapped==NULL)
261 continue ;
262 chanid=(CHANNEL_ID + ram_mapped);
263 tchanid=pcchannelid;
264 ctemp=readb(chanid) & 0x0f;
265 if (ctemp != *tchanid) continue;
266 for (i=2,j=1; i<=46; i=i+2,j++) {
267 if ((readb(chanid+i) & 0x0f) != tchanid[j]){
268 found_turbo=0;
269 break;
270 }
271 }
272 if (!found_turbo) continue;
273
274 writeb(0x90, ram_mapped+0x1E01);
275 for(i=2; i<0x0f; i++) {
276 writeb(0x00, ram_mapped+0x1E01+i);
277 }
278 writeb(0x00, ram_mapped+0x1E01);
279 for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif););
280 intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN));
281 if (intf_tbl) {
282 #if IBMTR_DEBUG_MESSAGES
283 printk("ibmtr::find_turbo_adapters, Turbo found at "
284 "ram_addr %x\n",ram_addr);
285 printk("ibmtr::find_turbo_adapters, interface_table ");
286 for(i=0; i<6; i++) {
287 printk("%x:",readb(ram_addr+intf_tbl+i));
288 }
289 printk("\n");
290 #endif
291 turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4));
292 turbo_irq[index]=readb(ram_mapped+intf_tbl+3);
293 outb(0, turbo_io[index] + ADAPTRESET);
294 for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif););
295 outb(0, turbo_io[index] + ADAPTRESETREL);
296 index++;
297 continue;
298 }
299 #if IBMTR_DEBUG_MESSAGES
300 printk("ibmtr::find_turbo_adapters, ibmtr card found at"
301 " %x but not a Turbo model\n",ram_addr);
302 #endif
303 iounmap(ram_mapped) ;
304 } /* for */
305 for(i=0; i<IBMTR_MAX_ADAPTERS; i++) {
306 if(!turbo_io[i]) break;
307 for (j=0; j<IBMTR_MAX_ADAPTERS; j++) {
308 if ( iolist[j] && iolist[j] != turbo_io[i]) continue;
309 iolist[j]=turbo_io[i];
310 break;
311 }
312 }
313 }
314
315 static void ibmtr_cleanup_card(struct net_device *dev)
316 {
317 if (dev->base_addr) {
318 outb(0,dev->base_addr+ADAPTRESET);
319
320 schedule_timeout(TR_RST_TIME); /* wait 50ms */
321
322 outb(0,dev->base_addr+ADAPTRESETREL);
323 }
324
325 #ifndef PCMCIA
326 free_irq(dev->irq, dev);
327 release_region(dev->base_addr, IBMTR_IO_EXTENT);
328
329 {
330 struct tok_info *ti = (struct tok_info *) dev->priv;
331 iounmap((u32 *)ti->mmio);
332 iounmap((u32 *)ti->sram_virt);
333 }
334 #endif
335 }
336
337 int ibmtr_probe_card(struct net_device *dev)
338 {
339 int err = ibmtr_probe(dev);
340 if (!err) {
341 err = register_netdev(dev);
342 if (err)
343 ibmtr_cleanup_card(dev);
344 }
345 return err;
346 }
347
348 /****************************************************************************
349 * ibmtr_probe(): Routine specified in the network device structure
350 * to probe for an IBM Token Ring Adapter. Routine outline:
351 * I. Interrogate hardware to determine if an adapter exists
352 * and what the speeds and feeds are
353 * II. Setup data structures to control execution based upon
354 * adapter characteristics.
355 *
356 * We expect ibmtr_probe to be called once for each device entry
357 * which references it.
358 ****************************************************************************/
359
360 static int ibmtr_probe(struct net_device *dev)
361 {
362 int i;
363 int base_addr = dev->base_addr;
364
365 if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */
366 return -ENXIO;
367 if (base_addr > 0x1ff) { /* Check a single specified location. */
368 if (!ibmtr_probe1(dev, base_addr)) return 0;
369 return -ENODEV;
370 }
371 find_turbo_adapters(ibmtr_portlist);
372 for (i = 0; ibmtr_portlist[i]; i++) {
373 int ioaddr = ibmtr_portlist[i];
374
375 if (!ibmtr_probe1(dev, ioaddr)) return 0;
376 }
377 return -ENODEV;
378 }
379
380 /*****************************************************************************/
381
382 static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
383 {
384
385 unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0;
386 void * t_mmio = NULL;
387 struct tok_info *ti = dev->priv;
388 void *cd_chanid;
389 unsigned char *tchanid, ctemp;
390 #ifndef PCMCIA
391 unsigned char t_irq=0;
392 unsigned long timeout;
393 static int version_printed;
394 #endif
395
396 /* Query the adapter PIO base port which will return
397 * indication of where MMIO was placed. We also have a
398 * coded interrupt number.
399 */
400 segment = inb(PIOaddr);
401 if (segment < 0x40 || segment > 0xe0) {
402 /* Out of range values so we'll assume non-existent IO device
403 * but this is not necessarily a problem, esp if a turbo
404 * adapter is being used. */
405 #if IBMTR_DEBUG_MESSAGES
406 DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, "
407 "Hardware Problem?\n",PIOaddr,segment);
408 #endif
409 return -ENODEV;
410 }
411 /*
412 * Compute the linear base address of the MMIO area
413 * as LINUX doesn't care about segments
414 */
415 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
416 if (!t_mmio) {
417 DPRINTK("Cannot remap mmiobase memory area") ;
418 return -ENODEV ;
419 }
420 intr = segment & 0x03; /* low bits is coded interrupt # */
421 if (ibmtr_debug_trace & TRC_INIT)
422 DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n"
423 , PIOaddr, (int) segment, t_mmio, (int) intr);
424
425 /*
426 * Now we will compare expected 'channelid' strings with
427 * what we is there to learn of ISA/MCA or not TR card
428 */
429 #ifdef PCMCIA
430 iounmap(t_mmio);
431 t_mmio = (void *)ti->mmio; /*BMS to get virtual address */
432 irq = ti->irq; /*BMS to display the irq! */
433 #endif
434 cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */
435 tchanid = pcchannelid;
436 cardpresent = TR_ISA; /* try ISA */
437
438 /* Suboptimize knowing first byte different */
439 ctemp = readb(cd_chanid) & 0x0f;
440 if (ctemp != *tchanid) { /* NOT ISA card, try MCA */
441 tchanid = mcchannelid;
442 cardpresent = TR_MCA;
443 if (ctemp != *tchanid) /* Neither ISA nor MCA */
444 cardpresent = NOTOK;
445 }
446 if (cardpresent != NOTOK) {
447 /* Know presumed type, try rest of ID */
448 for (i = 2, j = 1; i <= 46; i = i + 2, j++) {
449 if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue;
450 /* match failed, not TR card */
451 cardpresent = NOTOK;
452 break;
453 }
454 }
455 /*
456 * If we have an ISA board check for the ISA P&P version,
457 * as it has different IRQ settings
458 */
459 if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e))
460 cardpresent = TR_ISAPNP;
461 if (cardpresent == NOTOK) { /* "channel_id" did not match, report */
462 if (!(ibmtr_debug_trace & TRC_INIT)) {
463 #ifndef PCMCIA
464 iounmap(t_mmio);
465 #endif
466 return -ENODEV;
467 }
468 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
469 PIOaddr);
470 DPRINTK("Expected for ISA: ");
471 PrtChanID(pcchannelid, 1);
472 DPRINTK(" found: ");
473 /* BMS Note that this can be misleading, when hardware is flaky, because you
474 are reading it a second time here. So with my flaky hardware, I'll see my-
475 self in this block, with the HW ID matching the ISA ID exactly! */
476 HWPrtChanID(cd_chanid, 2);
477 DPRINTK("Expected for MCA: ");
478 PrtChanID(mcchannelid, 1);
479 }
480 /* Now, setup some of the pl0 buffers for this driver.. */
481 /* If called from PCMCIA, it is already set up, so no need to
482 waste the memory, just use the existing structure */
483 #ifndef PCMCIA
484 ti->mmio = t_mmio;
485 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
486 if (turbo_io[i] != PIOaddr)
487 continue;
488 #if IBMTR_DEBUG_MESSAGES
489 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
490 PIOaddr);
491 #endif
492 ti->turbo = 1;
493 t_irq = turbo_irq[i];
494 }
495 #endif /* !PCMCIA */
496 ti->readlog_pending = 0;
497 init_waitqueue_head(&ti->wait_for_reset);
498
499 /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP
500 * depending which card is inserted. */
501
502 #ifndef PCMCIA
503 switch (cardpresent) {
504 case TR_ISA:
505 if (intr == 0) irq = 9; /* irq2 really is irq9 */
506 if (intr == 1) irq = 3;
507 if (intr == 2) irq = 6;
508 if (intr == 3) irq = 7;
509 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
510 break;
511 case TR_MCA:
512 if (intr == 0) irq = 9;
513 if (intr == 1) irq = 3;
514 if (intr == 2) irq = 10;
515 if (intr == 3) irq = 11;
516 ti->global_int_enable = 0;
517 ti->adapter_int_enable = 0;
518 ti->sram_virt=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12;
519 break;
520 case TR_ISAPNP:
521 if (!t_irq) {
522 if (intr == 0) irq = 9;
523 if (intr == 1) irq = 3;
524 if (intr == 2) irq = 10;
525 if (intr == 3) irq = 11;
526 } else
527 irq=t_irq;
528 timeout = jiffies + TR_SPIN_INTERVAL;
529 while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){
530 if (!time_after(jiffies, timeout)) continue;
531 DPRINTK( "Hardware timeout during initialization.\n");
532 iounmap(t_mmio);
533 kfree(ti);
534 return -ENODEV;
535 }
536 ti->sram_virt =
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_virt=0x%x", ti->sram_virt);
546 if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */
547 DPRINTK(", ti->mmio=%p", ti->mmio);
548 printk(", segment=%02X", segment);
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 kfree(ti);
648 return -ENODEV;
649 break;
650 } /*end switch shared_ram_paging */
651
652 if (ibmtr_debug_trace & TRC_INIT)
653 DPRINTK("Shared RAM paging code: %02X, "
654 "mapped RAM size: %dK, shared RAM size: %dK, "
655 "page mask: %02X\n:",
656 ti->shared_ram_paging, ti->mapped_ram_size / 2,
657 ti->avail_shared_ram / 2, ti->page_mask);
658 #endif /*ENABLE_PAGING */
659 }
660
661 #ifndef PCMCIA
662 /* finish figuring the shared RAM address */
663 if (cardpresent == TR_ISA) {
664 static __u32 ram_bndry_mask[] =
665 { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 };
666 __u32 new_base, rrr_32, chk_base, rbm;
667
668 rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03;
669 rbm = ram_bndry_mask[rrr_32];
670 new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */
671 chk_base = new_base + (ti->mapped_ram_size << 9);
672 if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) {
673 DPRINTK("Shared RAM for this adapter (%05x) exceeds "
674 "driver limit (%05x), adapter not started.\n",
675 chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
676 iounmap(t_mmio);
677 kfree(ti);
678 return -ENODEV;
679 } else { /* seems cool, record what we have figured out */
680 ti->sram_base = new_base >> 12;
681 ibmtr_mem_base = chk_base;
682 }
683 }
684 else ti->sram_base = ti->sram_virt >> 12;
685
686 /* The PCMCIA has already got the interrupt line and the io port,
687 so no chance of anybody else getting it - MLP */
688 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
689 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
690 irq);
691 iounmap(t_mmio);
692 kfree(ti);
693 return -ENODEV;
694 }
695 /*?? Now, allocate some of the PIO PORTs for this driver.. */
696 /* record PIOaddr range as busy */
697 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
698 DPRINTK("Could not grab PIO range. Halting driver.\n");
699 free_irq(dev->irq, dev);
700 iounmap(t_mmio);
701 kfree(ti);
702 return -EBUSY;
703 }
704
705 if (!version_printed++) {
706 printk(version);
707 }
708 #endif /* !PCMCIA */
709 DPRINTK("%s %s found\n",
710 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
711 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
712 irq, PIOaddr, ti->mapped_ram_size / 2);
713 DPRINTK("Hardware address : %02X:%02X:%02X:%02X:%02X:%02X\n",
714 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
715 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
716 if (ti->page_mask)
717 DPRINTK("Shared RAM paging enabled. "
718 "Page size: %uK Shared Ram size %dK\n",
719 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
720 else
721 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
722 ti->page_mask);
723
724 /* Calculate the maximum DHB we can use */
725 /* two cases where avail_shared_ram doesn't equal mapped_ram_size:
726 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical)
727 2. user has configured adapter for less than avail_shared_ram
728 but is not using paging (she should use paging, I believe)
729 */
730 if (!ti->page_mask) {
731 ti->avail_shared_ram=
732 min(ti->mapped_ram_size,ti->avail_shared_ram);
733 }
734
735 switch (ti->avail_shared_ram) {
736 case 16: /* 8KB shared RAM */
737 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
738 ti->rbuf_len4 = 1032;
739 ti->rbuf_cnt4=2;
740 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
741 ti->rbuf_len16 = 1032;
742 ti->rbuf_cnt16=2;
743 break;
744 case 32: /* 16KB shared RAM */
745 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
746 ti->rbuf_len4 = 1032;
747 ti->rbuf_cnt4=4;
748 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
749 ti->rbuf_len16 = 1032; /*1024 usable */
750 ti->rbuf_cnt16=4;
751 break;
752 case 64: /* 32KB shared RAM */
753 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
754 ti->rbuf_len4 = 1032;
755 ti->rbuf_cnt4=6;
756 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
757 ti->rbuf_len16 = 1032;
758 ti->rbuf_cnt16=6;
759 break;
760 case 127: /* 63.5KB shared RAM */
761 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
762 ti->rbuf_len4 = 1032;
763 ti->rbuf_cnt4=6;
764 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
765 ti->rbuf_len16 = 1032;
766 ti->rbuf_cnt16=16;
767 break;
768 case 128: /* 64KB shared RAM */
769 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
770 ti->rbuf_len4 = 1032;
771 ti->rbuf_cnt4=6;
772 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
773 ti->rbuf_len16 = 1032;
774 ti->rbuf_cnt16=16;
775 break;
776 default:
777 ti->dhb_size4mb = 2048;
778 ti->rbuf_len4 = 1032;
779 ti->rbuf_cnt4=2;
780 ti->dhb_size16mb = 2048;
781 ti->rbuf_len16 = 1032;
782 ti->rbuf_cnt16=2;
783 break;
784 }
785 /* this formula is not smart enough for the paging case
786 ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE -
787 ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH -
788 DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB -
789 SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>;
790 */
791 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
792 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
793 /*BMS assuming 18 bytes of Routing Information (usually works) */
794 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
795 ti->maxmtu16, ti->maxmtu4);
796
797 dev->base_addr = PIOaddr; /* set the value for device */
798 dev->mem_start = ti->sram_base << 12;
799 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
800 trdev_init(dev);
801 return 0; /* Return 0 to indicate we have found a Token Ring card. */
802 } /*ibmtr_probe1() */
803
804 /*****************************************************************************/
805
806 /* query the adapter for the size of shared RAM */
807 /* the function returns the RAM size in units of 512 bytes */
808
809 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
810 {
811 unsigned char avail_sram_code;
812 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
813 /* Adapter gives
814 'F' -- use RRR bits 3,2
815 'E' -- 8kb 'D' -- 16kb
816 'C' -- 32kb 'A' -- 64KB
817 'B' - 64KB less 512 bytes at top
818 (WARNING ... must zero top bytes in INIT */
819
820 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
821 if (avail_sram_code) return size_code[avail_sram_code];
822 else /* for code 'F', must compute size from RRR(3,2) bits */
823 return 1 <<
824 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
825 }
826
827 /*****************************************************************************/
828
829 static int __devinit trdev_init(struct net_device *dev)
830 {
831 struct tok_info *ti = (struct tok_info *) dev->priv;
832
833 SET_PAGE(ti->srb_page);
834 ti->open_failure = NO ;
835 dev->open = tok_open;
836 dev->stop = tok_close;
837 dev->hard_start_xmit = tok_send_packet;
838 dev->get_stats = tok_get_stats;
839 dev->set_multicast_list = tok_set_multicast_list;
840 dev->change_mtu = ibmtr_change_mtu;
841
842 return 0;
843 }
844
845 /*****************************************************************************/
846
847 static int tok_init_card(struct net_device *dev)
848 {
849 struct tok_info *ti;
850 short PIOaddr;
851 unsigned long i;
852
853 PIOaddr = dev->base_addr;
854 ti = (struct tok_info *) dev->priv;
855 /* Special processing for first interrupt after reset */
856 ti->do_tok_int = FIRST_INT;
857 /* Reset adapter */
858 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
859 outb(0, PIOaddr + ADAPTRESET);
860
861 current->state=TASK_UNINTERRUPTIBLE;
862 schedule_timeout(TR_RST_TIME); /* wait 50ms */
863
864 outb(0, PIOaddr + ADAPTRESETREL);
865 #ifdef ENABLE_PAGING
866 if (ti->page_mask)
867 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
868 #endif
869 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
870 i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ);
871 return i? 0 : -EAGAIN;
872 }
873
874 /*****************************************************************************/
875 static int tok_open(struct net_device *dev)
876 {
877 struct tok_info *ti = (struct tok_info *) dev->priv;
878 int i;
879
880 /*the case we were left in a failure state during a previous open */
881 if (ti->open_failure == YES) {
882 DPRINTK("Last time you were disconnected, how about now?\n");
883 printk("You can't insert with an ICS connector half-cocked.\n");
884 }
885
886 ti->open_status = CLOSED; /* CLOSED or OPEN */
887 ti->sap_status = CLOSED; /* CLOSED or OPEN */
888 ti->open_failure = NO; /* NO or YES */
889 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
890 /* 12/2000 not typical Linux, but we can use RUNNING to let us know when
891 the network has crapped out or cables are disconnected. Useful because
892 the IFF_UP flag stays up the whole time, until ifconfig tr0 down.
893 */
894 dev->flags &= ~IFF_RUNNING;
895
896 ti->sram_virt &= ~1; /* to reverse what we do in tok_close */
897 /* init the spinlock */
898 spin_lock_init(&ti->lock);
899 init_timer(&ti->tr_timer);
900
901 i = tok_init_card(dev);
902 if (i) return i;
903
904 while (1){
905 tok_open_adapter((unsigned long) dev);
906 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
907 /* sig catch: estimate opening adapter takes more than .5 sec*/
908 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
909 if (i==0) break;
910 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
911 netif_start_queue(dev);
912 DPRINTK("Adapter is up and running\n");
913 return 0;
914 }
915 current->state=TASK_INTERRUPTIBLE;
916 i=schedule_timeout(TR_RETRY_INTERVAL); /* wait 30 seconds */
917 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
918 }
919 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
920 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
921 return -EAGAIN;
922 }
923
924 /*****************************************************************************/
925
926 #define COMMAND_OFST 0
927 #define OPEN_OPTIONS_OFST 8
928 #define NUM_RCV_BUF_OFST 24
929 #define RCV_BUF_LEN_OFST 26
930 #define DHB_LENGTH_OFST 28
931 #define NUM_DHB_OFST 30
932 #define DLC_MAX_SAP_OFST 32
933 #define DLC_MAX_STA_OFST 33
934
935 void tok_open_adapter(unsigned long dev_addr)
936 {
937 struct net_device *dev = (struct net_device *) dev_addr;
938 struct tok_info *ti;
939 int i;
940
941 ti = (struct tok_info *) dev->priv;
942 SET_PAGE(ti->init_srb_page);
943 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
944 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
945 writeb(0, ti->init_srb + i);
946 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
947 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
948 if (ti->ring_speed == 16) {
949 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
950 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
951 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
952 } else {
953 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
954 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
955 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
956 }
957 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
958 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
959 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
960 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
961 ti->srb_page = ti->init_srb_page;
962 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
963 readb(ti->init_srb + NUM_DHB_OFST),
964 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
965 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
966 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
967 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
968 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
969 }
970
971 /*****************************************************************************/
972
973 static void open_sap(unsigned char type, struct net_device *dev)
974 {
975 int i;
976 struct tok_info *ti = (struct tok_info *) dev->priv;
977
978 SET_PAGE(ti->srb_page);
979 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
980 writeb(0, ti->srb + i);
981
982 #define MAX_I_FIELD_OFST 14
983 #define SAP_VALUE_OFST 16
984 #define SAP_OPTIONS_OFST 17
985 #define STATION_COUNT_OFST 18
986
987 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
988 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
989 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
990 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
991 writeb(type, ti->srb + SAP_VALUE_OFST);
992 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
993 }
994
995
996 /*****************************************************************************/
997
998 static void tok_set_multicast_list(struct net_device *dev)
999 {
1000 struct tok_info *ti = (struct tok_info *) dev->priv;
1001 struct dev_mc_list *mclist;
1002 unsigned char address[4];
1003
1004 int i;
1005
1006 /*BMS the next line is CRUCIAL or you may be sad when you */
1007 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
1008 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
1009 address[0] = address[1] = address[2] = address[3] = 0;
1010 mclist = dev->mc_list;
1011 for (i = 0; i < dev->mc_count; i++) {
1012 address[0] |= mclist->dmi_addr[2];
1013 address[1] |= mclist->dmi_addr[3];
1014 address[2] |= mclist->dmi_addr[4];
1015 address[3] |= mclist->dmi_addr[5];
1016 mclist = mclist->next;
1017 }
1018 SET_PAGE(ti->srb_page);
1019 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1020 writeb(0, ti->srb + i);
1021
1022 #define FUNCT_ADDRESS_OFST 6
1023
1024 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1025 for (i = 0; i < 4; i++)
1026 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1027 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1028 #if TR_VERBOSE
1029 DPRINTK("Setting functional address: ");
1030 for (i=0;i<4;i++) printk("%02X ", address[i]);
1031 printk("\n");
1032 #endif
1033 }
1034
1035 /*****************************************************************************/
1036
1037 #define STATION_ID_OFST 4
1038
1039 static int tok_send_packet(struct sk_buff *skb, struct net_device *dev)
1040 {
1041 struct tok_info *ti;
1042 unsigned long flags;
1043 ti = (struct tok_info *) dev->priv;
1044
1045 netif_stop_queue(dev);
1046
1047 /* lock against other CPUs */
1048 spin_lock_irqsave(&(ti->lock), flags);
1049
1050 /* Save skb; we'll need it when the adapter asks for the data */
1051 ti->current_skb = skb;
1052 SET_PAGE(ti->srb_page);
1053 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1054 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1055 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1056 spin_unlock_irqrestore(&(ti->lock), flags);
1057 dev->trans_start = jiffies;
1058 return 0;
1059 }
1060
1061 /*****************************************************************************/
1062
1063 static int tok_close(struct net_device *dev)
1064 {
1065 struct tok_info *ti = (struct tok_info *) dev->priv;
1066
1067 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1068 /* unloading the module from memory, and then if a timer pops, ouch */
1069 del_timer_sync(&ti->tr_timer);
1070 outb(0, dev->base_addr + ADAPTRESET);
1071 ti->sram_virt |= 1;
1072 ti->open_status = CLOSED;
1073
1074 netif_stop_queue(dev);
1075 DPRINTK("Adapter is closed.\n");
1076 return 0;
1077 }
1078
1079 /*****************************************************************************/
1080
1081 #define RETCODE_OFST 2
1082 #define OPEN_ERROR_CODE_OFST 6
1083 #define ASB_ADDRESS_OFST 8
1084 #define SRB_ADDRESS_OFST 10
1085 #define ARB_ADDRESS_OFST 12
1086 #define SSB_ADDRESS_OFST 14
1087
1088 static char *printphase[]= {"Lobe media test","Physical insertion",
1089 "Address verification","Roll call poll","Request Parameters"};
1090 static char *printerror[]={"Function failure","Signal loss","Reserved",
1091 "Frequency error","Timeout","Ring failure","Ring beaconing",
1092 "Duplicate node address",
1093 "Parameter request-retry count exceeded","Remove received",
1094 "IMPL force received","Duplicate modifier",
1095 "No monitor detected","Monitor contention failed for RPL"};
1096
1097 void dir_open_adapter (struct net_device *dev) {
1098
1099 struct tok_info *ti = (struct tok_info *) dev->priv;
1100 unsigned char ret_code;
1101 __u16 err;
1102
1103 ti->srb = ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST));
1104 ti->ssb = ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST));
1105 ti->arb = ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST));
1106 ti->asb = ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST));
1107 if (ti->page_mask) {
1108 ti->srb_page = (ti->srb >> 8) & ti->page_mask;
1109 ti->srb &= ~(ti->page_mask << 8);
1110 ti->ssb_page = (ti->ssb >> 8) & ti->page_mask;
1111 ti->ssb &= ~(ti->page_mask << 8);
1112 ti->arb_page = (ti->arb >> 8) & ti->page_mask;
1113 ti->arb &= ~(ti->page_mask << 8);
1114 ti->asb_page = (ti->asb >> 8) & ti->page_mask;
1115 ti->asb &= ~(ti->page_mask << 8);
1116 }
1117 ti->srb += ti->sram_virt;
1118 ti->ssb += ti->sram_virt;
1119 ti->arb += ti->sram_virt;
1120 ti->asb += ti->sram_virt;
1121 ti->current_skb = NULL;
1122 ret_code = readb(ti->init_srb + RETCODE_OFST);
1123 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1124 if (!ret_code) {
1125 ti->open_status = OPEN; /* TR adapter is now available */
1126 if (ti->open_mode == AUTOMATIC) {
1127 DPRINTK("Adapter reopened.\n");
1128 }
1129 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1130 open_sap(EXTENDED_SAP, dev);
1131 return;
1132 }
1133 ti->open_failure = YES;
1134 if (ret_code == 7){
1135 if (err == 0x24) {
1136 if (!ti->auto_speedsave) {
1137 DPRINTK("Open failed: Adapter speed must match "
1138 "ring speed if Automatic Ring Speed Save is "
1139 "disabled.\n");
1140 ti->open_action = FAIL;
1141 }else
1142 DPRINTK("Retrying open to adjust to "
1143 "ring speed, ");
1144 } else if (err == 0x2d) {
1145 DPRINTK("Physical Insertion: No Monitor Detected, ");
1146 printk("retrying after %ds delay...\n",
1147 TR_RETRY_INTERVAL/HZ);
1148 } else if (err == 0x11) {
1149 DPRINTK("Lobe Media Function Failure (0x11), ");
1150 printk(" retrying after %ds delay...\n",
1151 TR_RETRY_INTERVAL/HZ);
1152 } else {
1153 char **prphase = printphase;
1154 char **prerror = printerror;
1155 DPRINTK("TR Adapter misc open failure, error code = ");
1156 printk("0x%x, Phase: %s, Error: %s\n",
1157 err, prphase[err/16 -1], prerror[err%16 -1]);
1158 printk(" retrying after %ds delay...\n",
1159 TR_RETRY_INTERVAL/HZ);
1160 }
1161 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1162 if (ti->open_action != FAIL) {
1163 if (ti->open_mode==AUTOMATIC){
1164 ti->open_action = REOPEN;
1165 ibmtr_reset_timer(&(ti->tr_timer), dev);
1166 return;
1167 }
1168 wake_up(&ti->wait_for_reset);
1169 return;
1170 }
1171 DPRINTK("FAILURE, CAPUT\n");
1172 }
1173
1174 /******************************************************************************/
1175
1176 irqreturn_t tok_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1177 {
1178 unsigned char status;
1179 /* unsigned char status_even ; */
1180 struct tok_info *ti;
1181 struct net_device *dev;
1182 #ifdef ENABLE_PAGING
1183 unsigned char save_srpr;
1184 #endif
1185
1186 dev = dev_id;
1187 #if TR_VERBOSE
1188 DPRINTK("Int from tok_driver, dev : %p irq%d regs=%p\n", dev,irq,regs);
1189 #endif
1190 ti = (struct tok_info *) dev->priv;
1191 if (ti->sram_virt & 1)
1192 return IRQ_NONE; /* PCMCIA card extraction flag */
1193 spin_lock(&(ti->lock));
1194 #ifdef ENABLE_PAGING
1195 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1196 #endif
1197
1198 /* Disable interrupts till processing is finished */
1199 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1200
1201 /* Reset interrupt for ISA boards */
1202 if (ti->adapter_int_enable)
1203 outb(0, ti->adapter_int_enable);
1204 else /* used for PCMCIA cards */
1205 outb(0, ti->global_int_enable);
1206 if (ti->do_tok_int == FIRST_INT){
1207 initial_tok_int(dev);
1208 #ifdef ENABLE_PAGING
1209 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1210 #endif
1211 spin_unlock(&(ti->lock));
1212 return IRQ_HANDLED;
1213 }
1214 /* Begin interrupt handler HERE inline to avoid the extra
1215 levels of logic and call depth for the original solution. */
1216 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1217 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1218 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1219 /*BMS status,status_even); */
1220
1221 if (status & ADAP_CHK_INT) {
1222 int i;
1223 __u32 check_reason;
1224 __u8 check_reason_page = 0;
1225 check_reason =
1226 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN));
1227 if (ti->page_mask) {
1228 check_reason_page = (check_reason >> 8) & ti->page_mask;
1229 check_reason &= ~(ti->page_mask << 8);
1230 }
1231 check_reason += ti->sram_virt;
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 = (u32)ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1521 #endif
1522 ti->init_srb = ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN));
1523 if (ti->page_mask) {
1524 ti->init_srb_page = (ti->init_srb >> 8) & ti->page_mask;
1525 ti->init_srb &= ~(ti->page_mask << 8);
1526 }
1527 ti->init_srb += ti->sram_virt;
1528 if (ti->page_mask && ti->avail_shared_ram == 127) {
1529 int last_512 = 0xfe00, i;
1530 int last_512_page=0;
1531 last_512_page=(last_512>>8)&ti->page_mask;
1532 last_512 &= ~(ti->page_mask << 8);
1533 /* initialize high section of ram (if necessary) */
1534 SET_PAGE(last_512_page);
1535 for (i = 0; i < 512; i++)
1536 writeb(0, ti->sram_virt + last_512 + i);
1537 }
1538 SET_PAGE(ti->init_srb_page);
1539
1540 #if TR_VERBOSE
1541 {
1542 int i;
1543
1544 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1545 DPRINTK("init_srb(%x):", (ti->init_srb) );
1546 for (i = 0; i < 20; i++)
1547 printk("%02X ", (int) readb(ti->init_srb + i));
1548 printk("\n");
1549 }
1550 #endif
1551
1552 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1553 encoded_addr = ntohs(hw_encoded_addr);
1554 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1555 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1556 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1557 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1558 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1559 ti->ring_speed, (unsigned int)dev->mem_start);
1560 ti->auto_speedsave=readb(ti->init_srb+INIT_STATUS_2_OFST)&4?TRUE:FALSE;
1561
1562 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1563 else tok_open_adapter((unsigned long)dev);
1564
1565 } /*initial_tok_int() */
1566
1567 /*****************************************************************************/
1568
1569 #define CMD_CORRELATE_OFST 1
1570 #define DHB_ADDRESS_OFST 6
1571
1572 #define FRAME_LENGTH_OFST 6
1573 #define HEADER_LENGTH_OFST 8
1574 #define RSAP_VALUE_OFST 9
1575
1576 static void tr_tx(struct net_device *dev)
1577 {
1578 struct tok_info *ti = (struct tok_info *) dev->priv;
1579 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1580 unsigned int hdr_len;
1581 __u32 dhb=0,dhb_base;
1582 unsigned char xmit_command;
1583 int i,dhb_len=0x4000,src_len,src_offset;
1584 struct trllc *llc;
1585 struct srb_xmit xsrb;
1586 __u8 dhb_page = 0;
1587 __u8 llc_ssap;
1588
1589 SET_PAGE(ti->asb_page);
1590
1591 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1592
1593 /* in providing the transmit interrupts, is telling us it is ready for
1594 data and providing a shared memory address for us to stuff with data.
1595 Here we compute the effective address where we will place data.
1596 */
1597 SET_PAGE(ti->arb_page);
1598 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1599 if (ti->page_mask) {
1600 dhb_page = (dhb_base >> 8) & ti->page_mask;
1601 dhb=dhb_base & ~(ti->page_mask << 8);
1602 }
1603 dhb += ti->sram_virt;
1604
1605 /* Figure out the size of the 802.5 header */
1606 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1607 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1608 else
1609 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1610 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1611
1612 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1613
1614 llc_ssap = llc->ssap;
1615 SET_PAGE(ti->srb_page);
1616 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1617 SET_PAGE(ti->asb_page);
1618 xmit_command = xsrb.command;
1619
1620 writeb(xmit_command, ti->asb + COMMAND_OFST);
1621 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1622 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1623 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1624 writeb(0, ti->asb + RETCODE_OFST);
1625 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1626 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1627 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1628 SET_PAGE(dhb_page);
1629 writeb(AC, dhb);
1630 writeb(LLC_FRAME, dhb + 1);
1631 for (i = 0; i < TR_ALEN; i++)
1632 writeb((int) 0x0FF, dhb + i + 2);
1633 for (i = 0; i < TR_ALEN; i++)
1634 writeb(0, dhb + i + TR_ALEN + 2);
1635 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1636 return;
1637 }
1638 /*
1639 * the token ring packet is copied from sk_buff to the adapter
1640 * buffer identified in the command data received with the interrupt.
1641 */
1642 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1643 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1644 src_len=ti->current_skb->len;
1645 src_offset=0;
1646 dhb=dhb_base;
1647 while(1) {
1648 if (ti->page_mask) {
1649 dhb_page=(dhb >> 8) & ti->page_mask;
1650 dhb=dhb & ~(ti->page_mask << 8);
1651 dhb_len=0x4000-dhb; /* remaining size of this page */
1652 }
1653 dhb+=ti->sram_virt;
1654 SET_PAGE(dhb_page);
1655 if (src_len > dhb_len) {
1656 memcpy_toio(dhb,&ti->current_skb->data[src_offset],
1657 dhb_len);
1658 src_len -= dhb_len;
1659 src_offset += dhb_len;
1660 dhb_base+=dhb_len;
1661 dhb=dhb_base;
1662 continue;
1663 }
1664 memcpy_toio(dhb, &ti->current_skb->data[src_offset], src_len);
1665 break;
1666 }
1667 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1668 ti->tr_stats.tx_bytes += ti->current_skb->len;
1669 dev_kfree_skb_irq(ti->current_skb);
1670 ti->current_skb = NULL;
1671 netif_wake_queue(dev);
1672 if (ti->readlog_pending)
1673 ibmtr_readlog(dev);
1674 } /*tr_tx */
1675
1676 /*****************************************************************************/
1677
1678
1679 #define RECEIVE_BUFFER_OFST 6
1680 #define LAN_HDR_LENGTH_OFST 8
1681 #define DLC_HDR_LENGTH_OFST 9
1682
1683 #define DSAP_OFST 0
1684 #define SSAP_OFST 1
1685 #define LLC_OFST 2
1686 #define PROTID_OFST 3
1687 #define ETHERTYPE_OFST 6
1688
1689 static void tr_rx(struct net_device *dev)
1690 {
1691 struct tok_info *ti = (struct tok_info *) dev->priv;
1692 __u32 rbuffer, rbufdata;
1693 __u8 rbuffer_page = 0;
1694 __u32 llc;
1695 unsigned char *data;
1696 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1697 unsigned char dlc_hdr_len;
1698 struct sk_buff *skb;
1699 unsigned int skb_size = 0;
1700 int IPv4_p = 0;
1701 unsigned int chksum = 0;
1702 struct iphdr *iph;
1703 struct arb_rec_req rarb;
1704
1705 SET_PAGE(ti->arb_page);
1706 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1707 rbuffer = ntohs(rarb.rec_buf_addr) ;
1708 if (ti->page_mask) {
1709 rbuffer_page = (rbuffer >> 8) & ti->page_mask;
1710 rbuffer &= ~(ti->page_mask << 8);
1711 }
1712 rbuffer += ti->sram_virt;
1713
1714 SET_PAGE(ti->asb_page);
1715
1716 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1717
1718 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1719 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1720 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1721
1722 lan_hdr_len = rarb.lan_hdr_len;
1723 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1724 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1725 return;
1726 } /*BMS I added this above just to be very safe */
1727 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1728 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1729
1730 SET_PAGE(rbuffer_page);
1731 llc = (rbuffer + offsetof(struct rec_buf, data) + lan_hdr_len);
1732
1733 #if TR_VERBOSE
1734 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1735 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1736 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1737 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1738 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1739 "ethertype: %04X\n",
1740 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1741 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1742 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1743 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1744 #endif
1745 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1746 SET_PAGE(ti->asb_page);
1747 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1748 ti->tr_stats.rx_dropped++;
1749 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1750 return;
1751 }
1752 length = ntohs(rarb.frame_len);
1753 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1754 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1755 length >= hdr_len) IPv4_p = 1;
1756 #if TR_VERBOSE
1757 #define SADDR_OFST 8
1758 #define DADDR_OFST 2
1759
1760 if (!IPv4_p) {
1761
1762 __u32 trhhdr;
1763
1764 trhhdr = (rbuffer + offsetof(struct rec_buf, data));
1765
1766 DPRINTK("Probably non-IP frame received.\n");
1767 DPRINTK("ssap: %02X dsap: %02X "
1768 "saddr: %02X:%02X:%02X:%02X:%02X:%02X "
1769 "daddr: %02X:%02X:%02X:%02X:%02X:%02X\n",
1770 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1771 readb(trhhdr+SADDR_OFST), readb(trhhdr+ SADDR_OFST+1),
1772 readb(trhhdr+SADDR_OFST+2), readb(trhhdr+SADDR_OFST+3),
1773 readb(trhhdr+SADDR_OFST+4), readb(trhhdr+SADDR_OFST+5),
1774 readb(trhhdr+DADDR_OFST), readb(trhhdr+DADDR_OFST + 1),
1775 readb(trhhdr+DADDR_OFST+2), readb(trhhdr+DADDR_OFST+3),
1776 readb(trhhdr+DADDR_OFST+4), readb(trhhdr+DADDR_OFST+5));
1777 }
1778 #endif
1779
1780 /*BMS handle the case she comes in with few hops but leaves with many */
1781 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1782
1783 if (!(skb = dev_alloc_skb(skb_size))) {
1784 DPRINTK("out of memory. frame dropped.\n");
1785 ti->tr_stats.rx_dropped++;
1786 SET_PAGE(ti->asb_page);
1787 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1788 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1789 return;
1790 }
1791 /*BMS again, if she comes in with few but leaves with many */
1792 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1793 skb_put(skb, length);
1794 skb->dev = dev;
1795 data = skb->data;
1796 rbuffer_len = ntohs(readw(rbuffer + offsetof(struct rec_buf, buf_len)));
1797 rbufdata = rbuffer + offsetof(struct rec_buf, data);
1798
1799 if (IPv4_p) {
1800 /* Copy the headers without checksumming */
1801 memcpy_fromio(data, rbufdata, hdr_len);
1802
1803 /* Watch for padded packets and bogons */
1804 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1805 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1806 length -= hdr_len;
1807 if ((ip_len <= length) && (ip_len > 7))
1808 length = ip_len;
1809 data += hdr_len;
1810 rbuffer_len -= hdr_len;
1811 rbufdata += hdr_len;
1812 }
1813 /* Copy the payload... */
1814 #define BUFFER_POINTER_OFST 2
1815 #define BUFFER_LENGTH_OFST 6
1816 for (;;) {
1817 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1818 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1819 length,rbuffer_len);
1820 if (IPv4_p)
1821 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1822 data,length<rbuffer_len?length:rbuffer_len,chksum);
1823 else
1824 memcpy_fromio(data, rbufdata, rbuffer_len);
1825 rbuffer = ntohs(readw(rbuffer+BUFFER_POINTER_OFST)) ;
1826 if (!rbuffer)
1827 break;
1828 rbuffer -= 2;
1829 length -= rbuffer_len;
1830 data += rbuffer_len;
1831 if (ti->page_mask) {
1832 rbuffer_page = (rbuffer >> 8) & ti->page_mask;
1833 rbuffer &= ~(ti->page_mask << 8);
1834 }
1835 rbuffer += ti->sram_virt;
1836 SET_PAGE(rbuffer_page);
1837 rbuffer_len = ntohs(readw(rbuffer + BUFFER_LENGTH_OFST));
1838 rbufdata = rbuffer + offsetof(struct rec_buf, data);
1839 }
1840
1841 SET_PAGE(ti->asb_page);
1842 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1843
1844 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1845
1846 ti->tr_stats.rx_bytes += skb->len;
1847 ti->tr_stats.rx_packets++;
1848
1849 skb->protocol = tr_type_trans(skb, dev);
1850 if (IPv4_p) {
1851 skb->csum = chksum;
1852 skb->ip_summed = 1;
1853 }
1854 netif_rx(skb);
1855 dev->last_rx = jiffies;
1856 } /*tr_rx */
1857
1858 /*****************************************************************************/
1859
1860 void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1861 {
1862 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1863 tmr->data = (unsigned long) dev;
1864 tmr->function = tok_rerun;
1865 init_timer(tmr);
1866 add_timer(tmr);
1867 }
1868
1869 /*****************************************************************************/
1870
1871 void tok_rerun(unsigned long dev_addr){
1872
1873 struct net_device *dev = (struct net_device *)dev_addr;
1874 struct tok_info *ti = (struct tok_info *) dev->priv;
1875
1876 if ( ti->open_action == RESTART){
1877 ti->do_tok_int = FIRST_INT;
1878 outb(0, dev->base_addr + ADAPTRESETREL);
1879 #ifdef ENABLE_PAGING
1880 if (ti->page_mask)
1881 writeb(SRPR_ENABLE_PAGING,
1882 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1883 #endif
1884
1885 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1886 } else
1887 tok_open_adapter(dev_addr);
1888 }
1889
1890 /*****************************************************************************/
1891
1892 void ibmtr_readlog(struct net_device *dev)
1893 {
1894 struct tok_info *ti;
1895
1896 ti = (struct tok_info *) dev->priv;
1897
1898 ti->readlog_pending = 0;
1899 SET_PAGE(ti->srb_page);
1900 writeb(DIR_READ_LOG, ti->srb);
1901 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1902 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1903
1904 netif_stop_queue(dev);
1905
1906 }
1907
1908 /*****************************************************************************/
1909
1910 /* tok_get_stats(): Basically a scaffold routine which will return
1911 the address of the tr_statistics structure associated with
1912 this device -- the tr.... structure is an ethnet look-alike
1913 so at least for this iteration may suffice. */
1914
1915 static struct net_device_stats *tok_get_stats(struct net_device *dev)
1916 {
1917
1918 struct tok_info *toki;
1919 toki = (struct tok_info *) dev->priv;
1920 return (struct net_device_stats *) &toki->tr_stats;
1921 }
1922
1923 /*****************************************************************************/
1924
1925 int ibmtr_change_mtu(struct net_device *dev, int mtu)
1926 {
1927 struct tok_info *ti = (struct tok_info *) dev->priv;
1928
1929 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1930 return -EINVAL;
1931 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1932 return -EINVAL;
1933 dev->mtu = mtu;
1934 return 0;
1935 }
1936
1937 /*****************************************************************************/
1938 #ifdef MODULE
1939
1940 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1941 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1942 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1943 static int irq[IBMTR_MAX_ADAPTERS];
1944 static int mem[IBMTR_MAX_ADAPTERS];
1945
1946 MODULE_LICENSE("GPL");
1947
1948 module_param_array(io, int, NULL, 0);
1949 module_param_array(irq, int, NULL, 0);
1950 module_param_array(mem, int, NULL, 0);
1951
1952 static int __init ibmtr_init(void)
1953 {
1954 int i;
1955 int count=0;
1956
1957 find_turbo_adapters(io);
1958
1959 for (i = 0; io[i] && (i < IBMTR_MAX_ADAPTERS); i++) {
1960 struct net_device *dev;
1961 irq[i] = 0;
1962 mem[i] = 0;
1963 dev = alloc_trdev(sizeof(struct tok_info));
1964 if (dev == NULL) {
1965 if (i == 0)
1966 return -ENOMEM;
1967 break;
1968 }
1969 dev->base_addr = io[i];
1970 dev->irq = irq[i];
1971 dev->mem_start = mem[i];
1972
1973 if (ibmtr_probe_card(dev)) {
1974 free_netdev(dev);
1975 continue;
1976 }
1977 dev_ibmtr[i] = dev;
1978 count++;
1979 }
1980 if (count) return 0;
1981 printk("ibmtr: register_netdev() returned non-zero.\n");
1982 return -EIO;
1983 }
1984 module_init(ibmtr_init);
1985
1986 static void __exit ibmtr_cleanup(void)
1987 {
1988 int i;
1989
1990 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1991 if (!dev_ibmtr[i])
1992 continue;
1993 unregister_netdev(dev_ibmtr[i]);
1994 ibmtr_cleanup_card(dev_ibmtr[i]);
1995 free_netdev(dev_ibmtr[i]);
1996 }
1997 }
1998 module_exit(ibmtr_cleanup);
1999 #endif
2000
|
This page was automatically generated by the
LXR engine.
|