Ejemplos de ion_alloc_mm en C++ (Cpp)

Ejemplo n.º 1

int ion_m4u_misc_using()
{
    int i;
    int ion_fd;
    int ion_test_fd;
    ion_user_handle_t handle;
    int share_fd;
    volatile char* pBuf;
    pid_t pid;
    unsigned int bufsize = 1*1024*1024;

    ion_fd = ion_open();
    if (ion_fd < 0)
    {
        printf("Cannot open ion device.\n");
        return 0;
    }
    if (ion_alloc_mm(ion_fd, bufsize, 4, 0, &handle))
    {
        printf("IOCTL[ION_IOC_ALLOC] failed!\n");
        return 0;
    }

    if (ion_share(ion_fd, handle, &share_fd))
    {
        printf("IOCTL[ION_IOC_SHARE] failed!\n");
        return 0;
    }

    pBuf = (char*)ion_mmap(ion_fd, NULL, bufsize, PROT_READ|PROT_WRITE, MAP_SHARED, share_fd, 0);
    printf("ion_map: pBuf = 0x%lx\n", (unsigned long)pBuf);
    if (!pBuf)
    {
        printf("Cannot map ion buffer.\n");
        return 0;
    }


    MTKM4UDrv CM4u;
    unsigned int BufMVA;
    int ret;
    ret = CM4u.m4u_alloc_mva(0,     
                       (unsigned long)pBuf, bufsize,             
                       M4U_PROT_READ|M4U_PROT_WRITE,
                       M4U_FLAGS_SEQ_ACCESS,
                       &BufMVA);             
    if(ret)
    {
        printf("allocate mva fail. ret=0x%x\n", ret);
        return ret;
    }
    printf("mva=0x%x\n", BufMVA);
                       
    ret = CM4u.m4u_cache_sync(0, M4U_CACHE_FLUSH_BY_RANGE, 
                    (unsigned long)pBuf,bufsize, BufMVA);
    if(ret)
    {
        printf("cache flush fail. ret=%d,va=0x%lx,size=0x%x\n", ret,(unsigned long)pBuf,bufsize);
        return ret;
    }
    ret = CM4u.m4u_dealloc_mva(0, (unsigned long)pBuf,bufsize, BufMVA);
    if(ret)
    {
        printf("m4u_dealloc_mva fail. ret=%d, mva=0x%x\n", ret, BufMVA);
    }

    return 0;

}

Ejemplo n.º 2

Archivo: imem_drv.cpp Proyecto: WayWingsDev/mediatek

//-----------------------------------------------------------------------------
MINT32 IMemDrvImp::allocVirtBuf(
    IMEM_BUF_INFO* pInfo)
{
#if defined (__ISP_USE_PMEM__)
    IMEM_DBG("__ISP_USE_PMEM__");
    //
    //pInfo->type = BUF_TYPE_PMEM;
    pInfo->virtAddr= (MUINT32) ::pmem_alloc_sync(pInfo->size, &pInfo->memID);
    //
    IMEM_DBG("memID[0x%x]",pInfo->memID);
#elif defined (__ISP_USE_STD_M4U__)
    IMEM_DBG("__ISP_USE_STD_M4U__");
    //
    //pInfo->type = BUF_TYPE_STD_M4U;
    pInfo->memID = (MINT32)(IMEM_MIN_ION_FD-1);
    pInfo->virtAddr = (MUINT32)::memalign(L1_CACHE_BYTES, pInfo->size); //32Bytes align
    //will call allocM4UMemory function(we show information there)
	//IMEM_INF("[Std M4U] mID[0x%x]/size[0x%x]/VA[0x%x]",pInfo->memID,pInfo->size,pInfo->virtAddr);
#elif defined (__ISP_USE_ION__)
    IMEM_DBG("__ISP_USE_ION__");
    //
    struct ion_handle *pIonHandle;
    MINT32 IonBufFd;

    struct ion_fd_data fd_data;
    //a. Allocate a buffer
    if(ion_alloc_mm(
        mIonDrv,
        pInfo->size,
        32,
        0,
        &pIonHandle))
    {
        IMEM_ERR("ion_alloc_mm fail");
		IMEM_ERR("cBuf ID[0x%x]/size[0x%x]",pInfo->memID,pInfo->size);
        return -1;
    }
    //b. Map a new fd for client.
    if(ion_share(
        mIonDrv,
        pIonHandle,
        &IonBufFd))
    {
        IMEM_ERR("ion_share fail");
		IMEM_ERR("cBuf ID[0x%x]/size[0x%x]",pInfo->memID,pInfo->size);
        return -1;
    }
    pInfo->memID = (MINT32)IonBufFd; // Tianshu suggest to keep this fd
    //c. Map FD to a virtual space.
    if(pInfo->useNoncache)
    {
        pInfo->virtAddr = (MUINT32)ion_mmap(mIonDrv,NULL, pInfo->size, PROT_READ|PROT_WRITE|PROT_NOCACHE, MAP_SHARED, IonBufFd, 0);   
    }
    else
    {
        pInfo->virtAddr = (MUINT32)ion_mmap(mIonDrv,NULL, pInfo->size, PROT_READ|PROT_WRITE, MAP_SHARED, IonBufFd, 0);        
    }

    if (!pInfo->virtAddr)
    {
        IMEM_ERR("Cannot map ion buffer.");
		IMEM_ERR("cBuf ID[0x%x]/size[0x%x]",pInfo->memID,pInfo->size);
        return -1;
    }
    //
    IMEM_DBG("ionFd[0x%x]",pInfo->memID);
#endif
	IMEM_DBG("mID[0x%x]/size[0x%x]/VA[0x%x]",pInfo->memID,pInfo->size,pInfo->virtAddr);  //kk test
    return 0;
}