1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * USB Audio Driver for ALSA 4 * 5 * Quirks and vendor-specific extensions for mixer interfaces 6 * 7 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de> 8 * 9 * Many codes borrowed from audio.c by 10 * Alan Cox (alan@lxorguk.ukuu.org.uk) 11 * Thomas Sailer (sailer@ife.ee.ethz.ch) 12 * 13 * Audio Advantage Micro II support added by: 14 * Przemek Rudy (prudy1@o2.pl) 15 */ 16 17 #include <linux/hid.h> 18 #include <linux/init.h> 19 #include <linux/math64.h> 20 #include <linux/slab.h> 21 #include <linux/usb.h> 22 #include <linux/usb/audio.h> 23 24 #include <sound/asoundef.h> 25 #include <sound/core.h> 26 #include <sound/control.h> 27 #include <sound/hwdep.h> 28 #include <sound/info.h> 29 #include <sound/tlv.h> 30 31 #include "usbaudio.h" 32 #include "mixer.h" 33 #include "mixer_quirks.h" 34 #include "mixer_scarlett.h" 35 #include "mixer_scarlett_gen2.h" 36 #include "mixer_us16x08.h" 37 #include "mixer_s1810c.h" 38 #include "helper.h" 39 40 struct std_mono_table { 41 unsigned int unitid, control, cmask; 42 int val_type; 43 const char *name; 44 snd_kcontrol_tlv_rw_t *tlv_callback; 45 }; 46 47 /* This function allows for the creation of standard UAC controls. 48 * See the quirks for M-Audio FTUs or Ebox-44. 49 * If you don't want to set a TLV callback pass NULL. 50 * 51 * Since there doesn't seem to be a devices that needs a multichannel 52 * version, we keep it mono for simplicity. 53 */ 54 static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer, 55 unsigned int unitid, 56 unsigned int control, 57 unsigned int cmask, 58 int val_type, 59 unsigned int idx_off, 60 const char *name, 61 snd_kcontrol_tlv_rw_t *tlv_callback) 62 { 63 struct usb_mixer_elem_info *cval; 64 struct snd_kcontrol *kctl; 65 66 cval = kzalloc(sizeof(*cval), GFP_KERNEL); 67 if (!cval) 68 return -ENOMEM; 69 70 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid); 71 cval->val_type = val_type; 72 cval->channels = 1; 73 cval->control = control; 74 cval->cmask = cmask; 75 cval->idx_off = idx_off; 76 77 /* get_min_max() is called only for integer volumes later, 78 * so provide a short-cut for booleans */ 79 cval->min = 0; 80 cval->max = 1; 81 cval->res = 0; 82 cval->dBmin = 0; 83 cval->dBmax = 0; 84 85 /* Create control */ 86 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval); 87 if (!kctl) { 88 kfree(cval); 89 return -ENOMEM; 90 } 91 92 /* Set name */ 93 snprintf(kctl->id.name, sizeof(kctl->id.name), name); 94 kctl->private_free = snd_usb_mixer_elem_free; 95 96 /* set TLV */ 97 if (tlv_callback) { 98 kctl->tlv.c = tlv_callback; 99 kctl->vd[0].access |= 100 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 101 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 102 } 103 /* Add control to mixer */ 104 return snd_usb_mixer_add_control(&cval->head, kctl); 105 } 106 107 static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer, 108 unsigned int unitid, 109 unsigned int control, 110 unsigned int cmask, 111 int val_type, 112 const char *name, 113 snd_kcontrol_tlv_rw_t *tlv_callback) 114 { 115 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask, 116 val_type, 0 /* Offset */, name, tlv_callback); 117 } 118 119 /* 120 * Create a set of standard UAC controls from a table 121 */ 122 static int snd_create_std_mono_table(struct usb_mixer_interface *mixer, 123 const struct std_mono_table *t) 124 { 125 int err; 126 127 while (t->name != NULL) { 128 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control, 129 t->cmask, t->val_type, t->name, t->tlv_callback); 130 if (err < 0) 131 return err; 132 t++; 133 } 134 135 return 0; 136 } 137 138 static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer, 139 int id, 140 usb_mixer_elem_resume_func_t resume, 141 const struct snd_kcontrol_new *knew, 142 struct usb_mixer_elem_list **listp) 143 { 144 struct usb_mixer_elem_list *list; 145 struct snd_kcontrol *kctl; 146 147 list = kzalloc(sizeof(*list), GFP_KERNEL); 148 if (!list) 149 return -ENOMEM; 150 if (listp) 151 *listp = list; 152 list->mixer = mixer; 153 list->id = id; 154 list->resume = resume; 155 kctl = snd_ctl_new1(knew, list); 156 if (!kctl) { 157 kfree(list); 158 return -ENOMEM; 159 } 160 kctl->private_free = snd_usb_mixer_elem_free; 161 /* don't use snd_usb_mixer_add_control() here, this is a special list element */ 162 return snd_usb_mixer_add_list(list, kctl, false); 163 } 164 165 /* 166 * Sound Blaster remote control configuration 167 * 168 * format of remote control data: 169 * Extigy: xx 00 170 * Audigy 2 NX: 06 80 xx 00 00 00 171 * Live! 24-bit: 06 80 xx yy 22 83 172 */ 173 static const struct rc_config { 174 u32 usb_id; 175 u8 offset; 176 u8 length; 177 u8 packet_length; 178 u8 min_packet_length; /* minimum accepted length of the URB result */ 179 u8 mute_mixer_id; 180 u32 mute_code; 181 } rc_configs[] = { 182 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */ 183 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */ 184 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */ 185 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */ 186 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 187 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 188 { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 189 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */ 190 }; 191 192 static void snd_usb_soundblaster_remote_complete(struct urb *urb) 193 { 194 struct usb_mixer_interface *mixer = urb->context; 195 const struct rc_config *rc = mixer->rc_cfg; 196 u32 code; 197 198 if (urb->status < 0 || urb->actual_length < rc->min_packet_length) 199 return; 200 201 code = mixer->rc_buffer[rc->offset]; 202 if (rc->length == 2) 203 code |= mixer->rc_buffer[rc->offset + 1] << 8; 204 205 /* the Mute button actually changes the mixer control */ 206 if (code == rc->mute_code) 207 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id); 208 mixer->rc_code = code; 209 wmb(); 210 wake_up(&mixer->rc_waitq); 211 } 212 213 static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf, 214 long count, loff_t *offset) 215 { 216 struct usb_mixer_interface *mixer = hw->private_data; 217 int err; 218 u32 rc_code; 219 220 if (count != 1 && count != 4) 221 return -EINVAL; 222 err = wait_event_interruptible(mixer->rc_waitq, 223 (rc_code = xchg(&mixer->rc_code, 0)) != 0); 224 if (err == 0) { 225 if (count == 1) 226 err = put_user(rc_code, buf); 227 else 228 err = put_user(rc_code, (u32 __user *)buf); 229 } 230 return err < 0 ? err : count; 231 } 232 233 static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file, 234 poll_table *wait) 235 { 236 struct usb_mixer_interface *mixer = hw->private_data; 237 238 poll_wait(file, &mixer->rc_waitq, wait); 239 return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0; 240 } 241 242 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) 243 { 244 struct snd_hwdep *hwdep; 245 int err, len, i; 246 247 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i) 248 if (rc_configs[i].usb_id == mixer->chip->usb_id) 249 break; 250 if (i >= ARRAY_SIZE(rc_configs)) 251 return 0; 252 mixer->rc_cfg = &rc_configs[i]; 253 254 len = mixer->rc_cfg->packet_length; 255 256 init_waitqueue_head(&mixer->rc_waitq); 257 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep); 258 if (err < 0) 259 return err; 260 snprintf(hwdep->name, sizeof(hwdep->name), 261 "%s remote control", mixer->chip->card->shortname); 262 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC; 263 hwdep->private_data = mixer; 264 hwdep->ops.read = snd_usb_sbrc_hwdep_read; 265 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll; 266 hwdep->exclusive = 1; 267 268 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL); 269 if (!mixer->rc_urb) 270 return -ENOMEM; 271 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL); 272 if (!mixer->rc_setup_packet) { 273 usb_free_urb(mixer->rc_urb); 274 mixer->rc_urb = NULL; 275 return -ENOMEM; 276 } 277 mixer->rc_setup_packet->bRequestType = 278 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE; 279 mixer->rc_setup_packet->bRequest = UAC_GET_MEM; 280 mixer->rc_setup_packet->wValue = cpu_to_le16(0); 281 mixer->rc_setup_packet->wIndex = cpu_to_le16(0); 282 mixer->rc_setup_packet->wLength = cpu_to_le16(len); 283 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev, 284 usb_rcvctrlpipe(mixer->chip->dev, 0), 285 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len, 286 snd_usb_soundblaster_remote_complete, mixer); 287 return 0; 288 } 289 290 #define snd_audigy2nx_led_info snd_ctl_boolean_mono_info 291 292 static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 293 { 294 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8; 295 return 0; 296 } 297 298 static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer, 299 int value, int index) 300 { 301 struct snd_usb_audio *chip = mixer->chip; 302 int err; 303 304 err = snd_usb_lock_shutdown(chip); 305 if (err < 0) 306 return err; 307 308 if (chip->usb_id == USB_ID(0x041e, 0x3042)) 309 err = snd_usb_ctl_msg(chip->dev, 310 usb_sndctrlpipe(chip->dev, 0), 0x24, 311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 312 !value, 0, NULL, 0); 313 /* USB X-Fi S51 Pro */ 314 if (chip->usb_id == USB_ID(0x041e, 0x30df)) 315 err = snd_usb_ctl_msg(chip->dev, 316 usb_sndctrlpipe(chip->dev, 0), 0x24, 317 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 318 !value, 0, NULL, 0); 319 else 320 err = snd_usb_ctl_msg(chip->dev, 321 usb_sndctrlpipe(chip->dev, 0), 0x24, 322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 323 value, index + 2, NULL, 0); 324 snd_usb_unlock_shutdown(chip); 325 return err; 326 } 327 328 static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, 329 struct snd_ctl_elem_value *ucontrol) 330 { 331 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 332 struct usb_mixer_interface *mixer = list->mixer; 333 int index = kcontrol->private_value & 0xff; 334 unsigned int value = ucontrol->value.integer.value[0]; 335 int old_value = kcontrol->private_value >> 8; 336 int err; 337 338 if (value > 1) 339 return -EINVAL; 340 if (value == old_value) 341 return 0; 342 kcontrol->private_value = (value << 8) | index; 343 err = snd_audigy2nx_led_update(mixer, value, index); 344 return err < 0 ? err : 1; 345 } 346 347 static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list) 348 { 349 int priv_value = list->kctl->private_value; 350 351 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8, 352 priv_value & 0xff); 353 } 354 355 /* name and private_value are set dynamically */ 356 static const struct snd_kcontrol_new snd_audigy2nx_control = { 357 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 358 .info = snd_audigy2nx_led_info, 359 .get = snd_audigy2nx_led_get, 360 .put = snd_audigy2nx_led_put, 361 }; 362 363 static const char * const snd_audigy2nx_led_names[] = { 364 "CMSS LED Switch", 365 "Power LED Switch", 366 "Dolby Digital LED Switch", 367 }; 368 369 static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer) 370 { 371 int i, err; 372 373 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) { 374 struct snd_kcontrol_new knew; 375 376 /* USB X-Fi S51 doesn't have a CMSS LED */ 377 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0) 378 continue; 379 /* USB X-Fi S51 Pro doesn't have one either */ 380 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0) 381 continue; 382 if (i > 1 && /* Live24ext has 2 LEDs only */ 383 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 384 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) || 385 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) || 386 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))) 387 break; 388 389 knew = snd_audigy2nx_control; 390 knew.name = snd_audigy2nx_led_names[i]; 391 knew.private_value = (1 << 8) | i; /* LED on as default */ 392 err = add_single_ctl_with_resume(mixer, 0, 393 snd_audigy2nx_led_resume, 394 &knew, NULL); 395 if (err < 0) 396 return err; 397 } 398 return 0; 399 } 400 401 static void snd_audigy2nx_proc_read(struct snd_info_entry *entry, 402 struct snd_info_buffer *buffer) 403 { 404 static const struct sb_jack { 405 int unitid; 406 const char *name; 407 } jacks_audigy2nx[] = { 408 {4, "dig in "}, 409 {7, "line in"}, 410 {19, "spk out"}, 411 {20, "hph out"}, 412 {-1, NULL} 413 }, jacks_live24ext[] = { 414 {4, "line in"}, /* &1=Line, &2=Mic*/ 415 {3, "hph out"}, /* headphones */ 416 {0, "RC "}, /* last command, 6 bytes see rc_config above */ 417 {-1, NULL} 418 }; 419 const struct sb_jack *jacks; 420 struct usb_mixer_interface *mixer = entry->private_data; 421 int i, err; 422 u8 buf[3]; 423 424 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname); 425 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) 426 jacks = jacks_audigy2nx; 427 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 428 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 429 jacks = jacks_live24ext; 430 else 431 return; 432 433 for (i = 0; jacks[i].name; ++i) { 434 snd_iprintf(buffer, "%s: ", jacks[i].name); 435 err = snd_usb_lock_shutdown(mixer->chip); 436 if (err < 0) 437 return; 438 err = snd_usb_ctl_msg(mixer->chip->dev, 439 usb_rcvctrlpipe(mixer->chip->dev, 0), 440 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS | 441 USB_RECIP_INTERFACE, 0, 442 jacks[i].unitid << 8, buf, 3); 443 snd_usb_unlock_shutdown(mixer->chip); 444 if (err == 3 && (buf[0] == 3 || buf[0] == 6)) 445 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]); 446 else 447 snd_iprintf(buffer, "?\n"); 448 } 449 } 450 451 /* EMU0204 */ 452 static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol, 453 struct snd_ctl_elem_info *uinfo) 454 { 455 static const char * const texts[2] = {"1/2", "3/4"}; 456 457 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 458 } 459 460 static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol, 461 struct snd_ctl_elem_value *ucontrol) 462 { 463 ucontrol->value.enumerated.item[0] = kcontrol->private_value; 464 return 0; 465 } 466 467 static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer, 468 int value) 469 { 470 struct snd_usb_audio *chip = mixer->chip; 471 int err; 472 unsigned char buf[2]; 473 474 err = snd_usb_lock_shutdown(chip); 475 if (err < 0) 476 return err; 477 478 buf[0] = 0x01; 479 buf[1] = value ? 0x02 : 0x01; 480 err = snd_usb_ctl_msg(chip->dev, 481 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, 482 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 483 0x0400, 0x0e00, buf, 2); 484 snd_usb_unlock_shutdown(chip); 485 return err; 486 } 487 488 static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol, 489 struct snd_ctl_elem_value *ucontrol) 490 { 491 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 492 struct usb_mixer_interface *mixer = list->mixer; 493 unsigned int value = ucontrol->value.enumerated.item[0]; 494 int err; 495 496 if (value > 1) 497 return -EINVAL; 498 499 if (value == kcontrol->private_value) 500 return 0; 501 502 kcontrol->private_value = value; 503 err = snd_emu0204_ch_switch_update(mixer, value); 504 return err < 0 ? err : 1; 505 } 506 507 static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list) 508 { 509 return snd_emu0204_ch_switch_update(list->mixer, 510 list->kctl->private_value); 511 } 512 513 static const struct snd_kcontrol_new snd_emu0204_control = { 514 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 515 .name = "Front Jack Channels", 516 .info = snd_emu0204_ch_switch_info, 517 .get = snd_emu0204_ch_switch_get, 518 .put = snd_emu0204_ch_switch_put, 519 .private_value = 0, 520 }; 521 522 static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer) 523 { 524 return add_single_ctl_with_resume(mixer, 0, 525 snd_emu0204_ch_switch_resume, 526 &snd_emu0204_control, NULL); 527 } 528 529 /* ASUS Xonar U1 / U3 controls */ 530 531 static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol, 532 struct snd_ctl_elem_value *ucontrol) 533 { 534 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02); 535 return 0; 536 } 537 538 static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer, 539 unsigned char status) 540 { 541 struct snd_usb_audio *chip = mixer->chip; 542 int err; 543 544 err = snd_usb_lock_shutdown(chip); 545 if (err < 0) 546 return err; 547 err = snd_usb_ctl_msg(chip->dev, 548 usb_sndctrlpipe(chip->dev, 0), 0x08, 549 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 550 50, 0, &status, 1); 551 snd_usb_unlock_shutdown(chip); 552 return err; 553 } 554 555 static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol, 556 struct snd_ctl_elem_value *ucontrol) 557 { 558 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 559 u8 old_status, new_status; 560 int err; 561 562 old_status = kcontrol->private_value; 563 if (ucontrol->value.integer.value[0]) 564 new_status = old_status | 0x02; 565 else 566 new_status = old_status & ~0x02; 567 if (new_status == old_status) 568 return 0; 569 570 kcontrol->private_value = new_status; 571 err = snd_xonar_u1_switch_update(list->mixer, new_status); 572 return err < 0 ? err : 1; 573 } 574 575 static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list) 576 { 577 return snd_xonar_u1_switch_update(list->mixer, 578 list->kctl->private_value); 579 } 580 581 static const struct snd_kcontrol_new snd_xonar_u1_output_switch = { 582 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 583 .name = "Digital Playback Switch", 584 .info = snd_ctl_boolean_mono_info, 585 .get = snd_xonar_u1_switch_get, 586 .put = snd_xonar_u1_switch_put, 587 .private_value = 0x05, 588 }; 589 590 static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer) 591 { 592 return add_single_ctl_with_resume(mixer, 0, 593 snd_xonar_u1_switch_resume, 594 &snd_xonar_u1_output_switch, NULL); 595 } 596 597 /* Digidesign Mbox 1 helper functions */ 598 599 static int snd_mbox1_is_spdif_synced(struct snd_usb_audio *chip) 600 { 601 unsigned char buff[3]; 602 int err; 603 int is_spdif_synced; 604 605 /* Read clock source */ 606 err = snd_usb_ctl_msg(chip->dev, 607 usb_rcvctrlpipe(chip->dev, 0), 0x81, 608 USB_DIR_IN | 609 USB_TYPE_CLASS | 610 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); 611 if (err < 0) 612 return err; 613 614 /* spdif sync: buff is all zeroes */ 615 is_spdif_synced = !(buff[0] | buff[1] | buff[2]); 616 return is_spdif_synced; 617 } 618 619 static int snd_mbox1_set_clk_source(struct snd_usb_audio *chip, int rate_or_zero) 620 { 621 /* 2 possibilities: Internal -> expects sample rate 622 * S/PDIF sync -> expects rate = 0 623 */ 624 unsigned char buff[3]; 625 626 buff[0] = (rate_or_zero >> 0) & 0xff; 627 buff[1] = (rate_or_zero >> 8) & 0xff; 628 buff[2] = (rate_or_zero >> 16) & 0xff; 629 630 /* Set clock source */ 631 return snd_usb_ctl_msg(chip->dev, 632 usb_sndctrlpipe(chip->dev, 0), 0x1, 633 USB_TYPE_CLASS | 634 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); 635 } 636 637 static int snd_mbox1_is_spdif_input(struct snd_usb_audio *chip) 638 { 639 /* Hardware gives 2 possibilities: ANALOG Source -> 0x01 640 * S/PDIF Source -> 0x02 641 */ 642 int err; 643 unsigned char source[1]; 644 645 /* Read input source */ 646 err = snd_usb_ctl_msg(chip->dev, 647 usb_rcvctrlpipe(chip->dev, 0), 0x81, 648 USB_DIR_IN | 649 USB_TYPE_CLASS | 650 USB_RECIP_INTERFACE, 0x00, 0x500, source, 1); 651 if (err < 0) 652 return err; 653 654 return (source[0] == 2); 655 } 656 657 static int snd_mbox1_set_input_source(struct snd_usb_audio *chip, int is_spdif) 658 { 659 /* NB: Setting the input source to S/PDIF resets the clock source to S/PDIF 660 * Hardware expects 2 possibilities: ANALOG Source -> 0x01 661 * S/PDIF Source -> 0x02 662 */ 663 unsigned char buff[1]; 664 665 buff[0] = (is_spdif & 1) + 1; 666 667 /* Set input source */ 668 return snd_usb_ctl_msg(chip->dev, 669 usb_sndctrlpipe(chip->dev, 0), 0x1, 670 USB_TYPE_CLASS | 671 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1); 672 } 673 674 /* Digidesign Mbox 1 clock source switch (internal/spdif) */ 675 676 static int snd_mbox1_clk_switch_get(struct snd_kcontrol *kctl, 677 struct snd_ctl_elem_value *ucontrol) 678 { 679 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 680 struct snd_usb_audio *chip = list->mixer->chip; 681 int err; 682 683 err = snd_usb_lock_shutdown(chip); 684 if (err < 0) 685 goto err; 686 687 err = snd_mbox1_is_spdif_synced(chip); 688 if (err < 0) 689 goto err; 690 691 kctl->private_value = err; 692 err = 0; 693 ucontrol->value.enumerated.item[0] = kctl->private_value; 694 err: 695 snd_usb_unlock_shutdown(chip); 696 return err; 697 } 698 699 static int snd_mbox1_clk_switch_update(struct usb_mixer_interface *mixer, int is_spdif_sync) 700 { 701 struct snd_usb_audio *chip = mixer->chip; 702 int err; 703 704 err = snd_usb_lock_shutdown(chip); 705 if (err < 0) 706 return err; 707 708 err = snd_mbox1_is_spdif_input(chip); 709 if (err < 0) 710 goto err; 711 712 err = snd_mbox1_is_spdif_synced(chip); 713 if (err < 0) 714 goto err; 715 716 /* FIXME: hardcoded sample rate */ 717 err = snd_mbox1_set_clk_source(chip, is_spdif_sync ? 0 : 48000); 718 if (err < 0) 719 goto err; 720 721 err = snd_mbox1_is_spdif_synced(chip); 722 err: 723 snd_usb_unlock_shutdown(chip); 724 return err; 725 } 726 727 static int snd_mbox1_clk_switch_put(struct snd_kcontrol *kctl, 728 struct snd_ctl_elem_value *ucontrol) 729 { 730 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 731 struct usb_mixer_interface *mixer = list->mixer; 732 int err; 733 bool cur_val, new_val; 734 735 cur_val = kctl->private_value; 736 new_val = ucontrol->value.enumerated.item[0]; 737 if (cur_val == new_val) 738 return 0; 739 740 kctl->private_value = new_val; 741 err = snd_mbox1_clk_switch_update(mixer, new_val); 742 return err < 0 ? err : 1; 743 } 744 745 static int snd_mbox1_clk_switch_info(struct snd_kcontrol *kcontrol, 746 struct snd_ctl_elem_info *uinfo) 747 { 748 static const char *const texts[2] = { 749 "Internal", 750 "S/PDIF" 751 }; 752 753 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 754 } 755 756 static int snd_mbox1_clk_switch_resume(struct usb_mixer_elem_list *list) 757 { 758 return snd_mbox1_clk_switch_update(list->mixer, list->kctl->private_value); 759 } 760 761 /* Digidesign Mbox 1 input source switch (analog/spdif) */ 762 763 static int snd_mbox1_src_switch_get(struct snd_kcontrol *kctl, 764 struct snd_ctl_elem_value *ucontrol) 765 { 766 ucontrol->value.enumerated.item[0] = kctl->private_value; 767 return 0; 768 } 769 770 static int snd_mbox1_src_switch_update(struct usb_mixer_interface *mixer, int is_spdif_input) 771 { 772 struct snd_usb_audio *chip = mixer->chip; 773 int err; 774 775 err = snd_usb_lock_shutdown(chip); 776 if (err < 0) 777 return err; 778 779 err = snd_mbox1_is_spdif_input(chip); 780 if (err < 0) 781 goto err; 782 783 err = snd_mbox1_set_input_source(chip, is_spdif_input); 784 if (err < 0) 785 goto err; 786 787 err = snd_mbox1_is_spdif_input(chip); 788 if (err < 0) 789 goto err; 790 791 err = snd_mbox1_is_spdif_synced(chip); 792 err: 793 snd_usb_unlock_shutdown(chip); 794 return err; 795 } 796 797 static int snd_mbox1_src_switch_put(struct snd_kcontrol *kctl, 798 struct snd_ctl_elem_value *ucontrol) 799 { 800 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 801 struct usb_mixer_interface *mixer = list->mixer; 802 int err; 803 bool cur_val, new_val; 804 805 cur_val = kctl->private_value; 806 new_val = ucontrol->value.enumerated.item[0]; 807 if (cur_val == new_val) 808 return 0; 809 810 kctl->private_value = new_val; 811 err = snd_mbox1_src_switch_update(mixer, new_val); 812 return err < 0 ? err : 1; 813 } 814 815 static int snd_mbox1_src_switch_info(struct snd_kcontrol *kcontrol, 816 struct snd_ctl_elem_info *uinfo) 817 { 818 static const char *const texts[2] = { 819 "Analog", 820 "S/PDIF" 821 }; 822 823 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 824 } 825 826 static int snd_mbox1_src_switch_resume(struct usb_mixer_elem_list *list) 827 { 828 return snd_mbox1_src_switch_update(list->mixer, list->kctl->private_value); 829 } 830 831 static const struct snd_kcontrol_new snd_mbox1_clk_switch = { 832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 833 .name = "Clock Source", 834 .index = 0, 835 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 836 .info = snd_mbox1_clk_switch_info, 837 .get = snd_mbox1_clk_switch_get, 838 .put = snd_mbox1_clk_switch_put, 839 .private_value = 0 840 }; 841 842 static const struct snd_kcontrol_new snd_mbox1_src_switch = { 843 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 844 .name = "Input Source", 845 .index = 1, 846 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 847 .info = snd_mbox1_src_switch_info, 848 .get = snd_mbox1_src_switch_get, 849 .put = snd_mbox1_src_switch_put, 850 .private_value = 0 851 }; 852 853 static int snd_mbox1_controls_create(struct usb_mixer_interface *mixer) 854 { 855 int err; 856 err = add_single_ctl_with_resume(mixer, 0, 857 snd_mbox1_clk_switch_resume, 858 &snd_mbox1_clk_switch, NULL); 859 if (err < 0) 860 return err; 861 862 return add_single_ctl_with_resume(mixer, 1, 863 snd_mbox1_src_switch_resume, 864 &snd_mbox1_src_switch, NULL); 865 } 866 867 /* Native Instruments device quirks */ 868 869 #define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex)) 870 871 static int snd_ni_control_init_val(struct usb_mixer_interface *mixer, 872 struct snd_kcontrol *kctl) 873 { 874 struct usb_device *dev = mixer->chip->dev; 875 unsigned int pval = kctl->private_value; 876 u8 value; 877 int err; 878 879 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 880 (pval >> 16) & 0xff, 881 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 882 0, pval & 0xffff, &value, 1); 883 if (err < 0) { 884 dev_err(&dev->dev, 885 "unable to issue vendor read request (ret = %d)", err); 886 return err; 887 } 888 889 kctl->private_value |= ((unsigned int)value << 24); 890 return 0; 891 } 892 893 static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol, 894 struct snd_ctl_elem_value *ucontrol) 895 { 896 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24; 897 return 0; 898 } 899 900 static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list) 901 { 902 struct snd_usb_audio *chip = list->mixer->chip; 903 unsigned int pval = list->kctl->private_value; 904 int err; 905 906 err = snd_usb_lock_shutdown(chip); 907 if (err < 0) 908 return err; 909 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 910 (pval >> 16) & 0xff, 911 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 912 pval >> 24, pval & 0xffff, NULL, 0, 1000); 913 snd_usb_unlock_shutdown(chip); 914 return err; 915 } 916 917 static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol, 918 struct snd_ctl_elem_value *ucontrol) 919 { 920 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 921 u8 oldval = (kcontrol->private_value >> 24) & 0xff; 922 u8 newval = ucontrol->value.integer.value[0]; 923 int err; 924 925 if (oldval == newval) 926 return 0; 927 928 kcontrol->private_value &= ~(0xff << 24); 929 kcontrol->private_value |= (unsigned int)newval << 24; 930 err = snd_ni_update_cur_val(list); 931 return err < 0 ? err : 1; 932 } 933 934 static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = { 935 { 936 .name = "Direct Thru Channel A", 937 .private_value = _MAKE_NI_CONTROL(0x01, 0x03), 938 }, 939 { 940 .name = "Direct Thru Channel B", 941 .private_value = _MAKE_NI_CONTROL(0x01, 0x05), 942 }, 943 { 944 .name = "Phono Input Channel A", 945 .private_value = _MAKE_NI_CONTROL(0x02, 0x03), 946 }, 947 { 948 .name = "Phono Input Channel B", 949 .private_value = _MAKE_NI_CONTROL(0x02, 0x05), 950 }, 951 }; 952 953 static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = { 954 { 955 .name = "Direct Thru Channel A", 956 .private_value = _MAKE_NI_CONTROL(0x01, 0x03), 957 }, 958 { 959 .name = "Direct Thru Channel B", 960 .private_value = _MAKE_NI_CONTROL(0x01, 0x05), 961 }, 962 { 963 .name = "Direct Thru Channel C", 964 .private_value = _MAKE_NI_CONTROL(0x01, 0x07), 965 }, 966 { 967 .name = "Direct Thru Channel D", 968 .private_value = _MAKE_NI_CONTROL(0x01, 0x09), 969 }, 970 { 971 .name = "Phono Input Channel A", 972 .private_value = _MAKE_NI_CONTROL(0x02, 0x03), 973 }, 974 { 975 .name = "Phono Input Channel B", 976 .private_value = _MAKE_NI_CONTROL(0x02, 0x05), 977 }, 978 { 979 .name = "Phono Input Channel C", 980 .private_value = _MAKE_NI_CONTROL(0x02, 0x07), 981 }, 982 { 983 .name = "Phono Input Channel D", 984 .private_value = _MAKE_NI_CONTROL(0x02, 0x09), 985 }, 986 }; 987 988 static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer, 989 const struct snd_kcontrol_new *kc, 990 unsigned int count) 991 { 992 int i, err = 0; 993 struct snd_kcontrol_new template = { 994 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 995 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 996 .get = snd_nativeinstruments_control_get, 997 .put = snd_nativeinstruments_control_put, 998 .info = snd_ctl_boolean_mono_info, 999 }; 1000 1001 for (i = 0; i < count; i++) { 1002 struct usb_mixer_elem_list *list; 1003 1004 template.name = kc[i].name; 1005 template.private_value = kc[i].private_value; 1006 1007 err = add_single_ctl_with_resume(mixer, 0, 1008 snd_ni_update_cur_val, 1009 &template, &list); 1010 if (err < 0) 1011 break; 1012 snd_ni_control_init_val(mixer, list->kctl); 1013 } 1014 1015 return err; 1016 } 1017 1018 /* M-Audio FastTrack Ultra quirks */ 1019 /* FTU Effect switch (also used by C400/C600) */ 1020 static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol, 1021 struct snd_ctl_elem_info *uinfo) 1022 { 1023 static const char *const texts[8] = { 1024 "Room 1", "Room 2", "Room 3", "Hall 1", 1025 "Hall 2", "Plate", "Delay", "Echo" 1026 }; 1027 1028 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 1029 } 1030 1031 static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer, 1032 struct snd_kcontrol *kctl) 1033 { 1034 struct usb_device *dev = mixer->chip->dev; 1035 unsigned int pval = kctl->private_value; 1036 int err; 1037 unsigned char value[2]; 1038 1039 value[0] = 0x00; 1040 value[1] = 0x00; 1041 1042 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR, 1043 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 1044 pval & 0xff00, 1045 snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8), 1046 value, 2); 1047 if (err < 0) 1048 return err; 1049 1050 kctl->private_value |= (unsigned int)value[0] << 24; 1051 return 0; 1052 } 1053 1054 static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl, 1055 struct snd_ctl_elem_value *ucontrol) 1056 { 1057 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24; 1058 return 0; 1059 } 1060 1061 static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list) 1062 { 1063 struct snd_usb_audio *chip = list->mixer->chip; 1064 unsigned int pval = list->kctl->private_value; 1065 unsigned char value[2]; 1066 int err; 1067 1068 value[0] = pval >> 24; 1069 value[1] = 0; 1070 1071 err = snd_usb_lock_shutdown(chip); 1072 if (err < 0) 1073 return err; 1074 err = snd_usb_ctl_msg(chip->dev, 1075 usb_sndctrlpipe(chip->dev, 0), 1076 UAC_SET_CUR, 1077 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 1078 pval & 0xff00, 1079 snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8), 1080 value, 2); 1081 snd_usb_unlock_shutdown(chip); 1082 return err; 1083 } 1084 1085 static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl, 1086 struct snd_ctl_elem_value *ucontrol) 1087 { 1088 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 1089 unsigned int pval = list->kctl->private_value; 1090 int cur_val, err, new_val; 1091 1092 cur_val = pval >> 24; 1093 new_val = ucontrol->value.enumerated.item[0]; 1094 if (cur_val == new_val) 1095 return 0; 1096 1097 kctl->private_value &= ~(0xff << 24); 1098 kctl->private_value |= new_val << 24; 1099 err = snd_ftu_eff_switch_update(list); 1100 return err < 0 ? err : 1; 1101 } 1102 1103 static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer, 1104 int validx, int bUnitID) 1105 { 1106 static struct snd_kcontrol_new template = { 1107 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1108 .name = "Effect Program Switch", 1109 .index = 0, 1110 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 1111 .info = snd_ftu_eff_switch_info, 1112 .get = snd_ftu_eff_switch_get, 1113 .put = snd_ftu_eff_switch_put 1114 }; 1115 struct usb_mixer_elem_list *list; 1116 int err; 1117 1118 err = add_single_ctl_with_resume(mixer, bUnitID, 1119 snd_ftu_eff_switch_update, 1120 &template, &list); 1121 if (err < 0) 1122 return err; 1123 list->kctl->private_value = (validx << 8) | bUnitID; 1124 snd_ftu_eff_switch_init(mixer, list->kctl); 1125 return 0; 1126 } 1127 1128 /* Create volume controls for FTU devices*/ 1129 static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer) 1130 { 1131 char name[64]; 1132 unsigned int control, cmask; 1133 int in, out, err; 1134 1135 const unsigned int id = 5; 1136 const int val_type = USB_MIXER_S16; 1137 1138 for (out = 0; out < 8; out++) { 1139 control = out + 1; 1140 for (in = 0; in < 8; in++) { 1141 cmask = 1 << in; 1142 snprintf(name, sizeof(name), 1143 "AIn%d - Out%d Capture Volume", 1144 in + 1, out + 1); 1145 err = snd_create_std_mono_ctl(mixer, id, control, 1146 cmask, val_type, name, 1147 &snd_usb_mixer_vol_tlv); 1148 if (err < 0) 1149 return err; 1150 } 1151 for (in = 8; in < 16; in++) { 1152 cmask = 1 << in; 1153 snprintf(name, sizeof(name), 1154 "DIn%d - Out%d Playback Volume", 1155 in - 7, out + 1); 1156 err = snd_create_std_mono_ctl(mixer, id, control, 1157 cmask, val_type, name, 1158 &snd_usb_mixer_vol_tlv); 1159 if (err < 0) 1160 return err; 1161 } 1162 } 1163 1164 return 0; 1165 } 1166 1167 /* This control needs a volume quirk, see mixer.c */ 1168 static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer) 1169 { 1170 static const char name[] = "Effect Volume"; 1171 const unsigned int id = 6; 1172 const int val_type = USB_MIXER_U8; 1173 const unsigned int control = 2; 1174 const unsigned int cmask = 0; 1175 1176 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1177 name, snd_usb_mixer_vol_tlv); 1178 } 1179 1180 /* This control needs a volume quirk, see mixer.c */ 1181 static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer) 1182 { 1183 static const char name[] = "Effect Duration"; 1184 const unsigned int id = 6; 1185 const int val_type = USB_MIXER_S16; 1186 const unsigned int control = 3; 1187 const unsigned int cmask = 0; 1188 1189 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1190 name, snd_usb_mixer_vol_tlv); 1191 } 1192 1193 /* This control needs a volume quirk, see mixer.c */ 1194 static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) 1195 { 1196 static const char name[] = "Effect Feedback Volume"; 1197 const unsigned int id = 6; 1198 const int val_type = USB_MIXER_U8; 1199 const unsigned int control = 4; 1200 const unsigned int cmask = 0; 1201 1202 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1203 name, NULL); 1204 } 1205 1206 static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer) 1207 { 1208 unsigned int cmask; 1209 int err, ch; 1210 char name[48]; 1211 1212 const unsigned int id = 7; 1213 const int val_type = USB_MIXER_S16; 1214 const unsigned int control = 7; 1215 1216 for (ch = 0; ch < 4; ++ch) { 1217 cmask = 1 << ch; 1218 snprintf(name, sizeof(name), 1219 "Effect Return %d Volume", ch + 1); 1220 err = snd_create_std_mono_ctl(mixer, id, control, 1221 cmask, val_type, name, 1222 snd_usb_mixer_vol_tlv); 1223 if (err < 0) 1224 return err; 1225 } 1226 1227 return 0; 1228 } 1229 1230 static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer) 1231 { 1232 unsigned int cmask; 1233 int err, ch; 1234 char name[48]; 1235 1236 const unsigned int id = 5; 1237 const int val_type = USB_MIXER_S16; 1238 const unsigned int control = 9; 1239 1240 for (ch = 0; ch < 8; ++ch) { 1241 cmask = 1 << ch; 1242 snprintf(name, sizeof(name), 1243 "Effect Send AIn%d Volume", ch + 1); 1244 err = snd_create_std_mono_ctl(mixer, id, control, cmask, 1245 val_type, name, 1246 snd_usb_mixer_vol_tlv); 1247 if (err < 0) 1248 return err; 1249 } 1250 for (ch = 8; ch < 16; ++ch) { 1251 cmask = 1 << ch; 1252 snprintf(name, sizeof(name), 1253 "Effect Send DIn%d Volume", ch - 7); 1254 err = snd_create_std_mono_ctl(mixer, id, control, cmask, 1255 val_type, name, 1256 snd_usb_mixer_vol_tlv); 1257 if (err < 0) 1258 return err; 1259 } 1260 return 0; 1261 } 1262 1263 static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer) 1264 { 1265 int err; 1266 1267 err = snd_ftu_create_volume_ctls(mixer); 1268 if (err < 0) 1269 return err; 1270 1271 err = snd_ftu_create_effect_switch(mixer, 1, 6); 1272 if (err < 0) 1273 return err; 1274 1275 err = snd_ftu_create_effect_volume_ctl(mixer); 1276 if (err < 0) 1277 return err; 1278 1279 err = snd_ftu_create_effect_duration_ctl(mixer); 1280 if (err < 0) 1281 return err; 1282 1283 err = snd_ftu_create_effect_feedback_ctl(mixer); 1284 if (err < 0) 1285 return err; 1286 1287 err = snd_ftu_create_effect_return_ctls(mixer); 1288 if (err < 0) 1289 return err; 1290 1291 err = snd_ftu_create_effect_send_ctls(mixer); 1292 if (err < 0) 1293 return err; 1294 1295 return 0; 1296 } 1297 1298 void snd_emuusb_set_samplerate(struct snd_usb_audio *chip, 1299 unsigned char samplerate_id) 1300 { 1301 struct usb_mixer_interface *mixer; 1302 struct usb_mixer_elem_info *cval; 1303 int unitid = 12; /* SampleRate ExtensionUnit ID */ 1304 1305 list_for_each_entry(mixer, &chip->mixer_list, list) { 1306 if (mixer->id_elems[unitid]) { 1307 cval = mixer_elem_list_to_info(mixer->id_elems[unitid]); 1308 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, 1309 cval->control << 8, 1310 samplerate_id); 1311 snd_usb_mixer_notify_id(mixer, unitid); 1312 break; 1313 } 1314 } 1315 } 1316 1317 /* M-Audio Fast Track C400/C600 */ 1318 /* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */ 1319 static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer) 1320 { 1321 char name[64]; 1322 unsigned int cmask, offset; 1323 int out, chan, err; 1324 int num_outs = 0; 1325 int num_ins = 0; 1326 1327 const unsigned int id = 0x40; 1328 const int val_type = USB_MIXER_S16; 1329 const int control = 1; 1330 1331 switch (mixer->chip->usb_id) { 1332 case USB_ID(0x0763, 0x2030): 1333 num_outs = 6; 1334 num_ins = 4; 1335 break; 1336 case USB_ID(0x0763, 0x2031): 1337 num_outs = 8; 1338 num_ins = 6; 1339 break; 1340 } 1341 1342 for (chan = 0; chan < num_outs + num_ins; chan++) { 1343 for (out = 0; out < num_outs; out++) { 1344 if (chan < num_outs) { 1345 snprintf(name, sizeof(name), 1346 "PCM%d-Out%d Playback Volume", 1347 chan + 1, out + 1); 1348 } else { 1349 snprintf(name, sizeof(name), 1350 "In%d-Out%d Playback Volume", 1351 chan - num_outs + 1, out + 1); 1352 } 1353 1354 cmask = (out == 0) ? 0 : 1 << (out - 1); 1355 offset = chan * num_outs; 1356 err = snd_create_std_mono_ctl_offset(mixer, id, control, 1357 cmask, val_type, offset, name, 1358 &snd_usb_mixer_vol_tlv); 1359 if (err < 0) 1360 return err; 1361 } 1362 } 1363 1364 return 0; 1365 } 1366 1367 /* This control needs a volume quirk, see mixer.c */ 1368 static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer) 1369 { 1370 static const char name[] = "Effect Volume"; 1371 const unsigned int id = 0x43; 1372 const int val_type = USB_MIXER_U8; 1373 const unsigned int control = 3; 1374 const unsigned int cmask = 0; 1375 1376 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1377 name, snd_usb_mixer_vol_tlv); 1378 } 1379 1380 /* This control needs a volume quirk, see mixer.c */ 1381 static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer) 1382 { 1383 static const char name[] = "Effect Duration"; 1384 const unsigned int id = 0x43; 1385 const int val_type = USB_MIXER_S16; 1386 const unsigned int control = 4; 1387 const unsigned int cmask = 0; 1388 1389 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1390 name, snd_usb_mixer_vol_tlv); 1391 } 1392 1393 /* This control needs a volume quirk, see mixer.c */ 1394 static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) 1395 { 1396 static const char name[] = "Effect Feedback Volume"; 1397 const unsigned int id = 0x43; 1398 const int val_type = USB_MIXER_U8; 1399 const unsigned int control = 5; 1400 const unsigned int cmask = 0; 1401 1402 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1403 name, NULL); 1404 } 1405 1406 static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer) 1407 { 1408 char name[64]; 1409 unsigned int cmask; 1410 int chan, err; 1411 int num_outs = 0; 1412 int num_ins = 0; 1413 1414 const unsigned int id = 0x42; 1415 const int val_type = USB_MIXER_S16; 1416 const int control = 1; 1417 1418 switch (mixer->chip->usb_id) { 1419 case USB_ID(0x0763, 0x2030): 1420 num_outs = 6; 1421 num_ins = 4; 1422 break; 1423 case USB_ID(0x0763, 0x2031): 1424 num_outs = 8; 1425 num_ins = 6; 1426 break; 1427 } 1428 1429 for (chan = 0; chan < num_outs + num_ins; chan++) { 1430 if (chan < num_outs) { 1431 snprintf(name, sizeof(name), 1432 "Effect Send DOut%d", 1433 chan + 1); 1434 } else { 1435 snprintf(name, sizeof(name), 1436 "Effect Send AIn%d", 1437 chan - num_outs + 1); 1438 } 1439 1440 cmask = (chan == 0) ? 0 : 1 << (chan - 1); 1441 err = snd_create_std_mono_ctl(mixer, id, control, 1442 cmask, val_type, name, 1443 &snd_usb_mixer_vol_tlv); 1444 if (err < 0) 1445 return err; 1446 } 1447 1448 return 0; 1449 } 1450 1451 static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer) 1452 { 1453 char name[64]; 1454 unsigned int cmask; 1455 int chan, err; 1456 int num_outs = 0; 1457 int offset = 0; 1458 1459 const unsigned int id = 0x40; 1460 const int val_type = USB_MIXER_S16; 1461 const int control = 1; 1462 1463 switch (mixer->chip->usb_id) { 1464 case USB_ID(0x0763, 0x2030): 1465 num_outs = 6; 1466 offset = 0x3c; 1467 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */ 1468 break; 1469 case USB_ID(0x0763, 0x2031): 1470 num_outs = 8; 1471 offset = 0x70; 1472 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */ 1473 break; 1474 } 1475 1476 for (chan = 0; chan < num_outs; chan++) { 1477 snprintf(name, sizeof(name), 1478 "Effect Return %d", 1479 chan + 1); 1480 1481 cmask = (chan == 0) ? 0 : 1482 1 << (chan + (chan % 2) * num_outs - 1); 1483 err = snd_create_std_mono_ctl_offset(mixer, id, control, 1484 cmask, val_type, offset, name, 1485 &snd_usb_mixer_vol_tlv); 1486 if (err < 0) 1487 return err; 1488 } 1489 1490 return 0; 1491 } 1492 1493 static int snd_c400_create_mixer(struct usb_mixer_interface *mixer) 1494 { 1495 int err; 1496 1497 err = snd_c400_create_vol_ctls(mixer); 1498 if (err < 0) 1499 return err; 1500 1501 err = snd_c400_create_effect_vol_ctls(mixer); 1502 if (err < 0) 1503 return err; 1504 1505 err = snd_c400_create_effect_ret_vol_ctls(mixer); 1506 if (err < 0) 1507 return err; 1508 1509 err = snd_ftu_create_effect_switch(mixer, 2, 0x43); 1510 if (err < 0) 1511 return err; 1512 1513 err = snd_c400_create_effect_volume_ctl(mixer); 1514 if (err < 0) 1515 return err; 1516 1517 err = snd_c400_create_effect_duration_ctl(mixer); 1518 if (err < 0) 1519 return err; 1520 1521 err = snd_c400_create_effect_feedback_ctl(mixer); 1522 if (err < 0) 1523 return err; 1524 1525 return 0; 1526 } 1527 1528 /* 1529 * The mixer units for Ebox-44 are corrupt, and even where they 1530 * are valid they presents mono controls as L and R channels of 1531 * stereo. So we provide a good mixer here. 1532 */ 1533 static const struct std_mono_table ebox44_table[] = { 1534 { 1535 .unitid = 4, 1536 .control = 1, 1537 .cmask = 0x0, 1538 .val_type = USB_MIXER_INV_BOOLEAN, 1539 .name = "Headphone Playback Switch" 1540 }, 1541 { 1542 .unitid = 4, 1543 .control = 2, 1544 .cmask = 0x1, 1545 .val_type = USB_MIXER_S16, 1546 .name = "Headphone A Mix Playback Volume" 1547 }, 1548 { 1549 .unitid = 4, 1550 .control = 2, 1551 .cmask = 0x2, 1552 .val_type = USB_MIXER_S16, 1553 .name = "Headphone B Mix Playback Volume" 1554 }, 1555 1556 { 1557 .unitid = 7, 1558 .control = 1, 1559 .cmask = 0x0, 1560 .val_type = USB_MIXER_INV_BOOLEAN, 1561 .name = "Output Playback Switch" 1562 }, 1563 { 1564 .unitid = 7, 1565 .control = 2, 1566 .cmask = 0x1, 1567 .val_type = USB_MIXER_S16, 1568 .name = "Output A Playback Volume" 1569 }, 1570 { 1571 .unitid = 7, 1572 .control = 2, 1573 .cmask = 0x2, 1574 .val_type = USB_MIXER_S16, 1575 .name = "Output B Playback Volume" 1576 }, 1577 1578 { 1579 .unitid = 10, 1580 .control = 1, 1581 .cmask = 0x0, 1582 .val_type = USB_MIXER_INV_BOOLEAN, 1583 .name = "Input Capture Switch" 1584 }, 1585 { 1586 .unitid = 10, 1587 .control = 2, 1588 .cmask = 0x1, 1589 .val_type = USB_MIXER_S16, 1590 .name = "Input A Capture Volume" 1591 }, 1592 { 1593 .unitid = 10, 1594 .control = 2, 1595 .cmask = 0x2, 1596 .val_type = USB_MIXER_S16, 1597 .name = "Input B Capture Volume" 1598 }, 1599 1600 {} 1601 }; 1602 1603 /* Audio Advantage Micro II findings: 1604 * 1605 * Mapping spdif AES bits to vendor register.bit: 1606 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00 1607 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01 1608 * AES2: [0 0 0 0 0 0 0 0] 1609 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request 1610 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices 1611 * 1612 * power on values: 1613 * r2: 0x10 1614 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set 1615 * just after it to 0xa0, presumably it disables/mutes some analog 1616 * parts when there is no audio.) 1617 * r9: 0x28 1618 * 1619 * Optical transmitter on/off: 1620 * vendor register.bit: 9.1 1621 * 0 - on (0x28 register value) 1622 * 1 - off (0x2a register value) 1623 * 1624 */ 1625 static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol, 1626 struct snd_ctl_elem_info *uinfo) 1627 { 1628 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1629 uinfo->count = 1; 1630 return 0; 1631 } 1632 1633 static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol, 1634 struct snd_ctl_elem_value *ucontrol) 1635 { 1636 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1637 struct snd_usb_audio *chip = list->mixer->chip; 1638 int err; 1639 struct usb_interface *iface; 1640 struct usb_host_interface *alts; 1641 unsigned int ep; 1642 unsigned char data[3]; 1643 int rate; 1644 1645 err = snd_usb_lock_shutdown(chip); 1646 if (err < 0) 1647 return err; 1648 1649 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff; 1650 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff; 1651 ucontrol->value.iec958.status[2] = 0x00; 1652 1653 /* use known values for that card: interface#1 altsetting#1 */ 1654 iface = usb_ifnum_to_if(chip->dev, 1); 1655 if (!iface || iface->num_altsetting < 2) { 1656 err = -EINVAL; 1657 goto end; 1658 } 1659 alts = &iface->altsetting[1]; 1660 if (get_iface_desc(alts)->bNumEndpoints < 1) { 1661 err = -EINVAL; 1662 goto end; 1663 } 1664 ep = get_endpoint(alts, 0)->bEndpointAddress; 1665 1666 err = snd_usb_ctl_msg(chip->dev, 1667 usb_rcvctrlpipe(chip->dev, 0), 1668 UAC_GET_CUR, 1669 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, 1670 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, 1671 ep, 1672 data, 1673 sizeof(data)); 1674 if (err < 0) 1675 goto end; 1676 1677 rate = data[0] | (data[1] << 8) | (data[2] << 16); 1678 ucontrol->value.iec958.status[3] = (rate == 48000) ? 1679 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100; 1680 1681 err = 0; 1682 end: 1683 snd_usb_unlock_shutdown(chip); 1684 return err; 1685 } 1686 1687 static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list) 1688 { 1689 struct snd_usb_audio *chip = list->mixer->chip; 1690 unsigned int pval = list->kctl->private_value; 1691 u8 reg; 1692 int err; 1693 1694 err = snd_usb_lock_shutdown(chip); 1695 if (err < 0) 1696 return err; 1697 1698 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f); 1699 err = snd_usb_ctl_msg(chip->dev, 1700 usb_sndctrlpipe(chip->dev, 0), 1701 UAC_SET_CUR, 1702 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1703 reg, 1704 2, 1705 NULL, 1706 0); 1707 if (err < 0) 1708 goto end; 1709 1710 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20; 1711 reg |= (pval >> 12) & 0x0f; 1712 err = snd_usb_ctl_msg(chip->dev, 1713 usb_sndctrlpipe(chip->dev, 0), 1714 UAC_SET_CUR, 1715 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1716 reg, 1717 3, 1718 NULL, 1719 0); 1720 if (err < 0) 1721 goto end; 1722 1723 end: 1724 snd_usb_unlock_shutdown(chip); 1725 return err; 1726 } 1727 1728 static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol, 1729 struct snd_ctl_elem_value *ucontrol) 1730 { 1731 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1732 unsigned int pval, pval_old; 1733 int err; 1734 1735 pval = pval_old = kcontrol->private_value; 1736 pval &= 0xfffff0f0; 1737 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8; 1738 pval |= (ucontrol->value.iec958.status[0] & 0x0f); 1739 1740 pval &= 0xffff0fff; 1741 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8; 1742 1743 /* The frequency bits in AES3 cannot be set via register access. */ 1744 1745 /* Silently ignore any bits from the request that cannot be set. */ 1746 1747 if (pval == pval_old) 1748 return 0; 1749 1750 kcontrol->private_value = pval; 1751 err = snd_microii_spdif_default_update(list); 1752 return err < 0 ? err : 1; 1753 } 1754 1755 static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol, 1756 struct snd_ctl_elem_value *ucontrol) 1757 { 1758 ucontrol->value.iec958.status[0] = 0x0f; 1759 ucontrol->value.iec958.status[1] = 0xff; 1760 ucontrol->value.iec958.status[2] = 0x00; 1761 ucontrol->value.iec958.status[3] = 0x00; 1762 1763 return 0; 1764 } 1765 1766 static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol, 1767 struct snd_ctl_elem_value *ucontrol) 1768 { 1769 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02); 1770 1771 return 0; 1772 } 1773 1774 static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list) 1775 { 1776 struct snd_usb_audio *chip = list->mixer->chip; 1777 u8 reg = list->kctl->private_value; 1778 int err; 1779 1780 err = snd_usb_lock_shutdown(chip); 1781 if (err < 0) 1782 return err; 1783 1784 err = snd_usb_ctl_msg(chip->dev, 1785 usb_sndctrlpipe(chip->dev, 0), 1786 UAC_SET_CUR, 1787 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1788 reg, 1789 9, 1790 NULL, 1791 0); 1792 1793 snd_usb_unlock_shutdown(chip); 1794 return err; 1795 } 1796 1797 static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol, 1798 struct snd_ctl_elem_value *ucontrol) 1799 { 1800 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1801 u8 reg; 1802 int err; 1803 1804 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a; 1805 if (reg != list->kctl->private_value) 1806 return 0; 1807 1808 kcontrol->private_value = reg; 1809 err = snd_microii_spdif_switch_update(list); 1810 return err < 0 ? err : 1; 1811 } 1812 1813 static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = { 1814 { 1815 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1816 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 1817 .info = snd_microii_spdif_info, 1818 .get = snd_microii_spdif_default_get, 1819 .put = snd_microii_spdif_default_put, 1820 .private_value = 0x00000100UL,/* reset value */ 1821 }, 1822 { 1823 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1824 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1825 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK), 1826 .info = snd_microii_spdif_info, 1827 .get = snd_microii_spdif_mask_get, 1828 }, 1829 { 1830 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1831 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 1832 .info = snd_ctl_boolean_mono_info, 1833 .get = snd_microii_spdif_switch_get, 1834 .put = snd_microii_spdif_switch_put, 1835 .private_value = 0x00000028UL,/* reset value */ 1836 } 1837 }; 1838 1839 static int snd_microii_controls_create(struct usb_mixer_interface *mixer) 1840 { 1841 int err, i; 1842 static const usb_mixer_elem_resume_func_t resume_funcs[] = { 1843 snd_microii_spdif_default_update, 1844 NULL, 1845 snd_microii_spdif_switch_update 1846 }; 1847 1848 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) { 1849 err = add_single_ctl_with_resume(mixer, 0, 1850 resume_funcs[i], 1851 &snd_microii_mixer_spdif[i], 1852 NULL); 1853 if (err < 0) 1854 return err; 1855 } 1856 1857 return 0; 1858 } 1859 1860 /* Creative Sound Blaster E1 */ 1861 1862 static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol, 1863 struct snd_ctl_elem_value *ucontrol) 1864 { 1865 ucontrol->value.integer.value[0] = kcontrol->private_value; 1866 return 0; 1867 } 1868 1869 static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer, 1870 unsigned char state) 1871 { 1872 struct snd_usb_audio *chip = mixer->chip; 1873 int err; 1874 unsigned char buff[2]; 1875 1876 buff[0] = 0x02; 1877 buff[1] = state ? 0x02 : 0x00; 1878 1879 err = snd_usb_lock_shutdown(chip); 1880 if (err < 0) 1881 return err; 1882 err = snd_usb_ctl_msg(chip->dev, 1883 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT, 1884 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 1885 0x0202, 3, buff, 2); 1886 snd_usb_unlock_shutdown(chip); 1887 return err; 1888 } 1889 1890 static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol, 1891 struct snd_ctl_elem_value *ucontrol) 1892 { 1893 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 1894 unsigned char value = !!ucontrol->value.integer.value[0]; 1895 int err; 1896 1897 if (kcontrol->private_value == value) 1898 return 0; 1899 kcontrol->private_value = value; 1900 err = snd_soundblaster_e1_switch_update(list->mixer, value); 1901 return err < 0 ? err : 1; 1902 } 1903 1904 static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list) 1905 { 1906 return snd_soundblaster_e1_switch_update(list->mixer, 1907 list->kctl->private_value); 1908 } 1909 1910 static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol, 1911 struct snd_ctl_elem_info *uinfo) 1912 { 1913 static const char *const texts[2] = { 1914 "Mic", "Aux" 1915 }; 1916 1917 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 1918 } 1919 1920 static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = { 1921 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1922 .name = "Input Source", 1923 .info = snd_soundblaster_e1_switch_info, 1924 .get = snd_soundblaster_e1_switch_get, 1925 .put = snd_soundblaster_e1_switch_put, 1926 .private_value = 0, 1927 }; 1928 1929 static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer) 1930 { 1931 return add_single_ctl_with_resume(mixer, 0, 1932 snd_soundblaster_e1_switch_resume, 1933 &snd_soundblaster_e1_input_switch, 1934 NULL); 1935 } 1936 1937 static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id) 1938 { 1939 u16 buf = 0; 1940 1941 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, 1942 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 1943 ch, snd_usb_ctrl_intf(chip) | (id << 8), 1944 &buf, 2); 1945 } 1946 1947 static int dell_dock_mixer_init(struct usb_mixer_interface *mixer) 1948 { 1949 /* fix to 0dB playback volumes */ 1950 dell_dock_init_vol(mixer->chip, 1, 16); 1951 dell_dock_init_vol(mixer->chip, 2, 16); 1952 dell_dock_init_vol(mixer->chip, 1, 19); 1953 dell_dock_init_vol(mixer->chip, 2, 19); 1954 return 0; 1955 } 1956 1957 /* RME Class Compliant device quirks */ 1958 1959 #define SND_RME_GET_STATUS1 23 1960 #define SND_RME_GET_CURRENT_FREQ 17 1961 #define SND_RME_CLK_SYSTEM_SHIFT 16 1962 #define SND_RME_CLK_SYSTEM_MASK 0x1f 1963 #define SND_RME_CLK_AES_SHIFT 8 1964 #define SND_RME_CLK_SPDIF_SHIFT 12 1965 #define SND_RME_CLK_AES_SPDIF_MASK 0xf 1966 #define SND_RME_CLK_SYNC_SHIFT 6 1967 #define SND_RME_CLK_SYNC_MASK 0x3 1968 #define SND_RME_CLK_FREQMUL_SHIFT 18 1969 #define SND_RME_CLK_FREQMUL_MASK 0x7 1970 #define SND_RME_CLK_SYSTEM(x) \ 1971 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK) 1972 #define SND_RME_CLK_AES(x) \ 1973 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) 1974 #define SND_RME_CLK_SPDIF(x) \ 1975 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) 1976 #define SND_RME_CLK_SYNC(x) \ 1977 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK) 1978 #define SND_RME_CLK_FREQMUL(x) \ 1979 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK) 1980 #define SND_RME_CLK_AES_LOCK 0x1 1981 #define SND_RME_CLK_AES_SYNC 0x4 1982 #define SND_RME_CLK_SPDIF_LOCK 0x2 1983 #define SND_RME_CLK_SPDIF_SYNC 0x8 1984 #define SND_RME_SPDIF_IF_SHIFT 4 1985 #define SND_RME_SPDIF_FORMAT_SHIFT 5 1986 #define SND_RME_BINARY_MASK 0x1 1987 #define SND_RME_SPDIF_IF(x) \ 1988 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK) 1989 #define SND_RME_SPDIF_FORMAT(x) \ 1990 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK) 1991 1992 static const u32 snd_rme_rate_table[] = { 1993 32000, 44100, 48000, 50000, 1994 64000, 88200, 96000, 100000, 1995 128000, 176400, 192000, 200000, 1996 256000, 352800, 384000, 400000, 1997 512000, 705600, 768000, 800000 1998 }; 1999 /* maximum number of items for AES and S/PDIF rates for above table */ 2000 #define SND_RME_RATE_IDX_AES_SPDIF_NUM 12 2001 2002 enum snd_rme_domain { 2003 SND_RME_DOMAIN_SYSTEM, 2004 SND_RME_DOMAIN_AES, 2005 SND_RME_DOMAIN_SPDIF 2006 }; 2007 2008 enum snd_rme_clock_status { 2009 SND_RME_CLOCK_NOLOCK, 2010 SND_RME_CLOCK_LOCK, 2011 SND_RME_CLOCK_SYNC 2012 }; 2013 2014 static int snd_rme_read_value(struct snd_usb_audio *chip, 2015 unsigned int item, 2016 u32 *value) 2017 { 2018 struct usb_device *dev = chip->dev; 2019 int err; 2020 2021 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 2022 item, 2023 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2024 0, 0, 2025 value, sizeof(*value)); 2026 if (err < 0) 2027 dev_err(&dev->dev, 2028 "unable to issue vendor read request %d (ret = %d)", 2029 item, err); 2030 return err; 2031 } 2032 2033 static int snd_rme_get_status1(struct snd_kcontrol *kcontrol, 2034 u32 *status1) 2035 { 2036 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2037 struct snd_usb_audio *chip = list->mixer->chip; 2038 int err; 2039 2040 err = snd_usb_lock_shutdown(chip); 2041 if (err < 0) 2042 return err; 2043 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1); 2044 snd_usb_unlock_shutdown(chip); 2045 return err; 2046 } 2047 2048 static int snd_rme_rate_get(struct snd_kcontrol *kcontrol, 2049 struct snd_ctl_elem_value *ucontrol) 2050 { 2051 u32 status1; 2052 u32 rate = 0; 2053 int idx; 2054 int err; 2055 2056 err = snd_rme_get_status1(kcontrol, &status1); 2057 if (err < 0) 2058 return err; 2059 switch (kcontrol->private_value) { 2060 case SND_RME_DOMAIN_SYSTEM: 2061 idx = SND_RME_CLK_SYSTEM(status1); 2062 if (idx < ARRAY_SIZE(snd_rme_rate_table)) 2063 rate = snd_rme_rate_table[idx]; 2064 break; 2065 case SND_RME_DOMAIN_AES: 2066 idx = SND_RME_CLK_AES(status1); 2067 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) 2068 rate = snd_rme_rate_table[idx]; 2069 break; 2070 case SND_RME_DOMAIN_SPDIF: 2071 idx = SND_RME_CLK_SPDIF(status1); 2072 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) 2073 rate = snd_rme_rate_table[idx]; 2074 break; 2075 default: 2076 return -EINVAL; 2077 } 2078 ucontrol->value.integer.value[0] = rate; 2079 return 0; 2080 } 2081 2082 static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol, 2083 struct snd_ctl_elem_value *ucontrol) 2084 { 2085 u32 status1; 2086 int idx = SND_RME_CLOCK_NOLOCK; 2087 int err; 2088 2089 err = snd_rme_get_status1(kcontrol, &status1); 2090 if (err < 0) 2091 return err; 2092 switch (kcontrol->private_value) { 2093 case SND_RME_DOMAIN_AES: /* AES */ 2094 if (status1 & SND_RME_CLK_AES_SYNC) 2095 idx = SND_RME_CLOCK_SYNC; 2096 else if (status1 & SND_RME_CLK_AES_LOCK) 2097 idx = SND_RME_CLOCK_LOCK; 2098 break; 2099 case SND_RME_DOMAIN_SPDIF: /* SPDIF */ 2100 if (status1 & SND_RME_CLK_SPDIF_SYNC) 2101 idx = SND_RME_CLOCK_SYNC; 2102 else if (status1 & SND_RME_CLK_SPDIF_LOCK) 2103 idx = SND_RME_CLOCK_LOCK; 2104 break; 2105 default: 2106 return -EINVAL; 2107 } 2108 ucontrol->value.enumerated.item[0] = idx; 2109 return 0; 2110 } 2111 2112 static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol, 2113 struct snd_ctl_elem_value *ucontrol) 2114 { 2115 u32 status1; 2116 int err; 2117 2118 err = snd_rme_get_status1(kcontrol, &status1); 2119 if (err < 0) 2120 return err; 2121 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1); 2122 return 0; 2123 } 2124 2125 static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol, 2126 struct snd_ctl_elem_value *ucontrol) 2127 { 2128 u32 status1; 2129 int err; 2130 2131 err = snd_rme_get_status1(kcontrol, &status1); 2132 if (err < 0) 2133 return err; 2134 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1); 2135 return 0; 2136 } 2137 2138 static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol, 2139 struct snd_ctl_elem_value *ucontrol) 2140 { 2141 u32 status1; 2142 int err; 2143 2144 err = snd_rme_get_status1(kcontrol, &status1); 2145 if (err < 0) 2146 return err; 2147 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1); 2148 return 0; 2149 } 2150 2151 static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol, 2152 struct snd_ctl_elem_value *ucontrol) 2153 { 2154 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2155 struct snd_usb_audio *chip = list->mixer->chip; 2156 u32 status1; 2157 const u64 num = 104857600000000ULL; 2158 u32 den; 2159 unsigned int freq; 2160 int err; 2161 2162 err = snd_usb_lock_shutdown(chip); 2163 if (err < 0) 2164 return err; 2165 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1); 2166 if (err < 0) 2167 goto end; 2168 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den); 2169 if (err < 0) 2170 goto end; 2171 freq = (den == 0) ? 0 : div64_u64(num, den); 2172 freq <<= SND_RME_CLK_FREQMUL(status1); 2173 ucontrol->value.integer.value[0] = freq; 2174 2175 end: 2176 snd_usb_unlock_shutdown(chip); 2177 return err; 2178 } 2179 2180 static int snd_rme_rate_info(struct snd_kcontrol *kcontrol, 2181 struct snd_ctl_elem_info *uinfo) 2182 { 2183 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2184 uinfo->count = 1; 2185 switch (kcontrol->private_value) { 2186 case SND_RME_DOMAIN_SYSTEM: 2187 uinfo->value.integer.min = 32000; 2188 uinfo->value.integer.max = 800000; 2189 break; 2190 case SND_RME_DOMAIN_AES: 2191 case SND_RME_DOMAIN_SPDIF: 2192 default: 2193 uinfo->value.integer.min = 0; 2194 uinfo->value.integer.max = 200000; 2195 } 2196 uinfo->value.integer.step = 0; 2197 return 0; 2198 } 2199 2200 static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol, 2201 struct snd_ctl_elem_info *uinfo) 2202 { 2203 static const char *const sync_states[] = { 2204 "No Lock", "Lock", "Sync" 2205 }; 2206 2207 return snd_ctl_enum_info(uinfo, 1, 2208 ARRAY_SIZE(sync_states), sync_states); 2209 } 2210 2211 static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol, 2212 struct snd_ctl_elem_info *uinfo) 2213 { 2214 static const char *const spdif_if[] = { 2215 "Coaxial", "Optical" 2216 }; 2217 2218 return snd_ctl_enum_info(uinfo, 1, 2219 ARRAY_SIZE(spdif_if), spdif_if); 2220 } 2221 2222 static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol, 2223 struct snd_ctl_elem_info *uinfo) 2224 { 2225 static const char *const optical_type[] = { 2226 "Consumer", "Professional" 2227 }; 2228 2229 return snd_ctl_enum_info(uinfo, 1, 2230 ARRAY_SIZE(optical_type), optical_type); 2231 } 2232 2233 static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol, 2234 struct snd_ctl_elem_info *uinfo) 2235 { 2236 static const char *const sync_sources[] = { 2237 "Internal", "AES", "SPDIF", "Internal" 2238 }; 2239 2240 return snd_ctl_enum_info(uinfo, 1, 2241 ARRAY_SIZE(sync_sources), sync_sources); 2242 } 2243 2244 static const struct snd_kcontrol_new snd_rme_controls[] = { 2245 { 2246 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2247 .name = "AES Rate", 2248 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2249 .info = snd_rme_rate_info, 2250 .get = snd_rme_rate_get, 2251 .private_value = SND_RME_DOMAIN_AES 2252 }, 2253 { 2254 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2255 .name = "AES Sync", 2256 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2257 .info = snd_rme_sync_state_info, 2258 .get = snd_rme_sync_state_get, 2259 .private_value = SND_RME_DOMAIN_AES 2260 }, 2261 { 2262 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2263 .name = "SPDIF Rate", 2264 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2265 .info = snd_rme_rate_info, 2266 .get = snd_rme_rate_get, 2267 .private_value = SND_RME_DOMAIN_SPDIF 2268 }, 2269 { 2270 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2271 .name = "SPDIF Sync", 2272 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2273 .info = snd_rme_sync_state_info, 2274 .get = snd_rme_sync_state_get, 2275 .private_value = SND_RME_DOMAIN_SPDIF 2276 }, 2277 { 2278 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2279 .name = "SPDIF Interface", 2280 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2281 .info = snd_rme_spdif_if_info, 2282 .get = snd_rme_spdif_if_get, 2283 }, 2284 { 2285 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2286 .name = "SPDIF Format", 2287 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2288 .info = snd_rme_spdif_format_info, 2289 .get = snd_rme_spdif_format_get, 2290 }, 2291 { 2292 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2293 .name = "Sync Source", 2294 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2295 .info = snd_rme_sync_source_info, 2296 .get = snd_rme_sync_source_get 2297 }, 2298 { 2299 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2300 .name = "System Rate", 2301 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2302 .info = snd_rme_rate_info, 2303 .get = snd_rme_rate_get, 2304 .private_value = SND_RME_DOMAIN_SYSTEM 2305 }, 2306 { 2307 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2308 .name = "Current Frequency", 2309 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 2310 .info = snd_rme_rate_info, 2311 .get = snd_rme_current_freq_get 2312 } 2313 }; 2314 2315 static int snd_rme_controls_create(struct usb_mixer_interface *mixer) 2316 { 2317 int err, i; 2318 2319 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) { 2320 err = add_single_ctl_with_resume(mixer, 0, 2321 NULL, 2322 &snd_rme_controls[i], 2323 NULL); 2324 if (err < 0) 2325 return err; 2326 } 2327 2328 return 0; 2329 } 2330 2331 /* 2332 * RME Babyface Pro (FS) 2333 * 2334 * These devices exposes a couple of DSP functions via request to EP0. 2335 * Switches are available via control registers, while routing is controlled 2336 * by controlling the volume on each possible crossing point. 2337 * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with 2338 * 0dB being at dec. 32768. 2339 */ 2340 enum { 2341 SND_BBFPRO_CTL_REG1 = 0, 2342 SND_BBFPRO_CTL_REG2 2343 }; 2344 2345 #define SND_BBFPRO_CTL_REG_MASK 1 2346 #define SND_BBFPRO_CTL_IDX_MASK 0xff 2347 #define SND_BBFPRO_CTL_IDX_SHIFT 1 2348 #define SND_BBFPRO_CTL_VAL_MASK 1 2349 #define SND_BBFPRO_CTL_VAL_SHIFT 9 2350 #define SND_BBFPRO_CTL_REG1_CLK_MASTER 0 2351 #define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1 2352 #define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7 2353 #define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8 2354 #define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10 2355 #define SND_BBFPRO_CTL_REG2_48V_AN1 0 2356 #define SND_BBFPRO_CTL_REG2_48V_AN2 1 2357 #define SND_BBFPRO_CTL_REG2_SENS_IN3 2 2358 #define SND_BBFPRO_CTL_REG2_SENS_IN4 3 2359 #define SND_BBFPRO_CTL_REG2_PAD_AN1 4 2360 #define SND_BBFPRO_CTL_REG2_PAD_AN2 5 2361 2362 #define SND_BBFPRO_MIXER_IDX_MASK 0x1ff 2363 #define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff 2364 #define SND_BBFPRO_MIXER_VAL_SHIFT 9 2365 #define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf 2366 #define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB 2367 2368 #define SND_BBFPRO_USBREQ_CTL_REG1 0x10 2369 #define SND_BBFPRO_USBREQ_CTL_REG2 0x17 2370 #define SND_BBFPRO_USBREQ_MIXER 0x12 2371 2372 static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg, 2373 u8 index, u8 value) 2374 { 2375 int err; 2376 u16 usb_req, usb_idx, usb_val; 2377 struct snd_usb_audio *chip = mixer->chip; 2378 2379 err = snd_usb_lock_shutdown(chip); 2380 if (err < 0) 2381 return err; 2382 2383 if (reg == SND_BBFPRO_CTL_REG1) { 2384 usb_req = SND_BBFPRO_USBREQ_CTL_REG1; 2385 if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) { 2386 usb_idx = 3; 2387 usb_val = value ? 3 : 0; 2388 } else { 2389 usb_idx = 1 << index; 2390 usb_val = value ? usb_idx : 0; 2391 } 2392 } else { 2393 usb_req = SND_BBFPRO_USBREQ_CTL_REG2; 2394 usb_idx = 1 << index; 2395 usb_val = value ? usb_idx : 0; 2396 } 2397 2398 err = snd_usb_ctl_msg(chip->dev, 2399 usb_sndctrlpipe(chip->dev, 0), usb_req, 2400 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 2401 usb_val, usb_idx, NULL, 0); 2402 2403 snd_usb_unlock_shutdown(chip); 2404 return err; 2405 } 2406 2407 static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol, 2408 struct snd_ctl_elem_value *ucontrol) 2409 { 2410 u8 reg, idx, val; 2411 int pv; 2412 2413 pv = kcontrol->private_value; 2414 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2415 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2416 val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT; 2417 2418 if ((reg == SND_BBFPRO_CTL_REG1 && 2419 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) || 2420 (reg == SND_BBFPRO_CTL_REG2 && 2421 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || 2422 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) { 2423 ucontrol->value.enumerated.item[0] = val; 2424 } else { 2425 ucontrol->value.integer.value[0] = val; 2426 } 2427 return 0; 2428 } 2429 2430 static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol, 2431 struct snd_ctl_elem_info *uinfo) 2432 { 2433 u8 reg, idx; 2434 int pv; 2435 2436 pv = kcontrol->private_value; 2437 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2438 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2439 2440 if (reg == SND_BBFPRO_CTL_REG1 && 2441 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) { 2442 static const char * const texts[2] = { 2443 "AutoSync", 2444 "Internal" 2445 }; 2446 return snd_ctl_enum_info(uinfo, 1, 2, texts); 2447 } else if (reg == SND_BBFPRO_CTL_REG2 && 2448 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || 2449 idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) { 2450 static const char * const texts[2] = { 2451 "-10dBV", 2452 "+4dBu" 2453 }; 2454 return snd_ctl_enum_info(uinfo, 1, 2, texts); 2455 } 2456 2457 uinfo->count = 1; 2458 uinfo->value.integer.min = 0; 2459 uinfo->value.integer.max = 1; 2460 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 2461 return 0; 2462 } 2463 2464 static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol, 2465 struct snd_ctl_elem_value *ucontrol) 2466 { 2467 int err; 2468 u8 reg, idx; 2469 int old_value, pv, val; 2470 2471 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2472 struct usb_mixer_interface *mixer = list->mixer; 2473 2474 pv = kcontrol->private_value; 2475 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2476 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2477 old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK; 2478 2479 if ((reg == SND_BBFPRO_CTL_REG1 && 2480 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) || 2481 (reg == SND_BBFPRO_CTL_REG2 && 2482 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || 2483 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) { 2484 val = ucontrol->value.enumerated.item[0]; 2485 } else { 2486 val = ucontrol->value.integer.value[0]; 2487 } 2488 2489 if (val > 1) 2490 return -EINVAL; 2491 2492 if (val == old_value) 2493 return 0; 2494 2495 kcontrol->private_value = reg 2496 | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT) 2497 | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT); 2498 2499 err = snd_bbfpro_ctl_update(mixer, reg, idx, val); 2500 return err < 0 ? err : 1; 2501 } 2502 2503 static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list) 2504 { 2505 u8 reg, idx; 2506 int value, pv; 2507 2508 pv = list->kctl->private_value; 2509 reg = pv & SND_BBFPRO_CTL_REG_MASK; 2510 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; 2511 value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK; 2512 2513 return snd_bbfpro_ctl_update(list->mixer, reg, idx, value); 2514 } 2515 2516 static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index, 2517 u32 value) 2518 { 2519 struct snd_usb_audio *chip = mixer->chip; 2520 int err; 2521 u16 idx; 2522 u16 usb_idx, usb_val; 2523 u32 v; 2524 2525 err = snd_usb_lock_shutdown(chip); 2526 if (err < 0) 2527 return err; 2528 2529 idx = index & SND_BBFPRO_MIXER_IDX_MASK; 2530 // 18 bit linear volume, split so 2 bits end up in index. 2531 v = value & SND_BBFPRO_MIXER_VAL_MASK; 2532 usb_idx = idx | (v & 0x3) << 14; 2533 usb_val = (v >> 2) & 0xffff; 2534 2535 err = snd_usb_ctl_msg(chip->dev, 2536 usb_sndctrlpipe(chip->dev, 0), 2537 SND_BBFPRO_USBREQ_MIXER, 2538 USB_DIR_OUT | USB_TYPE_VENDOR | 2539 USB_RECIP_DEVICE, 2540 usb_val, usb_idx, NULL, 0); 2541 2542 snd_usb_unlock_shutdown(chip); 2543 return err; 2544 } 2545 2546 static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol, 2547 struct snd_ctl_elem_value *ucontrol) 2548 { 2549 ucontrol->value.integer.value[0] = 2550 kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT; 2551 return 0; 2552 } 2553 2554 static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol, 2555 struct snd_ctl_elem_info *uinfo) 2556 { 2557 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2558 uinfo->count = 1; 2559 uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN; 2560 uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX; 2561 return 0; 2562 } 2563 2564 static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol, 2565 struct snd_ctl_elem_value *ucontrol) 2566 { 2567 int err; 2568 u16 idx; 2569 u32 new_val, old_value, uvalue; 2570 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); 2571 struct usb_mixer_interface *mixer = list->mixer; 2572 2573 uvalue = ucontrol->value.integer.value[0]; 2574 idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK; 2575 old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT; 2576 2577 if (uvalue > SND_BBFPRO_MIXER_VAL_MAX) 2578 return -EINVAL; 2579 2580 if (uvalue == old_value) 2581 return 0; 2582 2583 new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK; 2584 2585 kcontrol->private_value = idx 2586 | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT); 2587 2588 err = snd_bbfpro_vol_update(mixer, idx, new_val); 2589 return err < 0 ? err : 1; 2590 } 2591 2592 static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list) 2593 { 2594 int pv = list->kctl->private_value; 2595 u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK; 2596 u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT) 2597 & SND_BBFPRO_MIXER_VAL_MASK; 2598 return snd_bbfpro_vol_update(list->mixer, idx, val); 2599 } 2600 2601 // Predfine elements 2602 static const struct snd_kcontrol_new snd_bbfpro_ctl_control = { 2603 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2604 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 2605 .index = 0, 2606 .info = snd_bbfpro_ctl_info, 2607 .get = snd_bbfpro_ctl_get, 2608 .put = snd_bbfpro_ctl_put 2609 }; 2610 2611 static const struct snd_kcontrol_new snd_bbfpro_vol_control = { 2612 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2613 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 2614 .index = 0, 2615 .info = snd_bbfpro_vol_info, 2616 .get = snd_bbfpro_vol_get, 2617 .put = snd_bbfpro_vol_put 2618 }; 2619 2620 static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg, 2621 u8 index, char *name) 2622 { 2623 struct snd_kcontrol_new knew = snd_bbfpro_ctl_control; 2624 2625 knew.name = name; 2626 knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK) 2627 | ((index & SND_BBFPRO_CTL_IDX_MASK) 2628 << SND_BBFPRO_CTL_IDX_SHIFT); 2629 2630 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume, 2631 &knew, NULL); 2632 } 2633 2634 static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index, 2635 char *name) 2636 { 2637 struct snd_kcontrol_new knew = snd_bbfpro_vol_control; 2638 2639 knew.name = name; 2640 knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK; 2641 2642 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume, 2643 &knew, NULL); 2644 } 2645 2646 static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer) 2647 { 2648 int err, i, o; 2649 char name[48]; 2650 2651 static const char * const input[] = { 2652 "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3", 2653 "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"}; 2654 2655 static const char * const output[] = { 2656 "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4", 2657 "ADAT5", "ADAT6", "ADAT7", "ADAT8"}; 2658 2659 for (o = 0 ; o < 12 ; ++o) { 2660 for (i = 0 ; i < 12 ; ++i) { 2661 // Line routing 2662 snprintf(name, sizeof(name), 2663 "%s-%s-%s Playback Volume", 2664 (i < 2 ? "Mic" : "Line"), 2665 input[i], output[o]); 2666 err = snd_bbfpro_vol_add(mixer, (26 * o + i), name); 2667 if (err < 0) 2668 return err; 2669 2670 // PCM routing... yes, it is output remapping 2671 snprintf(name, sizeof(name), 2672 "PCM-%s-%s Playback Volume", 2673 output[i], output[o]); 2674 err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i), 2675 name); 2676 if (err < 0) 2677 return err; 2678 } 2679 } 2680 2681 // Control Reg 1 2682 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2683 SND_BBFPRO_CTL_REG1_CLK_OPTICAL, 2684 "Sample Clock Source"); 2685 if (err < 0) 2686 return err; 2687 2688 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2689 SND_BBFPRO_CTL_REG1_SPDIF_PRO, 2690 "IEC958 Pro Mask"); 2691 if (err < 0) 2692 return err; 2693 2694 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2695 SND_BBFPRO_CTL_REG1_SPDIF_EMPH, 2696 "IEC958 Emphasis"); 2697 if (err < 0) 2698 return err; 2699 2700 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, 2701 SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL, 2702 "IEC958 Switch"); 2703 if (err < 0) 2704 return err; 2705 2706 // Control Reg 2 2707 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2708 SND_BBFPRO_CTL_REG2_48V_AN1, 2709 "Mic-AN1 48V"); 2710 if (err < 0) 2711 return err; 2712 2713 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2714 SND_BBFPRO_CTL_REG2_48V_AN2, 2715 "Mic-AN2 48V"); 2716 if (err < 0) 2717 return err; 2718 2719 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2720 SND_BBFPRO_CTL_REG2_SENS_IN3, 2721 "Line-IN3 Sens."); 2722 if (err < 0) 2723 return err; 2724 2725 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2726 SND_BBFPRO_CTL_REG2_SENS_IN4, 2727 "Line-IN4 Sens."); 2728 if (err < 0) 2729 return err; 2730 2731 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2732 SND_BBFPRO_CTL_REG2_PAD_AN1, 2733 "Mic-AN1 PAD"); 2734 if (err < 0) 2735 return err; 2736 2737 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, 2738 SND_BBFPRO_CTL_REG2_PAD_AN2, 2739 "Mic-AN2 PAD"); 2740 if (err < 0) 2741 return err; 2742 2743 return 0; 2744 } 2745 2746 /* 2747 * Pioneer DJ DJM Mixers 2748 * 2749 * These devices generally have options for soft-switching the playback and 2750 * capture sources in addition to the recording level. Although different 2751 * devices have different configurations, there seems to be canonical values 2752 * for specific capture/playback types: See the definitions of these below. 2753 * 2754 * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to 2755 * capture phono would be 0x0203. Capture, playback and capture level have 2756 * different wIndexes. 2757 */ 2758 2759 // Capture types 2760 #define SND_DJM_CAP_LINE 0x00 2761 #define SND_DJM_CAP_CDLINE 0x01 2762 #define SND_DJM_CAP_DIGITAL 0x02 2763 #define SND_DJM_CAP_PHONO 0x03 2764 #define SND_DJM_CAP_PFADER 0x06 2765 #define SND_DJM_CAP_XFADERA 0x07 2766 #define SND_DJM_CAP_XFADERB 0x08 2767 #define SND_DJM_CAP_MIC 0x09 2768 #define SND_DJM_CAP_AUX 0x0d 2769 #define SND_DJM_CAP_RECOUT 0x0a 2770 #define SND_DJM_CAP_NONE 0x0f 2771 #define SND_DJM_CAP_CH1PFADER 0x11 2772 #define SND_DJM_CAP_CH2PFADER 0x12 2773 #define SND_DJM_CAP_CH3PFADER 0x13 2774 #define SND_DJM_CAP_CH4PFADER 0x14 2775 2776 // Playback types 2777 #define SND_DJM_PB_CH1 0x00 2778 #define SND_DJM_PB_CH2 0x01 2779 #define SND_DJM_PB_AUX 0x04 2780 2781 #define SND_DJM_WINDEX_CAP 0x8002 2782 #define SND_DJM_WINDEX_CAPLVL 0x8003 2783 #define SND_DJM_WINDEX_PB 0x8016 2784 2785 // kcontrol->private_value layout 2786 #define SND_DJM_VALUE_MASK 0x0000ffff 2787 #define SND_DJM_GROUP_MASK 0x00ff0000 2788 #define SND_DJM_DEVICE_MASK 0xff000000 2789 #define SND_DJM_GROUP_SHIFT 16 2790 #define SND_DJM_DEVICE_SHIFT 24 2791 2792 // device table index 2793 // used for the snd_djm_devices table, so please update accordingly 2794 #define SND_DJM_250MK2_IDX 0x0 2795 #define SND_DJM_750_IDX 0x1 2796 #define SND_DJM_850_IDX 0x2 2797 #define SND_DJM_900NXS2_IDX 0x3 2798 #define SND_DJM_750MK2_IDX 0x4 2799 2800 2801 #define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \ 2802 .name = _name, \ 2803 .options = snd_djm_opts_##suffix, \ 2804 .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \ 2805 .default_value = _default_value, \ 2806 .wIndex = _windex } 2807 2808 #define SND_DJM_DEVICE(suffix) { \ 2809 .controls = snd_djm_ctls_##suffix, \ 2810 .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) } 2811 2812 2813 struct snd_djm_device { 2814 const char *name; 2815 const struct snd_djm_ctl *controls; 2816 size_t ncontrols; 2817 }; 2818 2819 struct snd_djm_ctl { 2820 const char *name; 2821 const u16 *options; 2822 size_t noptions; 2823 u16 default_value; 2824 u16 wIndex; 2825 }; 2826 2827 static const char *snd_djm_get_label_caplevel(u16 wvalue) 2828 { 2829 switch (wvalue) { 2830 case 0x0000: return "-19dB"; 2831 case 0x0100: return "-15dB"; 2832 case 0x0200: return "-10dB"; 2833 case 0x0300: return "-5dB"; 2834 default: return NULL; 2835 } 2836 }; 2837 2838 static const char *snd_djm_get_label_cap_common(u16 wvalue) 2839 { 2840 switch (wvalue & 0x00ff) { 2841 case SND_DJM_CAP_LINE: return "Control Tone LINE"; 2842 case SND_DJM_CAP_CDLINE: return "Control Tone CD/LINE"; 2843 case SND_DJM_CAP_DIGITAL: return "Control Tone DIGITAL"; 2844 case SND_DJM_CAP_PHONO: return "Control Tone PHONO"; 2845 case SND_DJM_CAP_PFADER: return "Post Fader"; 2846 case SND_DJM_CAP_XFADERA: return "Cross Fader A"; 2847 case SND_DJM_CAP_XFADERB: return "Cross Fader B"; 2848 case SND_DJM_CAP_MIC: return "Mic"; 2849 case SND_DJM_CAP_RECOUT: return "Rec Out"; 2850 case SND_DJM_CAP_AUX: return "Aux"; 2851 case SND_DJM_CAP_NONE: return "None"; 2852 case SND_DJM_CAP_CH1PFADER: return "Post Fader Ch1"; 2853 case SND_DJM_CAP_CH2PFADER: return "Post Fader Ch2"; 2854 case SND_DJM_CAP_CH3PFADER: return "Post Fader Ch3"; 2855 case SND_DJM_CAP_CH4PFADER: return "Post Fader Ch4"; 2856 default: return NULL; 2857 } 2858 }; 2859 2860 // The DJM-850 has different values for CD/LINE and LINE capture 2861 // control options than the other DJM declared in this file. 2862 static const char *snd_djm_get_label_cap_850(u16 wvalue) 2863 { 2864 switch (wvalue & 0x00ff) { 2865 case 0x00: return "Control Tone CD/LINE"; 2866 case 0x01: return "Control Tone LINE"; 2867 default: return snd_djm_get_label_cap_common(wvalue); 2868 } 2869 }; 2870 2871 static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue) 2872 { 2873 switch (device_idx) { 2874 case SND_DJM_850_IDX: return snd_djm_get_label_cap_850(wvalue); 2875 default: return snd_djm_get_label_cap_common(wvalue); 2876 } 2877 }; 2878 2879 static const char *snd_djm_get_label_pb(u16 wvalue) 2880 { 2881 switch (wvalue & 0x00ff) { 2882 case SND_DJM_PB_CH1: return "Ch1"; 2883 case SND_DJM_PB_CH2: return "Ch2"; 2884 case SND_DJM_PB_AUX: return "Aux"; 2885 default: return NULL; 2886 } 2887 }; 2888 2889 static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex) 2890 { 2891 switch (windex) { 2892 case SND_DJM_WINDEX_CAPLVL: return snd_djm_get_label_caplevel(wvalue); 2893 case SND_DJM_WINDEX_CAP: return snd_djm_get_label_cap(device_idx, wvalue); 2894 case SND_DJM_WINDEX_PB: return snd_djm_get_label_pb(wvalue); 2895 default: return NULL; 2896 } 2897 }; 2898 2899 // common DJM capture level option values 2900 static const u16 snd_djm_opts_cap_level[] = { 2901 0x0000, 0x0100, 0x0200, 0x0300 }; 2902 2903 2904 // DJM-250MK2 2905 static const u16 snd_djm_opts_250mk2_cap1[] = { 2906 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a }; 2907 2908 static const u16 snd_djm_opts_250mk2_cap2[] = { 2909 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a }; 2910 2911 static const u16 snd_djm_opts_250mk2_cap3[] = { 2912 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d }; 2913 2914 static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 }; 2915 static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 }; 2916 static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 }; 2917 2918 static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = { 2919 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2920 SND_DJM_CTL("Ch1 Input", 250mk2_cap1, 2, SND_DJM_WINDEX_CAP), 2921 SND_DJM_CTL("Ch2 Input", 250mk2_cap2, 2, SND_DJM_WINDEX_CAP), 2922 SND_DJM_CTL("Ch3 Input", 250mk2_cap3, 0, SND_DJM_WINDEX_CAP), 2923 SND_DJM_CTL("Ch1 Output", 250mk2_pb1, 0, SND_DJM_WINDEX_PB), 2924 SND_DJM_CTL("Ch2 Output", 250mk2_pb2, 1, SND_DJM_WINDEX_PB), 2925 SND_DJM_CTL("Ch3 Output", 250mk2_pb3, 2, SND_DJM_WINDEX_PB) 2926 }; 2927 2928 2929 // DJM-750 2930 static const u16 snd_djm_opts_750_cap1[] = { 2931 0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; 2932 static const u16 snd_djm_opts_750_cap2[] = { 2933 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; 2934 static const u16 snd_djm_opts_750_cap3[] = { 2935 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; 2936 static const u16 snd_djm_opts_750_cap4[] = { 2937 0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; 2938 2939 static const struct snd_djm_ctl snd_djm_ctls_750[] = { 2940 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2941 SND_DJM_CTL("Ch1 Input", 750_cap1, 2, SND_DJM_WINDEX_CAP), 2942 SND_DJM_CTL("Ch2 Input", 750_cap2, 2, SND_DJM_WINDEX_CAP), 2943 SND_DJM_CTL("Ch3 Input", 750_cap3, 0, SND_DJM_WINDEX_CAP), 2944 SND_DJM_CTL("Ch4 Input", 750_cap4, 0, SND_DJM_WINDEX_CAP) 2945 }; 2946 2947 2948 // DJM-850 2949 static const u16 snd_djm_opts_850_cap1[] = { 2950 0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; 2951 static const u16 snd_djm_opts_850_cap2[] = { 2952 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; 2953 static const u16 snd_djm_opts_850_cap3[] = { 2954 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; 2955 static const u16 snd_djm_opts_850_cap4[] = { 2956 0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; 2957 2958 static const struct snd_djm_ctl snd_djm_ctls_850[] = { 2959 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2960 SND_DJM_CTL("Ch1 Input", 850_cap1, 1, SND_DJM_WINDEX_CAP), 2961 SND_DJM_CTL("Ch2 Input", 850_cap2, 0, SND_DJM_WINDEX_CAP), 2962 SND_DJM_CTL("Ch3 Input", 850_cap3, 0, SND_DJM_WINDEX_CAP), 2963 SND_DJM_CTL("Ch4 Input", 850_cap4, 1, SND_DJM_WINDEX_CAP) 2964 }; 2965 2966 2967 // DJM-900NXS2 2968 static const u16 snd_djm_opts_900nxs2_cap1[] = { 2969 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a }; 2970 static const u16 snd_djm_opts_900nxs2_cap2[] = { 2971 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a }; 2972 static const u16 snd_djm_opts_900nxs2_cap3[] = { 2973 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a }; 2974 static const u16 snd_djm_opts_900nxs2_cap4[] = { 2975 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a }; 2976 static const u16 snd_djm_opts_900nxs2_cap5[] = { 2977 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 }; 2978 2979 static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = { 2980 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 2981 SND_DJM_CTL("Ch1 Input", 900nxs2_cap1, 2, SND_DJM_WINDEX_CAP), 2982 SND_DJM_CTL("Ch2 Input", 900nxs2_cap2, 2, SND_DJM_WINDEX_CAP), 2983 SND_DJM_CTL("Ch3 Input", 900nxs2_cap3, 2, SND_DJM_WINDEX_CAP), 2984 SND_DJM_CTL("Ch4 Input", 900nxs2_cap4, 2, SND_DJM_WINDEX_CAP), 2985 SND_DJM_CTL("Ch5 Input", 900nxs2_cap5, 3, SND_DJM_WINDEX_CAP) 2986 }; 2987 2988 // DJM-750MK2 2989 static const u16 snd_djm_opts_750mk2_cap1[] = { 2990 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a }; 2991 static const u16 snd_djm_opts_750mk2_cap2[] = { 2992 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a }; 2993 static const u16 snd_djm_opts_750mk2_cap3[] = { 2994 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a }; 2995 static const u16 snd_djm_opts_750mk2_cap4[] = { 2996 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a }; 2997 static const u16 snd_djm_opts_750mk2_cap5[] = { 2998 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 }; 2999 3000 static const u16 snd_djm_opts_750mk2_pb1[] = { 0x0100, 0x0101, 0x0104 }; 3001 static const u16 snd_djm_opts_750mk2_pb2[] = { 0x0200, 0x0201, 0x0204 }; 3002 static const u16 snd_djm_opts_750mk2_pb3[] = { 0x0300, 0x0301, 0x0304 }; 3003 3004 3005 static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = { 3006 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), 3007 SND_DJM_CTL("Ch1 Input", 750mk2_cap1, 2, SND_DJM_WINDEX_CAP), 3008 SND_DJM_CTL("Ch2 Input", 750mk2_cap2, 2, SND_DJM_WINDEX_CAP), 3009 SND_DJM_CTL("Ch3 Input", 750mk2_cap3, 2, SND_DJM_WINDEX_CAP), 3010 SND_DJM_CTL("Ch4 Input", 750mk2_cap4, 2, SND_DJM_WINDEX_CAP), 3011 SND_DJM_CTL("Ch5 Input", 750mk2_cap5, 3, SND_DJM_WINDEX_CAP), 3012 SND_DJM_CTL("Ch1 Output", 750mk2_pb1, 0, SND_DJM_WINDEX_PB), 3013 SND_DJM_CTL("Ch2 Output", 750mk2_pb2, 1, SND_DJM_WINDEX_PB), 3014 SND_DJM_CTL("Ch3 Output", 750mk2_pb3, 2, SND_DJM_WINDEX_PB) 3015 }; 3016 3017 3018 static const struct snd_djm_device snd_djm_devices[] = { 3019 [SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2), 3020 [SND_DJM_750_IDX] = SND_DJM_DEVICE(750), 3021 [SND_DJM_850_IDX] = SND_DJM_DEVICE(850), 3022 [SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2), 3023 [SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2), 3024 }; 3025 3026 3027 static int snd_djm_controls_info(struct snd_kcontrol *kctl, 3028 struct snd_ctl_elem_info *info) 3029 { 3030 unsigned long private_value = kctl->private_value; 3031 u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 3032 u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 3033 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 3034 const char *name; 3035 const struct snd_djm_ctl *ctl; 3036 size_t noptions; 3037 3038 if (ctl_idx >= device->ncontrols) 3039 return -EINVAL; 3040 3041 ctl = &device->controls[ctl_idx]; 3042 noptions = ctl->noptions; 3043 if (info->value.enumerated.item >= noptions) 3044 info->value.enumerated.item = noptions - 1; 3045 3046 name = snd_djm_get_label(device_idx, 3047 ctl->options[info->value.enumerated.item], 3048 ctl->wIndex); 3049 if (!name) 3050 return -EINVAL; 3051 3052 strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name)); 3053 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3054 info->count = 1; 3055 info->value.enumerated.items = noptions; 3056 return 0; 3057 } 3058 3059 static int snd_djm_controls_update(struct usb_mixer_interface *mixer, 3060 u8 device_idx, u8 group, u16 value) 3061 { 3062 int err; 3063 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 3064 3065 if ((group >= device->ncontrols) || value >= device->controls[group].noptions) 3066 return -EINVAL; 3067 3068 err = snd_usb_lock_shutdown(mixer->chip); 3069 if (err) 3070 return err; 3071 3072 err = snd_usb_ctl_msg( 3073 mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0), 3074 USB_REQ_SET_FEATURE, 3075 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 3076 device->controls[group].options[value], 3077 device->controls[group].wIndex, 3078 NULL, 0); 3079 3080 snd_usb_unlock_shutdown(mixer->chip); 3081 return err; 3082 } 3083 3084 static int snd_djm_controls_get(struct snd_kcontrol *kctl, 3085 struct snd_ctl_elem_value *elem) 3086 { 3087 elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK; 3088 return 0; 3089 } 3090 3091 static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem) 3092 { 3093 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); 3094 struct usb_mixer_interface *mixer = list->mixer; 3095 unsigned long private_value = kctl->private_value; 3096 3097 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 3098 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 3099 u16 value = elem->value.enumerated.item[0]; 3100 3101 kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) | 3102 (group << SND_DJM_GROUP_SHIFT) | 3103 value); 3104 3105 return snd_djm_controls_update(mixer, device, group, value); 3106 } 3107 3108 static int snd_djm_controls_resume(struct usb_mixer_elem_list *list) 3109 { 3110 unsigned long private_value = list->kctl->private_value; 3111 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; 3112 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; 3113 u16 value = (private_value & SND_DJM_VALUE_MASK); 3114 3115 return snd_djm_controls_update(list->mixer, device, group, value); 3116 } 3117 3118 static int snd_djm_controls_create(struct usb_mixer_interface *mixer, 3119 const u8 device_idx) 3120 { 3121 int err, i; 3122 u16 value; 3123 3124 const struct snd_djm_device *device = &snd_djm_devices[device_idx]; 3125 3126 struct snd_kcontrol_new knew = { 3127 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3128 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 3129 .index = 0, 3130 .info = snd_djm_controls_info, 3131 .get = snd_djm_controls_get, 3132 .put = snd_djm_controls_put 3133 }; 3134 3135 for (i = 0; i < device->ncontrols; i++) { 3136 value = device->controls[i].default_value; 3137 knew.name = device->controls[i].name; 3138 knew.private_value = ( 3139 ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) | 3140 (i << SND_DJM_GROUP_SHIFT) | 3141 value); 3142 err = snd_djm_controls_update(mixer, device_idx, i, value); 3143 if (err) 3144 return err; 3145 err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume, 3146 &knew, NULL); 3147 if (err) 3148 return err; 3149 } 3150 return 0; 3151 } 3152 3153 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer) 3154 { 3155 int err = 0; 3156 3157 err = snd_usb_soundblaster_remote_init(mixer); 3158 if (err < 0) 3159 return err; 3160 3161 switch (mixer->chip->usb_id) { 3162 /* Tascam US-16x08 */ 3163 case USB_ID(0x0644, 0x8047): 3164 err = snd_us16x08_controls_create(mixer); 3165 break; 3166 case USB_ID(0x041e, 0x3020): 3167 case USB_ID(0x041e, 0x3040): 3168 case USB_ID(0x041e, 0x3042): 3169 case USB_ID(0x041e, 0x30df): 3170 case USB_ID(0x041e, 0x3048): 3171 err = snd_audigy2nx_controls_create(mixer); 3172 if (err < 0) 3173 break; 3174 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx", 3175 mixer, snd_audigy2nx_proc_read); 3176 break; 3177 3178 /* EMU0204 */ 3179 case USB_ID(0x041e, 0x3f19): 3180 err = snd_emu0204_controls_create(mixer); 3181 break; 3182 3183 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ 3184 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */ 3185 err = snd_c400_create_mixer(mixer); 3186 break; 3187 3188 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ 3189 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ 3190 err = snd_ftu_create_mixer(mixer); 3191 break; 3192 3193 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */ 3194 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */ 3195 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */ 3196 err = snd_xonar_u1_controls_create(mixer); 3197 break; 3198 3199 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */ 3200 err = snd_microii_controls_create(mixer); 3201 break; 3202 3203 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */ 3204 err = snd_mbox1_controls_create(mixer); 3205 break; 3206 3207 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */ 3208 err = snd_nativeinstruments_create_mixer(mixer, 3209 snd_nativeinstruments_ta6_mixers, 3210 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers)); 3211 break; 3212 3213 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */ 3214 err = snd_nativeinstruments_create_mixer(mixer, 3215 snd_nativeinstruments_ta10_mixers, 3216 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers)); 3217 break; 3218 3219 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */ 3220 /* detection is disabled in mixer_maps.c */ 3221 err = snd_create_std_mono_table(mixer, ebox44_table); 3222 break; 3223 3224 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */ 3225 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */ 3226 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */ 3227 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */ 3228 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */ 3229 err = snd_scarlett_controls_create(mixer); 3230 break; 3231 3232 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */ 3233 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */ 3234 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */ 3235 case USB_ID(0x1235, 0x8211): /* Focusrite Scarlett Solo 3rd Gen */ 3236 case USB_ID(0x1235, 0x8210): /* Focusrite Scarlett 2i2 3rd Gen */ 3237 case USB_ID(0x1235, 0x8212): /* Focusrite Scarlett 4i4 3rd Gen */ 3238 case USB_ID(0x1235, 0x8213): /* Focusrite Scarlett 8i6 3rd Gen */ 3239 case USB_ID(0x1235, 0x8214): /* Focusrite Scarlett 18i8 3rd Gen */ 3240 case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */ 3241 err = snd_scarlett_gen2_init(mixer); 3242 break; 3243 3244 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */ 3245 err = snd_soundblaster_e1_switch_create(mixer); 3246 break; 3247 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 3248 err = dell_dock_mixer_init(mixer); 3249 break; 3250 3251 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */ 3252 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */ 3253 case USB_ID(0x2a39, 0x3fd4): /* RME */ 3254 err = snd_rme_controls_create(mixer); 3255 break; 3256 3257 case USB_ID(0x194f, 0x010c): /* Presonus Studio 1810c */ 3258 err = snd_sc1810_init_mixer(mixer); 3259 break; 3260 case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */ 3261 err = snd_bbfpro_controls_create(mixer); 3262 break; 3263 case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */ 3264 err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX); 3265 break; 3266 case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */ 3267 err = snd_djm_controls_create(mixer, SND_DJM_750_IDX); 3268 break; 3269 case USB_ID(0x2b73, 0x001b): /* Pioneer DJ DJM-750MK2 */ 3270 err = snd_djm_controls_create(mixer, SND_DJM_750MK2_IDX); 3271 break; 3272 case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */ 3273 err = snd_djm_controls_create(mixer, SND_DJM_850_IDX); 3274 break; 3275 case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */ 3276 err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX); 3277 break; 3278 } 3279 3280 return err; 3281 } 3282 3283 #ifdef CONFIG_PM 3284 void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer) 3285 { 3286 switch (mixer->chip->usb_id) { 3287 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ 3288 dell_dock_mixer_init(mixer); 3289 break; 3290 } 3291 } 3292 #endif 3293 3294 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer, 3295 int unitid) 3296 { 3297 if (!mixer->rc_cfg) 3298 return; 3299 /* unit ids specific to Extigy/Audigy 2 NX: */ 3300 switch (unitid) { 3301 case 0: /* remote control */ 3302 mixer->rc_urb->dev = mixer->chip->dev; 3303 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC); 3304 break; 3305 case 4: /* digital in jack */ 3306 case 7: /* line in jacks */ 3307 case 19: /* speaker out jacks */ 3308 case 20: /* headphones out jack */ 3309 break; 3310 /* live24ext: 4 = line-in jack */ 3311 case 3: /* hp-out jack (may actuate Mute) */ 3312 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 3313 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 3314 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id); 3315 break; 3316 default: 3317 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid); 3318 break; 3319 } 3320 } 3321 3322 static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer, 3323 struct usb_mixer_elem_info *cval, 3324 struct snd_kcontrol *kctl) 3325 { 3326 /* Approximation using 10 ranges based on output measurement on hw v1.2. 3327 * This seems close to the cubic mapping e.g. alsamixer uses. */ 3328 static const DECLARE_TLV_DB_RANGE(scale, 3329 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970), 3330 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160), 3331 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710), 3332 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560), 3333 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324), 3334 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031), 3335 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393), 3336 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032), 3337 32, 40, TLV_DB_MINMAX_ITEM(-968, -490), 3338 41, 50, TLV_DB_MINMAX_ITEM(-441, 0), 3339 ); 3340 3341 if (cval->min == 0 && cval->max == 50) { 3342 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n"); 3343 kctl->tlv.p = scale; 3344 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; 3345 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 3346 3347 } else if (cval->min == 0 && cval->max <= 1000) { 3348 /* Some other clearly broken DragonFly variant. 3349 * At least a 0..53 variant (hw v1.0) exists. 3350 */ 3351 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device"); 3352 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 3353 } 3354 } 3355 3356 void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer, 3357 struct usb_mixer_elem_info *cval, int unitid, 3358 struct snd_kcontrol *kctl) 3359 { 3360 switch (mixer->chip->usb_id) { 3361 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */ 3362 if (unitid == 7 && cval->control == UAC_FU_VOLUME) 3363 snd_dragonfly_quirk_db_scale(mixer, cval, kctl); 3364 break; 3365 /* lowest playback value is muted on C-Media devices */ 3366 case USB_ID(0x0d8c, 0x000c): 3367 case USB_ID(0x0d8c, 0x0014): 3368 if (strstr(kctl->id.name, "Playback")) 3369 cval->min_mute = 1; 3370 break; 3371 } 3372 } 3373 3374