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