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