← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/tokenring/olympic.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/tokenring/olympic.c
 
1
/*
 
2
 *   olympic.c (c) 1999 Peter De Schrijver All Rights Reserved
 
3
 *                 1999/2000 Mike Phillips (mikep@linuxtr.net)
 
4
 *
 
5
 *  Linux driver for IBM PCI tokenring cards based on the Pit/Pit-Phy/Olympic
 
6
 *  chipset. 
 
7
 *
 
8
 *  Base Driver Skeleton:
 
9
 *      Written 1993-94 by Donald Becker.
 
10
 *
 
11
 *      Copyright 1993 United States Government as represented by the
 
12
 *      Director, National Security Agency.
 
13
 *
 
14
 *  Thanks to Erik De Cock, Adrian Bridgett and Frank Fiene for their 
 
15
 *  assistance and perserverance with the testing of this driver.
 
16
 *
 
17
 *  This software may be used and distributed according to the terms
 
18
 *  of the GNU General Public License, incorporated herein by reference.
 
19
 * 
 
20
 *  4/27/99 - Alpha Release 0.1.0
 
21
 *            First release to the public
 
22
 *
 
23
 *  6/8/99  - Official Release 0.2.0   
 
24
 *            Merged into the kernel code 
 
25
 *  8/18/99 - Updated driver for 2.3.13 kernel to use new pci
 
26
 *            resource. Driver also reports the card name returned by
 
27
 *            the pci resource.
 
28
 *  1/11/00 - Added spinlocks for smp
 
29
 *  2/23/00 - Updated to dev_kfree_irq 
 
30
 *  3/10/00 - Fixed FDX enable which triggered other bugs also 
 
31
 *            squashed.
 
32
 *  5/20/00 - Changes to handle Olympic on LinuxPPC. Endian changes.
 
33
 *            The odd thing about the changes is that the fix for
 
34
 *            endian issues with the big-endian data in the arb, asb...
 
35
 *            was to always swab() the bytes, no matter what CPU.
 
36
 *            That's because the read[wl]() functions always swap the
 
37
 *            bytes on the way in on PPC.
 
38
 *            Fixing the hardware descriptors was another matter,
 
39
 *            because they weren't going through read[wl](), there all
 
40
 *            the results had to be in memory in le32 values. kdaaker
 
41
 *
 
42
 * 12/23/00 - Added minimal Cardbus support (Thanks Donald).
 
43
 *
 
44
 * 03/09/01 - Add new pci api, dev_base_lock, general clean up. 
 
45
 *
 
46
 * 03/27/01 - Add new dma pci (Thanks to Kyle Lucke) and alloc_trdev
 
47
 *            Change proc_fs behaviour, now one entry per adapter.
 
48
 *
 
49
 * 04/09/01 - Couple of bug fixes to the dma unmaps and ejecting the
 
50
 *            adapter when live does not take the system down with it.
 
51
 * 
 
52
 * 06/02/01 - Clean up, copy skb for small packets
 
53
 * 
 
54
 * 06/22/01 - Add EISR error handling routines 
 
55
 *
 
56
 * 07/19/01 - Improve bad LAA reporting, strip out freemem
 
57
 *            into a separate function, its called from 3 
 
58
 *            different places now. 
 
59
 * 02/09/02 - Replaced sleep_on. 
 
60
 * 03/01/02 - Replace access to several registers from 32 bit to 
 
61
 *            16 bit. Fixes alignment errors on PPC 64 bit machines.
 
62
 *            Thanks to Al Trautman for this one.
 
63
 * 03/10/02 - Fix BUG in arb_cmd. Bug was there all along but was
 
64
 *            silently ignored until the error checking code 
 
65
 *            went into version 1.0.0 
 
66
 * 06/04/02 - Add correct start up sequence for the cardbus adapters.
 
67
 *            Required for strict compliance with pci power mgmt specs.
 
68
 *  To Do:
 
69
 *
 
70
 *           Wake on lan        
 
71
 * 
 
72
 *  If Problems do Occur
 
73
 *  Most problems can be rectified by either closing and opening the interface
 
74
 *  (ifconfig down and up) or rmmod and insmod'ing the driver (a bit difficult
 
75
 *  if compiled into the kernel).
 
76
 */
 
77
 
 
78
/* Change OLYMPIC_DEBUG to 1 to get verbose, and I mean really verbose, messages */
 
79
 
 
80
#define OLYMPIC_DEBUG 0
 
81
 
 
82
 
 
83
#include <linux/module.h>
 
84
#include <linux/kernel.h>
 
85
#include <linux/errno.h>
 
86
#include <linux/timer.h>
 
87
#include <linux/in.h>
 
88
#include <linux/ioport.h>
 
89
#include <linux/seq_file.h>
 
90
#include <linux/string.h>
 
91
#include <linux/proc_fs.h>
 
92
#include <linux/ptrace.h>
 
93
#include <linux/skbuff.h>
 
94
#include <linux/interrupt.h>
 
95
#include <linux/delay.h>
 
96
#include <linux/netdevice.h>
 
97
#include <linux/trdevice.h>
 
98
#include <linux/stddef.h>
 
99
#include <linux/init.h>
 
100
#include <linux/pci.h>
 
101
#include <linux/spinlock.h>
 
102
#include <linux/bitops.h>
 
103
#include <linux/jiffies.h>
 
104
 
 
105
#include <net/checksum.h>
 
106
#include <net/net_namespace.h>
 
107
 
 
108
#include <asm/io.h>
 
109
#include <asm/system.h>
 
110
 
 
111
#include "olympic.h"
 
112
 
 
113
/* I've got to put some intelligence into the version number so that Peter and I know
 
114
 * which version of the code somebody has got. 
 
115
 * Version Number = a.b.c.d  where a.b.c is the level of code and d is the latest author.
 
116
 * So 0.0.1.pds = Peter, 0.0.1.mlp = Mike
 
117
 * 
 
118
 * Official releases will only have an a.b.c version number format. 
 
119
 */
 
120
 
 
121
static char version[] =
 
122
"Olympic.c v1.0.5 6/04/02 - Peter De Schrijver & Mike Phillips" ; 
 
123
 
 
124
static char *open_maj_error[]  = {"No error", "Lobe Media Test", "Physical Insertion",
 
125
                                   "Address Verification", "Neighbor Notification (Ring Poll)",
 
126
                                   "Request Parameters","FDX Registration Request",
 
127
                                   "FDX Duplicate Address Check", "Station registration Query Wait",
 
128
                                   "Unknown stage"};
 
129
 
 
130
static char *open_min_error[] = {"No error", "Function Failure", "Signal Lost", "Wire Fault",
 
131
                                   "Ring Speed Mismatch", "Timeout","Ring Failure","Ring Beaconing",
 
132
                                   "Duplicate Node Address","Request Parameters","Remove Received",
 
133
                                   "Reserved", "Reserved", "No Monitor Detected for RPL", 
 
134
                                   "Monitor Contention failer for RPL", "FDX Protocol Error"};
 
135
 
 
136
/* Module parameters */
 
137
 
 
138
MODULE_AUTHOR("Mike Phillips <mikep@linuxtr.net>") ; 
 
139
MODULE_DESCRIPTION("Olympic PCI/Cardbus Chipset Driver") ; 
 
140
 
 
141
/* Ring Speed 0,4,16,100 
 
142
 * 0 = Autosense         
 
143
 * 4,16 = Selected speed only, no autosense
 
144
 * This allows the card to be the first on the ring
 
145
 * and become the active monitor.
 
146
 * 100 = Nothing at present, 100mbps is autodetected
 
147
 * if FDX is turned on. May be implemented in the future to 
 
148
 * fail if 100mpbs is not detected.
 
149
 *
 
150
 * WARNING: Some hubs will allow you to insert
 
151
 * at the wrong speed
 
152
 */
 
153
 
 
154
static int ringspeed[OLYMPIC_MAX_ADAPTERS] = {0,} ;
 
155
module_param_array(ringspeed, int, NULL, 0);
 
156
 
 
157
/* Packet buffer size */
 
158
 
 
159
static int pkt_buf_sz[OLYMPIC_MAX_ADAPTERS] = {0,} ;
 
160
module_param_array(pkt_buf_sz, int, NULL, 0) ;
 
161
 
 
162
/* Message Level */
 
163
 
 
164
static int message_level[OLYMPIC_MAX_ADAPTERS] = {0,} ; 
 
165
module_param_array(message_level, int, NULL, 0) ;
 
166
 
 
167
/* Change network_monitor to receive mac frames through the arb channel.
 
168
 * Will also create a /proc/net/olympic_tr%d entry, where %d is the tr
 
169
 * device, i.e. tr0, tr1 etc. 
 
170
 * Intended to be used to create a ring-error reporting network module 
 
171
 * i.e. it will give you the source address of beaconers on the ring 
 
172
 */
 
173
static int network_monitor[OLYMPIC_MAX_ADAPTERS] = {0,};
 
174
module_param_array(network_monitor, int, NULL, 0);
 
175
 
 
176
static DEFINE_PCI_DEVICE_TABLE(olympic_pci_tbl) = {
 
177
        {PCI_VENDOR_ID_IBM,PCI_DEVICE_ID_IBM_TR_WAKE,PCI_ANY_ID,PCI_ANY_ID,},
 
178
        { }     /* Terminating Entry */
 
179
};
 
180
MODULE_DEVICE_TABLE(pci,olympic_pci_tbl) ; 
 
181
 
 
182
 
 
183
static int olympic_probe(struct pci_dev *pdev, const struct pci_device_id *ent); 
 
184
static int olympic_init(struct net_device *dev);
 
185
static int olympic_open(struct net_device *dev);
 
186
static netdev_tx_t olympic_xmit(struct sk_buff *skb,
 
187
                                      struct net_device *dev);
 
188
static int olympic_close(struct net_device *dev);
 
189
static void olympic_set_rx_mode(struct net_device *dev);
 
190
static void olympic_freemem(struct net_device *dev) ;  
 
191
static irqreturn_t olympic_interrupt(int irq, void *dev_id);
 
192
static int olympic_set_mac_address(struct net_device *dev, void *addr) ; 
 
193
static void olympic_arb_cmd(struct net_device *dev);
 
194
static int olympic_change_mtu(struct net_device *dev, int mtu);
 
195
static void olympic_srb_bh(struct net_device *dev) ; 
 
196
static void olympic_asb_bh(struct net_device *dev) ; 
 
197
static const struct file_operations olympic_proc_ops;
 
198
 
 
199
static const struct net_device_ops olympic_netdev_ops = {
 
200
        .ndo_open               = olympic_open,
 
201
        .ndo_stop               = olympic_close,
 
202
        .ndo_start_xmit         = olympic_xmit,
 
203
        .ndo_change_mtu         = olympic_change_mtu,
 
204
        .ndo_set_rx_mode        = olympic_set_rx_mode,
 
205
        .ndo_set_mac_address    = olympic_set_mac_address,
 
206
};
 
