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 return -EINVAL; 1514 alts = &iface->altsetting[1]; 1515 if (get_iface_desc(alts)->bNumEndpoints < 1) 1516 return -EINVAL; 1517 ep = get_endpoint(alts, 0)->bEndpointAddress; 1518 1519 err = snd_usb_ctl_msg(chip->dev, 1520 usb_rcvctrlpipe(chip->dev, 0), 1521 UAC_GET_CUR, 1522 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, 1523 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, 1524 ep, 1525 data, 1526 sizeof(data)); 1527 if (err < 0) 1528 goto end; 1529 1530 rate = data[0] | (data[1] << 8) | (data[2] << 16); 1531 ucontrol->value.iec958.status[3] = (rate == 48000) ? 1532 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100; 1533 1534 err = 0; 1535 end: 1536 snd_usb_unlock_shutdown(chip); 1537 return err; 1538 } 1539 1540 static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list) 1541 { 1542 struct snd_usb_audio *chip = list->mixer->chip; 1543 unsigned int pval = list->kctl->private_value; 1544 u8 reg; 1545 int err; 1546 1547 err = snd_usb_lock_shutdown(chip); 1548 if (err < 0) 1549 return err; 1550 1551 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f); 1552 err = snd_usb_ctl_msg(chip->dev, 1553 usb_sndctrlpipe(chip->dev, 0), 1554 UAC_SET_CUR, 1555 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1556 reg, 1557 2, 1558 NULL, 1559 0); 1560 if (err < 0) 1561 goto end; 1562 1563 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20; 1564 reg |= (pval >> 12) & 0x0f; 1565 err = snd_usb_ctl_msg(chip->dev, 1566 usb_sndctrlpipe(chip->dev, 0), 1567 UAC_SET_CUR, 1568 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1569 reg, 1570 3, 1571 NULL, 1572 0); 1573 if (err < 0) 1574 goto end; 1575 1576 end: 1577 snd_usb_unlock_shutdown(chip); 1578 return err; 1579 } 1580 1581 static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol, 1582 struct snd_ctl_elem_value *ucontrol) 1583 { 1584 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1585 unsigned int pval, pval_old; 1586 int err; 1587 1588 pval = pval_old = kcontrol->private_value; 1589 pval &= 0xfffff0f0; 1590 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8; 1591 pval |= (ucontrol->value.iec958.status[0] & 0x0f); 1592 1593 pval &= 0xffff0fff; 1594 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8; 1595 1596 /* The frequency bits in AES3 cannot be set via register access. */ 1597 1598 /* Silently ignore any bits from the request that cannot be set. */ 1599 1600 if (pval == pval_old) 1601 return 0; 1602 1603 kcontrol->private_value = pval; 1604 err = snd_microii_spdif_default_update(list); 1605 return err < 0 ? err : 1; 1606 } 1607 1608 static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol, 1609 struct snd_ctl_elem_value *ucontrol) 1610 { 1611 ucontrol->value.iec958.status[0] = 0x0f; 1612 ucontrol->value.iec958.status[1] = 0xff; 1613 ucontrol->value.iec958.status[2] = 0x00; 1614 ucontrol->value.iec958.status[3] = 0x00; 1615 1616 return 0; 1617 } 1618 1619 static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol, 1620 struct snd_ctl_elem_value *ucontrol) 1621 { 1622 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02); 1623 1624 return 0; 1625 } 1626 1627 static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list) 1628 { 1629 struct snd_usb_audio *chip = list->mixer->chip; 1630 u8 reg = list->kctl->private_value; 1631 int err; 1632 1633 err = snd_usb_lock_shutdown(chip); 1634 if (err < 0) 1635 return err; 1636 1637 err = snd_usb_ctl_msg(chip->dev, 1638 usb_sndctrlpipe(chip->dev, 0), 1639 UAC_SET_CUR, 1640 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1641 reg, 1642 9, 1643 NULL, 1644 0); 1645 1646 snd_usb_unlock_shutdown(chip); 1647 return err; 1648 } 1649 1650 static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol, 1651 struct snd_ctl_elem_value *ucontrol) 1652 { 1653 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1654 u8 reg; 1655 int err; 1656 1657 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a; 1658 if (reg != list->kctl->private_value) 1659 return 0; 1660 1661 kcontrol->private_value = reg; 1662 err = snd_microii_spdif_switch_update(list); 1663 return err < 0 ? err : 1; 1664 } 1665 1666 static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = { 1667 { 1668 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1669 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 1670 .info = snd_microii_spdif_info, 1671 .get = snd_microii_spdif_default_get, 1672 .put = snd_microii_spdif_default_put, 1673 .private_value = 0x00000100UL,/* reset value */ 1674 }, 1675 { 1676 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1677 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1678 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK), 1679 .info = snd_microii_spdif_info, 1680 .get = snd_microii_spdif_mask_get, 1681 }, 1682 { 1683 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1684 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 1685 .info = snd_ctl_boolean_mono_info, 1686 .get = snd_microii_spdif_switch_get, 1687 .put = snd_microii_spdif_switch_put, 1688 .private_value = 0x00000028UL,/* reset value */ 1689 } 1690 }; 1691 1692 static int snd_microii_controls_create(struct usb_mixer_interface *mixer) 1693 { 1694 int err, i; 1695 static const usb_mixer_elem_resume_func_t resume_funcs[] = { 1696 snd_microii_spdif_default_update, 1697 NULL, 1698 snd_microii_spdif_switch_update 1699 }; 1700 1701 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) { 1702 err = add_single_ctl_with_resume(mixer, 0, 1703 resume_funcs[i], 1704 &snd_microii_mixer_spdif[i], 1705 NULL); 1706 if (err < 0) 1707 return err; 1708 } 1709 1710 return 0; 1711 } 1712 1713 /* Creative Sound Blaster E1 */ 1714 1715 static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol, 1716 struct snd_ctl_elem_value *ucontrol) 1717 { 1718 ucontrol->value.integer.value[0] = kcontrol->private_value; 1719 return 0; 1720 } 1721 1722 static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer, 1723 unsigned char state) 1724 { 1725 struct snd_usb_audio *chip = mixer->chip; 1726 int err; 1727 unsigned char buff[2]; 1728 1729 buff[0] = 0x02; 1730 buff[1] = state ? 0x02 : 0x00; 1731 1732 err = snd_usb_lock_shutdown(chip); 1733 if (err < 0) 1734 return err; 1735 err = snd_usb_ctl_msg(chip->dev, 1736 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT, 1737 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 1738 0x0202, 3, buff, 2); 1739 snd_usb_unlock_shutdown(chip); 1740 return err; 1741 } 1742 1743 static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol, 1744 struct snd_ctl_elem_value *ucontrol) 1745 { 1746 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1747 unsigned char value = !!ucontrol->value.integer.value[0]; 1748 int err; 1749 1750 if (kcontrol->private_value == value) 1751 return 0; 1752 kcontrol->private_value = value; 1753 err = snd_soundblaster_e1_switch_update(list->mixer, value); 1754 return err < 0 ? err : 1; 1755 } 1756 1757 static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list) 1758 { 1759 return snd_soundblaster_e1_switch_update(list->mixer, 1760 list->kctl->private_value); 1761 } 1762 1763 static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol, 1764 struct snd_ctl_elem_info *uinfo) 1765 { 1766 static const char *const texts[2] = { 1767 "Mic", "Aux" 1768 }; 1769 1770 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 1771 } 1772 1773 static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = { 1774 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1775 .name = "Input Source", 1776 .info = snd_soundblaster_e1_switch_info, 1777 .get = snd_soundblaster_e1_switch_get, 1778 .put = snd_soundblaster_e1_switch_put, 1779 .private_value = 0, 1780 }; 1781 1782 static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer) 1783 { 1784 return add_single_ctl_with_resume(mixer, 0, 1785 snd_soundblaster_e1_switch_resume, 1786 &snd_soundblaster_e1_input_switch, 1787 NULL); 1788 } 1789 1790 static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id) 1791 { 1792 u16 buf = 0; 1793 1794 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, 1795 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 1796 ch, snd_usb_ctrl_intf(chip) | (id << 8), 1797 &buf, 2); 1798 } 1799 1800 static int dell_dock_mixer_init(struct usb_mixer_interface *mixer) 1801 { 1802 /* fix to 0dB playback volumes */ 1803 dell_dock_init_vol(mixer->chip, 1, 16); 1804 dell_dock_init_vol(mixer->chip, 2, 16); 1805 dell_dock_init_vol(mixer->chip, 1, 19); 1806 dell_dock_init_vol(mixer->chip, 2, 19); 1807 return 0; 1808 } 1809 1810 /* RME Class Compliant device quirks */ 1811 1812 #define SND_RME_GET_STATUS1 23 1813 #define SND_RME_GET_CURRENT_FREQ 17 1814 #define SND_RME_CLK_SYSTEM_SHIFT 16 1815 #define SND_RME_CLK_SYSTEM_MASK 0x1f 1816 #define SND_RME_CLK_AES_SHIFT 8 1817 #define SND_RME_CLK_SPDIF_SHIFT 12 1818 #define SND_RME_CLK_AES_SPDIF_MASK 0xf 1819 #define SND_RME_CLK_SYNC_SHIFT 6 1820 #define SND_RME_CLK_SYNC_MASK 0x3 1821 #define SND_RME_CLK_FREQMUL_SHIFT 18 1822 #define SND_RME_CLK_FREQMUL_MASK 0x7 1823 #define SND_RME_CLK_SYSTEM(x) \ 1824 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK) 1825 #define SND_RME_CLK_AES(x) \ 1826 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) 1827 #define SND_RME_CLK_SPDIF(x) \ 1828 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) 1829 #define SND_RME_CLK_SYNC(x) \ 1830 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK) 1831 #define SND_RME_CLK_FREQMUL(x) \ 1832 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK) 1833 #define SND_RME_CLK_AES_LOCK 0x1 1834 #define SND_RME_CLK_AES_SYNC 0x4 1835 #define SND_RME_CLK_SPDIF_LOCK 0x2 1836 #define SND_RME_CLK_SPDIF_SYNC 0x8 1837 #define SND_RME_SPDIF_IF_SHIFT 4 1838 #define SND_RME_SPDIF_FORMAT_SHIFT 5 1839 #define SND_RME_BINARY_MASK 0x1 1840 #define SND_RME_SPDIF_IF(x) \ 1841 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK) 1842 #define SND_RME_SPDIF_FORMAT(x) \ 1843 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK) 1844 1845 static const u32 snd_rme_rate_table[] = { 1846 32000, 44100, 48000, 50000, 1847 64000, 88200, 96000, 100000, 1848 128000, 176400, 192000, 200000, 1849 256000, 352800, 384000, 400000, 1850 512000, 705600, 768000, 800000 1851 }; 1852 /* maximum number of items for AES and S/PDIF rates for above table */ 1853 #define SND_RME_RATE_IDX_AES_SPDIF_NUM 12 1854 1855 enum snd_rme_domain { 1856 SND_RME_DOMAIN_SYSTEM, 1857 SND_RME_DOMAIN_AES, 1858 SND_RME_DOMAIN_SPDIF 1859 }; 1860 1861 enum snd_rme_clock_status { 1862 SND_RME_CLOCK_NOLOCK, 1863 SND_RME_CLOCK_LOCK, 1864 SND_RME_CLOCK_SYNC 1865 }; 1866 1867 static int snd_rme_read_value(struct snd_usb_audio *chip, 1868 unsigned int item, 1869 u32 *value) 1870 { 1871 struct usb_device *dev = chip->dev; 1872 int err; 1873 1874 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 1875 item, 1876 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1877 0, 0, 1878 value, sizeof(*value)); 1879 if (err < 0) 1880 dev_err(&dev->dev, 1881 "unable to issue vendor read request %d (ret = %d)", 1882 item, err); 1883 return err; 1884 } 1885 1886 static int snd_rme_get_status1(struct snd_kcontrol *kcontrol, 1887 u32 *status1) 1888 { 1889 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1890 struct snd_usb_audio *chip = list->mixer->chip; 1891 int err; 1892 1893 err = snd_usb_lock_shutdown(chip); 1894 if (err < 0) 1895 return err; 1896 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1); 1897 snd_usb_unlock_shutdown(chip); 1898 return err; 1899 } 1900 1901 static int snd_rme_rate_get(struct snd_kcontrol *kcontrol, 1902 struct snd_ctl_elem_value *ucontrol) 1903 { 1904 u32 status1; 1905 u32 rate = 0; 1906 int idx; 1907 int err; 1908 1909 err = snd_rme_get_status1(kcontrol, &status1); 1910 if (err < 0) 1911 return err; 1912 switch (kcontrol->private_value) { 1913 case SND_RME_DOMAIN_SYSTEM: 1914 idx = SND_RME_CLK_SYSTEM(status1); 1915 if (idx < ARRAY_SIZE(snd_rme_rate_table)) 1916 rate = snd_rme_rate_table[idx]; 1917 break; 1918 case SND_RME_DOMAIN_AES: 1919 idx = SND_RME_CLK_AES(status1); 1920 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) 1921 rate = snd_rme_rate_table[idx]; 1922 break; 1923 case SND_RME_DOMAIN_SPDIF: 1924 idx = SND_RME_CLK_SPDIF(status1); 1925 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) 1926 rate = snd_rme_rate_table[idx]; 1927 break; 1928 default: 1929 return -EINVAL; 1930 } 1931 ucontrol->value.integer.value[0] = rate; 1932 return 0; 1933 } 1934 1935 static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol, 1936 struct snd_ctl_elem_value *ucontrol) 1937 { 1938 u32 status1; 1939 int idx = SND_RME_CLOCK_NOLOCK; 1940 int err; 1941 1942 err = snd_rme_get_status1(kcontrol, &status1); 1943 if (err < 0) 1944 return err; 1945 switch (kcontrol->private_value) { 1946 case SND_RME_DOMAIN_AES: /* AES */ 1947 if (status1 & SND_RME_CLK_AES_SYNC) 1948 idx = SND_RME_CLOCK_SYNC; 1949 else if (status1 & SND_RME_CLK_AES_LOCK) 1950 idx = SND_RME_CLOCK_LOCK; 1951 break; 1952 case SND_RME_DOMAIN_SPDIF: /* SPDIF */ 1953 if (status1 & SND_RME_CLK_SPDIF_SYNC) 1954 idx = SND_RME_CLOCK_SYNC; 1955 else if (status1 & SND_RME_CLK_SPDIF_LOCK) 1956 idx = SND_RME_CLOCK_LOCK; 1957 break; 1958 default: 1959 return -EINVAL; 1960 } 1961 ucontrol->value.enumerated.item[0] = idx; 1962 return 0; 1963 } 1964 1965 static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol, 1966 struct snd_ctl_elem_value *ucontrol) 1967 { 1968 u32 status1; 1969 int err; 1970 1971 err = snd_rme_get_status1(kcontrol, &status1); 1972 if (err < 0) 1973 return err; 1974 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1); 1975 return 0; 1976 } 1977 1978 static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol, 1979 struct snd_ctl_elem_value *ucontrol) 1980 { 1981 u32 status1; 1982 int err; 1983 1984 err = snd_rme_get_status1(kcontrol, &status1); 1985 if (err < 0) 1986 return err; 1987 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1); 1988 return 0; 1989 } 1990 1991 static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol, 1992 struct snd_ctl_elem_value *ucontrol) 1993 { 1994 u32 status1; 1995 int err; 1996 1997 err = snd_rme_get_status1(kcontrol, &status1); 1998 if (err < 0) 1999 return err; 2000 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1); 2001 return 0; 2002 } 2003 2004 static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol, 2005 struct snd_ctl_elem_value *ucontrol) 2006 { 2007 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2008 struct snd_usb_audio *chip = list->mixer->chip; 2009 u32 status1; 2010 const u64 num = 104857600000000ULL; 2011 u32 den; 2012 unsigned int freq; 2013 int err; 2014 2015 err = snd_usb_lock_shutdown(chip); 2016 if (err < 0) 2017 return err; 2018 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1); 2019 if (err < 0) 2020 goto end; 2021 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den); 2022 if (err < 0) 2023 goto end; 2024 freq = (den == 0) ? 0 : div64_u64(num, den); 2025 freq <<= SND_RME_CLK_FREQMUL(status1); 2026 ucontrol->value.integer.value[0] = freq; 2027 2028 end: 2029 snd_usb_unlock_shutdown(chip); 2030 return err; 2031 } 2032 2033 static int snd_rme_rate_info(struct snd_kcontrol *kcontrol, 2034 struct snd_ctl_elem_info *uinfo) 2035 { 2036 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2037 uinfo->count = 1; 2038 switch (kcontrol->private_value) { 2039 case SND_RME_DOMAIN_SYSTEM: 2040 uinfo->value.integer.min = 32000; 2041 uinfo->value.integer.max = 800000; 2042 break; 2043 case SND_RME_DOMAIN_AES: 2044 case SND_RME_DOMAIN_SPDIF: 2045 default: 2046 uinfo->value.integer.min = 0; 2047 uinfo->value.integer.max = 200000; 2048 } 2049 uinfo->value.integer.step = 0; 2050 return 0; 2051 } 2052 2053 static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol, 2054 struct snd_ctl_elem_info *uinfo) 2055 { 2056 static const char *const sync_states[] = { 2057 "No Lock", "Lock", "Sync" 2058 }; 2059 2060 return snd_ctl_enum_info(uinfo, 1, 2061 ARRAY_SIZE(sync_states), sync_states); 2062 } 2063 2064 static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol, 2065 struct snd_ctl_elem_info *uinfo) 2066 { 2067 static const char *const spdif_if[] = { 2068 "Coaxial", "Optical" 2069 }; 2070 2071 return snd_ctl_enum_info(uinfo, 1, 2072 ARRAY_SIZE(spdif_if), spdif_if); 2073 } 2074 2075 static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol, 2076 struct snd_ctl_elem_info *uinfo) 2077 { 2078 static const char *const optical_type[] = { 2079 "Consumer", "Professional" 2080 }; 2081 2082 return snd_ctl_enum_info(uinfo, 1, 2083 ARRAY_SIZE(optical_type), optical_type); 2084 } 2085 2086 static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol, 2087 struct snd_ctl_elem_info *uinfo) 2088 { 2089 static const char *const sync_sources[] = { 2090 "Internal", "AES", "SPDIF", "Internal" 2091 }; 2092 2093 return snd_ctl_enum_info(uinfo, 1, 2094 ARRAY_SIZE(sync_sources), sync_sources); 2095 } 2096 2097 static const struct snd_kcontrol_new snd_rme_controls[] = { 2098 { 2099 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2100 .name = "AES Rate", 2101 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2102 .info = snd_rme_rate_info, 2103 .get = snd_rme_rate_get, 2104 .private_value = SND_RME_DOMAIN_AES 2105 }, 2106 { 2107 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2108 .name = "AES Sync", 2109 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2110 .info = snd_rme_sync_state_info, 2111 .get = snd_rme_sync_state_get, 2112 .private_value = SND_RME_DOMAIN_AES 2113 }, 2114 { 2115 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2116 .name = "SPDIF Rate", 2117 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2118 .info = snd_rme_rate_info, 2119 .get = snd_rme_rate_get, 2120 .private_value = SND_RME_DOMAIN_SPDIF 2121 }, 2122 { 2123 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2124 .name = "SPDIF Sync", 2125 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2126 .info = snd_rme_sync_state_info, 2127 .get = snd_rme_sync_state_get, 2128 .private_value = SND_RME_DOMAIN_SPDIF 2129 }, 2130 { 2131 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2132 .name = "SPDIF Interface", 2133 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2134 .info = snd_rme_spdif_if_info, 2135 .get = snd_rme_spdif_if_get, 2136 }, 2137 { 2138 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2139 .name = "SPDIF Format", 2140 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2141 .info = snd_rme_spdif_format_info, 2142 .get = snd_rme_spdif_format_get, 2143 }, 2144 { 2145 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2146 .name = "Sync Source", 2147 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2148 .info = snd_rme_sync_source_info, 2149 .get = snd_rme_sync_source_get 2150 }, 2151 { 2152 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2153 .name = "System Rate", 2154 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2155 .info = snd_rme_rate_info, 2156 .get = snd_rme_rate_get, 2157 .private_value = SND_RME_DOMAIN_SYSTEM 2158 }, 2159 { 2160 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2161 .name = "Current Frequency", 2162 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2163 .info = snd_rme_rate_info, 2164 .get = snd_rme_current_freq_get 2165 } 2166 }; 2167 2168 static int snd_rme_controls_create(struct usb_mixer_interface *mixer) 2169 { 2170 int err, i; 2171 2172 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) { 2173 err = add_single_ctl_with_resume(mixer, 0, 2174 NULL, 2175 &snd_rme_controls[i], 2176 NULL); 2177 if (err < 0) 2178 return err; 2179 } 2180 2181 return 0; 2182 } 2183 2184 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer) 2185 { 2186 int err = 0; 2187 2188 err = snd_usb_soundblaster_remote_init(mixer); 2189 if (err < 0) 2190 return err; 2191 2192 switch (mixer->chip->usb_id) { 2193 /* Tascam US-16x08 */ 2194 case USB_ID(0x0644, 0x8047): 2195 err = snd_us16x08_controls_create(mixer); 2196 break; 2197 case USB_ID(0x041e, 0x3020): 2198 case USB_ID(0x041e, 0x3040): 2199 case USB_ID(0x041e, 0x3042): 2200 case USB_ID(0x041e, 0x30df): 2201 case USB_ID(0x041e, 0x3048): 2202 err = snd_audigy2nx_controls_create(mixer); 2203 if (err < 0) 2204 break; 2205 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx", 2206 mixer, snd_audigy2nx_proc_read); 2207 break; 2208 2209 /* EMU0204 */ 2210 case USB_ID(0x041e, 0x3f19): 2211 err = snd_emu0204_controls_create(mixer); 2212 break; 2213 2214 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ 2215 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */ 2216 err = snd_c400_create_mixer(mixer); 2217 break; 2218 2219 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ 2220 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ 2221 err = snd_ftu_create_mixer(mixer); 2222 break; 2223 2224 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */ 2225 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */ 2226 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */ 2227 err = snd_xonar_u1_controls_create(mixer); 2228 break; 2229 2230 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */ 2231 err = snd_microii_controls_create(mixer); 2232 break; 2233 2234 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */ 2235 err = snd_mbox1_create_sync_switch(mixer); 2236 break; 2237 2238 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */ 2239 err = snd_nativeinstruments_create_mixer(mixer, 2240 snd_nativeinstruments_ta6_mixers, 2241 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers)); 2242 break; 2243 2244 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */ 2245 err = snd_nativeinstruments_create_mixer(mixer, 2246 snd_nativeinstruments_ta10_mixers, 2247 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers)); 2248 break; 2249 2250 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */ 2251 /* detection is disabled in mixer_maps.c */ 2252 err = snd_create_std_mono_table(mixer, ebox44_table); 2253 break; 2254 2255 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */ 2256 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */ 2257 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */ 2258 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */ 2259 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */ 2260 err = snd_scarlett_controls_create(mixer); 2261 break; 2262 2263 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */ 2264 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */ 2265 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */ 2266 err = snd_scarlett_gen2_controls_create(mixer); 2267 break; 2268 2269 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */ 2270 err = snd_soundblaster_e1_switch_create(mixer); 2271 break; 2272 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 2273 err = dell_dock_mixer_init(mixer); 2274 break; 2275 2276 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */ 2277 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */ 2278 case USB_ID(0x2a39, 0x3fd4): /* RME */ 2279 err = snd_rme_controls_create(mixer); 2280 break; 2281 2282 case USB_ID(0x0194f, 0x010c): /* Presonus Studio 1810c */ 2283 err = snd_sc1810_init_mixer(mixer); 2284 break; 2285 } 2286 2287 return err; 2288 } 2289 2290 #ifdef CONFIG_PM 2291 void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer) 2292 { 2293 switch (mixer->chip->usb_id) { 2294 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 2295 dell_dock_mixer_init(mixer); 2296 break; 2297 } 2298 } 2299 #endif 2300 2301 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer, 2302 int unitid) 2303 { 2304 if (!mixer->rc_cfg) 2305 return; 2306 /* unit ids specific to Extigy/Audigy 2 NX: */ 2307 switch (unitid) { 2308 case 0: /* remote control */ 2309 mixer->rc_urb->dev = mixer->chip->dev; 2310 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC); 2311 break; 2312 case 4: /* digital in jack */ 2313 case 7: /* line in jacks */ 2314 case 19: /* speaker out jacks */ 2315 case 20: /* headphones out jack */ 2316 break; 2317 /* live24ext: 4 = line-in jack */ 2318 case 3: /* hp-out jack (may actuate Mute) */ 2319 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 2320 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 2321 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id); 2322 break; 2323 default: 2324 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid); 2325 break; 2326 } 2327 } 2328 2329 static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer, 2330 struct usb_mixer_elem_info *cval, 2331 struct snd_kcontrol *kctl) 2332 { 2333 /* Approximation using 10 ranges based on output measurement on hw v1.2. 2334 * This seems close to the cubic mapping e.g. alsamixer uses. */ 2335 static const DECLARE_TLV_DB_RANGE(scale, 2336 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970), 2337 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160), 2338 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710), 2339 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560), 2340 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324), 2341 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031), 2342 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393), 2343 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032), 2344 32, 40, TLV_DB_MINMAX_ITEM(-968, -490), 2345 41, 50, TLV_DB_MINMAX_ITEM(-441, 0), 2346 ); 2347 2348 if (cval->min == 0 && cval->max == 50) { 2349 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n"); 2350 kctl->tlv.p = scale; 2351 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; 2352 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 2353 2354 } else if (cval->min == 0 && cval->max <= 1000) { 2355 /* Some other clearly broken DragonFly variant. 2356 * At least a 0..53 variant (hw v1.0) exists. 2357 */ 2358 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device"); 2359 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 2360 } 2361 } 2362 2363 void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer, 2364 struct usb_mixer_elem_info *cval, int unitid, 2365 struct snd_kcontrol *kctl) 2366 { 2367 switch (mixer->chip->usb_id) { 2368 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */ 2369 if (unitid == 7 && cval->control == UAC_FU_VOLUME) 2370 snd_dragonfly_quirk_db_scale(mixer, cval, kctl); 2371 break; 2372 /* lowest playback value is muted on C-Media devices */ 2373 case USB_ID(0x0d8c, 0x000c): 2374 case USB_ID(0x0d8c, 0x0014): 2375 if (strstr(kctl->id.name, "Playback")) 2376 cval->min_mute = 1; 2377 break; 2378 } 2379 } 2380 2381