1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/kernel.h>
14#include <linux/string.h>
15#include <linux/usb.h>
16#include "usb.h"
17
18
19#define usb_actconfig_show(field, multiplier, format_string) \
20static ssize_t show_##field(struct device *dev, \
21 struct device_attribute *attr, char *buf) \
22{ \
23 struct usb_device *udev; \
24 struct usb_host_config *actconfig; \
25 \
26 udev = to_usb_device(dev); \
27 actconfig = udev->actconfig; \
28 if (actconfig) \
29 return sprintf(buf, format_string, \
30 actconfig->desc.field * multiplier); \
31 else \
32 return 0; \
33} \
34
35#define usb_actconfig_attr(field, multiplier, format_string) \
36usb_actconfig_show(field, multiplier, format_string) \
37static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
38
39usb_actconfig_attr(bNumInterfaces, 1, "%2d\n")
40usb_actconfig_attr(bmAttributes, 1, "%2x\n")
41usb_actconfig_attr(bMaxPower, 2, "%3dmA\n")
42
43static ssize_t show_configuration_string(struct device *dev,
44 struct device_attribute *attr, char *buf)
45{
46 struct usb_device *udev;
47 struct usb_host_config *actconfig;
48
49 udev = to_usb_device(dev);
50 actconfig = udev->actconfig;
51 if ((!actconfig) || (!actconfig->string))
52 return 0;
53 return sprintf(buf, "%s\n", actconfig->string);
54}
55static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL);
56
57
58usb_actconfig_show(bConfigurationValue, 1, "%u\n");
59
60static ssize_t
61set_bConfigurationValue(struct device *dev, struct device_attribute *attr,
62 const char *buf, size_t count)
63{
64 struct usb_device *udev = to_usb_device(dev);
65 int config, value;
66
67 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
68 return -EINVAL;
69 usb_lock_device(udev);
70 value = usb_set_configuration(udev, config);
71 usb_unlock_device(udev);
72 return (value < 0) ? value : count;
73}
74
75static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR,
76 show_bConfigurationValue, set_bConfigurationValue);
77
78
79#define usb_string_attr(name) \
80static ssize_t show_##name(struct device *dev, \
81 struct device_attribute *attr, char *buf) \
82{ \
83 struct usb_device *udev; \
84 \
85 udev = to_usb_device(dev); \
86 return sprintf(buf, "%s\n", udev->name); \
87} \
88static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
89
90usb_string_attr(product);
91usb_string_attr(manufacturer);
92usb_string_attr(serial);
93
94static ssize_t
95show_speed(struct device *dev, struct device_attribute *attr, char *buf)
96{
97 struct usb_device *udev;
98 char *speed;
99
100 udev = to_usb_device(dev);
101
102 switch (udev->speed) {
103 case USB_SPEED_LOW:
104 speed = "1.5";
105 break;
106 case USB_SPEED_UNKNOWN:
107 case USB_SPEED_FULL:
108 speed = "12";
109 break;
110 case USB_SPEED_HIGH:
111 speed = "480";
112 break;
113 default:
114 speed = "unknown";
115 }
116 return sprintf(buf, "%s\n", speed);
117}
118static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL);
119
120static ssize_t
121show_busnum(struct device *dev, struct device_attribute *attr, char *buf)
122{
123 struct usb_device *udev;
124
125 udev = to_usb_device(dev);
126 return sprintf(buf, "%d\n", udev->bus->busnum);
127}
128static DEVICE_ATTR(busnum, S_IRUGO, show_busnum, NULL);
129
130static ssize_t
131show_devnum(struct device *dev, struct device_attribute *attr, char *buf)
132{
133 struct usb_device *udev;
134
135 udev = to_usb_device(dev);
136 return sprintf(buf, "%d\n", udev->devnum);
137}
138static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL);
139
140static ssize_t
141show_version(struct device *dev, struct device_attribute *attr, char *buf)
142{
143 struct usb_device *udev;
144 u16 bcdUSB;
145
146 udev = to_usb_device(dev);
147 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
148 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
149}
150static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
151
152static ssize_t
153show_maxchild(struct device *dev, struct device_attribute *attr, char *buf)
154{
155 struct usb_device *udev;
156
157 udev = to_usb_device(dev);
158 return sprintf(buf, "%d\n", udev->maxchild);
159}
160static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL);
161
162static ssize_t
163show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
164{
165 struct usb_device *udev;
166
167 udev = to_usb_device(dev);
168 return sprintf(buf, "0x%x\n", udev->quirks);
169}
170static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
171
172static ssize_t
173show_urbnum(struct device *dev, struct device_attribute *attr, char *buf)
174{
175 struct usb_device *udev;
176
177 udev = to_usb_device(dev);
178 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
179}
180static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
181
182
183#ifdef CONFIG_PM
184
185static const char power_group[] = "power";
186
187static ssize_t
188show_persist(struct device *dev, struct device_attribute *attr, char *buf)
189{
190 struct usb_device *udev = to_usb_device(dev);
191
192 return sprintf(buf, "%d\n", udev->persist_enabled);
193}
194
195static ssize_t
196set_persist(struct device *dev, struct device_attribute *attr,
197 const char *buf, size_t count)
198{
199 struct usb_device *udev = to_usb_device(dev);
200 int value;
201
202
203 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
204 return -EPERM;
205
206 if (sscanf(buf, "%d", &value) != 1)
207 return -EINVAL;
208 usb_pm_lock(udev);
209 udev->persist_enabled = !!value;
210 usb_pm_unlock(udev);
211 return count;
212}
213
214static DEVICE_ATTR(persist, S_IRUGO | S_IWUSR, show_persist, set_persist);
215
216static int add_persist_attributes(struct device *dev)
217{
218 int rc = 0;
219
220 if (is_usb_device(dev)) {
221 struct usb_device *udev = to_usb_device(dev);
222
223
224
225
226 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
227 rc = sysfs_add_file_to_group(&dev->kobj,
228 &dev_attr_persist.attr,
229 power_group);
230 }
231 return rc;
232}
233
234static void remove_persist_attributes(struct device *dev)
235{
236 sysfs_remove_file_from_group(&dev->kobj,
237 &dev_attr_persist.attr,
238 power_group);
239}
240#else
241
242#define add_persist_attributes(dev) 0
243#define remove_persist_attributes(dev) do {} while (0)
244
245#endif
246
247#ifdef CONFIG_USB_SUSPEND
248
249static ssize_t
250show_connected_duration(struct device *dev, struct device_attribute *attr,
251 char *buf)
252{
253 struct usb_device *udev = to_usb_device(dev);
254
255 return sprintf(buf, "%u\n",
256 jiffies_to_msecs(jiffies - udev->connect_time));
257}
258
259static DEVICE_ATTR(connected_duration, S_IRUGO, show_connected_duration, NULL);
260
261
262
263
264
265
266
267
268static ssize_t
269show_active_duration(struct device *dev, struct device_attribute *attr,
270 char *buf)
271{
272 struct usb_device *udev = to_usb_device(dev);
273 int duration;
274
275 if (udev->state != USB_STATE_SUSPENDED)
276 duration = jiffies_to_msecs(jiffies + udev->active_duration);
277 else
278 duration = jiffies_to_msecs(udev->active_duration);
279 return sprintf(buf, "%u\n", duration);
280}
281
282static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL);
283
284static ssize_t
285show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
286{
287 struct usb_device *udev = to_usb_device(dev);
288
289 return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ);
290}
291
292static ssize_t
293set_autosuspend(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 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
300 value <= - INT_MAX/HZ)
301 return -EINVAL;
302 value *= HZ;
303
304 udev->autosuspend_delay = value;
305 if (value >= 0)
306 usb_try_autosuspend_device(udev);
307 else {
308 if (usb_autoresume_device(udev) == 0)
309 usb_autosuspend_device(udev);
310 }
311 return count;
312}
313
314static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR,
315 show_autosuspend, set_autosuspend);
316
317static const char on_string[] = "on";
318static const char auto_string[] = "auto";
319static const char suspend_string[] = "suspend";
320
321static ssize_t
322show_level(struct device *dev, struct device_attribute *attr, char *buf)
323{
324 struct usb_device *udev = to_usb_device(dev);
325 const char *p = auto_string;
326
327 if (udev->state == USB_STATE_SUSPENDED) {
328 if (udev->autoresume_disabled)
329 p = suspend_string;
330 } else {
331 if (udev->autosuspend_disabled)
332 p = on_string;
333 }
334 return sprintf(buf, "%s\n", p);
335}
336
337static ssize_t
338set_level(struct device *dev, struct device_attribute *attr,
339 const char *buf, size_t count)
340{
341 struct usb_device *udev = to_usb_device(dev);
342 int len = count;
343 char *cp;
344 int rc = 0;
345 int old_autosuspend_disabled, old_autoresume_disabled;
346
347 cp = memchr(buf, '\n', count);
348 if (cp)
349 len = cp - buf;
350
351 usb_lock_device(udev);
352 old_autosuspend_disabled = udev->autosuspend_disabled;
353 old_autoresume_disabled = udev->autoresume_disabled;
354
355
356
357
358 if (len == sizeof on_string - 1 &&
359 strncmp(buf, on_string, len) == 0) {
360 udev->autosuspend_disabled = 1;
361 udev->autoresume_disabled = 0;
362 rc = usb_external_resume_device(udev);
363
364 } else if (len == sizeof auto_string - 1 &&
365 strncmp(buf, auto_string, len) == 0) {
366 udev->autosuspend_disabled = 0;
367 udev->autoresume_disabled = 0;
368 rc = usb_external_resume_device(udev);
369
370 } else if (len == sizeof suspend_string - 1 &&
371 strncmp(buf, suspend_string, len) == 0) {
372 udev->autosuspend_disabled = 0;
373 udev->autoresume_disabled = 1;
374 rc = usb_external_suspend_device(udev, PMSG_SUSPEND);
375
376 } else
377 rc = -EINVAL;
378
379 if (rc) {
380 udev->autosuspend_disabled = old_autosuspend_disabled;
381 udev->autoresume_disabled = old_autoresume_disabled;
382 }
383 usb_unlock_device(udev);
384 return (rc < 0 ? rc : count);
385}
386
387static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
388
389static int add_power_attributes(struct device *dev)
390{
391 int rc = 0;
392
393 if (is_usb_device(dev)) {
394 rc = sysfs_add_file_to_group(&dev->kobj,
395 &dev_attr_autosuspend.attr,
396 power_group);
397 if (rc == 0)
398 rc = sysfs_add_file_to_group(&dev->kobj,
399 &dev_attr_level.attr,
400 power_group);
401 if (rc == 0)
402 rc = sysfs_add_file_to_group(&dev->kobj,
403 &dev_attr_connected_duration.attr,
404 power_group);
405 if (rc == 0)
406 rc = sysfs_add_file_to_group(&dev->kobj,
407 &dev_attr_active_duration.attr,
408 power_group);
409 }
410 return rc;
411}
412
413static void remove_power_attributes(struct device *dev)
414{
415 sysfs_remove_file_from_group(&dev->kobj,
416 &dev_attr_active_duration.attr,
417 power_group);
418 sysfs_remove_file_from_group(&dev->kobj,
419 &dev_attr_connected_duration.attr,
420 power_group);
421 sysfs_remove_file_from_group(&dev->kobj,
422 &dev_attr_level.attr,
423 power_group);
424 sysfs_remove_file_from_group(&dev->kobj,
425 &dev_attr_autosuspend.attr,
426 power_group);
427}
428
429#else
430
431#define add_power_attributes(dev) 0
432#define remove_power_attributes(dev) do {} while (0)
433
434#endif
435
436
437
438#define usb_descriptor_attr_le16(field, format_string) \
439static ssize_t \
440show_##field(struct device *dev, struct device_attribute *attr, \
441 char *buf) \
442{ \
443 struct usb_device *udev; \
444 \
445 udev = to_usb_device(dev); \
446 return sprintf(buf, format_string, \
447 le16_to_cpu(udev->descriptor.field)); \
448} \
449static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
450
451usb_descriptor_attr_le16(idVendor, "%04x\n")
452usb_descriptor_attr_le16(idProduct, "%04x\n")
453usb_descriptor_attr_le16(bcdDevice, "%04x\n")
454
455#define usb_descriptor_attr(field, format_string) \
456static ssize_t \
457show_##field(struct device *dev, struct device_attribute *attr, \
458 char *buf) \
459{ \
460 struct usb_device *udev; \
461 \
462 udev = to_usb_device(dev); \
463 return sprintf(buf, format_string, udev->descriptor.field); \
464} \
465static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
466
467usb_descriptor_attr(bDeviceClass, "%02x\n")
468usb_descriptor_attr(bDeviceSubClass, "%02x\n")
469usb_descriptor_attr(bDeviceProtocol, "%02x\n")
470usb_descriptor_attr(bNumConfigurations, "%d\n")
471usb_descriptor_attr(bMaxPacketSize0, "%d\n")
472
473
474
475
476static ssize_t usb_dev_authorized_show(struct device *dev,
477 struct device_attribute *attr,
478 char *buf)
479{
480 struct usb_device *usb_dev = to_usb_device(dev);
481 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
482}
483
484
485
486
487
488
489
490static ssize_t usb_dev_authorized_store(struct device *dev,
491 struct device_attribute *attr,
492 const char *buf, size_t size)
493{
494 ssize_t result;
495 struct usb_device *usb_dev = to_usb_device(dev);
496 unsigned val;
497 result = sscanf(buf, "%u\n", &val);
498 if (result != 1)
499 result = -EINVAL;
500 else if (val == 0)
501 result = usb_deauthorize_device(usb_dev);
502 else
503 result = usb_authorize_device(usb_dev);
504 return result < 0? result : size;
505}
506
507static DEVICE_ATTR(authorized, 0644,
508 usb_dev_authorized_show, usb_dev_authorized_store);
509
510
511static struct attribute *dev_attrs[] = {
512
513 &dev_attr_configuration.attr,
514 &dev_attr_bNumInterfaces.attr,
515 &dev_attr_bConfigurationValue.attr,
516 &dev_attr_bmAttributes.attr,
517 &dev_attr_bMaxPower.attr,
518 &dev_attr_urbnum.attr,
519
520 &dev_attr_idVendor.attr,
521 &dev_attr_idProduct.attr,
522 &dev_attr_bcdDevice.attr,
523 &dev_attr_bDeviceClass.attr,
524 &dev_attr_bDeviceSubClass.attr,
525 &dev_attr_bDeviceProtocol.attr,
526 &dev_attr_bNumConfigurations.attr,
527 &dev_attr_bMaxPacketSize0.attr,
528 &dev_attr_speed.attr,
529 &dev_attr_busnum.attr,
530 &dev_attr_devnum.attr,
531 &dev_attr_version.attr,
532 &dev_attr_maxchild.attr,
533 &dev_attr_quirks.attr,
534 &dev_attr_authorized.attr,
535 NULL,
536};
537static struct attribute_group dev_attr_grp = {
538 .attrs = dev_attrs,
539};
540
541
542
543
544static struct attribute *dev_string_attrs[] = {
545 &dev_attr_manufacturer.attr,
546 &dev_attr_product.attr,
547 &dev_attr_serial.attr,
548 NULL
549};
550
551static mode_t dev_string_attrs_are_visible(struct kobject *kobj,
552 struct attribute *a, int n)
553{
554 struct usb_device *udev = to_usb_device(
555 container_of(kobj, struct device, kobj));
556
557 if (a == &dev_attr_manufacturer.attr) {
558 if (udev->manufacturer == NULL)
559 return 0;
560 } else if (a == &dev_attr_product.attr) {
561 if (udev->product == NULL)
562 return 0;
563 } else if (a == &dev_attr_serial.attr) {
564 if (udev->serial == NULL)
565 return 0;
566 }
567 return a->mode;
568}
569
570static struct attribute_group dev_string_attr_grp = {
571 .attrs = dev_string_attrs,
572 .is_visible = dev_string_attrs_are_visible,
573};
574
575struct attribute_group *usb_device_groups[] = {
576 &dev_attr_grp,
577 &dev_string_attr_grp,
578 NULL
579};
580
581
582
583static ssize_t
584read_descriptors(struct kobject *kobj, struct bin_attribute *attr,
585 char *buf, loff_t off, size_t count)
586{
587 struct usb_device *udev = to_usb_device(
588 container_of(kobj, struct device, kobj));
589 size_t nleft = count;
590 size_t srclen, n;
591 int cfgno;
592 void *src;
593
594
595
596
597
598 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
599 nleft > 0; ++cfgno) {
600 if (cfgno < 0) {
601 src = &udev->descriptor;
602 srclen = sizeof(struct usb_device_descriptor);
603 } else {
604 src = udev->rawdescriptors[cfgno];
605 srclen = __le16_to_cpu(udev->config[cfgno].desc.
606 wTotalLength);
607 }
608 if (off < srclen) {
609 n = min(nleft, srclen - (size_t) off);
610 memcpy(buf, src + off, n);
611 nleft -= n;
612 buf += n;
613 off = 0;
614 } else {
615 off -= srclen;
616 }
617 }
618 return count - nleft;
619}
620
621static struct bin_attribute dev_bin_attr_descriptors = {
622 .attr = {.name = "descriptors", .mode = 0444},
623 .read = read_descriptors,
624 .size = 18 + 65535,
625};
626
627int usb_create_sysfs_dev_files(struct usb_device *udev)
628{
629 struct device *dev = &udev->dev;
630 int retval;
631
632
633
634
635 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
636 if (retval)
637 goto error;
638
639 retval = add_persist_attributes(dev);
640 if (retval)
641 goto error;
642
643 retval = add_power_attributes(dev);
644 if (retval)
645 goto error;
646
647 retval = usb_create_ep_files(dev, &udev->ep0, udev);
648 if (retval)
649 goto error;
650 return 0;
651error:
652 usb_remove_sysfs_dev_files(udev);
653 return retval;
654}
655
656void usb_remove_sysfs_dev_files(struct usb_device *udev)
657{
658 struct device *dev = &udev->dev;
659
660 usb_remove_ep_files(&udev->ep0);
661 remove_power_attributes(dev);
662 remove_persist_attributes(dev);
663 device_remove_bin_file(dev, &dev_bin_attr_descriptors);
664}
665
666
667#define usb_intf_assoc_attr(field, format_string) \
668static ssize_t \
669show_iad_##field(struct device *dev, struct device_attribute *attr, \
670 char *buf) \
671{ \
672 struct usb_interface *intf = to_usb_interface(dev); \
673 \
674 return sprintf(buf, format_string, \
675 intf->intf_assoc->field); \
676} \
677static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL);
678
679usb_intf_assoc_attr(bFirstInterface, "%02x\n")
680usb_intf_assoc_attr(bInterfaceCount, "%02d\n")
681usb_intf_assoc_attr(bFunctionClass, "%02x\n")
682usb_intf_assoc_attr(bFunctionSubClass, "%02x\n")
683usb_intf_assoc_attr(bFunctionProtocol, "%02x\n")
684
685
686#define usb_intf_attr(field, format_string) \
687static ssize_t \
688show_##field(struct device *dev, struct device_attribute *attr, \
689 char *buf) \
690{ \
691 struct usb_interface *intf = to_usb_interface(dev); \
692 \
693 return sprintf(buf, format_string, \
694 intf->cur_altsetting->desc.field); \
695} \
696static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
697
698usb_intf_attr(bInterfaceNumber, "%02x\n")
699usb_intf_attr(bAlternateSetting, "%2d\n")
700usb_intf_attr(bNumEndpoints, "%02x\n")
701usb_intf_attr(bInterfaceClass, "%02x\n")
702usb_intf_attr(bInterfaceSubClass, "%02x\n")
703usb_intf_attr(bInterfaceProtocol, "%02x\n")
704
705static ssize_t show_interface_string(struct device *dev,
706 struct device_attribute *attr, char *buf)
707{
708 struct usb_interface *intf;
709 char *string;
710
711 intf = to_usb_interface(dev);
712 string = intf->cur_altsetting->string;
713 barrier();
714
715 if (!string)
716 return 0;
717 return sprintf(buf, "%s\n", string);
718}
719static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
720
721static ssize_t show_modalias(struct device *dev,
722 struct device_attribute *attr, char *buf)
723{
724 struct usb_interface *intf;
725 struct usb_device *udev;
726 struct usb_host_interface *alt;
727
728 intf = to_usb_interface(dev);
729 udev = interface_to_usbdev(intf);
730 alt = intf->cur_altsetting;
731
732 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
733 "ic%02Xisc%02Xip%02X\n",
734 le16_to_cpu(udev->descriptor.idVendor),
735 le16_to_cpu(udev->descriptor.idProduct),
736 le16_to_cpu(udev->descriptor.bcdDevice),
737 udev->descriptor.bDeviceClass,
738 udev->descriptor.bDeviceSubClass,
739 udev->descriptor.bDeviceProtocol,
740 alt->desc.bInterfaceClass,
741 alt->desc.bInterfaceSubClass,
742 alt->desc.bInterfaceProtocol);
743}
744static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
745
746static struct attribute *intf_attrs[] = {
747 &dev_attr_bInterfaceNumber.attr,
748 &dev_attr_bAlternateSetting.attr,
749 &dev_attr_bNumEndpoints.attr,
750 &dev_attr_bInterfaceClass.attr,
751 &dev_attr_bInterfaceSubClass.attr,
752 &dev_attr_bInterfaceProtocol.attr,
753 &dev_attr_modalias.attr,
754 NULL,
755};
756static struct attribute_group intf_attr_grp = {
757 .attrs = intf_attrs,
758};
759
760static struct attribute *intf_assoc_attrs[] = {
761 &dev_attr_iad_bFirstInterface.attr,
762 &dev_attr_iad_bInterfaceCount.attr,
763 &dev_attr_iad_bFunctionClass.attr,
764 &dev_attr_iad_bFunctionSubClass.attr,
765 &dev_attr_iad_bFunctionProtocol.attr,
766 NULL,
767};
768
769static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
770 struct attribute *a, int n)
771{
772 struct usb_interface *intf = to_usb_interface(
773 container_of(kobj, struct device, kobj));
774
775 if (intf->intf_assoc == NULL)
776 return 0;
777 return a->mode;
778}
779
780static struct attribute_group intf_assoc_attr_grp = {
781 .attrs = intf_assoc_attrs,
782 .is_visible = intf_assoc_attrs_are_visible,
783};
784
785struct attribute_group *usb_interface_groups[] = {
786 &intf_attr_grp,
787 &intf_assoc_attr_grp,
788 NULL
789};
790
791static inline void usb_create_intf_ep_files(struct usb_interface *intf,
792 struct usb_device *udev)
793{
794 struct usb_host_interface *iface_desc;
795 int i;
796
797 iface_desc = intf->cur_altsetting;
798 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
799 usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i],
800 udev);
801}
802
803static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
804{
805 struct usb_host_interface *iface_desc;
806 int i;
807
808 iface_desc = intf->cur_altsetting;
809 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
810 usb_remove_ep_files(&iface_desc->endpoint[i]);
811}
812
813int usb_create_sysfs_intf_files(struct usb_interface *intf)
814{
815 struct usb_device *udev = interface_to_usbdev(intf);
816 struct usb_host_interface *alt = intf->cur_altsetting;
817 int retval;
818
819 if (intf->sysfs_files_created)
820 return 0;
821
822
823
824
825
826 if (alt->string == NULL)
827 alt->string = usb_cache_string(udev, alt->desc.iInterface);
828 if (alt->string)
829 retval = device_create_file(&intf->dev, &dev_attr_interface);
830 usb_create_intf_ep_files(intf, udev);
831 intf->sysfs_files_created = 1;
832 return 0;
833}
834
835void usb_remove_sysfs_intf_files(struct usb_interface *intf)
836{
837 struct device *dev = &intf->dev;
838
839 if (!intf->sysfs_files_created)
840 return;
841 usb_remove_intf_ep_files(intf);
842 device_remove_file(dev, &dev_attr_interface);
843 intf->sysfs_files_created = 0;
844}
845
