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