camera/MemoryManager.cpp

/*
 * Copyright (C) Texas Instruments - http://www.ti.com/
 *
 * 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 "CameraHal.h"
#include "TICameraParameters.h"

extern "C" {

//#include <timm_osal_interfaces.h>
//#include <timm_osal_trace.h>


};

namespace Ti {
namespace Camera {

///@todo Move these constants to a common header file, preferably in tiler.h
#define STRIDE_8BIT (4 * 1024)
#define STRIDE_16BIT (4 * 1024)

#define ALLOCATION_2D 2

///Utility Macro Declarations

/*--------------------MemoryManager Class STARTS here-----------------------------*/
MemoryManager::MemoryManager() {
    mIonFd = -1;
}

MemoryManager::~MemoryManager() {
    if ( mIonFd >= 0 ) {
        ion_close(mIonFd);
        mIonFd = -1;
    }
}

status_t MemoryManager::initialize() {
    if ( mIonFd == -1 ) {
        mIonFd = ion_open();
        if ( mIonFd < 0 ) {
            CAMHAL_LOGE("ion_open() failed, error: %d", mIonFd);
            mIonFd = -1;
            return NO_INIT;
        }
    }

    return OK;
}

CameraBuffer* MemoryManager::allocateBufferList(int width, int height, const char* format, int &size, int numBufs)
{
    LOG_FUNCTION_NAME;

    CAMHAL_ASSERT(mIonFd != -1);

    ///We allocate numBufs+1 because the last entry will be marked NULL to indicate end of array, which is used when freeing
    ///the buffers
    const uint numArrayEntriesC = (uint)(numBufs+1);

    ///Allocate a buffer array
    CameraBuffer *buffers = new CameraBuffer [numArrayEntriesC];
    if(!buffers) {
        CAMHAL_LOGEB("Allocation failed when creating buffers array of %d CameraBuffer elements", numArrayEntriesC);
        goto error;
    }

    ///Initialize the array with zeros - this will help us while freeing the array in case of error
    ///If a value of an array element is NULL, it means we didnt allocate it
    memset(buffers, 0, sizeof(CameraBuffer) * numArrayEntriesC);

    //2D Allocations are not supported currently
    if(size != 0) {
        struct ion_handle *handle;
        int mmap_fd;
        size_t stride;

        ///1D buffers
        for (int i = 0; i < numBufs; i++) {
            unsigned char *data;
            int ret = ion_alloc(mIonFd, size, 0, 1 << ION_HEAP_TYPE_CARVEOUT,
                    &handle);
            if((ret < 0) || ((int)handle == -ENOMEM)) {
                ret = ion_alloc_tiler(mIonFd, (size_t)size, 1, TILER_PIXEL_FMT_PAGE,
                OMAP_ION_HEAP_TILER_MASK, &handle, &stride);
            }

            if((ret < 0) || ((int)handle == -ENOMEM)) {
                CAMHAL_LOGEB("FAILED to allocate ion buffer of size=%d. ret=%d(0x%x)", size, ret, ret);
                goto error;
            }

            CAMHAL_LOGDB("Before mapping, handle = %p, nSize = %d", handle, size);
            if ((ret = ion_map(mIonFd, handle, size, PROT_READ | PROT_WRITE, MAP_SHARED, 0,
                          &data, &mmap_fd)) < 0) {
                CAMHAL_LOGEB("Userspace mapping of ION buffers returned error %d", ret);
                ion_free(mIonFd, handle);
                goto error;
            }

            buffers[i].type = CAMERA_BUFFER_ION;
            buffers[i].opaque = data;
            buffers[i].mapped = data;
            buffers[i].ion_handle = handle;
            buffers[i].ion_fd = mIonFd;
            buffers[i].fd = mmap_fd;
            buffers[i].size = size;
            buffers[i].format = CameraHal::getPixelFormatConstant(format);

        }
    }

    LOG_FUNCTION_NAME_EXIT;

    return buffers;

error:

    CAMHAL_LOGE("Freeing buffers already allocated after error occurred");
    if(buffers)
        freeBufferList(buffers);

    if ( NULL != mErrorNotifier.get() )
        mErrorNotifier->errorNotify(-ENOMEM);
    LOG_FUNCTION_NAME_EXIT;

    return NULL;
}

CameraBuffer* MemoryManager::getBufferList(int *numBufs) {
    LOG_FUNCTION_NAME;
    if (numBufs) *numBufs = -1;

    return NULL;
}

//TODO: Get needed data to map tiler buffers
//Return dummy data for now
uint32_t * MemoryManager::getOffsets()
{
    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return NULL;
}

int MemoryManager::getFd()
{
    LOG_FUNCTION_NAME;

    LOG_FUNCTION_NAME_EXIT;

    return -1;
}

int MemoryManager::freeBufferList(CameraBuffer *buffers)
{
    status_t ret = NO_ERROR;
    LOG_FUNCTION_NAME;

    int i;

    if(!buffers)
        {
        CAMHAL_LOGEA("NULL pointer passed to freebuffer");
        LOG_FUNCTION_NAME_EXIT;
        return BAD_VALUE;
        }

    i = 0;
    while(buffers[i].type == CAMERA_BUFFER_ION)
        {
        if(buffers[i].size)
            {
            munmap(buffers[i].opaque, buffers[i].size);
            close(buffers[i].fd);
            ion_free(mIonFd, buffers[i].ion_handle);
            }
        else
            {
            CAMHAL_LOGEA("Not a valid Memory Manager buffer");
            }
        i++;
        }

    delete [] buffers;

    LOG_FUNCTION_NAME_EXIT;
    return ret;
}

status_t MemoryManager::setErrorHandler(ErrorNotifier *errorNotifier)
{
    status_t ret = NO_ERROR;

    LOG_FUNCTION_NAME;

    if ( NULL == errorNotifier )
        {
        CAMHAL_LOGEA("Invalid Error Notifier reference");
        ret = -EINVAL;
        }

    if ( NO_ERROR == ret )
        {
        mErrorNotifier = errorNotifier;
        }

    LOG_FUNCTION_NAME_EXIT;

    return ret;
}

} // namespace Camera
} // namespace Ti


/*--------------------MemoryManager Class ENDS here-----------------------------*/