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