1 /*
2 * USB Type-C Connector System Software Interface driver
3 *
4 * Copyright (C) 2017, Intel Corporation
5 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/completion.h>
13 #include <linux/property.h>
14 #include <linux/device.h>
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/slab.h>
18 #include <linux/usb/typec.h>
19
20 #include "ucsi.h"
21 #include "trace.h"
22
23 #define to_ucsi_connector(_cap_) container_of(_cap_, struct ucsi_connector, \
24 typec_cap)
25
26 /*
27 * UCSI_TIMEOUT_MS - PPM communication timeout
28 *
29 * Ideally we could use MIN_TIME_TO_RESPOND_WITH_BUSY (which is defined in UCSI
30 * specification) here as reference, but unfortunately we can't. It is very
31 * difficult to estimate the time it takes for the system to process the command
32 * before it is actually passed to the PPM.
33 */
34 #define UCSI_TIMEOUT_MS 5000
35
36 /*
37 * UCSI_SWAP_TIMEOUT_MS - Timeout for role swap requests
38 *
39 * 5 seconds is close to the time it takes for CapsCounter to reach 0, so even
40 * if the PPM does not generate Connector Change events before that with
41 * partners that do not support USB Power Delivery, this should still work.
42 */
43 #define UCSI_SWAP_TIMEOUT_MS 5000
44
45 enum ucsi_status {
46 UCSI_IDLE = 0,
47 UCSI_BUSY,
48 UCSI_ERROR,
49 };
50
51 struct ucsi_connector {
52 int num;
53
54 struct ucsi *ucsi;
55 struct work_struct work;
56 struct completion complete;
57
58 struct typec_port *port;
59 struct typec_partner *partner;
60
61 struct typec_capability typec_cap;
62
63 struct ucsi_connector_status status;
64 struct ucsi_connector_capability cap;
65 };
66
67 struct ucsi {
68 struct device *dev;
69 struct ucsi_ppm *ppm;
70
71 enum ucsi_status status;
72 struct completion complete;
73 struct ucsi_capability cap;
74 struct ucsi_connector *connector;
75
76 struct work_struct work;
77
78 /* PPM Communication lock */
79 struct mutex ppm_lock;
80
81 /* PPM communication flags */
82 unsigned long flags;
83 #define EVENT_PENDING 0
84 #define COMMAND_PENDING 1
85 #define ACK_PENDING 2
86 };
87
ucsi_sync(struct ucsi * ucsi)88 static inline int ucsi_sync(struct ucsi *ucsi)
89 {
90 if (ucsi->ppm && ucsi->ppm->sync)
91 return ucsi->ppm->sync(ucsi->ppm);
92 return 0;
93 }
94
ucsi_command(struct ucsi * ucsi,struct ucsi_control * ctrl)95 static int ucsi_command(struct ucsi *ucsi, struct ucsi_control *ctrl)
96 {
97 int ret;
98
99 trace_ucsi_command(ctrl);
100
101 set_bit(COMMAND_PENDING, &ucsi->flags);
102
103 ret = ucsi->ppm->cmd(ucsi->ppm, ctrl);
104 if (ret)
105 goto err_clear_flag;
106
107 if (!wait_for_completion_timeout(&ucsi->complete,
108 msecs_to_jiffies(UCSI_TIMEOUT_MS))) {
109 dev_warn(ucsi->dev, "PPM NOT RESPONDING\n");
110 ret = -ETIMEDOUT;
111 }
112
113 err_clear_flag:
114 clear_bit(COMMAND_PENDING, &ucsi->flags);
115
116 return ret;
117 }
118
ucsi_ack(struct ucsi * ucsi,u8 ack)119 static int ucsi_ack(struct ucsi *ucsi, u8 ack)
120 {
121 struct ucsi_control ctrl;
122 int ret;
123
124 trace_ucsi_ack(ack);
125
126 set_bit(ACK_PENDING, &ucsi->flags);
127
128 UCSI_CMD_ACK(ctrl, ack);
129 ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);
130 if (ret)
131 goto out_clear_bit;
132
133 /* Waiting for ACK with ACK CMD, but not with EVENT for now */
134 if (ack == UCSI_ACK_EVENT)
135 goto out_clear_bit;
136
137 if (!wait_for_completion_timeout(&ucsi->complete,
138 msecs_to_jiffies(UCSI_TIMEOUT_MS)))
139 ret = -ETIMEDOUT;
140
141 out_clear_bit:
142 clear_bit(ACK_PENDING, &ucsi->flags);
143
144 if (ret)
145 dev_err(ucsi->dev, "%s: failed\n", __func__);
146
147 return ret;
148 }
149
ucsi_run_command(struct ucsi * ucsi,struct ucsi_control * ctrl,void * data,size_t size)150 static int ucsi_run_command(struct ucsi *ucsi, struct ucsi_control *ctrl,
151 void *data, size_t size)
152 {
153 struct ucsi_control _ctrl;
154 u8 data_length;
155 u16 error;
156 int ret;
157
158 ret = ucsi_command(ucsi, ctrl);
159 if (ret)
160 goto err;
161
162 switch (ucsi->status) {
163 case UCSI_IDLE:
164 ret = ucsi_sync(ucsi);
165 if (ret)
166 dev_warn(ucsi->dev, "%s: sync failed\n", __func__);
167
168 if (data)
169 memcpy(data, ucsi->ppm->data->message_in, size);
170
171 data_length = ucsi->ppm->data->cci.data_length;
172
173 ret = ucsi_ack(ucsi, UCSI_ACK_CMD);
174 if (!ret)
175 ret = data_length;
176 break;
177 case UCSI_BUSY:
178 /* The caller decides whether to cancel or not */
179 ret = -EBUSY;
180 break;
181 case UCSI_ERROR:
182 ret = ucsi_ack(ucsi, UCSI_ACK_CMD);
183 if (ret)
184 break;
185
186 _ctrl.raw_cmd = 0;
187 _ctrl.cmd.cmd = UCSI_GET_ERROR_STATUS;
188 ret = ucsi_command(ucsi, &_ctrl);
189 if (ret) {
190 dev_err(ucsi->dev, "reading error failed!\n");
191 break;
192 }
193
194 memcpy(&error, ucsi->ppm->data->message_in, sizeof(error));
195
196 /* Something has really gone wrong */
197 if (WARN_ON(ucsi->status == UCSI_ERROR)) {
198 ret = -ENODEV;
199 break;
200 }
201
202 ret = ucsi_ack(ucsi, UCSI_ACK_CMD);
203 if (ret)
204 break;
205
206 switch (error) {
207 case UCSI_ERROR_INCOMPATIBLE_PARTNER:
208 ret = -EOPNOTSUPP;
209 break;
210 case UCSI_ERROR_CC_COMMUNICATION_ERR:
211 ret = -ECOMM;
212 break;
213 case UCSI_ERROR_CONTRACT_NEGOTIATION_FAIL:
214 ret = -EPROTO;
215 break;
216 case UCSI_ERROR_DEAD_BATTERY:
217 dev_warn(ucsi->dev, "Dead battery condition!\n");
218 ret = -EPERM;
219 break;
220 /* The following mean a bug in this driver */
221 case UCSI_ERROR_INVALID_CON_NUM:
222 case UCSI_ERROR_UNREGONIZED_CMD:
223 case UCSI_ERROR_INVALID_CMD_ARGUMENT:
224 dev_warn(ucsi->dev,
225 "%s: possible UCSI driver bug - error 0x%x\n",
226 __func__, error);
227 ret = -EINVAL;
228 break;
229 default:
230 dev_warn(ucsi->dev,
231 "%s: error without status\n", __func__);
232 ret = -EIO;
233 break;
234 }
235 break;
236 }
237
238 err:
239 trace_ucsi_run_command(ctrl, ret);
240
241 return ret;
242 }
243
244 /* -------------------------------------------------------------------------- */
245
ucsi_pwr_opmode_change(struct ucsi_connector * con)246 static void ucsi_pwr_opmode_change(struct ucsi_connector *con)
247 {
248 switch (con->status.pwr_op_mode) {
249 case UCSI_CONSTAT_PWR_OPMODE_PD:
250 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_PD);
251 break;
252 case UCSI_CONSTAT_PWR_OPMODE_TYPEC1_5:
253 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_1_5A);
254 break;
255 case UCSI_CONSTAT_PWR_OPMODE_TYPEC3_0:
256 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_3_0A);
257 break;
258 default:
259 typec_set_pwr_opmode(con->port, TYPEC_PWR_MODE_USB);
260 break;
261 }
262 }
263
ucsi_register_partner(struct ucsi_connector * con)264 static int ucsi_register_partner(struct ucsi_connector *con)
265 {
266 struct typec_partner_desc partner;
267
268 if (con->partner)
269 return 0;
270
271 memset(&partner, 0, sizeof(partner));
272
273 switch (con->status.partner_type) {
274 case UCSI_CONSTAT_PARTNER_TYPE_DEBUG:
275 partner.accessory = TYPEC_ACCESSORY_DEBUG;
276 break;
277 case UCSI_CONSTAT_PARTNER_TYPE_AUDIO:
278 partner.accessory = TYPEC_ACCESSORY_AUDIO;
279 break;
280 default:
281 break;
282 }
283
284 partner.usb_pd = con->status.pwr_op_mode == UCSI_CONSTAT_PWR_OPMODE_PD;
285
286 con->partner = typec_register_partner(con->port, &partner);
287 if (!con->partner) {
288 dev_err(con->ucsi->dev, "con%d: failed to register partner\n",
289 con->num);
290 return -ENODEV;
291 }
292
293 return 0;
294 }
295
ucsi_unregister_partner(struct ucsi_connector * con)296 static void ucsi_unregister_partner(struct ucsi_connector *con)
297 {
298 typec_unregister_partner(con->partner);
299 con->partner = NULL;
300 }
301
ucsi_connector_change(struct work_struct * work)302 static void ucsi_connector_change(struct work_struct *work)
303 {
304 struct ucsi_connector *con = container_of(work, struct ucsi_connector,
305 work);
306 struct ucsi *ucsi = con->ucsi;
307 struct ucsi_control ctrl;
308 int ret;
309
310 mutex_lock(&ucsi->ppm_lock);
311
312 UCSI_CMD_GET_CONNECTOR_STATUS(ctrl, con->num);
313 ret = ucsi_run_command(ucsi, &ctrl, &con->status, sizeof(con->status));
314 if (ret < 0) {
315 dev_err(ucsi->dev, "%s: GET_CONNECTOR_STATUS failed (%d)\n",
316 __func__, ret);
317 goto out_unlock;
318 }
319
320 if (con->status.change & UCSI_CONSTAT_POWER_OPMODE_CHANGE)
321 ucsi_pwr_opmode_change(con);
322
323 if (con->status.change & UCSI_CONSTAT_POWER_DIR_CHANGE) {
324 typec_set_pwr_role(con->port, con->status.pwr_dir);
325
326 /* Complete pending power role swap */
327 if (!completion_done(&con->complete))
328 complete(&con->complete);
329 }
330
331 if (con->status.change & UCSI_CONSTAT_PARTNER_CHANGE) {
332 switch (con->status.partner_type) {
333 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
334 typec_set_data_role(con->port, TYPEC_HOST);
335 break;
336 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
337 typec_set_data_role(con->port, TYPEC_DEVICE);
338 break;
339 default:
340 break;
341 }
342
343 /* Complete pending data role swap */
344 if (!completion_done(&con->complete))
345 complete(&con->complete);
346 }
347
348 if (con->status.change & UCSI_CONSTAT_CONNECT_CHANGE) {
349 typec_set_pwr_role(con->port, con->status.pwr_dir);
350
351 switch (con->status.partner_type) {
352 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
353 typec_set_data_role(con->port, TYPEC_HOST);
354 break;
355 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
356 typec_set_data_role(con->port, TYPEC_DEVICE);
357 break;
358 default:
359 break;
360 }
361
362 if (con->status.connected)
363 ucsi_register_partner(con);
364 else
365 ucsi_unregister_partner(con);
366 }
367
368 ret = ucsi_ack(ucsi, UCSI_ACK_EVENT);
369 if (ret)
370 dev_err(ucsi->dev, "%s: ACK failed (%d)", __func__, ret);
371
372 trace_ucsi_connector_change(con->num, &con->status);
373
374 out_unlock:
375 clear_bit(EVENT_PENDING, &ucsi->flags);
376 mutex_unlock(&ucsi->ppm_lock);
377 }
378
379 /**
380 * ucsi_notify - PPM notification handler
381 * @ucsi: Source UCSI Interface for the notifications
382 *
383 * Handle notifications from PPM of @ucsi.
384 */
ucsi_notify(struct ucsi * ucsi)385 void ucsi_notify(struct ucsi *ucsi)
386 {
387 struct ucsi_cci *cci;
388
389 /* There is no requirement to sync here, but no harm either. */
390 ucsi_sync(ucsi);
391
392 cci = &ucsi->ppm->data->cci;
393
394 if (cci->error)
395 ucsi->status = UCSI_ERROR;
396 else if (cci->busy)
397 ucsi->status = UCSI_BUSY;
398 else
399 ucsi->status = UCSI_IDLE;
400
401 if (cci->cmd_complete && test_bit(COMMAND_PENDING, &ucsi->flags)) {
402 complete(&ucsi->complete);
403 } else if (cci->ack_complete && test_bit(ACK_PENDING, &ucsi->flags)) {
404 complete(&ucsi->complete);
405 } else if (cci->connector_change) {
406 struct ucsi_connector *con;
407
408 con = &ucsi->connector[cci->connector_change - 1];
409
410 if (!test_and_set_bit(EVENT_PENDING, &ucsi->flags))
411 schedule_work(&con->work);
412 }
413
414 trace_ucsi_notify(ucsi->ppm->data->raw_cci);
415 }
416 EXPORT_SYMBOL_GPL(ucsi_notify);
417
418 /* -------------------------------------------------------------------------- */
419
ucsi_reset_connector(struct ucsi_connector * con,bool hard)420 static int ucsi_reset_connector(struct ucsi_connector *con, bool hard)
421 {
422 struct ucsi_control ctrl;
423
424 UCSI_CMD_CONNECTOR_RESET(ctrl, con, hard);
425
426 return ucsi_run_command(con->ucsi, &ctrl, NULL, 0);
427 }
428
ucsi_reset_ppm(struct ucsi * ucsi)429 static int ucsi_reset_ppm(struct ucsi *ucsi)
430 {
431 struct ucsi_control ctrl;
432 unsigned long tmo;
433 int ret;
434
435 ctrl.raw_cmd = 0;
436 ctrl.cmd.cmd = UCSI_PPM_RESET;
437 trace_ucsi_command(&ctrl);
438 ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);
439 if (ret)
440 goto err;
441
442 tmo = jiffies + msecs_to_jiffies(UCSI_TIMEOUT_MS);
443
444 do {
445 /* Here sync is critical. */
446 ret = ucsi_sync(ucsi);
447 if (ret)
448 goto err;
449
450 if (ucsi->ppm->data->cci.reset_complete)
451 break;
452
453 /* If the PPM is still doing something else, reset it again. */
454 if (ucsi->ppm->data->raw_cci) {
455 dev_warn_ratelimited(ucsi->dev,
456 "Failed to reset PPM! Trying again..\n");
457
458 trace_ucsi_command(&ctrl);
459 ret = ucsi->ppm->cmd(ucsi->ppm, &ctrl);
460 if (ret)
461 goto err;
462 }
463
464 /* Letting the PPM settle down. */
465 msleep(20);
466
467 ret = -ETIMEDOUT;
468 } while (time_is_after_jiffies(tmo));
469
470 err:
471 trace_ucsi_reset_ppm(&ctrl, ret);
472
473 return ret;
474 }
475
ucsi_role_cmd(struct ucsi_connector * con,struct ucsi_control * ctrl)476 static int ucsi_role_cmd(struct ucsi_connector *con, struct ucsi_control *ctrl)
477 {
478 int ret;
479
480 ret = ucsi_run_command(con->ucsi, ctrl, NULL, 0);
481 if (ret == -ETIMEDOUT) {
482 struct ucsi_control c;
483
484 /* PPM most likely stopped responding. Resetting everything. */
485 ucsi_reset_ppm(con->ucsi);
486
487 UCSI_CMD_SET_NTFY_ENABLE(c, UCSI_ENABLE_NTFY_ALL);
488 ucsi_run_command(con->ucsi, &c, NULL, 0);
489
490 ucsi_reset_connector(con, true);
491 }
492
493 return ret;
494 }
495
496 static int
ucsi_dr_swap(const struct typec_capability * cap,enum typec_data_role role)497 ucsi_dr_swap(const struct typec_capability *cap, enum typec_data_role role)
498 {
499 struct ucsi_connector *con = to_ucsi_connector(cap);
500 struct ucsi_control ctrl;
501 int ret = 0;
502
503 if (!con->partner)
504 return -ENOTCONN;
505
506 mutex_lock(&con->ucsi->ppm_lock);
507
508 if ((con->status.partner_type == UCSI_CONSTAT_PARTNER_TYPE_DFP &&
509 role == TYPEC_DEVICE) ||
510 (con->status.partner_type == UCSI_CONSTAT_PARTNER_TYPE_UFP &&
511 role == TYPEC_HOST))
512 goto out_unlock;
513
514 UCSI_CMD_SET_UOR(ctrl, con, role);
515 ret = ucsi_role_cmd(con, &ctrl);
516 if (ret < 0)
517 goto out_unlock;
518
519 mutex_unlock(&con->ucsi->ppm_lock);
520
521 if (!wait_for_completion_timeout(&con->complete,
522 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
523 return -ETIMEDOUT;
524
525 return 0;
526
527 out_unlock:
528 mutex_unlock(&con->ucsi->ppm_lock);
529
530 return ret;
531 }
532
533 static int
ucsi_pr_swap(const struct typec_capability * cap,enum typec_role role)534 ucsi_pr_swap(const struct typec_capability *cap, enum typec_role role)
535 {
536 struct ucsi_connector *con = to_ucsi_connector(cap);
537 struct ucsi_control ctrl;
538 int ret = 0;
539
540 if (!con->partner)
541 return -ENOTCONN;
542
543 mutex_lock(&con->ucsi->ppm_lock);
544
545 if (con->status.pwr_dir == role)
546 goto out_unlock;
547
548 UCSI_CMD_SET_PDR(ctrl, con, role);
549 ret = ucsi_role_cmd(con, &ctrl);
550 if (ret < 0)
551 goto out_unlock;
552
553 mutex_unlock(&con->ucsi->ppm_lock);
554
555 if (!wait_for_completion_timeout(&con->complete,
556 msecs_to_jiffies(UCSI_SWAP_TIMEOUT_MS)))
557 return -ETIMEDOUT;
558
559 mutex_lock(&con->ucsi->ppm_lock);
560
561 /* Something has gone wrong while swapping the role */
562 if (con->status.pwr_op_mode != UCSI_CONSTAT_PWR_OPMODE_PD) {
563 ucsi_reset_connector(con, true);
564 ret = -EPROTO;
565 }
566
567 out_unlock:
568 mutex_unlock(&con->ucsi->ppm_lock);
569
570 return ret;
571 }
572
ucsi_find_fwnode(struct ucsi_connector * con)573 static struct fwnode_handle *ucsi_find_fwnode(struct ucsi_connector *con)
574 {
575 struct fwnode_handle *fwnode;
576 int i = 1;
577
578 device_for_each_child_node(con->ucsi->dev, fwnode)
579 if (i++ == con->num)
580 return fwnode;
581 return NULL;
582 }
583
ucsi_register_port(struct ucsi * ucsi,int index)584 static int ucsi_register_port(struct ucsi *ucsi, int index)
585 {
586 struct ucsi_connector *con = &ucsi->connector[index];
587 struct typec_capability *cap = &con->typec_cap;
588 enum typec_accessory *accessory = cap->accessory;
589 struct ucsi_control ctrl;
590 int ret;
591
592 INIT_WORK(&con->work, ucsi_connector_change);
593 init_completion(&con->complete);
594 con->num = index + 1;
595 con->ucsi = ucsi;
596
597 /* Get connector capability */
598 UCSI_CMD_GET_CONNECTOR_CAPABILITY(ctrl, con->num);
599 ret = ucsi_run_command(ucsi, &ctrl, &con->cap, sizeof(con->cap));
600 if (ret < 0)
601 return ret;
602
603 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DRP)
604 cap->type = TYPEC_PORT_DRP;
605 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DFP)
606 cap->type = TYPEC_PORT_DFP;
607 else if (con->cap.op_mode & UCSI_CONCAP_OPMODE_UFP)
608 cap->type = TYPEC_PORT_UFP;
609
610 cap->revision = ucsi->cap.typec_version;
611 cap->pd_revision = ucsi->cap.pd_version;
612 cap->prefer_role = TYPEC_NO_PREFERRED_ROLE;
613
614 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_AUDIO_ACCESSORY)
615 *accessory++ = TYPEC_ACCESSORY_AUDIO;
616 if (con->cap.op_mode & UCSI_CONCAP_OPMODE_DEBUG_ACCESSORY)
617 *accessory = TYPEC_ACCESSORY_DEBUG;
618
619 cap->fwnode = ucsi_find_fwnode(con);
620 cap->dr_set = ucsi_dr_swap;
621 cap->pr_set = ucsi_pr_swap;
622
623 /* Register the connector */
624 con->port = typec_register_port(ucsi->dev, cap);
625 if (!con->port)
626 return -ENODEV;
627
628 /* Get the status */
629 UCSI_CMD_GET_CONNECTOR_STATUS(ctrl, con->num);
630 ret = ucsi_run_command(ucsi, &ctrl, &con->status, sizeof(con->status));
631 if (ret < 0) {
632 dev_err(ucsi->dev, "con%d: failed to get status\n", con->num);
633 return 0;
634 }
635
636 ucsi_pwr_opmode_change(con);
637 typec_set_pwr_role(con->port, con->status.pwr_dir);
638
639 switch (con->status.partner_type) {
640 case UCSI_CONSTAT_PARTNER_TYPE_UFP:
641 typec_set_data_role(con->port, TYPEC_HOST);
642 break;
643 case UCSI_CONSTAT_PARTNER_TYPE_DFP:
644 typec_set_data_role(con->port, TYPEC_DEVICE);
645 break;
646 default:
647 break;
648 }
649
650 /* Check if there is already something connected */
651 if (con->status.connected)
652 ucsi_register_partner(con);
653
654 trace_ucsi_register_port(con->num, &con->status);
655
656 return 0;
657 }
658
ucsi_init(struct work_struct * work)659 static void ucsi_init(struct work_struct *work)
660 {
661 struct ucsi *ucsi = container_of(work, struct ucsi, work);
662 struct ucsi_connector *con;
663 struct ucsi_control ctrl;
664 int ret;
665 int i;
666
667 mutex_lock(&ucsi->ppm_lock);
668
669 /* Reset the PPM */
670 ret = ucsi_reset_ppm(ucsi);
671 if (ret) {
672 dev_err(ucsi->dev, "failed to reset PPM!\n");
673 goto err;
674 }
675
676 /* Enable basic notifications */
677 UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_CMD_COMPLETE |
678 UCSI_ENABLE_NTFY_ERROR);
679 ret = ucsi_run_command(ucsi, &ctrl, NULL, 0);
680 if (ret < 0)
681 goto err_reset;
682
683 /* Get PPM capabilities */
684 UCSI_CMD_GET_CAPABILITY(ctrl);
685 ret = ucsi_run_command(ucsi, &ctrl, &ucsi->cap, sizeof(ucsi->cap));
686 if (ret < 0)
687 goto err_reset;
688
689 if (!ucsi->cap.num_connectors) {
690 ret = -ENODEV;
691 goto err_reset;
692 }
693
694 /* Allocate the connectors. Released in ucsi_unregister_ppm() */
695 ucsi->connector = kcalloc(ucsi->cap.num_connectors + 1,
696 sizeof(*ucsi->connector), GFP_KERNEL);
697 if (!ucsi->connector) {
698 ret = -ENOMEM;
699 goto err_reset;
700 }
701
702 /* Register all connectors */
703 for (i = 0; i < ucsi->cap.num_connectors; i++) {
704 ret = ucsi_register_port(ucsi, i);
705 if (ret)
706 goto err_unregister;
707 }
708
709 /* Enable all notifications */
710 UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_ALL);
711 ret = ucsi_run_command(ucsi, &ctrl, NULL, 0);
712 if (ret < 0)
713 goto err_unregister;
714
715 mutex_unlock(&ucsi->ppm_lock);
716
717 return;
718
719 err_unregister:
720 for (con = ucsi->connector; con->port; con++) {
721 ucsi_unregister_partner(con);
722 typec_unregister_port(con->port);
723 con->port = NULL;
724 }
725
726 err_reset:
727 ucsi_reset_ppm(ucsi);
728 err:
729 mutex_unlock(&ucsi->ppm_lock);
730 dev_err(ucsi->dev, "PPM init failed (%d)\n", ret);
731 }
732
733 /**
734 * ucsi_register_ppm - Register UCSI PPM Interface
735 * @dev: Device interface to the PPM
736 * @ppm: The PPM interface
737 *
738 * Allocates UCSI instance, associates it with @ppm and returns it to the
739 * caller, and schedules initialization of the interface.
740 */
ucsi_register_ppm(struct device * dev,struct ucsi_ppm * ppm)741 struct ucsi *ucsi_register_ppm(struct device *dev, struct ucsi_ppm *ppm)
742 {
743 struct ucsi *ucsi;
744
745 ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
746 if (!ucsi)
747 return ERR_PTR(-ENOMEM);
748
749 INIT_WORK(&ucsi->work, ucsi_init);
750 init_completion(&ucsi->complete);
751 mutex_init(&ucsi->ppm_lock);
752
753 ucsi->dev = dev;
754 ucsi->ppm = ppm;
755
756 /*
757 * Communication with the PPM takes a lot of time. It is not reasonable
758 * to initialize the driver here. Using a work for now.
759 */
760 queue_work(system_long_wq, &ucsi->work);
761
762 return ucsi;
763 }
764 EXPORT_SYMBOL_GPL(ucsi_register_ppm);
765
766 /**
767 * ucsi_unregister_ppm - Unregister UCSI PPM Interface
768 * @ucsi: struct ucsi associated with the PPM
769 *
770 * Unregister UCSI PPM that was created with ucsi_register().
771 */
ucsi_unregister_ppm(struct ucsi * ucsi)772 void ucsi_unregister_ppm(struct ucsi *ucsi)
773 {
774 struct ucsi_control ctrl;
775 int i;
776
777 /* Make sure that we are not in the middle of driver initialization */
778 cancel_work_sync(&ucsi->work);
779
780 mutex_lock(&ucsi->ppm_lock);
781
782 /* Disable everything except command complete notification */
783 UCSI_CMD_SET_NTFY_ENABLE(ctrl, UCSI_ENABLE_NTFY_CMD_COMPLETE)
784 ucsi_run_command(ucsi, &ctrl, NULL, 0);
785
786 mutex_unlock(&ucsi->ppm_lock);
787
788 for (i = 0; i < ucsi->cap.num_connectors; i++) {
789 cancel_work_sync(&ucsi->connector[i].work);
790 ucsi_unregister_partner(&ucsi->connector[i]);
791 typec_unregister_port(ucsi->connector[i].port);
792 }
793
794 ucsi_reset_ppm(ucsi);
795
796 kfree(ucsi->connector);
797 kfree(ucsi);
798 }
799 EXPORT_SYMBOL_GPL(ucsi_unregister_ppm);
800
801 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
802 MODULE_LICENSE("GPL v2");
803 MODULE_DESCRIPTION("USB Type-C Connector System Software Interface driver");
804