Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mixer_quirks.c
Go to the documentation of this file.
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 <[email protected]>
7  *
8  * Many codes borrowed from audio.c by
9  * Alan Cox ([email protected])
10  * Thomas Sailer ([email protected])
11  *
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26  */
27 
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/usb.h>
31 #include <linux/usb/audio.h>
32 
33 #include <sound/core.h>
34 #include <sound/control.h>
35 #include <sound/hwdep.h>
36 #include <sound/info.h>
37 
38 #include "usbaudio.h"
39 #include "mixer.h"
40 #include "mixer_quirks.h"
41 #include "helper.h"
42 
43 extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
44 
45 struct std_mono_table {
46  unsigned int unitid, control, cmask;
47  int val_type;
48  const char *name;
49  snd_kcontrol_tlv_rw_t *tlv_callback;
50 };
51 
52 /* private_free callback */
53 static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
54 {
55  kfree(kctl->private_data);
56  kctl->private_data = NULL;
57 }
58 
59 /* This function allows for the creation of standard UAC controls.
60  * See the quirks for M-Audio FTUs or Ebox-44.
61  * If you don't want to set a TLV callback pass NULL.
62  *
63  * Since there doesn't seem to be a devices that needs a multichannel
64  * version, we keep it mono for simplicity.
65  */
66 static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
67  unsigned int unitid,
68  unsigned int control,
69  unsigned int cmask,
70  int val_type,
71  const char *name,
72  snd_kcontrol_tlv_rw_t *tlv_callback)
73 {
74  int err;
75  struct usb_mixer_elem_info *cval;
76  struct snd_kcontrol *kctl;
77 
78  cval = kzalloc(sizeof(*cval), GFP_KERNEL);
79  if (!cval)
80  return -ENOMEM;
81 
82  cval->id = unitid;
83  cval->mixer = mixer;
84  cval->val_type = val_type;
85  cval->channels = 1;
86  cval->control = control;
87  cval->cmask = cmask;
88 
89  /* get_min_max() is called only for integer volumes later,
90  * so provide a short-cut for booleans */
91  cval->min = 0;
92  cval->max = 1;
93  cval->res = 0;
94  cval->dBmin = 0;
95  cval->dBmax = 0;
96 
97  /* Create control */
98  kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
99  if (!kctl) {
100  kfree(cval);
101  return -ENOMEM;
102  }
103 
104  /* Set name */
105  snprintf(kctl->id.name, sizeof(kctl->id.name), name);
106  kctl->private_free = usb_mixer_elem_free;
107 
108  /* set TLV */
109  if (tlv_callback) {
110  kctl->tlv.c = tlv_callback;
111  kctl->vd[0].access |=
112  SNDRV_CTL_ELEM_ACCESS_TLV_READ |
113  SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
114  }
115  /* Add control to mixer */
116  err = snd_usb_mixer_add_control(mixer, kctl);
117  if (err < 0)
118  return err;
119 
120  return 0;
121 }
122 
123 /*
124  * Create a set of standard UAC controls from a table
125  */
126 static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
127  struct std_mono_table *t)
128 {
129  int err;
130 
131  while (t->name != NULL) {
132  err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
133  t->cmask, t->val_type, t->name, t->tlv_callback);
134  if (err < 0)
135  return err;
136  t++;
137  }
138 
139  return 0;
140 }
141 
142 /*
143  * Sound Blaster remote control configuration
144  *
145  * format of remote control data:
146  * Extigy: xx 00
147  * Audigy 2 NX: 06 80 xx 00 00 00
148  * Live! 24-bit: 06 80 xx yy 22 83
149  */
150 static const struct rc_config {
151  u32 usb_id;
152  u8 offset;
153  u8 length;
154  u8 packet_length;
155  u8 min_packet_length; /* minimum accepted length of the URB result */
156  u8 mute_mixer_id;
157  u32 mute_code;
158 } rc_configs[] = {
159  { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
160  { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
161  { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
162  { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
163  { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
164  { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
165 };
166 
167 static void snd_usb_soundblaster_remote_complete(struct urb *urb)
168 {
169  struct usb_mixer_interface *mixer = urb->context;
170  const struct rc_config *rc = mixer->rc_cfg;
171  u32 code;
172 
173  if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
174  return;
175 
176  code = mixer->rc_buffer[rc->offset];
177  if (rc->length == 2)
178  code |= mixer->rc_buffer[rc->offset + 1] << 8;
179 
180  /* the Mute button actually changes the mixer control */
181  if (code == rc->mute_code)
182  snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
183  mixer->rc_code = code;
184  wmb();
185  wake_up(&mixer->rc_waitq);
186 }
187 
188 static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
189  long count, loff_t *offset)
190 {
191  struct usb_mixer_interface *mixer = hw->private_data;
192  int err;
193  u32 rc_code;
194 
195  if (count != 1 && count != 4)
196  return -EINVAL;
197  err = wait_event_interruptible(mixer->rc_waitq,
198  (rc_code = xchg(&mixer->rc_code, 0)) != 0);
199  if (err == 0) {
200  if (count == 1)
201  err = put_user(rc_code, buf);
202  else
203  err = put_user(rc_code, (u32 __user *)buf);
204  }
205  return err < 0 ? err : count;
206 }
207 
208 static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
209  poll_table *wait)
210 {
211  struct usb_mixer_interface *mixer = hw->private_data;
212 
213  poll_wait(file, &mixer->rc_waitq, wait);
214  return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
215 }
216 
217 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
218 {
219  struct snd_hwdep *hwdep;
220  int err, len, i;
221 
222  for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
223  if (rc_configs[i].usb_id == mixer->chip->usb_id)
224  break;
225  if (i >= ARRAY_SIZE(rc_configs))
226  return 0;
227  mixer->rc_cfg = &rc_configs[i];
228 
229  len = mixer->rc_cfg->packet_length;
230 
231  init_waitqueue_head(&mixer->rc_waitq);
232  err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
233  if (err < 0)
234  return err;
235  snprintf(hwdep->name, sizeof(hwdep->name),
236  "%s remote control", mixer->chip->card->shortname);
237  hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
238  hwdep->private_data = mixer;
239  hwdep->ops.read = snd_usb_sbrc_hwdep_read;
240  hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
241  hwdep->exclusive = 1;
242 
243  mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
244  if (!mixer->rc_urb)
245  return -ENOMEM;
246  mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
247  if (!mixer->rc_setup_packet) {
248  usb_free_urb(mixer->rc_urb);
249  mixer->rc_urb = NULL;
250  return -ENOMEM;
251  }
252  mixer->rc_setup_packet->bRequestType =
253  USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
254  mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
255  mixer->rc_setup_packet->wValue = cpu_to_le16(0);
256  mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
257  mixer->rc_setup_packet->wLength = cpu_to_le16(len);
258  usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
259  usb_rcvctrlpipe(mixer->chip->dev, 0),
260  (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
261  snd_usb_soundblaster_remote_complete, mixer);
262  return 0;
263 }
264 
265 #define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
266 
267 static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
268 {
269  struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
270  int index = kcontrol->private_value;
271 
272  ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
273  return 0;
274 }
275 
276 static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
277 {
278  struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
279  int index = kcontrol->private_value;
280  int value = ucontrol->value.integer.value[0];
281  int err, changed;
282 
283  if (value > 1)
284  return -EINVAL;
285  changed = value != mixer->audigy2nx_leds[index];
286  down_read(&mixer->chip->shutdown_rwsem);
287  if (mixer->chip->shutdown) {
288  err = -ENODEV;
289  goto out;
290  }
291  if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042))
292  err = snd_usb_ctl_msg(mixer->chip->dev,
293  usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
294  USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
295  !value, 0, NULL, 0);
296  /* USB X-Fi S51 Pro */
297  if (mixer->chip->usb_id == USB_ID(0x041e, 0x30df))
298  err = snd_usb_ctl_msg(mixer->chip->dev,
299  usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
300  USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
301  !value, 0, NULL, 0);
302  else
303  err = snd_usb_ctl_msg(mixer->chip->dev,
304  usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
305  USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
306  value, index + 2, NULL, 0);
307  out:
308  up_read(&mixer->chip->shutdown_rwsem);
309  if (err < 0)
310  return err;
311  mixer->audigy2nx_leds[index] = value;
312  return changed;
313 }
314 
315 static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
316  {
317  .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
318  .name = "CMSS LED Switch",
319  .info = snd_audigy2nx_led_info,
320  .get = snd_audigy2nx_led_get,
321  .put = snd_audigy2nx_led_put,
322  .private_value = 0,
323  },
324  {
325  .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
326  .name = "Power LED Switch",
327  .info = snd_audigy2nx_led_info,
328  .get = snd_audigy2nx_led_get,
329  .put = snd_audigy2nx_led_put,
330  .private_value = 1,
331  },
332  {
333  .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
334  .name = "Dolby Digital LED Switch",
335  .info = snd_audigy2nx_led_info,
336  .get = snd_audigy2nx_led_get,
337  .put = snd_audigy2nx_led_put,
338  .private_value = 2,
339  },
340 };
341 
342 static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
343 {
344  int i, err;
345 
346  for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
347  /* USB X-Fi S51 doesn't have a CMSS LED */
348  if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
349  continue;
350  /* USB X-Fi S51 Pro doesn't have one either */
351  if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
352  continue;
353  if (i > 1 && /* Live24ext has 2 LEDs only */
354  (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
355  mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
356  mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
357  mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
358  break;
359  err = snd_ctl_add(mixer->chip->card,
360  snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
361  if (err < 0)
362  return err;
363  }
364  mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
365  return 0;
366 }
367 
368 static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
369  struct snd_info_buffer *buffer)
370 {
371  static const struct sb_jack {
372  int unitid;
373  const char *name;
374  } jacks_audigy2nx[] = {
375  {4, "dig in "},
376  {7, "line in"},
377  {19, "spk out"},
378  {20, "hph out"},
379  {-1, NULL}
380  }, jacks_live24ext[] = {
381  {4, "line in"}, /* &1=Line, &2=Mic*/
382  {3, "hph out"}, /* headphones */
383  {0, "RC "}, /* last command, 6 bytes see rc_config above */
384  {-1, NULL}
385  };
386  const struct sb_jack *jacks;
387  struct usb_mixer_interface *mixer = entry->private_data;
388  int i, err;
389  u8 buf[3];
390 
391  snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
392  if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
393  jacks = jacks_audigy2nx;
394  else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
395  mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
396  jacks = jacks_live24ext;
397  else
398  return;
399 
400  for (i = 0; jacks[i].name; ++i) {
401  snd_iprintf(buffer, "%s: ", jacks[i].name);
402  down_read(&mixer->chip->shutdown_rwsem);
403  if (mixer->chip->shutdown)
404  err = 0;
405  else
406  err = snd_usb_ctl_msg(mixer->chip->dev,
407  usb_rcvctrlpipe(mixer->chip->dev, 0),
408  UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
409  USB_RECIP_INTERFACE, 0,
410  jacks[i].unitid << 8, buf, 3);
411  up_read(&mixer->chip->shutdown_rwsem);
412  if (err == 3 && (buf[0] == 3 || buf[0] == 6))
413  snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
414  else
415  snd_iprintf(buffer, "?\n");
416  }
417 }
418 
419 static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
420  struct snd_ctl_elem_value *ucontrol)
421 {
422  struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
423 
424  ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
425  return 0;
426 }
427 
428 static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
429  struct snd_ctl_elem_value *ucontrol)
430 {
431  struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
432  u8 old_status, new_status;
433  int err, changed;
434 
435  old_status = mixer->xonar_u1_status;
436  if (ucontrol->value.integer.value[0])
437  new_status = old_status | 0x02;
438  else
439  new_status = old_status & ~0x02;
440  changed = new_status != old_status;
441  down_read(&mixer->chip->shutdown_rwsem);
442  if (mixer->chip->shutdown)
443  err = -ENODEV;
444  else
445  err = snd_usb_ctl_msg(mixer->chip->dev,
446  usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
447  USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
448  50, 0, &new_status, 1);
449  up_read(&mixer->chip->shutdown_rwsem);
450  if (err < 0)
451  return err;
452  mixer->xonar_u1_status = new_status;
453  return changed;
454 }
455 
456 static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
457  .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
458  .name = "Digital Playback Switch",
459  .info = snd_ctl_boolean_mono_info,
460  .get = snd_xonar_u1_switch_get,
461  .put = snd_xonar_u1_switch_put,
462 };
463 
464 static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
465 {
466  int err;
467 
468  err = snd_ctl_add(mixer->chip->card,
469  snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
470  if (err < 0)
471  return err;
472  mixer->xonar_u1_status = 0x05;
473  return 0;
474 }
475 
476 /* Native Instruments device quirks */
477 
478 #define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
479 
480 static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
481  struct snd_ctl_elem_value *ucontrol)
482 {
483  struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
484  struct usb_device *dev = mixer->chip->dev;
485  u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
486  u16 wIndex = kcontrol->private_value & 0xffff;
487  u8 tmp;
488  int ret;
489 
490  down_read(&mixer->chip->shutdown_rwsem);
491  if (mixer->chip->shutdown)
492  ret = -ENODEV;
493  else
494  ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
495  USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
496  0, cpu_to_le16(wIndex),
497  &tmp, sizeof(tmp), 1000);
498  up_read(&mixer->chip->shutdown_rwsem);
499 
500  if (ret < 0) {
501  snd_printk(KERN_ERR
502  "unable to issue vendor read request (ret = %d)", ret);
503  return ret;
504  }
505 
506  ucontrol->value.integer.value[0] = tmp;
507 
508  return 0;
509 }
510 
511 static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
512  struct snd_ctl_elem_value *ucontrol)
513 {
514  struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
515  struct usb_device *dev = mixer->chip->dev;
516  u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
517  u16 wIndex = kcontrol->private_value & 0xffff;
518  u16 wValue = ucontrol->value.integer.value[0];
519  int ret;
520 
521  down_read(&mixer->chip->shutdown_rwsem);
522  if (mixer->chip->shutdown)
523  ret = -ENODEV;
524  else
525  ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest,
526  USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
527  cpu_to_le16(wValue), cpu_to_le16(wIndex),
528  NULL, 0, 1000);
529  up_read(&mixer->chip->shutdown_rwsem);
530 
531  if (ret < 0) {
532  snd_printk(KERN_ERR
533  "unable to issue vendor write request (ret = %d)", ret);
534  return ret;
535  }
536 
537  return 0;
538 }
539 
540 static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
541  {
542  .name = "Direct Thru Channel A",
543  .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
544  },
545  {
546  .name = "Direct Thru Channel B",
547  .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
548  },
549  {
550  .name = "Phono Input Channel A",
551  .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
552  },
553  {
554  .name = "Phono Input Channel B",
555  .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
556  },
557 };
558 
559 static struct snd_kcontrol_new snd_nativeinstruments_ta10_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 = "Direct Thru Channel C",
570  .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
571  },
572  {
573  .name = "Direct Thru Channel D",
574  .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
575  },
576  {
577  .name = "Phono Input Channel A",
578  .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
579  },
580  {
581  .name = "Phono Input Channel B",
582  .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
583  },
584  {
585  .name = "Phono Input Channel C",
586  .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
587  },
588  {
589  .name = "Phono Input Channel D",
590  .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
591  },
592 };
593 
594 static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
595  const struct snd_kcontrol_new *kc,
596  unsigned int count)
597 {
598  int i, err = 0;
599  struct snd_kcontrol_new template = {
600  .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
601  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
602  .get = snd_nativeinstruments_control_get,
603  .put = snd_nativeinstruments_control_put,
604  .info = snd_ctl_boolean_mono_info,
605  };
606 
607  for (i = 0; i < count; i++) {
608  struct snd_kcontrol *c;
609 
610  template.name = kc[i].name;
611  template.private_value = kc[i].private_value;
612 
613  c = snd_ctl_new1(&template, mixer);
614  err = snd_ctl_add(mixer->chip->card, c);
615 
616  if (err < 0)
617  break;
618  }
619 
620  return err;
621 }
622 
623 /* M-Audio FastTrack Ultra quirks */
624 /* FTU Effect switch */
625 struct snd_ftu_eff_switch_priv_val {
626  struct usb_mixer_interface *mixer;
627  int cached_value;
628  int is_cached;
629 };
630 
631 static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
632  struct snd_ctl_elem_info *uinfo)
633 {
634  static const char *texts[8] = {"Room 1",
635  "Room 2",
636  "Room 3",
637  "Hall 1",
638  "Hall 2",
639  "Plate",
640  "Delay",
641  "Echo"
642  };
643 
644  uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
645  uinfo->count = 1;
646  uinfo->value.enumerated.items = 8;
647  if (uinfo->value.enumerated.item > 7)
648  uinfo->value.enumerated.item = 7;
649  strcpy(uinfo->value.enumerated.name,
650  texts[uinfo->value.enumerated.item]);
651 
652  return 0;
653 }
654 
655 static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
656  struct snd_ctl_elem_value *ucontrol)
657 {
658  struct snd_usb_audio *chip;
659  struct usb_mixer_interface *mixer;
660  struct snd_ftu_eff_switch_priv_val *pval;
661  int err;
662  unsigned char value[2];
663 
664  const int id = 6;
665  const int validx = 1;
666  const int val_len = 2;
667 
668  value[0] = 0x00;
669  value[1] = 0x00;
670 
671  pval = (struct snd_ftu_eff_switch_priv_val *)
672  kctl->private_value;
673 
674  if (pval->is_cached) {
675  ucontrol->value.enumerated.item[0] = pval->cached_value;
676  return 0;
677  }
678 
679  mixer = (struct usb_mixer_interface *) pval->mixer;
680  if (snd_BUG_ON(!mixer))
681  return -EINVAL;
682 
683  chip = (struct snd_usb_audio *) mixer->chip;
684  if (snd_BUG_ON(!chip))
685  return -EINVAL;
686 
687 
688  down_read(&mixer->chip->shutdown_rwsem);
689  if (mixer->chip->shutdown)
690  err = -ENODEV;
691  else
692  err = snd_usb_ctl_msg(chip->dev,
693  usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
694  USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
695  validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
696  value, val_len);
697  up_read(&mixer->chip->shutdown_rwsem);
698  if (err < 0)
699  return err;
700 
701  ucontrol->value.enumerated.item[0] = value[0];
702  pval->cached_value = value[0];
703  pval->is_cached = 1;
704 
705  return 0;
706 }
707 
708 static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
709  struct snd_ctl_elem_value *ucontrol)
710 {
711  struct snd_usb_audio *chip;
712  struct snd_ftu_eff_switch_priv_val *pval;
713 
714  struct usb_mixer_interface *mixer;
715  int changed, cur_val, err, new_val;
716  unsigned char value[2];
717 
718 
719  const int id = 6;
720  const int validx = 1;
721  const int val_len = 2;
722 
723  changed = 0;
724 
725  pval = (struct snd_ftu_eff_switch_priv_val *)
726  kctl->private_value;
727  cur_val = pval->cached_value;
728  new_val = ucontrol->value.enumerated.item[0];
729 
730  mixer = (struct usb_mixer_interface *) pval->mixer;
731  if (snd_BUG_ON(!mixer))
732  return -EINVAL;
733 
734  chip = (struct snd_usb_audio *) mixer->chip;
735  if (snd_BUG_ON(!chip))
736  return -EINVAL;
737 
738  if (!pval->is_cached) {
739  /* Read current value */
740  down_read(&mixer->chip->shutdown_rwsem);
741  if (mixer->chip->shutdown)
742  err = -ENODEV;
743  else
744  err = snd_usb_ctl_msg(chip->dev,
745  usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
746  USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
747  validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
748  value, val_len);
749  up_read(&mixer->chip->shutdown_rwsem);
750  if (err < 0)
751  return err;
752 
753  cur_val = value[0];
754  pval->cached_value = cur_val;
755  pval->is_cached = 1;
756  }
757  /* update value if needed */
758  if (cur_val != new_val) {
759  value[0] = new_val;
760  value[1] = 0;
761  down_read(&mixer->chip->shutdown_rwsem);
762  if (mixer->chip->shutdown)
763  err = -ENODEV;
764  else
765  err = snd_usb_ctl_msg(chip->dev,
766  usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
767  USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
768  validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
769  value, val_len);
770  up_read(&mixer->chip->shutdown_rwsem);
771  if (err < 0)
772  return err;
773 
774  pval->cached_value = new_val;
775  pval->is_cached = 1;
776  changed = 1;
777  }
778 
779  return changed;
780 }
781 
782 static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer)
783 {
784  static struct snd_kcontrol_new template = {
785  .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
786  .name = "Effect Program Switch",
787  .index = 0,
788  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
789  .info = snd_ftu_eff_switch_info,
790  .get = snd_ftu_eff_switch_get,
791  .put = snd_ftu_eff_switch_put
792  };
793 
794  int err;
795  struct snd_kcontrol *kctl;
796  struct snd_ftu_eff_switch_priv_val *pval;
797 
798  pval = kzalloc(sizeof(*pval), GFP_KERNEL);
799  if (!pval)
800  return -ENOMEM;
801 
802  pval->cached_value = 0;
803  pval->is_cached = 0;
804  pval->mixer = mixer;
805 
806  template.private_value = (unsigned long) pval;
807  kctl = snd_ctl_new1(&template, mixer->chip);
808  if (!kctl) {
809  kfree(pval);
810  return -ENOMEM;
811  }
812 
813  err = snd_ctl_add(mixer->chip->card, kctl);
814  if (err < 0)
815  return err;
816 
817  return 0;
818 }
819 
820 /* Create volume controls for FTU devices*/
821 static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
822 {
823  char name[64];
824  unsigned int control, cmask;
825  int in, out, err;
826 
827  const unsigned int id = 5;
828  const int val_type = USB_MIXER_S16;
829 
830  for (out = 0; out < 8; out++) {
831  control = out + 1;
832  for (in = 0; in < 8; in++) {
833  cmask = 1 << in;
834  snprintf(name, sizeof(name),
835  "AIn%d - Out%d Capture Volume",
836  in + 1, out + 1);
837  err = snd_create_std_mono_ctl(mixer, id, control,
838  cmask, val_type, name,
839  &snd_usb_mixer_vol_tlv);
840  if (err < 0)
841  return err;
842  }
843  for (in = 8; in < 16; in++) {
844  cmask = 1 << in;
845  snprintf(name, sizeof(name),
846  "DIn%d - Out%d Playback Volume",
847  in - 7, out + 1);
848  err = snd_create_std_mono_ctl(mixer, id, control,
849  cmask, val_type, name,
850  &snd_usb_mixer_vol_tlv);
851  if (err < 0)
852  return err;
853  }
854  }
855 
856  return 0;
857 }
858 
859 /* This control needs a volume quirk, see mixer.c */
860 static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
861 {
862  static const char name[] = "Effect Volume";
863  const unsigned int id = 6;
864  const int val_type = USB_MIXER_U8;
865  const unsigned int control = 2;
866  const unsigned int cmask = 0;
867 
868  return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
869  name, snd_usb_mixer_vol_tlv);
870 }
871 
872 /* This control needs a volume quirk, see mixer.c */
873 static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
874 {
875  static const char name[] = "Effect Duration";
876  const unsigned int id = 6;
877  const int val_type = USB_MIXER_S16;
878  const unsigned int control = 3;
879  const unsigned int cmask = 0;
880 
881  return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
882  name, snd_usb_mixer_vol_tlv);
883 }
884 
885 /* This control needs a volume quirk, see mixer.c */
886 static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
887 {
888  static const char name[] = "Effect Feedback Volume";
889  const unsigned int id = 6;
890  const int val_type = USB_MIXER_U8;
891  const unsigned int control = 4;
892  const unsigned int cmask = 0;
893 
894  return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
895  name, NULL);
896 }
897 
898 static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
899 {
900  unsigned int cmask;
901  int err, ch;
902  char name[48];
903 
904  const unsigned int id = 7;
905  const int val_type = USB_MIXER_S16;
906  const unsigned int control = 7;
907 
908  for (ch = 0; ch < 4; ++ch) {
909  cmask = 1 << ch;
910  snprintf(name, sizeof(name),
911  "Effect Return %d Volume", ch + 1);
912  err = snd_create_std_mono_ctl(mixer, id, control,
913  cmask, val_type, name,
914  snd_usb_mixer_vol_tlv);
915  if (err < 0)
916  return err;
917  }
918 
919  return 0;
920 }
921 
922 static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
923 {
924  unsigned int cmask;
925  int err, ch;
926  char name[48];
927 
928  const unsigned int id = 5;
929  const int val_type = USB_MIXER_S16;
930  const unsigned int control = 9;
931 
932  for (ch = 0; ch < 8; ++ch) {
933  cmask = 1 << ch;
934  snprintf(name, sizeof(name),
935  "Effect Send AIn%d Volume", ch + 1);
936  err = snd_create_std_mono_ctl(mixer, id, control, cmask,
937  val_type, name,
938  snd_usb_mixer_vol_tlv);
939  if (err < 0)
940  return err;
941  }
942  for (ch = 8; ch < 16; ++ch) {
943  cmask = 1 << ch;
944  snprintf(name, sizeof(name),
945  "Effect Send DIn%d Volume", ch - 7);
946  err = snd_create_std_mono_ctl(mixer, id, control, cmask,
947  val_type, name,
948  snd_usb_mixer_vol_tlv);
949  if (err < 0)
950  return err;
951  }
952  return 0;
953 }
954 
955 static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
956 {
957  int err;
958 
959  err = snd_ftu_create_volume_ctls(mixer);
960  if (err < 0)
961  return err;
962 
963  err = snd_ftu_create_effect_switch(mixer);
964  if (err < 0)
965  return err;
966  err = snd_ftu_create_effect_volume_ctl(mixer);
967  if (err < 0)
968  return err;
969 
970  err = snd_ftu_create_effect_duration_ctl(mixer);
971  if (err < 0)
972  return err;
973 
974  err = snd_ftu_create_effect_feedback_ctl(mixer);
975  if (err < 0)
976  return err;
977 
978  err = snd_ftu_create_effect_return_ctls(mixer);
979  if (err < 0)
980  return err;
981 
982  err = snd_ftu_create_effect_send_ctls(mixer);
983  if (err < 0)
984  return err;
985 
986  return 0;
987 }
988 
989 void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
990  unsigned char samplerate_id)
991 {
992  struct usb_mixer_interface *mixer;
993  struct usb_mixer_elem_info *cval;
994  int unitid = 12; /* SamleRate ExtensionUnit ID */
995 
996  list_for_each_entry(mixer, &chip->mixer_list, list) {
997  cval = mixer->id_elems[unitid];
998  if (cval) {
999  snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1000  cval->control << 8,
1001  samplerate_id);
1002  snd_usb_mixer_notify_id(mixer, unitid);
1003  }
1004  break;
1005  }
1006 }
1007 
1008 /*
1009  * The mixer units for Ebox-44 are corrupt, and even where they
1010  * are valid they presents mono controls as L and R channels of
1011  * stereo. So we provide a good mixer here.
1012  */
1013 struct std_mono_table ebox44_table[] = {
1014  {
1015  .unitid = 4,
1016  .control = 1,
1017  .cmask = 0x0,
1018  .val_type = USB_MIXER_INV_BOOLEAN,
1019  .name = "Headphone Playback Switch"
1020  },
1021  {
1022  .unitid = 4,
1023  .control = 2,
1024  .cmask = 0x1,
1025  .val_type = USB_MIXER_S16,
1026  .name = "Headphone A Mix Playback Volume"
1027  },
1028  {
1029  .unitid = 4,
1030  .control = 2,
1031  .cmask = 0x2,
1032  .val_type = USB_MIXER_S16,
1033  .name = "Headphone B Mix Playback Volume"
1034  },
1035 
1036  {
1037  .unitid = 7,
1038  .control = 1,
1039  .cmask = 0x0,
1040  .val_type = USB_MIXER_INV_BOOLEAN,
1041  .name = "Output Playback Switch"
1042  },
1043  {
1044  .unitid = 7,
1045  .control = 2,
1046  .cmask = 0x1,
1047  .val_type = USB_MIXER_S16,
1048  .name = "Output A Playback Volume"
1049  },
1050  {
1051  .unitid = 7,
1052  .control = 2,
1053  .cmask = 0x2,
1054  .val_type = USB_MIXER_S16,
1055  .name = "Output B Playback Volume"
1056  },
1057 
1058  {
1059  .unitid = 10,
1060  .control = 1,
1061  .cmask = 0x0,
1062  .val_type = USB_MIXER_INV_BOOLEAN,
1063  .name = "Input Capture Switch"
1064  },
1065  {
1066  .unitid = 10,
1067  .control = 2,
1068  .cmask = 0x1,
1069  .val_type = USB_MIXER_S16,
1070  .name = "Input A Capture Volume"
1071  },
1072  {
1073  .unitid = 10,
1074  .control = 2,
1075  .cmask = 0x2,
1076  .val_type = USB_MIXER_S16,
1077  .name = "Input B Capture Volume"
1078  },
1079 
1080  {}
1081 };
1082 
1083 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
1084 {
1085  int err = 0;
1086  struct snd_info_entry *entry;
1087 
1088  if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
1089  return err;
1090 
1091  switch (mixer->chip->usb_id) {
1092  case USB_ID(0x041e, 0x3020):
1093  case USB_ID(0x041e, 0x3040):
1094  case USB_ID(0x041e, 0x3042):
1095  case USB_ID(0x041e, 0x30df):
1096  case USB_ID(0x041e, 0x3048):
1097  err = snd_audigy2nx_controls_create(mixer);
1098  if (err < 0)
1099  break;
1100  if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
1101  snd_info_set_text_ops(entry, mixer,
1102  snd_audigy2nx_proc_read);
1103  break;
1104 
1105  case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1106  case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
1107  err = snd_ftu_create_mixer(mixer);
1108  break;
1109 
1110  case USB_ID(0x0b05, 0x1739):
1111  case USB_ID(0x0b05, 0x1743):
1112  err = snd_xonar_u1_controls_create(mixer);
1113  break;
1114 
1115  case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
1116  err = snd_nativeinstruments_create_mixer(mixer,
1117  snd_nativeinstruments_ta6_mixers,
1118  ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
1119  break;
1120 
1121  case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
1122  err = snd_nativeinstruments_create_mixer(mixer,
1123  snd_nativeinstruments_ta10_mixers,
1124  ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
1125  break;
1126 
1127  case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
1128  /* detection is disabled in mixer_maps.c */
1129  err = snd_create_std_mono_table(mixer, ebox44_table);
1130  break;
1131  }
1132 
1133  return err;
1134 }
1135 
1136 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
1137  int unitid)
1138 {
1139  if (!mixer->rc_cfg)
1140  return;
1141  /* unit ids specific to Extigy/Audigy 2 NX: */
1142  switch (unitid) {
1143  case 0: /* remote control */
1144  mixer->rc_urb->dev = mixer->chip->dev;
1145  usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
1146  break;
1147  case 4: /* digital in jack */
1148  case 7: /* line in jacks */
1149  case 19: /* speaker out jacks */
1150  case 20: /* headphones out jack */
1151  break;
1152  /* live24ext: 4 = line-in jack */
1153  case 3: /* hp-out jack (may actuate Mute) */
1154  if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
1155  mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
1156  snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
1157  break;
1158  default:
1159  snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
1160  break;
1161  }
1162 }
1163 
Generated on Thu Jan 10 2013 15:08:56 for Linux Kernel by   doxygen 1.8.2