drivers/platform/chrome/cros_ec_typec.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2020 Google LLC
   4  *
   5  * This driver provides the ability to view and manage Type C ports through the
   6  * Chrome OS EC.
   7  */
   8
   9 #include <linux/acpi.h>
  10 #include <linux/list.h>
  11 #include <linux/module.h>
  12 #include <linux/of.h>
  13 #include <linux/platform_data/cros_ec_commands.h>
  14 #include <linux/platform_data/cros_ec_proto.h>
  15 #include <linux/platform_data/cros_usbpd_notify.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/usb/pd.h>
  18 #include <linux/usb/pd_vdo.h>
  19 #include <linux/usb/typec.h>
  20 #include <linux/usb/typec_altmode.h>
  21 #include <linux/usb/typec_dp.h>
  22 #include <linux/usb/typec_mux.h>
  23 #include <linux/usb/typec_tbt.h>
  24 #include <linux/usb/role.h>
  25
  26 #define DRV_NAME "cros-ec-typec"
  27
  28 /* Supported alt modes. */
  29 enum {
  30         CROS_EC_ALTMODE_DP = 0,
  31         CROS_EC_ALTMODE_TBT,
  32         CROS_EC_ALTMODE_MAX,
  33 };
  34
  35 /* Container for altmode pointer nodes. */
  36 struct cros_typec_altmode_node {
  37         struct typec_altmode *amode;
  38         struct list_head list;
  39 };
  40
  41 /* Per port data. */
  42 struct cros_typec_port {
  43         struct typec_port *port;
  44         /* Initial capabilities for the port. */
  45         struct typec_capability caps;
  46         struct typec_partner *partner;
  47         struct typec_cable *cable;
  48         /* SOP' plug. */
  49         struct typec_plug *plug;
  50         /* Port partner PD identity info. */
  51         struct usb_pd_identity p_identity;
  52         /* Port cable PD identity info. */
  53         struct usb_pd_identity c_identity;
  54         struct typec_switch *ori_sw;
  55         struct typec_mux *mux;
  56         struct usb_role_switch *role_sw;
  57
  58         /* Variables keeping track of switch state. */
  59         struct typec_mux_state state;
  60         uint8_t mux_flags;
  61         uint8_t role;
  62
  63         /* Port alt modes. */
  64         struct typec_altmode p_altmode[CROS_EC_ALTMODE_MAX];
  65
  66         /* Flag indicating that PD partner discovery data parsing is completed. */
  67         bool sop_disc_done;
  68         bool sop_prime_disc_done;
  69         struct ec_response_typec_discovery *disc_data;
  70         struct list_head partner_mode_list;
  71         struct list_head plug_mode_list;
  72 };
  73
  74 /* Platform-specific data for the Chrome OS EC Type C controller. */
  75 struct cros_typec_data {
  76         struct device *dev;
  77         struct cros_ec_device *ec;
  78         int num_ports;
  79         unsigned int pd_ctrl_ver;
  80         /* Array of ports, indexed by port number. */
  81         struct cros_typec_port *ports[EC_USB_PD_MAX_PORTS];
  82         struct notifier_block nb;
  83         struct work_struct port_work;
  84         bool typec_cmd_supported;
  85         bool needs_mux_ack;
  86 };
  87
  88 static int cros_typec_parse_port_props(struct typec_capability *cap,
  89                                        struct fwnode_handle *fwnode,
  90                                        struct device *dev)
  91 {
  92         const char *buf;
  93         int ret;
  94
  95         memset(cap, 0, sizeof(*cap));
  96         ret = fwnode_property_read_string(fwnode, "power-role", &buf);
  97         if (ret) {
  98                 dev_err(dev, "power-role not found: %d\n", ret);
  99                 return ret;
 100         }
 101
 102         ret = typec_find_port_power_role(buf);
 103         if (ret < 0)
 104                 return ret;
 105         cap->type = ret;
 106
 107         ret = fwnode_property_read_string(fwnode, "data-role", &buf);
 108         if (ret) {
 109                 dev_err(dev, "data-role not found: %d\n", ret);
 110                 return ret;
 111         }
 112
 113         ret = typec_find_port_data_role(buf);
 114         if (ret < 0)
 115                 return ret;
 116         cap->data = ret;
 117
 118         ret = fwnode_property_read_string(fwnode, "try-power-role", &buf);
 119         if (ret) {
 120                 dev_err(dev, "try-power-role not found: %d\n", ret);
 121                 return ret;
 122         }
 123
 124         ret = typec_find_power_role(buf);
 125         if (ret < 0)
 126                 return ret;
 127         cap->prefer_role = ret;
 128
 129         cap->fwnode = fwnode;
 130
 131         return 0;
 132 }
 133
 134 static int cros_typec_get_switch_handles(struct cros_typec_port *port,
 135                                          struct fwnode_handle *fwnode,
 136                                          struct device *dev)
 137 {
 138         port->mux = fwnode_typec_mux_get(fwnode, NULL);
 139         if (IS_ERR(port->mux)) {
 140                 dev_dbg(dev, "Mux handle not found.\n");
 141                 goto mux_err;
 142         }
 143
 144         port->ori_sw = fwnode_typec_switch_get(fwnode);
 145         if (IS_ERR(port->ori_sw)) {
 146                 dev_dbg(dev, "Orientation switch handle not found.\n");
 147                 goto ori_sw_err;
 148         }
 149
 150         port->role_sw = fwnode_usb_role_switch_get(fwnode);
 151         if (IS_ERR(port->role_sw)) {
 152                 dev_dbg(dev, "USB role switch handle not found.\n");
 153                 goto role_sw_err;
 154         }
 155
 156         return 0;
 157
 158 role_sw_err:
 159         usb_role_switch_put(port->role_sw);
 160 ori_sw_err:
 161         typec_switch_put(port->ori_sw);
 162 mux_err:
 163         typec_mux_put(port->mux);
 164
 165         return -ENODEV;
 166 }
 167
 168 static int cros_typec_add_partner(struct cros_typec_data *typec, int port_num,
 169                                   bool pd_en)
 170 {
 171         struct cros_typec_port *port = typec->ports[port_num];
 172         struct typec_partner_desc p_desc = {
 173                 .usb_pd = pd_en,
 174         };
 175         int ret = 0;
 176
 177         /*
 178          * Fill an initial PD identity, which will then be updated with info
 179          * from the EC.
 180          */
 181         p_desc.identity = &port->p_identity;
 182
 183         port->partner = typec_register_partner(port->port, &p_desc);
 184         if (IS_ERR(port->partner)) {
 185                 ret = PTR_ERR(port->partner);
 186                 port->partner = NULL;
 187         }
 188
 189         return ret;
 190 }
 191
 192 static void cros_typec_unregister_altmodes(struct cros_typec_data *typec, int port_num,
 193                                            bool is_partner)
 194 {
 195         struct cros_typec_port *port = typec->ports[port_num];
 196         struct cros_typec_altmode_node *node, *tmp;
 197         struct list_head *head;
 198
 199         head = is_partner ? &port->partner_mode_list : &port->plug_mode_list;
 200         list_for_each_entry_safe(node, tmp, head, list) {
 201                 list_del(&node->list);
 202                 typec_unregister_altmode(node->amode);
 203                 devm_kfree(typec->dev, node);
 204         }
 205 }
 206
 207 static int cros_typec_usb_disconnect_state(struct cros_typec_port *port)
 208 {
 209         port->state.alt = NULL;
 210         port->state.mode = TYPEC_STATE_USB;
 211         port->state.data = NULL;
 212
 213         usb_role_switch_set_role(port->role_sw, USB_ROLE_NONE);
 214         typec_switch_set(port->ori_sw, TYPEC_ORIENTATION_NONE);
 215
 216         return typec_mux_set(port->mux, &port->state);
 217 }
 218
 219 static void cros_typec_remove_partner(struct cros_typec_data *typec,
 220                                       int port_num)
 221 {
 222         struct cros_typec_port *port = typec->ports[port_num];
 223
 224         if (!port->partner)
 225                 return;
 226
 227         cros_typec_unregister_altmodes(typec, port_num, true);
 228
 229         cros_typec_usb_disconnect_state(port);
 230
 231         typec_unregister_partner(port->partner);
 232         port->partner = NULL;
 233         memset(&port->p_identity, 0, sizeof(port->p_identity));
 234         port->sop_disc_done = false;
 235 }
 236
 237 static void cros_typec_remove_cable(struct cros_typec_data *typec,
 238                                     int port_num)
 239 {
 240         struct cros_typec_port *port = typec->ports[port_num];
 241
 242         if (!port->cable)
 243                 return;
 244
 245         cros_typec_unregister_altmodes(typec, port_num, false);
 246
 247         typec_unregister_plug(port->plug);
 248         port->plug = NULL;
 249         typec_unregister_cable(port->cable);
 250         port->cable = NULL;
 251         memset(&port->c_identity, 0, sizeof(port->c_identity));
 252         port->sop_prime_disc_done = false;
 253 }
 254
 255 static void cros_unregister_ports(struct cros_typec_data *typec)
 256 {
 257         int i;
 258
 259         for (i = 0; i < typec->num_ports; i++) {
 260                 if (!typec->ports[i])
 261                         continue;
 262
 263                 cros_typec_remove_partner(typec, i);
 264                 cros_typec_remove_cable(typec, i);
 265
 266                 usb_role_switch_put(typec->ports[i]->role_sw);
 267                 typec_switch_put(typec->ports[i]->ori_sw);
 268                 typec_mux_put(typec->ports[i]->mux);
 269                 typec_unregister_port(typec->ports[i]->port);
 270         }
 271 }
 272
 273 /*
 274  * Fake the alt mode structs until we actually start registering Type C port
 275  * and partner alt modes.
 276  */
 277 static void cros_typec_register_port_altmodes(struct cros_typec_data *typec,
 278                                               int port_num)
 279 {
 280         struct cros_typec_port *port = typec->ports[port_num];
 281
 282         /* All PD capable CrOS devices are assumed to support DP altmode. */
 283         port->p_altmode[CROS_EC_ALTMODE_DP].svid = USB_TYPEC_DP_SID;
 284         port->p_altmode[CROS_EC_ALTMODE_DP].mode = USB_TYPEC_DP_MODE;
 285
 286         /*
 287          * Register TBT compatibility alt mode. The EC will not enter the mode
 288          * if it doesn't support it, so it's safe to register it unconditionally
 289          * here for now.
 290          */
 291         port->p_altmode[CROS_EC_ALTMODE_TBT].svid = USB_TYPEC_TBT_SID;
 292         port->p_altmode[CROS_EC_ALTMODE_TBT].mode = TYPEC_ANY_MODE;
 293
 294         port->state.alt = NULL;
 295         port->state.mode = TYPEC_STATE_USB;
 296         port->state.data = NULL;
 297 }
 298
 299 static int cros_typec_init_ports(struct cros_typec_data *typec)
 300 {
 301         struct device *dev = typec->dev;
 302         struct typec_capability *cap;
 303         struct fwnode_handle *fwnode;
 304         struct cros_typec_port *cros_port;
 305         const char *port_prop;
 306         int ret;
 307         int nports;
 308         u32 port_num = 0;
 309
 310         nports = device_get_child_node_count(dev);
 311         if (nports == 0) {
 312                 dev_err(dev, "No port entries found.\n");
 313                 return -ENODEV;
 314         }
 315
 316         if (nports > typec->num_ports) {
 317                 dev_err(dev, "More ports listed than can be supported.\n");
 318                 return -EINVAL;
 319         }
 320
 321         /* DT uses "reg" to specify port number. */
 322         port_prop = dev->of_node ? "reg" : "port-number";
 323         device_for_each_child_node(dev, fwnode) {
 324                 if (fwnode_property_read_u32(fwnode, port_prop, &port_num)) {
 325                         ret = -EINVAL;
 326                         dev_err(dev, "No port-number for port, aborting.\n");
 327                         goto unregister_ports;
 328                 }
 329
 330                 if (port_num >= typec->num_ports) {
 331                         dev_err(dev, "Invalid port number.\n");
 332                         ret = -EINVAL;
 333                         goto unregister_ports;
 334                 }
 335
 336                 dev_dbg(dev, "Registering port %d\n", port_num);
 337
 338                 cros_port = devm_kzalloc(dev, sizeof(*cros_port), GFP_KERNEL);
 339                 if (!cros_port) {
 340                         ret = -ENOMEM;
 341                         goto unregister_ports;
 342                 }
 343
 344                 typec->ports[port_num] = cros_port;
 345                 cap = &cros_port->caps;
 346
 347                 ret = cros_typec_parse_port_props(cap, fwnode, dev);
 348                 if (ret < 0)
 349                         goto unregister_ports;
 350
 351                 cros_port->port = typec_register_port(dev, cap);
 352                 if (IS_ERR(cros_port->port)) {
 353                         dev_err(dev, "Failed to register port %d\n", port_num);
 354                         ret = PTR_ERR(cros_port->port);
 355                         goto unregister_ports;
 356                 }
 357
 358                 ret = cros_typec_get_switch_handles(cros_port, fwnode, dev);
 359                 if (ret)
 360                         dev_dbg(dev, "No switch control for port %d\n",
 361                                 port_num);
 362
 363                 cros_typec_register_port_altmodes(typec, port_num);
 364
 365                 cros_port->disc_data = devm_kzalloc(dev, EC_PROTO2_MAX_RESPONSE_SIZE, GFP_KERNEL);
 366                 if (!cros_port->disc_data) {
 367                         ret = -ENOMEM;
 368                         goto unregister_ports;
 369                 }
 370
 371                 INIT_LIST_HEAD(&cros_port->partner_mode_list);
 372                 INIT_LIST_HEAD(&cros_port->plug_mode_list);
 373         }
 374
 375         return 0;
 376
 377 unregister_ports:
 378         cros_unregister_ports(typec);
 379         return ret;
 380 }
 381
 382 static int cros_typec_usb_safe_state(struct cros_typec_port *port)
 383 {
 384         port->state.mode = TYPEC_STATE_SAFE;
 385
 386         return typec_mux_set(port->mux, &port->state);
 387 }
 388
 389 /*
 390  * Spoof the VDOs that were likely communicated by the partner for TBT alt
 391  * mode.
 392  */
 393 static int cros_typec_enable_tbt(struct cros_typec_data *typec,
 394                                  int port_num,
 395                                  struct ec_response_usb_pd_control_v2 *pd_ctrl)
 396 {
 397         struct cros_typec_port *port = typec->ports[port_num];
 398         struct typec_thunderbolt_data data;
 399         int ret;
 400
 401         if (typec->pd_ctrl_ver < 2) {
 402                 dev_err(typec->dev,
 403                         "PD_CTRL version too old: %d\n", typec->pd_ctrl_ver);
 404                 return -ENOTSUPP;
 405         }
 406
 407         /* Device Discover Mode VDO */
 408         data.device_mode = TBT_MODE;
 409
 410         if (pd_ctrl->control_flags & USB_PD_CTRL_TBT_LEGACY_ADAPTER)
 411                 data.device_mode = TBT_SET_ADAPTER(TBT_ADAPTER_TBT3);
 412
 413         /* Cable Discover Mode VDO */
 414         data.cable_mode = TBT_MODE;
 415         data.cable_mode |= TBT_SET_CABLE_SPEED(pd_ctrl->cable_speed);
 416
 417         if (pd_ctrl->control_flags & USB_PD_CTRL_OPTICAL_CABLE)
 418                 data.cable_mode |= TBT_CABLE_OPTICAL;
 419
 420         if (pd_ctrl->control_flags & USB_PD_CTRL_ACTIVE_LINK_UNIDIR)
 421                 data.cable_mode |= TBT_CABLE_LINK_TRAINING;
 422
 423         data.cable_mode |= TBT_SET_CABLE_ROUNDED(pd_ctrl->cable_gen);
 424
 425         /* Enter Mode VDO */
 426         data.enter_vdo = TBT_SET_CABLE_SPEED(pd_ctrl->cable_speed);
 427
 428         if (pd_ctrl->control_flags & USB_PD_CTRL_ACTIVE_CABLE)
 429                 data.enter_vdo |= TBT_ENTER_MODE_ACTIVE_CABLE;
 430
 431         if (!port->state.alt) {
 432                 port->state.alt = &port->p_altmode[CROS_EC_ALTMODE_TBT];
 433                 ret = cros_typec_usb_safe_state(port);
 434                 if (ret)
 435                         return ret;
 436         }
 437
 438         port->state.data = &data;
 439         port->state.mode = TYPEC_TBT_MODE;
 440
 441         return typec_mux_set(port->mux, &port->state);
 442 }
 443
 444 /* Spoof the VDOs that were likely communicated by the partner. */
 445 static int cros_typec_enable_dp(struct cros_typec_data *typec,
 446                                 int port_num,
 447                                 struct ec_response_usb_pd_control_v2 *pd_ctrl)
 448 {
 449         struct cros_typec_port *port = typec->ports[port_num];
 450         struct typec_displayport_data dp_data;
 451         int ret;
 452
 453         if (typec->pd_ctrl_ver < 2) {
 454                 dev_err(typec->dev,
 455                         "PD_CTRL version too old: %d\n", typec->pd_ctrl_ver);
 456                 return -ENOTSUPP;
 457         }
 458
 459         if (!pd_ctrl->dp_mode) {
 460                 dev_err(typec->dev, "No valid DP mode provided.\n");
 461                 return -EINVAL;
 462         }
 463
 464         /* Status VDO. */
 465         dp_data.status = DP_STATUS_ENABLED;
 466         if (port->mux_flags & USB_PD_MUX_HPD_IRQ)
 467                 dp_data.status |= DP_STATUS_IRQ_HPD;
 468         if (port->mux_flags & USB_PD_MUX_HPD_LVL)
 469                 dp_data.status |= DP_STATUS_HPD_STATE;
 470
 471         /* Configuration VDO. */
 472         dp_data.conf = DP_CONF_SET_PIN_ASSIGN(pd_ctrl->dp_mode);
 473         if (!port->state.alt) {
 474                 port->state.alt = &port->p_altmode[CROS_EC_ALTMODE_DP];
 475                 ret = cros_typec_usb_safe_state(port);
 476                 if (ret)
 477                         return ret;
 478         }
 479
 480         port->state.data = &dp_data;
 481         port->state.mode = TYPEC_MODAL_STATE(ffs(pd_ctrl->dp_mode));
 482
 483         return typec_mux_set(port->mux, &port->state);
 484 }
 485
 486 static int cros_typec_enable_usb4(struct cros_typec_data *typec,
 487                                   int port_num,
 488                                   struct ec_response_usb_pd_control_v2 *pd_ctrl)
 489 {
 490         struct cros_typec_port *port = typec->ports[port_num];
 491         struct enter_usb_data data;
 492
 493         data.eudo = EUDO_USB_MODE_USB4 << EUDO_USB_MODE_SHIFT;
 494
 495         /* Cable Speed */
 496         data.eudo |= pd_ctrl->cable_speed << EUDO_CABLE_SPEED_SHIFT;
 497
 498         /* Cable Type */
 499         if (pd_ctrl->control_flags & USB_PD_CTRL_OPTICAL_CABLE)
 500                 data.eudo |= EUDO_CABLE_TYPE_OPTICAL << EUDO_CABLE_TYPE_SHIFT;
 501         else if (pd_ctrl->control_flags & USB_PD_CTRL_ACTIVE_CABLE)
 502                 data.eudo |= EUDO_CABLE_TYPE_RE_TIMER << EUDO_CABLE_TYPE_SHIFT;
 503
 504         data.active_link_training = !!(pd_ctrl->control_flags &
 505                                        USB_PD_CTRL_ACTIVE_LINK_UNIDIR);
 506
 507         port->state.alt = NULL;
 508         port->state.data = &data;
 509         port->state.mode = TYPEC_MODE_USB4;
 510
 511         return typec_mux_set(port->mux, &port->state);
 512 }
 513
 514 static int cros_typec_configure_mux(struct cros_typec_data *typec, int port_num,
 515                                 uint8_t mux_flags,
 516                                 struct ec_response_usb_pd_control_v2 *pd_ctrl)
 517 {
 518         struct cros_typec_port *port = typec->ports[port_num];
 519         struct ec_params_usb_pd_mux_ack mux_ack;
 520         enum typec_orientation orientation;
 521         int ret;
 522
 523         if (mux_flags == USB_PD_MUX_NONE) {
 524                 ret = cros_typec_usb_disconnect_state(port);
 525                 goto mux_ack;
 526         }
 527
 528         if (mux_flags & USB_PD_MUX_POLARITY_INVERTED)
 529                 orientation = TYPEC_ORIENTATION_REVERSE;
 530         else
 531                 orientation = TYPEC_ORIENTATION_NORMAL;
 532
 533         ret = typec_switch_set(port->ori_sw, orientation);
 534         if (ret)
 535                 return ret;
 536
 537         ret = usb_role_switch_set_role(typec->ports[port_num]->role_sw,
 538                                         pd_ctrl->role & PD_CTRL_RESP_ROLE_DATA
 539                                         ? USB_ROLE_HOST : USB_ROLE_DEVICE);
 540         if (ret)
 541                 return ret;
 542
 543         if (mux_flags & USB_PD_MUX_USB4_ENABLED) {
 544                 ret = cros_typec_enable_usb4(typec, port_num, pd_ctrl);
 545         } else if (mux_flags & USB_PD_MUX_TBT_COMPAT_ENABLED) {
 546                 ret = cros_typec_enable_tbt(typec, port_num, pd_ctrl);
 547         } else if (mux_flags & USB_PD_MUX_DP_ENABLED) {
 548                 ret = cros_typec_enable_dp(typec, port_num, pd_ctrl);
 549         } else if (mux_flags & USB_PD_MUX_SAFE_MODE) {
 550                 ret = cros_typec_usb_safe_state(port);
 551         } else if (mux_flags & USB_PD_MUX_USB_ENABLED) {
 552                 port->state.alt = NULL;
 553                 port->state.mode = TYPEC_STATE_USB;
 554                 ret = typec_mux_set(port->mux, &port->state);
 555         } else {
 556                 dev_dbg(typec->dev,
 557                         "Unrecognized mode requested, mux flags: %x\n",
 558                         mux_flags);
 559         }
 560
 561 mux_ack:
 562         if (!typec->needs_mux_ack)
 563                 return ret;
 564
 565         /* Sending Acknowledgment to EC */
 566         mux_ack.port = port_num;
 567
 568         if (cros_ec_command(typec->ec, 0, EC_CMD_USB_PD_MUX_ACK, &mux_ack,
 569                             sizeof(mux_ack), NULL, 0) < 0)
 570                 dev_warn(typec->dev,
 571                          "Failed to send Mux ACK to EC for port: %d\n",
 572                          port_num);
 573
 574         return ret;
 575 }
 576
 577 static void cros_typec_set_port_params_v0(struct cros_typec_data *typec,
 578                 int port_num, struct ec_response_usb_pd_control *resp)
 579 {
 580         struct typec_port *port = typec->ports[port_num]->port;
 581         enum typec_orientation polarity;
 582
 583         if (!resp->enabled)
 584                 polarity = TYPEC_ORIENTATION_NONE;
 585         else if (!resp->polarity)
 586                 polarity = TYPEC_ORIENTATION_NORMAL;
 587         else
 588                 polarity = TYPEC_ORIENTATION_REVERSE;
 589
 590         typec_set_pwr_role(port, resp->role ? TYPEC_SOURCE : TYPEC_SINK);
 591         typec_set_orientation(port, polarity);
 592 }
 593
 594 static void cros_typec_set_port_params_v1(struct cros_typec_data *typec,
 595                 int port_num, struct ec_response_usb_pd_control_v1 *resp)
 596 {
 597         struct typec_port *port = typec->ports[port_num]->port;
 598         enum typec_orientation polarity;
 599         bool pd_en;
 600         int ret;
 601
 602         if (!(resp->enabled & PD_CTRL_RESP_ENABLED_CONNECTED))
 603                 polarity = TYPEC_ORIENTATION_NONE;
 604         else if (!resp->polarity)
 605                 polarity = TYPEC_ORIENTATION_NORMAL;
 606         else
 607                 polarity = TYPEC_ORIENTATION_REVERSE;
 608         typec_set_orientation(port, polarity);
 609         typec_set_data_role(port, resp->role & PD_CTRL_RESP_ROLE_DATA ?
 610                         TYPEC_HOST : TYPEC_DEVICE);
 611         typec_set_pwr_role(port, resp->role & PD_CTRL_RESP_ROLE_POWER ?
 612                         TYPEC_SOURCE : TYPEC_SINK);
 613         typec_set_vconn_role(port, resp->role & PD_CTRL_RESP_ROLE_VCONN ?
 614                         TYPEC_SOURCE : TYPEC_SINK);
 615
 616         /* Register/remove partners when a connect/disconnect occurs. */
 617         if (resp->enabled & PD_CTRL_RESP_ENABLED_CONNECTED) {
 618                 if (typec->ports[port_num]->partner)
 619                         return;
 620
 621                 pd_en = resp->enabled & PD_CTRL_RESP_ENABLED_PD_CAPABLE;
 622                 ret = cros_typec_add_partner(typec, port_num, pd_en);
 623                 if (ret)
 624                         dev_warn(typec->dev,
 625                                  "Failed to register partner on port: %d\n",
 626                                  port_num);
 627         } else {
 628                 cros_typec_remove_partner(typec, port_num);
 629                 cros_typec_remove_cable(typec, port_num);
 630         }
 631 }
 632
 633 static int cros_typec_get_mux_info(struct cros_typec_data *typec, int port_num,
 634                                    struct ec_response_usb_pd_mux_info *resp)
 635 {
 636         struct ec_params_usb_pd_mux_info req = {
 637                 .port = port_num,
 638         };
 639
 640         return cros_ec_command(typec->ec, 0, EC_CMD_USB_PD_MUX_INFO, &req,
 641                                sizeof(req), resp, sizeof(*resp));
 642 }
 643
 644 /*
 645  * Helper function to register partner/plug altmodes.
 646  */
 647 static int cros_typec_register_altmodes(struct cros_typec_data *typec, int port_num,
 648                                         bool is_partner)
 649 {
 650         struct cros_typec_port *port = typec->ports[port_num];
 651         struct ec_response_typec_discovery *sop_disc = port->disc_data;
 652         struct cros_typec_altmode_node *node;
 653         struct typec_altmode_desc desc;
 654         struct typec_altmode *amode;
 655         int num_altmodes = 0;
 656         int ret = 0;
 657         int i, j;
 658
 659         for (i = 0; i < sop_disc->svid_count; i++) {
 660                 for (j = 0; j < sop_disc->svids[i].mode_count; j++) {
 661                         memset(&desc, 0, sizeof(desc));
 662                         desc.svid = sop_disc->svids[i].svid;
 663                         desc.mode = j;
 664                         desc.vdo = sop_disc->svids[i].mode_vdo[j];
 665
 666                         if (is_partner)
 667                                 amode = typec_partner_register_altmode(port->partner, &desc);
 668                         else
 669                                 amode = typec_plug_register_altmode(port->plug, &desc);
 670
 671                         if (IS_ERR(amode)) {
 672                                 ret = PTR_ERR(amode);
 673                                 goto err_cleanup;
 674                         }
 675
 676                         /* If no memory is available we should unregister and exit. */
 677                         node = devm_kzalloc(typec->dev, sizeof(*node), GFP_KERNEL);
 678                         if (!node) {
 679                                 ret = -ENOMEM;
 680                                 typec_unregister_altmode(amode);
 681                                 goto err_cleanup;
 682                         }
 683
 684                         node->amode = amode;
 685
 686                         if (is_partner)
 687                                 list_add_tail(&node->list, &port->partner_mode_list);
 688                         else
 689                                 list_add_tail(&node->list, &port->plug_mode_list);
 690                         num_altmodes++;
 691                 }
 692         }
 693
 694         if (is_partner)
 695                 ret = typec_partner_set_num_altmodes(port->partner, num_altmodes);
 696         else
 697                 ret = typec_plug_set_num_altmodes(port->plug, num_altmodes);
 698
 699         if (ret < 0) {
 700                 dev_err(typec->dev, "Unable to set %s num_altmodes for port: %d\n",
 701                         is_partner ? "partner" : "plug", port_num);
 702                 goto err_cleanup;
 703         }
 704
 705         return 0;
 706
 707 err_cleanup:
 708         cros_typec_unregister_altmodes(typec, port_num, is_partner);
 709         return ret;
 710 }
 711
 712 /*
 713  * Parse the PD identity data from the EC PD discovery responses and copy that to the supplied
 714  * PD identity struct.
 715  */
 716 static void cros_typec_parse_pd_identity(struct usb_pd_identity *id,
 717                                          struct ec_response_typec_discovery *disc)
 718 {
 719         int i;
 720
 721         /* First, update the PD identity VDOs for the partner. */
 722         if (disc->identity_count > 0)
 723                 id->id_header = disc->discovery_vdo[0];
 724         if (disc->identity_count > 1)
 725                 id->cert_stat = disc->discovery_vdo[1];
 726         if (disc->identity_count > 2)
 727                 id->product = disc->discovery_vdo[2];
 728
 729         /* Copy the remaining identity VDOs till a maximum of 6. */
 730         for (i = 3; i < disc->identity_count && i < VDO_MAX_OBJECTS; i++)
 731                 id->vdo[i - 3] = disc->discovery_vdo[i];
 732 }
 733
 734 static int cros_typec_handle_sop_prime_disc(struct cros_typec_data *typec, int port_num, u16 pd_revision)
 735 {
 736         struct cros_typec_port *port = typec->ports[port_num];
 737         struct ec_response_typec_discovery *disc = port->disc_data;
 738         struct typec_cable_desc c_desc = {};
 739         struct typec_plug_desc p_desc;
 740         struct ec_params_typec_discovery req = {
 741                 .port = port_num,
 742                 .partner_type = TYPEC_PARTNER_SOP_PRIME,
 743         };
 744         u32 cable_plug_type;
 745         int ret = 0;
 746
 747         memset(disc, 0, EC_PROTO2_MAX_RESPONSE_SIZE);
 748         ret = cros_ec_command(typec->ec, 0, EC_CMD_TYPEC_DISCOVERY, &req, sizeof(req),
 749                               disc, EC_PROTO2_MAX_RESPONSE_SIZE);
 750         if (ret < 0) {
 751                 dev_err(typec->dev, "Failed to get SOP' discovery data for port: %d\n", port_num);
 752                 goto sop_prime_disc_exit;
 753         }
 754
 755         /* Parse the PD identity data, even if only 0s were returned. */
 756         cros_typec_parse_pd_identity(&port->c_identity, disc);
 757
 758         if (disc->identity_count != 0) {
 759                 cable_plug_type = VDO_TYPEC_CABLE_TYPE(port->c_identity.vdo[0]);
 760                 switch (cable_plug_type) {
 761                 case CABLE_ATYPE:
 762                         c_desc.type = USB_PLUG_TYPE_A;
 763                         break;
 764                 case CABLE_BTYPE:
 765                         c_desc.type = USB_PLUG_TYPE_B;
 766                         break;
 767                 case CABLE_CTYPE:
 768                         c_desc.type = USB_PLUG_TYPE_C;
 769                         break;
 770                 case CABLE_CAPTIVE:
 771                         c_desc.type = USB_PLUG_CAPTIVE;
 772                         break;
 773                 default:
 774                         c_desc.type = USB_PLUG_NONE;
 775                 }
 776                 c_desc.active = PD_IDH_PTYPE(port->c_identity.id_header) == IDH_PTYPE_ACABLE;
 777         }
 778
 779         c_desc.identity = &port->c_identity;
 780         c_desc.pd_revision = pd_revision;
 781
 782         port->cable = typec_register_cable(port->port, &c_desc);
 783         if (IS_ERR(port->cable)) {
 784                 ret = PTR_ERR(port->cable);
 785                 port->cable = NULL;
 786                 goto sop_prime_disc_exit;
 787         }
 788
 789         p_desc.index = TYPEC_PLUG_SOP_P;
 790         port->plug = typec_register_plug(port->cable, &p_desc);
 791         if (IS_ERR(port->plug)) {
 792                 ret = PTR_ERR(port->plug);
 793                 port->plug = NULL;
 794                 goto sop_prime_disc_exit;
 795         }
 796
 797         ret = cros_typec_register_altmodes(typec, port_num, false);
 798         if (ret < 0) {
 799                 dev_err(typec->dev, "Failed to register plug altmodes, port: %d\n", port_num);
 800                 goto sop_prime_disc_exit;
 801         }
 802
 803         return 0;
 804
 805 sop_prime_disc_exit:
 806         cros_typec_remove_cable(typec, port_num);
 807         return ret;
 808 }
 809
 810 static int cros_typec_handle_sop_disc(struct cros_typec_data *typec, int port_num, u16 pd_revision)
 811 {
 812         struct cros_typec_port *port = typec->ports[port_num];
 813         struct ec_response_typec_discovery *sop_disc = port->disc_data;
 814         struct ec_params_typec_discovery req = {
 815                 .port = port_num,
 816                 .partner_type = TYPEC_PARTNER_SOP,
 817         };
 818         int ret = 0;
 819
 820         if (!port->partner) {
 821                 dev_err(typec->dev,
 822                         "SOP Discovery received without partner registered, port: %d\n",
 823                         port_num);
 824                 ret = -EINVAL;
 825                 goto disc_exit;
 826         }
 827
 828         typec_partner_set_pd_revision(port->partner, pd_revision);
 829
 830         memset(sop_disc, 0, EC_PROTO2_MAX_RESPONSE_SIZE);
 831         ret = cros_ec_command(typec->ec, 0, EC_CMD_TYPEC_DISCOVERY, &req, sizeof(req),
 832                               sop_disc, EC_PROTO2_MAX_RESPONSE_SIZE);
 833         if (ret < 0) {
 834                 dev_err(typec->dev, "Failed to get SOP discovery data for port: %d\n", port_num);
 835                 goto disc_exit;
 836         }
 837
 838         cros_typec_parse_pd_identity(&port->p_identity, sop_disc);
 839
 840         ret = typec_partner_set_identity(port->partner);
 841         if (ret < 0) {
 842                 dev_err(typec->dev, "Failed to update partner PD identity, port: %d\n", port_num);
 843                 goto disc_exit;
 844         }
 845
 846         ret = cros_typec_register_altmodes(typec, port_num, true);
 847         if (ret < 0) {
 848                 dev_err(typec->dev, "Failed to register partner altmodes, port: %d\n", port_num);
 849                 goto disc_exit;
 850         }
 851
 852 disc_exit:
 853         return ret;
 854 }
 855
 856 static int cros_typec_send_clear_event(struct cros_typec_data *typec, int port_num, u32 events_mask)
 857 {
 858         struct ec_params_typec_control req = {
 859                 .port = port_num,
 860                 .command = TYPEC_CONTROL_COMMAND_CLEAR_EVENTS,
 861                 .clear_events_mask = events_mask,
 862         };
 863
 864         return cros_ec_command(typec->ec, 0, EC_CMD_TYPEC_CONTROL, &req,
 865                                sizeof(req), NULL, 0);
 866 }
 867
 868 static void cros_typec_handle_status(struct cros_typec_data *typec, int port_num)
 869 {
 870         struct ec_response_typec_status resp;
 871         struct ec_params_typec_status req = {
 872                 .port = port_num,
 873         };
 874         int ret;
 875
 876         ret = cros_ec_command(typec->ec, 0, EC_CMD_TYPEC_STATUS, &req, sizeof(req),
 877                               &resp, sizeof(resp));
 878         if (ret < 0) {
 879                 dev_warn(typec->dev, "EC_CMD_TYPEC_STATUS failed for port: %d\n", port_num);
 880                 return;
 881         }
 882
 883         /* If we got a hard reset, unregister everything and return. */
 884         if (resp.events & PD_STATUS_EVENT_HARD_RESET) {
 885                 cros_typec_remove_partner(typec, port_num);
 886                 cros_typec_remove_cable(typec, port_num);
 887
 888                 ret = cros_typec_send_clear_event(typec, port_num,
 889                                                   PD_STATUS_EVENT_HARD_RESET);
 890                 if (ret < 0)
 891                         dev_warn(typec->dev,
 892                                  "Failed hard reset event clear, port: %d\n", port_num);
 893                 return;
 894         }
 895
 896         /* Handle any events appropriately. */
 897         if (resp.events & PD_STATUS_EVENT_SOP_DISC_DONE && !typec->ports[port_num]->sop_disc_done) {
 898                 u16 sop_revision;
 899
 900                 /* Convert BCD to the format preferred by the TypeC framework */
 901                 sop_revision = (le16_to_cpu(resp.sop_revision) & 0xff00) >> 4;
 902                 ret = cros_typec_handle_sop_disc(typec, port_num, sop_revision);
 903                 if (ret < 0)
 904                         dev_err(typec->dev, "Couldn't parse SOP Disc data, port: %d\n", port_num);
 905                 else {
 906                         typec->ports[port_num]->sop_disc_done = true;
 907                         ret = cros_typec_send_clear_event(typec, port_num,
 908                                                           PD_STATUS_EVENT_SOP_DISC_DONE);
 909                         if (ret < 0)
 910                                 dev_warn(typec->dev,
 911                                          "Failed SOP Disc event clear, port: %d\n", port_num);
 912                 }
 913                 if (resp.sop_connected)
 914                         typec_set_pwr_opmode(typec->ports[port_num]->port, TYPEC_PWR_MODE_PD);
 915         }
 916
 917         if (resp.events & PD_STATUS_EVENT_SOP_PRIME_DISC_DONE &&
 918             !typec->ports[port_num]->sop_prime_disc_done) {
 919                 u16 sop_prime_revision;
 920
 921                 /* Convert BCD to the format preferred by the TypeC framework */
 922                 sop_prime_revision = (le16_to_cpu(resp.sop_prime_revision) & 0xff00) >> 4;
 923                 ret = cros_typec_handle_sop_prime_disc(typec, port_num, sop_prime_revision);
 924                 if (ret < 0)
 925                         dev_err(typec->dev, "Couldn't parse SOP' Disc data, port: %d\n", port_num);
 926                 else {
 927                         typec->ports[port_num]->sop_prime_disc_done = true;
 928                         ret = cros_typec_send_clear_event(typec, port_num,
 929                                                           PD_STATUS_EVENT_SOP_PRIME_DISC_DONE);
 930                         if (ret < 0)
 931                                 dev_warn(typec->dev,
 932                                          "Failed SOP Disc event clear, port: %d\n", port_num);
 933                 }
 934         }
 935 }
 936
 937 static int cros_typec_port_update(struct cros_typec_data *typec, int port_num)
 938 {
 939         struct ec_params_usb_pd_control req;
 940         struct ec_response_usb_pd_control_v2 resp;
 941         struct ec_response_usb_pd_mux_info mux_resp;
 942         int ret;
 943
 944         if (port_num < 0 || port_num >= typec->num_ports) {
 945                 dev_err(typec->dev, "cannot get status for invalid port %d\n",
 946                         port_num);
 947                 return -EINVAL;
 948         }
 949
 950         req.port = port_num;
 951         req.role = USB_PD_CTRL_ROLE_NO_CHANGE;
 952         req.mux = USB_PD_CTRL_MUX_NO_CHANGE;
 953         req.swap = USB_PD_CTRL_SWAP_NONE;
 954
 955         ret = cros_ec_command(typec->ec, typec->pd_ctrl_ver,
 956                               EC_CMD_USB_PD_CONTROL, &req, sizeof(req),
 957                               &resp, sizeof(resp));
 958         if (ret < 0)
 959                 return ret;
 960
 961         dev_dbg(typec->dev, "Enabled %d: 0x%hhx\n", port_num, resp.enabled);
 962         dev_dbg(typec->dev, "Role %d: 0x%hhx\n", port_num, resp.role);
 963         dev_dbg(typec->dev, "Polarity %d: 0x%hhx\n", port_num, resp.polarity);
 964         dev_dbg(typec->dev, "State %d: %s\n", port_num, resp.state);
 965
 966         if (typec->pd_ctrl_ver != 0)
 967                 cros_typec_set_port_params_v1(typec, port_num,
 968                         (struct ec_response_usb_pd_control_v1 *)&resp);
 969         else
 970                 cros_typec_set_port_params_v0(typec, port_num,
 971                         (struct ec_response_usb_pd_control *) &resp);
 972
 973         if (typec->typec_cmd_supported)
 974                 cros_typec_handle_status(typec, port_num);
 975
 976         /* Update the switches if they exist, according to requested state */
 977         ret = cros_typec_get_mux_info(typec, port_num, &mux_resp);
 978         if (ret < 0) {
 979                 dev_warn(typec->dev,
 980                          "Failed to get mux info for port: %d, err = %d\n",
 981                          port_num, ret);
 982                 return 0;
 983         }
 984
 985         /* No change needs to be made, let's exit early. */
 986         if (typec->ports[port_num]->mux_flags == mux_resp.flags &&
 987             typec->ports[port_num]->role == resp.role)
 988                 return 0;
 989
 990         typec->ports[port_num]->mux_flags = mux_resp.flags;
 991         typec->ports[port_num]->role = resp.role;
 992         ret = cros_typec_configure_mux(typec, port_num, mux_resp.flags, &resp);
 993         if (ret)
 994                 dev_warn(typec->dev, "Configure muxes failed, err = %d\n", ret);
 995
 996         return ret;
 997 }
 998
 999 static int cros_typec_get_cmd_version(struct cros_typec_data *typec)
