]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/tokenring/lanstreamer.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[NET]: Make /proc/net per network namespace
[mirror_ubuntu-artful-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
248 SET_MODULE_OWNER(dev);
249 streamer_priv = dev->priv;
250
251#if STREAMER_NETWORK_MONITOR
252#ifdef CONFIG_PROC_FS
253 if (!dev_streamer)
457c4cbc 254 create_proc_read_entry("streamer_tr", 0, init_net.proc_net,
1da177e4
LT		 255 streamer_proc_info, NULL);
256 streamer_priv->next = dev_streamer;
257 dev_streamer = streamer_priv;
258#endif
259#endif
260
1e7f0bd8 261 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
1da177e4
LT		 262 if (rc) {
263 printk(KERN_ERR "%s: No suitable PCI mapping available.\n",
264 dev->name);
265 rc = -ENODEV;
266 goto err_out;
267 }
268
269 rc = pci_enable_device(pdev);
270 if (rc) {
271 printk(KERN_ERR "lanstreamer: unable to enable pci device\n");
272 rc=-EIO;
273 goto err_out;
274 }
275
276 pci_set_master(pdev);
277
278 rc = pci_set_mwi(pdev);
279 if (rc) {
280 printk(KERN_ERR "lanstreamer: unable to enable MWI on pci device\n");
281 goto err_out_disable;
282 }
283
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);
288
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);
293
294#if STREAMER_DEBUG
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);
299#endif
300
301 if (!request_region(pio_start, pio_len, "lanstreamer")) {
302 printk(KERN_ERR "lanstreamer: unable to get pci io addr %lx\n",
303 pio_start);
304 rc= -EBUSY;
305 goto err_out_mwi;
306 }
307
308 if (!request_mem_region(mmio_start, mmio_len, "lanstreamer")) {
309 printk(KERN_ERR "lanstreamer: unable to get pci mmio addr %lx\n",
310 mmio_start);
311 rc= -EBUSY;
312 goto err_out_free_pio;
313 }
314
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",
318 mmio_start);
319 rc= -EIO;
320 goto err_out_free_mmio;
321 }
322
323 init_waitqueue_head(&streamer_priv->srb_wait);
324 init_waitqueue_head(&streamer_priv->trb_wait);
325
326 dev->open = &streamer_open;
327 dev->hard_start_xmit = &streamer_xmit;
328 dev->change_mtu = &streamer_change_mtu;
329 dev->stop = &streamer_close;
330#if STREAMER_IOCTL
331 dev->do_ioctl = &streamer_ioctl;
332#else
333 dev->do_ioctl = NULL;
334#endif
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);
341
342 streamer_priv->streamer_card_name = (char *)pdev->resource[0].name;
343 streamer_priv->pci_dev = pdev;
344
345 if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000))
346 streamer_priv->pkt_buf_sz = PKT_BUF_SZ;
347 else
348 streamer_priv->pkt_buf_sz = pkt_buf_sz[card_no];
349
350 streamer_priv->streamer_ring_speed = ringspeed[card_no];
351 streamer_priv->streamer_message_level = message_level[card_no];
352
353 pci_set_drvdata(pdev, dev);
354
355 spin_lock_init(&streamer_priv->streamer_lock);
356
357 pci_read_config_word (pdev, PCI_COMMAND, &pcr);
358 pcr |= PCI_COMMAND_SERR;
359 pci_write_config_word (pdev, PCI_COMMAND, pcr);
360
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,
366 dev->irq);
367
368 if (streamer_reset(dev))
369 goto err_out_unmap;
370
371 rc = register_netdev(dev);
372 if (rc)
373 goto err_out_unmap;
374 return 0;
375
376err_out_unmap:
377 iounmap(streamer_priv->streamer_mmio);
378err_out_free_mmio:
379 release_mem_region(mmio_start, mmio_len);
380err_out_free_pio:
381 release_region(pio_start, pio_len);
382err_out_mwi:
383 pci_clear_mwi(pdev);
384err_out_disable:
385 pci_disable_device(pdev);
386err_out:
387 free_netdev(dev);
388#if STREAMER_DEBUG
389 printk("lanstreamer: Exit error %x\n",rc);
390#endif
391 return rc;
392}
393
394static void __devexit streamer_remove_one(struct pci_dev *pdev)
395{
396 struct net_device *dev=pci_get_drvdata(pdev);
397 struct streamer_private *streamer_priv;
398
399#if STREAMER_DEBUG
400 printk("lanstreamer::streamer_remove_one entry pdev %p\n",pdev);
401#endif
402
403 if (dev == NULL) {
404 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev is NULL\n");
405 return;
406 }
407
408 streamer_priv=dev->priv;
409 if (streamer_priv == NULL) {
410 printk(KERN_ERR "lanstreamer::streamer_remove_one, ERROR dev->priv is NULL\n");
411 return;
412 }
413
414#if STREAMER_NETWORK_MONITOR
415#ifdef CONFIG_PROC_FS
416 {
417 struct streamer_private **p, **next;
418
419 for (p = &dev_streamer; *p; p = next) {
420 next = &(*p)->next;
421 if (*p == streamer_priv) {
422 *p = *next;
423 break;
424 }
425 }
426 if (!dev_streamer)
457c4cbc 427 remove_proc_entry("streamer_tr", init_net.proc_net);
1da177e4
LT		 428 }
429#endif
430#endif
431
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));
436 pci_clear_mwi(pdev);
437 pci_disable_device(pdev);
438 free_netdev(dev);
439 pci_set_drvdata(pdev, NULL);
440}
441
442
443static int streamer_reset(struct net_device *dev)
444{
445 struct streamer_private *streamer_priv;
446 __u8 __iomem *streamer_mmio;
447 unsigned long t;
448 unsigned int uaa_addr;
449 struct sk_buff *skb = NULL;
450 __u16 misr;
451
452 streamer_priv = (struct streamer_private *) dev->priv;
453 streamer_mmio = streamer_priv->streamer_mmio;
454
455 writew(readw(streamer_mmio + BCTL) | BCTL_SOFTRESET, streamer_mmio + BCTL);
456 t = jiffies;
457 /* Hold soft reset bit for a while */
4f2ad811 458 ssleep(1);
1da177e4
LT		 459
460 writew(readw(streamer_mmio + BCTL) & ~BCTL_SOFTRESET,
461 streamer_mmio + BCTL);
462
463#if STREAMER_DEBUG
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));
467#endif
468 writew(readw(streamer_mmio + BCTL) | (BCTL_RX_FIFO_8 | BCTL_TX_FIFO_8), streamer_mmio + BCTL );
469
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",
475 dev->name);
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",
479 dev->name);
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",
484 dev->name);
485 writew(0, streamer_mmio + GPR);
486 }
487
488 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
489 if (!skb) {
490 printk(KERN_INFO "%s: skb allocation for diagnostics failed...proceeding\n",
491 dev->name);
492 } else {
493 struct streamer_rx_desc *rx_ring;
494 u8 *data;
495
496 rx_ring=(struct streamer_rx_desc *)skb->data;
497 data=((u8 *)skb->data)+sizeof(struct streamer_rx_desc);
498 rx_ring->forward=0;
499 rx_ring->status=0;
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);
505 }
506
507#if STREAMER_DEBUG
508 printk("GPR = %x\n", readw(streamer_mmio + GPR));
509#endif
510 /* start solo init */
511 writew(SISR_MI, streamer_mmio + SISR_MASK_SUM);
512
513 while (!((readw(streamer_mmio + SISR)) & SISR_SRB_REPLY)) {
4f2ad811 514 msleep_interruptible(100);
ff5688ae 515 if (time_after(jiffies, t + 40 * HZ)) {
1da177e4
LT		 516 printk(KERN_ERR
517 "IBM PCI tokenring card not responding\n");
518 release_region(dev->base_addr, STREAMER_IO_SPACE);
519 if (skb)
520 dev_kfree_skb(skb);
521 return -1;
522 }
523 }
524 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
525 misr = readw(streamer_mmio + MISR_RUM);
526 writew(~misr, streamer_mmio + MISR_RUM);
527
528 if (skb)
529 dev_kfree_skb(skb); /* release skb used for diagnostics */
530
531#if STREAMER_DEBUG
532 printk("LAPWWO: %x, LAPA: %x LAPE: %x\n",
533 readw(streamer_mmio + LAPWWO), readw(streamer_mmio + LAPA),
534 readw(streamer_mmio + LAPE));
535#endif
536
537#if STREAMER_DEBUG
538 {
539 int i;
540 writew(readw(streamer_mmio + LAPWWO),
541 streamer_mmio + LAPA);
542 printk("initialization response srb dump: ");
543 for (i = 0; i < 10; i++)
544 printk("%x:",
545 ntohs(readw(streamer_mmio + LAPDINC)));
546 printk("\n");
547 }
548#endif
549
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);
555 return -1;
556 }
557
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));
563
564#if STREAMER_DEBUG
565 printk("UAA resides at %x\n", uaa_addr);
566#endif
567
568 /* setup uaa area for access with LAPD */
569 {
570 int i;
571 __u16 addr;
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;
577 }
578#if STREAMER_DEBUG
579 printk("Adapter address: ");
580 for (i = 0; i < 6; i++) {
581 printk("%02x:", dev->dev_addr[i]);
582 }
583 printk("\n");
584#endif
585 }
586 return 0;
587}
588
589static int streamer_open(struct net_device *dev)
590{
591 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
592 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
593 unsigned long flags;
594 char open_error[255];
595 int i, open_finished = 1;
596 __u16 srb_word;
597 __u16 srb_open;
598 int rc;
599
600 if (readw(streamer_mmio+BMCTL_SUM) & BMCTL_RX_ENABLED) {
601 rc=streamer_reset(dev);
602 }
603
1fb9df5d 604 if (request_irq(dev->irq, &streamer_interrupt, IRQF_SHARED, "lanstreamer", dev)) {
1da177e4
LT		 605 return -EAGAIN;
606 }
607#if STREAMER_DEBUG
608 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
609 printk("pending ints: %x\n", readw(streamer_mmio + SISR));
610#endif
611
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 */
614
615 /* adapter is closed, so SRB is pointed to by LAPWWO */
616 writew(readw(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
617
618#if STREAMER_DEBUG
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));
623#endif
624 do {
625 int i;
626
627 for (i = 0; i < SRB_COMMAND_SIZE; i += 2) {
628 writew(0, streamer_mmio + LAPDINC);
629 }
630
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);
635
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 */
640#else
641 writew(htons(OPEN_ADAPTER_ENABLE_FDX), streamer_mmio + LAPDINC); /* Offset 8 word contains Open.Options */
642#endif
643
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);
653 }
654
655 /* save off srb open offset */
656 srb_open = readw(streamer_mmio + LAPWWO);
657#if STREAMER_DEBUG
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)));
663 }
664 printk("\n");
665#endif
666 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
667 streamer_priv->srb_queued = 1;
668
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);
672
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;
682 break;
683 }
684 }
685
686#if STREAMER_DEBUG
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++) {
691 printk("%x:",
692 ntohs(readw(streamer_mmio + LAPDINC)));
693 }
694#endif
695
696 /* If we get the same return response as we set, the interrupt wasn't raised and the open
697 * timed out.
698 */
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",
703 dev->name);
704 return -EIO;
705 }
706
707 if (srb_word != 0) {
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",
711 dev->name);
712 open_finished = 0;
713 } else {
714 __u16 error_code;
715
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)]);
721
722 if (!streamer_priv->streamer_ring_speed
723 && ((error_code & 0x0f) == 0x0d))
724 {
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);
728 return -EIO;
729 }
730
731 printk(KERN_WARNING "%s: %s\n",
732 dev->name, open_error);
733 free_irq(dev->irq, dev);
734 return -EIO;
735
736 } /* if autosense && open_finished */
737 } else {
738 printk(KERN_WARNING "%s: Bad OPEN response: %x\n",
739 dev->name, srb_word);
740 free_irq(dev->irq, dev);
741 return -EIO;
742 }
743 } else
744 open_finished = 1;
745 } while (!(open_finished)); /* Will only loop if ring speed mismatch re-open attempted && autosense is on */
746
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);
752
753 if (srb_word & 1)
754 streamer_priv->streamer_ring_speed = 16;
755 else
756 streamer_priv->streamer_ring_speed = 4;
757
758 if (streamer_priv->streamer_message_level)
759 printk(KERN_INFO "%s: Opened in %d Mbps mode\n",
760 dev->name,
761 streamer_priv->streamer_ring_speed);
762
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));
769
770 streamer_priv->streamer_receive_options = 0x00;
771 streamer_priv->streamer_copy_all_options = 0;
772
773 /* setup rx ring */
774 /* enable rx channel */
775 writew(~BMCTL_RX_DIS, streamer_mmio + BMCTL_RUM);
776
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);
783 return -EIO;
784 }
785
786 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
787 struct sk_buff *skb;
788
789 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
790 if (skb == NULL)
791 break;
792
793 skb->dev = dev;
794
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;
804 }
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));
808
809 if (i == 0) {
810 printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n", dev->name);
811 free_irq(dev->irq, dev);
812 return -EIO;
813 }
814
815 streamer_priv->rx_ring_last_received = STREAMER_RX_RING_SIZE - 1; /* last processed rx status */
816
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);
823
824 /* set bus master interrupt event mask */
825 writew(MISR_RX_NOBUF | MISR_RX_EOF, streamer_mmio + MISR_MASK);
826
827
828 /* setup tx ring */
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);
833 return -EIO;
834 }
835
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),
841 PCI_DMA_TODEVICE));
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;
849 }
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));
853
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;
857
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);
862
863#if STREAMER_DEBUG
864 printk("BMCTL: %x\n", readw(streamer_mmio + BMCTL_SUM));
865 printk("SISR MASK: %x\n", readw(streamer_mmio + SISR_MASK));
866#endif
867
868#if STREAMER_NETWORK_MONITOR
869
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)));
880
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)));
887#endif
888
889 netif_start_queue(dev);
890 netif_carrier_on(dev);
891 return 0;
892}
893
894/*
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
898 * all the frames.
899 *
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.
903 *
904 */
905static void streamer_rx(struct net_device *dev)
906{
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;
913
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;
917
918 while (rx_desc->status & 0x01000000) { /* While processed descriptors are available */
919 if (rx_ring_last_received != streamer_priv->rx_ring_last_received)
920 {
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);
923 }
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;
926
927 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */
928 frame_length = (rx_desc->framelen_buflen >> 16) & 0xffff;
929
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);
934 }
935 } else { /* received without errors */
936 if (rx_desc->status & 0x80000000) { /* frame complete */
937 buffer_cnt = 1;
938 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
939 } else {
940 skb = dev_alloc_skb(frame_length);
941 }
942
943 if (skb == NULL)
944 {
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 */
1da177e4
LT		 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,
953 PCI_DMA_FROMDEVICE);
954 skb2 = streamer_priv->rx_ring_skb[rx_ring_last_received];
955#if STREAMER_DEBUG_PACKETS
956 {
957 int i;
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++)
960 {
961 printk("%x:", skb2->data[i]);
962 if (((i + 1) % 16) == 0)
963 printk("\n");
964 }
965 printk("\n");
966 }
967#endif
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 */
983 netif_rx(skb2);
984 } else {
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;
990
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);
996
997 if (rx_desc->status & 0x80000000)
998 break; /* this descriptor completes the frame */
999
1000 /* else get the next pending descriptor */
1001 if (rx_ring_last_received!= streamer_priv->rx_ring_last_received)
1002 {
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);
1006 }
1007 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE-1)];
1008
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;
1012 } while (1);
1013
1014 skb->protocol = tr_type_trans(skb, dev);
1015 /* send up to the protocol */
1016 netif_rx(skb);
1017 }
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 */
1023
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 */
1027}
1028
7d12e780 1029static irqreturn_t streamer_interrupt(int irq, void *dev_id)
1da177e4
LT		 1030{
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;
1035 __u16 sisr;
1036 __u16 misr;
1037 u8 max_intr = MAX_INTR;
1038
1039 spin_lock(&streamer_priv->streamer_lock);
1040 sisr = readw(streamer_mmio + SISR);
1041
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)) {
1045
1046 if(sisr & SISR_PAR_ERR) {
1047 writew(~SISR_PAR_ERR, streamer_mmio + SISR_RUM);
1048 (void)readw(streamer_mmio + SISR_RUM);
1049 }
1050
1051 else if(sisr & SISR_SERR_ERR) {
1052 writew(~SISR_SERR_ERR, streamer_mmio + SISR_RUM);
1053 (void)readw(streamer_mmio + SISR_RUM);
1054 }
1055
1056 else if(sisr & SISR_MI) {
1057 misr = readw(streamer_mmio + MISR_RUM);
1058
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;
1073 }
1074 netif_wake_queue(dev);
1075 }
1076
1077 if (misr & MISR_RX_EOF) {
1078 streamer_rx(dev);
1079 }
1080 /* MISR_RX_EOF */
1081
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.
1085 */
1086 } /* SISR_RX_NOBUF */
1087
1088 writew(~misr, streamer_mmio + MISR_RUM);
1089 (void)readw(streamer_mmio + MISR_RUM);
1090 }
1091
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);
1097 }
1098 streamer_priv->srb_queued = 0;
1099
1100 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
1101 (void)readw(streamer_mmio + SISR_RUM);
1102 }
1103
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);
1115 }
1116
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);
1122 }
1123 writew(~SISR_ASB_FREE, streamer_mmio + SISR_RUM);
1124 (void)readw(streamer_mmio + SISR_RUM);
1125 }
1126 /* SISR_ASB_FREE */
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);
1131 }
1132 /* SISR_ARB_CMD */
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->
1137 trb_wait);
1138 }
1139 streamer_priv->trb_queued = 0;
1140 writew(~SISR_TRB_REPLY, streamer_mmio + SISR_RUM);
1141 (void)readw(streamer_mmio + SISR_RUM);
1142 }
1143 /* SISR_TRB_REPLY */
1144
1145 sisr = readw(streamer_mmio + SISR);
1146 max_intr--;
1147 } /* while() */
1148
1149 spin_unlock(&streamer_priv->streamer_lock) ;
1150 return IRQ_HANDLED;
1151}
1152
1153static int streamer_xmit(struct sk_buff *skb, struct net_device *dev)
1154{
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 ;
1159
1160 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1161
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;
1171
1172 streamer_priv->tx_ring_skb[streamer_priv->tx_ring_free] = skb;
1173 streamer_priv->free_tx_ring_entries--;
1174#if STREAMER_DEBUG_PACKETS
1175 {
1176 int i;
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)
1181 printk("\n");
1182 }
1183 printk("\n");
1184 }
1185#endif
1186
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);
1192
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);
1195 return 0;
1196 } else {
1197 netif_stop_queue(dev);
1198 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1199 return 1;
1200 }
1201}
1202
1203
1204static int streamer_close(struct net_device *dev)
1205{
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;
1210 int i;
1211
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);
1217
1218 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1219
1220 streamer_priv->srb_queued = 1;
1221 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1222
1223 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
1224
1225 while (streamer_priv->srb_queued)
1226 {
1227 interruptible_sleep_on_timeout(&streamer_priv->srb_wait,
1228 jiffies + 60 * HZ);
1229 if (signal_pending(current))
1230 {
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;
1237 break;
1238 }
1239 }
1240
1241 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1242
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]);
1246 }
1247 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1248 }
1249
1250 /* reset tx/rx fifo's and busmaster logic */
1251
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);
1254 udelay(1);
1255 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL);
1256 */
1257
1258#if STREAMER_DEBUG
1259 writew(streamer_priv->srb, streamer_mmio + LAPA);
1260 printk("srb): ");
1261 for (i = 0; i < 2; i++) {
1262 printk("%x ", ntohs(readw(streamer_mmio + LAPDINC)));
1263 }
1264 printk("\n");
1265#endif
1266 free_irq(dev->irq, dev);
1267 return 0;
1268}
1269
1270static void streamer_set_rx_mode(struct net_device *dev)
1271{
1272 struct streamer_private *streamer_priv =
1273 (struct streamer_private *) dev->priv;
1274 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1275 __u8 options = 0;
1276 struct dev_mc_list *dmi;
1277 unsigned char dev_mc_address[5];
1278 int i;
1279
1280 writel(streamer_priv->srb, streamer_mmio + LAPA);
1281 options = streamer_priv->streamer_copy_all_options;
1282
1283 if (dev->flags & IFF_PROMISC)
1284 options |= (3 << 5); /* All LLC and MAC frames, all through the main rx channel */
1285 else
1286 options &= ~(3 << 5);
1287
1288 /* Only issue the srb if there is a change in options */
1289
1290 if ((options ^ streamer_priv->streamer_copy_all_options))
1291 {
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);
1300
1301 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1302
1303 writel(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1304
1305 streamer_priv->streamer_copy_all_options = options;
1306 return;
1307 }
1308
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 ;
1312
1313 for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next)
1314 {
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] ;
1319 }
1320
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);
1328}
1329
1330static void streamer_srb_bh(struct net_device *dev)
1331{
1332 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
1333 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1334 __u16 srb_word;
1335
1336 writew(streamer_priv->srb, streamer_mmio + LAPA);
1337 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1338
1339 switch (srb_word) {
1340
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
1344 */
1345
1346 case SRB_MODIFY_RECEIVE_OPTIONS:
1347 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1348
1349 switch (srb_word) {
1350 case 0x01:
1351 printk(KERN_WARNING "%s: Unrecognized srb command\n", dev->name);
1352 break;
1353 case 0x04:
1354 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1355 break;
1356 default:
1357 if (streamer_priv->streamer_message_level)
1358 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",
1359 dev->name,
1360 streamer_priv->streamer_copy_all_options,
1361 streamer_priv->streamer_receive_options);
1362 break;
1363 } /* switch srb[2] */
1364 break;
1365
1366
1367 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1368 */
1369 case SRB_SET_GROUP_ADDRESS:
1370 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1371 switch (srb_word) {
1372 case 0x00:
1373 break;
1374 case 0x01:
1375 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name);
1376 break;
1377 case 0x04:
1378 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1379 break;
1380 case 0x3c:
1381 printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n", dev->name);
1382 break;
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);
1385 break;
1386 case 0x55:
1387 printk(KERN_INFO "%s: Group Address already set.\n", dev->name);
1388 break;
1389 default:
1390 break;
1391 } /* switch srb[2] */
1392 break;
1393
1394
1395 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1396 */
1397 case SRB_RESET_GROUP_ADDRESS:
1398 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1399 switch (srb_word) {
1400 case 0x00:
1401 break;
1402 case 0x01:
1403 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1404 break;
1405 case 0x04:
1406 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1407 break;
1408 case 0x39: /* Must deal with this if individual multicast addresses used */
1409 printk(KERN_INFO "%s: Group address not found \n", dev->name);
1410 break;
1411 default:
1412 break;
1413 } /* switch srb[2] */
1414 break;
1415
1416
1417 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1418 */
1419
1420 case SRB_SET_FUNC_ADDRESS:
1421 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1422 switch (srb_word) {
1423 case 0x00:
1424 if (streamer_priv->streamer_message_level)
1425 printk(KERN_INFO "%s: Functional Address Mask Set \n", dev->name);
1426 break;
1427 case 0x01:
1428 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1429 break;
1430 case 0x04:
1431 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1432 break;
1433 default:
1434 break;
1435 } /* switch srb[2] */
1436 break;
1437
1438 /* SRB_READ_LOG - Read and reset the adapter error counters
1439 */
1440
1441 case SRB_READ_LOG:
1442 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1443 switch (srb_word) {
1444 case 0x00:
1445 {
1446 int i;
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)));
1454 }
1455 printk("\n");
1456 }
1457 break;
1458 case 0x01:
1459 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1460 break;
1461 case 0x04:
1462 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1463 break;
1464
1465 } /* switch srb[2] */
1466 break;
1467
1468 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1469
1470 case SRB_READ_SR_COUNTERS:
1471 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1472 switch (srb_word) {
1473 case 0x00:
1474 if (streamer_priv->streamer_message_level)
1475 printk(KERN_INFO "%s: Read Source Routing Counters issued\n", dev->name);
1476 break;
1477 case 0x01:
1478 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1479 break;
1480 case 0x04:
1481 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1482 break;
1483 default:
1484 break;
1485 } /* switch srb[2] */
1486 break;
1487
1488 default:
1489 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n", dev->name);
1490 break;
1491 } /* switch srb[0] */
1492}
1493
1494static struct net_device_stats *streamer_get_stats(struct net_device *dev)
1495{
1496 struct streamer_private *streamer_priv;
1497 streamer_priv = (struct streamer_private *) dev->priv;
1498 return (struct net_device_stats *) &streamer_priv->streamer_stats;
1499}
1500
1501static int streamer_set_mac_address(struct net_device *dev, void *addr)
1502{
1503 struct sockaddr *saddr = addr;
1504 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
1505
1506 if (netif_running(dev))
1507 {
1508 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name);
1509 return -EIO;
1510 }
1511
1512 memcpy(streamer_priv->streamer_laa, saddr->sa_data, dev->addr_len);
1513
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]);
1522 }
1523 return 0;
1524}
1525
1526static void streamer_arb_cmd(struct net_device *dev)
1527{
1528 struct streamer_private *streamer_priv =
1529 (struct streamer_private *) dev->priv;
1530 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1531 __u8 header_len;
1532 __u16 frame_len, buffer_len;
1533 struct sk_buff *mac_frame;
1534 __u8 frame_data[256];
1535 __u16 buff_off;
1536 __u16 lan_status = 0, lan_status_diff; /* Initialize to stop compiler warning */
1537 __u8 fdx_prot_error;
1538 __u16 next_ptr;
1539 __u16 arb_word;
1540
1541#if STREAMER_NETWORK_MONITOR
1542 struct trh_hdr *mac_hdr;
1543#endif
1544
1545 writew(streamer_priv->arb, streamer_mmio + LAPA);
1546 arb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1547
1548 if (arb_word == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
1549 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1550 streamer_priv->mac_rx_buffer = buff_off = ntohs(readw(streamer_mmio + LAPDINC));
1551 header_len=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; /* 802.5 Token-Ring Header Length */
1552 frame_len = ntohs(readw(streamer_mmio + LAPDINC));
1553
1554#if STREAMER_DEBUG
1555 {
1556 int i;
1557 __u16 next;
1558 __u8 status;
1559 __u16 len;
1560
1561 writew(ntohs(buff_off), streamer_mmio + LAPA); /*setup window to frame data */
1562 next = htons(readw(streamer_mmio + LAPDINC));
1563 status =
1564 ntohs(readw(streamer_mmio + LAPDINC)) & 0xff;
1565 len = ntohs(readw(streamer_mmio + LAPDINC));
1566
1567 /* print out 1st 14 bytes of frame data */
1568 for (i = 0; i < 7; i++) {
1569 printk("Loc %d = %04x\n", i,
1570 ntohs(readw
1571 (streamer_mmio + LAPDINC)));
1572 }
1573
1574 printk("next %04x, fs %02x, len %04x \n", next,
1575 status, len);
1576 }
1577#endif
1578 if (!(mac_frame = dev_alloc_skb(frame_len))) {
1579 printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n",
1580 dev->name);
1581 goto drop_frame;
1582 }
1583 /* Walk the buffer chain, creating the frame */
1584
1585 do {
1586 int i;
1587 __u16 rx_word;
1588
1589 writew(htons(buff_off), streamer_mmio + LAPA); /* setup window to frame data */
1590 next_ptr = ntohs(readw(streamer_mmio + LAPDINC));
1591 readw(streamer_mmio + LAPDINC); /* read thru status word */
1592 buffer_len = ntohs(readw(streamer_mmio + LAPDINC));
1593
1594 if (buffer_len > 256)
1595 break;
1596
1597 i = 0;
1598 while (i < buffer_len) {
1599 rx_word=ntohs(readw(streamer_mmio+LAPDINC));
1600 frame_data[i]=rx_word >> 8;
1601 frame_data[i+1]=rx_word & 0xff;
1602 i += 2;
1603 }
1604
1605 memcpy(skb_put(mac_frame, buffer_len),
1606 frame_data, buffer_len);
1607 } while (next_ptr && (buff_off = next_ptr));
1608
c1a4b86e 1609 mac_frame->protocol = tr_type_trans(mac_frame, dev);
1da177e4
LT		 1610#if STREAMER_NETWORK_MONITOR
1611 printk(KERN_WARNING "%s: Received MAC Frame, details: \n",
1612 dev->name);
c1a4b86e 1613 mac_hdr = tr_hdr(mac_frame);
1da177e4
LT		 1614 printk(KERN_WARNING
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]);
1619 printk(KERN_WARNING
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]);
1624#endif
1da177e4
LT		 1625 netif_rx(mac_frame);
1626
1627 /* Now tell the card we have dealt with the received frame */
1628drop_frame:
1629 /* Set LISR Bit 1 */
1630 writel(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1631
1632 /* Is the ASB free ? */
1633
1634 if (!(readl(streamer_priv->streamer_mmio + SISR) & SISR_ASB_FREE))
1635 {
1636 streamer_priv->asb_queued = 1;
1637 writel(LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1638 return;
1639 /* Drop out and wait for the bottom half to be run */
1640 }
1641
1642
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);
1648
1649 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1650
1651 streamer_priv->asb_queued = 2;
1652 return;
1653
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;
1658
1659 /* Issue ARB Free */
1660 writew(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1661
1662 lan_status_diff = (streamer_priv->streamer_lan_status ^ lan_status) &
1663 lan_status;
1664
1665 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR))
1666 {
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);
1675
1676 /* Adapter has been closed by the hardware */
1677
1678 /* reset tx/rx fifo's and busmaster logic */
1679
1680 /* @TBD. no llc reset on autostreamer writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1681 udelay(1);
1682 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); */
1683
1684 netif_stop_queue(dev);
1685 netif_carrier_off(dev);
1686 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1687 }
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);
1704 }
1705
1706 if (lan_status_diff & LSC_CO) {
1707 if (streamer_priv->streamer_message_level)
1708 printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1709
1710 /* Issue READ.LOG command */
1711
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 */
1717
1718 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1719 }
1720
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);
1724
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);
1733
1734 }
1735 streamer_priv->streamer_lan_status = lan_status;
1736 } /* Lan.change.status */
1737 else
1738 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1739}
1740
1741static void streamer_asb_bh(struct net_device *dev)
1742{
1743 struct streamer_private *streamer_priv =
1744 (struct streamer_private *) dev->priv;
1745 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1746
1747 if (streamer_priv->asb_queued == 1)
1748 {
1749 /* Dropped through the first time */
1750
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);
1756
1757 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1758 streamer_priv->asb_queued = 2;
1759
1760 return;
1761 }
1762
1763 if (streamer_priv->asb_queued == 2) {
1764 __u8 rc;
1765 writew(streamer_priv->asb + 2, streamer_mmio + LAPA);
1766 rc=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1767 switch (rc) {
1768 case 0x01:
1769 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1770 break;
1771 case 0x26:
1772 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1773 break;
1774 case 0xFF:
1775 /* Valid response, everything should be ok again */
1776 break;
1777 default:
1778 printk(KERN_WARNING "%s: Invalid return code in asb\n", dev->name);
1779 break;
1780 }
1781 }
1782 streamer_priv->asb_queued = 0;
1783}
1784
1785static int streamer_change_mtu(struct net_device *dev, int mtu)
1786{
1787 struct streamer_private *streamer_priv =
1788 (struct streamer_private *) dev->priv;
1789 __u16 max_mtu;
1790
1791 if (streamer_priv->streamer_ring_speed == 4)
1792 max_mtu = 4500;
1793 else
1794 max_mtu = 18000;
1795
1796 if (mtu > max_mtu)
1797 return -EINVAL;
1798 if (mtu < 100)
1799 return -EINVAL;
1800
1801 dev->mtu = mtu;
1802 streamer_priv->pkt_buf_sz = mtu + TR_HLEN;
1803
1804 return 0;
1805}
1806
1807#if STREAMER_NETWORK_MONITOR
1808#ifdef CONFIG_PROC_FS
1809static int streamer_proc_info(char *buffer, char **start, off_t offset,
1810 int length, int *eof, void *data)
1811{
1812 struct streamer_private *sdev=NULL;
1813 struct pci_dev *pci_device = NULL;
1814 int len = 0;
1815 off_t begin = 0;
1816 off_t pos = 0;
1817 int size;
1818
1819 struct net_device *dev;
1820
1821 size = sprintf(buffer, "IBM LanStreamer/MPC Chipset Token Ring Adapters\n");
1822
1823 pos += size;
1824 len += size;
1825
1826 for(sdev=dev_streamer; sdev; sdev=sdev->next) {
1827 pci_device=sdev->pci_dev;
1828 dev=pci_get_drvdata(pci_device);
1829
1830 size = sprintf_info(buffer + len, dev);
1831 len += size;
1832 pos = begin + len;
1833
1834 if (pos < offset) {
1835 len = 0;
1836 begin = pos;
1837 }
1838 if (pos > offset + length)
1839 break;
1840 } /* for */
1841
1842 *start = buffer + (offset - begin); /* Start of wanted data */
1843 len -= (offset - begin); /* Start slop */
1844 if (len > length)
1845 len = length; /* Ending slop */
1846 return len;
1847}
1848
1849static int sprintf_info(char *buffer, struct net_device *dev)
1850{
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;
1856 int size = 0;
1857 int i;
1858
1859 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
1860 for (i = 0; i < 14; i += 2) {
1861 __u16 io_word;
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;
1866 }
1867 writew(streamer_priv->streamer_parms_addr, streamer_mmio + LAPA);
1868 for (i = 0; i < 68; i += 2) {
1869 __u16 io_word;
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;
1874 }
1875
1da177e4
LT		 1876 size = sprintf(buffer, "\n%6s: Adapter Address : Node Address : Functional Addr\n", dev->name);
1877
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]);
1886
1887 size += sprintf(buffer + size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1888
1889 size += sprintf(buffer + size, "%6s: Physical Addr : Up Node Address : Poll Address : AccPri : Auth Src : Att Code :\n", dev->name);
1890
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));
1902
1903 size += sprintf(buffer + size, "%6s: Source Address : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n", dev->name);
1904
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));
1913
1914 size += sprintf(buffer + size, "%6s: Beacon Details : Tx : Rx : NAUN Node Address : NAUN Node Phys : \n",
1915 dev->name);
1916
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]);
1926 return size;
1927}
1928#endif
1929#endif
1930
1da177e4
LT		 1931static 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),
1936};
1937
1938static int __init streamer_init_module(void) {
29917620 1939 return pci_register_driver(&streamer_pci_driver);
1da177e4
LT		 1940}
1941
1942static void __exit streamer_cleanup_module(void) {
1943 pci_unregister_driver(&streamer_pci_driver);
1944}
1945
1946module_init(streamer_init_module);
1947module_exit(streamer_cleanup_module);
1948MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror