drivers/phy/qualcomm/phy-qcom-usb-hs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /**
   3  * Copyright (C) 2016 Linaro Ltd
   4  */
   5 #include <linux/module.h>
   6 #include <linux/ulpi/driver.h>
   7 #include <linux/ulpi/regs.h>
   8 #include <linux/clk.h>
   9 #include <linux/regulator/consumer.h>
  10 #include <linux/of_device.h>
  11 #include <linux/phy/phy.h>
  12 #include <linux/reset.h>
  13 #include <linux/extcon.h>
  14 #include <linux/notifier.h>
  15
  16 #define ULPI_PWR_CLK_MNG_REG            0x88
  17 # define ULPI_PWR_OTG_COMP_DISABLE      BIT(0)
  18
  19 #define ULPI_MISC_A                     0x96
  20 # define ULPI_MISC_A_VBUSVLDEXTSEL      BIT(1)
  21 # define ULPI_MISC_A_VBUSVLDEXT         BIT(0)
  22
  23
  24 struct ulpi_seq {
  25         u8 addr;
  26         u8 val;
  27 };
  28
  29 struct qcom_usb_hs_phy {
  30         struct ulpi *ulpi;
  31         struct phy *phy;
  32         struct clk *ref_clk;
  33         struct clk *sleep_clk;
  34         struct regulator *v1p8;
  35         struct regulator *v3p3;
  36         struct reset_control *reset;
  37         struct ulpi_seq *init_seq;
  38         struct extcon_dev *vbus_edev;
  39         struct notifier_block vbus_notify;
  40 };
  41
  42 static int qcom_usb_hs_phy_set_mode(struct phy *phy,
  43                                     enum phy_mode mode, int submode)
  44 {
  45         struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
  46         u8 addr;
  47         int ret;
  48
  49         if (!uphy->vbus_edev) {
  50                 u8 val = 0;
  51
  52                 switch (mode) {
  53                 case PHY_MODE_USB_OTG:
  54                 case PHY_MODE_USB_HOST:
  55                         val |= ULPI_INT_IDGRD;
  56                         /* fall through */
  57                 case PHY_MODE_USB_DEVICE:
  58                         val |= ULPI_INT_SESS_VALID;
  59                 default:
  60                         break;
  61                 }
  62
  63                 ret = ulpi_write(uphy->ulpi, ULPI_USB_INT_EN_RISE, val);
  64                 if (ret)
  65                         return ret;
  66                 ret = ulpi_write(uphy->ulpi, ULPI_USB_INT_EN_FALL, val);
  67         } else {
  68                 switch (mode) {
  69                 case PHY_MODE_USB_OTG:
  70                 case PHY_MODE_USB_DEVICE:
  71                         addr = ULPI_SET(ULPI_MISC_A);
  72                         break;
  73                 case PHY_MODE_USB_HOST:
  74                         addr = ULPI_CLR(ULPI_MISC_A);
  75                         break;
  76                 default:
  77                         return -EINVAL;
  78                 }
  79
  80                 ret = ulpi_write(uphy->ulpi, ULPI_SET(ULPI_PWR_CLK_MNG_REG),
  81                                  ULPI_PWR_OTG_COMP_DISABLE);
  82                 if (ret)
  83                         return ret;
  84                 ret = ulpi_write(uphy->ulpi, addr, ULPI_MISC_A_VBUSVLDEXTSEL);
  85         }
  86
  87         return ret;
  88 }
  89
  90 static int
  91 qcom_usb_hs_phy_vbus_notifier(struct notifier_block *nb, unsigned long event,
  92                               void *ptr)
  93 {
  94         struct qcom_usb_hs_phy *uphy;
  95         u8 addr;
  96
  97         uphy = container_of(nb, struct qcom_usb_hs_phy, vbus_notify);
  98
  99         if (event)
 100                 addr = ULPI_SET(ULPI_MISC_A);
 101         else
 102                 addr = ULPI_CLR(ULPI_MISC_A);
 103
 104         return ulpi_write(uphy->ulpi, addr, ULPI_MISC_A_VBUSVLDEXT);
 105 }
 106
 107 static int qcom_usb_hs_phy_power_on(struct phy *phy)
 108 {
 109         struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
 110         struct ulpi *ulpi = uphy->ulpi;
 111         const struct ulpi_seq *seq;
 112         int ret, state;
 113
 114         ret = clk_prepare_enable(uphy->ref_clk);
 115         if (ret)
 116                 return ret;
 117
 118         ret = clk_prepare_enable(uphy->sleep_clk);
 119         if (ret)
 120                 goto err_sleep;
 121
 122         ret = regulator_set_load(uphy->v1p8, 50000);
 123         if (ret < 0)
 124                 goto err_1p8;
 125
 126         ret = regulator_enable(uphy->v1p8);
 127         if (ret)
 128                 goto err_1p8;
 129
 130         ret = regulator_set_voltage_triplet(uphy->v3p3, 3050000, 3300000,
 131                                             3300000);
 132         if (ret)
 133                 goto err_3p3;
 134
 135         ret = regulator_set_load(uphy->v3p3, 50000);
 136         if (ret < 0)
 137                 goto err_3p3;
 138
 139         ret = regulator_enable(uphy->v3p3);
 140         if (ret)
 141                 goto err_3p3;
 142
 143         for (seq = uphy->init_seq; seq->addr; seq++) {
 144                 ret = ulpi_write(ulpi, ULPI_EXT_VENDOR_SPECIFIC + seq->addr,
 145                                  seq->val);
 146                 if (ret)
 147                         goto err_ulpi;
 148         }
 149
 150         if (uphy->reset) {
 151                 ret = reset_control_reset(uphy->reset);
 152                 if (ret)
 153                         goto err_ulpi;
 154         }
 155
 156         if (uphy->vbus_edev) {
 157                 state = extcon_get_state(uphy->vbus_edev, EXTCON_USB);
 158                 /* setup initial state */
 159                 qcom_usb_hs_phy_vbus_notifier(&uphy->vbus_notify, state,
 160                                               uphy->vbus_edev);
 161                 ret = extcon_register_notifier(uphy->vbus_edev, EXTCON_USB,
 162                                                &uphy->vbus_notify);
 163                 if (ret)
 164                         goto err_ulpi;
 165         }
 166
 167         return 0;
 168 err_ulpi:
 169         regulator_disable(uphy->v3p3);
 170 err_3p3:
 171         regulator_disable(uphy->v1p8);
 172 err_1p8:
 173         clk_disable_unprepare(uphy->sleep_clk);
 174 err_sleep:
 175         clk_disable_unprepare(uphy->ref_clk);
 176         return ret;
 177 }
 178
 179 static int qcom_usb_hs_phy_power_off(struct phy *phy)
 180 {
 181         struct qcom_usb_hs_phy *uphy = phy_get_drvdata(phy);
 182
 183         if (uphy->vbus_edev)
 184                 extcon_unregister_notifier(uphy->vbus_edev, EXTCON_USB,
 185                                            &uphy->vbus_notify);
 186         regulator_disable(uphy->v3p3);
 187         regulator_disable(uphy->v1p8);
 188         clk_disable_unprepare(uphy->sleep_clk);
 189         clk_disable_unprepare(uphy->ref_clk);
 190
 191         return 0;
 192 }
 193
 194 static const struct phy_ops qcom_usb_hs_phy_ops = {
 195         .power_on = qcom_usb_hs_phy_power_on,
 196         .power_off = qcom_usb_hs_phy_power_off,
 197         .set_mode = qcom_usb_hs_phy_set_mode,
 198         .owner = THIS_MODULE,
 199 };
 200
 201 static int qcom_usb_hs_phy_probe(struct ulpi *ulpi)
 202 {
 203         struct qcom_usb_hs_phy *uphy;
 204         struct phy_provider *p;
 205         struct clk *clk;
 206         struct regulator *reg;
 207         struct reset_control *reset;
 208         int size;
 209         int ret;
 210
 211         uphy = devm_kzalloc(&ulpi->dev, sizeof(*uphy), GFP_KERNEL);
 212         if (!uphy)
 213                 return -ENOMEM;
 214         ulpi_set_drvdata(ulpi, uphy);
 215         uphy->ulpi = ulpi;
 216
 217         size = of_property_count_u8_elems(ulpi->dev.of_node, "qcom,init-seq");
 218         if (size < 0)
 219                 size = 0;
 220         uphy->init_seq = devm_kmalloc_array(&ulpi->dev, (size / 2) + 1,
 221                                            sizeof(*uphy->init_seq), GFP_KERNEL);
 222         if (!uphy->init_seq)
 223                 return -ENOMEM;
 224         ret = of_property_read_u8_array(ulpi->dev.of_node, "qcom,init-seq",
 225                                         (u8 *)uphy->init_seq, size);
 226         if (ret && size)
 227                 return ret;
 228         /* NUL terminate */
 229         uphy->init_seq[size / 2].addr = uphy->init_seq[size / 2].val = 0;
 230
 231         uphy->ref_clk = clk = devm_clk_get(&ulpi->dev, "ref");
 232         if (IS_ERR(clk))
 233                 return PTR_ERR(clk);
 234
 235         uphy->sleep_clk = clk = devm_clk_get(&ulpi->dev, "sleep");
 236         if (IS_ERR(clk))
 237                 return PTR_ERR(clk);
 238
 239         uphy->v1p8 = reg = devm_regulator_get(&ulpi->dev, "v1p8");
 240         if (IS_ERR(reg))
 241                 return PTR_ERR(reg);
 242
 243         uphy->v3p3 = reg = devm_regulator_get(&ulpi->dev, "v3p3");
 244         if (IS_ERR(reg))
 245                 return PTR_ERR(reg);
 246
 247         uphy->reset = reset = devm_reset_control_get(&ulpi->dev, "por");
 248         if (IS_ERR(reset)) {
 249                 if (PTR_ERR(reset) == -EPROBE_DEFER)
 250                         return PTR_ERR(reset);
 251                 uphy->reset = NULL;
 252         }
 253
 254         uphy->phy = devm_phy_create(&ulpi->dev, ulpi->dev.of_node,
 255                                     &qcom_usb_hs_phy_ops);
 256         if (IS_ERR(uphy->phy))
 257                 return PTR_ERR(uphy->phy);
 258
 259         uphy->vbus_edev = extcon_get_edev_by_phandle(&ulpi->dev, 0);
 260         if (IS_ERR(uphy->vbus_edev)) {
 261                 if (PTR_ERR(uphy->vbus_edev) != -ENODEV)
 262                         return PTR_ERR(uphy->vbus_edev);
 263                 uphy->vbus_edev = NULL;
 264         }
 265
 266         uphy->vbus_notify.notifier_call = qcom_usb_hs_phy_vbus_notifier;
 267         phy_set_drvdata(uphy->phy, uphy);
 268
 269         p = devm_of_phy_provider_register(&ulpi->dev, of_phy_simple_xlate);
 270         return PTR_ERR_OR_ZERO(p);
 271 }
 272
 273 static const struct of_device_id qcom_usb_hs_phy_match[] = {
 274         { .compatible = "qcom,usb-hs-phy", },
 275         { }
 276 };
 277 MODULE_DEVICE_TABLE(of, qcom_usb_hs_phy_match);
 278
 279 static struct ulpi_driver qcom_usb_hs_phy_driver = {
 280         .probe = qcom_usb_hs_phy_probe,
 281         .driver = {
 282                 .name = "qcom_usb_hs_phy",
 283                 .of_match_table = qcom_usb_hs_phy_match,
 284         },
 285 };
 286 module_ulpi_driver(qcom_usb_hs_phy_driver);
 287
 288 MODULE_DESCRIPTION("Qualcomm USB HS phy");
 289 MODULE_LICENSE("GPL v2");