1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * USB Type-C Connector Class 4 * 5 * Copyright (C) 2017, Intel Corporation 6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 7 */ 8 9 #include <linux/device.h> 10 #include <linux/module.h> 11 #include <linux/mutex.h> 12 #include <linux/property.h> 13 #include <linux/slab.h> 14 15 #include "bus.h" 16 17 struct typec_plug { 18 struct device dev; 19 enum typec_plug_index index; 20 struct ida mode_ids; 21 }; 22 23 struct typec_cable { 24 struct device dev; 25 enum typec_plug_type type; 26 struct usb_pd_identity *identity; 27 unsigned int active:1; 28 }; 29 30 struct typec_partner { 31 struct device dev; 32 unsigned int usb_pd:1; 33 struct usb_pd_identity *identity; 34 enum typec_accessory accessory; 35 struct ida mode_ids; 36 }; 37 38 struct typec_port { 39 unsigned int id; 40 struct device dev; 41 struct ida mode_ids; 42 43 int prefer_role; 44 enum typec_data_role data_role; 45 enum typec_role pwr_role; 46 enum typec_role vconn_role; 47 enum typec_pwr_opmode pwr_opmode; 48 enum typec_port_type port_type; 49 struct mutex port_type_lock; 50 51 enum typec_orientation orientation; 52 struct typec_switch *sw; 53 struct typec_mux *mux; 54 55 const struct typec_capability *cap; 56 }; 57 58 #define to_typec_port(_dev_) container_of(_dev_, struct typec_port, dev) 59 #define to_typec_plug(_dev_) container_of(_dev_, struct typec_plug, dev) 60 #define to_typec_cable(_dev_) container_of(_dev_, struct typec_cable, dev) 61 #define to_typec_partner(_dev_) container_of(_dev_, struct typec_partner, dev) 62 63 static const struct device_type typec_partner_dev_type; 64 static const struct device_type typec_cable_dev_type; 65 static const struct device_type typec_plug_dev_type; 66 67 #define is_typec_partner(_dev_) (_dev_->type == &typec_partner_dev_type) 68 #define is_typec_cable(_dev_) (_dev_->type == &typec_cable_dev_type) 69 #define is_typec_plug(_dev_) (_dev_->type == &typec_plug_dev_type) 70 71 static DEFINE_IDA(typec_index_ida); 72 static struct class *typec_class; 73 74 /* ------------------------------------------------------------------------- */ 75 /* Common attributes */ 76 77 static const char * const typec_accessory_modes[] = { 78 [TYPEC_ACCESSORY_NONE] = "none", 79 [TYPEC_ACCESSORY_AUDIO] = "analog_audio", 80 [TYPEC_ACCESSORY_DEBUG] = "debug", 81 }; 82 83 static struct usb_pd_identity *get_pd_identity(struct device *dev) 84 { 85 if (is_typec_partner(dev)) { 86 struct typec_partner *partner = to_typec_partner(dev); 87 88 return partner->identity; 89 } else if (is_typec_cable(dev)) { 90 struct typec_cable *cable = to_typec_cable(dev); 91 92 return cable->identity; 93 } 94 return NULL; 95 } 96 97 static ssize_t id_header_show(struct device *dev, struct device_attribute *attr, 98 char *buf) 99 { 100 struct usb_pd_identity *id = get_pd_identity(dev); 101 102 return sprintf(buf, "0x%08x\n", id->id_header); 103 } 104 static DEVICE_ATTR_RO(id_header); 105 106 static ssize_t cert_stat_show(struct device *dev, struct device_attribute *attr, 107 char *buf) 108 { 109 struct usb_pd_identity *id = get_pd_identity(dev); 110 111 return sprintf(buf, "0x%08x\n", id->cert_stat); 112 } 113 static DEVICE_ATTR_RO(cert_stat); 114 115 static ssize_t product_show(struct device *dev, struct device_attribute *attr, 116 char *buf) 117 { 118 struct usb_pd_identity *id = get_pd_identity(dev); 119 120 return sprintf(buf, "0x%08x\n", id->product); 121 } 122 static DEVICE_ATTR_RO(product); 123 124 static struct attribute *usb_pd_id_attrs[] = { 125 &dev_attr_id_header.attr, 126 &dev_attr_cert_stat.attr, 127 &dev_attr_product.attr, 128 NULL 129 }; 130 131 static const struct attribute_group usb_pd_id_group = { 132 .name = "identity", 133 .attrs = usb_pd_id_attrs, 134 }; 135 136 static const struct attribute_group *usb_pd_id_groups[] = { 137 &usb_pd_id_group, 138 NULL, 139 }; 140 141 static void typec_report_identity(struct device *dev) 142 { 143 sysfs_notify(&dev->kobj, "identity", "id_header"); 144 sysfs_notify(&dev->kobj, "identity", "cert_stat"); 145 sysfs_notify(&dev->kobj, "identity", "product"); 146 } 147 148 /* ------------------------------------------------------------------------- */ 149 /* Alternate Modes */ 150 151 static int altmode_match(struct device *dev, void *data) 152 { 153 struct typec_altmode *adev = to_typec_altmode(dev); 154 struct typec_device_id *id = data; 155 156 if (!is_typec_altmode(dev)) 157 return 0; 158 159 return ((adev->svid == id->svid) && (adev->mode == id->mode)); 160 } 161 162 static void typec_altmode_set_partner(struct altmode *altmode) 163 { 164 struct typec_altmode *adev = &altmode->adev; 165 struct typec_device_id id = { adev->svid, adev->mode, }; 166 struct typec_port *port = typec_altmode2port(adev); 167 struct altmode *partner; 168 struct device *dev; 169 170 dev = device_find_child(&port->dev, &id, altmode_match); 171 if (!dev) 172 return; 173 174 /* Bind the port alt mode to the partner/plug alt mode. */ 175 partner = to_altmode(to_typec_altmode(dev)); 176 altmode->partner = partner; 177 178 /* Bind the partner/plug alt mode to the port alt mode. */ 179 if (is_typec_plug(adev->dev.parent)) { 180 struct typec_plug *plug = to_typec_plug(adev->dev.parent); 181 182 partner->plug[plug->index] = altmode; 183 } else { 184 partner->partner = altmode; 185 } 186 } 187 188 static void typec_altmode_put_partner(struct altmode *altmode) 189 { 190 struct altmode *partner = altmode->partner; 191 struct typec_altmode *adev; 192 193 if (!partner) 194 return; 195 196 adev = &partner->adev; 197 198 if (is_typec_plug(adev->dev.parent)) { 199 struct typec_plug *plug = to_typec_plug(adev->dev.parent); 200 201 partner->plug[plug->index] = NULL; 202 } else { 203 partner->partner = NULL; 204 } 205 put_device(&adev->dev); 206 } 207 208 static void *typec_port_match(struct device_connection *con, int ep, void *data) 209 { 210 struct device *dev; 211 212 /* 213 * FIXME: Check does the fwnode supports the requested SVID. If it does 214 * we need to return ERR_PTR(-PROBE_DEFER) when there is no device. 215 */ 216 if (con->fwnode) 217 return class_find_device_by_fwnode(typec_class, con->fwnode); 218 219 dev = class_find_device_by_name(typec_class, con->endpoint[ep]); 220 221 return dev ? dev : ERR_PTR(-EPROBE_DEFER); 222 } 223 224 struct typec_altmode * 225 typec_altmode_register_notifier(struct device *dev, u16 svid, u8 mode, 226 struct notifier_block *nb) 227 { 228 struct typec_device_id id = { svid, mode, }; 229 struct device *altmode_dev; 230 struct device *port_dev; 231 struct altmode *altmode; 232 int ret; 233 234 /* Find the port linked to the caller */ 235 port_dev = device_connection_find_match(dev, NULL, NULL, 236 typec_port_match); 237 if (IS_ERR_OR_NULL(port_dev)) 238 return port_dev ? ERR_CAST(port_dev) : ERR_PTR(-ENODEV); 239 240 /* Find the altmode with matching svid */ 241 altmode_dev = device_find_child(port_dev, &id, altmode_match); 242 243 put_device(port_dev); 244 245 if (!altmode_dev) 246 return ERR_PTR(-ENODEV); 247 248 altmode = to_altmode(to_typec_altmode(altmode_dev)); 249 250 /* Register notifier */ 251 ret = blocking_notifier_chain_register(&altmode->nh, nb); 252 if (ret) { 253 put_device(altmode_dev); 254 return ERR_PTR(ret); 255 } 256 257 return &altmode->adev; 258 } 259 EXPORT_SYMBOL_GPL(typec_altmode_register_notifier); 260 261 void typec_altmode_unregister_notifier(struct typec_altmode *adev, 262 struct notifier_block *nb) 263 { 264 struct altmode *altmode = to_altmode(adev); 265 266 blocking_notifier_chain_unregister(&altmode->nh, nb); 267 put_device(&adev->dev); 268 } 269 EXPORT_SYMBOL_GPL(typec_altmode_unregister_notifier); 270 271 /** 272 * typec_altmode_update_active - Report Enter/Exit mode 273 * @adev: Handle to the alternate mode 274 * @active: True when the mode has been entered 275 * 276 * If a partner or cable plug executes Enter/Exit Mode command successfully, the 277 * drivers use this routine to report the updated state of the mode. 278 */ 279 void typec_altmode_update_active(struct typec_altmode *adev, bool active) 280 { 281 char dir[6]; 282 283 if (adev->active == active) 284 return; 285 286 if (!is_typec_port(adev->dev.parent) && adev->dev.driver) { 287 if (!active) 288 module_put(adev->dev.driver->owner); 289 else 290 WARN_ON(!try_module_get(adev->dev.driver->owner)); 291 } 292 293 adev->active = active; 294 snprintf(dir, sizeof(dir), "mode%d", adev->mode); 295 sysfs_notify(&adev->dev.kobj, dir, "active"); 296 sysfs_notify(&adev->dev.kobj, NULL, "active"); 297 kobject_uevent(&adev->dev.kobj, KOBJ_CHANGE); 298 } 299 EXPORT_SYMBOL_GPL(typec_altmode_update_active); 300 301 /** 302 * typec_altmode2port - Alternate Mode to USB Type-C port 303 * @alt: The Alternate Mode 304 * 305 * Returns handle to the port that a cable plug or partner with @alt is 306 * connected to. 307 */ 308 struct typec_port *typec_altmode2port(struct typec_altmode *alt) 309 { 310 if (is_typec_plug(alt->dev.parent)) 311 return to_typec_port(alt->dev.parent->parent->parent); 312 if (is_typec_partner(alt->dev.parent)) 313 return to_typec_port(alt->dev.parent->parent); 314 if (is_typec_port(alt->dev.parent)) 315 return to_typec_port(alt->dev.parent); 316 317 return NULL; 318 } 319 EXPORT_SYMBOL_GPL(typec_altmode2port); 320 321 static ssize_t 322 vdo_show(struct device *dev, struct device_attribute *attr, char *buf) 323 { 324 struct typec_altmode *alt = to_typec_altmode(dev); 325 326 return sprintf(buf, "0x%08x\n", alt->vdo); 327 } 328 static DEVICE_ATTR_RO(vdo); 329 330 static ssize_t 331 description_show(struct device *dev, struct device_attribute *attr, char *buf) 332 { 333 struct typec_altmode *alt = to_typec_altmode(dev); 334 335 return sprintf(buf, "%s\n", alt->desc ? alt->desc : ""); 336 } 337 static DEVICE_ATTR_RO(description); 338 339 static ssize_t 340 active_show(struct device *dev, struct device_attribute *attr, char *buf) 341 { 342 struct typec_altmode *alt = to_typec_altmode(dev); 343 344 return sprintf(buf, "%s\n", alt->active ? "yes" : "no"); 345 } 346 347 static ssize_t active_store(struct device *dev, struct device_attribute *attr, 348 const char *buf, size_t size) 349 { 350 struct typec_altmode *adev = to_typec_altmode(dev); 351 struct altmode *altmode = to_altmode(adev); 352 bool enter; 353 int ret; 354 355 ret = kstrtobool(buf, &enter); 356 if (ret) 357 return ret; 358 359 if (adev->active == enter) 360 return size; 361 362 if (is_typec_port(adev->dev.parent)) { 363 typec_altmode_update_active(adev, enter); 364 365 /* Make sure that the partner exits the mode before disabling */ 366 if (altmode->partner && !enter && altmode->partner->adev.active) 367 typec_altmode_exit(&altmode->partner->adev); 368 } else if (altmode->partner) { 369 if (enter && !altmode->partner->adev.active) { 370 dev_warn(dev, "port has the mode disabled\n"); 371 return -EPERM; 372 } 373 } 374 375 /* Note: If there is no driver, the mode will not be entered */ 376 if (adev->ops && adev->ops->activate) { 377 ret = adev->ops->activate(adev, enter); 378 if (ret) 379 return ret; 380 } 381 382 return size; 383 } 384 static DEVICE_ATTR_RW(active); 385 386 static ssize_t 387 supported_roles_show(struct device *dev, struct device_attribute *attr, 388 char *buf) 389 { 390 struct altmode *alt = to_altmode(to_typec_altmode(dev)); 391 ssize_t ret; 392 393 switch (alt->roles) { 394 case TYPEC_PORT_SRC: 395 ret = sprintf(buf, "source\n"); 396 break; 397 case TYPEC_PORT_SNK: 398 ret = sprintf(buf, "sink\n"); 399 break; 400 case TYPEC_PORT_DRP: 401 default: 402 ret = sprintf(buf, "source sink\n"); 403 break; 404 } 405 return ret; 406 } 407 static DEVICE_ATTR_RO(supported_roles); 408 409 static ssize_t 410 mode_show(struct device *dev, struct device_attribute *attr, char *buf) 411 { 412 struct typec_altmode *adev = to_typec_altmode(dev); 413 414 return sprintf(buf, "%u\n", adev->mode); 415 } 416 static DEVICE_ATTR_RO(mode); 417 418 static ssize_t 419 svid_show(struct device *dev, struct device_attribute *attr, char *buf) 420 { 421 struct typec_altmode *adev = to_typec_altmode(dev); 422 423 return sprintf(buf, "%04x\n", adev->svid); 424 } 425 static DEVICE_ATTR_RO(svid); 426 427 static struct attribute *typec_altmode_attrs[] = { 428 &dev_attr_active.attr, 429 &dev_attr_mode.attr, 430 &dev_attr_svid.attr, 431 &dev_attr_vdo.attr, 432 NULL 433 }; 434 ATTRIBUTE_GROUPS(typec_altmode); 435 436 static int altmode_id_get(struct device *dev) 437 { 438 struct ida *ids; 439 440 if (is_typec_partner(dev)) 441 ids = &to_typec_partner(dev)->mode_ids; 442 else if (is_typec_plug(dev)) 443 ids = &to_typec_plug(dev)->mode_ids; 444 else 445 ids = &to_typec_port(dev)->mode_ids; 446 447 return ida_simple_get(ids, 0, 0, GFP_KERNEL); 448 } 449 450 static void altmode_id_remove(struct device *dev, int id) 451 { 452 struct ida *ids; 453 454 if (is_typec_partner(dev)) 455 ids = &to_typec_partner(dev)->mode_ids; 456 else if (is_typec_plug(dev)) 457 ids = &to_typec_plug(dev)->mode_ids; 458 else 459 ids = &to_typec_port(dev)->mode_ids; 460 461 ida_simple_remove(ids, id); 462 } 463 464 static void typec_altmode_release(struct device *dev) 465 { 466 struct altmode *alt = to_altmode(to_typec_altmode(dev)); 467 468 typec_altmode_put_partner(alt); 469 470 altmode_id_remove(alt->adev.dev.parent, alt->id); 471 kfree(alt); 472 } 473 474 const struct device_type typec_altmode_dev_type = { 475 .name = "typec_alternate_mode", 476 .groups = typec_altmode_groups, 477 .release = typec_altmode_release, 478 }; 479 480 static struct typec_altmode * 481 typec_register_altmode(struct device *parent, 482 const struct typec_altmode_desc *desc) 483 { 484 unsigned int id = altmode_id_get(parent); 485 bool is_port = is_typec_port(parent); 486 struct altmode *alt; 487 int ret; 488 489 alt = kzalloc(sizeof(*alt), GFP_KERNEL); 490 if (!alt) 491 return ERR_PTR(-ENOMEM); 492 493 alt->adev.svid = desc->svid; 494 alt->adev.mode = desc->mode; 495 alt->adev.vdo = desc->vdo; 496 alt->roles = desc->roles; 497 alt->id = id; 498 499 alt->attrs[0] = &dev_attr_vdo.attr; 500 alt->attrs[1] = &dev_attr_description.attr; 501 alt->attrs[2] = &dev_attr_active.attr; 502 503 if (is_port) { 504 alt->attrs[3] = &dev_attr_supported_roles.attr; 505 alt->adev.active = true; /* Enabled by default */ 506 } 507 508 sprintf(alt->group_name, "mode%d", desc->mode); 509 alt->group.name = alt->group_name; 510 alt->group.attrs = alt->attrs; 511 alt->groups[0] = &alt->group; 512 513 alt->adev.dev.parent = parent; 514 alt->adev.dev.groups = alt->groups; 515 alt->adev.dev.type = &typec_altmode_dev_type; 516 dev_set_name(&alt->adev.dev, "%s.%u", dev_name(parent), id); 517 518 /* Link partners and plugs with the ports */ 519 if (is_port) 520 BLOCKING_INIT_NOTIFIER_HEAD(&alt->nh); 521 else 522 typec_altmode_set_partner(alt); 523 524 /* The partners are bind to drivers */ 525 if (is_typec_partner(parent)) 526 alt->adev.dev.bus = &typec_bus; 527 528 ret = device_register(&alt->adev.dev); 529 if (ret) { 530 dev_err(parent, "failed to register alternate mode (%d)\n", 531 ret); 532 put_device(&alt->adev.dev); 533 return ERR_PTR(ret); 534 } 535 536 return &alt->adev; 537 } 538 539 /** 540 * typec_unregister_altmode - Unregister Alternate Mode 541 * @adev: The alternate mode to be unregistered 542 * 543 * Unregister device created with typec_partner_register_altmode(), 544 * typec_plug_register_altmode() or typec_port_register_altmode(). 545 */ 546 void typec_unregister_altmode(struct typec_altmode *adev) 547 { 548 if (IS_ERR_OR_NULL(adev)) 549 return; 550 typec_mux_put(to_altmode(adev)->mux); 551 device_unregister(&adev->dev); 552 } 553 EXPORT_SYMBOL_GPL(typec_unregister_altmode); 554 555 /* ------------------------------------------------------------------------- */ 556 /* Type-C Partners */ 557 558 static ssize_t accessory_mode_show(struct device *dev, 559 struct device_attribute *attr, 560 char *buf) 561 { 562 struct typec_partner *p = to_typec_partner(dev); 563 564 return sprintf(buf, "%s\n", typec_accessory_modes[p->accessory]); 565 } 566 static DEVICE_ATTR_RO(accessory_mode); 567 568 static ssize_t supports_usb_power_delivery_show(struct device *dev, 569 struct device_attribute *attr, 570 char *buf) 571 { 572 struct typec_partner *p = to_typec_partner(dev); 573 574 return sprintf(buf, "%s\n", p->usb_pd ? "yes" : "no"); 575 } 576 static DEVICE_ATTR_RO(supports_usb_power_delivery); 577 578 static struct attribute *typec_partner_attrs[] = { 579 &dev_attr_accessory_mode.attr, 580 &dev_attr_supports_usb_power_delivery.attr, 581 NULL 582 }; 583 ATTRIBUTE_GROUPS(typec_partner); 584 585 static void typec_partner_release(struct device *dev) 586 { 587 struct typec_partner *partner = to_typec_partner(dev); 588 589 ida_destroy(&partner->mode_ids); 590 kfree(partner); 591 } 592 593 static const struct device_type typec_partner_dev_type = { 594 .name = "typec_partner", 595 .groups = typec_partner_groups, 596 .release = typec_partner_release, 597 }; 598 599 /** 600 * typec_partner_set_identity - Report result from Discover Identity command 601 * @partner: The partner updated identity values 602 * 603 * This routine is used to report that the result of Discover Identity USB power 604 * delivery command has become available. 605 */ 606 int typec_partner_set_identity(struct typec_partner *partner) 607 { 608 if (!partner->identity) 609 return -EINVAL; 610 611 typec_report_identity(&partner->dev); 612 return 0; 613 } 614 EXPORT_SYMBOL_GPL(typec_partner_set_identity); 615 616 /** 617 * typec_partner_register_altmode - Register USB Type-C Partner Alternate Mode 618 * @partner: USB Type-C Partner that supports the alternate mode 619 * @desc: Description of the alternate mode 620 * 621 * This routine is used to register each alternate mode individually that 622 * @partner has listed in response to Discover SVIDs command. The modes for a 623 * SVID listed in response to Discover Modes command need to be listed in an 624 * array in @desc. 625 * 626 * Returns handle to the alternate mode on success or NULL on failure. 627 */ 628 struct typec_altmode * 629 typec_partner_register_altmode(struct typec_partner *partner, 630 const struct typec_altmode_desc *desc) 631 { 632 return typec_register_altmode(&partner->dev, desc); 633 } 634 EXPORT_SYMBOL_GPL(typec_partner_register_altmode); 635 636 /** 637 * typec_register_partner - Register a USB Type-C Partner 638 * @port: The USB Type-C Port the partner is connected to 639 * @desc: Description of the partner 640 * 641 * Registers a device for USB Type-C Partner described in @desc. 642 * 643 * Returns handle to the partner on success or ERR_PTR on failure. 644 */ 645 struct typec_partner *typec_register_partner(struct typec_port *port, 646 struct typec_partner_desc *desc) 647 { 648 struct typec_partner *partner; 649 int ret; 650 651 partner = kzalloc(sizeof(*partner), GFP_KERNEL); 652 if (!partner) 653 return ERR_PTR(-ENOMEM); 654 655 ida_init(&partner->mode_ids); 656 partner->usb_pd = desc->usb_pd; 657 partner->accessory = desc->accessory; 658 659 if (desc->identity) { 660 /* 661 * Creating directory for the identity only if the driver is 662 * able to provide data to it. 663 */ 664 partner->dev.groups = usb_pd_id_groups; 665 partner->identity = desc->identity; 666 } 667 668 partner->dev.class = typec_class; 669 partner->dev.parent = &port->dev; 670 partner->dev.type = &typec_partner_dev_type; 671 dev_set_name(&partner->dev, "%s-partner", dev_name(&port->dev)); 672 673 ret = device_register(&partner->dev); 674 if (ret) { 675 dev_err(&port->dev, "failed to register partner (%d)\n", ret); 676 put_device(&partner->dev); 677 return ERR_PTR(ret); 678 } 679 680 return partner; 681 } 682 EXPORT_SYMBOL_GPL(typec_register_partner); 683 684 /** 685 * typec_unregister_partner - Unregister a USB Type-C Partner 686 * @partner: The partner to be unregistered 687 * 688 * Unregister device created with typec_register_partner(). 689 */ 690 void typec_unregister_partner(struct typec_partner *partner) 691 { 692 if (!IS_ERR_OR_NULL(partner)) 693 device_unregister(&partner->dev); 694 } 695 EXPORT_SYMBOL_GPL(typec_unregister_partner); 696 697 /* ------------------------------------------------------------------------- */ 698 /* Type-C Cable Plugs */ 699 700 static void typec_plug_release(struct device *dev) 701 { 702 struct typec_plug *plug = to_typec_plug(dev); 703 704 ida_destroy(&plug->mode_ids); 705 kfree(plug); 706 } 707 708 static const struct device_type typec_plug_dev_type = { 709 .name = "typec_plug", 710 .release = typec_plug_release, 711 }; 712 713 /** 714 * typec_plug_register_altmode - Register USB Type-C Cable Plug Alternate Mode 715 * @plug: USB Type-C Cable Plug that supports the alternate mode 716 * @desc: Description of the alternate mode 717 * 718 * This routine is used to register each alternate mode individually that @plug 719 * has listed in response to Discover SVIDs command. The modes for a SVID that 720 * the plug lists in response to Discover Modes command need to be listed in an 721 * array in @desc. 722 * 723 * Returns handle to the alternate mode on success or ERR_PTR on failure. 724 */ 725 struct typec_altmode * 726 typec_plug_register_altmode(struct typec_plug *plug, 727 const struct typec_altmode_desc *desc) 728 { 729 return typec_register_altmode(&plug->dev, desc); 730 } 731 EXPORT_SYMBOL_GPL(typec_plug_register_altmode); 732 733 /** 734 * typec_register_plug - Register a USB Type-C Cable Plug 735 * @cable: USB Type-C Cable with the plug 736 * @desc: Description of the cable plug 737 * 738 * Registers a device for USB Type-C Cable Plug described in @desc. A USB Type-C 739 * Cable Plug represents a plug with electronics in it that can response to USB 740 * Power Delivery SOP Prime or SOP Double Prime packages. 741 * 742 * Returns handle to the cable plug on success or ERR_PTR on failure. 743 */ 744 struct typec_plug *typec_register_plug(struct typec_cable *cable, 745 struct typec_plug_desc *desc) 746 { 747 struct typec_plug *plug; 748 char name[8]; 749 int ret; 750 751 plug = kzalloc(sizeof(*plug), GFP_KERNEL); 752 if (!plug) 753 return ERR_PTR(-ENOMEM); 754 755 sprintf(name, "plug%d", desc->index); 756 757 ida_init(&plug->mode_ids); 758 plug->index = desc->index; 759 plug->dev.class = typec_class; 760 plug->dev.parent = &cable->dev; 761 plug->dev.type = &typec_plug_dev_type; 762 dev_set_name(&plug->dev, "%s-%s", dev_name(cable->dev.parent), name); 763 764 ret = device_register(&plug->dev); 765 if (ret) { 766 dev_err(&cable->dev, "failed to register plug (%d)\n", ret); 767 put_device(&plug->dev); 768 return ERR_PTR(ret); 769 } 770 771 return plug; 772 } 773 EXPORT_SYMBOL_GPL(typec_register_plug); 774 775 /** 776 * typec_unregister_plug - Unregister a USB Type-C Cable Plug 777 * @plug: The cable plug to be unregistered 778 * 779 * Unregister device created with typec_register_plug(). 780 */ 781 void typec_unregister_plug(struct typec_plug *plug) 782 { 783 if (!IS_ERR_OR_NULL(plug)) 784 device_unregister(&plug->dev); 785 } 786 EXPORT_SYMBOL_GPL(typec_unregister_plug); 787 788 /* Type-C Cables */ 789 790 static ssize_t 791 type_show(struct device *dev, struct device_attribute *attr, char *buf) 792 { 793 struct typec_cable *cable = to_typec_cable(dev); 794 795 return sprintf(buf, "%s\n", cable->active ? "active" : "passive"); 796 } 797 static DEVICE_ATTR_RO(type); 798 799 static const char * const typec_plug_types[] = { 800 [USB_PLUG_NONE] = "unknown", 801 [USB_PLUG_TYPE_A] = "type-a", 802 [USB_PLUG_TYPE_B] = "type-b", 803 [USB_PLUG_TYPE_C] = "type-c", 804 [USB_PLUG_CAPTIVE] = "captive", 805 }; 806 807 static ssize_t plug_type_show(struct device *dev, 808 struct device_attribute *attr, char *buf) 809 { 810 struct typec_cable *cable = to_typec_cable(dev); 811 812 return sprintf(buf, "%s\n", typec_plug_types[cable->type]); 813 } 814 static DEVICE_ATTR_RO(plug_type); 815 816 static struct attribute *typec_cable_attrs[] = { 817 &dev_attr_type.attr, 818 &dev_attr_plug_type.attr, 819 NULL 820 }; 821 ATTRIBUTE_GROUPS(typec_cable); 822 823 static void typec_cable_release(struct device *dev) 824 { 825 struct typec_cable *cable = to_typec_cable(dev); 826 827 kfree(cable); 828 } 829 830 static const struct device_type typec_cable_dev_type = { 831 .name = "typec_cable", 832 .groups = typec_cable_groups, 833 .release = typec_cable_release, 834 }; 835 836 /** 837 * typec_cable_set_identity - Report result from Discover Identity command 838 * @cable: The cable updated identity values 839 * 840 * This routine is used to report that the result of Discover Identity USB power 841 * delivery command has become available. 842 */ 843 int typec_cable_set_identity(struct typec_cable *cable) 844 { 845 if (!cable->identity) 846 return -EINVAL; 847 848 typec_report_identity(&cable->dev); 849 return 0; 850 } 851 EXPORT_SYMBOL_GPL(typec_cable_set_identity); 852 853 /** 854 * typec_register_cable - Register a USB Type-C Cable 855 * @port: The USB Type-C Port the cable is connected to 856 * @desc: Description of the cable 857 * 858 * Registers a device for USB Type-C Cable described in @desc. The cable will be 859 * parent for the optional cable plug devises. 860 * 861 * Returns handle to the cable on success or ERR_PTR on failure. 862 */ 863 struct typec_cable *typec_register_cable(struct typec_port *port, 864 struct typec_cable_desc *desc) 865 { 866 struct typec_cable *cable; 867 int ret; 868 869 cable = kzalloc(sizeof(*cable), GFP_KERNEL); 870 if (!cable) 871 return ERR_PTR(-ENOMEM); 872 873 cable->type = desc->type; 874 cable->active = desc->active; 875 876 if (desc->identity) { 877 /* 878 * Creating directory for the identity only if the driver is 879 * able to provide data to it. 880 */ 881 cable->dev.groups = usb_pd_id_groups; 882 cable->identity = desc->identity; 883 } 884 885 cable->dev.class = typec_class; 886 cable->dev.parent = &port->dev; 887 cable->dev.type = &typec_cable_dev_type; 888 dev_set_name(&cable->dev, "%s-cable", dev_name(&port->dev)); 889 890 ret = device_register(&cable->dev); 891 if (ret) { 892 dev_err(&port->dev, "failed to register cable (%d)\n", ret); 893 put_device(&cable->dev); 894 return ERR_PTR(ret); 895 } 896 897 return cable; 898 } 899 EXPORT_SYMBOL_GPL(typec_register_cable); 900 901 /** 902 * typec_unregister_cable - Unregister a USB Type-C Cable 903 * @cable: The cable to be unregistered 904 * 905 * Unregister device created with typec_register_cable(). 906 */ 907 void typec_unregister_cable(struct typec_cable *cable) 908 { 909 if (!IS_ERR_OR_NULL(cable)) 910 device_unregister(&cable->dev); 911 } 912 EXPORT_SYMBOL_GPL(typec_unregister_cable); 913 914 /* ------------------------------------------------------------------------- */ 915 /* USB Type-C ports */ 916 917 static const char * const typec_roles[] = { 918 [TYPEC_SINK] = "sink", 919 [TYPEC_SOURCE] = "source", 920 }; 921 922 static const char * const typec_data_roles[] = { 923 [TYPEC_DEVICE] = "device", 924 [TYPEC_HOST] = "host", 925 }; 926 927 static const char * const typec_port_power_roles[] = { 928 [TYPEC_PORT_SRC] = "source", 929 [TYPEC_PORT_SNK] = "sink", 930 [TYPEC_PORT_DRP] = "dual", 931 }; 932 933 static const char * const typec_port_data_roles[] = { 934 [TYPEC_PORT_DFP] = "host", 935 [TYPEC_PORT_UFP] = "device", 936 [TYPEC_PORT_DRD] = "dual", 937 }; 938 939 static const char * const typec_port_types_drp[] = { 940 [TYPEC_PORT_SRC] = "dual [source] sink", 941 [TYPEC_PORT_SNK] = "dual source [sink]", 942 [TYPEC_PORT_DRP] = "[dual] source sink", 943 }; 944 945 static ssize_t 946 preferred_role_store(struct device *dev, struct device_attribute *attr, 947 const char *buf, size_t size) 948 { 949 struct typec_port *port = to_typec_port(dev); 950 int role; 951 int ret; 952 953 if (port->cap->type != TYPEC_PORT_DRP) { 954 dev_dbg(dev, "Preferred role only supported with DRP ports\n"); 955 return -EOPNOTSUPP; 956 } 957 958 if (!port->cap->try_role) { 959 dev_dbg(dev, "Setting preferred role not supported\n"); 960 return -EOPNOTSUPP; 961 } 962 963 role = sysfs_match_string(typec_roles, buf); 964 if (role < 0) { 965 if (sysfs_streq(buf, "none")) 966 role = TYPEC_NO_PREFERRED_ROLE; 967 else 968 return -EINVAL; 969 } 970 971 ret = port->cap->try_role(port->cap, role); 972 if (ret) 973 return ret; 974 975 port->prefer_role = role; 976 return size; 977 } 978 979 static ssize_t 980 preferred_role_show(struct device *dev, struct device_attribute *attr, 981 char *buf) 982 { 983 struct typec_port *port = to_typec_port(dev); 984 985 if (port->cap->type != TYPEC_PORT_DRP) 986 return 0; 987 988 if (port->prefer_role < 0) 989 return 0; 990 991 return sprintf(buf, "%s\n", typec_roles[port->prefer_role]); 992 } 993 static DEVICE_ATTR_RW(preferred_role); 994 995 static ssize_t data_role_store(struct device *dev, 996 struct device_attribute *attr, 997 const char *buf, size_t size) 998 { 999 struct typec_port *port = to_typec_port(dev); 1000 int ret; 1001 1002 if (!port->cap->dr_set) { 1003 dev_dbg(dev, "data role swapping not supported\n"); 1004 return -EOPNOTSUPP; 1005 } 1006 1007 ret = sysfs_match_string(typec_data_roles, buf); 1008 if (ret < 0) 1009 return ret; 1010 1011 mutex_lock(&port->port_type_lock); 1012 if (port->cap->data != TYPEC_PORT_DRD) { 1013 ret = -EOPNOTSUPP; 1014 goto unlock_and_ret; 1015 } 1016 1017 ret = port->cap->dr_set(port->cap, ret); 1018 if (ret) 1019 goto unlock_and_ret; 1020 1021 ret = size; 1022 unlock_and_ret: 1023 mutex_unlock(&port->port_type_lock); 1024 return ret; 1025 } 1026 1027 static ssize_t data_role_show(struct device *dev, 1028 struct device_attribute *attr, char *buf) 1029 { 1030 struct typec_port *port = to_typec_port(dev); 1031 1032 if (port->cap->data == TYPEC_PORT_DRD) 1033 return sprintf(buf, "%s\n", port->data_role == TYPEC_HOST ? 1034 "[host] device" : "host [device]"); 1035 1036 return sprintf(buf, "[%s]\n", typec_data_roles[port->data_role]); 1037 } 1038 static DEVICE_ATTR_RW(data_role); 1039 1040 static ssize_t power_role_store(struct device *dev, 1041 struct device_attribute *attr, 1042 const char *buf, size_t size) 1043 { 1044 struct typec_port *port = to_typec_port(dev); 1045 int ret; 1046 1047 if (!port->cap->pd_revision) { 1048 dev_dbg(dev, "USB Power Delivery not supported\n"); 1049 return -EOPNOTSUPP; 1050 } 1051 1052 if (!port->cap->pr_set) { 1053 dev_dbg(dev, "power role swapping not supported\n"); 1054 return -EOPNOTSUPP; 1055 } 1056 1057 if (port->pwr_opmode != TYPEC_PWR_MODE_PD) { 1058 dev_dbg(dev, "partner unable to swap power role\n"); 1059 return -EIO; 1060 } 1061 1062 ret = sysfs_match_string(typec_roles, buf); 1063 if (ret < 0) 1064 return ret; 1065 1066 mutex_lock(&port->port_type_lock); 1067 if (port->port_type != TYPEC_PORT_DRP) { 1068 dev_dbg(dev, "port type fixed at \"%s\"", 1069 typec_port_power_roles[port->port_type]); 1070 ret = -EOPNOTSUPP; 1071 goto unlock_and_ret; 1072 } 1073 1074 ret = port->cap->pr_set(port->cap, ret); 1075 if (ret) 1076 goto unlock_and_ret; 1077 1078 ret = size; 1079 unlock_and_ret: 1080 mutex_unlock(&port->port_type_lock); 1081 return ret; 1082 } 1083 1084 static ssize_t power_role_show(struct device *dev, 1085 struct device_attribute *attr, char *buf) 1086 { 1087 struct typec_port *port = to_typec_port(dev); 1088 1089 if (port->cap->type == TYPEC_PORT_DRP) 1090 return sprintf(buf, "%s\n", port->pwr_role == TYPEC_SOURCE ? 1091 "[source] sink" : "source [sink]"); 1092 1093 return sprintf(buf, "[%s]\n", typec_roles[port->pwr_role]); 1094 } 1095 static DEVICE_ATTR_RW(power_role); 1096 1097 static ssize_t 1098 port_type_store(struct device *dev, struct device_attribute *attr, 1099 const char *buf, size_t size) 1100 { 1101 struct typec_port *port = to_typec_port(dev); 1102 int ret; 1103 enum typec_port_type type; 1104 1105 if (!port->cap->port_type_set || port->cap->type != TYPEC_PORT_DRP) { 1106 dev_dbg(dev, "changing port type not supported\n"); 1107 return -EOPNOTSUPP; 1108 } 1109 1110 ret = sysfs_match_string(typec_port_power_roles, buf); 1111 if (ret < 0) 1112 return ret; 1113 1114 type = ret; 1115 mutex_lock(&port->port_type_lock); 1116 1117 if (port->port_type == type) { 1118 ret = size; 1119 goto unlock_and_ret; 1120 } 1121 1122 ret = port->cap->port_type_set(port->cap, type); 1123 if (ret) 1124 goto unlock_and_ret; 1125 1126 port->port_type = type; 1127 ret = size; 1128 1129 unlock_and_ret: 1130 mutex_unlock(&port->port_type_lock); 1131 return ret; 1132 } 1133 1134 static ssize_t 1135 port_type_show(struct device *dev, struct device_attribute *attr, 1136 char *buf) 1137 { 1138 struct typec_port *port = to_typec_port(dev); 1139 1140 if (port->cap->type == TYPEC_PORT_DRP) 1141 return sprintf(buf, "%s\n", 1142 typec_port_types_drp[port->port_type]); 1143 1144 return sprintf(buf, "[%s]\n", typec_port_power_roles[port->cap->type]); 1145 } 1146 static DEVICE_ATTR_RW(port_type); 1147 1148 static const char * const typec_pwr_opmodes[] = { 1149 [TYPEC_PWR_MODE_USB] = "default", 1150 [TYPEC_PWR_MODE_1_5A] = "1.5A", 1151 [TYPEC_PWR_MODE_3_0A] = "3.0A", 1152 [TYPEC_PWR_MODE_PD] = "usb_power_delivery", 1153 }; 1154 1155 static ssize_t power_operation_mode_show(struct device *dev, 1156 struct device_attribute *attr, 1157 char *buf) 1158 { 1159 struct typec_port *port = to_typec_port(dev); 1160 1161 return sprintf(buf, "%s\n", typec_pwr_opmodes[port->pwr_opmode]); 1162 } 1163 static DEVICE_ATTR_RO(power_operation_mode); 1164 1165 static ssize_t vconn_source_store(struct device *dev, 1166 struct device_attribute *attr, 1167 const char *buf, size_t size) 1168 { 1169 struct typec_port *port = to_typec_port(dev); 1170 bool source; 1171 int ret; 1172 1173 if (!port->cap->pd_revision) { 1174 dev_dbg(dev, "VCONN swap depends on USB Power Delivery\n"); 1175 return -EOPNOTSUPP; 1176 } 1177 1178 if (!port->cap->vconn_set) { 1179 dev_dbg(dev, "VCONN swapping not supported\n"); 1180 return -EOPNOTSUPP; 1181 } 1182 1183 ret = kstrtobool(buf, &source); 1184 if (ret) 1185 return ret; 1186 1187 ret = port->cap->vconn_set(port->cap, (enum typec_role)source); 1188 if (ret) 1189 return ret; 1190 1191 return size; 1192 } 1193 1194 static ssize_t vconn_source_show(struct device *dev, 1195 struct device_attribute *attr, char *buf) 1196 { 1197 struct typec_port *port = to_typec_port(dev); 1198 1199 return sprintf(buf, "%s\n", 1200 port->vconn_role == TYPEC_SOURCE ? "yes" : "no"); 1201 } 1202 static DEVICE_ATTR_RW(vconn_source); 1203 1204 static ssize_t supported_accessory_modes_show(struct device *dev, 1205 struct device_attribute *attr, 1206 char *buf) 1207 { 1208 struct typec_port *port = to_typec_port(dev); 1209 ssize_t ret = 0; 1210 int i; 1211 1212 for (i = 0; i < ARRAY_SIZE(port->cap->accessory); i++) { 1213 if (port->cap->accessory[i]) 1214 ret += sprintf(buf + ret, "%s ", 1215 typec_accessory_modes[port->cap->accessory[i]]); 1216 } 1217 1218 if (!ret) 1219 return sprintf(buf, "none\n"); 1220 1221 buf[ret - 1] = '\n'; 1222 1223 return ret; 1224 } 1225 static DEVICE_ATTR_RO(supported_accessory_modes); 1226 1227 static ssize_t usb_typec_revision_show(struct device *dev, 1228 struct device_attribute *attr, 1229 char *buf) 1230 { 1231 struct typec_port *port = to_typec_port(dev); 1232 u16 rev = port->cap->revision; 1233 1234 return sprintf(buf, "%d.%d\n", (rev >> 8) & 0xff, (rev >> 4) & 0xf); 1235 } 1236 static DEVICE_ATTR_RO(usb_typec_revision); 1237 1238 static ssize_t usb_power_delivery_revision_show(struct device *dev, 1239 struct device_attribute *attr, 1240 char *buf) 1241 { 1242 struct typec_port *p = to_typec_port(dev); 1243 1244 return sprintf(buf, "%d\n", (p->cap->pd_revision >> 8) & 0xff); 1245 } 1246 static DEVICE_ATTR_RO(usb_power_delivery_revision); 1247 1248 static struct attribute *typec_attrs[] = { 1249 &dev_attr_data_role.attr, 1250 &dev_attr_power_operation_mode.attr, 1251 &dev_attr_power_role.attr, 1252 &dev_attr_preferred_role.attr, 1253 &dev_attr_supported_accessory_modes.attr, 1254 &dev_attr_usb_power_delivery_revision.attr, 1255 &dev_attr_usb_typec_revision.attr, 1256 &dev_attr_vconn_source.attr, 1257 &dev_attr_port_type.attr, 1258 NULL, 1259 }; 1260 ATTRIBUTE_GROUPS(typec); 1261 1262 static int typec_uevent(struct device *dev, struct kobj_uevent_env *env) 1263 { 1264 int ret; 1265 1266 ret = add_uevent_var(env, "TYPEC_PORT=%s", dev_name(dev)); 1267 if (ret) 1268 dev_err(dev, "failed to add uevent TYPEC_PORT\n"); 1269 1270 return ret; 1271 } 1272 1273 static void typec_release(struct device *dev) 1274 { 1275 struct typec_port *port = to_typec_port(dev); 1276 1277 ida_simple_remove(&typec_index_ida, port->id); 1278 ida_destroy(&port->mode_ids); 1279 typec_switch_put(port->sw); 1280 typec_mux_put(port->mux); 1281 kfree(port); 1282 } 1283 1284 const struct device_type typec_port_dev_type = { 1285 .name = "typec_port", 1286 .groups = typec_groups, 1287 .uevent = typec_uevent, 1288 .release = typec_release, 1289 }; 1290 1291 /* --------------------------------------- */ 1292 /* Driver callbacks to report role updates */ 1293 1294 /** 1295 * typec_set_data_role - Report data role change 1296 * @port: The USB Type-C Port where the role was changed 1297 * @role: The new data role 1298 * 1299 * This routine is used by the port drivers to report data role changes. 1300 */ 1301 void typec_set_data_role(struct typec_port *port, enum typec_data_role role) 1302 { 1303 if (port->data_role == role) 1304 return; 1305 1306 port->data_role = role; 1307 sysfs_notify(&port->dev.kobj, NULL, "data_role"); 1308 kobject_uevent(&port->dev.kobj, KOBJ_CHANGE); 1309 } 1310 EXPORT_SYMBOL_GPL(typec_set_data_role); 1311 1312 /** 1313 * typec_set_pwr_role - Report power role change 1314 * @port: The USB Type-C Port where the role was changed 1315 * @role: The new data role 1316 * 1317 * This routine is used by the port drivers to report power role changes. 1318 */ 1319 void typec_set_pwr_role(struct typec_port *port, enum typec_role role) 1320 { 1321 if (port->pwr_role == role) 1322 return; 1323 1324 port->pwr_role = role; 1325 sysfs_notify(&port->dev.kobj, NULL, "power_role"); 1326 kobject_uevent(&port->dev.kobj, KOBJ_CHANGE); 1327 } 1328 EXPORT_SYMBOL_GPL(typec_set_pwr_role); 1329 1330 /** 1331 * typec_set_vconn_role - Report VCONN source change 1332 * @port: The USB Type-C Port which VCONN role changed 1333 * @role: Source when @port is sourcing VCONN, or Sink when it's not 1334 * 1335 * This routine is used by the port drivers to report if the VCONN source is 1336 * changes. 1337 */ 1338 void typec_set_vconn_role(struct typec_port *port, enum typec_role role) 1339 { 1340 if (port->vconn_role == role) 1341 return; 1342 1343 port->vconn_role = role; 1344 sysfs_notify(&port->dev.kobj, NULL, "vconn_source"); 1345 kobject_uevent(&port->dev.kobj, KOBJ_CHANGE); 1346 } 1347 EXPORT_SYMBOL_GPL(typec_set_vconn_role); 1348 1349 static int partner_match(struct device *dev, void *data) 1350 { 1351 return is_typec_partner(dev); 1352 } 1353 1354 /** 1355 * typec_set_pwr_opmode - Report changed power operation mode 1356 * @port: The USB Type-C Port where the mode was changed 1357 * @opmode: New power operation mode 1358 * 1359 * This routine is used by the port drivers to report changed power operation 1360 * mode in @port. The modes are USB (default), 1.5A, 3.0A as defined in USB 1361 * Type-C specification, and "USB Power Delivery" when the power levels are 1362 * negotiated with methods defined in USB Power Delivery specification. 1363 */ 1364 void typec_set_pwr_opmode(struct typec_port *port, 1365 enum typec_pwr_opmode opmode) 1366 { 1367 struct device *partner_dev; 1368 1369 if (port->pwr_opmode == opmode) 1370 return; 1371 1372 port->pwr_opmode = opmode; 1373 sysfs_notify(&port->dev.kobj, NULL, "power_operation_mode"); 1374 kobject_uevent(&port->dev.kobj, KOBJ_CHANGE); 1375 1376 partner_dev = device_find_child(&port->dev, NULL, partner_match); 1377 if (partner_dev) { 1378 struct typec_partner *partner = to_typec_partner(partner_dev); 1379 1380 if (opmode == TYPEC_PWR_MODE_PD && !partner->usb_pd) { 1381 partner->usb_pd = 1; 1382 sysfs_notify(&partner_dev->kobj, NULL, 1383 "supports_usb_power_delivery"); 1384 } 1385 put_device(partner_dev); 1386 } 1387 } 1388 EXPORT_SYMBOL_GPL(typec_set_pwr_opmode); 1389 1390 /** 1391 * typec_find_port_power_role - Get the typec port power capability 1392 * @name: port power capability string 1393 * 1394 * This routine is used to find the typec_port_type by its string name. 1395 * 1396 * Returns typec_port_type if success, otherwise negative error code. 1397 */ 1398 int typec_find_port_power_role(const char *name) 1399 { 1400 return match_string(typec_port_power_roles, 1401 ARRAY_SIZE(typec_port_power_roles), name); 1402 } 1403 EXPORT_SYMBOL_GPL(typec_find_port_power_role); 1404 1405 /** 1406 * typec_find_power_role - Find the typec one specific power role 1407 * @name: power role string 1408 * 1409 * This routine is used to find the typec_role by its string name. 1410 * 1411 * Returns typec_role if success, otherwise negative error code. 1412 */ 1413 int typec_find_power_role(const char *name) 1414 { 1415 return match_string(typec_roles, ARRAY_SIZE(typec_roles), name); 1416 } 1417 EXPORT_SYMBOL_GPL(typec_find_power_role); 1418 1419 /** 1420 * typec_find_port_data_role - Get the typec port data capability 1421 * @name: port data capability string 1422 * 1423 * This routine is used to find the typec_port_data by its string name. 1424 * 1425 * Returns typec_port_data if success, otherwise negative error code. 1426 */ 1427 int typec_find_port_data_role(const char *name) 1428 { 1429 return match_string(typec_port_data_roles, 1430 ARRAY_SIZE(typec_port_data_roles), name); 1431 } 1432 EXPORT_SYMBOL_GPL(typec_find_port_data_role); 1433 1434 /* ------------------------------------------ */ 1435 /* API for Multiplexer/DeMultiplexer Switches */ 1436 1437 /** 1438 * typec_set_orientation - Set USB Type-C cable plug orientation 1439 * @port: USB Type-C Port 1440 * @orientation: USB Type-C cable plug orientation 1441 * 1442 * Set cable plug orientation for @port. 1443 */ 1444 int typec_set_orientation(struct typec_port *port, 1445 enum typec_orientation orientation) 1446 { 1447 int ret; 1448 1449 if (port->sw) { 1450 ret = port->sw->set(port->sw, orientation); 1451 if (ret) 1452 return ret; 1453 } 1454 1455 port->orientation = orientation; 1456 1457 return 0; 1458 } 1459 EXPORT_SYMBOL_GPL(typec_set_orientation); 1460 1461 /** 1462 * typec_get_orientation - Get USB Type-C cable plug orientation 1463 * @port: USB Type-C Port 1464 * 1465 * Get current cable plug orientation for @port. 1466 */ 1467 enum typec_orientation typec_get_orientation(struct typec_port *port) 1468 { 1469 return port->orientation; 1470 } 1471 EXPORT_SYMBOL_GPL(typec_get_orientation); 1472 1473 /** 1474 * typec_set_mode - Set mode of operation for USB Type-C connector 1475 * @port: USB Type-C connector 1476 * @mode: Accessory Mode, USB Operation or Safe State 1477 * 1478 * Configure @port for Accessory Mode @mode. This function will configure the 1479 * muxes needed for @mode. 1480 */ 1481 int typec_set_mode(struct typec_port *port, int mode) 1482 { 1483 return port->mux ? port->mux->set(port->mux, mode) : 0; 1484 } 1485 EXPORT_SYMBOL_GPL(typec_set_mode); 1486 1487 /* --------------------------------------- */ 1488 1489 /** 1490 * typec_port_register_altmode - Register USB Type-C Port Alternate Mode 1491 * @port: USB Type-C Port that supports the alternate mode 1492 * @desc: Description of the alternate mode 1493 * 1494 * This routine is used to register an alternate mode that @port is capable of 1495 * supporting. 1496 * 1497 * Returns handle to the alternate mode on success or ERR_PTR on failure. 1498 */ 1499 struct typec_altmode * 1500 typec_port_register_altmode(struct typec_port *port, 1501 const struct typec_altmode_desc *desc) 1502 { 1503 struct typec_altmode *adev; 1504 struct typec_mux *mux; 1505 1506 mux = typec_mux_get(&port->dev, desc); 1507 if (IS_ERR(mux)) 1508 return ERR_CAST(mux); 1509 1510 adev = typec_register_altmode(&port->dev, desc); 1511 if (IS_ERR(adev)) 1512 typec_mux_put(mux); 1513 else 1514 to_altmode(adev)->mux = mux; 1515 1516 return adev; 1517 } 1518 EXPORT_SYMBOL_GPL(typec_port_register_altmode); 1519 1520 /** 1521 * typec_register_port - Register a USB Type-C Port 1522 * @parent: Parent device 1523 * @cap: Description of the port 1524 * 1525 * Registers a device for USB Type-C Port described in @cap. 1526 * 1527 * Returns handle to the port on success or ERR_PTR on failure. 1528 */ 1529 struct typec_port *typec_register_port(struct device *parent, 1530 const struct typec_capability *cap) 1531 { 1532 struct typec_port *port; 1533 int ret; 1534 int id; 1535 1536 port = kzalloc(sizeof(*port), GFP_KERNEL); 1537 if (!port) 1538 return ERR_PTR(-ENOMEM); 1539 1540 id = ida_simple_get(&typec_index_ida, 0, 0, GFP_KERNEL); 1541 if (id < 0) { 1542 kfree(port); 1543 return ERR_PTR(id); 1544 } 1545 1546 switch (cap->type) { 1547 case TYPEC_PORT_SRC: 1548 port->pwr_role = TYPEC_SOURCE; 1549 port->vconn_role = TYPEC_SOURCE; 1550 break; 1551 case TYPEC_PORT_SNK: 1552 port->pwr_role = TYPEC_SINK; 1553 port->vconn_role = TYPEC_SINK; 1554 break; 1555 case TYPEC_PORT_DRP: 1556 if (cap->prefer_role != TYPEC_NO_PREFERRED_ROLE) 1557 port->pwr_role = cap->prefer_role; 1558 else 1559 port->pwr_role = TYPEC_SINK; 1560 break; 1561 } 1562 1563 switch (cap->data) { 1564 case TYPEC_PORT_DFP: 1565 port->data_role = TYPEC_HOST; 1566 break; 1567 case TYPEC_PORT_UFP: 1568 port->data_role = TYPEC_DEVICE; 1569 break; 1570 case TYPEC_PORT_DRD: 1571 if (cap->prefer_role == TYPEC_SOURCE) 1572 port->data_role = TYPEC_HOST; 1573 else 1574 port->data_role = TYPEC_DEVICE; 1575 break; 1576 } 1577 1578 ida_init(&port->mode_ids); 1579 mutex_init(&port->port_type_lock); 1580 1581 port->id = id; 1582 port->cap = cap; 1583 port->port_type = cap->type; 1584 port->prefer_role = cap->prefer_role; 1585 1586 device_initialize(&port->dev); 1587 port->dev.class = typec_class; 1588 port->dev.parent = parent; 1589 port->dev.fwnode = cap->fwnode; 1590 port->dev.type = &typec_port_dev_type; 1591 dev_set_name(&port->dev, "port%d", id); 1592 1593 port->sw = typec_switch_get(&port->dev); 1594 if (IS_ERR(port->sw)) { 1595 put_device(&port->dev); 1596 return ERR_CAST(port->sw); 1597 } 1598 1599 port->mux = typec_mux_get(&port->dev, NULL); 1600 if (IS_ERR(port->mux)) { 1601 put_device(&port->dev); 1602 return ERR_CAST(port->mux); 1603 } 1604 1605 ret = device_add(&port->dev); 1606 if (ret) { 1607 dev_err(parent, "failed to register port (%d)\n", ret); 1608 put_device(&port->dev); 1609 return ERR_PTR(ret); 1610 } 1611 1612 return port; 1613 } 1614 EXPORT_SYMBOL_GPL(typec_register_port); 1615 1616 /** 1617 * typec_unregister_port - Unregister a USB Type-C Port 1618 * @port: The port to be unregistered 1619 * 1620 * Unregister device created with typec_register_port(). 1621 */ 1622 void typec_unregister_port(struct typec_port *port) 1623 { 1624 if (!IS_ERR_OR_NULL(port)) 1625 device_unregister(&port->dev); 1626 } 1627 EXPORT_SYMBOL_GPL(typec_unregister_port); 1628 1629 static int __init typec_init(void) 1630 { 1631 int ret; 1632 1633 ret = bus_register(&typec_bus); 1634 if (ret) 1635 return ret; 1636 1637 ret = class_register(&typec_mux_class); 1638 if (ret) 1639 goto err_unregister_bus; 1640 1641 typec_class = class_create(THIS_MODULE, "typec"); 1642 if (IS_ERR(typec_class)) { 1643 ret = PTR_ERR(typec_class); 1644 goto err_unregister_mux_class; 1645 } 1646 1647 return 0; 1648 1649 err_unregister_mux_class: 1650 class_unregister(&typec_mux_class); 1651 1652 err_unregister_bus: 1653 bus_unregister(&typec_bus); 1654 1655 return ret; 1656 } 1657 subsys_initcall(typec_init); 1658 1659 static void __exit typec_exit(void) 1660 { 1661 class_destroy(typec_class); 1662 ida_destroy(&typec_index_ida); 1663 bus_unregister(&typec_bus); 1664 class_unregister(&typec_mux_class); 1665 } 1666 module_exit(typec_exit); 1667 1668 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); 1669 MODULE_LICENSE("GPL v2"); 1670 MODULE_DESCRIPTION("USB Type-C Connector Class"); 1671