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