?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SK_BUFF]: Introduce ip_hdr(), remove skb->nh.iph
[linux-2.6/verdex.git] / drivers / net / tokenring / olympic.c
bloba62065808881e5a13ccfdf40195b5429de27f9f9
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
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);
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_release_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 free_netdev(dev);
285 op_release_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(time_after(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(time_after(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(time_after(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, IRQF_SHARED , "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 (time_after(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 /* Optimise based upon number of buffers used.
818 If only one buffer is used we can simply swap the buffers around.
819 If more than one then we must use the new buffer and copy the information
820 first. Ideally all frames would be in a single buffer, this can be tuned by
821 altering the buffer size. If the length of the packet is less than
822 1500 bytes we're going to copy it over anyway to stop packets getting
823 dropped from sockets with buffers smaller than our pkt_buf_sz. */
824
825 if (buffer_cnt==1) {
826 olympic_priv->rx_ring_last_received++ ;
827 olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
828 rx_ring_last_received = olympic_priv->rx_ring_last_received ;
829 if (length > 1500) {
830 skb2=olympic_priv->rx_ring_skb[rx_ring_last_received] ;
831 /* unmap buffer */
832 pci_unmap_single(olympic_priv->pdev,
833 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
834 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
835 skb_put(skb2,length-4);
836 skb2->protocol = tr_type_trans(skb2,dev);
837 olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer =
838 cpu_to_le32(pci_map_single(olympic_priv->pdev, skb->data,
839 olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
840 olympic_priv->olympic_rx_ring[rx_ring_last_received].res_length =
841 cpu_to_le32(olympic_priv->pkt_buf_sz);
842 olympic_priv->rx_ring_skb[rx_ring_last_received] = skb ;
843 netif_rx(skb2) ;
844 } else {
845 pci_dma_sync_single_for_cpu(olympic_priv->pdev,
846 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
847 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
848 memcpy(skb_put(skb,length-4),olympic_priv->rx_ring_skb[rx_ring_last_received]->data,length-4) ;
849 pci_dma_sync_single_for_device(olympic_priv->pdev,
850 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
851 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
852 skb->protocol = tr_type_trans(skb,dev) ;
853 netif_rx(skb) ;
854 }
855 } else {
856 do { /* Walk the buffers */
857 olympic_priv->rx_ring_last_received++ ;
858 olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE -1);
859 rx_ring_last_received = olympic_priv->rx_ring_last_received ;
860 pci_dma_sync_single_for_cpu(olympic_priv->pdev,
861 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
862 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
863 rx_desc = &(olympic_priv->olympic_rx_ring[rx_ring_last_received]);
864 cpy_length = (i == 1 ? frag_len : le32_to_cpu(rx_desc->res_length));
865 memcpy(skb_put(skb, cpy_length), olympic_priv->rx_ring_skb[rx_ring_last_received]->data, cpy_length) ;
866 pci_dma_sync_single_for_device(olympic_priv->pdev,
867 le32_to_cpu(olympic_priv->olympic_rx_ring[rx_ring_last_received].buffer),
868 olympic_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
869 } while (--i) ;
870 skb_trim(skb,skb->len-4) ;
871 skb->protocol = tr_type_trans(skb,dev);
872 netif_rx(skb) ;
873 }
874 dev->last_rx = jiffies ;
875 olympic_priv->olympic_stats.rx_packets++ ;
876 olympic_priv->olympic_stats.rx_bytes += length ;
877 } /* if skb == null */
878 } /* If status & 0x3b */
879
880 } else { /*if buffercnt & 0xC */
881 olympic_priv->rx_ring_last_received += i ;
882 olympic_priv->rx_ring_last_received &= (OLYMPIC_RX_RING_SIZE - 1) ;
883 }
884
885 rx_status->fragmentcnt_framelen = 0 ;
886 rx_status->status_buffercnt = 0 ;
887 rx_status = &(olympic_priv->olympic_rx_status_ring[(olympic_priv->rx_status_last_received+1) & (OLYMPIC_RX_RING_SIZE -1) ]);
888
889 writew((((readw(olympic_mmio+RXENQ)) & 0x8000) ^ 0x8000) | buffer_cnt , olympic_mmio+RXENQ);
890 } /* while */
891
892 }
893
894 static void olympic_freemem(struct net_device *dev)
895 {
896 struct olympic_private *olympic_priv=(struct olympic_private *)dev->priv;
897 int i;
898
899 for(i=0;i<OLYMPIC_RX_RING_SIZE;i++) {
900 if (olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received] != NULL) {
901 dev_kfree_skb_irq(olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received]);
902 olympic_priv->rx_ring_skb[olympic_priv->rx_status_last_received] = NULL;
903 }
904 if (olympic_priv->olympic_rx_ring[olympic_priv->rx_status_last_received].buffer != 0xdeadbeef) {
905 pci_unmap_single(olympic_priv->pdev,
906 le32_to_cpu(olympic_priv->olympic_rx_ring[olympic_priv->rx_status_last_received].buffer),
907 olympic_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE);
908 }
909 olympic_priv->rx_status_last_received++;
910 olympic_priv->rx_status_last_received&=OLYMPIC_RX_RING_SIZE-1;
911 }
912 /* unmap rings */
913 pci_unmap_single(olympic_priv->pdev, olympic_priv->rx_status_ring_dma_addr,
914 sizeof(struct olympic_rx_status) * OLYMPIC_RX_RING_SIZE, PCI_DMA_FROMDEVICE);
915 pci_unmap_single(olympic_priv->pdev, olympic_priv->rx_ring_dma_addr,
916 sizeof(struct olympic_rx_desc) * OLYMPIC_RX_RING_SIZE, PCI_DMA_TODEVICE);
917
918 pci_unmap_single(olympic_priv->pdev, olympic_priv->tx_status_ring_dma_addr,
919 sizeof(struct olympic_tx_status) * OLYMPIC_TX_RING_SIZE, PCI_DMA_FROMDEVICE);
920 pci_unmap_single(olympic_priv->pdev, olympic_priv->tx_ring_dma_addr,
921 sizeof(struct olympic_tx_desc) * OLYMPIC_TX_RING_SIZE, PCI_DMA_TODEVICE);
922
923 return ;
924 }
925
926 static irqreturn_t olympic_interrupt(int irq, void *dev_id)
927 {
928 struct net_device *dev= (struct net_device *)dev_id;
929 struct olympic_private *olympic_priv=(struct olympic_private *)dev->priv;
930 u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
931 u32 sisr;
932 u8 __iomem *adapter_check_area ;
933
934 /*
935 * Read sisr but don't reset it yet.
936 * The indication bit may have been set but the interrupt latch
937 * bit may not be set, so we'd lose the interrupt later.
938 */
939 sisr=readl(olympic_mmio+SISR) ;
940 if (!(sisr & SISR_MI)) /* Interrupt isn't for us */
941 return IRQ_NONE;
942 sisr=readl(olympic_mmio+SISR_RR) ; /* Read & Reset sisr */
943
944 spin_lock(&olympic_priv->olympic_lock);
945
946 /* Hotswap gives us this on removal */
947 if (sisr == 0xffffffff) {
948 printk(KERN_WARNING "%s: Hotswap adapter removal.\n",dev->name) ;
949 spin_unlock(&olympic_priv->olympic_lock) ;
950 return IRQ_NONE;
951 }
952
953 if (sisr & (SISR_SRB_REPLY | SISR_TX1_EOF | SISR_RX_STATUS | SISR_ADAPTER_CHECK |
954 SISR_ASB_FREE | SISR_ARB_CMD | SISR_TRB_REPLY | SISR_RX_NOBUF | SISR_ERR)) {
955
956 /* If we ever get this the adapter is seriously dead. Only a reset is going to
957 * bring it back to life. We're talking pci bus errors and such like :( */
958 if((sisr & SISR_ERR) && (readl(olympic_mmio+EISR) & EISR_MASK_OPTIONS)) {
959 printk(KERN_ERR "Olympic: EISR Error, EISR=%08x\n",readl(olympic_mmio+EISR)) ;
960 printk(KERN_ERR "The adapter must be reset to clear this condition.\n") ;
961 printk(KERN_ERR "Please report this error to the driver maintainer and/\n") ;
962 printk(KERN_ERR "or the linux-tr mailing list.\n") ;
963 wake_up_interruptible(&olympic_priv->srb_wait);
964 spin_unlock(&olympic_priv->olympic_lock) ;
965 return IRQ_HANDLED;
966 } /* SISR_ERR */
967
968 if(sisr & SISR_SRB_REPLY) {
969 if(olympic_priv->srb_queued==1) {
970 wake_up_interruptible(&olympic_priv->srb_wait);
971 } else if (olympic_priv->srb_queued==2) {
972 olympic_srb_bh(dev) ;
973 }
974 olympic_priv->srb_queued=0;
975 } /* SISR_SRB_REPLY */
976
977 /* We shouldn't ever miss the Tx interrupt, but the you never know, hence the loop to ensure
978 we get all tx completions. */
979 if (sisr & SISR_TX1_EOF) {
980 while(olympic_priv->olympic_tx_status_ring[(olympic_priv->tx_ring_last_status + 1) & (OLYMPIC_TX_RING_SIZE-1)].status) {
981 olympic_priv->tx_ring_last_status++;
982 olympic_priv->tx_ring_last_status &= (OLYMPIC_TX_RING_SIZE-1);
983 olympic_priv->free_tx_ring_entries++;
984 olympic_priv->olympic_stats.tx_bytes += olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]->len;
985 olympic_priv->olympic_stats.tx_packets++ ;
986 pci_unmap_single(olympic_priv->pdev,
987 le32_to_cpu(olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_last_status].buffer),
988 olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]->len,PCI_DMA_TODEVICE);
989 dev_kfree_skb_irq(olympic_priv->tx_ring_skb[olympic_priv->tx_ring_last_status]);
990 olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_last_status].buffer=0xdeadbeef;
991 olympic_priv->olympic_tx_status_ring[olympic_priv->tx_ring_last_status].status=0;
992 }
993 netif_wake_queue(dev);
994 } /* SISR_TX1_EOF */
995
996 if (sisr & SISR_RX_STATUS) {
997 olympic_rx(dev);
998 } /* SISR_RX_STATUS */
999
1000 if (sisr & SISR_ADAPTER_CHECK) {
1001 netif_stop_queue(dev);
1002 printk(KERN_WARNING "%s: Adapter Check Interrupt Raised, 8 bytes of information follow:\n", dev->name);
1003 writel(readl(olympic_mmio+LAPWWC),olympic_mmio+LAPA);
1004 adapter_check_area = olympic_priv->olympic_lap + ((readl(olympic_mmio+LAPWWC)) & (~0xf800)) ;
1005 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)) ;
1006 spin_unlock(&olympic_priv->olympic_lock) ;
1007 return IRQ_HANDLED;
1008 } /* SISR_ADAPTER_CHECK */
1009
1010 if (sisr & SISR_ASB_FREE) {
1011 /* Wake up anything that is waiting for the asb response */
1012 if (olympic_priv->asb_queued) {
1013 olympic_asb_bh(dev) ;
1014 }
1015 } /* SISR_ASB_FREE */
1016
1017 if (sisr & SISR_ARB_CMD) {
1018 olympic_arb_cmd(dev) ;
1019 } /* SISR_ARB_CMD */
1020
1021 if (sisr & SISR_TRB_REPLY) {
1022 /* Wake up anything that is waiting for the trb response */
1023 if (olympic_priv->trb_queued) {
1024 wake_up_interruptible(&olympic_priv->trb_wait);
1025 }
1026 olympic_priv->trb_queued = 0 ;
1027 } /* SISR_TRB_REPLY */
1028
1029 if (sisr & SISR_RX_NOBUF) {
1030 /* According to the documentation, we don't have to do anything, but trapping it keeps it out of
1031 /var/log/messages. */
1032 } /* SISR_RX_NOBUF */
1033 } else {
1034 printk(KERN_WARNING "%s: Unexpected interrupt: %x\n",dev->name, sisr);
1035 printk(KERN_WARNING "%s: SISR_MASK: %x\n",dev->name, readl(olympic_mmio+SISR_MASK)) ;
1036 } /* One if the interrupts we want */
1037 writel(SISR_MI,olympic_mmio+SISR_MASK_SUM);
1038
1039 spin_unlock(&olympic_priv->olympic_lock) ;
1040 return IRQ_HANDLED;
1041 }
1042
1043 static int olympic_xmit(struct sk_buff *skb, struct net_device *dev)
1044 {
1045 struct olympic_private *olympic_priv=(struct olympic_private *)dev->priv;
1046 u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
1047 unsigned long flags ;
1048
1049 spin_lock_irqsave(&olympic_priv->olympic_lock, flags);
1050
1051 netif_stop_queue(dev);
1052
1053 if(olympic_priv->free_tx_ring_entries) {
1054 olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_free].buffer =
1055 cpu_to_le32(pci_map_single(olympic_priv->pdev, skb->data, skb->len,PCI_DMA_TODEVICE));
1056 olympic_priv->olympic_tx_ring[olympic_priv->tx_ring_free].status_length = cpu_to_le32(skb->len | (0x80000000));
1057 olympic_priv->tx_ring_skb[olympic_priv->tx_ring_free]=skb;
1058 olympic_priv->free_tx_ring_entries--;
1059
1060 olympic_priv->tx_ring_free++;
1061 olympic_priv->tx_ring_free &= (OLYMPIC_TX_RING_SIZE-1);
1062 writew((((readw(olympic_mmio+TXENQ_1)) & 0x8000) ^ 0x8000) | 1,olympic_mmio+TXENQ_1);
1063 netif_wake_queue(dev);
1064 spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
1065 return 0;
1066 } else {
1067 spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
1068 return 1;
1069 }
1070
1071 }
1072
1073
1074 static int olympic_close(struct net_device *dev)
1075 {
1076 struct olympic_private *olympic_priv=(struct olympic_private *)dev->priv;
1077 u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio,*srb;
1078 unsigned long t,flags;
1079
1080 DECLARE_WAITQUEUE(wait,current) ;
1081
1082 netif_stop_queue(dev);
1083
1084 writel(olympic_priv->srb,olympic_mmio+LAPA);
1085 srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
1086
1087 writeb(SRB_CLOSE_ADAPTER,srb+0);
1088 writeb(0,srb+1);
1089 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1090
1091 add_wait_queue(&olympic_priv->srb_wait,&wait) ;
1092 set_current_state(TASK_INTERRUPTIBLE) ;
1093
1094 spin_lock_irqsave(&olympic_priv->olympic_lock,flags);
1095 olympic_priv->srb_queued=1;
1096
1097 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1098 spin_unlock_irqrestore(&olympic_priv->olympic_lock,flags);
1099
1100 while(olympic_priv->srb_queued) {
1101
1102 t = schedule_timeout_interruptible(60*HZ);
1103
1104 if(signal_pending(current)) {
1105 printk(KERN_WARNING "%s: SRB timed out.\n",dev->name);
1106 printk(KERN_WARNING "SISR=%x MISR=%x\n",readl(olympic_mmio+SISR),readl(olympic_mmio+LISR));
1107 olympic_priv->srb_queued=0;
1108 break;
1109 }
1110
1111 if (t == 0) {
1112 printk(KERN_WARNING "%s: SRB timed out. May not be fatal. \n",dev->name) ;
1113 }
1114 olympic_priv->srb_queued=0;
1115 }
1116 remove_wait_queue(&olympic_priv->srb_wait,&wait) ;
1117
1118 olympic_priv->rx_status_last_received++;
1119 olympic_priv->rx_status_last_received&=OLYMPIC_RX_RING_SIZE-1;
1120
1121 olympic_freemem(dev) ;
1122
1123 /* reset tx/rx fifo's and busmaster logic */
1124
1125 writel(readl(olympic_mmio+BCTL)|(3<<13),olympic_mmio+BCTL);
1126 udelay(1);
1127 writel(readl(olympic_mmio+BCTL)&~(3<<13),olympic_mmio+BCTL);
1128
1129 #if OLYMPIC_DEBUG
1130 {
1131 int i ;
1132 printk("srb(%p): ",srb);
1133 for(i=0;i<4;i++)
1134 printk("%x ",readb(srb+i));
1135 printk("\n");
1136 }
1137 #endif
1138 free_irq(dev->irq,dev);
1139
1140 return 0;
1141
1142 }
1143
1144 static void olympic_set_rx_mode(struct net_device *dev)
1145 {
1146 struct olympic_private *olympic_priv = (struct olympic_private *) dev->priv ;
1147 u8 __iomem *olympic_mmio = olympic_priv->olympic_mmio ;
1148 u8 options = 0;
1149 u8 __iomem *srb;
1150 struct dev_mc_list *dmi ;
1151 unsigned char dev_mc_address[4] ;
1152 int i ;
1153
1154 writel(olympic_priv->srb,olympic_mmio+LAPA);
1155 srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
1156 options = olympic_priv->olympic_copy_all_options;
1157
1158 if (dev->flags&IFF_PROMISC)
1159 options |= 0x61 ;
1160 else
1161 options &= ~0x61 ;
1162
1163 /* Only issue the srb if there is a change in options */
1164
1165 if ((options ^ olympic_priv->olympic_copy_all_options)) {
1166
1167 /* Now to issue the srb command to alter the copy.all.options */
1168
1169 writeb(SRB_MODIFY_RECEIVE_OPTIONS,srb);
1170 writeb(0,srb+1);
1171 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1172 writeb(0,srb+3);
1173 writeb(olympic_priv->olympic_receive_options,srb+4);
1174 writeb(options,srb+5);
1175
1176 olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
1177
1178 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1179
1180 olympic_priv->olympic_copy_all_options = options ;
1181
1182 return ;
1183 }
1184
1185 /* Set the functional addresses we need for multicast */
1186
1187 dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ;
1188
1189 for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next) {
1190 dev_mc_address[0] |= dmi->dmi_addr[2] ;
1191 dev_mc_address[1] |= dmi->dmi_addr[3] ;
1192 dev_mc_address[2] |= dmi->dmi_addr[4] ;
1193 dev_mc_address[3] |= dmi->dmi_addr[5] ;
1194 }
1195
1196 writeb(SRB_SET_FUNC_ADDRESS,srb+0);
1197 writeb(0,srb+1);
1198 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1199 writeb(0,srb+3);
1200 writeb(0,srb+4);
1201 writeb(0,srb+5);
1202 writeb(dev_mc_address[0],srb+6);
1203 writeb(dev_mc_address[1],srb+7);
1204 writeb(dev_mc_address[2],srb+8);
1205 writeb(dev_mc_address[3],srb+9);
1206
1207 olympic_priv->srb_queued = 2 ;
1208 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1209
1210 }
1211
1212 static void olympic_srb_bh(struct net_device *dev)
1213 {
1214 struct olympic_private *olympic_priv = (struct olympic_private *) dev->priv ;
1215 u8 __iomem *olympic_mmio = olympic_priv->olympic_mmio ;
1216 u8 __iomem *srb;
1217
1218 writel(olympic_priv->srb,olympic_mmio+LAPA);
1219 srb=olympic_priv->olympic_lap + (olympic_priv->srb & (~0xf800));
1220
1221 switch (readb(srb)) {
1222
1223 /* SRB_MODIFY_RECEIVE_OPTIONS i.e. set_multicast_list options (promiscuous)
1224 * At some point we should do something if we get an error, such as
1225 * resetting the IFF_PROMISC flag in dev
1226 */
1227
1228 case SRB_MODIFY_RECEIVE_OPTIONS:
1229 switch (readb(srb+2)) {
1230 case 0x01:
1231 printk(KERN_WARNING "%s: Unrecognized srb command\n",dev->name) ;
1232 break ;
1233 case 0x04:
1234 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name);
1235 break ;
1236 default:
1237 if (olympic_priv->olympic_message_level)
1238 printk(KERN_WARNING "%s: Receive Options Modified to %x,%x\n",dev->name,olympic_priv->olympic_copy_all_options, olympic_priv->olympic_receive_options) ;
1239 break ;
1240 } /* switch srb[2] */
1241 break ;
1242
1243 /* SRB_SET_GROUP_ADDRESS - Multicast group setting
1244 */
1245
1246 case SRB_SET_GROUP_ADDRESS:
1247 switch (readb(srb+2)) {
1248 case 0x00:
1249 break ;
1250 case 0x01:
1251 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1252 break ;
1253 case 0x04:
1254 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name);
1255 break ;
1256 case 0x3c:
1257 printk(KERN_WARNING "%s: Group/Functional address indicator bits not set correctly\n",dev->name) ;
1258 break ;
1259 case 0x3e: /* If we ever implement individual multicast addresses, will need to deal with this */
1260 printk(KERN_WARNING "%s: Group address registers full\n",dev->name) ;
1261 break ;
1262 case 0x55:
1263 printk(KERN_INFO "%s: Group Address already set.\n",dev->name) ;
1264 break ;
1265 default:
1266 break ;
1267 } /* switch srb[2] */
1268 break ;
1269
1270 /* SRB_RESET_GROUP_ADDRESS - Remove a multicast address from group list
1271 */
1272
1273 case SRB_RESET_GROUP_ADDRESS:
1274 switch (readb(srb+2)) {
1275 case 0x00:
1276 break ;
1277 case 0x01:
1278 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1279 break ;
1280 case 0x04:
1281 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1282 break ;
1283 case 0x39: /* Must deal with this if individual multicast addresses used */
1284 printk(KERN_INFO "%s: Group address not found \n",dev->name);
1285 break ;
1286 default:
1287 break ;
1288 } /* switch srb[2] */
1289 break ;
1290
1291
1292 /* SRB_SET_FUNC_ADDRESS - Called by the set_rx_mode
1293 */
1294
1295 case SRB_SET_FUNC_ADDRESS:
1296 switch (readb(srb+2)) {
1297 case 0x00:
1298 if (olympic_priv->olympic_message_level)
1299 printk(KERN_INFO "%s: Functional Address Mask Set \n",dev->name) ;
1300 break ;
1301 case 0x01:
1302 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1303 break ;
1304 case 0x04:
1305 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1306 break ;
1307 default:
1308 break ;
1309 } /* switch srb[2] */
1310 break ;
1311
1312 /* SRB_READ_LOG - Read and reset the adapter error counters
1313 */
1314
1315 case SRB_READ_LOG:
1316 switch (readb(srb+2)) {
1317 case 0x00:
1318 if (olympic_priv->olympic_message_level)
1319 printk(KERN_INFO "%s: Read Log issued\n",dev->name) ;
1320 break ;
1321 case 0x01:
1322 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1323 break ;
1324 case 0x04:
1325 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1326 break ;
1327
1328 } /* switch srb[2] */
1329 break ;
1330
1331 /* SRB_READ_SR_COUNTERS - Read and reset the source routing bridge related counters */
1332
1333 case SRB_READ_SR_COUNTERS:
1334 switch (readb(srb+2)) {
1335 case 0x00:
1336 if (olympic_priv->olympic_message_level)
1337 printk(KERN_INFO "%s: Read Source Routing Counters issued\n",dev->name) ;
1338 break ;
1339 case 0x01:
1340 printk(KERN_WARNING "%s: Unrecognized srb command \n",dev->name) ;
1341 break ;
1342 case 0x04:
1343 printk(KERN_WARNING "%s: Adapter must be open for this operation, doh!!\n",dev->name) ;
1344 break ;
1345 default:
1346 break ;
1347 } /* switch srb[2] */
1348 break ;
1349
1350 default:
1351 printk(KERN_WARNING "%s: Unrecognized srb bh return value.\n",dev->name);
1352 break ;
1353 } /* switch srb[0] */
1354
1355 }
1356
1357 static struct net_device_stats * olympic_get_stats(struct net_device *dev)
1358 {
1359 struct olympic_private *olympic_priv ;
1360 olympic_priv=(struct olympic_private *) dev->priv;
1361 return (struct net_device_stats *) &olympic_priv->olympic_stats;
1362 }
1363
1364 static int olympic_set_mac_address (struct net_device *dev, void *addr)
1365 {
1366 struct sockaddr *saddr = addr ;
1367 struct olympic_private *olympic_priv = (struct olympic_private *)dev->priv ;
1368
1369 if (netif_running(dev)) {
1370 printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name) ;
1371 return -EIO ;
1372 }
1373
1374 memcpy(olympic_priv->olympic_laa, saddr->sa_data,dev->addr_len) ;
1375
1376 if (olympic_priv->olympic_message_level) {
1377 printk(KERN_INFO "%s: MAC/LAA Set to = %x.%x.%x.%x.%x.%x\n",dev->name, olympic_priv->olympic_laa[0],
1378 olympic_priv->olympic_laa[1], olympic_priv->olympic_laa[2],
1379 olympic_priv->olympic_laa[3], olympic_priv->olympic_laa[4],
1380 olympic_priv->olympic_laa[5]);
1381 }
1382
1383 return 0 ;
1384 }
1385
1386 static void olympic_arb_cmd(struct net_device *dev)
1387 {
1388 struct olympic_private *olympic_priv = (struct olympic_private *) dev->priv;
1389 u8 __iomem *olympic_mmio=olympic_priv->olympic_mmio;
1390 u8 __iomem *arb_block, *asb_block, *srb ;
1391 u8 header_len ;
1392 u16 frame_len, buffer_len ;
1393 struct sk_buff *mac_frame ;
1394 u8 __iomem *buf_ptr ;
1395 u8 __iomem *frame_data ;
1396 u16 buff_off ;
1397 u16 lan_status = 0, lan_status_diff ; /* Initialize to stop compiler warning */
1398 u8 fdx_prot_error ;
1399 u16 next_ptr;
1400
1401 arb_block = (olympic_priv->olympic_lap + olympic_priv->arb) ;
1402 asb_block = (olympic_priv->olympic_lap + olympic_priv->asb) ;
1403 srb = (olympic_priv->olympic_lap + olympic_priv->srb) ;
1404
1405 if (readb(arb_block+0) == ARB_RECEIVE_DATA) { /* Receive.data, MAC frames */
1406
1407 header_len = readb(arb_block+8) ; /* 802.5 Token-Ring Header Length */
1408 frame_len = swab16(readw(arb_block + 10)) ;
1409
1410 buff_off = swab16(readw(arb_block + 6)) ;
1411
1412 buf_ptr = olympic_priv->olympic_lap + buff_off ;
1413
1414 #if OLYMPIC_DEBUG
1415 {
1416 int i;
1417 frame_data = buf_ptr+offsetof(struct mac_receive_buffer,frame_data) ;
1418
1419 for (i=0 ; i < 14 ; i++) {
1420 printk("Loc %d = %02x\n",i,readb(frame_data + i));
1421 }
1422
1423 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)));
1424 }
1425 #endif
1426 mac_frame = dev_alloc_skb(frame_len) ;
1427 if (!mac_frame) {
1428 printk(KERN_WARNING "%s: Memory squeeze, dropping frame.\n", dev->name);
1429 goto drop_frame;
1430 }
1431
1432 /* Walk the buffer chain, creating the frame */
1433
1434 do {
1435 frame_data = buf_ptr+offsetof(struct mac_receive_buffer,frame_data) ;
1436 buffer_len = swab16(readw(buf_ptr+offsetof(struct mac_receive_buffer,buffer_length)));
1437 memcpy_fromio(skb_put(mac_frame, buffer_len), frame_data , buffer_len ) ;
1438 next_ptr=readw(buf_ptr+offsetof(struct mac_receive_buffer,next));
1439 } while (next_ptr && (buf_ptr=olympic_priv->olympic_lap + ntohs(next_ptr)));
1440
1441 mac_frame->protocol = tr_type_trans(mac_frame, dev);
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 = tr_hdr(mac_frame);
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 netif_rx(mac_frame);
1451 dev->last_rx = jiffies;
1452
1453 drop_frame:
1454 /* Now tell the card we have dealt with the received frame */
1455
1456 /* Set LISR Bit 1 */
1457 writel(LISR_ARB_FREE,olympic_priv->olympic_mmio + LISR_SUM);
1458
1459 /* Is the ASB free ? */
1460
1461 if (readb(asb_block + 2) != 0xff) {
1462 olympic_priv->asb_queued = 1 ;
1463 writel(LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
1464 return ;
1465 /* Drop out and wait for the bottom half to be run */
1466 }
1467
1468 writeb(ASB_RECEIVE_DATA,asb_block); /* Receive data */
1469 writeb(OLYMPIC_CLEAR_RET_CODE,asb_block+2); /* Necessary ?? */
1470 writeb(readb(arb_block+6),asb_block+6); /* Must send the address back to the adapter */
1471 writeb(readb(arb_block+7),asb_block+7); /* To let it know we have dealt with the data */
1472
1473 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
1474
1475 olympic_priv->asb_queued = 2 ;
1476
1477 return ;
1478
1479 } else if (readb(arb_block) == ARB_LAN_CHANGE_STATUS) { /* Lan.change.status */
1480 lan_status = swab16(readw(arb_block+6));
1481 fdx_prot_error = readb(arb_block+8) ;
1482
1483 /* Issue ARB Free */
1484 writel(LISR_ARB_FREE,olympic_priv->olympic_mmio+LISR_SUM);
1485
1486 lan_status_diff = olympic_priv->olympic_lan_status ^ lan_status ;
1487
1488 if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR) ) {
1489 if (lan_status_diff & LSC_LWF)
1490 printk(KERN_WARNING "%s: Short circuit detected on the lobe\n",dev->name);
1491 if (lan_status_diff & LSC_ARW)
1492 printk(KERN_WARNING "%s: Auto removal error\n",dev->name);
1493 if (lan_status_diff & LSC_FPE)
1494 printk(KERN_WARNING "%s: FDX Protocol Error\n",dev->name);
1495 if (lan_status_diff & LSC_RR)
1496 printk(KERN_WARNING "%s: Force remove MAC frame received\n",dev->name);
1497
1498 /* Adapter has been closed by the hardware */
1499
1500 /* reset tx/rx fifo's and busmaster logic */
1501
1502 writel(readl(olympic_mmio+BCTL)|(3<<13),olympic_mmio+BCTL);
1503 udelay(1);
1504 writel(readl(olympic_mmio+BCTL)&~(3<<13),olympic_mmio+BCTL);
1505 netif_stop_queue(dev);
1506 olympic_priv->srb = readw(olympic_priv->olympic_lap + LAPWWO) ;
1507 printk(KERN_WARNING "%s: Adapter has been closed \n", dev->name) ;
1508 } /* If serious error */
1509
1510 if (olympic_priv->olympic_message_level) {
1511 if (lan_status_diff & LSC_SIG_LOSS)
1512 printk(KERN_WARNING "%s: No receive signal detected \n", dev->name) ;
1513 if (lan_status_diff & LSC_HARD_ERR)
1514 printk(KERN_INFO "%s: Beaconing \n",dev->name);
1515 if (lan_status_diff & LSC_SOFT_ERR)
1516 printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n",dev->name);
1517 if (lan_status_diff & LSC_TRAN_BCN)
1518 printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n",dev->name);
1519 if (lan_status_diff & LSC_SS)
1520 printk(KERN_INFO "%s: Single Station on the ring \n", dev->name);
1521 if (lan_status_diff & LSC_RING_REC)
1522 printk(KERN_INFO "%s: Ring recovery ongoing\n",dev->name);
1523 if (lan_status_diff & LSC_FDX_MODE)
1524 printk(KERN_INFO "%s: Operating in FDX mode\n",dev->name);
1525 }
1526
1527 if (lan_status_diff & LSC_CO) {
1528
1529 if (olympic_priv->olympic_message_level)
1530 printk(KERN_INFO "%s: Counter Overflow \n", dev->name);
1531
1532 /* Issue READ.LOG command */
1533
1534 writeb(SRB_READ_LOG, srb);
1535 writeb(0,srb+1);
1536 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1537 writeb(0,srb+3);
1538 writeb(0,srb+4);
1539 writeb(0,srb+5);
1540
1541 olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
1542
1543 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1544
1545 }
1546
1547 if (lan_status_diff & LSC_SR_CO) {
1548
1549 if (olympic_priv->olympic_message_level)
1550 printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name);
1551
1552 /* Issue a READ.SR.COUNTERS */
1553
1554 writeb(SRB_READ_SR_COUNTERS,srb);
1555 writeb(0,srb+1);
1556 writeb(OLYMPIC_CLEAR_RET_CODE,srb+2);
1557 writeb(0,srb+3);
1558
1559 olympic_priv->srb_queued=2; /* Can't sleep, use srb_bh */
1560
1561 writel(LISR_SRB_CMD,olympic_mmio+LISR_SUM);
1562
1563 }
1564
1565 olympic_priv->olympic_lan_status = lan_status ;
1566
1567 } /* Lan.change.status */
1568 else
1569 printk(KERN_WARNING "%s: Unknown arb command \n", dev->name);
1570 }
1571
1572 static void olympic_asb_bh(struct net_device *dev)
1573 {
1574 struct olympic_private *olympic_priv = (struct olympic_private *) dev->priv ;
1575 u8 __iomem *arb_block, *asb_block ;
1576
1577 arb_block = (olympic_priv->olympic_lap + olympic_priv->arb) ;
1578 asb_block = (olympic_priv->olympic_lap + olympic_priv->asb) ;
1579
1580 if (olympic_priv->asb_queued == 1) { /* Dropped through the first time */
1581
1582 writeb(ASB_RECEIVE_DATA,asb_block); /* Receive data */
1583 writeb(OLYMPIC_CLEAR_RET_CODE,asb_block+2); /* Necessary ?? */
1584 writeb(readb(arb_block+6),asb_block+6); /* Must send the address back to the adapter */
1585 writeb(readb(arb_block+7),asb_block+7); /* To let it know we have dealt with the data */
1586
1587 writel(LISR_ASB_REPLY | LISR_ASB_FREE_REQ,olympic_priv->olympic_mmio+LISR_SUM);
1588 olympic_priv->asb_queued = 2 ;
1589
1590 return ;
1591 }
1592
1593 if (olympic_priv->asb_queued == 2) {
1594 switch (readb(asb_block+2)) {
1595 case 0x01:
1596 printk(KERN_WARNING "%s: Unrecognized command code \n", dev->name);
1597 break ;
1598 case 0x26:
1599 printk(KERN_WARNING "%s: Unrecognized buffer address \n", dev->name);
1600 break ;
1601 case 0xFF:
1602 /* Valid response, everything should be ok again */
1603 break ;
1604 default:
1605 printk(KERN_WARNING "%s: Invalid return code in asb\n",dev->name);
1606 break ;
1607 }
1608 }
1609 olympic_priv->asb_queued = 0 ;
1610 }
1611
1612 static int olympic_change_mtu(struct net_device *dev, int mtu)
1613 {
1614 struct olympic_private *olympic_priv = (struct olympic_private *) dev->priv;
1615 u16 max_mtu ;
1616
1617 if (olympic_priv->olympic_ring_speed == 4)
1618 max_mtu = 4500 ;
1619 else
1620 max_mtu = 18000 ;
1621
1622 if (mtu > max_mtu)
1623 return -EINVAL ;
1624 if (mtu < 100)
1625 return -EINVAL ;
1626
1627 dev->mtu = mtu ;
1628 olympic_priv->pkt_buf_sz = mtu + TR_HLEN ;
1629
1630 return 0 ;
1631 }
1632
1633 static int olympic_proc_info(char *buffer, char **start, off_t offset, int length, int *eof, void *data)
1634 {
1635 struct net_device *dev = (struct net_device *)data ;
1636 struct olympic_private *olympic_priv=(struct olympic_private *)dev->priv;
1637 u8 __iomem *oat = (olympic_priv->olympic_lap + olympic_priv->olympic_addr_table_addr) ;
1638 u8 __iomem *opt = (olympic_priv->olympic_lap + olympic_priv->olympic_parms_addr) ;
1639 int size = 0 ;
1640 int len=0;
1641 off_t begin=0;
1642 off_t pos=0;
1643
1644 size = sprintf(buffer,
1645 "IBM Pit/Pit-Phy/Olympic Chipset Token Ring Adapter %s\n",dev->name);
1646 size += sprintf(buffer+size, "\n%6s: Adapter Address : Node Address : Functional Addr\n",
1647 dev->name);
1648
1649 size += sprintf(buffer+size, "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x\n",
1650 dev->name,
1651 dev->dev_addr[0],
1652 dev->dev_addr[1],
1653 dev->dev_addr[2],
1654 dev->dev_addr[3],
1655 dev->dev_addr[4],
1656 dev->dev_addr[5],
1657 readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)),
1658 readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+1),
1659 readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+2),
1660 readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+3),
1661 readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+4),
1662 readb(oat+offsetof(struct olympic_adapter_addr_table,node_addr)+5),
1663 readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)),
1664 readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+1),
1665 readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+2),
1666 readb(oat+offsetof(struct olympic_adapter_addr_table,func_addr)+3));
1667
1668 size += sprintf(buffer+size, "\n%6s: Token Ring Parameters Table:\n", dev->name);
1669
1670 size += sprintf(buffer+size, "%6s: Physical Addr : Up Node Address : Poll Address : AccPri : Auth Src : Att Code :\n",
1671 dev->name) ;
1672
1673 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",
1674 dev->name,
1675 readb(opt+offsetof(struct olympic_parameters_table, phys_addr)),
1676 readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+1),
1677 readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+2),
1678 readb(opt+offsetof(struct olympic_parameters_table, phys_addr)+3),
1679 readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)),
1680 readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+1),
1681 readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+2),
1682 readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+3),
1683 readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+4),
1684 readb(opt+offsetof(struct olympic_parameters_table, up_node_addr)+5),
1685 readb(opt+offsetof(struct olympic_parameters_table, poll_addr)),
1686 readb(opt+offsetof(struct olympic_parameters_table, poll_addr)+1),
1687 readb(opt+offsetof(struct olympic_parameters_table, poll_addr)+2),
1688 readb(opt+offsetof(struct olympic_parameters_table, poll_addr)+3),
1689 readb(opt+offsetof(struct olympic_parameters_table, poll_addr)+4),
1690 readb(opt+offsetof(struct olympic_parameters_table, poll_addr)+5),
1691 swab16(readw(opt+offsetof(struct olympic_parameters_table, acc_priority))),
1692 swab16(readw(opt+offsetof(struct olympic_parameters_table, auth_source_class))),
1693 swab16(readw(opt+offsetof(struct olympic_parameters_table, att_code))));
1694
1695 size += sprintf(buffer+size, "%6s: Source Address : Bcn T : Maj. V : Lan St : Lcl Rg : Mon Err : Frame Correl : \n",
1696 dev->name) ;
1697
1698 size += sprintf(buffer+size, "%6s: %02x:%02x:%02x:%02x:%02x:%02x : %04x : %04x : %04x : %04x : %04x : %04x : \n",
1699 dev->name,
1700 readb(opt+offsetof(struct olympic_parameters_table, source_addr)),
1701 readb(opt+offsetof(struct olympic_parameters_table, source_addr)+1),
1702 readb(opt+offsetof(struct olympic_parameters_table, source_addr)+2),
1703 readb(opt+offsetof(struct olympic_parameters_table, source_addr)+3),
1704 readb(opt+offsetof(struct olympic_parameters_table, source_addr)+4),
1705 readb(opt+offsetof(struct olympic_parameters_table, source_addr)+5),
1706 swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_type))),
1707 swab16(readw(opt+offsetof(struct olympic_parameters_table, major_vector))),
1708 swab16(readw(opt+offsetof(struct olympic_parameters_table, lan_status))),
1709 swab16(readw(opt+offsetof(struct olympic_parameters_table, local_ring))),
1710 swab16(readw(opt+offsetof(struct olympic_parameters_table, mon_error))),
1711 swab16(readw(opt+offsetof(struct olympic_parameters_table, frame_correl))));
1712
1713 size += sprintf(buffer+size, "%6s: Beacon Details : Tx : Rx : NAUN Node Address : NAUN Node Phys : \n",
1714 dev->name) ;
1715
1716 size += sprintf(buffer+size, "%6s: : %02x : %02x : %02x:%02x:%02x:%02x:%02x:%02x : %02x:%02x:%02x:%02x : \n",
1717 dev->name,
1718 swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_transmit))),
1719 swab16(readw(opt+offsetof(struct olympic_parameters_table, beacon_receive))),
1720 readb(opt+offsetof(struct olympic_parameters_table, beacon_naun)),
1721 readb(opt+offsetof(struct olympic_parameters_table, beacon_naun)+1),
1722 readb(opt+offsetof(struct olympic_parameters_table, beacon_naun)+2),
1723 readb(opt+offsetof(struct olympic_parameters_table, beacon_naun)+3),
1724 readb(opt+offsetof(struct olympic_parameters_table, beacon_naun)+4),
1725 readb(opt+offsetof(struct olympic_parameters_table, beacon_naun)+5),
1726 readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)),
1727 readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+1),
1728 readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+2),
1729 readb(opt+offsetof(struct olympic_parameters_table, beacon_phys)+3));
1730
1731 len=size;
1732 pos=begin+size;
1733 if (pos<offset) {
1734 len=0;
1735 begin=pos;
1736 }
1737 *start=buffer+(offset-begin); /* Start of wanted data */
1738 len-=(offset-begin); /* Start slop */
1739 if(len>length)
1740 len=length; /* Ending slop */
1741 return len;
1742 }
1743
1744 static void __devexit olympic_remove_one(struct pci_dev *pdev)
1745 {
1746 struct net_device *dev = pci_get_drvdata(pdev) ;
1747 struct olympic_private *olympic_priv=(struct olympic_private *)dev->priv;
1748
1749 if (olympic_priv->olympic_network_monitor) {
1750 char proc_name[20] ;
1751 strcpy(proc_name,"net/olympic_") ;
1752 strcat(proc_name,dev->name) ;
1753 remove_proc_entry(proc_name,NULL);
1754 }
1755 unregister_netdev(dev) ;
1756 iounmap(olympic_priv->olympic_mmio) ;
1757 iounmap(olympic_priv->olympic_lap) ;
1758 pci_release_regions(pdev) ;
1759 pci_set_drvdata(pdev,NULL) ;
1760 free_netdev(dev) ;
1761 }
1762
1763 static struct pci_driver olympic_driver = {
1764 .name = "olympic",
1765 .id_table = olympic_pci_tbl,
1766 .probe = olympic_probe,
1767 .remove = __devexit_p(olympic_remove_one),
1768 };
1769
1770 static int __init olympic_pci_init(void)
1771 {
1772 return pci_register_driver(&olympic_driver) ;
1773 }
1774
1775 static void __exit olympic_pci_cleanup(void)
1776 {
1777 pci_unregister_driver(&olympic_driver) ;
1778 }
1779
1780
1781 module_init(olympic_pci_init) ;
1782 module_exit(olympic_pci_cleanup) ;
1783
1784 MODULE_LICENSE("GPL");
Verdex Pro support