Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * drivers/usb/core/sysfs.c
4 : : *
5 : : * (C) Copyright 2002 David Brownell
6 : : * (C) Copyright 2002,2004 Greg Kroah-Hartman
7 : : * (C) Copyright 2002,2004 IBM Corp.
8 : : *
9 : : * All of the sysfs file attributes for usb devices and interfaces.
10 : : *
11 : : * Released under the GPLv2 only.
12 : : */
13 : :
14 : :
15 : : #include <linux/kernel.h>
16 : : #include <linux/string.h>
17 : : #include <linux/usb.h>
18 : : #include <linux/usb/hcd.h>
19 : : #include <linux/usb/quirks.h>
20 : : #include <linux/of.h>
21 : : #include "usb.h"
22 : :
23 : : /* Active configuration fields */
24 : : #define usb_actconfig_show(field, format_string) \
25 : : static ssize_t field##_show(struct device *dev, \
26 : : struct device_attribute *attr, char *buf) \
27 : : { \
28 : : struct usb_device *udev; \
29 : : struct usb_host_config *actconfig; \
30 : : ssize_t rc; \
31 : : \
32 : : udev = to_usb_device(dev); \
33 : : rc = usb_lock_device_interruptible(udev); \
34 : : if (rc < 0) \
35 : : return -EINTR; \
36 : : actconfig = udev->actconfig; \
37 : : if (actconfig) \
38 : : rc = sprintf(buf, format_string, \
39 : : actconfig->desc.field); \
40 : : usb_unlock_device(udev); \
41 : : return rc; \
42 : : } \
43 : :
44 : : #define usb_actconfig_attr(field, format_string) \
45 : : usb_actconfig_show(field, format_string) \
46 : : static DEVICE_ATTR_RO(field)
47 : :
48 [ # # # # ]: 0 : usb_actconfig_attr(bNumInterfaces, "%2d\n");
49 [ # # # # ]: 0 : usb_actconfig_attr(bmAttributes, "%2x\n");
50 : :
51 : 0 : static ssize_t bMaxPower_show(struct device *dev,
52 : : struct device_attribute *attr, char *buf)
53 : : {
54 : : struct usb_device *udev;
55 : : struct usb_host_config *actconfig;
56 : : ssize_t rc;
57 : :
58 : : udev = to_usb_device(dev);
59 : : rc = usb_lock_device_interruptible(udev);
60 [ # # ]: 0 : if (rc < 0)
61 : : return -EINTR;
62 : 0 : actconfig = udev->actconfig;
63 [ # # ]: 0 : if (actconfig)
64 : 0 : rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
65 : : usb_unlock_device(udev);
66 : 0 : return rc;
67 : : }
68 : : static DEVICE_ATTR_RO(bMaxPower);
69 : :
70 : 0 : static ssize_t configuration_show(struct device *dev,
71 : : struct device_attribute *attr, char *buf)
72 : : {
73 : : struct usb_device *udev;
74 : : struct usb_host_config *actconfig;
75 : : ssize_t rc;
76 : :
77 : : udev = to_usb_device(dev);
78 : : rc = usb_lock_device_interruptible(udev);
79 [ # # ]: 0 : if (rc < 0)
80 : : return -EINTR;
81 : 0 : actconfig = udev->actconfig;
82 [ # # # # ]: 0 : if (actconfig && actconfig->string)
83 : 0 : rc = sprintf(buf, "%s\n", actconfig->string);
84 : : usb_unlock_device(udev);
85 : 0 : return rc;
86 : : }
87 : : static DEVICE_ATTR_RO(configuration);
88 : :
89 : : /* configuration value is always present, and r/w */
90 [ + - + - ]: 18 : usb_actconfig_show(bConfigurationValue, "%u\n");
91 : :
92 : 0 : static ssize_t bConfigurationValue_store(struct device *dev,
93 : : struct device_attribute *attr,
94 : : const char *buf, size_t count)
95 : : {
96 : 0 : struct usb_device *udev = to_usb_device(dev);
97 : : int config, value, rc;
98 : :
99 [ # # # # : 0 : if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
# # ]
100 : : return -EINVAL;
101 : : rc = usb_lock_device_interruptible(udev);
102 [ # # ]: 0 : if (rc < 0)
103 : : return -EINTR;
104 : 0 : value = usb_set_configuration(udev, config);
105 : : usb_unlock_device(udev);
106 [ # # ]: 0 : return (value < 0) ? value : count;
107 : : }
108 : : static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
109 : : bConfigurationValue_show, bConfigurationValue_store);
110 : :
111 : : #ifdef CONFIG_OF
112 : 0 : static ssize_t devspec_show(struct device *dev, struct device_attribute *attr,
113 : : char *buf)
114 : : {
115 : 0 : struct device_node *of_node = dev->of_node;
116 : :
117 : 0 : return sprintf(buf, "%pOF\n", of_node);
118 : : }
119 : : static DEVICE_ATTR_RO(devspec);
120 : : #endif
121 : :
122 : : /* String fields */
123 : : #define usb_string_attr(name) \
124 : : static ssize_t name##_show(struct device *dev, \
125 : : struct device_attribute *attr, char *buf) \
126 : : { \
127 : : struct usb_device *udev; \
128 : : int retval; \
129 : : \
130 : : udev = to_usb_device(dev); \
131 : : retval = usb_lock_device_interruptible(udev); \
132 : : if (retval < 0) \
133 : : return -EINTR; \
134 : : retval = sprintf(buf, "%s\n", udev->name); \
135 : : usb_unlock_device(udev); \
136 : : return retval; \
137 : : } \
138 : : static DEVICE_ATTR_RO(name)
139 : :
140 [ + - ]: 13350 : usb_string_attr(product);
141 [ + - ]: 13350 : usb_string_attr(manufacturer);
142 [ + - ]: 13350 : usb_string_attr(serial);
143 : :
144 : 0 : static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
145 : : char *buf)
146 : : {
147 : : struct usb_device *udev;
148 : : char *speed;
149 : :
150 : : udev = to_usb_device(dev);
151 : :
152 [ # # ]: 0 : switch (udev->speed) {
153 : : case USB_SPEED_LOW:
154 : : speed = "1.5";
155 : : break;
156 : : case USB_SPEED_UNKNOWN:
157 : : case USB_SPEED_FULL:
158 : : speed = "12";
159 : : break;
160 : : case USB_SPEED_HIGH:
161 : : speed = "480";
162 : : break;
163 : : case USB_SPEED_WIRELESS:
164 : : speed = "480";
165 : : break;
166 : : case USB_SPEED_SUPER:
167 : : speed = "5000";
168 : : break;
169 : : case USB_SPEED_SUPER_PLUS:
170 : : speed = "10000";
171 : : break;
172 : : default:
173 : : speed = "unknown";
174 : : }
175 : 0 : return sprintf(buf, "%s\n", speed);
176 : : }
177 : : static DEVICE_ATTR_RO(speed);
178 : :
179 : 0 : static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
180 : : char *buf)
181 : : {
182 : : struct usb_device *udev;
183 : :
184 : : udev = to_usb_device(dev);
185 : 0 : return sprintf(buf, "%d\n", udev->rx_lanes);
186 : : }
187 : : static DEVICE_ATTR_RO(rx_lanes);
188 : :
189 : 0 : static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
190 : : char *buf)
191 : : {
192 : : struct usb_device *udev;
193 : :
194 : : udev = to_usb_device(dev);
195 : 0 : return sprintf(buf, "%d\n", udev->tx_lanes);
196 : : }
197 : : static DEVICE_ATTR_RO(tx_lanes);
198 : :
199 : 1218 : static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
200 : : char *buf)
201 : : {
202 : : struct usb_device *udev;
203 : :
204 : : udev = to_usb_device(dev);
205 : 1218 : return sprintf(buf, "%d\n", udev->bus->busnum);
206 : : }
207 : : static DEVICE_ATTR_RO(busnum);
208 : :
209 : 1218 : static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
210 : : char *buf)
211 : : {
212 : : struct usb_device *udev;
213 : :
214 : : udev = to_usb_device(dev);
215 : 1218 : return sprintf(buf, "%d\n", udev->devnum);
216 : : }
217 : : static DEVICE_ATTR_RO(devnum);
218 : :
219 : 0 : static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
220 : : char *buf)
221 : : {
222 : : struct usb_device *udev;
223 : :
224 : : udev = to_usb_device(dev);
225 : 0 : return sprintf(buf, "%s\n", udev->devpath);
226 : : }
227 : : static DEVICE_ATTR_RO(devpath);
228 : :
229 : 0 : static ssize_t version_show(struct device *dev, struct device_attribute *attr,
230 : : char *buf)
231 : : {
232 : : struct usb_device *udev;
233 : : u16 bcdUSB;
234 : :
235 : : udev = to_usb_device(dev);
236 : 0 : bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
237 : 0 : return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
238 : : }
239 : : static DEVICE_ATTR_RO(version);
240 : :
241 : 0 : static ssize_t maxchild_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", udev->maxchild);
248 : : }
249 : : static DEVICE_ATTR_RO(maxchild);
250 : :
251 : 0 : static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
252 : : char *buf)
253 : : {
254 : : struct usb_device *udev;
255 : :
256 : : udev = to_usb_device(dev);
257 : 0 : return sprintf(buf, "0x%x\n", udev->quirks);
258 : : }
259 : : static DEVICE_ATTR_RO(quirks);
260 : :
261 : 0 : static ssize_t avoid_reset_quirk_show(struct device *dev,
262 : : struct device_attribute *attr, char *buf)
263 : : {
264 : : struct usb_device *udev;
265 : :
266 : : udev = to_usb_device(dev);
267 : 0 : return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
268 : : }
269 : :
270 : 0 : static ssize_t avoid_reset_quirk_store(struct device *dev,
271 : : struct device_attribute *attr,
272 : : const char *buf, size_t count)
273 : : {
274 : : struct usb_device *udev = to_usb_device(dev);
275 : : int val, rc;
276 : :
277 [ # # # # : 0 : if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
# # ]
278 : : return -EINVAL;
279 : : rc = usb_lock_device_interruptible(udev);
280 [ # # ]: 0 : if (rc < 0)
281 : : return -EINTR;
282 [ # # ]: 0 : if (val)
283 : 0 : udev->quirks |= USB_QUIRK_RESET;
284 : : else
285 : 0 : udev->quirks &= ~USB_QUIRK_RESET;
286 : : usb_unlock_device(udev);
287 : 0 : return count;
288 : : }
289 : : static DEVICE_ATTR_RW(avoid_reset_quirk);
290 : :
291 : 0 : static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
292 : : char *buf)
293 : : {
294 : : struct usb_device *udev;
295 : :
296 : : udev = to_usb_device(dev);
297 : 0 : return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
298 : : }
299 : : static DEVICE_ATTR_RO(urbnum);
300 : :
301 : 0 : static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
302 : : char *buf)
303 : : {
304 : : struct usb_device *udev;
305 : : char *state;
306 : :
307 : : udev = to_usb_device(dev);
308 : :
309 [ # # # ]: 0 : switch (udev->removable) {
310 : : case USB_DEVICE_REMOVABLE:
311 : : state = "removable";
312 : : break;
313 : : case USB_DEVICE_FIXED:
314 : : state = "fixed";
315 : 0 : break;
316 : : default:
317 : : state = "unknown";
318 : : }
319 : :
320 : 0 : return sprintf(buf, "%s\n", state);
321 : : }
322 : : static DEVICE_ATTR_RO(removable);
323 : :
324 : 0 : static ssize_t ltm_capable_show(struct device *dev,
325 : : struct device_attribute *attr, char *buf)
326 : : {
327 [ # # ]: 0 : if (usb_device_supports_ltm(to_usb_device(dev)))
328 : 0 : return sprintf(buf, "%s\n", "yes");
329 : 0 : return sprintf(buf, "%s\n", "no");
330 : : }
331 : : static DEVICE_ATTR_RO(ltm_capable);
332 : :
333 : : #ifdef CONFIG_PM
334 : :
335 : 0 : static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
336 : : char *buf)
337 : : {
338 : : struct usb_device *udev = to_usb_device(dev);
339 : :
340 : 0 : return sprintf(buf, "%d\n", udev->persist_enabled);
341 : : }
342 : :
343 : 0 : static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
344 : : const char *buf, size_t count)
345 : : {
346 : : struct usb_device *udev = to_usb_device(dev);
347 : : int value, rc;
348 : :
349 : : /* Hubs are always enabled for USB_PERSIST */
350 [ # # ]: 0 : if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
351 : : return -EPERM;
352 : :
353 [ # # ]: 0 : if (sscanf(buf, "%d", &value) != 1)
354 : : return -EINVAL;
355 : :
356 : : rc = usb_lock_device_interruptible(udev);
357 [ # # ]: 0 : if (rc < 0)
358 : : return -EINTR;
359 : 0 : udev->persist_enabled = !!value;
360 : : usb_unlock_device(udev);
361 : 0 : return count;
362 : : }
363 : : static DEVICE_ATTR_RW(persist);
364 : :
365 : 2020 : static int add_persist_attributes(struct device *dev)
366 : : {
367 : : int rc = 0;
368 : :
369 [ + - ]: 2020 : if (is_usb_device(dev)) {
370 : : struct usb_device *udev = to_usb_device(dev);
371 : :
372 : : /* Hubs are automatically enabled for USB_PERSIST,
373 : : * no point in creating the attribute file.
374 : : */
375 [ + + ]: 2020 : if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
376 : 1212 : rc = sysfs_add_file_to_group(&dev->kobj,
377 : : &dev_attr_persist.attr,
378 : : power_group_name);
379 : : }
380 : 2020 : return rc;
381 : : }
382 : :
383 : : static void remove_persist_attributes(struct device *dev)
384 : : {
385 : 0 : sysfs_remove_file_from_group(&dev->kobj,
386 : : &dev_attr_persist.attr,
387 : : power_group_name);
388 : : }
389 : :
390 : 0 : static ssize_t connected_duration_show(struct device *dev,
391 : : struct device_attribute *attr, char *buf)
392 : : {
393 : : struct usb_device *udev = to_usb_device(dev);
394 : :
395 : 0 : return sprintf(buf, "%u\n",
396 : 0 : jiffies_to_msecs(jiffies - udev->connect_time));
397 : : }
398 : : static DEVICE_ATTR_RO(connected_duration);
399 : :
400 : : /*
401 : : * If the device is resumed, the last time the device was suspended has
402 : : * been pre-subtracted from active_duration. We add the current time to
403 : : * get the duration that the device was actually active.
404 : : *
405 : : * If the device is suspended, the active_duration is up-to-date.
406 : : */
407 : 0 : static ssize_t active_duration_show(struct device *dev,
408 : : struct device_attribute *attr, char *buf)
409 : : {
410 : : struct usb_device *udev = to_usb_device(dev);
411 : : int duration;
412 : :
413 [ # # ]: 0 : if (udev->state != USB_STATE_SUSPENDED)
414 : 0 : duration = jiffies_to_msecs(jiffies + udev->active_duration);
415 : : else
416 : 0 : duration = jiffies_to_msecs(udev->active_duration);
417 : 0 : return sprintf(buf, "%u\n", duration);
418 : : }
419 : : static DEVICE_ATTR_RO(active_duration);
420 : :
421 : 0 : static ssize_t autosuspend_show(struct device *dev,
422 : : struct device_attribute *attr, char *buf)
423 : : {
424 : 0 : return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
425 : : }
426 : :
427 : 0 : static ssize_t autosuspend_store(struct device *dev,
428 : : struct device_attribute *attr, const char *buf,
429 : : size_t count)
430 : : {
431 : : int value;
432 : :
433 [ # # # # : 0 : if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
# # ]
434 : : value <= -INT_MAX/1000)
435 : : return -EINVAL;
436 : :
437 : 0 : pm_runtime_set_autosuspend_delay(dev, value * 1000);
438 : 0 : return count;
439 : : }
440 : : static DEVICE_ATTR_RW(autosuspend);
441 : :
442 : : static const char on_string[] = "on";
443 : : static const char auto_string[] = "auto";
444 : :
445 : : static void warn_level(void)
446 : : {
447 : : static int level_warned;
448 : :
449 [ # # # # ]: 0 : if (!level_warned) {
450 : 0 : level_warned = 1;
451 : 0 : printk(KERN_WARNING "WARNING! power/level is deprecated; "
452 : : "use power/control instead\n");
453 : : }
454 : : }
455 : :
456 : 0 : static ssize_t level_show(struct device *dev, struct device_attribute *attr,
457 : : char *buf)
458 : : {
459 : : struct usb_device *udev = to_usb_device(dev);
460 : : const char *p = auto_string;
461 : :
462 : : warn_level();
463 [ # # # # ]: 0 : if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
464 : : p = on_string;
465 : 0 : return sprintf(buf, "%s\n", p);
466 : : }
467 : :
468 : 0 : static ssize_t level_store(struct device *dev, struct device_attribute *attr,
469 : : const char *buf, size_t count)
470 : : {
471 : 0 : struct usb_device *udev = to_usb_device(dev);
472 : 0 : int len = count;
473 : : char *cp;
474 : : int rc = count;
475 : : int rv;
476 : :
477 : : warn_level();
478 : 0 : cp = memchr(buf, '\n', count);
479 [ # # ]: 0 : if (cp)
480 : 0 : len = cp - buf;
481 : :
482 : : rv = usb_lock_device_interruptible(udev);
483 [ # # ]: 0 : if (rv < 0)
484 : : return -EINTR;
485 : :
486 [ # # # # ]: 0 : if (len == sizeof on_string - 1 &&
487 : 0 : strncmp(buf, on_string, len) == 0)
488 : 0 : usb_disable_autosuspend(udev);
489 : :
490 [ # # # # ]: 0 : else if (len == sizeof auto_string - 1 &&
491 : 0 : strncmp(buf, auto_string, len) == 0)
492 : 0 : usb_enable_autosuspend(udev);
493 : :
494 : : else
495 : : rc = -EINVAL;
496 : :
497 : : usb_unlock_device(udev);
498 : 0 : return rc;
499 : : }
500 : : static DEVICE_ATTR_RW(level);
501 : :
502 : 0 : static ssize_t usb2_hardware_lpm_show(struct device *dev,
503 : : struct device_attribute *attr, char *buf)
504 : : {
505 : : struct usb_device *udev = to_usb_device(dev);
506 : : const char *p;
507 : :
508 [ # # ]: 0 : if (udev->usb2_hw_lpm_allowed == 1)
509 : : p = "enabled";
510 : : else
511 : : p = "disabled";
512 : :
513 : 0 : return sprintf(buf, "%s\n", p);
514 : : }
515 : :
516 : 0 : static ssize_t usb2_hardware_lpm_store(struct device *dev,
517 : : struct device_attribute *attr,
518 : : const char *buf, size_t count)
519 : : {
520 : 0 : struct usb_device *udev = to_usb_device(dev);
521 : : bool value;
522 : : int ret;
523 : :
524 : : ret = usb_lock_device_interruptible(udev);
525 [ # # ]: 0 : if (ret < 0)
526 : : return -EINTR;
527 : :
528 : : ret = strtobool(buf, &value);
529 : :
530 [ # # ]: 0 : if (!ret) {
531 : 0 : udev->usb2_hw_lpm_allowed = value;
532 [ # # ]: 0 : if (value)
533 : 0 : ret = usb_enable_usb2_hardware_lpm(udev);
534 : : else
535 : 0 : ret = usb_disable_usb2_hardware_lpm(udev);
536 : : }
537 : :
538 : : usb_unlock_device(udev);
539 : :
540 [ # # ]: 0 : if (!ret)
541 : 0 : return count;
542 : :
543 : : return ret;
544 : : }
545 : : static DEVICE_ATTR_RW(usb2_hardware_lpm);
546 : :
547 : 0 : static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
548 : : struct device_attribute *attr,
549 : : char *buf)
550 : : {
551 : : struct usb_device *udev = to_usb_device(dev);
552 : 0 : return sprintf(buf, "%d\n", udev->l1_params.timeout);
553 : : }
554 : :
555 : 0 : static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
556 : : struct device_attribute *attr,
557 : : const char *buf, size_t count)
558 : : {
559 : : struct usb_device *udev = to_usb_device(dev);
560 : : u16 timeout;
561 : :
562 [ # # ]: 0 : if (kstrtou16(buf, 0, &timeout))
563 : : return -EINVAL;
564 : :
565 : 0 : udev->l1_params.timeout = timeout;
566 : :
567 : 0 : return count;
568 : : }
569 : : static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
570 : :
571 : 0 : static ssize_t usb2_lpm_besl_show(struct device *dev,
572 : : struct device_attribute *attr, char *buf)
573 : : {
574 : : struct usb_device *udev = to_usb_device(dev);
575 : 0 : return sprintf(buf, "%d\n", udev->l1_params.besl);
576 : : }
577 : :
578 : 0 : static ssize_t usb2_lpm_besl_store(struct device *dev,
579 : : struct device_attribute *attr,
580 : : const char *buf, size_t count)
581 : : {
582 : : struct usb_device *udev = to_usb_device(dev);
583 : : u8 besl;
584 : :
585 [ # # # # ]: 0 : if (kstrtou8(buf, 0, &besl) || besl > 15)
586 : : return -EINVAL;
587 : :
588 : 0 : udev->l1_params.besl = besl;
589 : :
590 : 0 : return count;
591 : : }
592 : : static DEVICE_ATTR_RW(usb2_lpm_besl);
593 : :
594 : 0 : static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
595 : : struct device_attribute *attr, char *buf)
596 : : {
597 : : struct usb_device *udev = to_usb_device(dev);
598 : : const char *p;
599 : : int rc;
600 : :
601 : : rc = usb_lock_device_interruptible(udev);
602 [ # # ]: 0 : if (rc < 0)
603 : : return -EINTR;
604 : :
605 [ # # ]: 0 : if (udev->usb3_lpm_u1_enabled)
606 : : p = "enabled";
607 : : else
608 : : p = "disabled";
609 : :
610 : : usb_unlock_device(udev);
611 : :
612 : 0 : return sprintf(buf, "%s\n", p);
613 : : }
614 : : static DEVICE_ATTR_RO(usb3_hardware_lpm_u1);
615 : :
616 : 0 : static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
617 : : struct device_attribute *attr, char *buf)
618 : : {
619 : : struct usb_device *udev = to_usb_device(dev);
620 : : const char *p;
621 : : int rc;
622 : :
623 : : rc = usb_lock_device_interruptible(udev);
624 [ # # ]: 0 : if (rc < 0)
625 : : return -EINTR;
626 : :
627 [ # # ]: 0 : if (udev->usb3_lpm_u2_enabled)
628 : : p = "enabled";
629 : : else
630 : : p = "disabled";
631 : :
632 : : usb_unlock_device(udev);
633 : :
634 : 0 : return sprintf(buf, "%s\n", p);
635 : : }
636 : : static DEVICE_ATTR_RO(usb3_hardware_lpm_u2);
637 : :
638 : : static struct attribute *usb2_hardware_lpm_attr[] = {
639 : : &dev_attr_usb2_hardware_lpm.attr,
640 : : &dev_attr_usb2_lpm_l1_timeout.attr,
641 : : &dev_attr_usb2_lpm_besl.attr,
642 : : NULL,
643 : : };
644 : : static struct attribute_group usb2_hardware_lpm_attr_group = {
645 : : .name = power_group_name,
646 : : .attrs = usb2_hardware_lpm_attr,
647 : : };
648 : :
649 : : static struct attribute *usb3_hardware_lpm_attr[] = {
650 : : &dev_attr_usb3_hardware_lpm_u1.attr,
651 : : &dev_attr_usb3_hardware_lpm_u2.attr,
652 : : NULL,
653 : : };
654 : : static struct attribute_group usb3_hardware_lpm_attr_group = {
655 : : .name = power_group_name,
656 : : .attrs = usb3_hardware_lpm_attr,
657 : : };
658 : :
659 : : static struct attribute *power_attrs[] = {
660 : : &dev_attr_autosuspend.attr,
661 : : &dev_attr_level.attr,
662 : : &dev_attr_connected_duration.attr,
663 : : &dev_attr_active_duration.attr,
664 : : NULL,
665 : : };
666 : : static struct attribute_group power_attr_group = {
667 : : .name = power_group_name,
668 : : .attrs = power_attrs,
669 : : };
670 : :
671 : 2020 : static int add_power_attributes(struct device *dev)
672 : : {
673 : : int rc = 0;
674 : :
675 [ + - ]: 2020 : if (is_usb_device(dev)) {
676 : : struct usb_device *udev = to_usb_device(dev);
677 : 2020 : rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
678 [ - + ]: 2020 : if (udev->usb2_hw_lpm_capable == 1)
679 : 0 : rc = sysfs_merge_group(&dev->kobj,
680 : : &usb2_hardware_lpm_attr_group);
681 [ - + ]: 2020 : if ((udev->speed == USB_SPEED_SUPER ||
682 [ # # ]: 0 : udev->speed == USB_SPEED_SUPER_PLUS) &&
683 : 0 : udev->lpm_capable == 1)
684 : 0 : rc = sysfs_merge_group(&dev->kobj,
685 : : &usb3_hardware_lpm_attr_group);
686 : : }
687 : :
688 : 2020 : return rc;
689 : : }
690 : :
691 : 0 : static void remove_power_attributes(struct device *dev)
692 : : {
693 : 0 : sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
694 : 0 : sysfs_unmerge_group(&dev->kobj, &power_attr_group);
695 : 0 : }
696 : :
697 : : #else
698 : :
699 : : #define add_persist_attributes(dev) 0
700 : : #define remove_persist_attributes(dev) do {} while (0)
701 : :
702 : : #define add_power_attributes(dev) 0
703 : : #define remove_power_attributes(dev) do {} while (0)
704 : :
705 : : #endif /* CONFIG_PM */
706 : :
707 : :
708 : : /* Descriptor fields */
709 : : #define usb_descriptor_attr_le16(field, format_string) \
710 : : static ssize_t \
711 : : field##_show(struct device *dev, struct device_attribute *attr, \
712 : : char *buf) \
713 : : { \
714 : : struct usb_device *udev; \
715 : : \
716 : : udev = to_usb_device(dev); \
717 : : return sprintf(buf, format_string, \
718 : : le16_to_cpu(udev->descriptor.field)); \
719 : : } \
720 : : static DEVICE_ATTR_RO(field)
721 : :
722 : 33192 : usb_descriptor_attr_le16(idVendor, "%04x\n");
723 : 4444 : usb_descriptor_attr_le16(idProduct, "%04x\n");
724 : 4444 : usb_descriptor_attr_le16(bcdDevice, "%04x\n");
725 : :
726 : : #define usb_descriptor_attr(field, format_string) \
727 : : static ssize_t \
728 : : field##_show(struct device *dev, struct device_attribute *attr, \
729 : : char *buf) \
730 : : { \
731 : : struct usb_device *udev; \
732 : : \
733 : : udev = to_usb_device(dev); \
734 : : return sprintf(buf, format_string, udev->descriptor.field); \
735 : : } \
736 : : static DEVICE_ATTR_RO(field)
737 : :
738 : 3232 : usb_descriptor_attr(bDeviceClass, "%02x\n");
739 : 0 : usb_descriptor_attr(bDeviceSubClass, "%02x\n");
740 : 0 : usb_descriptor_attr(bDeviceProtocol, "%02x\n");
741 : 0 : usb_descriptor_attr(bNumConfigurations, "%d\n");
742 : 0 : usb_descriptor_attr(bMaxPacketSize0, "%d\n");
743 : :
744 : :
745 : : /* show if the device is authorized (1) or not (0) */
746 : 0 : static ssize_t authorized_show(struct device *dev,
747 : : struct device_attribute *attr, char *buf)
748 : : {
749 : : struct usb_device *usb_dev = to_usb_device(dev);
750 : 0 : return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
751 : : }
752 : :
753 : : /*
754 : : * Authorize a device to be used in the system
755 : : *
756 : : * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
757 : : */
758 : 0 : static ssize_t authorized_store(struct device *dev,
759 : : struct device_attribute *attr, const char *buf,
760 : : size_t size)
761 : : {
762 : : ssize_t result;
763 : 0 : struct usb_device *usb_dev = to_usb_device(dev);
764 : : unsigned val;
765 : 0 : result = sscanf(buf, "%u\n", &val);
766 [ # # ]: 0 : if (result != 1)
767 : : result = -EINVAL;
768 [ # # ]: 0 : else if (val == 0)
769 : 0 : result = usb_deauthorize_device(usb_dev);
770 : : else
771 : 0 : result = usb_authorize_device(usb_dev);
772 [ # # ]: 0 : return result < 0 ? result : size;
773 : : }
774 : : static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
775 : : authorized_show, authorized_store);
776 : :
777 : : /* "Safely remove a device" */
778 : 0 : static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
779 : : const char *buf, size_t count)
780 : : {
781 : 0 : struct usb_device *udev = to_usb_device(dev);
782 : : int rc = 0;
783 : :
784 : : usb_lock_device(udev);
785 [ # # ]: 0 : if (udev->state != USB_STATE_NOTATTACHED) {
786 : :
787 : : /* To avoid races, first unconfigure and then remove */
788 : 0 : usb_set_configuration(udev, -1);
789 : 0 : rc = usb_remove_device(udev);
790 : : }
791 [ # # ]: 0 : if (rc == 0)
792 : 0 : rc = count;
793 : : usb_unlock_device(udev);
794 : 0 : return rc;
795 : : }
796 : : static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
797 : :
798 : :
799 : : static struct attribute *dev_attrs[] = {
800 : : /* current configuration's attributes */
801 : : &dev_attr_configuration.attr,
802 : : &dev_attr_bNumInterfaces.attr,
803 : : &dev_attr_bConfigurationValue.attr,
804 : : &dev_attr_bmAttributes.attr,
805 : : &dev_attr_bMaxPower.attr,
806 : : /* device attributes */
807 : : &dev_attr_urbnum.attr,
808 : : &dev_attr_idVendor.attr,
809 : : &dev_attr_idProduct.attr,
810 : : &dev_attr_bcdDevice.attr,
811 : : &dev_attr_bDeviceClass.attr,
812 : : &dev_attr_bDeviceSubClass.attr,
813 : : &dev_attr_bDeviceProtocol.attr,
814 : : &dev_attr_bNumConfigurations.attr,
815 : : &dev_attr_bMaxPacketSize0.attr,
816 : : &dev_attr_speed.attr,
817 : : &dev_attr_rx_lanes.attr,
818 : : &dev_attr_tx_lanes.attr,
819 : : &dev_attr_busnum.attr,
820 : : &dev_attr_devnum.attr,
821 : : &dev_attr_devpath.attr,
822 : : &dev_attr_version.attr,
823 : : &dev_attr_maxchild.attr,
824 : : &dev_attr_quirks.attr,
825 : : &dev_attr_avoid_reset_quirk.attr,
826 : : &dev_attr_authorized.attr,
827 : : &dev_attr_remove.attr,
828 : : &dev_attr_removable.attr,
829 : : &dev_attr_ltm_capable.attr,
830 : : #ifdef CONFIG_OF
831 : : &dev_attr_devspec.attr,
832 : : #endif
833 : : NULL,
834 : : };
835 : : static struct attribute_group dev_attr_grp = {
836 : : .attrs = dev_attrs,
837 : : };
838 : :
839 : : /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
840 : : * accordingly.
841 : : */
842 : : static struct attribute *dev_string_attrs[] = {
843 : : &dev_attr_manufacturer.attr,
844 : : &dev_attr_product.attr,
845 : : &dev_attr_serial.attr,
846 : : NULL
847 : : };
848 : :
849 : 6060 : static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
850 : : struct attribute *a, int n)
851 : : {
852 : : struct device *dev = container_of(kobj, struct device, kobj);
853 : : struct usb_device *udev = to_usb_device(dev);
854 : :
855 [ + + ]: 6060 : if (a == &dev_attr_manufacturer.attr) {
856 [ + - ]: 2020 : if (udev->manufacturer == NULL)
857 : : return 0;
858 [ + + ]: 4040 : } else if (a == &dev_attr_product.attr) {
859 [ + - ]: 2020 : if (udev->product == NULL)
860 : : return 0;
861 [ + - ]: 2020 : } else if (a == &dev_attr_serial.attr) {
862 [ + - ]: 2020 : if (udev->serial == NULL)
863 : : return 0;
864 : : }
865 : 6060 : return a->mode;
866 : : }
867 : :
868 : : static struct attribute_group dev_string_attr_grp = {
869 : : .attrs = dev_string_attrs,
870 : : .is_visible = dev_string_attrs_are_visible,
871 : : };
872 : :
873 : : const struct attribute_group *usb_device_groups[] = {
874 : : &dev_attr_grp,
875 : : &dev_string_attr_grp,
876 : : NULL
877 : : };
878 : :
879 : : /* Binary descriptors */
880 : :
881 : : static ssize_t
882 : 4464 : read_descriptors(struct file *filp, struct kobject *kobj,
883 : : struct bin_attribute *attr,
884 : : char *buf, loff_t off, size_t count)
885 : : {
886 : : struct device *dev = container_of(kobj, struct device, kobj);
887 : : struct usb_device *udev = to_usb_device(dev);
888 : : size_t nleft = count;
889 : : size_t srclen, n;
890 : : int cfgno;
891 : : void *src;
892 : :
893 : : /* The binary attribute begins with the device descriptor.
894 : : * Following that are the raw descriptor entries for all the
895 : : * configurations (config plus subsidiary descriptors).
896 : : */
897 [ + + + + ]: 18664 : for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
898 : 9736 : nleft > 0; ++cfgno) {
899 [ + + ]: 9736 : if (cfgno < 0) {
900 : 4462 : src = &udev->descriptor;
901 : : srclen = sizeof(struct usb_device_descriptor);
902 : : } else {
903 : 5274 : src = udev->rawdescriptors[cfgno];
904 : 5274 : srclen = __le16_to_cpu(udev->config[cfgno].desc.
905 : : wTotalLength);
906 : : }
907 [ + + ]: 9736 : if (off < srclen) {
908 : 9714 : n = min(nleft, srclen - (size_t) off);
909 : 9714 : memcpy(buf, src + off, n);
910 : 9714 : nleft -= n;
911 : 9714 : buf += n;
912 : : off = 0;
913 : : } else {
914 : 22 : off -= srclen;
915 : : }
916 : : }
917 : 4464 : return count - nleft;
918 : : }
919 : :
920 : : static struct bin_attribute dev_bin_attr_descriptors = {
921 : : .attr = {.name = "descriptors", .mode = 0444},
922 : : .read = read_descriptors,
923 : : .size = 18 + 65535, /* dev descr + max-size raw descriptor */
924 : : };
925 : :
926 : : /*
927 : : * Show & store the current value of authorized_default
928 : : */
929 : 0 : static ssize_t authorized_default_show(struct device *dev,
930 : : struct device_attribute *attr, char *buf)
931 : : {
932 : : struct usb_device *rh_usb_dev = to_usb_device(dev);
933 : 0 : struct usb_bus *usb_bus = rh_usb_dev->bus;
934 : : struct usb_hcd *hcd;
935 : :
936 : : hcd = bus_to_hcd(usb_bus);
937 : 0 : return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy);
938 : : }
939 : :
940 : 0 : static ssize_t authorized_default_store(struct device *dev,
941 : : struct device_attribute *attr,
942 : : const char *buf, size_t size)
943 : : {
944 : : ssize_t result;
945 : : unsigned int val;
946 : : struct usb_device *rh_usb_dev = to_usb_device(dev);
947 : 0 : struct usb_bus *usb_bus = rh_usb_dev->bus;
948 : : struct usb_hcd *hcd;
949 : :
950 : : hcd = bus_to_hcd(usb_bus);
951 : 0 : result = sscanf(buf, "%u\n", &val);
952 [ # # ]: 0 : if (result == 1) {
953 [ # # ]: 0 : hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ?
954 : : val : USB_DEVICE_AUTHORIZE_ALL;
955 : 0 : result = size;
956 : : } else {
957 : : result = -EINVAL;
958 : : }
959 : 0 : return result;
960 : : }
961 : : static DEVICE_ATTR_RW(authorized_default);
962 : :
963 : : /*
964 : : * interface_authorized_default_show - show default authorization status
965 : : * for USB interfaces
966 : : *
967 : : * note: interface_authorized_default is the default value
968 : : * for initializing the authorized attribute of interfaces
969 : : */
970 : 0 : static ssize_t interface_authorized_default_show(struct device *dev,
971 : : struct device_attribute *attr, char *buf)
972 : : {
973 : : struct usb_device *usb_dev = to_usb_device(dev);
974 : 0 : struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
975 : :
976 : 0 : return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd));
977 : : }
978 : :
979 : : /*
980 : : * interface_authorized_default_store - store default authorization status
981 : : * for USB interfaces
982 : : *
983 : : * note: interface_authorized_default is the default value
984 : : * for initializing the authorized attribute of interfaces
985 : : */
986 : 0 : static ssize_t interface_authorized_default_store(struct device *dev,
987 : : struct device_attribute *attr, const char *buf, size_t count)
988 : : {
989 : : struct usb_device *usb_dev = to_usb_device(dev);
990 : 0 : struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
991 : 0 : int rc = count;
992 : : bool val;
993 : :
994 [ # # ]: 0 : if (strtobool(buf, &val) != 0)
995 : : return -EINVAL;
996 : :
997 [ # # ]: 0 : if (val)
998 : 0 : set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
999 : : else
1000 : 0 : clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
1001 : :
1002 : 0 : return rc;
1003 : : }
1004 : : static DEVICE_ATTR_RW(interface_authorized_default);
1005 : :
1006 : : /* Group all the USB bus attributes */
1007 : : static struct attribute *usb_bus_attrs[] = {
1008 : : &dev_attr_authorized_default.attr,
1009 : : &dev_attr_interface_authorized_default.attr,
1010 : : NULL,
1011 : : };
1012 : :
1013 : : static const struct attribute_group usb_bus_attr_group = {
1014 : : .name = NULL, /* we want them in the same directory */
1015 : : .attrs = usb_bus_attrs,
1016 : : };
1017 : :
1018 : :
1019 : : static int add_default_authorized_attributes(struct device *dev)
1020 : : {
1021 : : int rc = 0;
1022 : :
1023 [ + - ]: 404 : if (is_usb_device(dev))
1024 : 404 : rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group);
1025 : :
1026 : : return rc;
1027 : : }
1028 : :
1029 : : static void remove_default_authorized_attributes(struct device *dev)
1030 : : {
1031 [ # # ]: 0 : if (is_usb_device(dev)) {
1032 : 0 : sysfs_remove_group(&dev->kobj, &usb_bus_attr_group);
1033 : : }
1034 : : }
1035 : :
1036 : 2020 : int usb_create_sysfs_dev_files(struct usb_device *udev)
1037 : : {
1038 : 2020 : struct device *dev = &udev->dev;
1039 : : int retval;
1040 : :
1041 : 2020 : retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
1042 [ + - ]: 2020 : if (retval)
1043 : : goto error;
1044 : :
1045 : 2020 : retval = add_persist_attributes(dev);
1046 [ + - ]: 2020 : if (retval)
1047 : : goto error;
1048 : :
1049 : 2020 : retval = add_power_attributes(dev);
1050 [ + - ]: 2020 : if (retval)
1051 : : goto error;
1052 : :
1053 [ + + ]: 2020 : if (is_root_hub(udev)) {
1054 : : retval = add_default_authorized_attributes(dev);
1055 [ + - ]: 404 : if (retval)
1056 : : goto error;
1057 : : }
1058 : 2020 : return retval;
1059 : :
1060 : : error:
1061 : 0 : usb_remove_sysfs_dev_files(udev);
1062 : 0 : return retval;
1063 : : }
1064 : :
1065 : 0 : void usb_remove_sysfs_dev_files(struct usb_device *udev)
1066 : : {
1067 : 0 : struct device *dev = &udev->dev;
1068 : :
1069 [ # # ]: 0 : if (is_root_hub(udev))
1070 : : remove_default_authorized_attributes(dev);
1071 : :
1072 : 0 : remove_power_attributes(dev);
1073 : : remove_persist_attributes(dev);
1074 : 0 : device_remove_bin_file(dev, &dev_bin_attr_descriptors);
1075 : 0 : }
1076 : :
1077 : : /* Interface Association Descriptor fields */
1078 : : #define usb_intf_assoc_attr(field, format_string) \
1079 : : static ssize_t \
1080 : : iad_##field##_show(struct device *dev, struct device_attribute *attr, \
1081 : : char *buf) \
1082 : : { \
1083 : : struct usb_interface *intf = to_usb_interface(dev); \
1084 : : \
1085 : : return sprintf(buf, format_string, \
1086 : : intf->intf_assoc->field); \
1087 : : } \
1088 : : static DEVICE_ATTR_RO(iad_##field)
1089 : :
1090 : 0 : usb_intf_assoc_attr(bFirstInterface, "%02x\n");
1091 : 0 : usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
1092 : 0 : usb_intf_assoc_attr(bFunctionClass, "%02x\n");
1093 : 0 : usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
1094 : 0 : usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
1095 : :
1096 : : /* Interface fields */
1097 : : #define usb_intf_attr(field, format_string) \
1098 : : static ssize_t \
1099 : : field##_show(struct device *dev, struct device_attribute *attr, \
1100 : : char *buf) \
1101 : : { \
1102 : : struct usb_interface *intf = to_usb_interface(dev); \
1103 : : \
1104 : : return sprintf(buf, format_string, \
1105 : : intf->cur_altsetting->desc.field); \
1106 : : } \
1107 : : static DEVICE_ATTR_RO(field)
1108 : :
1109 : 4848 : usb_intf_attr(bInterfaceNumber, "%02x\n");
1110 : 0 : usb_intf_attr(bAlternateSetting, "%2d\n");
1111 : 1616 : usb_intf_attr(bNumEndpoints, "%02x\n");
1112 : 9852 : usb_intf_attr(bInterfaceClass, "%02x\n");
1113 : 808 : usb_intf_attr(bInterfaceSubClass, "%02x\n");
1114 : 808 : usb_intf_attr(bInterfaceProtocol, "%02x\n");
1115 : :
1116 : 0 : static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
1117 : : char *buf)
1118 : : {
1119 : : struct usb_interface *intf;
1120 : : char *string;
1121 : :
1122 : : intf = to_usb_interface(dev);
1123 : 0 : string = READ_ONCE(intf->cur_altsetting->string);
1124 [ # # ]: 0 : if (!string)
1125 : : return 0;
1126 : 0 : return sprintf(buf, "%s\n", string);
1127 : : }
1128 : : static DEVICE_ATTR_RO(interface);
1129 : :
1130 : 0 : static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
1131 : : char *buf)
1132 : : {
1133 : : struct usb_interface *intf;
1134 : : struct usb_device *udev;
1135 : : struct usb_host_interface *alt;
1136 : :
1137 : : intf = to_usb_interface(dev);
1138 : : udev = interface_to_usbdev(intf);
1139 : 0 : alt = READ_ONCE(intf->cur_altsetting);
1140 : :
1141 : 0 : return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
1142 : : "ic%02Xisc%02Xip%02Xin%02X\n",
1143 : 0 : le16_to_cpu(udev->descriptor.idVendor),
1144 : 0 : le16_to_cpu(udev->descriptor.idProduct),
1145 : 0 : le16_to_cpu(udev->descriptor.bcdDevice),
1146 : 0 : udev->descriptor.bDeviceClass,
1147 : 0 : udev->descriptor.bDeviceSubClass,
1148 : 0 : udev->descriptor.bDeviceProtocol,
1149 : 0 : alt->desc.bInterfaceClass,
1150 : 0 : alt->desc.bInterfaceSubClass,
1151 : 0 : alt->desc.bInterfaceProtocol,
1152 : 0 : alt->desc.bInterfaceNumber);
1153 : : }
1154 : : static DEVICE_ATTR_RO(modalias);
1155 : :
1156 : 0 : static ssize_t supports_autosuspend_show(struct device *dev,
1157 : : struct device_attribute *attr,
1158 : : char *buf)
1159 : : {
1160 : : int s;
1161 : :
1162 : : s = device_lock_interruptible(dev);
1163 [ # # ]: 0 : if (s < 0)
1164 : : return -EINTR;
1165 : : /* Devices will be autosuspended even when an interface isn't claimed */
1166 [ # # # # ]: 0 : s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
1167 : : device_unlock(dev);
1168 : :
1169 : 0 : return sprintf(buf, "%u\n", s);
1170 : : }
1171 : : static DEVICE_ATTR_RO(supports_autosuspend);
1172 : :
1173 : : /*
1174 : : * interface_authorized_show - show authorization status of an USB interface
1175 : : * 1 is authorized, 0 is deauthorized
1176 : : */
1177 : 0 : static ssize_t interface_authorized_show(struct device *dev,
1178 : : struct device_attribute *attr, char *buf)
1179 : : {
1180 : : struct usb_interface *intf = to_usb_interface(dev);
1181 : :
1182 : 0 : return sprintf(buf, "%u\n", intf->authorized);
1183 : : }
1184 : :
1185 : : /*
1186 : : * interface_authorized_store - authorize or deauthorize an USB interface
1187 : : */
1188 : 0 : static ssize_t interface_authorized_store(struct device *dev,
1189 : : struct device_attribute *attr, const char *buf, size_t count)
1190 : : {
1191 : 0 : struct usb_interface *intf = to_usb_interface(dev);
1192 : : bool val;
1193 : :
1194 [ # # ]: 0 : if (strtobool(buf, &val) != 0)
1195 : : return -EINVAL;
1196 : :
1197 [ # # ]: 0 : if (val)
1198 : 0 : usb_authorize_interface(intf);
1199 : : else
1200 : 0 : usb_deauthorize_interface(intf);
1201 : :
1202 : 0 : return count;
1203 : : }
1204 : : static struct device_attribute dev_attr_interface_authorized =
1205 : : __ATTR(authorized, S_IRUGO | S_IWUSR,
1206 : : interface_authorized_show, interface_authorized_store);
1207 : :
1208 : : static struct attribute *intf_attrs[] = {
1209 : : &dev_attr_bInterfaceNumber.attr,
1210 : : &dev_attr_bAlternateSetting.attr,
1211 : : &dev_attr_bNumEndpoints.attr,
1212 : : &dev_attr_bInterfaceClass.attr,
1213 : : &dev_attr_bInterfaceSubClass.attr,
1214 : : &dev_attr_bInterfaceProtocol.attr,
1215 : : &dev_attr_modalias.attr,
1216 : : &dev_attr_supports_autosuspend.attr,
1217 : : &dev_attr_interface_authorized.attr,
1218 : : NULL,
1219 : : };
1220 : : static struct attribute_group intf_attr_grp = {
1221 : : .attrs = intf_attrs,
1222 : : };
1223 : :
1224 : : static struct attribute *intf_assoc_attrs[] = {
1225 : : &dev_attr_iad_bFirstInterface.attr,
1226 : : &dev_attr_iad_bInterfaceCount.attr,
1227 : : &dev_attr_iad_bFunctionClass.attr,
1228 : : &dev_attr_iad_bFunctionSubClass.attr,
1229 : : &dev_attr_iad_bFunctionProtocol.attr,
1230 : : NULL,
1231 : : };
1232 : :
1233 : 12120 : static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
1234 : : struct attribute *a, int n)
1235 : : {
1236 : : struct device *dev = container_of(kobj, struct device, kobj);
1237 : : struct usb_interface *intf = to_usb_interface(dev);
1238 : :
1239 [ - + ]: 12120 : if (intf->intf_assoc == NULL)
1240 : : return 0;
1241 : 0 : return a->mode;
1242 : : }
1243 : :
1244 : : static struct attribute_group intf_assoc_attr_grp = {
1245 : : .attrs = intf_assoc_attrs,
1246 : : .is_visible = intf_assoc_attrs_are_visible,
1247 : : };
1248 : :
1249 : : const struct attribute_group *usb_interface_groups[] = {
1250 : : &intf_attr_grp,
1251 : : &intf_assoc_attr_grp,
1252 : : NULL
1253 : : };
1254 : :
1255 : 2828 : void usb_create_sysfs_intf_files(struct usb_interface *intf)
1256 : : {
1257 : : struct usb_device *udev = interface_to_usbdev(intf);
1258 : 2828 : struct usb_host_interface *alt = intf->cur_altsetting;
1259 : :
1260 [ + - ]: 2828 : if (intf->sysfs_files_created || intf->unregistering)
1261 : 2828 : return;
1262 : :
1263 [ + - + - ]: 2828 : if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
1264 : 2828 : alt->string = usb_cache_string(udev, alt->desc.iInterface);
1265 [ + + ]: 2828 : if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
1266 : : ; /* We don't actually care if the function fails. */
1267 : 2828 : intf->sysfs_files_created = 1;
1268 : : }
1269 : :
1270 : 404 : void usb_remove_sysfs_intf_files(struct usb_interface *intf)
1271 : : {
1272 [ + - ]: 404 : if (!intf->sysfs_files_created)
1273 : 404 : return;
1274 : :
1275 : 404 : device_remove_file(&intf->dev, &dev_attr_interface);
1276 : 404 : intf->sysfs_files_created = 0;
1277 : : }
|