207
 
 
208
static int __devinit olympic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
209
{
 
210
        struct net_device *dev ; 
 
211
        struct olympic_private *olympic_priv;
 
212
        static int card_no = -1 ;
 
213
        int i ; 
 
214
 
 
215
        card_no++ ; 
 
216
 
 
217
        if ((i = pci_enable_device(pdev))) {
 
218
                return i ; 
 
219
        }
 
220
 
 
221
        pci_set_master(pdev);
 
222
 
 
223
        if ((i = pci_request_regions(pdev,"olympic"))) { 
 
224
                goto op_disable_dev;
 
225
        }
 
226
 
 
227
        dev = alloc_trdev(sizeof(struct olympic_private)) ; 
 
228
        if (!dev) {
 
229
                i = -ENOMEM; 
 
230
                goto op_release_dev;
 
231
        }
 
232
 
 
233
        olympic_priv = netdev_priv(dev) ;
 
234
        
 
235
        spin_lock_init(&olympic_priv->olympic_lock) ; 
 
236
 
 
237
        init_waitqueue_head(&olympic_priv->srb_wait);
 
238
        init_waitqueue_head(&olympic_priv->trb_wait);
 
239
#if OLYMPIC_DEBUG  
 
240
        printk(KERN_INFO "pci_device: %p, dev:%p, dev->priv: %p\n", pdev, dev, netdev_priv(dev));
 
241
#endif
 
242
        dev->irq=pdev->irq;
 
243
        dev->base_addr=pci_resource_start(pdev, 0);
 
244
        olympic_priv->olympic_card_name = pci_name(pdev);
 
245
        olympic_priv->pdev = pdev; 
 
246
        olympic_priv->olympic_mmio = ioremap(pci_resource_start(pdev,1),256);
 
247
        olympic_priv->olympic_lap = ioremap(pci_resource_start(pdev,2),2048);
 
248
        if (!olympic_priv->olympic_mmio || !olympic_priv->olympic_lap) {
 
249
                goto op_free_iomap;
 
250
        }
 
251
                                
 
252
        if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000) )
 
253
                olympic_priv->pkt_buf_sz = PKT_BUF_SZ ; 
 
254
        else
 
255
                olympic_priv->pkt_buf_sz = pkt_buf_sz[card_no] ; 
 
256
 
 
257
        dev->mtu = olympic_priv->pkt_buf_sz - TR_HLEN ; 
 
258
        olympic_priv->olympic_ring_speed = ringspeed[card_no] ; 
 
259
        olympic_priv->olympic_message_level = message_level[card_no] ; 
 
260
        olympic_priv->olympic_network_monitor = network_monitor[card_no];
 
261
        
 
262
        if ((i = olympic_init(dev))) {
 
263
                goto op_free_iomap;
 
264
        }                               
 
265
 
 
266
        dev->netdev_ops = &olympic_netdev_ops;
 
267
        SET_NETDEV_DEV(dev, &pdev->dev);
 
268
 
 
269
        pci_set_drvdata(pdev,dev) ; 
 
270
        register_netdev(dev) ; 
 
271
        printk("Olympic: %s registered as: %s\n",olympic_priv->olympic_card_name,dev->name);
 
272
        if (olympic_priv->olympic_network_monitor) { /* Must go after register_netdev as we need the device name */ 
 
273
                char proc_name[20] ; 
 
274
                strcpy(proc_name,"olympic_") ;
 
275
                strcat(proc_name,dev->name) ; 
 
276
                proc_create_data(proc_name, 0, init_net.proc_net, &olympic_proc_ops, dev);
 
277
                printk("Olympic: Network Monitor information: /proc/%s\n",proc_name); 
 
278
        }
 
279
        return  0 ;
 
280
 
 
281
op_free_iomap:
 
282
        if (olympic_priv->olympic_mmio)
 
283
                iounmap(olympic_priv->olympic_mmio); 
 
284
        if (olympic_priv->olympic_lap)
 
285
                iounmap(olympic_priv->olympic_lap);
 
286
 
 
287
        free_netdev(dev);
 
288
op_release_dev:
 
289
        pci_release_regions(pdev); 
 
290
 
 
291
op_disable_dev:
 
292
        pci_disable_device(pdev);
 
293
        return i;
 
294
}
 
295
 
 
296
static int olympic_init(struct net_device *dev)
 
297
{
 
298
        struct olympic_private *olympic_priv;
 
299
        u8 __iomem *olympic_mmio, *init_srb,*adapter_addr;
 
300
        unsigned long t; 
 
301
        unsigned int uaa_addr;
 
302
 
 
303
        olympic_priv=netdev_priv(dev);
 
304
        olympic_mmio=olympic_priv->olympic_mmio;
 
305
 
 
306
        printk("%s\n", version);
 
307
        printk("%s. I/O at %hx, MMIO at %p, LAP at %p, using irq %d\n", olympic_priv->olympic_card_name, (unsigned int) dev->base_addr,olympic_priv->olympic_mmio, olympic_priv->olympic_lap, dev->irq);
 
308
 
 
309
        writel(readl(olympic_mmio+BCTL) | BCTL_SOFTRESET,olympic_mmio+BCTL);
 
310
        t=jiffies;
 
311
        while((readl(olympic_mmio+BCTL)) & BCTL_SOFTRESET) {
 
312
                schedule();             
 
313
                if(time_after(jiffies, t + 40*HZ)) {
 
314
                        printk(KERN_ERR "IBM PCI tokenring card not responding.\n");
 
315
                        return -ENODEV;
 
316
                }
 
317
        }
 
318
 
 
319
 
 
320
        /* Needed for cardbus */
 
321
        if(!(readl(olympic_mmio+BCTL) & BCTL_MODE_INDICATOR)) {
 
322
                writel(readl(olympic_priv->olympic_mmio+FERMASK)|FERMASK_INT_BIT, olympic_mmio+FERMASK);
 
323
        }
 
324
        
 
325
#if OLYMPIC_DEBUG
 
326
        printk("BCTL: %x\n",readl(olympic_mmio+BCTL));
 
327
        printk("GPR: %x\n",readw(olympic_mmio+GPR));
 
328
        printk("SISRMASK: %x\n",readl(olympic_mmio+SISR_MASK));
 
329
#endif
 
330
        /* Aaaahhh, You have got to be real careful setting GPR, the card
 
331
           holds the previous values from flash memory, including autosense 
 
332
           and ring speed */
 
333
 
 
334
        writel(readl(olympic_mmio+BCTL)|BCTL_MIMREB,olympic_mmio+BCTL);
 
335
        
 
336
        if (olympic_priv->olympic_ring_speed  == 0) { /* Autosense */
 
337
                writew(readw(olympic_mmio+GPR)|GPR_AUTOSENSE,olympic_mmio+GPR);
 
338
                if (olympic_priv->olympic_message_level) 
 
339
                        printk(KERN_INFO "%s: Ringspeed autosense mode on\n",olympic_priv->olympic_card_name);
 
340
        } else if (olympic_priv->olympic_ring_speed == 16) {
 
341
                if (olympic_priv->olympic_message_level) 
 
342
                        printk(KERN_INFO "%s: Trying to open at 16 Mbps as requested\n", olympic_priv->olympic_card_name);
 
343
                writew(GPR_16MBPS, olympic_mmio+GPR);
 
344
        } else if (olympic_priv->olympic_ring_speed == 4) {
 
345
                if (olympic_priv->olympic_message_level) 
 
346
                        printk(KERN_INFO "%s: Trying to open at 4 Mbps as requested\n", olympic_priv->olympic_card_name) ; 
 
347
                writew(0, olympic_mmio+GPR);
 
348
        } 
 
349
        
 
350
        writew(readw(olympic_mmio+GPR)|GPR_NEPTUNE_BF,olympic_mmio+GPR);
 
351
 
 
352
#if OLYMPIC_DEBUG
 
353
        printk("GPR = %x\n",readw(olympic_mmio + GPR) ) ; 
 
354
#endif
 
355
        /* Solo has been paused to meet the Cardbus power
 
356
         * specs if the adapter is cardbus. Check to 
 
357
         * see its been paused and then restart solo. The
 
358
         * adapter should set the pause bit within 1 second.
 
359
         */
 
360
 
 
361
        if(!(readl(olympic_mmio+BCTL) & BCTL_MODE_INDICATOR)) { 
 
362
                t=jiffies;
 
363
                while (!(readl(olympic_mmio+CLKCTL) & CLKCTL_PAUSE)) {
 
364
                        schedule() ; 
 
365
                        if(time_after(jiffies, t + 2*HZ)) {
 
366
                                printk(KERN_ERR "IBM Cardbus tokenring adapter not responsing.\n") ; 
 
367
                                return -ENODEV;
 
368
                        }
 
369
                }
 
370
                writel(readl(olympic_mmio+CLKCTL) & ~CLKCTL_PAUSE, olympic_mmio+CLKCTL) ; 
 
371
        }
 
372
        
 
373
        /* start solo init */
 
374
        writel((1<<15),olympic_mmio+SISR_MASK_SUM);
 
375
 
 
376
        t=jiffies;
 
377
        while(!((readl(olympic_mmio+SISR_RR)) & SISR_SRB_REPLY)) {
 
378
                schedule();             
 
379
                if(time_after(jiffies, t + 15*HZ)) {
 
380
                        printk(KERN_ERR "IBM PCI tokenring card not responding.\n");
 
381
                        return -ENODEV;
 
382
                }
 
383
        }
 
384
        
 
385
        writel(readw(olympic_mmio+LAPWWO),olympic_mmio+LAPA);
 
386
 
 
387
#if OLYMPIC_DEBUG
 
388
        printk("LAPWWO: %x, LAPA: %x\n",readl(olympic_mmio+LAPWWO), readl(olympic_mmio+LAPA));
 
389
#endif
 
390
 
 
391
        init_srb=olympic_priv->olympic_lap + ((readw(olympic_mmio+LAPWWO)) & (~0xf800));
 
392
 
 
393
#if OLYMPIC_DEBUG               
 
394
{
 
395
        int i;
 
396
        printk("init_srb(%p): ",init_srb);
 
397
        for(i=0;i<20;i++)
 
398
                printk("%x ",readb(init_srb+i));
 
399
        printk("\n");
 
400
}
 
401
#endif  
 
402
        if(readw(init_srb+6)) {
 
403
                printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",readw(init_srb+6));
 
404
                return -ENODEV;
 
405
        }
 
406
 
 
407
        if (olympic_priv->olympic_message_level) {
 
408
                if ( readb(init_srb +2) & 0x40) { 
 
409
                        printk(KERN_INFO "Olympic: Adapter is FDX capable.\n") ;
 
410
                } else { 
 
411
                        printk(KERN_INFO "Olympic: Adapter cannot do FDX.\n");
 
412
                }
 
413
        }
 
414
  
 
415
        uaa_addr=swab16(readw(init_srb+8));
 
416
 
 
417
#if OLYMPIC_DEBUG
 
418
        printk("UAA resides at %x\n",uaa_addr);
 
419
#endif
 
420
 
 
421
        writel(uaa_addr,olympic_mmio+LAPA);
 
422
        adapter_addr=olympic_priv->olympic_lap + (uaa_addr & (~0xf800));
 
423
 
 
424
        memcpy_fromio(&dev->dev_addr[0], adapter_addr,6);
 
425
 
 
426
#if OLYMPIC_DEBUG
 
427
        printk("adapter address: %pM\n", dev->dev_addr);
 
428
#endif
 
429
 
 
430
        olympic_priv->olympic_addr_table_addr = swab16(readw(init_srb + 12)); 
 
431
        olympic_priv->olympic_parms_addr = swab16(readw(init_srb + 14)); 
 
432
 
 
433
        return 0;
 
434
 
 
435
}
 
436
 
 
437
static int olympic_open(struct net_device *dev)
 
