drivers/net/tokenring/lanstreamer.c

   1 /*
   2  *   lanstreamer.c -- driver for the IBM Auto LANStreamer PCI Adapter
   3  *
   4  *  Written By: Mike Sullivan, IBM Corporation
   5  *
   6  *  Copyright (C) 1999 IBM Corporation
   7  *
   8  *  Linux driver for IBM PCI tokenring cards based on the LanStreamer MPC
   9  *  chipset.
  10  *
  11  *  This driver is based on the olympic driver for IBM PCI TokenRing cards (Pit/Pit-Phy/Olympic
  12  *  chipsets) written  by:
  13  *      1999 Peter De Schrijver All Rights Reserved
  14  *      1999 Mike Phillips (phillim@amtrak.com)
  15  *
  16  *  Base Driver Skeleton:
  17  *      Written 1993-94 by Donald Becker.
  18  *
  19  *      Copyright 1993 United States Government as represented by the
  20  *      Director, National Security Agency.
  21  *
  22  * This program is free software; you can redistribute it and/or modify
  23  * it under the terms of the GNU General Public License as published by
  24  * the Free Software Foundation; either version 2 of the License, or
  25  * (at your option) any later version.
  26  *
  27  * This program is distributed in the hope that it will be useful,
  28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  * GNU General Public License for more details.
  31  *
  32  * NO WARRANTY
  33  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  34  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  35  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  36  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  37  * solely responsible for determining the appropriateness of using and
  38  * distributing the Program and assumes all risks associated with its
  39  * exercise of rights under this Agreement, including but not limited to
  40  * the risks and costs of program errors, damage to or loss of data,
  41  * programs or equipment, and unavailability or interruption of operations.
  42  *
  43  * DISCLAIMER OF LIABILITY
  44  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  45  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  47  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  48  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  49  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  50  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  51  *
  52  * You should have received a copy of the GNU General Public License
  53  * along with this program; if not, write to the Free Software
  54  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  55  *
  56  *
  57  *  12/10/99 - Alpha Release 0.1.0
  58  *            First release to the public
  59  *  03/03/00 - Merged to kernel, indented -kr -i8 -bri0, fixed some missing
  60  *              malloc free checks, reviewed code. <alan@redhat.com>
  61  *  03/13/00 - Added spinlocks for smp
  62  *  03/08/01 - Added support for module_init() and module_exit()
  63  *  08/15/01 - Added ioctl() functionality for debugging, changed netif_*_queue
  64  *             calls and other incorrectness - Kent Yoder <yoder1@us.ibm.com>
  65  *  11/05/01 - Restructured the interrupt function, added delays, reduced the
  66  *             the number of TX descriptors to 1, which together can prevent
  67  *             the card from locking up the box - <yoder1@us.ibm.com>
  68  *  09/27/02 - New PCI interface + bug fix. - <yoder1@us.ibm.com>
  69  *  11/13/02 - Removed free_irq calls which could cause a hang, added
  70  *             netif_carrier_{on|off} - <yoder1@us.ibm.com>
  71  *
  72  *  To Do:
  73  *
  74  *
  75  *  If Problems do Occur
  76  *  Most problems can be rectified by either closing and opening the interface
  77  *  (ifconfig down and up) or rmmod and insmod'ing the driver (a bit difficult
  78  *  if compiled into the kernel).
  79  */
  80
  81 /* Change STREAMER_DEBUG to 1 to get verbose, and I mean really verbose, messages */
  82
  83 #define STREAMER_DEBUG 0
  84 #define STREAMER_DEBUG_PACKETS 0
  85
  86 /* Change STREAMER_NETWORK_MONITOR to receive mac frames through the arb channel.
  87  * Will also create a /proc/net/streamer_tr entry if proc_fs is compiled into the
  88  * kernel.
  89  * Intended to be used to create a ring-error reporting network module
  90  * i.e. it will give you the source address of beaconers on the ring
  91  */
  92
  93 #define STREAMER_NETWORK_MONITOR 0
  94
  95 /* #define CONFIG_PROC_FS */
  96
  97 /*
  98  *  Allow or disallow ioctl's for debugging
  99  */
 100
 101 #define STREAMER_IOCTL 0
 102
 103 #include <linux/module.h>
 104 #include <linux/kernel.h>
 105 #include <linux/errno.h>
 106 #include <linux/timer.h>
 107 #include <linux/in.h>
 108 #include <linux/ioport.h>
 109 #include <linux/string.h>
 110 #include <linux/proc_fs.h>
 111 #include <linux/ptrace.h>
 112 #include <linux/skbuff.h>
 113 #include <linux/interrupt.h>
 114 #include <linux/delay.h>
 115 #include <linux/netdevice.h>
 116 #include <linux/trdevice.h>
 117 #include <linux/stddef.h>
 118 #include <linux/init.h>
 119 #include <linux/pci.h>
 120 #include <linux/dma-mapping.h>
 121 #include <linux/spinlock.h>
 122 #include <linux/bitops.h>
 123 #include <linux/jiffies.h>
 124
 125 #include <net/net_namespace.h>
 126 #include <net/checksum.h>
 127
 128 #include <asm/io.h>
 129 #include <asm/system.h>
 130
 131 #include "lanstreamer.h"
 132
 133 #if (BITS_PER_LONG == 64)
 134 #error broken on 64-bit: stores pointer to rx_ring->buffer in 32-bit int
 135 #endif
 136
 137
 138 /* I've got to put some intelligence into the version number so that Peter and I know
 139  * which version of the code somebody has got.
 140  * Version Number = a.b.c.d  where a.b.c is the level of code and d is the latest author.
 141  * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike
 142  *
 143  * Official releases will only have an a.b.c version number format.
 144  */
 145
 146 static char version[] = "LanStreamer.c v0.4.0 03/08/01 - Mike Sullivan\n"
 147                         "              v0.5.3 11/13/02 - Kent Yoder";
 148
 149 static DEFINE_PCI_DEVICE_TABLE(streamer_pci_tbl) = {
 150         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_TR, PCI_ANY_ID, PCI_ANY_ID,},
 151         {}      /* terminating entry */
 152 };
 153 MODULE_DEVICE_TABLE(pci,streamer_pci_tbl);
 154
 155
 156 static char *open_maj_error[] = {
 157         "No error", "Lobe Media Test", "Physical Insertion",
 158         "Address Verification", "Neighbor Notification (Ring Poll)",
 159         "Request Parameters", "FDX Registration Request",
 160         "FDX Lobe Media Test", "FDX Duplicate Address Check",
 161         "Unknown stage"
 162 };
 163
 164 static char *open_min_error[] = {
 165         "No error", "Function Failure", "Signal Lost", "Wire Fault",
 166         "Ring Speed Mismatch", "Timeout", "Ring Failure", "Ring Beaconing",
 167         "Duplicate Node Address", "Request Parameters", "Remove Received",
 168         "Reserved", "Reserved", "No Monitor Detected for RPL",
 169         "Monitor Contention failer for RPL", "FDX Protocol Error"
 170 };
 171
 172 /* Module parameters */
 173
 174 /* Ring Speed 0,4,16
 175  * 0 = Autosense
 176  * 4,16 = Selected speed only, no autosense
 177  * This allows the card to be the first on the ring
 178  * and become the active monitor.
 179  *
 180  * WARNING: Some hubs will allow you to insert
 181  * at the wrong speed
 182  */
 183
 184 static int ringspeed[STREAMER_MAX_ADAPTERS] = { 0, };
 185
 186 module_param_array(ringspeed, int, NULL, 0);
 187
 188 /* Packet buffer size */
 189
 190 static int pkt_buf_sz[STREAMER_MAX_ADAPTERS] = { 0, };
 191
 192 module_param_array(pkt_buf_sz, int, NULL, 0);
 193
 194 /* Message Level */
 195
 196 static int message_level[STREAMER_MAX_ADAPTERS] = { 1, };
 197
 198 module_param_array(message_level, int, NULL, 0);
 199
 200 #if STREAMER_IOCTL
 201 static int streamer_ioctl(struct net_device *, struct ifreq *, int);
 202 #endif
 203
 204 static int streamer_reset(struct net_device *dev);
 205 static int streamer_open(struct net_device *dev);
 206 static netdev_tx_t streamer_xmit(struct sk_buff *skb,
 207                                        struct net_device *dev);
 208 static int streamer_close(struct net_device *dev);
 209 static void streamer_set_rx_mode(struct net_device *dev);
 210 static irqreturn_t streamer_interrupt(int irq, void *dev_id);
 211 static int streamer_set_mac_address(struct net_device *dev, void *addr);
 212 static void streamer_arb_cmd(struct net_device *dev);
 213 static int streamer_change_mtu(struct net_device *dev, int mtu);
 214 static void streamer_srb_bh(struct net_device *dev);
 215 static void streamer_asb_bh(struct net_device *dev);
 216 #if STREAMER_NETWORK_MONITOR
 217 #ifdef CONFIG_PROC_FS
 218 static int streamer_proc_info(char *buffer, char **start, off_t offset,
 219                               int length, int *eof, void *data);
 220 static int sprintf_info(char *buffer, struct net_device *dev);
 221 struct streamer_private *dev_streamer=NULL;
 222 #endif
 223 #endif
 224
 225 static const struct net_device_ops streamer_netdev_ops = {
 226         .ndo_open               = streamer_open,
 227         .ndo_stop               = streamer_close,
 228         .ndo_start_xmit         = streamer_xmit,
 229         .ndo_change_mtu         = streamer_change_mtu,
 230 #if STREAMER_IOCTL
 231         .ndo_do_ioctl           = streamer_ioctl,
 232 #endif
 233         .ndo_set_multicast_list = streamer_set_rx_mode,
 234         .ndo_set_mac_address    = streamer_set_mac_address,
 235 };
 236
 237 static int __devinit streamer_init_one(struct pci_dev *pdev,
 238                                        const struct pci_device_id *ent)
 239 {
 240         struct net_device *dev;
 241         struct streamer_private *streamer_priv;
 242         unsigned long pio_start, pio_end, pio_flags, pio_len;
 243         unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
 244         int rc = 0;
 245         static int card_no=-1;
 246         u16 pcr;
 247
 248 #if STREAMER_DEBUG
 249         printk("lanstreamer::streamer_init_one, entry pdev %p\n",pdev);
 250 #endif
 251
 252         card_no++;
 253         dev = alloc_trdev(sizeof(*streamer_priv));
 254         if (dev==NULL) {
 255                 printk(KERN_ERR "lanstreamer: out of memory.\n");
 256                 return -ENOMEM;
 257         }
 258
 259         streamer_priv = netdev_priv(dev);
 260
 261 #if STREAMER_NETWORK_MONITOR
 262 #ifdef CONFIG_PROC_FS
 263         if (!dev_streamer)
 264                 create_proc_read_entry("streamer_tr", 0, init_net.proc_net,
 265                                         streamer_proc_info, NULL);
 266         streamer_priv->next = dev_streamer;
 267         dev_streamer = streamer_priv;
 268 #endif
 269 #endif
 270
 271         rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
 272         if (rc) {
 273                 printk(KERN_ERR "%s: No suitable PCI mapping available.\n",
 274                                 dev->name);
 275                 rc = -ENODEV;
 276                 goto err_out;
 277         }
 278
 279         rc = pci_enable_device(pdev);
 280         if (rc) {
 281                 printk(KERN_ERR "lanstreamer: unable to enable pci device\n");
 282                 rc=-EIO;
 283                 goto err_out;
 284         }
 285
 286         pci_set_master(pdev);
 287
 288         rc = pci_set_mwi(pdev);
 289         if (rc) {
 290                 printk(KERN_ERR "lanstreamer: unable to enable MWI on pci device\n");
 291                 goto err_out_disable;
 292         }
 293
 294         pio_start = pci_resource_start(pdev, 0);
 295         pio_end = pci_resource_end(pdev, 0);
 296         pio_flags = pci_resource_flags(pdev, 0);
 297         pio_len = pci_resource_len(pdev, 0);
 298
 299         mmio_start = pci_resource_start(pdev, 1);
 300         mmio_end = pci_resource_end(pdev, 1);
 301         mmio_flags = pci_resource_flags(pdev, 1);
 302         mmio_len = pci_resource_len(pdev, 1);
 303
 304 #if STREAMER_DEBUG
 305         printk("lanstreamer: pio_start %x pio_end %x pio_len %x pio_flags %x\n",
 306                 pio_start, pio_end, pio_len, pio_flags);
 307         printk("lanstreamer: mmio_start %x mmio_end %x mmio_len %x mmio_flags %x\n",
 308                 mmio_start, mmio_end, mmio_flags, mmio_len);
 309 #endif
 310
 311         if (!request_region(pio_start, pio_len, "lanstreamer")) {
 312                 printk(KERN_ERR "lanstreamer: unable to get pci io addr %lx\n",
 313                         pio_start);
 314                 rc= -EBUSY;
 315                 goto err_out_mwi;
 316         }
 317
 318         if (!request_mem_region(mmio_start, mmio_len, "lanstreamer")) {
 319                 printk(KERN_ERR "lanstreamer: unable to get pci mmio addr %lx\n",
 320                         mmio_start);
 321                 rc= -EBUSY;
 322                 goto err_out_free_pio;
 323         }
 324
 325         streamer_priv->streamer_mmio=ioremap(mmio_start, mmio_len);
 326         if (streamer_priv->streamer_mmio == NULL) {
 327                 printk(KERN_ERR "lanstreamer: unable to remap MMIO %lx\n",
 328                         mmio_start);
 329                 rc= -EIO;
 330                 goto err_out_free_mmio;
 331         }
 332
 333         init_waitqueue_head(&streamer_priv->srb_wait);
 334         init_waitqueue_head(&streamer_priv->trb_wait);
 335
 336         dev->netdev_ops = &streamer_netdev_ops;
 337         dev->irq = pdev->irq;
 338         dev->base_addr=pio_start;
 339         SET_NETDEV_DEV(dev, &pdev->dev);
 340
 341         streamer_priv->streamer_card_name = (char *)pdev->resource[0].name;
 342         streamer_priv->pci_dev = pdev;
 343
 344         if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000))
 345                 streamer_priv->pkt_buf_sz = PKT_BUF_SZ;
 346         else
 347                 streamer_priv->pkt_buf_sz = pkt_buf_sz[card_no];
 348
 349         streamer_priv->streamer_ring_speed = ringspeed[card_no];
 350         streamer_priv->streamer_message_level = message_level[card_no];
 351
 352         pci_set_drvdata(pdev, dev);
 353
 354         spin_lock_init(&streamer_priv->streamer_lock);
 355
 356         pci_read_config_word (pdev, PCI_COMMAND, &pcr);
 357         pcr |= PCI_COMMAND_SERR;
 358         pci_write_config_word (pdev, PCI_COMMAND, pcr);
 359
 360         printk("%s \n", version);
 361         printk("%s: %s. I/O at %hx, MMIO at %p, using irq %d\n",dev->name,
 362                 streamer_priv->streamer_card_name,
 363                 (unsigned int) dev->base_addr,
 364                 streamer_priv->streamer_mmio,
 365                 dev->irq);
 366
 367         if (streamer_reset(dev))
 368                 goto err_out_unmap;
 369
 370         rc = register_netdev(dev);
 371         if (rc)
 372                 goto err_out_unmap;
 373         return 0;
 374
 375 err_out_unmap:
 376         iounmap(streamer_priv->streamer_mmio);
 377 err_out_free_mmio:
 378         release_mem_region(mmio_start, mmio_len);
 379 err_out_free_pio:
 380         release_region(pio_start, pio_len);
 381 err_out_mwi:
 382         pci_clear_mwi(pdev);
 383 err_out_disable:
 384         pci_disable_device(pdev);
 385 err_out:
 386         free_netdev(dev);
 387 #if STREAMER_DEBUG
 388         printk("lanstreamer: Exit error %x\n",rc);
 389 #endif
 390         return rc;
 391 }
 392
 393 static void __devexit streamer_remove_one(struct pci_dev *pdev)
 394 {
 395         struct net_device *dev=pci_get_drvdata(pdev);
 396         struct streamer_private *streamer_priv;
 397
 398 #if STREAMER_DEBUG
 399         printk("lanstreamer::streamer_remove_one entry pdev %p\n",pdev);
 400 #endif
 401
 402         if (dev == NULL) {
 403                 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev is NULL\n");
 404                 return;
 405         }
 406
 407         streamer_priv=netdev_priv(dev);
 408         if (streamer_priv == NULL) {
 409                 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev->priv is NULL\n");
 410                 return;
 411         }
 412
 413 #if STREAMER_NETWORK_MONITOR
 414 #ifdef CONFIG_PROC_FS
 415         {
 416                 struct streamer_private **p, **next;
 417
 418                 for (p = &dev_streamer; *p; p = next) {
 419                         next = &(*p)->next;
 420                         if (*p == streamer_priv) {
 421                                 *p = *next;
 422                                 break;
 423                         }
 424                 }
 425                 if (!dev_streamer)
 426                         remove_proc_entry("streamer_tr", init_net.proc_net);
 427         }
 428 #endif
 429 #endif
 430
 431         unregister_netdev(dev);
 432         iounmap(streamer_priv->streamer_mmio);
 433         release_mem_region(pci_resource_start(pdev, 1), pci_resource_len(pdev,1));
 434         release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev,0));
 435         pci_clear_mwi(pdev);
 436         pci_disable_device(pdev);
 437         free_netdev(dev);
 438         pci_set_drvdata(pdev, NULL);
 439 }
 440
 441
 442 static int streamer_reset(struct net_device *dev)
 443 {
 444         struct streamer_private *streamer_priv;
 445         __u8 __iomem *streamer_mmio;
 446         unsigned long t;
 447         unsigned int uaa_addr;
 448         struct sk_buff *skb = NULL;
 449         __u16 misr;
 450
 451         streamer_priv = netdev_priv(dev);
 452         streamer_mmio = streamer_priv->streamer_mmio;
 453
 454         writew(readw(streamer_mmio + BCTL) | BCTL_SOFTRESET, streamer_mmio + BCTL);
 455         t = jiffies;
 456         /* Hold soft reset bit for a while */
 457         ssleep(1);
 458
 459         writew(readw(streamer_mmio + BCTL) & ~BCTL_SOFTRESET,
 460                streamer_mmio + BCTL);
 461
 462 #if STREAMER_DEBUG
 463         printk("BCTL: %x\n", readw(streamer_mmio + BCTL));
 464         printk("GPR: %x\n", readw(streamer_mmio + GPR));
 465         printk("SISRMASK: %x\n", readw(streamer_mmio + SISR_MASK));
 466 #endif
 467         writew(readw(streamer_mmio + BCTL) | (BCTL_RX_FIFO_8 | BCTL_TX_FIFO_8), streamer_mmio + BCTL );
 468
 469         if (streamer_priv->streamer_ring_speed == 0) {  /* Autosense */
 470                 writew(readw(streamer_mmio + GPR) | GPR_AUTOSENSE,
 471                        streamer_mmio + GPR);
 472                 if (streamer_priv->streamer_message_level)
 473                         printk(KERN_INFO "%s: Ringspeed autosense mode on\n",
 474                                dev->name);
 475         } else if (streamer_priv->streamer_ring_speed == 16) {
 476                 if (streamer_priv->streamer_message_level)
 477                         printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n",
 478                                dev->name);
 479                 writew(GPR_16MBPS, streamer_mmio + GPR);
 480         } else if (streamer_priv->streamer_ring_speed == 4) {
 481                 if (streamer_priv->streamer_message_level)
 482                         printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n",
 483                                dev->name);
 484                 writew(0, streamer_mmio + GPR);
 485         }
 486
 487         skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
 488         if (!skb) {
 489                 printk(KERN_INFO "%s: skb allocation for diagnostics failed...proceeding\n",
 490                        dev->name);
 491         } else {
 492                 struct streamer_rx_desc *rx_ring;
 493                 u8 *data;
 494
 495                 rx_ring=(struct streamer_rx_desc *)skb->data;
 496                 data=((u8 *)skb->data)+sizeof(struct streamer_rx_desc);
 497                 rx_ring->forward=0;
 498                 rx_ring->status=0;
 499                 rx_ring->buffer=cpu_to_le32(pci_map_single(streamer_priv->pci_dev, data,
 500                                                         512, PCI_DMA_FROMDEVICE));
 501                 rx_ring->framelen_buflen=512;
 502                 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, rx_ring, 512, PCI_DMA_FROMDEVICE)),
 503                         streamer_mmio+RXBDA);
 504         }
 505
 506 #if STREAMER_DEBUG
 507         printk("GPR = %x\n", readw(streamer_mmio + GPR));
 508 #endif
 509         /* start solo init */
 510         writew(SISR_MI, streamer_mmio + SISR_MASK_SUM);
 511
 512         while (!((readw(streamer_mmio + SISR)) & SISR_SRB_REPLY)) {
 513                 msleep_interruptible(100);
 514                 if (time_after(jiffies, t + 40 * HZ)) {
 515                         printk(KERN_ERR
 516                                "IBM PCI tokenring card not responding\n");
 517                         release_region(dev->base_addr, STREAMER_IO_SPACE);
 518                         if (skb)
 519                                 dev_kfree_skb(skb);
 520                         return -1;
 521                 }
 522         }
 523         writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
 524         misr = readw(streamer_mmio + MISR_RUM);
 525         writew(~misr, streamer_mmio + MISR_RUM);
 526
 527         if (skb)
 528                 dev_kfree_skb(skb);     /* release skb used for diagnostics */
 529
 530 #if STREAMER_DEBUG
 531         printk("LAPWWO: %x, LAPA: %x LAPE:  %x\n",
 532                readw(streamer_mmio + LAPWWO), readw(streamer_mmio + LAPA),
 533                readw(streamer_mmio + LAPE));
 534 #endif
 535
 536 #if STREAMER_DEBUG
 537         {
 538                 int i;
 539                 writew(readw(streamer_mmio + LAPWWO),
 540                        streamer_mmio + LAPA);
 541                 printk("initialization response srb dump: ");
 542                 for (i = 0; i < 10; i++)
 543                         printk("%x:",
 544                                ntohs(readw(streamer_mmio + LAPDINC)));
 545                 printk("\n");
 546         }
 547 #endif
 548
 549         writew(readw(streamer_mmio + LAPWWO) + 6, streamer_mmio + LAPA);
 550         if (readw(streamer_mmio + LAPD)) {
 551                 printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",
 552                        ntohs(readw(streamer_mmio + LAPD)));
 553                 release_region(dev->base_addr, STREAMER_IO_SPACE);
 554                 return -1;
 555         }
 556
 557         writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA);
 558         uaa_addr = ntohs(readw(streamer_mmio + LAPDINC));
 559         readw(streamer_mmio + LAPDINC); /* skip over Level.Addr field */
 560         streamer_priv->streamer_addr_table_addr = ntohs(readw(streamer_mmio + LAPDINC));
 561         streamer_priv->streamer_parms_addr = ntohs(readw(streamer_mmio + LAPDINC));
 562
 563 #if STREAMER_DEBUG
 564         printk("UAA resides at %x\n", uaa_addr);
 565 #endif
 566
 567         /* setup uaa area for access with LAPD */
 568         {
 569                 int i;
 570                 __u16 addr;
 571                 writew(uaa_addr, streamer_mmio + LAPA);
 572                 for (i = 0; i < 6; i += 2) {
 573                         addr=ntohs(readw(streamer_mmio+LAPDINC));
 574                         dev->dev_addr[i]= (addr >> 8) & 0xff;
 575                         dev->dev_addr[i+1]= addr & 0xff;
 576                 }
 577 #if STREAMER_DEBUG
 578                 printk("Adapter address: %pM\n", dev->dev_addr);
 579 #endif
 580         }
 581         return 0;
 582 }
 583
 584 static int streamer_open(struct net_device *dev)
 585 {
 586         struct streamer_private *streamer_priv = netdev_priv(dev);
 587         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
 588         unsigned long flags;
 589         char open_error[255];
 590         int i, open_finished = 1;
 591         __u16 srb_word;
 592         __u16 srb_open;
 593         int rc;
 594
 595         if (readw(streamer_mmio+BMCTL_SUM) & BMCTL_RX_ENABLED) {
 596                 rc=streamer_reset(dev);
 597         }
 598
 599         if (request_irq(dev->irq, streamer_interrupt, IRQF_SHARED, "lanstreamer", dev)) {
 600                 return -EAGAIN;
 601         }
 602 #if STREAMER_DEBUG
 603         printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
 604         printk("pending ints: %x\n", readw(streamer_mmio + SISR));
 605 #endif
 606
 607         writew(SISR_MI | SISR_SRB_REPLY, streamer_mmio + SISR_MASK);    /* more ints later, doesn't stop arb cmd interrupt */
 608         writew(LISR_LIE, streamer_mmio + LISR); /* more ints later */
 609
 610         /* adapter is closed, so SRB is pointed to by LAPWWO */
 611         writew(readw(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
 612
 613 #if STREAMER_DEBUG
 614         printk("LAPWWO: %x, LAPA: %x\n", readw(streamer_mmio + LAPWWO),
 615                readw(streamer_mmio + LAPA));
 616         printk("LAPE: %x\n", readw(streamer_mmio + LAPE));
 617         printk("SISR Mask = %04x\n", readw(streamer_mmio + SISR_MASK));
 618 #endif
 619         do {
 620                 for (i = 0; i < SRB_COMMAND_SIZE; i += 2) {
 621                         writew(0, streamer_mmio + LAPDINC);
 622                 }
 623
 624                 writew(readw(streamer_mmio+LAPWWO),streamer_mmio+LAPA);
 625                 writew(htons(SRB_OPEN_ADAPTER<<8),streamer_mmio+LAPDINC) ;      /* open */
 626                 writew(htons(STREAMER_CLEAR_RET_CODE<<8),streamer_mmio+LAPDINC);
 627                 writew(STREAMER_CLEAR_RET_CODE, streamer_mmio + LAPDINC);
 628
 629                 writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA);
 630 #if STREAMER_NETWORK_MONITOR
 631                 /* If Network Monitor, instruct card to copy MAC frames through the ARB */
 632                 writew(htons(OPEN_ADAPTER_ENABLE_FDX | OPEN_ADAPTER_PASS_ADC_MAC | OPEN_ADAPTER_PASS_ATT_MAC | OPEN_ADAPTER_PASS_BEACON), streamer_mmio + LAPDINC);     /* offset 8 word contains open options */
 633 #else
 634                 writew(htons(OPEN_ADAPTER_ENABLE_FDX), streamer_mmio + LAPDINC);        /* Offset 8 word contains Open.Options */
 635 #endif
 636
 637                 if (streamer_priv->streamer_laa[0]) {
 638                         writew(readw(streamer_mmio + LAPWWO) + 12, streamer_mmio + LAPA);
 639                         writew(htons((streamer_priv->streamer_laa[0] << 8) |
 640                                      streamer_priv->streamer_laa[1]),streamer_mmio+LAPDINC);
 641                         writew(htons((streamer_priv->streamer_laa[2] << 8) |
 642                                      streamer_priv->streamer_laa[3]),streamer_mmio+LAPDINC);
 643                         writew(htons((streamer_priv->streamer_laa[4] << 8) |
 644                                      streamer_priv->streamer_laa[5]),streamer_mmio+LAPDINC);
 645                         memcpy(dev->dev_addr, streamer_priv->streamer_laa, dev->addr_len);
 646                 }
 647
 648                 /* save off srb open offset */
 649                 srb_open = readw(streamer_mmio + LAPWWO);
 650 #if STREAMER_DEBUG
 651                 writew(readw(streamer_mmio + LAPWWO),
 652                        streamer_mmio + LAPA);
 653                 printk("srb open request: \n");
 654                 for (i = 0; i < 16; i++) {
 655                         printk("%x:", ntohs(readw(streamer_mmio + LAPDINC)));
 656                 }
 657                 printk("\n");
 658 #endif
 659                 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
 660                 streamer_priv->srb_queued = 1;
 661
 662                 /* signal solo that SRB command has been issued */
 663                 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
 664                 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
 665
 666                 while (streamer_priv->srb_queued) {
 667                         interruptible_sleep_on_timeout(&streamer_priv->srb_wait, 5 * HZ);
 668                         if (signal_pending(current)) {
 669                                 printk(KERN_WARNING "%s: SRB timed out.\n", dev->name);
 670                                 printk(KERN_WARNING "SISR=%x MISR=%x, LISR=%x\n",
 671                                        readw(streamer_mmio + SISR),
 672                                        readw(streamer_mmio + MISR_RUM),
 673                                        readw(streamer_mmio + LISR));
 674                                 streamer_priv->srb_queued = 0;
 675                                 break;
 676                         }
 677                 }
 678
 679 #if STREAMER_DEBUG
 680                 printk("SISR_MASK: %x\n", readw(streamer_mmio + SISR_MASK));
 681                 printk("srb open response:\n");
 682                 writew(srb_open, streamer_mmio + LAPA);
 683                 for (i = 0; i < 10; i++) {
 684                         printk("%x:",
 685                                ntohs(readw(streamer_mmio + LAPDINC)));
 686                 }
 687 #endif
 688
 689                 /* If we get the same return response as we set, the interrupt wasn't raised and the open
 690                  * timed out.
 691                  */
 692                 writew(srb_open + 2, streamer_mmio + LAPA);
 693                 srb_word = ntohs(readw(streamer_mmio + LAPD)) >> 8;
 694                 if (srb_word == STREAMER_CLEAR_RET_CODE) {
 695                         printk(KERN_WARNING "%s: Adapter Open time out or error.\n",
 696                                dev->name);
 697                         return -EIO;
 698                 }
 699
 700                 if (srb_word != 0) {
 701                         if (srb_word == 0x07) {
 702                                 if (!streamer_priv->streamer_ring_speed && open_finished) {     /* Autosense , first time around */
 703                                         printk(KERN_WARNING "%s: Retrying at different ring speed \n",
 704                                                dev->name);
 705                                         open_finished = 0;
 706                                 } else {
 707                                         __u16 error_code;
 708
 709                                         writew(srb_open + 6, streamer_mmio + LAPA);
 710                                         error_code = ntohs(readw(streamer_mmio + LAPD));
 711                                         strcpy(open_error, open_maj_error[(error_code & 0xf0) >> 4]);
 712                                         strcat(open_error, " - ");
 713                                         strcat(open_error, open_min_error[(error_code & 0x0f)]);
 714
 715                                         if (!streamer_priv->streamer_ring_speed &&
 716                                             ((error_code & 0x0f) == 0x0d))
 717                                         {
 718                                                 printk(KERN_WARNING "%s: Tried to autosense ring speed with no monitors present\n", dev->name);
 719                                                 printk(KERN_WARNING "%s: Please try again with a specified ring speed \n", dev->name);
 720                                                 free_irq(dev->irq, dev);
 721                                                 return -EIO;
 722                                         }
 723
 724                                         printk(KERN_WARNING "%s: %s\n",
 725                                                dev->name, open_error);
 726                                         free_irq(dev->irq, dev);
 727                                         return -EIO;
 728
 729                                 }       /* if autosense && open_finished */
 730                         } else {
 731                                 printk(KERN_WARNING "%s: Bad OPEN response: %x\n",
 732                                        dev->name, srb_word);
 733                                 free_irq(dev->irq, dev);
 734                                 return -EIO;
 735                         }
 736                 } else
 737                         open_finished = 1;
 738         } while (!(open_finished));     /* Will only loop if ring speed mismatch re-open attempted && autosense is on */
 739
 740         writew(srb_open + 18, streamer_mmio + LAPA);
 741         srb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
 742         if (srb_word & (1 << 3))
 743                 if (streamer_priv->streamer_message_level)
 744                         printk(KERN_INFO "%s: Opened in FDX Mode\n", dev->name);
 745
 746         if (srb_word & 1)
 747                 streamer_priv->streamer_ring_speed = 16;
 748         else
 749                 streamer_priv->streamer_ring_speed = 4;
 750
 751         if (streamer_priv->streamer_message_level)
 752                 printk(KERN_INFO "%s: Opened in %d Mbps mode\n",
 753                         dev->name,
 754                         streamer_priv->streamer_ring_speed);
 755
 756         writew(srb_open + 8, streamer_mmio + LAPA);
 757         streamer_priv->asb = ntohs(readw(streamer_mmio + LAPDINC));
 758         streamer_priv->srb = ntohs(readw(streamer_mmio + LAPDINC));
 759         streamer_priv->arb = ntohs(readw(streamer_mmio + LAPDINC));
 760         readw(streamer_mmio + LAPDINC); /* offset 14 word is rsvd */
 761         streamer_priv->trb = ntohs(readw(streamer_mmio + LAPDINC));
 762
 763         streamer_priv->streamer_receive_options = 0x00;
 764         streamer_priv->streamer_copy_all_options = 0;
 765
 766         /* setup rx ring */
 767         /* enable rx channel */
 768         writew(~BMCTL_RX_DIS, streamer_mmio + BMCTL_RUM);
 769
 770         /* setup rx descriptors */
 771         streamer_priv->streamer_rx_ring=
 772             kmalloc( sizeof(struct streamer_rx_desc)*
 773                      STREAMER_RX_RING_SIZE,GFP_KERNEL);
 774         if (!streamer_priv->streamer_rx_ring) {
 775             printk(KERN_WARNING "%s ALLOC of streamer rx ring FAILED!!\n",dev->name);
 776             return -EIO;
 777         }
 778
 779         for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
 780                 struct sk_buff *skb;
 781
 782                 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
 783                 if (skb == NULL)
 784                         break;
 785
 786                 skb->dev = dev;
 787
 788                 streamer_priv->streamer_rx_ring[i].forward =
 789                         cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[i + 1],
 790                                         sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE));
 791                 streamer_priv->streamer_rx_ring[i].status = 0;
 792                 streamer_priv->streamer_rx_ring[i].buffer =
 793                         cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data,
 794                                               streamer_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
 795                 streamer_priv->streamer_rx_ring[i].framelen_buflen = streamer_priv->pkt_buf_sz;
 796                 streamer_priv->rx_ring_skb[i] = skb;
 797         }
 798         streamer_priv->streamer_rx_ring[STREAMER_RX_RING_SIZE - 1].forward =
 799                                 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[0],
 800                                                 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE));
 801
 802         if (i == 0) {
 803                 printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n", dev->name);
 804                 free_irq(dev->irq, dev);
 805                 return -EIO;
 806         }
 807
 808         streamer_priv->rx_ring_last_received = STREAMER_RX_RING_SIZE - 1;       /* last processed rx status */
 809
 810         writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[0],
 811                                 sizeof(struct streamer_rx_desc), PCI_DMA_TODEVICE)),
 812                 streamer_mmio + RXBDA);
 813         writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[STREAMER_RX_RING_SIZE - 1],
 814                                 sizeof(struct streamer_rx_desc), PCI_DMA_TODEVICE)),
 815                 streamer_mmio + RXLBDA);
 816
 817         /* set bus master interrupt event mask */
 818         writew(MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK);
 819
 820
 821         /* setup tx ring */
 822         streamer_priv->streamer_tx_ring=kmalloc(sizeof(struct streamer_tx_desc)*
 823                                                 STREAMER_TX_RING_SIZE,GFP_KERNEL);
 824         if (!streamer_priv->streamer_tx_ring) {
 825             printk(KERN_WARNING "%s ALLOC of streamer_tx_ring FAILED\n",dev->name);
 826             return -EIO;
 827         }
 828
 829         writew(~BMCTL_TX2_DIS, streamer_mmio + BMCTL_RUM);      /* Enables TX channel 2 */
 830         for (i = 0; i < STREAMER_TX_RING_SIZE; i++) {
 831                 streamer_priv->streamer_tx_ring[i].forward = cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
 832                                                                                 &streamer_priv->streamer_tx_ring[i + 1],
 833                                                                                 sizeof(struct streamer_tx_desc),
 834                                                                                 PCI_DMA_TODEVICE));
 835                 streamer_priv->streamer_tx_ring[i].status = 0;
 836                 streamer_priv->streamer_tx_ring[i].bufcnt_framelen = 0;
 837                 streamer_priv->streamer_tx_ring[i].buffer = 0;
 838                 streamer_priv->streamer_tx_ring[i].buflen = 0;
 839                 streamer_priv->streamer_tx_ring[i].rsvd1 = 0;
 840                 streamer_priv->streamer_tx_ring[i].rsvd2 = 0;
 841                 streamer_priv->streamer_tx_ring[i].rsvd3 = 0;
 842         }
 843         streamer_priv->streamer_tx_ring[STREAMER_TX_RING_SIZE - 1].forward =
 844                                         cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_tx_ring[0],
 845                                                         sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE));
 846
 847         streamer_priv->free_tx_ring_entries = STREAMER_TX_RING_SIZE;
 848         streamer_priv->tx_ring_free = 0;        /* next entry in tx ring to use */
 849         streamer_priv->tx_ring_last_status = STREAMER_TX_RING_SIZE - 1;
 850
 851         /* set Busmaster interrupt event mask (handle receives on interrupt only */
 852         writew(MISR_TX2_EOF | MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK);
 853         /* set system event interrupt mask */
 854         writew(SISR_ADAPTER_CHECK | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_ASB_FREE, streamer_mmio + SISR_MASK_SUM);
 855
 856 #if STREAMER_DEBUG
 857         printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
 858         printk("SISR MASK: %x\n", readw(streamer_mmio + SISR_MASK));
 859 #endif
 860
 861 #if STREAMER_NETWORK_MONITOR
 862
 863         writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
 864         printk("%s: Node Address: %04x:%04x:%04x\n", dev->name,
 865                 ntohs(readw(streamer_mmio + LAPDINC)),
 866                 ntohs(readw(streamer_mmio + LAPDINC)),
 867                 ntohs(readw(streamer_mmio + LAPDINC)));
 868         readw(streamer_mmio + LAPDINC);
 869         readw(streamer_mmio + LAPDINC);
 870         printk("%s: Functional Address: %04x:%04x\n", dev->name,
 871                 ntohs(readw(streamer_mmio + LAPDINC)),
 872                 ntohs(readw(streamer_mmio + LAPDINC)));
 873
 874         writew(streamer_priv->streamer_parms_addr + 4,
 875                 streamer_mmio + LAPA);
 876         printk("%s: NAUN Address: %04x:%04x:%04x\n", dev->name,
 877                 ntohs(readw(streamer_mmio + LAPDINC)),
 878                 ntohs(readw(streamer_mmio + LAPDINC)),
 879                 ntohs(readw(streamer_mmio + LAPDINC)));
 880 #endif
 881
 882         netif_start_queue(dev);
 883         netif_carrier_on(dev);
 884         return 0;
 885 }
 886
 887 /*
 888  *      When we enter the rx routine we do not know how many frames have been
 889  *      queued on the rx channel.  Therefore we start at the next rx status
 890  *      position and travel around the receive ring until we have completed
 891  *      all the frames.
 892  *
 893  *      This means that we may process the frame before we receive the end
 894  *      of frame interrupt. This is why we always test the status instead
 895  *      of blindly processing the next frame.
 896  *
 897  */
 898 static void streamer_rx(struct net_device *dev)
 899 {
 900         struct streamer_private *streamer_priv =
 901             netdev_priv(dev);
 902         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
 903         struct streamer_rx_desc *rx_desc;
 904         int rx_ring_last_received, length, frame_length, buffer_cnt = 0;
 905         struct sk_buff *skb, *skb2;
 906
 907         /* setup the next rx descriptor to be received */
 908         rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)];
 909         rx_ring_last_received = streamer_priv->rx_ring_last_received;
 910
 911         while (rx_desc->status & 0x01000000) {  /* While processed descriptors are available */
 912                 if (rx_ring_last_received != streamer_priv->rx_ring_last_received)
 913                 {
 914                         printk(KERN_WARNING "RX Error 1 rx_ring_last_received not the same %x %x\n",
 915                                 rx_ring_last_received, streamer_priv->rx_ring_last_received);
 916                 }
 917                 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
 918                 rx_ring_last_received = streamer_priv->rx_ring_last_received;
 919
 920                 length = rx_desc->framelen_buflen & 0xffff;     /* buffer length */
 921                 frame_length = (rx_desc->framelen_buflen >> 16) & 0xffff;
 922
 923                 if (rx_desc->status & 0x7E830000) {     /* errors */
 924                         if (streamer_priv->streamer_message_level) {
 925                                 printk(KERN_WARNING "%s: Rx Error %x \n",
 926                                        dev->name, rx_desc->status);
 927                         }
 928                 } else {        /* received without errors */
 929                         if (rx_desc->status & 0x80000000) {     /* frame complete */
 930                                 buffer_cnt = 1;
 931                                 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
 932                         } else {
 933                                 skb = dev_alloc_skb(frame_length);
 934                         }
 935
 936                         if (skb == NULL)
 937                         {
 938                                 printk(KERN_WARNING "%s: Not enough memory to copy packet to upper layers. \n", dev->name);
 939                                 dev->stats.rx_dropped++;
 940                         } else {        /* we allocated an skb OK */
 941                                 if (buffer_cnt == 1) {
 942                                         /* release the DMA mapping */
 943                                         pci_unmap_single(streamer_priv->pci_dev,
 944                                                 le32_to_cpu(streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer),
 945                                                 streamer_priv->pkt_buf_sz,
 946                                                 PCI_DMA_FROMDEVICE);
 947                                         skb2 = streamer_priv->rx_ring_skb[rx_ring_last_received];
 948 #if STREAMER_DEBUG_PACKETS
 949                                         {
 950                                                 int i;
 951                                                 printk("streamer_rx packet print: skb->data2 %p  skb->head %p\n", skb2->data, skb2->head);
 952                                                 for (i = 0; i < frame_length; i++)
 953                                                 {
 954                                                         printk("%x:", skb2->data[i]);
 955                                                         if (((i + 1) % 16) == 0)
 956                                                                 printk("\n");
 957                                                 }
 958                                                 printk("\n");
 959                                         }
 960 #endif
 961                                         skb_put(skb2, length);
 962                                         skb2->protocol = tr_type_trans(skb2, dev);
 963                                         /* recycle this descriptor */
 964                                         streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0;
 965                                         streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz;
 966                                         streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer =
 967                                                 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, streamer_priv->pkt_buf_sz,
 968                                                                 PCI_DMA_FROMDEVICE));
 969                                         streamer_priv->rx_ring_skb[rx_ring_last_received] = skb;
 970                                         /* place recycled descriptor back on the adapter */
 971                                         writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
 972                                                                         &streamer_priv->streamer_rx_ring[rx_ring_last_received],
 973                                                                         sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE)),
 974                                                 streamer_mmio + RXLBDA);
 975                                         /* pass the received skb up to the protocol */
 976                                         netif_rx(skb2);
 977                                 } else {
 978                                         do {    /* Walk the buffers */
 979                                                 pci_unmap_single(streamer_priv->pci_dev, le32_to_cpu(rx_desc->buffer), length, PCI_DMA_FROMDEVICE),
 980                                                 memcpy(skb_put(skb, length), (void *)rx_desc->buffer, length);  /* copy this fragment */
 981                                                 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0;
 982                                                 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz;
 983
 984                                                 /* give descriptor back to the adapter */
 985                                                 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
 986                                                                         &streamer_priv->streamer_rx_ring[rx_ring_last_received],
 987                                                                         length, PCI_DMA_FROMDEVICE)),
 988                                                         streamer_mmio + RXLBDA);
 989
 990                                                 if (rx_desc->status & 0x80000000)
 991                                                         break;  /* this descriptor completes the frame */
 992
 993                                                 /* else get the next pending descriptor */
 994                                                 if (rx_ring_last_received!= streamer_priv->rx_ring_last_received)
 995                                                 {
 996                                                         printk("RX Error rx_ring_last_received not the same %x %x\n",
 997                                                                 rx_ring_last_received,
 998                                                                 streamer_priv->rx_ring_last_received);
 999                                                 }
