hardware_samsung/exynos4/hal/libgralloc_ump/alloc_device.cpp

/*
 * Copyright (C) 2010 ARM Limited. All rights reserved.
 *
 * Portions of this code have been modified from the original.
 * These modifications are:
 *    * includes
 *    * gralloc_alloc_buffer()
 *    * gralloc_alloc_framebuffer_locked()
 *    * gralloc_alloc_framebuffer()
 *    * alloc_device_alloc()
 *    * alloc_device_free()
 *    * alloc_device_close()
 *    * alloc_device_open()
 *
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <string.h>
#include <errno.h>
#include <pthread.h>

#include <cutils/log.h>
#include <cutils/atomic.h>
#include <hardware/hardware.h>
#include <hardware/gralloc.h>
#include "sec_format.h"
#include "graphics.h"

#include "gralloc_priv.h"
#include "gralloc_helper.h"
#include "framebuffer_device.h"

#include "ump.h"
#include "ump_ref_drv.h"
#include "secion.h"

/*****************************************************************************/
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>

#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include "format.h"

#include <linux/videodev2.h>
#include "s5p_fimc.h"

#ifdef SAMSUNG_EXYNOS4x12
#define PFX_NODE_FIMC1   "/dev/video3"
#endif
#ifdef SAMSUNG_EXYNOS4210
#define PFX_NODE_FIMC1   "/dev/video1"
#endif

#ifndef OMX_COLOR_FormatYUV420Planar
#define OMX_COLOR_FormatYUV420Planar 0x13
#endif

#ifndef OMX_COLOR_FormatYUV420SemiPlanar
#define OMX_COLOR_FormatYUV420SemiPlanar 0x15
#endif

#define PFX_NODE_MEM   "/dev/exynos-mem"
static int gMemfd = 0;

bool ion_dev_open = true;
static pthread_mutex_t l_surface= PTHREAD_MUTEX_INITIALIZER;
static int buffer_offset = 0;
static int gfd = 0;

#ifdef USE_PARTIAL_FLUSH
extern struct private_handle_rect *rect_list;
extern private_handle_rect *find_rect(int secure_id);
extern private_handle_rect *find_last_rect(int secure_id);
extern int release_rect(int secure_id);
#endif

#define EXYNOS4_ALIGN( value, base ) (((value) + ((base) - 1)) & ~((base) - 1))

