1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * uvc_ctrl.c -- USB Video Class driver - Controls
5 * Copyright (C) 2005-2010
6 * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
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>
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
35 /* ------------------------------------------------------------------------
39 static const struct uvc_control_info uvc_ctrls
[] = {
41 .entity
= UVC_GUID_UVC_PROCESSING
,
42 .selector
= UVC_PU_BRIGHTNESS_CONTROL
,
45 .flags
= UVC_CTRL_FLAG_SET_CUR
46 | UVC_CTRL_FLAG_GET_RANGE
47 | UVC_CTRL_FLAG_RESTORE
,
50 .entity
= UVC_GUID_UVC_PROCESSING
,
51 .selector
= UVC_PU_CONTRAST_CONTROL
,
54 .flags
= UVC_CTRL_FLAG_SET_CUR
55 | UVC_CTRL_FLAG_GET_RANGE
56 | UVC_CTRL_FLAG_RESTORE
,
59 .entity
= UVC_GUID_UVC_PROCESSING
,
60 .selector
= UVC_PU_HUE_CONTROL
,
63 .flags
= UVC_CTRL_FLAG_SET_CUR
64 | UVC_CTRL_FLAG_GET_RANGE
65 | UVC_CTRL_FLAG_RESTORE
66 | UVC_CTRL_FLAG_AUTO_UPDATE
,
69 .entity
= UVC_GUID_UVC_PROCESSING
,
70 .selector
= UVC_PU_SATURATION_CONTROL
,
73 .flags
= UVC_CTRL_FLAG_SET_CUR
74 | UVC_CTRL_FLAG_GET_RANGE
75 | UVC_CTRL_FLAG_RESTORE
,
78 .entity
= UVC_GUID_UVC_PROCESSING
,
79 .selector
= UVC_PU_SHARPNESS_CONTROL
,
82 .flags
= UVC_CTRL_FLAG_SET_CUR
83 | UVC_CTRL_FLAG_GET_RANGE
84 | UVC_CTRL_FLAG_RESTORE
,
87 .entity
= UVC_GUID_UVC_PROCESSING
,
88 .selector
= UVC_PU_GAMMA_CONTROL
,
91 .flags
= UVC_CTRL_FLAG_SET_CUR
92 | UVC_CTRL_FLAG_GET_RANGE
93 | UVC_CTRL_FLAG_RESTORE
,
96 .entity
= UVC_GUID_UVC_PROCESSING
,
97 .selector
= UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL
,
100 .flags
= UVC_CTRL_FLAG_SET_CUR
101 | UVC_CTRL_FLAG_GET_RANGE
102 | UVC_CTRL_FLAG_RESTORE
103 | UVC_CTRL_FLAG_AUTO_UPDATE
,
106 .entity
= UVC_GUID_UVC_PROCESSING
,
107 .selector
= UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL
,
110 .flags
= UVC_CTRL_FLAG_SET_CUR
111 | UVC_CTRL_FLAG_GET_RANGE
112 | UVC_CTRL_FLAG_RESTORE
113 | UVC_CTRL_FLAG_AUTO_UPDATE
,
116 .entity
= UVC_GUID_UVC_PROCESSING
,
117 .selector
= UVC_PU_BACKLIGHT_COMPENSATION_CONTROL
,
120 .flags
= UVC_CTRL_FLAG_SET_CUR
121 | UVC_CTRL_FLAG_GET_RANGE
122 | UVC_CTRL_FLAG_RESTORE
,
125 .entity
= UVC_GUID_UVC_PROCESSING
,
126 .selector
= UVC_PU_GAIN_CONTROL
,
129 .flags
= UVC_CTRL_FLAG_SET_CUR
130 | UVC_CTRL_FLAG_GET_RANGE
131 | UVC_CTRL_FLAG_RESTORE
,
134 .entity
= UVC_GUID_UVC_PROCESSING
,
135 .selector
= UVC_PU_POWER_LINE_FREQUENCY_CONTROL
,
138 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
139 | UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_RESTORE
,
142 .entity
= UVC_GUID_UVC_PROCESSING
,
143 .selector
= UVC_PU_HUE_AUTO_CONTROL
,
146 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
147 | UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_RESTORE
,
150 .entity
= UVC_GUID_UVC_PROCESSING
,
151 .selector
= UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL
,
154 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
155 | UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_RESTORE
,
158 .entity
= UVC_GUID_UVC_PROCESSING
,
159 .selector
= UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL
,
162 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
163 | UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_RESTORE
,
166 .entity
= UVC_GUID_UVC_PROCESSING
,
167 .selector
= UVC_PU_DIGITAL_MULTIPLIER_CONTROL
,
170 .flags
= UVC_CTRL_FLAG_SET_CUR
171 | UVC_CTRL_FLAG_GET_RANGE
172 | UVC_CTRL_FLAG_RESTORE
,
175 .entity
= UVC_GUID_UVC_PROCESSING
,
176 .selector
= UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL
,
179 .flags
= UVC_CTRL_FLAG_SET_CUR
180 | UVC_CTRL_FLAG_GET_RANGE
181 | UVC_CTRL_FLAG_RESTORE
,
184 .entity
= UVC_GUID_UVC_PROCESSING
,
185 .selector
= UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL
,
188 .flags
= UVC_CTRL_FLAG_GET_CUR
,
191 .entity
= UVC_GUID_UVC_PROCESSING
,
192 .selector
= UVC_PU_ANALOG_LOCK_STATUS_CONTROL
,
195 .flags
= UVC_CTRL_FLAG_GET_CUR
,
198 .entity
= UVC_GUID_UVC_CAMERA
,
199 .selector
= UVC_CT_SCANNING_MODE_CONTROL
,
202 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
203 | UVC_CTRL_FLAG_RESTORE
,
206 .entity
= UVC_GUID_UVC_CAMERA
,
207 .selector
= UVC_CT_AE_MODE_CONTROL
,
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
,
215 .entity
= UVC_GUID_UVC_CAMERA
,
216 .selector
= UVC_CT_AE_PRIORITY_CONTROL
,
219 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
220 | UVC_CTRL_FLAG_RESTORE
,
223 .entity
= UVC_GUID_UVC_CAMERA
,
224 .selector
= UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL
,
227 .flags
= UVC_CTRL_FLAG_SET_CUR
228 | UVC_CTRL_FLAG_GET_RANGE
229 | UVC_CTRL_FLAG_RESTORE
230 | UVC_CTRL_FLAG_AUTO_UPDATE
,
233 .entity
= UVC_GUID_UVC_CAMERA
,
234 .selector
= UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL
,
237 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_RESTORE
,
240 .entity
= UVC_GUID_UVC_CAMERA
,
241 .selector
= UVC_CT_FOCUS_ABSOLUTE_CONTROL
,
244 .flags
= UVC_CTRL_FLAG_SET_CUR
245 | UVC_CTRL_FLAG_GET_RANGE
246 | UVC_CTRL_FLAG_RESTORE
247 | UVC_CTRL_FLAG_AUTO_UPDATE
,
250 .entity
= UVC_GUID_UVC_CAMERA
,
251 .selector
= UVC_CT_FOCUS_RELATIVE_CONTROL
,
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
,
260 .entity
= UVC_GUID_UVC_CAMERA
,
261 .selector
= UVC_CT_IRIS_ABSOLUTE_CONTROL
,
264 .flags
= UVC_CTRL_FLAG_SET_CUR
265 | UVC_CTRL_FLAG_GET_RANGE
266 | UVC_CTRL_FLAG_RESTORE
267 | UVC_CTRL_FLAG_AUTO_UPDATE
,
270 .entity
= UVC_GUID_UVC_CAMERA
,
271 .selector
= UVC_CT_IRIS_RELATIVE_CONTROL
,
274 .flags
= UVC_CTRL_FLAG_SET_CUR
275 | UVC_CTRL_FLAG_AUTO_UPDATE
,
278 .entity
= UVC_GUID_UVC_CAMERA
,
279 .selector
= UVC_CT_ZOOM_ABSOLUTE_CONTROL
,
282 .flags
= UVC_CTRL_FLAG_SET_CUR
283 | UVC_CTRL_FLAG_GET_RANGE
284 | UVC_CTRL_FLAG_RESTORE
285 | UVC_CTRL_FLAG_AUTO_UPDATE
,
288 .entity
= UVC_GUID_UVC_CAMERA
,
289 .selector
= UVC_CT_ZOOM_RELATIVE_CONTROL
,
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
,
298 .entity
= UVC_GUID_UVC_CAMERA
,
299 .selector
= UVC_CT_PANTILT_ABSOLUTE_CONTROL
,
302 .flags
= UVC_CTRL_FLAG_SET_CUR
303 | UVC_CTRL_FLAG_GET_RANGE
304 | UVC_CTRL_FLAG_RESTORE
305 | UVC_CTRL_FLAG_AUTO_UPDATE
,
308 .entity
= UVC_GUID_UVC_CAMERA
,
309 .selector
= UVC_CT_PANTILT_RELATIVE_CONTROL
,
312 .flags
= UVC_CTRL_FLAG_SET_CUR
313 | UVC_CTRL_FLAG_GET_RANGE
314 | UVC_CTRL_FLAG_AUTO_UPDATE
,
317 .entity
= UVC_GUID_UVC_CAMERA
,
318 .selector
= UVC_CT_ROLL_ABSOLUTE_CONTROL
,
321 .flags
= UVC_CTRL_FLAG_SET_CUR
322 | UVC_CTRL_FLAG_GET_RANGE
323 | UVC_CTRL_FLAG_RESTORE
324 | UVC_CTRL_FLAG_AUTO_UPDATE
,
327 .entity
= UVC_GUID_UVC_CAMERA
,
328 .selector
= UVC_CT_ROLL_RELATIVE_CONTROL
,
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
,
337 .entity
= UVC_GUID_UVC_CAMERA
,
338 .selector
= UVC_CT_FOCUS_AUTO_CONTROL
,
341 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
342 | UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_RESTORE
,
345 .entity
= UVC_GUID_UVC_CAMERA
,
346 .selector
= UVC_CT_PRIVACY_CONTROL
,
349 .flags
= UVC_CTRL_FLAG_SET_CUR
| UVC_CTRL_FLAG_GET_CUR
350 | UVC_CTRL_FLAG_RESTORE
351 | UVC_CTRL_FLAG_AUTO_UPDATE
,
354 .entity
= UVC_GUID_EXT_GPIO_CONTROLLER
,
355 .selector
= UVC_CT_PRIVACY_CONTROL
,
358 .flags
= UVC_CTRL_FLAG_GET_CUR
359 | UVC_CTRL_FLAG_AUTO_UPDATE
,
363 static const u32 uvc_control_classes
[] = {
364 V4L2_CID_CAMERA_CLASS
,
368 static const int exposure_auto_mapping
[] = { 2, 1, 4, 8 };
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
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.
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.
384 static int uvc_mapping_get_menu_value(const struct uvc_control_mapping
*mapping
,
387 if (!test_bit(idx
, &mapping
->menu_mask
))
390 if (mapping
->menu_mapping
)
391 return mapping
->menu_mapping
[idx
];
397 uvc_mapping_get_menu_name(const struct uvc_control_mapping
*mapping
, u32 idx
)
399 if (!test_bit(idx
, &mapping
->menu_mask
))
402 if (mapping
->menu_names
)
403 return mapping
->menu_names
[idx
];
405 return v4l2_ctrl_get_menu(mapping
->id
)[idx
];
408 static s32
uvc_ctrl_get_zoom(struct uvc_control_mapping
*mapping
,
409 u8 query
, const u8
*data
)
411 s8 zoom
= (s8
)data
[0];
415 return (zoom
== 0) ? 0 : (zoom
> 0 ? data
[2] : -data
[2]);
426 static void uvc_ctrl_set_zoom(struct uvc_control_mapping
*mapping
,
429 data
[0] = value
== 0 ? 0 : (value
> 0) ? 1 : 0xff;
430 data
[2] = min((int)abs(value
), 0xff);
433 static s32
uvc_ctrl_get_rel_speed(struct uvc_control_mapping
*mapping
,
434 u8 query
, const u8
*data
)
436 unsigned int first
= mapping
->offset
/ 8;
437 s8 rel
= (s8
)data
[first
];
441 return (rel
== 0) ? 0 : (rel
> 0 ? data
[first
+1]
444 return -data
[first
+1];
449 return data
[first
+1];
453 static void uvc_ctrl_set_rel_speed(struct uvc_control_mapping
*mapping
,
456 unsigned int first
= mapping
->offset
/ 8;
458 data
[first
] = value
== 0 ? 0 : (value
> 0) ? 1 : 0xff;
459 data
[first
+1] = min_t(int, abs(value
), 0xff);
462 static const struct uvc_control_mapping uvc_ctrl_mappings
[] = {
464 .id
= V4L2_CID_BRIGHTNESS
,
465 .entity
= UVC_GUID_UVC_PROCESSING
,
466 .selector
= UVC_PU_BRIGHTNESS_CONTROL
,
469 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
470 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
473 .id
= V4L2_CID_CONTRAST
,
474 .entity
= UVC_GUID_UVC_PROCESSING
,
475 .selector
= UVC_PU_CONTRAST_CONTROL
,
478 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
479 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
483 .entity
= UVC_GUID_UVC_PROCESSING
,
484 .selector
= UVC_PU_HUE_CONTROL
,
487 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
488 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
489 .master_id
= V4L2_CID_HUE_AUTO
,
493 .id
= V4L2_CID_SATURATION
,
494 .entity
= UVC_GUID_UVC_PROCESSING
,
495 .selector
= UVC_PU_SATURATION_CONTROL
,
498 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
499 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
502 .id
= V4L2_CID_SHARPNESS
,
503 .entity
= UVC_GUID_UVC_PROCESSING
,
504 .selector
= UVC_PU_SHARPNESS_CONTROL
,
507 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
508 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
511 .id
= V4L2_CID_GAMMA
,
512 .entity
= UVC_GUID_UVC_PROCESSING
,
513 .selector
= UVC_PU_GAMMA_CONTROL
,
516 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
517 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
520 .id
= V4L2_CID_BACKLIGHT_COMPENSATION
,
521 .entity
= UVC_GUID_UVC_PROCESSING
,
522 .selector
= UVC_PU_BACKLIGHT_COMPENSATION_CONTROL
,
525 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
526 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
530 .entity
= UVC_GUID_UVC_PROCESSING
,
531 .selector
= UVC_PU_GAIN_CONTROL
,
534 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
535 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
538 .id
= V4L2_CID_HUE_AUTO
,
539 .entity
= UVC_GUID_UVC_PROCESSING
,
540 .selector
= UVC_PU_HUE_AUTO_CONTROL
,
543 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
544 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
545 .slave_ids
= { V4L2_CID_HUE
, },
548 .id
= V4L2_CID_EXPOSURE_AUTO
,
549 .entity
= UVC_GUID_UVC_CAMERA
,
550 .selector
= UVC_CT_AE_MODE_CONTROL
,
553 .v4l2_type
= V4L2_CTRL_TYPE_MENU
,
554 .data_type
= UVC_CTRL_DATA_TYPE_BITMASK
,
555 .menu_mapping
= exposure_auto_mapping
,
556 .menu_mask
= GENMASK(V4L2_EXPOSURE_APERTURE_PRIORITY
,
558 .slave_ids
= { V4L2_CID_EXPOSURE_ABSOLUTE
, },
561 .id
= V4L2_CID_EXPOSURE_AUTO_PRIORITY
,
562 .entity
= UVC_GUID_UVC_CAMERA
,
563 .selector
= UVC_CT_AE_PRIORITY_CONTROL
,
566 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
567 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
570 .id
= V4L2_CID_EXPOSURE_ABSOLUTE
,
571 .entity
= UVC_GUID_UVC_CAMERA
,
572 .selector
= UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL
,
575 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
576 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
577 .master_id
= V4L2_CID_EXPOSURE_AUTO
,
578 .master_manual
= V4L2_EXPOSURE_MANUAL
,
581 .id
= V4L2_CID_AUTO_WHITE_BALANCE
,
582 .entity
= UVC_GUID_UVC_PROCESSING
,
583 .selector
= UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL
,
586 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
587 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
588 .slave_ids
= { V4L2_CID_WHITE_BALANCE_TEMPERATURE
, },
591 .id
= V4L2_CID_WHITE_BALANCE_TEMPERATURE
,
592 .entity
= UVC_GUID_UVC_PROCESSING
,
593 .selector
= UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL
,
596 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
597 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
598 .master_id
= V4L2_CID_AUTO_WHITE_BALANCE
,
602 .id
= V4L2_CID_AUTO_WHITE_BALANCE
,
603 .entity
= UVC_GUID_UVC_PROCESSING
,
604 .selector
= UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL
,
607 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
608 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
609 .slave_ids
= { V4L2_CID_BLUE_BALANCE
,
610 V4L2_CID_RED_BALANCE
},
613 .id
= V4L2_CID_BLUE_BALANCE
,
614 .entity
= UVC_GUID_UVC_PROCESSING
,
615 .selector
= UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL
,
618 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
619 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
620 .master_id
= V4L2_CID_AUTO_WHITE_BALANCE
,
624 .id
= V4L2_CID_RED_BALANCE
,
625 .entity
= UVC_GUID_UVC_PROCESSING
,
626 .selector
= UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL
,
629 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
630 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
631 .master_id
= V4L2_CID_AUTO_WHITE_BALANCE
,
635 .id
= V4L2_CID_FOCUS_ABSOLUTE
,
636 .entity
= UVC_GUID_UVC_CAMERA
,
637 .selector
= UVC_CT_FOCUS_ABSOLUTE_CONTROL
,
640 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
641 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
642 .master_id
= V4L2_CID_FOCUS_AUTO
,
646 .id
= V4L2_CID_FOCUS_AUTO
,
647 .entity
= UVC_GUID_UVC_CAMERA
,
648 .selector
= UVC_CT_FOCUS_AUTO_CONTROL
,
651 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
652 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
653 .slave_ids
= { V4L2_CID_FOCUS_ABSOLUTE
, },
656 .id
= V4L2_CID_IRIS_ABSOLUTE
,
657 .entity
= UVC_GUID_UVC_CAMERA
,
658 .selector
= UVC_CT_IRIS_ABSOLUTE_CONTROL
,
661 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
662 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
665 .id
= V4L2_CID_IRIS_RELATIVE
,
666 .entity
= UVC_GUID_UVC_CAMERA
,
667 .selector
= UVC_CT_IRIS_RELATIVE_CONTROL
,
670 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
671 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
674 .id
= V4L2_CID_ZOOM_ABSOLUTE
,
675 .entity
= UVC_GUID_UVC_CAMERA
,
676 .selector
= UVC_CT_ZOOM_ABSOLUTE_CONTROL
,
679 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
680 .data_type
= UVC_CTRL_DATA_TYPE_UNSIGNED
,
683 .id
= V4L2_CID_ZOOM_CONTINUOUS
,
684 .entity
= UVC_GUID_UVC_CAMERA
,
685 .selector
= UVC_CT_ZOOM_RELATIVE_CONTROL
,
688 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
689 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
690 .get
= uvc_ctrl_get_zoom
,
691 .set
= uvc_ctrl_set_zoom
,
694 .id
= V4L2_CID_PAN_ABSOLUTE
,
695 .entity
= UVC_GUID_UVC_CAMERA
,
696 .selector
= UVC_CT_PANTILT_ABSOLUTE_CONTROL
,
699 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
700 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
703 .id
= V4L2_CID_TILT_ABSOLUTE
,
704 .entity
= UVC_GUID_UVC_CAMERA
,
705 .selector
= UVC_CT_PANTILT_ABSOLUTE_CONTROL
,
708 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
709 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
712 .id
= V4L2_CID_PAN_SPEED
,
713 .entity
= UVC_GUID_UVC_CAMERA
,
714 .selector
= UVC_CT_PANTILT_RELATIVE_CONTROL
,
717 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
718 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
719 .get
= uvc_ctrl_get_rel_speed
,
720 .set
= uvc_ctrl_set_rel_speed
,
723 .id
= V4L2_CID_TILT_SPEED
,
724 .entity
= UVC_GUID_UVC_CAMERA
,
725 .selector
= UVC_CT_PANTILT_RELATIVE_CONTROL
,
728 .v4l2_type
= V4L2_CTRL_TYPE_INTEGER
,
729 .data_type
= UVC_CTRL_DATA_TYPE_SIGNED
,
730 .get
= uvc_ctrl_get_rel_speed
,
731 .set
= uvc_ctrl_set_rel_speed
,
734 .id
= V4L2_CID_PRIVACY
,
735 .entity
= UVC_GUID_UVC_CAMERA
,
736 .selector
= UVC_CT_PRIVACY_CONTROL
,
739 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
740 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
743 .id
= V4L2_CID_PRIVACY
,
744 .entity
= UVC_GUID_EXT_GPIO_CONTROLLER
,
745 .selector
= UVC_CT_PRIVACY_CONTROL
,
748 .v4l2_type
= V4L2_CTRL_TYPE_BOOLEAN
,
749 .data_type
= UVC_CTRL_DATA_TYPE_BOOLEAN
,
753 const struct uvc_control_mapping uvc_ctrl_power_line_mapping_limited
= {
754 .id
= V4L2_CID_POWER_LINE_FREQUENCY
,
755 .entity
= UVC_GUID_UVC_PROCESSING
,
756 .selector
= UVC_PU_POWER_LINE_FREQUENCY_CONTROL
,
759 .v4l2_type
= V4L2_CTRL_TYPE_MENU
,
760 .data_type
= UVC_CTRL_DATA_TYPE_ENUM
,
761 .menu_mask
= GENMASK(V4L2_CID_POWER_LINE_FREQUENCY_60HZ
,
762 V4L2_CID_POWER_LINE_FREQUENCY_50HZ
),
765 const struct uvc_control_mapping uvc_ctrl_power_line_mapping_uvc11
= {
766 .id
= V4L2_CID_POWER_LINE_FREQUENCY
,
767 .entity
= UVC_GUID_UVC_PROCESSING
,
768 .selector
= UVC_PU_POWER_LINE_FREQUENCY_CONTROL
,
771 .v4l2_type
= V4L2_CTRL_TYPE_MENU
,
772 .data_type
= UVC_CTRL_DATA_TYPE_ENUM
,
773 .menu_mask
= GENMASK(V4L2_CID_POWER_LINE_FREQUENCY_60HZ
,
774 V4L2_CID_POWER_LINE_FREQUENCY_DISABLED
),
777 static const struct uvc_control_mapping
*uvc_ctrl_mappings_uvc11
[] = {
778 &uvc_ctrl_power_line_mapping_uvc11
,
782 static const struct uvc_control_mapping uvc_ctrl_power_line_mapping_uvc15
= {
783 .id
= V4L2_CID_POWER_LINE_FREQUENCY
,
784 .entity
= UVC_GUID_UVC_PROCESSING
,
785 .selector
= UVC_PU_POWER_LINE_FREQUENCY_CONTROL
,
788 .v4l2_type
= V4L2_CTRL_TYPE_MENU
,
789 .data_type
= UVC_CTRL_DATA_TYPE_ENUM
,
790 .menu_mask
= GENMASK(V4L2_CID_POWER_LINE_FREQUENCY_AUTO
,
791 V4L2_CID_POWER_LINE_FREQUENCY_DISABLED
),
794 static const struct uvc_control_mapping
*uvc_ctrl_mappings_uvc15
[] = {
795 &uvc_ctrl_power_line_mapping_uvc15
,
799 /* ------------------------------------------------------------------------
803 static inline u8
*uvc_ctrl_data(struct uvc_control
*ctrl
, int id
)
805 return ctrl
->uvc_data
+ id
* ctrl
->info
.size
;
808 static inline int uvc_test_bit(const u8
*data
, int bit
)
810 return (data
[bit
>> 3] >> (bit
& 7)) & 1;
813 static inline void uvc_clear_bit(u8
*data
, int bit
)
815 data
[bit
>> 3] &= ~(1 << (bit
& 7));
819 * Extract the bit string specified by mapping->offset and mapping->size
820 * from the little-endian data stored at 'data' and return the result as
821 * a signed 32bit integer. Sign extension will be performed if the mapping
822 * references a signed data type.
824 static s32
uvc_get_le_value(struct uvc_control_mapping
*mapping
,
825 u8 query
, const u8
*data
)
827 int bits
= mapping
->size
;
828 int offset
= mapping
->offset
;
834 mask
= ((1LL << bits
) - 1) << offset
;
837 u8 byte
= *data
& mask
;
838 value
|= offset
> 0 ? (byte
>> offset
) : (byte
<< (-offset
));
839 bits
-= 8 - (offset
> 0 ? offset
: 0);
844 mask
= (1 << bits
) - 1;
848 /* Sign-extend the value if needed. */
849 if (mapping
->data_type
== UVC_CTRL_DATA_TYPE_SIGNED
)
850 value
|= -(value
& (1 << (mapping
->size
- 1)));
856 * Set the bit string specified by mapping->offset and mapping->size
857 * in the little-endian data stored at 'data' to the value 'value'.
859 static void uvc_set_le_value(struct uvc_control_mapping
*mapping
,
862 int bits
= mapping
->size
;
863 int offset
= mapping
->offset
;
867 * According to the v4l2 spec, writing any value to a button control
868 * should result in the action belonging to the button control being
869 * triggered. UVC devices however want to see a 1 written -> override
872 if (mapping
->v4l2_type
== V4L2_CTRL_TYPE_BUTTON
)
878 for (; bits
> 0; data
++) {
879 mask
= ((1LL << bits
) - 1) << offset
;
880 *data
= (*data
& ~mask
) | ((value
<< offset
) & mask
);
881 value
>>= offset
? offset
: 8;
887 /* ------------------------------------------------------------------------
888 * Terminal and unit management
891 static int uvc_entity_match_guid(const struct uvc_entity
*entity
,
894 return memcmp(entity
->guid
, guid
, sizeof(entity
->guid
)) == 0;
897 /* ------------------------------------------------------------------------
901 static void __uvc_find_control(struct uvc_entity
*entity
, u32 v4l2_id
,
902 struct uvc_control_mapping
**mapping
, struct uvc_control
**control
,
905 struct uvc_control
*ctrl
;
906 struct uvc_control_mapping
*map
;
912 for (i
= 0; i
< entity
->ncontrols
; ++i
) {
913 ctrl
= &entity
->controls
[i
];
914 if (!ctrl
->initialized
)
917 list_for_each_entry(map
, &ctrl
->info
.mappings
, list
) {
918 if ((map
->id
== v4l2_id
) && !next
) {
924 if ((*mapping
== NULL
|| (*mapping
)->id
> map
->id
) &&
925 (map
->id
> v4l2_id
) && next
) {
933 static struct uvc_control
*uvc_find_control(struct uvc_video_chain
*chain
,
934 u32 v4l2_id
, struct uvc_control_mapping
**mapping
)
936 struct uvc_control
*ctrl
= NULL
;
937 struct uvc_entity
*entity
;
938 int next
= v4l2_id
& V4L2_CTRL_FLAG_NEXT_CTRL
;
942 /* Mask the query flags. */
943 v4l2_id
&= V4L2_CTRL_ID_MASK
;
945 /* Find the control. */
946 list_for_each_entry(entity
, &chain
->entities
, chain
) {
947 __uvc_find_control(entity
, v4l2_id
, mapping
, &ctrl
, next
);
952 if (ctrl
== NULL
&& !next
)
953 uvc_dbg(chain
->dev
, CONTROL
, "Control 0x%08x not found\n",
959 static int uvc_ctrl_populate_cache(struct uvc_video_chain
*chain
,
960 struct uvc_control
*ctrl
)
964 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_DEF
) {
965 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_DEF
, ctrl
->entity
->id
,
966 chain
->dev
->intfnum
, ctrl
->info
.selector
,
967 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_DEF
),
973 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_MIN
) {
974 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_MIN
, ctrl
->entity
->id
,
975 chain
->dev
->intfnum
, ctrl
->info
.selector
,
976 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MIN
),
981 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_MAX
) {
982 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_MAX
, ctrl
->entity
->id
,
983 chain
->dev
->intfnum
, ctrl
->info
.selector
,
984 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MAX
),
989 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_RES
) {
990 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_RES
, ctrl
->entity
->id
,
991 chain
->dev
->intfnum
, ctrl
->info
.selector
,
992 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_RES
),
995 if (UVC_ENTITY_TYPE(ctrl
->entity
) !=
996 UVC_VC_EXTENSION_UNIT
)
1000 * GET_RES is mandatory for XU controls, but some
1001 * cameras still choke on it. Ignore errors and set the
1002 * resolution value to zero.
1004 uvc_warn_once(chain
->dev
, UVC_WARN_XU_GET_RES
,
1005 "UVC non compliance - GET_RES failed on "
1006 "an XU control. Enabling workaround.\n");
1007 memset(uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_RES
), 0,
1016 static s32
__uvc_ctrl_get_value(struct uvc_control_mapping
*mapping
,
1019 s32 value
= mapping
->get(mapping
, UVC_GET_CUR
, data
);
1021 if (mapping
->v4l2_type
== V4L2_CTRL_TYPE_MENU
) {
1024 for (i
= 0; BIT(i
) <= mapping
->menu_mask
; ++i
) {
1027 if (!test_bit(i
, &mapping
->menu_mask
))
1030 menu_value
= uvc_mapping_get_menu_value(mapping
, i
);
1032 if (menu_value
== value
) {
1042 static int __uvc_ctrl_load_cur(struct uvc_video_chain
*chain
,
1043 struct uvc_control
*ctrl
)
1051 data
= uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_CURRENT
);
1053 if ((ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
) == 0) {
1054 memset(data
, 0, ctrl
->info
.size
);
1060 if (ctrl
->entity
->get_cur
)
1061 ret
= ctrl
->entity
->get_cur(chain
->dev
, ctrl
->entity
,
1062 ctrl
->info
.selector
, data
,
1065 ret
= uvc_query_ctrl(chain
->dev
, UVC_GET_CUR
,
1066 ctrl
->entity
->id
, chain
->dev
->intfnum
,
1067 ctrl
->info
.selector
, data
,
1078 static int __uvc_ctrl_get(struct uvc_video_chain
*chain
,
1079 struct uvc_control
*ctrl
,
1080 struct uvc_control_mapping
*mapping
,
1085 if ((ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
) == 0)
1088 ret
= __uvc_ctrl_load_cur(chain
, ctrl
);
1092 *value
= __uvc_ctrl_get_value(mapping
,
1093 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_CURRENT
));
1098 static int __uvc_query_v4l2_class(struct uvc_video_chain
*chain
, u32 req_id
,
1101 bool find_next
= req_id
& V4L2_CTRL_FLAG_NEXT_CTRL
;
1104 req_id
&= V4L2_CTRL_ID_MASK
;
1106 for (i
= 0; i
< ARRAY_SIZE(uvc_control_classes
); i
++) {
1107 if (!(chain
->ctrl_class_bitmap
& BIT(i
)))
1110 if (uvc_control_classes
[i
] == req_id
)
1114 if (uvc_control_classes
[i
] > req_id
&&
1115 uvc_control_classes
[i
] < found_id
)
1122 static int uvc_query_v4l2_class(struct uvc_video_chain
*chain
, u32 req_id
,
1123 u32 found_id
, struct v4l2_queryctrl
*v4l2_ctrl
)
1127 idx
= __uvc_query_v4l2_class(chain
, req_id
, found_id
);
1131 memset(v4l2_ctrl
, 0, sizeof(*v4l2_ctrl
));
1132 v4l2_ctrl
->id
= uvc_control_classes
[idx
];
1133 strscpy(v4l2_ctrl
->name
, v4l2_ctrl_get_name(v4l2_ctrl
->id
),
1134 sizeof(v4l2_ctrl
->name
));
1135 v4l2_ctrl
->type
= V4L2_CTRL_TYPE_CTRL_CLASS
;
1136 v4l2_ctrl
->flags
= V4L2_CTRL_FLAG_WRITE_ONLY
1137 | V4L2_CTRL_FLAG_READ_ONLY
;
1142 * Check if control @v4l2_id can be accessed by the given control @ioctl
1143 * (VIDIOC_G_EXT_CTRLS, VIDIOC_TRY_EXT_CTRLS or VIDIOC_S_EXT_CTRLS).
1145 * For set operations on slave controls, check if the master's value is set to
1146 * manual, either in the others controls set in the same ioctl call, or from
1147 * the master's current value. This catches VIDIOC_S_EXT_CTRLS calls that set
1148 * both the master and slave control, such as for instance setting
1149 * auto_exposure=1, exposure_time_absolute=251.
1151 int uvc_ctrl_is_accessible(struct uvc_video_chain
*chain
, u32 v4l2_id
,
1152 const struct v4l2_ext_controls
*ctrls
,
1153 unsigned long ioctl
)
1155 struct uvc_control_mapping
*master_map
= NULL
;
1156 struct uvc_control
*master_ctrl
= NULL
;
1157 struct uvc_control_mapping
*mapping
;
1158 struct uvc_control
*ctrl
;
1159 bool read
= ioctl
== VIDIOC_G_EXT_CTRLS
;
1164 if (__uvc_query_v4l2_class(chain
, v4l2_id
, 0) >= 0)
1167 ctrl
= uvc_find_control(chain
, v4l2_id
, &mapping
);
1171 if (!(ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
) && read
)
1174 if (!(ctrl
->info
.flags
& UVC_CTRL_FLAG_SET_CUR
) && !read
)
1177 if (ioctl
!= VIDIOC_S_EXT_CTRLS
|| !mapping
->master_id
)
1181 * Iterate backwards in cases where the master control is accessed
1182 * multiple times in the same ioctl. We want the last value.
1184 for (i
= ctrls
->count
- 1; i
>= 0; i
--) {
1185 if (ctrls
->controls
[i
].id
== mapping
->master_id
)
1186 return ctrls
->controls
[i
].value
==
1187 mapping
->master_manual
? 0 : -EACCES
;
1190 __uvc_find_control(ctrl
->entity
, mapping
->master_id
, &master_map
,
1193 if (!master_ctrl
|| !(master_ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
))
1196 ret
= __uvc_ctrl_get(chain
, master_ctrl
, master_map
, &val
);
1197 if (ret
>= 0 && val
!= mapping
->master_manual
)
1203 static const char *uvc_map_get_name(const struct uvc_control_mapping
*map
)
1210 name
= v4l2_ctrl_get_name(map
->id
);
1214 return "Unknown Control";
1217 static u32
uvc_get_ctrl_bitmap(struct uvc_control
*ctrl
,
1218 struct uvc_control_mapping
*mapping
)
1221 * Some controls, like CT_AE_MODE_CONTROL, use GET_RES to represent
1222 * the number of bits supported. Those controls do not list GET_MAX
1225 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_RES
)
1226 return mapping
->get(mapping
, UVC_GET_RES
,
1227 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_RES
));
1229 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_MAX
)
1230 return mapping
->get(mapping
, UVC_GET_MAX
,
1231 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MAX
));
1236 static int __uvc_query_v4l2_ctrl(struct uvc_video_chain
*chain
,
1237 struct uvc_control
*ctrl
,
1238 struct uvc_control_mapping
*mapping
,
1239 struct v4l2_queryctrl
*v4l2_ctrl
)
1241 struct uvc_control_mapping
*master_map
= NULL
;
1242 struct uvc_control
*master_ctrl
= NULL
;
1245 memset(v4l2_ctrl
, 0, sizeof(*v4l2_ctrl
));
1246 v4l2_ctrl
->id
= mapping
->id
;
1247 v4l2_ctrl
->type
= mapping
->v4l2_type
;
1248 strscpy(v4l2_ctrl
->name
, uvc_map_get_name(mapping
),
1249 sizeof(v4l2_ctrl
->name
));
1250 v4l2_ctrl
->flags
= 0;
1252 if (!(ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
))
1253 v4l2_ctrl
->flags
|= V4L2_CTRL_FLAG_WRITE_ONLY
;
1254 if (!(ctrl
->info
.flags
& UVC_CTRL_FLAG_SET_CUR
))
1255 v4l2_ctrl
->flags
|= V4L2_CTRL_FLAG_READ_ONLY
;
1257 if (mapping
->master_id
)
1258 __uvc_find_control(ctrl
->entity
, mapping
->master_id
,
1259 &master_map
, &master_ctrl
, 0);
1260 if (master_ctrl
&& (master_ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
)) {
1262 int ret
= __uvc_ctrl_get(chain
, master_ctrl
, master_map
, &val
);
1266 if (val
!= mapping
->master_manual
)
1267 v4l2_ctrl
->flags
|= V4L2_CTRL_FLAG_INACTIVE
;
1270 if (!ctrl
->cached
) {
1271 int ret
= uvc_ctrl_populate_cache(chain
, ctrl
);
1276 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_DEF
) {
1277 v4l2_ctrl
->default_value
= mapping
->get(mapping
, UVC_GET_DEF
,
1278 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_DEF
));
1281 switch (mapping
->v4l2_type
) {
1282 case V4L2_CTRL_TYPE_MENU
:
1283 v4l2_ctrl
->minimum
= ffs(mapping
->menu_mask
) - 1;
1284 v4l2_ctrl
->maximum
= fls(mapping
->menu_mask
) - 1;
1285 v4l2_ctrl
->step
= 1;
1287 for (i
= 0; BIT(i
) <= mapping
->menu_mask
; ++i
) {
1290 if (!test_bit(i
, &mapping
->menu_mask
))
1293 menu_value
= uvc_mapping_get_menu_value(mapping
, i
);
1295 if (menu_value
== v4l2_ctrl
->default_value
) {
1296 v4l2_ctrl
->default_value
= i
;
1303 case V4L2_CTRL_TYPE_BOOLEAN
:
1304 v4l2_ctrl
->minimum
= 0;
1305 v4l2_ctrl
->maximum
= 1;
1306 v4l2_ctrl
->step
= 1;
1309 case V4L2_CTRL_TYPE_BUTTON
:
1310 v4l2_ctrl
->minimum
= 0;
1311 v4l2_ctrl
->maximum
= 0;
1312 v4l2_ctrl
->step
= 0;
1315 case V4L2_CTRL_TYPE_BITMASK
:
1316 v4l2_ctrl
->minimum
= 0;
1317 v4l2_ctrl
->maximum
= uvc_get_ctrl_bitmap(ctrl
, mapping
);
1318 v4l2_ctrl
->step
= 0;
1325 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_MIN
)
1326 v4l2_ctrl
->minimum
= mapping
->get(mapping
, UVC_GET_MIN
,
1327 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MIN
));
1329 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_MAX
)
1330 v4l2_ctrl
->maximum
= mapping
->get(mapping
, UVC_GET_MAX
,
1331 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MAX
));
1333 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_RES
)
1334 v4l2_ctrl
->step
= mapping
->get(mapping
, UVC_GET_RES
,
1335 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_RES
));
1340 int uvc_query_v4l2_ctrl(struct uvc_video_chain
*chain
,
1341 struct v4l2_queryctrl
*v4l2_ctrl
)
1343 struct uvc_control
*ctrl
;
1344 struct uvc_control_mapping
*mapping
;
1347 ret
= mutex_lock_interruptible(&chain
->ctrl_mutex
);
1349 return -ERESTARTSYS
;
1351 /* Check if the ctrl is a know class */
1352 if (!(v4l2_ctrl
->id
& V4L2_CTRL_FLAG_NEXT_CTRL
)) {
1353 ret
= uvc_query_v4l2_class(chain
, v4l2_ctrl
->id
, 0, v4l2_ctrl
);
1358 ctrl
= uvc_find_control(chain
, v4l2_ctrl
->id
, &mapping
);
1365 * If we're enumerating control with V4L2_CTRL_FLAG_NEXT_CTRL, check if
1366 * a class should be inserted between the previous control and the one
1367 * we have just found.
1369 if (v4l2_ctrl
->id
& V4L2_CTRL_FLAG_NEXT_CTRL
) {
1370 ret
= uvc_query_v4l2_class(chain
, v4l2_ctrl
->id
, mapping
->id
,
1376 ret
= __uvc_query_v4l2_ctrl(chain
, ctrl
, mapping
, v4l2_ctrl
);
1378 mutex_unlock(&chain
->ctrl_mutex
);
1383 * Mapping V4L2 controls to UVC controls can be straightforward if done well.
1384 * Most of the UVC controls exist in V4L2, and can be mapped directly. Some
1385 * must be grouped (for instance the Red Balance, Blue Balance and Do White
1386 * Balance V4L2 controls use the White Balance Component UVC control) or
1387 * otherwise translated. The approach we take here is to use a translation
1388 * table for the controls that can be mapped directly, and handle the others
1391 int uvc_query_v4l2_menu(struct uvc_video_chain
*chain
,
1392 struct v4l2_querymenu
*query_menu
)
1394 struct uvc_control_mapping
*mapping
;
1395 struct uvc_control
*ctrl
;
1396 u32 index
= query_menu
->index
;
1397 u32 id
= query_menu
->id
;
1401 memset(query_menu
, 0, sizeof(*query_menu
));
1402 query_menu
->id
= id
;
1403 query_menu
->index
= index
;
1405 if (index
>= BITS_PER_TYPE(mapping
->menu_mask
))
1408 ret
= mutex_lock_interruptible(&chain
->ctrl_mutex
);
1410 return -ERESTARTSYS
;
1412 ctrl
= uvc_find_control(chain
, query_menu
->id
, &mapping
);
1413 if (ctrl
== NULL
|| mapping
->v4l2_type
!= V4L2_CTRL_TYPE_MENU
) {
1418 if (!test_bit(query_menu
->index
, &mapping
->menu_mask
)) {
1423 if (mapping
->data_type
== UVC_CTRL_DATA_TYPE_BITMASK
) {
1426 if (!ctrl
->cached
) {
1427 ret
= uvc_ctrl_populate_cache(chain
, ctrl
);
1432 mask
= uvc_mapping_get_menu_value(mapping
, query_menu
->index
);
1438 if (!(uvc_get_ctrl_bitmap(ctrl
, mapping
) & mask
)) {
1444 name
= uvc_mapping_get_menu_name(mapping
, query_menu
->index
);
1450 strscpy(query_menu
->name
, name
, sizeof(query_menu
->name
));
1453 mutex_unlock(&chain
->ctrl_mutex
);
1457 /* --------------------------------------------------------------------------
1458 * Ctrl event handling
1461 static void uvc_ctrl_fill_event(struct uvc_video_chain
*chain
,
1462 struct v4l2_event
*ev
,
1463 struct uvc_control
*ctrl
,
1464 struct uvc_control_mapping
*mapping
,
1465 s32 value
, u32 changes
)
1467 struct v4l2_queryctrl v4l2_ctrl
;
1469 __uvc_query_v4l2_ctrl(chain
, ctrl
, mapping
, &v4l2_ctrl
);
1471 memset(ev
, 0, sizeof(*ev
));
1472 ev
->type
= V4L2_EVENT_CTRL
;
1473 ev
->id
= v4l2_ctrl
.id
;
1474 ev
->u
.ctrl
.value
= value
;
1475 ev
->u
.ctrl
.changes
= changes
;
1476 ev
->u
.ctrl
.type
= v4l2_ctrl
.type
;
1477 ev
->u
.ctrl
.flags
= v4l2_ctrl
.flags
;
1478 ev
->u
.ctrl
.minimum
= v4l2_ctrl
.minimum
;
1479 ev
->u
.ctrl
.maximum
= v4l2_ctrl
.maximum
;
1480 ev
->u
.ctrl
.step
= v4l2_ctrl
.step
;
1481 ev
->u
.ctrl
.default_value
= v4l2_ctrl
.default_value
;
1485 * Send control change events to all subscribers for the @ctrl control. By
1486 * default the subscriber that generated the event, as identified by @handle,
1487 * is not notified unless it has set the V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK flag.
1488 * @handle can be NULL for asynchronous events related to auto-update controls,
1489 * in which case all subscribers are notified.
1491 static void uvc_ctrl_send_event(struct uvc_video_chain
*chain
,
1492 struct uvc_fh
*handle
, struct uvc_control
*ctrl
,
1493 struct uvc_control_mapping
*mapping
, s32 value
, u32 changes
)
1495 struct v4l2_fh
*originator
= handle
? &handle
->vfh
: NULL
;
1496 struct v4l2_subscribed_event
*sev
;
1497 struct v4l2_event ev
;
1499 if (list_empty(&mapping
->ev_subs
))
1502 uvc_ctrl_fill_event(chain
, &ev
, ctrl
, mapping
, value
, changes
);
1504 list_for_each_entry(sev
, &mapping
->ev_subs
, node
) {
1505 if (sev
->fh
!= originator
||
1506 (sev
->flags
& V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK
) ||
1507 (changes
& V4L2_EVENT_CTRL_CH_FLAGS
))
1508 v4l2_event_queue_fh(sev
->fh
, &ev
);
1513 * Send control change events for the slave of the @master control identified
1514 * by the V4L2 ID @slave_id. The @handle identifies the event subscriber that
1515 * generated the event and may be NULL for auto-update events.
1517 static void uvc_ctrl_send_slave_event(struct uvc_video_chain
*chain
,
1518 struct uvc_fh
*handle
, struct uvc_control
*master
, u32 slave_id
)
1520 struct uvc_control_mapping
*mapping
= NULL
;
1521 struct uvc_control
*ctrl
= NULL
;
1522 u32 changes
= V4L2_EVENT_CTRL_CH_FLAGS
;
1525 __uvc_find_control(master
->entity
, slave_id
, &mapping
, &ctrl
, 0);
1529 if (__uvc_ctrl_get(chain
, ctrl
, mapping
, &val
) == 0)
1530 changes
|= V4L2_EVENT_CTRL_CH_VALUE
;
1532 uvc_ctrl_send_event(chain
, handle
, ctrl
, mapping
, val
, changes
);
1535 void uvc_ctrl_status_event(struct uvc_video_chain
*chain
,
1536 struct uvc_control
*ctrl
, const u8
*data
)
1538 struct uvc_control_mapping
*mapping
;
1539 struct uvc_fh
*handle
;
1542 mutex_lock(&chain
->ctrl_mutex
);
1544 handle
= ctrl
->handle
;
1545 ctrl
->handle
= NULL
;
1547 list_for_each_entry(mapping
, &ctrl
->info
.mappings
, list
) {
1548 s32 value
= __uvc_ctrl_get_value(mapping
, data
);
1551 * handle may be NULL here if the device sends auto-update
1552 * events without a prior related control set from userspace.
1554 for (i
= 0; i
< ARRAY_SIZE(mapping
->slave_ids
); ++i
) {
1555 if (!mapping
->slave_ids
[i
])
1558 uvc_ctrl_send_slave_event(chain
, handle
, ctrl
,
1559 mapping
->slave_ids
[i
]);
1562 uvc_ctrl_send_event(chain
, handle
, ctrl
, mapping
, value
,
1563 V4L2_EVENT_CTRL_CH_VALUE
);
1566 mutex_unlock(&chain
->ctrl_mutex
);
1569 static void uvc_ctrl_status_event_work(struct work_struct
*work
)
1571 struct uvc_device
*dev
= container_of(work
, struct uvc_device
,
1573 struct uvc_ctrl_work
*w
= &dev
->async_ctrl
;
1576 uvc_ctrl_status_event(w
->chain
, w
->ctrl
, w
->data
);
1578 /* The barrier is needed to synchronize with uvc_status_stop(). */
1579 if (smp_load_acquire(&dev
->flush_status
))
1582 /* Resubmit the URB. */
1583 w
->urb
->interval
= dev
->int_ep
->desc
.bInterval
;
1584 ret
= usb_submit_urb(w
->urb
, GFP_KERNEL
);
1586 dev_err(&dev
->udev
->dev
,
1587 "Failed to resubmit status URB (%d).\n", ret
);
1590 bool uvc_ctrl_status_event_async(struct urb
*urb
, struct uvc_video_chain
*chain
,
1591 struct uvc_control
*ctrl
, const u8
*data
)
1593 struct uvc_device
*dev
= chain
->dev
;
1594 struct uvc_ctrl_work
*w
= &dev
->async_ctrl
;
1596 if (list_empty(&ctrl
->info
.mappings
)) {
1597 ctrl
->handle
= NULL
;
1606 schedule_work(&w
->work
);
1611 static bool uvc_ctrl_xctrls_has_control(const struct v4l2_ext_control
*xctrls
,
1612 unsigned int xctrls_count
, u32 id
)
1616 for (i
= 0; i
< xctrls_count
; ++i
) {
1617 if (xctrls
[i
].id
== id
)
1624 static void uvc_ctrl_send_events(struct uvc_fh
*handle
,
1625 const struct v4l2_ext_control
*xctrls
, unsigned int xctrls_count
)
1627 struct uvc_control_mapping
*mapping
;
1628 struct uvc_control
*ctrl
;
1629 u32 changes
= V4L2_EVENT_CTRL_CH_VALUE
;
1633 for (i
= 0; i
< xctrls_count
; ++i
) {
1634 ctrl
= uvc_find_control(handle
->chain
, xctrls
[i
].id
, &mapping
);
1636 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_ASYNCHRONOUS
)
1637 /* Notification will be sent from an Interrupt event. */
1640 for (j
= 0; j
< ARRAY_SIZE(mapping
->slave_ids
); ++j
) {
1641 u32 slave_id
= mapping
->slave_ids
[j
];
1647 * We can skip sending an event for the slave if the
1648 * slave is being modified in the same transaction.
1650 if (uvc_ctrl_xctrls_has_control(xctrls
, xctrls_count
,
1654 uvc_ctrl_send_slave_event(handle
->chain
, handle
, ctrl
,
1659 * If the master is being modified in the same transaction
1660 * flags may change too.
1662 if (mapping
->master_id
&&
1663 uvc_ctrl_xctrls_has_control(xctrls
, xctrls_count
,
1664 mapping
->master_id
))
1665 changes
|= V4L2_EVENT_CTRL_CH_FLAGS
;
1667 uvc_ctrl_send_event(handle
->chain
, handle
, ctrl
, mapping
,
1668 xctrls
[i
].value
, changes
);
1672 static int uvc_ctrl_add_event(struct v4l2_subscribed_event
*sev
, unsigned elems
)
1674 struct uvc_fh
*handle
= container_of(sev
->fh
, struct uvc_fh
, vfh
);
1675 struct uvc_control_mapping
*mapping
;
1676 struct uvc_control
*ctrl
;
1679 ret
= mutex_lock_interruptible(&handle
->chain
->ctrl_mutex
);
1681 return -ERESTARTSYS
;
1683 if (__uvc_query_v4l2_class(handle
->chain
, sev
->id
, 0) >= 0) {
1688 ctrl
= uvc_find_control(handle
->chain
, sev
->id
, &mapping
);
1694 list_add_tail(&sev
->node
, &mapping
->ev_subs
);
1695 if (sev
->flags
& V4L2_EVENT_SUB_FL_SEND_INITIAL
) {
1696 struct v4l2_event ev
;
1697 u32 changes
= V4L2_EVENT_CTRL_CH_FLAGS
;
1700 if (__uvc_ctrl_get(handle
->chain
, ctrl
, mapping
, &val
) == 0)
1701 changes
|= V4L2_EVENT_CTRL_CH_VALUE
;
1703 uvc_ctrl_fill_event(handle
->chain
, &ev
, ctrl
, mapping
, val
,
1706 * Mark the queue as active, allowing this initial event to be
1710 v4l2_event_queue_fh(sev
->fh
, &ev
);
1714 mutex_unlock(&handle
->chain
->ctrl_mutex
);
1718 static void uvc_ctrl_del_event(struct v4l2_subscribed_event
*sev
)
1720 struct uvc_fh
*handle
= container_of(sev
->fh
, struct uvc_fh
, vfh
);
1722 mutex_lock(&handle
->chain
->ctrl_mutex
);
1723 if (__uvc_query_v4l2_class(handle
->chain
, sev
->id
, 0) >= 0)
1725 list_del(&sev
->node
);
1727 mutex_unlock(&handle
->chain
->ctrl_mutex
);
1730 const struct v4l2_subscribed_event_ops uvc_ctrl_sub_ev_ops
= {
1731 .add
= uvc_ctrl_add_event
,
1732 .del
= uvc_ctrl_del_event
,
1733 .replace
= v4l2_ctrl_replace
,
1734 .merge
= v4l2_ctrl_merge
,
1737 /* --------------------------------------------------------------------------
1738 * Control transactions
1740 * To make extended set operations as atomic as the hardware allows, controls
1741 * are handled using begin/commit/rollback operations.
1743 * At the beginning of a set request, uvc_ctrl_begin should be called to
1744 * initialize the request. This function acquires the control lock.
1746 * When setting a control, the new value is stored in the control data field
1747 * at position UVC_CTRL_DATA_CURRENT. The control is then marked as dirty for
1748 * later processing. If the UVC and V4L2 control sizes differ, the current
1749 * value is loaded from the hardware before storing the new value in the data
1752 * After processing all controls in the transaction, uvc_ctrl_commit or
1753 * uvc_ctrl_rollback must be called to apply the pending changes to the
1754 * hardware or revert them. When applying changes, all controls marked as
1755 * dirty will be modified in the UVC device, and the dirty flag will be
1756 * cleared. When reverting controls, the control data field
1757 * UVC_CTRL_DATA_CURRENT is reverted to its previous value
1758 * (UVC_CTRL_DATA_BACKUP) for all dirty controls. Both functions release the
1761 int uvc_ctrl_begin(struct uvc_video_chain
*chain
)
1763 return mutex_lock_interruptible(&chain
->ctrl_mutex
) ? -ERESTARTSYS
: 0;
1766 static int uvc_ctrl_commit_entity(struct uvc_device
*dev
,
1767 struct uvc_entity
*entity
, int rollback
, struct uvc_control
**err_ctrl
)
1769 struct uvc_control
*ctrl
;
1776 for (i
= 0; i
< entity
->ncontrols
; ++i
) {
1777 ctrl
= &entity
->controls
[i
];
1778 if (!ctrl
->initialized
)
1782 * Reset the loaded flag for auto-update controls that were
1783 * marked as loaded in uvc_ctrl_get/uvc_ctrl_set to prevent
1784 * uvc_ctrl_get from using the cached value, and for write-only
1785 * controls to prevent uvc_ctrl_set from setting bits not
1786 * explicitly set by the user.
1788 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_AUTO_UPDATE
||
1789 !(ctrl
->info
.flags
& UVC_CTRL_FLAG_GET_CUR
))
1796 ret
= uvc_query_ctrl(dev
, UVC_SET_CUR
, ctrl
->entity
->id
,
1797 dev
->intfnum
, ctrl
->info
.selector
,
1798 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_CURRENT
),
1803 if (rollback
|| ret
< 0)
1804 memcpy(uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_CURRENT
),
1805 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_BACKUP
),
1820 static int uvc_ctrl_find_ctrl_idx(struct uvc_entity
*entity
,
1821 struct v4l2_ext_controls
*ctrls
,
1822 struct uvc_control
*uvc_control
)
1824 struct uvc_control_mapping
*mapping
= NULL
;
1825 struct uvc_control
*ctrl_found
= NULL
;
1829 return ctrls
->count
;
1831 for (i
= 0; i
< ctrls
->count
; i
++) {
1832 __uvc_find_control(entity
, ctrls
->controls
[i
].id
, &mapping
,
1834 if (uvc_control
== ctrl_found
)
1838 return ctrls
->count
;
1841 int __uvc_ctrl_commit(struct uvc_fh
*handle
, int rollback
,
1842 struct v4l2_ext_controls
*ctrls
)
1844 struct uvc_video_chain
*chain
= handle
->chain
;
1845 struct uvc_control
*err_ctrl
;
1846 struct uvc_entity
*entity
;
1849 /* Find the control. */
1850 list_for_each_entry(entity
, &chain
->entities
, chain
) {
1851 ret
= uvc_ctrl_commit_entity(chain
->dev
, entity
, rollback
,
1858 uvc_ctrl_send_events(handle
, ctrls
->controls
, ctrls
->count
);
1860 if (ret
< 0 && ctrls
)
1861 ctrls
->error_idx
= uvc_ctrl_find_ctrl_idx(entity
, ctrls
,
1863 mutex_unlock(&chain
->ctrl_mutex
);
1867 int uvc_ctrl_get(struct uvc_video_chain
*chain
,
1868 struct v4l2_ext_control
*xctrl
)
1870 struct uvc_control
*ctrl
;
1871 struct uvc_control_mapping
*mapping
;
1873 if (__uvc_query_v4l2_class(chain
, xctrl
->id
, 0) >= 0)
1876 ctrl
= uvc_find_control(chain
, xctrl
->id
, &mapping
);
1880 return __uvc_ctrl_get(chain
, ctrl
, mapping
, &xctrl
->value
);
1883 int uvc_ctrl_set(struct uvc_fh
*handle
,
1884 struct v4l2_ext_control
*xctrl
)
1886 struct uvc_video_chain
*chain
= handle
->chain
;
1887 struct uvc_control
*ctrl
;
1888 struct uvc_control_mapping
*mapping
;
1895 if (__uvc_query_v4l2_class(chain
, xctrl
->id
, 0) >= 0)
1898 ctrl
= uvc_find_control(chain
, xctrl
->id
, &mapping
);
1901 if (!(ctrl
->info
.flags
& UVC_CTRL_FLAG_SET_CUR
))
1904 /* Clamp out of range values. */
1905 switch (mapping
->v4l2_type
) {
1906 case V4L2_CTRL_TYPE_INTEGER
:
1907 if (!ctrl
->cached
) {
1908 ret
= uvc_ctrl_populate_cache(chain
, ctrl
);
1913 min
= mapping
->get(mapping
, UVC_GET_MIN
,
1914 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MIN
));
1915 max
= mapping
->get(mapping
, UVC_GET_MAX
,
1916 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_MAX
));
1917 step
= mapping
->get(mapping
, UVC_GET_RES
,
1918 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_RES
));
1922 xctrl
->value
= min
+ DIV_ROUND_CLOSEST((u32
)(xctrl
->value
- min
),
1924 if (mapping
->data_type
== UVC_CTRL_DATA_TYPE_SIGNED
)
1925 xctrl
->value
= clamp(xctrl
->value
, min
, max
);
1927 xctrl
->value
= clamp_t(u32
, xctrl
->value
, min
, max
);
1928 value
= xctrl
->value
;
1931 case V4L2_CTRL_TYPE_BITMASK
:
1932 if (!ctrl
->cached
) {
1933 ret
= uvc_ctrl_populate_cache(chain
, ctrl
);
1938 xctrl
->value
&= uvc_get_ctrl_bitmap(ctrl
, mapping
);
1939 value
= xctrl
->value
;
1942 case V4L2_CTRL_TYPE_BOOLEAN
:
1943 xctrl
->value
= clamp(xctrl
->value
, 0, 1);
1944 value
= xctrl
->value
;
1947 case V4L2_CTRL_TYPE_MENU
:
1948 if (xctrl
->value
< (ffs(mapping
->menu_mask
) - 1) ||
1949 xctrl
->value
> (fls(mapping
->menu_mask
) - 1))
1952 if (!test_bit(xctrl
->value
, &mapping
->menu_mask
))
1955 value
= uvc_mapping_get_menu_value(mapping
, xctrl
->value
);
1958 * Valid menu indices are reported by the GET_RES request for
1959 * UVC controls that support it.
1961 if (mapping
->data_type
== UVC_CTRL_DATA_TYPE_BITMASK
) {
1962 if (!ctrl
->cached
) {
1963 ret
= uvc_ctrl_populate_cache(chain
, ctrl
);
1968 if (!(uvc_get_ctrl_bitmap(ctrl
, mapping
) & value
))
1975 value
= xctrl
->value
;
1980 * If the mapping doesn't span the whole UVC control, the current value
1981 * needs to be loaded from the device to perform the read-modify-write
1984 if ((ctrl
->info
.size
* 8) != mapping
->size
) {
1985 ret
= __uvc_ctrl_load_cur(chain
, ctrl
);
1990 /* Backup the current value in case we need to rollback later. */
1992 memcpy(uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_BACKUP
),
1993 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_CURRENT
),
1997 mapping
->set(mapping
, value
,
1998 uvc_ctrl_data(ctrl
, UVC_CTRL_DATA_CURRENT
));
2000 if (ctrl
->info
.flags
& UVC_CTRL_FLAG_ASYNCHRONOUS
)
2001 ctrl
->handle
= handle
;
2008 /* --------------------------------------------------------------------------
2013 * Retrieve flags for a given control
2015 static int uvc_ctrl_get_flags(struct uvc_device
*dev
,
2016 const struct uvc_control
*ctrl
,
2017 struct uvc_control_info
*info
)
2022 data
= kmalloc(1, GFP_KERNEL
);
2026 if (ctrl
->entity
->get_info
)
2027 ret
= ctrl
->entity
->get_info(dev
, ctrl
->entity
,
2028 ctrl
->info
.selector
, data
);
2030 ret
= uvc_query_ctrl(dev
, UVC_GET_INFO
, ctrl
->entity
->id
,
2031 dev
->intfnum
, info
->selector
, data
, 1);
2033 info
->flags
|= (data
[0] & UVC_CONTROL_CAP_GET
?
2034 UVC_CTRL_FLAG_GET_CUR
: 0)
2035 | (data
[0] & UVC_CONTROL_CAP_SET
?
2036 UVC_CTRL_FLAG_SET_CUR
: 0)
2037 | (data
[0] & UVC_CONTROL_CAP_AUTOUPDATE
?
2038 UVC_CTRL_FLAG_AUTO_UPDATE
: 0)
2039 | (data
[0] & UVC_CONTROL_CAP_ASYNCHRONOUS
?
2040 UVC_CTRL_FLAG_ASYNCHRONOUS
: 0);
2046 static void uvc_ctrl_fixup_xu_info(struct uvc_device
*dev
,
2047 const struct uvc_control
*ctrl
, struct uvc_control_info
*info
)
2049 struct uvc_ctrl_fixup
{
2050 struct usb_device_id id
;
2056 static const struct uvc_ctrl_fixup fixups
[] = {
2057 { { USB_DEVICE(0x046d, 0x08c2) }, 9, 1,
2058 UVC_CTRL_FLAG_GET_MIN
| UVC_CTRL_FLAG_GET_MAX
|
2059 UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_SET_CUR
|
2060 UVC_CTRL_FLAG_AUTO_UPDATE
},
2061 { { USB_DEVICE(0x046d, 0x08cc) }, 9, 1,
2062 UVC_CTRL_FLAG_GET_MIN
| UVC_CTRL_FLAG_GET_MAX
|
2063 UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_SET_CUR
|
2064 UVC_CTRL_FLAG_AUTO_UPDATE
},
2065 { { USB_DEVICE(0x046d, 0x0994) }, 9, 1,
2066 UVC_CTRL_FLAG_GET_MIN
| UVC_CTRL_FLAG_GET_MAX
|
2067 UVC_CTRL_FLAG_GET_DEF
| UVC_CTRL_FLAG_SET_CUR
|
2068 UVC_CTRL_FLAG_AUTO_UPDATE
},
2073 for (i
= 0; i
< ARRAY_SIZE(fixups
); ++i
) {
2074 if (!usb_match_one_id(dev
->intf
, &fixups
[i
].id
))
2077 if (fixups
[i
].entity
== ctrl
->entity
->id
&&
2078 fixups
[i
].selector
== info
->selector
) {
2079 info
->flags
= fixups
[i
].flags
;
2086 * Query control information (size and flags) for XU controls.
2088 static int uvc_ctrl_fill_xu_info(struct uvc_device
*dev
,
2089 const struct uvc_control
*ctrl
, struct uvc_control_info
*info
)
2094 data
= kmalloc(2, GFP_KERNEL
);
2098 memcpy(info
->entity
, ctrl
->entity
->guid
, sizeof(info
->entity
));
2099 info
->index
= ctrl
->index
;
2100 info
->selector
= ctrl
->index
+ 1;
2102 /* Query and verify the control length (GET_LEN) */
2103 ret
= uvc_query_ctrl(dev
, UVC_GET_LEN
, ctrl
->entity
->id
, dev
->intfnum
,
2104 info
->selector
, data
, 2);
2106 uvc_dbg(dev
, CONTROL
,
2107 "GET_LEN failed on control %pUl/%u (%d)\n",
2108 info
->entity
, info
->selector
, ret
);
2112 info
->size
= le16_to_cpup((__le16
*)data
);
2114 info
->flags
= UVC_CTRL_FLAG_GET_MIN
| UVC_CTRL_FLAG_GET_MAX
2115 | UVC_CTRL_FLAG_GET_RES
| UVC_CTRL_FLAG_GET_DEF
;
2117 ret
= uvc_ctrl_get_flags(dev
, ctrl
, info
);
2119 uvc_dbg(dev
, CONTROL
,
2120 "Failed to get flags for control %pUl/%u (%d)\n",
2121 info
->entity
, info
->selector
, ret
);
2125 uvc_ctrl_fixup_xu_info(dev
, ctrl
, info
);
2127 uvc_dbg(dev
, CONTROL
,
2128 "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }\n",
2129 info
->entity
, info
->selector
, info
->size
,
2130 (info
->flags
& UVC_CTRL_FLAG_GET_CUR
) ? 1 : 0,
2131 (info
->flags
& UVC_CTRL_FLAG_SET_CUR
) ? 1 : 0,
2132 (info
->flags
& UVC_CTRL_FLAG_AUTO_UPDATE
) ? 1 : 0);
2139 static int uvc_ctrl_add_info(struct uvc_device
*dev
, struct uvc_control
*ctrl
,
2140 const struct uvc_control_info
*info
);
2142 static int uvc_ctrl_init_xu_ctrl(struct uvc_device
*dev
,
2143 struct uvc_control
*ctrl
)
2145 struct uvc_control_info info
;
2148 if (ctrl
->initialized
)
2151 ret
= uvc_ctrl_fill_xu_info(dev
, ctrl
, &info
);
2155 ret
= uvc_ctrl_add_info(dev
, ctrl
, &info
);
2157 uvc_dbg(dev
, CONTROL
,
2158 "Failed to initialize control %pUl/%u on device %s entity %u\n",
2159 info
.entity
, info
.selector
, dev
->udev
->devpath
,
2165 int uvc_xu_ctrl_query(struct uvc_video_chain
*chain
,
2166 struct uvc_xu_control_query
*xqry
)
2168 struct uvc_entity
*entity
;
2169 struct uvc_control
*ctrl
;
2177 /* Find the extension unit. */
2179 list_for_each_entry(entity
, &chain
->entities
, chain
) {
2180 if (UVC_ENTITY_TYPE(entity
) == UVC_VC_EXTENSION_UNIT
&&
2181 entity
->id
== xqry
->unit
) {
2188 uvc_dbg(chain
->dev
, CONTROL
, "Extension unit %u not found\n",
2193 /* Find the control and perform delayed initialization if needed. */
2195 for (i
= 0; i
< entity
->ncontrols
; ++i
) {
2196 ctrl
= &entity
->controls
[i
];
2197 if (ctrl
->index
== xqry
->selector
- 1) {
2204 uvc_dbg(chain
->dev
, CONTROL
, "Control %pUl/%u not found\n",
2205 entity
->guid
, xqry
->selector
);
2209 if (mutex_lock_interruptible(&chain
->ctrl_mutex
))
2210 return -ERESTARTSYS
;
2212 ret
= uvc_ctrl_init_xu_ctrl(chain
->dev
, ctrl
);
2218 /* Validate the required buffer size and flags for the request */
2220 size
= ctrl
->info
.size
;
2222 switch (xqry
->query
) {
2224 reqflags
= UVC_CTRL_FLAG_GET_CUR
;
2227 reqflags
= UVC_CTRL_FLAG_GET_MIN
;
2230 reqflags
= UVC_CTRL_FLAG_GET_MAX
;
2233 reqflags
= UVC_CTRL_FLAG_GET_DEF
;
2236 reqflags
= UVC_CTRL_FLAG_GET_RES
;
2239 reqflags
= UVC_CTRL_FLAG_SET_CUR
;
2252 if (size
!= xqry
->size
) {
2257 if (reqflags
&& !(ctrl
->info
.flags
& reqflags
)) {
2262 data
= kmalloc(size
, GFP_KERNEL
);
2268 if (xqry
->query
== UVC_SET_CUR
&&
2269 copy_from_user(data
, xqry
->data
, size
)) {
2274 ret
= uvc_query_ctrl(chain
->dev
, xqry
->query
, xqry
->unit
,
2275 chain
->dev
->intfnum
, xqry
->selector
, data
, size
);
2279 if (xqry
->query
!= UVC_SET_CUR
&&
2280 copy_to_user(xqry
->data
, data
, size
))
2284 mutex_unlock(&chain
->ctrl_mutex
);
2288 /* --------------------------------------------------------------------------
2293 * Restore control values after resume, skipping controls that haven't been
2297 * - Don't restore modified controls that are back to their default value.
2298 * - Handle restore order (Auto-Exposure Mode should be restored before
2301 int uvc_ctrl_restore_values(struct uvc_device
*dev
)
2303 struct uvc_control
*ctrl
;
2304 struct uvc_entity
*entity
;
2308 /* Walk the entities list and restore controls when possible. */
2309 list_for_each_entry(entity
, &dev
->entities
, list
) {
2311 for (i
= 0; i
< entity
->ncontrols
; ++i
) {
2312 ctrl
= &entity
->controls
[i
];
2314 if (!ctrl
->initialized
|| !ctrl
->modified
||
2315 (ctrl
->info
.flags
& UVC_CTRL_FLAG_RESTORE
) == 0)
2317 dev_dbg(&dev
->udev
->dev
,
2318 "restoring control %pUl/%u/%u\n",
2319 ctrl
->info
.entity
, ctrl
->info
.index
,
2320 ctrl
->info
.selector
);
2324 ret
= uvc_ctrl_commit_entity(dev
, entity
, 0, NULL
);
2332 /* --------------------------------------------------------------------------
2333 * Control and mapping handling
2337 * Add control information to a given control.
2339 static int uvc_ctrl_add_info(struct uvc_device
*dev
, struct uvc_control
*ctrl
,
2340 const struct uvc_control_info
*info
)
2343 INIT_LIST_HEAD(&ctrl
->info
.mappings
);
2345 /* Allocate an array to save control values (cur, def, max, etc.) */
2346 ctrl
->uvc_data
= kzalloc(ctrl
->info
.size
* UVC_CTRL_DATA_LAST
+ 1,
2348 if (!ctrl
->uvc_data
)
2351 ctrl
->initialized
= 1;
2353 uvc_dbg(dev
, CONTROL
, "Added control %pUl/%u to device %s entity %u\n",
2354 ctrl
->info
.entity
, ctrl
->info
.selector
, dev
->udev
->devpath
,
2361 * Add a control mapping to a given control.
2363 static int __uvc_ctrl_add_mapping(struct uvc_video_chain
*chain
,
2364 struct uvc_control
*ctrl
, const struct uvc_control_mapping
*mapping
)
2366 struct uvc_control_mapping
*map
;
2371 * Most mappings come from static kernel data, and need to be duplicated.
2372 * Mappings that come from userspace will be unnecessarily duplicated,
2373 * this could be optimized.
2375 map
= kmemdup(mapping
, sizeof(*mapping
), GFP_KERNEL
);
2380 map
->menu_names
= NULL
;
2381 map
->menu_mapping
= NULL
;
2383 /* For UVCIOC_CTRL_MAP custom control */
2384 if (mapping
->name
) {
2385 map
->name
= kstrdup(mapping
->name
, GFP_KERNEL
);
2390 INIT_LIST_HEAD(&map
->ev_subs
);
2392 if (mapping
->menu_mapping
&& mapping
->menu_mask
) {
2393 size
= sizeof(mapping
->menu_mapping
[0])
2394 * fls(mapping
->menu_mask
);
2395 map
->menu_mapping
= kmemdup(mapping
->menu_mapping
, size
,
2397 if (!map
->menu_mapping
)
2400 if (mapping
->menu_names
&& mapping
->menu_mask
) {
2401 size
= sizeof(mapping
->menu_names
[0])
2402 * fls(mapping
->menu_mask
);
2403 map
->menu_names
= kmemdup(mapping
->menu_names
, size
,
2405 if (!map
->menu_names
)
2409 if (map
->get
== NULL
)
2410 map
->get
= uvc_get_le_value
;
2411 if (map
->set
== NULL
)
2412 map
->set
= uvc_set_le_value
;
2414 for (i
= 0; i
< ARRAY_SIZE(uvc_control_classes
); i
++) {
2415 if (V4L2_CTRL_ID2WHICH(uvc_control_classes
[i
]) ==
2416 V4L2_CTRL_ID2WHICH(map
->id
)) {
2417 chain
->ctrl_class_bitmap
|= BIT(i
);
2422 list_add_tail(&map
->list
, &ctrl
->info
.mappings
);
2423 uvc_dbg(chain
->dev
, CONTROL
, "Adding mapping '%s' to control %pUl/%u\n",
2424 uvc_map_get_name(map
), ctrl
->info
.entity
,
2425 ctrl
->info
.selector
);
2430 kfree(map
->menu_names
);
2431 kfree(map
->menu_mapping
);
2437 int uvc_ctrl_add_mapping(struct uvc_video_chain
*chain
,
2438 const struct uvc_control_mapping
*mapping
)
2440 struct uvc_device
*dev
= chain
->dev
;
2441 struct uvc_control_mapping
*map
;
2442 struct uvc_entity
*entity
;
2443 struct uvc_control
*ctrl
;
2447 if (mapping
->id
& ~V4L2_CTRL_ID_MASK
) {
2448 uvc_dbg(dev
, CONTROL
,
2449 "Can't add mapping '%s', control id 0x%08x is invalid\n",
2450 uvc_map_get_name(mapping
), mapping
->id
);
2454 /* Search for the matching (GUID/CS) control on the current chain */
2455 list_for_each_entry(entity
, &chain
->entities
, chain
) {
2458 if (UVC_ENTITY_TYPE(entity
) != UVC_VC_EXTENSION_UNIT
||
2459 !uvc_entity_match_guid(entity
, mapping
->entity
))
2462 for (i
= 0; i
< entity
->ncontrols
; ++i
) {
2463 ctrl
= &entity
->controls
[i
];
2464 if (ctrl
->index
== mapping
->selector
- 1) {
2476 if (mutex_lock_interruptible(&chain
->ctrl_mutex
))
2477 return -ERESTARTSYS
;
2479 /* Perform delayed initialization of XU controls */
2480 ret
= uvc_ctrl_init_xu_ctrl(dev
, ctrl
);
2486 /* Validate the user-provided bit-size and offset */
2487 if (mapping
->size
> 32 ||
2488 mapping
->offset
+ mapping
->size
> ctrl
->info
.size
* 8) {
2493 list_for_each_entry(map
, &ctrl
->info
.mappings
, list
) {
2494 if (mapping
->id
== map
->id
) {
2495 uvc_dbg(dev
, CONTROL
,
2496 "Can't add mapping '%s', control id 0x%08x already exists\n",
2497 uvc_map_get_name(mapping
), mapping
->id
);
2503 /* Prevent excess memory consumption */
2504 if (atomic_inc_return(&dev
->nmappings
) > UVC_MAX_CONTROL_MAPPINGS
) {
2505 atomic_dec(&dev
->nmappings
);
2506 uvc_dbg(dev
, CONTROL
,
2507 "Can't add mapping '%s', maximum mappings count (%u) exceeded\n",
2508 uvc_map_get_name(mapping
), UVC_MAX_CONTROL_MAPPINGS
);
2513 ret
= __uvc_ctrl_add_mapping(chain
, ctrl
, mapping
);
2515 atomic_dec(&dev
->nmappings
);
2518 mutex_unlock(&chain
->ctrl_mutex
);
2523 * Prune an entity of its bogus controls using a blacklist. Bogus controls
2524 * are currently the ones that crash the camera or unconditionally return an
2525 * error when queried.
2527 static void uvc_ctrl_prune_entity(struct uvc_device
*dev
,
2528 struct uvc_entity
*entity
)
2530 struct uvc_ctrl_blacklist
{
2531 struct usb_device_id id
;
2535 static const struct uvc_ctrl_blacklist processing_blacklist
[] = {
2536 { { USB_DEVICE(0x13d3, 0x509b) }, 9 }, /* Gain */
2537 { { USB_DEVICE(0x1c4f, 0x3000) }, 6 }, /* WB Temperature */
2538 { { USB_DEVICE(0x5986, 0x0241) }, 2 }, /* Hue */
2540 static const struct uvc_ctrl_blacklist camera_blacklist
[] = {
2541 { { USB_DEVICE(0x06f8, 0x3005) }, 9 }, /* Zoom, Absolute */
2544 const struct uvc_ctrl_blacklist
*blacklist
;
2550 switch (UVC_ENTITY_TYPE(entity
)) {
2551 case UVC_VC_PROCESSING_UNIT
:
2552 blacklist
= processing_blacklist
;
2553 count
= ARRAY_SIZE(processing_blacklist
);
2554 controls
= entity
->processing
.bmControls
;
2555 size
= entity
->processing
.bControlSize
;
2558 case UVC_ITT_CAMERA
:
2559 blacklist
= camera_blacklist
;
2560 count
= ARRAY_SIZE(camera_blacklist
);
2561 controls
= entity
->camera
.bmControls
;
2562 size
= entity
->camera
.bControlSize
;
2569 for (i
= 0; i
< count
; ++i
) {
2570 if (!usb_match_one_id(dev
->intf
, &blacklist
[i
].id
))
2573 if (blacklist
[i
].index
>= 8 * size
||
2574 !uvc_test_bit(controls
, blacklist
[i
].index
))
2577 uvc_dbg(dev
, CONTROL
,
2578 "%u/%u control is black listed, removing it\n",
2579 entity
->id
, blacklist
[i
].index
);
2581 uvc_clear_bit(controls
, blacklist
[i
].index
);
2586 * Add control information and hardcoded stock control mappings to the given
2589 static void uvc_ctrl_init_ctrl(struct uvc_video_chain
*chain
,
2590 struct uvc_control
*ctrl
)
2592 const struct uvc_control_mapping
**mappings
;
2596 * XU controls initialization requires querying the device for control
2597 * information. As some buggy UVC devices will crash when queried
2598 * repeatedly in a tight loop, delay XU controls initialization until
2601 if (UVC_ENTITY_TYPE(ctrl
->entity
) == UVC_VC_EXTENSION_UNIT
)
2604 for (i
= 0; i
< ARRAY_SIZE(uvc_ctrls
); ++i
) {
2605 const struct uvc_control_info
*info
= &uvc_ctrls
[i
];
2607 if (uvc_entity_match_guid(ctrl
->entity
, info
->entity
) &&
2608 ctrl
->index
== info
->index
) {
2609 uvc_ctrl_add_info(chain
->dev
, ctrl
, info
);
2611 * Retrieve control flags from the device. Ignore errors
2612 * and work with default flag values from the uvc_ctrl
2613 * array when the device doesn't properly implement
2614 * GET_INFO on standard controls.
2616 uvc_ctrl_get_flags(chain
->dev
, ctrl
, &ctrl
->info
);
2621 if (!ctrl
->initialized
)
2625 * First check if the device provides a custom mapping for this control,
2626 * used to override standard mappings for non-conformant devices. Don't
2627 * process standard mappings if a custom mapping is found. This
2628 * mechanism doesn't support combining standard and custom mappings for
2631 if (chain
->dev
->info
->mappings
) {
2632 bool custom
= false;
2634 for (i
= 0; chain
->dev
->info
->mappings
[i
]; ++i
) {
2635 const struct uvc_control_mapping
*mapping
=
2636 chain
->dev
->info
->mappings
[i
];
2638 if (uvc_entity_match_guid(ctrl
->entity
, mapping
->entity
) &&
2639 ctrl
->info
.selector
== mapping
->selector
) {
2640 __uvc_ctrl_add_mapping(chain
, ctrl
, mapping
);
2649 /* Process common mappings next. */
2650 for (i
= 0; i
< ARRAY_SIZE(uvc_ctrl_mappings
); ++i
) {
2651 const struct uvc_control_mapping
*mapping
= &uvc_ctrl_mappings
[i
];
2653 if (uvc_entity_match_guid(ctrl
->entity
, mapping
->entity
) &&
2654 ctrl
->info
.selector
== mapping
->selector
)
2655 __uvc_ctrl_add_mapping(chain
, ctrl
, mapping
);
2658 /* Finally process version-specific mappings. */
2659 mappings
= chain
->dev
->uvc_version
< 0x0150
2660 ? uvc_ctrl_mappings_uvc11
: uvc_ctrl_mappings_uvc15
;
2662 for (i
= 0; mappings
[i
]; ++i
) {
2663 const struct uvc_control_mapping
*mapping
= mappings
[i
];
2665 if (uvc_entity_match_guid(ctrl
->entity
, mapping
->entity
) &&
2666 ctrl
->info
.selector
== mapping
->selector
)
2667 __uvc_ctrl_add_mapping(chain
, ctrl
, mapping
);
2672 * Initialize device controls.
2674 static int uvc_ctrl_init_chain(struct uvc_video_chain
*chain
)
2676 struct uvc_entity
*entity
;
2679 /* Walk the entities list and instantiate controls */
2680 list_for_each_entry(entity
, &chain
->entities
, chain
) {
2681 struct uvc_control
*ctrl
;
2682 unsigned int bControlSize
= 0, ncontrols
;
2683 u8
*bmControls
= NULL
;
2685 if (UVC_ENTITY_TYPE(entity
) == UVC_VC_EXTENSION_UNIT
) {
2686 bmControls
= entity
->extension
.bmControls
;
2687 bControlSize
= entity
->extension
.bControlSize
;
2688 } else if (UVC_ENTITY_TYPE(entity
) == UVC_VC_PROCESSING_UNIT
) {
2689 bmControls
= entity
->processing
.bmControls
;
2690 bControlSize
= entity
->processing
.bControlSize
;
2691 } else if (UVC_ENTITY_TYPE(entity
) == UVC_ITT_CAMERA
) {
2692 bmControls
= entity
->camera
.bmControls
;
2693 bControlSize
= entity
->camera
.bControlSize
;
2694 } else if (UVC_ENTITY_TYPE(entity
) == UVC_EXT_GPIO_UNIT
) {
2695 bmControls
= entity
->gpio
.bmControls
;
2696 bControlSize
= entity
->gpio
.bControlSize
;
2699 /* Remove bogus/blacklisted controls */
2700 uvc_ctrl_prune_entity(chain
->dev
, entity
);
2702 /* Count supported controls and allocate the controls array */
2703 ncontrols
= memweight(bmControls
, bControlSize
);
2707 entity
->controls
= kcalloc(ncontrols
, sizeof(*ctrl
),
2709 if (entity
->controls
== NULL
)
2711 entity
->ncontrols
= ncontrols
;
2713 /* Initialize all supported controls */
2714 ctrl
= entity
->controls
;
2715 for (i
= 0; i
< bControlSize
* 8; ++i
) {
2716 if (uvc_test_bit(bmControls
, i
) == 0)
2719 ctrl
->entity
= entity
;
2722 uvc_ctrl_init_ctrl(chain
, ctrl
);
2730 int uvc_ctrl_init_device(struct uvc_device
*dev
)
2732 struct uvc_video_chain
*chain
;
2735 INIT_WORK(&dev
->async_ctrl
.work
, uvc_ctrl_status_event_work
);
2737 list_for_each_entry(chain
, &dev
->chains
, list
) {
2738 ret
= uvc_ctrl_init_chain(chain
);
2747 * Cleanup device controls.
2749 static void uvc_ctrl_cleanup_mappings(struct uvc_device
*dev
,
2750 struct uvc_control
*ctrl
)
2752 struct uvc_control_mapping
*mapping
, *nm
;
2754 list_for_each_entry_safe(mapping
, nm
, &ctrl
->info
.mappings
, list
) {
2755 list_del(&mapping
->list
);
2756 kfree(mapping
->menu_names
);
2757 kfree(mapping
->menu_mapping
);
2758 kfree(mapping
->name
);
2763 void uvc_ctrl_cleanup_device(struct uvc_device
*dev
)
2765 struct uvc_entity
*entity
;
2768 /* Can be uninitialized if we are aborting on probe error. */
2769 if (dev
->async_ctrl
.work
.func
)
2770 cancel_work_sync(&dev
->async_ctrl
.work
);
2772 /* Free controls and control mappings for all entities. */
2773 list_for_each_entry(entity
, &dev
->entities
, list
) {
2774 for (i
= 0; i
< entity
->ncontrols
; ++i
) {
2775 struct uvc_control
*ctrl
= &entity
->controls
[i
];
2777 if (!ctrl
->initialized
)
2780 uvc_ctrl_cleanup_mappings(dev
, ctrl
);
2781 kfree(ctrl
->uvc_data
);
2784 kfree(entity
->controls
);