438
{
 
439
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
440
        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio,*init_srb;
 
441
        unsigned long flags, t;
 
442
        int i, open_finished = 1 ;
 
443
        u8 resp, err;
 
444
 
 
445
        DECLARE_WAITQUEUE(wait,current) ; 
 
446
 
 
447
        olympic_init(dev);
 
448
 
 
449
        if (request_irq(dev->irq, olympic_interrupt, IRQF_SHARED , "olympic",
 
450
                        dev))
 
451
                return -EAGAIN;
 
452
 
 
453
#if OLYMPIC_DEBUG
 
454
        printk("BMCTL: %x\n",readl(olympic_mmio+BMCTL_SUM));
 
455
        printk("pending ints: %x\n",readl(olympic_mmio+SISR_RR));
 
456
#endif
 
457
 
 
458
        writel(SISR_MI,olympic_mmio+SISR_MASK_SUM);
 
459
 
 
460
        writel(SISR_MI | SISR_SRB_REPLY, olympic_mmio+SISR_MASK); /* more ints later, doesn't stop arb cmd interrupt */
 
461
 
 
462
        writel(LISR_LIE,olympic_mmio+LISR); /* more ints later */
 
463
 
 
464
        /* adapter is closed, so SRB is pointed to by LAPWWO */
 
465
 
 
466
        writel(readw(olympic_mmio+LAPWWO),olympic_mmio+LAPA);
 
467
        init_srb=olympic_priv->olympic_lap + ((readw(olympic_mmio+LAPWWO)) & (~0xf800));
 
468
        
 
469
#if OLYMPIC_DEBUG
 
470
        printk("LAPWWO: %x, LAPA: %x\n",readw(olympic_mmio+LAPWWO), readl(olympic_mmio+LAPA));
 
471
        printk("SISR Mask = %04x\n", readl(olympic_mmio+SISR_MASK));
 
472
        printk("Before the open command\n");
 
473
#endif  
 
474
        do {
 
475
                memset_io(init_srb,0,SRB_COMMAND_SIZE);
 
476
 
 
477
                writeb(SRB_OPEN_ADAPTER,init_srb) ;     /* open */
 
478
                writeb(OLYMPIC_CLEAR_RET_CODE,init_srb+2);
 
479
 
 
480
                /* If Network Monitor, instruct card to copy MAC frames through the ARB */
 
481
                if (olympic_priv->olympic_network_monitor) 
 
482
                        writew(swab16(OPEN_ADAPTER_ENABLE_FDX | OPEN_ADAPTER_PASS_ADC_MAC | OPEN_ADAPTER_PASS_ATT_MAC | OPEN_ADAPTER_PASS_BEACON), init_srb+8);
 
483
                else
 
484
                        writew(swab16(OPEN_ADAPTER_ENABLE_FDX), init_srb+8);
 
485
        
 
486
                /* Test OR of first 3 bytes as its totally possible for 
 
487
                 * someone to set the first 2 bytes to be zero, although this 
 
488
                 * is an error, the first byte must have bit 6 set to 1  */
 
489
 
 
490
                if (olympic_priv->olympic_laa[0] | olympic_priv->olympic_laa[1] | olympic_priv->olympic_laa[2]) {
 
491
                        writeb(olympic_priv->olympic_laa[0],init_srb+12);
 
492
                        writeb(olympic_priv->olympic_laa[1],init_srb+13);
 
493
                        writeb(olympic_priv->olympic_laa[2],init_srb+14);
 
494
                        writeb(olympic_priv->olympic_laa[3],init_srb+15);
 
495
                        writeb(olympic_priv->olympic_laa[4],init_srb+16);
 
496
                        writeb(olympic_priv->olympic_laa[5],init_srb+17);
 
497
                        memcpy(dev->dev_addr,olympic_priv->olympic_laa,dev->addr_len) ;  
 
498
                }       
 
499
                writeb(1,init_srb+30);
 
500
 
 
501
                spin_lock_irqsave(&olympic_priv->olympic_lock,flags);   
 
502
                olympic_priv->srb_queued=1;
 
503
 
 
504
                writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 
505
                spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
 
506
 
 
507
                t = jiffies ; 
 
508
        
 
509
                add_wait_queue(&olympic_priv->srb_wait,&wait) ;
 
510
                set_current_state(TASK_INTERRUPTIBLE) ; 
 
511
 
 
512
                while(olympic_priv->srb_queued) {        
 
513
                        schedule() ; 
 
514
                        if(signal_pending(current))     {            
 
515
                                printk(KERN_WARNING "%s: Signal received in open.\n",
 
516
                                        dev->name);
 
517
                                printk(KERN_WARNING "SISR=%x LISR=%x\n",
 
518
                                        readl(olympic_mmio+SISR),
 
519
                                        readl(olympic_mmio+LISR));
 
520
                                olympic_priv->srb_queued=0;
 
521
                                break;
 
522
                        }
 
523
                        if (time_after(jiffies, t + 10*HZ)) {
 
524
                                printk(KERN_WARNING "%s: SRB timed out.\n",dev->name);
 
525
                                olympic_priv->srb_queued=0;
 
526
                                break ; 
 
527
                        } 
 
528
                        set_current_state(TASK_INTERRUPTIBLE) ; 
 
529
                }
 
530
                remove_wait_queue(&olympic_priv->srb_wait,&wait) ; 
 
531
                set_current_state(TASK_RUNNING) ; 
 
532
                olympic_priv->srb_queued = 0 ; 
 
533
#if OLYMPIC_DEBUG
 
534
                printk("init_srb(%p): ",init_srb);
 
535
                for(i=0;i<20;i++)
 
536
                        printk("%02x ",readb(init_srb+i));
 
537
                printk("\n");
 
538
#endif
 
539
                
 
540
                /* If we get the same return response as we set, the interrupt wasn't raised and the open
 
541
                 * timed out.
 
542
                 */
 
543
 
 
544
                switch (resp = readb(init_srb+2)) {
 
545
                case OLYMPIC_CLEAR_RET_CODE:
 
546
                        printk(KERN_WARNING "%s: Adapter Open time out or error.\n", dev->name) ; 
 
547
                        goto out;
 
548
                case 0:
 
549
                        open_finished = 1;
 
550
                        break;
 
551
                case 0x07:
 
552
                        if (!olympic_priv->olympic_ring_speed && open_finished) { /* Autosense , first time around */
 
553
                                printk(KERN_WARNING "%s: Retrying at different ring speed\n", dev->name);
 
554
                                open_finished = 0 ;  
 
555
                                continue;
 
556
                        }
 
557
 
 
558
                        err = readb(init_srb+7);
 
559
 
 
560
                        if (!olympic_priv->olympic_ring_speed && ((err & 0x0f) == 0x0d)) { 
 
561
                                printk(KERN_WARNING "%s: Tried to autosense ring speed with no monitors present\n",dev->name);
 
562
                                printk(KERN_WARNING "%s: Please try again with a specified ring speed\n",dev->name);
 
563
                        } else {
 
564
                                printk(KERN_WARNING "%s: %s - %s\n", dev->name,
 
565
                                        open_maj_error[(err & 0xf0) >> 4],
 
566
                                        open_min_error[(err & 0x0f)]);
 
567
                        }
 
568
                        goto out;
 
569
 
 
570
                case 0x32:
 
571
                        printk(KERN_WARNING "%s: Invalid LAA: %pM\n",
 
572
                               dev->name, olympic_priv->olympic_laa);
 
573
                        goto out;
 
574
 
 
575
                default:
 
576
                        printk(KERN_WARNING "%s: Bad OPEN response: %x\n", dev->name, resp);
 
577
                        goto out;
 
578
 
 
579
                }
 
580
        } while (!(open_finished)) ; /* Will only loop if ring speed mismatch re-open attempted && autosense is on */   
 
581
 
 
582
        if (readb(init_srb+18) & (1<<3)) 
 
583
                if (olympic_priv->olympic_message_level) 
 
584
                        printk(KERN_INFO "%s: Opened in FDX Mode\n",dev->name);
 
585
 
 
586
        if (readb(init_srb+18) & (1<<1))
 
587
                olympic_priv->olympic_ring_speed = 100 ; 
 
588
        else if (readb(init_srb+18) & 1)
 
589
                olympic_priv->olympic_ring_speed = 16 ; 
 
590
        else
 
591
                olympic_priv->olympic_ring_speed = 4 ; 
 
592
 
 
593
        if (olympic_priv->olympic_message_level) 
 
594
                printk(KERN_INFO "%s: Opened in %d Mbps mode\n",dev->name, olympic_priv->olympic_ring_speed);
 
595
 
 
596
        olympic_priv->asb = swab16(readw(init_srb+8));
 
597
        olympic_priv->srb = swab16(readw(init_srb+10));
 
598
        olympic_priv->arb = swab16(readw(init_srb+12));
 
599
        olympic_priv->trb = swab16(readw(init_srb+16));
 
600
 
 
601
        olympic_priv->olympic_receive_options = 0x01 ; 
 
602
        olympic_priv->olympic_copy_all_options = 0 ; 
 
603
        
 
604
        /* setup rx ring */
 
605
        
 
606
        writel((3<<16),olympic_mmio+BMCTL_RWM); /* Ensure end of frame generated interrupts */ 
 
607
 
 
608
        writel(BMCTL_RX_DIS|3,olympic_mmio+BMCTL_RWM); /* Yes, this the enables RX channel */
 
609
 
 
610
        for(i=0;i<OLYMPIC_RX_RING_SIZE;i++) {
 
611
 
 
612
                struct sk_buff *skb;
 
613
                
 
614
                skb=dev_alloc_skb(olympic_priv->pkt_buf_sz);
 
615
                if(skb == NULL)
 
616
                        break;
 
617
 
 
618
                skb->dev = dev;
 
619
 
 
620
                olympic_priv->olympic_rx_ring[i].buffer = cpu_to_le32(pci_map_single(olympic_priv->pdev, 
 
621
                                                          skb->data,olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE)) ; 
 
622
                olympic_priv->olympic_rx_ring[i].res_length = cpu_to_le32(olympic_priv->pkt_buf_sz); 
 
623
                olympic_priv->rx_ring_skb[i]=skb;
 
624
        }
 
625
 
 
626
        if (i==0) {
 
627
                printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled\n",dev->name);
 
628
                goto out;
 
629
        }
 
630
 
 
631
        olympic_priv->rx_ring_dma_addr = pci_map_single(olympic_priv->pdev,olympic_priv->olympic_rx_ring, 
 
632
                                         sizeof(struct olympic_rx_desc) * OLYMPIC_RX_RING_SIZE, PCI_DMA_TODEVICE);
 
633
        writel(olympic_priv->rx_ring_dma_addr, olympic_mmio+RXDESCQ);
 
634
        writel(olympic_priv->rx_ring_dma_addr, olympic_mmio+RXCDA);
 
635
        writew(i, olympic_mmio+RXDESCQCNT);
 
636
                
 
637
        olympic_priv->rx_status_ring_dma_addr = pci_map_single(olympic_priv->pdev, olympic_priv->olympic_rx_status_ring, 
 
638
                                                sizeof(struct olympic_rx_status) * OLYMPIC_RX_RING_SIZE, PCI_DMA_FROMDEVICE);
 
639
        writel(olympic_priv->rx_status_ring_dma_addr, olympic_mmio+RXSTATQ);
 
640
        writel(olympic_priv->rx_status_ring_dma_addr, olympic_mmio+RXCSA);
 
641
        
 
642
        olympic_priv->rx_ring_last_received = OLYMPIC_RX_RING_SIZE - 1; /* last processed rx status */
 
643
        olympic_priv->rx_status_last_received = OLYMPIC_RX_RING_SIZE - 1;  
 
644
 
 
645
        writew(i, olympic_mmio+RXSTATQCNT);
 
646
 
 
647
#if OLYMPIC_DEBUG 
 
648
        printk("# of rx buffers: %d, RXENQ: %x\n",i, readw(olympic_mmio+RXENQ));
 
649
        printk("RXCSA: %x, rx_status_ring[0]: %p\n",readl(olympic_mmio+RXCSA),&olympic_priv->olympic_rx_status_ring[0]);
 
650
        printk(" stat_ring[1]: %p, stat_ring[2]: %p, stat_ring[3]: %p\n", &(olympic_priv->olympic_rx_status_ring[1]), &(olympic_priv->olympic_rx_status_ring[2]), &(olympic_priv->olympic_rx_status_ring[3]) );
 
651
        printk(" stat_ring[4]: %p, stat_ring[5]: %p, stat_ring[6]: %p\n", &(olympic_priv->olympic_rx_status_ring[4]), &(olympic_priv->olympic_rx_status_ring[5]), &(olympic_priv->olympic_rx_status_ring[6]) );
 
652
        printk(" stat_ring[7]: %p\n", &(olympic_priv->olympic_rx_status_ring[7])  );
 
653
 
 
654
        printk("RXCDA: %x, rx_ring[0]: %p\n",readl(olympic_mmio+RXCDA),&olympic_priv->olympic_rx_ring[0]);
 
655
        printk("Rx_ring_dma_addr = %08x, rx_status_dma_addr = %08x\n",
 
656
                olympic_priv->rx_ring_dma_addr,olympic_priv->rx_status_ring_dma_addr) ; 
 
657
#endif
 
658
 
 
659
        writew((((readw(olympic_mmio+RXENQ)) & 0x8000) ^ 0x8000) | i,olympic_mmio+RXENQ);
 
660
 
 
661
#if OLYMPIC_DEBUG 
 
662
        printk("# of rx buffers: %d, RXENQ: %x\n",i, readw(olympic_mmio+RXENQ));
 
663
        printk("RXCSA: %x, rx_ring[0]: %p\n",readl(olympic_mmio+RXCSA),&olympic_priv->olympic_rx_status_ring[0]);
 
664
        printk("RXCDA: %x, rx_ring[0]: %p\n",readl(olympic_mmio+RXCDA),&olympic_priv->olympic_rx_ring[0]);
 
665
#endif 
 
666
 
 
667
        writel(SISR_RX_STATUS | SISR_RX_NOBUF,olympic_mmio+SISR_MASK_SUM);
 
668
 
 
669
        /* setup tx ring */
 
670
 
 
671
        writel(BMCTL_TX1_DIS,olympic_mmio+BMCTL_RWM); /* Yes, this enables TX channel 1 */
 
672
        for(i=0;i<OLYMPIC_TX_RING_SIZE;i++) 
 
673
                olympic_priv->olympic_tx_ring[i].buffer=cpu_to_le32(0xdeadbeef);
 
674
 
 
675
        olympic_priv->free_tx_ring_entries=OLYMPIC_TX_RING_SIZE;
 
676
        olympic_priv->tx_ring_dma_addr = pci_map_single(olympic_priv->pdev,olympic_priv->olympic_tx_ring,
 
677
                                         sizeof(struct olympic_tx_desc) * OLYMPIC_TX_RING_SIZE,PCI_DMA_TODEVICE) ; 
 
678
        writel(olympic_priv->tx_ring_dma_addr, olympic_mmio+TXDESCQ_1);
 
679
        writel(olympic_priv->tx_ring_dma_addr, olympic_mmio+TXCDA_1);
 
680
        writew(OLYMPIC_TX_RING_SIZE, olympic_mmio+TXDESCQCNT_1);
 
681
        
 
682
        olympic_priv->tx_status_ring_dma_addr = pci_map_single(olympic_priv->pdev, olympic_priv->olympic_tx_status_ring,
 
683
                                                sizeof(struct olympic_tx_status) * OLYMPIC_TX_RING_SIZE, PCI_DMA_FROMDEVICE);
 
684
        writel(olympic_priv->tx_status_ring_dma_addr,olympic_mmio+TXSTATQ_1);
 
685
        writel(olympic_priv->tx_status_ring_dma_addr,olympic_mmio+TXCSA_1);
 
686
        writew(OLYMPIC_TX_RING_SIZE,olympic_mmio+TXSTATQCNT_1);
 
687
                
 
688
        olympic_priv->tx_ring_free=0; /* next entry in tx ring to use */
 
689
        olympic_priv->tx_ring_last_status=OLYMPIC_TX_RING_SIZE-1; /* last processed tx status */
 
690
 
 
691
        writel(0xffffffff, olympic_mmio+EISR_RWM) ; /* clean the eisr */
 
692
        writel(0,olympic_mmio+EISR) ; 
 
693
        writel(EISR_MASK_OPTIONS,olympic_mmio+EISR_MASK) ; /* enables most of the TX error interrupts */
 
694
        writel(SISR_TX1_EOF | SISR_ADAPTER_CHECK | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_ASB_FREE | SISR_ERR,olympic_mmio+SISR_MASK_SUM);
 
695
 
 
696
#if OLYMPIC_DEBUG 
 
697
        printk("BMCTL: %x\n",readl(olympic_mmio+BMCTL_SUM));
 
698
        printk("SISR MASK: %x\n",readl(olympic_mmio+SISR_MASK));
 
699
#endif
 
700
 
 
701
        if (olympic_priv->olympic_network_monitor) { 
 
702
                u8 __iomem *oat;
 
703
                u8 __iomem *opt;
 
704
                u8 addr[6];
 
705
                oat = (olympic_priv->olympic_lap + olympic_priv->olympic_addr_table_addr);
 
706
                opt = (olympic_priv->olympic_lap + olympic_priv->olympic_parms_addr);
 
707
 
 
708
                for (i = 0; i < 6; i++)
 
709
                        addr[i] = readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+i);
 
710
                printk("%s: Node Address: %pM\n", dev->name, addr);
 
711
                printk("%s: Functional Address: %02x:%02x:%02x:%02x\n",dev->name, 
 
712
                        readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)), 
 
