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