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