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