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