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