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