drivers/net/tokenring/lanstreamer.c

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