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