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_get_num_altmode(struct typec_altmode **alt) 307 { 308 int i; 309 310 for (i = 0; i < UCSI_MAX_ALTMODES; i++) 311 if (!alt[i]) 312 break; 313 314 return i; 315 } 316 317 static int ucsi_register_altmode(struct ucsi_connector *con, 318 struct typec_altmode_desc *desc, 319 u8 recipient) 320 { 321 struct typec_altmode *alt; 322 bool override; 323 int ret; 324 int i; 325 326 override = !!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_OVERRIDE); 327 328 switch (recipient) { 329 case UCSI_RECIPIENT_CON: 330 i = ucsi_next_altmode(con->port_altmode); 331 if (i < 0) { 332 ret = i; 333 goto err; 334 } 335 336 ret = ucsi_altmode_next_mode(con->port_altmode, desc->svid); 337 if (ret < 0) 338 return ret; 339 340 desc->mode = ret; 341 342 switch (desc->svid) { 343 case USB_TYPEC_DP_SID: 344 alt = ucsi_register_displayport(con, override, i, desc); 345 break; 346 case USB_TYPEC_NVIDIA_VLINK_SID: 347 if (desc->vdo == USB_TYPEC_NVIDIA_VLINK_DBG_VDO) 348 alt = typec_port_register_altmode(con->port, 349 desc); 350 else 351 alt = ucsi_register_displayport(con, override, 352 i, desc); 353 break; 354 default: 355 alt = typec_port_register_altmode(con->port, desc); 356 break; 357 } 358 359 if (IS_ERR(alt)) { 360 ret = PTR_ERR(alt); 361 goto err; 362 } 363 364 con->port_altmode[i] = alt; 365 break; 366 case UCSI_RECIPIENT_SOP: 367 i = ucsi_next_altmode(con->partner_altmode); 368 if (i < 0) { 369 ret = i; 370 goto err; 371 } 372 373 ret = ucsi_altmode_next_mode(con->partner_altmode, desc->svid); 374 if (ret < 0) 375 return ret; 376 377 desc->mode = ret; 378 379 alt = typec_partner_register_altmode(con->partner, desc); 380 if (IS_ERR(alt)) { 381 ret = PTR_ERR(alt); 382 goto err; 383 } 384 385 con->partner_altmode[i] = alt; 386 break; 387 default: 388 return -EINVAL; 389 } 390 391 trace_ucsi_register_altmode(recipient, alt); 392 393 return 0; 394 395 err: 396 dev_err(con->ucsi->dev, "failed to registers svid 0x%04x mode %d\n", 397 desc->svid, desc->mode); 398 399 return ret; 400 } 401 402 static int 403 ucsi_register_altmodes_nvidia(struct ucsi_connector *con, u8 recipient) 404 { 405 int max_altmodes = UCSI_MAX_ALTMODES; 406 struct typec_altmode_desc desc; 407 struct ucsi_altmode alt; 408 struct ucsi_altmode orig[UCSI_MAX_ALTMODES]; 409 struct ucsi_altmode updated[UCSI_MAX_ALTMODES]; 410 struct ucsi *ucsi = con->ucsi; 411 bool multi_dp = false; 412 u64 command; 413 int ret; 414 int len; 415 int i; 416 int k = 0; 417 418 if (recipient == UCSI_RECIPIENT_CON) 419 max_altmodes = con->ucsi->cap.num_alt_modes; 420 421 memset(orig, 0, sizeof(orig)); 422 memset(updated, 0, sizeof(updated)); 423 424 /* First get all the alternate modes */ 425 for (i = 0; i < max_altmodes; i++) { 426 memset(&alt, 0, sizeof(alt)); 427 command = UCSI_GET_ALTERNATE_MODES; 428 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient); 429 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num); 430 command |= UCSI_GET_ALTMODE_OFFSET(i); 431 len = ucsi_send_command(con->ucsi, command, &alt, sizeof(alt)); 432 /* 433 * We are collecting all altmodes first and then registering. 434 * Some type-C device will return zero length data beyond last 435 * alternate modes. We should not return if length is zero. 436 */ 437 if (len < 0) 438 return len; 439 440 /* We got all altmodes, now break out and register them */ 441 if (!len || !alt.svid) 442 break; 443 444 orig[k].mid = alt.mid; 445 orig[k].svid = alt.svid; 446 k++; 447 } 448 /* 449 * Update the original altmode table as some ppms may report 450 * multiple DP altmodes. 451 */ 452 if (recipient == UCSI_RECIPIENT_CON) 453 multi_dp = ucsi->ops->update_altmodes(ucsi, orig, updated); 454 455 /* now register altmodes */ 456 for (i = 0; i < max_altmodes; i++) { 457 memset(&desc, 0, sizeof(desc)); 458 if (multi_dp && recipient == UCSI_RECIPIENT_CON) { 459 desc.svid = updated[i].svid; 460 desc.vdo = updated[i].mid; 461 } else { 462 desc.svid = orig[i].svid; 463 desc.vdo = orig[i].mid; 464 } 465 desc.roles = TYPEC_PORT_DRD; 466 467 if (!desc.svid) 468 return 0; 469 470 ret = ucsi_register_altmode(con, &desc, recipient); 471 if (ret) 472 return ret; 473 } 474 475 return 0; 476 } 477 478 static int ucsi_register_altmodes(struct ucsi_connector *con, u8 recipient) 479 { 480 int max_altmodes = UCSI_MAX_ALTMODES; 481 struct typec_altmode_desc desc; 482 struct ucsi_altmode alt[2]; 483 u64 command; 484 int num; 485 int ret; 486 int len; 487 int j; 488 int i; 489 490 if (!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS)) 491 return 0; 492 493 if (recipient == UCSI_RECIPIENT_SOP && con->partner_altmode[0]) 494 return 0; 495 496 if (con->ucsi->ops->update_altmodes) 497 return ucsi_register_altmodes_nvidia(con, recipient); 498 499 if (recipient == UCSI_RECIPIENT_CON) 500 max_altmodes = con->ucsi->cap.num_alt_modes; 501 502 for (i = 0; i < max_altmodes;) { 503 memset(alt, 0, sizeof(alt)); 504 command = UCSI_GET_ALTERNATE_MODES; 505 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient); 506 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num); 507 command |= UCSI_GET_ALTMODE_OFFSET(i); 508 len = ucsi_send_command(con->ucsi, command, alt, sizeof(alt)); 509 if (len == -EBUSY) 510 continue; 511 if (len <= 0) 512 return len; 513 514 /* 515 * This code is requesting one alt mode at a time, but some PPMs 516 * may still return two. If that happens both alt modes need be 517 * registered and the offset for the next alt mode has to be 518 * incremented. 519 */ 520 num = len / sizeof(alt[0]); 521 i += num; 522 523 for (j = 0; j < num; j++) { 524 if (!alt[j].svid) 525 return 0; 526 527 memset(&desc, 0, sizeof(desc)); 528 desc.vdo = alt[j].mid; 529 desc.svid = alt[j].svid; 530 desc.roles = TYPEC_PORT_DRD; 531 532 ret = ucsi_register_altmode(con, &desc, recipient); 533 if (ret) 534 return ret; 535 } 536 } 537 538 return 0; 539 } 540 541 static void ucsi_unregister_altmodes(struct ucsi_connector *con, u8 recipient) 542 { 543 const struct typec_altmode *pdev; 544 struct typec_altmode **adev; 545 int i = 0; 546 547 switch (recipient) { 548 case UCSI_RECIPIENT_CON: 549 adev = con->port_altmode; 550 break; 551 case UCSI_RECIPIENT_SOP: 552 adev = con->partner_altmode; 553 break; 554 default: 555 return; 556 } 557 558 while (adev[i]) { 559 if (recipient == UCSI_RECIPIENT_SOP && 560 (adev[i]->svid == USB_TYPEC_DP_SID || 561 (adev[i]->svid == USB_TYPEC_NVIDIA_VLINK_SID && 562 adev[i]->vdo != USB_TYPEC_NVIDIA_VLINK_DBG_VDO))) { 563 pdev = typec_altmode_get_partner(adev[i]); 564 ucsi_displayport_remove_partner((void *)pdev); 565 } 566 typec_unregister_altmode(adev[i]); 567 adev[i++] = NULL; 568 } 569 } 570 571 static int ucsi_get_pdos(struct ucsi_connector *con, int is_partner, 572 u32 *pdos, int offset, int num_pdos) 573 { 574 struct ucsi *ucsi = con->ucsi; 575 u64 command; 576 int ret; 577 578 command = UCSI_COMMAND(UCSI_GET_PDOS) | UCSI_CONNECTOR_NUMBER(con->num); 579 command |= UCSI_GET_PDOS_PARTNER_PDO(is_partner); 580 command |= UCSI_GET_PDOS_PDO_OFFSET(offset); 581 command |= UCSI_GET_PDOS_NUM_PDOS(num_pdos - 1); 582 command |= UCSI_GET_PDOS_SRC_PDOS; 583 ret = ucsi_send_command(ucsi, command, pdos + offset, 584 num_pdos * sizeof(u32)); 585 if (ret < 0 && ret != -ETIMEDOUT) 586 dev_err(ucsi->dev, "UCSI_GET_PDOS failed (%d)\n", ret); 587 if (ret == 0 && offset == 0) 588 dev_warn(ucsi->dev, "UCSI_GET_PDOS returned 0 bytes\n"); 589 590 return ret; 591 } 592 593 static int ucsi_get_src_pdos(struct ucsi_connector *con) 594 { 595 int ret; 596 597 /* UCSI max payload means only getting at most 4 PDOs at a time */ 598 ret = ucsi_get_pdos(con, 1, con->src_pdos, 0, UCSI_MAX_PDOS); 599 if (ret < 0) 600 return ret; 601 602 con->num_pdos = ret / sizeof(u32); /* number of bytes to 32-bit PDOs */ 603 if (con->num_pdos < UCSI_MAX_PDOS) 604 return 0; 605 606 /* get the remaining PDOs, if any */ 607 ret = ucsi_get_pdos(con, 1, con->src_pdos, UCSI_MAX_PDOS, 608 PDO_MAX_OBJECTS - UCSI_MAX_PDOS); 609 if (ret < 0) 610 return ret; 611 612 con->num_pdos += ret / sizeof(u32); 613 614 ucsi_port_psy_changed(con); 615 616 return 0; 617 } 618 619 static int ucsi_check_altmodes(struct ucsi_connector *con) 620 { 621 int ret, num_partner_am; 622 623 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP); 624 if (ret && ret != -ETIMEDOUT) 625 dev_err(con->ucsi->dev, 626 "con%d: failed to register partner alt modes (%d)\n", 627 con->num, ret); 628 629 /* Ignoring the errors in this case. */ 630 if (con->partner_altmode[0]) { 631 num_partner_am = ucsi_get_num_altmode(con->partner_altmode); 632 if (num_partner_am > 0) 633 typec_partner_set_num_altmodes(con->partner, num_partner_am); 634 ucsi_altmode_update_active(con); 635 return 0; 636 } 637 638 return ret; 639 } 640 641 static void ucsi_pwr_opmode_change(struct ucsi_connector *con) 642 { 643 switch (UCSI_CONSTAT_PWR_OPMODE(con->status.flags)) { 644 case UCSI_CONSTAT_PWR_OPMODE_PD: 645 con->rdo = con->status.request_data_obj; 646 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD); 647 ucsi_partner_task(con, ucsi_get_src_pdos, 30, 0); 648 ucsi_partner_task(con, ucsi_check_altmodes, 30, 0); 649 break; 650 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5: 651 con->rdo = 0; 652 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A); 653 break; 654 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0: 655 con->rdo = 0; 656 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A); 657 break; 658 default: 659 con->rdo = 0; 660 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB); 661 break; 662 } 663 } 664 665 static int ucsi_register_partner(struct ucsi_connector *con) 666 { 667 u8 pwr_opmode = UCSI_CONSTAT_PWR_OPMODE(con->status.flags); 668 struct typec_partner_desc desc; 669 struct typec_partner *partner; 670 671 if (con->partner) 672 return 0; 673 674 memset(&desc, 0, sizeof(desc)); 675 676 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) { 677 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG: 678 desc.accessory = TYPEC_ACCESSORY_DEBUG; 679 break; 680 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO: 681 desc.accessory = TYPEC_ACCESSORY_AUDIO; 682 break; 683 default: 684 break; 685 } 686 687 desc.usb_pd = pwr_opmode == UCSI_CONSTAT_PWR_OPMODE_PD; 688 689 partner = typec_register_partner(con->port, &desc); 690 if (IS_ERR(partner)) { 691 dev_err(con->ucsi->dev, 692 "con%d: failed to register partner (%ld)\n", con->num, 693 PTR_ERR(partner)); 694 return PTR_ERR(partner); 695 } 696 697 con->partner = partner; 698 699 return 0; 700 } 701 702 static void ucsi_unregister_partner(struct ucsi_connector *con) 703 { 704 if (!con->partner) 705 return; 706 707 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP); 708 typec_unregister_partner(con->partner); 709 con->partner = NULL; 710 } 711 712 static void ucsi_partner_change(struct ucsi_connector *con) 713 { 714 enum usb_role u_role = USB_ROLE_NONE; 715 int ret; 716 717 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) { 718 case UCSI_CONSTAT_PARTNER_TYPE_UFP: 719 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP: 720 u_role = USB_ROLE_HOST; 721 fallthrough; 722 case UCSI_CONSTAT_PARTNER_TYPE_CABLE: 723 typec_set_data_role(con->port, TYPEC_HOST); 724 break; 725 case UCSI_CONSTAT_PARTNER_TYPE_DFP: 726 u_role = USB_ROLE_DEVICE; 727 typec_set_data_role(con->port, TYPEC_DEVICE); 728 break; 729 default: 730 break; 731 } 732 733 /* Only notify USB controller if partner supports USB data */ 734 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB)) 735 u_role = USB_ROLE_NONE; 736 737 ret = usb_role_switch_set_role(con->usb_role_sw, u_role); 738 if (ret) 739 dev_err(con->ucsi->dev, "con:%d: failed to set usb role:%d\n", 740 con->num, u_role); 741 } 742 743 static int ucsi_check_connection(struct ucsi_connector *con) 744 { 745 u64 command; 746 int ret; 747 748 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num); 749 ret = ucsi_send_command(con->ucsi, command, &con->status, sizeof(con->status)); 750 if (ret < 0) { 751 dev_err(con->ucsi->dev, "GET_CONNECTOR_STATUS failed (%d)\n", ret); 752 return ret; 753 } 754 755 if (con->status.flags & UCSI_CONSTAT_CONNECTED) { 756 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) == 757 UCSI_CONSTAT_PWR_OPMODE_PD) 758 ucsi_partner_task(con, ucsi_check_altmodes, 30, 0); 759 } else { 760 ucsi_partner_change(con); 761 ucsi_port_psy_changed(con); 762 ucsi_unregister_partner(con); 763 } 764 765 return 0; 766 } 767 768 static void ucsi_handle_connector_change(struct work_struct *work) 769 { 770 struct ucsi_connector *con = container_of(work, struct ucsi_connector, 771 work); 772 struct ucsi *ucsi = con->ucsi; 773 enum typec_role role; 774 u64 command; 775 int ret; 776 777 mutex_lock(&con->lock); 778 779 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num); 780 ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status)); 781 if (ret < 0) { 782 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n", 783 __func__, ret); 784 goto out_unlock; 785 } 786 787 trace_ucsi_connector_change(con->num, &con->status); 788 789 role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR); 790 791 if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) { 792 typec_set_pwr_role(con->port, role); 793 794 /* Complete pending power role swap */ 795 if (!completion_done(&con->complete)) 796 complete(&con->complete); 797 } 798 799 if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) { 800 typec_set_pwr_role(con->port, role); 801 ucsi_port_psy_changed(con); 802 ucsi_partner_change(con); 803 804 if (con->status.flags & UCSI_CONSTAT_CONNECTED) { 805 ucsi_register_partner(con); 806 ucsi_partner_task(con, ucsi_check_connection, 1, HZ); 807 } else { 808 ucsi_unregister_partner(con); 809 } 810 } 811 812 if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE || 813 con->status.change & UCSI_CONSTAT_POWER_LEVEL_CHANGE) 814 ucsi_pwr_opmode_change(con); 815 816 if (con->partner && con->status.change & UCSI_CONSTAT_PARTNER_CHANGE) { 817 ucsi_partner_change(con); 818 819 /* Complete pending data role swap */ 820 if (!completion_done(&con->complete)) 821 complete(&con->complete); 822 } 823 824 if (con->status.change & UCSI_CONSTAT_CAM_CHANGE) 825 ucsi_partner_task(con, ucsi_check_altmodes, 1, 0); 826 827 clear_bit(EVENT_PENDING, &con->ucsi->flags); 828 829 ret = ucsi_acknowledge_connector_change(ucsi); 830 if (ret) 831 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret); 832 833 out_unlock: 834 mutex_unlock(&con->lock); 835 } 836 837 /** 838 * ucsi_connector_change - Process Connector Change Event 839 * @ucsi: UCSI Interface 840 * @num: Connector number 841 */ 842 void ucsi_connector_change(struct ucsi *ucsi, u8 num) 843 { 844 struct ucsi_connector *con = &ucsi->connector[num - 1]; 845 846 if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) { 847 dev_dbg(ucsi->dev, "Bogus connector change event\n"); 848 return; 849 } 850 851 if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags)) 852 schedule_work(&con->work); 853 } 854 EXPORT_SYMBOL_GPL(ucsi_connector_change); 855 856 /* -------------------------------------------------------------------------- */ 857 858 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard) 859 { 860 u64 command; 861 862 command = UCSI_CONNECTOR_RESET | UCSI_CONNECTOR_NUMBER(con->num); 863 command |= hard ? UCSI_CONNECTOR_RESET_HARD : 0; 864 865 return ucsi_send_command(con->ucsi, command, NULL, 0); 866 } 867 868 static int ucsi_reset_ppm(struct ucsi *ucsi) 869 { 870 u64 command = UCSI_PPM_RESET; 871 unsigned long tmo; 872 u32 cci; 873 int ret; 874 875 mutex_lock(&ucsi->ppm_lock); 876 877 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command, 878 sizeof(command)); 879 if (ret < 0) 880 goto out; 881 882 tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS); 883 884 do { 885 if (time_is_before_jiffies(tmo)) { 886 ret = -ETIMEDOUT; 887 goto out; 888 } 889 890 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci)); 891 if (ret) 892 goto out; 893 894 /* If the PPM is still doing something else, reset it again. */ 895 if (cci & ~UCSI_CCI_RESET_COMPLETE) { 896 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, 897 &command, 898 sizeof(command)); 899 if (ret < 0) 900 goto out; 901 } 902 903 msleep(20); 904 } while (!(cci & UCSI_CCI_RESET_COMPLETE)); 905 906 out: 907 mutex_unlock(&ucsi->ppm_lock); 908 return ret; 909 } 910 911 static int ucsi_role_cmd(struct ucsi_connector *con, u64 command) 912 { 913 int ret; 914 915 ret = ucsi_send_command(con->ucsi, command, NULL, 0); 916 if (ret == -ETIMEDOUT) { 917 u64 c; 918 919 /* PPM most likely stopped responding. Resetting everything. */ 920 ucsi_reset_ppm(con->ucsi); 921 922 c = UCSI_SET_NOTIFICATION_ENABLE | con->ucsi->ntfy; 923 ucsi_send_command(con->ucsi, c, NULL, 0); 924 925 ucsi_reset_connector(con, true); 926 } 927 928 return ret; 929 } 930 931 static int ucsi_dr_swap(struct typec_port *port, enum typec_data_role role) 932 { 933 struct ucsi_connector *con = typec_get_drvdata(port); 934 u8 partner_type; 935 u64 command; 936 int ret = 0; 937 938 mutex_lock(&con->lock); 939 940 if (!con->partner) { 941 ret = -ENOTCONN; 942 goto out_unlock; 943 } 944 945 partner_type = UCSI_CONSTAT_PARTNER_TYPE(con->status.flags); 946 if ((partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP && 947 role == TYPEC_DEVICE) || 948 (partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP && 949 role == TYPEC_HOST)) 950 goto out_unlock; 951 952 reinit_completion(&con->complete); 953 954 command = UCSI_SET_UOR | UCSI_CONNECTOR_NUMBER(con->num); 955 command |= UCSI_SET_UOR_ROLE(role); 956 command |= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS; 957 ret = ucsi_role_cmd(con, command); 958 if (ret < 0) 959 goto out_unlock; 960 961 mutex_unlock(&con->lock); 962 963 if (!wait_for_completion_timeout(&con->complete, 964 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) 965 return -ETIMEDOUT; 966 967 return 0; 968 969 out_unlock: 970 mutex_unlock(&con->lock); 971 972 return ret; 973 } 974 975 static int ucsi_pr_swap(struct typec_port *port, enum typec_role role) 976 { 977 struct ucsi_connector *con = typec_get_drvdata(port); 978 enum typec_role cur_role; 979 u64 command; 980 int ret = 0; 981 982 mutex_lock(&con->lock); 983 984 if (!con->partner) { 985 ret = -ENOTCONN; 986 goto out_unlock; 987 } 988 989 cur_role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR); 990 991 if (cur_role == role) 992 goto out_unlock; 993 994 reinit_completion(&con->complete); 995 996 command = UCSI_SET_PDR | UCSI_CONNECTOR_NUMBER(con->num); 997 command |= UCSI_SET_PDR_ROLE(role); 998 command |= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS; 999 ret = ucsi_role_cmd(con, command); 1000 if (ret < 0) 1001 goto out_unlock; 1002 1003 mutex_unlock(&con->lock); 1004 1005 if (!wait_for_completion_timeout(&con->complete, 1006 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) 1007 return -ETIMEDOUT; 1008 1009 mutex_lock(&con->lock); 1010 1011 /* Something has gone wrong while swapping the role */ 1012 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) != 1013 UCSI_CONSTAT_PWR_OPMODE_PD) { 1014 ucsi_reset_connector(con, true); 1015 ret = -EPROTO; 1016 } 1017 1018 out_unlock: 1019 mutex_unlock(&con->lock); 1020 1021 return ret; 1022 } 1023 1024 static const struct typec_operations ucsi_ops = { 1025 .dr_set = ucsi_dr_swap, 1026 .pr_set = ucsi_pr_swap 1027 }; 1028 1029 /* Caller must call fwnode_handle_put() after use */ 1030 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con) 1031 { 1032 struct fwnode_handle *fwnode; 1033 int i = 1; 1034 1035 device_for_each_child_node(con->ucsi->dev, fwnode) 1036 if (i++ == con->num) 1037 return fwnode; 1038 return NULL; 1039 } 1040 1041 static int ucsi_register_port(struct ucsi *ucsi, int index) 1042 { 1043 struct ucsi_connector *con = &ucsi->connector[index]; 1044 struct typec_capability *cap = &con->typec_cap; 1045 enum typec_accessory *accessory = cap->accessory; 1046 enum usb_role u_role = USB_ROLE_NONE; 1047 u64 command; 1048 char *name; 1049 int ret; 1050 1051 name = kasprintf(GFP_KERNEL, "%s-con%d", dev_name(ucsi->dev), con->num); 1052 if (!name) 1053 return -ENOMEM; 1054 1055 con->wq = create_singlethread_workqueue(name); 1056 kfree(name); 1057 if (!con->wq) 1058 return -ENOMEM; 1059 1060 INIT_WORK(&con->work, ucsi_handle_connector_change); 1061 init_completion(&con->complete); 1062 mutex_init(&con->lock); 1063 con->num = index + 1; 1064 con->ucsi = ucsi; 1065 1066 cap->fwnode = ucsi_find_fwnode(con); 1067 con->usb_role_sw = fwnode_usb_role_switch_get(cap->fwnode); 1068 if (IS_ERR(con->usb_role_sw)) { 1069 dev_err(ucsi->dev, "con%d: failed to get usb role switch\n", 1070 con->num); 1071 return PTR_ERR(con->usb_role_sw); 1072 } 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 static void ucsi_unregister_connectors(struct ucsi *ucsi) 1200 { 1201 struct ucsi_connector *con; 1202 int i; 1203 1204 if (!ucsi->connector) 1205 return; 1206 1207 for (i = 0; i < ucsi->cap.num_connectors; i++) { 1208 con = &ucsi->connector[i]; 1209 1210 if (!con->wq) 1211 break; 1212 1213 cancel_work_sync(&con->work); 1214 ucsi_unregister_partner(con); 1215 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON); 1216 ucsi_unregister_port_psy(con); 1217 destroy_workqueue(con->wq); 1218 typec_unregister_port(con->port); 1219 } 1220 1221 kfree(ucsi->connector); 1222 ucsi->connector = NULL; 1223 } 1224 1225 /** 1226 * ucsi_init - Initialize UCSI interface 1227 * @ucsi: UCSI to be initialized 1228 * 1229 * Registers all ports @ucsi has and enables all notification events. 1230 */ 1231 static int ucsi_init(struct ucsi *ucsi) 1232 { 1233 u64 command; 1234 int ret; 1235 int i; 1236 1237 /* Reset the PPM */ 1238 ret = ucsi_reset_ppm(ucsi); 1239 if (ret) { 1240 dev_err(ucsi->dev, "failed to reset PPM!\n"); 1241 goto err; 1242 } 1243 1244 /* Enable basic notifications */ 1245 ucsi->ntfy = UCSI_ENABLE_NTFY_CMD_COMPLETE | UCSI_ENABLE_NTFY_ERROR; 1246 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy; 1247 ret = ucsi_send_command(ucsi, command, NULL, 0); 1248 if (ret < 0) 1249 goto err_reset; 1250 1251 /* Get PPM capabilities */ 1252 command = UCSI_GET_CAPABILITY; 1253 ret = ucsi_send_command(ucsi, command, &ucsi->cap, sizeof(ucsi->cap)); 1254 if (ret < 0) 1255 goto err_reset; 1256 1257 if (!ucsi->cap.num_connectors) { 1258 ret = -ENODEV; 1259 goto err_reset; 1260 } 1261 1262 /* Allocate the connectors. Released in ucsi_unregister() */ 1263 ucsi->connector = kcalloc(ucsi->cap.num_connectors, 1264 sizeof(*ucsi->connector), GFP_KERNEL); 1265 if (!ucsi->connector) { 1266 ret = -ENOMEM; 1267 goto err_reset; 1268 } 1269 1270 /* Register all connectors */ 1271 for (i = 0; i < ucsi->cap.num_connectors; i++) { 1272 ret = ucsi_register_port(ucsi, i); 1273 if (ret) 1274 goto err_unregister; 1275 } 1276 1277 /* Enable all notifications */ 1278 ucsi->ntfy = UCSI_ENABLE_NTFY_ALL; 1279 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy; 1280 ret = ucsi_send_command(ucsi, command, NULL, 0); 1281 if (ret < 0) 1282 goto err_unregister; 1283 1284 return 0; 1285 1286 err_unregister: 1287 ucsi_unregister_connectors(ucsi); 1288 1289 err_reset: 1290 memset(&ucsi->cap, 0, sizeof(ucsi->cap)); 1291 ucsi_reset_ppm(ucsi); 1292 err: 1293 return ret; 1294 } 1295 1296 static void ucsi_init_work(struct work_struct *work) 1297 { 1298 struct ucsi *ucsi = container_of(work, struct ucsi, work.work); 1299 int ret; 1300 1301 ret = ucsi_init(ucsi); 1302 if (ret) 1303 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret); 1304 1305 if (ret == -EPROBE_DEFER) { 1306 if (ucsi->work_count++ > UCSI_ROLE_SWITCH_WAIT_COUNT) 1307 return; 1308 1309 queue_delayed_work(system_long_wq, &ucsi->work, 1310 UCSI_ROLE_SWITCH_INTERVAL); 1311 } 1312 } 1313 1314 /** 1315 * ucsi_get_drvdata - Return private driver data pointer 1316 * @ucsi: UCSI interface 1317 */ 1318 void *ucsi_get_drvdata(struct ucsi *ucsi) 1319 { 1320 return ucsi->driver_data; 1321 } 1322 EXPORT_SYMBOL_GPL(ucsi_get_drvdata); 1323 1324 /** 1325 * ucsi_set_drvdata - Assign private driver data pointer 1326 * @ucsi: UCSI interface 1327 * @data: Private data pointer 1328 */ 1329 void ucsi_set_drvdata(struct ucsi *ucsi, void *data) 1330 { 1331 ucsi->driver_data = data; 1332 } 1333 EXPORT_SYMBOL_GPL(ucsi_set_drvdata); 1334 1335 /** 1336 * ucsi_create - Allocate UCSI instance 1337 * @dev: Device interface to the PPM (Platform Policy Manager) 1338 * @ops: I/O routines 1339 */ 1340 struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops) 1341 { 1342 struct ucsi *ucsi; 1343 1344 if (!ops || !ops->read || !ops->sync_write || !ops->async_write) 1345 return ERR_PTR(-EINVAL); 1346 1347 ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL); 1348 if (!ucsi) 1349 return ERR_PTR(-ENOMEM); 1350 1351 INIT_DELAYED_WORK(&ucsi->work, ucsi_init_work); 1352 mutex_init(&ucsi->ppm_lock); 1353 ucsi->dev = dev; 1354 ucsi->ops = ops; 1355 1356 return ucsi; 1357 } 1358 EXPORT_SYMBOL_GPL(ucsi_create); 1359 1360 /** 1361 * ucsi_destroy - Free UCSI instance 1362 * @ucsi: UCSI instance to be freed 1363 */ 1364 void ucsi_destroy(struct ucsi *ucsi) 1365 { 1366 kfree(ucsi); 1367 } 1368 EXPORT_SYMBOL_GPL(ucsi_destroy); 1369 1370 /** 1371 * ucsi_register - Register UCSI interface 1372 * @ucsi: UCSI instance 1373 */ 1374 int ucsi_register(struct ucsi *ucsi) 1375 { 1376 int ret; 1377 1378 ret = ucsi->ops->read(ucsi, UCSI_VERSION, &ucsi->version, 1379 sizeof(ucsi->version)); 1380 if (ret) 1381 return ret; 1382 1383 if (!ucsi->version) 1384 return -ENODEV; 1385 1386 queue_delayed_work(system_long_wq, &ucsi->work, 0); 1387 1388 return 0; 1389 } 1390 EXPORT_SYMBOL_GPL(ucsi_register); 1391 1392 /** 1393 * ucsi_unregister - Unregister UCSI interface 1394 * @ucsi: UCSI interface to be unregistered 1395 * 1396 * Unregister UCSI interface that was created with ucsi_register(). 1397 */ 1398 void ucsi_unregister(struct ucsi *ucsi) 1399 { 1400 u64 cmd = UCSI_SET_NOTIFICATION_ENABLE; 1401 1402 /* Make sure that we are not in the middle of driver initialization */ 1403 cancel_delayed_work_sync(&ucsi->work); 1404 1405 /* Disable notifications */ 1406 ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd)); 1407 1408 ucsi_unregister_connectors(ucsi); 1409 } 1410 EXPORT_SYMBOL_GPL(ucsi_unregister); 1411 1412 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); 1413 MODULE_LICENSE("GPL v2"); 1414 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver"); 1415