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