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

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