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