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