713
                        readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+1),
 
714
                        readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+2),
 
715
                        readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+3));
 
716
 
 
717
                for (i = 0; i < 6; i++)
 
718
                        addr[i] = readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+i);
 
719
                printk("%s: NAUN Address: %pM\n", dev->name, addr);
 
720
        }
 
721
        
 
722
        netif_start_queue(dev);
 
723
        return 0;
 
724
 
 
725
out:
 
726
        free_irq(dev->irq, dev);
 
727
        return -EIO;
 
728
}       
 
729
 
 
730
/*
 
731
 *      When we enter the rx routine we do not know how many frames have been 
 
732
 *      queued on the rx channel.  Therefore we start at the next rx status
 
733
 *      position and travel around the receive ring until we have completed
 
734
 *      all the frames.
 
735
 *
 
736
 *      This means that we may process the frame before we receive the end
 
737
 *      of frame interrupt. This is why we always test the status instead
 
738
 *      of blindly processing the next frame.
 
739
 *
 
740
 *      We also remove the last 4 bytes from the packet as well, these are
 
741
 *      just token ring trailer info and upset protocols that don't check 
 
742
 *      their own length, i.e. SNA. 
 
743
 *      
 
744
 */
 
745
static void olympic_rx(struct net_device *dev)
 
746
{
 
747
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
748
        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
 
749
        struct olympic_rx_status *rx_status;
 
750
        struct olympic_rx_desc *rx_desc ; 
 
751
        int rx_ring_last_received,length, buffer_cnt, cpy_length, frag_len;
 
752
        struct sk_buff *skb, *skb2;
 
753
        int i;
 
754
 
 
755
        rx_status=&(olympic_priv->olympic_rx_status_ring[(olympic_priv->rx_status_last_received + 1) & (OLYMPIC_RX_RING_SIZE - 1)]) ; 
 
756
 
 
757
        while (rx_status->status_buffercnt) { 
 
758
                u32 l_status_buffercnt;
 
759
 
 
760
                olympic_priv->rx_status_last_received++ ;
 
761
                olympic_priv->rx_status_last_received &= (OLYMPIC_RX_RING_SIZE -1);
 
762
#if OLYMPIC_DEBUG
 
763
                printk("rx status: %x rx len: %x\n", le32_to_cpu(rx_status->status_buffercnt), le32_to_cpu(rx_status->fragmentcnt_framelen));
 
764
#endif
 
765
                length = le32_to_cpu(rx_status->fragmentcnt_framelen) & 0xffff;
 
766
                buffer_cnt = le32_to_cpu(rx_status->status_buffercnt) & 0xffff; 
 
767
                i = buffer_cnt ; /* Need buffer_cnt later for rxenq update */ 
 
768
                frag_len = le32_to_cpu(rx_status->fragmentcnt_framelen) >> 16; 
 
769
 
 
770
#if OLYMPIC_DEBUG 
 
771
                printk("length: %x, frag_len: %x, buffer_cnt: %x\n", length, frag_len, buffer_cnt);
 
772
#endif
 
773
                l_status_buffercnt = le32_to_cpu(rx_status->status_buffercnt);
 
774
                if(l_status_buffercnt & 0xC0000000) {
 
775
                        if (l_status_buffercnt & 0x3B000000) {
 
776
                                if (olympic_priv->olympic_message_level) {
 
777
                                        if (l_status_buffercnt & (1<<29))  /* Rx Frame Truncated */
 
778
                                                printk(KERN_WARNING "%s: Rx Frame Truncated\n",dev->name);
 
779
                                        if (l_status_buffercnt & (1<<28)) /*Rx receive overrun */
 
780
                                                printk(KERN_WARNING "%s: Rx Frame Receive overrun\n",dev->name);
 
781
                                        if (l_status_buffercnt & (1<<27)) /* No receive buffers */
 
782
                                                printk(KERN_WARNING "%s: No receive buffers\n",dev->name);
 
783
                                        if (l_status_buffercnt & (1<<25)) /* Receive frame error detect */
 
784
                                                printk(KERN_WARNING "%s: Receive frame error detect\n",dev->name);
 
785
                                        if (l_status_buffercnt & (1<<24)) /* Received Error Detect */
 
786
                                                printk(KERN_WARNING "%s: Received Error Detect\n",dev->name);
 
787
                                } 
 
788
                                olympic_priv->rx_ring_last_received += i ; 
 
789
                                olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1) ; 
 
790
                                dev->stats.rx_errors++;
 
791
                        } else {        
 
792
                        
 
793
                                if (buffer_cnt == 1) {
 
794
                                        skb = dev_alloc_skb(max_t(int, olympic_priv->pkt_buf_sz,length)) ; 
 
795
                                } else {
 
796
                                        skb = dev_alloc_skb(length) ; 
 
797
                                }
 
798
 
 
799
                                if (skb == NULL) {
 
800
                                        printk(KERN_WARNING "%s: Not enough memory to copy packet to upper layers.\n",dev->name) ;
 
801
                                        dev->stats.rx_dropped++;
 
802
                                        /* Update counters even though we don't transfer the frame */
 
803
                                        olympic_priv->rx_ring_last_received += i ; 
 
804
                                        olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1) ;  
 
805
                                } else  {
 
806
                                        /* Optimise based upon number of buffers used. 
 
807
                                           If only one buffer is used we can simply swap the buffers around.
 
808
                                           If more than one then we must use the new buffer and copy the information
 
809
                                           first. Ideally all frames would be in a single buffer, this can be tuned by
 
810
                                           altering the buffer size. If the length of the packet is less than
 
811
                                           1500 bytes we're going to copy it over anyway to stop packets getting
 
812
                                           dropped from sockets with buffers smaller than our pkt_buf_sz. */
 
813
                                
 
814
                                        if (buffer_cnt==1) {
 
815
                                                olympic_priv->rx_ring_last_received++ ; 
 
816
                                                olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
 
817
                                                rx_ring_last_received = olympic_priv->rx_ring_last_received ;
 
818
                                                if (length > 1500) { 
 
819
                                                        skb2=olympic_priv->rx_ring_skb[rx_ring_last_received] ; 
 
820
                                                        /* unmap buffer */
 
821
                                                        pci_unmap_single(olympic_priv->pdev,
 
822
                                                                le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer), 
 
823
                                                                olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ; 
 
824
                                                        skb_put(skb2,length-4);
 
825
                                                        skb2->protocol = tr_type_trans(skb2,dev);
 
826
                                                        olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer = 
 
827
                                                                cpu_to_le32(pci_map_single(olympic_priv->pdev, skb->data, 
 
828
                                                                olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
 
829
                                                        olympic_priv->olympic_rx_ring[rx_ring_last_received].res_length = 
 
830
                                                                cpu_to_le32(olympic_priv->pkt_buf_sz); 
 
831
                                                        olympic_priv->rx_ring_skb[rx_ring_last_received] = skb ; 
 
832
                                                        netif_rx(skb2) ; 
 
833
                                                } else { 
 
834
                                                        pci_dma_sync_single_for_cpu(olympic_priv->pdev,
 
835
                                                                le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 
836
                                                                olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ; 
 
837
                                                        skb_copy_from_linear_data(olympic_priv->rx_ring_skb[rx_ring_last_received],
 
838
                                                                      skb_put(skb,length - 4),
 
839
                                                                      length - 4);
 
840
                                                        pci_dma_sync_single_for_device(olympic_priv->pdev,
 
841
                                                                le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 
842
                                                                olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 
843
                                                        skb->protocol = tr_type_trans(skb,dev) ; 
 
844
                                                        netif_rx(skb) ; 
 
845
                                                } 
 
846
                                        } else {
 
847
                                                do { /* Walk the buffers */ 
 
848
                                                        olympic_priv->rx_ring_last_received++ ; 
 
849
                                                        olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
 
850
                                                        rx_ring_last_received = olympic_priv->rx_ring_last_received ; 
 
851
                                                        pci_dma_sync_single_for_cpu(olympic_priv->pdev,
 
852
                                                                le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 
853
                                                                olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ; 
 
854
                                                        rx_desc = &(olympic_priv->olympic_rx_ring[rx_ring_last_received]);
 
855
                                                        cpy_length = (i == 1 ? frag_len : le32_to_cpu(rx_desc->res_length)); 
 
856
                                                        skb_copy_from_linear_data(olympic_priv->rx_ring_skb[rx_ring_last_received],
 
857
                                                                      skb_put(skb, cpy_length),
 
858
                                                                      cpy_length);
 
859
                                                        pci_dma_sync_single_for_device(olympic_priv->pdev,
 
860
                                                                le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
 
861
                                                                olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
 
862
                                                } while (--i) ; 
 
863
                                                skb_trim(skb,skb->len-4) ; 
 
864
                                                skb->protocol = tr_type_trans(skb,dev);
 
865
                                                netif_rx(skb) ; 
 
866
                                        } 
 
867
                                        dev->stats.rx_packets++ ;
 
868
                                        dev->stats.rx_bytes += length ;
 
869
                                } /* if skb == null */
 
870
                        } /* If status & 0x3b */
 
871
 
 
872
                } else { /*if buffercnt & 0xC */
 
873
                        olympic_priv->rx_ring_last_received += i ; 
 
874
                        olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE - 1) ; 
 
875
                } 
 
876
 
 
877
                rx_status->fragmentcnt_framelen = 0 ; 
 
878
                rx_status->status_buffercnt = 0 ; 
 
879
                rx_status = &(olympic_priv->olympic_rx_status_ring[(olympic_priv->rx_status_last_received+1) & (OLYMPIC_RX_RING_SIZE -1) ]);
 
880
 
 
881
                writew((((readw(olympic_mmio+RXENQ)) & 0x8000) ^ 0x8000) |  buffer_cnt , olympic_mmio+RXENQ); 
 
882
        } /* while */
 
883
 
 
884
}
 
885
 
 
886
static void olympic_freemem(struct net_device *dev) 
 
887
{ 
 
888
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
889
        int i;
 
890
                        
 
891
        for(i=0;i<OLYMPIC_RX_RING_SIZE;i++) {
 
892
                if (olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received] != NULL) {
 
893
                        dev_kfree_skb_irq(olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received]);
 
894
                        olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received] = NULL;
 
895
                }
 
896
                if (olympic_priv->olympic_rx_ring[olympic_priv->rx_status_last_received].buffer != cpu_to_le32(0xdeadbeef)) {
 
897
                        pci_unmap_single(olympic_priv->pdev, 
 
898
                        le32_to_cpu(olympic_priv->olympic_rx_ring[olympic_priv->rx_status_last_received].buffer),
 
899
                        olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE);
 
900
                }
 
901
                olympic_priv->rx_status_last_received++;
 
902
                olympic_priv->rx_status_last_received&=OLYMPIC_RX_RING_SIZE-1;
 
903
        }
 
904
        /* unmap rings */
 
905
        pci_unmap_single(olympic_priv->pdev, olympic_priv->rx_status_ring_dma_addr, 
 
906
                sizeof(struct olympic_rx_status) * OLYMPIC_RX_RING_SIZE, PCI_DMA_FROMDEVICE);
 
907
        pci_unmap_single(olympic_priv->pdev, olympic_priv->rx_ring_dma_addr,
 
908
                sizeof(struct olympic_rx_desc) * OLYMPIC_RX_RING_SIZE, PCI_DMA_TODEVICE);
 
909
 
 
910
        pci_unmap_single(olympic_priv->pdev, olympic_priv->tx_status_ring_dma_addr, 
 
911
                sizeof(struct olympic_tx_status) * OLYMPIC_TX_RING_SIZE, PCI_DMA_FROMDEVICE);
 
912
        pci_unmap_single(olympic_priv->pdev, olympic_priv->tx_ring_dma_addr, 
 
913
                sizeof(struct olympic_tx_desc) * OLYMPIC_TX_RING_SIZE, PCI_DMA_TODEVICE);
 
914
 
 
915
        return ; 
 
916
}
 
