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 (cci & UCSI_CCI_BUSY) {
 136                 ucsi->ops->async_write(ucsi, UCSI_CANCEL, NULL, 0);
 137                 return -EBUSY;
 138         }
 139
 140         if (!(cci & UCSI_CCI_COMMAND_COMPLETE))
 141                 return -EIO;
 142
 143         if (cci & UCSI_CCI_NOT_SUPPORTED)
 144                 return -EOPNOTSUPP;
 145
 146         if (cci & UCSI_CCI_ERROR) {
 147                 if (cmd == UCSI_GET_ERROR_STATUS)
 148                         return -EIO;
 149                 return ucsi_read_error(ucsi);
 150         }
 151
 152         return UCSI_CCI_LENGTH(cci);
 153 }
 154
 155 int ucsi_send_command(struct ucsi *ucsi, u64 command,
 156                       void *data, size_t size)
 157 {
 158         u8 length;
 159         int ret;
 160
 161         mutex_lock(&ucsi->ppm_lock);
 162
 163         ret = ucsi_exec_command(ucsi, command);
 164         if (ret < 0)
 165                 goto out;
 166
 167         length = ret;
 168
 169         if (data) {
 170                 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, data, size);
 171                 if (ret)
 172                         goto out;
 173         }
 174
 175         ret = ucsi_acknowledge_command(ucsi);
 176         if (ret)
 177                 goto out;
 178
 179         ret = length;
 180 out:
 181         mutex_unlock(&ucsi->ppm_lock);
 182         return ret;
 183 }
 184 EXPORT_SYMBOL_GPL(ucsi_send_command);
 185
 186 int ucsi_resume(struct ucsi *ucsi)
 187 {
 188         u64 command;
 189
 190         /* Restore UCSI notification enable mask after system resume */
 191         command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
 192
 193         return ucsi_send_command(ucsi, command, NULL, 0);
 194 }
 195 EXPORT_SYMBOL_GPL(ucsi_resume);
 196 /* -------------------------------------------------------------------------- */
 197
 198 struct ucsi_work {
 199         struct delayed_work work;
 200         unsigned long delay;
 201         unsigned int count;
 202         struct ucsi_connector *con;
 203         int (*cb)(struct ucsi_connector *);
 204 };
 205
 206 static void ucsi_poll_worker(struct work_struct *work)
 207 {
 208         struct ucsi_work *uwork = container_of(work, struct ucsi_work, work.work);
 209         struct ucsi_connector *con = uwork->con;
 210         int ret;
 211
 212         mutex_lock(&con->lock);
 213
 214         if (!con->partner) {
 215                 mutex_unlock(&con->lock);
 216                 kfree(uwork);
 217                 return;
 218         }
 219
 220         ret = uwork->cb(con);
 221
 222         if (uwork->count-- && (ret == -EBUSY || ret == -ETIMEDOUT))
 223                 queue_delayed_work(con->wq, &uwork->work, uwork->delay);
 224         else
 225                 kfree(uwork);
 226
 227         mutex_unlock(&con->lock);
 228 }
 229
 230 static int ucsi_partner_task(struct ucsi_connector *con,
 231                              int (*cb)(struct ucsi_connector *),
 232                              int retries, unsigned long delay)
 233 {
 234         struct ucsi_work *uwork;
 235
 236         if (!con->partner)
 237                 return 0;
 238
 239         uwork = kzalloc(sizeof(*uwork), GFP_KERNEL);
 240         if (!uwork)
 241                 return -ENOMEM;
 242
 243         INIT_DELAYED_WORK(&uwork->work, ucsi_poll_worker);
 244         uwork->count = retries;
 245         uwork->delay = delay;
 246         uwork->con = con;
 247         uwork->cb = cb;
 248
 249         queue_delayed_work(con->wq, &uwork->work, delay);
 250
 251         return 0;
 252 }
 253
 254 /* -------------------------------------------------------------------------- */
 255
 256 void ucsi_altmode_update_active(struct ucsi_connector *con)
 257 {
 258         const struct typec_altmode *altmode = NULL;
 259         u64 command;
 260         int ret;
 261         u8 cur;
 262         int i;
 263
 264         command = UCSI_GET_CURRENT_CAM | UCSI_CONNECTOR_NUMBER(con->num);
 265         ret = ucsi_send_command(con->ucsi, command, &cur, sizeof(cur));
 266         if (ret < 0) {
 267                 if (con->ucsi->version > 0x0100) {
 268                         dev_err(con->ucsi->dev,
 269                                 "GET_CURRENT_CAM command failed\n");
 270                         return;
 271                 }
 272                 cur = 0xff;
 273         }
 274
 275         if (cur < UCSI_MAX_ALTMODES)
 276                 altmode = typec_altmode_get_partner(con->port_altmode[cur]);
 277
 278         for (i = 0; con->partner_altmode[i]; i++)
 279                 typec_altmode_update_active(con->partner_altmode[i],
 280                                             con->partner_altmode[i] == altmode);
 281 }
 282
 283 static int ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid)
 284 {
 285         u8 mode = 1;
 286         int i;
 287
 288         for (i = 0; alt[i]; i++) {
 289                 if (i > MODE_DISCOVERY_MAX)
 290                         return -ERANGE;
 291
 292                 if (alt[i]->svid == svid)
 293                         mode++;
 294         }
 295
 296         return mode;
 297 }
 298
 299 static int ucsi_next_altmode(struct typec_altmode **alt)
 300 {
 301         int i = 0;
 302
 303         for (i = 0; i < UCSI_MAX_ALTMODES; i++)
 304                 if (!alt[i])
 305                         return i;
 306
 307         return -ENOENT;
 308 }
 309
 310 static int ucsi_get_num_altmode(struct typec_altmode **alt)
 311 {
 312         int i;
 313
 314         for (i = 0; i < UCSI_MAX_ALTMODES; i++)
 315                 if (!alt[i])
 316                         break;
 317
 318         return i;
 319 }
 320
 321 static int ucsi_register_altmode(struct ucsi_connector *con,
 322                                  struct typec_altmode_desc *desc,
 323                                  u8 recipient)
 324 {
 325         struct typec_altmode *alt;
 326         bool override;
 327         int ret;
 328         int i;
 329
 330         override = !!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_OVERRIDE);
 331
 332         switch (recipient) {
 333         case UCSI_RECIPIENT_CON:
 334                 i = ucsi_next_altmode(con->port_altmode);
 335                 if (i < 0) {
 336                         ret = i;
 337                         goto err;
 338                 }
 339
 340                 ret = ucsi_altmode_next_mode(con->port_altmode, desc->svid);
 341                 if (ret < 0)
 342                         return ret;
 343
 344                 desc->mode = ret;
 345
 346                 switch (desc->svid) {
 347                 case USB_TYPEC_DP_SID:
 348                         alt = ucsi_register_displayport(con, override, i, desc);
 349                         break;
 350                 case USB_TYPEC_NVIDIA_VLINK_SID:
 351                         if (desc->vdo == USB_TYPEC_NVIDIA_VLINK_DBG_VDO)
 352                                 alt = typec_port_register_altmode(con->port,
 353                                                                   desc);
 354                         else
 355                                 alt = ucsi_register_displayport(con, override,
 356                                                                 i, desc);
 357                         break;
 358                 default:
 359                         alt = typec_port_register_altmode(con->port, desc);
 360                         break;
 361                 }
 362
 363                 if (IS_ERR(alt)) {
 364                         ret = PTR_ERR(alt);
 365                         goto err;
 366                 }
 367
 368                 con->port_altmode[i] = alt;
 369                 break;
 370         case UCSI_RECIPIENT_SOP:
 371                 i = ucsi_next_altmode(con->partner_altmode);
 372                 if (i < 0) {
 373                         ret = i;
 374                         goto err;
 375                 }
 376
 377                 ret = ucsi_altmode_next_mode(con->partner_altmode, desc->svid);
 378                 if (ret < 0)
 379                         return ret;
 380
 381                 desc->mode = ret;
 382
 383                 alt = typec_partner_register_altmode(con->partner, desc);
 384                 if (IS_ERR(alt)) {
 385                         ret = PTR_ERR(alt);
 386                         goto err;
 387                 }
 388
 389                 con->partner_altmode[i] = alt;
 390                 break;
 391         default:
 392                 return -EINVAL;
 393         }
 394
 395         trace_ucsi_register_altmode(recipient, alt);
 396
 397         return 0;
 398
 399 err:
 400         dev_err(con->ucsi->dev, "failed to registers svid 0x%04x mode %d\n",
 401                 desc->svid, desc->mode);
 402
 403         return ret;
 404 }
 405
 406 static int
 407 ucsi_register_altmodes_nvidia(struct ucsi_connector *con, u8 recipient)
 408 {
 409         int max_altmodes = UCSI_MAX_ALTMODES;
 410         struct typec_altmode_desc desc;
 411         struct ucsi_altmode alt;
 412         struct ucsi_altmode orig[UCSI_MAX_ALTMODES];
 413         struct ucsi_altmode updated[UCSI_MAX_ALTMODES];
 414         struct ucsi *ucsi = con->ucsi;
 415         bool multi_dp = false;
 416         u64 command;
 417         int ret;
 418         int len;
 419         int i;
 420         int k = 0;
 421
 422         if (recipient == UCSI_RECIPIENT_CON)
 423                 max_altmodes = con->ucsi->cap.num_alt_modes;
 424
 425         memset(orig, 0, sizeof(orig));
 426         memset(updated, 0, sizeof(updated));
 427
 428         /* First get all the alternate modes */
 429         for (i = 0; i < max_altmodes; i++) {
 430                 memset(&alt, 0, sizeof(alt));
 431                 command = UCSI_GET_ALTERNATE_MODES;
 432                 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient);
 433                 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num);
 434                 command |= UCSI_GET_ALTMODE_OFFSET(i);
 435                 len = ucsi_send_command(con->ucsi, command, &alt, sizeof(alt));
 436                 /*
 437                  * We are collecting all altmodes first and then registering.
 438                  * Some type-C device will return zero length data beyond last
 439                  * alternate modes. We should not return if length is zero.
 440                  */
 441                 if (len < 0)
 442                         return len;
 443
 444                 /* We got all altmodes, now break out and register them */
 445                 if (!len || !alt.svid)
 446                         break;
 447
 448                 orig[k].mid = alt.mid;
 449                 orig[k].svid = alt.svid;
 450                 k++;
 451         }
 452         /*
 453          * Update the original altmode table as some ppms may report
 454          * multiple DP altmodes.
 455          */
 456         if (recipient == UCSI_RECIPIENT_CON)
 457                 multi_dp = ucsi->ops->update_altmodes(ucsi, orig, updated);
 458
 459         /* now register altmodes */
 460         for (i = 0; i < max_altmodes; i++) {
 461                 memset(&desc, 0, sizeof(desc));
 462                 if (multi_dp && recipient == UCSI_RECIPIENT_CON) {
 463                         desc.svid = updated[i].svid;
 464                         desc.vdo = updated[i].mid;
 465                 } else {
 466                         desc.svid = orig[i].svid;
 467                         desc.vdo = orig[i].mid;
 468                 }
 469                 desc.roles = TYPEC_PORT_DRD;
 470
 471                 if (!desc.svid)
 472                         return 0;
 473
 474                 ret = ucsi_register_altmode(con, &desc, recipient);
 475                 if (ret)
 476                         return ret;
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int ucsi_register_altmodes(struct ucsi_connector *con, u8 recipient)
 483 {
 484         int max_altmodes = UCSI_MAX_ALTMODES;
 485         struct typec_altmode_desc desc;
 486         struct ucsi_altmode alt[2];
 487         u64 command;
 488         int num;
 489         int ret;
 490         int len;
 491         int j;
 492         int i;
 493
 494         if (!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS))
 495                 return 0;
 496
 497         if (recipient == UCSI_RECIPIENT_SOP && con->partner_altmode[0])
 498                 return 0;
 499
 500         if (con->ucsi->ops->update_altmodes)
 501                 return ucsi_register_altmodes_nvidia(con, recipient);
 502
 503         if (recipient == UCSI_RECIPIENT_CON)
 504                 max_altmodes = con->ucsi->cap.num_alt_modes;
 505
 506         for (i = 0; i < max_altmodes;) {
 507                 memset(alt, 0, sizeof(alt));
 508                 command = UCSI_GET_ALTERNATE_MODES;
 509                 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient);
 510                 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num);
 511                 command |= UCSI_GET_ALTMODE_OFFSET(i);
 512                 len = ucsi_send_command(con->ucsi, command, alt, sizeof(alt));
 513                 if (len == -EBUSY)
 514                         continue;
 515                 if (len <= 0)
 516                         return len;
 517
 518                 /*
 519                  * This code is requesting one alt mode at a time, but some PPMs
 520                  * may still return two. If that happens both alt modes need be
 521                  * registered and the offset for the next alt mode has to be
 522                  * incremented.
 523                  */
 524                 num = len / sizeof(alt[0]);
 525                 i += num;
 526
 527                 for (j = 0; j < num; j++) {
 528                         if (!alt[j].svid)
 529                                 return 0;
 530
 531                         memset(&desc, 0, sizeof(desc));
 532                         desc.vdo = alt[j].mid;
 533                         desc.svid = alt[j].svid;
 534                         desc.roles = TYPEC_PORT_DRD;
 535
 536                         ret = ucsi_register_altmode(con, &desc, recipient);
 537                         if (ret)
 538                                 return ret;
 539                 }
 540         }
 541
 542         return 0;
 543 }
 544
 545 static void ucsi_unregister_altmodes(struct ucsi_connector *con, u8 recipient)
 546 {
 547         const struct typec_altmode *pdev;
 548         struct typec_altmode **adev;
 549         int i = 0;
 550
 551         switch (recipient) {
 552         case UCSI_RECIPIENT_CON:
 553                 adev = con->port_altmode;
 554                 break;
 555         case UCSI_RECIPIENT_SOP:
 556                 adev = con->partner_altmode;
 557                 break;
 558         default:
 559                 return;
 560         }
 561
 562         while (adev[i]) {
 563                 if (recipient == UCSI_RECIPIENT_SOP &&
 564                     (adev[i]->svid == USB_TYPEC_DP_SID ||
 565                         (adev[i]->svid == USB_TYPEC_NVIDIA_VLINK_SID &&
 566                         adev[i]->vdo != USB_TYPEC_NVIDIA_VLINK_DBG_VDO))) {
 567                         pdev = typec_altmode_get_partner(adev[i]);
 568                         ucsi_displayport_remove_partner((void *)pdev);
 569                 }
 570                 typec_unregister_altmode(adev[i]);
 571                 adev[i++] = NULL;
 572         }
 573 }
 574
 575 static int ucsi_get_pdos(struct ucsi_connector *con, int is_partner,
 576                          u32 *pdos, int offset, int num_pdos)
 577 {
 578         struct ucsi *ucsi = con->ucsi;
 579         u64 command;
 580         int ret;
 581
 582         command = UCSI_COMMAND(UCSI_GET_PDOS) | UCSI_CONNECTOR_NUMBER(con->num);
 583         command |= UCSI_GET_PDOS_PARTNER_PDO(is_partner);
 584         command |= UCSI_GET_PDOS_PDO_OFFSET(offset);
 585         command |= UCSI_GET_PDOS_NUM_PDOS(num_pdos - 1);
 586         command |= UCSI_GET_PDOS_SRC_PDOS;
 587         ret = ucsi_send_command(ucsi, command, pdos + offset,
 588                                 num_pdos * sizeof(u32));
 589         if (ret < 0 && ret != -ETIMEDOUT)
 590                 dev_err(ucsi->dev, "UCSI_GET_PDOS failed (%d)\n", ret);
 591
 592         return ret;
 593 }
 594
 595 static int ucsi_get_src_pdos(struct ucsi_connector *con)
 596 {
 597         int ret;
 598
 599         /* UCSI max payload means only getting at most 4 PDOs at a time */
 600         ret = ucsi_get_pdos(con, 1, con->src_pdos, 0, UCSI_MAX_PDOS);
 601         if (ret < 0)
 602                 return ret;
 603
 604         con->num_pdos = ret / sizeof(u32); /* number of bytes to 32-bit PDOs */
 605         if (con->num_pdos < UCSI_MAX_PDOS)
 606                 return 0;
 607
 608         /* get the remaining PDOs, if any */
 609         ret = ucsi_get_pdos(con, 1, con->src_pdos, UCSI_MAX_PDOS,
 610                             PDO_MAX_OBJECTS - UCSI_MAX_PDOS);
 611         if (ret < 0)
 612                 return ret;
 613
 614         con->num_pdos += ret / sizeof(u32);
 615
 616         ucsi_port_psy_changed(con);
 617
 618         return 0;
 619 }
 620
 621 static int ucsi_check_altmodes(struct ucsi_connector *con)
 622 {
 623         int ret, num_partner_am;
 624
 625         ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
 626         if (ret && ret != -ETIMEDOUT)
 627                 dev_err(con->ucsi->dev,
 628                         "con%d: failed to register partner alt modes (%d)\n",
 629                         con->num, ret);
 630
 631         /* Ignoring the errors in this case. */
 632         if (con->partner_altmode[0]) {
 633                 num_partner_am = ucsi_get_num_altmode(con->partner_altmode);
 634                 if (num_partner_am > 0)
 635                         typec_partner_set_num_altmodes(con->partner, num_partner_am);
 636                 ucsi_altmode_update_active(con);
 637                 return 0;
 638         }
 639
 640         return ret;
 641 }
 642
 643 static void ucsi_pwr_opmode_change(struct ucsi_connector *con)
 644 {
 645         switch (UCSI_CONSTAT_PWR_OPMODE(con->status.flags)) {
 646         case UCSI_CONSTAT_PWR_OPMODE_PD:
 647                 con->rdo = con->status.request_data_obj;
 648                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD);
 649                 ucsi_partner_task(con, ucsi_get_src_pdos, 30, 0);
 650                 ucsi_partner_task(con, ucsi_check_altmodes, 30, 0);
 651                 break;
 652         case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5:
 653                 con->rdo = 0;
 654                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A);
 655                 break;
 656         case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0:
 657                 con->rdo = 0;
 658                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A);
 659                 break;
 660         default:
 661                 con->rdo = 0;
 662                 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB);
 663                 break;
 664         }
 665 }
 666
 667 static int ucsi_register_partner(struct ucsi_connector *con)
 668 {
 669         u8 pwr_opmode = UCSI_CONSTAT_PWR_OPMODE(con->status.flags);
 670         struct typec_partner_desc desc;
 671         struct typec_partner *partner;
 672
 673         if (con->partner)
 674                 return 0;
 675
 676         memset(&desc, 0, sizeof(desc));
 677
 678         switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
 679         case UCSI_CONSTAT_PARTNER_TYPE_DEBUG:
 680                 desc.accessory = TYPEC_ACCESSORY_DEBUG;
 681                 break;
 682         case UCSI_CONSTAT_PARTNER_TYPE_AUDIO:
 683                 desc.accessory = TYPEC_ACCESSORY_AUDIO;
 684                 break;
 685         default:
 686                 break;
 687         }
 688
 689         desc.usb_pd = pwr_opmode == UCSI_CONSTAT_PWR_OPMODE_PD;
 690
 691         partner = typec_register_partner(con->port, &desc);
 692         if (IS_ERR(partner)) {
 693                 dev_err(con->ucsi->dev,
 694                         "con%d: failed to register partner (%ld)\n", con->num,
 695                         PTR_ERR(partner));
 696                 return PTR_ERR(partner);
 697         }
 698
 699         con->partner = partner;
 700
 701         return 0;
 702 }
 703
 704 static void ucsi_unregister_partner(struct ucsi_connector *con)
 705 {
 706         if (!con->partner)
 707                 return;
 708
 709         ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP);
 710         typec_unregister_partner(con->partner);
 711         con->partner = NULL;
 712 }
 713
 714 static void ucsi_partner_change(struct ucsi_connector *con)
 715 {
 716         enum usb_role u_role = USB_ROLE_NONE;
 717         int ret;
 718
 719         switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
 720         case UCSI_CONSTAT_PARTNER_TYPE_UFP:
 721         case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
 722                 u_role = USB_ROLE_HOST;
 723                 fallthrough;
 724         case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
 725                 typec_set_data_role(con->port, TYPEC_HOST);
 726                 break;
 727         case UCSI_CONSTAT_PARTNER_TYPE_DFP:
 728                 u_role = USB_ROLE_DEVICE;
 729                 typec_set_data_role(con->port, TYPEC_DEVICE);
 730                 break;
 731         default:
 732                 break;
 733         }
 734
 735         /* Only notify USB controller if partner supports USB data */
 736         if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
 737                 u_role = USB_ROLE_NONE;
 738
 739         ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
 740         if (ret)
 741                 dev_err(con->ucsi->dev, "con:%d: failed to set usb role:%d\n",
 742                         con->num, u_role);
 743 }
 744
 745 static int ucsi_check_connection(struct ucsi_connector *con)
 746 {
 747         u64 command;
 748         int ret;
 749
 750         command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
 751         ret = ucsi_send_command(con->ucsi, command, &con->status, sizeof(con->status));
 752         if (ret < 0) {
 753                 dev_err(con->ucsi->dev, "GET_CONNECTOR_STATUS failed (%d)\n", ret);
 754                 return ret;
 755         }
 756
 757         if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
 758                 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) ==
 759                     UCSI_CONSTAT_PWR_OPMODE_PD)
 760                         ucsi_partner_task(con, ucsi_check_altmodes, 30, 0);
 761         } else {
 762                 ucsi_partner_change(con);
 763                 ucsi_port_psy_changed(con);
 764                 ucsi_unregister_partner(con);
 765         }
 766
 767         return 0;
 768 }
 769
 770 static void ucsi_handle_connector_change(struct work_struct *work)
 771 {
 772         struct ucsi_connector *con = container_of(work, struct ucsi_connector,
 773                                                   work);
 774         struct ucsi *ucsi = con->ucsi;
 775         enum typec_role role;
 776         u64 command;
 777         int ret;
 778
 779         mutex_lock(&con->lock);
 780
 781         command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
 782         ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status));
 783         if (ret < 0) {
 784                 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
 785                         __func__, ret);
 786                 goto out_unlock;
 787         }
 788
 789         trace_ucsi_connector_change(con->num, &con->status);
 790
 791         role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
 792
 793         if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) {
 794                 typec_set_pwr_role(con->port, role);
 795
 796                 /* Complete pending power role swap */
 797                 if (!completion_done(&con->complete))
 798                         complete(&con->complete);
 799         }
 800
 801         if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
 802                 typec_set_pwr_role(con->port, role);
 803                 ucsi_port_psy_changed(con);
 804                 ucsi_partner_change(con);
 805
 806                 if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
 807                         ucsi_register_partner(con);
 808                         ucsi_partner_task(con, ucsi_check_connection, 1, HZ);
 809                 } else {
 810                         ucsi_unregister_partner(con);
 811                 }
 812         }
 813
 814         if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE ||
 815             con->status.change & UCSI_CONSTAT_POWER_LEVEL_CHANGE)
 816                 ucsi_pwr_opmode_change(con);
 817
 818         if (con->partner && con->status.change & UCSI_CONSTAT_PARTNER_CHANGE) {
 819                 ucsi_partner_change(con);
 820
 821                 /* Complete pending data role swap */
 822                 if (!completion_done(&con->complete))
 823                         complete(&con->complete);
 824         }
 825
 826         if (con->status.change & UCSI_CONSTAT_CAM_CHANGE)
 827                 ucsi_partner_task(con, ucsi_check_altmodes, 1, 0);
 828
 829         clear_bit(EVENT_PENDING, &con->ucsi->flags);
 830
 831         ret = ucsi_acknowledge_connector_change(ucsi);
 832         if (ret)
 833                 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
 834
 835 out_unlock:
 836         mutex_unlock(&con->lock);
 837 }
 838
 839 /**
 840  * ucsi_connector_change - Process Connector Change Event
 841  * @ucsi: UCSI Interface
 842  * @num: Connector number
 843  */
 844 void ucsi_connector_change(struct ucsi *ucsi, u8 num)
 845 {
 846         struct ucsi_connector *con = &ucsi->connector[num - 1];
 847
 848         if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) {
 849                 dev_dbg(ucsi->dev, "Bogus connector change event\n");
 850                 return;
 851         }
 852
 853         if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags))
 854                 schedule_work(&con->work);
 855 }
 856 EXPORT_SYMBOL_GPL(ucsi_connector_change);
 857
 858 /* -------------------------------------------------------------------------- */
 859
 860 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard)
 861 {
 862         u64 command;
 863
 864         command = UCSI_CONNECTOR_RESET | UCSI_CONNECTOR_NUMBER(con->num);
 865         command |= hard ? UCSI_CONNECTOR_RESET_HARD : 0;
 866
 867         return ucsi_send_command(con->ucsi, command, NULL, 0);
 868 }
 869
 870 static int ucsi_reset_ppm(struct ucsi *ucsi)
 871 {
 872         u64 command = UCSI_PPM_RESET;
 873         unsigned long tmo;
 874         u32 cci;
 875         int ret;
 876
 877         mutex_lock(&ucsi->ppm_lock);
 878
 879         ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
 880                                      sizeof(command));
 881         if (ret < 0)
 882                 goto out;
 883
 884         tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
 885
 886         do {
 887                 if (time_is_before_jiffies(tmo)) {
 888                         ret = -ETIMEDOUT;
 889                         goto out;
 890                 }
 891
 892                 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
 893                 if (ret)
 894                         goto out;
 895
 896                 /* If the PPM is still doing something else, reset it again. */
 897                 if (cci & ~UCSI_CCI_RESET_COMPLETE) {
 898                         ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL,
 899                                                      &command,
 900                                                      sizeof(command));
 901                         if (ret < 0)
 902                                 goto out;
 903                 }
 904
 905                 msleep(20);
 906         } while (!(cci & UCSI_CCI_RESET_COMPLETE));
 907
 908 out:
 909         mutex_unlock(&ucsi->ppm_lock);
 910         return ret;
 911 }
 912
 913 static int ucsi_role_cmd(struct ucsi_connector *con, u64 command)
 914 {
 915         int ret;
 916
 917         ret = ucsi_send_command(con->ucsi, command, NULL, 0);
 918         if (ret == -ETIMEDOUT) {
 919                 u64 c;
 920
 921                 /* PPM most likely stopped responding. Resetting everything. */
 922                 ucsi_reset_ppm(con->ucsi);
 923
 924                 c = UCSI_SET_NOTIFICATION_ENABLE | con->ucsi->ntfy;
 925                 ucsi_send_command(con->ucsi, c, NULL, 0);
 926
 927                 ucsi_reset_connector(con, true);
 928         }
 929
 930         return ret;
 931 }
 932
 933 static int ucsi_dr_swap(struct typec_port *port, enum typec_data_role role)
 934 {
 935         struct ucsi_connector *con = typec_get_drvdata(port);
 936         u8 partner_type;
 937         u64 command;
 938         int ret = 0;
 939
 940         mutex_lock(&con->lock);
 941
 942         if (!con->partner) {
 943                 ret = -ENOTCONN;
 944                 goto out_unlock;
 945         }
 946
 947         partner_type = UCSI_CONSTAT_PARTNER_TYPE(con->status.flags);
 948         if ((partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP &&
 949              role == TYPEC_DEVICE) ||
 950             (partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP &&
 951              role == TYPEC_HOST))
 952                 goto out_unlock;
 953
 954         reinit_completion(&con->complete);
 955
 956         command = UCSI_SET_UOR | UCSI_CONNECTOR_NUMBER(con->num);
 957         command |= UCSI_SET_UOR_ROLE(role);
 958         command |= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS;
 959         ret = ucsi_role_cmd(con, command);
 960         if (ret < 0)
 961                 goto out_unlock;
 962
 963         mutex_unlock(&con->lock);
 964
 965         if (!wait_for_completion_timeout(&con->complete,
 966                                          msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
 967                 return -ETIMEDOUT;
 968
 969         return 0;
 970
 971 out_unlock:
 972         mutex_unlock(&con->lock);
 973
 974         return ret;
 975 }
 976
 977 static int ucsi_pr_swap(struct typec_port *port, enum typec_role role)
 978 {
 979         struct ucsi_connector *con = typec_get_drvdata(port);
 980         enum typec_role cur_role;
 981         u64 command;
 982         int ret = 0;
 983
 984         mutex_lock(&con->lock);
 985
 986         if (!con->partner) {
 987                 ret = -ENOTCONN;
 988                 goto out_unlock;
 989         }
 990
 991         cur_role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
 992
 993         if (cur_role == role)
 994                 goto out_unlock;
 995
 996         reinit_completion(&con->complete);
 997
 998         command = UCSI_SET_PDR | UCSI_CONNECTOR_NUMBER(con->num);
 999         command |= UCSI_SET_PDR_ROLE(role);
1000         command |= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS;
1001         ret = ucsi_role_cmd(con, command);
1002         if (ret < 0)
1003                 goto out_unlock;
1004
1005         mutex_unlock(&con->lock);
1006
1007         if (!wait_for_completion_timeout(&con->complete,
1008                                          msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
1009                 return -ETIMEDOUT;
1010
1011         mutex_lock(&con->lock);
1012
1013         /* Something has gone wrong while swapping the role */
1014         if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) !=
1015             UCSI_CONSTAT_PWR_OPMODE_PD) {
1016                 ucsi_reset_connector(con, true);
1017                 ret = -EPROTO;
1018         }
1019
1020 out_unlock:
1021         mutex_unlock(&con->lock);
1022
1023         return ret;
1024 }
1025
1026 static const struct typec_operations ucsi_ops = {
1027         .dr_set = ucsi_dr_swap,
1028         .pr_set = ucsi_pr_swap
1029 };
1030
1031 /* Caller must call fwnode_handle_put() after use */
1032 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con)
1033 {
1034         struct fwnode_handle *fwnode;
1035         int i = 1;
1036
1037         device_for_each_child_node(con->ucsi->dev, fwnode)
1038                 if (i++ == con->num)
1039                         return fwnode;
1040         return NULL;
1041 }
1042
1043 static int ucsi_register_port(struct ucsi *ucsi, int index)
1044 {
1045         struct ucsi_connector *con = &ucsi->connector[index];
1046         struct typec_capability *cap = &con->typec_cap;
1047         enum typec_accessory *accessory = cap->accessory;
1048         enum usb_role u_role = USB_ROLE_NONE;
1049         u64 command;
1050         char *name;
1051         int ret;
1052
1053         name = kasprintf(GFP_KERNEL, "%s-con%d", dev_name(ucsi->dev), con->num);
1054         if (!name)
1055                 return -ENOMEM;
1056
1057         con->wq = create_singlethread_workqueue(name);
1058         kfree(name);
1059         if (!con->wq)
1060                 return -ENOMEM;
1061
1062         INIT_WORK(&con->work, ucsi_handle_connector_change);
1063         init_completion(&con->complete);
1064         mutex_init(&con->lock);
1065         con->num = index + 1;
1066         con->ucsi = ucsi;
1067
1068         cap->fwnode = ucsi_find_fwnode(con);
1069         con->usb_role_sw = fwnode_usb_role_switch_get(cap->fwnode);
1070         if (IS_ERR(con->usb_role_sw))
1071                 return dev_err_probe(ucsi->dev, PTR_ERR(con->usb_role_sw),
1072                         "con%d: failed to get usb role switch\n", con->num);
1073
1074         /* Delay other interactions with the con until registration is complete */
1075         mutex_lock(&con->lock);
1076
1077         /* Get connector capability */
1078         command = UCSI_GET_CONNECTOR_CAPABILITY;
1079         command |= UCSI_CONNECTOR_NUMBER(con->num);
1080         ret = ucsi_send_command(ucsi, command, &con->cap, sizeof(con->cap));
1081         if (ret < 0)
1082                 goto out_unlock;
1083
1084         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP)
1085                 cap->data = TYPEC_PORT_DRD;
1086         else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP)
1087                 cap->data = TYPEC_PORT_DFP;
1088         else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP)
1089                 cap->data = TYPEC_PORT_UFP;
1090
1091         if ((con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER) &&
1092             (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER))
1093                 cap->type = TYPEC_PORT_DRP;
1094         else if (con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER)
1095                 cap->type = TYPEC_PORT_SRC;
1096         else if (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER)
1097                 cap->type = TYPEC_PORT_SNK;
1098
1099         cap->revision = ucsi->cap.typec_version;
1100         cap->pd_revision = ucsi->cap.pd_version;
1101         cap->svdm_version = SVDM_VER_2_0;
1102         cap->prefer_role = TYPEC_NO_PREFERRED_ROLE;
1103
1104         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY)
1105                 *accessory++ = TYPEC_ACCESSORY_AUDIO;
1106         if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY)
1107                 *accessory = TYPEC_ACCESSORY_DEBUG;
1108
1109         cap->driver_data = con;
1110         cap->ops = &ucsi_ops;
1111
1112         ret = ucsi_register_port_psy(con);
1113         if (ret)
1114                 goto out;
1115
1116         /* Register the connector */
1117         con->port = typec_register_port(ucsi->dev, cap);
1118         if (IS_ERR(con->port)) {
1119                 ret = PTR_ERR(con->port);
1120                 goto out;
1121         }
1122
1123         /* Alternate modes */
1124         ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_CON);
1125         if (ret) {
1126                 dev_err(ucsi->dev, "con%d: failed to register alt modes\n",
1127                         con->num);
1128                 goto out;
1129         }
1130
1131         /* Get the status */
1132         command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
1133         ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status));
1134         if (ret < 0) {
1135                 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num);
1136                 ret = 0;
1137                 goto out;
1138         }
1139         ret = 0; /* ucsi_send_command() returns length on success */
1140
1141         switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
1142         case UCSI_CONSTAT_PARTNER_TYPE_UFP:
1143         case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
1144                 u_role = USB_ROLE_HOST;
1145                 fallthrough;
1146         case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
1147                 typec_set_data_role(con->port, TYPEC_HOST);
1148                 break;
1149         case UCSI_CONSTAT_PARTNER_TYPE_DFP:
1150                 u_role = USB_ROLE_DEVICE;
1151                 typec_set_data_role(con->port, TYPEC_DEVICE);
1152                 break;
1153         default:
1154                 break;
1155         }
1156
1157         /* Check if there is already something connected */
1158         if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
1159                 typec_set_pwr_role(con->port,
1160                                   !!(con->status.flags & UCSI_CONSTAT_PWR_DIR));
1161                 ucsi_pwr_opmode_change(con);
1162                 ucsi_register_partner(con);
1163                 ucsi_port_psy_changed(con);
1164         }
1165
1166         /* Only notify USB controller if partner supports USB data */
1167         if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
1168                 u_role = USB_ROLE_NONE;
1169
1170         ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
1171         if (ret) {
1172                 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n",
1173                         con->num, u_role);
1174                 ret = 0;
1175         }
1176
1177         if (con->partner &&
1178             UCSI_CONSTAT_PWR_OPMODE(con->status.flags) ==
1179             UCSI_CONSTAT_PWR_OPMODE_PD) {
1180                 ucsi_get_src_pdos(con);
1181                 ucsi_check_altmodes(con);
1182         }
1183
1184         trace_ucsi_register_port(con->num, &con->status);
1185
1186 out:
1187         fwnode_handle_put(cap->fwnode);
1188 out_unlock:
1189         mutex_unlock(&con->lock);
1190
1191         if (ret && con->wq) {
1192                 destroy_workqueue(con->wq);
1193                 con->wq = NULL;
1194         }
1195
1196         return ret;
1197 }
1198
1199 /**
1200  * ucsi_init - Initialize UCSI interface
1201  * @ucsi: UCSI to be initialized
1202  *
1203  * Registers all ports @ucsi has and enables all notification events.
1204  */
1205 static int ucsi_init(struct ucsi *ucsi)
1206 {
1207         struct ucsi_connector *con;
1208         u64 command;
1209         int ret;
1210         int i;
1211
1212         /* Reset the PPM */
1213         ret = ucsi_reset_ppm(ucsi);
1214         if (ret) {
1215                 dev_err(ucsi->dev, "failed to reset PPM!\n");
1216                 goto err;
1217         }
1218
1219         /* Enable basic notifications */
1220         ucsi->ntfy = UCSI_ENABLE_NTFY_CMD_COMPLETE | UCSI_ENABLE_NTFY_ERROR;
1221         command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1222         ret = ucsi_send_command(ucsi, command, NULL, 0);
1223         if (ret < 0)
1224                 goto err_reset;
1225
1226         /* Get PPM capabilities */
1227         command = UCSI_GET_CAPABILITY;
1228         ret = ucsi_send_command(ucsi, command, &ucsi->cap, sizeof(ucsi->cap));
1229         if (ret < 0)
1230                 goto err_reset;
1231
1232         if (!ucsi->cap.num_connectors) {
1233                 ret = -ENODEV;
1234                 goto err_reset;
1235         }
1236
1237         /* Allocate the connectors. Released in ucsi_unregister() */
1238         ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1,
1239                                   sizeof(*ucsi->connector), GFP_KERNEL);
1240         if (!ucsi->connector) {
1241                 ret = -ENOMEM;
1242                 goto err_reset;
1243         }
1244
1245         /* Register all connectors */
1246         for (i = 0; i < ucsi->cap.num_connectors; i++) {
1247                 ret = ucsi_register_port(ucsi, i);
1248                 if (ret)
1249                         goto err_unregister;
1250         }
1251
1252         /* Enable all notifications */
1253         ucsi->ntfy = UCSI_ENABLE_NTFY_ALL;
1254         command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1255         ret = ucsi_send_command(ucsi, command, NULL, 0);
1256         if (ret < 0)
1257                 goto err_unregister;
1258
1259         return 0;
1260
1261 err_unregister:
1262         for (con = ucsi->connector; con->port; con++) {
1263                 ucsi_unregister_partner(con);
1264                 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON);
1265                 ucsi_unregister_port_psy(con);
1266                 if (con->wq)
1267                         destroy_workqueue(con->wq);
1268                 typec_unregister_port(con->port);
1269                 con->port = NULL;
1270         }
1271
1272 err_reset:
1273         memset(&ucsi->cap, 0, sizeof(ucsi->cap));
1274         ucsi_reset_ppm(ucsi);
1275 err:
1276         return ret;
1277 }
1278
1279 static void ucsi_init_work(struct work_struct *work)
1280 {
1281         struct ucsi *ucsi = container_of(work, struct ucsi, work.work);
1282         int ret;
1283
1284         ret = ucsi_init(ucsi);
1285         if (ret)
1286                 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret);
1287
1288         if (ret == -EPROBE_DEFER) {
1289                 if (ucsi->work_count++ > UCSI_ROLE_SWITCH_WAIT_COUNT)
1290                         return;
1291
1292                 queue_delayed_work(system_long_wq, &ucsi->work,
1293                                    UCSI_ROLE_SWITCH_INTERVAL);
1294         }
1295 }
1296
1297 /**
1298  * ucsi_get_drvdata - Return private driver data pointer
1299  * @ucsi: UCSI interface
1300  */
1301 void *ucsi_get_drvdata(struct ucsi *ucsi)
1302 {
1303         return ucsi->driver_data;
1304 }
1305 EXPORT_SYMBOL_GPL(ucsi_get_drvdata);
1306
1307 /**
1308  * ucsi_set_drvdata - Assign private driver data pointer
1309  * @ucsi: UCSI interface
1310  * @data: Private data pointer
1311  */
1312 void ucsi_set_drvdata(struct ucsi *ucsi, void *data)
1313 {
1314         ucsi->driver_data = data;
1315 }
1316 EXPORT_SYMBOL_GPL(ucsi_set_drvdata);
1317
1318 /**
1319  * ucsi_create - Allocate UCSI instance
1320  * @dev: Device interface to the PPM (Platform Policy Manager)
1321  * @ops: I/O routines
1322  */
1323 struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops)
1324 {
1325         struct ucsi *ucsi;
1326
1327         if (!ops || !ops->read || !ops->sync_write || !ops->async_write)
1328                 return ERR_PTR(-EINVAL);
1329
1330         ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
1331         if (!ucsi)
1332                 return ERR_PTR(-ENOMEM);
1333
1334         INIT_DELAYED_WORK(&ucsi->work, ucsi_init_work);
1335         mutex_init(&ucsi->ppm_lock);
1336         ucsi->dev = dev;
1337         ucsi->ops = ops;
1338
1339         return ucsi;
1340 }
1341 EXPORT_SYMBOL_GPL(ucsi_create);
1342
1343 /**
1344  * ucsi_destroy - Free UCSI instance
1345  * @ucsi: UCSI instance to be freed
1346  */
1347 void ucsi_destroy(struct ucsi *ucsi)
1348 {
1349         kfree(ucsi);
1350 }
1351 EXPORT_SYMBOL_GPL(ucsi_destroy);
1352
1353 /**
1354  * ucsi_register - Register UCSI interface
1355  * @ucsi: UCSI instance
1356  */
1357 int ucsi_register(struct ucsi *ucsi)
1358 {
1359         int ret;
1360
1361         ret = ucsi->ops->read(ucsi, UCSI_VERSION, &ucsi->version,
1362                               sizeof(ucsi->version));
1363         if (ret)
1364                 return ret;
1365
1366         if (!ucsi->version)
1367                 return -ENODEV;
1368
1369         queue_delayed_work(system_long_wq, &ucsi->work, 0);
1370
1371         return 0;
1372 }
1373 EXPORT_SYMBOL_GPL(ucsi_register);
1374
1375 /**
1376  * ucsi_unregister - Unregister UCSI interface
1377  * @ucsi: UCSI interface to be unregistered
1378  *
1379  * Unregister UCSI interface that was created with ucsi_register().
1380  */
1381 void ucsi_unregister(struct ucsi *ucsi)
1382 {
1383         u64 cmd = UCSI_SET_NOTIFICATION_ENABLE;
1384         int i;
1385
1386         /* Make sure that we are not in the middle of driver initialization */
1387         cancel_delayed_work_sync(&ucsi->work);
1388
1389         /* Disable notifications */
1390         ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
1391
1392         for (i = 0; i < ucsi->cap.num_connectors; i++) {
1393                 cancel_work_sync(&ucsi->connector[i].work);
1394                 ucsi_unregister_partner(&ucsi->connector[i]);
1395                 ucsi_unregister_altmodes(&ucsi->connector[i],
1396                                          UCSI_RECIPIENT_CON);
1397                 ucsi_unregister_port_psy(&ucsi->connector[i]);
1398                 if (ucsi->connector[i].wq)
1399                         destroy_workqueue(ucsi->connector[i].wq);
1400                 typec_unregister_port(ucsi->connector[i].port);
1401         }
1402
1403         kfree(ucsi->connector);
1404 }
1405 EXPORT_SYMBOL_GPL(ucsi_unregister);
1406
1407 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
1408 MODULE_LICENSE("GPL v2");
1409 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");