drivers/usb/phy/phy-generic.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * NOP USB transceiver for all USB transceiver which are either built-in
   4  * into USB IP or which are mostly autonomous.
   5  *
   6  * Copyright (C) 2009 Texas Instruments Inc
   7  * Author: Ajay Kumar Gupta <[email protected]>
   8  *
   9  * Current status:
  10  *      This provides a "nop" transceiver for PHYs which are
  11  *      autonomous such as isp1504, isp1707, etc.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/usb/gadget.h>
  18 #include <linux/usb/otg.h>
  19 #include <linux/usb/usb_phy_generic.h>
  20 #include <linux/slab.h>
  21 #include <linux/clk.h>
  22 #include <linux/regulator/consumer.h>
  23 #include <linux/of.h>
  24 #include <linux/gpio/consumer.h>
  25 #include <linux/delay.h>
  26
  27 #include "phy-generic.h"
  28
  29 #define VBUS_IRQ_FLAGS \
  30         (IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | \
  31                 IRQF_ONESHOT)
  32
  33 struct platform_device *usb_phy_generic_register(void)
  34 {
  35         return platform_device_register_simple("usb_phy_generic",
  36                         PLATFORM_DEVID_AUTO, NULL, 0);
  37 }
  38 EXPORT_SYMBOL_GPL(usb_phy_generic_register);
  39
  40 void usb_phy_generic_unregister(struct platform_device *pdev)
  41 {
  42         platform_device_unregister(pdev);
  43 }
  44 EXPORT_SYMBOL_GPL(usb_phy_generic_unregister);
  45
  46 static int nop_set_suspend(struct usb_phy *x, int suspend)
  47 {
  48         struct usb_phy_generic *nop = dev_get_drvdata(x->dev);
  49         int ret = 0;
  50
  51         if (suspend) {
  52                 if (!IS_ERR(nop->clk))
  53                         clk_disable_unprepare(nop->clk);
  54                 if (!IS_ERR(nop->vcc) && !device_may_wakeup(x->dev))
  55                         ret = regulator_disable(nop->vcc);
  56         } else {
  57                 if (!IS_ERR(nop->vcc) && !device_may_wakeup(x->dev))
  58                         ret = regulator_enable(nop->vcc);
  59                 if (!IS_ERR(nop->clk))
  60                         clk_prepare_enable(nop->clk);
  61         }
  62
  63         return ret;
  64 }
  65
  66 static void nop_reset(struct usb_phy_generic *nop)
  67 {
  68         if (!nop->gpiod_reset)
  69                 return;
  70
  71         gpiod_set_value_cansleep(nop->gpiod_reset, 1);
  72         usleep_range(10000, 20000);
  73         gpiod_set_value_cansleep(nop->gpiod_reset, 0);
  74         usleep_range(10000, 30000);
  75 }
  76
  77 /* interface to regulator framework */
  78 static int nop_set_vbus(struct usb_otg *otg, bool enable)
  79 {
  80         int ret = 0;
  81         struct usb_phy_generic *nop = dev_get_drvdata(otg->usb_phy->dev);
  82
  83         if (!nop->vbus_draw)
  84                 return 0;
  85
  86         if (enable && !nop->vbus_draw_enabled) {
  87                 ret = regulator_enable(nop->vbus_draw);
  88                 if (ret)
  89                         nop->vbus_draw_enabled = false;
  90                 else
  91                         nop->vbus_draw_enabled = true;
  92
  93         } else if (!enable && nop->vbus_draw_enabled) {
  94                 ret = regulator_disable(nop->vbus_draw);
  95                 nop->vbus_draw_enabled = false;
  96         }
  97         return ret;
  98 }
  99
 100
 101 static irqreturn_t nop_gpio_vbus_thread(int irq, void *data)
 102 {
 103         struct usb_phy_generic *nop = data;
 104         struct usb_otg *otg = nop->phy.otg;
 105         int vbus, status;
 106
 107         vbus = gpiod_get_value(nop->gpiod_vbus);
 108         if ((vbus ^ nop->vbus) == 0)
 109                 return IRQ_HANDLED;
 110         nop->vbus = vbus;
 111
 112         if (vbus) {
 113                 status = USB_EVENT_VBUS;
 114                 otg->state = OTG_STATE_B_PERIPHERAL;
 115                 nop->phy.last_event = status;
 116
 117                 atomic_notifier_call_chain(&nop->phy.notifier, status,
 118                                            otg->gadget);
 119         } else {
 120                 status = USB_EVENT_NONE;
 121                 otg->state = OTG_STATE_B_IDLE;
 122                 nop->phy.last_event = status;
 123
 124                 atomic_notifier_call_chain(&nop->phy.notifier, status,
 125                                            otg->gadget);
 126         }
 127         return IRQ_HANDLED;
 128 }
 129
 130 int usb_gen_phy_init(struct usb_phy *phy)
 131 {
 132         struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 133         int ret;
 134
 135         if (!IS_ERR(nop->vcc)) {
 136                 if (regulator_enable(nop->vcc))
 137                         dev_err(phy->dev, "Failed to enable power\n");
 138         }
 139
 140         if (!IS_ERR(nop->clk)) {
 141                 ret = clk_prepare_enable(nop->clk);
 142                 if (ret)
 143                         return ret;
 144         }
 145
 146         nop_reset(nop);
 147
 148         return 0;
 149 }
 150 EXPORT_SYMBOL_GPL(usb_gen_phy_init);
 151
 152 void usb_gen_phy_shutdown(struct usb_phy *phy)
 153 {
 154         struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 155
 156         gpiod_set_value_cansleep(nop->gpiod_reset, 1);
 157
 158         if (!IS_ERR(nop->clk))
 159                 clk_disable_unprepare(nop->clk);
 160
 161         if (!IS_ERR(nop->vcc)) {
 162                 if (regulator_disable(nop->vcc))
 163                         dev_err(phy->dev, "Failed to disable power\n");
 164         }
 165 }
 166 EXPORT_SYMBOL_GPL(usb_gen_phy_shutdown);
 167
 168 static int nop_set_peripheral(struct usb_otg *otg, struct usb_gadget *gadget)
 169 {
 170         if (!otg)
 171                 return -ENODEV;
 172
 173         if (!gadget) {
 174                 otg->gadget = NULL;
 175                 return -ENODEV;
 176         }
 177
 178         otg->gadget = gadget;
 179         if (otg->state == OTG_STATE_B_PERIPHERAL)
 180                 atomic_notifier_call_chain(&otg->usb_phy->notifier,
 181                                            USB_EVENT_VBUS, otg->gadget);
 182         else
 183                 otg->state = OTG_STATE_B_IDLE;
 184         return 0;
 185 }
 186
 187 static int nop_set_host(struct usb_otg *otg, struct usb_bus *host)
 188 {
 189         if (!otg)
 190                 return -ENODEV;
 191
 192         if (!host) {
 193                 otg->host = NULL;
 194                 return -ENODEV;
 195         }
 196
 197         otg->host = host;
 198         return 0;
 199 }
 200
 201 int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop)
 202 {
 203         enum usb_phy_type type = USB_PHY_TYPE_USB2;
 204         int err = 0;
 205
 206         u32 clk_rate = 0;
 207         bool needs_clk = false;
 208
 209         if (dev->of_node) {
 210                 struct device_node *node = dev->of_node;
 211
 212                 if (of_property_read_u32(node, "clock-frequency", &clk_rate))
 213                         clk_rate = 0;
 214
 215                 needs_clk = of_property_read_bool(node, "clocks");
 216         }
 217         nop->gpiod_reset = devm_gpiod_get_optional(dev, "reset",
 218                                                    GPIOD_ASIS);
 219         err = PTR_ERR_OR_ZERO(nop->gpiod_reset);
 220         if (!err) {
 221                 nop->gpiod_vbus = devm_gpiod_get_optional(dev,
 222                                                  "vbus-detect",
 223                                                  GPIOD_ASIS);
 224                 err = PTR_ERR_OR_ZERO(nop->gpiod_vbus);
 225         }
 226
 227         if (err)
 228                 return dev_err_probe(dev, err,
 229                                      "Error requesting RESET or VBUS GPIO\n");
 230         if (nop->gpiod_reset)
 231                 gpiod_direction_output(nop->gpiod_reset, 1);
 232
 233         nop->phy.otg = devm_kzalloc(dev, sizeof(*nop->phy.otg),
 234                         GFP_KERNEL);
 235         if (!nop->phy.otg)
 236                 return -ENOMEM;
 237
 238         nop->clk = devm_clk_get(dev, "main_clk");
 239         if (IS_ERR(nop->clk)) {
 240                 dev_dbg(dev, "Can't get phy clock: %ld\n",
 241                                         PTR_ERR(nop->clk));
 242                 if (needs_clk)
 243                         return PTR_ERR(nop->clk);
 244         }
 245
 246         if (!IS_ERR(nop->clk) && clk_rate) {
 247                 err = clk_set_rate(nop->clk, clk_rate);
 248                 if (err) {
 249                         dev_err(dev, "Error setting clock rate\n");
 250                         return err;
 251                 }
 252         }
 253
 254         nop->vcc = devm_regulator_get_optional(dev, "vcc");
 255         if (IS_ERR(nop->vcc) && PTR_ERR(nop->vcc) != -ENODEV)
 256                 return dev_err_probe(dev, PTR_ERR(nop->vcc),
 257                                      "could not get vcc regulator\n");
 258
 259         nop->vbus_draw = devm_regulator_get_exclusive(dev, "vbus");
 260         if (PTR_ERR(nop->vbus_draw) == -ENODEV)
 261                 nop->vbus_draw = NULL;
 262         if (IS_ERR(nop->vbus_draw))
 263                 return dev_err_probe(dev, PTR_ERR(nop->vbus_draw),
 264                                      "could not get vbus regulator\n");
 265
 266         nop->dev                = dev;
 267         nop->phy.dev            = nop->dev;
 268         nop->phy.label          = "nop-xceiv";
 269         nop->phy.set_suspend    = nop_set_suspend;
 270         nop->phy.type           = type;
 271
 272         nop->phy.otg->state             = OTG_STATE_UNDEFINED;
 273         nop->phy.otg->usb_phy           = &nop->phy;
 274         nop->phy.otg->set_host          = nop_set_host;
 275         nop->phy.otg->set_peripheral    = nop_set_peripheral;
 276         nop->phy.otg->set_vbus          = nop_set_vbus;
 277
 278         return 0;
 279 }
 280 EXPORT_SYMBOL_GPL(usb_phy_gen_create_phy);
 281
 282 static int usb_phy_generic_probe(struct platform_device *pdev)
 283 {
 284         struct device *dev = &pdev->dev;
 285         struct device_node *dn = dev->of_node;
 286         struct usb_phy_generic  *nop;
 287         int err;
 288
 289         nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL);
 290         if (!nop)
 291                 return -ENOMEM;
 292
 293         err = usb_phy_gen_create_phy(dev, nop);
 294         if (err)
 295                 return err;
 296         if (nop->gpiod_vbus) {
 297                 err = devm_request_threaded_irq(&pdev->dev,
 298                                                 gpiod_to_irq(nop->gpiod_vbus),
 299                                                 NULL, nop_gpio_vbus_thread,
 300                                                 VBUS_IRQ_FLAGS, "vbus_detect",
 301                                                 nop);
 302                 if (err) {
 303                         dev_err(&pdev->dev, "can't request irq %i, err: %d\n",
 304                                 gpiod_to_irq(nop->gpiod_vbus), err);
 305                         return err;
 306                 }
 307                 nop->phy.otg->state = gpiod_get_value(nop->gpiod_vbus) ?
 308                         OTG_STATE_B_PERIPHERAL : OTG_STATE_B_IDLE;
 309         }
 310
 311         nop->phy.init           = usb_gen_phy_init;
 312         nop->phy.shutdown       = usb_gen_phy_shutdown;
 313
 314         err = usb_add_phy_dev(&nop->phy);
 315         if (err) {
 316                 dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
 317                         err);
 318                 return err;
 319         }
 320
 321         platform_set_drvdata(pdev, nop);
 322
 323         device_set_wakeup_capable(&pdev->dev,
 324                                   of_property_read_bool(dn, "wakeup-source"));
 325
 326         return 0;
 327 }
 328
 329 static void usb_phy_generic_remove(struct platform_device *pdev)
 330 {
 331         struct usb_phy_generic *nop = platform_get_drvdata(pdev);
 332
 333         usb_remove_phy(&nop->phy);
 334
 335         if (nop->vbus_draw && nop->vbus_draw_enabled)
 336                 regulator_disable(nop->vbus_draw);
 337 }
 338
 339 static const struct of_device_id nop_xceiv_dt_ids[] = {
 340         { .compatible = "usb-nop-xceiv" },
 341         { }
 342 };
 343
 344 MODULE_DEVICE_TABLE(of, nop_xceiv_dt_ids);
 345
 346 static struct platform_driver usb_phy_generic_driver = {
 347         .probe          = usb_phy_generic_probe,
 348         .remove         = usb_phy_generic_remove,
 349         .driver         = {
 350                 .name   = "usb_phy_generic",
 351                 .of_match_table = nop_xceiv_dt_ids,
 352         },
 353 };
 354
 355 static int __init usb_phy_generic_init(void)
 356 {
 357         return platform_driver_register(&usb_phy_generic_driver);
 358 }
 359 subsys_initcall(usb_phy_generic_init);
 360
 361 static void __exit usb_phy_generic_exit(void)
 362 {
 363         platform_driver_unregister(&usb_phy_generic_driver);
 364 }
 365 module_exit(usb_phy_generic_exit);
 366
 367 MODULE_ALIAS("platform:usb_phy_generic");
 368 MODULE_AUTHOR("Texas Instruments Inc");
 369 MODULE_DESCRIPTION("NOP USB Transceiver driver");
 370 MODULE_LICENSE("GPL");