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