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