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