?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / net / tokenring / olympic.c
blobfd8dce90c957502eb2e98e2ee4d3f67e8fff2554
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");