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 int 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;
561 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
563 control = src->ci_parent->ci_parent;
564 header = config_group_find_item(to_config_group(control), "header");
565 if (!header || target->ci_parent != header)
568 opts = to_f_uvc_opts(control->ci_parent);
570 mutex_lock(&opts->lock);
572 class_array = uvcg_get_ctl_class_arr(src, opts);
580 target_hdr = to_uvcg_control_header(target);
581 --target_hdr->linked;
582 class_array[0] = NULL;
586 mutex_unlock(&opts->lock);
588 config_item_put(header);
589 mutex_unlock(su_mutex);
593 static struct configfs_item_operations uvcg_control_class_item_ops = {
594 .allow_link = uvcg_control_class_allow_link,
595 .drop_link = uvcg_control_class_drop_link,
598 static struct config_item_type uvcg_control_class_type = {
599 .ct_item_ops = &uvcg_control_class_item_ops,
600 .ct_owner = THIS_MODULE,
604 static struct uvcg_control_class_grp {
605 struct config_group group;
606 } uvcg_control_class_grp;
608 static struct config_item_type uvcg_control_class_grp_type = {
609 .ct_owner = THIS_MODULE,
613 static struct uvcg_control_grp {
614 struct config_group group;
617 static struct config_item_type uvcg_control_grp_type = {
618 .ct_owner = THIS_MODULE,
621 /* streaming/uncompressed */
622 static struct uvcg_uncompressed_grp {
623 struct config_group group;
624 } uvcg_uncompressed_grp;
626 /* streaming/mjpeg */
627 static struct uvcg_mjpeg_grp {
628 struct config_group group;
631 static struct config_item *fmt_parent[] = {
632 &uvcg_uncompressed_grp.group.cg_item,
633 &uvcg_mjpeg_grp.group.cg_item,
636 enum uvcg_format_type {
637 UVCG_UNCOMPRESSED = 0,
642 struct config_group group;
643 enum uvcg_format_type type;
646 __u8 bmaControls[UVCG_STREAMING_CONTROL_SIZE];
649 static struct uvcg_format *to_uvcg_format(struct config_item *item)
651 return container_of(to_config_group(item), struct uvcg_format, group);
654 static ssize_t uvcg_format_bma_controls_show(struct uvcg_format *f, char *page)
656 struct f_uvc_opts *opts;
657 struct config_item *opts_item;
658 struct mutex *su_mutex = &f->group.cg_subsys->su_mutex;
662 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
664 opts_item = f->group.cg_item.ci_parent->ci_parent->ci_parent;
665 opts = to_f_uvc_opts(opts_item);
667 mutex_lock(&opts->lock);
668 result = sprintf(pg, "0x");
670 for (i = 0; i < UVCG_STREAMING_CONTROL_SIZE; ++i) {
671 result += sprintf(pg, "%x\n", f->bmaControls[i]);
674 mutex_unlock(&opts->lock);
676 mutex_unlock(su_mutex);
680 static ssize_t uvcg_format_bma_controls_store(struct uvcg_format *ch,
681 const char *page, size_t len)
683 struct f_uvc_opts *opts;
684 struct config_item *opts_item;
685 struct mutex *su_mutex = &ch->group.cg_subsys->su_mutex;
688 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
690 opts_item = ch->group.cg_item.ci_parent->ci_parent->ci_parent;
691 opts = to_f_uvc_opts(opts_item);
693 mutex_lock(&opts->lock);
694 if (ch->linked || opts->refcnt) {
699 if (len < 4 || *page != '0' ||
700 (*(page + 1) != 'x' && *(page + 1) != 'X'))
702 ret = hex2bin(ch->bmaControls, page + 2, 1);
707 mutex_unlock(&opts->lock);
708 mutex_unlock(su_mutex);
712 struct uvcg_format_ptr {
713 struct uvcg_format *fmt;
714 struct list_head entry;
717 /* streaming/header/<NAME> */
718 struct uvcg_streaming_header {
719 struct config_item item;
720 struct uvc_input_header_descriptor desc;
722 struct list_head formats;
726 static struct uvcg_streaming_header *to_uvcg_streaming_header(struct config_item *item)
728 return container_of(item, struct uvcg_streaming_header, item);
731 static int uvcg_streaming_header_allow_link(struct config_item *src,
732 struct config_item *target)
734 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
735 struct config_item *opts_item;
736 struct f_uvc_opts *opts;
737 struct uvcg_streaming_header *src_hdr;
738 struct uvcg_format *target_fmt = NULL;
739 struct uvcg_format_ptr *format_ptr;
740 int i, ret = -EINVAL;
742 src_hdr = to_uvcg_streaming_header(src);
743 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
745 opts_item = src->ci_parent->ci_parent->ci_parent;
746 opts = to_f_uvc_opts(opts_item);
748 mutex_lock(&opts->lock);
750 if (src_hdr->linked) {
755 for (i = 0; i < ARRAY_SIZE(fmt_parent); ++i)
756 if (target->ci_parent == fmt_parent[i])
758 if (i == ARRAY_SIZE(fmt_parent))
761 target_fmt = container_of(to_config_group(target), struct uvcg_format,
766 format_ptr = kzalloc(sizeof(*format_ptr), GFP_KERNEL);
772 format_ptr->fmt = target_fmt;
773 list_add_tail(&format_ptr->entry, &src_hdr->formats);
775 ++target_fmt->linked;
778 mutex_unlock(&opts->lock);
779 mutex_unlock(su_mutex);
783 static int uvcg_streaming_header_drop_link(struct config_item *src,
784 struct config_item *target)
786 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
787 struct config_item *opts_item;
788 struct f_uvc_opts *opts;
789 struct uvcg_streaming_header *src_hdr;
790 struct uvcg_format *target_fmt = NULL;
791 struct uvcg_format_ptr *format_ptr, *tmp;
794 src_hdr = to_uvcg_streaming_header(src);
795 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
797 opts_item = src->ci_parent->ci_parent->ci_parent;
798 opts = to_f_uvc_opts(opts_item);
800 mutex_lock(&opts->lock);
801 target_fmt = container_of(to_config_group(target), struct uvcg_format,
806 list_for_each_entry_safe(format_ptr, tmp, &src_hdr->formats, entry)
807 if (format_ptr->fmt == target_fmt) {
808 list_del(&format_ptr->entry);
814 --target_fmt->linked;
817 mutex_unlock(&opts->lock);
818 mutex_unlock(su_mutex);
823 static struct configfs_item_operations uvcg_streaming_header_item_ops = {
824 .allow_link = uvcg_streaming_header_allow_link,
825 .drop_link = uvcg_streaming_header_drop_link,
828 #define UVCG_STREAMING_HEADER_ATTR(cname, aname, conv) \
829 static ssize_t uvcg_streaming_header_##cname##_show( \
830 struct config_item *item, char *page) \
832 struct uvcg_streaming_header *sh = to_uvcg_streaming_header(item); \
833 struct f_uvc_opts *opts; \
834 struct config_item *opts_item; \
835 struct mutex *su_mutex = &sh->item.ci_group->cg_subsys->su_mutex;\
838 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
840 opts_item = sh->item.ci_parent->ci_parent->ci_parent; \
841 opts = to_f_uvc_opts(opts_item); \
843 mutex_lock(&opts->lock); \
844 result = sprintf(page, "%d\n", conv(sh->desc.aname)); \
845 mutex_unlock(&opts->lock); \
847 mutex_unlock(su_mutex); \
851 UVC_ATTR_RO(uvcg_streaming_header_, cname, aname)
853 #define identity_conv(x) (x)
855 UVCG_STREAMING_HEADER_ATTR(bm_info, bmInfo, identity_conv);
856 UVCG_STREAMING_HEADER_ATTR(b_terminal_link, bTerminalLink, identity_conv);
857 UVCG_STREAMING_HEADER_ATTR(b_still_capture_method, bStillCaptureMethod,
859 UVCG_STREAMING_HEADER_ATTR(b_trigger_support, bTriggerSupport, identity_conv);
860 UVCG_STREAMING_HEADER_ATTR(b_trigger_usage, bTriggerUsage, identity_conv);
864 #undef UVCG_STREAMING_HEADER_ATTR
866 static struct configfs_attribute *uvcg_streaming_header_attrs[] = {
867 &uvcg_streaming_header_attr_bm_info,
868 &uvcg_streaming_header_attr_b_terminal_link,
869 &uvcg_streaming_header_attr_b_still_capture_method,
870 &uvcg_streaming_header_attr_b_trigger_support,
871 &uvcg_streaming_header_attr_b_trigger_usage,
875 static struct config_item_type uvcg_streaming_header_type = {
876 .ct_item_ops = &uvcg_streaming_header_item_ops,
877 .ct_attrs = uvcg_streaming_header_attrs,
878 .ct_owner = THIS_MODULE,
881 static struct config_item
882 *uvcg_streaming_header_make(struct config_group *group, const char *name)
884 struct uvcg_streaming_header *h;
886 h = kzalloc(sizeof(*h), GFP_KERNEL);
888 return ERR_PTR(-ENOMEM);
890 INIT_LIST_HEAD(&h->formats);
891 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
892 h->desc.bDescriptorSubType = UVC_VS_INPUT_HEADER;
893 h->desc.bTerminalLink = 3;
894 h->desc.bControlSize = UVCG_STREAMING_CONTROL_SIZE;
896 config_item_init_type_name(&h->item, name, &uvcg_streaming_header_type);
901 static void uvcg_streaming_header_drop(struct config_group *group,
902 struct config_item *item)
904 struct uvcg_streaming_header *h = to_uvcg_streaming_header(item);
909 /* streaming/header */
910 static struct uvcg_streaming_header_grp {
911 struct config_group group;
912 } uvcg_streaming_header_grp;
914 static struct configfs_group_operations uvcg_streaming_header_grp_ops = {
915 .make_item = uvcg_streaming_header_make,
916 .drop_item = uvcg_streaming_header_drop,
919 static struct config_item_type uvcg_streaming_header_grp_type = {
920 .ct_group_ops = &uvcg_streaming_header_grp_ops,
921 .ct_owner = THIS_MODULE,
924 /* streaming/<mode>/<format>/<NAME> */
928 u8 b_descriptor_type;
929 u8 b_descriptor_subtype;
936 u32 dw_max_video_frame_buffer_size;
937 u32 dw_default_frame_interval;
938 u8 b_frame_interval_type;
939 } __attribute__((packed)) frame;
940 u32 *dw_frame_interval;
941 enum uvcg_format_type fmt_type;
942 struct config_item item;
945 static struct uvcg_frame *to_uvcg_frame(struct config_item *item)
947 return container_of(item, struct uvcg_frame, item);
950 #define UVCG_FRAME_ATTR(cname, aname, to_cpu_endian, to_little_endian, bits) \
951 static ssize_t uvcg_frame_##cname##_show(struct config_item *item, char *page)\
953 struct uvcg_frame *f = to_uvcg_frame(item); \
954 struct f_uvc_opts *opts; \
955 struct config_item *opts_item; \
956 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
959 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
961 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
962 opts = to_f_uvc_opts(opts_item); \
964 mutex_lock(&opts->lock); \
965 result = sprintf(page, "%d\n", to_cpu_endian(f->frame.cname)); \
966 mutex_unlock(&opts->lock); \
968 mutex_unlock(su_mutex); \
972 static ssize_t uvcg_frame_##cname##_store(struct config_item *item, \
973 const char *page, size_t len)\
975 struct uvcg_frame *f = to_uvcg_frame(item); \
976 struct f_uvc_opts *opts; \
977 struct config_item *opts_item; \
978 struct uvcg_format *fmt; \
979 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
983 ret = kstrtou##bits(page, 0, &num); \
987 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
989 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
990 opts = to_f_uvc_opts(opts_item); \
991 fmt = to_uvcg_format(f->item.ci_parent); \
993 mutex_lock(&opts->lock); \
994 if (fmt->linked || opts->refcnt) { \
999 f->frame.cname = to_little_endian(num); \
1002 mutex_unlock(&opts->lock); \
1003 mutex_unlock(su_mutex); \
1007 UVC_ATTR(uvcg_frame_, cname, aname);
1009 #define noop_conversion(x) (x)
1011 UVCG_FRAME_ATTR(bm_capabilities, bmCapabilities, noop_conversion,
1012 noop_conversion, 8);
1013 UVCG_FRAME_ATTR(w_width, wWidth, le16_to_cpu, cpu_to_le16, 16);
1014 UVCG_FRAME_ATTR(w_height, wHeight, le16_to_cpu, cpu_to_le16, 16);
1015 UVCG_FRAME_ATTR(dw_min_bit_rate, dwMinBitRate, le32_to_cpu, cpu_to_le32, 32);
1016 UVCG_FRAME_ATTR(dw_max_bit_rate, dwMaxBitRate, le32_to_cpu, cpu_to_le32, 32);
1017 UVCG_FRAME_ATTR(dw_max_video_frame_buffer_size, dwMaxVideoFrameBufferSize,
1018 le32_to_cpu, cpu_to_le32, 32);
1019 UVCG_FRAME_ATTR(dw_default_frame_interval, dwDefaultFrameInterval,
1020 le32_to_cpu, cpu_to_le32, 32);
1022 #undef noop_conversion
1024 #undef UVCG_FRAME_ATTR
1026 static ssize_t uvcg_frame_dw_frame_interval_show(struct config_item *item,
1029 struct uvcg_frame *frm = to_uvcg_frame(item);
1030 struct f_uvc_opts *opts;
1031 struct config_item *opts_item;
1032 struct mutex *su_mutex = &frm->item.ci_group->cg_subsys->su_mutex;
1036 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1038 opts_item = frm->item.ci_parent->ci_parent->ci_parent->ci_parent;
1039 opts = to_f_uvc_opts(opts_item);
1041 mutex_lock(&opts->lock);
1042 for (result = 0, i = 0; i < frm->frame.b_frame_interval_type; ++i) {
1043 result += sprintf(pg, "%d\n",
1044 le32_to_cpu(frm->dw_frame_interval[i]));
1047 mutex_unlock(&opts->lock);
1049 mutex_unlock(su_mutex);
1053 static inline int __uvcg_count_frm_intrv(char *buf, void *priv)
1059 static inline int __uvcg_fill_frm_intrv(char *buf, void *priv)
1064 ret = kstrtou32(buf, 0, &num);
1069 **interv = cpu_to_le32(num);
1075 static int __uvcg_iter_frm_intrv(const char *page, size_t len,
1076 int (*fun)(char *, void *), void *priv)
1078 /* sign, base 2 representation, newline, terminator */
1079 char buf[1 + sizeof(u32) * 8 + 1 + 1];
1080 const char *pg = page;
1086 while (pg - page < len) {
1088 while (i < sizeof(buf) && (pg - page < len) &&
1089 *pg != '\0' && *pg != '\n')
1091 if (i == sizeof(buf))
1093 while ((pg - page < len) && (*pg == '\0' || *pg == '\n'))
1096 ret = fun(buf, priv);
1104 static ssize_t uvcg_frame_dw_frame_interval_store(struct config_item *item,
1105 const char *page, size_t len)
1107 struct uvcg_frame *ch = to_uvcg_frame(item);
1108 struct f_uvc_opts *opts;
1109 struct config_item *opts_item;
1110 struct uvcg_format *fmt;
1111 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;
1113 u32 *frm_intrv, *tmp;
1115 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1117 opts_item = ch->item.ci_parent->ci_parent->ci_parent->ci_parent;
1118 opts = to_f_uvc_opts(opts_item);
1119 fmt = to_uvcg_format(ch->item.ci_parent);
1121 mutex_lock(&opts->lock);
1122 if (fmt->linked || opts->refcnt) {
1127 ret = __uvcg_iter_frm_intrv(page, len, __uvcg_count_frm_intrv, &n);
1131 tmp = frm_intrv = kcalloc(n, sizeof(u32), GFP_KERNEL);
1137 ret = __uvcg_iter_frm_intrv(page, len, __uvcg_fill_frm_intrv, &tmp);
1143 kfree(ch->dw_frame_interval);
1144 ch->dw_frame_interval = frm_intrv;
1145 ch->frame.b_frame_interval_type = n;
1149 mutex_unlock(&opts->lock);
1150 mutex_unlock(su_mutex);
1154 UVC_ATTR(uvcg_frame_, dw_frame_interval, dwFrameInterval);
1156 static struct configfs_attribute *uvcg_frame_attrs[] = {
1157 &uvcg_frame_attr_bm_capabilities,
1158 &uvcg_frame_attr_w_width,
1159 &uvcg_frame_attr_w_height,
1160 &uvcg_frame_attr_dw_min_bit_rate,
1161 &uvcg_frame_attr_dw_max_bit_rate,
1162 &uvcg_frame_attr_dw_max_video_frame_buffer_size,
1163 &uvcg_frame_attr_dw_default_frame_interval,
1164 &uvcg_frame_attr_dw_frame_interval,
1168 static struct config_item_type uvcg_frame_type = {
1169 .ct_attrs = uvcg_frame_attrs,
1170 .ct_owner = THIS_MODULE,
1173 static struct config_item *uvcg_frame_make(struct config_group *group,
1176 struct uvcg_frame *h;
1177 struct uvcg_format *fmt;
1178 struct f_uvc_opts *opts;
1179 struct config_item *opts_item;
1181 h = kzalloc(sizeof(*h), GFP_KERNEL);
1183 return ERR_PTR(-ENOMEM);
1185 h->frame.b_descriptor_type = USB_DT_CS_INTERFACE;
1186 h->frame.b_frame_index = 1;
1187 h->frame.w_width = cpu_to_le16(640);
1188 h->frame.w_height = cpu_to_le16(360);
1189 h->frame.dw_min_bit_rate = cpu_to_le32(18432000);
1190 h->frame.dw_max_bit_rate = cpu_to_le32(55296000);
1191 h->frame.dw_max_video_frame_buffer_size = cpu_to_le32(460800);
1192 h->frame.dw_default_frame_interval = cpu_to_le32(666666);
1194 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1195 opts = to_f_uvc_opts(opts_item);
1197 mutex_lock(&opts->lock);
1198 fmt = to_uvcg_format(&group->cg_item);
1199 if (fmt->type == UVCG_UNCOMPRESSED) {
1200 h->frame.b_descriptor_subtype = UVC_VS_FRAME_UNCOMPRESSED;
1201 h->fmt_type = UVCG_UNCOMPRESSED;
1202 } else if (fmt->type == UVCG_MJPEG) {
1203 h->frame.b_descriptor_subtype = UVC_VS_FRAME_MJPEG;
1204 h->fmt_type = UVCG_MJPEG;
1206 mutex_unlock(&opts->lock);
1208 return ERR_PTR(-EINVAL);
1211 mutex_unlock(&opts->lock);
1213 config_item_init_type_name(&h->item, name, &uvcg_frame_type);
1218 static void uvcg_frame_drop(struct config_group *group, struct config_item *item)
1220 struct uvcg_frame *h = to_uvcg_frame(item);
1221 struct uvcg_format *fmt;
1222 struct f_uvc_opts *opts;
1223 struct config_item *opts_item;
1225 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1226 opts = to_f_uvc_opts(opts_item);
1228 mutex_lock(&opts->lock);
1229 fmt = to_uvcg_format(&group->cg_item);
1232 mutex_unlock(&opts->lock);
1235 /* streaming/uncompressed/<NAME> */
1236 struct uvcg_uncompressed {
1237 struct uvcg_format fmt;
1238 struct uvc_format_uncompressed desc;
1241 static struct uvcg_uncompressed *to_uvcg_uncompressed(struct config_item *item)
1243 return container_of(
1244 container_of(to_config_group(item), struct uvcg_format, group),
1245 struct uvcg_uncompressed, fmt);
1248 static struct configfs_group_operations uvcg_uncompressed_group_ops = {
1249 .make_item = uvcg_frame_make,
1250 .drop_item = uvcg_frame_drop,
1253 static ssize_t uvcg_uncompressed_guid_format_show(struct config_item *item,
1256 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1257 struct f_uvc_opts *opts;
1258 struct config_item *opts_item;
1259 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1261 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1263 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1264 opts = to_f_uvc_opts(opts_item);
1266 mutex_lock(&opts->lock);
1267 memcpy(page, ch->desc.guidFormat, sizeof(ch->desc.guidFormat));
1268 mutex_unlock(&opts->lock);
1270 mutex_unlock(su_mutex);
1272 return sizeof(ch->desc.guidFormat);
1275 static ssize_t uvcg_uncompressed_guid_format_store(struct config_item *item,
1276 const char *page, size_t len)
1278 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1279 struct f_uvc_opts *opts;
1280 struct config_item *opts_item;
1281 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1284 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1286 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1287 opts = to_f_uvc_opts(opts_item);
1289 mutex_lock(&opts->lock);
1290 if (ch->fmt.linked || opts->refcnt) {
1295 memcpy(ch->desc.guidFormat, page,
1296 min(sizeof(ch->desc.guidFormat), len));
1297 ret = sizeof(ch->desc.guidFormat);
1300 mutex_unlock(&opts->lock);
1301 mutex_unlock(su_mutex);
1305 UVC_ATTR(uvcg_uncompressed_, guid_format, guidFormat);
1307 #define UVCG_UNCOMPRESSED_ATTR_RO(cname, aname, conv) \
1308 static ssize_t uvcg_uncompressed_##cname##_show( \
1309 struct config_item *item, char *page) \
1311 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1312 struct f_uvc_opts *opts; \
1313 struct config_item *opts_item; \
1314 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1317 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1319 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1320 opts = to_f_uvc_opts(opts_item); \
1322 mutex_lock(&opts->lock); \
1323 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1324 mutex_unlock(&opts->lock); \
1326 mutex_unlock(su_mutex); \
1330 UVC_ATTR_RO(uvcg_uncompressed_, cname, aname);
1332 #define UVCG_UNCOMPRESSED_ATTR(cname, aname, conv) \
1333 static ssize_t uvcg_uncompressed_##cname##_show( \
1334 struct config_item *item, char *page) \
1336 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1337 struct f_uvc_opts *opts; \
1338 struct config_item *opts_item; \
1339 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1342 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1344 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1345 opts = to_f_uvc_opts(opts_item); \
1347 mutex_lock(&opts->lock); \
1348 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1349 mutex_unlock(&opts->lock); \
1351 mutex_unlock(su_mutex); \
1356 uvcg_uncompressed_##cname##_store(struct config_item *item, \
1357 const char *page, size_t len) \
1359 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1360 struct f_uvc_opts *opts; \
1361 struct config_item *opts_item; \
1362 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1366 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1368 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1369 opts = to_f_uvc_opts(opts_item); \
1371 mutex_lock(&opts->lock); \
1372 if (u->fmt.linked || opts->refcnt) { \
1377 ret = kstrtou8(page, 0, &num); \
1385 u->desc.aname = num; \
1388 mutex_unlock(&opts->lock); \
1389 mutex_unlock(su_mutex); \
1393 UVC_ATTR(uvcg_uncompressed_, cname, aname);
1395 #define identity_conv(x) (x)
1397 UVCG_UNCOMPRESSED_ATTR(b_bits_per_pixel, bBitsPerPixel, identity_conv);
1398 UVCG_UNCOMPRESSED_ATTR(b_default_frame_index, bDefaultFrameIndex,
1400 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, identity_conv);
1401 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, identity_conv);
1402 UVCG_UNCOMPRESSED_ATTR_RO(bm_interface_flags, bmInterfaceFlags, identity_conv);
1404 #undef identity_conv
1406 #undef UVCG_UNCOMPRESSED_ATTR
1407 #undef UVCG_UNCOMPRESSED_ATTR_RO
1409 static inline ssize_t
1410 uvcg_uncompressed_bma_controls_show(struct config_item *item, char *page)
1412 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1413 return uvcg_format_bma_controls_show(&unc->fmt, page);
1416 static inline ssize_t
1417 uvcg_uncompressed_bma_controls_store(struct config_item *item,
1418 const char *page, size_t len)
1420 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1421 return uvcg_format_bma_controls_store(&unc->fmt, page, len);
1424 UVC_ATTR(uvcg_uncompressed_, bma_controls, bmaControls);
1426 static struct configfs_attribute *uvcg_uncompressed_attrs[] = {
1427 &uvcg_uncompressed_attr_guid_format,
1428 &uvcg_uncompressed_attr_b_bits_per_pixel,
1429 &uvcg_uncompressed_attr_b_default_frame_index,
1430 &uvcg_uncompressed_attr_b_aspect_ratio_x,
1431 &uvcg_uncompressed_attr_b_aspect_ratio_y,
1432 &uvcg_uncompressed_attr_bm_interface_flags,
1433 &uvcg_uncompressed_attr_bma_controls,
1437 static struct config_item_type uvcg_uncompressed_type = {
1438 .ct_group_ops = &uvcg_uncompressed_group_ops,
1439 .ct_attrs = uvcg_uncompressed_attrs,
1440 .ct_owner = THIS_MODULE,
1443 static struct config_group *uvcg_uncompressed_make(struct config_group *group,
1446 static char guid[] = {
1447 'Y', 'U', 'Y', '2', 0x00, 0x00, 0x10, 0x00,
1448 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
1450 struct uvcg_uncompressed *h;
1452 h = kzalloc(sizeof(*h), GFP_KERNEL);
1454 return ERR_PTR(-ENOMEM);
1456 h->desc.bLength = UVC_DT_FORMAT_UNCOMPRESSED_SIZE;
1457 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1458 h->desc.bDescriptorSubType = UVC_VS_FORMAT_UNCOMPRESSED;
1459 memcpy(h->desc.guidFormat, guid, sizeof(guid));
1460 h->desc.bBitsPerPixel = 16;
1461 h->desc.bDefaultFrameIndex = 1;
1462 h->desc.bAspectRatioX = 0;
1463 h->desc.bAspectRatioY = 0;
1464 h->desc.bmInterfaceFlags = 0;
1465 h->desc.bCopyProtect = 0;
1467 h->fmt.type = UVCG_UNCOMPRESSED;
1468 config_group_init_type_name(&h->fmt.group, name,
1469 &uvcg_uncompressed_type);
1471 return &h->fmt.group;
1474 static void uvcg_uncompressed_drop(struct config_group *group,
1475 struct config_item *item)
1477 struct uvcg_uncompressed *h = to_uvcg_uncompressed(item);
1482 static struct configfs_group_operations uvcg_uncompressed_grp_ops = {
1483 .make_group = uvcg_uncompressed_make,
1484 .drop_item = uvcg_uncompressed_drop,
1487 static struct config_item_type uvcg_uncompressed_grp_type = {
1488 .ct_group_ops = &uvcg_uncompressed_grp_ops,
1489 .ct_owner = THIS_MODULE,
1492 /* streaming/mjpeg/<NAME> */
1494 struct uvcg_format fmt;
1495 struct uvc_format_mjpeg desc;
1498 static struct uvcg_mjpeg *to_uvcg_mjpeg(struct config_item *item)
1500 return container_of(
1501 container_of(to_config_group(item), struct uvcg_format, group),
1502 struct uvcg_mjpeg, fmt);
1505 static struct configfs_group_operations uvcg_mjpeg_group_ops = {
1506 .make_item = uvcg_frame_make,
1507 .drop_item = uvcg_frame_drop,
1510 #define UVCG_MJPEG_ATTR_RO(cname, aname, conv) \
1511 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1513 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1514 struct f_uvc_opts *opts; \
1515 struct config_item *opts_item; \
1516 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1519 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1521 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1522 opts = to_f_uvc_opts(opts_item); \
1524 mutex_lock(&opts->lock); \
1525 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1526 mutex_unlock(&opts->lock); \
1528 mutex_unlock(su_mutex); \
1532 UVC_ATTR_RO(uvcg_mjpeg_, cname, aname)
1534 #define UVCG_MJPEG_ATTR(cname, aname, conv) \
1535 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1537 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1538 struct f_uvc_opts *opts; \
1539 struct config_item *opts_item; \
1540 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1543 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1545 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1546 opts = to_f_uvc_opts(opts_item); \
1548 mutex_lock(&opts->lock); \
1549 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1550 mutex_unlock(&opts->lock); \
1552 mutex_unlock(su_mutex); \
1557 uvcg_mjpeg_##cname##_store(struct config_item *item, \
1558 const char *page, size_t len) \
1560 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1561 struct f_uvc_opts *opts; \
1562 struct config_item *opts_item; \
1563 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1567 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1569 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1570 opts = to_f_uvc_opts(opts_item); \
1572 mutex_lock(&opts->lock); \
1573 if (u->fmt.linked || opts->refcnt) { \
1578 ret = kstrtou8(page, 0, &num); \
1586 u->desc.aname = num; \
1589 mutex_unlock(&opts->lock); \
1590 mutex_unlock(su_mutex); \
1594 UVC_ATTR(uvcg_mjpeg_, cname, aname)
1596 #define identity_conv(x) (x)
1598 UVCG_MJPEG_ATTR(b_default_frame_index, bDefaultFrameIndex,
1600 UVCG_MJPEG_ATTR_RO(bm_flags, bmFlags, identity_conv);
1601 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, identity_conv);
1602 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, identity_conv);
1603 UVCG_MJPEG_ATTR_RO(bm_interface_flags, bmInterfaceFlags, identity_conv);
1605 #undef identity_conv
1607 #undef UVCG_MJPEG_ATTR
1608 #undef UVCG_MJPEG_ATTR_RO
1610 static inline ssize_t
1611 uvcg_mjpeg_bma_controls_show(struct config_item *item, char *page)
1613 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1614 return uvcg_format_bma_controls_show(&u->fmt, page);
1617 static inline ssize_t
1618 uvcg_mjpeg_bma_controls_store(struct config_item *item,
1619 const char *page, size_t len)
1621 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1622 return uvcg_format_bma_controls_store(&u->fmt, page, len);
1625 UVC_ATTR(uvcg_mjpeg_, bma_controls, bmaControls);
1627 static struct configfs_attribute *uvcg_mjpeg_attrs[] = {
1628 &uvcg_mjpeg_attr_b_default_frame_index,
1629 &uvcg_mjpeg_attr_bm_flags,
1630 &uvcg_mjpeg_attr_b_aspect_ratio_x,
1631 &uvcg_mjpeg_attr_b_aspect_ratio_y,
1632 &uvcg_mjpeg_attr_bm_interface_flags,
1633 &uvcg_mjpeg_attr_bma_controls,
1637 static struct config_item_type uvcg_mjpeg_type = {
1638 .ct_group_ops = &uvcg_mjpeg_group_ops,
1639 .ct_attrs = uvcg_mjpeg_attrs,
1640 .ct_owner = THIS_MODULE,
1643 static struct config_group *uvcg_mjpeg_make(struct config_group *group,
1646 struct uvcg_mjpeg *h;
1648 h = kzalloc(sizeof(*h), GFP_KERNEL);
1650 return ERR_PTR(-ENOMEM);
1652 h->desc.bLength = UVC_DT_FORMAT_MJPEG_SIZE;
1653 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1654 h->desc.bDescriptorSubType = UVC_VS_FORMAT_MJPEG;
1655 h->desc.bDefaultFrameIndex = 1;
1656 h->desc.bAspectRatioX = 0;
1657 h->desc.bAspectRatioY = 0;
1658 h->desc.bmInterfaceFlags = 0;
1659 h->desc.bCopyProtect = 0;
1661 h->fmt.type = UVCG_MJPEG;
1662 config_group_init_type_name(&h->fmt.group, name,
1665 return &h->fmt.group;
1668 static void uvcg_mjpeg_drop(struct config_group *group,
1669 struct config_item *item)
1671 struct uvcg_mjpeg *h = to_uvcg_mjpeg(item);
1676 static struct configfs_group_operations uvcg_mjpeg_grp_ops = {
1677 .make_group = uvcg_mjpeg_make,
1678 .drop_item = uvcg_mjpeg_drop,
1681 static struct config_item_type uvcg_mjpeg_grp_type = {
1682 .ct_group_ops = &uvcg_mjpeg_grp_ops,
1683 .ct_owner = THIS_MODULE,
1686 /* streaming/color_matching/default */
1687 static struct uvcg_default_color_matching {
1688 struct config_group group;
1689 } uvcg_default_color_matching;
1691 static inline struct uvcg_default_color_matching
1692 *to_uvcg_default_color_matching(struct config_item *item)
1694 return container_of(to_config_group(item),
1695 struct uvcg_default_color_matching, group);
1698 #define UVCG_DEFAULT_COLOR_MATCHING_ATTR(cname, aname, conv) \
1699 static ssize_t uvcg_default_color_matching_##cname##_show( \
1700 struct config_item *item, char *page) \
1702 struct uvcg_default_color_matching *dc = \
1703 to_uvcg_default_color_matching(item); \
1704 struct f_uvc_opts *opts; \
1705 struct config_item *opts_item; \
1706 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex; \
1707 struct uvc_color_matching_descriptor *cd; \
1710 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1712 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent; \
1713 opts = to_f_uvc_opts(opts_item); \
1714 cd = &opts->uvc_color_matching; \
1716 mutex_lock(&opts->lock); \
1717 result = sprintf(page, "%d\n", conv(cd->aname)); \
1718 mutex_unlock(&opts->lock); \
1720 mutex_unlock(su_mutex); \
1724 UVC_ATTR_RO(uvcg_default_color_matching_, cname, aname)
1726 #define identity_conv(x) (x)
1728 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_color_primaries, bColorPrimaries,
1730 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_transfer_characteristics,
1731 bTransferCharacteristics, identity_conv);
1732 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_matrix_coefficients, bMatrixCoefficients,
1735 #undef identity_conv
1737 #undef UVCG_DEFAULT_COLOR_MATCHING_ATTR
1739 static struct configfs_attribute *uvcg_default_color_matching_attrs[] = {
1740 &uvcg_default_color_matching_attr_b_color_primaries,
1741 &uvcg_default_color_matching_attr_b_transfer_characteristics,
1742 &uvcg_default_color_matching_attr_b_matrix_coefficients,
1746 static struct config_item_type uvcg_default_color_matching_type = {
1747 .ct_attrs = uvcg_default_color_matching_attrs,
1748 .ct_owner = THIS_MODULE,
1751 /* struct uvcg_color_matching {}; */
1753 /* streaming/color_matching */
1754 static struct uvcg_color_matching_grp {
1755 struct config_group group;
1756 } uvcg_color_matching_grp;
1758 static struct config_item_type uvcg_color_matching_grp_type = {
1759 .ct_owner = THIS_MODULE,
1762 /* streaming/class/{fs|hs|ss} */
1763 static struct uvcg_streaming_class {
1764 struct config_group group;
1765 } uvcg_streaming_class_fs, uvcg_streaming_class_hs, uvcg_streaming_class_ss;
1768 static inline struct uvc_descriptor_header
1769 ***__uvcg_get_stream_class_arr(struct config_item *i, struct f_uvc_opts *o)
1771 struct uvcg_streaming_class *cl = container_of(to_config_group(i),
1772 struct uvcg_streaming_class, group);
1774 if (cl == &uvcg_streaming_class_fs)
1775 return &o->uvc_fs_streaming_cls;
1777 if (cl == &uvcg_streaming_class_hs)
1778 return &o->uvc_hs_streaming_cls;
1780 if (cl == &uvcg_streaming_class_ss)
1781 return &o->uvc_ss_streaming_cls;
1786 enum uvcg_strm_type {
1793 * Iterate over a hierarchy of streaming descriptors' config items.
1794 * The items are created by the user with configfs.
1796 * It "processes" the header pointed to by @priv1, then for each format
1797 * that follows the header "processes" the format itself and then for
1798 * each frame inside a format "processes" the frame.
1800 * As a "processing" function the @fun is used.
1802 * __uvcg_iter_strm_cls() is used in two context: first, to calculate
1803 * the amount of memory needed for an array of streaming descriptors
1804 * and second, to actually fill the array.
1806 * @h: streaming header pointer
1807 * @priv2: an "inout" parameter (the caller might want to see the changes to it)
1808 * @priv3: an "inout" parameter (the caller might want to see the changes to it)
1809 * @fun: callback function for processing each level of the hierarchy
1811 static int __uvcg_iter_strm_cls(struct uvcg_streaming_header *h,
1812 void *priv2, void *priv3,
1813 int (*fun)(void *, void *, void *, int, enum uvcg_strm_type type))
1815 struct uvcg_format_ptr *f;
1816 struct config_group *grp;
1817 struct config_item *item;
1818 struct uvcg_frame *frm;
1825 ret = fun(h, priv2, priv3, 0, UVCG_HEADER);
1828 list_for_each_entry(f, &h->formats, entry) {
1829 ret = fun(f->fmt, priv2, priv3, i++, UVCG_FORMAT);
1832 grp = &f->fmt->group;
1833 list_for_each_entry(item, &grp->cg_children, ci_entry) {
1834 frm = to_uvcg_frame(item);
1835 ret = fun(frm, priv2, priv3, j++, UVCG_FRAME);
1845 * Count how many bytes are needed for an array of streaming descriptors.
1847 * @priv1: pointer to a header, format or frame
1848 * @priv2: inout parameter, accumulated size of the array
1849 * @priv3: inout parameter, accumulated number of the array elements
1850 * @n: unused, this function's prototype must match @fun in __uvcg_iter_strm_cls
1852 static int __uvcg_cnt_strm(void *priv1, void *priv2, void *priv3, int n,
1853 enum uvcg_strm_type type)
1855 size_t *size = priv2;
1856 size_t *count = priv3;
1860 struct uvcg_streaming_header *h = priv1;
1862 *size += sizeof(h->desc);
1864 *size += h->num_fmt * UVCG_STREAMING_CONTROL_SIZE;
1868 struct uvcg_format *fmt = priv1;
1870 if (fmt->type == UVCG_UNCOMPRESSED) {
1871 struct uvcg_uncompressed *u =
1872 container_of(fmt, struct uvcg_uncompressed,
1875 *size += sizeof(u->desc);
1876 } else if (fmt->type == UVCG_MJPEG) {
1877 struct uvcg_mjpeg *m =
1878 container_of(fmt, struct uvcg_mjpeg, fmt);
1880 *size += sizeof(m->desc);
1887 struct uvcg_frame *frm = priv1;
1888 int sz = sizeof(frm->dw_frame_interval);
1890 *size += sizeof(frm->frame);
1891 *size += frm->frame.b_frame_interval_type * sz;
1902 * Fill an array of streaming descriptors.
1904 * @priv1: pointer to a header, format or frame
1905 * @priv2: inout parameter, pointer into a block of memory
1906 * @priv3: inout parameter, pointer to a 2-dimensional array
1908 static int __uvcg_fill_strm(void *priv1, void *priv2, void *priv3, int n,
1909 enum uvcg_strm_type type)
1911 void **dest = priv2;
1912 struct uvc_descriptor_header ***array = priv3;
1920 struct uvc_input_header_descriptor *ihdr = *dest;
1921 struct uvcg_streaming_header *h = priv1;
1922 struct uvcg_format_ptr *f;
1924 memcpy(*dest, &h->desc, sizeof(h->desc));
1925 *dest += sizeof(h->desc);
1926 sz = UVCG_STREAMING_CONTROL_SIZE;
1927 list_for_each_entry(f, &h->formats, entry) {
1928 memcpy(*dest, f->fmt->bmaControls, sz);
1931 ihdr->bLength = sizeof(h->desc) + h->num_fmt * sz;
1932 ihdr->bNumFormats = h->num_fmt;
1936 struct uvcg_format *fmt = priv1;
1938 if (fmt->type == UVCG_UNCOMPRESSED) {
1939 struct uvc_format_uncompressed *unc = *dest;
1940 struct uvcg_uncompressed *u =
1941 container_of(fmt, struct uvcg_uncompressed,
1944 memcpy(*dest, &u->desc, sizeof(u->desc));
1945 *dest += sizeof(u->desc);
1946 unc->bNumFrameDescriptors = fmt->num_frames;
1947 unc->bFormatIndex = n + 1;
1948 } else if (fmt->type == UVCG_MJPEG) {
1949 struct uvc_format_mjpeg *mjp = *dest;
1950 struct uvcg_mjpeg *m =
1951 container_of(fmt, struct uvcg_mjpeg, fmt);
1953 memcpy(*dest, &m->desc, sizeof(m->desc));
1954 *dest += sizeof(m->desc);
1955 mjp->bNumFrameDescriptors = fmt->num_frames;
1956 mjp->bFormatIndex = n + 1;
1963 struct uvcg_frame *frm = priv1;
1964 struct uvc_descriptor_header *h = *dest;
1966 sz = sizeof(frm->frame);
1967 memcpy(*dest, &frm->frame, sz);
1969 sz = frm->frame.b_frame_interval_type *
1970 sizeof(*frm->dw_frame_interval);
1971 memcpy(*dest, frm->dw_frame_interval, sz);
1973 if (frm->fmt_type == UVCG_UNCOMPRESSED)
1974 h->bLength = UVC_DT_FRAME_UNCOMPRESSED_SIZE(
1975 frm->frame.b_frame_interval_type);
1976 else if (frm->fmt_type == UVCG_MJPEG)
1977 h->bLength = UVC_DT_FRAME_MJPEG_SIZE(
1978 frm->frame.b_frame_interval_type);
1986 static int uvcg_streaming_class_allow_link(struct config_item *src,
1987 struct config_item *target)
1989 struct config_item *streaming, *header;
1990 struct f_uvc_opts *opts;
1991 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1992 struct uvc_descriptor_header ***class_array, **cl_arr;
1993 struct uvcg_streaming_header *target_hdr;
1994 void *data, *data_save;
1995 size_t size = 0, count = 0;
1998 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2000 streaming = src->ci_parent->ci_parent;
2001 header = config_group_find_item(to_config_group(streaming), "header");
2002 if (!header || target->ci_parent != header)
2005 opts = to_f_uvc_opts(streaming->ci_parent);
2007 mutex_lock(&opts->lock);
2009 class_array = __uvcg_get_stream_class_arr(src, opts);
2010 if (!class_array || *class_array || opts->refcnt) {
2015 target_hdr = to_uvcg_streaming_header(target);
2016 ret = __uvcg_iter_strm_cls(target_hdr, &size, &count, __uvcg_cnt_strm);
2020 count += 2; /* color_matching, NULL */
2021 *class_array = kcalloc(count, sizeof(void *), GFP_KERNEL);
2022 if (!*class_array) {
2027 data = data_save = kzalloc(size, GFP_KERNEL);
2029 kfree(*class_array);
2030 *class_array = NULL;
2034 cl_arr = *class_array;
2035 ret = __uvcg_iter_strm_cls(target_hdr, &data, &cl_arr,
2038 kfree(*class_array);
2039 *class_array = NULL;
2041 * __uvcg_fill_strm() called from __uvcg_iter_stream_cls()
2042 * might have advanced the "data", so use a backup copy
2047 *cl_arr = (struct uvc_descriptor_header *)&opts->uvc_color_matching;
2049 ++target_hdr->linked;
2053 mutex_unlock(&opts->lock);
2055 config_item_put(header);
2056 mutex_unlock(su_mutex);
2060 static int uvcg_streaming_class_drop_link(struct config_item *src,
2061 struct config_item *target)
2063 struct config_item *streaming, *header;
2064 struct f_uvc_opts *opts;
2065 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
2066 struct uvc_descriptor_header ***class_array;
2067 struct uvcg_streaming_header *target_hdr;
2070 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2072 streaming = src->ci_parent->ci_parent;
2073 header = config_group_find_item(to_config_group(streaming), "header");
2074 if (!header || target->ci_parent != header)
2077 opts = to_f_uvc_opts(streaming->ci_parent);
2079 mutex_lock(&opts->lock);
2081 class_array = __uvcg_get_stream_class_arr(src, opts);
2082 if (!class_array || !*class_array)
2090 target_hdr = to_uvcg_streaming_header(target);
2091 --target_hdr->linked;
2092 kfree(**class_array);
2093 kfree(*class_array);
2094 *class_array = NULL;
2098 mutex_unlock(&opts->lock);
2100 config_item_put(header);
2101 mutex_unlock(su_mutex);
2105 static struct configfs_item_operations uvcg_streaming_class_item_ops = {
2106 .allow_link = uvcg_streaming_class_allow_link,
2107 .drop_link = uvcg_streaming_class_drop_link,
2110 static struct config_item_type uvcg_streaming_class_type = {
2111 .ct_item_ops = &uvcg_streaming_class_item_ops,
2112 .ct_owner = THIS_MODULE,
2115 /* streaming/class */
2116 static struct uvcg_streaming_class_grp {
2117 struct config_group group;
2118 } uvcg_streaming_class_grp;
2120 static struct config_item_type uvcg_streaming_class_grp_type = {
2121 .ct_owner = THIS_MODULE,
2125 static struct uvcg_streaming_grp {
2126 struct config_group group;
2127 } uvcg_streaming_grp;
2129 static struct config_item_type uvcg_streaming_grp_type = {
2130 .ct_owner = THIS_MODULE,
2133 static inline struct f_uvc_opts *to_f_uvc_opts(struct config_item *item)
2135 return container_of(to_config_group(item), struct f_uvc_opts,
2139 static void uvc_attr_release(struct config_item *item)
2141 struct f_uvc_opts *opts = to_f_uvc_opts(item);
2143 usb_put_function_instance(&opts->func_inst);
2146 static struct configfs_item_operations uvc_item_ops = {
2147 .release = uvc_attr_release,
2150 #define UVCG_OPTS_ATTR(cname, aname, conv, str2u, uxx, vnoc, limit) \
2151 static ssize_t f_uvc_opts_##cname##_show( \
2152 struct config_item *item, char *page) \
2154 struct f_uvc_opts *opts = to_f_uvc_opts(item); \
2157 mutex_lock(&opts->lock); \
2158 result = sprintf(page, "%d\n", conv(opts->cname)); \
2159 mutex_unlock(&opts->lock); \
2165 f_uvc_opts_##cname##_store(struct config_item *item, \
2166 const char *page, size_t len) \
2168 struct f_uvc_opts *opts = to_f_uvc_opts(item); \
2172 mutex_lock(&opts->lock); \
2173 if (opts->refcnt) { \
2178 ret = str2u(page, 0, &num); \
2182 if (num > limit) { \
2186 opts->cname = vnoc(num); \
2189 mutex_unlock(&opts->lock); \
2193 UVC_ATTR(f_uvc_opts_, cname, cname)
2195 #define identity_conv(x) (x)
2197 UVCG_OPTS_ATTR(streaming_interval, streaming_interval, identity_conv,
2198 kstrtou8, u8, identity_conv, 16);
2199 UVCG_OPTS_ATTR(streaming_maxpacket, streaming_maxpacket, le16_to_cpu,
2200 kstrtou16, u16, le16_to_cpu, 3072);
2201 UVCG_OPTS_ATTR(streaming_maxburst, streaming_maxburst, identity_conv,
2202 kstrtou8, u8, identity_conv, 15);
2204 #undef identity_conv
2206 #undef UVCG_OPTS_ATTR
2208 static struct configfs_attribute *uvc_attrs[] = {
2209 &f_uvc_opts_attr_streaming_interval,
2210 &f_uvc_opts_attr_streaming_maxpacket,
2211 &f_uvc_opts_attr_streaming_maxburst,
2215 static struct config_item_type uvc_func_type = {
2216 .ct_item_ops = &uvc_item_ops,
2217 .ct_attrs = uvc_attrs,
2218 .ct_owner = THIS_MODULE,
2221 int uvcg_attach_configfs(struct f_uvc_opts *opts)
2223 config_group_init_type_name(&uvcg_control_header_grp.group,
2225 &uvcg_control_header_grp_type);
2227 config_group_init_type_name(&uvcg_default_processing.group,
2228 "default", &uvcg_default_processing_type);
2229 config_group_init_type_name(&uvcg_processing_grp.group,
2230 "processing", &uvcg_processing_grp_type);
2231 configfs_add_default_group(&uvcg_default_processing.group,
2232 &uvcg_processing_grp.group);
2234 config_group_init_type_name(&uvcg_default_camera.group,
2235 "default", &uvcg_default_camera_type);
2236 config_group_init_type_name(&uvcg_camera_grp.group,
2237 "camera", &uvcg_camera_grp_type);
2238 configfs_add_default_group(&uvcg_default_camera.group,
2239 &uvcg_camera_grp.group);
2241 config_group_init_type_name(&uvcg_default_output.group,
2242 "default", &uvcg_default_output_type);
2243 config_group_init_type_name(&uvcg_output_grp.group,
2244 "output", &uvcg_output_grp_type);
2245 configfs_add_default_group(&uvcg_default_output.group,
2246 &uvcg_output_grp.group);
2248 config_group_init_type_name(&uvcg_terminal_grp.group,
2249 "terminal", &uvcg_terminal_grp_type);
2250 configfs_add_default_group(&uvcg_camera_grp.group,
2251 &uvcg_terminal_grp.group);
2252 configfs_add_default_group(&uvcg_output_grp.group,
2253 &uvcg_terminal_grp.group);
2255 config_group_init_type_name(&uvcg_control_class_fs.group,
2256 "fs", &uvcg_control_class_type);
2257 config_group_init_type_name(&uvcg_control_class_ss.group,
2258 "ss", &uvcg_control_class_type);
2259 config_group_init_type_name(&uvcg_control_class_grp.group,
2261 &uvcg_control_class_grp_type);
2262 configfs_add_default_group(&uvcg_control_class_fs.group,
2263 &uvcg_control_class_grp.group);
2264 configfs_add_default_group(&uvcg_control_class_ss.group,
2265 &uvcg_control_class_grp.group);
2267 config_group_init_type_name(&uvcg_control_grp.group,
2269 &uvcg_control_grp_type);
2270 configfs_add_default_group(&uvcg_control_header_grp.group,
2271 &uvcg_control_grp.group);
2272 configfs_add_default_group(&uvcg_processing_grp.group,
2273 &uvcg_control_grp.group);
2274 configfs_add_default_group(&uvcg_terminal_grp.group,
2275 &uvcg_control_grp.group);
2276 configfs_add_default_group(&uvcg_control_class_grp.group,
2277 &uvcg_control_grp.group);
2279 config_group_init_type_name(&uvcg_streaming_header_grp.group,
2281 &uvcg_streaming_header_grp_type);
2282 config_group_init_type_name(&uvcg_uncompressed_grp.group,
2284 &uvcg_uncompressed_grp_type);
2285 config_group_init_type_name(&uvcg_mjpeg_grp.group,
2287 &uvcg_mjpeg_grp_type);
2288 config_group_init_type_name(&uvcg_default_color_matching.group,
2290 &uvcg_default_color_matching_type);
2291 config_group_init_type_name(&uvcg_color_matching_grp.group,
2293 &uvcg_color_matching_grp_type);
2294 configfs_add_default_group(&uvcg_default_color_matching.group,
2295 &uvcg_color_matching_grp.group);
2297 config_group_init_type_name(&uvcg_streaming_class_fs.group,
2298 "fs", &uvcg_streaming_class_type);
2299 config_group_init_type_name(&uvcg_streaming_class_hs.group,
2300 "hs", &uvcg_streaming_class_type);
2301 config_group_init_type_name(&uvcg_streaming_class_ss.group,
2302 "ss", &uvcg_streaming_class_type);
2303 config_group_init_type_name(&uvcg_streaming_class_grp.group,
2304 "class", &uvcg_streaming_class_grp_type);
2305 configfs_add_default_group(&uvcg_streaming_class_fs.group,
2306 &uvcg_streaming_class_grp.group);
2307 configfs_add_default_group(&uvcg_streaming_class_hs.group,
2308 &uvcg_streaming_class_grp.group);
2309 configfs_add_default_group(&uvcg_streaming_class_ss.group,
2310 &uvcg_streaming_class_grp.group);
2312 config_group_init_type_name(&uvcg_streaming_grp.group,
2313 "streaming", &uvcg_streaming_grp_type);
2314 configfs_add_default_group(&uvcg_streaming_header_grp.group,
2315 &uvcg_streaming_grp.group);
2316 configfs_add_default_group(&uvcg_uncompressed_grp.group,
2317 &uvcg_streaming_grp.group);
2318 configfs_add_default_group(&uvcg_mjpeg_grp.group,
2319 &uvcg_streaming_grp.group);
2320 configfs_add_default_group(&uvcg_color_matching_grp.group,
2321 &uvcg_streaming_grp.group);
2322 configfs_add_default_group(&uvcg_streaming_class_grp.group,
2323 &uvcg_streaming_grp.group);
2325 config_group_init_type_name(&opts->func_inst.group,
2328 configfs_add_default_group(&uvcg_control_grp.group,
2329 &opts->func_inst.group);
2330 configfs_add_default_group(&uvcg_streaming_grp.group,
2331 &opts->func_inst.group);