projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


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