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