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.h> 16 17 #include "ucsi.h" 18 #include "trace.h" 19 20 #define to_ucsi_connector(_cap_) container_of(_cap_, struct ucsi_connector, \ 21 typec_cap) 22 23 /* 24 * UCSI_TIMEOUT_MS - PPM communication timeout 25 * 26 * Ideally we could use MIN_TIME_TO_RESPOND_WITH_BUSY (which is defined in UCSI 27 * specification) here as reference, but unfortunately we can't. It is very 28 * difficult to estimate the time it takes for the system to process the command 29 * before it is actually passed to the PPM. 30 */ 31 #define UCSI_TIMEOUT_MS 5000 32 33 /* 34 * UCSI_SWAP_TIMEOUT_MS - Timeout for role swap requests 35 * 36 * 5 seconds is close to the time it takes for CapsCounter to reach 0, so even 37 * if the PPM does not generate Connector Change events before that with 38 * partners that do not support USB Power Delivery, this should still work. 39 */ 40 #define UCSI_SWAP_TIMEOUT_MS 5000 41 42 enum ucsi_status { 43 UCSI_IDLE = 0, 44 UCSI_BUSY, 45 UCSI_ERROR, 46 }; 47 48 struct ucsi_connector { 49 int num; 50 51 struct ucsi *ucsi; 52 struct work_struct work; 53 struct completion complete; 54 55 struct typec_port *port; 56 struct typec_partner *partner; 57 58 struct typec_capability typec_cap; 59 60 struct ucsi_connector_status status; 61 struct ucsi_connector_capability cap; 62 }; 63 64 struct ucsi { 65 struct device *dev; 66 struct ucsi_ppm *ppm; 67 68 enum ucsi_status status; 69 struct completion complete; 70 struct ucsi_capability cap; 71 struct ucsi_connector *connector; 72 73 struct work_struct work; 74 75 /* PPM Communication lock */ 76 struct mutex ppm_lock; 77 78 /* PPM communication flags */ 79 unsigned long flags; 80 #define EVENT_PENDING 0 81 #define COMMAND_PENDING 1 82 #define ACK_PENDING 2 83 }; 84 85 static inline int ucsi_sync(struct ucsi *ucsi) 86 { 87 if (ucsi->ppm && ucsi->ppm->sync) 88 return ucsi->ppm->sync(ucsi->ppm); 89 return 0; 90 } 91 92 static int ucsi_command(struct ucsi *ucsi, struct ucsi_control *ctrl) 93 { 94 int ret; 95 96 trace_ucsi_command(ctrl); 97 98 set_bit(COMMAND_PENDING, &ucsi->flags); 99 100 ret = ucsi->ppm->cmd(ucsi->ppm, ctrl); 101 if (ret) 102 goto err_clear_flag; 103 104 if (!wait_for_completion_timeout(&ucsi->complete, 105 msecs_to_jiffies(UCSI_TIMEOUT_MS))) { 106 dev_warn(ucsi->dev, "PPM NOT RESPONDING\n"); 107 ret = -ETIMEDOUT; 108 } 109 110 err_clear_flag: 111 clear_bit(COMMAND_PENDING, &ucsi->flags); 112 113 return ret; 114 } 115 116 static int ucsi_ack(struct ucsi *ucsi, u8 ack) 117 { 118 struct ucsi_control ctrl; 119 int ret; 120 121 trace_ucsi_ack(ack); 122 123 set_bit(ACK_PENDING, &ucsi->flags); 124 125 UCSI_CMD_ACK(ctrl, ack); 126 ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl); 127 if (ret) 128 goto out_clear_bit; 129 130 /* Waiting for ACK with ACK CMD, but not with EVENT for now */ 131 if (ack == UCSI_ACK_EVENT) 132 goto out_clear_bit; 133 134 if (!wait_for_completion_timeout(&ucsi->complete, 135 msecs_to_jiffies(UCSI_TIMEOUT_MS))) 136 ret = -ETIMEDOUT; 137 138 out_clear_bit: 139 clear_bit(ACK_PENDING, &ucsi->flags); 140 141 if (ret) 142 dev_err(ucsi->dev, "%s: failed\n", __func__); 143 144 return ret; 145 } 146 147 static int ucsi_run_command(struct ucsi *ucsi, struct ucsi_control *ctrl, 148 void *data, size_t size) 149 { 150 struct ucsi_control _ctrl; 151 u8 data_length; 152 u16 error; 153 int ret; 154 155 ret = ucsi_command(ucsi, ctrl); 156 if (ret) 157 goto err; 158 159 switch (ucsi->status) { 160 case UCSI_IDLE: 161 ret = ucsi_sync(ucsi); 162 if (ret) 163 dev_warn(ucsi->dev, "%s: sync failed\n", __func__); 164 165 if (data) 166 memcpy(data, ucsi->ppm->data->message_in, size); 167 168 data_length = ucsi->ppm->data->cci.data_length; 169 170 ret = ucsi_ack(ucsi, UCSI_ACK_CMD); 171 if (!ret) 172 ret = data_length; 173 break; 174 case UCSI_BUSY: 175 /* The caller decides whether to cancel or not */ 176 ret = -EBUSY; 177 break; 178 case UCSI_ERROR: 179 ret = ucsi_ack(ucsi, UCSI_ACK_CMD); 180 if (ret) 181 break; 182 183 _ctrl.raw_cmd = 0; 184 _ctrl.cmd.cmd = UCSI_GET_ERROR_STATUS; 185 ret = ucsi_command(ucsi, &_ctrl); 186 if (ret) { 187 dev_err(ucsi->dev, "reading error failed!\n"); 188 break; 189 } 190 191 memcpy(&error, ucsi->ppm->data->message_in, sizeof(error)); 192 193 /* Something has really gone wrong */ 194 if (WARN_ON(ucsi->status == UCSI_ERROR)) { 195 ret = -ENODEV; 196 break; 197 } 198 199 ret = ucsi_ack(ucsi, UCSI_ACK_CMD); 200 if (ret) 201 break; 202 203 switch (error) { 204 case UCSI_ERROR_INCOMPATIBLE_PARTNER: 205 ret = -EOPNOTSUPP; 206 break; 207 case UCSI_ERROR_CC_COMMUNICATION_ERR: 208 ret = -ECOMM; 209 break; 210 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL: 211 ret = -EPROTO; 212 break; 213 case UCSI_ERROR_DEAD_BATTERY: 214 dev_warn(ucsi->dev, "Dead battery condition!\n"); 215 ret = -EPERM; 216 break; 217 /* The following mean a bug in this driver */ 218 case UCSI_ERROR_INVALID_CON_NUM: 219 case UCSI_ERROR_UNREGONIZED_CMD: 220 case UCSI_ERROR_INVALID_CMD_ARGUMENT: 221 dev_warn(ucsi->dev, 222 "%s: possible UCSI driver bug - error 0x%x\n", 223 __func__, error); 224 ret = -EINVAL; 225 break; 226 default: 227 dev_warn(ucsi->dev, 228 "%s: error without status\n", __func__); 229 ret = -EIO; 230 break; 231 } 232 break; 233 } 234 235 err: 236 trace_ucsi_run_command(ctrl, ret); 237 238 return ret; 239 } 240 241 /* -------------------------------------------------------------------------- */ 242 243 static void ucsi_pwr_opmode_change(struct ucsi_connector *con) 244 { 245 switch (con->status.pwr_op_mode) { 246 case UCSI_CONSTAT_PWR_OPMODE_PD: 247 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD); 248 break; 249 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5: 250 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A); 251 break; 252 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0: 253 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A); 254 break; 255 default: 256 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB); 257 break; 258 } 259 } 260 261 static int ucsi_register_partner(struct ucsi_connector *con) 262 { 263 struct typec_partner_desc desc; 264 struct typec_partner *partner; 265 266 if (con->partner) 267 return 0; 268 269 memset(&desc, 0, sizeof(desc)); 270 271 switch (con->status.partner_type) { 272 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG: 273 desc.accessory = TYPEC_ACCESSORY_DEBUG; 274 break; 275 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO: 276 desc.accessory = TYPEC_ACCESSORY_AUDIO; 277 break; 278 default: 279 break; 280 } 281 282 desc.usb_pd = con->status.pwr_op_mode == UCSI_CONSTAT_PWR_OPMODE_PD; 283 284 partner = typec_register_partner(con->port, &desc); 285 if (IS_ERR(partner)) { 286 dev_err(con->ucsi->dev, 287 "con%d: failed to register partner (%ld)\n", con->num, 288 PTR_ERR(partner)); 289 return PTR_ERR(partner); 290 } 291 292 con->partner = partner; 293 294 return 0; 295 } 296 297 static void ucsi_unregister_partner(struct ucsi_connector *con) 298 { 299 if (!con->partner) 300 return; 301 302 typec_unregister_partner(con->partner); 303 con->partner = NULL; 304 } 305 306 static void ucsi_connector_change(struct work_struct *work) 307 { 308 struct ucsi_connector *con = container_of(work, struct ucsi_connector, 309 work); 310 struct ucsi *ucsi = con->ucsi; 311 struct ucsi_control ctrl; 312 int ret; 313 314 mutex_lock(&ucsi->ppm_lock); 315 316 UCSI_CMD_GET_CONNECTOR_STATUS(ctrl, con->num); 317 ret = ucsi_run_command(ucsi, &ctrl, &con->status, sizeof(con->status)); 318 if (ret < 0) { 319 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n", 320 __func__, ret); 321 goto out_unlock; 322 } 323 324 if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE) 325 ucsi_pwr_opmode_change(con); 326 327 if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) { 328 typec_set_pwr_role(con->port, con->status.pwr_dir); 329 330 /* Complete pending power role swap */ 331 if (!completion_done(&con->complete)) 332 complete(&con->complete); 333 } 334 335 if (con->status.change & UCSI_CONSTAT_PARTNER_CHANGE) { 336 switch (con->status.partner_type) { 337 case UCSI_CONSTAT_PARTNER_TYPE_UFP: 338 typec_set_data_role(con->port, TYPEC_HOST); 339 break; 340 case UCSI_CONSTAT_PARTNER_TYPE_DFP: 341 typec_set_data_role(con->port, TYPEC_DEVICE); 342 break; 343 default: 344 break; 345 } 346 347 /* Complete pending data role swap */ 348 if (!completion_done(&con->complete)) 349 complete(&con->complete); 350 } 351 352 if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) { 353 typec_set_pwr_role(con->port, con->status.pwr_dir); 354 355 switch (con->status.partner_type) { 356 case UCSI_CONSTAT_PARTNER_TYPE_UFP: 357 typec_set_data_role(con->port, TYPEC_HOST); 358 break; 359 case UCSI_CONSTAT_PARTNER_TYPE_DFP: 360 typec_set_data_role(con->port, TYPEC_DEVICE); 361 break; 362 default: 363 break; 364 } 365 366 if (con->status.connected) 367 ucsi_register_partner(con); 368 else 369 ucsi_unregister_partner(con); 370 } 371 372 ret = ucsi_ack(ucsi, UCSI_ACK_EVENT); 373 if (ret) 374 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret); 375 376 trace_ucsi_connector_change(con->num, &con->status); 377 378 out_unlock: 379 clear_bit(EVENT_PENDING, &ucsi->flags); 380 mutex_unlock(&ucsi->ppm_lock); 381 } 382 383 /** 384 * ucsi_notify - PPM notification handler 385 * @ucsi: Source UCSI Interface for the notifications 386 * 387 * Handle notifications from PPM of @ucsi. 388 */ 389 void ucsi_notify(struct ucsi *ucsi) 390 { 391 struct ucsi_cci *cci; 392 393 /* There is no requirement to sync here, but no harm either. */ 394 ucsi_sync(ucsi); 395 396 cci = &ucsi->ppm->data->cci; 397 398 if (cci->error) 399 ucsi->status = UCSI_ERROR; 400 else if (cci->busy) 401 ucsi->status = UCSI_BUSY; 402 else 403 ucsi->status = UCSI_IDLE; 404 405 if (cci->cmd_complete && test_bit(COMMAND_PENDING, &ucsi->flags)) { 406 complete(&ucsi->complete); 407 } else if (cci->ack_complete && test_bit(ACK_PENDING, &ucsi->flags)) { 408 complete(&ucsi->complete); 409 } else if (cci->connector_change) { 410 struct ucsi_connector *con; 411 412 con = &ucsi->connector[cci->connector_change - 1]; 413 414 if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags)) 415 schedule_work(&con->work); 416 } 417 418 trace_ucsi_notify(ucsi->ppm->data->raw_cci); 419 } 420 EXPORT_SYMBOL_GPL(ucsi_notify); 421 422 /* -------------------------------------------------------------------------- */ 423 424 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard) 425 { 426 struct ucsi_control ctrl; 427 428 UCSI_CMD_CONNECTOR_RESET(ctrl, con, hard); 429 430 return ucsi_run_command(con->ucsi, &ctrl, NULL, 0); 431 } 432 433 static int ucsi_reset_ppm(struct ucsi *ucsi) 434 { 435 struct ucsi_control ctrl; 436 unsigned long tmo; 437 int ret; 438 439 ctrl.raw_cmd = 0; 440 ctrl.cmd.cmd = UCSI_PPM_RESET; 441 trace_ucsi_command(&ctrl); 442 ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl); 443 if (ret) 444 goto err; 445 446 tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS); 447 448 do { 449 /* Here sync is critical. */ 450 ret = ucsi_sync(ucsi); 451 if (ret) 452 goto err; 453 454 if (ucsi->ppm->data->cci.reset_complete) 455 break; 456 457 /* If the PPM is still doing something else, reset it again. */ 458 if (ucsi->ppm->data->raw_cci) { 459 dev_warn_ratelimited(ucsi->dev, 460 "Failed to reset PPM! Trying again..\n"); 461 462 trace_ucsi_command(&ctrl); 463 ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl); 464 if (ret) 465 goto err; 466 } 467 468 /* Letting the PPM settle down. */ 469 msleep(20); 470 471 ret = -ETIMEDOUT; 472 } while (time_is_after_jiffies(tmo)); 473 474 err: 475 trace_ucsi_reset_ppm(&ctrl, ret); 476 477 return ret; 478 } 479 480 static int ucsi_role_cmd(struct ucsi_connector *con, struct ucsi_control *ctrl) 481 { 482 int ret; 483 484 ret = ucsi_run_command(con->ucsi, ctrl, NULL, 0); 485 if (ret == -ETIMEDOUT) { 486 struct ucsi_control c; 487 488 /* PPM most likely stopped responding. Resetting everything. */ 489 ucsi_reset_ppm(con->ucsi); 490 491 UCSI_CMD_SET_NTFY_ENABLE(c, UCSI_ENABLE_NTFY_ALL); 492 ucsi_run_command(con->ucsi, &c, NULL, 0); 493 494 ucsi_reset_connector(con, true); 495 } 496 497 return ret; 498 } 499 500 static int 501 ucsi_dr_swap(const struct typec_capability *cap, enum typec_data_role role) 502 { 503 struct ucsi_connector *con = to_ucsi_connector(cap); 504 struct ucsi_control ctrl; 505 int ret = 0; 506 507 if (!con->partner) 508 return -ENOTCONN; 509 510 mutex_lock(&con->ucsi->ppm_lock); 511 512 if ((con->status.partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP && 513 role == TYPEC_DEVICE) || 514 (con->status.partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP && 515 role == TYPEC_HOST)) 516 goto out_unlock; 517 518 UCSI_CMD_SET_UOR(ctrl, con, role); 519 ret = ucsi_role_cmd(con, &ctrl); 520 if (ret < 0) 521 goto out_unlock; 522 523 mutex_unlock(&con->ucsi->ppm_lock); 524 525 if (!wait_for_completion_timeout(&con->complete, 526 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) 527 return -ETIMEDOUT; 528 529 return 0; 530 531 out_unlock: 532 mutex_unlock(&con->ucsi->ppm_lock); 533 534 return ret; 535 } 536 537 static int 538 ucsi_pr_swap(const struct typec_capability *cap, enum typec_role role) 539 { 540 struct ucsi_connector *con = to_ucsi_connector(cap); 541 struct ucsi_control ctrl; 542 int ret = 0; 543 544 if (!con->partner) 545 return -ENOTCONN; 546 547 mutex_lock(&con->ucsi->ppm_lock); 548 549 if (con->status.pwr_dir == role) 550 goto out_unlock; 551 552 UCSI_CMD_SET_PDR(ctrl, con, role); 553 ret = ucsi_role_cmd(con, &ctrl); 554 if (ret < 0) 555 goto out_unlock; 556 557 mutex_unlock(&con->ucsi->ppm_lock); 558 559 if (!wait_for_completion_timeout(&con->complete, 560 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) 561 return -ETIMEDOUT; 562 563 mutex_lock(&con->ucsi->ppm_lock); 564 565 /* Something has gone wrong while swapping the role */ 566 if (con->status.pwr_op_mode != UCSI_CONSTAT_PWR_OPMODE_PD) { 567 ucsi_reset_connector(con, true); 568 ret = -EPROTO; 569 } 570 571 out_unlock: 572 mutex_unlock(&con->ucsi->ppm_lock); 573 574 return ret; 575 } 576 577 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con) 578 { 579 struct fwnode_handle *fwnode; 580 int i = 1; 581 582 device_for_each_child_node(con->ucsi->dev, fwnode) 583 if (i++ == con->num) 584 return fwnode; 585 return NULL; 586 } 587 588 static int ucsi_register_port(struct ucsi *ucsi, int index) 589 { 590 struct ucsi_connector *con = &ucsi->connector[index]; 591 struct typec_capability *cap = &con->typec_cap; 592 enum typec_accessory *accessory = cap->accessory; 593 struct ucsi_control ctrl; 594 int ret; 595 596 INIT_WORK(&con->work, ucsi_connector_change); 597 init_completion(&con->complete); 598 con->num = index + 1; 599 con->ucsi = ucsi; 600 601 /* Get connector capability */ 602 UCSI_CMD_GET_CONNECTOR_CAPABILITY(ctrl, con->num); 603 ret = ucsi_run_command(ucsi, &ctrl, &con->cap, sizeof(con->cap)); 604 if (ret < 0) 605 return ret; 606 607 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP) 608 cap->data = TYPEC_PORT_DRD; 609 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP) 610 cap->data = TYPEC_PORT_DFP; 611 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP) 612 cap->data = TYPEC_PORT_UFP; 613 614 if (con->cap.provider && con->cap.consumer) 615 cap->type = TYPEC_PORT_DRP; 616 else if (con->cap.provider) 617 cap->type = TYPEC_PORT_SRC; 618 else if (con->cap.consumer) 619 cap->type = TYPEC_PORT_SNK; 620 621 cap->revision = ucsi->cap.typec_version; 622 cap->pd_revision = ucsi->cap.pd_version; 623 cap->prefer_role = TYPEC_NO_PREFERRED_ROLE; 624 625 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY) 626 *accessory++ = TYPEC_ACCESSORY_AUDIO; 627 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY) 628 *accessory = TYPEC_ACCESSORY_DEBUG; 629 630 cap->fwnode = ucsi_find_fwnode(con); 631 cap->dr_set = ucsi_dr_swap; 632 cap->pr_set = ucsi_pr_swap; 633 634 /* Register the connector */ 635 con->port = typec_register_port(ucsi->dev, cap); 636 if (IS_ERR(con->port)) 637 return PTR_ERR(con->port); 638 639 /* Get the status */ 640 UCSI_CMD_GET_CONNECTOR_STATUS(ctrl, con->num); 641 ret = ucsi_run_command(ucsi, &ctrl, &con->status, sizeof(con->status)); 642 if (ret < 0) { 643 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num); 644 return 0; 645 } 646 647 ucsi_pwr_opmode_change(con); 648 typec_set_pwr_role(con->port, con->status.pwr_dir); 649 650 switch (con->status.partner_type) { 651 case UCSI_CONSTAT_PARTNER_TYPE_UFP: 652 typec_set_data_role(con->port, TYPEC_HOST); 653 break; 654 case UCSI_CONSTAT_PARTNER_TYPE_DFP: 655 typec_set_data_role(con->port, TYPEC_DEVICE); 656 break; 657 default: 658 break; 659 } 660 661 /* Check if there is already something connected */ 662 if (con->status.connected) 663 ucsi_register_partner(con); 664 665 trace_ucsi_register_port(con->num, &con->status); 666 667 return 0; 668 } 669 670 static void ucsi_init(struct work_struct *work) 671 { 672 struct ucsi *ucsi = container_of(work, struct ucsi, work); 673 struct ucsi_connector *con; 674 struct ucsi_control ctrl; 675 int ret; 676 int i; 677 678 mutex_lock(&ucsi->ppm_lock); 679 680 /* Reset the PPM */ 681 ret = ucsi_reset_ppm(ucsi); 682 if (ret) { 683 dev_err(ucsi->dev, "failed to reset PPM!\n"); 684 goto err; 685 } 686 687 /* Enable basic notifications */ 688 UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_CMD_COMPLETE | 689 UCSI_ENABLE_NTFY_ERROR); 690 ret = ucsi_run_command(ucsi, &ctrl, NULL, 0); 691 if (ret < 0) 692 goto err_reset; 693 694 /* Get PPM capabilities */ 695 UCSI_CMD_GET_CAPABILITY(ctrl); 696 ret = ucsi_run_command(ucsi, &ctrl, &ucsi->cap, sizeof(ucsi->cap)); 697 if (ret < 0) 698 goto err_reset; 699 700 if (!ucsi->cap.num_connectors) { 701 ret = -ENODEV; 702 goto err_reset; 703 } 704 705 /* Allocate the connectors. Released in ucsi_unregister_ppm() */ 706 ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1, 707 sizeof(*ucsi->connector), GFP_KERNEL); 708 if (!ucsi->connector) { 709 ret = -ENOMEM; 710 goto err_reset; 711 } 712 713 /* Register all connectors */ 714 for (i = 0; i < ucsi->cap.num_connectors; i++) { 715 ret = ucsi_register_port(ucsi, i); 716 if (ret) 717 goto err_unregister; 718 } 719 720 /* Enable all notifications */ 721 UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_ALL); 722 ret = ucsi_run_command(ucsi, &ctrl, NULL, 0); 723 if (ret < 0) 724 goto err_unregister; 725 726 mutex_unlock(&ucsi->ppm_lock); 727 728 return; 729 730 err_unregister: 731 for (con = ucsi->connector; con->port; con++) { 732 ucsi_unregister_partner(con); 733 typec_unregister_port(con->port); 734 con->port = NULL; 735 } 736 737 err_reset: 738 ucsi_reset_ppm(ucsi); 739 err: 740 mutex_unlock(&ucsi->ppm_lock); 741 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret); 742 } 743 744 /** 745 * ucsi_register_ppm - Register UCSI PPM Interface 746 * @dev: Device interface to the PPM 747 * @ppm: The PPM interface 748 * 749 * Allocates UCSI instance, associates it with @ppm and returns it to the 750 * caller, and schedules initialization of the interface. 751 */ 752 struct ucsi *ucsi_register_ppm(struct device *dev, struct ucsi_ppm *ppm) 753 { 754 struct ucsi *ucsi; 755 756 ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL); 757 if (!ucsi) 758 return ERR_PTR(-ENOMEM); 759 760 INIT_WORK(&ucsi->work, ucsi_init); 761 init_completion(&ucsi->complete); 762 mutex_init(&ucsi->ppm_lock); 763 764 ucsi->dev = dev; 765 ucsi->ppm = ppm; 766 767 /* 768 * Communication with the PPM takes a lot of time. It is not reasonable 769 * to initialize the driver here. Using a work for now. 770 */ 771 queue_work(system_long_wq, &ucsi->work); 772 773 return ucsi; 774 } 775 EXPORT_SYMBOL_GPL(ucsi_register_ppm); 776 777 /** 778 * ucsi_unregister_ppm - Unregister UCSI PPM Interface 779 * @ucsi: struct ucsi associated with the PPM 780 * 781 * Unregister UCSI PPM that was created with ucsi_register(). 782 */ 783 void ucsi_unregister_ppm(struct ucsi *ucsi) 784 { 785 struct ucsi_control ctrl; 786 int i; 787 788 /* Make sure that we are not in the middle of driver initialization */ 789 cancel_work_sync(&ucsi->work); 790 791 mutex_lock(&ucsi->ppm_lock); 792 793 /* Disable everything except command complete notification */ 794 UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_CMD_COMPLETE) 795 ucsi_run_command(ucsi, &ctrl, NULL, 0); 796 797 mutex_unlock(&ucsi->ppm_lock); 798 799 for (i = 0; i < ucsi->cap.num_connectors; i++) { 800 cancel_work_sync(&ucsi->connector[i].work); 801 ucsi_unregister_partner(&ucsi->connector[i]); 802 typec_unregister_port(ucsi->connector[i].port); 803 } 804 805 ucsi_reset_ppm(ucsi); 806 807 kfree(ucsi->connector); 808 kfree(ucsi); 809 } 810 EXPORT_SYMBOL_GPL(ucsi_unregister_ppm); 811 812 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); 813 MODULE_LICENSE("GPL v2"); 814 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver"); 815