drivers/net/tokenring/ibmtr.c

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