drivers/net/wan/sbni.c

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