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