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(id: 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_mappings[] = {
463	{
464	.id = V4L2_CID_BRIGHTNESS,
465	.entity = UVC_GUID_UVC_PROCESSING,
466	.selector = UVC_PU_BRIGHTNESS_CONTROL,
467	.size = 16,
468	.offset = 0,
469	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
470	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
471	},
472	{
473	.id = V4L2_CID_CONTRAST,
474	.entity = UVC_GUID_UVC_PROCESSING,
475	.selector = UVC_PU_CONTRAST_CONTROL,
476	.size = 16,
477	.offset = 0,
478	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
479	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
480	},
481	{
482	.id = V4L2_CID_HUE,
483	.entity = UVC_GUID_UVC_PROCESSING,
484	.selector = UVC_PU_HUE_CONTROL,
485	.size = 16,
486	.offset = 0,
487	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
488	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
489	.master_id = V4L2_CID_HUE_AUTO,
490	.master_manual = 0,
491	},
492	{
493	.id = V4L2_CID_SATURATION,
494	.entity = UVC_GUID_UVC_PROCESSING,
495	.selector = UVC_PU_SATURATION_CONTROL,
496	.size = 16,
497	.offset = 0,
498	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
499	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
500	},
501	{
502	.id = V4L2_CID_SHARPNESS,
503	.entity = UVC_GUID_UVC_PROCESSING,
504	.selector = UVC_PU_SHARPNESS_CONTROL,
505	.size = 16,
506	.offset = 0,
507	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
508	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
509	},
510	{
511	.id = V4L2_CID_GAMMA,
512	.entity = UVC_GUID_UVC_PROCESSING,
513	.selector = UVC_PU_GAMMA_CONTROL,
514	.size = 16,
515	.offset = 0,
516	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
517	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
518	},
519	{
520	.id = V4L2_CID_BACKLIGHT_COMPENSATION,
521	.entity = UVC_GUID_UVC_PROCESSING,
522	.selector = UVC_PU_BACKLIGHT_COMPENSATION_CONTROL,
523	.size = 16,
524	.offset = 0,
525	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
526	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
527	},
528	{
529	.id = V4L2_CID_GAIN,
530	.entity = UVC_GUID_UVC_PROCESSING,
531	.selector = UVC_PU_GAIN_CONTROL,
532	.size = 16,
533	.offset = 0,
534	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
535	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
536	},
537	{
538	.id = V4L2_CID_HUE_AUTO,
539	.entity = UVC_GUID_UVC_PROCESSING,
540	.selector = UVC_PU_HUE_AUTO_CONTROL,
541	.size = 1,
542	.offset = 0,
543	.v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
544	.data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
545	.slave_ids = { V4L2_CID_HUE, },
546	},
547	{
548	.id = V4L2_CID_EXPOSURE_AUTO,
549	.entity = UVC_GUID_UVC_CAMERA,
550	.selector = UVC_CT_AE_MODE_CONTROL,
551	.size = 4,
552	.offset = 0,
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,
557	V4L2_EXPOSURE_AUTO),
558	.slave_ids = { V4L2_CID_EXPOSURE_ABSOLUTE, },
559	},
560	{
561	.id = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
562	.entity = UVC_GUID_UVC_CAMERA,
563	.selector = UVC_CT_AE_PRIORITY_CONTROL,
564	.size = 1,
565	.offset = 0,
566	.v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
567	.data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
568	},
569	{
570	.id = V4L2_CID_EXPOSURE_ABSOLUTE,
571	.entity = UVC_GUID_UVC_CAMERA,
572	.selector = UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
573	.size = 32,
574	.offset = 0,
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,
579	},
580	{
581	.id = V4L2_CID_AUTO_WHITE_BALANCE,
582	.entity = UVC_GUID_UVC_PROCESSING,
583	.selector = UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
584	.size = 1,
585	.offset = 0,
586	.v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
587	.data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
588	.slave_ids = { V4L2_CID_WHITE_BALANCE_TEMPERATURE, },
589	},
590	{
591	.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
592	.entity = UVC_GUID_UVC_PROCESSING,
593	.selector = UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
594	.size = 16,
595	.offset = 0,
596	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
597	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
598	.master_id = V4L2_CID_AUTO_WHITE_BALANCE,
599	.master_manual = 0,
600	},
601	{
602	.id = V4L2_CID_AUTO_WHITE_BALANCE,
603	.entity = UVC_GUID_UVC_PROCESSING,
604	.selector = UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
605	.size = 1,
606	.offset = 0,
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 },
611	},
612	{
613	.id = V4L2_CID_BLUE_BALANCE,
614	.entity = UVC_GUID_UVC_PROCESSING,
615	.selector = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
616	.size = 16,
617	.offset = 0,
618	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
619	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
620	.master_id = V4L2_CID_AUTO_WHITE_BALANCE,
621	.master_manual = 0,
622	},
623	{
624	.id = V4L2_CID_RED_BALANCE,
625	.entity = UVC_GUID_UVC_PROCESSING,
626	.selector = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
627	.size = 16,
628	.offset = 16,
629	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
630	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
631	.master_id = V4L2_CID_AUTO_WHITE_BALANCE,
632	.master_manual = 0,
633	},
634	{
635	.id = V4L2_CID_FOCUS_ABSOLUTE,
636	.entity = UVC_GUID_UVC_CAMERA,
637	.selector = UVC_CT_FOCUS_ABSOLUTE_CONTROL,
638	.size = 16,
639	.offset = 0,
640	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
641	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
642	.master_id = V4L2_CID_FOCUS_AUTO,
643	.master_manual = 0,
644	},
645	{
646	.id = V4L2_CID_FOCUS_AUTO,
647	.entity = UVC_GUID_UVC_CAMERA,
648	.selector = UVC_CT_FOCUS_AUTO_CONTROL,
649	.size = 1,
650	.offset = 0,
651	.v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
652	.data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
653	.slave_ids = { V4L2_CID_FOCUS_ABSOLUTE, },
654	},
655	{
656	.id = V4L2_CID_IRIS_ABSOLUTE,
657	.entity = UVC_GUID_UVC_CAMERA,
658	.selector = UVC_CT_IRIS_ABSOLUTE_CONTROL,
659	.size = 16,
660	.offset = 0,
661	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
662	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
663	},
664	{
665	.id = V4L2_CID_IRIS_RELATIVE,
666	.entity = UVC_GUID_UVC_CAMERA,
667	.selector = UVC_CT_IRIS_RELATIVE_CONTROL,
668	.size = 8,
669	.offset = 0,
670	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
671	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
672	},
673	{
674	.id = V4L2_CID_ZOOM_ABSOLUTE,
675	.entity = UVC_GUID_UVC_CAMERA,
676	.selector = UVC_CT_ZOOM_ABSOLUTE_CONTROL,
677	.size = 16,
678	.offset = 0,
679	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
680	.data_type = UVC_CTRL_DATA_TYPE_UNSIGNED,
681	},
682	{
683	.id = V4L2_CID_ZOOM_CONTINUOUS,
684	.entity = UVC_GUID_UVC_CAMERA,
685	.selector = UVC_CT_ZOOM_RELATIVE_CONTROL,
686	.size = 0,
687	.offset = 0,
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,
692	},
693	{
694	.id = V4L2_CID_PAN_ABSOLUTE,
695	.entity = UVC_GUID_UVC_CAMERA,
696	.selector = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
697	.size = 32,
698	.offset = 0,
699	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
700	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
701	},
702	{
703	.id = V4L2_CID_TILT_ABSOLUTE,
704	.entity = UVC_GUID_UVC_CAMERA,
705	.selector = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
706	.size = 32,
707	.offset = 32,
708	.v4l2_type = V4L2_CTRL_TYPE_INTEGER,
709	.data_type = UVC_CTRL_DATA_TYPE_SIGNED,
710	},
711	{
712	.id = V4L2_CID_PAN_SPEED,
713	.entity = UVC_GUID_UVC_CAMERA,
714	.selector = UVC_CT_PANTILT_RELATIVE_CONTROL,
715	.size = 16,
716	.offset = 0,
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,
721	},
722	{
723	.id = V4L2_CID_TILT_SPEED,
724	.entity = UVC_GUID_UVC_CAMERA,
725	.selector = UVC_CT_PANTILT_RELATIVE_CONTROL,
726	.size = 16,
727	.offset = 16,
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,
732	},
733	{
734	.id = V4L2_CID_PRIVACY,
735	.entity = UVC_GUID_UVC_CAMERA,
736	.selector = UVC_CT_PRIVACY_CONTROL,
737	.size = 1,
738	.offset = 0,
739	.v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
740	.data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
741	},
742	{
743	.id = V4L2_CID_PRIVACY,
744	.entity = UVC_GUID_EXT_GPIO_CONTROLLER,
745	.selector = UVC_CT_PRIVACY_CONTROL,
746	.size = 1,
747	.offset = 0,
748	.v4l2_type = V4L2_CTRL_TYPE_BOOLEAN,
749	.data_type = UVC_CTRL_DATA_TYPE_BOOLEAN,
750	},
751	};
752
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,
757	.size = 2,
758	.offset = 0,
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),
763	};
764
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,
769	.size = 2,
770	.offset = 0,
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),
775	};
776
777	static const struct uvc_control_mapping *uvc_ctrl_mappings_uvc11[] = {
778	&uvc_ctrl_power_line_mapping_uvc11,
779	NULL, /* Sentinel */
780	};
781
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,
786	.size = 2,
787	.offset = 0,
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),
792	};
793
794	static const struct uvc_control_mapping *uvc_ctrl_mappings_uvc15[] = {
795	&uvc_ctrl_power_line_mapping_uvc15,
796	NULL, /* Sentinel */
797	};
798
799	/* ------------------------------------------------------------------------
800	* Utility functions
801	*/
802
803	static inline u8 *uvc_ctrl_data(struct uvc_control *ctrl, int id)
804	{
805	return ctrl->uvc_data + id * ctrl->info.size;
806	}
807
808	static inline int uvc_test_bit(const u8 *data, int bit)
809	{
810	return (data[bit >> 3] >> (bit & 7)) & 1;
811	}
812
813	static inline void uvc_clear_bit(u8 *data, int bit)
814	{
815	data[bit >> 3] &= ~(1 << (bit & 7));
816	}
817
818	/*
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.
823	*/
824	static s32 uvc_get_le_value(struct uvc_control_mapping *mapping,
825	u8 query, const u8 *data)
826	{
827	int bits = mapping->size;
828	int offset = mapping->offset;
829	s32 value = 0;
830	u8 mask;
831
832	data += offset / 8;
833	offset &= 7;
834	mask = ((1LL << bits) - 1) << offset;
835
836	while (1) {
837	u8 byte = *data & mask;
838	value |= offset > 0 ? (byte >> offset) : (byte << (-offset));
839	bits -= 8 - (offset > 0 ? offset : 0);
840	if (bits <= 0)
841	break;
842
843	offset -= 8;
844	mask = (1 << bits) - 1;
845	data++;
846	}
847
848	/* Sign-extend the value if needed. */
849	if (mapping->data_type == UVC_CTRL_DATA_TYPE_SIGNED)
850	value |= -(value & (1 << (mapping->size - 1)));
851
852	return value;
853	}
854
855	/*
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'.
858	*/
859	static void uvc_set_le_value(struct uvc_control_mapping *mapping,
860	s32 value, u8 *data)
861	{
862	int bits = mapping->size;
863	int offset = mapping->offset;
864	u8 mask;
865
866	/*
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
870	* value.
871	*/
872	if (mapping->v4l2_type == V4L2_CTRL_TYPE_BUTTON)
873	value = -1;
874
875	data += offset / 8;
876	offset &= 7;
877
878	for (; bits > 0; data++) {
879	mask = ((1LL << bits) - 1) << offset;
880	*data = (*data & ~mask) | ((value << offset) & mask);
881	value >>= offset ? offset : 8;
882	bits -= 8 - offset;
883	offset = 0;
884	}
885	}
886
887	/* ------------------------------------------------------------------------
888	* Terminal and unit management
889	*/
890
891	static int uvc_entity_match_guid(const struct uvc_entity *entity,
892	const u8 guid[16])
893	{
894	return memcmp(p: entity->guid, q: guid, size: sizeof(entity->guid)) == 0;
895	}
896
897	/* ------------------------------------------------------------------------
898	* UVC Controls
899	*/
900
901	static void __uvc_find_control(struct uvc_entity *entity, u32 v4l2_id,
902	struct uvc_control_mapping **mapping, struct uvc_control **control,
903	int next)
904	{
905	struct uvc_control *ctrl;
906	struct uvc_control_mapping *map;
907	unsigned int i;
908
909	if (entity == NULL)
910	return;
911
912	for (i = 0; i < entity->ncontrols; ++i) {
913	ctrl = &entity->controls[i];
914	if (!ctrl->initialized)
915	continue;
916
917	list_for_each_entry(map, &ctrl->info.mappings, list) {
918	if ((map->id == v4l2_id) && !next) {
919	*control = ctrl;
920	*mapping = map;
921	return;
922	}
923
924	if ((*mapping == NULL || (*mapping)->id > map->id) &&
925	(map->id > v4l2_id) && next) {
926	*control = ctrl;
927	*mapping = map;
928	}
929	}
930	}
931	}
932
933	static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
934	u32 v4l2_id, struct uvc_control_mapping **mapping)
935	{
936	struct uvc_control *ctrl = NULL;
937	struct uvc_entity *entity;
938	int next = v4l2_id & V4L2_CTRL_FLAG_NEXT_CTRL;
939
940	*mapping = NULL;
941
942	/* Mask the query flags. */
943	v4l2_id &= V4L2_CTRL_ID_MASK;
944
945	/* Find the control. */
946	list_for_each_entry(entity, &chain->entities, chain) {
947	__uvc_find_control(entity, v4l2_id, mapping, control: &ctrl, next);
948	if (ctrl && !next)
949	return ctrl;
950	}
951
952	if (ctrl == NULL && !next)
953	uvc_dbg(chain->dev, CONTROL, "Control 0x%08x not found\n",
954	v4l2_id);
955
956	return ctrl;
957	}
958
959	static int uvc_ctrl_populate_cache(struct uvc_video_chain *chain,
960	struct uvc_control *ctrl)
961	{
962	int ret;
963
964	if (ctrl->info.flags & UVC_CTRL_FLAG_GET_DEF) {
965	ret = uvc_query_ctrl(dev: chain->dev, UVC_GET_DEF, unit: ctrl->entity->id,
966	intfnum: chain->dev->intfnum, cs: ctrl->info.selector,
967	data: uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF),
968	size: ctrl->info.size);
969	if (ret < 0)
970	return ret;
971	}
972
973	if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MIN) {
974	ret = uvc_query_ctrl(dev: chain->dev, UVC_GET_MIN, unit: ctrl->entity->id,
975	intfnum: chain->dev->intfnum, cs: ctrl->info.selector,
976	data: uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN),
977	size: ctrl->info.size);
978	if (ret < 0)
979	return ret;
980	}
981	if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MAX) {
982	ret = uvc_query_ctrl(dev: chain->dev, UVC_GET_MAX, unit: ctrl->entity->id,
983	intfnum: chain->dev->intfnum, cs: ctrl->info.selector,
984	data: uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX),
985	size: ctrl->info.size);
986	if (ret < 0)
987	return ret;
988	}
989	if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES) {
990	ret = uvc_query_ctrl(dev: chain->dev, UVC_GET_RES, unit: ctrl->entity->id,
991	intfnum: chain->dev->intfnum, cs: ctrl->info.selector,
992	data: uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES),
993	size: ctrl->info.size);
994	if (ret < 0) {
995	if (UVC_ENTITY_TYPE(ctrl->entity) !=
996	UVC_VC_EXTENSION_UNIT)
997	return ret;
998
999	/*
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.
1003	*/
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,
1008	ctrl->info.size);
1009	}
1010	}
1011
1012	ctrl->cached = 1;
1013	return 0;
1014	}
1015
1016	static s32 __uvc_ctrl_get_value(struct uvc_control_mapping *mapping,
1017	const u8 *data)
1018	{
1019	s32 value = mapping->get(mapping, UVC_GET_CUR, data);
1020
1021	if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
1022	unsigned int i;
1023
1024	for (i = 0; BIT(i) <= mapping->menu_mask; ++i) {
1025	u32 menu_value;
1026
1027	if (!test_bit(i, &mapping->menu_mask))
1028	continue;
1029
1030	menu_value = uvc_mapping_get_menu_value(mapping, idx: i);
1031
1032	if (menu_value == value) {
1033	value = i;
1034	break;
1035	}
1036	}
1037	}
1038
1039	return value;
1040	}
1041
1042	static int __uvc_ctrl_load_cur(struct uvc_video_chain *chain,
1043	struct uvc_control *ctrl)
1044	{
1045	u8 *data;
1046	int ret;
1047
1048	if (ctrl->loaded)
1049	return 0;
1050
1051	data = uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT);
1052
1053	if ((ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) == 0) {
1054	memset(data, 0, ctrl->info.size);
1055	ctrl->loaded = 1;
1056
1057	return 0;
1058	}
1059
1060	if (ctrl->entity->get_cur)
1061	ret = ctrl->entity->get_cur(chain->dev, ctrl->entity,
1062	ctrl->info.selector, data,
1063	ctrl->info.size);
1064	else
1065	ret = uvc_query_ctrl(dev: chain->dev, UVC_GET_CUR,
1066	unit: ctrl->entity->id, intfnum: chain->dev->intfnum,
1067	cs: ctrl->info.selector, data,
1068	size: ctrl->info.size);
1069
1070	if (ret < 0)
1071	return ret;
1072
1073	ctrl->loaded = 1;
1074
1075	return ret;
1076	}
1077
1078	static int __uvc_ctrl_get(struct uvc_video_chain *chain,
1079	struct uvc_control *ctrl,
1080	struct uvc_control_mapping *mapping,
1081	s32 *value)
1082	{
1083	int ret;
1084
1085	if ((ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) == 0)
1086	return -EACCES;
1087
1088	ret = __uvc_ctrl_load_cur(chain, ctrl);
1089	if (ret < 0)
1090	return ret;
1091
1092	*value = __uvc_ctrl_get_value(mapping,
1093	data: uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT));
1094
1095	return 0;
1096	}
1097
1098	static int __uvc_query_v4l2_class(struct uvc_video_chain *chain, u32 req_id,
1099	u32 found_id)
1100	{
1101	bool find_next = req_id & V4L2_CTRL_FLAG_NEXT_CTRL;
1102	unsigned int i;
1103
1104	req_id &= V4L2_CTRL_ID_MASK;
1105
1106	for (i = 0; i < ARRAY_SIZE(uvc_control_classes); i++) {
1107	if (!(chain->ctrl_class_bitmap & BIT(i)))
1108	continue;
1109	if (!find_next) {
1110	if (uvc_control_classes[i] == req_id)
1111	return i;
1112	continue;
1113	}
1114	if (uvc_control_classes[i] > req_id &&
1115	uvc_control_classes[i] < found_id)
1116	return i;
1117	}
1118
1119	return -ENODEV;
1120	}
1121
1122	static int uvc_query_v4l2_class(struct uvc_video_chain *chain, u32 req_id,
1123	u32 found_id, struct v4l2_queryctrl *v4l2_ctrl)
1124	{
1125	int idx;
1126
1127	idx = __uvc_query_v4l2_class(chain, req_id, found_id);
1128	if (idx < 0)
1129	return -ENODEV;
1130
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;
1138	return 0;
1139	}
1140
1141	/*
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).
1144	*
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.
1150	*/
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)
1154	{
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;
1160	s32 val;
1161	int ret;
1162	int i;
1163
1164	if (__uvc_query_v4l2_class(chain, req_id: v4l2_id, found_id: 0) >= 0)
1165	return -EACCES;
1166
1167	ctrl = uvc_find_control(chain, v4l2_id, mapping: &mapping);
1168	if (!ctrl)
1169	return -EINVAL;
1170
1171	if (!(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) && read)
1172	return -EACCES;
1173
1174	if (!(ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR) && !read)
1175	return -EACCES;
1176
1177	if (ioctl != VIDIOC_S_EXT_CTRLS || !mapping->master_id)
1178	return 0;
1179
1180	/*
1181	* Iterate backwards in cases where the master control is accessed
1182	* multiple times in the same ioctl. We want the last value.
1183	*/
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;
1188	}
1189
1190	__uvc_find_control(entity: ctrl->entity, v4l2_id: mapping->master_id, mapping: &master_map,
1191	control: &master_ctrl, next: 0);
1192
1193	if (!master_ctrl || !(master_ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
1194	return 0;
1195
1196	ret = __uvc_ctrl_get(chain, ctrl: master_ctrl, mapping: master_map, value: &val);
1197	if (ret >= 0 && val != mapping->master_manual)
1198	return -EACCES;
1199
1200	return 0;
1201	}
1202
1203	static const char *uvc_map_get_name(const struct uvc_control_mapping *map)
1204	{
1205	const char *name;
1206
1207	if (map->name)
1208	return map->name;
1209
1210	name = v4l2_ctrl_get_name(id: map->id);
1211	if (name)
1212	return name;
1213
1214	return "Unknown Control";
1215	}
1216
1217	static u32 uvc_get_ctrl_bitmap(struct uvc_control *ctrl,
1218	struct uvc_control_mapping *mapping)
1219	{
1220	/*
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
1223	* as supported.
1224	*/
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));
1228
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));
1232
1233	return ~0;
1234	}
1235
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)
1240	{
1241	struct uvc_control_mapping *master_map = NULL;
1242	struct uvc_control *master_ctrl = NULL;
1243	unsigned int i;
1244
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;
1251
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;
1256
1257	if (mapping->master_id)
1258	__uvc_find_control(entity: ctrl->entity, v4l2_id: mapping->master_id,
1259	mapping: &master_map, control: &master_ctrl, next: 0);
1260	if (master_ctrl && (master_ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR)) {
1261	s32 val;
1262	int ret = __uvc_ctrl_get(chain, ctrl: master_ctrl, mapping: master_map, value: &val);
1263	if (ret < 0)
1264	return ret;
1265
1266	if (val != mapping->master_manual)
1267	v4l2_ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1268	}
1269
1270	if (!ctrl->cached) {
1271	int ret = uvc_ctrl_populate_cache(chain, ctrl);
1272	if (ret < 0)
1273	return ret;
1274	}
1275
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));
1279	}
1280
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(x: mapping->menu_mask) - 1;
1285	v4l2_ctrl->step = 1;
1286
1287	for (i = 0; BIT(i) <= mapping->menu_mask; ++i) {
1288	u32 menu_value;
1289
1290	if (!test_bit(i, &mapping->menu_mask))
1291	continue;
1292
1293	menu_value = uvc_mapping_get_menu_value(mapping, idx: i);
1294
1295	if (menu_value == v4l2_ctrl->default_value) {
1296	v4l2_ctrl->default_value = i;
1297	break;
1298	}
1299	}
1300
1301	return 0;
1302
1303	case V4L2_CTRL_TYPE_BOOLEAN:
1304	v4l2_ctrl->minimum = 0;
1305	v4l2_ctrl->maximum = 1;
1306	v4l2_ctrl->step = 1;
1307	return 0;
1308
1309	case V4L2_CTRL_TYPE_BUTTON:
1310	v4l2_ctrl->minimum = 0;
1311	v4l2_ctrl->maximum = 0;
1312	v4l2_ctrl->step = 0;
1313	return 0;
1314
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;
1319	return 0;
1320
1321	default:
1322	break;
1323	}
1324
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));
1328
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));
1332
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));
1336
1337	return 0;
1338	}
1339
1340	int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
1341	struct v4l2_queryctrl *v4l2_ctrl)
1342	{
1343	struct uvc_control *ctrl;
1344	struct uvc_control_mapping *mapping;
1345	int ret;
1346
1347	ret = mutex_lock_interruptible(&chain->ctrl_mutex);
1348	if (ret < 0)
1349	return -ERESTARTSYS;
1350
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, req_id: v4l2_ctrl->id, found_id: 0, v4l2_ctrl);
1354	if (!ret)
1355	goto done;
1356	}
1357
1358	ctrl = uvc_find_control(chain, v4l2_id: v4l2_ctrl->id, mapping: &mapping);
1359	if (ctrl == NULL) {
1360	ret = -EINVAL;
1361	goto done;
1362	}
1363
1364	/*
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.
1368	*/
1369	if (v4l2_ctrl->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
1370	ret = uvc_query_v4l2_class(chain, req_id: v4l2_ctrl->id, found_id: mapping->id,
1371	v4l2_ctrl);
1372	if (!ret)
1373	goto done;
1374	}
1375
1376	ret = __uvc_query_v4l2_ctrl(chain, ctrl, mapping, v4l2_ctrl);
1377	done:
1378	mutex_unlock(lock: &chain->ctrl_mutex);
1379	return ret;
1380	}
1381
1382	/*
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
1389	* manually.
1390	*/
1391	int uvc_query_v4l2_menu(struct uvc_video_chain *chain,
1392	struct v4l2_querymenu *query_menu)
1393	{
1394	struct uvc_control_mapping *mapping;
1395	struct uvc_control *ctrl;
1396	u32 index = query_menu->index;
1397	u32 id = query_menu->id;
1398	const char *name;
1399	int ret;
1400
1401	memset(query_menu, 0, sizeof(*query_menu));
1402	query_menu->id = id;
1403	query_menu->index = index;
1404
1405	if (index >= BITS_PER_TYPE(mapping->menu_mask))
1406	return -EINVAL;
1407
1408	ret = mutex_lock_interruptible(&chain->ctrl_mutex);
1409	if (ret < 0)
1410	return -ERESTARTSYS;
1411
1412	ctrl = uvc_find_control(chain, v4l2_id: query_menu->id, mapping: &mapping);
1413	if (ctrl == NULL || mapping->v4l2_type != V4L2_CTRL_TYPE_MENU) {
1414	ret = -EINVAL;
1415	goto done;
1416	}
1417
1418	if (!test_bit(query_menu->index, &mapping->menu_mask)) {
1419	ret = -EINVAL;
1420	goto done;
1421	}
1422
1423	if (mapping->data_type == UVC_CTRL_DATA_TYPE_BITMASK) {
1424	int mask;
1425
1426	if (!ctrl->cached) {
1427	ret = uvc_ctrl_populate_cache(chain, ctrl);
1428	if (ret < 0)
1429	goto done;
1430	}
1431
1432	mask = uvc_mapping_get_menu_value(mapping, idx: query_menu->index);
1433	if (mask < 0) {
1434	ret = mask;
1435	goto done;
1436	}
1437
1438	if (!(uvc_get_ctrl_bitmap(ctrl, mapping) & mask)) {
1439	ret = -EINVAL;
1440	goto done;
1441	}
1442	}
1443
1444	name = uvc_mapping_get_menu_name(mapping, idx: query_menu->index);
1445	if (!name) {
1446	ret = -EINVAL;
1447	goto done;
1448	}
1449
1450	strscpy(query_menu->name, name, sizeof(query_menu->name));
1451
1452	done:
1453	mutex_unlock(lock: &chain->ctrl_mutex);
1454	return ret;
1455	}
1456
1457	/* --------------------------------------------------------------------------
1458	* Ctrl event handling
1459	*/
1460
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)
1466	{
1467	struct v4l2_queryctrl v4l2_ctrl;
1468
1469	__uvc_query_v4l2_ctrl(chain, ctrl, mapping, v4l2_ctrl: &v4l2_ctrl);
1470
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;
1482	}
1483
1484	/*
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.
1490	*/
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)
1494	{
1495	struct v4l2_fh *originator = handle ? &handle->vfh : NULL;
1496	struct v4l2_subscribed_event *sev;
1497	struct v4l2_event ev;
1498
1499	if (list_empty(head: &mapping->ev_subs))
1500	return;
1501
1502	uvc_ctrl_fill_event(chain, ev: &ev, ctrl, mapping, value, changes);
1503
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(fh: sev->fh, ev: &ev);
1509	}
1510	}
1511
1512	/*
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.
1516	*/
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)
1519	{
1520	struct uvc_control_mapping *mapping = NULL;
1521	struct uvc_control *ctrl = NULL;
1522	u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
1523	s32 val = 0;
1524
1525	__uvc_find_control(entity: master->entity, v4l2_id: slave_id, mapping: &mapping, control: &ctrl, next: 0);
1526	if (ctrl == NULL)
1527	return;
1528
1529	if (__uvc_ctrl_get(chain, ctrl, mapping, value: &val) == 0)
1530	changes |= V4L2_EVENT_CTRL_CH_VALUE;
1531
1532	uvc_ctrl_send_event(chain, handle, ctrl, mapping, value: val, changes);
1533	}
1534
1535	void uvc_ctrl_status_event(struct uvc_video_chain *chain,
1536	struct uvc_control *ctrl, const u8 *data)
1537	{
1538	struct uvc_control_mapping *mapping;
1539	struct uvc_fh *handle;
1540	unsigned int i;
1541
1542	mutex_lock(&chain->ctrl_mutex);
1543
1544	handle = ctrl->handle;
1545	ctrl->handle = NULL;
1546
1547	list_for_each_entry(mapping, &ctrl->info.mappings, list) {
1548	s32 value = __uvc_ctrl_get_value(mapping, data);
1549
1550	/*
1551	* handle may be NULL here if the device sends auto-update
1552	* events without a prior related control set from userspace.
1553	*/
1554	for (i = 0; i < ARRAY_SIZE(mapping->slave_ids); ++i) {
1555	if (!mapping->slave_ids[i])
1556	break;
1557
1558	uvc_ctrl_send_slave_event(chain, handle, master: ctrl,
1559	slave_id: mapping->slave_ids[i]);
1560	}
1561
1562	uvc_ctrl_send_event(chain, handle, ctrl, mapping, value,
1563	V4L2_EVENT_CTRL_CH_VALUE);
1564	}
1565
1566	mutex_unlock(lock: &chain->ctrl_mutex);
1567	}
1568
1569	static void uvc_ctrl_status_event_work(struct work_struct *work)
1570	{
1571	struct uvc_device *dev = container_of(work, struct uvc_device,
1572	async_ctrl.work);
1573	struct uvc_ctrl_work *w = &dev->async_ctrl;
1574	int ret;
1575
1576	uvc_ctrl_status_event(chain: w->chain, ctrl: w->ctrl, data: w->data);
1577
1578	/* The barrier is needed to synchronize with uvc_status_stop(). */
1579	if (smp_load_acquire(&dev->flush_status))
1580	return;
1581
1582	/* Resubmit the URB. */
1583	w->urb->interval = dev->int_ep->desc.bInterval;
1584	ret = usb_submit_urb(urb: w->urb, GFP_KERNEL);
1585	if (ret < 0)
1586	dev_err(&dev->udev->dev,
1587	"Failed to resubmit status URB (%d).\n", ret);
1588	}
1589
1590	bool uvc_ctrl_status_event_async(struct urb *urb, struct uvc_video_chain *chain,
1591	struct uvc_control *ctrl, const u8 *data)
1592	{
1593	struct uvc_device *dev = chain->dev;
1594	struct uvc_ctrl_work *w = &dev->async_ctrl;
1595
1596	if (list_empty(head: &ctrl->info.mappings)) {
1597	ctrl->handle = NULL;
1598	return false;
1599	}
1600
1601	w->data = data;
1602	w->urb = urb;
1603	w->chain = chain;
1604	w->ctrl = ctrl;
1605
1606	schedule_work(work: &w->work);
1607
1608	return true;
1609	}
1610
1611	static bool uvc_ctrl_xctrls_has_control(const struct v4l2_ext_control *xctrls,
1612	unsigned int xctrls_count, u32 id)
1613	{
1614	unsigned int i;
1615
1616	for (i = 0; i < xctrls_count; ++i) {
1617	if (xctrls[i].id == id)
1618	return true;
1619	}
1620
1621	return false;
1622	}
1623
1624	static void uvc_ctrl_send_events(struct uvc_fh *handle,
1625	const struct v4l2_ext_control *xctrls, unsigned int xctrls_count)
1626	{
1627	struct uvc_control_mapping *mapping;
1628	struct uvc_control *ctrl;
1629	u32 changes = V4L2_EVENT_CTRL_CH_VALUE;
1630	unsigned int i;
1631	unsigned int j;
1632
1633	for (i = 0; i < xctrls_count; ++i) {
1634	ctrl = uvc_find_control(chain: handle->chain, v4l2_id: xctrls[i].id, mapping: &mapping);
1635
1636	if (ctrl->info.flags & UVC_CTRL_FLAG_ASYNCHRONOUS)
1637	/* Notification will be sent from an Interrupt event. */
1638	continue;
1639
1640	for (j = 0; j < ARRAY_SIZE(mapping->slave_ids); ++j) {
1641	u32 slave_id = mapping->slave_ids[j];
1642
1643	if (!slave_id)
1644	break;
1645
1646	/*
1647	* We can skip sending an event for the slave if the
1648	* slave is being modified in the same transaction.
1649	*/
1650	if (uvc_ctrl_xctrls_has_control(xctrls, xctrls_count,
1651	id: slave_id))
1652	continue;
1653
1654	uvc_ctrl_send_slave_event(chain: handle->chain, handle, master: ctrl,
1655	slave_id);
1656	}
1657
1658	/*
1659	* If the master is being modified in the same transaction
1660	* flags may change too.
1661	*/
1662	if (mapping->master_id &&
1663	uvc_ctrl_xctrls_has_control(xctrls, xctrls_count,
1664	id: mapping->master_id))
1665	changes |= V4L2_EVENT_CTRL_CH_FLAGS;
1666
1667	uvc_ctrl_send_event(chain: handle->chain, handle, ctrl, mapping,
1668	value: xctrls[i].value, changes);
1669	}
1670	}
1671
1672	static int uvc_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
1673	{
1674	struct uvc_fh *handle = container_of(sev->fh, struct uvc_fh, vfh);
1675	struct uvc_control_mapping *mapping;
1676	struct uvc_control *ctrl;
1677	int ret;
1678
1679	ret = mutex_lock_interruptible(&handle->chain->ctrl_mutex);
1680	if (ret < 0)
1681	return -ERESTARTSYS;
1682
1683	if (__uvc_query_v4l2_class(chain: handle->chain, req_id: sev->id, found_id: 0) >= 0) {
1684	ret = 0;
1685	goto done;
1686	}
1687
1688	ctrl = uvc_find_control(chain: handle->chain, v4l2_id: sev->id, mapping: &mapping);
1689	if (ctrl == NULL) {
1690	ret = -EINVAL;
1691	goto done;
1692	}
1693
1694	list_add_tail(new: &sev->node, head: &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;
1698	s32 val = 0;
1699
1700	if (__uvc_ctrl_get(chain: handle->chain, ctrl, mapping, value: &val) == 0)
1701	changes |= V4L2_EVENT_CTRL_CH_VALUE;
1702
1703	uvc_ctrl_fill_event(chain: handle->chain, ev: &ev, ctrl, mapping, value: val,
1704	changes);
1705	/*
1706	* Mark the queue as active, allowing this initial event to be
1707	* accepted.
1708	*/
1709	sev->elems = elems;
1710	v4l2_event_queue_fh(fh: sev->fh, ev: &ev);
1711	}
1712
1713	done:
1714	mutex_unlock(lock: &handle->chain->ctrl_mutex);
1715	return ret;
1716	}
1717
1718	static void uvc_ctrl_del_event(struct v4l2_subscribed_event *sev)
1719	{
1720	struct uvc_fh *handle = container_of(sev->fh, struct uvc_fh, vfh);
1721
1722	mutex_lock(&handle->chain->ctrl_mutex);
1723	if (__uvc_query_v4l2_class(chain: handle->chain, req_id: sev->id, found_id: 0) >= 0)
1724	goto done;
1725	list_del(entry: &sev->node);
1726	done:
1727	mutex_unlock(lock: &handle->chain->ctrl_mutex);
1728	}
1729
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,
1735	};
1736
1737	/* --------------------------------------------------------------------------
1738	* Control transactions
1739	*
1740	* To make extended set operations as atomic as the hardware allows, controls
1741	* are handled using begin/commit/rollback operations.
1742	*
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.
1745	*
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
1750	* field.
1751	*
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
1759	* control lock.
1760	*/
1761	int uvc_ctrl_begin(struct uvc_video_chain *chain)
1762	{
1763	return mutex_lock_interruptible(&chain->ctrl_mutex) ? -ERESTARTSYS : 0;
1764	}
1765
1766	static int uvc_ctrl_commit_entity(struct uvc_device *dev,
1767	struct uvc_entity *entity, int rollback, struct uvc_control **err_ctrl)
1768	{
1769	struct uvc_control *ctrl;
1770	unsigned int i;
1771	int ret;
1772
1773	if (entity == NULL)
1774	return 0;
1775
1776	for (i = 0; i < entity->ncontrols; ++i) {
1777	ctrl = &entity->controls[i];
1778	if (!ctrl->initialized)
1779	continue;
1780
1781	/*
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.
1787	*/
1788	if (ctrl->info.flags & UVC_CTRL_FLAG_AUTO_UPDATE ||
1789	!(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
1790	ctrl->loaded = 0;
1791
1792	if (!ctrl->dirty)
1793	continue;
1794
1795	if (!rollback)
1796	ret = uvc_query_ctrl(dev, UVC_SET_CUR, unit: ctrl->entity->id,
1797	intfnum: dev->intfnum, cs: ctrl->info.selector,
1798	data: uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1799	size: ctrl->info.size);
1800	else
1801	ret = 0;
1802
1803	if (rollback || ret < 0)
1804	memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1805	uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
1806	ctrl->info.size);
1807
1808	ctrl->dirty = 0;
1809
1810	if (ret < 0) {
1811	if (err_ctrl)
1812	*err_ctrl = ctrl;
1813	return ret;
1814	}
1815	}
1816
1817	return 0;
1818	}
1819
1820	static int uvc_ctrl_find_ctrl_idx(struct uvc_entity *entity,
1821	struct v4l2_ext_controls *ctrls,
1822	struct uvc_control *uvc_control)
1823	{
1824	struct uvc_control_mapping *mapping = NULL;
1825	struct uvc_control *ctrl_found = NULL;
1826	unsigned int i;
1827
1828	if (!entity)
1829	return ctrls->count;
1830
1831	for (i = 0; i < ctrls->count; i++) {
1832	__uvc_find_control(entity, v4l2_id: ctrls->controls[i].id, mapping: &mapping,
1833	control: &ctrl_found, next: 0);
1834	if (uvc_control == ctrl_found)
1835	return i;
1836	}
1837
1838	return ctrls->count;
1839	}
1840
1841	int __uvc_ctrl_commit(struct uvc_fh *handle, int rollback,
1842	struct v4l2_ext_controls *ctrls)
1843	{
1844	struct uvc_video_chain *chain = handle->chain;
1845	struct uvc_control *err_ctrl;
1846	struct uvc_entity *entity;
1847	int ret = 0;
1848
1849	/* Find the control. */
1850	list_for_each_entry(entity, &chain->entities, chain) {
1851	ret = uvc_ctrl_commit_entity(dev: chain->dev, entity, rollback,
1852	err_ctrl: &err_ctrl);
1853	if (ret < 0)
1854	goto done;
1855	}
1856
1857	if (!rollback)
1858	uvc_ctrl_send_events(handle, xctrls: ctrls->controls, xctrls_count: ctrls->count);
1859	done:
1860	if (ret < 0 && ctrls)
1861	ctrls->error_idx = uvc_ctrl_find_ctrl_idx(entity, ctrls,
1862	uvc_control: err_ctrl);
1863	mutex_unlock(lock: &chain->ctrl_mutex);
1864	return ret;
1865	}
1866
1867	int uvc_ctrl_get(struct uvc_video_chain *chain,
1868	struct v4l2_ext_control *xctrl)
1869	{
1870	struct uvc_control *ctrl;
1871	struct uvc_control_mapping *mapping;
1872
1873	if (__uvc_query_v4l2_class(chain, req_id: xctrl->id, found_id: 0) >= 0)
1874	return -EACCES;
1875
1876	ctrl = uvc_find_control(chain, v4l2_id: xctrl->id, mapping: &mapping);
1877	if (ctrl == NULL)
1878	return -EINVAL;
1879
1880	return __uvc_ctrl_get(chain, ctrl, mapping, value: &xctrl->value);
1881	}
1882
1883	int uvc_ctrl_set(struct uvc_fh *handle,
1884	struct v4l2_ext_control *xctrl)
1885	{
1886	struct uvc_video_chain *chain = handle->chain;
1887	struct uvc_control *ctrl;
1888	struct uvc_control_mapping *mapping;
1889	s32 value;
1890	u32 step;
1891	s32 min;
1892	s32 max;
1893	int ret;
1894
1895	if (__uvc_query_v4l2_class(chain, req_id: xctrl->id, found_id: 0) >= 0)
1896	return -EACCES;
1897
1898	ctrl = uvc_find_control(chain, v4l2_id: xctrl->id, mapping: &mapping);
1899	if (ctrl == NULL)
1900	return -EINVAL;
1901	if (!(ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR))
1902	return -EACCES;
1903
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);
1909	if (ret < 0)
1910	return ret;
1911	}
1912
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));
1919	if (step == 0)
1920	step = 1;
1921
1922	xctrl->value = min + DIV_ROUND_CLOSEST((u32)(xctrl->value - min),
1923	step) * step;
1924	if (mapping->data_type == UVC_CTRL_DATA_TYPE_SIGNED)
1925	xctrl->value = clamp(xctrl->value, min, max);
1926	else
1927	xctrl->value = clamp_t(u32, xctrl->value, min, max);
1928	value = xctrl->value;
1929	break;
1930
1931	case V4L2_CTRL_TYPE_BITMASK:
1932	if (!ctrl->cached) {
1933	ret = uvc_ctrl_populate_cache(chain, ctrl);
1934	if (ret < 0)
1935	return ret;
1936	}
1937
1938	xctrl->value &= uvc_get_ctrl_bitmap(ctrl, mapping);
1939	value = xctrl->value;
1940	break;
1941
1942	case V4L2_CTRL_TYPE_BOOLEAN:
1943	xctrl->value = clamp(xctrl->value, 0, 1);
1944	value = xctrl->value;
1945	break;
1946
1947	case V4L2_CTRL_TYPE_MENU:
1948	if (xctrl->value < (ffs(mapping->menu_mask) - 1) ||
1949	xctrl->value > (fls(x: mapping->menu_mask) - 1))
1950	return -ERANGE;
1951
1952	if (!test_bit(xctrl->value, &mapping->menu_mask))
1953	return -EINVAL;
1954
1955	value = uvc_mapping_get_menu_value(mapping, idx: xctrl->value);
1956
1957	/*
1958	* Valid menu indices are reported by the GET_RES request for
1959	* UVC controls that support it.
1960	*/
1961	if (mapping->data_type == UVC_CTRL_DATA_TYPE_BITMASK) {
1962	if (!ctrl->cached) {
1963	ret = uvc_ctrl_populate_cache(chain, ctrl);
1964	if (ret < 0)
1965	return ret;
1966	}
1967
1968	if (!(uvc_get_ctrl_bitmap(ctrl, mapping) & value))
1969	return -EINVAL;
1970	}
1971
1972	break;
1973
1974	default:
1975	value = xctrl->value;
1976	break;
1977	}
1978
1979	/*
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
1982	* operation.
1983	*/
1984	if ((ctrl->info.size * 8) != mapping->size) {
1985	ret = __uvc_ctrl_load_cur(chain, ctrl);
1986	if (ret < 0)
1987	return ret;
1988	}
1989
1990	/* Backup the current value in case we need to rollback later. */
1991	if (!ctrl->dirty) {
1992	memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
1993	uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1994	ctrl->info.size);
1995	}
1996
1997	mapping->set(mapping, value,
1998	uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT));
1999
2000	if (ctrl->info.flags & UVC_CTRL_FLAG_ASYNCHRONOUS)
2001	ctrl->handle = handle;
2002
2003	ctrl->dirty = 1;
2004	ctrl->modified = 1;
2005	return 0;
2006	}
2007
2008	/* --------------------------------------------------------------------------
2009	* Dynamic controls
2010	*/
2011
2012	/*
2013	* Retrieve flags for a given control
2014	*/
2015	static int uvc_ctrl_get_flags(struct uvc_device *dev,
2016	const struct uvc_control *ctrl,
2017	struct uvc_control_info *info)
2018	{
2019	u8 *data;
2020	int ret;
2021
2022	data = kmalloc(size: 1, GFP_KERNEL);
2023	if (data == NULL)
2024	return -ENOMEM;
2025
2026	if (ctrl->entity->get_info)
2027	ret = ctrl->entity->get_info(dev, ctrl->entity,
2028	ctrl->info.selector, data);
2029	else
2030	ret = uvc_query_ctrl(dev, UVC_GET_INFO, unit: ctrl->entity->id,
2031	intfnum: dev->intfnum, cs: info->selector, data, size: 1);
2032	if (!ret)
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);
2041
2042	kfree(objp: data);
2043	return ret;
2044	}
2045
2046	static void uvc_ctrl_fixup_xu_info(struct uvc_device *dev,
2047	const struct uvc_control *ctrl, struct uvc_control_info *info)
2048	{
2049	struct uvc_ctrl_fixup {
2050	struct usb_device_id id;
2051	u8 entity;
2052	u8 selector;
2053	u8 flags;
2054	};
2055
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 },
2069	};
2070
2071	unsigned int i;
2072
2073	for (i = 0; i < ARRAY_SIZE(fixups); ++i) {
2074	if (!usb_match_one_id(interface: dev->intf, id: &fixups[i].id))
2075	continue;
2076
2077	if (fixups[i].entity == ctrl->entity->id &&
2078	fixups[i].selector == info->selector) {
2079	info->flags = fixups[i].flags;
2080	return;
2081	}
2082	}
2083	}
2084
2085	/*
2086	* Query control information (size and flags) for XU controls.
2087	*/
2088	static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
2089	const struct uvc_control *ctrl, struct uvc_control_info *info)
2090	{
2091	u8 *data;
2092	int ret;
2093
2094	data = kmalloc(size: 2, GFP_KERNEL);
2095	if (data == NULL)
2096	return -ENOMEM;
2097
2098	memcpy(info->entity, ctrl->entity->guid, sizeof(info->entity));
2099	info->index = ctrl->index;
2100	info->selector = ctrl->index + 1;
2101
2102	/* Query and verify the control length (GET_LEN) */
2103	ret = uvc_query_ctrl(dev, UVC_GET_LEN, unit: ctrl->entity->id, intfnum: dev->intfnum,
2104	cs: info->selector, data, size: 2);
2105	if (ret < 0) {
2106	uvc_dbg(dev, CONTROL,
2107	"GET_LEN failed on control %pUl/%u (%d)\n",
2108	info->entity, info->selector, ret);
2109	goto done;
2110	}
2111
2112	info->size = le16_to_cpup(p: (__le16 *)data);
2113
2114	info->flags = UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX
2115	| UVC_CTRL_FLAG_GET_RES | UVC_CTRL_FLAG_GET_DEF;
2116
2117	ret = uvc_ctrl_get_flags(dev, ctrl, info);
2118	if (ret < 0) {
2119	uvc_dbg(dev, CONTROL,
2120	"Failed to get flags for control %pUl/%u (%d)\n",
2121	info->entity, info->selector, ret);
2122	goto done;
2123	}
2124
2125	uvc_ctrl_fixup_xu_info(dev, ctrl, info);
2126
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);
2133
2134	done:
2135	kfree(objp: data);
2136	return ret;
2137	}
2138
2139	static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
2140	const struct uvc_control_info *info);
2141
2142	static int uvc_ctrl_init_xu_ctrl(struct uvc_device *dev,
2143	struct uvc_control *ctrl)
2144	{
2145	struct uvc_control_info info;
2146	int ret;
2147
2148	if (ctrl->initialized)
2149	return 0;
2150
2151	ret = uvc_ctrl_fill_xu_info(dev, ctrl, info: &info);
2152	if (ret < 0)
2153	return ret;
2154
2155	ret = uvc_ctrl_add_info(dev, ctrl, info: &info);
2156	if (ret < 0)
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,
2160	ctrl->entity->id);
2161
2162	return ret;
2163	}
2164
2165	int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
2166	struct uvc_xu_control_query *xqry)
2167	{
2168	struct uvc_entity *entity;
2169	struct uvc_control *ctrl;
2170	unsigned int i;
2171	bool found;
2172	u32 reqflags;
2173	u16 size;
2174	u8 *data = NULL;
2175	int ret;
2176
2177	/* Find the extension unit. */
2178	found = false;
2179	list_for_each_entry(entity, &chain->entities, chain) {
2180	if (UVC_ENTITY_TYPE(entity) == UVC_VC_EXTENSION_UNIT &&
2181	entity->id == xqry->unit) {
2182	found = true;
2183	break;
2184	}
2185	}
2186
2187	if (!found) {
2188	uvc_dbg(chain->dev, CONTROL, "Extension unit %u not found\n",
2189	xqry->unit);
2190	return -ENOENT;
2191	}
2192
2193	/* Find the control and perform delayed initialization if needed. */
2194	found = false;
2195	for (i = 0; i < entity->ncontrols; ++i) {
2196	ctrl = &entity->controls[i];
2197	if (ctrl->index == xqry->selector - 1) {
2198	found = true;
2199	break;
2200	}
2201	}
2202
2203	if (!found) {
2204	uvc_dbg(chain->dev, CONTROL, "Control %pUl/%u not found\n",
2205	entity->guid, xqry->selector);
2206	return -ENOENT;
2207	}
2208
2209	if (mutex_lock_interruptible(&chain->ctrl_mutex))
2210	return -ERESTARTSYS;
2211
2212	ret = uvc_ctrl_init_xu_ctrl(dev: chain->dev, ctrl);
2213	if (ret < 0) {
2214	ret = -ENOENT;
2215	goto done;
2216	}
2217
2218	/* Validate the required buffer size and flags for the request */
2219	reqflags = 0;
2220	size = ctrl->info.size;
2221
2222	switch (xqry->query) {
2223	case UVC_GET_CUR:
2224	reqflags = UVC_CTRL_FLAG_GET_CUR;
2225	break;
2226	case UVC_GET_MIN:
2227	reqflags = UVC_CTRL_FLAG_GET_MIN;
2228	break;
2229	case UVC_GET_MAX:
2230	reqflags = UVC_CTRL_FLAG_GET_MAX;
2231	break;
2232	case UVC_GET_DEF:
2233	reqflags = UVC_CTRL_FLAG_GET_DEF;
2234	break;
2235	case UVC_GET_RES:
2236	reqflags = UVC_CTRL_FLAG_GET_RES;
2237	break;
2238	case UVC_SET_CUR:
2239	reqflags = UVC_CTRL_FLAG_SET_CUR;
2240	break;
2241	case UVC_GET_LEN:
2242	size = 2;
2243	break;
2244	case UVC_GET_INFO:
2245	size = 1;
2246	break;
2247	default:
2248	ret = -EINVAL;
2249	goto done;
2250	}
2251
2252	if (size != xqry->size) {
2253	ret = -ENOBUFS;
2254	goto done;
2255	}
2256
2257	if (reqflags && !(ctrl->info.flags & reqflags)) {
2258	ret = -EBADRQC;
2259	goto done;
2260	}
2261
2262	data = kmalloc(size, GFP_KERNEL);
2263	if (data == NULL) {
2264	ret = -ENOMEM;
2265	goto done;
2266	}
2267
2268	if (xqry->query == UVC_SET_CUR &&
2269	copy_from_user(to: data, from: xqry->data, n: size)) {
2270	ret = -EFAULT;
2271	goto done;
2272	}
2273
2274	ret = uvc_query_ctrl(dev: chain->dev, query: xqry->query, unit: xqry->unit,
2275	intfnum: chain->dev->intfnum, cs: xqry->selector, data, size);
2276	if (ret < 0)
2277	goto done;
2278
2279	if (xqry->query != UVC_SET_CUR &&
2280	copy_to_user(to: xqry->data, from: data, n: size))
2281	ret = -EFAULT;
2282	done:
2283	kfree(objp: data);
2284	mutex_unlock(lock: &chain->ctrl_mutex);
2285	return ret;
2286	}
2287
2288	/* --------------------------------------------------------------------------
2289	* Suspend/resume
2290	*/
2291
2292	/*
2293	* Restore control values after resume, skipping controls that haven't been
2294	* changed.
2295	*
2296	* TODO
2297	* - Don't restore modified controls that are back to their default value.
2298	* - Handle restore order (Auto-Exposure Mode should be restored before
2299	* Exposure Time).
2300	*/
2301	int uvc_ctrl_restore_values(struct uvc_device *dev)
2302	{
2303	struct uvc_control *ctrl;
2304	struct uvc_entity *entity;
2305	unsigned int i;
2306	int ret;
2307
2308	/* Walk the entities list and restore controls when possible. */
2309	list_for_each_entry(entity, &dev->entities, list) {
2310
2311	for (i = 0; i < entity->ncontrols; ++i) {
2312	ctrl = &entity->controls[i];
2313
2314	if (!ctrl->initialized || !ctrl->modified ||
2315	(ctrl->info.flags & UVC_CTRL_FLAG_RESTORE) == 0)
2316	continue;
2317	dev_dbg(&dev->udev->dev,
2318	"restoring control %pUl/%u/%u\n",
2319	ctrl->info.entity, ctrl->info.index,
2320	ctrl->info.selector);
2321	ctrl->dirty = 1;
2322	}
2323
2324	ret = uvc_ctrl_commit_entity(dev, entity, rollback: 0, NULL);
2325	if (ret < 0)
2326	return ret;
2327	}
2328
2329	return 0;
2330	}
2331
2332	/* --------------------------------------------------------------------------
2333	* Control and mapping handling
2334	*/
2335
2336	/*
2337	* Add control information to a given control.
2338	*/
2339	static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
2340	const struct uvc_control_info *info)
2341	{
2342	ctrl->info = *info;
2343	INIT_LIST_HEAD(list: &ctrl->info.mappings);
2344
2345	/* Allocate an array to save control values (cur, def, max, etc.) */
2346	ctrl->uvc_data = kzalloc(size: ctrl->info.size * UVC_CTRL_DATA_LAST + 1,
2347	GFP_KERNEL);
2348	if (!ctrl->uvc_data)
2349	return -ENOMEM;
2350
2351	ctrl->initialized = 1;
2352
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,
2355	ctrl->entity->id);
2356
2357	return 0;
2358	}
2359
2360	/*
2361	* Add a control mapping to a given control.
2362	*/
2363	static int __uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
2364	struct uvc_control *ctrl, const struct uvc_control_mapping *mapping)
2365	{
2366	struct uvc_control_mapping *map;
2367	unsigned int size;
2368	unsigned int i;
2369
2370	/*
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.
2374	*/
2375	map = kmemdup(p: mapping, size: sizeof(*mapping), GFP_KERNEL);
2376	if (!map)
2377	return -ENOMEM;
2378
2379	map->name = NULL;
2380	map->menu_names = NULL;
2381	map->menu_mapping = NULL;
2382
2383	/* For UVCIOC_CTRL_MAP custom control */
2384	if (mapping->name) {
2385	map->name = kstrdup(s: mapping->name, GFP_KERNEL);
2386	if (!map->name)
2387	goto err_nomem;
2388	}
2389
2390	INIT_LIST_HEAD(list: &map->ev_subs);
2391
2392	if (mapping->menu_mapping && mapping->menu_mask) {
2393	size = sizeof(mapping->menu_mapping[0])
2394	* fls(x: mapping->menu_mask);
2395	map->menu_mapping = kmemdup(p: mapping->menu_mapping, size,
2396	GFP_KERNEL);
2397	if (!map->menu_mapping)
2398	goto err_nomem;
2399	}
2400	if (mapping->menu_names && mapping->menu_mask) {
2401	size = sizeof(mapping->menu_names[0])
2402	* fls(x: mapping->menu_mask);
2403	map->menu_names = kmemdup(p: mapping->menu_names, size,
2404	GFP_KERNEL);
2405	if (!map->menu_names)
2406	goto err_nomem;
2407	}
2408
2409	if (map->get == NULL)
2410	map->get = uvc_get_le_value;
2411	if (map->set == NULL)
2412	map->set = uvc_set_le_value;
2413
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);
2418	break;
2419	}
2420	}
2421
2422	list_add_tail(new: &map->list, head: &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);
2426
2427	return 0;
2428
2429	err_nomem:
2430	kfree(objp: map->menu_names);
2431	kfree(objp: map->menu_mapping);
2432	kfree(objp: map->name);
2433	kfree(objp: map);
2434	return -ENOMEM;
2435	}
2436
2437	int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
2438	const struct uvc_control_mapping *mapping)
2439	{
2440	struct uvc_device *dev = chain->dev;
2441	struct uvc_control_mapping *map;
2442	struct uvc_entity *entity;
2443	struct uvc_control *ctrl;
2444	int found = 0;
2445	int ret;
2446
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);
2451	return -EINVAL;
2452	}
2453
2454	/* Search for the matching (GUID/CS) control on the current chain */
2455	list_for_each_entry(entity, &chain->entities, chain) {
2456	unsigned int i;
2457
2458	if (UVC_ENTITY_TYPE(entity) != UVC_VC_EXTENSION_UNIT ||
2459	!uvc_entity_match_guid(entity, guid: mapping->entity))
2460	continue;
2461
2462	for (i = 0; i < entity->ncontrols; ++i) {
2463	ctrl = &entity->controls[i];
2464	if (ctrl->index == mapping->selector - 1) {
2465	found = 1;
2466	break;
2467	}
2468	}
2469
2470	if (found)
2471	break;
2472	}
2473	if (!found)
2474	return -ENOENT;
2475
2476	if (mutex_lock_interruptible(&chain->ctrl_mutex))
2477	return -ERESTARTSYS;
2478
2479	/* Perform delayed initialization of XU controls */
2480	ret = uvc_ctrl_init_xu_ctrl(dev, ctrl);
2481	if (ret < 0) {
2482	ret = -ENOENT;
2483	goto done;
2484	}
2485
2486	/* Validate the user-provided bit-size and offset */
2487	if (mapping->size > 32 ||
2488	mapping->offset + mapping->size > ctrl->info.size * 8) {
2489	ret = -EINVAL;
2490	goto done;
2491	}
2492
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);
2498	ret = -EEXIST;
2499	goto done;
2500	}
2501	}
2502
2503	/* Prevent excess memory consumption */
2504	if (atomic_inc_return(v: &dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) {
2505	atomic_dec(v: &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);
2509	ret = -ENOMEM;
2510	goto done;
2511	}
2512
2513	ret = __uvc_ctrl_add_mapping(chain, ctrl, mapping);
2514	if (ret < 0)
2515	atomic_dec(v: &dev->nmappings);
2516
2517	done:
2518	mutex_unlock(lock: &chain->ctrl_mutex);
2519	return ret;
2520	}
2521
2522	/*
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.
2526	*/
2527	static void uvc_ctrl_prune_entity(struct uvc_device *dev,
2528	struct uvc_entity *entity)
2529	{
2530	struct uvc_ctrl_blacklist {
2531	struct usb_device_id id;
2532	u8 index;
2533	};
2534
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 */
2539	};
2540	static const struct uvc_ctrl_blacklist camera_blacklist[] = {
2541	{ { USB_DEVICE(0x06f8, 0x3005) }, 9 }, /* Zoom, Absolute */
2542	};
2543
2544	const struct uvc_ctrl_blacklist *blacklist;
2545	unsigned int size;
2546	unsigned int count;
2547	unsigned int i;
2548	u8 *controls;
2549
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;
2556	break;
2557
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;
2563	break;
2564
2565	default:
2566	return;
2567	}
2568
2569	for (i = 0; i < count; ++i) {
2570	if (!usb_match_one_id(interface: dev->intf, id: &blacklist[i].id))
2571	continue;
2572
2573	if (blacklist[i].index >= 8 * size ||
2574	!uvc_test_bit(data: controls, bit: blacklist[i].index))
2575	continue;
2576
2577	uvc_dbg(dev, CONTROL,
2578	"%u/%u control is black listed, removing it\n",
2579	entity->id, blacklist[i].index);
2580
2581	uvc_clear_bit(data: controls, bit: blacklist[i].index);
2582	}
2583	}
2584
2585	/*
2586	* Add control information and hardcoded stock control mappings to the given
2587	* device.
2588	*/
2589	static void uvc_ctrl_init_ctrl(struct uvc_video_chain *chain,
2590	struct uvc_control *ctrl)
2591	{
2592	const struct uvc_control_mapping **mappings;
2593	unsigned int i;
2594
2595	/*
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
2599	* first use.
2600	*/
2601	if (UVC_ENTITY_TYPE(ctrl->entity) == UVC_VC_EXTENSION_UNIT)
2602	return;
2603
2604	for (i = 0; i < ARRAY_SIZE(uvc_ctrls); ++i) {
2605	const struct uvc_control_info *info = &uvc_ctrls[i];
2606
2607	if (uvc_entity_match_guid(entity: ctrl->entity, guid: info->entity) &&
2608	ctrl->index == info->index) {
2609	uvc_ctrl_add_info(dev: chain->dev, ctrl, info);
2610	/*
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.
2615	*/
2616	uvc_ctrl_get_flags(dev: chain->dev, ctrl, info: &ctrl->info);
2617	break;
2618	}
2619	}
2620
2621	if (!ctrl->initialized)
2622	return;
2623
2624	/*
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
2629	* a single control.
2630	*/
2631	if (chain->dev->info->mappings) {
2632	bool custom = false;
2633
2634	for (i = 0; chain->dev->info->mappings[i]; ++i) {
2635	const struct uvc_control_mapping *mapping =
2636	chain->dev->info->mappings[i];
2637
2638	if (uvc_entity_match_guid(entity: ctrl->entity, guid: mapping->entity) &&
2639	ctrl->info.selector == mapping->selector) {
2640	__uvc_ctrl_add_mapping(chain, ctrl, mapping);
2641	custom = true;
2642	}
2643	}
2644
2645	if (custom)
2646	return;
2647	}
2648
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];
2652
2653	if (uvc_entity_match_guid(entity: ctrl->entity, guid: mapping->entity) &&
2654	ctrl->info.selector == mapping->selector)
2655	__uvc_ctrl_add_mapping(chain, ctrl, mapping);
2656	}
2657
2658	/* Finally process version-specific mappings. */
2659	mappings = chain->dev->uvc_version < 0x0150
2660	? uvc_ctrl_mappings_uvc11 : uvc_ctrl_mappings_uvc15;
2661
2662	for (i = 0; mappings[i]; ++i) {
2663	const struct uvc_control_mapping *mapping = mappings[i];
2664
2665	if (uvc_entity_match_guid(entity: ctrl->entity, guid: mapping->entity) &&
2666	ctrl->info.selector == mapping->selector)
2667	__uvc_ctrl_add_mapping(chain, ctrl, mapping);
2668	}
2669	}
2670
2671	/*
2672	* Initialize device controls.
2673	*/
2674	static int uvc_ctrl_init_chain(struct uvc_video_chain *chain)
2675	{
2676	struct uvc_entity *entity;
2677	unsigned int i;
2678
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;
2684
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;
2697	}
2698
2699	/* Remove bogus/blacklisted controls */
2700	uvc_ctrl_prune_entity(dev: chain->dev, entity);
2701
2702	/* Count supported controls and allocate the controls array */
2703	ncontrols = memweight(ptr: bmControls, bytes: bControlSize);
2704	if (ncontrols == 0)
2705	continue;
2706
2707	entity->controls = kcalloc(n: ncontrols, size: sizeof(*ctrl),
2708	GFP_KERNEL);
2709	if (entity->controls == NULL)
2710	return -ENOMEM;
2711	entity->ncontrols = ncontrols;
2712
2713	/* Initialize all supported controls */
2714	ctrl = entity->controls;
2715	for (i = 0; i < bControlSize * 8; ++i) {
2716	if (uvc_test_bit(data: bmControls, bit: i) == 0)
2717	continue;
2718
2719	ctrl->entity = entity;
2720	ctrl->index = i;
2721
2722	uvc_ctrl_init_ctrl(chain, ctrl);
2723	ctrl++;
2724	}
2725	}
2726
2727	return 0;
2728	}
2729
2730	int uvc_ctrl_init_device(struct uvc_device *dev)
2731	{
2732	struct uvc_video_chain *chain;
2733	int ret;
2734
2735	INIT_WORK(&dev->async_ctrl.work, uvc_ctrl_status_event_work);
2736
2737	list_for_each_entry(chain, &dev->chains, list) {
2738	ret = uvc_ctrl_init_chain(chain);
2739	if (ret)
2740	return ret;
2741	}
2742
2743	return 0;
2744	}
2745
2746	/*
2747	* Cleanup device controls.
2748	*/
2749	static void uvc_ctrl_cleanup_mappings(struct uvc_device *dev,
2750	struct uvc_control *ctrl)
2751	{
2752	struct uvc_control_mapping *mapping, *nm;
2753
2754	list_for_each_entry_safe(mapping, nm, &ctrl->info.mappings, list) {
2755	list_del(entry: &mapping->list);
2756	kfree(objp: mapping->menu_names);
2757	kfree(objp: mapping->menu_mapping);
2758	kfree(objp: mapping->name);
2759	kfree(objp: mapping);
2760	}
2761	}
2762
2763	void uvc_ctrl_cleanup_device(struct uvc_device *dev)
2764	{
2765	struct uvc_entity *entity;
2766	unsigned int i;
2767
2768	/* Can be uninitialized if we are aborting on probe error. */
2769	if (dev->async_ctrl.work.func)
2770	cancel_work_sync(work: &dev->async_ctrl.work);
2771
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];
2776
2777	if (!ctrl->initialized)
2778	continue;
2779
2780	uvc_ctrl_cleanup_mappings(dev, ctrl);
2781	kfree(objp: ctrl->uvc_data);
2782	}
2783
2784	kfree(objp: entity->controls);
2785	}
2786	}
2787