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