]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - sound/pci/echoaudio/echoaudio.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'drm-misc-fixes-2021-02-02' of git://anongit.freedesktop.org/drm/drm-misc...
[mirror_ubuntu-hirsute-kernel.git] / sound / pci / echoaudio / echoaudio.c
CommitLineData
873e65bc 1// SPDX-License-Identifier: GPL-2.0-only
dd7b254d
GP		 2/*
3 * ALSA driver for Echoaudio soundcards.
4 * Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
a0b224b9 5 * Copyright (C) 2020 Mark Hills <mark@xwax.org>
dd7b254d
GP		 6 */
7
da155d5b
PG		 8#include <linux/module.h>
9
dd7b254d
GP		 10MODULE_AUTHOR("Giuliano Pochini <pochini@shiny.it>");
11MODULE_LICENSE("GPL v2");
12MODULE_DESCRIPTION("Echoaudio " ECHOCARD_NAME " soundcards driver");
13MODULE_SUPPORTED_DEVICE("{{Echoaudio," ECHOCARD_NAME "}}");
14MODULE_DEVICE_TABLE(pci, snd_echo_ids);
15
16static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
17static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
a67ff6a5 18static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
dd7b254d
GP		 19
20module_param_array(index, int, NULL, 0444);
21MODULE_PARM_DESC(index, "Index value for " ECHOCARD_NAME " soundcard.");
22module_param_array(id, charp, NULL, 0444);
23MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
24module_param_array(enable, bool, NULL, 0444);
25MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
26
9bca0907 27static const unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
0cb29ea0 28static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
dd7b254d 29
19b50063
GP		 30
31
dd7b254d 32static int get_firmware(const struct firmware **fw_entry,
19b50063 33 struct echoaudio *chip, const short fw_index)
dd7b254d
GP		 34{
35 int err;
36 char name[30];
19b50063 37
c7561cd8 38#ifdef CONFIG_PM_SLEEP
4f8ada44 39 if (chip->fw_cache[fw_index]) {
b5b4a41b
SM		 40 dev_dbg(chip->card->dev,
41 "firmware requested: %s is cached\n",
42 card_fw[fw_index].data);
4f8ada44
GP		 43 *fw_entry = chip->fw_cache[fw_index];
44 return 0;
45 }
46#endif
47
b5b4a41b
SM		 48 dev_dbg(chip->card->dev,
49 "firmware requested: %s\n", card_fw[fw_index].data);
4f8ada44 50 snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
afe5da3e 51 err = request_firmware(fw_entry, name, &chip->pci->dev);
4f8ada44 52 if (err < 0)
ece7a36d
TI		 53 dev_err(chip->card->dev,
54 "get_firmware(): Firmware not available (%d)\n", err);
c7561cd8 55#ifdef CONFIG_PM_SLEEP
4f8ada44
GP		 56 else
57 chip->fw_cache[fw_index] = *fw_entry;
58#endif
dd7b254d
GP		 59 return err;
60}
61
19b50063
GP		 62
63
e3690869
SM		 64static void free_firmware(const struct firmware *fw_entry,
65 struct echoaudio *chip)
dd7b254d 66{
c7561cd8 67#ifdef CONFIG_PM_SLEEP
b5b4a41b 68 dev_dbg(chip->card->dev, "firmware not released (kept in cache)\n");
4f8ada44 69#else
dd7b254d 70 release_firmware(fw_entry);
4f8ada44
GP		 71#endif
72}
73
74
75
76static void free_firmware_cache(struct echoaudio *chip)
77{
c7561cd8 78#ifdef CONFIG_PM_SLEEP
4f8ada44
GP		 79 int i;
80
81 for (i = 0; i < 8 ; i++)
82 if (chip->fw_cache[i]) {
83 release_firmware(chip->fw_cache[i]);
b5b4a41b 84 dev_dbg(chip->card->dev, "release_firmware(%d)\n", i);
4f8ada44
GP		 85 }
86
4f8ada44 87#endif
dd7b254d
GP		 88}
89
90
91
92/******************************************************************************
93 PCM interface
94******************************************************************************/
95
96static 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
107static 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
135static 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
169static 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
204static 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
241sample rate only if there is only one pcm device open. */
242static 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;
027c7002
MH		 249 int err;
250
251 mutex_lock(&chip->mode_mutex);
dd7b254d 252
027c7002
MH		 253 if (chip->can_set_rate) {
254 err = 0;
255 } else {
dd7b254d
GP		 256 snd_interval_any(&fixed);
257 fixed.min = fixed.max = chip->sample_rate;
027c7002 258 err = snd_interval_refine(rate, &fixed);
dd7b254d 259 }
027c7002
MH		 260
261 mutex_unlock(&chip->mode_mutex);
262 return err;
dd7b254d
GP		 263}
264
265
266static 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
59feddb2
PI		 280 pipe = kzalloc(sizeof(struct audiopipe), GFP_KERNEL);
281 if (!pipe)
dd7b254d 282 return -ENOMEM;
dd7b254d
GP		 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));
b5b4a41b 287 dev_dbg(chip->card->dev, "max_channels=%d\n", max_channels);
dd7b254d
GP		 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
027c7002 333 /* Allocate a page for the scatter-gather list */
dd7b254d 334 if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
7564d3b6 335 &chip->pci->dev,
dd7b254d 336 PAGE_SIZE, &pipe->sgpage)) < 0) {
b5b4a41b 337 dev_err(chip->card->dev, "s-g list allocation failed\n");
dd7b254d
GP		 338 return err;
339 }
340
027c7002
MH		 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
dd7b254d
GP		 352 return 0;
353}
354
355
356
357static int pcm_analog_in_open(struct snd_pcm_substream *substream)
358{
359 struct echoaudio *chip = snd_pcm_substream_chip(substream);
360 int err;
361
dd7b254d
GP		 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;
027c7002 375
dd7b254d
GP		 376 return 0;
377}
378
379
380
381static 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
dd7b254d
GP		 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;
027c7002 405
dd7b254d
GP		 406 return 0;
407}
408
409
410
411#ifdef ECHOCARD_HAS_DIGITAL_IO
412
413static 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
dd7b254d 418 max_channels = num_digital_busses_in(chip) - substream->number;
befceea9 419 mutex_lock(&chip->mode_mutex);
dd7b254d
GP		 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
dd7b254d 441din_exit:
befceea9 442 mutex_unlock(&chip->mode_mutex);
dd7b254d
GP		 443 return err;
444}
445
446
447
448#ifndef ECHOCARD_HAS_VMIXER /* See the note in snd_echo_new_pcm() */
449
450static 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
dd7b254d 455 max_channels = num_digital_busses_out(chip) - substream->number;
befceea9 456 mutex_lock(&chip->mode_mutex);
dd7b254d
GP		 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;
027c7002 479
dd7b254d 480dout_exit:
befceea9 481 mutex_unlock(&chip->mode_mutex);
dd7b254d
GP		 482 return err;
483}
484
485#endif /* !ECHOCARD_HAS_VMIXER */
486
487#endif /* ECHOCARD_HAS_DIGITAL_IO */
488
489
490
491static int pcm_close(struct snd_pcm_substream *substream)
492{
493 struct echoaudio *chip = snd_pcm_substream_chip(substream);
dd7b254d
GP		 494
495 /* Nothing to do here. Audio is already off and pipe will be
496 * freed by its callback
497 */
dd7b254d 498
027c7002
MH		 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:
dd7b254d 508 chip->can_set_rate = 1;
027c7002
MH		 509 break;
510
511 case 0:
dd7b254d 512 chip->rate_set = 0;
027c7002
MH		 513 break;
514 }
dd7b254d 515
027c7002 516 mutex_unlock(&chip->mode_mutex);
dd7b254d
GP		 517 return 0;
518}
519
520
521
522/* Channel allocation and scatter-gather list setup */
523static 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;
dd7b254d
GP		 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) {
b5b4a41b 539 dev_dbg(chip->card->dev, "hwp_ie free(%d)\n", pipe->index);
dd7b254d 540 err = free_pipes(chip, pipe);
da3cec35 541 snd_BUG_ON(err);
dd7b254d
GP		 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);
b5b4a41b
SM		 548 dev_err(chip->card->dev, "allocate_pipes(%d) err=%d\n",
549 pipe_index, err);
dd7b254d
GP		 550 return err;
551 }
552 spin_unlock_irq(&chip->lock);
b5b4a41b 553 dev_dbg(chip->card->dev, "allocate_pipes()=%d\n", pipe_index);
dd7b254d 554
b5b4a41b
SM		 555 dev_dbg(chip->card->dev,
556 "pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n",
dd7b254d 557 params_buffer_bytes(hw_params), params_periods(hw_params),
b5b4a41b 558 params_period_bytes(hw_params));
dd7b254d 559
dd7b254d
GP		 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) {
77a23f26
TI		 568 dma_addr_t addr;
569 addr = snd_pcm_sgbuf_get_addr(substream, offs);
dd7b254d 570 if (rest <= edge - offs) {
77a23f26 571 sglist_add_mapping(chip, pipe, addr, rest);
dd7b254d
GP		 572 sglist_add_irq(chip, pipe);
573 offs += rest;
574 rest = 0;
575 } else {
77a23f26 576 sglist_add_mapping(chip, pipe, addr,
dd7b254d
GP		 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 */
a0b224b9 594 pipe->last_period = 0;
dd7b254d
GP		 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);
dd7b254d
GP		 603 return 0;
604}
605
606
607
608static 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
619static 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
630static 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() */
642static 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
656static 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) {
b5b4a41b 666 dev_dbg(chip->card->dev, "pcm_hw_free(%d)\n", pipe->index);
dd7b254d
GP		 667 free_pipes(chip, pipe);
668 chip->substream[pipe->index] = NULL;
669 pipe->index = -1;
670 }
671 spin_unlock_irq(&chip->lock);
672
dd7b254d
GP		 673 return 0;
674}
675
676
677
678static 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
b5b4a41b
SM		 685 dev_dbg(chip->card->dev, "Prepare rate=%d format=%d channels=%d\n",
686 runtime->rate, runtime->format, runtime->channels);
dd7b254d
GP		 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;
c0dbbdad 702 fallthrough;
dd7b254d
GP		 703 case SNDRV_PCM_FORMAT_S32_LE:
704 format.bits_per_sample = 32;
705 break;
706 default:
b5b4a41b
SM		 707 dev_err(chip->card->dev,
708 "Prepare error: unsupported format %d\n",
709 runtime->format);
dd7b254d
GP		 710 return -EINVAL;
711 }
712
da3cec35
TI		 713 if (snd_BUG_ON(pipe_index >= px_num(chip)))
714 return -EINVAL;
6c331254
MH		 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))) {
b91c9cb9 724 spin_unlock_irq(&chip->lock);
da3cec35 725 return -EINVAL;
6c331254
MH		 726 }
727
dd7b254d 728 set_audio_format(chip, pipe_index, &format);
6c331254
MH		 729 spin_unlock_irq(&chip->lock);
730
dd7b254d
GP		 731 return 0;
732}
733
734
735
736static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
737{
738 struct echoaudio *chip = snd_pcm_substream_chip(substream);
0bc66fd3 739 struct audiopipe *pipe;
dd7b254d
GP		 740 int i, err;
741 u32 channelmask = 0;
dd7b254d
GP		 742 struct snd_pcm_substream *s;
743
ef991b95 744 snd_pcm_group_for_each_entry(s, substream) {
dd7b254d
GP		 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) {
47b5d028 755 case SNDRV_PCM_TRIGGER_RESUME:
dd7b254d
GP		 756 case SNDRV_PCM_TRIGGER_START:
757 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
dd7b254d
GP		 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:
a0b224b9 763 pipe->last_period = 0;
dd7b254d
GP		 764 pipe->last_counter = 0;
765 pipe->position = 0;
766 *pipe->dma_counter = 0;
c0dbbdad 767 fallthrough;
dd7b254d
GP		 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;
47b5d028 779 case SNDRV_PCM_TRIGGER_SUSPEND:
dd7b254d 780 case SNDRV_PCM_TRIGGER_STOP:
dd7b254d
GP		 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:
dd7b254d
GP		 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
807static 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;
a0b224b9 811 u32 counter, step;
dd7b254d 812
a0b224b9
MH		 813 /*
814 * IRQ handling runs concurrently. Do not share tracking of
815 * counter with it, which would race or require locking
816 */
dd7b254d 817
a0b224b9
MH		 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);
dd7b254d
GP		 831}
832
833
834
835/* pcm *_ops structures */
afa04880 836static const struct snd_pcm_ops analog_playback_ops = {
dd7b254d
GP		 837 .open = pcm_analog_out_open,
838 .close = pcm_close,
dd7b254d
GP		 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,
dd7b254d 844};
afa04880 845static const struct snd_pcm_ops analog_capture_ops = {
dd7b254d
GP		 846 .open = pcm_analog_in_open,
847 .close = pcm_close,
dd7b254d
GP		 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,
dd7b254d
GP		 853};
854#ifdef ECHOCARD_HAS_DIGITAL_IO
855#ifndef ECHOCARD_HAS_VMIXER
afa04880 856static const struct snd_pcm_ops digital_playback_ops = {
dd7b254d
GP		 857 .open = pcm_digital_out_open,
858 .close = pcm_close,
dd7b254d
GP		 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,
dd7b254d
GP		 864};
865#endif /* !ECHOCARD_HAS_VMIXER */
afa04880 866static const struct snd_pcm_ops digital_capture_ops = {
dd7b254d
GP		 867 .open = pcm_digital_in_open,
868 .close = pcm_close,
dd7b254d
GP		 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,
dd7b254d
GP		 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 */
7564d3b6 882static void snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
dd7b254d
GP		 883{
884 struct snd_pcm_substream *ss;
5116b94a 885 int stream;
dd7b254d
GP		 886
887 for (stream = 0; stream < 2; stream++)
5116b94a 888 for (ss = pcm->streams[stream].substream; ss; ss = ss->next)
11f63ca3
TI		 889 snd_pcm_set_managed_buffer(ss, SNDRV_DMA_TYPE_DEV_SG,
890 dev,
891 ss->number ? 0 : 128<<10,
892 256<<10);
dd7b254d
GP		 893}
894
895
896
897/*<--snd_echo_probe() */
e23e7a14 898static int snd_echo_new_pcm(struct echoaudio *chip)
dd7b254d
GP		 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);
7564d3b6 919 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
dd7b254d
GP		 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);
7564d3b6 930 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
dd7b254d
GP		 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);
7564d3b6 950 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
dd7b254d
GP		 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);
7564d3b6 963 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
dd7b254d
GP		 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
392bf2f1 978#if !defined(ECHOCARD_HAS_VMIXER) || defined(ECHOCARD_HAS_LINE_OUT_GAIN)
9f5d790d 979
dd7b254d
GP		 980/******************* PCM output volume *******************/
981static 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
994static 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
1006static 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
392bf2f1
GP		 1031#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
1032/* On the Mia this one controls the line-out volume */
f3b827e0 1033static const struct snd_kcontrol_new snd_echo_line_output_gain = {
392bf2f1
GP		 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
f3b827e0 1044static const struct snd_kcontrol_new snd_echo_pcm_output_gain = {
dd7b254d
GP		 1045 .name = "PCM Playback Volume",
1046 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
048b9450 1047 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
dd7b254d
GP		 1048 .info = snd_echo_output_gain_info,
1049 .get = snd_echo_output_gain_get,
1050 .put = snd_echo_output_gain_put,
048b9450 1051 .tlv = {.p = db_scale_output_gain},
dd7b254d
GP		 1052};
1053#endif
1054
392bf2f1
GP		 1055#endif /* !ECHOCARD_HAS_VMIXER || ECHOCARD_HAS_LINE_OUT_GAIN */
1056
dd7b254d
GP		 1057
1058
1059#ifdef ECHOCARD_HAS_INPUT_GAIN
1060
1061/******************* Analog input volume *******************/
1062static 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
1075static 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
1087static 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
0cb29ea0 1112static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
048b9450 1113
f3b827e0 1114static const struct snd_kcontrol_new snd_echo_line_input_gain = {
dd7b254d
GP		 1115 .name = "Line Capture Volume",
1116 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
048b9450 1117 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
dd7b254d
GP		 1118 .info = snd_echo_input_gain_info,
1119 .get = snd_echo_input_gain_get,
1120 .put = snd_echo_input_gain_put,
048b9450 1121 .tlv = {.p = db_scale_input_gain},
dd7b254d
GP		 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) ***************/
1131static 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
1144static 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
1156static 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
f3b827e0 1178static const struct snd_kcontrol_new snd_echo_output_nominal_level = {
dd7b254d
GP		 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) ***************/
1193static 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
1206static 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
1219static 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
f3b827e0 1244static const struct snd_kcontrol_new snd_echo_intput_nominal_level = {
dd7b254d
GP		 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 *******************/
1259static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1260 struct snd_ctl_elem_info *uinfo)
1261{
dd7b254d 1262 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
51db452d 1263 uinfo->count = 1;
dd7b254d
GP		 1264 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1265 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
dd7b254d
GP		 1266 return 0;
1267}
1268
1269static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1270 struct snd_ctl_elem_value *ucontrol)
1271{
77008b70
DC		 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);
dd7b254d 1275
77008b70
DC		 1276 if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1277 return -EINVAL;
1278
1279 ucontrol->value.integer.value[0] = chip->monitor_gain[out][in];
dd7b254d
GP		 1280 return 0;
1281}
1282
1283static 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;
77008b70 1288 unsigned int out, in;
dd7b254d
GP		 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);
77008b70
DC		 1294 if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1295 return -EINVAL;
dd7b254d
GP		 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
e23e7a14 1309static struct snd_kcontrol_new snd_echo_monitor_mixer = {
dd7b254d
GP		 1310 .name = "Monitor Mixer Volume",
1311 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
048b9450 1312 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
dd7b254d
GP		 1313 .info = snd_echo_mixer_info,
1314 .get = snd_echo_mixer_get,
1315 .put = snd_echo_mixer_put,
048b9450 1316 .tlv = {.p = db_scale_output_gain},
dd7b254d
GP		 1317};
1318
1319#endif /* ECHOCARD_HAS_MONITOR */
1320
1321
1322
1323#ifdef ECHOCARD_HAS_VMIXER
1324
1325/******************* Vmixer *******************/
1326static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1327 struct snd_ctl_elem_info *uinfo)
1328{
dd7b254d 1329 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
51db452d 1330 uinfo->count = 1;
dd7b254d
GP		 1331 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1332 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
dd7b254d
GP		 1333 return 0;
1334}
1335
1336static 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
1348static 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
e23e7a14 1372static struct snd_kcontrol_new snd_echo_vmixer = {
dd7b254d
GP		 1373 .name = "VMixer Volume",
1374 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
048b9450 1375 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
dd7b254d
GP		 1376 .info = snd_echo_vmixer_info,
1377 .get = snd_echo_vmixer_get,
1378 .put = snd_echo_vmixer_put,
048b9450 1379 .tlv = {.p = db_scale_output_gain},
dd7b254d
GP		 1380};
1381
1382#endif /* ECHOCARD_HAS_VMIXER */
1383
1384
1385
1386#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1387
1388/******************* Digital mode switch *******************/
1389static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1390 struct snd_ctl_elem_info *uinfo)
1391{
c69a4f30 1392 static const char * const names[4] = {
dd7b254d
GP		 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);
c69a4f30 1399 return snd_ctl_enum_info(uinfo, 1, chip->num_digital_modes, names);
dd7b254d
GP		 1400}
1401
1402static 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
1418static 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. */
befceea9 1436 mutex_lock(&chip->mode_mutex);
dd7b254d
GP		 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 */
027c7002 1441 if (chip->opencount) {
dd7b254d
GP		 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);
b5b4a41b
SM		 1450 dev_dbg(chip->card->dev,
1451 "SDM() =%d\n", changed);
dd7b254d
GP		 1452 }
1453 if (changed >= 0)
1454 changed = 1; /* No errors */
1455 }
befceea9 1456 mutex_unlock(&chip->mode_mutex);
dd7b254d
GP		 1457 }
1458 return changed;
1459}
1460
f3b827e0 1461static const struct snd_kcontrol_new snd_echo_digital_mode_switch = {
dd7b254d
GP		 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 *******************/
1476static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1477 struct snd_ctl_elem_info *uinfo)
1478{
c69a4f30 1479 static const char * const names[2] = {"Consumer", "Professional"};
dd7b254d 1480
c69a4f30 1481 return snd_ctl_enum_info(uinfo, 1, 2, names);
dd7b254d
GP		 1482}
1483
1484static 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
1494static 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
f3b827e0 1511static const struct snd_kcontrol_new snd_echo_spdif_mode_switch = {
dd7b254d
GP		 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 *******************/
1526static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1527 struct snd_ctl_elem_info *uinfo)
1528{
c69a4f30 1529 static const char * const names[8] = {
dd7b254d
GP		 1530 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1531 "ESync96", "MTC"
1532 };
1533 struct echoaudio *chip;
1534
1535 chip = snd_kcontrol_chip(kcontrol);
c69a4f30 1536 return snd_ctl_enum_info(uinfo, 1, chip->num_clock_sources, names);
dd7b254d
GP		 1537}
1538
1539static 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
1555static 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) {
befceea9 1569 mutex_lock(&chip->mode_mutex);
dd7b254d
GP		 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);
befceea9 1574 mutex_unlock(&chip->mode_mutex);
dd7b254d
GP		 1575 }
1576
1577 if (changed < 0)
b5b4a41b
SM		 1578 dev_dbg(chip->card->dev,
1579 "seticlk val%d err 0x%x\n", dclock, changed);
dd7b254d
GP		 1580
1581 return changed;
1582}
1583
f3b827e0 1584static const struct snd_kcontrol_new snd_echo_clock_source_switch = {
dd7b254d
GP		 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 *******************/
a5ce8890 1599#define snd_echo_phantom_power_info snd_ctl_boolean_mono_info
dd7b254d
GP		 1600
1601static 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
1610static 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
f3b827e0 1627static const struct snd_kcontrol_new snd_echo_phantom_power_switch = {
dd7b254d
GP		 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 *******************/
a5ce8890 1642#define snd_echo_automute_info snd_ctl_boolean_mono_info
dd7b254d
GP		 1643
1644static 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
1653static 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
f3b827e0 1670static const struct snd_kcontrol_new snd_echo_automute_switch = {
dd7b254d
GP		 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 *******************/
a5ce8890 1683#define snd_echo_vumeters_switch_info snd_ctl_boolean_mono_info
dd7b254d
GP		 1684
1685static 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
f3b827e0 1697static const struct snd_kcontrol_new snd_echo_vumeters_switch = {
dd7b254d
GP		 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) *****/
1708static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1709 struct snd_ctl_elem_info *uinfo)
1710{
dd7b254d 1711 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
51db452d 1712 uinfo->count = 96;
dd7b254d
GP		 1713 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1714 uinfo->value.integer.max = 0;
dd7b254d
GP		 1715 return 0;
1716}
1717
1718static 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
f3b827e0 1728static const struct snd_kcontrol_new snd_echo_vumeters = {
dd7b254d
GP		 1729 .name = "VU-meters",
1730 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
048b9450
GP		 1731 .access = SNDRV_CTL_ELEM_ACCESS_READ |
1732 SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1733 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
dd7b254d
GP		 1734 .info = snd_echo_vumeters_info,
1735 .get = snd_echo_vumeters_get,
048b9450 1736 .tlv = {.p = db_scale_output_gain},
dd7b254d
GP		 1737};
1738
1739
1740
1741/*** Channels info - it exports informations about the number of channels ***/
1742static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1743 struct snd_ctl_elem_info *uinfo)
1744{
dd7b254d
GP		 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
1752static 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
f3b827e0 1781static const struct snd_kcontrol_new snd_echo_channels_info = {
dd7b254d
GP		 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/******************************************************************************
a0b224b9 1793 IRQ Handling
dd7b254d 1794******************************************************************************/
a0b224b9
MH		 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 */
1802static 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}
dd7b254d 1825
7d12e780 1826static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
dd7b254d
GP		 1827{
1828 struct echoaudio *chip = dev_id;
a0b224b9 1829 int ss, st;
dd7b254d
GP		 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++) {
a0b224b9
MH		 1840 struct snd_pcm_substream *substream;
1841
b721e68b 1842 substream = chip->substream[ss];
a0b224b9
MH		 1843 if (substream && period_has_elapsed(substream)) {
1844 spin_unlock(&chip->lock);
1845 snd_pcm_period_elapsed(substream);
1846 spin_lock(&chip->lock);
dd7b254d
GP		 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);
b5b4a41b 1854 dev_dbg(chip->card->dev, "rawmidi_iread=%d\n", st);
dd7b254d
GP		 1855 }
1856#endif
1857 return IRQ_HANDLED;
1858}
1859
1860
1861
1862
1863/******************************************************************************
1864 Module construction / destruction
1865******************************************************************************/
1866
1867static int snd_echo_free(struct echoaudio *chip)
1868{
ebf029da 1869 if (chip->comm_page)
dd7b254d 1870 rest_in_peace(chip);
dd7b254d
GP		 1871
1872 if (chip->irq >= 0)
437a5a46 1873 free_irq(chip->irq, chip);
dd7b254d 1874
ebf029da
TI		 1875 if (chip->comm_page)
1876 snd_dma_free_pages(&chip->commpage_dma_buf);
1877
ff6defa6 1878 iounmap(chip->dsp_registers);
057a4a55 1879 release_and_free_resource(chip->iores);
dd7b254d
GP		 1880 pci_disable_device(chip->pci);
1881
1882 /* release chip data */
4f8ada44 1883 free_firmware_cache(chip);
dd7b254d 1884 kfree(chip);
dd7b254d
GP		 1885 return 0;
1886}
1887
1888
1889
1890static int snd_echo_dev_free(struct snd_device *device)
1891{
1892 struct echoaudio *chip = device->device_data;
1893
dd7b254d
GP		 1894 return snd_echo_free(chip);
1895}
1896
1897
1898
1899/* <--snd_echo_probe() */
e23e7a14
BP		 1900static int snd_echo_create(struct snd_card *card,
1901 struct pci_dev *pci,
1902 struct echoaudio **rchip)
dd7b254d
GP		 1903{
1904 struct echoaudio *chip;
1905 int err;
1906 size_t sz;
efb0ad25 1907 static const struct snd_device_ops ops = {
dd7b254d
GP		 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
47b5d028
GP		 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 }
b5b4a41b 1926 dev_dbg(card->dev, "chip=%p\n", chip);
47b5d028
GP		 1927 spin_lock_init(&chip->lock);
1928 chip->card = card;
1929 chip->pci = pci;
1930 chip->irq = -1;
027c7002 1931 chip->opencount = 0;
47b5d028
GP		 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;
dd7b254d 1939 }
dd7b254d
GP		 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) {
ece7a36d 1949 dev_err(chip->card->dev, "cannot get memory region\n");
4f50b41f 1950 snd_echo_free(chip);
dd7b254d
GP		 1951 return -EBUSY;
1952 }
85cb905d 1953 chip->dsp_registers = ioremap(chip->dsp_registers_phys, sz);
6ade657d
KL		 1954 if (!chip->dsp_registers) {
1955 dev_err(chip->card->dev, "ioremap failed\n");
1956 snd_echo_free(chip);
1957 return -ENOMEM;
1958 }
dd7b254d 1959
437a5a46 1960 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
934c2b6d 1961 KBUILD_MODNAME, chip)) {
ece7a36d 1962 dev_err(chip->card->dev, "cannot grab irq\n");
4f50b41f 1963 snd_echo_free(chip);
dd7b254d
GP		 1964 return -EBUSY;
1965 }
1966 chip->irq = pci->irq;
d4cad99f 1967 card->sync_irq = chip->irq;
b5b4a41b
SM		 1968 dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n",
1969 chip->pci, chip->irq, chip->pci->subsystem_device);
dd7b254d
GP		 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 */
7564d3b6 1973 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
dd7b254d
GP		 1974 sizeof(struct comm_page),
1975 &chip->commpage_dma_buf) < 0) {
ece7a36d 1976 dev_err(chip->card->dev, "cannot allocate the comm page\n");
4f50b41f 1977 snd_echo_free(chip);
dd7b254d
GP		 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);
47b5d028
GP		 1984 if (err >= 0)
1985 err = set_mixer_defaults(chip);
1986 if (err < 0) {
b5b4a41b 1987 dev_err(card->dev, "init_hw err=%d\n", err);
dd7b254d
GP		 1988 snd_echo_free(chip);
1989 return err;
1990 }
dd7b254d
GP		 1991
1992 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1993 snd_echo_free(chip);
1994 return err;
1995 }
dd7b254d
GP		 1996 *rchip = chip;
1997 /* Init done ! */
1998 return 0;
1999}
2000
2001
2002
2003/* constructor */
e23e7a14
BP		 2004static int snd_echo_probe(struct pci_dev *pci,
2005 const struct pci_device_id *pci_id)
dd7b254d
GP		 2006{
2007 static int dev;
2008 struct snd_card *card;
2009 struct echoaudio *chip;
2010 char *dsp;
8f53cb8e
PLB		 2011 __maybe_unused int i;
2012 int err;
dd7b254d
GP		 2013
2014 if (dev >= SNDRV_CARDS)
2015 return -ENODEV;
2016 if (!enable[dev]) {
2017 dev++;
2018 return -ENOENT;
2019 }
2020
dd7b254d 2021 i = 0;
60c5772b
TI		 2022 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2023 0, &card);
e58de7ba
TI		 2024 if (err < 0)
2025 return err;
dd7b254d 2026
47b5d028 2027 chip = NULL; /* Tells snd_echo_create to allocate chip */
dd7b254d
GP		 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) {
ece7a36d 2045 dev_err(chip->card->dev, "new pcm error %d\n", err);
dd7b254d
GP		 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) {
ece7a36d 2053 dev_err(chip->card->dev, "new midi error %d\n", err);
dd7b254d
GP		 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);
dd7b254d
GP		 2062 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2063 goto ctl_error;
392bf2f1
GP		 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)
dd7b254d
GP		 2068 goto ctl_error;
2069#endif
392bf2f1
GP		 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 */
dd7b254d
GP		 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
a0fd4345
JL		 2149 err = snd_card_register(card);
2150 if (err < 0)
dd7b254d 2151 goto ctl_error;
ece7a36d 2152 dev_info(card->dev, "Card registered: %s\n", card->longname);
dd7b254d
GP		 2153
2154 pci_set_drvdata(pci, chip);
2155 dev++;
2156 return 0;
2157
2158ctl_error:
ece7a36d 2159 dev_err(card->dev, "new control error %d\n", err);
dd7b254d
GP		 2160 snd_card_free(card);
2161 return err;
2162}
2163
2164
2165
c7561cd8 2166#if defined(CONFIG_PM_SLEEP)
47b5d028 2167
68cb2b55 2168static int snd_echo_suspend(struct device *dev)
47b5d028 2169{
68cb2b55 2170 struct echoaudio *chip = dev_get_drvdata(dev);
47b5d028 2171
47b5d028
GP		 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;
d4cad99f 2192 chip->card->sync_irq = -1;
47b5d028
GP		 2193 return 0;
2194}
2195
2196
2197
68cb2b55 2198static int snd_echo_resume(struct device *dev)
47b5d028 2199{
68cb2b55
TI		 2200 struct pci_dev *pci = to_pci_dev(dev);
2201 struct echoaudio *chip = dev_get_drvdata(dev);
47b5d028
GP		 2202 struct comm_page *commpage, *commpage_bak;
2203 u32 pipe_alloc_mask;
2204 int err;
2205
5e291a90
CY		 2206 commpage = chip->comm_page;
2207 commpage_bak = kmemdup(commpage, sizeof(*commpage), GFP_KERNEL);
0b6d092c
KV		 2208 if (commpage_bak == NULL)
2209 return -ENOMEM;
47b5d028
GP		 2210
2211 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2212 if (err < 0) {
2213 kfree(commpage_bak);
b5b4a41b 2214 dev_err(dev, "resume init_hw err=%d\n", err);
47b5d028
GP		 2215 return err;
2216 }
47b5d028
GP		 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 }
47b5d028
GP		 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,
934c2b6d 2239 KBUILD_MODNAME, chip)) {
ece7a36d 2240 dev_err(chip->card->dev, "cannot grab irq\n");
47b5d028
GP		 2241 return -EBUSY;
2242 }
2243 chip->irq = pci->irq;
d4cad99f 2244 chip->card->sync_irq = chip->irq;
b5b4a41b 2245 dev_dbg(dev, "resume irq=%d\n", chip->irq);
47b5d028
GP		 2246
2247#ifdef ECHOCARD_HAS_MIDI
2248 if (chip->midi_input_enabled)
3f6175ec 2249 enable_midi_input(chip, true);
47b5d028
GP		 2250 if (chip->midi_out)
2251 snd_echo_midi_output_trigger(chip->midi_out, 1);
2252#endif
2253
47b5d028
GP		 2254 return 0;
2255}
2256
68cb2b55
TI		 2257static 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
c7561cd8 2261#endif /* CONFIG_PM_SLEEP */
47b5d028
GP		 2262
2263
e23e7a14 2264static void snd_echo_remove(struct pci_dev *pci)
dd7b254d
GP		 2265{
2266 struct echoaudio *chip;
2267
2268 chip = pci_get_drvdata(pci);
2269 if (chip)
2270 snd_card_free(chip->card);
dd7b254d
GP		 2271}
2272
2273
2274
2275/******************************************************************************
2276 Everything starts and ends here
2277******************************************************************************/
2278
2279/* pci_driver definition */
e9f66d9b 2280static struct pci_driver echo_driver = {
3733e424 2281 .name = KBUILD_MODNAME,
dd7b254d
GP		 2282 .id_table = snd_echo_ids,
2283 .probe = snd_echo_probe,
e23e7a14 2284 .remove = snd_echo_remove,
68cb2b55
TI		 2285 .driver = {
2286 .pm = SND_ECHO_PM_OPS,
2287 },
dd7b254d
GP		 2288};
2289
e9f66d9b 2290module_pci_driver(echo_driver);
Ubuntu Hirsute Linux kernel mirror