Merge tag 'usb-6.7-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

+6 -1

Documentation/devicetree/bindings/usb/microchip,usb5744.yaml

··· 36 36 37 37 vdd-supply: 38 38 description: 39 - VDD power supply to the hub 39 + 3V3 power supply to the hub 40 + 41 + vdd2-supply: 42 + description: 43 + 1V2 power supply to the hub 40 44 41 45 peer-hub: 42 46 $ref: /schemas/types.yaml#/definitions/phandle ··· 66 62 properties: 67 63 reset-gpios: false 68 64 vdd-supply: false 65 + vdd2-supply: false 69 66 peer-hub: false 70 67 i2c-bus: false 71 68 else:

+2 -2

Documentation/devicetree/bindings/usb/qcom,dwc3.yaml

··· 521 521 522 522 interrupts = <GIC_SPI 131 IRQ_TYPE_LEVEL_HIGH>, 523 523 <GIC_SPI 486 IRQ_TYPE_LEVEL_HIGH>, 524 - <GIC_SPI 488 IRQ_TYPE_LEVEL_HIGH>, 525 - <GIC_SPI 489 IRQ_TYPE_LEVEL_HIGH>; 524 + <GIC_SPI 488 IRQ_TYPE_EDGE_BOTH>, 525 + <GIC_SPI 489 IRQ_TYPE_EDGE_BOTH>; 526 526 interrupt-names = "hs_phy_irq", "ss_phy_irq", 527 527 "dm_hs_phy_irq", "dp_hs_phy_irq"; 528 528

+1 -1

Documentation/devicetree/bindings/usb/usb-hcd.yaml

