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 /***** handler for otg line status change *****/
 688
 689 static irqreturn_t line_irq_handler(int irq, void *dev_id)
 690 {
 691         /* clear irq */
 692
 693         if (control_usb->grf_uoc0_base->CON0 & 1 << 15)
 694                 control_usb->grf_uoc0_base->CON0 = (1 << 15 | 1 << 31);
 695
 696         if (control_usb->grf_uoc1_base->CON0 & 1 << 15)
 697                 control_usb->grf_uoc1_base->CON0 = (1 << 15 | 1 << 31);
 698
 699         if (control_usb->grf_uoc2_base->CON0 & 1 << 15)
 700                 control_usb->grf_uoc2_base->CON0 = (1 << 15 | 1 << 31);
 701
 702         if (control_usb->usb_irq_wakeup) {
 703                 wake_lock_timeout(&control_usb->usb_wakelock,
 704                                   WAKE_LOCK_TIMEOUT);
 705                 schedule_delayed_work(&control_usb->usb_det_wakeup_work,
 706                                       HZ / 10);
 707         }
 708
 709         return IRQ_HANDLED;
 710 }
 711
 712 /************* register usb detection irqs **************/
 713 static int otg_irq_detect_init(struct platform_device *pdev)
 714 {
 715         int ret = 0;
 716         int irq = 0;
 717
 718         if (control_usb->usb_irq_wakeup) {
 719                 wake_lock_init(&control_usb->usb_wakelock, WAKE_LOCK_SUSPEND,
 720                                "usb_detect");
 721                 INIT_DELAYED_WORK(&control_usb->usb_det_wakeup_work, do_wakeup);
 722         }
 723
 724         /*register otg_bvalid irq */
 725         irq = platform_get_irq_byname(pdev, "otg_bvalid");
 726         if (irq > 0) {
 727                 ret =
 728                     request_irq(irq, bvalid_irq_handler, 0, "otg_bvalid", NULL);
 729                 if (ret < 0) {
 730                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 731                         return ret;
 732                 } else {
 733                         /* enable bvalid irq  */
 734                         control_usb->grf_uoc0_base->CON4 = 0x000c000c;
 735                         if (control_usb->usb_irq_wakeup)
 736                                 enable_irq_wake(irq);
 737                 }
 738         }
 739 #if 0
 740         /*register otg_id irq */
 741         irq = platform_get_irq_byname(pdev, "otg_id");
 742         if (irq > 0) {
 743                 ret = request_irq(irq, id_irq_handler, 0, "otg_id", NULL);
 744                 if (ret < 0) {
 745                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 746                         return ret;
 747                 } else {
 748                         control_usb->grf_uoc0_base->CON4 = 0x00f000f0;
 749                         if (control_usb->usb_irq_wakeup)
 750                                 enable_irq_wake(irq);
 751                 }
 752         }
 753
 754         /*register otg_linestate irq */
 755         irq = platform_get_irq_byname(pdev, "otg_linestate");
 756         if (irq > 0) {
 757                 ret =
 758                     request_irq(irq, line_irq_handler, 0, "otg_linestate",
 759                                 NULL);
 760                 if (ret < 0) {
 761                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 762                         return ret;
 763                 } else {
 764                         control_usb->grf_uoc0_base->CON0 = 0xc000c000;
 765                         if (control_usb->usb_irq_wakeup)
 766                                 enable_irq_wake(irq);
 767                 }
 768         }
 769
 770         /*register host0_linestate irq */
 771         irq = platform_get_irq_byname(pdev, "host0_linestate");
 772         if (irq > 0) {
 773                 ret =
 774                     request_irq(irq, line_irq_handler, 0, "host0_linestate",
 775                                 NULL);
 776                 if (ret < 0) {
 777                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 778                         return ret;
 779                 } else {
 780                         control_usb->grf_uoc1_base->CON0 = 0xc000c000;
 781                         if (control_usb->usb_irq_wakeup)
 782                                 enable_irq_wake(irq);
 783                 }
 784         }
 785
 786         /*register host1_linestate irq */
 787         irq = platform_get_irq_byname(pdev, "host1_linestate");
 788         if (irq > 0) {
 789                 ret =
 790                     request_irq(irq, line_irq_handler, 0, "host1_linestate",
 791                                 NULL);
 792                 if (ret < 0) {
 793                         dev_err(&pdev->dev, "request_irq %d failed!\n", irq);
 794                         return ret;
 795                 } else {
 796                         control_usb->grf_uoc2_base->CON0 = 0xc000c000;
 797                         if (control_usb->usb_irq_wakeup)
 798                                 enable_irq_wake(irq);
 799                 }
 800         }
 801 #endif
 802         return ret;
 803 }
 804
 805 /********** end of rk3288 usb detections **********/
 806
 807 static int usb_grf_ioremap(struct platform_device *pdev)
 808 {
 809         int ret = 0;
 810         struct resource *res;
 811         void *grf_soc_status1;
 812         void *grf_soc_status2;
 813         void *grf_soc_status19;
 814         void *grf_soc_status21;
 815         void *grf_uoc0_base;
 816         void *grf_uoc1_base;
 817         void *grf_uoc2_base;
 818         void *grf_uoc3_base;
 819         void *grf_uoc4_base;
 820
 821         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 822                                            "GRF_SOC_STATUS1");
 823         grf_soc_status1 = devm_ioremap_resource(&pdev->dev, res);
 824         if (IS_ERR(grf_soc_status1)) {
 825                 ret = PTR_ERR(grf_soc_status1);
 826                 return ret;
 827         }
 828         control_usb->grf_soc_status1_rk3288 =
 829             (pGRF_SOC_STATUS1_RK3288) grf_soc_status1;
 830
 831         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 832                                            "GRF_SOC_STATUS2");
 833         grf_soc_status2 = devm_ioremap_resource(&pdev->dev, res);
 834         if (IS_ERR(grf_soc_status2)) {
 835                 ret = PTR_ERR(grf_soc_status2);
 836                 return ret;
 837         }
 838         control_usb->grf_soc_status2_rk3288 =
 839             (pGRF_SOC_STATUS2_RK3288) grf_soc_status2;
 840
 841         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 842                                            "GRF_SOC_STATUS19");
 843         grf_soc_status19 = devm_ioremap_resource(&pdev->dev, res);
 844         if (IS_ERR(grf_soc_status19)) {
 845                 ret = PTR_ERR(grf_soc_status19);
 846                 return ret;
 847         }
 848         control_usb->grf_soc_status19_rk3288 =
 849             (pGRF_SOC_STATUS19_RK3288) grf_soc_status19;
 850
 851         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 852                                            "GRF_SOC_STATUS21");
 853         grf_soc_status21 = devm_ioremap_resource(&pdev->dev, res);
 854         if (IS_ERR(grf_soc_status21)) {
 855                 ret = PTR_ERR(grf_soc_status21);
 856                 return ret;
 857         }
 858         control_usb->grf_soc_status21_rk3288 =
 859             (pGRF_SOC_STATUS21_RK3288) grf_soc_status21;
 860
 861         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 862                                            "GRF_UOC0_BASE");
 863         grf_uoc0_base = devm_ioremap_resource(&pdev->dev, res);
 864         if (IS_ERR(grf_uoc0_base)) {
 865                 ret = PTR_ERR(grf_uoc0_base);
 866                 return ret;
 867         }
 868         control_usb->grf_uoc0_base = (pGRF_UOC0_REG) grf_uoc0_base;
 869
 870         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 871                                            "GRF_UOC1_BASE");
 872         grf_uoc1_base = devm_ioremap_resource(&pdev->dev, res);
 873         if (IS_ERR(grf_uoc1_base)) {
 874                 ret = PTR_ERR(grf_uoc1_base);
 875                 return ret;
 876         }
 877         control_usb->grf_uoc1_base = (pGRF_UOC1_REG) grf_uoc1_base;
 878
 879         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 880                                            "GRF_UOC2_BASE");
 881         grf_uoc2_base = devm_ioremap_resource(&pdev->dev, res);
 882         if (IS_ERR(grf_uoc2_base)) {
 883                 ret = PTR_ERR(grf_uoc2_base);
 884                 return ret;
 885         }
 886         control_usb->grf_uoc2_base = (pGRF_UOC2_REG) grf_uoc2_base;
 887
 888         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 889                                            "GRF_UOC3_BASE");
 890         grf_uoc3_base = devm_ioremap_resource(&pdev->dev, res);
 891         if (IS_ERR(grf_uoc3_base)) {
 892                 ret = PTR_ERR(grf_uoc3_base);
 893                 return ret;
 894         }
 895         control_usb->grf_uoc3_base = (pGRF_UOC3_REG) grf_uoc3_base;
 896
 897         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 898                                            "GRF_UOC4_BASE");
 899         grf_uoc4_base = devm_ioremap_resource(&pdev->dev, res);
 900         if (IS_ERR(grf_uoc4_base)) {
 901                 ret = PTR_ERR(grf_uoc4_base);
 902                 return ret;
 903         }
 904         control_usb->grf_uoc4_base = (pGRF_UOC4_REG) grf_uoc4_base;
 905
 906         return ret;
 907 }
 908
 909 #ifdef CONFIG_OF
 910
 911 static const struct of_device_id rk_usb_control_id_table[] = {
 912         {
 913          .compatible = "rockchip,rk3288-usb-control",
 914          },
 915         {},
 916 };
 917
 918 #endif
 919
 920 static int rk_usb_control_probe(struct platform_device *pdev)
 921 {
 922         int gpio, err;
 923         struct device_node *np = pdev->dev.of_node;
 924         int ret = 0;
 925
 926         control_usb =
 927             devm_kzalloc(&pdev->dev, sizeof(*control_usb), GFP_KERNEL);
 928         if (!control_usb) {
 929                 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
 930                 ret = -ENOMEM;
 931                 goto out;
 932         }
 933
 934         control_usb->chip_id = RK3288_USB_CTLR;
 935         control_usb->remote_wakeup = of_property_read_bool(np,
 936                                                            "rockchip,remote_wakeup");
 937         control_usb->usb_irq_wakeup = of_property_read_bool(np,
 938                                                             "rockchip,usb_irq_wakeup");
 939
 940         INIT_DELAYED_WORK(&control_usb->usb_charger_det_work,
 941                           usb_battery_charger_detect_work);
 942
 943         control_usb->host_gpios =
 944             devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
 945         if (!control_usb->host_gpios) {
 946                 dev_err(&pdev->dev, "unable to alloc memory for host_gpios\n");
 947                 ret = -ENOMEM;
 948                 goto out;
 949         }
 950
 951         gpio = of_get_named_gpio(np, "host_drv_gpio", 0);
 952         control_usb->host_gpios->gpio = gpio;
 953
 954         if (!gpio_is_valid(gpio)) {
 955                 dev_err(&pdev->dev, "invalid host gpio%d\n", gpio);
 956         } else {
 957                 err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio");
 958                 if (err) {
 959                         dev_err(&pdev->dev,
 960                                 "failed to request GPIO%d for host_drv\n",
 961                                 gpio);
 962                         ret = err;
 963                         goto out;
 964                 }
 965                 gpio_direction_output(control_usb->host_gpios->gpio, 1);
 966         }
 967
 968         control_usb->otg_gpios =
 969             devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL);
 970         if (!control_usb->otg_gpios) {
 971                 dev_err(&pdev->dev, "unable to alloc memory for otg_gpios\n");
 972                 ret = -ENOMEM;
 973                 goto out;
 974         }
 975
 976         gpio = of_get_named_gpio(np, "otg_drv_gpio", 0);
 977         control_usb->otg_gpios->gpio = gpio;
 978
 979         if (!gpio_is_valid(gpio)) {
 980                 dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio);
 981         } else {
 982                 err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio");
 983                 if (err) {
 984                         dev_err(&pdev->dev,
 985                                 "failed to request GPIO%d for otg_drv\n", gpio);
 986                         ret = err;
 987                         goto out;
 988                 }
 989                 gpio_direction_output(control_usb->otg_gpios->gpio, 0);
 990         }
 991
 992 out:
 993         return ret;
 994 }
 995
 996 static int rk_usb_control_remove(struct platform_device *pdev)
 997 {
 998         return 0;
 999 }
