1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * USB Type-C Connector System Software Interface driver
4 *
5 * Copyright (C) 2017, Intel Corporation
6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
7 */
8
9 #include <linux/completion.h>
10 #include <linux/property.h>
11 #include <linux/device.h>
12 #include <linux/module.h>
13 #include <linux/delay.h>
14 #include <linux/slab.h>
15 #include <linux/usb/typec_dp.h>
16
17 #include "ucsi.h"
18 #include "trace.h"
19
20 /*
21 * UCSI_TIMEOUT_MS - PPM communication timeout
22 *
23 * Ideally we could use MIN_TIME_TO_RESPOND_WITH_BUSY (which is defined in UCSI
24 * specification) here as reference, but unfortunately we can't. It is very
25 * difficult to estimate the time it takes for the system to process the command
26 * before it is actually passed to the PPM.
27 */
28 #define UCSI_TIMEOUT_MS 5000
29
30 /*
31 * UCSI_SWAP_TIMEOUT_MS - Timeout for role swap requests
32 *
33 * 5 seconds is close to the time it takes for CapsCounter to reach 0, so even
34 * if the PPM does not generate Connector Change events before that with
35 * partners that do not support USB Power Delivery, this should still work.
36 */
37 #define UCSI_SWAP_TIMEOUT_MS 5000
38
ucsi_acknowledge_command(struct ucsi * ucsi)39 static int ucsi_acknowledge_command(struct ucsi *ucsi)
40 {
41 u64 ctrl;
42
43 ctrl = UCSI_ACK_CC_CI;
44 ctrl |= UCSI_ACK_COMMAND_COMPLETE;
45
46 return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl));
47 }
48
ucsi_acknowledge_connector_change(struct ucsi * ucsi)49 static int ucsi_acknowledge_connector_change(struct ucsi *ucsi)
50 {
51 u64 ctrl;
52
53 ctrl = UCSI_ACK_CC_CI;
54 ctrl |= UCSI_ACK_CONNECTOR_CHANGE;
55
56 return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl));
57 }
58
59 static int ucsi_exec_command(struct ucsi *ucsi, u64 command);
60
ucsi_read_error(struct ucsi * ucsi)61 static int ucsi_read_error(struct ucsi *ucsi)
62 {
63 u16 error;
64 int ret;
65
66 /* Acknowledge the command that failed */
67 ret = ucsi_acknowledge_command(ucsi);
68 if (ret)
69 return ret;
70
71 ret = ucsi_exec_command(ucsi, UCSI_GET_ERROR_STATUS);
72 if (ret < 0)
73 return ret;
74
75 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, &error, sizeof(error));
76 if (ret)
77 return ret;
78
79 switch (error) {
80 case UCSI_ERROR_INCOMPATIBLE_PARTNER:
81 return -EOPNOTSUPP;
82 case UCSI_ERROR_CC_COMMUNICATION_ERR:
83 return -ECOMM;
84 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL:
85 return -EPROTO;
86 case UCSI_ERROR_DEAD_BATTERY:
87 dev_warn(ucsi->dev, "Dead battery condition!\n");
88 return -EPERM;
89 case UCSI_ERROR_INVALID_CON_NUM:
90 case UCSI_ERROR_UNREGONIZED_CMD:
91 case UCSI_ERROR_INVALID_CMD_ARGUMENT:
92 dev_err(ucsi->dev, "possible UCSI driver bug %u\n", error);
93 return -EINVAL;
94 case UCSI_ERROR_OVERCURRENT:
95 dev_warn(ucsi->dev, "Overcurrent condition\n");
96 break;
97 case UCSI_ERROR_PARTNER_REJECTED_SWAP:
98 dev_warn(ucsi->dev, "Partner rejected swap\n");
99 break;
100 case UCSI_ERROR_HARD_RESET:
101 dev_warn(ucsi->dev, "Hard reset occurred\n");
102 break;
103 case UCSI_ERROR_PPM_POLICY_CONFLICT:
104 dev_warn(ucsi->dev, "PPM Policy conflict\n");
105 break;
106 case UCSI_ERROR_SWAP_REJECTED:
107 dev_warn(ucsi->dev, "Swap rejected\n");
108 break;
109 case UCSI_ERROR_UNDEFINED:
110 default:
111 dev_err(ucsi->dev, "unknown error %u\n", error);
112 break;
113 }
114
115 return -EIO;
116 }
117
ucsi_exec_command(struct ucsi * ucsi,u64 cmd)118 static int ucsi_exec_command(struct ucsi *ucsi, u64 cmd)
119 {
120 u32 cci;
121 int ret;
122
123 ret = ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
124 if (ret)
125 return ret;
126
127 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
128 if (ret)
129 return ret;
130
131 if (cci & UCSI_CCI_BUSY)
132 return -EBUSY;
133
134 if (!(cci & UCSI_CCI_COMMAND_COMPLETE))
135 return -EIO;
136
137 if (cci & UCSI_CCI_NOT_SUPPORTED)
138 return -EOPNOTSUPP;
139
140 if (cci & UCSI_CCI_ERROR) {
141 if (cmd == UCSI_GET_ERROR_STATUS)
142 return -EIO;
143 return ucsi_read_error(ucsi);
144 }
145
146 return UCSI_CCI_LENGTH(cci);
147 }
148
ucsi_send_command(struct ucsi * ucsi,u64 command,void * data,size_t size)149 int ucsi_send_command(struct ucsi *ucsi, u64 command,
150 void *data, size_t size)
151 {
152 u8 length;
153 int ret;
154
155 mutex_lock(&ucsi->ppm_lock);
156
157 ret = ucsi_exec_command(ucsi, command);
158 if (ret < 0)
159 goto out;
160
161 length = ret;
162
163 if (data) {
164 ret = ucsi->ops->read(ucsi, UCSI_MESSAGE_IN, data, size);
165 if (ret)
166 goto out;
167 }
168
169 ret = ucsi_acknowledge_command(ucsi);
170 if (ret)
171 goto out;
172
173 ret = length;
174 out:
175 mutex_unlock(&ucsi->ppm_lock);
176 return ret;
177 }
178 EXPORT_SYMBOL_GPL(ucsi_send_command);
179
ucsi_resume(struct ucsi * ucsi)180 int ucsi_resume(struct ucsi *ucsi)
181 {
182 u64 command;
183
184 /* Restore UCSI notification enable mask after system resume */
185 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
186
187 return ucsi_send_command(ucsi, command, NULL, 0);
188 }
189 EXPORT_SYMBOL_GPL(ucsi_resume);
190 /* -------------------------------------------------------------------------- */
191
ucsi_altmode_update_active(struct ucsi_connector * con)192 void ucsi_altmode_update_active(struct ucsi_connector *con)
193 {
194 const struct typec_altmode *altmode = NULL;
195 u64 command;
196 int ret;
197 u8 cur;
198 int i;
199
200 command = UCSI_GET_CURRENT_CAM | UCSI_CONNECTOR_NUMBER(con->num);
201 ret = ucsi_send_command(con->ucsi, command, &cur, sizeof(cur));
202 if (ret < 0) {
203 if (con->ucsi->version > 0x0100) {
204 dev_err(con->ucsi->dev,
205 "GET_CURRENT_CAM command failed\n");
206 return;
207 }
208 cur = 0xff;
209 }
210
211 if (cur < UCSI_MAX_ALTMODES)
212 altmode = typec_altmode_get_partner(con->port_altmode[cur]);
213
214 for (i = 0; con->partner_altmode[i]; i++)
215 typec_altmode_update_active(con->partner_altmode[i],
216 con->partner_altmode[i] == altmode);
217 }
218
ucsi_altmode_next_mode(struct typec_altmode ** alt,u16 svid)219 static int ucsi_altmode_next_mode(struct typec_altmode **alt, u16 svid)
220 {
221 u8 mode = 1;
222 int i;
223
224 for (i = 0; alt[i]; i++) {
225 if (i > MODE_DISCOVERY_MAX)
226 return -ERANGE;
227
228 if (alt[i]->svid == svid)
229 mode++;
230 }
231
232 return mode;
233 }
234
ucsi_next_altmode(struct typec_altmode ** alt)235 static int ucsi_next_altmode(struct typec_altmode **alt)
236 {
237 int i = 0;
238
239 for (i = 0; i < UCSI_MAX_ALTMODES; i++)
240 if (!alt[i])
241 return i;
242
243 return -ENOENT;
244 }
245
ucsi_register_altmode(struct ucsi_connector * con,struct typec_altmode_desc * desc,u8 recipient)246 static int ucsi_register_altmode(struct ucsi_connector *con,
247 struct typec_altmode_desc *desc,
248 u8 recipient)
249 {
250 struct typec_altmode *alt;
251 bool override;
252 int ret;
253 int i;
254
255 override = !!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_OVERRIDE);
256
257 switch (recipient) {
258 case UCSI_RECIPIENT_CON:
259 i = ucsi_next_altmode(con->port_altmode);
260 if (i < 0) {
261 ret = i;
262 goto err;
263 }
264
265 ret = ucsi_altmode_next_mode(con->port_altmode, desc->svid);
266 if (ret < 0)
267 return ret;
268
269 desc->mode = ret;
270
271 switch (desc->svid) {
272 case USB_TYPEC_DP_SID:
273 alt = ucsi_register_displayport(con, override, i, desc);
274 break;
275 case USB_TYPEC_NVIDIA_VLINK_SID:
276 if (desc->vdo == USB_TYPEC_NVIDIA_VLINK_DBG_VDO)
277 alt = typec_port_register_altmode(con->port,
278 desc);
279 else
280 alt = ucsi_register_displayport(con, override,
281 i, desc);
282 break;
283 default:
284 alt = typec_port_register_altmode(con->port, desc);
285 break;
286 }
287
288 if (IS_ERR(alt)) {
289 ret = PTR_ERR(alt);
290 goto err;
291 }
292
293 con->port_altmode[i] = alt;
294 break;
295 case UCSI_RECIPIENT_SOP:
296 i = ucsi_next_altmode(con->partner_altmode);
297 if (i < 0) {
298 ret = i;
299 goto err;
300 }
301
302 ret = ucsi_altmode_next_mode(con->partner_altmode, desc->svid);
303 if (ret < 0)
304 return ret;
305
306 desc->mode = ret;
307
308 alt = typec_partner_register_altmode(con->partner, desc);
309 if (IS_ERR(alt)) {
310 ret = PTR_ERR(alt);
311 goto err;
312 }
313
314 con->partner_altmode[i] = alt;
315 break;
316 default:
317 return -EINVAL;
318 }
319
320 trace_ucsi_register_altmode(recipient, alt);
321
322 return 0;
323
324 err:
325 dev_err(con->ucsi->dev, "failed to registers svid 0x%04x mode %d\n",
326 desc->svid, desc->mode);
327
328 return ret;
329 }
330
331 static int
ucsi_register_altmodes_nvidia(struct ucsi_connector * con,u8 recipient)332 ucsi_register_altmodes_nvidia(struct ucsi_connector *con, u8 recipient)
333 {
334 int max_altmodes = UCSI_MAX_ALTMODES;
335 struct typec_altmode_desc desc;
336 struct ucsi_altmode alt;
337 struct ucsi_altmode orig[UCSI_MAX_ALTMODES];
338 struct ucsi_altmode updated[UCSI_MAX_ALTMODES];
339 struct ucsi *ucsi = con->ucsi;
340 bool multi_dp = false;
341 u64 command;
342 int ret;
343 int len;
344 int i;
345 int k = 0;
346
347 if (recipient == UCSI_RECIPIENT_CON)
348 max_altmodes = con->ucsi->cap.num_alt_modes;
349
350 memset(orig, 0, sizeof(orig));
351 memset(updated, 0, sizeof(updated));
352
353 /* First get all the alternate modes */
354 for (i = 0; i < max_altmodes; i++) {
355 memset(&alt, 0, sizeof(alt));
356 command = UCSI_GET_ALTERNATE_MODES;
357 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient);
358 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num);
359 command |= UCSI_GET_ALTMODE_OFFSET(i);
360 len = ucsi_send_command(con->ucsi, command, &alt, sizeof(alt));
361 /*
362 * We are collecting all altmodes first and then registering.
363 * Some type-C device will return zero length data beyond last
364 * alternate modes. We should not return if length is zero.
365 */
366 if (len < 0)
367 return len;
368
369 /* We got all altmodes, now break out and register them */
370 if (!len || !alt.svid)
371 break;
372
373 orig[k].mid = alt.mid;
374 orig[k].svid = alt.svid;
375 k++;
376 }
377 /*
378 * Update the original altmode table as some ppms may report
379 * multiple DP altmodes.
380 */
381 if (recipient == UCSI_RECIPIENT_CON)
382 multi_dp = ucsi->ops->update_altmodes(ucsi, orig, updated);
383
384 /* now register altmodes */
385 for (i = 0; i < max_altmodes; i++) {
386 memset(&desc, 0, sizeof(desc));
387 if (multi_dp && recipient == UCSI_RECIPIENT_CON) {
388 desc.svid = updated[i].svid;
389 desc.vdo = updated[i].mid;
390 } else {
391 desc.svid = orig[i].svid;
392 desc.vdo = orig[i].mid;
393 }
394 desc.roles = TYPEC_PORT_DRD;
395
396 if (!desc.svid)
397 return 0;
398
399 ret = ucsi_register_altmode(con, &desc, recipient);
400 if (ret)
401 return ret;
402 }
403
404 return 0;
405 }
406
ucsi_register_altmodes(struct ucsi_connector * con,u8 recipient)407 static int ucsi_register_altmodes(struct ucsi_connector *con, u8 recipient)
408 {
409 int max_altmodes = UCSI_MAX_ALTMODES;
410 struct typec_altmode_desc desc;
411 struct ucsi_altmode alt[2];
412 u64 command;
413 int num;
414 int ret;
415 int len;
416 int j;
417 int i;
418
419 if (!(con->ucsi->cap.features & UCSI_CAP_ALT_MODE_DETAILS))
420 return 0;
421
422 if (recipient == UCSI_RECIPIENT_SOP && con->partner_altmode[0])
423 return 0;
424
425 if (con->ucsi->ops->update_altmodes)
426 return ucsi_register_altmodes_nvidia(con, recipient);
427
428 if (recipient == UCSI_RECIPIENT_CON)
429 max_altmodes = con->ucsi->cap.num_alt_modes;
430
431 for (i = 0; i < max_altmodes;) {
432 memset(alt, 0, sizeof(alt));
433 command = UCSI_GET_ALTERNATE_MODES;
434 command |= UCSI_GET_ALTMODE_RECIPIENT(recipient);
435 command |= UCSI_GET_ALTMODE_CONNECTOR_NUMBER(con->num);
436 command |= UCSI_GET_ALTMODE_OFFSET(i);
437 len = ucsi_send_command(con->ucsi, command, alt, sizeof(alt));
438 if (len <= 0)
439 return len;
440
441 /*
442 * This code is requesting one alt mode at a time, but some PPMs
443 * may still return two. If that happens both alt modes need be
444 * registered and the offset for the next alt mode has to be
445 * incremented.
446 */
447 num = len / sizeof(alt[0]);
448 i += num;
449
450 for (j = 0; j < num; j++) {
451 if (!alt[j].svid)
452 return 0;
453
454 memset(&desc, 0, sizeof(desc));
455 desc.vdo = alt[j].mid;
456 desc.svid = alt[j].svid;
457 desc.roles = TYPEC_PORT_DRD;
458
459 ret = ucsi_register_altmode(con, &desc, recipient);
460 if (ret)
461 return ret;
462 }
463 }
464
465 return 0;
466 }
467
ucsi_unregister_altmodes(struct ucsi_connector * con,u8 recipient)468 static void ucsi_unregister_altmodes(struct ucsi_connector *con, u8 recipient)
469 {
470 const struct typec_altmode *pdev;
471 struct typec_altmode **adev;
472 int i = 0;
473
474 switch (recipient) {
475 case UCSI_RECIPIENT_CON:
476 adev = con->port_altmode;
477 break;
478 case UCSI_RECIPIENT_SOP:
479 adev = con->partner_altmode;
480 break;
481 default:
482 return;
483 }
484
485 while (adev[i]) {
486 if (recipient == UCSI_RECIPIENT_SOP &&
487 (adev[i]->svid == USB_TYPEC_DP_SID ||
488 (adev[i]->svid == USB_TYPEC_NVIDIA_VLINK_SID &&
489 adev[i]->vdo != USB_TYPEC_NVIDIA_VLINK_DBG_VDO))) {
490 pdev = typec_altmode_get_partner(adev[i]);
491 ucsi_displayport_remove_partner((void *)pdev);
492 }
493 typec_unregister_altmode(adev[i]);
494 adev[i++] = NULL;
495 }
496 }
497
ucsi_get_pdos(struct ucsi_connector * con,int is_partner,u32 * pdos,int offset,int num_pdos)498 static int ucsi_get_pdos(struct ucsi_connector *con, int is_partner,
499 u32 *pdos, int offset, int num_pdos)
500 {
501 struct ucsi *ucsi = con->ucsi;
502 u64 command;
503 int ret;
504
505 command = UCSI_COMMAND(UCSI_GET_PDOS) | UCSI_CONNECTOR_NUMBER(con->num);
506 command |= UCSI_GET_PDOS_PARTNER_PDO(is_partner);
507 command |= UCSI_GET_PDOS_PDO_OFFSET(offset);
508 command |= UCSI_GET_PDOS_NUM_PDOS(num_pdos - 1);
509 command |= UCSI_GET_PDOS_SRC_PDOS;
510 ret = ucsi_send_command(ucsi, command, pdos + offset,
511 num_pdos * sizeof(u32));
512 if (ret < 0)
513 dev_err(ucsi->dev, "UCSI_GET_PDOS failed (%d)\n", ret);
514 if (ret == 0 && offset == 0)
515 dev_warn(ucsi->dev, "UCSI_GET_PDOS returned 0 bytes\n");
516
517 return ret;
518 }
519
ucsi_get_src_pdos(struct ucsi_connector * con,int is_partner)520 static void ucsi_get_src_pdos(struct ucsi_connector *con, int is_partner)
521 {
522 int ret;
523
524 /* UCSI max payload means only getting at most 4 PDOs at a time */
525 ret = ucsi_get_pdos(con, 1, con->src_pdos, 0, UCSI_MAX_PDOS);
526 if (ret < 0)
527 return;
528
529 con->num_pdos = ret / sizeof(u32); /* number of bytes to 32-bit PDOs */
530 if (con->num_pdos < UCSI_MAX_PDOS)
531 return;
532
533 /* get the remaining PDOs, if any */
534 ret = ucsi_get_pdos(con, 1, con->src_pdos, UCSI_MAX_PDOS,
535 PDO_MAX_OBJECTS - UCSI_MAX_PDOS);
536 if (ret < 0)
537 return;
538
539 con->num_pdos += ret / sizeof(u32);
540 }
541
ucsi_pwr_opmode_change(struct ucsi_connector * con)542 static void ucsi_pwr_opmode_change(struct ucsi_connector *con)
543 {
544 switch (UCSI_CONSTAT_PWR_OPMODE(con->status.flags)) {
545 case UCSI_CONSTAT_PWR_OPMODE_PD:
546 con->rdo = con->status.request_data_obj;
547 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD);
548 ucsi_get_src_pdos(con, 1);
549 break;
550 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5:
551 con->rdo = 0;
552 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A);
553 break;
554 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0:
555 con->rdo = 0;
556 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A);
557 break;
558 default:
559 con->rdo = 0;
560 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB);
561 break;
562 }
563 }
564
ucsi_register_partner(struct ucsi_connector * con)565 static int ucsi_register_partner(struct ucsi_connector *con)
566 {
567 u8 pwr_opmode = UCSI_CONSTAT_PWR_OPMODE(con->status.flags);
568 struct typec_partner_desc desc;
569 struct typec_partner *partner;
570
571 if (con->partner)
572 return 0;
573
574 memset(&desc, 0, sizeof(desc));
575
576 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
577 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG:
578 desc.accessory = TYPEC_ACCESSORY_DEBUG;
579 break;
580 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO:
581 desc.accessory = TYPEC_ACCESSORY_AUDIO;
582 break;
583 default:
584 break;
585 }
586
587 desc.usb_pd = pwr_opmode == UCSI_CONSTAT_PWR_OPMODE_PD;
588
589 partner = typec_register_partner(con->port, &desc);
590 if (IS_ERR(partner)) {
591 dev_err(con->ucsi->dev,
592 "con%d: failed to register partner (%ld)\n", con->num,
593 PTR_ERR(partner));
594 return PTR_ERR(partner);
595 }
596
597 con->partner = partner;
598
599 return 0;
600 }
601
ucsi_unregister_partner(struct ucsi_connector * con)602 static void ucsi_unregister_partner(struct ucsi_connector *con)
603 {
604 if (!con->partner)
605 return;
606
607 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_SOP);
608 typec_unregister_partner(con->partner);
609 con->partner = NULL;
610 }
611
ucsi_partner_change(struct ucsi_connector * con)612 static void ucsi_partner_change(struct ucsi_connector *con)
613 {
614 enum usb_role u_role = USB_ROLE_NONE;
615 int ret;
616
617 if (!con->partner)
618 return;
619
620 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
621 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
622 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
623 u_role = USB_ROLE_HOST;
624 fallthrough;
625 case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
626 typec_set_data_role(con->port, TYPEC_HOST);
627 break;
628 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
629 u_role = USB_ROLE_DEVICE;
630 typec_set_data_role(con->port, TYPEC_DEVICE);
631 break;
632 default:
633 break;
634 }
635
636 /* Complete pending data role swap */
637 if (!completion_done(&con->complete))
638 complete(&con->complete);
639
640 /* Only notify USB controller if partner supports USB data */
641 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
642 u_role = USB_ROLE_NONE;
643
644 ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
645 if (ret)
646 dev_err(con->ucsi->dev, "con:%d: failed to set usb role:%d\n",
647 con->num, u_role);
648
649 /* Can't rely on Partner Flags field. Always checking the alt modes. */
650 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
651 if (ret)
652 dev_err(con->ucsi->dev,
653 "con%d: failed to register partner alternate modes\n",
654 con->num);
655 else
656 ucsi_altmode_update_active(con);
657 }
658
ucsi_handle_connector_change(struct work_struct * work)659 static void ucsi_handle_connector_change(struct work_struct *work)
660 {
661 struct ucsi_connector *con = container_of(work, struct ucsi_connector,
662 work);
663 struct ucsi *ucsi = con->ucsi;
664 struct ucsi_connector_status pre_ack_status;
665 struct ucsi_connector_status post_ack_status;
666 enum typec_role role;
667 enum usb_role u_role = USB_ROLE_NONE;
668 u16 inferred_changes;
669 u16 changed_flags;
670 u64 command;
671 int ret;
672
673 mutex_lock(&con->lock);
674
675 /*
676 * Some/many PPMs have an issue where all fields in the change bitfield
677 * are cleared when an ACK is send. This will causes any change
678 * between GET_CONNECTOR_STATUS and ACK to be lost.
679 *
680 * We work around this by re-fetching the connector status afterwards.
681 * We then infer any changes that we see have happened but that may not
682 * be represented in the change bitfield.
683 *
684 * Also, even though we don't need to know the currently supported alt
685 * modes, we run the GET_CAM_SUPPORTED command to ensure the PPM does
686 * not get stuck in case it assumes we do.
687 * Always do this, rather than relying on UCSI_CONSTAT_CAM_CHANGE to be
688 * set in the change bitfield.
689 *
690 * We end up with the following actions:
691 * 1. UCSI_GET_CONNECTOR_STATUS, store result, update unprocessed_changes
692 * 2. UCSI_GET_CAM_SUPPORTED, discard result
693 * 3. ACK connector change
694 * 4. UCSI_GET_CONNECTOR_STATUS, store result
695 * 5. Infere lost changes by comparing UCSI_GET_CONNECTOR_STATUS results
696 * 6. If PPM reported a new change, then restart in order to ACK
697 * 7. Process everything as usual.
698 *
699 * We may end up seeing a change twice, but we can only miss extremely
700 * short transitional changes.
701 */
702
703 /* 1. First UCSI_GET_CONNECTOR_STATUS */
704 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
705 ret = ucsi_send_command(ucsi, command, &pre_ack_status,
706 sizeof(pre_ack_status));
707 if (ret < 0) {
708 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
709 __func__, ret);
710 goto out_unlock;
711 }
712 con->unprocessed_changes |= pre_ack_status.change;
713
714 /* 2. Run UCSI_GET_CAM_SUPPORTED and discard the result. */
715 command = UCSI_GET_CAM_SUPPORTED;
716 command |= UCSI_CONNECTOR_NUMBER(con->num);
717 ucsi_send_command(con->ucsi, command, NULL, 0);
718
719 /* 3. ACK connector change */
720 clear_bit(EVENT_PENDING, &ucsi->flags);
721 ret = ucsi_acknowledge_connector_change(ucsi);
722 if (ret) {
723 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
724 goto out_unlock;
725 }
726
727 /* 4. Second UCSI_GET_CONNECTOR_STATUS */
728 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
729 ret = ucsi_send_command(ucsi, command, &post_ack_status,
730 sizeof(post_ack_status));
731 if (ret < 0) {
732 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
733 __func__, ret);
734 goto out_unlock;
735 }
736
737 /* 5. Inferre any missing changes */
738 changed_flags = pre_ack_status.flags ^ post_ack_status.flags;
739 inferred_changes = 0;
740 if (UCSI_CONSTAT_PWR_OPMODE(changed_flags) != 0)
741 inferred_changes |= UCSI_CONSTAT_POWER_OPMODE_CHANGE;
742
743 if (changed_flags & UCSI_CONSTAT_CONNECTED)
744 inferred_changes |= UCSI_CONSTAT_CONNECT_CHANGE;
745
746 if (changed_flags & UCSI_CONSTAT_PWR_DIR)
747 inferred_changes |= UCSI_CONSTAT_POWER_DIR_CHANGE;
748
749 if (UCSI_CONSTAT_PARTNER_FLAGS(changed_flags) != 0)
750 inferred_changes |= UCSI_CONSTAT_PARTNER_CHANGE;
751
752 if (UCSI_CONSTAT_PARTNER_TYPE(changed_flags) != 0)
753 inferred_changes |= UCSI_CONSTAT_PARTNER_CHANGE;
754
755 /* Mask out anything that was correctly notified in the later call. */
756 inferred_changes &= ~post_ack_status.change;
757 if (inferred_changes)
758 dev_dbg(ucsi->dev, "%s: Inferred changes that would have been lost: 0x%04x\n",
759 __func__, inferred_changes);
760
761 con->unprocessed_changes |= inferred_changes;
762
763 /* 6. If PPM reported a new change, then restart in order to ACK */
764 if (post_ack_status.change)
765 goto out_unlock;
766
767 /* 7. Continue as if nothing happened */
768 con->status = post_ack_status;
769 con->status.change = con->unprocessed_changes;
770 con->unprocessed_changes = 0;
771
772 role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
773
774 if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE ||
775 con->status.change & UCSI_CONSTAT_POWER_LEVEL_CHANGE) {
776 ucsi_pwr_opmode_change(con);
777 ucsi_port_psy_changed(con);
778 }
779
780 if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) {
781 typec_set_pwr_role(con->port, role);
782
783 /* Complete pending power role swap */
784 if (!completion_done(&con->complete))
785 complete(&con->complete);
786 }
787
788 if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
789 typec_set_pwr_role(con->port, role);
790
791 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
792 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
793 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
794 u_role = USB_ROLE_HOST;
795 fallthrough;
796 case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
797 typec_set_data_role(con->port, TYPEC_HOST);
798 break;
799 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
800 u_role = USB_ROLE_DEVICE;
801 typec_set_data_role(con->port, TYPEC_DEVICE);
802 break;
803 default:
804 break;
805 }
806
807 if (con->status.flags & UCSI_CONSTAT_CONNECTED)
808 ucsi_register_partner(con);
809 else
810 ucsi_unregister_partner(con);
811
812 ucsi_port_psy_changed(con);
813
814 /* Only notify USB controller if partner supports USB data */
815 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) &
816 UCSI_CONSTAT_PARTNER_FLAG_USB))
817 u_role = USB_ROLE_NONE;
818
819 ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
820 if (ret)
821 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n",
822 con->num, u_role);
823 }
824
825 if (con->status.change & UCSI_CONSTAT_PARTNER_CHANGE)
826 ucsi_partner_change(con);
827
828 trace_ucsi_connector_change(con->num, &con->status);
829
830 out_unlock:
831 if (test_and_clear_bit(EVENT_PENDING, &ucsi->flags)) {
832 schedule_work(&con->work);
833 mutex_unlock(&con->lock);
834 return;
835 }
836
837 clear_bit(EVENT_PROCESSING, &ucsi->flags);
838 mutex_unlock(&con->lock);
839 }
840
841 /**
842 * ucsi_connector_change - Process Connector Change Event
843 * @ucsi: UCSI Interface
844 * @num: Connector number
845 */
ucsi_connector_change(struct ucsi * ucsi,u8 num)846 void ucsi_connector_change(struct ucsi *ucsi, u8 num)
847 {
848 struct ucsi_connector *con = &ucsi->connector[num - 1];
849
850 if (!(ucsi->ntfy & UCSI_ENABLE_NTFY_CONNECTOR_CHANGE)) {
851 dev_dbg(ucsi->dev, "Bogus connector change event\n");
852 return;
853 }
854
855 set_bit(EVENT_PENDING, &ucsi->flags);
856
857 if (!test_and_set_bit(EVENT_PROCESSING, &ucsi->flags))
858 schedule_work(&con->work);
859 }
860 EXPORT_SYMBOL_GPL(ucsi_connector_change);
861
862 /* -------------------------------------------------------------------------- */
863
ucsi_reset_connector(struct ucsi_connector * con,bool hard)864 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard)
865 {
866 u64 command;
867
868 command = UCSI_CONNECTOR_RESET | UCSI_CONNECTOR_NUMBER(con->num);
869 command |= hard ? UCSI_CONNECTOR_RESET_HARD : 0;
870
871 return ucsi_send_command(con->ucsi, command, NULL, 0);
872 }
873
ucsi_reset_ppm(struct ucsi * ucsi)874 static int ucsi_reset_ppm(struct ucsi *ucsi)
875 {
876 u64 command = UCSI_PPM_RESET;
877 unsigned long tmo;
878 u32 cci;
879 int ret;
880
881 mutex_lock(&ucsi->ppm_lock);
882
883 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
884 sizeof(command));
885 if (ret < 0)
886 goto out;
887
888 tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
889
890 do {
891 if (time_is_before_jiffies(tmo)) {
892 ret = -ETIMEDOUT;
893 goto out;
894 }
895
896 ret = ucsi->ops->read(ucsi, UCSI_CCI, &cci, sizeof(cci));
897 if (ret)
898 goto out;
899
900 /* If the PPM is still doing something else, reset it again. */
901 if (cci & ~UCSI_CCI_RESET_COMPLETE) {
902 ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL,
903 &command,
904 sizeof(command));
905 if (ret < 0)
906 goto out;
907 }
908
909 msleep(20);
910 } while (!(cci & UCSI_CCI_RESET_COMPLETE));
911
912 out:
913 mutex_unlock(&ucsi->ppm_lock);
914 return ret;
915 }
916
ucsi_role_cmd(struct ucsi_connector * con,u64 command)917 static int ucsi_role_cmd(struct ucsi_connector *con, u64 command)
918 {
919 int ret;
920
921 ret = ucsi_send_command(con->ucsi, command, NULL, 0);
922 if (ret == -ETIMEDOUT) {
923 u64 c;
924
925 /* PPM most likely stopped responding. Resetting everything. */
926 ucsi_reset_ppm(con->ucsi);
927
928 c = UCSI_SET_NOTIFICATION_ENABLE | con->ucsi->ntfy;
929 ucsi_send_command(con->ucsi, c, NULL, 0);
930
931 ucsi_reset_connector(con, true);
932 }
933
934 return ret;
935 }
936
ucsi_dr_swap(struct typec_port * port,enum typec_data_role role)937 static int ucsi_dr_swap(struct typec_port *port, enum typec_data_role role)
938 {
939 struct ucsi_connector *con = typec_get_drvdata(port);
940 u8 partner_type;
941 u64 command;
942 int ret = 0;
943
944 mutex_lock(&con->lock);
945
946 if (!con->partner) {
947 ret = -ENOTCONN;
948 goto out_unlock;
949 }
950
951 partner_type = UCSI_CONSTAT_PARTNER_TYPE(con->status.flags);
952 if ((partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP &&
953 role == TYPEC_DEVICE) ||
954 (partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP &&
955 role == TYPEC_HOST))
956 goto out_unlock;
957
958 command = UCSI_SET_UOR | UCSI_CONNECTOR_NUMBER(con->num);
959 command |= UCSI_SET_UOR_ROLE(role);
960 command |= UCSI_SET_UOR_ACCEPT_ROLE_SWAPS;
961 ret = ucsi_role_cmd(con, command);
962 if (ret < 0)
963 goto out_unlock;
964
965 if (!wait_for_completion_timeout(&con->complete,
966 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
967 ret = -ETIMEDOUT;
968
969 out_unlock:
970 mutex_unlock(&con->lock);
971
972 return ret < 0 ? ret : 0;
973 }
974
ucsi_pr_swap(struct typec_port * port,enum typec_role role)975 static int ucsi_pr_swap(struct typec_port *port, enum typec_role role)
976 {
977 struct ucsi_connector *con = typec_get_drvdata(port);
978 enum typec_role cur_role;
979 u64 command;
980 int ret = 0;
981
982 mutex_lock(&con->lock);
983
984 if (!con->partner) {
985 ret = -ENOTCONN;
986 goto out_unlock;
987 }
988
989 cur_role = !!(con->status.flags & UCSI_CONSTAT_PWR_DIR);
990
991 if (cur_role == role)
992 goto out_unlock;
993
994 command = UCSI_SET_PDR | UCSI_CONNECTOR_NUMBER(con->num);
995 command |= UCSI_SET_PDR_ROLE(role);
996 command |= UCSI_SET_PDR_ACCEPT_ROLE_SWAPS;
997 ret = ucsi_role_cmd(con, command);
998 if (ret < 0)
999 goto out_unlock;
1000
1001 if (!wait_for_completion_timeout(&con->complete,
1002 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS))) {
1003 ret = -ETIMEDOUT;
1004 goto out_unlock;
1005 }
1006
1007 /* Something has gone wrong while swapping the role */
1008 if (UCSI_CONSTAT_PWR_OPMODE(con->status.flags) !=
1009 UCSI_CONSTAT_PWR_OPMODE_PD) {
1010 ucsi_reset_connector(con, true);
1011 ret = -EPROTO;
1012 }
1013
1014 out_unlock:
1015 mutex_unlock(&con->lock);
1016
1017 return ret;
1018 }
1019
1020 static const struct typec_operations ucsi_ops = {
1021 .dr_set = ucsi_dr_swap,
1022 .pr_set = ucsi_pr_swap
1023 };
1024
1025 /* Caller must call fwnode_handle_put() after use */
ucsi_find_fwnode(struct ucsi_connector * con)1026 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con)
1027 {
1028 struct fwnode_handle *fwnode;
1029 int i = 1;
1030
1031 device_for_each_child_node(con->ucsi->dev, fwnode)
1032 if (i++ == con->num)
1033 return fwnode;
1034 return NULL;
1035 }
1036
ucsi_register_port(struct ucsi * ucsi,int index)1037 static int ucsi_register_port(struct ucsi *ucsi, int index)
1038 {
1039 struct ucsi_connector *con = &ucsi->connector[index];
1040 struct typec_capability *cap = &con->typec_cap;
1041 enum typec_accessory *accessory = cap->accessory;
1042 enum usb_role u_role = USB_ROLE_NONE;
1043 u64 command;
1044 int ret;
1045
1046 INIT_WORK(&con->work, ucsi_handle_connector_change);
1047 init_completion(&con->complete);
1048 mutex_init(&con->lock);
1049 con->num = index + 1;
1050 con->ucsi = ucsi;
1051
1052 /* Delay other interactions with the con until registration is complete */
1053 mutex_lock(&con->lock);
1054
1055 /* Get connector capability */
1056 command = UCSI_GET_CONNECTOR_CAPABILITY;
1057 command |= UCSI_CONNECTOR_NUMBER(con->num);
1058 ret = ucsi_send_command(ucsi, command, &con->cap, sizeof(con->cap));
1059 if (ret < 0)
1060 goto out_unlock;
1061
1062 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP)
1063 cap->data = TYPEC_PORT_DRD;
1064 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP)
1065 cap->data = TYPEC_PORT_DFP;
1066 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP)
1067 cap->data = TYPEC_PORT_UFP;
1068
1069 if ((con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER) &&
1070 (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER))
1071 cap->type = TYPEC_PORT_DRP;
1072 else if (con->cap.flags & UCSI_CONCAP_FLAG_PROVIDER)
1073 cap->type = TYPEC_PORT_SRC;
1074 else if (con->cap.flags & UCSI_CONCAP_FLAG_CONSUMER)
1075 cap->type = TYPEC_PORT_SNK;
1076
1077 cap->revision = ucsi->cap.typec_version;
1078 cap->pd_revision = ucsi->cap.pd_version;
1079 cap->svdm_version = SVDM_VER_2_0;
1080 cap->prefer_role = TYPEC_NO_PREFERRED_ROLE;
1081
1082 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY)
1083 *accessory++ = TYPEC_ACCESSORY_AUDIO;
1084 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY)
1085 *accessory = TYPEC_ACCESSORY_DEBUG;
1086
1087 cap->fwnode = ucsi_find_fwnode(con);
1088 cap->driver_data = con;
1089 cap->ops = &ucsi_ops;
1090
1091 ret = ucsi_register_port_psy(con);
1092 if (ret)
1093 goto out;
1094
1095 /* Register the connector */
1096 con->port = typec_register_port(ucsi->dev, cap);
1097 if (IS_ERR(con->port)) {
1098 ret = PTR_ERR(con->port);
1099 goto out;
1100 }
1101
1102 /* Alternate modes */
1103 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_CON);
1104 if (ret) {
1105 dev_err(ucsi->dev, "con%d: failed to register alt modes\n",
1106 con->num);
1107 goto out;
1108 }
1109
1110 /* Get the status */
1111 command = UCSI_GET_CONNECTOR_STATUS | UCSI_CONNECTOR_NUMBER(con->num);
1112 ret = ucsi_send_command(ucsi, command, &con->status, sizeof(con->status));
1113 if (ret < 0) {
1114 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num);
1115 ret = 0;
1116 goto out;
1117 }
1118 ret = 0; /* ucsi_send_command() returns length on success */
1119
1120 switch (UCSI_CONSTAT_PARTNER_TYPE(con->status.flags)) {
1121 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
1122 case UCSI_CONSTAT_PARTNER_TYPE_CABLE_AND_UFP:
1123 u_role = USB_ROLE_HOST;
1124 fallthrough;
1125 case UCSI_CONSTAT_PARTNER_TYPE_CABLE:
1126 typec_set_data_role(con->port, TYPEC_HOST);
1127 break;
1128 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
1129 u_role = USB_ROLE_DEVICE;
1130 typec_set_data_role(con->port, TYPEC_DEVICE);
1131 break;
1132 default:
1133 break;
1134 }
1135
1136 /* Check if there is already something connected */
1137 if (con->status.flags & UCSI_CONSTAT_CONNECTED) {
1138 typec_set_pwr_role(con->port,
1139 !!(con->status.flags & UCSI_CONSTAT_PWR_DIR));
1140 ucsi_pwr_opmode_change(con);
1141 ucsi_register_partner(con);
1142 ucsi_port_psy_changed(con);
1143 }
1144
1145 con->usb_role_sw = fwnode_usb_role_switch_get(cap->fwnode);
1146 if (IS_ERR(con->usb_role_sw)) {
1147 dev_err(ucsi->dev, "con%d: failed to get usb role switch\n",
1148 con->num);
1149 con->usb_role_sw = NULL;
1150 }
1151
1152 /* Only notify USB controller if partner supports USB data */
1153 if (!(UCSI_CONSTAT_PARTNER_FLAGS(con->status.flags) & UCSI_CONSTAT_PARTNER_FLAG_USB))
1154 u_role = USB_ROLE_NONE;
1155
1156 ret = usb_role_switch_set_role(con->usb_role_sw, u_role);
1157 if (ret) {
1158 dev_err(ucsi->dev, "con:%d: failed to set usb role:%d\n",
1159 con->num, u_role);
1160 ret = 0;
1161 }
1162
1163 if (con->partner) {
1164 ret = ucsi_register_altmodes(con, UCSI_RECIPIENT_SOP);
1165 if (ret) {
1166 dev_err(ucsi->dev,
1167 "con%d: failed to register alternate modes\n",
1168 con->num);
1169 ret = 0;
1170 } else {
1171 ucsi_altmode_update_active(con);
1172 }
1173 }
1174
1175 trace_ucsi_register_port(con->num, &con->status);
1176
1177 out:
1178 fwnode_handle_put(cap->fwnode);
1179 out_unlock:
1180 mutex_unlock(&con->lock);
1181 return ret;
1182 }
1183
1184 /**
1185 * ucsi_init - Initialize UCSI interface
1186 * @ucsi: UCSI to be initialized
1187 *
1188 * Registers all ports @ucsi has and enables all notification events.
1189 */
ucsi_init(struct ucsi * ucsi)1190 static int ucsi_init(struct ucsi *ucsi)
1191 {
1192 struct ucsi_connector *con;
1193 u64 command;
1194 int ret;
1195 int i;
1196
1197 /* Reset the PPM */
1198 ret = ucsi_reset_ppm(ucsi);
1199 if (ret) {
1200 dev_err(ucsi->dev, "failed to reset PPM!\n");
1201 goto err;
1202 }
1203
1204 /* Enable basic notifications */
1205 ucsi->ntfy = UCSI_ENABLE_NTFY_CMD_COMPLETE | UCSI_ENABLE_NTFY_ERROR;
1206 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1207 ret = ucsi_send_command(ucsi, command, NULL, 0);
1208 if (ret < 0)
1209 goto err_reset;
1210
1211 /* Get PPM capabilities */
1212 command = UCSI_GET_CAPABILITY;
1213 ret = ucsi_send_command(ucsi, command, &ucsi->cap, sizeof(ucsi->cap));
1214 if (ret < 0)
1215 goto err_reset;
1216
1217 if (!ucsi->cap.num_connectors) {
1218 ret = -ENODEV;
1219 goto err_reset;
1220 }
1221
1222 /* Allocate the connectors. Released in ucsi_unregister_ppm() */
1223 ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1,
1224 sizeof(*ucsi->connector), GFP_KERNEL);
1225 if (!ucsi->connector) {
1226 ret = -ENOMEM;
1227 goto err_reset;
1228 }
1229
1230 /* Register all connectors */
1231 for (i = 0; i < ucsi->cap.num_connectors; i++) {
1232 ret = ucsi_register_port(ucsi, i);
1233 if (ret)
1234 goto err_unregister;
1235 }
1236
1237 /* Enable all notifications */
1238 ucsi->ntfy = UCSI_ENABLE_NTFY_ALL;
1239 command = UCSI_SET_NOTIFICATION_ENABLE | ucsi->ntfy;
1240 ret = ucsi_send_command(ucsi, command, NULL, 0);
1241 if (ret < 0)
1242 goto err_unregister;
1243
1244 return 0;
1245
1246 err_unregister:
1247 for (con = ucsi->connector; con->port; con++) {
1248 ucsi_unregister_partner(con);
1249 ucsi_unregister_altmodes(con, UCSI_RECIPIENT_CON);
1250 ucsi_unregister_port_psy(con);
1251 typec_unregister_port(con->port);
1252 con->port = NULL;
1253 }
1254
1255 err_reset:
1256 ucsi_reset_ppm(ucsi);
1257 err:
1258 return ret;
1259 }
1260
ucsi_init_work(struct work_struct * work)1261 static void ucsi_init_work(struct work_struct *work)
1262 {
1263 struct ucsi *ucsi = container_of(work, struct ucsi, work);
1264 int ret;
1265
1266 ret = ucsi_init(ucsi);
1267 if (ret)
1268 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret);
1269 }
1270
1271 /**
1272 * ucsi_get_drvdata - Return private driver data pointer
1273 * @ucsi: UCSI interface
1274 */
ucsi_get_drvdata(struct ucsi * ucsi)1275 void *ucsi_get_drvdata(struct ucsi *ucsi)
1276 {
1277 return ucsi->driver_data;
1278 }
1279 EXPORT_SYMBOL_GPL(ucsi_get_drvdata);
1280
1281 /**
1282 * ucsi_get_drvdata - Assign private driver data pointer
1283 * @ucsi: UCSI interface
1284 * @data: Private data pointer
1285 */
ucsi_set_drvdata(struct ucsi * ucsi,void * data)1286 void ucsi_set_drvdata(struct ucsi *ucsi, void *data)
1287 {
1288 ucsi->driver_data = data;
1289 }
1290 EXPORT_SYMBOL_GPL(ucsi_set_drvdata);
1291
1292 /**
1293 * ucsi_create - Allocate UCSI instance
1294 * @dev: Device interface to the PPM (Platform Policy Manager)
1295 * @ops: I/O routines
1296 */
ucsi_create(struct device * dev,const struct ucsi_operations * ops)1297 struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops)
1298 {
1299 struct ucsi *ucsi;
1300
1301 if (!ops || !ops->read || !ops->sync_write || !ops->async_write)
1302 return ERR_PTR(-EINVAL);
1303
1304 ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
1305 if (!ucsi)
1306 return ERR_PTR(-ENOMEM);
1307
1308 INIT_WORK(&ucsi->work, ucsi_init_work);
1309 mutex_init(&ucsi->ppm_lock);
1310 ucsi->dev = dev;
1311 ucsi->ops = ops;
1312
1313 return ucsi;
1314 }
1315 EXPORT_SYMBOL_GPL(ucsi_create);
1316
1317 /**
1318 * ucsi_destroy - Free UCSI instance
1319 * @ucsi: UCSI instance to be freed
1320 */
ucsi_destroy(struct ucsi * ucsi)1321 void ucsi_destroy(struct ucsi *ucsi)
1322 {
1323 kfree(ucsi);
1324 }
1325 EXPORT_SYMBOL_GPL(ucsi_destroy);
1326
1327 /**
1328 * ucsi_register - Register UCSI interface
1329 * @ucsi: UCSI instance
1330 */
ucsi_register(struct ucsi * ucsi)1331 int ucsi_register(struct ucsi *ucsi)
1332 {
1333 int ret;
1334
1335 ret = ucsi->ops->read(ucsi, UCSI_VERSION, &ucsi->version,
1336 sizeof(ucsi->version));
1337 if (ret)
1338 return ret;
1339
1340 if (!ucsi->version)
1341 return -ENODEV;
1342
1343 queue_work(system_long_wq, &ucsi->work);
1344
1345 return 0;
1346 }
1347 EXPORT_SYMBOL_GPL(ucsi_register);
1348
1349 /**
1350 * ucsi_unregister - Unregister UCSI interface
1351 * @ucsi: UCSI interface to be unregistered
1352 *
1353 * Unregister UCSI interface that was created with ucsi_register().
1354 */
ucsi_unregister(struct ucsi * ucsi)1355 void ucsi_unregister(struct ucsi *ucsi)
1356 {
1357 u64 cmd = UCSI_SET_NOTIFICATION_ENABLE;
1358 int i;
1359
1360 /* Make sure that we are not in the middle of driver initialization */
1361 cancel_work_sync(&ucsi->work);
1362
1363 /* Disable notifications */
1364 ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
1365
1366 for (i = 0; i < ucsi->cap.num_connectors; i++) {
1367 cancel_work_sync(&ucsi->connector[i].work);
1368 ucsi_unregister_partner(&ucsi->connector[i]);
1369 ucsi_unregister_altmodes(&ucsi->connector[i],
1370 UCSI_RECIPIENT_CON);
1371 ucsi_unregister_port_psy(&ucsi->connector[i]);
1372 typec_unregister_port(ucsi->connector[i].port);
1373 }
1374
1375 kfree(ucsi->connector);
1376 }
1377 EXPORT_SYMBOL_GPL(ucsi_unregister);
1378
1379 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
1380 MODULE_LICENSE("GPL v2");
1381 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");
1382