··· 41 41 - | 42 42 usb { 43 43 phys = <&usb2_phy1>, <&usb3_phy1>; 44 - phy-names = "usb"; 44 + phy-names = "usb2", "usb3"; 45 45 #address-cells = <1>; 46 46 #size-cells = <0>; 47 47

-1

drivers/phy/Kconfig

··· 87 87 source "drivers/phy/mscc/Kconfig" 88 88 source "drivers/phy/qualcomm/Kconfig" 89 89 source "drivers/phy/ralink/Kconfig" 90 - source "drivers/phy/realtek/Kconfig" 91 90 source "drivers/phy/renesas/Kconfig" 92 91 source "drivers/phy/rockchip/Kconfig" 93 92 source "drivers/phy/samsung/Kconfig"

-1

drivers/phy/Makefile

··· 26 26 mscc/ \ 27 27 qualcomm/ \ 28 28 ralink/ \ 29 - realtek/ \ 30 29 renesas/ \ 31 30 rockchip/ \ 32 31 samsung/ \

-32

drivers/phy/realtek/Kconfig

··· 1 - # SPDX-License-Identifier: GPL-2.0 2 - # 3 - # Phy drivers for Realtek platforms 4 - # 5 - 6 - if ARCH_REALTEK || COMPILE_TEST 7 - 8 - config PHY_RTK_RTD_USB2PHY 9 - tristate "Realtek RTD USB2 PHY Transceiver Driver" 10 - depends on USB_SUPPORT 11 - select GENERIC_PHY 12 - select USB_PHY 13 - select USB_COMMON 14 - help 15 - Enable this to support Realtek SoC USB2 phy transceiver. 16 - The DHC (digital home center) RTD series SoCs used the Synopsys 17 - DWC3 USB IP. This driver will do the PHY initialization 18 - of the parameters. 19 - 20 - config PHY_RTK_RTD_USB3PHY 21 - tristate "Realtek RTD USB3 PHY Transceiver Driver" 22 - depends on USB_SUPPORT 23 - select GENERIC_PHY 24 - select USB_PHY 25 - select USB_COMMON 26 - help 27 - Enable this to support Realtek SoC USB3 phy transceiver. 28 - The DHC (digital home center) RTD series SoCs used the Synopsys 29 - DWC3 USB IP. This driver will do the PHY initialization 30 - of the parameters. 31 - 32 - endif # ARCH_REALTEK || COMPILE_TEST

-3

drivers/phy/realtek/Makefile

··· 1 - # SPDX-License-Identifier: GPL-2.0 2 - obj-$(CONFIG_PHY_RTK_RTD_USB2PHY) += phy-rtk-usb2.o 3 - obj-$(CONFIG_PHY_RTK_RTD_USB3PHY) += phy-rtk-usb3.o

-1325

drivers/phy/realtek/phy-rtk-usb2.c

··· 1 - // SPDX-License-Identifier: GPL-2.0 2 - /* 3 - * phy-rtk-usb2.c RTK usb2.0 PHY driver 4 - * 5 - * Copyright (C) 2023 Realtek Semiconductor Corporation 6 - * 7 - */ 8 - 9 - #include <linux/module.h> 10 - #include <linux/of.h> 11 - #include <linux/of_address.h> 12 - #include <linux/platform_device.h> 13 - #include <linux/uaccess.h> 14 - #include <linux/debugfs.h> 15 - #include <linux/nvmem-consumer.h> 16 - #include <linux/regmap.h> 17 - #include <linux/sys_soc.h> 18 - #include <linux/mfd/syscon.h> 19 - #include <linux/phy/phy.h> 20 - #include <linux/usb.h> 21 - #include <linux/usb/phy.h> 22 - #include <linux/usb/hcd.h> 23 - 24 - /* GUSB2PHYACCn register */ 25 - #define PHY_NEW_REG_REQ BIT(25) 26 - #define PHY_VSTS_BUSY BIT(23) 27 - #define PHY_VCTRL_SHIFT 8 28 - #define PHY_REG_DATA_MASK 0xff 29 - 30 - #define GET_LOW_NIBBLE(addr) ((addr) & 0x0f) 31 - #define GET_HIGH_NIBBLE(addr) (((addr) & 0xf0) >> 4) 32 - 33 - #define EFUS_USB_DC_CAL_RATE 2 34 - #define EFUS_USB_DC_CAL_MAX 7 35 - 36 - #define EFUS_USB_DC_DIS_RATE 1 37 - #define EFUS_USB_DC_DIS_MAX 7 38 - 39 - #define MAX_PHY_DATA_SIZE 20 40 - #define OFFEST_PHY_READ 0x20 41 - 42 - #define MAX_USB_PHY_NUM 4 43 - #define MAX_USB_PHY_PAGE0_DATA_SIZE 16 44 - #define MAX_USB_PHY_PAGE1_DATA_SIZE 16 45 - #define MAX_USB_PHY_PAGE2_DATA_SIZE 8 46 - 47 - #define SET_PAGE_OFFSET 0xf4 48 - #define SET_PAGE_0 0x9b 49 - #define SET_PAGE_1 0xbb 50 - #define SET_PAGE_2 0xdb 51 - 52 - #define PAGE_START 0xe0 53 - #define PAGE0_0XE4 0xe4 54 - #define PAGE0_0XE6 0xe6 55 - #define PAGE0_0XE7 0xe7 56 - #define PAGE1_0XE0 0xe0 57 - #define PAGE1_0XE2 0xe2 58 - 59 - #define SENSITIVITY_CTRL (BIT(4) | BIT(5) | BIT(6)) 60 - #define ENABLE_AUTO_SENSITIVITY_CALIBRATION BIT(2) 61 - #define DEFAULT_DC_DRIVING_VALUE (0x8) 62 - #define DEFAULT_DC_DISCONNECTION_VALUE (0x6) 63 - #define HS_CLK_SELECT BIT(6) 64 - 65 - struct phy_reg { 66 - void __iomem *reg_wrap_vstatus; 67 - void __iomem *reg_gusb2phyacc0; 68 - int vstatus_index; 69 - }; 70 - 71 - struct phy_data { 72 - u8 addr; 73 - u8 data; 74 - }; 75 - 76 - struct phy_cfg { 77 - int page0_size; 78 - struct phy_data page0[MAX_USB_PHY_PAGE0_DATA_SIZE]; 79 - int page1_size; 80 - struct phy_data page1[MAX_USB_PHY_PAGE1_DATA_SIZE]; 81 - int page2_size; 82 - struct phy_data page2[MAX_USB_PHY_PAGE2_DATA_SIZE]; 83 - 84 - int num_phy; 85 - 86 - bool check_efuse; 87 - int check_efuse_version; 88 - #define CHECK_EFUSE_V1 1 89 - #define CHECK_EFUSE_V2 2 90 - int efuse_dc_driving_rate; 91 - int efuse_dc_disconnect_rate; 92 - int dc_driving_mask; 93 - int dc_disconnect_mask; 94 - bool usb_dc_disconnect_at_page0; 95 - int driving_updated_for_dev_dis; 96 - 97 - bool do_toggle; 98 - bool do_toggle_driving; 99 - bool use_default_parameter; 100 - bool is_double_sensitivity_mode; 101 - }; 102 - 103 - struct phy_parameter { 104 - struct phy_reg phy_reg; 105 - 106 - /* Get from efuse */ 107 - s8 efuse_usb_dc_cal; 108 - s8 efuse_usb_dc_dis; 109 - 110 - /* Get from dts */ 111 - bool inverse_hstx_sync_clock; 112 - u32 driving_level; 113 - s32 driving_level_compensate; 114 - s32 disconnection_compensate; 115 - }; 116 - 117 - struct rtk_phy { 118 - struct usb_phy phy; 119 - struct device *dev; 120 - 121 - struct phy_cfg *phy_cfg; 122 - int num_phy; 123 - struct phy_parameter *phy_parameter; 124 - 125 - struct dentry *debug_dir; 126 - }; 127 - 128 - /* mapping 0xE0 to 0 ... 0xE7 to 7, 0xF0 to 8 ,,, 0xF7 to 15 */ 129 - static inline int page_addr_to_array_index(u8 addr) 130 - { 131 - return (int)((((addr) - PAGE_START) & 0x7) + 132 - ((((addr) - PAGE_START) & 0x10) >> 1)); 133 - } 134 - 135 - static inline u8 array_index_to_page_addr(int index) 136 - { 137 - return ((((index) + PAGE_START) & 0x7) + 138 - ((((index) & 0x8) << 1) + PAGE_START)); 139 - } 140 - 141 - #define PHY_IO_TIMEOUT_USEC (50000) 142 - #define PHY_IO_DELAY_US (100) 143 - 144 - static inline int utmi_wait_register(void __iomem *reg, u32 mask, u32 result) 145 - { 146 - int ret; 147 - unsigned int val; 148 - 149 - ret = read_poll_timeout(readl, val, ((val & mask) == result), 150 - PHY_IO_DELAY_US, PHY_IO_TIMEOUT_USEC, false, reg); 151 - if (ret) { 152 - pr_err("%s can't program USB phy\n", __func__); 153 - return -ETIMEDOUT; 154 - } 155 - 156 - return 0; 157 - } 158 - 159 - static char rtk_phy_read(struct phy_reg *phy_reg, char addr) 160 - { 161 - void __iomem *reg_gusb2phyacc0 = phy_reg->reg_gusb2phyacc0; 162 - unsigned int val; 163 - int ret = 0; 164 - 165 - addr -= OFFEST_PHY_READ; 166 - 167 - /* polling until VBusy == 0 */ 168 - ret = utmi_wait_register(reg_gusb2phyacc0, PHY_VSTS_BUSY, 0); 169 - if (ret) 170 - return (char)ret; 171 - 172 - /* VCtrl = low nibble of addr, and set PHY_NEW_REG_REQ */ 173 - val = PHY_NEW_REG_REQ | (GET_LOW_NIBBLE(addr) << PHY_VCTRL_SHIFT); 174 - writel(val, reg_gusb2phyacc0); 175 - ret = utmi_wait_register(reg_gusb2phyacc0, PHY_VSTS_BUSY, 0); 176 - if (ret) 177 - return (char)ret; 178 - 179 - /* VCtrl = high nibble of addr, and set PHY_NEW_REG_REQ */ 180 - val = PHY_NEW_REG_REQ | (GET_HIGH_NIBBLE(addr) << PHY_VCTRL_SHIFT); 181 - writel(val, reg_gusb2phyacc0); 182 - ret = utmi_wait_register(reg_gusb2phyacc0, PHY_VSTS_BUSY, 0); 183 - if (ret) 184 - return (char)ret; 185 - 186 - val = readl(reg_gusb2phyacc0); 187 - 188 - return (char)(val & PHY_REG_DATA_MASK); 189 - } 190 - 191 - static int rtk_phy_write(struct phy_reg *phy_reg, char addr, char data) 192 - { 193 - unsigned int val; 194 - void __iomem *reg_wrap_vstatus = phy_reg->reg_wrap_vstatus; 195 - void __iomem *reg_gusb2phyacc0 = phy_reg->reg_gusb2phyacc0; 196 - int shift_bits = phy_reg->vstatus_index * 8; 197 - int ret = 0; 198 - 199 - /* write data to VStatusOut2 (data output to phy) */ 200 - writel((u32)data << shift_bits, reg_wrap_vstatus); 201 - 202 - ret = utmi_wait_register(reg_gusb2phyacc0, PHY_VSTS_BUSY, 0); 203 - if (ret) 204 - return ret; 205 - 206 - /* VCtrl = low nibble of addr, set PHY_NEW_REG_REQ */ 207 - val = PHY_NEW_REG_REQ | (GET_LOW_NIBBLE(addr) << PHY_VCTRL_SHIFT); 208 - 209 - writel(val, reg_gusb2phyacc0); 210 - ret = utmi_wait_register(reg_gusb2phyacc0, PHY_VSTS_BUSY, 0); 211 - if (ret) 212 - return ret; 213 - 214 - /* VCtrl = high nibble of addr, set PHY_NEW_REG_REQ */ 215 - val = PHY_NEW_REG_REQ | (GET_HIGH_NIBBLE(addr) << PHY_VCTRL_SHIFT); 216 - 217 - writel(val, reg_gusb2phyacc0); 218 - ret = utmi_wait_register(reg_gusb2phyacc0, PHY_VSTS_BUSY, 0); 219 - if (ret) 220 - return ret; 221 - 222 - return 0; 223 - } 224 - 225 - static int rtk_phy_set_page(struct phy_reg *phy_reg, int page) 226 - { 227 - switch (page) { 228 - case 0: 229 - return rtk_phy_write(phy_reg, SET_PAGE_OFFSET, SET_PAGE_0); 230 - case 1: 231 - return rtk_phy_write(phy_reg, SET_PAGE_OFFSET, SET_PAGE_1); 232 - case 2: 233 - return rtk_phy_write(phy_reg, SET_PAGE_OFFSET, SET_PAGE_2); 234 - default: 235 - pr_err("%s error page=%d\n", __func__, page); 236 - } 237 - 238 - return -EINVAL; 239 - } 240 - 241 - static u8 __updated_dc_disconnect_level_page0_0xe4(struct phy_cfg *phy_cfg, 242 - struct phy_parameter *phy_parameter, u8 data) 243 - { 244 - u8 ret; 245 - s32 val; 246 - s32 dc_disconnect_mask = phy_cfg->dc_disconnect_mask; 247 - int offset = 4; 248 - 249 - val = (s32)((data >> offset) & dc_disconnect_mask) 250 - + phy_parameter->efuse_usb_dc_dis 251 - + phy_parameter->disconnection_compensate; 252 - 253 - if (val > dc_disconnect_mask) 254 - val = dc_disconnect_mask; 255 - else if (val < 0) 256 - val = 0; 257 - 258 - ret = (data & (~(dc_disconnect_mask << offset))) | 259 - (val & dc_disconnect_mask) << offset; 260 - 261 - return ret; 262 - } 263 - 264 - /* updated disconnect level at page0 */ 265 - static void update_dc_disconnect_level_at_page0(struct rtk_phy *rtk_phy, 266 - struct phy_parameter *phy_parameter, bool update) 267 - { 268 - struct phy_cfg *phy_cfg; 269 - struct phy_reg *phy_reg; 270 - struct phy_data *phy_data_page; 271 - struct phy_data *phy_data; 272 - u8 addr, data; 273 - int offset = 4; 274 - s32 dc_disconnect_mask; 275 - int i; 276 - 277 - phy_cfg = rtk_phy->phy_cfg; 278 - phy_reg = &phy_parameter->phy_reg; 279 - 280 - /* Set page 0 */ 281 - phy_data_page = phy_cfg->page0; 282 - rtk_phy_set_page(phy_reg, 0); 283 - 284 - i = page_addr_to_array_index(PAGE0_0XE4); 285 - phy_data = phy_data_page + i; 286 - if (!phy_data->addr) { 287 - phy_data->addr = PAGE0_0XE4; 288 - phy_data->data = rtk_phy_read(phy_reg, PAGE0_0XE4); 289 - } 290 - 291 - addr = phy_data->addr; 292 - data = phy_data->data; 293 - dc_disconnect_mask = phy_cfg->dc_disconnect_mask; 294 - 295 - if (update) 296 - data = __updated_dc_disconnect_level_page0_0xe4(phy_cfg, phy_parameter, data); 297 - else 298 - data = (data & ~(dc_disconnect_mask << offset)) | 299 - (DEFAULT_DC_DISCONNECTION_VALUE << offset); 300 - 301 - if (rtk_phy_write(phy_reg, addr, data)) 302 - dev_err(rtk_phy->dev, 303 - "%s: Error to set page1 parameter addr=0x%x value=0x%x\n", 304 - __func__, addr, data); 305 - } 306 - 307 - static u8 __updated_dc_disconnect_level_page1_0xe2(struct phy_cfg *phy_cfg, 308 - struct phy_parameter *phy_parameter, u8 data) 309 - { 310 - u8 ret; 311 - s32 val; 312 - s32 dc_disconnect_mask = phy_cfg->dc_disconnect_mask; 313 - 314 - if (phy_cfg->check_efuse_version == CHECK_EFUSE_V1) { 315 - val = (s32)(data & dc_disconnect_mask) 316 - + phy_parameter->efuse_usb_dc_dis 317 - + phy_parameter->disconnection_compensate; 318 - } else { /* for CHECK_EFUSE_V2 or no efuse */ 319 - if (phy_parameter->efuse_usb_dc_dis) 320 - val = (s32)(phy_parameter->efuse_usb_dc_dis + 321 - phy_parameter->disconnection_compensate); 322 - else 323 - val = (s32)((data & dc_disconnect_mask) + 324 - phy_parameter->disconnection_compensate); 325 - } 326 - 327 - if (val > dc_disconnect_mask) 328 - val = dc_disconnect_mask; 329 - else if (val < 0) 330 - val = 0; 331 - 332 - ret = (data & (~dc_disconnect_mask)) | (val & dc_disconnect_mask); 333 - 334 - return ret; 335 - } 336 - 337 - /* updated disconnect level at page1 */ 338 - static void update_dc_disconnect_level_at_page1(struct rtk_phy *rtk_phy, 339 - struct phy_parameter *phy_parameter, bool update) 340 - { 341 - struct phy_cfg *phy_cfg; 342 - struct phy_data *phy_data_page; 343 - struct phy_data *phy_data; 344 - struct phy_reg *phy_reg; 345 - u8 addr, data; 346 - s32 dc_disconnect_mask; 347 - int i; 348 - 349 - phy_cfg = rtk_phy->phy_cfg; 350 - phy_reg = &phy_parameter->phy_reg; 351 - 352 - /* Set page 1 */ 353 - phy_data_page = phy_cfg->page1; 354 - rtk_phy_set_page(phy_reg, 1); 355 - 356 - i = page_addr_to_array_index(PAGE1_0XE2); 357 - phy_data = phy_data_page + i; 358 - if (!phy_data->addr) { 359 - phy_data->addr = PAGE1_0XE2; 360 - phy_data->data = rtk_phy_read(phy_reg, PAGE1_0XE2); 361 - } 362 - 363 - addr = phy_data->addr; 364 - data = phy_data->data; 365 - dc_disconnect_mask = phy_cfg->dc_disconnect_mask; 366 - 367 - if (update) 368 - data = __updated_dc_disconnect_level_page1_0xe2(phy_cfg, phy_parameter, data); 369 - else 370 - data = (data & ~dc_disconnect_mask) | DEFAULT_DC_DISCONNECTION_VALUE; 371 - 372 - if (rtk_phy_write(phy_reg, addr, data)) 373 - dev_err(rtk_phy->dev, 374 - "%s: Error to set page1 parameter addr=0x%x value=0x%x\n", 375 - __func__, addr, data); 376 - } 377 - 378 - static void update_dc_disconnect_level(struct rtk_phy *rtk_phy, 379 - struct phy_parameter *phy_parameter, bool update) 380 - { 381 - struct phy_cfg *phy_cfg = rtk_phy->phy_cfg; 382 - 383 - if (phy_cfg->usb_dc_disconnect_at_page0) 384 - update_dc_disconnect_level_at_page0(rtk_phy, phy_parameter, update); 385 - else 386 - update_dc_disconnect_level_at_page1(rtk_phy, phy_parameter, update); 387 - } 388 - 389 - static u8 __update_dc_driving_page0_0xe4(struct phy_cfg *phy_cfg, 390 - struct phy_parameter *phy_parameter, u8 data) 391 - { 392 - s32 driving_level_compensate = phy_parameter->driving_level_compensate; 393 - s32 dc_driving_mask = phy_cfg->dc_driving_mask; 394 - s32 val; 395 - u8 ret; 396 - 397 - if (phy_cfg->check_efuse_version == CHECK_EFUSE_V1) { 398 - val = (s32)(data & dc_driving_mask) + driving_level_compensate 399 - + phy_parameter->efuse_usb_dc_cal; 400 - } else { /* for CHECK_EFUSE_V2 or no efuse */ 401 - if (phy_parameter->efuse_usb_dc_cal) 402 - val = (s32)((phy_parameter->efuse_usb_dc_cal & dc_driving_mask) 403 - + driving_level_compensate); 404 - else 405 - val = (s32)(data & dc_driving_mask); 406 - } 407 - 408 - if (val > dc_driving_mask) 409 - val = dc_driving_mask; 410 - else if (val < 0) 411 - val = 0; 412 - 413 - ret = (data & (~dc_driving_mask)) | (val & dc_driving_mask); 414 - 415 - return ret; 416 - } 417 - 418 - static void update_dc_driving_level(struct rtk_phy *rtk_phy, 419 - struct phy_parameter *phy_parameter) 420 - { 421 - struct phy_cfg *phy_cfg; 422 - struct phy_reg *phy_reg; 423 - 424 - phy_reg = &phy_parameter->phy_reg; 425 - phy_cfg = rtk_phy->phy_cfg; 426 - if (!phy_cfg->page0[4].addr) { 427 - rtk_phy_set_page(phy_reg, 0); 428 - phy_cfg->page0[4].addr = PAGE0_0XE4; 429 - phy_cfg->page0[4].data = rtk_phy_read(phy_reg, PAGE0_0XE4); 430 - } 431 - 432 - if (phy_parameter->driving_level != DEFAULT_DC_DRIVING_VALUE) { 433 - u32 dc_driving_mask; 434 - u8 driving_level; 435 - u8 data; 436 - 437 - data = phy_cfg->page0[4].data; 438 - dc_driving_mask = phy_cfg->dc_driving_mask; 439 - driving_level = data & dc_driving_mask; 440 - 441 - dev_dbg(rtk_phy->dev, "%s driving_level=%d => dts driving_level=%d\n", 442 - __func__, driving_level, phy_parameter->driving_level); 443 - 444 - phy_cfg->page0[4].data = (data & (~dc_driving_mask)) | 445 - (phy_parameter->driving_level & dc_driving_mask); 446 - } 447 - 448 - phy_cfg->page0[4].data = __update_dc_driving_page0_0xe4(phy_cfg, 449 - phy_parameter, 450 - phy_cfg->page0[4].data); 451 - } 452 - 453 - static void update_hs_clk_select(struct rtk_phy *rtk_phy, 454 - struct phy_parameter *phy_parameter) 455 - { 456 - struct phy_cfg *phy_cfg; 457 - struct phy_reg *phy_reg; 458 - 459 - phy_cfg = rtk_phy->phy_cfg; 460 - phy_reg = &phy_parameter->phy_reg; 461 - 462 - if (phy_parameter->inverse_hstx_sync_clock) { 463 - if (!phy_cfg->page0[6].addr) { 464 - rtk_phy_set_page(phy_reg, 0); 465 - phy_cfg->page0[6].addr = PAGE0_0XE6; 466 - phy_cfg->page0[6].data = rtk_phy_read(phy_reg, PAGE0_0XE6); 467 - } 468 - 469 - phy_cfg->page0[6].data = phy_cfg->page0[6].data | HS_CLK_SELECT; 470 - } 471 - } 472 - 473 - static void do_rtk_phy_toggle(struct rtk_phy *rtk_phy, 474 - int index, bool connect) 475 - { 476 - struct phy_parameter *phy_parameter; 477 - struct phy_cfg *phy_cfg; 478 - struct phy_reg *phy_reg; 479 - struct phy_data *phy_data_page; 480 - u8 addr, data; 481 - int i; 482 - 483 - phy_cfg = rtk_phy->phy_cfg; 484 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 485 - phy_reg = &phy_parameter->phy_reg; 486 - 487 - if (!phy_cfg->do_toggle) 488 - goto out; 489 - 490 - if (phy_cfg->is_double_sensitivity_mode) 491 - goto do_toggle_driving; 492 - 493 - /* Set page 0 */ 494 - rtk_phy_set_page(phy_reg, 0); 495 - 496 - addr = PAGE0_0XE7; 497 - data = rtk_phy_read(phy_reg, addr); 498 - 499 - if (connect) 500 - rtk_phy_write(phy_reg, addr, data & (~SENSITIVITY_CTRL)); 501 - else 502 - rtk_phy_write(phy_reg, addr, data | (SENSITIVITY_CTRL)); 503 - 504 - do_toggle_driving: 505 - 506 - if (!phy_cfg->do_toggle_driving) 507 - goto do_toggle; 508 - 509 - /* Page 0 addr 0xE4 driving capability */ 510 - 511 - /* Set page 0 */ 512 - phy_data_page = phy_cfg->page0; 513 - rtk_phy_set_page(phy_reg, 0); 514 - 515 - i = page_addr_to_array_index(PAGE0_0XE4); 516 - addr = phy_data_page[i].addr; 517 - data = phy_data_page[i].data; 518 - 519 - if (connect) { 520 - rtk_phy_write(phy_reg, addr, data); 521 - } else { 522 - u8 value; 523 - s32 tmp; 524 - s32 driving_updated = 525 - phy_cfg->driving_updated_for_dev_dis; 526 - s32 dc_driving_mask = phy_cfg->dc_driving_mask; 527 - 528 - tmp = (s32)(data & dc_driving_mask) + driving_updated; 529 - 530 - if (tmp > dc_driving_mask) 531 - tmp = dc_driving_mask; 532 - else if (tmp < 0) 533 - tmp = 0; 534 - 535 - value = (data & (~dc_driving_mask)) | (tmp & dc_driving_mask); 536 - 537 - rtk_phy_write(phy_reg, addr, value); 538 - } 539 - 540 - do_toggle: 541 - /* restore dc disconnect level before toggle */ 542 - update_dc_disconnect_level(rtk_phy, phy_parameter, false); 543 - 544 - /* Set page 1 */ 545 - rtk_phy_set_page(phy_reg, 1); 546 - 547 - addr = PAGE1_0XE0; 548 - data = rtk_phy_read(phy_reg, addr); 549 - 550 - rtk_phy_write(phy_reg, addr, data & 551 - (~ENABLE_AUTO_SENSITIVITY_CALIBRATION)); 552 - mdelay(1); 553 - rtk_phy_write(phy_reg, addr, data | 554 - (ENABLE_AUTO_SENSITIVITY_CALIBRATION)); 555 - 556 - /* update dc disconnect level after toggle */ 557 - update_dc_disconnect_level(rtk_phy, phy_parameter, true); 558 - 559 - out: 560 - return; 561 - } 562 - 563 - static int do_rtk_phy_init(struct rtk_phy *rtk_phy, int index) 564 - { 565 - struct phy_parameter *phy_parameter; 566 - struct phy_cfg *phy_cfg; 567 - struct phy_data *phy_data_page; 568 - struct phy_reg *phy_reg; 569 - int i; 570 - 571 - phy_cfg = rtk_phy->phy_cfg; 572 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 573 - phy_reg = &phy_parameter->phy_reg; 574 - 575 - if (phy_cfg->use_default_parameter) { 576 - dev_dbg(rtk_phy->dev, "%s phy#%d use default parameter\n", 577 - __func__, index); 578 - goto do_toggle; 579 - } 580 - 581 - /* Set page 0 */ 582 - phy_data_page = phy_cfg->page0; 583 - rtk_phy_set_page(phy_reg, 0); 584 - 585 - for (i = 0; i < phy_cfg->page0_size; i++) { 586 - struct phy_data *phy_data = phy_data_page + i; 587 - u8 addr = phy_data->addr; 588 - u8 data = phy_data->data; 589 - 590 - if (!addr) 591 - continue; 592 - 593 - if (rtk_phy_write(phy_reg, addr, data)) { 594 - dev_err(rtk_phy->dev, 595 - "%s: Error to set page0 parameter addr=0x%x value=0x%x\n", 596 - __func__, addr, data); 597 - return -EINVAL; 598 - } 599 - } 600 - 601 - /* Set page 1 */ 602 - phy_data_page = phy_cfg->page1; 603 - rtk_phy_set_page(phy_reg, 1); 604 - 605 - for (i = 0; i < phy_cfg->page1_size; i++) { 606 - struct phy_data *phy_data = phy_data_page + i; 607 - u8 addr = phy_data->addr; 608 - u8 data = phy_data->data; 609 - 610 - if (!addr) 611 - continue; 612 - 613 - if (rtk_phy_write(phy_reg, addr, data)) { 614 - dev_err(rtk_phy->dev, 615 - "%s: Error to set page1 parameter addr=0x%x value=0x%x\n", 616 - __func__, addr, data); 617 - return -EINVAL; 618 - } 619 - } 620 - 621 - if (phy_cfg->page2_size == 0) 622 - goto do_toggle; 623 - 624 - /* Set page 2 */ 625 - phy_data_page = phy_cfg->page2; 626 - rtk_phy_set_page(phy_reg, 2); 627 - 628 - for (i = 0; i < phy_cfg->page2_size; i++) { 629 - struct phy_data *phy_data = phy_data_page + i; 630 - u8 addr = phy_data->addr; 631 - u8 data = phy_data->data; 632 - 633 - if (!addr) 634 - continue; 635 - 636 - if (rtk_phy_write(phy_reg, addr, data)) { 637 - dev_err(rtk_phy->dev, 638 - "%s: Error to set page2 parameter addr=0x%x value=0x%x\n", 639 - __func__, addr, data); 640 - return -EINVAL; 641 - } 642 - } 643 - 644 - do_toggle: 645 - do_rtk_phy_toggle(rtk_phy, index, false); 646 - 647 - return 0; 648 - } 649 - 650 - static int rtk_phy_init(struct phy *phy) 651 - { 652 - struct rtk_phy *rtk_phy = phy_get_drvdata(phy); 653 - unsigned long phy_init_time = jiffies; 654 - int i, ret = 0; 655 - 656 - if (!rtk_phy) 657 - return -EINVAL; 658 - 659 - for (i = 0; i < rtk_phy->num_phy; i++) 660 - ret = do_rtk_phy_init(rtk_phy, i); 661 - 662 - dev_dbg(rtk_phy->dev, "Initialized RTK USB 2.0 PHY (take %dms)\n", 663 - jiffies_to_msecs(jiffies - phy_init_time)); 664 - return ret; 665 - } 666 - 667 - static int rtk_phy_exit(struct phy *phy) 668 - { 669 - return 0; 670 - } 671 - 672 - static const struct phy_ops ops = { 673 - .init = rtk_phy_init, 674 - .exit = rtk_phy_exit, 675 - .owner = THIS_MODULE, 676 - }; 677 - 678 - static void rtk_phy_toggle(struct usb_phy *usb2_phy, bool connect, int port) 679 - { 680 - int index = port; 681 - struct rtk_phy *rtk_phy = NULL; 682 - 683 - rtk_phy = dev_get_drvdata(usb2_phy->dev); 684 - 685 - if (index > rtk_phy->num_phy) { 686 - dev_err(rtk_phy->dev, "%s: The port=%d is not in usb phy (num_phy=%d)\n", 687 - __func__, index, rtk_phy->num_phy); 688 - return; 689 - } 690 - 691 - do_rtk_phy_toggle(rtk_phy, index, connect); 692 - } 693 - 694 - static int rtk_phy_notify_port_status(struct usb_phy *x, int port, 695 - u16 portstatus, u16 portchange) 696 - { 697 - bool connect = false; 698 - 699 - pr_debug("%s port=%d portstatus=0x%x portchange=0x%x\n", 700 - __func__, port, (int)portstatus, (int)portchange); 701 - if (portstatus & USB_PORT_STAT_CONNECTION) 702 - connect = true; 703 - 704 - if (portchange & USB_PORT_STAT_C_CONNECTION) 705 - rtk_phy_toggle(x, connect, port); 706 - 707 - return 0; 708 - } 709 - 710 - #ifdef CONFIG_DEBUG_FS 711 - static struct dentry *create_phy_debug_root(void) 712 - { 713 - struct dentry *phy_debug_root; 714 - 715 - phy_debug_root = debugfs_lookup("phy", usb_debug_root); 716 - if (!phy_debug_root) 717 - phy_debug_root = debugfs_create_dir("phy", usb_debug_root); 718 - 719 - return phy_debug_root; 720 - } 721 - 722 - static int rtk_usb2_parameter_show(struct seq_file *s, void *unused) 723 - { 724 - struct rtk_phy *rtk_phy = s->private; 725 - struct phy_cfg *phy_cfg; 726 - int i, index; 727 - 728 - phy_cfg = rtk_phy->phy_cfg; 729 - 730 - seq_puts(s, "Property:\n"); 731 - seq_printf(s, " check_efuse: %s\n", 732 - phy_cfg->check_efuse ? "Enable" : "Disable"); 733 - seq_printf(s, " check_efuse_version: %d\n", 734 - phy_cfg->check_efuse_version); 735 - seq_printf(s, " efuse_dc_driving_rate: %d\n", 736 - phy_cfg->efuse_dc_driving_rate); 737 - seq_printf(s, " dc_driving_mask: 0x%x\n", 738 - phy_cfg->dc_driving_mask); 739 - seq_printf(s, " efuse_dc_disconnect_rate: %d\n", 740 - phy_cfg->efuse_dc_disconnect_rate); 741 - seq_printf(s, " dc_disconnect_mask: 0x%x\n", 742 - phy_cfg->dc_disconnect_mask); 743 - seq_printf(s, " usb_dc_disconnect_at_page0: %s\n", 744 - phy_cfg->usb_dc_disconnect_at_page0 ? "true" : "false"); 745 - seq_printf(s, " do_toggle: %s\n", 746 - phy_cfg->do_toggle ? "Enable" : "Disable"); 747 - seq_printf(s, " do_toggle_driving: %s\n", 748 - phy_cfg->do_toggle_driving ? "Enable" : "Disable"); 749 - seq_printf(s, " driving_updated_for_dev_dis: 0x%x\n", 750 - phy_cfg->driving_updated_for_dev_dis); 751 - seq_printf(s, " use_default_parameter: %s\n", 752 - phy_cfg->use_default_parameter ? "Enable" : "Disable"); 753 - seq_printf(s, " is_double_sensitivity_mode: %s\n", 754 - phy_cfg->is_double_sensitivity_mode ? "Enable" : "Disable"); 755 - 756 - for (index = 0; index < rtk_phy->num_phy; index++) { 757 - struct phy_parameter *phy_parameter; 758 - struct phy_reg *phy_reg; 759 - struct phy_data *phy_data_page; 760 - 761 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 762 - phy_reg = &phy_parameter->phy_reg; 763 - 764 - seq_printf(s, "PHY %d:\n", index); 765 - 766 - seq_puts(s, "Page 0:\n"); 767 - /* Set page 0 */ 768 - phy_data_page = phy_cfg->page0; 769 - rtk_phy_set_page(phy_reg, 0); 770 - 771 - for (i = 0; i < phy_cfg->page0_size; i++) { 772 - struct phy_data *phy_data = phy_data_page + i; 773 - u8 addr = array_index_to_page_addr(i); 774 - u8 data = phy_data->data; 775 - u8 value = rtk_phy_read(phy_reg, addr); 776 - 777 - if (phy_data->addr) 778 - seq_printf(s, " Page 0: addr=0x%x data=0x%02x ==> read value=0x%02x\n", 779 - addr, data, value); 780 - else 781 - seq_printf(s, " Page 0: addr=0x%x data=none ==> read value=0x%02x\n", 782 - addr, value); 783 - } 784 - 785 - seq_puts(s, "Page 1:\n"); 786 - /* Set page 1 */ 787 - phy_data_page = phy_cfg->page1; 788 - rtk_phy_set_page(phy_reg, 1); 789 - 790 - for (i = 0; i < phy_cfg->page1_size; i++) { 791 - struct phy_data *phy_data = phy_data_page + i; 792 - u8 addr = array_index_to_page_addr(i); 793 - u8 data = phy_data->data; 794 - u8 value = rtk_phy_read(phy_reg, addr); 795 - 796 - if (phy_data->addr) 797 - seq_printf(s, " Page 1: addr=0x%x data=0x%02x ==> read value=0x%02x\n", 798 - addr, data, value); 799 - else 800 - seq_printf(s, " Page 1: addr=0x%x data=none ==> read value=0x%02x\n", 801 - addr, value); 802 - } 803 - 804 - if (phy_cfg->page2_size == 0) 805 - goto out; 806 - 807 - seq_puts(s, "Page 2:\n"); 808 - /* Set page 2 */ 809 - phy_data_page = phy_cfg->page2; 810 - rtk_phy_set_page(phy_reg, 2); 811 - 812 - for (i = 0; i < phy_cfg->page2_size; i++) { 813 - struct phy_data *phy_data = phy_data_page + i; 814 - u8 addr = array_index_to_page_addr(i); 815 - u8 data = phy_data->data; 816 - u8 value = rtk_phy_read(phy_reg, addr); 817 - 818 - if (phy_data->addr) 819 - seq_printf(s, " Page 2: addr=0x%x data=0x%02x ==> read value=0x%02x\n", 820 - addr, data, value); 821 - else 822 - seq_printf(s, " Page 2: addr=0x%x data=none ==> read value=0x%02x\n", 823 - addr, value); 824 - } 825 - 826 - out: 827 - seq_puts(s, "PHY Property:\n"); 828 - seq_printf(s, " efuse_usb_dc_cal: %d\n", 829 - (int)phy_parameter->efuse_usb_dc_cal); 830 - seq_printf(s, " efuse_usb_dc_dis: %d\n", 831 - (int)phy_parameter->efuse_usb_dc_dis); 832 - seq_printf(s, " inverse_hstx_sync_clock: %s\n", 833 - phy_parameter->inverse_hstx_sync_clock ? "Enable" : "Disable"); 834 - seq_printf(s, " driving_level: %d\n", 835 - phy_parameter->driving_level); 836 - seq_printf(s, " driving_level_compensate: %d\n", 837 - phy_parameter->driving_level_compensate); 838 - seq_printf(s, " disconnection_compensate: %d\n", 839 - phy_parameter->disconnection_compensate); 840 - } 841 - 842 - return 0; 843 - } 844 - DEFINE_SHOW_ATTRIBUTE(rtk_usb2_parameter); 845 - 846 - static inline void create_debug_files(struct rtk_phy *rtk_phy) 847 - { 848 - struct dentry *phy_debug_root = NULL; 849 - 850 - phy_debug_root = create_phy_debug_root(); 851 - if (!phy_debug_root) 852 - return; 853 - 854 - rtk_phy->debug_dir = debugfs_create_dir(dev_name(rtk_phy->dev), 855 - phy_debug_root); 856 - 857 - debugfs_create_file("parameter", 0444, rtk_phy->debug_dir, rtk_phy, 858 - &rtk_usb2_parameter_fops); 859 - 860 - return; 861 - } 862 - 863 - static inline void remove_debug_files(struct rtk_phy *rtk_phy) 864 - { 865 - debugfs_remove_recursive(rtk_phy->debug_dir); 866 - } 867 - #else 868 - static inline void create_debug_files(struct rtk_phy *rtk_phy) { } 869 - static inline void remove_debug_files(struct rtk_phy *rtk_phy) { } 870 - #endif /* CONFIG_DEBUG_FS */ 871 - 872 - static int get_phy_data_by_efuse(struct rtk_phy *rtk_phy, 873 - struct phy_parameter *phy_parameter, int index) 874 - { 875 - struct phy_cfg *phy_cfg = rtk_phy->phy_cfg; 876 - u8 value = 0; 877 - struct nvmem_cell *cell; 878 - struct soc_device_attribute rtk_soc_groot[] = { 879 - { .family = "Realtek Groot",}, 880 - { /* empty */ } }; 881 - 882 - if (!phy_cfg->check_efuse) 883 - goto out; 884 - 885 - /* Read efuse for usb dc cal */ 886 - cell = nvmem_cell_get(rtk_phy->dev, "usb-dc-cal"); 887 - if (IS_ERR(cell)) { 888 - dev_dbg(rtk_phy->dev, "%s no usb-dc-cal: %ld\n", 889 - __func__, PTR_ERR(cell)); 890 - } else { 891 - unsigned char *buf; 892 - size_t buf_size; 893 - 894 - buf = nvmem_cell_read(cell, &buf_size); 895 - if (!IS_ERR(buf)) { 896 - value = buf[0] & phy_cfg->dc_driving_mask; 897 - kfree(buf); 898 - } 899 - nvmem_cell_put(cell); 900 - } 901 - 902 - if (phy_cfg->check_efuse_version == CHECK_EFUSE_V1) { 903 - int rate = phy_cfg->efuse_dc_driving_rate; 904 - 905 - if (value <= EFUS_USB_DC_CAL_MAX) 906 - phy_parameter->efuse_usb_dc_cal = (int8_t)(value * rate); 907 - else 908 - phy_parameter->efuse_usb_dc_cal = -(int8_t) 909 - ((EFUS_USB_DC_CAL_MAX & value) * rate); 910 - 911 - if (soc_device_match(rtk_soc_groot)) { 912 - dev_dbg(rtk_phy->dev, "For groot IC we need a workaround to adjust efuse_usb_dc_cal\n"); 913 - 914 - /* We don't multiple dc_cal_rate=2 for positive dc cal compensate */ 915 - if (value <= EFUS_USB_DC_CAL_MAX) 916 - phy_parameter->efuse_usb_dc_cal = (int8_t)(value); 917 - 918 - /* We set max dc cal compensate is 0x8 if otp is 0x7 */ 919 - if (value == 0x7) 920 - phy_parameter->efuse_usb_dc_cal = (int8_t)(value + 1); 921 - } 922 - } else { /* for CHECK_EFUSE_V2 */ 923 - phy_parameter->efuse_usb_dc_cal = value & phy_cfg->dc_driving_mask; 924 - } 925 - 926 - /* Read efuse for usb dc disconnect level */ 927 - value = 0; 928 - cell = nvmem_cell_get(rtk_phy->dev, "usb-dc-dis"); 929 - if (IS_ERR(cell)) { 930 - dev_dbg(rtk_phy->dev, "%s no usb-dc-dis: %ld\n", 931 - __func__, PTR_ERR(cell)); 932 - } else { 933 - unsigned char *buf; 934 - size_t buf_size; 935 - 936 - buf = nvmem_cell_read(cell, &buf_size); 937 - if (!IS_ERR(buf)) { 938 - value = buf[0] & phy_cfg->dc_disconnect_mask; 939 - kfree(buf); 940 - } 941 - nvmem_cell_put(cell); 942 - } 943 - 944 - if (phy_cfg->check_efuse_version == CHECK_EFUSE_V1) { 945 - int rate = phy_cfg->efuse_dc_disconnect_rate; 946 - 947 - if (value <= EFUS_USB_DC_DIS_MAX) 948 - phy_parameter->efuse_usb_dc_dis = (int8_t)(value * rate); 949 - else 950 - phy_parameter->efuse_usb_dc_dis = -(int8_t) 951 - ((EFUS_USB_DC_DIS_MAX & value) * rate); 952 - } else { /* for CHECK_EFUSE_V2 */ 953 - phy_parameter->efuse_usb_dc_dis = value & phy_cfg->dc_disconnect_mask; 954 - } 955 - 956 - out: 957 - return 0; 958 - } 959 - 960 - static int parse_phy_data(struct rtk_phy *rtk_phy) 961 - { 962 - struct device *dev = rtk_phy->dev; 963 - struct device_node *np = dev->of_node; 964 - struct phy_parameter *phy_parameter; 965 - int ret = 0; 966 - int index; 967 - 968 - rtk_phy->phy_parameter = devm_kzalloc(dev, sizeof(struct phy_parameter) * 969 - rtk_phy->num_phy, GFP_KERNEL); 970 - if (!rtk_phy->phy_parameter) 971 - return -ENOMEM; 972 - 973 - for (index = 0; index < rtk_phy->num_phy; index++) { 974 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 975 - 976 - phy_parameter->phy_reg.reg_wrap_vstatus = of_iomap(np, 0); 977 - phy_parameter->phy_reg.reg_gusb2phyacc0 = of_iomap(np, 1) + index; 978 - phy_parameter->phy_reg.vstatus_index = index; 979 - 980 - if (of_property_read_bool(np, "realtek,inverse-hstx-sync-clock")) 981 - phy_parameter->inverse_hstx_sync_clock = true; 982 - else 983 - phy_parameter->inverse_hstx_sync_clock = false; 984 - 985 - if (of_property_read_u32_index(np, "realtek,driving-level", 986 - index, &phy_parameter->driving_level)) 987 - phy_parameter->driving_level = DEFAULT_DC_DRIVING_VALUE; 988 - 989 - if (of_property_read_u32_index(np, "realtek,driving-level-compensate", 990 - index, &phy_parameter->driving_level_compensate)) 991 - phy_parameter->driving_level_compensate = 0; 992 - 993 - if (of_property_read_u32_index(np, "realtek,disconnection-compensate", 994 - index, &phy_parameter->disconnection_compensate)) 995 - phy_parameter->disconnection_compensate = 0; 996 - 997 - get_phy_data_by_efuse(rtk_phy, phy_parameter, index); 998 - 999 - update_dc_driving_level(rtk_phy, phy_parameter); 1000 - 1001 - update_hs_clk_select(rtk_phy, phy_parameter); 1002 - } 1003 - 1004 - return ret; 1005 - } 1006 - 1007 - static int rtk_usb2phy_probe(struct platform_device *pdev) 1008 - { 1009 - struct rtk_phy *rtk_phy; 1010 - struct device *dev = &pdev->dev; 1011 - struct phy *generic_phy; 1012 - struct phy_provider *phy_provider; 1013 - const struct phy_cfg *phy_cfg; 1014 - int ret = 0; 1015 - 1016 - phy_cfg = of_device_get_match_data(dev); 1017 - if (!phy_cfg) { 1018 - dev_err(dev, "phy config are not assigned!\n"); 1019 - return -EINVAL; 1020 - } 1021 - 1022 - rtk_phy = devm_kzalloc(dev, sizeof(*rtk_phy), GFP_KERNEL); 1023 - if (!rtk_phy) 1024 - return -ENOMEM; 1025 - 1026 - rtk_phy->dev = &pdev->dev; 1027 - rtk_phy->phy.dev = rtk_phy->dev; 1028 - rtk_phy->phy.label = "rtk-usb2phy"; 1029 - rtk_phy->phy.notify_port_status = rtk_phy_notify_port_status; 1030 - 1031 - rtk_phy->phy_cfg = devm_kzalloc(dev, sizeof(*phy_cfg), GFP_KERNEL); 1032 - 1033 - memcpy(rtk_phy->phy_cfg, phy_cfg, sizeof(*phy_cfg)); 1034 - 1035 - rtk_phy->num_phy = phy_cfg->num_phy; 1036 - 1037 - ret = parse_phy_data(rtk_phy); 1038 - if (ret) 1039 - goto err; 1040 - 1041 - platform_set_drvdata(pdev, rtk_phy); 1042 - 1043 - generic_phy = devm_phy_create(rtk_phy->dev, NULL, &ops); 1044 - if (IS_ERR(generic_phy)) 1045 - return PTR_ERR(generic_phy); 1046 - 1047 - phy_set_drvdata(generic_phy, rtk_phy); 1048 - 1049 - phy_provider = devm_of_phy_provider_register(rtk_phy->dev, 1050 - of_phy_simple_xlate); 1051 - if (IS_ERR(phy_provider)) 1052 - return PTR_ERR(phy_provider); 1053 - 1054 - ret = usb_add_phy_dev(&rtk_phy->phy); 1055 - if (ret) 1056 - goto err; 1057 - 1058 - create_debug_files(rtk_phy); 1059 - 1060 - err: 1061 - return ret; 1062 - } 1063 - 1064 - static void rtk_usb2phy_remove(struct platform_device *pdev) 1065 - { 1066 - struct rtk_phy *rtk_phy = platform_get_drvdata(pdev); 1067 - 1068 - remove_debug_files(rtk_phy); 1069 - 1070 - usb_remove_phy(&rtk_phy->phy); 1071 - } 1072 - 1073 - static const struct phy_cfg rtd1295_phy_cfg = { 1074 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1075 - .page0 = { [0] = {0xe0, 0x90}, 1076 - [3] = {0xe3, 0x3a}, 1077 - [4] = {0xe4, 0x68}, 1078 - [6] = {0xe6, 0x91}, 1079 - [13] = {0xf5, 0x81}, 1080 - [15] = {0xf7, 0x02}, }, 1081 - .page1_size = 8, 1082 - .page1 = { /* default parameter */ }, 1083 - .page2_size = 0, 1084 - .page2 = { /* no parameter */ }, 1085 - .num_phy = 1, 1086 - .check_efuse = false, 1087 - .check_efuse_version = CHECK_EFUSE_V1, 1088 - .efuse_dc_driving_rate = 1, 1089 - .dc_driving_mask = 0xf, 1090 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1091 - .dc_disconnect_mask = 0xf, 1092 - .usb_dc_disconnect_at_page0 = true, 1093 - .do_toggle = true, 1094 - .do_toggle_driving = false, 1095 - .driving_updated_for_dev_dis = 0xf, 1096 - .use_default_parameter = false, 1097 - .is_double_sensitivity_mode = false, 1098 - }; 1099 - 1100 - static const struct phy_cfg rtd1395_phy_cfg = { 1101 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1102 - .page0 = { [4] = {0xe4, 0xac}, 1103 - [13] = {0xf5, 0x00}, 1104 - [15] = {0xf7, 0x02}, }, 1105 - .page1_size = 8, 1106 - .page1 = { /* default parameter */ }, 1107 - .page2_size = 0, 1108 - .page2 = { /* no parameter */ }, 1109 - .num_phy = 1, 1110 - .check_efuse = false, 1111 - .check_efuse_version = CHECK_EFUSE_V1, 1112 - .efuse_dc_driving_rate = 1, 1113 - .dc_driving_mask = 0xf, 1114 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1115 - .dc_disconnect_mask = 0xf, 1116 - .usb_dc_disconnect_at_page0 = true, 1117 - .do_toggle = true, 1118 - .do_toggle_driving = false, 1119 - .driving_updated_for_dev_dis = 0xf, 1120 - .use_default_parameter = false, 1121 - .is_double_sensitivity_mode = false, 1122 - }; 1123 - 1124 - static const struct phy_cfg rtd1395_phy_cfg_2port = { 1125 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1126 - .page0 = { [4] = {0xe4, 0xac}, 1127 - [13] = {0xf5, 0x00}, 1128 - [15] = {0xf7, 0x02}, }, 1129 - .page1_size = 8, 1130 - .page1 = { /* default parameter */ }, 1131 - .page2_size = 0, 1132 - .page2 = { /* no parameter */ }, 1133 - .num_phy = 2, 1134 - .check_efuse = false, 1135 - .check_efuse_version = CHECK_EFUSE_V1, 1136 - .efuse_dc_driving_rate = 1, 1137 - .dc_driving_mask = 0xf, 1138 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1139 - .dc_disconnect_mask = 0xf, 1140 - .usb_dc_disconnect_at_page0 = true, 1141 - .do_toggle = true, 1142 - .do_toggle_driving = false, 1143 - .driving_updated_for_dev_dis = 0xf, 1144 - .use_default_parameter = false, 1145 - .is_double_sensitivity_mode = false, 1146 - }; 1147 - 1148 - static const struct phy_cfg rtd1619_phy_cfg = { 1149 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1150 - .page0 = { [4] = {0xe4, 0x68}, }, 1151 - .page1_size = 8, 1152 - .page1 = { /* default parameter */ }, 1153 - .page2_size = 0, 1154 - .page2 = { /* no parameter */ }, 1155 - .num_phy = 1, 1156 - .check_efuse = true, 1157 - .check_efuse_version = CHECK_EFUSE_V1, 1158 - .efuse_dc_driving_rate = 1, 1159 - .dc_driving_mask = 0xf, 1160 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1161 - .dc_disconnect_mask = 0xf, 1162 - .usb_dc_disconnect_at_page0 = true, 1163 - .do_toggle = true, 1164 - .do_toggle_driving = false, 1165 - .driving_updated_for_dev_dis = 0xf, 1166 - .use_default_parameter = false, 1167 - .is_double_sensitivity_mode = false, 1168 - }; 1169 - 1170 - static const struct phy_cfg rtd1319_phy_cfg = { 1171 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1172 - .page0 = { [0] = {0xe0, 0x18}, 1173 - [4] = {0xe4, 0x6a}, 1174 - [7] = {0xe7, 0x71}, 1175 - [13] = {0xf5, 0x15}, 1176 - [15] = {0xf7, 0x32}, }, 1177 - .page1_size = 8, 1178 - .page1 = { [3] = {0xe3, 0x44}, }, 1179 - .page2_size = MAX_USB_PHY_PAGE2_DATA_SIZE, 1180 - .page2 = { [0] = {0xe0, 0x01}, }, 1181 - .num_phy = 1, 1182 - .check_efuse = true, 1183 - .check_efuse_version = CHECK_EFUSE_V1, 1184 - .efuse_dc_driving_rate = 1, 1185 - .dc_driving_mask = 0xf, 1186 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1187 - .dc_disconnect_mask = 0xf, 1188 - .usb_dc_disconnect_at_page0 = true, 1189 - .do_toggle = true, 1190 - .do_toggle_driving = true, 1191 - .driving_updated_for_dev_dis = 0xf, 1192 - .use_default_parameter = false, 1193 - .is_double_sensitivity_mode = true, 1194 - }; 1195 - 1196 - static const struct phy_cfg rtd1312c_phy_cfg = { 1197 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1198 - .page0 = { [0] = {0xe0, 0x14}, 1199 - [4] = {0xe4, 0x67}, 1200 - [5] = {0xe5, 0x55}, }, 1201 - .page1_size = 8, 1202 - .page1 = { [3] = {0xe3, 0x23}, 1203 - [6] = {0xe6, 0x58}, }, 1204 - .page2_size = MAX_USB_PHY_PAGE2_DATA_SIZE, 1205 - .page2 = { /* default parameter */ }, 1206 - .num_phy = 1, 1207 - .check_efuse = true, 1208 - .check_efuse_version = CHECK_EFUSE_V1, 1209 - .efuse_dc_driving_rate = 1, 1210 - .dc_driving_mask = 0xf, 1211 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1212 - .dc_disconnect_mask = 0xf, 1213 - .usb_dc_disconnect_at_page0 = true, 1214 - .do_toggle = true, 1215 - .do_toggle_driving = true, 1216 - .driving_updated_for_dev_dis = 0xf, 1217 - .use_default_parameter = false, 1218 - .is_double_sensitivity_mode = true, 1219 - }; 1220 - 1221 - static const struct phy_cfg rtd1619b_phy_cfg = { 1222 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1223 - .page0 = { [0] = {0xe0, 0xa3}, 1224 - [4] = {0xe4, 0x88}, 1225 - [5] = {0xe5, 0x4f}, 1226 - [6] = {0xe6, 0x02}, }, 1227 - .page1_size = 8, 1228 - .page1 = { [3] = {0xe3, 0x64}, }, 1229 - .page2_size = MAX_USB_PHY_PAGE2_DATA_SIZE, 1230 - .page2 = { [7] = {0xe7, 0x45}, }, 1231 - .num_phy = 1, 1232 - .check_efuse = true, 1233 - .check_efuse_version = CHECK_EFUSE_V1, 1234 - .efuse_dc_driving_rate = EFUS_USB_DC_CAL_RATE, 1235 - .dc_driving_mask = 0x1f, 1236 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1237 - .dc_disconnect_mask = 0xf, 1238 - .usb_dc_disconnect_at_page0 = false, 1239 - .do_toggle = true, 1240 - .do_toggle_driving = true, 1241 - .driving_updated_for_dev_dis = 0x8, 1242 - .use_default_parameter = false, 1243 - .is_double_sensitivity_mode = true, 1244 - }; 1245 - 1246 - static const struct phy_cfg rtd1319d_phy_cfg = { 1247 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1248 - .page0 = { [0] = {0xe0, 0xa3}, 1249 - [4] = {0xe4, 0x8e}, 1250 - [5] = {0xe5, 0x4f}, 1251 - [6] = {0xe6, 0x02}, }, 1252 - .page1_size = MAX_USB_PHY_PAGE1_DATA_SIZE, 1253 - .page1 = { [14] = {0xf5, 0x1}, }, 1254 - .page2_size = MAX_USB_PHY_PAGE2_DATA_SIZE, 1255 - .page2 = { [7] = {0xe7, 0x44}, }, 1256 - .check_efuse = true, 1257 - .num_phy = 1, 1258 - .check_efuse_version = CHECK_EFUSE_V1, 1259 - .efuse_dc_driving_rate = EFUS_USB_DC_CAL_RATE, 1260 - .dc_driving_mask = 0x1f, 1261 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1262 - .dc_disconnect_mask = 0xf, 1263 - .usb_dc_disconnect_at_page0 = false, 1264 - .do_toggle = true, 1265 - .do_toggle_driving = false, 1266 - .driving_updated_for_dev_dis = 0x8, 1267 - .use_default_parameter = false, 1268 - .is_double_sensitivity_mode = true, 1269 - }; 1270 - 1271 - static const struct phy_cfg rtd1315e_phy_cfg = { 1272 - .page0_size = MAX_USB_PHY_PAGE0_DATA_SIZE, 1273 - .page0 = { [0] = {0xe0, 0xa3}, 1274 - [4] = {0xe4, 0x8c}, 1275 - [5] = {0xe5, 0x4f}, 1276 - [6] = {0xe6, 0x02}, }, 1277 - .page1_size = MAX_USB_PHY_PAGE1_DATA_SIZE, 1278 - .page1 = { [3] = {0xe3, 0x7f}, 1279 - [14] = {0xf5, 0x01}, }, 1280 - .page2_size = MAX_USB_PHY_PAGE2_DATA_SIZE, 1281 - .page2 = { [7] = {0xe7, 0x44}, }, 1282 - .num_phy = 1, 1283 - .check_efuse = true, 1284 - .check_efuse_version = CHECK_EFUSE_V2, 1285 - .efuse_dc_driving_rate = EFUS_USB_DC_CAL_RATE, 1286 - .dc_driving_mask = 0x1f, 1287 - .efuse_dc_disconnect_rate = EFUS_USB_DC_DIS_RATE, 1288 - .dc_disconnect_mask = 0xf, 1289 - .usb_dc_disconnect_at_page0 = false, 1290 - .do_toggle = true, 1291 - .do_toggle_driving = false, 1292 - .driving_updated_for_dev_dis = 0x8, 1293 - .use_default_parameter = false, 1294 - .is_double_sensitivity_mode = true, 1295 - }; 1296 - 1297 - static const struct of_device_id usbphy_rtk_dt_match[] = { 1298 - { .compatible = "realtek,rtd1295-usb2phy", .data = &rtd1295_phy_cfg }, 1299 - { .compatible = "realtek,rtd1312c-usb2phy", .data = &rtd1312c_phy_cfg }, 1300 - { .compatible = "realtek,rtd1315e-usb2phy", .data = &rtd1315e_phy_cfg }, 1301 - { .compatible = "realtek,rtd1319-usb2phy", .data = &rtd1319_phy_cfg }, 1302 - { .compatible = "realtek,rtd1319d-usb2phy", .data = &rtd1319d_phy_cfg }, 1303 - { .compatible = "realtek,rtd1395-usb2phy", .data = &rtd1395_phy_cfg }, 1304 - { .compatible = "realtek,rtd1395-usb2phy-2port", .data = &rtd1395_phy_cfg_2port }, 1305 - { .compatible = "realtek,rtd1619-usb2phy", .data = &rtd1619_phy_cfg }, 1306 - { .compatible = "realtek,rtd1619b-usb2phy", .data = &rtd1619b_phy_cfg }, 1307 - {}, 1308 - }; 1309 - MODULE_DEVICE_TABLE(of, usbphy_rtk_dt_match); 1310 - 1311 - static struct platform_driver rtk_usb2phy_driver = { 1312 - .probe = rtk_usb2phy_probe, 1313 - .remove_new = rtk_usb2phy_remove, 1314 - .driver = { 1315 - .name = "rtk-usb2phy", 1316 - .of_match_table = usbphy_rtk_dt_match, 1317 - }, 1318 - }; 1319 - 1320 - module_platform_driver(rtk_usb2phy_driver); 1321 - 1322 - MODULE_LICENSE("GPL"); 1323 - MODULE_ALIAS("platform: rtk-usb2phy"); 1324 - MODULE_AUTHOR("Stanley Chang <stanley_chang@realtek.com>"); 1325 - MODULE_DESCRIPTION("Realtek usb 2.0 phy driver");

-761

drivers/phy/realtek/phy-rtk-usb3.c

··· 1 - // SPDX-License-Identifier: GPL-2.0 2 - /* 3 - * phy-rtk-usb3.c RTK usb3.0 phy driver 4 - * 5 - * copyright (c) 2023 realtek semiconductor corporation 6 - * 7 - */ 8 - 9 - #include <linux/module.h> 10 - #include <linux/of.h> 11 - #include <linux/of_address.h> 12 - #include <linux/platform_device.h> 13 - #include <linux/uaccess.h> 14 - #include <linux/debugfs.h> 15 - #include <linux/nvmem-consumer.h> 16 - #include <linux/regmap.h> 17 - #include <linux/sys_soc.h> 18 - #include <linux/mfd/syscon.h> 19 - #include <linux/phy/phy.h> 20 - #include <linux/usb.h> 21 - #include <linux/usb/hcd.h> 22 - #include <linux/usb/phy.h> 23 - 24 - #define USB_MDIO_CTRL_PHY_BUSY BIT(7) 25 - #define USB_MDIO_CTRL_PHY_WRITE BIT(0) 26 - #define USB_MDIO_CTRL_PHY_ADDR_SHIFT 8 27 - #define USB_MDIO_CTRL_PHY_DATA_SHIFT 16 28 - 29 - #define MAX_USB_PHY_DATA_SIZE 0x30 30 - #define PHY_ADDR_0X09 0x09 31 - #define PHY_ADDR_0X0B 0x0b 32 - #define PHY_ADDR_0X0D 0x0d 33 - #define PHY_ADDR_0X10 0x10 34 - #define PHY_ADDR_0X1F 0x1f 35 - #define PHY_ADDR_0X20 0x20 36 - #define PHY_ADDR_0X21 0x21 37 - #define PHY_ADDR_0X30 0x30 38 - 39 - #define REG_0X09_FORCE_CALIBRATION BIT(9) 40 - #define REG_0X0B_RX_OFFSET_RANGE_MASK 0xc 41 - #define REG_0X0D_RX_DEBUG_TEST_EN BIT(6) 42 - #define REG_0X10_DEBUG_MODE_SETTING 0x3c0 43 - #define REG_0X10_DEBUG_MODE_SETTING_MASK 0x3f8 44 - #define REG_0X1F_RX_OFFSET_CODE_MASK 0x1e 45 - 46 - #define USB_U3_TX_LFPS_SWING_TRIM_SHIFT 4 47 - #define USB_U3_TX_LFPS_SWING_TRIM_MASK 0xf 48 - #define AMPLITUDE_CONTROL_COARSE_MASK 0xff 49 - #define AMPLITUDE_CONTROL_FINE_MASK 0xffff 50 - #define AMPLITUDE_CONTROL_COARSE_DEFAULT 0xff 51 - #define AMPLITUDE_CONTROL_FINE_DEFAULT 0xffff 52 - 53 - #define PHY_ADDR_MAP_ARRAY_INDEX(addr) (addr) 54 - #define ARRAY_INDEX_MAP_PHY_ADDR(index) (index) 55 - 56 - struct phy_reg { 57 - void __iomem *reg_mdio_ctl; 58 - }; 59 - 60 - struct phy_data { 61 - u8 addr; 62 - u16 data; 63 - }; 64 - 65 - struct phy_cfg { 66 - int param_size; 67 - struct phy_data param[MAX_USB_PHY_DATA_SIZE]; 68 - 69 - bool check_efuse; 70 - bool do_toggle; 71 - bool do_toggle_once; 72 - bool use_default_parameter; 73 - bool check_rx_front_end_offset; 74 - }; 75 - 76 - struct phy_parameter { 77 - struct phy_reg phy_reg; 78 - 79 - /* Get from efuse */ 80 - u8 efuse_usb_u3_tx_lfps_swing_trim; 81 - 82 - /* Get from dts */ 83 - u32 amplitude_control_coarse; 84 - u32 amplitude_control_fine; 85 - }; 86 - 87 - struct rtk_phy { 88 - struct usb_phy phy; 89 - struct device *dev; 90 - 91 - struct phy_cfg *phy_cfg; 92 - int num_phy; 93 - struct phy_parameter *phy_parameter; 94 - 95 - struct dentry *debug_dir; 96 - }; 97 - 98 - #define PHY_IO_TIMEOUT_USEC (50000) 99 - #define PHY_IO_DELAY_US (100) 100 - 101 - static inline int utmi_wait_register(void __iomem *reg, u32 mask, u32 result) 102 - { 103 - int ret; 104 - unsigned int val; 105 - 106 - ret = read_poll_timeout(readl, val, ((val & mask) == result), 107 - PHY_IO_DELAY_US, PHY_IO_TIMEOUT_USEC, false, reg); 108 - if (ret) { 109 - pr_err("%s can't program USB phy\n", __func__); 110 - return -ETIMEDOUT; 111 - } 112 - 113 - return 0; 114 - } 115 - 116 - static int rtk_phy3_wait_vbusy(struct phy_reg *phy_reg) 117 - { 118 - return utmi_wait_register(phy_reg->reg_mdio_ctl, USB_MDIO_CTRL_PHY_BUSY, 0); 119 - } 120 - 121 - static u16 rtk_phy_read(struct phy_reg *phy_reg, char addr) 122 - { 123 - unsigned int tmp; 124 - u32 value; 125 - 126 - tmp = (addr << USB_MDIO_CTRL_PHY_ADDR_SHIFT); 127 - 128 - writel(tmp, phy_reg->reg_mdio_ctl); 129 - 130 - rtk_phy3_wait_vbusy(phy_reg); 131 - 132 - value = readl(phy_reg->reg_mdio_ctl); 133 - value = value >> USB_MDIO_CTRL_PHY_DATA_SHIFT; 134 - 135 - return (u16)value; 136 - } 137 - 138 - static int rtk_phy_write(struct phy_reg *phy_reg, char addr, u16 data) 139 - { 140 - unsigned int val; 141 - 142 - val = USB_MDIO_CTRL_PHY_WRITE | 143 - (addr << USB_MDIO_CTRL_PHY_ADDR_SHIFT) | 144 - (data << USB_MDIO_CTRL_PHY_DATA_SHIFT); 145 - 146 - writel(val, phy_reg->reg_mdio_ctl); 147 - 148 - rtk_phy3_wait_vbusy(phy_reg); 149 - 150 - return 0; 151 - } 152 - 153 - static void do_rtk_usb3_phy_toggle(struct rtk_phy *rtk_phy, int index, bool connect) 154 - { 155 - struct phy_cfg *phy_cfg = rtk_phy->phy_cfg; 156 - struct phy_reg *phy_reg; 157 - struct phy_parameter *phy_parameter; 158 - struct phy_data *phy_data; 159 - u8 addr; 160 - u16 data; 161 - int i; 162 - 163 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 164 - phy_reg = &phy_parameter->phy_reg; 165 - 166 - if (!phy_cfg->do_toggle) 167 - return; 168 - 169 - i = PHY_ADDR_MAP_ARRAY_INDEX(PHY_ADDR_0X09); 170 - phy_data = phy_cfg->param + i; 171 - addr = phy_data->addr; 172 - data = phy_data->data; 173 - 174 - if (!addr && !data) { 175 - addr = PHY_ADDR_0X09; 176 - data = rtk_phy_read(phy_reg, addr); 177 - phy_data->addr = addr; 178 - phy_data->data = data; 179 - } 180 - 181 - rtk_phy_write(phy_reg, addr, data & (~REG_0X09_FORCE_CALIBRATION)); 182 - mdelay(1); 183 - rtk_phy_write(phy_reg, addr, data | REG_0X09_FORCE_CALIBRATION); 184 - } 185 - 186 - static int do_rtk_phy_init(struct rtk_phy *rtk_phy, int index) 187 - { 188 - struct phy_cfg *phy_cfg; 189 - struct phy_reg *phy_reg; 190 - struct phy_parameter *phy_parameter; 191 - int i = 0; 192 - 193 - phy_cfg = rtk_phy->phy_cfg; 194 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 195 - phy_reg = &phy_parameter->phy_reg; 196 - 197 - if (phy_cfg->use_default_parameter) 198 - goto do_toggle; 199 - 200 - for (i = 0; i < phy_cfg->param_size; i++) { 201 - struct phy_data *phy_data = phy_cfg->param + i; 202 - u8 addr = phy_data->addr; 203 - u16 data = phy_data->data; 204 - 205 - if (!addr && !data) 206 - continue; 207 - 208 - rtk_phy_write(phy_reg, addr, data); 209 - } 210 - 211 - do_toggle: 212 - if (phy_cfg->do_toggle_once) 213 - phy_cfg->do_toggle = true; 214 - 215 - do_rtk_usb3_phy_toggle(rtk_phy, index, false); 216 - 217 - if (phy_cfg->do_toggle_once) { 218 - u16 check_value = 0; 219 - int count = 10; 220 - u16 value_0x0d, value_0x10; 221 - 222 - /* Enable Debug mode by set 0x0D and 0x10 */ 223 - value_0x0d = rtk_phy_read(phy_reg, PHY_ADDR_0X0D); 224 - value_0x10 = rtk_phy_read(phy_reg, PHY_ADDR_0X10); 225 - 226 - rtk_phy_write(phy_reg, PHY_ADDR_0X0D, 227 - value_0x0d | REG_0X0D_RX_DEBUG_TEST_EN); 228 - rtk_phy_write(phy_reg, PHY_ADDR_0X10, 229 - (value_0x10 & ~REG_0X10_DEBUG_MODE_SETTING_MASK) | 230 - REG_0X10_DEBUG_MODE_SETTING); 231 - 232 - check_value = rtk_phy_read(phy_reg, PHY_ADDR_0X30); 233 - 234 - while (!(check_value & BIT(15))) { 235 - check_value = rtk_phy_read(phy_reg, PHY_ADDR_0X30); 236 - mdelay(1); 237 - if (count-- < 0) 238 - break; 239 - } 240 - 241 - if (!(check_value & BIT(15))) 242 - dev_info(rtk_phy->dev, "toggle fail addr=0x%02x, data=0x%04x\n", 243 - PHY_ADDR_0X30, check_value); 244 - 245 - /* Disable Debug mode by set 0x0D and 0x10 to default*/ 246 - rtk_phy_write(phy_reg, PHY_ADDR_0X0D, value_0x0d); 247 - rtk_phy_write(phy_reg, PHY_ADDR_0X10, value_0x10); 248 - 249 - phy_cfg->do_toggle = false; 250 - } 251 - 252 - if (phy_cfg->check_rx_front_end_offset) { 253 - u16 rx_offset_code, rx_offset_range; 254 - u16 code_mask = REG_0X1F_RX_OFFSET_CODE_MASK; 255 - u16 range_mask = REG_0X0B_RX_OFFSET_RANGE_MASK; 256 - bool do_update = false; 257 - 258 - rx_offset_code = rtk_phy_read(phy_reg, PHY_ADDR_0X1F); 259 - if (((rx_offset_code & code_mask) == 0x0) || 260 - ((rx_offset_code & code_mask) == code_mask)) 261 - do_update = true; 262 - 263 - rx_offset_range = rtk_phy_read(phy_reg, PHY_ADDR_0X0B); 264 - if (((rx_offset_range & range_mask) == range_mask) && do_update) { 265 - dev_warn(rtk_phy->dev, "Don't update rx_offset_range (rx_offset_code=0x%x, rx_offset_range=0x%x)\n", 266 - rx_offset_code, rx_offset_range); 267 - do_update = false; 268 - } 269 - 270 - if (do_update) { 271 - u16 tmp1, tmp2; 272 - 273 - tmp1 = rx_offset_range & (~range_mask); 274 - tmp2 = rx_offset_range & range_mask; 275 - tmp2 += (1 << 2); 276 - rx_offset_range = tmp1 | (tmp2 & range_mask); 277 - rtk_phy_write(phy_reg, PHY_ADDR_0X0B, rx_offset_range); 278 - goto do_toggle; 279 - } 280 - } 281 - 282 - return 0; 283 - } 284 - 285 - static int rtk_phy_init(struct phy *phy) 286 - { 287 - struct rtk_phy *rtk_phy = phy_get_drvdata(phy); 288 - int ret = 0; 289 - int i; 290 - unsigned long phy_init_time = jiffies; 291 - 292 - for (i = 0; i < rtk_phy->num_phy; i++) 293 - ret = do_rtk_phy_init(rtk_phy, i); 294 - 295 - dev_dbg(rtk_phy->dev, "Initialized RTK USB 3.0 PHY (take %dms)\n", 296 - jiffies_to_msecs(jiffies - phy_init_time)); 297 - 298 - return ret; 299 - } 300 - 301 - static int rtk_phy_exit(struct phy *phy) 302 - { 303 - return 0; 304 - } 305 - 306 - static const struct phy_ops ops = { 307 - .init = rtk_phy_init, 308 - .exit = rtk_phy_exit, 309 - .owner = THIS_MODULE, 310 - }; 311 - 312 - static void rtk_phy_toggle(struct usb_phy *usb3_phy, bool connect, int port) 313 - { 314 - int index = port; 315 - struct rtk_phy *rtk_phy = NULL; 316 - 317 - rtk_phy = dev_get_drvdata(usb3_phy->dev); 318 - 319 - if (index > rtk_phy->num_phy) { 320 - dev_err(rtk_phy->dev, "%s: The port=%d is not in usb phy (num_phy=%d)\n", 321 - __func__, index, rtk_phy->num_phy); 322 - return; 323 - } 324 - 325 - do_rtk_usb3_phy_toggle(rtk_phy, index, connect); 326 - } 327 - 328 - static int rtk_phy_notify_port_status(struct usb_phy *x, int port, 329 - u16 portstatus, u16 portchange) 330 - { 331 - bool connect = false; 332 - 333 - pr_debug("%s port=%d portstatus=0x%x portchange=0x%x\n", 334 - __func__, port, (int)portstatus, (int)portchange); 335 - if (portstatus & USB_PORT_STAT_CONNECTION) 336 - connect = true; 337 - 338 - if (portchange & USB_PORT_STAT_C_CONNECTION) 339 - rtk_phy_toggle(x, connect, port); 340 - 341 - return 0; 342 - } 343 - 344 - #ifdef CONFIG_DEBUG_FS 345 - static struct dentry *create_phy_debug_root(void) 346 - { 347 - struct dentry *phy_debug_root; 348 - 349 - phy_debug_root = debugfs_lookup("phy", usb_debug_root); 350 - if (!phy_debug_root) 351 - phy_debug_root = debugfs_create_dir("phy", usb_debug_root); 352 - 353 - return phy_debug_root; 354 - } 355 - 356 - static int rtk_usb3_parameter_show(struct seq_file *s, void *unused) 357 - { 358 - struct rtk_phy *rtk_phy = s->private; 359 - struct phy_cfg *phy_cfg; 360 - int i, index; 361 - 362 - phy_cfg = rtk_phy->phy_cfg; 363 - 364 - seq_puts(s, "Property:\n"); 365 - seq_printf(s, " check_efuse: %s\n", 366 - phy_cfg->check_efuse ? "Enable" : "Disable"); 367 - seq_printf(s, " do_toggle: %s\n", 368 - phy_cfg->do_toggle ? "Enable" : "Disable"); 369 - seq_printf(s, " do_toggle_once: %s\n", 370 - phy_cfg->do_toggle_once ? "Enable" : "Disable"); 371 - seq_printf(s, " use_default_parameter: %s\n", 372 - phy_cfg->use_default_parameter ? "Enable" : "Disable"); 373 - 374 - for (index = 0; index < rtk_phy->num_phy; index++) { 375 - struct phy_reg *phy_reg; 376 - struct phy_parameter *phy_parameter; 377 - 378 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 379 - phy_reg = &phy_parameter->phy_reg; 380 - 381 - seq_printf(s, "PHY %d:\n", index); 382 - 383 - for (i = 0; i < phy_cfg->param_size; i++) { 384 - struct phy_data *phy_data = phy_cfg->param + i; 385 - u8 addr = ARRAY_INDEX_MAP_PHY_ADDR(i); 386 - u16 data = phy_data->data; 387 - 388 - if (!phy_data->addr && !data) 389 - seq_printf(s, " addr = 0x%02x, data = none ==> read value = 0x%04x\n", 390 - addr, rtk_phy_read(phy_reg, addr)); 391 - else 392 - seq_printf(s, " addr = 0x%02x, data = 0x%04x ==> read value = 0x%04x\n", 393 - addr, data, rtk_phy_read(phy_reg, addr)); 394 - } 395 - 396 - seq_puts(s, "PHY Property:\n"); 397 - seq_printf(s, " efuse_usb_u3_tx_lfps_swing_trim: 0x%x\n", 398 - (int)phy_parameter->efuse_usb_u3_tx_lfps_swing_trim); 399 - seq_printf(s, " amplitude_control_coarse: 0x%x\n", 400 - (int)phy_parameter->amplitude_control_coarse); 401 - seq_printf(s, " amplitude_control_fine: 0x%x\n", 402 - (int)phy_parameter->amplitude_control_fine); 403 - } 404 - 405 - return 0; 406 - } 407 - DEFINE_SHOW_ATTRIBUTE(rtk_usb3_parameter); 408 - 409 - static inline void create_debug_files(struct rtk_phy *rtk_phy) 410 - { 411 - struct dentry *phy_debug_root = NULL; 412 - 413 - phy_debug_root = create_phy_debug_root(); 414 - 415 - if (!phy_debug_root) 416 - return; 417 - 418 - rtk_phy->debug_dir = debugfs_create_dir(dev_name(rtk_phy->dev), phy_debug_root); 419 - 420 - debugfs_create_file("parameter", 0444, rtk_phy->debug_dir, rtk_phy, 421 - &rtk_usb3_parameter_fops); 422 - 423 - return; 424 - } 425 - 426 - static inline void remove_debug_files(struct rtk_phy *rtk_phy) 427 - { 428 - debugfs_remove_recursive(rtk_phy->debug_dir); 429 - } 430 - #else 431 - static inline void create_debug_files(struct rtk_phy *rtk_phy) { } 432 - static inline void remove_debug_files(struct rtk_phy *rtk_phy) { } 433 - #endif /* CONFIG_DEBUG_FS */ 434 - 435 - static int get_phy_data_by_efuse(struct rtk_phy *rtk_phy, 436 - struct phy_parameter *phy_parameter, int index) 437 - { 438 - struct phy_cfg *phy_cfg = rtk_phy->phy_cfg; 439 - u8 value = 0; 440 - struct nvmem_cell *cell; 441 - 442 - if (!phy_cfg->check_efuse) 443 - goto out; 444 - 445 - cell = nvmem_cell_get(rtk_phy->dev, "usb_u3_tx_lfps_swing_trim"); 446 - if (IS_ERR(cell)) { 447 - dev_dbg(rtk_phy->dev, "%s no usb_u3_tx_lfps_swing_trim: %ld\n", 448 - __func__, PTR_ERR(cell)); 449 - } else { 450 - unsigned char *buf; 451 - size_t buf_size; 452 - 453 - buf = nvmem_cell_read(cell, &buf_size); 454 - if (!IS_ERR(buf)) { 455 - value = buf[0] & USB_U3_TX_LFPS_SWING_TRIM_MASK; 456 - kfree(buf); 457 - } 458 - nvmem_cell_put(cell); 459 - } 460 - 461 - if (value > 0 && value < 0x8) 462 - phy_parameter->efuse_usb_u3_tx_lfps_swing_trim = 0x8; 463 - else 464 - phy_parameter->efuse_usb_u3_tx_lfps_swing_trim = (u8)value; 465 - 466 - out: 467 - return 0; 468 - } 469 - 470 - static void update_amplitude_control_value(struct rtk_phy *rtk_phy, 471 - struct phy_parameter *phy_parameter) 472 - { 473 - struct phy_cfg *phy_cfg; 474 - struct phy_reg *phy_reg; 475 - 476 - phy_reg = &phy_parameter->phy_reg; 477 - phy_cfg = rtk_phy->phy_cfg; 478 - 479 - if (phy_parameter->amplitude_control_coarse != AMPLITUDE_CONTROL_COARSE_DEFAULT) { 480 - u16 val_mask = AMPLITUDE_CONTROL_COARSE_MASK; 481 - u16 data; 482 - 483 - if (!phy_cfg->param[PHY_ADDR_0X20].addr && !phy_cfg->param[PHY_ADDR_0X20].data) { 484 - phy_cfg->param[PHY_ADDR_0X20].addr = PHY_ADDR_0X20; 485 - data = rtk_phy_read(phy_reg, PHY_ADDR_0X20); 486 - } else { 487 - data = phy_cfg->param[PHY_ADDR_0X20].data; 488 - } 489 - 490 - data &= (~val_mask); 491 - data |= (phy_parameter->amplitude_control_coarse & val_mask); 492 - 493 - phy_cfg->param[PHY_ADDR_0X20].data = data; 494 - } 495 - 496 - if (phy_parameter->efuse_usb_u3_tx_lfps_swing_trim) { 497 - u8 efuse_val = phy_parameter->efuse_usb_u3_tx_lfps_swing_trim; 498 - u16 val_mask = USB_U3_TX_LFPS_SWING_TRIM_MASK; 499 - int val_shift = USB_U3_TX_LFPS_SWING_TRIM_SHIFT; 500 - u16 data; 501 - 502 - if (!phy_cfg->param[PHY_ADDR_0X20].addr && !phy_cfg->param[PHY_ADDR_0X20].data) { 503 - phy_cfg->param[PHY_ADDR_0X20].addr = PHY_ADDR_0X20; 504 - data = rtk_phy_read(phy_reg, PHY_ADDR_0X20); 505 - } else { 506 - data = phy_cfg->param[PHY_ADDR_0X20].data; 507 - } 508 - 509 - data &= ~(val_mask << val_shift); 510 - data |= ((efuse_val & val_mask) << val_shift); 511 - 512 - phy_cfg->param[PHY_ADDR_0X20].data = data; 513 - } 514 - 515 - if (phy_parameter->amplitude_control_fine != AMPLITUDE_CONTROL_FINE_DEFAULT) { 516 - u16 val_mask = AMPLITUDE_CONTROL_FINE_MASK; 517 - 518 - if (!phy_cfg->param[PHY_ADDR_0X21].addr && !phy_cfg->param[PHY_ADDR_0X21].data) 519 - phy_cfg->param[PHY_ADDR_0X21].addr = PHY_ADDR_0X21; 520 - 521 - phy_cfg->param[PHY_ADDR_0X21].data = 522 - phy_parameter->amplitude_control_fine & val_mask; 523 - } 524 - } 525 - 526 - static int parse_phy_data(struct rtk_phy *rtk_phy) 527 - { 528 - struct device *dev = rtk_phy->dev; 529 - struct phy_parameter *phy_parameter; 530 - int ret = 0; 531 - int index; 532 - 533 - rtk_phy->phy_parameter = devm_kzalloc(dev, sizeof(struct phy_parameter) * 534 - rtk_phy->num_phy, GFP_KERNEL); 535 - if (!rtk_phy->phy_parameter) 536 - return -ENOMEM; 537 - 538 - for (index = 0; index < rtk_phy->num_phy; index++) { 539 - phy_parameter = &((struct phy_parameter *)rtk_phy->phy_parameter)[index]; 540 - 541 - phy_parameter->phy_reg.reg_mdio_ctl = of_iomap(dev->of_node, 0) + index; 542 - 543 - /* Amplitude control address 0x20 bit 0 to bit 7 */ 544 - if (of_property_read_u32(dev->of_node, "realtek,amplitude-control-coarse-tuning", 545 - &phy_parameter->amplitude_control_coarse)) 546 - phy_parameter->amplitude_control_coarse = AMPLITUDE_CONTROL_COARSE_DEFAULT; 547 - 548 - /* Amplitude control address 0x21 bit 0 to bit 16 */ 549 - if (of_property_read_u32(dev->of_node, "realtek,amplitude-control-fine-tuning", 550 - &phy_parameter->amplitude_control_fine)) 551 - phy_parameter->amplitude_control_fine = AMPLITUDE_CONTROL_FINE_DEFAULT; 552 - 553 - get_phy_data_by_efuse(rtk_phy, phy_parameter, index); 554 - 555 - update_amplitude_control_value(rtk_phy, phy_parameter); 556 - } 557 - 558 - return ret; 559 - } 560 - 561 - static int rtk_usb3phy_probe(struct platform_device *pdev) 562 - { 563 - struct rtk_phy *rtk_phy; 564 - struct device *dev = &pdev->dev; 565 - struct phy *generic_phy; 566 - struct phy_provider *phy_provider; 567 - const struct phy_cfg *phy_cfg; 568 - int ret; 569 - 570 - phy_cfg = of_device_get_match_data(dev); 571 - if (!phy_cfg) { 572 - dev_err(dev, "phy config are not assigned!\n"); 573 - return -EINVAL; 574 - } 575 - 576 - rtk_phy = devm_kzalloc(dev, sizeof(*rtk_phy), GFP_KERNEL); 577 - if (!rtk_phy) 578 - return -ENOMEM; 579 - 580 - rtk_phy->dev = &pdev->dev; 581 - rtk_phy->phy.dev = rtk_phy->dev; 582 - rtk_phy->phy.label = "rtk-usb3phy"; 583 - rtk_phy->phy.notify_port_status = rtk_phy_notify_port_status; 584 - 585 - rtk_phy->phy_cfg = devm_kzalloc(dev, sizeof(*phy_cfg), GFP_KERNEL); 586 - 587 - memcpy(rtk_phy->phy_cfg, phy_cfg, sizeof(*phy_cfg)); 588 - 589 - rtk_phy->num_phy = 1; 590 - 591 - ret = parse_phy_data(rtk_phy); 592 - if (ret) 593 - goto err; 594 - 595 - platform_set_drvdata(pdev, rtk_phy); 596 - 597 - generic_phy = devm_phy_create(rtk_phy->dev, NULL, &ops); 598 - if (IS_ERR(generic_phy)) 599 - return PTR_ERR(generic_phy); 600 - 601 - phy_set_drvdata(generic_phy, rtk_phy); 602 - 603 - phy_provider = devm_of_phy_provider_register(rtk_phy->dev, of_phy_simple_xlate); 604 - if (IS_ERR(phy_provider)) 605 - return PTR_ERR(phy_provider); 606 - 607 - ret = usb_add_phy_dev(&rtk_phy->phy); 608 - if (ret) 609 - goto err; 610 - 611 - create_debug_files(rtk_phy); 612 - 613 - err: 614 - return ret; 615 - } 616 - 617 - static void rtk_usb3phy_remove(struct platform_device *pdev) 618 - { 619 - struct rtk_phy *rtk_phy = platform_get_drvdata(pdev); 620 - 621 - remove_debug_files(rtk_phy); 622 - 623 - usb_remove_phy(&rtk_phy->phy); 624 - } 625 - 626 - static const struct phy_cfg rtd1295_phy_cfg = { 627 - .param_size = MAX_USB_PHY_DATA_SIZE, 628 - .param = { [0] = {0x01, 0x4008}, [1] = {0x01, 0xe046}, 629 - [2] = {0x02, 0x6046}, [3] = {0x03, 0x2779}, 630 - [4] = {0x04, 0x72f5}, [5] = {0x05, 0x2ad3}, 631 - [6] = {0x06, 0x000e}, [7] = {0x07, 0x2e00}, 632 - [8] = {0x08, 0x3591}, [9] = {0x09, 0x525c}, 633 - [10] = {0x0a, 0xa600}, [11] = {0x0b, 0xa904}, 634 - [12] = {0x0c, 0xc000}, [13] = {0x0d, 0xef1c}, 635 - [14] = {0x0e, 0x2000}, [15] = {0x0f, 0x0000}, 636 - [16] = {0x10, 0x000c}, [17] = {0x11, 0x4c00}, 637 - [18] = {0x12, 0xfc00}, [19] = {0x13, 0x0c81}, 638 - [20] = {0x14, 0xde01}, [21] = {0x15, 0x0000}, 639 - [22] = {0x16, 0x0000}, [23] = {0x17, 0x0000}, 640 - [24] = {0x18, 0x0000}, [25] = {0x19, 0x4004}, 641 - [26] = {0x1a, 0x1260}, [27] = {0x1b, 0xff00}, 642 - [28] = {0x1c, 0xcb00}, [29] = {0x1d, 0xa03f}, 643 - [30] = {0x1e, 0xc2e0}, [31] = {0x1f, 0x2807}, 644 - [32] = {0x20, 0x947a}, [33] = {0x21, 0x88aa}, 645 - [34] = {0x22, 0x0057}, [35] = {0x23, 0xab66}, 646 - [36] = {0x24, 0x0800}, [37] = {0x25, 0x0000}, 647 - [38] = {0x26, 0x040a}, [39] = {0x27, 0x01d6}, 648 - [40] = {0x28, 0xf8c2}, [41] = {0x29, 0x3080}, 649 - [42] = {0x2a, 0x3082}, [43] = {0x2b, 0x2078}, 650 - [44] = {0x2c, 0xffff}, [45] = {0x2d, 0xffff}, 651 - [46] = {0x2e, 0x0000}, [47] = {0x2f, 0x0040}, }, 652 - .check_efuse = false, 653 - .do_toggle = true, 654 - .do_toggle_once = false, 655 - .use_default_parameter = false, 656 - .check_rx_front_end_offset = false, 657 - }; 658 - 659 - static const struct phy_cfg rtd1619_phy_cfg = { 660 - .param_size = MAX_USB_PHY_DATA_SIZE, 661 - .param = { [8] = {0x08, 0x3591}, 662 - [38] = {0x26, 0x840b}, 663 - [40] = {0x28, 0xf842}, }, 664 - .check_efuse = false, 665 - .do_toggle = true, 666 - .do_toggle_once = false, 667 - .use_default_parameter = false, 668 - .check_rx_front_end_offset = false, 669 - }; 670 - 671 - static const struct phy_cfg rtd1319_phy_cfg = { 672 - .param_size = MAX_USB_PHY_DATA_SIZE, 673 - .param = { [1] = {0x01, 0xac86}, 674 - [6] = {0x06, 0x0003}, 675 - [9] = {0x09, 0x924c}, 676 - [10] = {0x0a, 0xa608}, 677 - [11] = {0x0b, 0xb905}, 678 - [14] = {0x0e, 0x2010}, 679 - [32] = {0x20, 0x705a}, 680 - [33] = {0x21, 0xf645}, 681 - [34] = {0x22, 0x0013}, 682 - [35] = {0x23, 0xcb66}, 683 - [41] = {0x29, 0xff00}, }, 684 - .check_efuse = true, 685 - .do_toggle = true, 686 - .do_toggle_once = false, 687 - .use_default_parameter = false, 688 - .check_rx_front_end_offset = false, 689 - }; 690 - 691 - static const struct phy_cfg rtd1619b_phy_cfg = { 692 - .param_size = MAX_USB_PHY_DATA_SIZE, 693 - .param = { [1] = {0x01, 0xac8c}, 694 - [6] = {0x06, 0x0017}, 695 - [9] = {0x09, 0x724c}, 696 - [10] = {0x0a, 0xb610}, 697 - [11] = {0x0b, 0xb90d}, 698 - [13] = {0x0d, 0xef2a}, 699 - [15] = {0x0f, 0x9050}, 700 - [16] = {0x10, 0x000c}, 701 - [32] = {0x20, 0x70ff}, 702 - [34] = {0x22, 0x0013}, 703 - [35] = {0x23, 0xdb66}, 704 - [38] = {0x26, 0x8609}, 705 - [41] = {0x29, 0xff13}, 706 - [42] = {0x2a, 0x3070}, }, 707 - .check_efuse = true, 708 - .do_toggle = false, 709 - .do_toggle_once = true, 710 - .use_default_parameter = false, 711 - .check_rx_front_end_offset = false, 712 - }; 713 - 714 - static const struct phy_cfg rtd1319d_phy_cfg = { 715 - .param_size = MAX_USB_PHY_DATA_SIZE, 716 - .param = { [1] = {0x01, 0xac89}, 717 - [4] = {0x04, 0xf2f5}, 718 - [6] = {0x06, 0x0017}, 719 - [9] = {0x09, 0x424c}, 720 - [10] = {0x0a, 0x9610}, 721 - [11] = {0x0b, 0x9901}, 722 - [12] = {0x0c, 0xf000}, 723 - [13] = {0x0d, 0xef2a}, 724 - [14] = {0x0e, 0x1000}, 725 - [15] = {0x0f, 0x9050}, 726 - [32] = {0x20, 0x7077}, 727 - [35] = {0x23, 0x0b62}, 728 - [37] = {0x25, 0x10ec}, 729 - [42] = {0x2a, 0x3070}, }, 730 - .check_efuse = true, 731 - .do_toggle = false, 732 - .do_toggle_once = true, 733 - .use_default_parameter = false, 734 - .check_rx_front_end_offset = true, 735 - }; 736 - 737 - static const struct of_device_id usbphy_rtk_dt_match[] = { 738 - { .compatible = "realtek,rtd1295-usb3phy", .data = &rtd1295_phy_cfg }, 739 - { .compatible = "realtek,rtd1319-usb3phy", .data = &rtd1319_phy_cfg }, 740 - { .compatible = "realtek,rtd1319d-usb3phy", .data = &rtd1319d_phy_cfg }, 741 - { .compatible = "realtek,rtd1619-usb3phy", .data = &rtd1619_phy_cfg }, 742 - { .compatible = "realtek,rtd1619b-usb3phy", .data = &rtd1619b_phy_cfg }, 743 - {}, 744 - }; 745 - MODULE_DEVICE_TABLE(of, usbphy_rtk_dt_match); 746 - 747 - static struct platform_driver rtk_usb3phy_driver = { 748 - .probe = rtk_usb3phy_probe, 749 - .remove_new = rtk_usb3phy_remove, 750 - .driver = { 751 - .name = "rtk-usb3phy", 752 - .of_match_table = usbphy_rtk_dt_match, 753 - }, 754 - }; 755 - 756 - module_platform_driver(rtk_usb3phy_driver); 757 - 758 - MODULE_LICENSE("GPL"); 759 - MODULE_ALIAS("platform: rtk-usb3phy"); 760 - MODULE_AUTHOR("Stanley Chang <stanley_chang@realtek.com>"); 761 - MODULE_DESCRIPTION("Realtek usb 3.0 phy driver");

+3 -3

drivers/thunderbolt/switch.c

··· 1143 1143 * Only set bonding if the link was not already bonded. This 1144 1144 * avoids the lane adapter to re-enter bonding state. 1145 1145 */ 1146 - if (width == TB_LINK_WIDTH_SINGLE) { 1146 + if (width == TB_LINK_WIDTH_SINGLE && !tb_is_upstream_port(port)) { 1147 1147 ret = tb_port_set_lane_bonding(port, true); 1148 1148 if (ret) 1149 1149 goto err_lane1; ··· 2880 2880 return tb_port_wait_for_link_width(down, TB_LINK_WIDTH_SINGLE, 100); 2881 2881 } 2882 2882 2883 + /* Note updating sw->link_width done in tb_switch_update_link_attributes() */ 2883 2884 static int tb_switch_asym_enable(struct tb_switch *sw, enum tb_link_width width) 2884 2885 { 2885 2886 struct tb_port *up, *down, *port; ··· 2920 2919 return ret; 2921 2920 } 2922 2921 2923 - sw->link_width = width; 2924 2922 return 0; 2925 2923 } 2926 2924 2925 + /* Note updating sw->link_width done in tb_switch_update_link_attributes() */ 2927 2926 static int tb_switch_asym_disable(struct tb_switch *sw) 2928 2927 { 2929 2928 struct tb_port *up, *down; ··· 2958 2957 return ret; 2959 2958 } 2960 2959 2961 - sw->link_width = TB_LINK_WIDTH_DUAL; 2962 2960 return 0; 2963 2961 } 2964 2962

