Lines Matching refs:cval
126 #define filter_error(cval, err) \
127 ((cval)->head.mixer->ignore_ctl_error ? 0 : (err))
140 struct usb_mixer_elem_info *cval)
143 cval->dBmin = p->dB->min;
144 cval->dBmax = p->dB->max;
145 cval->initialized = 1;
203 static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
205 switch (cval->val_type) {
233 static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
235 switch (cval->val_type) {
250 static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
252 if (!cval->res)
253 cval->res = 1;
254 if (val < cval->min)
256 else if (val >= cval->max)
257 return (cval->max - cval->min + cval->res - 1) / cval->res;
259 return (val - cval->min) / cval->res;
262 static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
265 return cval->min;
266 if (!cval->res)
267 cval->res = 1;
268 val *= cval->res;
269 val += cval->min;
270 if (val > cval->max)
271 return cval->max;
300 static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request,
303 struct snd_usb_audio *chip = cval->head.mixer->chip;
305 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
314 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
319 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
328 request, validx, idx, cval->val_type);
336 static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request,
339 struct snd_usb_audio *chip = cval->head.mixer->chip;
346 val_size = uac2_ctl_value_size(cval->val_type);
362 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
372 request, validx, idx, cval->val_type);
395 *value_ret = convert_signed_value(cval,
401 static int get_ctl_value(struct usb_mixer_elem_info *cval, int request,
404 validx += cval->idx_off;
406 return (cval->head.mixer->protocol == UAC_VERSION_1) ?
407 get_ctl_value_v1(cval, request, validx, value_ret) :
408 get_ctl_value_v2(cval, request, validx, value_ret);
411 static int get_cur_ctl_value(struct usb_mixer_elem_info *cval,
414 return get_ctl_value(cval, UAC_GET_CUR, validx, value);
418 static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
421 return get_ctl_value(cval, UAC_GET_CUR,
422 (cval->control << 8) | channel,
426 int snd_usb_get_cur_mix_value(struct usb_mixer_elem_info *cval,
431 if (cval->cached & (1 << channel)) {
432 *value = cval->cache_val[index];
435 err = get_cur_mix_raw(cval, channel, value);
437 if (!cval->head.mixer->ignore_ctl_error)
438 usb_audio_dbg(cval->head.mixer->chip,
440 cval->control, channel, err);
443 cval->cached |= 1 << channel;
444 cval->cache_val[index] = *value;
452 int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
455 struct snd_usb_audio *chip = cval->head.mixer->chip;
459 validx += cval->idx_off;
462 if (cval->head.mixer->protocol == UAC_VERSION_1) {
463 val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
465 val_len = uac2_ctl_value_size(cval->val_type);
476 value_set = convert_bytes_value(cval, value_set);
487 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
500 request, validx, idx, cval->val_type, buf[0], buf[1]);
508 static int set_cur_ctl_value(struct usb_mixer_elem_info *cval,
511 return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
514 int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
519 cval->master_readonly :
520 cval->ch_readonly & (1 << (channel - 1));
523 usb_audio_dbg(cval->head.mixer->chip,
525 __func__, channel, cval->control);
529 err = snd_usb_mixer_set_ctl_value(cval,
530 UAC_SET_CUR, (cval->control << 8) | channel,
534 cval->cached |= 1 << channel;
535 cval->cache_val[index] = value;
545 struct usb_mixer_elem_info *cval = kcontrol->private_data;
550 if (cval->min_mute)
552 scale[2] = cval->dBmin;
553 scale[3] = cval->dBmax;
1061 static void usb_mixer_elem_info_free(struct usb_mixer_elem_info *cval)
1063 kfree(cval);
1078 static void volume_control_quirks(struct usb_mixer_elem_info *cval,
1081 struct snd_usb_audio *chip = cval->head.mixer->chip;
1086 cval->min = 0x0000;
1087 cval->max = 0xffff;
1088 cval->res = 0x00e6;
1093 cval->min = 0x00;
1094 cval->max = 0xff;
1098 cval->min = 0xb706;
1099 cval->max = 0xff7b;
1100 cval->res = 0x0073;
1105 cval->min = 0xb5fb; /* -73 dB = 0xb6ff */
1106 cval->max = 0xfcfe;
1107 cval->res = 0x0073;
1116 cval->min = 0x0000;
1117 cval->max = 0x7f00;
1118 cval->res = 0x0100;
1125 cval->min = 0x00;
1126 cval->max = 0x7f;
1135 cval->min = -256;
1149 cval->min == -15616) {
1152 cval->max = -256;
1160 cval->min = 6080;
1161 cval->max = 8768;
1162 cval->res = 192;
1183 "set resolution quirk: cval->res = 384\n");
1184 cval->res = 384;
1190 cval->min >>= 8;
1191 cval->max = 0;
1192 cval->res = 1;
1201 static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval,
1205 cval->min = default_min;
1206 cval->max = cval->min + 1;
1207 cval->res = 1;
1208 cval->dBmin = cval->dBmax = 0;
1210 if (cval->val_type == USB_MIXER_BOOLEAN ||
1211 cval->val_type == USB_MIXER_INV_BOOLEAN) {
1212 cval->initialized = 1;
1215 if (cval->cmask) {
1218 if (cval->cmask & (1 << i)) {
1223 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
1224 get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
1225 usb_audio_err(cval->head.mixer->chip,
1227 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1228 cval->control, cval->head.id);
1231 if (get_ctl_value(cval, UAC_GET_RES,
1232 (cval->control << 8) | minchn,
1233 &cval->res) < 0) {
1234 cval->res = 1;
1236 int last_valid_res = cval->res;
1238 while (cval->res > 1) {
1239 if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES,
1240 (cval->control << 8) | minchn,
1241 cval->res / 2) < 0)
1243 cval->res /= 2;
1245 if (get_ctl_value(cval, UAC_GET_RES,
1246 (cval->control << 8) | minchn, &cval->res) < 0)
1247 cval->res = last_valid_res;
1249 if (cval->res == 0)
1250 cval->res = 1;
1258 if (cval->min + cval->res < cval->max) {
1259 int last_valid_res = cval->res;
1261 if (get_cur_mix_raw(cval, minchn, &saved) < 0)
1265 if (test < cval->max)
1266 test += cval->res;
1268 test -= cval->res;
1269 if (test < cval->min || test > cval->max ||
1270 snd_usb_set_cur_mix_value(cval, minchn, 0, test) ||
1271 get_cur_mix_raw(cval, minchn, &check)) {
1272 cval->res = last_valid_res;
1277 cval->res *= 2;
1279 snd_usb_set_cur_mix_value(cval, minchn, 0, saved);
1283 cval->initialized = 1;
1287 volume_control_quirks(cval, kctl);
1292 cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
1293 cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
1294 if (cval->dBmin > cval->dBmax) {
1296 if (cval->dBmin < 0)
1297 cval->dBmax = 0;
1298 else if (cval->dBmin > 0)
1299 cval->dBmin = 0;
1300 if (cval->dBmin > cval->dBmax) {
1308 if (cval->dBmax <= -9600) {
1309 usb_audio_info(cval->head.mixer->chip,
1311 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1312 cval->dBmin, cval->dBmax);
1313 cval->dBmin = cval->dBmax = 0;
1320 #define get_min_max(cval, def) get_min_max_with_quirks(cval, def, NULL)
1326 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1328 if (cval->val_type == USB_MIXER_BOOLEAN ||
1329 cval->val_type == USB_MIXER_INV_BOOLEAN)
1333 uinfo->count = cval->channels;
1334 if (cval->val_type == USB_MIXER_BOOLEAN ||
1335 cval->val_type == USB_MIXER_INV_BOOLEAN) {
1339 if (!cval->initialized) {
1340 get_min_max_with_quirks(cval, 0, kcontrol);
1341 if (cval->initialized && cval->dBmin >= cval->dBmax) {
1345 snd_ctl_notify(cval->head.mixer->chip->card,
1352 (cval->max - cval->min + cval->res - 1) / cval->res;
1361 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1364 ucontrol->value.integer.value[0] = cval->min;
1365 if (cval->cmask) {
1368 if (!(cval->cmask & (1 << c)))
1370 err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &val);
1372 return filter_error(cval, err);
1373 val = get_relative_value(cval, val);
1380 err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1382 return filter_error(cval, err);
1383 val = get_relative_value(cval, val);
1393 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1397 if (cval->cmask) {
1400 if (!(cval->cmask & (1 << c)))
1402 err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &oval);
1404 return filter_error(cval, err);
1406 val = get_abs_value(cval, val);
1408 snd_usb_set_cur_mix_value(cval, c + 1, cnt, val);
1415 err = snd_usb_get_cur_mix_value(cval, 0, 0, &oval);
1417 return filter_error(cval, err);
1419 val = get_abs_value(cval, val);
1421 snd_usb_set_cur_mix_value(cval, 0, 0, val);
1432 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1435 err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1437 return filter_error(cval, err);
1447 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1448 struct snd_usb_audio *chip = cval->head.mixer->chip;
1451 validx = cval->control << 8 | 0;
1457 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
1458 if (cval->head.mixer->protocol == UAC_VERSION_2) {
1484 UAC_GET_CUR, validx, idx, cval->val_type);
1485 return filter_error(cval, ret);
1595 struct usb_mixer_elem_info *cval;
1608 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1609 if (!cval)
1611 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
1612 cval->control = control;
1613 cval->cmask = ctl_mask;
1617 usb_mixer_elem_info_free(cval);
1621 cval->val_type = ctl_info->type;
1623 cval->val_type = ctl_info->type_uac2 >= 0 ?
1627 cval->channels = 1; /* master channel */
1628 cval->master_readonly = readonly_mask;
1634 cval->channels = c;
1635 cval->ch_readonly = readonly_mask;
1643 if (cval->channels == readonly_mask)
1644 kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1646 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1650 usb_mixer_elem_info_free(cval);
1711 get_min_max_with_quirks(cval, 0, kctl);
1714 if (cval->max <= cval->min) {
1717 cval->head.id, kctl->id.name);
1724 check_mapped_dB(map, cval);
1725 if (cval->dBmin < cval->dBmax || !cval->initialized) {
1733 snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl);
1735 range = (cval->max - cval->min) / cval->res;
1743 "Warning! Unlikely big volume range (=%u), cval->res is probably wrong.",
1747 cval->head.id, kctl->id.name, cval->channels,
1748 cval->min, cval->max, cval->res);
1752 cval->head.id, kctl->id.name, cval->channels,
1753 cval->min, cval->max, cval->res);
1754 snd_usb_mixer_add_control(&cval->head, kctl);
1803 struct usb_mixer_elem_info *cval;
1810 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1811 if (!cval)
1813 snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id);
1825 cval->control = UAC2_TE_CONNECTOR;
1827 cval->control = UAC3_TE_INSERTION;
1829 cval->val_type = USB_MIXER_BOOLEAN;
1830 cval->channels = 1; /* report true if any channel is connected */
1831 cval->min = 0;
1832 cval->max = 1;
1833 kctl = snd_ctl_new1(&usb_connector_ctl_ro, cval);
1836 usb_mixer_elem_info_free(cval);
1846 snd_usb_mixer_add_control(&cval->head, kctl);
1853 struct usb_mixer_elem_info *cval;
1869 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1870 if (!cval)
1873 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID);
1875 cval->min = 0;
1876 cval->max = 1;
1877 cval->channels = 1;
1878 cval->val_type = USB_MIXER_BOOLEAN;
1879 cval->control = UAC2_CS_CONTROL_CLOCK_VALID;
1881 cval->master_readonly = 1;
1883 kctl = snd_ctl_new1(&usb_bool_master_control_ctl_ro, cval);
1886 usb_mixer_elem_info_free(cval);
1900 return snd_usb_mixer_add_control(&cval->head, kctl);
2075 struct usb_mixer_elem_info *cval;
2084 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2085 if (!cval)
2088 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2089 cval->control = in_ch + 1; /* based on 1 */
2090 cval->val_type = USB_MIXER_S16;
2095 cval->cmask |= (1 << i);
2096 cval->channels++;
2101 get_min_max(cval, 0);
2103 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
2106 usb_mixer_elem_info_free(cval);
2120 cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max);
2121 snd_usb_mixer_add_control(&cval->head, kctl);
2220 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2223 err = get_cur_ctl_value(cval, cval->control << 8, &val);
2225 ucontrol->value.integer.value[0] = cval->min;
2226 return filter_error(cval, err);
2228 val = get_relative_value(cval, val);
2237 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2240 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
2242 return filter_error(cval, err);
2244 val = get_abs_value(cval, val);
2246 set_cur_ctl_value(cval, cval->control << 8, val);
2383 struct usb_mixer_elem_info *cval;
2429 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2430 if (!cval)
2432 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2433 cval->control = valinfo->control;
2434 cval->val_type = valinfo->val_type;
2435 cval->channels = 1;
2440 cval->master_readonly = 1;
2451 if (cval->control == UAC_UD_MODE_SELECT)
2455 if (cval->control == UAC3_UD_MODE_SELECT)
2463 cval->min = 1;
2464 cval->max = control_spec[0];
2465 cval->res = 1;
2466 cval->initialized = 1;
2470 get_min_max(cval, valinfo->min_value);
2478 cval->min = 0;
2479 cval->max = 5;
2480 cval->res = 1;
2481 cval->initialized = 1;
2484 get_min_max(cval, valinfo->min_value);
2488 err = get_cur_ctl_value(cval, cval->control << 8, &val);
2490 usb_mixer_elem_info_free(cval);
2494 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
2496 usb_mixer_elem_info_free(cval);
2524 cval->head.id, kctl->id.name, cval->channels,
2525 cval->min, cval->max);
2527 err = snd_usb_mixer_add_control(&cval->head, kctl);
2570 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2575 return snd_ctl_enum_info(uinfo, 1, cval->max, itemlist);
2582 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2585 err = get_cur_ctl_value(cval, cval->control << 8, &val);
2588 return filter_error(cval, err);
2590 val = get_relative_value(cval, val);
2599 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2602 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
2604 return filter_error(cval, err);
2606 val = get_abs_value(cval, val);
2608 set_cur_ctl_value(cval, cval->control << 8, val);
2632 struct usb_mixer_elem_info *cval = kctl->private_data;
2633 num_ins = cval->max;
2634 usb_mixer_elem_info_free(cval);
2655 struct usb_mixer_elem_info *cval;
2673 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2674 if (!cval)
2676 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2677 cval->val_type = USB_MIXER_U8;
2678 cval->channels = 1;
2679 cval->min = 1;
2680 cval->max = desc->bNrInPins;
2681 cval->res = 1;
2682 cval->initialized = 1;
2687 cval->control = 0;
2693 cval->control = UAC2_CX_CLOCK_SELECTOR;
2695 cval->control = UAC2_SU_SELECTOR;
2722 kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
2770 cval->head.id, kctl->id.name, desc->bNrInPins);
2771 return snd_usb_mixer_add_control(&cval->head, kctl);
2778 usb_mixer_elem_info_free(cval);
3275 struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3288 "channels=%i, type=\"%s\"\n", cval->head.id,
3289 cval->control, cval->cmask, cval->channels,
3290 val_types[cval->val_type]);
3292 cval->min, cval->max, cval->dBmin, cval->dBmax);
3639 struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3642 if (cval->val_type == USB_MIXER_BESPOKEN)
3645 if (cval->cmask) {
3648 if (!(cval->cmask & (1 << c)))
3650 if (cval->cached & (1 << (c + 1))) {
3651 err = snd_usb_set_cur_mix_value(cval, c + 1, idx,
3652 cval->cache_val[idx]);
3660 if (cval->cached) {
3661 err = snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);