4 * Configfs support for the uvc function.
6 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
7 * http://www.samsung.com
9 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 #include "uvc_configfs.h"
18 #define UVCG_STREAMING_CONTROL_SIZE 1
20 #define UVC_ATTR(prefix, cname, aname) \
21 static struct configfs_attribute prefix##attr_##cname = { \
22 .ca_name = __stringify(aname), \
23 .ca_mode = S_IRUGO | S_IWUGO, \
24 .ca_owner = THIS_MODULE, \
25 .show = prefix##cname##_show, \
26 .store = prefix##cname##_store, \
29 #define UVC_ATTR_RO(prefix, cname, aname) \
30 static struct configfs_attribute prefix##attr_##cname = { \
31 .ca_name = __stringify(aname), \
33 .ca_owner = THIS_MODULE, \
34 .show = prefix##cname##_show, \
37 static inline struct f_uvc_opts *to_f_uvc_opts(struct config_item *item);
39 /* control/header/<NAME> */
40 DECLARE_UVC_HEADER_DESCRIPTOR(1);
42 struct uvcg_control_header {
43 struct config_item item;
44 struct UVC_HEADER_DESCRIPTOR(1) desc;
48 static struct uvcg_control_header *to_uvcg_control_header(struct config_item *item)
50 return container_of(item, struct uvcg_control_header, item);
53 #define UVCG_CTRL_HDR_ATTR(cname, aname, conv, str2u, uxx, vnoc, limit) \
54 static ssize_t uvcg_control_header_##cname##_show( \
55 struct config_item *item, char *page) \
57 struct uvcg_control_header *ch = to_uvcg_control_header(item); \
58 struct f_uvc_opts *opts; \
59 struct config_item *opts_item; \
60 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
63 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
65 opts_item = ch->item.ci_parent->ci_parent->ci_parent; \
66 opts = to_f_uvc_opts(opts_item); \
68 mutex_lock(&opts->lock); \
69 result = sprintf(page, "%d\n", conv(ch->desc.aname)); \
70 mutex_unlock(&opts->lock); \
72 mutex_unlock(su_mutex); \
77 uvcg_control_header_##cname##_store(struct config_item *item, \
78 const char *page, size_t len) \
80 struct uvcg_control_header *ch = to_uvcg_control_header(item); \
81 struct f_uvc_opts *opts; \
82 struct config_item *opts_item; \
83 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
87 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
89 opts_item = ch->item.ci_parent->ci_parent->ci_parent; \
90 opts = to_f_uvc_opts(opts_item); \
92 mutex_lock(&opts->lock); \
93 if (ch->linked || opts->refcnt) { \
98 ret = str2u(page, 0, &num); \
106 ch->desc.aname = vnoc(num); \
109 mutex_unlock(&opts->lock); \
110 mutex_unlock(su_mutex); \
114 UVC_ATTR(uvcg_control_header_, cname, aname)
116 UVCG_CTRL_HDR_ATTR(bcd_uvc, bcdUVC, le16_to_cpu, kstrtou16, u16, cpu_to_le16,
119 UVCG_CTRL_HDR_ATTR(dw_clock_frequency, dwClockFrequency, le32_to_cpu, kstrtou32,
120 u32, cpu_to_le32, 0x7fffffff);
122 #undef UVCG_CTRL_HDR_ATTR
124 static struct configfs_attribute *uvcg_control_header_attrs[] = {
125 &uvcg_control_header_attr_bcd_uvc,
126 &uvcg_control_header_attr_dw_clock_frequency,
130 static struct config_item_type uvcg_control_header_type = {
131 .ct_attrs = uvcg_control_header_attrs,
132 .ct_owner = THIS_MODULE,
135 static struct config_item *uvcg_control_header_make(struct config_group *group,
138 struct uvcg_control_header *h;
140 h = kzalloc(sizeof(*h), GFP_KERNEL);
142 return ERR_PTR(-ENOMEM);
144 h->desc.bLength = UVC_DT_HEADER_SIZE(1);
145 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
146 h->desc.bDescriptorSubType = UVC_VC_HEADER;
147 h->desc.bcdUVC = cpu_to_le16(0x0100);
148 h->desc.dwClockFrequency = cpu_to_le32(48000000);
150 config_item_init_type_name(&h->item, name, &uvcg_control_header_type);
155 static void uvcg_control_header_drop(struct config_group *group,
156 struct config_item *item)
158 struct uvcg_control_header *h = to_uvcg_control_header(item);
164 static struct uvcg_control_header_grp {
165 struct config_group group;
166 } uvcg_control_header_grp;
168 static struct configfs_group_operations uvcg_control_header_grp_ops = {
169 .make_item = uvcg_control_header_make,
170 .drop_item = uvcg_control_header_drop,
173 static struct config_item_type uvcg_control_header_grp_type = {
174 .ct_group_ops = &uvcg_control_header_grp_ops,
175 .ct_owner = THIS_MODULE,
178 /* control/processing/default */
179 static struct uvcg_default_processing {
180 struct config_group group;
181 } uvcg_default_processing;
183 static inline struct uvcg_default_processing
184 *to_uvcg_default_processing(struct config_item *item)
186 return container_of(to_config_group(item),
187 struct uvcg_default_processing, group);
190 #define UVCG_DEFAULT_PROCESSING_ATTR(cname, aname, conv) \
191 static ssize_t uvcg_default_processing_##cname##_show( \
192 struct config_item *item, char *page) \
194 struct uvcg_default_processing *dp = to_uvcg_default_processing(item); \
195 struct f_uvc_opts *opts; \
196 struct config_item *opts_item; \
197 struct mutex *su_mutex = &dp->group.cg_subsys->su_mutex; \
198 struct uvc_processing_unit_descriptor *pd; \
201 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
203 opts_item = dp->group.cg_item.ci_parent->ci_parent->ci_parent; \
204 opts = to_f_uvc_opts(opts_item); \
205 pd = &opts->uvc_processing; \
207 mutex_lock(&opts->lock); \
208 result = sprintf(page, "%d\n", conv(pd->aname)); \
209 mutex_unlock(&opts->lock); \
211 mutex_unlock(su_mutex); \
215 UVC_ATTR_RO(uvcg_default_processing_, cname, aname)
217 #define identity_conv(x) (x)
219 UVCG_DEFAULT_PROCESSING_ATTR(b_unit_id, bUnitID, identity_conv);
220 UVCG_DEFAULT_PROCESSING_ATTR(b_source_id, bSourceID, identity_conv);
221 UVCG_DEFAULT_PROCESSING_ATTR(w_max_multiplier, wMaxMultiplier, le16_to_cpu);
222 UVCG_DEFAULT_PROCESSING_ATTR(i_processing, iProcessing, identity_conv);
226 #undef UVCG_DEFAULT_PROCESSING_ATTR
228 static ssize_t uvcg_default_processing_bm_controls_show(
229 struct config_item *item, char *page)
231 struct uvcg_default_processing *dp = to_uvcg_default_processing(item);
232 struct f_uvc_opts *opts;
233 struct config_item *opts_item;
234 struct mutex *su_mutex = &dp->group.cg_subsys->su_mutex;
235 struct uvc_processing_unit_descriptor *pd;
239 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
241 opts_item = dp->group.cg_item.ci_parent->ci_parent->ci_parent;
242 opts = to_f_uvc_opts(opts_item);
243 pd = &opts->uvc_processing;
245 mutex_lock(&opts->lock);
246 for (result = 0, i = 0; i < pd->bControlSize; ++i) {
247 result += sprintf(pg, "%d\n", pd->bmControls[i]);
250 mutex_unlock(&opts->lock);
252 mutex_unlock(su_mutex);
257 UVC_ATTR_RO(uvcg_default_processing_, bm_controls, bmControls);
259 static struct configfs_attribute *uvcg_default_processing_attrs[] = {
260 &uvcg_default_processing_attr_b_unit_id,
261 &uvcg_default_processing_attr_b_source_id,
262 &uvcg_default_processing_attr_w_max_multiplier,
263 &uvcg_default_processing_attr_bm_controls,
264 &uvcg_default_processing_attr_i_processing,
268 static struct config_item_type uvcg_default_processing_type = {
269 .ct_attrs = uvcg_default_processing_attrs,
270 .ct_owner = THIS_MODULE,
273 /* struct uvcg_processing {}; */
275 /* control/processing */
276 static struct uvcg_processing_grp {
277 struct config_group group;
278 } uvcg_processing_grp;
280 static struct config_item_type uvcg_processing_grp_type = {
281 .ct_owner = THIS_MODULE,
284 /* control/terminal/camera/default */
285 static struct uvcg_default_camera {
286 struct config_group group;
287 } uvcg_default_camera;
289 static inline struct uvcg_default_camera
290 *to_uvcg_default_camera(struct config_item *item)
292 return container_of(to_config_group(item),
293 struct uvcg_default_camera, group);
296 #define UVCG_DEFAULT_CAMERA_ATTR(cname, aname, conv) \
297 static ssize_t uvcg_default_camera_##cname##_show( \
298 struct config_item *item, char *page) \
300 struct uvcg_default_camera *dc = to_uvcg_default_camera(item); \
301 struct f_uvc_opts *opts; \
302 struct config_item *opts_item; \
303 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex; \
304 struct uvc_camera_terminal_descriptor *cd; \
307 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
309 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent-> \
311 opts = to_f_uvc_opts(opts_item); \
312 cd = &opts->uvc_camera_terminal; \
314 mutex_lock(&opts->lock); \
315 result = sprintf(page, "%d\n", conv(cd->aname)); \
316 mutex_unlock(&opts->lock); \
318 mutex_unlock(su_mutex); \
323 UVC_ATTR_RO(uvcg_default_camera_, cname, aname)
325 #define identity_conv(x) (x)
327 UVCG_DEFAULT_CAMERA_ATTR(b_terminal_id, bTerminalID, identity_conv);
328 UVCG_DEFAULT_CAMERA_ATTR(w_terminal_type, wTerminalType, le16_to_cpu);
329 UVCG_DEFAULT_CAMERA_ATTR(b_assoc_terminal, bAssocTerminal, identity_conv);
330 UVCG_DEFAULT_CAMERA_ATTR(i_terminal, iTerminal, identity_conv);
331 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_min, wObjectiveFocalLengthMin,
333 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_max, wObjectiveFocalLengthMax,
335 UVCG_DEFAULT_CAMERA_ATTR(w_ocular_focal_length, wOcularFocalLength,
340 #undef UVCG_DEFAULT_CAMERA_ATTR
342 static ssize_t uvcg_default_camera_bm_controls_show(
343 struct config_item *item, char *page)
345 struct uvcg_default_camera *dc = to_uvcg_default_camera(item);
346 struct f_uvc_opts *opts;
347 struct config_item *opts_item;
348 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex;
349 struct uvc_camera_terminal_descriptor *cd;
353 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
355 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent->
357 opts = to_f_uvc_opts(opts_item);
358 cd = &opts->uvc_camera_terminal;
360 mutex_lock(&opts->lock);
361 for (result = 0, i = 0; i < cd->bControlSize; ++i) {
362 result += sprintf(pg, "%d\n", cd->bmControls[i]);
365 mutex_unlock(&opts->lock);
367 mutex_unlock(su_mutex);
371 UVC_ATTR_RO(uvcg_default_camera_, bm_controls, bmControls);
373 static struct configfs_attribute *uvcg_default_camera_attrs[] = {
374 &uvcg_default_camera_attr_b_terminal_id,
375 &uvcg_default_camera_attr_w_terminal_type,
376 &uvcg_default_camera_attr_b_assoc_terminal,
377 &uvcg_default_camera_attr_i_terminal,
378 &uvcg_default_camera_attr_w_objective_focal_length_min,
379 &uvcg_default_camera_attr_w_objective_focal_length_max,
380 &uvcg_default_camera_attr_w_ocular_focal_length,
381 &uvcg_default_camera_attr_bm_controls,
385 static struct config_item_type uvcg_default_camera_type = {
386 .ct_attrs = uvcg_default_camera_attrs,
387 .ct_owner = THIS_MODULE,
390 /* struct uvcg_camera {}; */
392 /* control/terminal/camera */
393 static struct uvcg_camera_grp {
394 struct config_group group;
397 static struct config_item_type uvcg_camera_grp_type = {
398 .ct_owner = THIS_MODULE,
401 /* control/terminal/output/default */
402 static struct uvcg_default_output {
403 struct config_group group;
404 } uvcg_default_output;
406 static inline struct uvcg_default_output
407 *to_uvcg_default_output(struct config_item *item)
409 return container_of(to_config_group(item),
410 struct uvcg_default_output, group);
413 #define UVCG_DEFAULT_OUTPUT_ATTR(cname, aname, conv) \
414 static ssize_t uvcg_default_output_##cname##_show( \
415 struct config_item *item, char *page) \
417 struct uvcg_default_output *dout = to_uvcg_default_output(item); \
418 struct f_uvc_opts *opts; \
419 struct config_item *opts_item; \
420 struct mutex *su_mutex = &dout->group.cg_subsys->su_mutex; \
421 struct uvc_output_terminal_descriptor *cd; \
424 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
426 opts_item = dout->group.cg_item.ci_parent->ci_parent-> \
427 ci_parent->ci_parent; \
428 opts = to_f_uvc_opts(opts_item); \
429 cd = &opts->uvc_output_terminal; \
431 mutex_lock(&opts->lock); \
432 result = sprintf(page, "%d\n", conv(cd->aname)); \
433 mutex_unlock(&opts->lock); \
435 mutex_unlock(su_mutex); \
440 UVC_ATTR_RO(uvcg_default_output_, cname, aname)
442 #define identity_conv(x) (x)
444 UVCG_DEFAULT_OUTPUT_ATTR(b_terminal_id, bTerminalID, identity_conv);
445 UVCG_DEFAULT_OUTPUT_ATTR(w_terminal_type, wTerminalType, le16_to_cpu);
446 UVCG_DEFAULT_OUTPUT_ATTR(b_assoc_terminal, bAssocTerminal, identity_conv);
447 UVCG_DEFAULT_OUTPUT_ATTR(b_source_id, bSourceID, identity_conv);
448 UVCG_DEFAULT_OUTPUT_ATTR(i_terminal, iTerminal, identity_conv);
452 #undef UVCG_DEFAULT_OUTPUT_ATTR
454 static struct configfs_attribute *uvcg_default_output_attrs[] = {
455 &uvcg_default_output_attr_b_terminal_id,
456 &uvcg_default_output_attr_w_terminal_type,
457 &uvcg_default_output_attr_b_assoc_terminal,
458 &uvcg_default_output_attr_b_source_id,
459 &uvcg_default_output_attr_i_terminal,
463 static struct config_item_type uvcg_default_output_type = {
464 .ct_attrs = uvcg_default_output_attrs,
465 .ct_owner = THIS_MODULE,
468 /* struct uvcg_output {}; */
470 /* control/terminal/output */
471 static struct uvcg_output_grp {
472 struct config_group group;
475 static struct config_item_type uvcg_output_grp_type = {
476 .ct_owner = THIS_MODULE,
479 /* control/terminal */
480 static struct uvcg_terminal_grp {
481 struct config_group group;
484 static struct config_item_type uvcg_terminal_grp_type = {
485 .ct_owner = THIS_MODULE,
488 /* control/class/{fs} */
489 static struct uvcg_control_class {
490 struct config_group group;
491 } uvcg_control_class_fs, uvcg_control_class_ss;
494 static inline struct uvc_descriptor_header
495 **uvcg_get_ctl_class_arr(struct config_item *i, struct f_uvc_opts *o)
497 struct uvcg_control_class *cl = container_of(to_config_group(i),
498 struct uvcg_control_class, group);
500 if (cl == &uvcg_control_class_fs)
501 return o->uvc_fs_control_cls;
503 if (cl == &uvcg_control_class_ss)
504 return o->uvc_ss_control_cls;
509 static int uvcg_control_class_allow_link(struct config_item *src,
510 struct config_item *target)
512 struct config_item *control, *header;
513 struct f_uvc_opts *opts;
514 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
515 struct uvc_descriptor_header **class_array;
516 struct uvcg_control_header *target_hdr;
519 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
521 control = src->ci_parent->ci_parent;
522 header = config_group_find_item(to_config_group(control), "header");
523 if (!header || target->ci_parent != header)
526 opts = to_f_uvc_opts(control->ci_parent);
528 mutex_lock(&opts->lock);
530 class_array = uvcg_get_ctl_class_arr(src, opts);
533 if (opts->refcnt || class_array[0]) {
538 target_hdr = to_uvcg_control_header(target);
539 ++target_hdr->linked;
540 class_array[0] = (struct uvc_descriptor_header *)&target_hdr->desc;
544 mutex_unlock(&opts->lock);
546 config_item_put(header);
547 mutex_unlock(su_mutex);
551 static void uvcg_control_class_drop_link(struct config_item *src,
552 struct config_item *target)
554 struct config_item *control, *header;
555 struct f_uvc_opts *opts;
556 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
557 struct uvc_descriptor_header **class_array;
558 struct uvcg_control_header *target_hdr;
560 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
562 control = src->ci_parent->ci_parent;
563 header = config_group_find_item(to_config_group(control), "header");
564 if (!header || target->ci_parent != header)
567 opts = to_f_uvc_opts(control->ci_parent);
569 mutex_lock(&opts->lock);
571 class_array = uvcg_get_ctl_class_arr(src, opts);
572 if (!class_array || opts->refcnt)
575 target_hdr = to_uvcg_control_header(target);
576 --target_hdr->linked;
577 class_array[0] = NULL;
580 mutex_unlock(&opts->lock);
582 config_item_put(header);
583 mutex_unlock(su_mutex);
586 static struct configfs_item_operations uvcg_control_class_item_ops = {
587 .allow_link = uvcg_control_class_allow_link,
588 .drop_link = uvcg_control_class_drop_link,
591 static struct config_item_type uvcg_control_class_type = {
592 .ct_item_ops = &uvcg_control_class_item_ops,
593 .ct_owner = THIS_MODULE,
597 static struct uvcg_control_class_grp {
598 struct config_group group;
599 } uvcg_control_class_grp;
601 static struct config_item_type uvcg_control_class_grp_type = {
602 .ct_owner = THIS_MODULE,
606 static struct uvcg_control_grp {
607 struct config_group group;
610 static struct config_item_type uvcg_control_grp_type = {
611 .ct_owner = THIS_MODULE,
614 /* streaming/uncompressed */
615 static struct uvcg_uncompressed_grp {
616 struct config_group group;
617 } uvcg_uncompressed_grp;
619 /* streaming/mjpeg */
620 static struct uvcg_mjpeg_grp {
621 struct config_group group;
624 static struct config_item *fmt_parent[] = {
625 &uvcg_uncompressed_grp.group.cg_item,
626 &uvcg_mjpeg_grp.group.cg_item,
629 enum uvcg_format_type {
630 UVCG_UNCOMPRESSED = 0,
635 struct config_group group;
636 enum uvcg_format_type type;
639 __u8 bmaControls[UVCG_STREAMING_CONTROL_SIZE];
642 static struct uvcg_format *to_uvcg_format(struct config_item *item)
644 return container_of(to_config_group(item), struct uvcg_format, group);
647 static ssize_t uvcg_format_bma_controls_show(struct uvcg_format *f, char *page)
649 struct f_uvc_opts *opts;
650 struct config_item *opts_item;
651 struct mutex *su_mutex = &f->group.cg_subsys->su_mutex;
655 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
657 opts_item = f->group.cg_item.ci_parent->ci_parent->ci_parent;
658 opts = to_f_uvc_opts(opts_item);
660 mutex_lock(&opts->lock);
661 result = sprintf(pg, "0x");
663 for (i = 0; i < UVCG_STREAMING_CONTROL_SIZE; ++i) {
664 result += sprintf(pg, "%x\n", f->bmaControls[i]);
667 mutex_unlock(&opts->lock);
669 mutex_unlock(su_mutex);
673 static ssize_t uvcg_format_bma_controls_store(struct uvcg_format *ch,
674 const char *page, size_t len)
676 struct f_uvc_opts *opts;
677 struct config_item *opts_item;
678 struct mutex *su_mutex = &ch->group.cg_subsys->su_mutex;
681 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
683 opts_item = ch->group.cg_item.ci_parent->ci_parent->ci_parent;
684 opts = to_f_uvc_opts(opts_item);
686 mutex_lock(&opts->lock);
687 if (ch->linked || opts->refcnt) {
692 if (len < 4 || *page != '0' ||
693 (*(page + 1) != 'x' && *(page + 1) != 'X'))
695 ret = hex2bin(ch->bmaControls, page + 2, 1);
700 mutex_unlock(&opts->lock);
701 mutex_unlock(su_mutex);
705 struct uvcg_format_ptr {
706 struct uvcg_format *fmt;
707 struct list_head entry;
710 /* streaming/header/<NAME> */
711 struct uvcg_streaming_header {
712 struct config_item item;
713 struct uvc_input_header_descriptor desc;
715 struct list_head formats;
719 static struct uvcg_streaming_header *to_uvcg_streaming_header(struct config_item *item)
721 return container_of(item, struct uvcg_streaming_header, item);
724 static int uvcg_streaming_header_allow_link(struct config_item *src,
725 struct config_item *target)
727 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
728 struct config_item *opts_item;
729 struct f_uvc_opts *opts;
730 struct uvcg_streaming_header *src_hdr;
731 struct uvcg_format *target_fmt = NULL;
732 struct uvcg_format_ptr *format_ptr;
733 int i, ret = -EINVAL;
735 src_hdr = to_uvcg_streaming_header(src);
736 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
738 opts_item = src->ci_parent->ci_parent->ci_parent;
739 opts = to_f_uvc_opts(opts_item);
741 mutex_lock(&opts->lock);
743 if (src_hdr->linked) {
748 for (i = 0; i < ARRAY_SIZE(fmt_parent); ++i)
749 if (target->ci_parent == fmt_parent[i])
751 if (i == ARRAY_SIZE(fmt_parent))
754 target_fmt = container_of(to_config_group(target), struct uvcg_format,
759 format_ptr = kzalloc(sizeof(*format_ptr), GFP_KERNEL);
765 format_ptr->fmt = target_fmt;
766 list_add_tail(&format_ptr->entry, &src_hdr->formats);
768 ++target_fmt->linked;
771 mutex_unlock(&opts->lock);
772 mutex_unlock(su_mutex);
776 static void uvcg_streaming_header_drop_link(struct config_item *src,
777 struct config_item *target)
779 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
780 struct config_item *opts_item;
781 struct f_uvc_opts *opts;
782 struct uvcg_streaming_header *src_hdr;
783 struct uvcg_format *target_fmt = NULL;
784 struct uvcg_format_ptr *format_ptr, *tmp;
786 src_hdr = to_uvcg_streaming_header(src);
787 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
789 opts_item = src->ci_parent->ci_parent->ci_parent;
790 opts = to_f_uvc_opts(opts_item);
792 mutex_lock(&opts->lock);
793 target_fmt = container_of(to_config_group(target), struct uvcg_format,
798 list_for_each_entry_safe(format_ptr, tmp, &src_hdr->formats, entry)
799 if (format_ptr->fmt == target_fmt) {
800 list_del(&format_ptr->entry);
806 --target_fmt->linked;
809 mutex_unlock(&opts->lock);
810 mutex_unlock(su_mutex);
813 static struct configfs_item_operations uvcg_streaming_header_item_ops = {
814 .allow_link = uvcg_streaming_header_allow_link,
815 .drop_link = uvcg_streaming_header_drop_link,
818 #define UVCG_STREAMING_HEADER_ATTR(cname, aname, conv) \
819 static ssize_t uvcg_streaming_header_##cname##_show( \
820 struct config_item *item, char *page) \
822 struct uvcg_streaming_header *sh = to_uvcg_streaming_header(item); \
823 struct f_uvc_opts *opts; \
824 struct config_item *opts_item; \
825 struct mutex *su_mutex = &sh->item.ci_group->cg_subsys->su_mutex;\
828 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
830 opts_item = sh->item.ci_parent->ci_parent->ci_parent; \
831 opts = to_f_uvc_opts(opts_item); \
833 mutex_lock(&opts->lock); \
834 result = sprintf(page, "%d\n", conv(sh->desc.aname)); \
835 mutex_unlock(&opts->lock); \
837 mutex_unlock(su_mutex); \
841 UVC_ATTR_RO(uvcg_streaming_header_, cname, aname)
843 #define identity_conv(x) (x)
845 UVCG_STREAMING_HEADER_ATTR(bm_info, bmInfo, identity_conv);
846 UVCG_STREAMING_HEADER_ATTR(b_terminal_link, bTerminalLink, identity_conv);
847 UVCG_STREAMING_HEADER_ATTR(b_still_capture_method, bStillCaptureMethod,
849 UVCG_STREAMING_HEADER_ATTR(b_trigger_support, bTriggerSupport, identity_conv);
850 UVCG_STREAMING_HEADER_ATTR(b_trigger_usage, bTriggerUsage, identity_conv);
854 #undef UVCG_STREAMING_HEADER_ATTR
856 static struct configfs_attribute *uvcg_streaming_header_attrs[] = {
857 &uvcg_streaming_header_attr_bm_info,
858 &uvcg_streaming_header_attr_b_terminal_link,
859 &uvcg_streaming_header_attr_b_still_capture_method,
860 &uvcg_streaming_header_attr_b_trigger_support,
861 &uvcg_streaming_header_attr_b_trigger_usage,
865 static struct config_item_type uvcg_streaming_header_type = {
866 .ct_item_ops = &uvcg_streaming_header_item_ops,
867 .ct_attrs = uvcg_streaming_header_attrs,
868 .ct_owner = THIS_MODULE,
871 static struct config_item
872 *uvcg_streaming_header_make(struct config_group *group, const char *name)
874 struct uvcg_streaming_header *h;
876 h = kzalloc(sizeof(*h), GFP_KERNEL);
878 return ERR_PTR(-ENOMEM);
880 INIT_LIST_HEAD(&h->formats);
881 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
882 h->desc.bDescriptorSubType = UVC_VS_INPUT_HEADER;
883 h->desc.bTerminalLink = 3;
884 h->desc.bControlSize = UVCG_STREAMING_CONTROL_SIZE;
886 config_item_init_type_name(&h->item, name, &uvcg_streaming_header_type);
891 static void uvcg_streaming_header_drop(struct config_group *group,
892 struct config_item *item)
894 struct uvcg_streaming_header *h = to_uvcg_streaming_header(item);
899 /* streaming/header */
900 static struct uvcg_streaming_header_grp {
901 struct config_group group;
902 } uvcg_streaming_header_grp;
904 static struct configfs_group_operations uvcg_streaming_header_grp_ops = {
905 .make_item = uvcg_streaming_header_make,
906 .drop_item = uvcg_streaming_header_drop,
909 static struct config_item_type uvcg_streaming_header_grp_type = {
910 .ct_group_ops = &uvcg_streaming_header_grp_ops,
911 .ct_owner = THIS_MODULE,
914 /* streaming/<mode>/<format>/<NAME> */
918 u8 b_descriptor_type;
919 u8 b_descriptor_subtype;
926 u32 dw_max_video_frame_buffer_size;
927 u32 dw_default_frame_interval;
928 u8 b_frame_interval_type;
929 } __attribute__((packed)) frame;
930 u32 *dw_frame_interval;
931 enum uvcg_format_type fmt_type;
932 struct config_item item;
935 static struct uvcg_frame *to_uvcg_frame(struct config_item *item)
937 return container_of(item, struct uvcg_frame, item);
940 #define UVCG_FRAME_ATTR(cname, aname, to_cpu_endian, to_little_endian, bits) \
941 static ssize_t uvcg_frame_##cname##_show(struct config_item *item, char *page)\
943 struct uvcg_frame *f = to_uvcg_frame(item); \
944 struct f_uvc_opts *opts; \
945 struct config_item *opts_item; \
946 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
949 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
951 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
952 opts = to_f_uvc_opts(opts_item); \
954 mutex_lock(&opts->lock); \
955 result = sprintf(page, "%d\n", to_cpu_endian(f->frame.cname)); \
956 mutex_unlock(&opts->lock); \
958 mutex_unlock(su_mutex); \
962 static ssize_t uvcg_frame_##cname##_store(struct config_item *item, \
963 const char *page, size_t len)\
965 struct uvcg_frame *f = to_uvcg_frame(item); \
966 struct f_uvc_opts *opts; \
967 struct config_item *opts_item; \
968 struct uvcg_format *fmt; \
969 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
973 ret = kstrtou##bits(page, 0, &num); \
977 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
979 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
980 opts = to_f_uvc_opts(opts_item); \
981 fmt = to_uvcg_format(f->item.ci_parent); \
983 mutex_lock(&opts->lock); \
984 if (fmt->linked || opts->refcnt) { \
989 f->frame.cname = to_little_endian(num); \
992 mutex_unlock(&opts->lock); \
993 mutex_unlock(su_mutex); \
997 UVC_ATTR(uvcg_frame_, cname, aname);
999 #define noop_conversion(x) (x)
1001 UVCG_FRAME_ATTR(bm_capabilities, bmCapabilities, noop_conversion,
1002 noop_conversion, 8);
1003 UVCG_FRAME_ATTR(w_width, wWidth, le16_to_cpu, cpu_to_le16, 16);
1004 UVCG_FRAME_ATTR(w_height, wHeight, le16_to_cpu, cpu_to_le16, 16);
1005 UVCG_FRAME_ATTR(dw_min_bit_rate, dwMinBitRate, le32_to_cpu, cpu_to_le32, 32);
1006 UVCG_FRAME_ATTR(dw_max_bit_rate, dwMaxBitRate, le32_to_cpu, cpu_to_le32, 32);
1007 UVCG_FRAME_ATTR(dw_max_video_frame_buffer_size, dwMaxVideoFrameBufferSize,
1008 le32_to_cpu, cpu_to_le32, 32);
1009 UVCG_FRAME_ATTR(dw_default_frame_interval, dwDefaultFrameInterval,
1010 le32_to_cpu, cpu_to_le32, 32);
1012 #undef noop_conversion
1014 #undef UVCG_FRAME_ATTR
1016 static ssize_t uvcg_frame_dw_frame_interval_show(struct config_item *item,
1019 struct uvcg_frame *frm = to_uvcg_frame(item);
1020 struct f_uvc_opts *opts;
1021 struct config_item *opts_item;
1022 struct mutex *su_mutex = &frm->item.ci_group->cg_subsys->su_mutex;
1026 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1028 opts_item = frm->item.ci_parent->ci_parent->ci_parent->ci_parent;
1029 opts = to_f_uvc_opts(opts_item);
1031 mutex_lock(&opts->lock);
1032 for (result = 0, i = 0; i < frm->frame.b_frame_interval_type; ++i) {
1033 result += sprintf(pg, "%d\n",
1034 le32_to_cpu(frm->dw_frame_interval[i]));
1037 mutex_unlock(&opts->lock);
1039 mutex_unlock(su_mutex);
1043 static inline int __uvcg_count_frm_intrv(char *buf, void *priv)
1049 static inline int __uvcg_fill_frm_intrv(char *buf, void *priv)
1054 ret = kstrtou32(buf, 0, &num);
1059 **interv = cpu_to_le32(num);
1065 static int __uvcg_iter_frm_intrv(const char *page, size_t len,
1066 int (*fun)(char *, void *), void *priv)
1068 /* sign, base 2 representation, newline, terminator */
1069 char buf[1 + sizeof(u32) * 8 + 1 + 1];
1070 const char *pg = page;
1076 while (pg - page < len) {
1078 while (i < sizeof(buf) && (pg - page < len) &&
1079 *pg != '\0' && *pg != '\n')
1081 if (i == sizeof(buf))
1083 while ((pg - page < len) && (*pg == '\0' || *pg == '\n'))
1086 ret = fun(buf, priv);
1094 static ssize_t uvcg_frame_dw_frame_interval_store(struct config_item *item,
1095 const char *page, size_t len)
1097 struct uvcg_frame *ch = to_uvcg_frame(item);
1098 struct f_uvc_opts *opts;
1099 struct config_item *opts_item;
1100 struct uvcg_format *fmt;
1101 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;
1103 u32 *frm_intrv, *tmp;
1105 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1107 opts_item = ch->item.ci_parent->ci_parent->ci_parent->ci_parent;
1108 opts = to_f_uvc_opts(opts_item);
1109 fmt = to_uvcg_format(ch->item.ci_parent);
1111 mutex_lock(&opts->lock);
1112 if (fmt->linked || opts->refcnt) {
1117 ret = __uvcg_iter_frm_intrv(page, len, __uvcg_count_frm_intrv, &n);
1121 tmp = frm_intrv = kcalloc(n, sizeof(u32), GFP_KERNEL);
1127 ret = __uvcg_iter_frm_intrv(page, len, __uvcg_fill_frm_intrv, &tmp);
1133 kfree(ch->dw_frame_interval);
1134 ch->dw_frame_interval = frm_intrv;
1135 ch->frame.b_frame_interval_type = n;
1139 mutex_unlock(&opts->lock);
1140 mutex_unlock(su_mutex);
1144 UVC_ATTR(uvcg_frame_, dw_frame_interval, dwFrameInterval);
1146 static struct configfs_attribute *uvcg_frame_attrs[] = {
1147 &uvcg_frame_attr_bm_capabilities,
1148 &uvcg_frame_attr_w_width,
1149 &uvcg_frame_attr_w_height,
1150 &uvcg_frame_attr_dw_min_bit_rate,
1151 &uvcg_frame_attr_dw_max_bit_rate,
1152 &uvcg_frame_attr_dw_max_video_frame_buffer_size,
1153 &uvcg_frame_attr_dw_default_frame_interval,
1154 &uvcg_frame_attr_dw_frame_interval,
1158 static struct config_item_type uvcg_frame_type = {
1159 .ct_attrs = uvcg_frame_attrs,
1160 .ct_owner = THIS_MODULE,
1163 static struct config_item *uvcg_frame_make(struct config_group *group,
1166 struct uvcg_frame *h;
1167 struct uvcg_format *fmt;
1168 struct f_uvc_opts *opts;
1169 struct config_item *opts_item;
1171 h = kzalloc(sizeof(*h), GFP_KERNEL);
1173 return ERR_PTR(-ENOMEM);
1175 h->frame.b_descriptor_type = USB_DT_CS_INTERFACE;
1176 h->frame.b_frame_index = 1;
1177 h->frame.w_width = cpu_to_le16(640);
1178 h->frame.w_height = cpu_to_le16(360);
1179 h->frame.dw_min_bit_rate = cpu_to_le32(18432000);
1180 h->frame.dw_max_bit_rate = cpu_to_le32(55296000);
1181 h->frame.dw_max_video_frame_buffer_size = cpu_to_le32(460800);
1182 h->frame.dw_default_frame_interval = cpu_to_le32(666666);
1184 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1185 opts = to_f_uvc_opts(opts_item);
1187 mutex_lock(&opts->lock);
1188 fmt = to_uvcg_format(&group->cg_item);
1189 if (fmt->type == UVCG_UNCOMPRESSED) {
1190 h->frame.b_descriptor_subtype = UVC_VS_FRAME_UNCOMPRESSED;
1191 h->fmt_type = UVCG_UNCOMPRESSED;
1192 } else if (fmt->type == UVCG_MJPEG) {
1193 h->frame.b_descriptor_subtype = UVC_VS_FRAME_MJPEG;
1194 h->fmt_type = UVCG_MJPEG;
1196 mutex_unlock(&opts->lock);
1198 return ERR_PTR(-EINVAL);
1201 mutex_unlock(&opts->lock);
1203 config_item_init_type_name(&h->item, name, &uvcg_frame_type);
1208 static void uvcg_frame_drop(struct config_group *group, struct config_item *item)
1210 struct uvcg_frame *h = to_uvcg_frame(item);
1211 struct uvcg_format *fmt;
1212 struct f_uvc_opts *opts;
1213 struct config_item *opts_item;
1215 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1216 opts = to_f_uvc_opts(opts_item);
1218 mutex_lock(&opts->lock);
1219 fmt = to_uvcg_format(&group->cg_item);
1222 mutex_unlock(&opts->lock);
1225 /* streaming/uncompressed/<NAME> */
1226 struct uvcg_uncompressed {
1227 struct uvcg_format fmt;
1228 struct uvc_format_uncompressed desc;
1231 static struct uvcg_uncompressed *to_uvcg_uncompressed(struct config_item *item)
1233 return container_of(
1234 container_of(to_config_group(item), struct uvcg_format, group),
1235 struct uvcg_uncompressed, fmt);
1238 static struct configfs_group_operations uvcg_uncompressed_group_ops = {
1239 .make_item = uvcg_frame_make,
1240 .drop_item = uvcg_frame_drop,
1243 static ssize_t uvcg_uncompressed_guid_format_show(struct config_item *item,
1246 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1247 struct f_uvc_opts *opts;
1248 struct config_item *opts_item;
1249 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1251 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1253 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1254 opts = to_f_uvc_opts(opts_item);
1256 mutex_lock(&opts->lock);
1257 memcpy(page, ch->desc.guidFormat, sizeof(ch->desc.guidFormat));
1258 mutex_unlock(&opts->lock);
1260 mutex_unlock(su_mutex);
1262 return sizeof(ch->desc.guidFormat);
1265 static ssize_t uvcg_uncompressed_guid_format_store(struct config_item *item,
1266 const char *page, size_t len)
1268 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1269 struct f_uvc_opts *opts;
1270 struct config_item *opts_item;
1271 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1274 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1276 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1277 opts = to_f_uvc_opts(opts_item);
1279 mutex_lock(&opts->lock);
1280 if (ch->fmt.linked || opts->refcnt) {
1285 memcpy(ch->desc.guidFormat, page,
1286 min(sizeof(ch->desc.guidFormat), len));
1287 ret = sizeof(ch->desc.guidFormat);
1290 mutex_unlock(&opts->lock);
1291 mutex_unlock(su_mutex);
1295 UVC_ATTR(uvcg_uncompressed_, guid_format, guidFormat);
1297 #define UVCG_UNCOMPRESSED_ATTR_RO(cname, aname, conv) \
1298 static ssize_t uvcg_uncompressed_##cname##_show( \
1299 struct config_item *item, char *page) \
1301 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1302 struct f_uvc_opts *opts; \
1303 struct config_item *opts_item; \
1304 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1307 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1309 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1310 opts = to_f_uvc_opts(opts_item); \
1312 mutex_lock(&opts->lock); \
1313 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1314 mutex_unlock(&opts->lock); \
1316 mutex_unlock(su_mutex); \
1320 UVC_ATTR_RO(uvcg_uncompressed_, cname, aname);
1322 #define UVCG_UNCOMPRESSED_ATTR(cname, aname, conv) \
1323 static ssize_t uvcg_uncompressed_##cname##_show( \
1324 struct config_item *item, char *page) \
1326 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1327 struct f_uvc_opts *opts; \
1328 struct config_item *opts_item; \
1329 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1332 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1334 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1335 opts = to_f_uvc_opts(opts_item); \
1337 mutex_lock(&opts->lock); \
1338 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1339 mutex_unlock(&opts->lock); \
1341 mutex_unlock(su_mutex); \
1346 uvcg_uncompressed_##cname##_store(struct config_item *item, \
1347 const char *page, size_t len) \
1349 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1350 struct f_uvc_opts *opts; \
1351 struct config_item *opts_item; \
1352 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1356 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1358 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1359 opts = to_f_uvc_opts(opts_item); \
1361 mutex_lock(&opts->lock); \
1362 if (u->fmt.linked || opts->refcnt) { \
1367 ret = kstrtou8(page, 0, &num); \
1375 u->desc.aname = num; \
1378 mutex_unlock(&opts->lock); \
1379 mutex_unlock(su_mutex); \
1383 UVC_ATTR(uvcg_uncompressed_, cname, aname);
1385 #define identity_conv(x) (x)
1387 UVCG_UNCOMPRESSED_ATTR(b_bits_per_pixel, bBitsPerPixel, identity_conv);
1388 UVCG_UNCOMPRESSED_ATTR(b_default_frame_index, bDefaultFrameIndex,
1390 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, identity_conv);
1391 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, identity_conv);
1392 UVCG_UNCOMPRESSED_ATTR_RO(bm_interface_flags, bmInterfaceFlags, identity_conv);
1394 #undef identity_conv
1396 #undef UVCG_UNCOMPRESSED_ATTR
1397 #undef UVCG_UNCOMPRESSED_ATTR_RO
1399 static inline ssize_t
1400 uvcg_uncompressed_bma_controls_show(struct config_item *item, char *page)
1402 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1403 return uvcg_format_bma_controls_show(&unc->fmt, page);
1406 static inline ssize_t
1407 uvcg_uncompressed_bma_controls_store(struct config_item *item,
1408 const char *page, size_t len)
1410 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1411 return uvcg_format_bma_controls_store(&unc->fmt, page, len);
1414 UVC_ATTR(uvcg_uncompressed_, bma_controls, bmaControls);
1416 static struct configfs_attribute *uvcg_uncompressed_attrs[] = {
1417 &uvcg_uncompressed_attr_guid_format,
1418 &uvcg_uncompressed_attr_b_bits_per_pixel,
1419 &uvcg_uncompressed_attr_b_default_frame_index,
1420 &uvcg_uncompressed_attr_b_aspect_ratio_x,
1421 &uvcg_uncompressed_attr_b_aspect_ratio_y,
1422 &uvcg_uncompressed_attr_bm_interface_flags,
1423 &uvcg_uncompressed_attr_bma_controls,
1427 static struct config_item_type uvcg_uncompressed_type = {
1428 .ct_group_ops = &uvcg_uncompressed_group_ops,
1429 .ct_attrs = uvcg_uncompressed_attrs,
1430 .ct_owner = THIS_MODULE,
1433 static struct config_group *uvcg_uncompressed_make(struct config_group *group,
1436 static char guid[] = {
1437 'Y', 'U', 'Y', '2', 0x00, 0x00, 0x10, 0x00,
1438 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
1440 struct uvcg_uncompressed *h;
1442 h = kzalloc(sizeof(*h), GFP_KERNEL);
1444 return ERR_PTR(-ENOMEM);
1446 h->desc.bLength = UVC_DT_FORMAT_UNCOMPRESSED_SIZE;
1447 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1448 h->desc.bDescriptorSubType = UVC_VS_FORMAT_UNCOMPRESSED;
1449 memcpy(h->desc.guidFormat, guid, sizeof(guid));
1450 h->desc.bBitsPerPixel = 16;
1451 h->desc.bDefaultFrameIndex = 1;
1452 h->desc.bAspectRatioX = 0;
1453 h->desc.bAspectRatioY = 0;
1454 h->desc.bmInterfaceFlags = 0;
1455 h->desc.bCopyProtect = 0;
1457 h->fmt.type = UVCG_UNCOMPRESSED;
1458 config_group_init_type_name(&h->fmt.group, name,
1459 &uvcg_uncompressed_type);
1461 return &h->fmt.group;
1464 static void uvcg_uncompressed_drop(struct config_group *group,
1465 struct config_item *item)
1467 struct uvcg_uncompressed *h = to_uvcg_uncompressed(item);
1472 static struct configfs_group_operations uvcg_uncompressed_grp_ops = {
1473 .make_group = uvcg_uncompressed_make,
1474 .drop_item = uvcg_uncompressed_drop,
1477 static struct config_item_type uvcg_uncompressed_grp_type = {
1478 .ct_group_ops = &uvcg_uncompressed_grp_ops,
1479 .ct_owner = THIS_MODULE,
1482 /* streaming/mjpeg/<NAME> */
1484 struct uvcg_format fmt;
1485 struct uvc_format_mjpeg desc;
1488 static struct uvcg_mjpeg *to_uvcg_mjpeg(struct config_item *item)
1490 return container_of(
1491 container_of(to_config_group(item), struct uvcg_format, group),
1492 struct uvcg_mjpeg, fmt);
1495 static struct configfs_group_operations uvcg_mjpeg_group_ops = {
1496 .make_item = uvcg_frame_make,
1497 .drop_item = uvcg_frame_drop,
1500 #define UVCG_MJPEG_ATTR_RO(cname, aname, conv) \
1501 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1503 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1504 struct f_uvc_opts *opts; \
1505 struct config_item *opts_item; \
1506 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1509 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1511 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1512 opts = to_f_uvc_opts(opts_item); \
1514 mutex_lock(&opts->lock); \
1515 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1516 mutex_unlock(&opts->lock); \
1518 mutex_unlock(su_mutex); \
1522 UVC_ATTR_RO(uvcg_mjpeg_, cname, aname)
1524 #define UVCG_MJPEG_ATTR(cname, aname, conv) \
1525 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1527 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1528 struct f_uvc_opts *opts; \
1529 struct config_item *opts_item; \
1530 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1533 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1535 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1536 opts = to_f_uvc_opts(opts_item); \
1538 mutex_lock(&opts->lock); \
1539 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1540 mutex_unlock(&opts->lock); \
1542 mutex_unlock(su_mutex); \
1547 uvcg_mjpeg_##cname##_store(struct config_item *item, \
1548 const char *page, size_t len) \
1550 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1551 struct f_uvc_opts *opts; \
1552 struct config_item *opts_item; \
1553 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1557 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1559 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1560 opts = to_f_uvc_opts(opts_item); \
1562 mutex_lock(&opts->lock); \
1563 if (u->fmt.linked || opts->refcnt) { \
1568 ret = kstrtou8(page, 0, &num); \
1576 u->desc.aname = num; \
1579 mutex_unlock(&opts->lock); \
1580 mutex_unlock(su_mutex); \
1584 UVC_ATTR(uvcg_mjpeg_, cname, aname)
1586 #define identity_conv(x) (x)
1588 UVCG_MJPEG_ATTR(b_default_frame_index, bDefaultFrameIndex,
1590 UVCG_MJPEG_ATTR_RO(bm_flags, bmFlags, identity_conv);
1591 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, identity_conv);
1592 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, identity_conv);
1593 UVCG_MJPEG_ATTR_RO(bm_interface_flags, bmInterfaceFlags, identity_conv);
1595 #undef identity_conv
1597 #undef UVCG_MJPEG_ATTR
1598 #undef UVCG_MJPEG_ATTR_RO
1600 static inline ssize_t
1601 uvcg_mjpeg_bma_controls_show(struct config_item *item, char *page)
1603 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1604 return uvcg_format_bma_controls_show(&u->fmt, page);
1607 static inline ssize_t
1608 uvcg_mjpeg_bma_controls_store(struct config_item *item,
1609 const char *page, size_t len)
1611 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1612 return uvcg_format_bma_controls_store(&u->fmt, page, len);
1615 UVC_ATTR(uvcg_mjpeg_, bma_controls, bmaControls);
1617 static struct configfs_attribute *uvcg_mjpeg_attrs[] = {
1618 &uvcg_mjpeg_attr_b_default_frame_index,
1619 &uvcg_mjpeg_attr_bm_flags,
1620 &uvcg_mjpeg_attr_b_aspect_ratio_x,
1621 &uvcg_mjpeg_attr_b_aspect_ratio_y,
1622 &uvcg_mjpeg_attr_bm_interface_flags,
1623 &uvcg_mjpeg_attr_bma_controls,
1627 static struct config_item_type uvcg_mjpeg_type = {
1628 .ct_group_ops = &uvcg_mjpeg_group_ops,
1629 .ct_attrs = uvcg_mjpeg_attrs,
1630 .ct_owner = THIS_MODULE,
1633 static struct config_group *uvcg_mjpeg_make(struct config_group *group,
1636 struct uvcg_mjpeg *h;
1638 h = kzalloc(sizeof(*h), GFP_KERNEL);
1640 return ERR_PTR(-ENOMEM);
1642 h->desc.bLength = UVC_DT_FORMAT_MJPEG_SIZE;
1643 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1644 h->desc.bDescriptorSubType = UVC_VS_FORMAT_MJPEG;
1645 h->desc.bDefaultFrameIndex = 1;
1646 h->desc.bAspectRatioX = 0;
1647 h->desc.bAspectRatioY = 0;
1648 h->desc.bmInterfaceFlags = 0;
1649 h->desc.bCopyProtect = 0;
1651 h->fmt.type = UVCG_MJPEG;
1652 config_group_init_type_name(&h->fmt.group, name,
1655 return &h->fmt.group;
1658 static void uvcg_mjpeg_drop(struct config_group *group,
1659 struct config_item *item)
1661 struct uvcg_mjpeg *h = to_uvcg_mjpeg(item);
1666 static struct configfs_group_operations uvcg_mjpeg_grp_ops = {
1667 .make_group = uvcg_mjpeg_make,
1668 .drop_item = uvcg_mjpeg_drop,
1671 static struct config_item_type uvcg_mjpeg_grp_type = {
1672 .ct_group_ops = &uvcg_mjpeg_grp_ops,
1673 .ct_owner = THIS_MODULE,
1676 /* streaming/color_matching/default */
1677 static struct uvcg_default_color_matching {
1678 struct config_group group;
1679 } uvcg_default_color_matching;
1681 static inline struct uvcg_default_color_matching
1682 *to_uvcg_default_color_matching(struct config_item *item)
1684 return container_of(to_config_group(item),
1685 struct uvcg_default_color_matching, group);
1688 #define UVCG_DEFAULT_COLOR_MATCHING_ATTR(cname, aname, conv) \
1689 static ssize_t uvcg_default_color_matching_##cname##_show( \
1690 struct config_item *item, char *page) \
1692 struct uvcg_default_color_matching *dc = \
1693 to_uvcg_default_color_matching(item); \
1694 struct f_uvc_opts *opts; \
1695 struct config_item *opts_item; \
1696 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex; \
1697 struct uvc_color_matching_descriptor *cd; \
1700 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1702 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent; \
1703 opts = to_f_uvc_opts(opts_item); \
1704 cd = &opts->uvc_color_matching; \
1706 mutex_lock(&opts->lock); \
1707 result = sprintf(page, "%d\n", conv(cd->aname)); \
1708 mutex_unlock(&opts->lock); \
1710 mutex_unlock(su_mutex); \
1714 UVC_ATTR_RO(uvcg_default_color_matching_, cname, aname)
1716 #define identity_conv(x) (x)
1718 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_color_primaries, bColorPrimaries,
1720 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_transfer_characteristics,
1721 bTransferCharacteristics, identity_conv);
1722 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_matrix_coefficients, bMatrixCoefficients,
1725 #undef identity_conv
1727 #undef UVCG_DEFAULT_COLOR_MATCHING_ATTR
1729 static struct configfs_attribute *uvcg_default_color_matching_attrs[] = {
1730 &uvcg_default_color_matching_attr_b_color_primaries,
1731 &uvcg_default_color_matching_attr_b_transfer_characteristics,
1732 &uvcg_default_color_matching_attr_b_matrix_coefficients,
1736 static struct config_item_type uvcg_default_color_matching_type = {
1737 .ct_attrs = uvcg_default_color_matching_attrs,
1738 .ct_owner = THIS_MODULE,
1741 /* struct uvcg_color_matching {}; */
1743 /* streaming/color_matching */
1744 static struct uvcg_color_matching_grp {
1745 struct config_group group;
1746 } uvcg_color_matching_grp;
1748 static struct config_item_type uvcg_color_matching_grp_type = {
1749 .ct_owner = THIS_MODULE,
1752 /* streaming/class/{fs|hs|ss} */
1753 static struct uvcg_streaming_class {
1754 struct config_group group;
1755 } uvcg_streaming_class_fs, uvcg_streaming_class_hs, uvcg_streaming_class_ss;
1758 static inline struct uvc_descriptor_header
1759 ***__uvcg_get_stream_class_arr(struct config_item *i, struct f_uvc_opts *o)
1761 struct uvcg_streaming_class *cl = container_of(to_config_group(i),
1762 struct uvcg_streaming_class, group);
1764 if (cl == &uvcg_streaming_class_fs)
1765 return &o->uvc_fs_streaming_cls;
1767 if (cl == &uvcg_streaming_class_hs)
1768 return &o->uvc_hs_streaming_cls;
1770 if (cl == &uvcg_streaming_class_ss)
1771 return &o->uvc_ss_streaming_cls;
1776 enum uvcg_strm_type {
1783 * Iterate over a hierarchy of streaming descriptors' config items.
1784 * The items are created by the user with configfs.
1786 * It "processes" the header pointed to by @priv1, then for each format
1787 * that follows the header "processes" the format itself and then for
1788 * each frame inside a format "processes" the frame.
1790 * As a "processing" function the @fun is used.
1792 * __uvcg_iter_strm_cls() is used in two context: first, to calculate
1793 * the amount of memory needed for an array of streaming descriptors
1794 * and second, to actually fill the array.
1796 * @h: streaming header pointer
1797 * @priv2: an "inout" parameter (the caller might want to see the changes to it)
1798 * @priv3: an "inout" parameter (the caller might want to see the changes to it)
1799 * @fun: callback function for processing each level of the hierarchy
1801 static int __uvcg_iter_strm_cls(struct uvcg_streaming_header *h,
1802 void *priv2, void *priv3,
1803 int (*fun)(void *, void *, void *, int, enum uvcg_strm_type type))
1805 struct uvcg_format_ptr *f;
1806 struct config_group *grp;
1807 struct config_item *item;
1808 struct uvcg_frame *frm;
1815 ret = fun(h, priv2, priv3, 0, UVCG_HEADER);
1818 list_for_each_entry(f, &h->formats, entry) {
1819 ret = fun(f->fmt, priv2, priv3, i++, UVCG_FORMAT);
1822 grp = &f->fmt->group;
1823 list_for_each_entry(item, &grp->cg_children, ci_entry) {
1824 frm = to_uvcg_frame(item);
1825 ret = fun(frm, priv2, priv3, j++, UVCG_FRAME);
1835 * Count how many bytes are needed for an array of streaming descriptors.
1837 * @priv1: pointer to a header, format or frame
1838 * @priv2: inout parameter, accumulated size of the array
1839 * @priv3: inout parameter, accumulated number of the array elements
1840 * @n: unused, this function's prototype must match @fun in __uvcg_iter_strm_cls
1842 static int __uvcg_cnt_strm(void *priv1, void *priv2, void *priv3, int n,
1843 enum uvcg_strm_type type)
1845 size_t *size = priv2;
1846 size_t *count = priv3;
1850 struct uvcg_streaming_header *h = priv1;
1852 *size += sizeof(h->desc);
1854 *size += h->num_fmt * UVCG_STREAMING_CONTROL_SIZE;
1858 struct uvcg_format *fmt = priv1;
1860 if (fmt->type == UVCG_UNCOMPRESSED) {
1861 struct uvcg_uncompressed *u =
1862 container_of(fmt, struct uvcg_uncompressed,
1865 *size += sizeof(u->desc);
1866 } else if (fmt->type == UVCG_MJPEG) {
1867 struct uvcg_mjpeg *m =
1868 container_of(fmt, struct uvcg_mjpeg, fmt);
1870 *size += sizeof(m->desc);
1877 struct uvcg_frame *frm = priv1;
1878 int sz = sizeof(frm->dw_frame_interval);
1880 *size += sizeof(frm->frame);
1881 *size += frm->frame.b_frame_interval_type * sz;
1892 * Fill an array of streaming descriptors.
1894 * @priv1: pointer to a header, format or frame
1895 * @priv2: inout parameter, pointer into a block of memory
1896 * @priv3: inout parameter, pointer to a 2-dimensional array
1898 static int __uvcg_fill_strm(void *priv1, void *priv2, void *priv3, int n,
1899 enum uvcg_strm_type type)
1901 void **dest = priv2;
1902 struct uvc_descriptor_header ***array = priv3;
1910 struct uvc_input_header_descriptor *ihdr = *dest;
1911 struct uvcg_streaming_header *h = priv1;
1912 struct uvcg_format_ptr *f;
1914 memcpy(*dest, &h->desc, sizeof(h->desc));
1915 *dest += sizeof(h->desc);
1916 sz = UVCG_STREAMING_CONTROL_SIZE;
1917 list_for_each_entry(f, &h->formats, entry) {
1918 memcpy(*dest, f->fmt->bmaControls, sz);
1921 ihdr->bLength = sizeof(h->desc) + h->num_fmt * sz;
1922 ihdr->bNumFormats = h->num_fmt;
1926 struct uvcg_format *fmt = priv1;
1928 if (fmt->type == UVCG_UNCOMPRESSED) {
1929 struct uvc_format_uncompressed *unc = *dest;
1930 struct uvcg_uncompressed *u =
1931 container_of(fmt, struct uvcg_uncompressed,
1934 memcpy(*dest, &u->desc, sizeof(u->desc));
1935 *dest += sizeof(u->desc);
1936 unc->bNumFrameDescriptors = fmt->num_frames;
1937 unc->bFormatIndex = n + 1;
1938 } else if (fmt->type == UVCG_MJPEG) {
1939 struct uvc_format_mjpeg *mjp = *dest;
1940 struct uvcg_mjpeg *m =
1941 container_of(fmt, struct uvcg_mjpeg, fmt);
1943 memcpy(*dest, &m->desc, sizeof(m->desc));
1944 *dest += sizeof(m->desc);
1945 mjp->bNumFrameDescriptors = fmt->num_frames;
1946 mjp->bFormatIndex = n + 1;
1953 struct uvcg_frame *frm = priv1;
1954 struct uvc_descriptor_header *h = *dest;
1956 sz = sizeof(frm->frame);
1957 memcpy(*dest, &frm->frame, sz);
1959 sz = frm->frame.b_frame_interval_type *
1960 sizeof(*frm->dw_frame_interval);
1961 memcpy(*dest, frm->dw_frame_interval, sz);
1963 if (frm->fmt_type == UVCG_UNCOMPRESSED)
1964 h->bLength = UVC_DT_FRAME_UNCOMPRESSED_SIZE(
1965 frm->frame.b_frame_interval_type);
1966 else if (frm->fmt_type == UVCG_MJPEG)
1967 h->bLength = UVC_DT_FRAME_MJPEG_SIZE(
1968 frm->frame.b_frame_interval_type);
1976 static int uvcg_streaming_class_allow_link(struct config_item *src,
1977 struct config_item *target)
1979 struct config_item *streaming, *header;
1980 struct f_uvc_opts *opts;
1981 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1982 struct uvc_descriptor_header ***class_array, **cl_arr;
1983 struct uvcg_streaming_header *target_hdr;
1984 void *data, *data_save;
1985 size_t size = 0, count = 0;
1988 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1990 streaming = src->ci_parent->ci_parent;
1991 header = config_group_find_item(to_config_group(streaming), "header");
1992 if (!header || target->ci_parent != header)
1995 opts = to_f_uvc_opts(streaming->ci_parent);
1997 mutex_lock(&opts->lock);
1999 class_array = __uvcg_get_stream_class_arr(src, opts);
2000 if (!class_array || *class_array || opts->refcnt) {
2005 target_hdr = to_uvcg_streaming_header(target);
2006 ret = __uvcg_iter_strm_cls(target_hdr, &size, &count, __uvcg_cnt_strm);
2010 count += 2; /* color_matching, NULL */
2011 *class_array = kcalloc(count, sizeof(void *), GFP_KERNEL);
2012 if (!*class_array) {
2017 data = data_save = kzalloc(size, GFP_KERNEL);
2019 kfree(*class_array);
2020 *class_array = NULL;
2024 cl_arr = *class_array;
2025 ret = __uvcg_iter_strm_cls(target_hdr, &data, &cl_arr,
2028 kfree(*class_array);
2029 *class_array = NULL;
2031 * __uvcg_fill_strm() called from __uvcg_iter_stream_cls()
2032 * might have advanced the "data", so use a backup copy
2037 *cl_arr = (struct uvc_descriptor_header *)&opts->uvc_color_matching;
2039 ++target_hdr->linked;
2043 mutex_unlock(&opts->lock);
2045 config_item_put(header);
2046 mutex_unlock(su_mutex);
2050 static void uvcg_streaming_class_drop_link(struct config_item *src,
2051 struct config_item *target)
2053 struct config_item *streaming, *header;
2054 struct f_uvc_opts *opts;
2055 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
2056 struct uvc_descriptor_header ***class_array;
2057 struct uvcg_streaming_header *target_hdr;
2059 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2061 streaming = src->ci_parent->ci_parent;
2062 header = config_group_find_item(to_config_group(streaming), "header");
2063 if (!header || target->ci_parent != header)
2066 opts = to_f_uvc_opts(streaming->ci_parent);
2068 mutex_lock(&opts->lock);
2070 class_array = __uvcg_get_stream_class_arr(src, opts);
2071 if (!class_array || !*class_array)
2077 target_hdr = to_uvcg_streaming_header(target);
2078 --target_hdr->linked;
2079 kfree(**class_array);
2080 kfree(*class_array);
2081 *class_array = NULL;
2084 mutex_unlock(&opts->lock);
2086 config_item_put(header);
2087 mutex_unlock(su_mutex);
2090 static struct configfs_item_operations uvcg_streaming_class_item_ops = {
2091 .allow_link = uvcg_streaming_class_allow_link,
2092 .drop_link = uvcg_streaming_class_drop_link,
2095 static struct config_item_type uvcg_streaming_class_type = {
2096 .ct_item_ops = &uvcg_streaming_class_item_ops,
2097 .ct_owner = THIS_MODULE,
2100 /* streaming/class */
2101 static struct uvcg_streaming_class_grp {
2102 struct config_group group;
2103 } uvcg_streaming_class_grp;
2105 static struct config_item_type uvcg_streaming_class_grp_type = {
2106 .ct_owner = THIS_MODULE,
2110 static struct uvcg_streaming_grp {
2111 struct config_group group;
2112 } uvcg_streaming_grp;
2114 static struct config_item_type uvcg_streaming_grp_type = {
2115 .ct_owner = THIS_MODULE,
2118 static inline struct f_uvc_opts *to_f_uvc_opts(struct config_item *item)
2120 return container_of(to_config_group(item), struct f_uvc_opts,
2124 static void uvc_attr_release(struct config_item *item)
2126 struct f_uvc_opts *opts = to_f_uvc_opts(item);
2128 usb_put_function_instance(&opts->func_inst);
2131 static struct configfs_item_operations uvc_item_ops = {
2132 .release = uvc_attr_release,
2135 #define UVCG_OPTS_ATTR(cname, aname, conv, str2u, uxx, vnoc, limit) \
2136 static ssize_t f_uvc_opts_##cname##_show( \
2137 struct config_item *item, char *page) \
2139 struct f_uvc_opts *opts = to_f_uvc_opts(item); \
2142 mutex_lock(&opts->lock); \
2143 result = sprintf(page, "%d\n", conv(opts->cname)); \
2144 mutex_unlock(&opts->lock); \
2150 f_uvc_opts_##cname##_store(struct config_item *item, \
2151 const char *page, size_t len) \
2153 struct f_uvc_opts *opts = to_f_uvc_opts(item); \
2157 mutex_lock(&opts->lock); \
2158 if (opts->refcnt) { \
2163 ret = str2u(page, 0, &num); \
2167 if (num > limit) { \
2171 opts->cname = vnoc(num); \
2174 mutex_unlock(&opts->lock); \
2178 UVC_ATTR(f_uvc_opts_, cname, cname)
2180 #define identity_conv(x) (x)
2182 UVCG_OPTS_ATTR(streaming_interval, streaming_interval, identity_conv,
2183 kstrtou8, u8, identity_conv, 16);
2184 UVCG_OPTS_ATTR(streaming_maxpacket, streaming_maxpacket, le16_to_cpu,
2185 kstrtou16, u16, le16_to_cpu, 3072);
2186 UVCG_OPTS_ATTR(streaming_maxburst, streaming_maxburst, identity_conv,
2187 kstrtou8, u8, identity_conv, 15);
2189 #undef identity_conv
2191 #undef UVCG_OPTS_ATTR
2193 static struct configfs_attribute *uvc_attrs[] = {
2194 &f_uvc_opts_attr_streaming_interval,
2195 &f_uvc_opts_attr_streaming_maxpacket,
2196 &f_uvc_opts_attr_streaming_maxburst,
2200 static struct config_item_type uvc_func_type = {
2201 .ct_item_ops = &uvc_item_ops,
2202 .ct_attrs = uvc_attrs,
2203 .ct_owner = THIS_MODULE,
2206 int uvcg_attach_configfs(struct f_uvc_opts *opts)
2208 config_group_init_type_name(&uvcg_control_header_grp.group,
2210 &uvcg_control_header_grp_type);
2212 config_group_init_type_name(&uvcg_default_processing.group,
2213 "default", &uvcg_default_processing_type);
2214 config_group_init_type_name(&uvcg_processing_grp.group,
2215 "processing", &uvcg_processing_grp_type);
2216 configfs_add_default_group(&uvcg_default_processing.group,
2217 &uvcg_processing_grp.group);
2219 config_group_init_type_name(&uvcg_default_camera.group,
2220 "default", &uvcg_default_camera_type);
2221 config_group_init_type_name(&uvcg_camera_grp.group,
2222 "camera", &uvcg_camera_grp_type);
2223 configfs_add_default_group(&uvcg_default_camera.group,
2224 &uvcg_camera_grp.group);
2226 config_group_init_type_name(&uvcg_default_output.group,
2227 "default", &uvcg_default_output_type);
2228 config_group_init_type_name(&uvcg_output_grp.group,
2229 "output", &uvcg_output_grp_type);
2230 configfs_add_default_group(&uvcg_default_output.group,
2231 &uvcg_output_grp.group);
2233 config_group_init_type_name(&uvcg_terminal_grp.group,
2234 "terminal", &uvcg_terminal_grp_type);
2235 configfs_add_default_group(&uvcg_camera_grp.group,
2236 &uvcg_terminal_grp.group);
2237 configfs_add_default_group(&uvcg_output_grp.group,
2238 &uvcg_terminal_grp.group);
2240 config_group_init_type_name(&uvcg_control_class_fs.group,
2241 "fs", &uvcg_control_class_type);
2242 config_group_init_type_name(&uvcg_control_class_ss.group,
2243 "ss", &uvcg_control_class_type);
2244 config_group_init_type_name(&uvcg_control_class_grp.group,
2246 &uvcg_control_class_grp_type);
2247 configfs_add_default_group(&uvcg_control_class_fs.group,
2248 &uvcg_control_class_grp.group);
2249 configfs_add_default_group(&uvcg_control_class_ss.group,
2250 &uvcg_control_class_grp.group);
2252 config_group_init_type_name(&uvcg_control_grp.group,
2254 &uvcg_control_grp_type);
2255 configfs_add_default_group(&uvcg_control_header_grp.group,
2256 &uvcg_control_grp.group);
2257 configfs_add_default_group(&uvcg_processing_grp.group,
2258 &uvcg_control_grp.group);
2259 configfs_add_default_group(&uvcg_terminal_grp.group,
2260 &uvcg_control_grp.group);
2261 configfs_add_default_group(&uvcg_control_class_grp.group,
2262 &uvcg_control_grp.group);
2264 config_group_init_type_name(&uvcg_streaming_header_grp.group,
2266 &uvcg_streaming_header_grp_type);
2267 config_group_init_type_name(&uvcg_uncompressed_grp.group,
2269 &uvcg_uncompressed_grp_type);
2270 config_group_init_type_name(&uvcg_mjpeg_grp.group,
2272 &uvcg_mjpeg_grp_type);
2273 config_group_init_type_name(&uvcg_default_color_matching.group,
2275 &uvcg_default_color_matching_type);
2276 config_group_init_type_name(&uvcg_color_matching_grp.group,
2278 &uvcg_color_matching_grp_type);
2279 configfs_add_default_group(&uvcg_default_color_matching.group,
2280 &uvcg_color_matching_grp.group);
2282 config_group_init_type_name(&uvcg_streaming_class_fs.group,
2283 "fs", &uvcg_streaming_class_type);
2284 config_group_init_type_name(&uvcg_streaming_class_hs.group,
2285 "hs", &uvcg_streaming_class_type);
2286 config_group_init_type_name(&uvcg_streaming_class_ss.group,
2287 "ss", &uvcg_streaming_class_type);
2288 config_group_init_type_name(&uvcg_streaming_class_grp.group,
2289 "class", &uvcg_streaming_class_grp_type);
2290 configfs_add_default_group(&uvcg_streaming_class_fs.group,
2291 &uvcg_streaming_class_grp.group);
2292 configfs_add_default_group(&uvcg_streaming_class_hs.group,
2293 &uvcg_streaming_class_grp.group);
2294 configfs_add_default_group(&uvcg_streaming_class_ss.group,
2295 &uvcg_streaming_class_grp.group);
2297 config_group_init_type_name(&uvcg_streaming_grp.group,
2298 "streaming", &uvcg_streaming_grp_type);
2299 configfs_add_default_group(&uvcg_streaming_header_grp.group,
2300 &uvcg_streaming_grp.group);
2301 configfs_add_default_group(&uvcg_uncompressed_grp.group,
2302 &uvcg_streaming_grp.group);
2303 configfs_add_default_group(&uvcg_mjpeg_grp.group,
2304 &uvcg_streaming_grp.group);
2305 configfs_add_default_group(&uvcg_color_matching_grp.group,
2306 &uvcg_streaming_grp.group);
2307 configfs_add_default_group(&uvcg_streaming_class_grp.group,
2308 &uvcg_streaming_grp.group);
2310 config_group_init_type_name(&opts->func_inst.group,
2313 configfs_add_default_group(&uvcg_control_grp.group,
2314 &opts->func_inst.group);
2315 configfs_add_default_group(&uvcg_streaming_grp.group,
2316 &opts->func_inst.group);