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>
60 #include <net/Space.h>
63 #include <asm/types.h>
64 #include <asm/byteorder.h>
66 #include <linux/uaccess.h>
70 /* device private data */
73 struct timer_list watchdog;
74 struct net_device *watchdog_dev;
77 struct sk_buff *rx_buf_p; /* receive buffer ptr */
78 struct sk_buff *tx_buf_p; /* transmit buffer ptr */
80 unsigned int framelen; /* current frame length */
81 unsigned int maxframe; /* maximum valid frame length */
83 unsigned int inppos, outpos; /* positions in rx/tx buffers */
85 /* transmitting frame number - from frames qty to 1 */
86 unsigned int tx_frameno;
88 /* expected number of next receiving frame */
89 unsigned int wait_frameno;
91 /* count of failed attempts to frame send - 32 attempts do before
92 error - while receiver tunes on opposite side of wire */
93 unsigned int trans_errors;
95 /* idle time; send pong when limit exceeded */
96 unsigned int timer_ticks;
98 /* fields used for receive level autoselection */
100 unsigned int cur_rxl_index, timeout_rxl;
101 unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
103 struct sbni_csr1 csr1; /* current value of CSR1 */
104 struct sbni_in_stats in_stats; /* internal statistics */
106 struct net_device *second; /* for ISA/dual cards */
108 #ifdef CONFIG_SBNI_MULTILINE
109 struct net_device *master;
110 struct net_device *link;
115 static int sbni_card_probe( unsigned long );
116 static int sbni_pci_probe( struct net_device * );
117 static struct net_device *sbni_probe1(struct net_device *, unsigned long, int);
118 static int sbni_open( struct net_device * );
119 static int sbni_close( struct net_device * );
120 static netdev_tx_t sbni_start_xmit(struct sk_buff *,
121 struct net_device * );
122 static int sbni_ioctl( struct net_device *, struct ifreq *, int );
123 static void set_multicast_list( struct net_device * );
125 static irqreturn_t sbni_interrupt( int, void * );
126 static void handle_channel( struct net_device * );
127 static int recv_frame( struct net_device * );
128 static void send_frame( struct net_device * );
129 static int upload_data( struct net_device *,
130 unsigned, unsigned, unsigned, u32 );
131 static void download_data( struct net_device *, u32 * );
132 static void sbni_watchdog(struct timer_list *);
133 static void interpret_ack( struct net_device *, unsigned );
134 static int append_frame_to_pkt( struct net_device *, unsigned, u32 );
135 static void indicate_pkt( struct net_device * );
136 static void card_start( struct net_device * );
137 static void prepare_to_send( struct sk_buff *, struct net_device * );
138 static void drop_xmit_queue( struct net_device * );
139 static void send_frame_header( struct net_device *, u32 * );
140 static int skip_tail( unsigned int, unsigned int, u32 );
141 static int check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
142 static void change_level( struct net_device * );
143 static void timeout_change_level( struct net_device * );
144 static u32 calc_crc32( u32, u8 *, u32 );
145 static struct sk_buff * get_rx_buf( struct net_device * );
146 static int sbni_init( struct net_device * );
148 #ifdef CONFIG_SBNI_MULTILINE
149 static int enslave( struct net_device *, struct net_device * );
150 static int emancipate( struct net_device * );
153 static const char version[] =
154 "Granch SBNI12 driver ver 5.0.1 Jun 22 2001 Denis I.Timofeev.\n";
156 static bool skip_pci_probe __initdata = false;
157 static int scandone __initdata = 0;
158 static int num __initdata = 0;
160 static unsigned char rxl_tab[];
161 static u32 crc32tab[];
163 /* A list of all installed devices, for removing the driver module. */
164 static struct net_device *sbni_cards[ SBNI_MAX_NUM_CARDS ];
166 /* Lists of device's parameters */
167 static u32 io[ SBNI_MAX_NUM_CARDS ] __initdata =
168 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
169 static u32 irq[ SBNI_MAX_NUM_CARDS ] __initdata;
170 static u32 baud[ SBNI_MAX_NUM_CARDS ] __initdata;
171 static u32 rxl[ SBNI_MAX_NUM_CARDS ] __initdata =
172 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
173 static u32 mac[ SBNI_MAX_NUM_CARDS ] __initdata;
177 static iarr *dest[5] __initdata = { &io, &irq, &baud, &rxl, &mac };
180 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
181 static unsigned int netcard_portlist[ ] __initdata = {
182 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
183 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
184 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
187 #define NET_LOCAL_LOCK(dev) (((struct net_local *)netdev_priv(dev))->lock)
190 * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
191 * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
194 static inline int __init
195 sbni_isa_probe( struct net_device *dev )
197 if( dev->base_addr > 0x1ff &&
198 request_region( dev->base_addr, SBNI_IO_EXTENT, dev->name ) &&
199 sbni_probe1( dev, dev->base_addr, dev->irq ) )
203 pr_err("base address 0x%lx is busy, or adapter is malfunctional!\n",
209 static const struct net_device_ops sbni_netdev_ops = {
210 .ndo_open = sbni_open,
211 .ndo_stop = sbni_close,
212 .ndo_start_xmit = sbni_start_xmit,
213 .ndo_set_rx_mode = set_multicast_list,
214 .ndo_do_ioctl = sbni_ioctl,
215 .ndo_set_mac_address = eth_mac_addr,
216 .ndo_validate_addr = eth_validate_addr,
219 static void __init sbni_devsetup(struct net_device *dev)
222 dev->netdev_ops = &sbni_netdev_ops;
225 int __init sbni_probe(int unit)
227 struct net_device *dev;
230 dev = alloc_netdev(sizeof(struct net_local), "sbni",
231 NET_NAME_UNKNOWN, sbni_devsetup);
235 dev->netdev_ops = &sbni_netdev_ops;
237 sprintf(dev->name, "sbni%d", unit);
238 netdev_boot_setup_check(dev);
240 err = sbni_init(dev);
246 err = register_netdev(dev);
248 release_region( dev->base_addr, SBNI_IO_EXTENT );
252 pr_info_once("%s", version);
256 static int __init sbni_init(struct net_device *dev)
260 return sbni_isa_probe( dev );
261 /* otherwise we have to perform search our adapter */
263 if( io[ num ] != -1 ) {
264 dev->base_addr = io[ num ];
265 dev->irq = irq[ num ];
266 } else if( scandone || io[ 0 ] != -1 ) {
270 /* if io[ num ] contains non-zero address, then that is on ISA bus */
272 return sbni_isa_probe( dev );
274 /* ...otherwise - scan PCI first */
275 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
278 if( io[ num ] == -1 ) {
279 /* Auto-scan will be stopped when first ISA card were found */
285 for( i = 0; netcard_portlist[ i ]; ++i ) {
286 int ioaddr = netcard_portlist[ i ];
287 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name ) &&
288 sbni_probe1( dev, ioaddr, 0 ))
297 sbni_pci_probe( struct net_device *dev )
299 struct pci_dev *pdev = NULL;
301 while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
304 unsigned long pci_ioaddr;
306 if( pdev->vendor != SBNI_PCI_VENDOR &&
307 pdev->device != SBNI_PCI_DEVICE )
310 pci_ioaddr = pci_resource_start( pdev, 0 );
311 pci_irq_line = pdev->irq;
313 /* Avoid already found cards from previous calls */
314 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
315 if (pdev->subsystem_device != 2)
318 /* Dual adapter is present */
319 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
324 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
326 "WARNING: The PCI BIOS assigned this PCI card to IRQ %d, which is unlikely to work!.\n"
327 "You should use the PCI BIOS setup to assign a valid IRQ line.\n",
330 /* avoiding re-enable dual adapters */
331 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
332 release_region( pci_ioaddr, SBNI_IO_EXTENT );
336 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
337 SET_NETDEV_DEV(dev, &pdev->dev);
338 /* not the best thing to do, but this is all messed up
339 for hotplug systems anyway... */
348 static struct net_device * __init
349 sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
351 struct net_local *nl;
353 if( sbni_card_probe( ioaddr ) ) {
354 release_region( ioaddr, SBNI_IO_EXTENT );
358 outb( 0, ioaddr + CSR0 );
361 unsigned long irq_mask;
363 irq_mask = probe_irq_on();
364 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
365 outb( PR_RES, ioaddr + CSR1 );
367 irq = probe_irq_off(irq_mask);
368 outb( 0, ioaddr + CSR0 );
371 pr_err("%s: can't detect device irq!\n", dev->name);
372 release_region( ioaddr, SBNI_IO_EXTENT );
375 } else if( irq == 2 )
379 dev->base_addr = ioaddr;
381 /* Fill in sbni-specific dev fields. */
382 nl = netdev_priv(dev);
384 pr_err("%s: unable to get memory!\n", dev->name);
385 release_region( ioaddr, SBNI_IO_EXTENT );
389 memset( nl, 0, sizeof(struct net_local) );
390 spin_lock_init( &nl->lock );
392 /* store MAC address (generate if that isn't known) */
393 *(__be16 *)dev->dev_addr = htons( 0x00ff );
394 *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
397 (u32)((long)netdev_priv(dev))) & 0x00ffffff));
399 /* store link settings (speed, receive level ) */
400 nl->maxframe = DEFAULT_FRAME_LEN;
401 nl->csr1.rate = baud[ num ];
403 if( (nl->cur_rxl_index = rxl[ num ]) == -1 ) {
405 nl->cur_rxl_index = DEF_RXL;
406 nl->delta_rxl = DEF_RXL_DELTA;
410 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
411 if( inb( ioaddr + CSR0 ) & 0x01 )
412 nl->state |= FL_SLOW_MODE;
414 pr_notice("%s: ioaddr %#lx, irq %d, MAC: 00:ff:01:%02x:%02x:%02x\n",
415 dev->name, dev->base_addr, dev->irq,
416 ((u8 *)dev->dev_addr)[3],
417 ((u8 *)dev->dev_addr)[4],
418 ((u8 *)dev->dev_addr)[5]);
420 pr_notice("%s: speed %d",
422 ((nl->state & FL_SLOW_MODE) ? 500000 : 2000000)
423 / (1 << nl->csr1.rate));
425 if( nl->delta_rxl == 0 )
426 pr_cont(", receive level 0x%x (fixed)\n", nl->cur_rxl_index);
428 pr_cont(", receive level (auto)\n");
430 #ifdef CONFIG_SBNI_MULTILINE
435 sbni_cards[ num++ ] = dev;
439 /* -------------------------------------------------------------------------- */
441 #ifdef CONFIG_SBNI_MULTILINE
444 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
446 struct net_device *p;
448 netif_stop_queue( dev );
450 /* Looking for idle device in the list */
452 struct net_local *nl = netdev_priv(p);
453 spin_lock( &nl->lock );
454 if( nl->tx_buf_p || (nl->state & FL_LINE_DOWN) ) {
456 spin_unlock( &nl->lock );
458 /* Idle dev is found */
459 prepare_to_send( skb, p );
460 spin_unlock( &nl->lock );
461 netif_start_queue( dev );
466 return NETDEV_TX_BUSY;
469 #else /* CONFIG_SBNI_MULTILINE */
472 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
474 struct net_local *nl = netdev_priv(dev);
476 netif_stop_queue( dev );
477 spin_lock( &nl->lock );
479 prepare_to_send( skb, dev );
481 spin_unlock( &nl->lock );
485 #endif /* CONFIG_SBNI_MULTILINE */
487 /* -------------------------------------------------------------------------- */
489 /* interrupt handler */
492 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
493 * be looked as two independent single-channel devices. Every channel seems
494 * as Ethernet interface but interrupt handler must be common. Really, first
495 * channel ("master") driver only registers the handler. In its struct net_local
496 * it has got pointer to "slave" channel's struct net_local and handles that's
498 * dev of successfully attached ISA SBNI boards is linked to list.
499 * While next board driver is initialized, it scans this list. If one
500 * has found dev with same irq and ioaddr different by 4 then it assumes
501 * this board to be "master".
505 sbni_interrupt( int irq, void *dev_id )
507 struct net_device *dev = dev_id;
508 struct net_local *nl = netdev_priv(dev);
511 spin_lock( &nl->lock );
513 spin_lock(&NET_LOCAL_LOCK(nl->second));
517 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) ) {
518 handle_channel( dev );
521 if( nl->second && /* second channel present */
522 (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) ) {
523 handle_channel( nl->second );
529 spin_unlock(&NET_LOCAL_LOCK(nl->second));
530 spin_unlock( &nl->lock );
536 handle_channel( struct net_device *dev )
538 struct net_local *nl = netdev_priv(dev);
539 unsigned long ioaddr = dev->base_addr;
544 #ifdef CONFIG_SBNI_MULTILINE
545 /* Lock the master device because we going to change its local data */
546 if( nl->state & FL_SLAVE )
547 spin_lock(&NET_LOCAL_LOCK(nl->master));
550 outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
552 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
554 csr0 = inb( ioaddr + CSR0 );
555 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
558 req_ans = !(nl->state & FL_PREV_OK);
561 req_ans = recv_frame( dev );
564 * TR_RDY always equals 1 here because we have owned the marker,
565 * and we set TR_REQ when disabled interrupts
567 csr0 = inb( ioaddr + CSR0 );
568 if( !(csr0 & TR_RDY) || (csr0 & RC_RDY) )
569 netdev_err(dev, "internal error!\n");
571 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
572 if( req_ans || nl->tx_frameno != 0 )
575 /* send marker without any data */
576 outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
579 outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
581 #ifdef CONFIG_SBNI_MULTILINE
582 if( nl->state & FL_SLAVE )
583 spin_unlock(&NET_LOCAL_LOCK(nl->master));
589 * Routine returns 1 if it needs to acknowledge received frame.
590 * Empty frame received without errors won't be acknowledged.
594 recv_frame( struct net_device *dev )
596 struct net_local *nl = netdev_priv(dev);
597 unsigned long ioaddr = dev->base_addr;
599 u32 crc = CRC32_INITIAL;
601 unsigned framelen = 0, frameno, ack;
602 unsigned is_first, frame_ok = 0;
604 if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
605 frame_ok = framelen > 4
606 ? upload_data( dev, framelen, frameno, is_first, crc )
607 : skip_tail( ioaddr, framelen, crc );
609 interpret_ack( dev, ack );
612 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
614 nl->state |= FL_PREV_OK;
616 nl->in_stats.all_rx_number++;
618 nl->state &= ~FL_PREV_OK;
620 nl->in_stats.all_rx_number++;
621 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 );
705 upload_data( struct net_device *dev, unsigned framelen, unsigned frameno,
706 unsigned is_first, u32 crc )
708 struct net_local *nl = netdev_priv(dev);
713 nl->wait_frameno = frameno;
717 if( nl->wait_frameno == frameno ) {
719 if( nl->inppos + framelen <= ETHER_MAX_LEN )
720 frame_ok = append_frame_to_pkt( dev, framelen, crc );
723 * if CRC is right but framelen incorrect then transmitter
724 * error was occurred... drop entire packet
726 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
728 nl->wait_frameno = 0;
730 #ifdef CONFIG_SBNI_MULTILINE
731 nl->master->stats.rx_errors++;
732 nl->master->stats.rx_missed_errors++;
734 dev->stats.rx_errors++;
735 dev->stats.rx_missed_errors++;
738 /* now skip all frames until is_first != 0 */
740 frame_ok = skip_tail( dev->base_addr, framelen, crc );
742 if( is_first && !frame_ok ) {
744 * Frame has been broken, but we had already stored
745 * is_first... Drop entire packet.
747 nl->wait_frameno = 0;
748 #ifdef CONFIG_SBNI_MULTILINE
749 nl->master->stats.rx_errors++;
750 nl->master->stats.rx_crc_errors++;
752 dev->stats.rx_errors++;
753 dev->stats.rx_crc_errors++;
762 send_complete( struct net_device *dev )
764 struct net_local *nl = netdev_priv(dev);
766 #ifdef CONFIG_SBNI_MULTILINE
767 nl->master->stats.tx_packets++;
768 nl->master->stats.tx_bytes += nl->tx_buf_p->len;
770 dev->stats.tx_packets++;
771 dev->stats.tx_bytes += nl->tx_buf_p->len;
773 dev_consume_skb_irq(nl->tx_buf_p);
778 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
784 interpret_ack( struct net_device *dev, unsigned ack )
786 struct net_local *nl = netdev_priv(dev);
788 if( ack == FRAME_SENT_OK ) {
789 nl->state &= ~FL_NEED_RESEND;
791 if( nl->state & FL_WAIT_ACK ) {
792 nl->outpos += nl->framelen;
794 if( --nl->tx_frameno ) {
795 nl->framelen = min_t(unsigned int,
797 nl->tx_buf_p->len - nl->outpos);
799 send_complete( dev );
800 #ifdef CONFIG_SBNI_MULTILINE
801 netif_wake_queue( nl->master );
803 netif_wake_queue( dev );
809 nl->state &= ~FL_WAIT_ACK;
814 * Glue received frame with previous fragments of packet.
815 * Indicate packet when last frame would be accepted.
819 append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
821 struct net_local *nl = netdev_priv(dev);
825 if( nl->inppos + framelen > ETHER_MAX_LEN )
828 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
831 p = nl->rx_buf_p->data + nl->inppos;
832 insb( dev->base_addr + DAT, p, framelen );
833 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
836 nl->inppos += framelen - 4;
837 if( --nl->wait_frameno == 0 ) /* last frame received */
845 * Prepare to start output on adapter.
846 * Transmitter will be actually activated when marker is accepted.
850 prepare_to_send( struct sk_buff *skb, struct net_device *dev )
852 struct net_local *nl = netdev_priv(dev);
856 /* nl->tx_buf_p == NULL here! */
858 netdev_err(dev, "memory leak!\n");
861 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
864 if( len < SBNI_MIN_LEN )
868 nl->tx_frameno = DIV_ROUND_UP(len, nl->maxframe);
869 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
871 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
872 #ifdef CONFIG_SBNI_MULTILINE
873 netif_trans_update(nl->master);
875 netif_trans_update(dev);
881 drop_xmit_queue( struct net_device *dev )
883 struct net_local *nl = netdev_priv(dev);
886 dev_kfree_skb_any( nl->tx_buf_p );
888 #ifdef CONFIG_SBNI_MULTILINE
889 nl->master->stats.tx_errors++;
890 nl->master->stats.tx_carrier_errors++;
892 dev->stats.tx_errors++;
893 dev->stats.tx_carrier_errors++;
900 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
901 #ifdef CONFIG_SBNI_MULTILINE
902 netif_start_queue( nl->master );
903 netif_trans_update(nl->master);
905 netif_start_queue( dev );
906 netif_trans_update(dev);
912 send_frame_header( struct net_device *dev, u32 *crc_p )
914 struct net_local *nl = netdev_priv(dev);
917 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
920 if( nl->state & FL_NEED_RESEND )
921 len_field |= FRAME_RETRY; /* non-first attempt... */
923 if( nl->outpos == 0 )
924 len_field |= FRAME_FIRST;
926 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
927 outb( SBNI_SIG, dev->base_addr + DAT );
929 value = (u8) len_field;
930 outb( value, dev->base_addr + DAT );
931 crc = CRC32( value, crc );
932 value = (u8) (len_field >> 8);
933 outb( value, dev->base_addr + DAT );
934 crc = CRC32( value, crc );
936 outb( nl->tx_frameno, dev->base_addr + DAT );
937 crc = CRC32( nl->tx_frameno, crc );
938 outb( 0, dev->base_addr + DAT );
939 crc = CRC32( 0, crc );
945 * if frame tail not needed (incorrect number or received twice),
946 * it won't store, but CRC will be calculated
950 skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
953 crc = CRC32( inb( ioaddr + DAT ), crc );
955 return crc == CRC32_REMAINDER;
960 * Preliminary checks if frame header is correct, calculates its CRC
961 * and split it to simple fields
965 check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
966 u32 *is_first, u32 *crc_p )
971 if( inb( ioaddr + DAT ) != SBNI_SIG )
974 value = inb( ioaddr + DAT );
975 *framelen = (u32)value;
976 crc = CRC32( value, crc );
977 value = inb( ioaddr + DAT );
978 *framelen |= ((u32)value) << 8;
979 crc = CRC32( value, crc );
981 *ack = *framelen & FRAME_ACK_MASK;
982 *is_first = (*framelen & FRAME_FIRST) != 0;
984 if( (*framelen &= FRAME_LEN_MASK) < 6 ||
985 *framelen > SBNI_MAX_FRAME - 3 )
988 value = inb( ioaddr + DAT );
989 *frameno = (u32)value;
990 crc = CRC32( value, crc );
992 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
1000 static struct sk_buff *
1001 get_rx_buf( struct net_device *dev )
1003 /* +2 is to compensate for the alignment fixup below */
1004 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
1008 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1014 indicate_pkt( struct net_device *dev )
1016 struct net_local *nl = netdev_priv(dev);
1017 struct sk_buff *skb = nl->rx_buf_p;
1019 skb_put( skb, nl->inppos );
1021 #ifdef CONFIG_SBNI_MULTILINE
1022 skb->protocol = eth_type_trans( skb, nl->master );
1024 ++nl->master->stats.rx_packets;
1025 nl->master->stats.rx_bytes += nl->inppos;
1027 skb->protocol = eth_type_trans( skb, dev );
1029 ++dev->stats.rx_packets;
1030 dev->stats.rx_bytes += nl->inppos;
1032 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1036 /* -------------------------------------------------------------------------- */
1039 * Routine checks periodically wire activity and regenerates marker if
1040 * connect was inactive for a long time.
1044 sbni_watchdog(struct timer_list *t)
1046 struct net_local *nl = from_timer(nl, t, watchdog);
1047 struct net_device *dev = nl->watchdog_dev;
1048 unsigned long flags;
1051 spin_lock_irqsave( &nl->lock, flags );
1053 csr0 = inb( dev->base_addr + CSR0 );
1054 if( csr0 & RC_CHK ) {
1056 if( nl->timer_ticks ) {
1057 if( csr0 & (RC_RDY | BU_EMP) )
1058 /* receiving not active */
1061 nl->in_stats.timeout_number++;
1063 timeout_change_level( dev );
1065 outb( *(u_char *)&nl->csr1 | PR_RES,
1066 dev->base_addr + CSR1 );
1067 csr0 = inb( dev->base_addr + CSR0 );
1070 nl->state &= ~FL_LINE_DOWN;
1072 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1074 mod_timer(t, jiffies + SBNI_TIMEOUT);
1076 spin_unlock_irqrestore( &nl->lock, flags );
1080 static unsigned char rxl_tab[] = {
1081 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1082 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1085 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1086 static unsigned char timeout_rxl_tab[] = {
1087 0x03, 0x05, 0x08, 0x0b
1090 /* -------------------------------------------------------------------------- */
1093 card_start( struct net_device *dev )
1095 struct net_local *nl = netdev_priv(dev);
1097 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1098 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1099 nl->state |= FL_PREV_OK;
1101 nl->inppos = nl->outpos = 0;
1102 nl->wait_frameno = 0;
1106 outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1107 outb( EN_INT, dev->base_addr + CSR0 );
1110 /* -------------------------------------------------------------------------- */
1112 /* Receive level auto-selection */
1115 change_level( struct net_device *dev )
1117 struct net_local *nl = netdev_priv(dev);
1119 if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
1122 if( nl->cur_rxl_index == 0 )
1124 else if( nl->cur_rxl_index == 15 )
1126 else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1127 nl->delta_rxl = -nl->delta_rxl;
1129 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1130 inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
1131 outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1133 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1134 nl->cur_rxl_rcvd = 0;
1139 timeout_change_level( struct net_device *dev )
1141 struct net_local *nl = netdev_priv(dev);
1143 nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1144 if( ++nl->timeout_rxl >= 4 )
1145 nl->timeout_rxl = 0;
1147 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1148 inb( dev->base_addr + CSR0 );
1149 outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1151 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1152 nl->cur_rxl_rcvd = 0;
1155 /* -------------------------------------------------------------------------- */
1158 * Open/initialize the board.
1162 sbni_open( struct net_device *dev )
1164 struct net_local *nl = netdev_priv(dev);
1165 struct timer_list *w = &nl->watchdog;
1168 * For double ISA adapters within "common irq" mode, we have to
1169 * determine whether primary or secondary channel is initialized,
1170 * and set the irq handler only in first case.
1172 if( dev->base_addr < 0x400 ) { /* ISA only */
1173 struct net_device **p = sbni_cards;
1174 for( ; *p && p < sbni_cards + SBNI_MAX_NUM_CARDS; ++p )
1175 if( (*p)->irq == dev->irq &&
1176 ((*p)->base_addr == dev->base_addr + 4 ||
1177 (*p)->base_addr == dev->base_addr - 4) &&
1178 (*p)->flags & IFF_UP ) {
1180 ((struct net_local *) (netdev_priv(*p)))
1182 netdev_notice(dev, "using shared irq with %s\n",
1184 nl->state |= FL_SECONDARY;
1185 goto handler_attached;
1189 if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1190 netdev_err(dev, "unable to get IRQ %d\n", dev->irq);
1196 spin_lock( &nl->lock );
1197 memset( &dev->stats, 0, sizeof(struct net_device_stats) );
1198 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1202 netif_start_queue( dev );
1204 /* set timer watchdog */
1205 nl->watchdog_dev = dev;
1206 timer_setup(w, sbni_watchdog, 0);
1207 w->expires = jiffies + SBNI_TIMEOUT;
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;
1349 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1350 nl->csr1.rate = flags.rate;
1351 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1352 spin_unlock( &nl->lock );
1355 #ifdef CONFIG_SBNI_MULTILINE
1357 case SIOCDEVENSLAVE :
1358 if (!capable(CAP_NET_ADMIN))
1361 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1363 slave_dev = dev_get_by_name(&init_net, slave_name );
1364 if( !slave_dev || !(slave_dev->flags & IFF_UP) ) {
1365 netdev_err(dev, "trying to enslave non-active device %s\n",
1372 return enslave( dev, slave_dev );
1374 case SIOCDEVEMANSIPATE :
1375 if (!capable(CAP_NET_ADMIN))
1378 return emancipate( dev );
1380 #endif /* CONFIG_SBNI_MULTILINE */
1390 #ifdef CONFIG_SBNI_MULTILINE
1393 enslave( struct net_device *dev, struct net_device *slave_dev )
1395 struct net_local *nl = netdev_priv(dev);
1396 struct net_local *snl = netdev_priv(slave_dev);
1398 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1401 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1404 spin_lock( &nl->lock );
1405 spin_lock( &snl->lock );
1407 /* append to list */
1408 snl->link = nl->link;
1409 nl->link = slave_dev;
1411 snl->state |= FL_SLAVE;
1413 /* Summary statistics of MultiLine operation will be stored
1414 in master's counters */
1415 memset( &slave_dev->stats, 0, sizeof(struct net_device_stats) );
1416 netif_stop_queue( slave_dev );
1417 netif_wake_queue( dev ); /* Now we are able to transmit */
1419 spin_unlock( &snl->lock );
1420 spin_unlock( &nl->lock );
1421 netdev_notice(dev, "slave device (%s) attached\n", slave_dev->name);
1427 emancipate( struct net_device *dev )
1429 struct net_local *snl = netdev_priv(dev);
1430 struct net_device *p = snl->master;
1431 struct net_local *nl = netdev_priv(p);
1433 if( !(snl->state & FL_SLAVE) )
1436 spin_lock( &nl->lock );
1437 spin_lock( &snl->lock );
1438 drop_xmit_queue( dev );
1440 /* exclude from list */
1441 for(;;) { /* must be in list */
1442 struct net_local *t = netdev_priv(p);
1443 if( t->link == dev ) {
1444 t->link = snl->link;
1452 snl->state &= ~FL_SLAVE;
1454 netif_start_queue( dev );
1456 spin_unlock( &snl->lock );
1457 spin_unlock( &nl->lock );
1466 set_multicast_list( struct net_device *dev )
1468 return; /* sbni always operate in promiscuos mode */
1473 module_param_hw_array(io, int, ioport, NULL, 0);
1474 module_param_hw_array(irq, int, irq, NULL, 0);
1475 module_param_array(baud, int, NULL, 0);
1476 module_param_array(rxl, int, NULL, 0);
1477 module_param_array(mac, int, NULL, 0);
1478 module_param(skip_pci_probe, bool, 0);
1480 MODULE_LICENSE("GPL");
1483 int __init init_module( void )
1485 struct net_device *dev;
1488 while( num < SBNI_MAX_NUM_CARDS ) {
1489 dev = alloc_netdev(sizeof(struct net_local), "sbni%d",
1490 NET_NAME_UNKNOWN, sbni_devsetup);
1494 sprintf( dev->name, "sbni%d", num );
1496 err = sbni_init(dev);
1502 if( register_netdev( dev ) ) {
1503 release_region( dev->base_addr, SBNI_IO_EXTENT );
1509 return *sbni_cards ? 0 : -ENODEV;
1513 cleanup_module(void)
1517 for (i = 0; i < SBNI_MAX_NUM_CARDS; ++i) {
1518 struct net_device *dev = sbni_cards[i];
1520 unregister_netdev(dev);
1521 release_region(dev->base_addr, SBNI_IO_EXTENT);
1530 sbni_setup( char *p )
1537 for( n = 0, parm = 0; *p && n < 8; ) {
1538 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1539 if( !*p || *p == ')' )
1545 } else if( *p++ != ',' ) {
1553 pr_err("Error in sbni kernel parameter!\n");
1557 __setup( "sbni=", sbni_setup );
1561 /* -------------------------------------------------------------------------- */
1564 calc_crc32( u32 crc, u8 *p, u32 len )
1567 crc = CRC32( *p++, crc );
1572 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1573 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1574 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1575 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1576 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1577 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1578 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1579 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1580 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1581 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1582 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1583 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1584 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1585 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1586 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1587 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1588 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1589 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1590 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1591 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1592 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1593 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1594 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1595 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1596 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1597 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1598 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1599 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1600 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1601 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1602 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1603 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1604 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1605 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1606 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1607 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1608 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1609 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1610 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1611 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1612 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1613 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1614 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1615 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1616 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1617 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1618 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1619 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1620 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1621 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1622 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1623 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1624 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1625 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1626 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1627 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1628 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1629 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1630 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1631 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1632 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1633 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1634 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1635 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1636 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000