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