1
2
3
4
5
6
7
8#include <linux/gpio.h>
9#include <linux/gpio/consumer.h>
10#include <linux/interrupt.h>
11#include <linux/i2c.h>
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/of_gpio.h>
15#include <linux/regmap.h>
16#include <linux/usb/pd.h>
17#include <linux/usb/tcpm.h>
18#include <linux/usb/typec.h>
19
20#include "tcpci.h"
21
22#define PD_ACTIVITY_TIMEOUT_MS 10000
23
24#define TCPC_VENDOR_ALERT 0x80
25
26#define TCPC_RECEIVE_BUFFER_COUNT_OFFSET 0
27#define TCPC_RECEIVE_BUFFER_FRAME_TYPE_OFFSET 1
28#define TCPC_RECEIVE_BUFFER_RX_BYTE_BUF_OFFSET 2
29
30
31
32
33
34
35#define TCPC_RECEIVE_BUFFER_LEN 32
36
37#define MAX_BUCK_BOOST_SID 0x69
38#define MAX_BUCK_BOOST_OP 0xb9
39#define MAX_BUCK_BOOST_OFF 0
40#define MAX_BUCK_BOOST_SOURCE 0xa
41#define MAX_BUCK_BOOST_SINK 0x5
42
43struct max_tcpci_chip {
44 struct tcpci_data data;
45 struct tcpci *tcpci;
46 struct device *dev;
47 struct i2c_client *client;
48 struct tcpm_port *port;
49};
50
51static const struct regmap_range max_tcpci_tcpci_range[] = {
52 regmap_reg_range(0x00, 0x95)
53};
54
55const struct regmap_access_table max_tcpci_tcpci_write_table = {
56 .yes_ranges = max_tcpci_tcpci_range,
57 .n_yes_ranges = ARRAY_SIZE(max_tcpci_tcpci_range),
58};
59
60static const struct regmap_config max_tcpci_regmap_config = {
61 .reg_bits = 8,
62 .val_bits = 8,
63 .max_register = 0x95,
64 .wr_table = &max_tcpci_tcpci_write_table,
65};
66
67static struct max_tcpci_chip *tdata_to_max_tcpci(struct tcpci_data *tdata)
68{
69 return container_of(tdata, struct max_tcpci_chip, data);
70}
71
72static int max_tcpci_read16(struct max_tcpci_chip *chip, unsigned int reg, u16 *val)
73{
74 return regmap_raw_read(chip->data.regmap, reg, val, sizeof(u16));
75}
76
77static int max_tcpci_write16(struct max_tcpci_chip *chip, unsigned int reg, u16 val)
78{
79 return regmap_raw_write(chip->data.regmap, reg, &val, sizeof(u16));
80}
81
82static int max_tcpci_read8(struct max_tcpci_chip *chip, unsigned int reg, u8 *val)
83{
84 return regmap_raw_read(chip->data.regmap, reg, val, sizeof(u8));
85}
86
87static int max_tcpci_write8(struct max_tcpci_chip *chip, unsigned int reg, u8 val)
88{
89 return regmap_raw_write(chip->data.regmap, reg, &val, sizeof(u8));
90}
91
92static void max_tcpci_init_regs(struct max_tcpci_chip *chip)
93{
94 u16 alert_mask = 0;
95 int ret;
96
97 ret = max_tcpci_write16(chip, TCPC_ALERT, 0xffff);
98 if (ret < 0) {
99 dev_err(chip->dev, "Error writing to TCPC_ALERT ret:%d\n", ret);
100 return;
101 }
102
103 ret = max_tcpci_write16(chip, TCPC_VENDOR_ALERT, 0xffff);
104 if (ret < 0) {
105 dev_err(chip->dev, "Error writing to TCPC_VENDOR_ALERT ret:%d\n", ret);
106 return;
107 }
108
109 ret = max_tcpci_write8(chip, TCPC_ALERT_EXTENDED, 0xff);
110 if (ret < 0) {
111 dev_err(chip->dev, "Unable to clear TCPC_ALERT_EXTENDED ret:%d\n", ret);
112 return;
113 }
114
115
116 ret = max_tcpci_write8(chip, TCPC_EXTENDED_STATUS_MASK, TCPC_EXTENDED_STATUS_VSAFE0V);
117 if (ret < 0) {
118 dev_err(chip->dev, "Unable to unmask TCPC_EXTENDED_STATUS_VSAFE0V ret:%d\n", ret);
119 return;
120 }
121
122 alert_mask = TCPC_ALERT_TX_SUCCESS | TCPC_ALERT_TX_DISCARDED | TCPC_ALERT_TX_FAILED |
123 TCPC_ALERT_RX_HARD_RST | TCPC_ALERT_RX_STATUS | TCPC_ALERT_CC_STATUS |
124 TCPC_ALERT_VBUS_DISCNCT | TCPC_ALERT_RX_BUF_OVF | TCPC_ALERT_POWER_STATUS |
125
126 TCPC_ALERT_EXTND | TCPC_ALERT_EXTENDED_STATUS;
127
128 ret = max_tcpci_write16(chip, TCPC_ALERT_MASK, alert_mask);
129 if (ret < 0) {
130 dev_err(chip->dev,
131 "Error enabling TCPC_ALERT: TCPC_ALERT_MASK write failed ret:%d\n", ret);
132 return;
133 }
134
135
136 ret = max_tcpci_write8(chip, TCPC_POWER_CTRL, 0);
137 if (ret < 0) {
138 dev_err(chip->dev, "Error writing to TCPC_POWER_CTRL ret:%d\n", ret);
139 return;
140 }
141
142 ret = max_tcpci_write8(chip, TCPC_ALERT_EXTENDED_MASK, TCPC_SINK_FAST_ROLE_SWAP);
143 if (ret < 0)
144 return;
145}
146
147static void process_rx(struct max_tcpci_chip *chip, u16 status)
148{
149 struct pd_message msg;
150 u8 count, frame_type, rx_buf[TCPC_RECEIVE_BUFFER_LEN];
151 int ret, payload_index;
152 u8 *rx_buf_ptr;
153
154
155
156
157
158
159 ret = regmap_raw_read(chip->data.regmap, TCPC_RX_BYTE_CNT, rx_buf, 2);
160 if (ret < 0) {
161 dev_err(chip->dev, "TCPC_RX_BYTE_CNT read failed ret:%d", ret);
162 return;
163 }
164
165 count = rx_buf[TCPC_RECEIVE_BUFFER_COUNT_OFFSET];
166 frame_type = rx_buf[TCPC_RECEIVE_BUFFER_FRAME_TYPE_OFFSET];
167
168 if (count == 0 || frame_type != TCPC_RX_BUF_FRAME_TYPE_SOP) {
169 max_tcpci_write16(chip, TCPC_ALERT, TCPC_ALERT_RX_STATUS);
170 dev_err(chip->dev, "%s", count == 0 ? "error: count is 0" :
171 "error frame_type is not SOP");
172 return;
173 }
174
175 if (count > sizeof(struct pd_message) || count + 1 > TCPC_RECEIVE_BUFFER_LEN) {
176 dev_err(chip->dev, "Invalid TCPC_RX_BYTE_CNT %d", count);
177 return;
178 }
179
180
181
182
183
184 count += 1;
185 ret = regmap_raw_read(chip->data.regmap, TCPC_RX_BYTE_CNT, rx_buf, count);
186 if (ret < 0) {
187 dev_err(chip->dev, "Error: TCPC_RX_BYTE_CNT read failed: %d", ret);
188 return;
189 }
190
191 rx_buf_ptr = rx_buf + TCPC_RECEIVE_BUFFER_RX_BYTE_BUF_OFFSET;
192 msg.header = cpu_to_le16(*(u16 *)rx_buf_ptr);
193 rx_buf_ptr = rx_buf_ptr + sizeof(msg.header);
194 for (payload_index = 0; payload_index < pd_header_cnt_le(msg.header); payload_index++,
195 rx_buf_ptr += sizeof(msg.payload[0]))
196 msg.payload[payload_index] = cpu_to_le32(*(u32 *)rx_buf_ptr);
197
198
199
200
201
202 ret = max_tcpci_write16(chip, TCPC_ALERT, status & TCPC_ALERT_RX_BUF_OVF ?
203 TCPC_ALERT_RX_STATUS | TCPC_ALERT_RX_BUF_OVF :
204 TCPC_ALERT_RX_STATUS);
205 if (ret < 0)
206 return;
207
208 tcpm_pd_receive(chip->port, &msg);
209}
210
211static int max_tcpci_set_vbus(struct tcpci *tcpci, struct tcpci_data *tdata, bool source, bool sink)
212{
213 struct max_tcpci_chip *chip = tdata_to_max_tcpci(tdata);
214 u8 buffer_source[2] = {MAX_BUCK_BOOST_OP, MAX_BUCK_BOOST_SOURCE};
215 u8 buffer_sink[2] = {MAX_BUCK_BOOST_OP, MAX_BUCK_BOOST_SINK};
216 u8 buffer_none[2] = {MAX_BUCK_BOOST_OP, MAX_BUCK_BOOST_OFF};
217 struct i2c_client *i2c = chip->client;
218 int ret;
219
220 struct i2c_msg msgs[] = {
221 {
222 .addr = MAX_BUCK_BOOST_SID,
223 .flags = i2c->flags & I2C_M_TEN,
224 .len = 2,
225 .buf = source ? buffer_source : sink ? buffer_sink : buffer_none,
226 },
227 };
228
229 if (source && sink) {
230 dev_err(chip->dev, "Both source and sink set\n");
231 return -EINVAL;
232 }
233
234 ret = i2c_transfer(i2c->adapter, msgs, 1);
235
236 return ret < 0 ? ret : 1;
237}
238
239static void process_power_status(struct max_tcpci_chip *chip)
240{
241 u8 pwr_status;
242 int ret;
243
244 ret = max_tcpci_read8(chip, TCPC_POWER_STATUS, &pwr_status);
245 if (ret < 0)
246 return;
247
248 if (pwr_status == 0xff)
249 max_tcpci_init_regs(chip);
250 else if (pwr_status & TCPC_POWER_STATUS_SOURCING_VBUS)
251 tcpm_sourcing_vbus(chip->port);
252 else
253 tcpm_vbus_change(chip->port);
254}
255
256static void max_tcpci_frs_sourcing_vbus(struct tcpci *tcpci, struct tcpci_data *tdata)
257{
258
259
260
261
262
263 max_tcpci_set_vbus(tcpci, tdata, true, false);
264}
265
266static void process_tx(struct max_tcpci_chip *chip, u16 status)
267{
268 if (status & TCPC_ALERT_TX_SUCCESS)
269 tcpm_pd_transmit_complete(chip->port, TCPC_TX_SUCCESS);
270 else if (status & TCPC_ALERT_TX_DISCARDED)
271 tcpm_pd_transmit_complete(chip->port, TCPC_TX_DISCARDED);
272 else if (status & TCPC_ALERT_TX_FAILED)
273 tcpm_pd_transmit_complete(chip->port, TCPC_TX_FAILED);
274
275
276 if ((status & TCPC_ALERT_TX_SUCCESS) && (status & TCPC_ALERT_TX_FAILED))
277 max_tcpci_init_regs(chip);
278}
279
280static irqreturn_t _max_tcpci_irq(struct max_tcpci_chip *chip, u16 status)
281{
282 u16 mask;
283 int ret;
284 u8 reg_status;
285
286
287
288
289
290 if (status & ~TCPC_ALERT_RX_STATUS) {
291 mask = status & TCPC_ALERT_RX_BUF_OVF ?
292 status & ~(TCPC_ALERT_RX_STATUS | TCPC_ALERT_RX_BUF_OVF) :
293 status & ~TCPC_ALERT_RX_STATUS;
294 ret = max_tcpci_write16(chip, TCPC_ALERT, mask);
295 if (ret < 0) {
296 dev_err(chip->dev, "ALERT clear failed\n");
297 return ret;
298 }
299 }
300
301 if (status & TCPC_ALERT_RX_BUF_OVF && !(status & TCPC_ALERT_RX_STATUS)) {
302 ret = max_tcpci_write16(chip, TCPC_ALERT, (TCPC_ALERT_RX_STATUS |
303 TCPC_ALERT_RX_BUF_OVF));
304 if (ret < 0) {
305 dev_err(chip->dev, "ALERT clear failed\n");
306 return ret;
307 }
308 }
309
310 if (status & TCPC_ALERT_EXTND) {
311 ret = max_tcpci_read8(chip, TCPC_ALERT_EXTENDED, ®_status);
312 if (ret < 0)
313 return ret;
314
315 ret = max_tcpci_write8(chip, TCPC_ALERT_EXTENDED, reg_status);
316 if (ret < 0)
317 return ret;
318
319 if (reg_status & TCPC_SINK_FAST_ROLE_SWAP) {
320 dev_info(chip->dev, "FRS Signal");
321 tcpm_sink_frs(chip->port);
322 }
323 }
324
325 if (status & TCPC_ALERT_EXTENDED_STATUS) {
326 ret = max_tcpci_read8(chip, TCPC_EXTENDED_STATUS, (u8 *)®_status);
327 if (ret >= 0 && (reg_status & TCPC_EXTENDED_STATUS_VSAFE0V))
328 tcpm_vbus_change(chip->port);
329 }
330
331 if (status & TCPC_ALERT_RX_STATUS)
332 process_rx(chip, status);
333
334 if (status & TCPC_ALERT_VBUS_DISCNCT)
335 tcpm_vbus_change(chip->port);
336
337 if (status & TCPC_ALERT_CC_STATUS)
338 tcpm_cc_change(chip->port);
339
340 if (status & TCPC_ALERT_POWER_STATUS)
341 process_power_status(chip);
342
343 if (status & TCPC_ALERT_RX_HARD_RST) {
344 tcpm_pd_hard_reset(chip->port);
345 max_tcpci_init_regs(chip);
346 }
347
348 if (status & TCPC_ALERT_TX_SUCCESS || status & TCPC_ALERT_TX_DISCARDED || status &
349 TCPC_ALERT_TX_FAILED)
350 process_tx(chip, status);
351
352 return IRQ_HANDLED;
353}
354
355static irqreturn_t max_tcpci_irq(int irq, void *dev_id)
356{
357 struct max_tcpci_chip *chip = dev_id;
358 u16 status;
359 irqreturn_t irq_return = IRQ_HANDLED;
360 int ret;
361
362 if (!chip->port)
363 return IRQ_HANDLED;
364
365 ret = max_tcpci_read16(chip, TCPC_ALERT, &status);
366 if (ret < 0) {
367 dev_err(chip->dev, "ALERT read failed\n");
368 return ret;
369 }
370 while (status) {
371 irq_return = _max_tcpci_irq(chip, status);
372
373 ret = max_tcpci_read16(chip, TCPC_ALERT, &status);
374 if (ret < 0)
375 break;
376 }
377
378 return irq_return;
379}
380
381static irqreturn_t max_tcpci_isr(int irq, void *dev_id)
382{
383 struct max_tcpci_chip *chip = dev_id;
384
385 pm_wakeup_event(chip->dev, PD_ACTIVITY_TIMEOUT_MS);
386
387 if (!chip->port)
388 return IRQ_HANDLED;
389
390 return IRQ_WAKE_THREAD;
391}
392
393static int max_tcpci_init_alert(struct max_tcpci_chip *chip, struct i2c_client *client)
394{
395 int ret;
396
397 ret = devm_request_threaded_irq(chip->dev, client->irq, max_tcpci_isr, max_tcpci_irq,
398 (IRQF_TRIGGER_LOW | IRQF_ONESHOT), dev_name(chip->dev),
399 chip);
400
401 if (ret < 0)
402 return ret;
403
404 enable_irq_wake(client->irq);
405 return 0;
406}
407
408static int max_tcpci_start_toggling(struct tcpci *tcpci, struct tcpci_data *tdata,
409 enum typec_cc_status cc)
410{
411 struct max_tcpci_chip *chip = tdata_to_max_tcpci(tdata);
412
413 max_tcpci_init_regs(chip);
414
415 return 0;
416}
417
418static int tcpci_init(struct tcpci *tcpci, struct tcpci_data *data)
419{
420
421
422
423
424 return -1;
425}
426
427static int max_tcpci_probe(struct i2c_client *client, const struct i2c_device_id *i2c_id)
428{
429 int ret;
430 struct max_tcpci_chip *chip;
431 u8 power_status;
432
433 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
434 if (!chip)
435 return -ENOMEM;
436
437 chip->client = client;
438 chip->data.regmap = devm_regmap_init_i2c(client, &max_tcpci_regmap_config);
439 if (IS_ERR(chip->data.regmap)) {
440 dev_err(&client->dev, "Regmap init failed\n");
441 return PTR_ERR(chip->data.regmap);
442 }
443
444 chip->dev = &client->dev;
445 i2c_set_clientdata(client, chip);
446
447 ret = max_tcpci_read8(chip, TCPC_POWER_STATUS, &power_status);
448 if (ret < 0)
449 return ret;
450
451
452 chip->data.set_vbus = max_tcpci_set_vbus;
453 chip->data.start_drp_toggling = max_tcpci_start_toggling;
454 chip->data.TX_BUF_BYTE_x_hidden = true;
455 chip->data.init = tcpci_init;
456 chip->data.frs_sourcing_vbus = max_tcpci_frs_sourcing_vbus;
457 chip->data.auto_discharge_disconnect = true;
458 chip->data.vbus_vsafe0v = true;
459
460 max_tcpci_init_regs(chip);
461 chip->tcpci = tcpci_register_port(chip->dev, &chip->data);
462 if (IS_ERR(chip->tcpci)) {
463 dev_err(&client->dev, "TCPCI port registration failed");
464 ret = PTR_ERR(chip->tcpci);
465 return PTR_ERR(chip->tcpci);
466 }
467 chip->port = tcpci_get_tcpm_port(chip->tcpci);
468 ret = max_tcpci_init_alert(chip, client);
469 if (ret < 0)
470 goto unreg_port;
471
472 device_init_wakeup(chip->dev, true);
473 return 0;
474
475unreg_port:
476 tcpci_unregister_port(chip->tcpci);
477
478 return ret;
479}
480
481static int max_tcpci_remove(struct i2c_client *client)
482{
483 struct max_tcpci_chip *chip = i2c_get_clientdata(client);
484
485 if (!IS_ERR_OR_NULL(chip->tcpci))
486 tcpci_unregister_port(chip->tcpci);
487
488 return 0;
489}
490
491static const struct i2c_device_id max_tcpci_id[] = {
492 { "maxtcpc", 0 },
493 { }
494};
495MODULE_DEVICE_TABLE(i2c, max_tcpci_id);
496
497#ifdef CONFIG_OF
498static const struct of_device_id max_tcpci_of_match[] = {
499 { .compatible = "maxim,max33359", },
500 {},
501};
502MODULE_DEVICE_TABLE(of, max_tcpci_of_match);
503#endif
504
505static struct i2c_driver max_tcpci_i2c_driver = {
506 .driver = {
507 .name = "maxtcpc",
508 .of_match_table = of_match_ptr(max_tcpci_of_match),
509 },
510 .probe = max_tcpci_probe,
511 .remove = max_tcpci_remove,
512 .id_table = max_tcpci_id,
513};
514module_i2c_driver(max_tcpci_i2c_driver);
515
516MODULE_AUTHOR("Badhri Jagan Sridharan <badhri@google.com>");
517MODULE_DESCRIPTION("Maxim TCPCI based USB Type-C Port Controller Interface Driver");
518MODULE_LICENSE("GPL v2");
519
