git.oblomov.eu Git - linux-2.6/blob - drivers/net/wan/sbni.c

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