917
 
 
918
static irqreturn_t olympic_interrupt(int irq, void *dev_id) 
 
919
{
 
920
        struct net_device *dev= (struct net_device *)dev_id;
 
921
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
922
        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
 
923
        u32 sisr;
 
924
        u8 __iomem *adapter_check_area ; 
 
925
        
 
926
        /* 
 
927
         *  Read sisr but don't reset it yet. 
 
928
         *  The indication bit may have been set but the interrupt latch
 
929
         *  bit may not be set, so we'd lose the interrupt later. 
 
930
         */ 
 
931
        sisr=readl(olympic_mmio+SISR) ; 
 
932
        if (!(sisr & SISR_MI)) /* Interrupt isn't for us */ 
 
933
                return IRQ_NONE;
 
934
        sisr=readl(olympic_mmio+SISR_RR) ;  /* Read & Reset sisr */ 
 
935
 
 
936
        spin_lock(&olympic_priv->olympic_lock);
 
937
 
 
938
        /* Hotswap gives us this on removal */
 
939
        if (sisr == 0xffffffff) { 
 
940
                printk(KERN_WARNING "%s: Hotswap adapter removal.\n",dev->name) ; 
 
941
                spin_unlock(&olympic_priv->olympic_lock) ; 
 
942
                return IRQ_NONE;
 
943
        } 
 
944
                
 
945
        if (sisr & (SISR_SRB_REPLY | SISR_TX1_EOF | SISR_RX_STATUS | SISR_ADAPTER_CHECK |  
 
946
                        SISR_ASB_FREE | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_RX_NOBUF | SISR_ERR)) {  
 
947
        
 
948
                /* If we ever get this the adapter is seriously dead. Only a reset is going to 
 
949
                 * bring it back to life. We're talking pci bus errors and such like :( */ 
 
950
                if((sisr & SISR_ERR) && (readl(olympic_mmio+EISR) & EISR_MASK_OPTIONS)) {
 
951
                        printk(KERN_ERR "Olympic: EISR Error, EISR=%08x\n",readl(olympic_mmio+EISR)) ; 
 
952
                        printk(KERN_ERR "The adapter must be reset to clear this condition.\n") ; 
 
953
                        printk(KERN_ERR "Please report this error to the driver maintainer and/\n") ; 
 
954
                        printk(KERN_ERR "or the linux-tr mailing list.\n") ; 
 
955
                        wake_up_interruptible(&olympic_priv->srb_wait);
 
956
                        spin_unlock(&olympic_priv->olympic_lock) ; 
 
957
                        return IRQ_HANDLED;
 
958
                } /* SISR_ERR */
 
959
 
 
960
                if(sisr & SISR_SRB_REPLY) {
 
961
                        if(olympic_priv->srb_queued==1) {
 
962
                                wake_up_interruptible(&olympic_priv->srb_wait);
 
963
                        } else if (olympic_priv->srb_queued==2) { 
 
964
                                olympic_srb_bh(dev) ; 
 
965
                        }
 
966
                        olympic_priv->srb_queued=0;
 
967
                } /* SISR_SRB_REPLY */
 
968
 
 
969
                /* We shouldn't ever miss the Tx interrupt, but the you never know, hence the loop to ensure
 
970
                   we get all tx completions. */
 
971
                if (sisr & SISR_TX1_EOF) {
 
972
                        while(olympic_priv->olympic_tx_status_ring[(olympic_priv->tx_ring_last_status + 1) & (OLYMPIC_TX_RING_SIZE-1)].status) { 
 
973
                                olympic_priv->tx_ring_last_status++;
 
974
                                olympic_priv->tx_ring_last_status &= (OLYMPIC_TX_RING_SIZE-1);
 
975
                                olympic_priv->free_tx_ring_entries++;
 
976
                                dev->stats.tx_bytes += olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]->len;
 
977
                                dev->stats.tx_packets++ ;
 
978
                                pci_unmap_single(olympic_priv->pdev, 
 
979
                                        le32_to_cpu(olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_last_status].buffer), 
 
980
                                        olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]->len,PCI_DMA_TODEVICE);
 
981
                                dev_kfree_skb_irq(olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]);
 
982
                                olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_last_status].buffer=cpu_to_le32(0xdeadbeef);
 
983
                                olympic_priv->olympic_tx_status_ring[olympic_priv->tx_ring_last_status].status=0;
 
984
                        }
 
985
                        netif_wake_queue(dev);
 
986
                } /* SISR_TX1_EOF */
 
987
        
 
988
                if (sisr & SISR_RX_STATUS) {
 
989
                        olympic_rx(dev);
 
990
                } /* SISR_RX_STATUS */
 
991
        
 
992
                if (sisr & SISR_ADAPTER_CHECK) {
 
993
                        netif_stop_queue(dev);
 
994
                        printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name);
 
995
                        writel(readl(olympic_mmio+LAPWWC),olympic_mmio+LAPA);
 
996
                        adapter_check_area = olympic_priv->olympic_lap + ((readl(olympic_mmio+LAPWWC)) & (~0xf800)) ;
 
997
                        printk(KERN_WARNING "%s: Bytes %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",dev->name, readb(adapter_check_area+0), readb(adapter_check_area+1), readb(adapter_check_area+2), readb(adapter_check_area+3), readb(adapter_check_area+4), readb(adapter_check_area+5), readb(adapter_check_area+6), readb(adapter_check_area+7)) ; 
 
998
                        spin_unlock(&olympic_priv->olympic_lock) ; 
 
999
                        return IRQ_HANDLED; 
 
1000
                } /* SISR_ADAPTER_CHECK */
 
1001
        
 
1002
                if (sisr & SISR_ASB_FREE) {
 
1003
                        /* Wake up anything that is waiting for the asb response */  
 
1004
                        if (olympic_priv->asb_queued) {
 
1005
                                olympic_asb_bh(dev) ; 
 
1006
                        }
 
1007
                } /* SISR_ASB_FREE */
 
1008
        
 
1009
                if (sisr & SISR_ARB_CMD) {
 
1010
                        olympic_arb_cmd(dev) ; 
 
1011
                } /* SISR_ARB_CMD */
 
1012
        
 
1013
                if (sisr & SISR_TRB_REPLY) {
 
1014
                        /* Wake up anything that is waiting for the trb response */
 
1015
                        if (olympic_priv->trb_queued) {
 
1016
                                wake_up_interruptible(&olympic_priv->trb_wait);
 
1017
                        }
 
1018
                        olympic_priv->trb_queued = 0 ; 
 
1019
                } /* SISR_TRB_REPLY */  
 
