Line data Source code
1 1 : /*
2 : * Copyright 2022 The Chromium OS Authors
3 : * SPDX-License-Identifier: Apache-2.0
4 : */
5 :
6 : /**
7 : * @file
8 : * @brief USBC Type-C Port Controller device APIs
9 : *
10 : * This file contains the USB Type-C Port Controller device APIs.
11 : * All Type-C Port Controller device drivers should implement the
12 : * APIs described in this file.
13 : */
14 :
15 : #ifndef ZEPHYR_INCLUDE_DRIVERS_USBC_USBC_TCPC_H_
16 : #define ZEPHYR_INCLUDE_DRIVERS_USBC_USBC_TCPC_H_
17 :
18 : /**
19 : * @brief USB Type-C Port Controller API
20 : * @defgroup usb_type_c_port_controller_api USB Type-C Port Controller API
21 : * @since 3.1
22 : * @version 0.1.0
23 : * @ingroup usb_type_c
24 : * @{
25 : */
26 :
27 : #include <zephyr/types.h>
28 : #include <zephyr/device.h>
29 : #include <errno.h>
30 :
31 : #include "usbc_tc.h"
32 : #include "usbc_pd.h"
33 :
34 : #ifdef __cplusplus
35 : extern "C" {
36 : #endif
37 :
38 : /**
39 : * @brief TCPC Alert bits
40 : */
41 1 : enum tcpc_alert {
42 : /** CC status changed */
43 : TCPC_ALERT_CC_STATUS,
44 : /** Power status changed */
45 : TCPC_ALERT_POWER_STATUS,
46 : /** Receive Buffer register changed */
47 : TCPC_ALERT_MSG_STATUS,
48 : /** Received Hard Reset message */
49 : TCPC_ALERT_HARD_RESET_RECEIVED,
50 : /** SOP* message transmission not successful */
51 : TCPC_ALERT_TRANSMIT_MSG_FAILED,
52 : /**
53 : * Reset or SOP* message transmission not sent
54 : * due to an incoming receive message
55 : */
56 : TCPC_ALERT_TRANSMIT_MSG_DISCARDED,
57 : /** Reset or SOP* message transmission successful */
58 : TCPC_ALERT_TRANSMIT_MSG_SUCCESS,
59 : /** A high-voltage alarm has occurred */
60 : TCPC_ALERT_VBUS_ALARM_HI,
61 : /** A low-voltage alarm has occurred */
62 : TCPC_ALERT_VBUS_ALARM_LO,
63 : /** A fault has occurred. Read the FAULT_STATUS register */
64 : TCPC_ALERT_FAULT_STATUS,
65 : /** TCPC RX buffer has overflowed */
66 : TCPC_ALERT_RX_BUFFER_OVERFLOW,
67 : /** The TCPC in Attached.SNK state has detected a sink disconnect */
68 : TCPC_ALERT_VBUS_SNK_DISCONNECT,
69 : /** Receive buffer register changed */
70 : TCPC_ALERT_BEGINNING_MSG_STATUS,
71 : /** Extended status changed */
72 : TCPC_ALERT_EXTENDED_STATUS,
73 : /**
74 : * An extended interrupt event has occurred. Read the alert_extended
75 : * register
76 : */
77 : TCPC_ALERT_EXTENDED,
78 : /** A vendor defined alert has been detected */
79 : TCPC_ALERT_VENDOR_DEFINED
80 : };
81 :
82 : /**
83 : * @brief TCPC Status register
84 : */
85 1 : enum tcpc_status_reg {
86 : /** The Altert register */
87 : TCPC_ALERT_STATUS,
88 : /** The CC Status register */
89 : TCPC_CC_STATUS,
90 : /** The Power Status register */
91 : TCPC_POWER_STATUS,
92 : /** The Fault Status register */
93 : TCPC_FAULT_STATUS,
94 : /** The Extended Status register */
95 : TCPC_EXTENDED_STATUS,
96 : /** The Extended Alert Status register */
97 : TCPC_EXTENDED_ALERT_STATUS,
98 : /** The Vendor Defined Status register */
99 : TCPC_VENDOR_DEFINED_STATUS
100 : };
101 :
102 : /**
103 : * @brief TCPC Chip Information
104 : */
105 1 : struct tcpc_chip_info {
106 : /** Vendor Id */
107 1 : uint16_t vendor_id;
108 : /** Product Id */
109 1 : uint16_t product_id;
110 : /** Device Id */
111 1 : uint16_t device_id;
112 : /** Firmware version number */
113 1 : uint64_t fw_version_number;
114 :
115 : union {
116 : /** Minimum Required firmware version string */
117 1 : uint8_t min_req_fw_version_string[8];
118 : /** Minimum Required firmware version number */
119 1 : uint64_t min_req_fw_version_number;
120 0 : };
121 : };
122 :
123 0 : typedef int (*tcpc_vconn_control_cb_t)(const struct device *dev, enum tc_cc_polarity pol,
124 : bool enable);
125 0 : typedef int (*tcpc_vconn_discharge_cb_t)(const struct device *dev, enum tc_cc_polarity pol,
126 : bool enable);
127 0 : typedef void (*tcpc_alert_handler_cb_t)(const struct device *dev, void *data,
128 : enum tcpc_alert alert);
129 :
130 0 : __subsystem struct tcpc_driver_api {
131 0 : int (*init)(const struct device *dev);
132 0 : int (*get_cc)(const struct device *dev, enum tc_cc_voltage_state *cc1,
133 : enum tc_cc_voltage_state *cc2);
134 0 : int (*select_rp_value)(const struct device *dev, enum tc_rp_value rp);
135 0 : int (*get_rp_value)(const struct device *dev, enum tc_rp_value *rp);
136 0 : int (*set_cc)(const struct device *dev, enum tc_cc_pull pull);
137 0 : void (*set_vconn_discharge_cb)(const struct device *dev, tcpc_vconn_discharge_cb_t cb);
138 0 : void (*set_vconn_cb)(const struct device *dev, tcpc_vconn_control_cb_t vconn_cb);
139 0 : int (*vconn_discharge)(const struct device *dev, bool enable);
140 0 : int (*set_vconn)(const struct device *dev, bool enable);
141 0 : int (*set_roles)(const struct device *dev, enum tc_power_role power_role,
142 : enum tc_data_role data_role);
143 0 : int (*get_rx_pending_msg)(const struct device *dev, struct pd_msg *msg);
144 0 : int (*set_rx_enable)(const struct device *dev, bool enable);
145 0 : int (*set_cc_polarity)(const struct device *dev, enum tc_cc_polarity polarity);
146 0 : int (*transmit_data)(const struct device *dev, struct pd_msg *msg);
147 0 : int (*dump_std_reg)(const struct device *dev);
148 0 : void (*alert_handler_cb)(const struct device *dev, void *data, enum tcpc_alert alert);
149 0 : int (*get_status_register)(const struct device *dev, enum tcpc_status_reg reg,
150 : uint32_t *status);
151 0 : int (*clear_status_register)(const struct device *dev, enum tcpc_status_reg reg,
152 : uint32_t mask);
153 0 : int (*mask_status_register)(const struct device *dev, enum tcpc_status_reg reg,
154 : uint32_t mask);
155 0 : int (*set_debug_accessory)(const struct device *dev, bool enable);
156 0 : int (*set_debug_detach)(const struct device *dev);
157 0 : int (*set_drp_toggle)(const struct device *dev, bool enable);
158 0 : int (*get_snk_ctrl)(const struct device *dev);
159 0 : int (*set_snk_ctrl)(const struct device *dev, bool enable);
160 0 : int (*get_src_ctrl)(const struct device *dev);
161 0 : int (*set_src_ctrl)(const struct device *dev, bool enable);
162 0 : int (*get_chip_info)(const struct device *dev, struct tcpc_chip_info *chip_info);
163 0 : int (*set_low_power_mode)(const struct device *dev, bool enable);
164 0 : int (*sop_prime_enable)(const struct device *dev, bool enable);
165 0 : int (*set_bist_test_mode)(const struct device *dev, bool enable);
166 0 : int (*set_alert_handler_cb)(const struct device *dev, tcpc_alert_handler_cb_t handler,
167 : void *data);
168 : };
169 :
170 : /**
171 : * @brief Returns whether the sink has detected a Rp resistor on the other side
172 : */
173 1 : static inline int tcpc_is_cc_rp(enum tc_cc_voltage_state cc)
174 : {
175 : return (cc == TC_CC_VOLT_RP_DEF) || (cc == TC_CC_VOLT_RP_1A5) || (cc == TC_CC_VOLT_RP_3A0);
176 : }
177 :
178 : /**
179 : * @brief Returns true if both CC lines are completely open
180 : */
181 1 : static inline int tcpc_is_cc_open(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
182 : {
183 : return (cc1 < TC_CC_VOLT_RD) && (cc2 < TC_CC_VOLT_RD);
184 : }
185 :
186 : /**
187 : * @brief Returns true if we detect the port partner is a snk debug accessory
188 : */
189 1 : static inline int tcpc_is_cc_snk_dbg_acc(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
190 : {
191 : return cc1 == TC_CC_VOLT_RD && cc2 == TC_CC_VOLT_RD;
192 : }
193 :
194 : /**
195 : * @brief Returns true if we detect the port partner is a src debug accessory
196 : */
197 1 : static inline int tcpc_is_cc_src_dbg_acc(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
198 : {
199 : return tcpc_is_cc_rp(cc1) && tcpc_is_cc_rp(cc2);
200 : }
201 :
202 : /**
203 : * @brief Returns true if the port partner is an audio accessory
204 : */
205 1 : static inline int tcpc_is_cc_audio_acc(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
206 : {
207 : return cc1 == TC_CC_VOLT_RA && cc2 == TC_CC_VOLT_RA;
208 : }
209 :
210 : /**
211 : * @brief Returns true if the port partner is presenting at least one Rd
212 : */
213 1 : static inline int tcpc_is_cc_at_least_one_rd(enum tc_cc_voltage_state cc1,
214 : enum tc_cc_voltage_state cc2)
215 : {
216 : return cc1 == TC_CC_VOLT_RD || cc2 == TC_CC_VOLT_RD;
217 : }
218 :
219 : /**
220 : * @brief Returns true if the port partner is presenting Rd on only one CC line
221 : */
222 1 : static inline int tcpc_is_cc_only_one_rd(enum tc_cc_voltage_state cc1, enum tc_cc_voltage_state cc2)
223 : {
224 : return tcpc_is_cc_at_least_one_rd(cc1, cc2) && cc1 != cc2;
225 : }
226 :
227 : /**
228 : * @brief Initializes the TCPC
229 : *
230 : * @param dev Runtime device structure
231 : *
232 : * @retval 0 on success
233 : * @retval -EIO on failure
234 : * @retval -EAGAIN if initialization should be postponed
235 : */
236 1 : static inline int tcpc_init(const struct device *dev)
237 : {
238 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
239 :
240 : __ASSERT(api->init != NULL, "Callback pointer should not be NULL");
241 :
242 : return api->init(dev);
243 : }
244 :
245 : /**
246 : * @brief Reads the status of the CC lines
247 : *
248 : * @param dev Runtime device structure
249 : * @param cc1 A pointer where the CC1 status is written
250 : * @param cc2 A pointer where the CC2 status is written
251 : *
252 : * @retval 0 on success
253 : * @retval -EIO on failure
254 : * @retval -ENOSYS if not implemented
255 : */
256 1 : static inline int tcpc_get_cc(const struct device *dev, enum tc_cc_voltage_state *cc1,
257 : enum tc_cc_voltage_state *cc2)
258 : {
259 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
260 :
261 : if (api->get_cc == NULL) {
262 : return -ENOSYS;
263 : }
264 :
265 : return api->get_cc(dev, cc1, cc2);
266 : }
267 :
268 : /**
269 : * @brief Sets the value of CC pull up resistor used when operating as a Source
270 : *
271 : * @param dev Runtime device structure
272 : * @param rp Value of the Pull-Up Resistor.
273 : *
274 : * @retval 0 on success
275 : * @retval -ENOSYS
276 : * @retval -EIO on failure
277 : */
278 1 : static inline int tcpc_select_rp_value(const struct device *dev, enum tc_rp_value rp)
279 : {
280 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
281 :
282 : if (api->select_rp_value == NULL) {
283 : return -ENOSYS;
284 : }
285 :
286 : return api->select_rp_value(dev, rp);
287 : }
288 :
289 : /**
290 : * @brief Gets the value of the CC pull up resistor used when operating as a Source
291 : *
292 : * @param dev Runtime device structure
293 : * @param rp pointer where the value of the Pull-Up Resistor is stored
294 : *
295 : * @retval 0 on success
296 : * @retval -ENOSYS
297 : * @retval -EIO on failure
298 : */
299 1 : static inline int tcpc_get_rp_value(const struct device *dev, enum tc_rp_value *rp)
300 : {
301 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
302 :
303 : if (api->get_rp_value == NULL) {
304 : return -ENOSYS;
305 : }
306 :
307 : return api->get_rp_value(dev, rp);
308 : }
309 :
310 : /**
311 : * @brief Sets the CC pull resistor and sets the role as either Source or Sink
312 : *
313 : * @param dev Runtime device structure
314 : * @param pull The pull resistor to set
315 : *
316 : * @retval 0 on success
317 : * @retval -EIO on failure
318 : */
319 1 : static inline int tcpc_set_cc(const struct device *dev, enum tc_cc_pull pull)
320 : {
321 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
322 :
323 : __ASSERT(api->set_cc != NULL, "Callback pointer should not be NULL");
324 :
325 : return api->set_cc(dev, pull);
326 : }
327 :
328 : /**
329 : * @brief Sets a callback that can enable or disable VCONN if the TCPC is
330 : * unable to or the system is configured in a way that does not use
331 : * the VCONN control capabilities of the TCPC
332 : *
333 : * The callback is called in the tcpc_set_vconn function if vconn_cb isn't NULL
334 : *
335 : * @param dev Runtime device structure
336 : * @param vconn_cb pointer to the callback function that controls vconn
337 : */
338 1 : static inline void tcpc_set_vconn_cb(const struct device *dev, tcpc_vconn_control_cb_t vconn_cb)
339 : {
340 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
341 :
342 : __ASSERT(api->set_vconn_cb != NULL, "Callback pointer should not be NULL");
343 :
344 : api->set_vconn_cb(dev, vconn_cb);
345 : }
346 :
347 : /**
348 : * @brief Sets a callback that can enable or discharge VCONN if the TCPC is
349 : * unable to or the system is configured in a way that does not use
350 : * the VCONN control capabilities of the TCPC
351 : *
352 : * The callback is called in the tcpc_vconn_discharge function if cb isn't NULL
353 : *
354 : * @param dev Runtime device structure
355 : * @param cb pointer to the callback function that discharges vconn
356 : */
357 1 : static inline void tcpc_set_vconn_discharge_cb(const struct device *dev,
358 : tcpc_vconn_discharge_cb_t cb)
359 : {
360 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
361 :
362 : __ASSERT(api->set_vconn_discharge_cb != NULL, "Callback pointer should not be NULL");
363 :
364 : api->set_vconn_discharge_cb(dev, cb);
365 : }
366 :
367 : /**
368 : * @brief Discharges VCONN
369 : *
370 : * This function uses the TCPC to discharge VCONN if possible or calls the
371 : * callback function set by tcpc_set_vconn_cb
372 : *
373 : * @param dev Runtime device structure
374 : * @param enable VCONN discharge is enabled when true, it's disabled
375 : *
376 : * @retval 0 on success
377 : * @retval -EIO on failure
378 : * @retval -ENOSYS if not implemented
379 : */
380 1 : static inline int tcpc_vconn_discharge(const struct device *dev, bool enable)
381 : {
382 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
383 :
384 : if (api->vconn_discharge == NULL) {
385 : return -ENOSYS;
386 : }
387 :
388 : return api->vconn_discharge(dev, enable);
389 : }
390 :
391 : /**
392 : * @brief Enables or disables VCONN
393 : *
394 : * This function uses the TCPC to measure VCONN if possible or calls the
395 : * callback function set by tcpc_set_vconn_cb
396 : *
397 : * @param dev Runtime device structure
398 : * @param enable VCONN is enabled when true, it's disabled
399 : *
400 : * @retval 0 on success
401 : * @retval -EIO on failure
402 : * @retval -ENOSYS if not implemented
403 : */
404 1 : static inline int tcpc_set_vconn(const struct device *dev, bool enable)
405 : {
406 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
407 :
408 : if (api->set_vconn == NULL) {
409 : return -ENOSYS;
410 : }
411 :
412 : return api->set_vconn(dev, enable);
413 : }
414 :
415 : /**
416 : * @brief Sets the Power and Data Role of the PD message header
417 : *
418 : * This function only needs to be called once per data / power role change
419 : *
420 : * @param dev Runtime device structure
421 : * @param power_role current power role
422 : * @param data_role current data role
423 : *
424 : * @retval 0 on success
425 : * @retval -EIO on failure
426 : * @retval -ENOSYS if not implemented
427 : */
428 1 : static inline int tcpc_set_roles(const struct device *dev, enum tc_power_role power_role,
429 : enum tc_data_role data_role)
430 : {
431 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
432 :
433 : if (api->set_roles == NULL) {
434 : return -ENOSYS;
435 : }
436 :
437 : return api->set_roles(dev, power_role, data_role);
438 : }
439 :
440 : /**
441 : * @brief Retrieves the Power Delivery message from the TCPC.
442 : * If buf is NULL, then only the status is returned, where 0 means there is a message pending and
443 : * -ENODATA means there is no pending message.
444 : *
445 : * @param dev Runtime device structure
446 : * @param buf pointer where the pd_buf pointer is written, NULL if only checking the status
447 : *
448 : * @retval Greater or equal to 0 is the number of bytes received if buf parameter is provided
449 : * @retval 0 if there is a message pending and buf parameter is NULL
450 : * @retval -EIO on failure
451 : * @retval -ENODATA if no message is pending
452 : */
453 1 : static inline int tcpc_get_rx_pending_msg(const struct device *dev, struct pd_msg *buf)
454 : {
455 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
456 :
457 : __ASSERT(api->get_rx_pending_msg != NULL, "Callback pointer should not be NULL");
458 :
459 : return api->get_rx_pending_msg(dev, buf);
460 : }
461 :
462 : /**
463 : * @brief Enables the reception of SOP* message types
464 : *
465 : * @param dev Runtime device structure
466 : * @param enable Enable Power Delivery when true, else it's
467 : * disabled
468 : *
469 : * @retval 0 on success
470 : * @retval -EIO on failure
471 : * @retval -ENOSYS if not implemented
472 : */
473 1 : static inline int tcpc_set_rx_enable(const struct device *dev, bool enable)
474 : {
475 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
476 :
477 : if (api->set_rx_enable == NULL) {
478 : return -ENOSYS;
479 : }
480 :
481 : return api->set_rx_enable(dev, enable);
482 : }
483 :
484 : /**
485 : * @brief Sets the polarity of the CC lines
486 : *
487 : * @param dev Runtime device structure
488 : * @param polarity Polarity of the cc line
489 : *
490 : * @retval 0 on success
491 : * @retval -EIO on failure
492 : */
493 1 : static inline int tcpc_set_cc_polarity(const struct device *dev, enum tc_cc_polarity polarity)
494 : {
495 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
496 :
497 : __ASSERT(api->set_cc_polarity != NULL, "Callback pointer should not be NULL");
498 :
499 : return api->set_cc_polarity(dev, polarity);
500 : }
501 :
502 : /**
503 : * @brief Transmits a Power Delivery message
504 : *
505 : * @param dev Runtime device structure
506 : * @param msg Power Delivery message to transmit
507 : *
508 : * @retval 0 on success
509 : * @retval -EIO on failure
510 : * @retval -ENOSYS if not implemented
511 : */
512 1 : static inline int tcpc_transmit_data(const struct device *dev, struct pd_msg *msg)
513 : {
514 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
515 :
516 : if (api->transmit_data == NULL) {
517 : return -ENOSYS;
518 : }
519 :
520 : return api->transmit_data(dev, msg);
521 : }
522 :
523 : /**
524 : * @brief Dump a set of TCPC registers
525 : *
526 : * @param dev Runtime device structure
527 : *
528 : * @retval 0 on success
529 : * @retval -EIO on failure
530 : * @retval -ENOSYS if not implemented
531 : */
532 1 : static inline int tcpc_dump_std_reg(const struct device *dev)
533 : {
534 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
535 :
536 : if (api->dump_std_reg == NULL) {
537 : return -ENOSYS;
538 : }
539 :
540 : return api->dump_std_reg(dev);
541 : }
542 :
543 : /**
544 : * @brief Sets the alert function that's called when an interrupt is triggered
545 : * due to an alert bit
546 : *
547 : * Calling this function enables the particular alert bit
548 : *
549 : * @param dev Runtime device structure
550 : * @param handler The callback function called when the bit is set
551 : * @param data user data passed to the callback
552 : *
553 : * @retval 0 on success
554 : * @retval -EINVAL on failure
555 : */
556 1 : static inline int tcpc_set_alert_handler_cb(const struct device *dev,
557 : tcpc_alert_handler_cb_t handler, void *data)
558 : {
559 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
560 :
561 : __ASSERT(api->set_alert_handler_cb != NULL, "Callback pointer should not be NULL");
562 :
563 : return api->set_alert_handler_cb(dev, handler, data);
564 : }
565 :
566 : /**
567 : * @brief Gets a status register
568 : *
569 : * @param dev Runtime device structure
570 : * @param reg The status register to read
571 : * @param status Pointer where the status is stored
572 : *
573 : * @retval 0 on success
574 : * @retval -EIO on failure
575 : * @retval -ENOSYS if not implemented
576 : */
577 1 : static inline int tcpc_get_status_register(const struct device *dev, enum tcpc_status_reg reg,
578 : uint32_t *status)
579 : {
580 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
581 :
582 : if (api->get_status_register == NULL) {
583 : return -ENOSYS;
584 : }
585 :
586 : return api->get_status_register(dev, reg, status);
587 : }
588 :
589 : /**
590 : * @brief Clears a TCPC status register
591 : *
592 : * @param dev Runtime device structure
593 : * @param reg The status register to read
594 : * @param mask A bit mask of the status register to clear.
595 : * A status bit is cleared when it's set to 1.
596 : *
597 : * @retval 0 on success
598 : * @retval -EIO on failure
599 : * @retval -ENOSYS if not implemented
600 : */
601 1 : static inline int tcpc_clear_status_register(const struct device *dev, enum tcpc_status_reg reg,
602 : uint32_t mask)
603 : {
604 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
605 :
606 : if (api->clear_status_register == NULL) {
607 : return -ENOSYS;
608 : }
609 :
610 : return api->clear_status_register(dev, reg, mask);
611 : }
612 :
613 : /**
614 : * @brief Sets the mask of a TCPC status register
615 : *
616 : * @param dev Runtime device structure
617 : * @param reg The status register to read
618 : * @param mask A bit mask of the status register to mask.
619 : * The status bit is masked if it's 0, else it's unmasked.
620 : *
621 : * @retval 0 on success
622 : * @retval -EIO on failure
623 : * @retval -ENOSYS if not implemented
624 : */
625 1 : static inline int tcpc_mask_status_register(const struct device *dev, enum tcpc_status_reg reg,
626 : uint32_t mask)
627 : {
628 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
629 :
630 : if (api->mask_status_register == NULL) {
631 : return -ENOSYS;
632 : }
633 :
634 : return api->mask_status_register(dev, reg, mask);
635 : }
636 :
637 : /**
638 : * @brief Manual control of TCPC DebugAccessory control
639 : *
640 : * @param dev Runtime device structure
641 : * @param enable Enable Debug Accessory when true, else it's disabled
642 : *
643 : * @retval 0 on success
644 : * @retval -EIO on failure
645 : * @retval -ENOSYS if not implemented
646 : */
647 1 : static inline int tcpc_set_debug_accessory(const struct device *dev, bool enable)
648 : {
649 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
650 :
651 : if (api->set_debug_accessory == NULL) {
652 : return -ENOSYS;
653 : }
654 :
655 : return api->set_debug_accessory(dev, enable);
656 : }
657 :
658 : /**
659 : * @brief Detach from a debug connection
660 : *
661 : * @param dev Runtime device structure
662 : *
663 : * @retval 0 on success
664 : * @retval -EIO on failure
665 : * @retval -ENOSYS if not implemented
666 : */
667 1 : static inline int tcpc_set_debug_detach(const struct device *dev)
668 : {
669 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
670 :
671 : if (api->set_debug_detach == NULL) {
672 : return -ENOSYS;
673 : }
674 :
675 : return api->set_debug_detach(dev);
676 : }
677 :
678 : /**
679 : * @brief Enable TCPC auto dual role toggle
680 : *
681 : * @param dev Runtime device structure
682 : * @param enable Auto dual role toggle is active when true, else it's disabled
683 : *
684 : * @retval 0 on success
685 : * @retval -EIO on failure
686 : * @retval -ENOSYS if not implemented
687 : */
688 1 : static inline int tcpc_set_drp_toggle(const struct device *dev, bool enable)
689 : {
690 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
691 :
692 : if (api->set_drp_toggle == NULL) {
693 : return -ENOSYS;
694 : }
695 :
696 : return api->set_drp_toggle(dev, enable);
697 : }
698 :
699 : /**
700 : * @brief Queries the current sinking state of the TCPC
701 : *
702 : * @param dev Runtime device structure
703 : *
704 : * @retval true if sinking power
705 : * @retval false if not sinking power
706 : * @retval -ENOSYS if not implemented
707 : */
708 1 : static inline int tcpc_get_snk_ctrl(const struct device *dev)
709 : {
710 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
711 :
712 : if (api->get_snk_ctrl == NULL) {
713 : return -ENOSYS;
714 : }
715 :
716 : return api->get_snk_ctrl(dev);
717 : }
718 :
719 : /**
720 : * @brief Set the VBUS sinking state of the TCPC
721 : *
722 : * @param dev Runtime device structure
723 : * @param enable True if sinking should be enabled, false if disabled
724 : * @retval 0 on success
725 : * @retval -ENOSYS if not implemented
726 : */
727 1 : static inline int tcpc_set_snk_ctrl(const struct device *dev, bool enable)
728 : {
729 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
730 :
731 : if (api->set_snk_ctrl == NULL) {
732 : return -ENOSYS;
733 : }
734 :
735 : return api->set_snk_ctrl(dev, enable);
736 : }
737 :
738 : /**
739 : * @brief Queries the current sourcing state of the TCPC
740 : *
741 : * @param dev Runtime device structure
742 : *
743 : * @retval true if sourcing power
744 : * @retval false if not sourcing power
745 : * @retval -ENOSYS if not implemented
746 : */
747 1 : static inline int tcpc_get_src_ctrl(const struct device *dev)
748 : {
749 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
750 :
751 : if (api->get_src_ctrl == NULL) {
752 : return -ENOSYS;
753 : }
754 :
755 : return api->get_src_ctrl(dev);
756 : }
757 :
758 : /**
759 : * @brief Set the VBUS sourcing state of the TCPC
760 : *
761 : * @param dev Runtime device structure
762 : * @param enable True if sourcing should be enabled, false if disabled
763 : * @retval 0 on success
764 : * @retval -ENOSYS if not implemented
765 : */
766 1 : static inline int tcpc_set_src_ctrl(const struct device *dev, bool enable)
767 : {
768 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
769 :
770 : if (api->set_src_ctrl == NULL) {
771 : return -ENOSYS;
772 : }
773 :
774 : return api->set_src_ctrl(dev, enable);
775 : }
776 :
777 : /**
778 : * @brief Controls the BIST Mode of the TCPC. It disables RX alerts while the
779 : * mode is active.
780 : *
781 : * @param dev Runtime device structure
782 : * @param enable The TCPC enters BIST TEST Mode when true
783 : *
784 : * @retval 0 on success
785 : * @retval -EIO on failure
786 : * @retval -ENOSYS if not implemented
787 : */
788 1 : static inline int tcpc_set_bist_test_mode(const struct device *dev, bool enable)
789 : {
790 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
791 :
792 : if (api->set_bist_test_mode == NULL) {
793 : return -ENOSYS;
794 : }
795 :
796 : return api->set_bist_test_mode(dev, enable);
797 : }
798 :
799 : /**
800 : * @brief Gets the TCPC firmware version
801 : *
802 : * @param dev Runtime device structure
803 : * @param chip_info Pointer to TCPC chip info where the version is stored
804 : *
805 : * @retval 0 on success
806 : * @retval -EIO on failure
807 : * @retval -ENOSYS if not implemented
808 : */
809 1 : static inline int tcpc_get_chip_info(const struct device *dev, struct tcpc_chip_info *chip_info)
810 : {
811 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
812 :
813 : if (api->get_chip_info == NULL) {
814 : return -ENOSYS;
815 : }
816 :
817 : return api->get_chip_info(dev, chip_info);
818 : }
819 :
820 : /**
821 : * @brief Instructs the TCPC to enter or exit low power mode
822 : *
823 : * @param dev Runtime device structure
824 : * @param enable The TCPC enters low power mode when true, else it exits it
825 : *
826 : * @retval 0 on success
827 : * @retval -EIO on failure
828 : * @retval -ENOSYS if not implemented
829 : */
830 1 : static inline int tcpc_set_low_power_mode(const struct device *dev, bool enable)
831 : {
832 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
833 :
834 : if (api->set_low_power_mode == NULL) {
835 : return -ENOSYS;
836 : }
837 :
838 : return api->set_low_power_mode(dev, enable);
839 : }
840 :
841 : /**
842 : * @brief Enables the reception of SOP Prime and optionally SOP Double Prime messages
843 : *
844 : * @param dev Runtime device structure
845 : * @param enable Can receive SOP Prime messages and SOP Double Prime messages when true,
846 : * else it can not
847 : *
848 : * @retval 0 on success
849 : * @retval -EIO on failure
850 : * @retval -ENOSYS if not implemented
851 : */
852 1 : static inline int tcpc_sop_prime_enable(const struct device *dev, bool enable)
853 : {
854 : const struct tcpc_driver_api *api = (const struct tcpc_driver_api *)dev->api;
855 :
856 : if (api->sop_prime_enable == NULL) {
857 : return -ENOSYS;
858 : }
859 :
860 : return api->sop_prime_enable(dev, enable);
861 : }
862 :
863 : /**
864 : * @}
865 : */
866 :
867 : #ifdef __cplusplus
868 : }
869 : #endif
870 :
871 : #endif /* ZEPHYR_INCLUDE_DRIVERS_USBC_USBC_TCPC_H_ */
|
