mixer.c (9cbb2808ccfb3c64300151baf73bd5f11feab77f) mixer.c (0ba41d917eeb87f608cf147f870ff2f4c1056bab)
1/*
2 * (Tentative) USB Audio Driver for ALSA
3 *
4 * Mixer control part
5 *
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7 *
8 * Many codes borrowed from audio.c by

--- 291 unchanged lines hidden (view full) ---

300 if (snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
301 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
302 validx, idx, buf, val_len) >= val_len) {
303 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
304 err = 0;
305 goto out;
306 }
307 }
1/*
2 * (Tentative) USB Audio Driver for ALSA
3 *
4 * Mixer control part
5 *
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7 *
8 * Many codes borrowed from audio.c by

--- 291 unchanged lines hidden (view full) ---

300 if (snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
301 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
302 validx, idx, buf, val_len) >= val_len) {
303 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
304 err = 0;
305 goto out;
306 }
307 }
308 snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
309 request, validx, idx, cval->val_type);
308 usb_audio_dbg(chip,
309 "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
310 request, validx, idx, cval->val_type);
310 err = -EINVAL;
311
312 out:
313 up_read(&chip->shutdown_rwsem);
314 snd_usb_autosuspend(cval->mixer->chip);
315 return err;
316}
317

--- 28 unchanged lines hidden (view full) ---

346 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
347 validx, idx, buf, size);
348 }
349 up_read(&chip->shutdown_rwsem);
350 snd_usb_autosuspend(chip);
351
352 if (ret < 0) {
353error:
311 err = -EINVAL;
312
313 out:
314 up_read(&chip->shutdown_rwsem);
315 snd_usb_autosuspend(cval->mixer->chip);
316 return err;
317}
318

--- 28 unchanged lines hidden (view full) ---

347 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
348 validx, idx, buf, size);
349 }
350 up_read(&chip->shutdown_rwsem);
351 snd_usb_autosuspend(chip);
352
353 if (ret < 0) {
354error:
354 snd_printk(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
355 request, validx, idx, cval->val_type);
355 usb_audio_err(chip,
356 "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
357 request, validx, idx, cval->val_type);
356 return ret;
357 }
358
359 /* FIXME: how should we handle multiple triplets here? */
360
361 switch (request) {
362 case UAC_GET_CUR:
363 val = buf;

--- 44 unchanged lines hidden (view full) ---

408
409 if (cval->cached & (1 << channel)) {
410 *value = cval->cache_val[index];
411 return 0;
412 }
413 err = get_cur_mix_raw(cval, channel, value);
414 if (err < 0) {
415 if (!cval->mixer->ignore_ctl_error)
358 return ret;
359 }
360
361 /* FIXME: how should we handle multiple triplets here? */
362
363 switch (request) {
364 case UAC_GET_CUR:
365 val = buf;

--- 44 unchanged lines hidden (view full) ---

410
411 if (cval->cached & (1 << channel)) {
412 *value = cval->cache_val[index];
413 return 0;
414 }
415 err = get_cur_mix_raw(cval, channel, value);
416 if (err < 0) {
417 if (!cval->mixer->ignore_ctl_error)
416 snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n",
418 usb_audio_dbg(cval->mixer->chip,
419 "cannot get current value for control %d ch %d: err = %d\n",
417 cval->control, channel, err);
418 return err;
419 }
420 cval->cached |= 1 << channel;
421 cval->cache_val[index] = *value;
422 return 0;
423}
424

--- 14 unchanged lines hidden (view full) ---

439 if (cval->mixer->protocol == UAC_VERSION_1) {
440 val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
441 } else { /* UAC_VERSION_2 */
442 /* audio class v2 controls are always 2 bytes in size */
443 val_len = sizeof(__u16);
444
445 /* FIXME */
446 if (request != UAC_SET_CUR) {
420 cval->control, channel, err);
421 return err;
422 }
423 cval->cached |= 1 << channel;
424 cval->cache_val[index] = *value;
425 return 0;
426}
427

--- 14 unchanged lines hidden (view full) ---

442 if (cval->mixer->protocol == UAC_VERSION_1) {
443 val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
444 } else { /* UAC_VERSION_2 */
445 /* audio class v2 controls are always 2 bytes in size */
446 val_len = sizeof(__u16);
447
448 /* FIXME */
449 if (request != UAC_SET_CUR) {
447 snd_printdd(KERN_WARNING "RANGE setting not yet supported\n");
450 usb_audio_dbg(chip, "RANGE setting not yet supported\n");
448 return -EINVAL;
449 }
450
451 request = UAC2_CS_CUR;
452 }
453
454 value_set = convert_bytes_value(cval, value_set);
455 buf[0] = value_set & 0xff;

--- 9 unchanged lines hidden (view full) ---

465 if (snd_usb_ctl_msg(chip->dev,
466 usb_sndctrlpipe(chip->dev, 0), request,
467 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
468 validx, idx, buf, val_len) >= 0) {
469 err = 0;
470 goto out;
471 }
472 }
451 return -EINVAL;
452 }
453
454 request = UAC2_CS_CUR;
455 }
456
457 value_set = convert_bytes_value(cval, value_set);
458 buf[0] = value_set & 0xff;

--- 9 unchanged lines hidden (view full) ---

468 if (snd_usb_ctl_msg(chip->dev,
469 usb_sndctrlpipe(chip->dev, 0), request,
470 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
471 validx, idx, buf, val_len) >= 0) {
472 err = 0;
473 goto out;
474 }
475 }
473 snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
476 usb_audio_dbg(chip, "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
474 request, validx, idx, cval->val_type, buf[0], buf[1]);
475 err = -EINVAL;
476
477 out:
478 up_read(&chip->shutdown_rwsem);
479 snd_usb_autosuspend(chip);
480 return err;
481}