1020
        
 
1021
                if (sisr & SISR_RX_NOBUF) {
 
1022
                        /* According to the documentation, we don't have to do anything, but trapping it keeps it out of
 
1023
                                   /var/log/messages.  */
 
1024
                } /* SISR_RX_NOBUF */
 
1025
        } else { 
 
1026
                printk(KERN_WARNING "%s: Unexpected interrupt: %x\n",dev->name, sisr);
 
1027
                printk(KERN_WARNING "%s: SISR_MASK: %x\n",dev->name, readl(olympic_mmio+SISR_MASK)) ;
 
1028
        } /* One if the interrupts we want */
 
1029
        writel(SISR_MI,olympic_mmio+SISR_MASK_SUM);
 
1030
        
 
1031
        spin_unlock(&olympic_priv->olympic_lock) ; 
 
1032
        return IRQ_HANDLED;
 
1033
}       
 
1034
 
 
1035
static netdev_tx_t olympic_xmit(struct sk_buff *skb,
 
1036
                                      struct net_device *dev)
 
1037
{
 
1038
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
1039
        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
 
1040
        unsigned long flags ; 
 
1041
 
 
1042
        spin_lock_irqsave(&olympic_priv->olympic_lock, flags);
 
1043
 
 
1044
        netif_stop_queue(dev);
 
1045
        
 
1046
        if(olympic_priv->free_tx_ring_entries) {
 
1047
                olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_free].buffer = 
 
1048
                        cpu_to_le32(pci_map_single(olympic_priv->pdev, skb->data, skb->len,PCI_DMA_TODEVICE));
 
1049
                olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_free].status_length = cpu_to_le32(skb->len | (0x80000000));
 
1050
                olympic_priv->tx_ring_skb[olympic_priv->tx_ring_free]=skb;
 
1051
                olympic_priv->free_tx_ring_entries--;
 
1052
 
 
1053
                olympic_priv->tx_ring_free++;
 
1054
                olympic_priv->tx_ring_free &= (OLYMPIC_TX_RING_SIZE-1);
 
1055
                writew((((readw(olympic_mmio+TXENQ_1)) & 0x8000) ^ 0x8000) | 1,olympic_mmio+TXENQ_1);
 
1056
                netif_wake_queue(dev);
 
1057
                spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
 
1058
                return NETDEV_TX_OK;
 
1059
        } else {
 
1060
                spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
 
1061
                return NETDEV_TX_BUSY;
 
1062
        } 
 
1063
 
 
1064
}
 
1065
        
 
1066
 
 
1067
static int olympic_close(struct net_device *dev) 
 
1068
{
 
1069
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
1070
        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio,*srb;
 
1071
        unsigned long t,flags;
 
1072
 
 
1073
        DECLARE_WAITQUEUE(wait,current) ; 
 
1074
 
 
1075
        netif_stop_queue(dev);
 
1076
        
 
1077
        writel(olympic_priv->srb,olympic_mmio+LAPA);
 
1078
        srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
 
1079
        
 
1080
        writeb(SRB_CLOSE_ADAPTER,srb+0);
 
1081
        writeb(0,srb+1);
 
1082
        writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
 
1083
 
 
1084
        add_wait_queue(&olympic_priv->srb_wait,&wait) ;
 
1085
        set_current_state(TASK_INTERRUPTIBLE) ; 
 
1086
 
 
1087
        spin_lock_irqsave(&olympic_priv->olympic_lock,flags);
 
1088
        olympic_priv->srb_queued=1;
 
1089
 
 
1090
        writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 
1091
        spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
 
1092
 
 
1093
        while(olympic_priv->srb_queued) {
 
1094
 
 
1095
                t = schedule_timeout_interruptible(60*HZ);
 
1096
 
 
1097
                if(signal_pending(current))     {            
 
1098
                        printk(KERN_WARNING "%s: SRB timed out.\n",dev->name);
 
1099
                        printk(KERN_WARNING "SISR=%x MISR=%x\n",readl(olympic_mmio+SISR),readl(olympic_mmio+LISR));
 
1100
                        olympic_priv->srb_queued=0;
 
1101
                        break;
 
1102
                }
 
1103
 
 
1104
                if (t == 0) { 
 
1105
                        printk(KERN_WARNING "%s: SRB timed out. May not be fatal.\n",dev->name);
 
1106
                } 
 
1107
                olympic_priv->srb_queued=0;
 
1108
        }
 
1109
        remove_wait_queue(&olympic_priv->srb_wait,&wait) ; 
 
1110
 
 
1111
        olympic_priv->rx_status_last_received++;
 
1112
        olympic_priv->rx_status_last_received&=OLYMPIC_RX_RING_SIZE-1;
 
1113
 
 
1114
        olympic_freemem(dev) ;  
 
1115
 
 
1116
        /* reset tx/rx fifo's and busmaster logic */
 
1117
 
 
1118
        writel(readl(olympic_mmio+BCTL)|(3<<13),olympic_mmio+BCTL);
 
1119
        udelay(1);
 
1120
        writel(readl(olympic_mmio+BCTL)&~(3<<13),olympic_mmio+BCTL);
 
1121
 
 
1122
#if OLYMPIC_DEBUG
 
1123
        {
 
1124
        int i ; 
 
1125
        printk("srb(%p): ",srb);
 
1126
        for(i=0;i<4;i++)
 
1127
                printk("%x ",readb(srb+i));
 
1128
        printk("\n");
 
1129
        }
 
1130
#endif
 
1131
        free_irq(dev->irq,dev);
 
1132
 
 
1133
        return 0;
 
1134
        
 
1135
}
 
1136
 
 
1137
static void olympic_set_rx_mode(struct net_device *dev) 
 
1138
{
 
1139
        struct olympic_private *olympic_priv = netdev_priv(dev);
 
1140
        u8 __iomem *olympic_mmio = olympic_priv->olympic_mmio ; 
 
1141
        u8 options = 0; 
 
1142
        u8 __iomem *srb;
 
1143
        struct netdev_hw_addr *ha;
 
1144
        unsigned char dev_mc_address[4] ; 
 
1145
 
 
1146
        writel(olympic_priv->srb,olympic_mmio+LAPA);
 
1147
        srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
 
1148
        options = olympic_priv->olympic_copy_all_options; 
 
1149
 
 
1150
        if (dev->flags&IFF_PROMISC)  
 
1151
                options |= 0x61 ;
 
1152
        else
 
1153
                options &= ~0x61 ; 
 
1154
 
 
1155
        /* Only issue the srb if there is a change in options */
 
1156
 
 
1157
        if ((options ^ olympic_priv->olympic_copy_all_options)) { 
 
1158
        
 
1159
                /* Now to issue the srb command to alter the copy.all.options */
 
1160
        
 
1161
                writeb(SRB_MODIFY_RECEIVE_OPTIONS,srb);
 
1162
                writeb(0,srb+1);
 
1163
                writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
 
1164
                writeb(0,srb+3);
 
1165
                writeb(olympic_priv->olympic_receive_options,srb+4);
 
1166
                writeb(options,srb+5);
 
1167
 
 
1168
                olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
 
1169
 
 
1170
                writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 
1171
 
 
1172
                olympic_priv->olympic_copy_all_options = options ;
 
1173
                
 
1174
                return ;  
 
1175
        } 
 
1176
 
 
1177
        /* Set the functional addresses we need for multicast */
 
1178
 
 
1179
        dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ; 
 
1180
 
 
1181
        netdev_for_each_mc_addr(ha, dev) {
 
1182
                dev_mc_address[0] |= ha->addr[2];
 
1183
                dev_mc_address[1] |= ha->addr[3];
 
1184
                dev_mc_address[2] |= ha->addr[4];
 
1185
                dev_mc_address[3] |= ha->addr[5];
 
1186
        }
 
1187
 
 
1188
        writeb(SRB_SET_FUNC_ADDRESS,srb+0);
 
1189
        writeb(0,srb+1);
 
1190
        writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
 
1191
        writeb(0,srb+3);
 
1192
        writeb(0,srb+4);
 
1193
        writeb(0,srb+5);
 
1194
        writeb(dev_mc_address[0],srb+6);
 
1195
        writeb(dev_mc_address[1],srb+7);
 
1196
        writeb(dev_mc_address[2],srb+8);
 
1197
        writeb(dev_mc_address[3],srb+9);
 
1198
 
 
1199
        olympic_priv->srb_queued = 2 ;
 
1200
        writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 
1201
 
 
1202
}
 
1203
 
 
1204
static void olympic_srb_bh(struct net_device *dev) 
 
1205
{ 
 
1206
        struct olympic_private *olympic_priv = netdev_priv(dev);
 
1207
        u8 __iomem *olympic_mmio = olympic_priv->olympic_mmio ; 
 
1208
        u8 __iomem *srb;
 
1209
 
 
1210
        writel(olympic_priv->srb,olympic_mmio+LAPA);
 
1211
        srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
 
1212
 
 
1213
        switch (readb(srb)) { 
 
1214
 
 
1215
                /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous) 
 
1216
                 * At some point we should do something if we get an error, such as
 
1217
                 * resetting the IFF_PROMISC flag in dev
 
1218
                 */
 
1219
 
 
1220
                case SRB_MODIFY_RECEIVE_OPTIONS:
 
1221
                        switch (readb(srb+2)) { 
 
1222
                                case 0x01:
 
1223
                                        printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name) ; 
 
1224
                                        break ; 
 
1225
                                case 0x04:
 
1226
                                        printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name);
 
1227
                                        break ; 
 
1228
                                default:
 
1229
                                        if (olympic_priv->olympic_message_level) 
 
1230
                                                printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",dev->name,olympic_priv->olympic_copy_all_options, olympic_priv->olympic_receive_options) ; 
 
1231
                                        break ;         
 
1232
                        } /* switch srb[2] */ 
 
1233
                        break ;
 
1234
                
 
1235
                /* SRB_SET_GROUP_ADDRESS - Multicast group setting 
 
1236
                 */
 
1237
 
 
1238
                case SRB_SET_GROUP_ADDRESS:
 
1239
                        switch (readb(srb+2)) { 
 
1240
                                case 0x00:
 
1241
                                        break ; 
 
1242
                                case 0x01:
 
1243
                                        printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name);
 
1244
                                        break ;
 
1245
                                case 0x04:
 
1246
                                        printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name); 
 
1247
                                        break ;
 
1248
                                case 0x3c:
 
1249
                                        printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n",dev->name) ; 
 
1250
                                        break ;
 
1251
                                case 0x3e: /* If we ever implement individual multicast addresses, will need to deal with this */
 
1252
                                        printk(KERN_WARNING "%s: Group address registers full\n",dev->name) ; 
 
1253
                                        break ;  
 
1254
                                case 0x55:
 
1255
                                        printk(KERN_INFO "%s: Group Address already set.\n",dev->name) ; 
 
1256
                                        break ;
 
1257
                                default:
 
1258
                                        break ; 
 
1259
                        } /* switch srb[2] */ 
 
1260
                        break ; 
 
1261
 
 
1262
                /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
 
1263
                 */
 
1264
 
 
1265
                case SRB_RESET_GROUP_ADDRESS:
 
1266
                        switch (readb(srb+2)) { 
 
1267
                                case 0x00:
 
1268
                                        break ; 
 
1269
                                case 0x01:
 
1270
                                        printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name);
 
1271
                                        break ; 
 
1272
                                case 0x04:
 
1273
                                        printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ; 
 
1274
                                        break ; 
 
1275
                                case 0x39: /* Must deal with this if individual multicast addresses used */
 
1276
                                        printk(KERN_INFO "%s: Group address not found\n",dev->name);
 
1277
                                        break ;
 
1278
                                default:
 
1279
                                        break ; 
 
1280
                        } /* switch srb[2] */
 
1281
                        break ; 
 
1282
 
 
1283
                
 
1284
                /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode 
 
1285
                 */
 
