int res_trk_get_mem_type(void)
{
int mem_type = -1;
switch (resource_context.res_mem_type) {
case DDL_FW_MEM:
mem_type = ION_HEAP(resource_context.fw_mem_type);
return mem_type;
case DDL_MM_MEM:
mem_type = resource_context.memtype;
break;
case DDL_CMD_MEM:
if (res_trk_check_for_sec_session())
mem_type = resource_context.cmd_mem_type;
else
mem_type = resource_context.memtype;
break;
default:
return mem_type;
}
if (resource_context.vidc_platform_data->enable_ion) {
if (res_trk_check_for_sec_session()) {
mem_type = ION_HEAP(mem_type);
if (resource_context.res_mem_type != DDL_FW_MEM)
mem_type |= ION_SECURE;
else if (res_trk_is_cp_enabled())
mem_type |= ION_SECURE;
} else
mem_type = (ION_HEAP(mem_type) |
ION_HEAP(ION_IOMMU_HEAP_ID));
}
return mem_type;
}
void ddl_fw_release(struct ddl_buf_addr *dram_base)
{
void *cookie = dram_base->pil_cookie;
if (res_trk_is_cp_enabled() &&
res_trk_check_for_sec_session()) {
res_trk_close_secure_session();
if (IS_ERR_OR_NULL(cookie)) {
pr_err("Invalid params");
return;
}
if (res_trk_enable_footswitch()) {
pr_err("Failed to enable footswitch");
return;
}
if (res_trk_enable_iommu_clocks()) {
res_trk_disable_footswitch();
pr_err("Failed to enable iommu clocks\n");
return;
}
pil_put(cookie);
if (res_trk_disable_iommu_clocks())
pr_err("Failed to disable iommu clocks\n");
if (res_trk_disable_footswitch())
pr_err("Failed to disable footswitch\n");
} else {
if (res_trk_check_for_sec_session())
res_trk_close_secure_session();
res_trk_release_fw_addr();
}
}
u32 ddl_fw_init(struct ddl_buf_addr *dram_base)
{
u8 *dest_addr;
dest_addr = DDL_GET_ALIGNED_VITUAL(*dram_base);
DDL_MSG_LOW("FW Addr / FW Size : %x/%d", (u32)vidc_video_codec_fw,
vidc_video_codec_fw_size);
if (res_trk_check_for_sec_session() && res_trk_is_cp_enabled()) {
if (res_trk_enable_footswitch()) {
pr_err("Failed to enable footswitch");
return false;
}
if (res_trk_enable_iommu_clocks()) {
res_trk_disable_footswitch();
pr_err("Failed to enable iommu clocks\n");
return false;
}
dram_base->pil_cookie = pil_get("vidc");
if (res_trk_disable_iommu_clocks())
pr_err("Failed to disable iommu clocks\n");
if (IS_ERR_OR_NULL(dram_base->pil_cookie)) {
res_trk_disable_footswitch();
pr_err("pil_get failed\n");
return false;
}
} else {
if (vidc_video_codec_fw_size > dram_base->buffer_size ||
!vidc_video_codec_fw)
return false;
memcpy(dest_addr, vidc_video_codec_fw,
vidc_video_codec_fw_size);
}
return true;
}
static int res_trk_pmem_alloc
(struct ddl_buf_addr *addr, size_t sz, u32 alignment)
{
u32 alloc_size;
struct ddl_context *ddl_context;
int rc = 0;
DBG_PMEM("\n%s() IN: Requested alloc size(%u)", __func__, (u32)sz);
if (!addr) {
DDL_MSG_ERROR("\n%s() Invalid Parameters", __func__);
rc = -EINVAL;
goto bail_out;
}
ddl_context = ddl_get_context();
res_trk_set_mem_type(addr->mem_type);
alloc_size = (sz + alignment);
if (res_trk_get_enable_ion()) {
if (!res_trk_is_cp_enabled() ||
!res_trk_check_for_sec_session()) {
if (!ddl_context->video_ion_client)
ddl_context->video_ion_client =
res_trk_get_ion_client();
if (!ddl_context->video_ion_client) {
DDL_MSG_ERROR(
"%s() :DDL ION Client Invalid handle\n",
__func__);
rc = -ENOMEM;
goto bail_out;
}
alloc_size = (alloc_size+4095) & ~4095;
addr->alloc_handle = ion_alloc(
ddl_context->video_ion_client,
alloc_size, SZ_4K,
res_trk_get_mem_type());
if (IS_ERR_OR_NULL(addr->alloc_handle)) {
DDL_MSG_ERROR("%s() :DDL ION alloc failed\n",
__func__);
rc = -ENOMEM;
goto bail_out;
}
} else {
addr->alloc_handle = NULL;
addr->alloced_phys_addr = PIL_FW_BASE_ADDR;
addr->buffer_size = sz;
}
} else {
addr->alloced_phys_addr = (phys_addr_t)
allocate_contiguous_memory_nomap(alloc_size,
res_trk_get_mem_type(), SZ_4K);
if (!addr->alloced_phys_addr) {
DDL_MSG_ERROR("%s() : acm alloc failed (%d)\n",
__func__, alloc_size);
rc = -ENOMEM;
goto bail_out;
}
addr->buffer_size = sz;
return rc;
}
bail_out:
return rc;
}
unsigned int res_trk_get_ion_flags(void)
{
unsigned int flags = 0;
if (resource_context.res_mem_type == DDL_FW_MEM)
return flags;
if (resource_context.vidc_platform_data->enable_ion) {
if (res_trk_check_for_sec_session()) {
if (resource_context.res_mem_type != DDL_FW_MEM)
flags |= ION_SECURE;
else if (res_trk_is_cp_enabled())
flags |= ION_SECURE;
}
}
return flags;
}
u32 res_trk_get_firmware_addr(struct ddl_buf_addr *firm_addr)
{
int rc = 0;
size_t size = 0;
if (!firm_addr || resource_context.firmware_addr.mapped_buffer) {
pr_err("%s() invalid params", __func__);
return -EINVAL;
}
if (res_trk_is_cp_enabled() && res_trk_check_for_sec_session())
size = PIL_FW_SIZE;
else
size = VIDC_FW_SIZE;
if (res_trk_pmem_alloc(&resource_context.firmware_addr,
size, DDL_KILO_BYTE(128))) {
pr_err("%s() Firmware buffer allocation failed",
__func__);
memset(&resource_context.firmware_addr, 0,
sizeof(resource_context.firmware_addr));
rc = -ENOMEM;
goto fail_alloc;
}
if (!res_trk_pmem_map(&resource_context.firmware_addr,
resource_context.firmware_addr.buffer_size,
DDL_KILO_BYTE(128))) {
pr_err("%s() Firmware buffer mapping failed",
__func__);
rc = -ENOMEM;
goto fail_map;
}
memcpy(firm_addr, &resource_context.firmware_addr,
sizeof(struct ddl_buf_addr));
return 0;
fail_map:
res_trk_pmem_free(&resource_context.firmware_addr);
fail_alloc:
return rc;
}