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