1000
1001 static struct platform_driver rk_usb_control_driver = {
1002         .probe = rk_usb_control_probe,
1003         .remove = rk_usb_control_remove,
1004         .driver = {
1005                    .name = "rk3288-usb-control",
1006                    .owner = THIS_MODULE,
1007                    .of_match_table = of_match_ptr(rk_usb_control_id_table),
1008                    },
1009 };
1010
1011 #ifdef CONFIG_OF
1012
1013 static const struct of_device_id dwc_otg_control_usb_id_table[] = {
1014         {
1015          .compatible = "rockchip,rk3288-dwc-control-usb",
1016          },
1017         {},
1018 };
1019
1020 #endif
1021
1022 static int dwc_otg_control_usb_probe(struct platform_device *pdev)
1023 {
1024         struct clk *hclk_usb_peri, *phyclk_480m, *phyclk480m_parent;
1025         int ret = 0;
1026
1027         if (!control_usb) {
1028                 dev_err(&pdev->dev, "unable to alloc memory for control usb\n");
1029                 ret = -ENOMEM;
1030                 goto err1;
1031         }
1032
1033         hclk_usb_peri = devm_clk_get(&pdev->dev, "hclk_usb_peri");
1034         if (IS_ERR(hclk_usb_peri)) {
1035                 dev_err(&pdev->dev, "Failed to get hclk_usb_peri\n");
1036                 ret = -EINVAL;
1037                 goto err1;
1038         }
1039
1040         control_usb->hclk_usb_peri = hclk_usb_peri;
1041         clk_prepare_enable(hclk_usb_peri);
1042
1043         phyclk480m_parent = devm_clk_get(&pdev->dev, "usbphy2_480m");
1044         if (IS_ERR(phyclk480m_parent)) {
1045                 dev_err(&pdev->dev, "Failed to get usbphy2_480m\n");
1046                 goto err2;
1047         }
1048
1049         phyclk_480m = devm_clk_get(&pdev->dev, "usbphy_480m");
1050         if (IS_ERR(phyclk_480m)) {
1051                 dev_err(&pdev->dev, "Failed to get usbphy_480m\n");
1052                 goto err2;
1053         }
1054
1055         clk_set_parent(phyclk_480m, phyclk480m_parent);
1056
1057         ret = usb_grf_ioremap(pdev);
1058         if (ret) {
1059                 dev_err(&pdev->dev, "Failed to ioremap usb grf\n");
1060                 goto err2;
1061         }
1062 #ifdef CONFIG_USB20_OTG
1063         if (usb20otg_get_status(USB_STATUS_BVABLID)) {
1064                 rk_usb_charger_status = USB_BC_TYPE_SDP;
1065                 schedule_delayed_work(&control_usb->usb_charger_det_work,
1066                                       HZ / 10);
1067         }
1068 #endif
1069
1070         ret = otg_irq_detect_init(pdev);
1071         if (ret < 0)
1072                 goto err2;
1073
1074         return 0;
1075
1076 err2:
1077         clk_disable_unprepare(hclk_usb_peri);
1078 err1:
1079         return ret;
1080 }
1081
1082 static int dwc_otg_control_usb_remove(struct platform_device *pdev)
1083 {
1084         clk_disable_unprepare(control_usb->hclk_usb_peri);
1085         return 0;
1086 }
1087
1088 static struct platform_driver dwc_otg_control_usb_driver = {
1089         .probe = dwc_otg_control_usb_probe,
1090         .remove = dwc_otg_control_usb_remove,
1091         .driver = {
1092                    .name = "rk3288-dwc-control-usb",
1093                    .owner = THIS_MODULE,
1094                    .of_match_table = of_match_ptr(dwc_otg_control_usb_id_table),
1095                    },
1096 };
1097
1098 static int __init dwc_otg_control_usb_init(void)
1099 {
1100         int retval = 0;
1101
1102         retval = platform_driver_register(&rk_usb_control_driver);
1103         if (retval < 0) {
1104                 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1105                 return retval;
1106         }
1107
1108         retval = platform_driver_register(&dwc_otg_control_usb_driver);
1109
1110         if (retval < 0) {
1111                 printk(KERN_ERR "%s retval=%d\n", __func__, retval);
1112                 return retval;
1113         }
1114         return retval;
1115 }
1116
1117 subsys_initcall(dwc_otg_control_usb_init);
1118
1119 static void __exit dwc_otg_control_usb_exit(void)
1120 {
1121         platform_driver_unregister(&rk_usb_control_driver);
1122         platform_driver_unregister(&dwc_otg_control_usb_driver);
1123 }
1124
1125 module_exit(dwc_otg_control_usb_exit);
1126 MODULE_ALIAS("platform: dwc_control_usb");
1127 MODULE_AUTHOR("RockChip Inc.");
1128 MODULE_DESCRIPTION("RockChip Control Module USB Driver");
1129 MODULE_LICENSE("GPL v2");