static int gralloc_alloc_buffer(alloc_device_t* dev, size_t size, int usage,
                                buffer_handle_t* pHandle, int w, int h,
                                int format, int bpp, int stride_raw, int stride)
{
    ump_handle ump_mem_handle;
    void *cpu_ptr;
    ump_secure_id ump_id;

    size = round_up_to_page_size(size);
#ifdef INSIGNAL_FIMC1
    if (usage & GRALLOC_USAGE_HW_FIMC1) {
        int dev_fd=0;
        char node[20];
        int ret;
        int paddr=0;
        int offset=0;

        struct v4l2_control     vc;
        sprintf(node, "%s", PFX_NODE_FIMC1);

        if (gfd == 0) {
            gfd = open(node, O_RDWR);

            if (gfd < 0) {
                ALOGE("%s:: %s Post processor open error\n", __func__, node);
                return false;
            }
        }

        vc.id = V4L2_CID_RESERVED_MEM_BASE_ADDR;
        vc.value = 0;
        ret = ioctl(gfd, VIDIOC_G_CTRL, &vc);
        if (ret < 0) {
            ALOGE("Error in video VIDIOC_G_CTRL - V4L2_CID_RESERVED_MEM_BAES_ADDR (%d)\n", ret);
            return false;
        }
        paddr = (unsigned int)vc.value;

        if ((buffer_offset + size) >= FIMC1_RESERVED_SIZE * 1024)
            buffer_offset = 0;

        paddr += buffer_offset;
        private_handle_t* hnd = new private_handle_t(private_handle_t::PRIV_FLAGS_USES_IOCTL, size, 0,
                private_handle_t::LOCK_STATE_MAPPED, 0, 0);

        *pHandle = hnd;
        hnd->format = format;
        hnd->usage = usage;
        hnd->width = w;
        hnd->height = h;
        hnd->bpp = bpp;
        hnd->paddr = paddr;
        hnd->offset = buffer_offset;
        hnd->stride = stride;
        hnd->fd = gfd;
        hnd->uoffset = (EXYNOS4_ALIGN((EXYNOS4_ALIGN(hnd->width, 16) * EXYNOS4_ALIGN(hnd->height, 16)), 4096));
        hnd->voffset = (EXYNOS4_ALIGN((EXYNOS4_ALIGN((hnd->width >> 1), 16) * EXYNOS4_ALIGN((hnd->height >> 1), 16)), 4096));
        buffer_offset += size;

        if (gMemfd == 0) {
            gMemfd = open(PFX_NODE_MEM, O_RDWR);
            if (gMemfd < 0) {
                ALOGE("%s:: %s exynos-mem open error\n", __func__, PFX_NODE_MEM);
                return false;
            }
        }

        size_t size = FIMC1_RESERVED_SIZE * 1024;

        void *mappedAddress = mmap(0, size,
               PROT_READ|PROT_WRITE, MAP_SHARED, gMemfd, (hnd->paddr - hnd->offset));
        hnd->base = intptr_t(mappedAddress) + hnd->offset;
        return 0;
    } else {
#endif
        ion_buffer ion_fd = 0;
        unsigned int ion_flags = 0;
        int priv_alloc_flag = private_handle_t::PRIV_FLAGS_USES_UMP;

#ifdef  INSIGNAL_FIMC1
        if (usage & GRALLOC_USAGE_HW_ION) {
#else
        if (usage & GRALLOC_USAGE_HW_ION || usage & GRALLOC_USAGE_HW_FIMC1) {
#endif
            if (!ion_dev_open) {
                ALOGE("ERROR, failed to open ion");
                return -1;
            }

            private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
            ion_flags = ION_HEAP_EXYNOS_MASK;
            ion_fd = ion_alloc(m->ion_client, size, 0, ion_flags);

            if (ion_fd < 0) {
                ALOGE("Failed to ion_alloc");
                return -1;
            }

            cpu_ptr = ion_map(ion_fd, size, 0);

            if (NULL == cpu_ptr) {
                ALOGE("Failed to ion_map");
                ion_free(ion_fd);
                return -1;
            }

            ump_mem_handle = ump_ref_drv_ion_import(ion_fd, UMP_REF_DRV_CONSTRAINT_NONE);

            if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle) {
                priv_alloc_flag = private_handle_t::PRIV_FLAGS_USES_ION;
            } else {
                ALOGE("gralloc_alloc_buffer() failed to import ION memory");
                ion_unmap(cpu_ptr, size);
                ion_free(ion_fd);
                return -1;
            }
        }
#ifdef SAMSUNG_EXYNOS_CACHE_UMP
        else if ((usage&GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
            ump_mem_handle = ump_ref_drv_allocate(size, UMP_REF_DRV_CONSTRAINT_USE_CACHE);
        else
            ump_mem_handle = ump_ref_drv_allocate(size, UMP_REF_DRV_CONSTRAINT_NONE);
#else
        else
            ump_mem_handle = ump_ref_drv_allocate(size, UMP_REF_DRV_CONSTRAINT_NONE);
#endif
        if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle) {
            if (!(usage & GRALLOC_USAGE_HW_ION || usage & GRALLOC_USAGE_HW_FIMC1))
                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;
                    hnd = new private_handle_t(priv_alloc_flag, size, (int)cpu_ptr,
                    private_handle_t::LOCK_STATE_MAPPED, ump_id, ump_mem_handle, ion_fd, 0, 0);
                    if (NULL != hnd) {
                        *pHandle = hnd;
#ifdef USE_PARTIAL_FLUSH
                        if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
                            private_handle_rect *psRect;
                            private_handle_rect *psFRect;
                            psRect = (private_handle_rect *)calloc(1, sizeof(private_handle_rect));
                            psRect->handle = (int)hnd->ump_id;
                            psRect->stride = stride_raw;
                            psFRect = find_last_rect((int)hnd->ump_id);
                            psFRect->next = psRect;
                        }
#endif
                        hnd->format = format;
                        hnd->usage = usage;
                        hnd->width = w;
                        hnd->height = h;
                        hnd->bpp = bpp;
                        hnd->stride = stride;
                        if(hnd->format == HAL_PIXEL_FORMAT_YV12) {
                            hnd->uoffset = ((EXYNOS4_ALIGN(hnd->width, 16) * hnd->height));
                            hnd->voffset = ((EXYNOS4_ALIGN((hnd->width >> 1), 16) * (hnd->height >> 1)));
                        } else {
                            hnd->uoffset = ((EXYNOS4_ALIGN(hnd->width, 16) * EXYNOS4_ALIGN(hnd->height, 16)));
                            hnd->voffset = ((EXYNOS4_ALIGN((hnd->width >> 1), 16) * EXYNOS4_ALIGN((hnd->height >> 1), 16)));
                        }
                        return 0;
                    } else {
                        ALOGE("gralloc_alloc_buffer() failed to allocate handle");
                    }
                } else {
                    ALOGE("gralloc_alloc_buffer() failed to retrieve valid secure id");
                }

                ump_mapped_pointer_release(ump_mem_handle);
            } else {
                ALOGE("gralloc_alloc_buffer() failed to map UMP memory");
            }

            ump_reference_release(ump_mem_handle);
        } else {
            ALOGE("gralloc_alloc_buffer() failed to allcoate UMP memory");
        }
