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/version.h>
123 #include <linux/bitops.h>
124 #include <linux/jiffies.h>
126 #include <net/net_namespace.h>
127 #include <net/checksum.h>
130 #include <asm/system.h>
132 #include "lanstreamer.h"
134 #if (BITS_PER_LONG == 64)
135 #error broken on 64-bit: stores pointer to rx_ring->buffer in 32-bit int
139 /* I've got to put some intelligence into the version number so that Peter and I know
140 * which version of the code somebody has got.
141 * Version Number = a.b.c.d where a.b.c is the level of code and d is the latest author.
142 * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike
144 * Official releases will only have an a.b.c version number format.
147 static char version[] = "LanStreamer.c v0.4.0 03/08/01 - Mike Sullivan\n"
148 " v0.5.3 11/13/02 - Kent Yoder";
150 static struct pci_device_id streamer_pci_tbl[] = {
151 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_TR, PCI_ANY_ID, PCI_ANY_ID,},
152 {} /* terminating entry */
154 MODULE_DEVICE_TABLE(pci,streamer_pci_tbl);
157 static char *open_maj_error[] = {
158 "No error", "Lobe Media Test", "Physical Insertion",
159 "Address Verification", "Neighbor Notification (Ring Poll)",
160 "Request Parameters", "FDX Registration Request",
161 "FDX Lobe Media Test", "FDX Duplicate Address Check",
165 static char *open_min_error[] = {
166 "No error", "Function Failure", "Signal Lost", "Wire Fault",
167 "Ring Speed Mismatch", "Timeout", "Ring Failure", "Ring Beaconing",
168 "Duplicate Node Address", "Request Parameters", "Remove Received",
169 "Reserved", "Reserved", "No Monitor Detected for RPL",
170 "Monitor Contention failer for RPL", "FDX Protocol Error"
173 /* Module paramters */
177 * 4,16 = Selected speed only, no autosense
178 * This allows the card to be the first on the ring
179 * and become the active monitor.
181 * WARNING: Some hubs will allow you to insert
185 static int ringspeed[STREAMER_MAX_ADAPTERS] = { 0, };
187 module_param_array(ringspeed, int, NULL, 0);
189 /* Packet buffer size */
191 static int pkt_buf_sz[STREAMER_MAX_ADAPTERS] = { 0, };
193 module_param_array(pkt_buf_sz, int, NULL, 0);
197 static int message_level[STREAMER_MAX_ADAPTERS] = { 1, };
199 module_param_array(message_level, int, NULL, 0);
202 static int streamer_ioctl(struct net_device *, struct ifreq *, int);
205 static int streamer_reset(struct net_device *dev);
206 static int streamer_open(struct net_device *dev);
207 static int streamer_xmit(struct sk_buff *skb, struct net_device *dev);
208 static int streamer_close(struct net_device *dev);
209 static void streamer_set_rx_mode(struct net_device *dev);
210 static irqreturn_t streamer_interrupt(int irq, void *dev_id);
211 static struct net_device_stats *streamer_get_stats(struct net_device *dev);
212 static int streamer_set_mac_address(struct net_device *dev, void *addr);
213 static void streamer_arb_cmd(struct net_device *dev);
214 static int streamer_change_mtu(struct net_device *dev, int mtu);
215 static void streamer_srb_bh(struct net_device *dev);
216 static void streamer_asb_bh(struct net_device *dev);
217 #if STREAMER_NETWORK_MONITOR
218 #ifdef CONFIG_PROC_FS
219 static int streamer_proc_info(char *buffer, char **start, off_t offset,
220 int length, int *eof, void *data);
221 static int sprintf_info(char *buffer, struct net_device *dev);
222 struct streamer_private *dev_streamer=NULL;
226 static int __devinit streamer_init_one(struct pci_dev *pdev,
227 const struct pci_device_id *ent)
229 struct net_device *dev;
230 struct streamer_private *streamer_priv;
231 unsigned long pio_start, pio_end, pio_flags, pio_len;
232 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
234 static int card_no=-1;
238 printk("lanstreamer::streamer_init_one, entry pdev %p\n",pdev);
242 dev = alloc_trdev(sizeof(*streamer_priv));
244 printk(KERN_ERR "lanstreamer: out of memory.\n");
248 SET_MODULE_OWNER(dev);
249 streamer_priv = dev->priv;
251 #if STREAMER_NETWORK_MONITOR
252 #ifdef CONFIG_PROC_FS
254 create_proc_read_entry("streamer_tr", 0, init_net.proc_net,
255 streamer_proc_info, NULL);
256 streamer_priv->next = dev_streamer;
257 dev_streamer = streamer_priv;
261 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
263 printk(KERN_ERR "%s: No suitable PCI mapping available.\n",
269 rc = pci_enable_device(pdev);
271 printk(KERN_ERR "lanstreamer: unable to enable pci device\n");
276 pci_set_master(pdev);
278 rc = pci_set_mwi(pdev);
280 printk(KERN_ERR "lanstreamer: unable to enable MWI on pci device\n");
281 goto err_out_disable;
284 pio_start = pci_resource_start(pdev, 0);
285 pio_end = pci_resource_end(pdev, 0);
286 pio_flags = pci_resource_flags(pdev, 0);
287 pio_len = pci_resource_len(pdev, 0);
289 mmio_start = pci_resource_start(pdev, 1);
290 mmio_end = pci_resource_end(pdev, 1);
291 mmio_flags = pci_resource_flags(pdev, 1);
292 mmio_len = pci_resource_len(pdev, 1);
295 printk("lanstreamer: pio_start %x pio_end %x pio_len %x pio_flags %x\n",
296 pio_start, pio_end, pio_len, pio_flags);
297 printk("lanstreamer: mmio_start %x mmio_end %x mmio_len %x mmio_flags %x\n",
298 mmio_start, mmio_end, mmio_flags, mmio_len);
301 if (!request_region(pio_start, pio_len, "lanstreamer")) {
302 printk(KERN_ERR "lanstreamer: unable to get pci io addr %lx\n",
308 if (!request_mem_region(mmio_start, mmio_len, "lanstreamer")) {
309 printk(KERN_ERR "lanstreamer: unable to get pci mmio addr %lx\n",
312 goto err_out_free_pio;
315 streamer_priv->streamer_mmio=ioremap(mmio_start, mmio_len);
316 if (streamer_priv->streamer_mmio == NULL) {
317 printk(KERN_ERR "lanstreamer: unable to remap MMIO %lx\n",
320 goto err_out_free_mmio;
323 init_waitqueue_head(&streamer_priv->srb_wait);
324 init_waitqueue_head(&streamer_priv->trb_wait);
326 dev->open = &streamer_open;
327 dev->hard_start_xmit = &streamer_xmit;
328 dev->change_mtu = &streamer_change_mtu;
329 dev->stop = &streamer_close;
331 dev->do_ioctl = &streamer_ioctl;
333 dev->do_ioctl = NULL;
335 dev->set_multicast_list = &streamer_set_rx_mode;
336 dev->get_stats = &streamer_get_stats;
337 dev->set_mac_address = &streamer_set_mac_address;
338 dev->irq = pdev->irq;
339 dev->base_addr=pio_start;
340 SET_NETDEV_DEV(dev, &pdev->dev);
342 streamer_priv->streamer_card_name = (char *)pdev->resource[0].name;
343 streamer_priv->pci_dev = pdev;
345 if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000))
346 streamer_priv->pkt_buf_sz = PKT_BUF_SZ;
348 streamer_priv->pkt_buf_sz = pkt_buf_sz[card_no];
350 streamer_priv->streamer_ring_speed = ringspeed[card_no];
351 streamer_priv->streamer_message_level = message_level[card_no];
353 pci_set_drvdata(pdev, dev);
355 spin_lock_init(&streamer_priv->streamer_lock);
357 pci_read_config_word (pdev, PCI_COMMAND, &pcr);
358 pcr |= PCI_COMMAND_SERR;
359 pci_write_config_word (pdev, PCI_COMMAND, pcr);
361 printk("%s \n", version);
362 printk("%s: %s. I/O at %hx, MMIO at %p, using irq %d\n",dev->name,
363 streamer_priv->streamer_card_name,
364 (unsigned int) dev->base_addr,
365 streamer_priv->streamer_mmio,
368 if (streamer_reset(dev))
371 rc = register_netdev(dev);
377 iounmap(streamer_priv->streamer_mmio);
379 release_mem_region(mmio_start, mmio_len);
381 release_region(pio_start, pio_len);
385 pci_disable_device(pdev);
389 printk("lanstreamer: Exit error %x\n",rc);
394 static void __devexit streamer_remove_one(struct pci_dev *pdev)
396 struct net_device *dev=pci_get_drvdata(pdev);
397 struct streamer_private *streamer_priv;
400 printk("lanstreamer::streamer_remove_one entry pdev %p\n",pdev);
404 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev is NULL\n");
408 streamer_priv=dev->priv;
409 if (streamer_priv == NULL) {
410 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev->priv is NULL\n");
414 #if STREAMER_NETWORK_MONITOR
415 #ifdef CONFIG_PROC_FS
417 struct streamer_private **p, **next;
419 for (p = &dev_streamer; *p; p = next) {
421 if (*p == streamer_priv) {
427 remove_proc_entry("streamer_tr", init_net.proc_net);
432 unregister_netdev(dev);
433 iounmap(streamer_priv->streamer_mmio);
434 release_mem_region(pci_resource_start(pdev, 1), pci_resource_len(pdev,1));
435 release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev,0));
437 pci_disable_device(pdev);
439 pci_set_drvdata(pdev, NULL);
443 static int streamer_reset(struct net_device *dev)
445 struct streamer_private *streamer_priv;
446 __u8 __iomem *streamer_mmio;
448 unsigned int uaa_addr;
449 struct sk_buff *skb = NULL;
452 streamer_priv = (struct streamer_private *) dev->priv;
453 streamer_mmio = streamer_priv->streamer_mmio;
455 writew(readw(streamer_mmio + BCTL) | BCTL_SOFTRESET, streamer_mmio + BCTL);
457 /* Hold soft reset bit for a while */
460 writew(readw(streamer_mmio + BCTL) & ~BCTL_SOFTRESET,
461 streamer_mmio + BCTL);
464 printk("BCTL: %x\n", readw(streamer_mmio + BCTL));
465 printk("GPR: %x\n", readw(streamer_mmio + GPR));
466 printk("SISRMASK: %x\n", readw(streamer_mmio + SISR_MASK));
468 writew(readw(streamer_mmio + BCTL) | (BCTL_RX_FIFO_8 | BCTL_TX_FIFO_8), streamer_mmio + BCTL );
470 if (streamer_priv->streamer_ring_speed == 0) { /* Autosense */
471 writew(readw(streamer_mmio + GPR) | GPR_AUTOSENSE,
472 streamer_mmio + GPR);
473 if (streamer_priv->streamer_message_level)
474 printk(KERN_INFO "%s: Ringspeed autosense mode on\n",
476 } else if (streamer_priv->streamer_ring_speed == 16) {
477 if (streamer_priv->streamer_message_level)
478 printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n",
480 writew(GPR_16MBPS, streamer_mmio + GPR);
481 } else if (streamer_priv->streamer_ring_speed == 4) {
482 if (streamer_priv->streamer_message_level)
483 printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n",
485 writew(0, streamer_mmio + GPR);
488 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
490 printk(KERN_INFO "%s: skb allocation for diagnostics failed...proceeding\n",
493 struct streamer_rx_desc *rx_ring;
496 rx_ring=(struct streamer_rx_desc *)skb->data;
497 data=((u8 *)skb->data)+sizeof(struct streamer_rx_desc);
500 rx_ring->buffer=cpu_to_le32(pci_map_single(streamer_priv->pci_dev, data,
501 512, PCI_DMA_FROMDEVICE));
502 rx_ring->framelen_buflen=512;
503 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, rx_ring, 512, PCI_DMA_FROMDEVICE)),
504 streamer_mmio+RXBDA);
508 printk("GPR = %x\n", readw(streamer_mmio + GPR));
510 /* start solo init */
511 writew(SISR_MI, streamer_mmio + SISR_MASK_SUM);
513 while (!((readw(streamer_mmio + SISR)) & SISR_SRB_REPLY)) {
514 msleep_interruptible(100);
515 if (time_after(jiffies, t + 40 * HZ)) {
517 "IBM PCI tokenring card not responding\n");
518 release_region(dev->base_addr, STREAMER_IO_SPACE);
524 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
525 misr = readw(streamer_mmio + MISR_RUM);
526 writew(~misr, streamer_mmio + MISR_RUM);
529 dev_kfree_skb(skb); /* release skb used for diagnostics */
532 printk("LAPWWO: %x, LAPA: %x LAPE: %x\n",
533 readw(streamer_mmio + LAPWWO), readw(streamer_mmio + LAPA),
534 readw(streamer_mmio + LAPE));
540 writew(readw(streamer_mmio + LAPWWO),
541 streamer_mmio + LAPA);
542 printk("initialization response srb dump: ");
543 for (i = 0; i < 10; i++)
545 ntohs(readw(streamer_mmio + LAPDINC)));
550 writew(readw(streamer_mmio + LAPWWO) + 6, streamer_mmio + LAPA);
551 if (readw(streamer_mmio + LAPD)) {
552 printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",
553 ntohs(readw(streamer_mmio + LAPD)));
554 release_region(dev->base_addr, STREAMER_IO_SPACE);
558 writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA);
559 uaa_addr = ntohs(readw(streamer_mmio + LAPDINC));
560 readw(streamer_mmio + LAPDINC); /* skip over Level.Addr field */
561 streamer_priv->streamer_addr_table_addr = ntohs(readw(streamer_mmio + LAPDINC));
562 streamer_priv->streamer_parms_addr = ntohs(readw(streamer_mmio + LAPDINC));
565 printk("UAA resides at %x\n", uaa_addr);
568 /* setup uaa area for access with LAPD */
572 writew(uaa_addr, streamer_mmio + LAPA);
573 for (i = 0; i < 6; i += 2) {
574 addr=ntohs(readw(streamer_mmio+LAPDINC));
575 dev->dev_addr[i]= (addr >> 8) & 0xff;
576 dev->dev_addr[i+1]= addr & 0xff;
579 printk("Adapter address: ");
580 for (i = 0; i < 6; i++) {
581 printk("%02x:", dev->dev_addr[i]);
589 static int streamer_open(struct net_device *dev)
591 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
592 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
594 char open_error[255];
595 int i, open_finished = 1;
600 if (readw(streamer_mmio+BMCTL_SUM) & BMCTL_RX_ENABLED) {
601 rc=streamer_reset(dev);
604 if (request_irq(dev->irq, &streamer_interrupt, IRQF_SHARED, "lanstreamer", dev)) {
608 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
609 printk("pending ints: %x\n", readw(streamer_mmio + SISR));
612 writew(SISR_MI | SISR_SRB_REPLY, streamer_mmio + SISR_MASK); /* more ints later, doesn't stop arb cmd interrupt */
613 writew(LISR_LIE, streamer_mmio + LISR); /* more ints later */
615 /* adapter is closed, so SRB is pointed to by LAPWWO */
616 writew(readw(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
619 printk("LAPWWO: %x, LAPA: %x\n", readw(streamer_mmio + LAPWWO),
620 readw(streamer_mmio + LAPA));
621 printk("LAPE: %x\n", readw(streamer_mmio + LAPE));
622 printk("SISR Mask = %04x\n", readw(streamer_mmio + SISR_MASK));
627 for (i = 0; i < SRB_COMMAND_SIZE; i += 2) {
628 writew(0, streamer_mmio + LAPDINC);
631 writew(readw(streamer_mmio+LAPWWO),streamer_mmio+LAPA);
632 writew(htons(SRB_OPEN_ADAPTER<<8),streamer_mmio+LAPDINC) ; /* open */
633 writew(htons(STREAMER_CLEAR_RET_CODE<<8),streamer_mmio+LAPDINC);
634 writew(STREAMER_CLEAR_RET_CODE, streamer_mmio + LAPDINC);
636 writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA);
637 #if STREAMER_NETWORK_MONITOR
638 /* If Network Monitor, instruct card to copy MAC frames through the ARB */
639 writew(htons(OPEN_ADAPTER_ENABLE_FDX | OPEN_ADAPTER_PASS_ADC_MAC | OPEN_ADAPTER_PASS_ATT_MAC | OPEN_ADAPTER_PASS_BEACON), streamer_mmio + LAPDINC); /* offset 8 word contains open options */
641 writew(htons(OPEN_ADAPTER_ENABLE_FDX), streamer_mmio + LAPDINC); /* Offset 8 word contains Open.Options */
644 if (streamer_priv->streamer_laa[0]) {
645 writew(readw(streamer_mmio + LAPWWO) + 12, streamer_mmio + LAPA);
646 writew(htons((streamer_priv->streamer_laa[0] << 8) |
647 streamer_priv->streamer_laa[1]),streamer_mmio+LAPDINC);
648 writew(htons((streamer_priv->streamer_laa[2] << 8) |
649 streamer_priv->streamer_laa[3]),streamer_mmio+LAPDINC);
650 writew(htons((streamer_priv->streamer_laa[4] << 8) |
651 streamer_priv->streamer_laa[5]),streamer_mmio+LAPDINC);
652 memcpy(dev->dev_addr, streamer_priv->streamer_laa, dev->addr_len);
655 /* save off srb open offset */
656 srb_open = readw(streamer_mmio + LAPWWO);
658 writew(readw(streamer_mmio + LAPWWO),
659 streamer_mmio + LAPA);
660 printk("srb open request: \n");
661 for (i = 0; i < 16; i++) {
662 printk("%x:", ntohs(readw(streamer_mmio + LAPDINC)));
666 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
667 streamer_priv->srb_queued = 1;
669 /* signal solo that SRB command has been issued */
670 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
671 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
673 while (streamer_priv->srb_queued) {
674 interruptible_sleep_on_timeout(&streamer_priv->srb_wait, 5 * HZ);
675 if (signal_pending(current)) {
676 printk(KERN_WARNING "%s: SRB timed out.\n", dev->name);
677 printk(KERN_WARNING "SISR=%x MISR=%x, LISR=%x\n",
678 readw(streamer_mmio + SISR),
679 readw(streamer_mmio + MISR_RUM),
680 readw(streamer_mmio + LISR));
681 streamer_priv->srb_queued = 0;
687 printk("SISR_MASK: %x\n", readw(streamer_mmio + SISR_MASK));
688 printk("srb open response:\n");
689 writew(srb_open, streamer_mmio + LAPA);
690 for (i = 0; i < 10; i++) {
692 ntohs(readw(streamer_mmio + LAPDINC)));
696 /* If we get the same return response as we set, the interrupt wasn't raised and the open
699 writew(srb_open + 2, streamer_mmio + LAPA);
700 srb_word = ntohs(readw(streamer_mmio + LAPD)) >> 8;
701 if (srb_word == STREAMER_CLEAR_RET_CODE) {
702 printk(KERN_WARNING "%s: Adapter Open time out or error.\n",
708 if (srb_word == 0x07) {
709 if (!streamer_priv->streamer_ring_speed && open_finished) { /* Autosense , first time around */
710 printk(KERN_WARNING "%s: Retrying at different ring speed \n",
716 writew(srb_open + 6, streamer_mmio + LAPA);
717 error_code = ntohs(readw(streamer_mmio + LAPD));
718 strcpy(open_error, open_maj_error[(error_code & 0xf0) >> 4]);
719 strcat(open_error, " - ");
720 strcat(open_error, open_min_error[(error_code & 0x0f)]);
722 if (!streamer_priv->streamer_ring_speed
723 && ((error_code & 0x0f) == 0x0d))
725 printk(KERN_WARNING "%s: Tried to autosense ring speed with no monitors present\n", dev->name);
726 printk(KERN_WARNING "%s: Please try again with a specified ring speed \n", dev->name);
727 free_irq(dev->irq, dev);
731 printk(KERN_WARNING "%s: %s\n",
732 dev->name, open_error);
733 free_irq(dev->irq, dev);
736 } /* if autosense && open_finished */
738 printk(KERN_WARNING "%s: Bad OPEN response: %x\n",
739 dev->name, srb_word);
740 free_irq(dev->irq, dev);
745 } while (!(open_finished)); /* Will only loop if ring speed mismatch re-open attempted && autosense is on */
747 writew(srb_open + 18, streamer_mmio + LAPA);
748 srb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
749 if (srb_word & (1 << 3))
750 if (streamer_priv->streamer_message_level)
751 printk(KERN_INFO "%s: Opened in FDX Mode\n", dev->name);
754 streamer_priv->streamer_ring_speed = 16;
756 streamer_priv->streamer_ring_speed = 4;
758 if (streamer_priv->streamer_message_level)
759 printk(KERN_INFO "%s: Opened in %d Mbps mode\n",
761 streamer_priv->streamer_ring_speed);
763 writew(srb_open + 8, streamer_mmio + LAPA);
764 streamer_priv->asb = ntohs(readw(streamer_mmio + LAPDINC));
765 streamer_priv->srb = ntohs(readw(streamer_mmio + LAPDINC));
766 streamer_priv->arb = ntohs(readw(streamer_mmio + LAPDINC));
767 readw(streamer_mmio + LAPDINC); /* offset 14 word is rsvd */
768 streamer_priv->trb = ntohs(readw(streamer_mmio + LAPDINC));
770 streamer_priv->streamer_receive_options = 0x00;
771 streamer_priv->streamer_copy_all_options = 0;
774 /* enable rx channel */
775 writew(~BMCTL_RX_DIS, streamer_mmio + BMCTL_RUM);
777 /* setup rx descriptors */
778 streamer_priv->streamer_rx_ring=
779 kmalloc( sizeof(struct streamer_rx_desc)*
780 STREAMER_RX_RING_SIZE,GFP_KERNEL);
781 if (!streamer_priv->streamer_rx_ring) {
782 printk(KERN_WARNING "%s ALLOC of streamer rx ring FAILED!!\n",dev->name);
786 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
789 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
795 streamer_priv->streamer_rx_ring[i].forward =
796 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[i + 1],
797 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE));
798 streamer_priv->streamer_rx_ring[i].status = 0;
799 streamer_priv->streamer_rx_ring[i].buffer =
800 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data,
801 streamer_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
802 streamer_priv->streamer_rx_ring[i].framelen_buflen = streamer_priv->pkt_buf_sz;
803 streamer_priv->rx_ring_skb[i] = skb;
805 streamer_priv->streamer_rx_ring[STREAMER_RX_RING_SIZE - 1].forward =
806 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[0],
807 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE));
810 printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n", dev->name);
811 free_irq(dev->irq, dev);
815 streamer_priv->rx_ring_last_received = STREAMER_RX_RING_SIZE - 1; /* last processed rx status */
817 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[0],
818 sizeof(struct streamer_rx_desc), PCI_DMA_TODEVICE)),
819 streamer_mmio + RXBDA);
820 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_rx_ring[STREAMER_RX_RING_SIZE - 1],
821 sizeof(struct streamer_rx_desc), PCI_DMA_TODEVICE)),
822 streamer_mmio + RXLBDA);
824 /* set bus master interrupt event mask */
825 writew(MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK);
829 streamer_priv->streamer_tx_ring=kmalloc(sizeof(struct streamer_tx_desc)*
830 STREAMER_TX_RING_SIZE,GFP_KERNEL);
831 if (!streamer_priv->streamer_tx_ring) {
832 printk(KERN_WARNING "%s ALLOC of streamer_tx_ring FAILED\n",dev->name);
836 writew(~BMCTL_TX2_DIS, streamer_mmio + BMCTL_RUM); /* Enables TX channel 2 */
837 for (i = 0; i < STREAMER_TX_RING_SIZE; i++) {
838 streamer_priv->streamer_tx_ring[i].forward = cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
839 &streamer_priv->streamer_tx_ring[i + 1],
840 sizeof(struct streamer_tx_desc),
842 streamer_priv->streamer_tx_ring[i].status = 0;
843 streamer_priv->streamer_tx_ring[i].bufcnt_framelen = 0;
844 streamer_priv->streamer_tx_ring[i].buffer = 0;
845 streamer_priv->streamer_tx_ring[i].buflen = 0;
846 streamer_priv->streamer_tx_ring[i].rsvd1 = 0;
847 streamer_priv->streamer_tx_ring[i].rsvd2 = 0;
848 streamer_priv->streamer_tx_ring[i].rsvd3 = 0;
850 streamer_priv->streamer_tx_ring[STREAMER_TX_RING_SIZE - 1].forward =
851 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, &streamer_priv->streamer_tx_ring[0],
852 sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE));
854 streamer_priv->free_tx_ring_entries = STREAMER_TX_RING_SIZE;
855 streamer_priv->tx_ring_free = 0; /* next entry in tx ring to use */
856 streamer_priv->tx_ring_last_status = STREAMER_TX_RING_SIZE - 1;
858 /* set Busmaster interrupt event mask (handle receives on interrupt only */
859 writew(MISR_TX2_EOF | MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK);
860 /* set system event interrupt mask */
861 writew(SISR_ADAPTER_CHECK | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_ASB_FREE, streamer_mmio + SISR_MASK_SUM);
864 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
865 printk("SISR MASK: %x\n", readw(streamer_mmio + SISR_MASK));
868 #if STREAMER_NETWORK_MONITOR
870 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
871 printk("%s: Node Address: %04x:%04x:%04x\n", dev->name,
872 ntohs(readw(streamer_mmio + LAPDINC)),
873 ntohs(readw(streamer_mmio + LAPDINC)),
874 ntohs(readw(streamer_mmio + LAPDINC)));
875 readw(streamer_mmio + LAPDINC);
876 readw(streamer_mmio + LAPDINC);
877 printk("%s: Functional Address: %04x:%04x\n", dev->name,
878 ntohs(readw(streamer_mmio + LAPDINC)),
879 ntohs(readw(streamer_mmio + LAPDINC)));
881 writew(streamer_priv->streamer_parms_addr + 4,
882 streamer_mmio + LAPA);
883 printk("%s: NAUN Address: %04x:%04x:%04x\n", dev->name,
884 ntohs(readw(streamer_mmio + LAPDINC)),
885 ntohs(readw(streamer_mmio + LAPDINC)),
886 ntohs(readw(streamer_mmio + LAPDINC)));
889 netif_start_queue(dev);
890 netif_carrier_on(dev);
895 * When we enter the rx routine we do not know how many frames have been
896 * queued on the rx channel. Therefore we start at the next rx status
897 * position and travel around the receive ring until we have completed
900 * This means that we may process the frame before we receive the end
901 * of frame interrupt. This is why we always test the status instead
902 * of blindly processing the next frame.
905 static void streamer_rx(struct net_device *dev)
907 struct streamer_private *streamer_priv =
908 (struct streamer_private *) dev->priv;
909 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
910 struct streamer_rx_desc *rx_desc;
911 int rx_ring_last_received, length, frame_length, buffer_cnt = 0;
912 struct sk_buff *skb, *skb2;
914 /* setup the next rx descriptor to be received */
915 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)];
916 rx_ring_last_received = streamer_priv->rx_ring_last_received;
918 while (rx_desc->status & 0x01000000) { /* While processed descriptors are available */
919 if (rx_ring_last_received != streamer_priv->rx_ring_last_received)
921 printk(KERN_WARNING "RX Error 1 rx_ring_last_received not the same %x %x\n",
922 rx_ring_last_received, streamer_priv->rx_ring_last_received);
924 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
925 rx_ring_last_received = streamer_priv->rx_ring_last_received;
927 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */
928 frame_length = (rx_desc->framelen_buflen >> 16) & 0xffff;
930 if (rx_desc->status & 0x7E830000) { /* errors */
931 if (streamer_priv->streamer_message_level) {
932 printk(KERN_WARNING "%s: Rx Error %x \n",
933 dev->name, rx_desc->status);
935 } else { /* received without errors */
936 if (rx_desc->status & 0x80000000) { /* frame complete */
938 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
940 skb = dev_alloc_skb(frame_length);
945 printk(KERN_WARNING "%s: Not enough memory to copy packet to upper layers. \n", dev->name);
946 streamer_priv->streamer_stats.rx_dropped++;
947 } else { /* we allocated an skb OK */
948 if (buffer_cnt == 1) {
949 /* release the DMA mapping */
950 pci_unmap_single(streamer_priv->pci_dev,
951 le32_to_cpu(streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer),
952 streamer_priv->pkt_buf_sz,
954 skb2 = streamer_priv->rx_ring_skb[rx_ring_last_received];
955 #if STREAMER_DEBUG_PACKETS
958 printk("streamer_rx packet print: skb->data2 %p skb->head %p\n", skb2->data, skb2->head);
959 for (i = 0; i < frame_length; i++)
961 printk("%x:", skb2->data[i]);
962 if (((i + 1) % 16) == 0)
968 skb_put(skb2, length);
969 skb2->protocol = tr_type_trans(skb2, dev);
970 /* recycle this descriptor */
971 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0;
972 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz;
973 streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer =
974 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, streamer_priv->pkt_buf_sz,
975 PCI_DMA_FROMDEVICE));
976 streamer_priv->rx_ring_skb[rx_ring_last_received] = skb;
977 /* place recycled descriptor back on the adapter */
978 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
979 &streamer_priv->streamer_rx_ring[rx_ring_last_received],
980 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE)),
981 streamer_mmio + RXLBDA);
982 /* pass the received skb up to the protocol */
985 do { /* Walk the buffers */
986 pci_unmap_single(streamer_priv->pci_dev, le32_to_cpu(rx_desc->buffer), length, PCI_DMA_FROMDEVICE),
987 memcpy(skb_put(skb, length), (void *)rx_desc->buffer, length); /* copy this fragment */
988 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0;
989 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz;
991 /* give descriptor back to the adapter */
992 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
993 &streamer_priv->streamer_rx_ring[rx_ring_last_received],
994 length, PCI_DMA_FROMDEVICE)),
995 streamer_mmio + RXLBDA);
997 if (rx_desc->status & 0x80000000)
998 break; /* this descriptor completes the frame */
1000 /* else get the next pending descriptor */
1001 if (rx_ring_last_received!= streamer_priv->rx_ring_last_received)
1003 printk("RX Error rx_ring_last_received not the same %x %x\n",
1004 rx_ring_last_received,
1005 streamer_priv->rx_ring_last_received);
1007 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE-1)];
1009 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */
1010 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE - 1);
1011 rx_ring_last_received = streamer_priv->rx_ring_last_received;
1014 skb->protocol = tr_type_trans(skb, dev);
1015 /* send up to the protocol */
1018 dev->last_rx = jiffies;
1019 streamer_priv->streamer_stats.rx_packets++;
1020 streamer_priv->streamer_stats.rx_bytes += length;
1021 } /* if skb == null */
1022 } /* end received without errors */
1024 /* try the next one */
1025 rx_desc = &streamer_priv->streamer_rx_ring[(rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)];
1026 } /* end for all completed rx descriptors */
1029 static irqreturn_t streamer_interrupt(int irq, void *dev_id)
1031 struct net_device *dev = (struct net_device *) dev_id;
1032 struct streamer_private *streamer_priv =
1033 (struct streamer_private *) dev->priv;
1034 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1037 u8 max_intr = MAX_INTR;
1039 spin_lock(&streamer_priv->streamer_lock);
1040 sisr = readw(streamer_mmio + SISR);
1042 while((sisr & (SISR_MI | SISR_SRB_REPLY | SISR_ADAPTER_CHECK | SISR_ASB_FREE |
1043 SISR_ARB_CMD | SISR_TRB_REPLY | SISR_PAR_ERR | SISR_SERR_ERR))
1044 && (max_intr > 0)) {
1046 if(sisr & SISR_PAR_ERR) {
1047 writew(~SISR_PAR_ERR, streamer_mmio + SISR_RUM);
1048 (void)readw(streamer_mmio + SISR_RUM);
1051 else if(sisr & SISR_SERR_ERR) {
1052 writew(~SISR_SERR_ERR, streamer_mmio + SISR_RUM);
1053 (void)readw(streamer_mmio + SISR_RUM);
1056 else if(sisr & SISR_MI) {
1057 misr = readw(streamer_mmio + MISR_RUM);
1059 if (misr & MISR_TX2_EOF) {
1060 while(streamer_priv->streamer_tx_ring[(streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1)].status) {
1061 streamer_priv->tx_ring_last_status = (streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1);
1062 streamer_priv->free_tx_ring_entries++;
1063 streamer_priv->streamer_stats.tx_bytes += streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]->len;
1064 streamer_priv->streamer_stats.tx_packets++;
1065 dev_kfree_skb_irq(streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]);
1066 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buffer = 0xdeadbeef;
1067 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].status = 0;
1068 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].bufcnt_framelen = 0;
1069 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buflen = 0;
1070 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd1 = 0;
1071 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd2 = 0;
1072 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd3 = 0;
1074 netif_wake_queue(dev);
1077 if (misr & MISR_RX_EOF) {
1082 if (misr & MISR_RX_NOBUF) {
1083 /* According to the documentation, we don't have to do anything,
1084 * but trapping it keeps it out of /var/log/messages.
1086 } /* SISR_RX_NOBUF */
1088 writew(~misr, streamer_mmio + MISR_RUM);
1089 (void)readw(streamer_mmio + MISR_RUM);
1092 else if (sisr & SISR_SRB_REPLY) {
1093 if (streamer_priv->srb_queued == 1) {
1094 wake_up_interruptible(&streamer_priv->srb_wait);
1095 } else if (streamer_priv->srb_queued == 2) {
1096 streamer_srb_bh(dev);
1098 streamer_priv->srb_queued = 0;
1100 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
1101 (void)readw(streamer_mmio + SISR_RUM);
1104 else if (sisr & SISR_ADAPTER_CHECK) {
1105 printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name);
1106 writel(readl(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
1107 printk(KERN_WARNING "%s: Words %x:%x:%x:%x:\n",
1108 dev->name, readw(streamer_mmio + LAPDINC),
1109 ntohs(readw(streamer_mmio + LAPDINC)),
1110 ntohs(readw(streamer_mmio + LAPDINC)),
1111 ntohs(readw(streamer_mmio + LAPDINC)));
1112 netif_stop_queue(dev);
1113 netif_carrier_off(dev);
1114 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1117 /* SISR_ADAPTER_CHECK */
1118 else if (sisr & SISR_ASB_FREE) {
1119 /* Wake up anything that is waiting for the asb response */
1120 if (streamer_priv->asb_queued) {
1121 streamer_asb_bh(dev);
1123 writew(~SISR_ASB_FREE, streamer_mmio + SISR_RUM);
1124 (void)readw(streamer_mmio + SISR_RUM);
1127 else if (sisr & SISR_ARB_CMD) {
1128 streamer_arb_cmd(dev);
1129 writew(~SISR_ARB_CMD, streamer_mmio + SISR_RUM);
1130 (void)readw(streamer_mmio + SISR_RUM);
1133 else if (sisr & SISR_TRB_REPLY) {
1134 /* Wake up anything that is waiting for the trb response */
1135 if (streamer_priv->trb_queued) {
1136 wake_up_interruptible(&streamer_priv->
1139 streamer_priv->trb_queued = 0;
1140 writew(~SISR_TRB_REPLY, streamer_mmio + SISR_RUM);
1141 (void)readw(streamer_mmio + SISR_RUM);
1143 /* SISR_TRB_REPLY */
1145 sisr = readw(streamer_mmio + SISR);
1149 spin_unlock(&streamer_priv->streamer_lock) ;
1153 static int streamer_xmit(struct sk_buff *skb, struct net_device *dev)
1155 struct streamer_private *streamer_priv =
1156 (struct streamer_private *) dev->priv;
1157 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1158 unsigned long flags ;
1160 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1162 if (streamer_priv->free_tx_ring_entries) {
1163 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].status = 0;
1164 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].bufcnt_framelen = 0x00020000 | skb->len;
1165 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buffer =
1166 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE));
1167 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd1 = skb->len;
1168 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd2 = 0;
1169 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd3 = 0;
1170 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buflen = skb->len;
1172 streamer_priv->tx_ring_skb[streamer_priv->tx_ring_free] = skb;
1173 streamer_priv->free_tx_ring_entries--;
1174 #if STREAMER_DEBUG_PACKETS
1177 printk("streamer_xmit packet print:\n");
1178 for (i = 0; i < skb->len; i++) {
1179 printk("%x:", skb->data[i]);
1180 if (((i + 1) % 16) == 0)
1187 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
1188 &streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free],
1189 sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE)),
1190 streamer_mmio + TX2LFDA);
1191 (void)readl(streamer_mmio + TX2LFDA);
1193 streamer_priv->tx_ring_free = (streamer_priv->tx_ring_free + 1) & (STREAMER_TX_RING_SIZE - 1);
1194 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1197 netif_stop_queue(dev);
1198 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1204 static int streamer_close(struct net_device *dev)
1206 struct streamer_private *streamer_priv =
1207 (struct streamer_private *) dev->priv;
1208 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1209 unsigned long flags;
1212 netif_stop_queue(dev);
1213 netif_carrier_off(dev);
1214 writew(streamer_priv->srb, streamer_mmio + LAPA);
1215 writew(htons(SRB_CLOSE_ADAPTER << 8),streamer_mmio+LAPDINC);
1216 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1218 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1220 streamer_priv->srb_queued = 1;
1221 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1223 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
1225 while (streamer_priv->srb_queued)
1227 interruptible_sleep_on_timeout(&streamer_priv->srb_wait,
1229 if (signal_pending(current))
1231 printk(KERN_WARNING "%s: SRB timed out.\n", dev->name);
1232 printk(KERN_WARNING "SISR=%x MISR=%x LISR=%x\n",
1233 readw(streamer_mmio + SISR),
1234 readw(streamer_mmio + MISR_RUM),
1235 readw(streamer_mmio + LISR));
1236 streamer_priv->srb_queued = 0;
1241 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1243 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
1244 if (streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]) {
1245 dev_kfree_skb(streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]);
1247 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1250 /* reset tx/rx fifo's and busmaster logic */
1252 /* TBD. Add graceful way to reset the LLC channel without doing a soft reset.
1253 writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1255 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL);
1259 writew(streamer_priv->srb, streamer_mmio + LAPA);
1261 for (i = 0; i < 2; i++) {
1262 printk("%x ", ntohs(readw(streamer_mmio + LAPDINC)));
1266 free_irq(dev->irq, dev);
1270 static void streamer_set_rx_mode(struct net_device *dev)
1272 struct streamer_private *streamer_priv =
1273 (struct streamer_private *) dev->priv;
1274 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1276 struct dev_mc_list *dmi;
1277 unsigned char dev_mc_address[5];
1280 writel(streamer_priv->srb, streamer_mmio + LAPA);
1281 options = streamer_priv->streamer_copy_all_options;
1283 if (dev->flags & IFF_PROMISC)
1284 options |= (3 << 5); /* All LLC and MAC frames, all through the main rx channel */
1286 options &= ~(3 << 5);
1288 /* Only issue the srb if there is a change in options */
1290 if ((options ^ streamer_priv->streamer_copy_all_options))
1292 /* Now to issue the srb command to alter the copy.all.options */
1293 writew(htons(SRB_MODIFY_RECEIVE_OPTIONS << 8), streamer_mmio+LAPDINC);
1294 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1295 writew(htons((streamer_priv->streamer_receive_options << 8) | options),streamer_mmio+LAPDINC);
1296 writew(htons(0x4a41),streamer_mmio+LAPDINC);
1297 writew(htons(0x4d45),streamer_mmio+LAPDINC);
1298 writew(htons(0x5320),streamer_mmio+LAPDINC);
1299 writew(0x2020, streamer_mmio + LAPDINC);
1301 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1303 writel(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1305 streamer_priv->streamer_copy_all_options = options;
1309 /* Set the functional addresses we need for multicast */
1310 writel(streamer_priv->srb,streamer_mmio+LAPA);
1311 dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ;
1313 for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next)
1315 dev_mc_address[0] |= dmi->dmi_addr[2] ;
1316 dev_mc_address[1] |= dmi->dmi_addr[3] ;
1317 dev_mc_address[2] |= dmi->dmi_addr[4] ;
1318 dev_mc_address[3] |= dmi->dmi_addr[5] ;
1321 writew(htons(SRB_SET_FUNC_ADDRESS << 8),streamer_mmio+LAPDINC);
1322 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1323 writew(0,streamer_mmio+LAPDINC);
1324 writew(htons( (dev_mc_address[0] << 8) | dev_mc_address[1]),streamer_mmio+LAPDINC);
1325 writew(htons( (dev_mc_address[2] << 8) | dev_mc_address[3]),streamer_mmio+LAPDINC);
1326 streamer_priv->srb_queued = 2 ;
1327 writel(LISR_SRB_CMD,streamer_mmio+LISR_SUM);
1330 static void streamer_srb_bh(struct net_device *dev)
1332 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
1333 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1336 writew(streamer_priv->srb, streamer_mmio + LAPA);
1337 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1341 /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous)
1342 * At some point we should do something if we get an error, such as
1343 * resetting the IFF_PROMISC flag in dev
1346 case SRB_MODIFY_RECEIVE_OPTIONS:
1347 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1351 printk(KERN_WARNING "%s: Unrecognized srb command\n", dev->name);
1354 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1357 if (streamer_priv->streamer_message_level)
1358 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",
1360 streamer_priv->streamer_copy_all_options,
1361 streamer_priv->streamer_receive_options);
1363 } /* switch srb[2] */
1367 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1369 case SRB_SET_GROUP_ADDRESS:
1370 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1375 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name);
1378 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1381 printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n", dev->name);
1383 case 0x3e: /* If we ever implement individual multicast addresses, will need to deal with this */
1384 printk(KERN_WARNING "%s: Group address registers full\n", dev->name);
1387 printk(KERN_INFO "%s: Group Address already set.\n", dev->name);
1391 } /* switch srb[2] */
1395 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1397 case SRB_RESET_GROUP_ADDRESS:
1398 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1403 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1406 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1408 case 0x39: /* Must deal with this if individual multicast addresses used */
1409 printk(KERN_INFO "%s: Group address not found \n", dev->name);
1413 } /* switch srb[2] */
1417 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1420 case SRB_SET_FUNC_ADDRESS:
1421 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1424 if (streamer_priv->streamer_message_level)
1425 printk(KERN_INFO "%s: Functional Address Mask Set \n", dev->name);
1428 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1431 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1435 } /* switch srb[2] */
1438 /* SRB_READ_LOG - Read and reset the adapter error counters
1442 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1447 if (streamer_priv->streamer_message_level)
1448 printk(KERN_INFO "%s: Read Log command complete\n", dev->name);
1449 printk("Read Log statistics: ");
1450 writew(streamer_priv->srb + 6,
1451 streamer_mmio + LAPA);
1452 for (i = 0; i < 5; i++) {
1453 printk("%x:", ntohs(readw(streamer_mmio + LAPDINC)));
1459 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1462 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1465 } /* switch srb[2] */
1468 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1470 case SRB_READ_SR_COUNTERS:
1471 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1474 if (streamer_priv->streamer_message_level)
1475 printk(KERN_INFO "%s: Read Source Routing Counters issued\n", dev->name);
1478 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1481 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1485 } /* switch srb[2] */
1489 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n", dev->name);
1491 } /* switch srb[0] */
1494 static struct net_device_stats *streamer_get_stats(struct net_device *dev)
1496 struct streamer_private *streamer_priv;
1497 streamer_priv = (struct streamer_private *) dev->priv;
1498 return (struct net_device_stats *) &streamer_priv->streamer_stats;
1501 static int streamer_set_mac_address(struct net_device *dev, void *addr)
1503 struct sockaddr *saddr = addr;
1504 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
1506 if (netif_running(dev))
1508 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name);
1512 memcpy(streamer_priv->streamer_laa, saddr->sa_data, dev->addr_len);
1514 if (streamer_priv->streamer_message_level) {
1515 printk(KERN_INFO "%s: MAC/LAA Set to = %x.%x.%x.%x.%x.%x\n",
1516 dev->name, streamer_priv->streamer_laa[0],
1517 streamer_priv->streamer_laa[1],
1518 streamer_priv->streamer_laa[2],
1519 streamer_priv->streamer_laa[3],
1520 streamer_priv->streamer_laa[4],
1521 streamer_priv->streamer_laa[5]);
1526 static void streamer_arb_cmd(struct net_device *dev)
1528 struct streamer_private *streamer_priv =
1529 (struct streamer_private *) dev->priv;
1530 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1532 __u16 frame_len, buffer_len;
1533 struct sk_buff *mac_frame;
1534 __u8 frame_data[256];
1536 __u16 lan_status = 0, lan_status_diff; /* Initialize to stop compiler warning */
1537 __u8 fdx_prot_error;
1541 #if STREAMER_NETWORK_MONITOR
1542 struct trh_hdr *mac_hdr;
1545 writew(streamer_priv->arb, streamer_mmio + LAPA);
1546 arb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1548 if (arb_word == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
1549 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1550 streamer_priv->mac_rx_buffer = buff_off = ntohs(readw(streamer_mmio + LAPDINC));
1551 header_len=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; /* 802.5 Token-Ring Header Length */
1552 frame_len = ntohs(readw(streamer_mmio + LAPDINC));
1561 writew(ntohs(buff_off), streamer_mmio + LAPA); /*setup window to frame data */
1562 next = htons(readw(streamer_mmio + LAPDINC));
1564 ntohs(readw(streamer_mmio + LAPDINC)) & 0xff;
1565 len = ntohs(readw(streamer_mmio + LAPDINC));
1567 /* print out 1st 14 bytes of frame data */
1568 for (i = 0; i < 7; i++) {
1569 printk("Loc %d = %04x\n", i,
1571 (streamer_mmio + LAPDINC)));
1574 printk("next %04x, fs %02x, len %04x \n", next,
1578 if (!(mac_frame = dev_alloc_skb(frame_len))) {
1579 printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n",
1583 /* Walk the buffer chain, creating the frame */
1589 writew(htons(buff_off), streamer_mmio + LAPA); /* setup window to frame data */
1590 next_ptr = ntohs(readw(streamer_mmio + LAPDINC));
1591 readw(streamer_mmio + LAPDINC); /* read thru status word */
1592 buffer_len = ntohs(readw(streamer_mmio + LAPDINC));
1594 if (buffer_len > 256)
1598 while (i < buffer_len) {
1599 rx_word=ntohs(readw(streamer_mmio+LAPDINC));
1600 frame_data[i]=rx_word >> 8;
1601 frame_data[i+1]=rx_word & 0xff;
1605 memcpy(skb_put(mac_frame, buffer_len),
1606 frame_data, buffer_len);
1607 } while (next_ptr && (buff_off = next_ptr));
1609 mac_frame->protocol = tr_type_trans(mac_frame, dev);
1610 #if STREAMER_NETWORK_MONITOR
1611 printk(KERN_WARNING "%s: Received MAC Frame, details: \n",
1613 mac_hdr = tr_hdr(mac_frame);
1615 "%s: MAC Frame Dest. Addr: %02x:%02x:%02x:%02x:%02x:%02x \n",
1616 dev->name, mac_hdr->daddr[0], mac_hdr->daddr[1],
1617 mac_hdr->daddr[2], mac_hdr->daddr[3],
1618 mac_hdr->daddr[4], mac_hdr->daddr[5]);
1620 "%s: MAC Frame Srce. Addr: %02x:%02x:%02x:%02x:%02x:%02x \n",
1621 dev->name, mac_hdr->saddr[0], mac_hdr->saddr[1],
1622 mac_hdr->saddr[2], mac_hdr->saddr[3],
1623 mac_hdr->saddr[4], mac_hdr->saddr[5]);
1625 netif_rx(mac_frame);
1627 /* Now tell the card we have dealt with the received frame */
1629 /* Set LISR Bit 1 */
1630 writel(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1632 /* Is the ASB free ? */
1634 if (!(readl(streamer_priv->streamer_mmio + SISR) & SISR_ASB_FREE))
1636 streamer_priv->asb_queued = 1;
1637 writel(LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1639 /* Drop out and wait for the bottom half to be run */
1643 writew(streamer_priv->asb, streamer_mmio + LAPA);
1644 writew(htons(ASB_RECEIVE_DATA << 8), streamer_mmio+LAPDINC);
1645 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1646 writew(0, streamer_mmio + LAPDINC);
1647 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1649 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1651 streamer_priv->asb_queued = 2;
1654 } else if (arb_word == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
1655 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1656 lan_status = ntohs(readw(streamer_mmio + LAPDINC));
1657 fdx_prot_error = ntohs(readw(streamer_mmio+LAPD)) >> 8;
1659 /* Issue ARB Free */
1660 writew(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1662 lan_status_diff = (streamer_priv->streamer_lan_status ^ lan_status) &
1665 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR))
1667 if (lan_status_diff & LSC_LWF)
1668 printk(KERN_WARNING "%s: Short circuit detected on the lobe\n", dev->name);
1669 if (lan_status_diff & LSC_ARW)
1670 printk(KERN_WARNING "%s: Auto removal error\n", dev->name);
1671 if (lan_status_diff & LSC_FPE)
1672 printk(KERN_WARNING "%s: FDX Protocol Error\n", dev->name);
1673 if (lan_status_diff & LSC_RR)
1674 printk(KERN_WARNING "%s: Force remove MAC frame received\n", dev->name);
1676 /* Adapter has been closed by the hardware */
1678 /* reset tx/rx fifo's and busmaster logic */
1680 /* @TBD. no llc reset on autostreamer writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1682 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); */
1684 netif_stop_queue(dev);
1685 netif_carrier_off(dev);
1686 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1688 /* If serious error */
1689 if (streamer_priv->streamer_message_level) {
1690 if (lan_status_diff & LSC_SIG_LOSS)
1691 printk(KERN_WARNING "%s: No receive signal detected \n", dev->name);
1692 if (lan_status_diff & LSC_HARD_ERR)
1693 printk(KERN_INFO "%s: Beaconing \n", dev->name);
1694 if (lan_status_diff & LSC_SOFT_ERR)
1695 printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n", dev->name);
1696 if (lan_status_diff & LSC_TRAN_BCN)
1697 printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n", dev->name);
1698 if (lan_status_diff & LSC_SS)
1699 printk(KERN_INFO "%s: Single Station on the ring \n", dev->name);
1700 if (lan_status_diff & LSC_RING_REC)
1701 printk(KERN_INFO "%s: Ring recovery ongoing\n", dev->name);
1702 if (lan_status_diff & LSC_FDX_MODE)
1703 printk(KERN_INFO "%s: Operating in FDX mode\n", dev->name);
1706 if (lan_status_diff & LSC_CO) {
1707 if (streamer_priv->streamer_message_level)
1708 printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1710 /* Issue READ.LOG command */
1712 writew(streamer_priv->srb, streamer_mmio + LAPA);
1713 writew(htons(SRB_READ_LOG << 8),streamer_mmio+LAPDINC);
1714 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1715 writew(0, streamer_mmio + LAPDINC);
1716 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1718 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1721 if (lan_status_diff & LSC_SR_CO) {
1722 if (streamer_priv->streamer_message_level)
1723 printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
1725 /* Issue a READ.SR.COUNTERS */
1726 writew(streamer_priv->srb, streamer_mmio + LAPA);
1727 writew(htons(SRB_READ_SR_COUNTERS << 8),
1728 streamer_mmio+LAPDINC);
1729 writew(htons(STREAMER_CLEAR_RET_CODE << 8),
1730 streamer_mmio+LAPDINC);
1731 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1732 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1735 streamer_priv->streamer_lan_status = lan_status;
1736 } /* Lan.change.status */
1738 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1741 static void streamer_asb_bh(struct net_device *dev)
1743 struct streamer_private *streamer_priv =
1744 (struct streamer_private *) dev->priv;
1745 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1747 if (streamer_priv->asb_queued == 1)
1749 /* Dropped through the first time */
1751 writew(streamer_priv->asb, streamer_mmio + LAPA);
1752 writew(htons(ASB_RECEIVE_DATA << 8),streamer_mmio+LAPDINC);
1753 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1754 writew(0, streamer_mmio + LAPDINC);
1755 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1757 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1758 streamer_priv->asb_queued = 2;
1763 if (streamer_priv->asb_queued == 2) {
1765 writew(streamer_priv->asb + 2, streamer_mmio + LAPA);
1766 rc=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1769 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1772 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1775 /* Valid response, everything should be ok again */
1778 printk(KERN_WARNING "%s: Invalid return code in asb\n", dev->name);
1782 streamer_priv->asb_queued = 0;
1785 static int streamer_change_mtu(struct net_device *dev, int mtu)
1787 struct streamer_private *streamer_priv =
1788 (struct streamer_private *) dev->priv;
1791 if (streamer_priv->streamer_ring_speed == 4)
1802 streamer_priv->pkt_buf_sz = mtu + TR_HLEN;
1807 #if STREAMER_NETWORK_MONITOR
1808 #ifdef CONFIG_PROC_FS
1809 static int streamer_proc_info(char *buffer, char **start, off_t offset,
1810 int length, int *eof, void *data)
1812 struct streamer_private *sdev=NULL;
1813 struct pci_dev *pci_device = NULL;
1819 struct net_device *dev;
1821 size = sprintf(buffer, "IBM LanStreamer/MPC Chipset Token Ring Adapters\n");
1826 for(sdev=dev_streamer; sdev; sdev=sdev->next) {
1827 pci_device=sdev->pci_dev;
1828 dev=pci_get_drvdata(pci_device);
1830 size = sprintf_info(buffer + len, dev);
1838 if (pos > offset + length)
1842 *start = buffer + (offset - begin); /* Start of wanted data */
1843 len -= (offset - begin); /* Start slop */
1845 len = length; /* Ending slop */
1849 static int sprintf_info(char *buffer, struct net_device *dev)
1851 struct streamer_private *streamer_priv =
1852 (struct streamer_private *) dev->priv;
1853 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1854 struct streamer_adapter_addr_table sat;
1855 struct streamer_parameters_table spt;
1859 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
1860 for (i = 0; i < 14; i += 2) {
1862 __u8 *datap = (__u8 *) & sat;
1863 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1864 datap[size]=io_word >> 8;
1865 datap[size+1]=io_word & 0xff;
1867 writew(streamer_priv->streamer_parms_addr, streamer_mmio + LAPA);
1868 for (i = 0; i < 68; i += 2) {
1870 __u8 *datap = (__u8 *) & spt;
1871 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1872 datap[size]=io_word >> 8;
1873 datap[size+1]=io_word & 0xff;
1876 size = sprintf(buffer, "\n%6s: Adapter Address : Node Address : Functional Addr\n", dev->name);
1878 size += sprintf(buffer + size,
1879 "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x\n",
1880 dev->name, dev->dev_addr[0], dev->dev_addr[1],
1881 dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4],
1882 dev->dev_addr[5], sat.node_addr[0], sat.node_addr[1],
1883 sat.node_addr[2], sat.node_addr[3], sat.node_addr[4],
1884 sat.node_addr[5], sat.func_addr[0], sat.func_addr[1],
1885 sat.func_addr[2], sat.func_addr[3]);
1887 size += sprintf(buffer + size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1889 size += sprintf(buffer + size, "%6s: Physical Addr : Up Node Address : Poll Address : AccPri : Auth Src : Att Code :\n", dev->name);
1891 size += sprintf(buffer + size,
1892 "%6s: %02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x :\n",
1893 dev->name, spt.phys_addr[0], spt.phys_addr[1],
1894 spt.phys_addr[2], spt.phys_addr[3],
1895 spt.up_node_addr[0], spt.up_node_addr[1],
1896 spt.up_node_addr[2], spt.up_node_addr[3],
1897 spt.up_node_addr[4], spt.up_node_addr[4],
1898 spt.poll_addr[0], spt.poll_addr[1], spt.poll_addr[2],
1899 spt.poll_addr[3], spt.poll_addr[4], spt.poll_addr[5],
1900 ntohs(spt.acc_priority), ntohs(spt.auth_source_class),
1901 ntohs(spt.att_code));
1903 size += sprintf(buffer + size, "%6s: Source Address : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n", dev->name);
1905 size += sprintf(buffer + size,
1906 "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x : %04x : %04x : %04x : \n",
1907 dev->name, spt.source_addr[0], spt.source_addr[1],
1908 spt.source_addr[2], spt.source_addr[3],
1909 spt.source_addr[4], spt.source_addr[5],
1910 ntohs(spt.beacon_type), ntohs(spt.major_vector),
1911 ntohs(spt.lan_status), ntohs(spt.local_ring),
1912 ntohs(spt.mon_error), ntohs(spt.frame_correl));
1914 size += sprintf(buffer + size, "%6s: Beacon Details : Tx : Rx : NAUN Node Address : NAUN Node Phys : \n",
1917 size += sprintf(buffer + size,
1918 "%6s: : %02x : %02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x : \n",
1919 dev->name, ntohs(spt.beacon_transmit),
1920 ntohs(spt.beacon_receive), spt.beacon_naun[0],
1921 spt.beacon_naun[1], spt.beacon_naun[2],
1922 spt.beacon_naun[3], spt.beacon_naun[4],
1923 spt.beacon_naun[5], spt.beacon_phys[0],
1924 spt.beacon_phys[1], spt.beacon_phys[2],
1925 spt.beacon_phys[3]);
1931 static struct pci_driver streamer_pci_driver = {
1932 .name = "lanstreamer",
1933 .id_table = streamer_pci_tbl,
1934 .probe = streamer_init_one,
1935 .remove = __devexit_p(streamer_remove_one),
1938 static int __init streamer_init_module(void) {
1939 return pci_register_driver(&streamer_pci_driver);
1942 static void __exit streamer_cleanup_module(void) {
1943 pci_unregister_driver(&streamer_pci_driver);
1946 module_init(streamer_init_module);
1947 module_exit(streamer_cleanup_module);
1948 MODULE_LICENSE("GPL");