drivers/usb/typec/ucsi/ucsi.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
ucsi_sync
ucsi_command
ucsi_ack
ucsi_run_command
ucsi_send_command
ucsi_resume
ucsi_altmode_update_active
ucsi_altmode_next_mode
ucsi_next_altmode
ucsi_register_altmode
ucsi_register_altmodes
ucsi_unregister_altmodes
ucsi_pwr_opmode_change
ucsi_register_partner
ucsi_unregister_partner
ucsi_partner_change
ucsi_connector_change
ucsi_notify
ucsi_reset_connector
ucsi_reset_ppm
ucsi_role_cmd
ucsi_dr_swap
ucsi_pr_swap
ucsi_find_fwnode
ucsi_register_port
ucsi_init
ucsi_register_ppm
ucsi_unregister_ppm
   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 #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 static inline int ucsi_sync(struct ucsi *ucsi)
  43 {
  44         if (ucsi->ppm && ucsi->ppm->sync)
  45                 return ucsi->ppm->sync(ucsi->ppm);
  46         return 0;
  47 }
  48 
  49 static int ucsi_command(struct ucsi *ucsi, struct ucsi_control *ctrl)
  50 {
  51         int ret;
  52 
  53         trace_ucsi_command(ctrl);
  54 
  55         set_bit(COMMAND_PENDING, &ucsi->flags);
  56 
  57         ret = ucsi->ppm->cmd(ucsi->ppm, ctrl);
  58         if (ret)
  59                 goto err_clear_flag;
  60 
  61         if (!wait_for_completion_timeout(&ucsi->complete,
  62                                          msecs_to_jiffies(UCSI_TIMEOUT_MS))) {
  63                 dev_warn(ucsi->dev, "PPM NOT RESPONDING\n");
  64                 ret = -ETIMEDOUT;
  65         }
  66 
  67 err_clear_flag:
  68         clear_bit(COMMAND_PENDING, &ucsi->flags);
  69 
  70         return ret;
  71 }
  72 
  73 static int ucsi_ack(struct ucsi *ucsi, u8 ack)
  74 {
  75         struct ucsi_control ctrl;
  76         int ret;
  77 
  78         trace_ucsi_ack(ack);
  79 
  80         set_bit(ACK_PENDING, &ucsi->flags);
  81 
  82         UCSI_CMD_ACK(ctrl, ack);
  83         ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);
  84         if (ret)
  85                 goto out_clear_bit;
  86 
  87         /* Waiting for ACK with ACK CMD, but not with EVENT for now */
  88         if (ack == UCSI_ACK_EVENT)
  89                 goto out_clear_bit;
  90 
  91         if (!wait_for_completion_timeout(&ucsi->complete,
  92                                          msecs_to_jiffies(UCSI_TIMEOUT_MS)))
  93                 ret = -ETIMEDOUT;
  94 
  95 out_clear_bit:
  96         clear_bit(ACK_PENDING, &ucsi->flags);
  97 
  98         if (ret)
  99                 dev_err(ucsi->dev, "%s: failed\n", __func__);
 100 
 101         return ret;
 102 }
 103 
 104 static int ucsi_run_command(struct ucsi *ucsi, struct ucsi_control *ctrl,
 105                             void *data, size_t size)
 106 {
 107         struct ucsi_control _ctrl;
 108         u8 data_length;
 109         u16 error;
 110         int ret;
 111 
 112         ret = ucsi_command(ucsi, ctrl);
 113         if (ret)
 114                 goto err;
 115 
 116         switch (ucsi->status) {
 117         case UCSI_IDLE:
 118                 ret = ucsi_sync(ucsi);
 119                 if (ret)
 120                         dev_warn(ucsi->dev, "%s: sync failed\n", __func__);
 121 
 122                 if (data)
 123                         memcpy(data, ucsi->ppm->data->message_in, size);
 124 
 125                 data_length = ucsi->ppm->data->cci.data_length;
 126 
 127                 ret = ucsi_ack(ucsi, UCSI_ACK_CMD);
 128                 if (!ret)
 129                         ret = data_length;
 130                 break;
 131         case UCSI_BUSY:
 132                 /* The caller decides whether to cancel or not */
 133                 ret = -EBUSY;
 134                 break;
 135         case UCSI_ERROR:
 136                 ret = ucsi_ack(ucsi, UCSI_ACK_CMD);
 137                 if (ret)
 138                         break;
 139 
 140                 _ctrl.raw_cmd = 0;
 141                 _ctrl.cmd.cmd = UCSI_GET_ERROR_STATUS;
 142                 ret = ucsi_command(ucsi, &_ctrl);
 143                 if (ret) {
 144                         dev_err(ucsi->dev, "reading error failed!\n");
 145                         break;
 146                 }
 147 
 148                 memcpy(&error, ucsi->ppm->data->message_in, sizeof(error));
 149 
 150                 /* Something has really gone wrong */
 151                 if (WARN_ON(ucsi->status == UCSI_ERROR)) {
 152                         ret = -ENODEV;
 153                         break;
 154                 }
 155 
 156                 ret = ucsi_ack(ucsi, UCSI_ACK_CMD);
 157                 if (ret)
 158                         break;
 159 
 160                 switch (error) {
 161                 case UCSI_ERROR_INCOMPATIBLE_PARTNER:
 162                         ret = -EOPNOTSUPP;
 163                         break;
 164                 case UCSI_ERROR_CC_COMMUNICATION_ERR:
 165                         ret = -ECOMM;
 166                         break;
 167                 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL:
 168                         ret = -EPROTO;
 169                         break;
 170                 case UCSI_ERROR_DEAD_BATTERY:
 171                         dev_warn(ucsi->dev, "Dead battery condition!\n");
 172                         ret = -EPERM;
 173                         break;
 174                 /* The following mean a bug in this driver */
 175                 case UCSI_ERROR_INVALID_CON_NUM:
 176                 case UCSI_ERROR_UNREGONIZED_CMD:
 177                 case UCSI_ERROR_INVALID_CMD_ARGUMENT:
 178                         dev_warn(ucsi->dev,
 179                                  "%s: possible UCSI driver bug - error 0x%x\n",
 180                                  __func__, error);
 181                         ret = -EINVAL;
 182                         break;
 183                 default:
 184                         dev_warn(ucsi->dev,
 185                                  "%s: error without status\n", __func__);
 186                         ret = -EIO;
 187                         break;
 188                 }
 189                 break;
 190         }
 191 
 192 err:
 193         trace_ucsi_run_command(ctrl, ret);
 194 
 195         return ret;
 196 }
 197 
 198 int ucsi_send_command(struct ucsi *ucsi, struct ucsi_control *ctrl,
 199                       void *retval, size_t size)
 200 {
 201         int ret;
 202 
 203         mutex_lock(&ucsi->ppm_lock);
 204         ret = ucsi_run_command(ucsi, ctrl, retval, size);
 205         mutex_unlock(&ucsi->ppm_lock);
 206 
 207         return ret;
 208 }
 209 EXPORT_SYMBOL_GPL(ucsi_send_command);
 210 
 211 int ucsi_resume(struct ucsi *ucsi)
 212 {
 213         struct ucsi_control ctrl;
 214 
 215         /* Restore UCSI notification enable mask after system resume */
 216         UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_ALL);
 217         return ucsi_send_command(ucsi, &ctrl, NULL, 0);
 218 }
 219 EXPORT_SYMBOL_GPL(ucsi_resume);
 220 /* -------------------------------------------------------------------------- */
 221 
 222 void ucsi_altmode_update_active(struct ucsi_connector *con)
 223 {
 224         const struct typec_altmode *altmode = NULL;
 225         struct ucsi_control ctrl;
 226         int ret;
 227         u8 cur;
 228         int i;
 229 
 230         UCSI_CMD_GET_CURRENT_CAM(ctrl, con->num);
 231         ret = ucsi_run_command(con->ucsi, &ctrl, &cur, sizeof(cur));
 232         if (ret < 0) {
 233                 if (con->ucsi->ppm->data->version > 0x0100) {
 234                         dev_err(con->ucsi->dev,
 235                                 "GET_CURRENT_CAM command failed\n");
 236                         return;
 237                 }
 238                 cur = 0xff;
 239         }
 240 
 241         if (cur < UCSI_MAX_ALTMODES)
 242                 altmode = typec_altmode_get_partner(con->port_altmode[cur]);
 243 
 244         for (i = 0; con->partner_altmode[i]; i++)
 245                 typec_altmode_update_active(con->partner_altmode[i],
 246                                             con->partner_altmode[i] == altmode);
 247 }
 248 
 249 static u8 ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid)
 250 {
 251         u8 mode = 1;
 252         int i;
 253 
 254         for (i = 0; alt[i]; i++)
 255                 if (alt[i]->svid == svid)
 256                         mode++;
 257 
 258         return mode;
 259 }
 260 
 261 static int ucsi_next_altmode(struct typec_altmode **alt)
 262 {
 263         int i = 0;
 264 
 265         for (i = 0; i < UCSI_MAX_ALTMODES; i++)
 266                 if (!alt[i])
 267                         return i;
 268 
 269         return -ENOENT;
 270 }
 271 
 272 static int ucsi_register_altmode(struct ucsi_connector *con,
 273                                  struct typec_altmode_desc *desc,
 274                                  u8 recipient)
 275 {
 276         struct typec_altmode *alt;
 277         bool override;
 278         int ret;
 279         int i;
 280 
 281         override = !!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_OVERRIDE);
 282 
 283         switch (recipient) {
 284         case UCSI_RECIPIENT_CON:
 285                 i = ucsi_next_altmode(con->port_altmode);
 286                 if (i < 0) {
 287                         ret = i;
 288                         goto err;
 289                 }
 290 
 291                 desc->mode = ucsi_altmode_next_mode(con->port_altmode,
 292                                                     desc->svid);
 293 
 294                 switch (desc->svid) {
 295                 case USB_TYPEC_DP_SID:
 296                 case USB_TYPEC_NVIDIA_VLINK_SID:
 297                         alt = ucsi_register_displayport(con, override, i, desc);
 298                         break;
 299                 default:
 300                         alt = typec_port_register_altmode(con->port, desc);
 301                         break;
 302                 }
 303 
 304                 if (IS_ERR(alt)) {
 305                         ret = PTR_ERR(alt);
 306                         goto err;
 307                 }
 308 
 309                 con->port_altmode[i] = alt;
 310                 break;
 311         case UCSI_RECIPIENT_SOP:
 312                 i = ucsi_next_altmode(con->partner_altmode);
 313                 if (i < 0) {
 314                         ret = i;
 315                         goto err;
 316                 }
 317 
 318                 desc->mode = ucsi_altmode_next_mode(con->partner_altmode,
 319                                                     desc->svid);
 320 
 321                 alt = typec_partner_register_altmode(con->partner, desc);
 322                 if (IS_ERR(alt)) {
 323                         ret = PTR_ERR(alt);
 324                         goto err;
 325                 }
 326 
 327                 con->partner_altmode[i] = alt;
 328                 break;
 329         default:
 330                 return -EINVAL;
 331         }
 332 
 333         trace_ucsi_register_altmode(recipient, alt);
 334 
 335         return 0;
 336 
 337 err:
 338         dev_err(con->ucsi->dev, "failed to registers svid 0x%04x mode %d\n",
 339                 desc->svid, desc->mode);
 340 
 341         return ret;
 342 }
 343 
 344 static int ucsi_register_altmodes(struct ucsi_connector *con, u8 recipient)
 345 {
 346         int max_altmodes = UCSI_MAX_ALTMODES;
 347         struct typec_altmode_desc desc;
 348         struct ucsi_altmode alt[2];
 349         struct ucsi_control ctrl;
 350         int num = 1;
 351         int ret;
 352         int len;
 353         int j;
 354         int i;
 355 
 356         if (!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS))
 357                 return 0;
 358 
 359         if (recipient == UCSI_RECIPIENT_SOP && con->partner_altmode[0])
 360                 return 0;
 361 
 362         if (recipient == UCSI_RECIPIENT_CON)
 363                 max_altmodes = con->ucsi->cap.num_alt_modes;
 364 
 365         for (i = 0; i < max_altmodes;) {
 366                 memset(alt, 0, sizeof(alt));
 367                 UCSI_CMD_GET_ALTERNATE_MODES(ctrl, recipient, con->num, i, 1);
 368                 len = ucsi_run_command(con->ucsi, &ctrl, alt, sizeof(alt));
 369                 if (len <= 0)
 370                         return len;
 371 
 372                 /*
 373                  * This code is requesting one alt mode at a time, but some PPMs
 374                  * may still return two. If that happens both alt modes need be
 375                  * registered and the offset for the next alt mode has to be
 376                  * incremented.
 377                  */
 378                 num = len / sizeof(alt[0]);
 379                 i += num;
 380 
 381                 for (j = 0; j < num; j++) {
 382                         if (!alt[j].svid)
 383                                 return 0;
 384 
 385                         memset(&desc, 0, sizeof(desc));
 386                         desc.vdo = alt[j].mid;
 387                         desc.svid = alt[j].svid;
 388                         desc.roles = TYPEC_PORT_DRD;
 389 
 390                         ret = ucsi_register_altmode(con, &desc, recipient);
 391                         if (ret)
 392                                 return ret;
 393                 }
 394         }
 395 
 396         return 0;
 397 }
 398 
 399 static void ucsi_unregister_altmodes(struct ucsi_connector *con, u8 recipient)
 400 {
 401         const struct typec_altmode *pdev;
 402         struct typec_altmode **adev;
 403         int i = 0;
 404 
 405         switch (recipient) {
 406         case UCSI_RECIPIENT_CON:
 407                 adev = con->port_altmode;
 408                 break;
 409         case UCSI_RECIPIENT_SOP:
 410                 adev = con->partner_altmode;
 411                 break;
 412         default:
 413                 return;
 414         }
 415 
 416         while (adev[i]) {
 417                 if (recipient == UCSI_RECIPIENT_SOP &&
 418                     (adev[i]->svid == USB_TYPEC_DP_SID ||
 419                         adev[i]->svid == USB_TYPEC_NVIDIA_VLINK_SID)) {
 420                         pdev = typec_altmode_get_partner(adev[i]);
 421                         ucsi_displayport_remove_partner((void *)pdev);
 422                 }
 423                 typec_unregister_altmode(adev[i]);
 424                 adev[i++] = NULL;
 425         }
 426 }
 427 
 428 static void ucsi_pwr_opmode_change(struct ucsi_connector *con)
 429 {
 430         switch (con->status.pwr_op_mode) {
 431         case UCSI_CONSTAT_PWR_OPMODE_PD:
 432                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD);
 433                 break;
 434         case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5:
 435                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A);
 436                 break;
 437         case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0:
 438                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A);
 439                 break;
 440         default:
 441                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB);
 442                 break;
 443         }
 444 }
 445 
 446 static int ucsi_register_partner(struct ucsi_connector *con)
 447 {
 448         struct typec_partner_desc desc;
 449         struct typec_partner *partner;
 450 
 451         if (con->partner)
 452                 return 0;
 453 
 454         memset(&desc, 0, sizeof(desc));
 455 
 456         switch (con->status.partner_type) {
 457         case UCSI_CONSTAT_PARTNER_TYPE_DEBUG:
 458                 desc.accessory = TYPEC_ACCESSORY_DEBUG;
 459                 break;
 460         case UCSI_CONSTAT_PARTNER_TYPE_AUDIO:
 461                 desc.accessory = TYPEC_ACCESSORY_AUDIO;
 462                 break;
 463         default:
 464                 break;
 465         }
 466 
 467         desc.usb_pd = con->status.pwr_op_mode == UCSI_CONSTAT_PWR_OPMODE_PD;
 468 
 469         partner = typec_register_partner(con->port, &desc);
 470         if (IS_ERR(partner)) {
 471                 dev_err(con->ucsi->dev,
 472                         "con%d: failed to register partner (%ld)\n", con->num,
 473                         PTR_ERR(partner));
 474                 return PTR_ERR(partner);
 475         }
 476 
 477         con->partner = partner;
 478 
 479         return 0;
 480 }
 481 
 482 static void ucsi_unregister_partner(struct ucsi_connector *con)
 483 {
 484         if (!con->partner)
 485                 return;
 486 
 487         ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP);
 488         typec_unregister_partner(con->partner);
 489         con->partner = NULL;
 490 }
 491 
 492 static void ucsi_partner_change(struct ucsi_connector *con)
 493 {
 494         int ret;
 495 
 496         if (!con->partner)
 497                 return;
 498 
 499         switch (con->status.partner_type) {
 500         case UCSI_CONSTAT_PARTNER_TYPE_UFP:
 501                 typec_set_data_role(con->port, TYPEC_HOST);
 502                 break;
 503         case UCSI_CONSTAT_PARTNER_TYPE_DFP:
 504                 typec_set_data_role(con->port, TYPEC_DEVICE);
 505                 break;
 506         default:
 507                 break;
 508         }
 509 
 510         /* Complete pending data role swap */
 511         if (!completion_done(&con->complete))
 512                 complete(&con->complete);
 513 
 514         /* Can't rely on Partner Flags field. Always checking the alt modes. */
 515         ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
 516         if (ret)
 517                 dev_err(con->ucsi->dev,
 518                         "con%d: failed to register partner alternate modes\n",
 519                         con->num);
 520         else
 521                 ucsi_altmode_update_active(con);
 522 }
 523 
 524 static void ucsi_connector_change(struct work_struct *work)
 525 {
 526         struct ucsi_connector *con = container_of(work, struct ucsi_connector,
 527                                                   work);
 528         struct ucsi *ucsi = con->ucsi;
 529         struct ucsi_control ctrl;
 530         int ret;
 531 
 532         mutex_lock(&con->lock);
 533 
 534         UCSI_CMD_GET_CONNECTOR_STATUS(ctrl, con->num);
 535         ret = ucsi_send_command(ucsi, &ctrl, &con->status, sizeof(con->status));
 536         if (ret < 0) {
 537                 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
 538                         __func__, ret);
 539                 goto out_unlock;
 540         }
 541 
 542         if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE)
 543                 ucsi_pwr_opmode_change(con);
 544 
 545         if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) {
 546                 typec_set_pwr_role(con->port, con->status.pwr_dir);
 547 
 548                 /* Complete pending power role swap */
 549                 if (!completion_done(&con->complete))
 550                         complete(&con->complete);
 551         }
 552 
 553         if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
 554                 typec_set_pwr_role(con->port, con->status.pwr_dir);
 555 
 556                 switch (con->status.partner_type) {
 557                 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
 558                         typec_set_data_role(con->port, TYPEC_HOST);
 559                         break;
 560                 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
 561                         typec_set_data_role(con->port, TYPEC_DEVICE);
 562                         break;
 563                 default:
 564                         break;
 565                 }
 566 
 567                 if (con->status.connected)
 568                         ucsi_register_partner(con);
 569                 else
 570                         ucsi_unregister_partner(con);
 571         }
 572 
 573         if (con->status.change & UCSI_CONSTAT_CAM_CHANGE) {
 574                 /*
 575                  * We don't need to know the currently supported alt modes here.
 576                  * Running GET_CAM_SUPPORTED command just to make sure the PPM
 577                  * does not get stuck in case it assumes we do so.
 578                  */
 579                 UCSI_CMD_GET_CAM_SUPPORTED(ctrl, con->num);
 580                 ucsi_run_command(con->ucsi, &ctrl, NULL, 0);
 581         }
 582 
 583         if (con->status.change & UCSI_CONSTAT_PARTNER_CHANGE)
 584                 ucsi_partner_change(con);
 585 
 586         ret = ucsi_ack(ucsi, UCSI_ACK_EVENT);
 587         if (ret)
 588                 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
 589 
 590         trace_ucsi_connector_change(con->num, &con->status);
 591 
 592 out_unlock:
 593         clear_bit(EVENT_PENDING, &ucsi->flags);
 594         mutex_unlock(&con->lock);
 595 }
 596 
 597 /**
 598  * ucsi_notify - PPM notification handler
 599  * @ucsi: Source UCSI Interface for the notifications
 600  *
 601  * Handle notifications from PPM of @ucsi.
 602  */
 603 void ucsi_notify(struct ucsi *ucsi)
 604 {
 605         struct ucsi_cci *cci;
 606 
 607         /* There is no requirement to sync here, but no harm either. */
 608         ucsi_sync(ucsi);
 609 
 610         cci = &ucsi->ppm->data->cci;
 611 
 612         if (cci->error)
 613                 ucsi->status = UCSI_ERROR;
 614         else if (cci->busy)
 615                 ucsi->status = UCSI_BUSY;
 616         else
 617                 ucsi->status = UCSI_IDLE;
 618 
 619         if (cci->cmd_complete && test_bit(COMMAND_PENDING, &ucsi->flags)) {
 620                 complete(&ucsi->complete);
 621         } else if (cci->ack_complete && test_bit(ACK_PENDING, &ucsi->flags)) {
 622                 complete(&ucsi->complete);
 623         } else if (cci->connector_change) {
 624                 struct ucsi_connector *con;
 625 
 626                 con = &ucsi->connector[cci->connector_change - 1];
 627 
 628                 if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags))
 629                         schedule_work(&con->work);
 630         }
 631 
 632         trace_ucsi_notify(ucsi->ppm->data->raw_cci);
 633 }
 634 EXPORT_SYMBOL_GPL(ucsi_notify);
 635 
 636 /* -------------------------------------------------------------------------- */
 637 
 638 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard)
 639 {
 640         struct ucsi_control ctrl;
 641 
 642         UCSI_CMD_CONNECTOR_RESET(ctrl, con, hard);
 643 
 644         return ucsi_send_command(con->ucsi, &ctrl, NULL, 0);
 645 }
 646 
 647 static int ucsi_reset_ppm(struct ucsi *ucsi)
 648 {
 649         struct ucsi_control ctrl;
 650         unsigned long tmo;
 651         int ret;
 652 
 653         ctrl.raw_cmd = 0;
 654         ctrl.cmd.cmd = UCSI_PPM_RESET;
 655         trace_ucsi_command(&ctrl);
 656         ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);
 657         if (ret)
 658                 goto err;
 659 
 660         tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
 661 
 662         do {
 663                 /* Here sync is critical. */
 664                 ret = ucsi_sync(ucsi);
 665                 if (ret)
 666                         goto err;
 667 
 668                 if (ucsi->ppm->data->cci.reset_complete)
 669                         break;
 670 
 671                 /* If the PPM is still doing something else, reset it again. */
 672                 if (ucsi->ppm->data->raw_cci) {
 673                         dev_warn_ratelimited(ucsi->dev,
 674                                 "Failed to reset PPM! Trying again..\n");
 675 
 676                         trace_ucsi_command(&ctrl);
 677                         ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);
 678                         if (ret)
 679                                 goto err;
 680                 }
 681 
 682                 /* Letting the PPM settle down. */
 683                 msleep(20);
 684 
 685                 ret = -ETIMEDOUT;
 686         } while (time_is_after_jiffies(tmo));
 687 
 688 err:
 689         trace_ucsi_reset_ppm(&ctrl, ret);
 690 
 691         return ret;
 692 }
 693 
 694 static int ucsi_role_cmd(struct ucsi_connector *con, struct ucsi_control *ctrl)
 695 {
 696         int ret;
 697 
 698         ret = ucsi_send_command(con->ucsi, ctrl, NULL, 0);
 699         if (ret == -ETIMEDOUT) {
 700                 struct ucsi_control c;
 701 
 702                 /* PPM most likely stopped responding. Resetting everything. */
 703                 mutex_lock(&con->ucsi->ppm_lock);
 704                 ucsi_reset_ppm(con->ucsi);
 705                 mutex_unlock(&con->ucsi->ppm_lock);
 706 
 707                 UCSI_CMD_SET_NTFY_ENABLE(c, UCSI_ENABLE_NTFY_ALL);
 708                 ucsi_send_command(con->ucsi, &c, NULL, 0);
 709 
 710                 ucsi_reset_connector(con, true);
 711         }
 712 
 713         return ret;
 714 }
 715 
 716 static int
 717 ucsi_dr_swap(const struct typec_capability *cap, enum typec_data_role role)
 718 {
 719         struct ucsi_connector *con = to_ucsi_connector(cap);
 720         struct ucsi_control ctrl;
 721         int ret = 0;
 722 
 723         mutex_lock(&con->lock);
 724 
 725         if (!con->partner) {
 726                 ret = -ENOTCONN;
 727                 goto out_unlock;
 728         }
 729 
 730         if ((con->status.partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP &&
 731              role == TYPEC_DEVICE) ||
 732             (con->status.partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP &&
 733              role == TYPEC_HOST))
 734                 goto out_unlock;
 735 
 736         UCSI_CMD_SET_UOR(ctrl, con, role);
 737         ret = ucsi_role_cmd(con, &ctrl);
 738         if (ret < 0)
 739                 goto out_unlock;
 740 
 741         if (!wait_for_completion_timeout(&con->complete,
 742                                         msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
 743                 ret = -ETIMEDOUT;
 744 
 745 out_unlock:
 746         mutex_unlock(&con->lock);
 747 
 748         return ret < 0 ? ret : 0;
 749 }
 750 
 751 static int
 752 ucsi_pr_swap(const struct typec_capability *cap, enum typec_role role)
 753 {
 754         struct ucsi_connector *con = to_ucsi_connector(cap);
 755         struct ucsi_control ctrl;
 756         int ret = 0;
 757 
 758         mutex_lock(&con->lock);
 759 
 760         if (!con->partner) {
 761                 ret = -ENOTCONN;
 762                 goto out_unlock;
 763         }
 764 
 765         if (con->status.pwr_dir == role)
 766                 goto out_unlock;
 767 
 768         UCSI_CMD_SET_PDR(ctrl, con, role);
 769         ret = ucsi_role_cmd(con, &ctrl);
 770         if (ret < 0)
 771                 goto out_unlock;
 772 
 773         if (!wait_for_completion_timeout(&con->complete,
 774                                 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) {
 775                 ret = -ETIMEDOUT;
 776                 goto out_unlock;
 777         }
 778 
 779         /* Something has gone wrong while swapping the role */
 780         if (con->status.pwr_op_mode != UCSI_CONSTAT_PWR_OPMODE_PD) {
 781                 ucsi_reset_connector(con, true);
 782                 ret = -EPROTO;
 783         }
 784 
 785 out_unlock:
 786         mutex_unlock(&con->lock);
 787 
 788         return ret;
 789 }
 790 
 791 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con)
 792 {
 793         struct fwnode_handle *fwnode;
 794         int i = 1;
 795 
 796         device_for_each_child_node(con->ucsi->dev, fwnode)
 797                 if (i++ == con->num)
 798                         return fwnode;
 799         return NULL;
 800 }
 801 
 802 static int ucsi_register_port(struct ucsi *ucsi, int index)
 803 {
 804         struct ucsi_connector *con = &ucsi->connector[index];
 805         struct typec_capability *cap = &con->typec_cap;
 806         enum typec_accessory *accessory = cap->accessory;
 807         struct ucsi_control ctrl;
 808         int ret;
 809 
 810         INIT_WORK(&con->work, ucsi_connector_change);
 811         init_completion(&con->complete);
 812         mutex_init(&con->lock);
 813         con->num = index + 1;
 814         con->ucsi = ucsi;
 815 
 816         /* Get connector capability */
 817         UCSI_CMD_GET_CONNECTOR_CAPABILITY(ctrl, con->num);
 818         ret = ucsi_run_command(ucsi, &ctrl, &con->cap, sizeof(con->cap));
 819         if (ret < 0)
 820                 return ret;
 821 
 822         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP)
 823                 cap->data = TYPEC_PORT_DRD;
 824         else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP)
 825                 cap->data = TYPEC_PORT_DFP;
 826         else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP)
 827                 cap->data = TYPEC_PORT_UFP;
 828 
 829         if (con->cap.provider && con->cap.consumer)
 830                 cap->type = TYPEC_PORT_DRP;
 831         else if (con->cap.provider)
 832                 cap->type = TYPEC_PORT_SRC;
 833         else if (con->cap.consumer)
 834                 cap->type = TYPEC_PORT_SNK;
 835 
 836         cap->revision = ucsi->cap.typec_version;
 837         cap->pd_revision = ucsi->cap.pd_version;
 838         cap->prefer_role = TYPEC_NO_PREFERRED_ROLE;
 839 
 840         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY)
 841                 *accessory++ = TYPEC_ACCESSORY_AUDIO;
 842         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY)
 843                 *accessory = TYPEC_ACCESSORY_DEBUG;
 844 
 845         cap->fwnode = ucsi_find_fwnode(con);
 846         cap->dr_set = ucsi_dr_swap;
 847         cap->pr_set = ucsi_pr_swap;
 848 
 849         /* Register the connector */
 850         con->port = typec_register_port(ucsi->dev, cap);
 851         if (IS_ERR(con->port))
 852                 return PTR_ERR(con->port);
 853 
 854         /* Alternate modes */
 855         ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_CON);
 856         if (ret)
 857                 dev_err(ucsi->dev, "con%d: failed to register alt modes\n",
 858                         con->num);
 859 
 860         /* Get the status */
 861         UCSI_CMD_GET_CONNECTOR_STATUS(ctrl, con->num);
 862         ret = ucsi_run_command(ucsi, &ctrl, &con->status, sizeof(con->status));
 863         if (ret < 0) {
 864                 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num);
 865                 return 0;
 866         }
 867 
 868         ucsi_pwr_opmode_change(con);
 869         typec_set_pwr_role(con->port, con->status.pwr_dir);
 870 
 871         switch (con->status.partner_type) {
 872         case UCSI_CONSTAT_PARTNER_TYPE_UFP:
 873                 typec_set_data_role(con->port, TYPEC_HOST);
 874                 break;
 875         case UCSI_CONSTAT_PARTNER_TYPE_DFP:
 876                 typec_set_data_role(con->port, TYPEC_DEVICE);
 877                 break;
 878         default:
 879                 break;
 880         }
 881 
 882         /* Check if there is already something connected */
 883         if (con->status.connected)
 884                 ucsi_register_partner(con);
 885 
 886         if (con->partner) {
 887                 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
 888                 if (ret)
 889                         dev_err(ucsi->dev,
 890                                 "con%d: failed to register alternate modes\n",
 891                                 con->num);
 892                 else
 893                         ucsi_altmode_update_active(con);
 894         }
 895 
 896         trace_ucsi_register_port(con->num, &con->status);
 897 
 898         return 0;
 899 }
 900 
 901 static void ucsi_init(struct work_struct *work)
 902 {
 903         struct ucsi *ucsi = container_of(work, struct ucsi, work);
 904         struct ucsi_connector *con;
 905         struct ucsi_control ctrl;
 906         int ret;
 907         int i;
 908 
 909         mutex_lock(&ucsi->ppm_lock);
 910 
 911         /* Reset the PPM */
 912         ret = ucsi_reset_ppm(ucsi);
 913         if (ret) {
 914                 dev_err(ucsi->dev, "failed to reset PPM!\n");
 915                 goto err;
 916         }
 917 
 918         /* Enable basic notifications */
 919         UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_CMD_COMPLETE |
 920                                         UCSI_ENABLE_NTFY_ERROR);
 921         ret = ucsi_run_command(ucsi, &ctrl, NULL, 0);
 922         if (ret < 0)
 923                 goto err_reset;
 924 
 925         /* Get PPM capabilities */
 926         UCSI_CMD_GET_CAPABILITY(ctrl);
 927         ret = ucsi_run_command(ucsi, &ctrl, &ucsi->cap, sizeof(ucsi->cap));
 928         if (ret < 0)
 929                 goto err_reset;
 930 
 931         if (!ucsi->cap.num_connectors) {
 932                 ret = -ENODEV;
 933                 goto err_reset;
 934         }
 935 
 936         /* Allocate the connectors. Released in ucsi_unregister_ppm() */
 937         ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1,
 938                                   sizeof(*ucsi->connector), GFP_KERNEL);
 939         if (!ucsi->connector) {
 940                 ret = -ENOMEM;
 941                 goto err_reset;
 942         }
 943 
 944         /* Register all connectors */
 945         for (i = 0; i < ucsi->cap.num_connectors; i++) {
 946                 ret = ucsi_register_port(ucsi, i);
 947                 if (ret)
 948                         goto err_unregister;
 949         }
 950 
 951         /* Enable all notifications */
 952         UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_ALL);
 953         ret = ucsi_run_command(ucsi, &ctrl, NULL, 0);
 954         if (ret < 0)
 955                 goto err_unregister;
 956 
 957         mutex_unlock(&ucsi->ppm_lock);
 958 
 959         return;
 960 
 961 err_unregister:
 962         for (con = ucsi->connector; con->port; con++) {
 963                 ucsi_unregister_partner(con);
 964                 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON);
 965                 typec_unregister_port(con->port);
 966                 con->port = NULL;
 967         }
 968 
 969 err_reset:
 970         ucsi_reset_ppm(ucsi);
 971 err:
 972         mutex_unlock(&ucsi->ppm_lock);
 973         dev_err(ucsi->dev, "PPM init failed (%d)\n", ret);
 974 }
 975 
 976 /**
 977  * ucsi_register_ppm - Register UCSI PPM Interface
 978  * @dev: Device interface to the PPM
 979  * @ppm: The PPM interface
 980  *
 981  * Allocates UCSI instance, associates it with @ppm and returns it to the
 982  * caller, and schedules initialization of the interface.
 983  */
 984 struct ucsi *ucsi_register_ppm(struct device *dev, struct ucsi_ppm *ppm)
 985 {
 986         struct ucsi *ucsi;
 987 
 988         ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
 989         if (!ucsi)
 990                 return ERR_PTR(-ENOMEM);
 991 
 992         INIT_WORK(&ucsi->work, ucsi_init);
 993         init_completion(&ucsi->complete);
 994         mutex_init(&ucsi->ppm_lock);
 995 
 996         ucsi->dev = dev;
 997         ucsi->ppm = ppm;
 998 
 999         /*
1000          * Communication with the PPM takes a lot of time. It is not reasonable
1001          * to initialize the driver here. Using a work for now.
1002          */
1003         queue_work(system_long_wq, &ucsi->work);
1004 
1005         return ucsi;
1006 }
1007 EXPORT_SYMBOL_GPL(ucsi_register_ppm);
1008 
1009 /**
1010  * ucsi_unregister_ppm - Unregister UCSI PPM Interface
1011  * @ucsi: struct ucsi associated with the PPM
1012  *
1013  * Unregister UCSI PPM that was created with ucsi_register().
1014  */
1015 void ucsi_unregister_ppm(struct ucsi *ucsi)
1016 {
1017         struct ucsi_control ctrl;
1018         int i;
1019 
1020         /* Make sure that we are not in the middle of driver initialization */
1021         cancel_work_sync(&ucsi->work);
1022 
1023         /* Disable everything except command complete notification */
1024         UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_CMD_COMPLETE)
1025         ucsi_send_command(ucsi, &ctrl, NULL, 0);
1026 
1027         for (i = 0; i < ucsi->cap.num_connectors; i++) {
1028                 cancel_work_sync(&ucsi->connector[i].work);
1029                 ucsi_unregister_partner(&ucsi->connector[i]);
1030                 ucsi_unregister_altmodes(&ucsi->connector[i],
1031                                          UCSI_RECIPIENT_CON);
1032                 typec_unregister_port(ucsi->connector[i].port);
1033         }
1034 
1035         ucsi_reset_ppm(ucsi);
1036 
1037         kfree(ucsi->connector);
1038         kfree(ucsi);
1039 }
1040 EXPORT_SYMBOL_GPL(ucsi_unregister_ppm);
1041 
1042 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
1043 MODULE_LICENSE("GPL v2");
1044 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/usb/typec/ucsi/ucsi.c

DEFINITIONS
