?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: use NETDEV_TX_OK instead of 0 in ndo_start_xmit() functions
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / wan / sbni.c
blob545178e6765dfd7ece0382ea556a4daec25ab8f9
1 /* sbni.c: Granch SBNI12 leased line adapters driver for linux
2 *
3 * Written 2001 by Denis I.Timofeev (timofeev@granch.ru)
4 *
5 * Previous versions were written by Yaroslav Polyakov,
6 * Alexey Zverev and Max Khon.
7 *
8 * Driver supports SBNI12-02,-04,-05,-10,-11 cards, single and
9 * double-channel, PCI and ISA modifications.
10 * More info and useful utilities to work with SBNI12 cards you can find
11 * at http://www.granch.com (English) or http://www.granch.ru (Russian)
12 *
13 * This software may be used and distributed according to the terms
14 * of the GNU General Public License.
15 *
16 *
17 * 5.0.1 Jun 22 2001
18 * - Fixed bug in probe
19 * 5.0.0 Jun 06 2001
20 * - Driver was completely redesigned by Denis I.Timofeev,
21 * - now PCI/Dual, ISA/Dual (with single interrupt line) models are
22 * - supported
23 * 3.3.0 Thu Feb 24 21:30:28 NOVT 2000
24 * - PCI cards support
25 * 3.2.0 Mon Dec 13 22:26:53 NOVT 1999
26 * - Completely rebuilt all the packet storage system
27 * - to work in Ethernet-like style.
28 * 3.1.1 just fixed some bugs (5 aug 1999)
29 * 3.1.0 added balancing feature (26 apr 1999)
30 * 3.0.1 just fixed some bugs (14 apr 1999).
31 * 3.0.0 Initial Revision, Yaroslav Polyakov (24 Feb 1999)
32 * - added pre-calculation for CRC, fixed bug with "len-2" frames,
33 * - removed outbound fragmentation (MTU=1000), written CRC-calculation
34 * - on asm, added work with hard_headers and now we have our own cache
35 * - for them, optionally supported word-interchange on some chipsets,
36 *
37 * Known problem: this driver wasn't tested on multiprocessor machine.
38 */
39
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/ptrace.h>
43 #include <linux/fcntl.h>
44 #include <linux/ioport.h>
45 #include <linux/interrupt.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/errno.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/pci.h>
52 #include <linux/skbuff.h>
53 #include <linux/timer.h>
54 #include <linux/init.h>
55 #include <linux/delay.h>
56
57 #include <net/net_namespace.h>
58 #include <net/arp.h>
59
60 #include <asm/io.h>
61 #include <asm/types.h>
62 #include <asm/byteorder.h>
63 #include <asm/irq.h>
64 #include <asm/uaccess.h>
65
66 #include "sbni.h"
67
68 /* device private data */
69
70 struct net_local {
71 struct timer_list watchdog;
72
73 spinlock_t lock;
74 struct sk_buff *rx_buf_p; /* receive buffer ptr */
75 struct sk_buff *tx_buf_p; /* transmit buffer ptr */
76
77 unsigned int framelen; /* current frame length */
78 unsigned int maxframe; /* maximum valid frame length */
79 unsigned int state;
80 unsigned int inppos, outpos; /* positions in rx/tx buffers */
81
82 /* transmitting frame number - from frames qty to 1 */
83 unsigned int tx_frameno;
84
85 /* expected number of next receiving frame */
86 unsigned int wait_frameno;
87
88 /* count of failed attempts to frame send - 32 attempts do before
89 error - while receiver tunes on opposite side of wire */
90 unsigned int trans_errors;
91
92 /* idle time; send pong when limit exceeded */
93 unsigned int timer_ticks;
94
95 /* fields used for receive level autoselection */
96 int delta_rxl;
97 unsigned int cur_rxl_index, timeout_rxl;
98 unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
99
100 struct sbni_csr1 csr1; /* current value of CSR1 */
101 struct sbni_in_stats in_stats; /* internal statistics */
102
103 struct net_device *second; /* for ISA/dual cards */
104
105 #ifdef CONFIG_SBNI_MULTILINE
106 struct net_device *master;
107 struct net_device *link;
108 #endif
109 };
110
111
112 static int sbni_card_probe( unsigned long );
113 static int sbni_pci_probe( struct net_device * );
114 static struct net_device *sbni_probe1(struct net_device *, unsigned long, int);
115 static int sbni_open( struct net_device * );
116 static int sbni_close( struct net_device * );
117 static int sbni_start_xmit( struct sk_buff *, struct net_device * );
118 static int sbni_ioctl( struct net_device *, struct ifreq *, int );
119 static void set_multicast_list( struct net_device * );
120
121 static irqreturn_t sbni_interrupt( int, void * );
122 static void handle_channel( struct net_device * );
123 static int recv_frame( struct net_device * );
124 static void send_frame( struct net_device * );
125 static int upload_data( struct net_device *,
126 unsigned, unsigned, unsigned, u32 );
127 static void download_data( struct net_device *, u32 * );
128 static void sbni_watchdog( unsigned long );
129 static void interpret_ack( struct net_device *, unsigned );
130 static int append_frame_to_pkt( struct net_device *, unsigned, u32 );
131 static void indicate_pkt( struct net_device * );
132 static void card_start( struct net_device * );
133 static void prepare_to_send( struct sk_buff *, struct net_device * );
134 static void drop_xmit_queue( struct net_device * );
135 static void send_frame_header( struct net_device *, u32 * );
136 static int skip_tail( unsigned int, unsigned int, u32 );
137 static int check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
138 static void change_level( struct net_device * );
139 static void timeout_change_level( struct net_device * );
140 static u32 calc_crc32( u32, u8 *, u32 );
141 static struct sk_buff * get_rx_buf( struct net_device * );
142 static int sbni_init( struct net_device * );
143
144 #ifdef CONFIG_SBNI_MULTILINE
145 static int enslave( struct net_device *, struct net_device * );
146 static int emancipate( struct net_device * );
147 #endif
148
149 #ifdef __i386__
150 #define ASM_CRC 1
151 #endif
152
153 static const char version[] =
154 "Granch SBNI12 driver ver 5.0.1 Jun 22 2001 Denis I.Timofeev.\n";
155
156 static int skip_pci_probe __initdata = 0;
157 static int scandone __initdata = 0;
158 static int num __initdata = 0;
159
160 static unsigned char rxl_tab[];
161 static u32 crc32tab[];
162
163 /* A list of all installed devices, for removing the driver module. */
164 static struct net_device *sbni_cards[ SBNI_MAX_NUM_CARDS ];
165
166 /* Lists of device's parameters */
167 static u32 io[ SBNI_MAX_NUM_CARDS ] __initdata =
168 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
169 static u32 irq[ SBNI_MAX_NUM_CARDS ] __initdata;
170 static u32 baud[ SBNI_MAX_NUM_CARDS ] __initdata;
171 static u32 rxl[ SBNI_MAX_NUM_CARDS ] __initdata =
172 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
173 static u32 mac[ SBNI_MAX_NUM_CARDS ] __initdata;
174
175 #ifndef MODULE
176 typedef u32 iarr[];
177 static iarr __initdata *dest[5] = { &io, &irq, &baud, &rxl, &mac };
178 #endif
179
180 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
181 static unsigned int netcard_portlist[ ] __initdata = {
182 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
183 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
184 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
185 0 };
186
187 #define NET_LOCAL_LOCK(dev) (((struct net_local *)netdev_priv(dev))->lock)
188
189 /*
190 * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
191 * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
192 */
193
194 static inline int __init
195 sbni_isa_probe( struct net_device *dev )
196 {
197 if( dev->base_addr > 0x1ff
198 && request_region( dev->base_addr, SBNI_IO_EXTENT, dev->name )
199 && sbni_probe1( dev, dev->base_addr, dev->irq ) )
200
201 return 0;
202 else {
203 printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
204 "is malfunctional!\n", dev->base_addr );
205 return -ENODEV;
206 }
207 }
208
209 static const struct net_device_ops sbni_netdev_ops = {
210 .ndo_open = sbni_open,
211 .ndo_stop = sbni_close,
212 .ndo_start_xmit = sbni_start_xmit,
213 .ndo_set_multicast_list = set_multicast_list,
214 .ndo_do_ioctl = sbni_ioctl,
215 .ndo_change_mtu = eth_change_mtu,
216 .ndo_set_mac_address = eth_mac_addr,
217 .ndo_validate_addr = eth_validate_addr,
218 };
219
220 static void __init sbni_devsetup(struct net_device *dev)
221 {
222 ether_setup( dev );
223 dev->netdev_ops = &sbni_netdev_ops;
224 }
225
226 int __init sbni_probe(int unit)
227 {
228 struct net_device *dev;
229 static unsigned version_printed __initdata = 0;
230 int err;
231
232 dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
233 if (!dev)
234 return -ENOMEM;
235
236 dev->netdev_ops = &sbni_netdev_ops;
237
238 sprintf(dev->name, "sbni%d", unit);
239 netdev_boot_setup_check(dev);
240
241 err = sbni_init(dev);
242 if (err) {
243 free_netdev(dev);
244 return err;
245 }
246
247 err = register_netdev(dev);
248 if (err) {
249 release_region( dev->base_addr, SBNI_IO_EXTENT );
250 free_netdev(dev);
251 return err;
252 }
253 if( version_printed++ == 0 )
254 printk( KERN_INFO "%s", version );
255 return 0;
256 }
257
258 static int __init sbni_init(struct net_device *dev)
259 {
260 int i;
261 if( dev->base_addr )
262 return sbni_isa_probe( dev );
263 /* otherwise we have to perform search our adapter */
264
265 if( io[ num ] != -1 )
266 dev->base_addr = io[ num ],
267 dev->irq = irq[ num ];
268 else if( scandone || io[ 0 ] != -1 )
269 return -ENODEV;
270
271 /* if io[ num ] contains non-zero address, then that is on ISA bus */
272 if( dev->base_addr )
273 return sbni_isa_probe( dev );
274
275 /* ...otherwise - scan PCI first */
276 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
277 return 0;
278
279 if( io[ num ] == -1 ) {
280 /* Auto-scan will be stopped when first ISA card were found */
281 scandone = 1;
282 if( num > 0 )
283 return -ENODEV;
284 }
285
286 for( i = 0; netcard_portlist[ i ]; ++i ) {
287 int ioaddr = netcard_portlist[ i ];
288 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
289 && sbni_probe1( dev, ioaddr, 0 ))
290 return 0;
291 }
292
293 return -ENODEV;
294 }
295
296
297 static int __init
298 sbni_pci_probe( struct net_device *dev )
299 {
300 struct pci_dev *pdev = NULL;
301
302 while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
303 != NULL ) {
304 int pci_irq_line;
305 unsigned long pci_ioaddr;
306 u16 subsys;
307
308 if( pdev->vendor != SBNI_PCI_VENDOR
309 && pdev->device != SBNI_PCI_DEVICE )
310 continue;
311
312 pci_ioaddr = pci_resource_start( pdev, 0 );
313 pci_irq_line = pdev->irq;
314
315 /* Avoid already found cards from previous calls */
316 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
317 pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
318
319 if (subsys != 2)
320 continue;
321
322 /* Dual adapter is present */
323 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
324 dev->name ) )
325 continue;
326 }
327
328 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
329 printk( KERN_WARNING " WARNING: The PCI BIOS assigned "
330 "this PCI card to IRQ %d, which is unlikely "
331 "to work!.\n"
332 KERN_WARNING " You should use the PCI BIOS "
333 "setup to assign a valid IRQ line.\n",
334 pci_irq_line );
335
336 /* avoiding re-enable dual adapters */
337 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
338 release_region( pci_ioaddr, SBNI_IO_EXTENT );
339 pci_dev_put( pdev );
340 return -EIO;
341 }
342 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
343 SET_NETDEV_DEV(dev, &pdev->dev);
344 /* not the best thing to do, but this is all messed up
345 for hotplug systems anyway... */
346 pci_dev_put( pdev );
347 return 0;
348 }
349 }
350 return -ENODEV;
351 }
352
353
354 static struct net_device * __init
355 sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
356 {
357 struct net_local *nl;
358
359 if( sbni_card_probe( ioaddr ) ) {
360 release_region( ioaddr, SBNI_IO_EXTENT );
361 return NULL;
362 }
363
364 outb( 0, ioaddr + CSR0 );
365
366 if( irq < 2 ) {
367 unsigned long irq_mask;
368
369 irq_mask = probe_irq_on();
370 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
371 outb( PR_RES, ioaddr + CSR1 );
372 mdelay(50);
373 irq = probe_irq_off(irq_mask);
374 outb( 0, ioaddr + CSR0 );
375
376 if( !irq ) {
377 printk( KERN_ERR "%s: can't detect device irq!\n",
378 dev->name );
379 release_region( ioaddr, SBNI_IO_EXTENT );
380 return NULL;
381 }
382 } else if( irq == 2 )
383 irq = 9;
384
385 dev->irq = irq;
386 dev->base_addr = ioaddr;
387
388 /* Fill in sbni-specific dev fields. */
389 nl = netdev_priv(dev);
390 if( !nl ) {
391 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
392 release_region( ioaddr, SBNI_IO_EXTENT );
393 return NULL;
394 }
395
396 memset( nl, 0, sizeof(struct net_local) );
397 spin_lock_init( &nl->lock );
398
399 /* store MAC address (generate if that isn't known) */
400 *(__be16 *)dev->dev_addr = htons( 0x00ff );
401 *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
402 ((mac[num] ?
403 mac[num] :
404 (u32)((long)netdev_priv(dev))) & 0x00ffffff));
405
406 /* store link settings (speed, receive level ) */
407 nl->maxframe = DEFAULT_FRAME_LEN;
408 nl->csr1.rate = baud[ num ];
409
410 if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
411 /* autotune rxl */
412 nl->cur_rxl_index = DEF_RXL,
413 nl->delta_rxl = DEF_RXL_DELTA;
414 else
415 nl->delta_rxl = 0;
416 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
417 if( inb( ioaddr + CSR0 ) & 0x01 )
418 nl->state |= FL_SLOW_MODE;
419
420 printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
421 "MAC: 00:ff:01:%02x:%02x:%02x\n",
422 dev->name, dev->base_addr, dev->irq,
423 ((u8 *) dev->dev_addr) [3],
424 ((u8 *) dev->dev_addr) [4],
425 ((u8 *) dev->dev_addr) [5] );
426
427 printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
428 ( (nl->state & FL_SLOW_MODE) ? 500000 : 2000000)
429 / (1 << nl->csr1.rate) );
430
431 if( nl->delta_rxl == 0 )
432 printk( "0x%x (fixed)\n", nl->cur_rxl_index );
433 else
434 printk( "(auto)\n");
435
436 #ifdef CONFIG_SBNI_MULTILINE
437 nl->master = dev;
438 nl->link = NULL;
439 #endif
440
441 sbni_cards[ num++ ] = dev;
442 return dev;
443 }
444
445 /* -------------------------------------------------------------------------- */
446
447 #ifdef CONFIG_SBNI_MULTILINE
448
449 static int
450 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
451 {
452 struct net_device *p;
453
454 netif_stop_queue( dev );
455
456 /* Looking for idle device in the list */
457 for( p = dev; p; ) {
458 struct net_local *nl = netdev_priv(p);
459 spin_lock( &nl->lock );
460 if( nl->tx_buf_p || (nl->state & FL_LINE_DOWN) ) {
461 p = nl->link;
462 spin_unlock( &nl->lock );
463 } else {
464 /* Idle dev is found */
465 prepare_to_send( skb, p );
466 spin_unlock( &nl->lock );
467 netif_start_queue( dev );
468 return NETDEV_TX_OK;
469 }
470 }
471
472 return NETDEV_TX_BUSY;
473 }
474
475 #else /* CONFIG_SBNI_MULTILINE */
476
477 static int
478 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
479 {
480 struct net_local *nl = netdev_priv(dev);
481
482 netif_stop_queue( dev );
483 spin_lock( &nl->lock );
484
485 prepare_to_send( skb, dev );
486
487 spin_unlock( &nl->lock );
488 return NETDEV_TX_OK;
489 }
490
491 #endif /* CONFIG_SBNI_MULTILINE */
492
493 /* -------------------------------------------------------------------------- */
494
495 /* interrupt handler */
496
497 /*
498 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
499 * be looked as two independent single-channel devices. Every channel seems
500 * as Ethernet interface but interrupt handler must be common. Really, first
501 * channel ("master") driver only registers the handler. In its struct net_local
502 * it has got pointer to "slave" channel's struct net_local and handles that's
503 * interrupts too.
504 * dev of successfully attached ISA SBNI boards is linked to list.
505 * While next board driver is initialized, it scans this list. If one
506 * has found dev with same irq and ioaddr different by 4 then it assumes
507 * this board to be "master".
508 */
509
510 static irqreturn_t
511 sbni_interrupt( int irq, void *dev_id )
512 {
513 struct net_device *dev = dev_id;
514 struct net_local *nl = netdev_priv(dev);
515 int repeat;
516
517 spin_lock( &nl->lock );
518 if( nl->second )
519 spin_lock(&NET_LOCAL_LOCK(nl->second));
520
521 do {
522 repeat = 0;
523 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
524 handle_channel( dev ),
525 repeat = 1;
526 if( nl->second && /* second channel present */
527 (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
528 handle_channel( nl->second ),
529 repeat = 1;
530 } while( repeat );
531
532 if( nl->second )
533 spin_unlock(&NET_LOCAL_LOCK(nl->second));
534 spin_unlock( &nl->lock );
535 return IRQ_HANDLED;
536 }
537
538
539 static void
540 handle_channel( struct net_device *dev )
541 {
542 struct net_local *nl = netdev_priv(dev);
543 unsigned long ioaddr = dev->base_addr;
544
545 int req_ans;
546 unsigned char csr0;
547
548 #ifdef CONFIG_SBNI_MULTILINE
549 /* Lock the master device because we going to change its local data */
550 if( nl->state & FL_SLAVE )
551 spin_lock(&NET_LOCAL_LOCK(nl->master));
552 #endif
553
554 outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
555
556 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
557 for(;;) {
558 csr0 = inb( ioaddr + CSR0 );
559 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
560 break;
561
562 req_ans = !(nl->state & FL_PREV_OK);
563
564 if( csr0 & RC_RDY )
565 req_ans = recv_frame( dev );
566
567 /*
568 * TR_RDY always equals 1 here because we have owned the marker,
569 * and we set TR_REQ when disabled interrupts
570 */
571 csr0 = inb( ioaddr + CSR0 );
572 if( !(csr0 & TR_RDY) || (csr0 & RC_RDY) )
573 printk( KERN_ERR "%s: internal error!\n", dev->name );
574
575 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
576 if( req_ans || nl->tx_frameno != 0 )
577 send_frame( dev );
578 else
579 /* send marker without any data */
580 outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
581 }
582
583 outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
584
585 #ifdef CONFIG_SBNI_MULTILINE
586 if( nl->state & FL_SLAVE )
587 spin_unlock(&NET_LOCAL_LOCK(nl->master));
588 #endif
589 }
590
591
592 /*
593 * Routine returns 1 if it need to acknoweledge received frame.
594 * Empty frame received without errors won't be acknoweledged.
595 */
596
597 static int
598 recv_frame( struct net_device *dev )
599 {
600 struct net_local *nl = netdev_priv(dev);
601 unsigned long ioaddr = dev->base_addr;
602
603 u32 crc = CRC32_INITIAL;
604
605 unsigned framelen = 0, frameno, ack;
606 unsigned is_first, frame_ok = 0;
607
608 if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
609 frame_ok = framelen > 4
610 ? upload_data( dev, framelen, frameno, is_first, crc )
611 : skip_tail( ioaddr, framelen, crc );
612 if( frame_ok )
613 interpret_ack( dev, ack );
614 }
615
616 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
617 if( frame_ok ) {
618 nl->state |= FL_PREV_OK;
619 if( framelen > 4 )
620 nl->in_stats.all_rx_number++;
621 } else
622 nl->state &= ~FL_PREV_OK,
623 change_level( dev ),
624 nl->in_stats.all_rx_number++,
625 nl->in_stats.bad_rx_number++;
626
627 return !frame_ok || framelen > 4;
628 }
629
630
631 static void
632 send_frame( struct net_device *dev )
633 {
634 struct net_local *nl = netdev_priv(dev);
635
636 u32 crc = CRC32_INITIAL;
637
638 if( nl->state & FL_NEED_RESEND ) {
639
640 /* if frame was sended but not ACK'ed - resend it */
641 if( nl->trans_errors ) {
642 --nl->trans_errors;
643 if( nl->framelen != 0 )
644 nl->in_stats.resend_tx_number++;
645 } else {
646 /* cannot xmit with many attempts */
647 #ifdef CONFIG_SBNI_MULTILINE
648 if( (nl->state & FL_SLAVE) || nl->link )
649 #endif
650 nl->state |= FL_LINE_DOWN;
651 drop_xmit_queue( dev );
652 goto do_send;
653 }
654 } else
655 nl->trans_errors = TR_ERROR_COUNT;
656
657 send_frame_header( dev, &crc );
658 nl->state |= FL_NEED_RESEND;
659 /*
660 * FL_NEED_RESEND will be cleared after ACK, but if empty
661 * frame sended then in prepare_to_send next frame
662 */
663
664
665 if( nl->framelen ) {
666 download_data( dev, &crc );
667 nl->in_stats.all_tx_number++;
668 nl->state |= FL_WAIT_ACK;
669 }
670
671 outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
672
673 do_send:
674 outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
675
676 if( nl->tx_frameno )
677 /* next frame exists - we request card to send it */
678 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
679 dev->base_addr + CSR0 );
680 }
681
682
683 /*
684 * Write the frame data into adapter's buffer memory, and calculate CRC.
685 * Do padding if necessary.
686 */
687
688 static void
689 download_data( struct net_device *dev, u32 *crc_p )
690 {
691 struct net_local *nl = netdev_priv(dev);
692 struct sk_buff *skb = nl->tx_buf_p;
693
694 unsigned len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
695
696 outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
697 *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
698
699 /* if packet too short we should write some more bytes to pad */
700 for( len = nl->framelen - len; len--; )
701 outb( 0, dev->base_addr + DAT ),
702 *crc_p = CRC32( 0, *crc_p );
703 }
704
705
706 static int
707 upload_data( struct net_device *dev, unsigned framelen, unsigned frameno,
708 unsigned is_first, u32 crc )
709 {
710 struct net_local *nl = netdev_priv(dev);
711
712 int frame_ok;
713
714 if( is_first )
715 nl->wait_frameno = frameno,
716 nl->inppos = 0;
717
718 if( nl->wait_frameno == frameno ) {
719
720 if( nl->inppos + framelen <= ETHER_MAX_LEN )
721 frame_ok = append_frame_to_pkt( dev, framelen, crc );
722
723 /*
724 * if CRC is right but framelen incorrect then transmitter
725 * error was occurred... drop entire packet
726 */
727 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
728 != 0 )
729 nl->wait_frameno = 0,
730 nl->inppos = 0,
731 #ifdef CONFIG_SBNI_MULTILINE
732 nl->master->stats.rx_errors++,
733 nl->master->stats.rx_missed_errors++;
734 #else
735 dev->stats.rx_errors++,
736 dev->stats.rx_missed_errors++;
737 #endif
738 /* now skip all frames until is_first != 0 */
739 } else
740 frame_ok = skip_tail( dev->base_addr, framelen, crc );
741
742 if( is_first && !frame_ok )
743 /*
744 * Frame has been broken, but we had already stored
745 * is_first... Drop entire packet.
746 */
747 nl->wait_frameno = 0,
748 #ifdef CONFIG_SBNI_MULTILINE
749 nl->master->stats.rx_errors++,
750 nl->master->stats.rx_crc_errors++;
751 #else
752 dev->stats.rx_errors++,
753 dev->stats.rx_crc_errors++;
754 #endif
755
756 return frame_ok;
757 }
758
759
760 static inline void
761 send_complete( struct net_device *dev )
762 {
763 struct net_local *nl = netdev_priv(dev);
764
765 #ifdef CONFIG_SBNI_MULTILINE
766 nl->master->stats.tx_packets++;
767 nl->master->stats.tx_bytes += nl->tx_buf_p->len;
768 #else
769 dev->stats.tx_packets++;
770 dev->stats.tx_bytes += nl->tx_buf_p->len;
771 #endif
772 dev_kfree_skb_irq( nl->tx_buf_p );
773
774 nl->tx_buf_p = NULL;
775
776 nl->outpos = 0;
777 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
778 nl->framelen = 0;
779 }
780
781
782 static void
783 interpret_ack( struct net_device *dev, unsigned ack )
784 {
785 struct net_local *nl = netdev_priv(dev);
786
787 if( ack == FRAME_SENT_OK ) {
788 nl->state &= ~FL_NEED_RESEND;
789
790 if( nl->state & FL_WAIT_ACK ) {
791 nl->outpos += nl->framelen;
792
793 if( --nl->tx_frameno )
794 nl->framelen = min_t(unsigned int,
795 nl->maxframe,
796 nl->tx_buf_p->len - nl->outpos);
797 else
798 send_complete( dev ),
799 #ifdef CONFIG_SBNI_MULTILINE
800 netif_wake_queue( nl->master );
801 #else
802 netif_wake_queue( dev );
803 #endif
804 }
805 }
806
807 nl->state &= ~FL_WAIT_ACK;
808 }
809
810
811 /*
812 * Glue received frame with previous fragments of packet.
813 * Indicate packet when last frame would be accepted.
814 */
815
816 static int
817 append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
818 {
819 struct net_local *nl = netdev_priv(dev);
820
821 u8 *p;
822
823 if( nl->inppos + framelen > ETHER_MAX_LEN )
824 return 0;
825
826 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
827 return 0;
828
829 p = nl->rx_buf_p->data + nl->inppos;
830 insb( dev->base_addr + DAT, p, framelen );
831 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
832 return 0;
833
834 nl->inppos += framelen - 4;
835 if( --nl->wait_frameno == 0 ) /* last frame received */
836 indicate_pkt( dev );
837
838 return 1;
839 }
840
841
842 /*
843 * Prepare to start output on adapter.
844 * Transmitter will be actually activated when marker is accepted.
845 */
846
847 static void
848 prepare_to_send( struct sk_buff *skb, struct net_device *dev )
849 {
850 struct net_local *nl = netdev_priv(dev);
851
852 unsigned int len;
853
854 /* nl->tx_buf_p == NULL here! */
855 if( nl->tx_buf_p )
856 printk( KERN_ERR "%s: memory leak!\n", dev->name );
857
858 nl->outpos = 0;
859 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
860
861 len = skb->len;
862 if( len < SBNI_MIN_LEN )
863 len = SBNI_MIN_LEN;
864
865 nl->tx_buf_p = skb;
866 nl->tx_frameno = DIV_ROUND_UP(len, nl->maxframe);
867 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
868
869 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
870 #ifdef CONFIG_SBNI_MULTILINE
871 nl->master->trans_start = jiffies;
872 #else
873 dev->trans_start = jiffies;
874 #endif
875 }
876
877
878 static void
879 drop_xmit_queue( struct net_device *dev )
880 {
881 struct net_local *nl = netdev_priv(dev);
882
883 if( nl->tx_buf_p )
884 dev_kfree_skb_any( nl->tx_buf_p ),
885 nl->tx_buf_p = NULL,
886 #ifdef CONFIG_SBNI_MULTILINE
887 nl->master->stats.tx_errors++,
888 nl->master->stats.tx_carrier_errors++;
889 #else
890 dev->stats.tx_errors++,
891 dev->stats.tx_carrier_errors++;
892 #endif
893
894 nl->tx_frameno = 0;
895 nl->framelen = 0;
896 nl->outpos = 0;
897 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
898 #ifdef CONFIG_SBNI_MULTILINE
899 netif_start_queue( nl->master );
900 nl->master->trans_start = jiffies;
901 #else
902 netif_start_queue( dev );
903 dev->trans_start = jiffies;
904 #endif
905 }
906
907
908 static void
909 send_frame_header( struct net_device *dev, u32 *crc_p )
910 {
911 struct net_local *nl = netdev_priv(dev);
912
913 u32 crc = *crc_p;
914 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
915 u8 value;
916
917 if( nl->state & FL_NEED_RESEND )
918 len_field |= FRAME_RETRY; /* non-first attempt... */
919
920 if( nl->outpos == 0 )
921 len_field |= FRAME_FIRST;
922
923 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
924 outb( SBNI_SIG, dev->base_addr + DAT );
925
926 value = (u8) len_field;
927 outb( value, dev->base_addr + DAT );
928 crc = CRC32( value, crc );
929 value = (u8) (len_field >> 8);
930 outb( value, dev->base_addr + DAT );
931 crc = CRC32( value, crc );
932
933 outb( nl->tx_frameno, dev->base_addr + DAT );
934 crc = CRC32( nl->tx_frameno, crc );
935 outb( 0, dev->base_addr + DAT );
936 crc = CRC32( 0, crc );
937 *crc_p = crc;
938 }
939
940
941 /*
942 * if frame tail not needed (incorrect number or received twice),
943 * it won't store, but CRC will be calculated
944 */
945
946 static int
947 skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
948 {
949 while( tail_len-- )
950 crc = CRC32( inb( ioaddr + DAT ), crc );
951
952 return crc == CRC32_REMAINDER;
953 }
954
955
956 /*
957 * Preliminary checks if frame header is correct, calculates its CRC
958 * and split it to simple fields
959 */
960
961 static int
962 check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
963 u32 *is_first, u32 *crc_p )
964 {
965 u32 crc = *crc_p;
966 u8 value;
967
968 if( inb( ioaddr + DAT ) != SBNI_SIG )
969 return 0;
970
971 value = inb( ioaddr + DAT );
972 *framelen = (u32)value;
973 crc = CRC32( value, crc );
974 value = inb( ioaddr + DAT );
975 *framelen |= ((u32)value) << 8;
976 crc = CRC32( value, crc );
977
978 *ack = *framelen & FRAME_ACK_MASK;
979 *is_first = (*framelen & FRAME_FIRST) != 0;
980
981 if( (*framelen &= FRAME_LEN_MASK) < 6
982 || *framelen > SBNI_MAX_FRAME - 3 )
983 return 0;
984
985 value = inb( ioaddr + DAT );
986 *frameno = (u32)value;
987 crc = CRC32( value, crc );
988
989 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
990 *framelen -= 2;
991
992 *crc_p = crc;
993 return 1;
994 }
995
996
997 static struct sk_buff *
998 get_rx_buf( struct net_device *dev )
999 {
1000 /* +2 is to compensate for the alignment fixup below */
1001 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
1002 if( !skb )
1003 return NULL;
1004
1005 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1006 return skb;
1007 }
1008
1009
1010 static void
1011 indicate_pkt( struct net_device *dev )
1012 {
1013 struct net_local *nl = netdev_priv(dev);
1014 struct sk_buff *skb = nl->rx_buf_p;
1015
1016 skb_put( skb, nl->inppos );
1017
1018 #ifdef CONFIG_SBNI_MULTILINE
1019 skb->protocol = eth_type_trans( skb, nl->master );
1020 netif_rx( skb );
1021 ++nl->master->stats.rx_packets;
1022 nl->master->stats.rx_bytes += nl->inppos;
1023 #else
1024 skb->protocol = eth_type_trans( skb, dev );
1025 netif_rx( skb );
1026 ++dev->stats.rx_packets;
1027 dev->stats.rx_bytes += nl->inppos;
1028 #endif
1029 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1030 }
1031
1032
1033 /* -------------------------------------------------------------------------- */
1034
1035 /*
1036 * Routine checks periodically wire activity and regenerates marker if
1037 * connect was inactive for a long time.
1038 */
1039
1040 static void
1041 sbni_watchdog( unsigned long arg )
1042 {
1043 struct net_device *dev = (struct net_device *) arg;
1044 struct net_local *nl = netdev_priv(dev);
1045 struct timer_list *w = &nl->watchdog;
1046 unsigned long flags;
1047 unsigned char csr0;
1048
1049 spin_lock_irqsave( &nl->lock, flags );
1050
1051 csr0 = inb( dev->base_addr + CSR0 );
1052 if( csr0 & RC_CHK ) {
1053
1054 if( nl->timer_ticks ) {
1055 if( csr0 & (RC_RDY | BU_EMP) )
1056 /* receiving not active */
1057 nl->timer_ticks--;
1058 } else {
1059 nl->in_stats.timeout_number++;
1060 if( nl->delta_rxl )
1061 timeout_change_level( dev );
1062
1063 outb( *(u_char *)&nl->csr1 | PR_RES,
1064 dev->base_addr + CSR1 );
1065 csr0 = inb( dev->base_addr + CSR0 );
1066 }
1067 } else
1068 nl->state &= ~FL_LINE_DOWN;
1069
1070 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1071
1072 init_timer( w );
1073 w->expires = jiffies + SBNI_TIMEOUT;
1074 w->data = arg;
1075 w->function = sbni_watchdog;
1076 add_timer( w );
1077
1078 spin_unlock_irqrestore( &nl->lock, flags );
1079 }
1080
1081
1082 static unsigned char rxl_tab[] = {
1083 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1084 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1085 };
1086
1087 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1088 static unsigned char timeout_rxl_tab[] = {
1089 0x03, 0x05, 0x08, 0x0b
1090 };
1091
1092 /* -------------------------------------------------------------------------- */
1093
1094 static void
1095 card_start( struct net_device *dev )
1096 {
1097 struct net_local *nl = netdev_priv(dev);
1098
1099 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1100 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1101 nl->state |= FL_PREV_OK;
1102
1103 nl->inppos = nl->outpos = 0;
1104 nl->wait_frameno = 0;
1105 nl->tx_frameno = 0;
1106 nl->framelen = 0;
1107
1108 outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1109 outb( EN_INT, dev->base_addr + CSR0 );
1110 }
1111
1112 /* -------------------------------------------------------------------------- */
1113
1114 /* Receive level auto-selection */
1115
1116 static void
1117 change_level( struct net_device *dev )
1118 {
1119 struct net_local *nl = netdev_priv(dev);
1120
1121 if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
1122 return;
1123
1124 if( nl->cur_rxl_index == 0 )
1125 nl->delta_rxl = 1;
1126 else if( nl->cur_rxl_index == 15 )
1127 nl->delta_rxl = -1;
1128 else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1129 nl->delta_rxl = -nl->delta_rxl;
1130
1131 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1132 inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
1133 outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1134
1135 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1136 nl->cur_rxl_rcvd = 0;
1137 }
1138
1139
1140 static void
1141 timeout_change_level( struct net_device *dev )
1142 {
1143 struct net_local *nl = netdev_priv(dev);
1144
1145 nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1146 if( ++nl->timeout_rxl >= 4 )
1147 nl->timeout_rxl = 0;
1148
1149 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1150 inb( dev->base_addr + CSR0 );
1151 outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1152
1153 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1154 nl->cur_rxl_rcvd = 0;
1155 }
1156
1157 /* -------------------------------------------------------------------------- */
1158
1159 /*
1160 * Open/initialize the board.
1161 */
1162
1163 static int
1164 sbni_open( struct net_device *dev )
1165 {
1166 struct net_local *nl = netdev_priv(dev);
1167 struct timer_list *w = &nl->watchdog;
1168
1169 /*
1170 * For double ISA adapters within "common irq" mode, we have to
1171 * determine whether primary or secondary channel is initialized,
1172 * and set the irq handler only in first case.
1173 */
1174 if( dev->base_addr < 0x400 ) { /* ISA only */
1175 struct net_device **p = sbni_cards;
1176 for( ; *p && p < sbni_cards + SBNI_MAX_NUM_CARDS; ++p )
1177 if( (*p)->irq == dev->irq
1178 && ((*p)->base_addr == dev->base_addr + 4
1179 || (*p)->base_addr == dev->base_addr - 4)
1180 && (*p)->flags & IFF_UP ) {
1181
1182 ((struct net_local *) (netdev_priv(*p)))
1183 ->second = dev;
1184 printk( KERN_NOTICE "%s: using shared irq "
1185 "with %s\n", dev->name, (*p)->name );
1186 nl->state |= FL_SECONDARY;
1187 goto handler_attached;
1188 }
1189 }
1190
1191 if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1192 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1193 dev->name, dev->irq );
1194 return -EAGAIN;
1195 }
1196
1197 handler_attached:
1198
1199 spin_lock( &nl->lock );
1200 memset( &dev->stats, 0, sizeof(struct net_device_stats) );
1201 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1202
1203 card_start( dev );
1204
1205 netif_start_queue( dev );
1206
1207 /* set timer watchdog */
1208 init_timer( w );
1209 w->expires = jiffies + SBNI_TIMEOUT;
1210 w->data = (unsigned long) dev;
1211 w->function = sbni_watchdog;
1212 add_timer( w );
1213
1214 spin_unlock( &nl->lock );
1215 return 0;
1216 }
1217
1218
1219 static int
1220 sbni_close( struct net_device *dev )
1221 {
1222 struct net_local *nl = netdev_priv(dev);
1223
1224 if( nl->second && nl->second->flags & IFF_UP ) {
1225 printk( KERN_NOTICE "Secondary channel (%s) is active!\n",
1226 nl->second->name );
1227 return -EBUSY;
1228 }
1229
1230 #ifdef CONFIG_SBNI_MULTILINE
1231 if( nl->state & FL_SLAVE )
1232 emancipate( dev );
1233 else
1234 while( nl->link ) /* it's master device! */
1235 emancipate( nl->link );
1236 #endif
1237
1238 spin_lock( &nl->lock );
1239
1240 nl->second = NULL;
1241 drop_xmit_queue( dev );
1242 netif_stop_queue( dev );
1243
1244 del_timer( &nl->watchdog );
1245
1246 outb( 0, dev->base_addr + CSR0 );
1247
1248 if( !(nl->state & FL_SECONDARY) )
1249 free_irq( dev->irq, dev );
1250 nl->state &= FL_SECONDARY;
1251
1252 spin_unlock( &nl->lock );
1253 return 0;
1254 }
1255
1256
1257 /*
1258 Valid combinations in CSR0 (for probing):
1259
1260 VALID_DECODER 0000,0011,1011,1010
1261
1262 ; 0 ; -
1263 TR_REQ ; 1 ; +
1264 TR_RDY ; 2 ; -
1265 TR_RDY TR_REQ ; 3 ; +
1266 BU_EMP ; 4 ; +
1267 BU_EMP TR_REQ ; 5 ; +
1268 BU_EMP TR_RDY ; 6 ; -
1269 BU_EMP TR_RDY TR_REQ ; 7 ; +
1270 RC_RDY ; 8 ; +
1271 RC_RDY TR_REQ ; 9 ; +
1272 RC_RDY TR_RDY ; 10 ; -
1273 RC_RDY TR_RDY TR_REQ ; 11 ; -
1274 RC_RDY BU_EMP ; 12 ; -
1275 RC_RDY BU_EMP TR_REQ ; 13 ; -
1276 RC_RDY BU_EMP TR_RDY ; 14 ; -
1277 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1278 */
1279
1280 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1281
1282
1283 static int
1284 sbni_card_probe( unsigned long ioaddr )
1285 {
1286 unsigned char csr0;
1287
1288 csr0 = inb( ioaddr + CSR0 );
1289 if( csr0 != 0xff && csr0 != 0x00 ) {
1290 csr0 &= ~EN_INT;
1291 if( csr0 & BU_EMP )
1292 csr0 |= EN_INT;
1293
1294 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1295 return 0;
1296 }
1297
1298 return -ENODEV;
1299 }
1300
1301 /* -------------------------------------------------------------------------- */
1302
1303 static int
1304 sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1305 {
1306 struct net_local *nl = netdev_priv(dev);
1307 struct sbni_flags flags;
1308 int error = 0;
1309
1310 #ifdef CONFIG_SBNI_MULTILINE
1311 struct net_device *slave_dev;
1312 char slave_name[ 8 ];
1313 #endif
1314
1315 switch( cmd ) {
1316 case SIOCDEVGETINSTATS :
1317 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1318 sizeof(struct sbni_in_stats) ))
1319 error = -EFAULT;
1320 break;
1321
1322 case SIOCDEVRESINSTATS :
1323 if (!capable(CAP_NET_ADMIN))
1324 return -EPERM;
1325 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1326 break;
1327
1328 case SIOCDEVGHWSTATE :
1329 flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
1330 flags.rate = nl->csr1.rate;
1331 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1332 flags.rxl = nl->cur_rxl_index;
1333 flags.fixed_rxl = nl->delta_rxl == 0;
1334
1335 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1336 error = -EFAULT;
1337 break;
1338
1339 case SIOCDEVSHWSTATE :
1340 if (!capable(CAP_NET_ADMIN))
1341 return -EPERM;
1342
1343 spin_lock( &nl->lock );
1344 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1345 if( flags.fixed_rxl )
1346 nl->delta_rxl = 0,
1347 nl->cur_rxl_index = flags.rxl;
1348 else
1349 nl->delta_rxl = DEF_RXL_DELTA,
1350 nl->cur_rxl_index = DEF_RXL;
1351
1352 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1353 nl->csr1.rate = flags.rate;
1354 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1355 spin_unlock( &nl->lock );
1356 break;
1357
1358 #ifdef CONFIG_SBNI_MULTILINE
1359
1360 case SIOCDEVENSLAVE :
1361 if (!capable(CAP_NET_ADMIN))
1362 return -EPERM;
1363
1364 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1365 return -EFAULT;
1366 slave_dev = dev_get_by_name(&init_net, slave_name );
1367 if( !slave_dev || !(slave_dev->flags & IFF_UP) ) {
1368 printk( KERN_ERR "%s: trying to enslave non-active "
1369 "device %s\n", dev->name, slave_name );
1370 return -EPERM;
1371 }
1372
1373 return enslave( dev, slave_dev );
1374
1375 case SIOCDEVEMANSIPATE :
1376 if (!capable(CAP_NET_ADMIN))
1377 return -EPERM;
1378
1379 return emancipate( dev );
1380
1381 #endif /* CONFIG_SBNI_MULTILINE */
1382
1383 default :
1384 return -EOPNOTSUPP;
1385 }
1386
1387 return error;
1388 }
1389
1390
1391 #ifdef CONFIG_SBNI_MULTILINE
1392
1393 static int
1394 enslave( struct net_device *dev, struct net_device *slave_dev )
1395 {
1396 struct net_local *nl = netdev_priv(dev);
1397 struct net_local *snl = netdev_priv(slave_dev);
1398
1399 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1400 return -EBUSY;
1401
1402 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1403 return -EBUSY;
1404
1405 spin_lock( &nl->lock );
1406 spin_lock( &snl->lock );
1407
1408 /* append to list */
1409 snl->link = nl->link;
1410 nl->link = slave_dev;
1411 snl->master = dev;
1412 snl->state |= FL_SLAVE;
1413
1414 /* Summary statistics of MultiLine operation will be stored
1415 in master's counters */
1416 memset( &slave_dev->stats, 0, sizeof(struct net_device_stats) );
1417 netif_stop_queue( slave_dev );
1418 netif_wake_queue( dev ); /* Now we are able to transmit */
1419
1420 spin_unlock( &snl->lock );
1421 spin_unlock( &nl->lock );
1422 printk( KERN_NOTICE "%s: slave device (%s) attached.\n",
1423 dev->name, slave_dev->name );
1424 return 0;
1425 }
1426
1427
1428 static int
1429 emancipate( struct net_device *dev )
1430 {
1431 struct net_local *snl = netdev_priv(dev);
1432 struct net_device *p = snl->master;
1433 struct net_local *nl = netdev_priv(p);
1434
1435 if( !(snl->state & FL_SLAVE) )
1436 return -EINVAL;
1437
1438 spin_lock( &nl->lock );
1439 spin_lock( &snl->lock );
1440 drop_xmit_queue( dev );
1441
1442 /* exclude from list */
1443 for(;;) { /* must be in list */
1444 struct net_local *t = netdev_priv(p);
1445 if( t->link == dev ) {
1446 t->link = snl->link;
1447 break;
1448 }
1449 p = t->link;
1450 }
1451
1452 snl->link = NULL;
1453 snl->master = dev;
1454 snl->state &= ~FL_SLAVE;
1455
1456 netif_start_queue( dev );
1457
1458 spin_unlock( &snl->lock );
1459 spin_unlock( &nl->lock );
1460
1461 dev_put( dev );
1462 return 0;
1463 }
1464
1465 #endif
1466
1467 static void
1468 set_multicast_list( struct net_device *dev )
1469 {
1470 return; /* sbni always operate in promiscuos mode */
1471 }
1472
1473
1474 #ifdef MODULE
1475 module_param_array(io, int, NULL, 0);
1476 module_param_array(irq, int, NULL, 0);
1477 module_param_array(baud, int, NULL, 0);
1478 module_param_array(rxl, int, NULL, 0);
1479 module_param_array(mac, int, NULL, 0);
1480 module_param(skip_pci_probe, bool, 0);
1481
1482 MODULE_LICENSE("GPL");
1483
1484
1485 int __init init_module( void )
1486 {
1487 struct net_device *dev;
1488 int err;
1489
1490 while( num < SBNI_MAX_NUM_CARDS ) {
1491 dev = alloc_netdev(sizeof(struct net_local),
1492 "sbni%d", sbni_devsetup);
1493 if( !dev)
1494 break;
1495
1496 sprintf( dev->name, "sbni%d", num );
1497
1498 err = sbni_init(dev);
1499 if (err) {
1500 free_netdev(dev);
1501 break;
1502 }
1503
1504 if( register_netdev( dev ) ) {
1505 release_region( dev->base_addr, SBNI_IO_EXTENT );
1506 free_netdev( dev );
1507 break;
1508 }
1509 }
1510
1511 return *sbni_cards ? 0 : -ENODEV;
1512 }
1513
1514 void
1515 cleanup_module(void)
1516 {
1517 int i;
1518
1519 for (i = 0; i < SBNI_MAX_NUM_CARDS; ++i) {
1520 struct net_device *dev = sbni_cards[i];
1521 if (dev != NULL) {
1522 unregister_netdev(dev);
1523 release_region(dev->base_addr, SBNI_IO_EXTENT);
1524 free_netdev(dev);
1525 }
1526 }
1527 }
1528
1529 #else /* MODULE */
1530
1531 static int __init
1532 sbni_setup( char *p )
1533 {
1534 int n, parm;
1535
1536 if( *p++ != '(' )
1537 goto bad_param;
1538
1539 for( n = 0, parm = 0; *p && n < 8; ) {
1540 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1541 if( !*p || *p == ')' )
1542 return 1;
1543 if( *p == ';' )
1544 ++p, ++n, parm = 0;
1545 else if( *p++ != ',' )
1546 break;
1547 else
1548 if( ++parm >= 5 )
1549 break;
1550 }
1551 bad_param:
1552 printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1553 return 0;
1554 }
1555
1556 __setup( "sbni=", sbni_setup );
1557
1558 #endif /* MODULE */
1559
1560 /* -------------------------------------------------------------------------- */
1561
1562 #ifdef ASM_CRC
1563
1564 static u32
1565 calc_crc32( u32 crc, u8 *p, u32 len )
1566 {
1567 register u32 _crc;
1568 _crc = crc;
1569
1570 __asm__ __volatile__ (
1571 "xorl %%ebx, %%ebx\n"
1572 "movl %2, %%esi\n"
1573 "movl %3, %%ecx\n"
1574 "movl $crc32tab, %%edi\n"
1575 "shrl $2, %%ecx\n"
1576 "jz 1f\n"
1577
1578 ".align 4\n"
1579 "0:\n"
1580 "movb %%al, %%bl\n"
1581 "movl (%%esi), %%edx\n"
1582 "shrl $8, %%eax\n"
1583 "xorb %%dl, %%bl\n"
1584 "shrl $8, %%edx\n"
1585 "xorl (%%edi,%%ebx,4), %%eax\n"
1586
1587 "movb %%al, %%bl\n"
1588 "shrl $8, %%eax\n"
1589 "xorb %%dl, %%bl\n"
1590 "shrl $8, %%edx\n"
1591 "xorl (%%edi,%%ebx,4), %%eax\n"
1592
1593 "movb %%al, %%bl\n"
1594 "shrl $8, %%eax\n"
1595 "xorb %%dl, %%bl\n"
1596 "movb %%dh, %%dl\n"
1597 "xorl (%%edi,%%ebx,4), %%eax\n"
1598
1599 "movb %%al, %%bl\n"
1600 "shrl $8, %%eax\n"
1601 "xorb %%dl, %%bl\n"
1602 "addl $4, %%esi\n"
1603 "xorl (%%edi,%%ebx,4), %%eax\n"
1604
1605 "decl %%ecx\n"
1606 "jnz 0b\n"
1607
1608 "1:\n"
1609 "movl %3, %%ecx\n"
1610 "andl $3, %%ecx\n"
1611 "jz 2f\n"
1612
1613 "movb %%al, %%bl\n"
1614 "shrl $8, %%eax\n"
1615 "xorb (%%esi), %%bl\n"
1616 "xorl (%%edi,%%ebx,4), %%eax\n"
1617
1618 "decl %%ecx\n"
1619 "jz 2f\n"
1620
1621 "movb %%al, %%bl\n"
1622 "shrl $8, %%eax\n"
1623 "xorb 1(%%esi), %%bl\n"
1624 "xorl (%%edi,%%ebx,4), %%eax\n"
1625
1626 "decl %%ecx\n"
1627 "jz 2f\n"
1628
1629 "movb %%al, %%bl\n"
1630 "shrl $8, %%eax\n"
1631 "xorb 2(%%esi), %%bl\n"
1632 "xorl (%%edi,%%ebx,4), %%eax\n"
1633 "2:\n"
1634 : "=a" (_crc)
1635 : "0" (_crc), "g" (p), "g" (len)
1636 : "bx", "cx", "dx", "si", "di"
1637 );
1638
1639 return _crc;
1640 }
1641
1642 #else /* ASM_CRC */
1643
1644 static u32
1645 calc_crc32( u32 crc, u8 *p, u32 len )
1646 {
1647 while( len-- )
1648 crc = CRC32( *p++, crc );
1649
1650 return crc;
1651 }
1652
1653 #endif /* ASM_CRC */
1654
1655
1656 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1657 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1658 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1659 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1660 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1661 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1662 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1663 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1664 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1665 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1666 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1667 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1668 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1669 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1670 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1671 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1672 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1673 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1674 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1675 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1676 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1677 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1678 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1679 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1680 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1681 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1682 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1683 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1684 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1685 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1686 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1687 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1688 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1689 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1690 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1691 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1692 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1693 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1694 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1695 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1696 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1697 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1698 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1699 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1700 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1701 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1702 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1703 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1704 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1705 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1706 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1707 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1708 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1709 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1710 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1711 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1712 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1713 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1714 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1715 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1716 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1717 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1718 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1719 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1720 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000
1721 };
1722
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree