?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
powerpc/64: Copy as much as possible in __copy_tofrom_user
[linux/fpc-iii.git] / sound / pci / echoaudio / echoaudio.c
blob358ef7dcf4105f2a20666d4da87362ba0af2e0db
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, &chip->pci->dev);
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 audiopipe *pipe;
740 int i, err;
741 u32 channelmask = 0;
742 struct snd_pcm_substream *s;
743
744 snd_pcm_group_for_each_entry(s, substream) {
745 for (i = 0; i < DSP_MAXPIPES; i++) {
746 if (s == chip->substream[i]) {
747 channelmask |= 1 << i;
748 snd_pcm_trigger_done(s, substream);
749 }
750 }
751 }
752
753 spin_lock(&chip->lock);
754 switch (cmd) {
755 case SNDRV_PCM_TRIGGER_RESUME:
756 case SNDRV_PCM_TRIGGER_START:
757 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
758 for (i = 0; i < DSP_MAXPIPES; i++) {
759 if (channelmask & (1 << i)) {
760 pipe = chip->substream[i]->runtime->private_data;
761 switch (pipe->state) {
762 case PIPE_STATE_STOPPED:
763 chip->last_period[i] = 0;
764 pipe->last_counter = 0;
765 pipe->position = 0;
766 *pipe->dma_counter = 0;
767 case PIPE_STATE_PAUSED:
768 pipe->state = PIPE_STATE_STARTED;
769 break;
770 case PIPE_STATE_STARTED:
771 break;
772 }
773 }
774 }
775 err = start_transport(chip, channelmask,
776 chip->pipe_cyclic_mask);
777 break;
778 case SNDRV_PCM_TRIGGER_SUSPEND:
779 case SNDRV_PCM_TRIGGER_STOP:
780 for (i = 0; i < DSP_MAXPIPES; i++) {
781 if (channelmask & (1 << i)) {
782 pipe = chip->substream[i]->runtime->private_data;
783 pipe->state = PIPE_STATE_STOPPED;
784 }
785 }
786 err = stop_transport(chip, channelmask);
787 break;
788 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
789 for (i = 0; i < DSP_MAXPIPES; i++) {
790 if (channelmask & (1 << i)) {
791 pipe = chip->substream[i]->runtime->private_data;
792 pipe->state = PIPE_STATE_PAUSED;
793 }
794 }
795 err = pause_transport(chip, channelmask);
796 break;
797 default:
798 err = -EINVAL;
799 }
800 spin_unlock(&chip->lock);
801 return err;
802 }
803
804
805
806 static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
807 {
808 struct snd_pcm_runtime *runtime = substream->runtime;
809 struct audiopipe *pipe = runtime->private_data;
810 size_t cnt, bufsize, pos;
811
812 cnt = le32_to_cpu(*pipe->dma_counter);
813 pipe->position += cnt - pipe->last_counter;
814 pipe->last_counter = cnt;
815 bufsize = substream->runtime->buffer_size;
816 pos = bytes_to_frames(substream->runtime, pipe->position);
817
818 while (pos >= bufsize) {
819 pipe->position -= frames_to_bytes(substream->runtime, bufsize);
820 pos -= bufsize;
821 }
822 return pos;
823 }
824
825
826
827 /* pcm *_ops structures */
828 static const struct snd_pcm_ops analog_playback_ops = {
829 .open = pcm_analog_out_open,
830 .close = pcm_close,
831 .ioctl = snd_pcm_lib_ioctl,
832 .hw_params = pcm_analog_out_hw_params,
833 .hw_free = pcm_hw_free,
834 .prepare = pcm_prepare,
835 .trigger = pcm_trigger,
836 .pointer = pcm_pointer,
837 .page = snd_pcm_sgbuf_ops_page,
838 };
839 static const struct snd_pcm_ops analog_capture_ops = {
840 .open = pcm_analog_in_open,
841 .close = pcm_close,
842 .ioctl = snd_pcm_lib_ioctl,
843 .hw_params = pcm_analog_in_hw_params,
844 .hw_free = pcm_hw_free,
845 .prepare = pcm_prepare,
846 .trigger = pcm_trigger,
847 .pointer = pcm_pointer,
848 .page = snd_pcm_sgbuf_ops_page,
849 };
850 #ifdef ECHOCARD_HAS_DIGITAL_IO
851 #ifndef ECHOCARD_HAS_VMIXER
852 static const struct snd_pcm_ops digital_playback_ops = {
853 .open = pcm_digital_out_open,
854 .close = pcm_close,
855 .ioctl = snd_pcm_lib_ioctl,
856 .hw_params = pcm_digital_out_hw_params,
857 .hw_free = pcm_hw_free,
858 .prepare = pcm_prepare,
859 .trigger = pcm_trigger,
860 .pointer = pcm_pointer,
861 .page = snd_pcm_sgbuf_ops_page,
862 };
863 #endif /* !ECHOCARD_HAS_VMIXER */
864 static const struct snd_pcm_ops digital_capture_ops = {
865 .open = pcm_digital_in_open,
866 .close = pcm_close,
867 .ioctl = snd_pcm_lib_ioctl,
868 .hw_params = pcm_digital_in_hw_params,
869 .hw_free = pcm_hw_free,
870 .prepare = pcm_prepare,
871 .trigger = pcm_trigger,
872 .pointer = pcm_pointer,
873 .page = snd_pcm_sgbuf_ops_page,
874 };
875 #endif /* ECHOCARD_HAS_DIGITAL_IO */
876
877
878
879 /* Preallocate memory only for the first substream because it's the most
880 * used one
881 */
882 static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
883 {
884 struct snd_pcm_substream *ss;
885 int stream, err;
886
887 for (stream = 0; stream < 2; stream++)
888 for (ss = pcm->streams[stream].substream; ss; ss = ss->next) {
889 err = snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
890 dev,
891 ss->number ? 0 : 128<<10,
892 256<<10);
893 if (err < 0)
894 return err;
895 }
896 return 0;
897 }
898
899
900
901 /*<--snd_echo_probe() */
902 static int snd_echo_new_pcm(struct echoaudio *chip)
903 {
904 struct snd_pcm *pcm;
905 int err;
906
907 #ifdef ECHOCARD_HAS_VMIXER
908 /* This card has a Vmixer, that is there is no direct mapping from PCM
909 streams to physical outputs. The user can mix the streams as he wishes
910 via control interface and it's possible to send any stream to any
911 output, thus it makes no sense to keep analog and digital outputs
912 separated */
913
914 /* PCM#0 Virtual outputs and analog inputs */
915 if ((err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
916 num_analog_busses_in(chip), &pcm)) < 0)
917 return err;
918 pcm->private_data = chip;
919 chip->analog_pcm = pcm;
920 strcpy(pcm->name, chip->card->shortname);
921 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
922 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
923 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
924 return err;
925
926 #ifdef ECHOCARD_HAS_DIGITAL_IO
927 /* PCM#1 Digital inputs, no outputs */
928 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
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_CAPTURE, &digital_capture_ops);
935 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
936 return err;
937 #endif /* ECHOCARD_HAS_DIGITAL_IO */
938
939 #else /* ECHOCARD_HAS_VMIXER */
940
941 /* The card can manage substreams formed by analog and digital channels
942 at the same time, but I prefer to keep analog and digital channels
943 separated, because that mixed thing is confusing and useless. So we
944 register two PCM devices: */
945
946 /* PCM#0 Analog i/o */
947 if ((err = snd_pcm_new(chip->card, "Analog PCM", 0,
948 num_analog_busses_out(chip),
949 num_analog_busses_in(chip), &pcm)) < 0)
950 return err;
951 pcm->private_data = chip;
952 chip->analog_pcm = pcm;
953 strcpy(pcm->name, chip->card->shortname);
954 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
955 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
956 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
957 return err;
958
959 #ifdef ECHOCARD_HAS_DIGITAL_IO
960 /* PCM#1 Digital i/o */
961 if ((err = snd_pcm_new(chip->card, "Digital PCM", 1,
962 num_digital_busses_out(chip),
963 num_digital_busses_in(chip), &pcm)) < 0)
964 return err;
965 pcm->private_data = chip;
966 chip->digital_pcm = pcm;
967 strcpy(pcm->name, chip->card->shortname);
968 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
969 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
970 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
971 return err;
972 #endif /* ECHOCARD_HAS_DIGITAL_IO */
973
974 #endif /* ECHOCARD_HAS_VMIXER */
975
976 return 0;
977 }
978
979
980
981
982 /******************************************************************************
983 Control interface
984 ******************************************************************************/
985
986 #if !defined(ECHOCARD_HAS_VMIXER) || defined(ECHOCARD_HAS_LINE_OUT_GAIN)
987
988 /******************* PCM output volume *******************/
989 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
990 struct snd_ctl_elem_info *uinfo)
991 {
992 struct echoaudio *chip;
993
994 chip = snd_kcontrol_chip(kcontrol);
995 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
996 uinfo->count = num_busses_out(chip);
997 uinfo->value.integer.min = ECHOGAIN_MINOUT;
998 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
999 return 0;
1000 }
1001
1002 static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
1003 struct snd_ctl_elem_value *ucontrol)
1004 {
1005 struct echoaudio *chip;
1006 int c;
1007
1008 chip = snd_kcontrol_chip(kcontrol);
1009 for (c = 0; c < num_busses_out(chip); c++)
1010 ucontrol->value.integer.value[c] = chip->output_gain[c];
1011 return 0;
1012 }
1013
1014 static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
1015 struct snd_ctl_elem_value *ucontrol)
1016 {
1017 struct echoaudio *chip;
1018 int c, changed, gain;
1019
1020 changed = 0;
1021 chip = snd_kcontrol_chip(kcontrol);
1022 spin_lock_irq(&chip->lock);
1023 for (c = 0; c < num_busses_out(chip); c++) {
1024 gain = ucontrol->value.integer.value[c];
1025 /* Ignore out of range values */
1026 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1027 continue;
1028 if (chip->output_gain[c] != gain) {
1029 set_output_gain(chip, c, gain);
1030 changed = 1;
1031 }
1032 }
1033 if (changed)
1034 update_output_line_level(chip);
1035 spin_unlock_irq(&chip->lock);
1036 return changed;
1037 }
1038
1039 #ifdef ECHOCARD_HAS_LINE_OUT_GAIN
1040 /* On the Mia this one controls the line-out volume */
1041 static const struct snd_kcontrol_new snd_echo_line_output_gain = {
1042 .name = "Line Playback Volume",
1043 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1044 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1045 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1046 .info = snd_echo_output_gain_info,
1047 .get = snd_echo_output_gain_get,
1048 .put = snd_echo_output_gain_put,
1049 .tlv = {.p = db_scale_output_gain},
1050 };
1051 #else
1052 static const struct snd_kcontrol_new snd_echo_pcm_output_gain = {
1053 .name = "PCM Playback Volume",
1054 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1055 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1056 .info = snd_echo_output_gain_info,
1057 .get = snd_echo_output_gain_get,
1058 .put = snd_echo_output_gain_put,
1059 .tlv = {.p = db_scale_output_gain},
1060 };
1061 #endif
1062
1063 #endif /* !ECHOCARD_HAS_VMIXER || ECHOCARD_HAS_LINE_OUT_GAIN */
1064
1065
1066
1067 #ifdef ECHOCARD_HAS_INPUT_GAIN
1068
1069 /******************* Analog input volume *******************/
1070 static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1071 struct snd_ctl_elem_info *uinfo)
1072 {
1073 struct echoaudio *chip;
1074
1075 chip = snd_kcontrol_chip(kcontrol);
1076 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1077 uinfo->count = num_analog_busses_in(chip);
1078 uinfo->value.integer.min = ECHOGAIN_MININP;
1079 uinfo->value.integer.max = ECHOGAIN_MAXINP;
1080 return 0;
1081 }
1082
1083 static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1084 struct snd_ctl_elem_value *ucontrol)
1085 {
1086 struct echoaudio *chip;
1087 int c;
1088
1089 chip = snd_kcontrol_chip(kcontrol);
1090 for (c = 0; c < num_analog_busses_in(chip); c++)
1091 ucontrol->value.integer.value[c] = chip->input_gain[c];
1092 return 0;
1093 }
1094
1095 static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1096 struct snd_ctl_elem_value *ucontrol)
1097 {
1098 struct echoaudio *chip;
1099 int c, gain, changed;
1100
1101 changed = 0;
1102 chip = snd_kcontrol_chip(kcontrol);
1103 spin_lock_irq(&chip->lock);
1104 for (c = 0; c < num_analog_busses_in(chip); c++) {
1105 gain = ucontrol->value.integer.value[c];
1106 /* Ignore out of range values */
1107 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1108 continue;
1109 if (chip->input_gain[c] != gain) {
1110 set_input_gain(chip, c, gain);
1111 changed = 1;
1112 }
1113 }
1114 if (changed)
1115 update_input_line_level(chip);
1116 spin_unlock_irq(&chip->lock);
1117 return changed;
1118 }
1119
1120 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1121
1122 static const struct snd_kcontrol_new snd_echo_line_input_gain = {
1123 .name = "Line Capture Volume",
1124 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1125 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1126 .info = snd_echo_input_gain_info,
1127 .get = snd_echo_input_gain_get,
1128 .put = snd_echo_input_gain_put,
1129 .tlv = {.p = db_scale_input_gain},
1130 };
1131
1132 #endif /* ECHOCARD_HAS_INPUT_GAIN */
1133
1134
1135
1136 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1137
1138 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1139 static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1140 struct snd_ctl_elem_info *uinfo)
1141 {
1142 struct echoaudio *chip;
1143
1144 chip = snd_kcontrol_chip(kcontrol);
1145 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1146 uinfo->count = num_analog_busses_out(chip);
1147 uinfo->value.integer.min = 0;
1148 uinfo->value.integer.max = 1;
1149 return 0;
1150 }
1151
1152 static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1153 struct snd_ctl_elem_value *ucontrol)
1154 {
1155 struct echoaudio *chip;
1156 int c;
1157
1158 chip = snd_kcontrol_chip(kcontrol);
1159 for (c = 0; c < num_analog_busses_out(chip); c++)
1160 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1161 return 0;
1162 }
1163
1164 static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1165 struct snd_ctl_elem_value *ucontrol)
1166 {
1167 struct echoaudio *chip;
1168 int c, changed;
1169
1170 changed = 0;
1171 chip = snd_kcontrol_chip(kcontrol);
1172 spin_lock_irq(&chip->lock);
1173 for (c = 0; c < num_analog_busses_out(chip); c++) {
1174 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1175 set_nominal_level(chip, c,
1176 ucontrol->value.integer.value[c]);
1177 changed = 1;
1178 }
1179 }
1180 if (changed)
1181 update_output_line_level(chip);
1182 spin_unlock_irq(&chip->lock);
1183 return changed;
1184 }
1185
1186 static const struct snd_kcontrol_new snd_echo_output_nominal_level = {
1187 .name = "Line Playback Switch (-10dBV)",
1188 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1189 .info = snd_echo_output_nominal_info,
1190 .get = snd_echo_output_nominal_get,
1191 .put = snd_echo_output_nominal_put,
1192 };
1193
1194 #endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1195
1196
1197
1198 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1199
1200 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1201 static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1202 struct snd_ctl_elem_info *uinfo)
1203 {
1204 struct echoaudio *chip;
1205
1206 chip = snd_kcontrol_chip(kcontrol);
1207 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1208 uinfo->count = num_analog_busses_in(chip);
1209 uinfo->value.integer.min = 0;
1210 uinfo->value.integer.max = 1;
1211 return 0;
1212 }
1213
1214 static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1215 struct snd_ctl_elem_value *ucontrol)
1216 {
1217 struct echoaudio *chip;
1218 int c;
1219
1220 chip = snd_kcontrol_chip(kcontrol);
1221 for (c = 0; c < num_analog_busses_in(chip); c++)
1222 ucontrol->value.integer.value[c] =
1223 chip->nominal_level[bx_analog_in(chip) + c];
1224 return 0;
1225 }
1226
1227 static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1228 struct snd_ctl_elem_value *ucontrol)
1229 {
1230 struct echoaudio *chip;
1231 int c, changed;
1232
1233 changed = 0;
1234 chip = snd_kcontrol_chip(kcontrol);
1235 spin_lock_irq(&chip->lock);
1236 for (c = 0; c < num_analog_busses_in(chip); c++) {
1237 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1238 ucontrol->value.integer.value[c]) {
1239 set_nominal_level(chip, bx_analog_in(chip) + c,
1240 ucontrol->value.integer.value[c]);
1241 changed = 1;
1242 }
1243 }
1244 if (changed)
1245 update_output_line_level(chip); /* "Output" is not a mistake
1246 * here.
1247 */
1248 spin_unlock_irq(&chip->lock);
1249 return changed;
1250 }
1251
1252 static const struct snd_kcontrol_new snd_echo_intput_nominal_level = {
1253 .name = "Line Capture Switch (-10dBV)",
1254 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1255 .info = snd_echo_input_nominal_info,
1256 .get = snd_echo_input_nominal_get,
1257 .put = snd_echo_input_nominal_put,
1258 };
1259
1260 #endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1261
1262
1263
1264 #ifdef ECHOCARD_HAS_MONITOR
1265
1266 /******************* Monitor mixer *******************/
1267 static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1268 struct snd_ctl_elem_info *uinfo)
1269 {
1270 struct echoaudio *chip;
1271
1272 chip = snd_kcontrol_chip(kcontrol);
1273 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1274 uinfo->count = 1;
1275 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1276 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1277 uinfo->dimen.d[0] = num_busses_out(chip);
1278 uinfo->dimen.d[1] = num_busses_in(chip);
1279 return 0;
1280 }
1281
1282 static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1283 struct snd_ctl_elem_value *ucontrol)
1284 {
1285 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1286 unsigned int out = ucontrol->id.index / num_busses_in(chip);
1287 unsigned int in = ucontrol->id.index % num_busses_in(chip);
1288
1289 if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1290 return -EINVAL;
1291
1292 ucontrol->value.integer.value[0] = chip->monitor_gain[out][in];
1293 return 0;
1294 }
1295
1296 static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1297 struct snd_ctl_elem_value *ucontrol)
1298 {
1299 struct echoaudio *chip;
1300 int changed, gain;
1301 unsigned int out, in;
1302
1303 changed = 0;
1304 chip = snd_kcontrol_chip(kcontrol);
1305 out = ucontrol->id.index / num_busses_in(chip);
1306 in = ucontrol->id.index % num_busses_in(chip);
1307 if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1308 return -EINVAL;
1309 gain = ucontrol->value.integer.value[0];
1310 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1311 return -EINVAL;
1312 if (chip->monitor_gain[out][in] != gain) {
1313 spin_lock_irq(&chip->lock);
1314 set_monitor_gain(chip, out, in, gain);
1315 update_output_line_level(chip);
1316 spin_unlock_irq(&chip->lock);
1317 changed = 1;
1318 }
1319 return changed;
1320 }
1321
1322 static struct snd_kcontrol_new snd_echo_monitor_mixer = {
1323 .name = "Monitor Mixer Volume",
1324 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1325 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1326 .info = snd_echo_mixer_info,
1327 .get = snd_echo_mixer_get,
1328 .put = snd_echo_mixer_put,
1329 .tlv = {.p = db_scale_output_gain},
1330 };
1331
1332 #endif /* ECHOCARD_HAS_MONITOR */
1333
1334
1335
1336 #ifdef ECHOCARD_HAS_VMIXER
1337
1338 /******************* Vmixer *******************/
1339 static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1340 struct snd_ctl_elem_info *uinfo)
1341 {
1342 struct echoaudio *chip;
1343
1344 chip = snd_kcontrol_chip(kcontrol);
1345 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1346 uinfo->count = 1;
1347 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1348 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1349 uinfo->dimen.d[0] = num_busses_out(chip);
1350 uinfo->dimen.d[1] = num_pipes_out(chip);
1351 return 0;
1352 }
1353
1354 static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1355 struct snd_ctl_elem_value *ucontrol)
1356 {
1357 struct echoaudio *chip;
1358
1359 chip = snd_kcontrol_chip(kcontrol);
1360 ucontrol->value.integer.value[0] =
1361 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1362 [ucontrol->id.index % num_pipes_out(chip)];
1363 return 0;
1364 }
1365
1366 static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1367 struct snd_ctl_elem_value *ucontrol)
1368 {
1369 struct echoaudio *chip;
1370 int gain, changed;
1371 short vch, out;
1372
1373 changed = 0;
1374 chip = snd_kcontrol_chip(kcontrol);
1375 out = ucontrol->id.index / num_pipes_out(chip);
1376 vch = ucontrol->id.index % num_pipes_out(chip);
1377 gain = ucontrol->value.integer.value[0];
1378 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1379 return -EINVAL;
1380 if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1381 spin_lock_irq(&chip->lock);
1382 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1383 update_vmixer_level(chip);
1384 spin_unlock_irq(&chip->lock);
1385 changed = 1;
1386 }
1387 return changed;
1388 }
1389
1390 static struct snd_kcontrol_new snd_echo_vmixer = {
1391 .name = "VMixer Volume",
1392 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1393 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1394 .info = snd_echo_vmixer_info,
1395 .get = snd_echo_vmixer_get,
1396 .put = snd_echo_vmixer_put,
1397 .tlv = {.p = db_scale_output_gain},
1398 };
1399
1400 #endif /* ECHOCARD_HAS_VMIXER */
1401
1402
1403
1404 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1405
1406 /******************* Digital mode switch *******************/
1407 static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1408 struct snd_ctl_elem_info *uinfo)
1409 {
1410 static const char * const names[4] = {
1411 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1412 "S/PDIF Cdrom"
1413 };
1414 struct echoaudio *chip;
1415
1416 chip = snd_kcontrol_chip(kcontrol);
1417 return snd_ctl_enum_info(uinfo, 1, chip->num_digital_modes, names);
1418 }
1419
1420 static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1421 struct snd_ctl_elem_value *ucontrol)
1422 {
1423 struct echoaudio *chip;
1424 int i, mode;
1425
1426 chip = snd_kcontrol_chip(kcontrol);
1427 mode = chip->digital_mode;
1428 for (i = chip->num_digital_modes - 1; i >= 0; i--)
1429 if (mode == chip->digital_mode_list[i]) {
1430 ucontrol->value.enumerated.item[0] = i;
1431 break;
1432 }
1433 return 0;
1434 }
1435
1436 static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1437 struct snd_ctl_elem_value *ucontrol)
1438 {
1439 struct echoaudio *chip;
1440 int changed;
1441 unsigned short emode, dmode;
1442
1443 changed = 0;
1444 chip = snd_kcontrol_chip(kcontrol);
1445
1446 emode = ucontrol->value.enumerated.item[0];
1447 if (emode >= chip->num_digital_modes)
1448 return -EINVAL;
1449 dmode = chip->digital_mode_list[emode];
1450
1451 if (dmode != chip->digital_mode) {
1452 /* mode_mutex is required to make this operation atomic wrt
1453 pcm_digital_*_open() and set_input_clock() functions. */
1454 mutex_lock(&chip->mode_mutex);
1455
1456 /* Do not allow the user to change the digital mode when a pcm
1457 device is open because it also changes the number of channels
1458 and the allowed sample rates */
1459 if (atomic_read(&chip->opencount)) {
1460 changed = -EAGAIN;
1461 } else {
1462 changed = set_digital_mode(chip, dmode);
1463 /* If we had to change the clock source, report it */
1464 if (changed > 0 && chip->clock_src_ctl) {
1465 snd_ctl_notify(chip->card,
1466 SNDRV_CTL_EVENT_MASK_VALUE,
1467 &chip->clock_src_ctl->id);
1468 dev_dbg(chip->card->dev,
1469 "SDM() =%d\n", changed);
1470 }
1471 if (changed >= 0)
1472 changed = 1; /* No errors */
1473 }
1474 mutex_unlock(&chip->mode_mutex);
1475 }
1476 return changed;
1477 }
1478
1479 static const struct snd_kcontrol_new snd_echo_digital_mode_switch = {
1480 .name = "Digital mode Switch",
1481 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1482 .info = snd_echo_digital_mode_info,
1483 .get = snd_echo_digital_mode_get,
1484 .put = snd_echo_digital_mode_put,
1485 };
1486
1487 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1488
1489
1490
1491 #ifdef ECHOCARD_HAS_DIGITAL_IO
1492
1493 /******************* S/PDIF mode switch *******************/
1494 static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1495 struct snd_ctl_elem_info *uinfo)
1496 {
1497 static const char * const names[2] = {"Consumer", "Professional"};
1498
1499 return snd_ctl_enum_info(uinfo, 1, 2, names);
1500 }
1501
1502 static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1503 struct snd_ctl_elem_value *ucontrol)
1504 {
1505 struct echoaudio *chip;
1506
1507 chip = snd_kcontrol_chip(kcontrol);
1508 ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1509 return 0;
1510 }
1511
1512 static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1513 struct snd_ctl_elem_value *ucontrol)
1514 {
1515 struct echoaudio *chip;
1516 int mode;
1517
1518 chip = snd_kcontrol_chip(kcontrol);
1519 mode = !!ucontrol->value.enumerated.item[0];
1520 if (mode != chip->professional_spdif) {
1521 spin_lock_irq(&chip->lock);
1522 set_professional_spdif(chip, mode);
1523 spin_unlock_irq(&chip->lock);
1524 return 1;
1525 }
1526 return 0;
1527 }
1528
1529 static const struct snd_kcontrol_new snd_echo_spdif_mode_switch = {
1530 .name = "S/PDIF mode Switch",
1531 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1532 .info = snd_echo_spdif_mode_info,
1533 .get = snd_echo_spdif_mode_get,
1534 .put = snd_echo_spdif_mode_put,
1535 };
1536
1537 #endif /* ECHOCARD_HAS_DIGITAL_IO */
1538
1539
1540
1541 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1542
1543 /******************* Select input clock source *******************/
1544 static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1545 struct snd_ctl_elem_info *uinfo)
1546 {
1547 static const char * const names[8] = {
1548 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1549 "ESync96", "MTC"
1550 };
1551 struct echoaudio *chip;
1552
1553 chip = snd_kcontrol_chip(kcontrol);
1554 return snd_ctl_enum_info(uinfo, 1, chip->num_clock_sources, names);
1555 }
1556
1557 static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1558 struct snd_ctl_elem_value *ucontrol)
1559 {
1560 struct echoaudio *chip;
1561 int i, clock;
1562
1563 chip = snd_kcontrol_chip(kcontrol);
1564 clock = chip->input_clock;
1565
1566 for (i = 0; i < chip->num_clock_sources; i++)
1567 if (clock == chip->clock_source_list[i])
1568 ucontrol->value.enumerated.item[0] = i;
1569
1570 return 0;
1571 }
1572
1573 static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1574 struct snd_ctl_elem_value *ucontrol)
1575 {
1576 struct echoaudio *chip;
1577 int changed;
1578 unsigned int eclock, dclock;
1579
1580 changed = 0;
1581 chip = snd_kcontrol_chip(kcontrol);
1582 eclock = ucontrol->value.enumerated.item[0];
1583 if (eclock >= chip->input_clock_types)
1584 return -EINVAL;
1585 dclock = chip->clock_source_list[eclock];
1586 if (chip->input_clock != dclock) {
1587 mutex_lock(&chip->mode_mutex);
1588 spin_lock_irq(&chip->lock);
1589 if ((changed = set_input_clock(chip, dclock)) == 0)
1590 changed = 1; /* no errors */
1591 spin_unlock_irq(&chip->lock);
1592 mutex_unlock(&chip->mode_mutex);
1593 }
1594
1595 if (changed < 0)
1596 dev_dbg(chip->card->dev,
1597 "seticlk val%d err 0x%x\n", dclock, changed);
1598
1599 return changed;
1600 }
1601
1602 static const struct snd_kcontrol_new snd_echo_clock_source_switch = {
1603 .name = "Sample Clock Source",
1604 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1605 .info = snd_echo_clock_source_info,
1606 .get = snd_echo_clock_source_get,
1607 .put = snd_echo_clock_source_put,
1608 };
1609
1610 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1611
1612
1613
1614 #ifdef ECHOCARD_HAS_PHANTOM_POWER
1615
1616 /******************* Phantom power switch *******************/
1617 #define snd_echo_phantom_power_info snd_ctl_boolean_mono_info
1618
1619 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1620 struct snd_ctl_elem_value *ucontrol)
1621 {
1622 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1623
1624 ucontrol->value.integer.value[0] = chip->phantom_power;
1625 return 0;
1626 }
1627
1628 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1629 struct snd_ctl_elem_value *ucontrol)
1630 {
1631 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1632 int power, changed = 0;
1633
1634 power = !!ucontrol->value.integer.value[0];
1635 if (chip->phantom_power != power) {
1636 spin_lock_irq(&chip->lock);
1637 changed = set_phantom_power(chip, power);
1638 spin_unlock_irq(&chip->lock);
1639 if (changed == 0)
1640 changed = 1; /* no errors */
1641 }
1642 return changed;
1643 }
1644
1645 static const struct snd_kcontrol_new snd_echo_phantom_power_switch = {
1646 .name = "Phantom power Switch",
1647 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1648 .info = snd_echo_phantom_power_info,
1649 .get = snd_echo_phantom_power_get,
1650 .put = snd_echo_phantom_power_put,
1651 };
1652
1653 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1654
1655
1656
1657 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1658
1659 /******************* Digital input automute switch *******************/
1660 #define snd_echo_automute_info snd_ctl_boolean_mono_info
1661
1662 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1663 struct snd_ctl_elem_value *ucontrol)
1664 {
1665 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1666
1667 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1668 return 0;
1669 }
1670
1671 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1672 struct snd_ctl_elem_value *ucontrol)
1673 {
1674 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1675 int automute, changed = 0;
1676
1677 automute = !!ucontrol->value.integer.value[0];
1678 if (chip->digital_in_automute != automute) {
1679 spin_lock_irq(&chip->lock);
1680 changed = set_input_auto_mute(chip, automute);
1681 spin_unlock_irq(&chip->lock);
1682 if (changed == 0)
1683 changed = 1; /* no errors */
1684 }
1685 return changed;
1686 }
1687
1688 static const struct snd_kcontrol_new snd_echo_automute_switch = {
1689 .name = "Digital Capture Switch (automute)",
1690 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1691 .info = snd_echo_automute_info,
1692 .get = snd_echo_automute_get,
1693 .put = snd_echo_automute_put,
1694 };
1695
1696 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1697
1698
1699
1700 /******************* VU-meters switch *******************/
1701 #define snd_echo_vumeters_switch_info snd_ctl_boolean_mono_info
1702
1703 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1704 struct snd_ctl_elem_value *ucontrol)
1705 {
1706 struct echoaudio *chip;
1707
1708 chip = snd_kcontrol_chip(kcontrol);
1709 spin_lock_irq(&chip->lock);
1710 set_meters_on(chip, ucontrol->value.integer.value[0]);
1711 spin_unlock_irq(&chip->lock);
1712 return 1;
1713 }
1714
1715 static const struct snd_kcontrol_new snd_echo_vumeters_switch = {
1716 .name = "VU-meters Switch",
1717 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1718 .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1719 .info = snd_echo_vumeters_switch_info,
1720 .put = snd_echo_vumeters_switch_put,
1721 };
1722
1723
1724
1725 /***** Read VU-meters (input, output, analog and digital together) *****/
1726 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1727 struct snd_ctl_elem_info *uinfo)
1728 {
1729 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1730 uinfo->count = 96;
1731 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1732 uinfo->value.integer.max = 0;
1733 #ifdef ECHOCARD_HAS_VMIXER
1734 uinfo->dimen.d[0] = 3; /* Out, In, Virt */
1735 #else
1736 uinfo->dimen.d[0] = 2; /* Out, In */
1737 #endif
1738 uinfo->dimen.d[1] = 16; /* 16 channels */
1739 uinfo->dimen.d[2] = 2; /* 0=level, 1=peak */
1740 return 0;
1741 }
1742
1743 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1744 struct snd_ctl_elem_value *ucontrol)
1745 {
1746 struct echoaudio *chip;
1747
1748 chip = snd_kcontrol_chip(kcontrol);
1749 get_audio_meters(chip, ucontrol->value.integer.value);
1750 return 0;
1751 }
1752
1753 static const struct snd_kcontrol_new snd_echo_vumeters = {
1754 .name = "VU-meters",
1755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1756 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1757 SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1758 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1759 .info = snd_echo_vumeters_info,
1760 .get = snd_echo_vumeters_get,
1761 .tlv = {.p = db_scale_output_gain},
1762 };
1763
1764
1765
1766 /*** Channels info - it exports informations about the number of channels ***/
1767 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1768 struct snd_ctl_elem_info *uinfo)
1769 {
1770 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1771 uinfo->count = 6;
1772 uinfo->value.integer.min = 0;
1773 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1774 return 0;
1775 }
1776
1777 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1778 struct snd_ctl_elem_value *ucontrol)
1779 {
1780 struct echoaudio *chip;
1781 int detected, clocks, bit, src;
1782
1783 chip = snd_kcontrol_chip(kcontrol);
1784 ucontrol->value.integer.value[0] = num_busses_in(chip);
1785 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1786 ucontrol->value.integer.value[2] = num_busses_out(chip);
1787 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1788 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1789
1790 /* Compute the bitmask of the currently valid input clocks */
1791 detected = detect_input_clocks(chip);
1792 clocks = 0;
1793 src = chip->num_clock_sources - 1;
1794 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1795 if (detected & (1 << bit))
1796 for (; src >= 0; src--)
1797 if (bit == chip->clock_source_list[src]) {
1798 clocks |= 1 << src;
1799 break;
1800 }
1801 ucontrol->value.integer.value[5] = clocks;
1802
1803 return 0;
1804 }
1805
1806 static const struct snd_kcontrol_new snd_echo_channels_info = {
1807 .name = "Channels info",
1808 .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1809 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1810 .info = snd_echo_channels_info_info,
1811 .get = snd_echo_channels_info_get,
1812 };
1813
1814
1815
1816
1817 /******************************************************************************
1818 IRQ Handler
1819 ******************************************************************************/
1820
1821 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1822 {
1823 struct echoaudio *chip = dev_id;
1824 struct snd_pcm_substream *substream;
1825 int period, ss, st;
1826
1827 spin_lock(&chip->lock);
1828 st = service_irq(chip);
1829 if (st < 0) {
1830 spin_unlock(&chip->lock);
1831 return IRQ_NONE;
1832 }
1833 /* The hardware doesn't tell us which substream caused the irq,
1834 thus we have to check all running substreams. */
1835 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1836 substream = chip->substream[ss];
1837 if (substream && ((struct audiopipe *)substream->runtime->
1838 private_data)->state == PIPE_STATE_STARTED) {
1839 period = pcm_pointer(substream) /
1840 substream->runtime->period_size;
1841 if (period != chip->last_period[ss]) {
1842 chip->last_period[ss] = period;
1843 spin_unlock(&chip->lock);
1844 snd_pcm_period_elapsed(substream);
1845 spin_lock(&chip->lock);
1846 }
1847 }
1848 }
1849 spin_unlock(&chip->lock);
1850
1851 #ifdef ECHOCARD_HAS_MIDI
1852 if (st > 0 && chip->midi_in) {
1853 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1854 dev_dbg(chip->card->dev, "rawmidi_iread=%d\n", st);
1855 }
1856 #endif
1857 return IRQ_HANDLED;
1858 }
1859
1860
1861
1862
1863 /******************************************************************************
1864 Module construction / destruction
1865 ******************************************************************************/
1866
1867 static int snd_echo_free(struct echoaudio *chip)
1868 {
1869 if (chip->comm_page)
1870 rest_in_peace(chip);
1871
1872 if (chip->irq >= 0)
1873 free_irq(chip->irq, chip);
1874
1875 if (chip->comm_page)
1876 snd_dma_free_pages(&chip->commpage_dma_buf);
1877
1878 iounmap(chip->dsp_registers);
1879 release_and_free_resource(chip->iores);
1880 pci_disable_device(chip->pci);
1881
1882 /* release chip data */
1883 free_firmware_cache(chip);
1884 kfree(chip);
1885 return 0;
1886 }
1887
1888
1889
1890 static int snd_echo_dev_free(struct snd_device *device)
1891 {
1892 struct echoaudio *chip = device->device_data;
1893
1894 return snd_echo_free(chip);
1895 }
1896
1897
1898
1899 /* <--snd_echo_probe() */
1900 static int snd_echo_create(struct snd_card *card,
1901 struct pci_dev *pci,
1902 struct echoaudio **rchip)
1903 {
1904 struct echoaudio *chip;
1905 int err;
1906 size_t sz;
1907 static struct snd_device_ops ops = {
1908 .dev_free = snd_echo_dev_free,
1909 };
1910
1911 *rchip = NULL;
1912
1913 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1914
1915 if ((err = pci_enable_device(pci)) < 0)
1916 return err;
1917 pci_set_master(pci);
1918
1919 /* Allocate chip if needed */
1920 if (!*rchip) {
1921 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1922 if (!chip) {
1923 pci_disable_device(pci);
1924 return -ENOMEM;
1925 }
1926 dev_dbg(card->dev, "chip=%p\n", chip);
1927 spin_lock_init(&chip->lock);
1928 chip->card = card;
1929 chip->pci = pci;
1930 chip->irq = -1;
1931 atomic_set(&chip->opencount, 0);
1932 mutex_init(&chip->mode_mutex);
1933 chip->can_set_rate = 1;
1934 } else {
1935 /* If this was called from the resume function, chip is
1936 * already allocated and it contains current card settings.
1937 */
1938 chip = *rchip;
1939 }
1940
1941 /* PCI resource allocation */
1942 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1943 sz = pci_resource_len(pci, 0);
1944 if (sz > PAGE_SIZE)
1945 sz = PAGE_SIZE; /* We map only the required part */
1946
1947 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1948 ECHOCARD_NAME)) == NULL) {
1949 dev_err(chip->card->dev, "cannot get memory region\n");
1950 snd_echo_free(chip);
1951 return -EBUSY;
1952 }
1953 chip->dsp_registers = (volatile u32 __iomem *)
1954 ioremap_nocache(chip->dsp_registers_phys, sz);
1955
1956 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1957 KBUILD_MODNAME, chip)) {
1958 dev_err(chip->card->dev, "cannot grab irq\n");
1959 snd_echo_free(chip);
1960 return -EBUSY;
1961 }
1962 chip->irq = pci->irq;
1963 dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n",
1964 chip->pci, chip->irq, chip->pci->subsystem_device);
1965
1966 /* Create the DSP comm page - this is the area of memory used for most
1967 of the communication with the DSP, which accesses it via bus mastering */
1968 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1969 sizeof(struct comm_page),
1970 &chip->commpage_dma_buf) < 0) {
1971 dev_err(chip->card->dev, "cannot allocate the comm page\n");
1972 snd_echo_free(chip);
1973 return -ENOMEM;
1974 }
1975 chip->comm_page_phys = chip->commpage_dma_buf.addr;
1976 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1977
1978 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1979 if (err >= 0)
1980 err = set_mixer_defaults(chip);
1981 if (err < 0) {
1982 dev_err(card->dev, "init_hw err=%d\n", err);
1983 snd_echo_free(chip);
1984 return err;
1985 }
1986
1987 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1988 snd_echo_free(chip);
1989 return err;
1990 }
1991 *rchip = chip;
1992 /* Init done ! */
1993 return 0;
1994 }
1995
1996
1997
1998 /* constructor */
1999 static int snd_echo_probe(struct pci_dev *pci,
2000 const struct pci_device_id *pci_id)
2001 {
2002 static int dev;
2003 struct snd_card *card;
2004 struct echoaudio *chip;
2005 char *dsp;
2006 int i, err;
2007
2008 if (dev >= SNDRV_CARDS)
2009 return -ENODEV;
2010 if (!enable[dev]) {
2011 dev++;
2012 return -ENOENT;
2013 }
2014
2015 i = 0;
2016 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2017 0, &card);
2018 if (err < 0)
2019 return err;
2020
2021 chip = NULL; /* Tells snd_echo_create to allocate chip */
2022 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2023 snd_card_free(card);
2024 return err;
2025 }
2026
2027 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2028 strcpy(card->shortname, chip->card_name);
2029
2030 dsp = "56301";
2031 if (pci_id->device == 0x3410)
2032 dsp = "56361";
2033
2034 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2035 card->shortname, pci_id->subdevice & 0x000f, dsp,
2036 chip->dsp_registers_phys, chip->irq);
2037
2038 if ((err = snd_echo_new_pcm(chip)) < 0) {
2039 dev_err(chip->card->dev, "new pcm error %d\n", err);
2040 snd_card_free(card);
2041 return err;
2042 }
2043
2044 #ifdef ECHOCARD_HAS_MIDI
2045 if (chip->has_midi) { /* Some Mia's do not have midi */
2046 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2047 dev_err(chip->card->dev, "new midi error %d\n", err);
2048 snd_card_free(card);
2049 return err;
2050 }
2051 }
2052 #endif
2053
2054 #ifdef ECHOCARD_HAS_VMIXER
2055 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2056 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2057 goto ctl_error;
2058 #ifdef ECHOCARD_HAS_LINE_OUT_GAIN
2059 err = snd_ctl_add(chip->card,
2060 snd_ctl_new1(&snd_echo_line_output_gain, chip));
2061 if (err < 0)
2062 goto ctl_error;
2063 #endif
2064 #else /* ECHOCARD_HAS_VMIXER */
2065 err = snd_ctl_add(chip->card,
2066 snd_ctl_new1(&snd_echo_pcm_output_gain, chip));
2067 if (err < 0)
2068 goto ctl_error;
2069 #endif /* ECHOCARD_HAS_VMIXER */
2070
2071 #ifdef ECHOCARD_HAS_INPUT_GAIN
2072 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2073 goto ctl_error;
2074 #endif
2075
2076 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2077 if (!chip->hasnt_input_nominal_level)
2078 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2079 goto ctl_error;
2080 #endif
2081
2082 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2083 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2084 goto ctl_error;
2085 #endif
2086
2087 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2088 goto ctl_error;
2089
2090 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2091 goto ctl_error;
2092
2093 #ifdef ECHOCARD_HAS_MONITOR
2094 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2095 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2096 goto ctl_error;
2097 #endif
2098
2099 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2100 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2101 goto ctl_error;
2102 #endif
2103
2104 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2105 goto ctl_error;
2106
2107 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2108 /* Creates a list of available digital modes */
2109 chip->num_digital_modes = 0;
2110 for (i = 0; i < 6; i++)
2111 if (chip->digital_modes & (1 << i))
2112 chip->digital_mode_list[chip->num_digital_modes++] = i;
2113
2114 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2115 goto ctl_error;
2116 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2117
2118 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2119 /* Creates a list of available clock sources */
2120 chip->num_clock_sources = 0;
2121 for (i = 0; i < 10; i++)
2122 if (chip->input_clock_types & (1 << i))
2123 chip->clock_source_list[chip->num_clock_sources++] = i;
2124
2125 if (chip->num_clock_sources > 1) {
2126 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2127 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2128 goto ctl_error;
2129 }
2130 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2131
2132 #ifdef ECHOCARD_HAS_DIGITAL_IO
2133 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2134 goto ctl_error;
2135 #endif
2136
2137 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2138 if (chip->has_phantom_power)
2139 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2140 goto ctl_error;
2141 #endif
2142
2143 err = snd_card_register(card);
2144 if (err < 0)
2145 goto ctl_error;
2146 dev_info(card->dev, "Card registered: %s\n", card->longname);
2147
2148 pci_set_drvdata(pci, chip);
2149 dev++;
2150 return 0;
2151
2152 ctl_error:
2153 dev_err(card->dev, "new control error %d\n", err);
2154 snd_card_free(card);
2155 return err;
2156 }
2157
2158
2159
2160 #if defined(CONFIG_PM_SLEEP)
2161
2162 static int snd_echo_suspend(struct device *dev)
2163 {
2164 struct echoaudio *chip = dev_get_drvdata(dev);
2165
2166 snd_pcm_suspend_all(chip->analog_pcm);
2167 snd_pcm_suspend_all(chip->digital_pcm);
2168
2169 #ifdef ECHOCARD_HAS_MIDI
2170 /* This call can sleep */
2171 if (chip->midi_out)
2172 snd_echo_midi_output_trigger(chip->midi_out, 0);
2173 #endif
2174 spin_lock_irq(&chip->lock);
2175 if (wait_handshake(chip)) {
2176 spin_unlock_irq(&chip->lock);
2177 return -EIO;
2178 }
2179 clear_handshake(chip);
2180 if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0) {
2181 spin_unlock_irq(&chip->lock);
2182 return -EIO;
2183 }
2184 spin_unlock_irq(&chip->lock);
2185
2186 chip->dsp_code = NULL;
2187 free_irq(chip->irq, chip);
2188 chip->irq = -1;
2189 return 0;
2190 }
2191
2192
2193
2194 static int snd_echo_resume(struct device *dev)
2195 {
2196 struct pci_dev *pci = to_pci_dev(dev);
2197 struct echoaudio *chip = dev_get_drvdata(dev);
2198 struct comm_page *commpage, *commpage_bak;
2199 u32 pipe_alloc_mask;
2200 int err;
2201
2202 commpage_bak = kmalloc(sizeof(*commpage), GFP_KERNEL);
2203 if (commpage_bak == NULL)
2204 return -ENOMEM;
2205 commpage = chip->comm_page;
2206 memcpy(commpage_bak, commpage, sizeof(*commpage));
2207
2208 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2209 if (err < 0) {
2210 kfree(commpage_bak);
2211 dev_err(dev, "resume init_hw err=%d\n", err);
2212 snd_echo_free(chip);
2213 return err;
2214 }
2215
2216 /* Temporarily set chip->pipe_alloc_mask=0 otherwise
2217 * restore_dsp_settings() fails.
2218 */
2219 pipe_alloc_mask = chip->pipe_alloc_mask;
2220 chip->pipe_alloc_mask = 0;
2221 err = restore_dsp_rettings(chip);
2222 chip->pipe_alloc_mask = pipe_alloc_mask;
2223 if (err < 0) {
2224 kfree(commpage_bak);
2225 return err;
2226 }
2227
2228 memcpy(&commpage->audio_format, &commpage_bak->audio_format,
2229 sizeof(commpage->audio_format));
2230 memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
2231 sizeof(commpage->sglist_addr));
2232 memcpy(&commpage->midi_output, &commpage_bak->midi_output,
2233 sizeof(commpage->midi_output));
2234 kfree(commpage_bak);
2235
2236 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
2237 KBUILD_MODNAME, chip)) {
2238 dev_err(chip->card->dev, "cannot grab irq\n");
2239 snd_echo_free(chip);
2240 return -EBUSY;
2241 }
2242 chip->irq = pci->irq;
2243 dev_dbg(dev, "resume irq=%d\n", chip->irq);
2244
2245 #ifdef ECHOCARD_HAS_MIDI
2246 if (chip->midi_input_enabled)
2247 enable_midi_input(chip, true);
2248 if (chip->midi_out)
2249 snd_echo_midi_output_trigger(chip->midi_out, 1);
2250 #endif
2251
2252 return 0;
2253 }
2254
2255 static SIMPLE_DEV_PM_OPS(snd_echo_pm, snd_echo_suspend, snd_echo_resume);
2256 #define SND_ECHO_PM_OPS &snd_echo_pm
2257 #else
2258 #define SND_ECHO_PM_OPS NULL
2259 #endif /* CONFIG_PM_SLEEP */
2260
2261
2262 static void snd_echo_remove(struct pci_dev *pci)
2263 {
2264 struct echoaudio *chip;
2265
2266 chip = pci_get_drvdata(pci);
2267 if (chip)
2268 snd_card_free(chip->card);
2269 }
2270
2271
2272
2273 /******************************************************************************
2274 Everything starts and ends here
2275 ******************************************************************************/
2276
2277 /* pci_driver definition */
2278 static struct pci_driver echo_driver = {
2279 .name = KBUILD_MODNAME,
2280 .id_table = snd_echo_ids,
2281 .probe = snd_echo_probe,
2282 .remove = snd_echo_remove,
2283 .driver = {
2284 .pm = SND_ECHO_PM_OPS,
2285 },
2286 };
2287
2288 module_pci_driver(echo_driver);
Linux with added FPC-III support