Lines Matching refs:cval
274 static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
276 switch (cval->val_type) {
304 static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
306 switch (cval->val_type) {
321 static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
323 if (! cval->res)
324 cval->res = 1;
325 if (val < cval->min)
327 else if (val >= cval->max)
328 return (cval->max - cval->min + cval->res - 1) / cval->res;
330 return (val - cval->min) / cval->res;
333 static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
336 return cval->min;
337 if (! cval->res)
338 cval->res = 1;
339 val *= cval->res;
340 val += cval->min;
341 if (val > cval->max)
342 return cval->max;
351 static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
354 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
358 if (snd_usb_ctl_msg(cval->mixer->chip->dev,
359 usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
362 validx, cval->mixer->ctrlif | (cval->id << 8),
364 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
369 request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
373 static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
375 return get_ctl_value(cval, GET_CUR, validx, value);
379 static inline int get_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int *value)
381 return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value);
388 static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int value_set)
391 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
394 value_set = convert_bytes_value(cval, value_set);
398 if (snd_usb_ctl_msg(cval->mixer->chip->dev,
399 usb_sndctrlpipe(cval->mixer->chip->dev, 0),
402 validx, cval->mixer->ctrlif | (cval->id << 8),
406 request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type, buf[0], buf[1]);
410 static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
412 return set_ctl_value(cval, SET_CUR, validx, value);
415 static inline int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int value)
417 return set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel, value);
426 struct usb_mixer_elem_info *cval = kcontrol->private_data;
434 scale[2] = (convert_signed_value(cval, cval->min) * 100) / 256;
435 scale[3] = (convert_signed_value(cval, cval->res) * 100) / 256;
468 struct usb_mixer_elem_info *cval = kctl->private_data;
477 cval->elem_id = &kctl->id;
478 cval->next_id_elem = state->mixer->id_elems[cval->id];
479 state->mixer->id_elems[cval->id] = cval;
670 static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
673 cval->min = default_min;
674 cval->max = cval->min + 1;
675 cval->res = 1;
677 if (cval->val_type == USB_MIXER_BOOLEAN ||
678 cval->val_type == USB_MIXER_INV_BOOLEAN) {
679 cval->initialized = 1;
682 if (cval->cmask) {
685 if (cval->cmask & (1 << i)) {
690 if (get_ctl_value(cval, GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
691 get_ctl_value(cval, GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
693 cval->id, cval->mixer->ctrlif, cval->control, cval->id);
696 if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
697 cval->res = 1;
699 int last_valid_res = cval->res;
701 while (cval->res > 1) {
702 if (set_ctl_value(cval, SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
704 cval->res /= 2;
706 if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
707 cval->res = last_valid_res;
709 if (cval->res == 0)
710 cval->res = 1;
718 if (cval->min + cval->res < cval->max) {
719 int last_valid_res = cval->res;
721 get_cur_mix_value(cval, minchn, &saved);
724 if (test < cval->max)
725 test += cval->res;
727 test -= cval->res;
728 if (test < cval->min || test > cval->max ||
729 set_cur_mix_value(cval, minchn, test) ||
730 get_cur_mix_value(cval, minchn, &check)) {
731 cval->res = last_valid_res;
736 cval->res *= 2;
738 set_cur_mix_value(cval, minchn, saved);
741 cval->initialized = 1;
750 struct usb_mixer_elem_info *cval = kcontrol->private_data;
752 if (cval->val_type == USB_MIXER_BOOLEAN ||
753 cval->val_type == USB_MIXER_INV_BOOLEAN)
757 uinfo->count = cval->channels;
758 if (cval->val_type == USB_MIXER_BOOLEAN ||
759 cval->val_type == USB_MIXER_INV_BOOLEAN) {
763 if (! cval->initialized)
764 get_min_max(cval, 0);
767 (cval->max - cval->min + cval->res - 1) / cval->res;
775 struct usb_mixer_elem_info *cval = kcontrol->private_data;
778 if (cval->cmask) {
781 if (cval->cmask & (1 << c)) {
782 err = get_cur_mix_value(cval, c + 1, &val);
784 if (cval->mixer->ignore_ctl_error) {
785 ucontrol->value.integer.value[0] = cval->min;
788 snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n", cval->control, c + 1, err);
791 val = get_relative_value(cval, val);
798 err = get_cur_mix_value(cval, 0, &val);
800 if (cval->mixer->ignore_ctl_error) {
801 ucontrol->value.integer.value[0] = cval->min;
804 snd_printd(KERN_ERR "cannot get current value for control %d master ch: err = %d\n", cval->control, err);
807 val = get_relative_value(cval, val);
816 struct usb_mixer_elem_info *cval = kcontrol->private_data;
820 if (cval->cmask) {
823 if (cval->cmask & (1 << c)) {
824 err = get_cur_mix_value(cval, c + 1, &oval);
826 if (cval->mixer->ignore_ctl_error)
831 val = get_abs_value(cval, val);
833 set_cur_mix_value(cval, c + 1, val);
836 get_cur_mix_value(cval, c + 1, &val);
842 err = get_cur_mix_value(cval, 0, &oval);
843 if (err < 0 && cval->mixer->ignore_ctl_error)
848 val = get_abs_value(cval, val);
850 set_cur_mix_value(cval, 0, val);
878 struct usb_mixer_elem_info *cval;
889 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
890 if (! cval) {
894 cval->mixer = state->mixer;
895 cval->id = unitid;
896 cval->control = control;
897 cval->cmask = ctl_mask;
898 cval->val_type = audio_feature_info[control-1].type;
900 cval->channels = 1; /* master channel */
906 cval->channels = c;
910 get_min_max(cval, 0);
912 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
915 kfree(cval);
981 cval->min == -15616) {
983 cval->max = -256;
988 cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
1059 struct usb_mixer_elem_info *cval;
1068 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1069 if (! cval)
1072 cval->mixer = state->mixer;
1073 cval->id = unitid;
1074 cval->control = in_ch + 1; /* based on 1 */
1075 cval->val_type = USB_MIXER_S16;
1078 cval->cmask |= (1 << i);
1079 cval->channels++;
1084 get_min_max(cval, 0);
1086 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1089 kfree(cval);
1102 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1162 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1165 err = get_cur_ctl_value(cval, cval->control << 8, &val);
1166 if (err < 0 && cval->mixer->ignore_ctl_error) {
1167 ucontrol->value.integer.value[0] = cval->min;
1172 val = get_relative_value(cval, val);
1180 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1183 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
1185 if (cval->mixer->ignore_ctl_error)
1190 val = get_abs_value(cval, val);
1192 set_cur_ctl_value(cval, cval->control << 8, val);
1279 struct usb_mixer_elem_info *cval;
1314 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1315 if (! cval) {
1319 cval->mixer = state->mixer;
1320 cval->id = unitid;
1321 cval->control = valinfo->control;
1322 cval->val_type = valinfo->val_type;
1323 cval->channels = 1;
1326 if (type == USB_PROC_UPDOWN && cval->control == USB_PROC_UPDOWN_MODE_SEL) {
1327 cval->min = 1;
1328 cval->max = dsc[15];
1329 cval->res = 1;
1330 cval->initialized = 1;
1332 get_min_max(cval, valinfo->min_value);
1334 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
1337 kfree(cval);
1342 if (check_mapped_name(state, unitid, cval->control, kctl->id.name, sizeof(kctl->id.name)))
1358 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1386 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1392 uinfo->value.enumerated.items = cval->max;
1393 if ((int)uinfo->value.enumerated.item >= cval->max)
1394 uinfo->value.enumerated.item = cval->max - 1;
1402 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1405 err = get_cur_ctl_value(cval, 0, &val);
1407 if (cval->mixer->ignore_ctl_error) {
1413 val = get_relative_value(cval, val);
1421 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1424 err = get_cur_ctl_value(cval, 0, &oval);
1426 if (cval->mixer->ignore_ctl_error)
1431 val = get_abs_value(cval, val);
1433 set_cur_ctl_value(cval, 0, val);
1457 struct usb_mixer_elem_info *cval = kctl->private_data;
1458 num_ins = cval->max;
1459 kfree(cval);
1479 struct usb_mixer_elem_info *cval;
1499 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1500 if (! cval) {
1504 cval->mixer = state->mixer;
1505 cval->id = unitid;
1506 cval->val_type = USB_MIXER_U8;
1507 cval->channels = 1;
1508 cval->min = 1;
1509 cval->max = num_ins;
1510 cval->res = 1;
1511 cval->initialized = 1;
1516 kfree(cval);
1529 kfree(cval);
1540 kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
1544 kfree(cval);
1569 cval->id, kctl->id.name, num_ins);