?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
[linux-2.6/cjktty.git] / drivers / net / tokenring / lanstreamer.c
blobe999feb8c0bbe15777955415691a838d6e0978c8
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/checksum.h>
127
128 #include <asm/io.h>
129 #include <asm/system.h>
130
131 #include "lanstreamer.h"
132
133 #if (BITS_PER_LONG == 64)
134 #error broken on 64-bit: stores pointer to rx_ring->buffer in 32-bit int
135 #endif
136
137
138 /* I've got to put some intelligence into the version number so that Peter and I know
139 * which version of the code somebody has got.
140 * Version Number = a.b.c.d where a.b.c is the level of code and d is the latest author.
141 * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike
142 *
143 * Official releases will only have an a.b.c version number format.
144 */
145
146 static char version[] = "LanStreamer.c v0.4.0 03/08/01 - Mike Sullivan\n"
147 " v0.5.3 11/13/02 - Kent Yoder";
148
149 static struct pci_device_id streamer_pci_tbl[] = {
150 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_TR, PCI_ANY_ID, PCI_ANY_ID,},
151 {} /* terminating entry */
152 };
153 MODULE_DEVICE_TABLE(pci,streamer_pci_tbl);
154
155
156 static char *open_maj_error[] = {
157 "No error", "Lobe Media Test", "Physical Insertion",
158 "Address Verification", "Neighbor Notification (Ring Poll)",
159 "Request Parameters", "FDX Registration Request",
160 "FDX Lobe Media Test", "FDX Duplicate Address Check",
161 "Unknown stage"
162 };
163
164 static char *open_min_error[] = {
165 "No error", "Function Failure", "Signal Lost", "Wire Fault",
166 "Ring Speed Mismatch", "Timeout", "Ring Failure", "Ring Beaconing",
167 "Duplicate Node Address", "Request Parameters", "Remove Received",
168 "Reserved", "Reserved", "No Monitor Detected for RPL",
169 "Monitor Contention failer for RPL", "FDX Protocol Error"
170 };
171
172 /* Module paramters */
173
174 /* Ring Speed 0,4,16
175 * 0 = Autosense
176 * 4,16 = Selected speed only, no autosense
177 * This allows the card to be the first on the ring
178 * and become the active monitor.
179 *
180 * WARNING: Some hubs will allow you to insert
181 * at the wrong speed
182 */
183
184 static int ringspeed[STREAMER_MAX_ADAPTERS] = { 0, };
185
186 module_param_array(ringspeed, int, NULL, 0);
187
188 /* Packet buffer size */
189
190 static int pkt_buf_sz[STREAMER_MAX_ADAPTERS] = { 0, };
191
192 module_param_array(pkt_buf_sz, int, NULL, 0);
193
194 /* Message Level */
195
196 static int message_level[STREAMER_MAX_ADAPTERS] = { 1, };
197
198 module_param_array(message_level, int, NULL, 0);
199
200 #if STREAMER_IOCTL
201 static int streamer_ioctl(struct net_device *, struct ifreq *, int);
202 #endif
203
204 static int streamer_reset(struct net_device *dev);
205 static int streamer_open(struct net_device *dev);
206 static int streamer_xmit(struct sk_buff *skb, struct net_device *dev);
207 static int streamer_close(struct net_device *dev);
208 static void streamer_set_rx_mode(struct net_device *dev);
209 static irqreturn_t streamer_interrupt(int irq, void *dev_id);
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, 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=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 ssleep(1);
458
459 writew(readw(streamer_mmio + BCTL) & ~BCTL_SOFTRESET,
460 streamer_mmio + BCTL);
461
462 #if STREAMER_DEBUG
463 printk("BCTL: %x\n", readw(streamer_mmio + BCTL));
464 printk("GPR: %x\n", readw(streamer_mmio + GPR));
465 printk("SISRMASK: %x\n", readw(streamer_mmio + SISR_MASK));
466 #endif
467 writew(readw(streamer_mmio + BCTL) | (BCTL_RX_FIFO_8 | BCTL_TX_FIFO_8), streamer_mmio + BCTL );
468
469 if (streamer_priv->streamer_ring_speed == 0) { /* Autosense */
470 writew(readw(streamer_mmio + GPR) | GPR_AUTOSENSE,
471 streamer_mmio + GPR);
472 if (streamer_priv->streamer_message_level)
473 printk(KERN_INFO "%s: Ringspeed autosense mode on\n",
474 dev->name);
475 } else if (streamer_priv->streamer_ring_speed == 16) {
476 if (streamer_priv->streamer_message_level)
477 printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n",
478 dev->name);
479 writew(GPR_16MBPS, streamer_mmio + GPR);
480 } else if (streamer_priv->streamer_ring_speed == 4) {
481 if (streamer_priv->streamer_message_level)
482 printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n",
483 dev->name);
484 writew(0, streamer_mmio + GPR);
485 }
486
487 skb = dev_alloc_skb(streamer_priv->pkt_buf_sz);
488 if (!skb) {
489 printk(KERN_INFO "%s: skb allocation for diagnostics failed...proceeding\n",
490 dev->name);
491 } else {
492 struct streamer_rx_desc *rx_ring;
493 u8 *data;
494
495 rx_ring=(struct streamer_rx_desc *)skb->data;
496 data=((u8 *)skb->data)+sizeof(struct streamer_rx_desc);
497 rx_ring->forward=0;
498 rx_ring->status=0;
499 rx_ring->buffer=cpu_to_le32(pci_map_single(streamer_priv->pci_dev, data,
500 512, PCI_DMA_FROMDEVICE));
501 rx_ring->framelen_buflen=512;
502 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev, rx_ring, 512, PCI_DMA_FROMDEVICE)),
503 streamer_mmio+RXBDA);
504 }
505
506 #if STREAMER_DEBUG
507 printk("GPR = %x\n", readw(streamer_mmio + GPR));
508 #endif
509 /* start solo init */
510 writew(SISR_MI, streamer_mmio + SISR_MASK_SUM);
511
512 while (!((readw(streamer_mmio + SISR)) & SISR_SRB_REPLY)) {
513 msleep_interruptible(100);
514 if (time_after(jiffies, t + 40 * HZ)) {
515 printk(KERN_ERR
516 "IBM PCI tokenring card not responding\n");
517 release_region(dev->base_addr, STREAMER_IO_SPACE);
518 if (skb)
519 dev_kfree_skb(skb);
520 return -1;
521 }
522 }
523 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
524 misr = readw(streamer_mmio + MISR_RUM);
525 writew(~misr, streamer_mmio + MISR_RUM);
526
527 if (skb)
528 dev_kfree_skb(skb); /* release skb used for diagnostics */
529
530 #if STREAMER_DEBUG
531 printk("LAPWWO: %x, LAPA: %x LAPE: %x\n",
532 readw(streamer_mmio + LAPWWO), readw(streamer_mmio + LAPA),
533 readw(streamer_mmio + LAPE));
534 #endif
535
536 #if STREAMER_DEBUG
537 {
538 int i;
539 writew(readw(streamer_mmio + LAPWWO),
540 streamer_mmio + LAPA);
541 printk("initialization response srb dump: ");
542 for (i = 0; i < 10; i++)
543 printk("%x:",
544 ntohs(readw(streamer_mmio + LAPDINC)));
545 printk("\n");
546 }
547 #endif
548
549 writew(readw(streamer_mmio + LAPWWO) + 6, streamer_mmio + LAPA);
550 if (readw(streamer_mmio + LAPD)) {
551 printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",
552 ntohs(readw(streamer_mmio + LAPD)));
553 release_region(dev->base_addr, STREAMER_IO_SPACE);
554 return -1;
555 }
556
557 writew(readw(streamer_mmio + LAPWWO) + 8, streamer_mmio + LAPA);
558 uaa_addr = ntohs(readw(streamer_mmio + LAPDINC));
559 readw(streamer_mmio + LAPDINC); /* skip over Level.Addr field */
560 streamer_priv->streamer_addr_table_addr = ntohs(readw(streamer_mmio + LAPDINC));
561 streamer_priv->streamer_parms_addr = ntohs(readw(streamer_mmio + LAPDINC));
562
563 #if STREAMER_DEBUG
564 printk("UAA resides at %x\n", uaa_addr);
565 #endif
566
567 /* setup uaa area for access with LAPD */
568 {
569 int i;
570 __u16 addr;
571 writew(uaa_addr, streamer_mmio + LAPA);
572 for (i = 0; i < 6; i += 2) {
573 addr=ntohs(readw(streamer_mmio+LAPDINC));
574 dev->dev_addr[i]= (addr >> 8) & 0xff;
575 dev->dev_addr[i+1]= addr & 0xff;
576 }
577 #if STREAMER_DEBUG
578 printk("Adapter address: ");
579 for (i = 0; i < 6; i++) {
580 printk("%02x:", dev->dev_addr[i]);
581 }
582 printk("\n");
583 #endif
584 }
585 return 0;
586 }
587
588 static int streamer_open(struct net_device *dev)
589 {
590 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
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 (struct streamer_private *) dev->priv;
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 skb->dev = dev;
948
949 if (buffer_cnt == 1) {
950 /* release the DMA mapping */
951 pci_unmap_single(streamer_priv->pci_dev,
952 le32_to_cpu(streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer),
953 streamer_priv->pkt_buf_sz,
954 PCI_DMA_FROMDEVICE);
955 skb2 = streamer_priv->rx_ring_skb[rx_ring_last_received];
956 #if STREAMER_DEBUG_PACKETS
957 {
958 int i;
959 printk("streamer_rx packet print: skb->data2 %p skb->head %p\n", skb2->data, skb2->head);
960 for (i = 0; i < frame_length; i++)
961 {
962 printk("%x:", skb2->data[i]);
963 if (((i + 1) % 16) == 0)
964 printk("\n");
965 }
966 printk("\n");
967 }
968 #endif
969 skb_put(skb2, length);
970 skb2->protocol = tr_type_trans(skb2, dev);
971 /* recycle this descriptor */
972 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0;
973 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz;
974 streamer_priv->streamer_rx_ring[rx_ring_last_received].buffer =
975 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, streamer_priv->pkt_buf_sz,
976 PCI_DMA_FROMDEVICE));
977 streamer_priv->rx_ring_skb[rx_ring_last_received] = skb;
978 /* place recycled descriptor back on the adapter */
979 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
980 &streamer_priv->streamer_rx_ring[rx_ring_last_received],
981 sizeof(struct streamer_rx_desc), PCI_DMA_FROMDEVICE)),
982 streamer_mmio + RXLBDA);
983 /* pass the received skb up to the protocol */
984 netif_rx(skb2);
985 } else {
986 do { /* Walk the buffers */
987 pci_unmap_single(streamer_priv->pci_dev, le32_to_cpu(rx_desc->buffer), length, PCI_DMA_FROMDEVICE),
988 memcpy(skb_put(skb, length), (void *)rx_desc->buffer, length); /* copy this fragment */
989 streamer_priv->streamer_rx_ring[rx_ring_last_received].status = 0;
990 streamer_priv->streamer_rx_ring[rx_ring_last_received].framelen_buflen = streamer_priv->pkt_buf_sz;
991
992 /* give descriptor back to the adapter */
993 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
994 &streamer_priv->streamer_rx_ring[rx_ring_last_received],
995 length, PCI_DMA_FROMDEVICE)),
996 streamer_mmio + RXLBDA);
997
998 if (rx_desc->status & 0x80000000)
999 break; /* this descriptor completes the frame */
1000
1001 /* else get the next pending descriptor */
1002 if (rx_ring_last_received!= streamer_priv->rx_ring_last_received)
1003 {
1004 printk("RX Error rx_ring_last_received not the same %x %x\n",
1005 rx_ring_last_received,
1006 streamer_priv->rx_ring_last_received);
1007 }
1008 rx_desc = &streamer_priv->streamer_rx_ring[(streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE-1)];
1009
1010 length = rx_desc->framelen_buflen & 0xffff; /* buffer length */
1011 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received+1) & (STREAMER_RX_RING_SIZE - 1);
1012 rx_ring_last_received = streamer_priv->rx_ring_last_received;
1013 } while (1);
1014
1015 skb->protocol = tr_type_trans(skb, dev);
1016 /* send up to the protocol */
1017 netif_rx(skb);
1018 }
1019 dev->last_rx = jiffies;
1020 streamer_priv->streamer_stats.rx_packets++;
1021 streamer_priv->streamer_stats.rx_bytes += length;
1022 } /* if skb == null */
1023 } /* end received without errors */
1024
1025 /* try the next one */
1026 rx_desc = &streamer_priv->streamer_rx_ring[(rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1)];
1027 } /* end for all completed rx descriptors */
1028 }
1029
1030 static irqreturn_t streamer_interrupt(int irq, void *dev_id)
1031 {
1032 struct net_device *dev = (struct net_device *) dev_id;
1033 struct streamer_private *streamer_priv =
1034 (struct streamer_private *) dev->priv;
1035 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1036 __u16 sisr;
1037 __u16 misr;
1038 u8 max_intr = MAX_INTR;
1039
1040 spin_lock(&streamer_priv->streamer_lock);
1041 sisr = readw(streamer_mmio + SISR);
1042
1043 while((sisr & (SISR_MI | SISR_SRB_REPLY | SISR_ADAPTER_CHECK | SISR_ASB_FREE |
1044 SISR_ARB_CMD | SISR_TRB_REPLY | SISR_PAR_ERR | SISR_SERR_ERR))
1045 && (max_intr > 0)) {
1046
1047 if(sisr & SISR_PAR_ERR) {
1048 writew(~SISR_PAR_ERR, streamer_mmio + SISR_RUM);
1049 (void)readw(streamer_mmio + SISR_RUM);
1050 }
1051
1052 else if(sisr & SISR_SERR_ERR) {
1053 writew(~SISR_SERR_ERR, streamer_mmio + SISR_RUM);
1054 (void)readw(streamer_mmio + SISR_RUM);
1055 }
1056
1057 else if(sisr & SISR_MI) {
1058 misr = readw(streamer_mmio + MISR_RUM);
1059
1060 if (misr & MISR_TX2_EOF) {
1061 while(streamer_priv->streamer_tx_ring[(streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1)].status) {
1062 streamer_priv->tx_ring_last_status = (streamer_priv->tx_ring_last_status + 1) & (STREAMER_TX_RING_SIZE - 1);
1063 streamer_priv->free_tx_ring_entries++;
1064 streamer_priv->streamer_stats.tx_bytes += streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]->len;
1065 streamer_priv->streamer_stats.tx_packets++;
1066 dev_kfree_skb_irq(streamer_priv->tx_ring_skb[streamer_priv->tx_ring_last_status]);
1067 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buffer = 0xdeadbeef;
1068 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].status = 0;
1069 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].bufcnt_framelen = 0;
1070 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].buflen = 0;
1071 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd1 = 0;
1072 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd2 = 0;
1073 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_last_status].rsvd3 = 0;
1074 }
1075 netif_wake_queue(dev);
1076 }
1077
1078 if (misr & MISR_RX_EOF) {
1079 streamer_rx(dev);
1080 }
1081 /* MISR_RX_EOF */
1082
1083 if (misr & MISR_RX_NOBUF) {
1084 /* According to the documentation, we don't have to do anything,
1085 * but trapping it keeps it out of /var/log/messages.
1086 */
1087 } /* SISR_RX_NOBUF */
1088
1089 writew(~misr, streamer_mmio + MISR_RUM);
1090 (void)readw(streamer_mmio + MISR_RUM);
1091 }
1092
1093 else if (sisr & SISR_SRB_REPLY) {
1094 if (streamer_priv->srb_queued == 1) {
1095 wake_up_interruptible(&streamer_priv->srb_wait);
1096 } else if (streamer_priv->srb_queued == 2) {
1097 streamer_srb_bh(dev);
1098 }
1099 streamer_priv->srb_queued = 0;
1100
1101 writew(~SISR_SRB_REPLY, streamer_mmio + SISR_RUM);
1102 (void)readw(streamer_mmio + SISR_RUM);
1103 }
1104
1105 else if (sisr & SISR_ADAPTER_CHECK) {
1106 printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name);
1107 writel(readl(streamer_mmio + LAPWWO), streamer_mmio + LAPA);
1108 printk(KERN_WARNING "%s: Words %x:%x:%x:%x:\n",
1109 dev->name, readw(streamer_mmio + LAPDINC),
1110 ntohs(readw(streamer_mmio + LAPDINC)),
1111 ntohs(readw(streamer_mmio + LAPDINC)),
1112 ntohs(readw(streamer_mmio + LAPDINC)));
1113 netif_stop_queue(dev);
1114 netif_carrier_off(dev);
1115 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1116 }
1117
1118 /* SISR_ADAPTER_CHECK */
1119 else if (sisr & SISR_ASB_FREE) {
1120 /* Wake up anything that is waiting for the asb response */
1121 if (streamer_priv->asb_queued) {
1122 streamer_asb_bh(dev);
1123 }
1124 writew(~SISR_ASB_FREE, streamer_mmio + SISR_RUM);
1125 (void)readw(streamer_mmio + SISR_RUM);
1126 }
1127 /* SISR_ASB_FREE */
1128 else if (sisr & SISR_ARB_CMD) {
1129 streamer_arb_cmd(dev);
1130 writew(~SISR_ARB_CMD, streamer_mmio + SISR_RUM);
1131 (void)readw(streamer_mmio + SISR_RUM);
1132 }
1133 /* SISR_ARB_CMD */
1134 else if (sisr & SISR_TRB_REPLY) {
1135 /* Wake up anything that is waiting for the trb response */
1136 if (streamer_priv->trb_queued) {
1137 wake_up_interruptible(&streamer_priv->
1138 trb_wait);
1139 }
1140 streamer_priv->trb_queued = 0;
1141 writew(~SISR_TRB_REPLY, streamer_mmio + SISR_RUM);
1142 (void)readw(streamer_mmio + SISR_RUM);
1143 }
1144 /* SISR_TRB_REPLY */
1145
1146 sisr = readw(streamer_mmio + SISR);
1147 max_intr--;
1148 } /* while() */
1149
1150 spin_unlock(&streamer_priv->streamer_lock) ;
1151 return IRQ_HANDLED;
1152 }
1153
1154 static int streamer_xmit(struct sk_buff *skb, struct net_device *dev)
1155 {
1156 struct streamer_private *streamer_priv =
1157 (struct streamer_private *) dev->priv;
1158 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1159 unsigned long flags ;
1160
1161 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1162
1163 if (streamer_priv->free_tx_ring_entries) {
1164 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].status = 0;
1165 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].bufcnt_framelen = 0x00020000 | skb->len;
1166 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buffer =
1167 cpu_to_le32(pci_map_single(streamer_priv->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE));
1168 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd1 = skb->len;
1169 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd2 = 0;
1170 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].rsvd3 = 0;
1171 streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free].buflen = skb->len;
1172
1173 streamer_priv->tx_ring_skb[streamer_priv->tx_ring_free] = skb;
1174 streamer_priv->free_tx_ring_entries--;
1175 #if STREAMER_DEBUG_PACKETS
1176 {
1177 int i;
1178 printk("streamer_xmit packet print:\n");
1179 for (i = 0; i < skb->len; i++) {
1180 printk("%x:", skb->data[i]);
1181 if (((i + 1) % 16) == 0)
1182 printk("\n");
1183 }
1184 printk("\n");
1185 }
1186 #endif
1187
1188 writel(cpu_to_le32(pci_map_single(streamer_priv->pci_dev,
1189 &streamer_priv->streamer_tx_ring[streamer_priv->tx_ring_free],
1190 sizeof(struct streamer_tx_desc), PCI_DMA_TODEVICE)),
1191 streamer_mmio + TX2LFDA);
1192 (void)readl(streamer_mmio + TX2LFDA);
1193
1194 streamer_priv->tx_ring_free = (streamer_priv->tx_ring_free + 1) & (STREAMER_TX_RING_SIZE - 1);
1195 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1196 return 0;
1197 } else {
1198 netif_stop_queue(dev);
1199 spin_unlock_irqrestore(&streamer_priv->streamer_lock,flags);
1200 return 1;
1201 }
1202 }
1203
1204
1205 static int streamer_close(struct net_device *dev)
1206 {
1207 struct streamer_private *streamer_priv =
1208 (struct streamer_private *) dev->priv;
1209 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1210 unsigned long flags;
1211 int i;
1212
1213 netif_stop_queue(dev);
1214 netif_carrier_off(dev);
1215 writew(streamer_priv->srb, streamer_mmio + LAPA);
1216 writew(htons(SRB_CLOSE_ADAPTER << 8),streamer_mmio+LAPDINC);
1217 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1218
1219 spin_lock_irqsave(&streamer_priv->streamer_lock, flags);
1220
1221 streamer_priv->srb_queued = 1;
1222 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1223
1224 spin_unlock_irqrestore(&streamer_priv->streamer_lock, flags);
1225
1226 while (streamer_priv->srb_queued)
1227 {
1228 interruptible_sleep_on_timeout(&streamer_priv->srb_wait,
1229 jiffies + 60 * HZ);
1230 if (signal_pending(current))
1231 {
1232 printk(KERN_WARNING "%s: SRB timed out.\n", dev->name);
1233 printk(KERN_WARNING "SISR=%x MISR=%x LISR=%x\n",
1234 readw(streamer_mmio + SISR),
1235 readw(streamer_mmio + MISR_RUM),
1236 readw(streamer_mmio + LISR));
1237 streamer_priv->srb_queued = 0;
1238 break;
1239 }
1240 }
1241
1242 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1243
1244 for (i = 0; i < STREAMER_RX_RING_SIZE; i++) {
1245 if (streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]) {
1246 dev_kfree_skb(streamer_priv->rx_ring_skb[streamer_priv->rx_ring_last_received]);
1247 }
1248 streamer_priv->rx_ring_last_received = (streamer_priv->rx_ring_last_received + 1) & (STREAMER_RX_RING_SIZE - 1);
1249 }
1250
1251 /* reset tx/rx fifo's and busmaster logic */
1252
1253 /* TBD. Add graceful way to reset the LLC channel without doing a soft reset.
1254 writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1255 udelay(1);
1256 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL);
1257 */
1258
1259 #if STREAMER_DEBUG
1260 writew(streamer_priv->srb, streamer_mmio + LAPA);
1261 printk("srb): ");
1262 for (i = 0; i < 2; i++) {
1263 printk("%x ", ntohs(readw(streamer_mmio + LAPDINC)));
1264 }
1265 printk("\n");
1266 #endif
1267 free_irq(dev->irq, dev);
1268 return 0;
1269 }
1270
1271 static void streamer_set_rx_mode(struct net_device *dev)
1272 {
1273 struct streamer_private *streamer_priv =
1274 (struct streamer_private *) dev->priv;
1275 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1276 __u8 options = 0;
1277 struct dev_mc_list *dmi;
1278 unsigned char dev_mc_address[5];
1279 int i;
1280
1281 writel(streamer_priv->srb, streamer_mmio + LAPA);
1282 options = streamer_priv->streamer_copy_all_options;
1283
1284 if (dev->flags & IFF_PROMISC)
1285 options |= (3 << 5); /* All LLC and MAC frames, all through the main rx channel */
1286 else
1287 options &= ~(3 << 5);
1288
1289 /* Only issue the srb if there is a change in options */
1290
1291 if ((options ^ streamer_priv->streamer_copy_all_options))
1292 {
1293 /* Now to issue the srb command to alter the copy.all.options */
1294 writew(htons(SRB_MODIFY_RECEIVE_OPTIONS << 8), streamer_mmio+LAPDINC);
1295 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1296 writew(htons((streamer_priv->streamer_receive_options << 8) | options),streamer_mmio+LAPDINC);
1297 writew(htons(0x4a41),streamer_mmio+LAPDINC);
1298 writew(htons(0x4d45),streamer_mmio+LAPDINC);
1299 writew(htons(0x5320),streamer_mmio+LAPDINC);
1300 writew(0x2020, streamer_mmio + LAPDINC);
1301
1302 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1303
1304 writel(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1305
1306 streamer_priv->streamer_copy_all_options = options;
1307 return;
1308 }
1309
1310 /* Set the functional addresses we need for multicast */
1311 writel(streamer_priv->srb,streamer_mmio+LAPA);
1312 dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ;
1313
1314 for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next)
1315 {
1316 dev_mc_address[0] |= dmi->dmi_addr[2] ;
1317 dev_mc_address[1] |= dmi->dmi_addr[3] ;
1318 dev_mc_address[2] |= dmi->dmi_addr[4] ;
1319 dev_mc_address[3] |= dmi->dmi_addr[5] ;
1320 }
1321
1322 writew(htons(SRB_SET_FUNC_ADDRESS << 8),streamer_mmio+LAPDINC);
1323 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1324 writew(0,streamer_mmio+LAPDINC);
1325 writew(htons( (dev_mc_address[0] << 8) | dev_mc_address[1]),streamer_mmio+LAPDINC);
1326 writew(htons( (dev_mc_address[2] << 8) | dev_mc_address[3]),streamer_mmio+LAPDINC);
1327 streamer_priv->srb_queued = 2 ;
1328 writel(LISR_SRB_CMD,streamer_mmio+LISR_SUM);
1329 }
1330
1331 static void streamer_srb_bh(struct net_device *dev)
1332 {
1333 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
1334 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1335 __u16 srb_word;
1336
1337 writew(streamer_priv->srb, streamer_mmio + LAPA);
1338 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1339
1340 switch (srb_word) {
1341
1342 /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous)
1343 * At some point we should do something if we get an error, such as
1344 * resetting the IFF_PROMISC flag in dev
1345 */
1346
1347 case SRB_MODIFY_RECEIVE_OPTIONS:
1348 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1349
1350 switch (srb_word) {
1351 case 0x01:
1352 printk(KERN_WARNING "%s: Unrecognized srb command\n", dev->name);
1353 break;
1354 case 0x04:
1355 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1356 break;
1357 default:
1358 if (streamer_priv->streamer_message_level)
1359 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",
1360 dev->name,
1361 streamer_priv->streamer_copy_all_options,
1362 streamer_priv->streamer_receive_options);
1363 break;
1364 } /* switch srb[2] */
1365 break;
1366
1367
1368 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1369 */
1370 case SRB_SET_GROUP_ADDRESS:
1371 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1372 switch (srb_word) {
1373 case 0x00:
1374 break;
1375 case 0x01:
1376 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name);
1377 break;
1378 case 0x04:
1379 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1380 break;
1381 case 0x3c:
1382 printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n", dev->name);
1383 break;
1384 case 0x3e: /* If we ever implement individual multicast addresses, will need to deal with this */
1385 printk(KERN_WARNING "%s: Group address registers full\n", dev->name);
1386 break;
1387 case 0x55:
1388 printk(KERN_INFO "%s: Group Address already set.\n", dev->name);
1389 break;
1390 default:
1391 break;
1392 } /* switch srb[2] */
1393 break;
1394
1395
1396 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1397 */
1398 case SRB_RESET_GROUP_ADDRESS:
1399 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1400 switch (srb_word) {
1401 case 0x00:
1402 break;
1403 case 0x01:
1404 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1405 break;
1406 case 0x04:
1407 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1408 break;
1409 case 0x39: /* Must deal with this if individual multicast addresses used */
1410 printk(KERN_INFO "%s: Group address not found \n", dev->name);
1411 break;
1412 default:
1413 break;
1414 } /* switch srb[2] */
1415 break;
1416
1417
1418 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1419 */
1420
1421 case SRB_SET_FUNC_ADDRESS:
1422 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1423 switch (srb_word) {
1424 case 0x00:
1425 if (streamer_priv->streamer_message_level)
1426 printk(KERN_INFO "%s: Functional Address Mask Set \n", dev->name);
1427 break;
1428 case 0x01:
1429 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1430 break;
1431 case 0x04:
1432 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1433 break;
1434 default:
1435 break;
1436 } /* switch srb[2] */
1437 break;
1438
1439 /* SRB_READ_LOG - Read and reset the adapter error counters
1440 */
1441
1442 case SRB_READ_LOG:
1443 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1444 switch (srb_word) {
1445 case 0x00:
1446 {
1447 int i;
1448 if (streamer_priv->streamer_message_level)
1449 printk(KERN_INFO "%s: Read Log command complete\n", dev->name);
1450 printk("Read Log statistics: ");
1451 writew(streamer_priv->srb + 6,
1452 streamer_mmio + LAPA);
1453 for (i = 0; i < 5; i++) {
1454 printk("%x:", ntohs(readw(streamer_mmio + LAPDINC)));
1455 }
1456 printk("\n");
1457 }
1458 break;
1459 case 0x01:
1460 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1461 break;
1462 case 0x04:
1463 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1464 break;
1465
1466 } /* switch srb[2] */
1467 break;
1468
1469 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1470
1471 case SRB_READ_SR_COUNTERS:
1472 srb_word=ntohs(readw(streamer_mmio+LAPDINC)) >> 8;
1473 switch (srb_word) {
1474 case 0x00:
1475 if (streamer_priv->streamer_message_level)
1476 printk(KERN_INFO "%s: Read Source Routing Counters issued\n", dev->name);
1477 break;
1478 case 0x01:
1479 printk(KERN_WARNING "%s: Unrecognized srb command \n", dev->name);
1480 break;
1481 case 0x04:
1482 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n", dev->name);
1483 break;
1484 default:
1485 break;
1486 } /* switch srb[2] */
1487 break;
1488
1489 default:
1490 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n", dev->name);
1491 break;
1492 } /* switch srb[0] */
1493 }
1494
1495 static struct net_device_stats *streamer_get_stats(struct net_device *dev)
1496 {
1497 struct streamer_private *streamer_priv;
1498 streamer_priv = (struct streamer_private *) dev->priv;
1499 return (struct net_device_stats *) &streamer_priv->streamer_stats;
1500 }
1501
1502 static int streamer_set_mac_address(struct net_device *dev, void *addr)
1503 {
1504 struct sockaddr *saddr = addr;
1505 struct streamer_private *streamer_priv = (struct streamer_private *) dev->priv;
1506
1507 if (netif_running(dev))
1508 {
1509 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name);
1510 return -EIO;
1511 }
1512
1513 memcpy(streamer_priv->streamer_laa, saddr->sa_data, dev->addr_len);
1514
1515 if (streamer_priv->streamer_message_level) {
1516 printk(KERN_INFO "%s: MAC/LAA Set to = %x.%x.%x.%x.%x.%x\n",
1517 dev->name, streamer_priv->streamer_laa[0],
1518 streamer_priv->streamer_laa[1],
1519 streamer_priv->streamer_laa[2],
1520 streamer_priv->streamer_laa[3],
1521 streamer_priv->streamer_laa[4],
1522 streamer_priv->streamer_laa[5]);
1523 }
1524 return 0;
1525 }
1526
1527 static void streamer_arb_cmd(struct net_device *dev)
1528 {
1529 struct streamer_private *streamer_priv =
1530 (struct streamer_private *) dev->priv;
1531 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1532 __u8 header_len;
1533 __u16 frame_len, buffer_len;
1534 struct sk_buff *mac_frame;
1535 __u8 frame_data[256];
1536 __u16 buff_off;
1537 __u16 lan_status = 0, lan_status_diff; /* Initialize to stop compiler warning */
1538 __u8 fdx_prot_error;
1539 __u16 next_ptr;
1540 __u16 arb_word;
1541
1542 #if STREAMER_NETWORK_MONITOR
1543 struct trh_hdr *mac_hdr;
1544 #endif
1545
1546 writew(streamer_priv->arb, streamer_mmio + LAPA);
1547 arb_word=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1548
1549 if (arb_word == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
1550 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1551 streamer_priv->mac_rx_buffer = buff_off = ntohs(readw(streamer_mmio + LAPDINC));
1552 header_len=ntohs(readw(streamer_mmio+LAPDINC)) >> 8; /* 802.5 Token-Ring Header Length */
1553 frame_len = ntohs(readw(streamer_mmio + LAPDINC));
1554
1555 #if STREAMER_DEBUG
1556 {
1557 int i;
1558 __u16 next;
1559 __u8 status;
1560 __u16 len;
1561
1562 writew(ntohs(buff_off), streamer_mmio + LAPA); /*setup window to frame data */
1563 next = htons(readw(streamer_mmio + LAPDINC));
1564 status =
1565 ntohs(readw(streamer_mmio + LAPDINC)) & 0xff;
1566 len = ntohs(readw(streamer_mmio + LAPDINC));
1567
1568 /* print out 1st 14 bytes of frame data */
1569 for (i = 0; i < 7; i++) {
1570 printk("Loc %d = %04x\n", i,
1571 ntohs(readw
1572 (streamer_mmio + LAPDINC)));
1573 }
1574
1575 printk("next %04x, fs %02x, len %04x \n", next,
1576 status, len);
1577 }
1578 #endif
1579 if (!(mac_frame = dev_alloc_skb(frame_len))) {
1580 printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n",
1581 dev->name);
1582 goto drop_frame;
1583 }
1584 /* Walk the buffer chain, creating the frame */
1585
1586 do {
1587 int i;
1588 __u16 rx_word;
1589
1590 writew(htons(buff_off), streamer_mmio + LAPA); /* setup window to frame data */
1591 next_ptr = ntohs(readw(streamer_mmio + LAPDINC));
1592 readw(streamer_mmio + LAPDINC); /* read thru status word */
1593 buffer_len = ntohs(readw(streamer_mmio + LAPDINC));
1594
1595 if (buffer_len > 256)
1596 break;
1597
1598 i = 0;
1599 while (i < buffer_len) {
1600 rx_word=ntohs(readw(streamer_mmio+LAPDINC));
1601 frame_data[i]=rx_word >> 8;
1602 frame_data[i+1]=rx_word & 0xff;
1603 i += 2;
1604 }
1605
1606 memcpy(skb_put(mac_frame, buffer_len),
1607 frame_data, buffer_len);
1608 } while (next_ptr && (buff_off = next_ptr));
1609
1610 #if STREAMER_NETWORK_MONITOR
1611 printk(KERN_WARNING "%s: Received MAC Frame, details: \n",
1612 dev->name);
1613 mac_hdr = (struct trh_hdr *) mac_frame->data;
1614 printk(KERN_WARNING
1615 "%s: MAC Frame Dest. Addr: %02x:%02x:%02x:%02x:%02x:%02x \n",
1616 dev->name, mac_hdr->daddr[0], mac_hdr->daddr[1],
1617 mac_hdr->daddr[2], mac_hdr->daddr[3],
1618 mac_hdr->daddr[4], mac_hdr->daddr[5]);
1619 printk(KERN_WARNING
1620 "%s: MAC Frame Srce. Addr: %02x:%02x:%02x:%02x:%02x:%02x \n",
1621 dev->name, mac_hdr->saddr[0], mac_hdr->saddr[1],
1622 mac_hdr->saddr[2], mac_hdr->saddr[3],
1623 mac_hdr->saddr[4], mac_hdr->saddr[5]);
1624 #endif
1625 mac_frame->dev = dev;
1626 mac_frame->protocol = tr_type_trans(mac_frame, dev);
1627 netif_rx(mac_frame);
1628
1629 /* Now tell the card we have dealt with the received frame */
1630 drop_frame:
1631 /* Set LISR Bit 1 */
1632 writel(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1633
1634 /* Is the ASB free ? */
1635
1636 if (!(readl(streamer_priv->streamer_mmio + SISR) & SISR_ASB_FREE))
1637 {
1638 streamer_priv->asb_queued = 1;
1639 writel(LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1640 return;
1641 /* Drop out and wait for the bottom half to be run */
1642 }
1643
1644
1645 writew(streamer_priv->asb, streamer_mmio + LAPA);
1646 writew(htons(ASB_RECEIVE_DATA << 8), streamer_mmio+LAPDINC);
1647 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1648 writew(0, streamer_mmio + LAPDINC);
1649 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1650
1651 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1652
1653 streamer_priv->asb_queued = 2;
1654 return;
1655
1656 } else if (arb_word == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
1657 writew(streamer_priv->arb + 6, streamer_mmio + LAPA);
1658 lan_status = ntohs(readw(streamer_mmio + LAPDINC));
1659 fdx_prot_error = ntohs(readw(streamer_mmio+LAPD)) >> 8;
1660
1661 /* Issue ARB Free */
1662 writew(LISR_ARB_FREE, streamer_priv->streamer_mmio + LISR_SUM);
1663
1664 lan_status_diff = (streamer_priv->streamer_lan_status ^ lan_status) &
1665 lan_status;
1666
1667 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR))
1668 {
1669 if (lan_status_diff & LSC_LWF)
1670 printk(KERN_WARNING "%s: Short circuit detected on the lobe\n", dev->name);
1671 if (lan_status_diff & LSC_ARW)
1672 printk(KERN_WARNING "%s: Auto removal error\n", dev->name);
1673 if (lan_status_diff & LSC_FPE)
1674 printk(KERN_WARNING "%s: FDX Protocol Error\n", dev->name);
1675 if (lan_status_diff & LSC_RR)
1676 printk(KERN_WARNING "%s: Force remove MAC frame received\n", dev->name);
1677
1678 /* Adapter has been closed by the hardware */
1679
1680 /* reset tx/rx fifo's and busmaster logic */
1681
1682 /* @TBD. no llc reset on autostreamer writel(readl(streamer_mmio+BCTL)|(3<<13),streamer_mmio+BCTL);
1683 udelay(1);
1684 writel(readl(streamer_mmio+BCTL)&~(3<<13),streamer_mmio+BCTL); */
1685
1686 netif_stop_queue(dev);
1687 netif_carrier_off(dev);
1688 printk(KERN_WARNING "%s: Adapter must be manually reset.\n", dev->name);
1689 }
1690 /* If serious error */
1691 if (streamer_priv->streamer_message_level) {
1692 if (lan_status_diff & LSC_SIG_LOSS)
1693 printk(KERN_WARNING "%s: No receive signal detected \n", dev->name);
1694 if (lan_status_diff & LSC_HARD_ERR)
1695 printk(KERN_INFO "%s: Beaconing \n", dev->name);
1696 if (lan_status_diff & LSC_SOFT_ERR)
1697 printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n", dev->name);
1698 if (lan_status_diff & LSC_TRAN_BCN)
1699 printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n", dev->name);
1700 if (lan_status_diff & LSC_SS)
1701 printk(KERN_INFO "%s: Single Station on the ring \n", dev->name);
1702 if (lan_status_diff & LSC_RING_REC)
1703 printk(KERN_INFO "%s: Ring recovery ongoing\n", dev->name);
1704 if (lan_status_diff & LSC_FDX_MODE)
1705 printk(KERN_INFO "%s: Operating in FDX mode\n", dev->name);
1706 }
1707
1708 if (lan_status_diff & LSC_CO) {
1709 if (streamer_priv->streamer_message_level)
1710 printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1711
1712 /* Issue READ.LOG command */
1713
1714 writew(streamer_priv->srb, streamer_mmio + LAPA);
1715 writew(htons(SRB_READ_LOG << 8),streamer_mmio+LAPDINC);
1716 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1717 writew(0, streamer_mmio + LAPDINC);
1718 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1719
1720 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1721 }
1722
1723 if (lan_status_diff & LSC_SR_CO) {
1724 if (streamer_priv->streamer_message_level)
1725 printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
1726
1727 /* Issue a READ.SR.COUNTERS */
1728 writew(streamer_priv->srb, streamer_mmio + LAPA);
1729 writew(htons(SRB_READ_SR_COUNTERS << 8),
1730 streamer_mmio+LAPDINC);
1731 writew(htons(STREAMER_CLEAR_RET_CODE << 8),
1732 streamer_mmio+LAPDINC);
1733 streamer_priv->srb_queued = 2; /* Can't sleep, use srb_bh */
1734 writew(LISR_SRB_CMD, streamer_mmio + LISR_SUM);
1735
1736 }
1737 streamer_priv->streamer_lan_status = lan_status;
1738 } /* Lan.change.status */
1739 else
1740 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1741 }
1742
1743 static void streamer_asb_bh(struct net_device *dev)
1744 {
1745 struct streamer_private *streamer_priv =
1746 (struct streamer_private *) dev->priv;
1747 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1748
1749 if (streamer_priv->asb_queued == 1)
1750 {
1751 /* Dropped through the first time */
1752
1753 writew(streamer_priv->asb, streamer_mmio + LAPA);
1754 writew(htons(ASB_RECEIVE_DATA << 8),streamer_mmio+LAPDINC);
1755 writew(htons(STREAMER_CLEAR_RET_CODE << 8), streamer_mmio+LAPDINC);
1756 writew(0, streamer_mmio + LAPDINC);
1757 writew(htons(streamer_priv->mac_rx_buffer), streamer_mmio + LAPD);
1758
1759 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ, streamer_priv->streamer_mmio + LISR_SUM);
1760 streamer_priv->asb_queued = 2;
1761
1762 return;
1763 }
1764
1765 if (streamer_priv->asb_queued == 2) {
1766 __u8 rc;
1767 writew(streamer_priv->asb + 2, streamer_mmio + LAPA);
1768 rc=ntohs(readw(streamer_mmio+LAPD)) >> 8;
1769 switch (rc) {
1770 case 0x01:
1771 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1772 break;
1773 case 0x26:
1774 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1775 break;
1776 case 0xFF:
1777 /* Valid response, everything should be ok again */
1778 break;
1779 default:
1780 printk(KERN_WARNING "%s: Invalid return code in asb\n", dev->name);
1781 break;
1782 }
1783 }
1784 streamer_priv->asb_queued = 0;
1785 }
1786
1787 static int streamer_change_mtu(struct net_device *dev, int mtu)
1788 {
1789 struct streamer_private *streamer_priv =
1790 (struct streamer_private *) dev->priv;
1791 __u16 max_mtu;
1792
1793 if (streamer_priv->streamer_ring_speed == 4)
1794 max_mtu = 4500;
1795 else
1796 max_mtu = 18000;
1797
1798 if (mtu > max_mtu)
1799 return -EINVAL;
1800 if (mtu < 100)
1801 return -EINVAL;
1802
1803 dev->mtu = mtu;
1804 streamer_priv->pkt_buf_sz = mtu + TR_HLEN;
1805
1806 return 0;
1807 }
1808
1809 #if STREAMER_NETWORK_MONITOR
1810 #ifdef CONFIG_PROC_FS
1811 static int streamer_proc_info(char *buffer, char **start, off_t offset,
1812 int length, int *eof, void *data)
1813 {
1814 struct streamer_private *sdev=NULL;
1815 struct pci_dev *pci_device = NULL;
1816 int len = 0;
1817 off_t begin = 0;
1818 off_t pos = 0;
1819 int size;
1820
1821 struct net_device *dev;
1822
1823 size = sprintf(buffer, "IBM LanStreamer/MPC Chipset Token Ring Adapters\n");
1824
1825 pos += size;
1826 len += size;
1827
1828 for(sdev=dev_streamer; sdev; sdev=sdev->next) {
1829 pci_device=sdev->pci_dev;
1830 dev=pci_get_drvdata(pci_device);
1831
1832 size = sprintf_info(buffer + len, dev);
1833 len += size;
1834 pos = begin + len;
1835
1836 if (pos < offset) {
1837 len = 0;
1838 begin = pos;
1839 }
1840 if (pos > offset + length)
1841 break;
1842 } /* for */
1843
1844 *start = buffer + (offset - begin); /* Start of wanted data */
1845 len -= (offset - begin); /* Start slop */
1846 if (len > length)
1847 len = length; /* Ending slop */
1848 return len;
1849 }
1850
1851 static int sprintf_info(char *buffer, struct net_device *dev)
1852 {
1853 struct streamer_private *streamer_priv =
1854 (struct streamer_private *) dev->priv;
1855 __u8 __iomem *streamer_mmio = streamer_priv->streamer_mmio;
1856 struct streamer_adapter_addr_table sat;
1857 struct streamer_parameters_table spt;
1858 int size = 0;
1859 int i;
1860
1861 writew(streamer_priv->streamer_addr_table_addr, streamer_mmio + LAPA);
1862 for (i = 0; i < 14; i += 2) {
1863 __u16 io_word;
1864 __u8 *datap = (__u8 *) & sat;
1865 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1866 datap[size]=io_word >> 8;
1867 datap[size+1]=io_word & 0xff;
1868 }
1869 writew(streamer_priv->streamer_parms_addr, streamer_mmio + LAPA);
1870 for (i = 0; i < 68; i += 2) {
1871 __u16 io_word;
1872 __u8 *datap = (__u8 *) & spt;
1873 io_word=ntohs(readw(streamer_mmio+LAPDINC));
1874 datap[size]=io_word >> 8;
1875 datap[size+1]=io_word & 0xff;
1876 }
1877
1878 size = sprintf(buffer, "\n%6s: Adapter Address : Node Address : Functional Addr\n", dev->name);
1879
1880 size += sprintf(buffer + size,
1881 "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x\n",
1882 dev->name, dev->dev_addr[0], dev->dev_addr[1],
1883 dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4],
1884 dev->dev_addr[5], sat.node_addr[0], sat.node_addr[1],
1885 sat.node_addr[2], sat.node_addr[3], sat.node_addr[4],
1886 sat.node_addr[5], sat.func_addr[0], sat.func_addr[1],
1887 sat.func_addr[2], sat.func_addr[3]);
1888
1889 size += sprintf(buffer + size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1890
1891 size += sprintf(buffer + size, "%6s: Physical Addr : Up Node Address : Poll Address : AccPri : Auth Src : Att Code :\n", dev->name);
1892
1893 size += sprintf(buffer + size,
1894 "%6s: %02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x :\n",
1895 dev->name, spt.phys_addr[0], spt.phys_addr[1],
1896 spt.phys_addr[2], spt.phys_addr[3],
1897 spt.up_node_addr[0], spt.up_node_addr[1],
1898 spt.up_node_addr[2], spt.up_node_addr[3],
1899 spt.up_node_addr[4], spt.up_node_addr[4],
1900 spt.poll_addr[0], spt.poll_addr[1], spt.poll_addr[2],
1901 spt.poll_addr[3], spt.poll_addr[4], spt.poll_addr[5],
1902 ntohs(spt.acc_priority), ntohs(spt.auth_source_class),
1903 ntohs(spt.att_code));
1904
1905 size += sprintf(buffer + size, "%6s: Source Address : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n", dev->name);
1906
1907 size += sprintf(buffer + size,
1908 "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x : %04x : %04x : %04x : \n",
1909 dev->name, spt.source_addr[0], spt.source_addr[1],
1910 spt.source_addr[2], spt.source_addr[3],
1911 spt.source_addr[4], spt.source_addr[5],
1912 ntohs(spt.beacon_type), ntohs(spt.major_vector),
1913 ntohs(spt.lan_status), ntohs(spt.local_ring),
1914 ntohs(spt.mon_error), ntohs(spt.frame_correl));
1915
1916 size += sprintf(buffer + size, "%6s: Beacon Details : Tx : Rx : NAUN Node Address : NAUN Node Phys : \n",
1917 dev->name);
1918
1919 size += sprintf(buffer + size,
1920 "%6s: : %02x : %02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x : \n",
1921 dev->name, ntohs(spt.beacon_transmit),
1922 ntohs(spt.beacon_receive), spt.beacon_naun[0],
1923 spt.beacon_naun[1], spt.beacon_naun[2],
1924 spt.beacon_naun[3], spt.beacon_naun[4],
1925 spt.beacon_naun[5], spt.beacon_phys[0],
1926 spt.beacon_phys[1], spt.beacon_phys[2],
1927 spt.beacon_phys[3]);
1928 return size;
1929 }
1930 #endif
1931 #endif
1932
1933 static struct pci_driver streamer_pci_driver = {
1934 .name = "lanstreamer",
1935 .id_table = streamer_pci_tbl,
1936 .probe = streamer_init_one,
1937 .remove = __devexit_p(streamer_remove_one),
1938 };
1939
1940 static int __init streamer_init_module(void) {
1941 return pci_register_driver(&streamer_pci_driver);
1942 }
1943
1944 static void __exit streamer_cleanup_module(void) {
1945 pci_unregister_driver(&streamer_pci_driver);
1946 }
1947
1948 module_init(streamer_init_module);
1949 module_exit(streamer_cleanup_module);
1950 MODULE_LICENSE("GPL");
CJK support for tty framebuffer vt