1855 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*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 routines10 */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 031 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#endif37 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 044 if (status & IPR_ADCBUFHALFFULL) {45 if (emu->pcm_capture_substream->runtime->mode == SNDRV_PCM_MODE_FRAME)46 return;47 }48#endif49 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 056 if (status & IPR_MICBUFHALFFULL) {57 if (emu->pcm_capture_mic_substream->runtime->mode == SNDRV_PCM_MODE_FRAME)58 return;59 }60#endif61 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 068 if (status & IPR_EFXBUFHALFFULL) {69 if (emu->pcm_capture_efx_substream->runtime->mode == SNDRV_PCM_MODE_FRAME)70 return;71 }72#endif73 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 an101 // arbitrary number of periods per buffer, we use an extra voice with a102 // period-sized loop as the interrupt source. Additionally, the interrupt103 // 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, 16125};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 = 0131};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*128142};143 144static const struct snd_pcm_hw_constraint_list hw_constraints_capture_buffer_sizes = {145 .count = 31,146 .list = capture_buffer_sizes,147 .mask = 0148};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 0x00004000222#define PITCH_96000 0x00008000223#define PITCH_85000 0x00007155224#define PITCH_80726 0x00006ba2225#define PITCH_67882 0x00005a82226#define PITCH_57081 0x00004c1c227 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 hurt277 CPF, stereo ? CPF_STEREO_MASK : 0,278 // Assumption that PT is already 0 so no harm overwriting279 PTRX, (send_amount[0] << 8) | send_amount[1],280 // Stereo slaves don't need to have the addresses set, but it doesn't hurt281 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 memory286 Z1, 0,287 Z2, 0,288 // Invalidate maps289 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 routing296 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 voices461 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 } else524 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 actually568 // 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 cache573 ccr = (64 - 3) << REG_SHIFT(CCR_CACHEINVALIDSIZE);574 if (stereo) {575 // The engine goes haywire if CCR_READADDRESS is out of sync576 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 frame598 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 interrupt608 // source needs to be delayed.609 //610 // In principle, this wouldn't need to be the cache's entire size - in611 // practice, CCR_CACHEINVALIDSIZE (CIS) > `fetch threshold` has never612 // been observed, and assuming 40 _bytes_ should be safe.613 //614 // The cache fills are somewhat random, which makes it impossible to615 // align them with the interrupts. This makes a non-delayed interrupt616 // source not practical, as the interrupt handler would have to wait617 // 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-based620 // 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 } else799 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 } else825 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 could855 // return a more advanced position representing how far the hardware has856 // already read the buffer, and set runtime->delay accordingly. However,857 // this would be slightly different for every channel (and remarkably slow858 // 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 no935 // 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 after943 // they have been started, to potentially avoid torturing the speakers944 // 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 bit952 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 description1003 */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 description1026 */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 else1081 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 a1125 // 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 else1200 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 01339 /* For 96kHz */1340 runtime->hw.channels_min = runtime->hw.channels_max = 4;1341#endif1342#if 01343 /* For 192kHz */1344 runtime->hw.channels_min = runtime->hw.channels_max = 2;1345#endif1346 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_put1557};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 141571#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_IEC9581697 {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#endif1708 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 else1823 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 to1846 // 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}1855