1000                                                 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE-1)];
1001
1002                                                 length = rx_desc->framelen_buflen & 0xffff;     /* buffer length */
1003                                                 streamer_priv->rx_ring_last_received =  (streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE - 1);
1004                                                 rx_ring_last_received = streamer_priv->rx_ring_last_received;
1005                                         } while (1);
1006
1007                                         skb->protocol = tr_type_trans(skb, dev);
1008                                         /* send up to the protocol */
1009                                         netif_rx(skb);
1010                                 }
1011                                 dev->stats.rx_packets++;
1012                                 dev->stats.rx_bytes += length;
1013                         }       /* if skb == null */
1014                 }               /* end received without errors */
1015
1016                 /* try the next one */
1017                 rx_desc = &streamer_priv->streamer_rx_ring[(rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)];
1018         }                       /* end for all completed rx descriptors */
1019 }
1020
1021 static irqreturn_t streamer_interrupt(int irq, void *dev_id)
1022 {
1023         struct net_device *dev = (struct net_device *) dev_id;
1024         struct streamer_private *streamer_priv =
1025             netdev_priv(dev);
1026         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1027         __u16 sisr;
1028         __u16 misr;
1029         u8 max_intr = MAX_INTR;
1030
1031         spin_lock(&streamer_priv->streamer_lock);
1032         sisr = readw(streamer_mmio + SISR);
1033
1034         while((sisr & (SISR_MI | SISR_SRB_REPLY | SISR_ADAPTER_CHECK | SISR_ASB_FREE |
1035                        SISR_ARB_CMD | SISR_TRB_REPLY | SISR_PAR_ERR | SISR_SERR_ERR)) &&
1036               (max_intr > 0)) {
1037
1038                 if(sisr & SISR_PAR_ERR) {
1039                         writew(~SISR_PAR_ERR, streamer_mmio + SISR_RUM);
1040                         (void)readw(streamer_mmio + SISR_RUM);
1041                 }
1042
1043                 else if(sisr & SISR_SERR_ERR) {
1044                         writew(~SISR_SERR_ERR, streamer_mmio + SISR_RUM);
1045                         (void)readw(streamer_mmio + SISR_RUM);
1046                 }
1047
1048                 else if(sisr & SISR_MI) {
1049                         misr = readw(streamer_mmio + MISR_RUM);
1050
1051                 if (misr & MISR_TX2_EOF) {
1052                                 while(streamer_priv->streamer_tx_ring[(streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1)].status) {
1053                                 streamer_priv->tx_ring_last_status = (streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1);
1054                                 streamer_priv->free_tx_ring_entries++;
1055                                 dev->stats.tx_bytes += streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]->len;
1056                                 dev->stats.tx_packets++;
1057                                 dev_kfree_skb_irq(streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]);
1058                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buffer = 0xdeadbeef;
1059                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].status = 0;
1060                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].bufcnt_framelen = 0;
1061                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buflen = 0;
1062                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd1 = 0;
1063                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd2 = 0;
1064                                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd3 = 0;
1065                         }
1066                         netif_wake_queue(dev);
1067                 }
1068
1069                 if (misr & MISR_RX_EOF) {
1070                         streamer_rx(dev);
1071                 }
1072                 /* MISR_RX_EOF */
1073
1074                         if (misr & MISR_RX_NOBUF) {
1075                                 /* According to the documentation, we don't have to do anything,
1076                                  * but trapping it keeps it out of /var/log/messages.
1077                                  */
1078                         }               /* SISR_RX_NOBUF */
1079
1080                         writew(~misr, streamer_mmio + MISR_RUM);
1081                         (void)readw(streamer_mmio + MISR_RUM);
1082                 }
1083
1084                 else if (sisr & SISR_SRB_REPLY) {
1085                         if (streamer_priv->srb_queued == 1) {
1086                                 wake_up_interruptible(&streamer_priv->srb_wait);
1087                         } else if (streamer_priv->srb_queued == 2) {
1088                                 streamer_srb_bh(dev);
1089                         }
1090                         streamer_priv->srb_queued = 0;
1091
1092                         writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
1093                         (void)readw(streamer_mmio + SISR_RUM);
1094                 }
1095
1096                 else if (sisr & SISR_ADAPTER_CHECK) {
1097                         printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name);
1098                         writel(readl(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
1099                         printk(KERN_WARNING "%s: Words %x:%x:%x:%x:\n",
1100                                dev->name, readw(streamer_mmio + LAPDINC),
1101                                ntohs(readw(streamer_mmio + LAPDINC)),
1102                                ntohs(readw(streamer_mmio + LAPDINC)),
1103                                ntohs(readw(streamer_mmio + LAPDINC)));
1104                         netif_stop_queue(dev);
1105                         netif_carrier_off(dev);
1106                         printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1107                 }
1108
1109                 /* SISR_ADAPTER_CHECK */
1110                 else if (sisr & SISR_ASB_FREE) {
1111                         /* Wake up anything that is waiting for the asb response */
1112                         if (streamer_priv->asb_queued) {
1113                                 streamer_asb_bh(dev);
1114                         }
1115                         writew(~SISR_ASB_FREE, streamer_mmio + SISR_RUM);
1116                         (void)readw(streamer_mmio + SISR_RUM);
1117                 }
1118                 /* SISR_ASB_FREE */
1119                 else if (sisr & SISR_ARB_CMD) {
1120                         streamer_arb_cmd(dev);
1121                         writew(~SISR_ARB_CMD, streamer_mmio + SISR_RUM);
1122                         (void)readw(streamer_mmio + SISR_RUM);
1123                 }
1124                 /* SISR_ARB_CMD */
1125                 else if (sisr & SISR_TRB_REPLY) {
1126                         /* Wake up anything that is waiting for the trb response */
1127                         if (streamer_priv->trb_queued) {
1128                                 wake_up_interruptible(&streamer_priv->
1129                                                       trb_wait);
1130                         }
1131                         streamer_priv->trb_queued = 0;
1132                         writew(~SISR_TRB_REPLY, streamer_mmio + SISR_RUM);
1133                         (void)readw(streamer_mmio + SISR_RUM);
1134                 }
1135                 /* SISR_TRB_REPLY */
1136
1137                 sisr = readw(streamer_mmio + SISR);
1138                 max_intr--;
1139         } /* while() */
1140
1141         spin_unlock(&streamer_priv->streamer_lock) ;
1142         return IRQ_HANDLED;
1143 }
1144
1145 static netdev_tx_t streamer_xmit(struct sk_buff *skb,
1146                                        struct net_device *dev)
1147 {
1148         struct streamer_private *streamer_priv =
1149             netdev_priv(dev);
1150         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1151         unsigned long flags ;
1152
1153         spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1154
1155         if (streamer_priv->free_tx_ring_entries) {
1156                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].status = 0;
1157                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].bufcnt_framelen = 0x00020000 | skb->len;
1158                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buffer =
1159                         cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE));
1160                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd1 = skb->len;
1161                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd2 = 0;
1162                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd3 = 0;
1163                 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buflen = skb->len;
1164
1165                 streamer_priv->tx_ring_skb[streamer_priv->tx_ring_free] = skb;
1166                 streamer_priv->free_tx_ring_entries--;
1167 #if STREAMER_DEBUG_PACKETS
1168                 {
1169                         int i;
1170                         printk("streamer_xmit packet print:\n");
1171                         for (i = 0; i < skb->len; i++) {
1172                                 printk("%x:", skb->data[i]);
1173                                 if (((i + 1) % 16) == 0)
1174                                         printk("\n");
1175                         }
1176                         printk("\n");
1177                 }
1178 #endif
1179
1180                 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
1181                                         &streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free],
1182                                         sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE)),
1183                         streamer_mmio + TX2LFDA);
1184                 (void)readl(streamer_mmio + TX2LFDA);
1185
1186                 streamer_priv->tx_ring_free = (streamer_priv->tx_ring_free + 1) & (STREAMER_TX_RING_SIZE - 1);
1187                 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1188                 return NETDEV_TX_OK;
1189         } else {
1190                 netif_stop_queue(dev);
1191                 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1192                 return NETDEV_TX_BUSY;
1193         }
1194 }
1195
1196
1197 static int streamer_close(struct net_device *dev)
1198 {
1199         struct streamer_private *streamer_priv =
1200             netdev_priv(dev);
1201         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1202         unsigned long flags;
1203         int i;
1204
1205         netif_stop_queue(dev);
1206         netif_carrier_off(dev);
1207         writew(streamer_priv->srb, streamer_mmio + LAPA);
1208         writew(htons(SRB_CLOSE_ADAPTER << 8),streamer_mmio+LAPDINC);
1209         writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1210
1211         spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1212
1213         streamer_priv->srb_queued = 1;
1214         writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1215
1216         spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
1217
1218         while (streamer_priv->srb_queued)
1219         {
1220                 interruptible_sleep_on_timeout(&streamer_priv->srb_wait,
1221                                                jiffies + 60 * HZ);
1222                 if (signal_pending(current))
1223                 {
1224                         printk(KERN_WARNING "%s: SRB timed out.\n", dev->name);
1225                         printk(KERN_WARNING "SISR=%x MISR=%x LISR=%x\n",
1226                                readw(streamer_mmio + SISR),
1227                                readw(streamer_mmio + MISR_RUM),
1228                                readw(streamer_mmio + LISR));
1229                         streamer_priv->srb_queued = 0;
1230                         break;
1231                 }
1232         }
1233
1234         streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1235
1236         for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
1237                 if (streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]) {
1238                         dev_kfree_skb(streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]);
1239                 }
1240                 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1241         }
1242
1243         /* reset tx/rx fifo's and busmaster logic */
1244
1245         /* TBD. Add graceful way to reset the LLC channel without doing a soft reset.
1246            writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1247            udelay(1);
1248            writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL);
1249          */
1250
1251 #if STREAMER_DEBUG
1252         writew(streamer_priv->srb, streamer_mmio + LAPA);
1253         printk("srb): ");
1254         for (i = 0; i < 2; i++) {
1255                 printk("%x ", ntohs(readw(streamer_mmio + LAPDINC)));
1256         }
1257         printk("\n");
1258 #endif
1259         free_irq(dev->irq, dev);
1260         return 0;
1261 }
1262
1263 static void streamer_set_rx_mode(struct net_device *dev)
1264 {
1265         struct streamer_private *streamer_priv =
1266             netdev_priv(dev);
1267         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1268         __u8 options = 0;
1269         struct dev_mc_list *dmi;
1270         unsigned char dev_mc_address[5];
1271
1272         writel(streamer_priv->srb, streamer_mmio + LAPA);
1273         options = streamer_priv->streamer_copy_all_options;
1274
1275         if (dev->flags & IFF_PROMISC)
1276                 options |= (3 << 5);    /* All LLC and MAC frames, all through the main rx channel */
1277         else
1278                 options &= ~(3 << 5);
1279
1280         /* Only issue the srb if there is a change in options */
1281
1282         if ((options ^ streamer_priv->streamer_copy_all_options))
1283         {
1284                 /* Now to issue the srb command to alter the copy.all.options */
1285                 writew(htons(SRB_MODIFY_RECEIVE_OPTIONS << 8), streamer_mmio+LAPDINC);
1286                 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1287                 writew(htons((streamer_priv->streamer_receive_options << 8) | options),streamer_mmio+LAPDINC);
1288                 writew(htons(0x4a41),streamer_mmio+LAPDINC);
1289                 writew(htons(0x4d45),streamer_mmio+LAPDINC);
1290                 writew(htons(0x5320),streamer_mmio+LAPDINC);
1291                 writew(0x2020, streamer_mmio + LAPDINC);
1292
1293                 streamer_priv->srb_queued = 2;  /* Can't sleep, use srb_bh */
1294
1295                 writel(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1296
1297                 streamer_priv->streamer_copy_all_options = options;
1298                 return;
1299         }
1300
1301         /* Set the functional addresses we need for multicast */
1302         writel(streamer_priv->srb,streamer_mmio+LAPA);
1303         dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ;
1304
1305         netdev_for_each_mc_addr(dmi, dev) {
1306                 dev_mc_address[0] |= dmi->dmi_addr[2] ;
1307                 dev_mc_address[1] |= dmi->dmi_addr[3] ;
1308                 dev_mc_address[2] |= dmi->dmi_addr[4] ;
1309                 dev_mc_address[3] |= dmi->dmi_addr[5] ;
1310         }
1311
1312         writew(htons(SRB_SET_FUNC_ADDRESS << 8),streamer_mmio+LAPDINC);
1313         writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1314         writew(0,streamer_mmio+LAPDINC);
1315         writew(htons( (dev_mc_address[0] << 8) | dev_mc_address[1]),streamer_mmio+LAPDINC);
1316         writew(htons( (dev_mc_address[2] << 8) | dev_mc_address[3]),streamer_mmio+LAPDINC);
1317         streamer_priv->srb_queued = 2 ;
1318         writel(LISR_SRB_CMD,streamer_mmio+LISR_SUM);
1319 }
1320
1321 static void streamer_srb_bh(struct net_device *dev)
1322 {
1323         struct streamer_private *streamer_priv = netdev_priv(dev);
1324         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1325         __u16 srb_word;
1326
1327         writew(streamer_priv->srb, streamer_mmio + LAPA);
1328         srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1329
1330         switch (srb_word) {
1331
1332                 /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous)
1333                  * At some point we should do something if we get an error, such as
1334                  * resetting the IFF_PROMISC flag in dev
1335                  */
1336
1337         case SRB_MODIFY_RECEIVE_OPTIONS:
1338                 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1339
1340                 switch (srb_word) {
1341                 case 0x01:
1342                         printk(KERN_WARNING "%s: Unrecognized srb command\n", dev->name);
1343                         break;
1344                 case 0x04:
1345                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1346                         break;
1347                 default:
1348                         if (streamer_priv->streamer_message_level)
1349                                 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",
1350                                        dev->name,
1351                                        streamer_priv->streamer_copy_all_options,
1352                                        streamer_priv->streamer_receive_options);
1353                         break;
1354                 }               /* switch srb[2] */
1355                 break;
1356
1357
1358                 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1359                  */
1360         case SRB_SET_GROUP_ADDRESS:
1361                 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1362                 switch (srb_word) {
1363                 case 0x00:
1364                         break;
1365                 case 0x01:
1366                         printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name);
1367                         break;
1368                 case 0x04:
1369                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1370                         break;
1371                 case 0x3c:
1372                         printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n", dev->name);
1373                         break;
1374                 case 0x3e:      /* If we ever implement individual multicast addresses, will need to deal with this */
1375                         printk(KERN_WARNING "%s: Group address registers full\n", dev->name);
1376                         break;
1377                 case 0x55:
1378                         printk(KERN_INFO "%s: Group Address already set.\n", dev->name);
1379                         break;
1380                 default:
1381                         break;
1382                 }               /* switch srb[2] */
1383                 break;
1384
1385
1386                 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1387                  */
1388         case SRB_RESET_GROUP_ADDRESS:
1389                 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1390                 switch (srb_word) {
1391                 case 0x00:
1392                         break;
1393                 case 0x01:
1394                         printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1395                         break;
1396                 case 0x04:
1397                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1398                         break;
1399                 case 0x39:      /* Must deal with this if individual multicast addresses used */
1400                         printk(KERN_INFO "%s: Group address not found \n", dev->name);
1401                         break;
1402                 default:
1403                         break;
1404                 }               /* switch srb[2] */
1405                 break;
1406
1407
1408                 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1409                  */
1410
1411         case SRB_SET_FUNC_ADDRESS:
1412                 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1413                 switch (srb_word) {
1414                 case 0x00:
1415                         if (streamer_priv->streamer_message_level)
1416                                 printk(KERN_INFO "%s: Functional Address Mask Set \n", dev->name);
1417                         break;
1418                 case 0x01:
1419                         printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1420                         break;
1421                 case 0x04:
1422                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1423                         break;
1424                 default:
1425                         break;
1426                 }               /* switch srb[2] */
1427                 break;
1428
1429                 /* SRB_READ_LOG - Read and reset the adapter error counters
1430                  */
1431
1432         case SRB_READ_LOG:
1433                 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1434                 switch (srb_word) {
1435                 case 0x00:
1436                         {
1437                                 int i;
1438                                 if (streamer_priv->streamer_message_level)
1439                                         printk(KERN_INFO "%s: Read Log command complete\n", dev->name);
1440                                 printk("Read Log statistics: ");
1441                                 writew(streamer_priv->srb + 6,
1442                                        streamer_mmio + LAPA);
1443                                 for (i = 0; i < 5; i++) {
1444                                         printk("%x:", ntohs(readw(streamer_mmio + LAPDINC)));
1445                                 }
1446                                 printk("\n");
1447                         }
1448                         break;
1449                 case 0x01:
1450                         printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1451                         break;
1452                 case 0x04:
1453                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1454                         break;
1455
1456                 }               /* switch srb[2] */
1457                 break;
1458
1459                 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1460
1461         case SRB_READ_SR_COUNTERS:
1462                 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1463                 switch (srb_word) {
1464                 case 0x00:
1465                         if (streamer_priv->streamer_message_level)
1466                                 printk(KERN_INFO "%s: Read Source Routing Counters issued\n", dev->name);
1467                         break;
1468                 case 0x01:
1469                         printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1470                         break;
1471                 case 0x04:
1472                         printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1473                         break;
1474                 default:
1475                         break;
1476                 }               /* switch srb[2] */
1477                 break;
1478
1479         default:
1480                 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n", dev->name);
1481                 break;
1482         }                       /* switch srb[0] */
1483 }
1484
1485 static int streamer_set_mac_address(struct net_device *dev, void *addr)
1486 {
1487         struct sockaddr *saddr = addr;
1488         struct streamer_private *streamer_priv = netdev_priv(dev);
1489
1490         if (netif_running(dev))
1491         {
1492                 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name);
1493                 return -EIO;
1494         }
1495
1496         memcpy(streamer_priv->streamer_laa, saddr->sa_data, dev->addr_len);
1497
1498         if (streamer_priv->streamer_message_level) {
1499                 printk(KERN_INFO "%s: MAC/LAA Set to  = %x.%x.%x.%x.%x.%x\n",
1500                        dev->name, streamer_priv->streamer_laa[0],
1501                        streamer_priv->streamer_laa[1],
1502                        streamer_priv->streamer_laa[2],
1503                        streamer_priv->streamer_laa[3],
1504                        streamer_priv->streamer_laa[4],
1505                        streamer_priv->streamer_laa[5]);
1506         }
1507         return 0;
1508 }
1509
1510 static void streamer_arb_cmd(struct net_device *dev)
1511 {
1512         struct streamer_private *streamer_priv =
1513             netdev_priv(dev);
1514         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1515         __u8 header_len;
1516         __u16 frame_len, buffer_len;
1517         struct sk_buff *mac_frame;
1518         __u8 frame_data[256];
1519         __u16 buff_off;
1520         __u16 lan_status = 0, lan_status_diff;  /* Initialize to stop compiler warning */
1521         __u8 fdx_prot_error;
1522         __u16 next_ptr;
1523         __u16 arb_word;
1524
1525 #if STREAMER_NETWORK_MONITOR
1526         struct trh_hdr *mac_hdr;
1527 #endif
1528
1529         writew(streamer_priv->arb, streamer_mmio + LAPA);
1530         arb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1531
1532         if (arb_word == ARB_RECEIVE_DATA) {     /* Receive.data, MAC frames */
1533                 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1534                 streamer_priv->mac_rx_buffer = buff_off = ntohs(readw(streamer_mmio + LAPDINC));
1535                 header_len=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; /* 802.5 Token-Ring Header Length */
1536                 frame_len = ntohs(readw(streamer_mmio + LAPDINC));
1537
1538 #if STREAMER_DEBUG
1539                 {
1540                         int i;
1541                         __u16 next;
1542                         __u8 status;
1543                         __u16 len;
1544
1545                         writew(ntohs(buff_off), streamer_mmio + LAPA);  /*setup window to frame data */
1546                         next = htons(readw(streamer_mmio + LAPDINC));
1547                         status =
1548                             ntohs(readw(streamer_mmio + LAPDINC)) & 0xff;
1549                         len = ntohs(readw(streamer_mmio + LAPDINC));
1550
1551                         /* print out 1st 14 bytes of frame data */
1552                         for (i = 0; i < 7; i++) {
1553                                 printk("Loc %d = %04x\n", i,
1554                                        ntohs(readw
1555                                              (streamer_mmio + LAPDINC)));
1556                         }
1557
1558                         printk("next %04x, fs %02x, len %04x \n", next,
1559                                status, len);
1560                 }
1561 #endif
1562                 if (!(mac_frame = dev_alloc_skb(frame_len))) {
1563                         printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n",
1564                                dev->name);
1565                         goto drop_frame;
1566                 }
1567                 /* Walk the buffer chain, creating the frame */
1568
1569                 do {
1570                         int i;
1571                         __u16 rx_word;
1572
1573                         writew(htons(buff_off), streamer_mmio + LAPA);  /* setup window to frame data */
1574                         next_ptr = ntohs(readw(streamer_mmio + LAPDINC));
1575                         readw(streamer_mmio + LAPDINC); /* read thru status word */
1576                         buffer_len = ntohs(readw(streamer_mmio + LAPDINC));
1577
1578                         if (buffer_len > 256)
1579                                 break;
1580
1581                         i = 0;
1582                         while (i < buffer_len) {
1583                                 rx_word=ntohs(readw(streamer_mmio+LAPDINC));
1584                                 frame_data[i]=rx_word >> 8;
1585                                 frame_data[i+1]=rx_word & 0xff;
1586                                 i += 2;
1587                         }
1588
1589                         memcpy(skb_put(mac_frame, buffer_len),
1590                                       frame_data, buffer_len);
1591                 } while (next_ptr && (buff_off = next_ptr));
1592
1593                 mac_frame->protocol = tr_type_trans(mac_frame, dev);
1594 #if STREAMER_NETWORK_MONITOR
1595                 printk(KERN_WARNING "%s: Received MAC Frame, details: \n",
1596                        dev->name);
1597                 mac_hdr = tr_hdr(mac_frame);
1598                 printk(KERN_WARNING
1599                        "%s: MAC Frame Dest. Addr: %pM\n",
1600                        dev->name, mac_hdr->daddr);
1601                 printk(KERN_WARNING
1602                        "%s: MAC Frame Srce. Addr: %pM\n",
1603                        dev->name, mac_hdr->saddr);
1604 #endif
1605                 netif_rx(mac_frame);
1606
1607                 /* Now tell the card we have dealt with the received frame */
1608 drop_frame:
1609                 /* Set LISR Bit 1 */
1610                 writel(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1611
1612                 /* Is the ASB free ? */
1613
1614                 if (!(readl(streamer_priv->streamer_mmio + SISR) & SISR_ASB_FREE))
1615                 {
1616                         streamer_priv->asb_queued = 1;
1617                         writel(LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1618                         return;
1619                         /* Drop out and wait for the bottom half to be run */
1620                 }
1621
1622
1623                 writew(streamer_priv->asb, streamer_mmio + LAPA);
1624                 writew(htons(ASB_RECEIVE_DATA << 8), streamer_mmio+LAPDINC);
1625                 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1626                 writew(0, streamer_mmio + LAPDINC);
1627                 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1628
1629                 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1630
1631                 streamer_priv->asb_queued = 2;
1632                 return;
1633
1634         } else if (arb_word == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
1635                 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1636                 lan_status = ntohs(readw(streamer_mmio + LAPDINC));
1637                 fdx_prot_error = ntohs(readw(streamer_mmio+LAPD)) >> 8;
1638
1639                 /* Issue ARB Free */
1640                 writew(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1641
1642                 lan_status_diff = (streamer_priv->streamer_lan_status ^ lan_status) &
1643                     lan_status;
1644
1645                 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR))
1646                 {
1647                         if (lan_status_diff & LSC_LWF)
1648                                 printk(KERN_WARNING "%s: Short circuit detected on the lobe\n", dev->name);
1649                         if (lan_status_diff & LSC_ARW)
1650                                 printk(KERN_WARNING "%s: Auto removal error\n", dev->name);
1651                         if (lan_status_diff & LSC_FPE)
1652                                 printk(KERN_WARNING "%s: FDX Protocol Error\n", dev->name);
1653                         if (lan_status_diff & LSC_RR)
1654                                 printk(KERN_WARNING "%s: Force remove MAC frame received\n", dev->name);
1655
1656                         /* Adapter has been closed by the hardware */
1657
1658                         /* reset tx/rx fifo's and busmaster logic */
1659
1660                         /* @TBD. no llc reset on autostreamer writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1661                            udelay(1);
1662                            writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); */
1663
1664                         netif_stop_queue(dev);
1665                         netif_carrier_off(dev);
1666                         printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1667                 }
1668                 /* If serious error */
1669                 if (streamer_priv->streamer_message_level) {
1670                         if (lan_status_diff & LSC_SIG_LOSS)
1671                                 printk(KERN_WARNING "%s: No receive signal detected \n", dev->name);
1672                         if (lan_status_diff & LSC_HARD_ERR)
1673                                 printk(KERN_INFO "%s: Beaconing \n", dev->name);
1674                         if (lan_status_diff & LSC_SOFT_ERR)
1675                                 printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n", dev->name);
1676                         if (lan_status_diff & LSC_TRAN_BCN)
1677                                 printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n", dev->name);
1678                         if (lan_status_diff & LSC_SS)
1679                                 printk(KERN_INFO "%s: Single Station on the ring \n", dev->name);
1680                         if (lan_status_diff & LSC_RING_REC)
1681                                 printk(KERN_INFO "%s: Ring recovery ongoing\n", dev->name);
1682                         if (lan_status_diff & LSC_FDX_MODE)
1683                                 printk(KERN_INFO "%s: Operating in FDX mode\n", dev->name);
1684                 }
1685
1686                 if (lan_status_diff & LSC_CO) {
1687                         if (streamer_priv->streamer_message_level)
1688                                 printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1689
1690                         /* Issue READ.LOG command */
1691
1692                         writew(streamer_priv->srb, streamer_mmio + LAPA);
1693                         writew(htons(SRB_READ_LOG << 8),streamer_mmio+LAPDINC);
1694                         writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1695                         writew(0, streamer_mmio + LAPDINC);
1696                         streamer_priv->srb_queued = 2;  /* Can't sleep, use srb_bh */
1697
1698                         writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1699                 }
1700
1701                 if (lan_status_diff & LSC_SR_CO) {
1702                         if (streamer_priv->streamer_message_level)
1703                                 printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
1704
1705                         /* Issue a READ.SR.COUNTERS */
1706                         writew(streamer_priv->srb, streamer_mmio + LAPA);
1707                         writew(htons(SRB_READ_SR_COUNTERS << 8),
1708                                streamer_mmio+LAPDINC);
1709                         writew(htons(STREAMER_CLEAR_RET_CODE << 8),
1710                                streamer_mmio+LAPDINC);
1711                         streamer_priv->srb_queued = 2;  /* Can't sleep, use srb_bh */
1712                         writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1713
1714                 }
1715                 streamer_priv->streamer_lan_status = lan_status;
1716         } /* Lan.change.status */
1717         else
1718                 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1719 }
1720
1721 static void streamer_asb_bh(struct net_device *dev)
1722 {
1723         struct streamer_private *streamer_priv =
1724             netdev_priv(dev);
1725         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1726
1727         if (streamer_priv->asb_queued == 1)
1728         {
1729                 /* Dropped through the first time */
1730
1731                 writew(streamer_priv->asb, streamer_mmio + LAPA);
1732                 writew(htons(ASB_RECEIVE_DATA << 8),streamer_mmio+LAPDINC);
1733                 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1734                 writew(0, streamer_mmio + LAPDINC);
1735                 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1736
1737                 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1738                 streamer_priv->asb_queued = 2;
1739
1740                 return;
1741         }
1742
1743         if (streamer_priv->asb_queued == 2) {
1744                 __u8 rc;
1745                 writew(streamer_priv->asb + 2, streamer_mmio + LAPA);
1746                 rc=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1747                 switch (rc) {
1748                 case 0x01:
1749                         printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1750                         break;
1751                 case 0x26:
1752                         printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1753                         break;
1754                 case 0xFF:
1755                         /* Valid response, everything should be ok again */
1756                         break;
1757                 default:
1758                         printk(KERN_WARNING "%s: Invalid return code in asb\n", dev->name);
1759                         break;
1760                 }
1761         }
1762         streamer_priv->asb_queued = 0;
1763 }
1764
1765 static int streamer_change_mtu(struct net_device *dev, int mtu)
1766 {
1767         struct streamer_private *streamer_priv =
1768             netdev_priv(dev);
1769         __u16 max_mtu;
1770
1771         if (streamer_priv->streamer_ring_speed == 4)
1772                 max_mtu = 4500;
1773         else
1774                 max_mtu = 18000;
1775
1776         if (mtu > max_mtu)
1777                 return -EINVAL;
1778         if (mtu < 100)
1779                 return -EINVAL;
1780
1781         dev->mtu = mtu;
1782         streamer_priv->pkt_buf_sz = mtu + TR_HLEN;
1783
1784         return 0;
1785 }
1786
1787 #if STREAMER_NETWORK_MONITOR
1788 #ifdef CONFIG_PROC_FS
1789 static int streamer_proc_info(char *buffer, char **start, off_t offset,
1790                               int length, int *eof, void *data)
1791 {
1792   struct streamer_private *sdev=NULL;
1793         struct pci_dev *pci_device = NULL;
1794         int len = 0;
1795         off_t begin = 0;
1796         off_t pos = 0;
1797         int size;
1798
1799   struct net_device *dev;
1800
1801         size = sprintf(buffer, "IBM LanStreamer/MPC Chipset Token Ring Adapters\n");
1802
1803         pos += size;
1804         len += size;
1805
1806   for(sdev=dev_streamer; sdev; sdev=sdev->next) {
1807     pci_device=sdev->pci_dev;
1808     dev=pci_get_drvdata(pci_device);
1809
1810                                 size = sprintf_info(buffer + len, dev);
1811                                 len += size;
1812                                 pos = begin + len;
1813
1814                                 if (pos < offset) {
1815                                         len = 0;
1816                                         begin = pos;
1817                                 }
1818                                 if (pos > offset + length)
1819                                         break;
1820                 }               /* for */
1821
1822         *start = buffer + (offset - begin);     /* Start of wanted data */
1823         len -= (offset - begin);        /* Start slop */
1824         if (len > length)
1825                 len = length;   /* Ending slop */
1826         return len;
1827 }
1828
1829 static int sprintf_info(char *buffer, struct net_device *dev)
1830 {
1831         struct streamer_private *streamer_priv =
1832             netdev_priv(dev);
1833         __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1834         struct streamer_adapter_addr_table sat;
1835         struct streamer_parameters_table spt;
1836         int size = 0;
1837         int i;
1838
1839         writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
1840         for (i = 0; i < 14; i += 2) {
1841                 __u16 io_word;
1842                 __u8 *datap = (__u8 *) & sat;
1843                 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1844                 datap[size]=io_word >> 8;
1845                 datap[size+1]=io_word & 0xff;
1846         }
1847         writew(streamer_priv->streamer_parms_addr, streamer_mmio + LAPA);
1848         for (i = 0; i < 68; i += 2) {
1849                 __u16 io_word;
1850                 __u8 *datap = (__u8 *) & spt;
1851                 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1852                 datap[size]=io_word >> 8;
1853                 datap[size+1]=io_word & 0xff;
1854         }
1855
1856         size = sprintf(buffer, "\n%6s: Adapter Address   : Node Address      : Functional Addr\n", dev->name);
1857
1858         size += sprintf(buffer + size,
1859                         "%6s: %pM : %pM : %02x:%02x:%02x:%02x\n",
1860                         dev->name, dev->dev_addr, sat.node_addr,
1861                         sat.func_addr[0], sat.func_addr[1],
1862                         sat.func_addr[2], sat.func_addr[3]);
1863
1864         size += sprintf(buffer + size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1865
1866         size += sprintf(buffer + size, "%6s: Physical Addr : Up Node Address   : Poll Address      : AccPri : Auth Src : Att Code :\n", dev->name);
1867
1868         size += sprintf(buffer + size,
1869                     "%6s: %02x:%02x:%02x:%02x   : %pM : %pM : %04x   : %04x     :  %04x    :\n",
1870                     dev->name, spt.phys_addr[0], spt.phys_addr[1],
1871                     spt.phys_addr[2], spt.phys_addr[3],
1872                     spt.up_node_addr, spt.poll_addr,
1873                     ntohs(spt.acc_priority), ntohs(spt.auth_source_class),
1874                     ntohs(spt.att_code));
1875
1876         size += sprintf(buffer + size, "%6s: Source Address    : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n", dev->name);
1877
1878         size += sprintf(buffer + size,
1879                     "%6s: %pM : %04x  : %04x   : %04x   : %04x   : %04x    :     %04x     : \n",
1880                     dev->name, spt.source_addr,
1881                     ntohs(spt.beacon_type), ntohs(spt.major_vector),
1882                     ntohs(spt.lan_status), ntohs(spt.local_ring),
1883                     ntohs(spt.mon_error), ntohs(spt.frame_correl));
1884
1885         size += sprintf(buffer + size, "%6s: Beacon Details :  Tx  :  Rx  : NAUN Node Address : NAUN Node Phys : \n",
1886                     dev->name);
1887
1888         size += sprintf(buffer + size,
1889                     "%6s:                :  %02x  :  %02x  : %pM : %02x:%02x:%02x:%02x    : \n",
1890                     dev->name, ntohs(spt.beacon_transmit),
1891                     ntohs(spt.beacon_receive),
1892                     spt.beacon_naun,
1893                     spt.beacon_phys[0], spt.beacon_phys[1],
1894                     spt.beacon_phys[2], spt.beacon_phys[3]);
1895         return size;
1896 }
1897 #endif
1898 #endif
1899
1900 static struct pci_driver streamer_pci_driver = {
1901   .name     = "lanstreamer",
1902   .id_table = streamer_pci_tbl,
1903   .probe    = streamer_init_one,
1904   .remove   = __devexit_p(streamer_remove_one),
1905 };
1906
1907 static int __init streamer_init_module(void) {
1908   return pci_register_driver(&streamer_pci_driver);
1909 }
1910
1911 static void __exit streamer_cleanup_module(void) {
1912   pci_unregister_driver(&streamer_pci_driver);
1913 }
1914
1915 module_init(streamer_init_module);
1916 module_exit(streamer_cleanup_module);
1917 MODULE_LICENSE("GPL");