?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
JBD: round commit timer up to avoid uncommitted transaction
[linux/fpc-iii.git] / drivers / net / tokenring / ibmtr.c
blob525bbc5b9c9d7aeacefbb632f1940d2830258b47
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 /* changes the output format of driver initialization */
120 #define TR_VERBOSE 0
121
122 /* some 95 OS send many non UI frame; this allow removing the warning */
123 #define TR_FILTERNONUI 1
124
125 #include <linux/ioport.h>
126 #include <linux/netdevice.h>
127 #include <linux/ip.h>
128 #include <linux/trdevice.h>
129 #include <linux/ibmtr.h>
130
131 #include <net/checksum.h>
132
133 #include <asm/io.h>
134
135 #define DPRINTK(format, args...) printk("%s: " format, dev->name , ## args)
136 #define DPRINTD(format, args...) DummyCall("%s: " format, dev->name , ## args)
137
138 /* version and credits */
139 #ifndef PCMCIA
140 static char version[] __devinitdata =
141 "\nibmtr.c: v1.3.57 8/ 7/94 Peter De Schrijver and Mark Swanson\n"
142 " v2.1.125 10/20/98 Paul Norton <pnorton@ieee.org>\n"
143 " v2.2.0 12/30/98 Joel Sloan <jjs@c-me.com>\n"
144 " v2.2.1 02/08/00 Mike Sullivan <sullivam@us.ibm.com>\n"
145 " v2.2.2 07/27/00 Burt Silverman <burts@us.ibm.com>\n"
146 " v2.4.0 03/01/01 Mike Sullivan <sullivan@us.ibm.com>\n";
147 #endif
148
149 /* this allows displaying full adapter information */
150
151 static char *channel_def[] __devinitdata = { "ISA", "MCA", "ISA P&P" };
152
153 static char pcchannelid[] __devinitdata = {
154 0x05, 0x00, 0x04, 0x09,
155 0x04, 0x03, 0x04, 0x0f,
156 0x03, 0x06, 0x03, 0x01,
157 0x03, 0x01, 0x03, 0x00,
158 0x03, 0x09, 0x03, 0x09,
159 0x03, 0x00, 0x02, 0x00
160 };
161
162 static char mcchannelid[] __devinitdata = {
163 0x04, 0x0d, 0x04, 0x01,
164 0x05, 0x02, 0x05, 0x03,
165 0x03, 0x06, 0x03, 0x03,
166 0x05, 0x08, 0x03, 0x04,
167 0x03, 0x05, 0x03, 0x01,
168 0x03, 0x08, 0x02, 0x00
169 };
170
171 static char __devinit *adapter_def(char type)
172 {
173 switch (type) {
174 case 0xF: return "PC Adapter | PC Adapter II | Adapter/A";
175 case 0xE: return "16/4 Adapter | 16/4 Adapter/A (long)";
176 case 0xD: return "16/4 Adapter/A (short) | 16/4 ISA-16 Adapter";
177 case 0xC: return "Auto 16/4 Adapter";
178 default: return "adapter (unknown type)";
179 };
180 };
181
182 #define TRC_INIT 0x01 /* Trace initialization & PROBEs */
183 #define TRC_INITV 0x02 /* verbose init trace points */
184 static unsigned char ibmtr_debug_trace = 0;
185
186 static int ibmtr_probe1(struct net_device *dev, int ioaddr);
187 static unsigned char get_sram_size(struct tok_info *adapt_info);
188 static int trdev_init(struct net_device *dev);
189 static int tok_open(struct net_device *dev);
190 static int tok_init_card(struct net_device *dev);
191 static void tok_open_adapter(unsigned long dev_addr);
192 static void open_sap(unsigned char type, struct net_device *dev);
193 static void tok_set_multicast_list(struct net_device *dev);
194 static netdev_tx_t tok_send_packet(struct sk_buff *skb,
195 struct net_device *dev);
196 static int tok_close(struct net_device *dev);
197 static irqreturn_t tok_interrupt(int irq, void *dev_id);
198 static void initial_tok_int(struct net_device *dev);
199 static void tr_tx(struct net_device *dev);
200 static void tr_rx(struct net_device *dev);
201 static void ibmtr_reset_timer(struct timer_list*tmr,struct net_device *dev);
202 static void tok_rerun(unsigned long dev_addr);
203 static void ibmtr_readlog(struct net_device *dev);
204 static int ibmtr_change_mtu(struct net_device *dev, int mtu);
205 static void find_turbo_adapters(int *iolist);
206
207 static int ibmtr_portlist[IBMTR_MAX_ADAPTERS+1] __devinitdata = {
208 0xa20, 0xa24, 0, 0, 0
209 };
210 static int __devinitdata turbo_io[IBMTR_MAX_ADAPTERS] = {0};
211 static int __devinitdata turbo_irq[IBMTR_MAX_ADAPTERS] = {0};
212 static int __devinitdata turbo_searched = 0;
213
214 #ifndef PCMCIA
215 static __u32 ibmtr_mem_base __devinitdata = 0xd0000;
216 #endif
217
218 static void __devinit PrtChanID(char *pcid, short stride)
219 {
220 short i, j;
221 for (i = 0, j = 0; i < 24; i++, j += stride)
222 printk("%1x", ((int) pcid[j]) & 0x0f);
223 printk("\n");
224 }
225
226 static void __devinit HWPrtChanID(void __iomem *pcid, short stride)
227 {
228 short i, j;
229 for (i = 0, j = 0; i < 24; i++, j += stride)
230 printk("%1x", ((int) readb(pcid + j)) & 0x0f);
231 printk("\n");
232 }
233
234 /* We have to ioremap every checked address, because isa_readb is
235 * going away.
236 */
237
238 static void __devinit find_turbo_adapters(int *iolist)
239 {
240 int ram_addr;
241 int index=0;
242 void __iomem *chanid;
243 int found_turbo=0;
244 unsigned char *tchanid, ctemp;
245 int i, j;
246 unsigned long jif;
247 void __iomem *ram_mapped ;
248
249 if (turbo_searched == 1) return;
250 turbo_searched=1;
251 for (ram_addr=0xC0000; ram_addr < 0xE0000; ram_addr+=0x2000) {
252
253 __u32 intf_tbl=0;
254
255 found_turbo=1;
256 ram_mapped = ioremap((u32)ram_addr,0x1fff) ;
257 if (ram_mapped==NULL)
258 continue ;
259 chanid=(CHANNEL_ID + ram_mapped);
260 tchanid=pcchannelid;
261 ctemp=readb(chanid) & 0x0f;
262 if (ctemp != *tchanid) continue;
263 for (i=2,j=1; i<=46; i=i+2,j++) {
264 if ((readb(chanid+i) & 0x0f) != tchanid[j]){
265 found_turbo=0;
266 break;
267 }
268 }
269 if (!found_turbo) continue;
270
271 writeb(0x90, ram_mapped+0x1E01);
272 for(i=2; i<0x0f; i++) {
273 writeb(0x00, ram_mapped+0x1E01+i);
274 }
275 writeb(0x00, ram_mapped+0x1E01);
276 for(jif=jiffies+TR_BUSY_INTERVAL; time_before_eq(jiffies,jif););
277 intf_tbl=ntohs(readw(ram_mapped+ACA_OFFSET+ACA_RW+WRBR_EVEN));
278 if (intf_tbl) {
279 #if IBMTR_DEBUG_MESSAGES
280 printk("ibmtr::find_turbo_adapters, Turbo found at "
281 "ram_addr %x\n",ram_addr);
282 printk("ibmtr::find_turbo_adapters, interface_table ");
283 for(i=0; i<6; i++) {
284 printk("%x:",readb(ram_addr+intf_tbl+i));
285 }
286 printk("\n");
287 #endif
288 turbo_io[index]=ntohs(readw(ram_mapped+intf_tbl+4));
289 turbo_irq[index]=readb(ram_mapped+intf_tbl+3);
290 outb(0, turbo_io[index] + ADAPTRESET);
291 for(jif=jiffies+TR_RST_TIME;time_before_eq(jiffies,jif););
292 outb(0, turbo_io[index] + ADAPTRESETREL);
293 index++;
294 continue;
295 }
296 #if IBMTR_DEBUG_MESSAGES
297 printk("ibmtr::find_turbo_adapters, ibmtr card found at"
298 " %x but not a Turbo model\n",ram_addr);
299 #endif
300 iounmap(ram_mapped) ;
301 } /* for */
302 for(i=0; i<IBMTR_MAX_ADAPTERS; i++) {
303 if(!turbo_io[i]) break;
304 for (j=0; j<IBMTR_MAX_ADAPTERS; j++) {
305 if ( iolist[j] && iolist[j] != turbo_io[i]) continue;
306 iolist[j]=turbo_io[i];
307 break;
308 }
309 }
310 }
311
312 static void ibmtr_cleanup_card(struct net_device *dev)
313 {
314 if (dev->base_addr) {
315 outb(0,dev->base_addr+ADAPTRESET);
316
317 schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
318
319 outb(0,dev->base_addr+ADAPTRESETREL);
320 }
321
322 #ifndef PCMCIA
323 free_irq(dev->irq, dev);
324 release_region(dev->base_addr, IBMTR_IO_EXTENT);
325
326 {
327 struct tok_info *ti = netdev_priv(dev);
328 iounmap(ti->mmio);
329 iounmap(ti->sram_virt);
330 }
331 #endif
332 }
333
334 /****************************************************************************
335 * ibmtr_probe(): Routine specified in the network device structure
336 * to probe for an IBM Token Ring Adapter. Routine outline:
337 * I. Interrogate hardware to determine if an adapter exists
338 * and what the speeds and feeds are
339 * II. Setup data structures to control execution based upon
340 * adapter characteristics.
341 *
342 * We expect ibmtr_probe to be called once for each device entry
343 * which references it.
344 ****************************************************************************/
345
346 static int __devinit ibmtr_probe(struct net_device *dev)
347 {
348 int i;
349 int base_addr = dev->base_addr;
350
351 if (base_addr && base_addr <= 0x1ff) /* Don't probe at all. */
352 return -ENXIO;
353 if (base_addr > 0x1ff) { /* Check a single specified location. */
354 if (!ibmtr_probe1(dev, base_addr)) return 0;
355 return -ENODEV;
356 }
357 find_turbo_adapters(ibmtr_portlist);
358 for (i = 0; ibmtr_portlist[i]; i++) {
359 int ioaddr = ibmtr_portlist[i];
360
361 if (!ibmtr_probe1(dev, ioaddr)) return 0;
362 }
363 return -ENODEV;
364 }
365
366 int __devinit ibmtr_probe_card(struct net_device *dev)
367 {
368 int err = ibmtr_probe(dev);
369 if (!err) {
370 err = register_netdev(dev);
371 if (err)
372 ibmtr_cleanup_card(dev);
373 }
374 return err;
375 }
376
377 /*****************************************************************************/
378
379 static int __devinit ibmtr_probe1(struct net_device *dev, int PIOaddr)
380 {
381
382 unsigned char segment, intr=0, irq=0, i, j, cardpresent=NOTOK, temp=0;
383 void __iomem * t_mmio = NULL;
384 struct tok_info *ti = netdev_priv(dev);
385 void __iomem *cd_chanid;
386 unsigned char *tchanid, ctemp;
387 #ifndef PCMCIA
388 unsigned char t_irq=0;
389 unsigned long timeout;
390 static int version_printed;
391 #endif
392
393 /* Query the adapter PIO base port which will return
394 * indication of where MMIO was placed. We also have a
395 * coded interrupt number.
396 */
397 segment = inb(PIOaddr);
398 if (segment < 0x40 || segment > 0xe0) {
399 /* Out of range values so we'll assume non-existent IO device
400 * but this is not necessarily a problem, esp if a turbo
401 * adapter is being used. */
402 #if IBMTR_DEBUG_MESSAGES
403 DPRINTK("ibmtr_probe1(): unhappy that inb(0x%X) == 0x%X, "
404 "Hardware Problem?\n",PIOaddr,segment);
405 #endif
406 return -ENODEV;
407 }
408 /*
409 * Compute the linear base address of the MMIO area
410 * as LINUX doesn't care about segments
411 */
412 t_mmio = ioremap(((__u32) (segment & 0xfc) << 11) + 0x80000,2048);
413 if (!t_mmio) {
414 DPRINTK("Cannot remap mmiobase memory area") ;
415 return -ENODEV ;
416 }
417 intr = segment & 0x03; /* low bits is coded interrupt # */
418 if (ibmtr_debug_trace & TRC_INIT)
419 DPRINTK("PIOaddr: %4hx seg/intr: %2x mmio base: %p intr: %d\n"
420 , PIOaddr, (int) segment, t_mmio, (int) intr);
421
422 /*
423 * Now we will compare expected 'channelid' strings with
424 * what we is there to learn of ISA/MCA or not TR card
425 */
426 #ifdef PCMCIA
427 iounmap(t_mmio);
428 t_mmio = ti->mmio; /*BMS to get virtual address */
429 irq = ti->irq; /*BMS to display the irq! */
430 #endif
431 cd_chanid = (CHANNEL_ID + t_mmio); /* for efficiency */
432 tchanid = pcchannelid;
433 cardpresent = TR_ISA; /* try ISA */
434
435 /* Suboptimize knowing first byte different */
436 ctemp = readb(cd_chanid) & 0x0f;
437 if (ctemp != *tchanid) { /* NOT ISA card, try MCA */
438 tchanid = mcchannelid;
439 cardpresent = TR_MCA;
440 if (ctemp != *tchanid) /* Neither ISA nor MCA */
441 cardpresent = NOTOK;
442 }
443 if (cardpresent != NOTOK) {
444 /* Know presumed type, try rest of ID */
445 for (i = 2, j = 1; i <= 46; i = i + 2, j++) {
446 if( (readb(cd_chanid+i)&0x0f) == tchanid[j]) continue;
447 /* match failed, not TR card */
448 cardpresent = NOTOK;
449 break;
450 }
451 }
452 /*
453 * If we have an ISA board check for the ISA P&P version,
454 * as it has different IRQ settings
455 */
456 if (cardpresent == TR_ISA && (readb(AIPFID + t_mmio) == 0x0e))
457 cardpresent = TR_ISAPNP;
458 if (cardpresent == NOTOK) { /* "channel_id" did not match, report */
459 if (!(ibmtr_debug_trace & TRC_INIT)) {
460 #ifndef PCMCIA
461 iounmap(t_mmio);
462 #endif
463 return -ENODEV;
464 }
465 DPRINTK( "Channel ID string not found for PIOaddr: %4hx\n",
466 PIOaddr);
467 DPRINTK("Expected for ISA: ");
468 PrtChanID(pcchannelid, 1);
469 DPRINTK(" found: ");
470 /* BMS Note that this can be misleading, when hardware is flaky, because you
471 are reading it a second time here. So with my flaky hardware, I'll see my-
472 self in this block, with the HW ID matching the ISA ID exactly! */
473 HWPrtChanID(cd_chanid, 2);
474 DPRINTK("Expected for MCA: ");
475 PrtChanID(mcchannelid, 1);
476 }
477 /* Now, setup some of the pl0 buffers for this driver.. */
478 /* If called from PCMCIA, it is already set up, so no need to
479 waste the memory, just use the existing structure */
480 #ifndef PCMCIA
481 ti->mmio = t_mmio;
482 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++) {
483 if (turbo_io[i] != PIOaddr)
484 continue;
485 #if IBMTR_DEBUG_MESSAGES
486 printk("ibmtr::tr_probe1, setting PIOaddr %x to Turbo\n",
487 PIOaddr);
488 #endif
489 ti->turbo = 1;
490 t_irq = turbo_irq[i];
491 }
492 #endif /* !PCMCIA */
493 ti->readlog_pending = 0;
494 init_waitqueue_head(&ti->wait_for_reset);
495
496 /* if PCMCIA, the card can be recognized as either TR_ISA or TR_ISAPNP
497 * depending which card is inserted. */
498
499 #ifndef PCMCIA
500 switch (cardpresent) {
501 case TR_ISA:
502 if (intr == 0) irq = 9; /* irq2 really is irq9 */
503 if (intr == 1) irq = 3;
504 if (intr == 2) irq = 6;
505 if (intr == 3) irq = 7;
506 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
507 break;
508 case TR_MCA:
509 if (intr == 0) irq = 9;
510 if (intr == 1) irq = 3;
511 if (intr == 2) irq = 10;
512 if (intr == 3) irq = 11;
513 ti->global_int_enable = 0;
514 ti->adapter_int_enable = 0;
515 ti->sram_phys=(__u32)(inb(PIOaddr+ADAPTRESETREL) & 0xfe) << 12;
516 break;
517 case TR_ISAPNP:
518 if (!t_irq) {
519 if (intr == 0) irq = 9;
520 if (intr == 1) irq = 3;
521 if (intr == 2) irq = 10;
522 if (intr == 3) irq = 11;
523 } else
524 irq=t_irq;
525 timeout = jiffies + TR_SPIN_INTERVAL;
526 while (!readb(ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN)){
527 if (!time_after(jiffies, timeout)) continue;
528 DPRINTK( "Hardware timeout during initialization.\n");
529 iounmap(t_mmio);
530 return -ENODEV;
531 }
532 ti->sram_phys =
533 ((__u32)readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_EVEN)<<12);
534 ti->adapter_int_enable = PIOaddr + ADAPTINTREL;
535 break;
536 } /*end switch (cardpresent) */
537 #endif /*not PCMCIA */
538
539 if (ibmtr_debug_trace & TRC_INIT) { /* just report int */
540 DPRINTK("irq=%d", irq);
541 printk(", sram_phys=0x%x", ti->sram_phys);
542 if(ibmtr_debug_trace&TRC_INITV){ /* full chat in verbose only */
543 DPRINTK(", ti->mmio=%p", ti->mmio);
544 printk(", segment=%02X", segment);
545 }
546 printk(".\n");
547 }
548
549 /* Get hw address of token ring card */
550 j = 0;
551 for (i = 0; i < 0x18; i = i + 2) {
552 /* technical reference states to do this */
553 temp = readb(ti->mmio + AIP + i) & 0x0f;
554 ti->hw_address[j] = temp;
555 if (j & 1)
556 dev->dev_addr[(j / 2)] =
557 ti->hw_address[j]+ (ti->hw_address[j - 1] << 4);
558 ++j;
559 }
560 /* get Adapter type: 'F' = Adapter/A, 'E' = 16/4 Adapter II,... */
561 ti->adapter_type = readb(ti->mmio + AIPADAPTYPE);
562
563 /* get Data Rate: F=4Mb, E=16Mb, D=4Mb & 16Mb ?? */
564 ti->data_rate = readb(ti->mmio + AIPDATARATE);
565
566 /* Get Early Token Release support?: F=no, E=4Mb, D=16Mb, C=4&16Mb */
567 ti->token_release = readb(ti->mmio + AIPEARLYTOKEN);
568
569 /* How much shared RAM is on adapter ? */
570 if (ti->turbo) {
571 ti->avail_shared_ram=127;
572 } else {
573 ti->avail_shared_ram = get_sram_size(ti);/*in 512 byte units */
574 }
575 /* We need to set or do a bunch of work here based on previous results*/
576 /* Support paging? What sizes?: F=no, E=16k, D=32k, C=16 & 32k */
577 ti->shared_ram_paging = readb(ti->mmio + AIPSHRAMPAGE);
578
579 /* Available DHB 4Mb size: F=2048, E=4096, D=4464 */
580 switch (readb(ti->mmio + AIP4MBDHB)) {
581 case 0xe: ti->dhb_size4mb = 4096; break;
582 case 0xd: ti->dhb_size4mb = 4464; break;
583 default: ti->dhb_size4mb = 2048; break;
584 }
585
586 /* Available DHB 16Mb size: F=2048, E=4096, D=8192, C=16384, B=17960 */
587 switch (readb(ti->mmio + AIP16MBDHB)) {
588 case 0xe: ti->dhb_size16mb = 4096; break;
589 case 0xd: ti->dhb_size16mb = 8192; break;
590 case 0xc: ti->dhb_size16mb = 16384; break;
591 case 0xb: ti->dhb_size16mb = 17960; break;
592 default: ti->dhb_size16mb = 2048; break;
593 }
594
595 /* We must figure out how much shared memory space this adapter
596 * will occupy so that if there are two adapters we can fit both
597 * in. Given a choice, we will limit this adapter to 32K. The
598 * maximum space will will use for two adapters is 64K so if the
599 * adapter we are working on demands 64K (it also doesn't support
600 * paging), then only one adapter can be supported.
601 */
602
603 /*
604 * determine how much of total RAM is mapped into PC space
605 */
606 ti->mapped_ram_size= /*sixteen to onehundredtwentyeight 512byte blocks*/
607 1<< ((readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03) + 4);
608 ti->page_mask = 0;
609 if (ti->turbo) ti->page_mask=0xf0;
610 else if (ti->shared_ram_paging == 0xf); /* No paging in adapter */
611 else {
612 #ifdef ENABLE_PAGING
613 unsigned char pg_size = 0;
614 /* BMS: page size: PCMCIA, use configuration register;
615 ISAPNP, use LANAIDC config tool from www.ibm.com */
616 switch (ti->shared_ram_paging) {
617 case 0xf:
618 break;
619 case 0xe:
620 ti->page_mask = (ti->mapped_ram_size == 32) ? 0xc0 : 0;
621 pg_size = 32; /* 16KB page size */
622 break;
623 case 0xd:
624 ti->page_mask = (ti->mapped_ram_size == 64) ? 0x80 : 0;
625 pg_size = 64; /* 32KB page size */
626 break;
627 case 0xc:
628 switch (ti->mapped_ram_size) {
629 case 32:
630 ti->page_mask = 0xc0;
631 pg_size = 32;
632 break;
633 case 64:
634 ti->page_mask = 0x80;
635 pg_size = 64;
636 break;
637 }
638 break;
639 default:
640 DPRINTK("Unknown shared ram paging info %01X\n",
641 ti->shared_ram_paging);
642 iounmap(t_mmio);
643 return -ENODEV;
644 break;
645 } /*end switch shared_ram_paging */
646
647 if (ibmtr_debug_trace & TRC_INIT)
648 DPRINTK("Shared RAM paging code: %02X, "
649 "mapped RAM size: %dK, shared RAM size: %dK, "
650 "page mask: %02X\n:",
651 ti->shared_ram_paging, ti->mapped_ram_size / 2,
652 ti->avail_shared_ram / 2, ti->page_mask);
653 #endif /*ENABLE_PAGING */
654 }
655
656 #ifndef PCMCIA
657 /* finish figuring the shared RAM address */
658 if (cardpresent == TR_ISA) {
659 static __u32 ram_bndry_mask[] =
660 { 0xffffe000, 0xffffc000, 0xffff8000, 0xffff0000 };
661 __u32 new_base, rrr_32, chk_base, rbm;
662
663 rrr_32=readb(ti->mmio+ACA_OFFSET+ACA_RW+RRR_ODD) >> 2 & 0x03;
664 rbm = ram_bndry_mask[rrr_32];
665 new_base = (ibmtr_mem_base + (~rbm)) & rbm;/* up to boundary */
666 chk_base = new_base + (ti->mapped_ram_size << 9);
667 if (chk_base > (ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE)) {
668 DPRINTK("Shared RAM for this adapter (%05x) exceeds "
669 "driver limit (%05x), adapter not started.\n",
670 chk_base, ibmtr_mem_base + IBMTR_SHARED_RAM_SIZE);
671 iounmap(t_mmio);
672 return -ENODEV;
673 } else { /* seems cool, record what we have figured out */
674 ti->sram_base = new_base >> 12;
675 ibmtr_mem_base = chk_base;
676 }
677 }
678 else ti->sram_base = ti->sram_phys >> 12;
679
680 /* The PCMCIA has already got the interrupt line and the io port,
681 so no chance of anybody else getting it - MLP */
682 if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
683 DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
684 irq);
685 iounmap(t_mmio);
686 return -ENODEV;
687 }
688 /*?? Now, allocate some of the PIO PORTs for this driver.. */
689 /* record PIOaddr range as busy */
690 if (!request_region(PIOaddr, IBMTR_IO_EXTENT, "ibmtr")) {
691 DPRINTK("Could not grab PIO range. Halting driver.\n");
692 free_irq(dev->irq, dev);
693 iounmap(t_mmio);
694 return -EBUSY;
695 }
696
697 if (!version_printed++) {
698 printk(version);
699 }
700 #endif /* !PCMCIA */
701 DPRINTK("%s %s found\n",
702 channel_def[cardpresent - 1], adapter_def(ti->adapter_type));
703 DPRINTK("using irq %d, PIOaddr %hx, %dK shared RAM.\n",
704 irq, PIOaddr, ti->mapped_ram_size / 2);
705 DPRINTK("Hardware address : %pM\n", dev->dev_addr);
706 if (ti->page_mask)
707 DPRINTK("Shared RAM paging enabled. "
708 "Page size: %uK Shared Ram size %dK\n",
709 ((ti->page_mask^0xff)+1) >>2, ti->avail_shared_ram / 2);
710 else
711 DPRINTK("Shared RAM paging disabled. ti->page_mask %x\n",
712 ti->page_mask);
713
714 /* Calculate the maximum DHB we can use */
715 /* two cases where avail_shared_ram doesn't equal mapped_ram_size:
716 1. avail_shared_ram is 127 but mapped_ram_size is 128 (typical)
717 2. user has configured adapter for less than avail_shared_ram
718 but is not using paging (she should use paging, I believe)
719 */
720 if (!ti->page_mask) {
721 ti->avail_shared_ram=
722 min(ti->mapped_ram_size,ti->avail_shared_ram);
723 }
724
725 switch (ti->avail_shared_ram) {
726 case 16: /* 8KB shared RAM */
727 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)2048);
728 ti->rbuf_len4 = 1032;
729 ti->rbuf_cnt4=2;
730 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)2048);
731 ti->rbuf_len16 = 1032;
732 ti->rbuf_cnt16=2;
733 break;
734 case 32: /* 16KB shared RAM */
735 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
736 ti->rbuf_len4 = 1032;
737 ti->rbuf_cnt4=4;
738 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)4096);
739 ti->rbuf_len16 = 1032; /*1024 usable */
740 ti->rbuf_cnt16=4;
741 break;
742 case 64: /* 32KB shared RAM */
743 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
744 ti->rbuf_len4 = 1032;
745 ti->rbuf_cnt4=6;
746 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)10240);
747 ti->rbuf_len16 = 1032;
748 ti->rbuf_cnt16=6;
749 break;
750 case 127: /* 63.5KB shared RAM */
751 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
752 ti->rbuf_len4 = 1032;
753 ti->rbuf_cnt4=6;
754 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)16384);
755 ti->rbuf_len16 = 1032;
756 ti->rbuf_cnt16=16;
757 break;
758 case 128: /* 64KB shared RAM */
759 ti->dhb_size4mb = min(ti->dhb_size4mb, (unsigned short)4464);
760 ti->rbuf_len4 = 1032;
761 ti->rbuf_cnt4=6;
762 ti->dhb_size16mb = min(ti->dhb_size16mb, (unsigned short)17960);
763 ti->rbuf_len16 = 1032;
764 ti->rbuf_cnt16=16;
765 break;
766 default:
767 ti->dhb_size4mb = 2048;
768 ti->rbuf_len4 = 1032;
769 ti->rbuf_cnt4=2;
770 ti->dhb_size16mb = 2048;
771 ti->rbuf_len16 = 1032;
772 ti->rbuf_cnt16=2;
773 break;
774 }
775 /* this formula is not smart enough for the paging case
776 ti->rbuf_cnt<x> = (ti->avail_shared_ram * BLOCKSZ - ADAPT_PRIVATE -
777 ARBLENGTH - SSBLENGTH - DLC_MAX_SAP * SAPLENGTH -
778 DLC_MAX_STA * STALENGTH - ti->dhb_size<x>mb * NUM_DHB -
779 SRBLENGTH - ASBLENGTH) / ti->rbuf_len<x>;
780 */
781 ti->maxmtu16 = (ti->rbuf_len16 - 8) * ti->rbuf_cnt16 - TR_HLEN;
782 ti->maxmtu4 = (ti->rbuf_len4 - 8) * ti->rbuf_cnt4 - TR_HLEN;
783 /*BMS assuming 18 bytes of Routing Information (usually works) */
784 DPRINTK("Maximum Receive Internet Protocol MTU 16Mbps: %d, 4Mbps: %d\n",
785 ti->maxmtu16, ti->maxmtu4);
786
787 dev->base_addr = PIOaddr; /* set the value for device */
788 dev->mem_start = ti->sram_base << 12;
789 dev->mem_end = dev->mem_start + (ti->mapped_ram_size << 9) - 1;
790 trdev_init(dev);
791 return 0; /* Return 0 to indicate we have found a Token Ring card. */
792 } /*ibmtr_probe1() */
793
794 /*****************************************************************************/
795
796 /* query the adapter for the size of shared RAM */
797 /* the function returns the RAM size in units of 512 bytes */
798
799 static unsigned char __devinit get_sram_size(struct tok_info *adapt_info)
800 {
801 unsigned char avail_sram_code;
802 static unsigned char size_code[] = { 0, 16, 32, 64, 127, 128 };
803 /* Adapter gives
804 'F' -- use RRR bits 3,2
805 'E' -- 8kb 'D' -- 16kb
806 'C' -- 32kb 'A' -- 64KB
807 'B' - 64KB less 512 bytes at top
808 (WARNING ... must zero top bytes in INIT */
809
810 avail_sram_code = 0xf - readb(adapt_info->mmio + AIPAVAILSHRAM);
811 if (avail_sram_code) return size_code[avail_sram_code];
812 else /* for code 'F', must compute size from RRR(3,2) bits */
813 return 1 <<
814 ((readb(adapt_info->mmio+ACA_OFFSET+ACA_RW+RRR_ODD)>>2&3)+4);
815 }
816
817 /*****************************************************************************/
818
819 static const struct net_device_ops trdev_netdev_ops = {
820 .ndo_open = tok_open,
821 .ndo_stop = tok_close,
822 .ndo_start_xmit = tok_send_packet,
823 .ndo_set_multicast_list = tok_set_multicast_list,
824 .ndo_change_mtu = ibmtr_change_mtu,
825 };
826
827 static int __devinit trdev_init(struct net_device *dev)
828 {
829 struct tok_info *ti = netdev_priv(dev);
830
831 SET_PAGE(ti->srb_page);
832 ti->open_failure = NO ;
833 dev->netdev_ops = &trdev_netdev_ops;
834
835 return 0;
836 }
837
838 /*****************************************************************************/
839
840 static int tok_init_card(struct net_device *dev)
841 {
842 struct tok_info *ti;
843 short PIOaddr;
844 unsigned long i;
845
846 PIOaddr = dev->base_addr;
847 ti = netdev_priv(dev);
848 /* Special processing for first interrupt after reset */
849 ti->do_tok_int = FIRST_INT;
850 /* Reset adapter */
851 writeb(~INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
852 outb(0, PIOaddr + ADAPTRESET);
853
854 schedule_timeout_uninterruptible(TR_RST_TIME); /* wait 50ms */
855
856 outb(0, PIOaddr + ADAPTRESETREL);
857 #ifdef ENABLE_PAGING
858 if (ti->page_mask)
859 writeb(SRPR_ENABLE_PAGING,ti->mmio+ACA_OFFSET+ACA_RW+SRPR_EVEN);
860 #endif
861 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
862 i = sleep_on_timeout(&ti->wait_for_reset, 4 * HZ);
863 return i? 0 : -EAGAIN;
864 }
865
866 /*****************************************************************************/
867 static int tok_open(struct net_device *dev)
868 {
869 struct tok_info *ti = netdev_priv(dev);
870 int i;
871
872 /*the case we were left in a failure state during a previous open */
873 if (ti->open_failure == YES) {
874 DPRINTK("Last time you were disconnected, how about now?\n");
875 printk("You can't insert with an ICS connector half-cocked.\n");
876 }
877
878 ti->open_status = CLOSED; /* CLOSED or OPEN */
879 ti->sap_status = CLOSED; /* CLOSED or OPEN */
880 ti->open_failure = NO; /* NO or YES */
881 ti->open_mode = MANUAL; /* MANUAL or AUTOMATIC */
882
883 ti->sram_phys &= ~1; /* to reverse what we do in tok_close */
884 /* init the spinlock */
885 spin_lock_init(&ti->lock);
886 init_timer(&ti->tr_timer);
887
888 i = tok_init_card(dev);
889 if (i) return i;
890
891 while (1){
892 tok_open_adapter((unsigned long) dev);
893 i= interruptible_sleep_on_timeout(&ti->wait_for_reset, 25 * HZ);
894 /* sig catch: estimate opening adapter takes more than .5 sec*/
895 if (i>(245*HZ)/10) break; /* fancier than if (i==25*HZ) */
896 if (i==0) break;
897 if (ti->open_status == OPEN && ti->sap_status==OPEN) {
898 netif_start_queue(dev);
899 DPRINTK("Adapter is up and running\n");
900 return 0;
901 }
902 i=schedule_timeout_interruptible(TR_RETRY_INTERVAL);
903 /* wait 30 seconds */
904 if(i!=0) break; /*prob. a signal, like the i>24*HZ case above */
905 }
906 outb(0, dev->base_addr + ADAPTRESET);/* kill pending interrupts*/
907 DPRINTK("TERMINATED via signal\n"); /*BMS useful */
908 return -EAGAIN;
909 }
910
911 /*****************************************************************************/
912
913 #define COMMAND_OFST 0
914 #define OPEN_OPTIONS_OFST 8
915 #define NUM_RCV_BUF_OFST 24
916 #define RCV_BUF_LEN_OFST 26
917 #define DHB_LENGTH_OFST 28
918 #define NUM_DHB_OFST 30
919 #define DLC_MAX_SAP_OFST 32
920 #define DLC_MAX_STA_OFST 33
921
922 static void tok_open_adapter(unsigned long dev_addr)
923 {
924 struct net_device *dev = (struct net_device *) dev_addr;
925 struct tok_info *ti;
926 int i;
927
928 ti = netdev_priv(dev);
929 SET_PAGE(ti->init_srb_page);
930 writeb(~SRB_RESP_INT, ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_ODD);
931 for (i = 0; i < sizeof(struct dir_open_adapter); i++)
932 writeb(0, ti->init_srb + i);
933 writeb(DIR_OPEN_ADAPTER, ti->init_srb + COMMAND_OFST);
934 writew(htons(OPEN_PASS_BCON_MAC), ti->init_srb + OPEN_OPTIONS_OFST);
935 if (ti->ring_speed == 16) {
936 writew(htons(ti->dhb_size16mb), ti->init_srb + DHB_LENGTH_OFST);
937 writew(htons(ti->rbuf_cnt16), ti->init_srb + NUM_RCV_BUF_OFST);
938 writew(htons(ti->rbuf_len16), ti->init_srb + RCV_BUF_LEN_OFST);
939 } else {
940 writew(htons(ti->dhb_size4mb), ti->init_srb + DHB_LENGTH_OFST);
941 writew(htons(ti->rbuf_cnt4), ti->init_srb + NUM_RCV_BUF_OFST);
942 writew(htons(ti->rbuf_len4), ti->init_srb + RCV_BUF_LEN_OFST);
943 }
944 writeb(NUM_DHB, /* always 2 */ ti->init_srb + NUM_DHB_OFST);
945 writeb(DLC_MAX_SAP, ti->init_srb + DLC_MAX_SAP_OFST);
946 writeb(DLC_MAX_STA, ti->init_srb + DLC_MAX_STA_OFST);
947 ti->srb = ti->init_srb; /* We use this one in the interrupt handler */
948 ti->srb_page = ti->init_srb_page;
949 DPRINTK("Opening adapter: Xmit bfrs: %d X %d, Rcv bfrs: %d X %d\n",
950 readb(ti->init_srb + NUM_DHB_OFST),
951 ntohs(readw(ti->init_srb + DHB_LENGTH_OFST)),
952 ntohs(readw(ti->init_srb + NUM_RCV_BUF_OFST)),
953 ntohs(readw(ti->init_srb + RCV_BUF_LEN_OFST)));
954 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
955 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
956 }
957
958 /*****************************************************************************/
959
960 static void open_sap(unsigned char type, struct net_device *dev)
961 {
962 int i;
963 struct tok_info *ti = netdev_priv(dev);
964
965 SET_PAGE(ti->srb_page);
966 for (i = 0; i < sizeof(struct dlc_open_sap); i++)
967 writeb(0, ti->srb + i);
968
969 #define MAX_I_FIELD_OFST 14
970 #define SAP_VALUE_OFST 16
971 #define SAP_OPTIONS_OFST 17
972 #define STATION_COUNT_OFST 18
973
974 writeb(DLC_OPEN_SAP, ti->srb + COMMAND_OFST);
975 writew(htons(MAX_I_FIELD), ti->srb + MAX_I_FIELD_OFST);
976 writeb(SAP_OPEN_IND_SAP | SAP_OPEN_PRIORITY, ti->srb+ SAP_OPTIONS_OFST);
977 writeb(SAP_OPEN_STATION_CNT, ti->srb + STATION_COUNT_OFST);
978 writeb(type, ti->srb + SAP_VALUE_OFST);
979 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
980 }
981
982
983 /*****************************************************************************/
984
985 static void tok_set_multicast_list(struct net_device *dev)
986 {
987 struct tok_info *ti = netdev_priv(dev);
988 struct dev_mc_list *mclist;
989 unsigned char address[4];
990
991 int i;
992
993 /*BMS the next line is CRUCIAL or you may be sad when you */
994 /*BMS ifconfig tr down or hot unplug a PCMCIA card ??hownowbrowncow*/
995 if (/*BMSHELPdev->start == 0 ||*/ ti->open_status != OPEN) return;
996 address[0] = address[1] = address[2] = address[3] = 0;
997 mclist = dev->mc_list;
998 for (i = 0; i < dev->mc_count; i++) {
999 address[0] |= mclist->dmi_addr[2];
1000 address[1] |= mclist->dmi_addr[3];
1001 address[2] |= mclist->dmi_addr[4];
1002 address[3] |= mclist->dmi_addr[5];
1003 mclist = mclist->next;
1004 }
1005 SET_PAGE(ti->srb_page);
1006 for (i = 0; i < sizeof(struct srb_set_funct_addr); i++)
1007 writeb(0, ti->srb + i);
1008
1009 #define FUNCT_ADDRESS_OFST 6
1010
1011 writeb(DIR_SET_FUNC_ADDR, ti->srb + COMMAND_OFST);
1012 for (i = 0; i < 4; i++)
1013 writeb(address[i], ti->srb + FUNCT_ADDRESS_OFST + i);
1014 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1015 #if TR_VERBOSE
1016 DPRINTK("Setting functional address: ");
1017 for (i=0;i<4;i++) printk("%02X ", address[i]);
1018 printk("\n");
1019 #endif
1020 }
1021
1022 /*****************************************************************************/
1023
1024 #define STATION_ID_OFST 4
1025
1026 static netdev_tx_t tok_send_packet(struct sk_buff *skb,
1027 struct net_device *dev)
1028 {
1029 struct tok_info *ti;
1030 unsigned long flags;
1031 ti = netdev_priv(dev);
1032
1033 netif_stop_queue(dev);
1034
1035 /* lock against other CPUs */
1036 spin_lock_irqsave(&(ti->lock), flags);
1037
1038 /* Save skb; we'll need it when the adapter asks for the data */
1039 ti->current_skb = skb;
1040 SET_PAGE(ti->srb_page);
1041 writeb(XMIT_UI_FRAME, ti->srb + COMMAND_OFST);
1042 writew(ti->exsap_station_id, ti->srb + STATION_ID_OFST);
1043 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1044 spin_unlock_irqrestore(&(ti->lock), flags);
1045 dev->trans_start = jiffies;
1046 return NETDEV_TX_OK;
1047 }
1048
1049 /*****************************************************************************/
1050
1051 static int tok_close(struct net_device *dev)
1052 {
1053 struct tok_info *ti = netdev_priv(dev);
1054
1055 /* Important for PCMCIA hot unplug, otherwise, we'll pull the card, */
1056 /* unloading the module from memory, and then if a timer pops, ouch */
1057 del_timer_sync(&ti->tr_timer);
1058 outb(0, dev->base_addr + ADAPTRESET);
1059 ti->sram_phys |= 1;
1060 ti->open_status = CLOSED;
1061
1062 netif_stop_queue(dev);
1063 DPRINTK("Adapter is closed.\n");
1064 return 0;
1065 }
1066
1067 /*****************************************************************************/
1068
1069 #define RETCODE_OFST 2
1070 #define OPEN_ERROR_CODE_OFST 6
1071 #define ASB_ADDRESS_OFST 8
1072 #define SRB_ADDRESS_OFST 10
1073 #define ARB_ADDRESS_OFST 12
1074 #define SSB_ADDRESS_OFST 14
1075
1076 static char *printphase[]= {"Lobe media test","Physical insertion",
1077 "Address verification","Roll call poll","Request Parameters"};
1078 static char *printerror[]={"Function failure","Signal loss","Reserved",
1079 "Frequency error","Timeout","Ring failure","Ring beaconing",
1080 "Duplicate node address",
1081 "Parameter request-retry count exceeded","Remove received",
1082 "IMPL force received","Duplicate modifier",
1083 "No monitor detected","Monitor contention failed for RPL"};
1084
1085 static void __iomem *map_address(struct tok_info *ti, unsigned index, __u8 *page)
1086 {
1087 if (ti->page_mask) {
1088 *page = (index >> 8) & ti->page_mask;
1089 index &= ~(ti->page_mask << 8);
1090 }
1091 return ti->sram_virt + index;
1092 }
1093
1094 static void dir_open_adapter (struct net_device *dev)
1095 {
1096 struct tok_info *ti = netdev_priv(dev);
1097 unsigned char ret_code;
1098 __u16 err;
1099
1100 ti->srb = map_address(ti,
1101 ntohs(readw(ti->init_srb + SRB_ADDRESS_OFST)),
1102 &ti->srb_page);
1103 ti->ssb = map_address(ti,
1104 ntohs(readw(ti->init_srb + SSB_ADDRESS_OFST)),
1105 &ti->ssb_page);
1106 ti->arb = map_address(ti,
1107 ntohs(readw(ti->init_srb + ARB_ADDRESS_OFST)),
1108 &ti->arb_page);
1109 ti->asb = map_address(ti,
1110 ntohs(readw(ti->init_srb + ASB_ADDRESS_OFST)),
1111 &ti->asb_page);
1112 ti->current_skb = NULL;
1113 ret_code = readb(ti->init_srb + RETCODE_OFST);
1114 err = ntohs(readw(ti->init_srb + OPEN_ERROR_CODE_OFST));
1115 if (!ret_code) {
1116 ti->open_status = OPEN; /* TR adapter is now available */
1117 if (ti->open_mode == AUTOMATIC) {
1118 DPRINTK("Adapter reopened.\n");
1119 }
1120 writeb(~SRB_RESP_INT, ti->mmio+ACA_OFFSET+ACA_RESET+ISRP_ODD);
1121 open_sap(EXTENDED_SAP, dev);
1122 return;
1123 }
1124 ti->open_failure = YES;
1125 if (ret_code == 7){
1126 if (err == 0x24) {
1127 if (!ti->auto_speedsave) {
1128 DPRINTK("Open failed: Adapter speed must match "
1129 "ring speed if Automatic Ring Speed Save is "
1130 "disabled.\n");
1131 ti->open_action = FAIL;
1132 }else
1133 DPRINTK("Retrying open to adjust to "
1134 "ring speed, ");
1135 } else if (err == 0x2d) {
1136 DPRINTK("Physical Insertion: No Monitor Detected, ");
1137 printk("retrying after %ds delay...\n",
1138 TR_RETRY_INTERVAL/HZ);
1139 } else if (err == 0x11) {
1140 DPRINTK("Lobe Media Function Failure (0x11), ");
1141 printk(" retrying after %ds delay...\n",
1142 TR_RETRY_INTERVAL/HZ);
1143 } else {
1144 char **prphase = printphase;
1145 char **prerror = printerror;
1146 DPRINTK("TR Adapter misc open failure, error code = ");
1147 printk("0x%x, Phase: %s, Error: %s\n",
1148 err, prphase[err/16 -1], prerror[err%16 -1]);
1149 printk(" retrying after %ds delay...\n",
1150 TR_RETRY_INTERVAL/HZ);
1151 }
1152 } else DPRINTK("open failed: ret_code = %02X..., ", ret_code);
1153 if (ti->open_action != FAIL) {
1154 if (ti->open_mode==AUTOMATIC){
1155 ti->open_action = REOPEN;
1156 ibmtr_reset_timer(&(ti->tr_timer), dev);
1157 return;
1158 }
1159 wake_up(&ti->wait_for_reset);
1160 return;
1161 }
1162 DPRINTK("FAILURE, CAPUT\n");
1163 }
1164
1165 /******************************************************************************/
1166
1167 static irqreturn_t tok_interrupt(int irq, void *dev_id)
1168 {
1169 unsigned char status;
1170 /* unsigned char status_even ; */
1171 struct tok_info *ti;
1172 struct net_device *dev;
1173 #ifdef ENABLE_PAGING
1174 unsigned char save_srpr;
1175 #endif
1176
1177 dev = dev_id;
1178 #if TR_VERBOSE
1179 DPRINTK("Int from tok_driver, dev : %p irq%d\n", dev,irq);
1180 #endif
1181 ti = netdev_priv(dev);
1182 if (ti->sram_phys & 1)
1183 return IRQ_NONE; /* PCMCIA card extraction flag */
1184 spin_lock(&(ti->lock));
1185 #ifdef ENABLE_PAGING
1186 save_srpr = readb(ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1187 #endif
1188
1189 /* Disable interrupts till processing is finished */
1190 writeb((~INT_ENABLE), ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1191
1192 /* Reset interrupt for ISA boards */
1193 if (ti->adapter_int_enable)
1194 outb(0, ti->adapter_int_enable);
1195 else /* used for PCMCIA cards */
1196 outb(0, ti->global_int_enable);
1197 if (ti->do_tok_int == FIRST_INT){
1198 initial_tok_int(dev);
1199 #ifdef ENABLE_PAGING
1200 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1201 #endif
1202 spin_unlock(&(ti->lock));
1203 return IRQ_HANDLED;
1204 }
1205 /* Begin interrupt handler HERE inline to avoid the extra
1206 levels of logic and call depth for the original solution. */
1207 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_ODD);
1208 /*BMSstatus_even = readb (ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN) */
1209 /*BMSdebugprintk("tok_interrupt: ISRP_ODD = 0x%x ISRP_EVEN = 0x%x\n", */
1210 /*BMS status,status_even); */
1211
1212 if (status & ADAP_CHK_INT) {
1213 int i;
1214 void __iomem *check_reason;
1215 __u8 check_reason_page = 0;
1216 check_reason = map_address(ti,
1217 ntohs(readw(ti->mmio+ ACA_OFFSET+ACA_RW + WWCR_EVEN)),
1218 &check_reason_page);
1219 SET_PAGE(check_reason_page);
1220
1221 DPRINTK("Adapter check interrupt\n");
1222 DPRINTK("8 reason bytes follow: ");
1223 for (i = 0; i < 8; i++, check_reason++)
1224 printk("%02X ", (int) readb(check_reason));
1225 printk("\n");
1226 writeb(~ADAP_CHK_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1227 status = readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRA_EVEN);
1228 DPRINTK("ISRA_EVEN == 0x02%x\n",status);
1229 ti->open_status = CLOSED;
1230 ti->sap_status = CLOSED;
1231 ti->open_mode = AUTOMATIC;
1232 netif_carrier_off(dev);
1233 netif_stop_queue(dev);
1234 ti->open_action = RESTART;
1235 outb(0, dev->base_addr + ADAPTRESET);
1236 ibmtr_reset_timer(&(ti->tr_timer), dev);/*BMS try to reopen*/
1237 spin_unlock(&(ti->lock));
1238 return IRQ_HANDLED;
1239 }
1240 if (readb(ti->mmio + ACA_OFFSET + ACA_RW + ISRP_EVEN)
1241 & (TCR_INT | ERR_INT | ACCESS_INT)) {
1242 DPRINTK("adapter error: ISRP_EVEN : %02x\n",
1243 (int)readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRP_EVEN));
1244 writeb(~(TCR_INT | ERR_INT | ACCESS_INT),
1245 ti->mmio + ACA_OFFSET + ACA_RESET + ISRP_EVEN);
1246 status= readb(ti->mmio+ ACA_OFFSET + ACA_RW + ISRA_EVEN);/*BMS*/
1247 DPRINTK("ISRA_EVEN == 0x02%x\n",status);/*BMS*/
1248 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1249 #ifdef ENABLE_PAGING
1250 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1251 #endif
1252 spin_unlock(&(ti->lock));
1253 return IRQ_HANDLED;
1254 }
1255 if (status & SRB_RESP_INT) { /* SRB response */
1256 SET_PAGE(ti->srb_page);
1257 #if TR_VERBOSE
1258 DPRINTK("SRB resp: cmd=%02X rsp=%02X\n",
1259 readb(ti->srb), readb(ti->srb + RETCODE_OFST));
1260 #endif
1261 switch (readb(ti->srb)) { /* SRB command check */
1262 case XMIT_DIR_FRAME:{
1263 unsigned char xmit_ret_code;
1264 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1265 if (xmit_ret_code == 0xff) break;
1266 DPRINTK("error on xmit_dir_frame request: %02X\n",
1267 xmit_ret_code);
1268 if (ti->current_skb) {
1269 dev_kfree_skb_irq(ti->current_skb);
1270 ti->current_skb = NULL;
1271 }
1272 /*dev->tbusy = 0;*/
1273 netif_wake_queue(dev);
1274 if (ti->readlog_pending)
1275 ibmtr_readlog(dev);
1276 break;
1277 }
1278 case XMIT_UI_FRAME:{
1279 unsigned char xmit_ret_code;
1280
1281 xmit_ret_code = readb(ti->srb + RETCODE_OFST);
1282 if (xmit_ret_code == 0xff) break;
1283 DPRINTK("error on xmit_ui_frame request: %02X\n",
1284 xmit_ret_code);
1285 if (ti->current_skb) {
1286 dev_kfree_skb_irq(ti->current_skb);
1287 ti->current_skb = NULL;
1288 }
1289 netif_wake_queue(dev);
1290 if (ti->readlog_pending)
1291 ibmtr_readlog(dev);
1292 break;
1293 }
1294 case DIR_OPEN_ADAPTER:
1295 dir_open_adapter(dev);
1296 break;
1297 case DLC_OPEN_SAP:
1298 if (readb(ti->srb + RETCODE_OFST)) {
1299 DPRINTK("open_sap failed: ret_code = %02X, "
1300 "retrying\n",
1301 (int) readb(ti->srb + RETCODE_OFST));
1302 ti->open_action = REOPEN;
1303 ibmtr_reset_timer(&(ti->tr_timer), dev);
1304 break;
1305 }
1306 ti->exsap_station_id = readw(ti->srb + STATION_ID_OFST);
1307 ti->sap_status = OPEN;/* TR adapter is now available */
1308 if (ti->open_mode==MANUAL){
1309 wake_up(&ti->wait_for_reset);
1310 break;
1311 }
1312 netif_wake_queue(dev);
1313 netif_carrier_on(dev);
1314 break;
1315 case DIR_INTERRUPT:
1316 case DIR_MOD_OPEN_PARAMS:
1317 case DIR_SET_GRP_ADDR:
1318 case DIR_SET_FUNC_ADDR:
1319 case DLC_CLOSE_SAP:
1320 if (readb(ti->srb + RETCODE_OFST))
1321 DPRINTK("error on %02X: %02X\n",
1322 (int) readb(ti->srb + COMMAND_OFST),
1323 (int) readb(ti->srb + RETCODE_OFST));
1324 break;
1325 case DIR_READ_LOG:
1326 if (readb(ti->srb + RETCODE_OFST)){
1327 DPRINTK("error on dir_read_log: %02X\n",
1328 (int) readb(ti->srb + RETCODE_OFST));
1329 netif_wake_queue(dev);
1330 break;
1331 }
1332 #if IBMTR_DEBUG_MESSAGES
1333
1334 #define LINE_ERRORS_OFST 0
1335 #define INTERNAL_ERRORS_OFST 1
1336 #define BURST_ERRORS_OFST 2
1337 #define AC_ERRORS_OFST 3
1338 #define ABORT_DELIMITERS_OFST 4
1339 #define LOST_FRAMES_OFST 6
1340 #define RECV_CONGEST_COUNT_OFST 7
1341 #define FRAME_COPIED_ERRORS_OFST 8
1342 #define FREQUENCY_ERRORS_OFST 9
1343 #define TOKEN_ERRORS_OFST 10
1344
1345 DPRINTK("Line errors %02X, Internal errors %02X, "
1346 "Burst errors %02X\n" "A/C errors %02X, "
1347 "Abort delimiters %02X, Lost frames %02X\n"
1348 "Receive congestion count %02X, "
1349 "Frame copied errors %02X\nFrequency errors %02X, "
1350 "Token errors %02X\n",
1351 (int) readb(ti->srb + LINE_ERRORS_OFST),
1352 (int) readb(ti->srb + INTERNAL_ERRORS_OFST),
1353 (int) readb(ti->srb + BURST_ERRORS_OFST),
1354 (int) readb(ti->srb + AC_ERRORS_OFST),
1355 (int) readb(ti->srb + ABORT_DELIMITERS_OFST),
1356 (int) readb(ti->srb + LOST_FRAMES_OFST),
1357 (int) readb(ti->srb + RECV_CONGEST_COUNT_OFST),
1358 (int) readb(ti->srb + FRAME_COPIED_ERRORS_OFST),
1359 (int) readb(ti->srb + FREQUENCY_ERRORS_OFST),
1360 (int) readb(ti->srb + TOKEN_ERRORS_OFST));
1361 #endif
1362 netif_wake_queue(dev);
1363 break;
1364 default:
1365 DPRINTK("Unknown command %02X encountered\n",
1366 (int) readb(ti->srb));
1367 } /* end switch SRB command check */
1368 writeb(~SRB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1369 } /* if SRB response */
1370 if (status & ASB_FREE_INT) { /* ASB response */
1371 SET_PAGE(ti->asb_page);
1372 #if TR_VERBOSE
1373 DPRINTK("ASB resp: cmd=%02X\n", readb(ti->asb));
1374 #endif
1375
1376 switch (readb(ti->asb)) { /* ASB command check */
1377 case REC_DATA:
1378 case XMIT_UI_FRAME:
1379 case XMIT_DIR_FRAME:
1380 break;
1381 default:
1382 DPRINTK("unknown command in asb %02X\n",
1383 (int) readb(ti->asb));
1384 } /* switch ASB command check */
1385 if (readb(ti->asb + 2) != 0xff) /* checks ret_code */
1386 DPRINTK("ASB error %02X in cmd %02X\n",
1387 (int) readb(ti->asb + 2), (int) readb(ti->asb));
1388 writeb(~ASB_FREE_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1389 } /* if ASB response */
1390
1391 #define STATUS_OFST 6
1392 #define NETW_STATUS_OFST 6
1393
1394 if (status & ARB_CMD_INT) { /* ARB response */
1395 SET_PAGE(ti->arb_page);
1396 #if TR_VERBOSE
1397 DPRINTK("ARB resp: cmd=%02X\n", readb(ti->arb));
1398 #endif
1399
1400 switch (readb(ti->arb)) { /* ARB command check */
1401 case DLC_STATUS:
1402 DPRINTK("DLC_STATUS new status: %02X on station %02X\n",
1403 ntohs(readw(ti->arb + STATUS_OFST)),
1404 ntohs(readw(ti->arb+ STATION_ID_OFST)));
1405 break;
1406 case REC_DATA:
1407 tr_rx(dev);
1408 break;
1409 case RING_STAT_CHANGE:{
1410 unsigned short ring_status;
1411 ring_status= ntohs(readw(ti->arb + NETW_STATUS_OFST));
1412 if (ibmtr_debug_trace & TRC_INIT)
1413 DPRINTK("Ring Status Change...(0x%x)\n",
1414 ring_status);
1415 if(ring_status& (REMOVE_RECV|AUTO_REMOVAL|LOBE_FAULT)){
1416 netif_stop_queue(dev);
1417 netif_carrier_off(dev);
1418 DPRINTK("Remove received, or Auto-removal error"
1419 ", or Lobe fault\n");
1420 DPRINTK("We'll try to reopen the closed adapter"
1421 " after a %d second delay.\n",
1422 TR_RETRY_INTERVAL/HZ);
1423 /*I was confused: I saw the TR reopening but */
1424 /*forgot:with an RJ45 in an RJ45/ICS adapter */
1425 /*but adapter not in the ring, the TR will */
1426 /* open, and then soon close and come here. */
1427 ti->open_mode = AUTOMATIC;
1428 ti->open_status = CLOSED; /*12/2000 BMS*/
1429 ti->open_action = REOPEN;
1430 ibmtr_reset_timer(&(ti->tr_timer), dev);
1431 } else if (ring_status & LOG_OVERFLOW) {
1432 if(netif_queue_stopped(dev))
1433 ti->readlog_pending = 1;
1434 else
1435 ibmtr_readlog(dev);
1436 }
1437 break;
1438 }
1439 case XMIT_DATA_REQ:
1440 tr_tx(dev);
1441 break;
1442 default:
1443 DPRINTK("Unknown command %02X in arb\n",
1444 (int) readb(ti->arb));
1445 break;
1446 } /* switch ARB command check */
1447 writeb(~ARB_CMD_INT, ti->mmio+ ACA_OFFSET+ACA_RESET + ISRP_ODD);
1448 writeb(ARB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1449 } /* if ARB response */
1450 if (status & SSB_RESP_INT) { /* SSB response */
1451 unsigned char retcode;
1452 SET_PAGE(ti->ssb_page);
1453 #if TR_VERBOSE
1454 DPRINTK("SSB resp: cmd=%02X rsp=%02X\n",
1455 readb(ti->ssb), readb(ti->ssb + 2));
1456 #endif
1457
1458 switch (readb(ti->ssb)) { /* SSB command check */
1459 case XMIT_DIR_FRAME:
1460 case XMIT_UI_FRAME:
1461 retcode = readb(ti->ssb + 2);
1462 if (retcode && (retcode != 0x22))/* checks ret_code */
1463 DPRINTK("xmit ret_code: %02X xmit error code: "
1464 "%02X\n",
1465 (int)retcode, (int)readb(ti->ssb + 6));
1466 else
1467 dev->stats.tx_packets++;
1468 break;
1469 case XMIT_XID_CMD:
1470 DPRINTK("xmit xid ret_code: %02X\n",
1471 (int) readb(ti->ssb + 2));
1472 default:
1473 DPRINTK("Unknown command %02X in ssb\n",
1474 (int) readb(ti->ssb));
1475 } /* SSB command check */
1476 writeb(~SSB_RESP_INT, ti->mmio+ ACA_OFFSET+ACA_RESET+ ISRP_ODD);
1477 writeb(SSB_FREE, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1478 } /* if SSB response */
1479 #ifdef ENABLE_PAGING
1480 writeb(save_srpr, ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1481 #endif
1482 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1483 spin_unlock(&(ti->lock));
1484 return IRQ_HANDLED;
1485 } /*tok_interrupt */
1486
1487 /*****************************************************************************/
1488
1489 #define INIT_STATUS_OFST 1
1490 #define INIT_STATUS_2_OFST 2
1491 #define ENCODED_ADDRESS_OFST 8
1492
1493 static void initial_tok_int(struct net_device *dev)
1494 {
1495
1496 __u32 encoded_addr, hw_encoded_addr;
1497 struct tok_info *ti;
1498 unsigned char init_status; /*BMS 12/2000*/
1499
1500 ti = netdev_priv(dev);
1501
1502 ti->do_tok_int = NOT_FIRST;
1503
1504 /* we assign the shared-ram address for ISA devices */
1505 writeb(ti->sram_base, ti->mmio + ACA_OFFSET + ACA_RW + RRR_EVEN);
1506 #ifndef PCMCIA
1507 ti->sram_virt = ioremap(((__u32)ti->sram_base << 12), ti->avail_shared_ram);
1508 #endif
1509 ti->init_srb = map_address(ti,
1510 ntohs(readw(ti->mmio + ACA_OFFSET + WRBR_EVEN)),
1511 &ti->init_srb_page);
1512 if (ti->page_mask && ti->avail_shared_ram == 127) {
1513 void __iomem *last_512;
1514 __u8 last_512_page=0;
1515 int i;
1516 last_512 = map_address(ti, 0xfe00, &last_512_page);
1517 /* initialize high section of ram (if necessary) */
1518 SET_PAGE(last_512_page);
1519 for (i = 0; i < 512; i++)
1520 writeb(0, last_512 + i);
1521 }
1522 SET_PAGE(ti->init_srb_page);
1523
1524 #if TR_VERBOSE
1525 {
1526 int i;
1527
1528 DPRINTK("ti->init_srb_page=0x%x\n", ti->init_srb_page);
1529 DPRINTK("init_srb(%p):", ti->init_srb );
1530 for (i = 0; i < 20; i++)
1531 printk("%02X ", (int) readb(ti->init_srb + i));
1532 printk("\n");
1533 }
1534 #endif
1535
1536 hw_encoded_addr = readw(ti->init_srb + ENCODED_ADDRESS_OFST);
1537 encoded_addr = ntohs(hw_encoded_addr);
1538 init_status= /*BMS 12/2000 check for shallow mode possibility (Turbo)*/
1539 readb(ti->init_srb+offsetof(struct srb_init_response,init_status));
1540 /*printk("Initial interrupt: init_status= 0x%02x\n",init_status);*/
1541 ti->ring_speed = init_status & 0x01 ? 16 : 4;
1542 DPRINTK("Initial interrupt : %d Mbps, shared RAM base %08x.\n",
1543 ti->ring_speed, (unsigned int)dev->mem_start);
1544 ti->auto_speedsave = (readb(ti->init_srb+INIT_STATUS_2_OFST) & 4) != 0;
1545
1546 if (ti->open_mode == MANUAL) wake_up(&ti->wait_for_reset);
1547 else tok_open_adapter((unsigned long)dev);
1548
1549 } /*initial_tok_int() */
1550
1551 /*****************************************************************************/
1552
1553 #define CMD_CORRELATE_OFST 1
1554 #define DHB_ADDRESS_OFST 6
1555
1556 #define FRAME_LENGTH_OFST 6
1557 #define HEADER_LENGTH_OFST 8
1558 #define RSAP_VALUE_OFST 9
1559
1560 static void tr_tx(struct net_device *dev)
1561 {
1562 struct tok_info *ti = netdev_priv(dev);
1563 struct trh_hdr *trhdr = (struct trh_hdr *) ti->current_skb->data;
1564 unsigned int hdr_len;
1565 __u32 dhb=0,dhb_base;
1566 void __iomem *dhbuf = NULL;
1567 unsigned char xmit_command;
1568 int i,dhb_len=0x4000,src_len,src_offset;
1569 struct trllc *llc;
1570 struct srb_xmit xsrb;
1571 __u8 dhb_page = 0;
1572 __u8 llc_ssap;
1573
1574 SET_PAGE(ti->asb_page);
1575
1576 if (readb(ti->asb+RETCODE_OFST) != 0xFF) DPRINTK("ASB not free !!!\n");
1577
1578 /* in providing the transmit interrupts, is telling us it is ready for
1579 data and providing a shared memory address for us to stuff with data.
1580 Here we compute the effective address where we will place data.
1581 */
1582 SET_PAGE(ti->arb_page);
1583 dhb=dhb_base=ntohs(readw(ti->arb + DHB_ADDRESS_OFST));
1584 if (ti->page_mask) {
1585 dhb_page = (dhb_base >> 8) & ti->page_mask;
1586 dhb=dhb_base & ~(ti->page_mask << 8);
1587 }
1588 dhbuf = ti->sram_virt + dhb;
1589
1590 /* Figure out the size of the 802.5 header */
1591 if (!(trhdr->saddr[0] & 0x80)) /* RIF present? */
1592 hdr_len = sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1593 else
1594 hdr_len = ((ntohs(trhdr->rcf) & TR_RCF_LEN_MASK) >> 8)
1595 + sizeof(struct trh_hdr) - TR_MAXRIFLEN;
1596
1597 llc = (struct trllc *) (ti->current_skb->data + hdr_len);
1598
1599 llc_ssap = llc->ssap;
1600 SET_PAGE(ti->srb_page);
1601 memcpy_fromio(&xsrb, ti->srb, sizeof(xsrb));
1602 SET_PAGE(ti->asb_page);
1603 xmit_command = xsrb.command;
1604
1605 writeb(xmit_command, ti->asb + COMMAND_OFST);
1606 writew(xsrb.station_id, ti->asb + STATION_ID_OFST);
1607 writeb(llc_ssap, ti->asb + RSAP_VALUE_OFST);
1608 writeb(xsrb.cmd_corr, ti->asb + CMD_CORRELATE_OFST);
1609 writeb(0, ti->asb + RETCODE_OFST);
1610 if ((xmit_command == XMIT_XID_CMD) || (xmit_command == XMIT_TEST_CMD)) {
1611 writew(htons(0x11), ti->asb + FRAME_LENGTH_OFST);
1612 writeb(0x0e, ti->asb + HEADER_LENGTH_OFST);
1613 SET_PAGE(dhb_page);
1614 writeb(AC, dhbuf);
1615 writeb(LLC_FRAME, dhbuf + 1);
1616 for (i = 0; i < TR_ALEN; i++)
1617 writeb((int) 0x0FF, dhbuf + i + 2);
1618 for (i = 0; i < TR_ALEN; i++)
1619 writeb(0, dhbuf + i + TR_ALEN + 2);
1620 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1621 return;
1622 }
1623 /*
1624 * the token ring packet is copied from sk_buff to the adapter
1625 * buffer identified in the command data received with the interrupt.
1626 */
1627 writeb(hdr_len, ti->asb + HEADER_LENGTH_OFST);
1628 writew(htons(ti->current_skb->len), ti->asb + FRAME_LENGTH_OFST);
1629 src_len=ti->current_skb->len;
1630 src_offset=0;
1631 dhb=dhb_base;
1632 while(1) {
1633 if (ti->page_mask) {
1634 dhb_page=(dhb >> 8) & ti->page_mask;
1635 dhb=dhb & ~(ti->page_mask << 8);
1636 dhb_len=0x4000-dhb; /* remaining size of this page */
1637 }
1638 dhbuf = ti->sram_virt + dhb;
1639 SET_PAGE(dhb_page);
1640 if (src_len > dhb_len) {
1641 memcpy_toio(dhbuf,&ti->current_skb->data[src_offset],
1642 dhb_len);
1643 src_len -= dhb_len;
1644 src_offset += dhb_len;
1645 dhb_base+=dhb_len;
1646 dhb=dhb_base;
1647 continue;
1648 }
1649 memcpy_toio(dhbuf, &ti->current_skb->data[src_offset], src_len);
1650 break;
1651 }
1652 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1653 dev->stats.tx_bytes += ti->current_skb->len;
1654 dev_kfree_skb_irq(ti->current_skb);
1655 ti->current_skb = NULL;
1656 netif_wake_queue(dev);
1657 if (ti->readlog_pending)
1658 ibmtr_readlog(dev);
1659 } /*tr_tx */
1660
1661 /*****************************************************************************/
1662
1663
1664 #define RECEIVE_BUFFER_OFST 6
1665 #define LAN_HDR_LENGTH_OFST 8
1666 #define DLC_HDR_LENGTH_OFST 9
1667
1668 #define DSAP_OFST 0
1669 #define SSAP_OFST 1
1670 #define LLC_OFST 2
1671 #define PROTID_OFST 3
1672 #define ETHERTYPE_OFST 6
1673
1674 static void tr_rx(struct net_device *dev)
1675 {
1676 struct tok_info *ti = netdev_priv(dev);
1677 __u32 rbuffer;
1678 void __iomem *rbuf, *rbufdata, *llc;
1679 __u8 rbuffer_page = 0;
1680 unsigned char *data;
1681 unsigned int rbuffer_len, lan_hdr_len, hdr_len, ip_len, length;
1682 unsigned char dlc_hdr_len;
1683 struct sk_buff *skb;
1684 unsigned int skb_size = 0;
1685 int IPv4_p = 0;
1686 unsigned int chksum = 0;
1687 struct iphdr *iph;
1688 struct arb_rec_req rarb;
1689
1690 SET_PAGE(ti->arb_page);
1691 memcpy_fromio(&rarb, ti->arb, sizeof(rarb));
1692 rbuffer = ntohs(rarb.rec_buf_addr) ;
1693 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1694
1695 SET_PAGE(ti->asb_page);
1696
1697 if (readb(ti->asb + RETCODE_OFST) !=0xFF) DPRINTK("ASB not free !!!\n");
1698
1699 writeb(REC_DATA, ti->asb + COMMAND_OFST);
1700 writew(rarb.station_id, ti->asb + STATION_ID_OFST);
1701 writew(rarb.rec_buf_addr, ti->asb + RECEIVE_BUFFER_OFST);
1702
1703 lan_hdr_len = rarb.lan_hdr_len;
1704 if (lan_hdr_len > sizeof(struct trh_hdr)) {
1705 DPRINTK("Linux cannot handle greater than 18 bytes RIF\n");
1706 return;
1707 } /*BMS I added this above just to be very safe */
1708 dlc_hdr_len = readb(ti->arb + DLC_HDR_LENGTH_OFST);
1709 hdr_len = lan_hdr_len + sizeof(struct trllc) + sizeof(struct iphdr);
1710
1711 SET_PAGE(rbuffer_page);
1712 llc = rbuf + offsetof(struct rec_buf, data) + lan_hdr_len;
1713
1714 #if TR_VERBOSE
1715 DPRINTK("offsetof data: %02X lan_hdr_len: %02X\n",
1716 (__u32) offsetof(struct rec_buf, data), (unsigned int) lan_hdr_len);
1717 DPRINTK("llc: %08X rec_buf_addr: %04X dev->mem_start: %lX\n",
1718 llc, ntohs(rarb.rec_buf_addr), dev->mem_start);
1719 DPRINTK("dsap: %02X, ssap: %02X, llc: %02X, protid: %02X%02X%02X, "
1720 "ethertype: %04X\n",
1721 (int) readb(llc + DSAP_OFST), (int) readb(llc + SSAP_OFST),
1722 (int) readb(llc + LLC_OFST), (int) readb(llc + PROTID_OFST),
1723 (int) readb(llc+PROTID_OFST+1),(int)readb(llc+PROTID_OFST + 2),
1724 (int) ntohs(readw(llc + ETHERTYPE_OFST)));
1725 #endif
1726 if (readb(llc + offsetof(struct trllc, llc)) != UI_CMD) {
1727 SET_PAGE(ti->asb_page);
1728 writeb(DATA_LOST, ti->asb + RETCODE_OFST);
1729 dev->stats.rx_dropped++;
1730 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1731 return;
1732 }
1733 length = ntohs(rarb.frame_len);
1734 if (readb(llc + DSAP_OFST) == EXTENDED_SAP &&
1735 readb(llc + SSAP_OFST) == EXTENDED_SAP &&
1736 length >= hdr_len) IPv4_p = 1;
1737 #if TR_VERBOSE
1738 #define SADDR_OFST 8
1739 #define DADDR_OFST 2
1740
1741 if (!IPv4_p) {
1742
1743 void __iomem *trhhdr = rbuf + offsetof(struct rec_buf, data);
1744 u8 saddr[6];
1745 u8 daddr[6];
1746 int i;
1747 for (i = 0 ; i < 6 ; i++)
1748 saddr[i] = readb(trhhdr + SADDR_OFST + i);
1749 for (i = 0 ; i < 6 ; i++)
1750 daddr[i] = readb(trhhdr + DADDR_OFST + i);
1751 DPRINTK("Probably non-IP frame received.\n");
1752 DPRINTK("ssap: %02X dsap: %02X "
1753 "saddr: %pM daddr: %pM\n",
1754 readb(llc + SSAP_OFST), readb(llc + DSAP_OFST),
1755 saddr, daddr);
1756 }
1757 #endif
1758
1759 /*BMS handle the case she comes in with few hops but leaves with many */
1760 skb_size=length-lan_hdr_len+sizeof(struct trh_hdr)+sizeof(struct trllc);
1761
1762 if (!(skb = dev_alloc_skb(skb_size))) {
1763 DPRINTK("out of memory. frame dropped.\n");
1764 dev->stats.rx_dropped++;
1765 SET_PAGE(ti->asb_page);
1766 writeb(DATA_LOST, ti->asb + offsetof(struct asb_rec, ret_code));
1767 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1768 return;
1769 }
1770 /*BMS again, if she comes in with few but leaves with many */
1771 skb_reserve(skb, sizeof(struct trh_hdr) - lan_hdr_len);
1772 skb_put(skb, length);
1773 data = skb->data;
1774 rbuffer_len = ntohs(readw(rbuf + offsetof(struct rec_buf, buf_len)));
1775 rbufdata = rbuf + offsetof(struct rec_buf, data);
1776
1777 if (IPv4_p) {
1778 /* Copy the headers without checksumming */
1779 memcpy_fromio(data, rbufdata, hdr_len);
1780
1781 /* Watch for padded packets and bogons */
1782 iph= (struct iphdr *)(data+ lan_hdr_len + sizeof(struct trllc));
1783 ip_len = ntohs(iph->tot_len) - sizeof(struct iphdr);
1784 length -= hdr_len;
1785 if ((ip_len <= length) && (ip_len > 7))
1786 length = ip_len;
1787 data += hdr_len;
1788 rbuffer_len -= hdr_len;
1789 rbufdata += hdr_len;
1790 }
1791 /* Copy the payload... */
1792 #define BUFFER_POINTER_OFST 2
1793 #define BUFFER_LENGTH_OFST 6
1794 for (;;) {
1795 if (ibmtr_debug_trace&TRC_INITV && length < rbuffer_len)
1796 DPRINTK("CURIOUS, length=%d < rbuffer_len=%d\n",
1797 length,rbuffer_len);
1798 if (IPv4_p)
1799 chksum=csum_partial_copy_nocheck((void*)rbufdata,
1800 data,length<rbuffer_len?length:rbuffer_len,chksum);
1801 else
1802 memcpy_fromio(data, rbufdata, rbuffer_len);
1803 rbuffer = ntohs(readw(rbuf+BUFFER_POINTER_OFST)) ;
1804 if (!rbuffer)
1805 break;
1806 rbuffer -= 2;
1807 length -= rbuffer_len;
1808 data += rbuffer_len;
1809 rbuf = map_address(ti, rbuffer, &rbuffer_page);
1810 SET_PAGE(rbuffer_page);
1811 rbuffer_len = ntohs(readw(rbuf + BUFFER_LENGTH_OFST));
1812 rbufdata = rbuf + offsetof(struct rec_buf, data);
1813 }
1814
1815 SET_PAGE(ti->asb_page);
1816 writeb(0, ti->asb + offsetof(struct asb_rec, ret_code));
1817
1818 writeb(RESP_IN_ASB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1819
1820 dev->stats.rx_bytes += skb->len;
1821 dev->stats.rx_packets++;
1822
1823 skb->protocol = tr_type_trans(skb, dev);
1824 if (IPv4_p) {
1825 skb->csum = chksum;
1826 skb->ip_summed = CHECKSUM_COMPLETE;
1827 }
1828 netif_rx(skb);
1829 } /*tr_rx */
1830
1831 /*****************************************************************************/
1832
1833 static void ibmtr_reset_timer(struct timer_list *tmr, struct net_device *dev)
1834 {
1835 tmr->expires = jiffies + TR_RETRY_INTERVAL;
1836 tmr->data = (unsigned long) dev;
1837 tmr->function = tok_rerun;
1838 init_timer(tmr);
1839 add_timer(tmr);
1840 }
1841
1842 /*****************************************************************************/
1843
1844 static void tok_rerun(unsigned long dev_addr)
1845 {
1846 struct net_device *dev = (struct net_device *)dev_addr;
1847 struct tok_info *ti = netdev_priv(dev);
1848
1849 if ( ti->open_action == RESTART){
1850 ti->do_tok_int = FIRST_INT;
1851 outb(0, dev->base_addr + ADAPTRESETREL);
1852 #ifdef ENABLE_PAGING
1853 if (ti->page_mask)
1854 writeb(SRPR_ENABLE_PAGING,
1855 ti->mmio + ACA_OFFSET + ACA_RW + SRPR_EVEN);
1856 #endif
1857
1858 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1859 } else
1860 tok_open_adapter(dev_addr);
1861 }
1862
1863 /*****************************************************************************/
1864
1865 static void ibmtr_readlog(struct net_device *dev)
1866 {
1867 struct tok_info *ti;
1868
1869 ti = netdev_priv(dev);
1870
1871 ti->readlog_pending = 0;
1872 SET_PAGE(ti->srb_page);
1873 writeb(DIR_READ_LOG, ti->srb);
1874 writeb(INT_ENABLE, ti->mmio + ACA_OFFSET + ACA_SET + ISRP_EVEN);
1875 writeb(CMD_IN_SRB, ti->mmio + ACA_OFFSET + ACA_SET + ISRA_ODD);
1876
1877 netif_stop_queue(dev);
1878
1879 }
1880
1881 /*****************************************************************************/
1882
1883 static int ibmtr_change_mtu(struct net_device *dev, int mtu)
1884 {
1885 struct tok_info *ti = netdev_priv(dev);
1886
1887 if (ti->ring_speed == 16 && mtu > ti->maxmtu16)
1888 return -EINVAL;
1889 if (ti->ring_speed == 4 && mtu > ti->maxmtu4)
1890 return -EINVAL;
1891 dev->mtu = mtu;
1892 return 0;
1893 }
1894
1895 /*****************************************************************************/
1896 #ifdef MODULE
1897
1898 /* 3COM 3C619C supports 8 interrupts, 32 I/O ports */
1899 static struct net_device *dev_ibmtr[IBMTR_MAX_ADAPTERS];
1900 static int io[IBMTR_MAX_ADAPTERS] = { 0xa20, 0xa24 };
1901 static int irq[IBMTR_MAX_ADAPTERS];
1902 static int mem[IBMTR_MAX_ADAPTERS];
1903
1904 MODULE_LICENSE("GPL");
1905
1906 module_param_array(io, int, NULL, 0);
1907 module_param_array(irq, int, NULL, 0);
1908 module_param_array(mem, int, NULL, 0);
1909
1910 static int __init ibmtr_init(void)
1911 {
1912 int i;
1913 int count=0;
1914
1915 find_turbo_adapters(io);
1916
1917 for (i = 0; i < IBMTR_MAX_ADAPTERS && io[i]; i++) {
1918 struct net_device *dev;
1919 irq[i] = 0;
1920 mem[i] = 0;
1921 dev = alloc_trdev(sizeof(struct tok_info));
1922 if (dev == NULL) {
1923 if (i == 0)
1924 return -ENOMEM;
1925 break;
1926 }
1927 dev->base_addr = io[i];
1928 dev->irq = irq[i];
1929 dev->mem_start = mem[i];
1930
1931 if (ibmtr_probe_card(dev)) {
1932 free_netdev(dev);
1933 continue;
1934 }
1935 dev_ibmtr[i] = dev;
1936 count++;
1937 }
1938 if (count) return 0;
1939 printk("ibmtr: register_netdev() returned non-zero.\n");
1940 return -EIO;
1941 }
1942 module_init(ibmtr_init);
1943
1944 static void __exit ibmtr_cleanup(void)
1945 {
1946 int i;
1947
1948 for (i = 0; i < IBMTR_MAX_ADAPTERS; i++){
1949 if (!dev_ibmtr[i])
1950 continue;
1951 unregister_netdev(dev_ibmtr[i]);
1952 ibmtr_cleanup_card(dev_ibmtr[i]);
1953 free_netdev(dev_ibmtr[i]);
1954 }
1955 }
1956 module_exit(ibmtr_cleanup);
1957 #endif
Linux with added FPC-III support