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