LXR linux/drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

   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
  14static 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. */
  39int pvr2_ctrl_set_value(struct pvr2_ctrl *cptr,int val)
  40{
  41        return pvr2_ctrl_set_mask_value(cptr,~0,val);
  42}
  43
  44
  45/* Set/clear specific bits of the given control. */
  46int 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. */
  71int 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 */
  83enum 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) */
  91int 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) */
 107int 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) */
 123int 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) */
 139int 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) */
 153int 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 */
 167const 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 */
 175const 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 */
 183int 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                                                bptr,bmax,"%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(bptr,bmax,"%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 */
 225int pvr2_ctrl_get_v4lid(struct pvr2_ctrl *cptr)
 226{
 227        if (!cptr) return 0;
 228        return cptr->info->v4l_id;
 229}
 230
 231
 232unsigned 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 */
 251int 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 */
 259int 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 */
 269int 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 */
 281int 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
 291static 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(ptr,len,"%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(ptr,len,"%s0x%lx",
 324                                        (spcFl ? " " : ""),
 325                                        um);
 326                        ptr += cnt; len -= cnt; uc += cnt;
 327                        spcFl = !0;
 328                } else if (um & val) {
 329                        cnt = scnprintf(ptr,len,"%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(ptr,len,"%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
 346static const char *boolNames[] = {
 347        "false",
 348        "true",
 349        "no",
 350        "yes",
 351};
 352
 353
 354static int parse_token(const char *ptr,unsigned int len,
 355                       int *valptr,
 356                       const char * const *names, unsigned int namecnt)
 357{
 358        char buf[33];
 359        unsigned int slen;
 360        unsigned int idx;
 361        int negfl;
 362        char *p2;
 363        *valptr = 0;
 364        if (!names) namecnt = 0;
 365        for (idx = 0; idx < namecnt; idx++) {
 366                if (!names[idx]) continue;
 367                slen = strlen(names[idx]);
 368                if (slen != len) continue;
 369                if (memcmp(names[idx],ptr,slen)) continue;
 370                *valptr = idx;
 371                return 0;
 372        }
 373        negfl = 0;
 374        if ((*ptr == '-') || (*ptr == '+')) {
 375                negfl = (*ptr == '-');
 376                ptr++; len--;
 377        }
 378        if (len >= sizeof(buf)) return -EINVAL;
 379        memcpy(buf,ptr,len);
 380        buf[len] = 0;
 381        *valptr = simple_strtol(buf,&p2,0);
 382        if (negfl) *valptr = -(*valptr);
 383        if (*p2) return -EINVAL;
 384        return 1;
 385}
 386
 387
 388static int parse_mtoken(const char *ptr,unsigned int len,
 389                        int *valptr,
 390                        const char **names,int valid_bits)
 391{
 392        char buf[33];
 393        unsigned int slen;
 394        unsigned int idx;
 395        char *p2;
 396        int msk;
 397        *valptr = 0;
 398        for (idx = 0, msk = 1; valid_bits; idx++, msk <<= 1) {
 399                if (!(msk & valid_bits)) continue;
 400                valid_bits &= ~msk;
 401                if (!names[idx]) continue;
 402                slen = strlen(names[idx]);
 403                if (slen != len) continue;
 404                if (memcmp(names[idx],ptr,slen)) continue;
 405                *valptr = msk;
 406                return 0;
 407        }
 408        if (len >= sizeof(buf)) return -EINVAL;
 409        memcpy(buf,ptr,len);
 410        buf[len] = 0;
 411        *valptr = simple_strtol(buf,&p2,0);
 412        if (*p2) return -EINVAL;
 413        return 0;
 414}
 415
 416
 417static int parse_tlist(const char *ptr,unsigned int len,
 418                       int *maskptr,int *valptr,
 419                       const char **names,int valid_bits)
 420{
 421        unsigned int cnt;
 422        int mask,val,kv,mode,ret;
 423        mask = 0;
 424        val = 0;
 425        ret = 0;
 426        while (len) {
 427                cnt = 0;
 428                while ((cnt < len) &&
 429                       ((ptr[cnt] <= 32) ||
 430                        (ptr[cnt] >= 127))) cnt++;
 431                ptr += cnt;
 432                len -= cnt;
 433                mode = 0;
 434                if ((*ptr == '-') || (*ptr == '+')) {
 435                        mode = (*ptr == '-') ? -1 : 1;
 436                        ptr++;
 437                        len--;
 438                }
 439                cnt = 0;
 440                while (cnt < len) {
 441                        if (ptr[cnt] <= 32) break;
 442                        if (ptr[cnt] >= 127) break;
 443                        cnt++;
 444                }
 445                if (!cnt) break;
 446                if (parse_mtoken(ptr,cnt,&kv,names,valid_bits)) {
 447                        ret = -EINVAL;
 448                        break;
 449                }
 450                ptr += cnt;
 451                len -= cnt;
 452                switch (mode) {
 453                case 0:
 454                        mask = valid_bits;
 455                        val |= kv;
 456                        break;
 457                case -1:
 458                        mask |= kv;
 459                        val &= ~kv;
 460                        break;
 461                case 1:
 462                        mask |= kv;
 463                        val |= kv;
 464                        break;
 465                default:
 466                        break;
 467                }
 468        }
 469        *maskptr = mask;
 470        *valptr = val;
 471        return ret;
 472}
 473
 474
 475/* Convert a symbolic value to a mask/value pair */
 476int pvr2_ctrl_sym_to_value(struct pvr2_ctrl *cptr,
 477                           const char *ptr,unsigned int len,
 478                           int *maskptr,int *valptr)
 479{
 480        int ret = -EINVAL;
 481        unsigned int cnt;
 482
 483        *maskptr = 0;
 484        *valptr = 0;
 485
 486        cnt = 0;
 487        while ((cnt < len) && ((ptr[cnt] <= 32) || (ptr[cnt] >= 127))) cnt++;
 488        len -= cnt; ptr += cnt;
 489        cnt = 0;
 490        while ((cnt < len) && ((ptr[len-(cnt+1)] <= 32) ||
 491                               (ptr[len-(cnt+1)] >= 127))) cnt++;
 492        len -= cnt;
 493
 494        if (!len) return -EINVAL;
 495
 496        LOCK_TAKE(cptr->hdw->big_lock); do {
 497                if (cptr->info->type == pvr2_ctl_int) {
 498                        ret = parse_token(ptr,len,valptr,NULL,0);
 499                        if (ret >= 0) {
 500                                ret = pvr2_ctrl_range_check(cptr,*valptr);
 501                        }
 502                        *maskptr = ~0;
 503                } else if (cptr->info->type == pvr2_ctl_bool) {
 504                        ret = parse_token(ptr,len,valptr,boolNames,
 505                                          ARRAY_SIZE(boolNames));
 506                        if (ret == 1) {
 507                                *valptr = *valptr ? !0 : 0;
 508                        } else if (ret == 0) {
 509                                *valptr = (*valptr & 1) ? !0 : 0;
 510                        }
 511                        *maskptr = 1;
 512                } else if (cptr->info->type == pvr2_ctl_enum) {
 513                        ret = parse_token(
 514                                ptr,len,valptr,
 515                                cptr->info->def.type_enum.value_names,
 516                                cptr->info->def.type_enum.count);
 517                        if (ret >= 0) {
 518                                ret = pvr2_ctrl_range_check(cptr,*valptr);
 519                        }
 520                        *maskptr = ~0;
 521                } else if (cptr->info->type == pvr2_ctl_bitmask) {
 522                        ret = parse_tlist(
 523                                ptr,len,maskptr,valptr,
 524                                cptr->info->def.type_bitmask.bit_names,
 525                                cptr->info->def.type_bitmask.valid_bits);
 526                }
 527        } while(0); LOCK_GIVE(cptr->hdw->big_lock);
 528        return ret;
 529}
 530
 531
 532/* Convert a given mask/val to a symbolic value */
 533int pvr2_ctrl_value_to_sym_internal(struct pvr2_ctrl *cptr,
 534                                    int mask,int val,
 535                                    char *buf,unsigned int maxlen,
 536                                    unsigned int *len)
 537{
 538        int ret = -EINVAL;
 539
 540        *len = 0;
 541        if (cptr->info->type == pvr2_ctl_int) {
 542                *len = scnprintf(buf,maxlen,"%d",val);
 543                ret = 0;
 544        } else if (cptr->info->type == pvr2_ctl_bool) {
 545                *len = scnprintf(buf,maxlen,"%s",val ? "true" : "false");
 546                ret = 0;
 547        } else if (cptr->info->type == pvr2_ctl_enum) {
 548                const char * const *names;
 549                names = cptr->info->def.type_enum.value_names;
 550                if ((val >= 0) &&
 551                    (val < cptr->info->def.type_enum.count)) {
 552                        if (names[val]) {
 553                                *len = scnprintf(
 554                                        buf,maxlen,"%s",
 555                                        names[val]);
 556                        } else {
 557                                *len = 0;
 558                        }
 559                        ret = 0;
 560                }
 561        } else if (cptr->info->type == pvr2_ctl_bitmask) {
 562                *len = gen_bitmask_string(
 563                        val & mask & cptr->info->def.type_bitmask.valid_bits,
 564                        ~0,!0,
 565                        cptr->info->def.type_bitmask.bit_names,
 566                        buf,maxlen);
 567        }
 568        return ret;
 569}
 570
 571
 572/* Convert a given mask/val to a symbolic value */
 573int pvr2_ctrl_value_to_sym(struct pvr2_ctrl *cptr,
 574                           int mask,int val,
 575                           char *buf,unsigned int maxlen,
 576                           unsigned int *len)
 577{
 578        int ret;
 579        LOCK_TAKE(cptr->hdw->big_lock); do {
 580                ret = pvr2_ctrl_value_to_sym_internal(cptr,mask,val,
 581                                                      buf,maxlen,len);
 582        } while(0); LOCK_GIVE(cptr->hdw->big_lock);
 583        return ret;
 584}
 585