| /* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #define LOG_TAG "QCameraHWI_Mem" |
| |
| // System dependencies |
| #include <fcntl.h> |
| #define MMAN_H <SYSTEM_HEADER_PREFIX/mman.h> |
| #include MMAN_H |
| #include "gralloc_priv.h" |
| |
| // Display dependencies |
| #include "qdMetaData.h" |
| |
| // Camera dependencies |
| #include "QCamera3HWI.h" |
| #include "QCamera3Mem.h" |
| #include "QCameraTrace.h" |
| |
| extern "C" { |
| #include "mm_camera_dbg.h" |
| #include "mm_camera_interface.h" |
| } |
| |
| using namespace android; |
| |
| namespace qcamera { |
| |
| // QCaemra2Memory base class |
| |
| /*=========================================================================== |
| * FUNCTION : QCamera3Memory |
| * |
| * DESCRIPTION: default constructor of QCamera3Memory |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : None |
| *==========================================================================*/ |
| QCamera3Memory::QCamera3Memory() |
| { |
| mBufferCount = 0; |
| for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i++) { |
| mMemInfo[i].fd = -1; |
| mMemInfo[i].handle = 0; |
| mMemInfo[i].size = 0; |
| mCurrentFrameNumbers[i] = -1; |
| } |
| main_ion_fd = open("/dev/ion", O_RDONLY); |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : ~QCamera3Memory |
| * |
| * DESCRIPTION: deconstructor of QCamera3Memory |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : None |
| *==========================================================================*/ |
| QCamera3Memory::~QCamera3Memory() |
| { |
| close(main_ion_fd); |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : cacheOpsInternal |
| * |
| * DESCRIPTION: ion related memory cache operations |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * @cmd : cache ops command |
| * @vaddr : ptr to the virtual address |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3Memory::cacheOpsInternal(uint32_t index, unsigned int cmd, void *vaddr) |
| { |
| ATRACE_CALL(); |
| Mutex::Autolock lock(mLock); |
| |
| struct ion_flush_data cache_inv_data; |
| struct ion_custom_data custom_data; |
| int ret = OK; |
| |
| if (MM_CAMERA_MAX_NUM_FRAMES <= index) { |
| LOGE("index %d out of bound [0, %d)", |
| index, MM_CAMERA_MAX_NUM_FRAMES); |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not registered", index); |
| return BAD_INDEX; |
| } |
| |
| memset(&cache_inv_data, 0, sizeof(cache_inv_data)); |
| memset(&custom_data, 0, sizeof(custom_data)); |
| cache_inv_data.vaddr = vaddr; |
| cache_inv_data.fd = mMemInfo[index].fd; |
| cache_inv_data.handle = mMemInfo[index].handle; |
| cache_inv_data.length = (unsigned int)mMemInfo[index].size; |
| custom_data.cmd = cmd; |
| custom_data.arg = (unsigned long)&cache_inv_data; |
| |
| LOGD("addr = %p, fd = %d, handle = %lx length = %d, ION Fd = %d", |
| cache_inv_data.vaddr, cache_inv_data.fd, |
| (unsigned long)cache_inv_data.handle, cache_inv_data.length, |
| main_ion_fd); |
| ret = ioctl(main_ion_fd, ION_IOC_CUSTOM, &custom_data); |
| if (ret < 0) |
| LOGE("Cache Invalidate failed: %s\n", strerror(errno)); |
| |
| return ret; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getFd |
| * |
| * DESCRIPTION: return file descriptor of the indexed buffer |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : file descriptor |
| *==========================================================================*/ |
| int QCamera3Memory::getFd(uint32_t index) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (MM_CAMERA_MAX_NUM_FRAMES <= index) { |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| return BAD_INDEX; |
| } |
| |
| return mMemInfo[index].fd; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getSize |
| * |
| * DESCRIPTION: return buffer size of the indexed buffer |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : buffer size |
| *==========================================================================*/ |
| ssize_t QCamera3Memory::getSize(uint32_t index) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (MM_CAMERA_MAX_NUM_FRAMES <= index) { |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| return BAD_INDEX; |
| } |
| |
| return (ssize_t)mMemInfo[index].size; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getCnt |
| * |
| * DESCRIPTION: query number of buffers allocated |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : number of buffers allocated |
| *==========================================================================*/ |
| uint32_t QCamera3Memory::getCnt() |
| { |
| Mutex::Autolock lock(mLock); |
| |
| return mBufferCount; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getBufDef |
| * |
| * DESCRIPTION: query detailed buffer information |
| * |
| * PARAMETERS : |
| * @offset : [input] frame buffer offset |
| * @bufDef : [output] reference to struct to store buffer definition |
| * @index : [input] index of the buffer |
| * @virtualAddr : [input] Whether to fill out virtual address |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int32_t QCamera3Memory::getBufDef(const cam_frame_len_offset_t &offset, |
| mm_camera_buf_def_t &bufDef, uint32_t index, bool virtualAddr) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (!mBufferCount) { |
| LOGE("Memory not allocated"); |
| return NO_INIT; |
| } |
| |
| bufDef.fd = mMemInfo[index].fd; |
| bufDef.frame_len = mMemInfo[index].size; |
| bufDef.mem_info = (void *)this; |
| bufDef.buffer = virtualAddr ? getPtrLocked(index) : nullptr; |
| bufDef.planes_buf.num_planes = (int8_t)offset.num_planes; |
| bufDef.buf_idx = (uint8_t)index; |
| |
| /* Plane 0 needs to be set separately. Set other planes in a loop */ |
| bufDef.planes_buf.planes[0].length = offset.mp[0].len; |
| bufDef.planes_buf.planes[0].m.userptr = (long unsigned int)mMemInfo[index].fd; |
| bufDef.planes_buf.planes[0].data_offset = offset.mp[0].offset; |
| bufDef.planes_buf.planes[0].reserved[0] = 0; |
| for (int i = 1; i < bufDef.planes_buf.num_planes; i++) { |
| bufDef.planes_buf.planes[i].length = offset.mp[i].len; |
| bufDef.planes_buf.planes[i].m.userptr = (long unsigned int)mMemInfo[i].fd; |
| bufDef.planes_buf.planes[i].data_offset = offset.mp[i].offset; |
| bufDef.planes_buf.planes[i].reserved[0] = |
| bufDef.planes_buf.planes[i-1].reserved[0] + |
| bufDef.planes_buf.planes[i-1].length; |
| } |
| |
| return NO_ERROR; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : QCamera3HeapMemory |
| * |
| * DESCRIPTION: constructor of QCamera3HeapMemory for ion memory used internally in HAL |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| QCamera3HeapMemory::QCamera3HeapMemory(uint32_t maxCnt) |
| : QCamera3Memory() |
| { |
| mMaxCnt = MIN(maxCnt, MM_CAMERA_MAX_NUM_FRAMES); |
| for (uint32_t i = 0; i < mMaxCnt; i ++) |
| mPtr[i] = NULL; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : ~QCamera3HeapMemory |
| * |
| * DESCRIPTION: deconstructor of QCamera3HeapMemory |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| QCamera3HeapMemory::~QCamera3HeapMemory() |
| { |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : allocOneBuffer |
| * |
| * DESCRIPTION: impl of allocating one buffers of certain size |
| * |
| * PARAMETERS : |
| * @memInfo : [output] reference to struct to store additional memory allocation info |
| * @heap : [input] heap id to indicate where the buffers will be allocated from |
| * @size : [input] lenght of the buffer to be allocated |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3HeapMemory::allocOneBuffer(QCamera3MemInfo &memInfo, |
| unsigned int heap_id, size_t size, bool isCached) |
| { |
| int rc = OK; |
| struct ion_handle_data handle_data; |
| struct ion_allocation_data allocData; |
| struct ion_fd_data ion_info_fd; |
| |
| if (main_ion_fd < 0) { |
| LOGE("Ion dev open failed: %s\n", strerror(errno)); |
| goto ION_OPEN_FAILED; |
| } |
| |
| memset(&allocData, 0, sizeof(allocData)); |
| allocData.len = size; |
| /* to make it page size aligned */ |
| allocData.len = (allocData.len + 4095U) & (~4095U); |
| allocData.align = 4096; |
| if (isCached) { |
| allocData.flags = ION_FLAG_CACHED; |
| } |
| allocData.heap_id_mask = heap_id; |
| rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &allocData); |
| if (rc < 0) { |
| LOGE("ION allocation for len %d failed: %s\n", allocData.len, |
| strerror(errno)); |
| goto ION_ALLOC_FAILED; |
| } |
| |
| memset(&ion_info_fd, 0, sizeof(ion_info_fd)); |
| ion_info_fd.handle = allocData.handle; |
| rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd); |
| if (rc < 0) { |
| LOGE("ION map failed %s\n", strerror(errno)); |
| goto ION_MAP_FAILED; |
| } |
| |
| memInfo.fd = ion_info_fd.fd; |
| memInfo.handle = ion_info_fd.handle; |
| memInfo.size = allocData.len; |
| return OK; |
| |
| ION_MAP_FAILED: |
| memset(&handle_data, 0, sizeof(handle_data)); |
| handle_data.handle = ion_info_fd.handle; |
| ioctl(main_ion_fd, ION_IOC_FREE, &handle_data); |
| ION_ALLOC_FAILED: |
| ION_OPEN_FAILED: |
| return NO_MEMORY; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : deallocOneBuffer |
| * |
| * DESCRIPTION: impl of deallocating one buffers |
| * |
| * PARAMETERS : |
| * @memInfo : reference to struct that stores additional memory allocation info |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| void QCamera3HeapMemory::deallocOneBuffer(QCamera3MemInfo &memInfo) |
| { |
| struct ion_handle_data handle_data; |
| |
| if (memInfo.fd >= 0) { |
| close(memInfo.fd); |
| memInfo.fd = -1; |
| } |
| |
| if (main_ion_fd >= 0) { |
| memset(&handle_data, 0, sizeof(handle_data)); |
| handle_data.handle = memInfo.handle; |
| ioctl(main_ion_fd, ION_IOC_FREE, &handle_data); |
| } |
| memInfo.handle = 0; |
| memInfo.size = 0; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getPtrLocked |
| * |
| * DESCRIPTION: Return buffer pointer. |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : buffer ptr |
| *==========================================================================*/ |
| void *QCamera3HeapMemory::getPtrLocked(uint32_t index) |
| { |
| if (index >= mBufferCount) { |
| LOGE("index out of bound"); |
| return NULL; |
| } |
| return mPtr[index]; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : markFrameNumber |
| * |
| * DESCRIPTION: We use this function from the request call path to mark the |
| * buffers with the frame number they are intended for this info |
| * is used later when giving out callback & it is duty of PP to |
| * ensure that data for that particular frameNumber/Request is |
| * written to this buffer. |
| * PARAMETERS : |
| * @index : index of the buffer |
| * @frame# : Frame number from the framework |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int32_t QCamera3HeapMemory::markFrameNumber(uint32_t index, uint32_t frameNumber) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (index >= mBufferCount) { |
| LOGE("Index %d out of bounds, current buffer count is %d", |
| index, mBufferCount); |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not allocated", index); |
| return BAD_INDEX; |
| } |
| |
| mCurrentFrameNumbers[index] = (int32_t)frameNumber; |
| |
| return NO_ERROR; |
| } |
| |
| |
| /*=========================================================================== |
| * FUNCTION : getFrameNumber |
| * |
| * DESCRIPTION: We use this to fetch the frameNumber for the request with which |
| * this buffer was given to HAL |
| * |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : int32_t frameNumber |
| * positive/zero -- success |
| * negative failure |
| *==========================================================================*/ |
| int32_t QCamera3HeapMemory::getFrameNumber(uint32_t index) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (index >= mBufferCount) { |
| LOGE("Index %d out of bounds, current buffer count is %d", |
| index, mBufferCount); |
| return -1; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not registered", index); |
| return -1; |
| } |
| |
| return mCurrentFrameNumbers[index]; |
| } |
| |
| |
| /*=========================================================================== |
| * FUNCTION : getOldestFrameNumber |
| * |
| * DESCRIPTION: We use this to fetch the oldest frame number expected per FIFO |
| * |
| * |
| * PARAMETERS : |
| * |
| * |
| * RETURN : int32_t frameNumber |
| * negative failure |
| *==========================================================================*/ |
| int32_t QCamera3HeapMemory::getOldestFrameNumber(uint32_t &bufIndex) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| int32_t oldest = INT_MAX; |
| bool empty = true; |
| |
| for (uint32_t index = 0; |
| index < mBufferCount; index++) { |
| if (mMemInfo[index].handle) { |
| if ((empty) || (!empty && oldest > mCurrentFrameNumbers[index] |
| && mCurrentFrameNumbers[index] != -1)) { |
| oldest = mCurrentFrameNumbers[index]; |
| bufIndex = index; |
| } |
| empty = false; |
| } |
| } |
| if (empty) |
| return -1; |
| else |
| return oldest; |
| } |
| |
| |
| /*=========================================================================== |
| * FUNCTION : getBufferIndex |
| * |
| * DESCRIPTION: We use this to fetch the buffer index for the request with |
| * a particular frame number |
| * |
| * |
| * PARAMETERS : |
| * @frameNumber : frame number of the buffer |
| * |
| * RETURN : int32_t buffer index |
| * negative failure |
| *==========================================================================*/ |
| int32_t QCamera3HeapMemory::getBufferIndex(uint32_t frameNumber) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| for (uint32_t index = 0; |
| index < mBufferCount; index++) { |
| if (mMemInfo[index].handle && |
| mCurrentFrameNumbers[index] == (int32_t)frameNumber) |
| return (int32_t)index; |
| } |
| return -1; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getPtr |
| * |
| * DESCRIPTION: Return buffer pointer |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : buffer ptr |
| *==========================================================================*/ |
| void *QCamera3HeapMemory::getPtr(uint32_t index) |
| { |
| return getPtrLocked(index); |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : allocate |
| * |
| * DESCRIPTION: allocate requested number of buffers of certain size |
| * |
| * PARAMETERS : |
| * @size : lenght of the buffer to be allocated |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3HeapMemory::allocate(size_t size) |
| { |
| unsigned int heap_id_mask = 0x1 << ION_IOMMU_HEAP_ID; |
| uint32_t i; |
| int rc = NO_ERROR; |
| |
| //Note that now we allow incremental allocation. In other words, we allow |
| //multiple alloc being called as long as the sum of count does not exceed |
| //mMaxCnt. |
| if (mBufferCount > 0) { |
| LOGE("There is already buffer allocated."); |
| return BAD_INDEX; |
| } |
| |
| for (i = 0; i < mMaxCnt; i ++) { |
| rc = allocOneBuffer(mMemInfo[i], heap_id_mask, size); |
| if (rc < 0) { |
| LOGE("AllocateIonMemory failed"); |
| goto ALLOC_FAILED; |
| } |
| |
| void *vaddr = mmap(NULL, |
| mMemInfo[i].size, |
| PROT_READ | PROT_WRITE, |
| MAP_SHARED, |
| mMemInfo[i].fd, 0); |
| if (vaddr == MAP_FAILED) { |
| deallocOneBuffer(mMemInfo[i]); |
| LOGE("mmap failed for buffer %d", i); |
| goto ALLOC_FAILED; |
| } else |
| mPtr[i] = vaddr; |
| } |
| if (rc == 0) |
| mBufferCount = mMaxCnt; |
| |
| return OK; |
| |
| ALLOC_FAILED: |
| for (uint32_t j = 0; j < i; j++) { |
| munmap(mPtr[j], mMemInfo[j].size); |
| mPtr[j] = NULL; |
| deallocOneBuffer(mMemInfo[j]); |
| } |
| return NO_MEMORY; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : allocateOne |
| * |
| * DESCRIPTION: allocate one buffer |
| * |
| * PARAMETERS : |
| * @size : lenght of the buffer to be allocated |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3HeapMemory::allocateOne(size_t size, bool isCached) |
| { |
| unsigned int heap_id_mask = 0x1 << ION_IOMMU_HEAP_ID; |
| int rc = NO_ERROR; |
| |
| //Note that now we allow incremental allocation. In other words, we allow |
| //multiple alloc being called as long as the sum of count does not exceed |
| //mMaxCnt. |
| if (mBufferCount + 1 > mMaxCnt) { |
| LOGE("Buffer count %d + 1 out of bound. Max is %d", |
| mBufferCount, mMaxCnt); |
| return BAD_INDEX; |
| } |
| |
| rc = allocOneBuffer(mMemInfo[mBufferCount], heap_id_mask, size, isCached); |
| if (rc < 0) { |
| LOGE("AllocateIonMemory failed"); |
| return NO_MEMORY; |
| } |
| |
| void *vaddr = mmap(NULL, |
| mMemInfo[mBufferCount].size, |
| PROT_READ | PROT_WRITE, |
| MAP_SHARED, |
| mMemInfo[mBufferCount].fd, 0); |
| if (vaddr == MAP_FAILED) { |
| deallocOneBuffer(mMemInfo[mBufferCount]); |
| LOGE("mmap failed for buffer"); |
| return NO_MEMORY; |
| } else |
| mPtr[mBufferCount] = vaddr; |
| |
| if (rc == 0) |
| mBufferCount += 1; |
| |
| return mBufferCount-1; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : deallocate |
| * |
| * DESCRIPTION: deallocate buffers |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| void QCamera3HeapMemory::deallocate() |
| { |
| for (uint32_t i = 0; i < mBufferCount; i++) { |
| munmap(mPtr[i], mMemInfo[i].size); |
| mPtr[i] = NULL; |
| deallocOneBuffer(mMemInfo[i]); |
| mCurrentFrameNumbers[i] = -1; |
| } |
| mBufferCount = 0; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : cacheOps |
| * |
| * DESCRIPTION: ion related memory cache operations |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * @cmd : cache ops command |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3HeapMemory::cacheOps(uint32_t index, unsigned int cmd) |
| { |
| if (index >= mBufferCount) |
| return BAD_INDEX; |
| return cacheOpsInternal(index, cmd, mPtr[index]); |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getMatchBufIndex |
| * |
| * DESCRIPTION: query buffer index by object ptr |
| * |
| * PARAMETERS : |
| * @object : object ptr |
| * |
| * RETURN : buffer index if match found, |
| * -1 if failed |
| *==========================================================================*/ |
| int QCamera3HeapMemory::getMatchBufIndex(void * /*object*/) |
| { |
| |
| /* |
| TODO for HEAP memory type, would there be an equivalent requirement? |
| |
| int index = -1; |
| buffer_handle_t *key = (buffer_handle_t*) object; |
| if (!key) { |
| return BAD_VALUE; |
| } |
| for (int i = 0; i < mBufferCount; i++) { |
| if (mBufferHandle[i] == key) { |
| index = i; |
| break; |
| } |
| } |
| return index; |
| */ |
| LOGE("FATAL: Not supposed to come here"); |
| return -1; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : QCamera3GrallocMemory |
| * |
| * DESCRIPTION: constructor of QCamera3GrallocMemory |
| * preview stream buffers are allocated from gralloc native_windoe |
| * |
| * PARAMETERS : |
| * @startIdx : start index of array after which we can register buffers in. |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| QCamera3GrallocMemory::QCamera3GrallocMemory(uint32_t startIdx) |
| : QCamera3Memory(), mStartIdx(startIdx) |
| { |
| for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i ++) { |
| mBufferHandle[i] = NULL; |
| mPrivateHandle[i] = NULL; |
| mPtr[i] = nullptr; |
| } |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : ~QCamera3GrallocMemory |
| * |
| * DESCRIPTION: deconstructor of QCamera3GrallocMemory |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| QCamera3GrallocMemory::~QCamera3GrallocMemory() |
| { |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : registerBuffer |
| * |
| * DESCRIPTION: registers frameworks-allocated gralloc buffer_handle_t |
| * |
| * PARAMETERS : |
| * @buffers : buffer_handle_t pointer |
| * @type : cam_stream_type_t |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3GrallocMemory::registerBuffer(buffer_handle_t *buffer, |
| __unused cam_stream_type_t type) |
| { |
| status_t ret = NO_ERROR; |
| struct ion_fd_data ion_info_fd; |
| int32_t colorSpace = ITU_R_601_FR; |
| int32_t idx = -1; |
| |
| LOGD("E"); |
| |
| memset(&ion_info_fd, 0, sizeof(ion_info_fd)); |
| |
| if (0 <= getMatchBufIndex((void *) buffer)) { |
| LOGL("Buffer already registered"); |
| return ALREADY_EXISTS; |
| } |
| |
| Mutex::Autolock lock(mLock); |
| if (mBufferCount >= (MM_CAMERA_MAX_NUM_FRAMES - 1 - mStartIdx)) { |
| LOGE("Number of buffers %d greater than what's supported %d", |
| mBufferCount, MM_CAMERA_MAX_NUM_FRAMES - mStartIdx); |
| return BAD_INDEX; |
| } |
| |
| idx = getFreeIndexLocked(); |
| if (0 > idx) { |
| LOGE("No available memory slots"); |
| return BAD_INDEX; |
| } |
| |
| mBufferHandle[idx] = buffer; |
| mPrivateHandle[idx] = (struct private_handle_t *)(*mBufferHandle[idx]); |
| |
| setMetaData(mPrivateHandle[idx], UPDATE_COLOR_SPACE, &colorSpace); |
| |
| if (main_ion_fd < 0) { |
| LOGE("failed: could not open ion device"); |
| ret = NO_MEMORY; |
| goto end; |
| } else { |
| ion_info_fd.fd = mPrivateHandle[idx]->fd; |
| if (ioctl(main_ion_fd, |
| ION_IOC_IMPORT, &ion_info_fd) < 0) { |
| LOGE("ION import failed\n"); |
| ret = NO_MEMORY; |
| goto end; |
| } |
| } |
| LOGD("idx = %d, fd = %d, size = %d, offset = %d", |
| idx, mPrivateHandle[idx]->fd, |
| mPrivateHandle[idx]->size, |
| mPrivateHandle[idx]->offset); |
| mMemInfo[idx].fd = mPrivateHandle[idx]->fd; |
| mMemInfo[idx].size = |
| ( /* FIXME: Should update ION interface */ size_t) |
| mPrivateHandle[idx]->size; |
| mMemInfo[idx].handle = ion_info_fd.handle; |
| |
| mBufferCount++; |
| |
| end: |
| LOGD("X "); |
| return ret; |
| } |
| /*=========================================================================== |
| * FUNCTION : unregisterBufferLocked |
| * |
| * DESCRIPTION: Unregister buffer. Please note that this method has to be |
| * called with 'mLock' acquired. |
| * |
| * PARAMETERS : |
| * @idx : unregister buffer at index 'idx' |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int32_t QCamera3GrallocMemory::unregisterBufferLocked(size_t idx) |
| { |
| if (mPtr[idx] != nullptr) { |
| munmap(mPtr[idx], mMemInfo[idx].size); |
| mPtr[idx] = nullptr; |
| } |
| |
| struct ion_handle_data ion_handle; |
| memset(&ion_handle, 0, sizeof(ion_handle)); |
| ion_handle.handle = mMemInfo[idx].handle; |
| if (ioctl(main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) { |
| LOGE("ion free failed"); |
| } |
| memset(&mMemInfo[idx], 0, sizeof(struct QCamera3MemInfo)); |
| mBufferHandle[idx] = NULL; |
| mPrivateHandle[idx] = NULL; |
| mCurrentFrameNumbers[idx] = -1; |
| mBufferCount--; |
| |
| return NO_ERROR; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : unregisterBuffer |
| * |
| * DESCRIPTION: unregister buffer |
| * |
| * PARAMETERS : |
| * @idx : unregister buffer at index 'idx' |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int32_t QCamera3GrallocMemory::unregisterBuffer(size_t idx) |
| { |
| int32_t rc = NO_ERROR; |
| Mutex::Autolock lock(mLock); |
| |
| LOGD("E ", __FUNCTION__); |
| |
| if (MM_CAMERA_MAX_NUM_FRAMES <= idx) { |
| LOGE("Buffer index %d greater than what is supported %d", |
| idx, MM_CAMERA_MAX_NUM_FRAMES); |
| return BAD_VALUE; |
| } |
| if (idx < mStartIdx) { |
| LOGE("buffer index %d less than starting index %d", |
| idx, mStartIdx); |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[idx].handle) { |
| LOGE("Trying to unregister buffer at %d which still not registered", |
| idx); |
| return BAD_VALUE; |
| } |
| |
| rc = unregisterBufferLocked(idx); |
| |
| LOGD("X ",__FUNCTION__); |
| |
| return rc; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : unregisterBuffers |
| * |
| * DESCRIPTION: unregister buffers |
| * |
| * PARAMETERS : none |
| * |
| * RETURN : none |
| *==========================================================================*/ |
| void QCamera3GrallocMemory::unregisterBuffers() |
| { |
| int err = NO_ERROR; |
| Mutex::Autolock lock(mLock); |
| |
| LOGD("E ", __FUNCTION__); |
| |
| for (uint32_t cnt = mStartIdx; cnt < MM_CAMERA_MAX_NUM_FRAMES; cnt++) { |
| if (0 == mMemInfo[cnt].handle) { |
| continue; |
| } |
| err = unregisterBufferLocked(cnt); |
| if (NO_ERROR != err) { |
| LOGE("Error unregistering buffer %d error %d", |
| cnt, err); |
| } |
| } |
| mBufferCount = 0; |
| LOGD("X ",__FUNCTION__); |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : markFrameNumber |
| * |
| * DESCRIPTION: We use this function from the request call path to mark the |
| * buffers with the frame number they are intended for this info |
| * is used later when giving out callback & it is duty of PP to |
| * ensure that data for that particular frameNumber/Request is |
| * written to this buffer. |
| * PARAMETERS : |
| * @index : index of the buffer |
| * @frame# : Frame number from the framework |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int32_t QCamera3GrallocMemory::markFrameNumber(uint32_t index, uint32_t frameNumber) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (index >= MM_CAMERA_MAX_NUM_FRAMES) { |
| LOGE("Index out of bounds"); |
| return BAD_INDEX; |
| } |
| if (index < mStartIdx) { |
| LOGE("buffer index %d less than starting index %d", |
| index, mStartIdx); |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not registered", index); |
| return BAD_INDEX; |
| } |
| |
| mCurrentFrameNumbers[index] = (int32_t)frameNumber; |
| |
| return NO_ERROR; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getFrameNumber |
| * |
| * DESCRIPTION: We use this to fetch the frameNumber for the request with which |
| * this buffer was given to HAL |
| * |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : int32_t frameNumber |
| * positive/zero -- success |
| * negative failure |
| *==========================================================================*/ |
| int32_t QCamera3GrallocMemory::getFrameNumber(uint32_t index) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (index >= MM_CAMERA_MAX_NUM_FRAMES) { |
| LOGE("Index out of bounds"); |
| return -1; |
| } |
| if (index < mStartIdx) { |
| LOGE("buffer index %d less than starting index %d", |
| index, mStartIdx); |
| return BAD_INDEX; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not registered", index); |
| return -1; |
| } |
| |
| return mCurrentFrameNumbers[index]; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getOldestFrameNumber |
| * |
| * DESCRIPTION: We use this to fetch the oldest frame number expected per FIFO |
| * |
| * |
| * PARAMETERS : |
| * |
| * |
| * RETURN : int32_t frameNumber |
| * negative failure |
| *==========================================================================*/ |
| int32_t QCamera3GrallocMemory::getOldestFrameNumber(uint32_t &bufIndex) |
| { |
| int32_t oldest = INT_MAX; |
| bool empty = true; |
| for (uint32_t index = mStartIdx; |
| index < MM_CAMERA_MAX_NUM_FRAMES; index++) { |
| if (mMemInfo[index].handle) { |
| if ((empty) || |
| (!empty && oldest > mCurrentFrameNumbers[index] |
| && mCurrentFrameNumbers[index] != -1)) { |
| oldest = mCurrentFrameNumbers[index]; |
| bufIndex = index; |
| } |
| empty = false; |
| } |
| } |
| if (empty) |
| return -1; |
| else |
| return oldest; |
| } |
| |
| |
| /*=========================================================================== |
| * FUNCTION : getBufferIndex |
| * |
| * DESCRIPTION: We use this to fetch the buffer index for the request with |
| * a particular frame number |
| * |
| * |
| * PARAMETERS : |
| * @frameNumber : frame number of the buffer |
| * |
| * RETURN : int32_t buffer index |
| * negative failure |
| *==========================================================================*/ |
| int32_t QCamera3GrallocMemory::getBufferIndex(uint32_t frameNumber) |
| { |
| for (uint32_t index = mStartIdx; |
| index < MM_CAMERA_MAX_NUM_FRAMES; index++) { |
| if (mMemInfo[index].handle && |
| mCurrentFrameNumbers[index] == (int32_t)frameNumber) |
| return (int32_t)index; |
| } |
| return -1; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : cacheOps |
| * |
| * DESCRIPTION: ion related memory cache operations |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * @cmd : cache ops command |
| * |
| * RETURN : int32_t type of status |
| * NO_ERROR -- success |
| * none-zero failure code |
| *==========================================================================*/ |
| int QCamera3GrallocMemory::cacheOps(uint32_t index, unsigned int cmd) |
| { |
| int rc = 0; |
| bool needToInvalidate = false; |
| struct private_handle_t *privateHandle = NULL; |
| privateHandle = mPrivateHandle[index]; |
| |
| if (privateHandle != NULL){ |
| if(privateHandle->flags & |
| (private_handle_t::PRIV_FLAGS_NON_CPU_WRITER)){ |
| needToInvalidate = true; |
| } |
| } |
| |
| if (index >= MM_CAMERA_MAX_NUM_FRAMES) { |
| LOGE("Index out of bounds"); |
| return -1; |
| } |
| if (index < mStartIdx) { |
| LOGE("buffer index %d less than starting index %d", |
| index, mStartIdx); |
| return BAD_INDEX; |
| } |
| |
| LOGD("needToInvalidate %d buf idx %d", needToInvalidate, index); |
| if(((cmd == ION_IOC_INV_CACHES) || (cmd == ION_IOC_CLEAN_INV_CACHES)) |
| && needToInvalidate) { |
| rc = cacheOpsInternal(index, cmd, mPtr[index]); |
| } |
| else if(cmd == ION_IOC_CLEAN_CACHES) { |
| rc = cacheOpsInternal(index, cmd, mPtr[index]); |
| } |
| return rc; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getMatchBufIndex |
| * |
| * DESCRIPTION: query buffer index by object ptr |
| * |
| * PARAMETERS : |
| * @opaque : opaque ptr |
| * |
| * RETURN : buffer index if match found, |
| * -1 if failed |
| *==========================================================================*/ |
| int QCamera3GrallocMemory::getMatchBufIndex(void *object) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| int index = -1; |
| buffer_handle_t *key = (buffer_handle_t*) object; |
| if (!key) { |
| return BAD_VALUE; |
| } |
| for (uint32_t i = mStartIdx; i < MM_CAMERA_MAX_NUM_FRAMES; i++) { |
| if (mBufferHandle[i] == key) { |
| index = (int)i; |
| break; |
| } |
| } |
| |
| return index; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getFreeIndexLocked |
| * |
| * DESCRIPTION: Find free index slot. Note 'mLock' needs to be acquired |
| * before calling this method. |
| * |
| * PARAMETERS : None |
| * |
| * RETURN : free buffer index if found, |
| * -1 if failed |
| *==========================================================================*/ |
| int QCamera3GrallocMemory::getFreeIndexLocked() |
| { |
| int index = -1; |
| |
| if (mBufferCount >= (MM_CAMERA_MAX_NUM_FRAMES - 1)) { |
| LOGE("Number of buffers %d greater than what's supported %d", |
| mBufferCount, MM_CAMERA_MAX_NUM_FRAMES); |
| return index; |
| } |
| |
| for (size_t i = mStartIdx; i < MM_CAMERA_MAX_NUM_FRAMES; i++) { |
| if (0 == mMemInfo[i].handle) { |
| index = i; |
| break; |
| } |
| } |
| |
| return index; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getPtrLocked |
| * |
| * DESCRIPTION: Return buffer pointer. Please note 'mLock' must be acquired |
| * before calling this method. |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : buffer ptr |
| *==========================================================================*/ |
| void *QCamera3GrallocMemory::getPtrLocked(uint32_t index) |
| { |
| if (MM_CAMERA_MAX_NUM_FRAMES <= index) { |
| LOGE("index %d out of bound [0, %d)", |
| index, MM_CAMERA_MAX_NUM_FRAMES); |
| return NULL; |
| } |
| if (index < mStartIdx) { |
| LOGE("buffer index %d less than starting index %d", |
| index, mStartIdx); |
| return NULL; |
| } |
| |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not registered", index); |
| return NULL; |
| } |
| |
| if (mPtr[index] == nullptr) { |
| void *vaddr = NULL; |
| vaddr = mmap(NULL, |
| mMemInfo[index].size, |
| PROT_READ | PROT_WRITE, |
| MAP_SHARED, |
| mMemInfo[index].fd, 0); |
| |
| if (vaddr == MAP_FAILED) { |
| LOGE("mmap failed for buffer index %d, size %d: %s(%d)", |
| index, mMemInfo[index].size, strerror(errno), errno); |
| return NULL; |
| } else { |
| mPtr[index] = vaddr; |
| } |
| } |
| |
| return mPtr[index]; |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getPtr |
| * |
| * DESCRIPTION: Return buffer pointer. |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : buffer ptr |
| *==========================================================================*/ |
| void *QCamera3GrallocMemory::getPtr(uint32_t index) |
| { |
| Mutex::Autolock lock(mLock); |
| return getPtrLocked(index); |
| } |
| |
| /*=========================================================================== |
| * FUNCTION : getBufferHandle |
| * |
| * DESCRIPTION: return framework pointer |
| * |
| * PARAMETERS : |
| * @index : index of the buffer |
| * |
| * RETURN : buffer ptr if match found |
| NULL if failed |
| *==========================================================================*/ |
| void *QCamera3GrallocMemory::getBufferHandle(uint32_t index) |
| { |
| Mutex::Autolock lock(mLock); |
| |
| if (MM_CAMERA_MAX_NUM_FRAMES <= index) { |
| LOGE("index %d out of bound [0, %d)", |
| index, MM_CAMERA_MAX_NUM_FRAMES); |
| return NULL; |
| } |
| if (index < mStartIdx) { |
| LOGE("buffer index %d less than starting index %d", |
| index, mStartIdx); |
| return NULL; |
| } |
| |
| if (0 == mMemInfo[index].handle) { |
| LOGE("Buffer at %d not registered", index); |
| return NULL; |
| } |
| |
| return mBufferHandle[index]; |
| } |
| }; //namespace qcamera |