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

   1 /*
   2  *   olympic.c (c) 1999 Peter De Schrijver All Rights Reserved
   3  *                 1999/2000 Mike Phillips (mikep@linuxtr.net)
   4  *
   5  *  Linux driver for IBM PCI tokenring cards based on the Pit/Pit-Phy/Olympic
   6  *  chipset.
   7  *
   8  *  Base Driver Skeleton:
   9  *      Written 1993-94 by Donald Becker.
  10  *
  11  *      Copyright 1993 United States Government as represented by the
  12  *      Director, National Security Agency.
  13  *
  14  *  Thanks to Erik De Cock, Adrian Bridgett and Frank Fiene for their
  15  *  assistance and perserverance with the testing of this driver.
  16  *
  17  *  This software may be used and distributed according to the terms
  18  *  of the GNU General Public License, incorporated herein by reference.
  19  *
  20  *  4/27/99 - Alpha Release 0.1.0
  21  *            First release to the public
  22  *
  23  *  6/8/99  - Official Release 0.2.0
  24  *            Merged into the kernel code
  25  *  8/18/99 - Updated driver for 2.3.13 kernel to use new pci
  26  *            resource. Driver also reports the card name returned by
  27  *            the pci resource.
  28  *  1/11/00 - Added spinlocks for smp
  29  *  2/23/00 - Updated to dev_kfree_irq
  30  *  3/10/00 - Fixed FDX enable which triggered other bugs also
  31  *            squashed.
  32  *  5/20/00 - Changes to handle Olympic on LinuxPPC. Endian changes.
  33  *            The odd thing about the changes is that the fix for
  34  *            endian issues with the big-endian data in the arb, asb...
  35  *            was to always swab() the bytes, no matter what CPU.
  36  *            That's because the read[wl]() functions always swap the
  37  *            bytes on the way in on PPC.
  38  *            Fixing the hardware descriptors was another matter,
  39  *            because they weren't going through read[wl](), there all
  40  *            the results had to be in memory in le32 values. kdaaker
  41  *
  42  * 12/23/00 - Added minimal Cardbus support (Thanks Donald).
  43  *
  44  * 03/09/01 - Add new pci api, dev_base_lock, general clean up.
  45  *
  46  * 03/27/01 - Add new dma pci (Thanks to Kyle Lucke) and alloc_trdev
  47  *            Change proc_fs behaviour, now one entry per adapter.
  48  *
  49  * 04/09/01 - Couple of bug fixes to the dma unmaps and ejecting the
  50  *            adapter when live does not take the system down with it.
  51  *
  52  * 06/02/01 - Clean up, copy skb for small packets
  53  *
  54  * 06/22/01 - Add EISR error handling routines
  55  *
  56  * 07/19/01 - Improve bad LAA reporting, strip out freemem
  57  *            into a separate function, its called from 3
  58  *            different places now.
  59  * 02/09/02 - Replaced sleep_on.
  60  * 03/01/02 - Replace access to several registers from 32 bit to
  61  *            16 bit. Fixes alignment errors on PPC 64 bit machines.
  62  *            Thanks to Al Trautman for this one.
  63  * 03/10/02 - Fix BUG in arb_cmd. Bug was there all along but was
  64  *            silently ignored until the error checking code
  65  *            went into version 1.0.0
  66  * 06/04/02 - Add correct start up sequence for the cardbus adapters.
  67  *            Required for strict compliance with pci power mgmt specs.
  68  *  To Do:
  69  *
  70  *           Wake on lan
  71  *
  72  *  If Problems do Occur
  73  *  Most problems can be rectified by either closing and opening the interface
  74  *  (ifconfig down and up) or rmmod and insmod'ing the driver (a bit difficult
  75  *  if compiled into the kernel).
  76  */
  77
  78 /* Change OLYMPIC_DEBUG to 1 to get verbose, and I mean really verbose, messages */
  79
  80 #define OLYMPIC_DEBUG 0
  81
  82
  83 #include <linux/module.h>
  84 #include <linux/kernel.h>
  85 #include <linux/errno.h>
  86 #include <linux/timer.h>
  87 #include <linux/in.h>
  88 #include <linux/ioport.h>
  89 #include <linux/string.h>
  90 #include <linux/proc_fs.h>
  91 #include <linux/ptrace.h>
  92 #include <linux/skbuff.h>
  93 #include <linux/interrupt.h>
  94 #include <linux/delay.h>
  95 #include <linux/netdevice.h>
  96 #include <linux/trdevice.h>
  97 #include <linux/stddef.h>
  98 #include <linux/init.h>
  99 #include <linux/pci.h>
 100 #include <linux/spinlock.h>
 101 #include <linux/bitops.h>
 102 #include <linux/jiffies.h>
 103
 104 #include <net/checksum.h>
 105 #include <net/net_namespace.h>
 106
 107 #include <asm/io.h>
 108 #include <asm/system.h>
 109
 110 #include "olympic.h"
 111
 112 /* I've got to put some intelligence into the version number so that Peter and I know
 113  * which version of the code somebody has got.
 114  * Version Number = a.b.c.d  where a.b.c is the level of code and d is the latest author.
 115  * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike
 116  *
 117  * Official releases will only have an a.b.c version number format.
 118  */
 119
 120 static char version[] =
 121 "Olympic.c v1.0.5 6/04/02 - Peter De Schrijver & Mike Phillips" ;
 122
 123 static char *open_maj_error[]  = {"No error", "Lobe Media Test", "Physical Insertion",
 124                                    "Address Verification", "Neighbor Notification (Ring Poll)",
 125                                    "Request Parameters","FDX Registration Request",
 126                                    "FDX Duplicate Address Check", "Station registration Query Wait",
 127                                    "Unknown stage"};
 128
 129 static char *open_min_error[] = {"No error", "Function Failure", "Signal Lost", "Wire Fault",
 130                                    "Ring Speed Mismatch", "Timeout","Ring Failure","Ring Beaconing",
 131                                    "Duplicate Node Address","Request Parameters","Remove Received",
 132                                    "Reserved", "Reserved", "No Monitor Detected for RPL",
 133                                    "Monitor Contention failer for RPL", "FDX Protocol Error"};
 134
 135 /* Module paramters */
 136
 137 MODULE_AUTHOR("Mike Phillips <mikep@linuxtr.net>") ;
 138 MODULE_DESCRIPTION("Olympic PCI/Cardbus Chipset Driver") ;
 139
 140 /* Ring Speed 0,4,16,100
 141  * 0 = Autosense
 142  * 4,16 = Selected speed only, no autosense
 143  * This allows the card to be the first on the ring
 144  * and become the active monitor.
 145  * 100 = Nothing at present, 100mbps is autodetected
 146  * if FDX is turned on. May be implemented in the future to
 147  * fail if 100mpbs is not detected.
 148  *
 149  * WARNING: Some hubs will allow you to insert
 150  * at the wrong speed
 151  */
 152
 153 static int ringspeed[OLYMPIC_MAX_ADAPTERS] = {0,} ;
 154 module_param_array(ringspeed, int, NULL, 0);
 155
 156 /* Packet buffer size */
 157
 158 static int pkt_buf_sz[OLYMPIC_MAX_ADAPTERS] = {0,} ;
 159 module_param_array(pkt_buf_sz, int, NULL, 0) ;
 160
 161 /* Message Level */
 162
 163 static int message_level[OLYMPIC_MAX_ADAPTERS] = {0,} ;
 164 module_param_array(message_level, int, NULL, 0) ;
 165
 166 /* Change network_monitor to receive mac frames through the arb channel.
 167  * Will also create a /proc/net/olympic_tr%d entry, where %d is the tr
 168  * device, i.e. tr0, tr1 etc.
 169  * Intended to be used to create a ring-error reporting network module
 170  * i.e. it will give you the source address of beaconers on the ring
 171  */
 172 static int network_monitor[OLYMPIC_MAX_ADAPTERS] = {0,};
 173 module_param_array(network_monitor, int, NULL, 0);
 174
 175 static struct pci_device_id olympic_pci_tbl[] = {
 176         {PCI_VENDOR_ID_IBM,PCI_DEVICE_ID_IBM_TR_WAKE,PCI_ANY_ID,PCI_ANY_ID,},
 177         { }     /* Terminating Entry */
 178 };
 179 MODULE_DEVICE_TABLE(pci,olympic_pci_tbl) ;
 180
 181
 182 static int olympic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 183 static int olympic_init(struct net_device *dev);
 184 static int olympic_open(struct net_device *dev);
 185 static int olympic_xmit(struct sk_buff *skb, struct net_device *dev);
 186 static int olympic_close(struct net_device *dev);
 187 static void olympic_set_rx_mode(struct net_device *dev);
 188 static void olympic_freemem(struct net_device *dev) ;
 189 static irqreturn_t olympic_interrupt(int irq, void *dev_id);
 190 static struct net_device_stats * olympic_get_stats(struct net_device *dev);
 191 static int olympic_set_mac_address(struct net_device *dev, void *addr) ;
 192 static void olympic_arb_cmd(struct net_device *dev);
 193 static int olympic_change_mtu(struct net_device *dev, int mtu);
 194 static void olympic_srb_bh(struct net_device *dev) ;
 195 static void olympic_asb_bh(struct net_device *dev) ;
 196 static int olympic_proc_info(char *buffer, char **start, off_t offset, int length, int *eof, void *data) ;
 197
 198 static int __devinit olympic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 199 {
 200         struct net_device *dev ;
 201         struct olympic_private *olympic_priv;
 202         static int card_no = -1 ;
 203         int i ;
 204
 205         card_no++ ;
 206
 207         if ((i = pci_enable_device(pdev))) {
 208                 return i ;
 209         }
 210
 211         pci_set_master(pdev);
 212
 213         if ((i = pci_request_regions(pdev,"olympic"))) {
 214                 goto op_disable_dev;
 215         }
 216
 217         dev = alloc_trdev(sizeof(struct olympic_private)) ;
 218         if (!dev) {
 219                 i = -ENOMEM;
 220                 goto op_release_dev;
 221         }
 222
 223         olympic_priv = netdev_priv(dev) ;
 224
 225         spin_lock_init(&olympic_priv->olympic_lock) ;
 226
 227         init_waitqueue_head(&olympic_priv->srb_wait);
 228         init_waitqueue_head(&olympic_priv->trb_wait);
 229 #if OLYMPIC_DEBUG
 230         printk(KERN_INFO "pci_device: %p, dev:%p, dev->priv: %p\n", pdev, dev, netdev_priv(dev));
 231 #endif
 232         dev->irq=pdev->irq;
 233         dev->base_addr=pci_resource_start(pdev, 0);
 234         olympic_priv->olympic_card_name = pci_name(pdev);
 235         olympic_priv->pdev = pdev;
 236         olympic_priv->olympic_mmio = ioremap(pci_resource_start(pdev,1),256);
 237         olympic_priv->olympic_lap = ioremap(pci_resource_start(pdev,2),2048);
 238         if (!olympic_priv->olympic_mmio || !olympic_priv->olympic_lap) {
 239                 goto op_free_iomap;
 240         }
 241
 242         if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000) )
 243                 olympic_priv->pkt_buf_sz = PKT_BUF_SZ ;
 244         else
 245                 olympic_priv->pkt_buf_sz = pkt_buf_sz[card_no] ;
 246
 247         dev->mtu = olympic_priv->pkt_buf_sz - TR_HLEN ;
 248         olympic_priv->olympic_ring_speed = ringspeed[card_no] ;
 249         olympic_priv->olympic_message_level = message_level[card_no] ;
 250         olympic_priv->olympic_network_monitor = network_monitor[card_no];
 251
 252         if ((i = olympic_init(dev))) {
 253                 goto op_free_iomap;
 254         }
 255
 256         dev->open=&olympic_open;
 257         dev->hard_start_xmit=&olympic_xmit;
 258         dev->change_mtu=&olympic_change_mtu;
 259         dev->stop=&olympic_close;
 260         dev->do_ioctl=NULL;
 261         dev->set_multicast_list=&olympic_set_rx_mode;
 262         dev->get_stats=&olympic_get_stats ;
 263         dev->set_mac_address=&olympic_set_mac_address ;
 264         SET_NETDEV_DEV(dev, &pdev->dev);
 265
 266         pci_set_drvdata(pdev,dev) ;
 267         register_netdev(dev) ;
 268         printk("Olympic: %s registered as: %s\n",olympic_priv->olympic_card_name,dev->name);
 269         if (olympic_priv->olympic_network_monitor) { /* Must go after register_netdev as we need the device name */
 270                 char proc_name[20] ;
 271                 strcpy(proc_name,"olympic_") ;
 272                 strcat(proc_name,dev->name) ;
 273                 create_proc_read_entry(proc_name,0,init_net.proc_net,olympic_proc_info,(void *)dev) ;
 274                 printk("Olympic: Network Monitor information: /proc/%s\n",proc_name);
 275         }
 276         return  0 ;
 277
 278 op_free_iomap:
 279         if (olympic_priv->olympic_mmio)
 280                 iounmap(olympic_priv->olympic_mmio);
 281         if (olympic_priv->olympic_lap)
 282                 iounmap(olympic_priv->olympic_lap);
 283
 284         free_netdev(dev);
 285 op_release_dev:
 286         pci_release_regions(pdev);
 287
 288 op_disable_dev:
 289         pci_disable_device(pdev);
 290         return i;
 291 }
 292
 293 static int olympic_init(struct net_device *dev)
 294 {
 295         struct olympic_private *olympic_priv;
 296         u8 __iomem *olympic_mmio, *init_srb,*adapter_addr;
 297         unsigned long t;
 298         unsigned int uaa_addr;
 299
 300         olympic_priv=netdev_priv(dev);
 301         olympic_mmio=olympic_priv->olympic_mmio;
 302
 303         printk("%s \n", version);
 304         printk("%s. I/O at %hx, MMIO at %p, LAP at %p, using irq %d\n", olympic_priv->olympic_card_name, (unsigned int) dev->base_addr,olympic_priv->olympic_mmio, olympic_priv->olympic_lap, dev->irq);
 305
 306         writel(readl(olympic_mmio+BCTL) | BCTL_SOFTRESET,olympic_mmio+BCTL);
 307         t=jiffies;
 308         while((readl(olympic_mmio+BCTL)) & BCTL_SOFTRESET) {
 309                 schedule();
 310                 if(time_after(jiffies, t + 40*HZ)) {
 311                         printk(KERN_ERR "IBM PCI tokenring card not responding.\n");
 312                         return -ENODEV;
 313                 }
 314         }
 315
 316
 317         /* Needed for cardbus */
 318         if(!(readl(olympic_mmio+BCTL) & BCTL_MODE_INDICATOR)) {
 319                 writel(readl(olympic_priv->olympic_mmio+FERMASK)|FERMASK_INT_BIT, olympic_mmio+FERMASK);
 320         }
 321
 322 #if OLYMPIC_DEBUG
 323         printk("BCTL: %x\n",readl(olympic_mmio+BCTL));
 324         printk("GPR: %x\n",readw(olympic_mmio+GPR));
 325         printk("SISRMASK: %x\n",readl(olympic_mmio+SISR_MASK));
 326 #endif
 327         /* Aaaahhh, You have got to be real careful setting GPR, the card
 328            holds the previous values from flash memory, including autosense
 329            and ring speed */
 330
 331         writel(readl(olympic_mmio+BCTL)|BCTL_MIMREB,olympic_mmio+BCTL);
 332
 333         if (olympic_priv->olympic_ring_speed  == 0) { /* Autosense */
 334                 writew(readw(olympic_mmio+GPR)|GPR_AUTOSENSE,olympic_mmio+GPR);
 335                 if (olympic_priv->olympic_message_level)
 336                         printk(KERN_INFO "%s: Ringspeed autosense mode on\n",olympic_priv->olympic_card_name);
 337         } else if (olympic_priv->olympic_ring_speed == 16) {
 338                 if (olympic_priv->olympic_message_level)
 339                         printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n", olympic_priv->olympic_card_name);
 340                 writew(GPR_16MBPS, olympic_mmio+GPR);
 341         } else if (olympic_priv->olympic_ring_speed == 4) {
 342                 if (olympic_priv->olympic_message_level)
 343                         printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n", olympic_priv->olympic_card_name) ;
 344                 writew(0, olympic_mmio+GPR);
 345         }
 346
 347         writew(readw(olympic_mmio+GPR)|GPR_NEPTUNE_BF,olympic_mmio+GPR);
 348
 349 #if OLYMPIC_DEBUG
 350         printk("GPR = %x\n",readw(olympic_mmio + GPR) ) ;
 351 #endif
 352         /* Solo has been paused to meet the Cardbus power
 353          * specs if the adapter is cardbus. Check to
 354          * see its been paused and then restart solo. The
 355          * adapter should set the pause bit within 1 second.
 356          */
 357
 358         if(!(readl(olympic_mmio+BCTL) & BCTL_MODE_INDICATOR)) {
 359                 t=jiffies;
 360                 while (!(readl(olympic_mmio+CLKCTL) & CLKCTL_PAUSE)) {
 361                         schedule() ;
 362                         if(time_after(jiffies, t + 2*HZ)) {
 363                                 printk(KERN_ERR "IBM Cardbus tokenring adapter not responsing.\n") ;
 364                                 return -ENODEV;
 365                         }
 366                 }
 367                 writel(readl(olympic_mmio+CLKCTL) & ~CLKCTL_PAUSE, olympic_mmio+CLKCTL) ;
 368         }
 369
 370         /* start solo init */
 371         writel((1<<15),olympic_mmio+SISR_MASK_SUM);
 372
 373         t=jiffies;
 374         while(!((readl(olympic_mmio+SISR_RR)) & SISR_SRB_REPLY)) {
 375                 schedule();
 376                 if(time_after(jiffies, t + 15*HZ)) {
 377                         printk(KERN_ERR "IBM PCI tokenring card not responding.\n");
 378                         return -ENODEV;
 379                 }
 380         }
 381
 382         writel(readw(olympic_mmio+LAPWWO),olympic_mmio+LAPA);
 383
 384 #if OLYMPIC_DEBUG
 385         printk("LAPWWO: %x, LAPA: %x\n",readl(olympic_mmio+LAPWWO), readl(olympic_mmio+LAPA));
 386 #endif
 387
 388         init_srb=olympic_priv->olympic_lap + ((readw(olympic_mmio+LAPWWO)) & (~0xf800));
 389
 390 #if OLYMPIC_DEBUG
 391 {
 392         int i;
 393         printk("init_srb(%p): ",init_srb);
 394         for(i=0;i<20;i++)
 395                 printk("%x ",readb(init_srb+i));
 396         printk("\n");
 397 }
 398 #endif
 399         if(readw(init_srb+6)) {
 400                 printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",readw(init_srb+6));
 401                 return -ENODEV;
 402         }
 403
 404         if (olympic_priv->olympic_message_level) {
 405                 if ( readb(init_srb +2) & 0x40) {
 406                         printk(KERN_INFO "Olympic: Adapter is FDX capable.\n") ;
 407                 } else {
 408                         printk(KERN_INFO "Olympic: Adapter cannot do FDX.\n");
 409                 }
 410         }
 411
 412         uaa_addr=swab16(readw(init_srb+8));
 413
 414 #if OLYMPIC_DEBUG
 415         printk("UAA resides at %x\n",uaa_addr);
 416 #endif
 417
 418         writel(uaa_addr,olympic_mmio+LAPA);
 419         adapter_addr=olympic_priv->olympic_lap + (uaa_addr & (~0xf800));
 420
 421         memcpy_fromio(&dev->dev_addr[0], adapter_addr,6);
 422
 423 #if OLYMPIC_DEBUG
 424         printk("adapter address: %pM\n", dev->dev_addr);
 425 #endif
 426
 427         olympic_priv->olympic_addr_table_addr = swab16(readw(init_srb + 12));
 428         olympic_priv->olympic_parms_addr = swab16(readw(init_srb + 14));
 429
 430         return 0;
 431
 432 }
 433
 434 static int olympic_open(struct net_device *dev)
 435 {
 436         struct olympic_private *olympic_priv=netdev_priv(dev);
 437         u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio,*init_srb;
 438         unsigned long flags, t;
 439         int i, open_finished = 1 ;
 440         u8 resp, err;
 441
 442         DECLARE_WAITQUEUE(wait,current) ;
 443
 444         olympic_init(dev);
 445
 446         if(request_irq(dev->irq, &olympic_interrupt, IRQF_SHARED , "olympic", dev)) {
 447                 return -EAGAIN;
 448         }
 449
 450 #if OLYMPIC_DEBUG
 451         printk("BMCTL: %x\n",readl(olympic_mmio+BMCTL_SUM));
 452         printk("pending ints: %x\n",readl(olympic_mmio+SISR_RR));
 453 #endif
 454
 455         writel(SISR_MI,olympic_mmio+SISR_MASK_SUM);
 456
 457         writel(SISR_MI | SISR_SRB_REPLY, olympic_mmio+SISR_MASK); /* more ints later, doesn't stop arb cmd interrupt */
 458
 459         writel(LISR_LIE,olympic_mmio+LISR); /* more ints later */
 460
 461         /* adapter is closed, so SRB is pointed to by LAPWWO */
 462
 463         writel(readw(olympic_mmio+LAPWWO),olympic_mmio+LAPA);
 464         init_srb=olympic_priv->olympic_lap + ((readw(olympic_mmio+LAPWWO)) & (~0xf800));
 465
 466 #if OLYMPIC_DEBUG
 467         printk("LAPWWO: %x, LAPA: %x\n",readw(olympic_mmio+LAPWWO), readl(olympic_mmio+LAPA));
 468         printk("SISR Mask = %04x\n", readl(olympic_mmio+SISR_MASK));
 469         printk("Before the open command \n");
 470 #endif
 471         do {
 472                 memset_io(init_srb,0,SRB_COMMAND_SIZE);
 473
 474                 writeb(SRB_OPEN_ADAPTER,init_srb) ;     /* open */
 475                 writeb(OLYMPIC_CLEAR_RET_CODE,init_srb+2);
 476
 477                 /* If Network Monitor, instruct card to copy MAC frames through the ARB */
 478                 if (olympic_priv->olympic_network_monitor)
 479                         writew(swab16(OPEN_ADAPTER_ENABLE_FDX | OPEN_ADAPTER_PASS_ADC_MAC | OPEN_ADAPTER_PASS_ATT_MAC | OPEN_ADAPTER_PASS_BEACON), init_srb+8);
 480                 else
 481                         writew(swab16(OPEN_ADAPTER_ENABLE_FDX), init_srb+8);
 482
 483                 /* Test OR of first 3 bytes as its totally possible for
 484                  * someone to set the first 2 bytes to be zero, although this
 485                  * is an error, the first byte must have bit 6 set to 1  */
 486
 487                 if (olympic_priv->olympic_laa[0] | olympic_priv->olympic_laa[1] | olympic_priv->olympic_laa[2]) {
 488                         writeb(olympic_priv->olympic_laa[0],init_srb+12);
 489                         writeb(olympic_priv->olympic_laa[1],init_srb+13);
 490                         writeb(olympic_priv->olympic_laa[2],init_srb+14);
 491                         writeb(olympic_priv->olympic_laa[3],init_srb+15);
 492                         writeb(olympic_priv->olympic_laa[4],init_srb+16);
 493                         writeb(olympic_priv->olympic_laa[5],init_srb+17);
 494                         memcpy(dev->dev_addr,olympic_priv->olympic_laa,dev->addr_len) ;
 495                 }
 496                 writeb(1,init_srb+30);
 497
 498                 spin_lock_irqsave(&olympic_priv->olympic_lock,flags);
 499                 olympic_priv->srb_queued=1;
 500
 501                 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 502                 spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
 503
 504                 t = jiffies ;
 505
 506                 add_wait_queue(&olympic_priv->srb_wait,&wait) ;
 507                 set_current_state(TASK_INTERRUPTIBLE) ;
 508
 509                 while(olympic_priv->srb_queued) {
 510                         schedule() ;
 511                         if(signal_pending(current))     {
 512                                 printk(KERN_WARNING "%s: Signal received in open.\n",
 513                                         dev->name);
 514                                 printk(KERN_WARNING "SISR=%x LISR=%x\n",
 515                                         readl(olympic_mmio+SISR),
 516                                         readl(olympic_mmio+LISR));
 517                                 olympic_priv->srb_queued=0;
 518                                 break;
 519                         }
 520                         if (time_after(jiffies, t + 10*HZ)) {
 521                                 printk(KERN_WARNING "%s: SRB timed out. \n",dev->name) ;
 522                                 olympic_priv->srb_queued=0;
 523                                 break ;
 524                         }
 525                         set_current_state(TASK_INTERRUPTIBLE) ;
 526                 }
 527                 remove_wait_queue(&olympic_priv->srb_wait,&wait) ;
 528                 set_current_state(TASK_RUNNING) ;
 529                 olympic_priv->srb_queued = 0 ;
 530 #if OLYMPIC_DEBUG
 531                 printk("init_srb(%p): ",init_srb);
 532                 for(i=0;i<20;i++)
 533                         printk("%02x ",readb(init_srb+i));
 534                 printk("\n");
 535 #endif
 536
 537                 /* If we get the same return response as we set, the interrupt wasn't raised and the open
 538                  * timed out.
 539                  */
 540
 541                 switch (resp = readb(init_srb+2)) {
 542                 case OLYMPIC_CLEAR_RET_CODE:
 543                         printk(KERN_WARNING "%s: Adapter Open time out or error.\n", dev->name) ;
 544                         goto out;
 545                 case 0:
 546                         open_finished = 1;
 547                         break;
 548                 case 0x07:
 549                         if (!olympic_priv->olympic_ring_speed && open_finished) { /* Autosense , first time around */
 550                                 printk(KERN_WARNING "%s: Retrying at different ring speed \n", dev->name);
 551                                 open_finished = 0 ;
 552                                 continue;
 553                         }
 554
 555                         err = readb(init_srb+7);
 556
 557                         if (!olympic_priv->olympic_ring_speed && ((err & 0x0f) == 0x0d)) {
 558                                 printk(KERN_WARNING "%s: Tried to autosense ring speed with no monitors present\n",dev->name);
 559                                 printk(KERN_WARNING "%s: Please try again with a specified ring speed \n",dev->name);
 560                         } else {
 561                                 printk(KERN_WARNING "%s: %s - %s\n", dev->name,
 562                                         open_maj_error[(err & 0xf0) >> 4],
 563                                         open_min_error[(err & 0x0f)]);
 564                         }
 565                         goto out;
 566
 567                 case 0x32:
 568                         printk(KERN_WARNING "%s: Invalid LAA: %pM\n",
 569                                dev->name, olympic_priv->olympic_laa);
 570                         goto out;
 571
 572                 default:
 573                         printk(KERN_WARNING "%s: Bad OPEN response: %x\n", dev->name, resp);
 574                         goto out;
 575
 576                 }
 577         } while (!(open_finished)) ; /* Will only loop if ring speed mismatch re-open attempted && autosense is on */
 578
 579         if (readb(init_srb+18) & (1<<3))
 580                 if (olympic_priv->olympic_message_level)
 581                         printk(KERN_INFO "%s: Opened in FDX Mode\n",dev->name);
 582
 583         if (readb(init_srb+18) & (1<<1))
 584                 olympic_priv->olympic_ring_speed = 100 ;
 585         else if (readb(init_srb+18) & 1)
 586                 olympic_priv->olympic_ring_speed = 16 ;
 587         else
 588                 olympic_priv->olympic_ring_speed = 4 ;
 589
 590         if (olympic_priv->olympic_message_level)
 591                 printk(KERN_INFO "%s: Opened in %d Mbps mode\n",dev->name, olympic_priv->olympic_ring_speed);
 592
 593         olympic_priv->asb = swab16(readw(init_srb+8));
 594         olympic_priv->srb = swab16(readw(init_srb+10));
 595         olympic_priv->arb = swab16(readw(init_srb+12));
 596         olympic_priv->trb = swab16(readw(init_srb+16));
 597
 598         olympic_priv->olympic_receive_options = 0x01 ;
 599         olympic_priv->olympic_copy_all_options = 0 ;
 600
 601         /* setup rx ring */
 602
 603         writel((3<<16),olympic_mmio+BMCTL_RWM); /* Ensure end of frame generated interrupts */
 604
 605         writel(BMCTL_RX_DIS|3,olympic_mmio+BMCTL_RWM); /* Yes, this the enables RX channel */
 606
 607         for(i=0;i<OLYMPIC_RX_RING_SIZE;i++) {
 608
 609                 struct sk_buff *skb;
 610
 611                 skb=dev_alloc_skb(olympic_priv->pkt_buf_sz);
 612                 if(skb == NULL)
 613                         break;
 614
 615                 skb->dev = dev;
 616
 617                 olympic_priv->olympic_rx_ring[i].buffer = cpu_to_le32(pci_map_single(olympic_priv->pdev,
 618                                                           skb->data,olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE)) ;
 619                 olympic_priv->olympic_rx_ring[i].res_length = cpu_to_le32(olympic_priv->pkt_buf_sz);
 620                 olympic_priv->rx_ring_skb[i]=skb;
 621         }
 622
 623         if (i==0) {
 624                 printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n",dev->name);
 625                 goto out;
 626         }
 627
 628         olympic_priv->rx_ring_dma_addr = pci_map_single(olympic_priv->pdev,olympic_priv->olympic_rx_ring,
 629                                          sizeof(struct olympic_rx_desc) * OLYMPIC_RX_RING_SIZE, PCI_DMA_TODEVICE);
 630         writel(olympic_priv->rx_ring_dma_addr, olympic_mmio+RXDESCQ);
 631         writel(olympic_priv->rx_ring_dma_addr, olympic_mmio+RXCDA);
 632         writew(i, olympic_mmio+RXDESCQCNT);
 633
 634         olympic_priv->rx_status_ring_dma_addr = pci_map_single(olympic_priv->pdev, olympic_priv->olympic_rx_status_ring,
 635                                                 sizeof(struct olympic_rx_status) * OLYMPIC_RX_RING_SIZE, PCI_DMA_FROMDEVICE);
 636         writel(olympic_priv->rx_status_ring_dma_addr, olympic_mmio+RXSTATQ);
 637         writel(olympic_priv->rx_status_ring_dma_addr, olympic_mmio+RXCSA);
 638
 639         olympic_priv->rx_ring_last_received = OLYMPIC_RX_RING_SIZE - 1; /* last processed rx status */
 640         olympic_priv->rx_status_last_received = OLYMPIC_RX_RING_SIZE - 1;
 641
 642         writew(i, olympic_mmio+RXSTATQCNT);
 643
 644 #if OLYMPIC_DEBUG
 645         printk("# of rx buffers: %d, RXENQ: %x\n",i, readw(olympic_mmio+RXENQ));
 646         printk("RXCSA: %x, rx_status_ring[0]: %p\n",readl(olympic_mmio+RXCSA),&olympic_priv->olympic_rx_status_ring[0]);
 647         printk(" stat_ring[1]: %p, stat_ring[2]: %p, stat_ring[3]: %p\n", &(olympic_priv->olympic_rx_status_ring[1]), &(olympic_priv->olympic_rx_status_ring[2]), &(olympic_priv->olympic_rx_status_ring[3]) );
 648         printk(" stat_ring[4]: %p, stat_ring[5]: %p, stat_ring[6]: %p\n", &(olympic_priv->olympic_rx_status_ring[4]), &(olympic_priv->olympic_rx_status_ring[5]), &(olympic_priv->olympic_rx_status_ring[6]) );
 649         printk(" stat_ring[7]: %p\n", &(olympic_priv->olympic_rx_status_ring[7])  );
 650
 651         printk("RXCDA: %x, rx_ring[0]: %p\n",readl(olympic_mmio+RXCDA),&olympic_priv->olympic_rx_ring[0]);
 652         printk("Rx_ring_dma_addr = %08x, rx_status_dma_addr = %08x\n",
 653                 olympic_priv->rx_ring_dma_addr,olympic_priv->rx_status_ring_dma_addr) ;
 654 #endif
 655
 656         writew((((readw(olympic_mmio+RXENQ)) & 0x8000) ^ 0x8000) | i,olympic_mmio+RXENQ);
 657
 658 #if OLYMPIC_DEBUG
 659         printk("# of rx buffers: %d, RXENQ: %x\n",i, readw(olympic_mmio+RXENQ));
 660         printk("RXCSA: %x, rx_ring[0]: %p\n",readl(olympic_mmio+RXCSA),&olympic_priv->olympic_rx_status_ring[0]);
 661         printk("RXCDA: %x, rx_ring[0]: %p\n",readl(olympic_mmio+RXCDA),&olympic_priv->olympic_rx_ring[0]);
 662 #endif
 663
 664         writel(SISR_RX_STATUS | SISR_RX_NOBUF,olympic_mmio+SISR_MASK_SUM);
 665
 666         /* setup tx ring */
 667
 668         writel(BMCTL_TX1_DIS,olympic_mmio+BMCTL_RWM); /* Yes, this enables TX channel 1 */
 669         for(i=0;i<OLYMPIC_TX_RING_SIZE;i++)
 670                 olympic_priv->olympic_tx_ring[i].buffer=cpu_to_le32(0xdeadbeef);
 671
 672         olympic_priv->free_tx_ring_entries=OLYMPIC_TX_RING_SIZE;
 673         olympic_priv->tx_ring_dma_addr = pci_map_single(olympic_priv->pdev,olympic_priv->olympic_tx_ring,
 674                                          sizeof(struct olympic_tx_desc) * OLYMPIC_TX_RING_SIZE,PCI_DMA_TODEVICE) ;
 675         writel(olympic_priv->tx_ring_dma_addr, olympic_mmio+TXDESCQ_1);
 676         writel(olympic_priv->tx_ring_dma_addr, olympic_mmio+TXCDA_1);
 677         writew(OLYMPIC_TX_RING_SIZE, olympic_mmio+TXDESCQCNT_1);
 678
 679         olympic_priv->tx_status_ring_dma_addr = pci_map_single(olympic_priv->pdev, olympic_priv->olympic_tx_status_ring,
 680                                                 sizeof(struct olympic_tx_status) * OLYMPIC_TX_RING_SIZE, PCI_DMA_FROMDEVICE);
 681         writel(olympic_priv->tx_status_ring_dma_addr,olympic_mmio+TXSTATQ_1);
 682         writel(olympic_priv->tx_status_ring_dma_addr,olympic_mmio+TXCSA_1);
 683         writew(OLYMPIC_TX_RING_SIZE,olympic_mmio+TXSTATQCNT_1);
 684
 685         olympic_priv->tx_ring_free=0; /* next entry in tx ring to use */
 686         olympic_priv->tx_ring_last_status=OLYMPIC_TX_RING_SIZE-1; /* last processed tx status */
 687
 688         writel(0xffffffff, olympic_mmio+EISR_RWM) ; /* clean the eisr */
 689         writel(0,olympic_mmio+EISR) ;
 690         writel(EISR_MASK_OPTIONS,olympic_mmio+EISR_MASK) ; /* enables most of the TX error interrupts */
 691         writel(SISR_TX1_EOF | SISR_ADAPTER_CHECK | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_ASB_FREE | SISR_ERR,olympic_mmio+SISR_MASK_SUM);
 692
 693 #if OLYMPIC_DEBUG
 694         printk("BMCTL: %x\n",readl(olympic_mmio+BMCTL_SUM));
 695         printk("SISR MASK: %x\n",readl(olympic_mmio+SISR_MASK));
 696 #endif
 697
 698         if (olympic_priv->olympic_network_monitor) {
 699                 u8 __iomem *oat;
 700                 u8 __iomem *opt;
 701                 int i;
 702                 u8 addr[6];
 703                 oat = (olympic_priv->olympic_lap + olympic_priv->olympic_addr_table_addr);
 704                 opt = (olympic_priv->olympic_lap + olympic_priv->olympic_parms_addr);
 705
 706                 for (i = 0; i < 6; i++)
 707                         addr[i] = readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+i);
 708                 printk("%s: Node Address: %pM\n", dev->name, addr);
 709                 printk("%s: Functional Address: %02x:%02x:%02x:%02x\n",dev->name,
 710                         readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)),
 711                         readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+1),
 712                         readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+2),
 713                         readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+3));
 714
 715                 for (i = 0; i < 6; i++)
 716                         addr[i] = readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+i);
 717                 printk("%s: NAUN Address: %pM\n", dev->name, addr);
 718         }
 719
 720         netif_start_queue(dev);
 721         return 0;
 722
 723 out:
 724         free_irq(dev->irq, dev);
 725         return -EIO;
 726 }
 727
 728 /*
 729  *      When we enter the rx routine we do not know how many frames have been
 730  *      queued on the rx channel.  Therefore we start at the next rx status
 731  *      position and travel around the receive ring until we have completed
 732  *      all the frames.
 733  *
 734  *      This means that we may process the frame before we receive the end
 735  *      of frame interrupt. This is why we always test the status instead
 736  *      of blindly processing the next frame.
 737  *
 738  *      We also remove the last 4 bytes from the packet as well, these are
 739  *      just token ring trailer info and upset protocols that don't check
 740  *      their own length, i.e. SNA.
 741  *
 742  */
 743 static void olympic_rx(struct net_device *dev)
 744 {
 745         struct olympic_private *olympic_priv=netdev_priv(dev);
 746         u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
 747         struct olympic_rx_status *rx_status;
 748         struct olympic_rx_desc *rx_desc ;
 749         int rx_ring_last_received,length, buffer_cnt, cpy_length, frag_len;
 750         struct sk_buff *skb, *skb2;
 751         int i;
 752
 753         rx_status=&(olympic_priv->olympic_rx_status_ring[(olympic_priv->rx_status_last_received + 1) & (OLYMPIC_RX_RING_SIZE - 1)]) ;
 754
 755         while (rx_status->status_buffercnt) {
 756                 u32 l_status_buffercnt;
 757
 758                 olympic_priv->rx_status_last_received++ ;
 759                 olympic_priv->rx_status_last_received &= (OLYMPIC_RX_RING_SIZE -1);
 760 #if OLYMPIC_DEBUG
 761                 printk("rx status: %x rx len: %x \n", le32_to_cpu(rx_status->status_buffercnt), le32_to_cpu(rx_status->fragmentcnt_framelen));
 762 #endif
 763                 length = le32_to_cpu(rx_status->fragmentcnt_framelen) & 0xffff;
 764                 buffer_cnt = le32_to_cpu(rx_status->status_buffercnt) & 0xffff;
 765                 i = buffer_cnt ; /* Need buffer_cnt later for rxenq update */
 766                 frag_len = le32_to_cpu(rx_status->fragmentcnt_framelen) >> 16;
 767
 768 #if OLYMPIC_DEBUG
 769                 printk("length: %x, frag_len: %x, buffer_cnt: %x\n", length, frag_len, buffer_cnt);
 770 #endif
 771                 l_status_buffercnt = le32_to_cpu(rx_status->status_buffercnt);
 772                 if(l_status_buffercnt & 0xC0000000) {
 773                         if (l_status_buffercnt & 0x3B000000) {
 774                                 if (olympic_priv->olympic_message_level) {
 775                                         if (l_status_buffercnt & (1<<29))  /* Rx Frame Truncated */
 776                                                 printk(KERN_WARNING "%s: Rx Frame Truncated \n",dev->name);
 777                                         if (l_status_buffercnt & (1<<28)) /*Rx receive overrun */
 778                                                 printk(KERN_WARNING "%s: Rx Frame Receive overrun \n",dev->name);
 779                                         if (l_status_buffercnt & (1<<27)) /* No receive buffers */
 780                                                 printk(KERN_WARNING "%s: No receive buffers \n",dev->name);
 781                                         if (l_status_buffercnt & (1<<25)) /* Receive frame error detect */
 782                                                 printk(KERN_WARNING "%s: Receive frame error detect \n",dev->name);
 783                                         if (l_status_buffercnt & (1<<24)) /* Received Error Detect */
 784                                                 printk(KERN_WARNING "%s: Received Error Detect \n",dev->name);
 785                                 }
 786                                 olympic_priv->rx_ring_last_received += i ;
 787                                 olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1) ;
 788                                 olympic_priv->olympic_stats.rx_errors++;
 789                         } else {
 790
 791                                 if (buffer_cnt == 1) {
 792                                         skb = dev_alloc_skb(max_t(int, olympic_priv->pkt_buf_sz,length)) ;
 793                                 } else {
 794                                         skb = dev_alloc_skb(length) ;
 795                                 }
 796
 797                                 if (skb == NULL) {
 798                                         printk(KERN_WARNING "%s: Not enough memory to copy packet to upper layers. \n",dev->name) ;
 799                                         olympic_priv->olympic_stats.rx_dropped++ ;
 800                                         /* Update counters even though we don't transfer the frame */
 801                                         olympic_priv->rx_ring_last_received += i ;
 802                                         olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1) ;
 803                                 } else  {
 804                                         /* Optimise based upon number of buffers used.
 805                                            If only one buffer is used we can simply swap the buffers around.
 806                                            If more than one then we must use the new buffer and copy the information
 807                                            first. Ideally all frames would be in a single buffer, this can be tuned by
 808                                            altering the buffer size. If the length of the packet is less than
 809                                            1500 bytes we're going to copy it over anyway to stop packets getting
 810                                            dropped from sockets with buffers smaller than our pkt_buf_sz. */
 811
 812                                         if (buffer_cnt==1) {
 813                                                 olympic_priv->rx_ring_last_received++ ;
 814                                                 olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
 815                                                 rx_ring_last_received = olympic_priv->rx_ring_last_received ;
 816                                                 if (length > 1500) {
 817                                                         skb2=olympic_priv->rx_ring_skb[rx_ring_last_received] ;
 818                                                         /* unmap buffer */
 819                                                         pci_unmap_single(olympic_priv->pdev,
 820                                                                 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 821                                                                 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 822                                                         skb_put(skb2,length-4);
 823                                                         skb2->protocol = tr_type_trans(skb2,dev);
 824                                                         olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer =
 825                                                                 cpu_to_le32(pci_map_single(olympic_priv->pdev, skb->data,
 826                                                                 olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
 827                                                         olympic_priv->olympic_rx_ring[rx_ring_last_received].res_length =
 828                                                                 cpu_to_le32(olympic_priv->pkt_buf_sz);
 829                                                         olympic_priv->rx_ring_skb[rx_ring_last_received] = skb ;
 830                                                         netif_rx(skb2) ;
 831                                                 } else {
 832                                                         pci_dma_sync_single_for_cpu(olympic_priv->pdev,
 833                                                                 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 834                                                                 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 835                                                         skb_copy_from_linear_data(olympic_priv->rx_ring_skb[rx_ring_last_received],
 836                                                                       skb_put(skb,length - 4),
 837                                                                       length - 4);
 838                                                         pci_dma_sync_single_for_device(olympic_priv->pdev,
 839                                                                 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 840                                                                 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 841                                                         skb->protocol = tr_type_trans(skb,dev) ;
 842                                                         netif_rx(skb) ;
 843                                                 }
 844                                         } else {
 845                                                 do { /* Walk the buffers */
 846                                                         olympic_priv->rx_ring_last_received++ ;
 847                                                         olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
 848                                                         rx_ring_last_received = olympic_priv->rx_ring_last_received ;
 849                                                         pci_dma_sync_single_for_cpu(olympic_priv->pdev,
 850                                                                 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 851                                                                 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 852                                                         rx_desc = &(olympic_priv->olympic_rx_ring[rx_ring_last_received]);
 853                                                         cpy_length = (i == 1 ? frag_len : le32_to_cpu(rx_desc->res_length));
 854                                                         skb_copy_from_linear_data(olympic_priv->rx_ring_skb[rx_ring_last_received],
 855                                                                       skb_put(skb, cpy_length),
 856                                                                       cpy_length);
 857                                                         pci_dma_sync_single_for_device(olympic_priv->pdev,
 858                                                                 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 859                                                                 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 860                                                 } while (--i) ;
 861                                                 skb_trim(skb,skb->len-4) ;
 862                                                 skb->protocol = tr_type_trans(skb,dev);
 863                                                 netif_rx(skb) ;
 864                                         }
 865                                         olympic_priv->olympic_stats.rx_packets++ ;
 866                                         olympic_priv->olympic_stats.rx_bytes += length ;
 867                                 } /* if skb == null */
 868                         } /* If status & 0x3b */
 869
 870                 } else { /*if buffercnt & 0xC */
 871                         olympic_priv->rx_ring_last_received += i ;
 872                         olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE - 1) ;
 873                 }
 874
 875                 rx_status->fragmentcnt_framelen = 0 ;
 876                 rx_status->status_buffercnt = 0 ;
 877                 rx_status = &(olympic_priv->olympic_rx_status_ring[(olympic_priv->rx_status_last_received+1) & (OLYMPIC_RX_RING_SIZE -1) ]);
 878
 879                 writew((((readw(olympic_mmio+RXENQ)) & 0x8000) ^ 0x8000) |  buffer_cnt , olympic_mmio+RXENQ);
 880         } /* while */
 881
 882 }
 883
 884 static void olympic_freemem(struct net_device *dev)
 885 {
 886         struct olympic_private *olympic_priv=netdev_priv(dev);
 887         int i;
 888
 889         for(i=0;i<OLYMPIC_RX_RING_SIZE;i++) {
 890                 if (olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received] != NULL) {
 891                         dev_kfree_skb_irq(olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received]);
 892                         olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received] = NULL;
 893                 }
 894                 if (olympic_priv->olympic_rx_ring[olympic_priv->rx_status_last_received].buffer != cpu_to_le32(0xdeadbeef)) {
 895                         pci_unmap_single(olympic_priv->pdev,
 896                         le32_to_cpu(olympic_priv->olympic_rx_ring[olympic_priv->rx_status_last_received].buffer),
 897                         olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE);
 898                 }
 899                 olympic_priv->rx_status_last_received++;
 900                 olympic_priv->rx_status_last_received&=OLYMPIC_RX_RING_SIZE-1;
 901         }
 902         /* unmap rings */
 903         pci_unmap_single(olympic_priv->pdev, olympic_priv->rx_status_ring_dma_addr,
 904                 sizeof(struct olympic_rx_status) * OLYMPIC_RX_RING_SIZE, PCI_DMA_FROMDEVICE);
 905         pci_unmap_single(olympic_priv->pdev, olympic_priv->rx_ring_dma_addr,
 906                 sizeof(struct olympic_rx_desc) * OLYMPIC_RX_RING_SIZE, PCI_DMA_TODEVICE);
 907
 908         pci_unmap_single(olympic_priv->pdev, olympic_priv->tx_status_ring_dma_addr,
 909                 sizeof(struct olympic_tx_status) * OLYMPIC_TX_RING_SIZE, PCI_DMA_FROMDEVICE);
 910         pci_unmap_single(olympic_priv->pdev, olympic_priv->tx_ring_dma_addr,
 911                 sizeof(struct olympic_tx_desc) * OLYMPIC_TX_RING_SIZE, PCI_DMA_TODEVICE);
 912
 913         return ;
 914 }
 915
 916 static irqreturn_t olympic_interrupt(int irq, void *dev_id)
 917 {
 918         struct net_device *dev= (struct net_device *)dev_id;
 919         struct olympic_private *olympic_priv=netdev_priv(dev);
 920         u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
 921         u32 sisr;
 922         u8 __iomem *adapter_check_area ;
 923
 924         /*
 925          *  Read sisr but don't reset it yet.
 926          *  The indication bit may have been set but the interrupt latch
 927          *  bit may not be set, so we'd lose the interrupt later.
 928          */
 929         sisr=readl(olympic_mmio+SISR) ;
 930         if (!(sisr & SISR_MI)) /* Interrupt isn't for us */
 931                 return IRQ_NONE;
 932         sisr=readl(olympic_mmio+SISR_RR) ;  /* Read & Reset sisr */
 933
 934         spin_lock(&olympic_priv->olympic_lock);
 935
 936         /* Hotswap gives us this on removal */
 937         if (sisr == 0xffffffff) {
 938                 printk(KERN_WARNING "%s: Hotswap adapter removal.\n",dev->name) ;
 939                 spin_unlock(&olympic_priv->olympic_lock) ;
 940                 return IRQ_NONE;
 941         }
 942
 943         if (sisr & (SISR_SRB_REPLY | SISR_TX1_EOF | SISR_RX_STATUS | SISR_ADAPTER_CHECK |
 944                         SISR_ASB_FREE | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_RX_NOBUF | SISR_ERR)) {
 945
 946                 /* If we ever get this the adapter is seriously dead. Only a reset is going to
 947                  * bring it back to life. We're talking pci bus errors and such like :( */
 948                 if((sisr & SISR_ERR) && (readl(olympic_mmio+EISR) & EISR_MASK_OPTIONS)) {
 949                         printk(KERN_ERR "Olympic: EISR Error, EISR=%08x\n",readl(olympic_mmio+EISR)) ;
 950                         printk(KERN_ERR "The adapter must be reset to clear this condition.\n") ;
 951                         printk(KERN_ERR "Please report this error to the driver maintainer and/\n") ;
 952                         printk(KERN_ERR "or the linux-tr mailing list.\n") ;
 953                         wake_up_interruptible(&olympic_priv->srb_wait);
 954                         spin_unlock(&olympic_priv->olympic_lock) ;
 955                         return IRQ_HANDLED;
 956                 } /* SISR_ERR */
 957
 958                 if(sisr & SISR_SRB_REPLY) {
 959                         if(olympic_priv->srb_queued==1) {
 960                                 wake_up_interruptible(&olympic_priv->srb_wait);
 961                         } else if (olympic_priv->srb_queued==2) {
 962                                 olympic_srb_bh(dev) ;
 963                         }
 964                         olympic_priv->srb_queued=0;
 965                 } /* SISR_SRB_REPLY */
 966
 967                 /* We shouldn't ever miss the Tx interrupt, but the you never know, hence the loop to ensure
 968                    we get all tx completions. */
 969                 if (sisr & SISR_TX1_EOF) {
 970                         while(olympic_priv->olympic_tx_status_ring[(olympic_priv->tx_ring_last_status + 1) & (OLYMPIC_TX_RING_SIZE-1)].status) {
 971                                 olympic_priv->tx_ring_last_status++;
 972                                 olympic_priv->tx_ring_last_status &= (OLYMPIC_TX_RING_SIZE-1);
 973                                 olympic_priv->free_tx_ring_entries++;
 974                                 olympic_priv->olympic_stats.tx_bytes += olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]->len;
 975                                 olympic_priv->olympic_stats.tx_packets++ ;
 976                                 pci_unmap_single(olympic_priv->pdev,
 977                                         le32_to_cpu(olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_last_status].buffer),
 978                                         olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]->len,PCI_DMA_TODEVICE);
 979                                 dev_kfree_skb_irq(olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]);
 980                                 olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_last_status].buffer=cpu_to_le32(0xdeadbeef);
 981                                 olympic_priv->olympic_tx_status_ring[olympic_priv->tx_ring_last_status].status=0;
 982                         }
 983                         netif_wake_queue(dev);
 984                 } /* SISR_TX1_EOF */
 985
 986                 if (sisr & SISR_RX_STATUS) {
 987                         olympic_rx(dev);
 988                 } /* SISR_RX_STATUS */
 989
 990                 if (sisr & SISR_ADAPTER_CHECK) {
 991                         netif_stop_queue(dev);
 992                         printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name);
 993                         writel(readl(olympic_mmio+LAPWWC),olympic_mmio+LAPA);
 994                         adapter_check_area = olympic_priv->olympic_lap + ((readl(olympic_mmio+LAPWWC)) & (~0xf800)) ;
 995                         printk(KERN_WARNING "%s: Bytes %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",dev->name, readb(adapter_check_area+0), readb(adapter_check_area+1), readb(adapter_check_area+2), readb(adapter_check_area+3), readb(adapter_check_area+4), readb(adapter_check_area+5), readb(adapter_check_area+6), readb(adapter_check_area+7)) ;
 996                         spin_unlock(&olympic_priv->olympic_lock) ;
 997                         return IRQ_HANDLED;
 998                 } /* SISR_ADAPTER_CHECK */
 999
