drivers/usb/host/xhci-mtk.c

   1 /*
   2  * MediaTek xHCI Host Controller Driver
   3  *
   4  * Copyright (c) 2015 MediaTek Inc.
   5  * Author:
   6  *  Chunfeng Yun <chunfeng.yun@mediatek.com>
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18
  19 #include <linux/clk.h>
  20 #include <linux/dma-mapping.h>
  21 #include <linux/iopoll.h>
  22 #include <linux/kernel.h>
  23 #include <linux/mfd/syscon.h>
  24 #include <linux/module.h>
  25 #include <linux/of.h>
  26 #include <linux/phy/phy.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/pm_runtime.h>
  29 #include <linux/regmap.h>
  30 #include <linux/regulator/consumer.h>
  31
  32 #include "xhci.h"
  33 #include "xhci-mtk.h"
  34
  35 /* ip_pw_ctrl0 register */
  36 #define CTRL0_IP_SW_RST BIT(0)
  37
  38 /* ip_pw_ctrl1 register */
  39 #define CTRL1_IP_HOST_PDN       BIT(0)
  40
  41 /* ip_pw_ctrl2 register */
  42 #define CTRL2_IP_DEV_PDN        BIT(0)
  43
  44 /* ip_pw_sts1 register */
  45 #define STS1_IP_SLEEP_STS       BIT(30)
  46 #define STS1_XHCI_RST           BIT(11)
  47 #define STS1_SYS125_RST BIT(10)
  48 #define STS1_REF_RST            BIT(8)
  49 #define STS1_SYSPLL_STABLE      BIT(0)
  50
  51 /* ip_xhci_cap register */
  52 #define CAP_U3_PORT_NUM(p)      ((p) & 0xff)
  53 #define CAP_U2_PORT_NUM(p)      (((p) >> 8) & 0xff)
  54
  55 /* u3_ctrl_p register */
  56 #define CTRL_U3_PORT_HOST_SEL   BIT(2)
  57 #define CTRL_U3_PORT_PDN        BIT(1)
  58 #define CTRL_U3_PORT_DIS        BIT(0)
  59
  60 /* u2_ctrl_p register */
  61 #define CTRL_U2_PORT_HOST_SEL   BIT(2)
  62 #define CTRL_U2_PORT_PDN        BIT(1)
  63 #define CTRL_U2_PORT_DIS        BIT(0)
  64
  65 /* u2_phy_pll register */
  66 #define CTRL_U2_FORCE_PLL_STB   BIT(28)
  67
  68 #define PERI_WK_CTRL0           0x400
  69 #define UWK_CTR0_0P_LS_PE       BIT(8)  /* posedge */
  70 #define UWK_CTR0_0P_LS_NE       BIT(7)  /* negedge for 0p linestate*/
  71 #define UWK_CTL1_1P_LS_C(x)     (((x) & 0xf) << 1)
  72 #define UWK_CTL1_1P_LS_E        BIT(0)
  73
  74 #define PERI_WK_CTRL1           0x404
  75 #define UWK_CTL1_IS_C(x)        (((x) & 0xf) << 26)
  76 #define UWK_CTL1_IS_E           BIT(25)
  77 #define UWK_CTL1_0P_LS_C(x)     (((x) & 0xf) << 21)
  78 #define UWK_CTL1_0P_LS_E        BIT(20)
  79 #define UWK_CTL1_IDDIG_C(x)     (((x) & 0xf) << 11)  /* cycle debounce */
  80 #define UWK_CTL1_IDDIG_E        BIT(10) /* enable debounce */
  81 #define UWK_CTL1_IDDIG_P        BIT(9)  /* polarity */
  82 #define UWK_CTL1_0P_LS_P        BIT(7)
  83 #define UWK_CTL1_IS_P           BIT(6)  /* polarity for ip sleep */
  84
  85 enum ssusb_wakeup_src {
  86         SSUSB_WK_IP_SLEEP = 1,
  87         SSUSB_WK_LINE_STATE = 2,
  88 };
  89
  90 static int xhci_mtk_host_enable(struct xhci_hcd_mtk *mtk)
  91 {
  92         struct mu3c_ippc_regs __iomem *ippc = mtk->ippc_regs;
  93         u32 value, check_val;
  94         int ret;
  95         int i;
  96
  97         if (!mtk->has_ippc)
  98                 return 0;
  99
 100         /* power on host ip */
 101         value = readl(&ippc->ip_pw_ctr1);
 102         value &= ~CTRL1_IP_HOST_PDN;
 103         writel(value, &ippc->ip_pw_ctr1);
 104
 105         /* power on and enable all u3 ports */
 106         for (i = 0; i < mtk->num_u3_ports; i++) {
 107                 value = readl(&ippc->u3_ctrl_p[i]);
 108                 value &= ~(CTRL_U3_PORT_PDN | CTRL_U3_PORT_DIS);
 109                 value |= CTRL_U3_PORT_HOST_SEL;
 110                 writel(value, &ippc->u3_ctrl_p[i]);
 111         }
 112
 113         /* power on and enable all u2 ports */
 114         for (i = 0; i < mtk->num_u2_ports; i++) {
 115                 value = readl(&ippc->u2_ctrl_p[i]);
 116                 value &= ~(CTRL_U2_PORT_PDN | CTRL_U2_PORT_DIS);
 117                 value |= CTRL_U2_PORT_HOST_SEL;
 118                 writel(value, &ippc->u2_ctrl_p[i]);
 119         }
 120
 121         /*
 122          * wait for clocks to be stable, and clock domains reset to
 123          * be inactive after power on and enable ports
 124          */
 125         check_val = STS1_SYSPLL_STABLE | STS1_REF_RST |
 126                         STS1_SYS125_RST | STS1_XHCI_RST;
 127
 128         ret = readl_poll_timeout(&ippc->ip_pw_sts1, value,
 129                           (check_val == (value & check_val)), 100, 20000);
 130         if (ret) {
 131                 dev_err(mtk->dev, "clocks are not stable (0x%x)\n", value);
 132                 return ret;
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int xhci_mtk_host_disable(struct xhci_hcd_mtk *mtk)
 139 {
 140         struct mu3c_ippc_regs __iomem *ippc = mtk->ippc_regs;
 141         u32 value;
 142         int ret;
 143         int i;
 144
 145         if (!mtk->has_ippc)
 146                 return 0;
 147
 148         /* power down all u3 ports */
 149         for (i = 0; i < mtk->num_u3_ports; i++) {
 150                 value = readl(&ippc->u3_ctrl_p[i]);
 151                 value |= CTRL_U3_PORT_PDN;
 152                 writel(value, &ippc->u3_ctrl_p[i]);
 153         }
 154
 155         /* power down all u2 ports */
 156         for (i = 0; i < mtk->num_u2_ports; i++) {
 157                 value = readl(&ippc->u2_ctrl_p[i]);
 158                 value |= CTRL_U2_PORT_PDN;
 159                 writel(value, &ippc->u2_ctrl_p[i]);
 160         }
 161
 162         /* power down host ip */
 163         value = readl(&ippc->ip_pw_ctr1);
 164         value |= CTRL1_IP_HOST_PDN;
 165         writel(value, &ippc->ip_pw_ctr1);
 166
 167         /* wait for host ip to sleep */
 168         ret = readl_poll_timeout(&ippc->ip_pw_sts1, value,
 169                           (value & STS1_IP_SLEEP_STS), 100, 100000);
 170         if (ret) {
 171                 dev_err(mtk->dev, "ip sleep failed!!!\n");
 172                 return ret;
 173         }
 174         return 0;
 175 }
 176
 177 static int xhci_mtk_ssusb_config(struct xhci_hcd_mtk *mtk)
 178 {
 179         struct mu3c_ippc_regs __iomem *ippc = mtk->ippc_regs;
 180         u32 value;
 181
 182         if (!mtk->has_ippc)
 183                 return 0;
 184
 185         /* reset whole ip */
 186         value = readl(&ippc->ip_pw_ctr0);
 187         value |= CTRL0_IP_SW_RST;
 188         writel(value, &ippc->ip_pw_ctr0);
 189         udelay(1);
 190         value = readl(&ippc->ip_pw_ctr0);
 191         value &= ~CTRL0_IP_SW_RST;
 192         writel(value, &ippc->ip_pw_ctr0);
 193
 194         /*
 195          * device ip is default power-on in fact
 196          * power down device ip, otherwise ip-sleep will fail
 197          */
 198         value = readl(&ippc->ip_pw_ctr2);
 199         value |= CTRL2_IP_DEV_PDN;
 200         writel(value, &ippc->ip_pw_ctr2);
 201
 202         value = readl(&ippc->ip_xhci_cap);
 203         mtk->num_u3_ports = CAP_U3_PORT_NUM(value);
 204         mtk->num_u2_ports = CAP_U2_PORT_NUM(value);
 205         dev_dbg(mtk->dev, "%s u2p:%d, u3p:%d\n", __func__,
 206                         mtk->num_u2_ports, mtk->num_u3_ports);
 207
 208         return xhci_mtk_host_enable(mtk);
 209 }
 210
 211 static int xhci_mtk_clks_enable(struct xhci_hcd_mtk *mtk)
 212 {
 213         int ret;
 214
 215         ret = clk_prepare_enable(mtk->ref_clk);
 216         if (ret) {
 217                 dev_err(mtk->dev, "failed to enable ref_clk\n");
 218                 goto ref_clk_err;
 219         }
 220
 221         ret = clk_prepare_enable(mtk->sys_clk);
 222         if (ret) {
 223                 dev_err(mtk->dev, "failed to enable sys_clk\n");
 224                 goto sys_clk_err;
 225         }
 226
 227         if (mtk->wakeup_src) {
 228                 ret = clk_prepare_enable(mtk->wk_deb_p0);
 229                 if (ret) {
 230                         dev_err(mtk->dev, "failed to enable wk_deb_p0\n");
 231                         goto usb_p0_err;
 232                 }
 233
 234                 ret = clk_prepare_enable(mtk->wk_deb_p1);
 235                 if (ret) {
 236                         dev_err(mtk->dev, "failed to enable wk_deb_p1\n");
 237                         goto usb_p1_err;
 238                 }
 239         }
 240         return 0;
 241
 242 usb_p1_err:
 243         clk_disable_unprepare(mtk->wk_deb_p0);
 244 usb_p0_err:
 245         clk_disable_unprepare(mtk->sys_clk);
 246 sys_clk_err:
 247         clk_disable_unprepare(mtk->ref_clk);
 248 ref_clk_err:
 249         return -EINVAL;
 250 }
 251
 252 static void xhci_mtk_clks_disable(struct xhci_hcd_mtk *mtk)
 253 {
 254         if (mtk->wakeup_src) {
 255                 clk_disable_unprepare(mtk->wk_deb_p1);
 256                 clk_disable_unprepare(mtk->wk_deb_p0);
 257         }
 258         clk_disable_unprepare(mtk->sys_clk);
 259         clk_disable_unprepare(mtk->ref_clk);
 260 }
 261
 262 /* only clocks can be turn off for ip-sleep wakeup mode */
 263 static void usb_wakeup_ip_sleep_en(struct xhci_hcd_mtk *mtk)
 264 {
 265         u32 tmp;
 266         struct regmap *pericfg = mtk->pericfg;
 267
 268         regmap_read(pericfg, PERI_WK_CTRL1, &tmp);
 269         tmp &= ~UWK_CTL1_IS_P;
 270         tmp &= ~(UWK_CTL1_IS_C(0xf));
 271         tmp |= UWK_CTL1_IS_C(0x8);
 272         regmap_write(pericfg, PERI_WK_CTRL1, tmp);
 273         regmap_write(pericfg, PERI_WK_CTRL1, tmp | UWK_CTL1_IS_E);
 274
 275         regmap_read(pericfg, PERI_WK_CTRL1, &tmp);
 276         dev_dbg(mtk->dev, "%s(): WK_CTRL1[P6,E25,C26:29]=%#x\n",
 277                 __func__, tmp);
 278 }
 279
 280 static void usb_wakeup_ip_sleep_dis(struct xhci_hcd_mtk *mtk)
 281 {
 282         u32 tmp;
 283
 284         regmap_read(mtk->pericfg, PERI_WK_CTRL1, &tmp);
 285         tmp &= ~UWK_CTL1_IS_E;
 286         regmap_write(mtk->pericfg, PERI_WK_CTRL1, tmp);
 287 }
 288
 289 /*
 290 * for line-state wakeup mode, phy's power should not power-down
 291 * and only support cable plug in/out
 292 */
 293 static void usb_wakeup_line_state_en(struct xhci_hcd_mtk *mtk)
 294 {
 295         u32 tmp;
 296         struct regmap *pericfg = mtk->pericfg;
 297
 298         /* line-state of u2-port0 */
 299         regmap_read(pericfg, PERI_WK_CTRL1, &tmp);
 300         tmp &= ~UWK_CTL1_0P_LS_P;
 301         tmp &= ~(UWK_CTL1_0P_LS_C(0xf));
 302         tmp |= UWK_CTL1_0P_LS_C(0x8);
 303         regmap_write(pericfg, PERI_WK_CTRL1, tmp);
 304         regmap_read(pericfg, PERI_WK_CTRL1, &tmp);
 305         regmap_write(pericfg, PERI_WK_CTRL1, tmp | UWK_CTL1_0P_LS_E);
 306
 307         /* line-state of u2-port1 */
 308         regmap_read(pericfg, PERI_WK_CTRL0, &tmp);
 309         tmp &= ~(UWK_CTL1_1P_LS_C(0xf));
 310         tmp |= UWK_CTL1_1P_LS_C(0x8);
 311         regmap_write(pericfg, PERI_WK_CTRL0, tmp);
 312         regmap_write(pericfg, PERI_WK_CTRL0, tmp | UWK_CTL1_1P_LS_E);
 313 }
 314
 315 static void usb_wakeup_line_state_dis(struct xhci_hcd_mtk *mtk)
 316 {
 317         u32 tmp;
 318         struct regmap *pericfg = mtk->pericfg;
 319
 320         /* line-state of u2-port0 */
 321         regmap_read(pericfg, PERI_WK_CTRL1, &tmp);
 322         tmp &= ~UWK_CTL1_0P_LS_E;
 323         regmap_write(pericfg, PERI_WK_CTRL1, tmp);
 324
 325         /* line-state of u2-port1 */
 326         regmap_read(pericfg, PERI_WK_CTRL0, &tmp);
 327         tmp &= ~UWK_CTL1_1P_LS_E;
 328         regmap_write(pericfg, PERI_WK_CTRL0, tmp);
 329 }
 330
 331 static void usb_wakeup_enable(struct xhci_hcd_mtk *mtk)
 332 {
 333         if (mtk->wakeup_src == SSUSB_WK_IP_SLEEP)
 334                 usb_wakeup_ip_sleep_en(mtk);
 335         else if (mtk->wakeup_src == SSUSB_WK_LINE_STATE)
 336                 usb_wakeup_line_state_en(mtk);
 337 }
 338
 339 static void usb_wakeup_disable(struct xhci_hcd_mtk *mtk)
 340 {
 341         if (mtk->wakeup_src == SSUSB_WK_IP_SLEEP)
 342                 usb_wakeup_ip_sleep_dis(mtk);
 343         else if (mtk->wakeup_src == SSUSB_WK_LINE_STATE)
 344                 usb_wakeup_line_state_dis(mtk);
 345 }
 346
 347 static int usb_wakeup_of_property_parse(struct xhci_hcd_mtk *mtk,
 348                                 struct device_node *dn)
 349 {
 350         struct device *dev = mtk->dev;
 351
 352         /*
 353         * wakeup function is optional, so it is not an error if this property
 354         * does not exist, and in such case, no need to get relative
 355         * properties anymore.
 356         */
 357         of_property_read_u32(dn, "mediatek,wakeup-src", &mtk->wakeup_src);
 358         if (!mtk->wakeup_src)
 359                 return 0;
 360
 361         mtk->wk_deb_p0 = devm_clk_get(dev, "wakeup_deb_p0");
 362         if (IS_ERR(mtk->wk_deb_p0)) {
 363                 dev_err(dev, "fail to get wakeup_deb_p0\n");
 364                 return PTR_ERR(mtk->wk_deb_p0);
 365         }
 366
 367         mtk->wk_deb_p1 = devm_clk_get(dev, "wakeup_deb_p1");
 368         if (IS_ERR(mtk->wk_deb_p1)) {
 369                 dev_err(dev, "fail to get wakeup_deb_p1\n");
 370                 return PTR_ERR(mtk->wk_deb_p1);
 371         }
 372
 373         mtk->pericfg = syscon_regmap_lookup_by_phandle(dn,
 374                                                 "mediatek,syscon-wakeup");
 375         if (IS_ERR(mtk->pericfg)) {
 376                 dev_err(dev, "fail to get pericfg regs\n");
 377                 return PTR_ERR(mtk->pericfg);
 378         }
 379
 380         return 0;
 381 }
 382
 383 static int xhci_mtk_setup(struct usb_hcd *hcd);
 384 static const struct xhci_driver_overrides xhci_mtk_overrides __initconst = {
 385         .extra_priv_size = sizeof(struct xhci_hcd),
 386         .reset = xhci_mtk_setup,
 387 };
 388
 389 static struct hc_driver __read_mostly xhci_mtk_hc_driver;
 390
 391 static int xhci_mtk_phy_init(struct xhci_hcd_mtk *mtk)
 392 {
 393         int i;
 394         int ret;
 395
 396         for (i = 0; i < mtk->num_phys; i++) {
 397                 ret = phy_init(mtk->phys[i]);
 398                 if (ret)
 399                         goto exit_phy;
 400         }
 401         return 0;
 402
 403 exit_phy:
 404         for (; i > 0; i--)
 405                 phy_exit(mtk->phys[i - 1]);
 406
 407         return ret;
 408 }
 409
 410 static int xhci_mtk_phy_exit(struct xhci_hcd_mtk *mtk)
 411 {
 412         int i;
 413
 414         for (i = 0; i < mtk->num_phys; i++)
 415                 phy_exit(mtk->phys[i]);
 416
 417         return 0;
 418 }
 419
 420 static int xhci_mtk_phy_power_on(struct xhci_hcd_mtk *mtk)
 421 {
 422         int i;
 423         int ret;
 424
 425         for (i = 0; i < mtk->num_phys; i++) {
 426                 ret = phy_power_on(mtk->phys[i]);
 427                 if (ret)
 428                         goto power_off_phy;
 429         }
 430         return 0;
 431
 432 power_off_phy:
 433         for (; i > 0; i--)
 434                 phy_power_off(mtk->phys[i - 1]);
 435
 436         return ret;
 437 }
 438
 439 static void xhci_mtk_phy_power_off(struct xhci_hcd_mtk *mtk)
 440 {
 441         unsigned int i;
 442
 443         for (i = 0; i < mtk->num_phys; i++)
 444                 phy_power_off(mtk->phys[i]);
 445 }
 446
 447 static int xhci_mtk_ldos_enable(struct xhci_hcd_mtk *mtk)
 448 {
 449         int ret;
 450
 451         ret = regulator_enable(mtk->vbus);
 452         if (ret) {
 453                 dev_err(mtk->dev, "failed to enable vbus\n");
 454                 return ret;
 455         }
 456
 457         ret = regulator_enable(mtk->vusb33);
 458         if (ret) {
 459                 dev_err(mtk->dev, "failed to enable vusb33\n");
 460                 regulator_disable(mtk->vbus);
 461                 return ret;
 462         }
 463         return 0;
 464 }
 465
 466 static void xhci_mtk_ldos_disable(struct xhci_hcd_mtk *mtk)
 467 {
 468         regulator_disable(mtk->vbus);
 469         regulator_disable(mtk->vusb33);
 470 }
 471
 472 static void xhci_mtk_quirks(struct device *dev, struct xhci_hcd *xhci)
 473 {
 474         struct usb_hcd *hcd = xhci_to_hcd(xhci);
 475         struct xhci_hcd_mtk *mtk = hcd_to_mtk(hcd);
 476
 477         /*
 478          * As of now platform drivers don't provide MSI support so we ensure
 479          * here that the generic code does not try to make a pci_dev from our
 480          * dev struct in order to setup MSI
 481          */
 482         xhci->quirks |= XHCI_PLAT;
 483         xhci->quirks |= XHCI_MTK_HOST;
 484         /*
 485          * MTK host controller gives a spurious successful event after a
 486          * short transfer. Ignore it.
 487          */
 488         xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
 489         if (mtk->lpm_support)
 490                 xhci->quirks |= XHCI_LPM_SUPPORT;
 491 }
 492
 493 /* called during probe() after chip reset completes */
 494 static int xhci_mtk_setup(struct usb_hcd *hcd)
 495 {
 496         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 497         struct xhci_hcd_mtk *mtk = hcd_to_mtk(hcd);
 498         int ret;
 499
 500         if (usb_hcd_is_primary_hcd(hcd)) {
 501                 ret = xhci_mtk_ssusb_config(mtk);
 502                 if (ret)
 503                         return ret;
 504         }
 505
 506         ret = xhci_gen_setup(hcd, xhci_mtk_quirks);
 507         if (ret)
 508                 return ret;
 509
 510         if (usb_hcd_is_primary_hcd(hcd)) {
 511                 mtk->num_u3_ports = xhci->num_usb3_ports;
 512                 mtk->num_u2_ports = xhci->num_usb2_ports;
 513                 ret = xhci_mtk_sch_init(mtk);
 514                 if (ret)
 515                         return ret;
 516         }
 517
 518         return ret;
 519 }
 520
 521 static int xhci_mtk_probe(struct platform_device *pdev)
 522 {
 523         struct device *dev = &pdev->dev;
 524         struct device_node *node = dev->of_node;
 525         struct xhci_hcd_mtk *mtk;
 526         const struct hc_driver *driver;
 527         struct xhci_hcd *xhci;
 528         struct resource *res;
 529         struct usb_hcd *hcd;
 530         struct phy *phy;
 531         int phy_num;
 532         int ret = -ENODEV;
 533         int irq;
 534
 535         if (usb_disabled())
 536                 return -ENODEV;
 537
 538         driver = &xhci_mtk_hc_driver;
 539         mtk = devm_kzalloc(dev, sizeof(*mtk), GFP_KERNEL);
 540         if (!mtk)
 541                 return -ENOMEM;
 542
 543         mtk->dev = dev;
 544         mtk->vbus = devm_regulator_get(dev, "vbus");
 545         if (IS_ERR(mtk->vbus)) {
 546                 dev_err(dev, "fail to get vbus\n");
 547                 return PTR_ERR(mtk->vbus);
 548         }
 549
 550         mtk->vusb33 = devm_regulator_get(dev, "vusb33");
 551         if (IS_ERR(mtk->vusb33)) {
 552                 dev_err(dev, "fail to get vusb33\n");
 553                 return PTR_ERR(mtk->vusb33);
 554         }
 555
 556         mtk->sys_clk = devm_clk_get(dev, "sys_ck");
 557         if (IS_ERR(mtk->sys_clk)) {
 558                 dev_err(dev, "fail to get sys_ck\n");
 559                 return PTR_ERR(mtk->sys_clk);
 560         }
 561
 562         /*
 563          * reference clock is usually a "fixed-clock", make it optional
 564          * for backward compatibility and ignore the error if it does
 565          * not exist.
 566          */
 567         mtk->ref_clk = devm_clk_get(dev, "ref_ck");
 568         if (IS_ERR(mtk->ref_clk)) {
 569                 if (PTR_ERR(mtk->ref_clk) == -EPROBE_DEFER)
 570                         return -EPROBE_DEFER;
 571
 572                 mtk->ref_clk = NULL;
 573         }
 574
 575         mtk->lpm_support = of_property_read_bool(node, "usb3-lpm-capable");
 576
 577         ret = usb_wakeup_of_property_parse(mtk, node);
 578         if (ret)
 579                 return ret;
 580
 581         mtk->num_phys = of_count_phandle_with_args(node,
 582                         "phys", "#phy-cells");
 583         if (mtk->num_phys > 0) {
 584                 mtk->phys = devm_kcalloc(dev, mtk->num_phys,
 585                                         sizeof(*mtk->phys), GFP_KERNEL);
 586                 if (!mtk->phys)
 587                         return -ENOMEM;
 588         } else {
 589                 mtk->num_phys = 0;
 590         }
 591         pm_runtime_enable(dev);
 592         pm_runtime_get_sync(dev);
 593         device_enable_async_suspend(dev);
 594
 595         ret = xhci_mtk_ldos_enable(mtk);
 596         if (ret)
 597                 goto disable_pm;
 598
 599         ret = xhci_mtk_clks_enable(mtk);
 600         if (ret)
 601                 goto disable_ldos;
 602
 603         irq = platform_get_irq(pdev, 0);
 604         if (irq < 0) {
 605                 ret = irq;
 606                 goto disable_clk;
 607         }
 608
 609         /* Initialize dma_mask and coherent_dma_mask to 32-bits */
 610         ret = dma_set_coherent_mask(dev, DMA_BIT_MASK(32));
 611         if (ret)
 612                 goto disable_clk;
 613
 614         if (!dev->dma_mask)
 615                 dev->dma_mask = &dev->coherent_dma_mask;
 616         else
 617                 dma_set_mask(dev, DMA_BIT_MASK(32));
 618
 619         hcd = usb_create_hcd(driver, dev, dev_name(dev));
 620         if (!hcd) {
 621                 ret = -ENOMEM;
 622                 goto disable_clk;
 623         }
 624
 625         /*
 626          * USB 2.0 roothub is stored in the platform_device.
 627          * Swap it with mtk HCD.
 628          */
 629         mtk->hcd = platform_get_drvdata(pdev);
 630         platform_set_drvdata(pdev, mtk);
 631
 632         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mac");
 633         hcd->regs = devm_ioremap_resource(dev, res);
 634         if (IS_ERR(hcd->regs)) {
 635                 ret = PTR_ERR(hcd->regs);
 636                 goto put_usb2_hcd;
 637         }
 638         hcd->rsrc_start = res->start;
 639         hcd->rsrc_len = resource_size(res);
 640
 641         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ippc");
 642         if (res) {      /* ippc register is optional */
 643                 mtk->ippc_regs = devm_ioremap_resource(dev, res);
 644                 if (IS_ERR(mtk->ippc_regs)) {
 645                         ret = PTR_ERR(mtk->ippc_regs);
 646                         goto put_usb2_hcd;
 647                 }
 648                 mtk->has_ippc = true;
 649         } else {
 650                 mtk->has_ippc = false;
 651         }
 652
 653         for (phy_num = 0; phy_num < mtk->num_phys; phy_num++) {
 654                 phy = devm_of_phy_get_by_index(dev, node, phy_num);
 655                 if (IS_ERR(phy)) {
 656                         ret = PTR_ERR(phy);
 657                         goto put_usb2_hcd;
 658                 }
 659                 mtk->phys[phy_num] = phy;
 660         }
 661
 662         ret = xhci_mtk_phy_init(mtk);
 663         if (ret)
 664                 goto put_usb2_hcd;
 665
 666         ret = xhci_mtk_phy_power_on(mtk);
 667         if (ret)
 668                 goto exit_phys;
 669
 670         device_init_wakeup(dev, true);
 671
 672         xhci = hcd_to_xhci(hcd);
 673         xhci->main_hcd = hcd;
 674         xhci->shared_hcd = usb_create_shared_hcd(driver, dev,
 675                         dev_name(dev), hcd);
 676         if (!xhci->shared_hcd) {
 677                 ret = -ENOMEM;
 678                 goto power_off_phys;
 679         }
 680
 681         if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
 682                 xhci->shared_hcd->can_do_streams = 1;
 683
 684         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
 685         if (ret)
 686                 goto put_usb3_hcd;
 687
 688         ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
 689         if (ret)
 690                 goto dealloc_usb2_hcd;
 691
 692         return 0;
 693
 694 dealloc_usb2_hcd:
 695         usb_remove_hcd(hcd);
 696
 697 put_usb3_hcd:
 698         xhci_mtk_sch_exit(mtk);
 699         usb_put_hcd(xhci->shared_hcd);
 700
 701 power_off_phys:
 702         xhci_mtk_phy_power_off(mtk);
 703         device_init_wakeup(dev, false);
 704
 705 exit_phys:
 706         xhci_mtk_phy_exit(mtk);
 707
 708 put_usb2_hcd:
 709         usb_put_hcd(hcd);
 710
 711 disable_clk:
 712         xhci_mtk_clks_disable(mtk);
 713
 714 disable_ldos:
 715         xhci_mtk_ldos_disable(mtk);
 716
 717 disable_pm:
 718         pm_runtime_put_sync(dev);
 719         pm_runtime_disable(dev);
 720         return ret;
 721 }
 722
 723 static int xhci_mtk_remove(struct platform_device *dev)
 724 {
 725         struct xhci_hcd_mtk *mtk = platform_get_drvdata(dev);
 726         struct usb_hcd  *hcd = mtk->hcd;
 727         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 728
 729         usb_remove_hcd(xhci->shared_hcd);
 730         xhci_mtk_phy_power_off(mtk);
 731         xhci_mtk_phy_exit(mtk);
 732         device_init_wakeup(&dev->dev, false);
 733
 734         usb_remove_hcd(hcd);
 735         usb_put_hcd(xhci->shared_hcd);
 736         usb_put_hcd(hcd);
 737         xhci_mtk_sch_exit(mtk);
 738         xhci_mtk_clks_disable(mtk);
 739         xhci_mtk_ldos_disable(mtk);
 740         pm_runtime_put_sync(&dev->dev);
 741         pm_runtime_disable(&dev->dev);
 742
 743         return 0;
 744 }
 745
 746 /*
 747  * if ip sleep fails, and all clocks are disabled, access register will hang
 748  * AHB bus, so stop polling roothubs to avoid regs access on bus suspend.
 749  * and no need to check whether ip sleep failed or not; this will cause SPM
 750  * to wake up system immediately after system suspend complete if ip sleep
 751  * fails, it is what we wanted.
 752  */
 753 static int __maybe_unused xhci_mtk_suspend(struct device *dev)
 754 {
 755         struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
 756         struct usb_hcd *hcd = mtk->hcd;
 757         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 758
 759         xhci_dbg(xhci, "%s: stop port polling\n", __func__);
 760         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
 761         del_timer_sync(&hcd->rh_timer);
 762         clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
 763         del_timer_sync(&xhci->shared_hcd->rh_timer);
 764
 765         xhci_mtk_host_disable(mtk);
 766         xhci_mtk_phy_power_off(mtk);
 767         xhci_mtk_clks_disable(mtk);
 768         usb_wakeup_enable(mtk);
 769         return 0;
 770 }
 771
 772 static int __maybe_unused xhci_mtk_resume(struct device *dev)
 773 {
 774         struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
 775         struct usb_hcd *hcd = mtk->hcd;
 776         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
 777
 778         usb_wakeup_disable(mtk);
 779         xhci_mtk_clks_enable(mtk);
 780         xhci_mtk_phy_power_on(mtk);
 781         xhci_mtk_host_enable(mtk);
 782
 783         xhci_dbg(xhci, "%s: restart port polling\n", __func__);
 784         set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
 785         usb_hcd_poll_rh_status(hcd);
 786         set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
 787         usb_hcd_poll_rh_status(xhci->shared_hcd);
 788         return 0;
 789 }
 790
 791 static const struct dev_pm_ops xhci_mtk_pm_ops = {
 792         SET_SYSTEM_SLEEP_PM_OPS(xhci_mtk_suspend, xhci_mtk_resume)
 793 };
 794 #define DEV_PM_OPS IS_ENABLED(CONFIG_PM) ? &xhci_mtk_pm_ops : NULL
 795
 796 #ifdef CONFIG_OF
 797 static const struct of_device_id mtk_xhci_of_match[] = {
 798         { .compatible = "mediatek,mt8173-xhci"},
 799         { },
 800 };
 801 MODULE_DEVICE_TABLE(of, mtk_xhci_of_match);
 802 #endif
 803
 804 static struct platform_driver mtk_xhci_driver = {
 805         .probe  = xhci_mtk_probe,
 806         .remove = xhci_mtk_remove,
 807         .driver = {
 808                 .name = "xhci-mtk",
 809                 .pm = DEV_PM_OPS,
 810                 .of_match_table = of_match_ptr(mtk_xhci_of_match),
 811         },
 812 };
 813 MODULE_ALIAS("platform:xhci-mtk");
 814
 815 static int __init xhci_mtk_init(void)
 816 {
 817         xhci_init_driver(&xhci_mtk_hc_driver, &xhci_mtk_overrides);
 818         return platform_driver_register(&mtk_xhci_driver);
 819 }
 820 module_init(xhci_mtk_init);
 821
 822 static void __exit xhci_mtk_exit(void)
 823 {
 824         platform_driver_unregister(&mtk_xhci_driver);
 825 }
 826 module_exit(xhci_mtk_exit);
 827
 828 MODULE_AUTHOR("Chunfeng Yun <chunfeng.yun@mediatek.com>");
 829 MODULE_DESCRIPTION("MediaTek xHCI Host Controller Driver");
 830 MODULE_LICENSE("GPL v2");