2 #include "usbdev_grf_regs.h"
3 #include "dwc_otg_regs.h"
4 static struct dwc_otg_control_usb *control_usb;
6 #ifdef CONFIG_USB20_OTG
7 static void usb20otg_hw_init(void)
9 /* Turn off differential receiver in suspend mode */
10 writel(UOC_HIWORD_UPDATE(0, 1, 2),
11 RK_GRF_VIRT + RK312X_GRF_USBPHY0_CON6);
12 /* Set disconnect detection trigger point to 600mv */
13 writel(UOC_HIWORD_UPDATE(1, 0xf, 11),
14 RK_GRF_VIRT + RK312X_GRF_USBPHY0_CON7);
15 /* other haredware init,include:
16 * DRV_VBUS GPIO init */
17 if (gpio_is_valid(control_usb->otg_gpios->gpio)) {
18 if (gpio_get_value(control_usb->otg_gpios->gpio))
19 gpio_set_value(control_usb->otg_gpios->gpio, 0);
23 static void usb20otg_phy_suspend(void *pdata, int suspend)
25 struct dwc_otg_platform_data *usbpdata = pdata;
27 /* enable soft control */
28 writel(UOC_HIWORD_UPDATE(0x55, 0x7f, 0),
29 RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
30 usbpdata->phy_status = 1;
33 writel(UOC_HIWORD_UPDATE(0x0, 0x1, 0),
34 RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
35 usbpdata->phy_status = 0;
39 static void usb20otg_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
41 struct dwc_otg_platform_data *usbpdata = pdata;
42 struct reset_control *rst_otg_h, *rst_otg_p, *rst_otg_c;
44 rst_otg_h = devm_reset_control_get(usbpdata->dev, "otg_ahb");
45 rst_otg_p = devm_reset_control_get(usbpdata->dev, "otg_phy");
46 rst_otg_c = devm_reset_control_get(usbpdata->dev, "otg_controller");
47 if (IS_ERR(rst_otg_h) || IS_ERR(rst_otg_p) || IS_ERR(rst_otg_c)) {
48 dev_err(usbpdata->dev, "Fail to get reset control from dts\n");
55 writel(UOC_HIWORD_UPDATE(0x1, 0x3, 0),
56 RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
57 reset_control_assert(rst_otg_p);
59 writel(UOC_HIWORD_UPDATE(0x2, 0x3, 0),
60 RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
62 reset_control_deassert(rst_otg_p);
65 /* Controller reset */
66 reset_control_assert(rst_otg_c);
67 reset_control_assert(rst_otg_h);
71 reset_control_deassert(rst_otg_c);
72 reset_control_deassert(rst_otg_h);
80 static void usb20otg_clock_init(void *pdata)
82 struct dwc_otg_platform_data *usbpdata = pdata;
83 struct clk *ahbclk, *phyclk;
85 ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb0");
87 dev_err(usbpdata->dev, "Failed to get hclk_usb0\n");
91 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy0");
93 dev_err(usbpdata->dev, "Failed to get clk_usbphy0\n");
97 usbpdata->phyclk = phyclk;
98 usbpdata->ahbclk = ahbclk;
101 static void usb20otg_clock_enable(void *pdata, int enable)
103 struct dwc_otg_platform_data *usbpdata = pdata;
106 clk_prepare_enable(usbpdata->ahbclk);
107 clk_prepare_enable(usbpdata->phyclk);
109 clk_disable_unprepare(usbpdata->ahbclk);
111 clk_disable_unprepare(usbpdata->phyclk);
116 static int usb20otg_get_status(int id)
119 u32 soc_status0 = readl(RK_GRF_VIRT + RK312X_GRF_SOC_STATUS0);
121 case USB_STATUS_BVABLID:
123 ret = soc_status0 & (0x1 << 5);
125 case USB_STATUS_DPDM:
127 ret = soc_status0 & (0x3 << 6);
131 ret = soc_status0 & (0x1 << 8);
133 case USB_STATUS_UARTMODE:
134 ret = readl(RK_GRF_VIRT + RK312X_GRF_UOC1_CON4) & (1 << 12);
137 ret = control_usb->chip_id;
139 case USB_REMOTE_WAKEUP:
140 ret = control_usb->remote_wakeup;
143 ret = control_usb->usb_irq_wakeup;
151 #ifdef CONFIG_RK_USB_UART
153 * dwc_otg_uart_enabled - check if a usb-uart bypass func is enabled in DT
155 * Returns true if the status property of node "usb_uart" is set to "okay"
156 * or "ok", if this property is absent it will use the default status "ok"
159 static bool dwc_otg_uart_enabled(void)
161 struct device_node *np;
163 np = of_find_node_by_name(NULL, "usb_uart");
164 if (np && of_device_is_available(np))
170 static void dwc_otg_uart_mode(void *pdata, int enter_usb_uart_mode)
172 if ((1 == enter_usb_uart_mode) && dwc_otg_uart_enabled()) {
173 /* bypass dm, enter uart mode */
174 writel(UOC_HIWORD_UPDATE(0x3, 0x3, 12), RK_GRF_VIRT +
175 RK312X_GRF_UOC1_CON4);
177 } else if (0 == enter_usb_uart_mode) {
179 writel(UOC_HIWORD_UPDATE(0x0, 0x3, 12), RK_GRF_VIRT +
180 RK312X_GRF_UOC1_CON4);
184 static void dwc_otg_uart_mode(void *pdata, int enter_usb_uart_mode)
189 static void usb20otg_power_enable(int enable)
192 /* disable otg_drv power */
193 if (gpio_is_valid(control_usb->otg_gpios->gpio))
194 gpio_set_value(control_usb->otg_gpios->gpio, 0);
195 } else if (1 == enable) {
196 /* enable otg_drv power */
197 if (gpio_is_valid(control_usb->otg_gpios->gpio))
198 gpio_set_value(control_usb->otg_gpios->gpio, 1);
202 struct dwc_otg_platform_data usb20otg_pdata_rk3126 = {
207 .hw_init = usb20otg_hw_init,
208 .phy_suspend = usb20otg_phy_suspend,
209 .soft_reset = usb20otg_soft_reset,
210 .clock_init = usb20otg_clock_init,
211 .clock_enable = usb20otg_clock_enable,
212 .get_status = usb20otg_get_status,
213 .power_enable = usb20otg_power_enable,
214 .dwc_otg_uart_mode = dwc_otg_uart_mode,
215 .bc_detect_cb = rk_battery_charger_detect_cb,
219 #if defined(CONFIG_USB20_HOST) || defined(CONFIG_USB_EHCI_RK)
220 static void usb20host_hw_init(void)
222 /* Turn off differential receiver in suspend mode */
223 writel(UOC_HIWORD_UPDATE(0, 1, 2),
224 RK_GRF_VIRT + RK312X_GRF_USBPHY1_CON6);
225 /* Set disconnect detection trigger point to 600mv */
226 writel(UOC_HIWORD_UPDATE(1, 0xf, 11),
227 RK_GRF_VIRT + RK312X_GRF_USBPHY1_CON7);
228 /* other haredware init,include:
229 * DRV_VBUS GPIO init */
230 if (gpio_is_valid(control_usb->host_gpios->gpio)) {
231 if (!gpio_get_value(control_usb->host_gpios->gpio))
232 gpio_set_value(control_usb->host_gpios->gpio, 1);
236 static void usb20host_phy_suspend(void *pdata, int suspend)
238 struct dwc_otg_platform_data *usbpdata = pdata;
241 /* enable soft control */
242 writel(UOC_HIWORD_UPDATE(0x1d5, 0x1ff, 0),
243 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
244 usbpdata->phy_status = 1;
247 writel(UOC_HIWORD_UPDATE(0x0, 0x1, 0),
248 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
249 usbpdata->phy_status = 0;
253 static void usb20host_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
255 struct dwc_otg_platform_data *usbpdata = pdata;
256 struct reset_control *rst_host_h, *rst_host_p, *rst_host_c;
258 rst_host_h = devm_reset_control_get(usbpdata->dev, "host_ahb");
259 rst_host_p = devm_reset_control_get(usbpdata->dev, "host_phy");
260 rst_host_c = devm_reset_control_get(usbpdata->dev, "host_controller");
261 if (IS_ERR(rst_host_h) || IS_ERR(rst_host_p) || IS_ERR(rst_host_c)) {
262 dev_err(usbpdata->dev, "Fail to get reset control from dts\n");
269 writel(UOC_HIWORD_UPDATE(0x1, 0x3, 0),
270 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
271 reset_control_assert(rst_host_p);
273 writel(UOC_HIWORD_UPDATE(0x2, 0x3, 0),
274 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
277 reset_control_deassert(rst_host_p);
279 /* Controller reset */
280 reset_control_assert(rst_host_c);
281 reset_control_assert(rst_host_h);
285 reset_control_deassert(rst_host_c);
286 reset_control_deassert(rst_host_h);
294 static void usb20host_clock_init(void *pdata)
296 struct dwc_otg_platform_data *usbpdata = pdata;
297 struct clk *ahbclk, *phyclk;
299 ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb1");
300 if (IS_ERR(ahbclk)) {
301 dev_err(usbpdata->dev, "Failed to get hclk_usb1\n");
305 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy1");
306 if (IS_ERR(phyclk)) {
307 dev_err(usbpdata->dev, "Failed to get clk_usbphy1\n");
311 usbpdata->phyclk = phyclk;
312 usbpdata->ahbclk = ahbclk;
315 static void usb20host_clock_enable(void *pdata, int enable)
317 struct dwc_otg_platform_data *usbpdata = pdata;
320 clk_prepare_enable(usbpdata->ahbclk);
321 clk_prepare_enable(usbpdata->phyclk);
323 clk_disable_unprepare(usbpdata->ahbclk);
324 clk_disable_unprepare(usbpdata->phyclk);
328 static int usb20host_get_status(int id)
331 u32 soc_status0 = readl(RK_GRF_VIRT + RK312X_GRF_SOC_STATUS0);
334 case USB_STATUS_BVABLID:
336 ret = soc_status0 & (0x1 << 10);
338 case USB_STATUS_DPDM:
340 ret = soc_status0 & (0x3 << 11);
347 ret = control_usb->chip_id;
349 case USB_REMOTE_WAKEUP:
350 ret = control_usb->remote_wakeup;
353 ret = control_usb->usb_irq_wakeup;
361 static void usb20host_power_enable(int enable)
364 /* disable host_drv power */
365 /* do not disable power in default */
366 } else if (1 == enable) {
367 /* enable host_drv power */
368 if (gpio_is_valid(control_usb->host_gpios->gpio))
369 gpio_set_value(control_usb->host_gpios->gpio, 1);
373 struct dwc_otg_platform_data usb20host_pdata_rk3126 = {
378 .hw_init = usb20host_hw_init,
379 .phy_suspend = usb20host_phy_suspend,
380 .soft_reset = usb20host_soft_reset,
381 .clock_init = usb20host_clock_init,
382 .clock_enable = usb20host_clock_enable,
383 .get_status = usb20host_get_status,
384 .power_enable = usb20host_power_enable,
388 #ifdef CONFIG_USB_EHCI_RK
389 static void usb20ehci_phy_suspend(void *pdata, int suspend)
391 struct rkehci_platform_data *usbpdata = pdata;
394 /* enable soft control */
395 writel(UOC_HIWORD_UPDATE(0x1d5, 0x1ff, 0),
396 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
397 usbpdata->phy_status = 1;
400 writel(UOC_HIWORD_UPDATE(0x0, 0x1, 0),
401 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
402 usbpdata->phy_status = 0;
406 static void usb20ehci_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
408 struct rkehci_platform_data *usbpdata = pdata;
409 struct reset_control *rst_host_h, *rst_host_p, *rst_host_c;
411 rst_host_h = devm_reset_control_get(usbpdata->dev, "host_ahb");
412 rst_host_p = devm_reset_control_get(usbpdata->dev, "host_phy");
413 rst_host_c = devm_reset_control_get(usbpdata->dev, "host_controller");
414 if (IS_ERR(rst_host_h) || IS_ERR(rst_host_p) || IS_ERR(rst_host_c)) {
415 dev_err(usbpdata->dev, "Fail to get reset control from dts\n");
422 writel(UOC_HIWORD_UPDATE(0x1, 0x3, 0),
423 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
424 reset_control_assert(rst_host_p);
426 writel(UOC_HIWORD_UPDATE(0x2, 0x3, 0),
427 RK_GRF_VIRT + RK312X_GRF_UOC1_CON5);
430 reset_control_deassert(rst_host_p);
432 /* Controller reset */
433 reset_control_assert(rst_host_c);
434 reset_control_assert(rst_host_h);
438 reset_control_deassert(rst_host_c);
439 reset_control_deassert(rst_host_h);
447 static void usb20ehci_clock_init(void *pdata)
449 struct rkehci_platform_data *usbpdata = pdata;
450 struct clk *ahbclk, *phyclk;
452 if (soc_is_rk3126b())
453 ahbclk = devm_clk_get(usbpdata->dev, "hclk_hoct0_3126b");
455 ahbclk = devm_clk_get(usbpdata->dev, "hclk_hoct0_3126");
456 if (IS_ERR(ahbclk)) {
457 dev_err(usbpdata->dev, "Failed to get hclk_usb1\n");
461 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy1");
462 if (IS_ERR(phyclk)) {
463 dev_err(usbpdata->dev, "Failed to get clk_usbphy1\n");
467 usbpdata->phyclk = phyclk;
468 usbpdata->ahbclk = ahbclk;
471 static void usb20ehci_clock_enable(void *pdata, int enable)
473 struct rkehci_platform_data *usbpdata = pdata;
476 clk_prepare_enable(usbpdata->ahbclk);
477 clk_prepare_enable(usbpdata->phyclk);
479 clk_disable_unprepare(usbpdata->ahbclk);
480 clk_disable_unprepare(usbpdata->phyclk);
484 struct rkehci_platform_data usb20ehci_pdata_rk3126 = {
488 .hw_init = usb20host_hw_init,
489 .phy_suspend = usb20ehci_phy_suspend,
490 .soft_reset = usb20ehci_soft_reset,
491 .clock_init = usb20ehci_clock_init,
492 .clock_enable = usb20ehci_clock_enable,
493 .get_status = usb20host_get_status,
497 struct dwc_otg_platform_data usb20ohci_pdata_rk3126;
500 static const struct of_device_id rk_usb_control_id_table[] = {
502 .compatible = "rockchip,rk3126-usb-control",
507 /*********************************************************************
508 rk3126 usb detections
509 *********************************************************************/
511 #define WAKE_LOCK_TIMEOUT (HZ * 10)
512 static inline void do_wakeup(struct work_struct *work)
514 /* wake up the system */
515 rk_send_wakeup_key();
518 static void usb_battery_charger_detect_work(struct work_struct *work)
520 rk_battery_charger_detect_cb(usb_battery_charger_detect(1));
523 /********** handler for bvalid irq **********/
524 static irqreturn_t bvalid_irq_handler(int irq, void *dev_id)
527 writel(UOC_HIWORD_UPDATE(0x1, 0x1, 15),
528 RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
529 #ifdef CONFIG_RK_USB_UART
530 /* usb otg dp/dm switch to usb phy */
531 dwc_otg_uart_mode(NULL, PHY_USB_MODE);
534 if (control_usb->usb_irq_wakeup) {
535 wake_lock_timeout(&control_usb->usb_wakelock,
537 schedule_delayed_work(&control_usb->usb_det_wakeup_work,
541 schedule_delayed_work(&control_usb->usb_charger_det_work, HZ / 10);
546 /************* register usb detection irqs **************/
547 static int otg_irq_detect_init(struct platform_device *pdev)
552 if (control_usb->usb_irq_wakeup) {
553 wake_lock_init(&control_usb->usb_wakelock, WAKE_LOCK_SUSPEND,
555 INIT_DELAYED_WORK(&control_usb->usb_det_wakeup_work, do_wakeup);
558 /*register otg_bvalid irq */
559 irq = platform_get_irq_byname(pdev, "otg_bvalid");
560 if ((irq > 0) && control_usb->usb_irq_wakeup) {
561 ret = request_irq(irq, bvalid_irq_handler,
562 0, "otg_bvalid", NULL);
564 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
566 /* enable bvalid irq */
567 writel(UOC_HIWORD_UPDATE(0x1, 0x1, 14),
568 RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
574 /********** end of rk3126 usb detections **********/
575 static int rk_usb_control_probe(struct platform_device *pdev)
578 struct device_node *np = pdev->dev.of_node;
582 devm_kzalloc(&pdev->dev, sizeof(*control_usb), GFP_KERNEL);
584 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
589 control_usb->chip_id = RK3126_USB_CTLR;
590 control_usb->remote_wakeup = of_property_read_bool(np,
591 "rockchip,remote_wakeup");
592 control_usb->usb_irq_wakeup = of_property_read_bool(np,
593 "rockchip,usb_irq_wakeup");
595 INIT_DELAYED_WORK(&control_usb->usb_charger_det_work,
596 usb_battery_charger_detect_work);
598 control_usb->host_gpios =
599 devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
600 if (!control_usb->host_gpios) {
601 dev_err(&pdev->dev, "unable to alloc memory for host_gpios\n");
606 gpio = of_get_named_gpio(np, "host_drv_gpio", 0);
607 control_usb->host_gpios->gpio = gpio;
609 if (!gpio_is_valid(gpio)) {
610 dev_err(&pdev->dev, "invalid host gpio%d\n", gpio);
612 err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio");
615 "failed to request GPIO%d for host_drv\n",
620 gpio_direction_output(control_usb->host_gpios->gpio, 1);
623 control_usb->otg_gpios =
624 devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
625 if (!control_usb->otg_gpios) {
626 dev_err(&pdev->dev, "unable to alloc memory for otg_gpios\n");
631 gpio = of_get_named_gpio(np, "otg_drv_gpio", 0);
632 control_usb->otg_gpios->gpio = gpio;
634 if (!gpio_is_valid(gpio)) {
635 dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio);
637 err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio");
640 "failed to request GPIO%d for otg_drv\n", gpio);
644 gpio_direction_output(control_usb->otg_gpios->gpio, 0);
651 static int rk_usb_control_remove(struct platform_device *pdev)
656 static struct platform_driver rk_usb_control_driver = {
657 .probe = rk_usb_control_probe,
658 .remove = rk_usb_control_remove,
660 .name = "rk3126-usb-control",
661 .owner = THIS_MODULE,
662 .of_match_table = of_match_ptr(rk_usb_control_id_table),
668 static const struct of_device_id dwc_otg_control_usb_id_table[] = {
670 .compatible = "rockchip,rk3126-dwc-control-usb",
676 static int dwc_otg_control_usb_probe(struct platform_device *pdev)
678 struct clk *hclk_usb_peri;
682 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
687 hclk_usb_peri = devm_clk_get(&pdev->dev, "hclk_usb_peri");
688 if (IS_ERR(hclk_usb_peri)) {
689 dev_err(&pdev->dev, "Failed to get hclk_usb_peri\n");
694 control_usb->hclk_usb_peri = hclk_usb_peri;
695 clk_prepare_enable(hclk_usb_peri);
697 #ifdef CONFIG_USB20_OTG
698 if (usb20otg_get_status(USB_STATUS_BVABLID))
699 schedule_delayed_work(&control_usb->usb_charger_det_work,
703 ret = otg_irq_detect_init(pdev);
710 clk_disable_unprepare(hclk_usb_peri);
715 static int dwc_otg_control_usb_remove(struct platform_device *pdev)
717 clk_disable_unprepare(control_usb->hclk_usb_peri);
721 static struct platform_driver dwc_otg_control_usb_driver = {
722 .probe = dwc_otg_control_usb_probe,
723 .remove = dwc_otg_control_usb_remove,
725 .name = "rk3126-dwc-control-usb",
726 .owner = THIS_MODULE,
727 .of_match_table = of_match_ptr(dwc_otg_control_usb_id_table),
731 static int __init dwc_otg_control_usb_init(void)
735 retval |= platform_driver_register(&rk_usb_control_driver);
736 retval |= platform_driver_register(&dwc_otg_control_usb_driver);
740 subsys_initcall(dwc_otg_control_usb_init);
742 static void __exit dwc_otg_control_usb_exit(void)
744 platform_driver_unregister(&rk_usb_control_driver);
745 platform_driver_unregister(&dwc_otg_control_usb_driver);
748 module_exit(dwc_otg_control_usb_exit);
749 MODULE_ALIAS("platform: dwc_control_usb");
750 MODULE_AUTHOR("RockChip Inc.");
751 MODULE_DESCRIPTION("RockChip Control Module USB Driver");
752 MODULE_LICENSE("GPL v2");