Merge git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6
[linux-2.6] / drivers / net / wan / sbni.c
1 /* sbni.c:  Granch SBNI12 leased line adapters driver for linux
2  *
3  *      Written 2001 by Denis I.Timofeev (timofeev@granch.ru)
4  *
5  *      Previous versions were written by Yaroslav Polyakov,
6  *      Alexey Zverev and Max Khon.
7  *
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)
12  *
13  *      This software may be used and distributed according to the terms
14  *      of the GNU General Public License.
15  *
16  *
17  *  5.0.1       Jun 22 2001
18  *        - Fixed bug in probe
19  *  5.0.0       Jun 06 2001
20  *        - Driver was completely redesigned by Denis I.Timofeev,
21  *        - now PCI/Dual, ISA/Dual (with single interrupt line) models are
22  *        - supported
23  *  3.3.0       Thu Feb 24 21:30:28 NOVT 2000 
24  *        - PCI cards support
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,
36  * 
37  *      Known problem: this driver wasn't tested on multiprocessor machine.
38  */
39
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/ptrace.h>
43 #include <linux/fcntl.h>
44 #include <linux/ioport.h>
45 #include <linux/interrupt.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/errno.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/pci.h>
52 #include <linux/skbuff.h>
53 #include <linux/timer.h>
54 #include <linux/init.h>
55 #include <linux/delay.h>
56
57 #include <net/arp.h>
58
59 #include <asm/io.h>
60 #include <asm/types.h>
61 #include <asm/byteorder.h>
62 #include <asm/irq.h>
63 #include <asm/uaccess.h>
64
65 #include "sbni.h"
66
67 /* device private data */
68
69 struct net_local {
70         struct net_device_stats stats;
71         struct timer_list       watchdog;
72
73         spinlock_t      lock;
74         struct sk_buff  *rx_buf_p;              /* receive buffer ptr */
75         struct sk_buff  *tx_buf_p;              /* transmit buffer ptr */
76         
77         unsigned int    framelen;               /* current frame length */
78         unsigned int    maxframe;               /* maximum valid frame length */
79         unsigned int    state;
80         unsigned int    inppos, outpos;         /* positions in rx/tx buffers */
81
82         /* transmitting frame number - from frames qty to 1 */
83         unsigned int    tx_frameno;
84
85         /* expected number of next receiving frame */
86         unsigned int    wait_frameno;
87
88         /* count of failed attempts to frame send - 32 attempts do before
89            error - while receiver tunes on opposite side of wire */
90         unsigned int    trans_errors;
91
92         /* idle time; send pong when limit exceeded */
93         unsigned int    timer_ticks;
94
95         /* fields used for receive level autoselection */
96         int     delta_rxl;
97         unsigned int    cur_rxl_index, timeout_rxl;
98         unsigned long   cur_rxl_rcvd, prev_rxl_rcvd;
99
100         struct sbni_csr1        csr1;           /* current value of CSR1 */
101         struct sbni_in_stats    in_stats;       /* internal statistics */ 
102
103         struct net_device               *second;        /* for ISA/dual cards */
104
105 #ifdef CONFIG_SBNI_MULTILINE
106         struct net_device               *master;
107         struct net_device               *link;
108 #endif
109 };
110
111
112 static int  sbni_card_probe( unsigned long );
113 static int  sbni_pci_probe( struct net_device  * );
114 static struct net_device  *sbni_probe1(struct net_device *, unsigned long, int);
115 static int  sbni_open( struct net_device * );
116 static int  sbni_close( struct net_device * );
117 static int  sbni_start_xmit( struct sk_buff *, struct net_device * );
118 static int  sbni_ioctl( struct net_device *, struct ifreq *, int );
119 static struct net_device_stats  *sbni_get_stats( struct net_device * );
120 static void  set_multicast_list( struct net_device * );
121
122 static irqreturn_t sbni_interrupt( int, void * );
123 static void  handle_channel( struct net_device * );
124 static int   recv_frame( struct net_device * );
125 static void  send_frame( struct net_device * );
126 static int   upload_data( struct net_device *,
127                           unsigned, unsigned, unsigned, u32 );
128 static void  download_data( struct net_device *, u32 * );
129 static void  sbni_watchdog( unsigned long );
130 static void  interpret_ack( struct net_device *, unsigned );
131 static int   append_frame_to_pkt( struct net_device *, unsigned, u32 );
132 static void  indicate_pkt( struct net_device * );
133 static void  card_start( struct net_device * );
134 static void  prepare_to_send( struct sk_buff *, struct net_device * );
135 static void  drop_xmit_queue( struct net_device * );
136 static void  send_frame_header( struct net_device *, u32 * );
137 static int   skip_tail( unsigned int, unsigned int, u32 );
138 static int   check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
139 static void  change_level( struct net_device * );
140 static void  timeout_change_level( struct net_device * );
141 static u32   calc_crc32( u32, u8 *, u32 );
142 static struct sk_buff *  get_rx_buf( struct net_device * );
143 static int  sbni_init( struct net_device * );
144
145 #ifdef CONFIG_SBNI_MULTILINE
146 static int  enslave( struct net_device *, struct net_device * );
147 static int  emancipate( struct net_device * );
148 #endif
149
150 #ifdef __i386__
151 #define ASM_CRC 1
152 #endif
153
154 static const char  version[] =
155         "Granch SBNI12 driver ver 5.0.1  Jun 22 2001  Denis I.Timofeev.\n";
156
157 static int  skip_pci_probe      __initdata = 0;
158 static int  scandone    __initdata = 0;
159 static int  num         __initdata = 0;
160
161 static unsigned char  rxl_tab[];
162 static u32  crc32tab[];
163
164 /* A list of all installed devices, for removing the driver module. */
165 static struct net_device  *sbni_cards[ SBNI_MAX_NUM_CARDS ];
166
167 /* Lists of device's parameters */
168 static u32      io[   SBNI_MAX_NUM_CARDS ] __initdata =
169         { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
170 static u32      irq[  SBNI_MAX_NUM_CARDS ] __initdata;
171 static u32      baud[ SBNI_MAX_NUM_CARDS ] __initdata;
172 static u32      rxl[  SBNI_MAX_NUM_CARDS ] __initdata =
173         { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
174 static u32      mac[  SBNI_MAX_NUM_CARDS ] __initdata;
175
176 #ifndef MODULE
177 typedef u32  iarr[];
178 static iarr __initdata *dest[5] = { &io, &irq, &baud, &rxl, &mac };
179 #endif
180
181 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
182 static unsigned int  netcard_portlist[ ] __initdata = { 
183         0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
184         0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
185         0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
186         0 };
187
188
189 /*
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.
192  */
193
194 static inline int __init
195 sbni_isa_probe( struct net_device  *dev )
196 {
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 ) )
200
201                 return  0;
202         else {
203                 printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
204                         "is malfunctional!\n", dev->base_addr );
205                 return  -ENODEV;
206         }
207 }
208
209 static void __init sbni_devsetup(struct net_device *dev)
210 {
211         ether_setup( dev );
212         dev->open               = &sbni_open;
213         dev->stop               = &sbni_close;
214         dev->hard_start_xmit    = &sbni_start_xmit;
215         dev->get_stats          = &sbni_get_stats;
216         dev->set_multicast_list = &set_multicast_list;
217         dev->do_ioctl           = &sbni_ioctl;
218
219         SET_MODULE_OWNER( dev );
220 }
221
222 int __init sbni_probe(int unit)
223 {
224         struct net_device *dev;
225         static unsigned  version_printed __initdata = 0;
226         int err;
227
228         dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
229         if (!dev)
230                 return -ENOMEM;
231
232         sprintf(dev->name, "sbni%d", unit);
233         netdev_boot_setup_check(dev);
234
235         err = sbni_init(dev);
236         if (err) {
237                 free_netdev(dev);
238                 return err;
239         }
240
241         err = register_netdev(dev);
242         if (err) {
243                 release_region( dev->base_addr, SBNI_IO_EXTENT );
244                 free_netdev(dev);
245                 return err;
246         }
247         if( version_printed++ == 0 )
248                 printk( KERN_INFO "%s", version );
249         return 0;
250 }
251
252 static int __init sbni_init(struct net_device *dev)
253 {
254         int  i;
255         if( dev->base_addr )
256                 return  sbni_isa_probe( dev );
257         /* otherwise we have to perform search our adapter */
258
259         if( io[ num ] != -1 )
260                 dev->base_addr  = io[ num ],
261                 dev->irq        = irq[ num ];
262         else if( scandone  ||  io[ 0 ] != -1 )
263                 return  -ENODEV;
264
265         /* if io[ num ] contains non-zero address, then that is on ISA bus */
266         if( dev->base_addr )
267                 return  sbni_isa_probe( dev );
268
269         /* ...otherwise - scan PCI first */
270         if( !skip_pci_probe  &&  !sbni_pci_probe( dev ) )
271                 return  0;
272
273         if( io[ num ] == -1 ) {
274                 /* Auto-scan will be stopped when first ISA card were found */
275                 scandone = 1;
276                 if( num > 0 )
277                         return  -ENODEV;
278         }
279
280         for( i = 0;  netcard_portlist[ i ];  ++i ) {
281                 int  ioaddr = netcard_portlist[ i ];
282                 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
283                     &&  sbni_probe1( dev, ioaddr, 0 ))
284                         return 0;
285         }
286
287         return  -ENODEV;
288 }
289
290
291 int __init
292 sbni_pci_probe( struct net_device  *dev )
293 {
294         struct pci_dev  *pdev = NULL;
295
296         while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
297                != NULL ) {
298                 int  pci_irq_line;
299                 unsigned long  pci_ioaddr;
300                 u16  subsys;
301
302                 if( pdev->vendor != SBNI_PCI_VENDOR
303                     &&  pdev->device != SBNI_PCI_DEVICE )
304                                 continue;
305
306                 pci_ioaddr = pci_resource_start( pdev, 0 );
307                 pci_irq_line = pdev->irq;
308
309                 /* Avoid already found cards from previous calls */
310                 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
311                         pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
312
313                         if (subsys != 2)
314                                 continue;
315
316                         /* Dual adapter is present */
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                         printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
324                                 "this PCI card to IRQ %d, which is unlikely "
325                                 "to work!.\n"
326                                 KERN_WARNING " You should use the PCI BIOS "
327                                 "setup to assign a valid IRQ line.\n",
328                                 pci_irq_line );
329
330                 /* avoiding re-enable dual adapters */
331                 if( (pci_ioaddr & 7) == 0  &&  pci_enable_device( pdev ) ) {
332                         release_region( pci_ioaddr, SBNI_IO_EXTENT );
333                         pci_dev_put( pdev );
334                         return  -EIO;
335                 }
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... */
340                         pci_dev_put( pdev );
341                         return  0;
342                 }
343         }
344         return  -ENODEV;
345 }
346
347
348 static struct net_device * __init
349 sbni_probe1( struct net_device  *dev,  unsigned long  ioaddr,  int  irq )
350 {
351         struct net_local  *nl;
352
353         if( sbni_card_probe( ioaddr ) ) {
354                 release_region( ioaddr, SBNI_IO_EXTENT );
355                 return NULL;
356         }
357
358         outb( 0, ioaddr + CSR0 );
359
360         if( irq < 2 ) {
361                 unsigned long irq_mask;
362
363                 irq_mask = probe_irq_on();
364                 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
365                 outb( PR_RES, ioaddr + CSR1 );
366                 mdelay(50);
367                 irq = probe_irq_off(irq_mask);
368                 outb( 0, ioaddr + CSR0 );
369
370                 if( !irq ) {
371                         printk( KERN_ERR "%s: can't detect device irq!\n",
372                                 dev->name );
373                         release_region( ioaddr, SBNI_IO_EXTENT );
374                         return NULL;
375                 }
376         } else if( irq == 2 )
377                 irq = 9;
378
379         dev->irq = irq;
380         dev->base_addr = ioaddr;
381
382         /* Allocate dev->priv and fill in sbni-specific dev fields. */
383         nl = dev->priv;
384         if( !nl ) {
385                 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
386                 release_region( ioaddr, SBNI_IO_EXTENT );
387                 return NULL;
388         }
389
390         dev->priv = nl;
391         memset( nl, 0, sizeof(struct net_local) );
392         spin_lock_init( &nl->lock );
393
394         /* store MAC address (generate if that isn't known) */
395         *(u16 *)dev->dev_addr = htons( 0x00ff );
396         *(u32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
397                 ( (mac[num]  ?  mac[num]  :  (u32)((long)dev->priv)) & 0x00ffffff) );
398
399         /* store link settings (speed, receive level ) */
400         nl->maxframe  = DEFAULT_FRAME_LEN;
401         nl->csr1.rate = baud[ num ];
402
403         if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
404                 /* autotune rxl */
405                 nl->cur_rxl_index = DEF_RXL,
406                 nl->delta_rxl = DEF_RXL_DELTA;
407         else
408                 nl->delta_rxl = 0;
409         nl->csr1.rxl  = rxl_tab[ nl->cur_rxl_index ];
410         if( inb( ioaddr + CSR0 ) & 0x01 )
411                 nl->state |= FL_SLOW_MODE;
412
413         printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
414                 "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] );
419
420         printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
421                 ( (nl->state & FL_SLOW_MODE)  ?  500000 : 2000000)
422                 / (1 << nl->csr1.rate) );
423
424         if( nl->delta_rxl == 0 )
425                 printk( "0x%x (fixed)\n", nl->cur_rxl_index ); 
426         else
427                 printk( "(auto)\n");
428
429 #ifdef CONFIG_SBNI_MULTILINE
430         nl->master = dev;
431         nl->link   = NULL;
432 #endif
433    
434         sbni_cards[ num++ ] = dev;
435         return  dev;
436 }
437
438 /* -------------------------------------------------------------------------- */
439
440 #ifdef CONFIG_SBNI_MULTILINE
441
442 static int
443 sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
444 {
445         struct net_device  *p;
446
447         netif_stop_queue( dev );
448
449         /* Looking for idle device in the list */
450         for( p = dev;  p; ) {
451                 struct net_local  *nl = (struct net_local *) p->priv;
452                 spin_lock( &nl->lock );
453                 if( nl->tx_buf_p  ||  (nl->state & FL_LINE_DOWN) ) {
454                         p = nl->link;
455                         spin_unlock( &nl->lock );
456                 } else {
457                         /* Idle dev is found */
458                         prepare_to_send( skb, p );
459                         spin_unlock( &nl->lock );
460                         netif_start_queue( dev );
461                         return  0;
462                 }
463         }
464
465         return  1;
466 }
467
468 #else   /* CONFIG_SBNI_MULTILINE */
469
470 static int
471 sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
472 {
473         struct net_local  *nl  = (struct net_local *) dev->priv;
474
475         netif_stop_queue( dev );
476         spin_lock( &nl->lock );
477
478         prepare_to_send( skb, dev );
479
480         spin_unlock( &nl->lock );
481         return  0;
482 }
483
484 #endif  /* CONFIG_SBNI_MULTILINE */
485
486 /* -------------------------------------------------------------------------- */
487
488 /* interrupt handler */
489
490 /*
491  *      SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
492  * be looked as two independent single-channel devices. Every channel seems
493  * as Ethernet interface but interrupt handler must be common. Really, first
494  * channel ("master") driver only registers the handler. In its struct net_local
495  * it has got pointer to "slave" channel's struct net_local and handles that's
496  * interrupts too.
497  *      dev of successfully attached ISA SBNI boards is linked to list.
498  * While next board driver is initialized, it scans this list. If one
499  * has found dev with same irq and ioaddr different by 4 then it assumes
500  * this board to be "master".
501  */ 
502
503 static irqreturn_t
504 sbni_interrupt( int  irq,  void  *dev_id )
505 {
506         struct net_device         *dev = (struct net_device *) dev_id;
507         struct net_local  *nl  = (struct net_local *) dev->priv;
508         int     repeat;
509
510         spin_lock( &nl->lock );
511         if( nl->second )
512                 spin_lock( &((struct net_local *) nl->second->priv)->lock );
513
514         do {
515                 repeat = 0;
516                 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
517                         handle_channel( dev ),
518                         repeat = 1;
519                 if( nl->second  &&      /* second channel present */
520                     (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
521                         handle_channel( nl->second ),
522                         repeat = 1;
523         } while( repeat );
524
525         if( nl->second )
526                 spin_unlock( &((struct net_local *)nl->second->priv)->lock );
527         spin_unlock( &nl->lock );
528         return IRQ_HANDLED;
529 }
530
531
532 static void
533 handle_channel( struct net_device  *dev )
534 {
535         struct net_local        *nl    = (struct net_local *) dev->priv;
536         unsigned long           ioaddr = dev->base_addr;
537
538         int  req_ans;
539         unsigned char  csr0;
540
541 #ifdef CONFIG_SBNI_MULTILINE
542         /* Lock the master device because we going to change its local data */
543         if( nl->state & FL_SLAVE )
544                 spin_lock( &((struct net_local *) nl->master->priv)->lock );
545 #endif
546
547         outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
548
549         nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
550         for(;;) {
551                 csr0 = inb( ioaddr + CSR0 );
552                 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
553                         break;
554
555                 req_ans = !(nl->state & FL_PREV_OK);
556
557                 if( csr0 & RC_RDY )
558                         req_ans = recv_frame( dev );
559
560                 /*
561                  * TR_RDY always equals 1 here because we have owned the marker,
562                  * and we set TR_REQ when disabled interrupts
563                  */
564                 csr0 = inb( ioaddr + CSR0 );
565                 if( !(csr0 & TR_RDY)  ||  (csr0 & RC_RDY) )
566                         printk( KERN_ERR "%s: internal error!\n", dev->name );
567
568                 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
569                 if( req_ans  ||  nl->tx_frameno != 0 )
570                         send_frame( dev );
571                 else
572                         /* send marker without any data */
573                         outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
574         }
575
576         outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
577
578 #ifdef CONFIG_SBNI_MULTILINE
579         if( nl->state & FL_SLAVE )
580                 spin_unlock( &((struct net_local *) nl->master->priv)->lock );
581 #endif
582 }
583
584
585 /*
586  * Routine returns 1 if it need to acknoweledge received frame.
587  * Empty frame received without errors won't be acknoweledged.
588  */
589
590 static int
591 recv_frame( struct net_device  *dev )
592 {
593         struct net_local  *nl   = (struct net_local *) dev->priv;
594         unsigned long  ioaddr   = dev->base_addr;
595
596         u32  crc = CRC32_INITIAL;
597
598         unsigned  framelen, frameno, ack;
599         unsigned  is_first, frame_ok;
600
601         if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
602                 frame_ok = framelen > 4
603                         ?  upload_data( dev, framelen, frameno, is_first, crc )
604                         :  skip_tail( ioaddr, framelen, crc );
605                 if( frame_ok )
606                         interpret_ack( dev, ack );
607         } else
608                 frame_ok = 0;
609
610         outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
611         if( frame_ok ) {
612                 nl->state |= FL_PREV_OK;
613                 if( framelen > 4 )
614                         nl->in_stats.all_rx_number++;
615         } else
616                 nl->state &= ~FL_PREV_OK,
617                 change_level( dev ),
618                 nl->in_stats.all_rx_number++,
619                 nl->in_stats.bad_rx_number++;
620
621         return  !frame_ok  ||  framelen > 4;
622 }
623
624
625 static void
626 send_frame( struct net_device  *dev )
627 {
628         struct net_local  *nl    = (struct net_local *) dev->priv;
629
630         u32  crc = CRC32_INITIAL;
631
632         if( nl->state & FL_NEED_RESEND ) {
633
634                 /* if frame was sended but not ACK'ed - resend it */
635                 if( nl->trans_errors ) {
636                         --nl->trans_errors;
637                         if( nl->framelen != 0 )
638                                 nl->in_stats.resend_tx_number++;
639                 } else {
640                         /* cannot xmit with many attempts */
641 #ifdef CONFIG_SBNI_MULTILINE
642                         if( (nl->state & FL_SLAVE)  ||  nl->link )
643 #endif
644                         nl->state |= FL_LINE_DOWN;
645                         drop_xmit_queue( dev );
646                         goto  do_send;
647                 }
648         } else
649                 nl->trans_errors = TR_ERROR_COUNT;
650
651         send_frame_header( dev, &crc );
652         nl->state |= FL_NEED_RESEND;
653         /*
654          * FL_NEED_RESEND will be cleared after ACK, but if empty
655          * frame sended then in prepare_to_send next frame
656          */
657
658
659         if( nl->framelen ) {
660                 download_data( dev, &crc );
661                 nl->in_stats.all_tx_number++;
662                 nl->state |= FL_WAIT_ACK;
663         }
664
665         outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
666
667 do_send:
668         outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
669
670         if( nl->tx_frameno )
671                 /* next frame exists - we request card to send it */
672                 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
673                       dev->base_addr + CSR0 );
674 }
675
676
677 /*
678  * Write the frame data into adapter's buffer memory, and calculate CRC.
679  * Do padding if necessary.
680  */
681
682 static void
683 download_data( struct net_device  *dev,  u32  *crc_p )
684 {
685         struct net_local  *nl    = (struct net_local *) dev->priv;
686         struct sk_buff    *skb   = nl->tx_buf_p;
687
688         unsigned  len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
689
690         outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
691         *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
692
693         /* if packet too short we should write some more bytes to pad */
694         for( len = nl->framelen - len;  len--; )
695                 outb( 0, dev->base_addr + DAT ),
696                 *crc_p = CRC32( 0, *crc_p );
697 }
698
699
700 static int
701 upload_data( struct net_device  *dev,  unsigned  framelen,  unsigned  frameno,
702              unsigned  is_first,  u32  crc )
703 {
704         struct net_local  *nl = (struct net_local *) dev->priv;
705
706         int  frame_ok;
707
708         if( is_first )
709                 nl->wait_frameno = frameno,
710                 nl->inppos = 0;
711
712         if( nl->wait_frameno == frameno ) {
713
714                 if( nl->inppos + framelen  <=  ETHER_MAX_LEN )
715                         frame_ok = append_frame_to_pkt( dev, framelen, crc );
716
717                 /*
718                  * if CRC is right but framelen incorrect then transmitter
719                  * error was occurred... drop entire packet
720                  */
721                 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
722                          != 0 )
723                         nl->wait_frameno = 0,
724                         nl->inppos = 0,
725 #ifdef CONFIG_SBNI_MULTILINE
726                         ((struct net_local *) nl->master->priv)
727                                 ->stats.rx_errors++,
728                         ((struct net_local *) nl->master->priv)
729                                 ->stats.rx_missed_errors++;
730 #else
731                         nl->stats.rx_errors++,
732                         nl->stats.rx_missed_errors++;
733 #endif
734                         /* now skip all frames until is_first != 0 */
735         } else
736                 frame_ok = skip_tail( dev->base_addr, framelen, crc );
737
738         if( is_first  &&  !frame_ok )
739                 /*
740                  * Frame has been broken, but we had already stored
741                  * is_first... Drop entire packet.
742                  */
743                 nl->wait_frameno = 0,
744 #ifdef CONFIG_SBNI_MULTILINE
745                 ((struct net_local *) nl->master->priv)->stats.rx_errors++,
746                 ((struct net_local *) nl->master->priv)->stats.rx_crc_errors++;
747 #else
748                 nl->stats.rx_errors++,
749                 nl->stats.rx_crc_errors++;
750 #endif
751
752         return  frame_ok;
753 }
754
755
756 static __inline void
757 send_complete( struct net_local  *nl )
758 {
759 #ifdef CONFIG_SBNI_MULTILINE
760         ((struct net_local *) nl->master->priv)->stats.tx_packets++;
761         ((struct net_local *) nl->master->priv)->stats.tx_bytes
762                 += nl->tx_buf_p->len;
763 #else
764         nl->stats.tx_packets++;
765         nl->stats.tx_bytes += nl->tx_buf_p->len;
766 #endif
767         dev_kfree_skb_irq( nl->tx_buf_p );
768
769         nl->tx_buf_p = NULL;
770
771         nl->outpos = 0;
772         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
773         nl->framelen   = 0;
774 }
775
776
777 static void
778 interpret_ack( struct net_device  *dev,  unsigned  ack )
779 {
780         struct net_local  *nl = (struct net_local *) dev->priv;
781
782         if( ack == FRAME_SENT_OK ) {
783                 nl->state &= ~FL_NEED_RESEND;
784
785                 if( nl->state & FL_WAIT_ACK ) {
786                         nl->outpos += nl->framelen;
787
788                         if( --nl->tx_frameno )
789                                 nl->framelen = min_t(unsigned int,
790                                                    nl->maxframe,
791                                                    nl->tx_buf_p->len - nl->outpos);
792                         else
793                                 send_complete( nl ),
794 #ifdef CONFIG_SBNI_MULTILINE
795                                 netif_wake_queue( nl->master );
796 #else
797                                 netif_wake_queue( dev );
798 #endif
799                 }
800         }
801
802         nl->state &= ~FL_WAIT_ACK;
803 }
804
805
806 /*
807  * Glue received frame with previous fragments of packet.
808  * Indicate packet when last frame would be accepted.
809  */
810
811 static int
812 append_frame_to_pkt( struct net_device  *dev,  unsigned  framelen,  u32  crc )
813 {
814         struct net_local  *nl = (struct net_local *) dev->priv;
815
816         u8  *p;
817
818         if( nl->inppos + framelen  >  ETHER_MAX_LEN )
819                 return  0;
820
821         if( !nl->rx_buf_p  &&  !(nl->rx_buf_p = get_rx_buf( dev )) )
822                 return  0;
823
824         p = nl->rx_buf_p->data + nl->inppos;
825         insb( dev->base_addr + DAT, p, framelen );
826         if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
827                 return  0;
828
829         nl->inppos += framelen - 4;
830         if( --nl->wait_frameno == 0 )           /* last frame received */
831                 indicate_pkt( dev );
832
833         return  1;
834 }
835
836
837 /*
838  * Prepare to start output on adapter.
839  * Transmitter will be actually activated when marker is accepted.
840  */
841
842 static void
843 prepare_to_send( struct sk_buff  *skb,  struct net_device  *dev )
844 {
845         struct net_local  *nl = (struct net_local *) dev->priv;
846
847         unsigned int  len;
848
849         /* nl->tx_buf_p == NULL here! */
850         if( nl->tx_buf_p )
851                 printk( KERN_ERR "%s: memory leak!\n", dev->name );
852
853         nl->outpos = 0;
854         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
855
856         len = skb->len;
857         if( len < SBNI_MIN_LEN )
858                 len = SBNI_MIN_LEN;
859
860         nl->tx_buf_p    = skb;
861         nl->tx_frameno  = (len + nl->maxframe - 1) / nl->maxframe;
862         nl->framelen    = len < nl->maxframe  ?  len  :  nl->maxframe;
863
864         outb( inb( dev->base_addr + CSR0 ) | TR_REQ,  dev->base_addr + CSR0 );
865 #ifdef CONFIG_SBNI_MULTILINE
866         nl->master->trans_start = jiffies;
867 #else
868         dev->trans_start = jiffies;
869 #endif
870 }
871
872
873 static void
874 drop_xmit_queue( struct net_device  *dev )
875 {
876         struct net_local  *nl = (struct net_local *) dev->priv;
877
878         if( nl->tx_buf_p )
879                 dev_kfree_skb_any( nl->tx_buf_p ),
880                 nl->tx_buf_p = NULL,
881 #ifdef CONFIG_SBNI_MULTILINE
882                 ((struct net_local *) nl->master->priv)
883                         ->stats.tx_errors++,
884                 ((struct net_local *) nl->master->priv)
885                         ->stats.tx_carrier_errors++;
886 #else
887                 nl->stats.tx_errors++,
888                 nl->stats.tx_carrier_errors++;
889 #endif
890
891         nl->tx_frameno  = 0;
892         nl->framelen    = 0;
893         nl->outpos      = 0;
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;
898 #else
899         netif_start_queue( dev );
900         dev->trans_start = jiffies;
901 #endif
902 }
903
904
905 static void
906 send_frame_header( struct net_device  *dev,  u32  *crc_p )
907 {
908         struct net_local  *nl  = (struct net_local *) dev->priv;
909
910         u32  crc = *crc_p;
911         u32  len_field = nl->framelen + 6;      /* CRC + frameno + reserved */
912         u8   value;
913
914         if( nl->state & FL_NEED_RESEND )
915                 len_field |= FRAME_RETRY;       /* non-first attempt... */
916
917         if( nl->outpos == 0 )
918                 len_field |= FRAME_FIRST;
919
920         len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
921         outb( SBNI_SIG, dev->base_addr + DAT );
922
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 );
929
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 );
934         *crc_p = crc;
935 }
936
937
938 /*
939  * if frame tail not needed (incorrect number or received twice),
940  * it won't store, but CRC will be calculated
941  */
942
943 static int
944 skip_tail( unsigned int  ioaddr,  unsigned int  tail_len,  u32 crc )
945 {
946         while( tail_len-- )
947                 crc = CRC32( inb( ioaddr + DAT ), crc );
948
949         return  crc == CRC32_REMAINDER;
950 }
951
952
953 /*
954  * Preliminary checks if frame header is correct, calculates its CRC
955  * and split it to simple fields
956  */
957
958 static int
959 check_fhdr( u32  ioaddr,  u32  *framelen,  u32  *frameno,  u32  *ack,
960             u32  *is_first,  u32  *crc_p )
961 {
962         u32  crc = *crc_p;
963         u8   value;
964
965         if( inb( ioaddr + DAT ) != SBNI_SIG )
966                 return  0;
967
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 );
974
975         *ack = *framelen & FRAME_ACK_MASK;
976         *is_first = (*framelen & FRAME_FIRST) != 0;
977
978         if( (*framelen &= FRAME_LEN_MASK) < 6
979             ||  *framelen > SBNI_MAX_FRAME - 3 )
980                 return  0;
981
982         value = inb( ioaddr + DAT );
983         *frameno = (u32)value;
984         crc = CRC32( value, crc );
985
986         crc = CRC32( inb( ioaddr + DAT ), crc );        /* reserved byte */
987         *framelen -= 2;
988
989         *crc_p = crc;
990         return  1;
991 }
992
993
994 static struct sk_buff *
995 get_rx_buf( struct net_device  *dev )
996 {
997         /* +2 is to compensate for the alignment fixup below */
998         struct sk_buff  *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
999         if( !skb )
1000                 return  NULL;
1001
1002         skb_reserve( skb, 2 );          /* Align IP on longword boundaries */
1003         return  skb;
1004 }
1005
1006
1007 static void
1008 indicate_pkt( struct net_device  *dev )
1009 {
1010         struct net_local  *nl  = (struct net_local *) dev->priv;
1011         struct sk_buff    *skb = nl->rx_buf_p;
1012
1013         skb_put( skb, nl->inppos );
1014
1015 #ifdef CONFIG_SBNI_MULTILINE
1016         skb->protocol = eth_type_trans( skb, nl->master );
1017         netif_rx( skb );
1018         dev->last_rx = jiffies;
1019         ++((struct net_local *) nl->master->priv)->stats.rx_packets;
1020         ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
1021 #else
1022         skb->protocol = eth_type_trans( skb, dev );
1023         netif_rx( skb );
1024         dev->last_rx = jiffies;
1025         ++nl->stats.rx_packets;
1026         nl->stats.rx_bytes += nl->inppos;
1027 #endif
1028         nl->rx_buf_p = NULL;    /* protocol driver will clear this sk_buff */
1029 }
1030
1031
1032 /* -------------------------------------------------------------------------- */
1033
1034 /*
1035  * Routine checks periodically wire activity and regenerates marker if
1036  * connect was inactive for a long time.
1037  */
1038
1039 static void
1040 sbni_watchdog( unsigned long  arg )
1041 {
1042         struct net_device  *dev = (struct net_device *) arg;
1043         struct net_local   *nl  = (struct net_local *) dev->priv;
1044         struct timer_list  *w   = &nl->watchdog; 
1045         unsigned long      flags;
1046         unsigned char      csr0;
1047
1048         spin_lock_irqsave( &nl->lock, flags );
1049
1050         csr0 = inb( dev->base_addr + CSR0 );
1051         if( csr0 & RC_CHK ) {
1052
1053                 if( nl->timer_ticks ) {
1054                         if( csr0 & (RC_RDY | BU_EMP) )
1055                                 /* receiving not active */
1056                                 nl->timer_ticks--;
1057                 } else {
1058                         nl->in_stats.timeout_number++;
1059                         if( nl->delta_rxl )
1060                                 timeout_change_level( dev );
1061
1062                         outb( *(u_char *)&nl->csr1 | PR_RES,
1063                               dev->base_addr + CSR1 );
1064                         csr0 = inb( dev->base_addr + CSR0 );
1065                 }
1066         } else
1067                 nl->state &= ~FL_LINE_DOWN;
1068
1069         outb( csr0 | RC_CHK, dev->base_addr + CSR0 ); 
1070
1071         init_timer( w );
1072         w->expires      = jiffies + SBNI_TIMEOUT;
1073         w->data         = arg;
1074         w->function     = sbni_watchdog;
1075         add_timer( w );
1076
1077         spin_unlock_irqrestore( &nl->lock, flags );
1078 }
1079
1080
1081 static unsigned char  rxl_tab[] = {
1082         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1083         0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1084 };
1085
1086 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1087 static unsigned char  timeout_rxl_tab[] = {
1088         0x03, 0x05, 0x08, 0x0b
1089 };
1090
1091 /* -------------------------------------------------------------------------- */
1092
1093 static void
1094 card_start( struct net_device  *dev )
1095 {
1096         struct net_local  *nl = (struct net_local *) dev->priv;
1097
1098         nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1099         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1100         nl->state |= FL_PREV_OK;
1101
1102         nl->inppos = nl->outpos = 0;
1103         nl->wait_frameno = 0;
1104         nl->tx_frameno   = 0;
1105         nl->framelen     = 0;
1106
1107         outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1108         outb( EN_INT, dev->base_addr + CSR0 );
1109 }
1110
1111 /* -------------------------------------------------------------------------- */
1112
1113 /* Receive level auto-selection */
1114
1115 static void
1116 change_level( struct net_device  *dev )
1117 {
1118         struct net_local  *nl = (struct net_local *) dev->priv;
1119
1120         if( nl->delta_rxl == 0 )        /* do not auto-negotiate RxL */
1121                 return;
1122
1123         if( nl->cur_rxl_index == 0 )
1124                 nl->delta_rxl = 1;
1125         else if( nl->cur_rxl_index == 15 )
1126                 nl->delta_rxl = -1;
1127         else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1128                 nl->delta_rxl = -nl->delta_rxl;
1129
1130         nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1131         inb( dev->base_addr + CSR0 );   /* needs for PCI cards */
1132         outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1133
1134         nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1135         nl->cur_rxl_rcvd  = 0;
1136 }
1137
1138
1139 static void
1140 timeout_change_level( struct net_device  *dev )
1141 {
1142         struct net_local  *nl = (struct net_local *) dev->priv;
1143
1144         nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1145         if( ++nl->timeout_rxl >= 4 )
1146                 nl->timeout_rxl = 0;
1147
1148         nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1149         inb( dev->base_addr + CSR0 );
1150         outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1151
1152         nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1153         nl->cur_rxl_rcvd  = 0;
1154 }
1155
1156 /* -------------------------------------------------------------------------- */
1157
1158 /*
1159  *      Open/initialize the board. 
1160  */
1161
1162 static int
1163 sbni_open( struct net_device  *dev )
1164 {
1165         struct net_local        *nl = (struct net_local *) dev->priv;
1166         struct timer_list       *w  = &nl->watchdog;
1167
1168         /*
1169          * For double ISA adapters within "common irq" mode, we have to
1170          * determine whether primary or secondary channel is initialized,
1171          * and set the irq handler only in first case.
1172          */
1173         if( dev->base_addr < 0x400 ) {          /* ISA only */
1174                 struct net_device  **p = sbni_cards;
1175                 for( ;  *p  &&  p < sbni_cards + SBNI_MAX_NUM_CARDS;  ++p )
1176                         if( (*p)->irq == dev->irq
1177                             &&  ((*p)->base_addr == dev->base_addr + 4
1178                                  ||  (*p)->base_addr == dev->base_addr - 4)
1179                             &&  (*p)->flags & IFF_UP ) {
1180
1181                                 ((struct net_local *) ((*p)->priv))
1182                                         ->second = dev;
1183                                 printk( KERN_NOTICE "%s: using shared irq "
1184                                         "with %s\n", dev->name, (*p)->name );
1185                                 nl->state |= FL_SECONDARY;
1186                                 goto  handler_attached;
1187                         }
1188         }
1189
1190         if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1191                 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1192                         dev->name, dev->irq );
1193                 return  -EAGAIN;
1194         }
1195
1196 handler_attached:
1197
1198         spin_lock( &nl->lock );
1199         memset( &nl->stats, 0, sizeof(struct net_device_stats) );
1200         memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1201
1202         card_start( dev );
1203
1204         netif_start_queue( dev );
1205
1206         /* set timer watchdog */
1207         init_timer( w );
1208         w->expires      = jiffies + SBNI_TIMEOUT;
1209         w->data         = (unsigned long) dev;
1210         w->function     = sbni_watchdog;
1211         add_timer( w );
1212    
1213         spin_unlock( &nl->lock );
1214         return 0;
1215 }
1216
1217
1218 static int
1219 sbni_close( struct net_device  *dev )
1220 {
1221         struct net_local  *nl = (struct net_local *) dev->priv;
1222
1223         if( nl->second  &&  nl->second->flags & IFF_UP ) {
1224                 printk( KERN_NOTICE "Secondary channel (%s) is active!\n",
1225                         nl->second->name );
1226                 return  -EBUSY;
1227         }
1228
1229 #ifdef CONFIG_SBNI_MULTILINE
1230         if( nl->state & FL_SLAVE )
1231                 emancipate( dev );
1232         else
1233                 while( nl->link )       /* it's master device! */
1234                         emancipate( nl->link );
1235 #endif
1236
1237         spin_lock( &nl->lock );
1238
1239         nl->second = NULL;
1240         drop_xmit_queue( dev ); 
1241         netif_stop_queue( dev );
1242    
1243         del_timer( &nl->watchdog );
1244
1245         outb( 0, dev->base_addr + CSR0 );
1246
1247         if( !(nl->state & FL_SECONDARY) )
1248                 free_irq( dev->irq, dev );
1249         nl->state &= FL_SECONDARY;
1250
1251         spin_unlock( &nl->lock );
1252         return 0;
1253 }
1254
1255
1256 /*
1257         Valid combinations in CSR0 (for probing):
1258
1259         VALID_DECODER   0000,0011,1011,1010
1260
1261                                         ; 0   ; -
1262                                 TR_REQ  ; 1   ; +
1263                         TR_RDY          ; 2   ; -
1264                         TR_RDY  TR_REQ  ; 3   ; +
1265                 BU_EMP                  ; 4   ; +
1266                 BU_EMP          TR_REQ  ; 5   ; +
1267                 BU_EMP  TR_RDY          ; 6   ; -
1268                 BU_EMP  TR_RDY  TR_REQ  ; 7   ; +
1269         RC_RDY                          ; 8   ; +
1270         RC_RDY                  TR_REQ  ; 9   ; +
1271         RC_RDY          TR_RDY          ; 10  ; -
1272         RC_RDY          TR_RDY  TR_REQ  ; 11  ; -
1273         RC_RDY  BU_EMP                  ; 12  ; -
1274         RC_RDY  BU_EMP          TR_REQ  ; 13  ; -
1275         RC_RDY  BU_EMP  TR_RDY          ; 14  ; -
1276         RC_RDY  BU_EMP  TR_RDY  TR_REQ  ; 15  ; -
1277 */
1278
1279 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1280
1281
1282 static int
1283 sbni_card_probe( unsigned long  ioaddr )
1284 {
1285         unsigned char  csr0;
1286
1287         csr0 = inb( ioaddr + CSR0 );
1288         if( csr0 != 0xff  &&  csr0 != 0x00 ) {
1289                 csr0 &= ~EN_INT;
1290                 if( csr0 & BU_EMP )
1291                         csr0 |= EN_INT;
1292       
1293                 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1294                         return  0;
1295         }
1296    
1297         return  -ENODEV;
1298 }
1299
1300 /* -------------------------------------------------------------------------- */
1301
1302 static int
1303 sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
1304 {
1305         struct net_local  *nl = (struct net_local *) dev->priv; 
1306         struct sbni_flags  flags;
1307         int  error = 0;
1308
1309 #ifdef CONFIG_SBNI_MULTILINE
1310         struct net_device  *slave_dev;
1311         char  slave_name[ 8 ];
1312 #endif
1313   
1314         switch( cmd ) {
1315         case  SIOCDEVGETINSTATS :
1316                 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1317                                         sizeof(struct sbni_in_stats) ))
1318                         error = -EFAULT;
1319                 break;
1320
1321         case  SIOCDEVRESINSTATS :
1322                 if( current->euid != 0 )        /* root only */
1323                         return  -EPERM;
1324                 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1325                 break;
1326
1327         case  SIOCDEVGHWSTATE :
1328                 flags.mac_addr  = *(u32 *)(dev->dev_addr + 3);
1329                 flags.rate      = nl->csr1.rate;
1330                 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1331                 flags.rxl       = nl->cur_rxl_index;
1332                 flags.fixed_rxl = nl->delta_rxl == 0;
1333
1334                 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1335                         error = -EFAULT;
1336                 break;
1337
1338         case  SIOCDEVSHWSTATE :
1339                 if( current->euid != 0 )        /* root only */
1340                         return  -EPERM;
1341
1342                 spin_lock( &nl->lock );
1343                 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1344                 if( flags.fixed_rxl )
1345                         nl->delta_rxl = 0,
1346                         nl->cur_rxl_index = flags.rxl;
1347                 else
1348                         nl->delta_rxl = DEF_RXL_DELTA,
1349                         nl->cur_rxl_index = DEF_RXL;
1350
1351                 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1352                 nl->csr1.rate = flags.rate;
1353                 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1354                 spin_unlock( &nl->lock );
1355                 break;
1356
1357 #ifdef CONFIG_SBNI_MULTILINE
1358
1359         case  SIOCDEVENSLAVE :
1360                 if( current->euid != 0 )        /* root only */
1361                         return  -EPERM;
1362
1363                 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1364                         return -EFAULT;
1365                 slave_dev = dev_get_by_name( slave_name );
1366                 if( !slave_dev  ||  !(slave_dev->flags & IFF_UP) ) {
1367                         printk( KERN_ERR "%s: trying to enslave non-active "
1368                                 "device %s\n", dev->name, slave_name );
1369                         return  -EPERM;
1370                 }
1371
1372                 return  enslave( dev, slave_dev );
1373
1374         case  SIOCDEVEMANSIPATE :
1375                 if( current->euid != 0 )        /* root only */
1376                         return  -EPERM;
1377
1378                 return  emancipate( dev );
1379
1380 #endif  /* CONFIG_SBNI_MULTILINE */
1381
1382         default :
1383                 return  -EOPNOTSUPP;
1384         }
1385
1386         return  error;
1387 }
1388
1389
1390 #ifdef CONFIG_SBNI_MULTILINE
1391
1392 static int
1393 enslave( struct net_device  *dev,  struct net_device  *slave_dev )
1394 {
1395         struct net_local  *nl  = (struct net_local *) dev->priv;
1396         struct net_local  *snl = (struct net_local *) slave_dev->priv;
1397
1398         if( nl->state & FL_SLAVE )      /* This isn't master or free device */
1399                 return  -EBUSY;
1400
1401         if( snl->state & FL_SLAVE )     /* That was already enslaved */
1402                 return  -EBUSY;
1403
1404         spin_lock( &nl->lock );
1405         spin_lock( &snl->lock );
1406
1407         /* append to list */
1408         snl->link = nl->link;
1409         nl->link  = slave_dev;
1410         snl->master = dev;
1411         snl->state |= FL_SLAVE;
1412
1413         /* Summary statistics of MultiLine operation will be stored
1414            in master's counters */
1415         memset( &snl->stats, 0, sizeof(struct net_device_stats) );
1416         netif_stop_queue( slave_dev );
1417         netif_wake_queue( dev );        /* Now we are able to transmit */
1418
1419         spin_unlock( &snl->lock );
1420         spin_unlock( &nl->lock );
1421         printk( KERN_NOTICE "%s: slave device (%s) attached.\n",
1422                 dev->name, slave_dev->name );
1423         return  0;
1424 }
1425
1426
1427 static int
1428 emancipate( struct net_device  *dev )
1429 {
1430         struct net_local   *snl = (struct net_local *) dev->priv;
1431         struct net_device  *p   = snl->master;
1432         struct net_local   *nl  = (struct net_local *) p->priv;
1433
1434         if( !(snl->state & FL_SLAVE) )
1435                 return  -EINVAL;
1436
1437         spin_lock( &nl->lock );
1438         spin_lock( &snl->lock );
1439         drop_xmit_queue( dev );
1440
1441         /* exclude from list */
1442         for(;;) {       /* must be in list */
1443                 struct net_local  *t = (struct net_local *) p->priv;
1444                 if( t->link == dev ) {
1445                         t->link = snl->link;
1446                         break;
1447                 }
1448                 p = t->link;
1449         }
1450
1451         snl->link = NULL;
1452         snl->master = dev;
1453         snl->state &= ~FL_SLAVE;
1454
1455         netif_start_queue( dev );
1456
1457         spin_unlock( &snl->lock );
1458         spin_unlock( &nl->lock );
1459
1460         dev_put( dev );
1461         return  0;
1462 }
1463
1464 #endif
1465
1466
1467 static struct net_device_stats *
1468 sbni_get_stats( struct net_device  *dev )
1469 {
1470         return  &((struct net_local *) dev->priv)->stats;
1471 }
1472
1473
1474 static void
1475 set_multicast_list( struct net_device  *dev )
1476 {
1477         return;         /* sbni always operate in promiscuos mode */
1478 }
1479
1480
1481 #ifdef MODULE
1482 module_param_array(io, int, NULL, 0);
1483 module_param_array(irq, int, NULL, 0);
1484 module_param_array(baud, int, NULL, 0);
1485 module_param_array(rxl, int, NULL, 0);
1486 module_param_array(mac, int, NULL, 0);
1487 module_param(skip_pci_probe, bool, 0);
1488
1489 MODULE_LICENSE("GPL");
1490
1491
1492 int __init init_module( void )
1493 {
1494         struct net_device  *dev;
1495         int err;
1496
1497         while( num < SBNI_MAX_NUM_CARDS ) {
1498                 dev = alloc_netdev(sizeof(struct net_local), 
1499                                    "sbni%d", sbni_devsetup);
1500                 if( !dev)
1501                         break;
1502
1503                 sprintf( dev->name, "sbni%d", num );
1504
1505                 err = sbni_init(dev);
1506                 if (err) {
1507                         free_netdev(dev);
1508                         break;
1509                 }
1510
1511                 if( register_netdev( dev ) ) {
1512                         release_region( dev->base_addr, SBNI_IO_EXTENT );
1513                         free_netdev( dev );
1514                         break;
1515                 }
1516         }
1517
1518         return  *sbni_cards  ?  0  :  -ENODEV;
1519 }
1520
1521 void
1522 cleanup_module( void )
1523 {
1524         struct net_device  *dev;
1525         int  num;
1526
1527         for( num = 0;  num < SBNI_MAX_NUM_CARDS;  ++num )
1528                 if( (dev = sbni_cards[ num ]) != NULL ) {
1529                         unregister_netdev( dev );
1530                         release_region( dev->base_addr, SBNI_IO_EXTENT );
1531                         free_netdev( dev );
1532                 }
1533 }
1534
1535 #else   /* MODULE */
1536
1537 static int __init
1538 sbni_setup( char  *p )
1539 {
1540         int  n, parm;
1541
1542         if( *p++ != '(' )
1543                 goto  bad_param;
1544
1545         for( n = 0, parm = 0;  *p  &&  n < 8; ) {
1546                 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1547                 if( !*p  ||  *p == ')' )
1548                         return 1;
1549                 if( *p == ';' )
1550                         ++p, ++n, parm = 0;
1551                 else if( *p++ != ',' )
1552                         break;
1553                 else
1554                         if( ++parm >= 5 )
1555                                 break;
1556         }
1557 bad_param:
1558         printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1559         return 0;
1560 }
1561
1562 __setup( "sbni=", sbni_setup );
1563
1564 #endif  /* MODULE */
1565
1566 /* -------------------------------------------------------------------------- */
1567
1568 #ifdef ASM_CRC
1569
1570 static u32
1571 calc_crc32( u32  crc,  u8  *p,  u32  len )
1572 {
1573         register u32  _crc;
1574         _crc = crc;
1575         
1576         __asm__ __volatile__ (
1577                 "xorl   %%ebx, %%ebx\n"
1578                 "movl   %2, %%esi\n" 
1579                 "movl   %3, %%ecx\n" 
1580                 "movl   $crc32tab, %%edi\n"
1581                 "shrl   $2, %%ecx\n"
1582                 "jz     1f\n"
1583
1584                 ".align 4\n"
1585         "0:\n"
1586                 "movb   %%al, %%bl\n"
1587                 "movl   (%%esi), %%edx\n"
1588                 "shrl   $8, %%eax\n"
1589                 "xorb   %%dl, %%bl\n"
1590                 "shrl   $8, %%edx\n"
1591                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1592
1593                 "movb   %%al, %%bl\n"
1594                 "shrl   $8, %%eax\n"
1595                 "xorb   %%dl, %%bl\n"
1596                 "shrl   $8, %%edx\n"
1597                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1598
1599                 "movb   %%al, %%bl\n"
1600                 "shrl   $8, %%eax\n"
1601                 "xorb   %%dl, %%bl\n"
1602                 "movb   %%dh, %%dl\n" 
1603                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1604
1605                 "movb   %%al, %%bl\n"
1606                 "shrl   $8, %%eax\n"
1607                 "xorb   %%dl, %%bl\n"
1608                 "addl   $4, %%esi\n"
1609                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1610
1611                 "decl   %%ecx\n"
1612                 "jnz    0b\n"
1613
1614         "1:\n"
1615                 "movl   %3, %%ecx\n"
1616                 "andl   $3, %%ecx\n"
1617                 "jz     2f\n"
1618
1619                 "movb   %%al, %%bl\n"
1620                 "shrl   $8, %%eax\n"
1621                 "xorb   (%%esi), %%bl\n"
1622                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1623
1624                 "decl   %%ecx\n"
1625                 "jz     2f\n"
1626
1627                 "movb   %%al, %%bl\n"
1628                 "shrl   $8, %%eax\n"
1629                 "xorb   1(%%esi), %%bl\n"
1630                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1631
1632                 "decl   %%ecx\n"
1633                 "jz     2f\n"
1634
1635                 "movb   %%al, %%bl\n"
1636                 "shrl   $8, %%eax\n"
1637                 "xorb   2(%%esi), %%bl\n"
1638                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1639         "2:\n"
1640                 : "=a" (_crc)
1641                 : "0" (_crc), "g" (p), "g" (len)
1642                 : "bx", "cx", "dx", "si", "di"
1643         );
1644
1645         return  _crc;
1646 }
1647
1648 #else   /* ASM_CRC */
1649
1650 static u32
1651 calc_crc32( u32  crc,  u8  *p,  u32  len )
1652 {
1653         while( len-- )
1654                 crc = CRC32( *p++, crc );
1655
1656         return  crc;
1657 }
1658
1659 #endif  /* ASM_CRC */
1660
1661
1662 static u32  crc32tab[] __attribute__ ((aligned(8))) = {
1663         0xD202EF8D,  0xA505DF1B,  0x3C0C8EA1,  0x4B0BBE37,
1664         0xD56F2B94,  0xA2681B02,  0x3B614AB8,  0x4C667A2E,
1665         0xDCD967BF,  0xABDE5729,  0x32D70693,  0x45D03605,
1666         0xDBB4A3A6,  0xACB39330,  0x35BAC28A,  0x42BDF21C,
1667         0xCFB5FFE9,  0xB8B2CF7F,  0x21BB9EC5,  0x56BCAE53,
1668         0xC8D83BF0,  0xBFDF0B66,  0x26D65ADC,  0x51D16A4A,
1669         0xC16E77DB,  0xB669474D,  0x2F6016F7,  0x58672661,
1670         0xC603B3C2,  0xB1048354,  0x280DD2EE,  0x5F0AE278,
1671         0xE96CCF45,  0x9E6BFFD3,  0x0762AE69,  0x70659EFF,
1672         0xEE010B5C,  0x99063BCA,  0x000F6A70,  0x77085AE6,
1673         0xE7B74777,  0x90B077E1,  0x09B9265B,  0x7EBE16CD,
1674         0xE0DA836E,  0x97DDB3F8,  0x0ED4E242,  0x79D3D2D4,
1675         0xF4DBDF21,  0x83DCEFB7,  0x1AD5BE0D,  0x6DD28E9B,
1676         0xF3B61B38,  0x84B12BAE,  0x1DB87A14,  0x6ABF4A82,
1677         0xFA005713,  0x8D076785,  0x140E363F,  0x630906A9,
1678         0xFD6D930A,  0x8A6AA39C,  0x1363F226,  0x6464C2B0,
1679         0xA4DEAE1D,  0xD3D99E8B,  0x4AD0CF31,  0x3DD7FFA7,
1680         0xA3B36A04,  0xD4B45A92,  0x4DBD0B28,  0x3ABA3BBE,
1681         0xAA05262F,  0xDD0216B9,  0x440B4703,  0x330C7795,
1682         0xAD68E236,  0xDA6FD2A0,  0x4366831A,  0x3461B38C,
1683         0xB969BE79,  0xCE6E8EEF,  0x5767DF55,  0x2060EFC3,
1684         0xBE047A60,  0xC9034AF6,  0x500A1B4C,  0x270D2BDA,
1685         0xB7B2364B,  0xC0B506DD,  0x59BC5767,  0x2EBB67F1,
1686         0xB0DFF252,  0xC7D8C2C4,  0x5ED1937E,  0x29D6A3E8,
1687         0x9FB08ED5,  0xE8B7BE43,  0x71BEEFF9,  0x06B9DF6F,
1688         0x98DD4ACC,  0xEFDA7A5A,  0x76D32BE0,  0x01D41B76,
1689         0x916B06E7,  0xE66C3671,  0x7F6567CB,  0x0862575D,
1690         0x9606C2FE,  0xE101F268,  0x7808A3D2,  0x0F0F9344,
1691         0x82079EB1,  0xF500AE27,  0x6C09FF9D,  0x1B0ECF0B,
1692         0x856A5AA8,  0xF26D6A3E,  0x6B643B84,  0x1C630B12,
1693         0x8CDC1683,  0xFBDB2615,  0x62D277AF,  0x15D54739,
1694         0x8BB1D29A,  0xFCB6E20C,  0x65BFB3B6,  0x12B88320,
1695         0x3FBA6CAD,  0x48BD5C3B,  0xD1B40D81,  0xA6B33D17,
1696         0x38D7A8B4,  0x4FD09822,  0xD6D9C998,  0xA1DEF90E,
1697         0x3161E49F,  0x4666D409,  0xDF6F85B3,  0xA868B525,
1698         0x360C2086,  0x410B1010,  0xD80241AA,  0xAF05713C,
1699         0x220D7CC9,  0x550A4C5F,  0xCC031DE5,  0xBB042D73,
1700         0x2560B8D0,  0x52678846,  0xCB6ED9FC,  0xBC69E96A,
1701         0x2CD6F4FB,  0x5BD1C46D,  0xC2D895D7,  0xB5DFA541,
1702         0x2BBB30E2,  0x5CBC0074,  0xC5B551CE,  0xB2B26158,
1703         0x04D44C65,  0x73D37CF3,  0xEADA2D49,  0x9DDD1DDF,
1704         0x03B9887C,  0x74BEB8EA,  0xEDB7E950,  0x9AB0D9C6,
1705         0x0A0FC457,  0x7D08F4C1,  0xE401A57B,  0x930695ED,
1706         0x0D62004E,  0x7A6530D8,  0xE36C6162,  0x946B51F4,
1707         0x19635C01,  0x6E646C97,  0xF76D3D2D,  0x806A0DBB,
1708         0x1E0E9818,  0x6909A88E,  0xF000F934,  0x8707C9A2,
1709         0x17B8D433,  0x60BFE4A5,  0xF9B6B51F,  0x8EB18589,
1710         0x10D5102A,  0x67D220BC,  0xFEDB7106,  0x89DC4190,
1711         0x49662D3D,  0x3E611DAB,  0xA7684C11,  0xD06F7C87,
1712         0x4E0BE924,  0x390CD9B2,  0xA0058808,  0xD702B89E,
1713         0x47BDA50F,  0x30BA9599,  0xA9B3C423,  0xDEB4F4B5,
1714         0x40D06116,  0x37D75180,  0xAEDE003A,  0xD9D930AC,
1715         0x54D13D59,  0x23D60DCF,  0xBADF5C75,  0xCDD86CE3,
1716         0x53BCF940,  0x24BBC9D6,  0xBDB2986C,  0xCAB5A8FA,
1717         0x5A0AB56B,  0x2D0D85FD,  0xB404D447,  0xC303E4D1,
1718         0x5D677172,  0x2A6041E4,  0xB369105E,  0xC46E20C8,
1719         0x72080DF5,  0x050F3D63,  0x9C066CD9,  0xEB015C4F,
1720         0x7565C9EC,  0x0262F97A,  0x9B6BA8C0,  0xEC6C9856,
1721         0x7CD385C7,  0x0BD4B551,  0x92DDE4EB,  0xE5DAD47D,
1722         0x7BBE41DE,  0x0CB97148,  0x95B020F2,  0xE2B71064,
1723         0x6FBF1D91,  0x18B82D07,  0x81B17CBD,  0xF6B64C2B,
1724         0x68D2D988,  0x1FD5E91E,  0x86DCB8A4,  0xF1DB8832,
1725         0x616495A3,  0x1663A535,  0x8F6AF48F,  0xF86DC419,
1726         0x660951BA,  0x110E612C,  0x88073096,  0xFF000000
1727 };
1728