1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * drivers/net/phy/marvell.c 4 * 5 * Driver for Marvell PHYs 6 * 7 * Author: Andy Fleming 8 * 9 * Copyright (c) 2004 Freescale Semiconductor, Inc. 10 * 11 * Copyright (c) 2013 Michael Stapelberg <michael@stapelberg.de> 12 */ 13 #include <linux/kernel.h> 14 #include <linux/string.h> 15 #include <linux/ctype.h> 16 #include <linux/errno.h> 17 #include <linux/unistd.h> 18 #include <linux/hwmon.h> 19 #include <linux/interrupt.h> 20 #include <linux/init.h> 21 #include <linux/delay.h> 22 #include <linux/netdevice.h> 23 #include <linux/etherdevice.h> 24 #include <linux/skbuff.h> 25 #include <linux/spinlock.h> 26 #include <linux/mm.h> 27 #include <linux/module.h> 28 #include <linux/mii.h> 29 #include <linux/ethtool.h> 30 #include <linux/phy.h> 31 #include <linux/marvell_phy.h> 32 #include <linux/bitfield.h> 33 #include <linux/of.h> 34 35 #include <linux/io.h> 36 #include <asm/irq.h> 37 #include <linux/uaccess.h> 38 39 #define MII_MARVELL_PHY_PAGE 22 40 #define MII_MARVELL_COPPER_PAGE 0x00 41 #define MII_MARVELL_FIBER_PAGE 0x01 42 #define MII_MARVELL_MSCR_PAGE 0x02 43 #define MII_MARVELL_LED_PAGE 0x03 44 #define MII_MARVELL_MISC_TEST_PAGE 0x06 45 #define MII_MARVELL_WOL_PAGE 0x11 46 47 #define MII_M1011_IEVENT 0x13 48 #define MII_M1011_IEVENT_CLEAR 0x0000 49 50 #define MII_M1011_IMASK 0x12 51 #define MII_M1011_IMASK_INIT 0x6400 52 #define MII_M1011_IMASK_CLEAR 0x0000 53 54 #define MII_M1011_PHY_SCR 0x10 55 #define MII_M1011_PHY_SCR_DOWNSHIFT_EN BIT(11) 56 #define MII_M1011_PHY_SCR_DOWNSHIFT_MASK GENMASK(14, 12) 57 #define MII_M1011_PHY_SCR_DOWNSHIFT_MAX 8 58 #define MII_M1011_PHY_SCR_MDI (0x0 << 5) 59 #define MII_M1011_PHY_SCR_MDI_X (0x1 << 5) 60 #define MII_M1011_PHY_SCR_AUTO_CROSS (0x3 << 5) 61 62 #define MII_M1011_PHY_SSR 0x11 63 #define MII_M1011_PHY_SSR_DOWNSHIFT BIT(5) 64 65 #define MII_M1111_PHY_LED_CONTROL 0x18 66 #define MII_M1111_PHY_LED_DIRECT 0x4100 67 #define MII_M1111_PHY_LED_COMBINE 0x411c 68 #define MII_M1111_PHY_EXT_CR 0x14 69 #define MII_M1111_PHY_EXT_CR_DOWNSHIFT_MASK GENMASK(11, 9) 70 #define MII_M1111_PHY_EXT_CR_DOWNSHIFT_MAX 8 71 #define MII_M1111_PHY_EXT_CR_DOWNSHIFT_EN BIT(8) 72 #define MII_M1111_RGMII_RX_DELAY BIT(7) 73 #define MII_M1111_RGMII_TX_DELAY BIT(1) 74 #define MII_M1111_PHY_EXT_SR 0x1b 75 76 #define MII_M1111_HWCFG_MODE_MASK 0xf 77 #define MII_M1111_HWCFG_MODE_FIBER_RGMII 0x3 78 #define MII_M1111_HWCFG_MODE_SGMII_NO_CLK 0x4 79 #define MII_M1111_HWCFG_MODE_RTBI 0x7 80 #define MII_M1111_HWCFG_MODE_COPPER_RTBI 0x9 81 #define MII_M1111_HWCFG_MODE_COPPER_RGMII 0xb 82 #define MII_M1111_HWCFG_FIBER_COPPER_RES BIT(13) 83 #define MII_M1111_HWCFG_FIBER_COPPER_AUTO BIT(15) 84 85 #define MII_88E1121_PHY_MSCR_REG 21 86 #define MII_88E1121_PHY_MSCR_RX_DELAY BIT(5) 87 #define MII_88E1121_PHY_MSCR_TX_DELAY BIT(4) 88 #define MII_88E1121_PHY_MSCR_DELAY_MASK (BIT(5) | BIT(4)) 89 90 #define MII_88E1121_MISC_TEST 0x1a 91 #define MII_88E1510_MISC_TEST_TEMP_THRESHOLD_MASK 0x1f00 92 #define MII_88E1510_MISC_TEST_TEMP_THRESHOLD_SHIFT 8 93 #define MII_88E1510_MISC_TEST_TEMP_IRQ_EN BIT(7) 94 #define MII_88E1510_MISC_TEST_TEMP_IRQ BIT(6) 95 #define MII_88E1121_MISC_TEST_TEMP_SENSOR_EN BIT(5) 96 #define MII_88E1121_MISC_TEST_TEMP_MASK 0x1f 97 98 #define MII_88E1510_TEMP_SENSOR 0x1b 99 #define MII_88E1510_TEMP_SENSOR_MASK 0xff 100 101 #define MII_88E1540_COPPER_CTRL3 0x1a 102 #define MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_MASK GENMASK(11, 10) 103 #define MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_00MS 0 104 #define MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_10MS 1 105 #define MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_20MS 2 106 #define MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_40MS 3 107 #define MII_88E1540_COPPER_CTRL3_FAST_LINK_DOWN BIT(9) 108 109 #define MII_88E6390_MISC_TEST 0x1b 110 #define MII_88E6390_MISC_TEST_SAMPLE_1S 0 111 #define MII_88E6390_MISC_TEST_SAMPLE_10MS BIT(14) 112 #define MII_88E6390_MISC_TEST_SAMPLE_DISABLE BIT(15) 113 #define MII_88E6390_MISC_TEST_SAMPLE_ENABLE 0 114 #define MII_88E6390_MISC_TEST_SAMPLE_MASK (0x3 << 14) 115 116 #define MII_88E6390_TEMP_SENSOR 0x1c 117 #define MII_88E6390_TEMP_SENSOR_MASK 0xff 118 #define MII_88E6390_TEMP_SENSOR_SAMPLES 10 119 120 #define MII_88E1318S_PHY_MSCR1_REG 16 121 #define MII_88E1318S_PHY_MSCR1_PAD_ODD BIT(6) 122 123 /* Copper Specific Interrupt Enable Register */ 124 #define MII_88E1318S_PHY_CSIER 0x12 125 /* WOL Event Interrupt Enable */ 126 #define MII_88E1318S_PHY_CSIER_WOL_EIE BIT(7) 127 128 /* LED Timer Control Register */ 129 #define MII_88E1318S_PHY_LED_TCR 0x12 130 #define MII_88E1318S_PHY_LED_TCR_FORCE_INT BIT(15) 131 #define MII_88E1318S_PHY_LED_TCR_INTn_ENABLE BIT(7) 132 #define MII_88E1318S_PHY_LED_TCR_INT_ACTIVE_LOW BIT(11) 133 134 /* Magic Packet MAC address registers */ 135 #define MII_88E1318S_PHY_MAGIC_PACKET_WORD2 0x17 136 #define MII_88E1318S_PHY_MAGIC_PACKET_WORD1 0x18 137 #define MII_88E1318S_PHY_MAGIC_PACKET_WORD0 0x19 138 139 #define MII_88E1318S_PHY_WOL_CTRL 0x10 140 #define MII_88E1318S_PHY_WOL_CTRL_CLEAR_WOL_STATUS BIT(12) 141 #define MII_88E1318S_PHY_WOL_CTRL_MAGIC_PACKET_MATCH_ENABLE BIT(14) 142 143 #define MII_PHY_LED_CTRL 16 144 #define MII_88E1121_PHY_LED_DEF 0x0030 145 #define MII_88E1510_PHY_LED_DEF 0x1177 146 #define MII_88E1510_PHY_LED0_LINK_LED1_ACTIVE 0x1040 147 148 #define MII_M1011_PHY_STATUS 0x11 149 #define MII_M1011_PHY_STATUS_1000 0x8000 150 #define MII_M1011_PHY_STATUS_100 0x4000 151 #define MII_M1011_PHY_STATUS_SPD_MASK 0xc000 152 #define MII_M1011_PHY_STATUS_FULLDUPLEX 0x2000 153 #define MII_M1011_PHY_STATUS_RESOLVED 0x0800 154 #define MII_M1011_PHY_STATUS_LINK 0x0400 155 156 #define MII_88E3016_PHY_SPEC_CTRL 0x10 157 #define MII_88E3016_DISABLE_SCRAMBLER 0x0200 158 #define MII_88E3016_AUTO_MDIX_CROSSOVER 0x0030 159 160 #define MII_88E1510_GEN_CTRL_REG_1 0x14 161 #define MII_88E1510_GEN_CTRL_REG_1_MODE_MASK 0x7 162 #define MII_88E1510_GEN_CTRL_REG_1_MODE_SGMII 0x1 /* SGMII to copper */ 163 #define MII_88E1510_GEN_CTRL_REG_1_RESET 0x8000 /* Soft reset */ 164 165 #define LPA_PAUSE_FIBER 0x180 166 #define LPA_PAUSE_ASYM_FIBER 0x100 167 168 #define NB_FIBER_STATS 1 169 170 MODULE_DESCRIPTION("Marvell PHY driver"); 171 MODULE_AUTHOR("Andy Fleming"); 172 MODULE_LICENSE("GPL"); 173 174 struct marvell_hw_stat { 175 const char *string; 176 u8 page; 177 u8 reg; 178 u8 bits; 179 }; 180 181 static struct marvell_hw_stat marvell_hw_stats[] = { 182 { "phy_receive_errors_copper", 0, 21, 16}, 183 { "phy_idle_errors", 0, 10, 8 }, 184 { "phy_receive_errors_fiber", 1, 21, 16}, 185 }; 186 187 struct marvell_priv { 188 u64 stats[ARRAY_SIZE(marvell_hw_stats)]; 189 char *hwmon_name; 190 struct device *hwmon_dev; 191 }; 192 193 static int marvell_read_page(struct phy_device *phydev) 194 { 195 return __phy_read(phydev, MII_MARVELL_PHY_PAGE); 196 } 197 198 static int marvell_write_page(struct phy_device *phydev, int page) 199 { 200 return __phy_write(phydev, MII_MARVELL_PHY_PAGE, page); 201 } 202 203 static int marvell_set_page(struct phy_device *phydev, int page) 204 { 205 return phy_write(phydev, MII_MARVELL_PHY_PAGE, page); 206 } 207 208 static int marvell_ack_interrupt(struct phy_device *phydev) 209 { 210 int err; 211 212 /* Clear the interrupts by reading the reg */ 213 err = phy_read(phydev, MII_M1011_IEVENT); 214 215 if (err < 0) 216 return err; 217 218 return 0; 219 } 220 221 static int marvell_config_intr(struct phy_device *phydev) 222 { 223 int err; 224 225 if (phydev->interrupts == PHY_INTERRUPT_ENABLED) 226 err = phy_write(phydev, MII_M1011_IMASK, 227 MII_M1011_IMASK_INIT); 228 else 229 err = phy_write(phydev, MII_M1011_IMASK, 230 MII_M1011_IMASK_CLEAR); 231 232 return err; 233 } 234 235 static int marvell_set_polarity(struct phy_device *phydev, int polarity) 236 { 237 int reg; 238 int err; 239 int val; 240 241 /* get the current settings */ 242 reg = phy_read(phydev, MII_M1011_PHY_SCR); 243 if (reg < 0) 244 return reg; 245 246 val = reg; 247 val &= ~MII_M1011_PHY_SCR_AUTO_CROSS; 248 switch (polarity) { 249 case ETH_TP_MDI: 250 val |= MII_M1011_PHY_SCR_MDI; 251 break; 252 case ETH_TP_MDI_X: 253 val |= MII_M1011_PHY_SCR_MDI_X; 254 break; 255 case ETH_TP_MDI_AUTO: 256 case ETH_TP_MDI_INVALID: 257 default: 258 val |= MII_M1011_PHY_SCR_AUTO_CROSS; 259 break; 260 } 261 262 if (val != reg) { 263 /* Set the new polarity value in the register */ 264 err = phy_write(phydev, MII_M1011_PHY_SCR, val); 265 if (err) 266 return err; 267 } 268 269 return val != reg; 270 } 271 272 static int marvell_config_aneg(struct phy_device *phydev) 273 { 274 int changed = 0; 275 int err; 276 277 err = marvell_set_polarity(phydev, phydev->mdix_ctrl); 278 if (err < 0) 279 return err; 280 281 changed = err; 282 283 err = phy_write(phydev, MII_M1111_PHY_LED_CONTROL, 284 MII_M1111_PHY_LED_DIRECT); 285 if (err < 0) 286 return err; 287 288 err = genphy_config_aneg(phydev); 289 if (err < 0) 290 return err; 291 292 if (phydev->autoneg != AUTONEG_ENABLE || changed) { 293 /* A write to speed/duplex bits (that is performed by 294 * genphy_config_aneg() call above) must be followed by 295 * a software reset. Otherwise, the write has no effect. 296 */ 297 err = genphy_soft_reset(phydev); 298 if (err < 0) 299 return err; 300 } 301 302 return 0; 303 } 304 305 static int m88e1101_config_aneg(struct phy_device *phydev) 306 { 307 int err; 308 309 /* This Marvell PHY has an errata which requires 310 * that certain registers get written in order 311 * to restart autonegotiation 312 */ 313 err = genphy_soft_reset(phydev); 314 if (err < 0) 315 return err; 316 317 err = phy_write(phydev, 0x1d, 0x1f); 318 if (err < 0) 319 return err; 320 321 err = phy_write(phydev, 0x1e, 0x200c); 322 if (err < 0) 323 return err; 324 325 err = phy_write(phydev, 0x1d, 0x5); 326 if (err < 0) 327 return err; 328 329 err = phy_write(phydev, 0x1e, 0); 330 if (err < 0) 331 return err; 332 333 err = phy_write(phydev, 0x1e, 0x100); 334 if (err < 0) 335 return err; 336 337 return marvell_config_aneg(phydev); 338 } 339 340 #ifdef CONFIG_OF_MDIO 341 /* Set and/or override some configuration registers based on the 342 * marvell,reg-init property stored in the of_node for the phydev. 343 * 344 * marvell,reg-init = <reg-page reg mask value>,...; 345 * 346 * There may be one or more sets of <reg-page reg mask value>: 347 * 348 * reg-page: which register bank to use. 349 * reg: the register. 350 * mask: if non-zero, ANDed with existing register value. 351 * value: ORed with the masked value and written to the regiser. 352 * 353 */ 354 static int marvell_of_reg_init(struct phy_device *phydev) 355 { 356 const __be32 *paddr; 357 int len, i, saved_page, current_page, ret = 0; 358 359 if (!phydev->mdio.dev.of_node) 360 return 0; 361 362 paddr = of_get_property(phydev->mdio.dev.of_node, 363 "marvell,reg-init", &len); 364 if (!paddr || len < (4 * sizeof(*paddr))) 365 return 0; 366 367 saved_page = phy_save_page(phydev); 368 if (saved_page < 0) 369 goto err; 370 current_page = saved_page; 371 372 len /= sizeof(*paddr); 373 for (i = 0; i < len - 3; i += 4) { 374 u16 page = be32_to_cpup(paddr + i); 375 u16 reg = be32_to_cpup(paddr + i + 1); 376 u16 mask = be32_to_cpup(paddr + i + 2); 377 u16 val_bits = be32_to_cpup(paddr + i + 3); 378 int val; 379 380 if (page != current_page) { 381 current_page = page; 382 ret = marvell_write_page(phydev, page); 383 if (ret < 0) 384 goto err; 385 } 386 387 val = 0; 388 if (mask) { 389 val = __phy_read(phydev, reg); 390 if (val < 0) { 391 ret = val; 392 goto err; 393 } 394 val &= mask; 395 } 396 val |= val_bits; 397 398 ret = __phy_write(phydev, reg, val); 399 if (ret < 0) 400 goto err; 401 } 402 err: 403 return phy_restore_page(phydev, saved_page, ret); 404 } 405 #else 406 static int marvell_of_reg_init(struct phy_device *phydev) 407 { 408 return 0; 409 } 410 #endif /* CONFIG_OF_MDIO */ 411 412 static int m88e1121_config_aneg_rgmii_delays(struct phy_device *phydev) 413 { 414 int mscr; 415 416 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID) 417 mscr = MII_88E1121_PHY_MSCR_RX_DELAY | 418 MII_88E1121_PHY_MSCR_TX_DELAY; 419 else if (phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) 420 mscr = MII_88E1121_PHY_MSCR_RX_DELAY; 421 else if (phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID) 422 mscr = MII_88E1121_PHY_MSCR_TX_DELAY; 423 else 424 mscr = 0; 425 426 return phy_modify_paged(phydev, MII_MARVELL_MSCR_PAGE, 427 MII_88E1121_PHY_MSCR_REG, 428 MII_88E1121_PHY_MSCR_DELAY_MASK, mscr); 429 } 430 431 static int m88e1121_config_aneg(struct phy_device *phydev) 432 { 433 int changed = 0; 434 int err = 0; 435 436 if (phy_interface_is_rgmii(phydev)) { 437 err = m88e1121_config_aneg_rgmii_delays(phydev); 438 if (err < 0) 439 return err; 440 } 441 442 err = marvell_set_polarity(phydev, phydev->mdix_ctrl); 443 if (err < 0) 444 return err; 445 446 changed = err; 447 448 err = genphy_config_aneg(phydev); 449 if (err < 0) 450 return err; 451 452 if (phydev->autoneg != AUTONEG_ENABLE || changed) { 453 /* A software reset is used to ensure a "commit" of the 454 * changes is done. 455 */ 456 err = genphy_soft_reset(phydev); 457 if (err < 0) 458 return err; 459 } 460 461 return 0; 462 } 463 464 static int m88e1318_config_aneg(struct phy_device *phydev) 465 { 466 int err; 467 468 err = phy_modify_paged(phydev, MII_MARVELL_MSCR_PAGE, 469 MII_88E1318S_PHY_MSCR1_REG, 470 0, MII_88E1318S_PHY_MSCR1_PAD_ODD); 471 if (err < 0) 472 return err; 473 474 return m88e1121_config_aneg(phydev); 475 } 476 477 /** 478 * linkmode_adv_to_fiber_adv_t 479 * @advertise: the linkmode advertisement settings 480 * 481 * A small helper function that translates linkmode advertisement 482 * settings to phy autonegotiation advertisements for the MII_ADV 483 * register for fiber link. 484 */ 485 static inline u32 linkmode_adv_to_fiber_adv_t(unsigned long *advertise) 486 { 487 u32 result = 0; 488 489 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, advertise)) 490 result |= ADVERTISE_1000XHALF; 491 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, advertise)) 492 result |= ADVERTISE_1000XFULL; 493 494 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, advertise) && 495 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertise)) 496 result |= ADVERTISE_1000XPSE_ASYM; 497 else if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertise)) 498 result |= ADVERTISE_1000XPAUSE; 499 500 return result; 501 } 502 503 /** 504 * marvell_config_aneg_fiber - restart auto-negotiation or write BMCR 505 * @phydev: target phy_device struct 506 * 507 * Description: If auto-negotiation is enabled, we configure the 508 * advertising, and then restart auto-negotiation. If it is not 509 * enabled, then we write the BMCR. Adapted for fiber link in 510 * some Marvell's devices. 511 */ 512 static int marvell_config_aneg_fiber(struct phy_device *phydev) 513 { 514 int changed = 0; 515 int err; 516 u16 adv; 517 518 if (phydev->autoneg != AUTONEG_ENABLE) 519 return genphy_setup_forced(phydev); 520 521 /* Only allow advertising what this PHY supports */ 522 linkmode_and(phydev->advertising, phydev->advertising, 523 phydev->supported); 524 525 adv = linkmode_adv_to_fiber_adv_t(phydev->advertising); 526 527 /* Setup fiber advertisement */ 528 err = phy_modify_changed(phydev, MII_ADVERTISE, 529 ADVERTISE_1000XHALF | ADVERTISE_1000XFULL | 530 ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM, 531 adv); 532 if (err < 0) 533 return err; 534 if (err > 0) 535 changed = 1; 536 537 return genphy_check_and_restart_aneg(phydev, changed); 538 } 539 540 static int m88e1510_config_aneg(struct phy_device *phydev) 541 { 542 int err; 543 544 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 545 if (err < 0) 546 goto error; 547 548 /* Configure the copper link first */ 549 err = m88e1318_config_aneg(phydev); 550 if (err < 0) 551 goto error; 552 553 /* Do not touch the fiber page if we're in copper->sgmii mode */ 554 if (phydev->interface == PHY_INTERFACE_MODE_SGMII) 555 return 0; 556 557 /* Then the fiber link */ 558 err = marvell_set_page(phydev, MII_MARVELL_FIBER_PAGE); 559 if (err < 0) 560 goto error; 561 562 err = marvell_config_aneg_fiber(phydev); 563 if (err < 0) 564 goto error; 565 566 return marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 567 568 error: 569 marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 570 return err; 571 } 572 573 static void marvell_config_led(struct phy_device *phydev) 574 { 575 u16 def_config; 576 int err; 577 578 switch (MARVELL_PHY_FAMILY_ID(phydev->phy_id)) { 579 /* Default PHY LED config: LED[0] .. Link, LED[1] .. Activity */ 580 case MARVELL_PHY_FAMILY_ID(MARVELL_PHY_ID_88E1121R): 581 case MARVELL_PHY_FAMILY_ID(MARVELL_PHY_ID_88E1318S): 582 def_config = MII_88E1121_PHY_LED_DEF; 583 break; 584 /* Default PHY LED config: 585 * LED[0] .. 1000Mbps Link 586 * LED[1] .. 100Mbps Link 587 * LED[2] .. Blink, Activity 588 */ 589 case MARVELL_PHY_FAMILY_ID(MARVELL_PHY_ID_88E1510): 590 if (phydev->dev_flags & MARVELL_PHY_LED0_LINK_LED1_ACTIVE) 591 def_config = MII_88E1510_PHY_LED0_LINK_LED1_ACTIVE; 592 else 593 def_config = MII_88E1510_PHY_LED_DEF; 594 break; 595 default: 596 return; 597 } 598 599 err = phy_write_paged(phydev, MII_MARVELL_LED_PAGE, MII_PHY_LED_CTRL, 600 def_config); 601 if (err < 0) 602 phydev_warn(phydev, "Fail to config marvell phy LED.\n"); 603 } 604 605 static int marvell_config_init(struct phy_device *phydev) 606 { 607 /* Set defalut LED */ 608 marvell_config_led(phydev); 609 610 /* Set registers from marvell,reg-init DT property */ 611 return marvell_of_reg_init(phydev); 612 } 613 614 static int m88e3016_config_init(struct phy_device *phydev) 615 { 616 int ret; 617 618 /* Enable Scrambler and Auto-Crossover */ 619 ret = phy_modify(phydev, MII_88E3016_PHY_SPEC_CTRL, 620 MII_88E3016_DISABLE_SCRAMBLER, 621 MII_88E3016_AUTO_MDIX_CROSSOVER); 622 if (ret < 0) 623 return ret; 624 625 return marvell_config_init(phydev); 626 } 627 628 static int m88e1111_config_init_hwcfg_mode(struct phy_device *phydev, 629 u16 mode, 630 int fibre_copper_auto) 631 { 632 if (fibre_copper_auto) 633 mode |= MII_M1111_HWCFG_FIBER_COPPER_AUTO; 634 635 return phy_modify(phydev, MII_M1111_PHY_EXT_SR, 636 MII_M1111_HWCFG_MODE_MASK | 637 MII_M1111_HWCFG_FIBER_COPPER_AUTO | 638 MII_M1111_HWCFG_FIBER_COPPER_RES, 639 mode); 640 } 641 642 static int m88e1111_config_init_rgmii_delays(struct phy_device *phydev) 643 { 644 int delay; 645 646 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID) { 647 delay = MII_M1111_RGMII_RX_DELAY | MII_M1111_RGMII_TX_DELAY; 648 } else if (phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) { 649 delay = MII_M1111_RGMII_RX_DELAY; 650 } else if (phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID) { 651 delay = MII_M1111_RGMII_TX_DELAY; 652 } else { 653 delay = 0; 654 } 655 656 return phy_modify(phydev, MII_M1111_PHY_EXT_CR, 657 MII_M1111_RGMII_RX_DELAY | MII_M1111_RGMII_TX_DELAY, 658 delay); 659 } 660 661 static int m88e1111_config_init_rgmii(struct phy_device *phydev) 662 { 663 int temp; 664 int err; 665 666 err = m88e1111_config_init_rgmii_delays(phydev); 667 if (err < 0) 668 return err; 669 670 temp = phy_read(phydev, MII_M1111_PHY_EXT_SR); 671 if (temp < 0) 672 return temp; 673 674 temp &= ~(MII_M1111_HWCFG_MODE_MASK); 675 676 if (temp & MII_M1111_HWCFG_FIBER_COPPER_RES) 677 temp |= MII_M1111_HWCFG_MODE_FIBER_RGMII; 678 else 679 temp |= MII_M1111_HWCFG_MODE_COPPER_RGMII; 680 681 return phy_write(phydev, MII_M1111_PHY_EXT_SR, temp); 682 } 683 684 static int m88e1111_config_init_sgmii(struct phy_device *phydev) 685 { 686 int err; 687 688 err = m88e1111_config_init_hwcfg_mode( 689 phydev, 690 MII_M1111_HWCFG_MODE_SGMII_NO_CLK, 691 MII_M1111_HWCFG_FIBER_COPPER_AUTO); 692 if (err < 0) 693 return err; 694 695 /* make sure copper is selected */ 696 return marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 697 } 698 699 static int m88e1111_config_init_rtbi(struct phy_device *phydev) 700 { 701 int err; 702 703 err = m88e1111_config_init_rgmii_delays(phydev); 704 if (err < 0) 705 return err; 706 707 err = m88e1111_config_init_hwcfg_mode( 708 phydev, 709 MII_M1111_HWCFG_MODE_RTBI, 710 MII_M1111_HWCFG_FIBER_COPPER_AUTO); 711 if (err < 0) 712 return err; 713 714 /* soft reset */ 715 err = genphy_soft_reset(phydev); 716 if (err < 0) 717 return err; 718 719 return m88e1111_config_init_hwcfg_mode( 720 phydev, 721 MII_M1111_HWCFG_MODE_RTBI, 722 MII_M1111_HWCFG_FIBER_COPPER_AUTO); 723 } 724 725 static int m88e1111_config_init(struct phy_device *phydev) 726 { 727 int err; 728 729 if (phy_interface_is_rgmii(phydev)) { 730 err = m88e1111_config_init_rgmii(phydev); 731 if (err < 0) 732 return err; 733 } 734 735 if (phydev->interface == PHY_INTERFACE_MODE_SGMII) { 736 err = m88e1111_config_init_sgmii(phydev); 737 if (err < 0) 738 return err; 739 } 740 741 if (phydev->interface == PHY_INTERFACE_MODE_RTBI) { 742 err = m88e1111_config_init_rtbi(phydev); 743 if (err < 0) 744 return err; 745 } 746 747 err = marvell_of_reg_init(phydev); 748 if (err < 0) 749 return err; 750 751 return genphy_soft_reset(phydev); 752 } 753 754 static int m88e1111_get_downshift(struct phy_device *phydev, u8 *data) 755 { 756 int val, cnt, enable; 757 758 val = phy_read(phydev, MII_M1111_PHY_EXT_CR); 759 if (val < 0) 760 return val; 761 762 enable = FIELD_GET(MII_M1111_PHY_EXT_CR_DOWNSHIFT_EN, val); 763 cnt = FIELD_GET(MII_M1111_PHY_EXT_CR_DOWNSHIFT_MASK, val) + 1; 764 765 *data = enable ? cnt : DOWNSHIFT_DEV_DISABLE; 766 767 return 0; 768 } 769 770 static int m88e1111_set_downshift(struct phy_device *phydev, u8 cnt) 771 { 772 int val; 773 774 if (cnt > MII_M1111_PHY_EXT_CR_DOWNSHIFT_MAX) 775 return -E2BIG; 776 777 if (!cnt) 778 return phy_clear_bits(phydev, MII_M1111_PHY_EXT_CR, 779 MII_M1111_PHY_EXT_CR_DOWNSHIFT_EN); 780 781 val = MII_M1111_PHY_EXT_CR_DOWNSHIFT_EN; 782 val |= FIELD_PREP(MII_M1111_PHY_EXT_CR_DOWNSHIFT_MASK, cnt - 1); 783 784 return phy_modify(phydev, MII_M1111_PHY_EXT_CR, 785 MII_M1111_PHY_EXT_CR_DOWNSHIFT_EN | 786 MII_M1111_PHY_EXT_CR_DOWNSHIFT_MASK, 787 val); 788 } 789 790 static int m88e1111_get_tunable(struct phy_device *phydev, 791 struct ethtool_tunable *tuna, void *data) 792 { 793 switch (tuna->id) { 794 case ETHTOOL_PHY_DOWNSHIFT: 795 return m88e1111_get_downshift(phydev, data); 796 default: 797 return -EOPNOTSUPP; 798 } 799 } 800 801 static int m88e1111_set_tunable(struct phy_device *phydev, 802 struct ethtool_tunable *tuna, const void *data) 803 { 804 switch (tuna->id) { 805 case ETHTOOL_PHY_DOWNSHIFT: 806 return m88e1111_set_downshift(phydev, *(const u8 *)data); 807 default: 808 return -EOPNOTSUPP; 809 } 810 } 811 812 static int m88e1011_get_downshift(struct phy_device *phydev, u8 *data) 813 { 814 int val, cnt, enable; 815 816 val = phy_read(phydev, MII_M1011_PHY_SCR); 817 if (val < 0) 818 return val; 819 820 enable = FIELD_GET(MII_M1011_PHY_SCR_DOWNSHIFT_EN, val); 821 cnt = FIELD_GET(MII_M1011_PHY_SCR_DOWNSHIFT_MASK, val) + 1; 822 823 *data = enable ? cnt : DOWNSHIFT_DEV_DISABLE; 824 825 return 0; 826 } 827 828 static int m88e1011_set_downshift(struct phy_device *phydev, u8 cnt) 829 { 830 int val; 831 832 if (cnt > MII_M1011_PHY_SCR_DOWNSHIFT_MAX) 833 return -E2BIG; 834 835 if (!cnt) 836 return phy_clear_bits(phydev, MII_M1011_PHY_SCR, 837 MII_M1011_PHY_SCR_DOWNSHIFT_EN); 838 839 val = MII_M1011_PHY_SCR_DOWNSHIFT_EN; 840 val |= FIELD_PREP(MII_M1011_PHY_SCR_DOWNSHIFT_MASK, cnt - 1); 841 842 return phy_modify(phydev, MII_M1011_PHY_SCR, 843 MII_M1011_PHY_SCR_DOWNSHIFT_EN | 844 MII_M1011_PHY_SCR_DOWNSHIFT_MASK, 845 val); 846 } 847 848 static int m88e1011_get_tunable(struct phy_device *phydev, 849 struct ethtool_tunable *tuna, void *data) 850 { 851 switch (tuna->id) { 852 case ETHTOOL_PHY_DOWNSHIFT: 853 return m88e1011_get_downshift(phydev, data); 854 default: 855 return -EOPNOTSUPP; 856 } 857 } 858 859 static int m88e1011_set_tunable(struct phy_device *phydev, 860 struct ethtool_tunable *tuna, const void *data) 861 { 862 switch (tuna->id) { 863 case ETHTOOL_PHY_DOWNSHIFT: 864 return m88e1011_set_downshift(phydev, *(const u8 *)data); 865 default: 866 return -EOPNOTSUPP; 867 } 868 } 869 870 static int m88e1116r_config_init(struct phy_device *phydev) 871 { 872 int err; 873 874 err = genphy_soft_reset(phydev); 875 if (err < 0) 876 return err; 877 878 msleep(500); 879 880 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 881 if (err < 0) 882 return err; 883 884 err = marvell_set_polarity(phydev, phydev->mdix_ctrl); 885 if (err < 0) 886 return err; 887 888 err = m88e1011_set_downshift(phydev, 8); 889 if (err < 0) 890 return err; 891 892 if (phy_interface_is_rgmii(phydev)) { 893 err = m88e1121_config_aneg_rgmii_delays(phydev); 894 if (err < 0) 895 return err; 896 } 897 898 err = genphy_soft_reset(phydev); 899 if (err < 0) 900 return err; 901 902 return marvell_config_init(phydev); 903 } 904 905 static int m88e1318_config_init(struct phy_device *phydev) 906 { 907 if (phy_interrupt_is_valid(phydev)) { 908 int err = phy_modify_paged( 909 phydev, MII_MARVELL_LED_PAGE, 910 MII_88E1318S_PHY_LED_TCR, 911 MII_88E1318S_PHY_LED_TCR_FORCE_INT, 912 MII_88E1318S_PHY_LED_TCR_INTn_ENABLE | 913 MII_88E1318S_PHY_LED_TCR_INT_ACTIVE_LOW); 914 if (err < 0) 915 return err; 916 } 917 918 return marvell_config_init(phydev); 919 } 920 921 static int m88e1510_config_init(struct phy_device *phydev) 922 { 923 int err; 924 925 /* SGMII-to-Copper mode initialization */ 926 if (phydev->interface == PHY_INTERFACE_MODE_SGMII) { 927 /* Select page 18 */ 928 err = marvell_set_page(phydev, 18); 929 if (err < 0) 930 return err; 931 932 /* In reg 20, write MODE[2:0] = 0x1 (SGMII to Copper) */ 933 err = phy_modify(phydev, MII_88E1510_GEN_CTRL_REG_1, 934 MII_88E1510_GEN_CTRL_REG_1_MODE_MASK, 935 MII_88E1510_GEN_CTRL_REG_1_MODE_SGMII); 936 if (err < 0) 937 return err; 938 939 /* PHY reset is necessary after changing MODE[2:0] */ 940 err = phy_modify(phydev, MII_88E1510_GEN_CTRL_REG_1, 0, 941 MII_88E1510_GEN_CTRL_REG_1_RESET); 942 if (err < 0) 943 return err; 944 945 /* Reset page selection */ 946 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 947 if (err < 0) 948 return err; 949 } 950 951 return m88e1318_config_init(phydev); 952 } 953 954 static int m88e1118_config_aneg(struct phy_device *phydev) 955 { 956 int err; 957 958 err = genphy_soft_reset(phydev); 959 if (err < 0) 960 return err; 961 962 err = marvell_set_polarity(phydev, phydev->mdix_ctrl); 963 if (err < 0) 964 return err; 965 966 err = genphy_config_aneg(phydev); 967 return 0; 968 } 969 970 static int m88e1118_config_init(struct phy_device *phydev) 971 { 972 int err; 973 974 /* Change address */ 975 err = marvell_set_page(phydev, MII_MARVELL_MSCR_PAGE); 976 if (err < 0) 977 return err; 978 979 /* Enable 1000 Mbit */ 980 err = phy_write(phydev, 0x15, 0x1070); 981 if (err < 0) 982 return err; 983 984 /* Change address */ 985 err = marvell_set_page(phydev, MII_MARVELL_LED_PAGE); 986 if (err < 0) 987 return err; 988 989 /* Adjust LED Control */ 990 if (phydev->dev_flags & MARVELL_PHY_M1118_DNS323_LEDS) 991 err = phy_write(phydev, 0x10, 0x1100); 992 else 993 err = phy_write(phydev, 0x10, 0x021e); 994 if (err < 0) 995 return err; 996 997 err = marvell_of_reg_init(phydev); 998 if (err < 0) 999 return err; 1000 1001 /* Reset address */ 1002 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1003 if (err < 0) 1004 return err; 1005 1006 return genphy_soft_reset(phydev); 1007 } 1008 1009 static int m88e1149_config_init(struct phy_device *phydev) 1010 { 1011 int err; 1012 1013 /* Change address */ 1014 err = marvell_set_page(phydev, MII_MARVELL_MSCR_PAGE); 1015 if (err < 0) 1016 return err; 1017 1018 /* Enable 1000 Mbit */ 1019 err = phy_write(phydev, 0x15, 0x1048); 1020 if (err < 0) 1021 return err; 1022 1023 err = marvell_of_reg_init(phydev); 1024 if (err < 0) 1025 return err; 1026 1027 /* Reset address */ 1028 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1029 if (err < 0) 1030 return err; 1031 1032 return genphy_soft_reset(phydev); 1033 } 1034 1035 static int m88e1145_config_init_rgmii(struct phy_device *phydev) 1036 { 1037 int err; 1038 1039 err = m88e1111_config_init_rgmii_delays(phydev); 1040 if (err < 0) 1041 return err; 1042 1043 if (phydev->dev_flags & MARVELL_PHY_M1145_FLAGS_RESISTANCE) { 1044 err = phy_write(phydev, 0x1d, 0x0012); 1045 if (err < 0) 1046 return err; 1047 1048 err = phy_modify(phydev, 0x1e, 0x0fc0, 1049 2 << 9 | /* 36 ohm */ 1050 2 << 6); /* 39 ohm */ 1051 if (err < 0) 1052 return err; 1053 1054 err = phy_write(phydev, 0x1d, 0x3); 1055 if (err < 0) 1056 return err; 1057 1058 err = phy_write(phydev, 0x1e, 0x8000); 1059 } 1060 return err; 1061 } 1062 1063 static int m88e1145_config_init_sgmii(struct phy_device *phydev) 1064 { 1065 return m88e1111_config_init_hwcfg_mode( 1066 phydev, MII_M1111_HWCFG_MODE_SGMII_NO_CLK, 1067 MII_M1111_HWCFG_FIBER_COPPER_AUTO); 1068 } 1069 1070 static int m88e1145_config_init(struct phy_device *phydev) 1071 { 1072 int err; 1073 1074 /* Take care of errata E0 & E1 */ 1075 err = phy_write(phydev, 0x1d, 0x001b); 1076 if (err < 0) 1077 return err; 1078 1079 err = phy_write(phydev, 0x1e, 0x418f); 1080 if (err < 0) 1081 return err; 1082 1083 err = phy_write(phydev, 0x1d, 0x0016); 1084 if (err < 0) 1085 return err; 1086 1087 err = phy_write(phydev, 0x1e, 0xa2da); 1088 if (err < 0) 1089 return err; 1090 1091 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID) { 1092 err = m88e1145_config_init_rgmii(phydev); 1093 if (err < 0) 1094 return err; 1095 } 1096 1097 if (phydev->interface == PHY_INTERFACE_MODE_SGMII) { 1098 err = m88e1145_config_init_sgmii(phydev); 1099 if (err < 0) 1100 return err; 1101 } 1102 1103 err = marvell_of_reg_init(phydev); 1104 if (err < 0) 1105 return err; 1106 1107 return 0; 1108 } 1109 1110 static int m88e1540_get_fld(struct phy_device *phydev, u8 *msecs) 1111 { 1112 int val; 1113 1114 val = phy_read(phydev, MII_88E1540_COPPER_CTRL3); 1115 if (val < 0) 1116 return val; 1117 1118 if (!(val & MII_88E1540_COPPER_CTRL3_FAST_LINK_DOWN)) { 1119 *msecs = ETHTOOL_PHY_FAST_LINK_DOWN_OFF; 1120 return 0; 1121 } 1122 1123 val = FIELD_GET(MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_MASK, val); 1124 1125 switch (val) { 1126 case MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_00MS: 1127 *msecs = 0; 1128 break; 1129 case MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_10MS: 1130 *msecs = 10; 1131 break; 1132 case MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_20MS: 1133 *msecs = 20; 1134 break; 1135 case MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_40MS: 1136 *msecs = 40; 1137 break; 1138 default: 1139 return -EINVAL; 1140 } 1141 1142 return 0; 1143 } 1144 1145 static int m88e1540_set_fld(struct phy_device *phydev, const u8 *msecs) 1146 { 1147 struct ethtool_eee eee; 1148 int val, ret; 1149 1150 if (*msecs == ETHTOOL_PHY_FAST_LINK_DOWN_OFF) 1151 return phy_clear_bits(phydev, MII_88E1540_COPPER_CTRL3, 1152 MII_88E1540_COPPER_CTRL3_FAST_LINK_DOWN); 1153 1154 /* According to the Marvell data sheet EEE must be disabled for 1155 * Fast Link Down detection to work properly 1156 */ 1157 ret = phy_ethtool_get_eee(phydev, &eee); 1158 if (!ret && eee.eee_enabled) { 1159 phydev_warn(phydev, "Fast Link Down detection requires EEE to be disabled!\n"); 1160 return -EBUSY; 1161 } 1162 1163 if (*msecs <= 5) 1164 val = MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_00MS; 1165 else if (*msecs <= 15) 1166 val = MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_10MS; 1167 else if (*msecs <= 30) 1168 val = MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_20MS; 1169 else 1170 val = MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_40MS; 1171 1172 val = FIELD_PREP(MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_MASK, val); 1173 1174 ret = phy_modify(phydev, MII_88E1540_COPPER_CTRL3, 1175 MII_88E1540_COPPER_CTRL3_LINK_DOWN_DELAY_MASK, val); 1176 if (ret) 1177 return ret; 1178 1179 return phy_set_bits(phydev, MII_88E1540_COPPER_CTRL3, 1180 MII_88E1540_COPPER_CTRL3_FAST_LINK_DOWN); 1181 } 1182 1183 static int m88e1540_get_tunable(struct phy_device *phydev, 1184 struct ethtool_tunable *tuna, void *data) 1185 { 1186 switch (tuna->id) { 1187 case ETHTOOL_PHY_FAST_LINK_DOWN: 1188 return m88e1540_get_fld(phydev, data); 1189 case ETHTOOL_PHY_DOWNSHIFT: 1190 return m88e1011_get_downshift(phydev, data); 1191 default: 1192 return -EOPNOTSUPP; 1193 } 1194 } 1195 1196 static int m88e1540_set_tunable(struct phy_device *phydev, 1197 struct ethtool_tunable *tuna, const void *data) 1198 { 1199 switch (tuna->id) { 1200 case ETHTOOL_PHY_FAST_LINK_DOWN: 1201 return m88e1540_set_fld(phydev, data); 1202 case ETHTOOL_PHY_DOWNSHIFT: 1203 return m88e1011_set_downshift(phydev, *(const u8 *)data); 1204 default: 1205 return -EOPNOTSUPP; 1206 } 1207 } 1208 1209 /* The VOD can be out of specification on link up. Poke an 1210 * undocumented register, in an undocumented page, with a magic value 1211 * to fix this. 1212 */ 1213 static int m88e6390_errata(struct phy_device *phydev) 1214 { 1215 int err; 1216 1217 err = phy_write(phydev, MII_BMCR, 1218 BMCR_ANENABLE | BMCR_SPEED1000 | BMCR_FULLDPLX); 1219 if (err) 1220 return err; 1221 1222 usleep_range(300, 400); 1223 1224 err = phy_write_paged(phydev, 0xf8, 0x08, 0x36); 1225 if (err) 1226 return err; 1227 1228 return genphy_soft_reset(phydev); 1229 } 1230 1231 static int m88e6390_config_aneg(struct phy_device *phydev) 1232 { 1233 int err; 1234 1235 err = m88e6390_errata(phydev); 1236 if (err) 1237 return err; 1238 1239 return m88e1510_config_aneg(phydev); 1240 } 1241 1242 /** 1243 * fiber_lpa_mod_linkmode_lpa_t 1244 * @advertising: the linkmode advertisement settings 1245 * @lpa: value of the MII_LPA register for fiber link 1246 * 1247 * A small helper function that translates MII_LPA bits to linkmode LP 1248 * advertisement settings. Other bits in advertising are left 1249 * unchanged. 1250 */ 1251 static void fiber_lpa_mod_linkmode_lpa_t(unsigned long *advertising, u32 lpa) 1252 { 1253 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 1254 advertising, lpa & LPA_1000XHALF); 1255 1256 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1257 advertising, lpa & LPA_1000XFULL); 1258 } 1259 1260 static int marvell_read_status_page_an(struct phy_device *phydev, 1261 int fiber, int status) 1262 { 1263 int lpa; 1264 int err; 1265 1266 if (!(status & MII_M1011_PHY_STATUS_RESOLVED)) { 1267 phydev->link = 0; 1268 return 0; 1269 } 1270 1271 if (status & MII_M1011_PHY_STATUS_FULLDUPLEX) 1272 phydev->duplex = DUPLEX_FULL; 1273 else 1274 phydev->duplex = DUPLEX_HALF; 1275 1276 switch (status & MII_M1011_PHY_STATUS_SPD_MASK) { 1277 case MII_M1011_PHY_STATUS_1000: 1278 phydev->speed = SPEED_1000; 1279 break; 1280 1281 case MII_M1011_PHY_STATUS_100: 1282 phydev->speed = SPEED_100; 1283 break; 1284 1285 default: 1286 phydev->speed = SPEED_10; 1287 break; 1288 } 1289 1290 if (!fiber) { 1291 err = genphy_read_lpa(phydev); 1292 if (err < 0) 1293 return err; 1294 1295 phy_resolve_aneg_pause(phydev); 1296 } else { 1297 lpa = phy_read(phydev, MII_LPA); 1298 if (lpa < 0) 1299 return lpa; 1300 1301 /* The fiber link is only 1000M capable */ 1302 fiber_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa); 1303 1304 if (phydev->duplex == DUPLEX_FULL) { 1305 if (!(lpa & LPA_PAUSE_FIBER)) { 1306 phydev->pause = 0; 1307 phydev->asym_pause = 0; 1308 } else if ((lpa & LPA_PAUSE_ASYM_FIBER)) { 1309 phydev->pause = 1; 1310 phydev->asym_pause = 1; 1311 } else { 1312 phydev->pause = 1; 1313 phydev->asym_pause = 0; 1314 } 1315 } 1316 } 1317 1318 return 0; 1319 } 1320 1321 /* marvell_read_status_page 1322 * 1323 * Description: 1324 * Check the link, then figure out the current state 1325 * by comparing what we advertise with what the link partner 1326 * advertises. Start by checking the gigabit possibilities, 1327 * then move on to 10/100. 1328 */ 1329 static int marvell_read_status_page(struct phy_device *phydev, int page) 1330 { 1331 int status; 1332 int fiber; 1333 int err; 1334 1335 status = phy_read(phydev, MII_M1011_PHY_STATUS); 1336 if (status < 0) 1337 return status; 1338 1339 /* Use the generic register for copper link status, 1340 * and the PHY status register for fiber link status. 1341 */ 1342 if (page == MII_MARVELL_FIBER_PAGE) { 1343 phydev->link = !!(status & MII_M1011_PHY_STATUS_LINK); 1344 } else { 1345 err = genphy_update_link(phydev); 1346 if (err) 1347 return err; 1348 } 1349 1350 if (page == MII_MARVELL_FIBER_PAGE) 1351 fiber = 1; 1352 else 1353 fiber = 0; 1354 1355 linkmode_zero(phydev->lp_advertising); 1356 phydev->pause = 0; 1357 phydev->asym_pause = 0; 1358 phydev->speed = SPEED_UNKNOWN; 1359 phydev->duplex = DUPLEX_UNKNOWN; 1360 1361 if (phydev->autoneg == AUTONEG_ENABLE) 1362 err = marvell_read_status_page_an(phydev, fiber, status); 1363 else 1364 err = genphy_read_status_fixed(phydev); 1365 1366 return err; 1367 } 1368 1369 /* marvell_read_status 1370 * 1371 * Some Marvell's phys have two modes: fiber and copper. 1372 * Both need status checked. 1373 * Description: 1374 * First, check the fiber link and status. 1375 * If the fiber link is down, check the copper link and status which 1376 * will be the default value if both link are down. 1377 */ 1378 static int marvell_read_status(struct phy_device *phydev) 1379 { 1380 int err; 1381 1382 /* Check the fiber mode first */ 1383 if (linkmode_test_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, 1384 phydev->supported) && 1385 phydev->interface != PHY_INTERFACE_MODE_SGMII) { 1386 err = marvell_set_page(phydev, MII_MARVELL_FIBER_PAGE); 1387 if (err < 0) 1388 goto error; 1389 1390 err = marvell_read_status_page(phydev, MII_MARVELL_FIBER_PAGE); 1391 if (err < 0) 1392 goto error; 1393 1394 /* If the fiber link is up, it is the selected and 1395 * used link. In this case, we need to stay in the 1396 * fiber page. Please to be careful about that, avoid 1397 * to restore Copper page in other functions which 1398 * could break the behaviour for some fiber phy like 1399 * 88E1512. 1400 */ 1401 if (phydev->link) 1402 return 0; 1403 1404 /* If fiber link is down, check and save copper mode state */ 1405 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1406 if (err < 0) 1407 goto error; 1408 } 1409 1410 return marvell_read_status_page(phydev, MII_MARVELL_COPPER_PAGE); 1411 1412 error: 1413 marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1414 return err; 1415 } 1416 1417 /* marvell_suspend 1418 * 1419 * Some Marvell's phys have two modes: fiber and copper. 1420 * Both need to be suspended 1421 */ 1422 static int marvell_suspend(struct phy_device *phydev) 1423 { 1424 int err; 1425 1426 /* Suspend the fiber mode first */ 1427 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, 1428 phydev->supported)) { 1429 err = marvell_set_page(phydev, MII_MARVELL_FIBER_PAGE); 1430 if (err < 0) 1431 goto error; 1432 1433 /* With the page set, use the generic suspend */ 1434 err = genphy_suspend(phydev); 1435 if (err < 0) 1436 goto error; 1437 1438 /* Then, the copper link */ 1439 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1440 if (err < 0) 1441 goto error; 1442 } 1443 1444 /* With the page set, use the generic suspend */ 1445 return genphy_suspend(phydev); 1446 1447 error: 1448 marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1449 return err; 1450 } 1451 1452 /* marvell_resume 1453 * 1454 * Some Marvell's phys have two modes: fiber and copper. 1455 * Both need to be resumed 1456 */ 1457 static int marvell_resume(struct phy_device *phydev) 1458 { 1459 int err; 1460 1461 /* Resume the fiber mode first */ 1462 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, 1463 phydev->supported)) { 1464 err = marvell_set_page(phydev, MII_MARVELL_FIBER_PAGE); 1465 if (err < 0) 1466 goto error; 1467 1468 /* With the page set, use the generic resume */ 1469 err = genphy_resume(phydev); 1470 if (err < 0) 1471 goto error; 1472 1473 /* Then, the copper link */ 1474 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1475 if (err < 0) 1476 goto error; 1477 } 1478 1479 /* With the page set, use the generic resume */ 1480 return genphy_resume(phydev); 1481 1482 error: 1483 marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 1484 return err; 1485 } 1486 1487 static int marvell_aneg_done(struct phy_device *phydev) 1488 { 1489 int retval = phy_read(phydev, MII_M1011_PHY_STATUS); 1490 1491 return (retval < 0) ? retval : (retval & MII_M1011_PHY_STATUS_RESOLVED); 1492 } 1493 1494 static int m88e1121_did_interrupt(struct phy_device *phydev) 1495 { 1496 int imask; 1497 1498 imask = phy_read(phydev, MII_M1011_IEVENT); 1499 1500 if (imask & MII_M1011_IMASK_INIT) 1501 return 1; 1502 1503 return 0; 1504 } 1505 1506 static void m88e1318_get_wol(struct phy_device *phydev, 1507 struct ethtool_wolinfo *wol) 1508 { 1509 int oldpage, ret = 0; 1510 1511 wol->supported = WAKE_MAGIC; 1512 wol->wolopts = 0; 1513 1514 oldpage = phy_select_page(phydev, MII_MARVELL_WOL_PAGE); 1515 if (oldpage < 0) 1516 goto error; 1517 1518 ret = __phy_read(phydev, MII_88E1318S_PHY_WOL_CTRL); 1519 if (ret & MII_88E1318S_PHY_WOL_CTRL_MAGIC_PACKET_MATCH_ENABLE) 1520 wol->wolopts |= WAKE_MAGIC; 1521 1522 error: 1523 phy_restore_page(phydev, oldpage, ret); 1524 } 1525 1526 static int m88e1318_set_wol(struct phy_device *phydev, 1527 struct ethtool_wolinfo *wol) 1528 { 1529 int err = 0, oldpage; 1530 1531 oldpage = phy_save_page(phydev); 1532 if (oldpage < 0) 1533 goto error; 1534 1535 if (wol->wolopts & WAKE_MAGIC) { 1536 /* Explicitly switch to page 0x00, just to be sure */ 1537 err = marvell_write_page(phydev, MII_MARVELL_COPPER_PAGE); 1538 if (err < 0) 1539 goto error; 1540 1541 /* If WOL event happened once, the LED[2] interrupt pin 1542 * will not be cleared unless we reading the interrupt status 1543 * register. If interrupts are in use, the normal interrupt 1544 * handling will clear the WOL event. Clear the WOL event 1545 * before enabling it if !phy_interrupt_is_valid() 1546 */ 1547 if (!phy_interrupt_is_valid(phydev)) 1548 __phy_read(phydev, MII_M1011_IEVENT); 1549 1550 /* Enable the WOL interrupt */ 1551 err = __phy_modify(phydev, MII_88E1318S_PHY_CSIER, 0, 1552 MII_88E1318S_PHY_CSIER_WOL_EIE); 1553 if (err < 0) 1554 goto error; 1555 1556 err = marvell_write_page(phydev, MII_MARVELL_LED_PAGE); 1557 if (err < 0) 1558 goto error; 1559 1560 /* Setup LED[2] as interrupt pin (active low) */ 1561 err = __phy_modify(phydev, MII_88E1318S_PHY_LED_TCR, 1562 MII_88E1318S_PHY_LED_TCR_FORCE_INT, 1563 MII_88E1318S_PHY_LED_TCR_INTn_ENABLE | 1564 MII_88E1318S_PHY_LED_TCR_INT_ACTIVE_LOW); 1565 if (err < 0) 1566 goto error; 1567 1568 err = marvell_write_page(phydev, MII_MARVELL_WOL_PAGE); 1569 if (err < 0) 1570 goto error; 1571 1572 /* Store the device address for the magic packet */ 1573 err = __phy_write(phydev, MII_88E1318S_PHY_MAGIC_PACKET_WORD2, 1574 ((phydev->attached_dev->dev_addr[5] << 8) | 1575 phydev->attached_dev->dev_addr[4])); 1576 if (err < 0) 1577 goto error; 1578 err = __phy_write(phydev, MII_88E1318S_PHY_MAGIC_PACKET_WORD1, 1579 ((phydev->attached_dev->dev_addr[3] << 8) | 1580 phydev->attached_dev->dev_addr[2])); 1581 if (err < 0) 1582 goto error; 1583 err = __phy_write(phydev, MII_88E1318S_PHY_MAGIC_PACKET_WORD0, 1584 ((phydev->attached_dev->dev_addr[1] << 8) | 1585 phydev->attached_dev->dev_addr[0])); 1586 if (err < 0) 1587 goto error; 1588 1589 /* Clear WOL status and enable magic packet matching */ 1590 err = __phy_modify(phydev, MII_88E1318S_PHY_WOL_CTRL, 0, 1591 MII_88E1318S_PHY_WOL_CTRL_CLEAR_WOL_STATUS | 1592 MII_88E1318S_PHY_WOL_CTRL_MAGIC_PACKET_MATCH_ENABLE); 1593 if (err < 0) 1594 goto error; 1595 } else { 1596 err = marvell_write_page(phydev, MII_MARVELL_WOL_PAGE); 1597 if (err < 0) 1598 goto error; 1599 1600 /* Clear WOL status and disable magic packet matching */ 1601 err = __phy_modify(phydev, MII_88E1318S_PHY_WOL_CTRL, 1602 MII_88E1318S_PHY_WOL_CTRL_MAGIC_PACKET_MATCH_ENABLE, 1603 MII_88E1318S_PHY_WOL_CTRL_CLEAR_WOL_STATUS); 1604 if (err < 0) 1605 goto error; 1606 } 1607 1608 error: 1609 return phy_restore_page(phydev, oldpage, err); 1610 } 1611 1612 static int marvell_get_sset_count(struct phy_device *phydev) 1613 { 1614 if (linkmode_test_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, 1615 phydev->supported)) 1616 return ARRAY_SIZE(marvell_hw_stats); 1617 else 1618 return ARRAY_SIZE(marvell_hw_stats) - NB_FIBER_STATS; 1619 } 1620 1621 static void marvell_get_strings(struct phy_device *phydev, u8 *data) 1622 { 1623 int count = marvell_get_sset_count(phydev); 1624 int i; 1625 1626 for (i = 0; i < count; i++) { 1627 strlcpy(data + i * ETH_GSTRING_LEN, 1628 marvell_hw_stats[i].string, ETH_GSTRING_LEN); 1629 } 1630 } 1631 1632 static u64 marvell_get_stat(struct phy_device *phydev, int i) 1633 { 1634 struct marvell_hw_stat stat = marvell_hw_stats[i]; 1635 struct marvell_priv *priv = phydev->priv; 1636 int val; 1637 u64 ret; 1638 1639 val = phy_read_paged(phydev, stat.page, stat.reg); 1640 if (val < 0) { 1641 ret = U64_MAX; 1642 } else { 1643 val = val & ((1 << stat.bits) - 1); 1644 priv->stats[i] += val; 1645 ret = priv->stats[i]; 1646 } 1647 1648 return ret; 1649 } 1650 1651 static void marvell_get_stats(struct phy_device *phydev, 1652 struct ethtool_stats *stats, u64 *data) 1653 { 1654 int count = marvell_get_sset_count(phydev); 1655 int i; 1656 1657 for (i = 0; i < count; i++) 1658 data[i] = marvell_get_stat(phydev, i); 1659 } 1660 1661 #ifdef CONFIG_HWMON 1662 static int m88e1121_get_temp(struct phy_device *phydev, long *temp) 1663 { 1664 int oldpage; 1665 int ret = 0; 1666 int val; 1667 1668 *temp = 0; 1669 1670 oldpage = phy_select_page(phydev, MII_MARVELL_MISC_TEST_PAGE); 1671 if (oldpage < 0) 1672 goto error; 1673 1674 /* Enable temperature sensor */ 1675 ret = __phy_read(phydev, MII_88E1121_MISC_TEST); 1676 if (ret < 0) 1677 goto error; 1678 1679 ret = __phy_write(phydev, MII_88E1121_MISC_TEST, 1680 ret | MII_88E1121_MISC_TEST_TEMP_SENSOR_EN); 1681 if (ret < 0) 1682 goto error; 1683 1684 /* Wait for temperature to stabilize */ 1685 usleep_range(10000, 12000); 1686 1687 val = __phy_read(phydev, MII_88E1121_MISC_TEST); 1688 if (val < 0) { 1689 ret = val; 1690 goto error; 1691 } 1692 1693 /* Disable temperature sensor */ 1694 ret = __phy_write(phydev, MII_88E1121_MISC_TEST, 1695 ret & ~MII_88E1121_MISC_TEST_TEMP_SENSOR_EN); 1696 if (ret < 0) 1697 goto error; 1698 1699 *temp = ((val & MII_88E1121_MISC_TEST_TEMP_MASK) - 5) * 5000; 1700 1701 error: 1702 return phy_restore_page(phydev, oldpage, ret); 1703 } 1704 1705 static int m88e1121_hwmon_read(struct device *dev, 1706 enum hwmon_sensor_types type, 1707 u32 attr, int channel, long *temp) 1708 { 1709 struct phy_device *phydev = dev_get_drvdata(dev); 1710 int err; 1711 1712 switch (attr) { 1713 case hwmon_temp_input: 1714 err = m88e1121_get_temp(phydev, temp); 1715 break; 1716 default: 1717 return -EOPNOTSUPP; 1718 } 1719 1720 return err; 1721 } 1722 1723 static umode_t m88e1121_hwmon_is_visible(const void *data, 1724 enum hwmon_sensor_types type, 1725 u32 attr, int channel) 1726 { 1727 if (type != hwmon_temp) 1728 return 0; 1729 1730 switch (attr) { 1731 case hwmon_temp_input: 1732 return 0444; 1733 default: 1734 return 0; 1735 } 1736 } 1737 1738 static u32 m88e1121_hwmon_chip_config[] = { 1739 HWMON_C_REGISTER_TZ, 1740 0 1741 }; 1742 1743 static const struct hwmon_channel_info m88e1121_hwmon_chip = { 1744 .type = hwmon_chip, 1745 .config = m88e1121_hwmon_chip_config, 1746 }; 1747 1748 static u32 m88e1121_hwmon_temp_config[] = { 1749 HWMON_T_INPUT, 1750 0 1751 }; 1752 1753 static const struct hwmon_channel_info m88e1121_hwmon_temp = { 1754 .type = hwmon_temp, 1755 .config = m88e1121_hwmon_temp_config, 1756 }; 1757 1758 static const struct hwmon_channel_info *m88e1121_hwmon_info[] = { 1759 &m88e1121_hwmon_chip, 1760 &m88e1121_hwmon_temp, 1761 NULL 1762 }; 1763 1764 static const struct hwmon_ops m88e1121_hwmon_hwmon_ops = { 1765 .is_visible = m88e1121_hwmon_is_visible, 1766 .read = m88e1121_hwmon_read, 1767 }; 1768 1769 static const struct hwmon_chip_info m88e1121_hwmon_chip_info = { 1770 .ops = &m88e1121_hwmon_hwmon_ops, 1771 .info = m88e1121_hwmon_info, 1772 }; 1773 1774 static int m88e1510_get_temp(struct phy_device *phydev, long *temp) 1775 { 1776 int ret; 1777 1778 *temp = 0; 1779 1780 ret = phy_read_paged(phydev, MII_MARVELL_MISC_TEST_PAGE, 1781 MII_88E1510_TEMP_SENSOR); 1782 if (ret < 0) 1783 return ret; 1784 1785 *temp = ((ret & MII_88E1510_TEMP_SENSOR_MASK) - 25) * 1000; 1786 1787 return 0; 1788 } 1789 1790 static int m88e1510_get_temp_critical(struct phy_device *phydev, long *temp) 1791 { 1792 int ret; 1793 1794 *temp = 0; 1795 1796 ret = phy_read_paged(phydev, MII_MARVELL_MISC_TEST_PAGE, 1797 MII_88E1121_MISC_TEST); 1798 if (ret < 0) 1799 return ret; 1800 1801 *temp = (((ret & MII_88E1510_MISC_TEST_TEMP_THRESHOLD_MASK) >> 1802 MII_88E1510_MISC_TEST_TEMP_THRESHOLD_SHIFT) * 5) - 25; 1803 /* convert to mC */ 1804 *temp *= 1000; 1805 1806 return 0; 1807 } 1808 1809 static int m88e1510_set_temp_critical(struct phy_device *phydev, long temp) 1810 { 1811 temp = temp / 1000; 1812 temp = clamp_val(DIV_ROUND_CLOSEST(temp, 5) + 5, 0, 0x1f); 1813 1814 return phy_modify_paged(phydev, MII_MARVELL_MISC_TEST_PAGE, 1815 MII_88E1121_MISC_TEST, 1816 MII_88E1510_MISC_TEST_TEMP_THRESHOLD_MASK, 1817 temp << MII_88E1510_MISC_TEST_TEMP_THRESHOLD_SHIFT); 1818 } 1819 1820 static int m88e1510_get_temp_alarm(struct phy_device *phydev, long *alarm) 1821 { 1822 int ret; 1823 1824 *alarm = false; 1825 1826 ret = phy_read_paged(phydev, MII_MARVELL_MISC_TEST_PAGE, 1827 MII_88E1121_MISC_TEST); 1828 if (ret < 0) 1829 return ret; 1830 1831 *alarm = !!(ret & MII_88E1510_MISC_TEST_TEMP_IRQ); 1832 1833 return 0; 1834 } 1835 1836 static int m88e1510_hwmon_read(struct device *dev, 1837 enum hwmon_sensor_types type, 1838 u32 attr, int channel, long *temp) 1839 { 1840 struct phy_device *phydev = dev_get_drvdata(dev); 1841 int err; 1842 1843 switch (attr) { 1844 case hwmon_temp_input: 1845 err = m88e1510_get_temp(phydev, temp); 1846 break; 1847 case hwmon_temp_crit: 1848 err = m88e1510_get_temp_critical(phydev, temp); 1849 break; 1850 case hwmon_temp_max_alarm: 1851 err = m88e1510_get_temp_alarm(phydev, temp); 1852 break; 1853 default: 1854 return -EOPNOTSUPP; 1855 } 1856 1857 return err; 1858 } 1859 1860 static int m88e1510_hwmon_write(struct device *dev, 1861 enum hwmon_sensor_types type, 1862 u32 attr, int channel, long temp) 1863 { 1864 struct phy_device *phydev = dev_get_drvdata(dev); 1865 int err; 1866 1867 switch (attr) { 1868 case hwmon_temp_crit: 1869 err = m88e1510_set_temp_critical(phydev, temp); 1870 break; 1871 default: 1872 return -EOPNOTSUPP; 1873 } 1874 return err; 1875 } 1876 1877 static umode_t m88e1510_hwmon_is_visible(const void *data, 1878 enum hwmon_sensor_types type, 1879 u32 attr, int channel) 1880 { 1881 if (type != hwmon_temp) 1882 return 0; 1883 1884 switch (attr) { 1885 case hwmon_temp_input: 1886 case hwmon_temp_max_alarm: 1887 return 0444; 1888 case hwmon_temp_crit: 1889 return 0644; 1890 default: 1891 return 0; 1892 } 1893 } 1894 1895 static u32 m88e1510_hwmon_temp_config[] = { 1896 HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_MAX_ALARM, 1897 0 1898 }; 1899 1900 static const struct hwmon_channel_info m88e1510_hwmon_temp = { 1901 .type = hwmon_temp, 1902 .config = m88e1510_hwmon_temp_config, 1903 }; 1904 1905 static const struct hwmon_channel_info *m88e1510_hwmon_info[] = { 1906 &m88e1121_hwmon_chip, 1907 &m88e1510_hwmon_temp, 1908 NULL 1909 }; 1910 1911 static const struct hwmon_ops m88e1510_hwmon_hwmon_ops = { 1912 .is_visible = m88e1510_hwmon_is_visible, 1913 .read = m88e1510_hwmon_read, 1914 .write = m88e1510_hwmon_write, 1915 }; 1916 1917 static const struct hwmon_chip_info m88e1510_hwmon_chip_info = { 1918 .ops = &m88e1510_hwmon_hwmon_ops, 1919 .info = m88e1510_hwmon_info, 1920 }; 1921 1922 static int m88e6390_get_temp(struct phy_device *phydev, long *temp) 1923 { 1924 int sum = 0; 1925 int oldpage; 1926 int ret = 0; 1927 int i; 1928 1929 *temp = 0; 1930 1931 oldpage = phy_select_page(phydev, MII_MARVELL_MISC_TEST_PAGE); 1932 if (oldpage < 0) 1933 goto error; 1934 1935 /* Enable temperature sensor */ 1936 ret = __phy_read(phydev, MII_88E6390_MISC_TEST); 1937 if (ret < 0) 1938 goto error; 1939 1940 ret = ret & ~MII_88E6390_MISC_TEST_SAMPLE_MASK; 1941 ret |= MII_88E6390_MISC_TEST_SAMPLE_ENABLE | 1942 MII_88E6390_MISC_TEST_SAMPLE_1S; 1943 1944 ret = __phy_write(phydev, MII_88E6390_MISC_TEST, ret); 1945 if (ret < 0) 1946 goto error; 1947 1948 /* Wait for temperature to stabilize */ 1949 usleep_range(10000, 12000); 1950 1951 /* Reading the temperature sense has an errata. You need to read 1952 * a number of times and take an average. 1953 */ 1954 for (i = 0; i < MII_88E6390_TEMP_SENSOR_SAMPLES; i++) { 1955 ret = __phy_read(phydev, MII_88E6390_TEMP_SENSOR); 1956 if (ret < 0) 1957 goto error; 1958 sum += ret & MII_88E6390_TEMP_SENSOR_MASK; 1959 } 1960 1961 sum /= MII_88E6390_TEMP_SENSOR_SAMPLES; 1962 *temp = (sum - 75) * 1000; 1963 1964 /* Disable temperature sensor */ 1965 ret = __phy_read(phydev, MII_88E6390_MISC_TEST); 1966 if (ret < 0) 1967 goto error; 1968 1969 ret = ret & ~MII_88E6390_MISC_TEST_SAMPLE_MASK; 1970 ret |= MII_88E6390_MISC_TEST_SAMPLE_DISABLE; 1971 1972 ret = __phy_write(phydev, MII_88E6390_MISC_TEST, ret); 1973 1974 error: 1975 phy_restore_page(phydev, oldpage, ret); 1976 1977 return ret; 1978 } 1979 1980 static int m88e6390_hwmon_read(struct device *dev, 1981 enum hwmon_sensor_types type, 1982 u32 attr, int channel, long *temp) 1983 { 1984 struct phy_device *phydev = dev_get_drvdata(dev); 1985 int err; 1986 1987 switch (attr) { 1988 case hwmon_temp_input: 1989 err = m88e6390_get_temp(phydev, temp); 1990 break; 1991 default: 1992 return -EOPNOTSUPP; 1993 } 1994 1995 return err; 1996 } 1997 1998 static umode_t m88e6390_hwmon_is_visible(const void *data, 1999 enum hwmon_sensor_types type, 2000 u32 attr, int channel) 2001 { 2002 if (type != hwmon_temp) 2003 return 0; 2004 2005 switch (attr) { 2006 case hwmon_temp_input: 2007 return 0444; 2008 default: 2009 return 0; 2010 } 2011 } 2012 2013 static u32 m88e6390_hwmon_temp_config[] = { 2014 HWMON_T_INPUT, 2015 0 2016 }; 2017 2018 static const struct hwmon_channel_info m88e6390_hwmon_temp = { 2019 .type = hwmon_temp, 2020 .config = m88e6390_hwmon_temp_config, 2021 }; 2022 2023 static const struct hwmon_channel_info *m88e6390_hwmon_info[] = { 2024 &m88e1121_hwmon_chip, 2025 &m88e6390_hwmon_temp, 2026 NULL 2027 }; 2028 2029 static const struct hwmon_ops m88e6390_hwmon_hwmon_ops = { 2030 .is_visible = m88e6390_hwmon_is_visible, 2031 .read = m88e6390_hwmon_read, 2032 }; 2033 2034 static const struct hwmon_chip_info m88e6390_hwmon_chip_info = { 2035 .ops = &m88e6390_hwmon_hwmon_ops, 2036 .info = m88e6390_hwmon_info, 2037 }; 2038 2039 static int marvell_hwmon_name(struct phy_device *phydev) 2040 { 2041 struct marvell_priv *priv = phydev->priv; 2042 struct device *dev = &phydev->mdio.dev; 2043 const char *devname = dev_name(dev); 2044 size_t len = strlen(devname); 2045 int i, j; 2046 2047 priv->hwmon_name = devm_kzalloc(dev, len, GFP_KERNEL); 2048 if (!priv->hwmon_name) 2049 return -ENOMEM; 2050 2051 for (i = j = 0; i < len && devname[i]; i++) { 2052 if (isalnum(devname[i])) 2053 priv->hwmon_name[j++] = devname[i]; 2054 } 2055 2056 return 0; 2057 } 2058 2059 static int marvell_hwmon_probe(struct phy_device *phydev, 2060 const struct hwmon_chip_info *chip) 2061 { 2062 struct marvell_priv *priv = phydev->priv; 2063 struct device *dev = &phydev->mdio.dev; 2064 int err; 2065 2066 err = marvell_hwmon_name(phydev); 2067 if (err) 2068 return err; 2069 2070 priv->hwmon_dev = devm_hwmon_device_register_with_info( 2071 dev, priv->hwmon_name, phydev, chip, NULL); 2072 2073 return PTR_ERR_OR_ZERO(priv->hwmon_dev); 2074 } 2075 2076 static int m88e1121_hwmon_probe(struct phy_device *phydev) 2077 { 2078 return marvell_hwmon_probe(phydev, &m88e1121_hwmon_chip_info); 2079 } 2080 2081 static int m88e1510_hwmon_probe(struct phy_device *phydev) 2082 { 2083 return marvell_hwmon_probe(phydev, &m88e1510_hwmon_chip_info); 2084 } 2085 2086 static int m88e6390_hwmon_probe(struct phy_device *phydev) 2087 { 2088 return marvell_hwmon_probe(phydev, &m88e6390_hwmon_chip_info); 2089 } 2090 #else 2091 static int m88e1121_hwmon_probe(struct phy_device *phydev) 2092 { 2093 return 0; 2094 } 2095 2096 static int m88e1510_hwmon_probe(struct phy_device *phydev) 2097 { 2098 return 0; 2099 } 2100 2101 static int m88e6390_hwmon_probe(struct phy_device *phydev) 2102 { 2103 return 0; 2104 } 2105 #endif 2106 2107 static int marvell_probe(struct phy_device *phydev) 2108 { 2109 struct marvell_priv *priv; 2110 2111 priv = devm_kzalloc(&phydev->mdio.dev, sizeof(*priv), GFP_KERNEL); 2112 if (!priv) 2113 return -ENOMEM; 2114 2115 phydev->priv = priv; 2116 2117 return 0; 2118 } 2119 2120 static int m88e1121_probe(struct phy_device *phydev) 2121 { 2122 int err; 2123 2124 err = marvell_probe(phydev); 2125 if (err) 2126 return err; 2127 2128 return m88e1121_hwmon_probe(phydev); 2129 } 2130 2131 static int m88e1510_probe(struct phy_device *phydev) 2132 { 2133 int err; 2134 2135 err = marvell_probe(phydev); 2136 if (err) 2137 return err; 2138 2139 return m88e1510_hwmon_probe(phydev); 2140 } 2141 2142 static int m88e6390_probe(struct phy_device *phydev) 2143 { 2144 int err; 2145 2146 err = marvell_probe(phydev); 2147 if (err) 2148 return err; 2149 2150 return m88e6390_hwmon_probe(phydev); 2151 } 2152 2153 static struct phy_driver marvell_drivers[] = { 2154 { 2155 .phy_id = MARVELL_PHY_ID_88E1101, 2156 .phy_id_mask = MARVELL_PHY_ID_MASK, 2157 .name = "Marvell 88E1101", 2158 /* PHY_GBIT_FEATURES */ 2159 .probe = marvell_probe, 2160 .config_init = &marvell_config_init, 2161 .config_aneg = &m88e1101_config_aneg, 2162 .ack_interrupt = &marvell_ack_interrupt, 2163 .config_intr = &marvell_config_intr, 2164 .resume = &genphy_resume, 2165 .suspend = &genphy_suspend, 2166 .read_page = marvell_read_page, 2167 .write_page = marvell_write_page, 2168 .get_sset_count = marvell_get_sset_count, 2169 .get_strings = marvell_get_strings, 2170 .get_stats = marvell_get_stats, 2171 }, 2172 { 2173 .phy_id = MARVELL_PHY_ID_88E1112, 2174 .phy_id_mask = MARVELL_PHY_ID_MASK, 2175 .name = "Marvell 88E1112", 2176 /* PHY_GBIT_FEATURES */ 2177 .probe = marvell_probe, 2178 .config_init = &m88e1111_config_init, 2179 .config_aneg = &marvell_config_aneg, 2180 .ack_interrupt = &marvell_ack_interrupt, 2181 .config_intr = &marvell_config_intr, 2182 .resume = &genphy_resume, 2183 .suspend = &genphy_suspend, 2184 .read_page = marvell_read_page, 2185 .write_page = marvell_write_page, 2186 .get_sset_count = marvell_get_sset_count, 2187 .get_strings = marvell_get_strings, 2188 .get_stats = marvell_get_stats, 2189 .get_tunable = m88e1011_get_tunable, 2190 .set_tunable = m88e1011_set_tunable, 2191 }, 2192 { 2193 .phy_id = MARVELL_PHY_ID_88E1111, 2194 .phy_id_mask = MARVELL_PHY_ID_MASK, 2195 .name = "Marvell 88E1111", 2196 /* PHY_GBIT_FEATURES */ 2197 .probe = marvell_probe, 2198 .config_init = &m88e1111_config_init, 2199 .config_aneg = &marvell_config_aneg, 2200 .read_status = &marvell_read_status, 2201 .ack_interrupt = &marvell_ack_interrupt, 2202 .config_intr = &marvell_config_intr, 2203 .resume = &genphy_resume, 2204 .suspend = &genphy_suspend, 2205 .read_page = marvell_read_page, 2206 .write_page = marvell_write_page, 2207 .get_sset_count = marvell_get_sset_count, 2208 .get_strings = marvell_get_strings, 2209 .get_stats = marvell_get_stats, 2210 .get_tunable = m88e1111_get_tunable, 2211 .set_tunable = m88e1111_set_tunable, 2212 }, 2213 { 2214 .phy_id = MARVELL_PHY_ID_88E1118, 2215 .phy_id_mask = MARVELL_PHY_ID_MASK, 2216 .name = "Marvell 88E1118", 2217 /* PHY_GBIT_FEATURES */ 2218 .probe = marvell_probe, 2219 .config_init = &m88e1118_config_init, 2220 .config_aneg = &m88e1118_config_aneg, 2221 .ack_interrupt = &marvell_ack_interrupt, 2222 .config_intr = &marvell_config_intr, 2223 .resume = &genphy_resume, 2224 .suspend = &genphy_suspend, 2225 .read_page = marvell_read_page, 2226 .write_page = marvell_write_page, 2227 .get_sset_count = marvell_get_sset_count, 2228 .get_strings = marvell_get_strings, 2229 .get_stats = marvell_get_stats, 2230 }, 2231 { 2232 .phy_id = MARVELL_PHY_ID_88E1121R, 2233 .phy_id_mask = MARVELL_PHY_ID_MASK, 2234 .name = "Marvell 88E1121R", 2235 /* PHY_GBIT_FEATURES */ 2236 .probe = &m88e1121_probe, 2237 .config_init = &marvell_config_init, 2238 .config_aneg = &m88e1121_config_aneg, 2239 .read_status = &marvell_read_status, 2240 .ack_interrupt = &marvell_ack_interrupt, 2241 .config_intr = &marvell_config_intr, 2242 .did_interrupt = &m88e1121_did_interrupt, 2243 .resume = &genphy_resume, 2244 .suspend = &genphy_suspend, 2245 .read_page = marvell_read_page, 2246 .write_page = marvell_write_page, 2247 .get_sset_count = marvell_get_sset_count, 2248 .get_strings = marvell_get_strings, 2249 .get_stats = marvell_get_stats, 2250 .get_tunable = m88e1011_get_tunable, 2251 .set_tunable = m88e1011_set_tunable, 2252 }, 2253 { 2254 .phy_id = MARVELL_PHY_ID_88E1318S, 2255 .phy_id_mask = MARVELL_PHY_ID_MASK, 2256 .name = "Marvell 88E1318S", 2257 /* PHY_GBIT_FEATURES */ 2258 .probe = marvell_probe, 2259 .config_init = &m88e1318_config_init, 2260 .config_aneg = &m88e1318_config_aneg, 2261 .read_status = &marvell_read_status, 2262 .ack_interrupt = &marvell_ack_interrupt, 2263 .config_intr = &marvell_config_intr, 2264 .did_interrupt = &m88e1121_did_interrupt, 2265 .get_wol = &m88e1318_get_wol, 2266 .set_wol = &m88e1318_set_wol, 2267 .resume = &genphy_resume, 2268 .suspend = &genphy_suspend, 2269 .read_page = marvell_read_page, 2270 .write_page = marvell_write_page, 2271 .get_sset_count = marvell_get_sset_count, 2272 .get_strings = marvell_get_strings, 2273 .get_stats = marvell_get_stats, 2274 }, 2275 { 2276 .phy_id = MARVELL_PHY_ID_88E1145, 2277 .phy_id_mask = MARVELL_PHY_ID_MASK, 2278 .name = "Marvell 88E1145", 2279 /* PHY_GBIT_FEATURES */ 2280 .probe = marvell_probe, 2281 .config_init = &m88e1145_config_init, 2282 .config_aneg = &m88e1101_config_aneg, 2283 .read_status = &genphy_read_status, 2284 .ack_interrupt = &marvell_ack_interrupt, 2285 .config_intr = &marvell_config_intr, 2286 .resume = &genphy_resume, 2287 .suspend = &genphy_suspend, 2288 .read_page = marvell_read_page, 2289 .write_page = marvell_write_page, 2290 .get_sset_count = marvell_get_sset_count, 2291 .get_strings = marvell_get_strings, 2292 .get_stats = marvell_get_stats, 2293 .get_tunable = m88e1111_get_tunable, 2294 .set_tunable = m88e1111_set_tunable, 2295 }, 2296 { 2297 .phy_id = MARVELL_PHY_ID_88E1149R, 2298 .phy_id_mask = MARVELL_PHY_ID_MASK, 2299 .name = "Marvell 88E1149R", 2300 /* PHY_GBIT_FEATURES */ 2301 .probe = marvell_probe, 2302 .config_init = &m88e1149_config_init, 2303 .config_aneg = &m88e1118_config_aneg, 2304 .ack_interrupt = &marvell_ack_interrupt, 2305 .config_intr = &marvell_config_intr, 2306 .resume = &genphy_resume, 2307 .suspend = &genphy_suspend, 2308 .read_page = marvell_read_page, 2309 .write_page = marvell_write_page, 2310 .get_sset_count = marvell_get_sset_count, 2311 .get_strings = marvell_get_strings, 2312 .get_stats = marvell_get_stats, 2313 }, 2314 { 2315 .phy_id = MARVELL_PHY_ID_88E1240, 2316 .phy_id_mask = MARVELL_PHY_ID_MASK, 2317 .name = "Marvell 88E1240", 2318 /* PHY_GBIT_FEATURES */ 2319 .probe = marvell_probe, 2320 .config_init = &m88e1111_config_init, 2321 .config_aneg = &marvell_config_aneg, 2322 .ack_interrupt = &marvell_ack_interrupt, 2323 .config_intr = &marvell_config_intr, 2324 .resume = &genphy_resume, 2325 .suspend = &genphy_suspend, 2326 .read_page = marvell_read_page, 2327 .write_page = marvell_write_page, 2328 .get_sset_count = marvell_get_sset_count, 2329 .get_strings = marvell_get_strings, 2330 .get_stats = marvell_get_stats, 2331 }, 2332 { 2333 .phy_id = MARVELL_PHY_ID_88E1116R, 2334 .phy_id_mask = MARVELL_PHY_ID_MASK, 2335 .name = "Marvell 88E1116R", 2336 /* PHY_GBIT_FEATURES */ 2337 .probe = marvell_probe, 2338 .config_init = &m88e1116r_config_init, 2339 .ack_interrupt = &marvell_ack_interrupt, 2340 .config_intr = &marvell_config_intr, 2341 .resume = &genphy_resume, 2342 .suspend = &genphy_suspend, 2343 .read_page = marvell_read_page, 2344 .write_page = marvell_write_page, 2345 .get_sset_count = marvell_get_sset_count, 2346 .get_strings = marvell_get_strings, 2347 .get_stats = marvell_get_stats, 2348 .get_tunable = m88e1011_get_tunable, 2349 .set_tunable = m88e1011_set_tunable, 2350 }, 2351 { 2352 .phy_id = MARVELL_PHY_ID_88E1510, 2353 .phy_id_mask = MARVELL_PHY_ID_MASK, 2354 .name = "Marvell 88E1510", 2355 .features = PHY_GBIT_FIBRE_FEATURES, 2356 .probe = &m88e1510_probe, 2357 .config_init = &m88e1510_config_init, 2358 .config_aneg = &m88e1510_config_aneg, 2359 .read_status = &marvell_read_status, 2360 .ack_interrupt = &marvell_ack_interrupt, 2361 .config_intr = &marvell_config_intr, 2362 .did_interrupt = &m88e1121_did_interrupt, 2363 .get_wol = &m88e1318_get_wol, 2364 .set_wol = &m88e1318_set_wol, 2365 .resume = &marvell_resume, 2366 .suspend = &marvell_suspend, 2367 .read_page = marvell_read_page, 2368 .write_page = marvell_write_page, 2369 .get_sset_count = marvell_get_sset_count, 2370 .get_strings = marvell_get_strings, 2371 .get_stats = marvell_get_stats, 2372 .set_loopback = genphy_loopback, 2373 .get_tunable = m88e1011_get_tunable, 2374 .set_tunable = m88e1011_set_tunable, 2375 }, 2376 { 2377 .phy_id = MARVELL_PHY_ID_88E1540, 2378 .phy_id_mask = MARVELL_PHY_ID_MASK, 2379 .name = "Marvell 88E1540", 2380 /* PHY_GBIT_FEATURES */ 2381 .probe = m88e1510_probe, 2382 .config_init = &marvell_config_init, 2383 .config_aneg = &m88e1510_config_aneg, 2384 .read_status = &marvell_read_status, 2385 .ack_interrupt = &marvell_ack_interrupt, 2386 .config_intr = &marvell_config_intr, 2387 .did_interrupt = &m88e1121_did_interrupt, 2388 .resume = &genphy_resume, 2389 .suspend = &genphy_suspend, 2390 .read_page = marvell_read_page, 2391 .write_page = marvell_write_page, 2392 .get_sset_count = marvell_get_sset_count, 2393 .get_strings = marvell_get_strings, 2394 .get_stats = marvell_get_stats, 2395 .get_tunable = m88e1540_get_tunable, 2396 .set_tunable = m88e1540_set_tunable, 2397 }, 2398 { 2399 .phy_id = MARVELL_PHY_ID_88E1545, 2400 .phy_id_mask = MARVELL_PHY_ID_MASK, 2401 .name = "Marvell 88E1545", 2402 .probe = m88e1510_probe, 2403 /* PHY_GBIT_FEATURES */ 2404 .config_init = &marvell_config_init, 2405 .config_aneg = &m88e1510_config_aneg, 2406 .read_status = &marvell_read_status, 2407 .ack_interrupt = &marvell_ack_interrupt, 2408 .config_intr = &marvell_config_intr, 2409 .did_interrupt = &m88e1121_did_interrupt, 2410 .resume = &genphy_resume, 2411 .suspend = &genphy_suspend, 2412 .read_page = marvell_read_page, 2413 .write_page = marvell_write_page, 2414 .get_sset_count = marvell_get_sset_count, 2415 .get_strings = marvell_get_strings, 2416 .get_stats = marvell_get_stats, 2417 .get_tunable = m88e1540_get_tunable, 2418 .set_tunable = m88e1540_set_tunable, 2419 }, 2420 { 2421 .phy_id = MARVELL_PHY_ID_88E3016, 2422 .phy_id_mask = MARVELL_PHY_ID_MASK, 2423 .name = "Marvell 88E3016", 2424 /* PHY_BASIC_FEATURES */ 2425 .probe = marvell_probe, 2426 .config_init = &m88e3016_config_init, 2427 .aneg_done = &marvell_aneg_done, 2428 .read_status = &marvell_read_status, 2429 .ack_interrupt = &marvell_ack_interrupt, 2430 .config_intr = &marvell_config_intr, 2431 .did_interrupt = &m88e1121_did_interrupt, 2432 .resume = &genphy_resume, 2433 .suspend = &genphy_suspend, 2434 .read_page = marvell_read_page, 2435 .write_page = marvell_write_page, 2436 .get_sset_count = marvell_get_sset_count, 2437 .get_strings = marvell_get_strings, 2438 .get_stats = marvell_get_stats, 2439 }, 2440 { 2441 .phy_id = MARVELL_PHY_ID_88E6390, 2442 .phy_id_mask = MARVELL_PHY_ID_MASK, 2443 .name = "Marvell 88E6390", 2444 /* PHY_GBIT_FEATURES */ 2445 .probe = m88e6390_probe, 2446 .config_init = &marvell_config_init, 2447 .config_aneg = &m88e6390_config_aneg, 2448 .read_status = &marvell_read_status, 2449 .ack_interrupt = &marvell_ack_interrupt, 2450 .config_intr = &marvell_config_intr, 2451 .did_interrupt = &m88e1121_did_interrupt, 2452 .resume = &genphy_resume, 2453 .suspend = &genphy_suspend, 2454 .read_page = marvell_read_page, 2455 .write_page = marvell_write_page, 2456 .get_sset_count = marvell_get_sset_count, 2457 .get_strings = marvell_get_strings, 2458 .get_stats = marvell_get_stats, 2459 .get_tunable = m88e1540_get_tunable, 2460 .set_tunable = m88e1540_set_tunable, 2461 }, 2462 }; 2463 2464 module_phy_driver(marvell_drivers); 2465 2466 static struct mdio_device_id __maybe_unused marvell_tbl[] = { 2467 { MARVELL_PHY_ID_88E1101, MARVELL_PHY_ID_MASK }, 2468 { MARVELL_PHY_ID_88E1112, MARVELL_PHY_ID_MASK }, 2469 { MARVELL_PHY_ID_88E1111, MARVELL_PHY_ID_MASK }, 2470 { MARVELL_PHY_ID_88E1118, MARVELL_PHY_ID_MASK }, 2471 { MARVELL_PHY_ID_88E1121R, MARVELL_PHY_ID_MASK }, 2472 { MARVELL_PHY_ID_88E1145, MARVELL_PHY_ID_MASK }, 2473 { MARVELL_PHY_ID_88E1149R, MARVELL_PHY_ID_MASK }, 2474 { MARVELL_PHY_ID_88E1240, MARVELL_PHY_ID_MASK }, 2475 { MARVELL_PHY_ID_88E1318S, MARVELL_PHY_ID_MASK }, 2476 { MARVELL_PHY_ID_88E1116R, MARVELL_PHY_ID_MASK }, 2477 { MARVELL_PHY_ID_88E1510, MARVELL_PHY_ID_MASK }, 2478 { MARVELL_PHY_ID_88E1540, MARVELL_PHY_ID_MASK }, 2479 { MARVELL_PHY_ID_88E1545, MARVELL_PHY_ID_MASK }, 2480 { MARVELL_PHY_ID_88E3016, MARVELL_PHY_ID_MASK }, 2481 { MARVELL_PHY_ID_88E6390, MARVELL_PHY_ID_MASK }, 2482 { } 2483 }; 2484 2485 MODULE_DEVICE_TABLE(mdio, marvell_tbl); 2486