drivers/usb/phy/phy.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * phy.c -- USB phy handling
   4  *
   5  * Copyright (C) 2004-2013 Texas Instruments
   6  */
   7 #include <linux/kernel.h>
   8 #include <linux/export.h>
   9 #include <linux/err.h>
  10 #include <linux/device.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/of.h>
  14
  15 #include <linux/usb/phy.h>
  16
  17 /* Default current range by charger type. */
  18 #define DEFAULT_SDP_CUR_MIN     2
  19 #define DEFAULT_SDP_CUR_MAX     500
  20 #define DEFAULT_SDP_CUR_MIN_SS  150
  21 #define DEFAULT_SDP_CUR_MAX_SS  900
  22 #define DEFAULT_DCP_CUR_MIN     500
  23 #define DEFAULT_DCP_CUR_MAX     5000
  24 #define DEFAULT_CDP_CUR_MIN     1500
  25 #define DEFAULT_CDP_CUR_MAX     5000
  26 #define DEFAULT_ACA_CUR_MIN     1500
  27 #define DEFAULT_ACA_CUR_MAX     5000
  28
  29 static LIST_HEAD(phy_list);
  30 static LIST_HEAD(phy_bind_list);
  31 static DEFINE_SPINLOCK(phy_lock);
  32
  33 struct phy_devm {
  34         struct usb_phy *phy;
  35         struct notifier_block *nb;
  36 };
  37
  38 static struct usb_phy *__usb_find_phy(struct list_head *list,
  39         enum usb_phy_type type)
  40 {
  41         struct usb_phy  *phy = NULL;
  42
  43         list_for_each_entry(phy, list, head) {
  44                 if (phy->type != type)
  45                         continue;
  46
  47                 return phy;
  48         }
  49
  50         return ERR_PTR(-ENODEV);
  51 }
  52
  53 static struct usb_phy *__usb_find_phy_dev(struct device *dev,
  54         struct list_head *list, u8 index)
  55 {
  56         struct usb_phy_bind *phy_bind = NULL;
  57
  58         list_for_each_entry(phy_bind, list, list) {
  59                 if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
  60                                 phy_bind->index == index) {
  61                         if (phy_bind->phy)
  62                                 return phy_bind->phy;
  63                         else
  64                                 return ERR_PTR(-EPROBE_DEFER);
  65                 }
  66         }
  67
  68         return ERR_PTR(-ENODEV);
  69 }
  70
  71 static struct usb_phy *__of_usb_find_phy(struct device_node *node)
  72 {
  73         struct usb_phy  *phy;
  74
  75         if (!of_device_is_available(node))
  76                 return ERR_PTR(-ENODEV);
  77
  78         list_for_each_entry(phy, &phy_list, head) {
  79                 if (node != phy->dev->of_node)
  80                         continue;
  81
  82                 return phy;
  83         }
  84
  85         return ERR_PTR(-EPROBE_DEFER);
  86 }
  87
  88 static void usb_phy_set_default_current(struct usb_phy *usb_phy)
  89 {
  90         usb_phy->chg_cur.sdp_min = DEFAULT_SDP_CUR_MIN;
  91         usb_phy->chg_cur.sdp_max = DEFAULT_SDP_CUR_MAX;
  92         usb_phy->chg_cur.dcp_min = DEFAULT_DCP_CUR_MIN;
  93         usb_phy->chg_cur.dcp_max = DEFAULT_DCP_CUR_MAX;
  94         usb_phy->chg_cur.cdp_min = DEFAULT_CDP_CUR_MIN;
  95         usb_phy->chg_cur.cdp_max = DEFAULT_CDP_CUR_MAX;
  96         usb_phy->chg_cur.aca_min = DEFAULT_ACA_CUR_MIN;
  97         usb_phy->chg_cur.aca_max = DEFAULT_ACA_CUR_MAX;
  98 }
  99
 100 /**
 101  * usb_phy_notify_charger_work - notify the USB charger state
 102  * @work - the charger work to notify the USB charger state
 103  *
 104  * This work can be issued when USB charger state has been changed or
 105  * USB charger current has been changed, then we can notify the current
 106  * what can be drawn to power user and the charger state to userspace.
 107  *
 108  * If we get the charger type from extcon subsystem, we can notify the
 109  * charger state to power user automatically by usb_phy_get_charger_type()
 110  * issuing from extcon subsystem.
 111  *
 112  * If we get the charger type from ->charger_detect() instead of extcon
 113  * subsystem, the usb phy driver should issue usb_phy_set_charger_state()
 114  * to set charger state when the charger state has been changed.
 115  */
 116 static void usb_phy_notify_charger_work(struct work_struct *work)
 117 {
 118         struct usb_phy *usb_phy = container_of(work, struct usb_phy, chg_work);
 119         char uchger_state[50] = { 0 };
 120         char *envp[] = { uchger_state, NULL };
 121         unsigned int min, max;
 122
 123         switch (usb_phy->chg_state) {
 124         case USB_CHARGER_PRESENT:
 125                 usb_phy_get_charger_current(usb_phy, &min, &max);
 126
 127                 atomic_notifier_call_chain(&usb_phy->notifier, max, usb_phy);
 128                 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
 129                          "USB_CHARGER_STATE=%s", "USB_CHARGER_PRESENT");
 130                 break;
 131         case USB_CHARGER_ABSENT:
 132                 usb_phy_set_default_current(usb_phy);
 133
 134                 atomic_notifier_call_chain(&usb_phy->notifier, 0, usb_phy);
 135                 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
 136                          "USB_CHARGER_STATE=%s", "USB_CHARGER_ABSENT");
 137                 break;
 138         default:
 139                 dev_warn(usb_phy->dev, "Unknown USB charger state: %d\n",
 140                          usb_phy->chg_state);
 141                 return;
 142         }
 143
 144         kobject_uevent_env(&usb_phy->dev->kobj, KOBJ_CHANGE, envp);
 145 }
 146
 147 static void __usb_phy_get_charger_type(struct usb_phy *usb_phy)
 148 {
 149         if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_SDP) > 0) {
 150                 usb_phy->chg_type = SDP_TYPE;
 151                 usb_phy->chg_state = USB_CHARGER_PRESENT;
 152         } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_CDP) > 0) {
 153                 usb_phy->chg_type = CDP_TYPE;
 154                 usb_phy->chg_state = USB_CHARGER_PRESENT;
 155         } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_DCP) > 0) {
 156                 usb_phy->chg_type = DCP_TYPE;
 157                 usb_phy->chg_state = USB_CHARGER_PRESENT;
 158         } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_ACA) > 0) {
 159                 usb_phy->chg_type = ACA_TYPE;
 160                 usb_phy->chg_state = USB_CHARGER_PRESENT;
 161         } else {
 162                 usb_phy->chg_type = UNKNOWN_TYPE;
 163                 usb_phy->chg_state = USB_CHARGER_ABSENT;
 164         }
 165
 166         schedule_work(&usb_phy->chg_work);
 167 }
 168
 169 /**
 170  * usb_phy_get_charger_type - get charger type from extcon subsystem
 171  * @nb -the notifier block to determine charger type
 172  * @state - the cable state
 173  * @data - private data
 174  *
 175  * Determin the charger type from extcon subsystem which also means the
 176  * charger state has been chaned, then we should notify this event.
 177  */
 178 static int usb_phy_get_charger_type(struct notifier_block *nb,
 179                                     unsigned long state, void *data)
 180 {
 181         struct usb_phy *usb_phy = container_of(nb, struct usb_phy, type_nb);
 182
 183         __usb_phy_get_charger_type(usb_phy);
 184         return NOTIFY_OK;
 185 }
 186
 187 /**
 188  * usb_phy_set_charger_current - set the USB charger current
 189  * @usb_phy - the USB phy to be used
 190  * @mA - the current need to be set
 191  *
 192  * Usually we only change the charger default current when USB finished the
 193  * enumeration as one SDP charger. As one SDP charger, usb_phy_set_power()
 194  * will issue this function to change charger current when after setting USB
 195  * configuration, or suspend/resume USB. For other type charger, we should
 196  * use the default charger current and we do not suggest to issue this function
 197  * to change the charger current.
 198  *
 199  * When USB charger current has been changed, we need to notify the power users.
 200  */
 201 void usb_phy_set_charger_current(struct usb_phy *usb_phy, unsigned int mA)
 202 {
 203         switch (usb_phy->chg_type) {
 204         case SDP_TYPE:
 205                 if (usb_phy->chg_cur.sdp_max == mA)
 206                         return;
 207
 208                 usb_phy->chg_cur.sdp_max = (mA > DEFAULT_SDP_CUR_MAX_SS) ?
 209                         DEFAULT_SDP_CUR_MAX_SS : mA;
 210                 break;
 211         case DCP_TYPE:
 212                 if (usb_phy->chg_cur.dcp_max == mA)
 213                         return;
 214
 215                 usb_phy->chg_cur.dcp_max = (mA > DEFAULT_DCP_CUR_MAX) ?
 216                         DEFAULT_DCP_CUR_MAX : mA;
 217                 break;
 218         case CDP_TYPE:
 219                 if (usb_phy->chg_cur.cdp_max == mA)
 220                         return;
 221
 222                 usb_phy->chg_cur.cdp_max = (mA > DEFAULT_CDP_CUR_MAX) ?
 223                         DEFAULT_CDP_CUR_MAX : mA;
 224                 break;
 225         case ACA_TYPE:
 226                 if (usb_phy->chg_cur.aca_max == mA)
 227                         return;
 228
 229                 usb_phy->chg_cur.aca_max = (mA > DEFAULT_ACA_CUR_MAX) ?
 230                         DEFAULT_ACA_CUR_MAX : mA;
 231                 break;
 232         default:
 233                 return;
 234         }
 235
 236         schedule_work(&usb_phy->chg_work);
 237 }
 238 EXPORT_SYMBOL_GPL(usb_phy_set_charger_current);
 239
 240 /**
 241  * usb_phy_get_charger_current - get the USB charger current
 242  * @usb_phy - the USB phy to be used
 243  * @min - the minimum current
 244  * @max - the maximum current
 245  *
 246  * Usually we will notify the maximum current to power user, but for some
 247  * special case, power user also need the minimum current value. Then the
 248  * power user can issue this function to get the suitable current.
 249  */
 250 void usb_phy_get_charger_current(struct usb_phy *usb_phy,
 251                                  unsigned int *min, unsigned int *max)
 252 {
 253         switch (usb_phy->chg_type) {
 254         case SDP_TYPE:
 255                 *min = usb_phy->chg_cur.sdp_min;
 256                 *max = usb_phy->chg_cur.sdp_max;
 257                 break;
 258         case DCP_TYPE:
 259                 *min = usb_phy->chg_cur.dcp_min;
 260                 *max = usb_phy->chg_cur.dcp_max;
 261                 break;
 262         case CDP_TYPE:
 263                 *min = usb_phy->chg_cur.cdp_min;
 264                 *max = usb_phy->chg_cur.cdp_max;
 265                 break;
 266         case ACA_TYPE:
 267                 *min = usb_phy->chg_cur.aca_min;
 268                 *max = usb_phy->chg_cur.aca_max;
 269                 break;
 270         default:
 271                 *min = 0;
 272                 *max = 0;
 273                 break;
 274         }
 275 }
 276 EXPORT_SYMBOL_GPL(usb_phy_get_charger_current);
 277
 278 /**
 279  * usb_phy_set_charger_state - set the USB charger state
 280  * @usb_phy - the USB phy to be used
 281  * @state - the new state need to be set for charger
 282  *
 283  * The usb phy driver can issue this function when the usb phy driver
 284  * detected the charger state has been changed, in this case the charger
 285  * type should be get from ->charger_detect().
 286  */
 287 void usb_phy_set_charger_state(struct usb_phy *usb_phy,
 288                                enum usb_charger_state state)
 289 {
 290         if (usb_phy->chg_state == state || !usb_phy->charger_detect)
 291                 return;
 292
 293         usb_phy->chg_state = state;
 294         if (usb_phy->chg_state == USB_CHARGER_PRESENT)
 295                 usb_phy->chg_type = usb_phy->charger_detect(usb_phy);
 296         else
 297                 usb_phy->chg_type = UNKNOWN_TYPE;
 298
 299         schedule_work(&usb_phy->chg_work);
 300 }
 301 EXPORT_SYMBOL_GPL(usb_phy_set_charger_state);
 302
 303 static void devm_usb_phy_release(struct device *dev, void *res)
 304 {
 305         struct usb_phy *phy = *(struct usb_phy **)res;
 306
 307         usb_put_phy(phy);
 308 }
 309
 310 static void devm_usb_phy_release2(struct device *dev, void *_res)
 311 {
 312         struct phy_devm *res = _res;
 313
 314         if (res->nb)
 315                 usb_unregister_notifier(res->phy, res->nb);
 316         usb_put_phy(res->phy);
 317 }
 318
 319 static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
 320 {
 321         struct usb_phy **phy = res;
 322
 323         return *phy == match_data;
 324 }
 325
 326 static void usb_charger_init(struct usb_phy *usb_phy)
 327 {
 328         usb_phy->chg_type = UNKNOWN_TYPE;
 329         usb_phy->chg_state = USB_CHARGER_DEFAULT;
 330         usb_phy_set_default_current(usb_phy);
 331         INIT_WORK(&usb_phy->chg_work, usb_phy_notify_charger_work);
 332 }
 333
 334 static int usb_add_extcon(struct usb_phy *x)
 335 {
 336         int ret;
 337
 338         if (of_property_read_bool(x->dev->of_node, "extcon")) {
 339                 x->edev = extcon_get_edev_by_phandle(x->dev, 0);
 340                 if (IS_ERR(x->edev))
 341                         return PTR_ERR(x->edev);
 342
 343                 x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
 344                 if (IS_ERR(x->id_edev)) {
 345                         x->id_edev = NULL;
 346                         dev_info(x->dev, "No separate ID extcon device\n");
 347                 }
 348
 349                 if (x->vbus_nb.notifier_call) {
 350                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 351                                                             EXTCON_USB,
 352                                                             &x->vbus_nb);
 353                         if (ret < 0) {
 354                                 dev_err(x->dev,
 355                                         "register VBUS notifier failed\n");
 356                                 return ret;
 357                         }
 358                 } else {
 359                         x->type_nb.notifier_call = usb_phy_get_charger_type;
 360
 361                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 362                                                             EXTCON_CHG_USB_SDP,
 363                                                             &x->type_nb);
 364                         if (ret) {
 365                                 dev_err(x->dev,
 366                                         "register extcon USB SDP failed.\n");
 367                                 return ret;
 368                         }
 369
 370                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 371                                                             EXTCON_CHG_USB_CDP,
 372                                                             &x->type_nb);
 373                         if (ret) {
 374                                 dev_err(x->dev,
 375                                         "register extcon USB CDP failed.\n");
 376                                 return ret;
 377                         }
 378
 379                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 380                                                             EXTCON_CHG_USB_DCP,
 381                                                             &x->type_nb);
 382                         if (ret) {
 383                                 dev_err(x->dev,
 384                                         "register extcon USB DCP failed.\n");
 385                                 return ret;
 386                         }
 387
 388                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 389                                                             EXTCON_CHG_USB_ACA,
 390                                                             &x->type_nb);
 391                         if (ret) {
 392                                 dev_err(x->dev,
 393                                         "register extcon USB ACA failed.\n");
 394                                 return ret;
 395                         }
 396                 }
 397
 398                 if (x->id_nb.notifier_call) {
 399                         struct extcon_dev *id_ext;
 400
 401                         if (x->id_edev)
 402                                 id_ext = x->id_edev;
 403                         else
 404                                 id_ext = x->edev;
 405
 406                         ret = devm_extcon_register_notifier(x->dev, id_ext,
 407                                                             EXTCON_USB_HOST,
 408                                                             &x->id_nb);
 409                         if (ret < 0) {
 410                                 dev_err(x->dev,
 411                                         "register ID notifier failed\n");
 412                                 return ret;
 413                         }
 414                 }
 415         }
 416
 417         if (x->type_nb.notifier_call)
 418                 __usb_phy_get_charger_type(x);
 419
 420         return 0;
 421 }
 422
 423 /**
 424  * devm_usb_get_phy - find the USB PHY
 425  * @dev - device that requests this phy
 426  * @type - the type of the phy the controller requires
 427  *
 428  * Gets the phy using usb_get_phy(), and associates a device with it using
 429  * devres. On driver detach, release function is invoked on the devres data,
 430  * then, devres data is freed.
 431  *
 432  * For use by USB host and peripheral drivers.
 433  */
 434 struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
 435 {
 436         struct usb_phy **ptr, *phy;
 437
 438         ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
 439         if (!ptr)
 440                 return ERR_PTR(-ENOMEM);
 441
 442         phy = usb_get_phy(type);
 443         if (!IS_ERR(phy)) {
 444                 *ptr = phy;
 445                 devres_add(dev, ptr);
 446         } else
 447                 devres_free(ptr);
 448
 449         return phy;
 450 }
 451 EXPORT_SYMBOL_GPL(devm_usb_get_phy);
 452
 453 /**
 454  * usb_get_phy - find the USB PHY
 455  * @type - the type of the phy the controller requires
 456  *
 457  * Returns the phy driver, after getting a refcount to it; or
 458  * -ENODEV if there is no such phy.  The caller is responsible for
 459  * calling usb_put_phy() to release that count.
 460  *
 461  * For use by USB host and peripheral drivers.
 462  */
 463 struct usb_phy *usb_get_phy(enum usb_phy_type type)
 464 {
 465         struct usb_phy  *phy = NULL;
 466         unsigned long   flags;
 467
 468         spin_lock_irqsave(&phy_lock, flags);
 469
 470         phy = __usb_find_phy(&phy_list, type);
 471         if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
 472                 pr_debug("PHY: unable to find transceiver of type %s\n",
 473                         usb_phy_type_string(type));
 474                 if (!IS_ERR(phy))
 475                         phy = ERR_PTR(-ENODEV);
 476
 477                 goto err0;
 478         }
 479
 480         get_device(phy->dev);
 481
 482 err0:
 483         spin_unlock_irqrestore(&phy_lock, flags);
 484
 485         return phy;
 486 }
 487 EXPORT_SYMBOL_GPL(usb_get_phy);
 488
 489 /**
 490  * devm_usb_get_phy_by_node - find the USB PHY by device_node
 491  * @dev - device that requests this phy
 492  * @node - the device_node for the phy device.
 493  * @nb - a notifier_block to register with the phy.
 494  *
 495  * Returns the phy driver associated with the given device_node,
 496  * after getting a refcount to it, -ENODEV if there is no such phy or
 497  * -EPROBE_DEFER if the device is not yet loaded. While at that, it
 498  * also associates the device with
 499  * the phy using devres. On driver detach, release function is invoked
 500  * on the devres data, then, devres data is freed.
 501  *
 502  * For use by peripheral drivers for devices related to a phy,
 503  * such as a charger.
 504  */
 505 struct  usb_phy *devm_usb_get_phy_by_node(struct device *dev,
 506                                           struct device_node *node,
 507                                           struct notifier_block *nb)
 508 {
 509         struct usb_phy  *phy = ERR_PTR(-ENOMEM);
 510         struct phy_devm *ptr;
 511         unsigned long   flags;
 512
 513         ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
 514         if (!ptr) {
 515                 dev_dbg(dev, "failed to allocate memory for devres\n");
 516                 goto err0;
 517         }
 518
 519         spin_lock_irqsave(&phy_lock, flags);
 520
 521         phy = __of_usb_find_phy(node);
 522         if (IS_ERR(phy)) {
 523                 devres_free(ptr);
 524                 goto err1;
 525         }
 526
 527         if (!try_module_get(phy->dev->driver->owner)) {
 528                 phy = ERR_PTR(-ENODEV);
 529                 devres_free(ptr);
 530                 goto err1;
 531         }
 532         if (nb)
 533                 usb_register_notifier(phy, nb);
 534         ptr->phy = phy;
 535         ptr->nb = nb;
 536         devres_add(dev, ptr);
 537
 538         get_device(phy->dev);
 539
 540 err1:
 541         spin_unlock_irqrestore(&phy_lock, flags);
 542
 543 err0:
 544
 545         return phy;
 546 }
 547 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
 548
 549 /**
 550  * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
 551  * @dev - device that requests this phy
 552  * @phandle - name of the property holding the phy phandle value
 553  * @index - the index of the phy
 554  *
 555  * Returns the phy driver associated with the given phandle value,
 556  * after getting a refcount to it, -ENODEV if there is no such phy or
 557  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 558  * not yet loaded. While at that, it also associates the device with
 559  * the phy using devres. On driver detach, release function is invoked
 560  * on the devres data, then, devres data is freed.
 561  *
 562  * For use by USB host and peripheral drivers.
 563  */
 564 struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
 565         const char *phandle, u8 index)
 566 {
 567         struct device_node *node;
 568         struct usb_phy  *phy;
 569
 570         if (!dev->of_node) {
 571                 dev_dbg(dev, "device does not have a device node entry\n");
 572                 return ERR_PTR(-EINVAL);
 573         }
 574
 575         node = of_parse_phandle(dev->of_node, phandle, index);
 576         if (!node) {
 577                 dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
 578                         dev->of_node);
 579                 return ERR_PTR(-ENODEV);
 580         }
 581         phy = devm_usb_get_phy_by_node(dev, node, NULL);
 582         of_node_put(node);
 583         return phy;
 584 }
 585 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
 586
 587 /**
 588  * usb_get_phy_dev - find the USB PHY
 589  * @dev - device that requests this phy
 590  * @index - the index of the phy
 591  *
 592  * Returns the phy driver, after getting a refcount to it; or
 593  * -ENODEV if there is no such phy.  The caller is responsible for
 594  * calling usb_put_phy() to release that count.
 595  *
 596  * For use by USB host and peripheral drivers.
 597  */
 598 struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
 599 {
 600         struct usb_phy  *phy = NULL;
 601         unsigned long   flags;
 602
 603         spin_lock_irqsave(&phy_lock, flags);
 604
 605         phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
 606         if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
 607                 dev_dbg(dev, "unable to find transceiver\n");
 608                 if (!IS_ERR(phy))
 609                         phy = ERR_PTR(-ENODEV);
 610
 611                 goto err0;
 612         }
 613
 614         get_device(phy->dev);
 615
 616 err0:
 617         spin_unlock_irqrestore(&phy_lock, flags);
 618
 619         return phy;
 620 }
 621 EXPORT_SYMBOL_GPL(usb_get_phy_dev);
 622
 623 /**
 624  * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
 625  * @dev - device that requests this phy
 626  * @index - the index of the phy
 627  *
 628  * Gets the phy using usb_get_phy_dev(), and associates a device with it using
 629  * devres. On driver detach, release function is invoked on the devres data,
 630  * then, devres data is freed.
 631  *
 632  * For use by USB host and peripheral drivers.
 633  */
 634 struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
 635 {
 636         struct usb_phy **ptr, *phy;
 637
 638         ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
 639         if (!ptr)
 640                 return NULL;
 641
 642         phy = usb_get_phy_dev(dev, index);
 643         if (!IS_ERR(phy)) {
 644                 *ptr = phy;
 645                 devres_add(dev, ptr);
 646         } else
 647                 devres_free(ptr);
 648
 649         return phy;
 650 }
 651 EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev);
 652
 653 /**
 654  * devm_usb_put_phy - release the USB PHY
 655  * @dev - device that wants to release this phy
 656  * @phy - the phy returned by devm_usb_get_phy()
 657  *
 658  * destroys the devres associated with this phy and invokes usb_put_phy
 659  * to release the phy.
 660  *
 661  * For use by USB host and peripheral drivers.
 662  */
 663 void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
 664 {
 665         int r;
 666
 667         r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
 668         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 669 }
 670 EXPORT_SYMBOL_GPL(devm_usb_put_phy);
 671
 672 /**
 673  * usb_put_phy - release the USB PHY
 674  * @x: the phy returned by usb_get_phy()
 675  *
 676  * Releases a refcount the caller received from usb_get_phy().
 677  *
 678  * For use by USB host and peripheral drivers.
 679  */
 680 void usb_put_phy(struct usb_phy *x)
 681 {
 682         if (x) {
 683                 struct module *owner = x->dev->driver->owner;
 684
 685                 put_device(x->dev);
 686                 module_put(owner);
 687         }
 688 }
 689 EXPORT_SYMBOL_GPL(usb_put_phy);
 690
 691 /**
 692  * usb_add_phy - declare the USB PHY
 693  * @x: the USB phy to be used; or NULL
 694  * @type - the type of this PHY
 695  *
 696  * This call is exclusively for use by phy drivers, which
 697  * coordinate the activities of drivers for host and peripheral
 698  * controllers, and in some cases for VBUS current regulation.
 699  */
 700 int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
 701 {
 702         int             ret = 0;
 703         unsigned long   flags;
 704         struct usb_phy  *phy;
 705
 706         if (x->type != USB_PHY_TYPE_UNDEFINED) {
 707                 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
 708                 return -EINVAL;
 709         }
 710
 711         usb_charger_init(x);
 712         ret = usb_add_extcon(x);
 713         if (ret)
 714                 return ret;
 715
 716         ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
 717
 718         spin_lock_irqsave(&phy_lock, flags);
 719
 720         list_for_each_entry(phy, &phy_list, head) {
 721                 if (phy->type == type) {
 722                         ret = -EBUSY;
 723                         dev_err(x->dev, "transceiver type %s already exists\n",
 724                                                 usb_phy_type_string(type));
 725                         goto out;
 726                 }
 727         }
 728
 729         x->type = type;
 730         list_add_tail(&x->head, &phy_list);
 731
 732 out:
 733         spin_unlock_irqrestore(&phy_lock, flags);
 734         return ret;
 735 }
 736 EXPORT_SYMBOL_GPL(usb_add_phy);
 737
 738 /**
 739  * usb_add_phy_dev - declare the USB PHY
 740  * @x: the USB phy to be used; or NULL
 741  *
 742  * This call is exclusively for use by phy drivers, which
 743  * coordinate the activities of drivers for host and peripheral
 744  * controllers, and in some cases for VBUS current regulation.
 745  */
 746 int usb_add_phy_dev(struct usb_phy *x)
 747 {
 748         struct usb_phy_bind *phy_bind;
 749         unsigned long flags;
 750         int ret;
 751
 752         if (!x->dev) {
 753                 dev_err(x->dev, "no device provided for PHY\n");
 754                 return -EINVAL;
 755         }
 756
 757         usb_charger_init(x);
 758         ret = usb_add_extcon(x);
 759         if (ret)
 760                 return ret;
 761
 762         ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
 763
 764         spin_lock_irqsave(&phy_lock, flags);
 765         list_for_each_entry(phy_bind, &phy_bind_list, list)
 766                 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
 767                         phy_bind->phy = x;
 768
 769         list_add_tail(&x->head, &phy_list);
 770
 771         spin_unlock_irqrestore(&phy_lock, flags);
 772         return 0;
 773 }
 774 EXPORT_SYMBOL_GPL(usb_add_phy_dev);
 775
 776 /**
 777  * usb_remove_phy - remove the OTG PHY
 778  * @x: the USB OTG PHY to be removed;
 779  *
 780  * This reverts the effects of usb_add_phy
 781  */
 782 void usb_remove_phy(struct usb_phy *x)
 783 {
 784         unsigned long   flags;
 785         struct usb_phy_bind *phy_bind;
 786
 787         spin_lock_irqsave(&phy_lock, flags);
 788         if (x) {
 789                 list_for_each_entry(phy_bind, &phy_bind_list, list)
 790                         if (phy_bind->phy == x)
 791                                 phy_bind->phy = NULL;
 792                 list_del(&x->head);
 793         }
 794         spin_unlock_irqrestore(&phy_lock, flags);
 795 }
 796 EXPORT_SYMBOL_GPL(usb_remove_phy);
 797
 798 /**
 799  * usb_bind_phy - bind the phy and the controller that uses the phy
 800  * @dev_name: the device name of the device that will bind to the phy
 801  * @index: index to specify the port number
 802  * @phy_dev_name: the device name of the phy
 803  *
 804  * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
 805  * be used when the phy driver registers the phy and when the controller
 806  * requests this phy.
 807  *
 808  * To be used by platform specific initialization code.
 809  */
 810 int usb_bind_phy(const char *dev_name, u8 index,
 811                                 const char *phy_dev_name)
 812 {
 813         struct usb_phy_bind *phy_bind;
 814         unsigned long flags;
 815
 816         phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
 817         if (!phy_bind)
 818                 return -ENOMEM;
 819
 820         phy_bind->dev_name = dev_name;
 821         phy_bind->phy_dev_name = phy_dev_name;
 822         phy_bind->index = index;
 823
 824         spin_lock_irqsave(&phy_lock, flags);
 825         list_add_tail(&phy_bind->list, &phy_bind_list);
 826         spin_unlock_irqrestore(&phy_lock, flags);
 827
 828         return 0;
 829 }
 830 EXPORT_SYMBOL_GPL(usb_bind_phy);
 831
 832 /**
 833  * usb_phy_set_event - set event to phy event
 834  * @x: the phy returned by usb_get_phy();
 835  *
 836  * This sets event to phy event
 837  */
 838 void usb_phy_set_event(struct usb_phy *x, unsigned long event)
 839 {
 840         x->last_event = event;
 841 }
 842 EXPORT_SYMBOL_GPL(usb_phy_set_event);