Lines Matching refs:cval
129 #define filter_error(cval, err) \
130 ((cval)->head.mixer->ignore_ctl_error ? 0 : (err))
143 struct usb_mixer_elem_info *cval)
146 cval->dBmin = p->dB->min;
147 cval->dBmax = p->dB->max;
148 cval->min_mute = p->dB->min_mute;
149 cval->initialized = 1;
210 static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
212 switch (cval->val_type) {
240 static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
242 switch (cval->val_type) {
257 static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
259 if (!cval->res)
260 cval->res = 1;
261 if (val < cval->min)
263 else if (val >= cval->max)
264 return DIV_ROUND_UP(cval->max - cval->min, cval->res);
266 return (val - cval->min) / cval->res;
269 static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
272 return cval->min;
273 if (!cval->res)
274 cval->res = 1;
275 val *= cval->res;
276 val += cval->min;
277 if (val > cval->max)
278 return cval->max;
307 static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request,
310 struct snd_usb_audio *chip = cval->head.mixer->chip;
312 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
321 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
326 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
335 request, validx, idx, cval->val_type);
343 static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request,
346 struct snd_usb_audio *chip = cval->head.mixer->chip;
353 val_size = uac2_ctl_value_size(cval->val_type);
368 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
377 request, validx, idx, cval->val_type);
400 *value_ret = convert_signed_value(cval,
406 static int get_ctl_value(struct usb_mixer_elem_info *cval, int request,
409 validx += cval->idx_off;
411 return (cval->head.mixer->protocol == UAC_VERSION_1) ?
412 get_ctl_value_v1(cval, request, validx, value_ret) :
413 get_ctl_value_v2(cval, request, validx, value_ret);
416 static int get_cur_ctl_value(struct usb_mixer_elem_info *cval,
419 return get_ctl_value(cval, UAC_GET_CUR, validx, value);
423 static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
426 return get_ctl_value(cval, UAC_GET_CUR,
427 (cval->control << 8) | channel,
431 int snd_usb_get_cur_mix_value(struct usb_mixer_elem_info *cval,
436 if (cval->cached & (1 << channel)) {
437 *value = cval->cache_val[index];
440 err = get_cur_mix_raw(cval, channel, value);
442 if (!cval->head.mixer->ignore_ctl_error)
443 usb_audio_dbg(cval->head.mixer->chip,
445 cval->control, channel, err);
448 cval->cached |= 1 << channel;
449 cval->cache_val[index] = *value;
457 int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
460 struct snd_usb_audio *chip = cval->head.mixer->chip;
464 validx += cval->idx_off;
467 if (cval->head.mixer->protocol == UAC_VERSION_1) {
468 val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
470 val_len = uac2_ctl_value_size(cval->val_type);
481 value_set = convert_bytes_value(cval, value_set);
492 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
505 request, validx, idx, cval->val_type, buf[0], buf[1]);
513 static int set_cur_ctl_value(struct usb_mixer_elem_info *cval,
516 return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
519 int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
524 cval->master_readonly :
525 cval->ch_readonly & (1 << (channel - 1));
528 usb_audio_dbg(cval->head.mixer->chip,
530 __func__, channel, cval->control);
534 err = snd_usb_mixer_set_ctl_value(cval,
535 UAC_SET_CUR, (cval->control << 8) | channel,
539 cval->cached |= 1 << channel;
540 cval->cache_val[index] = value;
550 struct usb_mixer_elem_info *cval = kcontrol->private_data;
555 if (cval->min_mute)
557 scale[2] = cval->dBmin;
558 scale[3] = cval->dBmax;
1066 static void usb_mixer_elem_info_free(struct usb_mixer_elem_info *cval)
1068 kfree(cval);
1083 static void volume_control_quirks(struct usb_mixer_elem_info *cval,
1086 struct snd_usb_audio *chip = cval->head.mixer->chip;
1091 cval->min = 0x0000;
1092 cval->max = 0xffff;
1093 cval->res = 0x00e6;
1098 cval->min = 0x00;
1099 cval->max = 0xff;
1103 cval->min = 0xb706;
1104 cval->max = 0xff7b;
1105 cval->res = 0x0073;
1110 cval->min = 0xb5fb; /* -73 dB = 0xb6ff */
1111 cval->max = 0xfcfe;
1112 cval->res = 0x0073;
1121 cval->min = 0x0000;
1122 cval->max = 0x7f00;
1123 cval->res = 0x0100;
1130 cval->min = 0x00;
1131 cval->max = 0x7f;
1140 cval->min = -256;
1154 cval->min == -15616) {
1157 cval->max = -256;
1165 cval->min = 6080;
1166 cval->max = 8768;
1167 cval->res = 192;
1188 "set resolution quirk: cval->res = 384\n");
1189 cval->res = 384;
1195 cval->min >>= 8;
1196 cval->max = 0;
1197 cval->res = 1;
1203 "set resolution quirk: cval->res = 16\n");
1204 cval->res = 16;
1210 "set resolution quirk: cval->res = 16\n");
1211 cval->res = 16;
1220 static void init_cur_mix_raw(struct usb_mixer_elem_info *cval, int ch, int idx)
1224 err = snd_usb_get_cur_mix_value(cval, ch, idx, &val);
1227 if (!cval->head.mixer->ignore_ctl_error)
1228 usb_audio_warn(cval->head.mixer->chip,
1230 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1232 snd_usb_set_cur_mix_value(cval, ch, idx, cval->min);
1238 static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval,
1244 cval->min = default_min;
1245 cval->max = cval->min + 1;
1246 cval->res = 1;
1247 cval->dBmin = cval->dBmax = 0;
1249 if (cval->val_type == USB_MIXER_BOOLEAN ||
1250 cval->val_type == USB_MIXER_INV_BOOLEAN) {
1251 cval->initialized = 1;
1254 if (cval->cmask) {
1256 if (cval->cmask & (1 << i)) {
1261 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
1262 get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
1263 usb_audio_err(cval->head.mixer->chip,
1265 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1266 cval->control, cval->head.id);
1269 if (get_ctl_value(cval, UAC_GET_RES,
1270 (cval->control << 8) | minchn,
1271 &cval->res) < 0) {
1272 cval->res = 1;
1273 } else if (cval->head.mixer->protocol == UAC_VERSION_1) {
1274 int last_valid_res = cval->res;
1276 while (cval->res > 1) {
1277 if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES,
1278 (cval->control << 8) | minchn,
1279 cval->res / 2) < 0)
1281 cval->res /= 2;
1283 if (get_ctl_value(cval, UAC_GET_RES,
1284 (cval->control << 8) | minchn, &cval->res) < 0)
1285 cval->res = last_valid_res;
1287 if (cval->res == 0)
1288 cval->res = 1;
1296 if (cval->min + cval->res < cval->max) {
1297 int last_valid_res = cval->res;
1299 if (get_cur_mix_raw(cval, minchn, &saved) < 0)
1303 if (test < cval->max)
1304 test += cval->res;
1306 test -= cval->res;
1307 if (test < cval->min || test > cval->max ||
1308 snd_usb_set_cur_mix_value(cval, minchn, 0, test) ||
1309 get_cur_mix_raw(cval, minchn, &check)) {
1310 cval->res = last_valid_res;
1315 cval->res *= 2;
1317 snd_usb_set_cur_mix_value(cval, minchn, 0, saved);
1321 cval->initialized = 1;
1325 volume_control_quirks(cval, kctl);
1330 cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
1331 cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
1332 if (cval->dBmin > cval->dBmax) {
1334 if (cval->dBmin < 0)
1335 cval->dBmax = 0;
1336 else if (cval->dBmin > 0)
1337 cval->dBmin = 0;
1338 if (cval->dBmin > cval->dBmax) {
1346 if (cval->dBmax <= -9600) {
1347 usb_audio_info(cval->head.mixer->chip,
1349 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1350 cval->dBmin, cval->dBmax);
1351 cval->dBmin = cval->dBmax = 0;
1356 if (!cval->cmask) {
1357 init_cur_mix_raw(cval, 0, 0);
1361 if (cval->cmask & (1 << i)) {
1362 init_cur_mix_raw(cval, i + 1, idx);
1371 #define get_min_max(cval, def) get_min_max_with_quirks(cval, def, NULL)
1377 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1379 if (cval->val_type == USB_MIXER_BOOLEAN ||
1380 cval->val_type == USB_MIXER_INV_BOOLEAN)
1384 uinfo->count = cval->channels;
1385 if (cval->val_type == USB_MIXER_BOOLEAN ||
1386 cval->val_type == USB_MIXER_INV_BOOLEAN) {
1390 if (!cval->initialized) {
1391 get_min_max_with_quirks(cval, 0, kcontrol);
1392 if (cval->initialized && cval->dBmin >= cval->dBmax) {
1396 snd_ctl_notify(cval->head.mixer->chip->card,
1403 DIV_ROUND_UP(cval->max - cval->min, cval->res);
1412 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1415 ucontrol->value.integer.value[0] = cval->min;
1416 if (cval->cmask) {
1419 if (!(cval->cmask & (1 << c)))
1421 err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &val);
1423 return filter_error(cval, err);
1424 val = get_relative_value(cval, val);
1431 err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1433 return filter_error(cval, err);
1434 val = get_relative_value(cval, val);
1444 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1448 if (cval->cmask) {
1451 if (!(cval->cmask & (1 << c)))
1453 err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &oval);
1455 return filter_error(cval, err);
1457 val = get_abs_value(cval, val);
1459 snd_usb_set_cur_mix_value(cval, c + 1, cnt, val);
1466 err = snd_usb_get_cur_mix_value(cval, 0, 0, &oval);
1468 return filter_error(cval, err);
1470 val = get_abs_value(cval, val);
1472 snd_usb_set_cur_mix_value(cval, 0, 0, val);
1483 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1486 err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1488 return filter_error(cval, err);
1494 static int get_connector_value(struct usb_mixer_elem_info *cval,
1497 struct snd_usb_audio *chip = cval->head.mixer->chip;
1500 validx = cval->control << 8 | 0;
1506 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
1507 if (cval->head.mixer->protocol == UAC_VERSION_2) {
1536 UAC_GET_CUR, validx, idx, cval->val_type);
1541 return filter_error(cval, ret);
1551 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1554 ret = get_connector_value(cval, kcontrol->id.name, &val);
1666 struct usb_mixer_elem_info *cval;
1679 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1680 if (!cval)
1682 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
1683 cval->control = control;
1684 cval->cmask = ctl_mask;
1688 usb_mixer_elem_info_free(cval);
1692 cval->val_type = ctl_info->type;
1694 cval->val_type = ctl_info->type_uac2 >= 0 ?
1698 cval->channels = 1; /* master channel */
1699 cval->master_readonly = readonly_mask;
1705 cval->channels = c;
1706 cval->ch_readonly = readonly_mask;
1714 if (cval->channels == readonly_mask)
1715 kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1717 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1721 usb_mixer_elem_info_free(cval);
1782 get_min_max_with_quirks(cval, 0, kctl);
1785 if (cval->max <= cval->min) {
1788 cval->head.id, kctl->id.name);
1795 check_mapped_dB(map, cval);
1796 if (cval->dBmin < cval->dBmax || !cval->initialized) {
1804 snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl);
1806 range = (cval->max - cval->min) / cval->res;
1814 "Warning! Unlikely big volume range (=%u), cval->res is probably wrong.",
1818 cval->head.id, kctl->id.name, cval->channels,
1819 cval->min, cval->max, cval->res);
1823 cval->head.id, kctl->id.name, cval->channels,
1824 cval->min, cval->max, cval->res);
1825 snd_usb_mixer_add_control(&cval->head, kctl);
1871 struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
1873 get_connector_value(cval, NULL, NULL);
1883 struct usb_mixer_elem_info *cval;
1890 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1891 if (!cval)
1893 snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id);
1896 cval->head.resume = connector_mixer_resume;
1909 cval->control = UAC2_TE_CONNECTOR;
1911 cval->control = UAC3_TE_INSERTION;
1913 cval->val_type = USB_MIXER_BOOLEAN;
1914 cval->channels = 1; /* report true if any channel is connected */
1915 cval->min = 0;
1916 cval->max = 1;
1917 kctl = snd_ctl_new1(&usb_connector_ctl_ro, cval);
1920 usb_mixer_elem_info_free(cval);
1930 snd_usb_mixer_add_control(&cval->head, kctl);
1937 struct usb_mixer_elem_info *cval;
1952 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1953 if (!cval)
1956 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID);
1958 cval->min = 0;
1959 cval->max = 1;
1960 cval->channels = 1;
1961 cval->val_type = USB_MIXER_BOOLEAN;
1962 cval->control = UAC2_CS_CONTROL_CLOCK_VALID;
1964 cval->master_readonly = 1;
1966 kctl = snd_ctl_new1(&usb_bool_master_control_ctl_ro, cval);
1969 usb_mixer_elem_info_free(cval);
1982 return snd_usb_mixer_add_control(&cval->head, kctl);
2157 struct usb_mixer_elem_info *cval;
2166 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2167 if (!cval)
2170 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2171 cval->control = in_ch + 1; /* based on 1 */
2172 cval->val_type = USB_MIXER_S16;
2177 cval->cmask |= (1 << i);
2178 cval->channels++;
2183 get_min_max(cval, 0);
2185 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
2188 usb_mixer_elem_info_free(cval);
2202 cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max);
2203 snd_usb_mixer_add_control(&cval->head, kctl);
2302 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2305 err = get_cur_ctl_value(cval, cval->control << 8, &val);
2307 ucontrol->value.integer.value[0] = cval->min;
2308 return filter_error(cval, err);
2310 val = get_relative_value(cval, val);
2319 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2322 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
2324 return filter_error(cval, err);
2326 val = get_abs_value(cval, val);
2328 set_cur_ctl_value(cval, cval->control << 8, val);
2465 struct usb_mixer_elem_info *cval;
2511 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2512 if (!cval)
2514 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2515 cval->control = valinfo->control;
2516 cval->val_type = valinfo->val_type;
2517 cval->channels = 1;
2522 cval->master_readonly = 1;
2533 if (cval->control == UAC_UD_MODE_SELECT)
2537 if (cval->control == UAC3_UD_MODE_SELECT)
2545 cval->min = 1;
2546 cval->max = control_spec[0];
2547 cval->res = 1;
2548 cval->initialized = 1;
2552 get_min_max(cval, valinfo->min_value);
2560 cval->min = 0;
2561 cval->max = 5;
2562 cval->res = 1;
2563 cval->initialized = 1;
2566 get_min_max(cval, valinfo->min_value);
2570 err = get_cur_ctl_value(cval, cval->control << 8, &val);
2572 usb_mixer_elem_info_free(cval);
2576 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
2578 usb_mixer_elem_info_free(cval);
2606 cval->head.id, kctl->id.name, cval->channels,
2607 cval->min, cval->max);
2609 err = snd_usb_mixer_add_control(&cval->head, kctl);
2652 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2657 return snd_ctl_enum_info(uinfo, 1, cval->max, itemlist);
2664 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2667 err = get_cur_ctl_value(cval, cval->control << 8, &val);
2670 return filter_error(cval, err);
2672 val = get_relative_value(cval, val);
2681 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2684 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
2686 return filter_error(cval, err);
2688 val = get_abs_value(cval, val);
2690 set_cur_ctl_value(cval, cval->control << 8, val);
2714 struct usb_mixer_elem_info *cval = kctl->private_data;
2715 num_ins = cval->max;
2716 usb_mixer_elem_info_free(cval);
2737 struct usb_mixer_elem_info *cval;
2755 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2756 if (!cval)
2758 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2759 cval->val_type = USB_MIXER_U8;
2760 cval->channels = 1;
2761 cval->min = 1;
2762 cval->max = desc->bNrInPins;
2763 cval->res = 1;
2764 cval->initialized = 1;
2769 cval->control = 0;
2775 cval->control = UAC2_CX_CLOCK_SELECTOR;
2777 cval->control = UAC2_SU_SELECTOR;
2803 kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
2851 cval->head.id, kctl->id.name, desc->bNrInPins);
2852 return snd_usb_mixer_add_control(&cval->head, kctl);
2859 usb_mixer_elem_info_free(cval);
3355 struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3368 "channels=%i, type=\"%s\"\n", cval->head.id,
3369 cval->control, cval->cmask, cval->channels,
3370 val_types[cval->val_type]);
3372 cval->min, cval->max, cval->dBmin, cval->dBmax);
3671 struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3674 if (cval->val_type == USB_MIXER_BESPOKEN)
3677 if (cval->cmask) {
3680 if (!(cval->cmask & (1 << c)))
3682 if (cval->cached & (1 << (c + 1))) {
3683 err = snd_usb_set_cur_mix_value(cval, c + 1, idx,
3684 cval->cache_val[idx]);
3692 if (cval->cached)
3693 snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);