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