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