--- 7 unchanged lines hidden (view full) ---

489 int index, int value)
490{
491 int err;
492 unsigned int read_only = (channel == 0) ?
493 cval->master_readonly :
494 cval->ch_readonly & (1 << (channel - 1));
495
496 if (read_only) {
477 request, validx, idx, cval->val_type, buf[0], buf[1]);
478 err = -EINVAL;
479
480 out:
481 up_read(&chip->shutdown_rwsem);
482 snd_usb_autosuspend(chip);
483 return err;
484}

--- 7 unchanged lines hidden (view full) ---

492 int index, int value)
493{
494 int err;
495 unsigned int read_only = (channel == 0) ?
496 cval->master_readonly :
497 cval->ch_readonly & (1 << (channel - 1));
498
499 if (read_only) {
497 snd_printdd(KERN_INFO "%s(): channel %d of control %d is read_only\n",
500 usb_audio_dbg(cval->mixer->chip,
501 "%s(): channel %d of control %d is read_only\n",
498 __func__, channel, cval->control);
499 return 0;
500 }
501
502 err = snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
503 value);
504 if (err < 0)
505 return err;

--- 49 unchanged lines hidden (view full) ---

555 struct snd_kcontrol *kctl)
556{
557 struct usb_mixer_elem_info *cval = kctl->private_data;
558 int err;
559
560 while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
561 kctl->id.index++;
562 if ((err = snd_ctl_add(mixer->chip->card, kctl)) < 0) {
502 __func__, channel, cval->control);
503 return 0;
504 }
505
506 err = snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
507 value);
508 if (err < 0)
509 return err;

--- 49 unchanged lines hidden (view full) ---

559 struct snd_kcontrol *kctl)
560{
561 struct usb_mixer_elem_info *cval = kctl->private_data;
562 int err;
563
564 while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
565 kctl->id.index++;
566 if ((err = snd_ctl_add(mixer->chip->card, kctl)) < 0) {
563 snd_printd(KERN_ERR "cannot add control (err = %d)\n", err);
567 usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n", err);
564 return err;
565 }
566 cval->elem_id = &kctl->id;
567 cval->next_id_elem = mixer->id_elems[cval->id];
568 mixer->id_elems[cval->id] = cval;
569 return 0;
570}
571

--- 230 unchanged lines hidden (view full) ---

802/*
803 * interface to ALSA control for feature/mixer units
804 */
805
806/* volume control quirks */
807static void volume_control_quirks(struct usb_mixer_elem_info *cval,
808 struct snd_kcontrol *kctl)
809{
568 return err;
569 }
570 cval->elem_id = &kctl->id;
571 cval->next_id_elem = mixer->id_elems[cval->id];
572 mixer->id_elems[cval->id] = cval;
573 return 0;
574}
575

--- 230 unchanged lines hidden (view full) ---

806/*
807 * interface to ALSA control for feature/mixer units
808 */
809
810/* volume control quirks */
811static void volume_control_quirks(struct usb_mixer_elem_info *cval,
812 struct snd_kcontrol *kctl)
813{
810 switch (cval->mixer->chip->usb_id) {
814 struct snd_usb_audio *chip = cval->mixer->chip;
815 switch (chip->usb_id) {
811 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
812 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */
813 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
814 cval->min = 0x0000;
815 cval->max = 0xffff;
816 cval->res = 0x00e6;
817 break;
818 }

--- 15 unchanged lines hidden (view full) ---

834 cval->max = 0xfcfe;
835 cval->res = 0x0073;
836 }
837 break;
838
839 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
840 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
841 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
816 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
817 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */
818 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
819 cval->min = 0x0000;
820 cval->max = 0xffff;
821 cval->res = 0x00e6;
822 break;
823 }

--- 15 unchanged lines hidden (view full) ---

