1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * |
4 | * Copyright (C) 2005 Mike Isely <isely@pobox.com> |
5 | */ |
6 | |
7 | #include "pvrusb2-ctrl.h" |
8 | #include "pvrusb2-hdw-internal.h" |
9 | #include <linux/errno.h> |
10 | #include <linux/string.h> |
11 | #include <linux/mutex.h> |
12 | |
13 | |
14 | static int pvr2_ctrl_range_check(struct pvr2_ctrl *cptr,int val) |
15 | { |
16 | if (cptr->info->check_value) { |
17 | if (!cptr->info->check_value(cptr,val)) return -ERANGE; |
18 | } else if (cptr->info->type == pvr2_ctl_enum) { |
19 | if (val < 0) return -ERANGE; |
20 | if (val >= cptr->info->def.type_enum.count) return -ERANGE; |
21 | } else { |
22 | int lim; |
23 | lim = cptr->info->def.type_int.min_value; |
24 | if (cptr->info->get_min_value) { |
25 | cptr->info->get_min_value(cptr,&lim); |
26 | } |
27 | if (val < lim) return -ERANGE; |
28 | lim = cptr->info->def.type_int.max_value; |
29 | if (cptr->info->get_max_value) { |
30 | cptr->info->get_max_value(cptr,&lim); |
31 | } |
32 | if (val > lim) return -ERANGE; |
33 | } |
34 | return 0; |
35 | } |
36 | |
37 | |
38 | /* Set the given control. */ |
39 | int pvr2_ctrl_set_value(struct pvr2_ctrl *cptr,int val) |
40 | { |
41 | return pvr2_ctrl_set_mask_value(cptr,mask: ~0,val); |
42 | } |
43 | |
44 | |
45 | /* Set/clear specific bits of the given control. */ |
46 | int pvr2_ctrl_set_mask_value(struct pvr2_ctrl *cptr,int mask,int val) |
47 | { |
48 | int ret = 0; |
49 | if (!cptr) return -EINVAL; |
50 | LOCK_TAKE(cptr->hdw->big_lock); do { |
51 | if (cptr->info->set_value) { |
52 | if (cptr->info->type == pvr2_ctl_bitmask) { |
53 | mask &= cptr->info->def.type_bitmask.valid_bits; |
54 | } else if ((cptr->info->type == pvr2_ctl_int)|| |
55 | (cptr->info->type == pvr2_ctl_enum)) { |
56 | ret = pvr2_ctrl_range_check(cptr,val); |
57 | if (ret < 0) break; |
58 | } else if (cptr->info->type != pvr2_ctl_bool) { |
59 | break; |
60 | } |
61 | ret = cptr->info->set_value(cptr,mask,val); |
62 | } else { |
63 | ret = -EPERM; |
64 | } |
65 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
66 | return ret; |
67 | } |
68 | |
69 | |
70 | /* Get the current value of the given control. */ |
71 | int pvr2_ctrl_get_value(struct pvr2_ctrl *cptr,int *valptr) |
72 | { |
73 | int ret = 0; |
74 | if (!cptr) return -EINVAL; |
75 | LOCK_TAKE(cptr->hdw->big_lock); do { |
76 | ret = cptr->info->get_value(cptr,valptr); |
77 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
78 | return ret; |
79 | } |
80 | |
81 | |
82 | /* Retrieve control's type */ |
83 | enum pvr2_ctl_type pvr2_ctrl_get_type(struct pvr2_ctrl *cptr) |
84 | { |
85 | if (!cptr) return pvr2_ctl_int; |
86 | return cptr->info->type; |
87 | } |
88 | |
89 | |
90 | /* Retrieve control's maximum value (int type) */ |
91 | int pvr2_ctrl_get_max(struct pvr2_ctrl *cptr) |
92 | { |
93 | int ret = 0; |
94 | if (!cptr) return 0; |
95 | LOCK_TAKE(cptr->hdw->big_lock); do { |
96 | if (cptr->info->get_max_value) { |
97 | cptr->info->get_max_value(cptr,&ret); |
98 | } else if (cptr->info->type == pvr2_ctl_int) { |
99 | ret = cptr->info->def.type_int.max_value; |
100 | } |
101 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
102 | return ret; |
103 | } |
104 | |
105 | |
106 | /* Retrieve control's minimum value (int type) */ |
107 | int pvr2_ctrl_get_min(struct pvr2_ctrl *cptr) |
108 | { |
109 | int ret = 0; |
110 | if (!cptr) return 0; |
111 | LOCK_TAKE(cptr->hdw->big_lock); do { |
112 | if (cptr->info->get_min_value) { |
113 | cptr->info->get_min_value(cptr,&ret); |
114 | } else if (cptr->info->type == pvr2_ctl_int) { |
115 | ret = cptr->info->def.type_int.min_value; |
116 | } |
117 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
118 | return ret; |
119 | } |
120 | |
121 | |
122 | /* Retrieve control's default value (any type) */ |
123 | int pvr2_ctrl_get_def(struct pvr2_ctrl *cptr, int *valptr) |
124 | { |
125 | int ret = 0; |
126 | if (!cptr) return -EINVAL; |
127 | LOCK_TAKE(cptr->hdw->big_lock); do { |
128 | if (cptr->info->get_def_value) { |
129 | ret = cptr->info->get_def_value(cptr, valptr); |
130 | } else { |
131 | *valptr = cptr->info->default_value; |
132 | } |
133 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
134 | return ret; |
135 | } |
136 | |
137 | |
138 | /* Retrieve control's enumeration count (enum only) */ |
139 | int pvr2_ctrl_get_cnt(struct pvr2_ctrl *cptr) |
140 | { |
141 | int ret = 0; |
142 | if (!cptr) return 0; |
143 | LOCK_TAKE(cptr->hdw->big_lock); do { |
144 | if (cptr->info->type == pvr2_ctl_enum) { |
145 | ret = cptr->info->def.type_enum.count; |
146 | } |
147 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
148 | return ret; |
149 | } |
150 | |
151 | |
152 | /* Retrieve control's valid mask bits (bit mask only) */ |
153 | int pvr2_ctrl_get_mask(struct pvr2_ctrl *cptr) |
154 | { |
155 | int ret = 0; |
156 | if (!cptr) return 0; |
157 | LOCK_TAKE(cptr->hdw->big_lock); do { |
158 | if (cptr->info->type == pvr2_ctl_bitmask) { |
159 | ret = cptr->info->def.type_bitmask.valid_bits; |
160 | } |
161 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
162 | return ret; |
163 | } |
164 | |
165 | |
166 | /* Retrieve the control's name */ |
167 | const char *pvr2_ctrl_get_name(struct pvr2_ctrl *cptr) |
168 | { |
169 | if (!cptr) return NULL; |
170 | return cptr->info->name; |
171 | } |
172 | |
173 | |
174 | /* Retrieve the control's desc */ |
175 | const char *pvr2_ctrl_get_desc(struct pvr2_ctrl *cptr) |
176 | { |
177 | if (!cptr) return NULL; |
178 | return cptr->info->desc; |
179 | } |
180 | |
181 | |
182 | /* Retrieve a control enumeration or bit mask value */ |
183 | int pvr2_ctrl_get_valname(struct pvr2_ctrl *cptr,int val, |
184 | char *bptr,unsigned int bmax, |
185 | unsigned int *blen) |
186 | { |
187 | int ret = -EINVAL; |
188 | if (!cptr) return 0; |
189 | *blen = 0; |
190 | LOCK_TAKE(cptr->hdw->big_lock); do { |
191 | if (cptr->info->type == pvr2_ctl_enum) { |
192 | const char * const *names; |
193 | names = cptr->info->def.type_enum.value_names; |
194 | if (pvr2_ctrl_range_check(cptr,val) == 0) { |
195 | if (names[val]) { |
196 | *blen = scnprintf( |
197 | buf: bptr,size: bmax,fmt: "%s" , |
198 | names[val]); |
199 | } else { |
200 | *blen = 0; |
201 | } |
202 | ret = 0; |
203 | } |
204 | } else if (cptr->info->type == pvr2_ctl_bitmask) { |
205 | const char **names; |
206 | unsigned int idx; |
207 | int msk; |
208 | names = cptr->info->def.type_bitmask.bit_names; |
209 | val &= cptr->info->def.type_bitmask.valid_bits; |
210 | for (idx = 0, msk = 1; val; idx++, msk <<= 1) { |
211 | if (val & msk) { |
212 | *blen = scnprintf(buf: bptr,size: bmax,fmt: "%s" , |
213 | names[idx]); |
214 | ret = 0; |
215 | break; |
216 | } |
217 | } |
218 | } |
219 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
220 | return ret; |
221 | } |
222 | |
223 | |
224 | /* Return V4L ID for this control or zero if none */ |
225 | int pvr2_ctrl_get_v4lid(struct pvr2_ctrl *cptr) |
226 | { |
227 | if (!cptr) return 0; |
228 | return cptr->info->v4l_id; |
229 | } |
230 | |
231 | |
232 | unsigned int pvr2_ctrl_get_v4lflags(struct pvr2_ctrl *cptr) |
233 | { |
234 | unsigned int flags = 0; |
235 | |
236 | if (cptr->info->get_v4lflags) { |
237 | flags = cptr->info->get_v4lflags(cptr); |
238 | } |
239 | |
240 | if (cptr->info->set_value) { |
241 | flags &= ~V4L2_CTRL_FLAG_READ_ONLY; |
242 | } else { |
243 | flags |= V4L2_CTRL_FLAG_READ_ONLY; |
244 | } |
245 | |
246 | return flags; |
247 | } |
248 | |
249 | |
250 | /* Return true if control is writable */ |
251 | int pvr2_ctrl_is_writable(struct pvr2_ctrl *cptr) |
252 | { |
253 | if (!cptr) return 0; |
254 | return cptr->info->set_value != NULL; |
255 | } |
256 | |
257 | |
258 | /* Return true if control has custom symbolic representation */ |
259 | int pvr2_ctrl_has_custom_symbols(struct pvr2_ctrl *cptr) |
260 | { |
261 | if (!cptr) return 0; |
262 | if (!cptr->info->val_to_sym) return 0; |
263 | if (!cptr->info->sym_to_val) return 0; |
264 | return !0; |
265 | } |
266 | |
267 | |
268 | /* Convert a given mask/val to a custom symbolic value */ |
269 | int pvr2_ctrl_custom_value_to_sym(struct pvr2_ctrl *cptr, |
270 | int mask,int val, |
271 | char *buf,unsigned int maxlen, |
272 | unsigned int *len) |
273 | { |
274 | if (!cptr) return -EINVAL; |
275 | if (!cptr->info->val_to_sym) return -EINVAL; |
276 | return cptr->info->val_to_sym(cptr,mask,val,buf,maxlen,len); |
277 | } |
278 | |
279 | |
280 | /* Convert a symbolic value to a mask/value pair */ |
281 | int pvr2_ctrl_custom_sym_to_value(struct pvr2_ctrl *cptr, |
282 | const char *buf,unsigned int len, |
283 | int *maskptr,int *valptr) |
284 | { |
285 | if (!cptr) return -EINVAL; |
286 | if (!cptr->info->sym_to_val) return -EINVAL; |
287 | return cptr->info->sym_to_val(cptr,buf,len,maskptr,valptr); |
288 | } |
289 | |
290 | |
291 | static unsigned int gen_bitmask_string(int msk,int val,int msk_only, |
292 | const char **names, |
293 | char *ptr,unsigned int len) |
294 | { |
295 | unsigned int idx; |
296 | long sm,um; |
297 | int spcFl; |
298 | unsigned int uc,cnt; |
299 | const char *idStr; |
300 | |
301 | spcFl = 0; |
302 | uc = 0; |
303 | um = 0; |
304 | for (idx = 0, sm = 1; msk; idx++, sm <<= 1) { |
305 | if (sm & msk) { |
306 | msk &= ~sm; |
307 | idStr = names[idx]; |
308 | if (idStr) { |
309 | cnt = scnprintf(buf: ptr,size: len,fmt: "%s%s%s" , |
310 | (spcFl ? " " : "" ), |
311 | (msk_only ? "" : |
312 | ((val & sm) ? "+" : "-" )), |
313 | idStr); |
314 | ptr += cnt; len -= cnt; uc += cnt; |
315 | spcFl = !0; |
316 | } else { |
317 | um |= sm; |
318 | } |
319 | } |
320 | } |
321 | if (um) { |
322 | if (msk_only) { |
323 | cnt = scnprintf(buf: ptr,size: len,fmt: "%s0x%lx" , |
324 | (spcFl ? " " : "" ), |
325 | um); |
326 | ptr += cnt; len -= cnt; uc += cnt; |
327 | spcFl = !0; |
328 | } else if (um & val) { |
329 | cnt = scnprintf(buf: ptr,size: len,fmt: "%s+0x%lx" , |
330 | (spcFl ? " " : "" ), |
331 | um & val); |
332 | ptr += cnt; len -= cnt; uc += cnt; |
333 | spcFl = !0; |
334 | } else if (um & ~val) { |
335 | cnt = scnprintf(buf: ptr,size: len,fmt: "%s+0x%lx" , |
336 | (spcFl ? " " : "" ), |
337 | um & ~val); |
338 | ptr += cnt; len -= cnt; uc += cnt; |
339 | spcFl = !0; |
340 | } |
341 | } |
342 | return uc; |
343 | } |
344 | |
345 | |
346 | static const char *boolNames[] = { |
347 | "false" , |
348 | "true" , |
349 | "no" , |
350 | "yes" , |
351 | }; |
352 | |
353 | |
354 | static int parse_token(const char *ptr,unsigned int len, |
355 | int *valptr, |
356 | const char * const *names, unsigned int namecnt) |
357 | { |
358 | unsigned int slen; |
359 | unsigned int idx; |
360 | *valptr = 0; |
361 | if (!names) namecnt = 0; |
362 | for (idx = 0; idx < namecnt; idx++) { |
363 | if (!names[idx]) continue; |
364 | slen = strlen(names[idx]); |
365 | if (slen != len) continue; |
366 | if (memcmp(p: names[idx],q: ptr,size: slen)) continue; |
367 | *valptr = idx; |
368 | return 0; |
369 | } |
370 | return kstrtoint(s: ptr, base: 0, res: valptr) ? -EINVAL : 1; |
371 | } |
372 | |
373 | |
374 | static int parse_mtoken(const char *ptr,unsigned int len, |
375 | int *valptr, |
376 | const char **names,int valid_bits) |
377 | { |
378 | unsigned int slen; |
379 | unsigned int idx; |
380 | int msk; |
381 | *valptr = 0; |
382 | for (idx = 0, msk = 1; valid_bits; idx++, msk <<= 1) { |
383 | if (!(msk & valid_bits)) continue; |
384 | valid_bits &= ~msk; |
385 | if (!names[idx]) continue; |
386 | slen = strlen(names[idx]); |
387 | if (slen != len) continue; |
388 | if (memcmp(p: names[idx],q: ptr,size: slen)) continue; |
389 | *valptr = msk; |
390 | return 0; |
391 | } |
392 | return kstrtoint(s: ptr, base: 0, res: valptr); |
393 | } |
394 | |
395 | |
396 | static int parse_tlist(const char *ptr,unsigned int len, |
397 | int *maskptr,int *valptr, |
398 | const char **names,int valid_bits) |
399 | { |
400 | unsigned int cnt; |
401 | int mask,val,kv,mode,ret; |
402 | mask = 0; |
403 | val = 0; |
404 | ret = 0; |
405 | while (len) { |
406 | cnt = 0; |
407 | while ((cnt < len) && |
408 | ((ptr[cnt] <= 32) || |
409 | (ptr[cnt] >= 127))) cnt++; |
410 | ptr += cnt; |
411 | len -= cnt; |
412 | mode = 0; |
413 | if ((*ptr == '-') || (*ptr == '+')) { |
414 | mode = (*ptr == '-') ? -1 : 1; |
415 | ptr++; |
416 | len--; |
417 | } |
418 | cnt = 0; |
419 | while (cnt < len) { |
420 | if (ptr[cnt] <= 32) break; |
421 | if (ptr[cnt] >= 127) break; |
422 | cnt++; |
423 | } |
424 | if (!cnt) break; |
425 | if (parse_mtoken(ptr,len: cnt,valptr: &kv,names,valid_bits)) { |
426 | ret = -EINVAL; |
427 | break; |
428 | } |
429 | ptr += cnt; |
430 | len -= cnt; |
431 | switch (mode) { |
432 | case 0: |
433 | mask = valid_bits; |
434 | val |= kv; |
435 | break; |
436 | case -1: |
437 | mask |= kv; |
438 | val &= ~kv; |
439 | break; |
440 | case 1: |
441 | mask |= kv; |
442 | val |= kv; |
443 | break; |
444 | default: |
445 | break; |
446 | } |
447 | } |
448 | *maskptr = mask; |
449 | *valptr = val; |
450 | return ret; |
451 | } |
452 | |
453 | |
454 | /* Convert a symbolic value to a mask/value pair */ |
455 | int pvr2_ctrl_sym_to_value(struct pvr2_ctrl *cptr, |
456 | const char *ptr,unsigned int len, |
457 | int *maskptr,int *valptr) |
458 | { |
459 | int ret = -EINVAL; |
460 | unsigned int cnt; |
461 | |
462 | *maskptr = 0; |
463 | *valptr = 0; |
464 | |
465 | cnt = 0; |
466 | while ((cnt < len) && ((ptr[cnt] <= 32) || (ptr[cnt] >= 127))) cnt++; |
467 | len -= cnt; ptr += cnt; |
468 | cnt = 0; |
469 | while ((cnt < len) && ((ptr[len-(cnt+1)] <= 32) || |
470 | (ptr[len-(cnt+1)] >= 127))) cnt++; |
471 | len -= cnt; |
472 | |
473 | if (!len) return -EINVAL; |
474 | |
475 | LOCK_TAKE(cptr->hdw->big_lock); do { |
476 | if (cptr->info->type == pvr2_ctl_int) { |
477 | ret = parse_token(ptr,len,valptr,NULL,namecnt: 0); |
478 | if (ret >= 0) { |
479 | ret = pvr2_ctrl_range_check(cptr,val: *valptr); |
480 | } |
481 | *maskptr = ~0; |
482 | } else if (cptr->info->type == pvr2_ctl_bool) { |
483 | ret = parse_token(ptr,len,valptr,names: boolNames, |
484 | ARRAY_SIZE(boolNames)); |
485 | if (ret == 1) { |
486 | *valptr = *valptr ? !0 : 0; |
487 | } else if (ret == 0) { |
488 | *valptr = (*valptr & 1) ? !0 : 0; |
489 | } |
490 | *maskptr = 1; |
491 | } else if (cptr->info->type == pvr2_ctl_enum) { |
492 | ret = parse_token( |
493 | ptr,len,valptr, |
494 | names: cptr->info->def.type_enum.value_names, |
495 | namecnt: cptr->info->def.type_enum.count); |
496 | if (ret >= 0) { |
497 | ret = pvr2_ctrl_range_check(cptr,val: *valptr); |
498 | } |
499 | *maskptr = ~0; |
500 | } else if (cptr->info->type == pvr2_ctl_bitmask) { |
501 | ret = parse_tlist( |
502 | ptr,len,maskptr,valptr, |
503 | names: cptr->info->def.type_bitmask.bit_names, |
504 | valid_bits: cptr->info->def.type_bitmask.valid_bits); |
505 | } |
506 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
507 | return ret; |
508 | } |
509 | |
510 | |
511 | /* Convert a given mask/val to a symbolic value */ |
512 | int pvr2_ctrl_value_to_sym_internal(struct pvr2_ctrl *cptr, |
513 | int mask,int val, |
514 | char *buf,unsigned int maxlen, |
515 | unsigned int *len) |
516 | { |
517 | int ret = -EINVAL; |
518 | |
519 | *len = 0; |
520 | if (cptr->info->type == pvr2_ctl_int) { |
521 | *len = scnprintf(buf,size: maxlen,fmt: "%d" ,val); |
522 | ret = 0; |
523 | } else if (cptr->info->type == pvr2_ctl_bool) { |
524 | *len = scnprintf(buf,size: maxlen,fmt: "%s" ,val ? "true" : "false" ); |
525 | ret = 0; |
526 | } else if (cptr->info->type == pvr2_ctl_enum) { |
527 | const char * const *names; |
528 | names = cptr->info->def.type_enum.value_names; |
529 | if ((val >= 0) && |
530 | (val < cptr->info->def.type_enum.count)) { |
531 | if (names[val]) { |
532 | *len = scnprintf( |
533 | buf,size: maxlen,fmt: "%s" , |
534 | names[val]); |
535 | } else { |
536 | *len = 0; |
537 | } |
538 | ret = 0; |
539 | } |
540 | } else if (cptr->info->type == pvr2_ctl_bitmask) { |
541 | *len = gen_bitmask_string( |
542 | msk: val & mask & cptr->info->def.type_bitmask.valid_bits, |
543 | val: ~0,msk_only: !0, |
544 | names: cptr->info->def.type_bitmask.bit_names, |
545 | ptr: buf,len: maxlen); |
546 | } |
547 | return ret; |
548 | } |
549 | |
550 | |
551 | /* Convert a given mask/val to a symbolic value */ |
552 | int pvr2_ctrl_value_to_sym(struct pvr2_ctrl *cptr, |
553 | int mask,int val, |
554 | char *buf,unsigned int maxlen, |
555 | unsigned int *len) |
556 | { |
557 | int ret; |
558 | LOCK_TAKE(cptr->hdw->big_lock); do { |
559 | ret = pvr2_ctrl_value_to_sym_internal(cptr,mask,val, |
560 | buf,maxlen,len); |
561 | } while(0); LOCK_GIVE(cptr->hdw->big_lock); |
562 | return ret; |
563 | } |
564 | |