ps883x.c

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