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