1 /* 2 * USB Audio Driver for ALSA 3 * 4 * Quirks and vendor-specific extensions for mixer interfaces 5 * 6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de> 7 * 8 * Many codes borrowed from audio.c by 9 * Alan Cox (alan@lxorguk.ukuu.org.uk) 10 * Thomas Sailer (sailer@ife.ee.ethz.ch) 11 * 12 * Audio Advantage Micro II support added by: 13 * Przemek Rudy (prudy1@o2.pl) 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or 18 * (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 28 */ 29 30 #include <linux/init.h> 31 #include <linux/slab.h> 32 #include <linux/usb.h> 33 #include <linux/usb/audio.h> 34 35 #include <sound/asoundef.h> 36 #include <sound/core.h> 37 #include <sound/control.h> 38 #include <sound/hwdep.h> 39 #include <sound/info.h> 40 41 #include "usbaudio.h" 42 #include "mixer.h" 43 #include "mixer_quirks.h" 44 #include "helper.h" 45 46 extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl; 47 48 struct std_mono_table { 49 unsigned int unitid, control, cmask; 50 int val_type; 51 const char *name; 52 snd_kcontrol_tlv_rw_t *tlv_callback; 53 }; 54 55 /* private_free callback */ 56 static void usb_mixer_elem_free(struct snd_kcontrol *kctl) 57 { 58 kfree(kctl->private_data); 59 kctl->private_data = NULL; 60 } 61 62 /* This function allows for the creation of standard UAC controls. 63 * See the quirks for M-Audio FTUs or Ebox-44. 64 * If you don't want to set a TLV callback pass NULL. 65 * 66 * Since there doesn't seem to be a devices that needs a multichannel 67 * version, we keep it mono for simplicity. 68 */ 69 static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer, 70 unsigned int unitid, 71 unsigned int control, 72 unsigned int cmask, 73 int val_type, 74 unsigned int idx_off, 75 const char *name, 76 snd_kcontrol_tlv_rw_t *tlv_callback) 77 { 78 int err; 79 struct usb_mixer_elem_info *cval; 80 struct snd_kcontrol *kctl; 81 82 cval = kzalloc(sizeof(*cval), GFP_KERNEL); 83 if (!cval) 84 return -ENOMEM; 85 86 cval->id = unitid; 87 cval->mixer = mixer; 88 cval->val_type = val_type; 89 cval->channels = 1; 90 cval->control = control; 91 cval->cmask = cmask; 92 cval->idx_off = idx_off; 93 94 /* get_min_max() is called only for integer volumes later, 95 * so provide a short-cut for booleans */ 96 cval->min = 0; 97 cval->max = 1; 98 cval->res = 0; 99 cval->dBmin = 0; 100 cval->dBmax = 0; 101 102 /* Create control */ 103 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval); 104 if (!kctl) { 105 kfree(cval); 106 return -ENOMEM; 107 } 108 109 /* Set name */ 110 snprintf(kctl->id.name, sizeof(kctl->id.name), name); 111 kctl->private_free = usb_mixer_elem_free; 112 113 /* set TLV */ 114 if (tlv_callback) { 115 kctl->tlv.c = tlv_callback; 116 kctl->vd[0].access |= 117 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 118 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 119 } 120 /* Add control to mixer */ 121 err = snd_usb_mixer_add_control(mixer, kctl); 122 if (err < 0) 123 return err; 124 125 return 0; 126 } 127 128 static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer, 129 unsigned int unitid, 130 unsigned int control, 131 unsigned int cmask, 132 int val_type, 133 const char *name, 134 snd_kcontrol_tlv_rw_t *tlv_callback) 135 { 136 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask, 137 val_type, 0 /* Offset */, name, tlv_callback); 138 } 139 140 /* 141 * Create a set of standard UAC controls from a table 142 */ 143 static int snd_create_std_mono_table(struct usb_mixer_interface *mixer, 144 struct std_mono_table *t) 145 { 146 int err; 147 148 while (t->name != NULL) { 149 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control, 150 t->cmask, t->val_type, t->name, t->tlv_callback); 151 if (err < 0) 152 return err; 153 t++; 154 } 155 156 return 0; 157 } 158 159 /* 160 * Sound Blaster remote control configuration 161 * 162 * format of remote control data: 163 * Extigy: xx 00 164 * Audigy 2 NX: 06 80 xx 00 00 00 165 * Live! 24-bit: 06 80 xx yy 22 83 166 */ 167 static const struct rc_config { 168 u32 usb_id; 169 u8 offset; 170 u8 length; 171 u8 packet_length; 172 u8 min_packet_length; /* minimum accepted length of the URB result */ 173 u8 mute_mixer_id; 174 u32 mute_code; 175 } rc_configs[] = { 176 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */ 177 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */ 178 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */ 179 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */ 180 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ 181 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */ 182 }; 183 184 static void snd_usb_soundblaster_remote_complete(struct urb *urb) 185 { 186 struct usb_mixer_interface *mixer = urb->context; 187 const struct rc_config *rc = mixer->rc_cfg; 188 u32 code; 189 190 if (urb->status < 0 || urb->actual_length < rc->min_packet_length) 191 return; 192 193 code = mixer->rc_buffer[rc->offset]; 194 if (rc->length == 2) 195 code |= mixer->rc_buffer[rc->offset + 1] << 8; 196 197 /* the Mute button actually changes the mixer control */ 198 if (code == rc->mute_code) 199 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id); 200 mixer->rc_code = code; 201 wmb(); 202 wake_up(&mixer->rc_waitq); 203 } 204 205 static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf, 206 long count, loff_t *offset) 207 { 208 struct usb_mixer_interface *mixer = hw->private_data; 209 int err; 210 u32 rc_code; 211 212 if (count != 1 && count != 4) 213 return -EINVAL; 214 err = wait_event_interruptible(mixer->rc_waitq, 215 (rc_code = xchg(&mixer->rc_code, 0)) != 0); 216 if (err == 0) { 217 if (count == 1) 218 err = put_user(rc_code, buf); 219 else 220 err = put_user(rc_code, (u32 __user *)buf); 221 } 222 return err < 0 ? err : count; 223 } 224 225 static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file, 226 poll_table *wait) 227 { 228 struct usb_mixer_interface *mixer = hw->private_data; 229 230 poll_wait(file, &mixer->rc_waitq, wait); 231 return mixer->rc_code ? POLLIN | POLLRDNORM : 0; 232 } 233 234 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) 235 { 236 struct snd_hwdep *hwdep; 237 int err, len, i; 238 239 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i) 240 if (rc_configs[i].usb_id == mixer->chip->usb_id) 241 break; 242 if (i >= ARRAY_SIZE(rc_configs)) 243 return 0; 244 mixer->rc_cfg = &rc_configs[i]; 245 246 len = mixer->rc_cfg->packet_length; 247 248 init_waitqueue_head(&mixer->rc_waitq); 249 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep); 250 if (err < 0) 251 return err; 252 snprintf(hwdep->name, sizeof(hwdep->name), 253 "%s remote control", mixer->chip->card->shortname); 254 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC; 255 hwdep->private_data = mixer; 256 hwdep->ops.read = snd_usb_sbrc_hwdep_read; 257 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll; 258 hwdep->exclusive = 1; 259 260 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL); 261 if (!mixer->rc_urb) 262 return -ENOMEM; 263 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL); 264 if (!mixer->rc_setup_packet) { 265 usb_free_urb(mixer->rc_urb); 266 mixer->rc_urb = NULL; 267 return -ENOMEM; 268 } 269 mixer->rc_setup_packet->bRequestType = 270 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE; 271 mixer->rc_setup_packet->bRequest = UAC_GET_MEM; 272 mixer->rc_setup_packet->wValue = cpu_to_le16(0); 273 mixer->rc_setup_packet->wIndex = cpu_to_le16(0); 274 mixer->rc_setup_packet->wLength = cpu_to_le16(len); 275 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev, 276 usb_rcvctrlpipe(mixer->chip->dev, 0), 277 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len, 278 snd_usb_soundblaster_remote_complete, mixer); 279 return 0; 280 } 281 282 #define snd_audigy2nx_led_info snd_ctl_boolean_mono_info 283 284 static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 285 { 286 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 287 int index = kcontrol->private_value; 288 289 ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index]; 290 return 0; 291 } 292 293 static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 294 { 295 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 296 int index = kcontrol->private_value; 297 int value = ucontrol->value.integer.value[0]; 298 int err, changed; 299 300 if (value > 1) 301 return -EINVAL; 302 changed = value != mixer->audigy2nx_leds[index]; 303 down_read(&mixer->chip->shutdown_rwsem); 304 if (mixer->chip->shutdown) { 305 err = -ENODEV; 306 goto out; 307 } 308 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) 309 err = snd_usb_ctl_msg(mixer->chip->dev, 310 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24, 311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 312 !value, 0, NULL, 0); 313 /* USB X-Fi S51 Pro */ 314 if (mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) 315 err = snd_usb_ctl_msg(mixer->chip->dev, 316 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24, 317 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 318 !value, 0, NULL, 0); 319 else 320 err = snd_usb_ctl_msg(mixer->chip->dev, 321 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24, 322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 323 value, index + 2, NULL, 0); 324 out: 325 up_read(&mixer->chip->shutdown_rwsem); 326 if (err < 0) 327 return err; 328 mixer->audigy2nx_leds[index] = value; 329 return changed; 330 } 331 332 static struct snd_kcontrol_new snd_audigy2nx_controls[] = { 333 { 334 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 335 .name = "CMSS LED Switch", 336 .info = snd_audigy2nx_led_info, 337 .get = snd_audigy2nx_led_get, 338 .put = snd_audigy2nx_led_put, 339 .private_value = 0, 340 }, 341 { 342 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 343 .name = "Power LED Switch", 344 .info = snd_audigy2nx_led_info, 345 .get = snd_audigy2nx_led_get, 346 .put = snd_audigy2nx_led_put, 347 .private_value = 1, 348 }, 349 { 350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 351 .name = "Dolby Digital LED Switch", 352 .info = snd_audigy2nx_led_info, 353 .get = snd_audigy2nx_led_get, 354 .put = snd_audigy2nx_led_put, 355 .private_value = 2, 356 }, 357 }; 358 359 static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer) 360 { 361 int i, err; 362 363 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) { 364 /* USB X-Fi S51 doesn't have a CMSS LED */ 365 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0) 366 continue; 367 /* USB X-Fi S51 Pro doesn't have one either */ 368 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0) 369 continue; 370 if (i > 1 && /* Live24ext has 2 LEDs only */ 371 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 372 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) || 373 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) || 374 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))) 375 break; 376 err = snd_ctl_add(mixer->chip->card, 377 snd_ctl_new1(&snd_audigy2nx_controls[i], mixer)); 378 if (err < 0) 379 return err; 380 } 381 mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */ 382 return 0; 383 } 384 385 static void snd_audigy2nx_proc_read(struct snd_info_entry *entry, 386 struct snd_info_buffer *buffer) 387 { 388 static const struct sb_jack { 389 int unitid; 390 const char *name; 391 } jacks_audigy2nx[] = { 392 {4, "dig in "}, 393 {7, "line in"}, 394 {19, "spk out"}, 395 {20, "hph out"}, 396 {-1, NULL} 397 }, jacks_live24ext[] = { 398 {4, "line in"}, /* &1=Line, &2=Mic*/ 399 {3, "hph out"}, /* headphones */ 400 {0, "RC "}, /* last command, 6 bytes see rc_config above */ 401 {-1, NULL} 402 }; 403 const struct sb_jack *jacks; 404 struct usb_mixer_interface *mixer = entry->private_data; 405 int i, err; 406 u8 buf[3]; 407 408 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname); 409 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) 410 jacks = jacks_audigy2nx; 411 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 412 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 413 jacks = jacks_live24ext; 414 else 415 return; 416 417 for (i = 0; jacks[i].name; ++i) { 418 snd_iprintf(buffer, "%s: ", jacks[i].name); 419 down_read(&mixer->chip->shutdown_rwsem); 420 if (mixer->chip->shutdown) 421 err = 0; 422 else 423 err = snd_usb_ctl_msg(mixer->chip->dev, 424 usb_rcvctrlpipe(mixer->chip->dev, 0), 425 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS | 426 USB_RECIP_INTERFACE, 0, 427 jacks[i].unitid << 8, buf, 3); 428 up_read(&mixer->chip->shutdown_rwsem); 429 if (err == 3 && (buf[0] == 3 || buf[0] == 6)) 430 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]); 431 else 432 snd_iprintf(buffer, "?\n"); 433 } 434 } 435 436 /* ASUS Xonar U1 / U3 controls */ 437 438 static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol, 439 struct snd_ctl_elem_value *ucontrol) 440 { 441 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 442 443 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02); 444 return 0; 445 } 446 447 static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol, 448 struct snd_ctl_elem_value *ucontrol) 449 { 450 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 451 u8 old_status, new_status; 452 int err, changed; 453 454 old_status = mixer->xonar_u1_status; 455 if (ucontrol->value.integer.value[0]) 456 new_status = old_status | 0x02; 457 else 458 new_status = old_status & ~0x02; 459 changed = new_status != old_status; 460 down_read(&mixer->chip->shutdown_rwsem); 461 if (mixer->chip->shutdown) 462 err = -ENODEV; 463 else 464 err = snd_usb_ctl_msg(mixer->chip->dev, 465 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08, 466 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 467 50, 0, &new_status, 1); 468 up_read(&mixer->chip->shutdown_rwsem); 469 if (err < 0) 470 return err; 471 mixer->xonar_u1_status = new_status; 472 return changed; 473 } 474 475 static struct snd_kcontrol_new snd_xonar_u1_output_switch = { 476 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 477 .name = "Digital Playback Switch", 478 .info = snd_ctl_boolean_mono_info, 479 .get = snd_xonar_u1_switch_get, 480 .put = snd_xonar_u1_switch_put, 481 }; 482 483 static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer) 484 { 485 int err; 486 487 err = snd_ctl_add(mixer->chip->card, 488 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer)); 489 if (err < 0) 490 return err; 491 mixer->xonar_u1_status = 0x05; 492 return 0; 493 } 494 495 /* Native Instruments device quirks */ 496 497 #define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex)) 498 499 static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol, 500 struct snd_ctl_elem_value *ucontrol) 501 { 502 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 503 struct usb_device *dev = mixer->chip->dev; 504 u8 bRequest = (kcontrol->private_value >> 16) & 0xff; 505 u16 wIndex = kcontrol->private_value & 0xffff; 506 u8 tmp; 507 int ret; 508 509 down_read(&mixer->chip->shutdown_rwsem); 510 if (mixer->chip->shutdown) 511 ret = -ENODEV; 512 else 513 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest, 514 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 515 0, wIndex, 516 &tmp, sizeof(tmp), 1000); 517 up_read(&mixer->chip->shutdown_rwsem); 518 519 if (ret < 0) { 520 snd_printk(KERN_ERR 521 "unable to issue vendor read request (ret = %d)", ret); 522 return ret; 523 } 524 525 ucontrol->value.integer.value[0] = tmp; 526 527 return 0; 528 } 529 530 static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol, 531 struct snd_ctl_elem_value *ucontrol) 532 { 533 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 534 struct usb_device *dev = mixer->chip->dev; 535 u8 bRequest = (kcontrol->private_value >> 16) & 0xff; 536 u16 wIndex = kcontrol->private_value & 0xffff; 537 u16 wValue = ucontrol->value.integer.value[0]; 538 int ret; 539 540 down_read(&mixer->chip->shutdown_rwsem); 541 if (mixer->chip->shutdown) 542 ret = -ENODEV; 543 else 544 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest, 545 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 546 wValue, wIndex, 547 NULL, 0, 1000); 548 up_read(&mixer->chip->shutdown_rwsem); 549 550 if (ret < 0) { 551 snd_printk(KERN_ERR 552 "unable to issue vendor write request (ret = %d)", ret); 553 return ret; 554 } 555 556 return 0; 557 } 558 559 static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = { 560 { 561 .name = "Direct Thru Channel A", 562 .private_value = _MAKE_NI_CONTROL(0x01, 0x03), 563 }, 564 { 565 .name = "Direct Thru Channel B", 566 .private_value = _MAKE_NI_CONTROL(0x01, 0x05), 567 }, 568 { 569 .name = "Phono Input Channel A", 570 .private_value = _MAKE_NI_CONTROL(0x02, 0x03), 571 }, 572 { 573 .name = "Phono Input Channel B", 574 .private_value = _MAKE_NI_CONTROL(0x02, 0x05), 575 }, 576 }; 577 578 static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = { 579 { 580 .name = "Direct Thru Channel A", 581 .private_value = _MAKE_NI_CONTROL(0x01, 0x03), 582 }, 583 { 584 .name = "Direct Thru Channel B", 585 .private_value = _MAKE_NI_CONTROL(0x01, 0x05), 586 }, 587 { 588 .name = "Direct Thru Channel C", 589 .private_value = _MAKE_NI_CONTROL(0x01, 0x07), 590 }, 591 { 592 .name = "Direct Thru Channel D", 593 .private_value = _MAKE_NI_CONTROL(0x01, 0x09), 594 }, 595 { 596 .name = "Phono Input Channel A", 597 .private_value = _MAKE_NI_CONTROL(0x02, 0x03), 598 }, 599 { 600 .name = "Phono Input Channel B", 601 .private_value = _MAKE_NI_CONTROL(0x02, 0x05), 602 }, 603 { 604 .name = "Phono Input Channel C", 605 .private_value = _MAKE_NI_CONTROL(0x02, 0x07), 606 }, 607 { 608 .name = "Phono Input Channel D", 609 .private_value = _MAKE_NI_CONTROL(0x02, 0x09), 610 }, 611 }; 612 613 static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer, 614 const struct snd_kcontrol_new *kc, 615 unsigned int count) 616 { 617 int i, err = 0; 618 struct snd_kcontrol_new template = { 619 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 620 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 621 .get = snd_nativeinstruments_control_get, 622 .put = snd_nativeinstruments_control_put, 623 .info = snd_ctl_boolean_mono_info, 624 }; 625 626 for (i = 0; i < count; i++) { 627 struct snd_kcontrol *c; 628 629 template.name = kc[i].name; 630 template.private_value = kc[i].private_value; 631 632 c = snd_ctl_new1(&template, mixer); 633 err = snd_ctl_add(mixer->chip->card, c); 634 635 if (err < 0) 636 break; 637 } 638 639 return err; 640 } 641 642 /* M-Audio FastTrack Ultra quirks */ 643 /* FTU Effect switch (also used by C400/C600) */ 644 struct snd_ftu_eff_switch_priv_val { 645 struct usb_mixer_interface *mixer; 646 int cached_value; 647 int is_cached; 648 int bUnitID; 649 int validx; 650 }; 651 652 static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol, 653 struct snd_ctl_elem_info *uinfo) 654 { 655 static const char *texts[8] = {"Room 1", 656 "Room 2", 657 "Room 3", 658 "Hall 1", 659 "Hall 2", 660 "Plate", 661 "Delay", 662 "Echo" 663 }; 664 665 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 666 uinfo->count = 1; 667 uinfo->value.enumerated.items = 8; 668 if (uinfo->value.enumerated.item > 7) 669 uinfo->value.enumerated.item = 7; 670 strcpy(uinfo->value.enumerated.name, 671 texts[uinfo->value.enumerated.item]); 672 673 return 0; 674 } 675 676 static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl, 677 struct snd_ctl_elem_value *ucontrol) 678 { 679 struct snd_usb_audio *chip; 680 struct usb_mixer_interface *mixer; 681 struct snd_ftu_eff_switch_priv_val *pval; 682 int err; 683 unsigned char value[2]; 684 int id, validx; 685 686 const int val_len = 2; 687 688 value[0] = 0x00; 689 value[1] = 0x00; 690 691 pval = (struct snd_ftu_eff_switch_priv_val *) 692 kctl->private_value; 693 694 if (pval->is_cached) { 695 ucontrol->value.enumerated.item[0] = pval->cached_value; 696 return 0; 697 } 698 699 mixer = (struct usb_mixer_interface *) pval->mixer; 700 if (snd_BUG_ON(!mixer)) 701 return -EINVAL; 702 703 chip = (struct snd_usb_audio *) mixer->chip; 704 if (snd_BUG_ON(!chip)) 705 return -EINVAL; 706 707 id = pval->bUnitID; 708 validx = pval->validx; 709 710 down_read(&mixer->chip->shutdown_rwsem); 711 if (mixer->chip->shutdown) 712 err = -ENODEV; 713 else 714 err = snd_usb_ctl_msg(chip->dev, 715 usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR, 716 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 717 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8), 718 value, val_len); 719 up_read(&mixer->chip->shutdown_rwsem); 720 if (err < 0) 721 return err; 722 723 ucontrol->value.enumerated.item[0] = value[0]; 724 pval->cached_value = value[0]; 725 pval->is_cached = 1; 726 727 return 0; 728 } 729 730 static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl, 731 struct snd_ctl_elem_value *ucontrol) 732 { 733 struct snd_usb_audio *chip; 734 struct snd_ftu_eff_switch_priv_val *pval; 735 736 struct usb_mixer_interface *mixer; 737 int changed, cur_val, err, new_val; 738 unsigned char value[2]; 739 int id, validx; 740 741 const int val_len = 2; 742 743 changed = 0; 744 745 pval = (struct snd_ftu_eff_switch_priv_val *) 746 kctl->private_value; 747 cur_val = pval->cached_value; 748 new_val = ucontrol->value.enumerated.item[0]; 749 750 mixer = (struct usb_mixer_interface *) pval->mixer; 751 if (snd_BUG_ON(!mixer)) 752 return -EINVAL; 753 754 chip = (struct snd_usb_audio *) mixer->chip; 755 if (snd_BUG_ON(!chip)) 756 return -EINVAL; 757 758 id = pval->bUnitID; 759 validx = pval->validx; 760 761 if (!pval->is_cached) { 762 /* Read current value */ 763 down_read(&mixer->chip->shutdown_rwsem); 764 if (mixer->chip->shutdown) 765 err = -ENODEV; 766 else 767 err = snd_usb_ctl_msg(chip->dev, 768 usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR, 769 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 770 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8), 771 value, val_len); 772 up_read(&mixer->chip->shutdown_rwsem); 773 if (err < 0) 774 return err; 775 776 cur_val = value[0]; 777 pval->cached_value = cur_val; 778 pval->is_cached = 1; 779 } 780 /* update value if needed */ 781 if (cur_val != new_val) { 782 value[0] = new_val; 783 value[1] = 0; 784 down_read(&mixer->chip->shutdown_rwsem); 785 if (mixer->chip->shutdown) 786 err = -ENODEV; 787 else 788 err = snd_usb_ctl_msg(chip->dev, 789 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, 790 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 791 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8), 792 value, val_len); 793 up_read(&mixer->chip->shutdown_rwsem); 794 if (err < 0) 795 return err; 796 797 pval->cached_value = new_val; 798 pval->is_cached = 1; 799 changed = 1; 800 } 801 802 return changed; 803 } 804 805 static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer, 806 int validx, int bUnitID) 807 { 808 static struct snd_kcontrol_new template = { 809 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 810 .name = "Effect Program Switch", 811 .index = 0, 812 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 813 .info = snd_ftu_eff_switch_info, 814 .get = snd_ftu_eff_switch_get, 815 .put = snd_ftu_eff_switch_put 816 }; 817 818 int err; 819 struct snd_kcontrol *kctl; 820 struct snd_ftu_eff_switch_priv_val *pval; 821 822 pval = kzalloc(sizeof(*pval), GFP_KERNEL); 823 if (!pval) 824 return -ENOMEM; 825 826 pval->cached_value = 0; 827 pval->is_cached = 0; 828 pval->mixer = mixer; 829 pval->bUnitID = bUnitID; 830 pval->validx = validx; 831 832 template.private_value = (unsigned long) pval; 833 kctl = snd_ctl_new1(&template, mixer->chip); 834 if (!kctl) { 835 kfree(pval); 836 return -ENOMEM; 837 } 838 839 err = snd_ctl_add(mixer->chip->card, kctl); 840 if (err < 0) 841 return err; 842 843 return 0; 844 } 845 846 /* Create volume controls for FTU devices*/ 847 static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer) 848 { 849 char name[64]; 850 unsigned int control, cmask; 851 int in, out, err; 852 853 const unsigned int id = 5; 854 const int val_type = USB_MIXER_S16; 855 856 for (out = 0; out < 8; out++) { 857 control = out + 1; 858 for (in = 0; in < 8; in++) { 859 cmask = 1 << in; 860 snprintf(name, sizeof(name), 861 "AIn%d - Out%d Capture Volume", 862 in + 1, out + 1); 863 err = snd_create_std_mono_ctl(mixer, id, control, 864 cmask, val_type, name, 865 &snd_usb_mixer_vol_tlv); 866 if (err < 0) 867 return err; 868 } 869 for (in = 8; in < 16; in++) { 870 cmask = 1 << in; 871 snprintf(name, sizeof(name), 872 "DIn%d - Out%d Playback Volume", 873 in - 7, out + 1); 874 err = snd_create_std_mono_ctl(mixer, id, control, 875 cmask, val_type, name, 876 &snd_usb_mixer_vol_tlv); 877 if (err < 0) 878 return err; 879 } 880 } 881 882 return 0; 883 } 884 885 /* This control needs a volume quirk, see mixer.c */ 886 static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer) 887 { 888 static const char name[] = "Effect Volume"; 889 const unsigned int id = 6; 890 const int val_type = USB_MIXER_U8; 891 const unsigned int control = 2; 892 const unsigned int cmask = 0; 893 894 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 895 name, snd_usb_mixer_vol_tlv); 896 } 897 898 /* This control needs a volume quirk, see mixer.c */ 899 static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer) 900 { 901 static const char name[] = "Effect Duration"; 902 const unsigned int id = 6; 903 const int val_type = USB_MIXER_S16; 904 const unsigned int control = 3; 905 const unsigned int cmask = 0; 906 907 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 908 name, snd_usb_mixer_vol_tlv); 909 } 910 911 /* This control needs a volume quirk, see mixer.c */ 912 static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) 913 { 914 static const char name[] = "Effect Feedback Volume"; 915 const unsigned int id = 6; 916 const int val_type = USB_MIXER_U8; 917 const unsigned int control = 4; 918 const unsigned int cmask = 0; 919 920 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 921 name, NULL); 922 } 923 924 static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer) 925 { 926 unsigned int cmask; 927 int err, ch; 928 char name[48]; 929 930 const unsigned int id = 7; 931 const int val_type = USB_MIXER_S16; 932 const unsigned int control = 7; 933 934 for (ch = 0; ch < 4; ++ch) { 935 cmask = 1 << ch; 936 snprintf(name, sizeof(name), 937 "Effect Return %d Volume", ch + 1); 938 err = snd_create_std_mono_ctl(mixer, id, control, 939 cmask, val_type, name, 940 snd_usb_mixer_vol_tlv); 941 if (err < 0) 942 return err; 943 } 944 945 return 0; 946 } 947 948 static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer) 949 { 950 unsigned int cmask; 951 int err, ch; 952 char name[48]; 953 954 const unsigned int id = 5; 955 const int val_type = USB_MIXER_S16; 956 const unsigned int control = 9; 957 958 for (ch = 0; ch < 8; ++ch) { 959 cmask = 1 << ch; 960 snprintf(name, sizeof(name), 961 "Effect Send AIn%d Volume", ch + 1); 962 err = snd_create_std_mono_ctl(mixer, id, control, cmask, 963 val_type, name, 964 snd_usb_mixer_vol_tlv); 965 if (err < 0) 966 return err; 967 } 968 for (ch = 8; ch < 16; ++ch) { 969 cmask = 1 << ch; 970 snprintf(name, sizeof(name), 971 "Effect Send DIn%d Volume", ch - 7); 972 err = snd_create_std_mono_ctl(mixer, id, control, cmask, 973 val_type, name, 974 snd_usb_mixer_vol_tlv); 975 if (err < 0) 976 return err; 977 } 978 return 0; 979 } 980 981 static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer) 982 { 983 int err; 984 985 err = snd_ftu_create_volume_ctls(mixer); 986 if (err < 0) 987 return err; 988 989 err = snd_ftu_create_effect_switch(mixer, 1, 6); 990 if (err < 0) 991 return err; 992 993 err = snd_ftu_create_effect_volume_ctl(mixer); 994 if (err < 0) 995 return err; 996 997 err = snd_ftu_create_effect_duration_ctl(mixer); 998 if (err < 0) 999 return err; 1000 1001 err = snd_ftu_create_effect_feedback_ctl(mixer); 1002 if (err < 0) 1003 return err; 1004 1005 err = snd_ftu_create_effect_return_ctls(mixer); 1006 if (err < 0) 1007 return err; 1008 1009 err = snd_ftu_create_effect_send_ctls(mixer); 1010 if (err < 0) 1011 return err; 1012 1013 return 0; 1014 } 1015 1016 void snd_emuusb_set_samplerate(struct snd_usb_audio *chip, 1017 unsigned char samplerate_id) 1018 { 1019 struct usb_mixer_interface *mixer; 1020 struct usb_mixer_elem_info *cval; 1021 int unitid = 12; /* SamleRate ExtensionUnit ID */ 1022 1023 list_for_each_entry(mixer, &chip->mixer_list, list) { 1024 cval = mixer->id_elems[unitid]; 1025 if (cval) { 1026 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, 1027 cval->control << 8, 1028 samplerate_id); 1029 snd_usb_mixer_notify_id(mixer, unitid); 1030 } 1031 break; 1032 } 1033 } 1034 1035 /* M-Audio Fast Track C400/C600 */ 1036 /* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */ 1037 static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer) 1038 { 1039 char name[64]; 1040 unsigned int cmask, offset; 1041 int out, chan, err; 1042 int num_outs = 0; 1043 int num_ins = 0; 1044 1045 const unsigned int id = 0x40; 1046 const int val_type = USB_MIXER_S16; 1047 const int control = 1; 1048 1049 switch (mixer->chip->usb_id) { 1050 case USB_ID(0x0763, 0x2030): 1051 num_outs = 6; 1052 num_ins = 4; 1053 break; 1054 case USB_ID(0x0763, 0x2031): 1055 num_outs = 8; 1056 num_ins = 6; 1057 break; 1058 } 1059 1060 for (chan = 0; chan < num_outs + num_ins; chan++) { 1061 for (out = 0; out < num_outs; out++) { 1062 if (chan < num_outs) { 1063 snprintf(name, sizeof(name), 1064 "PCM%d-Out%d Playback Volume", 1065 chan + 1, out + 1); 1066 } else { 1067 snprintf(name, sizeof(name), 1068 "In%d-Out%d Playback Volume", 1069 chan - num_outs + 1, out + 1); 1070 } 1071 1072 cmask = (out == 0) ? 0 : 1 << (out - 1); 1073 offset = chan * num_outs; 1074 err = snd_create_std_mono_ctl_offset(mixer, id, control, 1075 cmask, val_type, offset, name, 1076 &snd_usb_mixer_vol_tlv); 1077 if (err < 0) 1078 return err; 1079 } 1080 } 1081 1082 return 0; 1083 } 1084 1085 /* This control needs a volume quirk, see mixer.c */ 1086 static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer) 1087 { 1088 static const char name[] = "Effect Volume"; 1089 const unsigned int id = 0x43; 1090 const int val_type = USB_MIXER_U8; 1091 const unsigned int control = 3; 1092 const unsigned int cmask = 0; 1093 1094 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1095 name, snd_usb_mixer_vol_tlv); 1096 } 1097 1098 /* This control needs a volume quirk, see mixer.c */ 1099 static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer) 1100 { 1101 static const char name[] = "Effect Duration"; 1102 const unsigned int id = 0x43; 1103 const int val_type = USB_MIXER_S16; 1104 const unsigned int control = 4; 1105 const unsigned int cmask = 0; 1106 1107 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1108 name, snd_usb_mixer_vol_tlv); 1109 } 1110 1111 /* This control needs a volume quirk, see mixer.c */ 1112 static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) 1113 { 1114 static const char name[] = "Effect Feedback Volume"; 1115 const unsigned int id = 0x43; 1116 const int val_type = USB_MIXER_U8; 1117 const unsigned int control = 5; 1118 const unsigned int cmask = 0; 1119 1120 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, 1121 name, NULL); 1122 } 1123 1124 static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer) 1125 { 1126 char name[64]; 1127 unsigned int cmask; 1128 int chan, err; 1129 int num_outs = 0; 1130 int num_ins = 0; 1131 1132 const unsigned int id = 0x42; 1133 const int val_type = USB_MIXER_S16; 1134 const int control = 1; 1135 1136 switch (mixer->chip->usb_id) { 1137 case USB_ID(0x0763, 0x2030): 1138 num_outs = 6; 1139 num_ins = 4; 1140 break; 1141 case USB_ID(0x0763, 0x2031): 1142 num_outs = 8; 1143 num_ins = 6; 1144 break; 1145 } 1146 1147 for (chan = 0; chan < num_outs + num_ins; chan++) { 1148 if (chan < num_outs) { 1149 snprintf(name, sizeof(name), 1150 "Effect Send DOut%d", 1151 chan + 1); 1152 } else { 1153 snprintf(name, sizeof(name), 1154 "Effect Send AIn%d", 1155 chan - num_outs + 1); 1156 } 1157 1158 cmask = (chan == 0) ? 0 : 1 << (chan - 1); 1159 err = snd_create_std_mono_ctl(mixer, id, control, 1160 cmask, val_type, name, 1161 &snd_usb_mixer_vol_tlv); 1162 if (err < 0) 1163 return err; 1164 } 1165 1166 return 0; 1167 } 1168 1169 static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer) 1170 { 1171 char name[64]; 1172 unsigned int cmask; 1173 int chan, err; 1174 int num_outs = 0; 1175 int offset = 0; 1176 1177 const unsigned int id = 0x40; 1178 const int val_type = USB_MIXER_S16; 1179 const int control = 1; 1180 1181 switch (mixer->chip->usb_id) { 1182 case USB_ID(0x0763, 0x2030): 1183 num_outs = 6; 1184 offset = 0x3c; 1185 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */ 1186 break; 1187 case USB_ID(0x0763, 0x2031): 1188 num_outs = 8; 1189 offset = 0x70; 1190 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */ 1191 break; 1192 } 1193 1194 for (chan = 0; chan < num_outs; chan++) { 1195 snprintf(name, sizeof(name), 1196 "Effect Return %d", 1197 chan + 1); 1198 1199 cmask = (chan == 0) ? 0 : 1200 1 << (chan + (chan % 2) * num_outs - 1); 1201 err = snd_create_std_mono_ctl_offset(mixer, id, control, 1202 cmask, val_type, offset, name, 1203 &snd_usb_mixer_vol_tlv); 1204 if (err < 0) 1205 return err; 1206 } 1207 1208 return 0; 1209 } 1210 1211 static int snd_c400_create_mixer(struct usb_mixer_interface *mixer) 1212 { 1213 int err; 1214 1215 err = snd_c400_create_vol_ctls(mixer); 1216 if (err < 0) 1217 return err; 1218 1219 err = snd_c400_create_effect_vol_ctls(mixer); 1220 if (err < 0) 1221 return err; 1222 1223 err = snd_c400_create_effect_ret_vol_ctls(mixer); 1224 if (err < 0) 1225 return err; 1226 1227 err = snd_ftu_create_effect_switch(mixer, 2, 0x43); 1228 if (err < 0) 1229 return err; 1230 1231 err = snd_c400_create_effect_volume_ctl(mixer); 1232 if (err < 0) 1233 return err; 1234 1235 err = snd_c400_create_effect_duration_ctl(mixer); 1236 if (err < 0) 1237 return err; 1238 1239 err = snd_c400_create_effect_feedback_ctl(mixer); 1240 if (err < 0) 1241 return err; 1242 1243 return 0; 1244 } 1245 1246 /* 1247 * The mixer units for Ebox-44 are corrupt, and even where they 1248 * are valid they presents mono controls as L and R channels of 1249 * stereo. So we provide a good mixer here. 1250 */ 1251 static struct std_mono_table ebox44_table[] = { 1252 { 1253 .unitid = 4, 1254 .control = 1, 1255 .cmask = 0x0, 1256 .val_type = USB_MIXER_INV_BOOLEAN, 1257 .name = "Headphone Playback Switch" 1258 }, 1259 { 1260 .unitid = 4, 1261 .control = 2, 1262 .cmask = 0x1, 1263 .val_type = USB_MIXER_S16, 1264 .name = "Headphone A Mix Playback Volume" 1265 }, 1266 { 1267 .unitid = 4, 1268 .control = 2, 1269 .cmask = 0x2, 1270 .val_type = USB_MIXER_S16, 1271 .name = "Headphone B Mix Playback Volume" 1272 }, 1273 1274 { 1275 .unitid = 7, 1276 .control = 1, 1277 .cmask = 0x0, 1278 .val_type = USB_MIXER_INV_BOOLEAN, 1279 .name = "Output Playback Switch" 1280 }, 1281 { 1282 .unitid = 7, 1283 .control = 2, 1284 .cmask = 0x1, 1285 .val_type = USB_MIXER_S16, 1286 .name = "Output A Playback Volume" 1287 }, 1288 { 1289 .unitid = 7, 1290 .control = 2, 1291 .cmask = 0x2, 1292 .val_type = USB_MIXER_S16, 1293 .name = "Output B Playback Volume" 1294 }, 1295 1296 { 1297 .unitid = 10, 1298 .control = 1, 1299 .cmask = 0x0, 1300 .val_type = USB_MIXER_INV_BOOLEAN, 1301 .name = "Input Capture Switch" 1302 }, 1303 { 1304 .unitid = 10, 1305 .control = 2, 1306 .cmask = 0x1, 1307 .val_type = USB_MIXER_S16, 1308 .name = "Input A Capture Volume" 1309 }, 1310 { 1311 .unitid = 10, 1312 .control = 2, 1313 .cmask = 0x2, 1314 .val_type = USB_MIXER_S16, 1315 .name = "Input B Capture Volume" 1316 }, 1317 1318 {} 1319 }; 1320 1321 /* Audio Advantage Micro II findings: 1322 * 1323 * Mapping spdif AES bits to vendor register.bit: 1324 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00 1325 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01 1326 * AES2: [0 0 0 0 0 0 0 0] 1327 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request 1328 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices 1329 * 1330 * power on values: 1331 * r2: 0x10 1332 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set 1333 * just after it to 0xa0, presumably it disables/mutes some analog 1334 * parts when there is no audio.) 1335 * r9: 0x28 1336 * 1337 * Optical transmitter on/off: 1338 * vendor register.bit: 9.1 1339 * 0 - on (0x28 register value) 1340 * 1 - off (0x2a register value) 1341 * 1342 */ 1343 static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol, 1344 struct snd_ctl_elem_info *uinfo) 1345 { 1346 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 1347 uinfo->count = 1; 1348 return 0; 1349 } 1350 1351 static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol, 1352 struct snd_ctl_elem_value *ucontrol) 1353 { 1354 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 1355 int err; 1356 struct usb_interface *iface; 1357 struct usb_host_interface *alts; 1358 unsigned int ep; 1359 unsigned char data[3]; 1360 int rate; 1361 1362 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff; 1363 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff; 1364 ucontrol->value.iec958.status[2] = 0x00; 1365 1366 /* use known values for that card: interface#1 altsetting#1 */ 1367 iface = usb_ifnum_to_if(mixer->chip->dev, 1); 1368 alts = &iface->altsetting[1]; 1369 ep = get_endpoint(alts, 0)->bEndpointAddress; 1370 1371 err = snd_usb_ctl_msg(mixer->chip->dev, 1372 usb_rcvctrlpipe(mixer->chip->dev, 0), 1373 UAC_GET_CUR, 1374 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, 1375 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, 1376 ep, 1377 data, 1378 sizeof(data)); 1379 if (err < 0) 1380 goto end; 1381 1382 rate = data[0] | (data[1] << 8) | (data[2] << 16); 1383 ucontrol->value.iec958.status[3] = (rate == 48000) ? 1384 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100; 1385 1386 err = 0; 1387 end: 1388 return err; 1389 } 1390 1391 static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol, 1392 struct snd_ctl_elem_value *ucontrol) 1393 { 1394 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 1395 int err; 1396 u8 reg; 1397 unsigned long priv_backup = kcontrol->private_value; 1398 1399 reg = ((ucontrol->value.iec958.status[1] & 0x0f) << 4) | 1400 (ucontrol->value.iec958.status[0] & 0x0f); 1401 err = snd_usb_ctl_msg(mixer->chip->dev, 1402 usb_sndctrlpipe(mixer->chip->dev, 0), 1403 UAC_SET_CUR, 1404 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1405 reg, 1406 2, 1407 NULL, 1408 0); 1409 if (err < 0) 1410 goto end; 1411 1412 kcontrol->private_value &= 0xfffff0f0; 1413 kcontrol->private_value |= (ucontrol->value.iec958.status[1] & 0x0f) << 8; 1414 kcontrol->private_value |= (ucontrol->value.iec958.status[0] & 0x0f); 1415 1416 reg = (ucontrol->value.iec958.status[0] & IEC958_AES0_NONAUDIO) ? 1417 0xa0 : 0x20; 1418 reg |= (ucontrol->value.iec958.status[1] >> 4) & 0x0f; 1419 err = snd_usb_ctl_msg(mixer->chip->dev, 1420 usb_sndctrlpipe(mixer->chip->dev, 0), 1421 UAC_SET_CUR, 1422 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1423 reg, 1424 3, 1425 NULL, 1426 0); 1427 if (err < 0) 1428 goto end; 1429 1430 kcontrol->private_value &= 0xffff0fff; 1431 kcontrol->private_value |= (ucontrol->value.iec958.status[1] & 0xf0) << 8; 1432 1433 /* The frequency bits in AES3 cannot be set via register access. */ 1434 1435 /* Silently ignore any bits from the request that cannot be set. */ 1436 1437 err = (priv_backup != kcontrol->private_value); 1438 end: 1439 return err; 1440 } 1441 1442 static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol, 1443 struct snd_ctl_elem_value *ucontrol) 1444 { 1445 ucontrol->value.iec958.status[0] = 0x0f; 1446 ucontrol->value.iec958.status[1] = 0xff; 1447 ucontrol->value.iec958.status[2] = 0x00; 1448 ucontrol->value.iec958.status[3] = 0x00; 1449 1450 return 0; 1451 } 1452 1453 static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol, 1454 struct snd_ctl_elem_value *ucontrol) 1455 { 1456 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02); 1457 1458 return 0; 1459 } 1460 1461 static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol, 1462 struct snd_ctl_elem_value *ucontrol) 1463 { 1464 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); 1465 int err; 1466 u8 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a; 1467 1468 err = snd_usb_ctl_msg(mixer->chip->dev, 1469 usb_sndctrlpipe(mixer->chip->dev, 0), 1470 UAC_SET_CUR, 1471 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1472 reg, 1473 9, 1474 NULL, 1475 0); 1476 1477 if (!err) { 1478 err = (reg != (kcontrol->private_value & 0x0ff)); 1479 if (err) 1480 kcontrol->private_value = reg; 1481 } 1482 1483 return err; 1484 } 1485 1486 static struct snd_kcontrol_new snd_microii_mixer_spdif[] = { 1487 { 1488 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1489 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 1490 .info = snd_microii_spdif_info, 1491 .get = snd_microii_spdif_default_get, 1492 .put = snd_microii_spdif_default_put, 1493 .private_value = 0x00000100UL,/* reset value */ 1494 }, 1495 { 1496 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1497 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1498 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK), 1499 .info = snd_microii_spdif_info, 1500 .get = snd_microii_spdif_mask_get, 1501 }, 1502 { 1503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1504 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 1505 .info = snd_ctl_boolean_mono_info, 1506 .get = snd_microii_spdif_switch_get, 1507 .put = snd_microii_spdif_switch_put, 1508 .private_value = 0x00000028UL,/* reset value */ 1509 } 1510 }; 1511 1512 static int snd_microii_controls_create(struct usb_mixer_interface *mixer) 1513 { 1514 int err, i; 1515 1516 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) { 1517 err = snd_ctl_add(mixer->chip->card, 1518 snd_ctl_new1(&snd_microii_mixer_spdif[i], mixer)); 1519 if (err < 0) 1520 return err; 1521 } 1522 1523 return err; 1524 } 1525 1526 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer) 1527 { 1528 int err = 0; 1529 struct snd_info_entry *entry; 1530 1531 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0) 1532 return err; 1533 1534 switch (mixer->chip->usb_id) { 1535 case USB_ID(0x041e, 0x3020): 1536 case USB_ID(0x041e, 0x3040): 1537 case USB_ID(0x041e, 0x3042): 1538 case USB_ID(0x041e, 0x30df): 1539 case USB_ID(0x041e, 0x3048): 1540 err = snd_audigy2nx_controls_create(mixer); 1541 if (err < 0) 1542 break; 1543 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry)) 1544 snd_info_set_text_ops(entry, mixer, 1545 snd_audigy2nx_proc_read); 1546 break; 1547 1548 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ 1549 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */ 1550 err = snd_c400_create_mixer(mixer); 1551 break; 1552 1553 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ 1554 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ 1555 err = snd_ftu_create_mixer(mixer); 1556 break; 1557 1558 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */ 1559 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */ 1560 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */ 1561 err = snd_xonar_u1_controls_create(mixer); 1562 break; 1563 1564 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */ 1565 err = snd_microii_controls_create(mixer); 1566 break; 1567 1568 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */ 1569 err = snd_nativeinstruments_create_mixer(mixer, 1570 snd_nativeinstruments_ta6_mixers, 1571 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers)); 1572 break; 1573 1574 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */ 1575 err = snd_nativeinstruments_create_mixer(mixer, 1576 snd_nativeinstruments_ta10_mixers, 1577 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers)); 1578 break; 1579 1580 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */ 1581 /* detection is disabled in mixer_maps.c */ 1582 err = snd_create_std_mono_table(mixer, ebox44_table); 1583 break; 1584 } 1585 1586 return err; 1587 } 1588 1589 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer, 1590 int unitid) 1591 { 1592 if (!mixer->rc_cfg) 1593 return; 1594 /* unit ids specific to Extigy/Audigy 2 NX: */ 1595 switch (unitid) { 1596 case 0: /* remote control */ 1597 mixer->rc_urb->dev = mixer->chip->dev; 1598 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC); 1599 break; 1600 case 4: /* digital in jack */ 1601 case 7: /* line in jacks */ 1602 case 19: /* speaker out jacks */ 1603 case 20: /* headphones out jack */ 1604 break; 1605 /* live24ext: 4 = line-in jack */ 1606 case 3: /* hp-out jack (may actuate Mute) */ 1607 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || 1608 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) 1609 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id); 1610 break; 1611 default: 1612 snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid); 1613 break; 1614 } 1615 } 1616 1617