2 * lanstreamer.c -- driver for the IBM Auto LANStreamer PCI Adapter
4 * Written By: Mike Sullivan, IBM Corporation
6 * Copyright (C) 1999 IBM Corporation
8 * Linux driver for IBM PCI tokenring cards based on the LanStreamer MPC
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)
16 * Base Driver Skeleton:
17 * Written 1993-94 by Donald Becker.
19 * Copyright 1993 United States Government as represented by the
20 * Director, National Security Agency.
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.
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.
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.
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
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
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>
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).
81 /* Change STREAMER_DEBUG to 1 to get verbose, and I mean really verbose, messages */
83 #define STREAMER_DEBUG 0
84 #define STREAMER_DEBUG_PACKETS 0
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
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
93 #define STREAMER_NETWORK_MONITOR 0
95 /* #define CONFIG_PROC_FS */
98 * Allow or disallow ioctl's for debugging
101 #define STREAMER_IOCTL 0
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>
125 #include <net/net_namespace.h>
126 #include <net/checksum.h>
129 #include <asm/system.h>
131 #include "lanstreamer.h"
133 #if (BITS_PER_LONG == 64)
134 #error broken on 64-bit: stores pointer to rx_ring->buffer in 32-bit int
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
143 * Official releases will only have an a.b.c version number format.
146 static char version[] = "LanStreamer.c v0.4.0 03/08/01 - Mike Sullivan\n"
147 " v0.5.3 11/13/02 - Kent Yoder";
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 */
153 MODULE_DEVICE_TABLE(pci,streamer_pci_tbl);
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",
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"
172 /* Module paramters */
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.
180 * WARNING: Some hubs will allow you to insert
184 static int ringspeed[STREAMER_MAX_ADAPTERS] = { 0, };
186 module_param_array(ringspeed, int, NULL, 0);
188 /* Packet buffer size */
190 static int pkt_buf_sz[STREAMER_MAX_ADAPTERS] = { 0, };
192 module_param_array(pkt_buf_sz, int, NULL, 0);
196 static int message_level[STREAMER_MAX_ADAPTERS] = { 1, };
198 module_param_array(message_level, int, NULL, 0);
201 static int streamer_ioctl(struct net_device *, struct ifreq *, int);
204 static int streamer_reset(struct net_device *dev);
205 static int streamer_open(struct net_device *dev);
206 static int streamer_xmit(struct sk_buff *skb, struct net_device *dev);
207 static int streamer_close(struct net_device *dev);
208 static void streamer_set_rx_mode(struct net_device *dev);
209 static irqreturn_t streamer_interrupt(int irq, void *dev_id);
210 static int streamer_set_mac_address(struct net_device *dev, void *addr);
211 static void streamer_arb_cmd(struct net_device *dev);
212 static int streamer_change_mtu(struct net_device *dev, int mtu);
213 static void streamer_srb_bh(struct net_device *dev);
214 static void streamer_asb_bh(struct net_device *dev);
215 #if STREAMER_NETWORK_MONITOR
216 #ifdef CONFIG_PROC_FS
217 static int streamer_proc_info(char *buffer, char **start, off_t offset,
218 int length, int *eof, void *data);
219 static int sprintf_info(char *buffer, struct net_device *dev);
220 struct streamer_private *dev_streamer=NULL;
224 static const struct net_device_ops streamer_netdev_ops = {
225 .ndo_open = streamer_open,
226 .ndo_stop = streamer_close,
227 .ndo_start_xmit = streamer_xmit,
228 .ndo_change_mtu = streamer_change_mtu,
230 .ndo_do_ioctl = streamer_ioctl,
232 .ndo_set_multicast_list = streamer_set_rx_mode,
233 .ndo_set_mac_address = streamer_set_mac_address,
236 static int __devinit streamer_init_one(struct pci_dev *pdev,
237 const struct pci_device_id *ent)
239 struct net_device *dev;
240 struct streamer_private *streamer_priv;
241 unsigned long pio_start, pio_end, pio_flags, pio_len;
242 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
244 static int card_no=-1;
248 printk("lanstreamer::streamer_init_one, entry pdev %p\n",pdev);
252 dev = alloc_trdev(sizeof(*streamer_priv));
254 printk(KERN_ERR "lanstreamer: out of memory.\n");
258 streamer_priv = netdev_priv(dev);
260 #if STREAMER_NETWORK_MONITOR
261 #ifdef CONFIG_PROC_FS
263 create_proc_read_entry("streamer_tr", 0, init_net.proc_net,
264 streamer_proc_info, NULL);
265 streamer_priv->next = dev_streamer;
266 dev_streamer = streamer_priv;
270 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
272 printk(KERN_ERR "%s: No suitable PCI mapping available.\n",
278 rc = pci_enable_device(pdev);
280 printk(KERN_ERR "lanstreamer: unable to enable pci device\n");
285 pci_set_master(pdev);
287 rc = pci_set_mwi(pdev);
289 printk(KERN_ERR "lanstreamer: unable to enable MWI on pci device\n");
290 goto err_out_disable;
293 pio_start = pci_resource_start(pdev, 0);
294 pio_end = pci_resource_end(pdev, 0);
295 pio_flags = pci_resource_flags(pdev, 0);
296 pio_len = pci_resource_len(pdev, 0);
298 mmio_start = pci_resource_start(pdev, 1);
299 mmio_end = pci_resource_end(pdev, 1);
300 mmio_flags = pci_resource_flags(pdev, 1);
301 mmio_len = pci_resource_len(pdev, 1);
304 printk("lanstreamer: pio_start %x pio_end %x pio_len %x pio_flags %x\n",
305 pio_start, pio_end, pio_len, pio_flags);
306 printk("lanstreamer: mmio_start %x mmio_end %x mmio_len %x mmio_flags %x\n",
307 mmio_start, mmio_end, mmio_flags, mmio_len);
310 if (!request_region(pio_start, pio_len, "lanstreamer")) {
311 printk(KERN_ERR "lanstreamer: unable to get pci io addr %lx\n",
317 if (!request_mem_region(mmio_start, mmio_len, "lanstreamer")) {
318 printk(KERN_ERR "lanstreamer: unable to get pci mmio addr %lx\n",
321 goto err_out_free_pio;
324 streamer_priv->streamer_mmio=ioremap(mmio_start, mmio_len);
325 if (streamer_priv->streamer_mmio == NULL) {
326 printk(KERN_ERR "lanstreamer: unable to remap MMIO %lx\n",
329 goto err_out_free_mmio;
332 init_waitqueue_head(&streamer_priv->srb_wait);
333 init_waitqueue_head(&streamer_priv->trb_wait);
335 dev->netdev_ops = &streamer_netdev_ops;
336 dev->irq = pdev->irq;
337 dev->base_addr=pio_start;
338 SET_NETDEV_DEV(dev, &pdev->dev);
340 streamer_priv->streamer_card_name = (char *)pdev->resource[0].name;
341 streamer_priv->pci_dev = pdev;
343 if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000))
344 streamer_priv->pkt_buf_sz = PKT_BUF_SZ;
346 streamer_priv->pkt_buf_sz = pkt_buf_sz[card_no];
348 streamer_priv->streamer_ring_speed = ringspeed[card_no];
349 streamer_priv->streamer_message_level = message_level[card_no];
351 pci_set_drvdata(pdev, dev);
353 spin_lock_init(&streamer_priv->streamer_lock);
355 pci_read_config_word (pdev, PCI_COMMAND, &pcr);
356 pcr |= PCI_COMMAND_SERR;
357 pci_write_config_word (pdev, PCI_COMMAND, pcr);
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,
366 if (streamer_reset(dev))
369 rc = register_netdev(dev);
375 iounmap(streamer_priv->streamer_mmio);
377 release_mem_region(mmio_start, mmio_len);
379 release_region(pio_start, pio_len);
383 pci_disable_device(pdev);
387 printk("lanstreamer: Exit error %x\n",rc);
392 static void __devexit streamer_remove_one(struct pci_dev *pdev)
394 struct net_device *dev=pci_get_drvdata(pdev);
395 struct streamer_private *streamer_priv;
398 printk("lanstreamer::streamer_remove_one entry pdev %p\n",pdev);
402 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev is NULL\n");
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");
412 #if STREAMER_NETWORK_MONITOR
413 #ifdef CONFIG_PROC_FS
415 struct streamer_private **p, **next;
417 for (p = &dev_streamer; *p; p = next) {
419 if (*p == streamer_priv) {
425 remove_proc_entry("streamer_tr", init_net.proc_net);
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));
435 pci_disable_device(pdev);
437 pci_set_drvdata(pdev, NULL);
441 static int streamer_reset(struct net_device *dev)
443 struct streamer_private *streamer_priv;
444 __u8 __iomem *streamer_mmio;
446 unsigned int uaa_addr;
447 struct sk_buff *skb = NULL;
450 streamer_priv = netdev_priv(dev);
451 streamer_mmio = streamer_priv->streamer_mmio;
453 writew(readw(streamer_mmio + BCTL) | BCTL_SOFTRESET, streamer_mmio + BCTL);
455 /* Hold soft reset bit for a while */
458 writew(readw(streamer_mmio + BCTL) & ~BCTL_SOFTRESET,
459 streamer_mmio + BCTL);
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));
466 writew(readw(streamer_mmio + BCTL) | (BCTL_RX_FIFO_8 | BCTL_TX_FIFO_8), streamer_mmio + BCTL );
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",
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",
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",
483 writew(0, streamer_mmio + GPR);
486 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
488 printk(KERN_INFO "%s: skb allocation for diagnostics failed...proceeding\n",
491 struct streamer_rx_desc *rx_ring;
494 rx_ring=(struct streamer_rx_desc *)skb->data;
495 data=((u8 *)skb->data)+sizeof(struct streamer_rx_desc);
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);
506 printk("GPR = %x\n", readw(streamer_mmio + GPR));
508 /* start solo init */
509 writew(SISR_MI, streamer_mmio + SISR_MASK_SUM);
511 while (!((readw(streamer_mmio + SISR)) & SISR_SRB_REPLY)) {
512 msleep_interruptible(100);
513 if (time_after(jiffies, t + 40 * HZ)) {
515 "IBM PCI tokenring card not responding\n");
516 release_region(dev->base_addr, STREAMER_IO_SPACE);
522 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
523 misr = readw(streamer_mmio + MISR_RUM);
524 writew(~misr, streamer_mmio + MISR_RUM);
527 dev_kfree_skb(skb); /* release skb used for diagnostics */
530 printk("LAPWWO: %x, LAPA: %x LAPE: %x\n",
531 readw(streamer_mmio + LAPWWO), readw(streamer_mmio + LAPA),
532 readw(streamer_mmio + LAPE));
538 writew(readw(streamer_mmio + LAPWWO),
539 streamer_mmio + LAPA);
540 printk("initialization response srb dump: ");
541 for (i = 0; i < 10; i++)
543 ntohs(readw(streamer_mmio + LAPDINC)));
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);
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));
563 printk("UAA resides at %x\n", uaa_addr);
566 /* setup uaa area for access with LAPD */
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;
577 printk("Adapter address: %pM\n", dev->dev_addr);
583 static int streamer_open(struct net_device *dev)
585 struct streamer_private *streamer_priv = netdev_priv(dev);
586 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
588 char open_error[255];
589 int i, open_finished = 1;
594 if (readw(streamer_mmio+BMCTL_SUM) & BMCTL_RX_ENABLED) {
595 rc=streamer_reset(dev);
598 if (request_irq(dev->irq, &streamer_interrupt, IRQF_SHARED, "lanstreamer", dev)) {
602 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
603 printk("pending ints: %x\n", readw(streamer_mmio + SISR));
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 */
609 /* adapter is closed, so SRB is pointed to by LAPWWO */
610 writew(readw(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
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));
621 for (i = 0; i < SRB_COMMAND_SIZE; i += 2) {
622 writew(0, streamer_mmio + LAPDINC);
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);
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 */
635 writew(htons(OPEN_ADAPTER_ENABLE_FDX), streamer_mmio + LAPDINC); /* Offset 8 word contains Open.Options */
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);
649 /* save off srb open offset */
650 srb_open = readw(streamer_mmio + LAPWWO);
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)));
660 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
661 streamer_priv->srb_queued = 1;
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);
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;
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++) {
686 ntohs(readw(streamer_mmio + LAPDINC)));
690 /* If we get the same return response as we set, the interrupt wasn't raised and the open
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",
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",
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)]);
716 if (!streamer_priv->streamer_ring_speed
717 && ((error_code & 0x0f) == 0x0d))
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);
725 printk(KERN_WARNING "%s: %s\n",
726 dev->name, open_error);
727 free_irq(dev->irq, dev);
730 } /* if autosense && open_finished */
732 printk(KERN_WARNING "%s: Bad OPEN response: %x\n",
733 dev->name, srb_word);
734 free_irq(dev->irq, dev);
739 } while (!(open_finished)); /* Will only loop if ring speed mismatch re-open attempted && autosense is on */
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);
748 streamer_priv->streamer_ring_speed = 16;
750 streamer_priv->streamer_ring_speed = 4;
752 if (streamer_priv->streamer_message_level)
753 printk(KERN_INFO "%s: Opened in %d Mbps mode\n",
755 streamer_priv->streamer_ring_speed);
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));
764 streamer_priv->streamer_receive_options = 0x00;
765 streamer_priv->streamer_copy_all_options = 0;
768 /* enable rx channel */
769 writew(~BMCTL_RX_DIS, streamer_mmio + BMCTL_RUM);
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);
780 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
783 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
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;
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));
804 printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n", dev->name);
805 free_irq(dev->irq, dev);
809 streamer_priv->rx_ring_last_received = STREAMER_RX_RING_SIZE - 1; /* last processed rx status */
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);
818 /* set bus master interrupt event mask */
819 writew(MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK);
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);
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),
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;
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));
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;
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);
858 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
859 printk("SISR MASK: %x\n", readw(streamer_mmio + SISR_MASK));
862 #if STREAMER_NETWORK_MONITOR
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)));
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)));
883 netif_start_queue(dev);
884 netif_carrier_on(dev);
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
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.
899 static void streamer_rx(struct net_device *dev)
901 struct streamer_private *streamer_priv =
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;
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;
912 while (rx_desc->status & 0x01000000) { /* While processed descriptors are available */
913 if (rx_ring_last_received != streamer_priv->rx_ring_last_received)
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);
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;
921 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */
922 frame_length = (rx_desc->framelen_buflen >> 16) & 0xffff;
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);
929 } else { /* received without errors */
930 if (rx_desc->status & 0x80000000) { /* frame complete */
932 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
934 skb = dev_alloc_skb(frame_length);
939 printk(KERN_WARNING "%s: Not enough memory to copy packet to upper layers. \n", dev->name);
940 dev->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,
948 skb2 = streamer_priv->rx_ring_skb[rx_ring_last_received];
949 #if STREAMER_DEBUG_PACKETS
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++)
955 printk("%x:", skb2->data[i]);
956 if (((i + 1) % 16) == 0)
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 */
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;
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);
991 if (rx_desc->status & 0x80000000)
992 break; /* this descriptor completes the frame */
994 /* else get the next pending descriptor */
995 if (rx_ring_last_received!= streamer_priv->rx_ring_last_received)
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);
1001 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE-1)];
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;
1008 skb->protocol = tr_type_trans(skb, dev);
1009 /* send up to the protocol */
1012 dev->stats.rx_packets++;
1013 dev->stats.rx_bytes += length;
1014 } /* if skb == null */
1015 } /* end received without errors */
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 */
1022 static irqreturn_t streamer_interrupt(int irq, void *dev_id)
1024 struct net_device *dev = (struct net_device *) dev_id;
1025 struct streamer_private *streamer_priv =
1027 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1030 u8 max_intr = MAX_INTR;
1032 spin_lock(&streamer_priv->streamer_lock);
1033 sisr = readw(streamer_mmio + SISR);
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)) {
1039 if(sisr & SISR_PAR_ERR) {
1040 writew(~SISR_PAR_ERR, streamer_mmio + SISR_RUM);
1041 (void)readw(streamer_mmio + SISR_RUM);
1044 else if(sisr & SISR_SERR_ERR) {
1045 writew(~SISR_SERR_ERR, streamer_mmio + SISR_RUM);
1046 (void)readw(streamer_mmio + SISR_RUM);
1049 else if(sisr & SISR_MI) {
1050 misr = readw(streamer_mmio + MISR_RUM);
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 dev->stats.tx_bytes += streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]->len;
1057 dev->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;
1067 netif_wake_queue(dev);
1070 if (misr & MISR_RX_EOF) {
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.
1079 } /* SISR_RX_NOBUF */
1081 writew(~misr, streamer_mmio + MISR_RUM);
1082 (void)readw(streamer_mmio + MISR_RUM);
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);
1091 streamer_priv->srb_queued = 0;
1093 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
1094 (void)readw(streamer_mmio + SISR_RUM);
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);
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);
1116 writew(~SISR_ASB_FREE, streamer_mmio + SISR_RUM);
1117 (void)readw(streamer_mmio + SISR_RUM);
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);
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->
1132 streamer_priv->trb_queued = 0;
1133 writew(~SISR_TRB_REPLY, streamer_mmio + SISR_RUM);
1134 (void)readw(streamer_mmio + SISR_RUM);
1136 /* SISR_TRB_REPLY */
1138 sisr = readw(streamer_mmio + SISR);
1142 spin_unlock(&streamer_priv->streamer_lock) ;
1146 static int streamer_xmit(struct sk_buff *skb, struct net_device *dev)
1148 struct streamer_private *streamer_priv =
1150 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1151 unsigned long flags ;
1153 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
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;
1165 streamer_priv->tx_ring_skb[streamer_priv->tx_ring_free] = skb;
1166 streamer_priv->free_tx_ring_entries--;
1167 #if STREAMER_DEBUG_PACKETS
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)
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);
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);
1190 netif_stop_queue(dev);
1191 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1197 static int streamer_close(struct net_device *dev)
1199 struct streamer_private *streamer_priv =
1201 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1202 unsigned long flags;
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);
1211 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1213 streamer_priv->srb_queued = 1;
1214 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1216 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
1218 while (streamer_priv->srb_queued)
1220 interruptible_sleep_on_timeout(&streamer_priv->srb_wait,
1222 if (signal_pending(current))
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;
1234 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
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]);
1240 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1243 /* reset tx/rx fifo's and busmaster logic */
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);
1248 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL);
1252 writew(streamer_priv->srb, streamer_mmio + LAPA);
1254 for (i = 0; i < 2; i++) {
1255 printk("%x ", ntohs(readw(streamer_mmio + LAPDINC)));
1259 free_irq(dev->irq, dev);
1263 static void streamer_set_rx_mode(struct net_device *dev)
1265 struct streamer_private *streamer_priv =
1267 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1269 struct dev_mc_list *dmi;
1270 unsigned char dev_mc_address[5];
1273 writel(streamer_priv->srb, streamer_mmio + LAPA);
1274 options = streamer_priv->streamer_copy_all_options;
1276 if (dev->flags & IFF_PROMISC)
1277 options |= (3 << 5); /* All LLC and MAC frames, all through the main rx channel */
1279 options &= ~(3 << 5);
1281 /* Only issue the srb if there is a change in options */
1283 if ((options ^ streamer_priv->streamer_copy_all_options))
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);
1294 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1296 writel(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1298 streamer_priv->streamer_copy_all_options = options;
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 ;
1306 for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next)
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] ;
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);
1323 static void streamer_srb_bh(struct net_device *dev)
1325 struct streamer_private *streamer_priv = netdev_priv(dev);
1326 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1329 writew(streamer_priv->srb, streamer_mmio + LAPA);
1330 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
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
1339 case SRB_MODIFY_RECEIVE_OPTIONS:
1340 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1344 printk(KERN_WARNING "%s: Unrecognized srb command\n", dev->name);
1347 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1350 if (streamer_priv->streamer_message_level)
1351 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",
1353 streamer_priv->streamer_copy_all_options,
1354 streamer_priv->streamer_receive_options);
1356 } /* switch srb[2] */
1360 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1362 case SRB_SET_GROUP_ADDRESS:
1363 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1368 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name);
1371 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1374 printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n", dev->name);
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);
1380 printk(KERN_INFO "%s: Group Address already set.\n", dev->name);
1384 } /* switch srb[2] */
1388 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1390 case SRB_RESET_GROUP_ADDRESS:
1391 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1396 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1399 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1401 case 0x39: /* Must deal with this if individual multicast addresses used */
1402 printk(KERN_INFO "%s: Group address not found \n", dev->name);
1406 } /* switch srb[2] */
1410 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1413 case SRB_SET_FUNC_ADDRESS:
1414 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1417 if (streamer_priv->streamer_message_level)
1418 printk(KERN_INFO "%s: Functional Address Mask Set \n", dev->name);
1421 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1424 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1428 } /* switch srb[2] */
1431 /* SRB_READ_LOG - Read and reset the adapter error counters
1435 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
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)));
1452 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1455 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1458 } /* switch srb[2] */
1461 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1463 case SRB_READ_SR_COUNTERS:
1464 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1467 if (streamer_priv->streamer_message_level)
1468 printk(KERN_INFO "%s: Read Source Routing Counters issued\n", dev->name);
1471 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1474 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1478 } /* switch srb[2] */
1482 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n", dev->name);
1484 } /* switch srb[0] */
1487 static int streamer_set_mac_address(struct net_device *dev, void *addr)
1489 struct sockaddr *saddr = addr;
1490 struct streamer_private *streamer_priv = netdev_priv(dev);
1492 if (netif_running(dev))
1494 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name);
1498 memcpy(streamer_priv->streamer_laa, saddr->sa_data, dev->addr_len);
1500 if (streamer_priv->streamer_message_level) {
1501 printk(KERN_INFO "%s: MAC/LAA Set to = %x.%x.%x.%x.%x.%x\n",
1502 dev->name, streamer_priv->streamer_laa[0],
1503 streamer_priv->streamer_laa[1],
1504 streamer_priv->streamer_laa[2],
1505 streamer_priv->streamer_laa[3],
1506 streamer_priv->streamer_laa[4],
1507 streamer_priv->streamer_laa[5]);
1512 static void streamer_arb_cmd(struct net_device *dev)
1514 struct streamer_private *streamer_priv =
1516 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1518 __u16 frame_len, buffer_len;
1519 struct sk_buff *mac_frame;
1520 __u8 frame_data[256];
1522 __u16 lan_status = 0, lan_status_diff; /* Initialize to stop compiler warning */
1523 __u8 fdx_prot_error;
1527 #if STREAMER_NETWORK_MONITOR
1528 struct trh_hdr *mac_hdr;
1531 writew(streamer_priv->arb, streamer_mmio + LAPA);
1532 arb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1534 if (arb_word == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
1535 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1536 streamer_priv->mac_rx_buffer = buff_off = ntohs(readw(streamer_mmio + LAPDINC));
1537 header_len=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; /* 802.5 Token-Ring Header Length */
1538 frame_len = ntohs(readw(streamer_mmio + LAPDINC));
1547 writew(ntohs(buff_off), streamer_mmio + LAPA); /*setup window to frame data */
1548 next = htons(readw(streamer_mmio + LAPDINC));
1550 ntohs(readw(streamer_mmio + LAPDINC)) & 0xff;
1551 len = ntohs(readw(streamer_mmio + LAPDINC));
1553 /* print out 1st 14 bytes of frame data */
1554 for (i = 0; i < 7; i++) {
1555 printk("Loc %d = %04x\n", i,
1557 (streamer_mmio + LAPDINC)));
1560 printk("next %04x, fs %02x, len %04x \n", next,
1564 if (!(mac_frame = dev_alloc_skb(frame_len))) {
1565 printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n",
1569 /* Walk the buffer chain, creating the frame */
1575 writew(htons(buff_off), streamer_mmio + LAPA); /* setup window to frame data */
1576 next_ptr = ntohs(readw(streamer_mmio + LAPDINC));
1577 readw(streamer_mmio + LAPDINC); /* read thru status word */
1578 buffer_len = ntohs(readw(streamer_mmio + LAPDINC));
1580 if (buffer_len > 256)
1584 while (i < buffer_len) {
1585 rx_word=ntohs(readw(streamer_mmio+LAPDINC));
1586 frame_data[i]=rx_word >> 8;
1587 frame_data[i+1]=rx_word & 0xff;
1591 memcpy(skb_put(mac_frame, buffer_len),
1592 frame_data, buffer_len);
1593 } while (next_ptr && (buff_off = next_ptr));
1595 mac_frame->protocol = tr_type_trans(mac_frame, dev);
1596 #if STREAMER_NETWORK_MONITOR
1597 printk(KERN_WARNING "%s: Received MAC Frame, details: \n",
1599 mac_hdr = tr_hdr(mac_frame);
1601 "%s: MAC Frame Dest. Addr: %pM\n",
1602 dev->name, mac_hdr->daddr);
1604 "%s: MAC Frame Srce. Addr: %pM\n",
1605 dev->name, mac_hdr->saddr);
1607 netif_rx(mac_frame);
1609 /* Now tell the card we have dealt with the received frame */
1611 /* Set LISR Bit 1 */
1612 writel(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1614 /* Is the ASB free ? */
1616 if (!(readl(streamer_priv->streamer_mmio + SISR) & SISR_ASB_FREE))
1618 streamer_priv->asb_queued = 1;
1619 writel(LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1621 /* Drop out and wait for the bottom half to be run */
1625 writew(streamer_priv->asb, streamer_mmio + LAPA);
1626 writew(htons(ASB_RECEIVE_DATA << 8), streamer_mmio+LAPDINC);
1627 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1628 writew(0, streamer_mmio + LAPDINC);
1629 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1631 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1633 streamer_priv->asb_queued = 2;
1636 } else if (arb_word == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
1637 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1638 lan_status = ntohs(readw(streamer_mmio + LAPDINC));
1639 fdx_prot_error = ntohs(readw(streamer_mmio+LAPD)) >> 8;
1641 /* Issue ARB Free */
1642 writew(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1644 lan_status_diff = (streamer_priv->streamer_lan_status ^ lan_status) &
1647 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR))
1649 if (lan_status_diff & LSC_LWF)
1650 printk(KERN_WARNING "%s: Short circuit detected on the lobe\n", dev->name);
1651 if (lan_status_diff & LSC_ARW)
1652 printk(KERN_WARNING "%s: Auto removal error\n", dev->name);
1653 if (lan_status_diff & LSC_FPE)
1654 printk(KERN_WARNING "%s: FDX Protocol Error\n", dev->name);
1655 if (lan_status_diff & LSC_RR)
1656 printk(KERN_WARNING "%s: Force remove MAC frame received\n", dev->name);
1658 /* Adapter has been closed by the hardware */
1660 /* reset tx/rx fifo's and busmaster logic */
1662 /* @TBD. no llc reset on autostreamer writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1664 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); */
1666 netif_stop_queue(dev);
1667 netif_carrier_off(dev);
1668 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1670 /* If serious error */
1671 if (streamer_priv->streamer_message_level) {
1672 if (lan_status_diff & LSC_SIG_LOSS)
1673 printk(KERN_WARNING "%s: No receive signal detected \n", dev->name);
1674 if (lan_status_diff & LSC_HARD_ERR)
1675 printk(KERN_INFO "%s: Beaconing \n", dev->name);
1676 if (lan_status_diff & LSC_SOFT_ERR)
1677 printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n", dev->name);
1678 if (lan_status_diff & LSC_TRAN_BCN)
1679 printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n", dev->name);
1680 if (lan_status_diff & LSC_SS)
1681 printk(KERN_INFO "%s: Single Station on the ring \n", dev->name);
1682 if (lan_status_diff & LSC_RING_REC)
1683 printk(KERN_INFO "%s: Ring recovery ongoing\n", dev->name);
1684 if (lan_status_diff & LSC_FDX_MODE)
1685 printk(KERN_INFO "%s: Operating in FDX mode\n", dev->name);
1688 if (lan_status_diff & LSC_CO) {
1689 if (streamer_priv->streamer_message_level)
1690 printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1692 /* Issue READ.LOG command */
1694 writew(streamer_priv->srb, streamer_mmio + LAPA);
1695 writew(htons(SRB_READ_LOG << 8),streamer_mmio+LAPDINC);
1696 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1697 writew(0, streamer_mmio + LAPDINC);
1698 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1700 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1703 if (lan_status_diff & LSC_SR_CO) {
1704 if (streamer_priv->streamer_message_level)
1705 printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
1707 /* Issue a READ.SR.COUNTERS */
1708 writew(streamer_priv->srb, streamer_mmio + LAPA);
1709 writew(htons(SRB_READ_SR_COUNTERS << 8),
1710 streamer_mmio+LAPDINC);
1711 writew(htons(STREAMER_CLEAR_RET_CODE << 8),
1712 streamer_mmio+LAPDINC);
1713 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1714 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1717 streamer_priv->streamer_lan_status = lan_status;
1718 } /* Lan.change.status */
1720 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1723 static void streamer_asb_bh(struct net_device *dev)
1725 struct streamer_private *streamer_priv =
1727 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1729 if (streamer_priv->asb_queued == 1)
1731 /* Dropped through the first time */
1733 writew(streamer_priv->asb, streamer_mmio + LAPA);
1734 writew(htons(ASB_RECEIVE_DATA << 8),streamer_mmio+LAPDINC);
1735 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1736 writew(0, streamer_mmio + LAPDINC);
1737 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1739 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1740 streamer_priv->asb_queued = 2;
1745 if (streamer_priv->asb_queued == 2) {
1747 writew(streamer_priv->asb + 2, streamer_mmio + LAPA);
1748 rc=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1751 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1754 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1757 /* Valid response, everything should be ok again */
1760 printk(KERN_WARNING "%s: Invalid return code in asb\n", dev->name);
1764 streamer_priv->asb_queued = 0;
1767 static int streamer_change_mtu(struct net_device *dev, int mtu)
1769 struct streamer_private *streamer_priv =
1773 if (streamer_priv->streamer_ring_speed == 4)
1784 streamer_priv->pkt_buf_sz = mtu + TR_HLEN;
1789 #if STREAMER_NETWORK_MONITOR
1790 #ifdef CONFIG_PROC_FS
1791 static int streamer_proc_info(char *buffer, char **start, off_t offset,
1792 int length, int *eof, void *data)
1794 struct streamer_private *sdev=NULL;
1795 struct pci_dev *pci_device = NULL;
1801 struct net_device *dev;
1803 size = sprintf(buffer, "IBM LanStreamer/MPC Chipset Token Ring Adapters\n");
1808 for(sdev=dev_streamer; sdev; sdev=sdev->next) {
1809 pci_device=sdev->pci_dev;
1810 dev=pci_get_drvdata(pci_device);
1812 size = sprintf_info(buffer + len, dev);
1820 if (pos > offset + length)
1824 *start = buffer + (offset - begin); /* Start of wanted data */
1825 len -= (offset - begin); /* Start slop */
1827 len = length; /* Ending slop */
1831 static int sprintf_info(char *buffer, struct net_device *dev)
1833 struct streamer_private *streamer_priv =
1835 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1836 struct streamer_adapter_addr_table sat;
1837 struct streamer_parameters_table spt;
1841 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
1842 for (i = 0; i < 14; i += 2) {
1844 __u8 *datap = (__u8 *) & sat;
1845 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1846 datap[size]=io_word >> 8;
1847 datap[size+1]=io_word & 0xff;
1849 writew(streamer_priv->streamer_parms_addr, streamer_mmio + LAPA);
1850 for (i = 0; i < 68; i += 2) {
1852 __u8 *datap = (__u8 *) & spt;
1853 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1854 datap[size]=io_word >> 8;
1855 datap[size+1]=io_word & 0xff;
1858 size = sprintf(buffer, "\n%6s: Adapter Address : Node Address : Functional Addr\n", dev->name);
1860 size += sprintf(buffer + size,
1861 "%6s: %pM : %pM : %02x:%02x:%02x:%02x\n",
1862 dev->name, dev->dev_addr, sat.node_addr,
1863 sat.func_addr[0], sat.func_addr[1],
1864 sat.func_addr[2], sat.func_addr[3]);
1866 size += sprintf(buffer + size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1868 size += sprintf(buffer + size, "%6s: Physical Addr : Up Node Address : Poll Address : AccPri : Auth Src : Att Code :\n", dev->name);
1870 size += sprintf(buffer + size,
1871 "%6s: %02x:%02x:%02x:%02x : %pM : %pM : %04x : %04x : %04x :\n",
1872 dev->name, spt.phys_addr[0], spt.phys_addr[1],
1873 spt.phys_addr[2], spt.phys_addr[3],
1874 spt.up_node_addr, spt.poll_addr,
1875 ntohs(spt.acc_priority), ntohs(spt.auth_source_class),
1876 ntohs(spt.att_code));
1878 size += sprintf(buffer + size, "%6s: Source Address : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n", dev->name);
1880 size += sprintf(buffer + size,
1881 "%6s: %pM : %04x : %04x : %04x : %04x : %04x : %04x : \n",
1882 dev->name, spt.source_addr,
1883 ntohs(spt.beacon_type), ntohs(spt.major_vector),
1884 ntohs(spt.lan_status), ntohs(spt.local_ring),
1885 ntohs(spt.mon_error), ntohs(spt.frame_correl));
1887 size += sprintf(buffer + size, "%6s: Beacon Details : Tx : Rx : NAUN Node Address : NAUN Node Phys : \n",
1890 size += sprintf(buffer + size,
1891 "%6s: : %02x : %02x : %pM : %02x:%02x:%02x:%02x : \n",
1892 dev->name, ntohs(spt.beacon_transmit),
1893 ntohs(spt.beacon_receive),
1895 spt.beacon_phys[0], spt.beacon_phys[1],
1896 spt.beacon_phys[2], spt.beacon_phys[3]);
1902 static struct pci_driver streamer_pci_driver = {
1903 .name = "lanstreamer",
1904 .id_table = streamer_pci_tbl,
1905 .probe = streamer_init_one,
1906 .remove = __devexit_p(streamer_remove_one),
1909 static int __init streamer_init_module(void) {
1910 return pci_register_driver(&streamer_pci_driver);
1913 static void __exit streamer_cleanup_module(void) {
1914 pci_unregister_driver(&streamer_pci_driver);
1917 module_init(streamer_init_module);
1918 module_exit(streamer_cleanup_module);
1919 MODULE_LICENSE("GPL");