?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / sound / pci / echoaudio / echoaudio.c
blob8dbc5c4ba421a03dd128050dbd271616efdee3ae
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 /******************* PCM output volume *******************/
954 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
955 struct snd_ctl_elem_info *uinfo)
956 {
957 struct echoaudio *chip;
958
959 chip = snd_kcontrol_chip(kcontrol);
960 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
961 uinfo->count = num_busses_out(chip);
962 uinfo->value.integer.min = ECHOGAIN_MINOUT;
963 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
964 return 0;
965 }
966
967 static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
968 struct snd_ctl_elem_value *ucontrol)
969 {
970 struct echoaudio *chip;
971 int c;
972
973 chip = snd_kcontrol_chip(kcontrol);
974 for (c = 0; c < num_busses_out(chip); c++)
975 ucontrol->value.integer.value[c] = chip->output_gain[c];
976 return 0;
977 }
978
979 static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
980 struct snd_ctl_elem_value *ucontrol)
981 {
982 struct echoaudio *chip;
983 int c, changed, gain;
984
985 changed = 0;
986 chip = snd_kcontrol_chip(kcontrol);
987 spin_lock_irq(&chip->lock);
988 for (c = 0; c < num_busses_out(chip); c++) {
989 gain = ucontrol->value.integer.value[c];
990 /* Ignore out of range values */
991 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
992 continue;
993 if (chip->output_gain[c] != gain) {
994 set_output_gain(chip, c, gain);
995 changed = 1;
996 }
997 }
998 if (changed)
999 update_output_line_level(chip);
1000 spin_unlock_irq(&chip->lock);
1001 return changed;
1002 }
1003
1004 #ifdef ECHOCARD_HAS_VMIXER
1005 /* On Vmixer cards this one controls the line-out volume */
1006 static struct snd_kcontrol_new snd_echo_line_output_gain __devinitdata = {
1007 .name = "Line 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 #else
1016 static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
1017 .name = "PCM Playback Volume",
1018 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1019 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1020 .info = snd_echo_output_gain_info,
1021 .get = snd_echo_output_gain_get,
1022 .put = snd_echo_output_gain_put,
1023 .tlv = {.p = db_scale_output_gain},
1024 };
1025 #endif
1026
1027
1028
1029 #ifdef ECHOCARD_HAS_INPUT_GAIN
1030
1031 /******************* Analog input volume *******************/
1032 static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1033 struct snd_ctl_elem_info *uinfo)
1034 {
1035 struct echoaudio *chip;
1036
1037 chip = snd_kcontrol_chip(kcontrol);
1038 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1039 uinfo->count = num_analog_busses_in(chip);
1040 uinfo->value.integer.min = ECHOGAIN_MININP;
1041 uinfo->value.integer.max = ECHOGAIN_MAXINP;
1042 return 0;
1043 }
1044
1045 static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1046 struct snd_ctl_elem_value *ucontrol)
1047 {
1048 struct echoaudio *chip;
1049 int c;
1050
1051 chip = snd_kcontrol_chip(kcontrol);
1052 for (c = 0; c < num_analog_busses_in(chip); c++)
1053 ucontrol->value.integer.value[c] = chip->input_gain[c];
1054 return 0;
1055 }
1056
1057 static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1058 struct snd_ctl_elem_value *ucontrol)
1059 {
1060 struct echoaudio *chip;
1061 int c, gain, changed;
1062
1063 changed = 0;
1064 chip = snd_kcontrol_chip(kcontrol);
1065 spin_lock_irq(&chip->lock);
1066 for (c = 0; c < num_analog_busses_in(chip); c++) {
1067 gain = ucontrol->value.integer.value[c];
1068 /* Ignore out of range values */
1069 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1070 continue;
1071 if (chip->input_gain[c] != gain) {
1072 set_input_gain(chip, c, gain);
1073 changed = 1;
1074 }
1075 }
1076 if (changed)
1077 update_input_line_level(chip);
1078 spin_unlock_irq(&chip->lock);
1079 return changed;
1080 }
1081
1082 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1083
1084 static struct snd_kcontrol_new snd_echo_line_input_gain __devinitdata = {
1085 .name = "Line Capture Volume",
1086 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1087 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1088 .info = snd_echo_input_gain_info,
1089 .get = snd_echo_input_gain_get,
1090 .put = snd_echo_input_gain_put,
1091 .tlv = {.p = db_scale_input_gain},
1092 };
1093
1094 #endif /* ECHOCARD_HAS_INPUT_GAIN */
1095
1096
1097
1098 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1099
1100 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1101 static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1102 struct snd_ctl_elem_info *uinfo)
1103 {
1104 struct echoaudio *chip;
1105
1106 chip = snd_kcontrol_chip(kcontrol);
1107 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1108 uinfo->count = num_analog_busses_out(chip);
1109 uinfo->value.integer.min = 0;
1110 uinfo->value.integer.max = 1;
1111 return 0;
1112 }
1113
1114 static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1115 struct snd_ctl_elem_value *ucontrol)
1116 {
1117 struct echoaudio *chip;
1118 int c;
1119
1120 chip = snd_kcontrol_chip(kcontrol);
1121 for (c = 0; c < num_analog_busses_out(chip); c++)
1122 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1123 return 0;
1124 }
1125
1126 static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1127 struct snd_ctl_elem_value *ucontrol)
1128 {
1129 struct echoaudio *chip;
1130 int c, changed;
1131
1132 changed = 0;
1133 chip = snd_kcontrol_chip(kcontrol);
1134 spin_lock_irq(&chip->lock);
1135 for (c = 0; c < num_analog_busses_out(chip); c++) {
1136 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1137 set_nominal_level(chip, c,
1138 ucontrol->value.integer.value[c]);
1139 changed = 1;
1140 }
1141 }
1142 if (changed)
1143 update_output_line_level(chip);
1144 spin_unlock_irq(&chip->lock);
1145 return changed;
1146 }
1147
1148 static struct snd_kcontrol_new snd_echo_output_nominal_level __devinitdata = {
1149 .name = "Line Playback Switch (-10dBV)",
1150 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1151 .info = snd_echo_output_nominal_info,
1152 .get = snd_echo_output_nominal_get,
1153 .put = snd_echo_output_nominal_put,
1154 };
1155
1156 #endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1157
1158
1159
1160 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1161
1162 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1163 static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1164 struct snd_ctl_elem_info *uinfo)
1165 {
1166 struct echoaudio *chip;
1167
1168 chip = snd_kcontrol_chip(kcontrol);
1169 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1170 uinfo->count = num_analog_busses_in(chip);
1171 uinfo->value.integer.min = 0;
1172 uinfo->value.integer.max = 1;
1173 return 0;
1174 }
1175
1176 static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1177 struct snd_ctl_elem_value *ucontrol)
1178 {
1179 struct echoaudio *chip;
1180 int c;
1181
1182 chip = snd_kcontrol_chip(kcontrol);
1183 for (c = 0; c < num_analog_busses_in(chip); c++)
1184 ucontrol->value.integer.value[c] =
1185 chip->nominal_level[bx_analog_in(chip) + c];
1186 return 0;
1187 }
1188
1189 static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1190 struct snd_ctl_elem_value *ucontrol)
1191 {
1192 struct echoaudio *chip;
1193 int c, changed;
1194
1195 changed = 0;
1196 chip = snd_kcontrol_chip(kcontrol);
1197 spin_lock_irq(&chip->lock);
1198 for (c = 0; c < num_analog_busses_in(chip); c++) {
1199 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1200 ucontrol->value.integer.value[c]) {
1201 set_nominal_level(chip, bx_analog_in(chip) + c,
1202 ucontrol->value.integer.value[c]);
1203 changed = 1;
1204 }
1205 }
1206 if (changed)
1207 update_output_line_level(chip); /* "Output" is not a mistake
1208 * here.
1209 */
1210 spin_unlock_irq(&chip->lock);
1211 return changed;
1212 }
1213
1214 static struct snd_kcontrol_new snd_echo_intput_nominal_level __devinitdata = {
1215 .name = "Line Capture Switch (-10dBV)",
1216 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1217 .info = snd_echo_input_nominal_info,
1218 .get = snd_echo_input_nominal_get,
1219 .put = snd_echo_input_nominal_put,
1220 };
1221
1222 #endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1223
1224
1225
1226 #ifdef ECHOCARD_HAS_MONITOR
1227
1228 /******************* Monitor mixer *******************/
1229 static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1230 struct snd_ctl_elem_info *uinfo)
1231 {
1232 struct echoaudio *chip;
1233
1234 chip = snd_kcontrol_chip(kcontrol);
1235 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1236 uinfo->count = 1;
1237 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1238 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1239 uinfo->dimen.d[0] = num_busses_out(chip);
1240 uinfo->dimen.d[1] = num_busses_in(chip);
1241 return 0;
1242 }
1243
1244 static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1245 struct snd_ctl_elem_value *ucontrol)
1246 {
1247 struct echoaudio *chip;
1248
1249 chip = snd_kcontrol_chip(kcontrol);
1250 ucontrol->value.integer.value[0] =
1251 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)]
1252 [ucontrol->id.index % num_busses_in(chip)];
1253 return 0;
1254 }
1255
1256 static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1257 struct snd_ctl_elem_value *ucontrol)
1258 {
1259 struct echoaudio *chip;
1260 int changed, gain;
1261 short out, in;
1262
1263 changed = 0;
1264 chip = snd_kcontrol_chip(kcontrol);
1265 out = ucontrol->id.index / num_busses_in(chip);
1266 in = ucontrol->id.index % num_busses_in(chip);
1267 gain = ucontrol->value.integer.value[0];
1268 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1269 return -EINVAL;
1270 if (chip->monitor_gain[out][in] != gain) {
1271 spin_lock_irq(&chip->lock);
1272 set_monitor_gain(chip, out, in, gain);
1273 update_output_line_level(chip);
1274 spin_unlock_irq(&chip->lock);
1275 changed = 1;
1276 }
1277 return changed;
1278 }
1279
1280 static struct snd_kcontrol_new snd_echo_monitor_mixer __devinitdata = {
1281 .name = "Monitor Mixer Volume",
1282 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1283 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1284 .info = snd_echo_mixer_info,
1285 .get = snd_echo_mixer_get,
1286 .put = snd_echo_mixer_put,
1287 .tlv = {.p = db_scale_output_gain},
1288 };
1289
1290 #endif /* ECHOCARD_HAS_MONITOR */
1291
1292
1293
1294 #ifdef ECHOCARD_HAS_VMIXER
1295
1296 /******************* Vmixer *******************/
1297 static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1298 struct snd_ctl_elem_info *uinfo)
1299 {
1300 struct echoaudio *chip;
1301
1302 chip = snd_kcontrol_chip(kcontrol);
1303 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1304 uinfo->count = 1;
1305 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1306 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1307 uinfo->dimen.d[0] = num_busses_out(chip);
1308 uinfo->dimen.d[1] = num_pipes_out(chip);
1309 return 0;
1310 }
1311
1312 static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1313 struct snd_ctl_elem_value *ucontrol)
1314 {
1315 struct echoaudio *chip;
1316
1317 chip = snd_kcontrol_chip(kcontrol);
1318 ucontrol->value.integer.value[0] =
1319 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1320 [ucontrol->id.index % num_pipes_out(chip)];
1321 return 0;
1322 }
1323
1324 static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1325 struct snd_ctl_elem_value *ucontrol)
1326 {
1327 struct echoaudio *chip;
1328 int gain, changed;
1329 short vch, out;
1330
1331 changed = 0;
1332 chip = snd_kcontrol_chip(kcontrol);
1333 out = ucontrol->id.index / num_pipes_out(chip);
1334 vch = ucontrol->id.index % num_pipes_out(chip);
1335 gain = ucontrol->value.integer.value[0];
1336 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1337 return -EINVAL;
1338 if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1339 spin_lock_irq(&chip->lock);
1340 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1341 update_vmixer_level(chip);
1342 spin_unlock_irq(&chip->lock);
1343 changed = 1;
1344 }
1345 return changed;
1346 }
1347
1348 static struct snd_kcontrol_new snd_echo_vmixer __devinitdata = {
1349 .name = "VMixer Volume",
1350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1351 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1352 .info = snd_echo_vmixer_info,
1353 .get = snd_echo_vmixer_get,
1354 .put = snd_echo_vmixer_put,
1355 .tlv = {.p = db_scale_output_gain},
1356 };
1357
1358 #endif /* ECHOCARD_HAS_VMIXER */
1359
1360
1361
1362 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1363
1364 /******************* Digital mode switch *******************/
1365 static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1366 struct snd_ctl_elem_info *uinfo)
1367 {
1368 static char *names[4] = {
1369 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1370 "S/PDIF Cdrom"
1371 };
1372 struct echoaudio *chip;
1373
1374 chip = snd_kcontrol_chip(kcontrol);
1375 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1376 uinfo->value.enumerated.items = chip->num_digital_modes;
1377 uinfo->count = 1;
1378 if (uinfo->value.enumerated.item >= chip->num_digital_modes)
1379 uinfo->value.enumerated.item = chip->num_digital_modes - 1;
1380 strcpy(uinfo->value.enumerated.name, names[
1381 chip->digital_mode_list[uinfo->value.enumerated.item]]);
1382 return 0;
1383 }
1384
1385 static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1386 struct snd_ctl_elem_value *ucontrol)
1387 {
1388 struct echoaudio *chip;
1389 int i, mode;
1390
1391 chip = snd_kcontrol_chip(kcontrol);
1392 mode = chip->digital_mode;
1393 for (i = chip->num_digital_modes - 1; i >= 0; i--)
1394 if (mode == chip->digital_mode_list[i]) {
1395 ucontrol->value.enumerated.item[0] = i;
1396 break;
1397 }
1398 return 0;
1399 }
1400
1401 static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1402 struct snd_ctl_elem_value *ucontrol)
1403 {
1404 struct echoaudio *chip;
1405 int changed;
1406 unsigned short emode, dmode;
1407
1408 changed = 0;
1409 chip = snd_kcontrol_chip(kcontrol);
1410
1411 emode = ucontrol->value.enumerated.item[0];
1412 if (emode >= chip->num_digital_modes)
1413 return -EINVAL;
1414 dmode = chip->digital_mode_list[emode];
1415
1416 if (dmode != chip->digital_mode) {
1417 /* mode_mutex is required to make this operation atomic wrt
1418 pcm_digital_*_open() and set_input_clock() functions. */
1419 mutex_lock(&chip->mode_mutex);
1420
1421 /* Do not allow the user to change the digital mode when a pcm
1422 device is open because it also changes the number of channels
1423 and the allowed sample rates */
1424 if (atomic_read(&chip->opencount)) {
1425 changed = -EAGAIN;
1426 } else {
1427 changed = set_digital_mode(chip, dmode);
1428 /* If we had to change the clock source, report it */
1429 if (changed > 0 && chip->clock_src_ctl) {
1430 snd_ctl_notify(chip->card,
1431 SNDRV_CTL_EVENT_MASK_VALUE,
1432 &chip->clock_src_ctl->id);
1433 DE_ACT(("SDM() =%d\n", changed));
1434 }
1435 if (changed >= 0)
1436 changed = 1; /* No errors */
1437 }
1438 mutex_unlock(&chip->mode_mutex);
1439 }
1440 return changed;
1441 }
1442
1443 static struct snd_kcontrol_new snd_echo_digital_mode_switch __devinitdata = {
1444 .name = "Digital mode Switch",
1445 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1446 .info = snd_echo_digital_mode_info,
1447 .get = snd_echo_digital_mode_get,
1448 .put = snd_echo_digital_mode_put,
1449 };
1450
1451 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1452
1453
1454
1455 #ifdef ECHOCARD_HAS_DIGITAL_IO
1456
1457 /******************* S/PDIF mode switch *******************/
1458 static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1459 struct snd_ctl_elem_info *uinfo)
1460 {
1461 static char *names[2] = {"Consumer", "Professional"};
1462
1463 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1464 uinfo->value.enumerated.items = 2;
1465 uinfo->count = 1;
1466 if (uinfo->value.enumerated.item)
1467 uinfo->value.enumerated.item = 1;
1468 strcpy(uinfo->value.enumerated.name,
1469 names[uinfo->value.enumerated.item]);
1470 return 0;
1471 }
1472
1473 static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1474 struct snd_ctl_elem_value *ucontrol)
1475 {
1476 struct echoaudio *chip;
1477
1478 chip = snd_kcontrol_chip(kcontrol);
1479 ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1480 return 0;
1481 }
1482
1483 static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1484 struct snd_ctl_elem_value *ucontrol)
1485 {
1486 struct echoaudio *chip;
1487 int mode;
1488
1489 chip = snd_kcontrol_chip(kcontrol);
1490 mode = !!ucontrol->value.enumerated.item[0];
1491 if (mode != chip->professional_spdif) {
1492 spin_lock_irq(&chip->lock);
1493 set_professional_spdif(chip, mode);
1494 spin_unlock_irq(&chip->lock);
1495 return 1;
1496 }
1497 return 0;
1498 }
1499
1500 static struct snd_kcontrol_new snd_echo_spdif_mode_switch __devinitdata = {
1501 .name = "S/PDIF mode Switch",
1502 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1503 .info = snd_echo_spdif_mode_info,
1504 .get = snd_echo_spdif_mode_get,
1505 .put = snd_echo_spdif_mode_put,
1506 };
1507
1508 #endif /* ECHOCARD_HAS_DIGITAL_IO */
1509
1510
1511
1512 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1513
1514 /******************* Select input clock source *******************/
1515 static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1516 struct snd_ctl_elem_info *uinfo)
1517 {
1518 static char *names[8] = {
1519 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1520 "ESync96", "MTC"
1521 };
1522 struct echoaudio *chip;
1523
1524 chip = snd_kcontrol_chip(kcontrol);
1525 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1526 uinfo->value.enumerated.items = chip->num_clock_sources;
1527 uinfo->count = 1;
1528 if (uinfo->value.enumerated.item >= chip->num_clock_sources)
1529 uinfo->value.enumerated.item = chip->num_clock_sources - 1;
1530 strcpy(uinfo->value.enumerated.name, names[
1531 chip->clock_source_list[uinfo->value.enumerated.item]]);
1532 return 0;
1533 }
1534
1535 static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1536 struct snd_ctl_elem_value *ucontrol)
1537 {
1538 struct echoaudio *chip;
1539 int i, clock;
1540
1541 chip = snd_kcontrol_chip(kcontrol);
1542 clock = chip->input_clock;
1543
1544 for (i = 0; i < chip->num_clock_sources; i++)
1545 if (clock == chip->clock_source_list[i])
1546 ucontrol->value.enumerated.item[0] = i;
1547
1548 return 0;
1549 }
1550
1551 static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1552 struct snd_ctl_elem_value *ucontrol)
1553 {
1554 struct echoaudio *chip;
1555 int changed;
1556 unsigned int eclock, dclock;
1557
1558 changed = 0;
1559 chip = snd_kcontrol_chip(kcontrol);
1560 eclock = ucontrol->value.enumerated.item[0];
1561 if (eclock >= chip->input_clock_types)
1562 return -EINVAL;
1563 dclock = chip->clock_source_list[eclock];
1564 if (chip->input_clock != dclock) {
1565 mutex_lock(&chip->mode_mutex);
1566 spin_lock_irq(&chip->lock);
1567 if ((changed = set_input_clock(chip, dclock)) == 0)
1568 changed = 1; /* no errors */
1569 spin_unlock_irq(&chip->lock);
1570 mutex_unlock(&chip->mode_mutex);
1571 }
1572
1573 if (changed < 0)
1574 DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed));
1575
1576 return changed;
1577 }
1578
1579 static struct snd_kcontrol_new snd_echo_clock_source_switch __devinitdata = {
1580 .name = "Sample Clock Source",
1581 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1582 .info = snd_echo_clock_source_info,
1583 .get = snd_echo_clock_source_get,
1584 .put = snd_echo_clock_source_put,
1585 };
1586
1587 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1588
1589
1590
1591 #ifdef ECHOCARD_HAS_PHANTOM_POWER
1592
1593 /******************* Phantom power switch *******************/
1594 #define snd_echo_phantom_power_info snd_ctl_boolean_mono_info
1595
1596 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1597 struct snd_ctl_elem_value *ucontrol)
1598 {
1599 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1600
1601 ucontrol->value.integer.value[0] = chip->phantom_power;
1602 return 0;
1603 }
1604
1605 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1606 struct snd_ctl_elem_value *ucontrol)
1607 {
1608 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1609 int power, changed = 0;
1610
1611 power = !!ucontrol->value.integer.value[0];
1612 if (chip->phantom_power != power) {
1613 spin_lock_irq(&chip->lock);
1614 changed = set_phantom_power(chip, power);
1615 spin_unlock_irq(&chip->lock);
1616 if (changed == 0)
1617 changed = 1; /* no errors */
1618 }
1619 return changed;
1620 }
1621
1622 static struct snd_kcontrol_new snd_echo_phantom_power_switch __devinitdata = {
1623 .name = "Phantom power Switch",
1624 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1625 .info = snd_echo_phantom_power_info,
1626 .get = snd_echo_phantom_power_get,
1627 .put = snd_echo_phantom_power_put,
1628 };
1629
1630 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1631
1632
1633
1634 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1635
1636 /******************* Digital input automute switch *******************/
1637 #define snd_echo_automute_info snd_ctl_boolean_mono_info
1638
1639 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1640 struct snd_ctl_elem_value *ucontrol)
1641 {
1642 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1643
1644 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1645 return 0;
1646 }
1647
1648 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1649 struct snd_ctl_elem_value *ucontrol)
1650 {
1651 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1652 int automute, changed = 0;
1653
1654 automute = !!ucontrol->value.integer.value[0];
1655 if (chip->digital_in_automute != automute) {
1656 spin_lock_irq(&chip->lock);
1657 changed = set_input_auto_mute(chip, automute);
1658 spin_unlock_irq(&chip->lock);
1659 if (changed == 0)
1660 changed = 1; /* no errors */
1661 }
1662 return changed;
1663 }
1664
1665 static struct snd_kcontrol_new snd_echo_automute_switch __devinitdata = {
1666 .name = "Digital Capture Switch (automute)",
1667 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1668 .info = snd_echo_automute_info,
1669 .get = snd_echo_automute_get,
1670 .put = snd_echo_automute_put,
1671 };
1672
1673 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1674
1675
1676
1677 /******************* VU-meters switch *******************/
1678 #define snd_echo_vumeters_switch_info snd_ctl_boolean_mono_info
1679
1680 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1681 struct snd_ctl_elem_value *ucontrol)
1682 {
1683 struct echoaudio *chip;
1684
1685 chip = snd_kcontrol_chip(kcontrol);
1686 spin_lock_irq(&chip->lock);
1687 set_meters_on(chip, ucontrol->value.integer.value[0]);
1688 spin_unlock_irq(&chip->lock);
1689 return 1;
1690 }
1691
1692 static struct snd_kcontrol_new snd_echo_vumeters_switch __devinitdata = {
1693 .name = "VU-meters Switch",
1694 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1695 .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1696 .info = snd_echo_vumeters_switch_info,
1697 .put = snd_echo_vumeters_switch_put,
1698 };
1699
1700
1701
1702 /***** Read VU-meters (input, output, analog and digital together) *****/
1703 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1704 struct snd_ctl_elem_info *uinfo)
1705 {
1706 struct echoaudio *chip;
1707
1708 chip = snd_kcontrol_chip(kcontrol);
1709 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1710 uinfo->count = 96;
1711 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1712 uinfo->value.integer.max = 0;
1713 #ifdef ECHOCARD_HAS_VMIXER
1714 uinfo->dimen.d[0] = 3; /* Out, In, Virt */
1715 #else
1716 uinfo->dimen.d[0] = 2; /* Out, In */
1717 #endif
1718 uinfo->dimen.d[1] = 16; /* 16 channels */
1719 uinfo->dimen.d[2] = 2; /* 0=level, 1=peak */
1720 return 0;
1721 }
1722
1723 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1724 struct snd_ctl_elem_value *ucontrol)
1725 {
1726 struct echoaudio *chip;
1727
1728 chip = snd_kcontrol_chip(kcontrol);
1729 get_audio_meters(chip, ucontrol->value.integer.value);
1730 return 0;
1731 }
1732
1733 static struct snd_kcontrol_new snd_echo_vumeters __devinitdata = {
1734 .name = "VU-meters",
1735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1736 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1737 SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1738 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1739 .info = snd_echo_vumeters_info,
1740 .get = snd_echo_vumeters_get,
1741 .tlv = {.p = db_scale_output_gain},
1742 };
1743
1744
1745
1746 /*** Channels info - it exports informations about the number of channels ***/
1747 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1748 struct snd_ctl_elem_info *uinfo)
1749 {
1750 struct echoaudio *chip;
1751
1752 chip = snd_kcontrol_chip(kcontrol);
1753 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1754 uinfo->count = 6;
1755 uinfo->value.integer.min = 0;
1756 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1757 return 0;
1758 }
1759
1760 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1761 struct snd_ctl_elem_value *ucontrol)
1762 {
1763 struct echoaudio *chip;
1764 int detected, clocks, bit, src;
1765
1766 chip = snd_kcontrol_chip(kcontrol);
1767 ucontrol->value.integer.value[0] = num_busses_in(chip);
1768 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1769 ucontrol->value.integer.value[2] = num_busses_out(chip);
1770 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1771 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1772
1773 /* Compute the bitmask of the currently valid input clocks */
1774 detected = detect_input_clocks(chip);
1775 clocks = 0;
1776 src = chip->num_clock_sources - 1;
1777 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1778 if (detected & (1 << bit))
1779 for (; src >= 0; src--)
1780 if (bit == chip->clock_source_list[src]) {
1781 clocks |= 1 << src;
1782 break;
1783 }
1784 ucontrol->value.integer.value[5] = clocks;
1785
1786 return 0;
1787 }
1788
1789 static struct snd_kcontrol_new snd_echo_channels_info __devinitdata = {
1790 .name = "Channels info",
1791 .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1792 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1793 .info = snd_echo_channels_info_info,
1794 .get = snd_echo_channels_info_get,
1795 };
1796
1797
1798
1799
1800 /******************************************************************************
1801 IRQ Handler
1802 ******************************************************************************/
1803
1804 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1805 {
1806 struct echoaudio *chip = dev_id;
1807 struct snd_pcm_substream *substream;
1808 int period, ss, st;
1809
1810 spin_lock(&chip->lock);
1811 st = service_irq(chip);
1812 if (st < 0) {
1813 spin_unlock(&chip->lock);
1814 return IRQ_NONE;
1815 }
1816 /* The hardware doesn't tell us which substream caused the irq,
1817 thus we have to check all running substreams. */
1818 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1819 if ((substream = chip->substream[ss])) {
1820 period = pcm_pointer(substream) /
1821 substream->runtime->period_size;
1822 if (period != chip->last_period[ss]) {
1823 chip->last_period[ss] = period;
1824 spin_unlock(&chip->lock);
1825 snd_pcm_period_elapsed(substream);
1826 spin_lock(&chip->lock);
1827 }
1828 }
1829 }
1830 spin_unlock(&chip->lock);
1831
1832 #ifdef ECHOCARD_HAS_MIDI
1833 if (st > 0 && chip->midi_in) {
1834 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1835 DE_MID(("rawmidi_iread=%d\n", st));
1836 }
1837 #endif
1838 return IRQ_HANDLED;
1839 }
1840
1841
1842
1843
1844 /******************************************************************************
1845 Module construction / destruction
1846 ******************************************************************************/
1847
1848 static int snd_echo_free(struct echoaudio *chip)
1849 {
1850 DE_INIT(("Stop DSP...\n"));
1851 if (chip->comm_page)
1852 rest_in_peace(chip);
1853 DE_INIT(("Stopped.\n"));
1854
1855 if (chip->irq >= 0)
1856 free_irq(chip->irq, chip);
1857
1858 if (chip->comm_page)
1859 snd_dma_free_pages(&chip->commpage_dma_buf);
1860
1861 if (chip->dsp_registers)
1862 iounmap(chip->dsp_registers);
1863
1864 if (chip->iores)
1865 release_and_free_resource(chip->iores);
1866
1867 DE_INIT(("MMIO freed.\n"));
1868
1869 pci_disable_device(chip->pci);
1870
1871 /* release chip data */
1872 kfree(chip);
1873 DE_INIT(("Chip freed.\n"));
1874 return 0;
1875 }
1876
1877
1878
1879 static int snd_echo_dev_free(struct snd_device *device)
1880 {
1881 struct echoaudio *chip = device->device_data;
1882
1883 DE_INIT(("snd_echo_dev_free()...\n"));
1884 return snd_echo_free(chip);
1885 }
1886
1887
1888
1889 /* <--snd_echo_probe() */
1890 static __devinit int snd_echo_create(struct snd_card *card,
1891 struct pci_dev *pci,
1892 struct echoaudio **rchip)
1893 {
1894 struct echoaudio *chip;
1895 int err;
1896 size_t sz;
1897 static struct snd_device_ops ops = {
1898 .dev_free = snd_echo_dev_free,
1899 };
1900
1901 *rchip = NULL;
1902
1903 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1904
1905 if ((err = pci_enable_device(pci)) < 0)
1906 return err;
1907 pci_set_master(pci);
1908
1909 /* allocate a chip-specific data */
1910 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1911 if (!chip) {
1912 pci_disable_device(pci);
1913 return -ENOMEM;
1914 }
1915 DE_INIT(("chip=%p\n", chip));
1916
1917 spin_lock_init(&chip->lock);
1918 chip->card = card;
1919 chip->pci = pci;
1920 chip->irq = -1;
1921
1922 /* PCI resource allocation */
1923 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1924 sz = pci_resource_len(pci, 0);
1925 if (sz > PAGE_SIZE)
1926 sz = PAGE_SIZE; /* We map only the required part */
1927
1928 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1929 ECHOCARD_NAME)) == NULL) {
1930 snd_echo_free(chip);
1931 snd_printk(KERN_ERR "cannot get memory region\n");
1932 return -EBUSY;
1933 }
1934 chip->dsp_registers = (volatile u32 __iomem *)
1935 ioremap_nocache(chip->dsp_registers_phys, sz);
1936
1937 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1938 ECHOCARD_NAME, chip)) {
1939 snd_echo_free(chip);
1940 snd_printk(KERN_ERR "cannot grab irq\n");
1941 return -EBUSY;
1942 }
1943 chip->irq = pci->irq;
1944 DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
1945 chip->pci, chip->irq, chip->pci->subsystem_device));
1946
1947 /* Create the DSP comm page - this is the area of memory used for most
1948 of the communication with the DSP, which accesses it via bus mastering */
1949 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1950 sizeof(struct comm_page),
1951 &chip->commpage_dma_buf) < 0) {
1952 snd_echo_free(chip);
1953 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1954 return -ENOMEM;
1955 }
1956 chip->comm_page_phys = chip->commpage_dma_buf.addr;
1957 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1958
1959 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1960 if (err) {
1961 DE_INIT(("init_hw err=%d\n", err));
1962 snd_echo_free(chip);
1963 return err;
1964 }
1965 DE_INIT(("Card init OK\n"));
1966
1967 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1968 snd_echo_free(chip);
1969 return err;
1970 }
1971 atomic_set(&chip->opencount, 0);
1972 mutex_init(&chip->mode_mutex);
1973 chip->can_set_rate = 1;
1974 *rchip = chip;
1975 /* Init done ! */
1976 return 0;
1977 }
1978
1979
1980
1981 /* constructor */
1982 static int __devinit snd_echo_probe(struct pci_dev *pci,
1983 const struct pci_device_id *pci_id)
1984 {
1985 static int dev;
1986 struct snd_card *card;
1987 struct echoaudio *chip;
1988 char *dsp;
1989 int i, err;
1990
1991 if (dev >= SNDRV_CARDS)
1992 return -ENODEV;
1993 if (!enable[dev]) {
1994 dev++;
1995 return -ENOENT;
1996 }
1997
1998 DE_INIT(("Echoaudio driver starting...\n"));
1999 i = 0;
2000 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2001 if (card == NULL)
2002 return -ENOMEM;
2003
2004 snd_card_set_dev(card, &pci->dev);
2005
2006 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2007 snd_card_free(card);
2008 return err;
2009 }
2010
2011 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2012 strcpy(card->shortname, chip->card_name);
2013
2014 dsp = "56301";
2015 if (pci_id->device == 0x3410)
2016 dsp = "56361";
2017
2018 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2019 card->shortname, pci_id->subdevice & 0x000f, dsp,
2020 chip->dsp_registers_phys, chip->irq);
2021
2022 if ((err = snd_echo_new_pcm(chip)) < 0) {
2023 snd_printk(KERN_ERR "new pcm error %d\n", err);
2024 snd_card_free(card);
2025 return err;
2026 }
2027
2028 #ifdef ECHOCARD_HAS_MIDI
2029 if (chip->has_midi) { /* Some Mia's do not have midi */
2030 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2031 snd_printk(KERN_ERR "new midi error %d\n", err);
2032 snd_card_free(card);
2033 return err;
2034 }
2035 }
2036 #endif
2037
2038 #ifdef ECHOCARD_HAS_VMIXER
2039 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2040 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_output_gain, chip))) < 0)
2041 goto ctl_error;
2042 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2043 goto ctl_error;
2044 #else
2045 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
2046 goto ctl_error;
2047 #endif
2048
2049 #ifdef ECHOCARD_HAS_INPUT_GAIN
2050 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2051 goto ctl_error;
2052 #endif
2053
2054 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2055 if (!chip->hasnt_input_nominal_level)
2056 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2057 goto ctl_error;
2058 #endif
2059
2060 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2061 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2062 goto ctl_error;
2063 #endif
2064
2065 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2066 goto ctl_error;
2067
2068 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2069 goto ctl_error;
2070
2071 #ifdef ECHOCARD_HAS_MONITOR
2072 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2073 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2074 goto ctl_error;
2075 #endif
2076
2077 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2078 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2079 goto ctl_error;
2080 #endif
2081
2082 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2083 goto ctl_error;
2084
2085 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2086 /* Creates a list of available digital modes */
2087 chip->num_digital_modes = 0;
2088 for (i = 0; i < 6; i++)
2089 if (chip->digital_modes & (1 << i))
2090 chip->digital_mode_list[chip->num_digital_modes++] = i;
2091
2092 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2093 goto ctl_error;
2094 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2095
2096 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2097 /* Creates a list of available clock sources */
2098 chip->num_clock_sources = 0;
2099 for (i = 0; i < 10; i++)
2100 if (chip->input_clock_types & (1 << i))
2101 chip->clock_source_list[chip->num_clock_sources++] = i;
2102
2103 if (chip->num_clock_sources > 1) {
2104 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2105 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2106 goto ctl_error;
2107 }
2108 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2109
2110 #ifdef ECHOCARD_HAS_DIGITAL_IO
2111 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2112 goto ctl_error;
2113 #endif
2114
2115 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2116 if (chip->has_phantom_power)
2117 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2118 goto ctl_error;
2119 #endif
2120
2121 if ((err = snd_card_register(card)) < 0) {
2122 snd_card_free(card);
2123 goto ctl_error;
2124 }
2125 snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2126
2127 pci_set_drvdata(pci, chip);
2128 dev++;
2129 return 0;
2130
2131 ctl_error:
2132 snd_printk(KERN_ERR "new control error %d\n", err);
2133 snd_card_free(card);
2134 return err;
2135 }
2136
2137
2138
2139 static void __devexit snd_echo_remove(struct pci_dev *pci)
2140 {
2141 struct echoaudio *chip;
2142
2143 chip = pci_get_drvdata(pci);
2144 if (chip)
2145 snd_card_free(chip->card);
2146 pci_set_drvdata(pci, NULL);
2147 }
2148
2149
2150
2151 /******************************************************************************
2152 Everything starts and ends here
2153 ******************************************************************************/
2154
2155 /* pci_driver definition */
2156 static struct pci_driver driver = {
2157 .name = "Echoaudio " ECHOCARD_NAME,
2158 .id_table = snd_echo_ids,
2159 .probe = snd_echo_probe,
2160 .remove = __devexit_p(snd_echo_remove),
2161 };
2162
2163
2164
2165 /* initialization of the module */
2166 static int __init alsa_card_echo_init(void)
2167 {
2168 return pci_register_driver(&driver);
2169 }
2170
2171
2172
2173 /* clean up the module */
2174 static void __exit alsa_card_echo_exit(void)
2175 {
2176 pci_unregister_driver(&driver);
2177 }
2178
2179
2180 module_init(alsa_card_echo_init)
2181 module_exit(alsa_card_echo_exit)
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK