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