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