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