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