1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2015-2017 Google, Inc
4 *
5 * USB Power Delivery protocol stack.
6 */
7
8 #include <asm/io.h>
9 #include <common.h>
10 #include <dm.h>
11 #include <asm/gpio.h>
12 #include <irq-generic.h>
13 #include <rk_timer_irq.h>
14 #include <power/power_delivery/tcpm.h>
15 #include <power/power_delivery/pd_vdo.h>
16
17 #define FOREACH_STATE(S) \
18 S(INVALID_STATE), \
19 S(TOGGLING), \
20 S(SRC_UNATTACHED), \
21 S(SRC_ATTACH_WAIT), \
22 S(SRC_ATTACHED), \
23 S(SRC_STARTUP), \
24 S(SRC_SEND_CAPABILITIES), \
25 S(SRC_SEND_CAPABILITIES_TIMEOUT), \
26 S(SRC_NEGOTIATE_CAPABILITIES), \
27 S(SRC_TRANSITION_SUPPLY), \
28 S(SRC_READY), \
29 S(SRC_WAIT_NEW_CAPABILITIES), \
30 \
31 S(SNK_UNATTACHED), \
32 S(SNK_ATTACH_WAIT), \
33 S(SNK_DEBOUNCED), \
34 S(SNK_ATTACHED), \
35 S(SNK_STARTUP), \
36 S(SNK_DISCOVERY), \
37 S(SNK_DISCOVERY_DEBOUNCE), \
38 S(SNK_DISCOVERY_DEBOUNCE_DONE), \
39 S(SNK_WAIT_CAPABILITIES), \
40 S(SNK_NEGOTIATE_CAPABILITIES), \
41 S(SNK_NEGOTIATE_PPS_CAPABILITIES), \
42 S(SNK_TRANSITION_SINK), \
43 S(SNK_TRANSITION_SINK_VBUS), \
44 S(SNK_READY), \
45 \
46 S(ACC_UNATTACHED), \
47 S(DEBUG_ACC_ATTACHED), \
48 S(AUDIO_ACC_ATTACHED), \
49 S(AUDIO_ACC_DEBOUNCE), \
50 \
51 S(HARD_RESET_SEND), \
52 S(HARD_RESET_START), \
53 S(SRC_HARD_RESET_VBUS_OFF), \
54 S(SRC_HARD_RESET_VBUS_ON), \
55 S(SNK_HARD_RESET_SINK_OFF), \
56 S(SNK_HARD_RESET_WAIT_VBUS), \
57 S(SNK_HARD_RESET_SINK_ON), \
58 \
59 S(SOFT_RESET), \
60 S(SRC_SOFT_RESET_WAIT_SNK_TX), \
61 S(SNK_SOFT_RESET), \
62 S(SOFT_RESET_SEND), \
63 \
64 S(DR_SWAP_ACCEPT), \
65 S(DR_SWAP_SEND), \
66 S(DR_SWAP_SEND_TIMEOUT), \
67 S(DR_SWAP_CANCEL), \
68 S(DR_SWAP_CHANGE_DR), \
69 \
70 S(PR_SWAP_ACCEPT), \
71 S(PR_SWAP_SEND), \
72 S(PR_SWAP_SEND_TIMEOUT), \
73 S(PR_SWAP_CANCEL), \
74 S(PR_SWAP_START), \
75 S(PR_SWAP_SRC_SNK_TRANSITION_OFF), \
76 S(PR_SWAP_SRC_SNK_SOURCE_OFF), \
77 S(PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED), \
78 S(PR_SWAP_SRC_SNK_SINK_ON), \
79 S(PR_SWAP_SNK_SRC_SINK_OFF), \
80 S(PR_SWAP_SNK_SRC_SOURCE_ON), \
81 S(PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP), \
82 \
83 S(VCONN_SWAP_ACCEPT), \
84 S(VCONN_SWAP_SEND), \
85 S(VCONN_SWAP_SEND_TIMEOUT), \
86 S(VCONN_SWAP_CANCEL), \
87 S(VCONN_SWAP_START), \
88 S(VCONN_SWAP_WAIT_FOR_VCONN), \
89 S(VCONN_SWAP_TURN_ON_VCONN), \
90 S(VCONN_SWAP_TURN_OFF_VCONN), \
91 \
92 S(FR_SWAP_SEND), \
93 S(FR_SWAP_SEND_TIMEOUT), \
94 S(FR_SWAP_SNK_SRC_TRANSITION_TO_OFF), \
95 S(FR_SWAP_SNK_SRC_NEW_SINK_READY), \
96 S(FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED), \
97 S(FR_SWAP_CANCEL), \
98 \
99 S(SNK_TRY), \
100 S(SNK_TRY_WAIT), \
101 S(SNK_TRY_WAIT_DEBOUNCE), \
102 S(SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS), \
103 S(SRC_TRYWAIT), \
104 S(SRC_TRYWAIT_DEBOUNCE), \
105 S(SRC_TRYWAIT_UNATTACHED), \
106 \
107 S(SRC_TRY), \
108 S(SRC_TRY_WAIT), \
109 S(SRC_TRY_DEBOUNCE), \
110 S(SNK_TRYWAIT), \
111 S(SNK_TRYWAIT_DEBOUNCE), \
112 S(SNK_TRYWAIT_VBUS), \
113 S(BIST_RX), \
114 \
115 S(GET_STATUS_SEND), \
116 S(GET_STATUS_SEND_TIMEOUT), \
117 S(GET_PPS_STATUS_SEND), \
118 S(GET_PPS_STATUS_SEND_TIMEOUT), \
119 \
120 S(GET_SINK_CAP), \
121 S(GET_SINK_CAP_TIMEOUT), \
122 \
123 S(ERROR_RECOVERY), \
124 S(PORT_RESET), \
125 S(PORT_RESET_WAIT_OFF), \
126 \
127 S(AMS_START), \
128 S(CHUNK_NOT_SUPP)
129
130 #define FOREACH_AMS(S) \
131 S(NONE_AMS), \
132 S(POWER_NEGOTIATION), \
133 S(GOTOMIN), \
134 S(SOFT_RESET_AMS), \
135 S(HARD_RESET), \
136 S(CABLE_RESET), \
137 S(GET_SOURCE_CAPABILITIES), \
138 S(GET_SINK_CAPABILITIES), \
139 S(POWER_ROLE_SWAP), \
140 S(FAST_ROLE_SWAP), \
141 S(DATA_ROLE_SWAP), \
142 S(VCONN_SWAP), \
143 S(SOURCE_ALERT), \
144 S(GETTING_SOURCE_EXTENDED_CAPABILITIES),\
145 S(GETTING_SOURCE_SINK_STATUS), \
146 S(GETTING_BATTERY_CAPABILITIES), \
147 S(GETTING_BATTERY_STATUS), \
148 S(GETTING_MANUFACTURER_INFORMATION), \
149 S(SECURITY), \
150 S(FIRMWARE_UPDATE), \
151 S(DISCOVER_IDENTITY), \
152 S(SOURCE_STARTUP_CABLE_PLUG_DISCOVER_IDENTITY), \
153 S(DISCOVER_SVIDS), \
154 S(DISCOVER_MODES), \
155 S(DFP_TO_UFP_ENTER_MODE), \
156 S(DFP_TO_UFP_EXIT_MODE), \
157 S(DFP_TO_CABLE_PLUG_ENTER_MODE), \
158 S(DFP_TO_CABLE_PLUG_EXIT_MODE), \
159 S(ATTENTION), \
160 S(BIST), \
161 S(UNSTRUCTURED_VDMS), \
162 S(STRUCTURED_VDMS), \
163 S(COUNTRY_INFO), \
164 S(COUNTRY_CODES)
165
166 #define GENERATE_ENUM(e) e
167 #define GENERATE_STRING(s) #s
168 #define TCPM_POLL_EVENT_TIME_OUT 2000
169
170 enum tcpm_state {
171 FOREACH_STATE(GENERATE_ENUM)
172 };
173
174 static const char * const tcpm_states[] = {
175 FOREACH_STATE(GENERATE_STRING)
176 };
177
178 enum tcpm_ams {
179 FOREACH_AMS(GENERATE_ENUM)
180 };
181
182 static const char * const tcpm_ams_str[] = {
183 FOREACH_AMS(GENERATE_STRING)
184 };
185
186 enum vdm_states {
187 VDM_STATE_ERR_BUSY = -3,
188 VDM_STATE_ERR_SEND = -2,
189 VDM_STATE_ERR_TMOUT = -1,
190 VDM_STATE_DONE = 0,
191 /* Anything >0 represents an active state */
192 VDM_STATE_READY = 1,
193 VDM_STATE_BUSY = 2,
194 VDM_STATE_WAIT_RSP_BUSY = 3,
195 VDM_STATE_SEND_MESSAGE = 4,
196 };
197
198 enum pd_msg_request {
199 PD_MSG_NONE = 0,
200 PD_MSG_CTRL_REJECT,
201 PD_MSG_CTRL_WAIT,
202 PD_MSG_CTRL_NOT_SUPP,
203 PD_MSG_DATA_SINK_CAP,
204 PD_MSG_DATA_SOURCE_CAP,
205 };
206
207 enum adev_actions {
208 ADEV_NONE = 0,
209 ADEV_NOTIFY_USB_AND_QUEUE_VDM,
210 ADEV_QUEUE_VDM,
211 ADEV_QUEUE_VDM_SEND_EXIT_MODE_ON_FAIL,
212 ADEV_ATTENTION,
213 };
214
215 /*
216 * Initial current capability of the new source when vSafe5V is applied during PD3.0 Fast Role Swap.
217 * Based on "Table 6-14 Fixed Supply PDO - Sink" of "USB Power Delivery Specification Revision 3.0,
218 * Version 1.2"
219 */
220 enum frs_typec_current {
221 FRS_NOT_SUPPORTED,
222 FRS_DEFAULT_POWER,
223 FRS_5V_1P5A,
224 FRS_5V_3A,
225 };
226
227 /* Events from low level driver */
228
229 #define TCPM_CC_EVENT BIT(0)
230 #define TCPM_VBUS_EVENT BIT(1)
231 #define TCPM_RESET_EVENT BIT(2)
232 #define TCPM_FRS_EVENT BIT(3)
233 #define TCPM_SOURCING_VBUS BIT(4)
234
235 #define LOG_BUFFER_ENTRIES 1024
236 #define LOG_BUFFER_ENTRY_SIZE 128
237
238 /* Alternate mode support */
239
240 #define SVID_DISCOVERY_MAX 16
241 #define ALTMODE_DISCOVERY_MAX (SVID_DISCOVERY_MAX * MODE_DISCOVERY_MAX)
242
243 #define GET_SINK_CAP_RETRY_MS 100
244 #define SEND_DISCOVER_RETRY_MS 100
245
246 /*
247 * @min_volt: Actual min voltage at the local port
248 * @req_min_volt: Requested min voltage to the port partner
249 * @max_volt: Actual max voltage at the local port
250 * @req_max_volt: Requested max voltage to the port partner
251 * @max_curr: Actual max current at the local port
252 * @req_max_curr: Requested max current of the port partner
253 * @req_out_volt: Requested output voltage to the port partner
254 * @req_op_curr: Requested operating current to the port partner
255 * @supported: Parter has atleast one APDO hence supports PPS
256 * @active: PPS mode is active
257 */
258 struct pd_pps_data {
259 u32 min_volt;
260 u32 req_min_volt;
261 u32 max_volt;
262 u32 req_max_volt;
263 u32 max_curr;
264 u32 req_max_curr;
265 u32 req_out_volt;
266 u32 req_op_curr;
267 bool supported;
268 bool active;
269 };
270
271 enum power_supply_usb_type {
272 POWER_SUPPLY_USB_TYPE_UNKNOWN = 0,
273 POWER_SUPPLY_USB_TYPE_SDP, /* Standard Downstream Port */
274 POWER_SUPPLY_USB_TYPE_DCP, /* Dedicated Charging Port */
275 POWER_SUPPLY_USB_TYPE_CDP, /* Charging Downstream Port */
276 POWER_SUPPLY_USB_TYPE_ACA, /* Accessory Charger Adapters */
277 POWER_SUPPLY_USB_TYPE_C, /* Type C Port */
278 POWER_SUPPLY_USB_TYPE_PD, /* Power Delivery Port */
279 POWER_SUPPLY_USB_TYPE_PD_DRP, /* PD Dual Role Port */
280 POWER_SUPPLY_USB_TYPE_PD_PPS, /* PD Programmable Power Supply */
281 POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID, /* Apple Charging Method */
282 };
283
284 struct tcpm_port {
285 struct udevice *dev;
286 struct typec_capability typec_caps;
287 struct tcpc_dev *tcpc;
288
289 enum typec_role vconn_role;
290 enum typec_role pwr_role;
291 enum typec_data_role data_role;
292 enum typec_pwr_opmode pwr_opmode;
293
294 struct usb_pd_identity partner_ident;
295 struct typec_partner_desc partner_desc;
296 struct typec_partner *partner;
297
298 enum typec_cc_status cc_req;
299
300 enum typec_cc_status cc1;
301 enum typec_cc_status cc2;
302 enum typec_cc_polarity polarity;
303
304 bool attached;
305 bool connected;
306 int poll_event_cnt;
307 enum typec_port_type port_type;
308
309 /*
310 * Set to true when vbus is greater than VSAFE5V min.
311 * Set to false when vbus falls below vSinkDisconnect max threshold.
312 */
313 bool vbus_present;
314
315 /*
316 * Set to true when vbus is less than VSAFE0V max.
317 * Set to false when vbus is greater than VSAFE0V max.
318 */
319 bool vbus_vsafe0v;
320
321 bool vbus_never_low;
322 bool vbus_source;
323 bool vbus_charge;
324
325 /* Set to true when Discover_Identity Command is expected to be sent in Ready states. */
326 bool send_discover;
327 bool op_vsafe5v;
328
329 int try_role;
330 int try_snk_count;
331 int try_src_count;
332
333 enum pd_msg_request queued_message;
334
335 enum tcpm_state enter_state;
336 enum tcpm_state prev_state;
337 enum tcpm_state state;
338 enum tcpm_state delayed_state;
339 unsigned long delay_ms;
340
341 spinlock_t pd_event_lock;
342 u32 pd_events;
343
344 bool state_machine_running;
345 /* Set to true when VDM State Machine has following actions. */
346 bool vdm_sm_running;
347
348 bool tx_complete;
349 enum tcpm_transmit_status tx_status;
350
351 struct mutex swap_lock; /* swap command lock */
352 bool swap_pending;
353 bool non_pd_role_swap;
354 int swap_status;
355
356 unsigned int negotiated_rev;
357 unsigned int message_id;
358 unsigned int caps_count;
359 unsigned int hard_reset_count;
360 bool pd_capable;
361 bool explicit_contract;
362 unsigned int rx_msgid;
363
364 /* Partner capabilities/requests */
365 u32 sink_request;
366 u32 source_caps[PDO_MAX_OBJECTS];
367 unsigned int nr_source_caps;
368 u32 sink_caps[PDO_MAX_OBJECTS];
369 unsigned int nr_sink_caps;
370
371 /*
372 * whether to wait for the Type-C device to send the DR_SWAP Message flag
373 * For Type-C device with Dual-Role Power and Dual-Role Data, the port side
374 * is used as sink + ufp, then the tcpm framework needs to wait for Type-C
375 * device to initiate DR_swap Message.
376 */
377 bool wait_dr_swap_Message;
378
379 /* Local capabilities */
380 u32 src_pdo[PDO_MAX_OBJECTS];
381 unsigned int nr_src_pdo;
382 u32 snk_pdo[PDO_MAX_OBJECTS];
383 unsigned int nr_snk_pdo;
384 u32 snk_vdo_v1[VDO_MAX_OBJECTS];
385 unsigned int nr_snk_vdo_v1;
386 u32 snk_vdo[VDO_MAX_OBJECTS];
387 unsigned int nr_snk_vdo;
388
389 unsigned int operating_snk_mw;
390 bool update_sink_caps;
391
392 /* Requested current / voltage to the port partner */
393 u32 req_current_limit;
394 u32 req_supply_voltage;
395 /* Actual current / voltage limit of the local port */
396 u32 current_limit;
397 u32 supply_voltage;
398
399 enum power_supply_usb_type usb_type;
400
401 u32 bist_request;
402
403 /* PD state for Vendor Defined Messages */
404 enum vdm_states vdm_state;
405 u32 vdm_retries;
406 /* next Vendor Defined Message to send */
407 u32 vdo_data[VDO_MAX_SIZE];
408 u8 vdo_count;
409 /* VDO to retry if UFP responder replied busy */
410 u32 vdo_retry;
411
412 /* PPS */
413 struct pd_pps_data pps_data;
414 bool pps_pending;
415 int pps_status;
416
417 /* Deadline in jiffies to exit src_try_wait state */
418 unsigned long max_wait;
419
420 /* port belongs to a self powered device */
421 bool self_powered;
422
423 /* Sink FRS */
424 enum frs_typec_current new_source_frs_current;
425
426 /* Sink caps have been queried */
427 bool sink_cap_done;
428
429 /* Port is still in tCCDebounce */
430 bool debouncing;
431
432 /* Collision Avoidance and Atomic Message Sequence */
433 enum tcpm_state upcoming_state;
434 enum tcpm_ams ams;
435 enum tcpm_ams next_ams;
436 bool in_ams;
437
438 /* Auto vbus discharge status */
439 bool auto_vbus_discharge_enabled;
440
441 /*
442 * When set, port requests PD_P_SNK_STDBY_MW upon entering SNK_DISCOVERY and
443 * the actual currrent limit after RX of PD_CTRL_PSRDY for PD link,
444 * SNK_READY for non-pd link.
445 */
446 bool slow_charger_loop;
447 #ifdef CONFIG_DEBUG_FS
448 struct dentry *dentry;
449 struct mutex logbuffer_lock; /* log buffer access lock */
450 int logbuffer_head;
451 int logbuffer_tail;
452 u8 *logbuffer[LOG_BUFFER_ENTRIES];
453 #endif
454 };
455
456 struct pd_rx_event {
457 struct tcpm_port *port;
458 struct pd_message msg;
459 };
460
461 static const char * const pd_rev[] = {
462 [PD_REV10] = "rev1",
463 [PD_REV20] = "rev2",
464 [PD_REV30] = "rev3",
465 };
466
467 #define tcpm_cc_is_sink(cc) \
468 ((cc) == TYPEC_CC_RP_DEF || (cc) == TYPEC_CC_RP_1_5 || \
469 (cc) == TYPEC_CC_RP_3_0)
470
471 #define tcpm_port_is_sink(port) \
472 ((tcpm_cc_is_sink((port)->cc1) && !tcpm_cc_is_sink((port)->cc2)) || \
473 (tcpm_cc_is_sink((port)->cc2) && !tcpm_cc_is_sink((port)->cc1)))
474
475 #define tcpm_cc_is_source(cc) ((cc) == TYPEC_CC_RD)
476 #define tcpm_cc_is_audio(cc) ((cc) == TYPEC_CC_RA)
477 #define tcpm_cc_is_open(cc) ((cc) == TYPEC_CC_OPEN)
478
479 #define tcpm_port_is_source(port) \
480 ((tcpm_cc_is_source((port)->cc1) && \
481 !tcpm_cc_is_source((port)->cc2)) || \
482 (tcpm_cc_is_source((port)->cc2) && \
483 !tcpm_cc_is_source((port)->cc1)))
484
485 #define tcpm_port_is_debug(port) \
486 (tcpm_cc_is_source((port)->cc1) && tcpm_cc_is_source((port)->cc2))
487
488 #define tcpm_port_is_audio(port) \
489 (tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_audio((port)->cc2))
490
491 #define tcpm_port_is_audio_detached(port) \
492 ((tcpm_cc_is_audio((port)->cc1) && tcpm_cc_is_open((port)->cc2)) || \
493 (tcpm_cc_is_audio((port)->cc2) && tcpm_cc_is_open((port)->cc1)))
494
495 #define tcpm_try_snk(port) \
496 ((port)->try_snk_count == 0 && (port)->try_role == TYPEC_SINK && \
497 (port)->port_type == TYPEC_PORT_DRP)
498
499 #define tcpm_try_src(port) \
500 ((port)->try_src_count == 0 && (port)->try_role == TYPEC_SOURCE && \
501 (port)->port_type == TYPEC_PORT_DRP)
502
503 #define tcpm_data_role_for_source(port) \
504 ((port)->typec_caps.data == TYPEC_PORT_UFP ? \
505 TYPEC_DEVICE : TYPEC_HOST)
506
507 #define tcpm_data_role_for_sink(port) \
508 ((port)->typec_caps.data == TYPEC_PORT_DFP ? \
509 TYPEC_HOST : TYPEC_DEVICE)
510
tcpm_default_state(struct tcpm_port * port)511 static enum tcpm_state tcpm_default_state(struct tcpm_port *port)
512 {
513 if (port->port_type == TYPEC_PORT_DRP) {
514 if (port->try_role == TYPEC_SINK)
515 return SNK_UNATTACHED;
516 else if (port->try_role == TYPEC_SOURCE)
517 return SRC_UNATTACHED;
518 /* Fall through to return SRC_UNATTACHED */
519 } else if (port->port_type == TYPEC_PORT_SNK) {
520 return SNK_UNATTACHED;
521 }
522 return SRC_UNATTACHED;
523 }
524
tcpm_port_is_disconnected(struct tcpm_port * port)525 static bool tcpm_port_is_disconnected(struct tcpm_port *port)
526 {
527 return (!port->attached && port->cc1 == TYPEC_CC_OPEN &&
528 port->cc2 == TYPEC_CC_OPEN) ||
529 (port->attached && ((port->polarity == TYPEC_POLARITY_CC1 &&
530 port->cc1 == TYPEC_CC_OPEN) ||
531 (port->polarity == TYPEC_POLARITY_CC2 &&
532 port->cc2 == TYPEC_CC_OPEN)));
533 }
534
tcpm_set_cc(struct tcpm_port * port,enum typec_cc_status cc)535 static void tcpm_set_cc(struct tcpm_port *port, enum typec_cc_status cc)
536 {
537 debug("%s: cc = %d", __func__, cc);
538 port->cc_req = cc;
539 port->tcpc->set_cc(port->tcpc, cc);
540 }
541
542 /*
543 * Determine RP value to set based on maximum current supported
544 * by a port if configured as source.
545 * Returns CC value to report to link partner.
546 */
tcpm_rp_cc(struct tcpm_port * port)547 static enum typec_cc_status tcpm_rp_cc(struct tcpm_port *port)
548 {
549 const u32 *src_pdo = port->src_pdo;
550 int nr_pdo = port->nr_src_pdo;
551 int i;
552
553 /*
554 * Search for first entry with matching voltage.
555 * It should report the maximum supported current.
556 */
557 for (i = 0; i < nr_pdo; i++) {
558 const u32 pdo = src_pdo[i];
559
560 if (pdo_type(pdo) == PDO_TYPE_FIXED &&
561 pdo_fixed_voltage(pdo) == 5000) {
562 unsigned int curr = pdo_max_current(pdo);
563
564 if (curr >= 3000)
565 return TYPEC_CC_RP_3_0;
566 else if (curr >= 1500)
567 return TYPEC_CC_RP_1_5;
568 return TYPEC_CC_RP_DEF;
569 }
570 }
571
572 return TYPEC_CC_RP_DEF;
573 }
574
tcpm_pd_transmit(struct tcpm_port * port,enum tcpm_transmit_type type,const struct pd_message * msg)575 static int tcpm_pd_transmit(struct tcpm_port *port,
576 enum tcpm_transmit_type type,
577 const struct pd_message *msg)
578 {
579 int ret;
580 int timeout = PD_T_TCPC_TX_TIMEOUT;
581
582 if (msg)
583 debug("PD TX, header: %#x\n", le16_to_cpu(msg->header));
584 else
585 debug("PD TX, type: %#x\n", type);
586
587 port->tx_complete = false;
588 ret = port->tcpc->pd_transmit(port->tcpc, type, msg, port->negotiated_rev);
589 if (ret < 0)
590 return ret;
591
592 while ((timeout > 0) && (!port->tx_complete)) {
593 port->tcpc->poll_event(port->tcpc);
594 udelay(1000);
595 timeout--;
596 }
597
598 if (!timeout) {
599 printf("%s: pd transmit data timeout\n", __func__);
600 return -ETIMEDOUT;
601 }
602
603 switch (port->tx_status) {
604 case TCPC_TX_SUCCESS:
605 port->message_id = (port->message_id + 1) & PD_HEADER_ID_MASK;
606 break;
607 case TCPC_TX_DISCARDED:
608 ret = -EAGAIN;
609 break;
610 case TCPC_TX_FAILED:
611 default:
612 ret = -EIO;
613 break;
614 }
615
616 return ret;
617 }
618
tcpm_pd_transmit_complete(struct tcpm_port * port,enum tcpm_transmit_status status)619 void tcpm_pd_transmit_complete(struct tcpm_port *port,
620 enum tcpm_transmit_status status)
621 {
622 debug("%s: PD TX complete, status: %u\n", __func__, status);
623 port->poll_event_cnt = 0;
624 port->tx_status = status;
625 port->tx_complete = true;
626 }
627 EXPORT_SYMBOL_GPL(tcpm_pd_transmit_complete);
628
tcpm_set_polarity(struct tcpm_port * port,enum typec_cc_polarity polarity)629 static int tcpm_set_polarity(struct tcpm_port *port,
630 enum typec_cc_polarity polarity)
631 {
632 int ret;
633
634 debug("%s: polarity %d\n", __func__, polarity);
635
636 ret = port->tcpc->set_polarity(port->tcpc, polarity);
637 if (ret < 0)
638 return ret;
639
640 port->polarity = polarity;
641
642 return 0;
643 }
644
tcpm_set_vconn(struct tcpm_port * port,bool enable)645 static int tcpm_set_vconn(struct tcpm_port *port, bool enable)
646 {
647 int ret;
648
649 debug("%s: vconn = %d\n", __func__, enable);
650
651 ret = port->tcpc->set_vconn(port->tcpc, enable);
652 if (!ret)
653 port->vconn_role = enable ? TYPEC_SOURCE : TYPEC_SINK;
654
655 return ret;
656 }
657
tcpm_get_current_limit(struct tcpm_port * port)658 static u32 tcpm_get_current_limit(struct tcpm_port *port)
659 {
660 enum typec_cc_status cc;
661 u32 limit;
662
663 cc = port->polarity ? port->cc2 : port->cc1;
664 switch (cc) {
665 case TYPEC_CC_RP_1_5:
666 limit = 1500;
667 break;
668 case TYPEC_CC_RP_3_0:
669 limit = 3000;
670 break;
671 case TYPEC_CC_RP_DEF:
672 default:
673 if (port->tcpc->get_current_limit)
674 limit = port->tcpc->get_current_limit(port->tcpc);
675 else
676 limit = 0;
677 break;
678 }
679
680 return limit;
681 }
682
tcpm_set_current_limit(struct tcpm_port * port,u32 max_ma,u32 mv)683 static int tcpm_set_current_limit(struct tcpm_port *port, u32 max_ma, u32 mv)
684 {
685 int ret = -EOPNOTSUPP;
686
687 debug("Setting voltage/current limit %u mV %u mA\n", mv, max_ma);
688
689 port->supply_voltage = mv;
690 port->current_limit = max_ma;
691
692 if (port->tcpc->set_current_limit)
693 ret = port->tcpc->set_current_limit(port->tcpc, max_ma, mv);
694
695 return ret;
696 }
697
tcpm_set_attached_state(struct tcpm_port * port,bool attached)698 static int tcpm_set_attached_state(struct tcpm_port *port, bool attached)
699 {
700 return port->tcpc->set_roles(port->tcpc, attached, port->pwr_role,
701 port->data_role);
702 }
703
tcpm_set_roles(struct tcpm_port * port,bool attached,enum typec_role role,enum typec_data_role data)704 static int tcpm_set_roles(struct tcpm_port *port, bool attached,
705 enum typec_role role, enum typec_data_role data)
706 {
707 #if 0
708 enum typec_orientation orientation;
709 enum usb_role usb_role;
710 #endif
711 int ret;
712
713 #if 0
714 if (port->polarity == TYPEC_POLARITY_CC1)
715 orientation = TYPEC_ORIENTATION_NORMAL;
716 else
717 orientation = TYPEC_ORIENTATION_REVERSE;
718
719 if (data == TYPEC_HOST)
720 usb_role = USB_ROLE_HOST;
721 else
722 usb_role = USB_ROLE_DEVICE;
723
724 ret = tcpm_mux_set(port, TYPEC_STATE_USB, usb_role, orientation);
725 if (ret < 0)
726 return ret;
727 #endif
728
729 ret = port->tcpc->set_roles(port->tcpc, attached, role, data);
730 if (ret < 0)
731 return ret;
732
733 port->pwr_role = role;
734 port->data_role = data;
735 #if 0
736 typec_set_data_role(port->typec_port, data);
737 typec_set_pwr_role(port->typec_port, role);
738 #endif
739
740 return 0;
741 }
742
tcpm_pd_send_source_caps(struct tcpm_port * port)743 static int tcpm_pd_send_source_caps(struct tcpm_port *port)
744 {
745 struct pd_message msg;
746 int i;
747
748 memset(&msg, 0, sizeof(msg));
749
750 if (!port->nr_src_pdo) {
751 /* No source capabilities defined, sink only */
752 msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
753 port->pwr_role,
754 port->data_role,
755 port->negotiated_rev,
756 port->message_id, 0);
757 } else {
758 msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP,
759 port->pwr_role,
760 port->data_role,
761 port->negotiated_rev,
762 port->message_id,
763 port->nr_src_pdo);
764 }
765
766 for (i = 0; i < port->nr_src_pdo; i++)
767 msg.payload[i] = cpu_to_le32(port->src_pdo[i]);
768
769 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
770 }
771
tcpm_pd_send_sink_caps(struct tcpm_port * port)772 static int tcpm_pd_send_sink_caps(struct tcpm_port *port)
773 {
774 struct pd_message msg;
775 unsigned int i;
776
777 memset(&msg, 0, sizeof(msg));
778
779 if (!port->nr_snk_pdo) {
780 /* No sink capabilities defined, source only */
781 msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
782 port->pwr_role,
783 port->data_role,
784 port->negotiated_rev,
785 port->message_id, 0);
786 } else {
787 msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP,
788 port->pwr_role,
789 port->data_role,
790 port->negotiated_rev,
791 port->message_id,
792 port->nr_snk_pdo);
793 }
794
795 for (i = 0; i < port->nr_snk_pdo; i++)
796 msg.payload[i] = cpu_to_le32(port->snk_pdo[i]);
797
798 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
799 }
800
801 static void tcpm_state_machine(struct tcpm_port *port);
802 static void tcpm_timer_uninit(struct tcpm_port *port);
tcpm_timer_irq(int irq,void * data)803 static void tcpm_timer_irq(int irq, void *data)
804 {
805 struct tcpm_port *port = data;
806
807 writel(TIMER_CLR_INT, TIMER_BASE + TIMER_INTSTATUS);
808 tcpm_timer_uninit(port);
809 tcpm_state_machine(port);
810 }
811
tcpm_timer_init(struct tcpm_port * port,uint32_t ms)812 static void tcpm_timer_init(struct tcpm_port *port, uint32_t ms)
813 {
814 uint64_t period = 24000ULL * ms;
815
816 /* Disable before conifg */
817 writel(0, TIMER_BASE + TIMER_CTRL);
818
819 /* Config */
820 writel((uint32_t)period, TIMER_BASE + TIMER_LOAD_COUNT0);
821 writel((uint32_t)(period >> 32), TIMER_BASE + TIMER_LOAD_COUNT1);
822 writel(TIMER_CLR_INT, TIMER_BASE + TIMER_INTSTATUS);
823 writel(TIMER_EN | TIMER_INT_EN, TIMER_BASE + TIMER_CTRL);
824
825 /* IRQ */
826 irq_install_handler(TIMER_IRQ,
827 (interrupt_handler_t *)tcpm_timer_irq, port);
828 irq_handler_enable(TIMER_IRQ);
829 }
830
tcpm_timer_uninit(struct tcpm_port * port)831 static void tcpm_timer_uninit(struct tcpm_port *port)
832 {
833 writel(0, TIMER_BASE + TIMER_CTRL);
834
835 irq_handler_disable(TIMER_IRQ);
836 irq_free_handler(TIMER_IRQ);
837 }
838
mod_tcpm_delayed_work(struct tcpm_port * port,unsigned int delay_ms)839 static void mod_tcpm_delayed_work(struct tcpm_port *port, unsigned int delay_ms)
840 {
841 if (delay_ms) {
842 tcpm_timer_init(port, delay_ms);
843 } else {
844 tcpm_timer_uninit(port);
845 tcpm_state_machine(port);
846 }
847 }
848
tcpm_set_state(struct tcpm_port * port,enum tcpm_state state,unsigned int delay_ms)849 static void tcpm_set_state(struct tcpm_port *port, enum tcpm_state state,
850 unsigned int delay_ms)
851 {
852 debug("%s: line = %d, delay_ms = %d, set state = %s\n",
853 __func__, __LINE__, delay_ms, tcpm_states[state]);
854
855 if (delay_ms) {
856 debug("pending state change %s -> %s @ %u ms [%s]\n",
857 tcpm_states[port->state], tcpm_states[state], delay_ms,
858 pd_rev[port->negotiated_rev]);
859 port->delayed_state = state;
860 mod_tcpm_delayed_work(port, delay_ms);
861 port->delay_ms = delay_ms;
862 } else {
863 debug("state change %s -> %s\n",
864 tcpm_states[port->state], tcpm_states[state]);
865 port->delayed_state = INVALID_STATE;
866 port->prev_state = port->state;
867 port->state = state;
868 /*
869 * Don't re-queue the state machine work item if we're currently
870 * in the state machine and we're immediately changing states.
871 * tcpm_state_machine_work() will continue running the state
872 * machine.
873 */
874 if (!port->state_machine_running)
875 mod_tcpm_delayed_work(port, 0);
876 }
877 }
878
tcpm_set_state_cond(struct tcpm_port * port,enum tcpm_state state,unsigned int delay_ms)879 static void tcpm_set_state_cond(struct tcpm_port *port, enum tcpm_state state,
880 unsigned int delay_ms)
881 {
882 if (port->enter_state == port->state)
883 tcpm_set_state(port, state, delay_ms);
884 else
885 debug("skipped %sstate change %s -> %s [%u ms], context state %s [%s %s]\n",
886 delay_ms ? "delayed " : "",
887 tcpm_states[port->state], tcpm_states[state],
888 delay_ms, tcpm_states[port->enter_state],
889 pd_rev[port->negotiated_rev], tcpm_ams_str[port->ams]);
890 }
891
tcpm_queue_message(struct tcpm_port * port,enum pd_msg_request message)892 static void tcpm_queue_message(struct tcpm_port *port,
893 enum pd_msg_request message)
894 {
895 port->queued_message = message;
896 mod_tcpm_delayed_work(port, 0);
897 }
898
899 #if 0
900 static void tcpm_pd_handle_msg(struct tcpm_port *port,
901 enum pd_msg_request message,
902 enum tcpm_ams ams);
903 #endif
904
905 enum pdo_err {
906 PDO_NO_ERR,
907 PDO_ERR_NO_VSAFE5V,
908 PDO_ERR_VSAFE5V_NOT_FIRST,
909 PDO_ERR_PDO_TYPE_NOT_IN_ORDER,
910 PDO_ERR_FIXED_NOT_SORTED,
911 PDO_ERR_VARIABLE_BATT_NOT_SORTED,
912 PDO_ERR_DUPE_PDO,
913 PDO_ERR_PPS_APDO_NOT_SORTED,
914 PDO_ERR_DUPE_PPS_APDO,
915 };
916
917 static const char * const pdo_err_msg[] = {
918 [PDO_ERR_NO_VSAFE5V] =
919 " err: source/sink caps should atleast have vSafe5V",
920 [PDO_ERR_VSAFE5V_NOT_FIRST] =
921 " err: vSafe5V Fixed Supply Object Shall always be the first object",
922 [PDO_ERR_PDO_TYPE_NOT_IN_ORDER] =
923 " err: PDOs should be in the following order: Fixed; Battery; Variable",
924 [PDO_ERR_FIXED_NOT_SORTED] =
925 " err: Fixed supply pdos should be in increasing order of their fixed voltage",
926 [PDO_ERR_VARIABLE_BATT_NOT_SORTED] =
927 " err: Variable/Battery supply pdos should be in increasing order of their minimum voltage",
928 [PDO_ERR_DUPE_PDO] =
929 " err: Variable/Batt supply pdos cannot have same min/max voltage",
930 [PDO_ERR_PPS_APDO_NOT_SORTED] =
931 " err: Programmable power supply apdos should be in increasing order of their maximum voltage",
932 [PDO_ERR_DUPE_PPS_APDO] =
933 " err: Programmable power supply apdos cannot have same min/max voltage and max current",
934 };
935
tcpm_caps_err(struct tcpm_port * port,const u32 * pdo,unsigned int nr_pdo)936 static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo,
937 unsigned int nr_pdo)
938 {
939 unsigned int i;
940
941 /* Should at least contain vSafe5v */
942 if (nr_pdo < 1)
943 return PDO_ERR_NO_VSAFE5V;
944
945 /* The vSafe5V Fixed Supply Object Shall always be the first object */
946 if (pdo_type(pdo[0]) != PDO_TYPE_FIXED ||
947 pdo_fixed_voltage(pdo[0]) != VSAFE5V)
948 return PDO_ERR_VSAFE5V_NOT_FIRST;
949
950 for (i = 1; i < nr_pdo; i++) {
951 if (pdo_type(pdo[i]) < pdo_type(pdo[i - 1])) {
952 return PDO_ERR_PDO_TYPE_NOT_IN_ORDER;
953 } else if (pdo_type(pdo[i]) == pdo_type(pdo[i - 1])) {
954 enum pd_pdo_type type = pdo_type(pdo[i]);
955
956 switch (type) {
957 /*
958 * The remaining Fixed Supply Objects, if
959 * present, shall be sent in voltage order;
960 * lowest to highest.
961 */
962 case PDO_TYPE_FIXED:
963 if (pdo_fixed_voltage(pdo[i]) <=
964 pdo_fixed_voltage(pdo[i - 1]))
965 return PDO_ERR_FIXED_NOT_SORTED;
966 break;
967 /*
968 * The Battery Supply Objects and Variable
969 * supply, if present shall be sent in Minimum
970 * Voltage order; lowest to highest.
971 */
972 case PDO_TYPE_VAR:
973 case PDO_TYPE_BATT:
974 if (pdo_min_voltage(pdo[i]) <
975 pdo_min_voltage(pdo[i - 1]))
976 return PDO_ERR_VARIABLE_BATT_NOT_SORTED;
977 else if ((pdo_min_voltage(pdo[i]) ==
978 pdo_min_voltage(pdo[i - 1])) &&
979 (pdo_max_voltage(pdo[i]) ==
980 pdo_max_voltage(pdo[i - 1])))
981 return PDO_ERR_DUPE_PDO;
982 break;
983 /*
984 * The Programmable Power Supply APDOs, if present,
985 * shall be sent in Maximum Voltage order;
986 * lowest to highest.
987 */
988 case PDO_TYPE_APDO:
989 if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS)
990 break;
991
992 if (pdo_pps_apdo_max_voltage(pdo[i]) <
993 pdo_pps_apdo_max_voltage(pdo[i - 1]))
994 return PDO_ERR_PPS_APDO_NOT_SORTED;
995 else if (pdo_pps_apdo_min_voltage(pdo[i]) ==
996 pdo_pps_apdo_min_voltage(pdo[i - 1]) &&
997 pdo_pps_apdo_max_voltage(pdo[i]) ==
998 pdo_pps_apdo_max_voltage(pdo[i - 1]) &&
999 pdo_pps_apdo_max_current(pdo[i]) ==
1000 pdo_pps_apdo_max_current(pdo[i - 1]))
1001 return PDO_ERR_DUPE_PPS_APDO;
1002 break;
1003 default:
1004 printf("%s: Unknown pdo type\n", __func__);
1005 }
1006 }
1007 }
1008
1009 return PDO_NO_ERR;
1010 }
1011
tcpm_validate_caps(struct tcpm_port * port,const u32 * pdo,unsigned int nr_pdo)1012 static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo,
1013 unsigned int nr_pdo)
1014 {
1015 enum pdo_err err_index = tcpm_caps_err(port, pdo, nr_pdo);
1016
1017 if (err_index != PDO_NO_ERR) {
1018 printf("%s", pdo_err_msg[err_index]);
1019 return -EINVAL;
1020 }
1021
1022 return 0;
1023 }
1024
1025 /*
1026 * PD (data, control) command handling functions
1027 */
ready_state(struct tcpm_port * port)1028 static inline enum tcpm_state ready_state(struct tcpm_port *port)
1029 {
1030 if (port->pwr_role == TYPEC_SOURCE)
1031 return SRC_READY;
1032 else
1033 return SNK_READY;
1034 }
1035
1036 static int tcpm_pd_send_control(struct tcpm_port *port,
1037 enum pd_ctrl_msg_type type);
1038
1039 #if 0
1040 static void tcpm_pd_handle_msg(struct tcpm_port *port,
1041 enum pd_msg_request message,
1042 enum tcpm_ams ams)
1043 {
1044 switch (port->state) {
1045 case SRC_READY:
1046 case SNK_READY:
1047 port->ams = ams;
1048 tcpm_queue_message(port, message);
1049 break;
1050 /* PD 3.0 Spec 8.3.3.4.1.1 and 6.8.1 */
1051 case SNK_TRANSITION_SINK:
1052 case SNK_TRANSITION_SINK_VBUS:
1053 case SRC_TRANSITION_SUPPLY:
1054 tcpm_set_state(port, HARD_RESET_SEND, 0);
1055 break;
1056 default:
1057 if (!tcpm_ams_interruptible(port)) {
1058 tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
1059 SRC_SOFT_RESET_WAIT_SNK_TX :
1060 SNK_SOFT_RESET,
1061 0);
1062 } else {
1063 port->next_ams = ams;
1064 tcpm_set_state(port, ready_state(port), 0);
1065 /* 6.8.1 process the Message */
1066 tcpm_queue_message(port, message);
1067 }
1068 break;
1069 }
1070 }
1071 #endif
1072
tcpm_pd_data_request(struct tcpm_port * port,const struct pd_message * msg)1073 static void tcpm_pd_data_request(struct tcpm_port *port,
1074 const struct pd_message *msg)
1075 {
1076 enum pd_data_msg_type type = pd_header_type_le(msg->header);
1077 unsigned int cnt = pd_header_cnt_le(msg->header);
1078 unsigned int rev = pd_header_rev_le(msg->header);
1079 unsigned int i;
1080
1081 switch (type) {
1082 case PD_DATA_SOURCE_CAP:
1083 for (i = 0; i < cnt; i++)
1084 port->source_caps[i] = le32_to_cpu(msg->payload[i]);
1085
1086 port->nr_source_caps = cnt;
1087
1088 tcpm_validate_caps(port, port->source_caps,
1089 port->nr_source_caps);
1090
1091 /*
1092 * Adjust revision in subsequent message headers, as required,
1093 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
1094 * support Rev 1.0 so just do nothing in that scenario.
1095 */
1096 if (rev == PD_REV10) {
1097 break;
1098 }
1099
1100 if (rev < PD_MAX_REV)
1101 port->negotiated_rev = rev;
1102
1103 if ((pdo_type(port->source_caps[0]) == PDO_TYPE_FIXED) &&
1104 (port->source_caps[0] & PDO_FIXED_DUAL_ROLE) &&
1105 (port->source_caps[0] & PDO_FIXED_DATA_SWAP)) {
1106 /* Dual role power and data, eg: self-powered Type-C */
1107 port->wait_dr_swap_Message = true;
1108 } else {
1109 /* Non-Dual role power, eg: adapter */
1110 port->wait_dr_swap_Message = false;
1111 }
1112
1113 /*
1114 * This message may be received even if VBUS is not
1115 * present. This is quite unexpected; see USB PD
1116 * specification, sections 8.3.3.6.3.1 and 8.3.3.6.3.2.
1117 * However, at the same time, we must be ready to
1118 * receive this message and respond to it 15ms after
1119 * receiving PS_RDY during power swap operations, no matter
1120 * if VBUS is available or not (USB PD specification,
1121 * section 6.5.9.2).
1122 * So we need to accept the message either way,
1123 * but be prepared to keep waiting for VBUS after it was
1124 * handled.
1125 */
1126 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
1127 break;
1128 case PD_DATA_REQUEST:
1129 /*
1130 * Adjust revision in subsequent message headers, as required,
1131 * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
1132 * support Rev 1.0 so just reject in that scenario.
1133 */
1134 if (rev == PD_REV10) {
1135 tcpm_queue_message(port, PD_MSG_CTRL_REJECT);
1136 break;
1137 }
1138
1139 if (rev < PD_MAX_REV)
1140 port->negotiated_rev = rev;
1141
1142 port->sink_request = le32_to_cpu(msg->payload[0]);
1143
1144 tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0);
1145 break;
1146 case PD_DATA_SINK_CAP:
1147 /* We don't do anything with this at the moment... */
1148 for (i = 0; i < cnt; i++)
1149 port->sink_caps[i] = le32_to_cpu(msg->payload[i]);
1150
1151 port->nr_sink_caps = cnt;
1152 break;
1153 default:
1154 break;
1155 }
1156 }
1157
tcpm_pd_ctrl_request(struct tcpm_port * port,const struct pd_message * msg)1158 static void tcpm_pd_ctrl_request(struct tcpm_port *port,
1159 const struct pd_message *msg)
1160 {
1161 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header);
1162 enum tcpm_state next_state;
1163
1164 switch (type) {
1165 case PD_CTRL_GOOD_CRC:
1166 case PD_CTRL_PING:
1167 break;
1168 case PD_CTRL_GET_SOURCE_CAP:
1169 switch (port->state) {
1170 case SRC_READY:
1171 case SNK_READY:
1172 tcpm_queue_message(port, PD_MSG_DATA_SOURCE_CAP);
1173 break;
1174 default:
1175 tcpm_queue_message(port, PD_MSG_CTRL_REJECT);
1176 break;
1177 }
1178 break;
1179 case PD_CTRL_GET_SINK_CAP:
1180 switch (port->state) {
1181 case SRC_READY:
1182 case SNK_READY:
1183 tcpm_queue_message(port, PD_MSG_DATA_SINK_CAP);
1184 break;
1185 default:
1186 tcpm_queue_message(port, PD_MSG_CTRL_REJECT);
1187 break;
1188 }
1189 break;
1190 case PD_CTRL_GOTO_MIN:
1191 break;
1192 case PD_CTRL_PS_RDY:
1193 switch (port->state) {
1194 case SNK_TRANSITION_SINK:
1195 if (port->vbus_present) {
1196 tcpm_set_current_limit(port,
1197 port->req_current_limit,
1198 port->req_supply_voltage);
1199 port->explicit_contract = true;
1200 tcpm_set_state(port, SNK_READY, 0);
1201 } else {
1202 /*
1203 * Seen after power swap. Keep waiting for VBUS
1204 * in a transitional state.
1205 */
1206 tcpm_set_state(port,
1207 SNK_TRANSITION_SINK_VBUS, 0);
1208 }
1209 break;
1210 default:
1211 break;
1212 }
1213 break;
1214 case PD_CTRL_REJECT:
1215 case PD_CTRL_WAIT:
1216 case PD_CTRL_NOT_SUPP:
1217 switch (port->state) {
1218 case SNK_NEGOTIATE_CAPABILITIES:
1219 /* USB PD specification, Figure 8-43 */
1220 if (port->explicit_contract)
1221 next_state = SNK_READY;
1222 else
1223 next_state = SNK_WAIT_CAPABILITIES;
1224
1225 tcpm_set_state(port, next_state, 0);
1226 break;
1227 case SNK_NEGOTIATE_PPS_CAPABILITIES:
1228 /* Revert data back from any requested PPS updates */
1229 port->pps_data.req_out_volt = port->supply_voltage;
1230 port->pps_data.req_op_curr = port->current_limit;
1231 port->pps_status = (type == PD_CTRL_WAIT ?
1232 -EAGAIN : -EOPNOTSUPP);
1233 tcpm_set_state(port, SNK_READY, 0);
1234 break;
1235 default:
1236 break;
1237 }
1238 break;
1239 case PD_CTRL_ACCEPT:
1240 switch (port->state) {
1241 case SNK_NEGOTIATE_CAPABILITIES:
1242 port->pps_data.active = false;
1243 tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
1244 break;
1245 case SNK_NEGOTIATE_PPS_CAPABILITIES:
1246 port->pps_data.active = true;
1247 /* ???? */
1248 port->pps_data.min_volt = port->pps_data.req_min_volt;
1249 port->pps_data.max_volt = port->pps_data.req_max_volt;
1250 port->pps_data.max_curr = port->pps_data.req_max_curr;
1251 port->req_supply_voltage = port->pps_data.req_out_volt;
1252 port->req_current_limit = port->pps_data.req_op_curr;
1253 tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
1254 break;
1255 case SOFT_RESET_SEND:
1256 port->message_id = 0;
1257 port->rx_msgid = -1;
1258 if (port->pwr_role == TYPEC_SOURCE)
1259 next_state = SRC_SEND_CAPABILITIES;
1260 else
1261 next_state = SNK_WAIT_CAPABILITIES;
1262 tcpm_set_state(port, next_state, 0);
1263 break;
1264 default:
1265 break;
1266 }
1267 break;
1268 case PD_CTRL_SOFT_RESET:
1269 tcpm_set_state(port, SOFT_RESET, 0);
1270 break;
1271 case PD_CTRL_DR_SWAP:
1272 if (port->port_type != TYPEC_PORT_DRP) {
1273 tcpm_queue_message(port, PD_MSG_CTRL_REJECT);
1274 break;
1275 }
1276 /*
1277 * XXX
1278 * 6.3.9: If an alternate mode is active, a request to swap
1279 * alternate modes shall trigger a port reset.
1280 */
1281 switch (port->state) {
1282 case SRC_READY:
1283 case SNK_READY:
1284 #if 0
1285 if (port->vdm_sm_running) {
1286 tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
1287 break;
1288 }
1289 #endif
1290 tcpm_set_state(port, DR_SWAP_ACCEPT, 0);
1291 break;
1292 default:
1293 tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
1294 break;
1295 }
1296 break;
1297 case PD_CTRL_PR_SWAP:
1298 case PD_CTRL_VCONN_SWAP:
1299 case PD_CTRL_GET_SOURCE_CAP_EXT:
1300 case PD_CTRL_GET_STATUS:
1301 case PD_CTRL_FR_SWAP:
1302 case PD_CTRL_GET_PPS_STATUS:
1303 case PD_CTRL_GET_COUNTRY_CODES:
1304 /* Currently not supported */
1305 printf("Currently not supported type %#x \n", type);
1306 tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
1307 break;
1308 default:
1309 printf("Unrecognized ctrl message type %#x\n", type);
1310 break;
1311 }
1312 }
1313
1314 #if 0
1315 static void tcpm_pd_ext_msg_request(struct tcpm_port *port,
1316 const struct pd_message *msg)
1317 {
1318 enum pd_ext_msg_type type = pd_header_type_le(msg->header);
1319 unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header);
1320
1321 if (!(le16_to_cpu(msg->ext_msg.header) & PD_EXT_HDR_CHUNKED)) {
1322 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
1323 printf("Unchunked extended messages unsupported\n");
1324 return;
1325 }
1326
1327 if (data_size > PD_EXT_MAX_CHUNK_DATA) {
1328 tcpm_pd_handle_state(port, CHUNK_NOT_SUPP, NONE_AMS, PD_T_CHUNK_NOT_SUPP);
1329 printf("Chunk handling not yet supported\n");
1330 return;
1331 }
1332
1333 switch (type) {
1334 case PD_EXT_STATUS:
1335 case PD_EXT_PPS_STATUS:
1336 tcpm_set_state(port, ready_state(port), 0);
1337 }
1338 break;
1339 case PD_EXT_SOURCE_CAP_EXT:
1340 case PD_EXT_GET_BATT_CAP:
1341 case PD_EXT_GET_BATT_STATUS:
1342 case PD_EXT_BATT_CAP:
1343 case PD_EXT_GET_MANUFACTURER_INFO:
1344 case PD_EXT_MANUFACTURER_INFO:
1345 case PD_EXT_SECURITY_REQUEST:
1346 case PD_EXT_SECURITY_RESPONSE:
1347 case PD_EXT_FW_UPDATE_REQUEST:
1348 case PD_EXT_FW_UPDATE_RESPONSE:
1349 case PD_EXT_COUNTRY_INFO:
1350 case PD_EXT_COUNTRY_CODES:
1351 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
1352 break;
1353 default:
1354 tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS);
1355 printf("Unrecognized extended message type %#x\n", type);
1356 break;
1357 }
1358 }
1359 #endif
1360
tcpm_pd_rx_handler(struct tcpm_port * port,struct pd_rx_event * event)1361 static void tcpm_pd_rx_handler(struct tcpm_port *port,
1362 struct pd_rx_event *event)
1363 {
1364 const struct pd_message *msg = &event->msg;
1365 unsigned int cnt = pd_header_cnt_le(msg->header);
1366
1367 debug("PD RX, header: %#x [%d]\n", le16_to_cpu(msg->header),
1368 port->attached);
1369
1370 if (port->attached) {
1371 enum pd_ctrl_msg_type type = pd_header_type_le(msg->header);
1372 unsigned int msgid = pd_header_msgid_le(msg->header);
1373
1374 /*
1375 * USB PD standard, 6.6.1.2:
1376 * "... if MessageID value in a received Message is the
1377 * same as the stored value, the receiver shall return a
1378 * GoodCRC Message with that MessageID value and drop
1379 * the Message (this is a retry of an already received
1380 * Message). Note: this shall not apply to the Soft_Reset
1381 * Message which always has a MessageID value of zero."
1382 */
1383 if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET)
1384 goto done;
1385 port->rx_msgid = msgid;
1386
1387 /*
1388 * If both ends believe to be DFP/host, we have a data role
1389 * mismatch.
1390 */
1391 if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) ==
1392 (port->data_role == TYPEC_HOST)) {
1393 printf("Data role mismatch, initiating error recovery\n");
1394 tcpm_set_state(port, ERROR_RECOVERY, 0);
1395 } else {
1396 if (cnt)
1397 tcpm_pd_data_request(port, msg);
1398 else
1399 tcpm_pd_ctrl_request(port, msg);
1400 }
1401 }
1402
1403 done:
1404 kfree(event);
1405 }
1406
tcpm_pd_receive(struct tcpm_port * port,const struct pd_message * msg)1407 void tcpm_pd_receive(struct tcpm_port *port, const struct pd_message *msg)
1408 {
1409 struct pd_rx_event *event;
1410
1411 port->poll_event_cnt = 0;
1412 event = kzalloc(sizeof(*event), GFP_ATOMIC);
1413 if (!event)
1414 return;
1415
1416 event->port = port;
1417 memcpy(&event->msg, msg, sizeof(*msg));
1418 tcpm_pd_rx_handler(port, event);
1419 }
1420 EXPORT_SYMBOL_GPL(tcpm_pd_receive);
1421
tcpm_pd_send_control(struct tcpm_port * port,enum pd_ctrl_msg_type type)1422 static int tcpm_pd_send_control(struct tcpm_port *port,
1423 enum pd_ctrl_msg_type type)
1424 {
1425 struct pd_message msg;
1426
1427 memset(&msg, 0, sizeof(msg));
1428 msg.header = PD_HEADER_LE(type, port->pwr_role,
1429 port->data_role,
1430 port->negotiated_rev,
1431 port->message_id, 0);
1432
1433 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1434 }
1435
1436 /*
1437 * Send queued message without affecting state.
1438 * Return true if state machine should go back to sleep,
1439 * false otherwise.
1440 */
tcpm_send_queued_message(struct tcpm_port * port)1441 static bool tcpm_send_queued_message(struct tcpm_port *port)
1442 {
1443 enum pd_msg_request queued_message;
1444
1445 do {
1446 queued_message = port->queued_message;
1447 port->queued_message = PD_MSG_NONE;
1448
1449 switch (queued_message) {
1450 case PD_MSG_CTRL_WAIT:
1451 tcpm_pd_send_control(port, PD_CTRL_WAIT);
1452 break;
1453 case PD_MSG_CTRL_REJECT:
1454 tcpm_pd_send_control(port, PD_CTRL_REJECT);
1455 break;
1456 case PD_MSG_CTRL_NOT_SUPP:
1457 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP);
1458 break;
1459 case PD_MSG_DATA_SINK_CAP:
1460 tcpm_pd_send_sink_caps(port);
1461 break;
1462 case PD_MSG_DATA_SOURCE_CAP:
1463 tcpm_pd_send_source_caps(port);
1464 break;
1465 default:
1466 break;
1467 }
1468 } while (port->queued_message != PD_MSG_NONE);
1469
1470 #if 0
1471 /* ??? */
1472 if (port->delayed_state != INVALID_STATE) {
1473 if (ktime_after(port->delayed_runtime, ktime_get())) {
1474 mod_tcpm_delayed_work(port, ktime_to_ms(ktime_sub(port->delayed_runtime,
1475 ktime_get())));
1476 return true;
1477 }
1478 port->delayed_state = INVALID_STATE;
1479 }
1480 #endif
1481 return false;
1482 }
1483
tcpm_pd_check_request(struct tcpm_port * port)1484 static int tcpm_pd_check_request(struct tcpm_port *port)
1485 {
1486 u32 pdo, rdo = port->sink_request;
1487 unsigned int max, op, pdo_max, index;
1488 enum pd_pdo_type type;
1489
1490 index = rdo_index(rdo);
1491 if (!index || index > port->nr_src_pdo)
1492 return -EINVAL;
1493
1494 pdo = port->src_pdo[index - 1];
1495 type = pdo_type(pdo);
1496 switch (type) {
1497 case PDO_TYPE_FIXED:
1498 case PDO_TYPE_VAR:
1499 max = rdo_max_current(rdo);
1500 op = rdo_op_current(rdo);
1501 pdo_max = pdo_max_current(pdo);
1502
1503 if (op > pdo_max)
1504 return -EINVAL;
1505 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH))
1506 return -EINVAL;
1507
1508 if (type == PDO_TYPE_FIXED)
1509 debug("Requested %u mV, %u mA for %u / %u mA\n",
1510 pdo_fixed_voltage(pdo), pdo_max, op, max);
1511 else
1512 debug("Requested %u -> %u mV, %u mA for %u / %u mA\n",
1513 pdo_min_voltage(pdo), pdo_max_voltage(pdo),
1514 pdo_max, op, max);
1515 break;
1516 case PDO_TYPE_BATT:
1517 max = rdo_max_power(rdo);
1518 op = rdo_op_power(rdo);
1519 pdo_max = pdo_max_power(pdo);
1520
1521 if (op > pdo_max)
1522 return -EINVAL;
1523 if (max > pdo_max && !(rdo & RDO_CAP_MISMATCH))
1524 return -EINVAL;
1525 printf("Requested %u -> %u mV, %u mW for %u / %u mW\n",
1526 pdo_min_voltage(pdo), pdo_max_voltage(pdo),
1527 pdo_max, op, max);
1528 break;
1529 default:
1530 return -EINVAL;
1531 }
1532
1533 port->op_vsafe5v = index == 1;
1534
1535 return 0;
1536 }
1537
1538 #define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y))
1539 #define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y))
1540
tcpm_pd_select_pdo(struct tcpm_port * port,int * sink_pdo,int * src_pdo)1541 static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo,
1542 int *src_pdo)
1543 {
1544 unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0,
1545 max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0,
1546 min_snk_mv = 0;
1547 int ret = -EINVAL;
1548
1549 port->pps_data.supported = false;
1550 port->usb_type = POWER_SUPPLY_USB_TYPE_PD;
1551
1552 /*
1553 * Select the source PDO providing the most power which has a
1554 * matchig sink cap.
1555 */
1556 for (i = 0; i < port->nr_source_caps; i++) {
1557 u32 pdo = port->source_caps[i];
1558 enum pd_pdo_type type = pdo_type(pdo);
1559
1560 switch (type) {
1561 case PDO_TYPE_FIXED:
1562 max_src_mv = pdo_fixed_voltage(pdo);
1563 min_src_mv = max_src_mv;
1564 break;
1565 case PDO_TYPE_BATT:
1566 case PDO_TYPE_VAR:
1567 max_src_mv = pdo_max_voltage(pdo);
1568 min_src_mv = pdo_min_voltage(pdo);
1569 break;
1570 case PDO_TYPE_APDO:
1571 if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) {
1572 port->pps_data.supported = true;
1573 port->usb_type =
1574 POWER_SUPPLY_USB_TYPE_PD_PPS;
1575 }
1576 continue;
1577 default:
1578 printf("Invalid source PDO type, ignoring\n");
1579 continue;
1580 }
1581
1582 switch (type) {
1583 case PDO_TYPE_FIXED:
1584 case PDO_TYPE_VAR:
1585 src_ma = pdo_max_current(pdo);
1586 src_mw = src_ma * min_src_mv / 1000;
1587 break;
1588 case PDO_TYPE_BATT:
1589 src_mw = pdo_max_power(pdo);
1590 break;
1591 case PDO_TYPE_APDO:
1592 continue;
1593 default:
1594 printf("Invalid source PDO type, ignoring\n");
1595 continue;
1596 }
1597
1598 for (j = 0; j < port->nr_snk_pdo; j++) {
1599 pdo = port->snk_pdo[j];
1600
1601 switch (pdo_type(pdo)) {
1602 case PDO_TYPE_FIXED:
1603 max_snk_mv = pdo_fixed_voltage(pdo);
1604 min_snk_mv = max_snk_mv;
1605 break;
1606 case PDO_TYPE_BATT:
1607 case PDO_TYPE_VAR:
1608 max_snk_mv = pdo_max_voltage(pdo);
1609 min_snk_mv = pdo_min_voltage(pdo);
1610 break;
1611 case PDO_TYPE_APDO:
1612 continue;
1613 default:
1614 printf("Invalid sink PDO type, ignoring\n");
1615 continue;
1616 }
1617
1618 if (max_src_mv <= max_snk_mv &&
1619 min_src_mv >= min_snk_mv) {
1620 /* Prefer higher voltages if available */
1621 if ((src_mw == max_mw && min_src_mv > max_mv) ||
1622 src_mw > max_mw) {
1623 *src_pdo = i;
1624 *sink_pdo = j;
1625 max_mw = src_mw;
1626 max_mv = min_src_mv;
1627 ret = 0;
1628 }
1629 }
1630 }
1631 }
1632
1633 return ret;
1634 }
1635
1636 #define min_pps_apdo_current(x, y) \
1637 min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y))
1638
tcpm_pd_select_pps_apdo(struct tcpm_port * port)1639 static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port)
1640 {
1641 unsigned int i, j, max_mw = 0, max_mv = 0;
1642 unsigned int min_src_mv, max_src_mv, src_ma, src_mw;
1643 unsigned int min_snk_mv, max_snk_mv;
1644 unsigned int max_op_mv;
1645 u32 pdo, src, snk;
1646 unsigned int src_pdo = 0, snk_pdo = 0;
1647
1648 /*
1649 * Select the source PPS APDO providing the most power while staying
1650 * within the board's limits. We skip the first PDO as this is always
1651 * 5V 3A.
1652 */
1653 for (i = 1; i < port->nr_source_caps; ++i) {
1654 pdo = port->source_caps[i];
1655
1656 switch (pdo_type(pdo)) {
1657 case PDO_TYPE_APDO:
1658 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
1659 printf("Not PPS APDO (source), ignoring\n");
1660 continue;
1661 }
1662
1663 min_src_mv = pdo_pps_apdo_min_voltage(pdo);
1664 max_src_mv = pdo_pps_apdo_max_voltage(pdo);
1665 src_ma = pdo_pps_apdo_max_current(pdo);
1666 src_mw = (src_ma * max_src_mv) / 1000;
1667
1668 /*
1669 * Now search through the sink PDOs to find a matching
1670 * PPS APDO. Again skip the first sink PDO as this will
1671 * always be 5V 3A.
1672 */
1673 for (j = 1; j < port->nr_snk_pdo; j++) {
1674 pdo = port->snk_pdo[j];
1675
1676 switch (pdo_type(pdo)) {
1677 case PDO_TYPE_APDO:
1678 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
1679 printf("Not PPS APDO (sink), ignoring\n");
1680 continue;
1681 }
1682
1683 min_snk_mv =
1684 pdo_pps_apdo_min_voltage(pdo);
1685 max_snk_mv =
1686 pdo_pps_apdo_max_voltage(pdo);
1687 break;
1688 default:
1689 printf("Not APDO type (sink), ignoring\n");
1690 continue;
1691 }
1692
1693 if (min_src_mv <= max_snk_mv &&
1694 max_src_mv >= min_snk_mv) {
1695 max_op_mv = min(max_src_mv, max_snk_mv);
1696 src_mw = (max_op_mv * src_ma) / 1000;
1697 /* Prefer higher voltages if available */
1698 if ((src_mw == max_mw &&
1699 max_op_mv > max_mv) ||
1700 src_mw > max_mw) {
1701 src_pdo = i;
1702 snk_pdo = j;
1703 max_mw = src_mw;
1704 max_mv = max_op_mv;
1705 }
1706 }
1707 }
1708
1709 break;
1710 default:
1711 printf("Not APDO type (source), ignoring\n");
1712 continue;
1713 }
1714 }
1715
1716 if (src_pdo) {
1717 src = port->source_caps[src_pdo];
1718 snk = port->snk_pdo[snk_pdo];
1719
1720 port->pps_data.req_min_volt = max(pdo_pps_apdo_min_voltage(src),
1721 pdo_pps_apdo_min_voltage(snk));
1722 port->pps_data.req_max_volt = min(pdo_pps_apdo_max_voltage(src),
1723 pdo_pps_apdo_max_voltage(snk));
1724 port->pps_data.req_max_curr = min_pps_apdo_current(src, snk);
1725 port->pps_data.req_out_volt = min(port->pps_data.req_max_volt,
1726 max(port->pps_data.req_min_volt,
1727 port->pps_data.req_out_volt));
1728 port->pps_data.req_op_curr = min(port->pps_data.req_max_curr,
1729 port->pps_data.req_op_curr);
1730 }
1731
1732 return src_pdo;
1733 }
1734
tcpm_pd_build_request(struct tcpm_port * port,u32 * rdo)1735 static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo)
1736 {
1737 unsigned int mv, ma, mw, flags;
1738 unsigned int max_ma, max_mw;
1739 enum pd_pdo_type type;
1740 u32 pdo, matching_snk_pdo;
1741 int src_pdo_index = 0;
1742 int snk_pdo_index = 0;
1743 int ret;
1744
1745 ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index);
1746 if (ret < 0)
1747 return ret;
1748
1749 pdo = port->source_caps[src_pdo_index];
1750 matching_snk_pdo = port->snk_pdo[snk_pdo_index];
1751 type = pdo_type(pdo);
1752
1753 switch (type) {
1754 case PDO_TYPE_FIXED:
1755 mv = pdo_fixed_voltage(pdo);
1756 break;
1757 case PDO_TYPE_BATT:
1758 case PDO_TYPE_VAR:
1759 mv = pdo_min_voltage(pdo);
1760 break;
1761 default:
1762 printf("Invalid PDO selected!\n");
1763 return -EINVAL;
1764 }
1765
1766 /* Select maximum available current within the sink pdo's limit */
1767 if (type == PDO_TYPE_BATT) {
1768 mw = min_power(pdo, matching_snk_pdo);
1769 ma = 1000 * mw / mv;
1770 } else {
1771 ma = min_current(pdo, matching_snk_pdo);
1772 mw = ma * mv / 1000;
1773 }
1774
1775 flags = RDO_USB_COMM | RDO_NO_SUSPEND;
1776
1777 /* Set mismatch bit if offered power is less than operating power */
1778 max_ma = ma;
1779 max_mw = mw;
1780 if (mw < port->operating_snk_mw) {
1781 flags |= RDO_CAP_MISMATCH;
1782 if (type == PDO_TYPE_BATT &&
1783 (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo)))
1784 max_mw = pdo_max_power(matching_snk_pdo);
1785 else if (pdo_max_current(matching_snk_pdo) >
1786 pdo_max_current(pdo))
1787 max_ma = pdo_max_current(matching_snk_pdo);
1788 }
1789
1790 debug("cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d\n",
1791 port->cc_req, port->cc1, port->cc2, port->vbus_source,
1792 port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
1793 port->polarity);
1794
1795 if (type == PDO_TYPE_BATT) {
1796 *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags);
1797
1798 printf("Requesting PDO %d: %u mV, %u mW%s\n",
1799 src_pdo_index, mv, mw,
1800 flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
1801 } else {
1802 *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags);
1803
1804 printf("Requesting PDO %d: %u mV, %u mA%s\n",
1805 src_pdo_index, mv, ma,
1806 flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
1807 }
1808
1809 port->req_current_limit = ma;
1810 port->req_supply_voltage = mv;
1811
1812 return 0;
1813 }
1814
tcpm_pd_send_request(struct tcpm_port * port)1815 static int tcpm_pd_send_request(struct tcpm_port *port)
1816 {
1817 struct pd_message msg;
1818 int ret;
1819 u32 rdo;
1820
1821 ret = tcpm_pd_build_request(port, &rdo);
1822 if (ret < 0)
1823 return ret;
1824
1825 memset(&msg, 0, sizeof(msg));
1826 msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
1827 port->pwr_role,
1828 port->data_role,
1829 port->negotiated_rev,
1830 port->message_id, 1);
1831 msg.payload[0] = cpu_to_le32(rdo);
1832
1833 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1834 }
1835
tcpm_pd_build_pps_request(struct tcpm_port * port,u32 * rdo)1836 static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo)
1837 {
1838 unsigned int out_mv, op_ma, op_mw, max_mv, max_ma, flags;
1839 enum pd_pdo_type type;
1840 unsigned int src_pdo_index;
1841 u32 pdo;
1842
1843 src_pdo_index = tcpm_pd_select_pps_apdo(port);
1844 if (!src_pdo_index)
1845 return -EOPNOTSUPP;
1846
1847 pdo = port->source_caps[src_pdo_index];
1848 type = pdo_type(pdo);
1849
1850 switch (type) {
1851 case PDO_TYPE_APDO:
1852 if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
1853 printf("Invalid APDO selected!\n");
1854 return -EINVAL;
1855 }
1856 max_mv = port->pps_data.req_max_volt;
1857 max_ma = port->pps_data.req_max_curr;
1858 out_mv = port->pps_data.req_out_volt;
1859 op_ma = port->pps_data.req_op_curr;
1860 break;
1861 default:
1862 printf("Invalid PDO selected!\n");
1863 return -EINVAL;
1864 }
1865
1866 flags = RDO_USB_COMM | RDO_NO_SUSPEND;
1867
1868 op_mw = (op_ma * out_mv) / 1000;
1869 if (op_mw < port->operating_snk_mw) {
1870 /*
1871 * Try raising current to meet power needs. If that's not enough
1872 * then try upping the voltage. If that's still not enough
1873 * then we've obviously chosen a PPS APDO which really isn't
1874 * suitable so abandon ship.
1875 */
1876 op_ma = (port->operating_snk_mw * 1000) / out_mv;
1877 if ((port->operating_snk_mw * 1000) % out_mv)
1878 ++op_ma;
1879 op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP);
1880
1881 if (op_ma > max_ma) {
1882 op_ma = max_ma;
1883 out_mv = (port->operating_snk_mw * 1000) / op_ma;
1884 if ((port->operating_snk_mw * 1000) % op_ma)
1885 ++out_mv;
1886 out_mv += RDO_PROG_VOLT_MV_STEP -
1887 (out_mv % RDO_PROG_VOLT_MV_STEP);
1888
1889 if (out_mv > max_mv) {
1890 printf("Invalid PPS APDO selected!\n");
1891 return -EINVAL;
1892 }
1893 }
1894 }
1895
1896 debug("cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d\n",
1897 port->cc_req, port->cc1, port->cc2, port->vbus_source,
1898 port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
1899 port->polarity);
1900
1901 *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags);
1902
1903 printf("Requesting APDO %d: %u mV, %u mA\n",
1904 src_pdo_index, out_mv, op_ma);
1905
1906 port->pps_data.req_op_curr = op_ma;
1907 port->pps_data.req_out_volt = out_mv;
1908
1909 return 0;
1910 }
1911
tcpm_pd_send_pps_request(struct tcpm_port * port)1912 static int tcpm_pd_send_pps_request(struct tcpm_port *port)
1913 {
1914 struct pd_message msg;
1915 int ret;
1916 u32 rdo;
1917
1918 ret = tcpm_pd_build_pps_request(port, &rdo);
1919 if (ret < 0)
1920 return ret;
1921
1922 memset(&msg, 0, sizeof(msg));
1923 msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
1924 port->pwr_role,
1925 port->data_role,
1926 port->negotiated_rev,
1927 port->message_id, 1);
1928 msg.payload[0] = cpu_to_le32(rdo);
1929
1930 return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
1931 }
1932
tcpm_set_vbus(struct tcpm_port * port,bool enable)1933 static int tcpm_set_vbus(struct tcpm_port *port, bool enable)
1934 {
1935 int ret;
1936
1937 if (enable && port->vbus_charge)
1938 return -EINVAL;
1939
1940 debug("vbus = %d charge = %d\n", enable, port->vbus_charge);
1941
1942 ret = port->tcpc->set_vbus(port->tcpc, enable, port->vbus_charge);
1943 if (ret < 0)
1944 return ret;
1945
1946 port->vbus_source = enable;
1947 return 0;
1948 }
1949
tcpm_set_charge(struct tcpm_port * port,bool charge)1950 static int tcpm_set_charge(struct tcpm_port *port, bool charge)
1951 {
1952 int ret;
1953
1954 if (charge && port->vbus_source)
1955 return -EINVAL;
1956
1957 if (charge != port->vbus_charge) {
1958 debug("vbus = %d charge = %d\n", port->vbus_source, charge);
1959 ret = port->tcpc->set_vbus(port->tcpc, port->vbus_source,
1960 charge);
1961 if (ret < 0)
1962 return ret;
1963 }
1964 port->vbus_charge = charge;
1965 return 0;
1966 }
1967
tcpm_start_toggling(struct tcpm_port * port,enum typec_cc_status cc)1968 static bool tcpm_start_toggling(struct tcpm_port *port, enum typec_cc_status cc)
1969 {
1970 int ret;
1971
1972 if (!port->tcpc->start_toggling)
1973 return false;
1974
1975 printf("Start toggling\n");
1976 ret = port->tcpc->start_toggling(port->tcpc, port->port_type, cc);
1977 return ret == 0;
1978 }
1979
tcpm_init_vbus(struct tcpm_port * port)1980 static int tcpm_init_vbus(struct tcpm_port *port)
1981 {
1982 int ret;
1983
1984 ret = port->tcpc->set_vbus(port->tcpc, false, false);
1985 port->vbus_source = false;
1986 port->vbus_charge = false;
1987 return ret;
1988 }
1989
tcpm_init_vconn(struct tcpm_port * port)1990 static int tcpm_init_vconn(struct tcpm_port *port)
1991 {
1992 int ret;
1993
1994 ret = port->tcpc->set_vconn(port->tcpc, false);
1995 port->vconn_role = TYPEC_SINK;
1996 return ret;
1997 }
1998
tcpm_typec_connect(struct tcpm_port * port)1999 static void tcpm_typec_connect(struct tcpm_port *port)
2000 {
2001 if (!port->connected) {
2002 port->connected = true;
2003 }
2004 }
2005
tcpm_src_attach(struct tcpm_port * port)2006 static int tcpm_src_attach(struct tcpm_port *port)
2007 {
2008 enum typec_cc_polarity polarity =
2009 port->cc2 == TYPEC_CC_RD ? TYPEC_POLARITY_CC2
2010 : TYPEC_POLARITY_CC1;
2011 int ret;
2012
2013 if (port->attached)
2014 return 0;
2015
2016 ret = tcpm_set_polarity(port, polarity);
2017 if (ret < 0)
2018 return ret;
2019
2020 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, TYPEC_HOST);
2021 if (ret < 0)
2022 return ret;
2023
2024 ret = port->tcpc->set_pd_rx(port->tcpc, true);
2025 if (ret < 0)
2026 goto out_disable_mux;
2027
2028 /*
2029 * USB Type-C specification, version 1.2,
2030 * chapter 4.5.2.2.8.1 (Attached.SRC Requirements)
2031 * Enable VCONN only if the non-RD port is set to RA.
2032 */
2033 if ((polarity == TYPEC_POLARITY_CC1 && port->cc2 == TYPEC_CC_RA) ||
2034 (polarity == TYPEC_POLARITY_CC2 && port->cc1 == TYPEC_CC_RA)) {
2035 ret = tcpm_set_vconn(port, true);
2036 if (ret < 0)
2037 goto out_disable_pd;
2038 }
2039
2040 ret = tcpm_set_vbus(port, true);
2041 if (ret < 0)
2042 goto out_disable_vconn;
2043
2044 port->pd_capable = false;
2045
2046 port->partner = NULL;
2047
2048 port->attached = true;
2049 port->debouncing = false;
2050 //port->send_discover = true;
2051
2052 return 0;
2053
2054 out_disable_vconn:
2055 tcpm_set_vconn(port, false);
2056 out_disable_pd:
2057 port->tcpc->set_pd_rx(port->tcpc, false);
2058 out_disable_mux:
2059 printf("CC connected in %s as DFP\n",
2060 polarity ? "CC2" : "CC1");
2061 return 0;
2062 }
2063
tcpm_typec_disconnect(struct tcpm_port * port)2064 static void tcpm_typec_disconnect(struct tcpm_port *port)
2065 {
2066 if (port->connected) {
2067 port->partner = NULL;
2068 port->connected = false;
2069 }
2070 }
2071
tcpm_reset_port(struct tcpm_port * port)2072 static void tcpm_reset_port(struct tcpm_port *port)
2073 {
2074 tcpm_timer_uninit(port);
2075 tcpm_typec_disconnect(port);
2076 port->poll_event_cnt = 0;
2077 port->wait_dr_swap_Message = false;
2078 port->attached = false;
2079 port->pd_capable = false;
2080 port->pps_data.supported = false;
2081
2082 /*
2083 * First Rx ID should be 0; set this to a sentinel of -1 so that
2084 * we can check tcpm_pd_rx_handler() if we had seen it before.
2085 */
2086 port->rx_msgid = -1;
2087
2088 port->tcpc->set_pd_rx(port->tcpc, false);
2089 tcpm_init_vbus(port); /* also disables charging */
2090 tcpm_init_vconn(port);
2091 tcpm_set_current_limit(port, 0, 0);
2092 tcpm_set_polarity(port, TYPEC_POLARITY_CC1);
2093 tcpm_set_attached_state(port, false);
2094 port->usb_type = POWER_SUPPLY_USB_TYPE_C;
2095 port->nr_sink_caps = 0;
2096 port->sink_cap_done = false;
2097 }
2098
tcpm_detach(struct tcpm_port * port)2099 static void tcpm_detach(struct tcpm_port *port)
2100 {
2101 if (tcpm_port_is_disconnected(port))
2102 port->hard_reset_count = 0;
2103
2104 if (!port->attached)
2105 return;
2106
2107 tcpm_reset_port(port);
2108 }
2109
tcpm_src_detach(struct tcpm_port * port)2110 static void tcpm_src_detach(struct tcpm_port *port)
2111 {
2112 tcpm_detach(port);
2113 }
2114
tcpm_snk_attach(struct tcpm_port * port)2115 static int tcpm_snk_attach(struct tcpm_port *port)
2116 {
2117 int ret;
2118
2119 if (port->attached)
2120 return 0;
2121
2122 ret = tcpm_set_polarity(port, port->cc2 != TYPEC_CC_OPEN ?
2123 TYPEC_POLARITY_CC2 : TYPEC_POLARITY_CC1);
2124 if (ret < 0)
2125 return ret;
2126
2127 ret = tcpm_set_roles(port, true, TYPEC_SINK, TYPEC_DEVICE);
2128 if (ret < 0)
2129 return ret;
2130
2131 port->pd_capable = false;
2132
2133 port->partner = NULL;
2134
2135 port->attached = true;
2136 port->debouncing = false;
2137 printf("CC connected in %s as UFP\n",
2138 port->cc1 != TYPEC_CC_OPEN ? "CC1" : "CC2");
2139
2140 return 0;
2141 }
2142
tcpm_snk_detach(struct tcpm_port * port)2143 static void tcpm_snk_detach(struct tcpm_port *port)
2144 {
2145 tcpm_detach(port);
2146 }
2147
tcpm_acc_attach(struct tcpm_port * port)2148 static int tcpm_acc_attach(struct tcpm_port *port)
2149 {
2150 int ret;
2151
2152 if (port->attached)
2153 return 0;
2154
2155 ret = tcpm_set_roles(port, true, TYPEC_SOURCE, TYPEC_HOST);
2156 if (ret < 0)
2157 return ret;
2158
2159 port->partner = NULL;
2160
2161 tcpm_typec_connect(port);
2162
2163 port->attached = true;
2164
2165 dev_info(port->dev, "CC connected as Audio Accessory\n");
2166
2167 return 0;
2168 }
2169
tcpm_acc_detach(struct tcpm_port * port)2170 static void tcpm_acc_detach(struct tcpm_port *port)
2171 {
2172 tcpm_detach(port);
2173 }
2174
hard_reset_state(struct tcpm_port * port)2175 static inline enum tcpm_state hard_reset_state(struct tcpm_port *port)
2176 {
2177 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT)
2178 return HARD_RESET_SEND;
2179 if (port->pd_capable)
2180 return ERROR_RECOVERY;
2181 if (port->pwr_role == TYPEC_SOURCE)
2182 return SRC_UNATTACHED;
2183 if (port->state == SNK_WAIT_CAPABILITIES)
2184 return SNK_READY;
2185 return SNK_UNATTACHED;
2186 }
2187
unattached_state(struct tcpm_port * port)2188 static inline enum tcpm_state unattached_state(struct tcpm_port *port)
2189 {
2190 if (port->port_type == TYPEC_PORT_DRP) {
2191 if (port->pwr_role == TYPEC_SOURCE)
2192 return SRC_UNATTACHED;
2193 else
2194 return SNK_UNATTACHED;
2195 } else if (port->port_type == TYPEC_PORT_SRC) {
2196 return SRC_UNATTACHED;
2197 }
2198
2199 return SNK_UNATTACHED;
2200 }
2201
tcpm_is_toggling(struct tcpm_port * port)2202 bool tcpm_is_toggling(struct tcpm_port *port)
2203 {
2204 if (port->port_type == TYPEC_PORT_DRP)
2205 return port->state == SRC_UNATTACHED || port->state == SNK_UNATTACHED ||
2206 port->state == TOGGLING;
2207
2208 return false;
2209 }
2210 EXPORT_SYMBOL_GPL(tcpm_is_toggling);
2211
run_state_machine(struct tcpm_port * port)2212 static void run_state_machine(struct tcpm_port *port)
2213 {
2214 int ret;
2215
2216 port->enter_state = port->state;
2217 switch (port->state) {
2218 case TOGGLING:
2219 break;
2220 /* SRC states */
2221 case SRC_UNATTACHED:
2222 tcpm_src_detach(port);
2223 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) {
2224 tcpm_set_state(port, TOGGLING, 0);
2225 break;
2226 }
2227 tcpm_set_cc(port, tcpm_rp_cc(port));
2228 if (port->port_type == TYPEC_PORT_DRP)
2229 tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK);
2230 break;
2231 case SRC_ATTACH_WAIT:
2232 if (tcpm_port_is_debug(port))
2233 tcpm_set_state(port, DEBUG_ACC_ATTACHED,
2234 PD_T_CC_DEBOUNCE);
2235 else if (tcpm_port_is_audio(port))
2236 tcpm_set_state(port, AUDIO_ACC_ATTACHED,
2237 PD_T_CC_DEBOUNCE);
2238 else if (tcpm_port_is_source(port))
2239 tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE);
2240 break;
2241
2242 case SRC_ATTACHED:
2243 ret = tcpm_src_attach(port);
2244 /*
2245 * Currently, vbus control is not implemented,
2246 * and the SRC detection process cannot be fully implemented.
2247 */
2248 tcpm_set_state(port, SRC_READY, 0);
2249 #if 0
2250 tcpm_set_state(port, SRC_UNATTACHED,
2251 ret < 0 ? 0 : PD_T_PS_SOURCE_ON);
2252 #endif
2253 break;
2254 case SRC_STARTUP:
2255 port->caps_count = 0;
2256 port->negotiated_rev = PD_MAX_REV;
2257 port->message_id = 0;
2258 port->rx_msgid = -1;
2259 port->explicit_contract = false;
2260 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
2261 break;
2262 case SRC_SEND_CAPABILITIES:
2263 port->caps_count++;
2264 if (port->caps_count > PD_N_CAPS_COUNT) {
2265 tcpm_set_state(port, SRC_READY, 0);
2266 break;
2267 }
2268 ret = tcpm_pd_send_source_caps(port);
2269 if (ret < 0) {
2270 tcpm_set_state(port, SRC_SEND_CAPABILITIES,
2271 PD_T_SEND_SOURCE_CAP);
2272 } else {
2273 /*
2274 * Per standard, we should clear the reset counter here.
2275 * However, that can result in state machine hang-ups.
2276 * Reset it only in READY state to improve stability.
2277 */
2278 /* port->hard_reset_count = 0; */
2279 port->caps_count = 0;
2280 port->pd_capable = true;
2281 tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT,
2282 PD_T_SEND_SOURCE_CAP);
2283 }
2284 break;
2285 case SRC_SEND_CAPABILITIES_TIMEOUT:
2286 /*
2287 * Error recovery for a PD_DATA_SOURCE_CAP reply timeout.
2288 *
2289 * PD 2.0 sinks are supposed to accept src-capabilities with a
2290 * 3.0 header and simply ignore any src PDOs which the sink does
2291 * not understand such as PPS but some 2.0 sinks instead ignore
2292 * the entire PD_DATA_SOURCE_CAP message, causing contract
2293 * negotiation to fail.
2294 *
2295 * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try
2296 * sending src-capabilities with a lower PD revision to
2297 * make these broken sinks work.
2298 */
2299 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) {
2300 tcpm_set_state(port, HARD_RESET_SEND, 0);
2301 } else if (port->negotiated_rev > PD_REV20) {
2302 port->negotiated_rev--;
2303 port->hard_reset_count = 0;
2304 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
2305 } else {
2306 tcpm_set_state(port, hard_reset_state(port), 0);
2307 }
2308 break;
2309 case SRC_NEGOTIATE_CAPABILITIES:
2310 ret = tcpm_pd_check_request(port);
2311 if (ret < 0) {
2312 tcpm_pd_send_control(port, PD_CTRL_REJECT);
2313 if (!port->explicit_contract) {
2314 tcpm_set_state(port,
2315 SRC_WAIT_NEW_CAPABILITIES, 0);
2316 } else {
2317 tcpm_set_state(port, SRC_READY, 0);
2318 }
2319 } else {
2320 tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
2321 tcpm_set_state(port, SRC_TRANSITION_SUPPLY,
2322 PD_T_SRC_TRANSITION);
2323 }
2324 break;
2325 case SRC_TRANSITION_SUPPLY:
2326 /* XXX: regulator_set_voltage(vbus, ...) */
2327 tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
2328 port->explicit_contract = true;
2329 tcpm_set_state_cond(port, SRC_READY, 0);
2330 break;
2331 case SRC_READY:
2332 #if 1
2333 port->hard_reset_count = 0;
2334 #endif
2335 port->try_src_count = 0;
2336
2337 tcpm_typec_connect(port);
2338 break;
2339 case SRC_WAIT_NEW_CAPABILITIES:
2340 /* Nothing to do... */
2341 break;
2342
2343 /* SNK states */
2344 case SNK_UNATTACHED:
2345 tcpm_snk_detach(port);
2346 if (tcpm_start_toggling(port, TYPEC_CC_RD)) {
2347 tcpm_set_state(port, TOGGLING, 0);
2348 break;
2349 }
2350 tcpm_set_cc(port, TYPEC_CC_RD);
2351 if (port->port_type == TYPEC_PORT_DRP)
2352 tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC);
2353 break;
2354 case SNK_ATTACH_WAIT:
2355 if ((port->cc1 == TYPEC_CC_OPEN &&
2356 port->cc2 != TYPEC_CC_OPEN) ||
2357 (port->cc1 != TYPEC_CC_OPEN &&
2358 port->cc2 == TYPEC_CC_OPEN))
2359 tcpm_set_state(port, SNK_DEBOUNCED,
2360 PD_T_CC_DEBOUNCE);
2361 else if (tcpm_port_is_disconnected(port))
2362 tcpm_set_state(port, SNK_UNATTACHED,
2363 PD_T_CC_DEBOUNCE);
2364 break;
2365 case SNK_DEBOUNCED:
2366 if (tcpm_port_is_disconnected(port)) {
2367 tcpm_set_state(port, SNK_UNATTACHED,
2368 PD_T_PD_DEBOUNCE);
2369 } else if (port->vbus_present)
2370 tcpm_set_state(port, SNK_ATTACHED, 0);
2371 else
2372 /* Wait for VBUS, but not forever */
2373 tcpm_set_state(port, PORT_RESET, PD_T_PS_SOURCE_ON);
2374 break;
2375
2376 case SNK_ATTACHED:
2377 ret = tcpm_snk_attach(port);
2378 if (ret < 0)
2379 tcpm_set_state(port, SNK_UNATTACHED, 0);
2380 else
2381 tcpm_set_state(port, SNK_STARTUP, 0);
2382 break;
2383 case SNK_STARTUP:
2384 port->negotiated_rev = PD_MAX_REV;
2385 port->message_id = 0;
2386 port->rx_msgid = -1;
2387 port->explicit_contract = false;
2388 tcpm_set_state(port, SNK_DISCOVERY, 0);
2389 break;
2390 case SNK_DISCOVERY:
2391 if (port->vbus_present) {
2392 tcpm_set_current_limit(port,
2393 tcpm_get_current_limit(port),
2394 5000);
2395 tcpm_set_charge(port, true);
2396 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
2397 break;
2398 }
2399 /*
2400 * For DRP, timeouts differ. Also, handling is supposed to be
2401 * different and much more complex (dead battery detection;
2402 * see USB power delivery specification, section 8.3.3.6.1.5.1).
2403 */
2404 tcpm_set_state(port, hard_reset_state(port),
2405 port->port_type == TYPEC_PORT_DRP ?
2406 PD_T_DB_DETECT : PD_T_NO_RESPONSE);
2407 break;
2408 case SNK_DISCOVERY_DEBOUNCE:
2409 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE,
2410 PD_T_CC_DEBOUNCE);
2411 break;
2412 case SNK_DISCOVERY_DEBOUNCE_DONE:
2413 #if 0
2414 if (!tcpm_port_is_disconnected(port) &&
2415 tcpm_port_is_sink(port) &&
2416 ktime_after(port->delayed_runtime, ktime_get())) {
2417 tcpm_set_state(port, SNK_DISCOVERY,
2418 ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get())));
2419 break;
2420 }
2421 #endif
2422 tcpm_set_state(port, unattached_state(port), 0);
2423 break;
2424 case SNK_WAIT_CAPABILITIES:
2425 ret = port->tcpc->set_pd_rx(port->tcpc, true);
2426 if (ret < 0) {
2427 tcpm_set_state(port, SNK_READY, 0);
2428 break;
2429 }
2430 /*
2431 * If VBUS has never been low, and we time out waiting
2432 * for source cap, try a soft reset first, in case we
2433 * were already in a stable contract before this boot.
2434 * Do this only once.
2435 */
2436 if (port->vbus_never_low) {
2437 port->vbus_never_low = false;
2438 tcpm_set_state(port, SOFT_RESET_SEND,
2439 PD_T_SINK_WAIT_CAP);
2440 } else {
2441 tcpm_set_state(port, hard_reset_state(port),
2442 PD_T_SINK_WAIT_CAP);
2443 }
2444 break;
2445 case SNK_NEGOTIATE_CAPABILITIES:
2446 port->pd_capable = true;
2447 port->hard_reset_count = 0;
2448 ret = tcpm_pd_send_request(port);
2449 if (ret < 0) {
2450 /* Let the Source send capabilities again. */
2451 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
2452 } else {
2453 tcpm_set_state_cond(port, hard_reset_state(port),
2454 PD_T_SENDER_RESPONSE);
2455 }
2456 break;
2457 case SNK_NEGOTIATE_PPS_CAPABILITIES:
2458 ret = tcpm_pd_send_pps_request(port);
2459 if (ret < 0) {
2460 port->pps_status = ret;
2461 /*
2462 * If this was called due to updates to sink
2463 * capabilities, and pps is no longer valid, we should
2464 * safely fall back to a standard PDO.
2465 */
2466 if (port->update_sink_caps)
2467 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
2468 else
2469 tcpm_set_state(port, SNK_READY, 0);
2470 } else {
2471 tcpm_set_state_cond(port, hard_reset_state(port),
2472 PD_T_SENDER_RESPONSE);
2473 }
2474 break;
2475 case SNK_TRANSITION_SINK:
2476 case SNK_TRANSITION_SINK_VBUS:
2477 tcpm_set_state(port, hard_reset_state(port),
2478 PD_T_PS_TRANSITION);
2479 break;
2480 case SNK_READY:
2481 port->try_snk_count = 0;
2482 port->update_sink_caps = false;
2483 tcpm_typec_connect(port);
2484 /*
2485 * Here poll_event_cnt is cleared, waiting for self-powered Type-C devices
2486 * to send DR_swap Messge until 1s (TCPM_POLL_EVENT_TIME_OUT * 500us)timeout
2487 */
2488 if (port->wait_dr_swap_Message)
2489 port->poll_event_cnt = 0;
2490
2491 break;
2492
2493 /* Accessory states */
2494 case ACC_UNATTACHED:
2495 tcpm_acc_detach(port);
2496 tcpm_set_state(port, SRC_UNATTACHED, 0);
2497 break;
2498 case DEBUG_ACC_ATTACHED:
2499 case AUDIO_ACC_ATTACHED:
2500 ret = tcpm_acc_attach(port);
2501 if (ret < 0)
2502 tcpm_set_state(port, ACC_UNATTACHED, 0);
2503 break;
2504 case AUDIO_ACC_DEBOUNCE:
2505 tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE);
2506 break;
2507
2508 /* Hard_Reset states */
2509 case HARD_RESET_SEND:
2510 tcpm_pd_transmit(port, TCPC_TX_HARD_RESET, NULL);
2511 tcpm_set_state(port, HARD_RESET_START, 0);
2512 port->wait_dr_swap_Message = false;
2513 break;
2514 case HARD_RESET_START:
2515 port->hard_reset_count++;
2516 port->tcpc->set_pd_rx(port->tcpc, false);
2517 port->nr_sink_caps = 0;
2518 port->send_discover = true;
2519 if (port->pwr_role == TYPEC_SOURCE)
2520 tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF,
2521 PD_T_PS_HARD_RESET);
2522 else
2523 tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0);
2524 break;
2525 case SRC_HARD_RESET_VBUS_OFF:
2526 tcpm_set_vconn(port, true);
2527 tcpm_set_vbus(port, false);
2528 tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE,
2529 TYPEC_HOST);
2530 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SRC_RECOVER);
2531 break;
2532 case SRC_HARD_RESET_VBUS_ON:
2533 tcpm_set_vconn(port, true);
2534 tcpm_set_vbus(port, true);
2535 port->tcpc->set_pd_rx(port->tcpc, true);
2536 tcpm_set_attached_state(port, true);
2537 tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON);
2538 break;
2539 case SNK_HARD_RESET_SINK_OFF:
2540 memset(&port->pps_data, 0, sizeof(port->pps_data));
2541 tcpm_set_vconn(port, false);
2542 if (port->pd_capable)
2543 tcpm_set_charge(port, false);
2544 tcpm_set_roles(port, port->self_powered, TYPEC_SINK,
2545 TYPEC_DEVICE);
2546 /*
2547 * VBUS may or may not toggle, depending on the adapter.
2548 * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON
2549 * directly after timeout.
2550 */
2551 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V);
2552 break;
2553 case SNK_HARD_RESET_WAIT_VBUS:
2554 /* Assume we're disconnected if VBUS doesn't come back. */
2555 tcpm_set_state(port, SNK_UNATTACHED,
2556 PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON);
2557 break;
2558 case SNK_HARD_RESET_SINK_ON:
2559 /* Note: There is no guarantee that VBUS is on in this state */
2560 /*
2561 * XXX:
2562 * The specification suggests that dual mode ports in sink
2563 * mode should transition to state PE_SRC_Transition_to_default.
2564 * See USB power delivery specification chapter 8.3.3.6.1.3.
2565 * This would mean to to
2566 * - turn off VCONN, reset power supply
2567 * - request hardware reset
2568 * - turn on VCONN
2569 * - Transition to state PE_Src_Startup
2570 * SNK only ports shall transition to state Snk_Startup
2571 * (see chapter 8.3.3.3.8).
2572 * Similar, dual-mode ports in source mode should transition
2573 * to PE_SNK_Transition_to_default.
2574 */
2575 if (port->pd_capable) {
2576 tcpm_set_current_limit(port,
2577 tcpm_get_current_limit(port),
2578 5000);
2579 tcpm_set_charge(port, true);
2580 }
2581 tcpm_set_attached_state(port, true);
2582 tcpm_set_state(port, SNK_STARTUP, 0);
2583 break;
2584
2585 /* Soft_Reset states */
2586 case SOFT_RESET:
2587 port->message_id = 0;
2588 port->rx_msgid = -1;
2589 tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
2590 if (port->pwr_role == TYPEC_SOURCE) {
2591 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
2592 } else {
2593 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
2594 }
2595 break;
2596 case SOFT_RESET_SEND:
2597 port->message_id = 0;
2598 port->rx_msgid = -1;
2599 if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET))
2600 tcpm_set_state_cond(port, hard_reset_state(port), 0);
2601 else
2602 tcpm_set_state_cond(port, hard_reset_state(port),
2603 PD_T_SENDER_RESPONSE);
2604 break;
2605
2606 /* DR_Swap states */
2607 case DR_SWAP_SEND:
2608 tcpm_pd_send_control(port, PD_CTRL_DR_SWAP);
2609 tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT,
2610 PD_T_SENDER_RESPONSE);
2611 break;
2612 case DR_SWAP_ACCEPT:
2613 tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
2614 #if 0
2615 /* Set VDM state machine running flag ASAP */
2616 if (port->data_role == TYPEC_DEVICE && port->send_discover)
2617 port->vdm_sm_running = true;
2618 #endif
2619 tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0);
2620 break;
2621 case DR_SWAP_SEND_TIMEOUT:
2622 //tcpm_swap_complete(port, -ETIMEDOUT);
2623 tcpm_set_state(port, ready_state(port), 0);
2624 break;
2625 case DR_SWAP_CHANGE_DR:
2626 if (port->data_role == TYPEC_HOST) {
2627 //tcpm_unregister_altmodes(port);
2628 tcpm_set_roles(port, true, port->pwr_role,
2629 TYPEC_DEVICE);
2630 } else {
2631 tcpm_set_roles(port, true, port->pwr_role,
2632 TYPEC_HOST);
2633 //port->send_discover = true;
2634 }
2635 /* DR_swap process complete, wait_dr_swap_Message is cleared */
2636 port->wait_dr_swap_Message = false;
2637 tcpm_set_state(port, ready_state(port), 0);
2638 break;
2639
2640 #if 0
2641
2642 /* PR_Swap states */
2643 case PR_SWAP_ACCEPT:
2644 tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
2645 tcpm_set_state(port, PR_SWAP_START, 0);
2646 break;
2647 case PR_SWAP_SEND:
2648 tcpm_pd_send_control(port, PD_CTRL_PR_SWAP);
2649 tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT,
2650 PD_T_SENDER_RESPONSE);
2651 break;
2652 case PR_SWAP_SEND_TIMEOUT:
2653 tcpm_set_state(port, ready_state(port), 0);
2654 break;
2655 case PR_SWAP_START:
2656 tcpm_apply_rc(port);
2657 if (port->pwr_role == TYPEC_SOURCE)
2658 tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF,
2659 PD_T_SRC_TRANSITION);
2660 else
2661 tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0);
2662 break;
2663 case PR_SWAP_SRC_SNK_TRANSITION_OFF:
2664 /*
2665 * Prevent vbus discharge circuit from turning on during PR_SWAP
2666 * as this is not a disconnect.
2667 */
2668 tcpm_set_vbus(port, false);
2669 port->explicit_contract = false;
2670 /* allow time for Vbus discharge, must be < tSrcSwapStdby */
2671 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF,
2672 PD_T_SRCSWAPSTDBY);
2673 break;
2674 case PR_SWAP_SRC_SNK_SOURCE_OFF:
2675 timer_val_msecs = PD_T_CC_DEBOUNCE;
2676 trace_android_vh_typec_tcpm_get_timer(tcpm_states[PR_SWAP_SRC_SNK_SOURCE_OFF],
2677 CC_DEBOUNCE, &timer_val_msecs);
2678 tcpm_set_cc(port, TYPEC_CC_RD);
2679 /* allow CC debounce */
2680 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED,
2681 timer_val_msecs);
2682 break;
2683 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
2684 /*
2685 * USB-PD standard, 6.2.1.4, Port Power Role:
2686 * "During the Power Role Swap Sequence, for the initial Source
2687 * Port, the Port Power Role field shall be set to Sink in the
2688 * PS_RDY Message indicating that the initial Source’s power
2689 * supply is turned off"
2690 */
2691 tcpm_set_pwr_role(port, TYPEC_SINK);
2692 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) {
2693 tcpm_set_state(port, ERROR_RECOVERY, 0);
2694 break;
2695 }
2696 tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS);
2697 break;
2698 case PR_SWAP_SRC_SNK_SINK_ON:
2699 tcpm_enable_auto_vbus_discharge(port, true);
2700 /* Set the vbus disconnect threshold for implicit contract */
2701 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
2702 tcpm_set_state(port, SNK_STARTUP, 0);
2703 break;
2704 case PR_SWAP_SNK_SRC_SINK_OFF:
2705 timer_val_msecs = PD_T_PS_SOURCE_OFF;
2706 trace_android_vh_typec_tcpm_get_timer(tcpm_states[PR_SWAP_SNK_SRC_SINK_OFF],
2707 SOURCE_OFF, &timer_val_msecs);
2708 /*
2709 * Prevent vbus discharge circuit from turning on during PR_SWAP
2710 * as this is not a disconnect.
2711 */
2712 tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB,
2713 port->pps_data.active, 0);
2714 tcpm_set_charge(port, false);
2715 tcpm_set_state(port, hard_reset_state(port), timer_val_msecs);
2716 break;
2717 case PR_SWAP_SNK_SRC_SOURCE_ON:
2718 tcpm_enable_auto_vbus_discharge(port, true);
2719 tcpm_set_cc(port, tcpm_rp_cc(port));
2720 tcpm_set_vbus(port, true);
2721 /*
2722 * allow time VBUS ramp-up, must be < tNewSrc
2723 * Also, this window overlaps with CC debounce as well.
2724 * So, Wait for the max of two which is PD_T_NEWSRC
2725 */
2726 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP,
2727 PD_T_NEWSRC);
2728 break;
2729 case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP:
2730 /*
2731 * USB PD standard, 6.2.1.4:
2732 * "Subsequent Messages initiated by the Policy Engine,
2733 * such as the PS_RDY Message sent to indicate that Vbus
2734 * is ready, will have the Port Power Role field set to
2735 * Source."
2736 */
2737 tcpm_set_pwr_role(port, TYPEC_SOURCE);
2738 tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
2739 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
2740 break;
2741 #endif
2742 case GET_STATUS_SEND:
2743 tcpm_pd_send_control(port, PD_CTRL_GET_STATUS);
2744 tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT,
2745 PD_T_SENDER_RESPONSE);
2746 break;
2747 case GET_STATUS_SEND_TIMEOUT:
2748 tcpm_set_state(port, ready_state(port), 0);
2749 break;
2750 case GET_PPS_STATUS_SEND:
2751 tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS);
2752 tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT,
2753 PD_T_SENDER_RESPONSE);
2754 break;
2755 case GET_PPS_STATUS_SEND_TIMEOUT:
2756 tcpm_set_state(port, ready_state(port), 0);
2757 break;
2758 case GET_SINK_CAP:
2759 tcpm_pd_send_control(port, PD_CTRL_GET_SINK_CAP);
2760 tcpm_set_state(port, GET_SINK_CAP_TIMEOUT, PD_T_SENDER_RESPONSE);
2761 break;
2762 case GET_SINK_CAP_TIMEOUT:
2763 tcpm_set_state(port, ready_state(port), 0);
2764 break;
2765 case ERROR_RECOVERY:
2766 tcpm_set_state(port, PORT_RESET, 0);
2767 break;
2768 case PORT_RESET:
2769 tcpm_reset_port(port);
2770 tcpm_set_cc(port, TYPEC_CC_OPEN);
2771 tcpm_set_state(port, PORT_RESET_WAIT_OFF,
2772 PD_T_ERROR_RECOVERY);
2773 break;
2774 case PORT_RESET_WAIT_OFF:
2775 tcpm_set_state(port,
2776 tcpm_default_state(port),
2777 port->vbus_present ? PD_T_PS_SOURCE_OFF : 0);
2778 break;
2779 default:
2780 printf("Unexpected port state %d\n", port->state);
2781 break;
2782 }
2783 }
2784
tcpm_state_machine(struct tcpm_port * port)2785 static void tcpm_state_machine(struct tcpm_port *port)
2786 {
2787 enum tcpm_state prev_state;
2788
2789 mutex_lock(&port->lock);
2790 port->state_machine_running = true;
2791
2792 if (port->queued_message && tcpm_send_queued_message(port))
2793 goto done;
2794
2795 /* If we were queued due to a delayed state change, update it now */
2796 if (port->delayed_state) {
2797 debug("state change %s -> %s [delayed %ld ms]\n",
2798 tcpm_states[port->state],
2799 tcpm_states[port->delayed_state], port->delay_ms);
2800 port->prev_state = port->state;
2801 port->state = port->delayed_state;
2802 port->delayed_state = INVALID_STATE;
2803 }
2804
2805 /*
2806 * Continue running as long as we have (non-delayed) state changes
2807 * to make.
2808 */
2809 do {
2810 prev_state = port->state;
2811 run_state_machine(port);
2812 if (port->queued_message)
2813 tcpm_send_queued_message(port);
2814 } while (port->state != prev_state && !port->delayed_state);
2815
2816 done:
2817 port->state_machine_running = false;
2818 mutex_unlock(&port->lock);
2819 }
2820
_tcpm_cc_change(struct tcpm_port * port,enum typec_cc_status cc1,enum typec_cc_status cc2)2821 static void _tcpm_cc_change(struct tcpm_port *port, enum typec_cc_status cc1,
2822 enum typec_cc_status cc2)
2823 {
2824 enum typec_cc_status old_cc1, old_cc2;
2825 enum tcpm_state new_state;
2826
2827 old_cc1 = port->cc1;
2828 old_cc2 = port->cc2;
2829 port->cc1 = cc1;
2830 port->cc2 = cc2;
2831
2832 debug("CC1: %u -> %u, CC2: %u -> %u [state %s, polarity %d, %s]\n",
2833 old_cc1, cc1, old_cc2, cc2, tcpm_states[port->state],
2834 port->polarity,
2835 tcpm_port_is_disconnected(port) ? "disconnected" : "connected");
2836
2837 switch (port->state) {
2838 case TOGGLING:
2839 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) ||
2840 tcpm_port_is_source(port))
2841 tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
2842 else if (tcpm_port_is_sink(port))
2843 tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
2844 break;
2845 case SRC_UNATTACHED:
2846 case ACC_UNATTACHED:
2847 if (tcpm_port_is_debug(port) || tcpm_port_is_audio(port) ||
2848 tcpm_port_is_source(port))
2849 tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
2850 break;
2851 case SRC_ATTACH_WAIT:
2852 if (tcpm_port_is_disconnected(port) ||
2853 tcpm_port_is_audio_detached(port))
2854 tcpm_set_state(port, SRC_UNATTACHED, 0);
2855 else if (cc1 != old_cc1 || cc2 != old_cc2)
2856 tcpm_set_state(port, SRC_ATTACH_WAIT, 0);
2857 break;
2858 case SRC_ATTACHED:
2859 case SRC_SEND_CAPABILITIES:
2860 case SRC_READY:
2861 if (tcpm_port_is_disconnected(port) ||
2862 !tcpm_port_is_source(port))
2863 tcpm_set_state(port, SRC_UNATTACHED, 0);
2864 break;
2865 case SNK_UNATTACHED:
2866 if (tcpm_port_is_sink(port))
2867 tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
2868 break;
2869 case SNK_ATTACH_WAIT:
2870 if ((port->cc1 == TYPEC_CC_OPEN &&
2871 port->cc2 != TYPEC_CC_OPEN) ||
2872 (port->cc1 != TYPEC_CC_OPEN &&
2873 port->cc2 == TYPEC_CC_OPEN))
2874 new_state = SNK_DEBOUNCED;
2875 else if (tcpm_port_is_disconnected(port))
2876 new_state = SNK_UNATTACHED;
2877 else
2878 break;
2879 if (new_state != port->delayed_state)
2880 tcpm_set_state(port, SNK_ATTACH_WAIT, 0);
2881 break;
2882 case SNK_DEBOUNCED:
2883 if (tcpm_port_is_disconnected(port))
2884 new_state = SNK_UNATTACHED;
2885 else if (port->vbus_present)
2886 new_state = tcpm_try_src(port) ? SRC_TRY : SNK_ATTACHED;
2887 else
2888 new_state = SNK_UNATTACHED;
2889 if (new_state != port->delayed_state)
2890 tcpm_set_state(port, SNK_DEBOUNCED, 0);
2891 break;
2892 case SNK_READY:
2893 if (tcpm_port_is_disconnected(port))
2894 tcpm_set_state(port, unattached_state(port), 0);
2895 else if (!port->pd_capable &&
2896 (cc1 != old_cc1 || cc2 != old_cc2))
2897 tcpm_set_current_limit(port,
2898 tcpm_get_current_limit(port),
2899 5000);
2900 break;
2901
2902 case AUDIO_ACC_ATTACHED:
2903 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN)
2904 tcpm_set_state(port, AUDIO_ACC_DEBOUNCE, 0);
2905 break;
2906 case AUDIO_ACC_DEBOUNCE:
2907 if (tcpm_port_is_audio(port))
2908 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 0);
2909 break;
2910
2911 case DEBUG_ACC_ATTACHED:
2912 if (cc1 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_OPEN)
2913 tcpm_set_state(port, ACC_UNATTACHED, 0);
2914 break;
2915
2916 case SNK_TRY:
2917 /* Do nothing, waiting for timeout */
2918 break;
2919
2920 case SNK_DISCOVERY:
2921 /* CC line is unstable, wait for debounce */
2922 if (tcpm_port_is_disconnected(port))
2923 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE, 0);
2924 break;
2925 case SNK_DISCOVERY_DEBOUNCE:
2926 break;
2927
2928 case SRC_TRYWAIT:
2929 /* Hand over to state machine if needed */
2930 if (!port->vbus_present && tcpm_port_is_source(port))
2931 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0);
2932 break;
2933 case SRC_TRYWAIT_DEBOUNCE:
2934 if (port->vbus_present || !tcpm_port_is_source(port))
2935 tcpm_set_state(port, SRC_TRYWAIT, 0);
2936 break;
2937 case SNK_TRY_WAIT_DEBOUNCE:
2938 if (!tcpm_port_is_sink(port)) {
2939 port->max_wait = 0;
2940 tcpm_set_state(port, SRC_TRYWAIT, 0);
2941 }
2942 break;
2943 case SRC_TRY_WAIT:
2944 if (tcpm_port_is_source(port))
2945 tcpm_set_state(port, SRC_TRY_DEBOUNCE, 0);
2946 break;
2947 case SRC_TRY_DEBOUNCE:
2948 tcpm_set_state(port, SRC_TRY_WAIT, 0);
2949 break;
2950 case SNK_TRYWAIT_DEBOUNCE:
2951 if (tcpm_port_is_sink(port))
2952 tcpm_set_state(port, SNK_TRYWAIT_VBUS, 0);
2953 break;
2954 case SNK_TRYWAIT_VBUS:
2955 if (!tcpm_port_is_sink(port))
2956 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0);
2957 break;
2958 case SNK_TRYWAIT:
2959 /* Do nothing, waiting for tCCDebounce */
2960 break;
2961 case PR_SWAP_SNK_SRC_SINK_OFF:
2962 case PR_SWAP_SRC_SNK_TRANSITION_OFF:
2963 case PR_SWAP_SRC_SNK_SOURCE_OFF:
2964 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
2965 case PR_SWAP_SNK_SRC_SOURCE_ON:
2966 /*
2967 * CC state change is expected in PR_SWAP
2968 * Ignore it.
2969 */
2970 break;
2971
2972 case PORT_RESET:
2973 case PORT_RESET_WAIT_OFF:
2974 /*
2975 * State set back to default mode once the timer completes.
2976 * Ignore CC changes here.
2977 */
2978 break;
2979 default:
2980 /*
2981 * While acting as sink and auto vbus discharge is enabled, Allow disconnect
2982 * to be driven by vbus disconnect.
2983 */
2984 if (tcpm_port_is_disconnected(port))
2985 tcpm_set_state(port, unattached_state(port), 0);
2986 break;
2987 }
2988 }
2989
_tcpm_pd_vbus_on(struct tcpm_port * port)2990 static void _tcpm_pd_vbus_on(struct tcpm_port *port)
2991 {
2992 debug("%s: VBUS on\n", __func__);
2993 port->vbus_present = true;
2994 /*
2995 * When vbus_present is true i.e. Voltage at VBUS is greater than VSAFE5V implicitly
2996 * states that vbus is not at VSAFE0V, hence clear the vbus_vsafe0v flag here.
2997 */
2998 port->vbus_vsafe0v = false;
2999
3000 switch (port->state) {
3001 case SNK_TRANSITION_SINK_VBUS:
3002 port->explicit_contract = true;
3003 tcpm_set_state(port, SNK_READY, 0);
3004 break;
3005 case SNK_DISCOVERY:
3006 tcpm_set_state(port, SNK_DISCOVERY, 0);
3007 break;
3008 case SNK_DEBOUNCED:
3009 tcpm_set_state(port, SNK_ATTACHED, 0);
3010 break;
3011 case SNK_HARD_RESET_WAIT_VBUS:
3012 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, 0);
3013 break;
3014 case SRC_ATTACHED:
3015 tcpm_set_state(port, SRC_STARTUP, 0);
3016 break;
3017 case SRC_HARD_RESET_VBUS_ON:
3018 tcpm_set_state(port, SRC_STARTUP, 0);
3019 break;
3020
3021 case SNK_TRY:
3022 /* Do nothing, waiting for timeout */
3023 break;
3024 case SRC_TRYWAIT:
3025 /* Do nothing, Waiting for Rd to be detected */
3026 break;
3027 case SRC_TRYWAIT_DEBOUNCE:
3028 tcpm_set_state(port, SRC_TRYWAIT, 0);
3029 break;
3030 case SNK_TRY_WAIT_DEBOUNCE:
3031 /* Do nothing, waiting for PD_DEBOUNCE to do be done */
3032 break;
3033 case SNK_TRYWAIT:
3034 /* Do nothing, waiting for tCCDebounce */
3035 break;
3036 case SNK_TRYWAIT_VBUS:
3037 if (tcpm_port_is_sink(port))
3038 tcpm_set_state(port, SNK_ATTACHED, 0);
3039 break;
3040 case SNK_TRYWAIT_DEBOUNCE:
3041 /* Do nothing, waiting for Rp */
3042 break;
3043 case SRC_TRY_WAIT:
3044 case SRC_TRY_DEBOUNCE:
3045 /* Do nothing, waiting for sink detection */
3046 break;
3047
3048 case PORT_RESET:
3049 case PORT_RESET_WAIT_OFF:
3050 /*
3051 * State set back to default mode once the timer completes.
3052 * Ignore vbus changes here.
3053 */
3054 break;
3055
3056 default:
3057 break;
3058 }
3059 }
3060
_tcpm_pd_vbus_off(struct tcpm_port * port)3061 static void _tcpm_pd_vbus_off(struct tcpm_port *port)
3062 {
3063 debug("%s: VBUS off\n", __func__);
3064 port->vbus_present = false;
3065 port->vbus_never_low = false;
3066 switch (port->state) {
3067 case SNK_HARD_RESET_SINK_OFF:
3068 tcpm_set_state(port, SNK_HARD_RESET_WAIT_VBUS, 0);
3069 break;
3070 case HARD_RESET_SEND:
3071 break;
3072 case SNK_TRY:
3073 /* Do nothing, waiting for timeout */
3074 break;
3075 case SRC_TRYWAIT:
3076 /* Hand over to state machine if needed */
3077 if (tcpm_port_is_source(port))
3078 tcpm_set_state(port, SRC_TRYWAIT_DEBOUNCE, 0);
3079 break;
3080 case SNK_TRY_WAIT_DEBOUNCE:
3081 /* Do nothing, waiting for PD_DEBOUNCE to do be done */
3082 break;
3083 case SNK_TRYWAIT:
3084 case SNK_TRYWAIT_VBUS:
3085 case SNK_TRYWAIT_DEBOUNCE:
3086 break;
3087 case SNK_ATTACH_WAIT:
3088 port->debouncing = false;
3089 tcpm_set_state(port, SNK_UNATTACHED, 0);
3090 break;
3091
3092 case SNK_NEGOTIATE_CAPABILITIES:
3093 break;
3094
3095 case PR_SWAP_SRC_SNK_TRANSITION_OFF:
3096 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 0);
3097 break;
3098
3099 case PR_SWAP_SNK_SRC_SINK_OFF:
3100 /* Do nothing, expected */
3101 break;
3102
3103 case PR_SWAP_SNK_SRC_SOURCE_ON:
3104 /*
3105 * Do nothing when vbus off notification is received.
3106 * TCPM can wait for PD_T_NEWSRC in PR_SWAP_SNK_SRC_SOURCE_ON
3107 * for the vbus source to ramp up.
3108 */
3109 break;
3110
3111 case PORT_RESET_WAIT_OFF:
3112 tcpm_set_state(port, tcpm_default_state(port), 0);
3113 break;
3114
3115 case SRC_TRY_WAIT:
3116 case SRC_TRY_DEBOUNCE:
3117 /* Do nothing, waiting for sink detection */
3118 break;
3119
3120 case PORT_RESET:
3121 /*
3122 * State set back to default mode once the timer completes.
3123 * Ignore vbus changes here.
3124 */
3125 break;
3126
3127 default:
3128 if (port->pwr_role == TYPEC_SINK && port->attached)
3129 tcpm_set_state(port, SNK_UNATTACHED, 0);
3130 break;
3131 }
3132 }
3133
_tcpm_pd_hard_reset(struct tcpm_port * port)3134 static void _tcpm_pd_hard_reset(struct tcpm_port *port)
3135 {
3136 debug("Received hard reset\n");
3137 port->poll_event_cnt = 0;
3138
3139 /* If a hard reset message is received during the port reset process,
3140 * we should ignore it, that is, do not set port->state to HARD_RESET_START.
3141 */
3142 if (port->state == PORT_RESET || port->state == PORT_RESET_WAIT_OFF)
3143 return ;
3144
3145 /*
3146 * If we keep receiving hard reset requests, executing the hard reset
3147 * must have failed. Revert to error recovery if that happens.
3148 */
3149 tcpm_set_state(port,
3150 port->hard_reset_count < PD_N_HARD_RESET_COUNT ?
3151 HARD_RESET_START : ERROR_RECOVERY,
3152 0);
3153 }
3154
3155 #if 0
3156 static void tcpm_pd_event_handler(struct tcpm_port *port)
3157 {
3158 u32 events;
3159
3160 while (port->pd_events) {
3161 events = port->pd_events;
3162 port->pd_events = 0;
3163 if (events & TCPM_RESET_EVENT)
3164 _tcpm_pd_hard_reset(port);
3165 if (events & TCPM_VBUS_EVENT) {
3166 bool vbus;
3167
3168 vbus = port->tcpc->get_vbus(port->tcpc);
3169 if (vbus) {
3170 _tcpm_pd_vbus_on(port);
3171 } else {
3172 _tcpm_pd_vbus_off(port);
3173 /*
3174 * When TCPC does not support detecting vsafe0v voltage level,
3175 * treat vbus absent as vsafe0v. Else invoke is_vbus_vsafe0v
3176 * to see if vbus has discharge to VSAFE0V.
3177 */
3178 if (!port->tcpc->is_vbus_vsafe0v ||
3179 port->tcpc->is_vbus_vsafe0v(port->tcpc))
3180 _tcpm_pd_vbus_vsafe0v(port);
3181 }
3182 }
3183 if (events & TCPM_CC_EVENT) {
3184 enum typec_cc_status cc1, cc2;
3185
3186 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
3187 _tcpm_cc_change(port, cc1, cc2);
3188 }
3189 if (events & TCPM_FRS_EVENT) {
3190 if (port->state == SNK_READY) {
3191 int ret;
3192
3193 port->upcoming_state = FR_SWAP_SEND;
3194 ret = tcpm_ams_start(port, FAST_ROLE_SWAP);
3195 if (ret == -EAGAIN)
3196 port->upcoming_state = INVALID_STATE;
3197 } else {
3198 tcpm_log(port, "Discarding FRS_SIGNAL! Not in sink ready");
3199 }
3200 }
3201 if (events & TCPM_SOURCING_VBUS) {
3202 tcpm_log(port, "sourcing vbus");
3203 /*
3204 * In fast role swap case TCPC autonomously sources vbus. Set vbus_source
3205 * true as TCPM wouldn't have called tcpm_set_vbus.
3206 *
3207 * When vbus is sourced on the command on TCPM i.e. TCPM called
3208 * tcpm_set_vbus to source vbus, vbus_source would already be true.
3209 */
3210 port->vbus_source = true;
3211 _tcpm_pd_vbus_on(port);
3212 }
3213 }
3214 }
3215 #endif
3216
tcpm_cc_change(struct tcpm_port * port)3217 void tcpm_cc_change(struct tcpm_port *port)
3218 {
3219 enum typec_cc_status cc1, cc2;
3220
3221 port->poll_event_cnt = 0;
3222 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
3223 _tcpm_cc_change(port, cc1, cc2);
3224 }
3225 EXPORT_SYMBOL_GPL(tcpm_cc_change);
3226
tcpm_vbus_change(struct tcpm_port * port)3227 void tcpm_vbus_change(struct tcpm_port *port)
3228 {
3229 bool vbus;
3230
3231 port->poll_event_cnt = 0;
3232 vbus = port->tcpc->get_vbus(port->tcpc);
3233 if (vbus)
3234 _tcpm_pd_vbus_on(port);
3235 else
3236 _tcpm_pd_vbus_off(port);
3237 }
3238 EXPORT_SYMBOL_GPL(tcpm_vbus_change);
3239
tcpm_pd_hard_reset(struct tcpm_port * port)3240 void tcpm_pd_hard_reset(struct tcpm_port *port)
3241 {
3242 port->poll_event_cnt = 0;
3243 _tcpm_pd_hard_reset(port);
3244 }
3245 EXPORT_SYMBOL_GPL(tcpm_pd_hard_reset);
3246
tcpm_init(struct tcpm_port * port)3247 static void tcpm_init(struct tcpm_port *port)
3248 {
3249 enum typec_cc_status cc1, cc2;
3250
3251 port->tcpc->init(port->tcpc);
3252
3253 tcpm_reset_port(port);
3254
3255 /*
3256 * XXX
3257 * Should possibly wait for VBUS to settle if it was enabled locally
3258 * since tcpm_reset_port() will disable VBUS.
3259 */
3260 port->vbus_present = port->tcpc->get_vbus(port->tcpc);
3261 if (port->vbus_present)
3262 port->vbus_never_low = true;
3263
3264 /*
3265 * 1. When vbus_present is true, voltage on VBUS is already at VSAFE5V.
3266 * So implicitly vbus_vsafe0v = false.
3267 *
3268 * 2. When vbus_present is false and TCPC does NOT support querying
3269 * vsafe0v status, then, it's best to assume vbus is at VSAFE0V i.e.
3270 * vbus_vsafe0v is true.
3271 *
3272 * 3. When vbus_present is false and TCPC does support querying vsafe0v,
3273 * then, query tcpc for vsafe0v status.
3274 */
3275 if (port->vbus_present)
3276 port->vbus_vsafe0v = false;
3277 else if (!port->tcpc->is_vbus_vsafe0v)
3278 port->vbus_vsafe0v = true;
3279 else
3280 port->vbus_vsafe0v = port->tcpc->is_vbus_vsafe0v(port->tcpc);
3281
3282 tcpm_set_state(port, tcpm_default_state(port), 0);
3283
3284 if (port->tcpc->get_cc(port->tcpc, &cc1, &cc2) == 0)
3285 _tcpm_cc_change(port, cc1, cc2);
3286 }
3287
tcpm_tcpc_reset(struct tcpm_port * port)3288 void tcpm_tcpc_reset(struct tcpm_port *port)
3289 {
3290 mutex_lock(&port->lock);
3291 /* XXX: Maintain PD connection if possible? */
3292 tcpm_init(port);
3293 mutex_unlock(&port->lock);
3294 }
3295 EXPORT_SYMBOL_GPL(tcpm_tcpc_reset);
3296
tcpm_fw_get_caps(struct tcpm_port * port)3297 static int tcpm_fw_get_caps(struct tcpm_port *port)
3298 {
3299 const char *cap_str;
3300 ofnode node = port->tcpc->connector_node;
3301 int ret;
3302 u32 mw, frs_current;
3303
3304 #if 0
3305 /* USB data support is optional */
3306 cap_str = ofnode_read_string(node, "data-role");
3307 if (cap_str) {
3308 ret = typec_find_port_data_role(cap_str);
3309 if (ret < 0)
3310 return ret;
3311 port->typec_caps.data = ret;
3312 }
3313 #endif
3314
3315 cap_str = ofnode_read_string(node, "power-role");
3316 if (!cap_str) {
3317 return -EINVAL;
3318 } else {
3319 if (!strcmp("dual", cap_str))
3320 port->typec_caps.type = TYPEC_PORT_DRP;
3321 else if (!strcmp("source", cap_str))
3322 port->typec_caps.type = TYPEC_PORT_SRC;
3323 else if (!strcmp("sink", cap_str))
3324 port->typec_caps.type = TYPEC_PORT_SNK;
3325 else
3326 return EINVAL;
3327 }
3328
3329 port->port_type = port->typec_caps.type;
3330
3331 port->slow_charger_loop = ofnode_read_bool(node, "slow-charger-loop");
3332 if (port->port_type == TYPEC_PORT_SNK)
3333 goto sink;
3334
3335 /* Get source pdos */
3336 ret = ofnode_read_size(node, "source-pdos") / sizeof(u32);
3337 if (ret <= 0)
3338 return -EINVAL;
3339
3340 port->nr_src_pdo = min(ret, PDO_MAX_OBJECTS);
3341 ret = ofnode_read_u32_array(node, "source-pdos",
3342 port->src_pdo, port->nr_src_pdo);
3343 if (ret || tcpm_validate_caps(port, port->src_pdo,
3344 port->nr_src_pdo))
3345 return -EINVAL;
3346
3347 if (port->port_type == TYPEC_PORT_SRC)
3348 return 0;
3349
3350 /* Get the preferred power role for DRP */
3351 cap_str = ofnode_read_string(node, "try-power-role");
3352 if (!cap_str) {
3353 return -EINVAL;
3354 } else {
3355 if (!strcmp("sink", cap_str))
3356 port->typec_caps.prefer_role = TYPEC_SINK;
3357 else if (!strcmp("source", cap_str))
3358 port->typec_caps.prefer_role = TYPEC_SOURCE;
3359 else
3360 return -EINVAL;
3361 }
3362 if (port->typec_caps.prefer_role < 0)
3363 return -EINVAL;
3364 sink:
3365 /* Get sink pdos */
3366 ret = ofnode_read_size(node, "sink-pdos") / sizeof(u32);
3367 if (ret <= 0)
3368 return -EINVAL;
3369
3370 port->nr_snk_pdo = min(ret, PDO_MAX_OBJECTS);
3371 ret = ofnode_read_u32_array(node, "sink-pdos",
3372 port->snk_pdo, port->nr_snk_pdo);
3373 if (ret || tcpm_validate_caps(port, port->snk_pdo,
3374 port->nr_snk_pdo))
3375 return -EINVAL;
3376
3377 if (ofnode_read_u32_array(node, "op-sink-microwatt", &mw, 1))
3378 return -EINVAL;
3379 port->operating_snk_mw = mw / 1000;
3380
3381 port->self_powered = ofnode_read_bool(node, "self-powered");
3382
3383 /* FRS can only be supported by DRP ports */
3384 if (port->port_type == TYPEC_PORT_DRP) {
3385 ret = ofnode_read_u32_array(node, "new-source-frs-typec-current",
3386 &frs_current, 1);
3387 if (ret >= 0 && frs_current <= FRS_5V_3A)
3388 port->new_source_frs_current = frs_current;
3389 }
3390
3391 /* sink-vdos is optional */
3392 ret = ofnode_read_size(node, "sink-vdos") / sizeof(u32);
3393 if (ret < 0)
3394 ret = 0;
3395
3396 port->nr_snk_vdo = min(ret, VDO_MAX_OBJECTS);
3397 if (port->nr_snk_vdo) {
3398 ret = ofnode_read_u32_array(node, "sink-vdos",
3399 port->snk_vdo, port->nr_snk_vdo);
3400 if (ret)
3401 return ret;
3402 }
3403
3404 /* If sink-vdos is found, sink-vdos-v1 is expected for backward compatibility. */
3405 if (port->nr_snk_vdo) {
3406 ret = ofnode_read_size(node, "sink-vdos-v1") / sizeof(u32);
3407 if (ret < 0)
3408 return ret;
3409 else if (ret == 0)
3410 return -ENODATA;
3411
3412 port->nr_snk_vdo_v1 = min(ret, VDO_MAX_OBJECTS);
3413 ret = ofnode_read_u32_array(node, "sink-vdos-v1",
3414 port->snk_vdo_v1,
3415 port->nr_snk_vdo_v1);
3416 if (ret)
3417 return ret;
3418 }
3419
3420 return 0;
3421 }
3422
tcpm_port_init(struct udevice * dev,struct tcpc_dev * tcpc)3423 struct tcpm_port *tcpm_port_init(struct udevice *dev, struct tcpc_dev *tcpc)
3424 {
3425 struct tcpm_port *port;
3426 int err;
3427
3428 if (!dev || !tcpc ||
3429 !tcpc->get_vbus || !tcpc->set_cc || !tcpc->get_cc ||
3430 !tcpc->set_polarity || !tcpc->set_vconn || !tcpc->set_vbus ||
3431 !tcpc->set_pd_rx || !tcpc->set_roles || !tcpc->pd_transmit)
3432 return ERR_PTR(-EINVAL);
3433
3434 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
3435 if (!port)
3436 return ERR_PTR(-ENOMEM);
3437
3438 port->dev = dev;
3439 port->tcpc = tcpc;
3440
3441 err = tcpm_fw_get_caps(port);
3442 if (err < 0) {
3443 printf("%s: please check the dts config of %s node(%d)\n",
3444 __func__, dev_read_name(dev), err);
3445 return ERR_PTR(err);
3446 }
3447
3448 port->try_role = port->typec_caps.prefer_role;
3449
3450 port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */
3451 port->typec_caps.pd_revision = 0x0300; /* USB-PD spec release 3.0 */
3452 port->typec_caps.svdm_version = SVDM_VER_2_0;
3453 port->typec_caps.driver_data = port;
3454 port->typec_caps.orientation_aware = 1;
3455
3456 port->port_type = port->typec_caps.type;
3457
3458 tcpm_init(port);
3459
3460 printf("%s: init finished\n", dev_read_name(dev));
3461
3462 return port;
3463 }
3464 EXPORT_SYMBOL_GPL(tcpm_port_init);
3465
tcpm_poll_event(struct tcpm_port * port)3466 void tcpm_poll_event(struct tcpm_port *port)
3467 {
3468 if (!port->tcpc->get_vbus(port->tcpc))
3469 return ;
3470
3471 while (port->poll_event_cnt < TCPM_POLL_EVENT_TIME_OUT) {
3472 if (!port->wait_dr_swap_Message &&
3473 ((port->state == SNK_READY) ||
3474 (port->state == SRC_READY) ||
3475 (port->state == DEBUG_ACC_ATTACHED) ||
3476 (port->state == AUDIO_ACC_ATTACHED)))
3477 break;
3478
3479 port->tcpc->poll_event(port->tcpc);
3480 port->poll_event_cnt++;
3481 udelay(500);
3482 }
3483
3484 /*
3485 * At this time, call the callback function of the respective pd chip
3486 * to enter the low-power mode. In order to reduce the time spent on
3487 * the PD chip driver as much as possible, the tcpm framework does not
3488 * fully process the communication initiated by the device,so it should
3489 * be noted that we can disable the internal oscillator, etc., but do
3490 * not turn off the power of the transceiver module, otherwise the
3491 * self-powered Type-C device will initiate a Message(eg: self-powered
3492 * Type-C hub initiates a SINK capability request(PD_CTRL_GET_SINK_CAP))
3493 * and the pd chip cannot reply to GoodCRC, causing the self-powered Type-C
3494 * device to switch vbus to vSafe5v, or even turn off vbus.
3495 */
3496 if (port->tcpc->enter_low_power_mode) {
3497 if (port->tcpc->enter_low_power_mode(port->tcpc,
3498 port->attached,
3499 port->pd_capable))
3500 printf("failed to enter low power\n");
3501 else
3502 printf("PD chip enter low power mode\n");
3503 }
3504 }
3505 EXPORT_SYMBOL_GPL(tcpm_poll_event);
3506
tcpm_get_voltage(struct tcpm_port * port)3507 int tcpm_get_voltage(struct tcpm_port *port)
3508 {
3509 return port->supply_voltage * 1000;
3510 }
3511 EXPORT_SYMBOL_GPL(tcpm_get_voltage);
3512
tcpm_get_current(struct tcpm_port * port)3513 int tcpm_get_current(struct tcpm_port *port)
3514 {
3515 return port->current_limit * 1000;
3516 }
3517 EXPORT_SYMBOL_GPL(tcpm_get_voltage);
3518
tcpm_get_online(struct tcpm_port * port)3519 int tcpm_get_online(struct tcpm_port *port)
3520 {
3521 if (port->state == SNK_READY)
3522 return 1;
3523 else
3524 return 0;
3525 }
3526 EXPORT_SYMBOL_GPL(tcpm_get_online);
3527
tcpm_uninit_port(struct tcpm_port * port)3528 void tcpm_uninit_port(struct tcpm_port *port)
3529 {
3530 tcpm_reset_port(port);
3531 }
3532 EXPORT_SYMBOL_GPL(tcpm_unregister_port);
3533