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