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