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 int usb_add_extcon(struct usb_phy *x)
 327 {
 328         int ret;
 329
 330         if (of_property_read_bool(x->dev->of_node, "extcon")) {
 331                 x->edev = extcon_get_edev_by_phandle(x->dev, 0);
 332                 if (IS_ERR(x->edev))
 333                         return PTR_ERR(x->edev);
 334
 335                 x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
 336                 if (IS_ERR(x->id_edev)) {
 337                         x->id_edev = NULL;
 338                         dev_info(x->dev, "No separate ID extcon device\n");
 339                 }
 340
 341                 if (x->vbus_nb.notifier_call) {
 342                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 343                                                             EXTCON_USB,
 344                                                             &x->vbus_nb);
 345                         if (ret < 0) {
 346                                 dev_err(x->dev,
 347                                         "register VBUS notifier failed\n");
 348                                 return ret;
 349                         }
 350                 } else {
 351                         x->type_nb.notifier_call = usb_phy_get_charger_type;
 352
 353                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 354                                                             EXTCON_CHG_USB_SDP,
 355                                                             &x->type_nb);
 356                         if (ret) {
 357                                 dev_err(x->dev,
 358                                         "register extcon USB SDP failed.\n");
 359                                 return ret;
 360                         }
 361
 362                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 363                                                             EXTCON_CHG_USB_CDP,
 364                                                             &x->type_nb);
 365                         if (ret) {
 366                                 dev_err(x->dev,
 367                                         "register extcon USB CDP failed.\n");
 368                                 return ret;
 369                         }
 370
 371                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 372                                                             EXTCON_CHG_USB_DCP,
 373                                                             &x->type_nb);
 374                         if (ret) {
 375                                 dev_err(x->dev,
 376                                         "register extcon USB DCP failed.\n");
 377                                 return ret;
 378                         }
 379
 380                         ret = devm_extcon_register_notifier(x->dev, x->edev,
 381                                                             EXTCON_CHG_USB_ACA,
 382                                                             &x->type_nb);
 383                         if (ret) {
 384                                 dev_err(x->dev,
 385                                         "register extcon USB ACA failed.\n");
 386                                 return ret;
 387                         }
 388                 }
 389
 390                 if (x->id_nb.notifier_call) {
 391                         struct extcon_dev *id_ext;
 392
 393                         if (x->id_edev)
 394                                 id_ext = x->id_edev;
 395                         else
 396                                 id_ext = x->edev;
 397
 398                         ret = devm_extcon_register_notifier(x->dev, id_ext,
 399                                                             EXTCON_USB_HOST,
 400                                                             &x->id_nb);
 401                         if (ret < 0) {
 402                                 dev_err(x->dev,
 403                                         "register ID notifier failed\n");
 404                                 return ret;
 405                         }
 406                 }
 407         }
 408
 409         usb_phy_set_default_current(x);
 410         INIT_WORK(&x->chg_work, usb_phy_notify_charger_work);
 411         x->chg_type = UNKNOWN_TYPE;
 412         x->chg_state = USB_CHARGER_DEFAULT;
 413         if (x->type_nb.notifier_call)
 414                 __usb_phy_get_charger_type(x);
 415
 416         return 0;
 417 }
 418
 419 /**
 420  * devm_usb_get_phy - find the USB PHY
 421  * @dev - device that requests this phy
 422  * @type - the type of the phy the controller requires
 423  *
 424  * Gets the phy using usb_get_phy(), and associates a device with it using
 425  * devres. On driver detach, release function is invoked on the devres data,
 426  * then, devres data is freed.
 427  *
 428  * For use by USB host and peripheral drivers.
 429  */
 430 struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
 431 {
 432         struct usb_phy **ptr, *phy;
 433
 434         ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
 435         if (!ptr)
 436                 return ERR_PTR(-ENOMEM);
 437
 438         phy = usb_get_phy(type);
 439         if (!IS_ERR(phy)) {
 440                 *ptr = phy;
 441                 devres_add(dev, ptr);
 442         } else
 443                 devres_free(ptr);
 444
 445         return phy;
 446 }
 447 EXPORT_SYMBOL_GPL(devm_usb_get_phy);
 448
 449 /**
 450  * usb_get_phy - find the USB PHY
 451  * @type - the type of the phy the controller requires
 452  *
 453  * Returns the phy driver, after getting a refcount to it; or
 454  * -ENODEV if there is no such phy.  The caller is responsible for
 455  * calling usb_put_phy() to release that count.
 456  *
 457  * For use by USB host and peripheral drivers.
 458  */
 459 struct usb_phy *usb_get_phy(enum usb_phy_type type)
 460 {
 461         struct usb_phy  *phy = NULL;
 462         unsigned long   flags;
 463
 464         spin_lock_irqsave(&phy_lock, flags);
 465
 466         phy = __usb_find_phy(&phy_list, type);
 467         if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
 468                 pr_debug("PHY: unable to find transceiver of type %s\n",
 469                         usb_phy_type_string(type));
 470                 if (!IS_ERR(phy))
 471                         phy = ERR_PTR(-ENODEV);
 472
 473                 goto err0;
 474         }
 475
 476         get_device(phy->dev);
 477
 478 err0:
 479         spin_unlock_irqrestore(&phy_lock, flags);
 480
 481         return phy;
 482 }
 483 EXPORT_SYMBOL_GPL(usb_get_phy);
 484
 485 /**
 486  * devm_usb_get_phy_by_node - find the USB PHY by device_node
 487  * @dev - device that requests this phy
 488  * @node - the device_node for the phy device.
 489  * @nb - a notifier_block to register with the phy.
 490  *
 491  * Returns the phy driver associated with the given device_node,
 492  * after getting a refcount to it, -ENODEV if there is no such phy or
 493  * -EPROBE_DEFER if the device is not yet loaded. While at that, it
 494  * also associates the device with
 495  * the phy using devres. On driver detach, release function is invoked
 496  * on the devres data, then, devres data is freed.
 497  *
 498  * For use by peripheral drivers for devices related to a phy,
 499  * such as a charger.
 500  */
 501 struct  usb_phy *devm_usb_get_phy_by_node(struct device *dev,
 502                                           struct device_node *node,
 503                                           struct notifier_block *nb)
 504 {
 505         struct usb_phy  *phy = ERR_PTR(-ENOMEM);
 506         struct phy_devm *ptr;
 507         unsigned long   flags;
 508
 509         ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
 510         if (!ptr) {
 511                 dev_dbg(dev, "failed to allocate memory for devres\n");
 512                 goto err0;
 513         }
 514
 515         spin_lock_irqsave(&phy_lock, flags);
 516
 517         phy = __of_usb_find_phy(node);
 518         if (IS_ERR(phy)) {
 519                 devres_free(ptr);
 520                 goto err1;
 521         }
 522
 523         if (!try_module_get(phy->dev->driver->owner)) {
 524                 phy = ERR_PTR(-ENODEV);
 525                 devres_free(ptr);
 526                 goto err1;
 527         }
 528         if (nb)
 529                 usb_register_notifier(phy, nb);
 530         ptr->phy = phy;
 531         ptr->nb = nb;
 532         devres_add(dev, ptr);
 533
 534         get_device(phy->dev);
 535
 536 err1:
 537         spin_unlock_irqrestore(&phy_lock, flags);
 538
 539 err0:
 540
 541         return phy;
 542 }
 543 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
 544
 545 /**
 546  * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
 547  * @dev - device that requests this phy
 548  * @phandle - name of the property holding the phy phandle value
 549  * @index - the index of the phy
 550  *
 551  * Returns the phy driver associated with the given phandle value,
 552  * after getting a refcount to it, -ENODEV if there is no such phy or
 553  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 554  * not yet loaded. While at that, it also associates the device with
 555  * the phy using devres. On driver detach, release function is invoked
 556  * on the devres data, then, devres data is freed.
 557  *
 558  * For use by USB host and peripheral drivers.
 559  */
 560 struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
 561         const char *phandle, u8 index)
 562 {
 563         struct device_node *node;
 564         struct usb_phy  *phy;
 565
 566         if (!dev->of_node) {
 567                 dev_dbg(dev, "device does not have a device node entry\n");
 568                 return ERR_PTR(-EINVAL);
 569         }
 570
 571         node = of_parse_phandle(dev->of_node, phandle, index);
 572         if (!node) {
 573                 dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
 574                         dev->of_node);
 575                 return ERR_PTR(-ENODEV);
 576         }
 577         phy = devm_usb_get_phy_by_node(dev, node, NULL);
 578         of_node_put(node);
 579         return phy;
 580 }
 581 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
 582
 583 /**
 584  * usb_get_phy_dev - find the USB PHY
 585  * @dev - device that requests this phy
 586  * @index - the index of the phy
 587  *
 588  * Returns the phy driver, after getting a refcount to it; or
 589  * -ENODEV if there is no such phy.  The caller is responsible for
 590  * calling usb_put_phy() to release that count.
 591  *
 592  * For use by USB host and peripheral drivers.
 593  */
 594 struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
 595 {
 596         struct usb_phy  *phy = NULL;
 597         unsigned long   flags;
 598
 599         spin_lock_irqsave(&phy_lock, flags);
 600
 601         phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
 602         if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
 603                 dev_dbg(dev, "unable to find transceiver\n");
 604                 if (!IS_ERR(phy))
 605                         phy = ERR_PTR(-ENODEV);
 606
 607                 goto err0;
 608         }
 609
 610         get_device(phy->dev);
 611
 612 err0:
 613         spin_unlock_irqrestore(&phy_lock, flags);
 614
 615         return phy;
 616 }
 617 EXPORT_SYMBOL_GPL(usb_get_phy_dev);
 618
 619 /**
 620  * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
 621  * @dev - device that requests this phy
 622  * @index - the index of the phy
 623  *
 624  * Gets the phy using usb_get_phy_dev(), and associates a device with it using
 625  * devres. On driver detach, release function is invoked on the devres data,
 626  * then, devres data is freed.
 627  *
 628  * For use by USB host and peripheral drivers.
 629  */
 630 struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
 631 {
 632         struct usb_phy **ptr, *phy;
 633
 634         ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
 635         if (!ptr)
 636                 return NULL;
 637
 638         phy = usb_get_phy_dev(dev, index);
 639         if (!IS_ERR(phy)) {
 640                 *ptr = phy;
 641                 devres_add(dev, ptr);
 642         } else
 643                 devres_free(ptr);
 644
 645         return phy;
 646 }
 647 EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev);
 648
 649 /**
 650  * devm_usb_put_phy - release the USB PHY
 651  * @dev - device that wants to release this phy
 652  * @phy - the phy returned by devm_usb_get_phy()
 653  *
 654  * destroys the devres associated with this phy and invokes usb_put_phy
 655  * to release the phy.
 656  *
 657  * For use by USB host and peripheral drivers.
 658  */
 659 void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
 660 {
 661         int r;
 662
 663         r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
 664         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
 665 }
 666 EXPORT_SYMBOL_GPL(devm_usb_put_phy);
 667
 668 /**
 669  * usb_put_phy - release the USB PHY
 670  * @x: the phy returned by usb_get_phy()
 671  *
 672  * Releases a refcount the caller received from usb_get_phy().
 673  *
 674  * For use by USB host and peripheral drivers.
 675  */
 676 void usb_put_phy(struct usb_phy *x)
 677 {
 678         if (x) {
 679                 struct module *owner = x->dev->driver->owner;
 680
 681                 put_device(x->dev);
 682                 module_put(owner);
 683         }
 684 }
 685 EXPORT_SYMBOL_GPL(usb_put_phy);
 686
 687 /**
 688  * usb_add_phy - declare the USB PHY
 689  * @x: the USB phy to be used; or NULL
 690  * @type - the type of this PHY
 691  *
 692  * This call is exclusively for use by phy drivers, which
 693  * coordinate the activities of drivers for host and peripheral
 694  * controllers, and in some cases for VBUS current regulation.
 695  */
 696 int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
 697 {
 698         int             ret = 0;
 699         unsigned long   flags;
 700         struct usb_phy  *phy;
 701
 702         if (x->type != USB_PHY_TYPE_UNDEFINED) {
 703                 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
 704                 return -EINVAL;
 705         }
 706
 707         ret = usb_add_extcon(x);
 708         if (ret)
 709                 return ret;
 710
 711         ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
 712
 713         spin_lock_irqsave(&phy_lock, flags);
 714
 715         list_for_each_entry(phy, &phy_list, head) {
 716                 if (phy->type == type) {
 717                         ret = -EBUSY;
 718                         dev_err(x->dev, "transceiver type %s already exists\n",
 719                                                 usb_phy_type_string(type));
 720                         goto out;
 721                 }
 722         }
 723
 724         x->type = type;
 725         list_add_tail(&x->head, &phy_list);
 726
 727 out:
 728         spin_unlock_irqrestore(&phy_lock, flags);
 729         return ret;
 730 }
 731 EXPORT_SYMBOL_GPL(usb_add_phy);
 732
 733 /**
 734  * usb_add_phy_dev - declare the USB PHY
 735  * @x: the USB phy to be used; or NULL
 736  *
 737  * This call is exclusively for use by phy drivers, which
 738  * coordinate the activities of drivers for host and peripheral
 739  * controllers, and in some cases for VBUS current regulation.
 740  */
 741 int usb_add_phy_dev(struct usb_phy *x)
 742 {
 743         struct usb_phy_bind *phy_bind;
 744         unsigned long flags;
 745         int ret;
 746
 747         if (!x->dev) {
 748                 dev_err(x->dev, "no device provided for PHY\n");
 749                 return -EINVAL;
 750         }
 751
 752         ret = usb_add_extcon(x);
 753         if (ret)
 754                 return ret;
 755
 756         ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
 757
 758         spin_lock_irqsave(&phy_lock, flags);
 759         list_for_each_entry(phy_bind, &phy_bind_list, list)
 760                 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
 761                         phy_bind->phy = x;
 762
 763         list_add_tail(&x->head, &phy_list);
 764
 765         spin_unlock_irqrestore(&phy_lock, flags);
 766         return 0;
 767 }
 768 EXPORT_SYMBOL_GPL(usb_add_phy_dev);
 769
 770 /**
 771  * usb_remove_phy - remove the OTG PHY
 772  * @x: the USB OTG PHY to be removed;
 773  *
 774  * This reverts the effects of usb_add_phy
 775  */
 776 void usb_remove_phy(struct usb_phy *x)
 777 {
 778         unsigned long   flags;
 779         struct usb_phy_bind *phy_bind;
 780
 781         spin_lock_irqsave(&phy_lock, flags);
 782         if (x) {
 783                 list_for_each_entry(phy_bind, &phy_bind_list, list)
 784                         if (phy_bind->phy == x)
 785                                 phy_bind->phy = NULL;
 786                 list_del(&x->head);
 787         }
 788         spin_unlock_irqrestore(&phy_lock, flags);
 789 }
 790 EXPORT_SYMBOL_GPL(usb_remove_phy);
 791
 792 /**
 793  * usb_bind_phy - bind the phy and the controller that uses the phy
 794  * @dev_name: the device name of the device that will bind to the phy
 795  * @index: index to specify the port number
 796  * @phy_dev_name: the device name of the phy
 797  *
 798  * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
 799  * be used when the phy driver registers the phy and when the controller
 800  * requests this phy.
 801  *
 802  * To be used by platform specific initialization code.
 803  */
 804 int usb_bind_phy(const char *dev_name, u8 index,
 805                                 const char *phy_dev_name)
 806 {
 807         struct usb_phy_bind *phy_bind;
 808         unsigned long flags;
 809
 810         phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
 811         if (!phy_bind)
 812                 return -ENOMEM;
 813
 814         phy_bind->dev_name = dev_name;
 815         phy_bind->phy_dev_name = phy_dev_name;
 816         phy_bind->index = index;
 817
 818         spin_lock_irqsave(&phy_lock, flags);
 819         list_add_tail(&phy_bind->list, &phy_bind_list);
 820         spin_unlock_irqrestore(&phy_lock, flags);
 821
 822         return 0;
 823 }
 824 EXPORT_SYMBOL_GPL(usb_bind_phy);
 825
 826 /**
 827  * usb_phy_set_event - set event to phy event
 828  * @x: the phy returned by usb_get_phy();
 829  *
 830  * This sets event to phy event
 831  */
 832 void usb_phy_set_event(struct usb_phy *x, unsigned long event)
 833 {
 834         x->last_event = event;
 835 }
 836 EXPORT_SYMBOL_GPL(usb_phy_set_event);