#ifdef INSIGNAL_FIMC1
    }
#endif
    return -1;
}

static int gralloc_alloc_framebuffer_locked(alloc_device_t* dev, size_t size, int usage,
                                            buffer_handle_t* pHandle, int w, int h,
                                            int format, int bpp)
{
    private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
    /* allocate the framebuffer */
    if (m->framebuffer == NULL) {
        /* initialize the framebuffer, the framebuffer is mapped once and forever. */
        int err = init_frame_buffer_locked(m);
        if (err < 0)
            return err;
    }

    const uint32_t bufferMask = m->bufferMask;
    const uint32_t numBuffers = m->numBuffers;
    const size_t bufferSize = m->finfo.line_length * m->info.yres;
    if (numBuffers == 1) {
        /*
         * If we have only one buffer, we never use page-flipping. Instead,
         * we return a regular buffer which will be memcpy'ed to the main
         * screen when post is called.
         */
        int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
        ALOGE("fallback to single buffering");
        return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle, w, h, format, bpp, 0, 0);
    }

    if (bufferMask >= ((1LU<<numBuffers)-1))
        return -ENOMEM;

    int vaddr = m->framebuffer->base;
    /* find a free slot */
    for (uint32_t i = 0; i < numBuffers; i++) {
        if ((bufferMask & (1LU<<i)) == 0) {
            m->bufferMask |= (1LU<<i);
            break;
        }
        vaddr += bufferSize;
    }

    /*
     * The entire framebuffer memory is already mapped,
     * now create a buffer object for parts of this memory
     */
    private_handle_t* hnd = new private_handle_t
            (private_handle_t::PRIV_FLAGS_FRAMEBUFFER, size, vaddr,
             0, dup(m->framebuffer->fd), vaddr - m->framebuffer->base);

    hnd->format = format;
    hnd->usage = usage;
    hnd->width = w;
    hnd->height = h;
    hnd->bpp = bpp;

    *pHandle = hnd;

    return 0;
}

static int gralloc_alloc_framebuffer(alloc_device_t* dev, size_t size, int usage,
                                     buffer_handle_t* pHandle, int w, int h,
                                     int format, int bpp)
{
    private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
    pthread_mutex_lock(&m->lock);
    int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle, w, h, format, bpp);
    pthread_mutex_unlock(&m->lock);
    return err;
}

static int alloc_device_alloc(alloc_device_t* dev, int w, int h, int format,
                              int usage, buffer_handle_t* pHandle, int* pStride)
{
    if (!pHandle || !pStride)
        return -EINVAL;

    size_t size = 0;
    size_t stride = 0;
    size_t stride_raw = 0;

    if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP ||
        format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED ||
        format == HAL_PIXEL_FORMAT_YCrCb_420_SP ||
        format == HAL_PIXEL_FORMAT_YCbCr_422_SP ||
        format == HAL_PIXEL_FORMAT_YCbCr_420_P  ||
        format == HAL_PIXEL_FORMAT_YV12 ||
        format == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP ||
        format == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED ||
        format == GGL_PIXEL_FORMAT_L_8 ||
        format == OMX_COLOR_FormatYUV420Planar ||
        format == OMX_COLOR_FormatYUV420SemiPlanar) {
        /* FIXME: there is no way to return the vstride */
        int vstride;
        stride = EXYNOS4_ALIGN(w, 16);
        vstride = EXYNOS4_ALIGN(h, 16);
        switch (format) {
        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
        case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
        case HAL_PIXEL_FORMAT_YCbCr_420_P:
        case HAL_PIXEL_FORMAT_YV12:
        case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP:
        case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED:
        case OMX_COLOR_FormatYUV420Planar:
        case OMX_COLOR_FormatYUV420SemiPlanar:
            size = stride * vstride + EXYNOS4_ALIGN((w / 2), 16) * EXYNOS4_ALIGN((h / 2), 16) * 2;
#ifdef  INSIGNAL_FIMC1
            if (usage & GRALLOC_USAGE_HW_FIMC1) {
#else
            if (usage & GRALLOC_USAGE_HW_ION || usage & GRALLOC_USAGE_HW_FIMC1) {
#endif
                size += PAGE_SIZE * 2;
            }
            break;
        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
            size = (stride * vstride) + (w/2 * h/2) * 2;
            break;
        case GGL_PIXEL_FORMAT_L_8:
            size = (stride * vstride);
            break;
        default:
            return -EINVAL;
        }
    } else {
        int bpp = 0;
        switch (format) {
        case HAL_PIXEL_FORMAT_RGBA_8888:
        case HAL_PIXEL_FORMAT_RGBX_8888:
        case HAL_PIXEL_FORMAT_BGRA_8888:
            bpp = 4;
            break;
        case HAL_PIXEL_FORMAT_RGB_888:
            bpp = 3;
            break;
        case HAL_PIXEL_FORMAT_RGB_565:
        case HAL_PIXEL_FORMAT_RGBA_5551:
        case HAL_PIXEL_FORMAT_RGBA_4444:
            bpp = 2;
            break;
        default:
            return -EINVAL;
        }
        size_t bpr = EXYNOS4_ALIGN((w*bpp), 8);
        size = bpr * h;
        stride = bpr / bpp;
        stride_raw = bpr;
    }

    int err;
    pthread_mutex_lock(&l_surface);
    if (usage & GRALLOC_USAGE_HW_FB)
        err = gralloc_alloc_framebuffer(dev, size, usage, pHandle, w, h, format, 32);
    else
        err = gralloc_alloc_buffer(dev, size, usage, pHandle, w, h, format, 0, (int)stride_raw, (int)stride);

    pthread_mutex_unlock(&l_surface);

    if (err < 0)
        return err;

    *pStride = stride;
    return 0;
}

