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