839 cval->max = 0xfcfe;
840 cval->res = 0x0073;
841 }
842 break;
843
844 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
845 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
846 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
842 snd_printk(KERN_INFO
843 "usb-audio: set quirk for FTU Effect Duration\n");
847 usb_audio_info(chip,
848 "set quirk for FTU Effect Duration\n");
844 cval->min = 0x0000;
845 cval->max = 0x7f00;
846 cval->res = 0x0100;
847 break;
848 }
849 if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
850 strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
849 cval->min = 0x0000;
850 cval->max = 0x7f00;
851 cval->res = 0x0100;
852 break;
853 }
854 if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
855 strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
851 snd_printk(KERN_INFO
852 "usb-audio: set quirks for FTU Effect Feedback/Volume\n");
856 usb_audio_info(chip,
857 "set quirks for FTU Effect Feedback/Volume\n");
853 cval->min = 0x00;
854 cval->max = 0x7f;
855 break;
856 }
857 break;
858
859 case USB_ID(0x0471, 0x0101):
860 case USB_ID(0x0471, 0x0104):
861 case USB_ID(0x0471, 0x0105):
862 case USB_ID(0x0672, 0x1041):
863 /* quirk for UDA1321/N101.
864 * note that detection between firmware 2.1.1.7 (N101)
865 * and later 2.1.1.21 is not very clear from datasheets.
866 * I hope that the min value is -15360 for newer firmware --jk
867 */
868 if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
869 cval->min == -15616) {
858 cval->min = 0x00;
859 cval->max = 0x7f;
860 break;
861 }
862 break;
863
864 case USB_ID(0x0471, 0x0101):
865 case USB_ID(0x0471, 0x0104):
866 case USB_ID(0x0471, 0x0105):
867 case USB_ID(0x0672, 0x1041):
868 /* quirk for UDA1321/N101.
869 * note that detection between firmware 2.1.1.7 (N101)
870 * and later 2.1.1.21 is not very clear from datasheets.
871 * I hope that the min value is -15360 for newer firmware --jk
872 */
873 if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
874 cval->min == -15616) {
870 snd_printk(KERN_INFO
875 usb_audio_info(chip,
871 "set volume quirk for UDA1321/N101 chip\n");
872 cval->max = -256;
873 }
874 break;
875
876 case USB_ID(0x046d, 0x09a4):
877 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
876 "set volume quirk for UDA1321/N101 chip\n");
877 cval->max = -256;
878 }
879 break;
880
881 case USB_ID(0x046d, 0x09a4):
882 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
878 snd_printk(KERN_INFO
883 usb_audio_info(chip,
879 "set volume quirk for QuickCam E3500\n");
880 cval->min = 6080;
881 cval->max = 8768;
882 cval->res = 192;
883 }
884 break;
885
886 case USB_ID(0x046d, 0x0808):
887 case USB_ID(0x046d, 0x0809):
888 case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */
889 case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */
890 case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */
891 case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */
892 case USB_ID(0x046d, 0x0991):
893 /* Most audio usb devices lie about volume resolution.
894 * Most Logitech webcams have res = 384.
895 * Proboly there is some logitech magic behind this number --fishor
896 */
897 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
884 "set volume quirk for QuickCam E3500\n");
885 cval->min = 6080;
886 cval->max = 8768;
887 cval->res = 192;
888 }
889 break;
890
891 case USB_ID(0x046d, 0x0808):
892 case USB_ID(0x046d, 0x0809):
893 case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */
894 case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */
895 case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */
896 case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */
897 case USB_ID(0x046d, 0x0991):
898 /* Most audio usb devices lie about volume resolution.
899 * Most Logitech webcams have res = 384.
900 * Proboly there is some logitech magic behind this number --fishor
901 */
902 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
898 snd_printk(KERN_INFO
903 usb_audio_info(chip,
899 "set resolution quirk: cval->res = 384\n");
900 cval->res = 384;
901 }
902 break;
903
904 }
905}
906

--- 19 unchanged lines hidden (view full) ---

926 for (i = 0; i < MAX_CHANNELS; i++)
927 if (cval->cmask & (1 << i)) {
928 minchn = i + 1;
929 break;
930 }
931 }
932 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
933 get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
904 "set resolution quirk: cval->res = 384\n");
905 cval->res = 384;
906 }
907 break;
908
909 }
910}
911

--- 19 unchanged lines hidden (view full) ---

