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