4 * Copyright (C) 2015 Google, Inc.
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <linux/ctype.h>
18 #include <linux/device.h>
19 #include <linux/usb/class-dual-role.h>
20 #include <linux/err.h>
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/stat.h>
25 #include <linux/types.h>
27 #define DUAL_ROLE_NOTIFICATION_TIMEOUT 2000
29 static ssize_t dual_role_store_property(struct device *dev,
30 struct device_attribute *attr,
31 const char *buf, size_t count);
32 static ssize_t dual_role_show_property(struct device *dev,
33 struct device_attribute *attr,
36 #define DUAL_ROLE_ATTR(_name) \
38 .attr = { .name = #_name }, \
39 .show = dual_role_show_property, \
40 .store = dual_role_store_property, \
43 static struct device_attribute dual_role_attrs[] = {
44 DUAL_ROLE_ATTR(supported_modes),
46 DUAL_ROLE_ATTR(power_role),
47 DUAL_ROLE_ATTR(data_role),
48 DUAL_ROLE_ATTR(powers_vconn),
51 struct class *dual_role_class;
52 EXPORT_SYMBOL_GPL(dual_role_class);
54 static struct device_type dual_role_dev_type;
56 static char *kstrdupcase(const char *str, gfp_t gfp, bool to_upper)
60 ustr = ret = kmalloc(strlen(str) + 1, gfp);
66 *ustr++ = to_upper ? toupper(*str++) : tolower(*str++);
73 static void dual_role_changed_work(struct work_struct *work)
75 struct dual_role_phy_instance *dual_role =
76 container_of(work, struct dual_role_phy_instance,
79 dev_dbg(&dual_role->dev, "%s\n", __func__);
80 kobject_uevent(&dual_role->dev.kobj, KOBJ_CHANGE);
83 void dual_role_instance_changed(struct dual_role_phy_instance *dual_role)
85 dev_dbg(&dual_role->dev, "%s\n", __func__);
86 pm_wakeup_event(&dual_role->dev, DUAL_ROLE_NOTIFICATION_TIMEOUT);
87 schedule_work(&dual_role->changed_work);
89 EXPORT_SYMBOL_GPL(dual_role_instance_changed);
91 int dual_role_get_property(struct dual_role_phy_instance *dual_role,
92 enum dual_role_property prop,
95 return dual_role->desc->get_property(dual_role, prop, val);
97 EXPORT_SYMBOL_GPL(dual_role_get_property);
99 int dual_role_set_property(struct dual_role_phy_instance *dual_role,
100 enum dual_role_property prop,
101 const unsigned int *val)
103 if (!dual_role->desc->set_property)
106 return dual_role->desc->set_property(dual_role, prop, val);
108 EXPORT_SYMBOL_GPL(dual_role_set_property);
110 int dual_role_property_is_writeable(struct dual_role_phy_instance *dual_role,
111 enum dual_role_property prop)
113 if (!dual_role->desc->property_is_writeable)
116 return dual_role->desc->property_is_writeable(dual_role, prop);
118 EXPORT_SYMBOL_GPL(dual_role_property_is_writeable);
120 static void dual_role_dev_release(struct device *dev)
122 struct dual_role_phy_instance *dual_role =
123 container_of(dev, struct dual_role_phy_instance, dev);
124 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
128 static struct dual_role_phy_instance *__must_check
129 __dual_role_register(struct device *parent,
130 const struct dual_role_phy_desc *desc)
133 struct dual_role_phy_instance *dual_role;
136 dual_role = kzalloc(sizeof(*dual_role), GFP_KERNEL);
138 return ERR_PTR(-ENOMEM);
140 dev = &dual_role->dev;
142 device_initialize(dev);
144 dev->class = dual_role_class;
145 dev->type = &dual_role_dev_type;
146 dev->parent = parent;
147 dev->release = dual_role_dev_release;
148 dev_set_drvdata(dev, dual_role);
149 dual_role->desc = desc;
151 rc = dev_set_name(dev, "%s", desc->name);
153 goto dev_set_name_failed;
155 INIT_WORK(&dual_role->changed_work, dual_role_changed_work);
157 rc = device_init_wakeup(dev, true);
159 goto wakeup_init_failed;
161 rc = device_add(dev);
163 goto device_add_failed;
165 dual_role_instance_changed(dual_role);
170 device_init_wakeup(dev, false);
179 static void dual_role_instance_unregister(struct dual_role_phy_instance
182 cancel_work_sync(&dual_role->changed_work);
183 device_init_wakeup(&dual_role->dev, false);
184 device_unregister(&dual_role->dev);
187 static void devm_dual_role_release(struct device *dev, void *res)
189 struct dual_role_phy_instance **dual_role = res;
191 dual_role_instance_unregister(*dual_role);
194 struct dual_role_phy_instance *__must_check
195 devm_dual_role_instance_register(struct device *parent,
196 const struct dual_role_phy_desc *desc)
198 struct dual_role_phy_instance **ptr, *dual_role;
200 ptr = devres_alloc(devm_dual_role_release, sizeof(*ptr), GFP_KERNEL);
203 return ERR_PTR(-ENOMEM);
204 dual_role = __dual_role_register(parent, desc);
205 if (IS_ERR(dual_role)) {
209 devres_add(parent, ptr);
213 EXPORT_SYMBOL_GPL(devm_dual_role_instance_register);
215 static int devm_dual_role_match(struct device *dev, void *res, void *data)
217 struct dual_role_phy_instance **r = res;
219 if (WARN_ON(!r || !*r))
225 void devm_dual_role_instance_unregister(struct device *dev,
226 struct dual_role_phy_instance
231 rc = devres_release(dev, devm_dual_role_release,
232 devm_dual_role_match, dual_role);
235 EXPORT_SYMBOL_GPL(devm_dual_role_instance_unregister);
237 void *dual_role_get_drvdata(struct dual_role_phy_instance *dual_role)
239 return dual_role->drv_data;
241 EXPORT_SYMBOL_GPL(dual_role_get_drvdata);
243 /***************** Device attribute functions **************************/
246 static char *supported_modes_text[] = {
247 "ufp dfp", "dfp", "ufp"
251 static char *mode_text[] = {
256 static char *pr_text[] = {
257 "source", "sink", "none"
261 static char *dr_text[] = {
262 "host", "device", "none"
266 static char *vconn_supply_text[] = {
270 static ssize_t dual_role_show_property(struct device *dev,
271 struct device_attribute *attr, char *buf)
274 struct dual_role_phy_instance *dual_role = dev_get_drvdata(dev);
275 const ptrdiff_t off = attr - dual_role_attrs;
278 if (off == DUAL_ROLE_PROP_SUPPORTED_MODES) {
279 value = dual_role->desc->supported_modes;
281 ret = dual_role_get_property(dual_role, off, &value);
286 "driver has no data for `%s' property\n",
288 else if (ret != -ENODEV)
290 "driver failed to report `%s' property: %zd\n",
291 attr->attr.name, ret);
296 if (off == DUAL_ROLE_PROP_SUPPORTED_MODES) {
297 BUILD_BUG_ON(DUAL_ROLE_PROP_SUPPORTED_MODES_TOTAL !=
298 ARRAY_SIZE(supported_modes_text));
299 if (value < DUAL_ROLE_PROP_SUPPORTED_MODES_TOTAL)
300 return snprintf(buf, PAGE_SIZE, "%s\n",
301 supported_modes_text[value]);
304 } else if (off == DUAL_ROLE_PROP_MODE) {
305 BUILD_BUG_ON(DUAL_ROLE_PROP_MODE_TOTAL !=
306 ARRAY_SIZE(mode_text));
307 if (value < DUAL_ROLE_PROP_MODE_TOTAL)
308 return snprintf(buf, PAGE_SIZE, "%s\n",
312 } else if (off == DUAL_ROLE_PROP_PR) {
313 BUILD_BUG_ON(DUAL_ROLE_PROP_PR_TOTAL != ARRAY_SIZE(pr_text));
314 if (value < DUAL_ROLE_PROP_PR_TOTAL)
315 return snprintf(buf, PAGE_SIZE, "%s\n",
319 } else if (off == DUAL_ROLE_PROP_DR) {
320 BUILD_BUG_ON(DUAL_ROLE_PROP_DR_TOTAL != ARRAY_SIZE(dr_text));
321 if (value < DUAL_ROLE_PROP_DR_TOTAL)
322 return snprintf(buf, PAGE_SIZE, "%s\n",
326 } else if (off == DUAL_ROLE_PROP_VCONN_SUPPLY) {
327 BUILD_BUG_ON(DUAL_ROLE_PROP_VCONN_SUPPLY_TOTAL !=
328 ARRAY_SIZE(vconn_supply_text));
329 if (value < DUAL_ROLE_PROP_VCONN_SUPPLY_TOTAL)
330 return snprintf(buf, PAGE_SIZE, "%s\n",
331 vconn_supply_text[value]);
338 static ssize_t dual_role_store_property(struct device *dev,
339 struct device_attribute *attr,
340 const char *buf, size_t count)
343 struct dual_role_phy_instance *dual_role = dev_get_drvdata(dev);
344 const ptrdiff_t off = attr - dual_role_attrs;
347 char *dup_buf, **text_array;
350 dup_buf = kstrdupcase(buf, GFP_KERNEL, false);
352 case DUAL_ROLE_PROP_MODE:
353 total = DUAL_ROLE_PROP_MODE_TOTAL;
354 text_array = mode_text;
356 case DUAL_ROLE_PROP_PR:
357 total = DUAL_ROLE_PROP_PR_TOTAL;
358 text_array = pr_text;
360 case DUAL_ROLE_PROP_DR:
361 total = DUAL_ROLE_PROP_DR_TOTAL;
362 text_array = dr_text;
364 case DUAL_ROLE_PROP_VCONN_SUPPLY:
365 ret = strtobool(dup_buf, &result);
374 for (i = 0; i <= total; i++) {
379 if (!strncmp(*(text_array + i), dup_buf,
380 strlen(*(text_array + i)))) {
387 ret = dual_role->desc->set_property(dual_role, off, &value);
398 static umode_t dual_role_attr_is_visible(struct kobject *kobj,
399 struct attribute *attr, int attrno)
401 struct device *dev = container_of(kobj, struct device, kobj);
402 struct dual_role_phy_instance *dual_role = dev_get_drvdata(dev);
403 umode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
406 if (attrno == DUAL_ROLE_PROP_SUPPORTED_MODES)
409 for (i = 0; i < dual_role->desc->num_properties; i++) {
410 int property = dual_role->desc->properties[i];
412 if (property == attrno) {
413 if (dual_role->desc->property_is_writeable &&
414 dual_role_property_is_writeable(dual_role, property)
425 static struct attribute *__dual_role_attrs[ARRAY_SIZE(dual_role_attrs) + 1];
427 static struct attribute_group dual_role_attr_group = {
428 .attrs = __dual_role_attrs,
429 .is_visible = dual_role_attr_is_visible,
432 static const struct attribute_group *dual_role_attr_groups[] = {
433 &dual_role_attr_group,
437 void dual_role_init_attrs(struct device_type *dev_type)
441 dev_type->groups = dual_role_attr_groups;
443 for (i = 0; i < ARRAY_SIZE(dual_role_attrs); i++)
444 __dual_role_attrs[i] = &dual_role_attrs[i].attr;
447 int dual_role_uevent(struct device *dev, struct kobj_uevent_env *env)
449 struct dual_role_phy_instance *dual_role = dev_get_drvdata(dev);
454 dev_dbg(dev, "uevent\n");
456 if (!dual_role || !dual_role->desc) {
457 dev_dbg(dev, "No dual_role phy yet\n");
461 dev_dbg(dev, "DUAL_ROLE_NAME=%s\n", dual_role->desc->name);
463 ret = add_uevent_var(env, "DUAL_ROLE_NAME=%s", dual_role->desc->name);
467 prop_buf = (char *)get_zeroed_page(GFP_KERNEL);
471 for (j = 0; j < dual_role->desc->num_properties; j++) {
472 struct device_attribute *attr;
475 attr = &dual_role_attrs[dual_role->desc->properties[j]];
477 ret = dual_role_show_property(dev, attr, prop_buf);
478 if (ret == -ENODEV || ret == -ENODATA) {
485 line = strnchr(prop_buf, PAGE_SIZE, '\n');
489 attrname = kstrdupcase(attr->attr.name, GFP_KERNEL, true);
493 dev_dbg(dev, "prop %s=%s\n", attrname, prop_buf);
495 ret = add_uevent_var(env, "DUAL_ROLE_%s=%s", attrname,
503 free_page((unsigned long)prop_buf);
508 /******************* Module Init ***********************************/
510 static int __init dual_role_class_init(void)
512 dual_role_class = class_create(THIS_MODULE, "dual_role_usb");
514 if (IS_ERR(dual_role_class))
515 return PTR_ERR(dual_role_class);
517 dual_role_class->dev_uevent = dual_role_uevent;
518 dual_role_init_attrs(&dual_role_dev_type);
523 static void __exit dual_role_class_exit(void)
525 class_destroy(dual_role_class);
528 subsys_initcall(dual_role_class_init);
529 module_exit(dual_role_class_exit);