drivers/usb/phy/phy.c

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

DEFINITIONS
