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