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