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