+11 -1

drivers/thunderbolt/tb.c

··· 213 213 if (!tb_switch_query_dp_resource(sw, port)) 214 214 continue; 215 215 216 - list_add(&port->list, &tcm->dp_resources); 216 + /* 217 + * If DP IN on device router exist, position it at the 218 + * beginning of the DP resources list, so that it is used 219 + * before DP IN of the host router. This way external GPU(s) 220 + * will be prioritized when pairing DP IN to a DP OUT. 221 + */ 222 + if (tb_route(sw)) 223 + list_add(&port->list, &tcm->dp_resources); 224 + else 225 + list_add_tail(&port->list, &tcm->dp_resources); 226 + 217 227 tb_port_dbg(port, "DP IN resource available\n"); 218 228 } 219 229 }

+3

drivers/usb/cdns3/cdnsp-ring.c

··· 1529 1529 unsigned long flags; 1530 1530 int counter = 0; 1531 1531 1532 + local_bh_disable(); 1532 1533 spin_lock_irqsave(&pdev->lock, flags); 1533 1534 1534 1535 if (pdev->cdnsp_state & (CDNSP_STATE_HALTED | CDNSP_STATE_DYING)) { ··· 1542 1541 cdnsp_died(pdev); 1543 1542 1544 1543 spin_unlock_irqrestore(&pdev->lock, flags); 1544 + local_bh_enable(); 1545 1545 return IRQ_HANDLED; 1546 1546 } 1547 1547 ··· 1559 1557 cdnsp_update_erst_dequeue(pdev, event_ring_deq, 1); 1560 1558 1561 1559 spin_unlock_irqrestore(&pdev->lock, flags); 1560 + local_bh_enable(); 1562 1561 1563 1562 return IRQ_HANDLED; 1564 1563 }