1000 {
1001         struct ec_params_get_cmd_versions_v1 req_v1;
1002         struct ec_response_get_cmd_versions resp;
1003         int ret;
1004
1005         /* We're interested in the PD control command version. */
1006         req_v1.cmd = EC_CMD_USB_PD_CONTROL;
1007         ret = cros_ec_command(typec->ec, 1, EC_CMD_GET_CMD_VERSIONS,
1008                               &req_v1, sizeof(req_v1), &resp,
1009                                     sizeof(resp));
1010         if (ret < 0)
1011                 return ret;
1012
1013         if (resp.version_mask & EC_VER_MASK(2))
1014                 typec->pd_ctrl_ver = 2;
1015         else if (resp.version_mask & EC_VER_MASK(1))
1016                 typec->pd_ctrl_ver = 1;
1017         else
1018                 typec->pd_ctrl_ver = 0;
1019
1020         dev_dbg(typec->dev, "PD Control has version mask 0x%02x\n",
1021                 typec->pd_ctrl_ver & 0xff);
1022
1023         return 0;
1024 }
1025
1026 static void cros_typec_port_work(struct work_struct *work)
1027 {
1028         struct cros_typec_data *typec = container_of(work, struct cros_typec_data, port_work);
1029         int ret, i;
1030
1031         for (i = 0; i < typec->num_ports; i++) {
1032                 ret = cros_typec_port_update(typec, i);
1033                 if (ret < 0)
1034                         dev_warn(typec->dev, "Update failed for port: %d\n", i);
1035         }
1036 }
1037
1038 static int cros_ec_typec_event(struct notifier_block *nb,
1039                                unsigned long host_event, void *_notify)
1040 {
1041         struct cros_typec_data *typec = container_of(nb, struct cros_typec_data, nb);
1042
1043         flush_work(&typec->port_work);
1044         schedule_work(&typec->port_work);
1045
1046         return NOTIFY_OK;
1047 }
1048
1049 #ifdef CONFIG_ACPI
1050 static const struct acpi_device_id cros_typec_acpi_id[] = {
1051         { "GOOG0014", 0 },
1052         {}
1053 };
1054 MODULE_DEVICE_TABLE(acpi, cros_typec_acpi_id);
1055 #endif
1056
1057 #ifdef CONFIG_OF
1058 static const struct of_device_id cros_typec_of_match[] = {
1059         { .compatible = "google,cros-ec-typec", },
1060         {}
1061 };
1062 MODULE_DEVICE_TABLE(of, cros_typec_of_match);
1063 #endif
1064
1065 static int cros_typec_probe(struct platform_device *pdev)
1066 {
1067         struct cros_ec_dev *ec_dev = NULL;
1068         struct device *dev = &pdev->dev;
1069         struct cros_typec_data *typec;
1070         struct ec_response_usb_pd_ports resp;
1071         int ret, i;
1072
1073         typec = devm_kzalloc(dev, sizeof(*typec), GFP_KERNEL);
1074         if (!typec)
1075                 return -ENOMEM;
1076
1077         typec->dev = dev;
1078         typec->ec = dev_get_drvdata(pdev->dev.parent);
1079         platform_set_drvdata(pdev, typec);
1080
1081         ret = cros_typec_get_cmd_version(typec);
1082         if (ret < 0) {
1083                 dev_err(dev, "failed to get PD command version info\n");
1084                 return ret;
1085         }
1086
1087         ec_dev = dev_get_drvdata(&typec->ec->ec->dev);
1088         typec->typec_cmd_supported = cros_ec_check_features(ec_dev, EC_FEATURE_TYPEC_CMD);
1089         typec->needs_mux_ack = cros_ec_check_features(ec_dev, EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK);
1090
1091         ret = cros_ec_command(typec->ec, 0, EC_CMD_USB_PD_PORTS, NULL, 0,
1092                               &resp, sizeof(resp));
1093         if (ret < 0)
1094                 return ret;
1095
1096         typec->num_ports = resp.num_ports;
1097         if (typec->num_ports > EC_USB_PD_MAX_PORTS) {
1098                 dev_warn(typec->dev,
1099                          "Too many ports reported: %d, limiting to max: %d\n",
1100                          typec->num_ports, EC_USB_PD_MAX_PORTS);
1101                 typec->num_ports = EC_USB_PD_MAX_PORTS;
1102         }
1103
1104         ret = cros_typec_init_ports(typec);
1105         if (ret < 0)
1106                 return ret;
1107
1108         INIT_WORK(&typec->port_work, cros_typec_port_work);
1109
1110         /*
1111          * Safe to call port update here, since we haven't registered the
1112          * PD notifier yet.
1113          */
1114         for (i = 0; i < typec->num_ports; i++) {
1115                 ret = cros_typec_port_update(typec, i);
1116                 if (ret < 0)
1117                         goto unregister_ports;
1118         }
1119
1120         typec->nb.notifier_call = cros_ec_typec_event;
1121         ret = cros_usbpd_register_notify(&typec->nb);
1122         if (ret < 0)
1123                 goto unregister_ports;
1124
1125         return 0;
1126
1127 unregister_ports:
1128         cros_unregister_ports(typec);
1129         return ret;
1130 }
1131
1132 static int __maybe_unused cros_typec_suspend(struct device *dev)
1133 {
1134         struct cros_typec_data *typec = dev_get_drvdata(dev);
1135
1136         cancel_work_sync(&typec->port_work);
1137
1138         return 0;
1139 }
1140
1141 static int __maybe_unused cros_typec_resume(struct device *dev)
1142 {
1143         struct cros_typec_data *typec = dev_get_drvdata(dev);
1144
1145         /* Refresh port state. */
1146         schedule_work(&typec->port_work);
1147
1148         return 0;
1149 }
1150
1151 static const struct dev_pm_ops cros_typec_pm_ops = {
1152         SET_SYSTEM_SLEEP_PM_OPS(cros_typec_suspend, cros_typec_resume)
1153 };
1154
1155 static struct platform_driver cros_typec_driver = {
1156         .driver = {
1157                 .name = DRV_NAME,
1158                 .acpi_match_table = ACPI_PTR(cros_typec_acpi_id),
1159                 .of_match_table = of_match_ptr(cros_typec_of_match),
1160                 .pm = &cros_typec_pm_ops,
1161         },
1162         .probe = cros_typec_probe,
1163 };
1164
1165 module_platform_driver(cros_typec_driver);
1166
1167 MODULE_AUTHOR("Prashant Malani <pmalani@chromium.org>");
1168 MODULE_DESCRIPTION("Chrome OS EC Type C control");
1169 MODULE_LICENSE("GPL");