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