3 #include "usbdev_grf_regs.h"
4 #include "dwc_otg_regs.h"
5 static struct dwc_otg_control_usb *control_usb;
7 #ifdef CONFIG_USB20_OTG
8 static void usb20otg_hw_init(void)
10 #ifndef CONFIG_USB20_HOST
11 /* enable soft control */
12 control_usb->grf_uoc2_base->CON2 = (0x01 << 2) | ((0x01 << 2) << 16);
14 control_usb->grf_uoc2_base->CON3 = 0x2A | (0x3F << 16);
16 /* usb phy config init
17 * usb phy enter usb mode */
18 control_usb->grf_uoc0_base->CON3 = (0x00c0 << 16);
20 /* other haredware init,include:
21 * DRV_VBUS GPIO init */
22 if (gpio_is_valid(control_usb->otg_gpios->gpio)) {
23 if (gpio_get_value(control_usb->otg_gpios->gpio))
24 gpio_set_value(control_usb->otg_gpios->gpio, 0);
28 static void usb20otg_phy_suspend(void *pdata, int suspend)
30 struct dwc_otg_platform_data *usbpdata = pdata;
33 /* enable soft control */
34 control_usb->grf_uoc0_base->CON2 =
35 (0x01 << 2) | ((0x01 << 2) << 16);
37 control_usb->grf_uoc0_base->CON3 = 0x2A | (0x3F << 16);
38 usbpdata->phy_status = 1;
41 control_usb->grf_uoc0_base->CON2 = ((0x01 << 2) << 16);
42 usbpdata->phy_status = 0;
46 static void usb20otg_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
48 struct dwc_otg_platform_data *usbpdata = pdata;
49 struct reset_control *rst_otg_h, *rst_otg_p, *rst_otg_c;
51 rst_otg_h = devm_reset_control_get(usbpdata->dev, "otg_ahb");
52 rst_otg_p = devm_reset_control_get(usbpdata->dev, "otg_phy");
53 rst_otg_c = devm_reset_control_get(usbpdata->dev, "otg_controller");
54 if (IS_ERR(rst_otg_h) || IS_ERR(rst_otg_p) || IS_ERR(rst_otg_c)) {
55 dev_err(usbpdata->dev, "Fail to get reset control from dts\n");
59 reset_control_assert(rst_otg_h);
60 reset_control_assert(rst_otg_p);
61 reset_control_assert(rst_otg_c);
63 reset_control_deassert(rst_otg_h);
64 reset_control_deassert(rst_otg_p);
65 reset_control_deassert(rst_otg_c);
69 static void usb20otg_clock_init(void *pdata)
71 struct dwc_otg_platform_data *usbpdata = pdata;
72 struct clk *ahbclk, *phyclk;
74 ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb0");
76 dev_err(usbpdata->dev, "Failed to get hclk_usb0\n");
80 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy0");
82 dev_err(usbpdata->dev, "Failed to get clk_usbphy0\n");
86 usbpdata->phyclk = phyclk;
87 usbpdata->ahbclk = ahbclk;
90 static void usb20otg_clock_enable(void *pdata, int enable)
92 struct dwc_otg_platform_data *usbpdata = pdata;
95 clk_prepare_enable(usbpdata->ahbclk);
96 clk_prepare_enable(usbpdata->phyclk);
98 clk_disable_unprepare(usbpdata->ahbclk);
99 clk_disable_unprepare(usbpdata->phyclk);
103 static int usb20otg_get_status(int id)
108 case USB_STATUS_BVABLID:
110 ret = control_usb->grf_soc_status2_rk3288->otg_bvalid;
112 case USB_STATUS_DPDM:
114 ret = control_usb->grf_soc_status2_rk3288->otg_linestate;
118 ret = control_usb->grf_soc_status2_rk3288->otg_iddig;
121 ret = control_usb->chip_id;
123 case USB_REMOTE_WAKEUP:
124 ret = control_usb->remote_wakeup;
127 ret = control_usb->usb_irq_wakeup;
136 #ifdef CONFIG_RK_USB_UART
137 static void dwc_otg_uart_mode(void *pdata, int enter_usb_uart_mode)
139 if (1 == enter_usb_uart_mode) {
140 /* bypass dm, enter uart mode */
141 control_usb->grf_uoc0_base->CON3 = (0x00c0 | (0x00c0 << 16));
143 } else if (0 == enter_usb_uart_mode) {
145 control_usb->grf_uoc0_base->CON3 = (0x00c0 << 16);
150 static void usb20otg_power_enable(int enable)
153 /* disable otg_drv power */
154 if (gpio_is_valid(control_usb->otg_gpios->gpio))
155 gpio_set_value(control_usb->otg_gpios->gpio, 0);
156 } else if (1 == enable) {
157 /* enable otg_drv power */
158 if (gpio_is_valid(control_usb->otg_gpios->gpio))
159 gpio_set_value(control_usb->otg_gpios->gpio, 1);
163 struct dwc_otg_platform_data usb20otg_pdata_rk3288 = {
168 .hw_init = usb20otg_hw_init,
169 .phy_suspend = usb20otg_phy_suspend,
170 .soft_reset = usb20otg_soft_reset,
171 .clock_init = usb20otg_clock_init,
172 .clock_enable = usb20otg_clock_enable,
173 .get_status = usb20otg_get_status,
174 .power_enable = usb20otg_power_enable,
175 #ifdef CONFIG_RK_USB_UART
176 .dwc_otg_uart_mode = dwc_otg_uart_mode,
178 .bc_detect_cb = usb20otg_battery_charger_detect_cb,
183 #ifdef CONFIG_USB20_HOST
185 static void usb20host_hw_init(void)
187 /* usb phy config init
188 * set common_on = 0, in suspend mode, host1 PLL blocks remain powered.
189 * for RK3288, hsic and other modules use host1 (DWC_OTG) 480M phy clk.
191 control_usb->grf_uoc2_base->CON0 = (1 << 16) | 0;
193 /* other haredware init,include:
194 * DRV_VBUS GPIO init */
195 if (gpio_is_valid(control_usb->host_gpios->gpio)) {
196 if (!gpio_get_value(control_usb->host_gpios->gpio))
197 gpio_set_value(control_usb->host_gpios->gpio, 1);
201 static void usb20host_phy_suspend(void *pdata, int suspend)
203 struct dwc_otg_platform_data *usbpdata = pdata;
206 /* enable soft control */
207 control_usb->grf_uoc2_base->CON2 =
208 (0x01 << 2) | ((0x01 << 2) << 16);
210 control_usb->grf_uoc2_base->CON3 = 0x2A | (0x3F << 16);
211 usbpdata->phy_status = 1;
214 control_usb->grf_uoc2_base->CON2 = ((0x01 << 2) << 16);
215 usbpdata->phy_status = 0;
219 static void usb20host_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
221 struct dwc_otg_platform_data *usbpdata = pdata;
222 struct reset_control *rst_host1_h, *rst_host1_p, *rst_host1_c;
224 rst_host1_h = devm_reset_control_get(usbpdata->dev, "host1_ahb");
225 rst_host1_p = devm_reset_control_get(usbpdata->dev, "host1_phy");
226 rst_host1_c = devm_reset_control_get(usbpdata->dev, "host1_controller");
227 if (IS_ERR(rst_host1_h) || IS_ERR(rst_host1_p) || IS_ERR(rst_host1_c)) {
228 dev_err(usbpdata->dev, "Fail to get reset control from dts\n");
232 reset_control_assert(rst_host1_h);
233 reset_control_assert(rst_host1_p);
234 reset_control_assert(rst_host1_c);
236 reset_control_deassert(rst_host1_h);
237 reset_control_deassert(rst_host1_p);
238 reset_control_deassert(rst_host1_c);
242 static void usb20host_clock_init(void *pdata)
244 struct dwc_otg_platform_data *usbpdata = pdata;
245 struct clk *ahbclk, *phyclk, *phyclk_480m;
247 ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb1");
248 if (IS_ERR(ahbclk)) {
249 dev_err(usbpdata->dev, "Failed to get hclk_usb1\n");
253 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy1");
254 if (IS_ERR(phyclk)) {
255 dev_err(usbpdata->dev, "Failed to get clk_usbphy1\n");
259 phyclk_480m = devm_clk_get(usbpdata->dev, "usbphy_480m");
260 if (IS_ERR(phyclk_480m)) {
261 dev_err(usbpdata->dev, "Failed to get usbphy_480m\n");
265 usbpdata->phyclk = phyclk;
266 usbpdata->ahbclk = ahbclk;
267 usbpdata->phyclk_480m = phyclk_480m;
270 static void usb20host_clock_enable(void *pdata, int enable)
272 struct dwc_otg_platform_data *usbpdata = pdata;
275 clk_prepare_enable(usbpdata->ahbclk);
276 clk_prepare_enable(usbpdata->phyclk);
278 clk_disable_unprepare(usbpdata->ahbclk);
279 clk_disable_unprepare(usbpdata->phyclk);
283 static int usb20host_get_status(int id)
288 case USB_STATUS_BVABLID:
290 ret = control_usb->grf_soc_status2_rk3288->host1_bvalid;
292 case USB_STATUS_DPDM:
294 ret = control_usb->grf_soc_status2_rk3288->host1_linestate;
298 ret = control_usb->grf_soc_status2_rk3288->host1_iddig;
301 ret = control_usb->chip_id;
303 case USB_REMOTE_WAKEUP:
304 ret = control_usb->remote_wakeup;
307 ret = control_usb->usb_irq_wakeup;
316 static void usb20host_power_enable(int enable)
319 /* disable host_drv power */
320 /* do not disable power in default */
321 } else if (1 == enable) {
322 /* enable host_drv power */
323 if (gpio_is_valid(control_usb->host_gpios->gpio))
324 gpio_set_value(control_usb->host_gpios->gpio, 1);
328 struct dwc_otg_platform_data usb20host_pdata_rk3288 = {
333 .hw_init = usb20host_hw_init,
334 .phy_suspend = usb20host_phy_suspend,
335 .soft_reset = usb20host_soft_reset,
336 .clock_init = usb20host_clock_init,
337 .clock_enable = usb20host_clock_enable,
338 .get_status = usb20host_get_status,
339 .power_enable = usb20host_power_enable,
344 #ifdef CONFIG_USB_EHCI_RKHSIC
345 static void rk_hsic_hw_init(void)
347 /* usb phy config init
348 * hsic phy config init, set hsicphy_txsrtune */
349 control_usb->grf_uoc3_base->CON0 = ((0xf << 6) << 16) | (0xf << 6);
351 /* other haredware init
352 * set common_on = 0, in suspend mode,
353 * otg/host PLL blocks remain powered
354 * for RK3288, use host1 (DWC_OTG) 480M phy clk
356 control_usb->grf_uoc2_base->CON0 = (1 << 16) | 0;
358 /* change INCR to INCR16 or INCR8(beats less than 16)
359 * or INCR4(beats less than 8) or SINGLE(beats less than 4)
361 control_usb->grf_uoc4_base->CON0 = 0x00ff00bc;
364 static void rk_hsic_clock_init(void *pdata)
366 /* By default, hsicphy_480m's parent is otg phy 480MHz clk
367 * rk3188 must use host phy 480MHz clk, because if otg bypass
368 * to uart mode, otg phy 480MHz clk will be closed automatically
370 struct rkehci_platform_data *usbpdata = pdata;
371 struct clk *ahbclk, *phyclk480m_hsic, *phyclk12m_hsic;
373 phyclk480m_hsic = devm_clk_get(usbpdata->dev, "hsicphy_480m");
374 if (IS_ERR(phyclk480m_hsic)) {
375 dev_err(usbpdata->dev, "Failed to get hsicphy_480m\n");
379 phyclk12m_hsic = devm_clk_get(usbpdata->dev, "hsicphy_12m");
380 if (IS_ERR(phyclk12m_hsic)) {
381 dev_err(usbpdata->dev, "Failed to get hsicphy_12m\n");
385 ahbclk = devm_clk_get(usbpdata->dev, "hclk_hsic");
386 if (IS_ERR(ahbclk)) {
387 dev_err(usbpdata->dev, "Failed to get hclk_hsic\n");
391 usbpdata->hclk_hsic = ahbclk;
392 usbpdata->hsic_phy_480m = phyclk480m_hsic;
393 usbpdata->hsic_phy_12m = phyclk12m_hsic;
396 static void rk_hsic_clock_enable(void *pdata, int enable)
398 struct rkehci_platform_data *usbpdata = pdata;
400 if (enable == usbpdata->clk_status)
403 clk_prepare_enable(usbpdata->hclk_hsic);
404 clk_prepare_enable(usbpdata->hsic_phy_480m);
405 clk_prepare_enable(usbpdata->hsic_phy_12m);
406 usbpdata->clk_status = 1;
408 clk_disable_unprepare(usbpdata->hclk_hsic);
409 clk_disable_unprepare(usbpdata->hsic_phy_480m);
410 clk_disable_unprepare(usbpdata->hsic_phy_12m);
411 usbpdata->clk_status = 0;
415 static void rk_hsic_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
417 struct rkehci_platform_data *usbpdata = pdata;
418 struct reset_control *rst_hsic_h, rst_hsic_a, rst_hsic_p;
420 rst_hsic_h = devm_reset_control_get(usbpdata->dev, "hsic_ahb");
421 rst_hsic_a = devm_reset_control_get(usbpdata->dev, "hsic_aux");
422 rst_hsic_p = devm_reset_control_get(usbpdata->dev, "hsic_phy");
424 reset_control_assert(rst_hsic_h);
425 reset_control_assert(rst_hsic_a);
426 reset_control_assert(rst_hsic_p);
428 reset_control_deassert(rst_hsic_h);
429 reset_control_deassert(rst_hsic_a);
430 reset_control_deassert(rst_hsic_p);
433 /* HSIC per-port reset */
434 control_usb->grf_uoc3_base->CON0 = ((1 << 10) << 16) | (1 << 10);
436 control_usb->grf_uoc3_base->CON0 = ((1 << 10) << 16) | (0 << 10);
440 struct rkehci_platform_data rkhsic_pdata_rk3288 = {
442 .hsic_phy_12m = NULL,
443 .hsic_phy_480m = NULL,
445 .hw_init = rk_hsic_hw_init,
446 .clock_init = rk_hsic_clock_init,
447 .clock_enable = rk_hsic_clock_enable,
448 .soft_reset = rk_hsic_soft_reset,
452 #ifdef CONFIG_USB_EHCI_RK
453 static void rk_ehci_hw_init(void)
455 /* usb phy config init */
457 /* DRV_VBUS GPIO init */
458 if (gpio_is_valid(control_usb->host_gpios->gpio)) {
459 if (!gpio_get_value(control_usb->host_gpios->gpio))
460 gpio_set_value(control_usb->host_gpios->gpio, 1);
464 static void rk_ehci_phy_suspend(void *pdata, int suspend)
466 struct rkehci_platform_data *usbpdata = pdata;
469 /* enable soft control */
470 control_usb->grf_uoc1_base->CON2 =
471 (0x01 << 2) | ((0x01 << 2) << 16);
473 control_usb->grf_uoc1_base->CON3 = 0x2A | (0x3F << 16);
474 usbpdata->phy_status = 1;
477 control_usb->grf_uoc1_base->CON2 = ((0x01 << 2) << 16);
478 usbpdata->phy_status = 0;
482 static void rk_ehci_clock_init(void *pdata)
484 struct rkehci_platform_data *usbpdata = pdata;
485 struct clk *ahbclk, *phyclk;
487 ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb2");
488 if (IS_ERR(ahbclk)) {
489 dev_err(usbpdata->dev, "Failed to get hclk_usb2\n");
493 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy2");
494 if (IS_ERR(phyclk)) {
495 dev_err(usbpdata->dev, "Failed to get clk_usbphy2\n");
499 usbpdata->phyclk = phyclk;
500 usbpdata->ahbclk = ahbclk;
503 static void rk_ehci_clock_enable(void *pdata, int enable)
505 struct rkehci_platform_data *usbpdata = pdata;
507 if (enable == usbpdata->clk_status)
510 clk_prepare_enable(usbpdata->ahbclk);
511 clk_prepare_enable(usbpdata->phyclk);
512 usbpdata->clk_status = 1;
514 clk_disable_unprepare(usbpdata->ahbclk);
515 clk_disable_unprepare(usbpdata->phyclk);
516 usbpdata->clk_status = 0;
520 static void rk_ehci_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
522 struct rkehci_platform_data *usbpdata = pdata;
523 struct reset_control *rst_host0_h, *rst_host0_p,
524 *rst_host0_c , *rst_host0;
526 rst_host0_h = devm_reset_control_get(usbpdata->dev, "ehci_ahb");
527 rst_host0_p = devm_reset_control_get(usbpdata->dev, "ehci_phy");
528 rst_host0_c = devm_reset_control_get(usbpdata->dev, "ehci_controller");
529 rst_host0 = devm_reset_control_get(usbpdata->dev, "ehci");
530 if (IS_ERR(rst_host0_h) || IS_ERR(rst_host0_p) ||
531 IS_ERR(rst_host0_c) || IS_ERR(rst_host0)) {
532 dev_err(usbpdata->dev, "Fail to get reset control from dts\n");
536 reset_control_assert(rst_host0_h);
537 reset_control_assert(rst_host0_p);
538 reset_control_assert(rst_host0_c);
539 reset_control_assert(rst_host0);
541 reset_control_deassert(rst_host0_h);
542 reset_control_deassert(rst_host0_p);
543 reset_control_deassert(rst_host0_c);
544 reset_control_deassert(rst_host0);
548 static int rk_ehci_get_status(int id)
553 case USB_STATUS_DPDM:
555 ret = control_usb->grf_soc_status2_rk3288->host0_linestate;
558 ret = control_usb->chip_id;
560 case USB_REMOTE_WAKEUP:
561 ret = control_usb->remote_wakeup;
564 ret = control_usb->usb_irq_wakeup;
573 struct rkehci_platform_data rkehci_pdata_rk3288 = {
578 .hw_init = rk_ehci_hw_init,
579 .phy_suspend = rk_ehci_phy_suspend,
580 .clock_init = rk_ehci_clock_init,
581 .clock_enable = rk_ehci_clock_enable,
582 .soft_reset = rk_ehci_soft_reset,
583 .get_status = rk_ehci_get_status,
587 #ifdef CONFIG_USB_OHCI_HCD_RK
588 static void rk_ohci_hw_init(void)
590 /* usb phy config init */
592 /* DRV_VBUS GPIO init */
593 if (gpio_is_valid(control_usb->host_gpios->gpio)) {
594 if (!gpio_get_value(control_usb->host_gpios->gpio))
595 gpio_set_value(control_usb->host_gpios->gpio, 1);
599 static void rk_ohci_clock_init(void *pdata)
601 struct rkehci_platform_data *usbpdata = pdata;
602 struct clk *ahbclk, *phyclk;
604 ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb3");
605 if (IS_ERR(ahbclk)) {
606 dev_err(usbpdata->dev, "Failed to get hclk_usb3\n");
610 phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy3");
611 if (IS_ERR(phyclk)) {
612 dev_err(usbpdata->dev, "Failed to get clk_usbphy3\n");
616 usbpdata->phyclk = phyclk;
617 usbpdata->ahbclk = ahbclk;
620 static void rk_ohci_clock_enable(void *pdata, int enable)
622 struct rkehci_platform_data *usbpdata = pdata;
624 if (enable == usbpdata->clk_status)
627 clk_prepare_enable(usbpdata->ahbclk);
628 clk_prepare_enable(usbpdata->phyclk);
629 usbpdata->clk_status = 1;
631 clk_disable_unprepare(usbpdata->ahbclk);
632 clk_disable_unprepare(usbpdata->phyclk);
633 usbpdata->clk_status = 0;
637 static void rk_ohci_soft_reset(void *pdata, enum rkusb_rst_flag rst_type)
641 struct rkehci_platform_data rkohci_pdata_rk3288 = {
645 .hw_init = rk_ohci_hw_init,
646 .clock_init = rk_ohci_clock_init,
647 .clock_enable = rk_ohci_clock_enable,
648 .soft_reset = rk_ohci_soft_reset,
652 /*********************************************************************
653 rk3288 usb detections
654 *********************************************************************/
656 #define WAKE_LOCK_TIMEOUT (HZ * 10)
657 static inline void do_wakeup(struct work_struct *work)
659 /* wake up the system */
660 rk_send_wakeup_key();
663 static void usb_battery_charger_detect_work(struct work_struct *work)
665 rk_usb_charger_status = usb_battery_charger_detect(0);
668 /********** handler for bvalid irq **********/
669 static irqreturn_t bvalid_irq_handler(int irq, void *dev_id)
672 control_usb->grf_uoc0_base->CON4 = (0x0008 | (0x0008 << 16));
674 #ifdef CONFIG_RK_USB_UART
675 /* usb otg dp/dm switch to usb phy */
676 dwc_otg_uart_mode(NULL, PHY_USB_MODE);
679 if (control_usb->usb_irq_wakeup) {
680 wake_lock_timeout(&control_usb->usb_wakelock,
682 schedule_delayed_work(&control_usb->usb_det_wakeup_work,
686 rk_usb_charger_status = USB_BC_TYPE_SDP;
687 schedule_delayed_work(&control_usb->usb_charger_det_work, HZ / 10);
692 /***** handler for otg id rise and fall edge *****/
693 static irqreturn_t id_irq_handler(int irq, void *dev_id)
695 unsigned int uoc_con;
698 uoc_con = control_usb->grf_uoc0_base->CON4;
701 if (uoc_con & (1 << 5)) {
702 /* clear id rise irq pandding */
703 control_usb->grf_uoc0_base->CON4 = ((1 << 5) | (1 << 21));
707 if (uoc_con & (1 << 7)) {
708 #ifdef CONFIG_RK_USB_UART
709 /* usb otg dp/dm switch to usb phy */
710 dwc_otg_uart_mode(NULL, PHY_USB_MODE);
712 /* clear id fall irq pandding */
713 control_usb->grf_uoc0_base->CON4 = ((1 << 7) | (1 << 23));
716 if (control_usb->usb_irq_wakeup) {
717 wake_lock_timeout(&control_usb->usb_wakelock,
719 schedule_delayed_work(&control_usb->usb_det_wakeup_work,
726 #ifdef USB_LINESTATE_IRQ
727 /***** handler for usb line status change *****/
729 static irqreturn_t line_irq_handler(int irq, void *dev_id)
733 if (control_usb->grf_uoc0_base->CON0 & 1 << 15)
734 control_usb->grf_uoc0_base->CON0 = (1 << 15 | 1 << 31);
736 if (control_usb->grf_uoc1_base->CON0 & 1 << 15)
737 control_usb->grf_uoc1_base->CON0 = (1 << 15 | 1 << 31);
739 if (control_usb->grf_uoc2_base->CON0 & 1 << 15)
740 control_usb->grf_uoc2_base->CON0 = (1 << 15 | 1 << 31);
742 if (control_usb->usb_irq_wakeup) {
743 wake_lock_timeout(&control_usb->usb_wakelock,
745 schedule_delayed_work(&control_usb->usb_det_wakeup_work,
753 /************* register usb detection irqs **************/
754 static int otg_irq_detect_init(struct platform_device *pdev)
759 if (control_usb->usb_irq_wakeup) {
760 wake_lock_init(&control_usb->usb_wakelock, WAKE_LOCK_SUSPEND,
762 INIT_DELAYED_WORK(&control_usb->usb_det_wakeup_work, do_wakeup);
765 /*register otg_bvalid irq */
766 irq = platform_get_irq_byname(pdev, "otg_bvalid");
767 if ((irq > 0) && control_usb->usb_irq_wakeup) {
768 ret = request_irq(irq, bvalid_irq_handler,
769 0, "otg_bvalid", NULL);
771 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
773 /* enable bvalid irq */
774 control_usb->grf_uoc0_base->CON4 = 0x000c000c;
778 /*register otg_id irq */
779 irq = platform_get_irq_byname(pdev, "otg_id");
780 if ((irq > 0) && control_usb->usb_irq_wakeup) {
781 ret = request_irq(irq, id_irq_handler, 0, "otg_id", NULL);
783 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
785 /* enable otg_id irq */
786 control_usb->grf_uoc0_base->CON4 = 0x00f000f0;
790 /*register otg_linestate irq */
791 irq = platform_get_irq_byname(pdev, "otg_linestate");
794 request_irq(irq, line_irq_handler, 0, "otg_linestate",
797 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
800 control_usb->grf_uoc0_base->CON0 = 0xc000c000;
801 if (control_usb->usb_irq_wakeup)
802 enable_irq_wake(irq);
806 /*register host0_linestate irq */
807 irq = platform_get_irq_byname(pdev, "host0_linestate");
810 request_irq(irq, line_irq_handler, 0, "host0_linestate",
813 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
816 control_usb->grf_uoc1_base->CON0 = 0xc000c000;
817 if (control_usb->usb_irq_wakeup)
818 enable_irq_wake(irq);
822 /*register host1_linestate irq */
823 irq = platform_get_irq_byname(pdev, "host1_linestate");
826 request_irq(irq, line_irq_handler, 0, "host1_linestate",
829 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
832 control_usb->grf_uoc2_base->CON0 = 0xc000c000;
833 if (control_usb->usb_irq_wakeup)
834 enable_irq_wake(irq);
841 /********** end of rk3288 usb detections **********/
843 static int usb_grf_ioremap(struct platform_device *pdev)
846 struct resource *res;
847 void *grf_soc_status1;
848 void *grf_soc_status2;
849 void *grf_soc_status19;
850 void *grf_soc_status21;
857 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
859 grf_soc_status1 = devm_ioremap_resource(&pdev->dev, res);
860 if (IS_ERR(grf_soc_status1)) {
861 ret = PTR_ERR(grf_soc_status1);
864 control_usb->grf_soc_status1_rk3288 =
865 (pGRF_SOC_STATUS1_RK3288) grf_soc_status1;
867 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
869 grf_soc_status2 = devm_ioremap_resource(&pdev->dev, res);
870 if (IS_ERR(grf_soc_status2)) {
871 ret = PTR_ERR(grf_soc_status2);
874 control_usb->grf_soc_status2_rk3288 =
875 (pGRF_SOC_STATUS2_RK3288) grf_soc_status2;
877 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
879 grf_soc_status19 = devm_ioremap_resource(&pdev->dev, res);
880 if (IS_ERR(grf_soc_status19)) {
881 ret = PTR_ERR(grf_soc_status19);
884 control_usb->grf_soc_status19_rk3288 =
885 (pGRF_SOC_STATUS19_RK3288) grf_soc_status19;
887 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
889 grf_soc_status21 = devm_ioremap_resource(&pdev->dev, res);
890 if (IS_ERR(grf_soc_status21)) {
891 ret = PTR_ERR(grf_soc_status21);
894 control_usb->grf_soc_status21_rk3288 =
895 (pGRF_SOC_STATUS21_RK3288) grf_soc_status21;
897 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
899 grf_uoc0_base = devm_ioremap_resource(&pdev->dev, res);
900 if (IS_ERR(grf_uoc0_base)) {
901 ret = PTR_ERR(grf_uoc0_base);
904 control_usb->grf_uoc0_base = (pGRF_UOC0_REG) grf_uoc0_base;
906 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
908 grf_uoc1_base = devm_ioremap_resource(&pdev->dev, res);
909 if (IS_ERR(grf_uoc1_base)) {
910 ret = PTR_ERR(grf_uoc1_base);
913 control_usb->grf_uoc1_base = (pGRF_UOC1_REG) grf_uoc1_base;
915 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
917 grf_uoc2_base = devm_ioremap_resource(&pdev->dev, res);
918 if (IS_ERR(grf_uoc2_base)) {
919 ret = PTR_ERR(grf_uoc2_base);
922 control_usb->grf_uoc2_base = (pGRF_UOC2_REG) grf_uoc2_base;
924 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
926 grf_uoc3_base = devm_ioremap_resource(&pdev->dev, res);
927 if (IS_ERR(grf_uoc3_base)) {
928 ret = PTR_ERR(grf_uoc3_base);
931 control_usb->grf_uoc3_base = (pGRF_UOC3_REG) grf_uoc3_base;
933 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
935 grf_uoc4_base = devm_ioremap_resource(&pdev->dev, res);
936 if (IS_ERR(grf_uoc4_base)) {
937 ret = PTR_ERR(grf_uoc4_base);
940 control_usb->grf_uoc4_base = (pGRF_UOC4_REG) grf_uoc4_base;
947 static const struct of_device_id rk_usb_control_id_table[] = {
949 .compatible = "rockchip,rk3288-usb-control",
956 static int rk_usb_control_probe(struct platform_device *pdev)
959 struct device_node *np = pdev->dev.of_node;
963 devm_kzalloc(&pdev->dev, sizeof(*control_usb), GFP_KERNEL);
965 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
970 control_usb->chip_id = RK3288_USB_CTLR;
971 control_usb->remote_wakeup = of_property_read_bool(np,
972 "rockchip,remote_wakeup");
973 control_usb->usb_irq_wakeup = of_property_read_bool(np,
974 "rockchip,usb_irq_wakeup");
976 INIT_DELAYED_WORK(&control_usb->usb_charger_det_work,
977 usb_battery_charger_detect_work);
979 control_usb->host_gpios =
980 devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
981 if (!control_usb->host_gpios) {
982 dev_err(&pdev->dev, "unable to alloc memory for host_gpios\n");
987 gpio = of_get_named_gpio(np, "host_drv_gpio", 0);
988 control_usb->host_gpios->gpio = gpio;
990 if (!gpio_is_valid(gpio)) {
991 dev_err(&pdev->dev, "invalid host gpio%d\n", gpio);
993 err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio");
996 "failed to request GPIO%d for host_drv\n",
1001 gpio_direction_output(control_usb->host_gpios->gpio, 1);
1004 control_usb->otg_gpios =
1005 devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
1006 if (!control_usb->otg_gpios) {
1007 dev_err(&pdev->dev, "unable to alloc memory for otg_gpios\n");
1012 gpio = of_get_named_gpio(np, "otg_drv_gpio", 0);
1013 control_usb->otg_gpios->gpio = gpio;
1015 if (!gpio_is_valid(gpio)) {
1016 dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio);
1018 err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio");
1021 "failed to request GPIO%d for otg_drv\n", gpio);
1025 gpio_direction_output(control_usb->otg_gpios->gpio, 0);
1032 static int rk_usb_control_remove(struct platform_device *pdev)
1037 static struct platform_driver rk_usb_control_driver = {
1038 .probe = rk_usb_control_probe,
1039 .remove = rk_usb_control_remove,
1041 .name = "rk3288-usb-control",
1042 .owner = THIS_MODULE,
1043 .of_match_table = of_match_ptr(rk_usb_control_id_table),
1049 static const struct of_device_id dwc_otg_control_usb_id_table[] = {
1051 .compatible = "rockchip,rk3288-dwc-control-usb",
1058 static int dwc_otg_control_usb_probe(struct platform_device *pdev)
1060 struct clk *hclk_usb_peri, *phyclk_480m, *phyclk480m_parent;
1064 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
1069 hclk_usb_peri = devm_clk_get(&pdev->dev, "hclk_usb_peri");
1070 if (IS_ERR(hclk_usb_peri)) {
1071 dev_err(&pdev->dev, "Failed to get hclk_usb_peri\n");
1076 control_usb->hclk_usb_peri = hclk_usb_peri;
1077 clk_prepare_enable(hclk_usb_peri);
1079 phyclk480m_parent = devm_clk_get(&pdev->dev, "usbphy2_480m");
1080 if (IS_ERR(phyclk480m_parent)) {
1081 dev_err(&pdev->dev, "Failed to get usbphy2_480m\n");
1085 phyclk_480m = devm_clk_get(&pdev->dev, "usbphy_480m");
1086 if (IS_ERR(phyclk_480m)) {
1087 dev_err(&pdev->dev, "Failed to get usbphy_480m\n");
1091 clk_set_parent(phyclk_480m, phyclk480m_parent);
1093 ret = usb_grf_ioremap(pdev);
1095 dev_err(&pdev->dev, "Failed to ioremap usb grf\n");
1098 #ifdef CONFIG_USB20_OTG
1099 if (usb20otg_get_status(USB_STATUS_BVABLID)) {
1100 rk_usb_charger_status = USB_BC_TYPE_SDP;
1101 schedule_delayed_work(&control_usb->usb_charger_det_work,
1106 ret = otg_irq_detect_init(pdev);
1113 clk_disable_unprepare(hclk_usb_peri);
1118 static int dwc_otg_control_usb_remove(struct platform_device *pdev)
1120 clk_disable_unprepare(control_usb->hclk_usb_peri);
1124 static struct platform_driver dwc_otg_control_usb_driver = {
1125 .probe = dwc_otg_control_usb_probe,
1126 .remove = dwc_otg_control_usb_remove,
1128 .name = "rk3288-dwc-control-usb",
1129 .owner = THIS_MODULE,
1130 .of_match_table = of_match_ptr(dwc_otg_control_usb_id_table),
1134 static int __init dwc_otg_control_usb_init(void)
1138 retval = platform_driver_register(&rk_usb_control_driver);
1140 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1144 retval = platform_driver_register(&dwc_otg_control_usb_driver);
1147 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1153 subsys_initcall(dwc_otg_control_usb_init);
1155 static void __exit dwc_otg_control_usb_exit(void)
1157 platform_driver_unregister(&rk_usb_control_driver);
1158 platform_driver_unregister(&dwc_otg_control_usb_driver);
1161 module_exit(dwc_otg_control_usb_exit);
1162 MODULE_ALIAS("platform: dwc_control_usb");
1163 MODULE_AUTHOR("RockChip Inc.");
1164 MODULE_DESCRIPTION("RockChip Control Module USB Driver");
1165 MODULE_LICENSE("GPL v2");