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