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 timer_list       watchdog;
  72
  73         spinlock_t      lock;
  74         struct sk_buff  *rx_buf_p;              /* receive buffer ptr */
  75         struct sk_buff  *tx_buf_p;              /* transmit buffer ptr */
  76
  77         unsigned int    framelen;               /* current frame length */
  78         unsigned int    maxframe;               /* maximum valid frame length */
  79         unsigned int    state;
  80         unsigned int    inppos, outpos;         /* positions in rx/tx buffers */
  81
  82         /* transmitting frame number - from frames qty to 1 */
  83         unsigned int    tx_frameno;
  84
  85         /* expected number of next receiving frame */
  86         unsigned int    wait_frameno;
  87
  88         /* count of failed attempts to frame send - 32 attempts do before
  89            error - while receiver tunes on opposite side of wire */
  90         unsigned int    trans_errors;
  91
  92         /* idle time; send pong when limit exceeded */
  93         unsigned int    timer_ticks;
  94
  95         /* fields used for receive level autoselection */
  96         int     delta_rxl;
  97         unsigned int    cur_rxl_index, timeout_rxl;
  98         unsigned long   cur_rxl_rcvd, prev_rxl_rcvd;
  99
 100         struct sbni_csr1        csr1;           /* current value of CSR1 */
 101         struct sbni_in_stats    in_stats;       /* internal statistics */
 102
 103         struct net_device               *second;        /* for ISA/dual cards */
 104
 105 #ifdef CONFIG_SBNI_MULTILINE
 106         struct net_device               *master;
 107         struct net_device               *link;
 108 #endif
 109 };
 110
 111
 112 static int  sbni_card_probe( unsigned long );
 113 static int  sbni_pci_probe( struct net_device  * );
 114 static struct net_device  *sbni_probe1(struct net_device *, unsigned long, int);
 115 static int  sbni_open( struct net_device * );
 116 static int  sbni_close( struct net_device * );
 117 static int  sbni_start_xmit( struct sk_buff *, struct net_device * );
 118 static int  sbni_ioctl( struct net_device *, struct ifreq *, int );
 119 static void  set_multicast_list( struct net_device * );
 120
 121 static irqreturn_t sbni_interrupt( int, void * );
 122 static void  handle_channel( struct net_device * );
 123 static int   recv_frame( struct net_device * );
 124 static void  send_frame( struct net_device * );
 125 static int   upload_data( struct net_device *,
 126                           unsigned, unsigned, unsigned, u32 );
 127 static void  download_data( struct net_device *, u32 * );
 128 static void  sbni_watchdog( unsigned long );
 129 static void  interpret_ack( struct net_device *, unsigned );
 130 static int   append_frame_to_pkt( struct net_device *, unsigned, u32 );
 131 static void  indicate_pkt( struct net_device * );
 132 static void  card_start( struct net_device * );
 133 static void  prepare_to_send( struct sk_buff *, struct net_device * );
 134 static void  drop_xmit_queue( struct net_device * );
 135 static void  send_frame_header( struct net_device *, u32 * );
 136 static int   skip_tail( unsigned int, unsigned int, u32 );
 137 static int   check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
 138 static void  change_level( struct net_device * );
 139 static void  timeout_change_level( struct net_device * );
 140 static u32   calc_crc32( u32, u8 *, u32 );
 141 static struct sk_buff *  get_rx_buf( struct net_device * );
 142 static int  sbni_init( struct net_device * );
 143
 144 #ifdef CONFIG_SBNI_MULTILINE
 145 static int  enslave( struct net_device *, struct net_device * );
 146 static int  emancipate( struct net_device * );
 147 #endif
 148
 149 #ifdef __i386__
 150 #define ASM_CRC 1
 151 #endif
 152
 153 static const char  version[] =
 154         "Granch SBNI12 driver ver 5.0.1  Jun 22 2001  Denis I.Timofeev.\n";
 155
 156 static int  skip_pci_probe      __initdata = 0;
 157 static int  scandone    __initdata = 0;
 158 static int  num         __initdata = 0;
 159
 160 static unsigned char  rxl_tab[];
 161 static u32  crc32tab[];
 162
 163 /* A list of all installed devices, for removing the driver module. */
 164 static struct net_device  *sbni_cards[ SBNI_MAX_NUM_CARDS ];
 165
 166 /* Lists of device's parameters */
 167 static u32      io[   SBNI_MAX_NUM_CARDS ] __initdata =
 168         { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
 169 static u32      irq[  SBNI_MAX_NUM_CARDS ] __initdata;
 170 static u32      baud[ SBNI_MAX_NUM_CARDS ] __initdata;
 171 static u32      rxl[  SBNI_MAX_NUM_CARDS ] __initdata =
 172         { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
 173 static u32      mac[  SBNI_MAX_NUM_CARDS ] __initdata;
 174
 175 #ifndef MODULE
 176 typedef u32  iarr[];
 177 static iarr __initdata *dest[5] = { &io, &irq, &baud, &rxl, &mac };
 178 #endif
 179
 180 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
 181 static unsigned int  netcard_portlist[ ] __initdata = {
 182         0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
 183         0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
 184         0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
 185         0 };
 186
 187 #define NET_LOCAL_LOCK(dev) (((struct net_local *)netdev_priv(dev))->lock)
 188
 189 /*
 190  * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
 191  * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
 192  */
 193
 194 static inline int __init
 195 sbni_isa_probe( struct net_device  *dev )
 196 {
 197         if( dev->base_addr > 0x1ff
 198             &&  request_region( dev->base_addr, SBNI_IO_EXTENT, dev->name )
 199             &&  sbni_probe1( dev, dev->base_addr, dev->irq ) )
 200
 201                 return  0;
 202         else {
 203                 printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
 204                         "is malfunctional!\n", dev->base_addr );
 205                 return  -ENODEV;
 206         }
 207 }
 208
 209 static const struct net_device_ops sbni_netdev_ops = {
 210         .ndo_open               = sbni_open,
 211         .ndo_stop               = sbni_close,
 212         .ndo_start_xmit         = sbni_start_xmit,
 213         .ndo_set_multicast_list = set_multicast_list,
 214         .ndo_do_ioctl           = sbni_ioctl,
 215         .ndo_change_mtu         = eth_change_mtu,
 216         .ndo_set_mac_address    = eth_mac_addr,
 217         .ndo_validate_addr      = eth_validate_addr,
 218 };
 219
 220 static void __init sbni_devsetup(struct net_device *dev)
 221 {
 222         ether_setup( dev );
 223         dev->netdev_ops = &sbni_netdev_ops;
 224 }
 225
 226 int __init sbni_probe(int unit)
 227 {
 228         struct net_device *dev;
 229         static unsigned  version_printed __initdata = 0;
 230         int err;
 231
 232         dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
 233         if (!dev)
 234                 return -ENOMEM;
 235
 236         dev->netdev_ops = &sbni_netdev_ops;
 237
 238         sprintf(dev->name, "sbni%d", unit);
 239         netdev_boot_setup_check(dev);
 240
 241         err = sbni_init(dev);
 242         if (err) {
 243                 free_netdev(dev);
 244                 return err;
 245         }
 246
 247         err = register_netdev(dev);
 248         if (err) {
 249                 release_region( dev->base_addr, SBNI_IO_EXTENT );
 250                 free_netdev(dev);
 251                 return err;
 252         }
 253         if( version_printed++ == 0 )
 254                 printk( KERN_INFO "%s", version );
 255         return 0;
 256 }
 257
 258 static int __init sbni_init(struct net_device *dev)
 259 {
 260         int  i;
 261         if( dev->base_addr )
 262                 return  sbni_isa_probe( dev );
 263         /* otherwise we have to perform search our adapter */
 264
 265         if( io[ num ] != -1 )
 266                 dev->base_addr  = io[ num ],
 267                 dev->irq        = irq[ num ];
 268         else if( scandone  ||  io[ 0 ] != -1 )
 269                 return  -ENODEV;
 270
 271         /* if io[ num ] contains non-zero address, then that is on ISA bus */
 272         if( dev->base_addr )
 273                 return  sbni_isa_probe( dev );
 274
 275         /* ...otherwise - scan PCI first */
 276         if( !skip_pci_probe  &&  !sbni_pci_probe( dev ) )
 277                 return  0;
 278
 279         if( io[ num ] == -1 ) {
 280                 /* Auto-scan will be stopped when first ISA card were found */
 281                 scandone = 1;
 282                 if( num > 0 )
 283                         return  -ENODEV;
 284         }
 285
 286         for( i = 0;  netcard_portlist[ i ];  ++i ) {
 287                 int  ioaddr = netcard_portlist[ i ];
 288                 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
 289                     &&  sbni_probe1( dev, ioaddr, 0 ))
 290                         return 0;
 291         }
 292
 293         return  -ENODEV;
 294 }
 295
 296
 297 static int __init
 298 sbni_pci_probe( struct net_device  *dev )
 299 {
 300         struct pci_dev  *pdev = NULL;
 301
 302         while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
 303                != NULL ) {
 304                 int  pci_irq_line;
 305                 unsigned long  pci_ioaddr;
 306                 u16  subsys;
 307
 308                 if( pdev->vendor != SBNI_PCI_VENDOR
 309                     &&  pdev->device != SBNI_PCI_DEVICE )
 310                                 continue;
 311
 312                 pci_ioaddr = pci_resource_start( pdev, 0 );
 313                 pci_irq_line = pdev->irq;
 314
 315                 /* Avoid already found cards from previous calls */
 316                 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
 317                         pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
 318
 319                         if (subsys != 2)
 320                                 continue;
 321
 322                         /* Dual adapter is present */
 323                         if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
 324                                                         dev->name ) )
 325                                 continue;
 326                 }
 327
 328                 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
 329                         printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
 330                                 "this PCI card to IRQ %d, which is unlikely "
 331                                 "to work!.\n"
 332                                 KERN_WARNING " You should use the PCI BIOS "
 333                                 "setup to assign a valid IRQ line.\n",
 334                                 pci_irq_line );
 335
 336                 /* avoiding re-enable dual adapters */
 337                 if( (pci_ioaddr & 7) == 0  &&  pci_enable_device( pdev ) ) {
 338                         release_region( pci_ioaddr, SBNI_IO_EXTENT );
 339                         pci_dev_put( pdev );
 340                         return  -EIO;
 341                 }
 342                 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
 343                         SET_NETDEV_DEV(dev, &pdev->dev);
 344                         /* not the best thing to do, but this is all messed up
 345                            for hotplug systems anyway... */
 346                         pci_dev_put( pdev );
 347                         return  0;
 348                 }
 349         }
 350         return  -ENODEV;
 351 }
 352
 353
 354 static struct net_device * __init
 355 sbni_probe1( struct net_device  *dev,  unsigned long  ioaddr,  int  irq )
 356 {
 357         struct net_local  *nl;
 358
 359         if( sbni_card_probe( ioaddr ) ) {
 360                 release_region( ioaddr, SBNI_IO_EXTENT );
 361                 return NULL;
 362         }
 363
 364         outb( 0, ioaddr + CSR0 );
 365
 366         if( irq < 2 ) {
 367                 unsigned long irq_mask;
 368
 369                 irq_mask = probe_irq_on();
 370                 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
 371                 outb( PR_RES, ioaddr + CSR1 );
 372                 mdelay(50);
 373                 irq = probe_irq_off(irq_mask);
 374                 outb( 0, ioaddr + CSR0 );
 375
 376                 if( !irq ) {
 377                         printk( KERN_ERR "%s: can't detect device irq!\n",
 378                                 dev->name );
 379                         release_region( ioaddr, SBNI_IO_EXTENT );
 380                         return NULL;
 381                 }
 382         } else if( irq == 2 )
 383                 irq = 9;
 384
 385         dev->irq = irq;
 386         dev->base_addr = ioaddr;
 387
 388         /* Fill in sbni-specific dev fields. */
 389         nl = netdev_priv(dev);
 390         if( !nl ) {
 391                 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
 392                 release_region( ioaddr, SBNI_IO_EXTENT );
 393                 return NULL;
 394         }
 395
 396         memset( nl, 0, sizeof(struct net_local) );
 397         spin_lock_init( &nl->lock );
 398
 399         /* store MAC address (generate if that isn't known) */
 400         *(__be16 *)dev->dev_addr = htons( 0x00ff );
 401         *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
 402                 ((mac[num] ?
 403                 mac[num] :
 404                 (u32)((long)netdev_priv(dev))) & 0x00ffffff));
 405
 406         /* store link settings (speed, receive level ) */
 407         nl->maxframe  = DEFAULT_FRAME_LEN;
 408         nl->csr1.rate = baud[ num ];
 409
 410         if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
 411                 /* autotune rxl */
 412                 nl->cur_rxl_index = DEF_RXL,
 413                 nl->delta_rxl = DEF_RXL_DELTA;
 414         else
 415                 nl->delta_rxl = 0;
 416         nl->csr1.rxl  = rxl_tab[ nl->cur_rxl_index ];
 417         if( inb( ioaddr + CSR0 ) & 0x01 )
 418                 nl->state |= FL_SLOW_MODE;
 419
 420         printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
 421                 "MAC: 00:ff:01:%02x:%02x:%02x\n",
 422                 dev->name, dev->base_addr, dev->irq,
 423                 ((u8 *) dev->dev_addr) [3],
 424                 ((u8 *) dev->dev_addr) [4],
 425                 ((u8 *) dev->dev_addr) [5] );
 426
 427         printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
 428                 ( (nl->state & FL_SLOW_MODE)  ?  500000 : 2000000)
 429                 / (1 << nl->csr1.rate) );
 430
 431         if( nl->delta_rxl == 0 )
 432                 printk( "0x%x (fixed)\n", nl->cur_rxl_index );
 433         else
 434                 printk( "(auto)\n");
 435
 436 #ifdef CONFIG_SBNI_MULTILINE
 437         nl->master = dev;
 438         nl->link   = NULL;
 439 #endif
 440
 441         sbni_cards[ num++ ] = dev;
 442         return  dev;
 443 }
 444
 445 /* -------------------------------------------------------------------------- */
 446
 447 #ifdef CONFIG_SBNI_MULTILINE
 448
 449 static int
 450 sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
 451 {
 452         struct net_device  *p;
 453
 454         netif_stop_queue( dev );
 455
 456         /* Looking for idle device in the list */
 457         for( p = dev;  p; ) {
 458                 struct net_local  *nl = netdev_priv(p);
 459                 spin_lock( &nl->lock );
 460                 if( nl->tx_buf_p  ||  (nl->state & FL_LINE_DOWN) ) {
 461                         p = nl->link;
 462                         spin_unlock( &nl->lock );
 463                 } else {
 464                         /* Idle dev is found */
 465                         prepare_to_send( skb, p );
 466                         spin_unlock( &nl->lock );
 467                         netif_start_queue( dev );
 468                         return  0;
 469                 }
 470         }
 471
 472         return NETDEV_TX_BUSY;
 473 }
 474
 475 #else   /* CONFIG_SBNI_MULTILINE */
 476
 477 static int
 478 sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
 479 {
 480         struct net_local  *nl  = netdev_priv(dev);
 481
 482         netif_stop_queue( dev );
 483         spin_lock( &nl->lock );
 484
 485         prepare_to_send( skb, dev );
 486
 487         spin_unlock( &nl->lock );
 488         return  0;
 489 }
 490
 491 #endif  /* CONFIG_SBNI_MULTILINE */
 492
 493 /* -------------------------------------------------------------------------- */
 494
 495 /* interrupt handler */
 496
 497 /*
 498  *      SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
 499  * be looked as two independent single-channel devices. Every channel seems
 500  * as Ethernet interface but interrupt handler must be common. Really, first
 501  * channel ("master") driver only registers the handler. In its struct net_local
 502  * it has got pointer to "slave" channel's struct net_local and handles that's
 503  * interrupts too.
 504  *      dev of successfully attached ISA SBNI boards is linked to list.
 505  * While next board driver is initialized, it scans this list. If one
 506  * has found dev with same irq and ioaddr different by 4 then it assumes
 507  * this board to be "master".
 508  */
 509
 510 static irqreturn_t
 511 sbni_interrupt( int  irq,  void  *dev_id )
 512 {
 513         struct net_device         *dev = dev_id;
 514         struct net_local  *nl  = netdev_priv(dev);
 515         int     repeat;
 516
 517         spin_lock( &nl->lock );
 518         if( nl->second )
 519                 spin_lock(&NET_LOCAL_LOCK(nl->second));
 520
 521         do {
 522                 repeat = 0;
 523                 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
 524                         handle_channel( dev ),
 525                         repeat = 1;
 526                 if( nl->second  &&      /* second channel present */
 527                     (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
 528                         handle_channel( nl->second ),
 529                         repeat = 1;
 530         } while( repeat );
 531
 532         if( nl->second )
 533                 spin_unlock(&NET_LOCAL_LOCK(nl->second));
 534         spin_unlock( &nl->lock );
 535         return IRQ_HANDLED;
 536 }
 537
 538
 539 static void
 540 handle_channel( struct net_device  *dev )
 541 {
 542         struct net_local        *nl    = netdev_priv(dev);
 543         unsigned long           ioaddr = dev->base_addr;
 544
 545         int  req_ans;
 546         unsigned char  csr0;
 547
 548 #ifdef CONFIG_SBNI_MULTILINE
 549         /* Lock the master device because we going to change its local data */
 550         if( nl->state & FL_SLAVE )
 551                 spin_lock(&NET_LOCAL_LOCK(nl->master));
 552 #endif
 553
 554         outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
 555
 556         nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
 557         for(;;) {
 558                 csr0 = inb( ioaddr + CSR0 );
 559                 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
 560                         break;
 561
 562                 req_ans = !(nl->state & FL_PREV_OK);
 563
 564                 if( csr0 & RC_RDY )
 565                         req_ans = recv_frame( dev );
 566
 567                 /*
 568                  * TR_RDY always equals 1 here because we have owned the marker,
 569                  * and we set TR_REQ when disabled interrupts
 570                  */
 571                 csr0 = inb( ioaddr + CSR0 );
 572                 if( !(csr0 & TR_RDY)  ||  (csr0 & RC_RDY) )
 573                         printk( KERN_ERR "%s: internal error!\n", dev->name );
 574
 575                 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
 576                 if( req_ans  ||  nl->tx_frameno != 0 )
 577                         send_frame( dev );
 578                 else
 579                         /* send marker without any data */
 580                         outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
 581         }
 582
 583         outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
 584
 585 #ifdef CONFIG_SBNI_MULTILINE
 586         if( nl->state & FL_SLAVE )
 587                 spin_unlock(&NET_LOCAL_LOCK(nl->master));
 588 #endif
 589 }
 590
 591
 592 /*
 593  * Routine returns 1 if it need to acknoweledge received frame.
 594  * Empty frame received without errors won't be acknoweledged.
 595  */
 596
 597 static int
 598 recv_frame( struct net_device  *dev )
 599 {
 600         struct net_local  *nl   = netdev_priv(dev);
 601         unsigned long  ioaddr   = dev->base_addr;
 602
 603         u32  crc = CRC32_INITIAL;
 604
 605         unsigned  framelen = 0, frameno, ack;
 606         unsigned  is_first, frame_ok = 0;
 607
 608         if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
 609                 frame_ok = framelen > 4
 610                         ?  upload_data( dev, framelen, frameno, is_first, crc )
 611                         :  skip_tail( ioaddr, framelen, crc );
 612                 if( frame_ok )
 613                         interpret_ack( dev, ack );
 614         }
 615
 616         outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
 617         if( frame_ok ) {
 618                 nl->state |= FL_PREV_OK;
 619                 if( framelen > 4 )
 620                         nl->in_stats.all_rx_number++;
 621         } else
 622                 nl->state &= ~FL_PREV_OK,
 623                 change_level( dev ),
 624                 nl->in_stats.all_rx_number++,
 625                 nl->in_stats.bad_rx_number++;
 626
 627         return  !frame_ok  ||  framelen > 4;
 628 }
 629
 630
 631 static void
 632 send_frame( struct net_device  *dev )
 633 {
 634         struct net_local  *nl    = netdev_priv(dev);
 635
 636         u32  crc = CRC32_INITIAL;
 637
 638         if( nl->state & FL_NEED_RESEND ) {
 639
 640                 /* if frame was sended but not ACK'ed - resend it */
 641                 if( nl->trans_errors ) {
 642                         --nl->trans_errors;
 643                         if( nl->framelen != 0 )
 644                                 nl->in_stats.resend_tx_number++;
 645                 } else {
 646                         /* cannot xmit with many attempts */
 647 #ifdef CONFIG_SBNI_MULTILINE
 648                         if( (nl->state & FL_SLAVE)  ||  nl->link )
 649 #endif
 650                         nl->state |= FL_LINE_DOWN;
 651                         drop_xmit_queue( dev );
 652                         goto  do_send;
 653                 }
 654         } else
 655                 nl->trans_errors = TR_ERROR_COUNT;
 656
 657         send_frame_header( dev, &crc );
 658         nl->state |= FL_NEED_RESEND;
 659         /*
 660          * FL_NEED_RESEND will be cleared after ACK, but if empty
 661          * frame sended then in prepare_to_send next frame
 662          */
 663
 664
 665         if( nl->framelen ) {
 666                 download_data( dev, &crc );
 667                 nl->in_stats.all_tx_number++;
 668                 nl->state |= FL_WAIT_ACK;
 669         }
 670
 671         outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
 672
 673 do_send:
 674         outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
 675
 676         if( nl->tx_frameno )
 677                 /* next frame exists - we request card to send it */
 678                 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
 679                       dev->base_addr + CSR0 );
 680 }
 681
 682
 683 /*
 684  * Write the frame data into adapter's buffer memory, and calculate CRC.
 685  * Do padding if necessary.
 686  */
 687
 688 static void
 689 download_data( struct net_device  *dev,  u32  *crc_p )
 690 {
 691         struct net_local  *nl    = netdev_priv(dev);
 692         struct sk_buff    *skb   = nl->tx_buf_p;
 693
 694         unsigned  len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
 695
 696         outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
 697         *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
 698
 699         /* if packet too short we should write some more bytes to pad */
 700         for( len = nl->framelen - len;  len--; )
 701                 outb( 0, dev->base_addr + DAT ),
 702                 *crc_p = CRC32( 0, *crc_p );
 703 }
 704
 705
 706 static int
 707 upload_data( struct net_device  *dev,  unsigned  framelen,  unsigned  frameno,
 708              unsigned  is_first,  u32  crc )
 709 {
 710         struct net_local  *nl = netdev_priv(dev);
 711
 712         int  frame_ok;
 713
 714         if( is_first )
 715                 nl->wait_frameno = frameno,
 716                 nl->inppos = 0;
 717
 718         if( nl->wait_frameno == frameno ) {
 719
 720                 if( nl->inppos + framelen  <=  ETHER_MAX_LEN )
 721                         frame_ok = append_frame_to_pkt( dev, framelen, crc );
 722
 723                 /*
 724                  * if CRC is right but framelen incorrect then transmitter
 725                  * error was occurred... drop entire packet
 726                  */
 727                 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
 728                          != 0 )
 729                         nl->wait_frameno = 0,
 730                         nl->inppos = 0,
 731 #ifdef CONFIG_SBNI_MULTILINE
 732                         nl->master->stats.rx_errors++,
 733                         nl->master->stats.rx_missed_errors++;
 734 #else
 735                         dev->stats.rx_errors++,
 736                         dev->stats.rx_missed_errors++;
 737 #endif
 738                         /* now skip all frames until is_first != 0 */
 739         } else
 740                 frame_ok = skip_tail( dev->base_addr, framelen, crc );
 741
 742         if( is_first  &&  !frame_ok )
 743                 /*
 744                  * Frame has been broken, but we had already stored
 745                  * is_first... Drop entire packet.
 746                  */
 747                 nl->wait_frameno = 0,
 748 #ifdef CONFIG_SBNI_MULTILINE
 749                 nl->master->stats.rx_errors++,
 750                 nl->master->stats.rx_crc_errors++;
 751 #else
 752                 dev->stats.rx_errors++,
 753                 dev->stats.rx_crc_errors++;
 754 #endif
 755
 756         return  frame_ok;
 757 }
 758
 759
 760 static inline void
 761 send_complete( struct net_device *dev )
 762 {
 763         struct net_local  *nl = netdev_priv(dev);
 764
 765 #ifdef CONFIG_SBNI_MULTILINE
 766         nl->master->stats.tx_packets++;
 767         nl->master->stats.tx_bytes += nl->tx_buf_p->len;
 768 #else
 769         dev->stats.tx_packets++;
 770         dev->stats.tx_bytes += nl->tx_buf_p->len;
 771 #endif
 772         dev_kfree_skb_irq( nl->tx_buf_p );
 773
 774         nl->tx_buf_p = NULL;
 775
 776         nl->outpos = 0;
 777         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
 778         nl->framelen   = 0;
 779 }
 780
 781
 782 static void
 783 interpret_ack( struct net_device  *dev,  unsigned  ack )
 784 {
 785         struct net_local  *nl = netdev_priv(dev);
 786
 787         if( ack == FRAME_SENT_OK ) {
 788                 nl->state &= ~FL_NEED_RESEND;
 789
 790                 if( nl->state & FL_WAIT_ACK ) {
 791                         nl->outpos += nl->framelen;
 792
 793                         if( --nl->tx_frameno )
 794                                 nl->framelen = min_t(unsigned int,
 795                                                    nl->maxframe,
 796                                                    nl->tx_buf_p->len - nl->outpos);
 797                         else
 798                                 send_complete( dev ),
 799 #ifdef CONFIG_SBNI_MULTILINE
 800                                 netif_wake_queue( nl->master );
 801 #else
 802                                 netif_wake_queue( dev );
 803 #endif
 804                 }
 805         }
 806
 807         nl->state &= ~FL_WAIT_ACK;
 808 }
 809
 810
 811 /*
 812  * Glue received frame with previous fragments of packet.
 813  * Indicate packet when last frame would be accepted.
 814  */
 815
 816 static int
 817 append_frame_to_pkt( struct net_device  *dev,  unsigned  framelen,  u32  crc )
 818 {
 819         struct net_local  *nl = netdev_priv(dev);
 820
 821         u8  *p;
 822
 823         if( nl->inppos + framelen  >  ETHER_MAX_LEN )
 824                 return  0;
 825
 826         if( !nl->rx_buf_p  &&  !(nl->rx_buf_p = get_rx_buf( dev )) )
 827                 return  0;
 828
 829         p = nl->rx_buf_p->data + nl->inppos;
 830         insb( dev->base_addr + DAT, p, framelen );
 831         if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
 832                 return  0;
 833
 834         nl->inppos += framelen - 4;
 835         if( --nl->wait_frameno == 0 )           /* last frame received */
 836                 indicate_pkt( dev );
 837
 838         return  1;
 839 }
 840
 841
 842 /*
 843  * Prepare to start output on adapter.
 844  * Transmitter will be actually activated when marker is accepted.
 845  */
 846
 847 static void
 848 prepare_to_send( struct sk_buff  *skb,  struct net_device  *dev )
 849 {
 850         struct net_local  *nl = netdev_priv(dev);
 851
 852         unsigned int  len;
 853
 854         /* nl->tx_buf_p == NULL here! */
 855         if( nl->tx_buf_p )
 856                 printk( KERN_ERR "%s: memory leak!\n", dev->name );
 857
 858         nl->outpos = 0;
 859         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
 860
 861         len = skb->len;
 862         if( len < SBNI_MIN_LEN )
 863                 len = SBNI_MIN_LEN;
 864
 865         nl->tx_buf_p    = skb;
 866         nl->tx_frameno  = DIV_ROUND_UP(len, nl->maxframe);
 867         nl->framelen    = len < nl->maxframe  ?  len  :  nl->maxframe;
 868
 869         outb( inb( dev->base_addr + CSR0 ) | TR_REQ,  dev->base_addr + CSR0 );
 870 #ifdef CONFIG_SBNI_MULTILINE
 871         nl->master->trans_start = jiffies;
 872 #else
 873         dev->trans_start = jiffies;
 874 #endif
 875 }
 876
 877
 878 static void
 879 drop_xmit_queue( struct net_device  *dev )
 880 {
 881         struct net_local  *nl = netdev_priv(dev);
 882
 883         if( nl->tx_buf_p )
 884                 dev_kfree_skb_any( nl->tx_buf_p ),
 885                 nl->tx_buf_p = NULL,
 886 #ifdef CONFIG_SBNI_MULTILINE
 887                 nl->master->stats.tx_errors++,
 888                 nl->master->stats.tx_carrier_errors++;
 889 #else
 890                 dev->stats.tx_errors++,
 891                 dev->stats.tx_carrier_errors++;
 892 #endif
 893
 894         nl->tx_frameno  = 0;
 895         nl->framelen    = 0;
 896         nl->outpos      = 0;
 897         nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
 898 #ifdef CONFIG_SBNI_MULTILINE
 899         netif_start_queue( nl->master );
 900         nl->master->trans_start = jiffies;
 901 #else
 902         netif_start_queue( dev );
 903         dev->trans_start = jiffies;
 904 #endif
 905 }
 906
 907
 908 static void
 909 send_frame_header( struct net_device  *dev,  u32  *crc_p )
 910 {
 911         struct net_local  *nl  = netdev_priv(dev);
 912
 913         u32  crc = *crc_p;
 914         u32  len_field = nl->framelen + 6;      /* CRC + frameno + reserved */
 915         u8   value;
 916
 917         if( nl->state & FL_NEED_RESEND )
 918                 len_field |= FRAME_RETRY;       /* non-first attempt... */
 919
 920         if( nl->outpos == 0 )
 921                 len_field |= FRAME_FIRST;
 922
 923         len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
 924         outb( SBNI_SIG, dev->base_addr + DAT );
 925
 926         value = (u8) len_field;
 927         outb( value, dev->base_addr + DAT );
 928         crc = CRC32( value, crc );
 929         value = (u8) (len_field >> 8);
 930         outb( value, dev->base_addr + DAT );
 931         crc = CRC32( value, crc );
 932
 933         outb( nl->tx_frameno, dev->base_addr + DAT );
 934         crc = CRC32( nl->tx_frameno, crc );
 935         outb( 0, dev->base_addr + DAT );
 936         crc = CRC32( 0, crc );
 937         *crc_p = crc;
 938 }
 939
 940
 941 /*
 942  * if frame tail not needed (incorrect number or received twice),
 943  * it won't store, but CRC will be calculated
 944  */
 945
 946 static int
 947 skip_tail( unsigned int  ioaddr,  unsigned int  tail_len,  u32 crc )
 948 {
 949         while( tail_len-- )
 950                 crc = CRC32( inb( ioaddr + DAT ), crc );
 951
 952         return  crc == CRC32_REMAINDER;
 953 }
 954
 955
 956 /*
 957  * Preliminary checks if frame header is correct, calculates its CRC
 958  * and split it to simple fields
 959  */
 960
 961 static int
 962 check_fhdr( u32  ioaddr,  u32  *framelen,  u32  *frameno,  u32  *ack,
 963             u32  *is_first,  u32  *crc_p )
 964 {
 965         u32  crc = *crc_p;
 966         u8   value;
 967
 968         if( inb( ioaddr + DAT ) != SBNI_SIG )
 969                 return  0;
 970
 971         value = inb( ioaddr + DAT );
 972         *framelen = (u32)value;
 973         crc = CRC32( value, crc );
 974         value = inb( ioaddr + DAT );
 975         *framelen |= ((u32)value) << 8;
 976         crc = CRC32( value, crc );
 977
 978         *ack = *framelen & FRAME_ACK_MASK;
 979         *is_first = (*framelen & FRAME_FIRST) != 0;
 980
 981         if( (*framelen &= FRAME_LEN_MASK) < 6
 982             ||  *framelen > SBNI_MAX_FRAME - 3 )
 983                 return  0;
 984
 985         value = inb( ioaddr + DAT );
 986         *frameno = (u32)value;
 987         crc = CRC32( value, crc );
 988
 989         crc = CRC32( inb( ioaddr + DAT ), crc );        /* reserved byte */
 990         *framelen -= 2;
 991
 992         *crc_p = crc;
 993         return  1;
 994 }
 995
 996
 997 static struct sk_buff *
 998 get_rx_buf( struct net_device  *dev )
 999 {
1000         /* +2 is to compensate for the alignment fixup below */
1001         struct sk_buff  *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
1002         if( !skb )
1003                 return  NULL;
1004
1005         skb_reserve( skb, 2 );          /* Align IP on longword boundaries */
1006         return  skb;
1007 }
1008
1009
1010 static void
1011 indicate_pkt( struct net_device  *dev )
1012 {
1013         struct net_local  *nl  = netdev_priv(dev);
1014         struct sk_buff    *skb = nl->rx_buf_p;
1015
1016         skb_put( skb, nl->inppos );
1017
1018 #ifdef CONFIG_SBNI_MULTILINE
1019         skb->protocol = eth_type_trans( skb, nl->master );
1020         netif_rx( skb );
1021         ++nl->master->stats.rx_packets;
1022         nl->master->stats.rx_bytes += nl->inppos;
1023 #else
1024         skb->protocol = eth_type_trans( skb, dev );
1025         netif_rx( skb );
1026         ++dev->stats.rx_packets;
1027         dev->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( &dev->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( &slave_dev->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 static void
1468 set_multicast_list( struct net_device  *dev )
1469 {
1470         return;         /* sbni always operate in promiscuos mode */
1471 }
1472
1473
1474 #ifdef MODULE
1475 module_param_array(io, int, NULL, 0);
1476 module_param_array(irq, int, NULL, 0);
1477 module_param_array(baud, int, NULL, 0);
1478 module_param_array(rxl, int, NULL, 0);
1479 module_param_array(mac, int, NULL, 0);
1480 module_param(skip_pci_probe, bool, 0);
1481
1482 MODULE_LICENSE("GPL");
1483
1484
1485 int __init init_module( void )
1486 {
1487         struct net_device  *dev;
1488         int err;
1489
1490         while( num < SBNI_MAX_NUM_CARDS ) {
1491                 dev = alloc_netdev(sizeof(struct net_local),
1492                                    "sbni%d", sbni_devsetup);
1493                 if( !dev)
1494                         break;
1495
1496                 sprintf( dev->name, "sbni%d", num );
1497
1498                 err = sbni_init(dev);
1499                 if (err) {
1500                         free_netdev(dev);
1501                         break;
1502                 }
1503
1504                 if( register_netdev( dev ) ) {
1505                         release_region( dev->base_addr, SBNI_IO_EXTENT );
1506                         free_netdev( dev );
1507                         break;
1508                 }
1509         }
1510
1511         return  *sbni_cards  ?  0  :  -ENODEV;
1512 }
1513
1514 void
1515 cleanup_module(void)
1516 {
1517         int i;
1518
1519         for (i = 0;  i < SBNI_MAX_NUM_CARDS;  ++i) {
1520                 struct net_device *dev = sbni_cards[i];
1521                 if (dev != NULL) {
1522                         unregister_netdev(dev);
1523                         release_region(dev->base_addr, SBNI_IO_EXTENT);
1524                         free_netdev(dev);
1525                 }
1526         }
1527 }
1528
1529 #else   /* MODULE */
1530
1531 static int __init
1532 sbni_setup( char  *p )
1533 {
1534         int  n, parm;
1535
1536         if( *p++ != '(' )
1537                 goto  bad_param;
1538
1539         for( n = 0, parm = 0;  *p  &&  n < 8; ) {
1540                 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1541                 if( !*p  ||  *p == ')' )
1542                         return 1;
1543                 if( *p == ';' )
1544                         ++p, ++n, parm = 0;
1545                 else if( *p++ != ',' )
1546                         break;
1547                 else
1548                         if( ++parm >= 5 )
1549                                 break;
1550         }
1551 bad_param:
1552         printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1553         return 0;
1554 }
1555
1556 __setup( "sbni=", sbni_setup );
1557
1558 #endif  /* MODULE */
1559
1560 /* -------------------------------------------------------------------------- */
1561
1562 #ifdef ASM_CRC
1563
1564 static u32
1565 calc_crc32( u32  crc,  u8  *p,  u32  len )
1566 {
1567         register u32  _crc;
1568         _crc = crc;
1569
1570         __asm__ __volatile__ (
1571                 "xorl   %%ebx, %%ebx\n"
1572                 "movl   %2, %%esi\n"
1573                 "movl   %3, %%ecx\n"
1574                 "movl   $crc32tab, %%edi\n"
1575                 "shrl   $2, %%ecx\n"
1576                 "jz     1f\n"
1577
1578                 ".align 4\n"
1579         "0:\n"
1580                 "movb   %%al, %%bl\n"
1581                 "movl   (%%esi), %%edx\n"
1582                 "shrl   $8, %%eax\n"
1583                 "xorb   %%dl, %%bl\n"
1584                 "shrl   $8, %%edx\n"
1585                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1586
1587                 "movb   %%al, %%bl\n"
1588                 "shrl   $8, %%eax\n"
1589                 "xorb   %%dl, %%bl\n"
1590                 "shrl   $8, %%edx\n"
1591                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1592
1593                 "movb   %%al, %%bl\n"
1594                 "shrl   $8, %%eax\n"
1595                 "xorb   %%dl, %%bl\n"
1596                 "movb   %%dh, %%dl\n"
1597                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1598
1599                 "movb   %%al, %%bl\n"
1600                 "shrl   $8, %%eax\n"
1601                 "xorb   %%dl, %%bl\n"
1602                 "addl   $4, %%esi\n"
1603                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1604
1605                 "decl   %%ecx\n"
1606                 "jnz    0b\n"
1607
1608         "1:\n"
1609                 "movl   %3, %%ecx\n"
1610                 "andl   $3, %%ecx\n"
1611                 "jz     2f\n"
1612
1613                 "movb   %%al, %%bl\n"
1614                 "shrl   $8, %%eax\n"
1615                 "xorb   (%%esi), %%bl\n"
1616                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1617
1618                 "decl   %%ecx\n"
1619                 "jz     2f\n"
1620
1621                 "movb   %%al, %%bl\n"
1622                 "shrl   $8, %%eax\n"
1623                 "xorb   1(%%esi), %%bl\n"
1624                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1625
1626                 "decl   %%ecx\n"
1627                 "jz     2f\n"
1628
1629                 "movb   %%al, %%bl\n"
1630                 "shrl   $8, %%eax\n"
1631                 "xorb   2(%%esi), %%bl\n"
1632                 "xorl   (%%edi,%%ebx,4), %%eax\n"
1633         "2:\n"
1634                 : "=a" (_crc)
1635                 : "0" (_crc), "g" (p), "g" (len)
1636                 : "bx", "cx", "dx", "si", "di"
1637         );
1638
1639         return  _crc;
1640 }
1641
1642 #else   /* ASM_CRC */
1643
1644 static u32
1645 calc_crc32( u32  crc,  u8  *p,  u32  len )
1646 {
1647         while( len-- )
1648                 crc = CRC32( *p++, crc );
1649
1650         return  crc;
1651 }
1652
1653 #endif  /* ASM_CRC */
1654
1655
1656 static u32  crc32tab[] __attribute__ ((aligned(8))) = {
1657         0xD202EF8D,  0xA505DF1B,  0x3C0C8EA1,  0x4B0BBE37,
1658         0xD56F2B94,  0xA2681B02,  0x3B614AB8,  0x4C667A2E,
1659         0xDCD967BF,  0xABDE5729,  0x32D70693,  0x45D03605,
1660         0xDBB4A3A6,  0xACB39330,  0x35BAC28A,  0x42BDF21C,
1661         0xCFB5FFE9,  0xB8B2CF7F,  0x21BB9EC5,  0x56BCAE53,
1662         0xC8D83BF0,  0xBFDF0B66,  0x26D65ADC,  0x51D16A4A,
1663         0xC16E77DB,  0xB669474D,  0x2F6016F7,  0x58672661,
1664         0xC603B3C2,  0xB1048354,  0x280DD2EE,  0x5F0AE278,
1665         0xE96CCF45,  0x9E6BFFD3,  0x0762AE69,  0x70659EFF,
1666         0xEE010B5C,  0x99063BCA,  0x000F6A70,  0x77085AE6,
1667         0xE7B74777,  0x90B077E1,  0x09B9265B,  0x7EBE16CD,
1668         0xE0DA836E,  0x97DDB3F8,  0x0ED4E242,  0x79D3D2D4,
1669         0xF4DBDF21,  0x83DCEFB7,  0x1AD5BE0D,  0x6DD28E9B,
1670         0xF3B61B38,  0x84B12BAE,  0x1DB87A14,  0x6ABF4A82,
1671         0xFA005713,  0x8D076785,  0x140E363F,  0x630906A9,
1672         0xFD6D930A,  0x8A6AA39C,  0x1363F226,  0x6464C2B0,
1673         0xA4DEAE1D,  0xD3D99E8B,  0x4AD0CF31,  0x3DD7FFA7,
1674         0xA3B36A04,  0xD4B45A92,  0x4DBD0B28,  0x3ABA3BBE,
1675         0xAA05262F,  0xDD0216B9,  0x440B4703,  0x330C7795,
1676         0xAD68E236,  0xDA6FD2A0,  0x4366831A,  0x3461B38C,
1677         0xB969BE79,  0xCE6E8EEF,  0x5767DF55,  0x2060EFC3,
1678         0xBE047A60,  0xC9034AF6,  0x500A1B4C,  0x270D2BDA,
1679         0xB7B2364B,  0xC0B506DD,  0x59BC5767,  0x2EBB67F1,
1680         0xB0DFF252,  0xC7D8C2C4,  0x5ED1937E,  0x29D6A3E8,
1681         0x9FB08ED5,  0xE8B7BE43,  0x71BEEFF9,  0x06B9DF6F,
1682         0x98DD4ACC,  0xEFDA7A5A,  0x76D32BE0,  0x01D41B76,
1683         0x916B06E7,  0xE66C3671,  0x7F6567CB,  0x0862575D,
1684         0x9606C2FE,  0xE101F268,  0x7808A3D2,  0x0F0F9344,
1685         0x82079EB1,  0xF500AE27,  0x6C09FF9D,  0x1B0ECF0B,
1686         0x856A5AA8,  0xF26D6A3E,  0x6B643B84,  0x1C630B12,
1687         0x8CDC1683,  0xFBDB2615,  0x62D277AF,  0x15D54739,
1688         0x8BB1D29A,  0xFCB6E20C,  0x65BFB3B6,  0x12B88320,
1689         0x3FBA6CAD,  0x48BD5C3B,  0xD1B40D81,  0xA6B33D17,
1690         0x38D7A8B4,  0x4FD09822,  0xD6D9C998,  0xA1DEF90E,
1691         0x3161E49F,  0x4666D409,  0xDF6F85B3,  0xA868B525,
1692         0x360C2086,  0x410B1010,  0xD80241AA,  0xAF05713C,
1693         0x220D7CC9,  0x550A4C5F,  0xCC031DE5,  0xBB042D73,
1694         0x2560B8D0,  0x52678846,  0xCB6ED9FC,  0xBC69E96A,
1695         0x2CD6F4FB,  0x5BD1C46D,  0xC2D895D7,  0xB5DFA541,
1696         0x2BBB30E2,  0x5CBC0074,  0xC5B551CE,  0xB2B26158,
1697         0x04D44C65,  0x73D37CF3,  0xEADA2D49,  0x9DDD1DDF,
1698         0x03B9887C,  0x74BEB8EA,  0xEDB7E950,  0x9AB0D9C6,
1699         0x0A0FC457,  0x7D08F4C1,  0xE401A57B,  0x930695ED,
1700         0x0D62004E,  0x7A6530D8,  0xE36C6162,  0x946B51F4,
1701         0x19635C01,  0x6E646C97,  0xF76D3D2D,  0x806A0DBB,
1702         0x1E0E9818,  0x6909A88E,  0xF000F934,  0x8707C9A2,
1703         0x17B8D433,  0x60BFE4A5,  0xF9B6B51F,  0x8EB18589,
1704         0x10D5102A,  0x67D220BC,  0xFEDB7106,  0x89DC4190,
1705         0x49662D3D,  0x3E611DAB,  0xA7684C11,  0xD06F7C87,
1706         0x4E0BE924,  0x390CD9B2,  0xA0058808,  0xD702B89E,
1707         0x47BDA50F,  0x30BA9599,  0xA9B3C423,  0xDEB4F4B5,
1708         0x40D06116,  0x37D75180,  0xAEDE003A,  0xD9D930AC,
1709         0x54D13D59,  0x23D60DCF,  0xBADF5C75,  0xCDD86CE3,
1710         0x53BCF940,  0x24BBC9D6,  0xBDB2986C,  0xCAB5A8FA,
1711         0x5A0AB56B,  0x2D0D85FD,  0xB404D447,  0xC303E4D1,
1712         0x5D677172,  0x2A6041E4,  0xB369105E,  0xC46E20C8,
1713         0x72080DF5,  0x050F3D63,  0x9C066CD9,  0xEB015C4F,
1714         0x7565C9EC,  0x0262F97A,  0x9B6BA8C0,  0xEC6C9856,
1715         0x7CD385C7,  0x0BD4B551,  0x92DDE4EB,  0xE5DAD47D,
1716         0x7BBE41DE,  0x0CB97148,  0x95B020F2,  0xE2B71064,
1717         0x6FBF1D91,  0x18B82D07,  0x81B17CBD,  0xF6B64C2B,
1718         0x68D2D988,  0x1FD5E91E,  0x86DCB8A4,  0xF1DB8832,
1719         0x616495A3,  0x1663A535,  0x8F6AF48F,  0xF86DC419,
1720         0x660951BA,  0x110E612C,  0x88073096,  0xFF000000
1721 };
1722