1 #include <linux/kernel.h>
2 #include <linux/platform_device.h>
3 #include <linux/delay.h>
4 #include <linux/dma-mapping.h>
6 #include <linux/module.h>
7 #include <linux/slab.h>
11 #include <linux/of_gpio.h>
12 #include <linux/of_device.h>
13 #include <linux/gpio.h>
14 #include <linux/wakelock.h>
15 #include <linux/workqueue.h>
16 #include <linux/interrupt.h>
17 #include <linux/irq.h>
18 #include "usbdev_grf_regs.h"
19 #include "usbdev_rk.h"
20 #include "dwc_otg_regs.h"
21 static struct dwc_otg_control_usb *control_usb;
23 static int usb_get_chip_id(void)
25 return control_usb->chip_id;
28 #ifdef CONFIG_USB20_OTG
29 static void usb20otg_hw_init(void)
31 #ifndef CONFIG_USB20_HOST
33 control_usb->grf_uoc2_base->CON2 = (0x01<<2)|((0x01<<2)<<16);
35 control_usb->grf_uoc2_base->CON3 = 0x2A|(0x3F<<16);
37 /* usb phy config init
38 * usb phy enter usb mode */
39 control_usb->grf_uoc0_base->CON3 = (0x00c0 << 16);
41 /* other haredware init,include:
42 * DRV_VBUS GPIO init */
43 // gpio_direction_output(control_usb->otg_gpios->gpio, 0);
47 static void usb20otg_phy_suspend(void* pdata, int suspend)
49 struct dwc_otg_platform_data *usbpdata=pdata;
53 control_usb->grf_uoc0_base->CON2 = (0x01<<2)|((0x01<<2)<<16);
55 control_usb->grf_uoc0_base->CON3 = 0x2A|(0x3F<<16);
56 usbpdata->phy_status = 1;
59 control_usb->grf_uoc0_base->CON2 = ((0x01<<2)<<16);
60 usbpdata->phy_status = 0;
64 static void usb20otg_soft_reset(void)
68 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_otg0");
76 dev_err(usbpdata->dev, "Failed to get hclk_otg0\n");
80 phyclk = devm_clk_get(usbpdata->dev, "otgphy0");
82 dev_err(usbpdata->dev, "Failed to get otgphy0\n");
86 usbpdata->phyclk = phyclk;
87 usbpdata->ahbclk = ahbclk;
91 static void usb20otg_clock_enable(void* pdata, int enable)
94 struct dwc_otg_platform_data *usbpdata=pdata;
97 clk_prepare_enable(usbpdata->ahbclk);
98 clk_prepare_enable(usbpdata->phyclk);
100 clk_disable_unprepare(usbpdata->ahbclk);
101 clk_disable_unprepare(usbpdata->phyclk);
105 static int usb20otg_get_status(int id)
110 case USB_STATUS_BVABLID:
112 ret = control_usb->grf_soc_status2_rk3288->otg_bvalid;
114 case USB_STATUS_DPDM:
116 ret = control_usb->grf_soc_status2_rk3288->otg_linestate;
120 ret = control_usb->grf_soc_status2_rk3288->otg_iddig;
129 #ifdef CONFIG_RK_USB_UART
130 static void dwc_otg_uart_mode(void* pdata, int enter_usb_uart_mode)
132 if(1 == enter_usb_uart_mode){
133 /* bypass dm, enter uart mode*/
134 control_usb->grf_uoc0_base->CON3 = (0x00c0 | (0x00c0 << 16));
136 }else if(0 == enter_usb_uart_mode){
138 control_usb->grf_uoc0_base->CON3 = (0x00c0 << 16);
143 static void usb20otg_power_enable(int enable)
145 if(0 == enable){//disable otg_drv power
146 gpio_set_value(control_usb->otg_gpios->gpio, 0);
147 }else if(1 == enable){//enable otg_drv power
148 gpio_set_value(control_usb->otg_gpios->gpio, 1);
153 struct dwc_otg_platform_data usb20otg_pdata_rk3288 = {
158 .hw_init = usb20otg_hw_init,
159 .phy_suspend = usb20otg_phy_suspend,
160 .soft_reset = usb20otg_soft_reset,
161 .clock_init = usb20otg_clock_init,
162 .clock_enable = usb20otg_clock_enable,
163 .get_status = usb20otg_get_status,
164 .get_chip_id = usb_get_chip_id,
166 .power_enable = usb20otg_power_enable,
167 #ifdef CONFIG_RK_USB_UART
168 .dwc_otg_uart_mode = dwc_otg_uart_mode,
174 #ifdef CONFIG_USB20_HOST
176 static void usb20host_hw_init(void)
178 /* usb phy config init */
180 /* other haredware init,include:
181 * DRV_VBUS GPIO init */
182 // gpio_direction_output(control_usb->host_gpios->gpio, 1);
185 static void usb20host_phy_suspend(void* pdata, int suspend)
187 struct dwc_otg_platform_data *usbpdata=pdata;
190 // enable soft control
191 control_usb->grf_uoc2_base->CON2 = (0x01<<2)|((0x01<<2)<<16);
193 control_usb->grf_uoc2_base->CON3 = 0x2A|(0x3F<<16);
194 usbpdata->phy_status = 1;
197 control_usb->grf_uoc2_base->CON2 = ((0x01<<2)<<16);
198 usbpdata->phy_status = 0;
202 static void usb20host_soft_reset(void)
206 static void usb20host_clock_init(void* pdata)
209 struct dwc_otg_platform_data *usbpdata=pdata;
210 struct clk* ahbclk,*phyclk;
212 ahbclk = devm_clk_get(usbpdata->dev, "hclk_otg1");
213 if (IS_ERR(ahbclk)) {
214 dev_err(usbpdata->dev, "Failed to get hclk_otg1\n");
218 phyclk = devm_clk_get(usbpdata->dev, "otgphy1");
219 if (IS_ERR(phyclk)) {
220 dev_err(usbpdata->dev, "Failed to get otgphy1\n");
224 usbpdata->phyclk = phyclk;
225 usbpdata->ahbclk = ahbclk;
229 static void usb20host_clock_enable(void* pdata, int enable)
232 struct dwc_otg_platform_data *usbpdata=pdata;
235 clk_prepare_enable(usbpdata->ahbclk);
236 clk_prepare_enable(usbpdata->phyclk);
238 clk_disable_unprepare(usbpdata->ahbclk);
239 clk_disable_unprepare(usbpdata->phyclk);
244 static int usb20host_get_status(int id)
249 case USB_STATUS_BVABLID:
251 ret = control_usb->grf_soc_status2_rk3288->host1_bvalid;
253 case USB_STATUS_DPDM:
255 ret = control_usb->grf_soc_status2_rk3288->host1_linestate;
259 ret = control_usb->grf_soc_status2_rk3288->host1_iddig;
268 static void usb20host_power_enable(int enable)
270 if(0 == enable){//disable host_drv power
271 //do not disable power in default
272 }else if(1 == enable){//enable host_drv power
273 gpio_set_value(control_usb->host_gpios->gpio, 1);
278 struct dwc_otg_platform_data usb20host_pdata_rk3288 = {
283 .hw_init = usb20host_hw_init,
284 .phy_suspend = usb20host_phy_suspend,
285 .soft_reset = usb20host_soft_reset,
286 .clock_init = usb20host_clock_init,
287 .clock_enable = usb20host_clock_enable,
288 .get_status = usb20host_get_status,
289 .get_chip_id = usb_get_chip_id,
290 .power_enable = usb20host_power_enable,
295 #ifdef CONFIG_USB_EHCI_RKHSIC
296 static void rk_hsic_hw_init(void)
298 // usb phy config init
299 // hsic phy config init, set hsicphy_txsrtune
300 control_usb->grf_uoc3_base->CON0 = ((0xf<<6)<<16)|(0xf<<6);
302 /* other haredware init
303 * set common_on, in suspend mode, otg/host PLL blocks remain powered
307 /* change INCR to INCR16 or INCR8(beats less than 16)
308 * or INCR4(beats less than 8) or SINGLE(beats less than 4)
310 control_usb->grf_uoc4_base->CON0 = 0x00ff00bc;
313 static void rk_hsic_clock_init(void* pdata)
315 /* By default, hsicphy_480m's parent is otg phy 480MHz clk
316 * rk3188 must use host phy 480MHz clk, because if otg bypass
317 * to uart mode, otg phy 480MHz clk will be closed automatically
320 struct rkehci_platform_data *usbpdata=pdata;
321 struct clk *ahbclk, *phyclk480m_hsic, *phyclk12m_hsic, *phyclk_otgphy1;
323 phyclk480m_hsic = devm_clk_get(usbpdata->dev, "hsicphy480m");
324 if (IS_ERR(phyclk480m_hsic)) {
325 dev_err(usbpdata->dev, "Failed to get hsicphy480m\n");
329 phyclk12m_hsic = devm_clk_get(usbpdata->dev, "hsicphy12m");
330 if (IS_ERR(phyclk12m_hsic)) {
331 dev_err(usbpdata->dev, "Failed to get hsicphy12m\n");
335 phyclk_otgphy1 = devm_clk_get(usbpdata->dev, "hsic_otgphy1");
336 if (IS_ERR(phyclk_otgphy1)) {
337 dev_err(usbpdata->dev, "Failed to get hsic_otgphy1\n");
341 ahbclk = devm_clk_get(usbpdata->dev, "hclk_hsic");
342 if (IS_ERR(ahbclk)) {
343 dev_err(usbpdata->dev, "Failed to get hclk_hsic\n");
347 clk_set_parent(phyclk480m_hsic, phyclk_otgphy1);
349 usbpdata->hclk_hsic = ahbclk;
350 usbpdata->hsic_phy_480m = phyclk480m_hsic;
351 usbpdata->hsic_phy_12m = phyclk12m_hsic;
355 static void rk_hsic_clock_enable(void* pdata, int enable)
358 struct rkehci_platform_data *usbpdata=pdata;
360 if(enable == usbpdata->clk_status)
363 clk_prepare_enable(usbpdata->hclk_hsic);
364 clk_prepare_enable(usbpdata->hsic_phy_480m);
365 clk_prepare_enable(usbpdata->hsic_phy_12m);
366 usbpdata->clk_status = 1;
368 clk_disable_unprepare(usbpdata->hclk_hsic);
369 clk_disable_unprepare(usbpdata->hsic_phy_480m);
370 clk_disable_unprepare(usbpdata->hsic_phy_12m);
371 usbpdata->clk_status = 0;
376 static void rk_hsic_soft_reset(void)
380 struct rkehci_platform_data rkhsic_pdata_rk3288 = {
382 .hsic_phy_12m = NULL,
383 .hsic_phy_480m = NULL,
385 .hw_init = rk_hsic_hw_init,
386 .clock_init = rk_hsic_clock_init,
387 .clock_enable = rk_hsic_clock_enable,
388 .soft_reset = rk_hsic_soft_reset,
389 .get_chip_id = usb_get_chip_id,
393 #ifdef CONFIG_USB_EHCI_RK
394 static void rk_ehci_hw_init(void)
399 static void rk_ehci_clock_init(void* pdata)
404 static void rk_ehci_clock_enable(void* pdata, int enable)
409 static void rk_ehci_soft_reset(void)
414 struct rkehci_platform_data rkehci_pdata_rk3288 = {
418 .hw_init = rk_ehci_hw_init,
419 .clock_init = rk_ehci_clock_init,
420 .clock_enable = rk_ehci_clock_enable,
421 .soft_reset = rk_ehci_soft_reset,
422 .get_chip_id = usb_get_chip_id,
426 #ifdef CONFIG_USB_OHCI_HCD_RK
427 static void rk_ohci_hw_init(void)
431 static void rk_ohci_clock_init(void* pdata)
435 static void rk_ohci_clock_enable(void* pdata, int enable)
439 static void rk_ohci_soft_reset(void)
443 struct rkehci_platform_data rkohci_pdata_rk3288 = {
447 .hw_init = rk_ohci_hw_init,
448 .clock_init = rk_ohci_clock_init,
449 .clock_enable = rk_ohci_clock_enable,
450 .soft_reset = rk_ohci_soft_reset,
451 .get_chip_id = usb_get_chip_id,
455 /*********************************************************************
456 rk3288 usb detections
457 *********************************************************************/
459 #ifdef CONFIG_RK_USB_DETECT_BY_OTG_BVALID
460 #define WAKE_LOCK_TIMEOUT (HZ * 10)
461 inline static void do_wakeup(struct work_struct *work)
463 // rk28_send_wakeup_key();
467 /********** handler for bvalid irq **********/
468 static irqreturn_t bvalid_irq_handler(int irq, void *dev_id)
471 control_usb->grf_uoc0_base->CON4 = (0x0008 | (0x0008 << 16));
473 #ifdef CONFIG_RK_USB_UART
474 /* usb otg dp/dm switch to usb phy */
475 dwc_otg_uart_mode(NULL, PHY_USB_MODE);
478 #ifdef CONFIG_RK_USB_DETECT_BY_OTG_BVALID
479 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
480 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
486 /***** handler for otg id rise and fall edge *****/
487 static irqreturn_t id_irq_handler(int irq, void *dev_id)
489 unsigned int uoc_con;
492 uoc_con = control_usb->grf_uoc0_base->CON4;
494 if(uoc_con & (1<<5))//id rise
496 control_usb->grf_uoc0_base->CON4 = ((1<<5)|(1<<21)); //clear id rise irq pandding
499 if(uoc_con & (1<<7))//id fall
501 #ifdef CONFIG_RK_USB_UART
502 /* usb otg dp/dm switch to usb phy */
503 dwc_otg_uart_mode(NULL, PHY_USB_MODE);
505 control_usb->grf_uoc0_base->CON4 = ((1<<7)|(1<<23));//clear id fall irq pandding
508 schedule_delayed_work(&control_usb->usb_wakelock, HZ/10);
512 /***** handler for otg line status change *****/
514 static irqreturn_t line_irq_handler(int irq, void *dev_id)
516 unsigned int uoc_con;
519 if(control_usb->grf_uoc0_base->CON0 & 1<<15){
520 control_usb->grf_uoc0_base->CON0 = (1<<15 | 1<<31);
523 if(control_usb->grf_uoc1_base->CON0 & 1<<15){
524 control_usb->grf_uoc1_base->CON0 = (1<<15 | 1<<31);
527 if(control_usb->grf_uoc2_base->CON0 & 1<<15){
528 control_usb->grf_uoc2_base->CON0 = (1<<15 | 1<<31);
531 //schedule_delayed_work(&usb_det_wakeup_work, HZ/10);
535 /************* register usb detection irqs **************/
536 static int otg_irq_detect_init(struct platform_device *pdev)
541 #ifdef CONFIG_RK_USB_DETECT_BY_OTG_BVALID
542 wake_lock_init(&control_usb->usb_wakelock, WAKE_LOCK_SUSPEND, "usb_detect");
543 INIT_DELAYED_WORK(&control_usb->usb_det_wakeup_work, do_wakeup);
546 /*register otg_bvalid irq*/
547 irq = platform_get_irq_byname(pdev, "otg_bvalid");
549 ret = request_irq(irq, bvalid_irq_handler, 0, "otg_bvalid", NULL);
551 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
553 control_usb->grf_uoc0_base->CON4 = 0x000c000c;// enable bvalid irq
556 /*register otg_id irq*/
557 irq = platform_get_irq_byname(pdev, "otg_id");
559 ret = request_irq(irq, id_irq_handler, 0, "otg_id", NULL);
561 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
563 control_usb->grf_uoc0_base->CON4 = 0x00f000f0;
566 /*register otg_linestate irq*/
567 irq = platform_get_irq_byname(pdev, "otg_linestate");
569 ret = request_irq(irq, line_irq_handler, 0, "otg_linestate", NULL);
571 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
573 control_usb->grf_uoc0_base->CON0 = 0xc000c000;
576 /*register host0_linestate irq*/
577 irq = platform_get_irq_byname(pdev, "host0_linestate");
579 ret = request_irq(irq, line_irq_handler, 0, "host0_linestate", NULL);
581 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
583 control_usb->grf_uoc1_base->CON0 = 0xc000c000;
586 /*register host1_linestate irq*/
587 irq = platform_get_irq_byname(pdev, "host1_linestate");
589 ret = request_irq(irq, line_irq_handler, 0, "host1_linestate", NULL);
591 dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
593 control_usb->grf_uoc2_base->CON0 = 0xc000c000;
599 /********** end of rk3288 usb detections **********/
601 static int usb_grf_ioremap(struct platform_device *pdev)
604 struct resource *res;
605 void *grf_soc_status1;
606 void *grf_soc_status2;
607 void *grf_soc_status19;
608 void *grf_soc_status21;
615 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
617 grf_soc_status1 = devm_ioremap_resource(&pdev->dev, res);
618 if (IS_ERR(grf_soc_status1)){
619 ret = PTR_ERR(grf_soc_status1);
622 control_usb->grf_soc_status1_rk3288 = (pGRF_SOC_STATUS1_RK3288)grf_soc_status1;
624 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
626 grf_soc_status2 = devm_ioremap_resource(&pdev->dev, res);
627 if (IS_ERR(grf_soc_status2)){
628 ret = PTR_ERR(grf_soc_status2);
631 control_usb->grf_soc_status2_rk3288 = (pGRF_SOC_STATUS2_RK3288)grf_soc_status2;
633 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
635 grf_soc_status19 = devm_ioremap_resource(&pdev->dev, res);
636 if (IS_ERR(grf_soc_status19)){
637 ret = PTR_ERR(grf_soc_status19);
640 control_usb->grf_soc_status19_rk3288 = (pGRF_SOC_STATUS19_RK3288)grf_soc_status19;
642 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
644 grf_soc_status21 = devm_ioremap_resource(&pdev->dev, res);
645 if (IS_ERR(grf_soc_status21)){
646 ret = PTR_ERR(grf_soc_status21);
649 control_usb->grf_soc_status21_rk3288 = (pGRF_SOC_STATUS21_RK3288)grf_soc_status21;
651 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
653 grf_uoc0_base = devm_ioremap_resource(&pdev->dev, res);
654 if (IS_ERR(grf_uoc0_base)){
655 ret = PTR_ERR(grf_uoc0_base);
658 control_usb->grf_uoc0_base = (pGRF_UOC0_REG)grf_uoc0_base;
660 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
662 grf_uoc1_base = devm_ioremap_resource(&pdev->dev, res);
663 if (IS_ERR(grf_uoc1_base)){
664 ret = PTR_ERR(grf_uoc1_base);
667 control_usb->grf_uoc1_base = (pGRF_UOC1_REG)grf_uoc1_base;
669 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
671 grf_uoc2_base = devm_ioremap_resource(&pdev->dev, res);
672 if (IS_ERR(grf_uoc2_base)){
673 ret = PTR_ERR(grf_uoc2_base);
676 control_usb->grf_uoc2_base = (pGRF_UOC2_REG)grf_uoc2_base;
678 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
680 grf_uoc3_base = devm_ioremap_resource(&pdev->dev, res);
681 if (IS_ERR(grf_uoc3_base)){
682 ret = PTR_ERR(grf_uoc3_base);
685 control_usb->grf_uoc3_base = (pGRF_UOC3_REG)grf_uoc3_base;
687 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
689 grf_uoc4_base = devm_ioremap_resource(&pdev->dev, res);
690 if (IS_ERR(grf_uoc4_base)){
691 ret = PTR_ERR(grf_uoc4_base);
694 control_usb->grf_uoc4_base = (pGRF_UOC4_REG)grf_uoc4_base;
701 static const struct of_device_id dwc_otg_control_usb_id_table[] = {
703 .compatible = "rockchip,rk3288-dwc-control-usb",
710 static int dwc_otg_control_usb_probe(struct platform_device *pdev)
713 struct device_node *np = pdev->dev.of_node;
714 // struct clk* hclk_usb_peri;
717 control_usb = devm_kzalloc(&pdev->dev, sizeof(*control_usb),GFP_KERNEL);
719 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
724 control_usb->chip_id = RK3288_USB_CTLR;
726 hclk_usb_peri = devm_clk_get(&pdev->dev, "hclk_usb_peri");
727 if (IS_ERR(hclk_usb_peri)) {
728 dev_err(&pdev->dev, "Failed to get hclk_usb_peri\n");
733 control_usb->hclk_usb_peri = hclk_usb_peri;
734 clk_prepare_enable(hclk_usb_peri);
736 ret = usb_grf_ioremap(pdev);
738 dev_err(&pdev->dev, "Failed to ioremap usb grf\n");
742 control_usb->host_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
744 gpio = of_get_named_gpio(np, "gpios", 0);
745 if(!gpio_is_valid(gpio)){
746 dev_err(&pdev->dev, "invalid host gpio%d\n", gpio);
750 control_usb->host_gpios->gpio = gpio;
751 err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio");
754 "failed to request GPIO%d for host_drv\n",
760 control_usb->otg_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
762 gpio = of_get_named_gpio(np, "gpios", 1);
763 if(!gpio_is_valid(gpio)){
764 dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio);
768 control_usb->otg_gpios->gpio = gpio;
769 err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio");
772 "failed to request GPIO%d for otg_drv\n",
778 ret = otg_irq_detect_init(pdev);
786 // clk_disable_unprepare(hclk_usb_peri);
791 static int dwc_otg_control_usb_remove(struct platform_device *pdev)
794 // clk_disable_unprepare(control_usb->hclk_usb_peri);
798 static struct platform_driver dwc_otg_control_usb_driver = {
799 .probe = dwc_otg_control_usb_probe,
800 .remove = dwc_otg_control_usb_remove,
802 .name = "rk3288-dwc-control-usb",
803 .owner = THIS_MODULE,
804 .of_match_table = of_match_ptr(dwc_otg_control_usb_id_table),
808 static int __init dwc_otg_control_usb_init(void)
810 return platform_driver_register(&dwc_otg_control_usb_driver);
813 subsys_initcall(dwc_otg_control_usb_init);
815 static void __exit dwc_otg_control_usb_exit(void)
817 platform_driver_unregister(&dwc_otg_control_usb_driver);
820 module_exit(dwc_otg_control_usb_exit);
821 MODULE_ALIAS("platform: dwc_control_usb");
822 MODULE_AUTHOR("RockChip Inc.");
823 MODULE_DESCRIPTION("RockChip Control Module USB Driver");
824 MODULE_LICENSE("GPL v2");