1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  *
4  * HDF is dual licensed: you can use it either under the terms of
5  * the GPL, or the BSD license, at your option.
6  * See the LICENSE file in the root of this repository for complete details.
7  */
8 
9 #include <securec.h>
10 #include <hdf_log.h>
11 #include <osal_mem.h>
12 #include "osal_uaccess.h"
13 #include "buffer_queue.h"
14 #include "camera_buffer_manager_adapter.h"
15 #include "camera_buffer.h"
16 
17 #define HDF_LOG_TAG HDF_CAMERA_BUFFER
18 
CameraBufferSyncForUser(struct CameraBuffer * buffer)19 void CameraBufferSyncForUser(struct CameraBuffer *buffer)
20 {
21     struct BufferQueue *queue = buffer->bufferQueue;
22 
23     if ((buffer->flags & BUFFER_DEVICE_SYNCED) == 0) {
24         return;
25     }
26 
27     if ((buffer->flags & BUFFER_NEED_USER_SYNC) != 0) {
28         for (uint32_t plane = 0; plane < buffer->numPlanes; ++plane) {
29             if (queue->memOps->syncForUser != NULL) {
30                 queue->memOps->syncForUser(buffer->planes[plane].memPriv);
31             }
32         }
33     }
34     buffer->flags &= ~BUFFER_DEVICE_SYNCED;
35 }
36 
CameraBufferFreeMmapPlanes(struct CameraBuffer * buffer)37 static void CameraBufferFreeMmapPlanes(struct CameraBuffer *buffer)
38 {
39     uint32_t plane;
40     struct BufferQueue *queue = buffer->bufferQueue;
41 
42     for (plane = 0; plane < buffer->numPlanes; ++plane) {
43         if ((queue->memOps->mmapFree != NULL) && (buffer->planes[plane].memPriv != NULL)) {
44             queue->memOps->mmapFree(buffer->planes[plane].memPriv);
45             buffer->planes[plane].memPriv = NULL;
46         }
47     }
48 }
49 
CameraBufferFreeUserPtrPlanes(struct CameraBuffer * buffer)50 static void CameraBufferFreeUserPtrPlanes(struct CameraBuffer *buffer)
51 {
52     uint32_t plane;
53     struct BufferQueue *queue = buffer->bufferQueue;
54 
55     for (plane = 0; plane < buffer->numPlanes; ++plane) {
56         if ((queue->memOps->freeUserPtr != NULL) && (buffer->planes[plane].memPriv != NULL)) {
57             queue->memOps->freeUserPtr(buffer->planes[plane].memPriv);
58             buffer->planes[plane].memPriv = NULL;
59             buffer->planes[plane].memory.userPtr = 0;
60             buffer->planes[plane].length = 0;
61         }
62     }
63 }
64 
CameraBufferFreeDmaPlane(struct CameraBuffer * buffer,struct BufferPlane * plane)65 static void CameraBufferFreeDmaPlane(struct CameraBuffer *buffer, struct BufferPlane *plane)
66 {
67     struct BufferQueue *queue = buffer->bufferQueue;
68 
69     if (plane->dmaMapped != 0) {
70         if (queue->memOps->unmapDmaBuf != NULL) {
71             queue->memOps->unmapDmaBuf(plane->memPriv);
72         }
73     }
74     if (queue->memOps->detachDmaBuf != NULL) {
75         queue->memOps->detachDmaBuf(plane->memPriv);
76     }
77 
78     MemoryAdapterPutDmaBuffer(plane->dmaBuf);
79     plane->memPriv = NULL;
80     plane->dmaBuf = NULL;
81     plane->dmaMapped = 0;
82 }
83 
CameraBufferFreeDmaPlanes(struct CameraBuffer * buffer)84 static void CameraBufferFreeDmaPlanes(struct CameraBuffer *buffer)
85 {
86     uint32_t planeId;
87 
88     for (planeId = 0; planeId < buffer->numPlanes; ++planeId) {
89         CameraBufferFreeDmaPlane(buffer, &buffer->planes[planeId]);
90     }
91 }
92 
CameraBufferFree(struct CameraBuffer * buffer)93 void CameraBufferFree(struct CameraBuffer *buffer)
94 {
95     struct BufferQueue *queue = buffer->bufferQueue;
96     if (queue->memType == MEMTYPE_MMAP) {
97         CameraBufferFreeMmapPlanes(buffer);
98     } else if (queue->memType == MEMTYPE_DMABUF) {
99         CameraBufferFreeDmaPlanes(buffer);
100     } else {
101         CameraBufferFreeUserPtrPlanes(buffer);
102     }
103 }
104 
CameraBufferAllocMmapPlane(struct CameraBuffer * buffer,int32_t planeNum)105 static int32_t CameraBufferAllocMmapPlane(struct CameraBuffer *buffer, int32_t planeNum)
106 {
107     struct BufferQueue *queue = buffer->bufferQueue;
108     void *memPriv = NULL;
109     int32_t ret = HDF_FAILURE;
110     unsigned long size = MemoryAdapterPageAlign(buffer->planes[planeNum].length);
111     if (size < buffer->planes[planeNum].length) {
112         return HDF_FAILURE;
113     }
114 
115     if (queue->memOps->mmapAlloc != NULL) {
116         memPriv = queue->memOps->mmapAlloc(queue, planeNum, size);
117     } else {
118         memPriv = NULL;
119     }
120 
121     if (MemoryAdapterIsErrOrNullPtr(memPriv)) {
122         if (memPriv != NULL) {
123             ret = MemoryAdapterPtrErr(memPriv);
124         }
125         return ret;
126     }
127     buffer->planes[planeNum].memPriv = memPriv;
128     return HDF_SUCCESS;
129 }
130 
CameraBufferAllocMmapPlanes(struct CameraBuffer * buffer)131 int32_t CameraBufferAllocMmapPlanes(struct CameraBuffer *buffer)
132 {
133     struct BufferQueue *queue = buffer->bufferQueue;
134     int32_t planeNum;
135     int32_t ret;
136 
137     for (planeNum = 0; planeNum < buffer->numPlanes; ++planeNum) {
138         ret = CameraBufferAllocMmapPlane(buffer, planeNum);
139         if (ret != HDF_SUCCESS) {
140             goto FREE;
141         }
142     }
143     return HDF_SUCCESS;
144 
145 FREE:
146     for (; planeNum > 0; --planeNum) {
147         if ((queue->memOps->mmapFree != NULL) && (buffer->planes[planeNum - 1].memPriv != NULL)) {
148             queue->memOps->mmapFree(buffer->planes[planeNum - 1].memPriv);
149             buffer->planes[planeNum - 1].memPriv = NULL;
150         }
151     }
152     return ret;
153 }
154 
CameraBufferSetupOffsets(struct CameraBuffer * buffer)155 void CameraBufferSetupOffsets(struct CameraBuffer *buffer)
156 {
157     struct BufferQueue *queue = buffer->bufferQueue;
158     uint32_t planeId;
159     unsigned long off;
160 
161     if (buffer->id != 0) {
162         struct CameraBuffer *prev = queue->buffers[buffer->id - 1];
163         struct BufferPlane *p = &prev->planes[prev->numPlanes - 1];
164         off = MemoryAdapterPageAlign(p->memory.offset + p->length);
165     } else {
166         off = MemoryAdapterPageAlign(buffer->planes[0].memory.offset);
167     }
168 
169     for (planeId = 0; planeId < buffer->numPlanes; ++planeId) {
170         buffer->planes[planeId].memory.offset = off;
171         off += buffer->planes[planeId].length;
172         off = MemoryAdapterPageAlign(off);
173     }
174 }
175 
CameraBufferCheckPlanes(struct CameraBuffer * buffer,const struct UserCameraBuffer * userBuffer)176 int32_t CameraBufferCheckPlanes(struct CameraBuffer *buffer, const struct UserCameraBuffer *userBuffer)
177 {
178     if (userBuffer->planes == NULL) {
179         HDF_LOGE("%s: user buffer's plane is null!", __func__);
180         return HDF_FAILURE;
181     }
182     if (userBuffer->planeCount < buffer->numPlanes || userBuffer->planeCount > MAX_PLANES) {
183         HDF_LOGE("%s: incorrect plane count!", __func__);
184         return HDF_FAILURE;
185     }
186     return HDF_SUCCESS;
187 }
188 
CameraBufferToUserBuffer(struct CameraBuffer * buffer,struct UserCameraBuffer * userBuffer)189 void CameraBufferToUserBuffer(struct CameraBuffer *buffer, struct UserCameraBuffer *userBuffer)
190 {
191     uint32_t plane;
192 
193     userBuffer->id = buffer->id;
194     userBuffer->memType = buffer->memType;
195     userBuffer->field = buffer->field;
196     userBuffer->timeStamp = buffer->timeStamp;
197     userBuffer->sequence = buffer->sequence;
198     userBuffer->planeCount = buffer->numPlanes;
199 
200     for (plane = 0; plane < buffer->numPlanes; ++plane) {
201         struct UserCameraPlane *dst = &userBuffer->planes[plane];
202         struct BufferPlane *src = &buffer->planes[plane];
203         dst->bytesUsed = src->bytesUsed;
204         dst->length = src->length;
205         if (buffer->memType == MEMTYPE_MMAP) {
206             dst->memory.offset = src->memory.offset;
207         } else if (buffer->memType == MEMTYPE_USERPTR) {
208             dst->memory.userPtr = src->memory.userPtr;
209         } else if (buffer->memType == MEMTYPE_DMABUF) {
210             dst->memory.fd = src->memory.fd;
211         }
212         dst->dataOffset = src->dataOffset;
213     }
214 
215     switch (buffer->state) {
216         case BUFFER_STATE_QUEUED:
217         case BUFFER_STATE_ACTIVE:
218             userBuffer->flags |= USER_BUFFER_QUEUED;
219             break;
220         case BUFFER_STATE_ERROR:
221             userBuffer->flags |= USER_BUFFER_ERROR;
222             break;
223         case BUFFER_STATE_DONE:
224             userBuffer->flags |= USER_BUFFER_DONE;
225             break;
226         default:
227             break;
228     }
229 }
230 
CameraBufferEnqueue(struct CameraBuffer * buffer)231 void CameraBufferEnqueue(struct CameraBuffer *buffer)
232 {
233     struct BufferQueue *queue = buffer->bufferQueue;
234 
235     buffer->state = BUFFER_STATE_ACTIVE;
236     OsalAtomicInc(&queue->driverOwnCount);
237     if (queue->queueOps->queueBuffer != NULL) {
238         queue->queueOps->queueBuffer(queue, buffer);
239     }
240     return;
241 }
242 
CameraBufferQueueBuffer(struct CameraBuffer * buffer)243 void CameraBufferQueueBuffer(struct CameraBuffer *buffer)
244 {
245     struct BufferQueue *queue = buffer->bufferQueue;
246 
247     DListInsertTail(&buffer->queueEntry, &queue->queuedList);
248     queue->queuedCount++;
249     queue->flags &= ~QUEUE_STATE_WAITING_BUFFERS;
250     buffer->state = BUFFER_STATE_QUEUED;
251     if ((queue->flags & QUEUE_STATE_STREAMING_CALLED) != 0) {
252         CameraBufferEnqueue(buffer);
253     }
254     return;
255 }
256 
CameraBufferSetCacheSync(struct BufferQueue * queue,struct CameraBuffer * buffer)257 void CameraBufferSetCacheSync(struct BufferQueue *queue, struct CameraBuffer *buffer)
258 {
259     if (queue->memType == MEMTYPE_DMABUF) {
260         buffer->flags &= ~BUFFER_NEED_DEVICE_SYNC;
261         buffer->flags &= ~BUFFER_NEED_USER_SYNC;
262         return;
263     }
264     buffer->flags |= BUFFER_NEED_DEVICE_SYNC;
265     buffer->flags |= BUFFER_NEED_USER_SYNC;
266     return;
267 }
268 
CameraBufferCheckPlaneLength(struct CameraBuffer * buffer,const struct UserCameraBuffer * userBuffer)269 int32_t CameraBufferCheckPlaneLength(struct CameraBuffer *buffer, const struct UserCameraBuffer *userBuffer)
270 {
271     uint32_t length;
272     uint32_t planeId;
273 
274     for (planeId = 0; planeId < buffer->numPlanes; ++planeId) {
275         if (buffer->memType == MEMTYPE_USERPTR || buffer->memType == MEMTYPE_DMABUF) {
276             length = userBuffer->planes[planeId].length;
277         } else {
278             length = buffer->planes[planeId].length;
279         }
280         uint32_t bytesUsed = userBuffer->planes[planeId].bytesUsed != 0 ?
281             userBuffer->planes[planeId].bytesUsed : length;
282         if (bytesUsed > length) {
283             return HDF_ERR_INVALID_PARAM;
284         }
285         if (userBuffer->planes[planeId].dataOffset > 0 && userBuffer->planes[planeId].dataOffset >= bytesUsed) {
286             return HDF_ERR_INVALID_PARAM;
287         }
288     }
289     return HDF_SUCCESS;
290 }
291 
CameraBufferPrepareMmap(struct CameraBuffer * buffer,struct BufferPlane planes[])292 static int32_t CameraBufferPrepareMmap(struct CameraBuffer *buffer, struct BufferPlane planes[])
293 {
294     uint32_t planeNum;
295 
296     for (planeNum = 0; planeNum < buffer->numPlanes; ++planeNum) {
297         buffer->planes[planeNum].bytesUsed = planes[planeNum].bytesUsed;
298         buffer->planes[planeNum].dataOffset = planes[planeNum].dataOffset;
299     }
300     return HDF_SUCCESS;
301 }
302 
CameraBufferPrepareUserPtrPlane(struct CameraBuffer * buffer,uint32_t planeNum,unsigned long userPtr,uint32_t length)303 static int32_t CameraBufferPrepareUserPtrPlane(struct CameraBuffer *buffer,
304     uint32_t planeNum, unsigned long userPtr, uint32_t length)
305 {
306     void *memPriv = NULL;
307     struct BufferQueue *queue = buffer->bufferQueue;
308     if (buffer->planes[planeNum].memPriv != NULL) {
309         if (queue->memOps->freeUserPtr != NULL) {
310             queue->memOps->freeUserPtr(buffer->planes[planeNum].memPriv);
311         } else {
312             HDF_LOGW("%s: no freeUserPtr function!", __func__);
313         }
314     }
315 
316     buffer->planes[planeNum].memPriv = NULL;
317     buffer->planes[planeNum].bytesUsed = 0;
318     buffer->planes[planeNum].length = 0;
319     buffer->planes[planeNum].memory.userPtr = 0;
320     buffer->planes[planeNum].dataOffset = 0;
321     if (queue->memOps->allocUserPtr != NULL) {
322         memPriv = queue->memOps->allocUserPtr(queue, planeNum, userPtr, length);
323     } else {
324         memPriv = NULL;
325     }
326 
327     if (MemoryAdapterIsErrPtr(memPriv)) {
328         int32_t ret = MemoryAdapterPtrErr(memPriv);
329         return ret;
330     }
331     buffer->planes[planeNum].memPriv = memPriv;
332     return HDF_SUCCESS;
333 }
334 
CameraBufferPrepareUserPtr(struct CameraBuffer * buffer,struct BufferPlane planes[])335 static int32_t CameraBufferPrepareUserPtr(struct CameraBuffer *buffer, struct BufferPlane planes[])
336 {
337     uint32_t planeNum;
338     int32_t ret;
339 
340     for (planeNum = 0; planeNum < buffer->numPlanes; ++planeNum) {
341         if ((buffer->planes[planeNum].memory.userPtr != 0) &&
342             (buffer->planes[planeNum].memory.userPtr == planes[planeNum].memory.userPtr) &&
343             (buffer->planes[planeNum].length == planes[planeNum].length)) {
344             continue;
345         }
346         if (planes[planeNum].length < buffer->planes[planeNum].minLength) {
347             goto FREE;
348         }
349         ret = CameraBufferPrepareUserPtrPlane(buffer, planeNum,
350             planes[planeNum].memory.userPtr, planes[planeNum].length);
351         if (ret != HDF_SUCCESS) {
352             goto FREE;
353         }
354     }
355     return HDF_SUCCESS;
356 
357 FREE:
358     CameraBufferFreeUserPtrPlanes(buffer);
359     HDF_LOGE("%s: user ptr mem prepare failed", __func__);
360     return HDF_FAILURE;
361 }
362 
CameraBufferAttachDmaPlane(struct CameraBuffer * buffer,uint32_t planeNum,struct BufferPlane planes[])363 static int32_t CameraBufferAttachDmaPlane(struct CameraBuffer *buffer, uint32_t planeNum, struct BufferPlane planes[])
364 {
365     void *memPriv = NULL;
366     struct BufferQueue *queue = buffer->bufferQueue;
367     void *dmaBuf = MemoryAdapterGetDmaBuffer(planes[planeNum].memory.fd);
368     if (MemoryAdapterIsErrOrNullPtr(dmaBuf)) {
369         HDF_LOGE("%s: dmaBuf ptr error!", __func__);
370         return HDF_FAILURE;
371     }
372     if (planes[planeNum].length == 0) {
373         planes[planeNum].length = MemoryAdapterDmaBufSize(dmaBuf);
374     }
375     if (planes[planeNum].length < buffer->planes[planeNum].minLength) {
376         MemoryAdapterPutDmaBuffer(dmaBuf);
377         HDF_LOGE("%s: not enough dmabuf length!", __func__);
378         return HDF_FAILURE;
379     }
380     if (dmaBuf == buffer->planes[planeNum].dmaBuf && buffer->planes[planeNum].length == planes[planeNum].length) {
381         MemoryAdapterPutDmaBuffer(dmaBuf);
382         return HDF_SUCCESS;
383     }
384     CameraBufferFreeDmaPlane(buffer, &buffer->planes[planeNum]);
385     buffer->planes[planeNum].bytesUsed = 0;
386     buffer->planes[planeNum].length = 0;
387     buffer->planes[planeNum].memory.fd = 0;
388     buffer->planes[planeNum].dataOffset = 0;
389 
390     if (queue->memOps->attachDmaBuf != NULL) {
391         memPriv = queue->memOps->attachDmaBuf(queue, planeNum, dmaBuf, planes[planeNum].length);
392     }
393 
394     if (MemoryAdapterIsErrPtr(memPriv)) {
395         int32_t ret = MemoryAdapterPtrErr(memPriv);
396         MemoryAdapterPutDmaBuffer(dmaBuf);
397         return ret;
398     }
399     buffer->planes[planeNum].dmaBuf = dmaBuf;
400     buffer->planes[planeNum].memPriv = memPriv;
401     return HDF_SUCCESS;
402 }
403 
CameraBufferAttachDmaBuffer(struct CameraBuffer * buffer,struct BufferPlane planes[])404 static int32_t CameraBufferAttachDmaBuffer(struct CameraBuffer *buffer, struct BufferPlane planes[])
405 {
406     uint32_t planeNum;
407 
408     for (planeNum = 0; planeNum < buffer->numPlanes; ++planeNum) {
409         int32_t ret = CameraBufferAttachDmaPlane(buffer, planeNum, planes);
410         if (ret != HDF_SUCCESS) {
411             return ret;
412         }
413     }
414     return HDF_SUCCESS;
415 }
416 
CameraBufferMapDmaBuffer(struct CameraBuffer * buffer,struct BufferPlane planes[])417 static int32_t CameraBufferMapDmaBuffer(struct CameraBuffer *buffer, struct BufferPlane planes[])
418 {
419     int32_t planeNum;
420     int32_t ret;
421     struct BufferQueue *queue = buffer->bufferQueue;
422 
423     for (planeNum = 0; planeNum < buffer->numPlanes; ++planeNum) {
424         if (buffer->planes[planeNum].dmaMapped != 0) {
425             continue;
426         }
427         if (queue->memOps->mapDmaBuf == NULL) {
428             HDF_LOGE("%s: mapDmaBuf function is NULL!", __func__);
429             return HDF_FAILURE;
430         }
431         ret = queue->memOps->mapDmaBuf(buffer->planes[planeNum].memPriv);
432         if (ret != HDF_SUCCESS) {
433             HDF_LOGE("%s: mapDmaBuf failed!", __func__);
434             return ret;
435         }
436         buffer->planes[planeNum].dmaMapped = 1;
437 
438         buffer->planes[planeNum].bytesUsed = planes[planeNum].bytesUsed;
439         buffer->planes[planeNum].length = planes[planeNum].length;
440         buffer->planes[planeNum].memory.fd = planes[planeNum].memory.fd;
441         buffer->planes[planeNum].dataOffset = planes[planeNum].dataOffset;
442     }
443 
444     return HDF_SUCCESS;
445 }
446 
CameraBufferPrepareDma(struct CameraBuffer * buffer,struct BufferPlane planes[])447 static int32_t CameraBufferPrepareDma(struct CameraBuffer *buffer, struct BufferPlane planes[])
448 {
449     int32_t ret;
450 
451     ret = CameraBufferAttachDmaBuffer(buffer, planes);
452     if (ret != HDF_SUCCESS) {
453         HDF_LOGE("%s: dma buffer attach failed", __func__);
454         goto FREE;
455     }
456     ret = CameraBufferMapDmaBuffer(buffer, planes);
457     if (ret != HDF_SUCCESS) {
458         HDF_LOGE("%s: dma buffer map failed", __func__);
459         goto FREE;
460     }
461     return HDF_SUCCESS;
462 
463 FREE:
464     CameraBufferFreeDmaPlanes(buffer);
465     return ret;
466 }
467 
CameraBufferPrepare(struct BufferQueue * queue,struct CameraBuffer * buffer,struct BufferPlane planes[])468 static int32_t CameraBufferPrepare(struct BufferQueue *queue, struct CameraBuffer *buffer, struct BufferPlane planes[])
469 {
470     int32_t ret;
471 
472     switch (queue->memType) {
473         case MEMTYPE_MMAP:
474             ret = CameraBufferPrepareMmap(buffer, planes);
475             break;
476         case MEMTYPE_USERPTR:
477             ret = CameraBufferPrepareUserPtr(buffer, planes);
478             break;
479         case MEMTYPE_DMABUF:
480             ret = CameraBufferPrepareDma(buffer, planes);
481             break;
482         default:
483             HDF_LOGE("%s: invalid queue type, type=%{public}u", __func__, queue->memType);
484             ret = HDF_FAILURE;
485             break;
486     }
487     if (ret != HDF_SUCCESS) {
488         HDF_LOGE("%s: buffer prepare is wrong", __func__);
489         return ret;
490     }
491     return HDF_SUCCESS;
492 }
493 
CameraBufferGetPlanesFromUserBuffer(struct CameraBuffer * buffer,struct BufferPlane * planes,const struct UserCameraBuffer * userBuffer)494 static int32_t CameraBufferGetPlanesFromUserBuffer(struct CameraBuffer *buffer,
495     struct BufferPlane *planes, const struct UserCameraBuffer *userBuffer)
496 {
497     uint32_t planeId;
498 
499     for (planeId = 0; planeId < buffer->numPlanes; ++planeId) {
500         switch (buffer->memType) {
501             case MEMTYPE_USERPTR:
502                 planes[planeId].memory.userPtr = userBuffer->planes[planeId].memory.userPtr;
503                 planes[planeId].length = userBuffer->planes[planeId].length;
504                 break;
505             case MEMTYPE_DMABUF:
506                 planes[planeId].memory.fd = userBuffer->planes[planeId].memory.fd;
507                 planes[planeId].length = userBuffer->planes[planeId].length;
508                 break;
509             default:
510                 break;
511         }
512         planes[planeId].bytesUsed = userBuffer->planes[planeId].bytesUsed;
513         planes[planeId].dataOffset = userBuffer->planes[planeId].dataOffset;
514     }
515 
516     return HDF_SUCCESS;
517 }
518 
CameraBufferSyncForDevice(struct CameraBuffer * buffer)519 static void CameraBufferSyncForDevice(struct CameraBuffer *buffer)
520 {
521     struct BufferQueue *queue = buffer->bufferQueue;
522     if ((buffer->flags & BUFFER_DEVICE_SYNCED) != 0) {
523         return;
524     }
525 
526     if ((buffer->flags & BUFFER_NEED_DEVICE_SYNC) != 0) {
527         for (uint32_t plane = 0; plane < buffer->numPlanes; ++plane) {
528             if (queue->memOps->syncForDevice != NULL) {
529                 queue->memOps->syncForDevice(buffer->planes[plane].memPriv);
530             }
531         }
532     }
533     buffer->flags |= BUFFER_DEVICE_SYNCED;
534 }
535 
CameraBufferFromUserBuffer(struct CameraBuffer * buffer,const struct UserCameraBuffer * userBuffer)536 int32_t CameraBufferFromUserBuffer(struct CameraBuffer *buffer, const struct UserCameraBuffer *userBuffer)
537 {
538     struct BufferPlane planes[MAX_PLANES];
539     struct BufferQueue *queue = buffer->bufferQueue;
540     enum BufferState origState = buffer->state;
541     int32_t ret;
542 
543     if ((queue->flags & QUEUE_STATE_ERROR) != 0) {
544         return HDF_FAILURE;
545     }
546     if ((buffer->flags & BUFFER_PREPARED) != 0) {
547         return HDF_SUCCESS;
548     }
549 
550     buffer->state = BUFFER_STATE_PREPARING;
551     (void)memset_s(planes, sizeof(planes), 0, sizeof(planes));
552     ret = CameraBufferGetPlanesFromUserBuffer(buffer, planes, userBuffer);
553     if (ret != HDF_SUCCESS) {
554         return ret;
555     }
556     ret = CameraBufferPrepare(queue, buffer, planes);
557     if (ret != HDF_SUCCESS) {
558         return ret;
559     }
560     CameraBufferSyncForDevice(buffer);
561     buffer->flags |= BUFFER_PREPARED;
562     buffer->state = origState;
563     return HDF_SUCCESS;
564 }
565