Loading...
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
472struct class typec_mux_class = {
473 .name = "typec_mux",
474};
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/mutex.h>
13#include <linux/usb/typec_mux.h>
14
15static DEFINE_MUTEX(switch_lock);
16static DEFINE_MUTEX(mux_lock);
17static LIST_HEAD(switch_list);
18static LIST_HEAD(mux_list);
19
20static void *typec_switch_match(struct device_connection *con, int ep,
21 void *data)
22{
23 struct typec_switch *sw;
24
25 list_for_each_entry(sw, &switch_list, entry)
26 if (!strcmp(con->endpoint[ep], dev_name(sw->dev)))
27 return sw;
28
29 /*
30 * We only get called if a connection was found, tell the caller to
31 * wait for the switch to show up.
32 */
33 return ERR_PTR(-EPROBE_DEFER);
34}
35
36/**
37 * typec_switch_get - Find USB Type-C orientation switch
38 * @dev: The caller device
39 *
40 * Finds a switch linked with @dev. Returns a reference to the switch on
41 * success, NULL if no matching connection was found, or
42 * ERR_PTR(-EPROBE_DEFER) when a connection was found but the switch
43 * has not been enumerated yet.
44 */
45struct typec_switch *typec_switch_get(struct device *dev)
46{
47 struct typec_switch *sw;
48
49 mutex_lock(&switch_lock);
50 sw = device_connection_find_match(dev, "typec-switch", NULL,
51 typec_switch_match);
52 if (!IS_ERR_OR_NULL(sw))
53 get_device(sw->dev);
54 mutex_unlock(&switch_lock);
55
56 return sw;
57}
58EXPORT_SYMBOL_GPL(typec_switch_get);
59
60/**
61 * typec_put_switch - Release USB Type-C orientation switch
62 * @sw: USB Type-C orientation switch
63 *
64 * Decrement reference count for @sw.
65 */
66void typec_switch_put(struct typec_switch *sw)
67{
68 if (!IS_ERR_OR_NULL(sw))
69 put_device(sw->dev);
70}
71EXPORT_SYMBOL_GPL(typec_switch_put);
72
73/**
74 * typec_switch_register - Register USB Type-C orientation switch
75 * @sw: USB Type-C orientation switch
76 *
77 * This function registers a switch that can be used for routing the correct
78 * data pairs depending on the cable plug orientation from the USB Type-C
79 * connector to the USB controllers. USB Type-C plugs can be inserted
80 * right-side-up or upside-down.
81 */
82int typec_switch_register(struct typec_switch *sw)
83{
84 mutex_lock(&switch_lock);
85 list_add_tail(&sw->entry, &switch_list);
86 mutex_unlock(&switch_lock);
87
88 return 0;
89}
90EXPORT_SYMBOL_GPL(typec_switch_register);
91
92/**
93 * typec_switch_unregister - Unregister USB Type-C orientation switch
94 * @sw: USB Type-C orientation switch
95 *
96 * Unregister switch that was registered with typec_switch_register().
97 */
98void typec_switch_unregister(struct typec_switch *sw)
99{
100 mutex_lock(&switch_lock);
101 list_del(&sw->entry);
102 mutex_unlock(&switch_lock);
103}
104EXPORT_SYMBOL_GPL(typec_switch_unregister);
105
106/* ------------------------------------------------------------------------- */
107
108static void *typec_mux_match(struct device_connection *con, int ep, void *data)
109{
110 struct typec_mux *mux;
111
112 list_for_each_entry(mux, &mux_list, entry)
113 if (!strcmp(con->endpoint[ep], dev_name(mux->dev)))
114 return mux;
115
116 /*
117 * We only get called if a connection was found, tell the caller to
118 * wait for the switch to show up.
119 */
120 return ERR_PTR(-EPROBE_DEFER);
121}
122
123/**
124 * typec_mux_get - Find USB Type-C Multiplexer
125 * @dev: The caller device
126 *
127 * Finds a mux linked to the caller. This function is primarily meant for the
128 * Type-C drivers. Returns a reference to the mux on success, NULL if no
129 * matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a connection
130 * was found but the mux has not been enumerated yet.
131 */
132struct typec_mux *typec_mux_get(struct device *dev)
133{
134 struct typec_mux *mux;
135
136 mutex_lock(&mux_lock);
137 mux = device_connection_find_match(dev, "typec-mux", NULL,
138 typec_mux_match);
139 if (!IS_ERR_OR_NULL(mux))
140 get_device(mux->dev);
141 mutex_unlock(&mux_lock);
142
143 return mux;
144}
145EXPORT_SYMBOL_GPL(typec_mux_get);
146
147/**
148 * typec_mux_put - Release handle to a Multiplexer
149 * @mux: USB Type-C Connector Multiplexer/DeMultiplexer
150 *
151 * Decrements reference count for @mux.
152 */
153void typec_mux_put(struct typec_mux *mux)
154{
155 if (!IS_ERR_OR_NULL(mux))
156 put_device(mux->dev);
157}
158EXPORT_SYMBOL_GPL(typec_mux_put);
159
160/**
161 * typec_mux_register - Register Multiplexer routing USB Type-C pins
162 * @mux: USB Type-C Connector Multiplexer/DeMultiplexer
163 *
164 * USB Type-C connectors can be used for alternate modes of operation besides
165 * USB when Accessory/Alternate Modes are supported. With some of those modes,
166 * the pins on the connector need to be reconfigured. This function registers
167 * multiplexer switches routing the pins on the connector.
168 */
169int typec_mux_register(struct typec_mux *mux)
170{
171 mutex_lock(&mux_lock);
172 list_add_tail(&mux->entry, &mux_list);
173 mutex_unlock(&mux_lock);
174
175 return 0;
176}
177EXPORT_SYMBOL_GPL(typec_mux_register);
178
179/**
180 * typec_mux_unregister - Unregister Multiplexer Switch
181 * @sw: USB Type-C Connector Multiplexer/DeMultiplexer
182 *
183 * Unregister mux that was registered with typec_mux_register().
184 */
185void typec_mux_unregister(struct typec_mux *mux)
186{
187 mutex_lock(&mux_lock);
188 list_del(&mux->entry);
189 mutex_unlock(&mux_lock);
190}
191EXPORT_SYMBOL_GPL(typec_mux_unregister);