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