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