| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Heikki Krogerus | 2389 | 86.97% | 6 | 37.50% |
| Bryan O'Donoghue | 227 | 8.26% | 2 | 12.50% |
| Nikolaus Voss | 95 | 3.46% | 3 | 18.75% |
| Kees Cook | 23 | 0.84% | 1 | 6.25% |
| Andy Shevchenko | 10 | 0.36% | 1 | 6.25% |
| Greg Kroah-Hartman | 2 | 0.07% | 2 | 12.50% |
| Alexander A. Klimov | 1 | 0.04% | 1 | 6.25% |
| Total | 2747 | 16 |
// SPDX-License-Identifier: GPL-2.0 /* * Driver for TI TPS6598x USB Power Delivery controller family * * Copyright (C) 2017, Intel Corporation * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> */ #include <linux/i2c.h> #include <linux/acpi.h> #include <linux/module.h> #include <linux/regmap.h> #include <linux/interrupt.h> #include <linux/usb/typec.h> #include <linux/usb/role.h> /* Register offsets */ #define TPS_REG_VID 0x00 #define TPS_REG_MODE 0x03 #define TPS_REG_CMD1 0x08 #define TPS_REG_DATA1 0x09 #define TPS_REG_INT_EVENT1 0x14 #define TPS_REG_INT_EVENT2 0x15 #define TPS_REG_INT_MASK1 0x16 #define TPS_REG_INT_MASK2 0x17 #define TPS_REG_INT_CLEAR1 0x18 #define TPS_REG_INT_CLEAR2 0x19 #define TPS_REG_STATUS 0x1a #define TPS_REG_SYSTEM_CONF 0x28 #define TPS_REG_CTRL_CONF 0x29 #define TPS_REG_POWER_STATUS 0x3f #define TPS_REG_RX_IDENTITY_SOP 0x48 /* TPS_REG_INT_* bits */ #define TPS_REG_INT_PLUG_EVENT BIT(3) /* TPS_REG_STATUS bits */ #define TPS_STATUS_PLUG_PRESENT BIT(0) #define TPS_STATUS_ORIENTATION BIT(4) #define TPS_STATUS_PORTROLE(s) (!!((s) & BIT(5))) #define TPS_STATUS_DATAROLE(s) (!!((s) & BIT(6))) #define TPS_STATUS_VCONN(s) (!!((s) & BIT(7))) /* TPS_REG_SYSTEM_CONF bits */ #define TPS_SYSCONF_PORTINFO(c) ((c) & 7) enum { TPS_PORTINFO_SINK, TPS_PORTINFO_SINK_ACCESSORY, TPS_PORTINFO_DRP_UFP, TPS_PORTINFO_DRP_UFP_DRD, TPS_PORTINFO_DRP_DFP, TPS_PORTINFO_DRP_DFP_DRD, TPS_PORTINFO_SOURCE, }; /* TPS_REG_POWER_STATUS bits */ #define TPS_POWER_STATUS_SOURCESINK BIT(1) #define TPS_POWER_STATUS_PWROPMODE(p) (((p) & GENMASK(3, 2)) >> 2) /* TPS_REG_RX_IDENTITY_SOP */ struct tps6598x_rx_identity_reg { u8 status; struct usb_pd_identity identity; u32 vdo[3]; } __packed; /* Standard Task return codes */ #define TPS_TASK_TIMEOUT 1 #define TPS_TASK_REJECTED 3 enum { TPS_MODE_APP, TPS_MODE_BOOT, TPS_MODE_BIST, TPS_MODE_DISC, }; static const char *const modes[] = { [TPS_MODE_APP] = "APP ", [TPS_MODE_BOOT] = "BOOT", [TPS_MODE_BIST] = "BIST", [TPS_MODE_DISC] = "DISC", }; /* Unrecognized commands will be replaced with "!CMD" */ #define INVALID_CMD(_cmd_) (_cmd_ == 0x444d4321) struct tps6598x { struct device *dev; struct regmap *regmap; struct mutex lock; /* device lock */ u8 i2c_protocol:1; struct typec_port *port; struct typec_partner *partner; struct usb_pd_identity partner_identity; struct usb_role_switch *role_sw; }; /* * Max data bytes for Data1, Data2, and other registers. See ch 1.3.2: * https://www.ti.com/lit/ug/slvuan1a/slvuan1a.pdf */ #define TPS_MAX_LEN 64 static int tps6598x_block_read(struct tps6598x *tps, u8 reg, void *val, size_t len) { u8 data[TPS_MAX_LEN + 1]; int ret; if (WARN_ON(len + 1 > sizeof(data))) return -EINVAL; if (!tps->i2c_protocol) return regmap_raw_read(tps->regmap, reg, val, len); ret = regmap_raw_read(tps->regmap, reg, data, sizeof(data)); if (ret) return ret; if (data[0] < len) return -EIO; memcpy(val, &data[1], len); return 0; } static int tps6598x_block_write(struct tps6598x *tps, u8 reg, const void *val, size_t len) { u8 data[TPS_MAX_LEN + 1]; if (!tps->i2c_protocol) return regmap_raw_write(tps->regmap, reg, val, len); data[0] = len; memcpy(&data[1], val, len); return regmap_raw_write(tps->regmap, reg, data, sizeof(data)); } static inline int tps6598x_read16(struct tps6598x *tps, u8 reg, u16 *val) { return tps6598x_block_read(tps, reg, val, sizeof(u16)); } static inline int tps6598x_read32(struct tps6598x *tps, u8 reg, u32 *val) { return tps6598x_block_read(tps, reg, val, sizeof(u32)); } static inline int tps6598x_read64(struct tps6598x *tps, u8 reg, u64 *val) { return tps6598x_block_read(tps, reg, val, sizeof(u64)); } static inline int tps6598x_write16(struct tps6598x *tps, u8 reg, u16 val) { return tps6598x_block_write(tps, reg, &val, sizeof(u16)); } static inline int tps6598x_write32(struct tps6598x *tps, u8 reg, u32 val) { return tps6598x_block_write(tps, reg, &val, sizeof(u32)); } static inline int tps6598x_write64(struct tps6598x *tps, u8 reg, u64 val) { return tps6598x_block_write(tps, reg, &val, sizeof(u64)); } static inline int tps6598x_write_4cc(struct tps6598x *tps, u8 reg, const char *val) { return tps6598x_block_write(tps, reg, val, 4); } static int tps6598x_read_partner_identity(struct tps6598x *tps) { struct tps6598x_rx_identity_reg id; int ret; ret = tps6598x_block_read(tps, TPS_REG_RX_IDENTITY_SOP, &id, sizeof(id)); if (ret) return ret; tps->partner_identity = id.identity; return 0; } static void tps6598x_set_data_role(struct tps6598x *tps, enum typec_data_role role, bool connected) { enum usb_role role_val; if (role == TYPEC_HOST) role_val = USB_ROLE_HOST; else role_val = USB_ROLE_DEVICE; if (!connected) role_val = USB_ROLE_NONE; usb_role_switch_set_role(tps->role_sw, role_val); typec_set_data_role(tps->port, role); } static int tps6598x_connect(struct tps6598x *tps, u32 status) { struct typec_partner_desc desc; enum typec_pwr_opmode mode; u16 pwr_status; int ret; if (tps->partner) return 0; ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status); if (ret < 0) return ret; mode = TPS_POWER_STATUS_PWROPMODE(pwr_status); desc.usb_pd = mode == TYPEC_PWR_MODE_PD; desc.accessory = TYPEC_ACCESSORY_NONE; /* XXX: handle accessories */ desc.identity = NULL; if (desc.usb_pd) { ret = tps6598x_read_partner_identity(tps); if (ret) return ret; desc.identity = &tps->partner_identity; } typec_set_pwr_opmode(tps->port, mode); typec_set_pwr_role(tps->port, TPS_STATUS_PORTROLE(status)); typec_set_vconn_role(tps->port, TPS_STATUS_VCONN(status)); tps6598x_set_data_role(tps, TPS_STATUS_DATAROLE(status), true); tps->partner = typec_register_partner(tps->port, &desc); if (IS_ERR(tps->partner)) return PTR_ERR(tps->partner); if (desc.identity) typec_partner_set_identity(tps->partner); return 0; } static void tps6598x_disconnect(struct tps6598x *tps, u32 status) { if (!IS_ERR(tps->partner)) typec_unregister_partner(tps->partner); tps->partner = NULL; typec_set_pwr_opmode(tps->port, TYPEC_PWR_MODE_USB); typec_set_pwr_role(tps->port, TPS_STATUS_PORTROLE(status)); typec_set_vconn_role(tps->port, TPS_STATUS_VCONN(status)); tps6598x_set_data_role(tps, TPS_STATUS_DATAROLE(status), false); } static int tps6598x_exec_cmd(struct tps6598x *tps, const char *cmd, size_t in_len, u8 *in_data, size_t out_len, u8 *out_data) { unsigned long timeout; u32 val; int ret; ret = tps6598x_read32(tps, TPS_REG_CMD1, &val); if (ret) return ret; if (val && !INVALID_CMD(val)) return -EBUSY; if (in_len) { ret = tps6598x_block_write(tps, TPS_REG_DATA1, in_data, in_len); if (ret) return ret; } ret = tps6598x_write_4cc(tps, TPS_REG_CMD1, cmd); if (ret < 0) return ret; /* XXX: Using 1s for now, but it may not be enough for every command. */ timeout = jiffies + msecs_to_jiffies(1000); do { ret = tps6598x_read32(tps, TPS_REG_CMD1, &val); if (ret) return ret; if (INVALID_CMD(val)) return -EINVAL; if (time_is_before_jiffies(timeout)) return -ETIMEDOUT; } while (val); if (out_len) { ret = tps6598x_block_read(tps, TPS_REG_DATA1, out_data, out_len); if (ret) return ret; val = out_data[0]; } else { ret = tps6598x_block_read(tps, TPS_REG_DATA1, &val, sizeof(u8)); if (ret) return ret; } switch (val) { case TPS_TASK_TIMEOUT: return -ETIMEDOUT; case TPS_TASK_REJECTED: return -EPERM; default: break; } return 0; } static int tps6598x_dr_set(struct typec_port *port, enum typec_data_role role) { const char *cmd = (role == TYPEC_DEVICE) ? "SWUF" : "SWDF"; struct tps6598x *tps = typec_get_drvdata(port); u32 status; int ret; mutex_lock(&tps->lock); ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL); if (ret) goto out_unlock; ret = tps6598x_read32(tps, TPS_REG_STATUS, &status); if (ret) goto out_unlock; if (role != TPS_STATUS_DATAROLE(status)) { ret = -EPROTO; goto out_unlock; } tps6598x_set_data_role(tps, role, true); out_unlock: mutex_unlock(&tps->lock); return ret; } static int tps6598x_pr_set(struct typec_port *port, enum typec_role role) { const char *cmd = (role == TYPEC_SINK) ? "SWSk" : "SWSr"; struct tps6598x *tps = typec_get_drvdata(port); u32 status; int ret; mutex_lock(&tps->lock); ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL); if (ret) goto out_unlock; ret = tps6598x_read32(tps, TPS_REG_STATUS, &status); if (ret) goto out_unlock; if (role != TPS_STATUS_PORTROLE(status)) { ret = -EPROTO; goto out_unlock; } typec_set_pwr_role(tps->port, role); out_unlock: mutex_unlock(&tps->lock); return ret; } static const struct typec_operations tps6598x_ops = { .dr_set = tps6598x_dr_set, .pr_set = tps6598x_pr_set, }; static irqreturn_t tps6598x_interrupt(int irq, void *data) { struct tps6598x *tps = data; u64 event1; u64 event2; u32 status; int ret; mutex_lock(&tps->lock); ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1); ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2); if (ret) { dev_err(tps->dev, "%s: failed to read events\n", __func__); goto err_unlock; } ret = tps6598x_read32(tps, TPS_REG_STATUS, &status); if (ret) { dev_err(tps->dev, "%s: failed to read status\n", __func__); goto err_clear_ints; } /* Handle plug insert or removal */ if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT) { if (status & TPS_STATUS_PLUG_PRESENT) { ret = tps6598x_connect(tps, status); if (ret) dev_err(tps->dev, "failed to register partner\n"); } else { tps6598x_disconnect(tps, status); } } err_clear_ints: tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1); tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2); err_unlock: mutex_unlock(&tps->lock); return IRQ_HANDLED; } static int tps6598x_check_mode(struct tps6598x *tps) { char mode[5] = { }; int ret; ret = tps6598x_read32(tps, TPS_REG_MODE, (void *)mode); if (ret) return ret; switch (match_string(modes, ARRAY_SIZE(modes), mode)) { case TPS_MODE_APP: return 0; case TPS_MODE_BOOT: dev_warn(tps->dev, "dead-battery condition\n"); return 0; case TPS_MODE_BIST: case TPS_MODE_DISC: default: dev_err(tps->dev, "controller in unsupported mode \"%s\"\n", mode); break; } return -ENODEV; } static const struct regmap_config tps6598x_regmap_config = { .reg_bits = 8, .val_bits = 8, .max_register = 0x7F, }; static int tps6598x_probe(struct i2c_client *client) { struct typec_capability typec_cap = { }; struct tps6598x *tps; struct fwnode_handle *fwnode; u32 status; u32 conf; u32 vid; int ret; tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); if (!tps) return -ENOMEM; mutex_init(&tps->lock); tps->dev = &client->dev; tps->regmap = devm_regmap_init_i2c(client, &tps6598x_regmap_config); if (IS_ERR(tps->regmap)) return PTR_ERR(tps->regmap); ret = tps6598x_read32(tps, TPS_REG_VID, &vid); if (ret < 0 || !vid) return -ENODEV; /* * Checking can the adapter handle SMBus protocol. If it can not, the * driver needs to take care of block reads separately. * * FIXME: Testing with I2C_FUNC_I2C. regmap-i2c uses I2C protocol * unconditionally if the adapter has I2C_FUNC_I2C set. */ if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) tps->i2c_protocol = true; /* Make sure the controller has application firmware running */ ret = tps6598x_check_mode(tps); if (ret) return ret; ret = tps6598x_read32(tps, TPS_REG_STATUS, &status); if (ret < 0) return ret; ret = tps6598x_read32(tps, TPS_REG_SYSTEM_CONF, &conf); if (ret < 0) return ret; fwnode = device_get_named_child_node(&client->dev, "connector"); if (IS_ERR(fwnode)) return PTR_ERR(fwnode); tps->role_sw = fwnode_usb_role_switch_get(fwnode); if (IS_ERR(tps->role_sw)) { ret = PTR_ERR(tps->role_sw); goto err_fwnode_put; } typec_cap.revision = USB_TYPEC_REV_1_2; typec_cap.pd_revision = 0x200; typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE; typec_cap.driver_data = tps; typec_cap.ops = &tps6598x_ops; typec_cap.fwnode = fwnode; switch (TPS_SYSCONF_PORTINFO(conf)) { case TPS_PORTINFO_SINK_ACCESSORY: case TPS_PORTINFO_SINK: typec_cap.type = TYPEC_PORT_SNK; typec_cap.data = TYPEC_PORT_UFP; break; case TPS_PORTINFO_DRP_UFP_DRD: case TPS_PORTINFO_DRP_DFP_DRD: typec_cap.type = TYPEC_PORT_DRP; typec_cap.data = TYPEC_PORT_DRD; break; case TPS_PORTINFO_DRP_UFP: typec_cap.type = TYPEC_PORT_DRP; typec_cap.data = TYPEC_PORT_UFP; break; case TPS_PORTINFO_DRP_DFP: typec_cap.type = TYPEC_PORT_DRP; typec_cap.data = TYPEC_PORT_DFP; break; case TPS_PORTINFO_SOURCE: typec_cap.type = TYPEC_PORT_SRC; typec_cap.data = TYPEC_PORT_DFP; break; default: ret = -ENODEV; goto err_role_put; } tps->port = typec_register_port(&client->dev, &typec_cap); if (IS_ERR(tps->port)) { ret = PTR_ERR(tps->port); goto err_role_put; } fwnode_handle_put(fwnode); if (status & TPS_STATUS_PLUG_PRESENT) { ret = tps6598x_connect(tps, status); if (ret) dev_err(&client->dev, "failed to register partner\n"); } ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, tps6598x_interrupt, IRQF_SHARED | IRQF_ONESHOT, dev_name(&client->dev), tps); if (ret) { tps6598x_disconnect(tps, 0); typec_unregister_port(tps->port); goto err_role_put; } i2c_set_clientdata(client, tps); return 0; err_role_put: usb_role_switch_put(tps->role_sw); err_fwnode_put: fwnode_handle_put(fwnode); return ret; } static int tps6598x_remove(struct i2c_client *client) { struct tps6598x *tps = i2c_get_clientdata(client); tps6598x_disconnect(tps, 0); typec_unregister_port(tps->port); usb_role_switch_put(tps->role_sw); return 0; } static const struct of_device_id tps6598x_of_match[] = { { .compatible = "ti,tps6598x", }, {} }; MODULE_DEVICE_TABLE(of, tps6598x_of_match); static const struct i2c_device_id tps6598x_id[] = { { "tps6598x" }, { } }; MODULE_DEVICE_TABLE(i2c, tps6598x_id); static struct i2c_driver tps6598x_i2c_driver = { .driver = { .name = "tps6598x", .of_match_table = tps6598x_of_match, }, .probe_new = tps6598x_probe, .remove = tps6598x_remove, .id_table = tps6598x_id, }; module_i2c_driver(tps6598x_i2c_driver); MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("TI TPS6598x USB Power Delivery Controller Driver");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1