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