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