drivers/usb/dwc_otg_310/usbdev_rk32.c

   1
   2 #include "usbdev_rk.h"
   3 #include "usbdev_grf_regs.h"
   4 #include "dwc_otg_regs.h"
   5 static struct dwc_otg_control_usb *control_usb;
   6
   7 #ifdef CONFIG_USB20_OTG
   8 static void usb20otg_hw_init(void)
   9 {
  10 #ifndef CONFIG_USB20_HOST
  11         //enable soft control
  12         control_usb->grf_uoc2_base->CON2 = (0x01<<2)|((0x01<<2)<<16);
  13         // enter suspend
  14         control_usb->grf_uoc2_base->CON3 = 0x2A|(0x3F<<16);
  15 #endif
  16         /* usb phy config init
  17          * usb phy enter usb mode */
  18         control_usb->grf_uoc0_base->CON3 = (0x00c0 << 16);
  19
  20         /* other haredware init,include:
  21          * DRV_VBUS GPIO init */
  22 //      gpio_direction_output(control_usb->otg_gpios->gpio, 0);
  23
  24 }
  25
  26 static void usb20otg_phy_suspend(void* pdata, int suspend)
  27 {
  28         struct dwc_otg_platform_data *usbpdata=pdata;
  29
  30         if(suspend){
  31                 //enable soft control
  32                 control_usb->grf_uoc0_base->CON2 = (0x01<<2)|((0x01<<2)<<16);
  33                 //enter suspend
  34                 control_usb->grf_uoc0_base->CON3 = 0x2A|(0x3F<<16);
  35                 usbpdata->phy_status = 1;
  36         }else{
  37                 // exit suspend.
  38                 control_usb->grf_uoc0_base->CON2 = ((0x01<<2)<<16);
  39                 usbpdata->phy_status = 0;
  40         }
  41 }
  42
  43 static void usb20otg_soft_reset(void)
  44 {
  45 }
  46
  47 static void usb20otg_clock_init(void* pdata)
  48 {
  49         /*
  50         struct dwc_otg_platform_data *usbpdata=pdata;
  51         struct clk* ahbclk,*phyclk;
  52
  53         ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb0");
  54         if (IS_ERR(ahbclk)) {
  55                 dev_err(usbpdata->dev, "Failed to get hclk_usb0\n");
  56                 return;
  57         }
  58
  59         phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy0");
  60         if (IS_ERR(phyclk)) {
  61                 dev_err(usbpdata->dev, "Failed to get clk_usbphy0\n");
  62                 return;
  63         }
  64
  65         usbpdata->phyclk = phyclk;
  66         usbpdata->ahbclk = ahbclk;
  67         */
  68 }
  69
  70 static void usb20otg_clock_enable(void* pdata, int enable)
  71 {
  72         /*
  73         struct dwc_otg_platform_data *usbpdata=pdata;
  74
  75         if(enable){
  76                 clk_prepare_enable(usbpdata->ahbclk);
  77                 clk_prepare_enable(usbpdata->phyclk);
  78         }else{
  79                 clk_disable_unprepare(usbpdata->ahbclk);
  80                 clk_disable_unprepare(usbpdata->phyclk);
  81         }*/
  82 }
  83
  84 static int usb20otg_get_status(int id)
  85 {
  86         int ret = -1;
  87
  88         switch(id){
  89                 case USB_STATUS_BVABLID:
  90                         // bvalid in grf
  91                         ret = control_usb->grf_soc_status2_rk3288->otg_bvalid;
  92                         break;
  93                 case USB_STATUS_DPDM:
  94                         // dpdm in grf
  95                         ret = control_usb->grf_soc_status2_rk3288->otg_linestate;
  96                         break;
  97                 case USB_STATUS_ID:
  98                         // id in grf
  99                         ret = control_usb->grf_soc_status2_rk3288->otg_iddig;
 100                         break;
 101                 case USB_CHIP_ID:
 102                         ret = control_usb->chip_id;
 103                         break;
 104                 case USB_REMOTE_WAKEUP:
 105                         ret = control_usb->remote_wakeup;
 106                         break;
 107                 case USB_IRQ_WAKEUP:
 108                         ret = control_usb->usb_irq_wakeup;
 109                         break;
 110                 default:
 111                         break;
 112         }
 113
 114         return ret;
 115 }
 116
 117 #ifdef CONFIG_RK_USB_UART
 118 static void dwc_otg_uart_mode(void* pdata, int enter_usb_uart_mode)
 119 {
 120         if(1 == enter_usb_uart_mode){
 121                 /* bypass dm, enter uart mode*/
 122                 control_usb->grf_uoc0_base->CON3 = (0x00c0 | (0x00c0 << 16));
 123
 124         }else if(0 == enter_usb_uart_mode){
 125                 /* enter usb mode */
 126                 control_usb->grf_uoc0_base->CON3 = (0x00c0 << 16);
 127         }
 128 }
 129 #endif
 130
 131 static void usb20otg_power_enable(int enable)
 132 {       /*
 133         if(0 == enable){//disable otg_drv power
 134                 gpio_set_value(control_usb->otg_gpios->gpio, 0);
 135         }else if(1 == enable){//enable otg_drv power
 136                 gpio_set_value(control_usb->otg_gpios->gpio, 1);
 137         }*/
 138 }
 139
 140
 141 struct dwc_otg_platform_data usb20otg_pdata_rk3288 = {
 142         .phyclk = NULL,
 143         .ahbclk = NULL,
 144         .busclk = NULL,
 145         .phy_status = 0,
 146         .hw_init = usb20otg_hw_init,
 147         .phy_suspend = usb20otg_phy_suspend,
 148         .soft_reset = usb20otg_soft_reset,
 149         .clock_init = usb20otg_clock_init,
 150         .clock_enable = usb20otg_clock_enable,
 151         .get_status = usb20otg_get_status,
 152         .power_enable = usb20otg_power_enable,
 153 #ifdef CONFIG_RK_USB_UART
 154         .dwc_otg_uart_mode = dwc_otg_uart_mode,
 155 #endif
 156     .bc_detect_cb=usb20otg_battery_charger_detect_cb,
 157 };
 158
 159 #endif
 160
 161 #ifdef CONFIG_USB20_HOST
 162
 163 static void usb20host_hw_init(void)
 164 {
 165         /* usb phy config init */
 166
 167         /* other haredware init,include:
 168          * DRV_VBUS GPIO init */
 169 //      gpio_direction_output(control_usb->host_gpios->gpio, 1);
 170 }
 171
 172 static void usb20host_phy_suspend(void* pdata, int suspend)
 173 {
 174         struct dwc_otg_platform_data *usbpdata=pdata;
 175
 176         if(suspend){
 177                 // enable soft control
 178                 control_usb->grf_uoc2_base->CON2 = (0x01<<2)|((0x01<<2)<<16);
 179                 // enter suspend
 180                 control_usb->grf_uoc2_base->CON3 = 0x2A|(0x3F<<16);
 181                 usbpdata->phy_status = 1;
 182         }else{
 183                 //exit suspend.
 184                 control_usb->grf_uoc2_base->CON2 = ((0x01<<2)<<16);
 185                 usbpdata->phy_status = 0;
 186         }
 187 }
 188
 189 static void usb20host_soft_reset(void)
 190 {
 191 }
 192
 193 static void usb20host_clock_init(void* pdata)
 194 {
 195         /*
 196         struct dwc_otg_platform_data *usbpdata=pdata;
 197         struct clk* ahbclk,*phyclk;
 198
 199         ahbclk = devm_clk_get(usbpdata->dev, "hclk_usb1");
 200         if (IS_ERR(ahbclk)) {
 201                 dev_err(usbpdata->dev, "Failed to get hclk_usb1\n");
 202                 return;
 203         }
 204
 205         phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy1");
 206         if (IS_ERR(phyclk)) {
 207                 dev_err(usbpdata->dev, "Failed to get clk_usbphy1\n");
 208                 return;
 209         }
 210
 211         usbpdata->phyclk = phyclk;
 212         usbpdata->ahbclk = ahbclk;
 213         */
 214 }
 215
 216 static void usb20host_clock_enable(void* pdata, int enable)
 217 {
 218         /*
 219         struct dwc_otg_platform_data *usbpdata=pdata;
 220
 221         if(enable){
 222                 clk_prepare_enable(usbpdata->ahbclk);
 223                 clk_prepare_enable(usbpdata->phyclk);
 224         }else{
 225                 clk_disable_unprepare(usbpdata->ahbclk);
 226                 clk_disable_unprepare(usbpdata->phyclk);
 227         }
 228         */
 229 }
 230
 231 static int usb20host_get_status(int id)
 232 {
 233         int ret = -1;
 234
 235         switch(id){
 236                 case USB_STATUS_BVABLID:
 237                         // bvalid in grf
 238                         ret = control_usb->grf_soc_status2_rk3288->host1_bvalid;
 239                         break;
 240                 case USB_STATUS_DPDM:
 241                         // dpdm in grf
 242                         ret = control_usb->grf_soc_status2_rk3288->host1_linestate;
 243                         break;
 244                 case USB_STATUS_ID:
 245                         // id in grf
 246                         ret = control_usb->grf_soc_status2_rk3288->host1_iddig;
 247                         break;
 248                 case USB_CHIP_ID:
 249                         ret = control_usb->chip_id;
 250                         break;
 251                 case USB_REMOTE_WAKEUP:
 252                         ret = control_usb->remote_wakeup;
 253                         break;
 254                 case USB_IRQ_WAKEUP:
 255                         ret = control_usb->usb_irq_wakeup;
 256                         break;
 257                 default:
 258                         break;
 259         }
 260
 261         return ret;
 262 }
 263
 264 static void usb20host_power_enable(int enable)
 265 {       /*
 266         if(0 == enable){//disable host_drv power
 267                 //do not disable power in default
 268         }else if(1 == enable){//enable host_drv power
 269                 gpio_set_value(control_usb->host_gpios->gpio, 1);
 270         }*/
 271 }
 272
 273
 274 struct dwc_otg_platform_data usb20host_pdata_rk3288 = {
 275         .phyclk = NULL,
 276         .ahbclk = NULL,
 277         .busclk = NULL,
 278         .phy_status = 0,
 279         .hw_init = usb20host_hw_init,
 280         .phy_suspend = usb20host_phy_suspend,
 281         .soft_reset = usb20host_soft_reset,
 282         .clock_init = usb20host_clock_init,
 283         .clock_enable = usb20host_clock_enable,
 284         .get_status = usb20host_get_status,
 285         .power_enable = usb20host_power_enable,
 286 };
 287
 288 #endif
 289
 290 #ifdef CONFIG_USB_EHCI_RKHSIC
 291 static void rk_hsic_hw_init(void)
 292 {
 293         // usb phy config init
 294         // hsic phy config init, set hsicphy_txsrtune
 295         control_usb->grf_uoc3_base->CON0 = ((0xf<<6)<<16)|(0xf<<6);
 296
 297         /* other haredware init
 298          * set common_on, in suspend mode, otg/host PLL blocks remain powered
 299          */
 300
 301
 302         /* change INCR to INCR16 or INCR8(beats less than 16)
 303          * or INCR4(beats less than 8) or SINGLE(beats less than 4)
 304          */
 305         control_usb->grf_uoc4_base->CON0 = 0x00ff00bc;
 306 }
 307
 308 static void rk_hsic_clock_init(void* pdata)
 309 {
 310         /* By default, hsicphy_480m's parent is otg phy 480MHz clk
 311          * rk3188 must use host phy 480MHz clk, because if otg bypass
 312          * to uart mode, otg phy 480MHz clk will be closed automatically
 313          */
 314         /*
 315         struct rkehci_platform_data *usbpdata=pdata;
 316         struct clk *ahbclk, *phyclk480m_hsic, *phyclk12m_hsic, *phyclk_usbphy1;
 317
 318         phyclk480m_hsic = devm_clk_get(usbpdata->dev, "hsicphy_480m");
 319         if (IS_ERR(phyclk480m_hsic)) {
 320                 dev_err(usbpdata->dev, "Failed to get hsicphy_480m\n");
 321                 return;
 322         }
 323
 324         phyclk12m_hsic = devm_clk_get(usbpdata->dev, "hsicphy_12m");
 325         if (IS_ERR(phyclk12m_hsic)) {
 326                 dev_err(usbpdata->dev, "Failed to get hsicphy_12m\n");
 327                 return;
 328         }
 329
 330         phyclk_usbphy1 = devm_clk_get(usbpdata->dev, "hsic_usbphy1");
 331         if (IS_ERR(phyclk_usbphy1)) {
 332                 dev_err(usbpdata->dev, "Failed to get hsic_usbphy1\n");
 333                 return;
 334         }
 335
 336         ahbclk = devm_clk_get(usbpdata->dev, "hclk_hsic");
 337         if (IS_ERR(ahbclk)) {
 338                 dev_err(usbpdata->dev, "Failed to get hclk_hsic\n");
 339                 return;
 340         }
 341
 342         clk_set_parent(phyclk480m_hsic, phyclk_usbphy1);
 343
 344         usbpdata->hclk_hsic = ahbclk;
 345         usbpdata->hsic_phy_480m = phyclk480m_hsic;
 346         usbpdata->hsic_phy_12m = phyclk12m_hsic;
 347         */
 348 }
 349
 350 static void rk_hsic_clock_enable(void* pdata, int enable)
 351 {
 352         /*
 353         struct rkehci_platform_data *usbpdata=pdata;
 354
 355         if(enable == usbpdata->clk_status)
 356                 return;
 357         if(enable){
 358                 clk_prepare_enable(usbpdata->hclk_hsic);
 359                 clk_prepare_enable(usbpdata->hsic_phy_480m);
 360                 clk_prepare_enable(usbpdata->hsic_phy_12m);
 361                 usbpdata->clk_status = 1;
 362         }else{
 363                 clk_disable_unprepare(usbpdata->hclk_hsic);
 364                 clk_disable_unprepare(usbpdata->hsic_phy_480m);
 365                 clk_disable_unprepare(usbpdata->hsic_phy_12m);
 366                 usbpdata->clk_status = 0;
 367         }
 368         */
 369 }
 370
 371 static void rk_hsic_soft_reset(void)
 372 {
 373 }
 374
 375 struct rkehci_platform_data rkhsic_pdata_rk3288 = {
 376         .hclk_hsic = NULL,
 377         .hsic_phy_12m = NULL,
 378         .hsic_phy_480m = NULL,
 379         .clk_status = -1,
 380         .hw_init = rk_hsic_hw_init,
 381         .clock_init = rk_hsic_clock_init,
 382         .clock_enable = rk_hsic_clock_enable,
 383         .soft_reset = rk_hsic_soft_reset,
 384 };
 385 #endif
 386
 387 #ifdef CONFIG_USB_EHCI_RK
 388 static void rk_ehci_hw_init(void)
 389 {
 390
 391 }
 392
 393 static void rk_ehci_clock_init(void* pdata)
 394 {
 395
 396 }
 397
 398 static void rk_ehci_clock_enable(void* pdata, int enable)
 399 {
 400
 401 }
 402
 403 static void rk_ehci_soft_reset(void)
 404 {
 405
 406 }
 407
 408 struct rkehci_platform_data rkehci_pdata_rk3288 = {
 409         .phyclk = NULL,
 410         .ahbclk = NULL,
 411         .clk_status = -1,
 412         .hw_init = rk_ehci_hw_init,
 413         .clock_init = rk_ehci_clock_init,
 414         .clock_enable = rk_ehci_clock_enable,
 415         .soft_reset = rk_ehci_soft_reset,
 416 };
 417 #endif
 418
 419 #ifdef CONFIG_USB_OHCI_HCD_RK
 420 static void rk_ohci_hw_init(void)
 421 {
 422 }
 423
 424 static void rk_ohci_clock_init(void* pdata)
 425 {
 426 }
 427
 428 static void rk_ohci_clock_enable(void* pdata, int enable)
 429 {
 430 }
 431
 432 static void rk_ohci_soft_reset(void)
 433 {
 434 }
 435
 436 struct rkehci_platform_data rkohci_pdata_rk3288 = {
 437         .phyclk = NULL,
 438         .ahbclk = NULL,
 439         .clk_status = -1,
 440         .hw_init = rk_ohci_hw_init,
 441         .clock_init = rk_ohci_clock_init,
 442         .clock_enable = rk_ohci_clock_enable,
 443         .soft_reset = rk_ohci_soft_reset,
 444 };
 445 #endif
 446
 447 /*********************************************************************
 448                         rk3288 usb detections
 449 *********************************************************************/
 450
 451 #define WAKE_LOCK_TIMEOUT (HZ * 10)
 452 inline static void do_wakeup(struct work_struct *work)
 453 {
 454 //      rk28_send_wakeup_key();
 455 }
 456
 457 /********** handler for bvalid irq **********/
 458 static irqreturn_t bvalid_irq_handler(int irq, void *dev_id)
 459 {
 460         /* clear irq */
 461         control_usb->grf_uoc0_base->CON4 = (0x0008 | (0x0008 << 16));
 462
 463 #ifdef CONFIG_RK_USB_UART
 464         /* usb otg dp/dm switch to usb phy */
 465         dwc_otg_uart_mode(NULL, PHY_USB_MODE);
 466 #endif
 467
 468         if(control_usb->usb_irq_wakeup){
 469                 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
 470                 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
 471         }
 472         return IRQ_HANDLED;
 473 }
 474
 475 /***** handler for otg id rise and fall edge *****/
 476 static irqreturn_t id_irq_handler(int irq, void *dev_id)
 477 {
 478     unsigned int uoc_con;
 479
 480      /* clear irq */
 481     uoc_con = control_usb->grf_uoc0_base->CON4;
 482
 483     if(uoc_con & (1<<5))//id rise
 484     {
 485         control_usb->grf_uoc0_base->CON4 = ((1<<5)|(1<<21)); //clear id rise irq pandding
 486     }
 487
 488     if(uoc_con & (1<<7))//id fall
 489     {
 490 #ifdef CONFIG_RK_USB_UART
 491         /* usb otg dp/dm switch to usb phy */
 492         dwc_otg_uart_mode(NULL, PHY_USB_MODE);
 493 #endif
 494         control_usb->grf_uoc0_base->CON4 = ((1<<7)|(1<<23));//clear id fall irq pandding
 495     }
 496
 497         if(control_usb->usb_irq_wakeup){
 498                 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
 499                 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
 500         }
 501
 502     return IRQ_HANDLED;
 503 }
 504
 505 /***** handler for otg line status change *****/
 506
 507 static irqreturn_t line_irq_handler(int irq, void *dev_id)
 508 {
 509     unsigned int uoc_con;
 510     /* clear irq */
 511
 512     if(control_usb->grf_uoc0_base->CON0 & 1<<15){
 513         control_usb->grf_uoc0_base->CON0 = (1<<15 | 1<<31);
 514     }
 515
 516     if(control_usb->grf_uoc1_base->CON0 & 1<<15){
 517         control_usb->grf_uoc1_base->CON0 = (1<<15 | 1<<31);
 518     }
 519
 520     if(control_usb->grf_uoc2_base->CON0 & 1<<15){
 521         control_usb->grf_uoc2_base->CON0 = (1<<15 | 1<<31);
 522     }
 523
 524         if(control_usb->usb_irq_wakeup){
 525                 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
 526                 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
 527         }
 528
 529     return IRQ_HANDLED;
 530 }
 531
 532 /************* register usb detection irqs **************/
 533 static int otg_irq_detect_init(struct platform_device *pdev)
 534 {
 535         int ret = 0;
 536         int irq = 0;
 537
 538         if(control_usb->usb_irq_wakeup){
 539                 wake_lock_init(&control_usb->usb_wakelock, WAKE_LOCK_SUSPEND, "usb_detect");
 540                 INIT_DELAYED_WORK(&control_usb->usb_det_wakeup_work, do_wakeup);
 541         }
 542
 543     /*register otg_bvalid irq*/
 544         irq = platform_get_irq_byname(pdev, "otg_bvalid");
 545         if (irq > 0) {
 546                 ret = request_irq(irq, bvalid_irq_handler, 0, "otg_bvalid", NULL);
 547                 if(ret < 0){
 548                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 549                         return ret;
 550                 }else{
 551                     control_usb->grf_uoc0_base->CON4 = 0x000c000c;// enable bvalid irq
 552                         if(control_usb->usb_irq_wakeup){
 553                                         enable_irq_wake(irq);
 554                         }
 555                 }
 556         }
 557
 558     /*register otg_id irq*/
 559     irq = platform_get_irq_byname(pdev, "otg_id");
 560     if(irq > 0){
 561         ret = request_irq(irq, id_irq_handler, 0, "otg_id", NULL);
 562         if(ret < 0){
 563                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 564                         return ret;
 565                 }else{
 566                     control_usb->grf_uoc0_base->CON4 = 0x00f000f0;
 567                         if(control_usb->usb_irq_wakeup){
 568                                         enable_irq_wake(irq);
 569                         }
 570                 }
 571     }
 572
 573     /*register otg_linestate irq*/
 574     irq = platform_get_irq_byname(pdev, "otg_linestate");
 575     if(irq > 0){
 576         ret = request_irq(irq, line_irq_handler, 0, "otg_linestate", NULL);
 577         if(ret < 0){
 578                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 579                         return ret;
 580                 }else{
 581                     control_usb->grf_uoc0_base->CON0 = 0xc000c000;
 582                         if(control_usb->usb_irq_wakeup){
 583                                         enable_irq_wake(irq);
 584                         }
 585                 }
 586     }
 587
 588     /*register host0_linestate irq*/
 589     irq = platform_get_irq_byname(pdev, "host0_linestate");
 590     if(irq > 0){
 591         ret = request_irq(irq, line_irq_handler, 0, "host0_linestate", NULL);
 592         if(ret < 0){
 593                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 594                         return ret;
 595                 }else{
 596                     control_usb->grf_uoc1_base->CON0 = 0xc000c000;
 597                         if(control_usb->usb_irq_wakeup){
 598                                         enable_irq_wake(irq);
 599                         }
 600                 }
 601     }
 602
 603     /*register host1_linestate irq*/
 604     irq = platform_get_irq_byname(pdev, "host1_linestate");
 605     if(irq > 0){
 606         ret = request_irq(irq, line_irq_handler, 0, "host1_linestate", NULL);
 607         if(ret < 0){
 608                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 609                         return ret;
 610                 }else{
 611                     control_usb->grf_uoc2_base->CON0 = 0xc000c000;
 612                         if(control_usb->usb_irq_wakeup){
 613                                         enable_irq_wake(irq);
 614                         }
 615                 }
 616     }
 617
 618         return ret;
 619 }
 620
 621 /********** end of rk3288 usb detections **********/
 622
 623 static int usb_grf_ioremap(struct platform_device *pdev)
 624 {
 625         int ret = 0;
 626         struct resource *res;
 627         void *grf_soc_status1;
 628         void *grf_soc_status2;
 629         void *grf_soc_status19;
 630         void *grf_soc_status21;
 631         void *grf_uoc0_base;
 632         void *grf_uoc1_base;
 633         void *grf_uoc2_base;
 634         void *grf_uoc3_base;
 635         void *grf_uoc4_base;
 636
 637         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 638                                                 "GRF_SOC_STATUS1");
 639         grf_soc_status1 = devm_ioremap_resource(&pdev->dev, res);
 640         if (IS_ERR(grf_soc_status1)){
 641                 ret = PTR_ERR(grf_soc_status1);
 642                 return ret;
 643         }
 644         control_usb->grf_soc_status1_rk3288 = (pGRF_SOC_STATUS1_RK3288)grf_soc_status1;
 645
 646         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 647                                                 "GRF_SOC_STATUS2");
 648         grf_soc_status2 = devm_ioremap_resource(&pdev->dev, res);
 649         if (IS_ERR(grf_soc_status2)){
 650                 ret = PTR_ERR(grf_soc_status2);
 651                 return ret;
 652         }
 653         control_usb->grf_soc_status2_rk3288 = (pGRF_SOC_STATUS2_RK3288)grf_soc_status2;
 654
 655         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 656                                                 "GRF_SOC_STATUS19");
 657         grf_soc_status19 = devm_ioremap_resource(&pdev->dev, res);
 658         if (IS_ERR(grf_soc_status19)){
 659                 ret = PTR_ERR(grf_soc_status19);
 660                 return ret;
 661         }
 662         control_usb->grf_soc_status19_rk3288 = (pGRF_SOC_STATUS19_RK3288)grf_soc_status19;
 663
 664         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 665                                                 "GRF_SOC_STATUS21");
 666         grf_soc_status21 = devm_ioremap_resource(&pdev->dev, res);
 667         if (IS_ERR(grf_soc_status21)){
 668                 ret = PTR_ERR(grf_soc_status21);
 669                 return ret;
 670         }
 671         control_usb->grf_soc_status21_rk3288 = (pGRF_SOC_STATUS21_RK3288)grf_soc_status21;
 672
 673         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 674                                                 "GRF_UOC0_BASE");
 675         grf_uoc0_base = devm_ioremap_resource(&pdev->dev, res);
 676         if (IS_ERR(grf_uoc0_base)){
 677                 ret = PTR_ERR(grf_uoc0_base);
 678                 return ret;
 679         }
 680         control_usb->grf_uoc0_base = (pGRF_UOC0_REG)grf_uoc0_base;
 681
 682         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 683                                                 "GRF_UOC1_BASE");
 684         grf_uoc1_base = devm_ioremap_resource(&pdev->dev, res);
 685         if (IS_ERR(grf_uoc1_base)){
 686                 ret = PTR_ERR(grf_uoc1_base);
 687                 return ret;
 688         }
 689         control_usb->grf_uoc1_base = (pGRF_UOC1_REG)grf_uoc1_base;
 690
 691         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 692                                                 "GRF_UOC2_BASE");
 693         grf_uoc2_base = devm_ioremap_resource(&pdev->dev, res);
 694         if (IS_ERR(grf_uoc2_base)){
 695                 ret = PTR_ERR(grf_uoc2_base);
 696                 return ret;
 697         }
 698         control_usb->grf_uoc2_base = (pGRF_UOC2_REG)grf_uoc2_base;
 699
 700         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 701                                                 "GRF_UOC3_BASE");
 702         grf_uoc3_base = devm_ioremap_resource(&pdev->dev, res);
 703         if (IS_ERR(grf_uoc3_base)){
 704                 ret = PTR_ERR(grf_uoc3_base);
 705                 return ret;
 706         }
 707         control_usb->grf_uoc3_base = (pGRF_UOC3_REG)grf_uoc3_base;
 708
 709         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 710                                                 "GRF_UOC4_BASE");
 711         grf_uoc4_base = devm_ioremap_resource(&pdev->dev, res);
 712         if (IS_ERR(grf_uoc4_base)){
 713                 ret = PTR_ERR(grf_uoc4_base);
 714                 return ret;
 715         }
 716         control_usb->grf_uoc4_base = (pGRF_UOC4_REG)grf_uoc4_base;
 717
 718         return ret;
 719 }
 720
 721 #ifdef CONFIG_OF
 722
 723 static const struct of_device_id dwc_otg_control_usb_id_table[] = {
 724         {
 725                 .compatible = "rockchip,rk3288-dwc-control-usb",
 726         },
 727         { },
 728 };
 729
 730 #endif
 731
 732 static int dwc_otg_control_usb_probe(struct platform_device *pdev)
 733 {
 734         int gpio, err;
 735         struct device_node *np = pdev->dev.of_node;
 736 //      struct clk* hclk_usb_peri;
 737         int ret = 0;
 738
 739         control_usb = devm_kzalloc(&pdev->dev, sizeof(*control_usb),GFP_KERNEL);
 740         if (!control_usb) {
 741                 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
 742                 ret =  -ENOMEM;
 743                 goto err1;
 744         }
 745
 746         control_usb->chip_id = RK3288_USB_CTLR;
 747         control_usb->remote_wakeup = of_property_read_bool(np,
 748                 "rockchip,remote_wakeup");
 749         control_usb->usb_irq_wakeup = of_property_read_bool(np,
 750                 "rockchip,usb_irq_wakeup");
 751
 752 /*      disable for debug
 753         hclk_usb_peri = devm_clk_get(&pdev->dev, "hclk_usb_peri");
 754         if (IS_ERR(hclk_usb_peri)) {
 755                 dev_err(&pdev->dev, "Failed to get hclk_usb_peri\n");
 756                 ret = -EINVAL;
 757                 goto err1;
 758         }
 759
 760         control_usb->hclk_usb_peri = hclk_usb_peri;
 761         clk_prepare_enable(hclk_usb_peri);
 762 */
 763         ret = usb_grf_ioremap(pdev);
 764         if(ret){
 765                 dev_err(&pdev->dev, "Failed to ioremap usb grf\n");
 766                 goto err2;
 767         }
 768 /*
 769         control_usb->host_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
 770
 771         gpio =  of_get_named_gpio(np, "gpios", 0);
 772         if(!gpio_is_valid(gpio)){
 773                 dev_err(&pdev->dev, "invalid host gpio%d\n", gpio);
 774                 ret = -EINVAL;
 775                 goto err2;
 776         }
 777         control_usb->host_gpios->gpio = gpio;
 778         err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio");
 779         if (err) {
 780                 dev_err(&pdev->dev,
 781                         "failed to request GPIO%d for host_drv\n",
 782                         gpio);
 783                 ret = err;
 784                 goto err2;
 785         }
 786
 787         control_usb->otg_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
 788
 789         gpio =  of_get_named_gpio(np, "gpios", 1);
 790         if(!gpio_is_valid(gpio)){
 791                 dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio);
 792                 ret = -EINVAL;
 793                 goto err2;
 794         }
 795         control_usb->otg_gpios->gpio = gpio;
 796         err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio");
 797         if (err) {
 798                 dev_err(&pdev->dev,
 799                         "failed to request GPIO%d for otg_drv\n",
 800                         gpio);
 801                 ret = err;
 802                 goto err2;
 803         }
 804 */
 805 /* disable for debug
 806         ret = otg_irq_detect_init(pdev);
 807         if (ret < 0)
 808                 goto err2;
 809 */
 810         return 0;
 811
 812 err2:
 813 //      disable for debug
 814 //      clk_disable_unprepare(hclk_usb_peri);
 815 err1:
 816         return ret;
 817 }
 818
 819 static int dwc_otg_control_usb_remove(struct platform_device *pdev)
 820 {
 821 //      disable for debug
 822 //      clk_disable_unprepare(control_usb->hclk_usb_peri);
 823         return 0;
 824 }
 825
 826 static struct platform_driver dwc_otg_control_usb_driver = {
 827         .probe          = dwc_otg_control_usb_probe,
 828         .remove         = dwc_otg_control_usb_remove,
 829         .driver         = {
 830                 .name   = "rk3288-dwc-control-usb",
 831                 .owner  = THIS_MODULE,
 832                 .of_match_table = of_match_ptr(dwc_otg_control_usb_id_table),
 833         },
 834 };
 835
 836 static int __init dwc_otg_control_usb_init(void)
 837 {
 838         return platform_driver_register(&dwc_otg_control_usb_driver);
 839 }
 840
 841 subsys_initcall(dwc_otg_control_usb_init);
 842
 843 static void __exit dwc_otg_control_usb_exit(void)
 844 {
 845         platform_driver_unregister(&dwc_otg_control_usb_driver);
 846 }
 847
 848 module_exit(dwc_otg_control_usb_exit);
 849 MODULE_ALIAS("platform: dwc_control_usb");
 850 MODULE_AUTHOR("RockChip Inc.");
 851 MODULE_DESCRIPTION("RockChip Control Module USB Driver");
 852 MODULE_LICENSE("GPL v2");