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