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/config.h>
41 #include <linux/module.h>
42 #include <linux/kernel.h>
43 #include <linux/ptrace.h>
44 #include <linux/fcntl.h>
45 #include <linux/ioport.h>
46 #include <linux/interrupt.h>
47 #include <linux/slab.h>
48 #include <linux/string.h>
49 #include <linux/errno.h>
50 #include <linux/netdevice.h>
51 #include <linux/etherdevice.h>
52 #include <linux/pci.h>
53 #include <linux/skbuff.h>
54 #include <linux/timer.h>
55 #include <linux/init.h>
56 #include <linux/delay.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 *, struct pt_regs * );
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 *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;
220 SET_MODULE_OWNER( dev );
223 int __init sbni_probe(int unit)
225 struct net_device *dev;
226 static unsigned version_printed __initdata = 0;
229 dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
233 sprintf(dev->name, "sbni%d", unit);
234 netdev_boot_setup_check(dev);
236 err = sbni_init(dev);
242 err = register_netdev(dev);
244 release_region( dev->base_addr, SBNI_IO_EXTENT );
248 if( version_printed++ == 0 )
249 printk( KERN_INFO "%s", version );
253 static int __init sbni_init(struct net_device *dev)
257 return sbni_isa_probe( dev );
258 /* otherwise we have to perform search our adapter */
260 if( io[ num ] != -1 )
261 dev->base_addr = io[ num ],
262 dev->irq = irq[ num ];
263 else if( scandone || io[ 0 ] != -1 )
266 /* if io[ num ] contains non-zero address, then that is on ISA bus */
268 return sbni_isa_probe( dev );
270 /* ...otherwise - scan PCI first */
271 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
274 if( io[ num ] == -1 ) {
275 /* Auto-scan will be stopped when first ISA card were found */
281 for( i = 0; netcard_portlist[ i ]; ++i ) {
282 int ioaddr = netcard_portlist[ i ];
283 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
284 && sbni_probe1( dev, ioaddr, 0 ))
293 sbni_pci_probe( struct net_device *dev )
295 struct pci_dev *pdev = NULL;
297 while( (pdev = pci_find_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
300 unsigned long pci_ioaddr;
303 if( pdev->vendor != SBNI_PCI_VENDOR
304 && pdev->device != SBNI_PCI_DEVICE )
307 pci_ioaddr = pci_resource_start( pdev, 0 );
308 pci_irq_line = pdev->irq;
310 /* Avoid already found cards from previous calls */
311 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
312 pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
317 /* Dual adapter is present */
318 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
323 if( pci_irq_line <= 0 || pci_irq_line >= NR_IRQS )
324 printk( KERN_WARNING " WARNING: The PCI BIOS assigned "
325 "this PCI card to IRQ %d, which is unlikely "
327 KERN_WARNING " You should use the PCI BIOS "
328 "setup to assign a valid IRQ line.\n",
331 /* avoiding re-enable dual adapters */
332 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
333 release_region( pci_ioaddr, SBNI_IO_EXTENT );
336 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
337 SET_NETDEV_DEV(dev, &pdev->dev);
345 static struct net_device * __init
346 sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
348 struct net_local *nl;
350 if( sbni_card_probe( ioaddr ) ) {
351 release_region( ioaddr, SBNI_IO_EXTENT );
355 outb( 0, ioaddr + CSR0 );
358 unsigned long irq_mask;
360 irq_mask = probe_irq_on();
361 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
362 outb( PR_RES, ioaddr + CSR1 );
364 irq = probe_irq_off(irq_mask);
365 outb( 0, ioaddr + CSR0 );
368 printk( KERN_ERR "%s: can't detect device irq!\n",
370 release_region( ioaddr, SBNI_IO_EXTENT );
373 } else if( irq == 2 )
377 dev->base_addr = ioaddr;
379 /* Allocate dev->priv and fill in sbni-specific dev fields. */
382 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
383 release_region( ioaddr, SBNI_IO_EXTENT );
388 memset( nl, 0, sizeof(struct net_local) );
389 spin_lock_init( &nl->lock );
391 /* store MAC address (generate if that isn't known) */
392 *(u16 *)dev->dev_addr = htons( 0x00ff );
393 *(u32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
394 ( (mac[num] ? mac[num] : (u32)((long)dev->priv)) & 0x00ffffff) );
396 /* store link settings (speed, receive level ) */
397 nl->maxframe = DEFAULT_FRAME_LEN;
398 nl->csr1.rate = baud[ num ];
400 if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
402 nl->cur_rxl_index = DEF_RXL,
403 nl->delta_rxl = DEF_RXL_DELTA;
406 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
407 if( inb( ioaddr + CSR0 ) & 0x01 )
408 nl->state |= FL_SLOW_MODE;
410 printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
411 "MAC: 00:ff:01:%02x:%02x:%02x\n",
412 dev->name, dev->base_addr, dev->irq,
413 ((u8 *) dev->dev_addr) [3],
414 ((u8 *) dev->dev_addr) [4],
415 ((u8 *) dev->dev_addr) [5] );
417 printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
418 ( (nl->state & FL_SLOW_MODE) ? 500000 : 2000000)
419 / (1 << nl->csr1.rate) );
421 if( nl->delta_rxl == 0 )
422 printk( "0x%x (fixed)\n", nl->cur_rxl_index );
426 #ifdef CONFIG_SBNI_MULTILINE
431 sbni_cards[ num++ ] = dev;
435 /* -------------------------------------------------------------------------- */
437 #ifdef CONFIG_SBNI_MULTILINE
440 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
442 struct net_device *p;
444 netif_stop_queue( dev );
446 /* Looking for idle device in the list */
448 struct net_local *nl = (struct net_local *) p->priv;
449 spin_lock( &nl->lock );
450 if( nl->tx_buf_p || (nl->state & FL_LINE_DOWN) ) {
452 spin_unlock( &nl->lock );
454 /* Idle dev is found */
455 prepare_to_send( skb, p );
456 spin_unlock( &nl->lock );
457 netif_start_queue( dev );
465 #else /* CONFIG_SBNI_MULTILINE */
468 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
470 struct net_local *nl = (struct net_local *) dev->priv;
472 netif_stop_queue( dev );
473 spin_lock( &nl->lock );
475 prepare_to_send( skb, dev );
477 spin_unlock( &nl->lock );
481 #endif /* CONFIG_SBNI_MULTILINE */
483 /* -------------------------------------------------------------------------- */
485 /* interrupt handler */
488 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
489 * be looked as two independent single-channel devices. Every channel seems
490 * as Ethernet interface but interrupt handler must be common. Really, first
491 * channel ("master") driver only registers the handler. In its struct net_local
492 * it has got pointer to "slave" channel's struct net_local and handles that's
494 * dev of successfully attached ISA SBNI boards is linked to list.
495 * While next board driver is initialized, it scans this list. If one
496 * has found dev with same irq and ioaddr different by 4 then it assumes
497 * this board to be "master".
501 sbni_interrupt( int irq, void *dev_id, struct pt_regs *regs )
503 struct net_device *dev = (struct net_device *) dev_id;
504 struct net_local *nl = (struct net_local *) dev->priv;
507 spin_lock( &nl->lock );
509 spin_lock( &((struct net_local *) nl->second->priv)->lock );
513 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
514 handle_channel( dev ),
516 if( nl->second && /* second channel present */
517 (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
518 handle_channel( nl->second ),
523 spin_unlock( &((struct net_local *)nl->second->priv)->lock );
524 spin_unlock( &nl->lock );
530 handle_channel( struct net_device *dev )
532 struct net_local *nl = (struct net_local *) dev->priv;
533 unsigned long ioaddr = dev->base_addr;
538 #ifdef CONFIG_SBNI_MULTILINE
539 /* Lock the master device because we going to change its local data */
540 if( nl->state & FL_SLAVE )
541 spin_lock( &((struct net_local *) nl->master->priv)->lock );
544 outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
546 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
548 csr0 = inb( ioaddr + CSR0 );
549 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
552 req_ans = !(nl->state & FL_PREV_OK);
555 req_ans = recv_frame( dev );
558 * TR_RDY always equals 1 here because we have owned the marker,
559 * and we set TR_REQ when disabled interrupts
561 csr0 = inb( ioaddr + CSR0 );
562 if( !(csr0 & TR_RDY) || (csr0 & RC_RDY) )
563 printk( KERN_ERR "%s: internal error!\n", dev->name );
565 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
566 if( req_ans || nl->tx_frameno != 0 )
569 /* send marker without any data */
570 outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
573 outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
575 #ifdef CONFIG_SBNI_MULTILINE
576 if( nl->state & FL_SLAVE )
577 spin_unlock( &((struct net_local *) nl->master->priv)->lock );
583 * Routine returns 1 if it need to acknoweledge received frame.
584 * Empty frame received without errors won't be acknoweledged.
588 recv_frame( struct net_device *dev )
590 struct net_local *nl = (struct net_local *) dev->priv;
591 unsigned long ioaddr = dev->base_addr;
593 u32 crc = CRC32_INITIAL;
595 unsigned framelen, frameno, ack;
596 unsigned is_first, frame_ok;
598 if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
599 frame_ok = framelen > 4
600 ? upload_data( dev, framelen, frameno, is_first, crc )
601 : skip_tail( ioaddr, framelen, crc );
603 interpret_ack( dev, ack );
607 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
609 nl->state |= FL_PREV_OK;
611 nl->in_stats.all_rx_number++;
613 nl->state &= ~FL_PREV_OK,
615 nl->in_stats.all_rx_number++,
616 nl->in_stats.bad_rx_number++;
618 return !frame_ok || framelen > 4;
623 send_frame( struct net_device *dev )
625 struct net_local *nl = (struct net_local *) dev->priv;
627 u32 crc = CRC32_INITIAL;
629 if( nl->state & FL_NEED_RESEND ) {
631 /* if frame was sended but not ACK'ed - resend it */
632 if( nl->trans_errors ) {
634 if( nl->framelen != 0 )
635 nl->in_stats.resend_tx_number++;
637 /* cannot xmit with many attempts */
638 #ifdef CONFIG_SBNI_MULTILINE
639 if( (nl->state & FL_SLAVE) || nl->link )
641 nl->state |= FL_LINE_DOWN;
642 drop_xmit_queue( dev );
646 nl->trans_errors = TR_ERROR_COUNT;
648 send_frame_header( dev, &crc );
649 nl->state |= FL_NEED_RESEND;
651 * FL_NEED_RESEND will be cleared after ACK, but if empty
652 * frame sended then in prepare_to_send next frame
657 download_data( dev, &crc );
658 nl->in_stats.all_tx_number++;
659 nl->state |= FL_WAIT_ACK;
662 outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
665 outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
668 /* next frame exists - we request card to send it */
669 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
670 dev->base_addr + CSR0 );
675 * Write the frame data into adapter's buffer memory, and calculate CRC.
676 * Do padding if necessary.
680 download_data( struct net_device *dev, u32 *crc_p )
682 struct net_local *nl = (struct net_local *) dev->priv;
683 struct sk_buff *skb = nl->tx_buf_p;
685 unsigned len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
687 outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
688 *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
690 /* if packet too short we should write some more bytes to pad */
691 for( len = nl->framelen - len; len--; )
692 outb( 0, dev->base_addr + DAT ),
693 *crc_p = CRC32( 0, *crc_p );
698 upload_data( struct net_device *dev, unsigned framelen, unsigned frameno,
699 unsigned is_first, u32 crc )
701 struct net_local *nl = (struct net_local *) dev->priv;
706 nl->wait_frameno = frameno,
709 if( nl->wait_frameno == frameno ) {
711 if( nl->inppos + framelen <= ETHER_MAX_LEN )
712 frame_ok = append_frame_to_pkt( dev, framelen, crc );
715 * if CRC is right but framelen incorrect then transmitter
716 * error was occurred... drop entire packet
718 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
720 nl->wait_frameno = 0,
722 #ifdef CONFIG_SBNI_MULTILINE
723 ((struct net_local *) nl->master->priv)
725 ((struct net_local *) nl->master->priv)
726 ->stats.rx_missed_errors++;
728 nl->stats.rx_errors++,
729 nl->stats.rx_missed_errors++;
731 /* now skip all frames until is_first != 0 */
733 frame_ok = skip_tail( dev->base_addr, framelen, crc );
735 if( is_first && !frame_ok )
737 * Frame has been broken, but we had already stored
738 * is_first... Drop entire packet.
740 nl->wait_frameno = 0,
741 #ifdef CONFIG_SBNI_MULTILINE
742 ((struct net_local *) nl->master->priv)->stats.rx_errors++,
743 ((struct net_local *) nl->master->priv)->stats.rx_crc_errors++;
745 nl->stats.rx_errors++,
746 nl->stats.rx_crc_errors++;
754 send_complete( struct net_local *nl )
756 #ifdef CONFIG_SBNI_MULTILINE
757 ((struct net_local *) nl->master->priv)->stats.tx_packets++;
758 ((struct net_local *) nl->master->priv)->stats.tx_bytes
759 += nl->tx_buf_p->len;
761 nl->stats.tx_packets++;
762 nl->stats.tx_bytes += nl->tx_buf_p->len;
764 dev_kfree_skb_irq( nl->tx_buf_p );
769 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
775 interpret_ack( struct net_device *dev, unsigned ack )
777 struct net_local *nl = (struct net_local *) dev->priv;
779 if( ack == FRAME_SENT_OK ) {
780 nl->state &= ~FL_NEED_RESEND;
782 if( nl->state & FL_WAIT_ACK ) {
783 nl->outpos += nl->framelen;
785 if( --nl->tx_frameno )
786 nl->framelen = min_t(unsigned int,
788 nl->tx_buf_p->len - nl->outpos);
791 #ifdef CONFIG_SBNI_MULTILINE
792 netif_wake_queue( nl->master );
794 netif_wake_queue( dev );
799 nl->state &= ~FL_WAIT_ACK;
804 * Glue received frame with previous fragments of packet.
805 * Indicate packet when last frame would be accepted.
809 append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
811 struct net_local *nl = (struct net_local *) dev->priv;
815 if( nl->inppos + framelen > ETHER_MAX_LEN )
818 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
821 p = nl->rx_buf_p->data + nl->inppos;
822 insb( dev->base_addr + DAT, p, framelen );
823 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
826 nl->inppos += framelen - 4;
827 if( --nl->wait_frameno == 0 ) /* last frame received */
835 * Prepare to start output on adapter.
836 * Transmitter will be actually activated when marker is accepted.
840 prepare_to_send( struct sk_buff *skb, struct net_device *dev )
842 struct net_local *nl = (struct net_local *) dev->priv;
846 /* nl->tx_buf_p == NULL here! */
848 printk( KERN_ERR "%s: memory leak!\n", dev->name );
851 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
854 if( len < SBNI_MIN_LEN )
858 nl->tx_frameno = (len + nl->maxframe - 1) / nl->maxframe;
859 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
861 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
862 #ifdef CONFIG_SBNI_MULTILINE
863 nl->master->trans_start = jiffies;
865 dev->trans_start = jiffies;
871 drop_xmit_queue( struct net_device *dev )
873 struct net_local *nl = (struct net_local *) dev->priv;
876 dev_kfree_skb_any( nl->tx_buf_p ),
878 #ifdef CONFIG_SBNI_MULTILINE
879 ((struct net_local *) nl->master->priv)
881 ((struct net_local *) nl->master->priv)
882 ->stats.tx_carrier_errors++;
884 nl->stats.tx_errors++,
885 nl->stats.tx_carrier_errors++;
891 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
892 #ifdef CONFIG_SBNI_MULTILINE
893 netif_start_queue( nl->master );
894 nl->master->trans_start = jiffies;
896 netif_start_queue( dev );
897 dev->trans_start = jiffies;
903 send_frame_header( struct net_device *dev, u32 *crc_p )
905 struct net_local *nl = (struct net_local *) dev->priv;
908 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
911 if( nl->state & FL_NEED_RESEND )
912 len_field |= FRAME_RETRY; /* non-first attempt... */
914 if( nl->outpos == 0 )
915 len_field |= FRAME_FIRST;
917 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
918 outb( SBNI_SIG, dev->base_addr + DAT );
920 value = (u8) len_field;
921 outb( value, dev->base_addr + DAT );
922 crc = CRC32( value, crc );
923 value = (u8) (len_field >> 8);
924 outb( value, dev->base_addr + DAT );
925 crc = CRC32( value, crc );
927 outb( nl->tx_frameno, dev->base_addr + DAT );
928 crc = CRC32( nl->tx_frameno, crc );
929 outb( 0, dev->base_addr + DAT );
930 crc = CRC32( 0, crc );
936 * if frame tail not needed (incorrect number or received twice),
937 * it won't store, but CRC will be calculated
941 skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
944 crc = CRC32( inb( ioaddr + DAT ), crc );
946 return crc == CRC32_REMAINDER;
951 * Preliminary checks if frame header is correct, calculates its CRC
952 * and split it to simple fields
956 check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
957 u32 *is_first, u32 *crc_p )
962 if( inb( ioaddr + DAT ) != SBNI_SIG )
965 value = inb( ioaddr + DAT );
966 *framelen = (u32)value;
967 crc = CRC32( value, crc );
968 value = inb( ioaddr + DAT );
969 *framelen |= ((u32)value) << 8;
970 crc = CRC32( value, crc );
972 *ack = *framelen & FRAME_ACK_MASK;
973 *is_first = (*framelen & FRAME_FIRST) != 0;
975 if( (*framelen &= FRAME_LEN_MASK) < 6
976 || *framelen > SBNI_MAX_FRAME - 3 )
979 value = inb( ioaddr + DAT );
980 *frameno = (u32)value;
981 crc = CRC32( value, crc );
983 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
991 static struct sk_buff *
992 get_rx_buf( struct net_device *dev )
994 /* +2 is to compensate for the alignment fixup below */
995 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
999 #ifdef CONFIG_SBNI_MULTILINE
1000 skb->dev = ((struct net_local *) dev->priv)->master;
1004 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1010 indicate_pkt( struct net_device *dev )
1012 struct net_local *nl = (struct net_local *) dev->priv;
1013 struct sk_buff *skb = nl->rx_buf_p;
1015 skb_put( skb, nl->inppos );
1017 #ifdef CONFIG_SBNI_MULTILINE
1018 skb->protocol = eth_type_trans( skb, nl->master );
1020 dev->last_rx = jiffies;
1021 ++((struct net_local *) nl->master->priv)->stats.rx_packets;
1022 ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
1024 skb->protocol = eth_type_trans( skb, dev );
1026 dev->last_rx = jiffies;
1027 ++nl->stats.rx_packets;
1028 nl->stats.rx_bytes += nl->inppos;
1030 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1034 /* -------------------------------------------------------------------------- */
1037 * Routine checks periodically wire activity and regenerates marker if
1038 * connect was inactive for a long time.
1042 sbni_watchdog( unsigned long arg )
1044 struct net_device *dev = (struct net_device *) arg;
1045 struct net_local *nl = (struct net_local *) dev->priv;
1046 struct timer_list *w = &nl->watchdog;
1047 unsigned long flags;
1050 spin_lock_irqsave( &nl->lock, flags );
1052 csr0 = inb( dev->base_addr + CSR0 );
1053 if( csr0 & RC_CHK ) {
1055 if( nl->timer_ticks ) {
1056 if( csr0 & (RC_RDY | BU_EMP) )
1057 /* receiving not active */
1060 nl->in_stats.timeout_number++;
1062 timeout_change_level( dev );
1064 outb( *(u_char *)&nl->csr1 | PR_RES,
1065 dev->base_addr + CSR1 );
1066 csr0 = inb( dev->base_addr + CSR0 );
1069 nl->state &= ~FL_LINE_DOWN;
1071 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1074 w->expires = jiffies + SBNI_TIMEOUT;
1076 w->function = sbni_watchdog;
1079 spin_unlock_irqrestore( &nl->lock, flags );
1083 static unsigned char rxl_tab[] = {
1084 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1085 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1088 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1089 static unsigned char timeout_rxl_tab[] = {
1090 0x03, 0x05, 0x08, 0x0b
1093 /* -------------------------------------------------------------------------- */
1096 card_start( struct net_device *dev )
1098 struct net_local *nl = (struct net_local *) dev->priv;
1100 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1101 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1102 nl->state |= FL_PREV_OK;
1104 nl->inppos = nl->outpos = 0;
1105 nl->wait_frameno = 0;
1109 outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1110 outb( EN_INT, dev->base_addr + CSR0 );
1113 /* -------------------------------------------------------------------------- */
1115 /* Receive level auto-selection */
1118 change_level( struct net_device *dev )
1120 struct net_local *nl = (struct net_local *) dev->priv;
1122 if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
1125 if( nl->cur_rxl_index == 0 )
1127 else if( nl->cur_rxl_index == 15 )
1129 else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1130 nl->delta_rxl = -nl->delta_rxl;
1132 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1133 inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
1134 outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1136 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1137 nl->cur_rxl_rcvd = 0;
1142 timeout_change_level( struct net_device *dev )
1144 struct net_local *nl = (struct net_local *) dev->priv;
1146 nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1147 if( ++nl->timeout_rxl >= 4 )
1148 nl->timeout_rxl = 0;
1150 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1151 inb( dev->base_addr + CSR0 );
1152 outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1154 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1155 nl->cur_rxl_rcvd = 0;
1158 /* -------------------------------------------------------------------------- */
1161 * Open/initialize the board.
1165 sbni_open( struct net_device *dev )
1167 struct net_local *nl = (struct net_local *) dev->priv;
1168 struct timer_list *w = &nl->watchdog;
1171 * For double ISA adapters within "common irq" mode, we have to
1172 * determine whether primary or secondary channel is initialized,
1173 * and set the irq handler only in first case.
1175 if( dev->base_addr < 0x400 ) { /* ISA only */
1176 struct net_device **p = sbni_cards;
1177 for( ; *p && p < sbni_cards + SBNI_MAX_NUM_CARDS; ++p )
1178 if( (*p)->irq == dev->irq
1179 && ((*p)->base_addr == dev->base_addr + 4
1180 || (*p)->base_addr == dev->base_addr - 4)
1181 && (*p)->flags & IFF_UP ) {
1183 ((struct net_local *) ((*p)->priv))
1185 printk( KERN_NOTICE "%s: using shared irq "
1186 "with %s\n", dev->name, (*p)->name );
1187 nl->state |= FL_SECONDARY;
1188 goto handler_attached;
1192 if( request_irq(dev->irq, sbni_interrupt, SA_SHIRQ, dev->name, dev) ) {
1193 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1194 dev->name, dev->irq );
1200 spin_lock( &nl->lock );
1201 memset( &nl->stats, 0, sizeof(struct net_device_stats) );
1202 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1206 netif_start_queue( dev );
1208 /* set timer watchdog */
1210 w->expires = jiffies + SBNI_TIMEOUT;
1211 w->data = (unsigned long) dev;
1212 w->function = sbni_watchdog;
1215 spin_unlock( &nl->lock );
1221 sbni_close( struct net_device *dev )
1223 struct net_local *nl = (struct net_local *) dev->priv;
1225 if( nl->second && nl->second->flags & IFF_UP ) {
1226 printk( KERN_NOTICE "Secondary channel (%s) is active!\n",
1231 #ifdef CONFIG_SBNI_MULTILINE
1232 if( nl->state & FL_SLAVE )
1235 while( nl->link ) /* it's master device! */
1236 emancipate( nl->link );
1239 spin_lock( &nl->lock );
1242 drop_xmit_queue( dev );
1243 netif_stop_queue( dev );
1245 del_timer( &nl->watchdog );
1247 outb( 0, dev->base_addr + CSR0 );
1249 if( !(nl->state & FL_SECONDARY) )
1250 free_irq( dev->irq, dev );
1251 nl->state &= FL_SECONDARY;
1253 spin_unlock( &nl->lock );
1259 Valid combinations in CSR0 (for probing):
1261 VALID_DECODER 0000,0011,1011,1010
1266 TR_RDY TR_REQ ; 3 ; +
1268 BU_EMP TR_REQ ; 5 ; +
1269 BU_EMP TR_RDY ; 6 ; -
1270 BU_EMP TR_RDY TR_REQ ; 7 ; +
1272 RC_RDY TR_REQ ; 9 ; +
1273 RC_RDY TR_RDY ; 10 ; -
1274 RC_RDY TR_RDY TR_REQ ; 11 ; -
1275 RC_RDY BU_EMP ; 12 ; -
1276 RC_RDY BU_EMP TR_REQ ; 13 ; -
1277 RC_RDY BU_EMP TR_RDY ; 14 ; -
1278 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1281 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1285 sbni_card_probe( unsigned long ioaddr )
1289 csr0 = inb( ioaddr + CSR0 );
1290 if( csr0 != 0xff && csr0 != 0x00 ) {
1295 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1302 /* -------------------------------------------------------------------------- */
1305 sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1307 struct net_local *nl = (struct net_local *) dev->priv;
1308 struct sbni_flags flags;
1311 #ifdef CONFIG_SBNI_MULTILINE
1312 struct net_device *slave_dev;
1313 char slave_name[ 8 ];
1317 case SIOCDEVGETINSTATS :
1318 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1319 sizeof(struct sbni_in_stats) ))
1323 case SIOCDEVRESINSTATS :
1324 if( current->euid != 0 ) /* root only */
1326 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1329 case SIOCDEVGHWSTATE :
1330 flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
1331 flags.rate = nl->csr1.rate;
1332 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1333 flags.rxl = nl->cur_rxl_index;
1334 flags.fixed_rxl = nl->delta_rxl == 0;
1336 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1340 case SIOCDEVSHWSTATE :
1341 if( current->euid != 0 ) /* root only */
1344 spin_lock( &nl->lock );
1345 flags = *(struct sbni_flags*) &ifr->ifr_data;
1346 if( flags.fixed_rxl )
1348 nl->cur_rxl_index = flags.rxl;
1350 nl->delta_rxl = DEF_RXL_DELTA,
1351 nl->cur_rxl_index = DEF_RXL;
1353 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1354 nl->csr1.rate = flags.rate;
1355 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1356 spin_unlock( &nl->lock );
1359 #ifdef CONFIG_SBNI_MULTILINE
1361 case SIOCDEVENSLAVE :
1362 if( current->euid != 0 ) /* root only */
1365 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1367 slave_dev = dev_get_by_name( slave_name );
1368 if( !slave_dev || !(slave_dev->flags & IFF_UP) ) {
1369 printk( KERN_ERR "%s: trying to enslave non-active "
1370 "device %s\n", dev->name, slave_name );
1374 return enslave( dev, slave_dev );
1376 case SIOCDEVEMANSIPATE :
1377 if( current->euid != 0 ) /* root only */
1380 return emancipate( dev );
1382 #endif /* CONFIG_SBNI_MULTILINE */
1392 #ifdef CONFIG_SBNI_MULTILINE
1395 enslave( struct net_device *dev, struct net_device *slave_dev )
1397 struct net_local *nl = (struct net_local *) dev->priv;
1398 struct net_local *snl = (struct net_local *) slave_dev->priv;
1400 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1403 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1406 spin_lock( &nl->lock );
1407 spin_lock( &snl->lock );
1409 /* append to list */
1410 snl->link = nl->link;
1411 nl->link = slave_dev;
1413 snl->state |= FL_SLAVE;
1415 /* Summary statistics of MultiLine operation will be stored
1416 in master's counters */
1417 memset( &snl->stats, 0, sizeof(struct net_device_stats) );
1418 netif_stop_queue( slave_dev );
1419 netif_wake_queue( dev ); /* Now we are able to transmit */
1421 spin_unlock( &snl->lock );
1422 spin_unlock( &nl->lock );
1423 printk( KERN_NOTICE "%s: slave device (%s) attached.\n",
1424 dev->name, slave_dev->name );
1430 emancipate( struct net_device *dev )
1432 struct net_local *snl = (struct net_local *) dev->priv;
1433 struct net_device *p = snl->master;
1434 struct net_local *nl = (struct net_local *) p->priv;
1436 if( !(snl->state & FL_SLAVE) )
1439 spin_lock( &nl->lock );
1440 spin_lock( &snl->lock );
1441 drop_xmit_queue( dev );
1443 /* exclude from list */
1444 for(;;) { /* must be in list */
1445 struct net_local *t = (struct net_local *) p->priv;
1446 if( t->link == dev ) {
1447 t->link = snl->link;
1455 snl->state &= ~FL_SLAVE;
1457 netif_start_queue( dev );
1459 spin_unlock( &snl->lock );
1460 spin_unlock( &nl->lock );
1469 static struct net_device_stats *
1470 sbni_get_stats( struct net_device *dev )
1472 return &((struct net_local *) dev->priv)->stats;
1477 set_multicast_list( struct net_device *dev )
1479 return; /* sbni always operate in promiscuos mode */
1485 MODULE_PARM( io, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
1486 MODULE_PARM( irq, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
1487 MODULE_PARM( baud, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
1488 MODULE_PARM( rxl, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
1489 MODULE_PARM( mac, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
1491 MODULE_PARM( skip_pci_probe, "i" );
1493 MODULE_LICENSE("GPL");
1499 struct net_device *dev;
1502 while( num < SBNI_MAX_NUM_CARDS ) {
1503 dev = alloc_netdev(sizeof(struct net_local),
1504 "sbni%d", sbni_devsetup);
1508 sprintf( dev->name, "sbni%d", num );
1510 err = sbni_init(dev);
1516 if( register_netdev( dev ) ) {
1517 release_region( dev->base_addr, SBNI_IO_EXTENT );
1523 return *sbni_cards ? 0 : -ENODEV;
1527 cleanup_module( void )
1529 struct net_device *dev;
1532 for( num = 0; num < SBNI_MAX_NUM_CARDS; ++num )
1533 if( (dev = sbni_cards[ num ]) != NULL ) {
1534 unregister_netdev( dev );
1535 release_region( dev->base_addr, SBNI_IO_EXTENT );
1543 sbni_setup( char *p )
1550 for( n = 0, parm = 0; *p && n < 8; ) {
1551 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1552 if( !*p || *p == ')' )
1556 else if( *p++ != ',' )
1563 printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1567 __setup( "sbni=", sbni_setup );
1571 /* -------------------------------------------------------------------------- */
1576 calc_crc32( u32 crc, u8 *p, u32 len )
1582 "xorl %%ebx, %%ebx\n"
1585 "movl $crc32tab, %%edi\n"
1592 "movl (%%esi), %%edx\n"
1596 "xorl (%%edi,%%ebx,4), %%eax\n"
1602 "xorl (%%edi,%%ebx,4), %%eax\n"
1608 "xorl (%%edi,%%ebx,4), %%eax\n"
1614 "xorl (%%edi,%%ebx,4), %%eax\n"
1626 "xorb (%%esi), %%bl\n"
1627 "xorl (%%edi,%%ebx,4), %%eax\n"
1634 "xorb 1(%%esi), %%bl\n"
1635 "xorl (%%edi,%%ebx,4), %%eax\n"
1642 "xorb 2(%%esi), %%bl\n"
1643 "xorl (%%edi,%%ebx,4), %%eax\n"
1646 : "0" (_crc), "g" (p), "g" (len)
1647 : "bx", "cx", "dx", "si", "di"
1656 calc_crc32( u32 crc, u8 *p, u32 len )
1659 crc = CRC32( *p++, crc );
1664 #endif /* ASM_CRC */
1667 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1668 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1669 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1670 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1671 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1672 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1673 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1674 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1675 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1676 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1677 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1678 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1679 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1680 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1681 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1682 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1683 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1684 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1685 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1686 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1687 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1688 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1689 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1690 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1691 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1692 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1693 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1694 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1695 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1696 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1697 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1698 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1699 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1700 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1701 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1702 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1703 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1704 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1705 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1706 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1707 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1708 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1709 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1710 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1711 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1712 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1713 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1714 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1715 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1716 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1717 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1718 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1719 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1720 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1721 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1722 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1723 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1724 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1725 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1726 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1727 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1728 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1729 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1730 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1731 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000