drivers/usb/typec/ucsi/ucsi.c

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