aboutsummaryrefslogtreecommitdiffstats
path: root/sound/pci/echoaudio/echoaudio.c
diff options
context:
space:
mode:
Diffstat (limited to 'sound/pci/echoaudio/echoaudio.c')
-rw-r--r--sound/pci/echoaudio/echoaudio.c2196
1 files changed, 2196 insertions, 0 deletions
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
new file mode 100644
index 000000000000..43b408ada1da
--- /dev/null
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -0,0 +1,2196 @@
1/*
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
19MODULE_AUTHOR("Giuliano Pochini <pochini@shiny.it>");
20MODULE_LICENSE("GPL v2");
21MODULE_DESCRIPTION("Echoaudio " ECHOCARD_NAME " soundcards driver");
22MODULE_SUPPORTED_DEVICE("{{Echoaudio," ECHOCARD_NAME "}}");
23MODULE_DEVICE_TABLE(pci, snd_echo_ids);
24
25static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
26static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
27static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
28
29module_param_array(index, int, NULL, 0444);
30MODULE_PARM_DESC(index, "Index value for " ECHOCARD_NAME " soundcard.");
31module_param_array(id, charp, NULL, 0444);
32MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
33module_param_array(enable, bool, NULL, 0444);
34MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
35
36static unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
37
38static int get_firmware(const struct firmware **fw_entry,
39 const struct firmware *frm, struct echoaudio *chip)
40{
41 int err;
42 char name[30];
43 DE_ACT(("firmware requested: %s\n", frm->data));
44 snprintf(name, sizeof(name), "ea/%s", frm->data);
45 if ((err = request_firmware(fw_entry, name, pci_device(chip))) < 0)
46 snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err);
47 return err;
48}
49
50static void free_firmware(const struct firmware *fw_entry)
51{
52 release_firmware(fw_entry);
53 DE_ACT(("firmware released\n"));
54}
55
56
57
58/******************************************************************************
59 PCM interface
60******************************************************************************/
61
62static void audiopipe_free(struct snd_pcm_runtime *runtime)
63{
64 struct audiopipe *pipe = runtime->private_data;
65
66 if (pipe->sgpage.area)
67 snd_dma_free_pages(&pipe->sgpage);
68 kfree(pipe);
69}
70
71
72
73static int hw_rule_capture_format_by_channels(struct snd_pcm_hw_params *params,
74 struct snd_pcm_hw_rule *rule)
75{
76 struct snd_interval *c = hw_param_interval(params,
77 SNDRV_PCM_HW_PARAM_CHANNELS);
78 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
79 struct snd_mask fmt;
80
81 snd_mask_any(&fmt);
82
83#ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
84 /* >=2 channels cannot be S32_BE */
85 if (c->min == 2) {
86 fmt.bits[0] &= ~SNDRV_PCM_FMTBIT_S32_BE;
87 return snd_mask_refine(f, &fmt);
88 }
89#endif
90 /* > 2 channels cannot be U8 and S32_BE */
91 if (c->min > 2) {
92 fmt.bits[0] &= ~(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S32_BE);
93 return snd_mask_refine(f, &fmt);
94 }
95 /* Mono is ok with any format */
96 return 0;
97}
98
99
100
101static int hw_rule_capture_channels_by_format(struct snd_pcm_hw_params *params,
102 struct snd_pcm_hw_rule *rule)
103{
104 struct snd_interval *c = hw_param_interval(params,
105 SNDRV_PCM_HW_PARAM_CHANNELS);
106 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
107 struct snd_interval ch;
108
109 snd_interval_any(&ch);
110
111 /* S32_BE is mono (and stereo) only */
112 if (f->bits[0] == SNDRV_PCM_FMTBIT_S32_BE) {
113 ch.min = 1;
114#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
115 ch.max = 2;
116#else
117 ch.max = 1;
118#endif
119 ch.integer = 1;
120 return snd_interval_refine(c, &ch);
121 }
122 /* U8 can be only mono or stereo */
123 if (f->bits[0] == SNDRV_PCM_FMTBIT_U8) {
124 ch.min = 1;
125 ch.max = 2;
126 ch.integer = 1;
127 return snd_interval_refine(c, &ch);
128 }
129 /* S16_LE, S24_3LE and S32_LE support any number of channels. */
130 return 0;
131}
132
133
134
135static int hw_rule_playback_format_by_channels(struct snd_pcm_hw_params *params,
136 struct snd_pcm_hw_rule *rule)
137{
138 struct snd_interval *c = hw_param_interval(params,
139 SNDRV_PCM_HW_PARAM_CHANNELS);
140 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
141 struct snd_mask fmt;
142 u64 fmask;
143 snd_mask_any(&fmt);
144
145 fmask = fmt.bits[0] + ((u64)fmt.bits[1] << 32);
146
147 /* >2 channels must be S16_LE, S24_3LE or S32_LE */
148 if (c->min > 2) {
149 fmask &= SNDRV_PCM_FMTBIT_S16_LE |
150 SNDRV_PCM_FMTBIT_S24_3LE |
151 SNDRV_PCM_FMTBIT_S32_LE;
152 /* 1 channel must be S32_BE or S32_LE */
153 } else if (c->max == 1)
154 fmask &= SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE;
155#ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
156 /* 2 channels cannot be S32_BE */
157 else if (c->min == 2 && c->max == 2)
158 fmask &= ~SNDRV_PCM_FMTBIT_S32_BE;
159#endif
160 else
161 return 0;
162
163 fmt.bits[0] &= (u32)fmask;
164 fmt.bits[1] &= (u32)(fmask >> 32);
165 return snd_mask_refine(f, &fmt);
166}
167
168
169
170static int hw_rule_playback_channels_by_format(struct snd_pcm_hw_params *params,
171 struct snd_pcm_hw_rule *rule)
172{
173 struct snd_interval *c = hw_param_interval(params,
174 SNDRV_PCM_HW_PARAM_CHANNELS);
175 struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
176 struct snd_interval ch;
177 u64 fmask;
178
179 snd_interval_any(&ch);
180 ch.integer = 1;
181 fmask = f->bits[0] + ((u64)f->bits[1] << 32);
182
183 /* S32_BE is mono (and stereo) only */
184 if (fmask == SNDRV_PCM_FMTBIT_S32_BE) {
185 ch.min = 1;
186#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
187 ch.max = 2;
188#else
189 ch.max = 1;
190#endif
191 /* U8 is stereo only */
192 } else if (fmask == SNDRV_PCM_FMTBIT_U8)
193 ch.min = ch.max = 2;
194 /* S16_LE and S24_3LE must be at least stereo */
195 else if (!(fmask & ~(SNDRV_PCM_FMTBIT_S16_LE |
196 SNDRV_PCM_FMTBIT_S24_3LE)))
197 ch.min = 2;
198 else
199 return 0;
200
201 return snd_interval_refine(c, &ch);
202}
203
204
205
206/* Since the sample rate is a global setting, do allow the user to change the
207sample rate only if there is only one pcm device open. */
208static int hw_rule_sample_rate(struct snd_pcm_hw_params *params,
209 struct snd_pcm_hw_rule *rule)
210{
211 struct snd_interval *rate = hw_param_interval(params,
212 SNDRV_PCM_HW_PARAM_RATE);
213 struct echoaudio *chip = rule->private;
214 struct snd_interval fixed;
215
216 if (!chip->can_set_rate) {
217 snd_interval_any(&fixed);
218 fixed.min = fixed.max = chip->sample_rate;
219 return snd_interval_refine(rate, &fixed);
220 }
221 return 0;
222}
223
224
225static int pcm_open(struct snd_pcm_substream *substream,
226 signed char max_channels)
227{
228 struct echoaudio *chip;
229 struct snd_pcm_runtime *runtime;
230 struct audiopipe *pipe;
231 int err, i;
232
233 if (max_channels <= 0)
234 return -EAGAIN;
235
236 chip = snd_pcm_substream_chip(substream);
237 runtime = substream->runtime;
238
239 if (!(pipe = kmalloc(sizeof(struct audiopipe), GFP_KERNEL)))
240 return -ENOMEM;
241 memset(pipe, 0, sizeof(struct audiopipe));
242 pipe->index = -1; /* Not configured yet */
243
244 /* Set up hw capabilities and contraints */
245 memcpy(&pipe->hw, &pcm_hardware_skel, sizeof(struct snd_pcm_hardware));
246 DE_HWP(("max_channels=%d\n", max_channels));
247 pipe->constr.list = channels_list;
248 pipe->constr.mask = 0;
249 for (i = 0; channels_list[i] <= max_channels; i++);
250 pipe->constr.count = i;
251 if (pipe->hw.channels_max > max_channels)
252 pipe->hw.channels_max = max_channels;
253 if (chip->digital_mode == DIGITAL_MODE_ADAT) {
254 pipe->hw.rate_max = 48000;
255 pipe->hw.rates &= SNDRV_PCM_RATE_8000_48000;
256 }
257
258 runtime->hw = pipe->hw;
259 runtime->private_data = pipe;
260 runtime->private_free = audiopipe_free;
261 snd_pcm_set_sync(substream);
262
263 /* Only mono and any even number of channels are allowed */
264 if ((err = snd_pcm_hw_constraint_list(runtime, 0,
265 SNDRV_PCM_HW_PARAM_CHANNELS,
266 &pipe->constr)) < 0)
267 return err;
268
269 /* All periods should have the same size */
270 if ((err = snd_pcm_hw_constraint_integer(runtime,
271 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
272 return err;
273
274 /* The hw accesses memory in chunks 32 frames long and they should be
275 32-bytes-aligned. It's not a requirement, but it seems that IRQs are
276 generated with a resolution of 32 frames. Thus we need the following */
277 if ((err = snd_pcm_hw_constraint_step(runtime, 0,
278 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
279 32)) < 0)
280 return err;
281 if ((err = snd_pcm_hw_constraint_step(runtime, 0,
282 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
283 32)) < 0)
284 return err;
285
286 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
287 SNDRV_PCM_HW_PARAM_RATE,
288 hw_rule_sample_rate, chip,
289 SNDRV_PCM_HW_PARAM_RATE, -1)) < 0)
290 return err;
291
292 /* Finally allocate a page for the scatter-gather list */
293 if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
294 snd_dma_pci_data(chip->pci),
295 PAGE_SIZE, &pipe->sgpage)) < 0) {
296 DE_HWP(("s-g list allocation failed\n"));
297 return err;
298 }
299
300 return 0;
301}
302
303
304
305static int pcm_analog_in_open(struct snd_pcm_substream *substream)
306{
307 struct echoaudio *chip = snd_pcm_substream_chip(substream);
308 int err;
309
310 DE_ACT(("pcm_analog_in_open\n"));
311 if ((err = pcm_open(substream, num_analog_busses_in(chip) -
312 substream->number)) < 0)
313 return err;
314 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
315 SNDRV_PCM_HW_PARAM_CHANNELS,
316 hw_rule_capture_channels_by_format, NULL,
317 SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
318 return err;
319 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
320 SNDRV_PCM_HW_PARAM_FORMAT,
321 hw_rule_capture_format_by_channels, NULL,
322 SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
323 return err;
324 atomic_inc(&chip->opencount);
325 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
326 chip->can_set_rate=0;
327 DE_HWP(("pcm_analog_in_open cs=%d oc=%d r=%d\n",
328 chip->can_set_rate, atomic_read(&chip->opencount),
329 chip->sample_rate));
330 return 0;
331}
332
333
334
335static int pcm_analog_out_open(struct snd_pcm_substream *substream)
336{
337 struct echoaudio *chip = snd_pcm_substream_chip(substream);
338 int max_channels, err;
339
340#ifdef ECHOCARD_HAS_VMIXER
341 max_channels = num_pipes_out(chip);
342#else
343 max_channels = num_analog_busses_out(chip);
344#endif
345 DE_ACT(("pcm_analog_out_open\n"));
346 if ((err = pcm_open(substream, max_channels - substream->number)) < 0)
347 return err;
348 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
349 SNDRV_PCM_HW_PARAM_CHANNELS,
350 hw_rule_playback_channels_by_format,
351 NULL,
352 SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
353 return err;
354 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
355 SNDRV_PCM_HW_PARAM_FORMAT,
356 hw_rule_playback_format_by_channels,
357 NULL,
358 SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
359 return err;
360 atomic_inc(&chip->opencount);
361 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
362 chip->can_set_rate=0;
363 DE_HWP(("pcm_analog_out_open cs=%d oc=%d r=%d\n",
364 chip->can_set_rate, atomic_read(&chip->opencount),
365 chip->sample_rate));
366 return 0;
367}
368
369
370
371#ifdef ECHOCARD_HAS_DIGITAL_IO
372
373static int pcm_digital_in_open(struct snd_pcm_substream *substream)
374{
375 struct echoaudio *chip = snd_pcm_substream_chip(substream);
376 int err, max_channels;
377
378 DE_ACT(("pcm_digital_in_open\n"));
379 max_channels = num_digital_busses_in(chip) - substream->number;
380 down(&chip->mode_mutex);
381 if (chip->digital_mode == DIGITAL_MODE_ADAT)
382 err = pcm_open(substream, max_channels);
383 else /* If the card has ADAT, subtract the 6 channels
384 * that S/PDIF doesn't have
385 */
386 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
387
388 if (err < 0)
389 goto din_exit;
390
391 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
392 SNDRV_PCM_HW_PARAM_CHANNELS,
393 hw_rule_capture_channels_by_format, NULL,
394 SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
395 goto din_exit;
396 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
397 SNDRV_PCM_HW_PARAM_FORMAT,
398 hw_rule_capture_format_by_channels, NULL,
399 SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
400 goto din_exit;
401
402 atomic_inc(&chip->opencount);
403 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
404 chip->can_set_rate=0;
405
406din_exit:
407 up(&chip->mode_mutex);
408 return err;
409}
410
411
412
413#ifndef ECHOCARD_HAS_VMIXER /* See the note in snd_echo_new_pcm() */
414
415static int pcm_digital_out_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_out_open\n"));
421 max_channels = num_digital_busses_out(chip) - substream->number;
422 down(&chip->mode_mutex);
423 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 dout_exit;
432
433 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
434 SNDRV_PCM_HW_PARAM_CHANNELS,
435 hw_rule_playback_channels_by_format,
436 NULL, SNDRV_PCM_HW_PARAM_FORMAT,
437 -1)) < 0)
438 goto dout_exit;
439 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
440 SNDRV_PCM_HW_PARAM_FORMAT,
441 hw_rule_playback_format_by_channels,
442 NULL, SNDRV_PCM_HW_PARAM_CHANNELS,
443 -1)) < 0)
444 goto dout_exit;
445 atomic_inc(&chip->opencount);
446 if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
447 chip->can_set_rate=0;
448dout_exit:
449 up(&chip->mode_mutex);
450 return err;
451}
452
453#endif /* !ECHOCARD_HAS_VMIXER */
454
455#endif /* ECHOCARD_HAS_DIGITAL_IO */
456
457
458
459static int pcm_close(struct snd_pcm_substream *substream)
460{
461 struct echoaudio *chip = snd_pcm_substream_chip(substream);
462 int oc;
463
464 /* Nothing to do here. Audio is already off and pipe will be
465 * freed by its callback
466 */
467 DE_ACT(("pcm_close\n"));
468
469 atomic_dec(&chip->opencount);
470 oc = atomic_read(&chip->opencount);
471 DE_ACT(("pcm_close oc=%d cs=%d rs=%d\n", oc,
472 chip->can_set_rate, chip->rate_set));
473 if (oc < 2)
474 chip->can_set_rate = 1;
475 if (oc == 0)
476 chip->rate_set = 0;
477 DE_ACT(("pcm_close2 oc=%d cs=%d rs=%d\n", oc,
478 chip->can_set_rate,chip->rate_set));
479
480 return 0;
481}
482
483
484
485/* Channel allocation and scatter-gather list setup */
486static int init_engine(struct snd_pcm_substream *substream,
487 struct snd_pcm_hw_params *hw_params,
488 int pipe_index, int interleave)
489{
490 struct echoaudio *chip;
491 int err, per, rest, page, edge, offs;
492 struct snd_sg_buf *sgbuf;
493 struct audiopipe *pipe;
494
495 chip = snd_pcm_substream_chip(substream);
496 pipe = (struct audiopipe *) substream->runtime->private_data;
497
498 /* Sets up che hardware. If it's already initialized, reset and
499 * redo with the new parameters
500 */
501 spin_lock_irq(&chip->lock);
502 if (pipe->index >= 0) {
503 DE_HWP(("hwp_ie free(%d)\n", pipe->index));
504 err = free_pipes(chip, pipe);
505 snd_assert(!err);
506 chip->substream[pipe->index] = NULL;
507 }
508
509 err = allocate_pipes(chip, pipe, pipe_index, interleave);
510 if (err < 0) {
511 spin_unlock_irq(&chip->lock);
512 DE_ACT((KERN_NOTICE "allocate_pipes(%d) err=%d\n",
513 pipe_index, err));
514 return err;
515 }
516 spin_unlock_irq(&chip->lock);
517 DE_ACT((KERN_NOTICE "allocate_pipes()=%d\n", pipe_index));
518
519 DE_HWP(("pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n",
520 params_buffer_bytes(hw_params), params_periods(hw_params),
521 params_period_bytes(hw_params)));
522 err = snd_pcm_lib_malloc_pages(substream,
523 params_buffer_bytes(hw_params));
524 if (err < 0) {
525 snd_printk(KERN_ERR "malloc_pages err=%d\n", err);
526 spin_lock_irq(&chip->lock);
527 free_pipes(chip, pipe);
528 spin_unlock_irq(&chip->lock);
529 pipe->index = -1;
530 return err;
531 }
532
533 sgbuf = snd_pcm_substream_sgbuf(substream);
534
535 DE_HWP(("pcm_hw_params table size=%d pages=%d\n",
536 sgbuf->size, sgbuf->pages));
537 sglist_init(chip, pipe);
538 edge = PAGE_SIZE;
539 for (offs = page = per = 0; offs < params_buffer_bytes(hw_params);
540 per++) {
541 rest = params_period_bytes(hw_params);
542 if (offs + rest > params_buffer_bytes(hw_params))
543 rest = params_buffer_bytes(hw_params) - offs;
544 while (rest) {
545 if (rest <= edge - offs) {
546 sglist_add_mapping(chip, pipe,
547 snd_sgbuf_get_addr(sgbuf, offs),
548 rest);
549 sglist_add_irq(chip, pipe);
550 offs += rest;
551 rest = 0;
552 } else {
553 sglist_add_mapping(chip, pipe,
554 snd_sgbuf_get_addr(sgbuf, offs),
555 edge - offs);
556 rest -= edge - offs;
557 offs = edge;
558 }
559 if (offs == edge) {
560 edge += PAGE_SIZE;
561 page++;
562 }
563 }
564 }
565
566 /* Close the ring buffer */
567 sglist_wrap(chip, pipe);
568
569 /* This stuff is used by the irq handler, so it must be
570 * initialized before chip->substream
571 */
572 chip->last_period[pipe_index] = 0;
573 pipe->last_counter = 0;
574 pipe->position = 0;
575 smp_wmb();
576 chip->substream[pipe_index] = substream;
577 chip->rate_set = 1;
578 spin_lock_irq(&chip->lock);
579 set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den);
580 spin_unlock_irq(&chip->lock);
581 DE_HWP(("pcm_hw_params ok\n"));
582 return 0;
583}
584
585
586
587static int pcm_analog_in_hw_params(struct snd_pcm_substream *substream,
588 struct snd_pcm_hw_params *hw_params)
589{
590 struct echoaudio *chip = snd_pcm_substream_chip(substream);
591
592 return init_engine(substream, hw_params, px_analog_in(chip) +
593 substream->number, params_channels(hw_params));
594}
595
596
597
598static int pcm_analog_out_hw_params(struct snd_pcm_substream *substream,
599 struct snd_pcm_hw_params *hw_params)
600{
601 return init_engine(substream, hw_params, substream->number,
602 params_channels(hw_params));
603}
604
605
606
607#ifdef ECHOCARD_HAS_DIGITAL_IO
608
609static int pcm_digital_in_hw_params(struct snd_pcm_substream *substream,
610 struct snd_pcm_hw_params *hw_params)
611{
612 struct echoaudio *chip = snd_pcm_substream_chip(substream);
613
614 return init_engine(substream, hw_params, px_digital_in(chip) +
615 substream->number, params_channels(hw_params));
616}
617
618
619
620#ifndef ECHOCARD_HAS_VMIXER /* See the note in snd_echo_new_pcm() */
621static int pcm_digital_out_hw_params(struct snd_pcm_substream *substream,
622 struct snd_pcm_hw_params *hw_params)
623{
624 struct echoaudio *chip = snd_pcm_substream_chip(substream);
625
626 return init_engine(substream, hw_params, px_digital_out(chip) +
627 substream->number, params_channels(hw_params));
628}
629#endif /* !ECHOCARD_HAS_VMIXER */
630
631#endif /* ECHOCARD_HAS_DIGITAL_IO */
632
633
634
635static int pcm_hw_free(struct snd_pcm_substream *substream)
636{
637 struct echoaudio *chip;
638 struct audiopipe *pipe;
639
640 chip = snd_pcm_substream_chip(substream);
641 pipe = (struct audiopipe *) substream->runtime->private_data;
642
643 spin_lock_irq(&chip->lock);
644 if (pipe->index >= 0) {
645 DE_HWP(("pcm_hw_free(%d)\n", pipe->index));
646 free_pipes(chip, pipe);
647 chip->substream[pipe->index] = NULL;
648 pipe->index = -1;
649 }
650 spin_unlock_irq(&chip->lock);
651
652 DE_HWP(("pcm_hw_freed\n"));
653 snd_pcm_lib_free_pages(substream);
654 return 0;
655}
656
657
658
659static int pcm_prepare(struct snd_pcm_substream *substream)
660{
661 struct echoaudio *chip = snd_pcm_substream_chip(substream);
662 struct snd_pcm_runtime *runtime = substream->runtime;
663 struct audioformat format;
664 int pipe_index = ((struct audiopipe *)runtime->private_data)->index;
665
666 DE_HWP(("Prepare rate=%d format=%d channels=%d\n",
667 runtime->rate, runtime->format, runtime->channels));
668 format.interleave = runtime->channels;
669 format.data_are_bigendian = 0;
670 format.mono_to_stereo = 0;
671 switch (runtime->format) {
672 case SNDRV_PCM_FORMAT_U8:
673 format.bits_per_sample = 8;
674 break;
675 case SNDRV_PCM_FORMAT_S16_LE:
676 format.bits_per_sample = 16;
677 break;
678 case SNDRV_PCM_FORMAT_S24_3LE:
679 format.bits_per_sample = 24;
680 break;
681 case SNDRV_PCM_FORMAT_S32_BE:
682 format.data_are_bigendian = 1;
683 case SNDRV_PCM_FORMAT_S32_LE:
684 format.bits_per_sample = 32;
685 break;
686 default:
687 DE_HWP(("Prepare error: unsupported format %d\n",
688 runtime->format));
689 return -EINVAL;
690 }
691
692 snd_assert(pipe_index < px_num(chip), return -EINVAL);
693 snd_assert(is_pipe_allocated(chip, pipe_index), return -EINVAL);
694 set_audio_format(chip, pipe_index, &format);
695 return 0;
696}
697
698
699
700static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
701{
702 struct echoaudio *chip = snd_pcm_substream_chip(substream);
703 struct snd_pcm_runtime *runtime = substream->runtime;
704 struct audiopipe *pipe = runtime->private_data;
705 int i, err;
706 u32 channelmask = 0;
707 struct list_head *pos;
708 struct snd_pcm_substream *s;
709
710 snd_pcm_group_for_each(pos, substream) {
711 s = snd_pcm_group_substream_entry(pos);
712 for (i = 0; i < DSP_MAXPIPES; i++) {
713 if (s == chip->substream[i]) {
714 channelmask |= 1 << i;
715 snd_pcm_trigger_done(s, substream);
716 }
717 }
718 }
719
720 spin_lock(&chip->lock);
721 switch (cmd) {
722 case SNDRV_PCM_TRIGGER_START:
723 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
724 DE_ACT(("pcm_trigger start\n"));
725 for (i = 0; i < DSP_MAXPIPES; i++) {
726 if (channelmask & (1 << i)) {
727 pipe = chip->substream[i]->runtime->private_data;
728 switch (pipe->state) {
729 case PIPE_STATE_STOPPED:
730 chip->last_period[i] = 0;
731 pipe->last_counter = 0;
732 pipe->position = 0;
733 *pipe->dma_counter = 0;
734 case PIPE_STATE_PAUSED:
735 pipe->state = PIPE_STATE_STARTED;
736 break;
737 case PIPE_STATE_STARTED:
738 break;
739 }
740 }
741 }
742 err = start_transport(chip, channelmask,
743 chip->pipe_cyclic_mask);
744 break;
745 case SNDRV_PCM_TRIGGER_STOP:
746 DE_ACT(("pcm_trigger stop\n"));
747 for (i = 0; i < DSP_MAXPIPES; i++) {
748 if (channelmask & (1 << i)) {
749 pipe = chip->substream[i]->runtime->private_data;
750 pipe->state = PIPE_STATE_STOPPED;
751 }
752 }
753 err = stop_transport(chip, channelmask);
754 break;
755 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
756 DE_ACT(("pcm_trigger pause\n"));
757 for (i = 0; i < DSP_MAXPIPES; i++) {
758 if (channelmask & (1 << i)) {
759 pipe = chip->substream[i]->runtime->private_data;
760 pipe->state = PIPE_STATE_PAUSED;
761 }
762 }
763 err = pause_transport(chip, channelmask);
764 break;
765 default:
766 err = -EINVAL;
767 }
768 spin_unlock(&chip->lock);
769 return err;
770}
771
772
773
774static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
775{
776 struct snd_pcm_runtime *runtime = substream->runtime;
777 struct audiopipe *pipe = runtime->private_data;
778 size_t cnt, bufsize, pos;
779
780 cnt = le32_to_cpu(*pipe->dma_counter);
781 pipe->position += cnt - pipe->last_counter;
782 pipe->last_counter = cnt;
783 bufsize = substream->runtime->buffer_size;
784 pos = bytes_to_frames(substream->runtime, pipe->position);
785
786 while (pos >= bufsize) {
787 pipe->position -= frames_to_bytes(substream->runtime, bufsize);
788 pos -= bufsize;
789 }
790 return pos;
791}
792
793
794
795/* pcm *_ops structures */
796static struct snd_pcm_ops analog_playback_ops = {
797 .open = pcm_analog_out_open,
798 .close = pcm_close,
799 .ioctl = snd_pcm_lib_ioctl,
800 .hw_params = pcm_analog_out_hw_params,
801 .hw_free = pcm_hw_free,
802 .prepare = pcm_prepare,
803 .trigger = pcm_trigger,
804 .pointer = pcm_pointer,
805 .page = snd_pcm_sgbuf_ops_page,
806};
807static struct snd_pcm_ops analog_capture_ops = {
808 .open = pcm_analog_in_open,
809 .close = pcm_close,
810 .ioctl = snd_pcm_lib_ioctl,
811 .hw_params = pcm_analog_in_hw_params,
812 .hw_free = pcm_hw_free,
813 .prepare = pcm_prepare,
814 .trigger = pcm_trigger,
815 .pointer = pcm_pointer,
816 .page = snd_pcm_sgbuf_ops_page,
817};
818#ifdef ECHOCARD_HAS_DIGITAL_IO
819#ifndef ECHOCARD_HAS_VMIXER
820static struct snd_pcm_ops digital_playback_ops = {
821 .open = pcm_digital_out_open,
822 .close = pcm_close,
823 .ioctl = snd_pcm_lib_ioctl,
824 .hw_params = pcm_digital_out_hw_params,
825 .hw_free = pcm_hw_free,
826 .prepare = pcm_prepare,
827 .trigger = pcm_trigger,
828 .pointer = pcm_pointer,
829 .page = snd_pcm_sgbuf_ops_page,
830};
831#endif /* !ECHOCARD_HAS_VMIXER */
832static struct snd_pcm_ops digital_capture_ops = {
833 .open = pcm_digital_in_open,
834 .close = pcm_close,
835 .ioctl = snd_pcm_lib_ioctl,
836 .hw_params = pcm_digital_in_hw_params,
837 .hw_free = pcm_hw_free,
838 .prepare = pcm_prepare,
839 .trigger = pcm_trigger,
840 .pointer = pcm_pointer,
841 .page = snd_pcm_sgbuf_ops_page,
842};
843#endif /* ECHOCARD_HAS_DIGITAL_IO */
844
845
846
847/* Preallocate memory only for the first substream because it's the most
848 * used one
849 */
850static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
851{
852 struct snd_pcm_substream *ss;
853 int stream, err;
854
855 for (stream = 0; stream < 2; stream++)
856 for (ss = pcm->streams[stream].substream; ss; ss = ss->next) {
857 err = snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
858 dev,
859 ss->number ? 0 : 128<<10,
860 256<<10);
861 if (err < 0)
862 return err;
863 }
864 return 0;
865}
866
867
868
869/*<--snd_echo_probe() */
870static int __devinit snd_echo_new_pcm(struct echoaudio *chip)
871{
872 struct snd_pcm *pcm;
873 int err;
874
875#ifdef ECHOCARD_HAS_VMIXER
876 /* This card has a Vmixer, that is there is no direct mapping from PCM
877 streams to physical outputs. The user can mix the streams as he wishes
878 via control interface and it's possible to send any stream to any
879 output, thus it makes no sense to keep analog and digital outputs
880 separated */
881
882 /* PCM#0 Virtual outputs and analog inputs */
883 if ((err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
884 num_analog_busses_in(chip), &pcm)) < 0)
885 return err;
886 pcm->private_data = chip;
887 chip->analog_pcm = pcm;
888 strcpy(pcm->name, chip->card->shortname);
889 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
890 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
891 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
892 return err;
893 DE_INIT(("Analog PCM ok\n"));
894
895#ifdef ECHOCARD_HAS_DIGITAL_IO
896 /* PCM#1 Digital inputs, no outputs */
897 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
898 num_digital_busses_in(chip), &pcm)) < 0)
899 return err;
900 pcm->private_data = chip;
901 chip->digital_pcm = pcm;
902 strcpy(pcm->name, chip->card->shortname);
903 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
904 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
905 return err;
906 DE_INIT(("Digital PCM ok\n"));
907#endif /* ECHOCARD_HAS_DIGITAL_IO */
908
909#else /* ECHOCARD_HAS_VMIXER */
910
911 /* The card can manage substreams formed by analog and digital channels
912 at the same time, but I prefer to keep analog and digital channels
913 separated, because that mixed thing is confusing and useless. So we
914 register two PCM devices: */
915
916 /* PCM#0 Analog i/o */
917 if ((err = snd_pcm_new(chip->card, "Analog PCM", 0,
918 num_analog_busses_out(chip),
919 num_analog_busses_in(chip), &pcm)) < 0)
920 return err;
921 pcm->private_data = chip;
922 chip->analog_pcm = pcm;
923 strcpy(pcm->name, chip->card->shortname);
924 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
925 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
926 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
927 return err;
928 DE_INIT(("Analog PCM ok\n"));
929
930#ifdef ECHOCARD_HAS_DIGITAL_IO
931 /* PCM#1 Digital i/o */
932 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1,
933 num_digital_busses_out(chip),
934 num_digital_busses_in(chip), &pcm)) < 0)
935 return err;
936 pcm->private_data = chip;
937 chip->digital_pcm = pcm;
938 strcpy(pcm->name, chip->card->shortname);
939 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
940 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
941 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
942 return err;
943 DE_INIT(("Digital PCM ok\n"));
944#endif /* ECHOCARD_HAS_DIGITAL_IO */
945
946#endif /* ECHOCARD_HAS_VMIXER */
947
948 return 0;
949}
950
951
952
953
954/******************************************************************************
955 Control interface
956******************************************************************************/
957
958/******************* PCM output volume *******************/
959static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
960 struct snd_ctl_elem_info *uinfo)
961{
962 struct echoaudio *chip;
963
964 chip = snd_kcontrol_chip(kcontrol);
965 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
966 uinfo->count = num_busses_out(chip);
967 uinfo->value.integer.min = ECHOGAIN_MINOUT;
968 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
969 return 0;
970}
971
972static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
973 struct snd_ctl_elem_value *ucontrol)
974{
975 struct echoaudio *chip;
976 int c;
977
978 chip = snd_kcontrol_chip(kcontrol);
979 for (c = 0; c < num_busses_out(chip); c++)
980 ucontrol->value.integer.value[c] = chip->output_gain[c];
981 return 0;
982}
983
984static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
985 struct snd_ctl_elem_value *ucontrol)
986{
987 struct echoaudio *chip;
988 int c, changed, gain;
989
990 changed = 0;
991 chip = snd_kcontrol_chip(kcontrol);
992 spin_lock_irq(&chip->lock);
993 for (c = 0; c < num_busses_out(chip); c++) {
994 gain = ucontrol->value.integer.value[c];
995 /* Ignore out of range values */
996 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
997 continue;
998 if (chip->output_gain[c] != gain) {
999 set_output_gain(chip, c, gain);
1000 changed = 1;
1001 }
1002 }
1003 if (changed)
1004 update_output_line_level(chip);
1005 spin_unlock_irq(&chip->lock);
1006 return changed;
1007}
1008
1009#ifdef ECHOCARD_HAS_VMIXER
1010/* On Vmixer cards this one controls the line-out volume */
1011static struct snd_kcontrol_new snd_echo_line_output_gain __devinitdata = {
1012 .name = "Line Playback Volume",
1013 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1014 .info = snd_echo_output_gain_info,
1015 .get = snd_echo_output_gain_get,
1016 .put = snd_echo_output_gain_put,
1017};
1018#else
1019static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
1020 .name = "PCM Playback Volume",
1021 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1022 .info = snd_echo_output_gain_info,
1023 .get = snd_echo_output_gain_get,
1024 .put = snd_echo_output_gain_put,
1025};
1026#endif
1027
1028
1029
1030#ifdef ECHOCARD_HAS_INPUT_GAIN
1031
1032/******************* Analog input volume *******************/
1033static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1034 struct snd_ctl_elem_info *uinfo)
1035{
1036 struct echoaudio *chip;
1037
1038 chip = snd_kcontrol_chip(kcontrol);
1039 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1040 uinfo->count = num_analog_busses_in(chip);
1041 uinfo->value.integer.min = ECHOGAIN_MININP;
1042 uinfo->value.integer.max = ECHOGAIN_MAXINP;
1043 return 0;
1044}
1045
1046static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1047 struct snd_ctl_elem_value *ucontrol)
1048{
1049 struct echoaudio *chip;
1050 int c;
1051
1052 chip = snd_kcontrol_chip(kcontrol);
1053 for (c = 0; c < num_analog_busses_in(chip); c++)
1054 ucontrol->value.integer.value[c] = chip->input_gain[c];
1055 return 0;
1056}
1057
1058static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1059 struct snd_ctl_elem_value *ucontrol)
1060{
1061 struct echoaudio *chip;
1062 int c, gain, changed;
1063
1064 changed = 0;
1065 chip = snd_kcontrol_chip(kcontrol);
1066 spin_lock_irq(&chip->lock);
1067 for (c = 0; c < num_analog_busses_in(chip); c++) {
1068 gain = ucontrol->value.integer.value[c];
1069 /* Ignore out of range values */
1070 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1071 continue;
1072 if (chip->input_gain[c] != gain) {
1073 set_input_gain(chip, c, gain);
1074 changed = 1;
1075 }
1076 }
1077 if (changed)
1078 update_input_line_level(chip);
1079 spin_unlock_irq(&chip->lock);
1080 return changed;
1081}
1082
1083static struct snd_kcontrol_new snd_echo_line_input_gain __devinitdata = {
1084 .name = "Line Capture Volume",
1085 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1086 .info = snd_echo_input_gain_info,
1087 .get = snd_echo_input_gain_get,
1088 .put = snd_echo_input_gain_put,
1089};
1090
1091#endif /* ECHOCARD_HAS_INPUT_GAIN */
1092
1093
1094
1095#ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1096
1097/************ Analog output nominal level (+4dBu / -10dBV) ***************/
1098static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1099 struct snd_ctl_elem_info *uinfo)
1100{
1101 struct echoaudio *chip;
1102
1103 chip = snd_kcontrol_chip(kcontrol);
1104 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1105 uinfo->count = num_analog_busses_out(chip);
1106 uinfo->value.integer.min = 0;
1107 uinfo->value.integer.max = 1;
1108 return 0;
1109}
1110
1111static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1112 struct snd_ctl_elem_value *ucontrol)
1113{
1114 struct echoaudio *chip;
1115 int c;
1116
1117 chip = snd_kcontrol_chip(kcontrol);
1118 for (c = 0; c < num_analog_busses_out(chip); c++)
1119 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1120 return 0;
1121}
1122
1123static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1124 struct snd_ctl_elem_value *ucontrol)
1125{
1126 struct echoaudio *chip;
1127 int c, changed;
1128
1129 changed = 0;
1130 chip = snd_kcontrol_chip(kcontrol);
1131 spin_lock_irq(&chip->lock);
1132 for (c = 0; c < num_analog_busses_out(chip); c++) {
1133 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1134 set_nominal_level(chip, c,
1135 ucontrol->value.integer.value[c]);
1136 changed = 1;
1137 }
1138 }
1139 if (changed)
1140 update_output_line_level(chip);
1141 spin_unlock_irq(&chip->lock);
1142 return changed;
1143}
1144
1145static struct snd_kcontrol_new snd_echo_output_nominal_level __devinitdata = {
1146 .name = "Line Playback Switch (-10dBV)",
1147 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1148 .info = snd_echo_output_nominal_info,
1149 .get = snd_echo_output_nominal_get,
1150 .put = snd_echo_output_nominal_put,
1151};
1152
1153#endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1154
1155
1156
1157#ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1158
1159/*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1160static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1161 struct snd_ctl_elem_info *uinfo)
1162{
1163 struct echoaudio *chip;
1164
1165 chip = snd_kcontrol_chip(kcontrol);
1166 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1167 uinfo->count = num_analog_busses_in(chip);
1168 uinfo->value.integer.min = 0;
1169 uinfo->value.integer.max = 1;
1170 return 0;
1171}
1172
1173static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1174 struct snd_ctl_elem_value *ucontrol)
1175{
1176 struct echoaudio *chip;
1177 int c;
1178
1179 chip = snd_kcontrol_chip(kcontrol);
1180 for (c = 0; c < num_analog_busses_in(chip); c++)
1181 ucontrol->value.integer.value[c] =
1182 chip->nominal_level[bx_analog_in(chip) + c];
1183 return 0;
1184}
1185
1186static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1187 struct snd_ctl_elem_value *ucontrol)
1188{
1189 struct echoaudio *chip;
1190 int c, changed;
1191
1192 changed = 0;
1193 chip = snd_kcontrol_chip(kcontrol);
1194 spin_lock_irq(&chip->lock);
1195 for (c = 0; c < num_analog_busses_in(chip); c++) {
1196 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1197 ucontrol->value.integer.value[c]) {
1198 set_nominal_level(chip, bx_analog_in(chip) + c,
1199 ucontrol->value.integer.value[c]);
1200 changed = 1;
1201 }
1202 }
1203 if (changed)
1204 update_output_line_level(chip); /* "Output" is not a mistake
1205 * here.
1206 */
1207 spin_unlock_irq(&chip->lock);
1208 return changed;
1209}
1210
1211static struct snd_kcontrol_new snd_echo_intput_nominal_level __devinitdata = {
1212 .name = "Line Capture Switch (-10dBV)",
1213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1214 .info = snd_echo_input_nominal_info,
1215 .get = snd_echo_input_nominal_get,
1216 .put = snd_echo_input_nominal_put,
1217};
1218
1219#endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1220
1221
1222
1223#ifdef ECHOCARD_HAS_MONITOR
1224
1225/******************* Monitor mixer *******************/
1226static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1227 struct snd_ctl_elem_info *uinfo)
1228{
1229 struct echoaudio *chip;
1230
1231 chip = snd_kcontrol_chip(kcontrol);
1232 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1233 uinfo->count = 1;
1234 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1235 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1236 uinfo->dimen.d[0] = num_busses_out(chip);
1237 uinfo->dimen.d[1] = num_busses_in(chip);
1238 return 0;
1239}
1240
1241static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1242 struct snd_ctl_elem_value *ucontrol)
1243{
1244 struct echoaudio *chip;
1245
1246 chip = snd_kcontrol_chip(kcontrol);
1247 ucontrol->value.integer.value[0] =
1248 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)]
1249 [ucontrol->id.index % num_busses_in(chip)];
1250 return 0;
1251}
1252
1253static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1254 struct snd_ctl_elem_value *ucontrol)
1255{
1256 struct echoaudio *chip;
1257 int changed, gain;
1258 short out, in;
1259
1260 changed = 0;
1261 chip = snd_kcontrol_chip(kcontrol);
1262 out = ucontrol->id.index / num_busses_in(chip);
1263 in = ucontrol->id.index % num_busses_in(chip);
1264 gain = ucontrol->value.integer.value[0];
1265 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1266 return -EINVAL;
1267 if (chip->monitor_gain[out][in] != gain) {
1268 spin_lock_irq(&chip->lock);
1269 set_monitor_gain(chip, out, in, gain);
1270 update_output_line_level(chip);
1271 spin_unlock_irq(&chip->lock);
1272 changed = 1;
1273 }
1274 return changed;
1275}
1276
1277static struct snd_kcontrol_new snd_echo_monitor_mixer __devinitdata = {
1278 .name = "Monitor Mixer Volume",
1279 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1280 .info = snd_echo_mixer_info,
1281 .get = snd_echo_mixer_get,
1282 .put = snd_echo_mixer_put,
1283};
1284
1285#endif /* ECHOCARD_HAS_MONITOR */
1286
1287
1288
1289#ifdef ECHOCARD_HAS_VMIXER
1290
1291/******************* Vmixer *******************/
1292static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1293 struct snd_ctl_elem_info *uinfo)
1294{
1295 struct echoaudio *chip;
1296
1297 chip = snd_kcontrol_chip(kcontrol);
1298 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1299 uinfo->count = 1;
1300 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1301 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1302 uinfo->dimen.d[0] = num_busses_out(chip);
1303 uinfo->dimen.d[1] = num_pipes_out(chip);
1304 return 0;
1305}
1306
1307static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1308 struct snd_ctl_elem_value *ucontrol)
1309{
1310 struct echoaudio *chip;
1311
1312 chip = snd_kcontrol_chip(kcontrol);
1313 ucontrol->value.integer.value[0] =
1314 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1315 [ucontrol->id.index % num_pipes_out(chip)];
1316 return 0;
1317}
1318
1319static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1320 struct snd_ctl_elem_value *ucontrol)
1321{
1322 struct echoaudio *chip;
1323 int gain, changed;
1324 short vch, out;
1325
1326 changed = 0;
1327 chip = snd_kcontrol_chip(kcontrol);
1328 out = ucontrol->id.index / num_pipes_out(chip);
1329 vch = ucontrol->id.index % num_pipes_out(chip);
1330 gain = ucontrol->value.integer.value[0];
1331 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1332 return -EINVAL;
1333 if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1334 spin_lock_irq(&chip->lock);
1335 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1336 update_vmixer_level(chip);
1337 spin_unlock_irq(&chip->lock);
1338 changed = 1;
1339 }
1340 return changed;
1341}
1342
1343static struct snd_kcontrol_new snd_echo_vmixer __devinitdata = {
1344 .name = "VMixer Volume",
1345 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1346 .info = snd_echo_vmixer_info,
1347 .get = snd_echo_vmixer_get,
1348 .put = snd_echo_vmixer_put,
1349};
1350
1351#endif /* ECHOCARD_HAS_VMIXER */
1352
1353
1354
1355#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1356
1357/******************* Digital mode switch *******************/
1358static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1359 struct snd_ctl_elem_info *uinfo)
1360{
1361 static char *names[4] = {
1362 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1363 "S/PDIF Cdrom"
1364 };
1365 struct echoaudio *chip;
1366
1367 chip = snd_kcontrol_chip(kcontrol);
1368 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1369 uinfo->value.enumerated.items = chip->num_digital_modes;
1370 uinfo->count = 1;
1371 if (uinfo->value.enumerated.item >= chip->num_digital_modes)
1372 uinfo->value.enumerated.item = chip->num_digital_modes - 1;
1373 strcpy(uinfo->value.enumerated.name, names[
1374 chip->digital_mode_list[uinfo->value.enumerated.item]]);
1375 return 0;
1376}
1377
1378static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1379 struct snd_ctl_elem_value *ucontrol)
1380{
1381 struct echoaudio *chip;
1382 int i, mode;
1383
1384 chip = snd_kcontrol_chip(kcontrol);
1385 mode = chip->digital_mode;
1386 for (i = chip->num_digital_modes - 1; i >= 0; i--)
1387 if (mode == chip->digital_mode_list[i]) {
1388 ucontrol->value.enumerated.item[0] = i;
1389 break;
1390 }
1391 return 0;
1392}
1393
1394static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1395 struct snd_ctl_elem_value *ucontrol)
1396{
1397 struct echoaudio *chip;
1398 int changed;
1399 unsigned short emode, dmode;
1400
1401 changed = 0;
1402 chip = snd_kcontrol_chip(kcontrol);
1403
1404 emode = ucontrol->value.enumerated.item[0];
1405 if (emode >= chip->num_digital_modes)
1406 return -EINVAL;
1407 dmode = chip->digital_mode_list[emode];
1408
1409 if (dmode != chip->digital_mode) {
1410 /* mode_mutex is required to make this operation atomic wrt
1411 pcm_digital_*_open() and set_input_clock() functions. */
1412 down(&chip->mode_mutex);
1413
1414 /* Do not allow the user to change the digital mode when a pcm
1415 device is open because it also changes the number of channels
1416 and the allowed sample rates */
1417 if (atomic_read(&chip->opencount)) {
1418 changed = -EAGAIN;
1419 } else {
1420 changed = set_digital_mode(chip, dmode);
1421 /* If we had to change the clock source, report it */
1422 if (changed > 0 && chip->clock_src_ctl) {
1423 snd_ctl_notify(chip->card,
1424 SNDRV_CTL_EVENT_MASK_VALUE,
1425 &chip->clock_src_ctl->id);
1426 DE_ACT(("SDM() =%d\n", changed));
1427 }
1428 if (changed >= 0)
1429 changed = 1; /* No errors */
1430 }
1431 up(&chip->mode_mutex);
1432 }
1433 return changed;
1434}
1435
1436static struct snd_kcontrol_new snd_echo_digital_mode_switch __devinitdata = {
1437 .name = "Digital mode Switch",
1438 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1439 .info = snd_echo_digital_mode_info,
1440 .get = snd_echo_digital_mode_get,
1441 .put = snd_echo_digital_mode_put,
1442};
1443
1444#endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1445
1446
1447
1448#ifdef ECHOCARD_HAS_DIGITAL_IO
1449
1450/******************* S/PDIF mode switch *******************/
1451static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1452 struct snd_ctl_elem_info *uinfo)
1453{
1454 static char *names[2] = {"Consumer", "Professional"};
1455
1456 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1457 uinfo->value.enumerated.items = 2;
1458 uinfo->count = 1;
1459 if (uinfo->value.enumerated.item)
1460 uinfo->value.enumerated.item = 1;
1461 strcpy(uinfo->value.enumerated.name,
1462 names[uinfo->value.enumerated.item]);
1463 return 0;
1464}
1465
1466static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1467 struct snd_ctl_elem_value *ucontrol)
1468{
1469 struct echoaudio *chip;
1470
1471 chip = snd_kcontrol_chip(kcontrol);
1472 ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1473 return 0;
1474}
1475
1476static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1477 struct snd_ctl_elem_value *ucontrol)
1478{
1479 struct echoaudio *chip;
1480 int mode;
1481
1482 chip = snd_kcontrol_chip(kcontrol);
1483 mode = !!ucontrol->value.enumerated.item[0];
1484 if (mode != chip->professional_spdif) {
1485 spin_lock_irq(&chip->lock);
1486 set_professional_spdif(chip, mode);
1487 spin_unlock_irq(&chip->lock);
1488 return 1;
1489 }
1490 return 0;
1491}
1492
1493static struct snd_kcontrol_new snd_echo_spdif_mode_switch __devinitdata = {
1494 .name = "S/PDIF mode Switch",
1495 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1496 .info = snd_echo_spdif_mode_info,
1497 .get = snd_echo_spdif_mode_get,
1498 .put = snd_echo_spdif_mode_put,
1499};
1500
1501#endif /* ECHOCARD_HAS_DIGITAL_IO */
1502
1503
1504
1505#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1506
1507/******************* Select input clock source *******************/
1508static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1509 struct snd_ctl_elem_info *uinfo)
1510{
1511 static char *names[8] = {
1512 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1513 "ESync96", "MTC"
1514 };
1515 struct echoaudio *chip;
1516
1517 chip = snd_kcontrol_chip(kcontrol);
1518 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1519 uinfo->value.enumerated.items = chip->num_clock_sources;
1520 uinfo->count = 1;
1521 if (uinfo->value.enumerated.item >= chip->num_clock_sources)
1522 uinfo->value.enumerated.item = chip->num_clock_sources - 1;
1523 strcpy(uinfo->value.enumerated.name, names[
1524 chip->clock_source_list[uinfo->value.enumerated.item]]);
1525 return 0;
1526}
1527
1528static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1529 struct snd_ctl_elem_value *ucontrol)
1530{
1531 struct echoaudio *chip;
1532 int i, clock;
1533
1534 chip = snd_kcontrol_chip(kcontrol);
1535 clock = chip->input_clock;
1536
1537 for (i = 0; i < chip->num_clock_sources; i++)
1538 if (clock == chip->clock_source_list[i])
1539 ucontrol->value.enumerated.item[0] = i;
1540
1541 return 0;
1542}
1543
1544static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1545 struct snd_ctl_elem_value *ucontrol)
1546{
1547 struct echoaudio *chip;
1548 int changed;
1549 unsigned int eclock, dclock;
1550
1551 changed = 0;
1552 chip = snd_kcontrol_chip(kcontrol);
1553 eclock = ucontrol->value.enumerated.item[0];
1554 if (eclock >= chip->input_clock_types)
1555 return -EINVAL;
1556 dclock = chip->clock_source_list[eclock];
1557 if (chip->input_clock != dclock) {
1558 down(&chip->mode_mutex);
1559 spin_lock_irq(&chip->lock);
1560 if ((changed = set_input_clock(chip, dclock)) == 0)
1561 changed = 1; /* no errors */
1562 spin_unlock_irq(&chip->lock);
1563 up(&chip->mode_mutex);
1564 }
1565
1566 if (changed < 0)
1567 DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed));
1568
1569 return changed;
1570}
1571
1572static struct snd_kcontrol_new snd_echo_clock_source_switch __devinitdata = {
1573 .name = "Sample Clock Source",
1574 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1575 .info = snd_echo_clock_source_info,
1576 .get = snd_echo_clock_source_get,
1577 .put = snd_echo_clock_source_put,
1578};
1579
1580#endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1581
1582
1583
1584#ifdef ECHOCARD_HAS_PHANTOM_POWER
1585
1586/******************* Phantom power switch *******************/
1587static int snd_echo_phantom_power_info(struct snd_kcontrol *kcontrol,
1588 struct snd_ctl_elem_info *uinfo)
1589{
1590 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1591 uinfo->count = 1;
1592 uinfo->value.integer.min = 0;
1593 uinfo->value.integer.max = 1;
1594 return 0;
1595}
1596
1597static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1598 struct snd_ctl_elem_value *ucontrol)
1599{
1600 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1601
1602 ucontrol->value.integer.value[0] = chip->phantom_power;
1603 return 0;
1604}
1605
1606static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1607 struct snd_ctl_elem_value *ucontrol)
1608{
1609 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1610 int power, changed = 0;
1611
1612 power = !!ucontrol->value.integer.value[0];
1613 if (chip->phantom_power != power) {
1614 spin_lock_irq(&chip->lock);
1615 changed = set_phantom_power(chip, power);
1616 spin_unlock_irq(&chip->lock);
1617 if (changed == 0)
1618 changed = 1; /* no errors */
1619 }
1620 return changed;
1621}
1622
1623static struct snd_kcontrol_new snd_echo_phantom_power_switch __devinitdata = {
1624 .name = "Phantom power Switch",
1625 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1626 .info = snd_echo_phantom_power_info,
1627 .get = snd_echo_phantom_power_get,
1628 .put = snd_echo_phantom_power_put,
1629};
1630
1631#endif /* ECHOCARD_HAS_PHANTOM_POWER */
1632
1633
1634
1635#ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1636
1637/******************* Digital input automute switch *******************/
1638static int snd_echo_automute_info(struct snd_kcontrol *kcontrol,
1639 struct snd_ctl_elem_info *uinfo)
1640{
1641 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1642 uinfo->count = 1;
1643 uinfo->value.integer.min = 0;
1644 uinfo->value.integer.max = 1;
1645 return 0;
1646}
1647
1648static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1649 struct snd_ctl_elem_value *ucontrol)
1650{
1651 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1652
1653 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1654 return 0;
1655}
1656
1657static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1658 struct snd_ctl_elem_value *ucontrol)
1659{
1660 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1661 int automute, changed = 0;
1662
1663 automute = !!ucontrol->value.integer.value[0];
1664 if (chip->digital_in_automute != automute) {
1665 spin_lock_irq(&chip->lock);
1666 changed = set_input_auto_mute(chip, automute);
1667 spin_unlock_irq(&chip->lock);
1668 if (changed == 0)
1669 changed = 1; /* no errors */
1670 }
1671 return changed;
1672}
1673
1674static struct snd_kcontrol_new snd_echo_automute_switch __devinitdata = {
1675 .name = "Digital Capture Switch (automute)",
1676 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1677 .info = snd_echo_automute_info,
1678 .get = snd_echo_automute_get,
1679 .put = snd_echo_automute_put,
1680};
1681
1682#endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1683
1684
1685
1686/******************* VU-meters switch *******************/
1687static int snd_echo_vumeters_switch_info(struct snd_kcontrol *kcontrol,
1688 struct snd_ctl_elem_info *uinfo)
1689{
1690 struct echoaudio *chip;
1691
1692 chip = snd_kcontrol_chip(kcontrol);
1693 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1694 uinfo->count = 1;
1695 uinfo->value.integer.min = 0;
1696 uinfo->value.integer.max = 1;
1697 return 0;
1698}
1699
1700static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1701 struct snd_ctl_elem_value *ucontrol)
1702{
1703 struct echoaudio *chip;
1704
1705 chip = snd_kcontrol_chip(kcontrol);
1706 spin_lock_irq(&chip->lock);
1707 set_meters_on(chip, ucontrol->value.integer.value[0]);
1708 spin_unlock_irq(&chip->lock);
1709 return 1;
1710}
1711
1712static struct snd_kcontrol_new snd_echo_vumeters_switch __devinitdata = {
1713 .name = "VU-meters Switch",
1714 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1715 .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1716 .info = snd_echo_vumeters_switch_info,
1717 .put = snd_echo_vumeters_switch_put,
1718};
1719
1720
1721
1722/***** Read VU-meters (input, output, analog and digital together) *****/
1723static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1724 struct snd_ctl_elem_info *uinfo)
1725{
1726 struct echoaudio *chip;
1727
1728 chip = snd_kcontrol_chip(kcontrol);
1729 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1730 uinfo->count = 96;
1731 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1732 uinfo->value.integer.max = 0;
1733#ifdef ECHOCARD_HAS_VMIXER
1734 uinfo->dimen.d[0] = 3; /* Out, In, Virt */
1735#else
1736 uinfo->dimen.d[0] = 2; /* Out, In */
1737#endif
1738 uinfo->dimen.d[1] = 16; /* 16 channels */
1739 uinfo->dimen.d[2] = 2; /* 0=level, 1=peak */
1740 return 0;
1741}
1742
1743static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1744 struct snd_ctl_elem_value *ucontrol)
1745{
1746 struct echoaudio *chip;
1747
1748 chip = snd_kcontrol_chip(kcontrol);
1749 get_audio_meters(chip, ucontrol->value.integer.value);
1750 return 0;
1751}
1752
1753static struct snd_kcontrol_new snd_echo_vumeters __devinitdata = {
1754 .name = "VU-meters",
1755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1756 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1757 .info = snd_echo_vumeters_info,
1758 .get = snd_echo_vumeters_get,
1759};
1760
1761
1762
1763/*** Channels info - it exports informations about the number of channels ***/
1764static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1765 struct snd_ctl_elem_info *uinfo)
1766{
1767 struct echoaudio *chip;
1768
1769 chip = snd_kcontrol_chip(kcontrol);
1770 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1771 uinfo->count = 6;
1772 uinfo->value.integer.min = 0;
1773 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1774 return 0;
1775}
1776
1777static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1778 struct snd_ctl_elem_value *ucontrol)
1779{
1780 struct echoaudio *chip;
1781 int detected, clocks, bit, src;
1782
1783 chip = snd_kcontrol_chip(kcontrol);
1784 ucontrol->value.integer.value[0] = num_busses_in(chip);
1785 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1786 ucontrol->value.integer.value[2] = num_busses_out(chip);
1787 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1788 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1789
1790 /* Compute the bitmask of the currently valid input clocks */
1791 detected = detect_input_clocks(chip);
1792 clocks = 0;
1793 src = chip->num_clock_sources - 1;
1794 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1795 if (detected & (1 << bit))
1796 for (; src >= 0; src--)
1797 if (bit == chip->clock_source_list[src]) {
1798 clocks |= 1 << src;
1799 break;
1800 }
1801 ucontrol->value.integer.value[5] = clocks;
1802
1803 return 0;
1804}
1805
1806static struct snd_kcontrol_new snd_echo_channels_info __devinitdata = {
1807 .name = "Channels info",
1808 .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1809 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1810 .info = snd_echo_channels_info_info,
1811 .get = snd_echo_channels_info_get,
1812};
1813
1814
1815
1816
1817/******************************************************************************
1818 IRQ Handler
1819******************************************************************************/
1820
1821static irqreturn_t snd_echo_interrupt(int irq, void *dev_id,
1822 struct pt_regs *regs)
1823{
1824 struct echoaudio *chip = dev_id;
1825 struct snd_pcm_substream *substream;
1826 int period, ss, st;
1827
1828 spin_lock(&chip->lock);
1829 st = service_irq(chip);
1830 if (st < 0) {
1831 spin_unlock(&chip->lock);
1832 return IRQ_NONE;
1833 }
1834 /* The hardware doesn't tell us which substream caused the irq,
1835 thus we have to check all running substreams. */
1836 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1837 if ((substream = chip->substream[ss])) {
1838 period = pcm_pointer(substream) /
1839 substream->runtime->period_size;
1840 if (period != chip->last_period[ss]) {
1841 chip->last_period[ss] = period;
1842 spin_unlock(&chip->lock);
1843 snd_pcm_period_elapsed(substream);
1844 spin_lock(&chip->lock);
1845 }
1846 }
1847 }
1848 spin_unlock(&chip->lock);
1849
1850#ifdef ECHOCARD_HAS_MIDI
1851 if (st > 0 && chip->midi_in) {
1852 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1853 DE_MID(("rawmidi_iread=%d\n", st));
1854 }
1855#endif
1856 return IRQ_HANDLED;
1857}
1858
1859
1860
1861
1862/******************************************************************************
1863 Module construction / destruction
1864******************************************************************************/
1865
1866static int snd_echo_free(struct echoaudio *chip)
1867{
1868 DE_INIT(("Stop DSP...\n"));
1869 if (chip->comm_page) {
1870 rest_in_peace(chip);
1871 snd_dma_free_pages(&chip->commpage_dma_buf);
1872 }
1873 DE_INIT(("Stopped.\n"));
1874
1875 if (chip->irq >= 0)
1876 free_irq(chip->irq, (void *)chip);
1877
1878 if (chip->dsp_registers)
1879 iounmap(chip->dsp_registers);
1880
1881 if (chip->iores)
1882 release_and_free_resource(chip->iores);
1883
1884 DE_INIT(("MMIO freed.\n"));
1885
1886 pci_disable_device(chip->pci);
1887
1888 /* release chip data */
1889 kfree(chip);
1890 DE_INIT(("Chip freed.\n"));
1891 return 0;
1892}
1893
1894
1895
1896static int snd_echo_dev_free(struct snd_device *device)
1897{
1898 struct echoaudio *chip = device->device_data;
1899
1900 DE_INIT(("snd_echo_dev_free()...\n"));
1901 return snd_echo_free(chip);
1902}
1903
1904
1905
1906/* <--snd_echo_probe() */
1907static __devinit int snd_echo_create(struct snd_card *card,
1908 struct pci_dev *pci,
1909 struct echoaudio **rchip)
1910{
1911 struct echoaudio *chip;
1912 int err;
1913 size_t sz;
1914 static struct snd_device_ops ops = {
1915 .dev_free = snd_echo_dev_free,
1916 };
1917
1918 *rchip = NULL;
1919
1920 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1921
1922 if ((err = pci_enable_device(pci)) < 0)
1923 return err;
1924 pci_set_master(pci);
1925
1926 /* allocate a chip-specific data */
1927 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1928 if (!chip) {
1929 pci_disable_device(pci);
1930 return -ENOMEM;
1931 }
1932 DE_INIT(("chip=%p\n", chip));
1933
1934 spin_lock_init(&chip->lock);
1935 chip->card = card;
1936 chip->pci = pci;
1937 chip->irq = -1;
1938
1939 /* PCI resource allocation */
1940 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1941 sz = pci_resource_len(pci, 0);
1942 if (sz > PAGE_SIZE)
1943 sz = PAGE_SIZE; /* We map only the required part */
1944
1945 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1946 ECHOCARD_NAME)) == NULL) {
1947 snd_echo_free(chip);
1948 snd_printk(KERN_ERR "cannot get memory region\n");
1949 return -EBUSY;
1950 }
1951 chip->dsp_registers = (volatile u32 __iomem *)
1952 ioremap_nocache(chip->dsp_registers_phys, sz);
1953
1954 if (request_irq(pci->irq, snd_echo_interrupt, SA_INTERRUPT | SA_SHIRQ,
1955 ECHOCARD_NAME, (void *)chip)) {
1956 snd_echo_free(chip);
1957 snd_printk(KERN_ERR "cannot grab irq\n");
1958 return -EBUSY;
1959 }
1960 chip->irq = pci->irq;
1961 DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
1962 chip->pci, chip->irq, chip->pci->subsystem_device));
1963
1964 /* Create the DSP comm page - this is the area of memory used for most
1965 of the communication with the DSP, which accesses it via bus mastering */
1966 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1967 sizeof(struct comm_page),
1968 &chip->commpage_dma_buf) < 0) {
1969 snd_echo_free(chip);
1970 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1971 return -ENOMEM;
1972 }
1973 chip->comm_page_phys = chip->commpage_dma_buf.addr;
1974 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1975
1976 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1977 if (err) {
1978 DE_INIT(("init_hw err=%d\n", err));
1979 snd_echo_free(chip);
1980 return err;
1981 }
1982 DE_INIT(("Card init OK\n"));
1983
1984 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1985 snd_echo_free(chip);
1986 return err;
1987 }
1988 atomic_set(&chip->opencount, 0);
1989 init_MUTEX(&chip->mode_mutex);
1990 chip->can_set_rate = 1;
1991 *rchip = chip;
1992 /* Init done ! */
1993 return 0;
1994}
1995
1996
1997
1998/* constructor */
1999static int __devinit snd_echo_probe(struct pci_dev *pci,
2000 const struct pci_device_id *pci_id)
2001{
2002 static int dev;
2003 struct snd_card *card;
2004 struct echoaudio *chip;
2005 char *dsp;
2006 int i, err;
2007
2008 if (dev >= SNDRV_CARDS)
2009 return -ENODEV;
2010 if (!enable[dev]) {
2011 dev++;
2012 return -ENOENT;
2013 }
2014
2015 DE_INIT(("Echoaudio driver starting...\n"));
2016 i = 0;
2017 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2018 if (card == NULL)
2019 return -ENOMEM;
2020
2021 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2022 snd_card_free(card);
2023 return err;
2024 }
2025
2026 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2027 strcpy(card->shortname, chip->card_name);
2028
2029 dsp = "56301";
2030 if (pci_id->device == 0x3410)
2031 dsp = "56361";
2032
2033 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2034 card->shortname, pci_id->subdevice & 0x000f, dsp,
2035 chip->dsp_registers_phys, chip->irq);
2036
2037 if ((err = snd_echo_new_pcm(chip)) < 0) {
2038 snd_printk(KERN_ERR "new pcm error %d\n", err);
2039 snd_card_free(card);
2040 return err;
2041 }
2042
2043#ifdef ECHOCARD_HAS_MIDI
2044 if (chip->has_midi) { /* Some Mia's do not have midi */
2045 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2046 snd_printk(KERN_ERR "new midi error %d\n", err);
2047 snd_card_free(card);
2048 return err;
2049 }
2050 }
2051#endif
2052
2053#ifdef ECHOCARD_HAS_VMIXER
2054 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2055 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_output_gain, chip))) < 0)
2056 goto ctl_error;
2057 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2058 goto ctl_error;
2059#else
2060 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
2061 goto ctl_error;
2062#endif
2063
2064#ifdef ECHOCARD_HAS_INPUT_GAIN
2065 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2066 goto ctl_error;
2067#endif
2068
2069#ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2070 if (!chip->hasnt_input_nominal_level)
2071 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2072 goto ctl_error;
2073#endif
2074
2075#ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2076 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2077 goto ctl_error;
2078#endif
2079
2080 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2081 goto ctl_error;
2082
2083 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2084 goto ctl_error;
2085
2086#ifdef ECHOCARD_HAS_MONITOR
2087 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2088 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2089 goto ctl_error;
2090#endif
2091
2092#ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2093 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2094 goto ctl_error;
2095#endif
2096
2097 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2098 goto ctl_error;
2099
2100#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2101 /* Creates a list of available digital modes */
2102 chip->num_digital_modes = 0;
2103 for (i = 0; i < 6; i++)
2104 if (chip->digital_modes & (1 << i))
2105 chip->digital_mode_list[chip->num_digital_modes++] = i;
2106
2107 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2108 goto ctl_error;
2109#endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2110
2111#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2112 /* Creates a list of available clock sources */
2113 chip->num_clock_sources = 0;
2114 for (i = 0; i < 10; i++)
2115 if (chip->input_clock_types & (1 << i))
2116 chip->clock_source_list[chip->num_clock_sources++] = i;
2117
2118 if (chip->num_clock_sources > 1) {
2119 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2120 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2121 goto ctl_error;
2122 }
2123#endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2124
2125#ifdef ECHOCARD_HAS_DIGITAL_IO
2126 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2127 goto ctl_error;
2128#endif
2129
2130#ifdef ECHOCARD_HAS_PHANTOM_POWER
2131 if (chip->has_phantom_power)
2132 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2133 goto ctl_error;
2134#endif
2135
2136 if ((err = snd_card_register(card)) < 0) {
2137 snd_card_free(card);
2138 goto ctl_error;
2139 }
2140 snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2141
2142 pci_set_drvdata(pci, chip);
2143 dev++;
2144 return 0;
2145
2146ctl_error:
2147 snd_printk(KERN_ERR "new control error %d\n", err);
2148 snd_card_free(card);
2149 return err;
2150}
2151
2152
2153
2154static void __devexit snd_echo_remove(struct pci_dev *pci)
2155{
2156 struct echoaudio *chip;
2157
2158 chip = pci_get_drvdata(pci);
2159 if (chip)
2160 snd_card_free(chip->card);
2161 pci_set_drvdata(pci, NULL);
2162}
2163
2164
2165
2166/******************************************************************************
2167 Everything starts and ends here
2168******************************************************************************/
2169
2170/* pci_driver definition */
2171static struct pci_driver driver = {
2172 .name = "Echoaudio " ECHOCARD_NAME,
2173 .id_table = snd_echo_ids,
2174 .probe = snd_echo_probe,
2175 .remove = __devexit_p(snd_echo_remove),
2176};
2177
2178
2179
2180/* initialization of the module */
2181static int __init alsa_card_echo_init(void)
2182{
2183 return pci_register_driver(&driver);
2184}
2185
2186
2187
2188/* clean up the module */
2189static void __exit alsa_card_echo_exit(void)
2190{
2191 pci_unregister_driver(&driver);
2192}
2193
2194
2195module_init(alsa_card_echo_init)
2196module_exit(alsa_card_echo_exit)
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-21 19:48:34 -0500