1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * USB Type-C Connector System Software Interface driver 4 * 5 * Copyright (C) 2017, Intel Corporation 6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 7 */ 8 9 #include <linux/completion.h> 10 #include <linux/property.h> 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/delay.h> 14 #include <linux/slab.h> 15 #include <linux/usb/typec_dp.h> 16 17 #include "ucsi.h" 18 #include "trace.h" 19 20 /* 21 * UCSI_TIMEOUT_MS - PPM communication timeout 22 * 23 * Ideally we could use MIN_TIME_TO_RESPOND_WITH_BUSY (which is defined in UCSI 24 * specification) here as reference, but unfortunately we can't. It is very 25 * difficult to estimate the time it takes for the system to process the command 26 * before it is actually passed to the PPM. 27 */ 28 #define UCSI_TIMEOUT_MS 5000 29 30 /* 31 * UCSI_SWAP_TIMEOUT_MS - Timeout for role swap requests 32 * 33 * 5 seconds is close to the time it takes for CapsCounter to reach 0, so even 34 * if the PPM does not generate Connector Change events before that with 35 * partners that do not support USB Power Delivery, this should still work. 36 */ 37 #define UCSI_SWAP_TIMEOUT_MS 5000 38 39 static int ucsi_acknowledge_command(struct ucsi *ucsi) 40 { 41 u64 ctrl; 42 43 ctrl = UCSI_ACK_CC_CI; 44 ctrl |= UCSI_ACK_COMMAND_COMPLETE; 45 46 return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl)); 47 } 48 49 static int ucsi_acknowledge_connector_change(struct ucsi *ucsi) 50 { 51 u64 ctrl; 52 53 ctrl = UCSI_ACK_CC_CI; 54 ctrl |= UCSI_ACK_CONNECTOR_CHANGE; 55 56 return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl)); 57 } 58 59 static int ucsi_exec_command(struct ucsi *ucsi, u64 command); 60 61 static int ucsi_read_error(struct ucsi *ucsi) 62 { 63 u16 error; 64 int ret; 65 66 /* Acknowledge the command that failed */ 67 ret = ucsi_acknowledge_command(ucsi); 68 if (ret) 69 return ret; 70 71 ret = ucsi_exec_command(ucsi, UCSI_GET_ERROR_STATUS); 72 if (ret < 0) 73 return ret; 74 75 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, &error, sizeof(error)); 76 if (ret) 77 return ret; 78 79 switch (error) { 80 case UCSI_ERROR_INCOMPATIBLE_PARTNER: 81 return -EOPNOTSUPP; 82 case UCSI_ERROR_CC_COMMUNICATION_ERR: 83 return -ECOMM; 84 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL: 85 return -EPROTO; 86 case UCSI_ERROR_DEAD_BATTERY: 87 dev_warn(ucsi->dev, "Dead battery condition!\n"); 88 return -EPERM; 89 case UCSI_ERROR_INVALID_CON_NUM: 90 case UCSI_ERROR_UNREGONIZED_CMD: 91 case UCSI_ERROR_INVALID_CMD_ARGUMENT: 92 dev_err(ucsi->dev, "possible UCSI driver bug %u\n", error); 93 return -EINVAL; 94 case UCSI_ERROR_OVERCURRENT: 95 dev_warn(ucsi->dev, "Overcurrent condition\n"); 96 break; 97 case UCSI_ERROR_PARTNER_REJECTED_SWAP: 98 dev_warn(ucsi->dev, "Partner rejected swap\n"); 99 break; 100 case UCSI_ERROR_HARD_RESET: 101 dev_warn(ucsi->dev, "Hard reset occurred\n"); 102 break; 103 case UCSI_ERROR_PPM_POLICY_CONFLICT: 104 dev_warn(ucsi->dev, "PPM Policy conflict\n"); 105 break; 106 case UCSI_ERROR_SWAP_REJECTED: 107 dev_warn(ucsi->dev, "Swap rejected\n"); 108 break; 109 case UCSI_ERROR_UNDEFINED: 110 default: 111 dev_err(ucsi->dev, "unknown error %u\n", error); 112 break; 113 } 114 115 return -EIO; 116 } 117 118 static int ucsi_exec_command(struct ucsi *ucsi, u64 cmd) 119 { 120 u32 cci; 121 int ret; 122 123 ret = ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd)); 124 if (ret) 125 return ret; 126 127 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci)); 128 if (ret) 129 return ret; 130 131 if (cci & UCSI_CCI_BUSY) { 132 ucsi->ops->async_write(ucsi, UCSI_CANCEL, NULL, 0); 133 return -EBUSY; 134 } 135 136 if (!(cci & UCSI_CCI_COMMAND_COMPLETE)) 137 return -EIO; 138 139 if (cci & UCSI_CCI_NOT_SUPPORTED) 140 return -EOPNOTSUPP; 141 142 if (cci & UCSI_CCI_ERROR) { 143 if (cmd == UCSI_GET_ERROR_STATUS) 144 return -EIO; 145 return ucsi_read_error(ucsi); 146 } 147 148 return UCSI_CCI_LENGTH(cci); 149 } 150 151 int ucsi_send_command(struct ucsi *ucsi, u64 command, 152 void *data, size_t size) 153 { 154 u8 length; 155 int ret; 156 157 mutex_lock(&ucsi->ppm_lock); 158 159 ret = ucsi_exec_command(ucsi, command); 160 if (ret < 0) 161 goto out; 162 163 length = ret; 164 165 if (data) { 166 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, data, size); 167 if (ret) 168 goto out; 169 } 170 171 ret = ucsi_acknowledge_command(ucsi); 172 if (ret) 173 goto out; 174 175 ret = length; 176 out: 177 mutex_unlock(&ucsi->ppm_lock); 178 return ret; 179 } 180 EXPORT_SYMBOL_GPL(ucsi_send_command); 181 182 int ucsi_resume(struct ucsi *ucsi) 183 { 184 u64 command; 185 186 /* Restore UCSI notification enable mask after system resume */ 187 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy; 188 189 return ucsi_send_command(ucsi, command, NULL, 0); 190 } 191 EXPORT_SYMBOL_GPL(ucsi_resume); 192 /* -------------------------------------------------------------------------- */ 193 194 struct ucsi_work { 195 struct delayed_work work; 196 unsigned long delay; 197 unsigned int count; 198 struct ucsi_connector *con; 199 int (*cb)(struct ucsi_connector *); 200 }; 201 202 static void ucsi_poll_worker(struct work_struct *work) 203 { 204 struct ucsi_work *uwork = container_of(work, struct ucsi_work, work.work); 205 struct ucsi_connector *con = uwork->con; 206 int ret; 207 208 mutex_lock(&con->lock); 209 210 if (!con->partner) { 211 mutex_unlock(&con->lock); 212 kfree(uwork); 213 return; 214 } 215 216 ret = uwork->cb(con); 217 218 if (uwork->count-- && (ret == -EBUSY || ret == -ETIMEDOUT)) 219 queue_delayed_work(con->wq, &uwork->work, uwork->delay); 220 else 221 kfree(uwork); 222 223 mutex_unlock(&con->lock); 224 } 225 226 static int ucsi_partner_task(struct ucsi_connector *con, 227 int (*cb)(struct ucsi_connector *), 228 int retries, unsigned long delay) 229 { 230 struct ucsi_work *uwork; 231 232 if (!con->partner) 233 return 0; 234 235 uwork = kzalloc(sizeof(*uwork), GFP_KERNEL); 236 if (!uwork) 237 return -ENOMEM; 238 239 INIT_DELAYED_WORK(&uwork->work, ucsi_poll_worker); 240 uwork->count = retries; 241 uwork->delay = delay; 242 uwork->con = con; 243 uwork->cb = cb; 244 245 queue_delayed_work(con->wq, &uwork->work, delay); 246 247 return 0; 248 } 249 250 /* -------------------------------------------------------------------------- */ 251 252 void ucsi_altmode_update_active(struct ucsi_connector *con) 253 { 254 const struct typec_altmode *altmode = NULL; 255 u64 command; 256 int ret; 257 u8 cur; 258 int i; 259 260 command = UCSI_GET_CURRENT_CAM | UCSI_CONNECTOR_NUMBER(con->num); 261 ret = ucsi_send_command(con->ucsi, command, &cur, sizeof(cur)); 262 if (ret < 0) { 263 if (con->ucsi->version > 0x0100) { 264 dev_err(con->ucsi->dev, 265 "GET_CURRENT_CAM command failed\n"); 266 return; 267 } 268 cur = 0xff; 269 } 270 271 if (cur < UCSI_MAX_ALTMODES) 272 altmode = typec_altmode_get_partner(con->port_altmode[cur]); 273 274 for (i = 0; con->partner_altmode[i]; i++) 275 typec_altmode_update_active(con->partner_altmode[i], 276 con->partner_altmode[i] == altmode); 277 } 278 279 static int ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid) 280 { 281 u8 mode = 1; 282 int i; 283 284 for (i = 0; alt[i]; i++) { 285 if (i > MODE_DISCOVERY_MAX) 286 return -ERANGE; 287 288 if (alt[i]->svid == svid) 289 mode++; 290 } 291 292 return mode; 293 } 294 295 static int ucsi_next_altmode(struct typec_altmode **alt) 296 { 297 int i = 0; 298 299 for (i = 0; i < UCSI_MAX_ALTMODES; i++) 300 if (!alt[i]) 301 return i; 302 303 return -ENOENT; 304 } 305 306 static int ucsi_register_altmode(struct ucsi_connector *con, 307 struct typec_altmode_desc *desc, 308 u8 recipient) 309 { 310 struct typec_altmode *alt; 311 bool override; 312 int ret; 313 int i; 314 315 override = !!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_OVERRIDE); 316 317 switch (recipient) { 318 case UCSI_RECIPIENT_CON: 319 i = ucsi_next_altmode(con->port_altmode); 320 if (i < 0) { 321 ret = i; 322 goto err; 323 } 324 325 ret = ucsi_altmode_next_mode(con->port_altmode, desc->svid); 326 if (ret < 0) 327 return ret; 328 329 desc->mode = ret; 330 331 switch (desc->svid) { 332 case USB_TYPEC_DP_SID: 333 alt = ucsi_register_displayport(con, override, i, desc); 334 break; 335 case USB_TYPEC_NVIDIA_VLINK_SID: 336 if (desc->vdo == USB_TYPEC_NVIDIA_VLINK_DBG_VDO) 337 alt = typec_port_register_altmode(con->port, 338 desc); 339 else 340 alt = ucsi_register_displayport(con, override, 341 i, desc); 342 break; 343 default: 344 alt = typec_port_register_altmode(con->port, desc); 345 break; 346 } 347 348 if (IS_ERR(alt)) { 349 ret = PTR_ERR(alt); 350 goto err; 351 } 352 353 con->port_altmode[i] = alt; 354 break; 355 case UCSI_RECIPIENT_SOP: 356 i = ucsi_next_altmode(con->partner_altmode); 357 if (i < 0) { 358 ret = i; 359 goto err; 360 } 361 362 ret = ucsi_altmode_next_mode(con->partner_altmode, desc->svid); 363 if (ret < 0) 364 return ret; 365 366 desc->mode = ret; 367 368 alt = typec_partner_register_altmode(con->partner, desc); 369 if (IS_ERR(alt)) { 370 ret = PTR_ERR(alt); 371 goto err; 372 } 373 374 con->partner_altmode[i] = alt; 375 break; 376 default: 377 return -EINVAL; 378 } 379 380 trace_ucsi_register_altmode(recipient, alt); 381 382 return 0; 383 384 err: 385 dev_err(con->ucsi->dev, "failed to registers svid 0x%04x mode %d\n", 386 desc->svid, desc->mode); 387 388 return ret; 389 } 390 391 static int 392 ucsi_register_altmodes_nvidia(struct ucsi_connector *con, u8 recipient) 393 { 394 int max_altmodes = UCSI_MAX_ALTMODES; 395 struct typec_altmode_desc desc; 396 struct ucsi_altmode alt; 397 struct ucsi_altmode orig[UCSI_MAX_ALTMODES]; 398 struct ucsi_altmode updated[UCSI_MAX_ALTMODES]; 399 struct ucsi *ucsi = con->ucsi; 400 bool multi_dp = false; 401 u64 command; 402 int ret; 403 int len; 404 int i; 405 int k = 0; 406 407 if (recipient == UCSI_RECIPIENT_CON) 408 max_altmodes = con->ucsi->cap.num_alt_modes; 409 410 memset(orig, 0, sizeof(orig)); 411 memset(updated, 0, sizeof(updated)); 412 413 /* First get all the alternate modes */ 414 for (i = 0; i < max_altmodes; i++) { 415 memset(&alt, 0, sizeof(alt)); 416 command = UCSI_GET_ALTERNATE_MODES; 417 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient); 418 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num); 419 command |= UCSI_GET_ALTMODE_OFFSET(i); 420 len = ucsi_send_command(con->ucsi, command, &alt, sizeof(alt)); 421 /* 422 * We are collecting all altmodes first and then registering. 423 * Some type-C device will return zero length data beyond last 424 * alternate modes. We should not return if length is zero. 425 */ 426 if (len < 0) 427 return len; 428 429 /* We got all altmodes, now break out and register them */ 430 if (!len || !alt.svid) 431 break; 432 433 orig[k].mid = alt.mid; 434 orig[k].svid = alt.svid; 435 k++; 436 } 437 /* 438 * Update the original altmode table as some ppms may report 439 * multiple DP altmodes. 440 */ 441 if (recipient == UCSI_RECIPIENT_CON) 442 multi_dp = ucsi->ops->update_altmodes(ucsi, orig, updated); 443 444 /* now register altmodes */ 445 for (i = 0; i < max_altmodes; i++) { 446 memset(&desc, 0, sizeof(desc)); 447 if (multi_dp && recipient == UCSI_RECIPIENT_CON) { 448 desc.svid = updated[i].svid; 449 desc.vdo = updated[i].mid; 450 } else { 451 desc.svid = orig[i].svid; 452 desc.vdo = orig[i].mid; 453 } 454 desc.roles = TYPEC_PORT_DRD; 455 456 if (!desc.svid) 457 return 0; 458 459 ret = ucsi_register_altmode(con, &desc, recipient); 460 if (ret) 461 return ret; 462 } 463 464 return 0; 465 } 466 467 static int ucsi_register_altmodes(struct ucsi_connector *con, u8 recipient) 468 { 469 int max_altmodes = UCSI_MAX_ALTMODES; 470 struct typec_altmode_desc desc; 471 struct ucsi_altmode alt[2]; 472 u64 command; 473 int num; 474 int ret; 475 int len; 476 int j; 477 int i; 478 479 if (!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS)) 480 return 0; 481 482 if (recipient == UCSI_RECIPIENT_SOP && con->partner_altmode[0]) 483 return 0; 484 485 if (con->ucsi->ops->update_altmodes) 486 return ucsi_register_altmodes_nvidia(con, recipient); 487 488 if (recipient == UCSI_RECIPIENT_CON) 489 max_altmodes = con->ucsi->cap.num_alt_modes; 490 491 for (i = 0; i < max_altmodes;) { 492 memset(alt, 0, sizeof(alt)); 493 command = UCSI_GET_ALTERNATE_MODES; 494 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient); 495 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num); 496 command |= UCSI_GET_ALTMODE_OFFSET(i); 497 len = ucsi_send_command(con->ucsi, command, alt, sizeof(alt)); 498 if (len == -EBUSY) 499 continue; 500 if (len <= 0) 501 return len; 502 503 /* 504 * This code is requesting one alt mode at a time, but some PPMs 505 * may still return two. If that happens both alt modes need be 506 * registered and the offset for the next alt mode has to be 507 * incremented. 508 */ 509 num = len / sizeof(alt[0]); 510 i += num; 511 512 for (j = 0; j < num; j++) { 513 if (!alt[j].svid) 514 return 0; 515 516 memset(&desc, 0, sizeof(desc)); 517 desc.vdo = alt[j].mid; 518 desc.svid = alt[j].svid; 519 desc.roles = TYPEC_PORT_DRD; 520 521 ret = ucsi_register_altmode(con, &desc, recipient); 522 if (ret) 523 return ret; 524 } 525 } 526 527 return 0; 528 } 529 530 static void ucsi_unregister_altmodes(struct ucsi_connector *con, u8 recipient) 531 { 532 const struct typec_altmode *pdev; 533 struct typec_altmode **adev; 534 int i = 0; 535 536 switch (recipient) { 537 case UCSI_RECIPIENT_CON: 538 adev = con->port_altmode; 539 break; 540 case UCSI_RECIPIENT_SOP: 541 adev = con->partner_altmode; 542 break; 543 default: 544 return; 545 } 546 547 while (adev[i]) { 548 if (recipient == UCSI_RECIPIENT_SOP && 549 (adev[i]->svid == USB_TYPEC_DP_SID || 550 (adev[i]->svid == USB_TYPEC_NVIDIA_VLINK_SID && 551 adev[i]->vdo != USB_TYPEC_NVIDIA_VLINK_DBG_VDO))) { 552 pdev = typec_altmode_get_partner(adev[i]); 553 ucsi_displayport_remove_partner((void *)pdev); 554 } 555 typec_unregister_altmode(adev[i]); 556 adev[i++] = NULL; 557 } 558 } 559 560 static int ucsi_get_pdos(struct ucsi_connector *con, int is_partner, 561 u32 *pdos, int offset, int num_pdos) 562 { 563 struct ucsi *ucsi = con->ucsi; 564 u64 command; 565 int ret; 566 567 command = UCSI_COMMAND(UCSI_GET_PDOS) | UCSI_CONNECTOR_NUMBER(con->num); 568 command |= UCSI_GET_PDOS_PARTNER_PDO(is_partner); 569 command |= UCSI_GET_PDOS_PDO_OFFSET(offset); 570 command |= UCSI_GET_PDOS_NUM_PDOS(num_pdos - 1); 571 command |= UCSI_GET_PDOS_SRC_PDOS; 572 ret = ucsi_send_command(ucsi, command, pdos + offset, 573 num_pdos * sizeof(u32)); 574 if (ret < 0 && ret != -ETIMEDOUT) 575 dev_err(ucsi->dev, "UCSI_GET_PDOS failed (%d)\n", ret); 576 if (ret == 0 && offset == 0) 577 dev_warn(ucsi->dev, "UCSI_GET_PDOS returned 0 bytes\n"); 578 579 return ret; 580 } 581 582 static int ucsi_get_src_pdos(struct ucsi_connector *con) 583 { 584 int ret; 585 586 /* UCSI max payload means only getting at most 4 PDOs at a time */ 587 ret = ucsi_get_pdos(con, 1, con->src_pdos, 0, UCSI_MAX_PDOS); 588 if (ret < 0) 589 return ret; 590 591 con->num_pdos = ret / sizeof(u32); /* number of bytes to 32-bit PDOs */ 592 if (con->num_pdos < UCSI_MAX_PDOS) 593 return 0; 594 595 /* get the remaining PDOs, if any */ 596 ret = ucsi_get_pdos(con, 1, con->src_pdos, UCSI_MAX_PDOS, 597 PDO_MAX_OBJECTS - UCSI_MAX_PDOS); 598 if (ret < 0) 599 return ret; 600 601 con->num_pdos += ret / sizeof(u32); 602 603 ucsi_port_psy_changed(con); 604 605 return 0; 606 } 607 608 static int ucsi_check_altmodes(struct ucsi_connector *con) 609 { 610 int ret; 611 612 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP); 613 if (ret && ret != -ETIMEDOUT) 614 dev_err(con->ucsi->dev, 615 "con%d: failed to register partner alt modes (%d)\n", 616 con->num, ret); 617 618 /* Ignoring the errors in this case. */ 619 if (con->partner_altmode[0]) { 620 ucsi_altmode_update_active(con); 621 return 0; 622 } 623 624 return ret; 625 } 626 627 static void ucsi_pwr_opmode_change(struct ucsi_connector *con) 628 { 629 switch (UCSI_CONSTAT_PWR_OPMODE(con->status.flags)) { 630 case UCSI_CONSTAT_PWR_OPMODE_PD: 631 con->rdo = con->status.request_data_obj; 632 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD); 633 ucsi_partner_task(con, ucsi_get_src_pdos, 30, 0); 634 ucsi_partner_task(con, ucsi_check_altmodes, 30, 0); 635 break; 636 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5: 637 con->rdo = 0; 638 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A); 639 break; 640 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0: 641 con->rdo = 0; 642 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A); 643 break; 644 default: 645 con->rdo = 0; 646 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB); 647 break; 648 } 649 } 650 651 static int ucsi_register_partner(struct ucsi_connector *con) 652 { 653 u8 pwr_opmode = UCSI_CONSTAT_PWR_OPMODE(con->status.flags); 654 struct typec_partner_desc desc; 655 struct typec_partner *partner; 656 657 if (con->partner) 658 return 0; 659 660 memset(&desc, 0, sizeof(desc)); 661 662 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) { 663 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG: 664 desc.accessory = TYPEC_ACCESSORY_DEBUG; 665 break; 666 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO: 667 desc.accessory = TYPEC_ACCESSORY_AUDIO; 668 break; 669 default: 670 break; 671 } 672 673 desc.usb_pd = pwr_opmode == UCSI_CONSTAT_PWR_OPMODE_PD; 674 675 partner = typec_register_partner(con->port, &desc); 676 if (IS_ERR(partner)) { 677 dev_err(con->ucsi->dev, 678 "con%d: failed to register partner (%ld)\n", con->num, 679 PTR_ERR(partner)); 680 return PTR_ERR(partner); 681 } 682 683 con->partner = partner; 684 685 return 0; 686 } 687 688 static void ucsi_unregister_partner(struct ucsi_connector *con) 689 { 690 if (!con->partner) 691 return; 692 693 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP); 694 typec_unregister_partner(con->partner); 695 con->partner = NULL; 696 } 697 698 static void ucsi_partner_change(struct ucsi_connector *con) 699 { 700 enum usb_role u_role = USB_ROLE_NONE; 701 int ret; 702 703 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) { 704 case UCSI_CONSTAT_PARTNER_TYPE_UFP: 705 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP: 706 u_role = USB_ROLE_HOST; 707 fallthrough; 708 case UCSI_CONSTAT_PARTNER_TYPE_CABLE: 709 typec_set_data_role(con->port, TYPEC_HOST); 710 break; 711 case UCSI_CONSTAT_PARTNER_TYPE_DFP: 712 u_role = USB_ROLE_DEVICE; 713 typec_set_data_role(con->port, TYPEC_DEVICE); 714 break; 715 default: 716 break; 717 } 718 719 /* Only notify USB controller if partner supports USB data */ 720 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB)) 721 u_role = USB_ROLE_NONE; 722 723 ret = usb_role_switch_set_role(con->usb_role_sw, u_role); 724 if (ret) 725 dev_err(con->ucsi->dev, "con:%d: failed to set usb role:%d\n", 726 con->num, u_role); 727 } 728 729 static int ucsi_check_connection(struct ucsi_connector *con) 730 { 731 u64 command; 732 int ret; 733 734 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num); 735 ret = ucsi_send_command(con->ucsi, command, &con->status, sizeof(con->status)); 736 if (ret < 0) { 737 dev_err(con->ucsi->dev, "GET_CONNECTOR_STATUS failed (%d)\n", ret); 738 return ret; 739 } 740 741 if (con->status.flags & UCSI_CONSTAT_CONNECTED) { 742 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) == 743 UCSI_CONSTAT_PWR_OPMODE_PD) 744 ucsi_partner_task(con, ucsi_check_altmodes, 30, 0); 745 } else { 746 ucsi_partner_change(con); 747 ucsi_port_psy_changed(con); 748 ucsi_unregister_partner(con); 749 } 750 751 return 0; 752 } 753 754 static void ucsi_handle_connector_change(struct work_struct *work) 755 { 756 struct ucsi_connector *con = container_of(work, struct ucsi_connector, 757 work); 758 struct ucsi *ucsi = con->ucsi; 759 enum typec_role role; 760 u64 command; 761 int ret; 762 763 mutex_lock(&con->lock); 764 765 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num); 766 ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status)); 767 if (ret < 0) { 768 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n", 769 __func__, ret); 770 goto out_unlock; 771 } 772 773 trace_ucsi_connector_change(con->num, &con->status); 774 775 role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR); 776 777 if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) { 778 typec_set_pwr_role(con->port, role); 779 780 /* Complete pending power role swap */ 781 if (!completion_done(&con->complete)) 782 complete(&con->complete); 783 } 784 785 if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) { 786 typec_set_pwr_role(con->port, role); 787 ucsi_port_psy_changed(con); 788 ucsi_partner_change(con); 789 790 if (con->status.flags & UCSI_CONSTAT_CONNECTED) { 791 ucsi_register_partner(con); 792 ucsi_partner_task(con, ucsi_check_connection, 1, HZ); 793 } else { 794 ucsi_unregister_partner(con); 795 } 796 } 797 798 if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE || 799 con->status.change & UCSI_CONSTAT_POWER_LEVEL_CHANGE) 800 ucsi_pwr_opmode_change(con); 801 802 if (con->partner && con->status.change & UCSI_CONSTAT_PARTNER_CHANGE) { 803 ucsi_partner_change(con); 804 805 /* Complete pending data role swap */ 806 if (!completion_done(&con->complete)) 807 complete(&con->complete); 808 } 809 810 if (con->status.change & UCSI_CONSTAT_CAM_CHANGE) 811 ucsi_partner_task(con, ucsi_check_altmodes, 1, 0); 812 813 clear_bit(EVENT_PENDING, &con->ucsi->flags); 814 815 ret = ucsi_acknowledge_connector_change(ucsi); 816 if (ret) 817 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret); 818 819 out_unlock: 820 mutex_unlock(&con->lock); 821 } 822 823 /** 824 * ucsi_connector_change - Process Connector Change Event 825 * @ucsi: UCSI Interface 826 * @num: Connector number 827 */ 828 void ucsi_connector_change(struct ucsi *ucsi, u8 num) 829 { 830 struct ucsi_connector *con = &ucsi->connector[num - 1]; 831 832 if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) { 833 dev_dbg(ucsi->dev, "Bogus connector change event\n"); 834 return; 835 } 836 837 if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags)) 838 schedule_work(&con->work); 839 } 840 EXPORT_SYMBOL_GPL(ucsi_connector_change); 841 842 /* -------------------------------------------------------------------------- */ 843 844 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard) 845 { 846 u64 command; 847 848 command = UCSI_CONNECTOR_RESET | UCSI_CONNECTOR_NUMBER(con->num); 849 command |= hard ? UCSI_CONNECTOR_RESET_HARD : 0; 850 851 return ucsi_send_command(con->ucsi, command, NULL, 0); 852 } 853 854 static int ucsi_reset_ppm(struct ucsi *ucsi) 855 { 856 u64 command = UCSI_PPM_RESET; 857 unsigned long tmo; 858 u32 cci; 859 int ret; 860 861 mutex_lock(&ucsi->ppm_lock); 862 863 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command, 864 sizeof(command)); 865 if (ret < 0) 866 goto out; 867 868 tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS); 869 870 do { 871 if (time_is_before_jiffies(tmo)) { 872 ret = -ETIMEDOUT; 873 goto out; 874 } 875 876 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci)); 877 if (ret) 878 goto out; 879 880 /* If the PPM is still doing something else, reset it again. */ 881 if (cci & ~UCSI_CCI_RESET_COMPLETE) { 882 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, 883 &command, 884 sizeof(command)); 885 if (ret < 0) 886 goto out; 887 } 888 889 msleep(20); 890 } while (!(cci & UCSI_CCI_RESET_COMPLETE)); 891 892 out: 893 mutex_unlock(&ucsi->ppm_lock); 894 return ret; 895 } 896 897 static int ucsi_role_cmd(struct ucsi_connector *con, u64 command) 898 { 899 int ret; 900 901 ret = ucsi_send_command(con->ucsi, command, NULL, 0); 902 if (ret == -ETIMEDOUT) { 903 u64 c; 904 905 /* PPM most likely stopped responding. Resetting everything. */ 906 ucsi_reset_ppm(con->ucsi); 907 908 c = UCSI_SET_NOTIFICATION_ENABLE | con->ucsi->ntfy; 909 ucsi_send_command(con->ucsi, c, NULL, 0); 910 911 ucsi_reset_connector(con, true); 912 } 913 914 return ret; 915 } 916 917 static int ucsi_dr_swap(struct typec_port *port, enum typec_data_role role) 918 { 919 struct ucsi_connector *con = typec_get_drvdata(port); 920 u8 partner_type; 921 u64 command; 922 int ret = 0; 923 924 mutex_lock(&con->lock); 925 926 if (!con->partner) { 927 ret = -ENOTCONN; 928 goto out_unlock; 929 } 930 931 partner_type = UCSI_CONSTAT_PARTNER_TYPE(con->status.flags); 932 if ((partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP && 933 role == TYPEC_DEVICE) || 934 (partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP && 935 role == TYPEC_HOST)) 936 goto out_unlock; 937 938 command = UCSI_SET_UOR | UCSI_CONNECTOR_NUMBER(con->num); 939 command |= UCSI_SET_UOR_ROLE(role); 940 command |= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS; 941 ret = ucsi_role_cmd(con, command); 942 if (ret < 0) 943 goto out_unlock; 944 945 if (!wait_for_completion_timeout(&con->complete, 946 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) 947 ret = -ETIMEDOUT; 948 949 out_unlock: 950 mutex_unlock(&con->lock); 951 952 return ret < 0 ? ret : 0; 953 } 954 955 static int ucsi_pr_swap(struct typec_port *port, enum typec_role role) 956 { 957 struct ucsi_connector *con = typec_get_drvdata(port); 958 enum typec_role cur_role; 959 u64 command; 960 int ret = 0; 961 962 mutex_lock(&con->lock); 963 964 if (!con->partner) { 965 ret = -ENOTCONN; 966 goto out_unlock; 967 } 968 969 cur_role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR); 970 971 if (cur_role == role) 972 goto out_unlock; 973 974 command = UCSI_SET_PDR | UCSI_CONNECTOR_NUMBER(con->num); 975 command |= UCSI_SET_PDR_ROLE(role); 976 command |= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS; 977 ret = ucsi_role_cmd(con, command); 978 if (ret < 0) 979 goto out_unlock; 980 981 if (!wait_for_completion_timeout(&con->complete, 982 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) { 983 ret = -ETIMEDOUT; 984 goto out_unlock; 985 } 986 987 /* Something has gone wrong while swapping the role */ 988 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) != 989 UCSI_CONSTAT_PWR_OPMODE_PD) { 990 ucsi_reset_connector(con, true); 991 ret = -EPROTO; 992 } 993 994 out_unlock: 995 mutex_unlock(&con->lock); 996 997 return ret; 998 } 999 1000 static const struct typec_operations ucsi_ops = { 1001 .dr_set = ucsi_dr_swap, 1002 .pr_set = ucsi_pr_swap 1003 }; 1004 1005 /* Caller must call fwnode_handle_put() after use */ 1006 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con) 1007 { 1008 struct fwnode_handle *fwnode; 1009 int i = 1; 1010 1011 device_for_each_child_node(con->ucsi->dev, fwnode) 1012 if (i++ == con->num) 1013 return fwnode; 1014 return NULL; 1015 } 1016 1017 static int ucsi_register_port(struct ucsi *ucsi, int index) 1018 { 1019 struct ucsi_connector *con = &ucsi->connector[index]; 1020 struct typec_capability *cap = &con->typec_cap; 1021 enum typec_accessory *accessory = cap->accessory; 1022 enum usb_role u_role = USB_ROLE_NONE; 1023 u64 command; 1024 char *name; 1025 int ret; 1026 1027 name = kasprintf(GFP_KERNEL, "%s-con%d", dev_name(ucsi->dev), con->num); 1028 if (!name) 1029 return -ENOMEM; 1030 1031 con->wq = create_singlethread_workqueue(name); 1032 kfree(name); 1033 if (!con->wq) 1034 return -ENOMEM; 1035 1036 INIT_WORK(&con->work, ucsi_handle_connector_change); 1037 init_completion(&con->complete); 1038 mutex_init(&con->lock); 1039 con->num = index + 1; 1040 con->ucsi = ucsi; 1041 1042 /* Delay other interactions with the con until registration is complete */ 1043 mutex_lock(&con->lock); 1044 1045 /* Get connector capability */ 1046 command = UCSI_GET_CONNECTOR_CAPABILITY; 1047 command |= UCSI_CONNECTOR_NUMBER(con->num); 1048 ret = ucsi_send_command(ucsi, command, &con->cap, sizeof(con->cap)); 1049 if (ret < 0) 1050 goto out_unlock; 1051 1052 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP) 1053 cap->data = TYPEC_PORT_DRD; 1054 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP) 1055 cap->data = TYPEC_PORT_DFP; 1056 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP) 1057 cap->data = TYPEC_PORT_UFP; 1058 1059 if ((con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER) && 1060 (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER)) 1061 cap->type = TYPEC_PORT_DRP; 1062 else if (con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER) 1063 cap->type = TYPEC_PORT_SRC; 1064 else if (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER) 1065 cap->type = TYPEC_PORT_SNK; 1066 1067 cap->revision = ucsi->cap.typec_version; 1068 cap->pd_revision = ucsi->cap.pd_version; 1069 cap->svdm_version = SVDM_VER_2_0; 1070 cap->prefer_role = TYPEC_NO_PREFERRED_ROLE; 1071 1072 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY) 1073 *accessory++ = TYPEC_ACCESSORY_AUDIO; 1074 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY) 1075 *accessory = TYPEC_ACCESSORY_DEBUG; 1076 1077 cap->fwnode = ucsi_find_fwnode(con); 1078 cap->driver_data = con; 1079 cap->ops = &ucsi_ops; 1080 1081 ret = ucsi_register_port_psy(con); 1082 if (ret) 1083 goto out; 1084 1085 /* Register the connector */ 1086 con->port = typec_register_port(ucsi->dev, cap); 1087 if (IS_ERR(con->port)) { 1088 ret = PTR_ERR(con->port); 1089 goto out; 1090 } 1091 1092 /* Alternate modes */ 1093 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_CON); 1094 if (ret) { 1095 dev_err(ucsi->dev, "con%d: failed to register alt modes\n", 1096 con->num); 1097 goto out; 1098 } 1099 1100 /* Get the status */ 1101 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num); 1102 ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status)); 1103 if (ret < 0) { 1104 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num); 1105 ret = 0; 1106 goto out; 1107 } 1108 ret = 0; /* ucsi_send_command() returns length on success */ 1109 1110 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) { 1111 case UCSI_CONSTAT_PARTNER_TYPE_UFP: 1112 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP: 1113 u_role = USB_ROLE_HOST; 1114 fallthrough; 1115 case UCSI_CONSTAT_PARTNER_TYPE_CABLE: 1116 typec_set_data_role(con->port, TYPEC_HOST); 1117 break; 1118 case UCSI_CONSTAT_PARTNER_TYPE_DFP: 1119 u_role = USB_ROLE_DEVICE; 1120 typec_set_data_role(con->port, TYPEC_DEVICE); 1121 break; 1122 default: 1123 break; 1124 } 1125 1126 /* Check if there is already something connected */ 1127 if (con->status.flags & UCSI_CONSTAT_CONNECTED) { 1128 typec_set_pwr_role(con->port, 1129 !!(con->status.flags & UCSI_CONSTAT_PWR_DIR)); 1130 ucsi_pwr_opmode_change(con); 1131 ucsi_register_partner(con); 1132 ucsi_port_psy_changed(con); 1133 } 1134 1135 con->usb_role_sw = fwnode_usb_role_switch_get(cap->fwnode); 1136 if (IS_ERR(con->usb_role_sw)) { 1137 dev_err(ucsi->dev, "con%d: failed to get usb role switch\n", 1138 con->num); 1139 con->usb_role_sw = NULL; 1140 } 1141 1142 /* Only notify USB controller if partner supports USB data */ 1143 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB)) 1144 u_role = USB_ROLE_NONE; 1145 1146 ret = usb_role_switch_set_role(con->usb_role_sw, u_role); 1147 if (ret) { 1148 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n", 1149 con->num, u_role); 1150 ret = 0; 1151 } 1152 1153 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) == UCSI_CONSTAT_PWR_OPMODE_PD) { 1154 ucsi_get_src_pdos(con); 1155 ucsi_check_altmodes(con); 1156 } 1157 1158 trace_ucsi_register_port(con->num, &con->status); 1159 1160 out: 1161 fwnode_handle_put(cap->fwnode); 1162 out_unlock: 1163 mutex_unlock(&con->lock); 1164 1165 if (ret && con->wq) { 1166 destroy_workqueue(con->wq); 1167 con->wq = NULL; 1168 } 1169 1170 return ret; 1171 } 1172 1173 /** 1174 * ucsi_init - Initialize UCSI interface 1175 * @ucsi: UCSI to be initialized 1176 * 1177 * Registers all ports @ucsi has and enables all notification events. 1178 */ 1179 static int ucsi_init(struct ucsi *ucsi) 1180 { 1181 struct ucsi_connector *con; 1182 u64 command; 1183 int ret; 1184 int i; 1185 1186 /* Reset the PPM */ 1187 ret = ucsi_reset_ppm(ucsi); 1188 if (ret) { 1189 dev_err(ucsi->dev, "failed to reset PPM!\n"); 1190 goto err; 1191 } 1192 1193 /* Enable basic notifications */ 1194 ucsi->ntfy = UCSI_ENABLE_NTFY_CMD_COMPLETE | UCSI_ENABLE_NTFY_ERROR; 1195 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy; 1196 ret = ucsi_send_command(ucsi, command, NULL, 0); 1197 if (ret < 0) 1198 goto err_reset; 1199 1200 /* Get PPM capabilities */ 1201 command = UCSI_GET_CAPABILITY; 1202 ret = ucsi_send_command(ucsi, command, &ucsi->cap, sizeof(ucsi->cap)); 1203 if (ret < 0) 1204 goto err_reset; 1205 1206 if (!ucsi->cap.num_connectors) { 1207 ret = -ENODEV; 1208 goto err_reset; 1209 } 1210 1211 /* Allocate the connectors. Released in ucsi_unregister() */ 1212 ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1, 1213 sizeof(*ucsi->connector), GFP_KERNEL); 1214 if (!ucsi->connector) { 1215 ret = -ENOMEM; 1216 goto err_reset; 1217 } 1218 1219 /* Register all connectors */ 1220 for (i = 0; i < ucsi->cap.num_connectors; i++) { 1221 ret = ucsi_register_port(ucsi, i); 1222 if (ret) 1223 goto err_unregister; 1224 } 1225 1226 /* Enable all notifications */ 1227 ucsi->ntfy = UCSI_ENABLE_NTFY_ALL; 1228 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy; 1229 ret = ucsi_send_command(ucsi, command, NULL, 0); 1230 if (ret < 0) 1231 goto err_unregister; 1232 1233 return 0; 1234 1235 err_unregister: 1236 for (con = ucsi->connector; con->port; con++) { 1237 ucsi_unregister_partner(con); 1238 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON); 1239 ucsi_unregister_port_psy(con); 1240 if (con->wq) 1241 destroy_workqueue(con->wq); 1242 typec_unregister_port(con->port); 1243 con->port = NULL; 1244 } 1245 1246 err_reset: 1247 memset(&ucsi->cap, 0, sizeof(ucsi->cap)); 1248 ucsi_reset_ppm(ucsi); 1249 err: 1250 return ret; 1251 } 1252 1253 static void ucsi_init_work(struct work_struct *work) 1254 { 1255 struct ucsi *ucsi = container_of(work, struct ucsi, work); 1256 int ret; 1257 1258 ret = ucsi_init(ucsi); 1259 if (ret) 1260 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret); 1261 } 1262 1263 /** 1264 * ucsi_get_drvdata - Return private driver data pointer 1265 * @ucsi: UCSI interface 1266 */ 1267 void *ucsi_get_drvdata(struct ucsi *ucsi) 1268 { 1269 return ucsi->driver_data; 1270 } 1271 EXPORT_SYMBOL_GPL(ucsi_get_drvdata); 1272 1273 /** 1274 * ucsi_set_drvdata - Assign private driver data pointer 1275 * @ucsi: UCSI interface 1276 * @data: Private data pointer 1277 */ 1278 void ucsi_set_drvdata(struct ucsi *ucsi, void *data) 1279 { 1280 ucsi->driver_data = data; 1281 } 1282 EXPORT_SYMBOL_GPL(ucsi_set_drvdata); 1283 1284 /** 1285 * ucsi_create - Allocate UCSI instance 1286 * @dev: Device interface to the PPM (Platform Policy Manager) 1287 * @ops: I/O routines 1288 */ 1289 struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops) 1290 { 1291 struct ucsi *ucsi; 1292 1293 if (!ops || !ops->read || !ops->sync_write || !ops->async_write) 1294 return ERR_PTR(-EINVAL); 1295 1296 ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL); 1297 if (!ucsi) 1298 return ERR_PTR(-ENOMEM); 1299 1300 INIT_WORK(&ucsi->work, ucsi_init_work); 1301 mutex_init(&ucsi->ppm_lock); 1302 ucsi->dev = dev; 1303 ucsi->ops = ops; 1304 1305 return ucsi; 1306 } 1307 EXPORT_SYMBOL_GPL(ucsi_create); 1308 1309 /** 1310 * ucsi_destroy - Free UCSI instance 1311 * @ucsi: UCSI instance to be freed 1312 */ 1313 void ucsi_destroy(struct ucsi *ucsi) 1314 { 1315 kfree(ucsi); 1316 } 1317 EXPORT_SYMBOL_GPL(ucsi_destroy); 1318 1319 /** 1320 * ucsi_register - Register UCSI interface 1321 * @ucsi: UCSI instance 1322 */ 1323 int ucsi_register(struct ucsi *ucsi) 1324 { 1325 int ret; 1326 1327 ret = ucsi->ops->read(ucsi, UCSI_VERSION, &ucsi->version, 1328 sizeof(ucsi->version)); 1329 if (ret) 1330 return ret; 1331 1332 if (!ucsi->version) 1333 return -ENODEV; 1334 1335 queue_work(system_long_wq, &ucsi->work); 1336 1337 return 0; 1338 } 1339 EXPORT_SYMBOL_GPL(ucsi_register); 1340 1341 /** 1342 * ucsi_unregister - Unregister UCSI interface 1343 * @ucsi: UCSI interface to be unregistered 1344 * 1345 * Unregister UCSI interface that was created with ucsi_register(). 1346 */ 1347 void ucsi_unregister(struct ucsi *ucsi) 1348 { 1349 u64 cmd = UCSI_SET_NOTIFICATION_ENABLE; 1350 int i; 1351 1352 /* Make sure that we are not in the middle of driver initialization */ 1353 cancel_work_sync(&ucsi->work); 1354 1355 /* Disable notifications */ 1356 ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd)); 1357 1358 for (i = 0; i < ucsi->cap.num_connectors; i++) { 1359 cancel_work_sync(&ucsi->connector[i].work); 1360 ucsi_unregister_partner(&ucsi->connector[i]); 1361 ucsi_unregister_altmodes(&ucsi->connector[i], 1362 UCSI_RECIPIENT_CON); 1363 ucsi_unregister_port_psy(&ucsi->connector[i]); 1364 if (ucsi->connector[i].wq) 1365 destroy_workqueue(ucsi->connector[i].wq); 1366 typec_unregister_port(ucsi->connector[i].port); 1367 } 1368 1369 kfree(ucsi->connector); 1370 } 1371 EXPORT_SYMBOL_GPL(ucsi_unregister); 1372 1373 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); 1374 MODULE_LICENSE("GPL v2"); 1375 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver"); 1376