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