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