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