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