931 for (i = 0; i < MAX_CHANNELS; i++)
932 if (cval->cmask & (1 << i)) {
933 minchn = i + 1;
934 break;
935 }
936 }
937 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
938 get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
934 snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
939 usb_audio_err(cval->mixer->chip,
940 "%d:%d: cannot get min/max values for control %d (id %d)\n",
935 cval->id, snd_usb_ctrl_intf(cval->mixer->chip), cval->control, cval->id);
936 return -EINVAL;
937 }
938 if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
939 cval->res = 1;
940 } else {
941 int last_valid_res = cval->res;
942

--- 247 unchanged lines hidden (view full) ---

1190 }
1191
1192 map = find_map(state, unitid, control);
1193 if (check_ignored_ctl(map))
1194 return;
1195
1196 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1197 if (! cval) {
941 cval->id, snd_usb_ctrl_intf(cval->mixer->chip), cval->control, cval->id);
942 return -EINVAL;
943 }
944 if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
945 cval->res = 1;
946 } else {
947 int last_valid_res = cval->res;
948

--- 247 unchanged lines hidden (view full) ---

1196 }
1197
1198 map = find_map(state, unitid, control);
1199 if (check_ignored_ctl(map))
1200 return;
1201
1202 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1203 if (! cval) {
1198 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1204 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1199 return;
1200 }
1201 cval->mixer = state->mixer;
1202 cval->id = unitid;
1203 cval->control = control;
1204 cval->cmask = ctl_mask;
1205 cval->val_type = audio_feature_info[control-1].type;
1206 if (ctl_mask == 0) {

--- 12 unchanged lines hidden (view full) ---

1219 * read-only. set_cur_mix_value() will check the mask again and won't
1220 * issue write commands to read-only channels. */
1221 if (cval->channels == readonly_mask)
1222 kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1223 else
1224 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1225
1226 if (! kctl) {
1205 return;
1206 }
1207 cval->mixer = state->mixer;
1208 cval->id = unitid;
1209 cval->control = control;
1210 cval->cmask = ctl_mask;
1211 cval->val_type = audio_feature_info[control-1].type;
1212 if (ctl_mask == 0) {

--- 12 unchanged lines hidden (view full) ---

1225 * read-only. set_cur_mix_value() will check the mask again and won't
1226 * issue write commands to read-only channels. */
1227 if (cval->channels == readonly_mask)
1228 kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1229 else
1230 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1231
1232 if (! kctl) {
1227 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1233 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1228 kfree(cval);
1229 return;
1230 }
1231 kctl->private_free = usb_mixer_elem_free;
1232
1233 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1234 mapped_name = len != 0;
1235 if (! len && nameid)

--- 57 unchanged lines hidden (view full) ---

1293 }
1294
1295 range = (cval->max - cval->min) / cval->res;
1296 /* Are there devices with volume range more than 255? I use a bit more
1297 * to be sure. 384 is a resolution magic number found on Logitech
1298 * devices. It will definitively catch all buggy Logitech devices.
1299 */
1300 if (range > 384) {
1234 kfree(cval);
1235 return;
1236 }
1237 kctl->private_free = usb_mixer_elem_free;
1238
1239 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1240 mapped_name = len != 0;
1241 if (! len && nameid)

--- 57 unchanged lines hidden (view full) ---

1299 }
1300
1301 range = (cval->max - cval->min) / cval->res;
1302 /* Are there devices with volume range more than 255? I use a bit more
1303 * to be sure. 384 is a resolution magic number found on Logitech
1304 * devices. It will definitively catch all buggy Logitech devices.
1305 */
1306 if (range > 384) {
1301 snd_printk(KERN_WARNING "usb_audio: Warning! Unlikely big "
1307 usb_audio_warn(state->chip, "Warning! Unlikely big "
1302 "volume range (=%u), cval->res is probably wrong.",
1303 range);
1308 "volume range (=%u), cval->res is probably wrong.",
1309 range);
1304 snd_printk(KERN_WARNING "usb_audio: [%d] FU [%s] ch = %d, "
1310 usb_audio_warn(state->chip, "[%d] FU [%s] ch = %d, "
1305 "val = %d/%d/%d", cval->id,
1306 kctl->id.name, cval->channels,
1307 cval->min, cval->max, cval->res);
1308 }
1309
1311 "val = %d/%d/%d", cval->id,
1312 kctl->id.name, cval->channels,
1313 cval->min, cval->max, cval->res);
1314 }
1315
1310 snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
1316 usb_audio_dbg(state->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
1311 cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
1312 snd_usb_mixer_add_control(state->mixer, kctl);
1313}
1314
1315
1316
1317/*
1318 * parse a feature unit

--- 7 unchanged lines hidden (view full) ---

1326 unsigned int master_bits, first_ch_bits;
1327 int err, csize;
1328 struct uac_feature_unit_descriptor *hdr = _ftr;
1329 __u8 *bmaControls;
1330
1331 if (state->mixer->protocol == UAC_VERSION_1) {
1332 csize = hdr->bControlSize;
1333 if (!csize) {
1317 cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
1318 snd_usb_mixer_add_control(state->mixer, kctl);
1319}
1320
1321
1322
1323/*
1324 * parse a feature unit

--- 7 unchanged lines hidden (view full) ---

1332 unsigned int master_bits, first_ch_bits;
1333 int err, csize;
1334 struct uac_feature_unit_descriptor *hdr = _ftr;
1335 __u8 *bmaControls;
1336
1337 if (state->mixer->protocol == UAC_VERSION_1) {
1338 csize = hdr->bControlSize;
1339 if (!csize) {
1334 snd_printdd(KERN_ERR "usbaudio: unit %u: "
1335 "invalid bControlSize == 0\n", unitid);
1340 usb_audio_dbg(state->chip,
1341 "unit %u: invalid bControlSize == 0\n",
1342 unitid);
1336 return -EINVAL;
1337 }
1338 channels = (hdr->bLength - 7) / csize - 1;
1339 bmaControls = hdr->bmaControls;
1340 if (hdr->bLength < 7 + csize) {
1343 return -EINVAL;
1344 }
1345 channels = (hdr->bLength - 7) / csize - 1;
1346 bmaControls = hdr->bmaControls;
1347 if (hdr->bLength < 7 + csize) {
1341 snd_printk(KERN_ERR "usbaudio: unit %u: "
1342 "invalid UAC_FEATURE_UNIT descriptor\n",
1343 unitid);
1348 usb_audio_err(state->chip,
1349 "unit %u: invalid UAC_FEATURE_UNIT descriptor\n",
1350 unitid);
1344 return -EINVAL;
1345 }
1346 } else {
1347 struct uac2_feature_unit_descriptor *ftr = _ftr;
1348 csize = 4;
1349 channels = (hdr->bLength - 6) / 4 - 1;
1350 bmaControls = ftr->bmaControls;
1351 if (hdr->bLength < 6 + csize) {
1351 return -EINVAL;
1352 }
1353 } else {
1354 struct uac2_feature_unit_descriptor *ftr = _ftr;
1355 csize = 4;
1356 channels = (hdr->bLength - 6) / 4 - 1;
1357 bmaControls = ftr->bmaControls;
1358 if (hdr->bLength < 6 + csize) {
1352 snd_printk(KERN_ERR "usbaudio: unit %u: "
1353 "invalid UAC_FEATURE_UNIT descriptor\n",
1354 unitid);
1359 usb_audio_err(state->chip,
1360 "unit %u: invalid UAC_FEATURE_UNIT descriptor\n",
1361 unitid);
1355 return -EINVAL;
1356 }
1357 }
1358
1359 /* parse the source unit */
1360 if ((err = parse_audio_unit(state, hdr->bSourceID)) < 0)
1361 return err;
1362
1363 /* determine the input source type and name */
1364 err = check_input_term(state, hdr->bSourceID, &iterm);
1365 if (err < 0)
1366 return err;
1367
1368 master_bits = snd_usb_combine_bytes(bmaControls, csize);
1369 /* master configuration quirks */
1370 switch (state->chip->usb_id) {
1371 case USB_ID(0x08bb, 0x2702):
1362 return -EINVAL;
1363 }
1364 }
1365
1366 /* parse the source unit */
1367 if ((err = parse_audio_unit(state, hdr->bSourceID)) < 0)
1368 return err;
1369
1370 /* determine the input source type and name */
1371 err = check_input_term(state, hdr->bSourceID, &iterm);
1372 if (err < 0)
1373 return err;
1374
1375 master_bits = snd_usb_combine_bytes(bmaControls, csize);
1376 /* master configuration quirks */
1377 switch (state->chip->usb_id) {
1378 case USB_ID(0x08bb, 0x2702):
1372 snd_printk(KERN_INFO
1373 "usbmixer: master volume quirk for PCM2702 chip\n");
1379 usb_audio_info(state->chip,
1380 "usbmixer: master volume quirk for PCM2702 chip\n");
1374 /* disable non-functional volume control */
1375 master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
1376 break;
1377 case USB_ID(0x1130, 0xf211):
1381 /* disable non-functional volume control */
1382 master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
1383 break;
1384 case USB_ID(0x1130, 0xf211):
1378 snd_printk(KERN_INFO
1379 "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
1385 usb_audio_info(state->chip,
1386 "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
1380 /* disable non-functional volume control */
1381 channels = 0;
1382 break;
1383
1384 }
1385 if (channels > 0)
1386 first_ch_bits = snd_usb_combine_bytes(bmaControls + csize, csize);
1387 else

--- 85 unchanged lines hidden (view full) ---

1473 }
1474 }
1475
1476 /* get min/max values */
1477 get_min_max(cval, 0);
1478
1479 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1480 if (! kctl) {
1387 /* disable non-functional volume control */
1388 channels = 0;
1389 break;
1390
1391 }
1392 if (channels > 0)
1393 first_ch_bits = snd_usb_combine_bytes(bmaControls + csize, csize);
1394 else

