1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2015-2017 Google, Inc
4 *
5 * USB Type-C Port Controller Interface.
6 */
7
8 #include <dm.h>
9 #include <i2c.h>
10 #include <asm/gpio.h>
11 #include <power/power_delivery/pd.h>
12 #include <power/power_delivery/tcpm.h>
13 #include <power/power_delivery/typec.h>
14 #include <power/power_delivery/power_delivery.h>
15
16 #include "tcpci.h"
17
18 #define PD_RETRY_COUNT 3
19
20 #define tcpc_presenting_cc1_rd(reg) \
21 (!(TCPC_ROLE_CTRL_DRP & (reg)) && \
22 (((reg) & (TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT)) == \
23 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT)))
24 #define tcpc_presenting_cc2_rd(reg) \
25 (!(TCPC_ROLE_CTRL_DRP & (reg)) && \
26 (((reg) & (TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT)) == \
27 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT)))
28
29 struct tcpci {
30 struct udevice *dev;
31
32 struct tcpm_port *port;
33
34 bool controls_vbus;
35 bool gpio_cc_int_present;
36
37 struct tcpc_dev tcpc;
38 struct tcpci_data *data;
39 struct gpio_desc gpio_cc_int;
40 };
41
42 struct tcpci_chip {
43 struct udevice *udev;
44 struct tcpci *tcpci;
45 struct tcpci_data data;
46 };
47
tcpc_to_tcpci(struct tcpc_dev * tcpc)48 static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc)
49 {
50 return container_of(tcpc, struct tcpci, tcpc);
51 }
52
tcpci_read16(struct tcpci * tcpci,unsigned int reg,u16 * val)53 static int tcpci_read16(struct tcpci *tcpci, unsigned int reg, u16 *val)
54 {
55 int ret = 0;
56 u8 buffer[2];
57
58 ret = dm_i2c_read(tcpci->dev, reg, buffer, 2);
59 if (ret) {
60 printf("%s: cannot read %02x, ret=%d\n",
61 __func__, reg, ret);
62 return ret;
63 }
64
65 *val = ((buffer[1] << 8) & 0xFF00) | (buffer[0] & 0xFF);
66
67 return ret;
68 }
69
tcpci_block_read(struct tcpci * tcpci,unsigned int reg,u8 * data,u8 length)70 static int tcpci_block_read(struct tcpci *tcpci, unsigned int reg,
71 u8 *data, u8 length)
72 {
73 int ret = 0;
74
75 ret = dm_i2c_read(tcpci->dev, reg, data, length);
76 if (ret)
77 printf("%s: cannot block read 0x%02x, len=%d, ret=%d\n",
78 __func__, reg, length, ret);
79
80 return ret;
81 }
82
tcpci_write16(struct tcpci * tcpci,unsigned int reg,u16 val)83 static int tcpci_write16(struct tcpci *tcpci, unsigned int reg, u16 val)
84 {
85 int ret = 0;
86 u8 buffer[2];
87
88 buffer[0] = val & 0xFF;
89 buffer[1] = (val >> 8) & 0xFF;
90 ret = dm_i2c_write(tcpci->dev, reg, buffer, 2);
91 if (ret)
92 printf("%s: cannot write 0x%02x, ret=%d\n",
93 __func__, reg, ret);
94
95 return ret;
96 }
97
tcpci_block_write(struct tcpci * tcpci,unsigned int reg,u8 * data,u8 length)98 static int tcpci_block_write(struct tcpci *tcpci, unsigned int reg,
99 u8 *data, u8 length)
100 {
101 int ret = 0;
102
103 ret = dm_i2c_write(tcpci->dev, reg, data, length);
104 if (ret)
105 printf("%s: cannot block write 0x%02x, len=%d, ret=%d\n",
106 __func__, reg, length, ret);
107
108 return ret;
109 }
110
tcpci_set_cc(struct tcpc_dev * tcpc,enum typec_cc_status cc)111 static int tcpci_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc)
112 {
113 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
114 unsigned int reg;
115 int ret;
116
117 switch (cc) {
118 case TYPEC_CC_RA:
119 reg = (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC1_SHIFT) |
120 (TCPC_ROLE_CTRL_CC_RA << TCPC_ROLE_CTRL_CC2_SHIFT);
121 break;
122 case TYPEC_CC_RD:
123 reg = (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) |
124 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT);
125 break;
126 case TYPEC_CC_RP_DEF:
127 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
128 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) |
129 (TCPC_ROLE_CTRL_RP_VAL_DEF <<
130 TCPC_ROLE_CTRL_RP_VAL_SHIFT);
131 break;
132 case TYPEC_CC_RP_1_5:
133 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
134 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) |
135 (TCPC_ROLE_CTRL_RP_VAL_1_5 <<
136 TCPC_ROLE_CTRL_RP_VAL_SHIFT);
137 break;
138 case TYPEC_CC_RP_3_0:
139 reg = (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
140 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT) |
141 (TCPC_ROLE_CTRL_RP_VAL_3_0 <<
142 TCPC_ROLE_CTRL_RP_VAL_SHIFT);
143 break;
144 case TYPEC_CC_OPEN:
145 default:
146 reg = (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT) |
147 (TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT);
148 break;
149 }
150
151 ret = dm_i2c_reg_write(tcpci->dev, TCPC_ROLE_CTRL, reg);
152 if (ret)
153 return ret;
154
155 return 0;
156 }
157
tcpci_start_toggling(struct tcpc_dev * tcpc,enum typec_port_type port_type,enum typec_cc_status cc)158 static int tcpci_start_toggling(struct tcpc_dev *tcpc,
159 enum typec_port_type port_type,
160 enum typec_cc_status cc)
161 {
162 int ret;
163 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
164 unsigned int reg = TCPC_ROLE_CTRL_DRP;
165
166 if (port_type != TYPEC_PORT_DRP)
167 return -EOPNOTSUPP;
168
169 /* Handle vendor drp toggling */
170 if (tcpci->data->start_drp_toggling) {
171 ret = tcpci->data->start_drp_toggling(tcpci, tcpci->data, cc);
172 if (ret < 0)
173 return ret;
174 }
175
176 switch (cc) {
177 default:
178 case TYPEC_CC_RP_DEF:
179 reg |= (TCPC_ROLE_CTRL_RP_VAL_DEF <<
180 TCPC_ROLE_CTRL_RP_VAL_SHIFT);
181 break;
182 case TYPEC_CC_RP_1_5:
183 reg |= (TCPC_ROLE_CTRL_RP_VAL_1_5 <<
184 TCPC_ROLE_CTRL_RP_VAL_SHIFT);
185 break;
186 case TYPEC_CC_RP_3_0:
187 reg |= (TCPC_ROLE_CTRL_RP_VAL_3_0 <<
188 TCPC_ROLE_CTRL_RP_VAL_SHIFT);
189 break;
190 }
191
192 if (cc == TYPEC_CC_RD)
193 reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) |
194 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT);
195 else
196 reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
197 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT);
198 ret = dm_i2c_reg_write(tcpci->dev, TCPC_ROLE_CTRL, reg);
199 if (ret < 0)
200 return ret;
201 return dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND,
202 TCPC_CMD_LOOK4CONNECTION);
203 }
204
tcpci_to_typec_cc(unsigned int cc,bool sink)205 static enum typec_cc_status tcpci_to_typec_cc(unsigned int cc, bool sink)
206 {
207 switch (cc) {
208 case 0x1:
209 return sink ? TYPEC_CC_RP_DEF : TYPEC_CC_RA;
210 case 0x2:
211 return sink ? TYPEC_CC_RP_1_5 : TYPEC_CC_RD;
212 case 0x3:
213 if (sink)
214 return TYPEC_CC_RP_3_0;
215 /* fall through */
216 case 0x0:
217 default:
218 return TYPEC_CC_OPEN;
219 }
220 }
221
tcpci_get_cc(struct tcpc_dev * tcpc,enum typec_cc_status * cc1,enum typec_cc_status * cc2)222 static int tcpci_get_cc(struct tcpc_dev *tcpc,
223 enum typec_cc_status *cc1, enum typec_cc_status *cc2)
224 {
225 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
226 unsigned int reg, role_control;
227
228 role_control = dm_i2c_reg_read(tcpci->dev, TCPC_ROLE_CTRL);
229 if (role_control < 0)
230 return role_control;
231
232 reg = dm_i2c_reg_read(tcpci->dev, TCPC_CC_STATUS);
233 if (reg < 0)
234 return reg;
235
236 *cc1 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC1_SHIFT) &
237 TCPC_CC_STATUS_CC1_MASK,
238 reg & TCPC_CC_STATUS_TERM ||
239 tcpc_presenting_cc1_rd(role_control));
240 *cc2 = tcpci_to_typec_cc((reg >> TCPC_CC_STATUS_CC2_SHIFT) &
241 TCPC_CC_STATUS_CC2_MASK,
242 reg & TCPC_CC_STATUS_TERM ||
243 tcpc_presenting_cc2_rd(role_control));
244
245 return 0;
246 }
247
tcpci_set_polarity(struct tcpc_dev * tcpc,enum typec_cc_polarity polarity)248 static int tcpci_set_polarity(struct tcpc_dev *tcpc,
249 enum typec_cc_polarity polarity)
250 {
251 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
252 unsigned int reg;
253 int ret;
254 enum typec_cc_status cc1, cc2;
255
256 /* Obtain Rp setting from role control */
257 reg = dm_i2c_reg_read(tcpci->dev, TCPC_ROLE_CTRL);
258 if (reg < 0)
259 return reg;
260
261 ret = tcpci_get_cc(tcpc, &cc1, &cc2);
262 if (ret < 0)
263 return ret;
264
265 /*
266 * When port has drp toggling enabled, ROLE_CONTROL would only have the initial
267 * terminations for the toggling and does not indicate the final cc
268 * terminations when ConnectionResult is 0 i.e. drp toggling stops and
269 * the connection is resolbed. Infer port role from TCPC_CC_STATUS based on the
270 * terminations seen. The port role is then used to set the cc terminations.
271 */
272 if (reg & TCPC_ROLE_CTRL_DRP) {
273 /* Disable DRP for the OPEN setting to take effect */
274 reg = reg & ~TCPC_ROLE_CTRL_DRP;
275
276 if (polarity == TYPEC_POLARITY_CC2) {
277 reg &= ~(TCPC_ROLE_CTRL_CC2_MASK << TCPC_ROLE_CTRL_CC2_SHIFT);
278 /* Local port is source */
279 if (cc2 == TYPEC_CC_RD)
280 /* Role control would have the Rp setting when DRP was enabled */
281 reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT;
282 else
283 reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT;
284 } else {
285 reg &= ~(TCPC_ROLE_CTRL_CC1_MASK << TCPC_ROLE_CTRL_CC1_SHIFT);
286 /* Local port is source */
287 if (cc1 == TYPEC_CC_RD)
288 /* Role control would have the Rp setting when DRP was enabled */
289 reg |= TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT;
290 else
291 reg |= TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT;
292 }
293 }
294
295 if (polarity == TYPEC_POLARITY_CC2)
296 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC1_SHIFT;
297 else
298 reg |= TCPC_ROLE_CTRL_CC_OPEN << TCPC_ROLE_CTRL_CC2_SHIFT;
299 ret = dm_i2c_reg_write(tcpci->dev, TCPC_ROLE_CTRL, reg);
300 if (ret < 0)
301 return ret;
302
303 return dm_i2c_reg_write(tcpci->dev, TCPC_TCPC_CTRL,
304 (polarity == TYPEC_POLARITY_CC2) ?
305 TCPC_TCPC_CTRL_ORIENTATION : 0);
306 }
307
tcpci_set_vconn(struct tcpc_dev * tcpc,bool enable)308 static int tcpci_set_vconn(struct tcpc_dev *tcpc, bool enable)
309 {
310 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
311 int ret;
312 unsigned int reg;
313
314 /* Handle vendor set vconn */
315 if (tcpci->data->set_vconn) {
316 ret = tcpci->data->set_vconn(tcpci, tcpci->data, enable);
317 if (ret < 0)
318 return ret;
319 }
320
321 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_CTRL);
322 if (reg)
323 return reg;
324 reg &= ~TCPC_POWER_CTRL_VCONN_ENABLE;
325 reg |= enable ? TCPC_POWER_CTRL_VCONN_ENABLE : 0;
326 return dm_i2c_reg_write(tcpci->dev, TCPC_POWER_CTRL, reg);
327 }
328
tcpci_set_roles(struct tcpc_dev * tcpc,bool attached,enum typec_role role,enum typec_data_role data)329 static int tcpci_set_roles(struct tcpc_dev *tcpc, bool attached,
330 enum typec_role role, enum typec_data_role data)
331 {
332 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
333 unsigned int reg;
334 int ret;
335
336 reg = PD_REV20 << TCPC_MSG_HDR_INFO_REV_SHIFT;
337 if (role == TYPEC_SOURCE)
338 reg |= TCPC_MSG_HDR_INFO_PWR_ROLE;
339 if (data == TYPEC_HOST)
340 reg |= TCPC_MSG_HDR_INFO_DATA_ROLE;
341 ret = dm_i2c_reg_write(tcpci->dev, TCPC_MSG_HDR_INFO, reg);
342 if (ret < 0)
343 return ret;
344
345 return 0;
346 }
347
tcpci_set_pd_rx(struct tcpc_dev * tcpc,bool enable)348 static int tcpci_set_pd_rx(struct tcpc_dev *tcpc, bool enable)
349 {
350 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
351 unsigned int reg = 0;
352 int ret;
353
354 if (enable)
355 reg = TCPC_RX_DETECT_SOP | TCPC_RX_DETECT_HARD_RESET;
356 ret = dm_i2c_reg_write(tcpci->dev, TCPC_RX_DETECT, reg);
357 if (ret < 0)
358 return ret;
359
360 return 0;
361 }
362
tcpci_get_vbus(struct tcpc_dev * tcpc)363 static int tcpci_get_vbus(struct tcpc_dev *tcpc)
364 {
365 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
366 unsigned int reg;
367
368 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_STATUS);
369 if (reg < 0)
370 return reg;
371
372 return !!(reg & TCPC_POWER_STATUS_VBUS_PRES);
373 }
374
tcpci_set_vbus(struct tcpc_dev * tcpc,bool source,bool sink)375 static int tcpci_set_vbus(struct tcpc_dev *tcpc, bool source, bool sink)
376 {
377 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
378 int ret;
379
380 /* Disable both source and sink first before enabling anything */
381
382 if (!source) {
383 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND,
384 TCPC_CMD_DISABLE_SRC_VBUS);
385 if (ret < 0)
386 return ret;
387 }
388
389 if (!sink) {
390 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND,
391 TCPC_CMD_DISABLE_SINK_VBUS);
392 if (ret < 0)
393 return ret;
394 }
395
396 if (source) {
397 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND,
398 TCPC_CMD_SRC_VBUS_DEFAULT);
399 if (ret < 0)
400 return ret;
401 }
402
403 if (sink) {
404 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND,
405 TCPC_CMD_SINK_VBUS);
406 if (ret < 0)
407 return ret;
408 }
409
410 return 0;
411 }
412
tcpci_pd_transmit(struct tcpc_dev * tcpc,enum tcpm_transmit_type type,const struct pd_message * msg,unsigned int negotiated_rev)413 static int tcpci_pd_transmit(struct tcpc_dev *tcpc,
414 enum tcpm_transmit_type type,
415 const struct pd_message *msg,
416 unsigned int negotiated_rev)
417 {
418 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
419 u16 header = msg ? le16_to_cpu(msg->header) : 0;
420 unsigned int reg, cnt;
421 int ret;
422
423 cnt = msg ? pd_header_cnt(header) * 4 : 0;
424 ret = dm_i2c_reg_write(tcpci->dev, TCPC_TX_BYTE_CNT, cnt + 2);
425 if (ret < 0)
426 return ret;
427
428 ret = tcpci_write16(tcpci, TCPC_TX_HDR, header);
429 if (ret < 0)
430 return ret;
431
432 if (cnt > 0) {
433 ret = tcpci_block_write(tcpci, TCPC_TX_DATA,
434 (u8 *)&msg->payload, cnt);
435 if (ret < 0)
436 return ret;
437 }
438
439 reg = (PD_RETRY_COUNT << TCPC_TRANSMIT_RETRY_SHIFT) |
440 (type << TCPC_TRANSMIT_TYPE_SHIFT);
441 ret = dm_i2c_reg_write(tcpci->dev, TCPC_TRANSMIT, reg);
442 if (ret < 0)
443 return ret;
444
445 return 0;
446 }
447
tcpci_init(struct tcpc_dev * tcpc)448 static int tcpci_init(struct tcpc_dev *tcpc)
449 {
450 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
451 unsigned int timeout = 0; /* XXX */
452 unsigned int reg;
453 int ret;
454
455 while (timeout < 100) {
456 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_STATUS);
457 if (reg < 0)
458 return reg;
459 if (!(reg & TCPC_POWER_STATUS_UNINIT))
460 break;
461 timeout++;
462 udelay(200);
463 }
464 if (timeout >= 100)
465 return -ETIMEDOUT;
466
467 /* Handle vendor init */
468 if (tcpci->data->init) {
469 ret = tcpci->data->init(tcpci, tcpci->data);
470 if (ret < 0)
471 return ret;
472 }
473
474 /* Clear all events */
475 ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff);
476 if (ret < 0)
477 return ret;
478
479 if (tcpci->controls_vbus)
480 reg = TCPC_POWER_STATUS_VBUS_PRES;
481 else
482 reg = 0;
483 ret = dm_i2c_reg_write(tcpci->dev, TCPC_POWER_STATUS_MASK, reg);
484 if (ret < 0)
485 return ret;
486
487 /* Enable Vbus detection */
488 ret = dm_i2c_reg_write(tcpci->dev, TCPC_COMMAND,
489 TCPC_CMD_ENABLE_VBUS_DETECT);
490 if (ret < 0)
491 return ret;
492
493 reg = TCPC_ALERT_TX_SUCCESS | TCPC_ALERT_TX_FAILED |
494 TCPC_ALERT_TX_DISCARDED | TCPC_ALERT_RX_STATUS |
495 TCPC_ALERT_RX_HARD_RST | TCPC_ALERT_CC_STATUS;
496 if (tcpci->controls_vbus)
497 reg |= TCPC_ALERT_POWER_STATUS;
498 return tcpci_write16(tcpci, TCPC_ALERT_MASK, reg);
499 }
500
tcpci_poll_event(struct tcpc_dev * tcpc)501 static void tcpci_poll_event(struct tcpc_dev *tcpc)
502 {
503 u16 status;
504 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
505
506 if (tcpci->gpio_cc_int_present)
507 if (!dm_gpio_get_value(&tcpci->gpio_cc_int))
508 return;
509
510 tcpci_read16(tcpci, TCPC_ALERT, &status);
511
512 /*
513 * Clear alert status for everything except RX_STATUS, which shouldn't
514 * be cleared until we have successfully retrieved message.
515 */
516 if (status & ~TCPC_ALERT_RX_STATUS)
517 tcpci_write16(tcpci, TCPC_ALERT,
518 status & ~TCPC_ALERT_RX_STATUS);
519
520 if (status & TCPC_ALERT_CC_STATUS)
521 tcpm_cc_change(tcpci->port);
522
523 if (status & TCPC_ALERT_POWER_STATUS) {
524 unsigned int reg;
525
526 reg = dm_i2c_reg_read(tcpci->dev, TCPC_POWER_STATUS_MASK);
527 if (reg < 0)
528 return;
529
530 /*
531 * If power status mask has been reset, then the TCPC
532 * has reset.
533 */
534 if (reg == 0xff)
535 tcpm_tcpc_reset(tcpci->port);
536 else
537 tcpm_vbus_change(tcpci->port);
538 }
539
540 if (status & TCPC_ALERT_RX_STATUS) {
541 struct pd_message msg;
542 unsigned int cnt, payload_cnt;
543 u16 header;
544
545 cnt = dm_i2c_reg_read(tcpci->dev, TCPC_RX_BYTE_CNT);
546 if (cnt < 0)
547 return;
548 /*
549 * 'cnt' corresponds to READABLE_BYTE_COUNT in section 4.4.14
550 * of the TCPCI spec [Rev 2.0 Ver 1.0 October 2017] and is
551 * defined in table 4-36 as one greater than the number of
552 * bytes received. And that number includes the header. So:
553 */
554 if (cnt > 3)
555 payload_cnt = cnt - (1 + sizeof(msg.header));
556 else
557 payload_cnt = 0;
558
559 tcpci_read16(tcpci, TCPC_RX_HDR, &header);
560 msg.header = cpu_to_le16(header);
561
562 if (WARN_ON(payload_cnt > sizeof(msg.payload)))
563 payload_cnt = sizeof(msg.payload);
564
565 if (payload_cnt > 0)
566 tcpci_block_read(tcpci, TCPC_RX_DATA,
567 (u8 *)&msg.payload, payload_cnt);
568
569 /* Read complete, clear RX status alert bit */
570 tcpci_write16(tcpci, TCPC_ALERT, TCPC_ALERT_RX_STATUS);
571
572 tcpm_pd_receive(tcpci->port, &msg);
573 }
574
575 if (status & TCPC_ALERT_RX_HARD_RST)
576 tcpm_pd_hard_reset(tcpci->port);
577
578 if (status & TCPC_ALERT_TX_SUCCESS)
579 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_SUCCESS);
580 else if (status & TCPC_ALERT_TX_DISCARDED)
581 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_DISCARDED);
582 else if (status & TCPC_ALERT_TX_FAILED)
583 tcpm_pd_transmit_complete(tcpci->port, TCPC_TX_FAILED);
584 }
585
tcpci_enter_low_power_mode(struct tcpc_dev * tcpc,bool attached,bool pd_capable)586 static int tcpci_enter_low_power_mode(struct tcpc_dev *tcpc,
587 bool attached, bool pd_capable)
588 {
589 int ret;
590 struct tcpci *tcpci = tcpc_to_tcpci(tcpc);
591 unsigned int reg;
592
593 /* Disable chip interrupts before unregistering port */
594 ret = tcpci_write16(tcpci, TCPC_ALERT_MASK, 0);
595 if (ret < 0)
596 return ret;
597
598 reg = dm_i2c_reg_read(tcpci->dev, TCPC_BMCIO_CTRL);
599 if (reg < 0)
600 return reg;
601 /*
602 * For Type-C devices with PD capability, Only disable VBUS detect,
603 * do not diable 24M oscillator for BMC communication. Otherwise,
604 * data packets cannot be received.
605 */
606 if (attached && pd_capable)
607 reg &= ~TCPC_BMCIO_VBUS_DETECT_MASK;
608 else
609 reg &= ~(TCPC_BMCIO_VBUS_DETECT_MASK | TCPC_BMCIO_24M_OSC_MASK);
610 return dm_i2c_reg_write(tcpci->dev, TCPC_BMCIO_CTRL, reg);
611 }
612
tcpci_parse_config(struct tcpci * tcpci)613 static int tcpci_parse_config(struct tcpci *tcpci)
614 {
615 tcpci->controls_vbus = true; /* XXX */
616
617 tcpci->tcpc.connector_node = dev_read_subnode(tcpci->dev, "connector");
618 if (!ofnode_valid(tcpci->tcpc.connector_node)) {
619 printf("%s: 'connector' node is not found\n", __func__);
620 return -EINVAL;
621 }
622
623 return 0;
624 }
625
tcpci_register_port(struct udevice * dev,struct tcpci_data * data)626 struct tcpci *tcpci_register_port(struct udevice *dev, struct tcpci_data *data)
627 {
628 struct tcpci *tcpci;
629 int err;
630
631 tcpci = devm_kzalloc(dev, sizeof(*tcpci), GFP_KERNEL);
632 if (!tcpci)
633 return ERR_PTR(-ENOMEM);
634
635 err = gpio_request_by_name(dev, "int-n-gpios", 0, &tcpci->gpio_cc_int, GPIOD_IS_IN);
636 if (err) {
637 printf("%s: fail to get int GPIO: err=%d\n", __func__, err);
638 tcpci->gpio_cc_int_present = false;
639 } else {
640 tcpci->gpio_cc_int_present = true;
641 }
642
643 tcpci->dev = dev;
644 tcpci->data = data;
645
646 tcpci->tcpc.init = tcpci_init;
647 tcpci->tcpc.get_vbus = tcpci_get_vbus;
648 tcpci->tcpc.set_vbus = tcpci_set_vbus;
649 tcpci->tcpc.set_cc = tcpci_set_cc;
650 tcpci->tcpc.get_cc = tcpci_get_cc;
651 tcpci->tcpc.set_polarity = tcpci_set_polarity;
652 tcpci->tcpc.set_vconn = tcpci_set_vconn;
653 tcpci->tcpc.start_toggling = tcpci_start_toggling;
654
655 tcpci->tcpc.set_pd_rx = tcpci_set_pd_rx;
656 tcpci->tcpc.set_roles = tcpci_set_roles;
657 tcpci->tcpc.pd_transmit = tcpci_pd_transmit;
658 tcpci->tcpc.poll_event = tcpci_poll_event;
659 tcpci->tcpc.enter_low_power_mode = tcpci_enter_low_power_mode;
660
661 err = tcpci_parse_config(tcpci);
662 if (err < 0)
663 return ERR_PTR(err);
664
665 tcpci->port = tcpm_port_init(tcpci->dev, &tcpci->tcpc);
666 if (IS_ERR(tcpci->port)) {
667 printf("%s: failed to tcpm port init\n", __func__);
668 return ERR_CAST(tcpci->port);
669 }
670
671 tcpm_poll_event(tcpci->port);
672
673 return tcpci;
674 }
675 EXPORT_SYMBOL_GPL(tcpci_register_port);
676
tcpci_unregister_port(struct tcpci * tcpci)677 void tcpci_unregister_port(struct tcpci *tcpci)
678 {
679 tcpm_uninit_port(tcpci->port);
680 }
681 EXPORT_SYMBOL_GPL(tcpci_unregister_port);
682
tcpci_get_voltage_fun(struct tcpci * tcpci)683 int tcpci_get_voltage_fun(struct tcpci *tcpci)
684 {
685 return tcpm_get_voltage(tcpci->port);
686 }
687 EXPORT_SYMBOL_GPL(tcpci_get_voltage_fun);
688
tcpci_get_current_fun(struct tcpci * tcpci)689 int tcpci_get_current_fun(struct tcpci *tcpci)
690 {
691 return tcpm_get_current(tcpci->port);
692 }
693 EXPORT_SYMBOL_GPL(tcpci_get_current_fun);
694
tcpci_get_online_fun(struct tcpci * tcpci)695 int tcpci_get_online_fun(struct tcpci *tcpci)
696 {
697 return tcpm_get_online(tcpci->port);
698 }
699 EXPORT_SYMBOL_GPL(tcpci_get_online_fun);
700
tcpci_probe(struct udevice * dev)701 static int tcpci_probe(struct udevice *dev)
702 {
703 struct tcpci_chip *chip = dev_get_priv(dev);
704 int err;
705 u16 val = 0;
706
707 chip->udev = dev;
708
709 /* Disable chip interrupts before requesting irq */
710 err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, val);
711 if (err < 0)
712 return err;
713
714 chip->tcpci = tcpci_register_port(chip->udev, &chip->data);
715 if (IS_ERR(chip->tcpci))
716 return PTR_ERR(chip->tcpci);
717
718 return 0;
719 }
720
tcpci_remove(struct udevice * dev)721 static int tcpci_remove(struct udevice *dev)
722 {
723 struct tcpci_chip *chip = dev_get_priv(dev);
724 int err;
725
726 /* Disable chip interrupts before unregistering port */
727 err = tcpci_write16(chip->tcpci, TCPC_ALERT_MASK, 0);
728 if (err < 0)
729 return err;
730
731 tcpci_unregister_port(chip->tcpci);
732
733 return 0;
734 }
735
tcpci_get_voltage(struct udevice * dev)736 static int tcpci_get_voltage(struct udevice *dev)
737 {
738 struct tcpci_chip *chip = dev_get_priv(dev);
739
740 return tcpm_get_voltage(chip->tcpci->port);
741 }
742
tcpci_get_current(struct udevice * dev)743 static int tcpci_get_current(struct udevice *dev)
744 {
745 struct tcpci_chip *chip = dev_get_priv(dev);
746
747 return tcpm_get_current(chip->tcpci->port);
748 }
749
tcpci_get_online(struct udevice * dev)750 static int tcpci_get_online(struct udevice *dev)
751 {
752 struct tcpci_chip *chip = dev_get_priv(dev);
753
754 return tcpm_get_online(chip->tcpci->port);
755 }
756
757 static struct dm_power_delivery_ops tcpci_ops = {
758 .get_voltage = tcpci_get_voltage,
759 .get_current = tcpci_get_current,
760 .get_online = tcpci_get_online,
761 };
762
763 static const struct udevice_id tcpci_ids[] = {
764 { .compatible = "nxp,ptn5110", },
765 {},
766 };
767
768 U_BOOT_DRIVER(tcpci) = {
769 .name = "tcpci",
770 .id = UCLASS_PD,
771 .of_match = tcpci_ids,
772 .ops = &tcpci_ops,
773 .probe = tcpci_probe,
774 .remove = tcpci_remove,
775 .priv_auto_alloc_size = sizeof(struct tcpci_chip),
776 }
777
778 MODULE_DESCRIPTION("USB Type-C Port Controller Interface driver");
779 MODULE_LICENSE("GPL");
780