drivers/net/wan/sbni.c

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

DEFINITIONS
