static int bf5xx_pcm_silence(struct snd_pcm_substream *substream,
int channel, unsigned long pos,
unsigned long count)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_pcm_runtime *runtime = substream->runtime;
unsigned int sample_size = runtime->sample_bits / 8;
void *buf = runtime->dma_area;
struct bf5xx_i2s_pcm_data *dma_data;
unsigned int offset, samples;
dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
if (dma_data->tdm_mode) {
offset = bytes_to_frames(runtime, pos) * 8 * sample_size;
samples = bytes_to_frames(runtime, count) * 8;
} else {
offset = pos;
samples = bytes_to_samples(runtime, count);
}
snd_pcm_format_set_silence(runtime->format, buf + offset, samples);
return 0;
}
static inline int sst_calc_tstamp(struct intel_sst_drv *ctx,
struct pcm_stream_info *info,
struct snd_pcm_substream *substream,
struct snd_sst_tstamp *fw_tstamp)
{
size_t delay_bytes, delay_frames;
size_t buffer_sz;
u32 pointer_bytes, pointer_samples;
dev_dbg(ctx->dev, "mrfld ring_buffer_counter %llu in bytes\n",
fw_tstamp->ring_buffer_counter);
dev_dbg(ctx->dev, "mrfld hardware_counter %llu in bytes\n",
fw_tstamp->hardware_counter);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
delay_bytes = (size_t) (fw_tstamp->ring_buffer_counter -
fw_tstamp->hardware_counter);
else
delay_bytes = (size_t) (fw_tstamp->hardware_counter -
fw_tstamp->ring_buffer_counter);
delay_frames = bytes_to_frames(substream->runtime, delay_bytes);
buffer_sz = snd_pcm_lib_buffer_bytes(substream);
div_u64_rem(fw_tstamp->ring_buffer_counter, buffer_sz, &pointer_bytes);
pointer_samples = bytes_to_samples(substream->runtime, pointer_bytes);
dev_dbg(ctx->dev, "pcm delay %zu in bytes\n", delay_bytes);
info->buffer_ptr = pointer_samples / substream->runtime->channels;
info->pcm_delay = delay_frames / substream->runtime->channels;
dev_dbg(ctx->dev, "buffer ptr %llu pcm_delay rep: %llu\n",
info->buffer_ptr, info->pcm_delay);
return 0;
}
static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy_pcm *dpcm = runtime->private_data;
int bps;
bps = snd_pcm_format_width(runtime->format) * runtime->rate * runtime->channels / 8;
if (bps <= 0)
return -EINVAL;
dpcm->pcm_bps = bps;
dpcm->pcm_hz = HZ;
dpcm->pcm_buffer_size = snd_pcm_lib_buffer_bytes(substream);
dpcm->pcm_period_size = snd_pcm_lib_period_bytes(substream);
dpcm->pcm_irq_pos = 0;
dpcm->pcm_buf_pos = 0;
snd_pcm_format_set_silence(runtime->format, runtime->dma_area, bytes_to_samples(runtime, runtime->dma_bytes));
return 0;
}
static int cyapi_stream(void *driver, struct bladerf_stream *stream,
bladerf_module module)
{
int status;
int idx = 0;
long len;
void *next_buffer;
ULONG timeout_ms;
bool success, done;
struct stream_data *data = get_stream_data(stream);
struct bladerf_cyapi *cyapi = get_backend_data(driver);
struct bladerf_metadata meta;
assert(stream->dev->transfer_timeout[stream->module] <= ULONG_MAX);
if (stream->dev->transfer_timeout[stream->module] == 0) {
timeout_ms = INFINITE;
} else {
timeout_ms = stream->dev->transfer_timeout[stream->module];
}
switch (module) {
case BLADERF_MODULE_RX:
data->ep = get_ep(cyapi->dev, SAMPLE_EP_IN);
break;
case BLADERF_MODULE_TX:
data->ep = get_ep(cyapi->dev, SAMPLE_EP_OUT);
break;
default:
assert(!"Invalid module");
return BLADERF_ERR_UNEXPECTED;
}
if (data->ep == NULL) {
log_debug("Failed to get EP handle.\n");
return BLADERF_ERR_UNEXPECTED;
}
data->ep->XferMode = XMODE_DIRECT;
data->ep->Abort();
data->ep->Reset();
log_verbose("Starting stream...\n");
status = 0;
done = false;
memset(&meta, 0, sizeof(meta));
MUTEX_LOCK(&stream->lock);
for (unsigned int i = 0; i < data->num_transfers && status == 0; i++) {
if (module == BLADERF_MODULE_TX) {
next_buffer = stream->cb(stream->dev, stream, &meta, NULL,
stream->samples_per_buffer,
stream->user_data);
if (next_buffer == BLADERF_STREAM_SHUTDOWN) {
done = true;
break;
} else if (next_buffer == BLADERF_STREAM_NO_DATA) {
continue;
}
} else {
next_buffer = stream->buffers[i];
}
status = submit_transfer(stream, next_buffer);
}
MUTEX_UNLOCK(&stream->lock);
if (status != 0) {
goto out;
}
while (!done) {
struct transfer *xfer;
size_t i;
i = data->inflight_i;
xfer = &data->transfers[i];
success = data->ep->WaitForXfer(&xfer->event, timeout_ms);
if (!success) {
status = BLADERF_ERR_TIMEOUT;
log_debug("Steam timed out.\n");
break;
}
len = 0;
next_buffer = NULL;
log_verbose("Got transfer complete in slot %u (buffer %p)\n",
i, data->transfers[i].buffer);
MUTEX_LOCK(&stream->lock);
success = data->ep->FinishDataXfer(data->transfers[i].buffer, len,
&data->transfers[i].event,
xfer->handle);
if (success) {
next_buffer = stream->cb(stream->dev, stream, &meta,
data->transfers[i].buffer,
bytes_to_samples(stream->format, len),
stream->user_data);
} else {
done = true;
status = BLADERF_ERR_IO;
log_debug("Failed to finish transfer %u, buf=%p.\n",
(unsigned int)i, &data->transfers[i].buffer);
}
data->transfers[i].buffer = NULL;
data->transfers[i].handle = NULL;
data->num_avail++;
pthread_cond_signal(&stream->can_submit_buffer);
if (next_buffer == BLADERF_STREAM_SHUTDOWN) {
done = true;
} else if (next_buffer != BLADERF_STREAM_NO_DATA) {
status = submit_transfer(stream, next_buffer);
done = (status != 0);
}
data->inflight_i = next_idx(data, data->inflight_i);
MUTEX_UNLOCK(&stream->lock);
}
out:
MUTEX_LOCK(&stream->lock);
stream->error_code = status;
stream->state = STREAM_SHUTTING_DOWN;
data->ep->Abort();
data->ep->Reset();
for (unsigned int i = 0; i < data->num_transfers; i++) {
LONG len = 0;
if (data->transfers[i].handle != NULL) {
data->ep->FinishDataXfer(data->transfers[i].buffer, len,
&data->transfers[i].event,
data->transfers[i].handle);
data->transfers[i].buffer = NULL;
data->transfers[i].handle = NULL;
data->num_avail++;
}
}
assert(data->num_avail == data->num_transfers);
stream->state = STREAM_DONE;
log_verbose("Stream done (error_code = %d)\n", stream->error_code);
MUTEX_UNLOCK(&stream->lock);
return 0;
}
static void check_position(int device, HWAVEIN win, DWORD bytes,
LPWAVEFORMATEX pwfx )
{
MMTIME mmtime;
MMRESULT rc;
DWORD returned;
mmtime.wType = TIME_BYTES;
rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
ok(rc==MMSYSERR_NOERROR,
"waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
if (mmtime.wType != TIME_BYTES && winetest_debug > 1)
trace("waveInGetPosition(%s): TIME_BYTES not supported, returned %s\n",
dev_name(device),wave_time_format(mmtime.wType));
returned = time_to_bytes(&mmtime, pwfx);
ok(returned == bytes, "waveInGetPosition(%s): returned %d bytes, "
"should be %d\n", dev_name(device), returned, bytes);
mmtime.wType = TIME_SAMPLES;
rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
ok(rc==MMSYSERR_NOERROR,
"waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
if (mmtime.wType != TIME_SAMPLES && winetest_debug > 1)
trace("waveInGetPosition(%s): TIME_SAMPLES not supported, "
"returned %s\n",dev_name(device),wave_time_format(mmtime.wType));
returned = time_to_bytes(&mmtime, pwfx);
ok(returned == bytes, "waveInGetPosition(%s): returned %d samples, "
"should be %d\n", dev_name(device), bytes_to_samples(returned, pwfx),
bytes_to_samples(bytes, pwfx));
mmtime.wType = TIME_MS;
rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
ok(rc==MMSYSERR_NOERROR,
"waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
if (mmtime.wType != TIME_MS && winetest_debug > 1)
trace("waveInGetPosition(%s): TIME_MS not supported, returned %s\n",
dev_name(device), wave_time_format(mmtime.wType));
returned = time_to_bytes(&mmtime, pwfx);
ok(returned == bytes, "waveInGetPosition(%s): returned %d ms, "
"should be %d\n", dev_name(device), bytes_to_ms(returned, pwfx),
bytes_to_ms(bytes, pwfx));
mmtime.wType = TIME_SMPTE;
rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
ok(rc==MMSYSERR_NOERROR,
"waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
if (mmtime.wType != TIME_SMPTE && winetest_debug > 1)
trace("waveInGetPosition(%s): TIME_SMPTE not supported, returned %s\n",
dev_name(device),wave_time_format(mmtime.wType));
returned = time_to_bytes(&mmtime, pwfx);
ok(returned == bytes, "waveInGetPosition(%s): SMPTE test failed\n",
dev_name(device));
mmtime.wType = TIME_MIDI;
rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
ok(rc==MMSYSERR_NOERROR,
"waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
if (mmtime.wType != TIME_MIDI && winetest_debug > 1)
trace("waveInGetPosition(%s): TIME_MIDI not supported, returned %s\n",
dev_name(device),wave_time_format(mmtime.wType));
returned = time_to_bytes(&mmtime, pwfx);
ok(returned == bytes, "waveInGetPosition(%s): MIDI test failed\n",
dev_name(device));
mmtime.wType = TIME_TICKS;
rc=waveInGetPosition(win, &mmtime, sizeof(mmtime));
ok(rc==MMSYSERR_NOERROR,
"waveInGetPosition(%s): rc=%s\n",dev_name(device),wave_in_error(rc));
if (mmtime.wType != TIME_TICKS && winetest_debug > 1)
trace("waveInGetPosition(%s): TIME_TICKS not supported, returned %s\n",
dev_name(device),wave_time_format(mmtime.wType));
returned = time_to_bytes(&mmtime, pwfx);
ok(returned == bytes, "waveInGetPosition(%s): TICKS test failed\n",
dev_name(device));
}