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