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