?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / sound / pci / echoaudio / echoaudio.c
blob90ec090792ba12c4c22eecb4378744dd14549868
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 mutex_lock(&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 mutex_unlock(&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 mutex_lock(&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 mutex_unlock(&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 mutex_lock(&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 mutex_unlock(&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 mutex_lock(&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 mutex_unlock(&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 #define snd_echo_phantom_power_info snd_ctl_boolean_mono_info
1599
1600 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1601 struct snd_ctl_elem_value *ucontrol)
1602 {
1603 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1604
1605 ucontrol->value.integer.value[0] = chip->phantom_power;
1606 return 0;
1607 }
1608
1609 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1610 struct snd_ctl_elem_value *ucontrol)
1611 {
1612 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1613 int power, changed = 0;
1614
1615 power = !!ucontrol->value.integer.value[0];
1616 if (chip->phantom_power != power) {
1617 spin_lock_irq(&chip->lock);
1618 changed = set_phantom_power(chip, power);
1619 spin_unlock_irq(&chip->lock);
1620 if (changed == 0)
1621 changed = 1; /* no errors */
1622 }
1623 return changed;
1624 }
1625
1626 static struct snd_kcontrol_new snd_echo_phantom_power_switch __devinitdata = {
1627 .name = "Phantom power Switch",
1628 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1629 .info = snd_echo_phantom_power_info,
1630 .get = snd_echo_phantom_power_get,
1631 .put = snd_echo_phantom_power_put,
1632 };
1633
1634 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1635
1636
1637
1638 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1639
1640 /******************* Digital input automute switch *******************/
1641 #define snd_echo_automute_info snd_ctl_boolean_mono_info
1642
1643 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1644 struct snd_ctl_elem_value *ucontrol)
1645 {
1646 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1647
1648 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1649 return 0;
1650 }
1651
1652 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1653 struct snd_ctl_elem_value *ucontrol)
1654 {
1655 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1656 int automute, changed = 0;
1657
1658 automute = !!ucontrol->value.integer.value[0];
1659 if (chip->digital_in_automute != automute) {
1660 spin_lock_irq(&chip->lock);
1661 changed = set_input_auto_mute(chip, automute);
1662 spin_unlock_irq(&chip->lock);
1663 if (changed == 0)
1664 changed = 1; /* no errors */
1665 }
1666 return changed;
1667 }
1668
1669 static struct snd_kcontrol_new snd_echo_automute_switch __devinitdata = {
1670 .name = "Digital Capture Switch (automute)",
1671 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1672 .info = snd_echo_automute_info,
1673 .get = snd_echo_automute_get,
1674 .put = snd_echo_automute_put,
1675 };
1676
1677 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1678
1679
1680
1681 /******************* VU-meters switch *******************/
1682 #define snd_echo_vumeters_switch_info snd_ctl_boolean_mono_info
1683
1684 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1685 struct snd_ctl_elem_value *ucontrol)
1686 {
1687 struct echoaudio *chip;
1688
1689 chip = snd_kcontrol_chip(kcontrol);
1690 spin_lock_irq(&chip->lock);
1691 set_meters_on(chip, ucontrol->value.integer.value[0]);
1692 spin_unlock_irq(&chip->lock);
1693 return 1;
1694 }
1695
1696 static struct snd_kcontrol_new snd_echo_vumeters_switch __devinitdata = {
1697 .name = "VU-meters Switch",
1698 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1699 .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1700 .info = snd_echo_vumeters_switch_info,
1701 .put = snd_echo_vumeters_switch_put,
1702 };
1703
1704
1705
1706 /***** Read VU-meters (input, output, analog and digital together) *****/
1707 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1708 struct snd_ctl_elem_info *uinfo)
1709 {
1710 struct echoaudio *chip;
1711
1712 chip = snd_kcontrol_chip(kcontrol);
1713 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1714 uinfo->count = 96;
1715 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1716 uinfo->value.integer.max = 0;
1717 #ifdef ECHOCARD_HAS_VMIXER
1718 uinfo->dimen.d[0] = 3; /* Out, In, Virt */
1719 #else
1720 uinfo->dimen.d[0] = 2; /* Out, In */
1721 #endif
1722 uinfo->dimen.d[1] = 16; /* 16 channels */
1723 uinfo->dimen.d[2] = 2; /* 0=level, 1=peak */
1724 return 0;
1725 }
1726
1727 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1728 struct snd_ctl_elem_value *ucontrol)
1729 {
1730 struct echoaudio *chip;
1731
1732 chip = snd_kcontrol_chip(kcontrol);
1733 get_audio_meters(chip, ucontrol->value.integer.value);
1734 return 0;
1735 }
1736
1737 static struct snd_kcontrol_new snd_echo_vumeters __devinitdata = {
1738 .name = "VU-meters",
1739 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1740 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1741 SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1742 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1743 .info = snd_echo_vumeters_info,
1744 .get = snd_echo_vumeters_get,
1745 .tlv = {.p = db_scale_output_gain},
1746 };
1747
1748
1749
1750 /*** Channels info - it exports informations about the number of channels ***/
1751 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1752 struct snd_ctl_elem_info *uinfo)
1753 {
1754 struct echoaudio *chip;
1755
1756 chip = snd_kcontrol_chip(kcontrol);
1757 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1758 uinfo->count = 6;
1759 uinfo->value.integer.min = 0;
1760 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1761 return 0;
1762 }
1763
1764 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1765 struct snd_ctl_elem_value *ucontrol)
1766 {
1767 struct echoaudio *chip;
1768 int detected, clocks, bit, src;
1769
1770 chip = snd_kcontrol_chip(kcontrol);
1771 ucontrol->value.integer.value[0] = num_busses_in(chip);
1772 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1773 ucontrol->value.integer.value[2] = num_busses_out(chip);
1774 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1775 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1776
1777 /* Compute the bitmask of the currently valid input clocks */
1778 detected = detect_input_clocks(chip);
1779 clocks = 0;
1780 src = chip->num_clock_sources - 1;
1781 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1782 if (detected & (1 << bit))
1783 for (; src >= 0; src--)
1784 if (bit == chip->clock_source_list[src]) {
1785 clocks |= 1 << src;
1786 break;
1787 }
1788 ucontrol->value.integer.value[5] = clocks;
1789
1790 return 0;
1791 }
1792
1793 static struct snd_kcontrol_new snd_echo_channels_info __devinitdata = {
1794 .name = "Channels info",
1795 .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1796 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1797 .info = snd_echo_channels_info_info,
1798 .get = snd_echo_channels_info_get,
1799 };
1800
1801
1802
1803
1804 /******************************************************************************
1805 IRQ Handler
1806 ******************************************************************************/
1807
1808 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1809 {
1810 struct echoaudio *chip = dev_id;
1811 struct snd_pcm_substream *substream;
1812 int period, ss, st;
1813
1814 spin_lock(&chip->lock);
1815 st = service_irq(chip);
1816 if (st < 0) {
1817 spin_unlock(&chip->lock);
1818 return IRQ_NONE;
1819 }
1820 /* The hardware doesn't tell us which substream caused the irq,
1821 thus we have to check all running substreams. */
1822 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1823 if ((substream = chip->substream[ss])) {
1824 period = pcm_pointer(substream) /
1825 substream->runtime->period_size;
1826 if (period != chip->last_period[ss]) {
1827 chip->last_period[ss] = period;
1828 spin_unlock(&chip->lock);
1829 snd_pcm_period_elapsed(substream);
1830 spin_lock(&chip->lock);
1831 }
1832 }
1833 }
1834 spin_unlock(&chip->lock);
1835
1836 #ifdef ECHOCARD_HAS_MIDI
1837 if (st > 0 && chip->midi_in) {
1838 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1839 DE_MID(("rawmidi_iread=%d\n", st));
1840 }
1841 #endif
1842 return IRQ_HANDLED;
1843 }
1844
1845
1846
1847
1848 /******************************************************************************
1849 Module construction / destruction
1850 ******************************************************************************/
1851
1852 static int snd_echo_free(struct echoaudio *chip)
1853 {
1854 DE_INIT(("Stop DSP...\n"));
1855 if (chip->comm_page) {
1856 rest_in_peace(chip);
1857 snd_dma_free_pages(&chip->commpage_dma_buf);
1858 }
1859 DE_INIT(("Stopped.\n"));
1860
1861 if (chip->irq >= 0)
1862 free_irq(chip->irq, chip);
1863
1864 if (chip->dsp_registers)
1865 iounmap(chip->dsp_registers);
1866
1867 if (chip->iores)
1868 release_and_free_resource(chip->iores);
1869
1870 DE_INIT(("MMIO freed.\n"));
1871
1872 pci_disable_device(chip->pci);
1873
1874 /* release chip data */
1875 kfree(chip);
1876 DE_INIT(("Chip freed.\n"));
1877 return 0;
1878 }
1879
1880
1881
1882 static int snd_echo_dev_free(struct snd_device *device)
1883 {
1884 struct echoaudio *chip = device->device_data;
1885
1886 DE_INIT(("snd_echo_dev_free()...\n"));
1887 return snd_echo_free(chip);
1888 }
1889
1890
1891
1892 /* <--snd_echo_probe() */
1893 static __devinit int snd_echo_create(struct snd_card *card,
1894 struct pci_dev *pci,
1895 struct echoaudio **rchip)
1896 {
1897 struct echoaudio *chip;
1898 int err;
1899 size_t sz;
1900 static struct snd_device_ops ops = {
1901 .dev_free = snd_echo_dev_free,
1902 };
1903
1904 *rchip = NULL;
1905
1906 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1907
1908 if ((err = pci_enable_device(pci)) < 0)
1909 return err;
1910 pci_set_master(pci);
1911
1912 /* allocate a chip-specific data */
1913 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1914 if (!chip) {
1915 pci_disable_device(pci);
1916 return -ENOMEM;
1917 }
1918 DE_INIT(("chip=%p\n", chip));
1919
1920 spin_lock_init(&chip->lock);
1921 chip->card = card;
1922 chip->pci = pci;
1923 chip->irq = -1;
1924
1925 /* PCI resource allocation */
1926 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1927 sz = pci_resource_len(pci, 0);
1928 if (sz > PAGE_SIZE)
1929 sz = PAGE_SIZE; /* We map only the required part */
1930
1931 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1932 ECHOCARD_NAME)) == NULL) {
1933 snd_echo_free(chip);
1934 snd_printk(KERN_ERR "cannot get memory region\n");
1935 return -EBUSY;
1936 }
1937 chip->dsp_registers = (volatile u32 __iomem *)
1938 ioremap_nocache(chip->dsp_registers_phys, sz);
1939
1940 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1941 ECHOCARD_NAME, chip)) {
1942 snd_echo_free(chip);
1943 snd_printk(KERN_ERR "cannot grab irq\n");
1944 return -EBUSY;
1945 }
1946 chip->irq = pci->irq;
1947 DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
1948 chip->pci, chip->irq, chip->pci->subsystem_device));
1949
1950 /* Create the DSP comm page - this is the area of memory used for most
1951 of the communication with the DSP, which accesses it via bus mastering */
1952 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1953 sizeof(struct comm_page),
1954 &chip->commpage_dma_buf) < 0) {
1955 snd_echo_free(chip);
1956 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1957 return -ENOMEM;
1958 }
1959 chip->comm_page_phys = chip->commpage_dma_buf.addr;
1960 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1961
1962 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1963 if (err) {
1964 DE_INIT(("init_hw err=%d\n", err));
1965 snd_echo_free(chip);
1966 return err;
1967 }
1968 DE_INIT(("Card init OK\n"));
1969
1970 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1971 snd_echo_free(chip);
1972 return err;
1973 }
1974 atomic_set(&chip->opencount, 0);
1975 mutex_init(&chip->mode_mutex);
1976 chip->can_set_rate = 1;
1977 *rchip = chip;
1978 /* Init done ! */
1979 return 0;
1980 }
1981
1982
1983
1984 /* constructor */
1985 static int __devinit snd_echo_probe(struct pci_dev *pci,
1986 const struct pci_device_id *pci_id)
1987 {
1988 static int dev;
1989 struct snd_card *card;
1990 struct echoaudio *chip;
1991 char *dsp;
1992 int i, err;
1993
1994 if (dev >= SNDRV_CARDS)
1995 return -ENODEV;
1996 if (!enable[dev]) {
1997 dev++;
1998 return -ENOENT;
1999 }
2000
2001 DE_INIT(("Echoaudio driver starting...\n"));
2002 i = 0;
2003 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2004 if (card == NULL)
2005 return -ENOMEM;
2006
2007 snd_card_set_dev(card, &pci->dev);
2008
2009 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2010 snd_card_free(card);
2011 return err;
2012 }
2013
2014 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2015 strcpy(card->shortname, chip->card_name);
2016
2017 dsp = "56301";
2018 if (pci_id->device == 0x3410)
2019 dsp = "56361";
2020
2021 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2022 card->shortname, pci_id->subdevice & 0x000f, dsp,
2023 chip->dsp_registers_phys, chip->irq);
2024
2025 if ((err = snd_echo_new_pcm(chip)) < 0) {
2026 snd_printk(KERN_ERR "new pcm error %d\n", err);
2027 snd_card_free(card);
2028 return err;
2029 }
2030
2031 #ifdef ECHOCARD_HAS_MIDI
2032 if (chip->has_midi) { /* Some Mia's do not have midi */
2033 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2034 snd_printk(KERN_ERR "new midi error %d\n", err);
2035 snd_card_free(card);
2036 return err;
2037 }
2038 }
2039 #endif
2040
2041 #ifdef ECHOCARD_HAS_VMIXER
2042 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2043 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_output_gain, chip))) < 0)
2044 goto ctl_error;
2045 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2046 goto ctl_error;
2047 #else
2048 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
2049 goto ctl_error;
2050 #endif
2051
2052 #ifdef ECHOCARD_HAS_INPUT_GAIN
2053 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2054 goto ctl_error;
2055 #endif
2056
2057 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2058 if (!chip->hasnt_input_nominal_level)
2059 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2060 goto ctl_error;
2061 #endif
2062
2063 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2064 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2065 goto ctl_error;
2066 #endif
2067
2068 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2069 goto ctl_error;
2070
2071 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2072 goto ctl_error;
2073
2074 #ifdef ECHOCARD_HAS_MONITOR
2075 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2076 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2077 goto ctl_error;
2078 #endif
2079
2080 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2081 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2082 goto ctl_error;
2083 #endif
2084
2085 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2086 goto ctl_error;
2087
2088 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2089 /* Creates a list of available digital modes */
2090 chip->num_digital_modes = 0;
2091 for (i = 0; i < 6; i++)
2092 if (chip->digital_modes & (1 << i))
2093 chip->digital_mode_list[chip->num_digital_modes++] = i;
2094
2095 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2096 goto ctl_error;
2097 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2098
2099 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2100 /* Creates a list of available clock sources */
2101 chip->num_clock_sources = 0;
2102 for (i = 0; i < 10; i++)
2103 if (chip->input_clock_types & (1 << i))
2104 chip->clock_source_list[chip->num_clock_sources++] = i;
2105
2106 if (chip->num_clock_sources > 1) {
2107 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2108 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2109 goto ctl_error;
2110 }
2111 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2112
2113 #ifdef ECHOCARD_HAS_DIGITAL_IO
2114 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2115 goto ctl_error;
2116 #endif
2117
2118 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2119 if (chip->has_phantom_power)
2120 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2121 goto ctl_error;
2122 #endif
2123
2124 if ((err = snd_card_register(card)) < 0) {
2125 snd_card_free(card);
2126 goto ctl_error;
2127 }
2128 snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2129
2130 pci_set_drvdata(pci, chip);
2131 dev++;
2132 return 0;
2133
2134 ctl_error:
2135 snd_printk(KERN_ERR "new control error %d\n", err);
2136 snd_card_free(card);
2137 return err;
2138 }
2139
2140
2141
2142 static void __devexit snd_echo_remove(struct pci_dev *pci)
2143 {
2144 struct echoaudio *chip;
2145
2146 chip = pci_get_drvdata(pci);
2147 if (chip)
2148 snd_card_free(chip->card);
2149 pci_set_drvdata(pci, NULL);
2150 }
2151
2152
2153
2154 /******************************************************************************
2155 Everything starts and ends here
2156 ******************************************************************************/
2157
2158 /* pci_driver definition */
2159 static struct pci_driver driver = {
2160 .name = "Echoaudio " ECHOCARD_NAME,
2161 .id_table = snd_echo_ids,
2162 .probe = snd_echo_probe,
2163 .remove = __devexit_p(snd_echo_remove),
2164 };
2165
2166
2167
2168 /* initialization of the module */
2169 static int __init alsa_card_echo_init(void)
2170 {
2171 return pci_register_driver(&driver);
2172 }
2173
2174
2175
2176 /* clean up the module */
2177 static void __exit alsa_card_echo_exit(void)
2178 {
2179 pci_unregister_driver(&driver);
2180 }
2181
2182
2183 module_init(alsa_card_echo_init)
2184 module_exit(alsa_card_echo_exit)
mah project overlay