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