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/bits.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/i2c.h>
12 #include <linux/interrupt.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/usb/tcpci.h>
15 #include <linux/usb/tcpm.h>
16 #include <linux/regmap.h>
17 #include <linux/regulator/consumer.h>
18 
19 #define RT1711H_VID		0x29CF
20 #define RT1711H_PID		0x1711
21 #define RT1711H_DID		0x2171
22 #define RT1715_DID		0x2173
23 
24 #define RT1711H_PHYCTRL1	0x80
25 #define RT1711H_PHYCTRL2	0x81
26 
27 #define RT1711H_RTCTRL4		0x93
28 /* rx threshold of rd/rp: 1b0 for level 0.4V/0.7V, 1b1 for 0.35V/0.75V */
29 #define RT1711H_BMCIO_RXDZSEL	BIT(0)
30 
31 #define RT1711H_RTCTRL8		0x9B
32 /* Autoidle timeout = (tout * 2 + 1) * 6.4ms */
33 #define RT1711H_RTCTRL8_SET(ck300, ship_off, auto_idle, tout) \
34 			    (((ck300) << 7) | ((ship_off) << 5) | \
35 			    ((auto_idle) << 3) | ((tout) & 0x07))
36 #define RT1711H_AUTOIDLEEN	BIT(3)
37 #define RT1711H_ENEXTMSG	BIT(4)
38 
39 #define RT1711H_RTCTRL11	0x9E
40 
41 /* I2C timeout = (tout + 1) * 12.5ms */
42 #define RT1711H_RTCTRL11_SET(en, tout) \
43 			     (((en) << 7) | ((tout) & 0x0F))
44 
45 #define RT1711H_RTCTRL13	0xA0
46 #define RT1711H_RTCTRL14	0xA1
47 #define RT1711H_RTCTRL15	0xA2
48 #define RT1711H_RTCTRL16	0xA3
49 
50 #define RT1711H_RTCTRL18	0xAF
51 /* 1b0 as fixed rx threshold of rd/rp 0.55V, 1b1 depends on RTCRTL4[0] */
52 #define BMCIO_RXDZEN	BIT(0)
53 
54 struct rt1711h_chip {
55 	struct tcpci_data data;
56 	struct tcpci *tcpci;
57 	struct device *dev;
58 	struct regulator *vbus;
59 	bool src_en;
60 	u16 did;
61 };
62 
rt1711h_read16(struct rt1711h_chip * chip,unsigned int reg,u16 * val)63 static int rt1711h_read16(struct rt1711h_chip *chip, unsigned int reg, u16 *val)
64 {
65 	return regmap_raw_read(chip->data.regmap, reg, val, sizeof(u16));
66 }
67 
rt1711h_write16(struct rt1711h_chip * chip,unsigned int reg,u16 val)68 static int rt1711h_write16(struct rt1711h_chip *chip, unsigned int reg, u16 val)
69 {
70 	return regmap_raw_write(chip->data.regmap, reg, &val, sizeof(u16));
71 }
72 
rt1711h_read8(struct rt1711h_chip * chip,unsigned int reg,u8 * val)73 static int rt1711h_read8(struct rt1711h_chip *chip, unsigned int reg, u8 *val)
74 {
75 	return regmap_raw_read(chip->data.regmap, reg, val, sizeof(u8));
76 }
77 
rt1711h_write8(struct rt1711h_chip * chip,unsigned int reg,u8 val)78 static int rt1711h_write8(struct rt1711h_chip *chip, unsigned int reg, u8 val)
79 {
80 	return regmap_raw_write(chip->data.regmap, reg, &val, sizeof(u8));
81 }
82 
83 static const struct regmap_config rt1711h_regmap_config = {
84 	.reg_bits = 8,
85 	.val_bits = 8,
86 
87 	.max_register = 0xFF, /* 0x80 .. 0xFF are vendor defined */
88 };
89 
tdata_to_rt1711h(struct tcpci_data * tdata)90 static struct rt1711h_chip *tdata_to_rt1711h(struct tcpci_data *tdata)
91 {
92 	return container_of(tdata, struct rt1711h_chip, data);
93 }
94 
rt1711h_init(struct tcpci * tcpci,struct tcpci_data * tdata)95 static int rt1711h_init(struct tcpci *tcpci, struct tcpci_data *tdata)
96 {
97 	struct rt1711h_chip *chip = tdata_to_rt1711h(tdata);
98 	struct regmap *regmap = chip->data.regmap;
99 	int ret;
100 
101 	/* CK 300K from 320K, shipping off, auto_idle enable, tout = 32ms */
102 	ret = rt1711h_write8(chip, RT1711H_RTCTRL8,
103 			     RT1711H_RTCTRL8_SET(0, 1, 1, 2));
104 	if (ret < 0)
105 		return ret;
106 
107 	/* Enable PD30 extended message for RT1715 */
108 	if (chip->did == RT1715_DID) {
109 		ret = regmap_update_bits(regmap, RT1711H_RTCTRL8,
110 					 RT1711H_ENEXTMSG, RT1711H_ENEXTMSG);
111 		if (ret < 0)
112 			return ret;
113 	}
114 
115 	/* I2C reset : (val + 1) * 12.5ms */
116 	ret = rt1711h_write8(chip, RT1711H_RTCTRL11,
117 			     RT1711H_RTCTRL11_SET(1, 0x0F));
118 	if (ret < 0)
119 		return ret;
120 
121 	/* tTCPCfilter : (26.7 * val) us */
122 	ret = rt1711h_write8(chip, RT1711H_RTCTRL14, 0x0F);
123 	if (ret < 0)
124 		return ret;
125 
126 	/*  tDRP : (51.2 + 6.4 * val) ms */
127 	ret = rt1711h_write8(chip, RT1711H_RTCTRL15, 0x04);
128 	if (ret < 0)
129 		return ret;
130 
131 	/* dcSRC.DRP : 33% */
132 	ret = rt1711h_write16(chip, RT1711H_RTCTRL16, 330);
133 	if (ret < 0)
134 		return ret;
135 
136 	/* Enable phy discard retry, retry count 7, rx filter deglitch 100 us */
137 	ret = rt1711h_write8(chip, RT1711H_PHYCTRL1, 0xF1);
138 	if (ret < 0)
139 		return ret;
140 
141 	/* Decrease wait time of BMC-encoded 1 bit from 2.67us to 2.55us */
142 	/* wait time : (val * .4167) us */
143 	return rt1711h_write8(chip, RT1711H_PHYCTRL2, 62);
144 }
145 
rt1711h_set_vbus(struct tcpci * tcpci,struct tcpci_data * tdata,bool src,bool snk)146 static int rt1711h_set_vbus(struct tcpci *tcpci, struct tcpci_data *tdata,
147 			    bool src, bool snk)
148 {
149 	struct rt1711h_chip *chip = tdata_to_rt1711h(tdata);
150 	int ret;
151 
152 	if (chip->src_en == src)
153 		return 0;
154 
155 	if (src)
156 		ret = regulator_enable(chip->vbus);
157 	else
158 		ret = regulator_disable(chip->vbus);
159 
160 	if (!ret)
161 		chip->src_en = src;
162 	return ret;
163 }
164 
rt1711h_set_vconn(struct tcpci * tcpci,struct tcpci_data * tdata,bool enable)165 static int rt1711h_set_vconn(struct tcpci *tcpci, struct tcpci_data *tdata,
166 			     bool enable)
167 {
168 	struct rt1711h_chip *chip = tdata_to_rt1711h(tdata);
169 
170 	return regmap_update_bits(chip->data.regmap, RT1711H_RTCTRL8,
171 				  RT1711H_AUTOIDLEEN, enable ? 0 : RT1711H_AUTOIDLEEN);
172 }
173 
174 /*
175  * Selects the CC PHY noise filter voltage level according to the remote current
176  * CC voltage level.
177  *
178  * @status: The port's current cc status read from IC
179  * Return 0 if writes succeed; failure code otherwise
180  */
rt1711h_init_cc_params(struct rt1711h_chip * chip,u8 status)181 static inline int rt1711h_init_cc_params(struct rt1711h_chip *chip, u8 status)
182 {
183 	int ret, cc1, cc2;
184 	u8 role = 0;
185 	u32 rxdz_en, rxdz_sel;
186 
187 	ret = rt1711h_read8(chip, TCPC_ROLE_CTRL, &role);
188 	if (ret < 0)
189 		return ret;
190 
191 	cc1 = tcpci_to_typec_cc((status >> TCPC_CC_STATUS_CC1_SHIFT) &
192 				TCPC_CC_STATUS_CC1_MASK,
193 				status & TCPC_CC_STATUS_TERM ||
194 				tcpc_presenting_rd(role, CC1));
195 	cc2 = tcpci_to_typec_cc((status >> TCPC_CC_STATUS_CC2_SHIFT) &
196 				TCPC_CC_STATUS_CC2_MASK,
197 				status & TCPC_CC_STATUS_TERM ||
198 				tcpc_presenting_rd(role, CC2));
199 
200 	if ((cc1 >= TYPEC_CC_RP_1_5 && cc2 < TYPEC_CC_RP_DEF) ||
201 	    (cc2 >= TYPEC_CC_RP_1_5 && cc1 < TYPEC_CC_RP_DEF)) {
202 		rxdz_en = BMCIO_RXDZEN;
203 		if (chip->did == RT1715_DID)
204 			rxdz_sel = RT1711H_BMCIO_RXDZSEL;
205 		else
206 			rxdz_sel = 0;
207 	} else {
208 		rxdz_en = 0;
209 		rxdz_sel = RT1711H_BMCIO_RXDZSEL;
210 	}
211 
212 	ret = regmap_update_bits(chip->data.regmap, RT1711H_RTCTRL18,
213 				 BMCIO_RXDZEN, rxdz_en);
214 	if (ret < 0)
215 		return ret;
216 
217 	return regmap_update_bits(chip->data.regmap, RT1711H_RTCTRL4,
218 				  RT1711H_BMCIO_RXDZSEL, rxdz_sel);
219 }
220 
rt1711h_start_drp_toggling(struct tcpci * tcpci,struct tcpci_data * tdata,enum typec_cc_status cc)221 static int rt1711h_start_drp_toggling(struct tcpci *tcpci,
222 				      struct tcpci_data *tdata,
223 				      enum typec_cc_status cc)
224 {
225 	struct rt1711h_chip *chip = tdata_to_rt1711h(tdata);
226 	int ret;
227 	unsigned int reg = 0;
228 
229 	switch (cc) {
230 	default:
231 	case TYPEC_CC_RP_DEF:
232 		reg |= (TCPC_ROLE_CTRL_RP_VAL_DEF <<
233 			TCPC_ROLE_CTRL_RP_VAL_SHIFT);
234 		break;
235 	case TYPEC_CC_RP_1_5:
236 		reg |= (TCPC_ROLE_CTRL_RP_VAL_1_5 <<
237 			TCPC_ROLE_CTRL_RP_VAL_SHIFT);
238 		break;
239 	case TYPEC_CC_RP_3_0:
240 		reg |= (TCPC_ROLE_CTRL_RP_VAL_3_0 <<
241 			TCPC_ROLE_CTRL_RP_VAL_SHIFT);
242 		break;
243 	}
244 
245 	if (cc == TYPEC_CC_RD)
246 		reg |= (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) |
247 			   (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT);
248 	else
249 		reg |= (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC1_SHIFT) |
250 			   (TCPC_ROLE_CTRL_CC_RP << TCPC_ROLE_CTRL_CC2_SHIFT);
251 
252 	ret = rt1711h_write8(chip, TCPC_ROLE_CTRL, reg);
253 	if (ret < 0)
254 		return ret;
255 	usleep_range(500, 1000);
256 
257 	return 0;
258 }
259 
rt1711h_irq(int irq,void * dev_id)260 static irqreturn_t rt1711h_irq(int irq, void *dev_id)
261 {
262 	int ret;
263 	u16 alert;
264 	u8 status;
265 	struct rt1711h_chip *chip = dev_id;
266 
267 	if (!chip->tcpci)
268 		return IRQ_HANDLED;
269 
270 	ret = rt1711h_read16(chip, TCPC_ALERT, &alert);
271 	if (ret < 0)
272 		goto out;
273 
274 	if (alert & TCPC_ALERT_CC_STATUS) {
275 		ret = rt1711h_read8(chip, TCPC_CC_STATUS, &status);
276 		if (ret < 0)
277 			goto out;
278 		/* Clear cc change event triggered by starting toggling */
279 		if (status & TCPC_CC_STATUS_TOGGLING)
280 			rt1711h_write8(chip, TCPC_ALERT, TCPC_ALERT_CC_STATUS);
281 		else
282 			rt1711h_init_cc_params(chip, status);
283 	}
284 
285 out:
286 	return tcpci_irq(chip->tcpci);
287 }
288 
rt1711h_sw_reset(struct rt1711h_chip * chip)289 static int rt1711h_sw_reset(struct rt1711h_chip *chip)
290 {
291 	int ret;
292 
293 	ret = rt1711h_write8(chip, RT1711H_RTCTRL13, 0x01);
294 	if (ret < 0)
295 		return ret;
296 
297 	usleep_range(1000, 2000);
298 	return 0;
299 }
300 
rt1711h_check_revision(struct i2c_client * i2c,struct rt1711h_chip * chip)301 static int rt1711h_check_revision(struct i2c_client *i2c, struct rt1711h_chip *chip)
302 {
303 	int ret;
304 
305 	ret = i2c_smbus_read_word_data(i2c, TCPC_VENDOR_ID);
306 	if (ret < 0)
307 		return ret;
308 	if (ret != RT1711H_VID) {
309 		dev_err(&i2c->dev, "vid is not correct, 0x%04x\n", ret);
310 		return -ENODEV;
311 	}
312 	ret = i2c_smbus_read_word_data(i2c, TCPC_PRODUCT_ID);
313 	if (ret < 0)
314 		return ret;
315 	if (ret != RT1711H_PID) {
316 		dev_err(&i2c->dev, "pid is not correct, 0x%04x\n", ret);
317 		return -ENODEV;
318 	}
319 	ret = i2c_smbus_read_word_data(i2c, TCPC_BCD_DEV);
320 	if (ret < 0)
321 		return ret;
322 	if (ret != chip->did) {
323 		dev_err(&i2c->dev, "did is not correct, 0x%04x\n", ret);
324 		return -ENODEV;
325 	}
326 	dev_dbg(&i2c->dev, "did is 0x%04x\n", ret);
327 	return ret;
328 }
329 
rt1711h_probe(struct i2c_client * client)330 static int rt1711h_probe(struct i2c_client *client)
331 {
332 	int ret;
333 	struct rt1711h_chip *chip;
334 
335 	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
336 	if (!chip)
337 		return -ENOMEM;
338 
339 	chip->did = (size_t)device_get_match_data(&client->dev);
340 
341 	ret = rt1711h_check_revision(client, chip);
342 	if (ret < 0) {
343 		dev_err(&client->dev, "check vid/pid fail\n");
344 		return ret;
345 	}
346 
347 	chip->data.regmap = devm_regmap_init_i2c(client,
348 						 &rt1711h_regmap_config);
349 	if (IS_ERR(chip->data.regmap))
350 		return PTR_ERR(chip->data.regmap);
351 
352 	chip->dev = &client->dev;
353 	i2c_set_clientdata(client, chip);
354 
355 	ret = rt1711h_sw_reset(chip);
356 	if (ret < 0)
357 		return ret;
358 
359 	/* Disable chip interrupts before requesting irq */
360 	ret = rt1711h_write16(chip, TCPC_ALERT_MASK, 0);
361 	if (ret < 0)
362 		return ret;
363 
364 	chip->vbus = devm_regulator_get(&client->dev, "vbus");
365 	if (IS_ERR(chip->vbus))
366 		return PTR_ERR(chip->vbus);
367 
368 	chip->data.init = rt1711h_init;
369 	chip->data.set_vbus = rt1711h_set_vbus;
370 	chip->data.set_vconn = rt1711h_set_vconn;
371 	chip->data.start_drp_toggling = rt1711h_start_drp_toggling;
372 	chip->tcpci = tcpci_register_port(chip->dev, &chip->data);
373 	if (IS_ERR_OR_NULL(chip->tcpci))
374 		return PTR_ERR(chip->tcpci);
375 
376 	ret = devm_request_threaded_irq(chip->dev, client->irq, NULL,
377 					rt1711h_irq,
378 					IRQF_ONESHOT | IRQF_TRIGGER_LOW,
379 					dev_name(chip->dev), chip);
380 	if (ret < 0)
381 		return ret;
382 	enable_irq_wake(client->irq);
383 
384 	return 0;
385 }
386 
rt1711h_remove(struct i2c_client * client)387 static void rt1711h_remove(struct i2c_client *client)
388 {
389 	struct rt1711h_chip *chip = i2c_get_clientdata(client);
390 
391 	tcpci_unregister_port(chip->tcpci);
392 }
393 
394 static const struct i2c_device_id rt1711h_id[] = {
395 	{ "rt1711h", 0 },
396 	{ "rt1715", 0 },
397 	{ }
398 };
399 MODULE_DEVICE_TABLE(i2c, rt1711h_id);
400 
401 #ifdef CONFIG_OF
402 static const struct of_device_id rt1711h_of_match[] = {
403 	{ .compatible = "richtek,rt1711h", .data = (void *)RT1711H_DID },
404 	{ .compatible = "richtek,rt1715", .data = (void *)RT1715_DID },
405 	{},
406 };
407 MODULE_DEVICE_TABLE(of, rt1711h_of_match);
408 #endif
409 
410 static struct i2c_driver rt1711h_i2c_driver = {
411 	.driver = {
412 		.name = "rt1711h",
413 		.of_match_table = of_match_ptr(rt1711h_of_match),
414 	},
415 	.probe = rt1711h_probe,
416 	.remove = rt1711h_remove,
417 	.id_table = rt1711h_id,
418 };
419 module_i2c_driver(rt1711h_i2c_driver);
420 
421 MODULE_AUTHOR("ShuFan Lee <shufan_lee@richtek.com>");
422 MODULE_DESCRIPTION("RT1711H USB Type-C Port Controller Interface Driver");
423 MODULE_LICENSE("GPL");
424