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