drivers/usb/dwc_otg_310/usbdev_rk32.c

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