C++ (Cpp) q6asm_audio_client_buf_alloc_contiguous Examples

Example #1

File: pcm_in_proxy.c Project: BackupWildfireDEV/ElementalX-Sense-5.0.2

static int config(struct pcm *pcm)
{

	int ret = 0, i;
	struct audio_buffer *buf;

	pr_debug("%s\n", __func__);

	ret = q6asm_audio_client_buf_alloc_contiguous(OUT,
			pcm->ac,
			pcm->buffer_size,
			pcm->buffer_count);
	if (ret < 0) {
		pr_err("Audio Start: Buffer Allocation failed rc = %d\n", ret);
		return -ENOMEM;
	}
	buf = pcm->ac->port[OUT].buf;

	if (buf == NULL || buf[0].data == NULL)
		return -ENOMEM;

	memset(buf[0].data, 0, pcm->buffer_size * pcm->buffer_count);
	pcm->dma_addr = (u32) buf[0].phys;
	pcm->dma_virt = (u32) buf[0].data;

	for (i = 0; i < pcm->buffer_count; i++) {
		pcm->dma_buf[i].addr = (u32) (buf[i].phys);
		pcm->dma_buf[i].v_addr = (u32) (buf[i].data);
		pcm->dma_buf[i].used = 0;
	}

	ret = afe_register_get_events(RT_PROXY_DAI_001_TX,
			pcm_afe_callback, pcm);
	if (ret < 0) {
		pr_err("afe-pcm:register for events failed\n");
		return ret;
	}
	ret = afe_cmd_memory_map(pcm->dma_addr,
			pcm->buffer_size * pcm->buffer_count);
	if (ret < 0) {
		pr_err("fail to map memory to DSP\n");
		return ret;
	}

	pr_debug("%s:success\n", __func__);
	return ret;
}

Example #2

File: msm-compress-q6-v2.c Project: LGaljo/android_kernel_samsung_s3ve3g

static int msm_compr_configure_dsp(struct snd_compr_stream *cstream)
{
	struct snd_compr_runtime *runtime = cstream->runtime;
	struct msm_compr_audio *prtd = runtime->private_data;
	struct snd_soc_pcm_runtime *soc_prtd = cstream->private_data;
	uint16_t bits_per_sample = 16;
	int dir = IN, ret = 0;
	struct audio_client *ac = prtd->audio_client;
	struct asm_softpause_params softpause = {
		.enable = SOFT_PAUSE_ENABLE,
		.period = SOFT_PAUSE_PERIOD,
		.step = SOFT_PAUSE_STEP,
		.rampingcurve = SOFT_PAUSE_CURVE_LINEAR,
	};
	struct asm_softvolume_params softvol = {
		.period = SOFT_VOLUME_PERIOD,
		.step = SOFT_VOLUME_STEP,
		.rampingcurve = SOFT_VOLUME_CURVE_LINEAR,
	};

	pr_debug("%s\n", __func__);
	ret = q6asm_stream_open_write_v2(ac,
				prtd->codec, bits_per_sample,
				ac->stream_id,
				prtd->gapless_state.use_dsp_gapless_mode);
	if (ret < 0) {
		pr_err("%s: Session out open failed\n", __func__);
		 return -ENOMEM;
	}

	prtd->gapless_state.stream_opened[ac->stream_id] = 1;
	pr_debug("%s be_id %d\n", __func__, soc_prtd->dai_link->be_id);
	msm_pcm_routing_reg_phy_stream(soc_prtd->dai_link->be_id,
				ac->perf_mode,
				prtd->session_id,
				SNDRV_PCM_STREAM_PLAYBACK);

	ret = msm_compr_set_volume(cstream, 0, 0);
	if (ret < 0)
		pr_err("%s : Set Volume failed : %d", __func__, ret);

	ret = q6asm_set_softpause(ac, &softpause);
	if (ret < 0)
		pr_err("%s: Send SoftPause Param failed ret=%d\n",
			__func__, ret);

	ret = q6asm_set_softvolume(ac, &softvol);
	if (ret < 0)
		pr_err("%s: Send SoftVolume Param failed ret=%d\n",
			__func__, ret);

	ret = q6asm_set_io_mode(ac, (COMPRESSED_IO | ASYNC_IO_MODE));
	if (ret < 0) {
		pr_err("%s: Set IO mode failed\n", __func__);
		return -EINVAL;
	}

	runtime->fragments = prtd->codec_param.buffer.fragments;
	runtime->fragment_size = prtd->codec_param.buffer.fragment_size;
	pr_debug("allocate %d buffers each of size %d\n",
			runtime->fragments,
			runtime->fragment_size);
	ret = q6asm_audio_client_buf_alloc_contiguous(dir, ac,
					runtime->fragment_size,
					runtime->fragments);
	if (ret < 0) {
		pr_err("Audio Start: Buffer Allocation failed rc = %d\n", ret);
		return -ENOMEM;
	}

	prtd->byte_offset  = 0;
	prtd->copied_total = 0;
	prtd->app_pointer  = 0;
	prtd->bytes_received = 0;
	prtd->buffer       = ac->port[dir].buf[0].data;
	prtd->buffer_paddr = ac->port[dir].buf[0].phys;
	prtd->buffer_size  = runtime->fragments * runtime->fragment_size;

	ret = msm_compr_send_media_format_block(cstream, ac->stream_id);
	if (ret < 0)
		pr_err("%s, failed to send media format block\n", __func__);

	return ret;
}