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