1286
 
 
1287
                case SRB_SET_FUNC_ADDRESS:
 
1288
                        switch (readb(srb+2)) { 
 
1289
                                case 0x00:
 
1290
                                        if (olympic_priv->olympic_message_level)
 
1291
                                                printk(KERN_INFO "%s: Functional Address Mask Set\n",dev->name);
 
1292
                                        break ;
 
1293
                                case 0x01:
 
1294
                                        printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name);
 
1295
                                        break ; 
 
1296
                                case 0x04:
 
1297
                                        printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ; 
 
1298
                                        break ; 
 
1299
                                default:
 
1300
                                        break ; 
 
1301
                        } /* switch srb[2] */
 
1302
                        break ; 
 
1303
        
 
1304
                /* SRB_READ_LOG - Read and reset the adapter error counters
 
1305
                 */
 
1306
 
 
1307
                case SRB_READ_LOG:
 
1308
                        switch (readb(srb+2)) { 
 
1309
                                case 0x00: 
 
1310
                                        if (olympic_priv->olympic_message_level) 
 
1311
                                                printk(KERN_INFO "%s: Read Log issued\n",dev->name) ; 
 
1312
                                        break ; 
 
1313
                                case 0x01:
 
1314
                                        printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name);
 
1315
                                        break ; 
 
1316
                                case 0x04:
 
1317
                                        printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ; 
 
1318
                                        break ; 
 
1319
                        
 
1320
                        } /* switch srb[2] */
 
1321
                        break ; 
 
1322
                
 
1323
                /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
 
1324
 
 
1325
                case SRB_READ_SR_COUNTERS:
 
1326
                        switch (readb(srb+2)) { 
 
1327
                                case 0x00: 
 
1328
                                        if (olympic_priv->olympic_message_level) 
 
1329
                                                printk(KERN_INFO "%s: Read Source Routing Counters issued\n",dev->name) ; 
 
1330
                                        break ; 
 
1331
                                case 0x01:
 
1332
                                        printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name);
 
1333
                                        break ; 
 
1334
                                case 0x04:
 
1335
                                        printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ; 
 
1336
                                        break ; 
 
1337
                                default:
 
1338
                                        break ; 
 
1339
                        } /* switch srb[2] */
 
1340
                        break ;
 
1341
 
 
1342
                default:
 
1343
                        printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n",dev->name);
 
1344
                        break ; 
 
1345
        } /* switch srb[0] */
 
1346
 
 
1347
} 
 
1348
 
 
1349
static int olympic_set_mac_address (struct net_device *dev, void *addr) 
 
1350
{
 
1351
        struct sockaddr *saddr = addr ; 
 
1352
        struct olympic_private *olympic_priv = netdev_priv(dev);
 
1353
 
 
1354
        if (netif_running(dev)) { 
 
1355
                printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name) ; 
 
1356
                return -EIO ; 
 
1357
        }
 
1358
 
 
1359
        memcpy(olympic_priv->olympic_laa, saddr->sa_data,dev->addr_len) ; 
 
1360
        
 
1361
        if (olympic_priv->olympic_message_level) { 
 
1362
                printk(KERN_INFO "%s: MAC/LAA Set to  = %x.%x.%x.%x.%x.%x\n",dev->name, olympic_priv->olympic_laa[0],
 
1363
                olympic_priv->olympic_laa[1], olympic_priv->olympic_laa[2],
 
1364
                olympic_priv->olympic_laa[3], olympic_priv->olympic_laa[4],
 
1365
                olympic_priv->olympic_laa[5]);
 
1366
        } 
 
1367
 
 
1368
        return 0 ; 
 
1369
}
 
1370
 
 
1371
static void olympic_arb_cmd(struct net_device *dev)
 
1372
{
 
1373
        struct olympic_private *olympic_priv = netdev_priv(dev);
 
1374
        u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
 
1375
        u8 __iomem *arb_block, *asb_block, *srb  ; 
 
1376
        u8 header_len ; 
 
1377
        u16 frame_len, buffer_len ;
 
1378
        struct sk_buff *mac_frame ;  
 
1379
        u8 __iomem *buf_ptr ;
 
1380
        u8 __iomem *frame_data ;  
 
1381
        u16 buff_off ; 
 
1382
        u16 lan_status = 0, lan_status_diff  ; /* Initialize to stop compiler warning */
 
1383
        u8 fdx_prot_error ; 
 
1384
        u16 next_ptr;
 
1385
 
 
1386
        arb_block = (olympic_priv->olympic_lap + olympic_priv->arb) ; 
 
1387
        asb_block = (olympic_priv->olympic_lap + olympic_priv->asb) ; 
 
1388
        srb = (olympic_priv->olympic_lap + olympic_priv->srb) ; 
 
1389
        
 
1390
        if (readb(arb_block+0) == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
 
1391
 
 
1392
                header_len = readb(arb_block+8) ; /* 802.5 Token-Ring Header Length */  
 
1393
                frame_len = swab16(readw(arb_block + 10)) ; 
 
1394
 
 
1395
                buff_off = swab16(readw(arb_block + 6)) ;
 
1396
                
 
1397
                buf_ptr = olympic_priv->olympic_lap + buff_off ; 
 
1398
 
 
1399
#if OLYMPIC_DEBUG
 
1400
{
 
1401
                int i;
 
1402
                frame_data = buf_ptr+offsetof(struct mac_receive_buffer,frame_data) ; 
 
1403
 
 
1404
                for (i=0 ;  i < 14 ; i++) { 
 
1405
                        printk("Loc %d = %02x\n",i,readb(frame_data + i)); 
 
1406
                }
 
1407
 
 
1408
                printk("next %04x, fs %02x, len %04x\n",readw(buf_ptr+offsetof(struct mac_receive_buffer,next)), readb(buf_ptr+offsetof(struct mac_receive_buffer,frame_status)), readw(buf_ptr+offsetof(struct mac_receive_buffer,buffer_length)));
 
1409
}
 
1410
#endif 
 
1411
                mac_frame = dev_alloc_skb(frame_len) ; 
 
1412
                if (!mac_frame) {
 
1413
                        printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n", dev->name);
 
1414
                        goto drop_frame;
 
1415
                }
 
1416
 
 
1417
                /* Walk the buffer chain, creating the frame */
 
1418
 
 
1419
                do {
 
1420
                        frame_data = buf_ptr+offsetof(struct mac_receive_buffer,frame_data) ; 
 
1421
                        buffer_len = swab16(readw(buf_ptr+offsetof(struct mac_receive_buffer,buffer_length))); 
 
1422
                        memcpy_fromio(skb_put(mac_frame, buffer_len), frame_data , buffer_len ) ;
 
1423
                        next_ptr=readw(buf_ptr+offsetof(struct mac_receive_buffer,next)); 
 
1424
                } while (next_ptr && (buf_ptr=olympic_priv->olympic_lap + swab16(next_ptr)));
 
1425
 
 
1426
                mac_frame->protocol = tr_type_trans(mac_frame, dev);
 
1427
 
 
1428
                if (olympic_priv->olympic_network_monitor) { 
 
1429
                        struct trh_hdr *mac_hdr;
 
1430
                        printk(KERN_WARNING "%s: Received MAC Frame, details:\n",dev->name);
 
1431
                        mac_hdr = tr_hdr(mac_frame);
 
1432
                        printk(KERN_WARNING "%s: MAC Frame Dest. Addr: %pM\n",
 
1433
                               dev->name, mac_hdr->daddr);
 
1434
                        printk(KERN_WARNING "%s: MAC Frame Srce. Addr: %pM\n",
 
1435
                               dev->name, mac_hdr->saddr);
 
1436
                }
 
1437
                netif_rx(mac_frame);
 
1438
 
 
1439
drop_frame:
 
1440
                /* Now tell the card we have dealt with the received frame */
 
1441
 
 
1442
                /* Set LISR Bit 1 */
 
1443
                writel(LISR_ARB_FREE,olympic_priv->olympic_mmio + LISR_SUM);
 
1444
 
 
1445
                /* Is the ASB free ? */         
 
1446
                
 
1447
                if (readb(asb_block + 2) != 0xff) { 
 
1448
                        olympic_priv->asb_queued = 1 ; 
 
1449
                        writel(LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM); 
 
1450
                        return ;        
 
1451
                        /* Drop out and wait for the bottom half to be run */
 
1452
                }
 
1453
                
 
1454
                writeb(ASB_RECEIVE_DATA,asb_block); /* Receive data */
 
1455
                writeb(OLYMPIC_CLEAR_RET_CODE,asb_block+2); /* Necessary ?? */
 
1456
                writeb(readb(arb_block+6),asb_block+6); /* Must send the address back to the adapter */
 
1457
                writeb(readb(arb_block+7),asb_block+7); /* To let it know we have dealt with the data */                
 
1458
 
 
1459
                writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
 
1460
                
 
1461
                olympic_priv->asb_queued = 2 ; 
 
1462
        
 
1463
                return ;        
 
1464
                
 
1465
        } else if (readb(arb_block) == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
 
1466
                lan_status = swab16(readw(arb_block+6));
 
1467
                fdx_prot_error = readb(arb_block+8) ; 
 
1468
                
 
1469
                /* Issue ARB Free */
 
1470
                writel(LISR_ARB_FREE,olympic_priv->olympic_mmio+LISR_SUM);
 
1471
 
 
1472
                lan_status_diff = olympic_priv->olympic_lan_status ^ lan_status ; 
 
1473
 
 
1474
                if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR) ) { 
 
1475
                        if (lan_status_diff & LSC_LWF) 
 
1476
                                        printk(KERN_WARNING "%s: Short circuit detected on the lobe\n",dev->name);
 
1477
                        if (lan_status_diff & LSC_ARW) 
 
1478
                                        printk(KERN_WARNING "%s: Auto removal error\n",dev->name);
 
1479
                        if (lan_status_diff & LSC_FPE)
 
1480
                                        printk(KERN_WARNING "%s: FDX Protocol Error\n",dev->name);
 
1481
                        if (lan_status_diff & LSC_RR) 
 
1482
                                        printk(KERN_WARNING "%s: Force remove MAC frame received\n",dev->name);
 
1483
                
 
1484
                        /* Adapter has been closed by the hardware */
 
1485
                
 
1486
                        /* reset tx/rx fifo's and busmaster logic */
 
1487
 
 
1488
                        writel(readl(olympic_mmio+BCTL)|(3<<13),olympic_mmio+BCTL);
 
1489
                        udelay(1);
 
1490
                        writel(readl(olympic_mmio+BCTL)&~(3<<13),olympic_mmio+BCTL);
 
1491
                        netif_stop_queue(dev);
 
1492
                        olympic_priv->srb = readw(olympic_priv->olympic_lap + LAPWWO) ; 
 
1493
                        printk(KERN_WARNING "%s: Adapter has been closed\n", dev->name);
 
1494
                } /* If serious error */
 
1495
                
 
1496
                if (olympic_priv->olympic_message_level) { 
 
1497
                        if (lan_status_diff & LSC_SIG_LOSS) 
 
1498
                                        printk(KERN_WARNING "%s: No receive signal detected\n", dev->name);
 
1499
                        if (lan_status_diff & LSC_HARD_ERR)
 
1500
                                        printk(KERN_INFO "%s: Beaconing\n",dev->name);
 
1501
                        if (lan_status_diff & LSC_SOFT_ERR)
 
1502
                                        printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame\n",dev->name);
 
1503
                        if (lan_status_diff & LSC_TRAN_BCN) 
 
1504
                                        printk(KERN_INFO "%s: We are transmitting the beacon, aaah\n",dev->name);
 
1505
                        if (lan_status_diff & LSC_SS) 
 
1506
                                        printk(KERN_INFO "%s: Single Station on the ring\n", dev->name);
 
1507
                        if (lan_status_diff & LSC_RING_REC)
 
1508
                                        printk(KERN_INFO "%s: Ring recovery ongoing\n",dev->name);
 
1509
                        if (lan_status_diff & LSC_FDX_MODE)
 
1510
                                        printk(KERN_INFO "%s: Operating in FDX mode\n",dev->name);
 
1511
                }       
 