--- 85 unchanged lines hidden (view full) ---

1480 }
1481 }
1482
1483 /* get min/max values */
1484 get_min_max(cval, 0);
1485
1486 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1487 if (! kctl) {
1481 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1488 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1482 kfree(cval);
1483 return;
1484 }
1485 kctl->private_free = usb_mixer_elem_free;
1486
1487 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1488 if (! len)
1489 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
1490 if (! len)
1491 len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
1492 append_ctl_name(kctl, " Volume");
1493
1489 kfree(cval);
1490 return;
1491 }
1492 kctl->private_free = usb_mixer_elem_free;
1493
1494 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1495 if (! len)
1496 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
1497 if (! len)
1498 len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
1499 append_ctl_name(kctl, " Volume");
1500
1494 snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
1501 usb_audio_dbg(state->chip, "[%d] MU [%s] ch = %d, val = %d/%d\n",
1495 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1496 snd_usb_mixer_add_control(state->mixer, kctl);
1497}
1498
1499
1500/*
1501 * parse a mixer unit
1502 */
1503static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *raw_desc)
1504{
1505 struct uac_mixer_unit_descriptor *desc = raw_desc;
1506 struct usb_audio_term iterm;
1507 int input_pins, num_ins, num_outs;
1508 int pin, ich, err;
1509
1510 if (desc->bLength < 11 || ! (input_pins = desc->bNrInPins) || ! (num_outs = uac_mixer_unit_bNrChannels(desc))) {
1502 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1503 snd_usb_mixer_add_control(state->mixer, kctl);
1504}
1505
1506
1507/*
1508 * parse a mixer unit
1509 */
1510static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *raw_desc)
1511{
1512 struct uac_mixer_unit_descriptor *desc = raw_desc;
1513 struct usb_audio_term iterm;
1514 int input_pins, num_ins, num_outs;
1515 int pin, ich, err;
1516
1517 if (desc->bLength < 11 || ! (input_pins = desc->bNrInPins) || ! (num_outs = uac_mixer_unit_bNrChannels(desc))) {
1511 snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid);
1518 usb_audio_err(state->chip, "invalid MIXER UNIT descriptor %d\n", unitid);
1512 return -EINVAL;
1513 }
1514 /* no bmControls field (e.g. Maya44) -> ignore */
1515 if (desc->bLength <= 10 + input_pins) {
1519 return -EINVAL;
1520 }
1521 /* no bmControls field (e.g. Maya44) -> ignore */
1522 if (desc->bLength <= 10 + input_pins) {
1516 snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid);
1523 usb_audio_dbg(state->chip, "MU %d has no bmControls field\n", unitid);
1517 return 0;
1518 }
1519
1520 num_ins = 0;
1521 ich = 0;
1522 for (pin = 0; pin < input_pins; pin++) {
1523 err = parse_audio_unit(state, desc->baSourceID[pin]);
1524 if (err < 0)

--- 182 unchanged lines hidden (view full) ---

1707 { 0 }
1708 };
1709 static struct procunit_info default_info = {
1710 0, NULL, default_value_info
1711 };
1712
1713 if (desc->bLength < 13 || desc->bLength < 13 + num_ins ||
1714 desc->bLength < num_ins + uac_processing_unit_bControlSize(desc, state->mixer->protocol)) {
1524 return 0;
1525 }
1526
1527 num_ins = 0;
1528 ich = 0;
1529 for (pin = 0; pin < input_pins; pin++) {
1530 err = parse_audio_unit(state, desc->baSourceID[pin]);
1531 if (err < 0)

--- 182 unchanged lines hidden (view full) ---

1714 { 0 }
1715 };
1716 static struct procunit_info default_info = {
1717 0, NULL, default_value_info
1718 };
1719
1720 if (desc->bLength < 13 || desc->bLength < 13 + num_ins ||
1721 desc->bLength < num_ins + uac_processing_unit_bControlSize(desc, state->mixer->protocol)) {
1715 snd_printk(KERN_ERR "invalid %s descriptor (id %d)\n", name, unitid);
1722 usb_audio_err(state->chip, "invalid %s descriptor (id %d)\n", name, unitid);
1716 return -EINVAL;
1717 }
1718
1719 for (i = 0; i < num_ins; i++) {
1720 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1721 return err;
1722 }
1723