1000                 if (sisr & SISR_ASB_FREE) {
1001                         /* Wake up anything that is waiting for the asb response */
1002                         if (olympic_priv->asb_queued) {
1003                                 olympic_asb_bh(dev) ;
1004                         }
1005                 } /* SISR_ASB_FREE */
1006
1007                 if (sisr & SISR_ARB_CMD) {
1008                         olympic_arb_cmd(dev) ;
1009                 } /* SISR_ARB_CMD */
1010
1011                 if (sisr & SISR_TRB_REPLY) {
1012                         /* Wake up anything that is waiting for the trb response */
1013                         if (olympic_priv->trb_queued) {
1014                                 wake_up_interruptible(&olympic_priv->trb_wait);
1015                         }
1016                         olympic_priv->trb_queued = 0 ;
1017                 } /* SISR_TRB_REPLY */
1018
1019                 if (sisr & SISR_RX_NOBUF) {
1020                         /* According to the documentation, we don't have to do anything, but trapping it keeps it out of
1021                                    /var/log/messages.  */
1022                 } /* SISR_RX_NOBUF */
1023         } else {
1024                 printk(KERN_WARNING "%s: Unexpected interrupt: %x\n",dev->name, sisr);
1025                 printk(KERN_WARNING "%s: SISR_MASK: %x\n",dev->name, readl(olympic_mmio+SISR_MASK)) ;
1026         } /* One if the interrupts we want */
1027         writel(SISR_MI,olympic_mmio+SISR_MASK_SUM);
1028
1029         spin_unlock(&olympic_priv->olympic_lock) ;
1030         return IRQ_HANDLED;
1031 }
1032
1033 static int olympic_xmit(struct sk_buff *skb, struct net_device *dev)
1034 {
1035         struct olympic_private *olympic_priv=netdev_priv(dev);
1036         u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
1037         unsigned long flags ;
1038
1039         spin_lock_irqsave(&olympic_priv->olympic_lock, flags);
1040
1041         netif_stop_queue(dev);
1042
1043         if(olympic_priv->free_tx_ring_entries) {
1044                 olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_free].buffer =
1045                         cpu_to_le32(pci_map_single(olympic_priv->pdev, skb->data, skb->len,PCI_DMA_TODEVICE));
1046                 olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_free].status_length = cpu_to_le32(skb->len | (0x80000000));
1047                 olympic_priv->tx_ring_skb[olympic_priv->tx_ring_free]=skb;
1048                 olympic_priv->free_tx_ring_entries--;
1049
1050                 olympic_priv->tx_ring_free++;
1051                 olympic_priv->tx_ring_free &= (OLYMPIC_TX_RING_SIZE-1);
1052                 writew((((readw(olympic_mmio+TXENQ_1)) & 0x8000) ^ 0x8000) | 1,olympic_mmio+TXENQ_1);
1053                 netif_wake_queue(dev);
1054                 spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
1055                 return 0;
1056         } else {
1057                 spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
1058                 return 1;
1059         }
1060
1061 }
1062
1063
1064 static int olympic_close(struct net_device *dev)
1065 {
1066         struct olympic_private *olympic_priv=netdev_priv(dev);
1067         u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio,*srb;
1068         unsigned long t,flags;
1069
1070         DECLARE_WAITQUEUE(wait,current) ;
1071
1072         netif_stop_queue(dev);
1073
1074         writel(olympic_priv->srb,olympic_mmio+LAPA);
1075         srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
1076
1077         writeb(SRB_CLOSE_ADAPTER,srb+0);
1078         writeb(0,srb+1);
1079         writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1080
1081         add_wait_queue(&olympic_priv->srb_wait,&wait) ;
1082         set_current_state(TASK_INTERRUPTIBLE) ;
1083
1084         spin_lock_irqsave(&olympic_priv->olympic_lock,flags);
1085         olympic_priv->srb_queued=1;
1086
1087         writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1088         spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
1089
1090         while(olympic_priv->srb_queued) {
1091
1092                 t = schedule_timeout_interruptible(60*HZ);
1093
1094                 if(signal_pending(current))     {
1095                         printk(KERN_WARNING "%s: SRB timed out.\n",dev->name);
1096                         printk(KERN_WARNING "SISR=%x MISR=%x\n",readl(olympic_mmio+SISR),readl(olympic_mmio+LISR));
1097                         olympic_priv->srb_queued=0;
1098                         break;
1099                 }
1100
1101                 if (t == 0) {
1102                         printk(KERN_WARNING "%s: SRB timed out. May not be fatal. \n",dev->name) ;
1103                 }
1104                 olympic_priv->srb_queued=0;
1105         }
1106         remove_wait_queue(&olympic_priv->srb_wait,&wait) ;
1107
1108         olympic_priv->rx_status_last_received++;
1109         olympic_priv->rx_status_last_received&=OLYMPIC_RX_RING_SIZE-1;
1110
1111         olympic_freemem(dev) ;
1112
1113         /* reset tx/rx fifo's and busmaster logic */
1114
1115         writel(readl(olympic_mmio+BCTL)|(3<<13),olympic_mmio+BCTL);
1116         udelay(1);
1117         writel(readl(olympic_mmio+BCTL)&~(3<<13),olympic_mmio+BCTL);
1118
1119 #if OLYMPIC_DEBUG
1120         {
1121         int i ;
1122         printk("srb(%p): ",srb);
1123         for(i=0;i<4;i++)
1124                 printk("%x ",readb(srb+i));
1125         printk("\n");
1126         }
1127 #endif
1128         free_irq(dev->irq,dev);
1129
1130         return 0;
1131
1132 }
1133
1134 static void olympic_set_rx_mode(struct net_device *dev)
1135 {
1136         struct olympic_private *olympic_priv = netdev_priv(dev);
1137         u8 __iomem *olympic_mmio = olympic_priv->olympic_mmio ;
1138         u8 options = 0;
1139         u8 __iomem *srb;
1140         struct dev_mc_list *dmi ;
1141         unsigned char dev_mc_address[4] ;
1142         int i ;
1143
1144         writel(olympic_priv->srb,olympic_mmio+LAPA);
1145         srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
1146         options = olympic_priv->olympic_copy_all_options;
1147
1148         if (dev->flags&IFF_PROMISC)
1149                 options |= 0x61 ;
1150         else
1151                 options &= ~0x61 ;
1152
1153         /* Only issue the srb if there is a change in options */
1154
1155         if ((options ^ olympic_priv->olympic_copy_all_options)) {
1156
1157                 /* Now to issue the srb command to alter the copy.all.options */
1158
1159                 writeb(SRB_MODIFY_RECEIVE_OPTIONS,srb);
1160                 writeb(0,srb+1);
1161                 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1162                 writeb(0,srb+3);
1163                 writeb(olympic_priv->olympic_receive_options,srb+4);
1164                 writeb(options,srb+5);
1165
1166                 olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
1167
1168                 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1169
1170                 olympic_priv->olympic_copy_all_options = options ;
1171
1172                 return ;
1173         }
1174
1175         /* Set the functional addresses we need for multicast */
1176
1177         dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ;
1178
1179         for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next) {
1180                 dev_mc_address[0] |= dmi->dmi_addr[2] ;
1181                 dev_mc_address[1] |= dmi->dmi_addr[3] ;
1182                 dev_mc_address[2] |= dmi->dmi_addr[4] ;
1183                 dev_mc_address[3] |= dmi->dmi_addr[5] ;
1184         }
1185
1186         writeb(SRB_SET_FUNC_ADDRESS,srb+0);
1187         writeb(0,srb+1);
1188         writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1189         writeb(0,srb+3);
1190         writeb(0,srb+4);
1191         writeb(0,srb+5);
1192         writeb(dev_mc_address[0],srb+6);
1193         writeb(dev_mc_address[1],srb+7);
1194         writeb(dev_mc_address[2],srb+8);
1195         writeb(dev_mc_address[3],srb+9);
1196
1197         olympic_priv->srb_queued = 2 ;
1198         writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1199
1200 }
1201
1202 static void olympic_srb_bh(struct net_device *dev)
1203 {
1204         struct olympic_private *olympic_priv = netdev_priv(dev);
1205         u8 __iomem *olympic_mmio = olympic_priv->olympic_mmio ;
1206         u8 __iomem *srb;
1207
1208         writel(olympic_priv->srb,olympic_mmio+LAPA);
1209         srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
1210
1211         switch (readb(srb)) {
1212
1213                 /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous)
1214                  * At some point we should do something if we get an error, such as
1215                  * resetting the IFF_PROMISC flag in dev
1216                  */
1217
1218                 case SRB_MODIFY_RECEIVE_OPTIONS:
1219                         switch (readb(srb+2)) {
1220                                 case 0x01:
1221                                         printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name) ;
1222                                         break ;
1223                                 case 0x04:
1224                                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name);
1225                                         break ;
1226                                 default:
1227                                         if (olympic_priv->olympic_message_level)
1228                                                 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",dev->name,olympic_priv->olympic_copy_all_options, olympic_priv->olympic_receive_options) ;
1229                                         break ;
1230                         } /* switch srb[2] */
1231                         break ;
1232
1233                 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1234                  */
1235
1236                 case SRB_SET_GROUP_ADDRESS:
1237                         switch (readb(srb+2)) {
1238                                 case 0x00:
1239                                         break ;
1240                                 case 0x01:
1241                                         printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1242                                         break ;
1243                                 case 0x04:
1244                                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name);
1245                                         break ;
1246                                 case 0x3c:
1247                                         printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n",dev->name) ;
1248                                         break ;
1249                                 case 0x3e: /* If we ever implement individual multicast addresses, will need to deal with this */
1250                                         printk(KERN_WARNING "%s: Group address registers full\n",dev->name) ;
1251                                         break ;
1252                                 case 0x55:
1253                                         printk(KERN_INFO "%s: Group Address already set.\n",dev->name) ;
1254                                         break ;
1255                                 default:
1256                                         break ;
1257                         } /* switch srb[2] */
1258                         break ;
1259
1260                 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1261                  */
1262
1263                 case SRB_RESET_GROUP_ADDRESS:
1264                         switch (readb(srb+2)) {
1265                                 case 0x00:
1266                                         break ;
1267                                 case 0x01:
1268                                         printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1269                                         break ;
1270                                 case 0x04:
1271                                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1272                                         break ;
1273                                 case 0x39: /* Must deal with this if individual multicast addresses used */
1274                                         printk(KERN_INFO "%s: Group address not found \n",dev->name);
1275                                         break ;
1276                                 default:
1277                                         break ;
1278                         } /* switch srb[2] */
1279                         break ;
1280
1281
1282                 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1283                  */
1284
1285                 case SRB_SET_FUNC_ADDRESS:
1286                         switch (readb(srb+2)) {
1287                                 case 0x00:
1288                                         if (olympic_priv->olympic_message_level)
1289                                                 printk(KERN_INFO "%s: Functional Address Mask Set \n",dev->name) ;
1290                                         break ;
1291                                 case 0x01:
1292                                         printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1293                                         break ;
1294                                 case 0x04:
1295                                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1296                                         break ;
1297                                 default:
1298                                         break ;
1299                         } /* switch srb[2] */
1300                         break ;
1301
1302                 /* SRB_READ_LOG - Read and reset the adapter error counters
1303                  */
1304
1305                 case SRB_READ_LOG:
1306                         switch (readb(srb+2)) {
1307                                 case 0x00:
1308                                         if (olympic_priv->olympic_message_level)
1309                                                 printk(KERN_INFO "%s: Read Log issued\n",dev->name) ;
1310                                         break ;
1311                                 case 0x01:
1312                                         printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1313                                         break ;
1314                                 case 0x04:
1315                                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1316                                         break ;
1317
1318                         } /* switch srb[2] */
1319                         break ;
1320
1321                 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1322
1323                 case SRB_READ_SR_COUNTERS:
1324                         switch (readb(srb+2)) {
1325                                 case 0x00:
1326                                         if (olympic_priv->olympic_message_level)
1327                                                 printk(KERN_INFO "%s: Read Source Routing Counters issued\n",dev->name) ;
1328                                         break ;
1329                                 case 0x01:
1330                                         printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1331                                         break ;
1332                                 case 0x04:
1333                                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1334                                         break ;
1335                                 default:
1336                                         break ;
1337                         } /* switch srb[2] */
1338                         break ;
1339
1340                 default:
1341                         printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n",dev->name);
1342                         break ;
1343         } /* switch srb[0] */
1344
1345 }
1346
1347 static struct net_device_stats * olympic_get_stats(struct net_device *dev)
1348 {
1349         struct olympic_private *olympic_priv ;
1350         olympic_priv=netdev_priv(dev);
1351         return (struct net_device_stats *) &olympic_priv->olympic_stats;
1352 }
1353
1354 static int olympic_set_mac_address (struct net_device *dev, void *addr)
1355 {
1356         struct sockaddr *saddr = addr ;
1357         struct olympic_private *olympic_priv = netdev_priv(dev);
1358
1359         if (netif_running(dev)) {
1360                 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name) ;
1361                 return -EIO ;
1362         }
1363
1364         memcpy(olympic_priv->olympic_laa, saddr->sa_data,dev->addr_len) ;
1365
1366         if (olympic_priv->olympic_message_level) {
1367                 printk(KERN_INFO "%s: MAC/LAA Set to  = %x.%x.%x.%x.%x.%x\n",dev->name, olympic_priv->olympic_laa[0],
1368                 olympic_priv->olympic_laa[1], olympic_priv->olympic_laa[2],
1369                 olympic_priv->olympic_laa[3], olympic_priv->olympic_laa[4],
1370                 olympic_priv->olympic_laa[5]);
1371         }
1372
1373         return 0 ;
1374 }
1375
1376 static void olympic_arb_cmd(struct net_device *dev)
1377 {
1378         struct olympic_private *olympic_priv = netdev_priv(dev);
1379         u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
1380         u8 __iomem *arb_block, *asb_block, *srb  ;
1381         u8 header_len ;
1382         u16 frame_len, buffer_len ;
1383         struct sk_buff *mac_frame ;
1384         u8 __iomem *buf_ptr ;
1385         u8 __iomem *frame_data ;
1386         u16 buff_off ;
1387         u16 lan_status = 0, lan_status_diff  ; /* Initialize to stop compiler warning */
1388         u8 fdx_prot_error ;
1389         u16 next_ptr;
1390
1391         arb_block = (olympic_priv->olympic_lap + olympic_priv->arb) ;
1392         asb_block = (olympic_priv->olympic_lap + olympic_priv->asb) ;
1393         srb = (olympic_priv->olympic_lap + olympic_priv->srb) ;
1394
1395         if (readb(arb_block+0) == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
1396
1397                 header_len = readb(arb_block+8) ; /* 802.5 Token-Ring Header Length */
1398                 frame_len = swab16(readw(arb_block + 10)) ;
1399
1400                 buff_off = swab16(readw(arb_block + 6)) ;
1401
1402                 buf_ptr = olympic_priv->olympic_lap + buff_off ;
1403
1404 #if OLYMPIC_DEBUG
1405 {
1406                 int i;
1407                 frame_data = buf_ptr+offsetof(struct mac_receive_buffer,frame_data) ;
1408
1409                 for (i=0 ;  i < 14 ; i++) {
1410                         printk("Loc %d = %02x\n",i,readb(frame_data + i));
1411                 }
1412
1413                 printk("next %04x, fs %02x, len %04x \n",readw(buf_ptr+offsetof(struct mac_receive_buffer,next)), readb(buf_ptr+offsetof(struct mac_receive_buffer,frame_status)), readw(buf_ptr+offsetof(struct mac_receive_buffer,buffer_length)));
1414 }
1415 #endif
1416                 mac_frame = dev_alloc_skb(frame_len) ;
1417                 if (!mac_frame) {
1418                         printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n", dev->name);
1419                         goto drop_frame;
1420                 }
1421
1422                 /* Walk the buffer chain, creating the frame */
1423
1424                 do {
1425                         frame_data = buf_ptr+offsetof(struct mac_receive_buffer,frame_data) ;
1426                         buffer_len = swab16(readw(buf_ptr+offsetof(struct mac_receive_buffer,buffer_length)));
1427                         memcpy_fromio(skb_put(mac_frame, buffer_len), frame_data , buffer_len ) ;
1428                         next_ptr=readw(buf_ptr+offsetof(struct mac_receive_buffer,next));
1429                 } while (next_ptr && (buf_ptr=olympic_priv->olympic_lap + swab16(next_ptr)));
1430
1431                 mac_frame->protocol = tr_type_trans(mac_frame, dev);
1432
1433                 if (olympic_priv->olympic_network_monitor) {
1434                         struct trh_hdr *mac_hdr;
1435                         printk(KERN_WARNING "%s: Received MAC Frame, details: \n",dev->name);
1436                         mac_hdr = tr_hdr(mac_frame);
1437                         printk(KERN_WARNING "%s: MAC Frame Dest. Addr: %pM\n",
1438                                dev->name, mac_hdr->daddr);
1439                         printk(KERN_WARNING "%s: MAC Frame Srce. Addr: %pM\n",
1440                                dev->name, mac_hdr->saddr);
1441                 }
1442                 netif_rx(mac_frame);
1443
1444 drop_frame:
1445                 /* Now tell the card we have dealt with the received frame */
1446
1447                 /* Set LISR Bit 1 */
1448                 writel(LISR_ARB_FREE,olympic_priv->olympic_mmio + LISR_SUM);
1449
1450                 /* Is the ASB free ? */
1451
1452                 if (readb(asb_block + 2) != 0xff) {
1453                         olympic_priv->asb_queued = 1 ;
1454                         writel(LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
1455                         return ;
1456                         /* Drop out and wait for the bottom half to be run */
1457                 }
1458
1459                 writeb(ASB_RECEIVE_DATA,asb_block); /* Receive data */
1460                 writeb(OLYMPIC_CLEAR_RET_CODE,asb_block+2); /* Necessary ?? */
1461                 writeb(readb(arb_block+6),asb_block+6); /* Must send the address back to the adapter */
1462                 writeb(readb(arb_block+7),asb_block+7); /* To let it know we have dealt with the data */
1463
1464                 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
1465
1466                 olympic_priv->asb_queued = 2 ;
1467
1468                 return ;
1469
1470         } else if (readb(arb_block) == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
1471                 lan_status = swab16(readw(arb_block+6));
1472                 fdx_prot_error = readb(arb_block+8) ;
1473
1474                 /* Issue ARB Free */
1475                 writel(LISR_ARB_FREE,olympic_priv->olympic_mmio+LISR_SUM);
1476
1477                 lan_status_diff = olympic_priv->olympic_lan_status ^ lan_status ;
1478
1479                 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR) ) {
1480                         if (lan_status_diff & LSC_LWF)
1481                                         printk(KERN_WARNING "%s: Short circuit detected on the lobe\n",dev->name);
1482                         if (lan_status_diff & LSC_ARW)
1483                                         printk(KERN_WARNING "%s: Auto removal error\n",dev->name);
1484                         if (lan_status_diff & LSC_FPE)
1485                                         printk(KERN_WARNING "%s: FDX Protocol Error\n",dev->name);
1486                         if (lan_status_diff & LSC_RR)
1487                                         printk(KERN_WARNING "%s: Force remove MAC frame received\n",dev->name);
1488
1489                         /* Adapter has been closed by the hardware */
1490
1491                         /* reset tx/rx fifo's and busmaster logic */
1492
1493                         writel(readl(olympic_mmio+BCTL)|(3<<13),olympic_mmio+BCTL);
1494                         udelay(1);
1495                         writel(readl(olympic_mmio+BCTL)&~(3<<13),olympic_mmio+BCTL);
1496                         netif_stop_queue(dev);
1497                         olympic_priv->srb = readw(olympic_priv->olympic_lap + LAPWWO) ;
1498                         printk(KERN_WARNING "%s: Adapter has been closed \n", dev->name) ;
1499                 } /* If serious error */
1500
1501                 if (olympic_priv->olympic_message_level) {
1502                         if (lan_status_diff & LSC_SIG_LOSS)
1503                                         printk(KERN_WARNING "%s: No receive signal detected \n", dev->name) ;
1504                         if (lan_status_diff & LSC_HARD_ERR)
1505                                         printk(KERN_INFO "%s: Beaconing \n",dev->name);
1506                         if (lan_status_diff & LSC_SOFT_ERR)
1507                                         printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n",dev->name);
1508                         if (lan_status_diff & LSC_TRAN_BCN)
1509                                         printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n",dev->name);
1510                         if (lan_status_diff & LSC_SS)
1511                                         printk(KERN_INFO "%s: Single Station on the ring \n", dev->name);
1512                         if (lan_status_diff & LSC_RING_REC)
1513                                         printk(KERN_INFO "%s: Ring recovery ongoing\n",dev->name);
1514                         if (lan_status_diff & LSC_FDX_MODE)
1515                                         printk(KERN_INFO "%s: Operating in FDX mode\n",dev->name);
1516                 }
1517
1518                 if (lan_status_diff & LSC_CO) {
1519
1520                                 if (olympic_priv->olympic_message_level)
1521                                         printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1522
1523                                 /* Issue READ.LOG command */
1524
1525                                 writeb(SRB_READ_LOG, srb);
1526                                 writeb(0,srb+1);
1527                                 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1528                                 writeb(0,srb+3);
1529                                 writeb(0,srb+4);
1530                                 writeb(0,srb+5);
1531
1532                                 olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
1533
1534                                 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1535
1536                 }
1537
1538                 if (lan_status_diff & LSC_SR_CO) {
1539
1540                                 if (olympic_priv->olympic_message_level)
1541                                         printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
1542
1543                                 /* Issue a READ.SR.COUNTERS */
1544
1545                                 writeb(SRB_READ_SR_COUNTERS,srb);
1546                                 writeb(0,srb+1);
1547                                 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1548                                 writeb(0,srb+3);
1549
1550                                 olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
1551
1552                                 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1553
1554                 }
1555
1556                 olympic_priv->olympic_lan_status = lan_status ;
1557
1558         }  /* Lan.change.status */
1559         else
1560                 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1561 }
1562
1563 static void olympic_asb_bh(struct net_device *dev)
1564 {
1565         struct olympic_private *olympic_priv = netdev_priv(dev);
1566         u8 __iomem *arb_block, *asb_block ;
1567
1568         arb_block = (olympic_priv->olympic_lap + olympic_priv->arb) ;
1569         asb_block = (olympic_priv->olympic_lap + olympic_priv->asb) ;
1570
1571         if (olympic_priv->asb_queued == 1) {   /* Dropped through the first time */
1572
1573                 writeb(ASB_RECEIVE_DATA,asb_block); /* Receive data */
1574                 writeb(OLYMPIC_CLEAR_RET_CODE,asb_block+2); /* Necessary ?? */
1575                 writeb(readb(arb_block+6),asb_block+6); /* Must send the address back to the adapter */
1576                 writeb(readb(arb_block+7),asb_block+7); /* To let it know we have dealt with the data */
1577
1578                 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
1579                 olympic_priv->asb_queued = 2 ;
1580
1581                 return ;
1582         }
1583
1584         if (olympic_priv->asb_queued == 2) {
1585                 switch (readb(asb_block+2)) {
1586                         case 0x01:
1587                                 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1588                                 break ;
1589                         case 0x26:
1590                                 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1591                                 break ;
1592                         case 0xFF:
1593                                 /* Valid response, everything should be ok again */
1594                                 break ;
1595                         default:
1596                                 printk(KERN_WARNING "%s: Invalid return code in asb\n",dev->name);
1597                                 break ;
1598                 }
1599         }
1600         olympic_priv->asb_queued = 0 ;
1601 }
1602
1603 static int olympic_change_mtu(struct net_device *dev, int mtu)
1604 {
1605         struct olympic_private *olympic_priv = netdev_priv(dev);
1606         u16 max_mtu ;
1607
1608         if (olympic_priv->olympic_ring_speed == 4)
1609                 max_mtu = 4500 ;
1610         else
1611                 max_mtu = 18000 ;
1612
1613         if (mtu > max_mtu)
1614                 return -EINVAL ;
1615         if (mtu < 100)
1616                 return -EINVAL ;
1617
1618         dev->mtu = mtu ;
1619         olympic_priv->pkt_buf_sz = mtu + TR_HLEN ;
1620
1621         return 0 ;
1622 }
1623
1624 static int olympic_proc_info(char *buffer, char **start, off_t offset, int length, int *eof, void *data)
1625 {
1626         struct net_device *dev = (struct net_device *)data ;
1627         struct olympic_private *olympic_priv=netdev_priv(dev);
1628         u8 __iomem *oat = (olympic_priv->olympic_lap + olympic_priv->olympic_addr_table_addr) ;
1629         u8 __iomem *opt = (olympic_priv->olympic_lap + olympic_priv->olympic_parms_addr) ;
1630         int size = 0 ;
1631         int len=0;
1632         off_t begin=0;
1633         off_t pos=0;
1634         u8 addr[6];
1635         u8 addr2[6];
1636         int i;
1637
1638         size = sprintf(buffer,
1639                 "IBM Pit/Pit-Phy/Olympic Chipset Token Ring Adapter %s\n",dev->name);
1640         size += sprintf(buffer+size, "\n%6s: Adapter Address   : Node Address      : Functional Addr\n",
1641            dev->name);
1642
1643         for (i = 0 ; i < 6 ; i++)
1644                 addr[i] = readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr) + i);
1645
1646         size += sprintf(buffer+size, "%6s: %pM : %pM : %02x:%02x:%02x:%02x\n",
1647            dev->name,
1648            dev->dev_addr, addr,
1649            readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)),
1650            readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+1),
1651            readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+2),
1652            readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+3));
1653
1654         size += sprintf(buffer+size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1655
1656         size += sprintf(buffer+size, "%6s: Physical Addr : Up Node Address   : Poll Address      : AccPri : Auth Src : Att Code :\n",
1657           dev->name) ;
1658
1659         for (i = 0 ; i < 6 ; i++)
1660                 addr[i] = readb(opt+offsetof(struct olympic_parameters_table, up_node_addr) + i);
1661         for (i = 0 ; i < 6 ; i++)
1662                 addr2[i] =  readb(opt+offsetof(struct olympic_parameters_table, poll_addr) + i);
1663
1664         size += sprintf(buffer+size, "%6s: %02x:%02x:%02x:%02x   : %pM : %pM : %04x   : %04x     :  %04x    :\n",
1665           dev->name,
1666           readb(opt+offsetof(struct olympic_parameters_table, phys_addr)),
1667           readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+1),
1668           readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+2),
1669           readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+3),
1670           addr, addr2,
1671           swab16(readw(opt+offsetof(struct olympic_parameters_table, acc_priority))),
1672           swab16(readw(opt+offsetof(struct olympic_parameters_table, auth_source_class))),
1673           swab16(readw(opt+offsetof(struct olympic_parameters_table, att_code))));
1674
1675         size += sprintf(buffer+size, "%6s: Source Address    : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n",
1676           dev->name) ;
1677
1678         for (i = 0 ; i < 6 ; i++)
1679                 addr[i] = readb(opt+offsetof(struct olympic_parameters_table, source_addr) + i);
1680         size += sprintf(buffer+size, "%6s: %pM : %04x  : %04x   : %04x   : %04x   : %04x    :     %04x     : \n",
1681           dev->name, addr,
1682           swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_type))),
1683           swab16(readw(opt+offsetof(struct olympic_parameters_table, major_vector))),
1684           swab16(readw(opt+offsetof(struct olympic_parameters_table, lan_status))),
1685           swab16(readw(opt+offsetof(struct olympic_parameters_table, local_ring))),
1686           swab16(readw(opt+offsetof(struct olympic_parameters_table, mon_error))),
1687           swab16(readw(opt+offsetof(struct olympic_parameters_table, frame_correl))));
1688
1689         size += sprintf(buffer+size, "%6s: Beacon Details :  Tx  :  Rx  : NAUN Node Address : NAUN Node Phys : \n",
1690           dev->name) ;
1691
1692         for (i = 0 ; i < 6 ; i++)
1693                 addr[i] = readb(opt+offsetof(struct olympic_parameters_table, beacon_naun) + i);
1694         size += sprintf(buffer+size, "%6s:                :  %02x  :  %02x  : %pM : %02x:%02x:%02x:%02x    : \n",
1695           dev->name,
1696           swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_transmit))),
1697           swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_receive))),
1698           addr,
1699           readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)),
1700           readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+1),
1701           readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+2),
1702           readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+3));
1703
1704         len=size;
1705         pos=begin+size;
1706         if (pos<offset) {
1707                 len=0;
1708                 begin=pos;
1709         }
1710         *start=buffer+(offset-begin);   /* Start of wanted data */
1711         len-=(offset-begin);            /* Start slop */
1712         if(len>length)
1713                 len=length;             /* Ending slop */
1714         return len;
1715 }
1716
1717 static void __devexit olympic_remove_one(struct pci_dev *pdev)
1718 {
1719         struct net_device *dev = pci_get_drvdata(pdev) ;
1720         struct olympic_private *olympic_priv=netdev_priv(dev);
1721
1722         if (olympic_priv->olympic_network_monitor) {
1723                 char proc_name[20] ;
1724                 strcpy(proc_name,"olympic_") ;
1725                 strcat(proc_name,dev->name) ;
1726                 remove_proc_entry(proc_name,init_net.proc_net);
1727         }
1728         unregister_netdev(dev) ;
1729         iounmap(olympic_priv->olympic_mmio) ;
1730         iounmap(olympic_priv->olympic_lap) ;
1731         pci_release_regions(pdev) ;
1732         pci_set_drvdata(pdev,NULL) ;
1733         free_netdev(dev) ;
1734 }
1735
1736 static struct pci_driver olympic_driver = {
1737         .name           = "olympic",
1738         .id_table       = olympic_pci_tbl,
1739         .probe          = olympic_probe,
1740         .remove         = __devexit_p(olympic_remove_one),
1741 };
1742
1743 static int __init olympic_pci_init(void)
1744 {
1745         return pci_register_driver(&olympic_driver) ;
1746 }
1747
1748 static void __exit olympic_pci_cleanup(void)
1749 {
1750         pci_unregister_driver(&olympic_driver) ;
1751 }
1752
1753
1754 module_init(olympic_pci_init) ;
1755 module_exit(olympic_pci_cleanup) ;
1756
1757 MODULE_LICENSE("GPL");