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