drivers/usb/typec/pd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * USB Power Delivery sysfs entries
   4  *
   5  * Copyright (C) 2022, Intel Corporation
   6  * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
   7  */
   8
   9 #include <linux/slab.h>
  10 #include <linux/usb/pd.h>
  11
  12 #include "pd.h"
  13
  14 static DEFINE_IDA(pd_ida);
  15
  16 static struct class pd_class = {
  17         .name = "usb_power_delivery",
  18         .owner = THIS_MODULE,
  19 };
  20
  21 #define to_pdo(o) container_of(o, struct pdo, dev)
  22
  23 struct pdo {
  24         struct device dev;
  25         int object_position;
  26         u32 pdo;
  27 };
  28
  29 static void pdo_release(struct device *dev)
  30 {
  31         kfree(to_pdo(dev));
  32 }
  33
  34 /* -------------------------------------------------------------------------- */
  35 /* Fixed Supply */
  36
  37 static ssize_t
  38 dual_role_power_show(struct device *dev, struct device_attribute *attr, char *buf)
  39 {
  40         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_DUAL_ROLE));
  41 }
  42 static DEVICE_ATTR_RO(dual_role_power);
  43
  44 static ssize_t
  45 usb_suspend_supported_show(struct device *dev, struct device_attribute *attr, char *buf)
  46 {
  47         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_SUSPEND));
  48 }
  49 static DEVICE_ATTR_RO(usb_suspend_supported);
  50
  51 static ssize_t
  52 higher_capability_show(struct device *dev, struct device_attribute *attr, char *buf)
  53 {
  54         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_HIGHER_CAP));
  55 }
  56 static DEVICE_ATTR_RO(higher_capability);
  57
  58 static ssize_t
  59 unconstrained_power_show(struct device *dev, struct device_attribute *attr, char *buf)
  60 {
  61         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_EXTPOWER));
  62 }
  63 static DEVICE_ATTR_RO(unconstrained_power);
  64
  65 static ssize_t
  66 usb_communication_capable_show(struct device *dev, struct device_attribute *attr, char *buf)
  67 {
  68         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_USB_COMM));
  69 }
  70 static DEVICE_ATTR_RO(usb_communication_capable);
  71
  72 static ssize_t
  73 dual_role_data_show(struct device *dev, struct device_attribute *attr, char *buf)
  74 {
  75         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_DATA_SWAP));
  76 }
  77 static DEVICE_ATTR_RO(dual_role_data);
  78
  79 static ssize_t
  80 unchunked_extended_messages_supported_show(struct device *dev,
  81                                            struct device_attribute *attr, char *buf)
  82 {
  83         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & PDO_FIXED_UNCHUNK_EXT));
  84 }
  85 static DEVICE_ATTR_RO(unchunked_extended_messages_supported);
  86
  87 /*
  88  * REVISIT: Peak Current requires access also to the RDO.
  89 static ssize_t
  90 peak_current_show(struct device *dev, struct device_attribute *attr, char *buf)
  91 {
  92         ...
  93 }
  94 */
  95
  96 static ssize_t
  97 fast_role_swap_current_show(struct device *dev, struct device_attribute *attr, char *buf)
  98 {
  99         return sysfs_emit(buf, "%u\n", to_pdo(dev)->pdo >> PDO_FIXED_FRS_CURR_SHIFT) & 3;
 100 }
 101 static DEVICE_ATTR_RO(fast_role_swap_current);
 102
 103 static ssize_t voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
 104 {
 105         return sysfs_emit(buf, "%umV\n", pdo_fixed_voltage(to_pdo(dev)->pdo));
 106 }
 107 static DEVICE_ATTR_RO(voltage);
 108
 109 /* Shared with Variable supplies, both source and sink */
 110 static ssize_t current_show(struct device *dev, struct device_attribute *attr, char *buf)
 111 {
 112         return sysfs_emit(buf, "%umA\n", pdo_max_current(to_pdo(dev)->pdo));
 113 }
 114
 115 /* Shared with Variable type supplies */
 116 static struct device_attribute maximum_current_attr = {
 117         .attr = {
 118                 .name = "maximum_current",
 119                 .mode = 0444,
 120         },
 121         .show = current_show,
 122 };
 123
 124 static struct device_attribute operational_current_attr = {
 125         .attr = {
 126                 .name = "operational_current",
 127                 .mode = 0444,
 128         },
 129         .show = current_show,
 130 };
 131
 132 static struct attribute *source_fixed_supply_attrs[] = {
 133         &dev_attr_dual_role_power.attr,
 134         &dev_attr_usb_suspend_supported.attr,
 135         &dev_attr_unconstrained_power.attr,
 136         &dev_attr_usb_communication_capable.attr,
 137         &dev_attr_dual_role_data.attr,
 138         &dev_attr_unchunked_extended_messages_supported.attr,
 139         /*&dev_attr_peak_current.attr,*/
 140         &dev_attr_voltage.attr,
 141         &maximum_current_attr.attr,
 142         NULL
 143 };
 144
 145 static umode_t fixed_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n)
 146 {
 147         if (to_pdo(kobj_to_dev(kobj))->object_position &&
 148             /*attr != &dev_attr_peak_current.attr &&*/
 149             attr != &dev_attr_voltage.attr &&
 150             attr != &maximum_current_attr.attr &&
 151             attr != &operational_current_attr.attr)
 152                 return 0;
 153
 154         return attr->mode;
 155 }
 156
 157 static const struct attribute_group source_fixed_supply_group = {
 158         .is_visible = fixed_attr_is_visible,
 159         .attrs = source_fixed_supply_attrs,
 160 };
 161 __ATTRIBUTE_GROUPS(source_fixed_supply);
 162
 163 static struct device_type source_fixed_supply_type = {
 164         .name = "pdo",
 165         .release = pdo_release,
 166         .groups = source_fixed_supply_groups,
 167 };
 168
 169 static struct attribute *sink_fixed_supply_attrs[] = {
 170         &dev_attr_dual_role_power.attr,
 171         &dev_attr_higher_capability.attr,
 172         &dev_attr_unconstrained_power.attr,
 173         &dev_attr_usb_communication_capable.attr,
 174         &dev_attr_dual_role_data.attr,
 175         &dev_attr_unchunked_extended_messages_supported.attr,
 176         &dev_attr_fast_role_swap_current.attr,
 177         &dev_attr_voltage.attr,
 178         &operational_current_attr.attr,
 179         NULL
 180 };
 181
 182 static const struct attribute_group sink_fixed_supply_group = {
 183         .is_visible = fixed_attr_is_visible,
 184         .attrs = sink_fixed_supply_attrs,
 185 };
 186 __ATTRIBUTE_GROUPS(sink_fixed_supply);
 187
 188 static struct device_type sink_fixed_supply_type = {
 189         .name = "pdo",
 190         .release = pdo_release,
 191         .groups = sink_fixed_supply_groups,
 192 };
 193
 194 /* -------------------------------------------------------------------------- */
 195 /* Variable Supply */
 196
 197 static ssize_t
 198 maximum_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
 199 {
 200         return sysfs_emit(buf, "%umV\n", pdo_max_voltage(to_pdo(dev)->pdo));
 201 }
 202 static DEVICE_ATTR_RO(maximum_voltage);
 203
 204 static ssize_t
 205 minimum_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
 206 {
 207         return sysfs_emit(buf, "%umV\n", pdo_min_voltage(to_pdo(dev)->pdo));
 208 }
 209 static DEVICE_ATTR_RO(minimum_voltage);
 210
 211 static struct attribute *source_variable_supply_attrs[] = {
 212         &dev_attr_maximum_voltage.attr,
 213         &dev_attr_minimum_voltage.attr,
 214         &maximum_current_attr.attr,
 215         NULL
 216 };
 217 ATTRIBUTE_GROUPS(source_variable_supply);
 218
 219 static struct device_type source_variable_supply_type = {
 220         .name = "pdo",
 221         .release = pdo_release,
 222         .groups = source_variable_supply_groups,
 223 };
 224
 225 static struct attribute *sink_variable_supply_attrs[] = {
 226         &dev_attr_maximum_voltage.attr,
 227         &dev_attr_minimum_voltage.attr,
 228         &operational_current_attr.attr,
 229         NULL
 230 };
 231 ATTRIBUTE_GROUPS(sink_variable_supply);
 232
 233 static struct device_type sink_variable_supply_type = {
 234         .name = "pdo",
 235         .release = pdo_release,
 236         .groups = sink_variable_supply_groups,
 237 };
 238
 239 /* -------------------------------------------------------------------------- */
 240 /* Battery */
 241
 242 static ssize_t
 243 maximum_power_show(struct device *dev, struct device_attribute *attr, char *buf)
 244 {
 245         return sysfs_emit(buf, "%umW\n", pdo_max_power(to_pdo(dev)->pdo));
 246 }
 247 static DEVICE_ATTR_RO(maximum_power);
 248
 249 static ssize_t
 250 operational_power_show(struct device *dev, struct device_attribute *attr, char *buf)
 251 {
 252         return sysfs_emit(buf, "%umW\n", pdo_max_power(to_pdo(dev)->pdo));
 253 }
 254 static DEVICE_ATTR_RO(operational_power);
 255
 256 static struct attribute *source_battery_attrs[] = {
 257         &dev_attr_maximum_voltage.attr,
 258         &dev_attr_minimum_voltage.attr,
 259         &dev_attr_maximum_power.attr,
 260         NULL
 261 };
 262 ATTRIBUTE_GROUPS(source_battery);
 263
 264 static struct device_type source_battery_type = {
 265         .name = "pdo",
 266         .release = pdo_release,
 267         .groups = source_battery_groups,
 268 };
 269
 270 static struct attribute *sink_battery_attrs[] = {
 271         &dev_attr_maximum_voltage.attr,
 272         &dev_attr_minimum_voltage.attr,
 273         &dev_attr_operational_power.attr,
 274         NULL
 275 };
 276 ATTRIBUTE_GROUPS(sink_battery);
 277
 278 static struct device_type sink_battery_type = {
 279         .name = "pdo",
 280         .release = pdo_release,
 281         .groups = sink_battery_groups,
 282 };
 283
 284 /* -------------------------------------------------------------------------- */
 285 /* Standard Power Range (SPR) Programmable Power Supply (PPS) */
 286
 287 static ssize_t
 288 pps_power_limited_show(struct device *dev, struct device_attribute *attr, char *buf)
 289 {
 290         return sysfs_emit(buf, "%u\n", !!(to_pdo(dev)->pdo & BIT(27)));
 291 }
 292 static DEVICE_ATTR_RO(pps_power_limited);
 293
 294 static ssize_t
 295 pps_max_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
 296 {
 297         return sysfs_emit(buf, "%umV\n", pdo_pps_apdo_max_voltage(to_pdo(dev)->pdo));
 298 }
 299
 300 static ssize_t
 301 pps_min_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
 302 {
 303         return sysfs_emit(buf, "%umV\n", pdo_pps_apdo_min_voltage(to_pdo(dev)->pdo));
 304 }
 305
 306 static ssize_t
 307 pps_max_current_show(struct device *dev, struct device_attribute *attr, char *buf)
 308 {
 309         return sysfs_emit(buf, "%umA\n", pdo_pps_apdo_max_current(to_pdo(dev)->pdo));
 310 }
 311
 312 static struct device_attribute pps_max_voltage_attr = {
 313         .attr = {
 314                 .name = "maximum_voltage",
 315                 .mode = 0444,
 316         },
 317         .show = pps_max_voltage_show,
 318 };
 319
 320 static struct device_attribute pps_min_voltage_attr = {
 321         .attr = {
 322                 .name = "minimum_voltage",
 323                 .mode = 0444,
 324         },
 325         .show = pps_min_voltage_show,
 326 };
 327
 328 static struct device_attribute pps_max_current_attr = {
 329         .attr = {
 330                 .name = "maximum_current",
 331                 .mode = 0444,
 332         },
 333         .show = pps_max_current_show,
 334 };
 335
 336 static struct attribute *source_pps_attrs[] = {
 337         &dev_attr_pps_power_limited.attr,
 338         &pps_max_voltage_attr.attr,
 339         &pps_min_voltage_attr.attr,
 340         &pps_max_current_attr.attr,
 341         NULL
 342 };
 343 ATTRIBUTE_GROUPS(source_pps);
 344
 345 static struct device_type source_pps_type = {
 346         .name = "pdo",
 347         .release = pdo_release,
 348         .groups = source_pps_groups,
 349 };
 350
 351 static struct attribute *sink_pps_attrs[] = {
 352         &pps_max_voltage_attr.attr,
 353         &pps_min_voltage_attr.attr,
 354         &pps_max_current_attr.attr,
 355         NULL
 356 };
 357 ATTRIBUTE_GROUPS(sink_pps);
 358
 359 static struct device_type sink_pps_type = {
 360         .name = "pdo",
 361         .release = pdo_release,
 362         .groups = sink_pps_groups,
 363 };
 364
 365 /* -------------------------------------------------------------------------- */
 366
 367 static const char * const supply_name[] = {
 368         [PDO_TYPE_FIXED] = "fixed_supply",
 369         [PDO_TYPE_BATT]  = "battery",
 370         [PDO_TYPE_VAR]   = "variable_supply",
 371 };
 372
 373 static const char * const apdo_supply_name[] = {
 374         [APDO_TYPE_PPS]  = "programmable_supply",
 375 };
 376
 377 static struct device_type *source_type[] = {
 378         [PDO_TYPE_FIXED] = &source_fixed_supply_type,
 379         [PDO_TYPE_BATT]  = &source_battery_type,
 380         [PDO_TYPE_VAR]   = &source_variable_supply_type,
 381 };
 382
 383 static struct device_type *source_apdo_type[] = {
 384         [APDO_TYPE_PPS]  = &source_pps_type,
 385 };
 386
 387 static struct device_type *sink_type[] = {
 388         [PDO_TYPE_FIXED] = &sink_fixed_supply_type,
 389         [PDO_TYPE_BATT]  = &sink_battery_type,
 390         [PDO_TYPE_VAR]   = &sink_variable_supply_type,
 391 };
 392
 393 static struct device_type *sink_apdo_type[] = {
 394         [APDO_TYPE_PPS]  = &sink_pps_type,
 395 };
 396
 397 /* REVISIT: Export when EPR_*_Capabilities need to be supported. */
 398 static int add_pdo(struct usb_power_delivery_capabilities *cap, u32 pdo, int position)
 399 {
 400         struct device_type *type;
 401         const char *name;
 402         struct pdo *p;
 403         int ret;
 404
 405         p = kzalloc(sizeof(*p), GFP_KERNEL);
 406         if (!p)
 407                 return -ENOMEM;
 408
 409         p->pdo = pdo;
 410         p->object_position = position;
 411
 412         if (pdo_type(pdo) == PDO_TYPE_APDO) {
 413                 /* FIXME: Only PPS supported for now! Skipping others. */
 414                 if (pdo_apdo_type(pdo) > APDO_TYPE_PPS) {
 415                         dev_warn(&cap->dev, "Unknown APDO type. PDO 0x%08x\n", pdo);
 416                         kfree(p);
 417                         return 0;
 418                 }
 419
 420                 if (is_source(cap->role))
 421                         type = source_apdo_type[pdo_apdo_type(pdo)];
 422                 else
 423                         type = sink_apdo_type[pdo_apdo_type(pdo)];
 424
 425                 name = apdo_supply_name[pdo_apdo_type(pdo)];
 426         } else {
 427                 if (is_source(cap->role))
 428                         type = source_type[pdo_type(pdo)];
 429                 else
 430                         type = sink_type[pdo_type(pdo)];
 431
 432                 name = supply_name[pdo_type(pdo)];
 433         }
 434
 435         p->dev.parent = &cap->dev;
 436         p->dev.type = type;
 437         dev_set_name(&p->dev, "%u:%s", position + 1, name);
 438
 439         ret = device_register(&p->dev);
 440         if (ret) {
 441                 put_device(&p->dev);
 442                 return ret;
 443         }
 444
 445         return 0;
 446 }
 447
 448 static int remove_pdo(struct device *dev, void *data)
 449 {
 450         device_unregister(dev);
 451         return 0;
 452 }
 453
 454 /* -------------------------------------------------------------------------- */
 455
 456 static const char * const cap_name[] = {
 457         [TYPEC_SINK]    = "sink-capabilities",
 458         [TYPEC_SOURCE]  = "source-capabilities",
 459 };
 460
 461 static void pd_capabilities_release(struct device *dev)
 462 {
 463         kfree(to_usb_power_delivery_capabilities(dev));
 464 }
 465
 466 static struct device_type pd_capabilities_type = {
 467         .name = "capabilities",
 468         .release = pd_capabilities_release,
 469 };
 470
 471 /**
 472  * usb_power_delivery_register_capabilities - Register a set of capabilities.
 473  * @pd: The USB PD instance that the capabilities belong to.
 474  * @desc: Description of the Capablities Message.
 475  *
 476  * This function registers a Capabilities Message described in @desc. The
 477  * capabilities will have their own sub-directory under @pd in sysfs.
 478  *
 479  * The function returns pointer to struct usb_power_delivery_capabilities, or
 480  * ERR_PRT(errno).
 481  */
 482 struct usb_power_delivery_capabilities *
 483 usb_power_delivery_register_capabilities(struct usb_power_delivery *pd,
 484                                          struct usb_power_delivery_capabilities_desc *desc)
 485 {
 486         struct usb_power_delivery_capabilities *cap;
 487         int ret;
 488         int i;
 489
 490         cap = kzalloc(sizeof(*cap), GFP_KERNEL);
 491         if (!cap)
 492                 return ERR_PTR(-ENOMEM);
 493
 494         cap->pd = pd;
 495         cap->role = desc->role;
 496
 497         cap->dev.parent = &pd->dev;
 498         cap->dev.type = &pd_capabilities_type;
 499         dev_set_name(&cap->dev, "%s", cap_name[cap->role]);
 500
 501         ret = device_register(&cap->dev);
 502         if (ret) {
 503                 put_device(&cap->dev);
 504                 return ERR_PTR(ret);
 505         }
 506
 507         for (i = 0; i < PDO_MAX_OBJECTS && desc->pdo[i]; i++) {
 508                 ret = add_pdo(cap, desc->pdo[i], i);
 509                 if (ret) {
 510                         usb_power_delivery_unregister_capabilities(cap);
 511                         return ERR_PTR(ret);
 512                 }
 513         }
 514
 515         return cap;
 516 }
 517 EXPORT_SYMBOL_GPL(usb_power_delivery_register_capabilities);
 518
 519 /**
 520  * usb_power_delivery_unregister_capabilities - Unregister a set of capabilities
 521  * @cap: The capabilities
 522  */
 523 void usb_power_delivery_unregister_capabilities(struct usb_power_delivery_capabilities *cap)
 524 {
 525         if (!cap)
 526                 return;
 527
 528         device_for_each_child(&cap->dev, NULL, remove_pdo);
 529         device_unregister(&cap->dev);
 530 }
 531 EXPORT_SYMBOL_GPL(usb_power_delivery_unregister_capabilities);
 532
 533 /* -------------------------------------------------------------------------- */
 534
 535 static ssize_t revision_show(struct device *dev, struct device_attribute *attr, char *buf)
 536 {
 537         struct usb_power_delivery *pd = to_usb_power_delivery(dev);
 538
 539         return sysfs_emit(buf, "%u.%u\n", (pd->revision >> 8) & 0xff, (pd->revision >> 4) & 0xf);
 540 }
 541 static DEVICE_ATTR_RO(revision);
 542
 543 static ssize_t version_show(struct device *dev, struct device_attribute *attr, char *buf)
 544 {
 545         struct usb_power_delivery *pd = to_usb_power_delivery(dev);
 546
 547         return sysfs_emit(buf, "%u.%u\n", (pd->version >> 8) & 0xff, (pd->version >> 4) & 0xf);
 548 }
 549 static DEVICE_ATTR_RO(version);
 550
 551 static struct attribute *pd_attrs[] = {
 552         &dev_attr_revision.attr,
 553         &dev_attr_version.attr,
 554         NULL
 555 };
 556
 557 static umode_t pd_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n)
 558 {
 559         struct usb_power_delivery *pd = to_usb_power_delivery(kobj_to_dev(kobj));
 560
 561         if (attr == &dev_attr_version.attr && !pd->version)
 562                 return 0;
 563
 564         return attr->mode;
 565 }
 566
 567 static const struct attribute_group pd_group = {
 568         .is_visible = pd_attr_is_visible,
 569         .attrs = pd_attrs,
 570 };
 571 __ATTRIBUTE_GROUPS(pd);
 572
 573 static void pd_release(struct device *dev)
 574 {
 575         struct usb_power_delivery *pd = to_usb_power_delivery(dev);
 576
 577         ida_simple_remove(&pd_ida, pd->id);
 578         kfree(pd);
 579 }
 580
 581 static struct device_type pd_type = {
 582         .name = "usb_power_delivery",
 583         .release = pd_release,
 584         .groups = pd_groups,
 585 };
 586
 587 struct usb_power_delivery *usb_power_delivery_find(const char *name)
 588 {
 589         struct device *dev;
 590
 591         dev = class_find_device_by_name(&pd_class, name);
 592
 593         return dev ? to_usb_power_delivery(dev) : NULL;
 594 }
 595
 596 /**
 597  * usb_power_delivery_register - Register USB Power Delivery Support.
 598  * @parent: Parent device.
 599  * @desc: Description of the USB PD contract.
 600  *
 601  * This routine can be used to register USB Power Delivery capabilities that a
 602  * device or devices can support. These capabilities represent all the
 603  * capabilities that can be negotiated with a partner, so not only the Power
 604  * Capabilities that are negotiated using the USB PD Capabilities Message.
 605  *
 606  * The USB Power Delivery Support object that this routine generates can be used
 607  * as the parent object for all the actual USB Power Delivery Messages and
 608  * objects that can be negotiated with the partner.
 609  *
 610  * Returns handle to struct usb_power_delivery or ERR_PTR.
 611  */
 612 struct usb_power_delivery *
 613 usb_power_delivery_register(struct device *parent, struct usb_power_delivery_desc *desc)
 614 {
 615         struct usb_power_delivery *pd;
 616         int ret;
 617
 618         pd = kzalloc(sizeof(*pd), GFP_KERNEL);
 619         if (!pd)
 620                 return ERR_PTR(-ENOMEM);
 621
 622         ret = ida_simple_get(&pd_ida, 0, 0, GFP_KERNEL);
 623         if (ret < 0) {
 624                 kfree(pd);
 625                 return ERR_PTR(ret);
 626         }
 627
 628         pd->id = ret;
 629         pd->revision = desc->revision;
 630         pd->version = desc->version;
 631
 632         pd->dev.parent = parent;
 633         pd->dev.type = &pd_type;
 634         pd->dev.class = &pd_class;
 635         dev_set_name(&pd->dev, "pd%d", pd->id);
 636
 637         ret = device_register(&pd->dev);
 638         if (ret) {
 639                 put_device(&pd->dev);
 640                 return ERR_PTR(ret);
 641         }
 642
 643         return pd;
 644 }
 645 EXPORT_SYMBOL_GPL(usb_power_delivery_register);
 646
 647 /**
 648  * usb_power_delivery_unregister - Unregister USB Power Delivery Support.
 649  * @pd: The USB PD contract.
 650  */
 651 void usb_power_delivery_unregister(struct usb_power_delivery *pd)
 652 {
 653         if (IS_ERR_OR_NULL(pd))
 654                 return;
 655
 656         device_unregister(&pd->dev);
 657 }
 658 EXPORT_SYMBOL_GPL(usb_power_delivery_unregister);
 659
 660 /**
 661  * usb_power_delivery_link_device - Link device to its USB PD object.
 662  * @pd: The USB PD instance.
 663  * @dev: The device.
 664  *
 665  * This function can be used to create a symlink named "usb_power_delivery" for
 666  * @dev that points to @pd.
 667  */
 668 int usb_power_delivery_link_device(struct usb_power_delivery *pd, struct device *dev)
 669 {
 670         int ret;
 671
 672         if (IS_ERR_OR_NULL(pd) || !dev)
 673                 return 0;
 674
 675         ret = sysfs_create_link(&dev->kobj, &pd->dev.kobj, "usb_power_delivery");
 676         if (ret)
 677                 return ret;
 678
 679         get_device(&pd->dev);
 680         get_device(dev);
 681
 682         return 0;
 683 }
 684 EXPORT_SYMBOL_GPL(usb_power_delivery_link_device);
 685
 686 /**
 687  * usb_power_delivery_unlink_device - Unlink device from its USB PD object.
 688  * @pd: The USB PD instance.
 689  * @dev: The device.
 690  *
 691  * Remove the symlink that was previously created with pd_link_device().
 692  */
 693 void usb_power_delivery_unlink_device(struct usb_power_delivery *pd, struct device *dev)
 694 {
 695         if (IS_ERR_OR_NULL(pd) || !dev)
 696                 return;
 697
 698         sysfs_remove_link(&dev->kobj, "usb_power_delivery");
 699         put_device(&pd->dev);
 700         put_device(dev);
 701 }
 702 EXPORT_SYMBOL_GPL(usb_power_delivery_unlink_device);
 703
 704 /* -------------------------------------------------------------------------- */
 705
 706 int __init usb_power_delivery_init(void)
 707 {
 708         return class_register(&pd_class);
 709 }
 710
 711 void __exit usb_power_delivery_exit(void)
 712 {
 713         ida_destroy(&pd_ida);
 714         class_unregister(&pd_class);
 715 }