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