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