--- 9 unchanged lines hidden (view full) ---

1733
1734 if (! (controls[valinfo->control / 8] & (1 << ((valinfo->control % 8) - 1))))
1735 continue;
1736 map = find_map(state, unitid, valinfo->control);
1737 if (check_ignored_ctl(map))
1738 continue;
1739 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1740 if (! cval) {
1723 return -EINVAL;
1724 }
1725
1726 for (i = 0; i < num_ins; i++) {
1727 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1728 return err;
1729 }
1730

--- 9 unchanged lines hidden (view full) ---

1740
1741 if (! (controls[valinfo->control / 8] & (1 << ((valinfo->control % 8) - 1))))
1742 continue;
1743 map = find_map(state, unitid, valinfo->control);
1744 if (check_ignored_ctl(map))
1745 continue;
1746 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1747 if (! cval) {
1741 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1748 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1742 return -ENOMEM;
1743 }
1744 cval->mixer = state->mixer;
1745 cval->id = unitid;
1746 cval->control = valinfo->control;
1747 cval->val_type = valinfo->val_type;
1748 cval->channels = 1;
1749

--- 15 unchanged lines hidden (view full) ---

1765 cval->res = 1;
1766 cval->initialized = 1;
1767 } else
1768 get_min_max(cval, valinfo->min_value);
1769 }
1770
1771 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
1772 if (! kctl) {
1749 return -ENOMEM;
1750 }
1751 cval->mixer = state->mixer;
1752 cval->id = unitid;
1753 cval->control = valinfo->control;
1754 cval->val_type = valinfo->val_type;
1755 cval->channels = 1;
1756

--- 15 unchanged lines hidden (view full) ---

1772 cval->res = 1;
1773 cval->initialized = 1;
1774 } else
1775 get_min_max(cval, valinfo->min_value);
1776 }
1777
1778 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
1779 if (! kctl) {
1773 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1780 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1774 kfree(cval);
1775 return -ENOMEM;
1776 }
1777 kctl->private_free = usb_mixer_elem_free;
1778
1779 if (check_mapped_name(map, kctl->id.name,
1780 sizeof(kctl->id.name)))
1781 /* nothing */ ;

--- 5 unchanged lines hidden (view full) ---

1787 if (nameid)
1788 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
1789 if (! len)
1790 strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
1791 }
1792 append_ctl_name(kctl, " ");
1793 append_ctl_name(kctl, valinfo->suffix);
1794
1781 kfree(cval);
1782 return -ENOMEM;
1783 }
1784 kctl->private_free = usb_mixer_elem_free;
1785
1786 if (check_mapped_name(map, kctl->id.name,
1787 sizeof(kctl->id.name)))
1788 /* nothing */ ;

--- 5 unchanged lines hidden (view full) ---

1794 if (nameid)
1795 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
1796 if (! len)
1797 strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
1798 }
1799 append_ctl_name(kctl, " ");
1800 append_ctl_name(kctl, valinfo->suffix);
1801
1795 snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
1802 usb_audio_dbg(state->chip,
1803 "[%d] PU [%s] ch = %d, val = %d/%d\n",
1796 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1797 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
1798 return err;
1799 }
1800 return 0;
1801}
1802
1803

--- 108 unchanged lines hidden (view full) ---

1912 unsigned int i, nameid, len;
1913 int err;
1914 struct usb_mixer_elem_info *cval;
1915 struct snd_kcontrol *kctl;
1916 const struct usbmix_name_map *map;
1917 char **namelist;
1918
1919 if (!desc->bNrInPins || desc->bLength < 5 + desc->bNrInPins) {
1804 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1805 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
1806 return err;
1807 }
1808 return 0;
1809}
1810
1811

--- 108 unchanged lines hidden (view full) ---

