1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * USB Audio Driver for ALSA 4 * 5 * Quirks and vendor-specific extensions for mixer interfaces 6 * 7 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de> 8 * 9 * Many codes borrowed from audio.c by 10 * Alan Cox (alan@lxorguk.ukuu.org.uk) 11 * Thomas Sailer (sailer@ife.ee.ethz.ch) 12 * 13 * Audio Advantage Micro II support added by: 14 * Przemek Rudy (prudy1@o2.pl) 15 */ 16 17#include <linux/hid.h> 18#include <linux/init.h> 19#include <linux/math64.h> 20#include <linux/slab.h> 21#include <linux/usb.h> 22#include <linux/usb/audio.h> 23 24#include <sound/asoundef.h> 25#include <sound/core.h> 26#include <sound/control.h> 27#include <sound/hwdep.h> 28#include <sound/info.h> 29#include <sound/tlv.h> 30 31#include "usbaudio.h" 32#include "mixer.h" 33#include "mixer_quirks.h" 34#include "mixer_scarlett.h" 35#include "mixer_scarlett_gen2.h" 36#include "mixer_us16x08.h" 37#include "mixer_s1810c.h" 38#include "helper.h" 39 40struct std_mono_table { 41 unsigned int unitid, control, cmask; 42 int val_type; 43 const char *name; 44 snd_kcontrol_tlv_rw_t *tlv_callback; 45}; 46 47/* This function allows for the creation of standard UAC controls. 48 * See the quirks for M-Audio FTUs or Ebox-44. 49 * If you don't want to set a TLV callback pass NULL. 50 * 51 * Since there doesn't seem to be a devices that needs a multichannel 52 * version, we keep it mono for simplicity. 53 */ 54static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer, 55 unsigned int unitid, 56 unsigned int control, 57 unsigned int cmask, 58 int val_type, 59 unsigned int idx_off, 60 const char *name, 61 snd_kcontrol_tlv_rw_t *tlv_callback) 62{ 63 struct usb_mixer_elem_info *cval; 64 struct snd_kcontrol *kctl; 65 66 cval = kzalloc(sizeof(*cval), GFP_KERNEL); 67 if (!cval) 68 return -ENOMEM; 69 70 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid); 71 cval->val_type = val_type; 72 cval->channels = 1; 73 cval->control = control; 74 cval->cmask = cmask; 75 cval->idx_off = idx_off; 76 77 /* get_min_max() is called only for integer volumes later, 78 * so provide a short-cut for booleans */ 79 cval->min = 0; 80 cval->max = 1; 81 cval->res = 0; 82 cval->dBmin = 0; 83 cval->dBmax = 0; 84 85 /* Create control */ 86 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval); 87 if (!kctl) { 88 kfree(cval); 89 return -ENOMEM; 90 } 91 92 /* Set name */ 93 snprintf(kctl->id.name, sizeof(kctl->id.name), name); 94 kctl->private_free = snd_usb_mixer_elem_free; 95 96 /* set TLV */ 97 if (tlv_callback) { 98 kctl->tlv.c = tlv_callback; 99 kctl->vd[0].access |= 100 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 101 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 102 } 103 /* Add control to mixer */ 104 return snd_usb_mixer_add_control(&cval->head, kctl); 105} 106 107static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer, 108 unsigned int unitid, 109 unsigned int control, 110 unsigned int cmask, 111 int val_type, 112 const char *name, 113 snd_kcontrol_tlv_rw_t *tlv_callback) 114{ 115 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask, 116 val_type, 0 /* Offset */, name, tlv_callback); 117} 118 119/* 120 * Create a set of standard UAC controls from a table 121 */ 122static int snd_create_std_mono_table(struct usb_mixer_interface *mixer, 123 const struct std_mono_table *t) 124{ 125 int err; 126 127 while (t->name != NULL) { 128 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control, 129 t->cmask, t->val_type, t->name, t->tlv_callback); 130 if (err < 0) 131 return err; 132 t++; 133 } 134 135 return 0; 136} 137 138static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer, 139 int id, 140 usb_mixer_elem_resume_func_t resume, 141 const struct snd_kcontrol_new *knew, 142 struct usb_mixer_elem_list **listp) 143{ 144 struct usb_mixer_elem_list *list; 145 struct snd_kcontrol *kctl; 146 147 list = kzalloc(sizeof(*list), GFP_KERNEL); 148 if (!list) 149 return -ENOMEM; 150 if (listp) 151 *listp = list; 152 list->mixer = mixer; 153 list->id = id; 154 list->resume = resume; 155 kctl = snd_ctl_new1(knew, list); 156 if (!kctl) { 157 kfree(list); 158 return -ENOMEM; 159 } 160 kctl->private_free = snd_usb_mixer_elem_free; 161 /* don't use snd_usb_mixer_add_control() here, this is a special list element */ 162 return snd_usb_mixer_add_list(list, kctl, false); 163} 164 165/* 166 * Sound Blaster remote control configuration 167 * 168 * format of remote control data: 169 * Extigy: xx 00 170 * Audigy 2 NX: 06 80 xx 00 00 00 171 * Live! 24-bit: 06 80 xx yy 22 83 172 */ 173static const struct rc_config { 174 u32 usb_id; 175 u8 offset; 176 u8 length; 177 u8 packet_length; 178 u8 min_packet_length; /* minimum accepted length of the URB result */ 179 u8 mute_mixer_id; 180 u32 mute_code; 181} rc_configs[] = { 182 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */ 183 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */ 184 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */ 185 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */ 186 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 187 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 188 { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 189 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */ 190}; 191 192static void snd_usb_soundblaster_remote_complete(struct urb *urb) 193{ 194 struct usb_mixer_interface *mixer = urb->context; 195 const struct rc_config *rc = mixer->rc_cfg; 196 u32 code; 197 198 if (urb->status < 0 || urb->actual_length < rc->min_packet_length) 199 return; 200 201 code = mixer->rc_buffer[rc->offset]; 202 if (rc->length == 2) 203 code |= mixer->rc_buffer[rc->offset + 1] << 8; 204 205 /* the Mute button actually changes the mixer control */ 206 if (code == rc->mute_code) 207 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id); 208 mixer->rc_code = code; 209 wmb(); 210 wake_up(&mixer->rc_waitq); 211} 212 213static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf, 214 long count, loff_t *offset) 215{ 216 struct usb_mixer_interface *mixer = hw->private_data; 217 int err; 218 u32 rc_code; 219 220 if (count != 1 && count != 4) 221 return -EINVAL; 222 err = wait_event_interruptible(mixer->rc_waitq, 223 (rc_code = xchg(&mixer->rc_code, 0)) != 0); 224 if (err == 0) { 225 if (count == 1) 226 err = put_user(rc_code, buf); 227 else 228 err = put_user(rc_code, (u32 __user *)buf); 229 } 230 return err < 0 ? err : count; 231} 232 233static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file, 234 poll_table *wait) 235{ 236 struct usb_mixer_interface *mixer = hw->private_data; 237 238 poll_wait(file, &mixer->rc_waitq, wait); 239 return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0; 240} 241 242static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) 243{ 244 struct snd_hwdep *hwdep; 245 int err, len, i; 246 247 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i) 248 if (rc_configs[i].usb_id == mixer->chip->usb_id) 249 break; 250 if (i >= ARRAY_SIZE(rc_configs)) 251 return 0; 252 mixer->rc_cfg = &rc_configs[i]; 253 254 len = mixer->rc_cfg->packet_length; 255 256 init_waitqueue_head(&mixer->rc_waitq); 257 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep); 258 if (err < 0) 259 return err; 260 snprintf(hwdep->name, sizeof(hwdep->name), 261 "%s remote control", mixer->chip->card->shortname); 262 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC; 263 hwdep->private_data = mixer; 264 hwdep->ops.read = snd_usb_sbrc_hwdep_read; 265 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll; 266 hwdep->exclusive = 1; 267 268 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL); 269 if (!mixer->rc_urb) 270 return -ENOMEM; 271 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL); 272 if (!mixer->rc_setup_packet) { 273 usb_free_urb(mixer->rc_urb); 274 mixer->rc_urb = NULL; 275 return -ENOMEM; 276 } 277 mixer->rc_setup_packet->bRequestType = 278 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE; 279 mixer->rc_setup_packet->bRequest = UAC_GET_MEM; 280 mixer->rc_setup_packet->wValue = cpu_to_le16(0); 281 mixer->rc_setup_packet->wIndex = cpu_to_le16(0); 282 mixer->rc_setup_packet->wLength = cpu_to_le16(len); 283 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev, 284 usb_rcvctrlpipe(mixer->chip->dev, 0), 285 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len, 286 snd_usb_soundblaster_remote_complete, mixer); 287 return 0; 288} 289 290#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info 291 292static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 293{ 294 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8; 295 return 0; 296} 297 298static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer, 299 int value, int index) 300{ 301 struct snd_usb_audio *chip = mixer->chip; 302 int err; 303 304 err = snd_usb_lock_shutdown(chip); 305 if (err < 0) 306 return err; 307 308 if (chip->usb_id == USB_ID(0x041e, 0x3042)) 309 err = snd_usb_ctl_msg(chip->dev, 310 usb_sndctrlpipe(chip->dev, 0), 0x24, 311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 312 !value, 0, NULL, 0); 313 /* USB X-Fi S51 Pro */ 314 if (chip->usb_id == USB_ID(0x041e, 0x30df)) 315 err = snd_usb_ctl_msg(chip->dev, 316 usb_sndctrlpipe(chip->dev, 0), 0x24, 317 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 318 !value, 0, NULL, 0); 319 else 320 err = snd_usb_ctl_msg(chip->dev, 321 usb_sndctrlpipe(chip->dev, 0), 0x24, 322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 323 value, index + 2, NULL, 0); 324 snd_usb_unlock_shutdown(chip); 325 return err; 326} 327 328static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, 329 struct snd_ctl_elem_value *ucontrol) 330{ 331 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 332 struct usb_mixer_interface *mixer = list->mixer; 333 int index = kcontrol->private_value & 0xff; 334 unsigned int value = ucontrol->value.integer.value[0]; 335 int old_value = kcontrol->private_value >> 8; 336 int err; 337 338 if (value > 1) 339 return -EINVAL; 340 if (value == old_value) 341 return 0; 342 kcontrol->private_value = (value << 8) | index; 343 err = snd_audigy2nx_led_update(mixer, value, index); 344 return err < 0 ? err : 1; 345} 346 347static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list) 348{ 349 int priv_value = list->kctl->private_value; 350 351 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8, 352 priv_value & 0xff); 353} 354 355/* name and private_value are set dynamically */ 356static const struct snd_kcontrol_new snd_audigy2nx_control = { 357 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 358 .info = snd_audigy2nx_led_info, 359 .get = snd_audigy2nx_led_get, 360 .put = snd_audigy2nx_led_put, 361}; 362 363static const char * const snd_audigy2nx_led_names[] = { 364 "CMSS LED Switch", 365 "Power LED Switch", 366 "Dolby Digital LED Switch", 367}; 368 369static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer) 370{ 371 int i, err; 372 373 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) { 374 struct snd_kcontrol_new knew; 375 376 /* USB X-Fi S51 doesn't have a CMSS LED */ 377 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0) 378 continue; 379 /* USB X-Fi S51 Pro doesn't have one either */ 380 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0) 381 continue; 382 if (i > 1 && /* Live24ext has 2 LEDs only */ 383 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 384 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) || 385 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) || 386 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))) 387 break; 388 389 knew = snd_audigy2nx_control; 390 knew.name = snd_audigy2nx_led_names[i]; 391 knew.private_value = (1 << 8) | i; /* LED on as default */ 392 err = add_single_ctl_with_resume(mixer, 0, 393 snd_audigy2nx_led_resume, 394 &knew, NULL); 395 if (err < 0) 396 return err; 397 } 398 return 0; 399} 400 401static void snd_audigy2nx_proc_read(struct snd_info_entry *entry, 402 struct snd_info_buffer *buffer) 403{ 404 static const struct sb_jack { 405 int unitid; 406 const char *name; 407 } jacks_audigy2nx[] = { 408 {4, "dig in "}, 409 {7, "line in"}, 410 {19, "spk out"}, 411 {20, "hph out"}, 412 {-1, NULL} 413 }, jacks_live24ext[] = { 414 {4, "line in"}, /* &1=Line, &2=Mic*/ 415 {3, "hph out"}, /* headphones */ 416 {0, "RC "}, /* last command, 6 bytes see rc_config above */ 417 {-1, NULL} 418 }; 419 const struct sb_jack *jacks; 420 struct usb_mixer_interface *mixer = entry->private_data; 421 int i, err; 422 u8 buf[3]; 423 424 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname); 425 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) 426 jacks = jacks_audigy2nx; 427 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 428 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 429 jacks = jacks_live24ext; 430 else 431 return; 432 433 for (i = 0; jacks[i].name; ++i) { 434 snd_iprintf(buffer, "%s: ", jacks[i].name); 435 err = snd_usb_lock_shutdown(mixer->chip); 436 if (err < 0) 437 return; 438 err = snd_usb_ctl_msg(mixer->chip->dev, 439 usb_rcvctrlpipe(mixer->chip->dev, 0), 440 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS | 441 USB_RECIP_INTERFACE, 0, 442 jacks[i].unitid << 8, buf, 3); 443 snd_usb_unlock_shutdown(mixer->chip); 444 if (err == 3 && (buf[0] == 3 || buf[0] == 6)) 445 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]); 446 else 447 snd_iprintf(buffer, "?\n"); 448 } 449} 450 451/* EMU0204 */ 452static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol, 453 struct snd_ctl_elem_info *uinfo) 454{ 455 static const char * const texts[2] = {"1/2", "3/4"}; 456 457 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 458} 459 460static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol, 461 struct snd_ctl_elem_value *ucontrol) 462{ 463 ucontrol->value.enumerated.item[0] = kcontrol->private_value; 464 return 0; 465} 466 467static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer, 468 int value) 469{ 470 struct snd_usb_audio *chip = mixer->chip; 471 int err; 472 unsigned char buf[2]; 473 474 err = snd_usb_lock_shutdown(chip); 475 if (err < 0) 476 return err; 477 478 buf[0] = 0x01; 479 buf[1] = value ? 0x02 : 0x01; 480 err = snd_usb_ctl_msg(chip->dev, 481 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, 482 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 483 0x0400, 0x0e00, buf, 2); 484 snd_usb_unlock_shutdown(chip); 485 return err; 486} 487 488static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol, 489 struct snd_ctl_elem_value *ucontrol) 490{ 491 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 492 struct usb_mixer_interface *mixer = list->mixer; 493 unsigned int value = ucontrol->value.enumerated.item[0]; 494 int err; 495 496 if (value > 1) 497 return -EINVAL; 498 499 if (value == kcontrol->private_value) 500 return 0; 501 502 kcontrol->private_value = value; 503 err = snd_emu0204_ch_switch_update(mixer, value); 504 return err < 0 ? err : 1; 505} 506 507static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list) 508{ 509 return snd_emu0204_ch_switch_update(list->mixer, 510 list->kctl->private_value); 511} 512 513static const struct snd_kcontrol_new snd_emu0204_control = { 514 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 515 .name = "Front Jack Channels", 516 .info = snd_emu0204_ch_switch_info, 517 .get = snd_emu0204_ch_switch_get, 518 .put = snd_emu0204_ch_switch_put, 519 .private_value = 0, 520}; 521 522static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer) 523{ 524 return add_single_ctl_with_resume(mixer, 0, 525 snd_emu0204_ch_switch_resume, 526 &snd_emu0204_control, NULL); 527} 528 529/* ASUS Xonar U1 / U3 controls */ 530 531static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol, 532 struct snd_ctl_elem_value *ucontrol) 533{ 534 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02); 535 return 0; 536} 537 538static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer, 539 unsigned char status) 540{ 541 struct snd_usb_audio *chip = mixer->chip; 542 int err; 543 544 err = snd_usb_lock_shutdown(chip); 545 if (err < 0) 546 return err; 547 err = snd_usb_ctl_msg(chip->dev, 548 usb_sndctrlpipe(chip->dev, 0), 0x08, 549 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 550 50, 0, &status, 1); 551 snd_usb_unlock_shutdown(chip); 552 return err; 553} 554 555static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol, 556 struct snd_ctl_elem_value *ucontrol) 557{ 558 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 559 u8 old_status, new_status; 560 int err; 561 562 old_status = kcontrol->private_value; 563 if (ucontrol->value.integer.value[0]) 564 new_status = old_status | 0x02; 565 else 566 new_status = old_status & ~0x02; 567 if (new_status == old_status) 568 return 0; 569 570 kcontrol->private_value = new_status; 571 err = snd_xonar_u1_switch_update(list->mixer, new_status); 572 return err < 0 ? err : 1; 573} 574 575static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list) 576{ 577 return snd_xonar_u1_switch_update(list->mixer, 578 list->kctl->private_value); 579} 580 581static const struct snd_kcontrol_new snd_xonar_u1_output_switch = { 582 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 583 .name = "Digital Playback Switch", 584 .info = snd_ctl_boolean_mono_info, 585 .get = snd_xonar_u1_switch_get, 586 .put = snd_xonar_u1_switch_put, 587 .private_value = 0x05, 588}; 589 590static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer) 591{ 592 return add_single_ctl_with_resume(mixer, 0, 593 snd_xonar_u1_switch_resume, 594 &snd_xonar_u1_output_switch, NULL); 595} 596 597/* Digidesign Mbox 1 clock source switch (internal/spdif) */ 598 599static int snd_mbox1_switch_get(struct snd_kcontrol *kctl, 600 struct snd_ctl_elem_value *ucontrol) 601{ 602 ucontrol->value.enumerated.item[0] = kctl->private_value; 603 return 0; 604} 605 606static int snd_mbox1_switch_update(struct usb_mixer_interface *mixer, int val) 607{ 608 struct snd_usb_audio *chip = mixer->chip; 609 int err; 610 unsigned char buff[3]; 611 612 err = snd_usb_lock_shutdown(chip); 613 if (err < 0) 614 return err; 615 616 /* Prepare for magic command to toggle clock source */ 617 err = snd_usb_ctl_msg(chip->dev, 618 usb_rcvctrlpipe(chip->dev, 0), 0x81, 619 USB_DIR_IN | 620 USB_TYPE_CLASS | 621 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1); 622 if (err < 0) 623 goto err; 624 err = snd_usb_ctl_msg(chip->dev, 625 usb_rcvctrlpipe(chip->dev, 0), 0x81, 626 USB_DIR_IN | 627 USB_TYPE_CLASS | 628 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); 629 if (err < 0) 630 goto err; 631 632 /* 2 possibilities: Internal -> send sample rate 633 * S/PDIF sync -> send zeroes 634 * NB: Sample rate locked to 48kHz on purpose to 635 * prevent user from resetting the sample rate 636 * while S/PDIF sync is enabled and confusing 637 * this configuration. 638 */ 639 if (val == 0) { 640 buff[0] = 0x80; 641 buff[1] = 0xbb; 642 buff[2] = 0x00; 643 } else { 644 buff[0] = buff[1] = buff[2] = 0x00; 645 } 646 647 /* Send the magic command to toggle the clock source */ 648 err = snd_usb_ctl_msg(chip->dev, 649 usb_sndctrlpipe(chip->dev, 0), 0x1, 650 USB_TYPE_CLASS | 651 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); 652 if (err < 0) 653 goto err; 654 err = snd_usb_ctl_msg(chip->dev, 655 usb_rcvctrlpipe(chip->dev, 0), 0x81, 656 USB_DIR_IN | 657 USB_TYPE_CLASS | 658 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); 659 if (err < 0) 660 goto err; 661 err = snd_usb_ctl_msg(chip->dev, 662 usb_rcvctrlpipe(chip->dev, 0), 0x81, 663 USB_DIR_IN | 664 USB_TYPE_CLASS | 665 USB_RECIP_ENDPOINT, 0x100, 0x2, buff, 3); 666 if (err < 0) 667 goto err; 668 669err: 670 snd_usb_unlock_shutdown(chip); 671 return err; 672} 673 674static int snd_mbox1_switch_put(struct snd_kcontrol *kctl, 675 struct snd_ctl_elem_value *ucontrol) 676{ 677 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 678 struct usb_mixer_interface *mixer = list->mixer; 679 int err; 680 bool cur_val, new_val; 681 682 cur_val = kctl->private_value; 683 new_val = ucontrol->value.enumerated.item[0]; 684 if (cur_val == new_val) 685 return 0; 686 687 kctl->private_value = new_val; 688 err = snd_mbox1_switch_update(mixer, new_val); 689 return err < 0 ? err : 1; 690} 691 692static int snd_mbox1_switch_info(struct snd_kcontrol *kcontrol, 693 struct snd_ctl_elem_info *uinfo) 694{ 695 static const char *const texts[2] = { 696 "Internal", 697 "S/PDIF" 698 }; 699 700 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 701} 702 703static int snd_mbox1_switch_resume(struct usb_mixer_elem_list *list) 704{ 705 return snd_mbox1_switch_update(list->mixer, list->kctl->private_value); 706} 707 708static const struct snd_kcontrol_new snd_mbox1_switch = { 709 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 710 .name = "Clock Source", 711 .index = 0, 712 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 713 .info = snd_mbox1_switch_info, 714 .get = snd_mbox1_switch_get, 715 .put = snd_mbox1_switch_put, 716 .private_value = 0 717}; 718 719static int snd_mbox1_create_sync_switch(struct usb_mixer_interface *mixer) 720{ 721 return add_single_ctl_with_resume(mixer, 0, 722 snd_mbox1_switch_resume, 723 &snd_mbox1_switch, NULL); 724} 725 726/* Native Instruments device quirks */ 727 728#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex)) 729 730static int snd_ni_control_init_val(struct usb_mixer_interface *mixer, 731 struct snd_kcontrol *kctl) 732{ 733 struct usb_device *dev = mixer->chip->dev; 734 unsigned int pval = kctl->private_value; 735 u8 value; 736 int err; 737 738 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 739 (pval >> 16) & 0xff, 740 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 741 0, pval & 0xffff, &value, 1); 742 if (err < 0) { 743 dev_err(&dev->dev, 744 "unable to issue vendor read request (ret = %d)", err); 745 return err; 746 } 747 748 kctl->private_value |= ((unsigned int)value << 24); 749 return 0; 750} 751 752static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol, 753 struct snd_ctl_elem_value *ucontrol) 754{ 755 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24; 756 return 0; 757} 758 759static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list) 760{ 761 struct snd_usb_audio *chip = list->mixer->chip; 762 unsigned int pval = list->kctl->private_value; 763 int err; 764 765 err = snd_usb_lock_shutdown(chip); 766 if (err < 0) 767 return err; 768 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 769 (pval >> 16) & 0xff, 770 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 771 pval >> 24, pval & 0xffff, NULL, 0, 1000); 772 snd_usb_unlock_shutdown(chip); 773 return err; 774} 775 776static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol, 777 struct snd_ctl_elem_value *ucontrol) 778{ 779 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 780 u8 oldval = (kcontrol->private_value >> 24) & 0xff; 781 u8 newval = ucontrol->value.integer.value[0]; 782 int err; 783 784 if (oldval == newval) 785 return 0; 786 787 kcontrol->private_value &= ~(0xff << 24); 788 kcontrol->private_value |= (unsigned int)newval << 24; 789 err = snd_ni_update_cur_val(list); 790 return err < 0 ? err : 1; 791} 792 793static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = { 794 { 795 .name = "Direct Thru Channel A", 796 .private_value = _MAKE_NI_CONTROL(0x01, 0x03), 797 }, 798 { 799 .name = "Direct Thru Channel B", 800 .private_value = _MAKE_NI_CONTROL(0x01, 0x05), 801 }, 802 { 803 .name = "Phono Input Channel A", 804 .private_value = _MAKE_NI_CONTROL(0x02, 0x03), 805 }, 806 { 807 .name = "Phono Input Channel B", 808 .private_value = _MAKE_NI_CONTROL(0x02, 0x05), 809 }, 810}; 811 812static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = { 813 { 814 .name = "Direct Thru Channel A", 815 .private_value = _MAKE_NI_CONTROL(0x01, 0x03), 816 }, 817 { 818 .name = "Direct Thru Channel B", 819 .private_value = _MAKE_NI_CONTROL(0x01, 0x05), 820 }, 821 { 822 .name = "Direct Thru Channel C", 823 .private_value = _MAKE_NI_CONTROL(0x01, 0x07), 824 }, 825 { 826 .name = "Direct Thru Channel D", 827 .private_value = _MAKE_NI_CONTROL(0x01, 0x09), 828 }, 829 { 830 .name = "Phono Input Channel A", 831 .private_value = _MAKE_NI_CONTROL(0x02, 0x03), 832 }, 833 { 834 .name = "Phono Input Channel B", 835 .private_value = _MAKE_NI_CONTROL(0x02, 0x05), 836 }, 837 { 838 .name = "Phono Input Channel C", 839 .private_value = _MAKE_NI_CONTROL(0x02, 0x07), 840 }, 841 { 842 .name = "Phono Input Channel D", 843 .private_value = _MAKE_NI_CONTROL(0x02, 0x09), 844 }, 845}; 846 847static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer, 848 const struct snd_kcontrol_new *kc, 849 unsigned int count) 850{ 851 int i, err = 0; 852 struct snd_kcontrol_new template = { 853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 854 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 855 .get = snd_nativeinstruments_control_get, 856 .put = snd_nativeinstruments_control_put, 857 .info = snd_ctl_boolean_mono_info, 858 }; 859 860 for (i = 0; i < count; i++) { 861 struct usb_mixer_elem_list *list; 862 863 template.name = kc[i].name; 864 template.private_value = kc[i].private_value; 865 866 err = add_single_ctl_with_resume(mixer, 0, 867 snd_ni_update_cur_val, 868 &template, &list); 869 if (err < 0) 870 break; 871 snd_ni_control_init_val(mixer, list->kctl); 872 } 873 874 return err; 875} 876 877/* M-Audio FastTrack Ultra quirks */ 878/* FTU Effect switch (also used by C400/C600) */ 879static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol, 880 struct snd_ctl_elem_info *uinfo) 881{ 882 static const char *const texts[8] = { 883 "Room 1", "Room 2", "Room 3", "Hall 1", 884 "Hall 2", "Plate", "Delay", "Echo" 885 }; 886 887 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 888} 889 890static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer, 891 struct snd_kcontrol *kctl) 892{ 893 struct usb_device *dev = mixer->chip->dev; 894 unsigned int pval = kctl->private_value; 895 int err; 896 unsigned char value[2]; 897 898 value[0] = 0x00; 899 value[1] = 0x00; 900 901 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR, 902 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 903 pval & 0xff00, 904 snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8), 905 value, 2); 906 if (err < 0) 907 return err; 908 909 kctl->private_value |= (unsigned int)value[0] << 24; 910 return 0; 911} 912 913static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl, 914 struct snd_ctl_elem_value *ucontrol) 915{ 916 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24; 917 return 0; 918} 919 920static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list) 921{ 922 struct snd_usb_audio *chip = list->mixer->chip; 923 unsigned int pval = list->kctl->private_value; 924 unsigned char value[2]; 925 int err; 926 927 value[0] = pval >> 24; 928 value[1] = 0; 929 930 err = snd_usb_lock_shutdown(chip); 931 if (err < 0) 932 return err; 933 err = snd_usb_ctl_msg(chip->dev, 934 usb_sndctrlpipe(chip->dev, 0), 935 UAC_SET_CUR, 936 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 937 pval & 0xff00, 938 snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8), 939 value, 2); 940 snd_usb_unlock_shutdown(chip); 941 return err; 942} 943 944static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl, 945 struct snd_ctl_elem_value *ucontrol) 946{ 947 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 948 unsigned int pval = list->kctl->private_value; 949 int cur_val, err, new_val; 950 951 cur_val = pval >> 24; 952 new_val = ucontrol->value.enumerated.item[0]; 953 if (cur_val == new_val) 954 return 0; 955 956 kctl->private_value &= ~(0xff << 24); 957 kctl->private_value |= new_val << 24; 958 err = snd_ftu_eff_switch_update(list); 959 return err < 0 ? err : 1; 960} 961 962static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer, 963 int validx, int bUnitID) 964{ 965 static struct snd_kcontrol_new template = { 966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 967 .name = "Effect Program Switch", 968 .index = 0, 969 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 970 .info = snd_ftu_eff_switch_info, 971 .get = snd_ftu_eff_switch_get, 972 .put = snd_ftu_eff_switch_put 973 }; 974 struct usb_mixer_elem_list *list; 975 int err; 976 977 err = add_single_ctl_with_resume(mixer, bUnitID, 978 snd_ftu_eff_switch_update, 979 &template, &list); 980 if (err < 0) 981 return err; 982 list->kctl->private_value = (validx << 8) | bUnitID; 983 snd_ftu_eff_switch_init(mixer, list->kctl); 984 return 0; 985} 986 987/* Create volume controls for FTU devices*/ 988static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer) 989{ 990 char name[64]; 991 unsigned int control, cmask; 992 int in, out, err; 993 994 const unsigned int id = 5; 995 const int val_type = USB_MIXER_S16; 996 997 for (out = 0; out < 8; out++) { 998 control = out + 1; 999 for (in = 0; in < 8; in++) { 1000 cmask = 1 << in; 1001 snprintf(name, sizeof(name), 1002 "AIn%d - Out%d Capture Volume", 1003 in + 1, out + 1); 1004 err = snd_create_std_mono_ctl(mixer, id, control, 1005 cmask, val_type, name, 1006 &snd_usb_mixer_vol_tlv); 1007 if (err < 0) 1008 return err; 1009 } 1010 for (in = 8; in < 16; in++) { 1011 cmask = 1 << in; 1012 snprintf(name, sizeof(name), 1013 "DIn%d - Out%d Playback Volume", 1014 in - 7, out + 1); 1015 err = snd_create_std_mono_ctl(mixer, id, control, 1016 cmask, val_type, name, 1017 &snd_usb_mixer_vol_tlv); 1018 if (err < 0) 1019 return err; 1020 } 1021 } 1022 1023 return 0; 1024} 1025 1026/* This control needs a volume quirk, see mixer.c */ 1027static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer) 1028{ 1029 static const char name[] = "Effect Volume"; 1030 const unsigned int id = 6; 1031 const int val_type = USB_MIXER_U8; 1032 const unsigned int control = 2; 1033 const unsigned int cmask = 0; 1034 1035 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1036 name, snd_usb_mixer_vol_tlv); 1037} 1038 1039/* This control needs a volume quirk, see mixer.c */ 1040static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer) 1041{ 1042 static const char name[] = "Effect Duration"; 1043 const unsigned int id = 6; 1044 const int val_type = USB_MIXER_S16; 1045 const unsigned int control = 3; 1046 const unsigned int cmask = 0; 1047 1048 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1049 name, snd_usb_mixer_vol_tlv); 1050} 1051 1052/* This control needs a volume quirk, see mixer.c */ 1053static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) 1054{ 1055 static const char name[] = "Effect Feedback Volume"; 1056 const unsigned int id = 6; 1057 const int val_type = USB_MIXER_U8; 1058 const unsigned int control = 4; 1059 const unsigned int cmask = 0; 1060 1061 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1062 name, NULL); 1063} 1064 1065static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer) 1066{ 1067 unsigned int cmask; 1068 int err, ch; 1069 char name[48]; 1070 1071 const unsigned int id = 7; 1072 const int val_type = USB_MIXER_S16; 1073 const unsigned int control = 7; 1074 1075 for (ch = 0; ch < 4; ++ch) { 1076 cmask = 1 << ch; 1077 snprintf(name, sizeof(name), 1078 "Effect Return %d Volume", ch + 1); 1079 err = snd_create_std_mono_ctl(mixer, id, control, 1080 cmask, val_type, name, 1081 snd_usb_mixer_vol_tlv); 1082 if (err < 0) 1083 return err; 1084 } 1085 1086 return 0; 1087} 1088 1089static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer) 1090{ 1091 unsigned int cmask; 1092 int err, ch; 1093 char name[48]; 1094 1095 const unsigned int id = 5; 1096 const int val_type = USB_MIXER_S16; 1097 const unsigned int control = 9; 1098 1099 for (ch = 0; ch < 8; ++ch) { 1100 cmask = 1 << ch; 1101 snprintf(name, sizeof(name), 1102 "Effect Send AIn%d Volume", ch + 1); 1103 err = snd_create_std_mono_ctl(mixer, id, control, cmask, 1104 val_type, name, 1105 snd_usb_mixer_vol_tlv); 1106 if (err < 0) 1107 return err; 1108 } 1109 for (ch = 8; ch < 16; ++ch) { 1110 cmask = 1 << ch; 1111 snprintf(name, sizeof(name), 1112 "Effect Send DIn%d Volume", ch - 7); 1113 err = snd_create_std_mono_ctl(mixer, id, control, cmask, 1114 val_type, name, 1115 snd_usb_mixer_vol_tlv); 1116 if (err < 0) 1117 return err; 1118 } 1119 return 0; 1120} 1121 1122static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer) 1123{ 1124 int err; 1125 1126 err = snd_ftu_create_volume_ctls(mixer); 1127 if (err < 0) 1128 return err; 1129 1130 err = snd_ftu_create_effect_switch(mixer, 1, 6); 1131 if (err < 0) 1132 return err; 1133 1134 err = snd_ftu_create_effect_volume_ctl(mixer); 1135 if (err < 0) 1136 return err; 1137 1138 err = snd_ftu_create_effect_duration_ctl(mixer); 1139 if (err < 0) 1140 return err; 1141 1142 err = snd_ftu_create_effect_feedback_ctl(mixer); 1143 if (err < 0) 1144 return err; 1145 1146 err = snd_ftu_create_effect_return_ctls(mixer); 1147 if (err < 0) 1148 return err; 1149 1150 err = snd_ftu_create_effect_send_ctls(mixer); 1151 if (err < 0) 1152 return err; 1153 1154 return 0; 1155} 1156 1157void snd_emuusb_set_samplerate(struct snd_usb_audio *chip, 1158 unsigned char samplerate_id) 1159{ 1160 struct usb_mixer_interface *mixer; 1161 struct usb_mixer_elem_info *cval; 1162 int unitid = 12; /* SampleRate ExtensionUnit ID */ 1163 1164 list_for_each_entry(mixer, &chip->mixer_list, list) { 1165 if (mixer->id_elems[unitid]) { 1166 cval = mixer_elem_list_to_info(mixer->id_elems[unitid]); 1167 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, 1168 cval->control << 8, 1169 samplerate_id); 1170 snd_usb_mixer_notify_id(mixer, unitid); 1171 break; 1172 } 1173 } 1174} 1175 1176/* M-Audio Fast Track C400/C600 */ 1177/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */ 1178static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer) 1179{ 1180 char name[64]; 1181 unsigned int cmask, offset; 1182 int out, chan, err; 1183 int num_outs = 0; 1184 int num_ins = 0; 1185 1186 const unsigned int id = 0x40; 1187 const int val_type = USB_MIXER_S16; 1188 const int control = 1; 1189 1190 switch (mixer->chip->usb_id) { 1191 case USB_ID(0x0763, 0x2030): 1192 num_outs = 6; 1193 num_ins = 4; 1194 break; 1195 case USB_ID(0x0763, 0x2031): 1196 num_outs = 8; 1197 num_ins = 6; 1198 break; 1199 } 1200 1201 for (chan = 0; chan < num_outs + num_ins; chan++) { 1202 for (out = 0; out < num_outs; out++) { 1203 if (chan < num_outs) { 1204 snprintf(name, sizeof(name), 1205 "PCM%d-Out%d Playback Volume", 1206 chan + 1, out + 1); 1207 } else { 1208 snprintf(name, sizeof(name), 1209 "In%d-Out%d Playback Volume", 1210 chan - num_outs + 1, out + 1); 1211 } 1212 1213 cmask = (out == 0) ? 0 : 1 << (out - 1); 1214 offset = chan * num_outs; 1215 err = snd_create_std_mono_ctl_offset(mixer, id, control, 1216 cmask, val_type, offset, name, 1217 &snd_usb_mixer_vol_tlv); 1218 if (err < 0) 1219 return err; 1220 } 1221 } 1222 1223 return 0; 1224} 1225 1226/* This control needs a volume quirk, see mixer.c */ 1227static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer) 1228{ 1229 static const char name[] = "Effect Volume"; 1230 const unsigned int id = 0x43; 1231 const int val_type = USB_MIXER_U8; 1232 const unsigned int control = 3; 1233 const unsigned int cmask = 0; 1234 1235 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1236 name, snd_usb_mixer_vol_tlv); 1237} 1238 1239/* This control needs a volume quirk, see mixer.c */ 1240static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer) 1241{ 1242 static const char name[] = "Effect Duration"; 1243 const unsigned int id = 0x43; 1244 const int val_type = USB_MIXER_S16; 1245 const unsigned int control = 4; 1246 const unsigned int cmask = 0; 1247 1248 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1249 name, snd_usb_mixer_vol_tlv); 1250} 1251 1252/* This control needs a volume quirk, see mixer.c */ 1253static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) 1254{ 1255 static const char name[] = "Effect Feedback Volume"; 1256 const unsigned int id = 0x43; 1257 const int val_type = USB_MIXER_U8; 1258 const unsigned int control = 5; 1259 const unsigned int cmask = 0; 1260 1261 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1262 name, NULL); 1263} 1264 1265static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer) 1266{ 1267 char name[64]; 1268 unsigned int cmask; 1269 int chan, err; 1270 int num_outs = 0; 1271 int num_ins = 0; 1272 1273 const unsigned int id = 0x42; 1274 const int val_type = USB_MIXER_S16; 1275 const int control = 1; 1276 1277 switch (mixer->chip->usb_id) { 1278 case USB_ID(0x0763, 0x2030): 1279 num_outs = 6; 1280 num_ins = 4; 1281 break; 1282 case USB_ID(0x0763, 0x2031): 1283 num_outs = 8; 1284 num_ins = 6; 1285 break; 1286 } 1287 1288 for (chan = 0; chan < num_outs + num_ins; chan++) { 1289 if (chan < num_outs) { 1290 snprintf(name, sizeof(name), 1291 "Effect Send DOut%d", 1292 chan + 1); 1293 } else { 1294 snprintf(name, sizeof(name), 1295 "Effect Send AIn%d", 1296 chan - num_outs + 1); 1297 } 1298 1299 cmask = (chan == 0) ? 0 : 1 << (chan - 1); 1300 err = snd_create_std_mono_ctl(mixer, id, control, 1301 cmask, val_type, name, 1302 &snd_usb_mixer_vol_tlv); 1303 if (err < 0) 1304 return err; 1305 } 1306 1307 return 0; 1308} 1309 1310static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer) 1311{ 1312 char name[64]; 1313 unsigned int cmask; 1314 int chan, err; 1315 int num_outs = 0; 1316 int offset = 0; 1317 1318 const unsigned int id = 0x40; 1319 const int val_type = USB_MIXER_S16; 1320 const int control = 1; 1321 1322 switch (mixer->chip->usb_id) { 1323 case USB_ID(0x0763, 0x2030): 1324 num_outs = 6; 1325 offset = 0x3c; 1326 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */ 1327 break; 1328 case USB_ID(0x0763, 0x2031): 1329 num_outs = 8; 1330 offset = 0x70; 1331 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */ 1332 break; 1333 } 1334 1335 for (chan = 0; chan < num_outs; chan++) { 1336 snprintf(name, sizeof(name), 1337 "Effect Return %d", 1338 chan + 1); 1339 1340 cmask = (chan == 0) ? 0 : 1341 1 << (chan + (chan % 2) * num_outs - 1); 1342 err = snd_create_std_mono_ctl_offset(mixer, id, control, 1343 cmask, val_type, offset, name, 1344 &snd_usb_mixer_vol_tlv); 1345 if (err < 0) 1346 return err; 1347 } 1348 1349 return 0; 1350} 1351 1352static int snd_c400_create_mixer(struct usb_mixer_interface *mixer) 1353{ 1354 int err; 1355 1356 err = snd_c400_create_vol_ctls(mixer); 1357 if (err < 0) 1358 return err; 1359 1360 err = snd_c400_create_effect_vol_ctls(mixer); 1361 if (err < 0) 1362 return err; 1363 1364 err = snd_c400_create_effect_ret_vol_ctls(mixer); 1365 if (err < 0) 1366 return err; 1367 1368 err = snd_ftu_create_effect_switch(mixer, 2, 0x43); 1369 if (err < 0) 1370 return err; 1371 1372 err = snd_c400_create_effect_volume_ctl(mixer); 1373 if (err < 0) 1374 return err; 1375 1376 err = snd_c400_create_effect_duration_ctl(mixer); 1377 if (err < 0) 1378 return err; 1379 1380 err = snd_c400_create_effect_feedback_ctl(mixer); 1381 if (err < 0) 1382 return err; 1383 1384 return 0; 1385} 1386 1387/* 1388 * The mixer units for Ebox-44 are corrupt, and even where they 1389 * are valid they presents mono controls as L and R channels of 1390 * stereo. So we provide a good mixer here. 1391 */ 1392static const struct std_mono_table ebox44_table[] = { 1393 { 1394 .unitid = 4, 1395 .control = 1, 1396 .cmask = 0x0, 1397 .val_type = USB_MIXER_INV_BOOLEAN, 1398 .name = "Headphone Playback Switch" 1399 }, 1400 { 1401 .unitid = 4, 1402 .control = 2, 1403 .cmask = 0x1, 1404 .val_type = USB_MIXER_S16, 1405 .name = "Headphone A Mix Playback Volume" 1406 }, 1407 { 1408 .unitid = 4, 1409 .control = 2, 1410 .cmask = 0x2, 1411 .val_type = USB_MIXER_S16, 1412 .name = "Headphone B Mix Playback Volume" 1413 }, 1414 1415 { 1416 .unitid = 7, 1417 .control = 1, 1418 .cmask = 0x0, 1419 .val_type = USB_MIXER_INV_BOOLEAN, 1420 .name = "Output Playback Switch" 1421 }, 1422 { 1423 .unitid = 7, 1424 .control = 2, 1425 .cmask = 0x1, 1426 .val_type = USB_MIXER_S16, 1427 .name = "Output A Playback Volume" 1428 }, 1429 { 1430 .unitid = 7, 1431 .control = 2, 1432 .cmask = 0x2, 1433 .val_type = USB_MIXER_S16, 1434 .name = "Output B Playback Volume" 1435 }, 1436 1437 { 1438 .unitid = 10, 1439 .control = 1, 1440 .cmask = 0x0, 1441 .val_type = USB_MIXER_INV_BOOLEAN, 1442 .name = "Input Capture Switch" 1443 }, 1444 { 1445 .unitid = 10, 1446 .control = 2, 1447 .cmask = 0x1, 1448 .val_type = USB_MIXER_S16, 1449 .name = "Input A Capture Volume" 1450 }, 1451 { 1452 .unitid = 10, 1453 .control = 2, 1454 .cmask = 0x2, 1455 .val_type = USB_MIXER_S16, 1456 .name = "Input B Capture Volume" 1457 }, 1458 1459 {} 1460}; 1461 1462/* Audio Advantage Micro II findings: 1463 * 1464 * Mapping spdif AES bits to vendor register.bit: 1465 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00 1466 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01 1467 * AES2: [0 0 0 0 0 0 0 0] 1468 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request 1469 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices 1470 * 1471 * power on values: 1472 * r2: 0x10 1473 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set 1474 * just after it to 0xa0, presumably it disables/mutes some analog 1475 * parts when there is no audio.) 1476 * r9: 0x28 1477 * 1478 * Optical transmitter on/off: 1479 * vendor register.bit: 9.1 1480 * 0 - on (0x28 register value) 1481 * 1 - off (0x2a register value) 1482 * 1483 */ 1484static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol, 1485 struct snd_ctl_elem_info *uinfo) 1486{ 1487 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1488 uinfo->count = 1; 1489 return 0; 1490} 1491 1492static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol, 1493 struct snd_ctl_elem_value *ucontrol) 1494{ 1495 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1496 struct snd_usb_audio *chip = list->mixer->chip; 1497 int err; 1498 struct usb_interface *iface; 1499 struct usb_host_interface *alts; 1500 unsigned int ep; 1501 unsigned char data[3]; 1502 int rate; 1503 1504 err = snd_usb_lock_shutdown(chip); 1505 if (err < 0) 1506 return err; 1507 1508 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff; 1509 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff; 1510 ucontrol->value.iec958.status[2] = 0x00; 1511 1512 /* use known values for that card: interface#1 altsetting#1 */ 1513 iface = usb_ifnum_to_if(chip->dev, 1); 1514 if (!iface || iface->num_altsetting < 2) { 1515 err = -EINVAL; 1516 goto end; 1517 } 1518 alts = &iface->altsetting[1]; 1519 if (get_iface_desc(alts)->bNumEndpoints < 1) { 1520 err = -EINVAL; 1521 goto end; 1522 } 1523 ep = get_endpoint(alts, 0)->bEndpointAddress; 1524 1525 err = snd_usb_ctl_msg(chip->dev, 1526 usb_rcvctrlpipe(chip->dev, 0), 1527 UAC_GET_CUR, 1528 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, 1529 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, 1530 ep, 1531 data, 1532 sizeof(data)); 1533 if (err < 0) 1534 goto end; 1535 1536 rate = data[0] | (data[1] << 8) | (data[2] << 16); 1537 ucontrol->value.iec958.status[3] = (rate == 48000) ? 1538 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100; 1539 1540 err = 0; 1541 end: 1542 snd_usb_unlock_shutdown(chip); 1543 return err; 1544} 1545 1546static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list) 1547{ 1548 struct snd_usb_audio *chip = list->mixer->chip; 1549 unsigned int pval = list->kctl->private_value; 1550 u8 reg; 1551 int err; 1552 1553 err = snd_usb_lock_shutdown(chip); 1554 if (err < 0) 1555 return err; 1556 1557 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f); 1558 err = snd_usb_ctl_msg(chip->dev, 1559 usb_sndctrlpipe(chip->dev, 0), 1560 UAC_SET_CUR, 1561 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1562 reg, 1563 2, 1564 NULL, 1565 0); 1566 if (err < 0) 1567 goto end; 1568 1569 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20; 1570 reg |= (pval >> 12) & 0x0f; 1571 err = snd_usb_ctl_msg(chip->dev, 1572 usb_sndctrlpipe(chip->dev, 0), 1573 UAC_SET_CUR, 1574 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1575 reg, 1576 3, 1577 NULL, 1578 0); 1579 if (err < 0) 1580 goto end; 1581 1582 end: 1583 snd_usb_unlock_shutdown(chip); 1584 return err; 1585} 1586 1587static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol, 1588 struct snd_ctl_elem_value *ucontrol) 1589{ 1590 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1591 unsigned int pval, pval_old; 1592 int err; 1593 1594 pval = pval_old = kcontrol->private_value; 1595 pval &= 0xfffff0f0; 1596 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8; 1597 pval |= (ucontrol->value.iec958.status[0] & 0x0f); 1598 1599 pval &= 0xffff0fff; 1600 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8; 1601 1602 /* The frequency bits in AES3 cannot be set via register access. */ 1603 1604 /* Silently ignore any bits from the request that cannot be set. */ 1605 1606 if (pval == pval_old) 1607 return 0; 1608 1609 kcontrol->private_value = pval; 1610 err = snd_microii_spdif_default_update(list); 1611 return err < 0 ? err : 1; 1612} 1613 1614static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol, 1615 struct snd_ctl_elem_value *ucontrol) 1616{ 1617 ucontrol->value.iec958.status[0] = 0x0f; 1618 ucontrol->value.iec958.status[1] = 0xff; 1619 ucontrol->value.iec958.status[2] = 0x00; 1620 ucontrol->value.iec958.status[3] = 0x00; 1621 1622 return 0; 1623} 1624 1625static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol, 1626 struct snd_ctl_elem_value *ucontrol) 1627{ 1628 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02); 1629 1630 return 0; 1631} 1632 1633static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list) 1634{ 1635 struct snd_usb_audio *chip = list->mixer->chip; 1636 u8 reg = list->kctl->private_value; 1637 int err; 1638 1639 err = snd_usb_lock_shutdown(chip); 1640 if (err < 0) 1641 return err; 1642 1643 err = snd_usb_ctl_msg(chip->dev, 1644 usb_sndctrlpipe(chip->dev, 0), 1645 UAC_SET_CUR, 1646 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1647 reg, 1648 9, 1649 NULL, 1650 0); 1651 1652 snd_usb_unlock_shutdown(chip); 1653 return err; 1654} 1655 1656static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol, 1657 struct snd_ctl_elem_value *ucontrol) 1658{ 1659 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1660 u8 reg; 1661 int err; 1662 1663 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a; 1664 if (reg != list->kctl->private_value) 1665 return 0; 1666 1667 kcontrol->private_value = reg; 1668 err = snd_microii_spdif_switch_update(list); 1669 return err < 0 ? err : 1; 1670} 1671 1672static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = { 1673 { 1674 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1675 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 1676 .info = snd_microii_spdif_info, 1677 .get = snd_microii_spdif_default_get, 1678 .put = snd_microii_spdif_default_put, 1679 .private_value = 0x00000100UL,/* reset value */ 1680 }, 1681 { 1682 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1683 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1684 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK), 1685 .info = snd_microii_spdif_info, 1686 .get = snd_microii_spdif_mask_get, 1687 }, 1688 { 1689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1690 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 1691 .info = snd_ctl_boolean_mono_info, 1692 .get = snd_microii_spdif_switch_get, 1693 .put = snd_microii_spdif_switch_put, 1694 .private_value = 0x00000028UL,/* reset value */ 1695 } 1696}; 1697 1698static int snd_microii_controls_create(struct usb_mixer_interface *mixer) 1699{ 1700 int err, i; 1701 static const usb_mixer_elem_resume_func_t resume_funcs[] = { 1702 snd_microii_spdif_default_update, 1703 NULL, 1704 snd_microii_spdif_switch_update 1705 }; 1706 1707 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) { 1708 err = add_single_ctl_with_resume(mixer, 0, 1709 resume_funcs[i], 1710 &snd_microii_mixer_spdif[i], 1711 NULL); 1712 if (err < 0) 1713 return err; 1714 } 1715 1716 return 0; 1717} 1718 1719/* Creative Sound Blaster E1 */ 1720 1721static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol, 1722 struct snd_ctl_elem_value *ucontrol) 1723{ 1724 ucontrol->value.integer.value[0] = kcontrol->private_value; 1725 return 0; 1726} 1727 1728static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer, 1729 unsigned char state) 1730{ 1731 struct snd_usb_audio *chip = mixer->chip; 1732 int err; 1733 unsigned char buff[2]; 1734 1735 buff[0] = 0x02; 1736 buff[1] = state ? 0x02 : 0x00; 1737 1738 err = snd_usb_lock_shutdown(chip); 1739 if (err < 0) 1740 return err; 1741 err = snd_usb_ctl_msg(chip->dev, 1742 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT, 1743 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 1744 0x0202, 3, buff, 2); 1745 snd_usb_unlock_shutdown(chip); 1746 return err; 1747} 1748 1749static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol, 1750 struct snd_ctl_elem_value *ucontrol) 1751{ 1752 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1753 unsigned char value = !!ucontrol->value.integer.value[0]; 1754 int err; 1755 1756 if (kcontrol->private_value == value) 1757 return 0; 1758 kcontrol->private_value = value; 1759 err = snd_soundblaster_e1_switch_update(list->mixer, value); 1760 return err < 0 ? err : 1; 1761} 1762 1763static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list) 1764{ 1765 return snd_soundblaster_e1_switch_update(list->mixer, 1766 list->kctl->private_value); 1767} 1768 1769static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol, 1770 struct snd_ctl_elem_info *uinfo) 1771{ 1772 static const char *const texts[2] = { 1773 "Mic", "Aux" 1774 }; 1775 1776 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 1777} 1778 1779static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = { 1780 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1781 .name = "Input Source", 1782 .info = snd_soundblaster_e1_switch_info, 1783 .get = snd_soundblaster_e1_switch_get, 1784 .put = snd_soundblaster_e1_switch_put, 1785 .private_value = 0, 1786}; 1787 1788static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer) 1789{ 1790 return add_single_ctl_with_resume(mixer, 0, 1791 snd_soundblaster_e1_switch_resume, 1792 &snd_soundblaster_e1_input_switch, 1793 NULL); 1794} 1795 1796static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id) 1797{ 1798 u16 buf = 0; 1799 1800 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, 1801 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 1802 ch, snd_usb_ctrl_intf(chip) | (id << 8), 1803 &buf, 2); 1804} 1805 1806static int dell_dock_mixer_init(struct usb_mixer_interface *mixer) 1807{ 1808 /* fix to 0dB playback volumes */ 1809 dell_dock_init_vol(mixer->chip, 1, 16); 1810 dell_dock_init_vol(mixer->chip, 2, 16); 1811 dell_dock_init_vol(mixer->chip, 1, 19); 1812 dell_dock_init_vol(mixer->chip, 2, 19); 1813 return 0; 1814} 1815 1816/* RME Class Compliant device quirks */ 1817 1818#define SND_RME_GET_STATUS1 23 1819#define SND_RME_GET_CURRENT_FREQ 17 1820#define SND_RME_CLK_SYSTEM_SHIFT 16 1821#define SND_RME_CLK_SYSTEM_MASK 0x1f 1822#define SND_RME_CLK_AES_SHIFT 8 1823#define SND_RME_CLK_SPDIF_SHIFT 12 1824#define SND_RME_CLK_AES_SPDIF_MASK 0xf 1825#define SND_RME_CLK_SYNC_SHIFT 6 1826#define SND_RME_CLK_SYNC_MASK 0x3 1827#define SND_RME_CLK_FREQMUL_SHIFT 18 1828#define SND_RME_CLK_FREQMUL_MASK 0x7 1829#define SND_RME_CLK_SYSTEM(x) \ 1830 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK) 1831#define SND_RME_CLK_AES(x) \ 1832 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) 1833#define SND_RME_CLK_SPDIF(x) \ 1834 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) 1835#define SND_RME_CLK_SYNC(x) \ 1836 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK) 1837#define SND_RME_CLK_FREQMUL(x) \ 1838 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK) 1839#define SND_RME_CLK_AES_LOCK 0x1 1840#define SND_RME_CLK_AES_SYNC 0x4 1841#define SND_RME_CLK_SPDIF_LOCK 0x2 1842#define SND_RME_CLK_SPDIF_SYNC 0x8 1843#define SND_RME_SPDIF_IF_SHIFT 4 1844#define SND_RME_SPDIF_FORMAT_SHIFT 5 1845#define SND_RME_BINARY_MASK 0x1 1846#define SND_RME_SPDIF_IF(x) \ 1847 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK) 1848#define SND_RME_SPDIF_FORMAT(x) \ 1849 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK) 1850 1851static const u32 snd_rme_rate_table[] = { 1852 32000, 44100, 48000, 50000, 1853 64000, 88200, 96000, 100000, 1854 128000, 176400, 192000, 200000, 1855 256000, 352800, 384000, 400000, 1856 512000, 705600, 768000, 800000 1857}; 1858/* maximum number of items for AES and S/PDIF rates for above table */ 1859#define SND_RME_RATE_IDX_AES_SPDIF_NUM 12 1860 1861enum snd_rme_domain { 1862 SND_RME_DOMAIN_SYSTEM, 1863 SND_RME_DOMAIN_AES, 1864 SND_RME_DOMAIN_SPDIF 1865}; 1866 1867enum snd_rme_clock_status { 1868 SND_RME_CLOCK_NOLOCK, 1869 SND_RME_CLOCK_LOCK, 1870 SND_RME_CLOCK_SYNC 1871}; 1872 1873static int snd_rme_read_value(struct snd_usb_audio *chip, 1874 unsigned int item, 1875 u32 *value) 1876{ 1877 struct usb_device *dev = chip->dev; 1878 int err; 1879 1880 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 1881 item, 1882 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1883 0, 0, 1884 value, sizeof(*value)); 1885 if (err < 0) 1886 dev_err(&dev->dev, 1887 "unable to issue vendor read request %d (ret = %d)", 1888 item, err); 1889 return err; 1890} 1891 1892static int snd_rme_get_status1(struct snd_kcontrol *kcontrol, 1893 u32 *status1) 1894{ 1895 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1896 struct snd_usb_audio *chip = list->mixer->chip; 1897 int err; 1898 1899 err = snd_usb_lock_shutdown(chip); 1900 if (err < 0) 1901 return err; 1902 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1); 1903 snd_usb_unlock_shutdown(chip); 1904 return err; 1905} 1906 1907static int snd_rme_rate_get(struct snd_kcontrol *kcontrol, 1908 struct snd_ctl_elem_value *ucontrol) 1909{ 1910 u32 status1; 1911 u32 rate = 0; 1912 int idx; 1913 int err; 1914 1915 err = snd_rme_get_status1(kcontrol, &status1); 1916 if (err < 0) 1917 return err; 1918 switch (kcontrol->private_value) { 1919 case SND_RME_DOMAIN_SYSTEM: 1920 idx = SND_RME_CLK_SYSTEM(status1); 1921 if (idx < ARRAY_SIZE(snd_rme_rate_table)) 1922 rate = snd_rme_rate_table[idx]; 1923 break; 1924 case SND_RME_DOMAIN_AES: 1925 idx = SND_RME_CLK_AES(status1); 1926 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) 1927 rate = snd_rme_rate_table[idx]; 1928 break; 1929 case SND_RME_DOMAIN_SPDIF: 1930 idx = SND_RME_CLK_SPDIF(status1); 1931 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) 1932 rate = snd_rme_rate_table[idx]; 1933 break; 1934 default: 1935 return -EINVAL; 1936 } 1937 ucontrol->value.integer.value[0] = rate; 1938 return 0; 1939} 1940 1941static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol, 1942 struct snd_ctl_elem_value *ucontrol) 1943{ 1944 u32 status1; 1945 int idx = SND_RME_CLOCK_NOLOCK; 1946 int err; 1947 1948 err = snd_rme_get_status1(kcontrol, &status1); 1949 if (err < 0) 1950 return err; 1951 switch (kcontrol->private_value) { 1952 case SND_RME_DOMAIN_AES: /* AES */ 1953 if (status1 & SND_RME_CLK_AES_SYNC) 1954 idx = SND_RME_CLOCK_SYNC; 1955 else if (status1 & SND_RME_CLK_AES_LOCK) 1956 idx = SND_RME_CLOCK_LOCK; 1957 break; 1958 case SND_RME_DOMAIN_SPDIF: /* SPDIF */ 1959 if (status1 & SND_RME_CLK_SPDIF_SYNC) 1960 idx = SND_RME_CLOCK_SYNC; 1961 else if (status1 & SND_RME_CLK_SPDIF_LOCK) 1962 idx = SND_RME_CLOCK_LOCK; 1963 break; 1964 default: 1965 return -EINVAL; 1966 } 1967 ucontrol->value.enumerated.item[0] = idx; 1968 return 0; 1969} 1970 1971static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol, 1972 struct snd_ctl_elem_value *ucontrol) 1973{ 1974 u32 status1; 1975 int err; 1976 1977 err = snd_rme_get_status1(kcontrol, &status1); 1978 if (err < 0) 1979 return err; 1980 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1); 1981 return 0; 1982} 1983 1984static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol, 1985 struct snd_ctl_elem_value *ucontrol) 1986{ 1987 u32 status1; 1988 int err; 1989 1990 err = snd_rme_get_status1(kcontrol, &status1); 1991 if (err < 0) 1992 return err; 1993 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1); 1994 return 0; 1995} 1996 1997static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol, 1998 struct snd_ctl_elem_value *ucontrol) 1999{ 2000 u32 status1; 2001 int err; 2002 2003 err = snd_rme_get_status1(kcontrol, &status1); 2004 if (err < 0) 2005 return err; 2006 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1); 2007 return 0; 2008} 2009 2010static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol, 2011 struct snd_ctl_elem_value *ucontrol) 2012{ 2013 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2014 struct snd_usb_audio *chip = list->mixer->chip; 2015 u32 status1; 2016 const u64 num = 104857600000000ULL; 2017 u32 den; 2018 unsigned int freq; 2019 int err; 2020 2021 err = snd_usb_lock_shutdown(chip); 2022 if (err < 0) 2023 return err; 2024 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1); 2025 if (err < 0) 2026 goto end; 2027 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den); 2028 if (err < 0) 2029 goto end; 2030 freq = (den == 0) ? 0 : div64_u64(num, den); 2031 freq <<= SND_RME_CLK_FREQMUL(status1); 2032 ucontrol->value.integer.value[0] = freq; 2033 2034end: 2035 snd_usb_unlock_shutdown(chip); 2036 return err; 2037} 2038 2039static int snd_rme_rate_info(struct snd_kcontrol *kcontrol, 2040 struct snd_ctl_elem_info *uinfo) 2041{ 2042 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2043 uinfo->count = 1; 2044 switch (kcontrol->private_value) { 2045 case SND_RME_DOMAIN_SYSTEM: 2046 uinfo->value.integer.min = 32000; 2047 uinfo->value.integer.max = 800000; 2048 break; 2049 case SND_RME_DOMAIN_AES: 2050 case SND_RME_DOMAIN_SPDIF: 2051 default: 2052 uinfo->value.integer.min = 0; 2053 uinfo->value.integer.max = 200000; 2054 } 2055 uinfo->value.integer.step = 0; 2056 return 0; 2057} 2058 2059static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol, 2060 struct snd_ctl_elem_info *uinfo) 2061{ 2062 static const char *const sync_states[] = { 2063 "No Lock", "Lock", "Sync" 2064 }; 2065 2066 return snd_ctl_enum_info(uinfo, 1, 2067 ARRAY_SIZE(sync_states), sync_states); 2068} 2069 2070static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol, 2071 struct snd_ctl_elem_info *uinfo) 2072{ 2073 static const char *const spdif_if[] = { 2074 "Coaxial", "Optical" 2075 }; 2076 2077 return snd_ctl_enum_info(uinfo, 1, 2078 ARRAY_SIZE(spdif_if), spdif_if); 2079} 2080 2081static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol, 2082 struct snd_ctl_elem_info *uinfo) 2083{ 2084 static const char *const optical_type[] = { 2085 "Consumer", "Professional" 2086 }; 2087 2088 return snd_ctl_enum_info(uinfo, 1, 2089 ARRAY_SIZE(optical_type), optical_type); 2090} 2091 2092static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol, 2093 struct snd_ctl_elem_info *uinfo) 2094{ 2095 static const char *const sync_sources[] = { 2096 "Internal", "AES", "SPDIF", "Internal" 2097 }; 2098 2099 return snd_ctl_enum_info(uinfo, 1, 2100 ARRAY_SIZE(sync_sources), sync_sources); 2101} 2102 2103static const struct snd_kcontrol_new snd_rme_controls[] = { 2104 { 2105 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2106 .name = "AES Rate", 2107 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2108 .info = snd_rme_rate_info, 2109 .get = snd_rme_rate_get, 2110 .private_value = SND_RME_DOMAIN_AES 2111 }, 2112 { 2113 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2114 .name = "AES Sync", 2115 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2116 .info = snd_rme_sync_state_info, 2117 .get = snd_rme_sync_state_get, 2118 .private_value = SND_RME_DOMAIN_AES 2119 }, 2120 { 2121 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2122 .name = "SPDIF Rate", 2123 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2124 .info = snd_rme_rate_info, 2125 .get = snd_rme_rate_get, 2126 .private_value = SND_RME_DOMAIN_SPDIF 2127 }, 2128 { 2129 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2130 .name = "SPDIF Sync", 2131 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2132 .info = snd_rme_sync_state_info, 2133 .get = snd_rme_sync_state_get, 2134 .private_value = SND_RME_DOMAIN_SPDIF 2135 }, 2136 { 2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2138 .name = "SPDIF Interface", 2139 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2140 .info = snd_rme_spdif_if_info, 2141 .get = snd_rme_spdif_if_get, 2142 }, 2143 { 2144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2145 .name = "SPDIF Format", 2146 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2147 .info = snd_rme_spdif_format_info, 2148 .get = snd_rme_spdif_format_get, 2149 }, 2150 { 2151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2152 .name = "Sync Source", 2153 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2154 .info = snd_rme_sync_source_info, 2155 .get = snd_rme_sync_source_get 2156 }, 2157 { 2158 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2159 .name = "System Rate", 2160 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2161 .info = snd_rme_rate_info, 2162 .get = snd_rme_rate_get, 2163 .private_value = SND_RME_DOMAIN_SYSTEM 2164 }, 2165 { 2166 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2167 .name = "Current Frequency", 2168 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2169 .info = snd_rme_rate_info, 2170 .get = snd_rme_current_freq_get 2171 } 2172}; 2173 2174static int snd_rme_controls_create(struct usb_mixer_interface *mixer) 2175{ 2176 int err, i; 2177 2178 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) { 2179 err = add_single_ctl_with_resume(mixer, 0, 2180 NULL, 2181 &snd_rme_controls[i], 2182 NULL); 2183 if (err < 0) 2184 return err; 2185 } 2186 2187 return 0; 2188} 2189 2190/* 2191 * RME Babyface Pro (FS) 2192 * 2193 * These devices exposes a couple of DSP functions via request to EP0. 2194 * Switches are available via control registers, while routing is controlled 2195 * by controlling the volume on each possible crossing point. 2196 * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with 2197 * 0dB being at dec. 32768. 2198 */ 2199enum { 2200 SND_BBFPRO_CTL_REG1 = 0, 2201 SND_BBFPRO_CTL_REG2 2202}; 2203 2204#define SND_BBFPRO_CTL_REG_MASK 1 2205#define SND_BBFPRO_CTL_IDX_MASK 0xff 2206#define SND_BBFPRO_CTL_IDX_SHIFT 1 2207#define SND_BBFPRO_CTL_VAL_MASK 1 2208#define SND_BBFPRO_CTL_VAL_SHIFT 9 2209#define SND_BBFPRO_CTL_REG1_CLK_MASTER 0 2210#define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1 2211#define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7 2212#define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8 2213#define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10 2214#define SND_BBFPRO_CTL_REG2_48V_AN1 0 2215#define SND_BBFPRO_CTL_REG2_48V_AN2 1 2216#define SND_BBFPRO_CTL_REG2_SENS_IN3 2 2217#define SND_BBFPRO_CTL_REG2_SENS_IN4 3 2218#define SND_BBFPRO_CTL_REG2_PAD_AN1 4 2219#define SND_BBFPRO_CTL_REG2_PAD_AN2 5 2220 2221#define SND_BBFPRO_MIXER_IDX_MASK 0x1ff 2222#define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff 2223#define SND_BBFPRO_MIXER_VAL_SHIFT 9 2224#define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf 2225#define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB 2226 2227#define SND_BBFPRO_USBREQ_CTL_REG1 0x10 2228#define SND_BBFPRO_USBREQ_CTL_REG2 0x17 2229#define SND_BBFPRO_USBREQ_MIXER 0x12 2230 2231static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg, 2232 u8 index, u8 value) 2233{ 2234 int err; 2235 u16 usb_req, usb_idx, usb_val; 2236 struct snd_usb_audio *chip = mixer->chip; 2237 2238 err = snd_usb_lock_shutdown(chip); 2239 if (err < 0) 2240 return err; 2241 2242 if (reg == SND_BBFPRO_CTL_REG1) { 2243 usb_req = SND_BBFPRO_USBREQ_CTL_REG1; 2244 if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) { 2245 usb_idx = 3; 2246 usb_val = value ? 3 : 0; 2247 } else { 2248 usb_idx = 1 << index; 2249 usb_val = value ? usb_idx : 0; 2250 } 2251 } else { 2252 usb_req = SND_BBFPRO_USBREQ_CTL_REG2; 2253 usb_idx = 1 << index; 2254 usb_val = value ? usb_idx : 0; 2255 } 2256 2257 err = snd_usb_ctl_msg(chip->dev, 2258 usb_sndctrlpipe(chip->dev, 0), usb_req, 2259 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2260 usb_val, usb_idx, NULL, 0); 2261 2262 snd_usb_unlock_shutdown(chip); 2263 return err; 2264} 2265 2266static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol, 2267 struct snd_ctl_elem_value *ucontrol) 2268{ 2269 u8 reg, idx, val; 2270 int pv; 2271 2272 pv = kcontrol->private_value; 2273 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2274 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2275 val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT; 2276 2277 if ((reg == SND_BBFPRO_CTL_REG1 && 2278 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) || 2279 (reg == SND_BBFPRO_CTL_REG2 && 2280 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || 2281 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) { 2282 ucontrol->value.enumerated.item[0] = val; 2283 } else { 2284 ucontrol->value.integer.value[0] = val; 2285 } 2286 return 0; 2287} 2288 2289static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol, 2290 struct snd_ctl_elem_info *uinfo) 2291{ 2292 u8 reg, idx; 2293 int pv; 2294 2295 pv = kcontrol->private_value; 2296 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2297 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2298 2299 if (reg == SND_BBFPRO_CTL_REG1 && 2300 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) { 2301 static const char * const texts[2] = { 2302 "AutoSync", 2303 "Internal" 2304 }; 2305 return snd_ctl_enum_info(uinfo, 1, 2, texts); 2306 } else if (reg == SND_BBFPRO_CTL_REG2 && 2307 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || 2308 idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) { 2309 static const char * const texts[2] = { 2310 "-10dBV", 2311 "+4dBu" 2312 }; 2313 return snd_ctl_enum_info(uinfo, 1, 2, texts); 2314 } 2315 2316 uinfo->count = 1; 2317 uinfo->value.integer.min = 0; 2318 uinfo->value.integer.max = 1; 2319 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 2320 return 0; 2321} 2322 2323static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol, 2324 struct snd_ctl_elem_value *ucontrol) 2325{ 2326 int err; 2327 u8 reg, idx; 2328 int old_value, pv, val; 2329 2330 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2331 struct usb_mixer_interface *mixer = list->mixer; 2332 2333 pv = kcontrol->private_value; 2334 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2335 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2336 old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK; 2337 2338 if ((reg == SND_BBFPRO_CTL_REG1 && 2339 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) || 2340 (reg == SND_BBFPRO_CTL_REG2 && 2341 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || 2342 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) { 2343 val = ucontrol->value.enumerated.item[0]; 2344 } else { 2345 val = ucontrol->value.integer.value[0]; 2346 } 2347 2348 if (val > 1) 2349 return -EINVAL; 2350 2351 if (val == old_value) 2352 return 0; 2353 2354 kcontrol->private_value = reg 2355 | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT) 2356 | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT); 2357 2358 err = snd_bbfpro_ctl_update(mixer, reg, idx, val); 2359 return err < 0 ? err : 1; 2360} 2361 2362static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list) 2363{ 2364 u8 reg, idx; 2365 int value, pv; 2366 2367 pv = list->kctl->private_value; 2368 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2369 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2370 value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK; 2371 2372 return snd_bbfpro_ctl_update(list->mixer, reg, idx, value); 2373} 2374 2375static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index, 2376 u32 value) 2377{ 2378 struct snd_usb_audio *chip = mixer->chip; 2379 int err; 2380 u16 idx; 2381 u16 usb_idx, usb_val; 2382 u32 v; 2383 2384 err = snd_usb_lock_shutdown(chip); 2385 if (err < 0) 2386 return err; 2387 2388 idx = index & SND_BBFPRO_MIXER_IDX_MASK; 2389 // 18 bit linear volume, split so 2 bits end up in index. 2390 v = value & SND_BBFPRO_MIXER_VAL_MASK; 2391 usb_idx = idx | (v & 0x3) << 14; 2392 usb_val = (v >> 2) & 0xffff; 2393 2394 err = snd_usb_ctl_msg(chip->dev, 2395 usb_sndctrlpipe(chip->dev, 0), 2396 SND_BBFPRO_USBREQ_MIXER, 2397 USB_DIR_OUT | USB_TYPE_VENDOR | 2398 USB_RECIP_DEVICE, 2399 usb_val, usb_idx, NULL, 0); 2400 2401 snd_usb_unlock_shutdown(chip); 2402 return err; 2403} 2404 2405static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol, 2406 struct snd_ctl_elem_value *ucontrol) 2407{ 2408 ucontrol->value.integer.value[0] = 2409 kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT; 2410 return 0; 2411} 2412 2413static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol, 2414 struct snd_ctl_elem_info *uinfo) 2415{ 2416 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2417 uinfo->count = 1; 2418 uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN; 2419 uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX; 2420 return 0; 2421} 2422 2423static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol, 2424 struct snd_ctl_elem_value *ucontrol) 2425{ 2426 int err; 2427 u16 idx; 2428 u32 new_val, old_value, uvalue; 2429 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2430 struct usb_mixer_interface *mixer = list->mixer; 2431 2432 uvalue = ucontrol->value.integer.value[0]; 2433 idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK; 2434 old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT; 2435 2436 if (uvalue > SND_BBFPRO_MIXER_VAL_MAX) 2437 return -EINVAL; 2438 2439 if (uvalue == old_value) 2440 return 0; 2441 2442 new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK; 2443 2444 kcontrol->private_value = idx 2445 | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT); 2446 2447 err = snd_bbfpro_vol_update(mixer, idx, new_val); 2448 return err < 0 ? err : 1; 2449} 2450 2451static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list) 2452{ 2453 int pv = list->kctl->private_value; 2454 u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK; 2455 u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT) 2456 & SND_BBFPRO_MIXER_VAL_MASK; 2457 return snd_bbfpro_vol_update(list->mixer, idx, val); 2458} 2459 2460// Predfine elements 2461static const struct snd_kcontrol_new snd_bbfpro_ctl_control = { 2462 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2463 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 2464 .index = 0, 2465 .info = snd_bbfpro_ctl_info, 2466 .get = snd_bbfpro_ctl_get, 2467 .put = snd_bbfpro_ctl_put 2468}; 2469 2470static const struct snd_kcontrol_new snd_bbfpro_vol_control = { 2471 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2472 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 2473 .index = 0, 2474 .info = snd_bbfpro_vol_info, 2475 .get = snd_bbfpro_vol_get, 2476 .put = snd_bbfpro_vol_put 2477}; 2478 2479static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg, 2480 u8 index, char *name) 2481{ 2482 struct snd_kcontrol_new knew = snd_bbfpro_ctl_control; 2483 2484 knew.name = name; 2485 knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK) 2486 | ((index & SND_BBFPRO_CTL_IDX_MASK) 2487 << SND_BBFPRO_CTL_IDX_SHIFT); 2488 2489 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume, 2490 &knew, NULL); 2491} 2492 2493static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index, 2494 char *name) 2495{ 2496 struct snd_kcontrol_new knew = snd_bbfpro_vol_control; 2497 2498 knew.name = name; 2499 knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK; 2500 2501 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume, 2502 &knew, NULL); 2503} 2504 2505static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer) 2506{ 2507 int err, i, o; 2508 char name[48]; 2509 2510 static const char * const input[] = { 2511 "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3", 2512 "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"}; 2513 2514 static const char * const output[] = { 2515 "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4", 2516 "ADAT5", "ADAT6", "ADAT7", "ADAT8"}; 2517 2518 for (o = 0 ; o < 12 ; ++o) { 2519 for (i = 0 ; i < 12 ; ++i) { 2520 // Line routing 2521 snprintf(name, sizeof(name), 2522 "%s-%s-%s Playback Volume", 2523 (i < 2 ? "Mic" : "Line"), 2524 input[i], output[o]); 2525 err = snd_bbfpro_vol_add(mixer, (26 * o + i), name); 2526 if (err < 0) 2527 return err; 2528 2529 // PCM routing... yes, it is output remapping 2530 snprintf(name, sizeof(name), 2531 "PCM-%s-%s Playback Volume", 2532 output[i], output[o]); 2533 err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i), 2534 name); 2535 if (err < 0) 2536 return err; 2537 } 2538 } 2539 2540 // Control Reg 1 2541 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2542 SND_BBFPRO_CTL_REG1_CLK_OPTICAL, 2543 "Sample Clock Source"); 2544 if (err < 0) 2545 return err; 2546 2547 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2548 SND_BBFPRO_CTL_REG1_SPDIF_PRO, 2549 "IEC958 Pro Mask"); 2550 if (err < 0) 2551 return err; 2552 2553 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2554 SND_BBFPRO_CTL_REG1_SPDIF_EMPH, 2555 "IEC958 Emphasis"); 2556 if (err < 0) 2557 return err; 2558 2559 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2560 SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL, 2561 "IEC958 Switch"); 2562 if (err < 0) 2563 return err; 2564 2565 // Control Reg 2 2566 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2567 SND_BBFPRO_CTL_REG2_48V_AN1, 2568 "Mic-AN1 48V"); 2569 if (err < 0) 2570 return err; 2571 2572 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2573 SND_BBFPRO_CTL_REG2_48V_AN2, 2574 "Mic-AN2 48V"); 2575 if (err < 0) 2576 return err; 2577 2578 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2579 SND_BBFPRO_CTL_REG2_SENS_IN3, 2580 "Line-IN3 Sens."); 2581 if (err < 0) 2582 return err; 2583 2584 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2585 SND_BBFPRO_CTL_REG2_SENS_IN4, 2586 "Line-IN4 Sens."); 2587 if (err < 0) 2588 return err; 2589 2590 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2591 SND_BBFPRO_CTL_REG2_PAD_AN1, 2592 "Mic-AN1 PAD"); 2593 if (err < 0) 2594 return err; 2595 2596 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2597 SND_BBFPRO_CTL_REG2_PAD_AN2, 2598 "Mic-AN2 PAD"); 2599 if (err < 0) 2600 return err; 2601 2602 return 0; 2603} 2604 2605/* 2606 * Pioneer DJ DJM Mixers 2607 * 2608 * These devices generally have options for soft-switching the playback and 2609 * capture sources in addition to the recording level. Although different 2610 * devices have different configurations, there seems to be canonical values 2611 * for specific capture/playback types: See the definitions of these below. 2612 * 2613 * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to 2614 * capture phono would be 0x0203. Capture, playback and capture level have 2615 * different wIndexes. 2616 */ 2617 2618// Capture types 2619#define SND_DJM_CAP_LINE 0x00 2620#define SND_DJM_CAP_CDLINE 0x01 2621#define SND_DJM_CAP_DIGITAL 0x02 2622#define SND_DJM_CAP_PHONO 0x03 2623#define SND_DJM_CAP_PFADER 0x06 2624#define SND_DJM_CAP_XFADERA 0x07 2625#define SND_DJM_CAP_XFADERB 0x08 2626#define SND_DJM_CAP_MIC 0x09 2627#define SND_DJM_CAP_AUX 0x0d 2628#define SND_DJM_CAP_RECOUT 0x0a 2629#define SND_DJM_CAP_NONE 0x0f 2630#define SND_DJM_CAP_CH1PFADER 0x11 2631#define SND_DJM_CAP_CH2PFADER 0x12 2632#define SND_DJM_CAP_CH3PFADER 0x13 2633#define SND_DJM_CAP_CH4PFADER 0x14 2634 2635// Playback types 2636#define SND_DJM_PB_CH1 0x00 2637#define SND_DJM_PB_CH2 0x01 2638#define SND_DJM_PB_AUX 0x04 2639 2640#define SND_DJM_WINDEX_CAP 0x8002 2641#define SND_DJM_WINDEX_CAPLVL 0x8003 2642#define SND_DJM_WINDEX_PB 0x8016 2643 2644// kcontrol->private_value layout 2645#define SND_DJM_VALUE_MASK 0x0000ffff 2646#define SND_DJM_GROUP_MASK 0x00ff0000 2647#define SND_DJM_DEVICE_MASK 0xff000000 2648#define SND_DJM_GROUP_SHIFT 16 2649#define SND_DJM_DEVICE_SHIFT 24 2650 2651// device table index 2652#define SND_DJM_250MK2_IDX 0x0 2653#define SND_DJM_750_IDX 0x1 2654#define SND_DJM_900NXS2_IDX 0x2 2655 2656 2657#define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \ 2658 .name = _name, \ 2659 .options = snd_djm_opts_##suffix, \ 2660 .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \ 2661 .default_value = _default_value, \ 2662 .wIndex = _windex } 2663 2664#define SND_DJM_DEVICE(suffix) { \ 2665 .controls = snd_djm_ctls_##suffix, \ 2666 .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) } 2667 2668 2669struct snd_djm_device { 2670 const char *name; 2671 const struct snd_djm_ctl *controls; 2672 size_t ncontrols; 2673}; 2674 2675struct snd_djm_ctl { 2676 const char *name; 2677 const u16 *options; 2678 size_t noptions; 2679 u16 default_value; 2680 u16 wIndex; 2681}; 2682 2683static const char *snd_djm_get_label_caplevel(u16 wvalue) 2684{ 2685 switch (wvalue) { 2686 case 0x0000: return "-19dB"; 2687 case 0x0100: return "-15dB"; 2688 case 0x0200: return "-10dB"; 2689 case 0x0300: return "-5dB"; 2690 default: return NULL; 2691 } 2692}; 2693 2694static const char *snd_djm_get_label_cap(u16 wvalue) 2695{ 2696 switch (wvalue & 0x00ff) { 2697 case SND_DJM_CAP_LINE: return "Control Tone LINE"; 2698 case SND_DJM_CAP_CDLINE: return "Control Tone CD/LINE"; 2699 case SND_DJM_CAP_DIGITAL: return "Control Tone DIGITAL"; 2700 case SND_DJM_CAP_PHONO: return "Control Tone PHONO"; 2701 case SND_DJM_CAP_PFADER: return "Post Fader"; 2702 case SND_DJM_CAP_XFADERA: return "Cross Fader A"; 2703 case SND_DJM_CAP_XFADERB: return "Cross Fader B"; 2704 case SND_DJM_CAP_MIC: return "Mic"; 2705 case SND_DJM_CAP_RECOUT: return "Rec Out"; 2706 case SND_DJM_CAP_AUX: return "Aux"; 2707 case SND_DJM_CAP_NONE: return "None"; 2708 case SND_DJM_CAP_CH1PFADER: return "Post Fader Ch1"; 2709 case SND_DJM_CAP_CH2PFADER: return "Post Fader Ch2"; 2710 case SND_DJM_CAP_CH3PFADER: return "Post Fader Ch3"; 2711 case SND_DJM_CAP_CH4PFADER: return "Post Fader Ch4"; 2712 default: return NULL; 2713 } 2714}; 2715 2716static const char *snd_djm_get_label_pb(u16 wvalue) 2717{ 2718 switch (wvalue & 0x00ff) { 2719 case SND_DJM_PB_CH1: return "Ch1"; 2720 case SND_DJM_PB_CH2: return "Ch2"; 2721 case SND_DJM_PB_AUX: return "Aux"; 2722 default: return NULL; 2723 } 2724}; 2725 2726static const char *snd_djm_get_label(u16 wvalue, u16 windex) 2727{ 2728 switch (windex) { 2729 case SND_DJM_WINDEX_CAPLVL: return snd_djm_get_label_caplevel(wvalue); 2730 case SND_DJM_WINDEX_CAP: return snd_djm_get_label_cap(wvalue); 2731 case SND_DJM_WINDEX_PB: return snd_djm_get_label_pb(wvalue); 2732 default: return NULL; 2733 } 2734}; 2735 2736 2737// DJM-250MK2 2738static const u16 snd_djm_opts_cap_level[] = { 2739 0x0000, 0x0100, 0x0200, 0x0300 }; 2740 2741static const u16 snd_djm_opts_250mk2_cap1[] = { 2742 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a }; 2743 2744static const u16 snd_djm_opts_250mk2_cap2[] = { 2745 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a }; 2746 2747static const u16 snd_djm_opts_250mk2_cap3[] = { 2748 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d }; 2749 2750static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 }; 2751static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 }; 2752static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 }; 2753 2754static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = { 2755 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2756 SND_DJM_CTL("Ch1 Input", 250mk2_cap1, 2, SND_DJM_WINDEX_CAP), 2757 SND_DJM_CTL("Ch2 Input", 250mk2_cap2, 2, SND_DJM_WINDEX_CAP), 2758 SND_DJM_CTL("Ch3 Input", 250mk2_cap3, 0, SND_DJM_WINDEX_CAP), 2759 SND_DJM_CTL("Ch1 Output", 250mk2_pb1, 0, SND_DJM_WINDEX_PB), 2760 SND_DJM_CTL("Ch2 Output", 250mk2_pb2, 1, SND_DJM_WINDEX_PB), 2761 SND_DJM_CTL("Ch3 Output", 250mk2_pb3, 2, SND_DJM_WINDEX_PB) 2762}; 2763 2764 2765// DJM-750 2766static const u16 snd_djm_opts_750_cap1[] = { 2767 0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; 2768static const u16 snd_djm_opts_750_cap2[] = { 2769 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; 2770static const u16 snd_djm_opts_750_cap3[] = { 2771 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; 2772static const u16 snd_djm_opts_750_cap4[] = { 2773 0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; 2774 2775static const struct snd_djm_ctl snd_djm_ctls_750[] = { 2776 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2777 SND_DJM_CTL("Ch1 Input", 750_cap1, 2, SND_DJM_WINDEX_CAP), 2778 SND_DJM_CTL("Ch2 Input", 750_cap2, 2, SND_DJM_WINDEX_CAP), 2779 SND_DJM_CTL("Ch3 Input", 750_cap3, 0, SND_DJM_WINDEX_CAP), 2780 SND_DJM_CTL("Ch4 Input", 750_cap4, 0, SND_DJM_WINDEX_CAP) 2781}; 2782 2783 2784// DJM-900NXS2 2785static const u16 snd_djm_opts_900nxs2_cap1[] = { 2786 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a }; 2787static const u16 snd_djm_opts_900nxs2_cap2[] = { 2788 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a }; 2789static const u16 snd_djm_opts_900nxs2_cap3[] = { 2790 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a }; 2791static const u16 snd_djm_opts_900nxs2_cap4[] = { 2792 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a }; 2793static const u16 snd_djm_opts_900nxs2_cap5[] = { 2794 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 }; 2795 2796static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = { 2797 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2798 SND_DJM_CTL("Ch1 Input", 900nxs2_cap1, 2, SND_DJM_WINDEX_CAP), 2799 SND_DJM_CTL("Ch2 Input", 900nxs2_cap2, 2, SND_DJM_WINDEX_CAP), 2800 SND_DJM_CTL("Ch3 Input", 900nxs2_cap3, 2, SND_DJM_WINDEX_CAP), 2801 SND_DJM_CTL("Ch4 Input", 900nxs2_cap4, 2, SND_DJM_WINDEX_CAP), 2802 SND_DJM_CTL("Ch5 Input", 900nxs2_cap5, 3, SND_DJM_WINDEX_CAP) 2803}; 2804 2805 2806static const struct snd_djm_device snd_djm_devices[] = { 2807 SND_DJM_DEVICE(250mk2), 2808 SND_DJM_DEVICE(750), 2809 SND_DJM_DEVICE(900nxs2) 2810}; 2811 2812 2813static int snd_djm_controls_info(struct snd_kcontrol *kctl, 2814 struct snd_ctl_elem_info *info) 2815{ 2816 unsigned long private_value = kctl->private_value; 2817 u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 2818 u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 2819 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 2820 const char *name; 2821 const struct snd_djm_ctl *ctl; 2822 size_t noptions; 2823 2824 if (ctl_idx >= device->ncontrols) 2825 return -EINVAL; 2826 2827 ctl = &device->controls[ctl_idx]; 2828 noptions = ctl->noptions; 2829 if (info->value.enumerated.item >= noptions) 2830 info->value.enumerated.item = noptions - 1; 2831 2832 name = snd_djm_get_label(ctl->options[info->value.enumerated.item], 2833 ctl->wIndex); 2834 if (!name) 2835 return -EINVAL; 2836 2837 strlcpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name)); 2838 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2839 info->count = 1; 2840 info->value.enumerated.items = noptions; 2841 return 0; 2842} 2843 2844static int snd_djm_controls_update(struct usb_mixer_interface *mixer, 2845 u8 device_idx, u8 group, u16 value) 2846{ 2847 int err; 2848 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 2849 2850 if ((group >= device->ncontrols) || value >= device->controls[group].noptions) 2851 return -EINVAL; 2852 2853 err = snd_usb_lock_shutdown(mixer->chip); 2854 if (err) 2855 return err; 2856 2857 err = snd_usb_ctl_msg( 2858 mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0), 2859 USB_REQ_SET_FEATURE, 2860 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2861 device->controls[group].options[value], 2862 device->controls[group].wIndex, 2863 NULL, 0); 2864 2865 snd_usb_unlock_shutdown(mixer->chip); 2866 return err; 2867} 2868 2869static int snd_djm_controls_get(struct snd_kcontrol *kctl, 2870 struct snd_ctl_elem_value *elem) 2871{ 2872 elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK; 2873 return 0; 2874} 2875 2876static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem) 2877{ 2878 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 2879 struct usb_mixer_interface *mixer = list->mixer; 2880 unsigned long private_value = kctl->private_value; 2881 2882 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 2883 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 2884 u16 value = elem->value.enumerated.item[0]; 2885 2886 kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) | 2887 (group << SND_DJM_GROUP_SHIFT) | 2888 value); 2889 2890 return snd_djm_controls_update(mixer, device, group, value); 2891} 2892 2893static int snd_djm_controls_resume(struct usb_mixer_elem_list *list) 2894{ 2895 unsigned long private_value = list->kctl->private_value; 2896 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 2897 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 2898 u16 value = (private_value & SND_DJM_VALUE_MASK); 2899 2900 return snd_djm_controls_update(list->mixer, device, group, value); 2901} 2902 2903static int snd_djm_controls_create(struct usb_mixer_interface *mixer, 2904 const u8 device_idx) 2905{ 2906 int err, i; 2907 u16 value; 2908 2909 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 2910 2911 struct snd_kcontrol_new knew = { 2912 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2913 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 2914 .index = 0, 2915 .info = snd_djm_controls_info, 2916 .get = snd_djm_controls_get, 2917 .put = snd_djm_controls_put 2918 }; 2919 2920 for (i = 0; i < device->ncontrols; i++) { 2921 value = device->controls[i].default_value; 2922 knew.name = device->controls[i].name; 2923 knew.private_value = ( 2924 ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) | 2925 (i << SND_DJM_GROUP_SHIFT) | 2926 value); 2927 err = snd_djm_controls_update(mixer, device_idx, i, value); 2928 if (err) 2929 return err; 2930 err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume, 2931 &knew, NULL); 2932 if (err) 2933 return err; 2934 } 2935 return 0; 2936} 2937 2938int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer) 2939{ 2940 int err = 0; 2941 2942 err = snd_usb_soundblaster_remote_init(mixer); 2943 if (err < 0) 2944 return err; 2945 2946 switch (mixer->chip->usb_id) { 2947 /* Tascam US-16x08 */ 2948 case USB_ID(0x0644, 0x8047): 2949 err = snd_us16x08_controls_create(mixer); 2950 break; 2951 case USB_ID(0x041e, 0x3020): 2952 case USB_ID(0x041e, 0x3040): 2953 case USB_ID(0x041e, 0x3042): 2954 case USB_ID(0x041e, 0x30df): 2955 case USB_ID(0x041e, 0x3048): 2956 err = snd_audigy2nx_controls_create(mixer); 2957 if (err < 0) 2958 break; 2959 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx", 2960 mixer, snd_audigy2nx_proc_read); 2961 break; 2962 2963 /* EMU0204 */ 2964 case USB_ID(0x041e, 0x3f19): 2965 err = snd_emu0204_controls_create(mixer); 2966 break; 2967 2968 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ 2969 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */ 2970 err = snd_c400_create_mixer(mixer); 2971 break; 2972 2973 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ 2974 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ 2975 err = snd_ftu_create_mixer(mixer); 2976 break; 2977 2978 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */ 2979 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */ 2980 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */ 2981 err = snd_xonar_u1_controls_create(mixer); 2982 break; 2983 2984 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */ 2985 err = snd_microii_controls_create(mixer); 2986 break; 2987 2988 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */ 2989 err = snd_mbox1_create_sync_switch(mixer); 2990 break; 2991 2992 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */ 2993 err = snd_nativeinstruments_create_mixer(mixer, 2994 snd_nativeinstruments_ta6_mixers, 2995 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers)); 2996 break; 2997 2998 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */ 2999 err = snd_nativeinstruments_create_mixer(mixer, 3000 snd_nativeinstruments_ta10_mixers, 3001 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers)); 3002 break; 3003 3004 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */ 3005 /* detection is disabled in mixer_maps.c */ 3006 err = snd_create_std_mono_table(mixer, ebox44_table); 3007 break; 3008 3009 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */ 3010 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */ 3011 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */ 3012 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */ 3013 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */ 3014 err = snd_scarlett_controls_create(mixer); 3015 break; 3016 3017 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */ 3018 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */ 3019 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */ 3020 err = snd_scarlett_gen2_init(mixer); 3021 break; 3022 3023 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */ 3024 err = snd_soundblaster_e1_switch_create(mixer); 3025 break; 3026 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 3027 err = dell_dock_mixer_init(mixer); 3028 break; 3029 3030 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */ 3031 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */ 3032 case USB_ID(0x2a39, 0x3fd4): /* RME */ 3033 err = snd_rme_controls_create(mixer); 3034 break; 3035 3036 case USB_ID(0x194f, 0x010c): /* Presonus Studio 1810c */ 3037 err = snd_sc1810_init_mixer(mixer); 3038 break; 3039 case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */ 3040 err = snd_bbfpro_controls_create(mixer); 3041 break; 3042 case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */ 3043 err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX); 3044 break; 3045 case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */ 3046 err = snd_djm_controls_create(mixer, SND_DJM_750_IDX); 3047 break; 3048 case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */ 3049 err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX); 3050 break; 3051 } 3052 3053 return err; 3054} 3055 3056#ifdef CONFIG_PM 3057void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer) 3058{ 3059 switch (mixer->chip->usb_id) { 3060 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 3061 dell_dock_mixer_init(mixer); 3062 break; 3063 } 3064} 3065#endif 3066 3067void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer, 3068 int unitid) 3069{ 3070 if (!mixer->rc_cfg) 3071 return; 3072 /* unit ids specific to Extigy/Audigy 2 NX: */ 3073 switch (unitid) { 3074 case 0: /* remote control */ 3075 mixer->rc_urb->dev = mixer->chip->dev; 3076 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC); 3077 break; 3078 case 4: /* digital in jack */ 3079 case 7: /* line in jacks */ 3080 case 19: /* speaker out jacks */ 3081 case 20: /* headphones out jack */ 3082 break; 3083 /* live24ext: 4 = line-in jack */ 3084 case 3: /* hp-out jack (may actuate Mute) */ 3085 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 3086 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 3087 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id); 3088 break; 3089 default: 3090 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid); 3091 break; 3092 } 3093} 3094 3095static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer, 3096 struct usb_mixer_elem_info *cval, 3097 struct snd_kcontrol *kctl) 3098{ 3099 /* Approximation using 10 ranges based on output measurement on hw v1.2. 3100 * This seems close to the cubic mapping e.g. alsamixer uses. */ 3101 static const DECLARE_TLV_DB_RANGE(scale, 3102 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970), 3103 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160), 3104 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710), 3105 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560), 3106 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324), 3107 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031), 3108 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393), 3109 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032), 3110 32, 40, TLV_DB_MINMAX_ITEM(-968, -490), 3111 41, 50, TLV_DB_MINMAX_ITEM(-441, 0), 3112 ); 3113 3114 if (cval->min == 0 && cval->max == 50) { 3115 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n"); 3116 kctl->tlv.p = scale; 3117 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; 3118 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 3119 3120 } else if (cval->min == 0 && cval->max <= 1000) { 3121 /* Some other clearly broken DragonFly variant. 3122 * At least a 0..53 variant (hw v1.0) exists. 3123 */ 3124 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device"); 3125 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 3126 } 3127} 3128 3129void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer, 3130 struct usb_mixer_elem_info *cval, int unitid, 3131 struct snd_kcontrol *kctl) 3132{ 3133 switch (mixer->chip->usb_id) { 3134 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */ 3135 if (unitid == 7 && cval->control == UAC_FU_VOLUME) 3136 snd_dragonfly_quirk_db_scale(mixer, cval, kctl); 3137 break; 3138 /* lowest playback value is muted on some devices */ 3139 case USB_ID(0x0d8c, 0x000c): /* C-Media */ 3140 case USB_ID(0x0d8c, 0x0014): /* C-Media */ 3141 case USB_ID(0x19f7, 0x0003): /* RODE NT-USB */ 3142 if (strstr(kctl->id.name, "Playback")) 3143 cval->min_mute = 1; 3144 break; 3145 } 3146} 3147 3148