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