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 40 struct 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 */ 54 static 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 107 static 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 */ 122 static 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 138 static 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->reset_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 */ 173 static 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 192 static 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 213 static 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 233 static __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 242 static 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 292 static 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 298 static 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 328 static 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 347 static 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 */ 356 static 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 363 static const char * const snd_audigy2nx_led_names[] = { 364 "CMSS LED Switch", 365 "Power LED Switch", 366 "Dolby Digital LED Switch", 367 }; 368 369 static 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 401 static 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 */ 452 static 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 460 static 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 467 static 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 488 static 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 507 static 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 513 static 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 522 static 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 531 static 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 538 static 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 555 static 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 575 static 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 581 static 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 590 static 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 599 static 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 606 static 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 669 err: 670 snd_usb_unlock_shutdown(chip); 671 return err; 672 } 673 674 static 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 692 static 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 703 static 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 708 static 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 719 static 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 730 static 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 752 static 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 759 static 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 776 static 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 793 static 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 812 static 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 847 static 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) */ 879 static 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 890 static 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 913 static 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 920 static 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 944 static 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 962 static 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*/ 988 static 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 */ 1027 static 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 */ 1040 static 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 */ 1053 static 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 1065 static 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 1089 static 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 1122 static 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 1157 void 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 */ 1178 static 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 */ 1227 static 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 */ 1240 static 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 */ 1253 static 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 1265 static 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 1310 static 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 1352 static 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 */ 1392 static 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 */ 1484 static 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 1492 static 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 1546 static 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 1587 static 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 1614 static 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 1625 static 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 1633 static 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 1656 static 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 1672 static 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 1698 static 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 1721 static 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 1728 static 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 1749 static 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 1763 static 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 1769 static 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 1779 static 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 1788 static 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 1796 static 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 1806 static 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 1851 static 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 1861 enum snd_rme_domain { 1862 SND_RME_DOMAIN_SYSTEM, 1863 SND_RME_DOMAIN_AES, 1864 SND_RME_DOMAIN_SPDIF 1865 }; 1866 1867 enum snd_rme_clock_status { 1868 SND_RME_CLOCK_NOLOCK, 1869 SND_RME_CLOCK_LOCK, 1870 SND_RME_CLOCK_SYNC 1871 }; 1872 1873 static 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 1892 static 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 1907 static 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 1941 static 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 1971 static 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 1984 static 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 1997 static 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 2010 static 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 2034 end: 2035 snd_usb_unlock_shutdown(chip); 2036 return err; 2037 } 2038 2039 static 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 2059 static 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 2070 static 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 2081 static 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 2092 static 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 2103 static 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 2174 static 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 */ 2199 enum { 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 2231 static 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 2266 static 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 2289 static 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 2323 static 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 2362 static 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 2375 static 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 2405 static 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 2413 static 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 2423 static 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 2451 static 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 2461 static 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 2470 static 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 2479 static 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 2493 static 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 2505 static 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 // used for the snd_djm_devices table, so please update accordingly 2653 #define SND_DJM_250MK2_IDX 0x0 2654 #define SND_DJM_750_IDX 0x1 2655 #define SND_DJM_850_IDX 0x2 2656 #define SND_DJM_900NXS2_IDX 0x3 2657 2658 2659 #define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \ 2660 .name = _name, \ 2661 .options = snd_djm_opts_##suffix, \ 2662 .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \ 2663 .default_value = _default_value, \ 2664 .wIndex = _windex } 2665 2666 #define SND_DJM_DEVICE(suffix) { \ 2667 .controls = snd_djm_ctls_##suffix, \ 2668 .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) } 2669 2670 2671 struct snd_djm_device { 2672 const char *name; 2673 const struct snd_djm_ctl *controls; 2674 size_t ncontrols; 2675 }; 2676 2677 struct snd_djm_ctl { 2678 const char *name; 2679 const u16 *options; 2680 size_t noptions; 2681 u16 default_value; 2682 u16 wIndex; 2683 }; 2684 2685 static const char *snd_djm_get_label_caplevel(u16 wvalue) 2686 { 2687 switch (wvalue) { 2688 case 0x0000: return "-19dB"; 2689 case 0x0100: return "-15dB"; 2690 case 0x0200: return "-10dB"; 2691 case 0x0300: return "-5dB"; 2692 default: return NULL; 2693 } 2694 }; 2695 2696 static const char *snd_djm_get_label_cap_common(u16 wvalue) 2697 { 2698 switch (wvalue & 0x00ff) { 2699 case SND_DJM_CAP_LINE: return "Control Tone LINE"; 2700 case SND_DJM_CAP_CDLINE: return "Control Tone CD/LINE"; 2701 case SND_DJM_CAP_DIGITAL: return "Control Tone DIGITAL"; 2702 case SND_DJM_CAP_PHONO: return "Control Tone PHONO"; 2703 case SND_DJM_CAP_PFADER: return "Post Fader"; 2704 case SND_DJM_CAP_XFADERA: return "Cross Fader A"; 2705 case SND_DJM_CAP_XFADERB: return "Cross Fader B"; 2706 case SND_DJM_CAP_MIC: return "Mic"; 2707 case SND_DJM_CAP_RECOUT: return "Rec Out"; 2708 case SND_DJM_CAP_AUX: return "Aux"; 2709 case SND_DJM_CAP_NONE: return "None"; 2710 case SND_DJM_CAP_CH1PFADER: return "Post Fader Ch1"; 2711 case SND_DJM_CAP_CH2PFADER: return "Post Fader Ch2"; 2712 case SND_DJM_CAP_CH3PFADER: return "Post Fader Ch3"; 2713 case SND_DJM_CAP_CH4PFADER: return "Post Fader Ch4"; 2714 default: return NULL; 2715 } 2716 }; 2717 2718 // The DJM-850 has different values for CD/LINE and LINE capture 2719 // control options than the other DJM declared in this file. 2720 static const char *snd_djm_get_label_cap_850(u16 wvalue) 2721 { 2722 switch (wvalue & 0x00ff) { 2723 case 0x00: return "Control Tone CD/LINE"; 2724 case 0x01: return "Control Tone LINE"; 2725 default: return snd_djm_get_label_cap_common(wvalue); 2726 } 2727 }; 2728 2729 static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue) 2730 { 2731 switch (device_idx) { 2732 case SND_DJM_850_IDX: return snd_djm_get_label_cap_850(wvalue); 2733 default: return snd_djm_get_label_cap_common(wvalue); 2734 } 2735 }; 2736 2737 static const char *snd_djm_get_label_pb(u16 wvalue) 2738 { 2739 switch (wvalue & 0x00ff) { 2740 case SND_DJM_PB_CH1: return "Ch1"; 2741 case SND_DJM_PB_CH2: return "Ch2"; 2742 case SND_DJM_PB_AUX: return "Aux"; 2743 default: return NULL; 2744 } 2745 }; 2746 2747 static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex) 2748 { 2749 switch (windex) { 2750 case SND_DJM_WINDEX_CAPLVL: return snd_djm_get_label_caplevel(wvalue); 2751 case SND_DJM_WINDEX_CAP: return snd_djm_get_label_cap(device_idx, wvalue); 2752 case SND_DJM_WINDEX_PB: return snd_djm_get_label_pb(wvalue); 2753 default: return NULL; 2754 } 2755 }; 2756 2757 // common DJM capture level option values 2758 static const u16 snd_djm_opts_cap_level[] = { 2759 0x0000, 0x0100, 0x0200, 0x0300 }; 2760 2761 2762 // DJM-250MK2 2763 static const u16 snd_djm_opts_250mk2_cap1[] = { 2764 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a }; 2765 2766 static const u16 snd_djm_opts_250mk2_cap2[] = { 2767 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a }; 2768 2769 static const u16 snd_djm_opts_250mk2_cap3[] = { 2770 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d }; 2771 2772 static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 }; 2773 static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 }; 2774 static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 }; 2775 2776 static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = { 2777 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2778 SND_DJM_CTL("Ch1 Input", 250mk2_cap1, 2, SND_DJM_WINDEX_CAP), 2779 SND_DJM_CTL("Ch2 Input", 250mk2_cap2, 2, SND_DJM_WINDEX_CAP), 2780 SND_DJM_CTL("Ch3 Input", 250mk2_cap3, 0, SND_DJM_WINDEX_CAP), 2781 SND_DJM_CTL("Ch1 Output", 250mk2_pb1, 0, SND_DJM_WINDEX_PB), 2782 SND_DJM_CTL("Ch2 Output", 250mk2_pb2, 1, SND_DJM_WINDEX_PB), 2783 SND_DJM_CTL("Ch3 Output", 250mk2_pb3, 2, SND_DJM_WINDEX_PB) 2784 }; 2785 2786 2787 // DJM-750 2788 static const u16 snd_djm_opts_750_cap1[] = { 2789 0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; 2790 static const u16 snd_djm_opts_750_cap2[] = { 2791 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; 2792 static const u16 snd_djm_opts_750_cap3[] = { 2793 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; 2794 static const u16 snd_djm_opts_750_cap4[] = { 2795 0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; 2796 2797 static const struct snd_djm_ctl snd_djm_ctls_750[] = { 2798 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2799 SND_DJM_CTL("Ch1 Input", 750_cap1, 2, SND_DJM_WINDEX_CAP), 2800 SND_DJM_CTL("Ch2 Input", 750_cap2, 2, SND_DJM_WINDEX_CAP), 2801 SND_DJM_CTL("Ch3 Input", 750_cap3, 0, SND_DJM_WINDEX_CAP), 2802 SND_DJM_CTL("Ch4 Input", 750_cap4, 0, SND_DJM_WINDEX_CAP) 2803 }; 2804 2805 2806 // DJM-850 2807 static const u16 snd_djm_opts_850_cap1[] = { 2808 0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; 2809 static const u16 snd_djm_opts_850_cap2[] = { 2810 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; 2811 static const u16 snd_djm_opts_850_cap3[] = { 2812 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; 2813 static const u16 snd_djm_opts_850_cap4[] = { 2814 0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; 2815 2816 static const struct snd_djm_ctl snd_djm_ctls_850[] = { 2817 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2818 SND_DJM_CTL("Ch1 Input", 850_cap1, 1, SND_DJM_WINDEX_CAP), 2819 SND_DJM_CTL("Ch2 Input", 850_cap2, 0, SND_DJM_WINDEX_CAP), 2820 SND_DJM_CTL("Ch3 Input", 850_cap3, 0, SND_DJM_WINDEX_CAP), 2821 SND_DJM_CTL("Ch4 Input", 850_cap4, 1, SND_DJM_WINDEX_CAP) 2822 }; 2823 2824 2825 // DJM-900NXS2 2826 static const u16 snd_djm_opts_900nxs2_cap1[] = { 2827 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a }; 2828 static const u16 snd_djm_opts_900nxs2_cap2[] = { 2829 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a }; 2830 static const u16 snd_djm_opts_900nxs2_cap3[] = { 2831 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a }; 2832 static const u16 snd_djm_opts_900nxs2_cap4[] = { 2833 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a }; 2834 static const u16 snd_djm_opts_900nxs2_cap5[] = { 2835 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 }; 2836 2837 static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = { 2838 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2839 SND_DJM_CTL("Ch1 Input", 900nxs2_cap1, 2, SND_DJM_WINDEX_CAP), 2840 SND_DJM_CTL("Ch2 Input", 900nxs2_cap2, 2, SND_DJM_WINDEX_CAP), 2841 SND_DJM_CTL("Ch3 Input", 900nxs2_cap3, 2, SND_DJM_WINDEX_CAP), 2842 SND_DJM_CTL("Ch4 Input", 900nxs2_cap4, 2, SND_DJM_WINDEX_CAP), 2843 SND_DJM_CTL("Ch5 Input", 900nxs2_cap5, 3, SND_DJM_WINDEX_CAP) 2844 }; 2845 2846 2847 static const struct snd_djm_device snd_djm_devices[] = { 2848 SND_DJM_DEVICE(250mk2), 2849 SND_DJM_DEVICE(750), 2850 SND_DJM_DEVICE(850), 2851 SND_DJM_DEVICE(900nxs2) 2852 }; 2853 2854 2855 static int snd_djm_controls_info(struct snd_kcontrol *kctl, 2856 struct snd_ctl_elem_info *info) 2857 { 2858 unsigned long private_value = kctl->private_value; 2859 u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 2860 u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 2861 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 2862 const char *name; 2863 const struct snd_djm_ctl *ctl; 2864 size_t noptions; 2865 2866 if (ctl_idx >= device->ncontrols) 2867 return -EINVAL; 2868 2869 ctl = &device->controls[ctl_idx]; 2870 noptions = ctl->noptions; 2871 if (info->value.enumerated.item >= noptions) 2872 info->value.enumerated.item = noptions - 1; 2873 2874 name = snd_djm_get_label(device_idx, 2875 ctl->options[info->value.enumerated.item], 2876 ctl->wIndex); 2877 if (!name) 2878 return -EINVAL; 2879 2880 strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name)); 2881 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2882 info->count = 1; 2883 info->value.enumerated.items = noptions; 2884 return 0; 2885 } 2886 2887 static int snd_djm_controls_update(struct usb_mixer_interface *mixer, 2888 u8 device_idx, u8 group, u16 value) 2889 { 2890 int err; 2891 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 2892 2893 if ((group >= device->ncontrols) || value >= device->controls[group].noptions) 2894 return -EINVAL; 2895 2896 err = snd_usb_lock_shutdown(mixer->chip); 2897 if (err) 2898 return err; 2899 2900 err = snd_usb_ctl_msg( 2901 mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0), 2902 USB_REQ_SET_FEATURE, 2903 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2904 device->controls[group].options[value], 2905 device->controls[group].wIndex, 2906 NULL, 0); 2907 2908 snd_usb_unlock_shutdown(mixer->chip); 2909 return err; 2910 } 2911 2912 static int snd_djm_controls_get(struct snd_kcontrol *kctl, 2913 struct snd_ctl_elem_value *elem) 2914 { 2915 elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK; 2916 return 0; 2917 } 2918 2919 static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem) 2920 { 2921 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 2922 struct usb_mixer_interface *mixer = list->mixer; 2923 unsigned long private_value = kctl->private_value; 2924 2925 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 2926 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 2927 u16 value = elem->value.enumerated.item[0]; 2928 2929 kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) | 2930 (group << SND_DJM_GROUP_SHIFT) | 2931 value); 2932 2933 return snd_djm_controls_update(mixer, device, group, value); 2934 } 2935 2936 static int snd_djm_controls_resume(struct usb_mixer_elem_list *list) 2937 { 2938 unsigned long private_value = list->kctl->private_value; 2939 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 2940 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 2941 u16 value = (private_value & SND_DJM_VALUE_MASK); 2942 2943 return snd_djm_controls_update(list->mixer, device, group, value); 2944 } 2945 2946 static int snd_djm_controls_create(struct usb_mixer_interface *mixer, 2947 const u8 device_idx) 2948 { 2949 int err, i; 2950 u16 value; 2951 2952 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 2953 2954 struct snd_kcontrol_new knew = { 2955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2956 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 2957 .index = 0, 2958 .info = snd_djm_controls_info, 2959 .get = snd_djm_controls_get, 2960 .put = snd_djm_controls_put 2961 }; 2962 2963 for (i = 0; i < device->ncontrols; i++) { 2964 value = device->controls[i].default_value; 2965 knew.name = device->controls[i].name; 2966 knew.private_value = ( 2967 ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) | 2968 (i << SND_DJM_GROUP_SHIFT) | 2969 value); 2970 err = snd_djm_controls_update(mixer, device_idx, i, value); 2971 if (err) 2972 return err; 2973 err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume, 2974 &knew, NULL); 2975 if (err) 2976 return err; 2977 } 2978 return 0; 2979 } 2980 2981 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer) 2982 { 2983 int err = 0; 2984 2985 err = snd_usb_soundblaster_remote_init(mixer); 2986 if (err < 0) 2987 return err; 2988 2989 switch (mixer->chip->usb_id) { 2990 /* Tascam US-16x08 */ 2991 case USB_ID(0x0644, 0x8047): 2992 err = snd_us16x08_controls_create(mixer); 2993 break; 2994 case USB_ID(0x041e, 0x3020): 2995 case USB_ID(0x041e, 0x3040): 2996 case USB_ID(0x041e, 0x3042): 2997 case USB_ID(0x041e, 0x30df): 2998 case USB_ID(0x041e, 0x3048): 2999 err = snd_audigy2nx_controls_create(mixer); 3000 if (err < 0) 3001 break; 3002 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx", 3003 mixer, snd_audigy2nx_proc_read); 3004 break; 3005 3006 /* EMU0204 */ 3007 case USB_ID(0x041e, 0x3f19): 3008 err = snd_emu0204_controls_create(mixer); 3009 break; 3010 3011 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ 3012 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */ 3013 err = snd_c400_create_mixer(mixer); 3014 break; 3015 3016 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ 3017 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ 3018 err = snd_ftu_create_mixer(mixer); 3019 break; 3020 3021 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */ 3022 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */ 3023 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */ 3024 err = snd_xonar_u1_controls_create(mixer); 3025 break; 3026 3027 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */ 3028 err = snd_microii_controls_create(mixer); 3029 break; 3030 3031 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */ 3032 err = snd_mbox1_create_sync_switch(mixer); 3033 break; 3034 3035 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */ 3036 err = snd_nativeinstruments_create_mixer(mixer, 3037 snd_nativeinstruments_ta6_mixers, 3038 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers)); 3039 break; 3040 3041 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */ 3042 err = snd_nativeinstruments_create_mixer(mixer, 3043 snd_nativeinstruments_ta10_mixers, 3044 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers)); 3045 break; 3046 3047 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */ 3048 /* detection is disabled in mixer_maps.c */ 3049 err = snd_create_std_mono_table(mixer, ebox44_table); 3050 break; 3051 3052 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */ 3053 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */ 3054 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */ 3055 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */ 3056 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */ 3057 err = snd_scarlett_controls_create(mixer); 3058 break; 3059 3060 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */ 3061 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */ 3062 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */ 3063 err = snd_scarlett_gen2_controls_create(mixer); 3064 break; 3065 3066 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */ 3067 err = snd_soundblaster_e1_switch_create(mixer); 3068 break; 3069 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 3070 err = dell_dock_mixer_init(mixer); 3071 break; 3072 3073 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */ 3074 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */ 3075 case USB_ID(0x2a39, 0x3fd4): /* RME */ 3076 err = snd_rme_controls_create(mixer); 3077 break; 3078 3079 case USB_ID(0x0194f, 0x010c): /* Presonus Studio 1810c */ 3080 err = snd_sc1810_init_mixer(mixer); 3081 break; 3082 case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */ 3083 err = snd_bbfpro_controls_create(mixer); 3084 break; 3085 case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */ 3086 err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX); 3087 break; 3088 case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */ 3089 err = snd_djm_controls_create(mixer, SND_DJM_750_IDX); 3090 break; 3091 case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */ 3092 err = snd_djm_controls_create(mixer, SND_DJM_850_IDX); 3093 break; 3094 case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */ 3095 err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX); 3096 break; 3097 } 3098 3099 return err; 3100 } 3101 3102 #ifdef CONFIG_PM 3103 void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer) 3104 { 3105 switch (mixer->chip->usb_id) { 3106 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 3107 dell_dock_mixer_init(mixer); 3108 break; 3109 } 3110 } 3111 #endif 3112 3113 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer, 3114 int unitid) 3115 { 3116 if (!mixer->rc_cfg) 3117 return; 3118 /* unit ids specific to Extigy/Audigy 2 NX: */ 3119 switch (unitid) { 3120 case 0: /* remote control */ 3121 mixer->rc_urb->dev = mixer->chip->dev; 3122 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC); 3123 break; 3124 case 4: /* digital in jack */ 3125 case 7: /* line in jacks */ 3126 case 19: /* speaker out jacks */ 3127 case 20: /* headphones out jack */ 3128 break; 3129 /* live24ext: 4 = line-in jack */ 3130 case 3: /* hp-out jack (may actuate Mute) */ 3131 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 3132 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 3133 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id); 3134 break; 3135 default: 3136 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid); 3137 break; 3138 } 3139 } 3140 3141 static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer, 3142 struct usb_mixer_elem_info *cval, 3143 struct snd_kcontrol *kctl) 3144 { 3145 /* Approximation using 10 ranges based on output measurement on hw v1.2. 3146 * This seems close to the cubic mapping e.g. alsamixer uses. */ 3147 static const DECLARE_TLV_DB_RANGE(scale, 3148 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970), 3149 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160), 3150 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710), 3151 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560), 3152 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324), 3153 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031), 3154 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393), 3155 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032), 3156 32, 40, TLV_DB_MINMAX_ITEM(-968, -490), 3157 41, 50, TLV_DB_MINMAX_ITEM(-441, 0), 3158 ); 3159 3160 if (cval->min == 0 && cval->max == 50) { 3161 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n"); 3162 kctl->tlv.p = scale; 3163 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; 3164 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 3165 3166 } else if (cval->min == 0 && cval->max <= 1000) { 3167 /* Some other clearly broken DragonFly variant. 3168 * At least a 0..53 variant (hw v1.0) exists. 3169 */ 3170 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device"); 3171 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 3172 } 3173 } 3174 3175 void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer, 3176 struct usb_mixer_elem_info *cval, int unitid, 3177 struct snd_kcontrol *kctl) 3178 { 3179 switch (mixer->chip->usb_id) { 3180 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */ 3181 if (unitid == 7 && cval->control == UAC_FU_VOLUME) 3182 snd_dragonfly_quirk_db_scale(mixer, cval, kctl); 3183 break; 3184 /* lowest playback value is muted on C-Media devices */ 3185 case USB_ID(0x0d8c, 0x000c): 3186 case USB_ID(0x0d8c, 0x0014): 3187 if (strstr(kctl->id.name, "Playback")) 3188 cval->min_mute = 1; 3189 break; 3190 } 3191 } 3192 3193