SAFE public projects git trees. - safe/jmp/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/net_namespace.h>
  58 #include <net/arp.h>
  59
  60 #include <asm/io.h>
  61 #include <asm/types.h>
  62 #include <asm/byteorder.h>
  63 #include <asm/irq.h>
  64 #include <asm/uaccess.h>
  65
  66 #include "sbni.h"
  67
  68 /* device private data */
  69
  70 struct net_local {
  71         struct net_device_stats stats;
  72         struct timer_list       watchdog;
  73
  74         spinlock_t      lock;
  75         struct sk_buff  *rx_buf_p;              /* receive buffer ptr */
  76         struct sk_buff  *tx_buf_p;              /* transmit buffer ptr */
  77
  78         unsigned int    framelen;               /* current frame length */
  79         unsigned int    maxframe;               /* maximum valid frame length */
  80         unsigned int    state;
  81         unsigned int    inppos, outpos;         /* positions in rx/tx buffers */
  82
  83         /* transmitting frame number - from frames qty to 1 */
  84         unsigned int    tx_frameno;
  85
  86         /* expected number of next receiving frame */
  87         unsigned int    wait_frameno;
  88
  89         /* count of failed attempts to frame send - 32 attempts do before
  90            error - while receiver tunes on opposite side of wire */
  91         unsigned int    trans_errors;
  92
  93         /* idle time; send pong when limit exceeded */
  94         unsigned int    timer_ticks;
  95
  96         /* fields used for receive level autoselection */
  97         int     delta_rxl;
  98         unsigned int    cur_rxl_index, timeout_rxl;
  99         unsigned long   cur_rxl_rcvd, prev_rxl_rcvd;
 100
 101         struct sbni_csr1        csr1;           /* current value of CSR1 */
 102         struct sbni_in_stats    in_stats;       /* internal statistics */
 103
 104         struct net_device               *second;        /* for ISA/dual cards */
 105
 106 #ifdef CONFIG_SBNI_MULTILINE
 107         struct net_device               *master;
 108         struct net_device               *link;
 109 #endif
 110 };
 111
 112
 113 static int  sbni_card_probe( unsigned long );
 114 static int  sbni_pci_probe( struct net_device  * );
 115 static struct net_device  *sbni_probe1(struct net_device *, unsigned long, int);
 116 static int  sbni_open( struct net_device * );
 117 static int  sbni_close( struct net_device * );
 118 static int  sbni_start_xmit( struct sk_buff *, struct net_device * );
 119 static int  sbni_ioctl( struct net_device *, struct ifreq *, int );
 120 static struct net_device_stats  *sbni_get_stats( struct net_device * );
 121 static void  set_multicast_list( struct net_device * );
 122
 123 static irqreturn_t sbni_interrupt( int, void * );
 124 static void  handle_channel( struct net_device * );
 125 static int   recv_frame( struct net_device * );
 126 static void  send_frame( struct net_device * );
 127 static int   upload_data( struct net_device *,
 128                           unsigned, unsigned, unsigned, u32 );
 129 static void  download_data( struct net_device *, u32 * );
 130 static void  sbni_watchdog( unsigned long );
 131 static void  interpret_ack( struct net_device *, unsigned );
 132 static int   append_frame_to_pkt( struct net_device *, unsigned, u32 );
 133 static void  indicate_pkt( struct net_device * );
 134 static void  card_start( struct net_device * );
 135 static void  prepare_to_send( struct sk_buff *, struct net_device * );
 136 static void  drop_xmit_queue( struct net_device * );
 137 static void  send_frame_header( struct net_device *, u32 * );
 138 static int   skip_tail( unsigned int, unsigned int, u32 );
 139 static int   check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
 140 static void  change_level( struct net_device * );
 141 static void  timeout_change_level( struct net_device * );
 142 static u32   calc_crc32( u32, u8 *, u32 );
 143 static struct sk_buff *  get_rx_buf( struct net_device * );
 144 static int  sbni_init( struct net_device * );
 145
 146 #ifdef CONFIG_SBNI_MULTILINE
 147 static int  enslave( struct net_device *, struct net_device * );
 148 static int  emancipate( struct net_device * );
 149 #endif
 150
 151 #ifdef __i386__
 152 #define ASM_CRC 1
 153 #endif
 154
 155 static const char  version[] =
 156         "Granch SBNI12 driver ver 5.0.1  Jun 22 2001  Denis I.Timofeev.\n";
 157
 158 static int  skip_pci_probe      __initdata = 0;
 159 static int  scandone    __initdata = 0;
 160 static int  num         __initdata = 0;
 161
 162 static unsigned char  rxl_tab[];
 163 static u32  crc32tab[];
 164
 165 /* A list of all installed devices, for removing the driver module. */
 166 static struct net_device  *sbni_cards[ SBNI_MAX_NUM_CARDS ];
 167
 168 /* Lists of device's parameters */
 169 static u32      io[   SBNI_MAX_NUM_CARDS ] __initdata =
 170         { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
 171 static u32      irq[  SBNI_MAX_NUM_CARDS ] __initdata;
 172 static u32      baud[ SBNI_MAX_NUM_CARDS ] __initdata;
 173 static u32      rxl[  SBNI_MAX_NUM_CARDS ] __initdata =
 174         { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
 175 static u32      mac[  SBNI_MAX_NUM_CARDS ] __initdata;
 176
 177 #ifndef MODULE
 178 typedef u32  iarr[];
 179 static iarr __initdata *dest[5] = { &io, &irq, &baud, &rxl, &mac };
 180 #endif
 181
 182 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
 183 static unsigned int  netcard_portlist[ ] __initdata = {
 184         0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
 185         0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
 186         0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
 187         0 };
 188
 189
 190 /*
 191  * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
 192  * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
 193  */
 194
 195 static inline int __init
 196 sbni_isa_probe( struct net_device  *dev )
 197 {
 198         if( dev->base_addr > 0x1ff
 199             &&  request_region( dev->base_addr, SBNI_IO_EXTENT, dev->name )
 200             &&  sbni_probe1( dev, dev->base_addr, dev->irq ) )
 201
 202                 return  0;
 203         else {
 204                 printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
 205                         "is malfunctional!\n", dev->base_addr );
 206                 return  -ENODEV;
 207         }
 208 }
 209
 210 static void __init sbni_devsetup(struct net_device *dev)
 211 {
 212         ether_setup( dev );
 213         dev->open               = &sbni_open;
 214         dev->stop               = &sbni_close;
 215         dev->hard_start_xmit    = &sbni_start_xmit;
 216         dev->get_stats          = &sbni_get_stats;
 217         dev->set_multicast_list = &set_multicast_list;
 218         dev->do_ioctl           = &sbni_ioctl;
 219
 220         SET_MODULE_OWNER( dev );
 221 }
 222
 223 int __init sbni_probe(int unit)
 224 {
 225         struct net_device *dev;
 226         static unsigned  version_printed __initdata = 0;
 227         int err;
 228
 229         dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
 230         if (!dev)
 231                 return -ENOMEM;
 232
 233         sprintf(dev->name, "sbni%d", unit);
 234         netdev_boot_setup_check(dev);
 235
 236         err = sbni_init(dev);
 237         if (err) {
 238                 free_netdev(dev);
 239                 return err;
 240         }
 241
 242         err = register_netdev(dev);
 243         if (err) {
 244                 release_region( dev->base_addr, SBNI_IO_EXTENT );
 245                 free_netdev(dev);
 246                 return err;
 247         }
 248         if( version_printed++ == 0 )
 249                 printk( KERN_INFO "%s", version );
 250         return 0;
 251 }
 252
 253 static int __init sbni_init(struct net_device *dev)
 254 {
 255         int  i;
 256         if( dev->base_addr )
 257                 return  sbni_isa_probe( dev );
 258         /* otherwise we have to perform search our adapter */
 259
 260         if( io[ num ] != -1 )
 261                 dev->base_addr  = io[ num ],
 262                 dev->irq        = irq[ num ];
 263         else if( scandone  ||  io[ 0 ] != -1 )
 264                 return  -ENODEV;
 265
 266         /* if io[ num ] contains non-zero address, then that is on ISA bus */
 267         if( dev->base_addr )
 268                 return  sbni_isa_probe( dev );
 269
 270         /* ...otherwise - scan PCI first */
 271         if( !skip_pci_probe  &&  !sbni_pci_probe( dev ) )
 272                 return  0;
 273
 274         if( io[ num ] == -1 ) {
 275                 /* Auto-scan will be stopped when first ISA card were found */
 276                 scandone = 1;
 277                 if( num > 0 )
 278                         return  -ENODEV;
 279         }
 280
 281         for( i = 0;  netcard_portlist[ i ];  ++i ) {
 282                 int  ioaddr = netcard_portlist[ i ];
 283                 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
 284                     &&  sbni_probe1( dev, ioaddr, 0 ))
 285                         return 0;
 286         }
 287
 288         return  -ENODEV;
 289 }
 290
 291
 292 int __init
 293 sbni_pci_probe( struct net_device  *dev )
 294 {
 295         struct pci_dev  *pdev = NULL;
 296
 297         while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
 298                != NULL ) {
 299                 int  pci_irq_line;
 300                 unsigned long  pci_ioaddr;
 301                 u16  subsys;
 302
 303                 if( pdev->vendor != SBNI_PCI_VENDOR
 304                     &&  pdev->device != SBNI_PCI_DEVICE )
 305                                 continue;
 306
 307                 pci_ioaddr = pci_resource_start( pdev, 0 );
 308                 pci_irq_line = pdev->irq;
 309
 310                 /* Avoid already found cards from previous calls */
 311                 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
 312                         pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
 313
 314                         if (subsys != 2)
 315                                 continue;
 316
 317                         /* Dual adapter is present */
 318                         if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
 319                                                         dev->name ) )
 320                                 continue;
 321                 }
 322
 323                 if( pci_irq_line <= 0  ||  pci_irq_line >= NR_IRQS )
 324                         printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
 325                                 "this PCI card to IRQ %d, which is unlikely "
 326                                 "to work!.\n"
 327                                 KERN_WARNING " You should use the PCI BIOS "
 328                                 "setup to assign a valid IRQ line.\n",
 329                                 pci_irq_line );
 330
 331                 /* avoiding re-enable dual adapters */
 332                 if( (pci_ioaddr & 7) == 0  &&  pci_enable_device( pdev ) ) {
 333                         release_region( pci_ioaddr, SBNI_IO_EXTENT );
 334                         pci_dev_put( pdev );
 335                         return  -EIO;
 336                 }
 337                 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
 338                         SET_NETDEV_DEV(dev, &pdev->dev);
 339                         /* not the best thing to do, but this is all messed up
 340                            for hotplug systems anyway... */
 341                         pci_dev_put( pdev );
 342                         return  0;
 343                 }
 344         }
 345         return  -ENODEV;
 346 }
 347
 348
 349 static struct net_device * __init
 350 sbni_probe1( struct net_device  *dev,  unsigned long  ioaddr,  int  irq )
 351 {
 352         struct net_local  *nl;
 353
 354         if( sbni_card_probe( ioaddr ) ) {
 355                 release_region( ioaddr, SBNI_IO_EXTENT );
 356                 return NULL;
 357         }
 358
 359         outb( 0, ioaddr + CSR0 );
 360
 361         if( irq < 2 ) {
 362                 unsigned long irq_mask;
 363
 364                 irq_mask = probe_irq_on();
 365                 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
 366                 outb( PR_RES, ioaddr + CSR1 );
 367                 mdelay(50);
 368                 irq = probe_irq_off(irq_mask);
 369                 outb( 0, ioaddr + CSR0 );
 370
 371                 if( !irq ) {
 372                         printk( KERN_ERR "%s: can't detect device irq!\n",
 373                                 dev->name );
 374                         release_region( ioaddr, SBNI_IO_EXTENT );
 375                         return NULL;
 376                 }
 377         } else if( irq == 2 )
 378                 irq = 9;
 379
 380         dev->irq = irq;
 381         dev->base_addr = ioaddr;
 382
 383         /* Allocate dev->priv and fill in sbni-specific dev fields. */
 384         nl = dev->priv;
 385         if( !nl ) {
 386                 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
 387                 release_region( ioaddr, SBNI_IO_EXTENT );
 388                 return NULL;
 389         }
 390
 391         dev->priv = nl;
 392         memset( nl, 0, sizeof(struct net_local) );
 393         spin_lock_init( &nl->lock );
 394
 395         /* store MAC address (generate if that isn't known) */
 396         *(u16 *)dev->dev_addr = htons( 0x00ff );
 397         *(u32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
 398                 ( (mac[num]  ?  mac[num]  :  (u32)((long)dev->priv)) & 0x00ffffff) );
 399
 400         /* store link settings (speed, receive level ) */
 401         nl->maxframe  = DEFAULT_FRAME_LEN;
 402         nl->csr1.rate = baud[ num ];
 403
 404         if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
 405                 /* autotune rxl */
 406                 nl->cur_rxl_index = DEF_RXL,
 407                 nl->delta_rxl = DEF_RXL_DELTA;
 408         else
 409                 nl->delta_rxl = 0;
 410         nl->csr1.rxl  = rxl_tab[ nl->cur_rxl_index ];
 411         if( inb( ioaddr + CSR0 ) & 0x01 )
 412                 nl->state |= FL_SLOW_MODE;
 413
 414         printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
 415                 "MAC: 00:ff:01:%02x:%02x:%02x\n",
 416                 dev->name, dev->base_addr, dev->irq,
 417                 ((u8 *) dev->dev_addr) [3],
 418                 ((u8 *) dev->dev_addr) [4],
 419                 ((u8 *) dev->dev_addr) [5] );
 420
 421         printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
 422                 ( (nl->state & FL_SLOW_MODE)  ?  500000 : 2000000)
 423                 / (1 << nl->csr1.rate) );
 424
 425         if( nl->delta_rxl == 0 )
 426                 printk( "0x%x (fixed)\n", nl->cur_rxl_index );
 427         else
 428                 printk( "(auto)\n");
 429
 430 #ifdef CONFIG_SBNI_MULTILINE
 431         nl->master = dev;
 432         nl->link   = NULL;
 433 #endif
 434
 435         sbni_cards[ num++ ] = dev;
 436         return  dev;
 437 }
 438
 439 /* -------------------------------------------------------------------------- */
 440
 441 #ifdef CONFIG_SBNI_MULTILINE
 442
 443 static int
 444 sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
 445 {
 446         struct net_device  *p;
 447
 448         netif_stop_queue( dev );
 449
 450         /* Looking for idle device in the list */
 451         for( p = dev;  p; ) {
 452                 struct net_local  *nl = (struct net_local *) p->priv;
 453                 spin_lock( &nl->lock );
 454                 if( nl->tx_buf_p  ||  (nl->state & FL_LINE_DOWN) ) {
 455                         p = nl->link;
 456                         spin_unlock( &nl->lock );
 457                 } else {
 458                         /* Idle dev is found */
 459                         prepare_to_send( skb, p );
 460                         spin_unlock( &nl->lock );
 461                         netif_start_queue( dev );
 462                         return  0;
 463                 }
 464         }
 465
 466         return  1;
 467 }
 468
 469 #else   /* CONFIG_SBNI_MULTILINE */
 470
 471 static int
 472 sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
 473 {
 474         struct net_local  *nl  = (struct net_local *) dev->priv;
 475
 476         netif_stop_queue( dev );
 477         spin_lock( &nl->lock );
 478
 479         prepare_to_send( skb, dev );
 480
 481         spin_unlock( &nl->lock );
 482         return  0;
 483 }
 484
 485 #endif  /* CONFIG_SBNI_MULTILINE */
 486
 487 /* -------------------------------------------------------------------------- */
 488
 489 /* interrupt handler */
 490
 491 /*
 492  *      SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
 493  * be looked as two independent single-channel devices. Every channel seems
 494  * as Ethernet interface but interrupt handler must be common. Really, first
 495  * channel ("master") driver only registers the handler. In its struct net_local
 496  * it has got pointer to "slave" channel's struct net_local and handles that's
 497  * interrupts too.
 498  *      dev of successfully attached ISA SBNI boards is linked to list.
 499  * While next board driver is initialized, it scans this list. If one
 500  * has found dev with same irq and ioaddr different by 4 then it assumes
 501  * this board to be "master".
 502  */
 503
 504 static irqreturn_t
 505 sbni_interrupt( int  irq,  void  *dev_id )
 506 {
 507         struct net_device         *dev = (struct net_device *) dev_id;
 508         struct net_local  *nl  = (struct net_local *) dev->priv;
 509         int     repeat;
 510
 511         spin_lock( &nl->lock );
 512         if( nl->second )
 513                 spin_lock( &((struct net_local *) nl->second->priv)->lock );
 514
 515         do {
 516                 repeat = 0;
 517                 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
 518                         handle_channel( dev ),
 519                         repeat = 1;
 520                 if( nl->second  &&      /* second channel present */
 521                     (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
 522                         handle_channel( nl->second ),
 523                         repeat = 1;
 524         } while( repeat );
 525
 526         if( nl->second )
 527                 spin_unlock( &((struct net_local *)nl->second->priv)->lock );
 528         spin_unlock( &nl->lock );
 529         return IRQ_HANDLED;
 530 }
 531
 532
 533 static void
 534 handle_channel( struct net_device  *dev )
 535 {
 536         struct net_local        *nl    = (struct net_local *) dev->priv;
 537         unsigned long           ioaddr = dev->base_addr;
 538
 539         int  req_ans;
 540         unsigned char  csr0;
 541
 542 #ifdef CONFIG_SBNI_MULTILINE
 543         /* Lock the master device because we going to change its local data */
 544         if( nl->state & FL_SLAVE )
 545                 spin_lock( &((struct net_local *) nl->master->priv)->lock );
 546 #endif
 547
 548         outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
 549
 550         nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
 551         for(;;) {
 552                 csr0 = inb( ioaddr + CSR0 );
 553                 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
 554                         break;
 555
 556                 req_ans = !(nl->state & FL_PREV_OK);
 557
 558                 if( csr0 & RC_RDY )
 559                         req_ans = recv_frame( dev );
 560
 561                 /*
 562                  * TR_RDY always equals 1 here because we have owned the marker,
 563                  * and we set TR_REQ when disabled interrupts
 564                  */
 565                 csr0 = inb( ioaddr + CSR0 );
 566                 if( !(csr0 & TR_RDY)  ||  (csr0 & RC_RDY) )
 567                         printk( KERN_ERR "%s: internal error!\n", dev->name );
 568
 569                 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
 570                 if( req_ans  ||  nl->tx_frameno != 0 )
 571                         send_frame( dev );
 572                 else
 573                         /* send marker without any data */
 574                         outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
 575         }
 576
 577         outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
 578
 579 #ifdef CONFIG_SBNI_MULTILINE
 580         if( nl->state & FL_SLAVE )
 581                 spin_unlock( &((struct net_local *) nl->master->priv)->lock );
 582 #endif
 583 }
 584
 585
 586 /*
 587  * Routine returns 1 if it need to acknoweledge received frame.
 588  * Empty frame received without errors won't be acknoweledged.
 589  */
 590
 591 static int
 592 recv_frame( struct net_device  *dev )
 593 {
 594         struct net_local  *nl   = (struct net_local *) dev->priv;
 595         unsigned long  ioaddr   = dev->base_addr;
 596
 597         u32  crc = CRC32_INITIAL;
 598
 599         unsigned  framelen = 0, frameno, ack;
 600         unsigned  is_first, frame_ok = 0;
 601
 602         if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
 603                 frame_ok = framelen > 4
 604                         ?  upload_data( dev, framelen, frameno, is_first, crc )
 605                         :  skip_tail( ioaddr, framelen, crc );
 606                 if( frame_ok )
 607                         interpret_ack( dev, ack );
 608         }
 609
 610         outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
 611         if( frame_ok ) {
 612                 nl->state |= FL_PREV_OK;
 613                 if( framelen > 4 )
 614                         nl->in_stats.all_rx_number++;
 615         } else
 616                 nl->state &= ~FL_PREV_OK,
 617                 change_level( dev ),
 618                 nl->in_stats.all_rx_number++,
 619                 nl->in_stats.bad_rx_number++;
 620
 621         return  !frame_ok  ||  framelen > 4;
 622 }
 623
 624
 625 static void
 626 send_frame( struct net_device  *dev )
 627 {
 628         struct net_local  *nl    = (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(&init_net, 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