tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Driver for TI TPS6598x USB Power Delivery controller family
4 *
5 * Copyright (C) 2017, Intel Corporation
6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
7 */
8
9#include <linux/i2c.h>
10#include <linux/acpi.h>
11#include <linux/module.h>
12#include <linux/regmap.h>
13#include <linux/interrupt.h>
14#include <linux/usb/typec.h>
15#include <linux/usb/role.h>
16
17/* Register offsets */
18#define TPS_REG_VID 0x00
19#define TPS_REG_MODE 0x03
20#define TPS_REG_CMD1 0x08
21#define TPS_REG_DATA1 0x09
22#define TPS_REG_INT_EVENT1 0x14
23#define TPS_REG_INT_EVENT2 0x15
24#define TPS_REG_INT_MASK1 0x16
25#define TPS_REG_INT_MASK2 0x17
26#define TPS_REG_INT_CLEAR1 0x18
27#define TPS_REG_INT_CLEAR2 0x19
28#define TPS_REG_STATUS 0x1a
29#define TPS_REG_SYSTEM_CONF 0x28
30#define TPS_REG_CTRL_CONF 0x29
31#define TPS_REG_POWER_STATUS 0x3f
32#define TPS_REG_RX_IDENTITY_SOP 0x48
33
34/* TPS_REG_INT_* bits */
35#define TPS_REG_INT_PLUG_EVENT BIT(3)
36
37/* TPS_REG_STATUS bits */
38#define TPS_STATUS_PLUG_PRESENT BIT(0)
39#define TPS_STATUS_ORIENTATION BIT(4)
40#define TPS_STATUS_PORTROLE(s) (!!((s) & BIT(5)))
41#define TPS_STATUS_DATAROLE(s) (!!((s) & BIT(6)))
42#define TPS_STATUS_VCONN(s) (!!((s) & BIT(7)))
43
44/* TPS_REG_SYSTEM_CONF bits */
45#define TPS_SYSCONF_PORTINFO(c) ((c) & 7)
46
47enum {
48 TPS_PORTINFO_SINK,
49 TPS_PORTINFO_SINK_ACCESSORY,
50 TPS_PORTINFO_DRP_UFP,
51 TPS_PORTINFO_DRP_UFP_DRD,
52 TPS_PORTINFO_DRP_DFP,
53 TPS_PORTINFO_DRP_DFP_DRD,
54 TPS_PORTINFO_SOURCE,
55};
56
57/* TPS_REG_POWER_STATUS bits */
58#define TPS_POWER_STATUS_SOURCESINK BIT(1)
59#define TPS_POWER_STATUS_PWROPMODE(p) (((p) & GENMASK(3, 2)) >> 2)
60
61/* TPS_REG_RX_IDENTITY_SOP */
62struct tps6598x_rx_identity_reg {
63 u8 status;
64 struct usb_pd_identity identity;
65 u32 vdo[3];
66} __packed;
67
68/* Standard Task return codes */
69#define TPS_TASK_TIMEOUT 1
70#define TPS_TASK_REJECTED 3
71
72enum {
73 TPS_MODE_APP,
74 TPS_MODE_BOOT,
75 TPS_MODE_BIST,
76 TPS_MODE_DISC,
77};
78
79static const char *const modes[] = {
80 [TPS_MODE_APP] = "APP ",
81 [TPS_MODE_BOOT] = "BOOT",
82 [TPS_MODE_BIST] = "BIST",
83 [TPS_MODE_DISC] = "DISC",
84};
85
86/* Unrecognized commands will be replaced with "!CMD" */
87#define INVALID_CMD(_cmd_) (_cmd_ == 0x444d4321)
88
89struct tps6598x {
90 struct device *dev;
91 struct regmap *regmap;
92 struct mutex lock; /* device lock */
93 u8 i2c_protocol:1;
94
95 struct typec_port *port;
96 struct typec_partner *partner;
97 struct usb_pd_identity partner_identity;
98 struct usb_role_switch *role_sw;
99};
100
101/*
102 * Max data bytes for Data1, Data2, and other registers. See ch 1.3.2:
103 * http://www.ti.com/lit/ug/slvuan1a/slvuan1a.pdf
104 */
105#define TPS_MAX_LEN 64
106
107static int
108tps6598x_block_read(struct tps6598x *tps, u8 reg, void *val, size_t len)
109{
110 u8 data[TPS_MAX_LEN + 1];
111 int ret;
112
113 if (WARN_ON(len + 1 > sizeof(data)))
114 return -EINVAL;
115
116 if (!tps->i2c_protocol)
117 return regmap_raw_read(tps->regmap, reg, val, len);
118
119 ret = regmap_raw_read(tps->regmap, reg, data, sizeof(data));
120 if (ret)
121 return ret;
122
123 if (data[0] < len)
124 return -EIO;
125
126 memcpy(val, &data[1], len);
127 return 0;
128}
129
130static int tps6598x_block_write(struct tps6598x *tps, u8 reg,
131 const void *val, size_t len)
132{
133 u8 data[TPS_MAX_LEN + 1];
134
135 if (!tps->i2c_protocol)
136 return regmap_raw_write(tps->regmap, reg, val, len);
137
138 data[0] = len;
139 memcpy(&data[1], val, len);
140
141 return regmap_raw_write(tps->regmap, reg, data, sizeof(data));
142}
143
144static inline int tps6598x_read16(struct tps6598x *tps, u8 reg, u16 *val)
145{
146 return tps6598x_block_read(tps, reg, val, sizeof(u16));
147}
148
149static inline int tps6598x_read32(struct tps6598x *tps, u8 reg, u32 *val)
150{
151 return tps6598x_block_read(tps, reg, val, sizeof(u32));
152}
153
154static inline int tps6598x_read64(struct tps6598x *tps, u8 reg, u64 *val)
155{
156 return tps6598x_block_read(tps, reg, val, sizeof(u64));
157}
158
159static inline int tps6598x_write16(struct tps6598x *tps, u8 reg, u16 val)
160{
161 return tps6598x_block_write(tps, reg, &val, sizeof(u16));
162}
163
164static inline int tps6598x_write32(struct tps6598x *tps, u8 reg, u32 val)
165{
166 return tps6598x_block_write(tps, reg, &val, sizeof(u32));
167}
168
169static inline int tps6598x_write64(struct tps6598x *tps, u8 reg, u64 val)
170{
171 return tps6598x_block_write(tps, reg, &val, sizeof(u64));
172}
173
174static inline int
175tps6598x_write_4cc(struct tps6598x *tps, u8 reg, const char *val)
176{
177 return tps6598x_block_write(tps, reg, val, 4);
178}
179
180static int tps6598x_read_partner_identity(struct tps6598x *tps)
181{
182 struct tps6598x_rx_identity_reg id;
183 int ret;
184
185 ret = tps6598x_block_read(tps, TPS_REG_RX_IDENTITY_SOP,
186 &id, sizeof(id));
187 if (ret)
188 return ret;
189
190 tps->partner_identity = id.identity;
191
192 return 0;
193}
194
195static void tps6598x_set_data_role(struct tps6598x *tps,
196 enum typec_data_role role, bool connected)
197{
198 enum usb_role role_val;
199
200 if (role == TYPEC_HOST)
201 role_val = USB_ROLE_HOST;
202 else
203 role_val = USB_ROLE_DEVICE;
204
205 if (!connected)
206 role_val = USB_ROLE_NONE;
207
208 usb_role_switch_set_role(tps->role_sw, role_val);
209 typec_set_data_role(tps->port, role);
210}
211
212static int tps6598x_connect(struct tps6598x *tps, u32 status)
213{
214 struct typec_partner_desc desc;
215 enum typec_pwr_opmode mode;
216 u16 pwr_status;
217 int ret;
218
219 if (tps->partner)
220 return 0;
221
222 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
223 if (ret < 0)
224 return ret;
225
226 mode = TPS_POWER_STATUS_PWROPMODE(pwr_status);
227
228 desc.usb_pd = mode == TYPEC_PWR_MODE_PD;
229 desc.accessory = TYPEC_ACCESSORY_NONE; /* XXX: handle accessories */
230 desc.identity = NULL;
231
232 if (desc.usb_pd) {
233 ret = tps6598x_read_partner_identity(tps);
234 if (ret)
235 return ret;
236 desc.identity = &tps->partner_identity;
237 }
238
239 typec_set_pwr_opmode(tps->port, mode);
240 typec_set_pwr_role(tps->port, TPS_STATUS_PORTROLE(status));
241 typec_set_vconn_role(tps->port, TPS_STATUS_VCONN(status));
242 tps6598x_set_data_role(tps, TPS_STATUS_DATAROLE(status), true);
243
244 tps->partner = typec_register_partner(tps->port, &desc);
245 if (IS_ERR(tps->partner))
246 return PTR_ERR(tps->partner);
247
248 if (desc.identity)
249 typec_partner_set_identity(tps->partner);
250
251 return 0;
252}
253
254static void tps6598x_disconnect(struct tps6598x *tps, u32 status)
255{
256 if (!IS_ERR(tps->partner))
257 typec_unregister_partner(tps->partner);
258 tps->partner = NULL;
259 typec_set_pwr_opmode(tps->port, TYPEC_PWR_MODE_USB);
260 typec_set_pwr_role(tps->port, TPS_STATUS_PORTROLE(status));
261 typec_set_vconn_role(tps->port, TPS_STATUS_VCONN(status));
262 tps6598x_set_data_role(tps, TPS_STATUS_DATAROLE(status), false);
263}
264
265static int tps6598x_exec_cmd(struct tps6598x *tps, const char *cmd,
266 size_t in_len, u8 *in_data,
267 size_t out_len, u8 *out_data)
268{
269 unsigned long timeout;
270 u32 val;
271 int ret;
272
273 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
274 if (ret)
275 return ret;
276 if (val && !INVALID_CMD(val))
277 return -EBUSY;
278
279 if (in_len) {
280 ret = tps6598x_block_write(tps, TPS_REG_DATA1,
281 in_data, in_len);
282 if (ret)
283 return ret;
284 }
285
286 ret = tps6598x_write_4cc(tps, TPS_REG_CMD1, cmd);
287 if (ret < 0)
288 return ret;
289
290 /* XXX: Using 1s for now, but it may not be enough for every command. */
291 timeout = jiffies + msecs_to_jiffies(1000);
292
293 do {
294 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
295 if (ret)
296 return ret;
297 if (INVALID_CMD(val))
298 return -EINVAL;
299
300 if (time_is_before_jiffies(timeout))
301 return -ETIMEDOUT;
302 } while (val);
303
304 if (out_len) {
305 ret = tps6598x_block_read(tps, TPS_REG_DATA1,
306 out_data, out_len);
307 if (ret)
308 return ret;
309 val = out_data[0];
310 } else {
311 ret = tps6598x_block_read(tps, TPS_REG_DATA1, &val, sizeof(u8));
312 if (ret)
313 return ret;
314 }
315
316 switch (val) {
317 case TPS_TASK_TIMEOUT:
318 return -ETIMEDOUT;
319 case TPS_TASK_REJECTED:
320 return -EPERM;
321 default:
322 break;
323 }
324
325 return 0;
326}
327
328static int tps6598x_dr_set(struct typec_port *port, enum typec_data_role role)
329{
330 const char *cmd = (role == TYPEC_DEVICE) ? "SWUF" : "SWDF";
331 struct tps6598x *tps = typec_get_drvdata(port);
332 u32 status;
333 int ret;
334
335 mutex_lock(&tps->lock);
336
337 ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
338 if (ret)
339 goto out_unlock;
340
341 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
342 if (ret)
343 goto out_unlock;
344
345 if (role != TPS_STATUS_DATAROLE(status)) {
346 ret = -EPROTO;
347 goto out_unlock;
348 }
349
350 tps6598x_set_data_role(tps, role, true);
351
352out_unlock:
353 mutex_unlock(&tps->lock);
354
355 return ret;
356}
357
358static int tps6598x_pr_set(struct typec_port *port, enum typec_role role)
359{
360 const char *cmd = (role == TYPEC_SINK) ? "SWSk" : "SWSr";
361 struct tps6598x *tps = typec_get_drvdata(port);
362 u32 status;
363 int ret;
364
365 mutex_lock(&tps->lock);
366
367 ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
368 if (ret)
369 goto out_unlock;
370
371 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
372 if (ret)
373 goto out_unlock;
374
375 if (role != TPS_STATUS_PORTROLE(status)) {
376 ret = -EPROTO;
377 goto out_unlock;
378 }
379
380 typec_set_pwr_role(tps->port, role);
381
382out_unlock:
383 mutex_unlock(&tps->lock);
384
385 return ret;
386}
387
388static const struct typec_operations tps6598x_ops = {
389 .dr_set = tps6598x_dr_set,
390 .pr_set = tps6598x_pr_set,
391};
392
393static irqreturn_t tps6598x_interrupt(int irq, void *data)
394{
395 struct tps6598x *tps = data;
396 u64 event1;
397 u64 event2;
398 u32 status;
399 int ret;
400
401 mutex_lock(&tps->lock);
402
403 ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1);
404 ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2);
405 if (ret) {
406 dev_err(tps->dev, "%s: failed to read events\n", __func__);
407 goto err_unlock;
408 }
409
410 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
411 if (ret) {
412 dev_err(tps->dev, "%s: failed to read status\n", __func__);
413 goto err_clear_ints;
414 }
415
416 /* Handle plug insert or removal */
417 if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT) {
418 if (status & TPS_STATUS_PLUG_PRESENT) {
419 ret = tps6598x_connect(tps, status);
420 if (ret)
421 dev_err(tps->dev,
422 "failed to register partner\n");
423 } else {
424 tps6598x_disconnect(tps, status);
425 }
426 }
427
428err_clear_ints:
429 tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1);
430 tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2);
431
432err_unlock:
433 mutex_unlock(&tps->lock);
434
435 return IRQ_HANDLED;
436}
437
438static int tps6598x_check_mode(struct tps6598x *tps)
439{
440 char mode[5] = { };
441 int ret;
442
443 ret = tps6598x_read32(tps, TPS_REG_MODE, (void *)mode);
444 if (ret)
445 return ret;
446
447 switch (match_string(modes, ARRAY_SIZE(modes), mode)) {
448 case TPS_MODE_APP:
449 return 0;
450 case TPS_MODE_BOOT:
451 dev_warn(tps->dev, "dead-battery condition\n");
452 return 0;
453 case TPS_MODE_BIST:
454 case TPS_MODE_DISC:
455 default:
456 dev_err(tps->dev, "controller in unsupported mode \"%s\"\n",
457 mode);
458 break;
459 }
460
461 return -ENODEV;
462}
463
464static const struct regmap_config tps6598x_regmap_config = {
465 .reg_bits = 8,
466 .val_bits = 8,
467 .max_register = 0x7F,
468};
469
470static int tps6598x_probe(struct i2c_client *client)
471{
472 struct typec_capability typec_cap = { };
473 struct tps6598x *tps;
474 struct fwnode_handle *fwnode;
475 u32 status;
476 u32 conf;
477 u32 vid;
478 int ret;
479
480 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
481 if (!tps)
482 return -ENOMEM;
483
484 mutex_init(&tps->lock);
485 tps->dev = &client->dev;
486
487 tps->regmap = devm_regmap_init_i2c(client, &tps6598x_regmap_config);
488 if (IS_ERR(tps->regmap))
489 return PTR_ERR(tps->regmap);
490
491 ret = tps6598x_read32(tps, TPS_REG_VID, &vid);
492 if (ret < 0 || !vid)
493 return -ENODEV;
494
495 /*
496 * Checking can the adapter handle SMBus protocol. If it can not, the
497 * driver needs to take care of block reads separately.
498 *
499 * FIXME: Testing with I2C_FUNC_I2C. regmap-i2c uses I2C protocol
500 * unconditionally if the adapter has I2C_FUNC_I2C set.
501 */
502 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
503 tps->i2c_protocol = true;
504
505 /* Make sure the controller has application firmware running */
506 ret = tps6598x_check_mode(tps);
507 if (ret)
508 return ret;
509
510 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
511 if (ret < 0)
512 return ret;
513
514 ret = tps6598x_read32(tps, TPS_REG_SYSTEM_CONF, &conf);
515 if (ret < 0)
516 return ret;
517
518 fwnode = device_get_named_child_node(&client->dev, "connector");
519 if (IS_ERR(fwnode))
520 return PTR_ERR(fwnode);
521
522 tps->role_sw = fwnode_usb_role_switch_get(fwnode);
523 if (IS_ERR(tps->role_sw)) {
524 ret = PTR_ERR(tps->role_sw);
525 goto err_fwnode_put;
526 }
527
528 typec_cap.revision = USB_TYPEC_REV_1_2;
529 typec_cap.pd_revision = 0x200;
530 typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE;
531 typec_cap.driver_data = tps;
532 typec_cap.ops = &tps6598x_ops;
533 typec_cap.fwnode = fwnode;
534
535 switch (TPS_SYSCONF_PORTINFO(conf)) {
536 case TPS_PORTINFO_SINK_ACCESSORY:
537 case TPS_PORTINFO_SINK:
538 typec_cap.type = TYPEC_PORT_SNK;
539 typec_cap.data = TYPEC_PORT_UFP;
540 break;
541 case TPS_PORTINFO_DRP_UFP_DRD:
542 case TPS_PORTINFO_DRP_DFP_DRD:
543 typec_cap.type = TYPEC_PORT_DRP;
544 typec_cap.data = TYPEC_PORT_DRD;
545 break;
546 case TPS_PORTINFO_DRP_UFP:
547 typec_cap.type = TYPEC_PORT_DRP;
548 typec_cap.data = TYPEC_PORT_UFP;
549 break;
550 case TPS_PORTINFO_DRP_DFP:
551 typec_cap.type = TYPEC_PORT_DRP;
552 typec_cap.data = TYPEC_PORT_DFP;
553 break;
554 case TPS_PORTINFO_SOURCE:
555 typec_cap.type = TYPEC_PORT_SRC;
556 typec_cap.data = TYPEC_PORT_DFP;
557 break;
558 default:
559 ret = -ENODEV;
560 goto err_role_put;
561 }
562
563 tps->port = typec_register_port(&client->dev, &typec_cap);
564 if (IS_ERR(tps->port)) {
565 ret = PTR_ERR(tps->port);
566 goto err_role_put;
567 }
568 fwnode_handle_put(fwnode);
569
570 if (status & TPS_STATUS_PLUG_PRESENT) {
571 ret = tps6598x_connect(tps, status);
572 if (ret)
573 dev_err(&client->dev, "failed to register partner\n");
574 }
575
576 ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
577 tps6598x_interrupt,
578 IRQF_SHARED | IRQF_ONESHOT,
579 dev_name(&client->dev), tps);
580 if (ret) {
581 tps6598x_disconnect(tps, 0);
582 typec_unregister_port(tps->port);
583 goto err_role_put;
584 }
585
586 i2c_set_clientdata(client, tps);
587
588 return 0;
589
590err_role_put:
591 usb_role_switch_put(tps->role_sw);
592err_fwnode_put:
593 fwnode_handle_put(fwnode);
594
595 return ret;
596}
597
598static int tps6598x_remove(struct i2c_client *client)
599{
600 struct tps6598x *tps = i2c_get_clientdata(client);
601
602 tps6598x_disconnect(tps, 0);
603 typec_unregister_port(tps->port);
604 usb_role_switch_put(tps->role_sw);
605
606 return 0;
607}
608
609static const struct of_device_id tps6598x_of_match[] = {
610 { .compatible = "ti,tps6598x", },
611 {}
612};
613MODULE_DEVICE_TABLE(of, tps6598x_of_match);
614
615static const struct i2c_device_id tps6598x_id[] = {
616 { "tps6598x" },
617 { }
618};
619MODULE_DEVICE_TABLE(i2c, tps6598x_id);
620
621static struct i2c_driver tps6598x_i2c_driver = {
622 .driver = {
623 .name = "tps6598x",
624 .of_match_table = tps6598x_of_match,
625 },
626 .probe_new = tps6598x_probe,
627 .remove = tps6598x_remove,
628 .id_table = tps6598x_id,
629};
630module_i2c_driver(tps6598x_i2c_driver);
631
632MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
633MODULE_LICENSE("GPL v2");
634MODULE_DESCRIPTION("TI TPS6598x USB Power Delivery Controller Driver");