1 /*
2 * Copyright (c) 2024 Jianxiong Gu <jianxiong.gu@outlook.com>
3 * SPDX-License-Identifier: Apache-2.0
4 */
5
6 #include <zephyr/device.h>
7 #include <zephyr/logging/log.h>
8 #include <zephyr/drivers/gpio.h>
9 #include <zephyr/drivers/i2c.h>
10 #include <zephyr/drivers/usb_c/tcpci_priv.h>
11 #include <zephyr/usb_c/usbc.h>
12 #include <zephyr/usb_c/tcpci.h>
13 #include <zephyr/shell/shell.h>
14 #include "rt1715.h"
15
16 #define DT_DRV_COMPAT richtek_rt1715
17 LOG_MODULE_REGISTER(rt1715, CONFIG_USBC_LOG_LEVEL);
18
19 /** Data structure for device instances */
20 struct rt1715_data {
21 /** Device structure used to retrieve it in k_work functions */
22 const struct device *const dev;
23 /** Delayable work item for chip initialization */
24 struct k_work_delayable init_dwork;
25 /** Initialization retries counter */
26 int init_retries;
27 /** Boolean value if chip was successfully initialized */
28 bool initialized;
29
30 /** Callback for alert GPIO */
31 struct gpio_callback alert_cb;
32 /** Work item for alert handling out of interrupt context */
33 struct k_work alert_work;
34
35 /** Boolean value if there is a message pending */
36 bool msg_pending;
37 /** One-slot Rx FIFO */
38 struct pd_msg rx_msg;
39
40 /** Alert handler set by USB-C stack */
41 tcpc_alert_handler_cb_t alert_handler;
42 /** Alert handler data set by USB-C stack */
43 void *alert_handler_data;
44
45 /** VCONN discharge callback set by USB-C stack */
46 tcpc_vconn_discharge_cb_t vconn_discharge_cb;
47 /** VCONN discharge callback data set by USB-C stack */
48 tcpc_vconn_control_cb_t vconn_cb;
49 /** Polarity of CC lines for PD and VCONN */
50 enum tc_cc_polarity cc_polarity;
51
52 /** Boolean value if there was a change on the CC lines since last check */
53 bool cc_changed;
54 /** State of CC1 line */
55 enum tc_cc_voltage_state cc1;
56 /** State of CC2 line */
57 enum tc_cc_voltage_state cc2;
58
59 /* Flag to receive or ignore SOP Prime messages */
60 bool rx_sop_prime_enable;
61 };
62
63 /** Configuration structure for device instances */
64 struct rt1715_cfg {
65 /** I2C bus and address used for communication */
66 const struct i2c_dt_spec bus;
67 /** GPIO specification for alert pin */
68 const struct gpio_dt_spec alert_gpio;
69 /** GPIO specification for VCONN power control pin */
70 const struct gpio_dt_spec vconn_ctrl_gpio;
71 /** GPIO specification for VCONN discharge control pin */
72 const struct gpio_dt_spec vconn_disc_gpio;
73 /** Maximum number of packet retransmissions done by TCPC */
74 const uint8_t transmit_retries;
75 };
76
tcpci_init_alert_mask(const struct device * dev)77 static int tcpci_init_alert_mask(const struct device *dev)
78 {
79 const struct rt1715_cfg *cfg = dev->config;
80
81 uint16_t mask = TCPC_REG_ALERT_TX_COMPLETE | TCPC_REG_ALERT_RX_STATUS |
82 TCPC_REG_ALERT_RX_HARD_RST | TCPC_REG_ALERT_CC_STATUS |
83 TCPC_REG_ALERT_POWER_STATUS | TCPC_REG_ALERT_FAULT |
84 TCPC_REG_ALERT_RX_BUF_OVF;
85
86 return tcpci_tcpm_mask_status_register(&cfg->bus, TCPC_ALERT_STATUS, mask);
87 }
88
rt1715_tcpc_init(const struct device * dev)89 static int rt1715_tcpc_init(const struct device *dev)
90 {
91 struct rt1715_data *data = dev->data;
92
93 if (!data->initialized) {
94 if (data->init_retries > CONFIG_USBC_TCPC_RT1715_INIT_RETRIES) {
95 LOG_ERR("TCPC was not initialized correctly");
96 return -EIO;
97 }
98
99 return -EAGAIN;
100 }
101
102 data->rx_sop_prime_enable = false;
103 data->msg_pending = false;
104 memset(&data->rx_msg, 0x00, sizeof(data->rx_msg));
105
106 LOG_INF("RT1715 TCPC initialized");
107 return 0;
108 }
109
rt1715_tcpc_get_cc(const struct device * dev,enum tc_cc_voltage_state * cc1,enum tc_cc_voltage_state * cc2)110 static int rt1715_tcpc_get_cc(const struct device *dev, enum tc_cc_voltage_state *cc1,
111 enum tc_cc_voltage_state *cc2)
112 {
113 const struct rt1715_cfg *cfg = dev->config;
114 struct rt1715_data *data = dev->data;
115 int ret;
116
117 if (!data->initialized) {
118 return -EIO;
119 }
120
121 if (IS_ENABLED(CONFIG_USBC_CSM_SINK_ONLY) && !data->cc_changed) {
122 *cc1 = data->cc1;
123 *cc2 = data->cc2;
124
125 return 0;
126 }
127
128 data->cc_changed = false;
129
130 ret = tcpci_tcpm_get_cc(&cfg->bus, cc1, cc2);
131
132 if (IS_ENABLED(CONFIG_USBC_CSM_SINK_ONLY) || *cc1 != data->cc1 || *cc2 != data->cc2) {
133 LOG_DBG("CC changed values: %d->%d, %d->%d", data->cc1, *cc1, data->cc2, *cc2);
134 data->cc1 = *cc1;
135 data->cc2 = *cc2;
136 }
137
138 return ret;
139 }
140
rt1715_tcpc_select_rp_value(const struct device * dev,enum tc_rp_value rp)141 static int rt1715_tcpc_select_rp_value(const struct device *dev, enum tc_rp_value rp)
142 {
143 const struct rt1715_cfg *cfg = dev->config;
144 struct rt1715_data *data = dev->data;
145
146 data->cc_changed = true;
147
148 return tcpci_tcpm_select_rp_value(&cfg->bus, rp);
149 }
150
rt1715_tcpc_get_rp_value(const struct device * dev,enum tc_rp_value * rp)151 static int rt1715_tcpc_get_rp_value(const struct device *dev, enum tc_rp_value *rp)
152 {
153 const struct rt1715_cfg *cfg = dev->config;
154
155 return tcpci_tcpm_get_rp_value(&cfg->bus, rp);
156 }
157
rt1715_tcpc_set_cc(const struct device * dev,enum tc_cc_pull pull)158 static int rt1715_tcpc_set_cc(const struct device *dev, enum tc_cc_pull pull)
159 {
160 const struct rt1715_cfg *cfg = dev->config;
161 struct rt1715_data *data = dev->data;
162
163 if (!data->initialized) {
164 return -EIO;
165 }
166
167 data->cc_changed = true;
168
169 return tcpci_tcpm_set_cc(&cfg->bus, pull);
170 }
171
rt1715_tcpc_set_vconn_discharge_cb(const struct device * dev,tcpc_vconn_discharge_cb_t cb)172 static void rt1715_tcpc_set_vconn_discharge_cb(const struct device *dev,
173 tcpc_vconn_discharge_cb_t cb)
174 {
175 struct rt1715_data *data = dev->data;
176
177 data->vconn_discharge_cb = cb;
178 }
179
rt1715_tcpc_set_vconn_cb(const struct device * dev,tcpc_vconn_control_cb_t vconn_cb)180 static void rt1715_tcpc_set_vconn_cb(const struct device *dev, tcpc_vconn_control_cb_t vconn_cb)
181 {
182 struct rt1715_data *data = dev->data;
183
184 data->vconn_cb = vconn_cb;
185 }
186
rt1715_tcpc_vconn_discharge(const struct device * dev,bool enable)187 static int rt1715_tcpc_vconn_discharge(const struct device *dev, bool enable)
188 {
189 const struct rt1715_cfg *cfg = dev->config;
190
191 if (cfg->vconn_disc_gpio.port == NULL) {
192 /* RT1715 does not have built-in VCONN discharge path */
193 LOG_ERR("VCONN discharge GPIO is not defined");
194 return -EIO;
195 }
196
197 return gpio_pin_set_dt(&cfg->vconn_disc_gpio, enable);
198 }
199
rt1715_tcpc_set_vconn(const struct device * dev,bool enable)200 static int rt1715_tcpc_set_vconn(const struct device *dev, bool enable)
201 {
202 const struct rt1715_cfg *cfg = dev->config;
203 struct rt1715_data *data = dev->data;
204 int ret;
205
206 if (!data->initialized) {
207 return -EIO;
208 }
209
210 if (enable == true && cfg->vconn_ctrl_gpio.port != NULL) {
211 /* Enable external VCONN power supply */
212 gpio_pin_set_dt(&cfg->vconn_ctrl_gpio, true);
213 }
214
215 data->cc_changed = true;
216 ret = tcpci_tcpm_set_vconn(&cfg->bus, enable);
217
218 if (ret != 0) {
219 return ret;
220 }
221
222 if (enable == false && cfg->vconn_ctrl_gpio.port != NULL) {
223 /* Disable external VCONN power supply */
224 gpio_pin_set_dt(&cfg->vconn_ctrl_gpio, false);
225 }
226
227 if (data->vconn_cb != NULL) {
228 ret = data->vconn_cb(dev, data->cc_polarity, enable);
229 }
230
231 return ret;
232 }
233
rt1715_tcpc_set_roles(const struct device * dev,enum tc_power_role power_role,enum tc_data_role data_role)234 static int rt1715_tcpc_set_roles(const struct device *dev, enum tc_power_role power_role,
235 enum tc_data_role data_role)
236 {
237 const struct rt1715_cfg *cfg = dev->config;
238
239 return tcpci_tcpm_set_roles(&cfg->bus, PD_REV30, power_role, data_role);
240 }
241
rt1715_tcpc_get_rx_pending_msg(const struct device * dev,struct pd_msg * msg)242 static int rt1715_tcpc_get_rx_pending_msg(const struct device *dev, struct pd_msg *msg)
243 {
244 struct rt1715_data *data = dev->data;
245
246 /* Rx message pending? */
247 if (!data->msg_pending) {
248 return -ENODATA;
249 }
250
251 /* Query status only? */
252 if (msg == NULL) {
253 return 0;
254 }
255
256 /* Dequeue Rx FIFO */
257 *msg = data->rx_msg;
258 data->msg_pending = false;
259
260 /* Indicate Rx message returned */
261 return 1;
262 }
263
rt1715_tcpc_rx_fifo_enqueue(const struct device * dev)264 static int rt1715_tcpc_rx_fifo_enqueue(const struct device *dev)
265 {
266 const struct rt1715_cfg *const cfg = dev->config;
267 struct rt1715_data *data = dev->data;
268 uint8_t buf[4];
269 uint8_t rxbcnt;
270 uint8_t rxftype;
271 uint16_t rxhead;
272 uint8_t rx_data_size;
273 struct pd_msg *msg = &data->rx_msg;
274 int ret = 0;
275
276 ret = i2c_burst_read_dt(&cfg->bus, TCPC_REG_RX_BUFFER, buf, sizeof(buf));
277 if (ret != 0) {
278 return ret;
279 }
280
281 rxbcnt = buf[0];
282 rxftype = buf[1];
283 rxhead = (buf[3] << 8) | buf[2];
284
285 /* rxbcnt = 1 (frame type) + 2 (Message Header) + Rx data byte count */
286 if (rxbcnt < 3) {
287 LOG_ERR("Invalid RXBCNT: %d", rxbcnt);
288 return -EIO;
289 }
290 rx_data_size = rxbcnt - 3;
291
292 /* Not support Unchunked Extended Message exceeding PD_CONVERT_PD_HEADER_COUNT_TO_BYTES */
293 if (rx_data_size > (PD_MAX_EXTENDED_MSG_LEGACY_LEN + 2)) {
294 LOG_ERR("Not support Unchunked Extended Message exceeding "
295 "PD_CONVERT_PD_HEADER_COUNT_TO_BYTES: %d",
296 rx_data_size);
297 return -EIO;
298 }
299
300 /* Rx frame type */
301 msg->type = rxftype;
302
303 /* Rx header */
304 msg->header.raw_value = (uint16_t)rxhead;
305
306 /* Rx data size */
307 msg->len = rx_data_size;
308
309 /* Rx data */
310 if (rx_data_size > 0) {
311 ret = i2c_burst_read_dt(&cfg->bus, TCPC_REG_RX_BUFFER + 4, msg->data, rx_data_size);
312 if (ret) {
313 LOG_ERR("Failed to read Rx data: %d", ret);
314 }
315 }
316
317 return ret;
318 }
319
rt1715_tcpc_set_rx_enable(const struct device * dev,bool enable)320 static int rt1715_tcpc_set_rx_enable(const struct device *dev, bool enable)
321 {
322 const struct rt1715_cfg *cfg = dev->config;
323 struct rt1715_data *data = dev->data;
324
325 if (!enable) {
326 return tcpci_tcpm_set_rx_type(&cfg->bus, 0);
327 }
328
329 if (data->rx_sop_prime_enable) {
330 return tcpci_tcpm_set_rx_type(&cfg->bus,
331 TCPC_REG_RX_DETECT_SOP_SOPP_SOPPP_HRST_MASK);
332 } else {
333 return tcpci_tcpm_set_rx_type(&cfg->bus, TCPC_REG_RX_DETECT_SOP_HRST_MASK);
334 }
335 }
336
rt1715_tcpc_set_cc_polarity(const struct device * dev,enum tc_cc_polarity polarity)337 static int rt1715_tcpc_set_cc_polarity(const struct device *dev, enum tc_cc_polarity polarity)
338 {
339 const struct rt1715_cfg *cfg = dev->config;
340 struct rt1715_data *data = dev->data;
341 int ret;
342
343 if (!data->initialized) {
344 return -EIO;
345 }
346
347 ret = tcpci_tcpm_set_cc_polarity(&cfg->bus, polarity);
348
349 if (ret != 0) {
350 return ret;
351 }
352
353 data->cc_changed = true;
354 data->cc_polarity = polarity;
355 return 0;
356 }
357
rt1715_tcpc_transmit_data(const struct device * dev,struct pd_msg * msg)358 static int rt1715_tcpc_transmit_data(const struct device *dev, struct pd_msg *msg)
359 {
360 const struct rt1715_cfg *cfg = dev->config;
361
362 return tcpci_tcpm_transmit_data(&cfg->bus, msg, cfg->transmit_retries);
363 }
364
rt1715_tcpc_dump_std_reg(const struct device * dev)365 static int rt1715_tcpc_dump_std_reg(const struct device *dev)
366 {
367 const struct rt1715_cfg *cfg = dev->config;
368
369 LOG_INF("TCPC %s:%s registers:", cfg->bus.bus->name, dev->name);
370
371 return tcpci_tcpm_dump_std_reg(&cfg->bus);
372 }
373
rt1715_tcpc_alert_handler_cb(const struct device * dev,void * data,enum tcpc_alert alert)374 void rt1715_tcpc_alert_handler_cb(const struct device *dev, void *data, enum tcpc_alert alert)
375 {
376 }
377
rt1715_tcpc_get_status_register(const struct device * dev,enum tcpc_status_reg reg,uint32_t * status)378 static int rt1715_tcpc_get_status_register(const struct device *dev, enum tcpc_status_reg reg,
379 uint32_t *status)
380 {
381 const struct rt1715_cfg *cfg = dev->config;
382
383 if (reg == TCPC_VENDOR_DEFINED_STATUS) {
384 return tcpci_read_reg8(&cfg->bus, RT1715_REG_RT_INT, (uint8_t *)status);
385 }
386
387 return tcpci_tcpm_get_status_register(&cfg->bus, reg, (uint16_t *)status);
388 }
389
rt1715_tcpc_clear_status_register(const struct device * dev,enum tcpc_status_reg reg,uint32_t mask)390 static int rt1715_tcpc_clear_status_register(const struct device *dev, enum tcpc_status_reg reg,
391 uint32_t mask)
392 {
393 const struct rt1715_cfg *cfg = dev->config;
394
395 if (reg == TCPC_VENDOR_DEFINED_STATUS) {
396 return tcpci_write_reg8(&cfg->bus, RT1715_REG_RT_INT, (uint8_t)mask);
397 }
398
399 return tcpci_tcpm_clear_status_register(&cfg->bus, reg, (uint16_t)mask);
400 }
401
rt1715_tcpc_mask_status_register(const struct device * dev,enum tcpc_status_reg reg,uint32_t mask)402 static int rt1715_tcpc_mask_status_register(const struct device *dev, enum tcpc_status_reg reg,
403 uint32_t mask)
404 {
405 const struct rt1715_cfg *cfg = dev->config;
406
407 if (reg == TCPC_VENDOR_DEFINED_STATUS) {
408 return tcpci_write_reg8(&cfg->bus, RT1715_REG_RT_INT_MASK, (uint8_t)mask);
409 }
410
411 return tcpci_tcpm_mask_status_register(&cfg->bus, reg, (uint16_t)mask);
412 }
413
rt1715_tcpc_set_drp_toggle(const struct device * dev,bool enable)414 static int rt1715_tcpc_set_drp_toggle(const struct device *dev, bool enable)
415 {
416 const struct rt1715_cfg *cfg = dev->config;
417
418 return tcpci_tcpm_set_drp_toggle(&cfg->bus, enable);
419 }
420
rt1715_tcpc_get_chip_info(const struct device * dev,struct tcpc_chip_info * chip_info)421 static int rt1715_tcpc_get_chip_info(const struct device *dev, struct tcpc_chip_info *chip_info)
422 {
423 const struct rt1715_cfg *cfg = dev->config;
424
425 if (chip_info == NULL) {
426 return -EIO;
427 }
428
429 chip_info->fw_version_number = 0;
430 chip_info->min_req_fw_version_number = 0;
431
432 return tcpci_tcpm_get_chip_info(&cfg->bus, chip_info);
433 }
434
rt1715_tcpc_set_low_power_mode(const struct device * dev,bool enable)435 static int rt1715_tcpc_set_low_power_mode(const struct device *dev, bool enable)
436 {
437 const struct rt1715_cfg *cfg = dev->config;
438 int ret;
439
440 ret = tcpci_write_reg8(&cfg->bus, RT1715_REG_SYS_WAKEUP, RT1715_REG_SYS_WAKEUP_EN);
441 if (ret < 0) {
442 return ret;
443 }
444
445 return tcpci_update_reg8(&cfg->bus, RT1715_REG_SYS_CTRL_1,
446 RT1715_REG_SYS_CTRL_1_BMCIO_LP_EN,
447 enable ? RT1715_REG_SYS_CTRL_1_BMCIO_LP_EN : 0);
448 }
449
rt1715_tcpc_sop_prime_enable(const struct device * dev,bool enable)450 static int rt1715_tcpc_sop_prime_enable(const struct device *dev, bool enable)
451 {
452 struct rt1715_data *data = dev->data;
453
454 data->rx_sop_prime_enable = enable;
455
456 return 0;
457 }
458
rt1715_tcpc_set_bist_test_mode(const struct device * dev,bool enable)459 static int rt1715_tcpc_set_bist_test_mode(const struct device *dev, bool enable)
460 {
461 const struct rt1715_cfg *cfg = dev->config;
462
463 return tcpci_tcpm_set_bist_test_mode(&cfg->bus, enable);
464 }
465
rt1715_tcpc_set_alert_handler_cb(const struct device * dev,tcpc_alert_handler_cb_t handler,void * handler_data)466 static int rt1715_tcpc_set_alert_handler_cb(const struct device *dev,
467 tcpc_alert_handler_cb_t handler, void *handler_data)
468 {
469 struct rt1715_data *data = dev->data;
470
471 if (data->alert_handler == handler && data->alert_handler_data == handler_data) {
472 return 0;
473 }
474
475 data->alert_handler = handler;
476 data->alert_handler_data = handler_data;
477
478 return 0;
479 }
480
481 static DEVICE_API(tcpc, rt1715_driver_api) = {
482 .init = rt1715_tcpc_init,
483 .get_cc = rt1715_tcpc_get_cc,
484 .select_rp_value = rt1715_tcpc_select_rp_value,
485 .get_rp_value = rt1715_tcpc_get_rp_value,
486 .set_cc = rt1715_tcpc_set_cc,
487 .set_vconn_discharge_cb = rt1715_tcpc_set_vconn_discharge_cb,
488 .set_vconn_cb = rt1715_tcpc_set_vconn_cb,
489 .vconn_discharge = rt1715_tcpc_vconn_discharge,
490 .set_vconn = rt1715_tcpc_set_vconn,
491 .set_roles = rt1715_tcpc_set_roles,
492 .get_rx_pending_msg = rt1715_tcpc_get_rx_pending_msg,
493 .set_rx_enable = rt1715_tcpc_set_rx_enable,
494 .set_cc_polarity = rt1715_tcpc_set_cc_polarity,
495 .transmit_data = rt1715_tcpc_transmit_data,
496 .dump_std_reg = rt1715_tcpc_dump_std_reg,
497 .alert_handler_cb = rt1715_tcpc_alert_handler_cb,
498 .get_status_register = rt1715_tcpc_get_status_register,
499 .clear_status_register = rt1715_tcpc_clear_status_register,
500 .mask_status_register = rt1715_tcpc_mask_status_register,
501 .set_drp_toggle = rt1715_tcpc_set_drp_toggle,
502 .get_chip_info = rt1715_tcpc_get_chip_info,
503 .set_low_power_mode = rt1715_tcpc_set_low_power_mode,
504 .sop_prime_enable = rt1715_tcpc_sop_prime_enable,
505 .set_bist_test_mode = rt1715_tcpc_set_bist_test_mode,
506 .set_alert_handler_cb = rt1715_tcpc_set_alert_handler_cb,
507 };
508
rt1715_alert_cb(const struct device * port,struct gpio_callback * cb,gpio_port_pins_t pins)509 void rt1715_alert_cb(const struct device *port, struct gpio_callback *cb, gpio_port_pins_t pins)
510 {
511 struct rt1715_data *data = CONTAINER_OF(cb, struct rt1715_data, alert_cb);
512
513 k_work_submit(&data->alert_work);
514 }
515
rt1715_alert_work_cb(struct k_work * work)516 void rt1715_alert_work_cb(struct k_work *work)
517 {
518 struct rt1715_data *data = CONTAINER_OF(work, struct rt1715_data, alert_work);
519 const struct device *dev = data->dev;
520 const struct rt1715_cfg *cfg = dev->config;
521 uint16_t alert_reg = 0;
522 uint16_t clear_flags = 0;
523
524 if (!data->initialized) {
525 return;
526 }
527
528 tcpci_tcpm_get_status_register(&cfg->bus, TCPC_ALERT_STATUS, &alert_reg);
529
530 while (alert_reg != 0) {
531 enum tcpc_alert alert_type = tcpci_alert_reg_to_enum(alert_reg);
532
533 if (alert_type == TCPC_ALERT_HARD_RESET_RECEIVED) {
534 LOG_DBG("hard rst received");
535 tcpci_init_alert_mask(dev);
536 data->cc_changed = true;
537 } else if (alert_type == TCPC_ALERT_FAULT_STATUS) {
538 uint8_t fault;
539
540 tcpci_tcpm_get_status_register(&cfg->bus, TCPC_FAULT_STATUS,
541 (uint16_t *)&fault);
542 tcpci_tcpm_clear_status_register(&cfg->bus, TCPC_FAULT_STATUS,
543 (uint16_t)fault);
544
545 LOG_DBG("fault: %02x", fault);
546 } else if (alert_type == TCPC_ALERT_POWER_STATUS) {
547 uint8_t pwr_status;
548
549 tcpci_tcpm_get_status_register(&cfg->bus, TCPC_POWER_STATUS,
550 (uint16_t *)&pwr_status);
551
552 LOG_DBG("power status: %02x", pwr_status);
553 } else if (alert_type == TCPC_ALERT_MSG_STATUS) {
554 LOG_DBG("MSG pending");
555
556 if (rt1715_tcpc_rx_fifo_enqueue(dev) == 0) {
557 data->msg_pending = true;
558 }
559 } else if (alert_type == TCPC_ALERT_CC_STATUS) {
560 data->cc_changed = true;
561 }
562
563 if (data->alert_handler != NULL) {
564 data->alert_handler(dev, data->alert_handler_data, alert_type);
565 }
566
567 clear_flags |= BIT(alert_type);
568 alert_reg &= ~BIT(alert_type);
569 }
570
571 tcpci_tcpm_clear_status_register(&cfg->bus, TCPC_ALERT_STATUS, clear_flags);
572 tcpci_tcpm_get_status_register(&cfg->bus, TCPC_ALERT_STATUS, &alert_reg);
573
574 /* If alert_reg is not 0 or the interrupt signal is still active */
575 if ((alert_reg != 0) || gpio_pin_get_dt(&cfg->alert_gpio)) {
576 k_work_submit(work);
577 }
578 }
579
rt1715_init_work_cb(struct k_work * work)580 void rt1715_init_work_cb(struct k_work *work)
581 {
582 struct k_work_delayable *dwork = k_work_delayable_from_work(work);
583 struct rt1715_data *data = CONTAINER_OF(dwork, struct rt1715_data, init_dwork);
584
585 const struct rt1715_cfg *cfg = data->dev->config;
586 uint8_t power_reg, lp_reg = 0;
587 struct tcpc_chip_info chip_info;
588 int ret;
589
590 LOG_INF("Initializing RT1715 chip: %s", data->dev->name);
591
592 ret = tcpci_tcpm_get_status_register(&cfg->bus, TCPC_POWER_STATUS, (uint16_t *)&power_reg);
593 if (ret != 0 || (power_reg & TCPC_REG_POWER_STATUS_UNINIT)) {
594 data->init_retries++;
595
596 if (data->init_retries > CONFIG_USBC_TCPC_RT1715_INIT_RETRIES) {
597 LOG_ERR("Chip didn't respond");
598 return;
599 }
600
601 LOG_DBG("Postpone chip initialization %d", data->init_retries);
602 k_work_schedule(&data->init_dwork, K_MSEC(CONFIG_USBC_TCPC_RT1715_INIT_DELAY));
603
604 return;
605 }
606
607 rt1715_tcpc_get_chip_info(data->dev, &chip_info);
608 LOG_INF("Initialized chip is: %04x:%04x:%04x", chip_info.vendor_id, chip_info.product_id,
609 chip_info.device_id);
610
611 /* Exit shutdown mode & Enable ext messages */
612 lp_reg = RT1715_REG_LP_CTRL_SHUTDOWN_OFF | RT1715_REG_LP_CTRL_ENEXTMSG;
613 /* Disable idle mode */
614 lp_reg &= ~RT1715_REG_LP_CTRL_AUTOIDLE_EN;
615 tcpci_write_reg8(&cfg->bus, RT1715_REG_LP_CTRL, lp_reg);
616
617 /* Initialize alert interrupt */
618 gpio_pin_configure_dt(&cfg->alert_gpio, GPIO_INPUT);
619
620 gpio_init_callback(&data->alert_cb, rt1715_alert_cb, BIT(cfg->alert_gpio.pin));
621
622 ret = gpio_add_callback(cfg->alert_gpio.port, &data->alert_cb);
623
624 if (ret != 0) {
625 LOG_ERR("Failed to add alert callback: %d", ret);
626 return;
627 }
628
629 gpio_pin_interrupt_configure_dt(&cfg->alert_gpio, GPIO_INT_EDGE_TO_ACTIVE);
630
631 tcpci_init_alert_mask(data->dev);
632 data->initialized = true;
633
634 /* Disable the vconn and open CC lines to reinitialize the communication with partner */
635 rt1715_tcpc_set_vconn(data->dev, false);
636 rt1715_tcpc_set_cc(data->dev, TC_CC_OPEN);
637
638 /* Check and clear any alert set after initialization */
639 k_work_submit(&data->alert_work);
640 }
641
rt1715_dev_init(const struct device * dev)642 static int rt1715_dev_init(const struct device *dev)
643 {
644 const struct rt1715_cfg *cfg = dev->config;
645 struct rt1715_data *data = dev->data;
646 int ret;
647
648 if (!device_is_ready(cfg->bus.bus)) {
649 return -EIO;
650 }
651
652 /* Resets the chip */
653 ret = tcpci_write_reg8(&cfg->bus, RT1715_REG_SW_RST, RT1715_REG_SW_RST_EN);
654 if (ret != 0) {
655 LOG_ERR("Failed to reset chip: %d", ret);
656 return ret;
657 }
658
659 k_work_init_delayable(&data->init_dwork, rt1715_init_work_cb);
660 k_work_schedule(&data->init_dwork, K_MSEC(CONFIG_USBC_TCPC_RT1715_INIT_DELAY));
661
662 k_work_init(&data->alert_work, rt1715_alert_work_cb);
663
664 return 0;
665 }
666
667 #define RT1715_DRIVER_DATA_INIT(node) \
668 { \
669 .dev = DEVICE_DT_GET(node), \
670 .init_retries = 0, \
671 .cc_changed = true, \
672 }
673
674 #define VCONN_CTRL_GPIO(node) \
675 .vconn_ctrl_gpio = COND_CODE_1(DT_INST_NODE_HAS_PROP(node, vconn_ctrl_gpios), \
676 (GPIO_DT_SPEC_INST_GET(node, vconn_ctrl_gpios)), ({0}))
677
678 #define VCONN_DISC_GPIO(node) \
679 .vconn_disc_gpio = COND_CODE_1(DT_INST_NODE_HAS_PROP(node, vconn_disc_gpios), \
680 (GPIO_DT_SPEC_INST_GET(node, vconn_disc_gpios)), ({0}))
681
682 #define RT1715_DRIVER_CFG_INIT(node) \
683 { \
684 .bus = I2C_DT_SPEC_GET(node), \
685 .alert_gpio = GPIO_DT_SPEC_GET(node, irq_gpios), \
686 .transmit_retries = DT_PROP(node, transmit_retries), \
687 VCONN_CTRL_GPIO(node), \
688 VCONN_DISC_GPIO(node), \
689 }
690
691 #define RT1715_DRIVER_INIT(inst) \
692 static struct rt1715_data drv_data_rt1715##inst = \
693 RT1715_DRIVER_DATA_INIT(DT_DRV_INST(inst)); \
694 static struct rt1715_cfg drv_cfg_rt1715##inst = RT1715_DRIVER_CFG_INIT(DT_DRV_INST(inst)); \
695 DEVICE_DT_INST_DEFINE(inst, &rt1715_dev_init, NULL, &drv_data_rt1715##inst, \
696 &drv_cfg_rt1715##inst, POST_KERNEL, CONFIG_USBC_TCPC_INIT_PRIORITY, \
697 &rt1715_driver_api);
698
699 DT_INST_FOREACH_STATUS_OKAY(RT1715_DRIVER_INIT)
700
