Branch data Line data Source code
1 : : /*
2 : : * drivers/usb/core/sysfs.c
3 : : *
4 : : * (C) Copyright 2002 David Brownell
5 : : * (C) Copyright 2002,2004 Greg Kroah-Hartman
6 : : * (C) Copyright 2002,2004 IBM Corp.
7 : : *
8 : : * All of the sysfs file attributes for usb devices and interfaces.
9 : : *
10 : : */
11 : :
12 : :
13 : : #include <linux/kernel.h>
14 : : #include <linux/string.h>
15 : : #include <linux/usb.h>
16 : : #include <linux/usb/quirks.h>
17 : : #include "usb.h"
18 : :
19 : : /* Active configuration fields */
20 : : #define usb_actconfig_show(field, format_string) \
21 : : static ssize_t field##_show(struct device *dev, \
22 : : struct device_attribute *attr, char *buf) \
23 : : { \
24 : : struct usb_device *udev; \
25 : : struct usb_host_config *actconfig; \
26 : : ssize_t rc = 0; \
27 : : \
28 : : udev = to_usb_device(dev); \
29 : : usb_lock_device(udev); \
30 : : actconfig = udev->actconfig; \
31 : : if (actconfig) \
32 : : rc = sprintf(buf, format_string, \
33 : : actconfig->desc.field); \
34 : : usb_unlock_device(udev); \
35 : : return rc; \
36 : : } \
37 : :
38 : : #define usb_actconfig_attr(field, format_string) \
39 : : usb_actconfig_show(field, format_string) \
40 : : static DEVICE_ATTR_RO(field)
41 : :
42 [ # # ]: 0 : usb_actconfig_attr(bNumInterfaces, "%2d\n");
43 [ # # ]: 0 : usb_actconfig_attr(bmAttributes, "%2x\n");
44 : :
45 : 0 : static ssize_t bMaxPower_show(struct device *dev,
46 : : struct device_attribute *attr, char *buf)
47 : : {
48 : 0 : struct usb_device *udev;
49 : 0 : struct usb_host_config *actconfig;
50 : : ssize_t rc = 0;
51 : :
52 : : udev = to_usb_device(dev);
53 : : usb_lock_device(udev);
54 : 0 : actconfig = udev->actconfig;
55 [ # # ]: 0 : if (actconfig)
56 : 0 : rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
57 : : usb_unlock_device(udev);
58 : 0 : return rc;
59 : : }
60 : : static DEVICE_ATTR_RO(bMaxPower);
61 : :
62 : 0 : static ssize_t configuration_show(struct device *dev,
63 : : struct device_attribute *attr, char *buf)
64 : : {
65 : : struct usb_device *udev;
66 : : struct usb_host_config *actconfig;
67 : : ssize_t rc = 0;
68 : :
69 : : udev = to_usb_device(dev);
70 : : usb_lock_device(udev);
71 : 0 : actconfig = udev->actconfig;
72 [ # # ][ # # ]: 0 : if (actconfig && actconfig->string)
73 : 0 : rc = sprintf(buf, "%s\n", actconfig->string);
74 : : usb_unlock_device(udev);
75 : 0 : return rc;
76 : : }
77 : : static DEVICE_ATTR_RO(configuration);
78 : :
79 : : /* configuration value is always present, and r/w */
80 [ # # ]: 0 : usb_actconfig_show(bConfigurationValue, "%u\n");
81 : :
82 : 0 : static ssize_t bConfigurationValue_store(struct device *dev,
83 : : struct device_attribute *attr,
84 : : const char *buf, size_t count)
85 : : {
86 : 0 : struct usb_device *udev = to_usb_device(dev);
87 : : int config, value;
88 : :
89 [ # # ][ # # ]: 0 : if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
[ # # ]
90 : : return -EINVAL;
91 : : usb_lock_device(udev);
92 : 0 : value = usb_set_configuration(udev, config);
93 : : usb_unlock_device(udev);
94 [ # # ]: 0 : return (value < 0) ? value : count;
95 : : }
96 : : static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
97 : : bConfigurationValue_show, bConfigurationValue_store);
98 : :
99 : : /* String fields */
100 : : #define usb_string_attr(name) \
101 : : static ssize_t name##_show(struct device *dev, \
102 : : struct device_attribute *attr, char *buf) \
103 : : { \
104 : : struct usb_device *udev; \
105 : : int retval; \
106 : : \
107 : : udev = to_usb_device(dev); \
108 : : usb_lock_device(udev); \
109 : : retval = sprintf(buf, "%s\n", udev->name); \
110 : : usb_unlock_device(udev); \
111 : : return retval; \
112 : : } \
113 : : static DEVICE_ATTR_RO(name)
114 : :
115 : 0 : usb_string_attr(product);
116 : 0 : usb_string_attr(manufacturer);
117 : 0 : usb_string_attr(serial);
118 : :
119 : 0 : static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
120 : : char *buf)
121 : : {
122 : : struct usb_device *udev;
123 : : char *speed;
124 : :
125 : : udev = to_usb_device(dev);
126 : :
127 [ # # ]: 0 : switch (udev->speed) {
128 : : case USB_SPEED_LOW:
129 : : speed = "1.5";
130 : : break;
131 : : case USB_SPEED_UNKNOWN:
132 : : case USB_SPEED_FULL:
133 : : speed = "12";
134 : : break;
135 : : case USB_SPEED_HIGH:
136 : : speed = "480";
137 : : break;
138 : : case USB_SPEED_WIRELESS:
139 : : speed = "480";
140 : : break;
141 : : case USB_SPEED_SUPER:
142 : : speed = "5000";
143 : : break;
144 : : default:
145 : : speed = "unknown";
146 : : }
147 : 0 : return sprintf(buf, "%s\n", speed);
148 : : }
149 : : static DEVICE_ATTR_RO(speed);
150 : :
151 : 0 : static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
152 : : char *buf)
153 : : {
154 : : struct usb_device *udev;
155 : :
156 : : udev = to_usb_device(dev);
157 : 0 : return sprintf(buf, "%d\n", udev->bus->busnum);
158 : : }
159 : : static DEVICE_ATTR_RO(busnum);
160 : :
161 : 0 : static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
162 : : char *buf)
163 : : {
164 : : struct usb_device *udev;
165 : :
166 : : udev = to_usb_device(dev);
167 : 0 : return sprintf(buf, "%d\n", udev->devnum);
168 : : }
169 : : static DEVICE_ATTR_RO(devnum);
170 : :
171 : 0 : static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
172 : : char *buf)
173 : : {
174 : : struct usb_device *udev;
175 : :
176 : : udev = to_usb_device(dev);
177 : 0 : return sprintf(buf, "%s\n", udev->devpath);
178 : : }
179 : : static DEVICE_ATTR_RO(devpath);
180 : :
181 : 0 : static ssize_t version_show(struct device *dev, struct device_attribute *attr,
182 : : char *buf)
183 : : {
184 : : struct usb_device *udev;
185 : : u16 bcdUSB;
186 : :
187 : : udev = to_usb_device(dev);
188 : 0 : bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
189 : 0 : return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
190 : : }
191 : : static DEVICE_ATTR_RO(version);
192 : :
193 : 0 : static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr,
194 : : char *buf)
195 : : {
196 : : struct usb_device *udev;
197 : :
198 : : udev = to_usb_device(dev);
199 : 0 : return sprintf(buf, "%d\n", udev->maxchild);
200 : : }
201 : : static DEVICE_ATTR_RO(maxchild);
202 : :
203 : 0 : static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
204 : : char *buf)
205 : : {
206 : : struct usb_device *udev;
207 : :
208 : : udev = to_usb_device(dev);
209 : 0 : return sprintf(buf, "0x%x\n", udev->quirks);
210 : : }
211 : : static DEVICE_ATTR_RO(quirks);
212 : :
213 : 0 : static ssize_t avoid_reset_quirk_show(struct device *dev,
214 : : struct device_attribute *attr, char *buf)
215 : : {
216 : : struct usb_device *udev;
217 : :
218 : : udev = to_usb_device(dev);
219 : 0 : return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
220 : : }
221 : :
222 : 0 : static ssize_t avoid_reset_quirk_store(struct device *dev,
223 : : struct device_attribute *attr,
224 : : const char *buf, size_t count)
225 : : {
226 : : struct usb_device *udev = to_usb_device(dev);
227 : : int val;
228 : :
229 [ # # ][ # # ]: 0 : if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
[ # # ]
230 : : return -EINVAL;
231 : : usb_lock_device(udev);
232 [ # # ]: 0 : if (val)
233 : 0 : udev->quirks |= USB_QUIRK_RESET;
234 : : else
235 : 0 : udev->quirks &= ~USB_QUIRK_RESET;
236 : : usb_unlock_device(udev);
237 : 0 : return count;
238 : : }
239 : : static DEVICE_ATTR_RW(avoid_reset_quirk);
240 : :
241 : 0 : static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
242 : : char *buf)
243 : : {
244 : : struct usb_device *udev;
245 : :
246 : : udev = to_usb_device(dev);
247 : 0 : return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
248 : : }
249 : : static DEVICE_ATTR_RO(urbnum);
250 : :
251 : 0 : static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
252 : : char *buf)
253 : : {
254 : : struct usb_device *udev;
255 : : char *state;
256 : :
257 : : udev = to_usb_device(dev);
258 : :
259 [ - + - ]: 2 : switch (udev->removable) {
260 : : case USB_DEVICE_REMOVABLE:
261 : : state = "removable";
262 : : break;
263 : : case USB_DEVICE_FIXED:
264 : : state = "fixed";
265 : 2 : break;
266 : : default:
267 : : state = "unknown";
268 : : }
269 : :
270 : 0 : return sprintf(buf, "%s\n", state);
271 : : }
272 : : static DEVICE_ATTR_RO(removable);
273 : :
274 : 0 : static ssize_t ltm_capable_show(struct device *dev,
275 : : struct device_attribute *attr, char *buf)
276 : : {
277 [ # # ]: 0 : if (usb_device_supports_ltm(to_usb_device(dev)))
278 : 0 : return sprintf(buf, "%s\n", "yes");
279 : 0 : return sprintf(buf, "%s\n", "no");
280 : : }
281 : : static DEVICE_ATTR_RO(ltm_capable);
282 : :
283 : : #ifdef CONFIG_PM
284 : :
285 : 0 : static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
286 : : char *buf)
287 : : {
288 : : struct usb_device *udev = to_usb_device(dev);
289 : :
290 : 0 : return sprintf(buf, "%d\n", udev->persist_enabled);
291 : : }
292 : :
293 : 0 : static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
294 : : const char *buf, size_t count)
295 : : {
296 : : struct usb_device *udev = to_usb_device(dev);
297 : : int value;
298 : :
299 : : /* Hubs are always enabled for USB_PERSIST */
300 [ # # ]: 0 : if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
301 : : return -EPERM;
302 : :
303 [ # # ]: 0 : if (sscanf(buf, "%d", &value) != 1)
304 : : return -EINVAL;
305 : :
306 : : usb_lock_device(udev);
307 : 0 : udev->persist_enabled = !!value;
308 : : usb_unlock_device(udev);
309 : 0 : return count;
310 : : }
311 : : static DEVICE_ATTR_RW(persist);
312 : :
313 : 0 : static int add_persist_attributes(struct device *dev)
314 : : {
315 : : int rc = 0;
316 : :
317 [ + - ]: 2 : if (is_usb_device(dev)) {
318 : : struct usb_device *udev = to_usb_device(dev);
319 : :
320 : : /* Hubs are automatically enabled for USB_PERSIST,
321 : : * no point in creating the attribute file.
322 : : */
323 [ + - ]: 2 : if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
324 : 2 : rc = sysfs_add_file_to_group(&dev->kobj,
325 : : &dev_attr_persist.attr,
326 : : power_group_name);
327 : : }
328 : 0 : return rc;
329 : : }
330 : :
331 : : static void remove_persist_attributes(struct device *dev)
332 : : {
333 : 2 : sysfs_remove_file_from_group(&dev->kobj,
334 : : &dev_attr_persist.attr,
335 : : power_group_name);
336 : : }
337 : : #else
338 : :
339 : : #define add_persist_attributes(dev) 0
340 : : #define remove_persist_attributes(dev) do {} while (0)
341 : :
342 : : #endif /* CONFIG_PM */
343 : :
344 : : #ifdef CONFIG_PM_RUNTIME
345 : :
346 : : static ssize_t connected_duration_show(struct device *dev,
347 : : struct device_attribute *attr, char *buf)
348 : : {
349 : : struct usb_device *udev = to_usb_device(dev);
350 : :
351 : : return sprintf(buf, "%u\n",
352 : : jiffies_to_msecs(jiffies - udev->connect_time));
353 : : }
354 : : static DEVICE_ATTR_RO(connected_duration);
355 : :
356 : : /*
357 : : * If the device is resumed, the last time the device was suspended has
358 : : * been pre-subtracted from active_duration. We add the current time to
359 : : * get the duration that the device was actually active.
360 : : *
361 : : * If the device is suspended, the active_duration is up-to-date.
362 : : */
363 : : static ssize_t active_duration_show(struct device *dev,
364 : : struct device_attribute *attr, char *buf)
365 : : {
366 : : struct usb_device *udev = to_usb_device(dev);
367 : : int duration;
368 : :
369 : : if (udev->state != USB_STATE_SUSPENDED)
370 : : duration = jiffies_to_msecs(jiffies + udev->active_duration);
371 : : else
372 : : duration = jiffies_to_msecs(udev->active_duration);
373 : : return sprintf(buf, "%u\n", duration);
374 : : }
375 : : static DEVICE_ATTR_RO(active_duration);
376 : :
377 : : static ssize_t autosuspend_show(struct device *dev,
378 : : struct device_attribute *attr, char *buf)
379 : : {
380 : : return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
381 : : }
382 : :
383 : : static ssize_t autosuspend_store(struct device *dev,
384 : : struct device_attribute *attr, const char *buf,
385 : : size_t count)
386 : : {
387 : : int value;
388 : :
389 : : if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
390 : : value <= -INT_MAX/1000)
391 : : return -EINVAL;
392 : :
393 : : pm_runtime_set_autosuspend_delay(dev, value * 1000);
394 : : return count;
395 : : }
396 : : static DEVICE_ATTR_RW(autosuspend);
397 : :
398 : : static const char on_string[] = "on";
399 : : static const char auto_string[] = "auto";
400 : :
401 : : static void warn_level(void)
402 : : {
403 : : static int level_warned;
404 : :
405 : : if (!level_warned) {
406 : : level_warned = 1;
407 : : printk(KERN_WARNING "WARNING! power/level is deprecated; "
408 : : "use power/control instead\n");
409 : : }
410 : : }
411 : :
412 : : static ssize_t level_show(struct device *dev, struct device_attribute *attr,
413 : : char *buf)
414 : : {
415 : : struct usb_device *udev = to_usb_device(dev);
416 : : const char *p = auto_string;
417 : :
418 : : warn_level();
419 : : if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
420 : : p = on_string;
421 : : return sprintf(buf, "%s\n", p);
422 : : }
423 : :
424 : : static ssize_t level_store(struct device *dev, struct device_attribute *attr,
425 : : const char *buf, size_t count)
426 : : {
427 : : struct usb_device *udev = to_usb_device(dev);
428 : : int len = count;
429 : : char *cp;
430 : : int rc = count;
431 : :
432 : : warn_level();
433 : : cp = memchr(buf, '\n', count);
434 : : if (cp)
435 : : len = cp - buf;
436 : :
437 : : usb_lock_device(udev);
438 : :
439 : : if (len == sizeof on_string - 1 &&
440 : : strncmp(buf, on_string, len) == 0)
441 : : usb_disable_autosuspend(udev);
442 : :
443 : : else if (len == sizeof auto_string - 1 &&
444 : : strncmp(buf, auto_string, len) == 0)
445 : : usb_enable_autosuspend(udev);
446 : :
447 : : else
448 : : rc = -EINVAL;
449 : :
450 : : usb_unlock_device(udev);
451 : : return rc;
452 : : }
453 : : static DEVICE_ATTR_RW(level);
454 : :
455 : : static ssize_t usb2_hardware_lpm_show(struct device *dev,
456 : : struct device_attribute *attr, char *buf)
457 : : {
458 : : struct usb_device *udev = to_usb_device(dev);
459 : : const char *p;
460 : :
461 : : if (udev->usb2_hw_lpm_allowed == 1)
462 : : p = "enabled";
463 : : else
464 : : p = "disabled";
465 : :
466 : : return sprintf(buf, "%s\n", p);
467 : : }
468 : :
469 : : static ssize_t usb2_hardware_lpm_store(struct device *dev,
470 : : struct device_attribute *attr,
471 : : const char *buf, size_t count)
472 : : {
473 : : struct usb_device *udev = to_usb_device(dev);
474 : : bool value;
475 : : int ret;
476 : :
477 : : usb_lock_device(udev);
478 : :
479 : : ret = strtobool(buf, &value);
480 : :
481 : : if (!ret) {
482 : : udev->usb2_hw_lpm_allowed = value;
483 : : ret = usb_set_usb2_hardware_lpm(udev, value);
484 : : }
485 : :
486 : : usb_unlock_device(udev);
487 : :
488 : : if (!ret)
489 : : return count;
490 : :
491 : : return ret;
492 : : }
493 : : static DEVICE_ATTR_RW(usb2_hardware_lpm);
494 : :
495 : : static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
496 : : struct device_attribute *attr,
497 : : char *buf)
498 : : {
499 : : struct usb_device *udev = to_usb_device(dev);
500 : : return sprintf(buf, "%d\n", udev->l1_params.timeout);
501 : : }
502 : :
503 : : static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
504 : : struct device_attribute *attr,
505 : : const char *buf, size_t count)
506 : : {
507 : : struct usb_device *udev = to_usb_device(dev);
508 : : u16 timeout;
509 : :
510 : : if (kstrtou16(buf, 0, &timeout))
511 : : return -EINVAL;
512 : :
513 : : udev->l1_params.timeout = timeout;
514 : :
515 : : return count;
516 : : }
517 : : static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
518 : :
519 : : static ssize_t usb2_lpm_besl_show(struct device *dev,
520 : : struct device_attribute *attr, char *buf)
521 : : {
522 : : struct usb_device *udev = to_usb_device(dev);
523 : : return sprintf(buf, "%d\n", udev->l1_params.besl);
524 : : }
525 : :
526 : : static ssize_t usb2_lpm_besl_store(struct device *dev,
527 : : struct device_attribute *attr,
528 : : const char *buf, size_t count)
529 : : {
530 : : struct usb_device *udev = to_usb_device(dev);
531 : : u8 besl;
532 : :
533 : : if (kstrtou8(buf, 0, &besl) || besl > 15)
534 : : return -EINVAL;
535 : :
536 : : udev->l1_params.besl = besl;
537 : :
538 : : return count;
539 : : }
540 : : static DEVICE_ATTR_RW(usb2_lpm_besl);
541 : :
542 : : static struct attribute *usb2_hardware_lpm_attr[] = {
543 : : &dev_attr_usb2_hardware_lpm.attr,
544 : : &dev_attr_usb2_lpm_l1_timeout.attr,
545 : : &dev_attr_usb2_lpm_besl.attr,
546 : : NULL,
547 : : };
548 : : static struct attribute_group usb2_hardware_lpm_attr_group = {
549 : : .name = power_group_name,
550 : : .attrs = usb2_hardware_lpm_attr,
551 : : };
552 : :
553 : : static struct attribute *power_attrs[] = {
554 : : &dev_attr_autosuspend.attr,
555 : : &dev_attr_level.attr,
556 : : &dev_attr_connected_duration.attr,
557 : : &dev_attr_active_duration.attr,
558 : : NULL,
559 : : };
560 : : static struct attribute_group power_attr_group = {
561 : : .name = power_group_name,
562 : : .attrs = power_attrs,
563 : : };
564 : :
565 : : static int add_power_attributes(struct device *dev)
566 : : {
567 : : int rc = 0;
568 : :
569 : : if (is_usb_device(dev)) {
570 : : struct usb_device *udev = to_usb_device(dev);
571 : : rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
572 : : if (udev->usb2_hw_lpm_capable == 1)
573 : : rc = sysfs_merge_group(&dev->kobj,
574 : : &usb2_hardware_lpm_attr_group);
575 : : }
576 : :
577 : : return rc;
578 : : }
579 : :
580 : : static void remove_power_attributes(struct device *dev)
581 : : {
582 : : sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
583 : : sysfs_unmerge_group(&dev->kobj, &power_attr_group);
584 : : }
585 : :
586 : : #else
587 : :
588 : : #define add_power_attributes(dev) 0
589 : : #define remove_power_attributes(dev) do {} while (0)
590 : :
591 : : #endif /* CONFIG_PM_RUNTIME */
592 : :
593 : :
594 : : /* Descriptor fields */
595 : : #define usb_descriptor_attr_le16(field, format_string) \
596 : : static ssize_t \
597 : : field##_show(struct device *dev, struct device_attribute *attr, \
598 : : char *buf) \
599 : : { \
600 : : struct usb_device *udev; \
601 : : \
602 : : udev = to_usb_device(dev); \
603 : : return sprintf(buf, format_string, \
604 : : le16_to_cpu(udev->descriptor.field)); \
605 : : } \
606 : : static DEVICE_ATTR_RO(field)
607 : :
608 : 0 : usb_descriptor_attr_le16(idVendor, "%04x\n");
609 : 0 : usb_descriptor_attr_le16(idProduct, "%04x\n");
610 : 0 : usb_descriptor_attr_le16(bcdDevice, "%04x\n");
611 : :
612 : : #define usb_descriptor_attr(field, format_string) \
613 : : static ssize_t \
614 : : field##_show(struct device *dev, struct device_attribute *attr, \
615 : : char *buf) \
616 : : { \
617 : : struct usb_device *udev; \
618 : : \
619 : : udev = to_usb_device(dev); \
620 : : return sprintf(buf, format_string, udev->descriptor.field); \
621 : : } \
622 : : static DEVICE_ATTR_RO(field)
623 : :
624 : 0 : usb_descriptor_attr(bDeviceClass, "%02x\n");
625 : 0 : usb_descriptor_attr(bDeviceSubClass, "%02x\n");
626 : 0 : usb_descriptor_attr(bDeviceProtocol, "%02x\n");
627 : 0 : usb_descriptor_attr(bNumConfigurations, "%d\n");
628 : 0 : usb_descriptor_attr(bMaxPacketSize0, "%d\n");
629 : :
630 : :
631 : : /* show if the device is authorized (1) or not (0) */
632 : 0 : static ssize_t authorized_show(struct device *dev,
633 : : struct device_attribute *attr, char *buf)
634 : : {
635 : : struct usb_device *usb_dev = to_usb_device(dev);
636 : 0 : return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
637 : : }
638 : :
639 : : /*
640 : : * Authorize a device to be used in the system
641 : : *
642 : : * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
643 : : */
644 : 0 : static ssize_t authorized_store(struct device *dev,
645 : : struct device_attribute *attr, const char *buf,
646 : : size_t size)
647 : : {
648 : : ssize_t result;
649 : 0 : struct usb_device *usb_dev = to_usb_device(dev);
650 : : unsigned val;
651 : 0 : result = sscanf(buf, "%u\n", &val);
652 [ # # ]: 0 : if (result != 1)
653 : : result = -EINVAL;
654 [ # # ]: 0 : else if (val == 0)
655 : 0 : result = usb_deauthorize_device(usb_dev);
656 : : else
657 : 0 : result = usb_authorize_device(usb_dev);
658 [ # # ]: 0 : return result < 0 ? result : size;
659 : : }
660 : : static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
661 : : authorized_show, authorized_store);
662 : :
663 : : /* "Safely remove a device" */
664 : 0 : static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
665 : : const char *buf, size_t count)
666 : : {
667 : 0 : struct usb_device *udev = to_usb_device(dev);
668 : : int rc = 0;
669 : :
670 : : usb_lock_device(udev);
671 [ # # ]: 0 : if (udev->state != USB_STATE_NOTATTACHED) {
672 : :
673 : : /* To avoid races, first unconfigure and then remove */
674 : 0 : usb_set_configuration(udev, -1);
675 : 0 : rc = usb_remove_device(udev);
676 : : }
677 [ # # ]: 0 : if (rc == 0)
678 : 0 : rc = count;
679 : : usb_unlock_device(udev);
680 : 0 : return rc;
681 : : }
682 : : static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
683 : :
684 : :
685 : : static struct attribute *dev_attrs[] = {
686 : : /* current configuration's attributes */
687 : : &dev_attr_configuration.attr,
688 : : &dev_attr_bNumInterfaces.attr,
689 : : &dev_attr_bConfigurationValue.attr,
690 : : &dev_attr_bmAttributes.attr,
691 : : &dev_attr_bMaxPower.attr,
692 : : /* device attributes */
693 : : &dev_attr_urbnum.attr,
694 : : &dev_attr_idVendor.attr,
695 : : &dev_attr_idProduct.attr,
696 : : &dev_attr_bcdDevice.attr,
697 : : &dev_attr_bDeviceClass.attr,
698 : : &dev_attr_bDeviceSubClass.attr,
699 : : &dev_attr_bDeviceProtocol.attr,
700 : : &dev_attr_bNumConfigurations.attr,
701 : : &dev_attr_bMaxPacketSize0.attr,
702 : : &dev_attr_speed.attr,
703 : : &dev_attr_busnum.attr,
704 : : &dev_attr_devnum.attr,
705 : : &dev_attr_devpath.attr,
706 : : &dev_attr_version.attr,
707 : : &dev_attr_maxchild.attr,
708 : : &dev_attr_quirks.attr,
709 : : &dev_attr_avoid_reset_quirk.attr,
710 : : &dev_attr_authorized.attr,
711 : : &dev_attr_remove.attr,
712 : : &dev_attr_removable.attr,
713 : : &dev_attr_ltm_capable.attr,
714 : : NULL,
715 : : };
716 : : static struct attribute_group dev_attr_grp = {
717 : : .attrs = dev_attrs,
718 : : };
719 : :
720 : : /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
721 : : * accordingly.
722 : : */
723 : : static struct attribute *dev_string_attrs[] = {
724 : : &dev_attr_manufacturer.attr,
725 : : &dev_attr_product.attr,
726 : : &dev_attr_serial.attr,
727 : : NULL
728 : : };
729 : :
730 : 0 : static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
731 : : struct attribute *a, int n)
732 : : {
733 : : struct device *dev = container_of(kobj, struct device, kobj);
734 : : struct usb_device *udev = to_usb_device(dev);
735 : :
736 [ + + ]: 6 : if (a == &dev_attr_manufacturer.attr) {
737 [ - + ]: 2 : if (udev->manufacturer == NULL)
738 : : return 0;
739 [ + + ]: 4 : } else if (a == &dev_attr_product.attr) {
740 [ + - ]: 2 : if (udev->product == NULL)
741 : : return 0;
742 [ + - ]: 2 : } else if (a == &dev_attr_serial.attr) {
743 [ - + ]: 2 : if (udev->serial == NULL)
744 : : return 0;
745 : : }
746 : 2 : return a->mode;
747 : : }
748 : :
749 : : static struct attribute_group dev_string_attr_grp = {
750 : : .attrs = dev_string_attrs,
751 : : .is_visible = dev_string_attrs_are_visible,
752 : : };
753 : :
754 : : const struct attribute_group *usb_device_groups[] = {
755 : : &dev_attr_grp,
756 : : &dev_string_attr_grp,
757 : : NULL
758 : : };
759 : :
760 : : /* Binary descriptors */
761 : :
762 : : static ssize_t
763 : 0 : read_descriptors(struct file *filp, struct kobject *kobj,
764 : : struct bin_attribute *attr,
765 : : char *buf, loff_t off, size_t count)
766 : : {
767 : : struct device *dev = container_of(kobj, struct device, kobj);
768 : : struct usb_device *udev = to_usb_device(dev);
769 : : size_t nleft = count;
770 : : size_t srclen, n;
771 : : int cfgno;
772 : : void *src;
773 : :
774 : : /* The binary attribute begins with the device descriptor.
775 : : * Following that are the raw descriptor entries for all the
776 : : * configurations (config plus subsidiary descriptors).
777 : : */
778 : : usb_lock_device(udev);
779 [ + - ][ + - ]: 16 : for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
780 : 16 : nleft > 0; ++cfgno) {
781 [ + + ]: 16 : if (cfgno < 0) {
782 : 8 : src = &udev->descriptor;
783 : : srclen = sizeof(struct usb_device_descriptor);
784 : : } else {
785 : 8 : src = udev->rawdescriptors[cfgno];
786 : 8 : srclen = __le16_to_cpu(udev->config[cfgno].desc.
787 : : wTotalLength);
788 : : }
789 [ + - ]: 16 : if (off < srclen) {
790 : 16 : n = min(nleft, srclen - (size_t) off);
791 : 16 : memcpy(buf, src + off, n);
792 : 16 : nleft -= n;
793 : 16 : buf += n;
794 : : off = 0;
795 : : } else {
796 : 0 : off -= srclen;
797 : : }
798 : : }
799 : : usb_unlock_device(udev);
800 : 8 : return count - nleft;
801 : : }
802 : :
803 : : static struct bin_attribute dev_bin_attr_descriptors = {
804 : : .attr = {.name = "descriptors", .mode = 0444},
805 : : .read = read_descriptors,
806 : : .size = 18 + 65535, /* dev descr + max-size raw descriptor */
807 : : };
808 : :
809 : 0 : int usb_create_sysfs_dev_files(struct usb_device *udev)
810 : : {
811 : 2 : struct device *dev = &udev->dev;
812 : : int retval;
813 : :
814 : 2 : retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
815 [ + - ]: 2 : if (retval)
816 : : goto error;
817 : :
818 : 2 : retval = add_persist_attributes(dev);
819 [ - + ]: 2 : if (retval)
820 : : goto error;
821 : :
822 : : retval = add_power_attributes(dev);
823 : : if (retval)
824 : : goto error;
825 : : return retval;
826 : : error:
827 : 0 : usb_remove_sysfs_dev_files(udev);
828 : 0 : return retval;
829 : : }
830 : :
831 : 0 : void usb_remove_sysfs_dev_files(struct usb_device *udev)
832 : : {
833 : 2 : struct device *dev = &udev->dev;
834 : :
835 : : remove_power_attributes(dev);
836 : : remove_persist_attributes(dev);
837 : 2 : device_remove_bin_file(dev, &dev_bin_attr_descriptors);
838 : 2 : }
839 : :
840 : : /* Interface Association Descriptor fields */
841 : : #define usb_intf_assoc_attr(field, format_string) \
842 : : static ssize_t \
843 : : iad_##field##_show(struct device *dev, struct device_attribute *attr, \
844 : : char *buf) \
845 : : { \
846 : : struct usb_interface *intf = to_usb_interface(dev); \
847 : : \
848 : : return sprintf(buf, format_string, \
849 : : intf->intf_assoc->field); \
850 : : } \
851 : : static DEVICE_ATTR_RO(iad_##field)
852 : :
853 : 0 : usb_intf_assoc_attr(bFirstInterface, "%02x\n");
854 : 0 : usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
855 : 0 : usb_intf_assoc_attr(bFunctionClass, "%02x\n");
856 : 0 : usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
857 : 0 : usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
858 : :
859 : : /* Interface fields */
860 : : #define usb_intf_attr(field, format_string) \
861 : : static ssize_t \
862 : : field##_show(struct device *dev, struct device_attribute *attr, \
863 : : char *buf) \
864 : : { \
865 : : struct usb_interface *intf = to_usb_interface(dev); \
866 : : \
867 : : return sprintf(buf, format_string, \
868 : : intf->cur_altsetting->desc.field); \
869 : : } \
870 : : static DEVICE_ATTR_RO(field)
871 : :
872 : 0 : usb_intf_attr(bInterfaceNumber, "%02x\n");
873 : 0 : usb_intf_attr(bAlternateSetting, "%2d\n");
874 : 0 : usb_intf_attr(bNumEndpoints, "%02x\n");
875 : 0 : usb_intf_attr(bInterfaceClass, "%02x\n");
876 : 0 : usb_intf_attr(bInterfaceSubClass, "%02x\n");
877 : 0 : usb_intf_attr(bInterfaceProtocol, "%02x\n");
878 : :
879 : 0 : static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
880 : : char *buf)
881 : : {
882 : : struct usb_interface *intf;
883 : : char *string;
884 : :
885 : : intf = to_usb_interface(dev);
886 : 0 : string = ACCESS_ONCE(intf->cur_altsetting->string);
887 [ # # ]: 0 : if (!string)
888 : : return 0;
889 : 0 : return sprintf(buf, "%s\n", string);
890 : : }
891 : : static DEVICE_ATTR_RO(interface);
892 : :
893 : 0 : static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
894 : : char *buf)
895 : : {
896 : 0 : struct usb_interface *intf;
897 : : struct usb_device *udev;
898 : : struct usb_host_interface *alt;
899 : :
900 : : intf = to_usb_interface(dev);
901 : : udev = interface_to_usbdev(intf);
902 : 0 : alt = ACCESS_ONCE(intf->cur_altsetting);
903 : :
904 : 0 : return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
905 : : "ic%02Xisc%02Xip%02Xin%02X\n",
906 : 0 : le16_to_cpu(udev->descriptor.idVendor),
907 : 0 : le16_to_cpu(udev->descriptor.idProduct),
908 : 0 : le16_to_cpu(udev->descriptor.bcdDevice),
909 : 0 : udev->descriptor.bDeviceClass,
910 : 0 : udev->descriptor.bDeviceSubClass,
911 : 0 : udev->descriptor.bDeviceProtocol,
912 : 0 : alt->desc.bInterfaceClass,
913 : 0 : alt->desc.bInterfaceSubClass,
914 : 0 : alt->desc.bInterfaceProtocol,
915 : 0 : alt->desc.bInterfaceNumber);
916 : : }
917 : : static DEVICE_ATTR_RO(modalias);
918 : :
919 : 0 : static ssize_t supports_autosuspend_show(struct device *dev,
920 : : struct device_attribute *attr,
921 : : char *buf)
922 : : {
923 : : int s;
924 : :
925 : : device_lock(dev);
926 : : /* Devices will be autosuspended even when an interface isn't claimed */
927 [ # # ][ # # ]: 0 : s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
928 : : device_unlock(dev);
929 : :
930 : 0 : return sprintf(buf, "%u\n", s);
931 : : }
932 : : static DEVICE_ATTR_RO(supports_autosuspend);
933 : :
934 : : static struct attribute *intf_attrs[] = {
935 : : &dev_attr_bInterfaceNumber.attr,
936 : : &dev_attr_bAlternateSetting.attr,
937 : : &dev_attr_bNumEndpoints.attr,
938 : : &dev_attr_bInterfaceClass.attr,
939 : : &dev_attr_bInterfaceSubClass.attr,
940 : : &dev_attr_bInterfaceProtocol.attr,
941 : : &dev_attr_modalias.attr,
942 : : &dev_attr_supports_autosuspend.attr,
943 : : NULL,
944 : : };
945 : : static struct attribute_group intf_attr_grp = {
946 : : .attrs = intf_attrs,
947 : : };
948 : :
949 : : static struct attribute *intf_assoc_attrs[] = {
950 : : &dev_attr_iad_bFirstInterface.attr,
951 : : &dev_attr_iad_bInterfaceCount.attr,
952 : : &dev_attr_iad_bFunctionClass.attr,
953 : : &dev_attr_iad_bFunctionSubClass.attr,
954 : : &dev_attr_iad_bFunctionProtocol.attr,
955 : : NULL,
956 : : };
957 : :
958 : 0 : static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
959 : : struct attribute *a, int n)
960 : : {
961 : : struct device *dev = container_of(kobj, struct device, kobj);
962 : : struct usb_interface *intf = to_usb_interface(dev);
963 : :
964 [ - + ]: 10 : if (intf->intf_assoc == NULL)
965 : : return 0;
966 : 0 : return a->mode;
967 : : }
968 : :
969 : : static struct attribute_group intf_assoc_attr_grp = {
970 : : .attrs = intf_assoc_attrs,
971 : : .is_visible = intf_assoc_attrs_are_visible,
972 : : };
973 : :
974 : : const struct attribute_group *usb_interface_groups[] = {
975 : : &intf_attr_grp,
976 : : &intf_assoc_attr_grp,
977 : : NULL
978 : : };
979 : :
980 : 0 : void usb_create_sysfs_intf_files(struct usb_interface *intf)
981 : : {
982 : 2 : struct usb_device *udev = interface_to_usbdev(intf);
983 : 2 : struct usb_host_interface *alt = intf->cur_altsetting;
984 : :
985 [ + - ]: 2 : if (intf->sysfs_files_created || intf->unregistering)
986 : 2 : return;
987 : :
988 [ + - ][ + - ]: 2 : if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
989 : 2 : alt->string = usb_cache_string(udev, alt->desc.iInterface);
990 [ - - ]: 2 : if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
991 : : ; /* We don't actually care if the function fails. */
992 : 2 : intf->sysfs_files_created = 1;
993 : : }
994 : :
995 : 0 : void usb_remove_sysfs_intf_files(struct usb_interface *intf)
996 : : {
997 [ + - ]: 2 : if (!intf->sysfs_files_created)
998 : 0 : return;
999 : :
1000 : 2 : device_remove_file(&intf->dev, &dev_attr_interface);
1001 : 2 : intf->sysfs_files_created = 0;
1002 : : }
|
