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