Pull bugzilla-6316 into release branch
[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 #ifdef CONFIG_SBNI_MULTILINE
1003         skb->dev = ((struct net_local *) dev->priv)->master;
1004 #else
1005         skb->dev = dev;
1006 #endif
1007         skb_reserve( skb, 2 );          /* Align IP on longword boundaries */
1008         return  skb;
1009 }
1010
1011
1012 static void
1013 indicate_pkt( struct net_device  *dev )
1014 {
1015         struct net_local  *nl  = (struct net_local *) dev->priv;
1016         struct sk_buff    *skb = nl->rx_buf_p;
1017
1018         skb_put( skb, nl->inppos );
1019
1020 #ifdef CONFIG_SBNI_MULTILINE
1021         skb->protocol = eth_type_trans( skb, nl->master );
1022         netif_rx( skb );
1023         dev->last_rx = jiffies;
1024         ++((struct net_local *) nl->master->priv)->stats.rx_packets;
1025         ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
1026 #else
1027         skb->protocol = eth_type_trans( skb, dev );
1028         netif_rx( skb );
1029         dev->last_rx = jiffies;
1030         ++nl->stats.rx_packets;
1031         nl->stats.rx_bytes += nl->inppos;
1032 #endif
1033         nl->rx_buf_p = NULL;    /* protocol driver will clear this sk_buff */
1034 }
1035
1036
1037 /* -------------------------------------------------------------------------- */
1038
1039 /*
1040  * Routine checks periodically wire activity and regenerates marker if
1041  * connect was inactive for a long time.
1042  */
1043
1044 static void
1045 sbni_watchdog( unsigned long  arg )
1046 {
1047         struct net_device  *dev = (struct net_device *) arg;
1048         struct net_local   *nl  = (struct net_local *) dev->priv;
1049         struct timer_list  *w   = &nl->watchdog; 
1050         unsigned long      flags;
1051         unsigned char      csr0;
1052
1053         spin_lock_irqsave( &nl->lock, flags );
1054
1055         csr0 = inb( dev->base_addr + CSR0 );
1056         if( csr0 & RC_CHK ) {
1057
1058                 if( nl->timer_ticks ) {
1059                         if( csr0 & (RC_RDY | BU_EMP) )
1060                                 /* receiving not active */
1061                                 nl->timer_ticks--;
1062                 } else {
1063                         nl->in_stats.timeout_number++;
1064                         if( nl->delta_rxl )
1065                                 timeout_change_level( dev );
1066
1067                         outb( *(u_char *)&nl->csr1 | PR_RES,
1068                               dev->base_addr + CSR1 );
1069                         csr0 = inb( dev->base_addr + CSR0 );
1070                 }
1071         } else
1072                 nl->state &= ~FL_LINE_DOWN;
1073
1074         outb( csr0 | RC_CHK, dev->base_addr + CSR0 ); 
1075
1076         init_timer( w );
1077         w->expires      = jiffies + SBNI_TIMEOUT;
1078         w->data         = arg;
1079         w->function     = sbni_watchdog;
1080         add_timer( w );
1081
1082         spin_unlock_irqrestore( &nl->lock, flags );
1083 }
1084
1085
1086 static unsigned char  rxl_tab[] = {
1087         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1088         0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1089 };
1090
1091 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1092 static unsigned char  timeout_rxl_tab[] = {
1093         0x03, 0x05, 0x08, 0x0b
1094 };
1095
1096 /* -------------------------------------------------------------------------- */
1097
1098 static void
1099 card_start( struct net_device  *dev )
1100 {
1101         struct net_local  *nl = (struct net_local *) dev->priv;
1102
1103         nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1104         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1105         nl->state |= FL_PREV_OK;
1106
1107         nl->inppos = nl->outpos = 0;
1108         nl->wait_frameno = 0;
1109         nl->tx_frameno   = 0;
1110         nl->framelen     = 0;
1111
1112         outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1113         outb( EN_INT, dev->base_addr + CSR0 );
1114 }
1115
1116 /* -------------------------------------------------------------------------- */
1117
1118 /* Receive level auto-selection */
1119
1120 static void
1121 change_level( struct net_device  *dev )
1122 {
1123         struct net_local  *nl = (struct net_local *) dev->priv;
1124
1125         if( nl->delta_rxl == 0 )        /* do not auto-negotiate RxL */
1126                 return;
1127
1128         if( nl->cur_rxl_index == 0 )
1129                 nl->delta_rxl = 1;
1130         else if( nl->cur_rxl_index == 15 )
1131                 nl->delta_rxl = -1;
1132         else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1133                 nl->delta_rxl = -nl->delta_rxl;
1134
1135         nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1136         inb( dev->base_addr + CSR0 );   /* needs for PCI cards */
1137         outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1138
1139         nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1140         nl->cur_rxl_rcvd  = 0;
1141 }
1142
1143
1144 static void
1145 timeout_change_level( struct net_device  *dev )
1146 {
1147         struct net_local  *nl = (struct net_local *) dev->priv;
1148
1149         nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1150         if( ++nl->timeout_rxl >= 4 )
1151                 nl->timeout_rxl = 0;
1152
1153         nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1154         inb( dev->base_addr + CSR0 );
1155         outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1156
1157         nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1158         nl->cur_rxl_rcvd  = 0;
1159 }
1160
1161 /* -------------------------------------------------------------------------- */
1162
1163 /*
1164  *      Open/initialize the board. 
1165  */
1166
1167 static int
1168 sbni_open( struct net_device  *dev )
1169 {
1170         struct net_local        *nl = (struct net_local *) dev->priv;
1171         struct timer_list       *w  = &nl->watchdog;
1172
1173         /*
1174          * For double ISA adapters within "common irq" mode, we have to
1175          * determine whether primary or secondary channel is initialized,
1176          * and set the irq handler only in first case.
1177          */
1178         if( dev->base_addr < 0x400 ) {          /* ISA only */
1179                 struct net_device  **p = sbni_cards;
1180                 for( ;  *p  &&  p < sbni_cards + SBNI_MAX_NUM_CARDS;  ++p )
1181                         if( (*p)->irq == dev->irq
1182                             &&  ((*p)->base_addr == dev->base_addr + 4
1183                                  ||  (*p)->base_addr == dev->base_addr - 4)
1184                             &&  (*p)->flags & IFF_UP ) {
1185
1186                                 ((struct net_local *) ((*p)->priv))
1187                                         ->second = dev;
1188                                 printk( KERN_NOTICE "%s: using shared irq "
1189                                         "with %s\n", dev->name, (*p)->name );
1190                                 nl->state |= FL_SECONDARY;
1191                                 goto  handler_attached;
1192                         }
1193         }
1194
1195         if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1196                 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1197                         dev->name, dev->irq );
1198                 return  -EAGAIN;
1199         }
1200
1201 handler_attached:
1202
1203         spin_lock( &nl->lock );
1204         memset( &nl->stats, 0, sizeof(struct net_device_stats) );
1205         memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1206
1207         card_start( dev );
1208
1209         netif_start_queue( dev );
1210
1211         /* set timer watchdog */
1212         init_timer( w );
1213         w->expires      = jiffies + SBNI_TIMEOUT;
1214         w->data         = (unsigned long) dev;
1215         w->function     = sbni_watchdog;
1216         add_timer( w );
1217    
1218         spin_unlock( &nl->lock );
1219         return 0;
1220 }
1221
1222
1223 static int
1224 sbni_close( struct net_device  *dev )
1225 {
1226         struct net_local  *nl = (struct net_local *) dev->priv;
1227
1228         if( nl->second  &&  nl->second->flags & IFF_UP ) {
1229                 printk( KERN_NOTICE "Secondary channel (%s) is active!\n",
1230                         nl->second->name );
1231                 return  -EBUSY;
1232         }
1233
1234 #ifdef CONFIG_SBNI_MULTILINE
1235         if( nl->state & FL_SLAVE )
1236                 emancipate( dev );
1237         else
1238                 while( nl->link )       /* it's master device! */
1239                         emancipate( nl->link );
1240 #endif
1241
1242         spin_lock( &nl->lock );
1243
1244         nl->second = NULL;
1245         drop_xmit_queue( dev ); 
1246         netif_stop_queue( dev );
1247    
1248         del_timer( &nl->watchdog );
1249
1250         outb( 0, dev->base_addr + CSR0 );
1251
1252         if( !(nl->state & FL_SECONDARY) )
1253                 free_irq( dev->irq, dev );
1254         nl->state &= FL_SECONDARY;
1255
1256         spin_unlock( &nl->lock );
1257         return 0;
1258 }
1259
1260
1261 /*
1262         Valid combinations in CSR0 (for probing):
1263
1264         VALID_DECODER   0000,0011,1011,1010
1265
1266                                         ; 0   ; -
1267                                 TR_REQ  ; 1   ; +
1268                         TR_RDY          ; 2   ; -
1269                         TR_RDY  TR_REQ  ; 3   ; +
1270                 BU_EMP                  ; 4   ; +
1271                 BU_EMP          TR_REQ  ; 5   ; +
1272                 BU_EMP  TR_RDY          ; 6   ; -
1273                 BU_EMP  TR_RDY  TR_REQ  ; 7   ; +
1274         RC_RDY                          ; 8   ; +
1275         RC_RDY                  TR_REQ  ; 9   ; +
1276         RC_RDY          TR_RDY          ; 10  ; -
1277         RC_RDY          TR_RDY  TR_REQ  ; 11  ; -
1278         RC_RDY  BU_EMP                  ; 12  ; -
1279         RC_RDY  BU_EMP          TR_REQ  ; 13  ; -
1280         RC_RDY  BU_EMP  TR_RDY          ; 14  ; -
1281         RC_RDY  BU_EMP  TR_RDY  TR_REQ  ; 15  ; -
1282 */
1283
1284 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1285
1286
1287 static int
1288 sbni_card_probe( unsigned long  ioaddr )
1289 {
1290         unsigned char  csr0;
1291
1292         csr0 = inb( ioaddr + CSR0 );
1293         if( csr0 != 0xff  &&  csr0 != 0x00 ) {
1294                 csr0 &= ~EN_INT;
1295                 if( csr0 & BU_EMP )
1296                         csr0 |= EN_INT;
1297       
1298                 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1299                         return  0;
1300         }
1301    
1302         return  -ENODEV;
1303 }
1304
1305 /* -------------------------------------------------------------------------- */
1306
1307 static int
1308 sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
1309 {
1310         struct net_local  *nl = (struct net_local *) dev->priv; 
1311         struct sbni_flags  flags;
1312         int  error = 0;
1313
1314 #ifdef CONFIG_SBNI_MULTILINE
1315         struct net_device  *slave_dev;
1316         char  slave_name[ 8 ];
1317 #endif
1318   
1319         switch( cmd ) {
1320         case  SIOCDEVGETINSTATS :
1321                 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1322                                         sizeof(struct sbni_in_stats) ))
1323                         error = -EFAULT;
1324                 break;
1325
1326         case  SIOCDEVRESINSTATS :
1327                 if( current->euid != 0 )        /* root only */
1328                         return  -EPERM;
1329                 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1330                 break;
1331
1332         case  SIOCDEVGHWSTATE :
1333                 flags.mac_addr  = *(u32 *)(dev->dev_addr + 3);
1334                 flags.rate      = nl->csr1.rate;
1335                 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1336                 flags.rxl       = nl->cur_rxl_index;
1337                 flags.fixed_rxl = nl->delta_rxl == 0;
1338
1339                 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1340                         error = -EFAULT;
1341                 break;
1342
1343         case  SIOCDEVSHWSTATE :
1344                 if( current->euid != 0 )        /* root only */
1345                         return  -EPERM;
1346
1347                 spin_lock( &nl->lock );
1348                 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1349                 if( flags.fixed_rxl )
1350                         nl->delta_rxl = 0,
1351                         nl->cur_rxl_index = flags.rxl;
1352                 else
1353                         nl->delta_rxl = DEF_RXL_DELTA,
1354                         nl->cur_rxl_index = DEF_RXL;
1355
1356                 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1357                 nl->csr1.rate = flags.rate;
1358                 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1359                 spin_unlock( &nl->lock );
1360                 break;
1361
1362 #ifdef CONFIG_SBNI_MULTILINE
1363
1364         case  SIOCDEVENSLAVE :
1365                 if( current->euid != 0 )        /* root only */
1366                         return  -EPERM;
1367
1368                 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1369                         return -EFAULT;
1370                 slave_dev = dev_get_by_name( slave_name );
1371                 if( !slave_dev  ||  !(slave_dev->flags & IFF_UP) ) {
1372                         printk( KERN_ERR "%s: trying to enslave non-active "
1373                                 "device %s\n", dev->name, slave_name );
1374                         return  -EPERM;
1375                 }
1376
1377                 return  enslave( dev, slave_dev );
1378
1379         case  SIOCDEVEMANSIPATE :
1380                 if( current->euid != 0 )        /* root only */
1381                         return  -EPERM;
1382
1383                 return  emancipate( dev );
1384
1385 #endif  /* CONFIG_SBNI_MULTILINE */
1386
1387         default :
1388                 return  -EOPNOTSUPP;
1389         }
1390
1391         return  error;
1392 }
1393
1394
1395 #ifdef CONFIG_SBNI_MULTILINE
1396
1397 static int
1398 enslave( struct net_device  *dev,  struct net_device  *slave_dev )
1399 {
1400         struct net_local  *nl  = (struct net_local *) dev->priv;
1401         struct net_local  *snl = (struct net_local *) slave_dev->priv;
1402
1403         if( nl->state & FL_SLAVE )      /* This isn't master or free device */
1404                 return  -EBUSY;
1405
1406         if( snl->state & FL_SLAVE )     /* That was already enslaved */
1407                 return  -EBUSY;
1408
1409         spin_lock( &nl->lock );
1410         spin_lock( &snl->lock );
1411
1412         /* append to list */
1413         snl->link = nl->link;
1414         nl->link  = slave_dev;
1415         snl->master = dev;
1416         snl->state |= FL_SLAVE;
1417
1418         /* Summary statistics of MultiLine operation will be stored
1419            in master's counters */
1420         memset( &snl->stats, 0, sizeof(struct net_device_stats) );
1421         netif_stop_queue( slave_dev );
1422         netif_wake_queue( dev );        /* Now we are able to transmit */
1423
1424         spin_unlock( &snl->lock );
1425         spin_unlock( &nl->lock );
1426         printk( KERN_NOTICE "%s: slave device (%s) attached.\n",
1427                 dev->name, slave_dev->name );
1428         return  0;
1429 }
1430
1431
1432 static int
1433 emancipate( struct net_device  *dev )
1434 {
1435         struct net_local   *snl = (struct net_local *) dev->priv;
1436         struct net_device  *p   = snl->master;
1437         struct net_local   *nl  = (struct net_local *) p->priv;
1438
1439         if( !(snl->state & FL_SLAVE) )
1440                 return  -EINVAL;
1441
1442         spin_lock( &nl->lock );
1443         spin_lock( &snl->lock );
1444         drop_xmit_queue( dev );
1445
1446         /* exclude from list */
1447         for(;;) {       /* must be in list */
1448                 struct net_local  *t = (struct net_local *) p->priv;
1449                 if( t->link == dev ) {
1450                         t->link = snl->link;
1451                         break;
1452                 }
1453                 p = t->link;
1454         }
1455
1456         snl->link = NULL;
1457         snl->master = dev;
1458         snl->state &= ~FL_SLAVE;
1459
1460         netif_start_queue( dev );
1461
1462         spin_unlock( &snl->lock );
1463         spin_unlock( &nl->lock );
1464
1465         dev_put( dev );
1466         return  0;
1467 }
1468
1469 #endif
1470
1471
1472 static struct net_device_stats *
1473 sbni_get_stats( struct net_device  *dev )
1474 {
1475         return  &((struct net_local *) dev->priv)->stats;
1476 }
1477
1478
1479 static void
1480 set_multicast_list( struct net_device  *dev )
1481 {
1482         return;         /* sbni always operate in promiscuos mode */
1483 }
1484
1485
1486 #ifdef MODULE
1487 module_param_array(io, int, NULL, 0);
1488 module_param_array(irq, int, NULL, 0);
1489 module_param_array(baud, int, NULL, 0);
1490 module_param_array(rxl, int, NULL, 0);
1491 module_param_array(mac, int, NULL, 0);
1492 module_param(skip_pci_probe, bool, 0);
1493
1494 MODULE_LICENSE("GPL");
1495
1496
1497 int __init init_module( void )
1498 {
1499         struct net_device  *dev;
1500         int err;
1501
1502         while( num < SBNI_MAX_NUM_CARDS ) {
1503                 dev = alloc_netdev(sizeof(struct net_local), 
1504                                    "sbni%d", sbni_devsetup);
1505                 if( !dev)
1506                         break;
1507
1508                 sprintf( dev->name, "sbni%d", num );
1509
1510                 err = sbni_init(dev);
1511                 if (err) {
1512                         free_netdev(dev);
1513                         break;
1514                 }
1515
1516                 if( register_netdev( dev ) ) {
1517                         release_region( dev->base_addr, SBNI_IO_EXTENT );
1518                         free_netdev( dev );
1519                         break;
1520                 }
1521         }
1522
1523         return  *sbni_cards  ?  0  :  -ENODEV;
1524 }
1525
1526 void
1527 cleanup_module( void )
1528 {
1529         struct net_device  *dev;
1530         int  num;
1531
1532         for( num = 0;  num < SBNI_MAX_NUM_CARDS;  ++num )
1533                 if( (dev = sbni_cards[ num ]) != NULL ) {
1534                         unregister_netdev( dev );
1535                         release_region( dev->base_addr, SBNI_IO_EXTENT );
1536                         free_netdev( dev );
1537                 }
1538 }
1539
1540 #else   /* MODULE */
1541
1542 static int __init
1543 sbni_setup( char  *p )
1544 {
1545         int  n, parm;
1546
1547         if( *p++ != '(' )
1548                 goto  bad_param;
1549
1550         for( n = 0, parm = 0;  *p  &&  n < 8; ) {
1551                 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1552                 if( !*p  ||  *p == ')' )
1553                         return 1;
1554                 if( *p == ';' )
1555                         ++p, ++n, parm = 0;
1556                 else if( *p++ != ',' )
1557                         break;
1558                 else
1559                         if( ++parm >= 5 )
1560                                 break;
1561         }
1562 bad_param:
1563         printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1564         return 0;
1565 }
1566
1567 __setup( "sbni=", sbni_setup );
1568
1569 #endif  /* MODULE */
1570
1571 /* -------------------------------------------------------------------------- */
1572
1573 #ifdef ASM_CRC
1574
1575 static u32
1576 calc_crc32( u32  crc,  u8  *p,  u32  len )
1577 {
1578         register u32  _crc;
1579         _crc = crc;
1580         
1581         __asm__ __volatile__ (
1582                 "xorl   %%ebx, %%ebx\n"
1583                 "movl   %2, %%esi\n" 
1584                 "movl   %3, %%ecx\n" 
1585                 "movl   $crc32tab, %%edi\n"
1586                 "shrl   $2, %%ecx\n"
1587                 "jz     1f\n"
1588
1589                 ".align 4\n"
1590         "0:\n"
1591                 "movb   %%al, %%bl\n"
1592                 "movl   (%%esi), %%edx\n"
1593                 "shrl   $8, %%eax\n"
1594                 "xorb   %%dl, %%bl\n"
1595                 "shrl   $8, %%edx\n"
1596                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1597
1598                 "movb   %%al, %%bl\n"
1599                 "shrl   $8, %%eax\n"
1600                 "xorb   %%dl, %%bl\n"
1601                 "shrl   $8, %%edx\n"
1602                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1603
1604                 "movb   %%al, %%bl\n"
1605                 "shrl   $8, %%eax\n"
1606                 "xorb   %%dl, %%bl\n"
1607                 "movb   %%dh, %%dl\n" 
1608                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1609
1610                 "movb   %%al, %%bl\n"
1611                 "shrl   $8, %%eax\n"
1612                 "xorb   %%dl, %%bl\n"
1613                 "addl   $4, %%esi\n"
1614                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1615
1616                 "decl   %%ecx\n"
1617                 "jnz    0b\n"
1618
1619         "1:\n"
1620                 "movl   %3, %%ecx\n"
1621                 "andl   $3, %%ecx\n"
1622                 "jz     2f\n"
1623
1624                 "movb   %%al, %%bl\n"
1625                 "shrl   $8, %%eax\n"
1626                 "xorb   (%%esi), %%bl\n"
1627                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1628
1629                 "decl   %%ecx\n"
1630                 "jz     2f\n"
1631
1632                 "movb   %%al, %%bl\n"
1633                 "shrl   $8, %%eax\n"
1634                 "xorb   1(%%esi), %%bl\n"
1635                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1636
1637                 "decl   %%ecx\n"
1638                 "jz     2f\n"
1639
1640                 "movb   %%al, %%bl\n"
1641                 "shrl   $8, %%eax\n"
1642                 "xorb   2(%%esi), %%bl\n"
1643                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1644         "2:\n"
1645                 : "=a" (_crc)
1646                 : "0" (_crc), "g" (p), "g" (len)
1647                 : "bx", "cx", "dx", "si", "di"
1648         );
1649
1650         return  _crc;
1651 }
1652
1653 #else   /* ASM_CRC */
1654
1655 static u32
1656 calc_crc32( u32  crc,  u8  *p,  u32  len )
1657 {
1658         while( len-- )
1659                 crc = CRC32( *p++, crc );
1660
1661         return  crc;
1662 }
1663
1664 #endif  /* ASM_CRC */
1665
1666
1667 static u32  crc32tab[] __attribute__ ((aligned(8))) = {
1668         0xD202EF8D,  0xA505DF1B,  0x3C0C8EA1,  0x4B0BBE37,
1669         0xD56F2B94,  0xA2681B02,  0x3B614AB8,  0x4C667A2E,
1670         0xDCD967BF,  0xABDE5729,  0x32D70693,  0x45D03605,
1671         0xDBB4A3A6,  0xACB39330,  0x35BAC28A,  0x42BDF21C,
1672         0xCFB5FFE9,  0xB8B2CF7F,  0x21BB9EC5,  0x56BCAE53,
1673         0xC8D83BF0,  0xBFDF0B66,  0x26D65ADC,  0x51D16A4A,
1674         0xC16E77DB,  0xB669474D,  0x2F6016F7,  0x58672661,
1675         0xC603B3C2,  0xB1048354,  0x280DD2EE,  0x5F0AE278,
1676         0xE96CCF45,  0x9E6BFFD3,  0x0762AE69,  0x70659EFF,
1677         0xEE010B5C,  0x99063BCA,  0x000F6A70,  0x77085AE6,
1678         0xE7B74777,  0x90B077E1,  0x09B9265B,  0x7EBE16CD,
1679         0xE0DA836E,  0x97DDB3F8,  0x0ED4E242,  0x79D3D2D4,
1680         0xF4DBDF21,  0x83DCEFB7,  0x1AD5BE0D,  0x6DD28E9B,
1681         0xF3B61B38,  0x84B12BAE,  0x1DB87A14,  0x6ABF4A82,
1682         0xFA005713,  0x8D076785,  0x140E363F,  0x630906A9,
1683         0xFD6D930A,  0x8A6AA39C,  0x1363F226,  0x6464C2B0,
1684         0xA4DEAE1D,  0xD3D99E8B,  0x4AD0CF31,  0x3DD7FFA7,
1685         0xA3B36A04,  0xD4B45A92,  0x4DBD0B28,  0x3ABA3BBE,
1686         0xAA05262F,  0xDD0216B9,  0x440B4703,  0x330C7795,
1687         0xAD68E236,  0xDA6FD2A0,  0x4366831A,  0x3461B38C,
1688         0xB969BE79,  0xCE6E8EEF,  0x5767DF55,  0x2060EFC3,
1689         0xBE047A60,  0xC9034AF6,  0x500A1B4C,  0x270D2BDA,
1690         0xB7B2364B,  0xC0B506DD,  0x59BC5767,  0x2EBB67F1,
1691         0xB0DFF252,  0xC7D8C2C4,  0x5ED1937E,  0x29D6A3E8,
1692         0x9FB08ED5,  0xE8B7BE43,  0x71BEEFF9,  0x06B9DF6F,
1693         0x98DD4ACC,  0xEFDA7A5A,  0x76D32BE0,  0x01D41B76,
1694         0x916B06E7,  0xE66C3671,  0x7F6567CB,  0x0862575D,
1695         0x9606C2FE,  0xE101F268,  0x7808A3D2,  0x0F0F9344,
1696         0x82079EB1,  0xF500AE27,  0x6C09FF9D,  0x1B0ECF0B,
1697         0x856A5AA8,  0xF26D6A3E,  0x6B643B84,  0x1C630B12,
1698         0x8CDC1683,  0xFBDB2615,  0x62D277AF,  0x15D54739,
1699         0x8BB1D29A,  0xFCB6E20C,  0x65BFB3B6,  0x12B88320,
1700         0x3FBA6CAD,  0x48BD5C3B,  0xD1B40D81,  0xA6B33D17,
1701         0x38D7A8B4,  0x4FD09822,  0xD6D9C998,  0xA1DEF90E,
1702         0x3161E49F,  0x4666D409,  0xDF6F85B3,  0xA868B525,
1703         0x360C2086,  0x410B1010,  0xD80241AA,  0xAF05713C,
1704         0x220D7CC9,  0x550A4C5F,  0xCC031DE5,  0xBB042D73,
1705         0x2560B8D0,  0x52678846,  0xCB6ED9FC,  0xBC69E96A,
1706         0x2CD6F4FB,  0x5BD1C46D,  0xC2D895D7,  0xB5DFA541,
1707         0x2BBB30E2,  0x5CBC0074,  0xC5B551CE,  0xB2B26158,
1708         0x04D44C65,  0x73D37CF3,  0xEADA2D49,  0x9DDD1DDF,
1709         0x03B9887C,  0x74BEB8EA,  0xEDB7E950,  0x9AB0D9C6,
1710         0x0A0FC457,  0x7D08F4C1,  0xE401A57B,  0x930695ED,
1711         0x0D62004E,  0x7A6530D8,  0xE36C6162,  0x946B51F4,
1712         0x19635C01,  0x6E646C97,  0xF76D3D2D,  0x806A0DBB,
1713         0x1E0E9818,  0x6909A88E,  0xF000F934,  0x8707C9A2,
1714         0x17B8D433,  0x60BFE4A5,  0xF9B6B51F,  0x8EB18589,
1715         0x10D5102A,  0x67D220BC,  0xFEDB7106,  0x89DC4190,
1716         0x49662D3D,  0x3E611DAB,  0xA7684C11,  0xD06F7C87,
1717         0x4E0BE924,  0x390CD9B2,  0xA0058808,  0xD702B89E,
1718         0x47BDA50F,  0x30BA9599,  0xA9B3C423,  0xDEB4F4B5,
1719         0x40D06116,  0x37D75180,  0xAEDE003A,  0xD9D930AC,
1720         0x54D13D59,  0x23D60DCF,  0xBADF5C75,  0xCDD86CE3,
1721         0x53BCF940,  0x24BBC9D6,  0xBDB2986C,  0xCAB5A8FA,
1722         0x5A0AB56B,  0x2D0D85FD,  0xB404D447,  0xC303E4D1,
1723         0x5D677172,  0x2A6041E4,  0xB369105E,  0xC46E20C8,
1724         0x72080DF5,  0x050F3D63,  0x9C066CD9,  0xEB015C4F,
1725         0x7565C9EC,  0x0262F97A,  0x9B6BA8C0,  0xEC6C9856,
1726         0x7CD385C7,  0x0BD4B551,  0x92DDE4EB,  0xE5DAD47D,
1727         0x7BBE41DE,  0x0CB97148,  0x95B020F2,  0xE2B71064,
1728         0x6FBF1D91,  0x18B82D07,  0x81B17CBD,  0xF6B64C2B,
1729         0x68D2D988,  0x1FD5E91E,  0x86DCB8A4,  0xF1DB8832,
1730         0x616495A3,  0x1663A535,  0x8F6AF48F,  0xF86DC419,
1731         0x660951BA,  0x110E612C,  0x88073096,  0xFF000000
1732 };
1733