1920 unsigned int i, nameid, len;
1921 int err;
1922 struct usb_mixer_elem_info *cval;
1923 struct snd_kcontrol *kctl;
1924 const struct usbmix_name_map *map;
1925 char **namelist;
1926
1927 if (!desc->bNrInPins || desc->bLength < 5 + desc->bNrInPins) {
1920 snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid);
1928 usb_audio_err(state->chip,
1929 "invalid SELECTOR UNIT descriptor %d\n", unitid);
1921 return -EINVAL;
1922 }
1923
1924 for (i = 0; i < desc->bNrInPins; i++) {
1925 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1926 return err;
1927 }
1928
1929 if (desc->bNrInPins == 1) /* only one ? nonsense! */
1930 return 0;
1931
1932 map = find_map(state, unitid, 0);
1933 if (check_ignored_ctl(map))
1934 return 0;
1935
1936 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1937 if (! cval) {
1930 return -EINVAL;
1931 }
1932
1933 for (i = 0; i < desc->bNrInPins; i++) {
1934 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1935 return err;
1936 }
1937
1938 if (desc->bNrInPins == 1) /* only one ? nonsense! */
1939 return 0;
1940
1941 map = find_map(state, unitid, 0);
1942 if (check_ignored_ctl(map))
1943 return 0;
1944
1945 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1946 if (! cval) {
1938 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1947 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1939 return -ENOMEM;
1940 }
1941 cval->mixer = state->mixer;
1942 cval->id = unitid;
1943 cval->val_type = USB_MIXER_U8;
1944 cval->channels = 1;
1945 cval->min = 1;
1946 cval->max = desc->bNrInPins;
1947 cval->res = 1;
1948 cval->initialized = 1;
1949
1950 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
1951 cval->control = UAC2_CX_CLOCK_SELECTOR;
1952 else
1953 cval->control = 0;
1954
1955 namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
1956 if (! namelist) {
1948 return -ENOMEM;
1949 }
1950 cval->mixer = state->mixer;
1951 cval->id = unitid;
1952 cval->val_type = USB_MIXER_U8;
1953 cval->channels = 1;
1954 cval->min = 1;
1955 cval->max = desc->bNrInPins;
1956 cval->res = 1;
1957 cval->initialized = 1;
1958
1959 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
1960 cval->control = UAC2_CX_CLOCK_SELECTOR;
1961 else
1962 cval->control = 0;
1963
1964 namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
1965 if (! namelist) {
1957 snd_printk(KERN_ERR "cannot malloc\n");
1966 usb_audio_err(state->chip, "cannot malloc\n");
1958 kfree(cval);
1959 return -ENOMEM;
1960 }
1961#define MAX_ITEM_NAME_LEN 64
1962 for (i = 0; i < desc->bNrInPins; i++) {
1963 struct usb_audio_term iterm;
1964 len = 0;
1965 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
1966 if (! namelist[i]) {
1967 kfree(cval);
1968 return -ENOMEM;
1969 }
1970#define MAX_ITEM_NAME_LEN 64
1971 for (i = 0; i < desc->bNrInPins; i++) {
1972 struct usb_audio_term iterm;
1973 len = 0;
1974 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
1975 if (! namelist[i]) {
1967 snd_printk(KERN_ERR "cannot malloc\n");
1976 usb_audio_err(state->chip, "cannot malloc\n");
1968 while (i--)
1969 kfree(namelist[i]);
1970 kfree(namelist);
1971 kfree(cval);
1972 return -ENOMEM;
1973 }
1974 len = check_mapped_selector_name(state, unitid, i, namelist[i],
1975 MAX_ITEM_NAME_LEN);
1976 if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0)
1977 len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0);
1978 if (! len)
1979 sprintf(namelist[i], "Input %d", i);
1980 }
1981
1982 kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
1983 if (! kctl) {
1977 while (i--)
1978 kfree(namelist[i]);
1979 kfree(namelist);
1980 kfree(cval);
1981 return -ENOMEM;
1982 }
1983 len = check_mapped_selector_name(state, unitid, i, namelist[i],
1984 MAX_ITEM_NAME_LEN);
1985 if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0)
1986 len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0);
1987 if (! len)
1988 sprintf(namelist[i], "Input %d", i);
1989 }
1990
1991 kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
1992 if (! kctl) {
1984 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1993 usb_audio_err(state->chip, "cannot malloc kcontrol\n");
1985 kfree(namelist);
1986 kfree(cval);
1987 return -ENOMEM;
1988 }
1989 kctl->private_value = (unsigned long)namelist;
1990 kctl->private_free = usb_mixer_selector_elem_free;
1991
1992 nameid = uac_selector_unit_iSelector(desc);

--- 11 unchanged lines hidden (view full) ---

2004 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
2005 append_ctl_name(kctl, " Clock Source");
2006 else if ((state->oterm.type & 0xff00) == 0x0100)
2007 append_ctl_name(kctl, " Capture Source");
2008 else
2009 append_ctl_name(kctl, " Playback Source");
2010 }
2011
1994 kfree(namelist);
1995 kfree(cval);
1996 return -ENOMEM;
1997 }
1998 kctl->private_value = (unsigned long)namelist;
1999 kctl->private_free = usb_mixer_selector_elem_free;
2000
2001 nameid = uac_selector_unit_iSelector(desc);

--- 11 unchanged lines hidden (view full) ---

2013 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
2014 append_ctl_name(kctl, " Clock Source");
2015 else if ((state->oterm.type & 0xff00) == 0x0100)
2016 append_ctl_name(kctl, " Capture Source");
2017 else
2018 append_ctl_name(kctl, " Playback Source");
2019 }
2020
2012 snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
2021 usb_audio_dbg(state->chip, "[%d] SU [%s] items = %d\n",
2013 cval->id, kctl->id.name, desc->bNrInPins);
2014 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
2015 return err;
2016
2017 return 0;
2018}
2019
2020

--- 5 unchanged lines hidden (view full) ---

2026{
2027 unsigned char *p1;
2028
2029 if (test_and_set_bit(unitid, state->unitbitmap))
2030 return 0; /* the unit already visited */
2031
2032 p1 = find_audio_control_unit(state, unitid);
2033 if (!p1) {
2022 cval->id, kctl->id.name, desc->bNrInPins);
2023 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
2024 return err;
2025
2026 return 0;
2027}
2028
2029

--- 5 unchanged lines hidden (view full) ---

