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