1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Parade ps883x usb retimer driver
4  *
5  * Copyright (C) 2024 Linaro Ltd.
6  */
7 
8 #include <drm/bridge/aux-bridge.h>
9 #include <linux/clk.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/i2c.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/mutex.h>
15 #include <linux/regmap.h>
16 #include <linux/regulator/consumer.h>
17 #include <linux/usb/typec_altmode.h>
18 #include <linux/usb/typec_dp.h>
19 #include <linux/usb/typec_mux.h>
20 #include <linux/usb/typec_retimer.h>
21 
22 #define REG_USB_PORT_CONN_STATUS_0		0x00
23 
24 #define CONN_STATUS_0_CONNECTION_PRESENT	BIT(0)
25 #define CONN_STATUS_0_ORIENTATION_REVERSED	BIT(1)
26 #define CONN_STATUS_0_USB_3_1_CONNECTED		BIT(5)
27 
28 #define REG_USB_PORT_CONN_STATUS_1		0x01
29 
30 #define CONN_STATUS_1_DP_CONNECTED		BIT(0)
31 #define CONN_STATUS_1_DP_SINK_REQUESTED		BIT(1)
32 #define CONN_STATUS_1_DP_PIN_ASSIGNMENT_C_D	BIT(2)
33 #define CONN_STATUS_1_DP_HPD_LEVEL		BIT(7)
34 
35 #define REG_USB_PORT_CONN_STATUS_2		0x02
36 
37 struct ps883x_retimer {
38 	struct i2c_client *client;
39 	struct gpio_desc *reset_gpio;
40 	struct regmap *regmap;
41 	struct typec_switch_dev *sw;
42 	struct typec_retimer *retimer;
43 	struct clk *xo_clk;
44 	struct regulator *vdd_supply;
45 	struct regulator *vdd33_supply;
46 	struct regulator *vdd33_cap_supply;
47 	struct regulator *vddat_supply;
48 	struct regulator *vddar_supply;
49 	struct regulator *vddio_supply;
50 
51 	struct typec_switch *typec_switch;
52 	struct typec_mux *typec_mux;
53 
54 	struct mutex lock; /* protect non-concurrent retimer & switch */
55 
56 	enum typec_orientation orientation;
57 	unsigned long mode;
58 	unsigned int svid;
59 };
60 
ps883x_configure(struct ps883x_retimer * retimer,int cfg0,int cfg1,int cfg2)61 static int ps883x_configure(struct ps883x_retimer *retimer, int cfg0,
62 			    int cfg1, int cfg2)
63 {
64 	struct device *dev = &retimer->client->dev;
65 	int ret;
66 
67 	ret = regmap_write(retimer->regmap, REG_USB_PORT_CONN_STATUS_0, cfg0);
68 	if (ret) {
69 		dev_err(dev, "failed to write conn_status_0: %d\n", ret);
70 		return ret;
71 	}
72 
73 	ret = regmap_write(retimer->regmap, REG_USB_PORT_CONN_STATUS_1, cfg1);
74 	if (ret) {
75 		dev_err(dev, "failed to write conn_status_1: %d\n", ret);
76 		return ret;
77 	}
78 
79 	ret = regmap_write(retimer->regmap, REG_USB_PORT_CONN_STATUS_2, cfg2);
80 	if (ret) {
81 		dev_err(dev, "failed to write conn_status_2: %d\n", ret);
82 		return ret;
83 	}
84 
85 	return 0;
86 }
87 
ps883x_set(struct ps883x_retimer * retimer)88 static int ps883x_set(struct ps883x_retimer *retimer)
89 {
90 	int cfg0 = CONN_STATUS_0_CONNECTION_PRESENT;
91 	int cfg1 = 0x00;
92 	int cfg2 = 0x00;
93 
94 	if (retimer->orientation == TYPEC_ORIENTATION_NONE ||
95 	    retimer->mode == TYPEC_STATE_SAFE) {
96 		return ps883x_configure(retimer, cfg0, cfg1, cfg2);
97 	}
98 
99 	if (retimer->mode != TYPEC_STATE_USB && retimer->svid != USB_TYPEC_DP_SID)
100 		return -EINVAL;
101 
102 	if (retimer->orientation == TYPEC_ORIENTATION_REVERSE)
103 		cfg0 |= CONN_STATUS_0_ORIENTATION_REVERSED;
104 
105 	switch (retimer->mode) {
106 	case TYPEC_STATE_USB:
107 		cfg0 |= CONN_STATUS_0_USB_3_1_CONNECTED;
108 		break;
109 
110 	case TYPEC_DP_STATE_C:
111 		cfg1 = CONN_STATUS_1_DP_CONNECTED |
112 		       CONN_STATUS_1_DP_SINK_REQUESTED |
113 		       CONN_STATUS_1_DP_PIN_ASSIGNMENT_C_D |
114 		       CONN_STATUS_1_DP_HPD_LEVEL;
115 		break;
116 
117 	case TYPEC_DP_STATE_D:
118 		cfg0 |= CONN_STATUS_0_USB_3_1_CONNECTED;
119 		cfg1 = CONN_STATUS_1_DP_CONNECTED |
120 		       CONN_STATUS_1_DP_SINK_REQUESTED |
121 		       CONN_STATUS_1_DP_PIN_ASSIGNMENT_C_D |
122 		       CONN_STATUS_1_DP_HPD_LEVEL;
123 		break;
124 
125 	case TYPEC_DP_STATE_E:
126 		cfg1 = CONN_STATUS_1_DP_CONNECTED |
127 		       CONN_STATUS_1_DP_HPD_LEVEL;
128 		break;
129 
130 	default:
131 		return -EOPNOTSUPP;
132 	}
133 
134 	return ps883x_configure(retimer, cfg0, cfg1, cfg2);
135 }
136 
ps883x_sw_set(struct typec_switch_dev * sw,enum typec_orientation orientation)137 static int ps883x_sw_set(struct typec_switch_dev *sw,
138 			 enum typec_orientation orientation)
139 {
140 	struct ps883x_retimer *retimer = typec_switch_get_drvdata(sw);
141 	int ret = 0;
142 
143 	ret = typec_switch_set(retimer->typec_switch, orientation);
144 	if (ret)
145 		return ret;
146 
147 	mutex_lock(&retimer->lock);
148 
149 	if (retimer->orientation != orientation) {
150 		retimer->orientation = orientation;
151 
152 		ret = ps883x_set(retimer);
153 	}
154 
155 	mutex_unlock(&retimer->lock);
156 
157 	return ret;
158 }
159 
ps883x_retimer_set(struct typec_retimer * rtmr,struct typec_retimer_state * state)160 static int ps883x_retimer_set(struct typec_retimer *rtmr,
161 			      struct typec_retimer_state *state)
162 {
163 	struct ps883x_retimer *retimer = typec_retimer_get_drvdata(rtmr);
164 	struct typec_mux_state mux_state;
165 	int ret = 0;
166 
167 	mutex_lock(&retimer->lock);
168 
169 	if (state->mode != retimer->mode) {
170 		retimer->mode = state->mode;
171 
172 		if (state->alt)
173 			retimer->svid = state->alt->svid;
174 		else
175 			retimer->svid = 0;
176 
177 		ret = ps883x_set(retimer);
178 	}
179 
180 	mutex_unlock(&retimer->lock);
181 
182 	if (ret)
183 		return ret;
184 
185 	mux_state.alt = state->alt;
186 	mux_state.data = state->data;
187 	mux_state.mode = state->mode;
188 
189 	return typec_mux_set(retimer->typec_mux, &mux_state);
190 }
191 
ps883x_enable_vregs(struct ps883x_retimer * retimer)192 static int ps883x_enable_vregs(struct ps883x_retimer *retimer)
193 {
194 	struct device *dev = &retimer->client->dev;
195 	int ret;
196 
197 	ret = regulator_enable(retimer->vdd33_supply);
198 	if (ret) {
199 		dev_err(dev, "cannot enable VDD 3.3V regulator: %d\n", ret);
200 		return ret;
201 	}
202 
203 	ret = regulator_enable(retimer->vdd33_cap_supply);
204 	if (ret) {
205 		dev_err(dev, "cannot enable VDD 3.3V CAP regulator: %d\n", ret);
206 		goto err_vdd33_disable;
207 	}
208 
209 	usleep_range(4000, 10000);
210 
211 	ret = regulator_enable(retimer->vdd_supply);
212 	if (ret) {
213 		dev_err(dev, "cannot enable VDD regulator: %d\n", ret);
214 		goto err_vdd33_cap_disable;
215 	}
216 
217 	ret = regulator_enable(retimer->vddar_supply);
218 	if (ret) {
219 		dev_err(dev, "cannot enable VDD AR regulator: %d\n", ret);
220 		goto err_vdd_disable;
221 	}
222 
223 	ret = regulator_enable(retimer->vddat_supply);
224 	if (ret) {
225 		dev_err(dev, "cannot enable VDD AT regulator: %d\n", ret);
226 		goto err_vddar_disable;
227 	}
228 
229 	ret = regulator_enable(retimer->vddio_supply);
230 	if (ret) {
231 		dev_err(dev, "cannot enable VDD IO regulator: %d\n", ret);
232 		goto err_vddat_disable;
233 	}
234 
235 	return 0;
236 
237 err_vddat_disable:
238 	regulator_disable(retimer->vddat_supply);
239 err_vddar_disable:
240 	regulator_disable(retimer->vddar_supply);
241 err_vdd_disable:
242 	regulator_disable(retimer->vdd_supply);
243 err_vdd33_cap_disable:
244 	regulator_disable(retimer->vdd33_cap_supply);
245 err_vdd33_disable:
246 	regulator_disable(retimer->vdd33_supply);
247 
248 	return ret;
249 }
250 
ps883x_disable_vregs(struct ps883x_retimer * retimer)251 static void ps883x_disable_vregs(struct ps883x_retimer *retimer)
252 {
253 	regulator_disable(retimer->vddio_supply);
254 	regulator_disable(retimer->vddat_supply);
255 	regulator_disable(retimer->vddar_supply);
256 	regulator_disable(retimer->vdd_supply);
257 	regulator_disable(retimer->vdd33_cap_supply);
258 	regulator_disable(retimer->vdd33_supply);
259 }
260 
ps883x_get_vregs(struct ps883x_retimer * retimer)261 static int ps883x_get_vregs(struct ps883x_retimer *retimer)
262 {
263 	struct device *dev = &retimer->client->dev;
264 
265 	retimer->vdd_supply = devm_regulator_get(dev, "vdd");
266 	if (IS_ERR(retimer->vdd_supply))
267 		return dev_err_probe(dev, PTR_ERR(retimer->vdd_supply),
268 				     "failed to get VDD\n");
269 
270 	retimer->vdd33_supply = devm_regulator_get(dev, "vdd33");
271 	if (IS_ERR(retimer->vdd33_supply))
272 		return dev_err_probe(dev, PTR_ERR(retimer->vdd33_supply),
273 				     "failed to get VDD 3.3V\n");
274 
275 	retimer->vdd33_cap_supply = devm_regulator_get(dev, "vdd33-cap");
276 	if (IS_ERR(retimer->vdd33_cap_supply))
277 		return dev_err_probe(dev, PTR_ERR(retimer->vdd33_cap_supply),
278 				     "failed to get VDD CAP 3.3V\n");
279 
280 	retimer->vddat_supply = devm_regulator_get(dev, "vddat");
281 	if (IS_ERR(retimer->vddat_supply))
282 		return dev_err_probe(dev, PTR_ERR(retimer->vddat_supply),
283 				     "failed to get VDD AT\n");
284 
285 	retimer->vddar_supply = devm_regulator_get(dev, "vddar");
286 	if (IS_ERR(retimer->vddar_supply))
287 		return dev_err_probe(dev, PTR_ERR(retimer->vddar_supply),
288 				     "failed to get VDD AR\n");
289 
290 	retimer->vddio_supply = devm_regulator_get(dev, "vddio");
291 	if (IS_ERR(retimer->vddio_supply))
292 		return dev_err_probe(dev, PTR_ERR(retimer->vddio_supply),
293 				     "failed to get VDD IO\n");
294 
295 	return 0;
296 }
297 
298 static const struct regmap_config ps883x_retimer_regmap = {
299 	.max_register = 0x1f,
300 	.reg_bits = 8,
301 	.val_bits = 8,
302 };
303 
ps883x_retimer_probe(struct i2c_client * client)304 static int ps883x_retimer_probe(struct i2c_client *client)
305 {
306 	struct device *dev = &client->dev;
307 	struct typec_switch_desc sw_desc = { };
308 	struct typec_retimer_desc rtmr_desc = { };
309 	struct ps883x_retimer *retimer;
310 	unsigned int val;
311 	int ret;
312 
313 	retimer = devm_kzalloc(dev, sizeof(*retimer), GFP_KERNEL);
314 	if (!retimer)
315 		return -ENOMEM;
316 
317 	retimer->client = client;
318 
319 	mutex_init(&retimer->lock);
320 
321 	retimer->regmap = devm_regmap_init_i2c(client, &ps883x_retimer_regmap);
322 	if (IS_ERR(retimer->regmap))
323 		return dev_err_probe(dev, PTR_ERR(retimer->regmap),
324 				     "failed to allocate register map\n");
325 
326 	ret = ps883x_get_vregs(retimer);
327 	if (ret)
328 		return ret;
329 
330 	retimer->xo_clk = devm_clk_get(dev, NULL);
331 	if (IS_ERR(retimer->xo_clk))
332 		return dev_err_probe(dev, PTR_ERR(retimer->xo_clk),
333 				     "failed to get xo clock\n");
334 
335 	retimer->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_ASIS);
336 	if (IS_ERR(retimer->reset_gpio))
337 		return dev_err_probe(dev, PTR_ERR(retimer->reset_gpio),
338 				     "failed to get reset gpio\n");
339 
340 	retimer->typec_switch = typec_switch_get(dev);
341 	if (IS_ERR(retimer->typec_switch))
342 		return dev_err_probe(dev, PTR_ERR(retimer->typec_switch),
343 				     "failed to acquire orientation-switch\n");
344 
345 	retimer->typec_mux = typec_mux_get(dev);
346 	if (IS_ERR(retimer->typec_mux)) {
347 		ret = dev_err_probe(dev, PTR_ERR(retimer->typec_mux),
348 				    "failed to acquire mode-mux\n");
349 		goto err_switch_put;
350 	}
351 
352 	ret = drm_aux_bridge_register(dev);
353 	if (ret)
354 		goto err_mux_put;
355 
356 	ret = ps883x_enable_vregs(retimer);
357 	if (ret)
358 		goto err_mux_put;
359 
360 	ret = clk_prepare_enable(retimer->xo_clk);
361 	if (ret) {
362 		dev_err(dev, "failed to enable XO: %d\n", ret);
363 		goto err_vregs_disable;
364 	}
365 
366 	/* skip resetting if already configured */
367 	if (regmap_test_bits(retimer->regmap, REG_USB_PORT_CONN_STATUS_0,
368 			     CONN_STATUS_0_CONNECTION_PRESENT) == 1) {
369 		gpiod_direction_output(retimer->reset_gpio, 0);
370 	} else {
371 		gpiod_direction_output(retimer->reset_gpio, 1);
372 
373 		/* VDD IO supply enable to reset release delay */
374 		usleep_range(4000, 14000);
375 
376 		gpiod_set_value(retimer->reset_gpio, 0);
377 
378 		/* firmware initialization delay */
379 		msleep(60);
380 
381 		/* make sure device is accessible */
382 		ret = regmap_read(retimer->regmap, REG_USB_PORT_CONN_STATUS_0,
383 				  &val);
384 		if (ret) {
385 			dev_err(dev, "failed to read conn_status_0: %d\n", ret);
386 			if (ret == -ENXIO)
387 				ret = -EIO;
388 			goto err_clk_disable;
389 		}
390 	}
391 
392 	sw_desc.drvdata = retimer;
393 	sw_desc.fwnode = dev_fwnode(dev);
394 	sw_desc.set = ps883x_sw_set;
395 
396 	retimer->sw = typec_switch_register(dev, &sw_desc);
397 	if (IS_ERR(retimer->sw)) {
398 		ret = PTR_ERR(retimer->sw);
399 		dev_err(dev, "failed to register typec switch: %d\n", ret);
400 		goto err_clk_disable;
401 	}
402 
403 	rtmr_desc.drvdata = retimer;
404 	rtmr_desc.fwnode = dev_fwnode(dev);
405 	rtmr_desc.set = ps883x_retimer_set;
406 
407 	retimer->retimer = typec_retimer_register(dev, &rtmr_desc);
408 	if (IS_ERR(retimer->retimer)) {
409 		ret = PTR_ERR(retimer->retimer);
410 		dev_err(dev, "failed to register typec retimer: %d\n", ret);
411 		goto err_switch_unregister;
412 	}
413 
414 	return 0;
415 
416 err_switch_unregister:
417 	typec_switch_unregister(retimer->sw);
418 err_clk_disable:
419 	clk_disable_unprepare(retimer->xo_clk);
420 err_vregs_disable:
421 	gpiod_set_value(retimer->reset_gpio, 1);
422 	ps883x_disable_vregs(retimer);
423 err_mux_put:
424 	typec_mux_put(retimer->typec_mux);
425 err_switch_put:
426 	typec_switch_put(retimer->typec_switch);
427 
428 	return ret;
429 }
430 
ps883x_retimer_remove(struct i2c_client * client)431 static void ps883x_retimer_remove(struct i2c_client *client)
432 {
433 	struct ps883x_retimer *retimer = i2c_get_clientdata(client);
434 
435 	typec_retimer_unregister(retimer->retimer);
436 	typec_switch_unregister(retimer->sw);
437 
438 	gpiod_set_value(retimer->reset_gpio, 1);
439 
440 	clk_disable_unprepare(retimer->xo_clk);
441 
442 	ps883x_disable_vregs(retimer);
443 
444 	typec_mux_put(retimer->typec_mux);
445 	typec_switch_put(retimer->typec_switch);
446 }
447 
448 static const struct of_device_id ps883x_retimer_of_table[] = {
449 	{ .compatible = "parade,ps8830" },
450 	{ }
451 };
452 MODULE_DEVICE_TABLE(of, ps883x_retimer_of_table);
453 
454 static struct i2c_driver ps883x_retimer_driver = {
455 	.driver = {
456 		.name = "ps883x_retimer",
457 		.of_match_table = ps883x_retimer_of_table,
458 	},
459 	.probe		= ps883x_retimer_probe,
460 	.remove		= ps883x_retimer_remove,
461 };
462 
463 module_i2c_driver(ps883x_retimer_driver);
464 
465 MODULE_DESCRIPTION("Parade ps883x Type-C Retimer driver");
466 MODULE_LICENSE("GPL");
467