1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2018, Richtek Technology Corporation 4 * 5 * Richtek RT1711H Type-C Chip Driver 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/i2c.h> 11 #include <linux/interrupt.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/usb/tcpm.h> 14 #include <linux/regmap.h> 15 #include "tcpci.h" 16 17 #define RT1711H_VID 0x29CF 18 #define RT1711H_PID 0x1711 19 20 #define RT1711H_RTCTRL8 0x9B 21 22 /* Autoidle timeout = (tout * 2 + 1) * 6.4ms */ 23 #define RT1711H_RTCTRL8_SET(ck300, ship_off, auto_idle, tout) \ 24 (((ck300) << 7) | ((ship_off) << 5) | \ 25 ((auto_idle) << 3) | ((tout) & 0x07)) 26 27 #define RT1711H_RTCTRL11 0x9E 28 29 /* I2C timeout = (tout + 1) * 12.5ms */ 30 #define RT1711H_RTCTRL11_SET(en, tout) \ 31 (((en) << 7) | ((tout) & 0x0F)) 32 33 #define RT1711H_RTCTRL13 0xA0 34 #define RT1711H_RTCTRL14 0xA1 35 #define RT1711H_RTCTRL15 0xA2 36 #define RT1711H_RTCTRL16 0xA3 37 38 struct rt1711h_chip { 39 struct tcpci_data data; 40 struct tcpci *tcpci; 41 struct device *dev; 42 }; 43 44 static int rt1711h_read16(struct rt1711h_chip *chip, unsigned int reg, u16 *val) 45 { 46 return regmap_raw_read(chip->data.regmap, reg, val, sizeof(u16)); 47 } 48 49 static int rt1711h_write16(struct rt1711h_chip *chip, unsigned int reg, u16 val) 50 { 51 return regmap_raw_write(chip->data.regmap, reg, &val, sizeof(u16)); 52 } 53 54 static int rt1711h_read8(struct rt1711h_chip *chip, unsigned int reg, u8 *val) 55 { 56 return regmap_raw_read(chip->data.regmap, reg, val, sizeof(u8)); 57 } 58 59 static int rt1711h_write8(struct rt1711h_chip *chip, unsigned int reg, u8 val) 60 { 61 return regmap_raw_write(chip->data.regmap, reg, &val, sizeof(u8)); 62 } 63 64 static const struct regmap_config rt1711h_regmap_config = { 65 .reg_bits = 8, 66 .val_bits = 8, 67 68 .max_register = 0xFF, /* 0x80 .. 0xFF are vendor defined */ 69 }; 70 71 static struct rt1711h_chip *tdata_to_rt1711h(struct tcpci_data *tdata) 72 { 73 return container_of(tdata, struct rt1711h_chip, data); 74 } 75 76 static int rt1711h_init(struct tcpci *tcpci, struct tcpci_data *tdata) 77 { 78 int ret; 79 struct rt1711h_chip *chip = tdata_to_rt1711h(tdata); 80 81 /* CK 300K from 320K, shipping off, auto_idle enable, tout = 32ms */ 82 ret = rt1711h_write8(chip, RT1711H_RTCTRL8, 83 RT1711H_RTCTRL8_SET(0, 1, 1, 2)); 84 if (ret < 0) 85 return ret; 86 87 /* I2C reset : (val + 1) * 12.5ms */ 88 ret = rt1711h_write8(chip, RT1711H_RTCTRL11, 89 RT1711H_RTCTRL11_SET(1, 0x0F)); 90 if (ret < 0) 91 return ret; 92 93 /* tTCPCfilter : (26.7 * val) us */ 94 ret = rt1711h_write8(chip, RT1711H_RTCTRL14, 0x0F); 95 if (ret < 0) 96 return ret; 97 98 /* tDRP : (51.2 + 6.4 * val) ms */ 99 ret = rt1711h_write8(chip, RT1711H_RTCTRL15, 0x04); 100 if (ret < 0) 101 return ret; 102 103 /* dcSRC.DRP : 33% */ 104 return rt1711h_write16(chip, RT1711H_RTCTRL16, 330); 105 } 106 107 static int rt1711h_set_vconn(struct tcpci *tcpci, struct tcpci_data *tdata, 108 bool enable) 109 { 110 struct rt1711h_chip *chip = tdata_to_rt1711h(tdata); 111 112 return rt1711h_write8(chip, RT1711H_RTCTRL8, 113 RT1711H_RTCTRL8_SET(0, 1, !enable, 2)); 114 } 115 116 static int rt1711h_start_drp_toggling(struct tcpci *tcpci, 117 struct tcpci_data *tdata, 118 enum typec_cc_status cc) 119 { 120 struct rt1711h_chip *chip = tdata_to_rt1711h(tdata); 121 int ret; 122 unsigned int reg = 0; 123 124 switch (cc) { 125 default: 126 case TYPEC_CC_RP_DEF: 127 reg |= (TCPC_ROLE_CTRL_RP_VAL_DEF << 128 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 129 break; 130 case TYPEC_CC_RP_1_5: 131 reg |= (TCPC_ROLE_CTRL_RP_VAL_1_5 << 132 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 133 break; 134 case TYPEC_CC_RP_3_0: 135 reg |= (TCPC_ROLE_CTRL_RP_VAL_3_0 << 136 TCPC_ROLE_CTRL_RP_VAL_SHIFT); 137 break; 138 } 139 140 if (cc == TYPEC_CC_RD) 141 reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | 142 (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); 143 else 144 reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) | 145 (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT); 146 147 ret = rt1711h_write8(chip, TCPC_ROLE_CTRL, reg); 148 if (ret < 0) 149 return ret; 150 usleep_range(500, 1000); 151 152 return 0; 153 } 154 155 static irqreturn_t rt1711h_irq(int irq, void *dev_id) 156 { 157 int ret; 158 u16 alert; 159 u8 status; 160 struct rt1711h_chip *chip = dev_id; 161 162 if (!chip->tcpci) 163 return IRQ_HANDLED; 164 165 ret = rt1711h_read16(chip, TCPC_ALERT, &alert); 166 if (ret < 0) 167 goto out; 168 169 if (alert & TCPC_ALERT_CC_STATUS) { 170 ret = rt1711h_read8(chip, TCPC_CC_STATUS, &status); 171 if (ret < 0) 172 goto out; 173 /* Clear cc change event triggered by starting toggling */ 174 if (status & TCPC_CC_STATUS_TOGGLING) 175 rt1711h_write8(chip, TCPC_ALERT, TCPC_ALERT_CC_STATUS); 176 } 177 178 out: 179 return tcpci_irq(chip->tcpci); 180 } 181 182 static int rt1711h_sw_reset(struct rt1711h_chip *chip) 183 { 184 int ret; 185 186 ret = rt1711h_write8(chip, RT1711H_RTCTRL13, 0x01); 187 if (ret < 0) 188 return ret; 189 190 usleep_range(1000, 2000); 191 return 0; 192 } 193 194 static int rt1711h_check_revision(struct i2c_client *i2c) 195 { 196 int ret; 197 198 ret = i2c_smbus_read_word_data(i2c, TCPC_VENDOR_ID); 199 if (ret < 0) 200 return ret; 201 if (ret != RT1711H_VID) { 202 dev_err(&i2c->dev, "vid is not correct, 0x%04x\n", ret); 203 return -ENODEV; 204 } 205 ret = i2c_smbus_read_word_data(i2c, TCPC_PRODUCT_ID); 206 if (ret < 0) 207 return ret; 208 if (ret != RT1711H_PID) { 209 dev_err(&i2c->dev, "pid is not correct, 0x%04x\n", ret); 210 return -ENODEV; 211 } 212 return 0; 213 } 214 215 static int rt1711h_probe(struct i2c_client *client, 216 const struct i2c_device_id *i2c_id) 217 { 218 int ret; 219 struct rt1711h_chip *chip; 220 221 ret = rt1711h_check_revision(client); 222 if (ret < 0) { 223 dev_err(&client->dev, "check vid/pid fail\n"); 224 return ret; 225 } 226 227 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 228 if (!chip) 229 return -ENOMEM; 230 231 chip->data.regmap = devm_regmap_init_i2c(client, 232 &rt1711h_regmap_config); 233 if (IS_ERR(chip->data.regmap)) 234 return PTR_ERR(chip->data.regmap); 235 236 chip->dev = &client->dev; 237 i2c_set_clientdata(client, chip); 238 239 ret = rt1711h_sw_reset(chip); 240 if (ret < 0) 241 return ret; 242 243 /* Disable chip interrupts before requesting irq */ 244 ret = rt1711h_write16(chip, TCPC_ALERT_MASK, 0); 245 if (ret < 0) 246 return ret; 247 248 chip->data.init = rt1711h_init; 249 chip->data.set_vconn = rt1711h_set_vconn; 250 chip->data.start_drp_toggling = rt1711h_start_drp_toggling; 251 chip->tcpci = tcpci_register_port(chip->dev, &chip->data); 252 if (IS_ERR_OR_NULL(chip->tcpci)) 253 return PTR_ERR(chip->tcpci); 254 255 ret = devm_request_threaded_irq(chip->dev, client->irq, NULL, 256 rt1711h_irq, 257 IRQF_ONESHOT | IRQF_TRIGGER_LOW, 258 dev_name(chip->dev), chip); 259 if (ret < 0) 260 return ret; 261 enable_irq_wake(client->irq); 262 263 return 0; 264 } 265 266 static int rt1711h_remove(struct i2c_client *client) 267 { 268 struct rt1711h_chip *chip = i2c_get_clientdata(client); 269 270 tcpci_unregister_port(chip->tcpci); 271 return 0; 272 } 273 274 static const struct i2c_device_id rt1711h_id[] = { 275 { "rt1711h", 0 }, 276 { } 277 }; 278 MODULE_DEVICE_TABLE(i2c, rt1711h_id); 279 280 #ifdef CONFIG_OF 281 static const struct of_device_id rt1711h_of_match[] = { 282 { .compatible = "richtek,rt1711h", }, 283 {}, 284 }; 285 MODULE_DEVICE_TABLE(of, rt1711h_of_match); 286 #endif 287 288 static struct i2c_driver rt1711h_i2c_driver = { 289 .driver = { 290 .name = "rt1711h", 291 .of_match_table = of_match_ptr(rt1711h_of_match), 292 }, 293 .probe = rt1711h_probe, 294 .remove = rt1711h_remove, 295 .id_table = rt1711h_id, 296 }; 297 module_i2c_driver(rt1711h_i2c_driver); 298 299 MODULE_AUTHOR("ShuFan Lee <shufan_lee@richtek.com>"); 300 MODULE_DESCRIPTION("RT1711H USB Type-C Port Controller Interface Driver"); 301 MODULE_LICENSE("GPL"); 302