static int alloc_device_free(alloc_device_t* dev, buffer_handle_t handle)
{
    if (private_handle_t::validate(handle) < 0)
        return -EINVAL;

    private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
    private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
    pthread_mutex_lock(&l_surface);
    if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {
        /* free this buffer */
        const size_t bufferSize = m->finfo.line_length * m->info.yres;
        int index = (hnd->base - m->framebuffer->base) / bufferSize;
        m->bufferMask &= ~(1<<index);
        close(hnd->fd);
    } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_IOCTL) {
        void* base = (void*)(intptr_t(hnd->base) - hnd->offset);
        size_t size = FIMC1_RESERVED_SIZE * 1024;
        if (munmap(base, size) < 0)
            ALOGE("Could not unmap %s", strerror(errno));
        if (0 < gMemfd) {
            close(gMemfd);
            gMemfd = 0;
        }
    } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_UMP) {
#ifdef USE_PARTIAL_FLUSH
        if (!release_rect((int)hnd->ump_id))
            ALOGE("secure id: 0x%x, release error",(int)hnd->ump_id);
#endif
        ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
        ump_reference_release((ump_handle)hnd->ump_mem_handle);
    } else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
#ifdef USE_PARTIAL_FLUSH
        if (!release_rect((int)hnd->ump_id))
            ALOGE("secure id: 0x%x, release error",(int)hnd->ump_id);
#endif
        ump_mapped_pointer_release((ump_handle)hnd->ump_mem_handle);
        ump_reference_release((ump_handle)hnd->ump_mem_handle);

        ion_unmap((void*)hnd->base, hnd->size);
        ion_free(hnd->fd);
    }
    pthread_mutex_unlock(&l_surface);
    delete hnd;

    return 0;
}

static int alloc_device_close(struct hw_device_t *device)
{
    alloc_device_t* dev = reinterpret_cast<alloc_device_t*>(device);
    if (dev) {
        private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
        if (ion_dev_open)
            ion_client_destroy(m->ion_client);
        delete dev;
        ump_close();
    }
    return 0;
}

int alloc_device_open(hw_module_t const* module, const char* name, hw_device_t** device)
{
    alloc_device_t *dev;

    dev = new alloc_device_t;
    if (NULL == dev)
        return -1;

    dev->common.module = const_cast<hw_module_t*>(module);
    private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
    m->ion_client = ion_client_create();
    ump_result ump_res = ump_open();
    if (0 > m->ion_client)
        ion_dev_open = false;
    if (UMP_OK != ump_res) {
        ALOGE("UMP open failed ump_res %d", ump_res);
        delete dev;
        return -1;
    }

    /* initialize our state here */
    memset(dev, 0, sizeof(*dev));

    /* initialize the procs */
    dev->common.tag = HARDWARE_DEVICE_TAG;
    dev->common.version = 0;
    dev->common.module = const_cast<hw_module_t*>(module);
    dev->common.close = alloc_device_close;
    dev->alloc = alloc_device_alloc;
    dev->free = alloc_device_free;

    *device = &dev->common;

    return 0;
}