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