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