drivers/net/tokenring/lanstreamer.c

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