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