1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * USB Type-C Multiplexer/DeMultiplexer Switch support
  4 *
  5 * Copyright (C) 2018 Intel Corporation
  6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
  7 *         Hans de Goede <hdegoede@redhat.com>
  8 */
  9
 10#include <linux/device.h>
 11#include <linux/list.h>
 12#include <linux/module.h>
 13#include <linux/mutex.h>
 14#include <linux/property.h>
 15#include <linux/slab.h>
 16
 17#include "class.h"
 18#include "mux.h"
 19
 20#define TYPEC_MUX_MAX_DEVS	3
 21
 22struct typec_switch {
 23	struct typec_switch_dev *sw_devs[TYPEC_MUX_MAX_DEVS];
 24	unsigned int num_sw_devs;
 25};
 26
 27static int switch_fwnode_match(struct device *dev, const void *fwnode)
 28{
 29	if (!is_typec_switch_dev(dev))
 30		return 0;
 31
 32	return device_match_fwnode(dev, fwnode);
 33}
 34
 35static void *typec_switch_match(const struct fwnode_handle *fwnode,
 36				const char *id, void *data)
 37{
 38	struct device *dev;
 39
 40	/*
 41	 * Device graph (OF graph) does not give any means to identify the
 42	 * device type or the device class of the remote port parent that @fwnode
 43	 * represents, so in order to identify the type or the class of @fwnode
 44	 * an additional device property is needed. With typec switches the
 45	 * property is named "orientation-switch" (@id). The value of the device
 46	 * property is ignored.
 47	 */
 48	if (id && !fwnode_property_present(fwnode, id))
 49		return NULL;
 50
 51	/*
 52	 * At this point we are sure that @fwnode is a typec switch in all
 53	 * cases. If the switch hasn't yet been registered for some reason, the
 54	 * function "defers probe" for now.
 55	 */
 56	dev = class_find_device(&typec_mux_class, NULL, fwnode,
 57				switch_fwnode_match);
 58
 59	return dev ? to_typec_switch_dev(dev) : ERR_PTR(-EPROBE_DEFER);
 60}
 61
 62/**
 63 * fwnode_typec_switch_get - Find USB Type-C orientation switch
 64 * @fwnode: The caller device node
 65 *
 66 * Finds a switch linked with @dev. Returns a reference to the switch on
 67 * success, NULL if no matching connection was found, or
 68 * ERR_PTR(-EPROBE_DEFER) when a connection was found but the switch
 69 * has not been enumerated yet.
 70 */
 71struct typec_switch *fwnode_typec_switch_get(struct fwnode_handle *fwnode)
 72{
 73	struct typec_switch_dev *sw_devs[TYPEC_MUX_MAX_DEVS];
 74	struct typec_switch *sw;
 75	int count;
 76	int err;
 77	int i;
 78
 79	sw = kzalloc(sizeof(*sw), GFP_KERNEL);
 80	if (!sw)
 81		return ERR_PTR(-ENOMEM);
 82
 83	count = fwnode_connection_find_matches(fwnode, "orientation-switch", NULL,
 84					       typec_switch_match,
 85					       (void **)sw_devs,
 86					       ARRAY_SIZE(sw_devs));
 87	if (count <= 0) {
 88		kfree(sw);
 89		return NULL;
 90	}
 91
 92	for (i = 0; i < count; i++) {
 93		if (IS_ERR(sw_devs[i])) {
 94			err = PTR_ERR(sw_devs[i]);
 95			goto put_sw_devs;
 96		}
 97	}
 98
 99	for (i = 0; i < count; i++) {
100		WARN_ON(!try_module_get(sw_devs[i]->dev.parent->driver->owner));
101		sw->sw_devs[i] = sw_devs[i];
102	}
103
104	sw->num_sw_devs = count;
105
106	return sw;
107
108put_sw_devs:
109	for (i = 0; i < count; i++) {
110		if (!IS_ERR(sw_devs[i]))
111			put_device(&sw_devs[i]->dev);
112	}
113
114	kfree(sw);
115
116	return ERR_PTR(err);
117}
118EXPORT_SYMBOL_GPL(fwnode_typec_switch_get);
119
120/**
121 * typec_switch_put - Release USB Type-C orientation switch
122 * @sw: USB Type-C orientation switch
123 *
124 * Decrement reference count for @sw.
125 */
126void typec_switch_put(struct typec_switch *sw)
127{
128	struct typec_switch_dev *sw_dev;
129	unsigned int i;
130
131	if (IS_ERR_OR_NULL(sw))
132		return;
133
134	for (i = 0; i < sw->num_sw_devs; i++) {
135		sw_dev = sw->sw_devs[i];
136
137		module_put(sw_dev->dev.parent->driver->owner);
138		put_device(&sw_dev->dev);
139	}
140	kfree(sw);
141}
142EXPORT_SYMBOL_GPL(typec_switch_put);
143
144static void typec_switch_release(struct device *dev)
145{
146	kfree(to_typec_switch_dev(dev));
147}
148
149const struct device_type typec_switch_dev_type = {
150	.name = "orientation_switch",
151	.release = typec_switch_release,
152};
153
154/**
155 * typec_switch_register - Register USB Type-C orientation switch
156 * @parent: Parent device
157 * @desc: Orientation switch description
158 *
159 * This function registers a switch that can be used for routing the correct
160 * data pairs depending on the cable plug orientation from the USB Type-C
161 * connector to the USB controllers. USB Type-C plugs can be inserted
162 * right-side-up or upside-down.
163 */
164struct typec_switch_dev *
165typec_switch_register(struct device *parent,
166		      const struct typec_switch_desc *desc)
167{
168	struct typec_switch_dev *sw_dev;
169	int ret;
170
171	if (!desc || !desc->set)
172		return ERR_PTR(-EINVAL);
173
174	sw_dev = kzalloc(sizeof(*sw_dev), GFP_KERNEL);
175	if (!sw_dev)
176		return ERR_PTR(-ENOMEM);
177
178	sw_dev->set = desc->set;
179
180	device_initialize(&sw_dev->dev);
181	sw_dev->dev.parent = parent;
182	sw_dev->dev.fwnode = desc->fwnode;
183	sw_dev->dev.class = &typec_mux_class;
184	sw_dev->dev.type = &typec_switch_dev_type;
185	sw_dev->dev.driver_data = desc->drvdata;
186	ret = dev_set_name(&sw_dev->dev, "%s-switch", desc->name ? desc->name : dev_name(parent));
187	if (ret) {
188		put_device(&sw_dev->dev);
189		return ERR_PTR(ret);
190	}
191
192	ret = device_add(&sw_dev->dev);
193	if (ret) {
194		dev_err(parent, "failed to register switch (%d)\n", ret);
195		put_device(&sw_dev->dev);
196		return ERR_PTR(ret);
197	}
198
199	return sw_dev;
200}
201EXPORT_SYMBOL_GPL(typec_switch_register);
202
203int typec_switch_set(struct typec_switch *sw,
204		     enum typec_orientation orientation)
205{
206	struct typec_switch_dev *sw_dev;
207	unsigned int i;
208	int ret;
209
210	if (IS_ERR_OR_NULL(sw))
211		return 0;
212
213	for (i = 0; i < sw->num_sw_devs; i++) {
214		sw_dev = sw->sw_devs[i];
215
216		ret = sw_dev->set(sw_dev, orientation);
217		if (ret)
218			return ret;
219	}
220
221	return 0;
222}
223EXPORT_SYMBOL_GPL(typec_switch_set);
224
225/**
226 * typec_switch_unregister - Unregister USB Type-C orientation switch
227 * @sw_dev: USB Type-C orientation switch
228 *
229 * Unregister switch that was registered with typec_switch_register().
230 */
231void typec_switch_unregister(struct typec_switch_dev *sw_dev)
232{
233	if (!IS_ERR_OR_NULL(sw_dev))
234		device_unregister(&sw_dev->dev);
235}
236EXPORT_SYMBOL_GPL(typec_switch_unregister);
237
238void typec_switch_set_drvdata(struct typec_switch_dev *sw_dev, void *data)
239{
240	dev_set_drvdata(&sw_dev->dev, data);
241}
242EXPORT_SYMBOL_GPL(typec_switch_set_drvdata);
243
244void *typec_switch_get_drvdata(struct typec_switch_dev *sw_dev)
245{
246	return dev_get_drvdata(&sw_dev->dev);
247}
248EXPORT_SYMBOL_GPL(typec_switch_get_drvdata);
249
250/* ------------------------------------------------------------------------- */
251
252struct typec_mux {
253	struct typec_mux_dev *mux_devs[TYPEC_MUX_MAX_DEVS];
254	unsigned int num_mux_devs;
255};
256
257static int mux_fwnode_match(struct device *dev, const void *fwnode)
258{
259	if (!is_typec_mux_dev(dev))
260		return 0;
261
262	return device_match_fwnode(dev, fwnode);
263}
264
265static void *typec_mux_match(const struct fwnode_handle *fwnode,
266			     const char *id, void *data)
267{
268	struct device *dev;
269
270	/*
271	 * Device graph (OF graph) does not give any means to identify the
272	 * device type or the device class of the remote port parent that @fwnode
273	 * represents, so in order to identify the type or the class of @fwnode
274	 * an additional device property is needed. With typec muxes the
275	 * property is named "mode-switch" (@id). The value of the device
276	 * property is ignored.
277	 */
278	if (id && !fwnode_property_present(fwnode, id))
279		return NULL;
280
281	dev = class_find_device(&typec_mux_class, NULL, fwnode,
282				mux_fwnode_match);
283
284	return dev ? to_typec_mux_dev(dev) : ERR_PTR(-EPROBE_DEFER);
285}
286
287/**
288 * fwnode_typec_mux_get - Find USB Type-C Multiplexer
289 * @fwnode: The caller device node
290 *
291 * Finds a mux linked to the caller. This function is primarily meant for the
292 * Type-C drivers. Returns a reference to the mux on success, NULL if no
293 * matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a connection
294 * was found but the mux has not been enumerated yet.
295 */
296struct typec_mux *fwnode_typec_mux_get(struct fwnode_handle *fwnode)
297{
298	struct typec_mux_dev *mux_devs[TYPEC_MUX_MAX_DEVS];
299	struct typec_mux *mux;
300	int count;
301	int err;
302	int i;
303
304	mux = kzalloc(sizeof(*mux), GFP_KERNEL);
305	if (!mux)
306		return ERR_PTR(-ENOMEM);
307
308	count = fwnode_connection_find_matches(fwnode, "mode-switch",
309					       NULL, typec_mux_match,
310					       (void **)mux_devs,
311					       ARRAY_SIZE(mux_devs));
312	if (count <= 0) {
313		kfree(mux);
314		return NULL;
315	}
316
317	for (i = 0; i < count; i++) {
318		if (IS_ERR(mux_devs[i])) {
319			err = PTR_ERR(mux_devs[i]);
320			goto put_mux_devs;
321		}
322	}
323
324	for (i = 0; i < count; i++) {
325		WARN_ON(!try_module_get(mux_devs[i]->dev.parent->driver->owner));
326		mux->mux_devs[i] = mux_devs[i];
327	}
328
329	mux->num_mux_devs = count;
330
331	return mux;
332
333put_mux_devs:
334	for (i = 0; i < count; i++) {
335		if (!IS_ERR(mux_devs[i]))
336			put_device(&mux_devs[i]->dev);
337	}
338
339	kfree(mux);
340
341	return ERR_PTR(err);
342}
343EXPORT_SYMBOL_GPL(fwnode_typec_mux_get);
344
345/**
346 * typec_mux_put - Release handle to a Multiplexer
347 * @mux: USB Type-C Connector Multiplexer/DeMultiplexer
348 *
349 * Decrements reference count for @mux.
350 */
351void typec_mux_put(struct typec_mux *mux)
352{
353	struct typec_mux_dev *mux_dev;
354	unsigned int i;
355
356	if (IS_ERR_OR_NULL(mux))
357		return;
358
359	for (i = 0; i < mux->num_mux_devs; i++) {
360		mux_dev = mux->mux_devs[i];
361		module_put(mux_dev->dev.parent->driver->owner);
362		put_device(&mux_dev->dev);
363	}
364	kfree(mux);
365}
366EXPORT_SYMBOL_GPL(typec_mux_put);
367
368int typec_mux_set(struct typec_mux *mux, struct typec_mux_state *state)
369{
370	struct typec_mux_dev *mux_dev;
371	unsigned int i;
372	int ret;
373
374	if (IS_ERR_OR_NULL(mux))
375		return 0;
376
377	for (i = 0; i < mux->num_mux_devs; i++) {
378		mux_dev = mux->mux_devs[i];
379
380		ret = mux_dev->set(mux_dev, state);
381		if (ret)
382			return ret;
383	}
384
385	return 0;
386}
387EXPORT_SYMBOL_GPL(typec_mux_set);
388
389static void typec_mux_release(struct device *dev)
390{
391	kfree(to_typec_mux_dev(dev));
392}
393
394const struct device_type typec_mux_dev_type = {
395	.name = "mode_switch",
396	.release = typec_mux_release,
397};
398
399/**
400 * typec_mux_register - Register Multiplexer routing USB Type-C pins
401 * @parent: Parent device
402 * @desc: Multiplexer description
403 *
404 * USB Type-C connectors can be used for alternate modes of operation besides
405 * USB when Accessory/Alternate Modes are supported. With some of those modes,
406 * the pins on the connector need to be reconfigured. This function registers
407 * multiplexer switches routing the pins on the connector.
408 */
409struct typec_mux_dev *
410typec_mux_register(struct device *parent, const struct typec_mux_desc *desc)
411{
412	struct typec_mux_dev *mux_dev;
413	int ret;
414
415	if (!desc || !desc->set)
416		return ERR_PTR(-EINVAL);
417
418	mux_dev = kzalloc(sizeof(*mux_dev), GFP_KERNEL);
419	if (!mux_dev)
420		return ERR_PTR(-ENOMEM);
421
422	mux_dev->set = desc->set;
423
424	device_initialize(&mux_dev->dev);
425	mux_dev->dev.parent = parent;
426	mux_dev->dev.fwnode = desc->fwnode;
427	mux_dev->dev.class = &typec_mux_class;
428	mux_dev->dev.type = &typec_mux_dev_type;
429	mux_dev->dev.driver_data = desc->drvdata;
430	ret = dev_set_name(&mux_dev->dev, "%s-mux", desc->name ? desc->name : dev_name(parent));
431	if (ret) {
432		put_device(&mux_dev->dev);
433		return ERR_PTR(ret);
434	}
435
436	ret = device_add(&mux_dev->dev);
437	if (ret) {
438		dev_err(parent, "failed to register mux (%d)\n", ret);
439		put_device(&mux_dev->dev);
440		return ERR_PTR(ret);
441	}
442
443	return mux_dev;
444}
445EXPORT_SYMBOL_GPL(typec_mux_register);
446
447/**
448 * typec_mux_unregister - Unregister Multiplexer Switch
449 * @mux_dev: USB Type-C Connector Multiplexer/DeMultiplexer
450 *
451 * Unregister mux that was registered with typec_mux_register().
452 */
453void typec_mux_unregister(struct typec_mux_dev *mux_dev)
454{
455	if (!IS_ERR_OR_NULL(mux_dev))
456		device_unregister(&mux_dev->dev);
457}
458EXPORT_SYMBOL_GPL(typec_mux_unregister);
459
460void typec_mux_set_drvdata(struct typec_mux_dev *mux_dev, void *data)
461{
462	dev_set_drvdata(&mux_dev->dev, data);
463}
464EXPORT_SYMBOL_GPL(typec_mux_set_drvdata);
465
466void *typec_mux_get_drvdata(struct typec_mux_dev *mux_dev)
467{
468	return dev_get_drvdata(&mux_dev->dev);
469}
470EXPORT_SYMBOL_GPL(typec_mux_get_drvdata);
471
472const struct class typec_mux_class = {
473	.name = "typec_mux",
474};