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