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, in suspend mode, otg/host PLL blocks remain powered
 302          */
 303
 304
 305         /* change INCR to INCR16 or INCR8(beats less than 16)
 306          * or INCR4(beats less than 8) or SINGLE(beats less than 4)
 307          */
 308         control_usb->grf_uoc4_base->CON0 = 0x00ff00bc;
 309 }
 310
 311 static void rk_hsic_clock_init(void* pdata)
 312 {
 313         /* By default, hsicphy_480m's parent is otg phy 480MHz clk
 314          * rk3188 must use host phy 480MHz clk, because if otg bypass
 315          * to uart mode, otg phy 480MHz clk will be closed automatically
 316          */
 317         /*
 318         struct rkehci_platform_data *usbpdata=pdata;
 319         struct clk *ahbclk, *phyclk480m_hsic, *phyclk12m_hsic, *phyclk_usbphy1;
 320
 321         phyclk480m_hsic = devm_clk_get(usbpdata->dev, "hsicphy_480m");
 322         if (IS_ERR(phyclk480m_hsic)) {
 323                 dev_err(usbpdata->dev, "Failed to get hsicphy_480m\n");
 324                 return;
 325         }
 326
 327         phyclk12m_hsic = devm_clk_get(usbpdata->dev, "hsicphy_12m");
 328         if (IS_ERR(phyclk12m_hsic)) {
 329                 dev_err(usbpdata->dev, "Failed to get hsicphy_12m\n");
 330                 return;
 331         }
 332
 333         phyclk_usbphy1 = devm_clk_get(usbpdata->dev, "hsic_usbphy1");
 334         if (IS_ERR(phyclk_usbphy1)) {
 335                 dev_err(usbpdata->dev, "Failed to get hsic_usbphy1\n");
 336                 return;
 337         }
 338
 339         ahbclk = devm_clk_get(usbpdata->dev, "hclk_hsic");
 340         if (IS_ERR(ahbclk)) {
 341                 dev_err(usbpdata->dev, "Failed to get hclk_hsic\n");
 342                 return;
 343         }
 344
 345         clk_set_parent(phyclk480m_hsic, phyclk_usbphy1);
 346
 347         usbpdata->hclk_hsic = ahbclk;
 348         usbpdata->hsic_phy_480m = phyclk480m_hsic;
 349         usbpdata->hsic_phy_12m = phyclk12m_hsic;
 350         */
 351 }
 352
 353 static void rk_hsic_clock_enable(void* pdata, int enable)
 354 {
 355         /*
 356         struct rkehci_platform_data *usbpdata=pdata;
 357
 358         if(enable == usbpdata->clk_status)
 359                 return;
 360         if(enable){
 361                 clk_prepare_enable(usbpdata->hclk_hsic);
 362                 clk_prepare_enable(usbpdata->hsic_phy_480m);
 363                 clk_prepare_enable(usbpdata->hsic_phy_12m);
 364                 usbpdata->clk_status = 1;
 365         }else{
 366                 clk_disable_unprepare(usbpdata->hclk_hsic);
 367                 clk_disable_unprepare(usbpdata->hsic_phy_480m);
 368                 clk_disable_unprepare(usbpdata->hsic_phy_12m);
 369                 usbpdata->clk_status = 0;
 370         }
 371         */
 372 }
 373
 374 static void rk_hsic_soft_reset(void)
 375 {
 376 }
 377
 378 struct rkehci_platform_data rkhsic_pdata_rk3288 = {
 379         .hclk_hsic = NULL,
 380         .hsic_phy_12m = NULL,
 381         .hsic_phy_480m = NULL,
 382         .clk_status = -1,
 383         .hw_init = rk_hsic_hw_init,
 384         .clock_init = rk_hsic_clock_init,
 385         .clock_enable = rk_hsic_clock_enable,
 386         .soft_reset = rk_hsic_soft_reset,
 387 };
 388 #endif
 389
 390 #ifdef CONFIG_USB_EHCI_RK
 391 static void rk_ehci_hw_init(void)
 392 {
 393         /* usb phy config init */
 394
 395         /* DRV_VBUS GPIO init */
 396         /*if(!gpio_get_value(control_usb->host_gpios->gpio)){
 397                 gpio_set_value(control_usb->host_gpios->gpio, 1);
 398         }*/
 399 }
 400
 401 static void rk_ehci_clock_init(void* pdata)
 402 {
 403 /*
 404         struct rkehci_platform_data *usbpdata=pdata;
 405         struct clk* ahbclk,*phyclk;
 406
 407         ahbclk = of_clk_get_by_name(of_get_parent(usbpdata->dev.of_node), "hclk_usb2");
 408         if (IS_ERR(ahbclk)) {
 409                 dev_err(usbpdata->dev, "Failed to get hclk_usb2\n");
 410                 return;
 411         }
 412
 413         phyclk = of_clk_get_by_name(of_get_parent(usbpdata->dev.of_node), "clk_usbphy2");
 414         if (IS_ERR(phyclk)) {
 415                 dev_err(usbpdata->dev, "Failed to get clk_usbphy2\n");
 416                 return;
 417         }
 418
 419         usbpdata->phyclk = phyclk;
 420         usbpdata->ahbclk = ahbclk;
 421 */
 422 }
 423
 424 static void rk_ehci_clock_enable(void* pdata, int enable)
 425 {
 426 /*
 427         struct rkehci_platform_data *usbpdata=pdata;
 428
 429         if(enable == usbpdata->clk_status)
 430                 return;
 431         if(enable){
 432                 clk_prepare_enable(usbpdata->ahbclk);
 433                 clk_prepare_enable(usbpdata->phyclk);
 434                 usbpdata->clk_status = 1;
 435         }else{
 436                 clk_disable_unprepare(usbpdata->ahbclk);
 437                 clk_disable_unprepare(usbpdata->phyclk);
 438                 usbpdata->clk_status = 0;
 439         }
 440 */
 441 }
 442
 443 static void rk_ehci_soft_reset(void)
 444 {
 445
 446 }
 447
 448 struct rkehci_platform_data rkehci_pdata_rk3288 = {
 449         .phyclk = NULL,
 450         .ahbclk = NULL,
 451         .clk_status = -1,
 452         .hw_init = rk_ehci_hw_init,
 453         .clock_init = rk_ehci_clock_init,
 454         .clock_enable = rk_ehci_clock_enable,
 455         .soft_reset = rk_ehci_soft_reset,
 456 };
 457 #endif
 458
 459 #ifdef CONFIG_USB_OHCI_HCD_RK
 460 static void rk_ohci_hw_init(void)
 461 {
 462         /* usb phy config init */
 463
 464         /* DRV_VBUS GPIO init */
 465         /*if(!gpio_get_value(control_usb->host_gpios->gpio)){
 466                 gpio_set_value(control_usb->host_gpios->gpio, 1);
 467         }*/
 468 }
 469
 470 static void rk_ohci_clock_init(void* pdata)
 471 {
 472 /*
 473         struct rkehci_platform_data *usbpdata=pdata;
 474         struct clk* ahbclk,*phyclk;
 475
 476         ahbclk = of_clk_get_by_name(of_get_parent(usbpdata->dev.of_node), "hclk_usb2");
 477         if (IS_ERR(ahbclk)) {
 478                 dev_err(usbpdata->dev, "Failed to get hclk_usb2\n");
 479                 return;
 480         }
 481
 482         phyclk = of_clk_get_by_name(of_get_parent(usbpdata->dev.of_node), "clk_usbphy2");
 483         if (IS_ERR(phyclk)) {
 484                 dev_err(usbpdata->dev, "Failed to get clk_usbphy2\n");
 485                 return;
 486         }
 487
 488         usbpdata->phyclk = phyclk;
 489         usbpdata->ahbclk = ahbclk;
 490 */
 491 }
 492
 493 static void rk_ohci_clock_enable(void* pdata, int enable)
 494 {
 495 /*
 496         struct rkehci_platform_data *usbpdata=pdata;
 497
 498         if(enable == usbpdata->clk_status)
 499                 return;
 500         if(enable){
 501                 clk_prepare_enable(usbpdata->ahbclk);
 502                 clk_prepare_enable(usbpdata->phyclk);
 503                 usbpdata->clk_status = 1;
 504         }else{
 505                 clk_disable_unprepare(usbpdata->ahbclk);
 506                 clk_disable_unprepare(usbpdata->phyclk);
 507                 usbpdata->clk_status = 0;
 508         }
 509 */
 510 }
 511
 512 static void rk_ohci_soft_reset(void)
 513 {
 514 }
 515
 516 struct rkehci_platform_data rkohci_pdata_rk3288 = {
 517         .phyclk = NULL,
 518         .ahbclk = NULL,
 519         .clk_status = -1,
 520         .hw_init = rk_ohci_hw_init,
 521         .clock_init = rk_ohci_clock_init,
 522         .clock_enable = rk_ohci_clock_enable,
 523         .soft_reset = rk_ohci_soft_reset,
 524 };
 525 #endif
 526
 527 /*********************************************************************
 528                         rk3288 usb detections
 529 *********************************************************************/
 530
 531 #define WAKE_LOCK_TIMEOUT (HZ * 10)
 532 inline static void do_wakeup(struct work_struct *work)
 533 {
 534 //      rk28_send_wakeup_key();
 535 }
 536
 537 /********** handler for bvalid irq **********/
 538 static irqreturn_t bvalid_irq_handler(int irq, void *dev_id)
 539 {
 540         /* clear irq */
 541         control_usb->grf_uoc0_base->CON4 = (0x0008 | (0x0008 << 16));
 542
 543 #ifdef CONFIG_RK_USB_UART
 544         /* usb otg dp/dm switch to usb phy */
 545         dwc_otg_uart_mode(NULL, PHY_USB_MODE);
 546 #endif
 547
 548         if(control_usb->usb_irq_wakeup){
 549                 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
 550                 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
 551         }
 552         return IRQ_HANDLED;
 553 }
 554
 555 /***** handler for otg id rise and fall edge *****/
 556 static irqreturn_t id_irq_handler(int irq, void *dev_id)
 557 {
 558     unsigned int uoc_con;
 559
 560      /* clear irq */
 561     uoc_con = control_usb->grf_uoc0_base->CON4;
 562
 563     if(uoc_con & (1<<5))//id rise
 564     {
 565         control_usb->grf_uoc0_base->CON4 = ((1<<5)|(1<<21)); //clear id rise irq pandding
 566     }
 567
 568     if(uoc_con & (1<<7))//id fall
 569     {
 570 #ifdef CONFIG_RK_USB_UART
 571         /* usb otg dp/dm switch to usb phy */
 572         dwc_otg_uart_mode(NULL, PHY_USB_MODE);
 573 #endif
 574         control_usb->grf_uoc0_base->CON4 = ((1<<7)|(1<<23));//clear id fall irq pandding
 575     }
 576
 577         if(control_usb->usb_irq_wakeup){
 578                 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
 579                 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
 580         }
 581
 582     return IRQ_HANDLED;
 583 }
 584
 585 /***** handler for otg line status change *****/
 586
 587 static irqreturn_t line_irq_handler(int irq, void *dev_id)
 588 {
 589     unsigned int uoc_con;
 590     /* clear irq */
 591
 592     if(control_usb->grf_uoc0_base->CON0 & 1<<15){
 593         control_usb->grf_uoc0_base->CON0 = (1<<15 | 1<<31);
 594     }
 595
 596     if(control_usb->grf_uoc1_base->CON0 & 1<<15){
 597         control_usb->grf_uoc1_base->CON0 = (1<<15 | 1<<31);
 598     }
 599
 600     if(control_usb->grf_uoc2_base->CON0 & 1<<15){
 601         control_usb->grf_uoc2_base->CON0 = (1<<15 | 1<<31);
 602     }
 603
 604         if(control_usb->usb_irq_wakeup){
 605                 wake_lock_timeout(&control_usb->usb_wakelock, WAKE_LOCK_TIMEOUT);
 606                 schedule_delayed_work(&control_usb->usb_det_wakeup_work, HZ/10);
 607         }
 608
 609     return IRQ_HANDLED;
 610 }
 611
 612 /************* register usb detection irqs **************/
 613 static int otg_irq_detect_init(struct platform_device *pdev)
 614 {
 615         int ret = 0;
 616         int irq = 0;
 617
 618         if(control_usb->usb_irq_wakeup){
 619                 wake_lock_init(&control_usb->usb_wakelock, WAKE_LOCK_SUSPEND, "usb_detect");
 620                 INIT_DELAYED_WORK(&control_usb->usb_det_wakeup_work, do_wakeup);
 621         }
 622
 623     /*register otg_bvalid irq*/
 624         irq = platform_get_irq_byname(pdev, "otg_bvalid");
 625         if (irq > 0) {
 626                 ret = request_irq(irq, bvalid_irq_handler, 0, "otg_bvalid", NULL);
 627                 if(ret < 0){
 628                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 629                         return ret;
 630                 }else{
 631                     control_usb->grf_uoc0_base->CON4 = 0x000c000c;// enable bvalid irq
 632                         if(control_usb->usb_irq_wakeup){
 633                                         enable_irq_wake(irq);
 634                         }
 635                 }
 636         }
 637
 638     /*register otg_id irq*/
 639     irq = platform_get_irq_byname(pdev, "otg_id");
 640     if(irq > 0){
 641         ret = request_irq(irq, id_irq_handler, 0, "otg_id", NULL);
 642         if(ret < 0){
 643                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 644                         return ret;
 645                 }else{
 646                     control_usb->grf_uoc0_base->CON4 = 0x00f000f0;
 647                         if(control_usb->usb_irq_wakeup){
 648                                         enable_irq_wake(irq);
 649                         }
 650                 }
 651     }
 652
 653     /*register otg_linestate irq*/
 654     irq = platform_get_irq_byname(pdev, "otg_linestate");
 655     if(irq > 0){
 656         ret = request_irq(irq, line_irq_handler, 0, "otg_linestate", NULL);
 657         if(ret < 0){
 658                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 659                         return ret;
 660                 }else{
 661                     control_usb->grf_uoc0_base->CON0 = 0xc000c000;
 662                         if(control_usb->usb_irq_wakeup){
 663                                         enable_irq_wake(irq);
 664                         }
 665                 }
 666     }
 667
 668     /*register host0_linestate irq*/
 669     irq = platform_get_irq_byname(pdev, "host0_linestate");
 670     if(irq > 0){
 671         ret = request_irq(irq, line_irq_handler, 0, "host0_linestate", NULL);
 672         if(ret < 0){
 673                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 674                         return ret;
 675                 }else{
 676                     control_usb->grf_uoc1_base->CON0 = 0xc000c000;
 677                         if(control_usb->usb_irq_wakeup){
 678                                         enable_irq_wake(irq);
 679                         }
 680                 }
 681     }
 682
 683     /*register host1_linestate irq*/
 684     irq = platform_get_irq_byname(pdev, "host1_linestate");
 685     if(irq > 0){
 686         ret = request_irq(irq, line_irq_handler, 0, "host1_linestate", NULL);
 687         if(ret < 0){
 688                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 689                         return ret;
 690                 }else{
 691                     control_usb->grf_uoc2_base->CON0 = 0xc000c000;
 692                         if(control_usb->usb_irq_wakeup){
 693                                         enable_irq_wake(irq);
 694                         }
 695                 }
 696     }
 697
 698         return ret;
 699 }
 700
 701 /********** end of rk3288 usb detections **********/
 702
 703 static int usb_grf_ioremap(struct platform_device *pdev)
 704 {
 705         int ret = 0;
 706         struct resource *res;
 707         void *grf_soc_status1;
 708         void *grf_soc_status2;
 709         void *grf_soc_status19;
 710         void *grf_soc_status21;
 711         void *grf_uoc0_base;
 712         void *grf_uoc1_base;
 713         void *grf_uoc2_base;
 714         void *grf_uoc3_base;
 715         void *grf_uoc4_base;
 716
 717         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 718                                                 "GRF_SOC_STATUS1");
 719         grf_soc_status1 = devm_ioremap_resource(&pdev->dev, res);
 720         if (IS_ERR(grf_soc_status1)){
 721                 ret = PTR_ERR(grf_soc_status1);
 722                 return ret;
 723         }
 724         control_usb->grf_soc_status1_rk3288 = (pGRF_SOC_STATUS1_RK3288)grf_soc_status1;
 725
 726         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 727                                                 "GRF_SOC_STATUS2");
 728         grf_soc_status2 = devm_ioremap_resource(&pdev->dev, res);
 729         if (IS_ERR(grf_soc_status2)){
 730                 ret = PTR_ERR(grf_soc_status2);
 731                 return ret;
 732         }
 733         control_usb->grf_soc_status2_rk3288 = (pGRF_SOC_STATUS2_RK3288)grf_soc_status2;
 734
 735         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 736                                                 "GRF_SOC_STATUS19");
 737         grf_soc_status19 = devm_ioremap_resource(&pdev->dev, res);
 738         if (IS_ERR(grf_soc_status19)){
 739                 ret = PTR_ERR(grf_soc_status19);
 740                 return ret;
 741         }
 742         control_usb->grf_soc_status19_rk3288 = (pGRF_SOC_STATUS19_RK3288)grf_soc_status19;
 743
 744         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 745                                                 "GRF_SOC_STATUS21");
 746         grf_soc_status21 = devm_ioremap_resource(&pdev->dev, res);
 747         if (IS_ERR(grf_soc_status21)){
 748                 ret = PTR_ERR(grf_soc_status21);
 749                 return ret;
 750         }
 751         control_usb->grf_soc_status21_rk3288 = (pGRF_SOC_STATUS21_RK3288)grf_soc_status21;
 752
 753         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 754                                                 "GRF_UOC0_BASE");
 755         grf_uoc0_base = devm_ioremap_resource(&pdev->dev, res);
 756         if (IS_ERR(grf_uoc0_base)){
 757                 ret = PTR_ERR(grf_uoc0_base);
 758                 return ret;
 759         }
 760         control_usb->grf_uoc0_base = (pGRF_UOC0_REG)grf_uoc0_base;
 761
 762         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 763                                                 "GRF_UOC1_BASE");
 764         grf_uoc1_base = devm_ioremap_resource(&pdev->dev, res);
 765         if (IS_ERR(grf_uoc1_base)){
 766                 ret = PTR_ERR(grf_uoc1_base);
 767                 return ret;
 768         }
 769         control_usb->grf_uoc1_base = (pGRF_UOC1_REG)grf_uoc1_base;
 770
 771         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 772                                                 "GRF_UOC2_BASE");
 773         grf_uoc2_base = devm_ioremap_resource(&pdev->dev, res);
 774         if (IS_ERR(grf_uoc2_base)){
 775                 ret = PTR_ERR(grf_uoc2_base);
 776                 return ret;
 777         }
 778         control_usb->grf_uoc2_base = (pGRF_UOC2_REG)grf_uoc2_base;
 779
 780         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 781                                                 "GRF_UOC3_BASE");
 782         grf_uoc3_base = devm_ioremap_resource(&pdev->dev, res);
 783         if (IS_ERR(grf_uoc3_base)){
 784                 ret = PTR_ERR(grf_uoc3_base);
 785                 return ret;
 786         }
 787         control_usb->grf_uoc3_base = (pGRF_UOC3_REG)grf_uoc3_base;
 788
 789         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 790                                                 "GRF_UOC4_BASE");
 791         grf_uoc4_base = devm_ioremap_resource(&pdev->dev, res);
 792         if (IS_ERR(grf_uoc4_base)){
 793                 ret = PTR_ERR(grf_uoc4_base);
 794                 return ret;
 795         }
 796         control_usb->grf_uoc4_base = (pGRF_UOC4_REG)grf_uoc4_base;
 797
 798         return ret;
 799 }
 800
 801 #ifdef CONFIG_OF
 802
 803 static const struct of_device_id dwc_otg_control_usb_id_table[] = {
 804         {
 805                 .compatible = "rockchip,rk3288-dwc-control-usb",
 806         },
 807         { },
 808 };
 809
 810 #endif
 811
 812 static int dwc_otg_control_usb_probe(struct platform_device *pdev)
 813 {
 814         int gpio, err;
 815         struct device_node *np = pdev->dev.of_node;
 816 //      struct clk* hclk_usb_peri;
 817         int ret = 0;
 818
 819         control_usb = devm_kzalloc(&pdev->dev, sizeof(*control_usb),GFP_KERNEL);
 820         if (!control_usb) {
 821                 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
 822                 ret =  -ENOMEM;
 823                 goto err1;
 824         }
 825
 826         control_usb->chip_id = RK3288_USB_CTLR;
 827         control_usb->remote_wakeup = of_property_read_bool(np,
 828                 "rockchip,remote_wakeup");
 829         control_usb->usb_irq_wakeup = of_property_read_bool(np,
 830                 "rockchip,usb_irq_wakeup");
 831
 832 /*      disable for debug
 833         hclk_usb_peri = devm_clk_get(&pdev->dev, "hclk_usb_peri");
 834         if (IS_ERR(hclk_usb_peri)) {
 835                 dev_err(&pdev->dev, "Failed to get hclk_usb_peri\n");
 836                 ret = -EINVAL;
 837                 goto err1;
 838         }
 839
 840         control_usb->hclk_usb_peri = hclk_usb_peri;
 841         clk_prepare_enable(hclk_usb_peri);
 842 */
 843         ret = usb_grf_ioremap(pdev);
 844         if(ret){
 845                 dev_err(&pdev->dev, "Failed to ioremap usb grf\n");
 846                 goto err2;
 847         }
 848 /*
 849         control_usb->host_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
 850         if(!control_usb->host_gpios){
 851                 dev_err(&pdev->dev, "unable to alloc memory for host_gpios\n");
 852                 ret =  -ENOMEM;
 853                 goto err2;
 854         }
 855
 856         gpio =  of_get_named_gpio(np, "gpios", 0);
 857         if(!gpio_is_valid(gpio)){
 858                 dev_err(&pdev->dev, "invalid host gpio%d\n", gpio);
 859                 ret = -EINVAL;
 860                 goto err2;
 861         }
 862         control_usb->host_gpios->gpio = gpio;
 863         err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio");
 864         if (err) {
 865                 dev_err(&pdev->dev,
 866                         "failed to request GPIO%d for host_drv\n",
 867                         gpio);
 868                 ret = err;
 869                 goto err2;
 870         }
 871         gpio_direction_output(control_usb->host_gpios->gpio, 1);
 872
 873         control_usb->otg_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
 874         if(!control_usb->otg_gpios){
 875                 dev_err(&pdev->dev, "unable to alloc memory for otg_gpios\n");
 876                 ret =  -ENOMEM;
 877                 goto err2;
 878         }
 879
 880         gpio =  of_get_named_gpio(np, "gpios", 1);
 881         if(!gpio_is_valid(gpio)){
 882                 dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio);
 883                 ret = -EINVAL;
 884                 goto err2;
 885         }
 886         control_usb->otg_gpios->gpio = gpio;
 887         err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio");
 888         if (err) {
 889                 dev_err(&pdev->dev,
 890                         "failed to request GPIO%d for otg_drv\n",
 891                         gpio);
 892                 ret = err;
 893                 goto err2;
 894         }
 895         gpio_direction_output(control_usb->otg_gpios->gpio, 0);
 896 */
 897 /* disable for debug
 898         ret = otg_irq_detect_init(pdev);
 899         if (ret < 0)
 900                 goto err2;
 901 */
 902         return 0;
 903
 904 err2:
 905 //      disable for debug
 906 //      clk_disable_unprepare(hclk_usb_peri);
 907 err1:
 908         return ret;
 909 }
 910
 911 static int dwc_otg_control_usb_remove(struct platform_device *pdev)
 912 {
 913 //      disable for debug
 914 //      clk_disable_unprepare(control_usb->hclk_usb_peri);
 915         return 0;
 916 }
 917
 918 static struct platform_driver dwc_otg_control_usb_driver = {
 919         .probe          = dwc_otg_control_usb_probe,
 920         .remove         = dwc_otg_control_usb_remove,
 921         .driver         = {
 922                 .name   = "rk3288-dwc-control-usb",
 923                 .owner  = THIS_MODULE,
 924                 .of_match_table = of_match_ptr(dwc_otg_control_usb_id_table),
 925         },
 926 };
 927
 928 static int __init dwc_otg_control_usb_init(void)
 929 {
 930         return platform_driver_register(&dwc_otg_control_usb_driver);
 931 }
 932
 933 subsys_initcall(dwc_otg_control_usb_init);
 934
 935 static void __exit dwc_otg_control_usb_exit(void)
 936 {
 937         platform_driver_unregister(&dwc_otg_control_usb_driver);
 938 }
 939
 940 module_exit(dwc_otg_control_usb_exit);
 941 MODULE_ALIAS("platform: dwc_control_usb");
 942 MODULE_AUTHOR("RockChip Inc.");
 943 MODULE_DESCRIPTION("RockChip Control Module USB Driver");
 944 MODULE_LICENSE("GPL v2");