1512
                
 
1513
                if (lan_status_diff & LSC_CO) { 
 
1514
                                        
 
1515
                                if (olympic_priv->olympic_message_level) 
 
1516
                                        printk(KERN_INFO "%s: Counter Overflow\n", dev->name);
 
1517
                                        
 
1518
                                /* Issue READ.LOG command */
 
1519
 
 
1520
                                writeb(SRB_READ_LOG, srb);
 
1521
                                writeb(0,srb+1);
 
1522
                                writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
 
1523
                                writeb(0,srb+3);
 
1524
                                writeb(0,srb+4);
 
1525
                                writeb(0,srb+5);
 
1526
                                        
 
1527
                                olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
 
1528
 
 
1529
                                writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 
1530
                                        
 
1531
                }
 
1532
 
 
1533
                if (lan_status_diff & LSC_SR_CO) { 
 
1534
 
 
1535
                                if (olympic_priv->olympic_message_level)
 
1536
                                        printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
 
1537
 
 
1538
                                /* Issue a READ.SR.COUNTERS */
 
1539
                                
 
1540
                                writeb(SRB_READ_SR_COUNTERS,srb);
 
1541
                                writeb(0,srb+1);
 
1542
                                writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
 
1543
                                writeb(0,srb+3);
 
1544
                                
 
1545
                                olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
 
1546
 
 
1547
                                writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
 
1548
 
 
1549
                }
 
1550
 
 
1551
                olympic_priv->olympic_lan_status = lan_status ; 
 
1552
        
 
1553
        }  /* Lan.change.status */
 
1554
        else
 
1555
                printk(KERN_WARNING "%s: Unknown arb command\n", dev->name);
 
1556
}
 
1557
 
 
1558
static void olympic_asb_bh(struct net_device *dev) 
 
1559
{
 
1560
        struct olympic_private *olympic_priv = netdev_priv(dev);
 
1561
        u8 __iomem *arb_block, *asb_block ; 
 
1562
 
 
1563
        arb_block = (olympic_priv->olympic_lap + olympic_priv->arb) ; 
 
1564
        asb_block = (olympic_priv->olympic_lap + olympic_priv->asb) ; 
 
1565
 
 
1566
        if (olympic_priv->asb_queued == 1) {   /* Dropped through the first time */
 
1567
 
 
1568
                writeb(ASB_RECEIVE_DATA,asb_block); /* Receive data */
 
1569
                writeb(OLYMPIC_CLEAR_RET_CODE,asb_block+2); /* Necessary ?? */
 
1570
                writeb(readb(arb_block+6),asb_block+6); /* Must send the address back to the adapter */
 
1571
                writeb(readb(arb_block+7),asb_block+7); /* To let it know we have dealt with the data */                
 
1572
 
 
1573
                writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
 
1574
                olympic_priv->asb_queued = 2 ; 
 
1575
 
 
1576
                return ; 
 
1577
        }
 
1578
 
 
1579
        if (olympic_priv->asb_queued == 2) { 
 
1580
                switch (readb(asb_block+2)) {
 
1581
                        case 0x01:
 
1582
                                printk(KERN_WARNING "%s: Unrecognized command code\n", dev->name);
 
1583
                                break ;
 
1584
                        case 0x26:
 
1585
                                printk(KERN_WARNING "%s: Unrecognized buffer address\n", dev->name);
 
1586
                                break ;
 
1587
                        case 0xFF:
 
1588
                                /* Valid response, everything should be ok again */
 
1589
                                break ;
 
1590
                        default:
 
1591
                                printk(KERN_WARNING "%s: Invalid return code in asb\n",dev->name);
 
1592
                                break ;
 
1593
                }
 
1594
        }
 
1595
        olympic_priv->asb_queued = 0 ; 
 
1596
}
 
1597
 
 
1598
static int olympic_change_mtu(struct net_device *dev, int mtu) 
 
1599
{
 
1600
        struct olympic_private *olympic_priv = netdev_priv(dev);
 
1601
        u16 max_mtu ; 
 
1602
 
 
1603
        if (olympic_priv->olympic_ring_speed == 4)
 
1604
                max_mtu = 4500 ; 
 
1605
        else
 
1606
                max_mtu = 18000 ; 
 
1607
        
 
1608
        if (mtu > max_mtu)
 
1609
                return -EINVAL ; 
 
1610
        if (mtu < 100) 
 
1611
                return -EINVAL ; 
 
1612
 
 
1613
        dev->mtu = mtu ; 
 
1614
        olympic_priv->pkt_buf_sz = mtu + TR_HLEN ; 
 
1615
 
 
1616
        return 0 ; 
 
1617
}
 
1618
 
 
1619
static int olympic_proc_show(struct seq_file *m, void *v)
 
1620
{
 
1621
        struct net_device *dev = m->private;
 
1622
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
1623
        u8 __iomem *oat = (olympic_priv->olympic_lap + olympic_priv->olympic_addr_table_addr) ; 
 
1624
        u8 __iomem *opt = (olympic_priv->olympic_lap + olympic_priv->olympic_parms_addr) ; 
 
1625
        u8 addr[6];
 
1626
        u8 addr2[6];
 
1627
        int i;
 
1628
 
 
1629
        seq_printf(m,
 
1630
                "IBM Pit/Pit-Phy/Olympic Chipset Token Ring Adapter %s\n",dev->name);
 
1631
        seq_printf(m, "\n%6s: Adapter Address   : Node Address      : Functional Addr\n",
 
1632
           dev->name); 
 
1633
 
 
1634
        for (i = 0 ; i < 6 ; i++)
 
1635
                addr[i] = readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr) + i);
 
1636
 
 
1637
        seq_printf(m, "%6s: %pM : %pM : %02x:%02x:%02x:%02x\n",
 
1638
           dev->name,
 
1639
           dev->dev_addr, addr,
 
1640
           readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)), 
 
1641
           readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+1),
 
1642
           readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+2),
 
1643
           readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+3));
 
1644
         
 
1645
        seq_printf(m, "\n%6s: Token Ring Parameters Table:\n", dev->name);
 
1646
 
 
1647
        seq_printf(m, "%6s: Physical Addr : Up Node Address   : Poll Address      : AccPri : Auth Src : Att Code :\n",
 
1648
          dev->name) ; 
 
1649
 
 
1650
        for (i = 0 ; i < 6 ; i++)
 
1651
                addr[i] = readb(opt+offsetof(struct olympic_parameters_table, up_node_addr) + i);
 
1652
        for (i = 0 ; i < 6 ; i++)
 
1653
                addr2[i] =  readb(opt+offsetof(struct olympic_parameters_table, poll_addr) + i);
 
1654
 
 
1655
        seq_printf(m, "%6s: %02x:%02x:%02x:%02x   : %pM : %pM : %04x   : %04x     :  %04x    :\n",
 
1656
          dev->name,
 
1657
          readb(opt+offsetof(struct olympic_parameters_table, phys_addr)),
 
1658
          readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+1),
 
1659
          readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+2),
 
1660
          readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+3),
 
1661
          addr, addr2,
 
1662
          swab16(readw(opt+offsetof(struct olympic_parameters_table, acc_priority))),
 
1663
          swab16(readw(opt+offsetof(struct olympic_parameters_table, auth_source_class))),
 
1664
          swab16(readw(opt+offsetof(struct olympic_parameters_table, att_code))));
 
1665
 
 
1666
        seq_printf(m, "%6s: Source Address    : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n",
 
1667
          dev->name) ; 
 
1668
        
 
1669
        for (i = 0 ; i < 6 ; i++)
 
1670
                addr[i] = readb(opt+offsetof(struct olympic_parameters_table, source_addr) + i);
 
1671
        seq_printf(m, "%6s: %pM : %04x  : %04x   : %04x   : %04x   : %04x    :     %04x     : \n",
 
1672
          dev->name, addr,
 
1673
          swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_type))),
 
1674
          swab16(readw(opt+offsetof(struct olympic_parameters_table, major_vector))),
 
1675
          swab16(readw(opt+offsetof(struct olympic_parameters_table, lan_status))),
 
1676
          swab16(readw(opt+offsetof(struct olympic_parameters_table, local_ring))),
 
1677
          swab16(readw(opt+offsetof(struct olympic_parameters_table, mon_error))),
 
1678
          swab16(readw(opt+offsetof(struct olympic_parameters_table, frame_correl))));
 
1679
 
 
1680
        seq_printf(m, "%6s: Beacon Details :  Tx  :  Rx  : NAUN Node Address : NAUN Node Phys : \n",
 
1681
          dev->name) ; 
 
1682
 
 
1683
        for (i = 0 ; i < 6 ; i++)
 
1684
                addr[i] = readb(opt+offsetof(struct olympic_parameters_table, beacon_naun) + i);
 
1685
        seq_printf(m, "%6s:                :  %02x  :  %02x  : %pM : %02x:%02x:%02x:%02x    : \n",
 
1686
          dev->name,
 
1687
          swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_transmit))),
 
1688
          swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_receive))),
 
1689
          addr,
 
1690
          readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)),
 
1691
          readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+1),
 
1692
          readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+2),
 
1693
          readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+3));
 
1694
 
 
1695
        return 0;
 
1696
}
 
1697
 
 
1698
static int olympic_proc_open(struct inode *inode, struct file *file)
 
1699
{
 
1700
        return single_open(file, olympic_proc_show, PDE(inode)->data);
 
1701
}
 
1702
 
 
1703
static const struct file_operations olympic_proc_ops = {
 
1704
        .open           = olympic_proc_open,
 
1705
        .read           = seq_read,
 
1706
        .llseek         = seq_lseek,
 
1707
        .release        = single_release,
 
1708
};
 
1709
 
 
1710
static void __devexit olympic_remove_one(struct pci_dev *pdev) 
 
1711
{
 
1712
        struct net_device *dev = pci_get_drvdata(pdev) ; 
 
1713
        struct olympic_private *olympic_priv=netdev_priv(dev);
 
1714
 
 
1715
        if (olympic_priv->olympic_network_monitor) { 
 
1716
                char proc_name[20] ; 
 
1717
                strcpy(proc_name,"olympic_") ;
 
1718
                strcat(proc_name,dev->name) ;
 
1719
                remove_proc_entry(proc_name,init_net.proc_net);
 
1720
        }
 
1721
        unregister_netdev(dev) ; 
 
1722
        iounmap(olympic_priv->olympic_mmio) ; 
 
1723
        iounmap(olympic_priv->olympic_lap) ; 
 
1724
        pci_release_regions(pdev) ;
 
1725
        pci_set_drvdata(pdev,NULL) ;    
 
1726
        free_netdev(dev) ; 
 
1727
}
 
1728
 
 
1729
static struct pci_driver olympic_driver = { 
 
1730
        .name           = "olympic",
 
1731
        .id_table       = olympic_pci_tbl,
 
1732
        .probe          = olympic_probe,
 
1733
        .remove         = __devexit_p(olympic_remove_one),
 
1734
};
 
1735
 
 
1736
static int __init olympic_pci_init(void) 
 
1737
{
 
1738
        return pci_register_driver(&olympic_driver) ;
 
1739
}
 
1740
 
 
1741
static void __exit olympic_pci_cleanup(void)
 
1742
{
 
1743
        pci_unregister_driver(&olympic_driver) ; 
 
1744
}       
 
1745
 
 
1746
 
 
1747
module_init(olympic_pci_init) ; 
 
1748
module_exit(olympic_pci_cleanup) ; 
 
1749
 
 
1750
MODULE_LICENSE("GPL");