+2 -1

drivers/usb/core/config.c

··· 1047 1047 1048 1048 if (cap->bDescriptorType != USB_DT_DEVICE_CAPABILITY) { 1049 1049 dev_notice(ddev, "descriptor type invalid, skip\n"); 1050 - continue; 1050 + goto skip_to_next_descriptor; 1051 1051 } 1052 1052 1053 1053 switch (cap_type) { ··· 1078 1078 break; 1079 1079 } 1080 1080 1081 + skip_to_next_descriptor: 1081 1082 total_len -= length; 1082 1083 buffer += length; 1083 1084 }

-23

drivers/usb/core/hub.c

··· 622 622 ret = 0; 623 623 } 624 624 mutex_unlock(&hub->status_mutex); 625 - 626 - /* 627 - * There is no need to lock status_mutex here, because status_mutex 628 - * protects hub->status, and the phy driver only checks the port 629 - * status without changing the status. 630 - */ 631 - if (!ret) { 632 - struct usb_device *hdev = hub->hdev; 633 - 634 - /* 635 - * Only roothub will be notified of port state changes, 636 - * since the USB PHY only cares about changes at the next 637 - * level. 638 - */ 639 - if (is_root_hub(hdev)) { 640 - struct usb_hcd *hcd = bus_to_hcd(hdev->bus); 641 - 642 - if (hcd->usb_phy) 643 - usb_phy_notify_port_status(hcd->usb_phy, 644 - port1 - 1, *status, *change); 645 - } 646 - } 647 - 648 625 return ret; 649 626 } 650 627

