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