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