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