drivers/usb/dwc3/dwc3-meson-g12a.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * USB Glue for Amlogic G12A SoCs
   4  *
   5  * Copyright (c) 2019 BayLibre, SAS
   6  * Author: Neil Armstrong <narmstrong@baylibre.com>
   7  */
   8
   9 /*
  10  * The USB is organized with a glue around the DWC3 Controller IP as :
  11  * - Control registers for each USB2 Ports
  12  * - Control registers for the USB PHY layer
  13  * - SuperSpeed PHY can be enabled only if port is used
  14  * - Dynamic OTG switching with ID change interrupt
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/clk.h>
  21 #include <linux/of.h>
  22 #include <linux/of_platform.h>
  23 #include <linux/pm_runtime.h>
  24 #include <linux/regmap.h>
  25 #include <linux/bitfield.h>
  26 #include <linux/bitops.h>
  27 #include <linux/reset.h>
  28 #include <linux/phy/phy.h>
  29 #include <linux/usb/otg.h>
  30 #include <linux/usb/role.h>
  31 #include <linux/regulator/consumer.h>
  32
  33 /* USB2 Ports Control Registers, offsets are per-port */
  34
  35 #define U2P_REG_SIZE                                            0x20
  36
  37 #define U2P_R0                                                  0x0
  38         #define U2P_R0_HOST_DEVICE                              BIT(0)
  39         #define U2P_R0_POWER_OK                                 BIT(1)
  40         #define U2P_R0_HAST_MODE                                BIT(2)
  41         #define U2P_R0_POWER_ON_RESET                           BIT(3)
  42         #define U2P_R0_ID_PULLUP                                BIT(4)
  43         #define U2P_R0_DRV_VBUS                                 BIT(5)
  44
  45 #define U2P_R1                                                  0x4
  46         #define U2P_R1_PHY_READY                                BIT(0)
  47         #define U2P_R1_ID_DIG                                   BIT(1)
  48         #define U2P_R1_OTG_SESSION_VALID                        BIT(2)
  49         #define U2P_R1_VBUS_VALID                               BIT(3)
  50
  51 /* USB Glue Control Registers */
  52
  53 #define G12A_GLUE_OFFSET                                        0x80
  54
  55 #define USB_R0                                                  0x00
  56         #define USB_R0_P30_LANE0_TX2RX_LOOPBACK                 BIT(17)
  57         #define USB_R0_P30_LANE0_EXT_PCLK_REQ                   BIT(18)
  58         #define USB_R0_P30_PCS_RX_LOS_MASK_VAL_MASK             GENMASK(28, 19)
  59         #define USB_R0_U2D_SS_SCALEDOWN_MODE_MASK               GENMASK(30, 29)
  60         #define USB_R0_U2D_ACT                                  BIT(31)
  61
  62 #define USB_R1                                                  0x04
  63         #define USB_R1_U3H_BIGENDIAN_GS                         BIT(0)
  64         #define USB_R1_U3H_PME_ENABLE                           BIT(1)
  65         #define USB_R1_U3H_HUB_PORT_OVERCURRENT_MASK            GENMASK(4, 2)
  66         #define USB_R1_U3H_HUB_PORT_PERM_ATTACH_MASK            GENMASK(9, 7)
  67         #define USB_R1_U3H_HOST_U2_PORT_DISABLE_MASK            GENMASK(13, 12)
  68         #define USB_R1_U3H_HOST_U3_PORT_DISABLE                 BIT(16)
  69         #define USB_R1_U3H_HOST_PORT_POWER_CONTROL_PRESENT      BIT(17)
  70         #define USB_R1_U3H_HOST_MSI_ENABLE                      BIT(18)
  71         #define USB_R1_U3H_FLADJ_30MHZ_REG_MASK                 GENMASK(24, 19)
  72         #define USB_R1_P30_PCS_TX_SWING_FULL_MASK               GENMASK(31, 25)
  73
  74 #define USB_R2                                                  0x08
  75         #define USB_R2_P30_PCS_TX_DEEMPH_3P5DB_MASK             GENMASK(25, 20)
  76         #define USB_R2_P30_PCS_TX_DEEMPH_6DB_MASK               GENMASK(31, 26)
  77
  78 #define USB_R3                                                  0x0c
  79         #define USB_R3_P30_SSC_ENABLE                           BIT(0)
  80         #define USB_R3_P30_SSC_RANGE_MASK                       GENMASK(3, 1)
  81         #define USB_R3_P30_SSC_REF_CLK_SEL_MASK                 GENMASK(12, 4)
  82         #define USB_R3_P30_REF_SSP_EN                           BIT(13)
  83
  84 #define USB_R4                                                  0x10
  85         #define USB_R4_P21_PORT_RESET_0                         BIT(0)
  86         #define USB_R4_P21_SLEEP_M0                             BIT(1)
  87         #define USB_R4_MEM_PD_MASK                              GENMASK(3, 2)
  88         #define USB_R4_P21_ONLY                                 BIT(4)
  89
  90 #define USB_R5                                                  0x14
  91         #define USB_R5_ID_DIG_SYNC                              BIT(0)
  92         #define USB_R5_ID_DIG_REG                               BIT(1)
  93         #define USB_R5_ID_DIG_CFG_MASK                          GENMASK(3, 2)
  94         #define USB_R5_ID_DIG_EN_0                              BIT(4)
  95         #define USB_R5_ID_DIG_EN_1                              BIT(5)
  96         #define USB_R5_ID_DIG_CURR                              BIT(6)
  97         #define USB_R5_ID_DIG_IRQ                               BIT(7)
  98         #define USB_R5_ID_DIG_TH_MASK                           GENMASK(15, 8)
  99         #define USB_R5_ID_DIG_CNT_MASK                          GENMASK(23, 16)
 100
 101 #define PHY_COUNT                                               3
 102 #define USB2_OTG_PHY                                            1
 103
 104 static struct clk_bulk_data meson_gxl_clocks[] = {
 105         { .id = "usb_ctrl" },
 106         { .id = "ddr" },
 107 };
 108
 109 static struct clk_bulk_data meson_g12a_clocks[] = {
 110         { .id = NULL },
 111 };
 112
 113 static struct clk_bulk_data meson_a1_clocks[] = {
 114         { .id = "usb_ctrl" },
 115         { .id = "usb_bus" },
 116         { .id = "xtal_usb_ctrl" },
 117 };
 118
 119 static const char * const meson_gxm_phy_names[] = {
 120         "usb2-phy0", "usb2-phy1", "usb2-phy2",
 121 };
 122
 123 static const char * const meson_g12a_phy_names[] = {
 124         "usb2-phy0", "usb2-phy1", "usb3-phy0",
 125 };
 126
 127 /*
 128  * Amlogic A1 has a single physical PHY, in slot 1, but still has the
 129  * two U2 PHY controls register blocks like G12A.
 130  * AXG has the similar scheme, thus needs the same tweak.
 131  * Handling the first PHY on slot 1 would need a large amount of code
 132  * changes, and the current management is generic enough to handle it
 133  * correctly when only the "usb2-phy1" phy is specified on-par with the
 134  * DT bindings.
 135  */
 136 static const char * const meson_a1_phy_names[] = {
 137         "usb2-phy0", "usb2-phy1"
 138 };
 139
 140 struct dwc3_meson_g12a;
 141
 142 struct dwc3_meson_g12a_drvdata {
 143         bool otg_switch_supported;
 144         bool otg_phy_host_port_disable;
 145         struct clk_bulk_data *clks;
 146         int num_clks;
 147         const char * const *phy_names;
 148         int num_phys;
 149         int (*setup_regmaps)(struct dwc3_meson_g12a *priv, void __iomem *base);
 150         int (*usb2_init_phy)(struct dwc3_meson_g12a *priv, int i,
 151                              enum phy_mode mode);
 152         int (*set_phy_mode)(struct dwc3_meson_g12a *priv, int i,
 153                             enum phy_mode mode);
 154         int (*usb_init)(struct dwc3_meson_g12a *priv);
 155         int (*usb_post_init)(struct dwc3_meson_g12a *priv);
 156 };
 157
 158 static int dwc3_meson_gxl_setup_regmaps(struct dwc3_meson_g12a *priv,
 159                                         void __iomem *base);
 160 static int dwc3_meson_g12a_setup_regmaps(struct dwc3_meson_g12a *priv,
 161                                          void __iomem *base);
 162
 163 static int dwc3_meson_g12a_usb2_init_phy(struct dwc3_meson_g12a *priv, int i,
 164                                          enum phy_mode mode);
 165 static int dwc3_meson_gxl_usb2_init_phy(struct dwc3_meson_g12a *priv, int i,
 166                                         enum phy_mode mode);
 167
 168 static int dwc3_meson_g12a_set_phy_mode(struct dwc3_meson_g12a *priv,
 169                                         int i, enum phy_mode mode);
 170 static int dwc3_meson_gxl_set_phy_mode(struct dwc3_meson_g12a *priv,
 171                                        int i, enum phy_mode mode);
 172
 173 static int dwc3_meson_g12a_usb_init(struct dwc3_meson_g12a *priv);
 174 static int dwc3_meson_gxl_usb_init(struct dwc3_meson_g12a *priv);
 175
 176 static int dwc3_meson_gxl_usb_post_init(struct dwc3_meson_g12a *priv);
 177
 178 /*
 179  * For GXL and GXM SoCs:
 180  * USB Phy muxing between the DWC2 Device controller and the DWC3 Host
 181  * controller is buggy when switching from Device to Host when USB port
 182  * is unpopulated, it causes the DWC3 to hard crash.
 183  * When populated (including OTG switching with ID pin), the switch works
 184  * like a charm like on the G12A platforms.
 185  * In order to still switch from Host to Device on an USB Type-A port,
 186  * an U2_PORT_DISABLE bit has been added to disconnect the DWC3 Host
 187  * controller from the port, but when used the DWC3 controller must be
 188  * reset to recover usage of the port.
 189  */
 190
 191 static struct dwc3_meson_g12a_drvdata gxl_drvdata = {
 192         .otg_switch_supported = true,
 193         .otg_phy_host_port_disable = true,
 194         .clks = meson_gxl_clocks,
 195         .num_clks = ARRAY_SIZE(meson_g12a_clocks),
 196         .phy_names = meson_a1_phy_names,
 197         .num_phys = ARRAY_SIZE(meson_a1_phy_names),
 198         .setup_regmaps = dwc3_meson_gxl_setup_regmaps,
 199         .usb2_init_phy = dwc3_meson_gxl_usb2_init_phy,
 200         .set_phy_mode = dwc3_meson_gxl_set_phy_mode,
 201         .usb_init = dwc3_meson_gxl_usb_init,
 202         .usb_post_init = dwc3_meson_gxl_usb_post_init,
 203 };
 204
 205 static struct dwc3_meson_g12a_drvdata gxm_drvdata = {
 206         .otg_switch_supported = true,
 207         .otg_phy_host_port_disable = true,
 208         .clks = meson_gxl_clocks,
 209         .num_clks = ARRAY_SIZE(meson_g12a_clocks),
 210         .phy_names = meson_gxm_phy_names,
 211         .num_phys = ARRAY_SIZE(meson_gxm_phy_names),
 212         .setup_regmaps = dwc3_meson_gxl_setup_regmaps,
 213         .usb2_init_phy = dwc3_meson_gxl_usb2_init_phy,
 214         .set_phy_mode = dwc3_meson_gxl_set_phy_mode,
 215         .usb_init = dwc3_meson_gxl_usb_init,
 216         .usb_post_init = dwc3_meson_gxl_usb_post_init,
 217 };
 218
 219 static struct dwc3_meson_g12a_drvdata axg_drvdata = {
 220         .otg_switch_supported = true,
 221         .clks = meson_gxl_clocks,
 222         .num_clks = ARRAY_SIZE(meson_gxl_clocks),
 223         .phy_names = meson_a1_phy_names,
 224         .num_phys = ARRAY_SIZE(meson_a1_phy_names),
 225         .setup_regmaps = dwc3_meson_gxl_setup_regmaps,
 226         .usb2_init_phy = dwc3_meson_gxl_usb2_init_phy,
 227         .set_phy_mode = dwc3_meson_gxl_set_phy_mode,
 228         .usb_init = dwc3_meson_g12a_usb_init,
 229         .usb_post_init = dwc3_meson_gxl_usb_post_init,
 230 };
 231
 232 static struct dwc3_meson_g12a_drvdata g12a_drvdata = {
 233         .otg_switch_supported = true,
 234         .clks = meson_g12a_clocks,
 235         .num_clks = ARRAY_SIZE(meson_g12a_clocks),
 236         .phy_names = meson_g12a_phy_names,
 237         .num_phys = ARRAY_SIZE(meson_g12a_phy_names),
 238         .setup_regmaps = dwc3_meson_g12a_setup_regmaps,
 239         .usb2_init_phy = dwc3_meson_g12a_usb2_init_phy,
 240         .set_phy_mode = dwc3_meson_g12a_set_phy_mode,
 241         .usb_init = dwc3_meson_g12a_usb_init,
 242 };
 243
 244 static struct dwc3_meson_g12a_drvdata a1_drvdata = {
 245         .otg_switch_supported = false,
 246         .clks = meson_a1_clocks,
 247         .num_clks = ARRAY_SIZE(meson_a1_clocks),
 248         .phy_names = meson_a1_phy_names,
 249         .num_phys = ARRAY_SIZE(meson_a1_phy_names),
 250         .setup_regmaps = dwc3_meson_g12a_setup_regmaps,
 251         .usb2_init_phy = dwc3_meson_g12a_usb2_init_phy,
 252         .set_phy_mode = dwc3_meson_g12a_set_phy_mode,
 253         .usb_init = dwc3_meson_g12a_usb_init,
 254 };
 255
 256 struct dwc3_meson_g12a {
 257         struct device           *dev;
 258         struct regmap           *u2p_regmap[PHY_COUNT];
 259         struct regmap           *usb_glue_regmap;
 260         struct reset_control    *reset;
 261         struct phy              *phys[PHY_COUNT];
 262         enum usb_dr_mode        otg_mode;
 263         enum phy_mode           otg_phy_mode;
 264         unsigned int            usb2_ports;
 265         unsigned int            usb3_ports;
 266         struct regulator        *vbus;
 267         struct usb_role_switch_desc switch_desc;
 268         struct usb_role_switch  *role_switch;
 269         const struct dwc3_meson_g12a_drvdata *drvdata;
 270 };
 271
 272 static int dwc3_meson_gxl_set_phy_mode(struct dwc3_meson_g12a *priv,
 273                                          int i, enum phy_mode mode)
 274 {
 275         return phy_set_mode(priv->phys[i], mode);
 276 }
 277
 278 static int dwc3_meson_gxl_usb2_init_phy(struct dwc3_meson_g12a *priv, int i,
 279                                         enum phy_mode mode)
 280 {
 281         /* On GXL PHY must be started in device mode for DWC2 init */
 282         return priv->drvdata->set_phy_mode(priv, i,
 283                                 (i == USB2_OTG_PHY) ? PHY_MODE_USB_DEVICE
 284                                                     : PHY_MODE_USB_HOST);
 285 }
 286
 287 static int dwc3_meson_g12a_set_phy_mode(struct dwc3_meson_g12a *priv,
 288                                          int i, enum phy_mode mode)
 289 {
 290         if (mode == PHY_MODE_USB_HOST)
 291                 regmap_update_bits(priv->u2p_regmap[i], U2P_R0,
 292                                 U2P_R0_HOST_DEVICE,
 293                                 U2P_R0_HOST_DEVICE);
 294         else
 295                 regmap_update_bits(priv->u2p_regmap[i], U2P_R0,
 296                                 U2P_R0_HOST_DEVICE, 0);
 297
 298         return 0;
 299 }
 300
 301 static int dwc3_meson_g12a_usb2_init_phy(struct dwc3_meson_g12a *priv, int i,
 302                                          enum phy_mode mode)
 303 {
 304         int ret;
 305
 306         regmap_update_bits(priv->u2p_regmap[i], U2P_R0,
 307                         U2P_R0_POWER_ON_RESET,
 308                         U2P_R0_POWER_ON_RESET);
 309
 310         if (priv->drvdata->otg_switch_supported && i == USB2_OTG_PHY) {
 311                 regmap_update_bits(priv->u2p_regmap[i], U2P_R0,
 312                                    U2P_R0_ID_PULLUP | U2P_R0_DRV_VBUS,
 313                                    U2P_R0_ID_PULLUP | U2P_R0_DRV_VBUS);
 314
 315                 ret = priv->drvdata->set_phy_mode(priv, i, mode);
 316         } else
 317                 ret = priv->drvdata->set_phy_mode(priv, i,
 318                                                   PHY_MODE_USB_HOST);
 319
 320         if (ret)
 321                 return ret;
 322
 323         regmap_update_bits(priv->u2p_regmap[i], U2P_R0,
 324                         U2P_R0_POWER_ON_RESET, 0);
 325
 326         return 0;
 327 }
 328
 329 static int dwc3_meson_g12a_usb2_init(struct dwc3_meson_g12a *priv,
 330                                      enum phy_mode mode)
 331 {
 332         int i, ret;
 333
 334         for (i = 0; i < priv->drvdata->num_phys; ++i) {
 335                 if (!priv->phys[i])
 336                         continue;
 337
 338                 if (!strstr(priv->drvdata->phy_names[i], "usb2"))
 339                         continue;
 340
 341                 ret = priv->drvdata->usb2_init_phy(priv, i, mode);
 342                 if (ret)
 343                         return ret;
 344         }
 345
 346         return 0;
 347 }
 348
 349 static void dwc3_meson_g12a_usb3_init(struct dwc3_meson_g12a *priv)
 350 {
 351         regmap_update_bits(priv->usb_glue_regmap, USB_R3,
 352                         USB_R3_P30_SSC_RANGE_MASK |
 353                         USB_R3_P30_REF_SSP_EN,
 354                         USB_R3_P30_SSC_ENABLE |
 355                         FIELD_PREP(USB_R3_P30_SSC_RANGE_MASK, 2) |
 356                         USB_R3_P30_REF_SSP_EN);
 357         udelay(2);
 358
 359         regmap_update_bits(priv->usb_glue_regmap, USB_R2,
 360                         USB_R2_P30_PCS_TX_DEEMPH_3P5DB_MASK,
 361                         FIELD_PREP(USB_R2_P30_PCS_TX_DEEMPH_3P5DB_MASK, 0x15));
 362
 363         regmap_update_bits(priv->usb_glue_regmap, USB_R2,
 364                         USB_R2_P30_PCS_TX_DEEMPH_6DB_MASK,
 365                         FIELD_PREP(USB_R2_P30_PCS_TX_DEEMPH_6DB_MASK, 0x20));
 366
 367         udelay(2);
 368
 369         regmap_update_bits(priv->usb_glue_regmap, USB_R1,
 370                         USB_R1_U3H_HOST_PORT_POWER_CONTROL_PRESENT,
 371                         USB_R1_U3H_HOST_PORT_POWER_CONTROL_PRESENT);
 372
 373         regmap_update_bits(priv->usb_glue_regmap, USB_R1,
 374                         USB_R1_P30_PCS_TX_SWING_FULL_MASK,
 375                         FIELD_PREP(USB_R1_P30_PCS_TX_SWING_FULL_MASK, 127));
 376 }
 377
 378 static void dwc3_meson_g12a_usb_otg_apply_mode(struct dwc3_meson_g12a *priv,
 379                                                enum phy_mode mode)
 380 {
 381         if (mode == PHY_MODE_USB_DEVICE) {
 382                 if (priv->otg_mode != USB_DR_MODE_OTG &&
 383                     priv->drvdata->otg_phy_host_port_disable)
 384                         /* Isolate the OTG PHY port from the Host Controller */
 385                         regmap_update_bits(priv->usb_glue_regmap, USB_R1,
 386                                 USB_R1_U3H_HOST_U2_PORT_DISABLE_MASK,
 387                                 FIELD_PREP(USB_R1_U3H_HOST_U2_PORT_DISABLE_MASK,
 388                                            BIT(USB2_OTG_PHY)));
 389
 390                 regmap_update_bits(priv->usb_glue_regmap, USB_R0,
 391                                 USB_R0_U2D_ACT, USB_R0_U2D_ACT);
 392                 regmap_update_bits(priv->usb_glue_regmap, USB_R0,
 393                                 USB_R0_U2D_SS_SCALEDOWN_MODE_MASK, 0);
 394                 regmap_update_bits(priv->usb_glue_regmap, USB_R4,
 395                                 USB_R4_P21_SLEEP_M0, USB_R4_P21_SLEEP_M0);
 396         } else {
 397                 if (priv->otg_mode != USB_DR_MODE_OTG &&
 398                     priv->drvdata->otg_phy_host_port_disable) {
 399                         regmap_update_bits(priv->usb_glue_regmap, USB_R1,
 400                                 USB_R1_U3H_HOST_U2_PORT_DISABLE_MASK, 0);
 401                         msleep(500);
 402                 }
 403                 regmap_update_bits(priv->usb_glue_regmap, USB_R0,
 404                                 USB_R0_U2D_ACT, 0);
 405                 regmap_update_bits(priv->usb_glue_regmap, USB_R4,
 406                                 USB_R4_P21_SLEEP_M0, 0);
 407         }
 408 }
 409
 410 static int dwc3_meson_g12a_usb_init_glue(struct dwc3_meson_g12a *priv,
 411                                          enum phy_mode mode)
 412 {
 413         int ret;
 414
 415         ret = dwc3_meson_g12a_usb2_init(priv, mode);
 416         if (ret)
 417                 return ret;
 418
 419         regmap_update_bits(priv->usb_glue_regmap, USB_R1,
 420                         USB_R1_U3H_FLADJ_30MHZ_REG_MASK,
 421                         FIELD_PREP(USB_R1_U3H_FLADJ_30MHZ_REG_MASK, 0x20));
 422
 423         regmap_update_bits(priv->usb_glue_regmap, USB_R5,
 424                         USB_R5_ID_DIG_EN_0,
 425                         USB_R5_ID_DIG_EN_0);
 426         regmap_update_bits(priv->usb_glue_regmap, USB_R5,
 427                         USB_R5_ID_DIG_EN_1,
 428                         USB_R5_ID_DIG_EN_1);
 429         regmap_update_bits(priv->usb_glue_regmap, USB_R5,
 430                         USB_R5_ID_DIG_TH_MASK,
 431                         FIELD_PREP(USB_R5_ID_DIG_TH_MASK, 0xff));
 432
 433         /* If we have an actual SuperSpeed port, initialize it */
 434         if (priv->usb3_ports)
 435                 dwc3_meson_g12a_usb3_init(priv);
 436
 437         dwc3_meson_g12a_usb_otg_apply_mode(priv, mode);
 438
 439         return 0;
 440 }
 441
 442 static const struct regmap_config phy_meson_g12a_usb_glue_regmap_conf = {
 443         .name = "usb-glue",
 444         .reg_bits = 8,
 445         .val_bits = 32,
 446         .reg_stride = 4,
 447         .max_register = USB_R5,
 448 };
 449
 450 static int dwc3_meson_g12a_get_phys(struct dwc3_meson_g12a *priv)
 451 {
 452         const char *phy_name;
 453         int i;
 454
 455         for (i = 0 ; i < priv->drvdata->num_phys ; ++i) {
 456                 phy_name = priv->drvdata->phy_names[i];
 457                 priv->phys[i] = devm_phy_optional_get(priv->dev, phy_name);
 458                 if (!priv->phys[i])
 459                         continue;
 460
 461                 if (IS_ERR(priv->phys[i]))
 462                         return PTR_ERR(priv->phys[i]);
 463
 464                 if (strstr(phy_name, "usb3"))
 465                         priv->usb3_ports++;
 466                 else
 467                         priv->usb2_ports++;
 468         }
 469
 470         dev_info(priv->dev, "USB2 ports: %d\n", priv->usb2_ports);
 471         dev_info(priv->dev, "USB3 ports: %d\n", priv->usb3_ports);
 472
 473         return 0;
 474 }
 475
 476 static enum phy_mode dwc3_meson_g12a_get_id(struct dwc3_meson_g12a *priv)
 477 {
 478         u32 reg;
 479
 480         regmap_read(priv->usb_glue_regmap, USB_R5, &reg);
 481
 482         if (reg & (USB_R5_ID_DIG_SYNC | USB_R5_ID_DIG_REG))
 483                 return PHY_MODE_USB_DEVICE;
 484
 485         return PHY_MODE_USB_HOST;
 486 }
 487
 488 static int dwc3_meson_g12a_otg_mode_set(struct dwc3_meson_g12a *priv,
 489                                         enum phy_mode mode)
 490 {
 491         int ret;
 492
 493         if (!priv->drvdata->otg_switch_supported || !priv->phys[USB2_OTG_PHY])
 494                 return -EINVAL;
 495
 496         if (mode == PHY_MODE_USB_HOST)
 497                 dev_info(priv->dev, "switching to Host Mode\n");
 498         else
 499                 dev_info(priv->dev, "switching to Device Mode\n");
 500
 501         if (priv->vbus) {
 502                 if (mode == PHY_MODE_USB_DEVICE)
 503                         ret = regulator_disable(priv->vbus);
 504                 else
 505                         ret = regulator_enable(priv->vbus);
 506                 if (ret)
 507                         return ret;
 508         }
 509
 510         priv->otg_phy_mode = mode;
 511
 512         ret = priv->drvdata->set_phy_mode(priv, USB2_OTG_PHY, mode);
 513         if (ret)
 514                 return ret;
 515
 516         dwc3_meson_g12a_usb_otg_apply_mode(priv, mode);
 517
 518         return 0;
 519 }
 520
 521 static int dwc3_meson_g12a_role_set(struct usb_role_switch *sw,
 522                                     enum usb_role role)
 523 {
 524         struct dwc3_meson_g12a *priv = usb_role_switch_get_drvdata(sw);
 525         enum phy_mode mode;
 526
 527         if (role == USB_ROLE_NONE)
 528                 return 0;
 529
 530         mode = (role == USB_ROLE_HOST) ? PHY_MODE_USB_HOST
 531                                        : PHY_MODE_USB_DEVICE;
 532
 533         if (mode == priv->otg_phy_mode)
 534                 return 0;
 535
 536         if (priv->drvdata->otg_phy_host_port_disable)
 537                 dev_warn_once(priv->dev, "Broken manual OTG switch\n");
 538
 539         return dwc3_meson_g12a_otg_mode_set(priv, mode);
 540 }
 541
 542 static enum usb_role dwc3_meson_g12a_role_get(struct usb_role_switch *sw)
 543 {
 544         struct dwc3_meson_g12a *priv = usb_role_switch_get_drvdata(sw);
 545
 546         return priv->otg_phy_mode == PHY_MODE_USB_HOST ?
 547                 USB_ROLE_HOST : USB_ROLE_DEVICE;
 548 }
 549
 550 static irqreturn_t dwc3_meson_g12a_irq_thread(int irq, void *data)
 551 {
 552         struct dwc3_meson_g12a *priv = data;
 553         enum phy_mode otg_id;
 554
 555         otg_id = dwc3_meson_g12a_get_id(priv);
 556         if (otg_id != priv->otg_phy_mode) {
 557                 if (dwc3_meson_g12a_otg_mode_set(priv, otg_id))
 558                         dev_warn(priv->dev, "Failed to switch OTG mode\n");
 559         }
 560
 561         regmap_update_bits(priv->usb_glue_regmap, USB_R5,
 562                            USB_R5_ID_DIG_IRQ, 0);
 563
 564         return IRQ_HANDLED;
 565 }
 566
 567 static struct device *dwc3_meson_g12_find_child(struct device *dev,
 568                                                 const char *compatible)
 569 {
 570         struct platform_device *pdev;
 571         struct device_node *np;
 572
 573         np = of_get_compatible_child(dev->of_node, compatible);
 574         if (!np)
 575                 return NULL;
 576
 577         pdev = of_find_device_by_node(np);
 578         of_node_put(np);
 579         if (!pdev)
 580                 return NULL;
 581
 582         return &pdev->dev;
 583 }
 584
 585 static int dwc3_meson_g12a_otg_init(struct platform_device *pdev,
 586                                     struct dwc3_meson_g12a *priv)
 587 {
 588         enum phy_mode otg_id;
 589         int ret, irq;
 590         struct device *dev = &pdev->dev;
 591
 592         if (!priv->drvdata->otg_switch_supported)
 593                 return 0;
 594
 595         if (priv->otg_mode == USB_DR_MODE_OTG) {
 596                 /* Ack irq before registering */
 597                 regmap_update_bits(priv->usb_glue_regmap, USB_R5,
 598                                    USB_R5_ID_DIG_IRQ, 0);
 599
 600                 irq = platform_get_irq(pdev, 0);
 601                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 602                                                 dwc3_meson_g12a_irq_thread,
 603                                                 IRQF_ONESHOT, pdev->name, priv);
 604                 if (ret)
 605                         return ret;
 606         }
 607
 608         /* Setup OTG mode corresponding to the ID pin */
 609         if (priv->otg_mode == USB_DR_MODE_OTG) {
 610                 otg_id = dwc3_meson_g12a_get_id(priv);
 611                 if (otg_id != priv->otg_phy_mode) {
 612                         if (dwc3_meson_g12a_otg_mode_set(priv, otg_id))
 613                                 dev_warn(dev, "Failed to switch OTG mode\n");
 614                 }
 615         }
 616
 617         /* Setup role switcher */
 618         priv->switch_desc.usb2_port = dwc3_meson_g12_find_child(dev,
 619                                                                 "snps,dwc3");
 620         priv->switch_desc.udc = dwc3_meson_g12_find_child(dev, "snps,dwc2");
 621         priv->switch_desc.allow_userspace_control = true;
 622         priv->switch_desc.set = dwc3_meson_g12a_role_set;
 623         priv->switch_desc.get = dwc3_meson_g12a_role_get;
 624         priv->switch_desc.driver_data = priv;
 625
 626         priv->role_switch = usb_role_switch_register(dev, &priv->switch_desc);
 627         if (IS_ERR(priv->role_switch))
 628                 dev_warn(dev, "Unable to register Role Switch\n");
 629
 630         return 0;
 631 }
 632
 633 static int dwc3_meson_gxl_setup_regmaps(struct dwc3_meson_g12a *priv,
 634                                         void __iomem *base)
 635 {
 636         /* GXL controls the PHY mode in the PHY registers unlike G12A */
 637         priv->usb_glue_regmap = devm_regmap_init_mmio(priv->dev, base,
 638                                         &phy_meson_g12a_usb_glue_regmap_conf);
 639         return PTR_ERR_OR_ZERO(priv->usb_glue_regmap);
 640 }
 641
 642 static int dwc3_meson_g12a_setup_regmaps(struct dwc3_meson_g12a *priv,
 643                                          void __iomem *base)
 644 {
 645         int i;
 646
 647         priv->usb_glue_regmap = devm_regmap_init_mmio(priv->dev,
 648                                         base + G12A_GLUE_OFFSET,
 649                                         &phy_meson_g12a_usb_glue_regmap_conf);
 650         if (IS_ERR(priv->usb_glue_regmap))
 651                 return PTR_ERR(priv->usb_glue_regmap);
 652
 653         /* Create a regmap for each USB2 PHY control register set */
 654         for (i = 0; i < priv->drvdata->num_phys; i++) {
 655                 struct regmap_config u2p_regmap_config = {
 656                         .reg_bits = 8,
 657                         .val_bits = 32,
 658                         .reg_stride = 4,
 659                         .max_register = U2P_R1,
 660                 };
 661
 662                 if (!strstr(priv->drvdata->phy_names[i], "usb2"))
 663                         continue;
 664
 665                 u2p_regmap_config.name = devm_kasprintf(priv->dev, GFP_KERNEL,
 666                                                         "u2p-%d", i);
 667                 if (!u2p_regmap_config.name)
 668                         return -ENOMEM;
 669
 670                 priv->u2p_regmap[i] = devm_regmap_init_mmio(priv->dev,
 671                                                 base + (i * U2P_REG_SIZE),
 672                                                 &u2p_regmap_config);
 673                 if (IS_ERR(priv->u2p_regmap[i]))
 674                         return PTR_ERR(priv->u2p_regmap[i]);
 675         }
 676
 677         return 0;
 678 }
 679
 680 static int dwc3_meson_g12a_usb_init(struct dwc3_meson_g12a *priv)
 681 {
 682         return dwc3_meson_g12a_usb_init_glue(priv, priv->otg_phy_mode);
 683 }
 684
 685 static int dwc3_meson_gxl_usb_init(struct dwc3_meson_g12a *priv)
 686 {
 687         return dwc3_meson_g12a_usb_init_glue(priv, PHY_MODE_USB_DEVICE);
 688 }
 689
 690 static int dwc3_meson_gxl_usb_post_init(struct dwc3_meson_g12a *priv)
 691 {
 692         int ret;
 693
 694         ret = priv->drvdata->set_phy_mode(priv, USB2_OTG_PHY,
 695                                           priv->otg_phy_mode);
 696         if (ret)
 697                 return ret;
 698
 699         dwc3_meson_g12a_usb_otg_apply_mode(priv, priv->otg_phy_mode);
 700
 701         return 0;
 702 }
 703
 704 static int dwc3_meson_g12a_probe(struct platform_device *pdev)
 705 {
 706         struct dwc3_meson_g12a  *priv;
 707         struct device           *dev = &pdev->dev;
 708         struct device_node      *np = dev->of_node;
 709         void __iomem *base;
 710         int ret, i;
 711
 712         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 713         if (!priv)
 714                 return -ENOMEM;
 715
 716         base = devm_platform_ioremap_resource(pdev, 0);
 717         if (IS_ERR(base))
 718                 return PTR_ERR(base);
 719
 720         priv->drvdata = of_device_get_match_data(&pdev->dev);
 721         priv->dev = dev;
 722
 723         priv->vbus = devm_regulator_get_optional(dev, "vbus");
 724         if (IS_ERR(priv->vbus)) {
 725                 if (PTR_ERR(priv->vbus) == -EPROBE_DEFER)
 726                         return PTR_ERR(priv->vbus);
 727                 priv->vbus = NULL;
 728         }
 729
 730         ret = devm_clk_bulk_get(dev,
 731                                 priv->drvdata->num_clks,
 732                                 priv->drvdata->clks);
 733         if (ret)
 734                 return ret;
 735
 736         ret = clk_bulk_prepare_enable(priv->drvdata->num_clks,
 737                                       priv->drvdata->clks);
 738         if (ret)
 739                 return ret;
 740
 741         platform_set_drvdata(pdev, priv);
 742
 743         priv->reset = devm_reset_control_get_shared(dev, NULL);
 744         if (IS_ERR(priv->reset)) {
 745                 ret = PTR_ERR(priv->reset);
 746                 dev_err(dev, "failed to get device reset, err=%d\n", ret);
 747                 goto err_disable_clks;
 748         }
 749
 750         ret = reset_control_reset(priv->reset);
 751         if (ret)
 752                 goto err_disable_clks;
 753
 754         ret = dwc3_meson_g12a_get_phys(priv);
 755         if (ret)
 756                 goto err_disable_clks;
 757
 758         ret = priv->drvdata->setup_regmaps(priv, base);
 759         if (ret)
 760                 goto err_disable_clks;
 761
 762         if (priv->vbus) {
 763                 ret = regulator_enable(priv->vbus);
 764                 if (ret)
 765                         goto err_disable_clks;
 766         }
 767
 768         /* Get dr_mode */
 769         priv->otg_mode = usb_get_dr_mode(dev);
 770
 771         if (priv->otg_mode == USB_DR_MODE_PERIPHERAL)
 772                 priv->otg_phy_mode = PHY_MODE_USB_DEVICE;
 773         else
 774                 priv->otg_phy_mode = PHY_MODE_USB_HOST;
 775
 776         ret = priv->drvdata->usb_init(priv);
 777         if (ret)
 778                 goto err_disable_regulator;
 779
 780         /* Init PHYs */
 781         for (i = 0 ; i < PHY_COUNT ; ++i) {
 782                 ret = phy_init(priv->phys[i]);
 783                 if (ret)
 784                         goto err_disable_regulator;
 785         }
 786
 787         /* Set PHY Power */
 788         for (i = 0 ; i < PHY_COUNT ; ++i) {
 789                 ret = phy_power_on(priv->phys[i]);
 790                 if (ret)
 791                         goto err_phys_exit;
 792         }
 793
 794         if (priv->drvdata->usb_post_init) {
 795                 ret = priv->drvdata->usb_post_init(priv);
 796                 if (ret)
 797                         goto err_phys_power;
 798         }
 799
 800         ret = of_platform_populate(np, NULL, NULL, dev);
 801         if (ret)
 802                 goto err_phys_power;
 803
 804         ret = dwc3_meson_g12a_otg_init(pdev, priv);
 805         if (ret)
 806                 goto err_phys_power;
 807
 808         pm_runtime_set_active(dev);
 809         pm_runtime_enable(dev);
 810         pm_runtime_get_sync(dev);
 811
 812         return 0;
 813
 814 err_phys_power:
 815         for (i = 0 ; i < PHY_COUNT ; ++i)
 816                 phy_power_off(priv->phys[i]);
 817
 818 err_phys_exit:
 819         for (i = 0 ; i < PHY_COUNT ; ++i)
 820                 phy_exit(priv->phys[i]);
 821
 822 err_disable_regulator:
 823         if (priv->vbus)
 824                 regulator_disable(priv->vbus);
 825
 826 err_disable_clks:
 827         clk_bulk_disable_unprepare(priv->drvdata->num_clks,
 828                                    priv->drvdata->clks);
 829
 830         return ret;
 831 }
 832
 833 static int dwc3_meson_g12a_remove(struct platform_device *pdev)
 834 {
 835         struct dwc3_meson_g12a *priv = platform_get_drvdata(pdev);
 836         struct device *dev = &pdev->dev;
 837         int i;
 838
 839         if (priv->drvdata->otg_switch_supported)
 840                 usb_role_switch_unregister(priv->role_switch);
 841
 842         of_platform_depopulate(dev);
 843
 844         for (i = 0 ; i < PHY_COUNT ; ++i) {
 845                 phy_power_off(priv->phys[i]);
 846                 phy_exit(priv->phys[i]);
 847         }
 848
 849         pm_runtime_disable(dev);
 850         pm_runtime_put_noidle(dev);
 851         pm_runtime_set_suspended(dev);
 852
 853         clk_bulk_disable_unprepare(priv->drvdata->num_clks,
 854                                    priv->drvdata->clks);
 855
 856         return 0;
 857 }
 858
 859 static int __maybe_unused dwc3_meson_g12a_runtime_suspend(struct device *dev)
 860 {
 861         struct dwc3_meson_g12a  *priv = dev_get_drvdata(dev);
 862
 863         clk_bulk_disable_unprepare(priv->drvdata->num_clks,
 864                                    priv->drvdata->clks);
 865
 866         return 0;
 867 }
 868
 869 static int __maybe_unused dwc3_meson_g12a_runtime_resume(struct device *dev)
 870 {
 871         struct dwc3_meson_g12a  *priv = dev_get_drvdata(dev);
 872
 873         return clk_bulk_prepare_enable(priv->drvdata->num_clks,
 874                                        priv->drvdata->clks);
 875 }
 876
 877 static int __maybe_unused dwc3_meson_g12a_suspend(struct device *dev)
 878 {
 879         struct dwc3_meson_g12a *priv = dev_get_drvdata(dev);
 880         int i, ret;
 881
 882         if (priv->vbus && priv->otg_phy_mode == PHY_MODE_USB_HOST) {
 883                 ret = regulator_disable(priv->vbus);
 884                 if (ret)
 885                         return ret;
 886         }
 887
 888         for (i = 0 ; i < PHY_COUNT ; ++i) {
 889                 phy_power_off(priv->phys[i]);
 890                 phy_exit(priv->phys[i]);
 891         }
 892
 893         reset_control_assert(priv->reset);
 894
 895         return 0;
 896 }
 897
 898 static int __maybe_unused dwc3_meson_g12a_resume(struct device *dev)
 899 {
 900         struct dwc3_meson_g12a *priv = dev_get_drvdata(dev);
 901         int i, ret;
 902
 903         reset_control_deassert(priv->reset);
 904
 905         ret = priv->drvdata->usb_init(priv);
 906         if (ret)
 907                 return ret;
 908
 909         /* Init PHYs */
 910         for (i = 0 ; i < PHY_COUNT ; ++i) {
 911                 ret = phy_init(priv->phys[i]);
 912                 if (ret)
 913                         return ret;
 914         }
 915
 916         /* Set PHY Power */
 917         for (i = 0 ; i < PHY_COUNT ; ++i) {
 918                 ret = phy_power_on(priv->phys[i]);
 919                 if (ret)
 920                         return ret;
 921         }
 922
 923         if (priv->vbus && priv->otg_phy_mode == PHY_MODE_USB_HOST) {
 924                 ret = regulator_enable(priv->vbus);
 925                 if (ret)
 926                         return ret;
 927         }
 928
 929         return 0;
 930 }
 931
 932 static const struct dev_pm_ops dwc3_meson_g12a_dev_pm_ops = {
 933         SET_SYSTEM_SLEEP_PM_OPS(dwc3_meson_g12a_suspend, dwc3_meson_g12a_resume)
 934         SET_RUNTIME_PM_OPS(dwc3_meson_g12a_runtime_suspend,
 935                            dwc3_meson_g12a_runtime_resume, NULL)
 936 };
 937
 938 static const struct of_device_id dwc3_meson_g12a_match[] = {
 939         {
 940                 .compatible = "amlogic,meson-gxl-usb-ctrl",
 941                 .data = &gxl_drvdata,
 942         },
 943         {
 944                 .compatible = "amlogic,meson-gxm-usb-ctrl",
 945                 .data = &gxm_drvdata,
 946         },
 947         {
 948                 .compatible = "amlogic,meson-axg-usb-ctrl",
 949                 .data = &axg_drvdata,
 950         },
 951         {
 952                 .compatible = "amlogic,meson-g12a-usb-ctrl",
 953                 .data = &g12a_drvdata,
 954         },
 955         {
 956                 .compatible = "amlogic,meson-a1-usb-ctrl",
 957                 .data = &a1_drvdata,
 958         },
 959         { /* Sentinel */ }
 960 };
 961 MODULE_DEVICE_TABLE(of, dwc3_meson_g12a_match);
 962
 963 static struct platform_driver dwc3_meson_g12a_driver = {
 964         .probe          = dwc3_meson_g12a_probe,
 965         .remove         = dwc3_meson_g12a_remove,
 966         .driver         = {
 967                 .name   = "dwc3-meson-g12a",
 968                 .of_match_table = dwc3_meson_g12a_match,
 969                 .pm     = &dwc3_meson_g12a_dev_pm_ops,
 970         },
 971 };
 972
 973 module_platform_driver(dwc3_meson_g12a_driver);
 974 MODULE_LICENSE("GPL v2");
 975 MODULE_DESCRIPTION("Amlogic Meson G12A USB Glue Layer");
 976 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");