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