drivers/net/tokenring/lanstreamer.c

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