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         command = UCSI_COMMAND(UCSI_GET_PDOS) | UCSI_CONNECTOR_NUMBER(con->num);
 582         command |= UCSI_GET_PDOS_PARTNER_PDO(is_partner);
 583         command |= UCSI_GET_PDOS_PDO_OFFSET(offset);
 584         command |= UCSI_GET_PDOS_NUM_PDOS(num_pdos - 1);
 585         command |= is_source(role) ? UCSI_GET_PDOS_SRC_PDOS : 0;
 586         ret = ucsi_send_command(ucsi, command, pdos + offset,
 587                                 num_pdos * sizeof(u32));
 588         if (ret < 0 && ret != -ETIMEDOUT)
 589                 dev_err(ucsi->dev, "UCSI_GET_PDOS failed (%d)\n", ret);
 590
 591         return ret;
 592 }
 593
 594 static int ucsi_get_pdos(struct ucsi_connector *con, enum typec_role role,
 595                          int is_partner, u32 *pdos)
 596 {
 597         u8 num_pdos;
 598         int ret;
 599
 600         /* UCSI max payload means only getting at most 4 PDOs at a time */
 601         ret = ucsi_read_pdos(con, role, is_partner, pdos, 0, UCSI_MAX_PDOS);
 602         if (ret < 0)
 603                 return ret;
 604
 605         num_pdos = ret / sizeof(u32); /* number of bytes to 32-bit PDOs */
 606         if (num_pdos < UCSI_MAX_PDOS)
 607                 return num_pdos;
 608
 609         /* get the remaining PDOs, if any */
 610         ret = ucsi_read_pdos(con, role, is_partner, pdos, UCSI_MAX_PDOS,
 611                              PDO_MAX_OBJECTS - UCSI_MAX_PDOS);
 612         if (ret < 0)
 613                 return ret;
 614
 615         return ret / sizeof(u32) + num_pdos;
 616 }
 617
 618 static int ucsi_get_src_pdos(struct ucsi_connector *con)
 619 {
 620         int ret;
 621
 622         ret = ucsi_get_pdos(con, TYPEC_SOURCE, 1, con->src_pdos);
 623         if (ret < 0)
 624                 return ret;
 625
 626         con->num_pdos = ret;
 627
 628         ucsi_port_psy_changed(con);
 629
 630         return ret;
 631 }
 632
 633 static int ucsi_check_altmodes(struct ucsi_connector *con)
 634 {
 635         int ret, num_partner_am;
 636
 637         ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
 638         if (ret && ret != -ETIMEDOUT)
 639                 dev_err(con->ucsi->dev,
 640                         "con%d: failed to register partner alt modes (%d)\n",
 641                         con->num, ret);
 642
 643         /* Ignoring the errors in this case. */
 644         if (con->partner_altmode[0]) {
 645                 num_partner_am = ucsi_get_num_altmode(con->partner_altmode);
 646                 if (num_partner_am > 0)
 647                         typec_partner_set_num_altmodes(con->partner, num_partner_am);
 648                 ucsi_altmode_update_active(con);
 649                 return 0;
 650         }
 651
 652         return ret;
 653 }
 654
 655 static int ucsi_register_partner_pdos(struct ucsi_connector *con)
 656 {
 657         struct usb_power_delivery_desc desc = { con->ucsi->cap.pd_version };
 658         struct usb_power_delivery_capabilities_desc caps;
 659         struct usb_power_delivery_capabilities *cap;
 660         int ret;
 661
 662         if (con->partner_pd)
 663                 return 0;
 664
 665         con->partner_pd = usb_power_delivery_register(NULL, &desc);
 666         if (IS_ERR(con->partner_pd))
 667                 return PTR_ERR(con->partner_pd);
 668
 669         ret = ucsi_get_pdos(con, TYPEC_SOURCE, 1, caps.pdo);
 670         if (ret > 0) {
 671                 if (ret < PDO_MAX_OBJECTS)
 672                         caps.pdo[ret] = 0;
 673
 674                 caps.role = TYPEC_SOURCE;
 675                 cap = usb_power_delivery_register_capabilities(con->partner_pd, &caps);
 676                 if (IS_ERR(cap))
 677                         return PTR_ERR(cap);
 678
 679                 con->partner_source_caps = cap;
 680
 681                 ret = typec_partner_set_usb_power_delivery(con->partner, con->partner_pd);
 682                 if (ret) {
 683                         usb_power_delivery_unregister_capabilities(con->partner_source_caps);
 684                         return ret;
 685                 }
 686         }
 687
 688         ret = ucsi_get_pdos(con, TYPEC_SINK, 1, caps.pdo);
 689         if (ret > 0) {
 690                 if (ret < PDO_MAX_OBJECTS)
 691                         caps.pdo[ret] = 0;
 692
 693                 caps.role = TYPEC_SINK;
 694
 695                 cap = usb_power_delivery_register_capabilities(con->partner_pd, &caps);
 696                 if (IS_ERR(cap))
 697                         return PTR_ERR(cap);
 698
 699                 con->partner_sink_caps = cap;
 700
 701                 ret = typec_partner_set_usb_power_delivery(con->partner, con->partner_pd);
 702                 if (ret) {
 703                         usb_power_delivery_unregister_capabilities(con->partner_sink_caps);
 704                         return ret;
 705                 }
 706         }
 707
 708         return 0;
 709 }
 710
 711 static void ucsi_unregister_partner_pdos(struct ucsi_connector *con)
 712 {
 713         usb_power_delivery_unregister_capabilities(con->partner_sink_caps);
 714         con->partner_sink_caps = NULL;
 715         usb_power_delivery_unregister_capabilities(con->partner_source_caps);
 716         con->partner_source_caps = NULL;
 717         usb_power_delivery_unregister(con->partner_pd);
 718         con->partner_pd = NULL;
 719 }
 720
 721 static void ucsi_pwr_opmode_change(struct ucsi_connector *con)
 722 {
 723         switch (UCSI_CONSTAT_PWR_OPMODE(con->status.flags)) {
 724         case UCSI_CONSTAT_PWR_OPMODE_PD:
 725                 con->rdo = con->status.request_data_obj;
 726                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD);
 727                 ucsi_partner_task(con, ucsi_get_src_pdos, 30, 0);
 728                 ucsi_partner_task(con, ucsi_check_altmodes, 30, 0);
 729                 ucsi_partner_task(con, ucsi_register_partner_pdos, 1, HZ);
 730                 break;
 731         case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5:
 732                 con->rdo = 0;
 733                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A);
 734                 break;
 735         case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0:
 736                 con->rdo = 0;
 737                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A);
 738                 break;
 739         default:
 740                 con->rdo = 0;
 741                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB);
 742                 break;
 743         }
 744 }
 745
 746 static int ucsi_register_partner(struct ucsi_connector *con)
 747 {
 748         u8 pwr_opmode = UCSI_CONSTAT_PWR_OPMODE(con->status.flags);
 749         struct typec_partner_desc desc;
 750         struct typec_partner *partner;
 751
 752         if (con->partner)
 753                 return 0;
 754
 755         memset(&desc, 0, sizeof(desc));
 756
 757         switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
 758         case UCSI_CONSTAT_PARTNER_TYPE_DEBUG:
 759                 desc.accessory = TYPEC_ACCESSORY_DEBUG;
 760                 break;
 761         case UCSI_CONSTAT_PARTNER_TYPE_AUDIO:
 762                 desc.accessory = TYPEC_ACCESSORY_AUDIO;
 763                 break;
 764         default:
 765                 break;
 766         }
 767
 768         desc.usb_pd = pwr_opmode == UCSI_CONSTAT_PWR_OPMODE_PD;
 769
 770         partner = typec_register_partner(con->port, &desc);
 771         if (IS_ERR(partner)) {
 772                 dev_err(con->ucsi->dev,
 773                         "con%d: failed to register partner (%ld)\n", con->num,
 774                         PTR_ERR(partner));
 775                 return PTR_ERR(partner);
 776         }
 777
 778         con->partner = partner;
 779
 780         return 0;
 781 }
 782
 783 static void ucsi_unregister_partner(struct ucsi_connector *con)
 784 {
 785         if (!con->partner)
 786                 return;
 787
 788         ucsi_unregister_partner_pdos(con);
 789         ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP);
 790         typec_unregister_partner(con->partner);
 791         con->partner = NULL;
 792 }
 793
 794 static void ucsi_partner_change(struct ucsi_connector *con)
 795 {
 796         enum usb_role u_role = USB_ROLE_NONE;
 797         int ret;
 798
 799         switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
 800         case UCSI_CONSTAT_PARTNER_TYPE_UFP:
 801         case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
 802                 u_role = USB_ROLE_HOST;
 803                 fallthrough;
 804         case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
 805                 typec_set_data_role(con->port, TYPEC_HOST);
 806                 break;
 807         case UCSI_CONSTAT_PARTNER_TYPE_DFP:
 808                 u_role = USB_ROLE_DEVICE;
 809                 typec_set_data_role(con->port, TYPEC_DEVICE);
 810                 break;
 811         default:
 812                 break;
 813         }
 814
 815         /* Only notify USB controller if partner supports USB data */
 816         if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
 817                 u_role = USB_ROLE_NONE;
 818
 819         ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
 820         if (ret)
 821                 dev_err(con->ucsi->dev, "con:%d: failed to set usb role:%d\n",
 822                         con->num, u_role);
 823 }
 824
 825 static int ucsi_check_connection(struct ucsi_connector *con)
 826 {
 827         u8 prev_flags = con->status.flags;
 828         u64 command;
 829         int ret;
 830
 831         command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
 832         ret = ucsi_send_command(con->ucsi, command, &con->status, sizeof(con->status));
 833         if (ret < 0) {
 834                 dev_err(con->ucsi->dev, "GET_CONNECTOR_STATUS failed (%d)\n", ret);
 835                 return ret;
 836         }
 837
 838         if (con->status.flags == prev_flags)
 839                 return 0;
 840
 841         if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
 842                 ucsi_register_partner(con);
 843                 ucsi_pwr_opmode_change(con);
 844                 ucsi_partner_change(con);
 845         } else {
 846                 ucsi_partner_change(con);
 847                 ucsi_port_psy_changed(con);
 848                 ucsi_unregister_partner(con);
 849         }
 850
 851         return 0;
 852 }
 853
 854 static void ucsi_handle_connector_change(struct work_struct *work)
 855 {
 856         struct ucsi_connector *con = container_of(work, struct ucsi_connector,
 857                                                   work);
 858         struct ucsi *ucsi = con->ucsi;
 859         enum typec_role role;
 860         u64 command;
 861         int ret;
 862
 863         mutex_lock(&con->lock);
 864
 865         command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
 866         ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status));
 867         if (ret < 0) {
 868                 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
 869                         __func__, ret);
 870                 goto out_unlock;
 871         }
 872
 873         trace_ucsi_connector_change(con->num, &con->status);
 874
 875         role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
 876
 877         if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) {
 878                 typec_set_pwr_role(con->port, role);
 879
 880                 /* Complete pending power role swap */
 881                 if (!completion_done(&con->complete))
 882                         complete(&con->complete);
 883         }
 884
 885         if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
 886                 typec_set_pwr_role(con->port, role);
 887                 ucsi_port_psy_changed(con);
 888                 ucsi_partner_change(con);
 889
 890                 if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
 891                         ucsi_register_partner(con);
 892                         ucsi_partner_task(con, ucsi_check_connection, 1, HZ);
 893
 894                         if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) ==
 895                             UCSI_CONSTAT_PWR_OPMODE_PD)
 896                                 ucsi_partner_task(con, ucsi_register_partner_pdos, 1, HZ);
 897                 } else {
 898                         ucsi_unregister_partner(con);
 899                 }
 900         }
 901
 902         if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE ||
 903             con->status.change & UCSI_CONSTAT_POWER_LEVEL_CHANGE)
 904                 ucsi_pwr_opmode_change(con);
 905
 906         if (con->partner && con->status.change & UCSI_CONSTAT_PARTNER_CHANGE) {
 907                 ucsi_partner_change(con);
 908
 909                 /* Complete pending data role swap */
 910                 if (!completion_done(&con->complete))
 911                         complete(&con->complete);
 912         }
 913
 914         if (con->status.change & UCSI_CONSTAT_CAM_CHANGE)
 915                 ucsi_partner_task(con, ucsi_check_altmodes, 1, 0);
 916
 917         clear_bit(EVENT_PENDING, &con->ucsi->flags);
 918
 919         ret = ucsi_acknowledge_connector_change(ucsi);
 920         if (ret)
 921                 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
 922
 923 out_unlock:
 924         mutex_unlock(&con->lock);
 925 }
 926
 927 /**
 928  * ucsi_connector_change - Process Connector Change Event
 929  * @ucsi: UCSI Interface
 930  * @num: Connector number
 931  */
 932 void ucsi_connector_change(struct ucsi *ucsi, u8 num)
 933 {
 934         struct ucsi_connector *con = &ucsi->connector[num - 1];
 935
 936         if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) {
 937                 dev_dbg(ucsi->dev, "Bogus connector change event\n");
 938                 return;
 939         }
 940
 941         if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags))
 942                 schedule_work(&con->work);
 943 }
 944 EXPORT_SYMBOL_GPL(ucsi_connector_change);
 945
 946 /* -------------------------------------------------------------------------- */
 947
 948 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard)
 949 {
 950         u64 command;
 951
 952         command = UCSI_CONNECTOR_RESET | UCSI_CONNECTOR_NUMBER(con->num);
 953         command |= hard ? UCSI_CONNECTOR_RESET_HARD : 0;
 954
 955         return ucsi_send_command(con->ucsi, command, NULL, 0);
 956 }
 957
 958 static int ucsi_reset_ppm(struct ucsi *ucsi)
 959 {
 960         u64 command = UCSI_PPM_RESET;
 961         unsigned long tmo;
 962         u32 cci;
 963         int ret;
 964
 965         mutex_lock(&ucsi->ppm_lock);
 966
 967         ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
 968                                      sizeof(command));
 969         if (ret < 0)
 970                 goto out;
 971
 972         tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
 973
 974         do {
 975                 if (time_is_before_jiffies(tmo)) {
 976                         ret = -ETIMEDOUT;
 977                         goto out;
 978                 }
 979
 980                 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
 981                 if (ret)
 982                         goto out;
 983
 984                 /* If the PPM is still doing something else, reset it again. */
 985                 if (cci & ~UCSI_CCI_RESET_COMPLETE) {
 986                         ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL,
 987                                                      &command,
 988                                                      sizeof(command));
 989                         if (ret < 0)
 990                                 goto out;
 991                 }
 992
 993                 msleep(20);
 994         } while (!(cci & UCSI_CCI_RESET_COMPLETE));
 995
 996 out:
 997         mutex_unlock(&ucsi->ppm_lock);
 998         return ret;
 999 }
