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