1 // SPDX-License-Identifier: GPL-2.0
3 * Driver for TI TPS6598x USB Power Delivery controller family
5 * Copyright (C) 2017, Intel Corporation
6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
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>
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
34 /* TPS_REG_INT_* bits */
35 #define TPS_REG_INT_PLUG_EVENT BIT(3)
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)))
44 /* TPS_REG_SYSTEM_CONF bits */
45 #define TPS_SYSCONF_PORTINFO(c) ((c) & 7)
49 TPS_PORTINFO_SINK_ACCESSORY,
51 TPS_PORTINFO_DRP_UFP_DRD,
53 TPS_PORTINFO_DRP_DFP_DRD,
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)
61 /* TPS_REG_RX_IDENTITY_SOP */
62 struct tps6598x_rx_identity_reg {
64 struct usb_pd_identity identity;
67 /* Standard Task return codes */
68 #define TPS_TASK_TIMEOUT 1
69 #define TPS_TASK_REJECTED 3
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",
85 /* Unrecognized commands will be replaced with "!CMD" */
86 #define INVALID_CMD(_cmd_) (_cmd_ == 0x444d4321)
90 struct regmap *regmap;
91 struct mutex lock; /* device lock */
94 struct typec_port *port;
95 struct typec_partner *partner;
96 struct usb_pd_identity partner_identity;
97 struct usb_role_switch *role_sw;
101 * Max data bytes for Data1, Data2, and other registers. See ch 1.3.2:
102 * https://www.ti.com/lit/ug/slvuan1a/slvuan1a.pdf
104 #define TPS_MAX_LEN 64
107 tps6598x_block_read(struct tps6598x *tps, u8 reg, void *val, size_t len)
109 u8 data[TPS_MAX_LEN + 1];
112 if (len + 1 > sizeof(data))
115 if (!tps->i2c_protocol)
116 return regmap_raw_read(tps->regmap, reg, val, len);
118 ret = regmap_raw_read(tps->regmap, reg, data, sizeof(data));
125 memcpy(val, &data[1], len);
129 static int tps6598x_block_write(struct tps6598x *tps, u8 reg,
130 const void *val, size_t len)
132 u8 data[TPS_MAX_LEN + 1];
134 if (!tps->i2c_protocol)
135 return regmap_raw_write(tps->regmap, reg, val, len);
138 memcpy(&data[1], val, len);
140 return regmap_raw_write(tps->regmap, reg, data, sizeof(data));
143 static inline int tps6598x_read16(struct tps6598x *tps, u8 reg, u16 *val)
145 return tps6598x_block_read(tps, reg, val, sizeof(u16));
148 static inline int tps6598x_read32(struct tps6598x *tps, u8 reg, u32 *val)
150 return tps6598x_block_read(tps, reg, val, sizeof(u32));
153 static inline int tps6598x_read64(struct tps6598x *tps, u8 reg, u64 *val)
155 return tps6598x_block_read(tps, reg, val, sizeof(u64));
158 static inline int tps6598x_write16(struct tps6598x *tps, u8 reg, u16 val)
160 return tps6598x_block_write(tps, reg, &val, sizeof(u16));
163 static inline int tps6598x_write32(struct tps6598x *tps, u8 reg, u32 val)
165 return tps6598x_block_write(tps, reg, &val, sizeof(u32));
168 static inline int tps6598x_write64(struct tps6598x *tps, u8 reg, u64 val)
170 return tps6598x_block_write(tps, reg, &val, sizeof(u64));
174 tps6598x_write_4cc(struct tps6598x *tps, u8 reg, const char *val)
176 return tps6598x_block_write(tps, reg, val, 4);
179 static int tps6598x_read_partner_identity(struct tps6598x *tps)
181 struct tps6598x_rx_identity_reg id;
184 ret = tps6598x_block_read(tps, TPS_REG_RX_IDENTITY_SOP,
189 tps->partner_identity = id.identity;
194 static void tps6598x_set_data_role(struct tps6598x *tps,
195 enum typec_data_role role, bool connected)
197 enum usb_role role_val;
199 if (role == TYPEC_HOST)
200 role_val = USB_ROLE_HOST;
202 role_val = USB_ROLE_DEVICE;
205 role_val = USB_ROLE_NONE;
207 usb_role_switch_set_role(tps->role_sw, role_val);
208 typec_set_data_role(tps->port, role);
211 static int tps6598x_connect(struct tps6598x *tps, u32 status)
213 struct typec_partner_desc desc;
214 enum typec_pwr_opmode mode;
221 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
225 mode = TPS_POWER_STATUS_PWROPMODE(pwr_status);
227 desc.usb_pd = mode == TYPEC_PWR_MODE_PD;
228 desc.accessory = TYPEC_ACCESSORY_NONE; /* XXX: handle accessories */
229 desc.identity = NULL;
232 ret = tps6598x_read_partner_identity(tps);
235 desc.identity = &tps->partner_identity;
238 typec_set_pwr_opmode(tps->port, mode);
239 typec_set_pwr_role(tps->port, TPS_STATUS_PORTROLE(status));
240 typec_set_vconn_role(tps->port, TPS_STATUS_VCONN(status));
241 tps6598x_set_data_role(tps, TPS_STATUS_DATAROLE(status), true);
243 tps->partner = typec_register_partner(tps->port, &desc);
244 if (IS_ERR(tps->partner))
245 return PTR_ERR(tps->partner);
248 typec_partner_set_identity(tps->partner);
253 static void tps6598x_disconnect(struct tps6598x *tps, u32 status)
255 if (!IS_ERR(tps->partner))
256 typec_unregister_partner(tps->partner);
258 typec_set_pwr_opmode(tps->port, TYPEC_PWR_MODE_USB);
259 typec_set_pwr_role(tps->port, TPS_STATUS_PORTROLE(status));
260 typec_set_vconn_role(tps->port, TPS_STATUS_VCONN(status));
261 tps6598x_set_data_role(tps, TPS_STATUS_DATAROLE(status), false);
264 static int tps6598x_exec_cmd(struct tps6598x *tps, const char *cmd,
265 size_t in_len, u8 *in_data,
266 size_t out_len, u8 *out_data)
268 unsigned long timeout;
272 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
275 if (val && !INVALID_CMD(val))
279 ret = tps6598x_block_write(tps, TPS_REG_DATA1,
285 ret = tps6598x_write_4cc(tps, TPS_REG_CMD1, cmd);
289 /* XXX: Using 1s for now, but it may not be enough for every command. */
290 timeout = jiffies + msecs_to_jiffies(1000);
293 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
296 if (INVALID_CMD(val))
299 if (time_is_before_jiffies(timeout))
304 ret = tps6598x_block_read(tps, TPS_REG_DATA1,
310 ret = tps6598x_block_read(tps, TPS_REG_DATA1, &val, sizeof(u8));
316 case TPS_TASK_TIMEOUT:
318 case TPS_TASK_REJECTED:
327 static int tps6598x_dr_set(struct typec_port *port, enum typec_data_role role)
329 const char *cmd = (role == TYPEC_DEVICE) ? "SWUF" : "SWDF";
330 struct tps6598x *tps = typec_get_drvdata(port);
334 mutex_lock(&tps->lock);
336 ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
340 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
344 if (role != TPS_STATUS_DATAROLE(status)) {
349 tps6598x_set_data_role(tps, role, true);
352 mutex_unlock(&tps->lock);
357 static int tps6598x_pr_set(struct typec_port *port, enum typec_role role)
359 const char *cmd = (role == TYPEC_SINK) ? "SWSk" : "SWSr";
360 struct tps6598x *tps = typec_get_drvdata(port);
364 mutex_lock(&tps->lock);
366 ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
370 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
374 if (role != TPS_STATUS_PORTROLE(status)) {
379 typec_set_pwr_role(tps->port, role);
382 mutex_unlock(&tps->lock);
387 static const struct typec_operations tps6598x_ops = {
388 .dr_set = tps6598x_dr_set,
389 .pr_set = tps6598x_pr_set,
392 static irqreturn_t tps6598x_interrupt(int irq, void *data)
394 struct tps6598x *tps = data;
400 mutex_lock(&tps->lock);
402 ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1);
403 ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2);
405 dev_err(tps->dev, "%s: failed to read events\n", __func__);
409 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
411 dev_err(tps->dev, "%s: failed to read status\n", __func__);
415 /* Handle plug insert or removal */
416 if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT) {
417 if (status & TPS_STATUS_PLUG_PRESENT) {
418 ret = tps6598x_connect(tps, status);
421 "failed to register partner\n");
423 tps6598x_disconnect(tps, status);
428 tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1);
429 tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2);
432 mutex_unlock(&tps->lock);
437 static int tps6598x_check_mode(struct tps6598x *tps)
442 ret = tps6598x_read32(tps, TPS_REG_MODE, (void *)mode);
446 switch (match_string(modes, ARRAY_SIZE(modes), mode)) {
450 dev_warn(tps->dev, "dead-battery condition\n");
455 dev_err(tps->dev, "controller in unsupported mode \"%s\"\n",
463 static const struct regmap_config tps6598x_regmap_config = {
466 .max_register = 0x7F,
469 static int tps6598x_probe(struct i2c_client *client)
471 struct typec_capability typec_cap = { };
472 struct tps6598x *tps;
473 struct fwnode_handle *fwnode;
479 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
483 mutex_init(&tps->lock);
484 tps->dev = &client->dev;
486 tps->regmap = devm_regmap_init_i2c(client, &tps6598x_regmap_config);
487 if (IS_ERR(tps->regmap))
488 return PTR_ERR(tps->regmap);
490 ret = tps6598x_read32(tps, TPS_REG_VID, &vid);
495 * Checking can the adapter handle SMBus protocol. If it can not, the
496 * driver needs to take care of block reads separately.
498 * FIXME: Testing with I2C_FUNC_I2C. regmap-i2c uses I2C protocol
499 * unconditionally if the adapter has I2C_FUNC_I2C set.
501 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
502 tps->i2c_protocol = true;
504 /* Make sure the controller has application firmware running */
505 ret = tps6598x_check_mode(tps);
509 ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
513 ret = tps6598x_read32(tps, TPS_REG_SYSTEM_CONF, &conf);
517 fwnode = device_get_named_child_node(&client->dev, "connector");
521 tps->role_sw = fwnode_usb_role_switch_get(fwnode);
522 if (IS_ERR(tps->role_sw)) {
523 ret = PTR_ERR(tps->role_sw);
527 typec_cap.revision = USB_TYPEC_REV_1_2;
528 typec_cap.pd_revision = 0x200;
529 typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE;
530 typec_cap.driver_data = tps;
531 typec_cap.ops = &tps6598x_ops;
532 typec_cap.fwnode = fwnode;
534 switch (TPS_SYSCONF_PORTINFO(conf)) {
535 case TPS_PORTINFO_SINK_ACCESSORY:
536 case TPS_PORTINFO_SINK:
537 typec_cap.type = TYPEC_PORT_SNK;
538 typec_cap.data = TYPEC_PORT_UFP;
540 case TPS_PORTINFO_DRP_UFP_DRD:
541 case TPS_PORTINFO_DRP_DFP_DRD:
542 typec_cap.type = TYPEC_PORT_DRP;
543 typec_cap.data = TYPEC_PORT_DRD;
545 case TPS_PORTINFO_DRP_UFP:
546 typec_cap.type = TYPEC_PORT_DRP;
547 typec_cap.data = TYPEC_PORT_UFP;
549 case TPS_PORTINFO_DRP_DFP:
550 typec_cap.type = TYPEC_PORT_DRP;
551 typec_cap.data = TYPEC_PORT_DFP;
553 case TPS_PORTINFO_SOURCE:
554 typec_cap.type = TYPEC_PORT_SRC;
555 typec_cap.data = TYPEC_PORT_DFP;
562 tps->port = typec_register_port(&client->dev, &typec_cap);
563 if (IS_ERR(tps->port)) {
564 ret = PTR_ERR(tps->port);
568 if (status & TPS_STATUS_PLUG_PRESENT) {
569 ret = tps6598x_connect(tps, status);
571 dev_err(&client->dev, "failed to register partner\n");
574 ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
576 IRQF_SHARED | IRQF_ONESHOT,
577 dev_name(&client->dev), tps);
579 tps6598x_disconnect(tps, 0);
580 typec_unregister_port(tps->port);
584 i2c_set_clientdata(client, tps);
585 fwnode_handle_put(fwnode);
590 usb_role_switch_put(tps->role_sw);
592 fwnode_handle_put(fwnode);
597 static int tps6598x_remove(struct i2c_client *client)
599 struct tps6598x *tps = i2c_get_clientdata(client);
601 tps6598x_disconnect(tps, 0);
602 typec_unregister_port(tps->port);
603 usb_role_switch_put(tps->role_sw);
608 static const struct of_device_id tps6598x_of_match[] = {
609 { .compatible = "ti,tps6598x", },
612 MODULE_DEVICE_TABLE(of, tps6598x_of_match);
614 static const struct i2c_device_id tps6598x_id[] = {
618 MODULE_DEVICE_TABLE(i2c, tps6598x_id);
620 static struct i2c_driver tps6598x_i2c_driver = {
623 .of_match_table = tps6598x_of_match,
625 .probe_new = tps6598x_probe,
626 .remove = tps6598x_remove,
627 .id_table = tps6598x_id,
629 module_i2c_driver(tps6598x_i2c_driver);
631 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
632 MODULE_LICENSE("GPL v2");
633 MODULE_DESCRIPTION("TI TPS6598x USB Power Delivery Controller Driver");