1000
1001 static int ucsi_role_cmd(struct ucsi_connector *con, u64 command)
1002 {
1003         int ret;
1004
1005         ret = ucsi_send_command(con->ucsi, command, NULL, 0);
1006         if (ret == -ETIMEDOUT) {
1007                 u64 c;
1008
1009                 /* PPM most likely stopped responding. Resetting everything. */
1010                 ucsi_reset_ppm(con->ucsi);
1011
1012                 c = UCSI_SET_NOTIFICATION_ENABLE | con->ucsi->ntfy;
1013                 ucsi_send_command(con->ucsi, c, NULL, 0);
1014
1015                 ucsi_reset_connector(con, true);
1016         }
1017
1018         return ret;
1019 }
1020
1021 static int ucsi_dr_swap(struct typec_port *port, enum typec_data_role role)
1022 {
1023         struct ucsi_connector *con = typec_get_drvdata(port);
1024         u8 partner_type;
1025         u64 command;
1026         int ret = 0;
1027
1028         mutex_lock(&con->lock);
1029
1030         if (!con->partner) {
1031                 ret = -ENOTCONN;
1032                 goto out_unlock;
1033         }
1034
1035         partner_type = UCSI_CONSTAT_PARTNER_TYPE(con->status.flags);
1036         if ((partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP &&
1037              role == TYPEC_DEVICE) ||
1038             (partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP &&
1039              role == TYPEC_HOST))
1040                 goto out_unlock;
1041
1042         reinit_completion(&con->complete);
1043
1044         command = UCSI_SET_UOR | UCSI_CONNECTOR_NUMBER(con->num);
1045         command |= UCSI_SET_UOR_ROLE(role);
1046         command |= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS;
1047         ret = ucsi_role_cmd(con, command);
1048         if (ret < 0)
1049                 goto out_unlock;
1050
1051         mutex_unlock(&con->lock);
1052
1053         if (!wait_for_completion_timeout(&con->complete,
1054                                          msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
1055                 return -ETIMEDOUT;
1056
1057         return 0;
1058
1059 out_unlock:
1060         mutex_unlock(&con->lock);
1061
1062         return ret;
1063 }
1064
1065 static int ucsi_pr_swap(struct typec_port *port, enum typec_role role)
1066 {
1067         struct ucsi_connector *con = typec_get_drvdata(port);
1068         enum typec_role cur_role;
1069         u64 command;
1070         int ret = 0;
1071
1072         mutex_lock(&con->lock);
1073
1074         if (!con->partner) {
1075                 ret = -ENOTCONN;
1076                 goto out_unlock;
1077         }
1078
1079         cur_role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
1080
1081         if (cur_role == role)
1082                 goto out_unlock;
1083
1084         reinit_completion(&con->complete);
1085
1086         command = UCSI_SET_PDR | UCSI_CONNECTOR_NUMBER(con->num);
1087         command |= UCSI_SET_PDR_ROLE(role);
1088         command |= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS;
1089         ret = ucsi_role_cmd(con, command);
1090         if (ret < 0)
1091                 goto out_unlock;
1092
1093         mutex_unlock(&con->lock);
1094
1095         if (!wait_for_completion_timeout(&con->complete,
1096                                          msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
1097                 return -ETIMEDOUT;
1098
1099         mutex_lock(&con->lock);
1100
1101         /* Something has gone wrong while swapping the role */
1102         if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) !=
1103             UCSI_CONSTAT_PWR_OPMODE_PD) {
1104                 ucsi_reset_connector(con, true);
1105                 ret = -EPROTO;
1106         }
1107
1108 out_unlock:
1109         mutex_unlock(&con->lock);
1110
1111         return ret;
1112 }
1113
1114 static const struct typec_operations ucsi_ops = {
1115         .dr_set = ucsi_dr_swap,
1116         .pr_set = ucsi_pr_swap
1117 };
1118
1119 /* Caller must call fwnode_handle_put() after use */
1120 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con)
1121 {
1122         struct fwnode_handle *fwnode;
1123         int i = 1;
1124
1125         device_for_each_child_node(con->ucsi->dev, fwnode)
1126                 if (i++ == con->num)
1127                         return fwnode;
1128         return NULL;
1129 }
1130
1131 static int ucsi_register_port(struct ucsi *ucsi, struct ucsi_connector *con)
1132 {
1133         struct usb_power_delivery_desc desc = { ucsi->cap.pd_version};
1134         struct usb_power_delivery_capabilities_desc pd_caps;
1135         struct usb_power_delivery_capabilities *pd_cap;
1136         struct typec_capability *cap = &con->typec_cap;
1137         enum typec_accessory *accessory = cap->accessory;
1138         enum usb_role u_role = USB_ROLE_NONE;
1139         u64 command;
1140         char *name;
1141         int ret;
1142
1143         name = kasprintf(GFP_KERNEL, "%s-con%d", dev_name(ucsi->dev), con->num);
1144         if (!name)
1145                 return -ENOMEM;
1146
1147         con->wq = create_singlethread_workqueue(name);
1148         kfree(name);
1149         if (!con->wq)
1150                 return -ENOMEM;
1151
1152         INIT_WORK(&con->work, ucsi_handle_connector_change);
1153         init_completion(&con->complete);
1154         mutex_init(&con->lock);
1155         INIT_LIST_HEAD(&con->partner_tasks);
1156         con->ucsi = ucsi;
1157
1158         cap->fwnode = ucsi_find_fwnode(con);
1159         con->usb_role_sw = fwnode_usb_role_switch_get(cap->fwnode);
1160         if (IS_ERR(con->usb_role_sw))
1161                 return dev_err_probe(ucsi->dev, PTR_ERR(con->usb_role_sw),
1162                         "con%d: failed to get usb role switch\n", con->num);
1163
1164         /* Delay other interactions with the con until registration is complete */
1165         mutex_lock(&con->lock);
1166
1167         /* Get connector capability */
1168         command = UCSI_GET_CONNECTOR_CAPABILITY;
1169         command |= UCSI_CONNECTOR_NUMBER(con->num);
1170         ret = ucsi_send_command(ucsi, command, &con->cap, sizeof(con->cap));
1171         if (ret < 0)
1172                 goto out_unlock;
1173
1174         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP)
1175                 cap->data = TYPEC_PORT_DRD;
1176         else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP)
1177                 cap->data = TYPEC_PORT_DFP;
1178         else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP)
1179                 cap->data = TYPEC_PORT_UFP;
1180
1181         if ((con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER) &&
1182             (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER))
1183                 cap->type = TYPEC_PORT_DRP;
1184         else if (con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER)
1185                 cap->type = TYPEC_PORT_SRC;
1186         else if (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER)
1187                 cap->type = TYPEC_PORT_SNK;
1188
1189         cap->revision = ucsi->cap.typec_version;
1190         cap->pd_revision = ucsi->cap.pd_version;
1191         cap->svdm_version = SVDM_VER_2_0;
1192         cap->prefer_role = TYPEC_NO_PREFERRED_ROLE;
1193
1194         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY)
1195                 *accessory++ = TYPEC_ACCESSORY_AUDIO;
1196         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY)
1197                 *accessory = TYPEC_ACCESSORY_DEBUG;
1198
1199         cap->driver_data = con;
1200         cap->ops = &ucsi_ops;
1201
1202         ret = ucsi_register_port_psy(con);
1203         if (ret)
1204                 goto out;
1205
1206         /* Register the connector */
1207         con->port = typec_register_port(ucsi->dev, cap);
1208         if (IS_ERR(con->port)) {
1209                 ret = PTR_ERR(con->port);
1210                 goto out;
1211         }
1212
1213         con->pd = usb_power_delivery_register(ucsi->dev, &desc);
1214
1215         ret = ucsi_get_pdos(con, TYPEC_SOURCE, 0, pd_caps.pdo);
1216         if (ret > 0) {
1217                 if (ret < PDO_MAX_OBJECTS)
1218                         pd_caps.pdo[ret] = 0;
1219
1220                 pd_caps.role = TYPEC_SOURCE;
1221                 pd_cap = usb_power_delivery_register_capabilities(con->pd, &pd_caps);
1222                 if (IS_ERR(pd_cap)) {
1223                         ret = PTR_ERR(pd_cap);
1224                         goto out;
1225                 }
1226
1227                 con->port_source_caps = pd_cap;
1228                 typec_port_set_usb_power_delivery(con->port, con->pd);
1229         }
1230
1231         memset(&pd_caps, 0, sizeof(pd_caps));
1232         ret = ucsi_get_pdos(con, TYPEC_SINK, 0, pd_caps.pdo);
1233         if (ret > 0) {
1234                 if (ret < PDO_MAX_OBJECTS)
1235                         pd_caps.pdo[ret] = 0;
1236
1237                 pd_caps.role = TYPEC_SINK;
1238                 pd_cap = usb_power_delivery_register_capabilities(con->pd, &pd_caps);
1239                 if (IS_ERR(pd_cap)) {
1240                         ret = PTR_ERR(pd_cap);
1241                         goto out;
1242                 }
1243
1244                 con->port_sink_caps = pd_cap;
1245                 typec_port_set_usb_power_delivery(con->port, con->pd);
1246         }
1247
1248         /* Alternate modes */
1249         ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_CON);
1250         if (ret) {
1251                 dev_err(ucsi->dev, "con%d: failed to register alt modes\n",
1252                         con->num);
1253                 goto out;
1254         }
1255
1256         /* Get the status */
1257         command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
1258         ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status));
1259         if (ret < 0) {
1260                 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num);
1261                 ret = 0;
1262                 goto out;
1263         }
1264         ret = 0; /* ucsi_send_command() returns length on success */
1265
1266         switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
1267         case UCSI_CONSTAT_PARTNER_TYPE_UFP:
1268         case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
1269                 u_role = USB_ROLE_HOST;
1270                 fallthrough;
1271         case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
1272                 typec_set_data_role(con->port, TYPEC_HOST);
1273                 break;
1274         case UCSI_CONSTAT_PARTNER_TYPE_DFP:
1275                 u_role = USB_ROLE_DEVICE;
1276                 typec_set_data_role(con->port, TYPEC_DEVICE);
1277                 break;
1278         default:
1279                 break;
1280         }
1281
1282         /* Check if there is already something connected */
1283         if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
1284                 typec_set_pwr_role(con->port,
1285                                   !!(con->status.flags & UCSI_CONSTAT_PWR_DIR));
1286                 ucsi_register_partner(con);
1287                 ucsi_pwr_opmode_change(con);
1288                 ucsi_port_psy_changed(con);
1289         }
1290
1291         /* Only notify USB controller if partner supports USB data */
1292         if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
1293                 u_role = USB_ROLE_NONE;
1294
1295         ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
1296         if (ret) {
1297                 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n",
1298                         con->num, u_role);
1299                 ret = 0;
1300         }
1301
1302         if (con->partner &&
1303             UCSI_CONSTAT_PWR_OPMODE(con->status.flags) ==
1304             UCSI_CONSTAT_PWR_OPMODE_PD) {
1305                 ucsi_get_src_pdos(con);
1306                 ucsi_check_altmodes(con);
1307         }
1308
1309         trace_ucsi_register_port(con->num, &con->status);
1310
1311 out:
1312         fwnode_handle_put(cap->fwnode);
1313 out_unlock:
1314         mutex_unlock(&con->lock);
1315
1316         if (ret && con->wq) {
1317                 destroy_workqueue(con->wq);
1318                 con->wq = NULL;
1319         }
1320
1321         return ret;
1322 }
1323
1324 /**
1325  * ucsi_init - Initialize UCSI interface
1326  * @ucsi: UCSI to be initialized
1327  *
1328  * Registers all ports @ucsi has and enables all notification events.
1329  */
1330 static int ucsi_init(struct ucsi *ucsi)
1331 {
1332         struct ucsi_connector *con, *connector;
1333         u64 command, ntfy;
1334         int ret;
1335         int i;
1336
1337         /* Reset the PPM */
1338         ret = ucsi_reset_ppm(ucsi);
1339         if (ret) {
1340                 dev_err(ucsi->dev, "failed to reset PPM!\n");
1341                 goto err;
1342         }
1343
1344         /* Enable basic notifications */
1345         ntfy = UCSI_ENABLE_NTFY_CMD_COMPLETE | UCSI_ENABLE_NTFY_ERROR;
1346         command = UCSI_SET_NOTIFICATION_ENABLE | ntfy;
1347         ret = ucsi_send_command(ucsi, command, NULL, 0);
1348         if (ret < 0)
1349                 goto err_reset;
1350
1351         /* Get PPM capabilities */
1352         command = UCSI_GET_CAPABILITY;
1353         ret = ucsi_send_command(ucsi, command, &ucsi->cap, sizeof(ucsi->cap));
1354         if (ret < 0)
1355                 goto err_reset;
1356
1357         if (!ucsi->cap.num_connectors) {
1358                 ret = -ENODEV;
1359                 goto err_reset;
1360         }
1361
1362         /* Allocate the connectors. Released in ucsi_unregister() */
1363         connector = kcalloc(ucsi->cap.num_connectors + 1, sizeof(*connector), GFP_KERNEL);
1364         if (!connector) {
1365                 ret = -ENOMEM;
1366                 goto err_reset;
1367         }
1368
1369         /* Register all connectors */
1370         for (i = 0; i < ucsi->cap.num_connectors; i++) {
1371                 connector[i].num = i + 1;
1372                 ret = ucsi_register_port(ucsi, &connector[i]);
1373                 if (ret)
1374                         goto err_unregister;
1375         }
1376
1377         /* Enable all notifications */
1378         ntfy = UCSI_ENABLE_NTFY_ALL;
1379         command = UCSI_SET_NOTIFICATION_ENABLE | ntfy;
1380         ret = ucsi_send_command(ucsi, command, NULL, 0);
1381         if (ret < 0)
1382                 goto err_unregister;
1383
1384         ucsi->connector = connector;
1385         ucsi->ntfy = ntfy;
1386         return 0;
1387
1388 err_unregister:
1389         for (con = connector; con->port; con++) {
1390                 ucsi_unregister_partner(con);
1391                 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON);
1392                 ucsi_unregister_port_psy(con);
1393                 if (con->wq)
1394                         destroy_workqueue(con->wq);
1395
1396                 usb_power_delivery_unregister_capabilities(con->port_sink_caps);
1397                 con->port_sink_caps = NULL;
1398                 usb_power_delivery_unregister_capabilities(con->port_source_caps);
1399                 con->port_source_caps = NULL;
1400                 usb_power_delivery_unregister(con->pd);
1401                 con->pd = NULL;
1402                 typec_unregister_port(con->port);
1403                 con->port = NULL;
1404         }
1405         kfree(connector);
1406 err_reset:
1407         memset(&ucsi->cap, 0, sizeof(ucsi->cap));
1408         ucsi_reset_ppm(ucsi);
1409 err:
1410         return ret;
1411 }
1412
1413 static void ucsi_resume_work(struct work_struct *work)
1414 {
1415         struct ucsi *ucsi = container_of(work, struct ucsi, resume_work);
1416         struct ucsi_connector *con;
1417         u64 command;
1418         int ret;
1419
1420         /* Restore UCSI notification enable mask after system resume */
1421         command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1422         ret = ucsi_send_command(ucsi, command, NULL, 0);
1423         if (ret < 0) {
1424                 dev_err(ucsi->dev, "failed to re-enable notifications (%d)\n", ret);
1425                 return;
1426         }
1427
1428         for (con = ucsi->connector; con->port; con++) {
1429                 mutex_lock(&con->lock);
1430                 ucsi_partner_task(con, ucsi_check_connection, 1, 0);
1431                 mutex_unlock(&con->lock);
1432         }
1433 }
1434
1435 int ucsi_resume(struct ucsi *ucsi)
1436 {
1437         if (ucsi->connector)
1438                 queue_work(system_long_wq, &ucsi->resume_work);
1439         return 0;
1440 }
1441 EXPORT_SYMBOL_GPL(ucsi_resume);
1442
1443 static void ucsi_init_work(struct work_struct *work)
1444 {
1445         struct ucsi *ucsi = container_of(work, struct ucsi, work.work);
1446         int ret;
1447
1448         ret = ucsi_init(ucsi);
1449         if (ret)
1450                 dev_err_probe(ucsi->dev, ret, "PPM init failed\n");
1451
1452         if (ret == -EPROBE_DEFER) {
1453                 if (ucsi->work_count++ > UCSI_ROLE_SWITCH_WAIT_COUNT) {
1454                         dev_err(ucsi->dev, "PPM init failed, stop trying\n");
1455                         return;
1456                 }
1457
1458                 queue_delayed_work(system_long_wq, &ucsi->work,
1459                                    UCSI_ROLE_SWITCH_INTERVAL);
1460         }
1461 }
1462
1463 /**
1464  * ucsi_get_drvdata - Return private driver data pointer
1465  * @ucsi: UCSI interface
1466  */
1467 void *ucsi_get_drvdata(struct ucsi *ucsi)
1468 {
1469         return ucsi->driver_data;
1470 }
1471 EXPORT_SYMBOL_GPL(ucsi_get_drvdata);
1472
1473 /**
1474  * ucsi_set_drvdata - Assign private driver data pointer
1475  * @ucsi: UCSI interface
1476  * @data: Private data pointer
1477  */
1478 void ucsi_set_drvdata(struct ucsi *ucsi, void *data)
1479 {
1480         ucsi->driver_data = data;
1481 }
1482 EXPORT_SYMBOL_GPL(ucsi_set_drvdata);
1483
1484 /**
1485  * ucsi_create - Allocate UCSI instance
1486  * @dev: Device interface to the PPM (Platform Policy Manager)
1487  * @ops: I/O routines
1488  */
1489 struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops)
1490 {
1491         struct ucsi *ucsi;
1492
1493         if (!ops || !ops->read || !ops->sync_write || !ops->async_write)
1494                 return ERR_PTR(-EINVAL);
1495
1496         ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
1497         if (!ucsi)
1498                 return ERR_PTR(-ENOMEM);
1499
1500         INIT_WORK(&ucsi->resume_work, ucsi_resume_work);
1501         INIT_DELAYED_WORK(&ucsi->work, ucsi_init_work);
1502         mutex_init(&ucsi->ppm_lock);
1503         ucsi->dev = dev;
1504         ucsi->ops = ops;
1505
1506         return ucsi;
1507 }
1508 EXPORT_SYMBOL_GPL(ucsi_create);
1509
1510 /**
1511  * ucsi_destroy - Free UCSI instance
1512  * @ucsi: UCSI instance to be freed
1513  */
1514 void ucsi_destroy(struct ucsi *ucsi)
1515 {
1516         kfree(ucsi);
1517 }
1518 EXPORT_SYMBOL_GPL(ucsi_destroy);
1519
1520 /**
1521  * ucsi_register - Register UCSI interface
1522  * @ucsi: UCSI instance
1523  */
1524 int ucsi_register(struct ucsi *ucsi)
1525 {
1526         int ret;
1527
1528         ret = ucsi->ops->read(ucsi, UCSI_VERSION, &ucsi->version,
1529                               sizeof(ucsi->version));
1530         if (ret)
1531                 return ret;
1532
1533         if (!ucsi->version)
1534                 return -ENODEV;
1535
1536         queue_delayed_work(system_long_wq, &ucsi->work, 0);
1537
1538         return 0;
1539 }
1540 EXPORT_SYMBOL_GPL(ucsi_register);
1541
1542 /**
1543  * ucsi_unregister - Unregister UCSI interface
1544  * @ucsi: UCSI interface to be unregistered
1545  *
1546  * Unregister UCSI interface that was created with ucsi_register().
1547  */
1548 void ucsi_unregister(struct ucsi *ucsi)
1549 {
1550         u64 cmd = UCSI_SET_NOTIFICATION_ENABLE;
1551         int i;
1552
1553         /* Make sure that we are not in the middle of driver initialization */
1554         cancel_delayed_work_sync(&ucsi->work);
1555         cancel_work_sync(&ucsi->resume_work);
1556
1557         /* Disable notifications */
1558         ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
1559
1560         if (!ucsi->connector)
1561                 return;
1562
1563         for (i = 0; i < ucsi->cap.num_connectors; i++) {
1564                 cancel_work_sync(&ucsi->connector[i].work);
1565                 ucsi_unregister_partner(&ucsi->connector[i]);
1566                 ucsi_unregister_altmodes(&ucsi->connector[i],
1567                                          UCSI_RECIPIENT_CON);
1568                 ucsi_unregister_port_psy(&ucsi->connector[i]);
1569
1570                 if (ucsi->connector[i].wq) {
1571                         struct ucsi_work *uwork;
1572
1573                         mutex_lock(&ucsi->connector[i].lock);
1574                         /*
1575                          * queue delayed items immediately so they can execute
1576                          * and free themselves before the wq is destroyed
1577                          */
1578                         list_for_each_entry(uwork, &ucsi->connector[i].partner_tasks, node)
1579                                 mod_delayed_work(ucsi->connector[i].wq, &uwork->work, 0);
1580                         mutex_unlock(&ucsi->connector[i].lock);
1581                         destroy_workqueue(ucsi->connector[i].wq);
1582                 }
1583
1584                 usb_power_delivery_unregister_capabilities(ucsi->connector[i].port_sink_caps);
1585                 ucsi->connector[i].port_sink_caps = NULL;
1586                 usb_power_delivery_unregister_capabilities(ucsi->connector[i].port_source_caps);
1587                 ucsi->connector[i].port_source_caps = NULL;
1588                 usb_power_delivery_unregister(ucsi->connector[i].pd);
1589                 ucsi->connector[i].pd = NULL;
1590                 typec_unregister_port(ucsi->connector[i].port);
1591         }
1592
1593         kfree(ucsi->connector);
1594 }
1595 EXPORT_SYMBOL_GPL(ucsi_unregister);
1596
1597 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
1598 MODULE_LICENSE("GPL v2");
1599 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");