int gralloc_register_buffer(gralloc_module_t const* module,
buffer_handle_t handle)
{
int err;
if (private_handle_t::validate(handle) < 0)
return -EINVAL;
err = gralloc_map(module, handle);
private_handle_t* hnd = (private_handle_t*)handle;
ALOGV("%s: base %p %d %d %d %d\n", __func__, hnd->base, hnd->size,
hnd->width, hnd->height, hnd->stride);
int ret;
ret = ion_import(getIonFd(module), hnd->fd, &hnd->handle);
if (ret)
ALOGE("error importing handle %d %x\n", hnd->fd, hnd->format);
if (hnd->fd1 >= 0) {
ret = ion_import(getIonFd(module), hnd->fd1, &hnd->handle1);
if (ret)
ALOGE("error importing handle1 %d %x\n", hnd->fd1, hnd->format);
}
if (hnd->fd2 >= 0) {
ret = ion_import(getIonFd(module), hnd->fd2, &hnd->handle2);
if (ret)
ALOGE("error importing handle2 %d %x\n", hnd->fd2, hnd->format);
}
return err;
}
uint32_t GuiExtIONDevice::import(int ion_fd)
{
if (m_dev_fd <= 0) return 0;
struct ion_handle* ion_hnd;
if (ion_import(m_dev_fd, ion_fd, &ion_hnd))
{
GUIEXT_LOGE("Failed to import ION handle: %s ", strerror(errno));
return 0;
}
return (unsigned int)ion_hnd;
}
unsigned int IonGetAddr(void *handle)
{
unsigned int phy_adr=0;
struct ion_handle *handle_ion;
private_handle_t* hnd = NULL;
SUNXI_hwcdev_context_t *Globctx = &gSunxiHwcDevice;
Globctx->ion_fd = ion_open();
if( Globctx->ion_fd != -1 )
{
hnd = (private_handle_t*)handle;
ion_import(Globctx->ion_fd,hnd->share_fd, &handle_ion);
phy_adr= (unsigned int)ion_getphyadr(Globctx->ion_fd,(void *)(handle_ion));
ion_sync_fd(Globctx->ion_fd,hnd->share_fd);
ion_close(Globctx->ion_fd);
Globctx->ion_fd = -1;
}
return phy_adr;
}
struct ion_handle *ion_import_fd(struct ion_client *client, int fd)
{
struct file *file = fget(fd);
struct ion_handle *handle;
if (!file) {
pr_err("%s: imported fd not found in file table.\n", __func__);
return ERR_PTR(-EINVAL);
}
if (file->f_op != &ion_share_fops) {
pr_err("%s: imported file %s is not a shared ion"
" file.", __func__, file->f_dentry->d_name.name);
handle = ERR_PTR(-EINVAL);
goto end;
}
handle = ion_import(client, file->private_data);
end:
fput(file);
return handle;
}
/*
* Invokes a client command to the Secure World
*/
int tf_invoke_client_command(
struct tf_connection *connection,
union tf_command *command,
union tf_answer *answer)
{
int error = 0;
struct tf_shmem_desc *shmem_desc[4] = {NULL};
int i;
#ifdef CONFIG_TF_ION
struct ion_handle *new_handle = NULL;
#endif /* CONFIG_TF_ION */
dprintk(KERN_INFO "tf_invoke_client_command(%p)\n", connection);
command->release_shared_memory.message_size =
(sizeof(struct tf_command_invoke_client_command) -
sizeof(struct tf_command_header)) / 4;
#ifdef CONFIG_TF_ZEBRA
error = tf_crypto_try_shortcuted_update(connection,
(struct tf_command_invoke_client_command *) command,
(struct tf_answer_invoke_client_command *) answer);
if (error == 0)
return error;
#endif
/* Map the tmprefs */
for (i = 0; i < 4; i++) {
int param_type = TF_GET_PARAM_TYPE(
command->invoke_client_command.param_types, i);
if ((param_type & (TF_PARAM_TYPE_MEMREF_FLAG |
TF_PARAM_TYPE_REGISTERED_MEMREF_FLAG))
== TF_PARAM_TYPE_MEMREF_FLAG) {
/* A temporary memref: map it */
error = tf_map_temp_shmem(connection,
&command->invoke_client_command.
params[i].temp_memref,
param_type, &shmem_desc[i]);
if (error != 0) {
dprintk(KERN_ERR
"tf_invoke_client_command: "
"unable to map temporary memory "
"block\n (%08X)", error);
goto error;
}
}
#ifdef CONFIG_TF_ION
else if (param_type == TF_PARAM_TYPE_MEMREF_ION_HANDLE) {
struct tf_command_invoke_client_command *invoke;
ion_phys_addr_t ion_addr;
size_t ion_len;
struct ion_buffer *buffer;
if (connection->ion_client == NULL) {
connection->ion_client = ion_client_create(
zebra_ion_device,
(1 << ION_HEAP_TYPE_CARVEOUT),
"tf");
}
if (connection->ion_client == NULL) {
dprintk(KERN_ERR "%s(%p): "
"unable to create ion client\n",
__func__, connection);
error = -EFAULT;
goto error;
}
invoke = &command->invoke_client_command;
dprintk(KERN_INFO "ion_handle %x",
invoke->params[i].value.a);
buffer = ion_share(connection->ion_client,
(struct ion_handle *)invoke->params[i].value.a);
if (buffer == NULL) {
dprintk(KERN_ERR "%s(%p): "
"unable to share ion handle\n",
__func__, connection);
error = -EFAULT;
goto error;
}
dprintk(KERN_INFO "ion_buffer %p", buffer);
new_handle = ion_import(connection->ion_client, buffer);
if (new_handle == NULL) {
dprintk(KERN_ERR "%s(%p): "
"unable to import ion buffer\n",
__func__, connection);
error = -EFAULT;
goto error;
}
dprintk(KERN_INFO "new_handle %x", new_handle);
error = ion_phys(connection->ion_client,
new_handle,
&ion_addr,
&ion_len);
if (error) {
dprintk(KERN_ERR
"%s: unable to convert ion handle "
"0x%08X (error code 0x%08X)\n",
__func__,
new_handle,
error);
error = -EINVAL;
goto error;
}
dprintk(KERN_INFO
"%s: handle=0x%08x phys_add=0x%08x length=0x%08x\n",
__func__, invoke->params[i].value.a, ion_addr, ion_len);
invoke->params[i].value.a = (u32) ion_addr;
invoke->params[i].value.b = (u32) ion_len;
invoke->param_types &= ~((0xF) << (4*i));
invoke->param_types |=
TF_PARAM_TYPE_VALUE_INPUT << (4*i);
}
#endif /* CONFIG_TF_ION */
}
command->invoke_client_command.device_context =
connection->device_context;
error = tf_send_receive(&connection->dev->sm, command,
answer, connection, true);
error:
#ifdef CONFIG_TF_ION
if (new_handle != NULL)
ion_free(connection->ion_client, new_handle);
#endif /* CONFIG_TF_ION */
/* Unmap de temp mem refs */
for (i = 0; i < 4; i++) {
if (shmem_desc[i] != NULL) {
dprintk(KERN_INFO "tf_invoke_client_command: "
"UnMatemp_memref %d\n ", i);
tf_unmap_shmem(connection, shmem_desc[i], 0);
}
}
if (error != 0)
dprintk(KERN_ERR "tf_invoke_client_command returns %d\n",
error);
else
dprintk(KERN_ERR "tf_invoke_client_command returns "
"error_code 0x%08X\n",
answer->invoke_client_command.error_code);
return error;
}
//-----------------------------------------------------------------------------
MINT32 IMemDrvImp::freeVirtBuf(
IMEM_BUF_INFO* pInfo)
{
IMEM_INF("mID[0x%x]/size[0x%x]/VA[0x%x]/PA[0x%x]",pInfo->memID,pInfo->size,pInfo->virtAddr,pInfo->phyAddr);
IMEM_DRV_DELAY
#if defined (__ISP_USE_PMEM__)
//
//if ( BUF_TYPE_PMEM != pInfo->type ) {
// IMEM_ERR("ERROR:mem type(%d)",pInfo->type);
// return -1;
//}
//
IMEM_DBG("pmem ID[0x%x]",pInfo->memID);
//
if( pInfo->virtAddr != 0 )
{
::pmem_free(
(MUINT8*)(pInfo->virtAddr),
pInfo->size,
pInfo->memID);
}
//#elif defined (__ISP_USE_STD_M4U__) || defined (__ISP_USE_ION__)
#else
//
//if ( BUF_TYPE_STD_M4U == pInfo->type ) {
if ( IMEM_MIN_ION_FD > pInfo->memID ) {
if ( pInfo->virtAddr != 0 ) {
::free((MUINT8 *)pInfo->virtAddr);
}
}
//
#if defined (__ISP_USE_ION__)
//
else /*if ( BUF_TYPE_ION == pInfo->type )*/ {
struct ion_handle *pIonHandle;
MINT32 IonBufFd;
//struct ion_handle_data handle_data;
//struct ion_fd_data fd_data;
//
//if ( BUF_TYPE_ION != pInfo->type ) {
// IMEM_ERR("ERROR:mem type(%d)",pInfo->type);
// return -1;
//}
//
IMEM_DBG("ionFd[0x%x]",pInfo->memID);
//a. get handle of ION_IOC_SHARE from fd_data.fd
IonBufFd = pInfo->memID;
if(ion_import(
mIonDrv,
IonBufFd,
&pIonHandle))
{
IMEM_ERR("ion_import fail(0x%x)",IonBufFd);
IMEM_ERR("cBuf ID[0x%x]/size[0x%x]/VA[0x%x]/PA[0x%x]/S[%d]/C[%d]",pInfo->memID,pInfo->size,pInfo->virtAddr,pInfo->phyAddr,pInfo->bufSecu,pInfo->bufCohe);
return -1;
}
//free for IMPORT ref cnt
if(ion_free(
mIonDrv,
pIonHandle))
{
IMEM_ERR("ion_free fail");
IMEM_ERR("cBuf ID[0x%x]/size[0x%x]/VA[0x%x]/PA[0x%x]/S[%d]/C[%d]",pInfo->memID,pInfo->size,pInfo->virtAddr,pInfo->phyAddr,pInfo->bufSecu,pInfo->bufCohe);
return -1;
}
//b. pair of mmap
ion_munmap(mIonDrv, (char*)pInfo->virtAddr, pInfo->size);
//c. pair of ION_IOC_SHARE
ion_share_close(mIonDrv, pInfo->memID);
//d. pair of ION_IOC_ALLOC
if(ion_free(
mIonDrv,
pIonHandle))
{
IMEM_ERR("ion_free fail");
IMEM_ERR("cBuf ID[0x%x]/size[0x%x]/VA[0x%x]/PA[0x%x]/S[%d]/C[%d]",pInfo->memID,pInfo->size,pInfo->virtAddr,pInfo->phyAddr,pInfo->bufSecu,pInfo->bufCohe);
return -1;
}
}
#else
else{
