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