QCamera3Mem.cpp revision 33cb7276f6c4d2eda72253d11cd9242e1f82bf7d 
1/* Copyright (c) 2012-2013, The Linux Foundataion. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 *     * Redistributions of source code must retain the above copyright
7 *       notice, this list of conditions and the following disclaimer.
8 *     * Redistributions in binary form must reproduce the above
9 *       copyright notice, this list of conditions and the following
10 *       disclaimer in the documentation and/or other materials provided
11 *       with the distribution.
12 *     * Neither the name of The Linux Foundation nor the names of its
13 *       contributors may be used to endorse or promote products derived
14 *       from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#define LOG_TAG "QCameraHWI_Mem"
31
32#include <string.h>
33#include <fcntl.h>
34#include <sys/mman.h>
35#include <utils/Log.h>
36#include <utils/Errors.h>
37#include <gralloc_priv.h>
38#include "QCamera3Mem.h"
39
40extern "C" {
41#include <mm_camera_interface.h>
42}
43
44using namespace android;
45
46namespace qcamera {
47
48// QCaemra2Memory base class
49
50/*===========================================================================
51 * FUNCTION   : QCamera3Memory
52 *
53 * DESCRIPTION: default constructor of QCamera3Memory
54 *
55 * PARAMETERS : none
56 *
57 * RETURN     : None
58 *==========================================================================*/
59QCamera3Memory::QCamera3Memory()
60{
61    mBufferCount = 0;
62    for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i++) {
63        mMemInfo[i].fd = 0;
64        mMemInfo[i].main_ion_fd = 0;
65        mMemInfo[i].handle = NULL;
66        mMemInfo[i].size = 0;
67    }
68}
69
70/*===========================================================================
71 * FUNCTION   : ~QCamera3Memory
72 *
73 * DESCRIPTION: deconstructor of QCamera3Memory
74 *
75 * PARAMETERS : none
76 *
77 * RETURN     : None
78 *==========================================================================*/
79QCamera3Memory::~QCamera3Memory()
80{
81}
82
83/*===========================================================================
84 * FUNCTION   : cacheOpsInternal
85 *
86 * DESCRIPTION: ion related memory cache operations
87 *
88 * PARAMETERS :
89 *   @index   : index of the buffer
90 *   @cmd     : cache ops command
91 *   @vaddr   : ptr to the virtual address
92 *
93 * RETURN     : int32_t type of status
94 *              NO_ERROR  -- success
95 *              none-zero failure code
96 *==========================================================================*/
97int QCamera3Memory::cacheOpsInternal(int index, unsigned int cmd, void *vaddr)
98{
99    struct ion_flush_data cache_inv_data;
100    struct ion_custom_data custom_data;
101    int ret = OK;
102
103    if (index >= mBufferCount) {
104        ALOGE("%s: index %d out of bound [0, %d)", __func__, index, mBufferCount);
105        return BAD_INDEX;
106    }
107
108    memset(&cache_inv_data, 0, sizeof(cache_inv_data));
109    memset(&custom_data, 0, sizeof(custom_data));
110    cache_inv_data.vaddr = vaddr;
111    cache_inv_data.fd = mMemInfo[index].fd;
112    cache_inv_data.handle = mMemInfo[index].handle;
113    cache_inv_data.length = mMemInfo[index].size;
114    custom_data.cmd = cmd;
115    custom_data.arg = (unsigned long)&cache_inv_data;
116
117    ALOGV("%s: addr = %p, fd = %d, handle = %p length = %d, ION Fd = %d",
118         __func__, cache_inv_data.vaddr, cache_inv_data.fd,
119         cache_inv_data.handle, cache_inv_data.length,
120         mMemInfo[index].main_ion_fd);
121    ret = ioctl(mMemInfo[index].main_ion_fd, ION_IOC_CUSTOM, &custom_data);
122    if (ret < 0)
123        ALOGE("%s: Cache Invalidate failed: %s\n", __func__, strerror(errno));
124
125    return ret;
126}
127
128/*===========================================================================
129 * FUNCTION   : getFd
130 *
131 * DESCRIPTION: return file descriptor of the indexed buffer
132 *
133 * PARAMETERS :
134 *   @index   : index of the buffer
135 *
136 * RETURN     : file descriptor
137 *==========================================================================*/
138int QCamera3Memory::getFd(int index) const
139{
140    if (index >= mBufferCount)
141        return BAD_INDEX;
142
143    return mMemInfo[index].fd;
144}
145
146/*===========================================================================
147 * FUNCTION   : getSize
148 *
149 * DESCRIPTION: return buffer size of the indexed buffer
150 *
151 * PARAMETERS :
152 *   @index   : index of the buffer
153 *
154 * RETURN     : buffer size
155 *==========================================================================*/
156int QCamera3Memory::getSize(int index) const
157{
158    if (index >= mBufferCount)
159        return BAD_INDEX;
160
161    return (int)mMemInfo[index].size;
162}
163
164/*===========================================================================
165 * FUNCTION   : getCnt
166 *
167 * DESCRIPTION: query number of buffers allocated
168 *
169 * PARAMETERS : none
170 *
171 * RETURN     : number of buffers allocated
172 *==========================================================================*/
173int QCamera3Memory::getCnt() const
174{
175    return mBufferCount;
176}
177
178/*===========================================================================
179 * FUNCTION   : getBufDef
180 *
181 * DESCRIPTION: query detailed buffer information
182 *
183 * PARAMETERS :
184 *   @offset  : [input] frame buffer offset
185 *   @bufDef  : [output] reference to struct to store buffer definition
186 *   @index   : [input] index of the buffer
187 *
188 * RETURN     : none
189 *==========================================================================*/
190void QCamera3Memory::getBufDef(const cam_frame_len_offset_t &offset,
191        mm_camera_buf_def_t &bufDef, int index) const
192{
193    if (!mBufferCount) {
194        ALOGE("Memory not allocated");
195        return;
196    }
197    bufDef.fd = mMemInfo[index].fd;
198    bufDef.frame_len = mMemInfo[index].size;
199    bufDef.mem_info = (void *)this;
200    bufDef.num_planes = offset.num_planes;
201    bufDef.buffer = getPtr(index);
202    bufDef.buf_idx = index;
203
204    /* Plane 0 needs to be set separately. Set other planes in a loop */
205    bufDef.planes[0].length = offset.mp[0].len;
206    bufDef.planes[0].m.userptr = mMemInfo[index].fd;
207    bufDef.planes[0].data_offset = offset.mp[0].offset;
208    bufDef.planes[0].reserved[0] = 0;
209    for (int i = 1; i < bufDef.num_planes; i++) {
210         bufDef.planes[i].length = offset.mp[i].len;
211         bufDef.planes[i].m.userptr = mMemInfo[i].fd;
212         bufDef.planes[i].data_offset = offset.mp[i].offset;
213         bufDef.planes[i].reserved[0] =
214                 bufDef.planes[i-1].reserved[0] +
215                 bufDef.planes[i-1].length;
216    }
217}
218
219/*===========================================================================
220 * FUNCTION   : QCamera3HeapMemory
221 *
222 * DESCRIPTION: constructor of QCamera3HeapMemory for ion memory used internally in HAL
223 *
224 * PARAMETERS : none
225 *
226 * RETURN     : none
227 *==========================================================================*/
228QCamera3HeapMemory::QCamera3HeapMemory()
229    : QCamera3Memory()
230{
231    for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i ++)
232        mPtr[i] = NULL;
233}
234
235/*===========================================================================
236 * FUNCTION   : ~QCamera3HeapMemory
237 *
238 * DESCRIPTION: deconstructor of QCamera3HeapMemory
239 *
240 * PARAMETERS : none
241 *
242 * RETURN     : none
243 *==========================================================================*/
244QCamera3HeapMemory::~QCamera3HeapMemory()
245{
246}
247
248/*===========================================================================
249 * FUNCTION   : alloc
250 *
251 * DESCRIPTION: allocate requested number of buffers of certain size
252 *
253 * PARAMETERS :
254 *   @count   : number of buffers to be allocated
255 *   @size    : lenght of the buffer to be allocated
256 *   @heap_id : heap id to indicate where the buffers will be allocated from
257 *
258 * RETURN     : int32_t type of status
259 *              NO_ERROR  -- success
260 *              none-zero failure code
261 *==========================================================================*/
262int QCamera3HeapMemory::alloc(int count, int size, int heap_id)
263{
264    int rc = OK;
265    if (count > MM_CAMERA_MAX_NUM_FRAMES) {
266        ALOGE("Buffer count %d out of bound. Max is %d", count, MM_CAMERA_MAX_NUM_FRAMES);
267        return BAD_INDEX;
268    }
269    if (mBufferCount) {
270        ALOGE("Allocating a already allocated heap memory");
271        return INVALID_OPERATION;
272    }
273
274    for (int i = 0; i < count; i ++) {
275        rc = allocOneBuffer(mMemInfo[i], heap_id, size);
276        if (rc < 0) {
277            ALOGE("AllocateIonMemory failed");
278            for (int j = i-1; j >= 0; j--)
279                deallocOneBuffer(mMemInfo[j]);
280            break;
281        }
282    }
283    return rc;
284}
285
286/*===========================================================================
287 * FUNCTION   : dealloc
288 *
289 * DESCRIPTION: deallocate buffers
290 *
291 * PARAMETERS : none
292 *
293 * RETURN     : none
294 *==========================================================================*/
295void QCamera3HeapMemory::dealloc()
296{
297    for (int i = 0; i < mBufferCount; i++)
298        deallocOneBuffer(mMemInfo[i]);
299}
300
301/*===========================================================================
302 * FUNCTION   : allocOneBuffer
303 *
304 * DESCRIPTION: impl of allocating one buffers of certain size
305 *
306 * PARAMETERS :
307 *   @memInfo : [output] reference to struct to store additional memory allocation info
308 *   @heap    : [input] heap id to indicate where the buffers will be allocated from
309 *   @size    : [input] lenght of the buffer to be allocated
310 *
311 * RETURN     : int32_t type of status
312 *              NO_ERROR  -- success
313 *              none-zero failure code
314 *==========================================================================*/
315int QCamera3HeapMemory::allocOneBuffer(QCamera3MemInfo &memInfo, int heap_id, int size)
316{
317    int rc = OK;
318    struct ion_handle_data handle_data;
319    struct ion_allocation_data alloc;
320    struct ion_fd_data ion_info_fd;
321    int main_ion_fd = 0;
322
323    main_ion_fd = open("/dev/ion", O_RDONLY);
324    if (main_ion_fd <= 0) {
325        ALOGE("Ion dev open failed: %s\n", strerror(errno));
326        goto ION_OPEN_FAILED;
327    }
328
329    memset(&alloc, 0, sizeof(alloc));
330    alloc.len = size;
331    /* to make it page size aligned */
332    alloc.len = (alloc.len + 4095) & (~4095);
333    alloc.align = 4096;
334    alloc.flags = ION_FLAG_CACHED;
335    alloc.heap_mask = heap_id;
336    rc = ioctl(main_ion_fd, ION_IOC_ALLOC, &alloc);
337    if (rc < 0) {
338        ALOGE("ION allocation for len %d failed: %s\n", alloc.len,
339            strerror(errno));
340        goto ION_ALLOC_FAILED;
341    }
342
343    memset(&ion_info_fd, 0, sizeof(ion_info_fd));
344    ion_info_fd.handle = alloc.handle;
345    rc = ioctl(main_ion_fd, ION_IOC_SHARE, &ion_info_fd);
346    if (rc < 0) {
347        ALOGE("ION map failed %s\n", strerror(errno));
348        goto ION_MAP_FAILED;
349    }
350
351    memInfo.main_ion_fd = main_ion_fd;
352    memInfo.fd = ion_info_fd.fd;
353    memInfo.handle = ion_info_fd.handle;
354    memInfo.size = alloc.len;
355    return OK;
356
357ION_MAP_FAILED:
358    memset(&handle_data, 0, sizeof(handle_data));
359    handle_data.handle = ion_info_fd.handle;
360    ioctl(main_ion_fd, ION_IOC_FREE, &handle_data);
361ION_ALLOC_FAILED:
362    close(main_ion_fd);
363ION_OPEN_FAILED:
364    return NO_MEMORY;
365}
366
367/*===========================================================================
368 * FUNCTION   : deallocOneBuffer
369 *
370 * DESCRIPTION: impl of deallocating one buffers
371 *
372 * PARAMETERS :
373 *   @memInfo : reference to struct that stores additional memory allocation info
374 *
375 * RETURN     : none
376 *==========================================================================*/
377void QCamera3HeapMemory::deallocOneBuffer(QCamera3MemInfo &memInfo)
378{
379    struct ion_handle_data handle_data;
380
381    if (memInfo.fd > 0) {
382        close(memInfo.fd);
383        memInfo.fd = 0;
384    }
385
386    if (memInfo.main_ion_fd > 0) {
387        memset(&handle_data, 0, sizeof(handle_data));
388        handle_data.handle = memInfo.handle;
389        ioctl(memInfo.main_ion_fd, ION_IOC_FREE, &handle_data);
390        close(memInfo.main_ion_fd);
391        memInfo.main_ion_fd = 0;
392    }
393    memInfo.handle = NULL;
394    memInfo.size = 0;
395}
396
397/*===========================================================================
398 * FUNCTION   : getPtr
399 *
400 * DESCRIPTION: return buffer pointer
401 *
402 * PARAMETERS :
403 *   @index   : index of the buffer
404 *
405 * RETURN     : buffer ptr
406 *==========================================================================*/
407void *QCamera3HeapMemory::getPtr(int index) const
408{
409    if (index >= mBufferCount) {
410        ALOGE("index out of bound");
411        return (void *)BAD_INDEX;
412    }
413    return mPtr[index];
414}
415
416/*===========================================================================
417 * FUNCTION   : allocate
418 *
419 * DESCRIPTION: allocate requested number of buffers of certain size
420 *
421 * PARAMETERS :
422 *   @count   : number of buffers to be allocated
423 *   @size    : lenght of the buffer to be allocated
424 *   @queueAll: whether to queue all allocated buffers at the beginning
425 *
426 * RETURN     : int32_t type of status
427 *              NO_ERROR  -- success
428 *              none-zero failure code
429 *==========================================================================*/
430int QCamera3HeapMemory::allocate(int count, int size, bool queueAll)
431{
432    int heap_mask = 0x1 << ION_IOMMU_HEAP_ID;
433    int rc = alloc(count, size, heap_mask);
434    if (rc < 0)
435        return rc;
436
437    for (int i = 0; i < count; i ++) {
438        void *vaddr = mmap(NULL,
439                    mMemInfo[i].size,
440                    PROT_READ | PROT_WRITE,
441                    MAP_SHARED,
442                    mMemInfo[i].fd, 0);
443        if (vaddr == MAP_FAILED) {
444            for (int j = i-1; j >= 0; j --) {
445                munmap(mPtr[i], mMemInfo[i].size);
446                rc = NO_MEMORY;
447                break;
448            }
449        } else
450            mPtr[i] = vaddr;
451    }
452    if (rc == 0)
453        mBufferCount = count;
454
455    mQueueAll = queueAll;
456    return OK;
457}
458
459/*===========================================================================
460 * FUNCTION   : deallocate
461 *
462 * DESCRIPTION: deallocate buffers
463 *
464 * PARAMETERS : none
465 *
466 * RETURN     : none
467 *==========================================================================*/
468void QCamera3HeapMemory::deallocate()
469{
470    for (int i = 0; i < mBufferCount; i++) {
471        munmap(mPtr[i], mMemInfo[i].size);
472        mPtr[i] = NULL;
473    }
474    dealloc();
475    mBufferCount = 0;
476}
477
478/*===========================================================================
479 * FUNCTION   : cacheOps
480 *
481 * DESCRIPTION: ion related memory cache operations
482 *
483 * PARAMETERS :
484 *   @index   : index of the buffer
485 *   @cmd     : cache ops command
486 *
487 * RETURN     : int32_t type of status
488 *              NO_ERROR  -- success
489 *              none-zero failure code
490 *==========================================================================*/
491int QCamera3HeapMemory::cacheOps(int index, unsigned int cmd)
492{
493    if (index >= mBufferCount)
494        return BAD_INDEX;
495    return cacheOpsInternal(index, cmd, mPtr[index]);
496}
497
498/*===========================================================================
499 * FUNCTION   : getRegFlags
500 *
501 * DESCRIPTION: query initial reg flags
502 *
503 * PARAMETERS :
504 *   @regFlags: initial reg flags of the allocated buffers
505 *
506 * RETURN     : int32_t type of status
507 *              NO_ERROR  -- success
508 *              none-zero failure code
509 *==========================================================================*/
510int QCamera3HeapMemory::getRegFlags(uint8_t * regFlags) const
511{
512    int i;
513    for (i = 0; i < mBufferCount; i ++)
514        regFlags[i] = (mQueueAll ? 1 : 0);
515    return NO_ERROR;
516}
517
518/*===========================================================================
519 * FUNCTION   : getMatchBufIndex
520 *
521 * DESCRIPTION: query buffer index by object ptr
522 *
523 * PARAMETERS :
524 *   @object  : object ptr
525 *
526 * RETURN     : buffer index if match found,
527 *              -1 if failed
528 *==========================================================================*/
529int QCamera3HeapMemory::getMatchBufIndex(void * /*object*/)
530{
531
532/*
533    TODO for HEAP memory type, would there be an equivalent requirement?
534
535    int index = -1;
536    buffer_handle_t *key = (buffer_handle_t*) object;
537    if (!key) {
538        return BAD_VALUE;
539    }
540    for (int i = 0; i < mBufferCount; i++) {
541        if (mBufferHandle[i] == key) {
542            index = i;
543            break;
544        }
545    }
546    return index;
547*/
548    ALOGE("%s: FATAL: Not supposed to come here", __func__);
549    return -1;
550}
551
552/*===========================================================================
553 * FUNCTION   : QCamera3GrallocMemory
554 *
555 * DESCRIPTION: constructor of QCamera3GrallocMemory
556 *              preview stream buffers are allocated from gralloc native_windoe
557 *
558 * PARAMETERS :
559 *   @getMemory : camera memory request ops table
560 *
561 * RETURN     : none
562 *==========================================================================*/
563QCamera3GrallocMemory::QCamera3GrallocMemory()
564        : QCamera3Memory()
565{
566    for (int i = 0; i < MM_CAMERA_MAX_NUM_FRAMES; i ++) {
567        mBufferHandle[i] = NULL;
568        mPrivateHandle[i] = NULL;
569        mCurrentFrameNumbers[i] = -1;
570    }
571}
572
573/*===========================================================================
574 * FUNCTION   : ~QCamera3GrallocMemory
575 *
576 * DESCRIPTION: deconstructor of QCamera3GrallocMemory
577 *
578 * PARAMETERS : none
579 *
580 * RETURN     : none
581 *==========================================================================*/
582QCamera3GrallocMemory::~QCamera3GrallocMemory()
583{
584}
585
586/*===========================================================================
587 * FUNCTION   : registerBuffers
588 *
589 * DESCRIPTION: register frameworks-allocated gralloc buffer_handle_t
590 *
591 * PARAMETERS :
592 *   @num_buffer : number of buffers to be registered
593 *   @buffers    : array of buffer_handle_t pointers
594 *
595 * RETURN     : int32_t type of status
596 *              NO_ERROR  -- success
597 *              none-zero failure code
598 *==========================================================================*/
599int QCamera3GrallocMemory::registerBuffers(uint32_t num_buffers, buffer_handle_t **buffers)
600{
601    status_t ret = NO_ERROR;
602    struct ion_fd_data ion_info_fd;
603    memset(&ion_info_fd, 0, sizeof(ion_info_fd));
604
605    ALOGI(" %s : E ", __FUNCTION__);
606
607    if (num_buffers > MM_CAMERA_MAX_NUM_FRAMES) {
608        ALOGE("%s: Number of buffers %d greater than what's supported %d",
609            __func__, num_buffers, MM_CAMERA_MAX_NUM_FRAMES);
610        return -EINVAL;
611    }
612
613    for (size_t cnt = 0; cnt < num_buffers; cnt++) {
614        if (buffers[cnt] == NULL) {
615            ALOGE("%s: Invalid buffers[%d].", __func__, cnt);
616            return -EINVAL;
617        }
618        mBufferHandle[cnt] = buffers[cnt];
619        mPrivateHandle[cnt] =
620            (struct private_handle_t *)(*mBufferHandle[cnt]);
621        mMemInfo[cnt].main_ion_fd = open("/dev/ion", O_RDONLY);
622        if (mMemInfo[cnt].main_ion_fd < 0) {
623            ALOGE("%s: failed: could not open ion device", __func__);
624            for(size_t i = 0; i < cnt; i++) {
625                struct ion_handle_data ion_handle;
626                memset(&ion_handle, 0, sizeof(ion_handle));
627                ion_handle.handle = mMemInfo[i].handle;
628                if (ioctl(mMemInfo[i].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) {
629                    ALOGE("%s: ion free failed", __func__);
630                }
631                close(mMemInfo[i].main_ion_fd);
632                ALOGD("%s: cancel_buffer: hdl =%p", __func__, (*mBufferHandle[i]));
633                mBufferHandle[i] = NULL;
634            }
635            memset(&mMemInfo, 0, sizeof(mMemInfo));
636            ret = -ENOMEM;
637            goto end;
638        } else {
639            ion_info_fd.fd = mPrivateHandle[cnt]->fd;
640            if (ioctl(mMemInfo[cnt].main_ion_fd,
641                      ION_IOC_IMPORT, &ion_info_fd) < 0) {
642                ALOGE("%s: ION import failed\n", __func__);
643                for(size_t i = 0; i < cnt; i++) {
644                    struct ion_handle_data ion_handle;
645                    memset(&ion_handle, 0, sizeof(ion_handle));
646                    ion_handle.handle = mMemInfo[i].handle;
647                    if (ioctl(mMemInfo[i].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) {
648                        ALOGE("ion free failed");
649                    }
650                    close(mMemInfo[i].main_ion_fd);
651                    mBufferHandle[i] = NULL;
652                }
653                close(mMemInfo[cnt].main_ion_fd);
654                memset(&mMemInfo, 0, sizeof(mMemInfo));
655                ret = -ENOMEM;
656                goto end;
657            }
658        }
659        ALOGD("%s: idx = %d, fd = %d, size = %d, offset = %d",
660              __func__, cnt, mPrivateHandle[cnt]->fd,
661              mPrivateHandle[cnt]->size,
662              mPrivateHandle[cnt]->offset);
663        mMemInfo[cnt].fd =
664            mPrivateHandle[cnt]->fd;
665        mMemInfo[cnt].size =
666            mPrivateHandle[cnt]->size;
667        mMemInfo[cnt].handle = ion_info_fd.handle;
668
669        void *vaddr = mmap(NULL,
670                    mMemInfo[cnt].size,
671                    PROT_READ | PROT_WRITE,
672                    MAP_SHARED,
673                    mMemInfo[cnt].fd, 0);
674        if (vaddr == MAP_FAILED) {
675            for (int j = cnt-1; j >= 0; j --) {
676                munmap(mPtr[cnt], mMemInfo[cnt].size);
677                ret = -ENOMEM;
678                break;
679            }
680        } else
681            mPtr[cnt] = vaddr;
682    }
683    mBufferCount = num_buffers;
684
685end:
686    ALOGI(" %s : X ",__func__);
687    return ret;
688}
689
690/*===========================================================================
691 * FUNCTION   : unregisterBuffers
692 *
693 * DESCRIPTION: unregister buffers
694 *
695 * PARAMETERS : none
696 *
697 * RETURN     : none
698 *==========================================================================*/
699void QCamera3GrallocMemory::unregisterBuffers()
700{
701    ALOGI("%s: E ", __FUNCTION__);
702
703    for (int cnt = 0; cnt < mBufferCount; cnt++) {
704        munmap(mPtr[cnt], mMemInfo[cnt].size);
705        mPtr[cnt] = NULL;
706
707        struct ion_handle_data ion_handle;
708        memset(&ion_handle, 0, sizeof(ion_handle));
709        ion_handle.handle = mMemInfo[cnt].handle;
710        if (ioctl(mMemInfo[cnt].main_ion_fd, ION_IOC_FREE, &ion_handle) < 0) {
711            ALOGE("ion free failed");
712        }
713        close(mMemInfo[cnt].main_ion_fd);
714        ALOGD("put buffer %d successfully", cnt);
715    }
716    mBufferCount = 0;
717    ALOGI(" %s : X ",__FUNCTION__);
718}
719
720/*===========================================================================
721 * FUNCTION   : markFrameNumber
722 *
723 * DESCRIPTION: We use this function from the request call path to mark the
724 *              buffers with the frame number they are intended for this info
725 *              is used later when giving out callback & it is duty of PP to
726 *              ensure that data for that particular frameNumber/Request is
727 *              written to this buffer.
728 * PARAMETERS :
729 *   @index   : index of the buffer
730 *   @frame#  : Frame number from the framework
731 *
732 * RETURN     : int32_t type of status
733 *              NO_ERROR  -- success
734 *              none-zero failure code
735 *==========================================================================*/
736int32_t QCamera3GrallocMemory::markFrameNumber(int index, uint32_t frameNumber)
737{
738    if(index >= mBufferCount || index >= MM_CAMERA_MAX_NUM_FRAMES) {
739        ALOGE("%s: Index out of bounds",__func__);
740        return BAD_INDEX;
741    }
742    mCurrentFrameNumbers[index] = frameNumber;
743    return NO_ERROR;
744}
745
746/*===========================================================================
747 * FUNCTION   : getFrameNumber
748 *
749 * DESCRIPTION: We use this to fetch the frameNumber for the request with which
750 *              this buffer was given to HAL
751 *
752 *
753 * PARAMETERS :
754 *   @index   : index of the buffer
755 *
756 * RETURN     : int32_t frameNumber
757 *              postive/zero  -- success
758 *              negetive failure
759 *==========================================================================*/
760int32_t QCamera3GrallocMemory::getFrameNumber(int index)
761{
762    if(index >= mBufferCount || index >= MM_CAMERA_MAX_NUM_FRAMES) {
763        ALOGE("%s: Index out of bounds",__func__);
764        return -1;
765    }
766
767    return mCurrentFrameNumbers[index];
768}
769
770/*===========================================================================
771 * FUNCTION   : cacheOps
772 *
773 * DESCRIPTION: ion related memory cache operations
774 *
775 * PARAMETERS :
776 *   @index   : index of the buffer
777 *   @cmd     : cache ops command
778 *
779 * RETURN     : int32_t type of status
780 *              NO_ERROR  -- success
781 *              none-zero failure code
782 *==========================================================================*/
783int QCamera3GrallocMemory::cacheOps(int index, unsigned int cmd)
784{
785    if (index >= mBufferCount)
786        return BAD_INDEX;
787    return cacheOpsInternal(index, cmd, mPtr[index]);
788}
789
790/*===========================================================================
791 * FUNCTION   : getRegFlags
792 *
793 * DESCRIPTION: query initial reg flags
794 *
795 * PARAMETERS :
796 *   @regFlags: initial reg flags of the allocated buffers
797 *
798 * RETURN     : int32_t type of status
799 *              NO_ERROR  -- success
800 *              none-zero failure code
801 *==========================================================================*/
802int QCamera3GrallocMemory::getRegFlags(uint8_t *regFlags) const
803{
804    int i;
805    for (i = 0; i < mBufferCount; i ++)
806        regFlags[i] = 0;
807    return NO_ERROR;
808}
809
810/*===========================================================================
811 * FUNCTION   : getMatchBufIndex
812 *
813 * DESCRIPTION: query buffer index by object ptr
814 *
815 * PARAMETERS :
816 *   @opaque  : opaque ptr
817 *
818 * RETURN     : buffer index if match found,
819 *              -1 if failed
820 *==========================================================================*/
821int QCamera3GrallocMemory::getMatchBufIndex(void *object)
822{
823    int index = -1;
824    buffer_handle_t *key = (buffer_handle_t*) object;
825    if (!key) {
826        return BAD_VALUE;
827    }
828    for (int i = 0; i < mBufferCount; i++) {
829        if (mBufferHandle[i] == key) {
830            index = i;
831            break;
832        }
833    }
834    return index;
835}
836
837/*===========================================================================
838 * FUNCTION   : getPtr
839 *
840 * DESCRIPTION: return buffer pointer
841 *
842 * PARAMETERS :
843 *   @index   : index of the buffer
844 *
845 * RETURN     : buffer ptr
846 *==========================================================================*/
847void *QCamera3GrallocMemory::getPtr(int index) const
848{
849    if (index >= mBufferCount) {
850        ALOGE("index out of bound");
851        return (void *)BAD_INDEX;
852    }
853    return mPtr[index];
854}
855
856}; //namespace qcamera
857