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