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