+7 -8

drivers/usb/dwc2/hcd_intr.c

··· 2015 2015 { 2016 2016 struct dwc2_qtd *qtd; 2017 2017 struct dwc2_host_chan *chan; 2018 - u32 hcint, hcintmsk; 2018 + u32 hcint, hcintraw, hcintmsk; 2019 2019 2020 2020 chan = hsotg->hc_ptr_array[chnum]; 2021 2021 2022 - hcint = dwc2_readl(hsotg, HCINT(chnum)); 2022 + hcintraw = dwc2_readl(hsotg, HCINT(chnum)); 2023 2023 hcintmsk = dwc2_readl(hsotg, HCINTMSK(chnum)); 2024 + hcint = hcintraw & hcintmsk; 2025 + dwc2_writel(hsotg, hcint, HCINT(chnum)); 2026 + 2024 2027 if (!chan) { 2025 2028 dev_err(hsotg->dev, "## hc_ptr_array for channel is NULL ##\n"); 2026 - dwc2_writel(hsotg, hcint, HCINT(chnum)); 2027 2029 return; 2028 2030 } 2029 2031 ··· 2034 2032 chnum); 2035 2033 dev_vdbg(hsotg->dev, 2036 2034 " hcint 0x%08x, hcintmsk 0x%08x, hcint&hcintmsk 0x%08x\n", 2037 - hcint, hcintmsk, hcint & hcintmsk); 2035 + hcintraw, hcintmsk, hcint); 2038 2036 } 2039 - 2040 - dwc2_writel(hsotg, hcint, HCINT(chnum)); 2041 2037 2042 2038 /* 2043 2039 * If we got an interrupt after someone called ··· 2046 2046 return; 2047 2047 } 2048 2048 2049 - chan->hcint = hcint; 2050 - hcint &= hcintmsk; 2049 + chan->hcint = hcintraw; 2051 2050 2052 2051 /* 2053 2052 * If the channel was halted due to a dequeue, the qtd list might

+2

drivers/usb/dwc3/core.c

··· 2034 2034 2035 2035 pm_runtime_put(dev); 2036 2036 2037 + dma_set_max_seg_size(dev, UINT_MAX); 2038 + 2037 2039 return 0; 2038 2040 2039 2041 err_exit_debugfs:

+1 -1

drivers/usb/dwc3/drd.c

··· 505 505 dwc->role_switch_default_mode = USB_DR_MODE_PERIPHERAL; 506 506 mode = DWC3_GCTL_PRTCAP_DEVICE; 507 507 } 508 + dwc3_set_mode(dwc, mode); 508 509 509 510 dwc3_role_switch.fwnode = dev_fwnode(dwc->dev); 510 511 dwc3_role_switch.set = dwc3_usb_role_switch_set; ··· 527 526 } 528 527 } 529 528 530 - dwc3_set_mode(dwc, mode); 531 529 return 0; 532 530 } 533 531 #else

+47 -22

drivers/usb/dwc3/dwc3-qcom.c

··· 546 546 pdata ? pdata->hs_phy_irq_index : -1); 547 547 if (irq > 0) { 548 548 /* Keep wakeup interrupts disabled until suspend */ 549 - irq_set_status_flags(irq, IRQ_NOAUTOEN); 550 549 ret = devm_request_threaded_irq(qcom->dev, irq, NULL, 551 550 qcom_dwc3_resume_irq, 552 - IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 551 + IRQF_ONESHOT | IRQF_NO_AUTOEN, 553 552 "qcom_dwc3 HS", qcom); 554 553 if (ret) { 555 554 dev_err(qcom->dev, "hs_phy_irq failed: %d\n", ret); ··· 560 561 irq = dwc3_qcom_get_irq(pdev, "dp_hs_phy_irq", 561 562 pdata ? pdata->dp_hs_phy_irq_index : -1); 562 563 if (irq > 0) { 563 - irq_set_status_flags(irq, IRQ_NOAUTOEN); 564 564 ret = devm_request_threaded_irq(qcom->dev, irq, NULL, 565 565 qcom_dwc3_resume_irq, 566 - IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 566 + IRQF_ONESHOT | IRQF_NO_AUTOEN, 567 567 "qcom_dwc3 DP_HS", qcom); 568 568 if (ret) { 569 569 dev_err(qcom->dev, "dp_hs_phy_irq failed: %d\n", ret); ··· 574 576 irq = dwc3_qcom_get_irq(pdev, "dm_hs_phy_irq", 575 577 pdata ? pdata->dm_hs_phy_irq_index : -1); 576 578 if (irq > 0) { 577 - irq_set_status_flags(irq, IRQ_NOAUTOEN); 578 579 ret = devm_request_threaded_irq(qcom->dev, irq, NULL, 579 580 qcom_dwc3_resume_irq, 580 - IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 581 + IRQF_ONESHOT | IRQF_NO_AUTOEN, 581 582 "qcom_dwc3 DM_HS", qcom); 582 583 if (ret) { 583 584 dev_err(qcom->dev, "dm_hs_phy_irq failed: %d\n", ret); ··· 588 591 irq = dwc3_qcom_get_irq(pdev, "ss_phy_irq", 589 592 pdata ? pdata->ss_phy_irq_index : -1); 590 593 if (irq > 0) { 591 - irq_set_status_flags(irq, IRQ_NOAUTOEN); 592 594 ret = devm_request_threaded_irq(qcom->dev, irq, NULL, 593 595 qcom_dwc3_resume_irq, 594 - IRQF_TRIGGER_HIGH | IRQF_ONESHOT, 596 + IRQF_ONESHOT | IRQF_NO_AUTOEN, 595 597 "qcom_dwc3 SS", qcom); 596 598 if (ret) { 597 599 dev_err(qcom->dev, "ss_phy_irq failed: %d\n", ret); ··· 754 758 if (!qcom->dwc3) { 755 759 ret = -ENODEV; 756 760 dev_err(dev, "failed to get dwc3 platform device\n"); 761 + of_platform_depopulate(dev); 757 762 } 758 763 759 764 node_put: ··· 763 766 return ret; 764 767 } 765 768 766 - static struct platform_device * 767 - dwc3_qcom_create_urs_usb_platdev(struct device *dev) 769 + static struct platform_device *dwc3_qcom_create_urs_usb_platdev(struct device *dev) 768 770 { 771 + struct platform_device *urs_usb = NULL; 769 772 struct fwnode_handle *fwh; 770 773 struct acpi_device *adev; 771 774 char name[8]; ··· 785 788 786 789 adev = to_acpi_device_node(fwh); 787 790 if (!adev) 788 - return NULL; 791 + goto err_put_handle; 789 792 790 - return acpi_create_platform_device(adev, NULL); 793 + urs_usb = acpi_create_platform_device(adev, NULL); 794 + if (IS_ERR_OR_NULL(urs_usb)) 795 + goto err_put_handle; 796 + 797 + return urs_usb; 798 + 799 + err_put_handle: 800 + fwnode_handle_put(fwh); 801 + 802 + return urs_usb; 803 + } 804 + 805 + static void dwc3_qcom_destroy_urs_usb_platdev(struct platform_device *urs_usb) 806 + { 807 + struct fwnode_handle *fwh = urs_usb->dev.fwnode; 808 + 809 + platform_device_unregister(urs_usb); 810 + fwnode_handle_put(fwh); 791 811 } 792 812 793 813 static int dwc3_qcom_probe(struct platform_device *pdev) ··· 888 874 qcom->qscratch_base = devm_ioremap_resource(dev, parent_res); 889 875 if (IS_ERR(qcom->qscratch_base)) { 890 876 ret = PTR_ERR(qcom->qscratch_base); 891 - goto clk_disable; 877 + goto free_urs; 892 878 } 893 879 894 880 ret = dwc3_qcom_setup_irq(pdev); 895 881 if (ret) { 896 882 dev_err(dev, "failed to setup IRQs, err=%d\n", ret); 897 - goto clk_disable; 883 + goto free_urs; 898 884 } 899 885 900 886 /* ··· 913 899 914 900 if (ret) { 915 901 dev_err(dev, "failed to register DWC3 Core, err=%d\n", ret); 916 - goto depopulate; 902 + goto free_urs; 917 903 } 918 904 919 905 ret = dwc3_qcom_interconnect_init(qcom); ··· 945 931 interconnect_exit: 946 932 dwc3_qcom_interconnect_exit(qcom); 947 933 depopulate: 948 - if (np) 934 + if (np) { 949 935 of_platform_depopulate(&pdev->dev); 950 - else 951 - platform_device_put(pdev); 936 + } else { 937 + device_remove_software_node(&qcom->dwc3->dev); 938 + platform_device_del(qcom->dwc3); 939 + } 940 + platform_device_put(qcom->dwc3); 941 + free_urs: 942 + if (qcom->urs_usb) 943 + dwc3_qcom_destroy_urs_usb_platdev(qcom->urs_usb); 952 944 clk_disable: 953 945 for (i = qcom->num_clocks - 1; i >= 0; i--) { 954 946 clk_disable_unprepare(qcom->clks[i]); ··· 973 953 struct device *dev = &pdev->dev; 974 954 int i; 975 955 976 - device_remove_software_node(&qcom->dwc3->dev); 977 - if (np) 956 + if (np) { 978 957 of_platform_depopulate(&pdev->dev); 979 - else 980 - platform_device_put(pdev); 958 + } else { 959 + device_remove_software_node(&qcom->dwc3->dev); 960 + platform_device_del(qcom->dwc3); 961 + } 962 + platform_device_put(qcom->dwc3); 963 + 964 + if (qcom->urs_usb) 965 + dwc3_qcom_destroy_urs_usb_platdev(qcom->urs_usb); 981 966 982 967 for (i = qcom->num_clocks - 1; i >= 0; i--) { 983 968 clk_disable_unprepare(qcom->clks[i]);

+7 -1

drivers/usb/dwc3/dwc3-rtk.c

··· 183 183 184 184 ret = of_property_read_string(dwc3_np, "maximum-speed", &maximum_speed); 185 185 if (ret < 0) 186 - return USB_SPEED_UNKNOWN; 186 + goto out; 187 187 188 188 ret = match_string(speed_names, ARRAY_SIZE(speed_names), maximum_speed); 189 + 190 + out: 191 + of_node_put(dwc3_np); 189 192 190 193 return (ret < 0) ? USB_SPEED_UNKNOWN : ret; 191 194 } ··· 341 338 } 342 339 343 340 switch_usb2_role(rtk, rtk->cur_role); 341 + 342 + platform_device_put(dwc3_pdev); 343 + of_node_put(dwc3_node); 344 344 345 345 return 0; 346 346

+10 -3

drivers/usb/host/xhci-mtk-sch.c

··· 650 650 651 651 if (sch_ep->ep_type == ISOC_OUT_EP) { 652 652 for (j = 0; j < sch_ep->num_budget_microframes; j++) { 653 - k = XHCI_MTK_BW_INDEX(base + j + CS_OFFSET); 654 - /* use cs to indicate existence of in-ss @(base+j) */ 655 - if (tt->fs_bus_bw_in[k]) 653 + k = XHCI_MTK_BW_INDEX(base + j); 654 + if (tt->in_ss_cnt[k]) 656 655 return -ESCH_SS_OVERLAP; 657 656 } 658 657 } else if (sch_ep->ep_type == ISOC_IN_EP || sch_ep->ep_type == INT_IN_EP) { ··· 767 768 fs_bus_bw[k] -= (u16)sch_ep->bw_budget_table[j]; 768 769 tt->fs_frame_bw[f] -= (u16)sch_ep->bw_budget_table[j]; 769 770 } 771 + } 772 + 773 + if (sch_ep->ep_type == ISOC_IN_EP || sch_ep->ep_type == INT_IN_EP) { 774 + k = XHCI_MTK_BW_INDEX(base); 775 + if (used) 776 + tt->in_ss_cnt[k]++; 777 + else 778 + tt->in_ss_cnt[k]--; 770 779 } 771 780 } 772 781

+2

drivers/usb/host/xhci-mtk.h

··· 38 38 * @fs_bus_bw_in: save bandwidth used by FS/LS IN eps in each uframes 39 39 * @ls_bus_bw: save bandwidth used by LS eps in each uframes 40 40 * @fs_frame_bw: save bandwidth used by FS/LS eps in each FS frames 41 + * @in_ss_cnt: the count of Start-Split for IN eps 41 42 * @ep_list: Endpoints using this TT 42 43 */ 43 44 struct mu3h_sch_tt { ··· 46 45 u16 fs_bus_bw_in[XHCI_MTK_MAX_ESIT]; 47 46 u8 ls_bus_bw[XHCI_MTK_MAX_ESIT]; 48 47 u16 fs_frame_bw[XHCI_MTK_FRAMES_CNT]; 48 + u8 in_ss_cnt[XHCI_MTK_MAX_ESIT]; 49 49 struct list_head ep_list; 50 50 }; 51 51

+30 -20

drivers/usb/host/xhci-plat.c

··· 13 13 #include <linux/module.h> 14 14 #include <linux/pci.h> 15 15 #include <linux/of.h> 16 + #include <linux/of_device.h> 16 17 #include <linux/platform_device.h> 17 18 #include <linux/usb/phy.h> 18 19 #include <linux/slab.h> ··· 149 148 int ret; 150 149 int irq; 151 150 struct xhci_plat_priv *priv = NULL; 152 - 151 + bool of_match; 153 152 154 153 if (usb_disabled()) 155 154 return -ENODEV; ··· 254 253 &xhci->imod_interval); 255 254 } 256 255 257 - hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0); 258 - if (IS_ERR(hcd->usb_phy)) { 259 - ret = PTR_ERR(hcd->usb_phy); 260 - if (ret == -EPROBE_DEFER) 261 - goto disable_clk; 262 - hcd->usb_phy = NULL; 263 - } else { 264 - ret = usb_phy_init(hcd->usb_phy); 265 - if (ret) 266 - goto disable_clk; 256 + /* 257 + * Drivers such as dwc3 manages PHYs themself (and rely on driver name 258 + * matching for the xhci platform device). 259 + */ 260 + of_match = of_match_device(pdev->dev.driver->of_match_table, &pdev->dev); 261 + if (of_match) { 262 + hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0); 263 + if (IS_ERR(hcd->usb_phy)) { 264 + ret = PTR_ERR(hcd->usb_phy); 265 + if (ret == -EPROBE_DEFER) 266 + goto disable_clk; 267 + hcd->usb_phy = NULL; 268 + } else { 269 + ret = usb_phy_init(hcd->usb_phy); 270 + if (ret) 271 + goto disable_clk; 272 + } 267 273 } 268 274 269 275 hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node); ··· 293 285 goto dealloc_usb2_hcd; 294 286 } 295 287 296 - xhci->shared_hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, 297 - "usb-phy", 1); 298 - if (IS_ERR(xhci->shared_hcd->usb_phy)) { 299 - xhci->shared_hcd->usb_phy = NULL; 300 - } else { 301 - ret = usb_phy_init(xhci->shared_hcd->usb_phy); 302 - if (ret) 303 - dev_err(sysdev, "%s init usb3phy fail (ret=%d)\n", 304 - __func__, ret); 288 + if (of_match) { 289 + xhci->shared_hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, 290 + "usb-phy", 1); 291 + if (IS_ERR(xhci->shared_hcd->usb_phy)) { 292 + xhci->shared_hcd->usb_phy = NULL; 293 + } else { 294 + ret = usb_phy_init(xhci->shared_hcd->usb_phy); 295 + if (ret) 296 + dev_err(sysdev, "%s init usb3phy fail (ret=%d)\n", 297 + __func__, ret); 298 + } 305 299 } 306 300 307 301 xhci->shared_hcd->tpl_support = hcd->tpl_support;

+2

drivers/usb/misc/onboard_usb_hub.c

··· 432 432 { USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2412) }, /* USB2412 USB 2.0 */ 433 433 { USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2514) }, /* USB2514B USB 2.0 */ 434 434 { USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2517) }, /* USB2517 USB 2.0 */ 435 + { USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2744) }, /* USB5744 USB 2.0 */ 436 + { USB_DEVICE(VENDOR_ID_MICROCHIP, 0x5744) }, /* USB5744 USB 3.0 */ 435 437 { USB_DEVICE(VENDOR_ID_REALTEK, 0x0411) }, /* RTS5411 USB 3.1 */ 436 438 { USB_DEVICE(VENDOR_ID_REALTEK, 0x5411) }, /* RTS5411 USB 2.1 */ 437 439 { USB_DEVICE(VENDOR_ID_REALTEK, 0x0414) }, /* RTS5414 USB 3.2 */

