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