source: GPL/trunk/alsa-kernel/pci/emu10k1/emupcm.c

Last change on this file was 777, checked in by David Azarewicz, 7 months ago

Merge from uniaud32-exp branch
File size: 58.1 KB
Line 
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 * Lee Revell <rlrevell@joe-job.com>
5 * James Courtier-Dutton <James@superbug.co.uk>
6 * Oswald Buddenhagen <oswald.buddenhagen@gmx.de>
7 * Creative Labs, Inc.
8 *
9 * Routines for control of EMU10K1 chips / PCM routines
10 */
11
12#include <linux/pci.h>
13#include <linux/delay.h>
14#include <linux/slab.h>
15#include <linux/time.h>
16#include <linux/init.h>
17#include <sound/core.h>
18#include <sound/emu10k1.h>
19
20static void snd_emu10k1_pcm_interrupt(struct snd_emu10k1 *emu,
21 struct snd_emu10k1_voice *voice)
22{
23 struct snd_emu10k1_pcm *epcm;
24
25 epcm = voice->epcm;
26 if (!epcm)
27 return;
28 if (epcm->substream == NULL)
29 return;
30#if 0
31 dev_dbg(emu->card->dev,
32 "IRQ: position = 0x%x, period = 0x%x, size = 0x%x\n",
33 epcm->substream->runtime->hw->pointer(emu, epcm->substream),
34 snd_pcm_lib_period_bytes(epcm->substream),
35 snd_pcm_lib_buffer_bytes(epcm->substream));
36#endif
37 snd_pcm_period_elapsed(epcm->substream);
38}
39
40static void snd_emu10k1_pcm_ac97adc_interrupt(struct snd_emu10k1 *emu,
41 unsigned int status)
42{
43#if 0
44 if (status & IPR_ADCBUFHALFFULL) {
45 if (emu->pcm_capture_substream->runtime->mode == SNDRV_PCM_MODE_FRAME)
46 return;
47 }
48#endif
49 snd_pcm_period_elapsed(emu->pcm_capture_substream);
50}
51
52static void snd_emu10k1_pcm_ac97mic_interrupt(struct snd_emu10k1 *emu,
53 unsigned int status)
54{
55#if 0
56 if (status & IPR_MICBUFHALFFULL) {
57 if (emu->pcm_capture_mic_substream->runtime->mode == SNDRV_PCM_MODE_FRAME)
58 return;
59 }
60#endif
61 snd_pcm_period_elapsed(emu->pcm_capture_mic_substream);
62}
63
64static void snd_emu10k1_pcm_efx_interrupt(struct snd_emu10k1 *emu,
65 unsigned int status)
66{
67#if 0
68 if (status & IPR_EFXBUFHALFFULL) {
69 if (emu->pcm_capture_efx_substream->runtime->mode == SNDRV_PCM_MODE_FRAME)
70 return;
71 }
72#endif
73 snd_pcm_period_elapsed(emu->pcm_capture_efx_substream);
74}
75
76static void snd_emu10k1_pcm_free_voices(struct snd_emu10k1_pcm *epcm)
77{
78 for (unsigned i = 0; i < ARRAY_SIZE(epcm->voices); i++) {
79 if (epcm->voices[i]) {
80 snd_emu10k1_voice_free(epcm->emu, epcm->voices[i]);
81 epcm->voices[i] = NULL;
82 }
83 }
84}
85
86static int snd_emu10k1_pcm_channel_alloc(struct snd_emu10k1_pcm *epcm,
87 int type, int count, int channels)
88{
89 int err;
90
91 snd_emu10k1_pcm_free_voices(epcm);
92
93 err = snd_emu10k1_voice_alloc(epcm->emu,
94 type, count, channels,
95 epcm, &epcm->voices[0]);
96 if (err < 0)
97 return err;
98
99 if (epcm->extra == NULL) {
100 // The hardware supports only (half-)loop interrupts, so to support an
101 // arbitrary number of periods per buffer, we use an extra voice with a
102 // period-sized loop as the interrupt source. Additionally, the interrupt
103 // timing of the hardware is "suboptimal" and needs some compensation.
104 err = snd_emu10k1_voice_alloc(epcm->emu,
105 type + 1, 1, 1,
106 epcm, &epcm->extra);
107 if (err < 0) {
108 /*
109 dev_dbg(emu->card->dev, "pcm_channel_alloc: "
110 "failed extra: voices=%d, frame=%d\n",
111 voices, frame);
112 */
113 snd_emu10k1_pcm_free_voices(epcm);
114 return err;
115 }
116 epcm->extra->interrupt = snd_emu10k1_pcm_interrupt;
117 }
118
119 return 0;
120}
121
122// Primes 2-7 and 2^n multiples thereof, up to 16.
123static const unsigned int efx_capture_channels[] = {
124 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16
125};
126
127static const struct snd_pcm_hw_constraint_list hw_constraints_efx_capture_channels = {
128 .count = ARRAY_SIZE(efx_capture_channels),
129 .list = efx_capture_channels,
130 .mask = 0
131};
132
133static const unsigned int capture_buffer_sizes[31] = {
134 384, 448, 512, 640,
135 384*2, 448*2, 512*2, 640*2,
136 384*4, 448*4, 512*4, 640*4,
137 384*8, 448*8, 512*8, 640*8,
138 384*16, 448*16, 512*16, 640*16,
139 384*32, 448*32, 512*32, 640*32,
140 384*64, 448*64, 512*64, 640*64,
141 384*128,448*128,512*128
142};
143
144static const struct snd_pcm_hw_constraint_list hw_constraints_capture_buffer_sizes = {
145 .count = 31,
146 .list = capture_buffer_sizes,
147 .mask = 0
148};
149
150static unsigned int snd_emu10k1_capture_rate_reg(unsigned int rate)
151{
152 switch (rate) {
153 case 8000: return ADCCR_SAMPLERATE_8;
154 case 11025: return ADCCR_SAMPLERATE_11;
155 case 16000: return ADCCR_SAMPLERATE_16;
156 case 22050: return ADCCR_SAMPLERATE_22;
157 case 24000: return ADCCR_SAMPLERATE_24;
158 case 32000: return ADCCR_SAMPLERATE_32;
159 case 44100: return ADCCR_SAMPLERATE_44;
160 case 48000: return ADCCR_SAMPLERATE_48;
161 default:
162 snd_BUG();
163 return ADCCR_SAMPLERATE_8;
164 }
165}
166
167static unsigned int snd_emu10k1_audigy_capture_rate_reg(unsigned int rate)
168{
169 switch (rate) {
170 case 8000: return A_ADCCR_SAMPLERATE_8;
171 case 11025: return A_ADCCR_SAMPLERATE_11;
172 case 12000: return A_ADCCR_SAMPLERATE_12;
173 case 16000: return ADCCR_SAMPLERATE_16;
174 case 22050: return ADCCR_SAMPLERATE_22;
175 case 24000: return ADCCR_SAMPLERATE_24;
176 case 32000: return ADCCR_SAMPLERATE_32;
177 case 44100: return ADCCR_SAMPLERATE_44;
178 case 48000: return ADCCR_SAMPLERATE_48;
179 default:
180 snd_BUG();
181 return A_ADCCR_SAMPLERATE_8;
182 }
183}
184
185static void snd_emu10k1_constrain_capture_rates(struct snd_emu10k1 *emu,
186 struct snd_pcm_runtime *runtime)
187{
188 if (emu->card_capabilities->emu_model &&
189 emu->emu1010.word_clock == 44100) {
190 runtime->hw.rates = SNDRV_PCM_RATE_11025 | \
191 SNDRV_PCM_RATE_22050 | \
192 SNDRV_PCM_RATE_44100;
193 runtime->hw.rate_min = 11025;
194 runtime->hw.rate_max = 44100;
195 } else if (emu->audigy) {
196 runtime->hw.rates = SNDRV_PCM_RATE_8000_48000 |
197 SNDRV_PCM_RATE_12000 |
198 SNDRV_PCM_RATE_24000;
199 }
200}
201
202static void snd_emu1010_constrain_efx_rate(struct snd_emu10k1 *emu,
203 struct snd_pcm_runtime *runtime)
204{
205 int rate;
206
207 rate = emu->emu1010.word_clock;
208 runtime->hw.rate_min = runtime->hw.rate_max = rate;
209 runtime->hw.rates = snd_pcm_rate_to_rate_bit(rate);
210}
211
212static unsigned int emu10k1_calc_pitch_target(unsigned int rate)
213{
214 unsigned int pitch_target;
215
216 pitch_target = (rate << 8) / 375;
217 pitch_target = (pitch_target >> 1) + (pitch_target & 1);
218 return pitch_target;
219}
220
221#define PITCH_48000 0x00004000
222#define PITCH_96000 0x00008000
223#define PITCH_85000 0x00007155
224#define PITCH_80726 0x00006ba2
225#define PITCH_67882 0x00005a82
226#define PITCH_57081 0x00004c1c
227
228static unsigned int emu10k1_select_interprom(unsigned int pitch_target)
229{
230 if (pitch_target == PITCH_48000)
231 return CCCA_INTERPROM_0;
232 else if (pitch_target < PITCH_48000)
233 return CCCA_INTERPROM_1;
234 else if (pitch_target >= PITCH_96000)
235 return CCCA_INTERPROM_0;
236 else if (pitch_target >= PITCH_85000)
237 return CCCA_INTERPROM_6;
238 else if (pitch_target >= PITCH_80726)
239 return CCCA_INTERPROM_5;
240 else if (pitch_target >= PITCH_67882)
241 return CCCA_INTERPROM_4;
242 else if (pitch_target >= PITCH_57081)
243 return CCCA_INTERPROM_3;
244 else
245 return CCCA_INTERPROM_2;
246}
247
248static u16 emu10k1_send_target_from_amount(u8 amount)
249{
250 static const u8 shifts[8] = { 4, 4, 5, 6, 7, 8, 9, 10 };
251 static const u16 offsets[8] = { 0, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000 };
252 u8 exp;
253
254 if (amount == 0xff)
255 return 0xffff;
256 exp = amount >> 5;
257 return ((amount & 0x1f) << shifts[exp]) + offsets[exp];
258}
259
260static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu,
261 struct snd_emu10k1_voice *evoice,
262 bool w_16, bool stereo,
263 unsigned int start_addr,
264 unsigned int end_addr,
265 const unsigned char *send_routing,
266 const unsigned char *send_amount)
267{
268 unsigned int silent_page;
269 int voice;
270
271 voice = evoice->number;
272
273 silent_page = ((unsigned int)emu->silent_page.addr << emu->address_mode) |
274 (emu->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
275 snd_emu10k1_ptr_write_multiple(emu, voice,
276 // Not really necessary for the slave, but it doesn't hurt
277 CPF, stereo ? CPF_STEREO_MASK : 0,
278 // Assumption that PT is already 0 so no harm overwriting
279 PTRX, (send_amount[0] << 8) | send_amount[1],
280 // Stereo slaves don't need to have the addresses set, but it doesn't hurt
281 DSL, end_addr | (send_amount[3] << 24),
282 PSST, start_addr | (send_amount[2] << 24),
283 CCCA, emu10k1_select_interprom(evoice->epcm->pitch_target) |
284 (w_16 ? 0 : CCCA_8BITSELECT),
285 // Clear filter delay memory
286 Z1, 0,
287 Z2, 0,
288 // Invalidate maps
289 MAPA, silent_page,
290 MAPB, silent_page,
291 // Disable filter (in conjunction with CCCA_RESONANCE == 0)
292 VTFT, VTFT_FILTERTARGET_MASK,
293 CVCF, CVCF_CURRENTFILTER_MASK,
294 REGLIST_END);
295 // Setup routing
296 if (emu->audigy) {
297 snd_emu10k1_ptr_write_multiple(emu, voice,
298 A_FXRT1, snd_emu10k1_compose_audigy_fxrt1(send_routing),
299 A_FXRT2, snd_emu10k1_compose_audigy_fxrt2(send_routing),
300 A_SENDAMOUNTS, snd_emu10k1_compose_audigy_sendamounts(send_amount),
301 REGLIST_END);
302 for (int i = 0; i < 4; i++) {
303 u32 aml = emu10k1_send_target_from_amount(send_amount[2 * i]);
304 u32 amh = emu10k1_send_target_from_amount(send_amount[2 * i + 1]);
305 snd_emu10k1_ptr_write(emu, A_CSBA + i, voice, (amh << 16) | aml);
306 }
307 } else {
308 snd_emu10k1_ptr_write(emu, FXRT, voice,
309 snd_emu10k1_compose_send_routing(send_routing));
310 }
311
312 emu->voices[voice].dirty = 1;
313}
314
315static void snd_emu10k1_pcm_init_voices(struct snd_emu10k1 *emu,
316 struct snd_emu10k1_voice *evoice,
317 bool w_16, bool stereo,
318 unsigned int start_addr,
319 unsigned int end_addr,
320 struct snd_emu10k1_pcm_mixer *mix)
321{
322 spin_lock_irq(&emu->reg_lock);
323 snd_emu10k1_pcm_init_voice(emu, evoice, w_16, stereo,
324 start_addr, end_addr,
325 &mix->send_routing[stereo][0],
326 &mix->send_volume[stereo][0]);
327 if (stereo)
328 snd_emu10k1_pcm_init_voice(emu, evoice + 1, w_16, true,
329 start_addr, end_addr,
330 &mix->send_routing[2][0],
331 &mix->send_volume[2][0]);
332 spin_unlock_irq(&emu->reg_lock);
333}
334
335static void snd_emu10k1_pcm_init_extra_voice(struct snd_emu10k1 *emu,
336 struct snd_emu10k1_voice *evoice,
337 bool w_16,
338 unsigned int start_addr,
339 unsigned int end_addr)
340{
341 static const unsigned char send_routing[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
342 static const unsigned char send_amount[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
343
344 snd_emu10k1_pcm_init_voice(emu, evoice, w_16, false,
345 start_addr, end_addr,
346 send_routing, send_amount);
347}
348
349static int snd_emu10k1_playback_hw_params(struct snd_pcm_substream *substream,
350 struct snd_pcm_hw_params *hw_params)
351{
352 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
353 struct snd_pcm_runtime *runtime = substream->runtime;
354 struct snd_emu10k1_pcm *epcm = runtime->private_data;
355 size_t alloc_size;
356 int type, channels, count;
357 int err;
358
359 if (epcm->type == PLAYBACK_EMUVOICE) {
360 type = EMU10K1_PCM;
361 channels = 1;
362 count = params_channels(hw_params);
363 } else {
364 type = EMU10K1_EFX;
365 channels = params_channels(hw_params);
366 count = 1;
367 }
368 err = snd_emu10k1_pcm_channel_alloc(epcm, type, count, channels);
369 if (err < 0)
370 return err;
371
372 alloc_size = params_buffer_bytes(hw_params);
373 if (emu->iommu_workaround)
374 alloc_size += EMUPAGESIZE;
375 err = snd_pcm_lib_malloc_pages(substream, alloc_size);
376 if (err < 0)
377 return err;
378 if (emu->iommu_workaround && runtime->dma_bytes >= EMUPAGESIZE)
379 runtime->dma_bytes -= EMUPAGESIZE;
380 if (err > 0) { /* change */
381 int mapped;
382 if (epcm->memblk != NULL)
383 snd_emu10k1_free_pages(emu, epcm->memblk);
384 epcm->memblk = snd_emu10k1_alloc_pages(emu, substream);
385 epcm->start_addr = 0;
386 if (! epcm->memblk)
387 return -ENOMEM;
388 mapped = ((struct snd_emu10k1_memblk *)epcm->memblk)->mapped_page;
389 if (mapped < 0)
390 return -ENOMEM;
391 epcm->start_addr = mapped << PAGE_SHIFT;
392 }
393 return 0;
394}
395
396static int snd_emu10k1_playback_hw_free(struct snd_pcm_substream *substream)
397{
398 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
399 struct snd_pcm_runtime *runtime = substream->runtime;
400 struct snd_emu10k1_pcm *epcm;
401
402 if (runtime->private_data == NULL)
403 return 0;
404 epcm = runtime->private_data;
405 if (epcm->extra) {
406 snd_emu10k1_voice_free(epcm->emu, epcm->extra);
407 epcm->extra = NULL;
408 }
409 snd_emu10k1_pcm_free_voices(epcm);
410 if (epcm->memblk) {
411 snd_emu10k1_free_pages(emu, epcm->memblk);
412 epcm->memblk = NULL;
413 epcm->start_addr = 0;
414 }
415 snd_pcm_lib_free_pages(substream);
416 return 0;
417}
418
419static int snd_emu10k1_playback_prepare(struct snd_pcm_substream *substream)
420{
421 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
422 struct snd_pcm_runtime *runtime = substream->runtime;
423 struct snd_emu10k1_pcm *epcm = runtime->private_data;
424 bool w_16 = snd_pcm_format_width(runtime->format) == 16;
425 bool stereo = runtime->channels == 2;
426 unsigned int start_addr, end_addr;
427 unsigned int rate;
428
429 rate = runtime->rate;
430 if (emu->card_capabilities->emu_model &&
431 emu->emu1010.word_clock == 44100)
432 rate = rate * 480 / 441;
433 epcm->pitch_target = emu10k1_calc_pitch_target(rate);
434
435 start_addr = epcm->start_addr >> w_16;
436 end_addr = start_addr + runtime->period_size;
437 snd_emu10k1_pcm_init_extra_voice(emu, epcm->extra, w_16,
438 start_addr, end_addr);
439 start_addr >>= stereo;
440 epcm->ccca_start_addr = start_addr;
441 end_addr = start_addr + runtime->buffer_size;
442 snd_emu10k1_pcm_init_voices(emu, epcm->voices[0], w_16, stereo,
443 start_addr, end_addr,
444 &emu->pcm_mixer[substream->number]);
445
446 return 0;
447}
448
449static int snd_emu10k1_efx_playback_prepare(struct snd_pcm_substream *substream)
450{
451 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
452 struct snd_pcm_runtime *runtime = substream->runtime;
453 struct snd_emu10k1_pcm *epcm = runtime->private_data;
454 unsigned int start_addr;
455 unsigned int extra_size, channel_size;
456 unsigned int i;
457
458 epcm->pitch_target = PITCH_48000;
459
460 start_addr = epcm->start_addr >> 1; // 16-bit voices
461
462 extra_size = runtime->period_size;
463 channel_size = runtime->buffer_size;
464
465 snd_emu10k1_pcm_init_extra_voice(emu, epcm->extra, true,
466 start_addr, start_addr + extra_size);
467
468 epcm->ccca_start_addr = start_addr;
469 for (i = 0; i < runtime->channels; i++) {
470 snd_emu10k1_pcm_init_voices(emu, epcm->voices[i], true, false,
471 start_addr, start_addr + channel_size,
472 &emu->efx_pcm_mixer[i]);
473 start_addr += channel_size;
474 }
475
476 return 0;
477}
478
479static const struct snd_pcm_hardware snd_emu10k1_efx_playback =
480{
481 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_NONINTERLEAVED |
482 SNDRV_PCM_INFO_BLOCK_TRANSFER |
483 SNDRV_PCM_INFO_RESUME |
484 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE),
485 .formats = SNDRV_PCM_FMTBIT_S16_LE,
486 .rates = SNDRV_PCM_RATE_48000,
487 .rate_min = 48000,
488 .rate_max = 48000,
489 .channels_min = 1,
490 .channels_max = NUM_EFX_PLAYBACK,
491 .buffer_bytes_max = (128*1024),
492 .period_bytes_max = (128*1024),
493 .periods_min = 2,
494 .periods_max = 1024,
495 .fifo_size = 0,
496};
497
498static int snd_emu10k1_capture_prepare(struct snd_pcm_substream *substream)
499{
500 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
501 struct snd_pcm_runtime *runtime = substream->runtime;
502 struct snd_emu10k1_pcm *epcm = runtime->private_data;
503 int idx;
504
505 /* zeroing the buffer size will stop capture */
506 snd_emu10k1_ptr_write(emu, epcm->capture_bs_reg, 0, 0);
507 switch (epcm->type) {
508 case CAPTURE_AC97ADC:
509 snd_emu10k1_ptr_write(emu, ADCCR, 0, 0);
510 break;
511 case CAPTURE_EFX:
512 if (emu->card_capabilities->emu_model) {
513 // The upper 32 16-bit capture voices, two for each of the 16 32-bit channels.
514 // The lower voices are occupied by A_EXTOUT_*_CAP*.
515 epcm->capture_cr_val = 0;
516 epcm->capture_cr_val2 = 0xffffffff >> (32 - runtime->channels * 2);
517 }
518 if (emu->audigy) {
519 snd_emu10k1_ptr_write_multiple(emu, 0,
520 A_FXWC1, 0,
521 A_FXWC2, 0,
522 REGLIST_END);
523 } else
524 snd_emu10k1_ptr_write(emu, FXWC, 0, 0);
525 break;
526 default:
527 break;
528 }
529 snd_emu10k1_ptr_write(emu, epcm->capture_ba_reg, 0, runtime->dma_addr);
530 epcm->capture_bufsize = snd_pcm_lib_buffer_bytes(substream);
531 epcm->capture_bs_val = 0;
532 for (idx = 0; idx < 31; idx++) {
533 if (capture_buffer_sizes[idx] == epcm->capture_bufsize) {
534 epcm->capture_bs_val = idx + 1;
535 break;
536 }
537 }
538 if (epcm->capture_bs_val == 0) {
539 snd_BUG();
540 epcm->capture_bs_val++;
541 }
542 if (epcm->type == CAPTURE_AC97ADC) {
543 unsigned rate = runtime->rate;
544 if (!(runtime->hw.rates & SNDRV_PCM_RATE_48000))
545 rate = rate * 480 / 441;
546
547 epcm->capture_cr_val = emu->audigy ? A_ADCCR_LCHANENABLE : ADCCR_LCHANENABLE;
548 if (runtime->channels > 1)
549 epcm->capture_cr_val |= emu->audigy ? A_ADCCR_RCHANENABLE : ADCCR_RCHANENABLE;
550 epcm->capture_cr_val |= emu->audigy ?
551 snd_emu10k1_audigy_capture_rate_reg(rate) :
552 snd_emu10k1_capture_rate_reg(rate);
553 }
554 return 0;
555}
556
557static void snd_emu10k1_playback_fill_cache(struct snd_emu10k1 *emu,
558 unsigned voice,
559 u32 sample, bool stereo)
560{
561 u32 ccr;
562
563 // We assume that the cache is resting at this point (i.e.,
564 // CCR_CACHEINVALIDSIZE is very small).
565
566 // Clear leading frames. For simplicitly, this does too much,
567 // except for 16-bit stereo. And the interpolator will actually
568 // access them at all only when we're pitch-shifting.
569 for (int i = 0; i < 3; i++)
570 snd_emu10k1_ptr_write(emu, CD0 + i, voice, sample);
571
572 // Fill cache
573 ccr = (64 - 3) << REG_SHIFT(CCR_CACHEINVALIDSIZE);
574 if (stereo) {
575 // The engine goes haywire if CCR_READADDRESS is out of sync
576 snd_emu10k1_ptr_write(emu, CCR, voice + 1, ccr);
577 }
578 snd_emu10k1_ptr_write(emu, CCR, voice, ccr);
579}
580
581static void snd_emu10k1_playback_prepare_voices(struct snd_emu10k1 *emu,
582 struct snd_emu10k1_pcm *epcm,
583 bool w_16, bool stereo,
584 int channels)
585{
586 struct snd_pcm_substream *substream = epcm->substream;
587 struct snd_pcm_runtime *runtime = substream->runtime;
588 unsigned eloop_start = epcm->start_addr >> w_16;
589 unsigned loop_start = eloop_start >> stereo;
590 unsigned eloop_size = runtime->period_size;
591 unsigned loop_size = runtime->buffer_size;
592 u32 sample = w_16 ? 0 : 0x80808080;
593
594 // To make the playback actually start at the 1st frame,
595 // we need to compensate for two circumstances:
596 // - The actual position is delayed by the cache size (64 frames)
597 // - The interpolator is centered around the 4th frame
598 loop_start += (epcm->resume_pos + 64 - 3) % loop_size;
599 for (int i = 0; i < channels; i++) {
600 unsigned voice = epcm->voices[i]->number;
601 snd_emu10k1_ptr_write(emu, CCCA_CURRADDR, voice, loop_start);
602 loop_start += loop_size;
603 snd_emu10k1_playback_fill_cache(emu, voice, sample, stereo);
604 }
605
606 // The interrupt is triggered when CCCA_CURRADDR (CA) wraps around,
607 // which is ahead of the actual playback position, so the interrupt
608 // source needs to be delayed.
609 //
610 // In principle, this wouldn't need to be the cache's entire size - in
611 // practice, CCR_CACHEINVALIDSIZE (CIS) > `fetch threshold` has never
612 // been observed, and assuming 40 _bytes_ should be safe.
613 //
614 // The cache fills are somewhat random, which makes it impossible to
615 // align them with the interrupts. This makes a non-delayed interrupt
616 // source not practical, as the interrupt handler would have to wait
617 // for (CA - CIS) >= period_boundary for every channel in the stream.
618 //
619 // This is why all other (open) drivers for these chips use timer-based
620 // interrupts.
621 //
622 eloop_start += (epcm->resume_pos + eloop_size - 3) % eloop_size;
623 snd_emu10k1_ptr_write(emu, CCCA_CURRADDR, epcm->extra->number, eloop_start);
624
625 // It takes a moment until the cache fills complete,
626 // but the unmuting takes long enough for that.
627}
628
629static void snd_emu10k1_playback_commit_volume(struct snd_emu10k1 *emu,
630 struct snd_emu10k1_voice *evoice,
631 unsigned int vattn)
632{
633 snd_emu10k1_ptr_write_multiple(emu, evoice->number,
634 VTFT, vattn | VTFT_FILTERTARGET_MASK,
635 CVCF, vattn | CVCF_CURRENTFILTER_MASK,
636 REGLIST_END);
637}
638
639static void snd_emu10k1_playback_unmute_voice(struct snd_emu10k1 *emu,
640 struct snd_emu10k1_voice *evoice,
641 bool stereo, bool master,
642 struct snd_emu10k1_pcm_mixer *mix)
643{
644 unsigned int vattn;
645 unsigned int tmp;
646
647 tmp = stereo ? (master ? 1 : 2) : 0;
648 vattn = mix->attn[tmp] << 16;
649 snd_emu10k1_playback_commit_volume(emu, evoice, vattn);
650}
651
652static void snd_emu10k1_playback_unmute_voices(struct snd_emu10k1 *emu,
653 struct snd_emu10k1_voice *evoice,
654 bool stereo,
655 struct snd_emu10k1_pcm_mixer *mix)
656{
657 snd_emu10k1_playback_unmute_voice(emu, evoice, stereo, true, mix);
658 if (stereo)
659 snd_emu10k1_playback_unmute_voice(emu, evoice + 1, true, false, mix);
660}
661
662static void snd_emu10k1_playback_mute_voice(struct snd_emu10k1 *emu,
663 struct snd_emu10k1_voice *evoice)
664{
665 snd_emu10k1_playback_commit_volume(emu, evoice, 0);
666}
667
668static void snd_emu10k1_playback_mute_voices(struct snd_emu10k1 *emu,
669 struct snd_emu10k1_voice *evoice,
670 bool stereo)
671{
672 snd_emu10k1_playback_mute_voice(emu, evoice);
673 if (stereo)
674 snd_emu10k1_playback_mute_voice(emu, evoice + 1);
675}
676
677static void snd_emu10k1_playback_commit_pitch(struct snd_emu10k1 *emu,
678 u32 voice, u32 pitch_target)
679{
680 u32 ptrx = snd_emu10k1_ptr_read(emu, PTRX, voice);
681 u32 cpf = snd_emu10k1_ptr_read(emu, CPF, voice);
682 snd_emu10k1_ptr_write_multiple(emu, voice,
683 PTRX, (ptrx & ~PTRX_PITCHTARGET_MASK) | pitch_target,
684 CPF, (cpf & ~(CPF_CURRENTPITCH_MASK | CPF_FRACADDRESS_MASK)) | pitch_target,
685 REGLIST_END);
686}
687
688static void snd_emu10k1_playback_trigger_voice(struct snd_emu10k1 *emu,
689 struct snd_emu10k1_voice *evoice)
690{
691 unsigned int voice;
692
693 voice = evoice->number;
694 snd_emu10k1_playback_commit_pitch(emu, voice, evoice->epcm->pitch_target << 16);
695}
696
697static void snd_emu10k1_playback_stop_voice(struct snd_emu10k1 *emu,
698 struct snd_emu10k1_voice *evoice)
699{
700 unsigned int voice;
701
702 voice = evoice->number;
703 snd_emu10k1_playback_commit_pitch(emu, voice, 0);
704}
705
706static void snd_emu10k1_playback_set_running(struct snd_emu10k1 *emu,
707 struct snd_emu10k1_pcm *epcm)
708{
709 epcm->running = 1;
710 snd_emu10k1_voice_intr_enable(emu, epcm->extra->number);
711}
712
713static void snd_emu10k1_playback_set_stopped(struct snd_emu10k1 *emu,
714 struct snd_emu10k1_pcm *epcm)
715{
716 snd_emu10k1_voice_intr_disable(emu, epcm->extra->number);
717 epcm->running = 0;
718}
719
720static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream,
721 int cmd)
722{
723 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
724 struct snd_pcm_runtime *runtime = substream->runtime;
725 struct snd_emu10k1_pcm *epcm = runtime->private_data;
726 struct snd_emu10k1_pcm_mixer *mix;
727 bool w_16 = snd_pcm_format_width(runtime->format) == 16;
728 bool stereo = runtime->channels == 2;
729 int result = 0;
730
731 /*
732 dev_dbg(emu->card->dev,
733 "trigger - emu10k1 = 0x%x, cmd = %i, pointer = %i\n",
734 (int)emu, cmd, substream->ops->pointer(substream))
735 */
736 spin_lock(&emu->reg_lock);
737 switch (cmd) {
738 case SNDRV_PCM_TRIGGER_START:
739 snd_emu10k1_playback_prepare_voices(emu, epcm, w_16, stereo, 1);
740 fallthrough;
741 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
742 case SNDRV_PCM_TRIGGER_RESUME:
743 mix = &emu->pcm_mixer[substream->number];
744 snd_emu10k1_playback_unmute_voices(emu, epcm->voices[0], stereo, mix);
745 snd_emu10k1_playback_set_running(emu, epcm);
746 snd_emu10k1_playback_trigger_voice(emu, epcm->voices[0]);
747 snd_emu10k1_playback_trigger_voice(emu, epcm->extra);
748 break;
749 case SNDRV_PCM_TRIGGER_STOP:
750 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
751 case SNDRV_PCM_TRIGGER_SUSPEND:
752 snd_emu10k1_playback_stop_voice(emu, epcm->voices[0]);
753 snd_emu10k1_playback_stop_voice(emu, epcm->extra);
754 snd_emu10k1_playback_set_stopped(emu, epcm);
755 snd_emu10k1_playback_mute_voices(emu, epcm->voices[0], stereo);
756 break;
757 default:
758 result = -EINVAL;
759 break;
760 }
761 spin_unlock(&emu->reg_lock);
762 return result;
763}
764
765static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream,
766 int cmd)
767{
768 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
769 struct snd_pcm_runtime *runtime = substream->runtime;
770 struct snd_emu10k1_pcm *epcm = runtime->private_data;
771 int result = 0;
772
773 spin_lock(&emu->reg_lock);
774 switch (cmd) {
775 case SNDRV_PCM_TRIGGER_START:
776 case SNDRV_PCM_TRIGGER_RESUME:
777 /* hmm this should cause full and half full interrupt to be raised? */
778 outl(epcm->capture_ipr, emu->port + IPR);
779 snd_emu10k1_intr_enable(emu, epcm->capture_inte);
780 /*
781 dev_dbg(emu->card->dev, "adccr = 0x%x, adcbs = 0x%x\n",
782 epcm->adccr, epcm->adcbs);
783 */
784 switch (epcm->type) {
785 case CAPTURE_AC97ADC:
786 snd_emu10k1_ptr_write(emu, ADCCR, 0, epcm->capture_cr_val);
787 break;
788 case CAPTURE_EFX:
789 if (emu->audigy) {
790 snd_emu10k1_ptr_write_multiple(emu, 0,
791 A_FXWC1, epcm->capture_cr_val,
792 A_FXWC2, epcm->capture_cr_val2,
793 REGLIST_END);
794 dev_dbg(emu->card->dev,
795 "cr_val=0x%x, cr_val2=0x%x\n",
796 epcm->capture_cr_val,
797 epcm->capture_cr_val2);
798 } else
799 snd_emu10k1_ptr_write(emu, FXWC, 0, epcm->capture_cr_val);
800 break;
801 default:
802 break;
803 }
804 snd_emu10k1_ptr_write(emu, epcm->capture_bs_reg, 0, epcm->capture_bs_val);
805 epcm->running = 1;
806 epcm->first_ptr = 1;
807 break;
808 case SNDRV_PCM_TRIGGER_STOP:
809 case SNDRV_PCM_TRIGGER_SUSPEND:
810 epcm->running = 0;
811 snd_emu10k1_intr_disable(emu, epcm->capture_inte);
812 outl(epcm->capture_ipr, emu->port + IPR);
813 snd_emu10k1_ptr_write(emu, epcm->capture_bs_reg, 0, 0);
814 switch (epcm->type) {
815 case CAPTURE_AC97ADC:
816 snd_emu10k1_ptr_write(emu, ADCCR, 0, 0);
817 break;
818 case CAPTURE_EFX:
819 if (emu->audigy) {
820 snd_emu10k1_ptr_write_multiple(emu, 0,
821 A_FXWC1, 0,
822 A_FXWC2, 0,
823 REGLIST_END);
824 } else
825 snd_emu10k1_ptr_write(emu, FXWC, 0, 0);
826 break;
827 default:
828 break;
829 }
830 break;
831 default:
832 result = -EINVAL;
833 }
834 spin_unlock(&emu->reg_lock);
835 return result;
836}
837
838static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream *substream)
839{
840 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
841 struct snd_pcm_runtime *runtime = substream->runtime;
842 struct snd_emu10k1_pcm *epcm = runtime->private_data;
843 int ptr;
844
845 if (!epcm->running)
846 return 0;
847
848 ptr = snd_emu10k1_ptr_read(emu, CCCA, epcm->voices[0]->number) & 0x00ffffff;
849 ptr -= epcm->ccca_start_addr;
850
851 // This is the size of the whole cache minus the interpolator read-ahead,
852 // which leads us to the actual playback position.
853 //
854 // The cache is constantly kept mostly filled, so in principle we could
855 // return a more advanced position representing how far the hardware has
856 // already read the buffer, and set runtime->delay accordingly. However,
857 // this would be slightly different for every channel (and remarkably slow
858 // to obtain), so only a fixed worst-case value would be practical.
859 //
860 ptr -= 64 - 3;
861 if (ptr < 0)
862 ptr += runtime->buffer_size;
863
864 /*
865 dev_dbg(emu->card->dev,
866 "ptr = 0x%lx, buffer_size = 0x%lx, period_size = 0x%lx\n",
867 (long)ptr, (long)runtime->buffer_size,
868 (long)runtime->period_size);
869 */
870 return ptr;
871}
872
873static u64 snd_emu10k1_efx_playback_voice_mask(struct snd_emu10k1_pcm *epcm,
874 int channels)
875{
876 u64 mask = 0;
877
878 for (int i = 0; i < channels; i++) {
879 int voice = epcm->voices[i]->number;
880 mask |= 1ULL << voice;
881 }
882 return mask;
883}
884
885static void snd_emu10k1_efx_playback_freeze_voices(struct snd_emu10k1 *emu,
886 struct snd_emu10k1_pcm *epcm,
887 int channels)
888{
889 for (int i = 0; i < channels; i++) {
890 int voice = epcm->voices[i]->number;
891 snd_emu10k1_ptr_write(emu, CPF_STOP, voice, 1);
892 snd_emu10k1_playback_commit_pitch(emu, voice, PITCH_48000 << 16);
893 }
894}
895
896static void snd_emu10k1_efx_playback_unmute_voices(struct snd_emu10k1 *emu,
897 struct snd_emu10k1_pcm *epcm,
898 int channels)
899{
900 for (int i = 0; i < channels; i++)
901 snd_emu10k1_playback_unmute_voice(emu, epcm->voices[i], false, true,
902 &emu->efx_pcm_mixer[i]);
903}
904
905static void snd_emu10k1_efx_playback_stop_voices(struct snd_emu10k1 *emu,
906 struct snd_emu10k1_pcm *epcm,
907 int channels)
908{
909 for (int i = 0; i < channels; i++)
910 snd_emu10k1_playback_stop_voice(emu, epcm->voices[i]);
911 snd_emu10k1_playback_set_stopped(emu, epcm);
912
913 for (int i = 0; i < channels; i++)
914 snd_emu10k1_playback_mute_voice(emu, epcm->voices[i]);
915}
916
917static int snd_emu10k1_efx_playback_trigger(struct snd_pcm_substream *substream,
918 int cmd)
919{
920 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
921 struct snd_pcm_runtime *runtime = substream->runtime;
922 struct snd_emu10k1_pcm *epcm = runtime->private_data;
923 u64 mask;
924 int result = 0;
925
926 spin_lock(&emu->reg_lock);
927 switch (cmd) {
928 case SNDRV_PCM_TRIGGER_START:
929 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
930 case SNDRV_PCM_TRIGGER_RESUME:
931 mask = snd_emu10k1_efx_playback_voice_mask(
932 epcm, runtime->channels);
933 for (int i = 0; i < 10; i++) {
934 // Note that the freeze is not interruptible, so we make no
935 // effort to reset the bits outside the error handling here.
936 snd_emu10k1_voice_set_loop_stop_multiple(emu, mask);
937 snd_emu10k1_efx_playback_freeze_voices(
938 emu, epcm, runtime->channels);
939 snd_emu10k1_playback_prepare_voices(
940 emu, epcm, true, false, runtime->channels);
941
942 // It might seem to make more sense to unmute the voices only after
943 // they have been started, to potentially avoid torturing the speakers
944 // if something goes wrong. However, we cannot unmute atomically,
945 // which means that we'd get some mild artifacts in the regular case.
946 snd_emu10k1_efx_playback_unmute_voices(emu, epcm, runtime->channels);
947
948 snd_emu10k1_playback_set_running(emu, epcm);
949 result = snd_emu10k1_voice_clear_loop_stop_multiple_atomic(emu, mask);
950 if (result == 0) {
951 // The extra voice is allowed to lag a bit
952 snd_emu10k1_playback_trigger_voice(emu, epcm->extra);
953 goto leave;
954 }
955
956 snd_emu10k1_efx_playback_stop_voices(
957 emu, epcm, runtime->channels);
958
959 if (result != -EAGAIN)
960 break;
961 // The sync start can legitimately fail due to NMIs, etc.
962 }
963 snd_emu10k1_voice_clear_loop_stop_multiple(emu, mask);
964 break;
965 case SNDRV_PCM_TRIGGER_SUSPEND:
966 case SNDRV_PCM_TRIGGER_STOP:
967 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
968 snd_emu10k1_playback_stop_voice(emu, epcm->extra);
969 snd_emu10k1_efx_playback_stop_voices(
970 emu, epcm, runtime->channels);
971
972 epcm->resume_pos = snd_emu10k1_playback_pointer(substream);
973 break;
974 default:
975 result = -EINVAL;
976 break;
977 }
978leave:
979 spin_unlock(&emu->reg_lock);
980 return result;
981}
982
983
984static snd_pcm_uframes_t snd_emu10k1_capture_pointer(struct snd_pcm_substream *substream)
985{
986 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
987 struct snd_pcm_runtime *runtime = substream->runtime;
988 struct snd_emu10k1_pcm *epcm = runtime->private_data;
989 unsigned int ptr;
990
991 if (!epcm->running)
992 return 0;
993 if (epcm->first_ptr) {
994 udelay(50); /* hack, it takes awhile until capture is started */
995 epcm->first_ptr = 0;
996 }
997 ptr = snd_emu10k1_ptr_read(emu, epcm->capture_idx_reg, 0) & 0x0000ffff;
998 return bytes_to_frames(runtime, ptr);
999}
1000
1001/*
1002 * Playback support device description
1003 */
1004
1005static const struct snd_pcm_hardware snd_emu10k1_playback =
1006{
1007 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1008 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1009 SNDRV_PCM_INFO_RESUME |
1010 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE),
1011 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
1012 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_96000,
1013 .rate_min = 4000,
1014 .rate_max = 96000,
1015 .channels_min = 1,
1016 .channels_max = 2,
1017 .buffer_bytes_max = (128*1024),
1018 .period_bytes_max = (128*1024),
1019 .periods_min = 2,
1020 .periods_max = 1024,
1021 .fifo_size = 0,
1022};
1023
1024/*
1025 * Capture support device description
1026 */
1027
1028static const struct snd_pcm_hardware snd_emu10k1_capture =
1029{
1030 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1031 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1032 SNDRV_PCM_INFO_RESUME |
1033 SNDRV_PCM_INFO_MMAP_VALID),
1034 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1035 .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_24000,
1036 .rate_min = 8000,
1037 .rate_max = 48000,
1038 .channels_min = 1,
1039 .channels_max = 2,
1040 .buffer_bytes_max = (64*1024),
1041 .period_bytes_min = 384,
1042 .period_bytes_max = (64*1024),
1043 .periods_min = 2,
1044 .periods_max = 2,
1045 .fifo_size = 0,
1046};
1047
1048static const struct snd_pcm_hardware snd_emu10k1_capture_efx =
1049{
1050 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1051 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1052 SNDRV_PCM_INFO_RESUME |
1053 SNDRV_PCM_INFO_MMAP_VALID),
1054 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1055 .rates = SNDRV_PCM_RATE_48000,
1056 .rate_min = 48000,
1057 .rate_max = 48000,
1058 .channels_min = 1,
1059 .channels_max = 16,
1060 .buffer_bytes_max = (64*1024),
1061 .period_bytes_min = 384,
1062 .period_bytes_max = (64*1024),
1063 .periods_min = 2,
1064 .periods_max = 2,
1065 .fifo_size = 0,
1066};
1067
1068/*
1069 *
1070 */
1071
1072static void snd_emu10k1_pcm_mixer_notify1(struct snd_emu10k1 *emu, struct snd_kcontrol *kctl, int idx, int activate)
1073{
1074 struct snd_ctl_elem_id id;
1075
1076 if (! kctl)
1077 return;
1078 if (activate)
1079 kctl->vd[idx].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1080 else
1081 kctl->vd[idx].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1082 snd_ctl_notify(emu->card, SNDRV_CTL_EVENT_MASK_VALUE |
1083 SNDRV_CTL_EVENT_MASK_INFO,
1084 snd_ctl_build_ioff(&id, kctl, idx));
1085}
1086
1087static void snd_emu10k1_pcm_mixer_notify(struct snd_emu10k1 *emu, int idx, int activate)
1088{
1089 snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_send_routing, idx, activate);
1090 snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_send_volume, idx, activate);
1091 snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_attn, idx, activate);
1092}
1093
1094static void snd_emu10k1_pcm_efx_mixer_notify(struct snd_emu10k1 *emu, int idx, int activate)
1095{
1096 snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_efx_send_routing, idx, activate);
1097 snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_efx_send_volume, idx, activate);
1098 snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_efx_attn, idx, activate);
1099}
1100
1101static void snd_emu10k1_pcm_free_substream(struct snd_pcm_runtime *runtime)
1102{
1103 kfree(runtime->private_data);
1104}
1105
1106static int snd_emu10k1_efx_playback_close(struct snd_pcm_substream *substream)
1107{
1108 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1109 struct snd_emu10k1_pcm_mixer *mix;
1110 int i;
1111
1112 for (i = 0; i < NUM_EFX_PLAYBACK; i++) {
1113 mix = &emu->efx_pcm_mixer[i];
1114 mix->epcm = NULL;
1115 snd_emu10k1_pcm_efx_mixer_notify(emu, i, 0);
1116 }
1117 return 0;
1118}
1119
1120static int snd_emu10k1_playback_set_constraints(struct snd_pcm_runtime *runtime)
1121{
1122 int err;
1123
1124 // The buffer size must be a multiple of the period size, to avoid a
1125 // mismatch between the extra voice and the regular voices.
1126 err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
1127 if (err < 0)
1128 return err;
1129 // The hardware is typically the cache's size of 64 frames ahead.
1130 // Leave enough time for actually filling up the buffer.
1131 err = snd_pcm_hw_constraint_minmax(
1132 runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 128, UINT_MAX);
1133 return err;
1134}
1135
1136static int snd_emu10k1_efx_playback_open(struct snd_pcm_substream *substream)
1137{
1138 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1139 struct snd_emu10k1_pcm *epcm;
1140 struct snd_emu10k1_pcm_mixer *mix;
1141 struct snd_pcm_runtime *runtime = substream->runtime;
1142 int i, j, err;
1143
1144 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
1145 if (epcm == NULL)
1146 return -ENOMEM;
1147 epcm->emu = emu;
1148 epcm->type = PLAYBACK_EFX;
1149 epcm->substream = substream;
1150
1151 runtime->private_data = epcm;
1152 runtime->private_free = snd_emu10k1_pcm_free_substream;
1153 runtime->hw = snd_emu10k1_efx_playback;
1154 if (emu->card_capabilities->emu_model)
1155 snd_emu1010_constrain_efx_rate(emu, runtime);
1156 err = snd_emu10k1_playback_set_constraints(runtime);
1157 if (err < 0) {
1158 kfree(epcm);
1159 return err;
1160 }
1161
1162 for (i = 0; i < NUM_EFX_PLAYBACK; i++) {
1163 mix = &emu->efx_pcm_mixer[i];
1164 for (j = 0; j < 8; j++)
1165 mix->send_routing[0][j] = i + j;
1166 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
1167 mix->send_volume[0][0] = 255;
1168 mix->attn[0] = 0x8000;
1169 mix->epcm = epcm;
1170 snd_emu10k1_pcm_efx_mixer_notify(emu, i, 1);
1171 }
1172 return 0;
1173}
1174
1175static int snd_emu10k1_playback_open(struct snd_pcm_substream *substream)
1176{
1177 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1178 struct snd_emu10k1_pcm *epcm;
1179 struct snd_emu10k1_pcm_mixer *mix;
1180 struct snd_pcm_runtime *runtime = substream->runtime;
1181 int i, err, sample_rate;
1182
1183 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
1184 if (epcm == NULL)
1185 return -ENOMEM;
1186 epcm->emu = emu;
1187 epcm->type = PLAYBACK_EMUVOICE;
1188 epcm->substream = substream;
1189 runtime->private_data = epcm;
1190 runtime->private_free = snd_emu10k1_pcm_free_substream;
1191 runtime->hw = snd_emu10k1_playback;
1192 err = snd_emu10k1_playback_set_constraints(runtime);
1193 if (err < 0) {
1194 kfree(epcm);
1195 return err;
1196 }
1197 if (emu->card_capabilities->emu_model)
1198 sample_rate = emu->emu1010.word_clock;
1199 else
1200 sample_rate = 48000;
1201 err = snd_pcm_hw_rule_noresample(runtime, sample_rate);
1202 if (err < 0) {
1203 kfree(epcm);
1204 return err;
1205 }
1206 mix = &emu->pcm_mixer[substream->number];
1207 for (i = 0; i < 8; i++)
1208 mix->send_routing[0][i] = mix->send_routing[1][i] = mix->send_routing[2][i] = i;
1209 memset(&mix->send_volume, 0, sizeof(mix->send_volume));
1210 mix->send_volume[0][0] = mix->send_volume[0][1] =
1211 mix->send_volume[1][0] = mix->send_volume[2][1] = 255;
1212 mix->attn[0] = mix->attn[1] = mix->attn[2] = 0x8000;
1213 mix->epcm = epcm;
1214 snd_emu10k1_pcm_mixer_notify(emu, substream->number, 1);
1215 return 0;
1216}
1217
1218static int snd_emu10k1_playback_close(struct snd_pcm_substream *substream)
1219{
1220 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1221 struct snd_emu10k1_pcm_mixer *mix = &emu->pcm_mixer[substream->number];
1222
1223 mix->epcm = NULL;
1224 snd_emu10k1_pcm_mixer_notify(emu, substream->number, 0);
1225 return 0;
1226}
1227
1228static int snd_emu10k1_capture_open(struct snd_pcm_substream *substream)
1229{
1230 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1231 struct snd_pcm_runtime *runtime = substream->runtime;
1232 struct snd_emu10k1_pcm *epcm;
1233
1234 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
1235 if (epcm == NULL)
1236 return -ENOMEM;
1237 epcm->emu = emu;
1238 epcm->type = CAPTURE_AC97ADC;
1239 epcm->substream = substream;
1240 epcm->capture_ipr = IPR_ADCBUFFULL|IPR_ADCBUFHALFFULL;
1241 epcm->capture_inte = INTE_ADCBUFENABLE;
1242 epcm->capture_ba_reg = ADCBA;
1243 epcm->capture_bs_reg = ADCBS;
1244 epcm->capture_idx_reg = emu->audigy ? A_ADCIDX : ADCIDX;
1245 runtime->private_data = epcm;
1246 runtime->private_free = snd_emu10k1_pcm_free_substream;
1247 runtime->hw = snd_emu10k1_capture;
1248 snd_emu10k1_constrain_capture_rates(emu, runtime);
1249 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1250 &hw_constraints_capture_buffer_sizes);
1251 emu->capture_interrupt = snd_emu10k1_pcm_ac97adc_interrupt;
1252 emu->pcm_capture_substream = substream;
1253 return 0;
1254}
1255
1256static int snd_emu10k1_capture_close(struct snd_pcm_substream *substream)
1257{
1258 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1259
1260 emu->capture_interrupt = NULL;
1261 emu->pcm_capture_substream = NULL;
1262 return 0;
1263}
1264
1265static int snd_emu10k1_capture_mic_open(struct snd_pcm_substream *substream)
1266{
1267 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1268 struct snd_emu10k1_pcm *epcm;
1269 struct snd_pcm_runtime *runtime = substream->runtime;
1270
1271 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
1272 if (epcm == NULL)
1273 return -ENOMEM;
1274 epcm->emu = emu;
1275 epcm->type = CAPTURE_AC97MIC;
1276 epcm->substream = substream;
1277 epcm->capture_ipr = IPR_MICBUFFULL|IPR_MICBUFHALFFULL;
1278 epcm->capture_inte = INTE_MICBUFENABLE;
1279 epcm->capture_ba_reg = MICBA;
1280 epcm->capture_bs_reg = MICBS;
1281 epcm->capture_idx_reg = emu->audigy ? A_MICIDX : MICIDX;
1282 substream->runtime->private_data = epcm;
1283 substream->runtime->private_free = snd_emu10k1_pcm_free_substream;
1284 runtime->hw = snd_emu10k1_capture;
1285 runtime->hw.rates = SNDRV_PCM_RATE_8000;
1286 runtime->hw.rate_min = runtime->hw.rate_max = 8000;
1287 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1288 &hw_constraints_capture_buffer_sizes);
1289 emu->capture_mic_interrupt = snd_emu10k1_pcm_ac97mic_interrupt;
1290 emu->pcm_capture_mic_substream = substream;
1291 return 0;
1292}
1293
1294static int snd_emu10k1_capture_mic_close(struct snd_pcm_substream *substream)
1295{
1296 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1297
1298 emu->capture_mic_interrupt = NULL;
1299 emu->pcm_capture_mic_substream = NULL;
1300 return 0;
1301}
1302
1303static int snd_emu10k1_capture_efx_open(struct snd_pcm_substream *substream)
1304{
1305 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1306 struct snd_emu10k1_pcm *epcm;
1307 struct snd_pcm_runtime *runtime = substream->runtime;
1308 int nefx = emu->audigy ? 64 : 32;
1309 int idx, err;
1310
1311 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
1312 if (epcm == NULL)
1313 return -ENOMEM;
1314 epcm->emu = emu;
1315 epcm->type = CAPTURE_EFX;
1316 epcm->substream = substream;
1317 epcm->capture_ipr = IPR_EFXBUFFULL|IPR_EFXBUFHALFFULL;
1318 epcm->capture_inte = INTE_EFXBUFENABLE;
1319 epcm->capture_ba_reg = FXBA;
1320 epcm->capture_bs_reg = FXBS;
1321 epcm->capture_idx_reg = FXIDX;
1322 substream->runtime->private_data = epcm;
1323 substream->runtime->private_free = snd_emu10k1_pcm_free_substream;
1324 runtime->hw = snd_emu10k1_capture_efx;
1325 if (emu->card_capabilities->emu_model) {
1326 snd_emu1010_constrain_efx_rate(emu, runtime);
1327 /*
1328 * There are 32 mono channels of 16bits each.
1329 * 24bit Audio uses 2x channels over 16bit,
1330 * 96kHz uses 2x channels over 48kHz,
1331 * 192kHz uses 4x channels over 48kHz.
1332 * So, for 48kHz 24bit, one has 16 channels,
1333 * for 96kHz 24bit, one has 8 channels,
1334 * for 192kHz 24bit, one has 4 channels.
1335 * 1010rev2 and 1616(m) cards have double that,
1336 * but we don't exceed 16 channels anyway.
1337 */
1338#if 0
1339 /* For 96kHz */
1340 runtime->hw.channels_min = runtime->hw.channels_max = 4;
1341#endif
1342#if 0
1343 /* For 192kHz */
1344 runtime->hw.channels_min = runtime->hw.channels_max = 2;
1345#endif
1346 runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
1347 } else {
1348 spin_lock_irq(&emu->reg_lock);
1349 runtime->hw.channels_min = runtime->hw.channels_max = 0;
1350 for (idx = 0; idx < nefx; idx++) {
1351 if (emu->efx_voices_mask[idx/32] & (1 << (idx%32))) {
1352 runtime->hw.channels_min++;
1353 runtime->hw.channels_max++;
1354 }
1355 }
1356 epcm->capture_cr_val = emu->efx_voices_mask[0];
1357 epcm->capture_cr_val2 = emu->efx_voices_mask[1];
1358 spin_unlock_irq(&emu->reg_lock);
1359 }
1360 err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1361 &hw_constraints_efx_capture_channels);
1362 if (err < 0) {
1363 kfree(epcm);
1364 return err;
1365 }
1366 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1367 &hw_constraints_capture_buffer_sizes);
1368 emu->capture_efx_interrupt = snd_emu10k1_pcm_efx_interrupt;
1369 emu->pcm_capture_efx_substream = substream;
1370 return 0;
1371}
1372
1373static int snd_emu10k1_capture_efx_close(struct snd_pcm_substream *substream)
1374{
1375 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1376
1377 emu->capture_efx_interrupt = NULL;
1378 emu->pcm_capture_efx_substream = NULL;
1379 return 0;
1380}
1381
1382static const struct snd_pcm_ops snd_emu10k1_playback_ops = {
1383 .open = snd_emu10k1_playback_open,
1384 .close = snd_emu10k1_playback_close,
1385 .hw_params = snd_emu10k1_playback_hw_params,
1386 .hw_free = snd_emu10k1_playback_hw_free,
1387 .prepare = snd_emu10k1_playback_prepare,
1388 .trigger = snd_emu10k1_playback_trigger,
1389 .pointer = snd_emu10k1_playback_pointer,
1390};
1391
1392static const struct snd_pcm_ops snd_emu10k1_capture_ops = {
1393 .open = snd_emu10k1_capture_open,
1394 .close = snd_emu10k1_capture_close,
1395 .prepare = snd_emu10k1_capture_prepare,
1396 .trigger = snd_emu10k1_capture_trigger,
1397 .pointer = snd_emu10k1_capture_pointer,
1398};
1399
1400/* EFX playback */
1401static const struct snd_pcm_ops snd_emu10k1_efx_playback_ops = {
1402 .open = snd_emu10k1_efx_playback_open,
1403 .close = snd_emu10k1_efx_playback_close,
1404 .hw_params = snd_emu10k1_playback_hw_params,
1405 .hw_free = snd_emu10k1_playback_hw_free,
1406 .prepare = snd_emu10k1_efx_playback_prepare,
1407 .trigger = snd_emu10k1_efx_playback_trigger,
1408 .pointer = snd_emu10k1_playback_pointer,
1409};
1410
1411int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device)
1412{
1413 struct snd_pcm *pcm;
1414 struct snd_pcm_substream *substream;
1415 int err;
1416
1417 err = snd_pcm_new(emu->card, "emu10k1", device, 32, 1, &pcm);
1418 if (err < 0)
1419 return err;
1420
1421 pcm->private_data = emu;
1422
1423 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_playback_ops);
1424 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_ops);
1425
1426 pcm->info_flags = 0;
1427 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
1428 strcpy(pcm->name, "ADC Capture/Standard PCM Playback");
1429 emu->pcm = pcm;
1430
1431 /* playback substream can't use managed buffers due to alignment */
1432 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
1433 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
1434 &emu->pci->dev,
1435 64*1024, 64*1024);
1436
1437 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next)
1438 snd_pcm_set_managed_buffer(substream, SNDRV_DMA_TYPE_DEV,
1439 &emu->pci->dev, 64*1024, 64*1024);
1440
1441 return 0;
1442}
1443
1444int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device)
1445{
1446 struct snd_pcm *pcm;
1447 struct snd_pcm_substream *substream;
1448 int err;
1449
1450 err = snd_pcm_new(emu->card, "emu10k1", device, 1, 0, &pcm);
1451 if (err < 0)
1452 return err;
1453
1454 pcm->private_data = emu;
1455
1456 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_efx_playback_ops);
1457
1458 pcm->info_flags = 0;
1459 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
1460 strcpy(pcm->name, "Multichannel Playback");
1461 emu->pcm_multi = pcm;
1462
1463 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
1464 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
1465 &emu->pci->dev,
1466 64*1024, 64*1024);
1467
1468 return 0;
1469}
1470
1471
1472static const struct snd_pcm_ops snd_emu10k1_capture_mic_ops = {
1473 .open = snd_emu10k1_capture_mic_open,
1474 .close = snd_emu10k1_capture_mic_close,
1475 .prepare = snd_emu10k1_capture_prepare,
1476 .trigger = snd_emu10k1_capture_trigger,
1477 .pointer = snd_emu10k1_capture_pointer,
1478};
1479
1480int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device)
1481{
1482 struct snd_pcm *pcm;
1483 int err;
1484
1485 err = snd_pcm_new(emu->card, "emu10k1 mic", device, 0, 1, &pcm);
1486 if (err < 0)
1487 return err;
1488
1489 pcm->private_data = emu;
1490
1491 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_mic_ops);
1492
1493 pcm->info_flags = 0;
1494 strcpy(pcm->name, "Mic Capture");
1495 emu->pcm_mic = pcm;
1496
1497 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, &emu->pci->dev,
1498 64*1024, 64*1024);
1499
1500 return 0;
1501}
1502
1503static int snd_emu10k1_pcm_efx_voices_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1504{
1505 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1506 int nefx = emu->audigy ? 64 : 32;
1507 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1508 uinfo->count = nefx;
1509 uinfo->value.integer.min = 0;
1510 uinfo->value.integer.max = 1;
1511 return 0;
1512}
1513
1514static int snd_emu10k1_pcm_efx_voices_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1515{
1516 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1517 int nefx = emu->audigy ? 64 : 32;
1518 int idx;
1519
1520 for (idx = 0; idx < nefx; idx++)
1521 ucontrol->value.integer.value[idx] = (emu->efx_voices_mask[idx / 32] & (1 << (idx % 32))) ? 1 : 0;
1522 return 0;
1523}
1524
1525static int snd_emu10k1_pcm_efx_voices_mask_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1526{
1527 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
1528 unsigned int nval[2], bits;
1529 int nefx = emu->audigy ? 64 : 32;
1530 int change, idx;
1531
1532 nval[0] = nval[1] = 0;
1533 for (idx = 0, bits = 0; idx < nefx; idx++)
1534 if (ucontrol->value.integer.value[idx]) {
1535 nval[idx / 32] |= 1 << (idx % 32);
1536 bits++;
1537 }
1538
1539 if (bits == 9 || bits == 11 || bits == 13 || bits == 15 || bits > 16)
1540 return -EINVAL;
1541
1542 spin_lock_irq(&emu->reg_lock);
1543 change = (nval[0] != emu->efx_voices_mask[0]) ||
1544 (nval[1] != emu->efx_voices_mask[1]);
1545 emu->efx_voices_mask[0] = nval[0];
1546 emu->efx_voices_mask[1] = nval[1];
1547 spin_unlock_irq(&emu->reg_lock);
1548 return change;
1549}
1550
1551static const struct snd_kcontrol_new snd_emu10k1_pcm_efx_voices_mask = {
1552 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1553 .name = "Captured FX8010 Outputs",
1554 .info = snd_emu10k1_pcm_efx_voices_mask_info,
1555 .get = snd_emu10k1_pcm_efx_voices_mask_get,
1556 .put = snd_emu10k1_pcm_efx_voices_mask_put
1557};
1558
1559static const struct snd_pcm_ops snd_emu10k1_capture_efx_ops = {
1560 .open = snd_emu10k1_capture_efx_open,
1561 .close = snd_emu10k1_capture_efx_close,
1562 .prepare = snd_emu10k1_capture_prepare,
1563 .trigger = snd_emu10k1_capture_trigger,
1564 .pointer = snd_emu10k1_capture_pointer,
1565};
1566
1567
1568/* EFX playback */
1569
1570#define INITIAL_TRAM_SHIFT 14
1571#define INITIAL_TRAM_POS(size) ((((size) / 2) - INITIAL_TRAM_SHIFT) - 1)
1572
1573static void snd_emu10k1_fx8010_playback_irq(struct snd_emu10k1 *emu, void *private_data)
1574{
1575 struct snd_pcm_substream *substream = private_data;
1576 snd_pcm_period_elapsed(substream);
1577}
1578
1579static void snd_emu10k1_fx8010_playback_tram_poke1(unsigned short *dst_left,
1580 unsigned short *dst_right,
1581 unsigned short *src,
1582 unsigned int count,
1583 unsigned int tram_shift)
1584{
1585 /*
1586 dev_dbg(emu->card->dev,
1587 "tram_poke1: dst_left = 0x%p, dst_right = 0x%p, "
1588 "src = 0x%p, count = 0x%x\n",
1589 dst_left, dst_right, src, count);
1590 */
1591 if ((tram_shift & 1) == 0) {
1592 while (count--) {
1593 *dst_left-- = *src++;
1594 *dst_right-- = *src++;
1595 }
1596 } else {
1597 while (count--) {
1598 *dst_right-- = *src++;
1599 *dst_left-- = *src++;
1600 }
1601 }
1602}
1603
1604static void fx8010_pb_trans_copy(struct snd_pcm_substream *substream,
1605 struct snd_pcm_indirect *rec, size_t bytes)
1606{
1607 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1608 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1609 unsigned int tram_size = pcm->buffer_size;
1610 unsigned short *src = (unsigned short *)(substream->runtime->dma_area + rec->sw_data);
1611 unsigned int frames = bytes >> 2, count;
1612 unsigned int tram_pos = pcm->tram_pos;
1613 unsigned int tram_shift = pcm->tram_shift;
1614
1615 while (frames > tram_pos) {
1616 count = tram_pos + 1;
1617 snd_emu10k1_fx8010_playback_tram_poke1((unsigned short *)emu->fx8010.etram_pages.area + tram_pos,
1618 (unsigned short *)emu->fx8010.etram_pages.area + tram_pos + tram_size / 2,
1619 src, count, tram_shift);
1620 src += count * 2;
1621 frames -= count;
1622 tram_pos = (tram_size / 2) - 1;
1623 tram_shift++;
1624 }
1625 snd_emu10k1_fx8010_playback_tram_poke1((unsigned short *)emu->fx8010.etram_pages.area + tram_pos,
1626 (unsigned short *)emu->fx8010.etram_pages.area + tram_pos + tram_size / 2,
1627 src, frames, tram_shift);
1628 tram_pos -= frames;
1629 pcm->tram_pos = tram_pos;
1630 pcm->tram_shift = tram_shift;
1631}
1632
1633static int snd_emu10k1_fx8010_playback_transfer(struct snd_pcm_substream *substream)
1634{
1635 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1636 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1637
1638 return snd_pcm_indirect_playback_transfer(substream, &pcm->pcm_rec,
1639 fx8010_pb_trans_copy);
1640}
1641
1642static int snd_emu10k1_fx8010_playback_hw_free(struct snd_pcm_substream *substream)
1643{
1644 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1645 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1646 unsigned int i;
1647
1648 for (i = 0; i < pcm->channels; i++)
1649 snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + 0x80 + pcm->etram[i], 0, 0);
1650 return 0;
1651}
1652
1653static int snd_emu10k1_fx8010_playback_prepare(struct snd_pcm_substream *substream)
1654{
1655 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1656 struct snd_pcm_runtime *runtime = substream->runtime;
1657 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1658 unsigned int i;
1659
1660 /*
1661 dev_dbg(emu->card->dev, "prepare: etram_pages = 0x%p, dma_area = 0x%x, "
1662 "buffer_size = 0x%x (0x%x)\n",
1663 emu->fx8010.etram_pages, runtime->dma_area,
1664 runtime->buffer_size, runtime->buffer_size << 2);
1665 */
1666 memset(&pcm->pcm_rec, 0, sizeof(pcm->pcm_rec));
1667 pcm->pcm_rec.hw_buffer_size = pcm->buffer_size * 2; /* byte size */
1668 pcm->pcm_rec.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream);
1669 pcm->tram_pos = INITIAL_TRAM_POS(pcm->buffer_size);
1670 pcm->tram_shift = 0;
1671 snd_emu10k1_ptr_write_multiple(emu, 0,
1672 emu->gpr_base + pcm->gpr_running, 0, /* reset */
1673 emu->gpr_base + pcm->gpr_trigger, 0, /* reset */
1674 emu->gpr_base + pcm->gpr_size, runtime->buffer_size,
1675 emu->gpr_base + pcm->gpr_ptr, 0, /* reset ptr number */
1676 emu->gpr_base + pcm->gpr_count, runtime->period_size,
1677 emu->gpr_base + pcm->gpr_tmpcount, runtime->period_size,
1678 REGLIST_END);
1679 for (i = 0; i < pcm->channels; i++)
1680 snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + 0x80 + pcm->etram[i], 0, (TANKMEMADDRREG_READ|TANKMEMADDRREG_ALIGN) + i * (runtime->buffer_size / pcm->channels));
1681 return 0;
1682}
1683
1684static int snd_emu10k1_fx8010_playback_trigger(struct snd_pcm_substream *substream, int cmd)
1685{
1686 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1687 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1688 int result = 0;
1689
1690 spin_lock(&emu->reg_lock);
1691 switch (cmd) {
1692 case SNDRV_PCM_TRIGGER_START:
1693 /* follow thru */
1694 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1695 case SNDRV_PCM_TRIGGER_RESUME:
1696#ifdef EMU10K1_SET_AC3_IEC958
1697 {
1698 int i;
1699 for (i = 0; i < 3; i++) {
1700 unsigned int bits;
1701 bits = SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1702 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS |
1703 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT | SPCS_NOTAUDIODATA;
1704 snd_emu10k1_ptr_write(emu, SPCS0 + i, 0, bits);
1705 }
1706 }
1707#endif
1708 result = snd_emu10k1_fx8010_register_irq_handler(emu, snd_emu10k1_fx8010_playback_irq, pcm->gpr_running, substream, &pcm->irq);
1709 if (result < 0)
1710 goto __err;
1711 snd_emu10k1_fx8010_playback_transfer(substream); /* roll the ball */
1712 snd_emu10k1_ptr_write(emu, emu->gpr_base + pcm->gpr_trigger, 0, 1);
1713 break;
1714 case SNDRV_PCM_TRIGGER_STOP:
1715 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1716 case SNDRV_PCM_TRIGGER_SUSPEND:
1717 snd_emu10k1_fx8010_unregister_irq_handler(emu, &pcm->irq);
1718 snd_emu10k1_ptr_write(emu, emu->gpr_base + pcm->gpr_trigger, 0, 0);
1719 pcm->tram_pos = INITIAL_TRAM_POS(pcm->buffer_size);
1720 pcm->tram_shift = 0;
1721 break;
1722 default:
1723 result = -EINVAL;
1724 break;
1725 }
1726 __err:
1727 spin_unlock(&emu->reg_lock);
1728 return result;
1729}
1730
1731static snd_pcm_uframes_t snd_emu10k1_fx8010_playback_pointer(struct snd_pcm_substream *substream)
1732{
1733 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1734 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1735 size_t ptr; /* byte pointer */
1736
1737 if (!snd_emu10k1_ptr_read(emu, emu->gpr_base + pcm->gpr_trigger, 0))
1738 return 0;
1739 ptr = snd_emu10k1_ptr_read(emu, emu->gpr_base + pcm->gpr_ptr, 0) << 2;
1740 return snd_pcm_indirect_playback_pointer(substream, &pcm->pcm_rec, ptr);
1741}
1742
1743static const struct snd_pcm_hardware snd_emu10k1_fx8010_playback =
1744{
1745 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1746 SNDRV_PCM_INFO_RESUME |
1747 /* SNDRV_PCM_INFO_MMAP_VALID | */ SNDRV_PCM_INFO_PAUSE |
1748 SNDRV_PCM_INFO_SYNC_APPLPTR),
1749 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
1750 .rates = SNDRV_PCM_RATE_48000,
1751 .rate_min = 48000,
1752 .rate_max = 48000,
1753 .channels_min = 1,
1754 .channels_max = 1,
1755 .buffer_bytes_max = (128*1024),
1756 .period_bytes_min = 1024,
1757 .period_bytes_max = (128*1024),
1758 .periods_min = 2,
1759 .periods_max = 1024,
1760 .fifo_size = 0,
1761};
1762
1763static int snd_emu10k1_fx8010_playback_open(struct snd_pcm_substream *substream)
1764{
1765 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1766 struct snd_pcm_runtime *runtime = substream->runtime;
1767 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1768
1769 runtime->hw = snd_emu10k1_fx8010_playback;
1770 runtime->hw.channels_min = runtime->hw.channels_max = pcm->channels;
1771 runtime->hw.period_bytes_max = (pcm->buffer_size * 2) / 2;
1772 spin_lock_irq(&emu->reg_lock);
1773 if (pcm->valid == 0) {
1774 spin_unlock_irq(&emu->reg_lock);
1775 return -ENODEV;
1776 }
1777 pcm->opened = 1;
1778 spin_unlock_irq(&emu->reg_lock);
1779 return 0;
1780}
1781
1782static int snd_emu10k1_fx8010_playback_close(struct snd_pcm_substream *substream)
1783{
1784 struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream);
1785 struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number];
1786
1787 spin_lock_irq(&emu->reg_lock);
1788 pcm->opened = 0;
1789 spin_unlock_irq(&emu->reg_lock);
1790 return 0;
1791}
1792
1793static const struct snd_pcm_ops snd_emu10k1_fx8010_playback_ops = {
1794 .open = snd_emu10k1_fx8010_playback_open,
1795 .close = snd_emu10k1_fx8010_playback_close,
1796 .hw_free = snd_emu10k1_fx8010_playback_hw_free,
1797 .prepare = snd_emu10k1_fx8010_playback_prepare,
1798 .trigger = snd_emu10k1_fx8010_playback_trigger,
1799 .pointer = snd_emu10k1_fx8010_playback_pointer,
1800 .ack = snd_emu10k1_fx8010_playback_transfer,
1801};
1802
1803int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device)
1804{
1805 struct snd_pcm *pcm;
1806 struct snd_kcontrol *kctl;
1807 int err;
1808
1809 err = snd_pcm_new(emu->card, "emu10k1 efx", device, emu->audigy ? 0 : 8, 1, &pcm);
1810 if (err < 0)
1811 return err;
1812
1813 pcm->private_data = emu;
1814
1815 if (!emu->audigy)
1816 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_fx8010_playback_ops);
1817 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_efx_ops);
1818
1819 pcm->info_flags = 0;
1820 if (emu->audigy)
1821 strcpy(pcm->name, "Multichannel Capture");
1822 else
1823 strcpy(pcm->name, "Multichannel Capture/PT Playback");
1824 emu->pcm_efx = pcm;
1825
1826 if (!emu->card_capabilities->emu_model) {
1827 // On Sound Blasters, the DSP code copies the EXTINs to FXBUS2.
1828 // The mask determines which of these and the EXTOUTs the multi-
1829 // channel capture actually records (the channel order is fixed).
1830 if (emu->audigy) {
1831 emu->efx_voices_mask[0] = 0;
1832 emu->efx_voices_mask[1] = 0xffff;
1833 } else {
1834 emu->efx_voices_mask[0] = 0xffff0000;
1835 emu->efx_voices_mask[1] = 0;
1836 }
1837 kctl = snd_ctl_new1(&snd_emu10k1_pcm_efx_voices_mask, emu);
1838 if (!kctl)
1839 return -ENOMEM;
1840 kctl->id.device = device;
1841 err = snd_ctl_add(emu->card, kctl);
1842 if (err < 0)
1843 return err;
1844 } else {
1845 // On E-MU cards, the DSP code copies the P16VINs/EMU32INs to
1846 // FXBUS2. These are already selected & routed by the FPGA,
1847 // so there is no need to apply additional masking.
1848 }
1849
1850 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, &emu->pci->dev,
1851 64*1024, 64*1024);
1852
1853 return 0;
1854}
Note: See TracBrowser for help on using the repository browser.