?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / usb / gadget / function / uvc_configfs.c
blobc9b8cc4aae5a0336d9d163ceb861a4a3c414cfad
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * uvc_configfs.c
4 *
5 * Configfs support for the uvc function.
6 *
7 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
8 * http://www.samsung.com
9 *
10 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
11 */
12 #include "u_uvc.h"
13 #include "uvc_configfs.h"
14
15 #define UVCG_STREAMING_CONTROL_SIZE 1
16
17 #define UVC_ATTR(prefix, cname, aname) \
18 static struct configfs_attribute prefix##attr_##cname = { \
19 .ca_name = __stringify(aname), \
20 .ca_mode = S_IRUGO | S_IWUGO, \
21 .ca_owner = THIS_MODULE, \
22 .show = prefix##cname##_show, \
23 .store = prefix##cname##_store, \
24 }
25
26 #define UVC_ATTR_RO(prefix, cname, aname) \
27 static struct configfs_attribute prefix##attr_##cname = { \
28 .ca_name = __stringify(aname), \
29 .ca_mode = S_IRUGO, \
30 .ca_owner = THIS_MODULE, \
31 .show = prefix##cname##_show, \
32 }
33
34 static inline struct f_uvc_opts *to_f_uvc_opts(struct config_item *item);
35
36 /* control/header/<NAME> */
37 DECLARE_UVC_HEADER_DESCRIPTOR(1);
38
39 struct uvcg_control_header {
40 struct config_item item;
41 struct UVC_HEADER_DESCRIPTOR(1) desc;
42 unsigned linked;
43 };
44
45 static struct uvcg_control_header *to_uvcg_control_header(struct config_item *item)
46 {
47 return container_of(item, struct uvcg_control_header, item);
48 }
49
50 #define UVCG_CTRL_HDR_ATTR(cname, aname, conv, str2u, uxx, vnoc, limit) \
51 static ssize_t uvcg_control_header_##cname##_show( \
52 struct config_item *item, char *page) \
53 { \
54 struct uvcg_control_header *ch = to_uvcg_control_header(item); \
55 struct f_uvc_opts *opts; \
56 struct config_item *opts_item; \
57 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
58 int result; \
59 \
60 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
61 \
62 opts_item = ch->item.ci_parent->ci_parent->ci_parent; \
63 opts = to_f_uvc_opts(opts_item); \
64 \
65 mutex_lock(&opts->lock); \
66 result = sprintf(page, "%d\n", conv(ch->desc.aname)); \
67 mutex_unlock(&opts->lock); \
68 \
69 mutex_unlock(su_mutex); \
70 return result; \
71 } \
72 \
73 static ssize_t \
74 uvcg_control_header_##cname##_store(struct config_item *item, \
75 const char *page, size_t len) \
76 { \
77 struct uvcg_control_header *ch = to_uvcg_control_header(item); \
78 struct f_uvc_opts *opts; \
79 struct config_item *opts_item; \
80 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
81 int ret; \
82 uxx num; \
83 \
84 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
85 \
86 opts_item = ch->item.ci_parent->ci_parent->ci_parent; \
87 opts = to_f_uvc_opts(opts_item); \
88 \
89 mutex_lock(&opts->lock); \
90 if (ch->linked || opts->refcnt) { \
91 ret = -EBUSY; \
92 goto end; \
93 } \
94 \
95 ret = str2u(page, 0, &num); \
96 if (ret) \
97 goto end; \
98 \
99 if (num > limit) { \
100 ret = -EINVAL; \
101 goto end; \
102 } \
103 ch->desc.aname = vnoc(num); \
104 ret = len; \
105 end: \
106 mutex_unlock(&opts->lock); \
107 mutex_unlock(su_mutex); \
108 return ret; \
109 } \
110 \
111 UVC_ATTR(uvcg_control_header_, cname, aname)
112
113 UVCG_CTRL_HDR_ATTR(bcd_uvc, bcdUVC, le16_to_cpu, kstrtou16, u16, cpu_to_le16,
114 0xffff);
115
116 UVCG_CTRL_HDR_ATTR(dw_clock_frequency, dwClockFrequency, le32_to_cpu, kstrtou32,
117 u32, cpu_to_le32, 0x7fffffff);
118
119 #undef UVCG_CTRL_HDR_ATTR
120
121 static struct configfs_attribute *uvcg_control_header_attrs[] = {
122 &uvcg_control_header_attr_bcd_uvc,
123 &uvcg_control_header_attr_dw_clock_frequency,
124 NULL,
125 };
126
127 static const struct config_item_type uvcg_control_header_type = {
128 .ct_attrs = uvcg_control_header_attrs,
129 .ct_owner = THIS_MODULE,
130 };
131
132 static struct config_item *uvcg_control_header_make(struct config_group *group,
133 const char *name)
134 {
135 struct uvcg_control_header *h;
136
137 h = kzalloc(sizeof(*h), GFP_KERNEL);
138 if (!h)
139 return ERR_PTR(-ENOMEM);
140
141 h->desc.bLength = UVC_DT_HEADER_SIZE(1);
142 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
143 h->desc.bDescriptorSubType = UVC_VC_HEADER;
144 h->desc.bcdUVC = cpu_to_le16(0x0100);
145 h->desc.dwClockFrequency = cpu_to_le32(48000000);
146
147 config_item_init_type_name(&h->item, name, &uvcg_control_header_type);
148
149 return &h->item;
150 }
151
152 static void uvcg_control_header_drop(struct config_group *group,
153 struct config_item *item)
154 {
155 struct uvcg_control_header *h = to_uvcg_control_header(item);
156
157 kfree(h);
158 }
159
160 /* control/header */
161 static struct uvcg_control_header_grp {
162 struct config_group group;
163 } uvcg_control_header_grp;
164
165 static struct configfs_group_operations uvcg_control_header_grp_ops = {
166 .make_item = uvcg_control_header_make,
167 .drop_item = uvcg_control_header_drop,
168 };
169
170 static const struct config_item_type uvcg_control_header_grp_type = {
171 .ct_group_ops = &uvcg_control_header_grp_ops,
172 .ct_owner = THIS_MODULE,
173 };
174
175 /* control/processing/default */
176 static struct uvcg_default_processing {
177 struct config_group group;
178 } uvcg_default_processing;
179
180 static inline struct uvcg_default_processing
181 *to_uvcg_default_processing(struct config_item *item)
182 {
183 return container_of(to_config_group(item),
184 struct uvcg_default_processing, group);
185 }
186
187 #define UVCG_DEFAULT_PROCESSING_ATTR(cname, aname, conv) \
188 static ssize_t uvcg_default_processing_##cname##_show( \
189 struct config_item *item, char *page) \
190 { \
191 struct uvcg_default_processing *dp = to_uvcg_default_processing(item); \
192 struct f_uvc_opts *opts; \
193 struct config_item *opts_item; \
194 struct mutex *su_mutex = &dp->group.cg_subsys->su_mutex; \
195 struct uvc_processing_unit_descriptor *pd; \
196 int result; \
197 \
198 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
199 \
200 opts_item = dp->group.cg_item.ci_parent->ci_parent->ci_parent; \
201 opts = to_f_uvc_opts(opts_item); \
202 pd = &opts->uvc_processing; \
203 \
204 mutex_lock(&opts->lock); \
205 result = sprintf(page, "%d\n", conv(pd->aname)); \
206 mutex_unlock(&opts->lock); \
207 \
208 mutex_unlock(su_mutex); \
209 return result; \
210 } \
211 \
212 UVC_ATTR_RO(uvcg_default_processing_, cname, aname)
213
214 #define identity_conv(x) (x)
215
216 UVCG_DEFAULT_PROCESSING_ATTR(b_unit_id, bUnitID, identity_conv);
217 UVCG_DEFAULT_PROCESSING_ATTR(b_source_id, bSourceID, identity_conv);
218 UVCG_DEFAULT_PROCESSING_ATTR(w_max_multiplier, wMaxMultiplier, le16_to_cpu);
219 UVCG_DEFAULT_PROCESSING_ATTR(i_processing, iProcessing, identity_conv);
220
221 #undef identity_conv
222
223 #undef UVCG_DEFAULT_PROCESSING_ATTR
224
225 static ssize_t uvcg_default_processing_bm_controls_show(
226 struct config_item *item, char *page)
227 {
228 struct uvcg_default_processing *dp = to_uvcg_default_processing(item);
229 struct f_uvc_opts *opts;
230 struct config_item *opts_item;
231 struct mutex *su_mutex = &dp->group.cg_subsys->su_mutex;
232 struct uvc_processing_unit_descriptor *pd;
233 int result, i;
234 char *pg = page;
235
236 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
237
238 opts_item = dp->group.cg_item.ci_parent->ci_parent->ci_parent;
239 opts = to_f_uvc_opts(opts_item);
240 pd = &opts->uvc_processing;
241
242 mutex_lock(&opts->lock);
243 for (result = 0, i = 0; i < pd->bControlSize; ++i) {
244 result += sprintf(pg, "%d\n", pd->bmControls[i]);
245 pg = page + result;
246 }
247 mutex_unlock(&opts->lock);
248
249 mutex_unlock(su_mutex);
250
251 return result;
252 }
253
254 UVC_ATTR_RO(uvcg_default_processing_, bm_controls, bmControls);
255
256 static struct configfs_attribute *uvcg_default_processing_attrs[] = {
257 &uvcg_default_processing_attr_b_unit_id,
258 &uvcg_default_processing_attr_b_source_id,
259 &uvcg_default_processing_attr_w_max_multiplier,
260 &uvcg_default_processing_attr_bm_controls,
261 &uvcg_default_processing_attr_i_processing,
262 NULL,
263 };
264
265 static const struct config_item_type uvcg_default_processing_type = {
266 .ct_attrs = uvcg_default_processing_attrs,
267 .ct_owner = THIS_MODULE,
268 };
269
270 /* struct uvcg_processing {}; */
271
272 /* control/processing */
273 static struct uvcg_processing_grp {
274 struct config_group group;
275 } uvcg_processing_grp;
276
277 static const struct config_item_type uvcg_processing_grp_type = {
278 .ct_owner = THIS_MODULE,
279 };
280
281 /* control/terminal/camera/default */
282 static struct uvcg_default_camera {
283 struct config_group group;
284 } uvcg_default_camera;
285
286 static inline struct uvcg_default_camera
287 *to_uvcg_default_camera(struct config_item *item)
288 {
289 return container_of(to_config_group(item),
290 struct uvcg_default_camera, group);
291 }
292
293 #define UVCG_DEFAULT_CAMERA_ATTR(cname, aname, conv) \
294 static ssize_t uvcg_default_camera_##cname##_show( \
295 struct config_item *item, char *page) \
296 { \
297 struct uvcg_default_camera *dc = to_uvcg_default_camera(item); \
298 struct f_uvc_opts *opts; \
299 struct config_item *opts_item; \
300 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex; \
301 struct uvc_camera_terminal_descriptor *cd; \
302 int result; \
303 \
304 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
305 \
306 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent-> \
307 ci_parent; \
308 opts = to_f_uvc_opts(opts_item); \
309 cd = &opts->uvc_camera_terminal; \
310 \
311 mutex_lock(&opts->lock); \
312 result = sprintf(page, "%d\n", conv(cd->aname)); \
313 mutex_unlock(&opts->lock); \
314 \
315 mutex_unlock(su_mutex); \
316 \
317 return result; \
318 } \
319 \
320 UVC_ATTR_RO(uvcg_default_camera_, cname, aname)
321
322 #define identity_conv(x) (x)
323
324 UVCG_DEFAULT_CAMERA_ATTR(b_terminal_id, bTerminalID, identity_conv);
325 UVCG_DEFAULT_CAMERA_ATTR(w_terminal_type, wTerminalType, le16_to_cpu);
326 UVCG_DEFAULT_CAMERA_ATTR(b_assoc_terminal, bAssocTerminal, identity_conv);
327 UVCG_DEFAULT_CAMERA_ATTR(i_terminal, iTerminal, identity_conv);
328 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_min, wObjectiveFocalLengthMin,
329 le16_to_cpu);
330 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_max, wObjectiveFocalLengthMax,
331 le16_to_cpu);
332 UVCG_DEFAULT_CAMERA_ATTR(w_ocular_focal_length, wOcularFocalLength,
333 le16_to_cpu);
334
335 #undef identity_conv
336
337 #undef UVCG_DEFAULT_CAMERA_ATTR
338
339 static ssize_t uvcg_default_camera_bm_controls_show(
340 struct config_item *item, char *page)
341 {
342 struct uvcg_default_camera *dc = to_uvcg_default_camera(item);
343 struct f_uvc_opts *opts;
344 struct config_item *opts_item;
345 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex;
346 struct uvc_camera_terminal_descriptor *cd;
347 int result, i;
348 char *pg = page;
349
350 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
351
352 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent->
353 ci_parent;
354 opts = to_f_uvc_opts(opts_item);
355 cd = &opts->uvc_camera_terminal;
356
357 mutex_lock(&opts->lock);
358 for (result = 0, i = 0; i < cd->bControlSize; ++i) {
359 result += sprintf(pg, "%d\n", cd->bmControls[i]);
360 pg = page + result;
361 }
362 mutex_unlock(&opts->lock);
363
364 mutex_unlock(su_mutex);
365 return result;
366 }
367
368 UVC_ATTR_RO(uvcg_default_camera_, bm_controls, bmControls);
369
370 static struct configfs_attribute *uvcg_default_camera_attrs[] = {
371 &uvcg_default_camera_attr_b_terminal_id,
372 &uvcg_default_camera_attr_w_terminal_type,
373 &uvcg_default_camera_attr_b_assoc_terminal,
374 &uvcg_default_camera_attr_i_terminal,
375 &uvcg_default_camera_attr_w_objective_focal_length_min,
376 &uvcg_default_camera_attr_w_objective_focal_length_max,
377 &uvcg_default_camera_attr_w_ocular_focal_length,
378 &uvcg_default_camera_attr_bm_controls,
379 NULL,
380 };
381
382 static const struct config_item_type uvcg_default_camera_type = {
383 .ct_attrs = uvcg_default_camera_attrs,
384 .ct_owner = THIS_MODULE,
385 };
386
387 /* struct uvcg_camera {}; */
388
389 /* control/terminal/camera */
390 static struct uvcg_camera_grp {
391 struct config_group group;
392 } uvcg_camera_grp;
393
394 static const struct config_item_type uvcg_camera_grp_type = {
395 .ct_owner = THIS_MODULE,
396 };
397
398 /* control/terminal/output/default */
399 static struct uvcg_default_output {
400 struct config_group group;
401 } uvcg_default_output;
402
403 static inline struct uvcg_default_output
404 *to_uvcg_default_output(struct config_item *item)
405 {
406 return container_of(to_config_group(item),
407 struct uvcg_default_output, group);
408 }
409
410 #define UVCG_DEFAULT_OUTPUT_ATTR(cname, aname, conv) \
411 static ssize_t uvcg_default_output_##cname##_show( \
412 struct config_item *item, char *page) \
413 { \
414 struct uvcg_default_output *dout = to_uvcg_default_output(item); \
415 struct f_uvc_opts *opts; \
416 struct config_item *opts_item; \
417 struct mutex *su_mutex = &dout->group.cg_subsys->su_mutex; \
418 struct uvc_output_terminal_descriptor *cd; \
419 int result; \
420 \
421 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
422 \
423 opts_item = dout->group.cg_item.ci_parent->ci_parent-> \
424 ci_parent->ci_parent; \
425 opts = to_f_uvc_opts(opts_item); \
426 cd = &opts->uvc_output_terminal; \
427 \
428 mutex_lock(&opts->lock); \
429 result = sprintf(page, "%d\n", conv(cd->aname)); \
430 mutex_unlock(&opts->lock); \
431 \
432 mutex_unlock(su_mutex); \
433 \
434 return result; \
435 } \
436 \
437 UVC_ATTR_RO(uvcg_default_output_, cname, aname)
438
439 #define identity_conv(x) (x)
440
441 UVCG_DEFAULT_OUTPUT_ATTR(b_terminal_id, bTerminalID, identity_conv);
442 UVCG_DEFAULT_OUTPUT_ATTR(w_terminal_type, wTerminalType, le16_to_cpu);
443 UVCG_DEFAULT_OUTPUT_ATTR(b_assoc_terminal, bAssocTerminal, identity_conv);
444 UVCG_DEFAULT_OUTPUT_ATTR(b_source_id, bSourceID, identity_conv);
445 UVCG_DEFAULT_OUTPUT_ATTR(i_terminal, iTerminal, identity_conv);
446
447 #undef identity_conv
448
449 #undef UVCG_DEFAULT_OUTPUT_ATTR
450
451 static struct configfs_attribute *uvcg_default_output_attrs[] = {
452 &uvcg_default_output_attr_b_terminal_id,
453 &uvcg_default_output_attr_w_terminal_type,
454 &uvcg_default_output_attr_b_assoc_terminal,
455 &uvcg_default_output_attr_b_source_id,
456 &uvcg_default_output_attr_i_terminal,
457 NULL,
458 };
459
460 static const struct config_item_type uvcg_default_output_type = {
461 .ct_attrs = uvcg_default_output_attrs,
462 .ct_owner = THIS_MODULE,
463 };
464
465 /* struct uvcg_output {}; */
466
467 /* control/terminal/output */
468 static struct uvcg_output_grp {
469 struct config_group group;
470 } uvcg_output_grp;
471
472 static const struct config_item_type uvcg_output_grp_type = {
473 .ct_owner = THIS_MODULE,
474 };
475
476 /* control/terminal */
477 static struct uvcg_terminal_grp {
478 struct config_group group;
479 } uvcg_terminal_grp;
480
481 static const struct config_item_type uvcg_terminal_grp_type = {
482 .ct_owner = THIS_MODULE,
483 };
484
485 /* control/class/{fs} */
486 static struct uvcg_control_class {
487 struct config_group group;
488 } uvcg_control_class_fs, uvcg_control_class_ss;
489
490
491 static inline struct uvc_descriptor_header
492 **uvcg_get_ctl_class_arr(struct config_item *i, struct f_uvc_opts *o)
493 {
494 struct uvcg_control_class *cl = container_of(to_config_group(i),
495 struct uvcg_control_class, group);
496
497 if (cl == &uvcg_control_class_fs)
498 return o->uvc_fs_control_cls;
499
500 if (cl == &uvcg_control_class_ss)
501 return o->uvc_ss_control_cls;
502
503 return NULL;
504 }
505
506 static int uvcg_control_class_allow_link(struct config_item *src,
507 struct config_item *target)
508 {
509 struct config_item *control, *header;
510 struct f_uvc_opts *opts;
511 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
512 struct uvc_descriptor_header **class_array;
513 struct uvcg_control_header *target_hdr;
514 int ret = -EINVAL;
515
516 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
517
518 control = src->ci_parent->ci_parent;
519 header = config_group_find_item(to_config_group(control), "header");
520 if (!header || target->ci_parent != header)
521 goto out;
522
523 opts = to_f_uvc_opts(control->ci_parent);
524
525 mutex_lock(&opts->lock);
526
527 class_array = uvcg_get_ctl_class_arr(src, opts);
528 if (!class_array)
529 goto unlock;
530 if (opts->refcnt || class_array[0]) {
531 ret = -EBUSY;
532 goto unlock;
533 }
534
535 target_hdr = to_uvcg_control_header(target);
536 ++target_hdr->linked;
537 class_array[0] = (struct uvc_descriptor_header *)&target_hdr->desc;
538 ret = 0;
539
540 unlock:
541 mutex_unlock(&opts->lock);
542 out:
543 mutex_unlock(su_mutex);
544 return ret;
545 }
546
547 static void uvcg_control_class_drop_link(struct config_item *src,
548 struct config_item *target)
549 {
550 struct config_item *control, *header;
551 struct f_uvc_opts *opts;
552 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
553 struct uvc_descriptor_header **class_array;
554 struct uvcg_control_header *target_hdr;
555
556 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
557
558 control = src->ci_parent->ci_parent;
559 header = config_group_find_item(to_config_group(control), "header");
560 if (!header || target->ci_parent != header)
561 goto out;
562
563 opts = to_f_uvc_opts(control->ci_parent);
564
565 mutex_lock(&opts->lock);
566
567 class_array = uvcg_get_ctl_class_arr(src, opts);
568 if (!class_array || opts->refcnt)
569 goto unlock;
570
571 target_hdr = to_uvcg_control_header(target);
572 --target_hdr->linked;
573 class_array[0] = NULL;
574
575 unlock:
576 mutex_unlock(&opts->lock);
577 out:
578 mutex_unlock(su_mutex);
579 }
580
581 static struct configfs_item_operations uvcg_control_class_item_ops = {
582 .allow_link = uvcg_control_class_allow_link,
583 .drop_link = uvcg_control_class_drop_link,
584 };
585
586 static const struct config_item_type uvcg_control_class_type = {
587 .ct_item_ops = &uvcg_control_class_item_ops,
588 .ct_owner = THIS_MODULE,
589 };
590
591 /* control/class */
592 static struct uvcg_control_class_grp {
593 struct config_group group;
594 } uvcg_control_class_grp;
595
596 static const struct config_item_type uvcg_control_class_grp_type = {
597 .ct_owner = THIS_MODULE,
598 };
599
600 /* control */
601 static struct uvcg_control_grp {
602 struct config_group group;
603 } uvcg_control_grp;
604
605 static const struct config_item_type uvcg_control_grp_type = {
606 .ct_owner = THIS_MODULE,
607 };
608
609 /* streaming/uncompressed */
610 static struct uvcg_uncompressed_grp {
611 struct config_group group;
612 } uvcg_uncompressed_grp;
613
614 /* streaming/mjpeg */
615 static struct uvcg_mjpeg_grp {
616 struct config_group group;
617 } uvcg_mjpeg_grp;
618
619 static struct config_item *fmt_parent[] = {
620 &uvcg_uncompressed_grp.group.cg_item,
621 &uvcg_mjpeg_grp.group.cg_item,
622 };
623
624 enum uvcg_format_type {
625 UVCG_UNCOMPRESSED = 0,
626 UVCG_MJPEG,
627 };
628
629 struct uvcg_format {
630 struct config_group group;
631 enum uvcg_format_type type;
632 unsigned linked;
633 unsigned num_frames;
634 __u8 bmaControls[UVCG_STREAMING_CONTROL_SIZE];
635 };
636
637 static struct uvcg_format *to_uvcg_format(struct config_item *item)
638 {
639 return container_of(to_config_group(item), struct uvcg_format, group);
640 }
641
642 static ssize_t uvcg_format_bma_controls_show(struct uvcg_format *f, char *page)
643 {
644 struct f_uvc_opts *opts;
645 struct config_item *opts_item;
646 struct mutex *su_mutex = &f->group.cg_subsys->su_mutex;
647 int result, i;
648 char *pg = page;
649
650 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
651
652 opts_item = f->group.cg_item.ci_parent->ci_parent->ci_parent;
653 opts = to_f_uvc_opts(opts_item);
654
655 mutex_lock(&opts->lock);
656 result = sprintf(pg, "0x");
657 pg += result;
658 for (i = 0; i < UVCG_STREAMING_CONTROL_SIZE; ++i) {
659 result += sprintf(pg, "%x\n", f->bmaControls[i]);
660 pg = page + result;
661 }
662 mutex_unlock(&opts->lock);
663
664 mutex_unlock(su_mutex);
665 return result;
666 }
667
668 static ssize_t uvcg_format_bma_controls_store(struct uvcg_format *ch,
669 const char *page, size_t len)
670 {
671 struct f_uvc_opts *opts;
672 struct config_item *opts_item;
673 struct mutex *su_mutex = &ch->group.cg_subsys->su_mutex;
674 int ret = -EINVAL;
675
676 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
677
678 opts_item = ch->group.cg_item.ci_parent->ci_parent->ci_parent;
679 opts = to_f_uvc_opts(opts_item);
680
681 mutex_lock(&opts->lock);
682 if (ch->linked || opts->refcnt) {
683 ret = -EBUSY;
684 goto end;
685 }
686
687 if (len < 4 || *page != '0' ||
688 (*(page + 1) != 'x' && *(page + 1) != 'X'))
689 goto end;
690 ret = hex2bin(ch->bmaControls, page + 2, 1);
691 if (ret < 0)
692 goto end;
693 ret = len;
694 end:
695 mutex_unlock(&opts->lock);
696 mutex_unlock(su_mutex);
697 return ret;
698 }
699
700 struct uvcg_format_ptr {
701 struct uvcg_format *fmt;
702 struct list_head entry;
703 };
704
705 /* streaming/header/<NAME> */
706 struct uvcg_streaming_header {
707 struct config_item item;
708 struct uvc_input_header_descriptor desc;
709 unsigned linked;
710 struct list_head formats;
711 unsigned num_fmt;
712 };
713
714 static struct uvcg_streaming_header *to_uvcg_streaming_header(struct config_item *item)
715 {
716 return container_of(item, struct uvcg_streaming_header, item);
717 }
718
719 static int uvcg_streaming_header_allow_link(struct config_item *src,
720 struct config_item *target)
721 {
722 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
723 struct config_item *opts_item;
724 struct f_uvc_opts *opts;
725 struct uvcg_streaming_header *src_hdr;
726 struct uvcg_format *target_fmt = NULL;
727 struct uvcg_format_ptr *format_ptr;
728 int i, ret = -EINVAL;
729
730 src_hdr = to_uvcg_streaming_header(src);
731 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
732
733 opts_item = src->ci_parent->ci_parent->ci_parent;
734 opts = to_f_uvc_opts(opts_item);
735
736 mutex_lock(&opts->lock);
737
738 if (src_hdr->linked) {
739 ret = -EBUSY;
740 goto out;
741 }
742
743 for (i = 0; i < ARRAY_SIZE(fmt_parent); ++i)
744 if (target->ci_parent == fmt_parent[i])
745 break;
746 if (i == ARRAY_SIZE(fmt_parent))
747 goto out;
748
749 target_fmt = container_of(to_config_group(target), struct uvcg_format,
750 group);
751 if (!target_fmt)
752 goto out;
753
754 format_ptr = kzalloc(sizeof(*format_ptr), GFP_KERNEL);
755 if (!format_ptr) {
756 ret = -ENOMEM;
757 goto out;
758 }
759 ret = 0;
760 format_ptr->fmt = target_fmt;
761 list_add_tail(&format_ptr->entry, &src_hdr->formats);
762 ++src_hdr->num_fmt;
763
764 out:
765 mutex_unlock(&opts->lock);
766 mutex_unlock(su_mutex);
767 return ret;
768 }
769
770 static void uvcg_streaming_header_drop_link(struct config_item *src,
771 struct config_item *target)
772 {
773 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
774 struct config_item *opts_item;
775 struct f_uvc_opts *opts;
776 struct uvcg_streaming_header *src_hdr;
777 struct uvcg_format *target_fmt = NULL;
778 struct uvcg_format_ptr *format_ptr, *tmp;
779
780 src_hdr = to_uvcg_streaming_header(src);
781 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
782
783 opts_item = src->ci_parent->ci_parent->ci_parent;
784 opts = to_f_uvc_opts(opts_item);
785
786 mutex_lock(&opts->lock);
787 target_fmt = container_of(to_config_group(target), struct uvcg_format,
788 group);
789 if (!target_fmt)
790 goto out;
791
792 list_for_each_entry_safe(format_ptr, tmp, &src_hdr->formats, entry)
793 if (format_ptr->fmt == target_fmt) {
794 list_del(&format_ptr->entry);
795 kfree(format_ptr);
796 --src_hdr->num_fmt;
797 break;
798 }
799
800 out:
801 mutex_unlock(&opts->lock);
802 mutex_unlock(su_mutex);
803 }
804
805 static struct configfs_item_operations uvcg_streaming_header_item_ops = {
806 .allow_link = uvcg_streaming_header_allow_link,
807 .drop_link = uvcg_streaming_header_drop_link,
808 };
809
810 #define UVCG_STREAMING_HEADER_ATTR(cname, aname, conv) \
811 static ssize_t uvcg_streaming_header_##cname##_show( \
812 struct config_item *item, char *page) \
813 { \
814 struct uvcg_streaming_header *sh = to_uvcg_streaming_header(item); \
815 struct f_uvc_opts *opts; \
816 struct config_item *opts_item; \
817 struct mutex *su_mutex = &sh->item.ci_group->cg_subsys->su_mutex;\
818 int result; \
819 \
820 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
821 \
822 opts_item = sh->item.ci_parent->ci_parent->ci_parent; \
823 opts = to_f_uvc_opts(opts_item); \
824 \
825 mutex_lock(&opts->lock); \
826 result = sprintf(page, "%d\n", conv(sh->desc.aname)); \
827 mutex_unlock(&opts->lock); \
828 \
829 mutex_unlock(su_mutex); \
830 return result; \
831 } \
832 \
833 UVC_ATTR_RO(uvcg_streaming_header_, cname, aname)
834
835 #define identity_conv(x) (x)
836
837 UVCG_STREAMING_HEADER_ATTR(bm_info, bmInfo, identity_conv);
838 UVCG_STREAMING_HEADER_ATTR(b_terminal_link, bTerminalLink, identity_conv);
839 UVCG_STREAMING_HEADER_ATTR(b_still_capture_method, bStillCaptureMethod,
840 identity_conv);
841 UVCG_STREAMING_HEADER_ATTR(b_trigger_support, bTriggerSupport, identity_conv);
842 UVCG_STREAMING_HEADER_ATTR(b_trigger_usage, bTriggerUsage, identity_conv);
843
844 #undef identity_conv
845
846 #undef UVCG_STREAMING_HEADER_ATTR
847
848 static struct configfs_attribute *uvcg_streaming_header_attrs[] = {
849 &uvcg_streaming_header_attr_bm_info,
850 &uvcg_streaming_header_attr_b_terminal_link,
851 &uvcg_streaming_header_attr_b_still_capture_method,
852 &uvcg_streaming_header_attr_b_trigger_support,
853 &uvcg_streaming_header_attr_b_trigger_usage,
854 NULL,
855 };
856
857 static const struct config_item_type uvcg_streaming_header_type = {
858 .ct_item_ops = &uvcg_streaming_header_item_ops,
859 .ct_attrs = uvcg_streaming_header_attrs,
860 .ct_owner = THIS_MODULE,
861 };
862
863 static struct config_item
864 *uvcg_streaming_header_make(struct config_group *group, const char *name)
865 {
866 struct uvcg_streaming_header *h;
867
868 h = kzalloc(sizeof(*h), GFP_KERNEL);
869 if (!h)
870 return ERR_PTR(-ENOMEM);
871
872 INIT_LIST_HEAD(&h->formats);
873 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
874 h->desc.bDescriptorSubType = UVC_VS_INPUT_HEADER;
875 h->desc.bTerminalLink = 3;
876 h->desc.bControlSize = UVCG_STREAMING_CONTROL_SIZE;
877
878 config_item_init_type_name(&h->item, name, &uvcg_streaming_header_type);
879
880 return &h->item;
881 }
882
883 static void uvcg_streaming_header_drop(struct config_group *group,
884 struct config_item *item)
885 {
886 struct uvcg_streaming_header *h = to_uvcg_streaming_header(item);
887
888 kfree(h);
889 }
890
891 /* streaming/header */
892 static struct uvcg_streaming_header_grp {
893 struct config_group group;
894 } uvcg_streaming_header_grp;
895
896 static struct configfs_group_operations uvcg_streaming_header_grp_ops = {
897 .make_item = uvcg_streaming_header_make,
898 .drop_item = uvcg_streaming_header_drop,
899 };
900
901 static const struct config_item_type uvcg_streaming_header_grp_type = {
902 .ct_group_ops = &uvcg_streaming_header_grp_ops,
903 .ct_owner = THIS_MODULE,
904 };
905
906 /* streaming/<mode>/<format>/<NAME> */
907 struct uvcg_frame {
908 struct {
909 u8 b_length;
910 u8 b_descriptor_type;
911 u8 b_descriptor_subtype;
912 u8 b_frame_index;
913 u8 bm_capabilities;
914 u16 w_width;
915 u16 w_height;
916 u32 dw_min_bit_rate;
917 u32 dw_max_bit_rate;
918 u32 dw_max_video_frame_buffer_size;
919 u32 dw_default_frame_interval;
920 u8 b_frame_interval_type;
921 } __attribute__((packed)) frame;
922 u32 *dw_frame_interval;
923 enum uvcg_format_type fmt_type;
924 struct config_item item;
925 };
926
927 static struct uvcg_frame *to_uvcg_frame(struct config_item *item)
928 {
929 return container_of(item, struct uvcg_frame, item);
930 }
931
932 #define UVCG_FRAME_ATTR(cname, aname, to_cpu_endian, to_little_endian, bits) \
933 static ssize_t uvcg_frame_##cname##_show(struct config_item *item, char *page)\
934 { \
935 struct uvcg_frame *f = to_uvcg_frame(item); \
936 struct f_uvc_opts *opts; \
937 struct config_item *opts_item; \
938 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
939 int result; \
940 \
941 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
942 \
943 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
944 opts = to_f_uvc_opts(opts_item); \
945 \
946 mutex_lock(&opts->lock); \
947 result = sprintf(page, "%d\n", to_cpu_endian(f->frame.cname)); \
948 mutex_unlock(&opts->lock); \
949 \
950 mutex_unlock(su_mutex); \
951 return result; \
952 } \
953 \
954 static ssize_t uvcg_frame_##cname##_store(struct config_item *item, \
955 const char *page, size_t len)\
956 { \
957 struct uvcg_frame *f = to_uvcg_frame(item); \
958 struct f_uvc_opts *opts; \
959 struct config_item *opts_item; \
960 struct uvcg_format *fmt; \
961 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
962 int ret; \
963 u##bits num; \
964 \
965 ret = kstrtou##bits(page, 0, &num); \
966 if (ret) \
967 return ret; \
968 \
969 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
970 \
971 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
972 opts = to_f_uvc_opts(opts_item); \
973 fmt = to_uvcg_format(f->item.ci_parent); \
974 \
975 mutex_lock(&opts->lock); \
976 if (fmt->linked || opts->refcnt) { \
977 ret = -EBUSY; \
978 goto end; \
979 } \
980 \
981 f->frame.cname = to_little_endian(num); \
982 ret = len; \
983 end: \
984 mutex_unlock(&opts->lock); \
985 mutex_unlock(su_mutex); \
986 return ret; \
987 } \
988 \
989 UVC_ATTR(uvcg_frame_, cname, aname);
990
991 #define noop_conversion(x) (x)
992
993 UVCG_FRAME_ATTR(bm_capabilities, bmCapabilities, noop_conversion,
994 noop_conversion, 8);
995 UVCG_FRAME_ATTR(w_width, wWidth, le16_to_cpu, cpu_to_le16, 16);
996 UVCG_FRAME_ATTR(w_height, wHeight, le16_to_cpu, cpu_to_le16, 16);
997 UVCG_FRAME_ATTR(dw_min_bit_rate, dwMinBitRate, le32_to_cpu, cpu_to_le32, 32);
998 UVCG_FRAME_ATTR(dw_max_bit_rate, dwMaxBitRate, le32_to_cpu, cpu_to_le32, 32);
999 UVCG_FRAME_ATTR(dw_max_video_frame_buffer_size, dwMaxVideoFrameBufferSize,
1000 le32_to_cpu, cpu_to_le32, 32);
1001 UVCG_FRAME_ATTR(dw_default_frame_interval, dwDefaultFrameInterval,
1002 le32_to_cpu, cpu_to_le32, 32);
1003
1004 #undef noop_conversion
1005
1006 #undef UVCG_FRAME_ATTR
1007
1008 static ssize_t uvcg_frame_dw_frame_interval_show(struct config_item *item,
1009 char *page)
1010 {
1011 struct uvcg_frame *frm = to_uvcg_frame(item);
1012 struct f_uvc_opts *opts;
1013 struct config_item *opts_item;
1014 struct mutex *su_mutex = &frm->item.ci_group->cg_subsys->su_mutex;
1015 int result, i;
1016 char *pg = page;
1017
1018 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1019
1020 opts_item = frm->item.ci_parent->ci_parent->ci_parent->ci_parent;
1021 opts = to_f_uvc_opts(opts_item);
1022
1023 mutex_lock(&opts->lock);
1024 for (result = 0, i = 0; i < frm->frame.b_frame_interval_type; ++i) {
1025 result += sprintf(pg, "%d\n",
1026 le32_to_cpu(frm->dw_frame_interval[i]));
1027 pg = page + result;
1028 }
1029 mutex_unlock(&opts->lock);
1030
1031 mutex_unlock(su_mutex);
1032 return result;
1033 }
1034
1035 static inline int __uvcg_count_frm_intrv(char *buf, void *priv)
1036 {
1037 ++*((int *)priv);
1038 return 0;
1039 }
1040
1041 static inline int __uvcg_fill_frm_intrv(char *buf, void *priv)
1042 {
1043 u32 num, **interv;
1044 int ret;
1045
1046 ret = kstrtou32(buf, 0, &num);
1047 if (ret)
1048 return ret;
1049
1050 interv = priv;
1051 **interv = cpu_to_le32(num);
1052 ++*interv;
1053
1054 return 0;
1055 }
1056
1057 static int __uvcg_iter_frm_intrv(const char *page, size_t len,
1058 int (*fun)(char *, void *), void *priv)
1059 {
1060 /* sign, base 2 representation, newline, terminator */
1061 char buf[1 + sizeof(u32) * 8 + 1 + 1];
1062 const char *pg = page;
1063 int i, ret;
1064
1065 if (!fun)
1066 return -EINVAL;
1067
1068 while (pg - page < len) {
1069 i = 0;
1070 while (i < sizeof(buf) && (pg - page < len) &&
1071 *pg != '\0' && *pg != '\n')
1072 buf[i++] = *pg++;
1073 if (i == sizeof(buf))
1074 return -EINVAL;
1075 while ((pg - page < len) && (*pg == '\0' || *pg == '\n'))
1076 ++pg;
1077 buf[i] = '\0';
1078 ret = fun(buf, priv);
1079 if (ret)
1080 return ret;
1081 }
1082
1083 return 0;
1084 }
1085
1086 static ssize_t uvcg_frame_dw_frame_interval_store(struct config_item *item,
1087 const char *page, size_t len)
1088 {
1089 struct uvcg_frame *ch = to_uvcg_frame(item);
1090 struct f_uvc_opts *opts;
1091 struct config_item *opts_item;
1092 struct uvcg_format *fmt;
1093 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;
1094 int ret = 0, n = 0;
1095 u32 *frm_intrv, *tmp;
1096
1097 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1098
1099 opts_item = ch->item.ci_parent->ci_parent->ci_parent->ci_parent;
1100 opts = to_f_uvc_opts(opts_item);
1101 fmt = to_uvcg_format(ch->item.ci_parent);
1102
1103 mutex_lock(&opts->lock);
1104 if (fmt->linked || opts->refcnt) {
1105 ret = -EBUSY;
1106 goto end;
1107 }
1108
1109 ret = __uvcg_iter_frm_intrv(page, len, __uvcg_count_frm_intrv, &n);
1110 if (ret)
1111 goto end;
1112
1113 tmp = frm_intrv = kcalloc(n, sizeof(u32), GFP_KERNEL);
1114 if (!frm_intrv) {
1115 ret = -ENOMEM;
1116 goto end;
1117 }
1118
1119 ret = __uvcg_iter_frm_intrv(page, len, __uvcg_fill_frm_intrv, &tmp);
1120 if (ret) {
1121 kfree(frm_intrv);
1122 goto end;
1123 }
1124
1125 kfree(ch->dw_frame_interval);
1126 ch->dw_frame_interval = frm_intrv;
1127 ch->frame.b_frame_interval_type = n;
1128 ret = len;
1129
1130 end:
1131 mutex_unlock(&opts->lock);
1132 mutex_unlock(su_mutex);
1133 return ret;
1134 }
1135
1136 UVC_ATTR(uvcg_frame_, dw_frame_interval, dwFrameInterval);
1137
1138 static struct configfs_attribute *uvcg_frame_attrs[] = {
1139 &uvcg_frame_attr_bm_capabilities,
1140 &uvcg_frame_attr_w_width,
1141 &uvcg_frame_attr_w_height,
1142 &uvcg_frame_attr_dw_min_bit_rate,
1143 &uvcg_frame_attr_dw_max_bit_rate,
1144 &uvcg_frame_attr_dw_max_video_frame_buffer_size,
1145 &uvcg_frame_attr_dw_default_frame_interval,
1146 &uvcg_frame_attr_dw_frame_interval,
1147 NULL,
1148 };
1149
1150 static const struct config_item_type uvcg_frame_type = {
1151 .ct_attrs = uvcg_frame_attrs,
1152 .ct_owner = THIS_MODULE,
1153 };
1154
1155 static struct config_item *uvcg_frame_make(struct config_group *group,
1156 const char *name)
1157 {
1158 struct uvcg_frame *h;
1159 struct uvcg_format *fmt;
1160 struct f_uvc_opts *opts;
1161 struct config_item *opts_item;
1162
1163 h = kzalloc(sizeof(*h), GFP_KERNEL);
1164 if (!h)
1165 return ERR_PTR(-ENOMEM);
1166
1167 h->frame.b_descriptor_type = USB_DT_CS_INTERFACE;
1168 h->frame.b_frame_index = 1;
1169 h->frame.w_width = cpu_to_le16(640);
1170 h->frame.w_height = cpu_to_le16(360);
1171 h->frame.dw_min_bit_rate = cpu_to_le32(18432000);
1172 h->frame.dw_max_bit_rate = cpu_to_le32(55296000);
1173 h->frame.dw_max_video_frame_buffer_size = cpu_to_le32(460800);
1174 h->frame.dw_default_frame_interval = cpu_to_le32(666666);
1175
1176 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1177 opts = to_f_uvc_opts(opts_item);
1178
1179 mutex_lock(&opts->lock);
1180 fmt = to_uvcg_format(&group->cg_item);
1181 if (fmt->type == UVCG_UNCOMPRESSED) {
1182 h->frame.b_descriptor_subtype = UVC_VS_FRAME_UNCOMPRESSED;
1183 h->fmt_type = UVCG_UNCOMPRESSED;
1184 } else if (fmt->type == UVCG_MJPEG) {
1185 h->frame.b_descriptor_subtype = UVC_VS_FRAME_MJPEG;
1186 h->fmt_type = UVCG_MJPEG;
1187 } else {
1188 mutex_unlock(&opts->lock);
1189 kfree(h);
1190 return ERR_PTR(-EINVAL);
1191 }
1192 ++fmt->num_frames;
1193 mutex_unlock(&opts->lock);
1194
1195 config_item_init_type_name(&h->item, name, &uvcg_frame_type);
1196
1197 return &h->item;
1198 }
1199
1200 static void uvcg_frame_drop(struct config_group *group, struct config_item *item)
1201 {
1202 struct uvcg_frame *h = to_uvcg_frame(item);
1203 struct uvcg_format *fmt;
1204 struct f_uvc_opts *opts;
1205 struct config_item *opts_item;
1206
1207 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1208 opts = to_f_uvc_opts(opts_item);
1209
1210 mutex_lock(&opts->lock);
1211 fmt = to_uvcg_format(&group->cg_item);
1212 --fmt->num_frames;
1213 kfree(h);
1214 mutex_unlock(&opts->lock);
1215 }
1216
1217 /* streaming/uncompressed/<NAME> */
1218 struct uvcg_uncompressed {
1219 struct uvcg_format fmt;
1220 struct uvc_format_uncompressed desc;
1221 };
1222
1223 static struct uvcg_uncompressed *to_uvcg_uncompressed(struct config_item *item)
1224 {
1225 return container_of(
1226 container_of(to_config_group(item), struct uvcg_format, group),
1227 struct uvcg_uncompressed, fmt);
1228 }
1229
1230 static struct configfs_group_operations uvcg_uncompressed_group_ops = {
1231 .make_item = uvcg_frame_make,
1232 .drop_item = uvcg_frame_drop,
1233 };
1234
1235 static ssize_t uvcg_uncompressed_guid_format_show(struct config_item *item,
1236 char *page)
1237 {
1238 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1239 struct f_uvc_opts *opts;
1240 struct config_item *opts_item;
1241 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1242
1243 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1244
1245 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1246 opts = to_f_uvc_opts(opts_item);
1247
1248 mutex_lock(&opts->lock);
1249 memcpy(page, ch->desc.guidFormat, sizeof(ch->desc.guidFormat));
1250 mutex_unlock(&opts->lock);
1251
1252 mutex_unlock(su_mutex);
1253
1254 return sizeof(ch->desc.guidFormat);
1255 }
1256
1257 static ssize_t uvcg_uncompressed_guid_format_store(struct config_item *item,
1258 const char *page, size_t len)
1259 {
1260 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1261 struct f_uvc_opts *opts;
1262 struct config_item *opts_item;
1263 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1264 int ret;
1265
1266 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1267
1268 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1269 opts = to_f_uvc_opts(opts_item);
1270
1271 mutex_lock(&opts->lock);
1272 if (ch->fmt.linked || opts->refcnt) {
1273 ret = -EBUSY;
1274 goto end;
1275 }
1276
1277 memcpy(ch->desc.guidFormat, page,
1278 min(sizeof(ch->desc.guidFormat), len));
1279 ret = sizeof(ch->desc.guidFormat);
1280
1281 end:
1282 mutex_unlock(&opts->lock);
1283 mutex_unlock(su_mutex);
1284 return ret;
1285 }
1286
1287 UVC_ATTR(uvcg_uncompressed_, guid_format, guidFormat);
1288
1289 #define UVCG_UNCOMPRESSED_ATTR_RO(cname, aname, conv) \
1290 static ssize_t uvcg_uncompressed_##cname##_show( \
1291 struct config_item *item, char *page) \
1292 { \
1293 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1294 struct f_uvc_opts *opts; \
1295 struct config_item *opts_item; \
1296 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1297 int result; \
1298 \
1299 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1300 \
1301 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1302 opts = to_f_uvc_opts(opts_item); \
1303 \
1304 mutex_lock(&opts->lock); \
1305 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1306 mutex_unlock(&opts->lock); \
1307 \
1308 mutex_unlock(su_mutex); \
1309 return result; \
1310 } \
1311 \
1312 UVC_ATTR_RO(uvcg_uncompressed_, cname, aname);
1313
1314 #define UVCG_UNCOMPRESSED_ATTR(cname, aname, conv) \
1315 static ssize_t uvcg_uncompressed_##cname##_show( \
1316 struct config_item *item, char *page) \
1317 { \
1318 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1319 struct f_uvc_opts *opts; \
1320 struct config_item *opts_item; \
1321 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1322 int result; \
1323 \
1324 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1325 \
1326 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1327 opts = to_f_uvc_opts(opts_item); \
1328 \
1329 mutex_lock(&opts->lock); \
1330 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1331 mutex_unlock(&opts->lock); \
1332 \
1333 mutex_unlock(su_mutex); \
1334 return result; \
1335 } \
1336 \
1337 static ssize_t \
1338 uvcg_uncompressed_##cname##_store(struct config_item *item, \
1339 const char *page, size_t len) \
1340 { \
1341 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
1342 struct f_uvc_opts *opts; \
1343 struct config_item *opts_item; \
1344 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1345 int ret; \
1346 u8 num; \
1347 \
1348 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1349 \
1350 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1351 opts = to_f_uvc_opts(opts_item); \
1352 \
1353 mutex_lock(&opts->lock); \
1354 if (u->fmt.linked || opts->refcnt) { \
1355 ret = -EBUSY; \
1356 goto end; \
1357 } \
1358 \
1359 ret = kstrtou8(page, 0, &num); \
1360 if (ret) \
1361 goto end; \
1362 \
1363 if (num > 255) { \
1364 ret = -EINVAL; \
1365 goto end; \
1366 } \
1367 u->desc.aname = num; \
1368 ret = len; \
1369 end: \
1370 mutex_unlock(&opts->lock); \
1371 mutex_unlock(su_mutex); \
1372 return ret; \
1373 } \
1374 \
1375 UVC_ATTR(uvcg_uncompressed_, cname, aname);
1376
1377 #define identity_conv(x) (x)
1378
1379 UVCG_UNCOMPRESSED_ATTR(b_bits_per_pixel, bBitsPerPixel, identity_conv);
1380 UVCG_UNCOMPRESSED_ATTR(b_default_frame_index, bDefaultFrameIndex,
1381 identity_conv);
1382 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, identity_conv);
1383 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, identity_conv);
1384 UVCG_UNCOMPRESSED_ATTR_RO(bm_interface_flags, bmInterfaceFlags, identity_conv);
1385
1386 #undef identity_conv
1387
1388 #undef UVCG_UNCOMPRESSED_ATTR
1389 #undef UVCG_UNCOMPRESSED_ATTR_RO
1390
1391 static inline ssize_t
1392 uvcg_uncompressed_bma_controls_show(struct config_item *item, char *page)
1393 {
1394 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1395 return uvcg_format_bma_controls_show(&unc->fmt, page);
1396 }
1397
1398 static inline ssize_t
1399 uvcg_uncompressed_bma_controls_store(struct config_item *item,
1400 const char *page, size_t len)
1401 {
1402 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1403 return uvcg_format_bma_controls_store(&unc->fmt, page, len);
1404 }
1405
1406 UVC_ATTR(uvcg_uncompressed_, bma_controls, bmaControls);
1407
1408 static struct configfs_attribute *uvcg_uncompressed_attrs[] = {
1409 &uvcg_uncompressed_attr_guid_format,
1410 &uvcg_uncompressed_attr_b_bits_per_pixel,
1411 &uvcg_uncompressed_attr_b_default_frame_index,
1412 &uvcg_uncompressed_attr_b_aspect_ratio_x,
1413 &uvcg_uncompressed_attr_b_aspect_ratio_y,
1414 &uvcg_uncompressed_attr_bm_interface_flags,
1415 &uvcg_uncompressed_attr_bma_controls,
1416 NULL,
1417 };
1418
1419 static const struct config_item_type uvcg_uncompressed_type = {
1420 .ct_group_ops = &uvcg_uncompressed_group_ops,
1421 .ct_attrs = uvcg_uncompressed_attrs,
1422 .ct_owner = THIS_MODULE,
1423 };
1424
1425 static struct config_group *uvcg_uncompressed_make(struct config_group *group,
1426 const char *name)
1427 {
1428 static char guid[] = {
1429 'Y', 'U', 'Y', '2', 0x00, 0x00, 0x10, 0x00,
1430 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
1431 };
1432 struct uvcg_uncompressed *h;
1433
1434 h = kzalloc(sizeof(*h), GFP_KERNEL);
1435 if (!h)
1436 return ERR_PTR(-ENOMEM);
1437
1438 h->desc.bLength = UVC_DT_FORMAT_UNCOMPRESSED_SIZE;
1439 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1440 h->desc.bDescriptorSubType = UVC_VS_FORMAT_UNCOMPRESSED;
1441 memcpy(h->desc.guidFormat, guid, sizeof(guid));
1442 h->desc.bBitsPerPixel = 16;
1443 h->desc.bDefaultFrameIndex = 1;
1444 h->desc.bAspectRatioX = 0;
1445 h->desc.bAspectRatioY = 0;
1446 h->desc.bmInterfaceFlags = 0;
1447 h->desc.bCopyProtect = 0;
1448
1449 h->fmt.type = UVCG_UNCOMPRESSED;
1450 config_group_init_type_name(&h->fmt.group, name,
1451 &uvcg_uncompressed_type);
1452
1453 return &h->fmt.group;
1454 }
1455
1456 static void uvcg_uncompressed_drop(struct config_group *group,
1457 struct config_item *item)
1458 {
1459 struct uvcg_uncompressed *h = to_uvcg_uncompressed(item);
1460
1461 kfree(h);
1462 }
1463
1464 static struct configfs_group_operations uvcg_uncompressed_grp_ops = {
1465 .make_group = uvcg_uncompressed_make,
1466 .drop_item = uvcg_uncompressed_drop,
1467 };
1468
1469 static const struct config_item_type uvcg_uncompressed_grp_type = {
1470 .ct_group_ops = &uvcg_uncompressed_grp_ops,
1471 .ct_owner = THIS_MODULE,
1472 };
1473
1474 /* streaming/mjpeg/<NAME> */
1475 struct uvcg_mjpeg {
1476 struct uvcg_format fmt;
1477 struct uvc_format_mjpeg desc;
1478 };
1479
1480 static struct uvcg_mjpeg *to_uvcg_mjpeg(struct config_item *item)
1481 {
1482 return container_of(
1483 container_of(to_config_group(item), struct uvcg_format, group),
1484 struct uvcg_mjpeg, fmt);
1485 }
1486
1487 static struct configfs_group_operations uvcg_mjpeg_group_ops = {
1488 .make_item = uvcg_frame_make,
1489 .drop_item = uvcg_frame_drop,
1490 };
1491
1492 #define UVCG_MJPEG_ATTR_RO(cname, aname, conv) \
1493 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1494 { \
1495 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1496 struct f_uvc_opts *opts; \
1497 struct config_item *opts_item; \
1498 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1499 int result; \
1500 \
1501 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1502 \
1503 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1504 opts = to_f_uvc_opts(opts_item); \
1505 \
1506 mutex_lock(&opts->lock); \
1507 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1508 mutex_unlock(&opts->lock); \
1509 \
1510 mutex_unlock(su_mutex); \
1511 return result; \
1512 } \
1513 \
1514 UVC_ATTR_RO(uvcg_mjpeg_, cname, aname)
1515
1516 #define UVCG_MJPEG_ATTR(cname, aname, conv) \
1517 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1518 { \
1519 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1520 struct f_uvc_opts *opts; \
1521 struct config_item *opts_item; \
1522 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1523 int result; \
1524 \
1525 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1526 \
1527 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1528 opts = to_f_uvc_opts(opts_item); \
1529 \
1530 mutex_lock(&opts->lock); \
1531 result = sprintf(page, "%d\n", conv(u->desc.aname)); \
1532 mutex_unlock(&opts->lock); \
1533 \
1534 mutex_unlock(su_mutex); \
1535 return result; \
1536 } \
1537 \
1538 static ssize_t \
1539 uvcg_mjpeg_##cname##_store(struct config_item *item, \
1540 const char *page, size_t len) \
1541 { \
1542 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item); \
1543 struct f_uvc_opts *opts; \
1544 struct config_item *opts_item; \
1545 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
1546 int ret; \
1547 u8 num; \
1548 \
1549 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1550 \
1551 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1552 opts = to_f_uvc_opts(opts_item); \
1553 \
1554 mutex_lock(&opts->lock); \
1555 if (u->fmt.linked || opts->refcnt) { \
1556 ret = -EBUSY; \
1557 goto end; \
1558 } \
1559 \
1560 ret = kstrtou8(page, 0, &num); \
1561 if (ret) \
1562 goto end; \
1563 \
1564 if (num > 255) { \
1565 ret = -EINVAL; \
1566 goto end; \
1567 } \
1568 u->desc.aname = num; \
1569 ret = len; \
1570 end: \
1571 mutex_unlock(&opts->lock); \
1572 mutex_unlock(su_mutex); \
1573 return ret; \
1574 } \
1575 \
1576 UVC_ATTR(uvcg_mjpeg_, cname, aname)
1577
1578 #define identity_conv(x) (x)
1579
1580 UVCG_MJPEG_ATTR(b_default_frame_index, bDefaultFrameIndex,
1581 identity_conv);
1582 UVCG_MJPEG_ATTR_RO(bm_flags, bmFlags, identity_conv);
1583 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, identity_conv);
1584 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, identity_conv);
1585 UVCG_MJPEG_ATTR_RO(bm_interface_flags, bmInterfaceFlags, identity_conv);
1586
1587 #undef identity_conv
1588
1589 #undef UVCG_MJPEG_ATTR
1590 #undef UVCG_MJPEG_ATTR_RO
1591
1592 static inline ssize_t
1593 uvcg_mjpeg_bma_controls_show(struct config_item *item, char *page)
1594 {
1595 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1596 return uvcg_format_bma_controls_show(&u->fmt, page);
1597 }
1598
1599 static inline ssize_t
1600 uvcg_mjpeg_bma_controls_store(struct config_item *item,
1601 const char *page, size_t len)
1602 {
1603 struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1604 return uvcg_format_bma_controls_store(&u->fmt, page, len);
1605 }
1606
1607 UVC_ATTR(uvcg_mjpeg_, bma_controls, bmaControls);
1608
1609 static struct configfs_attribute *uvcg_mjpeg_attrs[] = {
1610 &uvcg_mjpeg_attr_b_default_frame_index,
1611 &uvcg_mjpeg_attr_bm_flags,
1612 &uvcg_mjpeg_attr_b_aspect_ratio_x,
1613 &uvcg_mjpeg_attr_b_aspect_ratio_y,
1614 &uvcg_mjpeg_attr_bm_interface_flags,
1615 &uvcg_mjpeg_attr_bma_controls,
1616 NULL,
1617 };
1618
1619 static const struct config_item_type uvcg_mjpeg_type = {
1620 .ct_group_ops = &uvcg_mjpeg_group_ops,
1621 .ct_attrs = uvcg_mjpeg_attrs,
1622 .ct_owner = THIS_MODULE,
1623 };
1624
1625 static struct config_group *uvcg_mjpeg_make(struct config_group *group,
1626 const char *name)
1627 {
1628 struct uvcg_mjpeg *h;
1629
1630 h = kzalloc(sizeof(*h), GFP_KERNEL);
1631 if (!h)
1632 return ERR_PTR(-ENOMEM);
1633
1634 h->desc.bLength = UVC_DT_FORMAT_MJPEG_SIZE;
1635 h->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1636 h->desc.bDescriptorSubType = UVC_VS_FORMAT_MJPEG;
1637 h->desc.bDefaultFrameIndex = 1;
1638 h->desc.bAspectRatioX = 0;
1639 h->desc.bAspectRatioY = 0;
1640 h->desc.bmInterfaceFlags = 0;
1641 h->desc.bCopyProtect = 0;
1642
1643 h->fmt.type = UVCG_MJPEG;
1644 config_group_init_type_name(&h->fmt.group, name,
1645 &uvcg_mjpeg_type);
1646
1647 return &h->fmt.group;
1648 }
1649
1650 static void uvcg_mjpeg_drop(struct config_group *group,
1651 struct config_item *item)
1652 {
1653 struct uvcg_mjpeg *h = to_uvcg_mjpeg(item);
1654
1655 kfree(h);
1656 }
1657
1658 static struct configfs_group_operations uvcg_mjpeg_grp_ops = {
1659 .make_group = uvcg_mjpeg_make,
1660 .drop_item = uvcg_mjpeg_drop,
1661 };
1662
1663 static const struct config_item_type uvcg_mjpeg_grp_type = {
1664 .ct_group_ops = &uvcg_mjpeg_grp_ops,
1665 .ct_owner = THIS_MODULE,
1666 };
1667
1668 /* streaming/color_matching/default */
1669 static struct uvcg_default_color_matching {
1670 struct config_group group;
1671 } uvcg_default_color_matching;
1672
1673 static inline struct uvcg_default_color_matching
1674 *to_uvcg_default_color_matching(struct config_item *item)
1675 {
1676 return container_of(to_config_group(item),
1677 struct uvcg_default_color_matching, group);
1678 }
1679
1680 #define UVCG_DEFAULT_COLOR_MATCHING_ATTR(cname, aname, conv) \
1681 static ssize_t uvcg_default_color_matching_##cname##_show( \
1682 struct config_item *item, char *page) \
1683 { \
1684 struct uvcg_default_color_matching *dc = \
1685 to_uvcg_default_color_matching(item); \
1686 struct f_uvc_opts *opts; \
1687 struct config_item *opts_item; \
1688 struct mutex *su_mutex = &dc->group.cg_subsys->su_mutex; \
1689 struct uvc_color_matching_descriptor *cd; \
1690 int result; \
1691 \
1692 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
1693 \
1694 opts_item = dc->group.cg_item.ci_parent->ci_parent->ci_parent; \
1695 opts = to_f_uvc_opts(opts_item); \
1696 cd = &opts->uvc_color_matching; \
1697 \
1698 mutex_lock(&opts->lock); \
1699 result = sprintf(page, "%d\n", conv(cd->aname)); \
1700 mutex_unlock(&opts->lock); \
1701 \
1702 mutex_unlock(su_mutex); \
1703 return result; \
1704 } \
1705 \
1706 UVC_ATTR_RO(uvcg_default_color_matching_, cname, aname)
1707
1708 #define identity_conv(x) (x)
1709
1710 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_color_primaries, bColorPrimaries,
1711 identity_conv);
1712 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_transfer_characteristics,
1713 bTransferCharacteristics, identity_conv);
1714 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_matrix_coefficients, bMatrixCoefficients,
1715 identity_conv);
1716
1717 #undef identity_conv
1718
1719 #undef UVCG_DEFAULT_COLOR_MATCHING_ATTR
1720
1721 static struct configfs_attribute *uvcg_default_color_matching_attrs[] = {
1722 &uvcg_default_color_matching_attr_b_color_primaries,
1723 &uvcg_default_color_matching_attr_b_transfer_characteristics,
1724 &uvcg_default_color_matching_attr_b_matrix_coefficients,
1725 NULL,
1726 };
1727
1728 static const struct config_item_type uvcg_default_color_matching_type = {
1729 .ct_attrs = uvcg_default_color_matching_attrs,
1730 .ct_owner = THIS_MODULE,
1731 };
1732
1733 /* struct uvcg_color_matching {}; */
1734
1735 /* streaming/color_matching */
1736 static struct uvcg_color_matching_grp {
1737 struct config_group group;
1738 } uvcg_color_matching_grp;
1739
1740 static const struct config_item_type uvcg_color_matching_grp_type = {
1741 .ct_owner = THIS_MODULE,
1742 };
1743
1744 /* streaming/class/{fs|hs|ss} */
1745 static struct uvcg_streaming_class {
1746 struct config_group group;
1747 } uvcg_streaming_class_fs, uvcg_streaming_class_hs, uvcg_streaming_class_ss;
1748
1749
1750 static inline struct uvc_descriptor_header
1751 ***__uvcg_get_stream_class_arr(struct config_item *i, struct f_uvc_opts *o)
1752 {
1753 struct uvcg_streaming_class *cl = container_of(to_config_group(i),
1754 struct uvcg_streaming_class, group);
1755
1756 if (cl == &uvcg_streaming_class_fs)
1757 return &o->uvc_fs_streaming_cls;
1758
1759 if (cl == &uvcg_streaming_class_hs)
1760 return &o->uvc_hs_streaming_cls;
1761
1762 if (cl == &uvcg_streaming_class_ss)
1763 return &o->uvc_ss_streaming_cls;
1764
1765 return NULL;
1766 }
1767
1768 enum uvcg_strm_type {
1769 UVCG_HEADER = 0,
1770 UVCG_FORMAT,
1771 UVCG_FRAME
1772 };
1773
1774 /*
1775 * Iterate over a hierarchy of streaming descriptors' config items.
1776 * The items are created by the user with configfs.
1777 *
1778 * It "processes" the header pointed to by @priv1, then for each format
1779 * that follows the header "processes" the format itself and then for
1780 * each frame inside a format "processes" the frame.
1781 *
1782 * As a "processing" function the @fun is used.
1783 *
1784 * __uvcg_iter_strm_cls() is used in two context: first, to calculate
1785 * the amount of memory needed for an array of streaming descriptors
1786 * and second, to actually fill the array.
1787 *
1788 * @h: streaming header pointer
1789 * @priv2: an "inout" parameter (the caller might want to see the changes to it)
1790 * @priv3: an "inout" parameter (the caller might want to see the changes to it)
1791 * @fun: callback function for processing each level of the hierarchy
1792 */
1793 static int __uvcg_iter_strm_cls(struct uvcg_streaming_header *h,
1794 void *priv2, void *priv3,
1795 int (*fun)(void *, void *, void *, int, enum uvcg_strm_type type))
1796 {
1797 struct uvcg_format_ptr *f;
1798 struct config_group *grp;
1799 struct config_item *item;
1800 struct uvcg_frame *frm;
1801 int ret, i, j;
1802
1803 if (!fun)
1804 return -EINVAL;
1805
1806 i = j = 0;
1807 ret = fun(h, priv2, priv3, 0, UVCG_HEADER);
1808 if (ret)
1809 return ret;
1810 list_for_each_entry(f, &h->formats, entry) {
1811 ret = fun(f->fmt, priv2, priv3, i++, UVCG_FORMAT);
1812 if (ret)
1813 return ret;
1814 grp = &f->fmt->group;
1815 list_for_each_entry(item, &grp->cg_children, ci_entry) {
1816 frm = to_uvcg_frame(item);
1817 ret = fun(frm, priv2, priv3, j++, UVCG_FRAME);
1818 if (ret)
1819 return ret;
1820 }
1821 }
1822
1823 return ret;
1824 }
1825
1826 /*
1827 * Count how many bytes are needed for an array of streaming descriptors.
1828 *
1829 * @priv1: pointer to a header, format or frame
1830 * @priv2: inout parameter, accumulated size of the array
1831 * @priv3: inout parameter, accumulated number of the array elements
1832 * @n: unused, this function's prototype must match @fun in __uvcg_iter_strm_cls
1833 */
1834 static int __uvcg_cnt_strm(void *priv1, void *priv2, void *priv3, int n,
1835 enum uvcg_strm_type type)
1836 {
1837 size_t *size = priv2;
1838 size_t *count = priv3;
1839
1840 switch (type) {
1841 case UVCG_HEADER: {
1842 struct uvcg_streaming_header *h = priv1;
1843
1844 *size += sizeof(h->desc);
1845 /* bmaControls */
1846 *size += h->num_fmt * UVCG_STREAMING_CONTROL_SIZE;
1847 }
1848 break;
1849 case UVCG_FORMAT: {
1850 struct uvcg_format *fmt = priv1;
1851
1852 if (fmt->type == UVCG_UNCOMPRESSED) {
1853 struct uvcg_uncompressed *u =
1854 container_of(fmt, struct uvcg_uncompressed,
1855 fmt);
1856
1857 *size += sizeof(u->desc);
1858 } else if (fmt->type == UVCG_MJPEG) {
1859 struct uvcg_mjpeg *m =
1860 container_of(fmt, struct uvcg_mjpeg, fmt);
1861
1862 *size += sizeof(m->desc);
1863 } else {
1864 return -EINVAL;
1865 }
1866 }
1867 break;
1868 case UVCG_FRAME: {
1869 struct uvcg_frame *frm = priv1;
1870 int sz = sizeof(frm->dw_frame_interval);
1871
1872 *size += sizeof(frm->frame);
1873 *size += frm->frame.b_frame_interval_type * sz;
1874 }
1875 break;
1876 }
1877
1878 ++*count;
1879
1880 return 0;
1881 }
1882
1883 /*
1884 * Fill an array of streaming descriptors.
1885 *
1886 * @priv1: pointer to a header, format or frame
1887 * @priv2: inout parameter, pointer into a block of memory
1888 * @priv3: inout parameter, pointer to a 2-dimensional array
1889 */
1890 static int __uvcg_fill_strm(void *priv1, void *priv2, void *priv3, int n,
1891 enum uvcg_strm_type type)
1892 {
1893 void **dest = priv2;
1894 struct uvc_descriptor_header ***array = priv3;
1895 size_t sz;
1896
1897 **array = *dest;
1898 ++*array;
1899
1900 switch (type) {
1901 case UVCG_HEADER: {
1902 struct uvc_input_header_descriptor *ihdr = *dest;
1903 struct uvcg_streaming_header *h = priv1;
1904 struct uvcg_format_ptr *f;
1905
1906 memcpy(*dest, &h->desc, sizeof(h->desc));
1907 *dest += sizeof(h->desc);
1908 sz = UVCG_STREAMING_CONTROL_SIZE;
1909 list_for_each_entry(f, &h->formats, entry) {
1910 memcpy(*dest, f->fmt->bmaControls, sz);
1911 *dest += sz;
1912 }
1913 ihdr->bLength = sizeof(h->desc) + h->num_fmt * sz;
1914 ihdr->bNumFormats = h->num_fmt;
1915 }
1916 break;
1917 case UVCG_FORMAT: {
1918 struct uvcg_format *fmt = priv1;
1919
1920 if (fmt->type == UVCG_UNCOMPRESSED) {
1921 struct uvc_format_uncompressed *unc = *dest;
1922 struct uvcg_uncompressed *u =
1923 container_of(fmt, struct uvcg_uncompressed,
1924 fmt);
1925
1926 memcpy(*dest, &u->desc, sizeof(u->desc));
1927 *dest += sizeof(u->desc);
1928 unc->bNumFrameDescriptors = fmt->num_frames;
1929 unc->bFormatIndex = n + 1;
1930 } else if (fmt->type == UVCG_MJPEG) {
1931 struct uvc_format_mjpeg *mjp = *dest;
1932 struct uvcg_mjpeg *m =
1933 container_of(fmt, struct uvcg_mjpeg, fmt);
1934
1935 memcpy(*dest, &m->desc, sizeof(m->desc));
1936 *dest += sizeof(m->desc);
1937 mjp->bNumFrameDescriptors = fmt->num_frames;
1938 mjp->bFormatIndex = n + 1;
1939 } else {
1940 return -EINVAL;
1941 }
1942 }
1943 break;
1944 case UVCG_FRAME: {
1945 struct uvcg_frame *frm = priv1;
1946 struct uvc_descriptor_header *h = *dest;
1947
1948 sz = sizeof(frm->frame);
1949 memcpy(*dest, &frm->frame, sz);
1950 *dest += sz;
1951 sz = frm->frame.b_frame_interval_type *
1952 sizeof(*frm->dw_frame_interval);
1953 memcpy(*dest, frm->dw_frame_interval, sz);
1954 *dest += sz;
1955 if (frm->fmt_type == UVCG_UNCOMPRESSED)
1956 h->bLength = UVC_DT_FRAME_UNCOMPRESSED_SIZE(
1957 frm->frame.b_frame_interval_type);
1958 else if (frm->fmt_type == UVCG_MJPEG)
1959 h->bLength = UVC_DT_FRAME_MJPEG_SIZE(
1960 frm->frame.b_frame_interval_type);
1961 }
1962 break;
1963 }
1964
1965 return 0;
1966 }
1967
1968 static int uvcg_streaming_class_allow_link(struct config_item *src,
1969 struct config_item *target)
1970 {
1971 struct config_item *streaming, *header;
1972 struct f_uvc_opts *opts;
1973 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1974 struct uvc_descriptor_header ***class_array, **cl_arr;
1975 struct uvcg_streaming_header *target_hdr;
1976 void *data, *data_save;
1977 size_t size = 0, count = 0;
1978 int ret = -EINVAL;
1979
1980 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1981
1982 streaming = src->ci_parent->ci_parent;
1983 header = config_group_find_item(to_config_group(streaming), "header");
1984 if (!header || target->ci_parent != header)
1985 goto out;
1986
1987 opts = to_f_uvc_opts(streaming->ci_parent);
1988
1989 mutex_lock(&opts->lock);
1990
1991 class_array = __uvcg_get_stream_class_arr(src, opts);
1992 if (!class_array || *class_array || opts->refcnt) {
1993 ret = -EBUSY;
1994 goto unlock;
1995 }
1996
1997 target_hdr = to_uvcg_streaming_header(target);
1998 ret = __uvcg_iter_strm_cls(target_hdr, &size, &count, __uvcg_cnt_strm);
1999 if (ret)
2000 goto unlock;
2001
2002 count += 2; /* color_matching, NULL */
2003 *class_array = kcalloc(count, sizeof(void *), GFP_KERNEL);
2004 if (!*class_array) {
2005 ret = -ENOMEM;
2006 goto unlock;
2007 }
2008
2009 data = data_save = kzalloc(size, GFP_KERNEL);
2010 if (!data) {
2011 kfree(*class_array);
2012 *class_array = NULL;
2013 ret = -ENOMEM;
2014 goto unlock;
2015 }
2016 cl_arr = *class_array;
2017 ret = __uvcg_iter_strm_cls(target_hdr, &data, &cl_arr,
2018 __uvcg_fill_strm);
2019 if (ret) {
2020 kfree(*class_array);
2021 *class_array = NULL;
2022 /*
2023 * __uvcg_fill_strm() called from __uvcg_iter_stream_cls()
2024 * might have advanced the "data", so use a backup copy
2025 */
2026 kfree(data_save);
2027 goto unlock;
2028 }
2029 *cl_arr = (struct uvc_descriptor_header *)&opts->uvc_color_matching;
2030
2031 ++target_hdr->linked;
2032 ret = 0;
2033
2034 unlock:
2035 mutex_unlock(&opts->lock);
2036 out:
2037 mutex_unlock(su_mutex);
2038 return ret;
2039 }
2040
2041 static void uvcg_streaming_class_drop_link(struct config_item *src,
2042 struct config_item *target)
2043 {
2044 struct config_item *streaming, *header;
2045 struct f_uvc_opts *opts;
2046 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
2047 struct uvc_descriptor_header ***class_array;
2048 struct uvcg_streaming_header *target_hdr;
2049
2050 mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2051
2052 streaming = src->ci_parent->ci_parent;
2053 header = config_group_find_item(to_config_group(streaming), "header");
2054 if (!header || target->ci_parent != header)
2055 goto out;
2056
2057 opts = to_f_uvc_opts(streaming->ci_parent);
2058
2059 mutex_lock(&opts->lock);
2060
2061 class_array = __uvcg_get_stream_class_arr(src, opts);
2062 if (!class_array || !*class_array)
2063 goto unlock;
2064
2065 if (opts->refcnt)
2066 goto unlock;
2067
2068 target_hdr = to_uvcg_streaming_header(target);
2069 --target_hdr->linked;
2070 kfree(**class_array);
2071 kfree(*class_array);
2072 *class_array = NULL;
2073
2074 unlock:
2075 mutex_unlock(&opts->lock);
2076 out:
2077 mutex_unlock(su_mutex);
2078 }
2079
2080 static struct configfs_item_operations uvcg_streaming_class_item_ops = {
2081 .allow_link = uvcg_streaming_class_allow_link,
2082 .drop_link = uvcg_streaming_class_drop_link,
2083 };
2084
2085 static const struct config_item_type uvcg_streaming_class_type = {
2086 .ct_item_ops = &uvcg_streaming_class_item_ops,
2087 .ct_owner = THIS_MODULE,
2088 };
2089
2090 /* streaming/class */
2091 static struct uvcg_streaming_class_grp {
2092 struct config_group group;
2093 } uvcg_streaming_class_grp;
2094
2095 static const struct config_item_type uvcg_streaming_class_grp_type = {
2096 .ct_owner = THIS_MODULE,
2097 };
2098
2099 /* streaming */
2100 static struct uvcg_streaming_grp {
2101 struct config_group group;
2102 } uvcg_streaming_grp;
2103
2104 static const struct config_item_type uvcg_streaming_grp_type = {
2105 .ct_owner = THIS_MODULE,
2106 };
2107
2108 static inline struct f_uvc_opts *to_f_uvc_opts(struct config_item *item)
2109 {
2110 return container_of(to_config_group(item), struct f_uvc_opts,
2111 func_inst.group);
2112 }
2113
2114 static void uvc_attr_release(struct config_item *item)
2115 {
2116 struct f_uvc_opts *opts = to_f_uvc_opts(item);
2117
2118 usb_put_function_instance(&opts->func_inst);
2119 }
2120
2121 static struct configfs_item_operations uvc_item_ops = {
2122 .release = uvc_attr_release,
2123 };
2124
2125 #define UVCG_OPTS_ATTR(cname, aname, conv, str2u, uxx, vnoc, limit) \
2126 static ssize_t f_uvc_opts_##cname##_show( \
2127 struct config_item *item, char *page) \
2128 { \
2129 struct f_uvc_opts *opts = to_f_uvc_opts(item); \
2130 int result; \
2131 \
2132 mutex_lock(&opts->lock); \
2133 result = sprintf(page, "%d\n", conv(opts->cname)); \
2134 mutex_unlock(&opts->lock); \
2135 \
2136 return result; \
2137 } \
2138 \
2139 static ssize_t \
2140 f_uvc_opts_##cname##_store(struct config_item *item, \
2141 const char *page, size_t len) \
2142 { \
2143 struct f_uvc_opts *opts = to_f_uvc_opts(item); \
2144 int ret; \
2145 uxx num; \
2146 \
2147 mutex_lock(&opts->lock); \
2148 if (opts->refcnt) { \
2149 ret = -EBUSY; \
2150 goto end; \
2151 } \
2152 \
2153 ret = str2u(page, 0, &num); \
2154 if (ret) \
2155 goto end; \
2156 \
2157 if (num > limit) { \
2158 ret = -EINVAL; \
2159 goto end; \
2160 } \
2161 opts->cname = vnoc(num); \
2162 ret = len; \
2163 end: \
2164 mutex_unlock(&opts->lock); \
2165 return ret; \
2166 } \
2167 \
2168 UVC_ATTR(f_uvc_opts_, cname, cname)
2169
2170 #define identity_conv(x) (x)
2171
2172 UVCG_OPTS_ATTR(streaming_interval, streaming_interval, identity_conv,
2173 kstrtou8, u8, identity_conv, 16);
2174 UVCG_OPTS_ATTR(streaming_maxpacket, streaming_maxpacket, le16_to_cpu,
2175 kstrtou16, u16, le16_to_cpu, 3072);
2176 UVCG_OPTS_ATTR(streaming_maxburst, streaming_maxburst, identity_conv,
2177 kstrtou8, u8, identity_conv, 15);
2178
2179 #undef identity_conv
2180
2181 #undef UVCG_OPTS_ATTR
2182
2183 static struct configfs_attribute *uvc_attrs[] = {
2184 &f_uvc_opts_attr_streaming_interval,
2185 &f_uvc_opts_attr_streaming_maxpacket,
2186 &f_uvc_opts_attr_streaming_maxburst,
2187 NULL,
2188 };
2189
2190 static const struct config_item_type uvc_func_type = {
2191 .ct_item_ops = &uvc_item_ops,
2192 .ct_attrs = uvc_attrs,
2193 .ct_owner = THIS_MODULE,
2194 };
2195
2196 int uvcg_attach_configfs(struct f_uvc_opts *opts)
2197 {
2198 config_group_init_type_name(&uvcg_control_header_grp.group,
2199 "header",
2200 &uvcg_control_header_grp_type);
2201
2202 config_group_init_type_name(&uvcg_default_processing.group,
2203 "default", &uvcg_default_processing_type);
2204 config_group_init_type_name(&uvcg_processing_grp.group,
2205 "processing", &uvcg_processing_grp_type);
2206 configfs_add_default_group(&uvcg_default_processing.group,
2207 &uvcg_processing_grp.group);
2208
2209 config_group_init_type_name(&uvcg_default_camera.group,
2210 "default", &uvcg_default_camera_type);
2211 config_group_init_type_name(&uvcg_camera_grp.group,
2212 "camera", &uvcg_camera_grp_type);
2213 configfs_add_default_group(&uvcg_default_camera.group,
2214 &uvcg_camera_grp.group);
2215
2216 config_group_init_type_name(&uvcg_default_output.group,
2217 "default", &uvcg_default_output_type);
2218 config_group_init_type_name(&uvcg_output_grp.group,
2219 "output", &uvcg_output_grp_type);
2220 configfs_add_default_group(&uvcg_default_output.group,
2221 &uvcg_output_grp.group);
2222
2223 config_group_init_type_name(&uvcg_terminal_grp.group,
2224 "terminal", &uvcg_terminal_grp_type);
2225 configfs_add_default_group(&uvcg_camera_grp.group,
2226 &uvcg_terminal_grp.group);
2227 configfs_add_default_group(&uvcg_output_grp.group,
2228 &uvcg_terminal_grp.group);
2229
2230 config_group_init_type_name(&uvcg_control_class_fs.group,
2231 "fs", &uvcg_control_class_type);
2232 config_group_init_type_name(&uvcg_control_class_ss.group,
2233 "ss", &uvcg_control_class_type);
2234 config_group_init_type_name(&uvcg_control_class_grp.group,
2235 "class",
2236 &uvcg_control_class_grp_type);
2237 configfs_add_default_group(&uvcg_control_class_fs.group,
2238 &uvcg_control_class_grp.group);
2239 configfs_add_default_group(&uvcg_control_class_ss.group,
2240 &uvcg_control_class_grp.group);
2241
2242 config_group_init_type_name(&uvcg_control_grp.group,
2243 "control",
2244 &uvcg_control_grp_type);
2245 configfs_add_default_group(&uvcg_control_header_grp.group,
2246 &uvcg_control_grp.group);
2247 configfs_add_default_group(&uvcg_processing_grp.group,
2248 &uvcg_control_grp.group);
2249 configfs_add_default_group(&uvcg_terminal_grp.group,
2250 &uvcg_control_grp.group);
2251 configfs_add_default_group(&uvcg_control_class_grp.group,
2252 &uvcg_control_grp.group);
2253
2254 config_group_init_type_name(&uvcg_streaming_header_grp.group,
2255 "header",
2256 &uvcg_streaming_header_grp_type);
2257 config_group_init_type_name(&uvcg_uncompressed_grp.group,
2258 "uncompressed",
2259 &uvcg_uncompressed_grp_type);
2260 config_group_init_type_name(&uvcg_mjpeg_grp.group,
2261 "mjpeg",
2262 &uvcg_mjpeg_grp_type);
2263 config_group_init_type_name(&uvcg_default_color_matching.group,
2264 "default",
2265 &uvcg_default_color_matching_type);
2266 config_group_init_type_name(&uvcg_color_matching_grp.group,
2267 "color_matching",
2268 &uvcg_color_matching_grp_type);
2269 configfs_add_default_group(&uvcg_default_color_matching.group,
2270 &uvcg_color_matching_grp.group);
2271
2272 config_group_init_type_name(&uvcg_streaming_class_fs.group,
2273 "fs", &uvcg_streaming_class_type);
2274 config_group_init_type_name(&uvcg_streaming_class_hs.group,
2275 "hs", &uvcg_streaming_class_type);
2276 config_group_init_type_name(&uvcg_streaming_class_ss.group,
2277 "ss", &uvcg_streaming_class_type);
2278 config_group_init_type_name(&uvcg_streaming_class_grp.group,
2279 "class", &uvcg_streaming_class_grp_type);
2280 configfs_add_default_group(&uvcg_streaming_class_fs.group,
2281 &uvcg_streaming_class_grp.group);
2282 configfs_add_default_group(&uvcg_streaming_class_hs.group,
2283 &uvcg_streaming_class_grp.group);
2284 configfs_add_default_group(&uvcg_streaming_class_ss.group,
2285 &uvcg_streaming_class_grp.group);
2286
2287 config_group_init_type_name(&uvcg_streaming_grp.group,
2288 "streaming", &uvcg_streaming_grp_type);
2289 configfs_add_default_group(&uvcg_streaming_header_grp.group,
2290 &uvcg_streaming_grp.group);
2291 configfs_add_default_group(&uvcg_uncompressed_grp.group,
2292 &uvcg_streaming_grp.group);
2293 configfs_add_default_group(&uvcg_mjpeg_grp.group,
2294 &uvcg_streaming_grp.group);
2295 configfs_add_default_group(&uvcg_color_matching_grp.group,
2296 &uvcg_streaming_grp.group);
2297 configfs_add_default_group(&uvcg_streaming_class_grp.group,
2298 &uvcg_streaming_grp.group);
2299
2300 config_group_init_type_name(&opts->func_inst.group,
2301 "",
2302 &uvc_func_type);
2303 configfs_add_default_group(&uvcg_control_grp.group,
2304 &opts->func_inst.group);
2305 configfs_add_default_group(&uvcg_streaming_grp.group,
2306 &opts->func_inst.group);
2307
2308 return 0;
2309 }
CRIS linux kernel tree