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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
42 #include <linux/module.h>
43 #include <linux/kernel.h>
44 #include <linux/ptrace.h>
45 #include <linux/fcntl.h>
46 #include <linux/ioport.h>
47 #include <linux/interrupt.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>
58 #include <net/net_namespace.h>
62 #include <asm/types.h>
63 #include <asm/byteorder.h>
65 #include <asm/uaccess.h>
69 /* device private data */
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 netdev_tx_t sbni_start_xmit(struct sk_buff *,
119 struct net_device * );
120 static int sbni_ioctl( struct net_device *, struct ifreq *, int );
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,
189 #define NET_LOCAL_LOCK(dev) (((struct net_local *)netdev_priv(dev))->lock)
192 * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
193 * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
196 static inline int __init
197 sbni_isa_probe( struct net_device *dev )
199 if( dev->base_addr > 0x1ff &&
200 request_region( dev->base_addr, SBNI_IO_EXTENT, dev->name ) &&
201 sbni_probe1( dev, dev->base_addr, dev->irq ) )
205 pr_err("base address 0x%lx is busy, or adapter is malfunctional!\n",
211 static const struct net_device_ops sbni_netdev_ops = {
212 .ndo_open = sbni_open,
213 .ndo_stop = sbni_close,
214 .ndo_start_xmit = sbni_start_xmit,
215 .ndo_set_multicast_list = set_multicast_list,
216 .ndo_do_ioctl = sbni_ioctl,
217 .ndo_change_mtu = eth_change_mtu,
218 .ndo_set_mac_address = eth_mac_addr,
219 .ndo_validate_addr = eth_validate_addr,
222 static void __init sbni_devsetup(struct net_device *dev)
225 dev->netdev_ops = &sbni_netdev_ops;
228 int __init sbni_probe(int unit)
230 struct net_device *dev;
233 dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
237 dev->netdev_ops = &sbni_netdev_ops;
239 sprintf(dev->name, "sbni%d", unit);
240 netdev_boot_setup_check(dev);
242 err = sbni_init(dev);
248 err = register_netdev(dev);
250 release_region( dev->base_addr, SBNI_IO_EXTENT );
254 pr_info_once("%s", version);
258 static int __init sbni_init(struct net_device *dev)
262 return sbni_isa_probe( dev );
263 /* otherwise we have to perform search our adapter */
265 if( io[ num ] != -1 )
266 dev->base_addr = io[ num ],
267 dev->irq = irq[ num ];
268 else if( scandone || io[ 0 ] != -1 )
271 /* if io[ num ] contains non-zero address, then that is on ISA bus */
273 return sbni_isa_probe( dev );
275 /* ...otherwise - scan PCI first */
276 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
279 if( io[ num ] == -1 ) {
280 /* Auto-scan will be stopped when first ISA card were found */
286 for( i = 0; netcard_portlist[ i ]; ++i ) {
287 int ioaddr = netcard_portlist[ i ];
288 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name ) &&
289 sbni_probe1( dev, ioaddr, 0 ))
298 sbni_pci_probe( struct net_device *dev )
300 struct pci_dev *pdev = NULL;
302 while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
305 unsigned long pci_ioaddr;
308 if( pdev->vendor != SBNI_PCI_VENDOR &&
309 pdev->device != SBNI_PCI_DEVICE )
312 pci_ioaddr = pci_resource_start( pdev, 0 );
313 pci_irq_line = pdev->irq;
315 /* Avoid already found cards from previous calls */
316 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
317 pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
322 /* Dual adapter is present */
323 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
328 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
330 "WARNING: The PCI BIOS assigned this PCI card to IRQ %d, which is unlikely to work!.\n"
331 "You should use the PCI BIOS setup to assign a valid IRQ line.\n",
334 /* avoiding re-enable dual adapters */
335 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
336 release_region( pci_ioaddr, SBNI_IO_EXTENT );
340 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
341 SET_NETDEV_DEV(dev, &pdev->dev);
342 /* not the best thing to do, but this is all messed up
343 for hotplug systems anyway... */
352 static struct net_device * __init
353 sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
355 struct net_local *nl;
357 if( sbni_card_probe( ioaddr ) ) {
358 release_region( ioaddr, SBNI_IO_EXTENT );
362 outb( 0, ioaddr + CSR0 );
365 unsigned long irq_mask;
367 irq_mask = probe_irq_on();
368 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
369 outb( PR_RES, ioaddr + CSR1 );
371 irq = probe_irq_off(irq_mask);
372 outb( 0, ioaddr + CSR0 );
375 pr_err("%s: can't detect device irq!\n", dev->name);
376 release_region( ioaddr, SBNI_IO_EXTENT );
379 } else if( irq == 2 )
383 dev->base_addr = ioaddr;
385 /* Fill in sbni-specific dev fields. */
386 nl = netdev_priv(dev);
388 pr_err("%s: unable to get memory!\n", dev->name);
389 release_region( ioaddr, SBNI_IO_EXTENT );
393 memset( nl, 0, sizeof(struct net_local) );
394 spin_lock_init( &nl->lock );
396 /* store MAC address (generate if that isn't known) */
397 *(__be16 *)dev->dev_addr = htons( 0x00ff );
398 *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
401 (u32)((long)netdev_priv(dev))) & 0x00ffffff));
403 /* store link settings (speed, receive level ) */
404 nl->maxframe = DEFAULT_FRAME_LEN;
405 nl->csr1.rate = baud[ num ];
407 if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
409 nl->cur_rxl_index = DEF_RXL,
410 nl->delta_rxl = DEF_RXL_DELTA;
413 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
414 if( inb( ioaddr + CSR0 ) & 0x01 )
415 nl->state |= FL_SLOW_MODE;
417 pr_notice("%s: ioaddr %#lx, irq %d, MAC: 00:ff:01:%02x:%02x:%02x\n",
418 dev->name, dev->base_addr, dev->irq,
419 ((u8 *)dev->dev_addr)[3],
420 ((u8 *)dev->dev_addr)[4],
421 ((u8 *)dev->dev_addr)[5]);
423 pr_notice("%s: speed %d",
425 ((nl->state & FL_SLOW_MODE) ? 500000 : 2000000)
426 / (1 << nl->csr1.rate));
428 if( nl->delta_rxl == 0 )
429 pr_cont(", receive level 0x%x (fixed)\n", nl->cur_rxl_index);
431 pr_cont(", receive level (auto)\n");
433 #ifdef CONFIG_SBNI_MULTILINE
438 sbni_cards[ num++ ] = dev;
442 /* -------------------------------------------------------------------------- */
444 #ifdef CONFIG_SBNI_MULTILINE
447 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
449 struct net_device *p;
451 netif_stop_queue( dev );
453 /* Looking for idle device in the list */
455 struct net_local *nl = netdev_priv(p);
456 spin_lock( &nl->lock );
457 if( nl->tx_buf_p || (nl->state & FL_LINE_DOWN) ) {
459 spin_unlock( &nl->lock );
461 /* Idle dev is found */
462 prepare_to_send( skb, p );
463 spin_unlock( &nl->lock );
464 netif_start_queue( dev );
469 return NETDEV_TX_BUSY;
472 #else /* CONFIG_SBNI_MULTILINE */
475 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
477 struct net_local *nl = netdev_priv(dev);
479 netif_stop_queue( dev );
480 spin_lock( &nl->lock );
482 prepare_to_send( skb, dev );
484 spin_unlock( &nl->lock );
488 #endif /* CONFIG_SBNI_MULTILINE */
490 /* -------------------------------------------------------------------------- */
492 /* interrupt handler */
495 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
496 * be looked as two independent single-channel devices. Every channel seems
497 * as Ethernet interface but interrupt handler must be common. Really, first
498 * channel ("master") driver only registers the handler. In its struct net_local
499 * it has got pointer to "slave" channel's struct net_local and handles that's
501 * dev of successfully attached ISA SBNI boards is linked to list.
502 * While next board driver is initialized, it scans this list. If one
503 * has found dev with same irq and ioaddr different by 4 then it assumes
504 * this board to be "master".
508 sbni_interrupt( int irq, void *dev_id )
510 struct net_device *dev = dev_id;
511 struct net_local *nl = netdev_priv(dev);
514 spin_lock( &nl->lock );
516 spin_lock(&NET_LOCAL_LOCK(nl->second));
520 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
521 handle_channel( dev ),
523 if( nl->second && /* second channel present */
524 (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
525 handle_channel( nl->second ),
530 spin_unlock(&NET_LOCAL_LOCK(nl->second));
531 spin_unlock( &nl->lock );
537 handle_channel( struct net_device *dev )
539 struct net_local *nl = netdev_priv(dev);
540 unsigned long ioaddr = dev->base_addr;
545 #ifdef CONFIG_SBNI_MULTILINE
546 /* Lock the master device because we going to change its local data */
547 if( nl->state & FL_SLAVE )
548 spin_lock(&NET_LOCAL_LOCK(nl->master));
551 outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
553 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
555 csr0 = inb( ioaddr + CSR0 );
556 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
559 req_ans = !(nl->state & FL_PREV_OK);
562 req_ans = recv_frame( dev );
565 * TR_RDY always equals 1 here because we have owned the marker,
566 * and we set TR_REQ when disabled interrupts
568 csr0 = inb( ioaddr + CSR0 );
569 if( !(csr0 & TR_RDY) || (csr0 & RC_RDY) )
570 netdev_err(dev, "internal error!\n");
572 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
573 if( req_ans || nl->tx_frameno != 0 )
576 /* send marker without any data */
577 outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
580 outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
582 #ifdef CONFIG_SBNI_MULTILINE
583 if( nl->state & FL_SLAVE )
584 spin_unlock(&NET_LOCAL_LOCK(nl->master));
590 * Routine returns 1 if it need to acknoweledge received frame.
591 * Empty frame received without errors won't be acknoweledged.
595 recv_frame( struct net_device *dev )
597 struct net_local *nl = netdev_priv(dev);
598 unsigned long ioaddr = dev->base_addr;
600 u32 crc = CRC32_INITIAL;
602 unsigned framelen = 0, frameno, ack;
603 unsigned is_first, frame_ok = 0;
605 if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
606 frame_ok = framelen > 4
607 ? upload_data( dev, framelen, frameno, is_first, crc )
608 : skip_tail( ioaddr, framelen, crc );
610 interpret_ack( dev, ack );
613 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
615 nl->state |= FL_PREV_OK;
617 nl->in_stats.all_rx_number++;
619 nl->state &= ~FL_PREV_OK,
621 nl->in_stats.all_rx_number++,
622 nl->in_stats.bad_rx_number++;
624 return !frame_ok || framelen > 4;
629 send_frame( struct net_device *dev )
631 struct net_local *nl = netdev_priv(dev);
633 u32 crc = CRC32_INITIAL;
635 if( nl->state & FL_NEED_RESEND ) {
637 /* if frame was sended but not ACK'ed - resend it */
638 if( nl->trans_errors ) {
640 if( nl->framelen != 0 )
641 nl->in_stats.resend_tx_number++;
643 /* cannot xmit with many attempts */
644 #ifdef CONFIG_SBNI_MULTILINE
645 if( (nl->state & FL_SLAVE) || nl->link )
647 nl->state |= FL_LINE_DOWN;
648 drop_xmit_queue( dev );
652 nl->trans_errors = TR_ERROR_COUNT;
654 send_frame_header( dev, &crc );
655 nl->state |= FL_NEED_RESEND;
657 * FL_NEED_RESEND will be cleared after ACK, but if empty
658 * frame sended then in prepare_to_send next frame
663 download_data( dev, &crc );
664 nl->in_stats.all_tx_number++;
665 nl->state |= FL_WAIT_ACK;
668 outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
671 outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
674 /* next frame exists - we request card to send it */
675 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
676 dev->base_addr + CSR0 );
681 * Write the frame data into adapter's buffer memory, and calculate CRC.
682 * Do padding if necessary.
686 download_data( struct net_device *dev, u32 *crc_p )
688 struct net_local *nl = netdev_priv(dev);
689 struct sk_buff *skb = nl->tx_buf_p;
691 unsigned len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
693 outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
694 *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
696 /* if packet too short we should write some more bytes to pad */
697 for( len = nl->framelen - len; len--; )
698 outb( 0, dev->base_addr + DAT ),
699 *crc_p = CRC32( 0, *crc_p );
704 upload_data( struct net_device *dev, unsigned framelen, unsigned frameno,
705 unsigned is_first, u32 crc )
707 struct net_local *nl = netdev_priv(dev);
712 nl->wait_frameno = frameno,
715 if( nl->wait_frameno == frameno ) {
717 if( nl->inppos + framelen <= ETHER_MAX_LEN )
718 frame_ok = append_frame_to_pkt( dev, framelen, crc );
721 * if CRC is right but framelen incorrect then transmitter
722 * error was occurred... drop entire packet
724 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
726 nl->wait_frameno = 0,
728 #ifdef CONFIG_SBNI_MULTILINE
729 nl->master->stats.rx_errors++,
730 nl->master->stats.rx_missed_errors++;
732 dev->stats.rx_errors++,
733 dev->stats.rx_missed_errors++;
735 /* now skip all frames until is_first != 0 */
737 frame_ok = skip_tail( dev->base_addr, framelen, crc );
739 if( is_first && !frame_ok )
741 * Frame has been broken, but we had already stored
742 * is_first... Drop entire packet.
744 nl->wait_frameno = 0,
745 #ifdef CONFIG_SBNI_MULTILINE
746 nl->master->stats.rx_errors++,
747 nl->master->stats.rx_crc_errors++;
749 dev->stats.rx_errors++,
750 dev->stats.rx_crc_errors++;
758 send_complete( struct net_device *dev )
760 struct net_local *nl = netdev_priv(dev);
762 #ifdef CONFIG_SBNI_MULTILINE
763 nl->master->stats.tx_packets++;
764 nl->master->stats.tx_bytes += nl->tx_buf_p->len;
766 dev->stats.tx_packets++;
767 dev->stats.tx_bytes += nl->tx_buf_p->len;
769 dev_kfree_skb_irq( nl->tx_buf_p );
774 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
780 interpret_ack( struct net_device *dev, unsigned ack )
782 struct net_local *nl = netdev_priv(dev);
784 if( ack == FRAME_SENT_OK ) {
785 nl->state &= ~FL_NEED_RESEND;
787 if( nl->state & FL_WAIT_ACK ) {
788 nl->outpos += nl->framelen;
790 if( --nl->tx_frameno )
791 nl->framelen = min_t(unsigned int,
793 nl->tx_buf_p->len - nl->outpos);
795 send_complete( dev ),
796 #ifdef CONFIG_SBNI_MULTILINE
797 netif_wake_queue( nl->master );
799 netif_wake_queue( dev );
804 nl->state &= ~FL_WAIT_ACK;
809 * Glue received frame with previous fragments of packet.
810 * Indicate packet when last frame would be accepted.
814 append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
816 struct net_local *nl = netdev_priv(dev);
820 if( nl->inppos + framelen > ETHER_MAX_LEN )
823 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
826 p = nl->rx_buf_p->data + nl->inppos;
827 insb( dev->base_addr + DAT, p, framelen );
828 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
831 nl->inppos += framelen - 4;
832 if( --nl->wait_frameno == 0 ) /* last frame received */
840 * Prepare to start output on adapter.
841 * Transmitter will be actually activated when marker is accepted.
845 prepare_to_send( struct sk_buff *skb, struct net_device *dev )
847 struct net_local *nl = netdev_priv(dev);
851 /* nl->tx_buf_p == NULL here! */
853 netdev_err(dev, "memory leak!\n");
856 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
859 if( len < SBNI_MIN_LEN )
863 nl->tx_frameno = DIV_ROUND_UP(len, nl->maxframe);
864 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
866 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
867 #ifdef CONFIG_SBNI_MULTILINE
868 nl->master->trans_start = jiffies;
870 dev->trans_start = jiffies;
876 drop_xmit_queue( struct net_device *dev )
878 struct net_local *nl = netdev_priv(dev);
881 dev_kfree_skb_any( nl->tx_buf_p ),
883 #ifdef CONFIG_SBNI_MULTILINE
884 nl->master->stats.tx_errors++,
885 nl->master->stats.tx_carrier_errors++;
887 dev->stats.tx_errors++,
888 dev->stats.tx_carrier_errors++;
894 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
895 #ifdef CONFIG_SBNI_MULTILINE
896 netif_start_queue( nl->master );
897 nl->master->trans_start = jiffies;
899 netif_start_queue( dev );
900 dev->trans_start = jiffies;
906 send_frame_header( struct net_device *dev, u32 *crc_p )
908 struct net_local *nl = netdev_priv(dev);
911 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
914 if( nl->state & FL_NEED_RESEND )
915 len_field |= FRAME_RETRY; /* non-first attempt... */
917 if( nl->outpos == 0 )
918 len_field |= FRAME_FIRST;
920 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
921 outb( SBNI_SIG, dev->base_addr + DAT );
923 value = (u8) len_field;
924 outb( value, dev->base_addr + DAT );
925 crc = CRC32( value, crc );
926 value = (u8) (len_field >> 8);
927 outb( value, dev->base_addr + DAT );
928 crc = CRC32( value, crc );
930 outb( nl->tx_frameno, dev->base_addr + DAT );
931 crc = CRC32( nl->tx_frameno, crc );
932 outb( 0, dev->base_addr + DAT );
933 crc = CRC32( 0, crc );
939 * if frame tail not needed (incorrect number or received twice),
940 * it won't store, but CRC will be calculated
944 skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
947 crc = CRC32( inb( ioaddr + DAT ), crc );
949 return crc == CRC32_REMAINDER;
954 * Preliminary checks if frame header is correct, calculates its CRC
955 * and split it to simple fields
959 check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
960 u32 *is_first, u32 *crc_p )
965 if( inb( ioaddr + DAT ) != SBNI_SIG )
968 value = inb( ioaddr + DAT );
969 *framelen = (u32)value;
970 crc = CRC32( value, crc );
971 value = inb( ioaddr + DAT );
972 *framelen |= ((u32)value) << 8;
973 crc = CRC32( value, crc );
975 *ack = *framelen & FRAME_ACK_MASK;
976 *is_first = (*framelen & FRAME_FIRST) != 0;
978 if( (*framelen &= FRAME_LEN_MASK) < 6 ||
979 *framelen > SBNI_MAX_FRAME - 3 )
982 value = inb( ioaddr + DAT );
983 *frameno = (u32)value;
984 crc = CRC32( value, crc );
986 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
994 static struct sk_buff *
995 get_rx_buf( struct net_device *dev )
997 /* +2 is to compensate for the alignment fixup below */
998 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
1002 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1008 indicate_pkt( struct net_device *dev )
1010 struct net_local *nl = netdev_priv(dev);
1011 struct sk_buff *skb = nl->rx_buf_p;
1013 skb_put( skb, nl->inppos );
1015 #ifdef CONFIG_SBNI_MULTILINE
1016 skb->protocol = eth_type_trans( skb, nl->master );
1018 ++nl->master->stats.rx_packets;
1019 nl->master->stats.rx_bytes += nl->inppos;
1021 skb->protocol = eth_type_trans( skb, dev );
1023 ++dev->stats.rx_packets;
1024 dev->stats.rx_bytes += nl->inppos;
1026 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1030 /* -------------------------------------------------------------------------- */
1033 * Routine checks periodically wire activity and regenerates marker if
1034 * connect was inactive for a long time.
1038 sbni_watchdog( unsigned long arg )
1040 struct net_device *dev = (struct net_device *) arg;
1041 struct net_local *nl = netdev_priv(dev);
1042 struct timer_list *w = &nl->watchdog;
1043 unsigned long flags;
1046 spin_lock_irqsave( &nl->lock, flags );
1048 csr0 = inb( dev->base_addr + CSR0 );
1049 if( csr0 & RC_CHK ) {
1051 if( nl->timer_ticks ) {
1052 if( csr0 & (RC_RDY | BU_EMP) )
1053 /* receiving not active */
1056 nl->in_stats.timeout_number++;
1058 timeout_change_level( dev );
1060 outb( *(u_char *)&nl->csr1 | PR_RES,
1061 dev->base_addr + CSR1 );
1062 csr0 = inb( dev->base_addr + CSR0 );
1065 nl->state &= ~FL_LINE_DOWN;
1067 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1070 w->expires = jiffies + SBNI_TIMEOUT;
1072 w->function = sbni_watchdog;
1075 spin_unlock_irqrestore( &nl->lock, flags );
1079 static unsigned char rxl_tab[] = {
1080 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1081 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1084 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1085 static unsigned char timeout_rxl_tab[] = {
1086 0x03, 0x05, 0x08, 0x0b
1089 /* -------------------------------------------------------------------------- */
1092 card_start( struct net_device *dev )
1094 struct net_local *nl = netdev_priv(dev);
1096 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1097 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1098 nl->state |= FL_PREV_OK;
1100 nl->inppos = nl->outpos = 0;
1101 nl->wait_frameno = 0;
1105 outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1106 outb( EN_INT, dev->base_addr + CSR0 );
1109 /* -------------------------------------------------------------------------- */
1111 /* Receive level auto-selection */
1114 change_level( struct net_device *dev )
1116 struct net_local *nl = netdev_priv(dev);
1118 if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
1121 if( nl->cur_rxl_index == 0 )
1123 else if( nl->cur_rxl_index == 15 )
1125 else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1126 nl->delta_rxl = -nl->delta_rxl;
1128 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1129 inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
1130 outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1132 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1133 nl->cur_rxl_rcvd = 0;
1138 timeout_change_level( struct net_device *dev )
1140 struct net_local *nl = netdev_priv(dev);
1142 nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1143 if( ++nl->timeout_rxl >= 4 )
1144 nl->timeout_rxl = 0;
1146 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1147 inb( dev->base_addr + CSR0 );
1148 outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1150 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1151 nl->cur_rxl_rcvd = 0;
1154 /* -------------------------------------------------------------------------- */
1157 * Open/initialize the board.
1161 sbni_open( struct net_device *dev )
1163 struct net_local *nl = netdev_priv(dev);
1164 struct timer_list *w = &nl->watchdog;
1167 * For double ISA adapters within "common irq" mode, we have to
1168 * determine whether primary or secondary channel is initialized,
1169 * and set the irq handler only in first case.
1171 if( dev->base_addr < 0x400 ) { /* ISA only */
1172 struct net_device **p = sbni_cards;
1173 for( ; *p && p < sbni_cards + SBNI_MAX_NUM_CARDS; ++p )
1174 if( (*p)->irq == dev->irq &&
1175 ((*p)->base_addr == dev->base_addr + 4 ||
1176 (*p)->base_addr == dev->base_addr - 4) &&
1177 (*p)->flags & IFF_UP ) {
1179 ((struct net_local *) (netdev_priv(*p)))
1181 netdev_notice(dev, "using shared irq with %s\n",
1183 nl->state |= FL_SECONDARY;
1184 goto handler_attached;
1188 if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1189 netdev_err(dev, "unable to get IRQ %d\n", dev->irq);
1195 spin_lock( &nl->lock );
1196 memset( &dev->stats, 0, sizeof(struct net_device_stats) );
1197 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1201 netif_start_queue( dev );
1203 /* set timer watchdog */
1205 w->expires = jiffies + SBNI_TIMEOUT;
1206 w->data = (unsigned long) dev;
1207 w->function = sbni_watchdog;
1210 spin_unlock( &nl->lock );
1216 sbni_close( struct net_device *dev )
1218 struct net_local *nl = netdev_priv(dev);
1220 if( nl->second && nl->second->flags & IFF_UP ) {
1221 netdev_notice(dev, "Secondary channel (%s) is active!\n",
1226 #ifdef CONFIG_SBNI_MULTILINE
1227 if( nl->state & FL_SLAVE )
1230 while( nl->link ) /* it's master device! */
1231 emancipate( nl->link );
1234 spin_lock( &nl->lock );
1237 drop_xmit_queue( dev );
1238 netif_stop_queue( dev );
1240 del_timer( &nl->watchdog );
1242 outb( 0, dev->base_addr + CSR0 );
1244 if( !(nl->state & FL_SECONDARY) )
1245 free_irq( dev->irq, dev );
1246 nl->state &= FL_SECONDARY;
1248 spin_unlock( &nl->lock );
1254 Valid combinations in CSR0 (for probing):
1256 VALID_DECODER 0000,0011,1011,1010
1261 TR_RDY TR_REQ ; 3 ; +
1263 BU_EMP TR_REQ ; 5 ; +
1264 BU_EMP TR_RDY ; 6 ; -
1265 BU_EMP TR_RDY TR_REQ ; 7 ; +
1267 RC_RDY TR_REQ ; 9 ; +
1268 RC_RDY TR_RDY ; 10 ; -
1269 RC_RDY TR_RDY TR_REQ ; 11 ; -
1270 RC_RDY BU_EMP ; 12 ; -
1271 RC_RDY BU_EMP TR_REQ ; 13 ; -
1272 RC_RDY BU_EMP TR_RDY ; 14 ; -
1273 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1276 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1280 sbni_card_probe( unsigned long ioaddr )
1284 csr0 = inb( ioaddr + CSR0 );
1285 if( csr0 != 0xff && csr0 != 0x00 ) {
1290 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1297 /* -------------------------------------------------------------------------- */
1300 sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1302 struct net_local *nl = netdev_priv(dev);
1303 struct sbni_flags flags;
1306 #ifdef CONFIG_SBNI_MULTILINE
1307 struct net_device *slave_dev;
1308 char slave_name[ 8 ];
1312 case SIOCDEVGETINSTATS :
1313 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1314 sizeof(struct sbni_in_stats) ))
1318 case SIOCDEVRESINSTATS :
1319 if (!capable(CAP_NET_ADMIN))
1321 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1324 case SIOCDEVGHWSTATE :
1325 flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
1326 flags.rate = nl->csr1.rate;
1327 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1328 flags.rxl = nl->cur_rxl_index;
1329 flags.fixed_rxl = nl->delta_rxl == 0;
1331 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1335 case SIOCDEVSHWSTATE :
1336 if (!capable(CAP_NET_ADMIN))
1339 spin_lock( &nl->lock );
1340 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1341 if( flags.fixed_rxl )
1343 nl->cur_rxl_index = flags.rxl;
1345 nl->delta_rxl = DEF_RXL_DELTA,
1346 nl->cur_rxl_index = DEF_RXL;
1348 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1349 nl->csr1.rate = flags.rate;
1350 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1351 spin_unlock( &nl->lock );
1354 #ifdef CONFIG_SBNI_MULTILINE
1356 case SIOCDEVENSLAVE :
1357 if (!capable(CAP_NET_ADMIN))
1360 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1362 slave_dev = dev_get_by_name(&init_net, slave_name );
1363 if( !slave_dev || !(slave_dev->flags & IFF_UP) ) {
1364 netdev_err(dev, "trying to enslave non-active device %s\n",
1369 return enslave( dev, slave_dev );
1371 case SIOCDEVEMANSIPATE :
1372 if (!capable(CAP_NET_ADMIN))
1375 return emancipate( dev );
1377 #endif /* CONFIG_SBNI_MULTILINE */
1387 #ifdef CONFIG_SBNI_MULTILINE
1390 enslave( struct net_device *dev, struct net_device *slave_dev )
1392 struct net_local *nl = netdev_priv(dev);
1393 struct net_local *snl = netdev_priv(slave_dev);
1395 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1398 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1401 spin_lock( &nl->lock );
1402 spin_lock( &snl->lock );
1404 /* append to list */
1405 snl->link = nl->link;
1406 nl->link = slave_dev;
1408 snl->state |= FL_SLAVE;
1410 /* Summary statistics of MultiLine operation will be stored
1411 in master's counters */
1412 memset( &slave_dev->stats, 0, sizeof(struct net_device_stats) );
1413 netif_stop_queue( slave_dev );
1414 netif_wake_queue( dev ); /* Now we are able to transmit */
1416 spin_unlock( &snl->lock );
1417 spin_unlock( &nl->lock );
1418 netdev_notice(dev, "slave device (%s) attached\n", slave_dev->name);
1424 emancipate( struct net_device *dev )
1426 struct net_local *snl = netdev_priv(dev);
1427 struct net_device *p = snl->master;
1428 struct net_local *nl = netdev_priv(p);
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 = netdev_priv(p);
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 set_multicast_list( struct net_device *dev )
1465 return; /* sbni always operate in promiscuos mode */
1470 module_param_array(io, int, NULL, 0);
1471 module_param_array(irq, int, NULL, 0);
1472 module_param_array(baud, int, NULL, 0);
1473 module_param_array(rxl, int, NULL, 0);
1474 module_param_array(mac, int, NULL, 0);
1475 module_param(skip_pci_probe, bool, 0);
1477 MODULE_LICENSE("GPL");
1480 int __init init_module( void )
1482 struct net_device *dev;
1485 while( num < SBNI_MAX_NUM_CARDS ) {
1486 dev = alloc_netdev(sizeof(struct net_local),
1487 "sbni%d", sbni_devsetup);
1491 sprintf( dev->name, "sbni%d", num );
1493 err = sbni_init(dev);
1499 if( register_netdev( dev ) ) {
1500 release_region( dev->base_addr, SBNI_IO_EXTENT );
1506 return *sbni_cards ? 0 : -ENODEV;
1510 cleanup_module(void)
1514 for (i = 0; i < SBNI_MAX_NUM_CARDS; ++i) {
1515 struct net_device *dev = sbni_cards[i];
1517 unregister_netdev(dev);
1518 release_region(dev->base_addr, SBNI_IO_EXTENT);
1527 sbni_setup( char *p )
1534 for( n = 0, parm = 0; *p && n < 8; ) {
1535 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1536 if( !*p || *p == ')' )
1540 else if( *p++ != ',' )
1547 pr_err("Error in sbni kernel parameter!\n");
1551 __setup( "sbni=", sbni_setup );
1555 /* -------------------------------------------------------------------------- */
1560 calc_crc32( u32 crc, u8 *p, u32 len )
1565 __asm__ __volatile__ (
1566 "xorl %%ebx, %%ebx\n"
1569 "movl $crc32tab, %%edi\n"
1576 "movl (%%esi), %%edx\n"
1580 "xorl (%%edi,%%ebx,4), %%eax\n"
1586 "xorl (%%edi,%%ebx,4), %%eax\n"
1592 "xorl (%%edi,%%ebx,4), %%eax\n"
1598 "xorl (%%edi,%%ebx,4), %%eax\n"
1610 "xorb (%%esi), %%bl\n"
1611 "xorl (%%edi,%%ebx,4), %%eax\n"
1618 "xorb 1(%%esi), %%bl\n"
1619 "xorl (%%edi,%%ebx,4), %%eax\n"
1626 "xorb 2(%%esi), %%bl\n"
1627 "xorl (%%edi,%%ebx,4), %%eax\n"
1630 : "0" (_crc), "g" (p), "g" (len)
1631 : "bx", "cx", "dx", "si", "di"
1640 calc_crc32( u32 crc, u8 *p, u32 len )
1643 crc = CRC32( *p++, crc );
1648 #endif /* ASM_CRC */
1651 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1652 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1653 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1654 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1655 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1656 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1657 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1658 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1659 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1660 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1661 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1662 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1663 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1664 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1665 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1666 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1667 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1668 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1669 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1670 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1671 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1672 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1673 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1674 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1675 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1676 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1677 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1678 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1679 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1680 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1681 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1682 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1683 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1684 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1685 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1686 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1687 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1688 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1689 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1690 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1691 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1692 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1693 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1694 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1695 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1696 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1697 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1698 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1699 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1700 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1701 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1702 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1703 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1704 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1705 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1706 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1707 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1708 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1709 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1710 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1711 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1712 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1713 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1714 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1715 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000