blob: 1ef77c0d39ecc810b7893ff3f624e8a89bdd8144 [file] [log] [blame]
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001/*
2 * ALSA driver for Echoaudio soundcards.
3 * Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
Paul Gortmakerda155d52011-07-15 12:38:28 -040019#include <linux/module.h>
20
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020021MODULE_AUTHOR("Giuliano Pochini <pochini@shiny.it>");
22MODULE_LICENSE("GPL v2");
23MODULE_DESCRIPTION("Echoaudio " ECHOCARD_NAME " soundcards driver");
24MODULE_SUPPORTED_DEVICE("{{Echoaudio," ECHOCARD_NAME "}}");
25MODULE_DEVICE_TABLE(pci, snd_echo_ids);
26
27static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
28static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
Rusty Russella67ff6a2011-12-15 13:49:36 +103029static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020030
31module_param_array(index, int, NULL, 0444);
32MODULE_PARM_DESC(index, "Index value for " ECHOCARD_NAME " soundcard.");
33module_param_array(id, charp, NULL, 0444);
34MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
35module_param_array(enable, bool, NULL, 0444);
36MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
37
38static unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
Takashi Iwai0cb29ea2007-01-29 15:33:49 +010039static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020040
Giuliano Pochini19b50062010-02-14 18:15:34 +010041
42
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020043static int get_firmware(const struct firmware **fw_entry,
Giuliano Pochini19b50062010-02-14 18:15:34 +010044 struct echoaudio *chip, const short fw_index)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020045{
46 int err;
47 char name[30];
Giuliano Pochini19b50062010-02-14 18:15:34 +010048
Takashi Iwaic7561cd2012-08-14 18:12:04 +020049#ifdef CONFIG_PM_SLEEP
Giuliano Pochini4f8ada42010-02-14 18:15:51 +010050 if (chip->fw_cache[fw_index]) {
51 DE_ACT(("firmware requested: %s is cached\n", card_fw[fw_index].data));
52 *fw_entry = chip->fw_cache[fw_index];
53 return 0;
54 }
55#endif
56
57 DE_ACT(("firmware requested: %s\n", card_fw[fw_index].data));
58 snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
59 err = request_firmware(fw_entry, name, pci_device(chip));
60 if (err < 0)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020061 snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err);
Takashi Iwaic7561cd2012-08-14 18:12:04 +020062#ifdef CONFIG_PM_SLEEP
Giuliano Pochini4f8ada42010-02-14 18:15:51 +010063 else
64 chip->fw_cache[fw_index] = *fw_entry;
65#endif
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020066 return err;
67}
68
Giuliano Pochini19b50062010-02-14 18:15:34 +010069
70
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020071static void free_firmware(const struct firmware *fw_entry)
72{
Takashi Iwaic7561cd2012-08-14 18:12:04 +020073#ifdef CONFIG_PM_SLEEP
Giuliano Pochini4f8ada42010-02-14 18:15:51 +010074 DE_ACT(("firmware not released (kept in cache)\n"));
75#else
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020076 release_firmware(fw_entry);
77 DE_ACT(("firmware released\n"));
Giuliano Pochini4f8ada42010-02-14 18:15:51 +010078#endif
79}
80
81
82
83static void free_firmware_cache(struct echoaudio *chip)
84{
Takashi Iwaic7561cd2012-08-14 18:12:04 +020085#ifdef CONFIG_PM_SLEEP
Giuliano Pochini4f8ada42010-02-14 18:15:51 +010086 int i;
87
88 for (i = 0; i < 8 ; i++)
89 if (chip->fw_cache[i]) {
90 release_firmware(chip->fw_cache[i]);
91 DE_ACT(("release_firmware(%d)\n", i));
92 }
93
94 DE_ACT(("firmware_cache released\n"));
95#endif
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020096}
97
98
99
100/******************************************************************************
101 PCM interface
102******************************************************************************/
103
104static void audiopipe_free(struct snd_pcm_runtime *runtime)
105{
106 struct audiopipe *pipe = runtime->private_data;
107
108 if (pipe->sgpage.area)
109 snd_dma_free_pages(&pipe->sgpage);
110 kfree(pipe);
111}
112
113
114
115static int hw_rule_capture_format_by_channels(struct snd_pcm_hw_params *params,
116 struct snd_pcm_hw_rule *rule)
117{
118 struct snd_interval *c = hw_param_interval(params,
119 SNDRV_PCM_HW_PARAM_CHANNELS);
120 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
121 struct snd_mask fmt;
122
123 snd_mask_any(&fmt);
124
125#ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
126 /* >=2 channels cannot be S32_BE */
127 if (c->min == 2) {
128 fmt.bits[0] &= ~SNDRV_PCM_FMTBIT_S32_BE;
129 return snd_mask_refine(f, &fmt);
130 }
131#endif
132 /* > 2 channels cannot be U8 and S32_BE */
133 if (c->min > 2) {
134 fmt.bits[0] &= ~(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S32_BE);
135 return snd_mask_refine(f, &fmt);
136 }
137 /* Mono is ok with any format */
138 return 0;
139}
140
141
142
143static int hw_rule_capture_channels_by_format(struct snd_pcm_hw_params *params,
144 struct snd_pcm_hw_rule *rule)
145{
146 struct snd_interval *c = hw_param_interval(params,
147 SNDRV_PCM_HW_PARAM_CHANNELS);
148 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
149 struct snd_interval ch;
150
151 snd_interval_any(&ch);
152
153 /* S32_BE is mono (and stereo) only */
154 if (f->bits[0] == SNDRV_PCM_FMTBIT_S32_BE) {
155 ch.min = 1;
156#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
157 ch.max = 2;
158#else
159 ch.max = 1;
160#endif
161 ch.integer = 1;
162 return snd_interval_refine(c, &ch);
163 }
164 /* U8 can be only mono or stereo */
165 if (f->bits[0] == SNDRV_PCM_FMTBIT_U8) {
166 ch.min = 1;
167 ch.max = 2;
168 ch.integer = 1;
169 return snd_interval_refine(c, &ch);
170 }
171 /* S16_LE, S24_3LE and S32_LE support any number of channels. */
172 return 0;
173}
174
175
176
177static int hw_rule_playback_format_by_channels(struct snd_pcm_hw_params *params,
178 struct snd_pcm_hw_rule *rule)
179{
180 struct snd_interval *c = hw_param_interval(params,
181 SNDRV_PCM_HW_PARAM_CHANNELS);
182 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
183 struct snd_mask fmt;
184 u64 fmask;
185 snd_mask_any(&fmt);
186
187 fmask = fmt.bits[0] + ((u64)fmt.bits[1] << 32);
188
189 /* >2 channels must be S16_LE, S24_3LE or S32_LE */
190 if (c->min > 2) {
191 fmask &= SNDRV_PCM_FMTBIT_S16_LE |
192 SNDRV_PCM_FMTBIT_S24_3LE |
193 SNDRV_PCM_FMTBIT_S32_LE;
194 /* 1 channel must be S32_BE or S32_LE */
195 } else if (c->max == 1)
196 fmask &= SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE;
197#ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
198 /* 2 channels cannot be S32_BE */
199 else if (c->min == 2 && c->max == 2)
200 fmask &= ~SNDRV_PCM_FMTBIT_S32_BE;
201#endif
202 else
203 return 0;
204
205 fmt.bits[0] &= (u32)fmask;
206 fmt.bits[1] &= (u32)(fmask >> 32);
207 return snd_mask_refine(f, &fmt);
208}
209
210
211
212static int hw_rule_playback_channels_by_format(struct snd_pcm_hw_params *params,
213 struct snd_pcm_hw_rule *rule)
214{
215 struct snd_interval *c = hw_param_interval(params,
216 SNDRV_PCM_HW_PARAM_CHANNELS);
217 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
218 struct snd_interval ch;
219 u64 fmask;
220
221 snd_interval_any(&ch);
222 ch.integer = 1;
223 fmask = f->bits[0] + ((u64)f->bits[1] << 32);
224
225 /* S32_BE is mono (and stereo) only */
226 if (fmask == SNDRV_PCM_FMTBIT_S32_BE) {
227 ch.min = 1;
228#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
229 ch.max = 2;
230#else
231 ch.max = 1;
232#endif
233 /* U8 is stereo only */
234 } else if (fmask == SNDRV_PCM_FMTBIT_U8)
235 ch.min = ch.max = 2;
236 /* S16_LE and S24_3LE must be at least stereo */
237 else if (!(fmask & ~(SNDRV_PCM_FMTBIT_S16_LE |
238 SNDRV_PCM_FMTBIT_S24_3LE)))
239 ch.min = 2;
240 else
241 return 0;
242
243 return snd_interval_refine(c, &ch);
244}
245
246
247
248/* Since the sample rate is a global setting, do allow the user to change the
249sample rate only if there is only one pcm device open. */
250static int hw_rule_sample_rate(struct snd_pcm_hw_params *params,
251 struct snd_pcm_hw_rule *rule)
252{
253 struct snd_interval *rate = hw_param_interval(params,
254 SNDRV_PCM_HW_PARAM_RATE);
255 struct echoaudio *chip = rule->private;
256 struct snd_interval fixed;
257
258 if (!chip->can_set_rate) {
259 snd_interval_any(&fixed);
260 fixed.min = fixed.max = chip->sample_rate;
261 return snd_interval_refine(rate, &fixed);
262 }
263 return 0;
264}
265
266
267static int pcm_open(struct snd_pcm_substream *substream,
268 signed char max_channels)
269{
270 struct echoaudio *chip;
271 struct snd_pcm_runtime *runtime;
272 struct audiopipe *pipe;
273 int err, i;
274
275 if (max_channels <= 0)
276 return -EAGAIN;
277
278 chip = snd_pcm_substream_chip(substream);
279 runtime = substream->runtime;
280
Panagiotis Issaris59feddb2006-07-25 15:28:03 +0200281 pipe = kzalloc(sizeof(struct audiopipe), GFP_KERNEL);
282 if (!pipe)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200283 return -ENOMEM;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200284 pipe->index = -1; /* Not configured yet */
285
286 /* Set up hw capabilities and contraints */
287 memcpy(&pipe->hw, &pcm_hardware_skel, sizeof(struct snd_pcm_hardware));
288 DE_HWP(("max_channels=%d\n", max_channels));
289 pipe->constr.list = channels_list;
290 pipe->constr.mask = 0;
291 for (i = 0; channels_list[i] <= max_channels; i++);
292 pipe->constr.count = i;
293 if (pipe->hw.channels_max > max_channels)
294 pipe->hw.channels_max = max_channels;
295 if (chip->digital_mode == DIGITAL_MODE_ADAT) {
296 pipe->hw.rate_max = 48000;
297 pipe->hw.rates &= SNDRV_PCM_RATE_8000_48000;
298 }
299
300 runtime->hw = pipe->hw;
301 runtime->private_data = pipe;
302 runtime->private_free = audiopipe_free;
303 snd_pcm_set_sync(substream);
304
305 /* Only mono and any even number of channels are allowed */
306 if ((err = snd_pcm_hw_constraint_list(runtime, 0,
307 SNDRV_PCM_HW_PARAM_CHANNELS,
308 &pipe->constr)) < 0)
309 return err;
310
311 /* All periods should have the same size */
312 if ((err = snd_pcm_hw_constraint_integer(runtime,
313 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
314 return err;
315
316 /* The hw accesses memory in chunks 32 frames long and they should be
317 32-bytes-aligned. It's not a requirement, but it seems that IRQs are
318 generated with a resolution of 32 frames. Thus we need the following */
319 if ((err = snd_pcm_hw_constraint_step(runtime, 0,
320 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
321 32)) < 0)
322 return err;
323 if ((err = snd_pcm_hw_constraint_step(runtime, 0,
324 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
325 32)) < 0)
326 return err;
327
328 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
329 SNDRV_PCM_HW_PARAM_RATE,
330 hw_rule_sample_rate, chip,
331 SNDRV_PCM_HW_PARAM_RATE, -1)) < 0)
332 return err;
333
334 /* Finally allocate a page for the scatter-gather list */
335 if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
336 snd_dma_pci_data(chip->pci),
337 PAGE_SIZE, &pipe->sgpage)) < 0) {
338 DE_HWP(("s-g list allocation failed\n"));
339 return err;
340 }
341
342 return 0;
343}
344
345
346
347static int pcm_analog_in_open(struct snd_pcm_substream *substream)
348{
349 struct echoaudio *chip = snd_pcm_substream_chip(substream);
350 int err;
351
352 DE_ACT(("pcm_analog_in_open\n"));
353 if ((err = pcm_open(substream, num_analog_busses_in(chip) -
354 substream->number)) < 0)
355 return err;
356 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
357 SNDRV_PCM_HW_PARAM_CHANNELS,
358 hw_rule_capture_channels_by_format, NULL,
359 SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
360 return err;
361 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
362 SNDRV_PCM_HW_PARAM_FORMAT,
363 hw_rule_capture_format_by_channels, NULL,
364 SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
365 return err;
366 atomic_inc(&chip->opencount);
367 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
368 chip->can_set_rate=0;
369 DE_HWP(("pcm_analog_in_open cs=%d oc=%d r=%d\n",
370 chip->can_set_rate, atomic_read(&chip->opencount),
371 chip->sample_rate));
372 return 0;
373}
374
375
376
377static int pcm_analog_out_open(struct snd_pcm_substream *substream)
378{
379 struct echoaudio *chip = snd_pcm_substream_chip(substream);
380 int max_channels, err;
381
382#ifdef ECHOCARD_HAS_VMIXER
383 max_channels = num_pipes_out(chip);
384#else
385 max_channels = num_analog_busses_out(chip);
386#endif
387 DE_ACT(("pcm_analog_out_open\n"));
388 if ((err = pcm_open(substream, max_channels - substream->number)) < 0)
389 return err;
390 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
391 SNDRV_PCM_HW_PARAM_CHANNELS,
392 hw_rule_playback_channels_by_format,
393 NULL,
394 SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
395 return err;
396 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
397 SNDRV_PCM_HW_PARAM_FORMAT,
398 hw_rule_playback_format_by_channels,
399 NULL,
400 SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
401 return err;
402 atomic_inc(&chip->opencount);
403 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
404 chip->can_set_rate=0;
405 DE_HWP(("pcm_analog_out_open cs=%d oc=%d r=%d\n",
406 chip->can_set_rate, atomic_read(&chip->opencount),
407 chip->sample_rate));
408 return 0;
409}
410
411
412
413#ifdef ECHOCARD_HAS_DIGITAL_IO
414
415static int pcm_digital_in_open(struct snd_pcm_substream *substream)
416{
417 struct echoaudio *chip = snd_pcm_substream_chip(substream);
418 int err, max_channels;
419
420 DE_ACT(("pcm_digital_in_open\n"));
421 max_channels = num_digital_busses_in(chip) - substream->number;
Takashi Iwaibefceea2007-12-03 17:08:40 +0100422 mutex_lock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200423 if (chip->digital_mode == DIGITAL_MODE_ADAT)
424 err = pcm_open(substream, max_channels);
425 else /* If the card has ADAT, subtract the 6 channels
426 * that S/PDIF doesn't have
427 */
428 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
429
430 if (err < 0)
431 goto din_exit;
432
433 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
434 SNDRV_PCM_HW_PARAM_CHANNELS,
435 hw_rule_capture_channels_by_format, NULL,
436 SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
437 goto din_exit;
438 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
439 SNDRV_PCM_HW_PARAM_FORMAT,
440 hw_rule_capture_format_by_channels, NULL,
441 SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
442 goto din_exit;
443
444 atomic_inc(&chip->opencount);
445 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
446 chip->can_set_rate=0;
447
448din_exit:
Takashi Iwaibefceea2007-12-03 17:08:40 +0100449 mutex_unlock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200450 return err;
451}
452
453
454
455#ifndef ECHOCARD_HAS_VMIXER /* See the note in snd_echo_new_pcm() */
456
457static int pcm_digital_out_open(struct snd_pcm_substream *substream)
458{
459 struct echoaudio *chip = snd_pcm_substream_chip(substream);
460 int err, max_channels;
461
462 DE_ACT(("pcm_digital_out_open\n"));
463 max_channels = num_digital_busses_out(chip) - substream->number;
Takashi Iwaibefceea2007-12-03 17:08:40 +0100464 mutex_lock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200465 if (chip->digital_mode == DIGITAL_MODE_ADAT)
466 err = pcm_open(substream, max_channels);
467 else /* If the card has ADAT, subtract the 6 channels
468 * that S/PDIF doesn't have
469 */
470 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
471
472 if (err < 0)
473 goto dout_exit;
474
475 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
476 SNDRV_PCM_HW_PARAM_CHANNELS,
477 hw_rule_playback_channels_by_format,
478 NULL, SNDRV_PCM_HW_PARAM_FORMAT,
479 -1)) < 0)
480 goto dout_exit;
481 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
482 SNDRV_PCM_HW_PARAM_FORMAT,
483 hw_rule_playback_format_by_channels,
484 NULL, SNDRV_PCM_HW_PARAM_CHANNELS,
485 -1)) < 0)
486 goto dout_exit;
487 atomic_inc(&chip->opencount);
488 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
489 chip->can_set_rate=0;
490dout_exit:
Takashi Iwaibefceea2007-12-03 17:08:40 +0100491 mutex_unlock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200492 return err;
493}
494
495#endif /* !ECHOCARD_HAS_VMIXER */
496
497#endif /* ECHOCARD_HAS_DIGITAL_IO */
498
499
500
501static int pcm_close(struct snd_pcm_substream *substream)
502{
503 struct echoaudio *chip = snd_pcm_substream_chip(substream);
504 int oc;
505
506 /* Nothing to do here. Audio is already off and pipe will be
507 * freed by its callback
508 */
509 DE_ACT(("pcm_close\n"));
510
511 atomic_dec(&chip->opencount);
512 oc = atomic_read(&chip->opencount);
513 DE_ACT(("pcm_close oc=%d cs=%d rs=%d\n", oc,
514 chip->can_set_rate, chip->rate_set));
515 if (oc < 2)
516 chip->can_set_rate = 1;
517 if (oc == 0)
518 chip->rate_set = 0;
519 DE_ACT(("pcm_close2 oc=%d cs=%d rs=%d\n", oc,
520 chip->can_set_rate,chip->rate_set));
521
522 return 0;
523}
524
525
526
527/* Channel allocation and scatter-gather list setup */
528static int init_engine(struct snd_pcm_substream *substream,
529 struct snd_pcm_hw_params *hw_params,
530 int pipe_index, int interleave)
531{
532 struct echoaudio *chip;
533 int err, per, rest, page, edge, offs;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200534 struct audiopipe *pipe;
535
536 chip = snd_pcm_substream_chip(substream);
537 pipe = (struct audiopipe *) substream->runtime->private_data;
538
539 /* Sets up che hardware. If it's already initialized, reset and
540 * redo with the new parameters
541 */
542 spin_lock_irq(&chip->lock);
543 if (pipe->index >= 0) {
544 DE_HWP(("hwp_ie free(%d)\n", pipe->index));
545 err = free_pipes(chip, pipe);
Takashi Iwaida3cec32008-08-08 17:12:14 +0200546 snd_BUG_ON(err);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200547 chip->substream[pipe->index] = NULL;
548 }
549
550 err = allocate_pipes(chip, pipe, pipe_index, interleave);
551 if (err < 0) {
552 spin_unlock_irq(&chip->lock);
553 DE_ACT((KERN_NOTICE "allocate_pipes(%d) err=%d\n",
554 pipe_index, err));
555 return err;
556 }
557 spin_unlock_irq(&chip->lock);
558 DE_ACT((KERN_NOTICE "allocate_pipes()=%d\n", pipe_index));
559
560 DE_HWP(("pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n",
561 params_buffer_bytes(hw_params), params_periods(hw_params),
562 params_period_bytes(hw_params)));
563 err = snd_pcm_lib_malloc_pages(substream,
564 params_buffer_bytes(hw_params));
565 if (err < 0) {
566 snd_printk(KERN_ERR "malloc_pages err=%d\n", err);
567 spin_lock_irq(&chip->lock);
568 free_pipes(chip, pipe);
569 spin_unlock_irq(&chip->lock);
570 pipe->index = -1;
571 return err;
572 }
573
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200574 sglist_init(chip, pipe);
575 edge = PAGE_SIZE;
576 for (offs = page = per = 0; offs < params_buffer_bytes(hw_params);
577 per++) {
578 rest = params_period_bytes(hw_params);
579 if (offs + rest > params_buffer_bytes(hw_params))
580 rest = params_buffer_bytes(hw_params) - offs;
581 while (rest) {
Takashi Iwai77a23f22008-08-21 13:00:13 +0200582 dma_addr_t addr;
583 addr = snd_pcm_sgbuf_get_addr(substream, offs);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200584 if (rest <= edge - offs) {
Takashi Iwai77a23f22008-08-21 13:00:13 +0200585 sglist_add_mapping(chip, pipe, addr, rest);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200586 sglist_add_irq(chip, pipe);
587 offs += rest;
588 rest = 0;
589 } else {
Takashi Iwai77a23f22008-08-21 13:00:13 +0200590 sglist_add_mapping(chip, pipe, addr,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200591 edge - offs);
592 rest -= edge - offs;
593 offs = edge;
594 }
595 if (offs == edge) {
596 edge += PAGE_SIZE;
597 page++;
598 }
599 }
600 }
601
602 /* Close the ring buffer */
603 sglist_wrap(chip, pipe);
604
605 /* This stuff is used by the irq handler, so it must be
606 * initialized before chip->substream
607 */
608 chip->last_period[pipe_index] = 0;
609 pipe->last_counter = 0;
610 pipe->position = 0;
611 smp_wmb();
612 chip->substream[pipe_index] = substream;
613 chip->rate_set = 1;
614 spin_lock_irq(&chip->lock);
615 set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den);
616 spin_unlock_irq(&chip->lock);
617 DE_HWP(("pcm_hw_params ok\n"));
618 return 0;
619}
620
621
622
623static int pcm_analog_in_hw_params(struct snd_pcm_substream *substream,
624 struct snd_pcm_hw_params *hw_params)
625{
626 struct echoaudio *chip = snd_pcm_substream_chip(substream);
627
628 return init_engine(substream, hw_params, px_analog_in(chip) +
629 substream->number, params_channels(hw_params));
630}
631
632
633
634static int pcm_analog_out_hw_params(struct snd_pcm_substream *substream,
635 struct snd_pcm_hw_params *hw_params)
636{
637 return init_engine(substream, hw_params, substream->number,
638 params_channels(hw_params));
639}
640
641
642
643#ifdef ECHOCARD_HAS_DIGITAL_IO
644
645static int pcm_digital_in_hw_params(struct snd_pcm_substream *substream,
646 struct snd_pcm_hw_params *hw_params)
647{
648 struct echoaudio *chip = snd_pcm_substream_chip(substream);
649
650 return init_engine(substream, hw_params, px_digital_in(chip) +
651 substream->number, params_channels(hw_params));
652}
653
654
655
656#ifndef ECHOCARD_HAS_VMIXER /* See the note in snd_echo_new_pcm() */
657static int pcm_digital_out_hw_params(struct snd_pcm_substream *substream,
658 struct snd_pcm_hw_params *hw_params)
659{
660 struct echoaudio *chip = snd_pcm_substream_chip(substream);
661
662 return init_engine(substream, hw_params, px_digital_out(chip) +
663 substream->number, params_channels(hw_params));
664}
665#endif /* !ECHOCARD_HAS_VMIXER */
666
667#endif /* ECHOCARD_HAS_DIGITAL_IO */
668
669
670
671static int pcm_hw_free(struct snd_pcm_substream *substream)
672{
673 struct echoaudio *chip;
674 struct audiopipe *pipe;
675
676 chip = snd_pcm_substream_chip(substream);
677 pipe = (struct audiopipe *) substream->runtime->private_data;
678
679 spin_lock_irq(&chip->lock);
680 if (pipe->index >= 0) {
681 DE_HWP(("pcm_hw_free(%d)\n", pipe->index));
682 free_pipes(chip, pipe);
683 chip->substream[pipe->index] = NULL;
684 pipe->index = -1;
685 }
686 spin_unlock_irq(&chip->lock);
687
688 DE_HWP(("pcm_hw_freed\n"));
689 snd_pcm_lib_free_pages(substream);
690 return 0;
691}
692
693
694
695static int pcm_prepare(struct snd_pcm_substream *substream)
696{
697 struct echoaudio *chip = snd_pcm_substream_chip(substream);
698 struct snd_pcm_runtime *runtime = substream->runtime;
699 struct audioformat format;
700 int pipe_index = ((struct audiopipe *)runtime->private_data)->index;
701
702 DE_HWP(("Prepare rate=%d format=%d channels=%d\n",
703 runtime->rate, runtime->format, runtime->channels));
704 format.interleave = runtime->channels;
705 format.data_are_bigendian = 0;
706 format.mono_to_stereo = 0;
707 switch (runtime->format) {
708 case SNDRV_PCM_FORMAT_U8:
709 format.bits_per_sample = 8;
710 break;
711 case SNDRV_PCM_FORMAT_S16_LE:
712 format.bits_per_sample = 16;
713 break;
714 case SNDRV_PCM_FORMAT_S24_3LE:
715 format.bits_per_sample = 24;
716 break;
717 case SNDRV_PCM_FORMAT_S32_BE:
718 format.data_are_bigendian = 1;
719 case SNDRV_PCM_FORMAT_S32_LE:
720 format.bits_per_sample = 32;
721 break;
722 default:
723 DE_HWP(("Prepare error: unsupported format %d\n",
724 runtime->format));
725 return -EINVAL;
726 }
727
Takashi Iwaida3cec32008-08-08 17:12:14 +0200728 if (snd_BUG_ON(pipe_index >= px_num(chip)))
729 return -EINVAL;
730 if (snd_BUG_ON(!is_pipe_allocated(chip, pipe_index)))
731 return -EINVAL;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200732 set_audio_format(chip, pipe_index, &format);
733 return 0;
734}
735
736
737
738static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
739{
740 struct echoaudio *chip = snd_pcm_substream_chip(substream);
741 struct snd_pcm_runtime *runtime = substream->runtime;
742 struct audiopipe *pipe = runtime->private_data;
743 int i, err;
744 u32 channelmask = 0;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200745 struct snd_pcm_substream *s;
746
Takashi Iwaief991b92007-02-22 12:52:53 +0100747 snd_pcm_group_for_each_entry(s, substream) {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200748 for (i = 0; i < DSP_MAXPIPES; i++) {
749 if (s == chip->substream[i]) {
750 channelmask |= 1 << i;
751 snd_pcm_trigger_done(s, substream);
752 }
753 }
754 }
755
756 spin_lock(&chip->lock);
757 switch (cmd) {
Giuliano Pochini47b5d022010-02-14 18:16:10 +0100758 case SNDRV_PCM_TRIGGER_RESUME:
759 DE_ACT(("pcm_trigger resume\n"));
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200760 case SNDRV_PCM_TRIGGER_START:
761 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
762 DE_ACT(("pcm_trigger start\n"));
763 for (i = 0; i < DSP_MAXPIPES; i++) {
764 if (channelmask & (1 << i)) {
765 pipe = chip->substream[i]->runtime->private_data;
766 switch (pipe->state) {
767 case PIPE_STATE_STOPPED:
768 chip->last_period[i] = 0;
769 pipe->last_counter = 0;
770 pipe->position = 0;
771 *pipe->dma_counter = 0;
772 case PIPE_STATE_PAUSED:
773 pipe->state = PIPE_STATE_STARTED;
774 break;
775 case PIPE_STATE_STARTED:
776 break;
777 }
778 }
779 }
780 err = start_transport(chip, channelmask,
781 chip->pipe_cyclic_mask);
782 break;
Giuliano Pochini47b5d022010-02-14 18:16:10 +0100783 case SNDRV_PCM_TRIGGER_SUSPEND:
784 DE_ACT(("pcm_trigger suspend\n"));
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200785 case SNDRV_PCM_TRIGGER_STOP:
786 DE_ACT(("pcm_trigger stop\n"));
787 for (i = 0; i < DSP_MAXPIPES; i++) {
788 if (channelmask & (1 << i)) {
789 pipe = chip->substream[i]->runtime->private_data;
790 pipe->state = PIPE_STATE_STOPPED;
791 }
792 }
793 err = stop_transport(chip, channelmask);
794 break;
795 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
796 DE_ACT(("pcm_trigger pause\n"));
797 for (i = 0; i < DSP_MAXPIPES; i++) {
798 if (channelmask & (1 << i)) {
799 pipe = chip->substream[i]->runtime->private_data;
800 pipe->state = PIPE_STATE_PAUSED;
801 }
802 }
803 err = pause_transport(chip, channelmask);
804 break;
805 default:
806 err = -EINVAL;
807 }
808 spin_unlock(&chip->lock);
809 return err;
810}
811
812
813
814static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
815{
816 struct snd_pcm_runtime *runtime = substream->runtime;
817 struct audiopipe *pipe = runtime->private_data;
818 size_t cnt, bufsize, pos;
819
820 cnt = le32_to_cpu(*pipe->dma_counter);
821 pipe->position += cnt - pipe->last_counter;
822 pipe->last_counter = cnt;
823 bufsize = substream->runtime->buffer_size;
824 pos = bytes_to_frames(substream->runtime, pipe->position);
825
826 while (pos >= bufsize) {
827 pipe->position -= frames_to_bytes(substream->runtime, bufsize);
828 pos -= bufsize;
829 }
830 return pos;
831}
832
833
834
835/* pcm *_ops structures */
836static struct snd_pcm_ops analog_playback_ops = {
837 .open = pcm_analog_out_open,
838 .close = pcm_close,
839 .ioctl = snd_pcm_lib_ioctl,
840 .hw_params = pcm_analog_out_hw_params,
841 .hw_free = pcm_hw_free,
842 .prepare = pcm_prepare,
843 .trigger = pcm_trigger,
844 .pointer = pcm_pointer,
845 .page = snd_pcm_sgbuf_ops_page,
846};
847static struct snd_pcm_ops analog_capture_ops = {
848 .open = pcm_analog_in_open,
849 .close = pcm_close,
850 .ioctl = snd_pcm_lib_ioctl,
851 .hw_params = pcm_analog_in_hw_params,
852 .hw_free = pcm_hw_free,
853 .prepare = pcm_prepare,
854 .trigger = pcm_trigger,
855 .pointer = pcm_pointer,
856 .page = snd_pcm_sgbuf_ops_page,
857};
858#ifdef ECHOCARD_HAS_DIGITAL_IO
859#ifndef ECHOCARD_HAS_VMIXER
860static struct snd_pcm_ops digital_playback_ops = {
861 .open = pcm_digital_out_open,
862 .close = pcm_close,
863 .ioctl = snd_pcm_lib_ioctl,
864 .hw_params = pcm_digital_out_hw_params,
865 .hw_free = pcm_hw_free,
866 .prepare = pcm_prepare,
867 .trigger = pcm_trigger,
868 .pointer = pcm_pointer,
869 .page = snd_pcm_sgbuf_ops_page,
870};
871#endif /* !ECHOCARD_HAS_VMIXER */
872static struct snd_pcm_ops digital_capture_ops = {
873 .open = pcm_digital_in_open,
874 .close = pcm_close,
875 .ioctl = snd_pcm_lib_ioctl,
876 .hw_params = pcm_digital_in_hw_params,
877 .hw_free = pcm_hw_free,
878 .prepare = pcm_prepare,
879 .trigger = pcm_trigger,
880 .pointer = pcm_pointer,
881 .page = snd_pcm_sgbuf_ops_page,
882};
883#endif /* ECHOCARD_HAS_DIGITAL_IO */
884
885
886
887/* Preallocate memory only for the first substream because it's the most
888 * used one
889 */
890static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
891{
892 struct snd_pcm_substream *ss;
893 int stream, err;
894
895 for (stream = 0; stream < 2; stream++)
896 for (ss = pcm->streams[stream].substream; ss; ss = ss->next) {
897 err = snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
898 dev,
899 ss->number ? 0 : 128<<10,
900 256<<10);
901 if (err < 0)
902 return err;
903 }
904 return 0;
905}
906
907
908
909/*<--snd_echo_probe() */
Bill Pembertone23e7a12012-12-06 12:35:10 -0500910static int snd_echo_new_pcm(struct echoaudio *chip)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200911{
912 struct snd_pcm *pcm;
913 int err;
914
915#ifdef ECHOCARD_HAS_VMIXER
916 /* This card has a Vmixer, that is there is no direct mapping from PCM
917 streams to physical outputs. The user can mix the streams as he wishes
918 via control interface and it's possible to send any stream to any
919 output, thus it makes no sense to keep analog and digital outputs
920 separated */
921
922 /* PCM#0 Virtual outputs and analog inputs */
923 if ((err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
924 num_analog_busses_in(chip), &pcm)) < 0)
925 return err;
926 pcm->private_data = chip;
927 chip->analog_pcm = pcm;
928 strcpy(pcm->name, chip->card->shortname);
929 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
930 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
931 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
932 return err;
933 DE_INIT(("Analog PCM ok\n"));
934
935#ifdef ECHOCARD_HAS_DIGITAL_IO
936 /* PCM#1 Digital inputs, no outputs */
937 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
938 num_digital_busses_in(chip), &pcm)) < 0)
939 return err;
940 pcm->private_data = chip;
941 chip->digital_pcm = pcm;
942 strcpy(pcm->name, chip->card->shortname);
943 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
944 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
945 return err;
946 DE_INIT(("Digital PCM ok\n"));
947#endif /* ECHOCARD_HAS_DIGITAL_IO */
948
949#else /* ECHOCARD_HAS_VMIXER */
950
951 /* The card can manage substreams formed by analog and digital channels
952 at the same time, but I prefer to keep analog and digital channels
953 separated, because that mixed thing is confusing and useless. So we
954 register two PCM devices: */
955
956 /* PCM#0 Analog i/o */
957 if ((err = snd_pcm_new(chip->card, "Analog PCM", 0,
958 num_analog_busses_out(chip),
959 num_analog_busses_in(chip), &pcm)) < 0)
960 return err;
961 pcm->private_data = chip;
962 chip->analog_pcm = pcm;
963 strcpy(pcm->name, chip->card->shortname);
964 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
965 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
966 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
967 return err;
968 DE_INIT(("Analog PCM ok\n"));
969
970#ifdef ECHOCARD_HAS_DIGITAL_IO
971 /* PCM#1 Digital i/o */
972 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1,
973 num_digital_busses_out(chip),
974 num_digital_busses_in(chip), &pcm)) < 0)
975 return err;
976 pcm->private_data = chip;
977 chip->digital_pcm = pcm;
978 strcpy(pcm->name, chip->card->shortname);
979 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
980 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
981 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
982 return err;
983 DE_INIT(("Digital PCM ok\n"));
984#endif /* ECHOCARD_HAS_DIGITAL_IO */
985
986#endif /* ECHOCARD_HAS_VMIXER */
987
988 return 0;
989}
990
991
992
993
994/******************************************************************************
995 Control interface
996******************************************************************************/
997
Giuliano Pochini392bf2f2009-09-30 08:26:45 +0200998#if !defined(ECHOCARD_HAS_VMIXER) || defined(ECHOCARD_HAS_LINE_OUT_GAIN)
Giuliano Pochini9f5d7902009-03-15 21:33:34 +0100999
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001000/******************* PCM output volume *******************/
1001static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
1002 struct snd_ctl_elem_info *uinfo)
1003{
1004 struct echoaudio *chip;
1005
1006 chip = snd_kcontrol_chip(kcontrol);
1007 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1008 uinfo->count = num_busses_out(chip);
1009 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1010 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1011 return 0;
1012}
1013
1014static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
1015 struct snd_ctl_elem_value *ucontrol)
1016{
1017 struct echoaudio *chip;
1018 int c;
1019
1020 chip = snd_kcontrol_chip(kcontrol);
1021 for (c = 0; c < num_busses_out(chip); c++)
1022 ucontrol->value.integer.value[c] = chip->output_gain[c];
1023 return 0;
1024}
1025
1026static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
1027 struct snd_ctl_elem_value *ucontrol)
1028{
1029 struct echoaudio *chip;
1030 int c, changed, gain;
1031
1032 changed = 0;
1033 chip = snd_kcontrol_chip(kcontrol);
1034 spin_lock_irq(&chip->lock);
1035 for (c = 0; c < num_busses_out(chip); c++) {
1036 gain = ucontrol->value.integer.value[c];
1037 /* Ignore out of range values */
1038 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1039 continue;
1040 if (chip->output_gain[c] != gain) {
1041 set_output_gain(chip, c, gain);
1042 changed = 1;
1043 }
1044 }
1045 if (changed)
1046 update_output_line_level(chip);
1047 spin_unlock_irq(&chip->lock);
1048 return changed;
1049}
1050
Giuliano Pochini392bf2f2009-09-30 08:26:45 +02001051#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
1052/* On the Mia this one controls the line-out volume */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001053static struct snd_kcontrol_new snd_echo_line_output_gain = {
Giuliano Pochini392bf2f2009-09-30 08:26:45 +02001054 .name = "Line Playback Volume",
1055 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1056 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1057 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1058 .info = snd_echo_output_gain_info,
1059 .get = snd_echo_output_gain_get,
1060 .put = snd_echo_output_gain_put,
1061 .tlv = {.p = db_scale_output_gain},
1062};
1063#else
Bill Pembertone23e7a12012-12-06 12:35:10 -05001064static struct snd_kcontrol_new snd_echo_pcm_output_gain = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001065 .name = "PCM Playback Volume",
1066 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001067 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001068 .info = snd_echo_output_gain_info,
1069 .get = snd_echo_output_gain_get,
1070 .put = snd_echo_output_gain_put,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001071 .tlv = {.p = db_scale_output_gain},
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001072};
1073#endif
1074
Giuliano Pochini392bf2f2009-09-30 08:26:45 +02001075#endif /* !ECHOCARD_HAS_VMIXER || ECHOCARD_HAS_LINE_OUT_GAIN */
1076
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001077
1078
1079#ifdef ECHOCARD_HAS_INPUT_GAIN
1080
1081/******************* Analog input volume *******************/
1082static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1083 struct snd_ctl_elem_info *uinfo)
1084{
1085 struct echoaudio *chip;
1086
1087 chip = snd_kcontrol_chip(kcontrol);
1088 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1089 uinfo->count = num_analog_busses_in(chip);
1090 uinfo->value.integer.min = ECHOGAIN_MININP;
1091 uinfo->value.integer.max = ECHOGAIN_MAXINP;
1092 return 0;
1093}
1094
1095static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1096 struct snd_ctl_elem_value *ucontrol)
1097{
1098 struct echoaudio *chip;
1099 int c;
1100
1101 chip = snd_kcontrol_chip(kcontrol);
1102 for (c = 0; c < num_analog_busses_in(chip); c++)
1103 ucontrol->value.integer.value[c] = chip->input_gain[c];
1104 return 0;
1105}
1106
1107static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1108 struct snd_ctl_elem_value *ucontrol)
1109{
1110 struct echoaudio *chip;
1111 int c, gain, changed;
1112
1113 changed = 0;
1114 chip = snd_kcontrol_chip(kcontrol);
1115 spin_lock_irq(&chip->lock);
1116 for (c = 0; c < num_analog_busses_in(chip); c++) {
1117 gain = ucontrol->value.integer.value[c];
1118 /* Ignore out of range values */
1119 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1120 continue;
1121 if (chip->input_gain[c] != gain) {
1122 set_input_gain(chip, c, gain);
1123 changed = 1;
1124 }
1125 }
1126 if (changed)
1127 update_input_line_level(chip);
1128 spin_unlock_irq(&chip->lock);
1129 return changed;
1130}
1131
Takashi Iwai0cb29ea2007-01-29 15:33:49 +01001132static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
Giuliano Pochini048b9452006-11-24 13:03:58 +01001133
Bill Pembertone23e7a12012-12-06 12:35:10 -05001134static struct snd_kcontrol_new snd_echo_line_input_gain = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001135 .name = "Line Capture Volume",
1136 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001137 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001138 .info = snd_echo_input_gain_info,
1139 .get = snd_echo_input_gain_get,
1140 .put = snd_echo_input_gain_put,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001141 .tlv = {.p = db_scale_input_gain},
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001142};
1143
1144#endif /* ECHOCARD_HAS_INPUT_GAIN */
1145
1146
1147
1148#ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1149
1150/************ Analog output nominal level (+4dBu / -10dBV) ***************/
1151static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1152 struct snd_ctl_elem_info *uinfo)
1153{
1154 struct echoaudio *chip;
1155
1156 chip = snd_kcontrol_chip(kcontrol);
1157 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1158 uinfo->count = num_analog_busses_out(chip);
1159 uinfo->value.integer.min = 0;
1160 uinfo->value.integer.max = 1;
1161 return 0;
1162}
1163
1164static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1165 struct snd_ctl_elem_value *ucontrol)
1166{
1167 struct echoaudio *chip;
1168 int c;
1169
1170 chip = snd_kcontrol_chip(kcontrol);
1171 for (c = 0; c < num_analog_busses_out(chip); c++)
1172 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1173 return 0;
1174}
1175
1176static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1177 struct snd_ctl_elem_value *ucontrol)
1178{
1179 struct echoaudio *chip;
1180 int c, changed;
1181
1182 changed = 0;
1183 chip = snd_kcontrol_chip(kcontrol);
1184 spin_lock_irq(&chip->lock);
1185 for (c = 0; c < num_analog_busses_out(chip); c++) {
1186 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1187 set_nominal_level(chip, c,
1188 ucontrol->value.integer.value[c]);
1189 changed = 1;
1190 }
1191 }
1192 if (changed)
1193 update_output_line_level(chip);
1194 spin_unlock_irq(&chip->lock);
1195 return changed;
1196}
1197
Bill Pembertone23e7a12012-12-06 12:35:10 -05001198static struct snd_kcontrol_new snd_echo_output_nominal_level = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001199 .name = "Line Playback Switch (-10dBV)",
1200 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1201 .info = snd_echo_output_nominal_info,
1202 .get = snd_echo_output_nominal_get,
1203 .put = snd_echo_output_nominal_put,
1204};
1205
1206#endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1207
1208
1209
1210#ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1211
1212/*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1213static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1214 struct snd_ctl_elem_info *uinfo)
1215{
1216 struct echoaudio *chip;
1217
1218 chip = snd_kcontrol_chip(kcontrol);
1219 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1220 uinfo->count = num_analog_busses_in(chip);
1221 uinfo->value.integer.min = 0;
1222 uinfo->value.integer.max = 1;
1223 return 0;
1224}
1225
1226static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1227 struct snd_ctl_elem_value *ucontrol)
1228{
1229 struct echoaudio *chip;
1230 int c;
1231
1232 chip = snd_kcontrol_chip(kcontrol);
1233 for (c = 0; c < num_analog_busses_in(chip); c++)
1234 ucontrol->value.integer.value[c] =
1235 chip->nominal_level[bx_analog_in(chip) + c];
1236 return 0;
1237}
1238
1239static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1240 struct snd_ctl_elem_value *ucontrol)
1241{
1242 struct echoaudio *chip;
1243 int c, changed;
1244
1245 changed = 0;
1246 chip = snd_kcontrol_chip(kcontrol);
1247 spin_lock_irq(&chip->lock);
1248 for (c = 0; c < num_analog_busses_in(chip); c++) {
1249 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1250 ucontrol->value.integer.value[c]) {
1251 set_nominal_level(chip, bx_analog_in(chip) + c,
1252 ucontrol->value.integer.value[c]);
1253 changed = 1;
1254 }
1255 }
1256 if (changed)
1257 update_output_line_level(chip); /* "Output" is not a mistake
1258 * here.
1259 */
1260 spin_unlock_irq(&chip->lock);
1261 return changed;
1262}
1263
Bill Pembertone23e7a12012-12-06 12:35:10 -05001264static struct snd_kcontrol_new snd_echo_intput_nominal_level = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001265 .name = "Line Capture Switch (-10dBV)",
1266 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1267 .info = snd_echo_input_nominal_info,
1268 .get = snd_echo_input_nominal_get,
1269 .put = snd_echo_input_nominal_put,
1270};
1271
1272#endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1273
1274
1275
1276#ifdef ECHOCARD_HAS_MONITOR
1277
1278/******************* Monitor mixer *******************/
1279static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1280 struct snd_ctl_elem_info *uinfo)
1281{
1282 struct echoaudio *chip;
1283
1284 chip = snd_kcontrol_chip(kcontrol);
1285 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1286 uinfo->count = 1;
1287 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1288 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1289 uinfo->dimen.d[0] = num_busses_out(chip);
1290 uinfo->dimen.d[1] = num_busses_in(chip);
1291 return 0;
1292}
1293
1294static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1295 struct snd_ctl_elem_value *ucontrol)
1296{
1297 struct echoaudio *chip;
1298
1299 chip = snd_kcontrol_chip(kcontrol);
1300 ucontrol->value.integer.value[0] =
1301 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)]
1302 [ucontrol->id.index % num_busses_in(chip)];
1303 return 0;
1304}
1305
1306static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1307 struct snd_ctl_elem_value *ucontrol)
1308{
1309 struct echoaudio *chip;
1310 int changed, gain;
1311 short out, in;
1312
1313 changed = 0;
1314 chip = snd_kcontrol_chip(kcontrol);
1315 out = ucontrol->id.index / num_busses_in(chip);
1316 in = ucontrol->id.index % num_busses_in(chip);
1317 gain = ucontrol->value.integer.value[0];
1318 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1319 return -EINVAL;
1320 if (chip->monitor_gain[out][in] != gain) {
1321 spin_lock_irq(&chip->lock);
1322 set_monitor_gain(chip, out, in, gain);
1323 update_output_line_level(chip);
1324 spin_unlock_irq(&chip->lock);
1325 changed = 1;
1326 }
1327 return changed;
1328}
1329
Bill Pembertone23e7a12012-12-06 12:35:10 -05001330static struct snd_kcontrol_new snd_echo_monitor_mixer = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001331 .name = "Monitor Mixer Volume",
1332 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001333 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001334 .info = snd_echo_mixer_info,
1335 .get = snd_echo_mixer_get,
1336 .put = snd_echo_mixer_put,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001337 .tlv = {.p = db_scale_output_gain},
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001338};
1339
1340#endif /* ECHOCARD_HAS_MONITOR */
1341
1342
1343
1344#ifdef ECHOCARD_HAS_VMIXER
1345
1346/******************* Vmixer *******************/
1347static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1348 struct snd_ctl_elem_info *uinfo)
1349{
1350 struct echoaudio *chip;
1351
1352 chip = snd_kcontrol_chip(kcontrol);
1353 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1354 uinfo->count = 1;
1355 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1356 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1357 uinfo->dimen.d[0] = num_busses_out(chip);
1358 uinfo->dimen.d[1] = num_pipes_out(chip);
1359 return 0;
1360}
1361
1362static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1363 struct snd_ctl_elem_value *ucontrol)
1364{
1365 struct echoaudio *chip;
1366
1367 chip = snd_kcontrol_chip(kcontrol);
1368 ucontrol->value.integer.value[0] =
1369 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1370 [ucontrol->id.index % num_pipes_out(chip)];
1371 return 0;
1372}
1373
1374static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1375 struct snd_ctl_elem_value *ucontrol)
1376{
1377 struct echoaudio *chip;
1378 int gain, changed;
1379 short vch, out;
1380
1381 changed = 0;
1382 chip = snd_kcontrol_chip(kcontrol);
1383 out = ucontrol->id.index / num_pipes_out(chip);
1384 vch = ucontrol->id.index % num_pipes_out(chip);
1385 gain = ucontrol->value.integer.value[0];
1386 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1387 return -EINVAL;
1388 if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1389 spin_lock_irq(&chip->lock);
1390 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1391 update_vmixer_level(chip);
1392 spin_unlock_irq(&chip->lock);
1393 changed = 1;
1394 }
1395 return changed;
1396}
1397
Bill Pembertone23e7a12012-12-06 12:35:10 -05001398static struct snd_kcontrol_new snd_echo_vmixer = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001399 .name = "VMixer Volume",
1400 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001401 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001402 .info = snd_echo_vmixer_info,
1403 .get = snd_echo_vmixer_get,
1404 .put = snd_echo_vmixer_put,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001405 .tlv = {.p = db_scale_output_gain},
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001406};
1407
1408#endif /* ECHOCARD_HAS_VMIXER */
1409
1410
1411
1412#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1413
1414/******************* Digital mode switch *******************/
1415static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1416 struct snd_ctl_elem_info *uinfo)
1417{
1418 static char *names[4] = {
1419 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1420 "S/PDIF Cdrom"
1421 };
1422 struct echoaudio *chip;
1423
1424 chip = snd_kcontrol_chip(kcontrol);
1425 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1426 uinfo->value.enumerated.items = chip->num_digital_modes;
1427 uinfo->count = 1;
1428 if (uinfo->value.enumerated.item >= chip->num_digital_modes)
1429 uinfo->value.enumerated.item = chip->num_digital_modes - 1;
1430 strcpy(uinfo->value.enumerated.name, names[
1431 chip->digital_mode_list[uinfo->value.enumerated.item]]);
1432 return 0;
1433}
1434
1435static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1436 struct snd_ctl_elem_value *ucontrol)
1437{
1438 struct echoaudio *chip;
1439 int i, mode;
1440
1441 chip = snd_kcontrol_chip(kcontrol);
1442 mode = chip->digital_mode;
1443 for (i = chip->num_digital_modes - 1; i >= 0; i--)
1444 if (mode == chip->digital_mode_list[i]) {
1445 ucontrol->value.enumerated.item[0] = i;
1446 break;
1447 }
1448 return 0;
1449}
1450
1451static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1452 struct snd_ctl_elem_value *ucontrol)
1453{
1454 struct echoaudio *chip;
1455 int changed;
1456 unsigned short emode, dmode;
1457
1458 changed = 0;
1459 chip = snd_kcontrol_chip(kcontrol);
1460
1461 emode = ucontrol->value.enumerated.item[0];
1462 if (emode >= chip->num_digital_modes)
1463 return -EINVAL;
1464 dmode = chip->digital_mode_list[emode];
1465
1466 if (dmode != chip->digital_mode) {
1467 /* mode_mutex is required to make this operation atomic wrt
1468 pcm_digital_*_open() and set_input_clock() functions. */
Takashi Iwaibefceea2007-12-03 17:08:40 +01001469 mutex_lock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001470
1471 /* Do not allow the user to change the digital mode when a pcm
1472 device is open because it also changes the number of channels
1473 and the allowed sample rates */
1474 if (atomic_read(&chip->opencount)) {
1475 changed = -EAGAIN;
1476 } else {
1477 changed = set_digital_mode(chip, dmode);
1478 /* If we had to change the clock source, report it */
1479 if (changed > 0 && chip->clock_src_ctl) {
1480 snd_ctl_notify(chip->card,
1481 SNDRV_CTL_EVENT_MASK_VALUE,
1482 &chip->clock_src_ctl->id);
1483 DE_ACT(("SDM() =%d\n", changed));
1484 }
1485 if (changed >= 0)
1486 changed = 1; /* No errors */
1487 }
Takashi Iwaibefceea2007-12-03 17:08:40 +01001488 mutex_unlock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001489 }
1490 return changed;
1491}
1492
Bill Pembertone23e7a12012-12-06 12:35:10 -05001493static struct snd_kcontrol_new snd_echo_digital_mode_switch = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001494 .name = "Digital mode Switch",
1495 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1496 .info = snd_echo_digital_mode_info,
1497 .get = snd_echo_digital_mode_get,
1498 .put = snd_echo_digital_mode_put,
1499};
1500
1501#endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1502
1503
1504
1505#ifdef ECHOCARD_HAS_DIGITAL_IO
1506
1507/******************* S/PDIF mode switch *******************/
1508static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1509 struct snd_ctl_elem_info *uinfo)
1510{
1511 static char *names[2] = {"Consumer", "Professional"};
1512
1513 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1514 uinfo->value.enumerated.items = 2;
1515 uinfo->count = 1;
1516 if (uinfo->value.enumerated.item)
1517 uinfo->value.enumerated.item = 1;
1518 strcpy(uinfo->value.enumerated.name,
1519 names[uinfo->value.enumerated.item]);
1520 return 0;
1521}
1522
1523static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1524 struct snd_ctl_elem_value *ucontrol)
1525{
1526 struct echoaudio *chip;
1527
1528 chip = snd_kcontrol_chip(kcontrol);
1529 ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1530 return 0;
1531}
1532
1533static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1534 struct snd_ctl_elem_value *ucontrol)
1535{
1536 struct echoaudio *chip;
1537 int mode;
1538
1539 chip = snd_kcontrol_chip(kcontrol);
1540 mode = !!ucontrol->value.enumerated.item[0];
1541 if (mode != chip->professional_spdif) {
1542 spin_lock_irq(&chip->lock);
1543 set_professional_spdif(chip, mode);
1544 spin_unlock_irq(&chip->lock);
1545 return 1;
1546 }
1547 return 0;
1548}
1549
Bill Pembertone23e7a12012-12-06 12:35:10 -05001550static struct snd_kcontrol_new snd_echo_spdif_mode_switch = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001551 .name = "S/PDIF mode Switch",
1552 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1553 .info = snd_echo_spdif_mode_info,
1554 .get = snd_echo_spdif_mode_get,
1555 .put = snd_echo_spdif_mode_put,
1556};
1557
1558#endif /* ECHOCARD_HAS_DIGITAL_IO */
1559
1560
1561
1562#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1563
1564/******************* Select input clock source *******************/
1565static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1566 struct snd_ctl_elem_info *uinfo)
1567{
1568 static char *names[8] = {
1569 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1570 "ESync96", "MTC"
1571 };
1572 struct echoaudio *chip;
1573
1574 chip = snd_kcontrol_chip(kcontrol);
1575 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1576 uinfo->value.enumerated.items = chip->num_clock_sources;
1577 uinfo->count = 1;
1578 if (uinfo->value.enumerated.item >= chip->num_clock_sources)
1579 uinfo->value.enumerated.item = chip->num_clock_sources - 1;
1580 strcpy(uinfo->value.enumerated.name, names[
1581 chip->clock_source_list[uinfo->value.enumerated.item]]);
1582 return 0;
1583}
1584
1585static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1586 struct snd_ctl_elem_value *ucontrol)
1587{
1588 struct echoaudio *chip;
1589 int i, clock;
1590
1591 chip = snd_kcontrol_chip(kcontrol);
1592 clock = chip->input_clock;
1593
1594 for (i = 0; i < chip->num_clock_sources; i++)
1595 if (clock == chip->clock_source_list[i])
1596 ucontrol->value.enumerated.item[0] = i;
1597
1598 return 0;
1599}
1600
1601static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1602 struct snd_ctl_elem_value *ucontrol)
1603{
1604 struct echoaudio *chip;
1605 int changed;
1606 unsigned int eclock, dclock;
1607
1608 changed = 0;
1609 chip = snd_kcontrol_chip(kcontrol);
1610 eclock = ucontrol->value.enumerated.item[0];
1611 if (eclock >= chip->input_clock_types)
1612 return -EINVAL;
1613 dclock = chip->clock_source_list[eclock];
1614 if (chip->input_clock != dclock) {
Takashi Iwaibefceea2007-12-03 17:08:40 +01001615 mutex_lock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001616 spin_lock_irq(&chip->lock);
1617 if ((changed = set_input_clock(chip, dclock)) == 0)
1618 changed = 1; /* no errors */
1619 spin_unlock_irq(&chip->lock);
Takashi Iwaibefceea2007-12-03 17:08:40 +01001620 mutex_unlock(&chip->mode_mutex);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001621 }
1622
1623 if (changed < 0)
1624 DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed));
1625
1626 return changed;
1627}
1628
Bill Pembertone23e7a12012-12-06 12:35:10 -05001629static struct snd_kcontrol_new snd_echo_clock_source_switch = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001630 .name = "Sample Clock Source",
1631 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1632 .info = snd_echo_clock_source_info,
1633 .get = snd_echo_clock_source_get,
1634 .put = snd_echo_clock_source_put,
1635};
1636
1637#endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1638
1639
1640
1641#ifdef ECHOCARD_HAS_PHANTOM_POWER
1642
1643/******************* Phantom power switch *******************/
Takashi Iwaia5ce8892007-07-23 15:42:26 +02001644#define snd_echo_phantom_power_info snd_ctl_boolean_mono_info
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001645
1646static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1647 struct snd_ctl_elem_value *ucontrol)
1648{
1649 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1650
1651 ucontrol->value.integer.value[0] = chip->phantom_power;
1652 return 0;
1653}
1654
1655static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1656 struct snd_ctl_elem_value *ucontrol)
1657{
1658 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1659 int power, changed = 0;
1660
1661 power = !!ucontrol->value.integer.value[0];
1662 if (chip->phantom_power != power) {
1663 spin_lock_irq(&chip->lock);
1664 changed = set_phantom_power(chip, power);
1665 spin_unlock_irq(&chip->lock);
1666 if (changed == 0)
1667 changed = 1; /* no errors */
1668 }
1669 return changed;
1670}
1671
Bill Pembertone23e7a12012-12-06 12:35:10 -05001672static struct snd_kcontrol_new snd_echo_phantom_power_switch = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001673 .name = "Phantom power Switch",
1674 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1675 .info = snd_echo_phantom_power_info,
1676 .get = snd_echo_phantom_power_get,
1677 .put = snd_echo_phantom_power_put,
1678};
1679
1680#endif /* ECHOCARD_HAS_PHANTOM_POWER */
1681
1682
1683
1684#ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1685
1686/******************* Digital input automute switch *******************/
Takashi Iwaia5ce8892007-07-23 15:42:26 +02001687#define snd_echo_automute_info snd_ctl_boolean_mono_info
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001688
1689static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1690 struct snd_ctl_elem_value *ucontrol)
1691{
1692 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1693
1694 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1695 return 0;
1696}
1697
1698static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1699 struct snd_ctl_elem_value *ucontrol)
1700{
1701 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1702 int automute, changed = 0;
1703
1704 automute = !!ucontrol->value.integer.value[0];
1705 if (chip->digital_in_automute != automute) {
1706 spin_lock_irq(&chip->lock);
1707 changed = set_input_auto_mute(chip, automute);
1708 spin_unlock_irq(&chip->lock);
1709 if (changed == 0)
1710 changed = 1; /* no errors */
1711 }
1712 return changed;
1713}
1714
Bill Pembertone23e7a12012-12-06 12:35:10 -05001715static struct snd_kcontrol_new snd_echo_automute_switch = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001716 .name = "Digital Capture Switch (automute)",
1717 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1718 .info = snd_echo_automute_info,
1719 .get = snd_echo_automute_get,
1720 .put = snd_echo_automute_put,
1721};
1722
1723#endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1724
1725
1726
1727/******************* VU-meters switch *******************/
Takashi Iwaia5ce8892007-07-23 15:42:26 +02001728#define snd_echo_vumeters_switch_info snd_ctl_boolean_mono_info
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001729
1730static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1731 struct snd_ctl_elem_value *ucontrol)
1732{
1733 struct echoaudio *chip;
1734
1735 chip = snd_kcontrol_chip(kcontrol);
1736 spin_lock_irq(&chip->lock);
1737 set_meters_on(chip, ucontrol->value.integer.value[0]);
1738 spin_unlock_irq(&chip->lock);
1739 return 1;
1740}
1741
Bill Pembertone23e7a12012-12-06 12:35:10 -05001742static struct snd_kcontrol_new snd_echo_vumeters_switch = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001743 .name = "VU-meters Switch",
1744 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1745 .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1746 .info = snd_echo_vumeters_switch_info,
1747 .put = snd_echo_vumeters_switch_put,
1748};
1749
1750
1751
1752/***** Read VU-meters (input, output, analog and digital together) *****/
1753static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1754 struct snd_ctl_elem_info *uinfo)
1755{
1756 struct echoaudio *chip;
1757
1758 chip = snd_kcontrol_chip(kcontrol);
1759 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1760 uinfo->count = 96;
1761 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1762 uinfo->value.integer.max = 0;
1763#ifdef ECHOCARD_HAS_VMIXER
1764 uinfo->dimen.d[0] = 3; /* Out, In, Virt */
1765#else
1766 uinfo->dimen.d[0] = 2; /* Out, In */
1767#endif
1768 uinfo->dimen.d[1] = 16; /* 16 channels */
1769 uinfo->dimen.d[2] = 2; /* 0=level, 1=peak */
1770 return 0;
1771}
1772
1773static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1774 struct snd_ctl_elem_value *ucontrol)
1775{
1776 struct echoaudio *chip;
1777
1778 chip = snd_kcontrol_chip(kcontrol);
1779 get_audio_meters(chip, ucontrol->value.integer.value);
1780 return 0;
1781}
1782
Bill Pembertone23e7a12012-12-06 12:35:10 -05001783static struct snd_kcontrol_new snd_echo_vumeters = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001784 .name = "VU-meters",
1785 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001786 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1787 SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1788 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001789 .info = snd_echo_vumeters_info,
1790 .get = snd_echo_vumeters_get,
Giuliano Pochini048b9452006-11-24 13:03:58 +01001791 .tlv = {.p = db_scale_output_gain},
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001792};
1793
1794
1795
1796/*** Channels info - it exports informations about the number of channels ***/
1797static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1798 struct snd_ctl_elem_info *uinfo)
1799{
1800 struct echoaudio *chip;
1801
1802 chip = snd_kcontrol_chip(kcontrol);
1803 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1804 uinfo->count = 6;
1805 uinfo->value.integer.min = 0;
1806 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1807 return 0;
1808}
1809
1810static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1811 struct snd_ctl_elem_value *ucontrol)
1812{
1813 struct echoaudio *chip;
1814 int detected, clocks, bit, src;
1815
1816 chip = snd_kcontrol_chip(kcontrol);
1817 ucontrol->value.integer.value[0] = num_busses_in(chip);
1818 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1819 ucontrol->value.integer.value[2] = num_busses_out(chip);
1820 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1821 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1822
1823 /* Compute the bitmask of the currently valid input clocks */
1824 detected = detect_input_clocks(chip);
1825 clocks = 0;
1826 src = chip->num_clock_sources - 1;
1827 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1828 if (detected & (1 << bit))
1829 for (; src >= 0; src--)
1830 if (bit == chip->clock_source_list[src]) {
1831 clocks |= 1 << src;
1832 break;
1833 }
1834 ucontrol->value.integer.value[5] = clocks;
1835
1836 return 0;
1837}
1838
Bill Pembertone23e7a12012-12-06 12:35:10 -05001839static struct snd_kcontrol_new snd_echo_channels_info = {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001840 .name = "Channels info",
1841 .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1842 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1843 .info = snd_echo_channels_info_info,
1844 .get = snd_echo_channels_info_get,
1845};
1846
1847
1848
1849
1850/******************************************************************************
1851 IRQ Handler
1852******************************************************************************/
1853
David Howells7d12e782006-10-05 14:55:46 +01001854static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001855{
1856 struct echoaudio *chip = dev_id;
1857 struct snd_pcm_substream *substream;
1858 int period, ss, st;
1859
1860 spin_lock(&chip->lock);
1861 st = service_irq(chip);
1862 if (st < 0) {
1863 spin_unlock(&chip->lock);
1864 return IRQ_NONE;
1865 }
1866 /* The hardware doesn't tell us which substream caused the irq,
1867 thus we have to check all running substreams. */
1868 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
Giuliano Pochinib721e682010-02-17 00:57:44 +01001869 substream = chip->substream[ss];
1870 if (substream && ((struct audiopipe *)substream->runtime->
1871 private_data)->state == PIPE_STATE_STARTED) {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001872 period = pcm_pointer(substream) /
1873 substream->runtime->period_size;
1874 if (period != chip->last_period[ss]) {
1875 chip->last_period[ss] = period;
1876 spin_unlock(&chip->lock);
1877 snd_pcm_period_elapsed(substream);
1878 spin_lock(&chip->lock);
1879 }
1880 }
1881 }
1882 spin_unlock(&chip->lock);
1883
1884#ifdef ECHOCARD_HAS_MIDI
1885 if (st > 0 && chip->midi_in) {
1886 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1887 DE_MID(("rawmidi_iread=%d\n", st));
1888 }
1889#endif
1890 return IRQ_HANDLED;
1891}
1892
1893
1894
1895
1896/******************************************************************************
1897 Module construction / destruction
1898******************************************************************************/
1899
1900static int snd_echo_free(struct echoaudio *chip)
1901{
1902 DE_INIT(("Stop DSP...\n"));
Takashi Iwaiebf029d2008-04-22 17:28:11 +02001903 if (chip->comm_page)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001904 rest_in_peace(chip);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001905 DE_INIT(("Stopped.\n"));
1906
1907 if (chip->irq >= 0)
Takashi Iwai437a5a42006-11-21 12:14:23 +01001908 free_irq(chip->irq, chip);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001909
Takashi Iwaiebf029d2008-04-22 17:28:11 +02001910 if (chip->comm_page)
1911 snd_dma_free_pages(&chip->commpage_dma_buf);
1912
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001913 if (chip->dsp_registers)
1914 iounmap(chip->dsp_registers);
1915
Takashi Iwai8caf7aa2006-06-28 16:39:36 +02001916 if (chip->iores)
1917 release_and_free_resource(chip->iores);
1918
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001919 DE_INIT(("MMIO freed.\n"));
1920
1921 pci_disable_device(chip->pci);
1922
1923 /* release chip data */
Giuliano Pochini4f8ada42010-02-14 18:15:51 +01001924 free_firmware_cache(chip);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001925 kfree(chip);
1926 DE_INIT(("Chip freed.\n"));
1927 return 0;
1928}
1929
1930
1931
1932static int snd_echo_dev_free(struct snd_device *device)
1933{
1934 struct echoaudio *chip = device->device_data;
1935
1936 DE_INIT(("snd_echo_dev_free()...\n"));
1937 return snd_echo_free(chip);
1938}
1939
1940
1941
1942/* <--snd_echo_probe() */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001943static int snd_echo_create(struct snd_card *card,
1944 struct pci_dev *pci,
1945 struct echoaudio **rchip)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001946{
1947 struct echoaudio *chip;
1948 int err;
1949 size_t sz;
1950 static struct snd_device_ops ops = {
1951 .dev_free = snd_echo_dev_free,
1952 };
1953
1954 *rchip = NULL;
1955
1956 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1957
1958 if ((err = pci_enable_device(pci)) < 0)
1959 return err;
1960 pci_set_master(pci);
1961
Giuliano Pochini47b5d022010-02-14 18:16:10 +01001962 /* Allocate chip if needed */
1963 if (!*rchip) {
1964 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1965 if (!chip) {
1966 pci_disable_device(pci);
1967 return -ENOMEM;
1968 }
1969 DE_INIT(("chip=%p\n", chip));
1970 spin_lock_init(&chip->lock);
1971 chip->card = card;
1972 chip->pci = pci;
1973 chip->irq = -1;
1974 atomic_set(&chip->opencount, 0);
1975 mutex_init(&chip->mode_mutex);
1976 chip->can_set_rate = 1;
1977 } else {
1978 /* If this was called from the resume function, chip is
1979 * already allocated and it contains current card settings.
1980 */
1981 chip = *rchip;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001982 }
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001983
1984 /* PCI resource allocation */
1985 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1986 sz = pci_resource_len(pci, 0);
1987 if (sz > PAGE_SIZE)
1988 sz = PAGE_SIZE; /* We map only the required part */
1989
1990 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1991 ECHOCARD_NAME)) == NULL) {
1992 snd_echo_free(chip);
1993 snd_printk(KERN_ERR "cannot get memory region\n");
1994 return -EBUSY;
1995 }
1996 chip->dsp_registers = (volatile u32 __iomem *)
1997 ioremap_nocache(chip->dsp_registers_phys, sz);
1998
Takashi Iwai437a5a42006-11-21 12:14:23 +01001999 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
Takashi Iwai934c2b62011-06-10 16:36:37 +02002000 KBUILD_MODNAME, chip)) {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002001 snd_echo_free(chip);
2002 snd_printk(KERN_ERR "cannot grab irq\n");
2003 return -EBUSY;
2004 }
2005 chip->irq = pci->irq;
2006 DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
2007 chip->pci, chip->irq, chip->pci->subsystem_device));
2008
2009 /* Create the DSP comm page - this is the area of memory used for most
2010 of the communication with the DSP, which accesses it via bus mastering */
2011 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
2012 sizeof(struct comm_page),
2013 &chip->commpage_dma_buf) < 0) {
2014 snd_echo_free(chip);
2015 snd_printk(KERN_ERR "cannot allocate the comm page\n");
2016 return -ENOMEM;
2017 }
2018 chip->comm_page_phys = chip->commpage_dma_buf.addr;
2019 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
2020
2021 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002022 if (err >= 0)
2023 err = set_mixer_defaults(chip);
2024 if (err < 0) {
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002025 DE_INIT(("init_hw err=%d\n", err));
2026 snd_echo_free(chip);
2027 return err;
2028 }
2029 DE_INIT(("Card init OK\n"));
2030
2031 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2032 snd_echo_free(chip);
2033 return err;
2034 }
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002035 *rchip = chip;
2036 /* Init done ! */
2037 return 0;
2038}
2039
2040
2041
2042/* constructor */
Bill Pembertone23e7a12012-12-06 12:35:10 -05002043static int snd_echo_probe(struct pci_dev *pci,
2044 const struct pci_device_id *pci_id)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002045{
2046 static int dev;
2047 struct snd_card *card;
2048 struct echoaudio *chip;
2049 char *dsp;
2050 int i, err;
2051
2052 if (dev >= SNDRV_CARDS)
2053 return -ENODEV;
2054 if (!enable[dev]) {
2055 dev++;
2056 return -ENOENT;
2057 }
2058
2059 DE_INIT(("Echoaudio driver starting...\n"));
2060 i = 0;
Takashi Iwai60c57722014-01-29 14:20:19 +01002061 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2062 0, &card);
Takashi Iwaie58de7b2008-12-28 16:44:30 +01002063 if (err < 0)
2064 return err;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002065
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002066 chip = NULL; /* Tells snd_echo_create to allocate chip */
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002067 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2068 snd_card_free(card);
2069 return err;
2070 }
2071
2072 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2073 strcpy(card->shortname, chip->card_name);
2074
2075 dsp = "56301";
2076 if (pci_id->device == 0x3410)
2077 dsp = "56361";
2078
2079 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2080 card->shortname, pci_id->subdevice & 0x000f, dsp,
2081 chip->dsp_registers_phys, chip->irq);
2082
2083 if ((err = snd_echo_new_pcm(chip)) < 0) {
2084 snd_printk(KERN_ERR "new pcm error %d\n", err);
2085 snd_card_free(card);
2086 return err;
2087 }
2088
2089#ifdef ECHOCARD_HAS_MIDI
2090 if (chip->has_midi) { /* Some Mia's do not have midi */
2091 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2092 snd_printk(KERN_ERR "new midi error %d\n", err);
2093 snd_card_free(card);
2094 return err;
2095 }
2096 }
2097#endif
2098
2099#ifdef ECHOCARD_HAS_VMIXER
2100 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002101 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2102 goto ctl_error;
Giuliano Pochini392bf2f2009-09-30 08:26:45 +02002103#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
2104 err = snd_ctl_add(chip->card,
2105 snd_ctl_new1(&snd_echo_line_output_gain, chip));
2106 if (err < 0)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002107 goto ctl_error;
2108#endif
Giuliano Pochini392bf2f2009-09-30 08:26:45 +02002109#else /* ECHOCARD_HAS_VMIXER */
2110 err = snd_ctl_add(chip->card,
2111 snd_ctl_new1(&snd_echo_pcm_output_gain, chip));
2112 if (err < 0)
2113 goto ctl_error;
2114#endif /* ECHOCARD_HAS_VMIXER */
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002115
2116#ifdef ECHOCARD_HAS_INPUT_GAIN
2117 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2118 goto ctl_error;
2119#endif
2120
2121#ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2122 if (!chip->hasnt_input_nominal_level)
2123 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2124 goto ctl_error;
2125#endif
2126
2127#ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2128 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2129 goto ctl_error;
2130#endif
2131
2132 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2133 goto ctl_error;
2134
2135 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2136 goto ctl_error;
2137
2138#ifdef ECHOCARD_HAS_MONITOR
2139 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2140 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2141 goto ctl_error;
2142#endif
2143
2144#ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2145 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2146 goto ctl_error;
2147#endif
2148
2149 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2150 goto ctl_error;
2151
2152#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2153 /* Creates a list of available digital modes */
2154 chip->num_digital_modes = 0;
2155 for (i = 0; i < 6; i++)
2156 if (chip->digital_modes & (1 << i))
2157 chip->digital_mode_list[chip->num_digital_modes++] = i;
2158
2159 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2160 goto ctl_error;
2161#endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2162
2163#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2164 /* Creates a list of available clock sources */
2165 chip->num_clock_sources = 0;
2166 for (i = 0; i < 10; i++)
2167 if (chip->input_clock_types & (1 << i))
2168 chip->clock_source_list[chip->num_clock_sources++] = i;
2169
2170 if (chip->num_clock_sources > 1) {
2171 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2172 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2173 goto ctl_error;
2174 }
2175#endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2176
2177#ifdef ECHOCARD_HAS_DIGITAL_IO
2178 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2179 goto ctl_error;
2180#endif
2181
2182#ifdef ECHOCARD_HAS_PHANTOM_POWER
2183 if (chip->has_phantom_power)
2184 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2185 goto ctl_error;
2186#endif
2187
Julia Lawalla0fd4342010-04-02 14:47:59 +02002188 err = snd_card_register(card);
2189 if (err < 0)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002190 goto ctl_error;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002191 snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2192
2193 pci_set_drvdata(pci, chip);
2194 dev++;
2195 return 0;
2196
2197ctl_error:
2198 snd_printk(KERN_ERR "new control error %d\n", err);
2199 snd_card_free(card);
2200 return err;
2201}
2202
2203
2204
Takashi Iwaic7561cd2012-08-14 18:12:04 +02002205#if defined(CONFIG_PM_SLEEP)
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002206
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002207static int snd_echo_suspend(struct device *dev)
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002208{
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002209 struct pci_dev *pci = to_pci_dev(dev);
2210 struct echoaudio *chip = dev_get_drvdata(dev);
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002211
2212 DE_INIT(("suspend start\n"));
2213 snd_pcm_suspend_all(chip->analog_pcm);
2214 snd_pcm_suspend_all(chip->digital_pcm);
2215
2216#ifdef ECHOCARD_HAS_MIDI
2217 /* This call can sleep */
2218 if (chip->midi_out)
2219 snd_echo_midi_output_trigger(chip->midi_out, 0);
2220#endif
2221 spin_lock_irq(&chip->lock);
2222 if (wait_handshake(chip)) {
2223 spin_unlock_irq(&chip->lock);
2224 return -EIO;
2225 }
2226 clear_handshake(chip);
2227 if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0) {
2228 spin_unlock_irq(&chip->lock);
2229 return -EIO;
2230 }
2231 spin_unlock_irq(&chip->lock);
2232
2233 chip->dsp_code = NULL;
2234 free_irq(chip->irq, chip);
2235 chip->irq = -1;
2236 pci_save_state(pci);
2237 pci_disable_device(pci);
2238
2239 DE_INIT(("suspend done\n"));
2240 return 0;
2241}
2242
2243
2244
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002245static int snd_echo_resume(struct device *dev)
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002246{
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002247 struct pci_dev *pci = to_pci_dev(dev);
2248 struct echoaudio *chip = dev_get_drvdata(dev);
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002249 struct comm_page *commpage, *commpage_bak;
2250 u32 pipe_alloc_mask;
2251 int err;
2252
2253 DE_INIT(("resume start\n"));
2254 pci_restore_state(pci);
2255 commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
Kulikov Vasiliy0b6d0922010-07-16 20:15:43 +04002256 if (commpage_bak == NULL)
2257 return -ENOMEM;
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002258 commpage = chip->comm_page;
2259 memcpy(commpage_bak, commpage, sizeof(struct comm_page));
2260
2261 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2262 if (err < 0) {
2263 kfree(commpage_bak);
2264 DE_INIT(("resume init_hw err=%d\n", err));
2265 snd_echo_free(chip);
2266 return err;
2267 }
2268 DE_INIT(("resume init OK\n"));
2269
2270 /* Temporarily set chip->pipe_alloc_mask=0 otherwise
2271 * restore_dsp_settings() fails.
2272 */
2273 pipe_alloc_mask = chip->pipe_alloc_mask;
2274 chip->pipe_alloc_mask = 0;
2275 err = restore_dsp_rettings(chip);
2276 chip->pipe_alloc_mask = pipe_alloc_mask;
2277 if (err < 0) {
2278 kfree(commpage_bak);
2279 return err;
2280 }
2281 DE_INIT(("resume restore OK\n"));
2282
2283 memcpy(&commpage->audio_format, &commpage_bak->audio_format,
2284 sizeof(commpage->audio_format));
2285 memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
2286 sizeof(commpage->sglist_addr));
2287 memcpy(&commpage->midi_output, &commpage_bak->midi_output,
2288 sizeof(commpage->midi_output));
2289 kfree(commpage_bak);
2290
2291 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
Takashi Iwai934c2b62011-06-10 16:36:37 +02002292 KBUILD_MODNAME, chip)) {
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002293 snd_echo_free(chip);
2294 snd_printk(KERN_ERR "cannot grab irq\n");
2295 return -EBUSY;
2296 }
2297 chip->irq = pci->irq;
2298 DE_INIT(("resume irq=%d\n", chip->irq));
2299
2300#ifdef ECHOCARD_HAS_MIDI
2301 if (chip->midi_input_enabled)
2302 enable_midi_input(chip, TRUE);
2303 if (chip->midi_out)
2304 snd_echo_midi_output_trigger(chip->midi_out, 1);
2305#endif
2306
2307 DE_INIT(("resume done\n"));
2308 return 0;
2309}
2310
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002311static SIMPLE_DEV_PM_OPS(snd_echo_pm, snd_echo_suspend, snd_echo_resume);
2312#define SND_ECHO_PM_OPS &snd_echo_pm
2313#else
2314#define SND_ECHO_PM_OPS NULL
Takashi Iwaic7561cd2012-08-14 18:12:04 +02002315#endif /* CONFIG_PM_SLEEP */
Giuliano Pochini47b5d022010-02-14 18:16:10 +01002316
2317
Bill Pembertone23e7a12012-12-06 12:35:10 -05002318static void snd_echo_remove(struct pci_dev *pci)
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002319{
2320 struct echoaudio *chip;
2321
2322 chip = pci_get_drvdata(pci);
2323 if (chip)
2324 snd_card_free(chip->card);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002325}
2326
2327
2328
2329/******************************************************************************
2330 Everything starts and ends here
2331******************************************************************************/
2332
2333/* pci_driver definition */
Takashi Iwaie9f66d92012-04-24 12:25:00 +02002334static struct pci_driver echo_driver = {
Takashi Iwai3733e422011-06-10 16:20:20 +02002335 .name = KBUILD_MODNAME,
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002336 .id_table = snd_echo_ids,
2337 .probe = snd_echo_probe,
Bill Pembertone23e7a12012-12-06 12:35:10 -05002338 .remove = snd_echo_remove,
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002339 .driver = {
2340 .pm = SND_ECHO_PM_OPS,
2341 },
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02002342};
2343
Takashi Iwaie9f66d92012-04-24 12:25:00 +02002344module_pci_driver(echo_driver);