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