1/* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0 2 * driver for linux. 3 */ 4 5/* 6 Written 1996 by Russell Nelson, with reference to skeleton.c 7 written 1993-1994 by Donald Becker. 8 9 This software may be used and distributed according to the terms 10 of the GNU General Public License, incorporated herein by reference. 11 12 The author may be reached at nelson@crynwr.com, Crynwr 13 Software, 521 Pleasant Valley Rd., Potsdam, NY 13676 14 15 Changelog: 16 17 Mike Cruse : mcruse@cti-ltd.com 18 : Changes for Linux 2.0 compatibility. 19 : Added dev_id parameter in net_interrupt(), 20 : request_irq() and free_irq(). Just NULL for now. 21 22 Mike Cruse : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros 23 : in net_open() and net_close() so kerneld would know 24 : that the module is in use and wouldn't eject the 25 : driver prematurely. 26 27 Mike Cruse : Rewrote init_module() and cleanup_module using 8390.c 28 : as an example. Disabled autoprobing in init_module(), 29 : not a good thing to do to other devices while Linux 30 : is running from all accounts. 31 32 Russ Nelson : Jul 13 1998. Added RxOnly DMA support. 33 34 Melody Lee : Aug 10 1999. Changes for Linux 2.2.5 compatibility. 35 : email: ethernet@crystal.cirrus.com 36 37 Alan Cox : Removed 1.2 support, added 2.1 extra counters. 38 39 Andrew Morton : Kernel 2.3.48 40 : Handle kmalloc() failures 41 : Other resource allocation fixes 42 : Add SMP locks 43 : Integrate Russ Nelson's ALLOW_DMA functionality back in. 44 : If ALLOW_DMA is true, make DMA runtime selectable 45 : Folded in changes from Cirrus (Melody Lee 46 : <klee@crystal.cirrus.com>) 47 : Don't call netif_wake_queue() in net_send_packet() 48 : Fixed an out-of-mem bug in dma_rx() 49 : Updated Documentation/networking/cs89x0.txt 50 51 Andrew Morton : Kernel 2.3.99-pre1 52 : Use skb_reserve to longword align IP header (two places) 53 : Remove a delay loop from dma_rx() 54 : Replace '100' with HZ 55 : Clean up a couple of skb API abuses 56 : Added 'cs89x0_dma=N' kernel boot option 57 : Correctly initialise lp->lock in non-module compile 58 59 Andrew Morton : Kernel 2.3.99-pre4-1 60 : MOD_INC/DEC race fix (see 61 : http://www.uwsg.indiana.edu/hypermail/linux/kernel/0003.3/1532.html) 62 63 Andrew Morton : Kernel 2.4.0-test7-pre2 64 : Enhanced EEPROM support to cover more devices, 65 : abstracted IRQ mapping to support CONFIG_ARCH_CLPS7500 arch 66 : (Jason Gunthorpe <jgg@ualberta.ca>) 67 68 Andrew Morton : Kernel 2.4.0-test11-pre4 69 : Use dev->name in request_*() (Andrey Panin) 70 : Fix an error-path memleak in init_module() 71 : Preserve return value from request_irq() 72 : Fix type of `media' module parm (Keith Owens) 73 : Use SET_MODULE_OWNER() 74 : Tidied up strange request_irq() abuse in net_open(). 75 76 Andrew Morton : Kernel 2.4.3-pre1 77 : Request correct number of pages for DMA (Hugh Dickens) 78 : Select PP_ChipID _after_ unregister_netdev in cleanup_module() 79 : because unregister_netdev() calls get_stats. 80 : Make `version[]' __initdata 81 : Uninlined the read/write reg/word functions. 82 83 Oskar Schirmer : oskar@scara.com 84 : HiCO.SH4 (superh) support added (irq#1, cs89x0_media=) 85 86 Deepak Saxena : dsaxena@plexity.net 87 : Intel IXDP2x01 (XScale ixp2x00 NPU) platform support 88 89 Dmitry Pervushin : dpervushin@ru.mvista.com 90 : PNX010X platform support 91 92 Deepak Saxena : dsaxena@plexity.net 93 : Intel IXDP2351 platform support 94 95 Dmitry Pervushin : dpervushin@ru.mvista.com 96 : PNX010X platform support 97 98*/ 99 100/* Always include 'config.h' first in case the user wants to turn on 101 or override something. */ 102#include <linux/module.h> 103 104/* 105 * Set this to zero to disable DMA code 106 * 107 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma' 108 * module options so we don't break any startup scripts. 109 */ 110#ifndef CONFIG_ISA_DMA_API 111#define ALLOW_DMA 0 112#else 113#define ALLOW_DMA 1 114#endif 115 116/* 117 * Set this to zero to remove all the debug statements via 118 * dead code elimination 119 */ 120#define DEBUGGING 1 121 122/* 123 Sources: 124 125 Crynwr packet driver epktisa. 126 127 Crystal Semiconductor data sheets. 128 129*/ 130 131#include <linux/errno.h> 132#include <linux/netdevice.h> 133#include <linux/etherdevice.h> 134#include <linux/kernel.h> 135#include <linux/types.h> 136#include <linux/fcntl.h> 137#include <linux/interrupt.h> 138#include <linux/ioport.h> 139#include <linux/in.h> 140#include <linux/skbuff.h> 141#include <linux/spinlock.h> 142#include <linux/string.h> 143#include <linux/init.h> 144#include <linux/bitops.h> 145#include <linux/delay.h> 146#include <linux/gfp.h> 147 148#include <asm/system.h> 149#include <asm/io.h> 150#include <asm/irq.h> 151#if ALLOW_DMA 152#include <asm/dma.h> 153#endif 154 155#include "cs89x0.h" 156 157static char version[] __initdata = 158"cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton\n"; 159 160#define DRV_NAME "cs89x0" 161 162/* First, a few definitions that the brave might change. 163 A zero-terminated list of I/O addresses to be probed. Some special flags.. 164 Addr & 1 = Read back the address port, look for signature and reset 165 the page window before probing 166 Addr & 3 = Reset the page window and probe 167 The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space, 168 but it is possible that a Cirrus board could be plugged into the ISA 169 slots. */ 170/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps 171 them to system IRQ numbers. This mapping is card specific and is set to 172 the configuration of the Cirrus Eval board for this chip. */ 173#if defined(CONFIG_MACH_IXDP2351) 174static unsigned int netcard_portlist[] __used __initdata = {IXDP2351_VIRT_CS8900_BASE, 0}; 175static unsigned int cs8900_irq_map[] = {IRQ_IXDP2351_CS8900, 0, 0, 0}; 176#elif defined(CONFIG_ARCH_IXDP2X01) 177static unsigned int netcard_portlist[] __used __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0}; 178static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0}; 179#elif defined(CONFIG_MACH_MX31ADS) 180#include <mach/board-mx31ads.h> 181static unsigned int netcard_portlist[] __used __initdata = { 182 PBC_BASE_ADDRESS + PBC_CS8900A_IOBASE + 0x300, 0 183}; 184static unsigned cs8900_irq_map[] = {EXPIO_INT_ENET_INT, 0, 0, 0}; 185#else 186static unsigned int netcard_portlist[] __used __initdata = 187 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0}; 188static unsigned int cs8900_irq_map[] = {10,11,12,5}; 189#endif 190 191#if DEBUGGING 192static unsigned int net_debug = DEBUGGING; 193#else 194#define net_debug 0 /* gcc will remove all the debug code for us */ 195#endif 196 197/* The number of low I/O ports used by the ethercard. */ 198#define NETCARD_IO_EXTENT 16 199 200/* we allow the user to override various values normally set in the EEPROM */ 201#define FORCE_RJ45 0x0001 /* pick one of these three */ 202#define FORCE_AUI 0x0002 203#define FORCE_BNC 0x0004 204 205#define FORCE_AUTO 0x0010 /* pick one of these three */ 206#define FORCE_HALF 0x0020 207#define FORCE_FULL 0x0030 208 209/* Information that need to be kept for each board. */ 210struct net_local { 211 int chip_type; /* one of: CS8900, CS8920, CS8920M */ 212 char chip_revision; /* revision letter of the chip ('A'...) */ 213 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */ 214 int auto_neg_cnf; /* auto-negotiation word from EEPROM */ 215 int adapter_cnf; /* adapter configuration from EEPROM */ 216 int isa_config; /* ISA configuration from EEPROM */ 217 int irq_map; /* IRQ map from EEPROM */ 218 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */ 219 int curr_rx_cfg; /* a copy of PP_RxCFG */ 220 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */ 221 int send_underrun; /* keep track of how many underruns in a row we get */ 222 int force; /* force various values; see FORCE* above. */ 223 spinlock_t lock; 224#if ALLOW_DMA 225 int use_dma; /* Flag: we're using dma */ 226 int dma; /* DMA channel */ 227 int dmasize; /* 16 or 64 */ 228 unsigned char *dma_buff; /* points to the beginning of the buffer */ 229 unsigned char *end_dma_buff; /* points to the end of the buffer */ 230 unsigned char *rx_dma_ptr; /* points to the next packet */ 231#endif 232}; 233 234/* Index to functions, as function prototypes. */ 235 236static int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular); 237static int net_open(struct net_device *dev); 238static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev); 239static irqreturn_t net_interrupt(int irq, void *dev_id); 240static void set_multicast_list(struct net_device *dev); 241static void net_timeout(struct net_device *dev); 242static void net_rx(struct net_device *dev); 243static int net_close(struct net_device *dev); 244static struct net_device_stats *net_get_stats(struct net_device *dev); 245static void reset_chip(struct net_device *dev); 246static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer); 247static int get_eeprom_cksum(int off, int len, int *buffer); 248static int set_mac_address(struct net_device *dev, void *addr); 249static void count_rx_errors(int status, struct net_device *dev); 250#ifdef CONFIG_NET_POLL_CONTROLLER 251static void net_poll_controller(struct net_device *dev); 252#endif 253#if ALLOW_DMA 254static void get_dma_channel(struct net_device *dev); 255static void release_dma_buff(struct net_local *lp); 256#endif 257 258/* Example routines you must write ;->. */ 259#define tx_done(dev) 1 260 261/* 262 * Permit 'cs89x0_dma=N' in the kernel boot environment 263 */ 264#if !defined(MODULE) && (ALLOW_DMA != 0) 265static int g_cs89x0_dma; 266 267static int __init dma_fn(char *str) 268{ 269 g_cs89x0_dma = simple_strtol(str,NULL,0); 270 return 1; 271} 272 273__setup("cs89x0_dma=", dma_fn); 274#endif /* !defined(MODULE) && (ALLOW_DMA != 0) */ 275 276#ifndef MODULE 277static int g_cs89x0_media__force; 278 279static int __init media_fn(char *str) 280{ 281 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45; 282 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI; 283 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC; 284 return 1; 285} 286 287__setup("cs89x0_media=", media_fn); 288 289 290/* Check for a network adaptor of this type, and return '0' iff one exists. 291 If dev->base_addr == 0, probe all likely locations. 292 If dev->base_addr == 1, always return failure. 293 If dev->base_addr == 2, allocate space for the device and return success 294 (detachable devices only). 295 Return 0 on success. 296 */ 297 298struct net_device * __init cs89x0_probe(int unit) 299{ 300 struct net_device *dev = alloc_etherdev(sizeof(struct net_local)); 301 unsigned *port; 302 int err = 0; 303 int irq; 304 int io; 305 306 if (!dev) 307 return ERR_PTR(-ENODEV); 308 309 sprintf(dev->name, "eth%d", unit); 310 netdev_boot_setup_check(dev); 311 io = dev->base_addr; 312 irq = dev->irq; 313 314 if (net_debug) 315 printk("cs89x0:cs89x0_probe(0x%x)\n", io); 316 317 if (io > 0x1ff) { /* Check a single specified location. */ 318 err = cs89x0_probe1(dev, io, 0); 319 } else if (io != 0) { /* Don't probe at all. */ 320 err = -ENXIO; 321 } else { 322 for (port = netcard_portlist; *port; port++) { 323 if (cs89x0_probe1(dev, *port, 0) == 0) 324 break; 325 dev->irq = irq; 326 } 327 if (!*port) 328 err = -ENODEV; 329 } 330 if (err) 331 goto out; 332 return dev; 333out: 334 free_netdev(dev); 335 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n"); 336 return ERR_PTR(err); 337} 338#endif 339 340#if defined(CONFIG_MACH_IXDP2351) 341static u16 342readword(unsigned long base_addr, int portno) 343{ 344 return __raw_readw(base_addr + (portno << 1)); 345} 346 347static void 348writeword(unsigned long base_addr, int portno, u16 value) 349{ 350 __raw_writew(value, base_addr + (portno << 1)); 351} 352#elif defined(CONFIG_ARCH_IXDP2X01) 353static u16 354readword(unsigned long base_addr, int portno) 355{ 356 return __raw_readl(base_addr + (portno << 1)); 357} 358 359static void 360writeword(unsigned long base_addr, int portno, u16 value) 361{ 362 __raw_writel(value, base_addr + (portno << 1)); 363} 364#else 365static u16 366readword(unsigned long base_addr, int portno) 367{ 368 return inw(base_addr + portno); 369} 370 371static void 372writeword(unsigned long base_addr, int portno, u16 value) 373{ 374 outw(value, base_addr + portno); 375} 376#endif 377 378static void 379readwords(unsigned long base_addr, int portno, void *buf, int length) 380{ 381 u8 *buf8 = (u8 *)buf; 382 383 do { 384 u16 tmp16; 385 386 tmp16 = readword(base_addr, portno); 387 *buf8++ = (u8)tmp16; 388 *buf8++ = (u8)(tmp16 >> 8); 389 } while (--length); 390} 391 392static void 393writewords(unsigned long base_addr, int portno, void *buf, int length) 394{ 395 u8 *buf8 = (u8 *)buf; 396 397 do { 398 u16 tmp16; 399 400 tmp16 = *buf8++; 401 tmp16 |= (*buf8++) << 8; 402 writeword(base_addr, portno, tmp16); 403 } while (--length); 404} 405 406static u16 407readreg(struct net_device *dev, u16 regno) 408{ 409 writeword(dev->base_addr, ADD_PORT, regno); 410 return readword(dev->base_addr, DATA_PORT); 411} 412 413static void 414writereg(struct net_device *dev, u16 regno, u16 value) 415{ 416 writeword(dev->base_addr, ADD_PORT, regno); 417 writeword(dev->base_addr, DATA_PORT, value); 418} 419 420static int __init 421wait_eeprom_ready(struct net_device *dev) 422{ 423 int timeout = jiffies; 424 /* check to see if the EEPROM is ready, a timeout is used - 425 just in case EEPROM is ready when SI_BUSY in the 426 PP_SelfST is clear */ 427 while(readreg(dev, PP_SelfST) & SI_BUSY) 428 if (jiffies - timeout >= 40) 429 return -1; 430 return 0; 431} 432 433static int __init 434get_eeprom_data(struct net_device *dev, int off, int len, int *buffer) 435{ 436 int i; 437 438 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len); 439 for (i = 0; i < len; i++) { 440 if (wait_eeprom_ready(dev) < 0) return -1; 441 /* Now send the EEPROM read command and EEPROM location to read */ 442 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD); 443 if (wait_eeprom_ready(dev) < 0) return -1; 444 buffer[i] = readreg(dev, PP_EEData); 445 if (net_debug > 3) printk("%04x ", buffer[i]); 446 } 447 if (net_debug > 3) printk("\n"); 448 return 0; 449} 450 451static int __init 452get_eeprom_cksum(int off, int len, int *buffer) 453{ 454 int i, cksum; 455 456 cksum = 0; 457 for (i = 0; i < len; i++) 458 cksum += buffer[i]; 459 cksum &= 0xffff; 460 if (cksum == 0) 461 return 0; 462 return -1; 463} 464 465#ifdef CONFIG_NET_POLL_CONTROLLER 466/* 467 * Polling receive - used by netconsole and other diagnostic tools 468 * to allow network i/o with interrupts disabled. 469 */ 470static void net_poll_controller(struct net_device *dev) 471{ 472 disable_irq(dev->irq); 473 net_interrupt(dev->irq, dev); 474 enable_irq(dev->irq); 475} 476#endif 477 478static const struct net_device_ops net_ops = { 479 .ndo_open = net_open, 480 .ndo_stop = net_close, 481 .ndo_tx_timeout = net_timeout, 482 .ndo_start_xmit = net_send_packet, 483 .ndo_get_stats = net_get_stats, 484 .ndo_set_multicast_list = set_multicast_list, 485 .ndo_set_mac_address = set_mac_address, 486#ifdef CONFIG_NET_POLL_CONTROLLER 487 .ndo_poll_controller = net_poll_controller, 488#endif 489 .ndo_change_mtu = eth_change_mtu, 490 .ndo_validate_addr = eth_validate_addr, 491}; 492 493/* This is the real probe routine. Linux has a history of friendly device 494 probes on the ISA bus. A good device probes avoids doing writes, and 495 verifies that the correct device exists and functions. 496 Return 0 on success. 497 */ 498 499static int __init 500cs89x0_probe1(struct net_device *dev, int ioaddr, int modular) 501{ 502 struct net_local *lp = netdev_priv(dev); 503 static unsigned version_printed; 504 int i; 505 int tmp; 506 unsigned rev_type = 0; 507 int eeprom_buff[CHKSUM_LEN]; 508 int retval; 509 510 /* Initialize the device structure. */ 511 if (!modular) { 512 memset(lp, 0, sizeof(*lp)); 513 spin_lock_init(&lp->lock); 514#ifndef MODULE 515#if ALLOW_DMA 516 if (g_cs89x0_dma) { 517 lp->use_dma = 1; 518 lp->dma = g_cs89x0_dma; 519 lp->dmasize = 16; /* Could make this an option... */ 520 } 521#endif 522 lp->force = g_cs89x0_media__force; 523#endif 524 } 525 526 /* Grab the region so we can find another board if autoIRQ fails. */ 527 /* WTF is going on here? */ 528 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, DRV_NAME)) { 529 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n", 530 DRV_NAME, ioaddr, NETCARD_IO_EXTENT); 531 retval = -EBUSY; 532 goto out1; 533 } 534 535 /* if they give us an odd I/O address, then do ONE write to 536 the address port, to get it back to address zero, where we 537 expect to find the EISA signature word. An IO with a base of 0x3 538 will skip the test for the ADD_PORT. */ 539 if (ioaddr & 1) { 540 if (net_debug > 1) 541 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr); 542 if ((ioaddr & 2) != 2) 543 if ((readword(ioaddr & ~3, ADD_PORT) & ADD_MASK) != ADD_SIG) { 544 printk(KERN_ERR "%s: bad signature 0x%x\n", 545 dev->name, readword(ioaddr & ~3, ADD_PORT)); 546 retval = -ENODEV; 547 goto out2; 548 } 549 } 550 551 ioaddr &= ~3; 552 printk(KERN_DEBUG "PP_addr at %x[%x]: 0x%x\n", 553 ioaddr, ADD_PORT, readword(ioaddr, ADD_PORT)); 554 writeword(ioaddr, ADD_PORT, PP_ChipID); 555 556 tmp = readword(ioaddr, DATA_PORT); 557 if (tmp != CHIP_EISA_ID_SIG) { 558 printk(KERN_DEBUG "%s: incorrect signature at %x[%x]: 0x%x!=" 559 CHIP_EISA_ID_SIG_STR "\n", 560 dev->name, ioaddr, DATA_PORT, tmp); 561 retval = -ENODEV; 562 goto out2; 563 } 564 565 /* Fill in the 'dev' fields. */ 566 dev->base_addr = ioaddr; 567 568 /* get the chip type */ 569 rev_type = readreg(dev, PRODUCT_ID_ADD); 570 lp->chip_type = rev_type &~ REVISON_BITS; 571 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A'; 572 573 /* Check the chip type and revision in order to set the correct send command 574 CS8920 revision C and CS8900 revision F can use the faster send. */ 575 lp->send_cmd = TX_AFTER_381; 576 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F') 577 lp->send_cmd = TX_NOW; 578 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C') 579 lp->send_cmd = TX_NOW; 580 581 if (net_debug && version_printed++ == 0) 582 printk(version); 583 584 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ", 585 dev->name, 586 lp->chip_type==CS8900?'0':'2', 587 lp->chip_type==CS8920M?"M":"", 588 lp->chip_revision, 589 dev->base_addr); 590 591 reset_chip(dev); 592 593 /* Here we read the current configuration of the chip. If there 594 is no Extended EEPROM then the idea is to not disturb the chip 595 configuration, it should have been correctly setup by automatic 596 EEPROM read on reset. So, if the chip says it read the EEPROM 597 the driver will always do *something* instead of complain that 598 adapter_cnf is 0. */ 599 600 601 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) == 602 (EEPROM_OK|EEPROM_PRESENT)) { 603 /* Load the MAC. */ 604 for (i=0; i < ETH_ALEN/2; i++) { 605 unsigned int Addr; 606 Addr = readreg(dev, PP_IA+i*2); 607 dev->dev_addr[i*2] = Addr & 0xFF; 608 dev->dev_addr[i*2+1] = Addr >> 8; 609 } 610 611 /* Load the Adapter Configuration. 612 Note: Barring any more specific information from some 613 other source (ie EEPROM+Schematics), we would not know 614 how to operate a 10Base2 interface on the AUI port. 615 However, since we do read the status of HCB1 and use 616 settings that always result in calls to control_dc_dc(dev,0) 617 a BNC interface should work if the enable pin 618 (dc/dc converter) is on HCB1. It will be called AUI 619 however. */ 620 621 lp->adapter_cnf = 0; 622 i = readreg(dev, PP_LineCTL); 623 /* Preserve the setting of the HCB1 pin. */ 624 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL)) 625 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY; 626 /* Save the sqelch bit */ 627 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH) 628 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH; 629 /* Check if the card is in 10Base-t only mode */ 630 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0) 631 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T; 632 /* Check if the card is in AUI only mode */ 633 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY) 634 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI; 635 /* Check if the card is in Auto mode. */ 636 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET) 637 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T | 638 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO; 639 640 if (net_debug > 1) 641 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n", 642 dev->name, i, lp->adapter_cnf); 643 644 /* IRQ. Other chips already probe, see below. */ 645 if (lp->chip_type == CS8900) 646 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK; 647 648 printk( "[Cirrus EEPROM] "); 649 } 650 651 printk("\n"); 652 653 /* First check to see if an EEPROM is attached. */ 654 655 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0) 656 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n"); 657 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) { 658 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n"); 659 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) { 660 /* Check if the chip was able to read its own configuration starting 661 at 0 in the EEPROM*/ 662 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) != 663 (EEPROM_OK|EEPROM_PRESENT)) 664 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n"); 665 666 } else { 667 /* This reads an extended EEPROM that is not documented 668 in the CS8900 datasheet. */ 669 670 /* get transmission control word but keep the autonegotiation bits */ 671 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2]; 672 /* Store adapter configuration */ 673 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2]; 674 /* Store ISA configuration */ 675 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2]; 676 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8; 677 678 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */ 679 /* store the initial memory base address */ 680 for (i = 0; i < ETH_ALEN/2; i++) { 681 dev->dev_addr[i*2] = eeprom_buff[i]; 682 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8; 683 } 684 if (net_debug > 1) 685 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n", 686 dev->name, lp->adapter_cnf); 687 } 688 689 /* allow them to force multiple transceivers. If they force multiple, autosense */ 690 { 691 int count = 0; 692 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; } 693 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; } 694 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; } 695 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; } 696 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; } 697 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; } 698 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; } 699 } 700 701 if (net_debug > 1) 702 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n", 703 dev->name, lp->force, lp->adapter_cnf); 704 705 706 707 708 printk(KERN_INFO "cs89x0 media %s%s%s", 709 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"", 710 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"", 711 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":""); 712 713 lp->irq_map = 0xffff; 714 715 /* If this is a CS8900 then no pnp soft */ 716 if (lp->chip_type != CS8900 && 717 /* Check if the ISA IRQ has been set */ 718 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff, 719 (i != 0 && i < CS8920_NO_INTS))) { 720 if (!dev->irq) 721 dev->irq = i; 722 } else { 723 i = lp->isa_config & INT_NO_MASK; 724 if (lp->chip_type == CS8900) { 725#ifdef CONFIG_CS89x0_NONISA_IRQ 726 i = cs8900_irq_map[0]; 727#else 728 /* Translate the IRQ using the IRQ mapping table. */ 729 if (i >= ARRAY_SIZE(cs8900_irq_map)) 730 printk("\ncs89x0: invalid ISA interrupt number %d\n", i); 731 else 732 i = cs8900_irq_map[i]; 733 734 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */ 735 } else { 736 int irq_map_buff[IRQ_MAP_LEN/2]; 737 738 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA, 739 IRQ_MAP_LEN/2, 740 irq_map_buff) >= 0) { 741 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT) 742 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8); 743 } 744#endif 745 } 746 if (!dev->irq) 747 dev->irq = i; 748 } 749 750 printk(" IRQ %d", dev->irq); 751 752#if ALLOW_DMA 753 if (lp->use_dma) { 754 get_dma_channel(dev); 755 printk(", DMA %d", dev->dma); 756 } 757 else 758#endif 759 { 760 printk(", programmed I/O"); 761 } 762 763 /* print the ethernet address. */ 764 printk(", MAC %pM", dev->dev_addr); 765 766 dev->netdev_ops = &net_ops; 767 dev->watchdog_timeo = HZ; 768 769 printk("\n"); 770 if (net_debug) 771 printk("cs89x0_probe1() successful\n"); 772 773 retval = register_netdev(dev); 774 if (retval) 775 goto out3; 776 return 0; 777out3: 778 writeword(dev->base_addr, ADD_PORT, PP_ChipID); 779out2: 780 release_region(ioaddr & ~3, NETCARD_IO_EXTENT); 781out1: 782 return retval; 783} 784 785 786/********************************* 787 * This page contains DMA routines 788**********************************/ 789 790#if ALLOW_DMA 791 792#define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17) 793 794static void 795get_dma_channel(struct net_device *dev) 796{ 797 struct net_local *lp = netdev_priv(dev); 798 799 if (lp->dma) { 800 dev->dma = lp->dma; 801 lp->isa_config |= ISA_RxDMA; 802 } else { 803 if ((lp->isa_config & ANY_ISA_DMA) == 0) 804 return; 805 dev->dma = lp->isa_config & DMA_NO_MASK; 806 if (lp->chip_type == CS8900) 807 dev->dma += 5; 808 if (dev->dma < 5 || dev->dma > 7) { 809 lp->isa_config &= ~ANY_ISA_DMA; 810 return; 811 } 812 } 813} 814 815static void 816write_dma(struct net_device *dev, int chip_type, int dma) 817{ 818 struct net_local *lp = netdev_priv(dev); 819 if ((lp->isa_config & ANY_ISA_DMA) == 0) 820 return; 821 if (chip_type == CS8900) { 822 writereg(dev, PP_CS8900_ISADMA, dma-5); 823 } else { 824 writereg(dev, PP_CS8920_ISADMA, dma); 825 } 826} 827 828static void 829set_dma_cfg(struct net_device *dev) 830{ 831 struct net_local *lp = netdev_priv(dev); 832 833 if (lp->use_dma) { 834 if ((lp->isa_config & ANY_ISA_DMA) == 0) { 835 if (net_debug > 3) 836 printk("set_dma_cfg(): no DMA\n"); 837 return; 838 } 839 if (lp->isa_config & ISA_RxDMA) { 840 lp->curr_rx_cfg |= RX_DMA_ONLY; 841 if (net_debug > 3) 842 printk("set_dma_cfg(): RX_DMA_ONLY\n"); 843 } else { 844 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */ 845 if (net_debug > 3) 846 printk("set_dma_cfg(): AUTO_RX_DMA\n"); 847 } 848 } 849} 850 851static int 852dma_bufcfg(struct net_device *dev) 853{ 854 struct net_local *lp = netdev_priv(dev); 855 if (lp->use_dma) 856 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0; 857 else 858 return 0; 859} 860 861static int 862dma_busctl(struct net_device *dev) 863{ 864 int retval = 0; 865 struct net_local *lp = netdev_priv(dev); 866 if (lp->use_dma) { 867 if (lp->isa_config & ANY_ISA_DMA) 868 retval |= RESET_RX_DMA; /* Reset the DMA pointer */ 869 if (lp->isa_config & DMA_BURST) 870 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */ 871 if (lp->dmasize == 64) 872 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */ 873 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */ 874 } 875 return retval; 876} 877 878static void 879dma_rx(struct net_device *dev) 880{ 881 struct net_local *lp = netdev_priv(dev); 882 struct sk_buff *skb; 883 int status, length; 884 unsigned char *bp = lp->rx_dma_ptr; 885 886 status = bp[0] + (bp[1]<<8); 887 length = bp[2] + (bp[3]<<8); 888 bp += 4; 889 if (net_debug > 5) { 890 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n", 891 dev->name, (unsigned long)bp, status, length); 892 } 893 if ((status & RX_OK) == 0) { 894 count_rx_errors(status, dev); 895 goto skip_this_frame; 896 } 897 898 /* Malloc up new buffer. */ 899 skb = dev_alloc_skb(length + 2); 900 if (skb == NULL) { 901 if (net_debug) /* I don't think we want to do this to a stressed system */ 902 printk("%s: Memory squeeze, dropping packet.\n", dev->name); 903 dev->stats.rx_dropped++; 904 905 /* AKPM: advance bp to the next frame */ 906skip_this_frame: 907 bp += (length + 3) & ~3; 908 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024; 909 lp->rx_dma_ptr = bp; 910 return; 911 } 912 skb_reserve(skb, 2); /* longword align L3 header */ 913 914 if (bp + length > lp->end_dma_buff) { 915 int semi_cnt = lp->end_dma_buff - bp; 916 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt); 917 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff, 918 length - semi_cnt); 919 } else { 920 memcpy(skb_put(skb,length), bp, length); 921 } 922 bp += (length + 3) & ~3; 923 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024; 924 lp->rx_dma_ptr = bp; 925 926 if (net_debug > 3) { 927 printk( "%s: received %d byte DMA packet of type %x\n", 928 dev->name, length, 929 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]); 930 } 931 skb->protocol=eth_type_trans(skb,dev); 932 netif_rx(skb); 933 dev->stats.rx_packets++; 934 dev->stats.rx_bytes += length; 935} 936 937#endif /* ALLOW_DMA */ 938 939static void __init reset_chip(struct net_device *dev) 940{ 941#if !defined(CONFIG_MACH_MX31ADS) 942#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01) 943 struct net_local *lp = netdev_priv(dev); 944 int ioaddr = dev->base_addr; 945#endif 946 int reset_start_time; 947 948 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET); 949 950 /* wait 30 ms */ 951 msleep(30); 952 953#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01) 954 if (lp->chip_type != CS8900) { 955 /* Hardware problem requires PNP registers to be reconfigured after a reset */ 956 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAINT); 957 outb(dev->irq, ioaddr + DATA_PORT); 958 outb(0, ioaddr + DATA_PORT + 1); 959 960 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAMemB); 961 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT); 962 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1); 963 } 964#endif /* IXDP2x01 */ 965 966 /* Wait until the chip is reset */ 967 reset_start_time = jiffies; 968 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2) 969 ; 970#endif /* !CONFIG_MACH_MX31ADS */ 971} 972 973 974static void 975control_dc_dc(struct net_device *dev, int on_not_off) 976{ 977 struct net_local *lp = netdev_priv(dev); 978 unsigned int selfcontrol; 979 int timenow = jiffies; 980 /* control the DC to DC convertor in the SelfControl register. 981 Note: This is hooked up to a general purpose pin, might not 982 always be a DC to DC convertor. */ 983 984 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */ 985 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off) 986 selfcontrol |= HCB1; 987 else 988 selfcontrol &= ~HCB1; 989 writereg(dev, PP_SelfCTL, selfcontrol); 990 991 /* Wait for the DC/DC converter to power up - 500ms */ 992 while (jiffies - timenow < HZ) 993 ; 994} 995 996#define DETECTED_NONE 0 997#define DETECTED_RJ45H 1 998#define DETECTED_RJ45F 2 999#define DETECTED_AUI 3 1000#define DETECTED_BNC 4 1001 1002static int 1003detect_tp(struct net_device *dev) 1004{ 1005 struct net_local *lp = netdev_priv(dev); 1006 int timenow = jiffies; 1007 int fdx; 1008 1009 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name); 1010 1011 /* If connected to another full duplex capable 10-Base-T card the link pulses 1012 seem to be lost when the auto detect bit in the LineCTL is set. 1013 To overcome this the auto detect bit will be cleared whilst testing the 1014 10-Base-T interface. This would not be necessary for the sparrow chip but 1015 is simpler to do it anyway. */ 1016 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY); 1017 control_dc_dc(dev, 0); 1018 1019 /* Delay for the hardware to work out if the TP cable is present - 150ms */ 1020 for (timenow = jiffies; jiffies - timenow < 15; ) 1021 ; 1022 if ((readreg(dev, PP_LineST) & LINK_OK) == 0) 1023 return DETECTED_NONE; 1024 1025 if (lp->chip_type == CS8900) { 1026 switch (lp->force & 0xf0) { 1027 /* CS8900 doesn't support AUTO, change to HALF*/ 1028 case FORCE_AUTO: 1029 lp->force &= ~FORCE_AUTO; 1030 lp->force |= FORCE_HALF; 1031 break; 1032 case FORCE_HALF: 1033 break; 1034 case FORCE_FULL: 1035 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900); 1036 break; 1037 } 1038 fdx = readreg(dev, PP_TestCTL) & FDX_8900; 1039 } else { 1040 switch (lp->force & 0xf0) { 1041 case FORCE_AUTO: 1042 lp->auto_neg_cnf = AUTO_NEG_ENABLE; 1043 break; 1044 case FORCE_HALF: 1045 lp->auto_neg_cnf = 0; 1046 break; 1047 case FORCE_FULL: 1048 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX; 1049 break; 1050 } 1051 1052 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK); 1053 1054 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) { 1055 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name); 1056 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) { 1057 if (jiffies - timenow > 4000) { 1058 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n"); 1059 break; 1060 } 1061 } 1062 } 1063 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE; 1064 } 1065 if (fdx) 1066 return DETECTED_RJ45F; 1067 else 1068 return DETECTED_RJ45H; 1069} 1070 1071/* send a test packet - return true if carrier bits are ok */ 1072static int 1073send_test_pkt(struct net_device *dev) 1074{ 1075 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0, 1076 0, 46, /* A 46 in network order */ 1077 0, 0, /* DSAP=0 & SSAP=0 fields */ 1078 0xf3, 0 /* Control (Test Req + P bit set) */ }; 1079 long timenow = jiffies; 1080 1081 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON); 1082 1083 memcpy(test_packet, dev->dev_addr, ETH_ALEN); 1084 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN); 1085 1086 writeword(dev->base_addr, TX_CMD_PORT, TX_AFTER_ALL); 1087 writeword(dev->base_addr, TX_LEN_PORT, ETH_ZLEN); 1088 1089 /* Test to see if the chip has allocated memory for the packet */ 1090 while (jiffies - timenow < 5) 1091 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW) 1092 break; 1093 if (jiffies - timenow >= 5) 1094 return 0; /* this shouldn't happen */ 1095 1096 /* Write the contents of the packet */ 1097 writewords(dev->base_addr, TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1); 1098 1099 if (net_debug > 1) printk("Sending test packet "); 1100 /* wait a couple of jiffies for packet to be received */ 1101 for (timenow = jiffies; jiffies - timenow < 3; ) 1102 ; 1103 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) { 1104 if (net_debug > 1) printk("succeeded\n"); 1105 return 1; 1106 } 1107 if (net_debug > 1) printk("failed\n"); 1108 return 0; 1109} 1110 1111 1112static int 1113detect_aui(struct net_device *dev) 1114{ 1115 struct net_local *lp = netdev_priv(dev); 1116 1117 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name); 1118 control_dc_dc(dev, 0); 1119 1120 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY); 1121 1122 if (send_test_pkt(dev)) 1123 return DETECTED_AUI; 1124 else 1125 return DETECTED_NONE; 1126} 1127 1128static int 1129detect_bnc(struct net_device *dev) 1130{ 1131 struct net_local *lp = netdev_priv(dev); 1132 1133 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name); 1134 control_dc_dc(dev, 1); 1135 1136 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY); 1137 1138 if (send_test_pkt(dev)) 1139 return DETECTED_BNC; 1140 else 1141 return DETECTED_NONE; 1142} 1143 1144 1145static void 1146write_irq(struct net_device *dev, int chip_type, int irq) 1147{ 1148 int i; 1149 1150 if (chip_type == CS8900) { 1151 /* Search the mapping table for the corresponding IRQ pin. */ 1152 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++) 1153 if (cs8900_irq_map[i] == irq) 1154 break; 1155 /* Not found */ 1156 if (i == ARRAY_SIZE(cs8900_irq_map)) 1157 i = 3; 1158 writereg(dev, PP_CS8900_ISAINT, i); 1159 } else { 1160 writereg(dev, PP_CS8920_ISAINT, irq); 1161 } 1162} 1163 1164/* Open/initialize the board. This is called (in the current kernel) 1165 sometime after booting when the 'ifconfig' program is run. 1166 1167 This routine should set everything up anew at each open, even 1168 registers that "should" only need to be set once at boot, so that 1169 there is non-reboot way to recover if something goes wrong. 1170 */ 1171 1172/* AKPM: do we need to do any locking here? */ 1173 1174static int 1175net_open(struct net_device *dev) 1176{ 1177 struct net_local *lp = netdev_priv(dev); 1178 int result = 0; 1179 int i; 1180 int ret; 1181 1182 if (dev->irq < 2) { 1183 /* Allow interrupts to be generated by the chip */ 1184/* Cirrus' release had this: */ 1185/* And 2.3.47 had this: */ 1186 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON); 1187 1188 for (i = 2; i < CS8920_NO_INTS; i++) { 1189 if ((1 << i) & lp->irq_map) { 1190 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) { 1191 dev->irq = i; 1192 write_irq(dev, lp->chip_type, i); 1193 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */ 1194 break; 1195 } 1196 } 1197 } 1198 1199 if (i >= CS8920_NO_INTS) { 1200 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */ 1201 printk(KERN_ERR "cs89x0: can't get an interrupt\n"); 1202 ret = -EAGAIN; 1203 goto bad_out; 1204 } 1205 } 1206 else 1207 { 1208#ifndef CONFIG_CS89x0_NONISA_IRQ 1209 if (((1 << dev->irq) & lp->irq_map) == 0) { 1210 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n", 1211 dev->name, dev->irq, lp->irq_map); 1212 ret = -EAGAIN; 1213 goto bad_out; 1214 } 1215#endif 1216 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ ); 1217/* And 2.3.47 had this: */ 1218 write_irq(dev, lp->chip_type, dev->irq); 1219 ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev); 1220 if (ret) { 1221 printk(KERN_ERR "cs89x0: request_irq(%d) failed\n", dev->irq); 1222 goto bad_out; 1223 } 1224 } 1225 1226#if ALLOW_DMA 1227 if (lp->use_dma) { 1228 if (lp->isa_config & ANY_ISA_DMA) { 1229 unsigned long flags; 1230 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL, 1231 get_order(lp->dmasize * 1024)); 1232 1233 if (!lp->dma_buff) { 1234 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize); 1235 goto release_irq; 1236 } 1237 if (net_debug > 1) { 1238 printk( "%s: dma %lx %lx\n", 1239 dev->name, 1240 (unsigned long)lp->dma_buff, 1241 (unsigned long)isa_virt_to_bus(lp->dma_buff)); 1242 } 1243 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS || 1244 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) { 1245 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name); 1246 goto release_irq; 1247 } 1248 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */ 1249 if (request_dma(dev->dma, dev->name)) { 1250 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma); 1251 goto release_irq; 1252 } 1253 write_dma(dev, lp->chip_type, dev->dma); 1254 lp->rx_dma_ptr = lp->dma_buff; 1255 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024; 1256 spin_lock_irqsave(&lp->lock, flags); 1257 disable_dma(dev->dma); 1258 clear_dma_ff(dev->dma); 1259 set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */ 1260 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff)); 1261 set_dma_count(dev->dma, lp->dmasize*1024); 1262 enable_dma(dev->dma); 1263 spin_unlock_irqrestore(&lp->lock, flags); 1264 } 1265 } 1266#endif /* ALLOW_DMA */ 1267 1268 /* set the Ethernet address */ 1269 for (i=0; i < ETH_ALEN/2; i++) 1270 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8)); 1271 1272 /* while we're testing the interface, leave interrupts disabled */ 1273 writereg(dev, PP_BusCTL, MEMORY_ON); 1274 1275 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */ 1276 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH)) 1277 lp->linectl = LOW_RX_SQUELCH; 1278 else 1279 lp->linectl = 0; 1280 1281 /* check to make sure that they have the "right" hardware available */ 1282 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) { 1283 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break; 1284 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break; 1285 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break; 1286 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2); 1287 } 1288 if (!result) { 1289 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name); 1290release_dma: 1291#if ALLOW_DMA 1292 free_dma(dev->dma); 1293release_irq: 1294 release_dma_buff(lp); 1295#endif 1296 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON)); 1297 free_irq(dev->irq, dev); 1298 ret = -EAGAIN; 1299 goto bad_out; 1300 } 1301 1302 /* set the hardware to the configured choice */ 1303 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) { 1304 case A_CNF_MEDIA_10B_T: 1305 result = detect_tp(dev); 1306 if (result==DETECTED_NONE) { 1307 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name); 1308 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */ 1309 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */ 1310 } 1311 break; 1312 case A_CNF_MEDIA_AUI: 1313 result = detect_aui(dev); 1314 if (result==DETECTED_NONE) { 1315 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name); 1316 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */ 1317 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */ 1318 } 1319 break; 1320 case A_CNF_MEDIA_10B_2: 1321 result = detect_bnc(dev); 1322 if (result==DETECTED_NONE) { 1323 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name); 1324 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */ 1325 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */ 1326 } 1327 break; 1328 case A_CNF_MEDIA_AUTO: 1329 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET); 1330 if (lp->adapter_cnf & A_CNF_10B_T) 1331 if ((result = detect_tp(dev)) != DETECTED_NONE) 1332 break; 1333 if (lp->adapter_cnf & A_CNF_AUI) 1334 if ((result = detect_aui(dev)) != DETECTED_NONE) 1335 break; 1336 if (lp->adapter_cnf & A_CNF_10B_2) 1337 if ((result = detect_bnc(dev)) != DETECTED_NONE) 1338 break; 1339 printk(KERN_ERR "%s: no media detected\n", dev->name); 1340 goto release_dma; 1341 } 1342 switch(result) { 1343 case DETECTED_NONE: 1344 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name); 1345 goto release_dma; 1346 case DETECTED_RJ45H: 1347 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name); 1348 break; 1349 case DETECTED_RJ45F: 1350 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name); 1351 break; 1352 case DETECTED_AUI: 1353 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name); 1354 break; 1355 case DETECTED_BNC: 1356 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name); 1357 break; 1358 } 1359 1360 /* Turn on both receive and transmit operations */ 1361 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON); 1362 1363 /* Receive only error free packets addressed to this card */ 1364 lp->rx_mode = 0; 1365 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT); 1366 1367 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL; 1368 1369 if (lp->isa_config & STREAM_TRANSFER) 1370 lp->curr_rx_cfg |= RX_STREAM_ENBL; 1371#if ALLOW_DMA 1372 set_dma_cfg(dev); 1373#endif 1374 writereg(dev, PP_RxCFG, lp->curr_rx_cfg); 1375 1376 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL | 1377 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL); 1378 1379 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL | 1380#if ALLOW_DMA 1381 dma_bufcfg(dev) | 1382#endif 1383 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL); 1384 1385 /* now that we've got our act together, enable everything */ 1386 writereg(dev, PP_BusCTL, ENABLE_IRQ 1387 | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */ 1388#if ALLOW_DMA 1389 | dma_busctl(dev) 1390#endif 1391 ); 1392 netif_start_queue(dev); 1393 if (net_debug > 1) 1394 printk("cs89x0: net_open() succeeded\n"); 1395 return 0; 1396bad_out: 1397 return ret; 1398} 1399 1400static void net_timeout(struct net_device *dev) 1401{ 1402 /* If we get here, some higher level has decided we are broken. 1403 There should really be a "kick me" function call instead. */ 1404 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name, 1405 tx_done(dev) ? "IRQ conflict ?" : "network cable problem"); 1406 /* Try to restart the adaptor. */ 1407 netif_wake_queue(dev); 1408} 1409 1410static netdev_tx_t net_send_packet(struct sk_buff *skb,struct net_device *dev) 1411{ 1412 struct net_local *lp = netdev_priv(dev); 1413 unsigned long flags; 1414 1415 if (net_debug > 3) { 1416 printk("%s: sent %d byte packet of type %x\n", 1417 dev->name, skb->len, 1418 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]); 1419 } 1420 1421 /* keep the upload from being interrupted, since we 1422 ask the chip to start transmitting before the 1423 whole packet has been completely uploaded. */ 1424 1425 spin_lock_irqsave(&lp->lock, flags); 1426 netif_stop_queue(dev); 1427 1428 /* initiate a transmit sequence */ 1429 writeword(dev->base_addr, TX_CMD_PORT, lp->send_cmd); 1430 writeword(dev->base_addr, TX_LEN_PORT, skb->len); 1431 1432 /* Test to see if the chip has allocated memory for the packet */ 1433 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) { 1434 /* 1435 * Gasp! It hasn't. But that shouldn't happen since 1436 * we're waiting for TxOk, so return 1 and requeue this packet. 1437 */ 1438 1439 spin_unlock_irqrestore(&lp->lock, flags); 1440 if (net_debug) printk("cs89x0: Tx buffer not free!\n"); 1441 return NETDEV_TX_BUSY; 1442 } 1443 /* Write the contents of the packet */ 1444 writewords(dev->base_addr, TX_FRAME_PORT,skb->data,(skb->len+1) >>1); 1445 spin_unlock_irqrestore(&lp->lock, flags); 1446 dev->stats.tx_bytes += skb->len; 1447 dev_kfree_skb (skb); 1448 1449 /* 1450 * We DO NOT call netif_wake_queue() here. 1451 * We also DO NOT call netif_start_queue(). 1452 * 1453 * Either of these would cause another bottom half run through 1454 * net_send_packet() before this packet has fully gone out. That causes 1455 * us to hit the "Gasp!" above and the send is rescheduled. it runs like 1456 * a dog. We just return and wait for the Tx completion interrupt handler 1457 * to restart the netdevice layer 1458 */ 1459 1460 return NETDEV_TX_OK; 1461} 1462 1463/* The typical workload of the driver: 1464 Handle the network interface interrupts. */ 1465 1466static irqreturn_t net_interrupt(int irq, void *dev_id) 1467{ 1468 struct net_device *dev = dev_id; 1469 struct net_local *lp; 1470 int ioaddr, status; 1471 int handled = 0; 1472 1473 ioaddr = dev->base_addr; 1474 lp = netdev_priv(dev); 1475 1476 /* we MUST read all the events out of the ISQ, otherwise we'll never 1477 get interrupted again. As a consequence, we can't have any limit 1478 on the number of times we loop in the interrupt handler. The 1479 hardware guarantees that eventually we'll run out of events. Of 1480 course, if you're on a slow machine, and packets are arriving 1481 faster than you can read them off, you're screwed. Hasta la 1482 vista, baby! */ 1483 while ((status = readword(dev->base_addr, ISQ_PORT))) { 1484 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status); 1485 handled = 1; 1486 switch(status & ISQ_EVENT_MASK) { 1487 case ISQ_RECEIVER_EVENT: 1488 /* Got a packet(s). */ 1489 net_rx(dev); 1490 break; 1491 case ISQ_TRANSMITTER_EVENT: 1492 dev->stats.tx_packets++; 1493 netif_wake_queue(dev); /* Inform upper layers. */ 1494 if ((status & ( TX_OK | 1495 TX_LOST_CRS | 1496 TX_SQE_ERROR | 1497 TX_LATE_COL | 1498 TX_16_COL)) != TX_OK) { 1499 if ((status & TX_OK) == 0) 1500 dev->stats.tx_errors++; 1501 if (status & TX_LOST_CRS) 1502 dev->stats.tx_carrier_errors++; 1503 if (status & TX_SQE_ERROR) 1504 dev->stats.tx_heartbeat_errors++; 1505 if (status & TX_LATE_COL) 1506 dev->stats.tx_window_errors++; 1507 if (status & TX_16_COL) 1508 dev->stats.tx_aborted_errors++; 1509 } 1510 break; 1511 case ISQ_BUFFER_EVENT: 1512 if (status & READY_FOR_TX) { 1513 /* we tried to transmit a packet earlier, 1514 but inexplicably ran out of buffers. 1515 That shouldn't happen since we only ever 1516 load one packet. Shrug. Do the right 1517 thing anyway. */ 1518 netif_wake_queue(dev); /* Inform upper layers. */ 1519 } 1520 if (status & TX_UNDERRUN) { 1521 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name); 1522 lp->send_underrun++; 1523 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381; 1524 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL; 1525 /* transmit cycle is done, although 1526 frame wasn't transmitted - this 1527 avoids having to wait for the upper 1528 layers to timeout on us, in the 1529 event of a tx underrun */ 1530 netif_wake_queue(dev); /* Inform upper layers. */ 1531 } 1532#if ALLOW_DMA 1533 if (lp->use_dma && (status & RX_DMA)) { 1534 int count = readreg(dev, PP_DmaFrameCnt); 1535 while(count) { 1536 if (net_debug > 5) 1537 printk("%s: receiving %d DMA frames\n", dev->name, count); 1538 if (net_debug > 2 && count >1) 1539 printk("%s: receiving %d DMA frames\n", dev->name, count); 1540 dma_rx(dev); 1541 if (--count == 0) 1542 count = readreg(dev, PP_DmaFrameCnt); 1543 if (net_debug > 2 && count > 0) 1544 printk("%s: continuing with %d DMA frames\n", dev->name, count); 1545 } 1546 } 1547#endif 1548 break; 1549 case ISQ_RX_MISS_EVENT: 1550 dev->stats.rx_missed_errors += (status >> 6); 1551 break; 1552 case ISQ_TX_COL_EVENT: 1553 dev->stats.collisions += (status >> 6); 1554 break; 1555 } 1556 } 1557 return IRQ_RETVAL(handled); 1558} 1559 1560static void 1561count_rx_errors(int status, struct net_device *dev) 1562{ 1563 dev->stats.rx_errors++; 1564 if (status & RX_RUNT) 1565 dev->stats.rx_length_errors++; 1566 if (status & RX_EXTRA_DATA) 1567 dev->stats.rx_length_errors++; 1568 if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA|RX_RUNT))) 1569 /* per str 172 */ 1570 dev->stats.rx_crc_errors++; 1571 if (status & RX_DRIBBLE) 1572 dev->stats.rx_frame_errors++; 1573} 1574 1575/* We have a good packet(s), get it/them out of the buffers. */ 1576static void 1577net_rx(struct net_device *dev) 1578{ 1579 struct sk_buff *skb; 1580 int status, length; 1581 1582 int ioaddr = dev->base_addr; 1583 status = readword(ioaddr, RX_FRAME_PORT); 1584 length = readword(ioaddr, RX_FRAME_PORT); 1585 1586 if ((status & RX_OK) == 0) { 1587 count_rx_errors(status, dev); 1588 return; 1589 } 1590 1591 /* Malloc up new buffer. */ 1592 skb = dev_alloc_skb(length + 2); 1593 if (skb == NULL) { 1594 dev->stats.rx_dropped++; 1595 return; 1596 } 1597 skb_reserve(skb, 2); /* longword align L3 header */ 1598 1599 readwords(ioaddr, RX_FRAME_PORT, skb_put(skb, length), length >> 1); 1600 if (length & 1) 1601 skb->data[length-1] = readword(ioaddr, RX_FRAME_PORT); 1602 1603 if (net_debug > 3) { 1604 printk( "%s: received %d byte packet of type %x\n", 1605 dev->name, length, 1606 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]); 1607 } 1608 1609 skb->protocol=eth_type_trans(skb,dev); 1610 netif_rx(skb); 1611 dev->stats.rx_packets++; 1612 dev->stats.rx_bytes += length; 1613} 1614 1615#if ALLOW_DMA 1616static void release_dma_buff(struct net_local *lp) 1617{ 1618 if (lp->dma_buff) { 1619 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024)); 1620 lp->dma_buff = NULL; 1621 } 1622} 1623#endif 1624 1625/* The inverse routine to net_open(). */ 1626static int 1627net_close(struct net_device *dev) 1628{ 1629#if ALLOW_DMA 1630 struct net_local *lp = netdev_priv(dev); 1631#endif 1632 1633 netif_stop_queue(dev); 1634 1635 writereg(dev, PP_RxCFG, 0); 1636 writereg(dev, PP_TxCFG, 0); 1637 writereg(dev, PP_BufCFG, 0); 1638 writereg(dev, PP_BusCTL, 0); 1639 1640 free_irq(dev->irq, dev); 1641 1642#if ALLOW_DMA 1643 if (lp->use_dma && lp->dma) { 1644 free_dma(dev->dma); 1645 release_dma_buff(lp); 1646 } 1647#endif 1648 1649 /* Update the statistics here. */ 1650 return 0; 1651} 1652 1653/* Get the current statistics. This may be called with the card open or 1654 closed. */ 1655static struct net_device_stats * 1656net_get_stats(struct net_device *dev) 1657{ 1658 struct net_local *lp = netdev_priv(dev); 1659 unsigned long flags; 1660 1661 spin_lock_irqsave(&lp->lock, flags); 1662 /* Update the statistics from the device registers. */ 1663 dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6); 1664 dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6); 1665 spin_unlock_irqrestore(&lp->lock, flags); 1666 1667 return &dev->stats; 1668} 1669 1670static void set_multicast_list(struct net_device *dev) 1671{ 1672 struct net_local *lp = netdev_priv(dev); 1673 unsigned long flags; 1674 1675 spin_lock_irqsave(&lp->lock, flags); 1676 if(dev->flags&IFF_PROMISC) 1677 { 1678 lp->rx_mode = RX_ALL_ACCEPT; 1679 } 1680 else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) 1681 { 1682 /* The multicast-accept list is initialized to accept-all, and we 1683 rely on higher-level filtering for now. */ 1684 lp->rx_mode = RX_MULTCAST_ACCEPT; 1685 } 1686 else 1687 lp->rx_mode = 0; 1688 1689 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode); 1690 1691 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */ 1692 writereg(dev, PP_RxCFG, lp->curr_rx_cfg | 1693 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0)); 1694 spin_unlock_irqrestore(&lp->lock, flags); 1695} 1696 1697 1698static int set_mac_address(struct net_device *dev, void *p) 1699{ 1700 int i; 1701 struct sockaddr *addr = p; 1702 1703 if (netif_running(dev)) 1704 return -EBUSY; 1705 1706 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 1707 1708 if (net_debug) 1709 printk("%s: Setting MAC address to %pM.\n", 1710 dev->name, dev->dev_addr); 1711 1712 /* set the Ethernet address */ 1713 for (i=0; i < ETH_ALEN/2; i++) 1714 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8)); 1715 1716 return 0; 1717} 1718 1719#ifdef MODULE 1720 1721static struct net_device *dev_cs89x0; 1722 1723/* 1724 * Support the 'debug' module parm even if we're compiled for non-debug to 1725 * avoid breaking someone's startup scripts 1726 */ 1727 1728static int io; 1729static int irq; 1730static int debug; 1731static char media[8]; 1732static int duplex=-1; 1733 1734static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */ 1735static int dma; 1736static int dmasize=16; /* or 64 */ 1737 1738module_param(io, int, 0); 1739module_param(irq, int, 0); 1740module_param(debug, int, 0); 1741module_param_string(media, media, sizeof(media), 0); 1742module_param(duplex, int, 0); 1743module_param(dma , int, 0); 1744module_param(dmasize , int, 0); 1745module_param(use_dma , int, 0); 1746MODULE_PARM_DESC(io, "cs89x0 I/O base address"); 1747MODULE_PARM_DESC(irq, "cs89x0 IRQ number"); 1748#if DEBUGGING 1749MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)"); 1750#else 1751MODULE_PARM_DESC(debug, "(ignored)"); 1752#endif 1753MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)"); 1754/* No other value than -1 for duplex seems to be currently interpreted */ 1755MODULE_PARM_DESC(duplex, "(ignored)"); 1756#if ALLOW_DMA 1757MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0"); 1758MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0"); 1759MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)"); 1760#else 1761MODULE_PARM_DESC(dma , "(ignored)"); 1762MODULE_PARM_DESC(dmasize , "(ignored)"); 1763MODULE_PARM_DESC(use_dma , "(ignored)"); 1764#endif 1765 1766MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton"); 1767MODULE_LICENSE("GPL"); 1768 1769 1770/* 1771* media=t - specify media type 1772 or media=2 1773 or media=aui 1774 or medai=auto 1775* duplex=0 - specify forced half/full/autonegotiate duplex 1776* debug=# - debug level 1777 1778 1779* Default Chip Configuration: 1780 * DMA Burst = enabled 1781 * IOCHRDY Enabled = enabled 1782 * UseSA = enabled 1783 * CS8900 defaults to half-duplex if not specified on command-line 1784 * CS8920 defaults to autoneg if not specified on command-line 1785 * Use reset defaults for other config parameters 1786 1787* Assumptions: 1788 * media type specified is supported (circuitry is present) 1789 * if memory address is > 1MB, then required mem decode hw is present 1790 * if 10B-2, then agent other than driver will enable DC/DC converter 1791 (hw or software util) 1792 1793 1794*/ 1795 1796int __init init_module(void) 1797{ 1798 struct net_device *dev = alloc_etherdev(sizeof(struct net_local)); 1799 struct net_local *lp; 1800 int ret = 0; 1801 1802#if DEBUGGING 1803 net_debug = debug; 1804#else 1805 debug = 0; 1806#endif 1807 if (!dev) 1808 return -ENOMEM; 1809 1810 dev->irq = irq; 1811 dev->base_addr = io; 1812 lp = netdev_priv(dev); 1813 1814#if ALLOW_DMA 1815 if (use_dma) { 1816 lp->use_dma = use_dma; 1817 lp->dma = dma; 1818 lp->dmasize = dmasize; 1819 } 1820#endif 1821 1822 spin_lock_init(&lp->lock); 1823 1824 /* boy, they'd better get these right */ 1825 if (!strcmp(media, "rj45")) 1826 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T; 1827 else if (!strcmp(media, "aui")) 1828 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI; 1829 else if (!strcmp(media, "bnc")) 1830 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2; 1831 else 1832 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T; 1833 1834 if (duplex==-1) 1835 lp->auto_neg_cnf = AUTO_NEG_ENABLE; 1836 1837 if (io == 0) { 1838 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n"); 1839 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n"); 1840 ret = -EPERM; 1841 goto out; 1842 } else if (io <= 0x1ff) { 1843 ret = -ENXIO; 1844 goto out; 1845 } 1846 1847#if ALLOW_DMA 1848 if (use_dma && dmasize != 16 && dmasize != 64) { 1849 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize); 1850 ret = -EPERM; 1851 goto out; 1852 } 1853#endif 1854 ret = cs89x0_probe1(dev, io, 1); 1855 if (ret) 1856 goto out; 1857 1858 dev_cs89x0 = dev; 1859 return 0; 1860out: 1861 free_netdev(dev); 1862 return ret; 1863} 1864 1865void __exit 1866cleanup_module(void) 1867{ 1868 unregister_netdev(dev_cs89x0); 1869 writeword(dev_cs89x0->base_addr, ADD_PORT, PP_ChipID); 1870 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT); 1871 free_netdev(dev_cs89x0); 1872} 1873#endif /* MODULE */ 1874 1875/* 1876 * Local variables: 1877 * version-control: t 1878 * kept-new-versions: 5 1879 * c-indent-level: 8 1880 * tab-width: 8 1881 * End: 1882 * 1883 */ 1884