+7

drivers/usb/misc/onboard_usb_hub.h

··· 16 16 .num_supplies = 1, 17 17 }; 18 18 19 + static const struct onboard_hub_pdata microchip_usb5744_data = { 20 + .reset_us = 0, 21 + .num_supplies = 2, 22 + }; 23 + 19 24 static const struct onboard_hub_pdata realtek_rts5411_data = { 20 25 .reset_us = 0, 21 26 .num_supplies = 1, ··· 55 50 { .compatible = "usb424,2412", .data = &microchip_usb424_data, }, 56 51 { .compatible = "usb424,2514", .data = &microchip_usb424_data, }, 57 52 { .compatible = "usb424,2517", .data = &microchip_usb424_data, }, 53 + { .compatible = "usb424,2744", .data = &microchip_usb5744_data, }, 54 + { .compatible = "usb424,5744", .data = &microchip_usb5744_data, }, 58 55 { .compatible = "usb451,8140", .data = &ti_tusb8041_data, }, 59 56 { .compatible = "usb451,8142", .data = &ti_tusb8041_data, }, 60 57 { .compatible = "usb4b4,6504", .data = &cypress_hx3_data, },

+4 -13

drivers/usb/misc/usb-ljca.c

··· 457 457 u64 adr, u8 id) 458 458 { 459 459 struct ljca_match_ids_walk_data wd = { 0 }; 460 - struct acpi_device *parent, *adev; 461 460 struct device *dev = adap->dev; 461 + struct acpi_device *parent; 462 462 char uid[4]; 463 463 464 464 parent = ACPI_COMPANION(dev); ··· 466 466 return; 467 467 468 468 /* 469 - * get auxdev ACPI handle from the ACPI device directly 470 - * under the parent that matches _ADR. 471 - */ 472 - adev = acpi_find_child_device(parent, adr, false); 473 - if (adev) { 474 - ACPI_COMPANION_SET(&auxdev->dev, adev); 475 - return; 476 - } 477 - 478 - /* 479 - * _ADR is a grey area in the ACPI specification, some 469 + * Currently LJCA hw doesn't use _ADR instead the shipped 480 470 * platforms use _HID to distinguish children devices. 481 471 */ 482 472 switch (adr) { ··· 646 656 unsigned int i; 647 657 int ret; 648 658 659 + /* Not all LJCA chips implement SPI, a timeout reading the descriptors is normal */ 649 660 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_SPI, NULL, 0, buf, 650 661 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS); 651 662 if (ret < 0) 652 - return ret; 663 + return (ret == -ETIMEDOUT) ? 0 : ret; 653 664 654 665 /* check firmware response */ 655 666 desc = (struct ljca_spi_descriptor *)buf;

+8 -3

drivers/usb/serial/option.c

··· 203 203 #define DELL_PRODUCT_5829E_ESIM 0x81e4 204 204 #define DELL_PRODUCT_5829E 0x81e6 205 205 206 - #define DELL_PRODUCT_FM101R 0x8213 207 - #define DELL_PRODUCT_FM101R_ESIM 0x8215 206 + #define DELL_PRODUCT_FM101R_ESIM 0x8213 207 + #define DELL_PRODUCT_FM101R 0x8215 208 208 209 209 #define KYOCERA_VENDOR_ID 0x0c88 210 210 #define KYOCERA_PRODUCT_KPC650 0x17da ··· 609 609 #define UNISOC_VENDOR_ID 0x1782 610 610 /* TOZED LT70-C based on UNISOC SL8563 uses UNISOC's vendor ID */ 611 611 #define TOZED_PRODUCT_LT70C 0x4055 612 + /* Luat Air72*U series based on UNISOC UIS8910 uses UNISOC's vendor ID */ 613 + #define LUAT_PRODUCT_AIR720U 0x4e00 612 614 613 615 /* Device flags */ 614 616 ··· 1548 1546 { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0165, 0xff, 0xff, 0xff) }, 1549 1547 { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0167, 0xff, 0xff, 0xff), 1550 1548 .driver_info = RSVD(4) }, 1551 - { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0189, 0xff, 0xff, 0xff) }, 1549 + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0189, 0xff, 0xff, 0xff), 1550 + .driver_info = RSVD(4) }, 1552 1551 { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0191, 0xff, 0xff, 0xff), /* ZTE EuFi890 */ 1553 1552 .driver_info = RSVD(4) }, 1554 1553 { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0196, 0xff, 0xff, 0xff) }, ··· 2252 2249 .driver_info = RSVD(4) | RSVD(5) | RSVD(6) }, 2253 2250 { USB_DEVICE(0x1782, 0x4d10) }, /* Fibocom L610 (AT mode) */ 2254 2251 { USB_DEVICE_INTERFACE_CLASS(0x1782, 0x4d11, 0xff) }, /* Fibocom L610 (ECM/RNDIS mode) */ 2252 + { USB_DEVICE_AND_INTERFACE_INFO(0x2cb7, 0x0001, 0xff, 0xff, 0xff) }, /* Fibocom L716-EU (ECM/RNDIS mode) */ 2255 2253 { USB_DEVICE(0x2cb7, 0x0104), /* Fibocom NL678 series */ 2256 2254 .driver_info = RSVD(4) | RSVD(5) }, 2257 2255 { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x0105, 0xff), /* Fibocom NL678 series */ ··· 2275 2271 { USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9191, 0xff, 0xff, 0x40) }, 2276 2272 { USB_DEVICE_AND_INTERFACE_INFO(SIERRA_VENDOR_ID, SIERRA_PRODUCT_EM9191, 0xff, 0, 0) }, 2277 2273 { USB_DEVICE_AND_INTERFACE_INFO(UNISOC_VENDOR_ID, TOZED_PRODUCT_LT70C, 0xff, 0, 0) }, 2274 + { USB_DEVICE_AND_INTERFACE_INFO(UNISOC_VENDOR_ID, LUAT_PRODUCT_AIR720U, 0xff, 0, 0) }, 2278 2275 { } /* Terminating entry */ 2279 2276 }; 2280 2277 MODULE_DEVICE_TABLE(usb, option_ids);

+11 -1

drivers/usb/typec/tcpm/tcpm.c

··· 4273 4273 current_lim = PD_P_SNK_STDBY_MW / 5; 4274 4274 tcpm_set_current_limit(port, current_lim, 5000); 4275 4275 /* Not sink vbus if operational current is 0mA */ 4276 - tcpm_set_charge(port, !!pdo_max_current(port->snk_pdo[0])); 4276 + tcpm_set_charge(port, !port->pd_supported || 4277 + pdo_max_current(port->snk_pdo[0])); 4277 4278 4278 4279 if (!port->pd_supported) 4279 4280 tcpm_set_state(port, SNK_READY, 0); ··· 5391 5390 tcpm_log_force(port, "Received hard reset"); 5392 5391 if (port->bist_request == BDO_MODE_TESTDATA && port->tcpc->set_bist_data) 5393 5392 port->tcpc->set_bist_data(port->tcpc, false); 5393 + 5394 + switch (port->state) { 5395 + case ERROR_RECOVERY: 5396 + case PORT_RESET: 5397 + case PORT_RESET_WAIT_OFF: 5398 + return; 5399 + default: 5400 + break; 5401 + } 5394 5402 5395 5403 if (port->ams != NONE_AMS) 5396 5404 port->ams = NONE_AMS;

+9 -5

drivers/usb/typec/tipd/core.c

··· 968 968 ret = of_property_match_string(np, "reg-names", "patch-address"); 969 969 if (ret < 0) { 970 970 dev_err(tps->dev, "failed to get patch-address %d\n", ret); 971 - return ret; 971 + goto release_fw; 972 972 } 973 973 974 974 ret = of_property_read_u32_index(np, "reg", ret, &addr); 975 975 if (ret) 976 - return ret; 976 + goto release_fw; 977 977 978 978 if (addr == 0 || (addr >= 0x20 && addr <= 0x23)) { 979 979 dev_err(tps->dev, "wrong patch address %u\n", addr); 980 - return -EINVAL; 980 + ret = -EINVAL; 981 + goto release_fw; 981 982 } 982 983 983 984 bpms_data.addr = (u8)addr; ··· 1227 1226 TPS_REG_INT_PLUG_EVENT; 1228 1227 } 1229 1228 1230 - tps->data = device_get_match_data(tps->dev); 1229 + if (dev_fwnode(tps->dev)) 1230 + tps->data = device_get_match_data(tps->dev); 1231 + else 1232 + tps->data = i2c_get_match_data(client); 1231 1233 if (!tps->data) 1232 1234 return -EINVAL; 1233 1235 ··· 1429 1425 MODULE_DEVICE_TABLE(of, tps6598x_of_match); 1430 1426 1431 1427 static const struct i2c_device_id tps6598x_id[] = { 1432 - { "tps6598x" }, 1428 + { "tps6598x", (kernel_ulong_t)&tps6598x_data }, 1433 1429 { } 1434 1430 }; 1435 1431 MODULE_DEVICE_TABLE(i2c, tps6598x_id);

-13

include/linux/usb/phy.h

··· 144 144 */ 145 145 int (*set_wakeup)(struct usb_phy *x, bool enabled); 146 146 147 - /* notify phy port status change */ 148 - int (*notify_port_status)(struct usb_phy *x, int port, 149 - u16 portstatus, u16 portchange); 150 - 151 147 /* notify phy connect status change */ 152 148 int (*notify_connect)(struct usb_phy *x, 153 149 enum usb_device_speed speed); ··· 312 316 { 313 317 if (x && x->set_wakeup) 314 318 return x->set_wakeup(x, enabled); 315 - else 316 - return 0; 317 - } 318 - 319 - static inline int 320 - usb_phy_notify_port_status(struct usb_phy *x, int port, u16 portstatus, u16 portchange) 321 - { 322 - if (x && x->notify_port_status) 323 - return x->notify_port_status(x, port, portstatus, portchange); 324 319 else 325 320 return 0; 326 321 }

Configure Feed

Configure Feed