void msm_gemini_platform_p2v(struct file *file,
struct ion_handle **ionhandle)
{
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
if(*ionhandle == NULL)
return;
ion_unmap_iommu(gemini_client, *ionhandle, CAMERA_DOMAIN, GEN_POOL);
ion_free(gemini_client, *ionhandle);
*ionhandle = NULL;
#elif CONFIG_ANDROID_PMEM
put_pmem_file(file);
#endif
}
static int __msm_pmem_table_del(struct hlist_head *ptype,
struct msm_pmem_info *pinfo, struct ion_client *client)
{
int rc = 0;
struct msm_pmem_region *region;
struct hlist_node *node, *n;
switch (pinfo->type) {
case MSM_PMEM_AF:
case MSM_PMEM_AEC:
case MSM_PMEM_AWB:
case MSM_PMEM_RS:
case MSM_PMEM_CS:
case MSM_PMEM_IHIST:
case MSM_PMEM_SKIN:
case MSM_PMEM_AEC_AWB:
//QCT - BAYER STATS - MB
case MSM_PMEM_BAYER_GRID:
case MSM_PMEM_BAYER_FOCUS:
case MSM_PMEM_BAYER_HIST:
//QCT - BAYER STATS - ME
hlist_for_each_entry_safe(region, node, n,
ptype, list) {
if (pinfo->type == region->info.type &&
pinfo->vaddr == region->info.vaddr &&
pinfo->fd == region->info.fd) {
hlist_del(node);
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_unmap_iommu(client, region->handle,
CAMERA_DOMAIN, GEN_POOL);
ion_free(client, region->handle);
#else
put_pmem_file(region->file);
#endif
kfree(region);
}
}
break;
default:
rc = -EINVAL;
break;
}
return rc;
}
void videobuf2_pmem_contig_user_put(struct videobuf2_contig_pmem *mem,
struct ion_client *client, int domain_num)
{
if (mem->is_userptr) {
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_unmap_iommu(client, mem->ion_handle,
domain_num, 0);
ion_free(client, mem->ion_handle);
#elif CONFIG_ANDROID_PMEM
put_pmem_file(mem->file);
#endif
}
mem->is_userptr = 0;
mem->phyaddr = 0;
mem->size = 0;
mem->mapped_phyaddr = 0;
}
void videobuf2_pmem_contig_user_put(struct videobuf2_contig_pmem *mem,
struct ion_client *client)
{
if (msm_subsystem_unmap_buffer(mem->msm_buffer) < 0)
D("%s unmapped memory\n", __func__);
if (mem->is_userptr) {
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_free(client, mem->ion_handle);
#elif CONFIG_ANDROID_PMEM
put_pmem_file(mem->file);
#endif
}
mem->is_userptr = 0;
mem->phyaddr = 0;
mem->size = 0;
mem->mapped_phyaddr = 0;
}
void videobuf2_pmem_contig_user_put(struct videobuf2_contig_pmem *mem,
struct ion_client *client)
{
if (mem->is_userptr) {
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_unmap_kernel(client, mem->ion_handle);
ion_unmap_iommu(client, mem->ion_handle,
CAMERA_DOMAIN, GEN_POOL);
ion_free(client, mem->ion_handle);
#elif CONFIG_ANDROID_PMEM
put_pmem_file(mem->file);
#endif
}
mem->is_userptr = 0;
mem->phyaddr = 0;
mem->size = 0;
mem->mapped_phyaddr = 0;
}
static int deregister_pmem(void)
{
int result;
struct audproc_buffer_data buffer;
get_audproc_buffer_data(&buffer);
result = adm_memory_unmap_regions(buffer.phys_addr,
buffer.buf_size, NUM_AUDPROC_BUFFERS);
if (result < 0)
pr_err("Audcal unmap did not work!\n");
if (acdb_data.pmem_fd) {
put_pmem_file(acdb_data.file);
acdb_data.pmem_fd = 0;
}
return result;
}
static int __msm_pmem_table_del(struct hlist_head *ptype,
struct msm_pmem_info *pinfo, struct ion_client *client)
{
int rc = 0;
struct msm_pmem_region *region;
struct hlist_node *node, *n;
switch (pinfo->type) {
case MSM_PMEM_AF:
case MSM_PMEM_AEC:
case MSM_PMEM_AWB:
case MSM_PMEM_RS:
case MSM_PMEM_CS:
case MSM_PMEM_IHIST:
case MSM_PMEM_SKIN:
case MSM_PMEM_AEC_AWB:
hlist_for_each_entry_safe(region, node, n,
ptype, list) {
if (pinfo->type == region->info.type &&
pinfo->vaddr == region->info.vaddr &&
pinfo->fd == region->info.fd) {
hlist_del(node);
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_unmap_iommu(client, region->handle,
CAMERA_DOMAIN, GEN_POOL);
pr_err("%s: IOMMU unmapping address 0x%x\n", __func__, (unsigned int)region->paddr); //QCT patch, Fix_IOMMU_and_VFE_bus_overflow, 2012-10-31, freeso.kim
ion_free(client, region->handle);
#else
put_pmem_file(region->file);
#endif
kfree(region);
}
}
break;
default:
rc = -EINVAL;
break;
}
return rc;
}
int mdss_mdp_put_img(struct mdss_mdp_img_data *data)
{
/* only source may use frame buffer */
if (data->flags & MDP_MEMORY_ID_TYPE_FB) {
fput_light(data->srcp_file, data->p_need);
return 0;
}
if (data->srcp_file) {
put_pmem_file(data->srcp_file);
data->srcp_file = NULL;
return 0;
}
if (!IS_ERR_OR_NULL(data->srcp_ihdl)) {
ion_free(data->iclient, data->srcp_ihdl);
data->iclient = NULL;
data->srcp_ihdl = NULL;
return 0;
}
return -ENOMEM;
}
void videobuf2_pmem_contig_user_put(struct videobuf2_contig_pmem *mem,
struct ion_client *client, int domain_num)
{
if (mem->is_userptr) {
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
if (IS_ERR_OR_NULL(mem->ion_handle)) {
pr_err("%s ION import failed\n", __func__);
return;
}
ion_unmap_iommu(client, mem->ion_handle,
domain_num, 0);
ion_free(client, mem->ion_handle);
#elif CONFIG_ANDROID_PMEM
put_pmem_file(mem->file);
#endif
}
mem->is_userptr = 0;
mem->phyaddr = 0;
mem->size = 0;
mem->mapped_phyaddr = 0;
}
void msm_gemini_platform_p2v(struct file *file,
#if !defined(CONFIG_MSM_IOMMU)
struct msm_mapped_buffer **msm_buffer,
#endif
struct ion_handle **ionhandle)
{
#if !defined(CONFIG_MSM_IOMMU)
if (msm_subsystem_unmap_buffer(
(struct msm_mapped_buffer *)*msm_buffer) < 0)
pr_err("%s: umapped stat memory\n", __func__);
*msm_buffer = NULL;
#endif
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
#if defined(CONFIG_MSM_IOMMU)
ion_unmap_iommu(gemini_client, *ionhandle, CAMERA_DOMAIN, GEN_POOL);
#endif
ion_free(gemini_client, *ionhandle);
*ionhandle = NULL;
#elif CONFIG_ANDROID_PMEM
put_pmem_file(file);
#endif
}
void msm_gemini_platform_p2v(struct file *file)
{
put_pmem_file(file);
}
static int msm_pmem_table_add(struct hlist_head *ptype,
struct msm_pmem_info *info, struct ion_client *client)
{
unsigned long paddr;
#ifndef CONFIG_MSM_MULTIMEDIA_USE_ION
unsigned long kvstart;
struct file *file;
#endif
int rc = -ENOMEM;
unsigned long len;
struct msm_pmem_region *region;
region = kmalloc(sizeof(struct msm_pmem_region), GFP_KERNEL);
if (!region)
goto out;
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
region->handle = ion_import_fd(client, info->fd);
if (IS_ERR_OR_NULL(region->handle))
goto out1;
if (ion_map_iommu(client, region->handle, CAMERA_DOMAIN, GEN_POOL,
SZ_4K, 0, &paddr, &len, UNCACHED, 0) < 0)
goto out2;
#elif CONFIG_ANDROID_PMEM
rc = get_pmem_file(info->fd, &paddr, &kvstart, &len, &file);
if (rc < 0) {
pr_err("%s: get_pmem_file fd %d error %d\n",
__func__, info->fd, rc);
goto out1;
}
region->file = file;
#else
paddr = 0;
file = NULL;
kvstart = 0;
#endif
if (!info->len)
info->len = len;
rc = check_pmem_info(info, len);
if (rc < 0)
goto out3;
paddr += info->offset;
len = info->len;
if (check_overlap(ptype, paddr, len) < 0) {
rc = -EINVAL;
goto out3;
}
CDBG("%s: type %d, active flag %d, paddr 0x%lx, vaddr 0x%lx\n",
__func__, info->type, info->active, paddr,
(unsigned long)info->vaddr);
INIT_HLIST_NODE(®ion->list);
region->paddr = paddr;
region->len = len;
memcpy(®ion->info, info, sizeof(region->info));
D("%s Adding region to list with type %d\n", __func__,
region->info.type);
D("%s pmem_stats address is 0x%p\n", __func__, ptype);
hlist_add_head(&(region->list), ptype);
return 0;
out3:
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_unmap_iommu(client, region->handle, CAMERA_DOMAIN, GEN_POOL);
#endif
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
out2:
ion_free(client, region->handle);
#elif CONFIG_ANDROID_PMEM
put_pmem_file(region->file);
#endif
out1:
kfree(region);
out:
return rc;
}
static u32 vid_dec_set_buffer(struct video_client_ctx *client_ctx,
struct vdec_setbuffer_cmd *buffer_info)
{
enum vcd_buffer_type buffer_type;
enum buffer_dir dir_buffer = BUFFER_TYPE_INPUT;
u32 vcd_status = VCD_ERR_FAIL;
unsigned long user_vaddr, kernel_vaddr, phy_addr, len;
int pmem_fd;
struct file *file;
struct buf_addr_table *buf_addr_table;
s32 buffer_index = -1;
if (!client_ctx || !buffer_info)
return FALSE;
user_vaddr = (unsigned long)buffer_info->buffer.bufferaddr;
if (buffer_info->buffer_type == VDEC_BUFFER_TYPE_OUTPUT)
dir_buffer = BUFFER_TYPE_OUTPUT;
/*If buffer already set, ignore */
if (vid_c_lookup_addr_table(client_ctx, dir_buffer,
TRUE, &user_vaddr, &kernel_vaddr,
&phy_addr, &pmem_fd, &file,
&buffer_index)) {
DBG("%s() : user_virt_addr = 0x%08lx is alreday set.",
__func__, user_vaddr);
return TRUE;
}
if (get_pmem_file(buffer_info->buffer.pmem_fd,
&phy_addr, &kernel_vaddr, &len, &file)) {
ERR("%s(): get_pmem_file failed\n", __func__);
return FALSE;
}
put_pmem_file(file);
if (buffer_info->buffer_type == VDEC_BUFFER_TYPE_INPUT) {
buffer_type = VCD_BUFFER_INPUT;
client_ctx->num_of_input_buffers++;
if (client_ctx->num_of_input_buffers >
MAX_VIDEO_NUM_OF_BUFF) {
ERR("%s(): num_of_input_buffers reached max value"
" MAX_VIDEO_NUM_OF_BUFF \n", __func__);
client_ctx->num_of_input_buffers--;
return FALSE;
}
buffer_index = client_ctx->num_of_input_buffers - 1;
buf_addr_table =
&client_ctx->input_buf_addr_table[buffer_index];
buf_addr_table->user_vaddr =
(unsigned long)buffer_info->buffer.bufferaddr;
buf_addr_table->kernel_vaddr = kernel_vaddr;
buf_addr_table->phy_addr = phy_addr;
buf_addr_table->pmem_fd = buffer_info->buffer.pmem_fd;
buf_addr_table->file = file;
} else {
buffer_type = VCD_BUFFER_OUTPUT;
client_ctx->num_of_output_buffers++;
if (client_ctx->num_of_output_buffers >
MAX_VIDEO_NUM_OF_BUFF) {
ERR("%s(): num_of_outut_buffers reached max value"
" MAX_VIDEO_NUM_OF_BUFF \n", __func__);
client_ctx->num_of_output_buffers--;
return FALSE;
}
buffer_index = client_ctx->num_of_output_buffers - 1;
buf_addr_table =
&client_ctx->output_buf_addr_table[buffer_index];
kernel_vaddr += (unsigned long)buffer_info->buffer.offset;
phy_addr += (unsigned long)buffer_info->buffer.offset;
buf_addr_table->user_vaddr =
(unsigned long)buffer_info->buffer.bufferaddr;
buf_addr_table->kernel_vaddr = kernel_vaddr;
buf_addr_table->phy_addr = phy_addr;
buf_addr_table->pmem_fd = buffer_info->buffer.pmem_fd;
buf_addr_table->file = file;
}
vcd_status = vcd_set_buffer(client_ctx->vcd_handle,
buffer_type, (u8 *) kernel_vaddr,
buffer_info->buffer.buffer_len);
if (!vcd_status)
return TRUE;
else
return FALSE;
}
static int q6_config_encode(struct q6venc_dev *q6venc, uint32_t type,
struct init_config *init_config)
{
struct q6_init_config *q6_init_config = &init_config->q6_init_config;
int ret;
int i;
mutex_lock(&q6venc->lock);
if (q6venc->num_enc_bufs != 0) {
pr_err("%s: multiple sessions not supported\n", __func__);
ret = -EBUSY;
goto err_busy;
}
ret = get_buf_info(&q6venc->enc_bufs[0], &init_config->ref_frame_buf1);
if (ret) {
pr_err("%s: can't get ref_frame_buf1\n", __func__);
goto err_get_ref_frame_buf1;
}
ret = get_buf_info(&q6venc->enc_bufs[1], &init_config->ref_frame_buf2);
if (ret) {
pr_err("%s: can't get ref_frame_buf2\n", __func__);
goto err_get_ref_frame_buf2;
}
ret = get_buf_info(&q6venc->rlc_bufs[0], &init_config->rlc_buf1);
if (ret) {
pr_err("%s: can't get rlc_buf1\n", __func__);
goto err_get_rlc_buf1;
}
ret = get_buf_info(&q6venc->rlc_bufs[1], &init_config->rlc_buf2);
if (ret) {
pr_err("%s: can't get rlc_buf2\n", __func__);
goto err_get_rlc_buf2;
}
q6venc->rlc_buf_len = 2 * q6_init_config->rlc_buf_length;
q6venc->num_enc_bufs = 2;
q6venc->enc_buf_size =
(q6_init_config->enc_frame_width_inmb * PIXELS_PER_MACROBLOCK) *
(q6_init_config->enc_frame_height_inmb * PIXELS_PER_MACROBLOCK) *
BITS_PER_PIXEL / 8;
q6_init_config->ref_frame_buf1_phy = q6venc->enc_bufs[0].paddr;
q6_init_config->ref_frame_buf2_phy = q6venc->enc_bufs[1].paddr;
q6_init_config->rlc_buf1_phy = q6venc->rlc_bufs[0].paddr;
q6_init_config->rlc_buf2_phy = q6venc->rlc_bufs[1].paddr;
// The DSP may use the rlc_bufs during initialization,
for (i=0; i<RLC_MAX_BUF_NUM; i++)
{
dmac_inv_range((const void *)q6venc->rlc_bufs[i].vaddr,
(const void *)(q6venc->rlc_bufs[i].vaddr +
q6venc->rlc_buf_len));
}
ret = dal_call_f5(q6venc->venc, type, q6_init_config,
sizeof(struct q6_init_config));
if (ret) {
pr_err("%s: rpc failed \n", __func__);
goto err_dal_rpc_init;
}
mutex_unlock(&q6venc->lock);
return 0;
err_dal_rpc_init:
q6venc->num_enc_bufs = 0;
put_pmem_file(q6venc->rlc_bufs[1].file);
err_get_rlc_buf2:
put_pmem_file(q6venc->rlc_bufs[0].file);
err_get_rlc_buf1:
put_pmem_file(q6venc->enc_bufs[1].file);
err_get_ref_frame_buf2:
put_pmem_file(q6venc->enc_bufs[0].file);
err_get_ref_frame_buf1:
err_busy:
mutex_unlock(&q6venc->lock);
return ret;
}
/**
* videobuf_pmem_contig_user_get() - setup user space memory pointer
* @mem: per-buffer private videobuf-contig-pmem data
* @vb: video buffer to map
*
* This function validates and sets up a pointer to user space memory.
* Only physically contiguous pfn-mapped memory is accepted.
*
* Returns 0 if successful.
*/
int videobuf2_pmem_contig_user_get(struct videobuf2_contig_pmem *mem,
struct videobuf2_msm_offset *offset,
enum videobuf2_buffer_type buffer_type,
uint32_t addr_offset, int path,
struct ion_client *client)
{
unsigned long len;
int rc = 0;
#ifndef CONFIG_MSM_MULTIMEDIA_USE_ION
unsigned long kvstart;
#endif
unsigned int flags = 0;
unsigned long paddr = 0;
if (mem->phyaddr != 0)
return 0;
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
mem->ion_handle = ion_import_fd(client, (int)mem->vaddr);
if (IS_ERR_OR_NULL(mem->ion_handle)) {
pr_err("%s ION import failed\n", __func__);
return PTR_ERR(mem->ion_handle);
}
rc = ion_phys(client, mem->ion_handle, (ion_phys_addr_t *)&mem->phyaddr,
(size_t *)&len);
rc = ion_handle_get_flags(client, mem->ion_handle, &mem->ion_flags);
mem->kernel_vaddr = ion_map_kernel(client,
mem->ion_handle, mem->ion_flags);
#elif CONFIG_ANDROID_PMEM
rc = get_pmem_file((int)mem->vaddr, (unsigned long *)&mem->phyaddr,
&kvstart, &len, &mem->file);
if (rc < 0) {
pr_err("%s: get_pmem_file fd %d error %d\n",
__func__, (int)mem->vaddr, rc);
return rc;
}
#else
paddr = 0;
kvstart = 0;
#endif
if (offset)
mem->offset = *offset;
else
memset(&mem->offset, 0, sizeof(struct videobuf2_msm_offset));
mem->path = path;
mem->buffer_type = buffer_type;
paddr = mem->phyaddr;
flags = MSM_SUBSYSTEM_MAP_IOVA;
mem->subsys_id = MSM_SUBSYSTEM_CAMERA;
mem->msm_buffer = msm_subsystem_map_buffer(mem->phyaddr, len,
flags, &(mem->subsys_id), 1);
if (IS_ERR((void *)mem->msm_buffer)) {
pr_err("%s: msm_subsystem_map_buffer failed\n", __func__);
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
ion_unmap_kernel(client, mem->ion_handle);
ion_free(client, mem->ion_handle);
#elif CONFIG_ANDROID_PMEM
put_pmem_file(mem->file);
#endif
return PTR_ERR((void *)mem->msm_buffer);
}
paddr = mem->msm_buffer->iova[0];
mem->mapped_phyaddr = paddr + addr_offset;
mem->addr_offset = addr_offset;
return rc;
}
void msm_gemini_platform_p2v(struct file *file)
{
#ifdef CONFIG_ANDROID_PMEM
put_pmem_file(file);
#endif
}
