git.oblomov.eu Git - linux-2.6/blob - drivers/net/tokenring/ibmtr.c

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