2035{
2036 unsigned char *p1;
2037
2038 if (test_and_set_bit(unitid, state->unitbitmap))
2039 return 0; /* the unit already visited */
2040
2041 p1 = find_audio_control_unit(state, unitid);
2042 if (!p1) {
2034 snd_printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
2043 usb_audio_err(state->chip, "unit %d not found!\n", unitid);
2035 return -EINVAL;
2036 }
2037
2038 switch (p1[2]) {
2039 case UAC_INPUT_TERMINAL:
2040 case UAC2_CLOCK_SOURCE:
2041 return 0; /* NOP */
2042 case UAC_MIXER_UNIT:

--- 13 unchanged lines hidden (view full) ---

2056 /* UAC2_PROCESSING_UNIT_V2 has the same value */
2057 if (state->mixer->protocol == UAC_VERSION_1)
2058 return parse_audio_extension_unit(state, unitid, p1);
2059 else /* UAC_VERSION_2 */
2060 return parse_audio_processing_unit(state, unitid, p1);
2061 case UAC2_EXTENSION_UNIT_V2:
2062 return parse_audio_extension_unit(state, unitid, p1);
2063 default:
2044 return -EINVAL;
2045 }
2046
2047 switch (p1[2]) {
2048 case UAC_INPUT_TERMINAL:
2049 case UAC2_CLOCK_SOURCE:
2050 return 0; /* NOP */
2051 case UAC_MIXER_UNIT:

--- 13 unchanged lines hidden (view full) ---

2065 /* UAC2_PROCESSING_UNIT_V2 has the same value */
2066 if (state->mixer->protocol == UAC_VERSION_1)
2067 return parse_audio_extension_unit(state, unitid, p1);
2068 else /* UAC_VERSION_2 */
2069 return parse_audio_processing_unit(state, unitid, p1);
2070 case UAC2_EXTENSION_UNIT_V2:
2071 return parse_audio_extension_unit(state, unitid, p1);
2072 default:
2064 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
2073 usb_audio_err(state->chip,
2074 "unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
2065 return -EINVAL;
2066 }
2067}
2068
2069static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
2070{
2071 kfree(mixer->id_elems);
2072 if (mixer->urb) {

--- 131 unchanged lines hidden (view full) ---

2204 int attribute, int value, int index)
2205{
2206 struct usb_mixer_elem_info *info;
2207 __u8 unitid = (index >> 8) & 0xff;
2208 __u8 control = (value >> 8) & 0xff;
2209 __u8 channel = value & 0xff;
2210
2211 if (channel >= MAX_CHANNELS) {
2075 return -EINVAL;
2076 }
2077}
2078
2079static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
2080{
2081 kfree(mixer->id_elems);
2082 if (mixer->urb) {

--- 131 unchanged lines hidden (view full) ---

2214 int attribute, int value, int index)
2215{
2216 struct usb_mixer_elem_info *info;
2217 __u8 unitid = (index >> 8) & 0xff;
2218 __u8 control = (value >> 8) & 0xff;
2219 __u8 channel = value & 0xff;
2220
2221 if (channel >= MAX_CHANNELS) {
2212 snd_printk(KERN_DEBUG "%s(): bogus channel number %d\n",
2213 __func__, channel);
2222 usb_audio_dbg(mixer->chip,
2223 "%s(): bogus channel number %d\n",
2224 __func__, channel);
2214 return;
2215 }
2216
2217 for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem) {
2218 if (info->control != control)
2219 continue;
2220
2221 switch (attribute) {

--- 12 unchanged lines hidden (view full) ---

2234 /* TODO */
2235 break;
2236
2237 case UAC2_CS_MEM:
2238 /* TODO */
2239 break;
2240
2241 default:
2225 return;
2226 }
2227
2228 for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem) {
2229 if (info->control != control)
2230 continue;
2231
2232 switch (attribute) {

--- 12 unchanged lines hidden (view full) ---

2245 /* TODO */
2246 break;
2247
2248 case UAC2_CS_MEM:
2249 /* TODO */
2250 break;
2251
2252 default:
2242 snd_printk(KERN_DEBUG "unknown attribute %d in interrupt\n",
2243 attribute);
2253 usb_audio_dbg(mixer->chip,
2254 "unknown attribute %d in interrupt\n",
2255 attribute);
2244 break;
2245 } /* switch */
2246 }
2247}
2248
2249static void snd_usb_mixer_interrupt(struct urb *urb)
2250{
2251 struct usb_mixer_interface *mixer = urb->context;

--- 4 unchanged lines hidden (view full) ---

2256 goto requeue;
2257
2258 if (mixer->protocol == UAC_VERSION_1) {
2259 struct uac1_status_word *status;
2260
2261 for (status = urb->transfer_buffer;
2262 len >= sizeof(*status);
2263 len -= sizeof(*status), status++) {
2256 break;
2257 } /* switch */
2258 }
2259}
2260
2261static void snd_usb_mixer_interrupt(struct urb *urb)
2262{
2263 struct usb_mixer_interface *mixer = urb->context;

--- 4 unchanged lines hidden (view full) ---

2268 goto requeue;
2269
2270 if (mixer->protocol == UAC_VERSION_1) {
2271 struct uac1_status_word *status;
2272
2273 for (status = urb->transfer_buffer;
2274 len >= sizeof(*status);
2275 len -= sizeof(*status), status++) {
2264 snd_printd(KERN_DEBUG "status interrupt: %02x %02x\n",
2276 dev_dbg(&urb->dev->dev, "status interrupt: %02x %02x\n",
2265 status->bStatusType,
2266 status->bOriginator);
2267
2268 /* ignore any notifications not from the control interface */
2269 if ((status->bStatusType & UAC1_STATUS_TYPE_ORIG_MASK) !=
2270 UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF)
2271 continue;
2272

--- 206 unchanged lines hidden --- 		2277 status->bStatusType,
2278 status->bOriginator);
2279
2280 /* ignore any notifications not from the control interface */
2281 if ((status->bStatusType & UAC1_STATUS_TYPE_ORIG_MASK) !=
2282 UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF)
2283 continue;
2284

--- 206 unchanged lines hidden ---