1 /* Copyright (c) 2012-2016, The Linux Foundation. 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 // To remove
31 #include <cutils/properties.h>
32
33 // System dependencies
34 #include <pthread.h>
35 #include <errno.h>
36 #include <fcntl.h>
37 #include <stdlib.h>
38 #include <linux/media.h>
39 #include <media/msm_cam_sensor.h>
40 #include <dlfcn.h>
41 #include <unistd.h> // for close()
42
43 #define IOCTL_H <SYSTEM_HEADER_PREFIX/ioctl.h>
44 #include IOCTL_H
45
46 // Camera dependencies
47 #include "mm_camera_dbg.h"
48 #include "mm_camera_interface.h"
49 #include "mm_camera.h"
50
51 static pthread_mutex_t g_intf_lock = PTHREAD_MUTEX_INITIALIZER;
52
53 static mm_camera_ctrl_t g_cam_ctrl;
54
55 static pthread_mutex_t g_handler_lock = PTHREAD_MUTEX_INITIALIZER;
56 static uint16_t g_handler_history_count = 0; /* history count for handler */
57
58 #define CAM_SENSOR_TYPE_MASK (1U<<24) // 24th (starting from 0) bit tells its a MAIN or AUX camera
59 #define CAM_SENSOR_FORMAT_MASK (1U<<25) // 25th(starting from 0) bit tells its YUV sensor or not
60
61 /*===========================================================================
62 * FUNCTION : mm_camera_util_generate_handler
63 *
64 * DESCRIPTION: utility function to generate handler for camera/channel/stream
65 *
66 * PARAMETERS :
67 * @index: index of the object to have handler
68 *
69 * RETURN : uint32_t type of handle that uniquely identify the object
70 *==========================================================================*/
mm_camera_util_generate_handler(uint8_t index)71 uint32_t mm_camera_util_generate_handler(uint8_t index)
72 {
73 uint32_t handler = 0;
74 pthread_mutex_lock(&g_handler_lock);
75 g_handler_history_count++;
76 if (0 == g_handler_history_count) {
77 g_handler_history_count++;
78 }
79 handler = g_handler_history_count;
80 handler = (handler<<8) | index;
81 pthread_mutex_unlock(&g_handler_lock);
82 return handler;
83 }
84
85 /*===========================================================================
86 * FUNCTION : mm_camera_util_get_index_by_handler
87 *
88 * DESCRIPTION: utility function to get index from handle
89 *
90 * PARAMETERS :
91 * @handler: object handle
92 *
93 * RETURN : uint8_t type of index derived from handle
94 *==========================================================================*/
mm_camera_util_get_index_by_handler(uint32_t handler)95 uint8_t mm_camera_util_get_index_by_handler(uint32_t handler)
96 {
97 return (handler&0x000000ff);
98 }
99
100 /*===========================================================================
101 * FUNCTION : mm_camera_util_get_dev_name
102 *
103 * DESCRIPTION: utility function to get device name from camera handle
104 *
105 * PARAMETERS :
106 * @cam_handle: camera handle
107 *
108 * RETURN : char ptr to the device name stored in global variable
109 * NOTE : caller should not free the char ptr
110 *==========================================================================*/
mm_camera_util_get_dev_name(uint32_t cam_handle)111 const char *mm_camera_util_get_dev_name(uint32_t cam_handle)
112 {
113 char *dev_name = NULL;
114 uint8_t cam_idx = mm_camera_util_get_index_by_handler(cam_handle);
115 if(cam_idx < MM_CAMERA_MAX_NUM_SENSORS) {
116 dev_name = g_cam_ctrl.video_dev_name[cam_idx];
117 }
118 return dev_name;
119 }
120
121 /*===========================================================================
122 * FUNCTION : mm_camera_util_get_camera_by_handler
123 *
124 * DESCRIPTION: utility function to get camera object from camera handle
125 *
126 * PARAMETERS :
127 * @cam_handle: camera handle
128 *
129 * RETURN : ptr to the camera object stored in global variable
130 * NOTE : caller should not free the camera object ptr
131 *==========================================================================*/
mm_camera_util_get_camera_by_handler(uint32_t cam_handle)132 mm_camera_obj_t* mm_camera_util_get_camera_by_handler(uint32_t cam_handle)
133 {
134 mm_camera_obj_t *cam_obj = NULL;
135 uint8_t cam_idx = mm_camera_util_get_index_by_handler(cam_handle);
136
137 if (cam_idx < MM_CAMERA_MAX_NUM_SENSORS &&
138 (NULL != g_cam_ctrl.cam_obj[cam_idx]) &&
139 (cam_handle == g_cam_ctrl.cam_obj[cam_idx]->my_hdl)) {
140 cam_obj = g_cam_ctrl.cam_obj[cam_idx];
141 }
142 return cam_obj;
143 }
144
145 /*===========================================================================
146 * FUNCTION : mm_camera_util_get_camera_by_session_id
147 *
148 * DESCRIPTION: utility function to get camera object from camera sessionID
149 *
150 * PARAMETERS :
151 * @session_id: sessionid for which cam obj mapped
152 *
153 * RETURN : ptr to the camera object stored in global variable
154 * NOTE : caller should not free the camera object ptr
155 *==========================================================================*/
mm_camera_util_get_camera_by_session_id(uint32_t session_id)156 mm_camera_obj_t* mm_camera_util_get_camera_by_session_id(uint32_t session_id)
157 {
158 int cam_idx = 0;
159 mm_camera_obj_t *cam_obj = NULL;
160 for (cam_idx = 0; cam_idx < MM_CAMERA_MAX_NUM_SENSORS; cam_idx++) {
161 if ((NULL != g_cam_ctrl.cam_obj[cam_idx]) &&
162 (session_id == (uint32_t)g_cam_ctrl.cam_obj[cam_idx]->sessionid)) {
163 LOGD("session id:%d match idx:%d\n", session_id, cam_idx);
164 cam_obj = g_cam_ctrl.cam_obj[cam_idx];
165 }
166 }
167 return cam_obj;
168 }
169
170 /*===========================================================================
171 * FUNCTION : mm_camera_intf_query_capability
172 *
173 * DESCRIPTION: query camera capability
174 *
175 * PARAMETERS :
176 * @camera_handle: camera handle
177 *
178 * RETURN : int32_t type of status
179 * 0 -- success
180 * -1 -- failure
181 *==========================================================================*/
mm_camera_intf_query_capability(uint32_t camera_handle)182 static int32_t mm_camera_intf_query_capability(uint32_t camera_handle)
183 {
184 int32_t rc = -1;
185 mm_camera_obj_t * my_obj = NULL;
186
187 LOGD("E: camera_handler = %d ", camera_handle);
188
189 pthread_mutex_lock(&g_intf_lock);
190 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
191
192 if(my_obj) {
193 pthread_mutex_lock(&my_obj->cam_lock);
194 pthread_mutex_unlock(&g_intf_lock);
195 rc = mm_camera_query_capability(my_obj);
196 } else {
197 pthread_mutex_unlock(&g_intf_lock);
198 }
199 LOGD("X rc = %d", rc);
200 return rc;
201 }
202
203 /*===========================================================================
204 * FUNCTION : mm_camera_intf_set_parms
205 *
206 * DESCRIPTION: set parameters per camera
207 *
208 * PARAMETERS :
209 * @camera_handle: camera handle
210 * @parms : ptr to a param struct to be set to server
211 *
212 * RETURN : int32_t type of status
213 * 0 -- success
214 * -1 -- failure
215 * NOTE : Assume the parms struct buf is already mapped to server via
216 * domain socket. Corresponding fields of parameters to be set
217 * are already filled in by upper layer caller.
218 *==========================================================================*/
mm_camera_intf_set_parms(uint32_t camera_handle,parm_buffer_t * parms)219 static int32_t mm_camera_intf_set_parms(uint32_t camera_handle,
220 parm_buffer_t *parms)
221 {
222 int32_t rc = -1;
223 mm_camera_obj_t * my_obj = NULL;
224
225 pthread_mutex_lock(&g_intf_lock);
226 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
227
228 if(my_obj) {
229 pthread_mutex_lock(&my_obj->cam_lock);
230 pthread_mutex_unlock(&g_intf_lock);
231 rc = mm_camera_set_parms(my_obj, parms);
232 } else {
233 pthread_mutex_unlock(&g_intf_lock);
234 }
235 return rc;
236 }
237
238 /*===========================================================================
239 * FUNCTION : mm_camera_intf_get_parms
240 *
241 * DESCRIPTION: get parameters per camera
242 *
243 * PARAMETERS :
244 * @camera_handle: camera handle
245 * @parms : ptr to a param struct to be get from server
246 *
247 * RETURN : int32_t type of status
248 * 0 -- success
249 * -1 -- failure
250 * NOTE : Assume the parms struct buf is already mapped to server via
251 * domain socket. Parameters to be get from server are already
252 * filled in by upper layer caller. After this call, corresponding
253 * fields of requested parameters will be filled in by server with
254 * detailed information.
255 *==========================================================================*/
mm_camera_intf_get_parms(uint32_t camera_handle,parm_buffer_t * parms)256 static int32_t mm_camera_intf_get_parms(uint32_t camera_handle,
257 parm_buffer_t *parms)
258 {
259 int32_t rc = -1;
260 mm_camera_obj_t * my_obj = NULL;
261
262 pthread_mutex_lock(&g_intf_lock);
263 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
264
265 if(my_obj) {
266 pthread_mutex_lock(&my_obj->cam_lock);
267 pthread_mutex_unlock(&g_intf_lock);
268 rc = mm_camera_get_parms(my_obj, parms);
269 } else {
270 pthread_mutex_unlock(&g_intf_lock);
271 }
272 return rc;
273 }
274
275 /*===========================================================================
276 * FUNCTION : mm_camera_intf_do_auto_focus
277 *
278 * DESCRIPTION: performing auto focus
279 *
280 * PARAMETERS :
281 * @camera_handle: camera handle
282 *
283 * RETURN : int32_t type of status
284 * 0 -- success
285 * -1 -- failure
286 * NOTE : if this call success, we will always assume there will
287 * be an auto_focus event following up.
288 *==========================================================================*/
mm_camera_intf_do_auto_focus(uint32_t camera_handle)289 static int32_t mm_camera_intf_do_auto_focus(uint32_t camera_handle)
290 {
291 int32_t rc = -1;
292 mm_camera_obj_t * my_obj = NULL;
293
294 pthread_mutex_lock(&g_intf_lock);
295 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
296
297 if(my_obj) {
298 pthread_mutex_lock(&my_obj->cam_lock);
299 pthread_mutex_unlock(&g_intf_lock);
300 rc = mm_camera_do_auto_focus(my_obj);
301 } else {
302 pthread_mutex_unlock(&g_intf_lock);
303 }
304 return rc;
305 }
306
307 /*===========================================================================
308 * FUNCTION : mm_camera_intf_cancel_auto_focus
309 *
310 * DESCRIPTION: cancel auto focus
311 *
312 * PARAMETERS :
313 * @camera_handle: camera handle
314 *
315 * RETURN : int32_t type of status
316 * 0 -- success
317 * -1 -- failure
318 *==========================================================================*/
mm_camera_intf_cancel_auto_focus(uint32_t camera_handle)319 static int32_t mm_camera_intf_cancel_auto_focus(uint32_t camera_handle)
320 {
321 int32_t rc = -1;
322 mm_camera_obj_t * my_obj = NULL;
323
324 pthread_mutex_lock(&g_intf_lock);
325 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
326
327 if(my_obj) {
328 pthread_mutex_lock(&my_obj->cam_lock);
329 pthread_mutex_unlock(&g_intf_lock);
330 rc = mm_camera_cancel_auto_focus(my_obj);
331 } else {
332 pthread_mutex_unlock(&g_intf_lock);
333 }
334 return rc;
335 }
336
337 /*===========================================================================
338 * FUNCTION : mm_camera_intf_prepare_snapshot
339 *
340 * DESCRIPTION: prepare hardware for snapshot
341 *
342 * PARAMETERS :
343 * @camera_handle: camera handle
344 * @do_af_flag : flag indicating if AF is needed
345 *
346 * RETURN : int32_t type of status
347 * 0 -- success
348 * -1 -- failure
349 *==========================================================================*/
mm_camera_intf_prepare_snapshot(uint32_t camera_handle,int32_t do_af_flag)350 static int32_t mm_camera_intf_prepare_snapshot(uint32_t camera_handle,
351 int32_t do_af_flag)
352 {
353 int32_t rc = -1;
354 mm_camera_obj_t * my_obj = NULL;
355
356 pthread_mutex_lock(&g_intf_lock);
357 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
358
359 if(my_obj) {
360 pthread_mutex_lock(&my_obj->cam_lock);
361 pthread_mutex_unlock(&g_intf_lock);
362 rc = mm_camera_prepare_snapshot(my_obj, do_af_flag);
363 } else {
364 pthread_mutex_unlock(&g_intf_lock);
365 }
366 return rc;
367 }
368
369 /*===========================================================================
370 * FUNCTION : mm_camera_intf_flush
371 *
372 * DESCRIPTION: flush the current camera state and buffers
373 *
374 * PARAMETERS :
375 * @camera_handle: camera handle
376 *
377 * RETURN : int32_t type of status
378 * 0 -- success
379 * -1 -- failure
380 *==========================================================================*/
mm_camera_intf_flush(uint32_t camera_handle)381 static int32_t mm_camera_intf_flush(uint32_t camera_handle)
382 {
383 int32_t rc = -1;
384 mm_camera_obj_t * my_obj = NULL;
385
386 pthread_mutex_lock(&g_intf_lock);
387 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
388
389 if(my_obj) {
390 pthread_mutex_lock(&my_obj->cam_lock);
391 pthread_mutex_unlock(&g_intf_lock);
392 rc = mm_camera_flush(my_obj);
393 } else {
394 pthread_mutex_unlock(&g_intf_lock);
395 }
396 return rc;
397 }
398
399 /*===========================================================================
400 * FUNCTION : mm_camera_intf_close
401 *
402 * DESCRIPTION: close a camera by its handle
403 *
404 * PARAMETERS :
405 * @camera_handle: camera handle
406 *
407 * RETURN : int32_t type of status
408 * 0 -- success
409 * -1 -- failure
410 *==========================================================================*/
mm_camera_intf_close(uint32_t camera_handle)411 static int32_t mm_camera_intf_close(uint32_t camera_handle)
412 {
413 int32_t rc = -1;
414 uint8_t cam_idx = camera_handle & 0x00ff;
415 mm_camera_obj_t * my_obj = NULL;
416
417 LOGD("E: camera_handler = %d ", camera_handle);
418
419 pthread_mutex_lock(&g_intf_lock);
420 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
421
422 if (my_obj){
423 my_obj->ref_count--;
424
425 if(my_obj->ref_count > 0) {
426 /* still have reference to obj, return here */
427 LOGD("ref_count=%d\n", my_obj->ref_count);
428 pthread_mutex_unlock(&g_intf_lock);
429 rc = 0;
430 } else {
431 /* need close camera here as no other reference
432 * first empty g_cam_ctrl's referent to cam_obj */
433 g_cam_ctrl.cam_obj[cam_idx] = NULL;
434
435 pthread_mutex_lock(&my_obj->cam_lock);
436 pthread_mutex_unlock(&g_intf_lock);
437 rc = mm_camera_close(my_obj);
438 pthread_mutex_destroy(&my_obj->cam_lock);
439 free(my_obj);
440 }
441 } else {
442 pthread_mutex_unlock(&g_intf_lock);
443 }
444
445 return rc;
446 }
447
448 /*===========================================================================
449 * FUNCTION : mm_camera_intf_add_channel
450 *
451 * DESCRIPTION: add a channel
452 *
453 * PARAMETERS :
454 * @camera_handle: camera handle
455 * @attr : bundle attribute of the channel if needed
456 * @channel_cb : callback function for bundle data notify
457 * @userdata : user data ptr
458 *
459 * RETURN : uint32_t type of channel handle
460 * 0 -- invalid channel handle, meaning the op failed
461 * >0 -- successfully added a channel with a valid handle
462 * NOTE : if no bundle data notify is needed, meaning each stream in the
463 * channel will have its own stream data notify callback, then
464 * attr, channel_cb, and userdata can be NULL. In this case,
465 * no matching logic will be performed in channel for the bundling.
466 *==========================================================================*/
mm_camera_intf_add_channel(uint32_t camera_handle,mm_camera_channel_attr_t * attr,mm_camera_buf_notify_t channel_cb,void * userdata)467 static uint32_t mm_camera_intf_add_channel(uint32_t camera_handle,
468 mm_camera_channel_attr_t *attr,
469 mm_camera_buf_notify_t channel_cb,
470 void *userdata)
471 {
472 uint32_t ch_id = 0;
473 mm_camera_obj_t * my_obj = NULL;
474
475 LOGD("E camera_handler = %d", camera_handle);
476 pthread_mutex_lock(&g_intf_lock);
477 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
478
479 if(my_obj) {
480 pthread_mutex_lock(&my_obj->cam_lock);
481 pthread_mutex_unlock(&g_intf_lock);
482 ch_id = mm_camera_add_channel(my_obj, attr, channel_cb, userdata);
483 } else {
484 pthread_mutex_unlock(&g_intf_lock);
485 }
486 LOGD("X ch_id = %d", ch_id);
487 return ch_id;
488 }
489
490 /*===========================================================================
491 * FUNCTION : mm_camera_intf_del_channel
492 *
493 * DESCRIPTION: delete a channel by its handle
494 *
495 * PARAMETERS :
496 * @camera_handle: camera handle
497 * @ch_id : channel handle
498 *
499 * RETURN : int32_t type of status
500 * 0 -- success
501 * -1 -- failure
502 * NOTE : all streams in the channel should be stopped already before
503 * this channel can be deleted.
504 *==========================================================================*/
mm_camera_intf_del_channel(uint32_t camera_handle,uint32_t ch_id)505 static int32_t mm_camera_intf_del_channel(uint32_t camera_handle,
506 uint32_t ch_id)
507 {
508 int32_t rc = -1;
509 mm_camera_obj_t * my_obj = NULL;
510
511 LOGD("E ch_id = %d", ch_id);
512 pthread_mutex_lock(&g_intf_lock);
513 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
514
515 if(my_obj) {
516 pthread_mutex_lock(&my_obj->cam_lock);
517 pthread_mutex_unlock(&g_intf_lock);
518 rc = mm_camera_del_channel(my_obj, ch_id);
519 } else {
520 pthread_mutex_unlock(&g_intf_lock);
521 }
522 LOGD("X");
523 return rc;
524 }
525
526 /*===========================================================================
527 * FUNCTION : mm_camera_intf_get_bundle_info
528 *
529 * DESCRIPTION: query bundle info of the channel
530 *
531 * PARAMETERS :
532 * @camera_handle: camera handle
533 * @ch_id : channel handle
534 * @bundle_info : bundle info to be filled in
535 *
536 * RETURN : int32_t type of status
537 * 0 -- success
538 * -1 -- failure
539 * NOTE : all streams in the channel should be stopped already before
540 * this channel can be deleted.
541 *==========================================================================*/
mm_camera_intf_get_bundle_info(uint32_t camera_handle,uint32_t ch_id,cam_bundle_config_t * bundle_info)542 static int32_t mm_camera_intf_get_bundle_info(uint32_t camera_handle,
543 uint32_t ch_id,
544 cam_bundle_config_t *bundle_info)
545 {
546 int32_t rc = -1;
547 mm_camera_obj_t * my_obj = NULL;
548
549 LOGD("E ch_id = %d", ch_id);
550 pthread_mutex_lock(&g_intf_lock);
551 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
552
553 if(my_obj) {
554 pthread_mutex_lock(&my_obj->cam_lock);
555 pthread_mutex_unlock(&g_intf_lock);
556 rc = mm_camera_get_bundle_info(my_obj, ch_id, bundle_info);
557 } else {
558 pthread_mutex_unlock(&g_intf_lock);
559 }
560 LOGD("X");
561 return rc;
562 }
563
564 /*===========================================================================
565 * FUNCTION : mm_camera_intf_register_event_notify
566 *
567 * DESCRIPTION: register for event notify
568 *
569 * PARAMETERS :
570 * @camera_handle: camera handle
571 * @evt_cb : callback for event notify
572 * @user_data : user data ptr
573 *
574 * RETURN : int32_t type of status
575 * 0 -- success
576 * -1 -- failure
577 *==========================================================================*/
mm_camera_intf_register_event_notify(uint32_t camera_handle,mm_camera_event_notify_t evt_cb,void * user_data)578 static int32_t mm_camera_intf_register_event_notify(uint32_t camera_handle,
579 mm_camera_event_notify_t evt_cb,
580 void * user_data)
581 {
582 int32_t rc = -1;
583 mm_camera_obj_t * my_obj = NULL;
584
585 LOGD("E ");
586 pthread_mutex_lock(&g_intf_lock);
587 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
588
589 if(my_obj) {
590 pthread_mutex_lock(&my_obj->cam_lock);
591 pthread_mutex_unlock(&g_intf_lock);
592 rc = mm_camera_register_event_notify(my_obj, evt_cb, user_data);
593 } else {
594 pthread_mutex_unlock(&g_intf_lock);
595 }
596 LOGD("E rc = %d", rc);
597 return rc;
598 }
599
600 /*===========================================================================
601 * FUNCTION : mm_camera_intf_qbuf
602 *
603 * DESCRIPTION: enqueue buffer back to kernel
604 *
605 * PARAMETERS :
606 * @camera_handle: camera handle
607 * @ch_id : channel handle
608 * @buf : buf ptr to be enqueued
609 *
610 * RETURN : int32_t type of status
611 * 0 -- success
612 * -1 -- failure
613 *==========================================================================*/
mm_camera_intf_qbuf(uint32_t camera_handle,uint32_t ch_id,mm_camera_buf_def_t * buf)614 static int32_t mm_camera_intf_qbuf(uint32_t camera_handle,
615 uint32_t ch_id,
616 mm_camera_buf_def_t *buf)
617 {
618 int32_t rc = -1;
619 mm_camera_obj_t * my_obj = NULL;
620
621 pthread_mutex_lock(&g_intf_lock);
622 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
623
624 if(my_obj) {
625 pthread_mutex_lock(&my_obj->cam_lock);
626 pthread_mutex_unlock(&g_intf_lock);
627 rc = mm_camera_qbuf(my_obj, ch_id, buf);
628 } else {
629 pthread_mutex_unlock(&g_intf_lock);
630 }
631 LOGD("X evt_type = %d",rc);
632 return rc;
633 }
634
635 /*===========================================================================
636 * FUNCTION : mm_camera_intf_qbuf
637 *
638 * DESCRIPTION: enqueue buffer back to kernel
639 *
640 * PARAMETERS :
641 * @camera_handle: camera handle
642 * @ch_id : channel handle
643 * @buf : buf ptr to be enqueued
644 *
645 * RETURN : int32_t type of status
646 * 0 -- success
647 * -1 -- failure
648 *==========================================================================*/
mm_camera_intf_cancel_buf(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id,uint32_t buf_idx)649 static int32_t mm_camera_intf_cancel_buf(uint32_t camera_handle, uint32_t ch_id, uint32_t stream_id,
650 uint32_t buf_idx)
651 {
652 int32_t rc = -1;
653 mm_camera_obj_t * my_obj = NULL;
654
655 pthread_mutex_lock(&g_intf_lock);
656 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
657
658 if(my_obj) {
659 pthread_mutex_lock(&my_obj->cam_lock);
660 pthread_mutex_unlock(&g_intf_lock);
661 rc = mm_camera_cancel_buf(my_obj, ch_id, stream_id, buf_idx);
662 } else {
663 pthread_mutex_unlock(&g_intf_lock);
664 }
665 LOGD("X evt_type = %d",rc);
666 return rc;
667 }
668
669
670 /*===========================================================================
671 * FUNCTION : mm_camera_intf_get_queued_buf_count
672 *
673 * DESCRIPTION: returns the queued buffer count
674 *
675 * PARAMETERS :
676 * @camera_handle: camera handle
677 * @ch_id : channel handle
678 * @stream_id : stream id
679 *
680 * RETURN : int32_t - queued buffer count
681 *
682 *==========================================================================*/
mm_camera_intf_get_queued_buf_count(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id)683 static int32_t mm_camera_intf_get_queued_buf_count(uint32_t camera_handle,
684 uint32_t ch_id, uint32_t stream_id)
685 {
686 int32_t rc = -1;
687 mm_camera_obj_t * my_obj = NULL;
688
689 pthread_mutex_lock(&g_intf_lock);
690 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
691
692 if(my_obj) {
693 pthread_mutex_lock(&my_obj->cam_lock);
694 pthread_mutex_unlock(&g_intf_lock);
695 rc = mm_camera_get_queued_buf_count(my_obj, ch_id, stream_id);
696 } else {
697 pthread_mutex_unlock(&g_intf_lock);
698 }
699 LOGD("X queued buffer count = %d",rc);
700 return rc;
701 }
702
703 /*===========================================================================
704 * FUNCTION : mm_camera_intf_link_stream
705 *
706 * DESCRIPTION: link a stream into a new channel
707 *
708 * PARAMETERS :
709 * @camera_handle: camera handle
710 * @ch_id : channel handle
711 * @stream_id : stream id
712 * @linked_ch_id : channel in which the stream will be linked
713 *
714 * RETURN : int32_t type of stream handle
715 * 0 -- invalid stream handle, meaning the op failed
716 * >0 -- successfully linked a stream with a valid handle
717 *==========================================================================*/
mm_camera_intf_link_stream(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id,uint32_t linked_ch_id)718 static int32_t mm_camera_intf_link_stream(uint32_t camera_handle,
719 uint32_t ch_id,
720 uint32_t stream_id,
721 uint32_t linked_ch_id)
722 {
723 uint32_t id = 0;
724 mm_camera_obj_t * my_obj = NULL;
725
726 LOGD("E handle = %u ch_id = %u",
727 camera_handle, ch_id);
728
729 pthread_mutex_lock(&g_intf_lock);
730 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
731
732 if(my_obj) {
733 pthread_mutex_lock(&my_obj->cam_lock);
734 pthread_mutex_unlock(&g_intf_lock);
735 id = mm_camera_link_stream(my_obj, ch_id, stream_id, linked_ch_id);
736 } else {
737 pthread_mutex_unlock(&g_intf_lock);
738 }
739
740 LOGD("X stream_id = %u", stream_id);
741 return (int32_t)id;
742 }
743
744 /*===========================================================================
745 * FUNCTION : mm_camera_intf_add_stream
746 *
747 * DESCRIPTION: add a stream into a channel
748 *
749 * PARAMETERS :
750 * @camera_handle: camera handle
751 * @ch_id : channel handle
752 *
753 * RETURN : uint32_t type of stream handle
754 * 0 -- invalid stream handle, meaning the op failed
755 * >0 -- successfully added a stream with a valid handle
756 *==========================================================================*/
mm_camera_intf_add_stream(uint32_t camera_handle,uint32_t ch_id)757 static uint32_t mm_camera_intf_add_stream(uint32_t camera_handle,
758 uint32_t ch_id)
759 {
760 uint32_t stream_id = 0;
761 mm_camera_obj_t * my_obj = NULL;
762
763 LOGD("E handle = %d ch_id = %d",
764 camera_handle, ch_id);
765
766 pthread_mutex_lock(&g_intf_lock);
767 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
768
769 if(my_obj) {
770 pthread_mutex_lock(&my_obj->cam_lock);
771 pthread_mutex_unlock(&g_intf_lock);
772 stream_id = mm_camera_add_stream(my_obj, ch_id);
773 } else {
774 pthread_mutex_unlock(&g_intf_lock);
775 }
776 LOGD("X stream_id = %d", stream_id);
777 return stream_id;
778 }
779
780 /*===========================================================================
781 * FUNCTION : mm_camera_intf_del_stream
782 *
783 * DESCRIPTION: delete a stream by its handle
784 *
785 * PARAMETERS :
786 * @camera_handle: camera handle
787 * @ch_id : channel handle
788 * @stream_id : stream handle
789 *
790 * RETURN : int32_t type of status
791 * 0 -- success
792 * -1 -- failure
793 * NOTE : stream should be stopped already before it can be deleted.
794 *==========================================================================*/
mm_camera_intf_del_stream(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id)795 static int32_t mm_camera_intf_del_stream(uint32_t camera_handle,
796 uint32_t ch_id,
797 uint32_t stream_id)
798 {
799 int32_t rc = -1;
800 mm_camera_obj_t * my_obj = NULL;
801
802 LOGD("E handle = %d ch_id = %d stream_id = %d",
803 camera_handle, ch_id, stream_id);
804
805 pthread_mutex_lock(&g_intf_lock);
806 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
807
808 if(my_obj) {
809 pthread_mutex_lock(&my_obj->cam_lock);
810 pthread_mutex_unlock(&g_intf_lock);
811 rc = mm_camera_del_stream(my_obj, ch_id, stream_id);
812 } else {
813 pthread_mutex_unlock(&g_intf_lock);
814 }
815 LOGD("X rc = %d", rc);
816 return rc;
817 }
818
819 /*===========================================================================
820 * FUNCTION : mm_camera_intf_config_stream
821 *
822 * DESCRIPTION: configure a stream
823 *
824 * PARAMETERS :
825 * @camera_handle: camera handle
826 * @ch_id : channel handle
827 * @stream_id : stream handle
828 * @config : stream configuration
829 *
830 * RETURN : int32_t type of status
831 * 0 -- success
832 * -1 -- failure
833 *==========================================================================*/
mm_camera_intf_config_stream(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id,mm_camera_stream_config_t * config)834 static int32_t mm_camera_intf_config_stream(uint32_t camera_handle,
835 uint32_t ch_id,
836 uint32_t stream_id,
837 mm_camera_stream_config_t *config)
838 {
839 int32_t rc = -1;
840 mm_camera_obj_t * my_obj = NULL;
841
842 LOGD("E handle = %d, ch_id = %d,stream_id = %d",
843 camera_handle, ch_id, stream_id);
844
845 pthread_mutex_lock(&g_intf_lock);
846 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
847
848 LOGD("mm_camera_intf_config_stream stream_id = %d",stream_id);
849
850 if(my_obj) {
851 pthread_mutex_lock(&my_obj->cam_lock);
852 pthread_mutex_unlock(&g_intf_lock);
853 rc = mm_camera_config_stream(my_obj, ch_id, stream_id, config);
854 } else {
855 pthread_mutex_unlock(&g_intf_lock);
856 }
857 LOGD("X rc = %d", rc);
858 return rc;
859 }
860
861 /*===========================================================================
862 * FUNCTION : mm_camera_intf_start_channel
863 *
864 * DESCRIPTION: start a channel, which will start all streams in the channel
865 *
866 * PARAMETERS :
867 * @camera_handle: camera handle
868 * @ch_id : channel handle
869 *
870 * RETURN : int32_t type of status
871 * 0 -- success
872 * -1 -- failure
873 *==========================================================================*/
mm_camera_intf_start_channel(uint32_t camera_handle,uint32_t ch_id)874 static int32_t mm_camera_intf_start_channel(uint32_t camera_handle,
875 uint32_t ch_id)
876 {
877 int32_t rc = -1;
878 mm_camera_obj_t * my_obj = NULL;
879
880 pthread_mutex_lock(&g_intf_lock);
881 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
882
883 if(my_obj) {
884 pthread_mutex_lock(&my_obj->cam_lock);
885 pthread_mutex_unlock(&g_intf_lock);
886 rc = mm_camera_start_channel(my_obj, ch_id);
887 } else {
888 pthread_mutex_unlock(&g_intf_lock);
889 }
890 LOGD("X rc = %d", rc);
891 return rc;
892 }
893
894 /*===========================================================================
895 * FUNCTION : mm_camera_intf_stop_channel
896 *
897 * DESCRIPTION: stop a channel, which will stop all streams in the channel
898 *
899 * PARAMETERS :
900 * @camera_handle: camera handle
901 * @ch_id : channel handle
902 *
903 * RETURN : int32_t type of status
904 * 0 -- success
905 * -1 -- failure
906 *==========================================================================*/
mm_camera_intf_stop_channel(uint32_t camera_handle,uint32_t ch_id)907 static int32_t mm_camera_intf_stop_channel(uint32_t camera_handle,
908 uint32_t ch_id)
909 {
910 int32_t rc = -1;
911 mm_camera_obj_t * my_obj = NULL;
912
913 pthread_mutex_lock(&g_intf_lock);
914 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
915
916 if(my_obj) {
917 pthread_mutex_lock(&my_obj->cam_lock);
918 pthread_mutex_unlock(&g_intf_lock);
919 rc = mm_camera_stop_channel(my_obj, ch_id);
920 } else {
921 pthread_mutex_unlock(&g_intf_lock);
922 }
923 LOGD("X rc = %d", rc);
924 return rc;
925 }
926
927 /*===========================================================================
928 * FUNCTION : mm_camera_intf_request_super_buf
929 *
930 * DESCRIPTION: for burst mode in bundle, reuqest certain amount of matched
931 * frames from superbuf queue
932 *
933 * PARAMETERS :
934 * @camera_handle: camera handle
935 * @ch_id : channel handle
936 * @buf : request buffer info
937 *
938 * RETURN : int32_t type of status
939 * 0 -- success
940 * -1 -- failure
941 *==========================================================================*/
mm_camera_intf_request_super_buf(uint32_t camera_handle,uint32_t ch_id,mm_camera_req_buf_t * buf)942 static int32_t mm_camera_intf_request_super_buf(uint32_t camera_handle,
943 uint32_t ch_id, mm_camera_req_buf_t *buf)
944 {
945 int32_t rc = -1;
946 LOGD("E camera_handler = %d,ch_id = %d",
947 camera_handle, ch_id);
948 mm_camera_obj_t * my_obj = NULL;
949
950 pthread_mutex_lock(&g_intf_lock);
951 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
952
953 if(my_obj && buf) {
954 pthread_mutex_lock(&my_obj->cam_lock);
955 pthread_mutex_unlock(&g_intf_lock);
956 rc = mm_camera_request_super_buf (my_obj, ch_id, buf);
957 } else {
958 pthread_mutex_unlock(&g_intf_lock);
959 }
960 LOGD("X rc = %d", rc);
961 return rc;
962 }
963
964 /*===========================================================================
965 * FUNCTION : mm_camera_intf_cancel_super_buf_request
966 *
967 * DESCRIPTION: for burst mode in bundle, cancel the reuqest for certain amount
968 * of matched frames from superbuf queue
969 *
970 * PARAMETERS :
971 * @camera_handle: camera handle
972 * @ch_id : channel handle
973 *
974 * RETURN : int32_t type of status
975 * 0 -- success
976 * -1 -- failure
977 *==========================================================================*/
mm_camera_intf_cancel_super_buf_request(uint32_t camera_handle,uint32_t ch_id)978 static int32_t mm_camera_intf_cancel_super_buf_request(uint32_t camera_handle,
979 uint32_t ch_id)
980 {
981 int32_t rc = -1;
982 mm_camera_obj_t * my_obj = NULL;
983
984 LOGD("E camera_handler = %d,ch_id = %d",
985 camera_handle, ch_id);
986 pthread_mutex_lock(&g_intf_lock);
987 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
988
989 if(my_obj) {
990 pthread_mutex_lock(&my_obj->cam_lock);
991 pthread_mutex_unlock(&g_intf_lock);
992 rc = mm_camera_cancel_super_buf_request(my_obj, ch_id);
993 } else {
994 pthread_mutex_unlock(&g_intf_lock);
995 }
996 LOGD("X rc = %d", rc);
997 return rc;
998 }
999
1000 /*===========================================================================
1001 * FUNCTION : mm_camera_intf_flush_super_buf_queue
1002 *
1003 * DESCRIPTION: flush out all frames in the superbuf queue
1004 *
1005 * PARAMETERS :
1006 * @camera_handle: camera handle
1007 * @ch_id : channel handle
1008 * @frame_idx : frame index
1009 *
1010 * RETURN : int32_t type of status
1011 * 0 -- success
1012 * -1 -- failure
1013 *==========================================================================*/
mm_camera_intf_flush_super_buf_queue(uint32_t camera_handle,uint32_t ch_id,uint32_t frame_idx)1014 static int32_t mm_camera_intf_flush_super_buf_queue(uint32_t camera_handle,
1015 uint32_t ch_id, uint32_t frame_idx)
1016 {
1017 int32_t rc = -1;
1018 mm_camera_obj_t * my_obj = NULL;
1019
1020 LOGD("E camera_handler = %d,ch_id = %d",
1021 camera_handle, ch_id);
1022 pthread_mutex_lock(&g_intf_lock);
1023 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1024
1025 if(my_obj) {
1026 pthread_mutex_lock(&my_obj->cam_lock);
1027 pthread_mutex_unlock(&g_intf_lock);
1028 rc = mm_camera_flush_super_buf_queue(my_obj, ch_id, frame_idx);
1029 } else {
1030 pthread_mutex_unlock(&g_intf_lock);
1031 }
1032 LOGD("X rc = %d", rc);
1033 return rc;
1034 }
1035
1036 /*===========================================================================
1037 * FUNCTION : mm_camera_intf_start_zsl_snapshot
1038 *
1039 * DESCRIPTION: Starts zsl snapshot
1040 *
1041 * PARAMETERS :
1042 * @camera_handle: camera handle
1043 * @ch_id : channel handle
1044 *
1045 * RETURN : int32_t type of status
1046 * 0 -- success
1047 * -1 -- failure
1048 *==========================================================================*/
mm_camera_intf_start_zsl_snapshot(uint32_t camera_handle,uint32_t ch_id)1049 static int32_t mm_camera_intf_start_zsl_snapshot(uint32_t camera_handle,
1050 uint32_t ch_id)
1051 {
1052 int32_t rc = -1;
1053 mm_camera_obj_t * my_obj = NULL;
1054
1055 LOGD("E camera_handler = %d,ch_id = %d",
1056 camera_handle, ch_id);
1057 pthread_mutex_lock(&g_intf_lock);
1058 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1059
1060 if(my_obj) {
1061 pthread_mutex_lock(&my_obj->cam_lock);
1062 pthread_mutex_unlock(&g_intf_lock);
1063 rc = mm_camera_start_zsl_snapshot_ch(my_obj, ch_id);
1064 } else {
1065 pthread_mutex_unlock(&g_intf_lock);
1066 }
1067 LOGD("X rc = %d", rc);
1068 return rc;
1069 }
1070
1071 /*===========================================================================
1072 * FUNCTION : mm_camera_intf_stop_zsl_snapshot
1073 *
1074 * DESCRIPTION: Stops zsl snapshot
1075 *
1076 * PARAMETERS :
1077 * @camera_handle: camera handle
1078 * @ch_id : channel handle
1079 *
1080 * RETURN : int32_t type of status
1081 * 0 -- success
1082 * -1 -- failure
1083 *==========================================================================*/
mm_camera_intf_stop_zsl_snapshot(uint32_t camera_handle,uint32_t ch_id)1084 static int32_t mm_camera_intf_stop_zsl_snapshot(uint32_t camera_handle,
1085 uint32_t ch_id)
1086 {
1087 int32_t rc = -1;
1088 mm_camera_obj_t * my_obj = NULL;
1089
1090 LOGD("E camera_handler = %d,ch_id = %d",
1091 camera_handle, ch_id);
1092 pthread_mutex_lock(&g_intf_lock);
1093 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1094
1095 if(my_obj) {
1096 pthread_mutex_lock(&my_obj->cam_lock);
1097 pthread_mutex_unlock(&g_intf_lock);
1098 rc = mm_camera_stop_zsl_snapshot_ch(my_obj, ch_id);
1099 } else {
1100 pthread_mutex_unlock(&g_intf_lock);
1101 }
1102 LOGD("X rc = %d", rc);
1103 return rc;
1104 }
1105
1106 /*===========================================================================
1107 * FUNCTION : mm_camera_intf_configure_notify_mode
1108 *
1109 * DESCRIPTION: Configures channel notification mode
1110 *
1111 * PARAMETERS :
1112 * @camera_handle: camera handle
1113 * @ch_id : channel handle
1114 * @notify_mode : notification mode
1115 *
1116 * RETURN : int32_t type of status
1117 * 0 -- success
1118 * -1 -- failure
1119 *==========================================================================*/
mm_camera_intf_configure_notify_mode(uint32_t camera_handle,uint32_t ch_id,mm_camera_super_buf_notify_mode_t notify_mode)1120 static int32_t mm_camera_intf_configure_notify_mode(uint32_t camera_handle,
1121 uint32_t ch_id,
1122 mm_camera_super_buf_notify_mode_t notify_mode)
1123 {
1124 int32_t rc = -1;
1125 mm_camera_obj_t * my_obj = NULL;
1126
1127 LOGD("E camera_handler = %d,ch_id = %d",
1128 camera_handle, ch_id);
1129 pthread_mutex_lock(&g_intf_lock);
1130 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1131
1132 if(my_obj) {
1133 pthread_mutex_lock(&my_obj->cam_lock);
1134 pthread_mutex_unlock(&g_intf_lock);
1135 rc = mm_camera_config_channel_notify(my_obj, ch_id, notify_mode);
1136 } else {
1137 pthread_mutex_unlock(&g_intf_lock);
1138 }
1139 LOGD("X rc = %d", rc);
1140 return rc;
1141 }
1142
1143 /*===========================================================================
1144 * FUNCTION : mm_camera_intf_map_buf
1145 *
1146 * DESCRIPTION: mapping camera buffer via domain socket to server
1147 *
1148 * PARAMETERS :
1149 * @camera_handle: camera handle
1150 * @buf_type : type of buffer to be mapped. could be following values:
1151 * CAM_MAPPING_BUF_TYPE_CAPABILITY
1152 * CAM_MAPPING_BUF_TYPE_SETPARM_BUF
1153 * CAM_MAPPING_BUF_TYPE_GETPARM_BUF
1154 * @fd : file descriptor of the buffer
1155 * @size : size of the buffer
1156 *
1157 * RETURN : int32_t type of status
1158 * 0 -- success
1159 * -1 -- failure
1160 *==========================================================================*/
mm_camera_intf_map_buf(uint32_t camera_handle,uint8_t buf_type,int fd,size_t size,void * buffer)1161 static int32_t mm_camera_intf_map_buf(uint32_t camera_handle,
1162 uint8_t buf_type, int fd, size_t size, void *buffer)
1163 {
1164 int32_t rc = -1;
1165 mm_camera_obj_t * my_obj = NULL;
1166
1167 pthread_mutex_lock(&g_intf_lock);
1168 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1169
1170 if(my_obj) {
1171 pthread_mutex_lock(&my_obj->cam_lock);
1172 pthread_mutex_unlock(&g_intf_lock);
1173 rc = mm_camera_map_buf(my_obj, buf_type, fd, size, buffer);
1174 } else {
1175 pthread_mutex_unlock(&g_intf_lock);
1176 }
1177 return rc;
1178 }
1179
1180 /*===========================================================================
1181 * FUNCTION : mm_camera_intf_map_bufs
1182 *
1183 * DESCRIPTION: mapping camera buffer via domain socket to server
1184 *
1185 * PARAMETERS :
1186 * @camera_handle: camera handle
1187 * @buf_type : type of buffer to be mapped. could be following values:
1188 * CAM_MAPPING_BUF_TYPE_CAPABILITY
1189 * CAM_MAPPING_BUF_TYPE_SETPARM_BUF
1190 * CAM_MAPPING_BUF_TYPE_GETPARM_BUF
1191 *
1192 * RETURN : int32_t type of status
1193 * 0 -- success
1194 * -1 -- failure
1195 *==========================================================================*/
mm_camera_intf_map_bufs(uint32_t camera_handle,const cam_buf_map_type_list * buf_map_list)1196 static int32_t mm_camera_intf_map_bufs(uint32_t camera_handle,
1197 const cam_buf_map_type_list *buf_map_list)
1198 {
1199 int32_t rc = -1;
1200 mm_camera_obj_t * my_obj = NULL;
1201
1202 pthread_mutex_lock(&g_intf_lock);
1203 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1204
1205 if(my_obj) {
1206 pthread_mutex_lock(&my_obj->cam_lock);
1207 pthread_mutex_unlock(&g_intf_lock);
1208 rc = mm_camera_map_bufs(my_obj, buf_map_list);
1209 } else {
1210 pthread_mutex_unlock(&g_intf_lock);
1211 }
1212 return rc;
1213 }
1214
1215 /*===========================================================================
1216 * FUNCTION : mm_camera_intf_unmap_buf
1217 *
1218 * DESCRIPTION: unmapping camera buffer via domain socket to server
1219 *
1220 * PARAMETERS :
1221 * @camera_handle: camera handle
1222 * @buf_type : type of buffer to be unmapped. could be following values:
1223 * CAM_MAPPING_BUF_TYPE_CAPABILITY
1224 * CAM_MAPPING_BUF_TYPE_SETPARM_BUF
1225 * CAM_MAPPING_BUF_TYPE_GETPARM_BUF
1226 *
1227 * RETURN : int32_t type of status
1228 * 0 -- success
1229 * -1 -- failure
1230 *==========================================================================*/
mm_camera_intf_unmap_buf(uint32_t camera_handle,uint8_t buf_type)1231 static int32_t mm_camera_intf_unmap_buf(uint32_t camera_handle,
1232 uint8_t buf_type)
1233 {
1234 int32_t rc = -1;
1235 mm_camera_obj_t * my_obj = NULL;
1236
1237 pthread_mutex_lock(&g_intf_lock);
1238 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1239
1240 if(my_obj) {
1241 pthread_mutex_lock(&my_obj->cam_lock);
1242 pthread_mutex_unlock(&g_intf_lock);
1243 rc = mm_camera_unmap_buf(my_obj, buf_type);
1244 } else {
1245 pthread_mutex_unlock(&g_intf_lock);
1246 }
1247 return rc;
1248 }
1249
1250 /*===========================================================================
1251 * FUNCTION : mm_camera_intf_set_stream_parms
1252 *
1253 * DESCRIPTION: set parameters per stream
1254 *
1255 * PARAMETERS :
1256 * @camera_handle: camera handle
1257 * @ch_id : channel handle
1258 * @s_id : stream handle
1259 * @parms : ptr to a param struct to be set to server
1260 *
1261 * RETURN : int32_t type of status
1262 * 0 -- success
1263 * -1 -- failure
1264 * NOTE : Assume the parms struct buf is already mapped to server via
1265 * domain socket. Corresponding fields of parameters to be set
1266 * are already filled in by upper layer caller.
1267 *==========================================================================*/
mm_camera_intf_set_stream_parms(uint32_t camera_handle,uint32_t ch_id,uint32_t s_id,cam_stream_parm_buffer_t * parms)1268 static int32_t mm_camera_intf_set_stream_parms(uint32_t camera_handle,
1269 uint32_t ch_id,
1270 uint32_t s_id,
1271 cam_stream_parm_buffer_t *parms)
1272 {
1273 int32_t rc = -1;
1274 mm_camera_obj_t * my_obj = NULL;
1275
1276 pthread_mutex_lock(&g_intf_lock);
1277 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1278
1279 LOGD("E camera_handle = %d,ch_id = %d,s_id = %d",
1280 camera_handle, ch_id, s_id);
1281
1282 if(my_obj) {
1283 pthread_mutex_lock(&my_obj->cam_lock);
1284 pthread_mutex_unlock(&g_intf_lock);
1285 rc = mm_camera_set_stream_parms(my_obj, ch_id, s_id, parms);
1286 }else{
1287 pthread_mutex_unlock(&g_intf_lock);
1288 }
1289 LOGD("X rc = %d", rc);
1290 return rc;
1291 }
1292
1293 /*===========================================================================
1294 * FUNCTION : mm_camera_intf_get_stream_parms
1295 *
1296 * DESCRIPTION: get parameters per stream
1297 *
1298 * PARAMETERS :
1299 * @camera_handle: camera handle
1300 * @ch_id : channel handle
1301 * @s_id : stream handle
1302 * @parms : ptr to a param struct to be get from server
1303 *
1304 * RETURN : int32_t type of status
1305 * 0 -- success
1306 * -1 -- failure
1307 * NOTE : Assume the parms struct buf is already mapped to server via
1308 * domain socket. Parameters to be get from server are already
1309 * filled in by upper layer caller. After this call, corresponding
1310 * fields of requested parameters will be filled in by server with
1311 * detailed information.
1312 *==========================================================================*/
mm_camera_intf_get_stream_parms(uint32_t camera_handle,uint32_t ch_id,uint32_t s_id,cam_stream_parm_buffer_t * parms)1313 static int32_t mm_camera_intf_get_stream_parms(uint32_t camera_handle,
1314 uint32_t ch_id,
1315 uint32_t s_id,
1316 cam_stream_parm_buffer_t *parms)
1317 {
1318 int32_t rc = -1;
1319 mm_camera_obj_t * my_obj = NULL;
1320
1321 pthread_mutex_lock(&g_intf_lock);
1322 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1323
1324 LOGD("E camera_handle = %d,ch_id = %d,s_id = %d",
1325 camera_handle, ch_id, s_id);
1326
1327 if(my_obj) {
1328 pthread_mutex_lock(&my_obj->cam_lock);
1329 pthread_mutex_unlock(&g_intf_lock);
1330 rc = mm_camera_get_stream_parms(my_obj, ch_id, s_id, parms);
1331 }else{
1332 pthread_mutex_unlock(&g_intf_lock);
1333 }
1334
1335 LOGD("X rc = %d", rc);
1336 return rc;
1337 }
1338
1339 /*===========================================================================
1340 * FUNCTION : mm_camera_intf_map_stream_buf
1341 *
1342 * DESCRIPTION: mapping stream buffer via domain socket to server
1343 *
1344 * PARAMETERS :
1345 * @camera_handle: camera handle
1346 * @ch_id : channel handle
1347 * @s_id : stream handle
1348 * @buf_type : type of buffer to be mapped. could be following values:
1349 * CAM_MAPPING_BUF_TYPE_STREAM_BUF
1350 * CAM_MAPPING_BUF_TYPE_STREAM_INFO
1351 * CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF
1352 * @buf_idx : index of buffer within the stream buffers, only valid if
1353 * buf_type is CAM_MAPPING_BUF_TYPE_STREAM_BUF or
1354 * CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF
1355 * @plane_idx : plane index. If all planes share the same fd,
1356 * plane_idx = -1; otherwise, plean_idx is the
1357 * index to plane (0..num_of_planes)
1358 * @fd : file descriptor of the buffer
1359 * @size : size of the buffer
1360 *
1361 * RETURN : int32_t type of status
1362 * 0 -- success
1363 * -1 -- failure
1364 *==========================================================================*/
mm_camera_intf_map_stream_buf(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id,uint8_t buf_type,uint32_t buf_idx,int32_t plane_idx,int fd,size_t size,void * buffer)1365 static int32_t mm_camera_intf_map_stream_buf(uint32_t camera_handle,
1366 uint32_t ch_id, uint32_t stream_id, uint8_t buf_type,
1367 uint32_t buf_idx, int32_t plane_idx, int fd,
1368 size_t size, void *buffer)
1369 {
1370 int32_t rc = -1;
1371 mm_camera_obj_t * my_obj = NULL;
1372
1373 pthread_mutex_lock(&g_intf_lock);
1374 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1375
1376 LOGD("E camera_handle = %d, ch_id = %d, s_id = %d, buf_idx = %d, plane_idx = %d",
1377 camera_handle, ch_id, stream_id, buf_idx, plane_idx);
1378
1379 if(my_obj) {
1380 pthread_mutex_lock(&my_obj->cam_lock);
1381 pthread_mutex_unlock(&g_intf_lock);
1382 rc = mm_camera_map_stream_buf(my_obj, ch_id, stream_id,
1383 buf_type, buf_idx, plane_idx,
1384 fd, size, buffer);
1385 }else{
1386 pthread_mutex_unlock(&g_intf_lock);
1387 }
1388
1389 LOGD("X rc = %d", rc);
1390 return rc;
1391 }
1392
1393 /*===========================================================================
1394 * FUNCTION : mm_camera_intf_map_stream_bufs
1395 *
1396 * DESCRIPTION: mapping stream buffers via domain socket to server
1397 *
1398 * PARAMETERS :
1399 * @camera_handle: camera handle
1400 * @ch_id : channel handle
1401 * @buf_map_list : list of buffers to be mapped
1402 *
1403 * RETURN : int32_t type of status
1404 * 0 -- success
1405 * -1 -- failure
1406 *==========================================================================*/
mm_camera_intf_map_stream_bufs(uint32_t camera_handle,uint32_t ch_id,const cam_buf_map_type_list * buf_map_list)1407 static int32_t mm_camera_intf_map_stream_bufs(uint32_t camera_handle,
1408 uint32_t ch_id,
1409 const cam_buf_map_type_list *buf_map_list)
1410 {
1411 int32_t rc = -1;
1412 mm_camera_obj_t * my_obj = NULL;
1413
1414 pthread_mutex_lock(&g_intf_lock);
1415 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1416
1417 LOGD("E camera_handle = %d, ch_id = %d",
1418 camera_handle, ch_id);
1419
1420 if(my_obj) {
1421 pthread_mutex_lock(&my_obj->cam_lock);
1422 pthread_mutex_unlock(&g_intf_lock);
1423 rc = mm_camera_map_stream_bufs(my_obj, ch_id, buf_map_list);
1424 }else{
1425 pthread_mutex_unlock(&g_intf_lock);
1426 }
1427
1428 LOGD("X rc = %d", rc);
1429 return rc;
1430 }
1431
1432 /*===========================================================================
1433 * FUNCTION : mm_camera_intf_unmap_stream_buf
1434 *
1435 * DESCRIPTION: unmapping stream buffer via domain socket to server
1436 *
1437 * PARAMETERS :
1438 * @camera_handle: camera handle
1439 * @ch_id : channel handle
1440 * @s_id : stream handle
1441 * @buf_type : type of buffer to be unmapped. could be following values:
1442 * CAM_MAPPING_BUF_TYPE_STREAM_BUF
1443 * CAM_MAPPING_BUF_TYPE_STREAM_INFO
1444 * CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF
1445 * @buf_idx : index of buffer within the stream buffers, only valid if
1446 * buf_type is CAM_MAPPING_BUF_TYPE_STREAM_BUF or
1447 * CAM_MAPPING_BUF_TYPE_OFFLINE_INPUT_BUF
1448 * @plane_idx : plane index. If all planes share the same fd,
1449 * plane_idx = -1; otherwise, plean_idx is the
1450 * index to plane (0..num_of_planes)
1451 *
1452 * RETURN : int32_t type of status
1453 * 0 -- success
1454 * -1 -- failure
1455 *==========================================================================*/
mm_camera_intf_unmap_stream_buf(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id,uint8_t buf_type,uint32_t buf_idx,int32_t plane_idx)1456 static int32_t mm_camera_intf_unmap_stream_buf(uint32_t camera_handle,
1457 uint32_t ch_id,
1458 uint32_t stream_id,
1459 uint8_t buf_type,
1460 uint32_t buf_idx,
1461 int32_t plane_idx)
1462 {
1463 int32_t rc = -1;
1464 mm_camera_obj_t * my_obj = NULL;
1465
1466 pthread_mutex_lock(&g_intf_lock);
1467 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1468
1469 LOGD("E camera_handle = %d, ch_id = %d, s_id = %d, buf_idx = %d, plane_idx = %d",
1470 camera_handle, ch_id, stream_id, buf_idx, plane_idx);
1471
1472 if(my_obj) {
1473 pthread_mutex_lock(&my_obj->cam_lock);
1474 pthread_mutex_unlock(&g_intf_lock);
1475 rc = mm_camera_unmap_stream_buf(my_obj, ch_id, stream_id,
1476 buf_type, buf_idx, plane_idx);
1477 }else{
1478 pthread_mutex_unlock(&g_intf_lock);
1479 }
1480
1481 LOGD("X rc = %d", rc);
1482 return rc;
1483 }
1484
1485 /*===========================================================================
1486 * FUNCTION : mm_camera_intf_get_session_id
1487 *
1488 * DESCRIPTION: retrieve the session ID from the kernel for this HWI instance
1489 *
1490 * PARAMETERS :
1491 * @camera_handle: camera handle
1492 * @sessionid: session id to be retrieved from server
1493 *
1494 * RETURN : int32_t type of status
1495 * 0 -- success
1496 * -1 -- failure
1497 * NOTE : if this call succeeds, we will get a valid session id.
1498 *==========================================================================*/
mm_camera_intf_get_session_id(uint32_t camera_handle,uint32_t * sessionid)1499 static int32_t mm_camera_intf_get_session_id(uint32_t camera_handle,
1500 uint32_t* sessionid)
1501 {
1502 int32_t rc = -1;
1503 mm_camera_obj_t * my_obj = NULL;
1504
1505 pthread_mutex_lock(&g_intf_lock);
1506 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1507
1508 if(my_obj) {
1509 pthread_mutex_lock(&my_obj->cam_lock);
1510 pthread_mutex_unlock(&g_intf_lock);
1511 *sessionid = my_obj->sessionid;
1512 pthread_mutex_unlock(&my_obj->cam_lock);
1513 rc = 0;
1514 } else {
1515 pthread_mutex_unlock(&g_intf_lock);
1516 }
1517 return rc;
1518 }
1519
1520 /*===========================================================================
1521 * FUNCTION : mm_camera_intf_sync_related_sensors
1522 *
1523 * DESCRIPTION: retrieve the session ID from the kernel for this HWI instance
1524 *
1525 * PARAMETERS :
1526 * @camera_handle: camera handle
1527 * @related_cam_info: pointer to the related cam info to be sent to the server
1528 *
1529 * RETURN : int32_t type of status
1530 * 0 -- success
1531 * -1 -- failure
1532 * NOTE : if this call succeeds, we will get linking established in back end
1533 *==========================================================================*/
mm_camera_intf_sync_related_sensors(uint32_t camera_handle,cam_sync_related_sensors_event_info_t * related_cam_info)1534 static int32_t mm_camera_intf_sync_related_sensors(uint32_t camera_handle,
1535 cam_sync_related_sensors_event_info_t* related_cam_info)
1536 {
1537 int32_t rc = -1;
1538 mm_camera_obj_t * my_obj = NULL;
1539
1540 pthread_mutex_lock(&g_intf_lock);
1541 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1542
1543 if(my_obj) {
1544 pthread_mutex_lock(&my_obj->cam_lock);
1545 pthread_mutex_unlock(&g_intf_lock);
1546 rc = mm_camera_sync_related_sensors(my_obj, related_cam_info);
1547 } else {
1548 pthread_mutex_unlock(&g_intf_lock);
1549 }
1550 return rc;
1551 }
1552
1553 /*===========================================================================
1554 * FUNCTION : get_sensor_info
1555 *
1556 * DESCRIPTION: get sensor info like facing(back/front) and mount angle
1557 *
1558 * PARAMETERS :
1559 *
1560 * RETURN :
1561 *==========================================================================*/
get_sensor_info()1562 void get_sensor_info()
1563 {
1564 int rc = 0;
1565 int dev_fd = -1;
1566 struct media_device_info mdev_info;
1567 int num_media_devices = 0;
1568 size_t num_cameras = 0;
1569
1570 LOGD("E");
1571 while (1) {
1572 char dev_name[32];
1573 snprintf(dev_name, sizeof(dev_name), "/dev/media%d", num_media_devices);
1574 dev_fd = open(dev_name, O_RDWR | O_NONBLOCK);
1575 if (dev_fd < 0) {
1576 LOGD("Done discovering media devices\n");
1577 break;
1578 }
1579 num_media_devices++;
1580 memset(&mdev_info, 0, sizeof(mdev_info));
1581 rc = ioctl(dev_fd, MEDIA_IOC_DEVICE_INFO, &mdev_info);
1582 if (rc < 0) {
1583 LOGE("Error: ioctl media_dev failed: %s\n", strerror(errno));
1584 close(dev_fd);
1585 dev_fd = -1;
1586 num_cameras = 0;
1587 break;
1588 }
1589
1590 if(strncmp(mdev_info.model, MSM_CONFIGURATION_NAME, sizeof(mdev_info.model)) != 0) {
1591 close(dev_fd);
1592 dev_fd = -1;
1593 continue;
1594 }
1595
1596 unsigned int num_entities = 1;
1597 while (1) {
1598 struct media_entity_desc entity;
1599 uint32_t temp;
1600 uint32_t mount_angle;
1601 uint32_t facing;
1602 int32_t type = 0;
1603 uint8_t is_yuv;
1604
1605 memset(&entity, 0, sizeof(entity));
1606 entity.id = num_entities++;
1607 rc = ioctl(dev_fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
1608 if (rc < 0) {
1609 LOGD("Done enumerating media entities\n");
1610 rc = 0;
1611 break;
1612 }
1613 if(entity.type == MEDIA_ENT_T_V4L2_SUBDEV &&
1614 entity.group_id == MSM_CAMERA_SUBDEV_SENSOR) {
1615 temp = entity.flags >> 8;
1616 mount_angle = (temp & 0xFF) * 90;
1617 facing = (temp & 0xFF00) >> 8;
1618 type = ((entity.flags & CAM_SENSOR_TYPE_MASK) ?
1619 CAM_TYPE_AUX:CAM_TYPE_MAIN);
1620 is_yuv = ((entity.flags & CAM_SENSOR_FORMAT_MASK) ?
1621 CAM_SENSOR_YUV:CAM_SENSOR_RAW);
1622 LOGL("index = %u flag = %x mount_angle = %u "
1623 "facing = %u type: %u is_yuv = %u\n",
1624 (unsigned int)num_cameras, (unsigned int)temp,
1625 (unsigned int)mount_angle, (unsigned int)facing,
1626 (unsigned int)type, (uint8_t)is_yuv);
1627 g_cam_ctrl.info[num_cameras].facing = (int)facing;
1628 g_cam_ctrl.info[num_cameras].orientation = (int)mount_angle;
1629 g_cam_ctrl.cam_type[num_cameras] = type;
1630 g_cam_ctrl.is_yuv[num_cameras] = is_yuv;
1631 LOGD("dev_info[id=%zu,name='%s']\n",
1632 num_cameras, g_cam_ctrl.video_dev_name[num_cameras]);
1633 num_cameras++;
1634 continue;
1635 }
1636 }
1637 close(dev_fd);
1638 dev_fd = -1;
1639 }
1640
1641 LOGD("num_cameras=%d\n", g_cam_ctrl.num_cam);
1642 return;
1643 }
1644
1645 /*===========================================================================
1646 * FUNCTION : sort_camera_info
1647 *
1648 * DESCRIPTION: sort camera info to keep back cameras idx is smaller than front cameras idx
1649 *
1650 * PARAMETERS : number of cameras
1651 *
1652 * RETURN :
1653 *==========================================================================*/
sort_camera_info(int num_cam)1654 void sort_camera_info(int num_cam)
1655 {
1656 int idx = 0, i;
1657 int8_t is_dual_cam = 0, is_aux_cam_exposed = 0;
1658 char prop[PROPERTY_VALUE_MAX];
1659 struct camera_info temp_info[MM_CAMERA_MAX_NUM_SENSORS];
1660 cam_sync_type_t temp_type[MM_CAMERA_MAX_NUM_SENSORS];
1661 cam_sync_mode_t temp_mode[MM_CAMERA_MAX_NUM_SENSORS];
1662 uint8_t temp_is_yuv[MM_CAMERA_MAX_NUM_SENSORS];
1663 char temp_dev_name[MM_CAMERA_MAX_NUM_SENSORS][MM_CAMERA_DEV_NAME_LEN];
1664
1665 memset(temp_info, 0, sizeof(temp_info));
1666 memset(temp_dev_name, 0, sizeof(temp_dev_name));
1667 memset(temp_type, 0, sizeof(temp_type));
1668 memset(temp_mode, 0, sizeof(temp_mode));
1669 memset(temp_is_yuv, 0, sizeof(temp_is_yuv));
1670
1671 // Signifies whether system has to enable dual camera mode
1672 memset(prop, 0, sizeof(prop));
1673 property_get("persist.camera.dual.camera", prop, "0");
1674 is_dual_cam = atoi(prop);
1675
1676 // Signifies whether AUX camera has to be exposed as physical camera
1677 memset(prop, 0, sizeof(prop));
1678 property_get("persist.camera.aux.camera", prop, "0");
1679 is_aux_cam_exposed = atoi(prop);
1680 LOGI("dualCamera:%d auxCamera %d",
1681 is_dual_cam, is_aux_cam_exposed);
1682
1683 /*
1684 1. If dual camera is enabled, dont hide any camera here. Further logic to handle AUX
1685 cameras is handled in setupLogicalCameras().
1686 2. If dual camera is not enabled, hide Front camera if AUX camera property is set.
1687 In such case, application will see only back MAIN and back AUX cameras.
1688 3. TODO: Need to revisit this logic if front AUX is available.
1689 */
1690
1691 /* firstly save the main back cameras info*/
1692 for (i = 0; i < num_cam; i++) {
1693 if ((g_cam_ctrl.info[i].facing == CAMERA_FACING_BACK) &&
1694 (g_cam_ctrl.cam_type[i] == CAM_TYPE_MAIN)) {
1695 temp_info[idx] = g_cam_ctrl.info[i];
1696 temp_type[idx] = g_cam_ctrl.cam_type[i];
1697 temp_mode[idx] = g_cam_ctrl.cam_mode[i];
1698 temp_is_yuv[idx] = g_cam_ctrl.is_yuv[i];
1699 LOGD("Found Back Main Camera: i: %d idx: %d", i, idx);
1700 memcpy(temp_dev_name[idx++],g_cam_ctrl.video_dev_name[i],
1701 MM_CAMERA_DEV_NAME_LEN);
1702 }
1703 }
1704
1705 /* save the aux back cameras info*/
1706 if (is_dual_cam || is_aux_cam_exposed) {
1707 for (i = 0; i < num_cam; i++) {
1708 if ((g_cam_ctrl.info[i].facing == CAMERA_FACING_BACK) &&
1709 (g_cam_ctrl.cam_type[i] == CAM_TYPE_AUX)) {
1710 temp_info[idx] = g_cam_ctrl.info[i];
1711 temp_type[idx] = g_cam_ctrl.cam_type[i];
1712 temp_mode[idx] = g_cam_ctrl.cam_mode[i];
1713 temp_is_yuv[idx] = g_cam_ctrl.is_yuv[i];
1714 LOGD("Found Back Aux Camera: i: %d idx: %d", i, idx);
1715 memcpy(temp_dev_name[idx++],g_cam_ctrl.video_dev_name[i],
1716 MM_CAMERA_DEV_NAME_LEN);
1717 }
1718 }
1719 }
1720
1721 if (is_dual_cam || !is_aux_cam_exposed) {
1722 /* then save the front cameras info*/
1723 for (i = 0; i < num_cam; i++) {
1724 if ((g_cam_ctrl.info[i].facing == CAMERA_FACING_FRONT) &&
1725 (g_cam_ctrl.cam_type[i] == CAM_TYPE_MAIN)) {
1726 temp_info[idx] = g_cam_ctrl.info[i];
1727 temp_type[idx] = g_cam_ctrl.cam_type[i];
1728 temp_mode[idx] = g_cam_ctrl.cam_mode[i];
1729 temp_is_yuv[idx] = g_cam_ctrl.is_yuv[i];
1730 LOGD("Found Front Main Camera: i: %d idx: %d", i, idx);
1731 memcpy(temp_dev_name[idx++],g_cam_ctrl.video_dev_name[i],
1732 MM_CAMERA_DEV_NAME_LEN);
1733 }
1734 }
1735 }
1736
1737 //TODO: Need to revisit this logic if front AUX is available.
1738 /* save the aux front cameras info*/
1739 for (i = 0; i < num_cam; i++) {
1740 if ((g_cam_ctrl.info[i].facing == CAMERA_FACING_FRONT) &&
1741 (g_cam_ctrl.cam_type[i] == CAM_TYPE_AUX)) {
1742 temp_info[idx] = g_cam_ctrl.info[i];
1743 temp_type[idx] = g_cam_ctrl.cam_type[i];
1744 temp_mode[idx] = g_cam_ctrl.cam_mode[i];
1745 temp_is_yuv[idx] = g_cam_ctrl.is_yuv[i];
1746 LOGD("Found Front Aux Camera: i: %d idx: %d", i, idx);
1747 memcpy(temp_dev_name[idx++],g_cam_ctrl.video_dev_name[i],
1748 MM_CAMERA_DEV_NAME_LEN);
1749 }
1750 }
1751
1752 if (idx <= num_cam) {
1753 memcpy(g_cam_ctrl.info, temp_info, sizeof(temp_info));
1754 memcpy(g_cam_ctrl.cam_type, temp_type, sizeof(temp_type));
1755 memcpy(g_cam_ctrl.cam_mode, temp_mode, sizeof(temp_mode));
1756 memcpy(g_cam_ctrl.is_yuv, temp_is_yuv, sizeof(temp_is_yuv));
1757 memcpy(g_cam_ctrl.video_dev_name, temp_dev_name, sizeof(temp_dev_name));
1758 //Set num cam based on the cameras exposed finally via dual/aux properties.
1759 g_cam_ctrl.num_cam = idx;
1760 for (i = 0; i < idx; i++) {
1761 LOGI("Camera id: %d facing: %d, type: %d is_yuv: %d",
1762 i, g_cam_ctrl.info[i].facing, g_cam_ctrl.cam_type[i], g_cam_ctrl.is_yuv[i]);
1763 }
1764 }
1765 LOGI("Number of cameras %d sorted %d", num_cam, idx);
1766 return;
1767 }
1768
1769 /*===========================================================================
1770 * FUNCTION : get_num_of_cameras
1771 *
1772 * DESCRIPTION: get number of cameras
1773 *
1774 * PARAMETERS :
1775 *
1776 * RETURN : number of cameras supported
1777 *==========================================================================*/
get_num_of_cameras()1778 uint8_t get_num_of_cameras()
1779 {
1780 int rc = 0;
1781 int dev_fd = -1;
1782 struct media_device_info mdev_info;
1783 int num_media_devices = 0;
1784 int8_t num_cameras = 0;
1785 char subdev_name[32];
1786 char prop[PROPERTY_VALUE_MAX];
1787 #ifdef DAEMON_PRESENT
1788 int32_t sd_fd = -1;
1789 struct sensor_init_cfg_data cfg;
1790 #endif
1791
1792 LOGD("E");
1793
1794 property_get("vold.decrypt", prop, "0");
1795 int decrypt = atoi(prop);
1796 if (decrypt == 1)
1797 return 0;
1798 pthread_mutex_lock(&g_intf_lock);
1799
1800 memset (&g_cam_ctrl, 0, sizeof (g_cam_ctrl));
1801 #ifndef DAEMON_PRESENT
1802 if (mm_camera_load_shim_lib() < 0) {
1803 LOGE ("Failed to module shim library");
1804 return 0;
1805 }
1806 #endif /* DAEMON_PRESENT */
1807
1808 while (1) {
1809 uint32_t num_entities = 1U;
1810 char dev_name[32];
1811
1812 snprintf(dev_name, sizeof(dev_name), "/dev/media%d", num_media_devices);
1813 dev_fd = open(dev_name, O_RDWR | O_NONBLOCK);
1814 if (dev_fd < 0) {
1815 LOGD("Done discovering media devices\n");
1816 break;
1817 }
1818 num_media_devices++;
1819 rc = ioctl(dev_fd, MEDIA_IOC_DEVICE_INFO, &mdev_info);
1820 if (rc < 0) {
1821 LOGE("Error: ioctl media_dev failed: %s\n", strerror(errno));
1822 close(dev_fd);
1823 dev_fd = -1;
1824 break;
1825 }
1826
1827 if (strncmp(mdev_info.model, MSM_CONFIGURATION_NAME,
1828 sizeof(mdev_info.model)) != 0) {
1829 close(dev_fd);
1830 dev_fd = -1;
1831 continue;
1832 }
1833
1834 while (1) {
1835 struct media_entity_desc entity;
1836 memset(&entity, 0, sizeof(entity));
1837 entity.id = num_entities++;
1838 LOGD("entity id %d", entity.id);
1839 rc = ioctl(dev_fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
1840 if (rc < 0) {
1841 LOGD("Done enumerating media entities");
1842 rc = 0;
1843 break;
1844 }
1845 LOGD("entity name %s type %d group id %d",
1846 entity.name, entity.type, entity.group_id);
1847 if (entity.type == MEDIA_ENT_T_V4L2_SUBDEV &&
1848 entity.group_id == MSM_CAMERA_SUBDEV_SENSOR_INIT) {
1849 snprintf(subdev_name, sizeof(dev_name), "/dev/%s", entity.name);
1850 break;
1851 }
1852 }
1853 close(dev_fd);
1854 dev_fd = -1;
1855 }
1856
1857 #ifdef DAEMON_PRESENT
1858 /* Open sensor_init subdev */
1859 sd_fd = open(subdev_name, O_RDWR);
1860 if (sd_fd < 0) {
1861 LOGE("Open sensor_init subdev failed");
1862 return FALSE;
1863 }
1864
1865 cfg.cfgtype = CFG_SINIT_PROBE_WAIT_DONE;
1866 cfg.cfg.setting = NULL;
1867 if (ioctl(sd_fd, VIDIOC_MSM_SENSOR_INIT_CFG, &cfg) < 0) {
1868 LOGE("failed");
1869 }
1870 close(sd_fd);
1871 #endif
1872
1873
1874 num_media_devices = 0;
1875 while (1) {
1876 uint32_t num_entities = 1U;
1877 char dev_name[32];
1878
1879 snprintf(dev_name, sizeof(dev_name), "/dev/media%d", num_media_devices);
1880 dev_fd = open(dev_name, O_RDWR | O_NONBLOCK);
1881 if (dev_fd < 0) {
1882 LOGD("Done discovering media devices: %s\n", strerror(errno));
1883 break;
1884 }
1885 num_media_devices++;
1886 memset(&mdev_info, 0, sizeof(mdev_info));
1887 rc = ioctl(dev_fd, MEDIA_IOC_DEVICE_INFO, &mdev_info);
1888 if (rc < 0) {
1889 LOGE("Error: ioctl media_dev failed: %s\n", strerror(errno));
1890 close(dev_fd);
1891 dev_fd = -1;
1892 num_cameras = 0;
1893 break;
1894 }
1895
1896 if(strncmp(mdev_info.model, MSM_CAMERA_NAME, sizeof(mdev_info.model)) != 0) {
1897 close(dev_fd);
1898 dev_fd = -1;
1899 continue;
1900 }
1901
1902 while (1) {
1903 struct media_entity_desc entity;
1904 memset(&entity, 0, sizeof(entity));
1905 entity.id = num_entities++;
1906 rc = ioctl(dev_fd, MEDIA_IOC_ENUM_ENTITIES, &entity);
1907 if (rc < 0) {
1908 LOGD("Done enumerating media entities\n");
1909 rc = 0;
1910 break;
1911 }
1912 if(entity.type == MEDIA_ENT_T_DEVNODE_V4L && entity.group_id == QCAMERA_VNODE_GROUP_ID) {
1913 strlcpy(g_cam_ctrl.video_dev_name[num_cameras],
1914 entity.name, sizeof(entity.name));
1915 LOGI("dev_info[id=%d,name='%s']\n",
1916 (int)num_cameras, g_cam_ctrl.video_dev_name[num_cameras]);
1917 num_cameras++;
1918 break;
1919 }
1920 }
1921 close(dev_fd);
1922 dev_fd = -1;
1923 if (num_cameras >= MM_CAMERA_MAX_NUM_SENSORS) {
1924 LOGW("Maximum number of camera reached %d", num_cameras);
1925 break;
1926 }
1927 }
1928 g_cam_ctrl.num_cam = num_cameras;
1929
1930 get_sensor_info();
1931 sort_camera_info(g_cam_ctrl.num_cam);
1932 /* unlock the mutex */
1933 pthread_mutex_unlock(&g_intf_lock);
1934 LOGI("num_cameras=%d\n", (int)g_cam_ctrl.num_cam);
1935 return(uint8_t)g_cam_ctrl.num_cam;
1936 }
1937
1938 /*===========================================================================
1939 * FUNCTION : mm_camera_intf_process_advanced_capture
1940 *
1941 * DESCRIPTION: Configures channel advanced capture mode
1942 *
1943 * PARAMETERS :
1944 * @camera_handle: camera handle
1945 * @type : advanced capture type
1946 * @ch_id : channel handle
1947 * @trigger : 1 for start and 0 for cancel/stop
1948 * @value : input capture configaration
1949 *
1950 * RETURN : int32_t type of status
1951 * 0 -- success
1952 * -1 -- failure
1953 *==========================================================================*/
mm_camera_intf_process_advanced_capture(uint32_t camera_handle,uint32_t ch_id,mm_camera_advanced_capture_t type,int8_t trigger,void * in_value)1954 static int32_t mm_camera_intf_process_advanced_capture(uint32_t camera_handle,
1955 uint32_t ch_id, mm_camera_advanced_capture_t type,
1956 int8_t trigger, void *in_value)
1957 {
1958 int32_t rc = -1;
1959 mm_camera_obj_t * my_obj = NULL;
1960
1961 LOGD("E camera_handler = %d,ch_id = %d",
1962 camera_handle, ch_id);
1963 pthread_mutex_lock(&g_intf_lock);
1964 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
1965
1966 if(my_obj) {
1967 pthread_mutex_lock(&my_obj->cam_lock);
1968 pthread_mutex_unlock(&g_intf_lock);
1969 rc = mm_camera_channel_advanced_capture(my_obj, ch_id, type,
1970 (uint32_t)trigger, in_value);
1971 } else {
1972 pthread_mutex_unlock(&g_intf_lock);
1973 }
1974 LOGD("X ");
1975 return rc;
1976 }
1977
1978 /*===========================================================================
1979 * FUNCTION : mm_camera_intf_register_stream_buf_cb
1980 *
1981 * DESCRIPTION: Register special callback for stream buffer
1982 *
1983 * PARAMETERS :
1984 * @camera_handle: camera handle
1985 * @ch_id : channel handle
1986 * @stream_id : stream handle
1987 * @buf_cb : callback function
1988 * @buf_type :SYNC/ASYNC
1989 * @userdata : userdata pointer
1990 *
1991 * RETURN : int32_t type of status
1992 * 0 -- success
1993 * 1 -- failure
1994 *==========================================================================*/
mm_camera_intf_register_stream_buf_cb(uint32_t camera_handle,uint32_t ch_id,uint32_t stream_id,mm_camera_buf_notify_t buf_cb,mm_camera_stream_cb_type cb_type,void * userdata)1995 static int32_t mm_camera_intf_register_stream_buf_cb(uint32_t camera_handle,
1996 uint32_t ch_id, uint32_t stream_id, mm_camera_buf_notify_t buf_cb,
1997 mm_camera_stream_cb_type cb_type, void *userdata)
1998 {
1999 int32_t rc = 0;
2000 mm_camera_obj_t * my_obj = NULL;
2001
2002 LOGD("E handle = %u ch_id = %u",
2003 camera_handle, ch_id);
2004
2005 pthread_mutex_lock(&g_intf_lock);
2006 my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
2007
2008 if(my_obj) {
2009 pthread_mutex_lock(&my_obj->cam_lock);
2010 pthread_mutex_unlock(&g_intf_lock);
2011 rc = mm_camera_reg_stream_buf_cb(my_obj, ch_id, stream_id,
2012 buf_cb, cb_type, userdata);
2013 } else {
2014 pthread_mutex_unlock(&g_intf_lock);
2015 }
2016 return (int32_t)rc;
2017 }
2018
get_cam_info(uint32_t camera_id,cam_sync_type_t * pCamType)2019 struct camera_info *get_cam_info(uint32_t camera_id, cam_sync_type_t *pCamType)
2020 {
2021 *pCamType = g_cam_ctrl.cam_type[camera_id];
2022 return &g_cam_ctrl.info[camera_id];
2023 }
2024
is_yuv_sensor(uint32_t camera_id)2025 uint8_t is_yuv_sensor(uint32_t camera_id)
2026 {
2027 return g_cam_ctrl.is_yuv[camera_id];
2028 }
2029
2030 /* camera ops v-table */
2031 static mm_camera_ops_t mm_camera_ops = {
2032 .query_capability = mm_camera_intf_query_capability,
2033 .register_event_notify = mm_camera_intf_register_event_notify,
2034 .close_camera = mm_camera_intf_close,
2035 .set_parms = mm_camera_intf_set_parms,
2036 .get_parms = mm_camera_intf_get_parms,
2037 .do_auto_focus = mm_camera_intf_do_auto_focus,
2038 .cancel_auto_focus = mm_camera_intf_cancel_auto_focus,
2039 .prepare_snapshot = mm_camera_intf_prepare_snapshot,
2040 .start_zsl_snapshot = mm_camera_intf_start_zsl_snapshot,
2041 .stop_zsl_snapshot = mm_camera_intf_stop_zsl_snapshot,
2042 .map_buf = mm_camera_intf_map_buf,
2043 .map_bufs = mm_camera_intf_map_bufs,
2044 .unmap_buf = mm_camera_intf_unmap_buf,
2045 .add_channel = mm_camera_intf_add_channel,
2046 .delete_channel = mm_camera_intf_del_channel,
2047 .get_bundle_info = mm_camera_intf_get_bundle_info,
2048 .add_stream = mm_camera_intf_add_stream,
2049 .link_stream = mm_camera_intf_link_stream,
2050 .delete_stream = mm_camera_intf_del_stream,
2051 .config_stream = mm_camera_intf_config_stream,
2052 .qbuf = mm_camera_intf_qbuf,
2053 .cancel_buffer = mm_camera_intf_cancel_buf,
2054 .get_queued_buf_count = mm_camera_intf_get_queued_buf_count,
2055 .map_stream_buf = mm_camera_intf_map_stream_buf,
2056 .map_stream_bufs = mm_camera_intf_map_stream_bufs,
2057 .unmap_stream_buf = mm_camera_intf_unmap_stream_buf,
2058 .set_stream_parms = mm_camera_intf_set_stream_parms,
2059 .get_stream_parms = mm_camera_intf_get_stream_parms,
2060 .start_channel = mm_camera_intf_start_channel,
2061 .stop_channel = mm_camera_intf_stop_channel,
2062 .request_super_buf = mm_camera_intf_request_super_buf,
2063 .cancel_super_buf_request = mm_camera_intf_cancel_super_buf_request,
2064 .flush_super_buf_queue = mm_camera_intf_flush_super_buf_queue,
2065 .configure_notify_mode = mm_camera_intf_configure_notify_mode,
2066 .process_advanced_capture = mm_camera_intf_process_advanced_capture,
2067 .get_session_id = mm_camera_intf_get_session_id,
2068 .sync_related_sensors = mm_camera_intf_sync_related_sensors,
2069 .flush = mm_camera_intf_flush,
2070 .register_stream_buf_cb = mm_camera_intf_register_stream_buf_cb
2071 };
2072
2073 /*===========================================================================
2074 * FUNCTION : camera_open
2075 *
2076 * DESCRIPTION: open a camera by camera index
2077 *
2078 * PARAMETERS :
2079 * @camera_idx : camera index. should within range of 0 to num_of_cameras
2080 * @camera_vtbl : ptr to a virtual table containing camera handle and operation table.
2081 *
2082 * RETURN : int32_t type of status
2083 * 0 -- success
2084 * non-zero error code -- failure
2085 *==========================================================================*/
camera_open(uint8_t camera_idx,mm_camera_vtbl_t ** camera_vtbl)2086 int32_t camera_open(uint8_t camera_idx, mm_camera_vtbl_t **camera_vtbl)
2087 {
2088 int32_t rc = 0;
2089 mm_camera_obj_t *cam_obj = NULL;
2090
2091 #ifdef QCAMERA_REDEFINE_LOG
2092 mm_camera_set_dbg_log_properties();
2093 #endif
2094
2095 LOGD("E camera_idx = %d\n", camera_idx);
2096 if (camera_idx >= g_cam_ctrl.num_cam) {
2097 LOGE("Invalid camera_idx (%d)", camera_idx);
2098 return -EINVAL;
2099 }
2100
2101 pthread_mutex_lock(&g_intf_lock);
2102 /* opened already */
2103 if(NULL != g_cam_ctrl.cam_obj[camera_idx]) {
2104 /* Add reference */
2105 g_cam_ctrl.cam_obj[camera_idx]->ref_count++;
2106 pthread_mutex_unlock(&g_intf_lock);
2107 LOGD("opened alreadyn");
2108 *camera_vtbl = &g_cam_ctrl.cam_obj[camera_idx]->vtbl;
2109 return rc;
2110 }
2111
2112 cam_obj = (mm_camera_obj_t *)malloc(sizeof(mm_camera_obj_t));
2113 if(NULL == cam_obj) {
2114 pthread_mutex_unlock(&g_intf_lock);
2115 LOGE("no mem");
2116 return -EINVAL;
2117 }
2118
2119 /* initialize camera obj */
2120 memset(cam_obj, 0, sizeof(mm_camera_obj_t));
2121 cam_obj->ctrl_fd = -1;
2122 cam_obj->ds_fd = -1;
2123 cam_obj->ref_count++;
2124 cam_obj->my_hdl = mm_camera_util_generate_handler(camera_idx);
2125 cam_obj->vtbl.camera_handle = cam_obj->my_hdl; /* set handler */
2126 cam_obj->vtbl.ops = &mm_camera_ops;
2127 pthread_mutex_init(&cam_obj->cam_lock, NULL);
2128 /* unlock global interface lock, if not, in dual camera use case,
2129 * current open will block operation of another opened camera obj*/
2130 pthread_mutex_lock(&cam_obj->cam_lock);
2131 pthread_mutex_unlock(&g_intf_lock);
2132
2133 rc = mm_camera_open(cam_obj);
2134
2135 pthread_mutex_lock(&g_intf_lock);
2136 if (rc != 0) {
2137 LOGE("mm_camera_open err = %d", rc);
2138 pthread_mutex_destroy(&cam_obj->cam_lock);
2139 g_cam_ctrl.cam_obj[camera_idx] = NULL;
2140 free(cam_obj);
2141 cam_obj = NULL;
2142 pthread_mutex_unlock(&g_intf_lock);
2143 *camera_vtbl = NULL;
2144 return rc;
2145 } else {
2146 LOGD("Open succeded\n");
2147 g_cam_ctrl.cam_obj[camera_idx] = cam_obj;
2148 pthread_mutex_unlock(&g_intf_lock);
2149 *camera_vtbl = &cam_obj->vtbl;
2150 return 0;
2151 }
2152 }
2153
2154 /*===========================================================================
2155 * FUNCTION : mm_camera_load_shim_lib
2156 *
2157 * DESCRIPTION: Load shim layer library
2158 *
2159 * PARAMETERS :
2160 *
2161 * RETURN : status of load shim library
2162 *==========================================================================*/
mm_camera_load_shim_lib()2163 int32_t mm_camera_load_shim_lib()
2164 {
2165 const char* error = NULL;
2166 void *qdaemon_lib = NULL;
2167
2168 LOGD("E");
2169 qdaemon_lib = dlopen(SHIMLAYER_LIB, RTLD_NOW);
2170 if (!qdaemon_lib) {
2171 error = dlerror();
2172 LOGE("dlopen failed with error %s", error ? error : "");
2173 return -1;
2174 }
2175
2176 *(void **)&mm_camera_shim_module_init =
2177 dlsym(qdaemon_lib, "mct_shimlayer_process_module_init");
2178 if (!mm_camera_shim_module_init) {
2179 error = dlerror();
2180 LOGE("dlsym failed with error code %s", error ? error: "");
2181 dlclose(qdaemon_lib);
2182 return -1;
2183 }
2184
2185 return mm_camera_shim_module_init(&g_cam_ctrl.cam_shim_ops);
2186 }
2187
2188 /*===========================================================================
2189 * FUNCTION : mm_camera_module_open_session
2190 *
2191 * DESCRIPTION: wrapper function to call shim layer API to open session.
2192 *
2193 * PARAMETERS :
2194 * @sessionid : sessionID to open session
2195 * @evt_cb : Event callback function
2196 *
2197 * RETURN : int32_t type of status
2198 * 0 -- success
2199 * non-zero error code -- failure
2200 *==========================================================================*/
mm_camera_module_open_session(int sessionid,mm_camera_shim_event_handler_func evt_cb)2201 cam_status_t mm_camera_module_open_session(int sessionid,
2202 mm_camera_shim_event_handler_func evt_cb)
2203 {
2204 cam_status_t rc = -1;
2205 if(g_cam_ctrl.cam_shim_ops.mm_camera_shim_open_session) {
2206 rc = g_cam_ctrl.cam_shim_ops.mm_camera_shim_open_session(
2207 sessionid, evt_cb);
2208 }
2209 return rc;
2210 }
2211
2212 /*===========================================================================
2213 * FUNCTION : mm_camera_module_close_session
2214 *
2215 * DESCRIPTION: wrapper function to call shim layer API to close session
2216 *
2217 * PARAMETERS :
2218 * @sessionid : sessionID to open session
2219 *
2220 * RETURN : int32_t type of status
2221 * 0 -- success
2222 * non-zero error code -- failure
2223 *==========================================================================*/
mm_camera_module_close_session(int session)2224 int32_t mm_camera_module_close_session(int session)
2225 {
2226 int32_t rc = -1;
2227 if(g_cam_ctrl.cam_shim_ops.mm_camera_shim_close_session) {
2228 rc = g_cam_ctrl.cam_shim_ops.mm_camera_shim_close_session(session);
2229 }
2230 return rc;
2231 }
2232
2233 /*===========================================================================
2234 * FUNCTION : mm_camera_module_open_session
2235 *
2236 * DESCRIPTION: wrapper function to call shim layer API
2237 *
2238 * PARAMETERS :
2239 * @sessionid : sessionID to open session
2240 * @evt_cb : Event callback function
2241 *
2242 * RETURN : int32_t type of status
2243 * 0 -- success
2244 * non-zero error code -- failure
2245 *==========================================================================*/
mm_camera_module_send_cmd(cam_shim_packet_t * event)2246 int32_t mm_camera_module_send_cmd(cam_shim_packet_t *event)
2247 {
2248 int32_t rc = -1;
2249 if(g_cam_ctrl.cam_shim_ops.mm_camera_shim_send_cmd) {
2250 rc = g_cam_ctrl.cam_shim_ops.mm_camera_shim_send_cmd(event);
2251 }
2252 return rc;
2253 }
2254
2255 /*===========================================================================
2256 * FUNCTION : mm_camera_module_event_handler
2257 *
2258 * DESCRIPTION: call back function for shim layer
2259 *
2260 * PARAMETERS :
2261 *
2262 * RETURN : status of call back function
2263 *==========================================================================*/
mm_camera_module_event_handler(uint32_t session_id,cam_event_t * event)2264 int mm_camera_module_event_handler(uint32_t session_id, cam_event_t *event)
2265 {
2266 if (!event) {
2267 LOGE("null event");
2268 return FALSE;
2269 }
2270 mm_camera_event_t evt;
2271
2272 LOGD("session_id:%d, cmd:0x%x", session_id, event->server_event_type);
2273 memset(&evt, 0, sizeof(mm_camera_event_t));
2274
2275 evt = *event;
2276 mm_camera_obj_t *my_obj =
2277 mm_camera_util_get_camera_by_session_id(session_id);
2278 if (!my_obj) {
2279 LOGE("my_obj:%p", my_obj);
2280 return FALSE;
2281 }
2282 switch( evt.server_event_type) {
2283 case CAM_EVENT_TYPE_DAEMON_PULL_REQ:
2284 case CAM_EVENT_TYPE_CAC_DONE:
2285 case CAM_EVENT_TYPE_DAEMON_DIED:
2286 case CAM_EVENT_TYPE_INT_TAKE_JPEG:
2287 case CAM_EVENT_TYPE_INT_TAKE_RAW:
2288 mm_camera_enqueue_evt(my_obj, &evt);
2289 break;
2290 default:
2291 LOGE("cmd:%x from shim layer is not handled", evt.server_event_type);
2292 break;
2293 }
2294 return TRUE;
2295 }
2296
2297