1 /* sbni.c: Granch SBNI12 leased line adapters driver for linux
3 * Written 2001 by Denis I.Timofeev (timofeev@granch.ru)
5 * Previous versions were written by Yaroslav Polyakov,
6 * Alexey Zverev and Max Khon.
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)
13 * This software may be used and distributed according to the terms
14 * of the GNU General Public License.
18 * - Fixed bug in probe
20 * - Driver was completely redesigned by Denis I.Timofeev,
21 * - now PCI/Dual, ISA/Dual (with single interrupt line) models are
23 * 3.3.0 Thu Feb 24 21:30:28 NOVT 2000
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,
37 * Known problem: this driver wasn't tested on multiprocessor machine.
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>
57 #include <net/net_namespace.h>
61 #include <asm/types.h>
62 #include <asm/byteorder.h>
64 #include <asm/uaccess.h>
68 /* device private data */
71 struct net_device_stats stats
;
72 struct timer_list watchdog
;
75 struct sk_buff
*rx_buf_p
; /* receive buffer ptr */
76 struct sk_buff
*tx_buf_p
; /* transmit buffer ptr */
78 unsigned int framelen
; /* current frame length */
79 unsigned int maxframe
; /* maximum valid frame length */
81 unsigned int inppos
, outpos
; /* positions in rx/tx buffers */
83 /* transmitting frame number - from frames qty to 1 */
84 unsigned int tx_frameno
;
86 /* expected number of next receiving frame */
87 unsigned int wait_frameno
;
89 /* count of failed attempts to frame send - 32 attempts do before
90 error - while receiver tunes on opposite side of wire */
91 unsigned int trans_errors
;
93 /* idle time; send pong when limit exceeded */
94 unsigned int timer_ticks
;
96 /* fields used for receive level autoselection */
98 unsigned int cur_rxl_index
, timeout_rxl
;
99 unsigned long cur_rxl_rcvd
, prev_rxl_rcvd
;
101 struct sbni_csr1 csr1
; /* current value of CSR1 */
102 struct sbni_in_stats in_stats
; /* internal statistics */
104 struct net_device
*second
; /* for ISA/dual cards */
106 #ifdef CONFIG_SBNI_MULTILINE
107 struct net_device
*master
;
108 struct net_device
*link
;
113 static int sbni_card_probe( unsigned long );
114 static int sbni_pci_probe( struct net_device
* );
115 static struct net_device
*sbni_probe1(struct net_device
*, unsigned long, int);
116 static int sbni_open( struct net_device
* );
117 static int sbni_close( struct net_device
* );
118 static int sbni_start_xmit( struct sk_buff
*, struct net_device
* );
119 static int sbni_ioctl( struct net_device
*, struct ifreq
*, int );
120 static struct net_device_stats
*sbni_get_stats( struct net_device
* );
121 static void set_multicast_list( struct net_device
* );
123 static irqreturn_t
sbni_interrupt( int, void * );
124 static void handle_channel( struct net_device
* );
125 static int recv_frame( struct net_device
* );
126 static void send_frame( struct net_device
* );
127 static int upload_data( struct net_device
*,
128 unsigned, unsigned, unsigned, u32
);
129 static void download_data( struct net_device
*, u32
* );
130 static void sbni_watchdog( unsigned long );
131 static void interpret_ack( struct net_device
*, unsigned );
132 static int append_frame_to_pkt( struct net_device
*, unsigned, u32
);
133 static void indicate_pkt( struct net_device
* );
134 static void card_start( struct net_device
* );
135 static void prepare_to_send( struct sk_buff
*, struct net_device
* );
136 static void drop_xmit_queue( struct net_device
* );
137 static void send_frame_header( struct net_device
*, u32
* );
138 static int skip_tail( unsigned int, unsigned int, u32
);
139 static int check_fhdr( u32
, u32
*, u32
*, u32
*, u32
*, u32
* );
140 static void change_level( struct net_device
* );
141 static void timeout_change_level( struct net_device
* );
142 static u32
calc_crc32( u32
, u8
*, u32
);
143 static struct sk_buff
* get_rx_buf( struct net_device
* );
144 static int sbni_init( struct net_device
* );
146 #ifdef CONFIG_SBNI_MULTILINE
147 static int enslave( struct net_device
*, struct net_device
* );
148 static int emancipate( struct net_device
* );
155 static const char version
[] =
156 "Granch SBNI12 driver ver 5.0.1 Jun 22 2001 Denis I.Timofeev.\n";
158 static int skip_pci_probe __initdata
= 0;
159 static int scandone __initdata
= 0;
160 static int num __initdata
= 0;
162 static unsigned char rxl_tab
[];
163 static u32 crc32tab
[];
165 /* A list of all installed devices, for removing the driver module. */
166 static struct net_device
*sbni_cards
[ SBNI_MAX_NUM_CARDS
];
168 /* Lists of device's parameters */
169 static u32 io
[ SBNI_MAX_NUM_CARDS
] __initdata
=
170 { [0 ... SBNI_MAX_NUM_CARDS
-1] = -1 };
171 static u32 irq
[ SBNI_MAX_NUM_CARDS
] __initdata
;
172 static u32 baud
[ SBNI_MAX_NUM_CARDS
] __initdata
;
173 static u32 rxl
[ SBNI_MAX_NUM_CARDS
] __initdata
=
174 { [0 ... SBNI_MAX_NUM_CARDS
-1] = -1 };
175 static u32 mac
[ SBNI_MAX_NUM_CARDS
] __initdata
;
179 static iarr __initdata
*dest
[5] = { &io
, &irq
, &baud
, &rxl
, &mac
};
182 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
183 static unsigned int netcard_portlist
[ ] __initdata
= {
184 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
185 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
186 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
191 * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
192 * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
195 static inline int __init
196 sbni_isa_probe( struct net_device
*dev
)
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
) )
204 printk( KERN_ERR
"sbni: base address 0x%lx is busy, or adapter "
205 "is malfunctional!\n", dev
->base_addr
);
210 static void __init
sbni_devsetup(struct net_device
*dev
)
213 dev
->open
= &sbni_open
;
214 dev
->stop
= &sbni_close
;
215 dev
->hard_start_xmit
= &sbni_start_xmit
;
216 dev
->get_stats
= &sbni_get_stats
;
217 dev
->set_multicast_list
= &set_multicast_list
;
218 dev
->do_ioctl
= &sbni_ioctl
;
221 int __init
sbni_probe(int unit
)
223 struct net_device
*dev
;
224 static unsigned version_printed __initdata
= 0;
227 dev
= alloc_netdev(sizeof(struct net_local
), "sbni", sbni_devsetup
);
231 sprintf(dev
->name
, "sbni%d", unit
);
232 netdev_boot_setup_check(dev
);
234 err
= sbni_init(dev
);
240 err
= register_netdev(dev
);
242 release_region( dev
->base_addr
, SBNI_IO_EXTENT
);
246 if( version_printed
++ == 0 )
247 printk( KERN_INFO
"%s", version
);
251 static int __init
sbni_init(struct net_device
*dev
)
255 return sbni_isa_probe( dev
);
256 /* otherwise we have to perform search our adapter */
258 if( io
[ num
] != -1 )
259 dev
->base_addr
= io
[ num
],
260 dev
->irq
= irq
[ num
];
261 else if( scandone
|| io
[ 0 ] != -1 )
264 /* if io[ num ] contains non-zero address, then that is on ISA bus */
266 return sbni_isa_probe( dev
);
268 /* ...otherwise - scan PCI first */
269 if( !skip_pci_probe
&& !sbni_pci_probe( dev
) )
272 if( io
[ num
] == -1 ) {
273 /* Auto-scan will be stopped when first ISA card were found */
279 for( i
= 0; netcard_portlist
[ i
]; ++i
) {
280 int ioaddr
= netcard_portlist
[ i
];
281 if( request_region( ioaddr
, SBNI_IO_EXTENT
, dev
->name
)
282 && sbni_probe1( dev
, ioaddr
, 0 ))
291 sbni_pci_probe( struct net_device
*dev
)
293 struct pci_dev
*pdev
= NULL
;
295 while( (pdev
= pci_get_class( PCI_CLASS_NETWORK_OTHER
<< 8, pdev
))
298 unsigned long pci_ioaddr
;
301 if( pdev
->vendor
!= SBNI_PCI_VENDOR
302 && pdev
->device
!= SBNI_PCI_DEVICE
)
305 pci_ioaddr
= pci_resource_start( pdev
, 0 );
306 pci_irq_line
= pdev
->irq
;
308 /* Avoid already found cards from previous calls */
309 if( !request_region( pci_ioaddr
, SBNI_IO_EXTENT
, dev
->name
) ) {
310 pci_read_config_word( pdev
, PCI_SUBSYSTEM_ID
, &subsys
);
315 /* Dual adapter is present */
316 if (!request_region(pci_ioaddr
+= 4, SBNI_IO_EXTENT
,
321 if (pci_irq_line
<= 0 || pci_irq_line
>= nr_irqs
)
322 printk( KERN_WARNING
" WARNING: The PCI BIOS assigned "
323 "this PCI card to IRQ %d, which is unlikely "
325 KERN_WARNING
" You should use the PCI BIOS "
326 "setup to assign a valid IRQ line.\n",
329 /* avoiding re-enable dual adapters */
330 if( (pci_ioaddr
& 7) == 0 && pci_enable_device( pdev
) ) {
331 release_region( pci_ioaddr
, SBNI_IO_EXTENT
);
335 if( sbni_probe1( dev
, pci_ioaddr
, pci_irq_line
) ) {
336 SET_NETDEV_DEV(dev
, &pdev
->dev
);
337 /* not the best thing to do, but this is all messed up
338 for hotplug systems anyway... */
347 static struct net_device
* __init
348 sbni_probe1( struct net_device
*dev
, unsigned long ioaddr
, int irq
)
350 struct net_local
*nl
;
352 if( sbni_card_probe( ioaddr
) ) {
353 release_region( ioaddr
, SBNI_IO_EXTENT
);
357 outb( 0, ioaddr
+ CSR0
);
360 unsigned long irq_mask
;
362 irq_mask
= probe_irq_on();
363 outb( EN_INT
| TR_REQ
, ioaddr
+ CSR0
);
364 outb( PR_RES
, ioaddr
+ CSR1
);
366 irq
= probe_irq_off(irq_mask
);
367 outb( 0, ioaddr
+ CSR0
);
370 printk( KERN_ERR
"%s: can't detect device irq!\n",
372 release_region( ioaddr
, SBNI_IO_EXTENT
);
375 } else if( irq
== 2 )
379 dev
->base_addr
= ioaddr
;
381 /* Allocate dev->priv and fill in sbni-specific dev fields. */
384 printk( KERN_ERR
"%s: unable to get memory!\n", dev
->name
);
385 release_region( ioaddr
, SBNI_IO_EXTENT
);
390 memset( nl
, 0, sizeof(struct net_local
) );
391 spin_lock_init( &nl
->lock
);
393 /* store MAC address (generate if that isn't known) */
394 *(__be16
*)dev
->dev_addr
= htons( 0x00ff );
395 *(__be32
*)(dev
->dev_addr
+ 2) = htonl( 0x01000000 |
396 ( (mac
[num
] ? mac
[num
] : (u32
)((long)dev
->priv
)) & 0x00ffffff) );
398 /* store link settings (speed, receive level ) */
399 nl
->maxframe
= DEFAULT_FRAME_LEN
;
400 nl
->csr1
.rate
= baud
[ num
];
402 if( (nl
->cur_rxl_index
= rxl
[ num
]) == -1 )
404 nl
->cur_rxl_index
= DEF_RXL
,
405 nl
->delta_rxl
= DEF_RXL_DELTA
;
408 nl
->csr1
.rxl
= rxl_tab
[ nl
->cur_rxl_index
];
409 if( inb( ioaddr
+ CSR0
) & 0x01 )
410 nl
->state
|= FL_SLOW_MODE
;
412 printk( KERN_NOTICE
"%s: ioaddr %#lx, irq %d, "
413 "MAC: 00:ff:01:%02x:%02x:%02x\n",
414 dev
->name
, dev
->base_addr
, dev
->irq
,
415 ((u8
*) dev
->dev_addr
) [3],
416 ((u8
*) dev
->dev_addr
) [4],
417 ((u8
*) dev
->dev_addr
) [5] );
419 printk( KERN_NOTICE
"%s: speed %d, receive level ", dev
->name
,
420 ( (nl
->state
& FL_SLOW_MODE
) ? 500000 : 2000000)
421 / (1 << nl
->csr1
.rate
) );
423 if( nl
->delta_rxl
== 0 )
424 printk( "0x%x (fixed)\n", nl
->cur_rxl_index
);
428 #ifdef CONFIG_SBNI_MULTILINE
433 sbni_cards
[ num
++ ] = dev
;
437 /* -------------------------------------------------------------------------- */
439 #ifdef CONFIG_SBNI_MULTILINE
442 sbni_start_xmit( struct sk_buff
*skb
, struct net_device
*dev
)
444 struct net_device
*p
;
446 netif_stop_queue( dev
);
448 /* Looking for idle device in the list */
450 struct net_local
*nl
= (struct net_local
*) p
->priv
;
451 spin_lock( &nl
->lock
);
452 if( nl
->tx_buf_p
|| (nl
->state
& FL_LINE_DOWN
) ) {
454 spin_unlock( &nl
->lock
);
456 /* Idle dev is found */
457 prepare_to_send( skb
, p
);
458 spin_unlock( &nl
->lock
);
459 netif_start_queue( dev
);
467 #else /* CONFIG_SBNI_MULTILINE */
470 sbni_start_xmit( struct sk_buff
*skb
, struct net_device
*dev
)
472 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
474 netif_stop_queue( dev
);
475 spin_lock( &nl
->lock
);
477 prepare_to_send( skb
, dev
);
479 spin_unlock( &nl
->lock
);
483 #endif /* CONFIG_SBNI_MULTILINE */
485 /* -------------------------------------------------------------------------- */
487 /* interrupt handler */
490 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
491 * be looked as two independent single-channel devices. Every channel seems
492 * as Ethernet interface but interrupt handler must be common. Really, first
493 * channel ("master") driver only registers the handler. In its struct net_local
494 * it has got pointer to "slave" channel's struct net_local and handles that's
496 * dev of successfully attached ISA SBNI boards is linked to list.
497 * While next board driver is initialized, it scans this list. If one
498 * has found dev with same irq and ioaddr different by 4 then it assumes
499 * this board to be "master".
503 sbni_interrupt( int irq
, void *dev_id
)
505 struct net_device
*dev
= dev_id
;
506 struct net_local
*nl
= dev
->priv
;
509 spin_lock( &nl
->lock
);
511 spin_lock( &((struct net_local
*) nl
->second
->priv
)->lock
);
515 if( inb( dev
->base_addr
+ CSR0
) & (RC_RDY
| TR_RDY
) )
516 handle_channel( dev
),
518 if( nl
->second
&& /* second channel present */
519 (inb( nl
->second
->base_addr
+CSR0
) & (RC_RDY
| TR_RDY
)) )
520 handle_channel( nl
->second
),
525 spin_unlock( &((struct net_local
*)nl
->second
->priv
)->lock
);
526 spin_unlock( &nl
->lock
);
532 handle_channel( struct net_device
*dev
)
534 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
535 unsigned long ioaddr
= dev
->base_addr
;
540 #ifdef CONFIG_SBNI_MULTILINE
541 /* Lock the master device because we going to change its local data */
542 if( nl
->state
& FL_SLAVE
)
543 spin_lock( &((struct net_local
*) nl
->master
->priv
)->lock
);
546 outb( (inb( ioaddr
+ CSR0
) & ~EN_INT
) | TR_REQ
, ioaddr
+ CSR0
);
548 nl
->timer_ticks
= CHANGE_LEVEL_START_TICKS
;
550 csr0
= inb( ioaddr
+ CSR0
);
551 if( ( csr0
& (RC_RDY
| TR_RDY
) ) == 0 )
554 req_ans
= !(nl
->state
& FL_PREV_OK
);
557 req_ans
= recv_frame( dev
);
560 * TR_RDY always equals 1 here because we have owned the marker,
561 * and we set TR_REQ when disabled interrupts
563 csr0
= inb( ioaddr
+ CSR0
);
564 if( !(csr0
& TR_RDY
) || (csr0
& RC_RDY
) )
565 printk( KERN_ERR
"%s: internal error!\n", dev
->name
);
567 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
568 if( req_ans
|| nl
->tx_frameno
!= 0 )
571 /* send marker without any data */
572 outb( inb( ioaddr
+ CSR0
) & ~TR_REQ
, ioaddr
+ CSR0
);
575 outb( inb( ioaddr
+ CSR0
) | EN_INT
, ioaddr
+ CSR0
);
577 #ifdef CONFIG_SBNI_MULTILINE
578 if( nl
->state
& FL_SLAVE
)
579 spin_unlock( &((struct net_local
*) nl
->master
->priv
)->lock
);
585 * Routine returns 1 if it need to acknoweledge received frame.
586 * Empty frame received without errors won't be acknoweledged.
590 recv_frame( struct net_device
*dev
)
592 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
593 unsigned long ioaddr
= dev
->base_addr
;
595 u32 crc
= CRC32_INITIAL
;
597 unsigned framelen
= 0, frameno
, ack
;
598 unsigned is_first
, frame_ok
= 0;
600 if( check_fhdr( ioaddr
, &framelen
, &frameno
, &ack
, &is_first
, &crc
) ) {
601 frame_ok
= framelen
> 4
602 ? upload_data( dev
, framelen
, frameno
, is_first
, crc
)
603 : skip_tail( ioaddr
, framelen
, crc
);
605 interpret_ack( dev
, ack
);
608 outb( inb( ioaddr
+ CSR0
) ^ CT_ZER
, ioaddr
+ CSR0
);
610 nl
->state
|= FL_PREV_OK
;
612 nl
->in_stats
.all_rx_number
++;
614 nl
->state
&= ~FL_PREV_OK
,
616 nl
->in_stats
.all_rx_number
++,
617 nl
->in_stats
.bad_rx_number
++;
619 return !frame_ok
|| framelen
> 4;
624 send_frame( struct net_device
*dev
)
626 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
628 u32 crc
= CRC32_INITIAL
;
630 if( nl
->state
& FL_NEED_RESEND
) {
632 /* if frame was sended but not ACK'ed - resend it */
633 if( nl
->trans_errors
) {
635 if( nl
->framelen
!= 0 )
636 nl
->in_stats
.resend_tx_number
++;
638 /* cannot xmit with many attempts */
639 #ifdef CONFIG_SBNI_MULTILINE
640 if( (nl
->state
& FL_SLAVE
) || nl
->link
)
642 nl
->state
|= FL_LINE_DOWN
;
643 drop_xmit_queue( dev
);
647 nl
->trans_errors
= TR_ERROR_COUNT
;
649 send_frame_header( dev
, &crc
);
650 nl
->state
|= FL_NEED_RESEND
;
652 * FL_NEED_RESEND will be cleared after ACK, but if empty
653 * frame sended then in prepare_to_send next frame
658 download_data( dev
, &crc
);
659 nl
->in_stats
.all_tx_number
++;
660 nl
->state
|= FL_WAIT_ACK
;
663 outsb( dev
->base_addr
+ DAT
, (u8
*)&crc
, sizeof crc
);
666 outb( inb( dev
->base_addr
+ CSR0
) & ~TR_REQ
, dev
->base_addr
+ CSR0
);
669 /* next frame exists - we request card to send it */
670 outb( inb( dev
->base_addr
+ CSR0
) | TR_REQ
,
671 dev
->base_addr
+ CSR0
);
676 * Write the frame data into adapter's buffer memory, and calculate CRC.
677 * Do padding if necessary.
681 download_data( struct net_device
*dev
, u32
*crc_p
)
683 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
684 struct sk_buff
*skb
= nl
->tx_buf_p
;
686 unsigned len
= min_t(unsigned int, skb
->len
- nl
->outpos
, nl
->framelen
);
688 outsb( dev
->base_addr
+ DAT
, skb
->data
+ nl
->outpos
, len
);
689 *crc_p
= calc_crc32( *crc_p
, skb
->data
+ nl
->outpos
, len
);
691 /* if packet too short we should write some more bytes to pad */
692 for( len
= nl
->framelen
- len
; len
--; )
693 outb( 0, dev
->base_addr
+ DAT
),
694 *crc_p
= CRC32( 0, *crc_p
);
699 upload_data( struct net_device
*dev
, unsigned framelen
, unsigned frameno
,
700 unsigned is_first
, u32 crc
)
702 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
707 nl
->wait_frameno
= frameno
,
710 if( nl
->wait_frameno
== frameno
) {
712 if( nl
->inppos
+ framelen
<= ETHER_MAX_LEN
)
713 frame_ok
= append_frame_to_pkt( dev
, framelen
, crc
);
716 * if CRC is right but framelen incorrect then transmitter
717 * error was occurred... drop entire packet
719 else if( (frame_ok
= skip_tail( dev
->base_addr
, framelen
, crc
))
721 nl
->wait_frameno
= 0,
723 #ifdef CONFIG_SBNI_MULTILINE
724 ((struct net_local
*) nl
->master
->priv
)
726 ((struct net_local
*) nl
->master
->priv
)
727 ->stats
.rx_missed_errors
++;
729 nl
->stats
.rx_errors
++,
730 nl
->stats
.rx_missed_errors
++;
732 /* now skip all frames until is_first != 0 */
734 frame_ok
= skip_tail( dev
->base_addr
, framelen
, crc
);
736 if( is_first
&& !frame_ok
)
738 * Frame has been broken, but we had already stored
739 * is_first... Drop entire packet.
741 nl
->wait_frameno
= 0,
742 #ifdef CONFIG_SBNI_MULTILINE
743 ((struct net_local
*) nl
->master
->priv
)->stats
.rx_errors
++,
744 ((struct net_local
*) nl
->master
->priv
)->stats
.rx_crc_errors
++;
746 nl
->stats
.rx_errors
++,
747 nl
->stats
.rx_crc_errors
++;
755 send_complete( struct net_local
*nl
)
757 #ifdef CONFIG_SBNI_MULTILINE
758 ((struct net_local
*) nl
->master
->priv
)->stats
.tx_packets
++;
759 ((struct net_local
*) nl
->master
->priv
)->stats
.tx_bytes
760 += nl
->tx_buf_p
->len
;
762 nl
->stats
.tx_packets
++;
763 nl
->stats
.tx_bytes
+= nl
->tx_buf_p
->len
;
765 dev_kfree_skb_irq( nl
->tx_buf_p
);
770 nl
->state
&= ~(FL_WAIT_ACK
| FL_NEED_RESEND
);
776 interpret_ack( struct net_device
*dev
, unsigned ack
)
778 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
780 if( ack
== FRAME_SENT_OK
) {
781 nl
->state
&= ~FL_NEED_RESEND
;
783 if( nl
->state
& FL_WAIT_ACK
) {
784 nl
->outpos
+= nl
->framelen
;
786 if( --nl
->tx_frameno
)
787 nl
->framelen
= min_t(unsigned int,
789 nl
->tx_buf_p
->len
- nl
->outpos
);
792 #ifdef CONFIG_SBNI_MULTILINE
793 netif_wake_queue( nl
->master
);
795 netif_wake_queue( dev
);
800 nl
->state
&= ~FL_WAIT_ACK
;
805 * Glue received frame with previous fragments of packet.
806 * Indicate packet when last frame would be accepted.
810 append_frame_to_pkt( struct net_device
*dev
, unsigned framelen
, u32 crc
)
812 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
816 if( nl
->inppos
+ framelen
> ETHER_MAX_LEN
)
819 if( !nl
->rx_buf_p
&& !(nl
->rx_buf_p
= get_rx_buf( dev
)) )
822 p
= nl
->rx_buf_p
->data
+ nl
->inppos
;
823 insb( dev
->base_addr
+ DAT
, p
, framelen
);
824 if( calc_crc32( crc
, p
, framelen
) != CRC32_REMAINDER
)
827 nl
->inppos
+= framelen
- 4;
828 if( --nl
->wait_frameno
== 0 ) /* last frame received */
836 * Prepare to start output on adapter.
837 * Transmitter will be actually activated when marker is accepted.
841 prepare_to_send( struct sk_buff
*skb
, struct net_device
*dev
)
843 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
847 /* nl->tx_buf_p == NULL here! */
849 printk( KERN_ERR
"%s: memory leak!\n", dev
->name
);
852 nl
->state
&= ~(FL_WAIT_ACK
| FL_NEED_RESEND
);
855 if( len
< SBNI_MIN_LEN
)
859 nl
->tx_frameno
= DIV_ROUND_UP(len
, nl
->maxframe
);
860 nl
->framelen
= len
< nl
->maxframe
? len
: nl
->maxframe
;
862 outb( inb( dev
->base_addr
+ CSR0
) | TR_REQ
, dev
->base_addr
+ CSR0
);
863 #ifdef CONFIG_SBNI_MULTILINE
864 nl
->master
->trans_start
= jiffies
;
866 dev
->trans_start
= jiffies
;
872 drop_xmit_queue( struct net_device
*dev
)
874 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
877 dev_kfree_skb_any( nl
->tx_buf_p
),
879 #ifdef CONFIG_SBNI_MULTILINE
880 ((struct net_local
*) nl
->master
->priv
)
882 ((struct net_local
*) nl
->master
->priv
)
883 ->stats
.tx_carrier_errors
++;
885 nl
->stats
.tx_errors
++,
886 nl
->stats
.tx_carrier_errors
++;
892 nl
->state
&= ~(FL_WAIT_ACK
| FL_NEED_RESEND
);
893 #ifdef CONFIG_SBNI_MULTILINE
894 netif_start_queue( nl
->master
);
895 nl
->master
->trans_start
= jiffies
;
897 netif_start_queue( dev
);
898 dev
->trans_start
= jiffies
;
904 send_frame_header( struct net_device
*dev
, u32
*crc_p
)
906 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
909 u32 len_field
= nl
->framelen
+ 6; /* CRC + frameno + reserved */
912 if( nl
->state
& FL_NEED_RESEND
)
913 len_field
|= FRAME_RETRY
; /* non-first attempt... */
915 if( nl
->outpos
== 0 )
916 len_field
|= FRAME_FIRST
;
918 len_field
|= (nl
->state
& FL_PREV_OK
) ? FRAME_SENT_OK
: FRAME_SENT_BAD
;
919 outb( SBNI_SIG
, dev
->base_addr
+ DAT
);
921 value
= (u8
) len_field
;
922 outb( value
, dev
->base_addr
+ DAT
);
923 crc
= CRC32( value
, crc
);
924 value
= (u8
) (len_field
>> 8);
925 outb( value
, dev
->base_addr
+ DAT
);
926 crc
= CRC32( value
, crc
);
928 outb( nl
->tx_frameno
, dev
->base_addr
+ DAT
);
929 crc
= CRC32( nl
->tx_frameno
, crc
);
930 outb( 0, dev
->base_addr
+ DAT
);
931 crc
= CRC32( 0, crc
);
937 * if frame tail not needed (incorrect number or received twice),
938 * it won't store, but CRC will be calculated
942 skip_tail( unsigned int ioaddr
, unsigned int tail_len
, u32 crc
)
945 crc
= CRC32( inb( ioaddr
+ DAT
), crc
);
947 return crc
== CRC32_REMAINDER
;
952 * Preliminary checks if frame header is correct, calculates its CRC
953 * and split it to simple fields
957 check_fhdr( u32 ioaddr
, u32
*framelen
, u32
*frameno
, u32
*ack
,
958 u32
*is_first
, u32
*crc_p
)
963 if( inb( ioaddr
+ DAT
) != SBNI_SIG
)
966 value
= inb( ioaddr
+ DAT
);
967 *framelen
= (u32
)value
;
968 crc
= CRC32( value
, crc
);
969 value
= inb( ioaddr
+ DAT
);
970 *framelen
|= ((u32
)value
) << 8;
971 crc
= CRC32( value
, crc
);
973 *ack
= *framelen
& FRAME_ACK_MASK
;
974 *is_first
= (*framelen
& FRAME_FIRST
) != 0;
976 if( (*framelen
&= FRAME_LEN_MASK
) < 6
977 || *framelen
> SBNI_MAX_FRAME
- 3 )
980 value
= inb( ioaddr
+ DAT
);
981 *frameno
= (u32
)value
;
982 crc
= CRC32( value
, crc
);
984 crc
= CRC32( inb( ioaddr
+ DAT
), crc
); /* reserved byte */
992 static struct sk_buff
*
993 get_rx_buf( struct net_device
*dev
)
995 /* +2 is to compensate for the alignment fixup below */
996 struct sk_buff
*skb
= dev_alloc_skb( ETHER_MAX_LEN
+ 2 );
1000 skb_reserve( skb
, 2 ); /* Align IP on longword boundaries */
1006 indicate_pkt( struct net_device
*dev
)
1008 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1009 struct sk_buff
*skb
= nl
->rx_buf_p
;
1011 skb_put( skb
, nl
->inppos
);
1013 #ifdef CONFIG_SBNI_MULTILINE
1014 skb
->protocol
= eth_type_trans( skb
, nl
->master
);
1016 ++((struct net_local
*) nl
->master
->priv
)->stats
.rx_packets
;
1017 ((struct net_local
*) nl
->master
->priv
)->stats
.rx_bytes
+= nl
->inppos
;
1019 skb
->protocol
= eth_type_trans( skb
, dev
);
1021 ++nl
->stats
.rx_packets
;
1022 nl
->stats
.rx_bytes
+= nl
->inppos
;
1024 nl
->rx_buf_p
= NULL
; /* protocol driver will clear this sk_buff */
1028 /* -------------------------------------------------------------------------- */
1031 * Routine checks periodically wire activity and regenerates marker if
1032 * connect was inactive for a long time.
1036 sbni_watchdog( unsigned long arg
)
1038 struct net_device
*dev
= (struct net_device
*) arg
;
1039 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1040 struct timer_list
*w
= &nl
->watchdog
;
1041 unsigned long flags
;
1044 spin_lock_irqsave( &nl
->lock
, flags
);
1046 csr0
= inb( dev
->base_addr
+ CSR0
);
1047 if( csr0
& RC_CHK
) {
1049 if( nl
->timer_ticks
) {
1050 if( csr0
& (RC_RDY
| BU_EMP
) )
1051 /* receiving not active */
1054 nl
->in_stats
.timeout_number
++;
1056 timeout_change_level( dev
);
1058 outb( *(u_char
*)&nl
->csr1
| PR_RES
,
1059 dev
->base_addr
+ CSR1
);
1060 csr0
= inb( dev
->base_addr
+ CSR0
);
1063 nl
->state
&= ~FL_LINE_DOWN
;
1065 outb( csr0
| RC_CHK
, dev
->base_addr
+ CSR0
);
1068 w
->expires
= jiffies
+ SBNI_TIMEOUT
;
1070 w
->function
= sbni_watchdog
;
1073 spin_unlock_irqrestore( &nl
->lock
, flags
);
1077 static unsigned char rxl_tab
[] = {
1078 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1079 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1082 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1083 static unsigned char timeout_rxl_tab
[] = {
1084 0x03, 0x05, 0x08, 0x0b
1087 /* -------------------------------------------------------------------------- */
1090 card_start( struct net_device
*dev
)
1092 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1094 nl
->timer_ticks
= CHANGE_LEVEL_START_TICKS
;
1095 nl
->state
&= ~(FL_WAIT_ACK
| FL_NEED_RESEND
);
1096 nl
->state
|= FL_PREV_OK
;
1098 nl
->inppos
= nl
->outpos
= 0;
1099 nl
->wait_frameno
= 0;
1103 outb( *(u_char
*)&nl
->csr1
| PR_RES
, dev
->base_addr
+ CSR1
);
1104 outb( EN_INT
, dev
->base_addr
+ CSR0
);
1107 /* -------------------------------------------------------------------------- */
1109 /* Receive level auto-selection */
1112 change_level( struct net_device
*dev
)
1114 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1116 if( nl
->delta_rxl
== 0 ) /* do not auto-negotiate RxL */
1119 if( nl
->cur_rxl_index
== 0 )
1121 else if( nl
->cur_rxl_index
== 15 )
1123 else if( nl
->cur_rxl_rcvd
< nl
->prev_rxl_rcvd
)
1124 nl
->delta_rxl
= -nl
->delta_rxl
;
1126 nl
->csr1
.rxl
= rxl_tab
[ nl
->cur_rxl_index
+= nl
->delta_rxl
];
1127 inb( dev
->base_addr
+ CSR0
); /* needs for PCI cards */
1128 outb( *(u8
*)&nl
->csr1
, dev
->base_addr
+ CSR1
);
1130 nl
->prev_rxl_rcvd
= nl
->cur_rxl_rcvd
;
1131 nl
->cur_rxl_rcvd
= 0;
1136 timeout_change_level( struct net_device
*dev
)
1138 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1140 nl
->cur_rxl_index
= timeout_rxl_tab
[ nl
->timeout_rxl
];
1141 if( ++nl
->timeout_rxl
>= 4 )
1142 nl
->timeout_rxl
= 0;
1144 nl
->csr1
.rxl
= rxl_tab
[ nl
->cur_rxl_index
];
1145 inb( dev
->base_addr
+ CSR0
);
1146 outb( *(unsigned char *)&nl
->csr1
, dev
->base_addr
+ CSR1
);
1148 nl
->prev_rxl_rcvd
= nl
->cur_rxl_rcvd
;
1149 nl
->cur_rxl_rcvd
= 0;
1152 /* -------------------------------------------------------------------------- */
1155 * Open/initialize the board.
1159 sbni_open( struct net_device
*dev
)
1161 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1162 struct timer_list
*w
= &nl
->watchdog
;
1165 * For double ISA adapters within "common irq" mode, we have to
1166 * determine whether primary or secondary channel is initialized,
1167 * and set the irq handler only in first case.
1169 if( dev
->base_addr
< 0x400 ) { /* ISA only */
1170 struct net_device
**p
= sbni_cards
;
1171 for( ; *p
&& p
< sbni_cards
+ SBNI_MAX_NUM_CARDS
; ++p
)
1172 if( (*p
)->irq
== dev
->irq
1173 && ((*p
)->base_addr
== dev
->base_addr
+ 4
1174 || (*p
)->base_addr
== dev
->base_addr
- 4)
1175 && (*p
)->flags
& IFF_UP
) {
1177 ((struct net_local
*) ((*p
)->priv
))
1179 printk( KERN_NOTICE
"%s: using shared irq "
1180 "with %s\n", dev
->name
, (*p
)->name
);
1181 nl
->state
|= FL_SECONDARY
;
1182 goto handler_attached
;
1186 if( request_irq(dev
->irq
, sbni_interrupt
, IRQF_SHARED
, dev
->name
, dev
) ) {
1187 printk( KERN_ERR
"%s: unable to get IRQ %d.\n",
1188 dev
->name
, dev
->irq
);
1194 spin_lock( &nl
->lock
);
1195 memset( &nl
->stats
, 0, sizeof(struct net_device_stats
) );
1196 memset( &nl
->in_stats
, 0, sizeof(struct sbni_in_stats
) );
1200 netif_start_queue( dev
);
1202 /* set timer watchdog */
1204 w
->expires
= jiffies
+ SBNI_TIMEOUT
;
1205 w
->data
= (unsigned long) dev
;
1206 w
->function
= sbni_watchdog
;
1209 spin_unlock( &nl
->lock
);
1215 sbni_close( struct net_device
*dev
)
1217 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1219 if( nl
->second
&& nl
->second
->flags
& IFF_UP
) {
1220 printk( KERN_NOTICE
"Secondary channel (%s) is active!\n",
1225 #ifdef CONFIG_SBNI_MULTILINE
1226 if( nl
->state
& FL_SLAVE
)
1229 while( nl
->link
) /* it's master device! */
1230 emancipate( nl
->link
);
1233 spin_lock( &nl
->lock
);
1236 drop_xmit_queue( dev
);
1237 netif_stop_queue( dev
);
1239 del_timer( &nl
->watchdog
);
1241 outb( 0, dev
->base_addr
+ CSR0
);
1243 if( !(nl
->state
& FL_SECONDARY
) )
1244 free_irq( dev
->irq
, dev
);
1245 nl
->state
&= FL_SECONDARY
;
1247 spin_unlock( &nl
->lock
);
1253 Valid combinations in CSR0 (for probing):
1255 VALID_DECODER 0000,0011,1011,1010
1260 TR_RDY TR_REQ ; 3 ; +
1262 BU_EMP TR_REQ ; 5 ; +
1263 BU_EMP TR_RDY ; 6 ; -
1264 BU_EMP TR_RDY TR_REQ ; 7 ; +
1266 RC_RDY TR_REQ ; 9 ; +
1267 RC_RDY TR_RDY ; 10 ; -
1268 RC_RDY TR_RDY TR_REQ ; 11 ; -
1269 RC_RDY BU_EMP ; 12 ; -
1270 RC_RDY BU_EMP TR_REQ ; 13 ; -
1271 RC_RDY BU_EMP TR_RDY ; 14 ; -
1272 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1275 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1279 sbni_card_probe( unsigned long ioaddr
)
1283 csr0
= inb( ioaddr
+ CSR0
);
1284 if( csr0
!= 0xff && csr0
!= 0x00 ) {
1289 if( VALID_DECODER
& (1 << (csr0
>> 4)) )
1296 /* -------------------------------------------------------------------------- */
1299 sbni_ioctl( struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1301 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1302 struct sbni_flags flags
;
1305 #ifdef CONFIG_SBNI_MULTILINE
1306 struct net_device
*slave_dev
;
1307 char slave_name
[ 8 ];
1311 case SIOCDEVGETINSTATS
:
1312 if (copy_to_user( ifr
->ifr_data
, &nl
->in_stats
,
1313 sizeof(struct sbni_in_stats
) ))
1317 case SIOCDEVRESINSTATS
:
1318 if (!capable(CAP_NET_ADMIN
))
1320 memset( &nl
->in_stats
, 0, sizeof(struct sbni_in_stats
) );
1323 case SIOCDEVGHWSTATE
:
1324 flags
.mac_addr
= *(u32
*)(dev
->dev_addr
+ 3);
1325 flags
.rate
= nl
->csr1
.rate
;
1326 flags
.slow_mode
= (nl
->state
& FL_SLOW_MODE
) != 0;
1327 flags
.rxl
= nl
->cur_rxl_index
;
1328 flags
.fixed_rxl
= nl
->delta_rxl
== 0;
1330 if (copy_to_user( ifr
->ifr_data
, &flags
, sizeof flags
))
1334 case SIOCDEVSHWSTATE
:
1335 if (!capable(CAP_NET_ADMIN
))
1338 spin_lock( &nl
->lock
);
1339 flags
= *(struct sbni_flags
*) &ifr
->ifr_ifru
;
1340 if( flags
.fixed_rxl
)
1342 nl
->cur_rxl_index
= flags
.rxl
;
1344 nl
->delta_rxl
= DEF_RXL_DELTA
,
1345 nl
->cur_rxl_index
= DEF_RXL
;
1347 nl
->csr1
.rxl
= rxl_tab
[ nl
->cur_rxl_index
];
1348 nl
->csr1
.rate
= flags
.rate
;
1349 outb( *(u8
*)&nl
->csr1
| PR_RES
, dev
->base_addr
+ CSR1
);
1350 spin_unlock( &nl
->lock
);
1353 #ifdef CONFIG_SBNI_MULTILINE
1355 case SIOCDEVENSLAVE
:
1356 if (!capable(CAP_NET_ADMIN
))
1359 if (copy_from_user( slave_name
, ifr
->ifr_data
, sizeof slave_name
))
1361 slave_dev
= dev_get_by_name(&init_net
, slave_name
);
1362 if( !slave_dev
|| !(slave_dev
->flags
& IFF_UP
) ) {
1363 printk( KERN_ERR
"%s: trying to enslave non-active "
1364 "device %s\n", dev
->name
, slave_name
);
1368 return enslave( dev
, slave_dev
);
1370 case SIOCDEVEMANSIPATE
:
1371 if (!capable(CAP_NET_ADMIN
))
1374 return emancipate( dev
);
1376 #endif /* CONFIG_SBNI_MULTILINE */
1386 #ifdef CONFIG_SBNI_MULTILINE
1389 enslave( struct net_device
*dev
, struct net_device
*slave_dev
)
1391 struct net_local
*nl
= (struct net_local
*) dev
->priv
;
1392 struct net_local
*snl
= (struct net_local
*) slave_dev
->priv
;
1394 if( nl
->state
& FL_SLAVE
) /* This isn't master or free device */
1397 if( snl
->state
& FL_SLAVE
) /* That was already enslaved */
1400 spin_lock( &nl
->lock
);
1401 spin_lock( &snl
->lock
);
1403 /* append to list */
1404 snl
->link
= nl
->link
;
1405 nl
->link
= slave_dev
;
1407 snl
->state
|= FL_SLAVE
;
1409 /* Summary statistics of MultiLine operation will be stored
1410 in master's counters */
1411 memset( &snl
->stats
, 0, sizeof(struct net_device_stats
) );
1412 netif_stop_queue( slave_dev
);
1413 netif_wake_queue( dev
); /* Now we are able to transmit */
1415 spin_unlock( &snl
->lock
);
1416 spin_unlock( &nl
->lock
);
1417 printk( KERN_NOTICE
"%s: slave device (%s) attached.\n",
1418 dev
->name
, slave_dev
->name
);
1424 emancipate( struct net_device
*dev
)
1426 struct net_local
*snl
= (struct net_local
*) dev
->priv
;
1427 struct net_device
*p
= snl
->master
;
1428 struct net_local
*nl
= (struct net_local
*) p
->priv
;
1430 if( !(snl
->state
& FL_SLAVE
) )
1433 spin_lock( &nl
->lock
);
1434 spin_lock( &snl
->lock
);
1435 drop_xmit_queue( dev
);
1437 /* exclude from list */
1438 for(;;) { /* must be in list */
1439 struct net_local
*t
= (struct net_local
*) p
->priv
;
1440 if( t
->link
== dev
) {
1441 t
->link
= snl
->link
;
1449 snl
->state
&= ~FL_SLAVE
;
1451 netif_start_queue( dev
);
1453 spin_unlock( &snl
->lock
);
1454 spin_unlock( &nl
->lock
);
1463 static struct net_device_stats
*
1464 sbni_get_stats( struct net_device
*dev
)
1466 return &((struct net_local
*) dev
->priv
)->stats
;
1471 set_multicast_list( struct net_device
*dev
)
1473 return; /* sbni always operate in promiscuos mode */
1478 module_param_array(io
, int, NULL
, 0);
1479 module_param_array(irq
, int, NULL
, 0);
1480 module_param_array(baud
, int, NULL
, 0);
1481 module_param_array(rxl
, int, NULL
, 0);
1482 module_param_array(mac
, int, NULL
, 0);
1483 module_param(skip_pci_probe
, bool, 0);
1485 MODULE_LICENSE("GPL");
1488 int __init
init_module( void )
1490 struct net_device
*dev
;
1493 while( num
< SBNI_MAX_NUM_CARDS
) {
1494 dev
= alloc_netdev(sizeof(struct net_local
),
1495 "sbni%d", sbni_devsetup
);
1499 sprintf( dev
->name
, "sbni%d", num
);
1501 err
= sbni_init(dev
);
1507 if( register_netdev( dev
) ) {
1508 release_region( dev
->base_addr
, SBNI_IO_EXTENT
);
1514 return *sbni_cards
? 0 : -ENODEV
;
1518 cleanup_module( void )
1520 struct net_device
*dev
;
1523 for( num
= 0; num
< SBNI_MAX_NUM_CARDS
; ++num
)
1524 if( (dev
= sbni_cards
[ num
]) != NULL
) {
1525 unregister_netdev( dev
);
1526 release_region( dev
->base_addr
, SBNI_IO_EXTENT
);
1534 sbni_setup( char *p
)
1541 for( n
= 0, parm
= 0; *p
&& n
< 8; ) {
1542 (*dest
[ parm
])[ n
] = simple_strtol( p
, &p
, 0 );
1543 if( !*p
|| *p
== ')' )
1547 else if( *p
++ != ',' )
1554 printk( KERN_ERR
"Error in sbni kernel parameter!\n" );
1558 __setup( "sbni=", sbni_setup
);
1562 /* -------------------------------------------------------------------------- */
1567 calc_crc32( u32 crc
, u8
*p
, u32 len
)
1572 __asm__
__volatile__ (
1573 "xorl %%ebx, %%ebx\n"
1576 "movl $crc32tab, %%edi\n"
1583 "movl (%%esi), %%edx\n"
1587 "xorl (%%edi,%%ebx,4), %%eax\n"
1593 "xorl (%%edi,%%ebx,4), %%eax\n"
1599 "xorl (%%edi,%%ebx,4), %%eax\n"
1605 "xorl (%%edi,%%ebx,4), %%eax\n"
1617 "xorb (%%esi), %%bl\n"
1618 "xorl (%%edi,%%ebx,4), %%eax\n"
1625 "xorb 1(%%esi), %%bl\n"
1626 "xorl (%%edi,%%ebx,4), %%eax\n"
1633 "xorb 2(%%esi), %%bl\n"
1634 "xorl (%%edi,%%ebx,4), %%eax\n"
1637 : "0" (_crc
), "g" (p
), "g" (len
)
1638 : "bx", "cx", "dx", "si", "di"
1647 calc_crc32( u32 crc
, u8
*p
, u32 len
)
1650 crc
= CRC32( *p
++, crc
);
1655 #endif /* ASM_CRC */
1658 static u32 crc32tab
[] __attribute__ ((aligned(8))) = {
1659 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1660 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1661 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1662 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1663 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1664 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1665 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1666 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1667 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1668 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1669 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1670 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1671 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1672 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1673 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1674 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1675 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1676 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1677 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1678 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1679 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1680 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1681 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1682 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1683 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1684 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1685 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1686 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1687 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1688 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1689 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1690 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1691 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1692 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1693 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1694 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1695 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1696 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1697 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1698 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1699 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1700 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1701 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1702 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1703 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1704 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1705 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1706 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1707 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1708 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1709 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1710 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1711 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1712 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1713 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1714 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1715 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1716 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1717 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1718 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1719 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1720 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1721 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1722 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000