static Bool maliPrepareAccess(PixmapPtr pPix, int index)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
MaliPtr fPtr = MALIPTR(pScrn);
PrivPixmap *privPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pPix);
mali_mem_info *mem_info;
IGNORE(index);
if (!privPixmap)
{
ERROR_MSG("Failed to get private pixmap data");
return FALSE;
}
mem_info = privPixmap->mem_info;
if (NULL != mem_info)
{
if (privPixmap->refs == 0)
{
if (privPixmap->isFrameBuffer)
{
privPixmap->addr = (unsigned long)fPtr->fbmem;
}
else
{
privPixmap->addr = (unsigned long)ump_mapped_pointer_get(mem_info->handle);
}
privPixmap->addr += mem_info->offset;
}
}
else
{
ERROR_MSG("No mem_info on pixmap");
return FALSE;
}
pPix->devPrivate.ptr = (void *)(privPixmap->addr);
if (NULL == pPix->devPrivate.ptr)
{
ERROR_MSG("cpu address not set");
return FALSE;
}
privPixmap->refs++;
if (!privPixmap->isFrameBuffer)
{
int secure_id = 0;
_lock_item_s item;
secure_id = ump_secure_id_get(mem_info->handle);
if (secure_id)
{
item.secure_id = secure_id;
item.usage = _LOCK_ACCESS_CPU_WRITE;
if (fPtr->fd_umplock > 0)
{
ioctl(fPtr->fd_umplock, LOCK_IOCTL_CREATE, &item);
if (ioctl(fPtr->fd_umplock, LOCK_IOCTL_PROCESS, &item) < 0)
{
int max_retries = 5;
ERROR_MSG("Unable to process lock item with ID 0x%x - throttling\n", item.secure_id);
while ((ioctl(fPtr->fd_umplock, LOCK_IOCTL_PROCESS, &item) < 0) && max_retries)
{
usleep(2000);
max_retries--;
}
if (max_retries == 0)
{
ERROR_MSG("Warning: Max retries == 0\n");
}
}
}
if (fPtr->use_cached_ump)
{
ump_cache_operations_control(UMP_CACHE_OP_START);
ump_switch_hw_usage_secure_id(item.secure_id, UMP_USED_BY_CPU);
ump_cache_operations_control(UMP_CACHE_OP_FINISH);
}
}
}
return TRUE;
}
static int gralloc_register_buffer(gralloc_module_t const *module, buffer_handle_t handle)
{
MALI_IGNORE(module);
if (private_handle_t::validate(handle) < 0)
{
AERR("Registering invalid buffer 0x%p, returning error", handle);
return -EINVAL;
}
// if this handle was created in this process, then we keep it as is.
private_handle_t *hnd = (private_handle_t *)handle;
ALOGD_IF(mDebug>1,"register buffer handle:%p ion_hnd:0x%p",handle,hnd->ion_hnd);
int retval = -EINVAL;
pthread_mutex_lock(&s_map_lock);
#if GRALLOC_ARM_UMP_MODULE
if (!s_ump_is_open)
{
ump_result res = ump_open(); // MJOLL-4012: UMP implementation needs a ump_close() for each ump_open
if (res != UMP_OK)
{
pthread_mutex_unlock(&s_map_lock);
AERR("Failed to open UMP library with res=%d", res);
return retval;
}
s_ump_is_open = 1;
}
#endif
hnd->pid = getpid();
if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)
{
AERR("Can't register buffer 0x%p as it is a framebuffer", handle);
}
else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP)
{
#if GRALLOC_ARM_UMP_MODULE
hnd->ump_mem_handle = (int)ump_handle_create_from_secure_id(hnd->ump_id);
if (UMP_INVALID_MEMORY_HANDLE != (ump_handle)hnd->ump_mem_handle)
{
hnd->base = ump_mapped_pointer_get((ump_handle)hnd->ump_mem_handle);
if (0 != hnd->base)
{
hnd->lockState = private_handle_t::LOCK_STATE_MAPPED;
hnd->writeOwner = 0;
hnd->lockState = 0;
pthread_mutex_unlock(&s_map_lock);
return 0;
}
else
{
AERR("Failed to map UMP handle 0x%x", hnd->ump_mem_handle);
}
ump_reference_release((ump_handle)hnd->ump_mem_handle);
}
else
{
AERR("Failed to create UMP handle 0x%x", hnd->ump_mem_handle);
}
#else
AERR("Gralloc does not support UMP. Unable to register UMP memory for handle 0x%p", hnd);
#endif
}
else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION)
{
#if GRALLOC_ARM_DMA_BUF_MODULE
int ret;
unsigned char *mappedAddress;
size_t size = hnd->size;
hw_module_t *pmodule = NULL;
private_module_t *m = NULL;
#if 1
m = (private_module_t*)module;
#else
if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&pmodule) == 0)
{
m = reinterpret_cast<private_module_t *>(pmodule);
}
else
{
AERR("Could not get gralloc module for handle: 0x%p", hnd);
retval = -errno;
goto cleanup;
}
#endif
/* the test condition is set to m->ion_client <= 0 here, because:
* 1) module structure are initialized to 0 if no initial value is applied
* 2) a second user process should get a ion fd greater than 0.
*/
if (m->ion_client <= 0)
{
/* a second user process must obtain a client handle first via ion_open before it can obtain the shared ion buffer*/
m->ion_client = ion_open();
if (m->ion_client < 0)
{
AERR("Could not open ion device for handle: 0x%p", hnd);
retval = -errno;
goto cleanup;
}
}
mappedAddress = (unsigned char *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, hnd->share_fd, 0);
if (MAP_FAILED == mappedAddress)
{
AERR("mmap( share_fd:%d ) failed with %s", hnd->share_fd, strerror(errno));
retval = -errno;
goto cleanup;
}
hnd->base = mappedAddress + hnd->offset;
pthread_mutex_unlock(&s_map_lock);
return 0;
#endif
}
else
{
AERR("registering non-UMP buffer not supported. flags = %d", hnd->flags);
}
cleanup:
pthread_mutex_unlock(&s_map_lock);
return retval;
}
static int gralloc_register_buffer(gralloc_module_t const* module, buffer_handle_t handle)
{
if (private_handle_t::validate(handle) < 0)
{
LOGE("Registering invalid buffer, returning error");
return -EINVAL;
}
// if this handle was created in this process, then we keep it as is.
private_handle_t* hnd = (private_handle_t*)handle;
if (hnd->pid == getpid())
{
return 0;
}
int retval = -EINVAL;
pthread_mutex_lock(&s_map_lock);
if (!s_ump_is_open)
{
ump_result res = ump_open(); // TODO: Fix a ump_close() somewhere???
if (res != UMP_OK)
{
pthread_mutex_unlock(&s_map_lock);
LOGE("Failed to open UMP library");
return retval;
}
s_ump_is_open = 1;
}
if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP)
{
hnd->ump_mem_handle = (int)ump_handle_create_from_secure_id(hnd->ump_id);
if (UMP_INVALID_MEMORY_HANDLE != (ump_handle)hnd->ump_mem_handle)
{
hnd->base = (int)ump_mapped_pointer_get((ump_handle)hnd->ump_mem_handle);
if (0 != hnd->base)
{
hnd->lockState = private_handle_t::LOCK_STATE_MAPPED;
hnd->writeOwner = 0;
hnd->lockState = 0;
pthread_mutex_unlock(&s_map_lock);
return 0;
}
else
{
LOGE("Failed to map UMP handle");
}
ump_reference_release((ump_handle)hnd->ump_mem_handle);
}
else
{
LOGE("Failed to create UMP handle");
}
}
else
{
LOGE("registering non-UMP buffer not supported");
}
pthread_mutex_unlock(&s_map_lock);
return retval;
}
static int gralloc_alloc_buffer(alloc_device_t* dev, size_t size, int usage, buffer_handle_t* pHandle)
{
#if GRALLOC_ARM_DMA_BUF_MODULE
{
private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
struct ion_handle *ion_hnd;
unsigned char *cpu_ptr;
int shared_fd;
int ret;
ret = ion_alloc(m->ion_client, size, 0, ION_HEAP_SYSTEM_MASK, 0, &ion_hnd);
if ( ret != 0)
{
AERR("Failed to ion_alloc from ion_client:%d", m->ion_client);
return -1;
}
ret = ion_share( m->ion_client, ion_hnd, &shared_fd );
if ( ret != 0 )
{
AERR( "ion_share( %d ) failed", m->ion_client );
if ( 0 != ion_free( m->ion_client, ion_hnd ) ) AERR( "ion_free( %d ) failed", m->ion_client );
return -1;
}
cpu_ptr = (unsigned char*)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shared_fd, 0 );
if ( MAP_FAILED == cpu_ptr )
{
AERR( "ion_map( %d ) failed", m->ion_client );
if ( 0 != ion_free( m->ion_client, ion_hnd ) ) AERR( "ion_free( %d ) failed", m->ion_client );
close( shared_fd );
return -1;
}
private_handle_t *hnd = new private_handle_t( private_handle_t::PRIV_FLAGS_USES_ION, size, (int)cpu_ptr, private_handle_t::LOCK_STATE_MAPPED );
if ( NULL != hnd )
{
hnd->share_fd = shared_fd;
hnd->ion_hnd = ion_hnd;
*pHandle = hnd;
return 0;
}
else
{
AERR( "Gralloc out of mem for ion_client:%d", m->ion_client );
}
close( shared_fd );
ret = munmap( cpu_ptr, size );
if ( 0 != ret ) AERR( "munmap failed for base:%p size: %d", cpu_ptr, size );
ret = ion_free( m->ion_client, ion_hnd );
if ( 0 != ret ) AERR( "ion_free( %d ) failed", m->ion_client );
return -1;
}
#endif
#if GRALLOC_ARM_UMP_MODULE
{
ump_handle ump_mem_handle;
void *cpu_ptr;
ump_secure_id ump_id;
ump_alloc_constraints constraints;
size = round_up_to_page_size(size);
if( (usage&GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN )
{
constraints = UMP_REF_DRV_CONSTRAINT_USE_CACHE;
}
else
{
constraints = UMP_REF_DRV_CONSTRAINT_NONE;
}
#ifdef GRALLOC_SIMULATE_FAILURES
/* if the failure condition matches, fail this iteration */
if (__ump_alloc_should_fail())
{
ump_mem_handle = UMP_INVALID_MEMORY_HANDLE;
}
else
#endif
{
ump_mem_handle = ump_ref_drv_allocate(size, constraints);
if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle)
{
cpu_ptr = ump_mapped_pointer_get(ump_mem_handle);
if (NULL != cpu_ptr)
{
ump_id = ump_secure_id_get(ump_mem_handle);
if (UMP_INVALID_SECURE_ID != ump_id)
{
private_handle_t* hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_UMP, size, (int)cpu_ptr,
private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle);
if (NULL != hnd)
{
*pHandle = hnd;
return 0;
}
else
{
AERR( "gralloc_alloc_buffer() failed to allocate handle. ump_handle = %p, ump_id = %d", ump_mem_handle, ump_id );
}
}
else
{
AERR( "gralloc_alloc_buffer() failed to retrieve valid secure id. ump_handle = %p", ump_mem_handle );
}
ump_mapped_pointer_release(ump_mem_handle);
}
else
{
AERR( "gralloc_alloc_buffer() failed to map UMP memory. ump_handle = %p", ump_mem_handle );
}
ump_reference_release(ump_mem_handle);
}
else
{
AERR( "gralloc_alloc_buffer() failed to allocate UMP memory. size:%d constraints: %d", size, constraints );
}
}
return -1;
}
#endif
}
static DRI2Buffer2Ptr MaliDRI2CreateBuffer(DrawablePtr pDraw,
unsigned int attachment,
unsigned int format)
{
ScreenPtr pScreen = pDraw->pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
DRI2Buffer2Ptr buffer;
MaliDRI2BufferPrivatePtr privates;
ump_handle handle;
FBDevPtr pMxv = FBDEVPTR(pScrn);
Rk30MaliPtr rk_3d = pMxv->Rk30Mali;
OvlHWPtr overlay = pMxv->OvlHW;
Bool can_use_overlay = TRUE;
PixmapPtr pWindowPixmap;
if (pDraw->type == DRAWABLE_WINDOW &&
(pWindowPixmap = pScreen->GetWindowPixmap((WindowPtr)pDraw)))
{
DebugMsg("win=%p (w=%d, h=%d, x=%d, y=%d) has backing pix=%p (w=%d, h=%d, screen_x=%d, screen_y=%d)\n",
pDraw, pDraw->width, pDraw->height, pDraw->x, pDraw->y,
pWindowPixmap, pWindowPixmap->drawable.width, pWindowPixmap->drawable.height,
pWindowPixmap->screen_x, pWindowPixmap->screen_y);
}
if(attachment != DRI2BufferBackLeft && rk_3d->buf_back != NULL){
DebugMsg("DRI2 return NullBuffer\n");
return rk_3d->buf_back;
}
if (!(buffer = calloc(1, sizeof *buffer))) {
ErrorF("MaliDRI2CreateBuffer: calloc failed\n");
return NULL;
}
/* If it is a pixmap, just migrate this pixmap to UMP buffer */
if (pDraw->type == DRAWABLE_PIXMAP)
{
if (!(privates = MigratePixmapToUMP((PixmapPtr)pDraw))) {
ErrorF("MaliDRI2CreateBuffer: MigratePixmapToUMP failed\n");
free(buffer);
return NULL;
}
privates->refcount++;
buffer->attachment = attachment;
buffer->driverPrivate = privates;
buffer->format = format;
buffer->flags = 0;
buffer->cpp = pDraw->bitsPerPixel / 8;
buffer->pitch = ((PixmapPtr)pDraw)->devKind;
buffer->name = ump_secure_id_get(privates->handle);
DebugMsg("DRI2CreateBuffer pix=%p, buf=%p:%p, att=%d, ump=%d:%d, w=%d, h=%d, cpp=%d, depth=%d\n",
pDraw, buffer, privates, attachment, buffer->name, buffer->flags,
privates->width, privates->height, buffer->cpp, privates->depth);
return buffer;
}
/* The drawable must be a window for using hardware overlays */
if (pDraw->type != DRAWABLE_WINDOW){
ErrorF("Unexpected pDraw->type (%d) in MaliDRI2CreateBuffer\n", pDraw->type);
return NULL;
}
if (!(privates = calloc(1, sizeof *privates))) {
ErrorF("MaliDRI2CreateBuffer: calloc failed\n");
free(buffer);
return NULL;
}
/* We could not get framebuffer secure id */
if (rk_3d->ump_fb_secure_id1 == UMP_INVALID_SECURE_ID)
can_use_overlay = FALSE;
/* Overlay is already used by a different window */
if (rk_3d->pOverlayWin && rk_3d->pOverlayWin != (void *)pDraw)
can_use_overlay = FALSE;
/* TODO: try to support other color depths later */
if (pDraw->bitsPerPixel != 32)
can_use_overlay = FALSE;
/* The default common values */
buffer->attachment = attachment;
buffer->driverPrivate = privates;
buffer->format = format;
buffer->flags = 0;
buffer->cpp = pDraw->bitsPerPixel / 8;
/* Stride must be 8 bytes aligned for Mali400 */
// buffer->pitch = ((buffer->cpp * pDraw->width + 7) / 8) * 8;
buffer->pitch = ((buffer->cpp * overlay->cur_var.xres_virtual + 7) / 8) * 8;
privates->size = pDraw->height * buffer->pitch;
privates->width = pDraw->width;
privates->height = pDraw->height;
privates->depth = pDraw->depth;
/* if (disp && disp->framebuffer_size - disp->gfx_layer_size < privates->size) {
DebugMsg("Not enough space in the offscreen framebuffer (wanted %d for DRI2)\n",
privates->size);
can_use_overlay = FALSE;
}
*/
/*
if((pDraw->width+pDraw->x) > overlay->cur_var.xres ||
(pDraw->height+pDraw->y) > overlay->cur_var.yres)
can_use_overlay = FALSE;
*/
if(pDraw->width < 2 || pDraw->height < 2){
can_use_overlay = FALSE;
}
if(attachment != DRI2BufferBackLeft){
// can_use_overlay = FALSE;
free(privates);
buffer->driverPrivate = NULL;
buffer->name = UMP_INVALID_SECURE_ID;
if(rk_3d->buf_back == NULL)
rk_3d->buf_back = buffer;
goto end;
}
if(rk_3d->OvlPg == ERRORL){
rk_3d->OvlPg = OvlAllocLay(pScrn, ANYL);
if(rk_3d->OvlPg == ERRORL)
can_use_overlay = FALSE;
else{//init
OvlSetupFb(pScrn, 0, 0, rk_3d->OvlPg);
OvlEnable(pScrn, rk_3d->OvlPg, 1);
}
}
rk_3d->bOverlayWinEnabled = can_use_overlay;
if (can_use_overlay)
rk_3d->pOverlayWin = (WindowPtr)pDraw;
// buffer->pitch = ((buffer->cpp * overlay->OvlLay[rk_3d->OvlPg].var.xres_virtual + 7) / 8) * 8;
// rk_3d->bOverlayWinEnabled = TRUE;
// Stride must be 8 bytes aligned for Mali400
// privates->size = pDraw->height * buffer->pitch;
// buffer->flags = 0;
privates->handle = UMP_INVALID_MEMORY_HANDLE;
privates->addr = NULL;
buffer->name = rk_3d->ump_fb_secure_id1;
privates->handle = ump_handle_create_from_secure_id(buffer->name);
privates->addr = ump_mapped_pointer_get(privates->handle);
// privates->addr = NULL;//(void*)0x94000000;
/* }
else
{
// rk_3d->bOverlayWinEnabled = FALSE;
// Allocate UMP memory buffer
#ifdef HAVE_LIBUMP_CACHE_CONTROL
privates->handle = ump_ref_drv_allocate(privates->size,
UMP_REF_DRV_CONSTRAINT_PHYSICALLY_LINEAR |
UMP_REF_DRV_CONSTRAINT_USE_CACHE);
ump_cache_operations_control(UMP_CACHE_OP_START);
ump_switch_hw_usage_secure_id(ump_secure_id_get(privates->handle),
UMP_USED_BY_MALI);
ump_cache_operations_control(UMP_CACHE_OP_FINISH);
#else
privates->handle = ump_ref_drv_allocate(privates->size,
UMP_REF_DRV_CONSTRAINT_PHYSICALLY_LINEAR);
#endif
if (privates->handle == UMP_INVALID_MEMORY_HANDLE) {
ErrorF("Failed to allocate UMP buffer (size=%d)\n",
(int)privates->size);
}
privates->addr = ump_mapped_pointer_get(privates->handle);
buffer->name = ump_secure_id_get(privates->handle);
buffer->flags = 0;
}
*/
end:
DebugMsg("DRI2CreateBuffer win=%p, buf=%p:%p, att=%d, ump=%d:%d, w=%d, h=%d, cpp=%d, depth=%d adr=%p\n",
pDraw, buffer, privates, attachment, buffer->name, buffer->flags,
privates->width, privates->height, buffer->cpp, privates->depth,privates->addr);
return buffer;
}
//static int gralloc_alloc_buffer(alloc_device_t* dev, size_t size, int usage, buffer_handle_t* pHandle, bool reserve)
static int gralloc_alloc_buffer(alloc_device_t* dev, size_t size, int usage, buffer_handle_t* pHandle, int reserve)
{
#if GRALLOC_ARM_DMA_BUF_MODULE
{
private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module);
ion_user_handle_t ion_hnd;
unsigned char *cpu_ptr;
int shared_fd;
int ret;
unsigned int heap_mask;
int Ion_type;
bool Ishwc = false;
int Ion_flag = 0;
if(usage == (GRALLOC_USAGE_HW_COMPOSER|GRALLOC_USAGE_HW_RENDER))
Ishwc = true;
//ret = ion_alloc(m->ion_client, size, 0, ION_HEAP_SYSTEM_MASK, 0, &ion_hnd);
#ifdef USE_X86
if(usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK))
Ion_flag = (ION_FLAG_CACHED|ION_FLAG_CACHED_NEEDS_SYNC);
if(is_out_log())
ALOGD("usage=%x,protect=%x,ion_flag=%x,mmu=%d",usage,GRALLOC_USAGE_PROTECTED,Ion_flag,g_MMU_stat);
if (usage & GRALLOC_USAGE_PROTECTED) //secrue memery
{
unsigned long phys;
ret = ion_secure_alloc(m->ion_client, size,&phys);
//ALOGD("secure_alloc ret=%d,phys=%x",ret,(int)phys);
if(ret != 0)
{
AERR("Failed to ion_alloc from ion_client:%d, size: %d", m->ion_client, size);
return -1;
}
private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_ION, usage, size, 0, 0);
if (NULL != hnd)
{
hnd->share_fd = 0;
hnd->ion_hnd = 0;
hnd->type = 0;
hnd->phy_addr = (int)phys;
*pHandle = hnd;
if(is_out_log())
ALOGD("secure_alloc_ok phy=%x",usage,hnd->phy_addr);
return 0;
}
else
{
AERR("Gralloc out of mem for ion_client:%d", m->ion_client);
}
close(shared_fd);
return -1;
}
#endif
//ret = ion_alloc(m->ion_client, size, 0, ION_HEAP_SYSTEM_MASK, 0, &ion_hnd);
#ifdef USE_X86
if(g_MMU_stat
&& ((usage&GRALLOC_USAGE_HW_CAMERA_WRITE)==0)
&& !(usage & GRALLOC_USAGE_PRIVATE_2)
&& !Ishwc)
#else
if(g_MMU_stat)
#endif
{
heap_mask = ION_HEAP(ION_VMALLOC_HEAP_ID);
#ifdef USE_X86
if (usage & GRALLOC_USAGE_PRIVATE_2)
{
heap_mask |= ION_HEAP(ION_SECURE_HEAP_ID);
}
#endif
ret = ion_alloc(m->ion_client, size, 0, heap_mask, Ion_flag, &ion_hnd);
Ion_type = 1;
} else {
heap_mask = ION_HEAP(ION_CMA_HEAP_ID);
#ifdef USE_X86
if (usage & GRALLOC_USAGE_PRIVATE_2)
{
heap_mask |= ION_HEAP(ION_SECURE_HEAP_ID);
}
#endif
if (usage == (GRALLOC_USAGE_HW_CAMERA_WRITE|GRALLOC_USAGE_SW_READ_OFTEN)) {
ret = ion_alloc(m->ion_client, size, 0,heap_mask,
(ION_FLAG_CACHED|ION_FLAG_CACHED_NEEDS_SYNC), &ion_hnd);
} else {
ret = ion_alloc(m->ion_client, size, 0,heap_mask, Ion_flag, &ion_hnd);
}
#ifdef USE_X86
if(g_MMU_stat && Ishwc)
{
Ion_type = 1;
}
else
#endif
Ion_type = 0;
}
if (ret != 0)
{
if( (heap_mask & ION_HEAP(ION_CMA_HEAP_ID))
#ifdef USE_X86
&& !Ishwc
#endif
)
{
#ifdef BOARD_WITH_IOMMU
heap_mask = ION_HEAP(ION_VMALLOC_HEAP_ID);
#else
heap_mask = ION_HEAP(ION_CARVEOUT_HEAP_ID);
#endif
ret = ion_alloc(m->ion_client, size, 0, heap_mask, 0, &ion_hnd );
{
if( ret != 0)
{
AERR("Force to VMALLOC fail ion_client:%d", m->ion_client);
return -1;
}
else
{
ALOGD("Force to VMALLOC sucess !");
Ion_type = 1;
}
}
}
else
{
AERR("Failed to ion_alloc from ion_client:%d, size: %d", m->ion_client, size);
return -1;
}
}
ret = ion_share(m->ion_client, ion_hnd, &shared_fd);
if (ret != 0)
{
AERR("ion_share( %d ) failed", m->ion_client);
if (0 != ion_free(m->ion_client, ion_hnd))
{
AERR("ion_free( %d ) failed", m->ion_client);
}
return -1;
}
cpu_ptr = (unsigned char *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shared_fd, 0);
#ifdef USE_X86
//memset(cpu_ptr, 0, size);
#endif
if (MAP_FAILED == cpu_ptr)
{
AERR("ion_map( %d ) failed", m->ion_client);
if (0 != ion_free(m->ion_client, ion_hnd))
{
AERR("ion_free( %d ) failed", m->ion_client);
}
close(shared_fd);
return -1;
}
private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_ION, usage, size, (int)cpu_ptr, private_handle_t::LOCK_STATE_MAPPED);
if (NULL != hnd)
{
unsigned long cma_phys = 0;
hnd->share_fd = shared_fd;
hnd->ion_hnd = ion_hnd;
hnd->type = Ion_type;
if(!Ion_type)
{
int pret;
pret = ion_get_phys(m->ion_client, ion_hnd, &cma_phys);
//ALOGD("ion_get_phy ret=%d,cma_phys=%x",pret,cma_phys);
}
hnd->phy_addr = (int)cma_phys;
*pHandle = hnd;
if(is_out_log())
ALOGD("alloc_info fd[%d],type=%d,phy=%x",hnd->share_fd,hnd->type,hnd->phy_addr);
return 0;
}
else
{
AERR("Gralloc out of mem for ion_client:%d", m->ion_client);
}
close(shared_fd);
ret = munmap(cpu_ptr, size);
if (0 != ret)
{
AERR("munmap failed for base:%p size: %d", cpu_ptr, size);
}
ret = ion_free(m->ion_client, ion_hnd);
if (0 != ret)
{
AERR("ion_free( %d ) failed", m->ion_client);
}
return -1;
}
#endif
#if GRALLOC_ARM_UMP_MODULE
{
ump_handle ump_mem_handle;
void *cpu_ptr;
ump_secure_id ump_id;
int constraints;
size = round_up_to_page_size(size);
if ((usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
{
constraints = UMP_REF_DRV_CONSTRAINT_USE_CACHE;
}
else
{
constraints = UMP_REF_DRV_CONSTRAINT_NONE;
}
if ( reserve & 0x01)
{
constraints |= UMP_REF_DRV_CONSTRAINT_PRE_RESERVE;
}
if( reserve & 0x02)
{
constraints |= UMP_REF_DRV_UK_CONSTRAINT_MEM_SWITCH;
}
#ifdef GRALLOC_SIMULATE_FAILURES
/* if the failure condition matches, fail this iteration */
if (__ump_alloc_should_fail())
{
ump_mem_handle = UMP_INVALID_MEMORY_HANDLE;
}
else
#endif
{
ump_mem_handle = ump_ref_drv_allocate(size, (ump_alloc_constraints)constraints);
if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle)
{
cpu_ptr = ump_mapped_pointer_get(ump_mem_handle);
if (NULL != cpu_ptr)
{
ump_id = ump_secure_id_get(ump_mem_handle);
if (UMP_INVALID_SECURE_ID != ump_id)
{
private_handle_t *hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_UMP, usage, size, (int)cpu_ptr,
private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle);
if (NULL != hnd)
{
#ifdef USE_LCDC_COMPOSER
if( reserve & 0x02)
{
hnd->phy_addr = 0;
}
else
{
hnd->phy_addr = ump_phy_addr_get(ump_mem_handle);
}
#endif
*pHandle = hnd;
return 0;
}
else
{
AERR("gralloc_alloc_buffer() failed to allocate handle. ump_handle = %p, ump_id = %d", ump_mem_handle, ump_id);
}
}
else
{
AERR("gralloc_alloc_buffer() failed to retrieve valid secure id. ump_handle = %p", ump_mem_handle);
}
ump_mapped_pointer_release(ump_mem_handle);
}
else
{
AERR("gralloc_alloc_buffer() failed to map UMP memory. ump_handle = %p", ump_mem_handle);
}
ump_reference_release(ump_mem_handle);
}
else
{
AERR("gralloc_alloc_buffer() failed to allocate UMP memory. size:%d constraints: %d", size, constraints);
}
}
return -1;
}
#endif
static int gralloc_alloc_buffer(alloc_device_t* dev, size_t size, int usage, buffer_handle_t* pHandle)
{
ump_handle ump_mem_handle;
void *cpu_ptr;
ump_secure_id ump_id;
ump_alloc_constraints constraints;
size = round_up_to_page_size(size);
if( (usage&GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN )
{
constraints = UMP_REF_DRV_CONSTRAINT_USE_CACHE;
}
else
{
constraints = UMP_REF_DRV_CONSTRAINT_NONE;
}
#ifdef GRALLOC_SIMULATE_FAILURES
/* if the failure condition matches, fail this iteration */
if (__ump_alloc_should_fail())
{
ump_mem_handle = UMP_INVALID_MEMORY_HANDLE;
}
else
#endif
ump_mem_handle = ump_ref_drv_allocate(size, constraints);
if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle)
{
cpu_ptr = ump_mapped_pointer_get(ump_mem_handle);
if (NULL != cpu_ptr)
{
ump_id = ump_secure_id_get(ump_mem_handle);
if (UMP_INVALID_SECURE_ID != ump_id)
{
private_handle_t* hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_UMP, size, (int)cpu_ptr,
private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle);
if (NULL != hnd)
{
*pHandle = hnd;
return 0;
}
else
{
LOGE("gralloc_alloc_buffer() failed to allocate handle");
}
}
else
{
LOGE("gralloc_alloc_buffer() failed to retrieve valid secure id");
}
ump_mapped_pointer_release(ump_mem_handle);
}
else
{
LOGE("gralloc_alloc_buffer() failed to map UMP memory");
}
ump_reference_release(ump_mem_handle);
}
else
{
LOGE("gralloc_alloc_buffer() failed to allocate UMP memory");
}
return -1;
}
