drivers/net/wan/sbni.c

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