?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[POWERPC] Use menuconfig objects II - Macintosh
[wrt350n-kernel.git] / sound / pci / echoaudio / echoaudio.c
blobe413da00759bcbe3cc2e67086b41866d12e4bc4a
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 list_head *pos;
709 struct snd_pcm_substream *s;
710
711 snd_pcm_group_for_each(pos, substream) {
712 s = snd_pcm_group_substream_entry(pos);
713 for (i = 0; i < DSP_MAXPIPES; i++) {
714 if (s == chip->substream[i]) {
715 channelmask |= 1 << i;
716 snd_pcm_trigger_done(s, substream);
717 }
718 }
719 }
720
721 spin_lock(&chip->lock);
722 switch (cmd) {
723 case SNDRV_PCM_TRIGGER_START:
724 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
725 DE_ACT(("pcm_trigger start\n"));
726 for (i = 0; i < DSP_MAXPIPES; i++) {
727 if (channelmask & (1 << i)) {
728 pipe = chip->substream[i]->runtime->private_data;
729 switch (pipe->state) {
730 case PIPE_STATE_STOPPED:
731 chip->last_period[i] = 0;
732 pipe->last_counter = 0;
733 pipe->position = 0;
734 *pipe->dma_counter = 0;
735 case PIPE_STATE_PAUSED:
736 pipe->state = PIPE_STATE_STARTED;
737 break;
738 case PIPE_STATE_STARTED:
739 break;
740 }
741 }
742 }
743 err = start_transport(chip, channelmask,
744 chip->pipe_cyclic_mask);
745 break;
746 case SNDRV_PCM_TRIGGER_STOP:
747 DE_ACT(("pcm_trigger stop\n"));
748 for (i = 0; i < DSP_MAXPIPES; i++) {
749 if (channelmask & (1 << i)) {
750 pipe = chip->substream[i]->runtime->private_data;
751 pipe->state = PIPE_STATE_STOPPED;
752 }
753 }
754 err = stop_transport(chip, channelmask);
755 break;
756 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
757 DE_ACT(("pcm_trigger pause\n"));
758 for (i = 0; i < DSP_MAXPIPES; i++) {
759 if (channelmask & (1 << i)) {
760 pipe = chip->substream[i]->runtime->private_data;
761 pipe->state = PIPE_STATE_PAUSED;
762 }
763 }
764 err = pause_transport(chip, channelmask);
765 break;
766 default:
767 err = -EINVAL;
768 }
769 spin_unlock(&chip->lock);
770 return err;
771 }
772
773
774
775 static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
776 {
777 struct snd_pcm_runtime *runtime = substream->runtime;
778 struct audiopipe *pipe = runtime->private_data;
779 size_t cnt, bufsize, pos;
780
781 cnt = le32_to_cpu(*pipe->dma_counter);
782 pipe->position += cnt - pipe->last_counter;
783 pipe->last_counter = cnt;
784 bufsize = substream->runtime->buffer_size;
785 pos = bytes_to_frames(substream->runtime, pipe->position);
786
787 while (pos >= bufsize) {
788 pipe->position -= frames_to_bytes(substream->runtime, bufsize);
789 pos -= bufsize;
790 }
791 return pos;
792 }
793
794
795
796 /* pcm *_ops structures */
797 static struct snd_pcm_ops analog_playback_ops = {
798 .open = pcm_analog_out_open,
799 .close = pcm_close,
800 .ioctl = snd_pcm_lib_ioctl,
801 .hw_params = pcm_analog_out_hw_params,
802 .hw_free = pcm_hw_free,
803 .prepare = pcm_prepare,
804 .trigger = pcm_trigger,
805 .pointer = pcm_pointer,
806 .page = snd_pcm_sgbuf_ops_page,
807 };
808 static struct snd_pcm_ops analog_capture_ops = {
809 .open = pcm_analog_in_open,
810 .close = pcm_close,
811 .ioctl = snd_pcm_lib_ioctl,
812 .hw_params = pcm_analog_in_hw_params,
813 .hw_free = pcm_hw_free,
814 .prepare = pcm_prepare,
815 .trigger = pcm_trigger,
816 .pointer = pcm_pointer,
817 .page = snd_pcm_sgbuf_ops_page,
818 };
819 #ifdef ECHOCARD_HAS_DIGITAL_IO
820 #ifndef ECHOCARD_HAS_VMIXER
821 static struct snd_pcm_ops digital_playback_ops = {
822 .open = pcm_digital_out_open,
823 .close = pcm_close,
824 .ioctl = snd_pcm_lib_ioctl,
825 .hw_params = pcm_digital_out_hw_params,
826 .hw_free = pcm_hw_free,
827 .prepare = pcm_prepare,
828 .trigger = pcm_trigger,
829 .pointer = pcm_pointer,
830 .page = snd_pcm_sgbuf_ops_page,
831 };
832 #endif /* !ECHOCARD_HAS_VMIXER */
833 static struct snd_pcm_ops digital_capture_ops = {
834 .open = pcm_digital_in_open,
835 .close = pcm_close,
836 .ioctl = snd_pcm_lib_ioctl,
837 .hw_params = pcm_digital_in_hw_params,
838 .hw_free = pcm_hw_free,
839 .prepare = pcm_prepare,
840 .trigger = pcm_trigger,
841 .pointer = pcm_pointer,
842 .page = snd_pcm_sgbuf_ops_page,
843 };
844 #endif /* ECHOCARD_HAS_DIGITAL_IO */
845
846
847
848 /* Preallocate memory only for the first substream because it's the most
849 * used one
850 */
851 static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
852 {
853 struct snd_pcm_substream *ss;
854 int stream, err;
855
856 for (stream = 0; stream < 2; stream++)
857 for (ss = pcm->streams[stream].substream; ss; ss = ss->next) {
858 err = snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
859 dev,
860 ss->number ? 0 : 128<<10,
861 256<<10);
862 if (err < 0)
863 return err;
864 }
865 return 0;
866 }
867
868
869
870 /*<--snd_echo_probe() */
871 static int __devinit snd_echo_new_pcm(struct echoaudio *chip)
872 {
873 struct snd_pcm *pcm;
874 int err;
875
876 #ifdef ECHOCARD_HAS_VMIXER
877 /* This card has a Vmixer, that is there is no direct mapping from PCM
878 streams to physical outputs. The user can mix the streams as he wishes
879 via control interface and it's possible to send any stream to any
880 output, thus it makes no sense to keep analog and digital outputs
881 separated */
882
883 /* PCM#0 Virtual outputs and analog inputs */
884 if ((err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
885 num_analog_busses_in(chip), &pcm)) < 0)
886 return err;
887 pcm->private_data = chip;
888 chip->analog_pcm = pcm;
889 strcpy(pcm->name, chip->card->shortname);
890 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
891 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
892 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
893 return err;
894 DE_INIT(("Analog PCM ok\n"));
895
896 #ifdef ECHOCARD_HAS_DIGITAL_IO
897 /* PCM#1 Digital inputs, no outputs */
898 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
899 num_digital_busses_in(chip), &pcm)) < 0)
900 return err;
901 pcm->private_data = chip;
902 chip->digital_pcm = pcm;
903 strcpy(pcm->name, chip->card->shortname);
904 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
905 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
906 return err;
907 DE_INIT(("Digital PCM ok\n"));
908 #endif /* ECHOCARD_HAS_DIGITAL_IO */
909
910 #else /* ECHOCARD_HAS_VMIXER */
911
912 /* The card can manage substreams formed by analog and digital channels
913 at the same time, but I prefer to keep analog and digital channels
914 separated, because that mixed thing is confusing and useless. So we
915 register two PCM devices: */
916
917 /* PCM#0 Analog i/o */
918 if ((err = snd_pcm_new(chip->card, "Analog PCM", 0,
919 num_analog_busses_out(chip),
920 num_analog_busses_in(chip), &pcm)) < 0)
921 return err;
922 pcm->private_data = chip;
923 chip->analog_pcm = pcm;
924 strcpy(pcm->name, chip->card->shortname);
925 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
926 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
927 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
928 return err;
929 DE_INIT(("Analog PCM ok\n"));
930
931 #ifdef ECHOCARD_HAS_DIGITAL_IO
932 /* PCM#1 Digital i/o */
933 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1,
934 num_digital_busses_out(chip),
935 num_digital_busses_in(chip), &pcm)) < 0)
936 return err;
937 pcm->private_data = chip;
938 chip->digital_pcm = pcm;
939 strcpy(pcm->name, chip->card->shortname);
940 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
941 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
942 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
943 return err;
944 DE_INIT(("Digital PCM ok\n"));
945 #endif /* ECHOCARD_HAS_DIGITAL_IO */
946
947 #endif /* ECHOCARD_HAS_VMIXER */
948
949 return 0;
950 }
951
952
953
954
955 /******************************************************************************
956 Control interface
957 ******************************************************************************/
958
959 /******************* PCM output volume *******************/
960 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
961 struct snd_ctl_elem_info *uinfo)
962 {
963 struct echoaudio *chip;
964
965 chip = snd_kcontrol_chip(kcontrol);
966 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
967 uinfo->count = num_busses_out(chip);
968 uinfo->value.integer.min = ECHOGAIN_MINOUT;
969 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
970 return 0;
971 }
972
973 static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
974 struct snd_ctl_elem_value *ucontrol)
975 {
976 struct echoaudio *chip;
977 int c;
978
979 chip = snd_kcontrol_chip(kcontrol);
980 for (c = 0; c < num_busses_out(chip); c++)
981 ucontrol->value.integer.value[c] = chip->output_gain[c];
982 return 0;
983 }
984
985 static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
986 struct snd_ctl_elem_value *ucontrol)
987 {
988 struct echoaudio *chip;
989 int c, changed, gain;
990
991 changed = 0;
992 chip = snd_kcontrol_chip(kcontrol);
993 spin_lock_irq(&chip->lock);
994 for (c = 0; c < num_busses_out(chip); c++) {
995 gain = ucontrol->value.integer.value[c];
996 /* Ignore out of range values */
997 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
998 continue;
999 if (chip->output_gain[c] != gain) {
1000 set_output_gain(chip, c, gain);
1001 changed = 1;
1002 }
1003 }
1004 if (changed)
1005 update_output_line_level(chip);
1006 spin_unlock_irq(&chip->lock);
1007 return changed;
1008 }
1009
1010 #ifdef ECHOCARD_HAS_VMIXER
1011 /* On Vmixer cards this one controls the line-out volume */
1012 static struct snd_kcontrol_new snd_echo_line_output_gain __devinitdata = {
1013 .name = "Line Playback Volume",
1014 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1015 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1016 .info = snd_echo_output_gain_info,
1017 .get = snd_echo_output_gain_get,
1018 .put = snd_echo_output_gain_put,
1019 .tlv = {.p = db_scale_output_gain},
1020 };
1021 #else
1022 static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
1023 .name = "PCM Playback Volume",
1024 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1025 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1026 .info = snd_echo_output_gain_info,
1027 .get = snd_echo_output_gain_get,
1028 .put = snd_echo_output_gain_put,
1029 .tlv = {.p = db_scale_output_gain},
1030 };
1031 #endif
1032
1033
1034
1035 #ifdef ECHOCARD_HAS_INPUT_GAIN
1036
1037 /******************* Analog input volume *******************/
1038 static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1039 struct snd_ctl_elem_info *uinfo)
1040 {
1041 struct echoaudio *chip;
1042
1043 chip = snd_kcontrol_chip(kcontrol);
1044 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1045 uinfo->count = num_analog_busses_in(chip);
1046 uinfo->value.integer.min = ECHOGAIN_MININP;
1047 uinfo->value.integer.max = ECHOGAIN_MAXINP;
1048 return 0;
1049 }
1050
1051 static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1052 struct snd_ctl_elem_value *ucontrol)
1053 {
1054 struct echoaudio *chip;
1055 int c;
1056
1057 chip = snd_kcontrol_chip(kcontrol);
1058 for (c = 0; c < num_analog_busses_in(chip); c++)
1059 ucontrol->value.integer.value[c] = chip->input_gain[c];
1060 return 0;
1061 }
1062
1063 static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1064 struct snd_ctl_elem_value *ucontrol)
1065 {
1066 struct echoaudio *chip;
1067 int c, gain, changed;
1068
1069 changed = 0;
1070 chip = snd_kcontrol_chip(kcontrol);
1071 spin_lock_irq(&chip->lock);
1072 for (c = 0; c < num_analog_busses_in(chip); c++) {
1073 gain = ucontrol->value.integer.value[c];
1074 /* Ignore out of range values */
1075 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1076 continue;
1077 if (chip->input_gain[c] != gain) {
1078 set_input_gain(chip, c, gain);
1079 changed = 1;
1080 }
1081 }
1082 if (changed)
1083 update_input_line_level(chip);
1084 spin_unlock_irq(&chip->lock);
1085 return changed;
1086 }
1087
1088 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1089
1090 static struct snd_kcontrol_new snd_echo_line_input_gain __devinitdata = {
1091 .name = "Line Capture Volume",
1092 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1093 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1094 .info = snd_echo_input_gain_info,
1095 .get = snd_echo_input_gain_get,
1096 .put = snd_echo_input_gain_put,
1097 .tlv = {.p = db_scale_input_gain},
1098 };
1099
1100 #endif /* ECHOCARD_HAS_INPUT_GAIN */
1101
1102
1103
1104 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1105
1106 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1107 static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1108 struct snd_ctl_elem_info *uinfo)
1109 {
1110 struct echoaudio *chip;
1111
1112 chip = snd_kcontrol_chip(kcontrol);
1113 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1114 uinfo->count = num_analog_busses_out(chip);
1115 uinfo->value.integer.min = 0;
1116 uinfo->value.integer.max = 1;
1117 return 0;
1118 }
1119
1120 static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1121 struct snd_ctl_elem_value *ucontrol)
1122 {
1123 struct echoaudio *chip;
1124 int c;
1125
1126 chip = snd_kcontrol_chip(kcontrol);
1127 for (c = 0; c < num_analog_busses_out(chip); c++)
1128 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1129 return 0;
1130 }
1131
1132 static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1133 struct snd_ctl_elem_value *ucontrol)
1134 {
1135 struct echoaudio *chip;
1136 int c, changed;
1137
1138 changed = 0;
1139 chip = snd_kcontrol_chip(kcontrol);
1140 spin_lock_irq(&chip->lock);
1141 for (c = 0; c < num_analog_busses_out(chip); c++) {
1142 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1143 set_nominal_level(chip, c,
1144 ucontrol->value.integer.value[c]);
1145 changed = 1;
1146 }
1147 }
1148 if (changed)
1149 update_output_line_level(chip);
1150 spin_unlock_irq(&chip->lock);
1151 return changed;
1152 }
1153
1154 static struct snd_kcontrol_new snd_echo_output_nominal_level __devinitdata = {
1155 .name = "Line Playback Switch (-10dBV)",
1156 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1157 .info = snd_echo_output_nominal_info,
1158 .get = snd_echo_output_nominal_get,
1159 .put = snd_echo_output_nominal_put,
1160 };
1161
1162 #endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1163
1164
1165
1166 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1167
1168 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1169 static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1170 struct snd_ctl_elem_info *uinfo)
1171 {
1172 struct echoaudio *chip;
1173
1174 chip = snd_kcontrol_chip(kcontrol);
1175 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1176 uinfo->count = num_analog_busses_in(chip);
1177 uinfo->value.integer.min = 0;
1178 uinfo->value.integer.max = 1;
1179 return 0;
1180 }
1181
1182 static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1183 struct snd_ctl_elem_value *ucontrol)
1184 {
1185 struct echoaudio *chip;
1186 int c;
1187
1188 chip = snd_kcontrol_chip(kcontrol);
1189 for (c = 0; c < num_analog_busses_in(chip); c++)
1190 ucontrol->value.integer.value[c] =
1191 chip->nominal_level[bx_analog_in(chip) + c];
1192 return 0;
1193 }
1194
1195 static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1196 struct snd_ctl_elem_value *ucontrol)
1197 {
1198 struct echoaudio *chip;
1199 int c, changed;
1200
1201 changed = 0;
1202 chip = snd_kcontrol_chip(kcontrol);
1203 spin_lock_irq(&chip->lock);
1204 for (c = 0; c < num_analog_busses_in(chip); c++) {
1205 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1206 ucontrol->value.integer.value[c]) {
1207 set_nominal_level(chip, bx_analog_in(chip) + c,
1208 ucontrol->value.integer.value[c]);
1209 changed = 1;
1210 }
1211 }
1212 if (changed)
1213 update_output_line_level(chip); /* "Output" is not a mistake
1214 * here.
1215 */
1216 spin_unlock_irq(&chip->lock);
1217 return changed;
1218 }
1219
1220 static struct snd_kcontrol_new snd_echo_intput_nominal_level __devinitdata = {
1221 .name = "Line Capture Switch (-10dBV)",
1222 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1223 .info = snd_echo_input_nominal_info,
1224 .get = snd_echo_input_nominal_get,
1225 .put = snd_echo_input_nominal_put,
1226 };
1227
1228 #endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1229
1230
1231
1232 #ifdef ECHOCARD_HAS_MONITOR
1233
1234 /******************* Monitor mixer *******************/
1235 static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1236 struct snd_ctl_elem_info *uinfo)
1237 {
1238 struct echoaudio *chip;
1239
1240 chip = snd_kcontrol_chip(kcontrol);
1241 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1242 uinfo->count = 1;
1243 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1244 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1245 uinfo->dimen.d[0] = num_busses_out(chip);
1246 uinfo->dimen.d[1] = num_busses_in(chip);
1247 return 0;
1248 }
1249
1250 static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1251 struct snd_ctl_elem_value *ucontrol)
1252 {
1253 struct echoaudio *chip;
1254
1255 chip = snd_kcontrol_chip(kcontrol);
1256 ucontrol->value.integer.value[0] =
1257 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)]
1258 [ucontrol->id.index % num_busses_in(chip)];
1259 return 0;
1260 }
1261
1262 static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1263 struct snd_ctl_elem_value *ucontrol)
1264 {
1265 struct echoaudio *chip;
1266 int changed, gain;
1267 short out, in;
1268
1269 changed = 0;
1270 chip = snd_kcontrol_chip(kcontrol);
1271 out = ucontrol->id.index / num_busses_in(chip);
1272 in = ucontrol->id.index % num_busses_in(chip);
1273 gain = ucontrol->value.integer.value[0];
1274 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1275 return -EINVAL;
1276 if (chip->monitor_gain[out][in] != gain) {
1277 spin_lock_irq(&chip->lock);
1278 set_monitor_gain(chip, out, in, gain);
1279 update_output_line_level(chip);
1280 spin_unlock_irq(&chip->lock);
1281 changed = 1;
1282 }
1283 return changed;
1284 }
1285
1286 static struct snd_kcontrol_new snd_echo_monitor_mixer __devinitdata = {
1287 .name = "Monitor Mixer Volume",
1288 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1289 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1290 .info = snd_echo_mixer_info,
1291 .get = snd_echo_mixer_get,
1292 .put = snd_echo_mixer_put,
1293 .tlv = {.p = db_scale_output_gain},
1294 };
1295
1296 #endif /* ECHOCARD_HAS_MONITOR */
1297
1298
1299
1300 #ifdef ECHOCARD_HAS_VMIXER
1301
1302 /******************* Vmixer *******************/
1303 static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1304 struct snd_ctl_elem_info *uinfo)
1305 {
1306 struct echoaudio *chip;
1307
1308 chip = snd_kcontrol_chip(kcontrol);
1309 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1310 uinfo->count = 1;
1311 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1312 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1313 uinfo->dimen.d[0] = num_busses_out(chip);
1314 uinfo->dimen.d[1] = num_pipes_out(chip);
1315 return 0;
1316 }
1317
1318 static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1319 struct snd_ctl_elem_value *ucontrol)
1320 {
1321 struct echoaudio *chip;
1322
1323 chip = snd_kcontrol_chip(kcontrol);
1324 ucontrol->value.integer.value[0] =
1325 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1326 [ucontrol->id.index % num_pipes_out(chip)];
1327 return 0;
1328 }
1329
1330 static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1331 struct snd_ctl_elem_value *ucontrol)
1332 {
1333 struct echoaudio *chip;
1334 int gain, changed;
1335 short vch, out;
1336
1337 changed = 0;
1338 chip = snd_kcontrol_chip(kcontrol);
1339 out = ucontrol->id.index / num_pipes_out(chip);
1340 vch = ucontrol->id.index % num_pipes_out(chip);
1341 gain = ucontrol->value.integer.value[0];
1342 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1343 return -EINVAL;
1344 if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1345 spin_lock_irq(&chip->lock);
1346 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1347 update_vmixer_level(chip);
1348 spin_unlock_irq(&chip->lock);
1349 changed = 1;
1350 }
1351 return changed;
1352 }
1353
1354 static struct snd_kcontrol_new snd_echo_vmixer __devinitdata = {
1355 .name = "VMixer Volume",
1356 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1357 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1358 .info = snd_echo_vmixer_info,
1359 .get = snd_echo_vmixer_get,
1360 .put = snd_echo_vmixer_put,
1361 .tlv = {.p = db_scale_output_gain},
1362 };
1363
1364 #endif /* ECHOCARD_HAS_VMIXER */
1365
1366
1367
1368 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1369
1370 /******************* Digital mode switch *******************/
1371 static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1372 struct snd_ctl_elem_info *uinfo)
1373 {
1374 static char *names[4] = {
1375 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1376 "S/PDIF Cdrom"
1377 };
1378 struct echoaudio *chip;
1379
1380 chip = snd_kcontrol_chip(kcontrol);
1381 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1382 uinfo->value.enumerated.items = chip->num_digital_modes;
1383 uinfo->count = 1;
1384 if (uinfo->value.enumerated.item >= chip->num_digital_modes)
1385 uinfo->value.enumerated.item = chip->num_digital_modes - 1;
1386 strcpy(uinfo->value.enumerated.name, names[
1387 chip->digital_mode_list[uinfo->value.enumerated.item]]);
1388 return 0;
1389 }
1390
1391 static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1392 struct snd_ctl_elem_value *ucontrol)
1393 {
1394 struct echoaudio *chip;
1395 int i, mode;
1396
1397 chip = snd_kcontrol_chip(kcontrol);
1398 mode = chip->digital_mode;
1399 for (i = chip->num_digital_modes - 1; i >= 0; i--)
1400 if (mode == chip->digital_mode_list[i]) {
1401 ucontrol->value.enumerated.item[0] = i;
1402 break;
1403 }
1404 return 0;
1405 }
1406
1407 static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1408 struct snd_ctl_elem_value *ucontrol)
1409 {
1410 struct echoaudio *chip;
1411 int changed;
1412 unsigned short emode, dmode;
1413
1414 changed = 0;
1415 chip = snd_kcontrol_chip(kcontrol);
1416
1417 emode = ucontrol->value.enumerated.item[0];
1418 if (emode >= chip->num_digital_modes)
1419 return -EINVAL;
1420 dmode = chip->digital_mode_list[emode];
1421
1422 if (dmode != chip->digital_mode) {
1423 /* mode_mutex is required to make this operation atomic wrt
1424 pcm_digital_*_open() and set_input_clock() functions. */
1425 down(&chip->mode_mutex);
1426
1427 /* Do not allow the user to change the digital mode when a pcm
1428 device is open because it also changes the number of channels
1429 and the allowed sample rates */
1430 if (atomic_read(&chip->opencount)) {
1431 changed = -EAGAIN;
1432 } else {
1433 changed = set_digital_mode(chip, dmode);
1434 /* If we had to change the clock source, report it */
1435 if (changed > 0 && chip->clock_src_ctl) {
1436 snd_ctl_notify(chip->card,
1437 SNDRV_CTL_EVENT_MASK_VALUE,
1438 &chip->clock_src_ctl->id);
1439 DE_ACT(("SDM() =%d\n", changed));
1440 }
1441 if (changed >= 0)
1442 changed = 1; /* No errors */
1443 }
1444 up(&chip->mode_mutex);
1445 }
1446 return changed;
1447 }
1448
1449 static struct snd_kcontrol_new snd_echo_digital_mode_switch __devinitdata = {
1450 .name = "Digital mode Switch",
1451 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1452 .info = snd_echo_digital_mode_info,
1453 .get = snd_echo_digital_mode_get,
1454 .put = snd_echo_digital_mode_put,
1455 };
1456
1457 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1458
1459
1460
1461 #ifdef ECHOCARD_HAS_DIGITAL_IO
1462
1463 /******************* S/PDIF mode switch *******************/
1464 static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1465 struct snd_ctl_elem_info *uinfo)
1466 {
1467 static char *names[2] = {"Consumer", "Professional"};
1468
1469 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1470 uinfo->value.enumerated.items = 2;
1471 uinfo->count = 1;
1472 if (uinfo->value.enumerated.item)
1473 uinfo->value.enumerated.item = 1;
1474 strcpy(uinfo->value.enumerated.name,
1475 names[uinfo->value.enumerated.item]);
1476 return 0;
1477 }
1478
1479 static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1480 struct snd_ctl_elem_value *ucontrol)
1481 {
1482 struct echoaudio *chip;
1483
1484 chip = snd_kcontrol_chip(kcontrol);
1485 ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1486 return 0;
1487 }
1488
1489 static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1490 struct snd_ctl_elem_value *ucontrol)
1491 {
1492 struct echoaudio *chip;
1493 int mode;
1494
1495 chip = snd_kcontrol_chip(kcontrol);
1496 mode = !!ucontrol->value.enumerated.item[0];
1497 if (mode != chip->professional_spdif) {
1498 spin_lock_irq(&chip->lock);
1499 set_professional_spdif(chip, mode);
1500 spin_unlock_irq(&chip->lock);
1501 return 1;
1502 }
1503 return 0;
1504 }
1505
1506 static struct snd_kcontrol_new snd_echo_spdif_mode_switch __devinitdata = {
1507 .name = "S/PDIF mode Switch",
1508 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1509 .info = snd_echo_spdif_mode_info,
1510 .get = snd_echo_spdif_mode_get,
1511 .put = snd_echo_spdif_mode_put,
1512 };
1513
1514 #endif /* ECHOCARD_HAS_DIGITAL_IO */
1515
1516
1517
1518 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1519
1520 /******************* Select input clock source *******************/
1521 static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1522 struct snd_ctl_elem_info *uinfo)
1523 {
1524 static char *names[8] = {
1525 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1526 "ESync96", "MTC"
1527 };
1528 struct echoaudio *chip;
1529
1530 chip = snd_kcontrol_chip(kcontrol);
1531 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1532 uinfo->value.enumerated.items = chip->num_clock_sources;
1533 uinfo->count = 1;
1534 if (uinfo->value.enumerated.item >= chip->num_clock_sources)
1535 uinfo->value.enumerated.item = chip->num_clock_sources - 1;
1536 strcpy(uinfo->value.enumerated.name, names[
1537 chip->clock_source_list[uinfo->value.enumerated.item]]);
1538 return 0;
1539 }
1540
1541 static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1542 struct snd_ctl_elem_value *ucontrol)
1543 {
1544 struct echoaudio *chip;
1545 int i, clock;
1546
1547 chip = snd_kcontrol_chip(kcontrol);
1548 clock = chip->input_clock;
1549
1550 for (i = 0; i < chip->num_clock_sources; i++)
1551 if (clock == chip->clock_source_list[i])
1552 ucontrol->value.enumerated.item[0] = i;
1553
1554 return 0;
1555 }
1556
1557 static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1558 struct snd_ctl_elem_value *ucontrol)
1559 {
1560 struct echoaudio *chip;
1561 int changed;
1562 unsigned int eclock, dclock;
1563
1564 changed = 0;
1565 chip = snd_kcontrol_chip(kcontrol);
1566 eclock = ucontrol->value.enumerated.item[0];
1567 if (eclock >= chip->input_clock_types)
1568 return -EINVAL;
1569 dclock = chip->clock_source_list[eclock];
1570 if (chip->input_clock != dclock) {
1571 down(&chip->mode_mutex);
1572 spin_lock_irq(&chip->lock);
1573 if ((changed = set_input_clock(chip, dclock)) == 0)
1574 changed = 1; /* no errors */
1575 spin_unlock_irq(&chip->lock);
1576 up(&chip->mode_mutex);
1577 }
1578
1579 if (changed < 0)
1580 DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed));
1581
1582 return changed;
1583 }
1584
1585 static struct snd_kcontrol_new snd_echo_clock_source_switch __devinitdata = {
1586 .name = "Sample Clock Source",
1587 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1588 .info = snd_echo_clock_source_info,
1589 .get = snd_echo_clock_source_get,
1590 .put = snd_echo_clock_source_put,
1591 };
1592
1593 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1594
1595
1596
1597 #ifdef ECHOCARD_HAS_PHANTOM_POWER
1598
1599 /******************* Phantom power switch *******************/
1600 static int snd_echo_phantom_power_info(struct snd_kcontrol *kcontrol,
1601 struct snd_ctl_elem_info *uinfo)
1602 {
1603 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1604 uinfo->count = 1;
1605 uinfo->value.integer.min = 0;
1606 uinfo->value.integer.max = 1;
1607 return 0;
1608 }
1609
1610 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1611 struct snd_ctl_elem_value *ucontrol)
1612 {
1613 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1614
1615 ucontrol->value.integer.value[0] = chip->phantom_power;
1616 return 0;
1617 }
1618
1619 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1620 struct snd_ctl_elem_value *ucontrol)
1621 {
1622 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1623 int power, changed = 0;
1624
1625 power = !!ucontrol->value.integer.value[0];
1626 if (chip->phantom_power != power) {
1627 spin_lock_irq(&chip->lock);
1628 changed = set_phantom_power(chip, power);
1629 spin_unlock_irq(&chip->lock);
1630 if (changed == 0)
1631 changed = 1; /* no errors */
1632 }
1633 return changed;
1634 }
1635
1636 static struct snd_kcontrol_new snd_echo_phantom_power_switch __devinitdata = {
1637 .name = "Phantom power Switch",
1638 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1639 .info = snd_echo_phantom_power_info,
1640 .get = snd_echo_phantom_power_get,
1641 .put = snd_echo_phantom_power_put,
1642 };
1643
1644 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1645
1646
1647
1648 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1649
1650 /******************* Digital input automute switch *******************/
1651 static int snd_echo_automute_info(struct snd_kcontrol *kcontrol,
1652 struct snd_ctl_elem_info *uinfo)
1653 {
1654 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1655 uinfo->count = 1;
1656 uinfo->value.integer.min = 0;
1657 uinfo->value.integer.max = 1;
1658 return 0;
1659 }
1660
1661 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1662 struct snd_ctl_elem_value *ucontrol)
1663 {
1664 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1665
1666 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1667 return 0;
1668 }
1669
1670 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1671 struct snd_ctl_elem_value *ucontrol)
1672 {
1673 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1674 int automute, changed = 0;
1675
1676 automute = !!ucontrol->value.integer.value[0];
1677 if (chip->digital_in_automute != automute) {
1678 spin_lock_irq(&chip->lock);
1679 changed = set_input_auto_mute(chip, automute);
1680 spin_unlock_irq(&chip->lock);
1681 if (changed == 0)
1682 changed = 1; /* no errors */
1683 }
1684 return changed;
1685 }
1686
1687 static struct snd_kcontrol_new snd_echo_automute_switch __devinitdata = {
1688 .name = "Digital Capture Switch (automute)",
1689 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1690 .info = snd_echo_automute_info,
1691 .get = snd_echo_automute_get,
1692 .put = snd_echo_automute_put,
1693 };
1694
1695 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1696
1697
1698
1699 /******************* VU-meters switch *******************/
1700 static int snd_echo_vumeters_switch_info(struct snd_kcontrol *kcontrol,
1701 struct snd_ctl_elem_info *uinfo)
1702 {
1703 struct echoaudio *chip;
1704
1705 chip = snd_kcontrol_chip(kcontrol);
1706 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1707 uinfo->count = 1;
1708 uinfo->value.integer.min = 0;
1709 uinfo->value.integer.max = 1;
1710 return 0;
1711 }
1712
1713 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1714 struct snd_ctl_elem_value *ucontrol)
1715 {
1716 struct echoaudio *chip;
1717
1718 chip = snd_kcontrol_chip(kcontrol);
1719 spin_lock_irq(&chip->lock);
1720 set_meters_on(chip, ucontrol->value.integer.value[0]);
1721 spin_unlock_irq(&chip->lock);
1722 return 1;
1723 }
1724
1725 static struct snd_kcontrol_new snd_echo_vumeters_switch __devinitdata = {
1726 .name = "VU-meters Switch",
1727 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1728 .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1729 .info = snd_echo_vumeters_switch_info,
1730 .put = snd_echo_vumeters_switch_put,
1731 };
1732
1733
1734
1735 /***** Read VU-meters (input, output, analog and digital together) *****/
1736 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1737 struct snd_ctl_elem_info *uinfo)
1738 {
1739 struct echoaudio *chip;
1740
1741 chip = snd_kcontrol_chip(kcontrol);
1742 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1743 uinfo->count = 96;
1744 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1745 uinfo->value.integer.max = 0;
1746 #ifdef ECHOCARD_HAS_VMIXER
1747 uinfo->dimen.d[0] = 3; /* Out, In, Virt */
1748 #else
1749 uinfo->dimen.d[0] = 2; /* Out, In */
1750 #endif
1751 uinfo->dimen.d[1] = 16; /* 16 channels */
1752 uinfo->dimen.d[2] = 2; /* 0=level, 1=peak */
1753 return 0;
1754 }
1755
1756 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1757 struct snd_ctl_elem_value *ucontrol)
1758 {
1759 struct echoaudio *chip;
1760
1761 chip = snd_kcontrol_chip(kcontrol);
1762 get_audio_meters(chip, ucontrol->value.integer.value);
1763 return 0;
1764 }
1765
1766 static struct snd_kcontrol_new snd_echo_vumeters __devinitdata = {
1767 .name = "VU-meters",
1768 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1769 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1770 SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1771 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1772 .info = snd_echo_vumeters_info,
1773 .get = snd_echo_vumeters_get,
1774 .tlv = {.p = db_scale_output_gain},
1775 };
1776
1777
1778
1779 /*** Channels info - it exports informations about the number of channels ***/
1780 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1781 struct snd_ctl_elem_info *uinfo)
1782 {
1783 struct echoaudio *chip;
1784
1785 chip = snd_kcontrol_chip(kcontrol);
1786 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1787 uinfo->count = 6;
1788 uinfo->value.integer.min = 0;
1789 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1790 return 0;
1791 }
1792
1793 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1794 struct snd_ctl_elem_value *ucontrol)
1795 {
1796 struct echoaudio *chip;
1797 int detected, clocks, bit, src;
1798
1799 chip = snd_kcontrol_chip(kcontrol);
1800 ucontrol->value.integer.value[0] = num_busses_in(chip);
1801 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1802 ucontrol->value.integer.value[2] = num_busses_out(chip);
1803 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1804 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1805
1806 /* Compute the bitmask of the currently valid input clocks */
1807 detected = detect_input_clocks(chip);
1808 clocks = 0;
1809 src = chip->num_clock_sources - 1;
1810 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1811 if (detected & (1 << bit))
1812 for (; src >= 0; src--)
1813 if (bit == chip->clock_source_list[src]) {
1814 clocks |= 1 << src;
1815 break;
1816 }
1817 ucontrol->value.integer.value[5] = clocks;
1818
1819 return 0;
1820 }
1821
1822 static struct snd_kcontrol_new snd_echo_channels_info __devinitdata = {
1823 .name = "Channels info",
1824 .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1825 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1826 .info = snd_echo_channels_info_info,
1827 .get = snd_echo_channels_info_get,
1828 };
1829
1830
1831
1832
1833 /******************************************************************************
1834 IRQ Handler
1835 ******************************************************************************/
1836
1837 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1838 {
1839 struct echoaudio *chip = dev_id;
1840 struct snd_pcm_substream *substream;
1841 int period, ss, st;
1842
1843 spin_lock(&chip->lock);
1844 st = service_irq(chip);
1845 if (st < 0) {
1846 spin_unlock(&chip->lock);
1847 return IRQ_NONE;
1848 }
1849 /* The hardware doesn't tell us which substream caused the irq,
1850 thus we have to check all running substreams. */
1851 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1852 if ((substream = chip->substream[ss])) {
1853 period = pcm_pointer(substream) /
1854 substream->runtime->period_size;
1855 if (period != chip->last_period[ss]) {
1856 chip->last_period[ss] = period;
1857 spin_unlock(&chip->lock);
1858 snd_pcm_period_elapsed(substream);
1859 spin_lock(&chip->lock);
1860 }
1861 }
1862 }
1863 spin_unlock(&chip->lock);
1864
1865 #ifdef ECHOCARD_HAS_MIDI
1866 if (st > 0 && chip->midi_in) {
1867 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1868 DE_MID(("rawmidi_iread=%d\n", st));
1869 }
1870 #endif
1871 return IRQ_HANDLED;
1872 }
1873
1874
1875
1876
1877 /******************************************************************************
1878 Module construction / destruction
1879 ******************************************************************************/
1880
1881 static int snd_echo_free(struct echoaudio *chip)
1882 {
1883 DE_INIT(("Stop DSP...\n"));
1884 if (chip->comm_page) {
1885 rest_in_peace(chip);
1886 snd_dma_free_pages(&chip->commpage_dma_buf);
1887 }
1888 DE_INIT(("Stopped.\n"));
1889
1890 if (chip->irq >= 0)
1891 free_irq(chip->irq, chip);
1892
1893 if (chip->dsp_registers)
1894 iounmap(chip->dsp_registers);
1895
1896 if (chip->iores)
1897 release_and_free_resource(chip->iores);
1898
1899 DE_INIT(("MMIO freed.\n"));
1900
1901 pci_disable_device(chip->pci);
1902
1903 /* release chip data */
1904 kfree(chip);
1905 DE_INIT(("Chip freed.\n"));
1906 return 0;
1907 }
1908
1909
1910
1911 static int snd_echo_dev_free(struct snd_device *device)
1912 {
1913 struct echoaudio *chip = device->device_data;
1914
1915 DE_INIT(("snd_echo_dev_free()...\n"));
1916 return snd_echo_free(chip);
1917 }
1918
1919
1920
1921 /* <--snd_echo_probe() */
1922 static __devinit int snd_echo_create(struct snd_card *card,
1923 struct pci_dev *pci,
1924 struct echoaudio **rchip)
1925 {
1926 struct echoaudio *chip;
1927 int err;
1928 size_t sz;
1929 static struct snd_device_ops ops = {
1930 .dev_free = snd_echo_dev_free,
1931 };
1932
1933 *rchip = NULL;
1934
1935 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1936
1937 if ((err = pci_enable_device(pci)) < 0)
1938 return err;
1939 pci_set_master(pci);
1940
1941 /* allocate a chip-specific data */
1942 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1943 if (!chip) {
1944 pci_disable_device(pci);
1945 return -ENOMEM;
1946 }
1947 DE_INIT(("chip=%p\n", chip));
1948
1949 spin_lock_init(&chip->lock);
1950 chip->card = card;
1951 chip->pci = pci;
1952 chip->irq = -1;
1953
1954 /* PCI resource allocation */
1955 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1956 sz = pci_resource_len(pci, 0);
1957 if (sz > PAGE_SIZE)
1958 sz = PAGE_SIZE; /* We map only the required part */
1959
1960 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1961 ECHOCARD_NAME)) == NULL) {
1962 snd_echo_free(chip);
1963 snd_printk(KERN_ERR "cannot get memory region\n");
1964 return -EBUSY;
1965 }
1966 chip->dsp_registers = (volatile u32 __iomem *)
1967 ioremap_nocache(chip->dsp_registers_phys, sz);
1968
1969 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1970 ECHOCARD_NAME, chip)) {
1971 snd_echo_free(chip);
1972 snd_printk(KERN_ERR "cannot grab irq\n");
1973 return -EBUSY;
1974 }
1975 chip->irq = pci->irq;
1976 DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
1977 chip->pci, chip->irq, chip->pci->subsystem_device));
1978
1979 /* Create the DSP comm page - this is the area of memory used for most
1980 of the communication with the DSP, which accesses it via bus mastering */
1981 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1982 sizeof(struct comm_page),
1983 &chip->commpage_dma_buf) < 0) {
1984 snd_echo_free(chip);
1985 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1986 return -ENOMEM;
1987 }
1988 chip->comm_page_phys = chip->commpage_dma_buf.addr;
1989 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1990
1991 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1992 if (err) {
1993 DE_INIT(("init_hw err=%d\n", err));
1994 snd_echo_free(chip);
1995 return err;
1996 }
1997 DE_INIT(("Card init OK\n"));
1998
1999 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2000 snd_echo_free(chip);
2001 return err;
2002 }
2003 atomic_set(&chip->opencount, 0);
2004 init_MUTEX(&chip->mode_mutex);
2005 chip->can_set_rate = 1;
2006 *rchip = chip;
2007 /* Init done ! */
2008 return 0;
2009 }
2010
2011
2012
2013 /* constructor */
2014 static int __devinit snd_echo_probe(struct pci_dev *pci,
2015 const struct pci_device_id *pci_id)
2016 {
2017 static int dev;
2018 struct snd_card *card;
2019 struct echoaudio *chip;
2020 char *dsp;
2021 int i, err;
2022
2023 if (dev >= SNDRV_CARDS)
2024 return -ENODEV;
2025 if (!enable[dev]) {
2026 dev++;
2027 return -ENOENT;
2028 }
2029
2030 DE_INIT(("Echoaudio driver starting...\n"));
2031 i = 0;
2032 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2033 if (card == NULL)
2034 return -ENOMEM;
2035
2036 snd_card_set_dev(card, &pci->dev);
2037
2038 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2039 snd_card_free(card);
2040 return err;
2041 }
2042
2043 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2044 strcpy(card->shortname, chip->card_name);
2045
2046 dsp = "56301";
2047 if (pci_id->device == 0x3410)
2048 dsp = "56361";
2049
2050 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2051 card->shortname, pci_id->subdevice & 0x000f, dsp,
2052 chip->dsp_registers_phys, chip->irq);
2053
2054 if ((err = snd_echo_new_pcm(chip)) < 0) {
2055 snd_printk(KERN_ERR "new pcm error %d\n", err);
2056 snd_card_free(card);
2057 return err;
2058 }
2059
2060 #ifdef ECHOCARD_HAS_MIDI
2061 if (chip->has_midi) { /* Some Mia's do not have midi */
2062 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2063 snd_printk(KERN_ERR "new midi error %d\n", err);
2064 snd_card_free(card);
2065 return err;
2066 }
2067 }
2068 #endif
2069
2070 #ifdef ECHOCARD_HAS_VMIXER
2071 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2072 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_output_gain, chip))) < 0)
2073 goto ctl_error;
2074 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2075 goto ctl_error;
2076 #else
2077 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
2078 goto ctl_error;
2079 #endif
2080
2081 #ifdef ECHOCARD_HAS_INPUT_GAIN
2082 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2083 goto ctl_error;
2084 #endif
2085
2086 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2087 if (!chip->hasnt_input_nominal_level)
2088 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2089 goto ctl_error;
2090 #endif
2091
2092 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2093 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2094 goto ctl_error;
2095 #endif
2096
2097 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2098 goto ctl_error;
2099
2100 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2101 goto ctl_error;
2102
2103 #ifdef ECHOCARD_HAS_MONITOR
2104 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2105 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2106 goto ctl_error;
2107 #endif
2108
2109 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2110 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2111 goto ctl_error;
2112 #endif
2113
2114 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2115 goto ctl_error;
2116
2117 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2118 /* Creates a list of available digital modes */
2119 chip->num_digital_modes = 0;
2120 for (i = 0; i < 6; i++)
2121 if (chip->digital_modes & (1 << i))
2122 chip->digital_mode_list[chip->num_digital_modes++] = i;
2123
2124 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2125 goto ctl_error;
2126 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2127
2128 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2129 /* Creates a list of available clock sources */
2130 chip->num_clock_sources = 0;
2131 for (i = 0; i < 10; i++)
2132 if (chip->input_clock_types & (1 << i))
2133 chip->clock_source_list[chip->num_clock_sources++] = i;
2134
2135 if (chip->num_clock_sources > 1) {
2136 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2137 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2138 goto ctl_error;
2139 }
2140 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2141
2142 #ifdef ECHOCARD_HAS_DIGITAL_IO
2143 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2144 goto ctl_error;
2145 #endif
2146
2147 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2148 if (chip->has_phantom_power)
2149 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2150 goto ctl_error;
2151 #endif
2152
2153 if ((err = snd_card_register(card)) < 0) {
2154 snd_card_free(card);
2155 goto ctl_error;
2156 }
2157 snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2158
2159 pci_set_drvdata(pci, chip);
2160 dev++;
2161 return 0;
2162
2163 ctl_error:
2164 snd_printk(KERN_ERR "new control error %d\n", err);
2165 snd_card_free(card);
2166 return err;
2167 }
2168
2169
2170
2171 static void __devexit snd_echo_remove(struct pci_dev *pci)
2172 {
2173 struct echoaudio *chip;
2174
2175 chip = pci_get_drvdata(pci);
2176 if (chip)
2177 snd_card_free(chip->card);
2178 pci_set_drvdata(pci, NULL);
2179 }
2180
2181
2182
2183 /******************************************************************************
2184 Everything starts and ends here
2185 ******************************************************************************/
2186
2187 /* pci_driver definition */
2188 static struct pci_driver driver = {
2189 .name = "Echoaudio " ECHOCARD_NAME,
2190 .id_table = snd_echo_ids,
2191 .probe = snd_echo_probe,
2192 .remove = __devexit_p(snd_echo_remove),
2193 };
2194
2195
2196
2197 /* initialization of the module */
2198 static int __init alsa_card_echo_init(void)
2199 {
2200 return pci_register_driver(&driver);
2201 }
2202
2203
2204
2205 /* clean up the module */
2206 static void __exit alsa_card_echo_exit(void)
2207 {
2208 pci_unregister_driver(&driver);
2209 }
2210
2211
2212 module_init(alsa_card_echo_init)
2213 module_exit(alsa_card_echo_exit)
WRT350N Kernel Patches