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