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