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