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_device.h>
12 #include <linux/of_address.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 */
page_addr_to_array_index(u8 addr)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
array_index_to_page_addr(int index)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
utmi_wait_register(void __iomem * reg,u32 mask,u32 result)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
rtk_phy_read(struct phy_reg * phy_reg,char addr)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
rtk_phy_write(struct phy_reg * phy_reg,char addr,char data)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
rtk_phy_set_page(struct phy_reg * phy_reg,int page)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
__updated_dc_disconnect_level_page0_0xe4(struct phy_cfg * phy_cfg,struct phy_parameter * phy_parameter,u8 data)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 */
update_dc_disconnect_level_at_page0(struct rtk_phy * rtk_phy,struct phy_parameter * phy_parameter,bool update)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
__updated_dc_disconnect_level_page1_0xe2(struct phy_cfg * phy_cfg,struct phy_parameter * phy_parameter,u8 data)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 */
update_dc_disconnect_level_at_page1(struct rtk_phy * rtk_phy,struct phy_parameter * phy_parameter,bool update)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
update_dc_disconnect_level(struct rtk_phy * rtk_phy,struct phy_parameter * phy_parameter,bool update)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
__update_dc_driving_page0_0xe4(struct phy_cfg * phy_cfg,struct phy_parameter * phy_parameter,u8 data)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
update_dc_driving_level(struct rtk_phy * rtk_phy,struct phy_parameter * phy_parameter)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
update_hs_clk_select(struct rtk_phy * rtk_phy,struct phy_parameter * phy_parameter)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
do_rtk_phy_toggle(struct rtk_phy * rtk_phy,int index,bool connect)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
do_rtk_phy_init(struct rtk_phy * rtk_phy,int index)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
rtk_phy_init(struct phy * phy)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
rtk_phy_exit(struct phy * phy)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
rtk_phy_toggle(struct usb_phy * usb2_phy,bool connect,int port)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
rtk_phy_notify_port_status(struct usb_phy * x,int port,u16 portstatus,u16 portchange)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
create_phy_debug_root(void)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
rtk_usb2_parameter_show(struct seq_file * s,void * unused)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
create_debug_files(struct rtk_phy * rtk_phy)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
remove_debug_files(struct rtk_phy * rtk_phy)863 static inline void remove_debug_files(struct rtk_phy *rtk_phy)
864 {
865 debugfs_remove_recursive(rtk_phy->debug_dir);
866 }
867 #else
create_debug_files(struct rtk_phy * rtk_phy)868 static inline void create_debug_files(struct rtk_phy *rtk_phy) { }
remove_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
get_phy_data_by_efuse(struct rtk_phy * rtk_phy,struct phy_parameter * phy_parameter,int index)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
parse_phy_data(struct rtk_phy * rtk_phy)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
rtk_usb2phy_probe(struct platform_device * pdev)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
rtk_usb2phy_remove(struct platform_device * pdev)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");
1326