1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/phy.h> 3 #include <linux/module.h> 4 5 #include <linux/netdevice.h> 6 7 #include "mtk.h" 8 9 /* Difference between functions with mtk_tr* and __mtk_tr* prefixes is 10 * mtk_tr* functions: wrapped by page switching operations 11 * __mtk_tr* functions: no page switching operations 12 */ 13 14 static void __mtk_tr_access(struct phy_device *phydev, bool read, u8 ch_addr, 15 u8 node_addr, u8 data_addr) 16 { 17 u16 tr_cmd = BIT(15); /* bit 14 & 0 are reserved */ 18 19 if (read) 20 tr_cmd |= BIT(13); 21 22 tr_cmd |= (((ch_addr & 0x3) << 11) | 23 ((node_addr & 0xf) << 7) | 24 ((data_addr & 0x3f) << 1)); 25 dev_dbg(&phydev->mdio.dev, "tr_cmd: 0x%x\n", tr_cmd); 26 __phy_write(phydev, 0x10, tr_cmd); 27 } 28 29 static void __mtk_tr_read(struct phy_device *phydev, u8 ch_addr, u8 node_addr, 30 u8 data_addr, u16 *tr_high, u16 *tr_low) 31 { 32 __mtk_tr_access(phydev, true, ch_addr, node_addr, data_addr); 33 *tr_low = __phy_read(phydev, 0x11); 34 *tr_high = __phy_read(phydev, 0x12); 35 dev_dbg(&phydev->mdio.dev, "tr_high read: 0x%x, tr_low read: 0x%x\n", 36 *tr_high, *tr_low); 37 } 38 39 static void __mtk_tr_write(struct phy_device *phydev, u8 ch_addr, u8 node_addr, 40 u8 data_addr, u32 tr_data) 41 { 42 __phy_write(phydev, 0x11, tr_data & 0xffff); 43 __phy_write(phydev, 0x12, tr_data >> 16); 44 dev_dbg(&phydev->mdio.dev, "tr_high write: 0x%x, tr_low write: 0x%x\n", 45 tr_data >> 16, tr_data & 0xffff); 46 __mtk_tr_access(phydev, false, ch_addr, node_addr, data_addr); 47 } 48 49 void __mtk_tr_modify(struct phy_device *phydev, u8 ch_addr, u8 node_addr, 50 u8 data_addr, u32 mask, u32 set) 51 { 52 u32 tr_data; 53 u16 tr_high; 54 u16 tr_low; 55 56 __mtk_tr_read(phydev, ch_addr, node_addr, data_addr, &tr_high, &tr_low); 57 tr_data = (tr_high << 16) | tr_low; 58 tr_data = (tr_data & ~mask) | set; 59 __mtk_tr_write(phydev, ch_addr, node_addr, data_addr, tr_data); 60 } 61 EXPORT_SYMBOL_GPL(__mtk_tr_modify); 62 63 void mtk_tr_modify(struct phy_device *phydev, u8 ch_addr, u8 node_addr, 64 u8 data_addr, u32 mask, u32 set) 65 { 66 phy_select_page(phydev, MTK_PHY_PAGE_EXTENDED_52B5); 67 __mtk_tr_modify(phydev, ch_addr, node_addr, data_addr, mask, set); 68 phy_restore_page(phydev, MTK_PHY_PAGE_STANDARD, 0); 69 } 70 EXPORT_SYMBOL_GPL(mtk_tr_modify); 71 72 void __mtk_tr_set_bits(struct phy_device *phydev, u8 ch_addr, u8 node_addr, 73 u8 data_addr, u32 set) 74 { 75 __mtk_tr_modify(phydev, ch_addr, node_addr, data_addr, 0, set); 76 } 77 EXPORT_SYMBOL_GPL(__mtk_tr_set_bits); 78 79 void __mtk_tr_clr_bits(struct phy_device *phydev, u8 ch_addr, u8 node_addr, 80 u8 data_addr, u32 clr) 81 { 82 __mtk_tr_modify(phydev, ch_addr, node_addr, data_addr, clr, 0); 83 } 84 EXPORT_SYMBOL_GPL(__mtk_tr_clr_bits); 85 86 int mtk_phy_read_page(struct phy_device *phydev) 87 { 88 return __phy_read(phydev, MTK_EXT_PAGE_ACCESS); 89 } 90 EXPORT_SYMBOL_GPL(mtk_phy_read_page); 91 92 int mtk_phy_write_page(struct phy_device *phydev, int page) 93 { 94 return __phy_write(phydev, MTK_EXT_PAGE_ACCESS, page); 95 } 96 EXPORT_SYMBOL_GPL(mtk_phy_write_page); 97 98 int mtk_phy_led_hw_is_supported(struct phy_device *phydev, u8 index, 99 unsigned long rules, 100 unsigned long supported_triggers) 101 { 102 if (index > 1) 103 return -EINVAL; 104 105 /* All combinations of the supported triggers are allowed */ 106 if (rules & ~supported_triggers) 107 return -EOPNOTSUPP; 108 109 return 0; 110 } 111 EXPORT_SYMBOL_GPL(mtk_phy_led_hw_is_supported); 112 113 int mtk_phy_led_hw_ctrl_get(struct phy_device *phydev, u8 index, 114 unsigned long *rules, u16 on_set, 115 u16 rx_blink_set, u16 tx_blink_set) 116 { 117 unsigned int bit_blink = MTK_PHY_LED_STATE_FORCE_BLINK + 118 (index ? 16 : 0); 119 unsigned int bit_netdev = MTK_PHY_LED_STATE_NETDEV + (index ? 16 : 0); 120 unsigned int bit_on = MTK_PHY_LED_STATE_FORCE_ON + (index ? 16 : 0); 121 struct mtk_socphy_priv *priv = phydev->priv; 122 int on, blink; 123 124 if (index > 1) 125 return -EINVAL; 126 127 on = phy_read_mmd(phydev, MDIO_MMD_VEND2, 128 index ? MTK_PHY_LED1_ON_CTRL : MTK_PHY_LED0_ON_CTRL); 129 130 if (on < 0) 131 return -EIO; 132 133 blink = phy_read_mmd(phydev, MDIO_MMD_VEND2, 134 index ? MTK_PHY_LED1_BLINK_CTRL : 135 MTK_PHY_LED0_BLINK_CTRL); 136 if (blink < 0) 137 return -EIO; 138 139 if ((on & (on_set | MTK_PHY_LED_ON_FDX | 140 MTK_PHY_LED_ON_HDX | MTK_PHY_LED_ON_LINKDOWN)) || 141 (blink & (rx_blink_set | tx_blink_set))) 142 set_bit(bit_netdev, &priv->led_state); 143 else 144 clear_bit(bit_netdev, &priv->led_state); 145 146 if (on & MTK_PHY_LED_ON_FORCE_ON) 147 set_bit(bit_on, &priv->led_state); 148 else 149 clear_bit(bit_on, &priv->led_state); 150 151 if (blink & MTK_PHY_LED_BLINK_FORCE_BLINK) 152 set_bit(bit_blink, &priv->led_state); 153 else 154 clear_bit(bit_blink, &priv->led_state); 155 156 if (!rules) 157 return 0; 158 159 /* TRIGGER_NETDEV_LINK must not be reported together with any of the 160 * per-speed rules, the netdev trigger rejects that combination. 161 * on_set holds every speed this LED can indicate and is what 162 * mtk_phy_led_hw_ctrl_set() programs for TRIGGER_NETDEV_LINK, so 163 * report the speed independent rule only when they are all on. 164 */ 165 if ((on & on_set) == on_set) { 166 *rules |= BIT(TRIGGER_NETDEV_LINK); 167 } else { 168 if (on & MTK_PHY_LED_ON_LINK10) 169 *rules |= BIT(TRIGGER_NETDEV_LINK_10); 170 171 if (on & MTK_PHY_LED_ON_LINK100) 172 *rules |= BIT(TRIGGER_NETDEV_LINK_100); 173 174 if (on & MTK_PHY_LED_ON_LINK1000) 175 *rules |= BIT(TRIGGER_NETDEV_LINK_1000); 176 177 if (on & MTK_PHY_LED_ON_LINK2500) 178 *rules |= BIT(TRIGGER_NETDEV_LINK_2500); 179 } 180 181 if (on & MTK_PHY_LED_ON_FDX) 182 *rules |= BIT(TRIGGER_NETDEV_FULL_DUPLEX); 183 184 if (on & MTK_PHY_LED_ON_HDX) 185 *rules |= BIT(TRIGGER_NETDEV_HALF_DUPLEX); 186 187 if (blink & rx_blink_set) 188 *rules |= BIT(TRIGGER_NETDEV_RX); 189 190 if (blink & tx_blink_set) 191 *rules |= BIT(TRIGGER_NETDEV_TX); 192 193 return 0; 194 } 195 EXPORT_SYMBOL_GPL(mtk_phy_led_hw_ctrl_get); 196 197 int mtk_phy_led_hw_ctrl_set(struct phy_device *phydev, u8 index, 198 unsigned long rules, u16 on_set, 199 u16 rx_blink_set, u16 tx_blink_set) 200 { 201 unsigned int bit_netdev = MTK_PHY_LED_STATE_NETDEV + (index ? 16 : 0); 202 struct mtk_socphy_priv *priv = phydev->priv; 203 u16 on = 0, blink = 0; 204 int ret; 205 206 if (index > 1) 207 return -EINVAL; 208 209 if (rules & BIT(TRIGGER_NETDEV_FULL_DUPLEX)) 210 on |= MTK_PHY_LED_ON_FDX; 211 212 if (rules & BIT(TRIGGER_NETDEV_HALF_DUPLEX)) 213 on |= MTK_PHY_LED_ON_HDX; 214 215 if (rules & (BIT(TRIGGER_NETDEV_LINK_10) | BIT(TRIGGER_NETDEV_LINK))) 216 on |= MTK_PHY_LED_ON_LINK10; 217 218 if (rules & (BIT(TRIGGER_NETDEV_LINK_100) | BIT(TRIGGER_NETDEV_LINK))) 219 on |= MTK_PHY_LED_ON_LINK100; 220 221 if (rules & (BIT(TRIGGER_NETDEV_LINK_1000) | BIT(TRIGGER_NETDEV_LINK))) 222 on |= MTK_PHY_LED_ON_LINK1000; 223 224 if (rules & (BIT(TRIGGER_NETDEV_LINK_2500) | BIT(TRIGGER_NETDEV_LINK))) 225 on |= MTK_PHY_LED_ON_LINK2500; 226 227 if (rules & BIT(TRIGGER_NETDEV_RX)) { 228 if (on & on_set) { 229 if (on & MTK_PHY_LED_ON_LINK10) 230 blink |= MTK_PHY_LED_BLINK_10RX; 231 if (on & MTK_PHY_LED_ON_LINK100) 232 blink |= MTK_PHY_LED_BLINK_100RX; 233 if (on & MTK_PHY_LED_ON_LINK1000) 234 blink |= MTK_PHY_LED_BLINK_1000RX; 235 if (on & MTK_PHY_LED_ON_LINK2500) 236 blink |= MTK_PHY_LED_BLINK_2500RX; 237 } else { 238 blink |= rx_blink_set; 239 } 240 } 241 242 if (rules & BIT(TRIGGER_NETDEV_TX)) { 243 if (on & on_set) { 244 if (on & MTK_PHY_LED_ON_LINK10) 245 blink |= MTK_PHY_LED_BLINK_10TX; 246 if (on & MTK_PHY_LED_ON_LINK100) 247 blink |= MTK_PHY_LED_BLINK_100TX; 248 if (on & MTK_PHY_LED_ON_LINK1000) 249 blink |= MTK_PHY_LED_BLINK_1000TX; 250 if (on & MTK_PHY_LED_ON_LINK2500) 251 blink |= MTK_PHY_LED_BLINK_2500TX; 252 } else { 253 blink |= tx_blink_set; 254 } 255 } 256 257 if (blink || on) 258 set_bit(bit_netdev, &priv->led_state); 259 else 260 clear_bit(bit_netdev, &priv->led_state); 261 262 ret = phy_modify_mmd(phydev, MDIO_MMD_VEND2, index ? 263 MTK_PHY_LED1_ON_CTRL : MTK_PHY_LED0_ON_CTRL, 264 MTK_PHY_LED_ON_FDX | MTK_PHY_LED_ON_HDX | on_set, 265 on); 266 267 if (ret) 268 return ret; 269 270 return phy_write_mmd(phydev, MDIO_MMD_VEND2, index ? 271 MTK_PHY_LED1_BLINK_CTRL : 272 MTK_PHY_LED0_BLINK_CTRL, blink); 273 } 274 EXPORT_SYMBOL_GPL(mtk_phy_led_hw_ctrl_set); 275 276 int mtk_phy_led_num_dly_cfg(u8 index, unsigned long *delay_on, 277 unsigned long *delay_off, bool *blinking) 278 { 279 if (index > 1) 280 return -EINVAL; 281 282 if (delay_on && delay_off && (*delay_on > 0) && (*delay_off > 0)) { 283 *blinking = true; 284 *delay_on = 50; 285 *delay_off = 50; 286 } 287 288 return 0; 289 } 290 EXPORT_SYMBOL_GPL(mtk_phy_led_num_dly_cfg); 291 292 int mtk_phy_hw_led_on_set(struct phy_device *phydev, u8 index, 293 u16 led_on_mask, bool on) 294 { 295 unsigned int bit_on = MTK_PHY_LED_STATE_FORCE_ON + (index ? 16 : 0); 296 struct mtk_socphy_priv *priv = phydev->priv; 297 bool changed; 298 299 if (on) 300 changed = !test_and_set_bit(bit_on, &priv->led_state); 301 else 302 changed = !!test_and_clear_bit(bit_on, &priv->led_state); 303 304 changed |= !!test_and_clear_bit(MTK_PHY_LED_STATE_NETDEV + 305 (index ? 16 : 0), &priv->led_state); 306 if (changed) 307 return phy_modify_mmd(phydev, MDIO_MMD_VEND2, index ? 308 MTK_PHY_LED1_ON_CTRL : 309 MTK_PHY_LED0_ON_CTRL, 310 led_on_mask, 311 on ? MTK_PHY_LED_ON_FORCE_ON : 0); 312 else 313 return 0; 314 } 315 EXPORT_SYMBOL_GPL(mtk_phy_hw_led_on_set); 316 317 int mtk_phy_hw_led_blink_set(struct phy_device *phydev, u8 index, bool blinking) 318 { 319 unsigned int bit_blink = MTK_PHY_LED_STATE_FORCE_BLINK + 320 (index ? 16 : 0); 321 struct mtk_socphy_priv *priv = phydev->priv; 322 bool changed; 323 324 if (blinking) 325 changed = !test_and_set_bit(bit_blink, &priv->led_state); 326 else 327 changed = !!test_and_clear_bit(bit_blink, &priv->led_state); 328 329 changed |= !!test_bit(MTK_PHY_LED_STATE_NETDEV + 330 (index ? 16 : 0), &priv->led_state); 331 if (changed) 332 return phy_write_mmd(phydev, MDIO_MMD_VEND2, index ? 333 MTK_PHY_LED1_BLINK_CTRL : 334 MTK_PHY_LED0_BLINK_CTRL, 335 blinking ? 336 MTK_PHY_LED_BLINK_FORCE_BLINK : 0); 337 else 338 return 0; 339 } 340 EXPORT_SYMBOL_GPL(mtk_phy_hw_led_blink_set); 341 342 void mtk_phy_leds_state_init(struct phy_device *phydev) 343 { 344 int i; 345 346 for (i = 0; i < 2; ++i) 347 phydev->drv->led_hw_control_get(phydev, i, NULL); 348 } 349 EXPORT_SYMBOL_GPL(mtk_phy_leds_state_init); 350 351 MODULE_DESCRIPTION("MediaTek Ethernet PHY driver common"); 352 MODULE_AUTHOR("Sky Huang <SkyLake.Huang@mediatek.com>"); 353 MODULE_AUTHOR("Daniel Golle <daniel@makrotopia.org>"); 354 MODULE_LICENSE("GPL"); 355