drivers/net/tokenring/lanstreamer.c

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