?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/panel-edp: Add STA 116QHD024002
[drm/drm-misc.git] / drivers / media / usb / uvc / uvc_ctrl.c
blob4fe26e82e3d1c167bd59c5decf79a8391ae465a4
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * uvc_ctrl.c -- USB Video Class driver - Controls
4 *
5 * Copyright (C) 2005-2010
6 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7 */
8
9 #include <asm/barrier.h>
10 #include <linux/bitops.h>
11 #include <linux/kernel.h>
12 #include <linux/list.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/uaccess.h>
16 #include <linux/usb.h>
17 #include <linux/usb/uvc.h>
18 #include <linux/videodev2.h>
19 #include <linux/vmalloc.h>
20 #include <linux/wait.h>
21 #include <linux/workqueue.h>
22 #include <linux/atomic.h>
23 #include <media/v4l2-ctrls.h>
24
25 #include "uvcvideo.h"
26
27 #define UVC_CTRL_DATA_CURRENT 0
28 #define UVC_CTRL_DATA_BACKUP 1
29 #define UVC_CTRL_DATA_MIN 2
30 #define UVC_CTRL_DATA_MAX 3
31 #define UVC_CTRL_DATA_RES 4
32 #define UVC_CTRL_DATA_DEF 5
33 #define UVC_CTRL_DATA_LAST 6
34
35 /* ------------------------------------------------------------------------
36 * Controls
37 */
38
39 static const struct uvc_control_info uvc_ctrls[] = {
40 {
41 .entity = UVC_GUID_UVC_PROCESSING,
42 .selector = UVC_PU_BRIGHTNESS_CONTROL,
43 .index = 0,
44 .size = 2,
45 .flags = UVC_CTRL_FLAG_SET_CUR
46 | UVC_CTRL_FLAG_GET_RANGE
47 | UVC_CTRL_FLAG_RESTORE,
48 },
49 {
50 .entity = UVC_GUID_UVC_PROCESSING,
51 .selector = UVC_PU_CONTRAST_CONTROL,
52 .index = 1,
53 .size = 2,
54 .flags = UVC_CTRL_FLAG_SET_CUR
55 | UVC_CTRL_FLAG_GET_RANGE
56 | UVC_CTRL_FLAG_RESTORE,
57 },
58 {
59 .entity = UVC_GUID_UVC_PROCESSING,
60 .selector = UVC_PU_HUE_CONTROL,
61 .index = 2,
62 .size = 2,
63 .flags = UVC_CTRL_FLAG_SET_CUR
64 | UVC_CTRL_FLAG_GET_RANGE
65 | UVC_CTRL_FLAG_RESTORE
66 | UVC_CTRL_FLAG_AUTO_UPDATE,
67 },
68 {
69 .entity = UVC_GUID_UVC_PROCESSING,
70 .selector = UVC_PU_SATURATION_CONTROL,
71 .index = 3,
72 .size = 2,
73 .flags = UVC_CTRL_FLAG_SET_CUR
74 | UVC_CTRL_FLAG_GET_RANGE
75 | UVC_CTRL_FLAG_RESTORE,
76 },
77 {
78 .entity = UVC_GUID_UVC_PROCESSING,
79 .selector = UVC_PU_SHARPNESS_CONTROL,
80 .index = 4,
81 .size = 2,
82 .flags = UVC_CTRL_FLAG_SET_CUR
83 | UVC_CTRL_FLAG_GET_RANGE
84 | UVC_CTRL_FLAG_RESTORE,
85 },
86 {
87 .entity = UVC_GUID_UVC_PROCESSING,
88 .selector = UVC_PU_GAMMA_CONTROL,
89 .index = 5,
90 .size = 2,
91 .flags = UVC_CTRL_FLAG_SET_CUR
92 | UVC_CTRL_FLAG_GET_RANGE
93 | UVC_CTRL_FLAG_RESTORE,
94 },
95 {
96 .entity = UVC_GUID_UVC_PROCESSING,
97 .selector = UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
98 .index = 6,
99 .size = 2,
100 .flags = UVC_CTRL_FLAG_SET_CUR
101 | UVC_CTRL_FLAG_GET_RANGE
102 | UVC_CTRL_FLAG_RESTORE
103 | UVC_CTRL_FLAG_AUTO_UPDATE,
104 },
105 {
106 .entity = UVC_GUID_UVC_PROCESSING,
107 .selector = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
108 .index = 7,
109 .size = 4,
110 .flags = UVC_CTRL_FLAG_SET_CUR
111 | UVC_CTRL_FLAG_GET_RANGE
112 | UVC_CTRL_FLAG_RESTORE
113 | UVC_CTRL_FLAG_AUTO_UPDATE,
114 },
115 {
116 .entity = UVC_GUID_UVC_PROCESSING,
117 .selector = UVC_PU_BACKLIGHT_COMPENSATION_CONTROL,
118 .index = 8,
119 .size = 2,
120 .flags = UVC_CTRL_FLAG_SET_CUR
121 | UVC_CTRL_FLAG_GET_RANGE
122 | UVC_CTRL_FLAG_RESTORE,
123 },
124 {
125 .entity = UVC_GUID_UVC_PROCESSING,
126 .selector = UVC_PU_GAIN_CONTROL,
127 .index = 9,
128 .size = 2,
129 .flags = UVC_CTRL_FLAG_SET_CUR
130 | UVC_CTRL_FLAG_GET_RANGE
131 | UVC_CTRL_FLAG_RESTORE,
132 },
133 {
134 .entity = UVC_GUID_UVC_PROCESSING,
135 .selector = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
136 .index = 10,
137 .size = 1,
138 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
139 | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
140 },
141 {
142 .entity = UVC_GUID_UVC_PROCESSING,
143 .selector = UVC_PU_HUE_AUTO_CONTROL,
144 .index = 11,
145 .size = 1,
146 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
147 | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
148 },
149 {
150 .entity = UVC_GUID_UVC_PROCESSING,
151 .selector = UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
152 .index = 12,
153 .size = 1,
154 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
155 | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
156 },
157 {
158 .entity = UVC_GUID_UVC_PROCESSING,
159 .selector = UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
160 .index = 13,
161 .size = 1,
162 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
163 | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
164 },
165 {
166 .entity = UVC_GUID_UVC_PROCESSING,
167 .selector = UVC_PU_DIGITAL_MULTIPLIER_CONTROL,
168 .index = 14,
169 .size = 2,
170 .flags = UVC_CTRL_FLAG_SET_CUR
171 | UVC_CTRL_FLAG_GET_RANGE
172 | UVC_CTRL_FLAG_RESTORE,
173 },
174 {
175 .entity = UVC_GUID_UVC_PROCESSING,
176 .selector = UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL,
177 .index = 15,
178 .size = 2,
179 .flags = UVC_CTRL_FLAG_SET_CUR
180 | UVC_CTRL_FLAG_GET_RANGE
181 | UVC_CTRL_FLAG_RESTORE,
182 },
183 {
184 .entity = UVC_GUID_UVC_PROCESSING,
185 .selector = UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL,
186 .index = 16,
187 .size = 1,
188 .flags = UVC_CTRL_FLAG_GET_CUR,
189 },
190 {
191 .entity = UVC_GUID_UVC_PROCESSING,
192 .selector = UVC_PU_ANALOG_LOCK_STATUS_CONTROL,
193 .index = 17,
194 .size = 1,
195 .flags = UVC_CTRL_FLAG_GET_CUR,
196 },
197 {
198 .entity = UVC_GUID_UVC_CAMERA,
199 .selector = UVC_CT_SCANNING_MODE_CONTROL,
200 .index = 0,
201 .size = 1,
202 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
203 | UVC_CTRL_FLAG_RESTORE,
204 },
205 {
206 .entity = UVC_GUID_UVC_CAMERA,
207 .selector = UVC_CT_AE_MODE_CONTROL,
208 .index = 1,
209 .size = 1,
210 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
211 | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_GET_RES
212 | UVC_CTRL_FLAG_RESTORE,
213 },
214 {
215 .entity = UVC_GUID_UVC_CAMERA,
216 .selector = UVC_CT_AE_PRIORITY_CONTROL,
217 .index = 2,
218 .size = 1,
219 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
220 | UVC_CTRL_FLAG_RESTORE,
221 },
222 {
223 .entity = UVC_GUID_UVC_CAMERA,
224 .selector = UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
225 .index = 3,
226 .size = 4,
227 .flags = UVC_CTRL_FLAG_SET_CUR
228 | UVC_CTRL_FLAG_GET_RANGE
229 | UVC_CTRL_FLAG_RESTORE
230 | UVC_CTRL_FLAG_AUTO_UPDATE,
231 },
232 {
233 .entity = UVC_GUID_UVC_CAMERA,
234 .selector = UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL,
235 .index = 4,
236 .size = 1,
237 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_RESTORE,
238 },
239 {
240 .entity = UVC_GUID_UVC_CAMERA,
241 .selector = UVC_CT_FOCUS_ABSOLUTE_CONTROL,
242 .index = 5,
243 .size = 2,
244 .flags = UVC_CTRL_FLAG_SET_CUR
245 | UVC_CTRL_FLAG_GET_RANGE
246 | UVC_CTRL_FLAG_RESTORE
247 | UVC_CTRL_FLAG_AUTO_UPDATE,
248 },
249 {
250 .entity = UVC_GUID_UVC_CAMERA,
251 .selector = UVC_CT_FOCUS_RELATIVE_CONTROL,
252 .index = 6,
253 .size = 2,
254 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
255 | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
256 | UVC_CTRL_FLAG_GET_DEF
257 | UVC_CTRL_FLAG_AUTO_UPDATE,
258 },
259 {
260 .entity = UVC_GUID_UVC_CAMERA,
261 .selector = UVC_CT_IRIS_ABSOLUTE_CONTROL,
262 .index = 7,
263 .size = 2,
264 .flags = UVC_CTRL_FLAG_SET_CUR
265 | UVC_CTRL_FLAG_GET_RANGE
266 | UVC_CTRL_FLAG_RESTORE
267 | UVC_CTRL_FLAG_AUTO_UPDATE,
268 },
269 {
270 .entity = UVC_GUID_UVC_CAMERA,
271 .selector = UVC_CT_IRIS_RELATIVE_CONTROL,
272 .index = 8,
273 .size = 1,
274 .flags = UVC_CTRL_FLAG_SET_CUR
275 | UVC_CTRL_FLAG_AUTO_UPDATE,
276 },
277 {
278 .entity = UVC_GUID_UVC_CAMERA,
279 .selector = UVC_CT_ZOOM_ABSOLUTE_CONTROL,
280 .index = 9,
281 .size = 2,
282 .flags = UVC_CTRL_FLAG_SET_CUR
283 | UVC_CTRL_FLAG_GET_RANGE
284 | UVC_CTRL_FLAG_RESTORE
285 | UVC_CTRL_FLAG_AUTO_UPDATE,
286 },
287 {
288 .entity = UVC_GUID_UVC_CAMERA,
289 .selector = UVC_CT_ZOOM_RELATIVE_CONTROL,
290 .index = 10,
291 .size = 3,
292 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
293 | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
294 | UVC_CTRL_FLAG_GET_DEF
295 | UVC_CTRL_FLAG_AUTO_UPDATE,
296 },
297 {
298 .entity = UVC_GUID_UVC_CAMERA,
299 .selector = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
300 .index = 11,
301 .size = 8,
302 .flags = UVC_CTRL_FLAG_SET_CUR
303 | UVC_CTRL_FLAG_GET_RANGE
304 | UVC_CTRL_FLAG_RESTORE
305 | UVC_CTRL_FLAG_AUTO_UPDATE,
306 },
307 {
308 .entity = UVC_GUID_UVC_CAMERA,
309 .selector = UVC_CT_PANTILT_RELATIVE_CONTROL,
310 .index = 12,
311 .size = 4,
312 .flags = UVC_CTRL_FLAG_SET_CUR
313 | UVC_CTRL_FLAG_GET_RANGE
314 | UVC_CTRL_FLAG_AUTO_UPDATE,
315 },
316 {
317 .entity = UVC_GUID_UVC_CAMERA,
318 .selector = UVC_CT_ROLL_ABSOLUTE_CONTROL,
319 .index = 13,
320 .size = 2,
321 .flags = UVC_CTRL_FLAG_SET_CUR
322 | UVC_CTRL_FLAG_GET_RANGE
323 | UVC_CTRL_FLAG_RESTORE
324 | UVC_CTRL_FLAG_AUTO_UPDATE,
325 },
326 {
327 .entity = UVC_GUID_UVC_CAMERA,
328 .selector = UVC_CT_ROLL_RELATIVE_CONTROL,
329 .index = 14,
330 .size = 2,
331 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
332 | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
333 | UVC_CTRL_FLAG_GET_DEF
334 | UVC_CTRL_FLAG_AUTO_UPDATE,
335 },
336 {
337 .entity = UVC_GUID_UVC_CAMERA,
338 .selector = UVC_CT_FOCUS_AUTO_CONTROL,
339 .index = 17,
340 .size = 1,
341 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
342 | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
343 },
344 {
345 .entity = UVC_GUID_UVC_CAMERA,
346 .selector = UVC_CT_PRIVACY_CONTROL,
347 .index = 18,
348 .size = 1,
349 .flags = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
350 | UVC_CTRL_FLAG_RESTORE
351 | UVC_CTRL_FLAG_AUTO_UPDATE,
352 },
353 {
354 .entity = UVC_GUID_EXT_GPIO_CONTROLLER,
355 .selector = UVC_CT_PRIVACY_CONTROL,
356 .index = 0,
357 .size = 1,
358 .flags = UVC_CTRL_FLAG_GET_CUR
359 | UVC_CTRL_FLAG_AUTO_UPDATE,
360 },
361 };
362
363 static const u32 uvc_control_classes[] = {
364 V4L2_CID_CAMERA_CLASS,
365 V4L2_CID_USER_CLASS,
366 };
367
368 static const int exposure_auto_mapping[] = { 2, 1, 4, 8 };
369
370 /*
371 * This function translates the V4L2 menu index @idx, as exposed to userspace as
372 * the V4L2 control value, to the corresponding UVC control value used by the
373 * device. The custom menu_mapping in the control @mapping is used when
374 * available, otherwise the function assumes that the V4L2 and UVC values are
375 * identical.
376 *
377 * For controls of type UVC_CTRL_DATA_TYPE_BITMASK, the UVC control value is
378 * expressed as a bitmask and is thus guaranteed to have a single bit set.
379 *
380 * The function returns -EINVAL if the V4L2 menu index @idx isn't valid for the
381 * control, which includes all controls whose type isn't UVC_CTRL_DATA_TYPE_ENUM
382 * or UVC_CTRL_DATA_TYPE_BITMASK.
383 */
384 static int uvc_mapping_get_menu_value(const struct uvc_control_mapping *mapping,
385 u32 idx)
386 {
387 if (!test_bit(idx, &mapping->menu_mask))
388 return -EINVAL;
389
390 if (mapping->menu_mapping)
391 return mapping->menu_mapping[idx];
392
393 return idx;
394 }
395
396 static const char *
397 uvc_mapping_get_menu_name(const struct uvc_control_mapping *mapping, u32 idx)
398 {
399 if (!test_bit(idx, &mapping->menu_mask))
400 return NULL;
401
402 if (mapping->menu_names)
403 return mapping->menu_names[idx];
404
405 return v4l2_ctrl_get_menu(mapping->id)[idx];
406 }
407
408 static s32 uvc_ctrl_get_zoom(struct uvc_control_mapping *mapping,
409 u8 query, const u8 *data)
410 {
411 s8 zoom = (s8)data[0];
412
413 switch (query) {
414 case UVC_GET_CUR:
415 return (zoom == 0) ? 0 : (zoom > 0 ? data[2] : -data[2]);
416
417 case UVC_GET_MIN:
418 case UVC_GET_MAX:
419 case UVC_GET_RES:
420 case UVC_GET_DEF:
421 default:
422 return data[2];
423 }
424 }
425
426 static void uvc_ctrl_set_zoom(struct uvc_control_mapping *mapping,
427 s32 value, u8 *data)
428 {
429 data[0] = value == 0 ? 0 : (value > 0) ? 1 : 0xff;
430 data[2] = min((int)abs(value), 0xff);
431 }
432
433 static s32 uvc_ctrl_get_rel_speed(struct uvc_control_mapping *mapping,
434 u8 query, const u8 *data)
435 {
436 unsigned int first = mapping->offset / 8;
437 s8 rel = (s8)data[first];
438
439 switch (query) {
440 case UVC_GET_CUR:
441 return (rel == 0) ? 0 : (rel > 0 ? data[first+1]
442 : -data[first+1]);
443 case UVC_GET_MIN:
444 return -data[first+1];
445 case UVC_GET_MAX:
446 case UVC_GET_RES:
447 case UVC_GET_DEF:
448 default:
449 return data[first+1];
450 }
451 }
452
453 static void uvc_ctrl_set_rel_speed(struct uvc_control_mapping *mapping,
454 s32 value, u8 *data)
455 {
456 unsigned int first = mapping->offset / 8;
457
458 data[first] = value == 0 ? 0 : (value > 0) ? 1 : 0xff;
459 data[first+1] = min_t(int, abs(value), 0xff);
460 }
461
462 static const struct uvc_control_mapping uvc_ctrl_power_line_mapping_limited = {
463 .id = V4L2_CID_POWER_LINE_FREQUENCY,
464 .entity = UVC_GUID_UVC_PROCESSING,
465 .selector = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
466 .size = 2,
467 .offset = 0,
468 .v4l2_type = V4L2_CTRL_TYPE_MENU,
469 .data_type = UVC_CTRL_DATA_TYPE_ENUM,
470 .menu_mask = GENMASK(V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
471 V4L2_CID_POWER_LINE_FREQUENCY_50HZ),
472 };
473
474 static const struct uvc_control_mapping uvc_ctrl_power_line_mapping_uvc11 = {
475 .id = V4L2_CID_POWER_LINE_FREQUENCY,
476 .entity = UVC_GUID_UVC_PROCESSING,
477 .selector = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
478 .size = 2,
479 .offset = 0,
480 .v4l2_type = V4L2_CTRL_TYPE_MENU,
481 .data_type = UVC_CTRL_DATA_TYPE_ENUM,
482 .menu_mask = GENMASK(V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
483 V4L2_CID_POWER_LINE_FREQUENCY_DISABLED),
484 };
485
486 static const struct uvc_control_mapping uvc_ctrl_power_line_mapping_uvc15 = {
487 .id = V4L2_CID_POWER_LINE_FREQUENCY,
488 .entity = UVC_GUID_UVC_PROCESSING,
489 .selector = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
490 .size = 2,
491 .offset = 0,
492 .v4l2_type = V4L2_CTRL_TYPE_MENU,
493 .data_type = UVC_CTRL_DATA_TYPE_ENUM,
494 .menu_mask = GENMASK(V4L2_CID_POWER_LINE_FREQUENCY_AUTO,
495 V4L2_CID_POWER_LINE_FREQUENCY_DISABLED),
496 };
497
498 static const struct uvc_control_mapping *uvc_ctrl_filter_plf_mapping(
499 struct uvc_video_chain *chain, struct uvc_control *ctrl)
500 {
501 const struct uvc_control_mapping *out_mapping =
502 &uvc_ctrl_power_line_mapping_uvc11;
503 u8 *buf __free(kfree) = NULL;
504 u8 init_val;
505 int ret;
506
507 buf = kmalloc(sizeof(*buf), GFP_KERNEL);
508 if (!buf)
509 return NULL;
510
511 /* Save the current PLF value, so we can restore it. */
512 ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, ctrl->entity->id,
513 chain->dev->intfnum, ctrl->info.selector,
514 buf, sizeof(*buf));
515 /* If we cannot read the control skip it. */
516 if (ret)
517 return NULL;
518 init_val = *buf;
519
520 /* If PLF value cannot be set to off, it is limited. */
521 *buf = V4L2_CID_POWER_LINE_FREQUENCY_DISABLED;
522 ret = uvc_query_ctrl(chain->dev, UVC_SET_CUR, ctrl->entity->id,
523 chain->dev->intfnum, ctrl->info.selector,
524 buf, sizeof(*buf));
525 if (ret)
526 return &uvc_ctrl_power_line_mapping_limited;
527
528 /* UVC 1.1 does not define auto, we can exit. */
529 if (chain->dev->uvc_version < 0x150)
530 goto end;
531
532 /* Check if the device supports auto. */
533 *buf = V4L2_CID_POWER_LINE_FREQUENCY_AUTO;
534 ret = uvc_query_ctrl(chain->dev, UVC_SET_CUR, ctrl->entity->id,
535 chain->dev->intfnum, ctrl->info.selector,
536 buf, sizeof(*buf));
537 if (!ret)
538 out_mapping = &uvc_ctrl_power_line_mapping_uvc15;
539
540 end:
541 /* Restore initial value and add mapping. */
542 *buf = init_val;
543 uvc_query_ctrl(chain->dev, UVC_SET_CUR, ctrl->entity->id,
544 chain->dev->intfnum, ctrl->info.selector,
545 buf, sizeof(*buf));
546
547 return out_mapping;
548 }
549
550 static const struct uvc_control_mapping uvc_ctrl_mappings[] = {
551 {
552 .id = V4L2_CID_BRIGHTNESS,
553 .entity = UVC_GUID_UVC_PROCESSING,
554 .selector = UVC_PU_BRIGHTNESS_CONTROL,
555 .size = 16,
556 .offset = 0,
557 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
558 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
559 },
560 {
561 .id = V4L2_CID_CONTRAST,
562 .entity = UVC_GUID_UVC_PROCESSING,
563 .selector = UVC_PU_CONTRAST_CONTROL,
564 .size = 16,
565 .offset = 0,
566 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
567 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
568 },
569 {
570 .id = V4L2_CID_HUE,
571 .entity = UVC_GUID_UVC_PROCESSING,
572 .selector = UVC_PU_HUE_CONTROL,
573 .size = 16,
574 .offset = 0,
575 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
576 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
577 .master_id = V4L2_CID_HUE_AUTO,
578 .master_manual = 0,
579 },
580 {
581 .id = V4L2_CID_SATURATION,
582 .entity = UVC_GUID_UVC_PROCESSING,
583 .selector = UVC_PU_SATURATION_CONTROL,
584 .size = 16,
585 .offset = 0,
586 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
587 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
588 },
589 {
590 .id = V4L2_CID_SHARPNESS,
591 .entity = UVC_GUID_UVC_PROCESSING,
592 .selector = UVC_PU_SHARPNESS_CONTROL,
593 .size = 16,
594 .offset = 0,
595 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
596 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
597 },
598 {
599 .id = V4L2_CID_GAMMA,
600 .entity = UVC_GUID_UVC_PROCESSING,
601 .selector = UVC_PU_GAMMA_CONTROL,
602 .size = 16,
603 .offset = 0,
604 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
605 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
606 },
607 {
608 .id = V4L2_CID_BACKLIGHT_COMPENSATION,
609 .entity = UVC_GUID_UVC_PROCESSING,
610 .selector = UVC_PU_BACKLIGHT_COMPENSATION_CONTROL,
611 .size = 16,
612 .offset = 0,
613 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
614 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
615 },
616 {
617 .id = V4L2_CID_GAIN,
618 .entity = UVC_GUID_UVC_PROCESSING,
619 .selector = UVC_PU_GAIN_CONTROL,
620 .size = 16,
621 .offset = 0,
622 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
623 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
624 },
625 {
626 .id = V4L2_CID_HUE_AUTO,
627 .entity = UVC_GUID_UVC_PROCESSING,
628 .selector = UVC_PU_HUE_AUTO_CONTROL,
629 .size = 1,
630 .offset = 0,
631 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
632 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
633 .slave_ids = { V4L2_CID_HUE, },
634 },
635 {
636 .id = V4L2_CID_EXPOSURE_AUTO,
637 .entity = UVC_GUID_UVC_CAMERA,
638 .selector = UVC_CT_AE_MODE_CONTROL,
639 .size = 4,
640 .offset = 0,
641 .v4l2_type = V4L2_CTRL_TYPE_MENU,
642 .data_type = UVC_CTRL_DATA_TYPE_BITMASK,
643 .menu_mapping = exposure_auto_mapping,
644 .menu_mask = GENMASK(V4L2_EXPOSURE_APERTURE_PRIORITY,
645 V4L2_EXPOSURE_AUTO),
646 .slave_ids = { V4L2_CID_EXPOSURE_ABSOLUTE, },
647 },
648 {
649 .id = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
650 .entity = UVC_GUID_UVC_CAMERA,
651 .selector = UVC_CT_AE_PRIORITY_CONTROL,
652 .size = 1,
653 .offset = 0,
654 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
655 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
656 },
657 {
658 .id = V4L2_CID_EXPOSURE_ABSOLUTE,
659 .entity = UVC_GUID_UVC_CAMERA,
660 .selector = UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
661 .size = 32,
662 .offset = 0,
663 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
664 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
665 .master_id = V4L2_CID_EXPOSURE_AUTO,
666 .master_manual = V4L2_EXPOSURE_MANUAL,
667 },
668 {
669 .id = V4L2_CID_AUTO_WHITE_BALANCE,
670 .entity = UVC_GUID_UVC_PROCESSING,
671 .selector = UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
672 .size = 1,
673 .offset = 0,
674 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
675 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
676 .slave_ids = { V4L2_CID_WHITE_BALANCE_TEMPERATURE, },
677 },
678 {
679 .id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
680 .entity = UVC_GUID_UVC_PROCESSING,
681 .selector = UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
682 .size = 16,
683 .offset = 0,
684 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
685 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
686 .master_id = V4L2_CID_AUTO_WHITE_BALANCE,
687 .master_manual = 0,
688 },
689 {
690 .id = V4L2_CID_AUTO_WHITE_BALANCE,
691 .entity = UVC_GUID_UVC_PROCESSING,
692 .selector = UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
693 .size = 1,
694 .offset = 0,
695 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
696 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
697 .slave_ids = { V4L2_CID_BLUE_BALANCE,
698 V4L2_CID_RED_BALANCE },
699 },
700 {
701 .id = V4L2_CID_BLUE_BALANCE,
702 .entity = UVC_GUID_UVC_PROCESSING,
703 .selector = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
704 .size = 16,
705 .offset = 0,
706 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
707 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
708 .master_id = V4L2_CID_AUTO_WHITE_BALANCE,
709 .master_manual = 0,
710 },
711 {
712 .id = V4L2_CID_RED_BALANCE,
713 .entity = UVC_GUID_UVC_PROCESSING,
714 .selector = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
715 .size = 16,
716 .offset = 16,
717 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
718 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
719 .master_id = V4L2_CID_AUTO_WHITE_BALANCE,
720 .master_manual = 0,
721 },
722 {
723 .id = V4L2_CID_FOCUS_ABSOLUTE,
724 .entity = UVC_GUID_UVC_CAMERA,
725 .selector = UVC_CT_FOCUS_ABSOLUTE_CONTROL,
726 .size = 16,
727 .offset = 0,
728 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
729 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
730 .master_id = V4L2_CID_FOCUS_AUTO,
731 .master_manual = 0,
732 },
733 {
734 .id = V4L2_CID_FOCUS_AUTO,
735 .entity = UVC_GUID_UVC_CAMERA,
736 .selector = UVC_CT_FOCUS_AUTO_CONTROL,
737 .size = 1,
738 .offset = 0,
739 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
740 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
741 .slave_ids = { V4L2_CID_FOCUS_ABSOLUTE, },
742 },
743 {
744 .id = V4L2_CID_IRIS_ABSOLUTE,
745 .entity = UVC_GUID_UVC_CAMERA,
746 .selector = UVC_CT_IRIS_ABSOLUTE_CONTROL,
747 .size = 16,
748 .offset = 0,
749 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
750 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
751 },
752 {
753 .id = V4L2_CID_IRIS_RELATIVE,
754 .entity = UVC_GUID_UVC_CAMERA,
755 .selector = UVC_CT_IRIS_RELATIVE_CONTROL,
756 .size = 8,
757 .offset = 0,
758 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
759 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
760 },
761 {
762 .id = V4L2_CID_ZOOM_ABSOLUTE,
763 .entity = UVC_GUID_UVC_CAMERA,
764 .selector = UVC_CT_ZOOM_ABSOLUTE_CONTROL,
765 .size = 16,
766 .offset = 0,
767 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
768 .data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
769 },
770 {
771 .id = V4L2_CID_ZOOM_CONTINUOUS,
772 .entity = UVC_GUID_UVC_CAMERA,
773 .selector = UVC_CT_ZOOM_RELATIVE_CONTROL,
774 .size = 0,
775 .offset = 0,
776 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
777 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
778 .get = uvc_ctrl_get_zoom,
779 .set = uvc_ctrl_set_zoom,
780 },
781 {
782 .id = V4L2_CID_PAN_ABSOLUTE,
783 .entity = UVC_GUID_UVC_CAMERA,
784 .selector = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
785 .size = 32,
786 .offset = 0,
787 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
788 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
789 },
790 {
791 .id = V4L2_CID_TILT_ABSOLUTE,
792 .entity = UVC_GUID_UVC_CAMERA,
793 .selector = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
794 .size = 32,
795 .offset = 32,
796 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
797 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
798 },
799 {
800 .id = V4L2_CID_PAN_SPEED,
801 .entity = UVC_GUID_UVC_CAMERA,
802 .selector = UVC_CT_PANTILT_RELATIVE_CONTROL,
803 .size = 16,
804 .offset = 0,
805 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
806 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
807 .get = uvc_ctrl_get_rel_speed,
808 .set = uvc_ctrl_set_rel_speed,
809 },
810 {
811 .id = V4L2_CID_TILT_SPEED,
812 .entity = UVC_GUID_UVC_CAMERA,
813 .selector = UVC_CT_PANTILT_RELATIVE_CONTROL,
814 .size = 16,
815 .offset = 16,
816 .v4l2_type = V4L2_CTRL_TYPE_INTEGER,
817 .data_type = UVC_CTRL_DATA_TYPE_SIGNED,
818 .get = uvc_ctrl_get_rel_speed,
819 .set = uvc_ctrl_set_rel_speed,
820 },
821 {
822 .id = V4L2_CID_PRIVACY,
823 .entity = UVC_GUID_UVC_CAMERA,
824 .selector = UVC_CT_PRIVACY_CONTROL,
825 .size = 1,
826 .offset = 0,
827 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
828 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
829 },
830 {
831 .id = V4L2_CID_PRIVACY,
832 .entity = UVC_GUID_EXT_GPIO_CONTROLLER,
833 .selector = UVC_CT_PRIVACY_CONTROL,
834 .size = 1,
835 .offset = 0,
836 .v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
837 .data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
838 },
839 {
840 .entity = UVC_GUID_UVC_PROCESSING,
841 .selector = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
842 .filter_mapping = uvc_ctrl_filter_plf_mapping,
843 },
844 };
845
846 /* ------------------------------------------------------------------------
847 * Utility functions
848 */
849
850 static inline u8 *uvc_ctrl_data(struct uvc_control *ctrl, int id)
851 {
852 return ctrl->uvc_data + id * ctrl->info.size;
853 }
854
855 static inline int uvc_test_bit(const u8 *data, int bit)
856 {
857 return (data[bit >> 3] >> (bit & 7)) & 1;
858 }
859
860 static inline void uvc_clear_bit(u8 *data, int bit)
861 {
862 data[bit >> 3] &= ~(1 << (bit & 7));
863 }
864
865 /*
866 * Extract the bit string specified by mapping->offset and mapping->size
867 * from the little-endian data stored at 'data' and return the result as
868 * a signed 32bit integer. Sign extension will be performed if the mapping
869 * references a signed data type.
870 */
871 static s32 uvc_get_le_value(struct uvc_control_mapping *mapping,
872 u8 query, const u8 *data)
873 {
874 int bits = mapping->size;
875 int offset = mapping->offset;
876 s32 value = 0;
877 u8 mask;
878
879 data += offset / 8;
880 offset &= 7;
881 mask = ((1LL << bits) - 1) << offset;
882
883 while (1) {
884 u8 byte = *data & mask;
885 value |= offset > 0 ? (byte >> offset) : (byte << (-offset));
886 bits -= 8 - max(offset, 0);
887 if (bits <= 0)
888 break;
889
890 offset -= 8;
891 mask = (1 << bits) - 1;
892 data++;
893 }
894
895 /* Sign-extend the value if needed. */
896 if (mapping->data_type == UVC_CTRL_DATA_TYPE_SIGNED)
897 value |= -(value & (1 << (mapping->size - 1)));
898
899 return value;
900 }
901
902 /*
903 * Set the bit string specified by mapping->offset and mapping->size
904 * in the little-endian data stored at 'data' to the value 'value'.
905 */
906 static void uvc_set_le_value(struct uvc_control_mapping *mapping,
907 s32 value, u8 *data)
908 {
909 int bits = mapping->size;
910 int offset = mapping->offset;
911 u8 mask;
912
913 /*
914 * According to the v4l2 spec, writing any value to a button control
915 * should result in the action belonging to the button control being
916 * triggered. UVC devices however want to see a 1 written -> override
917 * value.
918 */
919 if (mapping->v4l2_type == V4L2_CTRL_TYPE_BUTTON)
920 value = -1;
921
922 data += offset / 8;
923 offset &= 7;
924
925 for (; bits > 0; data++) {
926 mask = ((1LL << bits) - 1) << offset;
927 *data = (*data & ~mask) | ((value << offset) & mask);
928 value >>= offset ? offset : 8;
929 bits -= 8 - offset;
930 offset = 0;
931 }
932 }
933
934 /* ------------------------------------------------------------------------
935 * Terminal and unit management
936 */
937
938 static int uvc_entity_match_guid(const struct uvc_entity *entity,
939 const u8 guid[16])
940 {
941 return memcmp(entity->guid, guid, sizeof(entity->guid)) == 0;
942 }
943
944 /* ------------------------------------------------------------------------
945 * UVC Controls
946 */
947
948 static void __uvc_find_control(struct uvc_entity *entity, u32 v4l2_id,
949 struct uvc_control_mapping **mapping, struct uvc_control **control,
950 int next)
951 {
952 struct uvc_control *ctrl;
953 struct uvc_control_mapping *map;
954 unsigned int i;
955
956 if (entity == NULL)
957 return;
958
959 for (i = 0; i < entity->ncontrols; ++i) {
960 ctrl = &entity->controls[i];
961 if (!ctrl->initialized)
962 continue;
963
964 list_for_each_entry(map, &ctrl->info.mappings, list) {
965 if ((map->id == v4l2_id) && !next) {
966 *control = ctrl;
967 *mapping = map;
968 return;
969 }
970
971 if ((*mapping == NULL || (*mapping)->id > map->id) &&
972 (map->id > v4l2_id) && next) {
973 *control = ctrl;
974 *mapping = map;
975 }
976 }
977 }
978 }
979
980 static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
981 u32 v4l2_id, struct uvc_control_mapping **mapping)
982 {
983 struct uvc_control *ctrl = NULL;
984 struct uvc_entity *entity;
985 int next = v4l2_id & V4L2_CTRL_FLAG_NEXT_CTRL;
986
987 *mapping = NULL;
988
989 /* Mask the query flags. */
990 v4l2_id &= V4L2_CTRL_ID_MASK;
991
992 /* Find the control. */
993 list_for_each_entry(entity, &chain->entities, chain) {
994 __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
995 if (ctrl && !next)
996 return ctrl;
997 }
998
999 if (ctrl == NULL && !next)
1000 uvc_dbg(chain->dev, CONTROL, "Control 0x%08x not found\n",
1001 v4l2_id);
1002
1003 return ctrl;
1004 }
1005
1006 static int uvc_ctrl_populate_cache(struct uvc_video_chain *chain,
1007 struct uvc_control *ctrl)
1008 {
1009 int ret;
1010
1011 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_DEF) {
1012 ret = uvc_query_ctrl(chain->dev, UVC_GET_DEF, ctrl->entity->id,
1013 chain->dev->intfnum, ctrl->info.selector,
1014 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF),
1015 ctrl->info.size);
1016 if (ret < 0)
1017 return ret;
1018 }
1019
1020 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MIN) {
1021 ret = uvc_query_ctrl(chain->dev, UVC_GET_MIN, ctrl->entity->id,
1022 chain->dev->intfnum, ctrl->info.selector,
1023 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN),
1024 ctrl->info.size);
1025 if (ret < 0)
1026 return ret;
1027 }
1028 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MAX) {
1029 ret = uvc_query_ctrl(chain->dev, UVC_GET_MAX, ctrl->entity->id,
1030 chain->dev->intfnum, ctrl->info.selector,
1031 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX),
1032 ctrl->info.size);
1033 if (ret < 0)
1034 return ret;
1035 }
1036 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES) {
1037 ret = uvc_query_ctrl(chain->dev, UVC_GET_RES, ctrl->entity->id,
1038 chain->dev->intfnum, ctrl->info.selector,
1039 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES),
1040 ctrl->info.size);
1041 if (ret < 0) {
1042 if (UVC_ENTITY_TYPE(ctrl->entity) !=
1043 UVC_VC_EXTENSION_UNIT)
1044 return ret;
1045
1046 /*
1047 * GET_RES is mandatory for XU controls, but some
1048 * cameras still choke on it. Ignore errors and set the
1049 * resolution value to zero.
1050 */
1051 uvc_warn_once(chain->dev, UVC_WARN_XU_GET_RES,
1052 "UVC non compliance - GET_RES failed on "
1053 "an XU control. Enabling workaround.\n");
1054 memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES), 0,
1055 ctrl->info.size);
1056 }
1057 }
1058
1059 ctrl->cached = 1;
1060 return 0;
1061 }
1062
1063 static s32 __uvc_ctrl_get_value(struct uvc_control_mapping *mapping,
1064 const u8 *data)
1065 {
1066 s32 value = mapping->get(mapping, UVC_GET_CUR, data);
1067
1068 if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
1069 unsigned int i;
1070
1071 for (i = 0; BIT(i) <= mapping->menu_mask; ++i) {
1072 u32 menu_value;
1073
1074 if (!test_bit(i, &mapping->menu_mask))
1075 continue;
1076
1077 menu_value = uvc_mapping_get_menu_value(mapping, i);
1078
1079 if (menu_value == value) {
1080 value = i;
1081 break;
1082 }
1083 }
1084 }
1085
1086 return value;
1087 }
1088
1089 static int __uvc_ctrl_load_cur(struct uvc_video_chain *chain,
1090 struct uvc_control *ctrl)
1091 {
1092 u8 *data;
1093 int ret;
1094
1095 if (ctrl->loaded)
1096 return 0;
1097
1098 data = uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT);
1099
1100 if ((ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) == 0) {
1101 memset(data, 0, ctrl->info.size);
1102 ctrl->loaded = 1;
1103
1104 return 0;
1105 }
1106
1107 if (ctrl->entity->get_cur)
1108 ret = ctrl->entity->get_cur(chain->dev, ctrl->entity,
1109 ctrl->info.selector, data,
1110 ctrl->info.size);
1111 else
1112 ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
1113 ctrl->entity->id, chain->dev->intfnum,
1114 ctrl->info.selector, data,
1115 ctrl->info.size);
1116
1117 if (ret < 0)
1118 return ret;
1119
1120 ctrl->loaded = 1;
1121
1122 return ret;
1123 }
1124
1125 static int __uvc_ctrl_get(struct uvc_video_chain *chain,
1126 struct uvc_control *ctrl,
1127 struct uvc_control_mapping *mapping,
1128 s32 *value)
1129 {
1130 int ret;
1131
1132 if ((ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) == 0)
1133 return -EACCES;
1134
1135 ret = __uvc_ctrl_load_cur(chain, ctrl);
1136 if (ret < 0)
1137 return ret;
1138
1139 *value = __uvc_ctrl_get_value(mapping,
1140 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT));
1141
1142 return 0;
1143 }
1144
1145 static int __uvc_query_v4l2_class(struct uvc_video_chain *chain, u32 req_id,
1146 u32 found_id)
1147 {
1148 bool find_next = req_id & V4L2_CTRL_FLAG_NEXT_CTRL;
1149 unsigned int i;
1150
1151 req_id &= V4L2_CTRL_ID_MASK;
1152
1153 for (i = 0; i < ARRAY_SIZE(uvc_control_classes); i++) {
1154 if (!(chain->ctrl_class_bitmap & BIT(i)))
1155 continue;
1156 if (!find_next) {
1157 if (uvc_control_classes[i] == req_id)
1158 return i;
1159 continue;
1160 }
1161 if (uvc_control_classes[i] > req_id &&
1162 uvc_control_classes[i] < found_id)
1163 return i;
1164 }
1165
1166 return -ENODEV;
1167 }
1168
1169 static int uvc_query_v4l2_class(struct uvc_video_chain *chain, u32 req_id,
1170 u32 found_id, struct v4l2_queryctrl *v4l2_ctrl)
1171 {
1172 int idx;
1173
1174 idx = __uvc_query_v4l2_class(chain, req_id, found_id);
1175 if (idx < 0)
1176 return -ENODEV;
1177
1178 memset(v4l2_ctrl, 0, sizeof(*v4l2_ctrl));
1179 v4l2_ctrl->id = uvc_control_classes[idx];
1180 strscpy(v4l2_ctrl->name, v4l2_ctrl_get_name(v4l2_ctrl->id),
1181 sizeof(v4l2_ctrl->name));
1182 v4l2_ctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
1183 v4l2_ctrl->flags = V4L2_CTRL_FLAG_WRITE_ONLY
1184 | V4L2_CTRL_FLAG_READ_ONLY;
1185 return 0;
1186 }
1187
1188 /*
1189 * Check if control @v4l2_id can be accessed by the given control @ioctl
1190 * (VIDIOC_G_EXT_CTRLS, VIDIOC_TRY_EXT_CTRLS or VIDIOC_S_EXT_CTRLS).
1191 *
1192 * For set operations on slave controls, check if the master's value is set to
1193 * manual, either in the others controls set in the same ioctl call, or from
1194 * the master's current value. This catches VIDIOC_S_EXT_CTRLS calls that set
1195 * both the master and slave control, such as for instance setting
1196 * auto_exposure=1, exposure_time_absolute=251.
1197 */
1198 int uvc_ctrl_is_accessible(struct uvc_video_chain *chain, u32 v4l2_id,
1199 const struct v4l2_ext_controls *ctrls,
1200 unsigned long ioctl)
1201 {
1202 struct uvc_control_mapping *master_map = NULL;
1203 struct uvc_control *master_ctrl = NULL;
1204 struct uvc_control_mapping *mapping;
1205 struct uvc_control *ctrl;
1206 bool read = ioctl == VIDIOC_G_EXT_CTRLS;
1207 s32 val;
1208 int ret;
1209 int i;
1210
1211 if (__uvc_query_v4l2_class(chain, v4l2_id, 0) >= 0)
1212 return -EACCES;
1213
1214 ctrl = uvc_find_control(chain, v4l2_id, &mapping);
1215 if (!ctrl)
1216 return -EINVAL;
1217
1218 if (!(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) && read)
1219 return -EACCES;
1220
1221 if (!(ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR) && !read)
1222 return -EACCES;
1223
1224 if (ioctl != VIDIOC_S_EXT_CTRLS || !mapping->master_id)
1225 return 0;
1226
1227 /*
1228 * Iterate backwards in cases where the master control is accessed
1229 * multiple times in the same ioctl. We want the last value.
1230 */
1231 for (i = ctrls->count - 1; i >= 0; i--) {
1232 if (ctrls->controls[i].id == mapping->master_id)
1233 return ctrls->controls[i].value ==
1234 mapping->master_manual ? 0 : -EACCES;
1235 }
1236
1237 __uvc_find_control(ctrl->entity, mapping->master_id, &master_map,
1238 &master_ctrl, 0);
1239
1240 if (!master_ctrl || !(master_ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
1241 return 0;
1242
1243 ret = __uvc_ctrl_get(chain, master_ctrl, master_map, &val);
1244 if (ret >= 0 && val != mapping->master_manual)
1245 return -EACCES;
1246
1247 return 0;
1248 }
1249
1250 static const char *uvc_map_get_name(const struct uvc_control_mapping *map)
1251 {
1252 const char *name;
1253
1254 if (map->name)
1255 return map->name;
1256
1257 name = v4l2_ctrl_get_name(map->id);
1258 if (name)
1259 return name;
1260
1261 return "Unknown Control";
1262 }
1263
1264 static u32 uvc_get_ctrl_bitmap(struct uvc_control *ctrl,
1265 struct uvc_control_mapping *mapping)
1266 {
1267 /*
1268 * Some controls, like CT_AE_MODE_CONTROL, use GET_RES to represent
1269 * the number of bits supported. Those controls do not list GET_MAX
1270 * as supported.
1271 */
1272 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES)
1273 return mapping->get(mapping, UVC_GET_RES,
1274 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
1275
1276 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MAX)
1277 return mapping->get(mapping, UVC_GET_MAX,
1278 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX));
1279
1280 return ~0;
1281 }
1282
1283 static int __uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
1284 struct uvc_control *ctrl,
1285 struct uvc_control_mapping *mapping,
1286 struct v4l2_queryctrl *v4l2_ctrl)
1287 {
1288 struct uvc_control_mapping *master_map = NULL;
1289 struct uvc_control *master_ctrl = NULL;
1290 unsigned int i;
1291
1292 memset(v4l2_ctrl, 0, sizeof(*v4l2_ctrl));
1293 v4l2_ctrl->id = mapping->id;
1294 v4l2_ctrl->type = mapping->v4l2_type;
1295 strscpy(v4l2_ctrl->name, uvc_map_get_name(mapping),
1296 sizeof(v4l2_ctrl->name));
1297 v4l2_ctrl->flags = 0;
1298
1299 if (!(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
1300 v4l2_ctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1301 if (!(ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR))
1302 v4l2_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1303
1304 if (mapping->master_id)
1305 __uvc_find_control(ctrl->entity, mapping->master_id,
1306 &master_map, &master_ctrl, 0);
1307 if (master_ctrl && (master_ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR)) {
1308 s32 val;
1309 int ret = __uvc_ctrl_get(chain, master_ctrl, master_map, &val);
1310 if (ret < 0)
1311 return ret;
1312
1313 if (val != mapping->master_manual)
1314 v4l2_ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1315 }
1316
1317 if (!ctrl->cached) {
1318 int ret = uvc_ctrl_populate_cache(chain, ctrl);
1319 if (ret < 0)
1320 return ret;
1321 }
1322
1323 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_DEF) {
1324 v4l2_ctrl->default_value = mapping->get(mapping, UVC_GET_DEF,
1325 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF));
1326 }
1327
1328 switch (mapping->v4l2_type) {
1329 case V4L2_CTRL_TYPE_MENU:
1330 v4l2_ctrl->minimum = ffs(mapping->menu_mask) - 1;
1331 v4l2_ctrl->maximum = fls(mapping->menu_mask) - 1;
1332 v4l2_ctrl->step = 1;
1333
1334 for (i = 0; BIT(i) <= mapping->menu_mask; ++i) {
1335 u32 menu_value;
1336
1337 if (!test_bit(i, &mapping->menu_mask))
1338 continue;
1339
1340 menu_value = uvc_mapping_get_menu_value(mapping, i);
1341
1342 if (menu_value == v4l2_ctrl->default_value) {
1343 v4l2_ctrl->default_value = i;
1344 break;
1345 }
1346 }
1347
1348 return 0;
1349
1350 case V4L2_CTRL_TYPE_BOOLEAN:
1351 v4l2_ctrl->minimum = 0;
1352 v4l2_ctrl->maximum = 1;
1353 v4l2_ctrl->step = 1;
1354 return 0;
1355
1356 case V4L2_CTRL_TYPE_BUTTON:
1357 v4l2_ctrl->minimum = 0;
1358 v4l2_ctrl->maximum = 0;
1359 v4l2_ctrl->step = 0;
1360 return 0;
1361
1362 case V4L2_CTRL_TYPE_BITMASK:
1363 v4l2_ctrl->minimum = 0;
1364 v4l2_ctrl->maximum = uvc_get_ctrl_bitmap(ctrl, mapping);
1365 v4l2_ctrl->step = 0;
1366 return 0;
1367
1368 default:
1369 break;
1370 }
1371
1372 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MIN)
1373 v4l2_ctrl->minimum = mapping->get(mapping, UVC_GET_MIN,
1374 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN));
1375
1376 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MAX)
1377 v4l2_ctrl->maximum = mapping->get(mapping, UVC_GET_MAX,
1378 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX));
1379
1380 if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES)
1381 v4l2_ctrl->step = mapping->get(mapping, UVC_GET_RES,
1382 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
1383
1384 return 0;
1385 }
1386
1387 int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
1388 struct v4l2_queryctrl *v4l2_ctrl)
1389 {
1390 struct uvc_control *ctrl;
1391 struct uvc_control_mapping *mapping;
1392 int ret;
1393
1394 ret = mutex_lock_interruptible(&chain->ctrl_mutex);
1395 if (ret < 0)
1396 return -ERESTARTSYS;
1397
1398 /* Check if the ctrl is a know class */
1399 if (!(v4l2_ctrl->id & V4L2_CTRL_FLAG_NEXT_CTRL)) {
1400 ret = uvc_query_v4l2_class(chain, v4l2_ctrl->id, 0, v4l2_ctrl);
1401 if (!ret)
1402 goto done;
1403 }
1404
1405 ctrl = uvc_find_control(chain, v4l2_ctrl->id, &mapping);
1406 if (ctrl == NULL) {
1407 ret = -EINVAL;
1408 goto done;
1409 }
1410
1411 /*
1412 * If we're enumerating control with V4L2_CTRL_FLAG_NEXT_CTRL, check if
1413 * a class should be inserted between the previous control and the one
1414 * we have just found.
1415 */
1416 if (v4l2_ctrl->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
1417 ret = uvc_query_v4l2_class(chain, v4l2_ctrl->id, mapping->id,
1418 v4l2_ctrl);
1419 if (!ret)
1420 goto done;
1421 }
1422
1423 ret = __uvc_query_v4l2_ctrl(chain, ctrl, mapping, v4l2_ctrl);
1424 done:
1425 mutex_unlock(&chain->ctrl_mutex);
1426 return ret;
1427 }
1428
1429 /*
1430 * Mapping V4L2 controls to UVC controls can be straightforward if done well.
1431 * Most of the UVC controls exist in V4L2, and can be mapped directly. Some
1432 * must be grouped (for instance the Red Balance, Blue Balance and Do White
1433 * Balance V4L2 controls use the White Balance Component UVC control) or
1434 * otherwise translated. The approach we take here is to use a translation
1435 * table for the controls that can be mapped directly, and handle the others
1436 * manually.
1437 */
1438 int uvc_query_v4l2_menu(struct uvc_video_chain *chain,
1439 struct v4l2_querymenu *query_menu)
1440 {
1441 struct uvc_control_mapping *mapping;
1442 struct uvc_control *ctrl;
1443 u32 index = query_menu->index;
1444 u32 id = query_menu->id;
1445 const char *name;
1446 int ret;
1447
1448 memset(query_menu, 0, sizeof(*query_menu));
1449 query_menu->id = id;
1450 query_menu->index = index;
1451
1452 if (index >= BITS_PER_TYPE(mapping->menu_mask))
1453 return -EINVAL;
1454
1455 ret = mutex_lock_interruptible(&chain->ctrl_mutex);
1456 if (ret < 0)
1457 return -ERESTARTSYS;
1458
1459 ctrl = uvc_find_control(chain, query_menu->id, &mapping);
1460 if (ctrl == NULL || mapping->v4l2_type != V4L2_CTRL_TYPE_MENU) {
1461 ret = -EINVAL;
1462 goto done;
1463 }
1464
1465 if (!test_bit(query_menu->index, &mapping->menu_mask)) {
1466 ret = -EINVAL;
1467 goto done;
1468 }
1469
1470 if (mapping->data_type == UVC_CTRL_DATA_TYPE_BITMASK) {
1471 int mask;
1472
1473 if (!ctrl->cached) {
1474 ret = uvc_ctrl_populate_cache(chain, ctrl);
1475 if (ret < 0)
1476 goto done;
1477 }
1478
1479 mask = uvc_mapping_get_menu_value(mapping, query_menu->index);
1480 if (mask < 0) {
1481 ret = mask;
1482 goto done;
1483 }
1484
1485 if (!(uvc_get_ctrl_bitmap(ctrl, mapping) & mask)) {
1486 ret = -EINVAL;
1487 goto done;
1488 }
1489 }
1490
1491 name = uvc_mapping_get_menu_name(mapping, query_menu->index);
1492 if (!name) {
1493 ret = -EINVAL;
1494 goto done;
1495 }
1496
1497 strscpy(query_menu->name, name, sizeof(query_menu->name));
1498
1499 done:
1500 mutex_unlock(&chain->ctrl_mutex);
1501 return ret;
1502 }
1503
1504 /* --------------------------------------------------------------------------
1505 * Ctrl event handling
1506 */
1507
1508 static void uvc_ctrl_fill_event(struct uvc_video_chain *chain,
1509 struct v4l2_event *ev,
1510 struct uvc_control *ctrl,
1511 struct uvc_control_mapping *mapping,
1512 s32 value, u32 changes)
1513 {
1514 struct v4l2_queryctrl v4l2_ctrl;
1515
1516 __uvc_query_v4l2_ctrl(chain, ctrl, mapping, &v4l2_ctrl);
1517
1518 memset(ev, 0, sizeof(*ev));
1519 ev->type = V4L2_EVENT_CTRL;
1520 ev->id = v4l2_ctrl.id;
1521 ev->u.ctrl.value = value;
1522 ev->u.ctrl.changes = changes;
1523 ev->u.ctrl.type = v4l2_ctrl.type;
1524 ev->u.ctrl.flags = v4l2_ctrl.flags;
1525 ev->u.ctrl.minimum = v4l2_ctrl.minimum;
1526 ev->u.ctrl.maximum = v4l2_ctrl.maximum;
1527 ev->u.ctrl.step = v4l2_ctrl.step;
1528 ev->u.ctrl.default_value = v4l2_ctrl.default_value;
1529 }
1530
1531 /*
1532 * Send control change events to all subscribers for the @ctrl control. By
1533 * default the subscriber that generated the event, as identified by @handle,
1534 * is not notified unless it has set the V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK flag.
1535 * @handle can be NULL for asynchronous events related to auto-update controls,
1536 * in which case all subscribers are notified.
1537 */
1538 static void uvc_ctrl_send_event(struct uvc_video_chain *chain,
1539 struct uvc_fh *handle, struct uvc_control *ctrl,
1540 struct uvc_control_mapping *mapping, s32 value, u32 changes)
1541 {
1542 struct v4l2_fh *originator = handle ? &handle->vfh : NULL;
1543 struct v4l2_subscribed_event *sev;
1544 struct v4l2_event ev;
1545
1546 if (list_empty(&mapping->ev_subs))
1547 return;
1548
1549 uvc_ctrl_fill_event(chain, &ev, ctrl, mapping, value, changes);
1550
1551 list_for_each_entry(sev, &mapping->ev_subs, node) {
1552 if (sev->fh != originator ||
1553 (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK) ||
1554 (changes & V4L2_EVENT_CTRL_CH_FLAGS))
1555 v4l2_event_queue_fh(sev->fh, &ev);
1556 }
1557 }
1558
1559 /*
1560 * Send control change events for the slave of the @master control identified
1561 * by the V4L2 ID @slave_id. The @handle identifies the event subscriber that
1562 * generated the event and may be NULL for auto-update events.
1563 */
1564 static void uvc_ctrl_send_slave_event(struct uvc_video_chain *chain,
1565 struct uvc_fh *handle, struct uvc_control *master, u32 slave_id)
1566 {
1567 struct uvc_control_mapping *mapping = NULL;
1568 struct uvc_control *ctrl = NULL;
1569 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
1570 s32 val = 0;
1571
1572 __uvc_find_control(master->entity, slave_id, &mapping, &ctrl, 0);
1573 if (ctrl == NULL)
1574 return;
1575
1576 if (__uvc_ctrl_get(chain, ctrl, mapping, &val) == 0)
1577 changes |= V4L2_EVENT_CTRL_CH_VALUE;
1578
1579 uvc_ctrl_send_event(chain, handle, ctrl, mapping, val, changes);
1580 }
1581
1582 void uvc_ctrl_status_event(struct uvc_video_chain *chain,
1583 struct uvc_control *ctrl, const u8 *data)
1584 {
1585 struct uvc_control_mapping *mapping;
1586 struct uvc_fh *handle;
1587 unsigned int i;
1588
1589 mutex_lock(&chain->ctrl_mutex);
1590
1591 handle = ctrl->handle;
1592 ctrl->handle = NULL;
1593
1594 list_for_each_entry(mapping, &ctrl->info.mappings, list) {
1595 s32 value = __uvc_ctrl_get_value(mapping, data);
1596
1597 /*
1598 * handle may be NULL here if the device sends auto-update
1599 * events without a prior related control set from userspace.
1600 */
1601 for (i = 0; i < ARRAY_SIZE(mapping->slave_ids); ++i) {
1602 if (!mapping->slave_ids[i])
1603 break;
1604
1605 uvc_ctrl_send_slave_event(chain, handle, ctrl,
1606 mapping->slave_ids[i]);
1607 }
1608
1609 uvc_ctrl_send_event(chain, handle, ctrl, mapping, value,
1610 V4L2_EVENT_CTRL_CH_VALUE);
1611 }
1612
1613 mutex_unlock(&chain->ctrl_mutex);
1614 }
1615
1616 static void uvc_ctrl_status_event_work(struct work_struct *work)
1617 {
1618 struct uvc_device *dev = container_of(work, struct uvc_device,
1619 async_ctrl.work);
1620 struct uvc_ctrl_work *w = &dev->async_ctrl;
1621 int ret;
1622
1623 uvc_ctrl_status_event(w->chain, w->ctrl, w->data);
1624
1625 /* The barrier is needed to synchronize with uvc_status_stop(). */
1626 if (smp_load_acquire(&dev->flush_status))
1627 return;
1628
1629 /* Resubmit the URB. */
1630 w->urb->interval = dev->int_ep->desc.bInterval;
1631 ret = usb_submit_urb(w->urb, GFP_KERNEL);
1632 if (ret < 0)
1633 dev_err(&dev->udev->dev,
1634 "Failed to resubmit status URB (%d).\n", ret);
1635 }
1636
1637 bool uvc_ctrl_status_event_async(struct urb *urb, struct uvc_video_chain *chain,
1638 struct uvc_control *ctrl, const u8 *data)
1639 {
1640 struct uvc_device *dev = chain->dev;
1641 struct uvc_ctrl_work *w = &dev->async_ctrl;
1642
1643 if (list_empty(&ctrl->info.mappings)) {
1644 ctrl->handle = NULL;
1645 return false;
1646 }
1647
1648 w->data = data;
1649 w->urb = urb;
1650 w->chain = chain;
1651 w->ctrl = ctrl;
1652
1653 schedule_work(&w->work);
1654
1655 return true;
1656 }
1657
1658 static bool uvc_ctrl_xctrls_has_control(const struct v4l2_ext_control *xctrls,
1659 unsigned int xctrls_count, u32 id)
1660 {
1661 unsigned int i;
1662
1663 for (i = 0; i < xctrls_count; ++i) {
1664 if (xctrls[i].id == id)
1665 return true;
1666 }
1667
1668 return false;
1669 }
1670
1671 static void uvc_ctrl_send_events(struct uvc_fh *handle,
1672 const struct v4l2_ext_control *xctrls, unsigned int xctrls_count)
1673 {
1674 struct uvc_control_mapping *mapping;
1675 struct uvc_control *ctrl;
1676 u32 changes = V4L2_EVENT_CTRL_CH_VALUE;
1677 unsigned int i;
1678 unsigned int j;
1679
1680 for (i = 0; i < xctrls_count; ++i) {
1681 ctrl = uvc_find_control(handle->chain, xctrls[i].id, &mapping);
1682
1683 if (ctrl->info.flags & UVC_CTRL_FLAG_ASYNCHRONOUS)
1684 /* Notification will be sent from an Interrupt event. */
1685 continue;
1686
1687 for (j = 0; j < ARRAY_SIZE(mapping->slave_ids); ++j) {
1688 u32 slave_id = mapping->slave_ids[j];
1689
1690 if (!slave_id)
1691 break;
1692
1693 /*
1694 * We can skip sending an event for the slave if the
1695 * slave is being modified in the same transaction.
1696 */
1697 if (uvc_ctrl_xctrls_has_control(xctrls, xctrls_count,
1698 slave_id))
1699 continue;
1700
1701 uvc_ctrl_send_slave_event(handle->chain, handle, ctrl,
1702 slave_id);
1703 }
1704
1705 /*
1706 * If the master is being modified in the same transaction
1707 * flags may change too.
1708 */
1709 if (mapping->master_id &&
1710 uvc_ctrl_xctrls_has_control(xctrls, xctrls_count,
1711 mapping->master_id))
1712 changes |= V4L2_EVENT_CTRL_CH_FLAGS;
1713
1714 uvc_ctrl_send_event(handle->chain, handle, ctrl, mapping,
1715 xctrls[i].value, changes);
1716 }
1717 }
1718
1719 static int uvc_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
1720 {
1721 struct uvc_fh *handle = container_of(sev->fh, struct uvc_fh, vfh);
1722 struct uvc_control_mapping *mapping;
1723 struct uvc_control *ctrl;
1724 int ret;
1725
1726 ret = mutex_lock_interruptible(&handle->chain->ctrl_mutex);
1727 if (ret < 0)
1728 return -ERESTARTSYS;
1729
1730 if (__uvc_query_v4l2_class(handle->chain, sev->id, 0) >= 0) {
1731 ret = 0;
1732 goto done;
1733 }
1734
1735 ctrl = uvc_find_control(handle->chain, sev->id, &mapping);
1736 if (ctrl == NULL) {
1737 ret = -EINVAL;
1738 goto done;
1739 }
1740
1741 list_add_tail(&sev->node, &mapping->ev_subs);
1742 if (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL) {
1743 struct v4l2_event ev;
1744 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
1745 s32 val = 0;
1746
1747 if (__uvc_ctrl_get(handle->chain, ctrl, mapping, &val) == 0)
1748 changes |= V4L2_EVENT_CTRL_CH_VALUE;
1749
1750 uvc_ctrl_fill_event(handle->chain, &ev, ctrl, mapping, val,
1751 changes);
1752 /*
1753 * Mark the queue as active, allowing this initial event to be
1754 * accepted.
1755 */
1756 sev->elems = elems;
1757 v4l2_event_queue_fh(sev->fh, &ev);
1758 }
1759
1760 done:
1761 mutex_unlock(&handle->chain->ctrl_mutex);
1762 return ret;
1763 }
1764
1765 static void uvc_ctrl_del_event(struct v4l2_subscribed_event *sev)
1766 {
1767 struct uvc_fh *handle = container_of(sev->fh, struct uvc_fh, vfh);
1768
1769 mutex_lock(&handle->chain->ctrl_mutex);
1770 if (__uvc_query_v4l2_class(handle->chain, sev->id, 0) >= 0)
1771 goto done;
1772 list_del(&sev->node);
1773 done:
1774 mutex_unlock(&handle->chain->ctrl_mutex);
1775 }
1776
1777 const struct v4l2_subscribed_event_ops uvc_ctrl_sub_ev_ops = {
1778 .add = uvc_ctrl_add_event,
1779 .del = uvc_ctrl_del_event,
1780 .replace = v4l2_ctrl_replace,
1781 .merge = v4l2_ctrl_merge,
1782 };
1783
1784 /* --------------------------------------------------------------------------
1785 * Control transactions
1786 *
1787 * To make extended set operations as atomic as the hardware allows, controls
1788 * are handled using begin/commit/rollback operations.
1789 *
1790 * At the beginning of a set request, uvc_ctrl_begin should be called to
1791 * initialize the request. This function acquires the control lock.
1792 *
1793 * When setting a control, the new value is stored in the control data field
1794 * at position UVC_CTRL_DATA_CURRENT. The control is then marked as dirty for
1795 * later processing. If the UVC and V4L2 control sizes differ, the current
1796 * value is loaded from the hardware before storing the new value in the data
1797 * field.
1798 *
1799 * After processing all controls in the transaction, uvc_ctrl_commit or
1800 * uvc_ctrl_rollback must be called to apply the pending changes to the
1801 * hardware or revert them. When applying changes, all controls marked as
1802 * dirty will be modified in the UVC device, and the dirty flag will be
1803 * cleared. When reverting controls, the control data field
1804 * UVC_CTRL_DATA_CURRENT is reverted to its previous value
1805 * (UVC_CTRL_DATA_BACKUP) for all dirty controls. Both functions release the
1806 * control lock.
1807 */
1808 int uvc_ctrl_begin(struct uvc_video_chain *chain)
1809 {
1810 return mutex_lock_interruptible(&chain->ctrl_mutex) ? -ERESTARTSYS : 0;
1811 }
1812
1813 static int uvc_ctrl_commit_entity(struct uvc_device *dev,
1814 struct uvc_entity *entity, int rollback, struct uvc_control **err_ctrl)
1815 {
1816 struct uvc_control *ctrl;
1817 unsigned int i;
1818 int ret;
1819
1820 if (entity == NULL)
1821 return 0;
1822
1823 for (i = 0; i < entity->ncontrols; ++i) {
1824 ctrl = &entity->controls[i];
1825 if (!ctrl->initialized)
1826 continue;
1827
1828 /*
1829 * Reset the loaded flag for auto-update controls that were
1830 * marked as loaded in uvc_ctrl_get/uvc_ctrl_set to prevent
1831 * uvc_ctrl_get from using the cached value, and for write-only
1832 * controls to prevent uvc_ctrl_set from setting bits not
1833 * explicitly set by the user.
1834 */
1835 if (ctrl->info.flags & UVC_CTRL_FLAG_AUTO_UPDATE ||
1836 !(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
1837 ctrl->loaded = 0;
1838
1839 if (!ctrl->dirty)
1840 continue;
1841
1842 if (!rollback)
1843 ret = uvc_query_ctrl(dev, UVC_SET_CUR, ctrl->entity->id,
1844 dev->intfnum, ctrl->info.selector,
1845 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1846 ctrl->info.size);
1847 else
1848 ret = 0;
1849
1850 if (rollback || ret < 0)
1851 memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1852 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
1853 ctrl->info.size);
1854
1855 ctrl->dirty = 0;
1856
1857 if (ret < 0) {
1858 if (err_ctrl)
1859 *err_ctrl = ctrl;
1860 return ret;
1861 }
1862 }
1863
1864 return 0;
1865 }
1866
1867 static int uvc_ctrl_find_ctrl_idx(struct uvc_entity *entity,
1868 struct v4l2_ext_controls *ctrls,
1869 struct uvc_control *uvc_control)
1870 {
1871 struct uvc_control_mapping *mapping = NULL;
1872 struct uvc_control *ctrl_found = NULL;
1873 unsigned int i;
1874
1875 if (!entity)
1876 return ctrls->count;
1877
1878 for (i = 0; i < ctrls->count; i++) {
1879 __uvc_find_control(entity, ctrls->controls[i].id, &mapping,
1880 &ctrl_found, 0);
1881 if (uvc_control == ctrl_found)
1882 return i;
1883 }
1884
1885 return ctrls->count;
1886 }
1887
1888 int __uvc_ctrl_commit(struct uvc_fh *handle, int rollback,
1889 struct v4l2_ext_controls *ctrls)
1890 {
1891 struct uvc_video_chain *chain = handle->chain;
1892 struct uvc_control *err_ctrl;
1893 struct uvc_entity *entity;
1894 int ret = 0;
1895
1896 /* Find the control. */
1897 list_for_each_entry(entity, &chain->entities, chain) {
1898 ret = uvc_ctrl_commit_entity(chain->dev, entity, rollback,
1899 &err_ctrl);
1900 if (ret < 0) {
1901 if (ctrls)
1902 ctrls->error_idx =
1903 uvc_ctrl_find_ctrl_idx(entity, ctrls,
1904 err_ctrl);
1905 goto done;
1906 }
1907 }
1908
1909 if (!rollback)
1910 uvc_ctrl_send_events(handle, ctrls->controls, ctrls->count);
1911 done:
1912 mutex_unlock(&chain->ctrl_mutex);
1913 return ret;
1914 }
1915
1916 int uvc_ctrl_get(struct uvc_video_chain *chain,
1917 struct v4l2_ext_control *xctrl)
1918 {
1919 struct uvc_control *ctrl;
1920 struct uvc_control_mapping *mapping;
1921
1922 if (__uvc_query_v4l2_class(chain, xctrl->id, 0) >= 0)
1923 return -EACCES;
1924
1925 ctrl = uvc_find_control(chain, xctrl->id, &mapping);
1926 if (ctrl == NULL)
1927 return -EINVAL;
1928
1929 return __uvc_ctrl_get(chain, ctrl, mapping, &xctrl->value);
1930 }
1931
1932 int uvc_ctrl_set(struct uvc_fh *handle,
1933 struct v4l2_ext_control *xctrl)
1934 {
1935 struct uvc_video_chain *chain = handle->chain;
1936 struct uvc_control *ctrl;
1937 struct uvc_control_mapping *mapping;
1938 s32 value;
1939 u32 step;
1940 s32 min;
1941 s32 max;
1942 int ret;
1943
1944 if (__uvc_query_v4l2_class(chain, xctrl->id, 0) >= 0)
1945 return -EACCES;
1946
1947 ctrl = uvc_find_control(chain, xctrl->id, &mapping);
1948 if (ctrl == NULL)
1949 return -EINVAL;
1950 if (!(ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR))
1951 return -EACCES;
1952
1953 /* Clamp out of range values. */
1954 switch (mapping->v4l2_type) {
1955 case V4L2_CTRL_TYPE_INTEGER:
1956 if (!ctrl->cached) {
1957 ret = uvc_ctrl_populate_cache(chain, ctrl);
1958 if (ret < 0)
1959 return ret;
1960 }
1961
1962 min = mapping->get(mapping, UVC_GET_MIN,
1963 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN));
1964 max = mapping->get(mapping, UVC_GET_MAX,
1965 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX));
1966 step = mapping->get(mapping, UVC_GET_RES,
1967 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
1968 if (step == 0)
1969 step = 1;
1970
1971 xctrl->value = min + DIV_ROUND_CLOSEST((u32)(xctrl->value - min),
1972 step) * step;
1973 if (mapping->data_type == UVC_CTRL_DATA_TYPE_SIGNED)
1974 xctrl->value = clamp(xctrl->value, min, max);
1975 else
1976 xctrl->value = clamp_t(u32, xctrl->value, min, max);
1977 value = xctrl->value;
1978 break;
1979
1980 case V4L2_CTRL_TYPE_BITMASK:
1981 if (!ctrl->cached) {
1982 ret = uvc_ctrl_populate_cache(chain, ctrl);
1983 if (ret < 0)
1984 return ret;
1985 }
1986
1987 xctrl->value &= uvc_get_ctrl_bitmap(ctrl, mapping);
1988 value = xctrl->value;
1989 break;
1990
1991 case V4L2_CTRL_TYPE_BOOLEAN:
1992 xctrl->value = clamp(xctrl->value, 0, 1);
1993 value = xctrl->value;
1994 break;
1995
1996 case V4L2_CTRL_TYPE_MENU:
1997 if (xctrl->value < (ffs(mapping->menu_mask) - 1) ||
1998 xctrl->value > (fls(mapping->menu_mask) - 1))
1999 return -ERANGE;
2000
2001 if (!test_bit(xctrl->value, &mapping->menu_mask))
2002 return -EINVAL;
2003
2004 value = uvc_mapping_get_menu_value(mapping, xctrl->value);
2005
2006 /*
2007 * Valid menu indices are reported by the GET_RES request for
2008 * UVC controls that support it.
2009 */
2010 if (mapping->data_type == UVC_CTRL_DATA_TYPE_BITMASK) {
2011 if (!ctrl->cached) {
2012 ret = uvc_ctrl_populate_cache(chain, ctrl);
2013 if (ret < 0)
2014 return ret;
2015 }
2016
2017 if (!(uvc_get_ctrl_bitmap(ctrl, mapping) & value))
2018 return -EINVAL;
2019 }
2020
2021 break;
2022
2023 default:
2024 value = xctrl->value;
2025 break;
2026 }
2027
2028 /*
2029 * If the mapping doesn't span the whole UVC control, the current value
2030 * needs to be loaded from the device to perform the read-modify-write
2031 * operation.
2032 */
2033 if ((ctrl->info.size * 8) != mapping->size) {
2034 ret = __uvc_ctrl_load_cur(chain, ctrl);
2035 if (ret < 0)
2036 return ret;
2037 }
2038
2039 /* Backup the current value in case we need to rollback later. */
2040 if (!ctrl->dirty) {
2041 memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
2042 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
2043 ctrl->info.size);
2044 }
2045
2046 mapping->set(mapping, value,
2047 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT));
2048
2049 if (ctrl->info.flags & UVC_CTRL_FLAG_ASYNCHRONOUS)
2050 ctrl->handle = handle;
2051
2052 ctrl->dirty = 1;
2053 ctrl->modified = 1;
2054 return 0;
2055 }
2056
2057 /* --------------------------------------------------------------------------
2058 * Dynamic controls
2059 */
2060
2061 /*
2062 * Retrieve flags for a given control
2063 */
2064 static int uvc_ctrl_get_flags(struct uvc_device *dev,
2065 const struct uvc_control *ctrl,
2066 struct uvc_control_info *info)
2067 {
2068 u8 *data;
2069 int ret;
2070
2071 data = kmalloc(1, GFP_KERNEL);
2072 if (data == NULL)
2073 return -ENOMEM;
2074
2075 if (ctrl->entity->get_info)
2076 ret = ctrl->entity->get_info(dev, ctrl->entity,
2077 ctrl->info.selector, data);
2078 else
2079 ret = uvc_query_ctrl(dev, UVC_GET_INFO, ctrl->entity->id,
2080 dev->intfnum, info->selector, data, 1);
2081
2082 if (!ret) {
2083 info->flags &= ~(UVC_CTRL_FLAG_GET_CUR |
2084 UVC_CTRL_FLAG_SET_CUR |
2085 UVC_CTRL_FLAG_AUTO_UPDATE |
2086 UVC_CTRL_FLAG_ASYNCHRONOUS);
2087
2088 info->flags |= (data[0] & UVC_CONTROL_CAP_GET ?
2089 UVC_CTRL_FLAG_GET_CUR : 0)
2090 | (data[0] & UVC_CONTROL_CAP_SET ?
2091 UVC_CTRL_FLAG_SET_CUR : 0)
2092 | (data[0] & UVC_CONTROL_CAP_AUTOUPDATE ?
2093 UVC_CTRL_FLAG_AUTO_UPDATE : 0)
2094 | (data[0] & UVC_CONTROL_CAP_ASYNCHRONOUS ?
2095 UVC_CTRL_FLAG_ASYNCHRONOUS : 0);
2096 }
2097
2098 kfree(data);
2099 return ret;
2100 }
2101
2102 static void uvc_ctrl_fixup_xu_info(struct uvc_device *dev,
2103 const struct uvc_control *ctrl, struct uvc_control_info *info)
2104 {
2105 struct uvc_ctrl_fixup {
2106 struct usb_device_id id;
2107 u8 entity;
2108 u8 selector;
2109 u8 flags;
2110 };
2111
2112 static const struct uvc_ctrl_fixup fixups[] = {
2113 { { USB_DEVICE(0x046d, 0x08c2) }, 9, 1,
2114 UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX |
2115 UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_SET_CUR |
2116 UVC_CTRL_FLAG_AUTO_UPDATE },
2117 { { USB_DEVICE(0x046d, 0x08cc) }, 9, 1,
2118 UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX |
2119 UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_SET_CUR |
2120 UVC_CTRL_FLAG_AUTO_UPDATE },
2121 { { USB_DEVICE(0x046d, 0x0994) }, 9, 1,
2122 UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX |
2123 UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_SET_CUR |
2124 UVC_CTRL_FLAG_AUTO_UPDATE },
2125 };
2126
2127 unsigned int i;
2128
2129 for (i = 0; i < ARRAY_SIZE(fixups); ++i) {
2130 if (!usb_match_one_id(dev->intf, &fixups[i].id))
2131 continue;
2132
2133 if (fixups[i].entity == ctrl->entity->id &&
2134 fixups[i].selector == info->selector) {
2135 info->flags = fixups[i].flags;
2136 return;
2137 }
2138 }
2139 }
2140
2141 /*
2142 * Query control information (size and flags) for XU controls.
2143 */
2144 static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
2145 const struct uvc_control *ctrl, struct uvc_control_info *info)
2146 {
2147 u8 *data;
2148 int ret;
2149
2150 data = kmalloc(2, GFP_KERNEL);
2151 if (data == NULL)
2152 return -ENOMEM;
2153
2154 memcpy(info->entity, ctrl->entity->guid, sizeof(info->entity));
2155 info->index = ctrl->index;
2156 info->selector = ctrl->index + 1;
2157
2158 /* Query and verify the control length (GET_LEN) */
2159 ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id, dev->intfnum,
2160 info->selector, data, 2);
2161 if (ret < 0) {
2162 uvc_dbg(dev, CONTROL,
2163 "GET_LEN failed on control %pUl/%u (%d)\n",
2164 info->entity, info->selector, ret);
2165 goto done;
2166 }
2167
2168 info->size = le16_to_cpup((__le16 *)data);
2169
2170 info->flags = UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX
2171 | UVC_CTRL_FLAG_GET_RES | UVC_CTRL_FLAG_GET_DEF;
2172
2173 ret = uvc_ctrl_get_flags(dev, ctrl, info);
2174 if (ret < 0) {
2175 uvc_dbg(dev, CONTROL,
2176 "Failed to get flags for control %pUl/%u (%d)\n",
2177 info->entity, info->selector, ret);
2178 goto done;
2179 }
2180
2181 uvc_ctrl_fixup_xu_info(dev, ctrl, info);
2182
2183 uvc_dbg(dev, CONTROL,
2184 "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }\n",
2185 info->entity, info->selector, info->size,
2186 (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
2187 (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
2188 (info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
2189
2190 done:
2191 kfree(data);
2192 return ret;
2193 }
2194
2195 static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
2196 const struct uvc_control_info *info);
2197
2198 static int uvc_ctrl_init_xu_ctrl(struct uvc_device *dev,
2199 struct uvc_control *ctrl)
2200 {
2201 struct uvc_control_info info;
2202 int ret;
2203
2204 if (ctrl->initialized)
2205 return 0;
2206
2207 ret = uvc_ctrl_fill_xu_info(dev, ctrl, &info);
2208 if (ret < 0)
2209 return ret;
2210
2211 ret = uvc_ctrl_add_info(dev, ctrl, &info);
2212 if (ret < 0)
2213 uvc_dbg(dev, CONTROL,
2214 "Failed to initialize control %pUl/%u on device %s entity %u\n",
2215 info.entity, info.selector, dev->udev->devpath,
2216 ctrl->entity->id);
2217
2218 return ret;
2219 }
2220
2221 int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
2222 struct uvc_xu_control_query *xqry)
2223 {
2224 struct uvc_entity *entity, *iter;
2225 struct uvc_control *ctrl;
2226 unsigned int i;
2227 bool found;
2228 u32 reqflags;
2229 u16 size;
2230 u8 *data = NULL;
2231 int ret;
2232
2233 /* Find the extension unit. */
2234 entity = NULL;
2235 list_for_each_entry(iter, &chain->entities, chain) {
2236 if (UVC_ENTITY_TYPE(iter) == UVC_VC_EXTENSION_UNIT &&
2237 iter->id == xqry->unit) {
2238 entity = iter;
2239 break;
2240 }
2241 }
2242
2243 if (!entity) {
2244 uvc_dbg(chain->dev, CONTROL, "Extension unit %u not found\n",
2245 xqry->unit);
2246 return -ENOENT;
2247 }
2248
2249 /* Find the control and perform delayed initialization if needed. */
2250 found = false;
2251 for (i = 0; i < entity->ncontrols; ++i) {
2252 ctrl = &entity->controls[i];
2253 if (ctrl->index == xqry->selector - 1) {
2254 found = true;
2255 break;
2256 }
2257 }
2258
2259 if (!found) {
2260 uvc_dbg(chain->dev, CONTROL, "Control %pUl/%u not found\n",
2261 entity->guid, xqry->selector);
2262 return -ENOENT;
2263 }
2264
2265 if (mutex_lock_interruptible(&chain->ctrl_mutex))
2266 return -ERESTARTSYS;
2267
2268 ret = uvc_ctrl_init_xu_ctrl(chain->dev, ctrl);
2269 if (ret < 0) {
2270 ret = -ENOENT;
2271 goto done;
2272 }
2273
2274 /* Validate the required buffer size and flags for the request */
2275 reqflags = 0;
2276 size = ctrl->info.size;
2277
2278 switch (xqry->query) {
2279 case UVC_GET_CUR:
2280 reqflags = UVC_CTRL_FLAG_GET_CUR;
2281 break;
2282 case UVC_GET_MIN:
2283 reqflags = UVC_CTRL_FLAG_GET_MIN;
2284 break;
2285 case UVC_GET_MAX:
2286 reqflags = UVC_CTRL_FLAG_GET_MAX;
2287 break;
2288 case UVC_GET_DEF:
2289 reqflags = UVC_CTRL_FLAG_GET_DEF;
2290 break;
2291 case UVC_GET_RES:
2292 reqflags = UVC_CTRL_FLAG_GET_RES;
2293 break;
2294 case UVC_SET_CUR:
2295 reqflags = UVC_CTRL_FLAG_SET_CUR;
2296 break;
2297 case UVC_GET_LEN:
2298 size = 2;
2299 break;
2300 case UVC_GET_INFO:
2301 size = 1;
2302 break;
2303 default:
2304 ret = -EINVAL;
2305 goto done;
2306 }
2307
2308 if (size != xqry->size) {
2309 ret = -ENOBUFS;
2310 goto done;
2311 }
2312
2313 if (reqflags && !(ctrl->info.flags & reqflags)) {
2314 ret = -EBADRQC;
2315 goto done;
2316 }
2317
2318 data = kmalloc(size, GFP_KERNEL);
2319 if (data == NULL) {
2320 ret = -ENOMEM;
2321 goto done;
2322 }
2323
2324 if (xqry->query == UVC_SET_CUR &&
2325 copy_from_user(data, xqry->data, size)) {
2326 ret = -EFAULT;
2327 goto done;
2328 }
2329
2330 ret = uvc_query_ctrl(chain->dev, xqry->query, xqry->unit,
2331 chain->dev->intfnum, xqry->selector, data, size);
2332 if (ret < 0)
2333 goto done;
2334
2335 if (xqry->query != UVC_SET_CUR &&
2336 copy_to_user(xqry->data, data, size))
2337 ret = -EFAULT;
2338 done:
2339 kfree(data);
2340 mutex_unlock(&chain->ctrl_mutex);
2341 return ret;
2342 }
2343
2344 /* --------------------------------------------------------------------------
2345 * Suspend/resume
2346 */
2347
2348 /*
2349 * Restore control values after resume, skipping controls that haven't been
2350 * changed.
2351 *
2352 * TODO
2353 * - Don't restore modified controls that are back to their default value.
2354 * - Handle restore order (Auto-Exposure Mode should be restored before
2355 * Exposure Time).
2356 */
2357 int uvc_ctrl_restore_values(struct uvc_device *dev)
2358 {
2359 struct uvc_control *ctrl;
2360 struct uvc_entity *entity;
2361 unsigned int i;
2362 int ret;
2363
2364 /* Walk the entities list and restore controls when possible. */
2365 list_for_each_entry(entity, &dev->entities, list) {
2366
2367 for (i = 0; i < entity->ncontrols; ++i) {
2368 ctrl = &entity->controls[i];
2369
2370 if (!ctrl->initialized || !ctrl->modified ||
2371 (ctrl->info.flags & UVC_CTRL_FLAG_RESTORE) == 0)
2372 continue;
2373 dev_dbg(&dev->udev->dev,
2374 "restoring control %pUl/%u/%u\n",
2375 ctrl->info.entity, ctrl->info.index,
2376 ctrl->info.selector);
2377 ctrl->dirty = 1;
2378 }
2379
2380 ret = uvc_ctrl_commit_entity(dev, entity, 0, NULL);
2381 if (ret < 0)
2382 return ret;
2383 }
2384
2385 return 0;
2386 }
2387
2388 /* --------------------------------------------------------------------------
2389 * Control and mapping handling
2390 */
2391
2392 /*
2393 * Add control information to a given control.
2394 */
2395 static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
2396 const struct uvc_control_info *info)
2397 {
2398 ctrl->info = *info;
2399 INIT_LIST_HEAD(&ctrl->info.mappings);
2400
2401 /* Allocate an array to save control values (cur, def, max, etc.) */
2402 ctrl->uvc_data = kzalloc(ctrl->info.size * UVC_CTRL_DATA_LAST + 1,
2403 GFP_KERNEL);
2404 if (!ctrl->uvc_data)
2405 return -ENOMEM;
2406
2407 ctrl->initialized = 1;
2408
2409 uvc_dbg(dev, CONTROL, "Added control %pUl/%u to device %s entity %u\n",
2410 ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
2411 ctrl->entity->id);
2412
2413 return 0;
2414 }
2415
2416 /*
2417 * Add a control mapping to a given control.
2418 */
2419 static int __uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
2420 struct uvc_control *ctrl, const struct uvc_control_mapping *mapping)
2421 {
2422 struct uvc_control_mapping *map;
2423 unsigned int size;
2424 unsigned int i;
2425
2426 /*
2427 * Most mappings come from static kernel data, and need to be duplicated.
2428 * Mappings that come from userspace will be unnecessarily duplicated,
2429 * this could be optimized.
2430 */
2431 map = kmemdup(mapping, sizeof(*mapping), GFP_KERNEL);
2432 if (!map)
2433 return -ENOMEM;
2434
2435 map->name = NULL;
2436 map->menu_names = NULL;
2437 map->menu_mapping = NULL;
2438
2439 /* For UVCIOC_CTRL_MAP custom control */
2440 if (mapping->name) {
2441 map->name = kstrdup(mapping->name, GFP_KERNEL);
2442 if (!map->name)
2443 goto err_nomem;
2444 }
2445
2446 INIT_LIST_HEAD(&map->ev_subs);
2447
2448 if (mapping->menu_mapping && mapping->menu_mask) {
2449 size = sizeof(mapping->menu_mapping[0])
2450 * fls(mapping->menu_mask);
2451 map->menu_mapping = kmemdup(mapping->menu_mapping, size,
2452 GFP_KERNEL);
2453 if (!map->menu_mapping)
2454 goto err_nomem;
2455 }
2456 if (mapping->menu_names && mapping->menu_mask) {
2457 size = sizeof(mapping->menu_names[0])
2458 * fls(mapping->menu_mask);
2459 map->menu_names = kmemdup(mapping->menu_names, size,
2460 GFP_KERNEL);
2461 if (!map->menu_names)
2462 goto err_nomem;
2463 }
2464
2465 if (map->get == NULL)
2466 map->get = uvc_get_le_value;
2467 if (map->set == NULL)
2468 map->set = uvc_set_le_value;
2469
2470 for (i = 0; i < ARRAY_SIZE(uvc_control_classes); i++) {
2471 if (V4L2_CTRL_ID2WHICH(uvc_control_classes[i]) ==
2472 V4L2_CTRL_ID2WHICH(map->id)) {
2473 chain->ctrl_class_bitmap |= BIT(i);
2474 break;
2475 }
2476 }
2477
2478 list_add_tail(&map->list, &ctrl->info.mappings);
2479 uvc_dbg(chain->dev, CONTROL, "Adding mapping '%s' to control %pUl/%u\n",
2480 uvc_map_get_name(map), ctrl->info.entity,
2481 ctrl->info.selector);
2482
2483 return 0;
2484
2485 err_nomem:
2486 kfree(map->menu_names);
2487 kfree(map->menu_mapping);
2488 kfree(map->name);
2489 kfree(map);
2490 return -ENOMEM;
2491 }
2492
2493 int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
2494 const struct uvc_control_mapping *mapping)
2495 {
2496 struct uvc_device *dev = chain->dev;
2497 struct uvc_control_mapping *map;
2498 struct uvc_entity *entity;
2499 struct uvc_control *ctrl;
2500 int found = 0;
2501 int ret;
2502
2503 if (mapping->id & ~V4L2_CTRL_ID_MASK) {
2504 uvc_dbg(dev, CONTROL,
2505 "Can't add mapping '%s', control id 0x%08x is invalid\n",
2506 uvc_map_get_name(mapping), mapping->id);
2507 return -EINVAL;
2508 }
2509
2510 /* Search for the matching (GUID/CS) control on the current chain */
2511 list_for_each_entry(entity, &chain->entities, chain) {
2512 unsigned int i;
2513
2514 if (UVC_ENTITY_TYPE(entity) != UVC_VC_EXTENSION_UNIT ||
2515 !uvc_entity_match_guid(entity, mapping->entity))
2516 continue;
2517
2518 for (i = 0; i < entity->ncontrols; ++i) {
2519 ctrl = &entity->controls[i];
2520 if (ctrl->index == mapping->selector - 1) {
2521 found = 1;
2522 break;
2523 }
2524 }
2525
2526 if (found)
2527 break;
2528 }
2529 if (!found)
2530 return -ENOENT;
2531
2532 if (mutex_lock_interruptible(&chain->ctrl_mutex))
2533 return -ERESTARTSYS;
2534
2535 /* Perform delayed initialization of XU controls */
2536 ret = uvc_ctrl_init_xu_ctrl(dev, ctrl);
2537 if (ret < 0) {
2538 ret = -ENOENT;
2539 goto done;
2540 }
2541
2542 /* Validate the user-provided bit-size and offset */
2543 if (mapping->size > 32 ||
2544 mapping->offset + mapping->size > ctrl->info.size * 8) {
2545 ret = -EINVAL;
2546 goto done;
2547 }
2548
2549 list_for_each_entry(map, &ctrl->info.mappings, list) {
2550 if (mapping->id == map->id) {
2551 uvc_dbg(dev, CONTROL,
2552 "Can't add mapping '%s', control id 0x%08x already exists\n",
2553 uvc_map_get_name(mapping), mapping->id);
2554 ret = -EEXIST;
2555 goto done;
2556 }
2557 }
2558
2559 /* Prevent excess memory consumption */
2560 if (atomic_inc_return(&dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) {
2561 atomic_dec(&dev->nmappings);
2562 uvc_dbg(dev, CONTROL,
2563 "Can't add mapping '%s', maximum mappings count (%u) exceeded\n",
2564 uvc_map_get_name(mapping), UVC_MAX_CONTROL_MAPPINGS);
2565 ret = -ENOMEM;
2566 goto done;
2567 }
2568
2569 ret = __uvc_ctrl_add_mapping(chain, ctrl, mapping);
2570 if (ret < 0)
2571 atomic_dec(&dev->nmappings);
2572
2573 done:
2574 mutex_unlock(&chain->ctrl_mutex);
2575 return ret;
2576 }
2577
2578 /*
2579 * Prune an entity of its bogus controls using a blacklist. Bogus controls
2580 * are currently the ones that crash the camera or unconditionally return an
2581 * error when queried.
2582 */
2583 static void uvc_ctrl_prune_entity(struct uvc_device *dev,
2584 struct uvc_entity *entity)
2585 {
2586 struct uvc_ctrl_blacklist {
2587 struct usb_device_id id;
2588 u8 index;
2589 };
2590
2591 static const struct uvc_ctrl_blacklist processing_blacklist[] = {
2592 { { USB_DEVICE(0x13d3, 0x509b) }, 9 }, /* Gain */
2593 { { USB_DEVICE(0x1c4f, 0x3000) }, 6 }, /* WB Temperature */
2594 { { USB_DEVICE(0x5986, 0x0241) }, 2 }, /* Hue */
2595 };
2596 static const struct uvc_ctrl_blacklist camera_blacklist[] = {
2597 { { USB_DEVICE(0x06f8, 0x3005) }, 9 }, /* Zoom, Absolute */
2598 };
2599
2600 const struct uvc_ctrl_blacklist *blacklist;
2601 unsigned int size;
2602 unsigned int count;
2603 unsigned int i;
2604 u8 *controls;
2605
2606 switch (UVC_ENTITY_TYPE(entity)) {
2607 case UVC_VC_PROCESSING_UNIT:
2608 blacklist = processing_blacklist;
2609 count = ARRAY_SIZE(processing_blacklist);
2610 controls = entity->processing.bmControls;
2611 size = entity->processing.bControlSize;
2612 break;
2613
2614 case UVC_ITT_CAMERA:
2615 blacklist = camera_blacklist;
2616 count = ARRAY_SIZE(camera_blacklist);
2617 controls = entity->camera.bmControls;
2618 size = entity->camera.bControlSize;
2619 break;
2620
2621 default:
2622 return;
2623 }
2624
2625 for (i = 0; i < count; ++i) {
2626 if (!usb_match_one_id(dev->intf, &blacklist[i].id))
2627 continue;
2628
2629 if (blacklist[i].index >= 8 * size ||
2630 !uvc_test_bit(controls, blacklist[i].index))
2631 continue;
2632
2633 uvc_dbg(dev, CONTROL,
2634 "%u/%u control is black listed, removing it\n",
2635 entity->id, blacklist[i].index);
2636
2637 uvc_clear_bit(controls, blacklist[i].index);
2638 }
2639 }
2640
2641 /*
2642 * Add control information and hardcoded stock control mappings to the given
2643 * device.
2644 */
2645 static void uvc_ctrl_init_ctrl(struct uvc_video_chain *chain,
2646 struct uvc_control *ctrl)
2647 {
2648 unsigned int i;
2649
2650 /*
2651 * XU controls initialization requires querying the device for control
2652 * information. As some buggy UVC devices will crash when queried
2653 * repeatedly in a tight loop, delay XU controls initialization until
2654 * first use.
2655 */
2656 if (UVC_ENTITY_TYPE(ctrl->entity) == UVC_VC_EXTENSION_UNIT)
2657 return;
2658
2659 for (i = 0; i < ARRAY_SIZE(uvc_ctrls); ++i) {
2660 const struct uvc_control_info *info = &uvc_ctrls[i];
2661
2662 if (uvc_entity_match_guid(ctrl->entity, info->entity) &&
2663 ctrl->index == info->index) {
2664 uvc_ctrl_add_info(chain->dev, ctrl, info);
2665 /*
2666 * Retrieve control flags from the device. Ignore errors
2667 * and work with default flag values from the uvc_ctrl
2668 * array when the device doesn't properly implement
2669 * GET_INFO on standard controls.
2670 */
2671 uvc_ctrl_get_flags(chain->dev, ctrl, &ctrl->info);
2672 break;
2673 }
2674 }
2675
2676 if (!ctrl->initialized)
2677 return;
2678
2679 /* Process common mappings. */
2680 for (i = 0; i < ARRAY_SIZE(uvc_ctrl_mappings); ++i) {
2681 const struct uvc_control_mapping *mapping = &uvc_ctrl_mappings[i];
2682
2683 if (!uvc_entity_match_guid(ctrl->entity, mapping->entity) ||
2684 ctrl->info.selector != mapping->selector)
2685 continue;
2686
2687 /* Let the device provide a custom mapping. */
2688 if (mapping->filter_mapping) {
2689 mapping = mapping->filter_mapping(chain, ctrl);
2690 if (!mapping)
2691 continue;
2692 }
2693
2694 __uvc_ctrl_add_mapping(chain, ctrl, mapping);
2695 }
2696 }
2697
2698 /*
2699 * Initialize device controls.
2700 */
2701 static int uvc_ctrl_init_chain(struct uvc_video_chain *chain)
2702 {
2703 struct uvc_entity *entity;
2704 unsigned int i;
2705
2706 /* Walk the entities list and instantiate controls */
2707 list_for_each_entry(entity, &chain->entities, chain) {
2708 struct uvc_control *ctrl;
2709 unsigned int bControlSize = 0, ncontrols;
2710 u8 *bmControls = NULL;
2711
2712 if (UVC_ENTITY_TYPE(entity) == UVC_VC_EXTENSION_UNIT) {
2713 bmControls = entity->extension.bmControls;
2714 bControlSize = entity->extension.bControlSize;
2715 } else if (UVC_ENTITY_TYPE(entity) == UVC_VC_PROCESSING_UNIT) {
2716 bmControls = entity->processing.bmControls;
2717 bControlSize = entity->processing.bControlSize;
2718 } else if (UVC_ENTITY_TYPE(entity) == UVC_ITT_CAMERA) {
2719 bmControls = entity->camera.bmControls;
2720 bControlSize = entity->camera.bControlSize;
2721 } else if (UVC_ENTITY_TYPE(entity) == UVC_EXT_GPIO_UNIT) {
2722 bmControls = entity->gpio.bmControls;
2723 bControlSize = entity->gpio.bControlSize;
2724 }
2725
2726 /* Remove bogus/blacklisted controls */
2727 uvc_ctrl_prune_entity(chain->dev, entity);
2728
2729 /* Count supported controls and allocate the controls array */
2730 ncontrols = memweight(bmControls, bControlSize);
2731 if (ncontrols == 0)
2732 continue;
2733
2734 entity->controls = kcalloc(ncontrols, sizeof(*ctrl),
2735 GFP_KERNEL);
2736 if (entity->controls == NULL)
2737 return -ENOMEM;
2738 entity->ncontrols = ncontrols;
2739
2740 /* Initialize all supported controls */
2741 ctrl = entity->controls;
2742 for (i = 0; i < bControlSize * 8; ++i) {
2743 if (uvc_test_bit(bmControls, i) == 0)
2744 continue;
2745
2746 ctrl->entity = entity;
2747 ctrl->index = i;
2748
2749 uvc_ctrl_init_ctrl(chain, ctrl);
2750 ctrl++;
2751 }
2752 }
2753
2754 return 0;
2755 }
2756
2757 int uvc_ctrl_init_device(struct uvc_device *dev)
2758 {
2759 struct uvc_video_chain *chain;
2760 int ret;
2761
2762 INIT_WORK(&dev->async_ctrl.work, uvc_ctrl_status_event_work);
2763
2764 list_for_each_entry(chain, &dev->chains, list) {
2765 ret = uvc_ctrl_init_chain(chain);
2766 if (ret)
2767 return ret;
2768 }
2769
2770 return 0;
2771 }
2772
2773 /*
2774 * Cleanup device controls.
2775 */
2776 static void uvc_ctrl_cleanup_mappings(struct uvc_device *dev,
2777 struct uvc_control *ctrl)
2778 {
2779 struct uvc_control_mapping *mapping, *nm;
2780
2781 list_for_each_entry_safe(mapping, nm, &ctrl->info.mappings, list) {
2782 list_del(&mapping->list);
2783 kfree(mapping->menu_names);
2784 kfree(mapping->menu_mapping);
2785 kfree(mapping->name);
2786 kfree(mapping);
2787 }
2788 }
2789
2790 void uvc_ctrl_cleanup_device(struct uvc_device *dev)
2791 {
2792 struct uvc_entity *entity;
2793 unsigned int i;
2794
2795 /* Can be uninitialized if we are aborting on probe error. */
2796 if (dev->async_ctrl.work.func)
2797 cancel_work_sync(&dev->async_ctrl.work);
2798
2799 /* Free controls and control mappings for all entities. */
2800 list_for_each_entry(entity, &dev->entities, list) {
2801 for (i = 0; i < entity->ncontrols; ++i) {
2802 struct uvc_control *ctrl = &entity->controls[i];
2803
2804 if (!ctrl->initialized)
2805 continue;
2806
2807 uvc_ctrl_cleanup_mappings(dev, ctrl);
2808 kfree(ctrl->uvc_data);
2809 }
2810
2811 kfree(entity->controls);
2812 }
2813 }
Kernel DRM miscellaneous fixes and cross-tree changes