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