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