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