From 6616278131edd80a12545085e06ee6b0e0a0a788 Mon Sep 17 00:00:00 2001 From: Prateek Chaubey Date: Sun, 7 Jan 2018 20:55:14 +0530 Subject: msm8996-common: zuk: Import OSS Camera HAL Tag: LA.HB.1.3.2-32600-8x96.0 Signed-off-by: Davide Garberi --- .../stack/mm-camera-interface/inc/mm_camera.h | 767 +++++++++++++++++++++ .../stack/mm-camera-interface/inc/mm_camera_dbg.h | 134 ++++ .../stack/mm-camera-interface/inc/mm_camera_sock.h | 76 ++ 3 files changed, 977 insertions(+) create mode 100644 camera/QCamera2/stack/mm-camera-interface/inc/mm_camera.h create mode 100644 camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_dbg.h create mode 100644 camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_sock.h (limited to 'camera/QCamera2/stack/mm-camera-interface/inc') diff --git a/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera.h b/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera.h new file mode 100644 index 0000000..971ae74 --- /dev/null +++ b/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera.h @@ -0,0 +1,767 @@ +/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef __MM_CAMERA_H__ +#define __MM_CAMERA_H__ + +// System dependencies +#include + +// Camera dependencies +#include "camera_common.h" +#include "cam_semaphore.h" +#include "mm_camera_interface.h" + +/********************************************************************************** +* Data structure declarations +***********************************************************************************/ +/* num of callbacks allowed for an event type */ +#define MM_CAMERA_EVT_ENTRY_MAX 4 +/* num of data callbacks allowed in a stream obj */ +#define MM_CAMERA_STREAM_BUF_CB_MAX 4 +/* num of data poll threads allowed in a channel obj */ +#define MM_CAMERA_CHANNEL_POLL_THREAD_MAX 1 + +#define MM_CAMERA_DEV_NAME_LEN 32 +#define MM_CAMERA_DEV_OPEN_TRIES 20 +#define MM_CAMERA_DEV_OPEN_RETRY_SLEEP 20 +#define THREAD_NAME_SIZE 15 + +/* Future frame idx, large enough to make sure capture +* settings can be applied and small enough to still capture an image */ +#define MM_CAMERA_MAX_FUTURE_FRAME_WAIT 100 +#define WAIT_TIMEOUT 5 + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + +#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) + +struct mm_channel; +struct mm_stream; +struct mm_camera_obj; + +typedef int64_t nsecs_t; + +typedef enum +{ + MM_CAMERA_CMD_TYPE_DATA_CB, /* dataB CMD */ + MM_CAMERA_CMD_TYPE_EVT_CB, /* evtCB CMD */ + MM_CAMERA_CMD_TYPE_EXIT, /* EXIT */ + MM_CAMERA_CMD_TYPE_REQ_DATA_CB,/* request data */ + MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB, /* superbuf dataB CMD */ + MM_CAMERA_CMD_TYPE_CONFIG_NOTIFY, /* configure notify mode */ + MM_CAMERA_CMD_TYPE_START_ZSL, /* start zsl snapshot for channel */ + MM_CAMERA_CMD_TYPE_STOP_ZSL, /* stop zsl snapshot for channel */ + MM_CAMERA_CMD_TYPE_FLUSH_QUEUE, /* flush queue */ + MM_CAMERA_CMD_TYPE_GENERAL, /* general cmd */ + MM_CAMERA_CMD_TYPE_MAX +} mm_camera_cmdcb_type_t; + +typedef struct { + uint32_t stream_id; + uint32_t frame_idx; + uint32_t flags; + mm_camera_buf_def_t *buf; /* ref to buf */ +} mm_camera_buf_info_t; + +typedef enum { + MM_CAMERA_GENERIC_CMD_TYPE_AE_BRACKETING, + MM_CAMERA_GENERIC_CMD_TYPE_AF_BRACKETING, + MM_CAMERA_GENERIC_CMD_TYPE_FLASH_BRACKETING, + MM_CAMERA_GENERIC_CMD_TYPE_ZOOM_1X, + MM_CAMERA_GENERIC_CMD_TYPE_CAPTURE_SETTING, +} mm_camera_generic_cmd_type_t; + +typedef struct { + mm_camera_generic_cmd_type_t type; + uint32_t payload[32]; + union { + cam_capture_frame_config_t frame_config; + }; +} mm_camera_generic_cmd_t; + +typedef struct { + uint32_t frame_idx; + cam_stream_type_t stream_type; +} mm_camera_flush_cmd_t; + +typedef struct { + mm_camera_cmdcb_type_t cmd_type; + union { + mm_camera_buf_info_t buf; /* frame buf if dataCB */ + mm_camera_event_t evt; /* evt if evtCB */ + mm_camera_super_buf_t superbuf; /* superbuf if superbuf dataCB*/ + mm_camera_req_buf_t req_buf; /* num of buf requested */ + mm_camera_flush_cmd_t flush_cmd; /* frame idx boundary for flush superbuf queue*/ + mm_camera_super_buf_notify_mode_t notify_mode; /* notification mode */ + mm_camera_generic_cmd_t gen_cmd; + } u; +} mm_camera_cmdcb_t; + +typedef void (*mm_camera_cmd_cb_t)(mm_camera_cmdcb_t * cmd_cb, void* user_data); + +typedef struct { + uint8_t is_active; /*indicates whether thread is active or not */ + cam_queue_t cmd_queue; /* cmd queue (queuing dataCB, asyncCB, or exitCMD) */ + pthread_t cmd_pid; /* cmd thread ID */ + cam_semaphore_t cmd_sem; /* semaphore for cmd thread */ + cam_semaphore_t sync_sem; /* semaphore for synchronization with cmd thread */ + mm_camera_cmd_cb_t cb; /* cb for cmd */ + void* user_data; /* user_data for cb */ + char threadName[THREAD_NAME_SIZE]; +} mm_camera_cmd_thread_t; + +typedef enum { + MM_CAMERA_POLL_TYPE_EVT, + MM_CAMERA_POLL_TYPE_DATA, + MM_CAMERA_POLL_TYPE_MAX +} mm_camera_poll_thread_type_t; + +/* function ptr defined for poll notify CB, + * registered at poll thread with poll fd */ +typedef void (*mm_camera_poll_notify_t)(void *user_data); + +typedef struct { + int32_t fd; + mm_camera_poll_notify_t notify_cb; + uint32_t handler; + void* user_data; +} mm_camera_poll_entry_t; + +typedef struct { + mm_camera_poll_thread_type_t poll_type; + /* array to store poll fd and cb info + * for MM_CAMERA_POLL_TYPE_EVT, only index 0 is valid; + * for MM_CAMERA_POLL_TYPE_DATA, depends on valid stream fd */ + mm_camera_poll_entry_t poll_entries[MAX_STREAM_NUM_IN_BUNDLE]; + int32_t pfds[2]; + pthread_t pid; + int32_t state; + int timeoutms; + uint32_t cmd; + struct pollfd poll_fds[MAX_STREAM_NUM_IN_BUNDLE + 1]; + uint8_t num_fds; + pthread_mutex_t mutex; + pthread_cond_t cond_v; + int32_t status; + char threadName[THREAD_NAME_SIZE]; + //void *my_obj; +} mm_camera_poll_thread_t; + +/* mm_stream */ +typedef enum { + MM_STREAM_STATE_NOTUSED = 0, /* not used */ + MM_STREAM_STATE_INITED, /* inited */ + MM_STREAM_STATE_ACQUIRED, /* acquired, fd opened */ + MM_STREAM_STATE_CFG, /* fmt & dim configured */ + MM_STREAM_STATE_BUFFED, /* buf allocated */ + MM_STREAM_STATE_REG, /* buf regged, stream off */ + MM_STREAM_STATE_ACTIVE, /* active */ + MM_STREAM_STATE_MAX +} mm_stream_state_type_t; + +typedef enum { + MM_STREAM_EVT_ACQUIRE, + MM_STREAM_EVT_RELEASE, + MM_STREAM_EVT_SET_FMT, + MM_STREAM_EVT_GET_BUF, + MM_STREAM_EVT_PUT_BUF, + MM_STREAM_EVT_REG_BUF, + MM_STREAM_EVT_UNREG_BUF, + MM_STREAM_EVT_START, + MM_STREAM_EVT_STOP, + MM_STREAM_EVT_QBUF, + MM_STREAM_EVT_SET_PARM, + MM_STREAM_EVT_GET_PARM, + MM_STREAM_EVT_DO_ACTION, + MM_STREAM_EVT_GET_QUEUED_BUF_COUNT, + MM_STREAM_EVT_MAX +} mm_stream_evt_type_t; + +typedef struct { + mm_camera_buf_notify_t cb; + void *user_data; + /* cb_count = -1: infinite + * cb_count > 0: register only for required times */ + int8_t cb_count; + mm_camera_stream_cb_type cb_type; +} mm_stream_data_cb_t; + +typedef struct { + /* buf reference count */ + uint8_t buf_refcnt; + + /* This flag is to indicate if after allocation, + * the corresponding buf needs to qbuf into kernel + * (e.g. for preview usecase, display needs to hold two bufs, + * so no need to qbuf these two bufs initially) */ + uint8_t initial_reg_flag; + + /* indicate if buf is in kernel(1) or client(0) */ + uint8_t in_kernel; + /*indicate if this buffer is mapped to daemon*/ + int8_t map_status; +} mm_stream_buf_status_t; + +typedef struct mm_stream { + uint32_t my_hdl; /* local stream id */ + uint32_t server_stream_id; /* stream id from server */ + int32_t fd; + mm_stream_state_type_t state; + + /* stream info*/ + cam_stream_info_t *stream_info; + + /* padding info */ + cam_padding_info_t padding_info; + + /* offset */ + cam_frame_len_offset_t frame_offset; + + pthread_mutex_t cmd_lock; /* lock to protect cmd_thread */ + mm_camera_cmd_thread_t cmd_thread; + + /* dataCB registered on this stream obj */ + pthread_mutex_t cb_lock; /* cb lock to protect buf_cb */ + mm_stream_data_cb_t buf_cb[MM_CAMERA_STREAM_BUF_CB_MAX]; + + /* stream buffer management */ + pthread_mutex_t buf_lock; + uint8_t buf_num; /* num of buffers allocated */ + mm_camera_buf_def_t* buf; /* ptr to buf array */ + mm_stream_buf_status_t buf_status[CAM_MAX_NUM_BUFS_PER_STREAM]; /* ptr to buf status array */ + + uint8_t plane_buf_num; /* num of plane buffers allocated Used only in Batch mode*/ + mm_camera_buf_def_t *plane_buf; /*Pointer to plane buffer array Used only in Batch mode */ + int32_t cur_buf_idx; /* Current container buffer active filling. Used only in Batch mode*/ + uint8_t cur_bufs_staged; /*Number of plane buf freed by HAL for this usr buf*/ + + + /* reference to parent channel_obj */ + struct mm_channel* ch_obj; + + uint8_t is_bundled; /* flag if stream is bundled */ + + /* reference to linked channel_obj */ + struct mm_channel* linked_obj; + struct mm_stream * linked_stream; /* original stream */ + uint8_t is_linked; /* flag if stream is linked */ + + mm_camera_stream_mem_vtbl_t mem_vtbl; /* mem ops tbl */ + + mm_camera_map_unmap_ops_tbl_t map_ops; + + int8_t queued_buffer_count; + + /*latest timestamp of this stream frame received & last frameID*/ + uint32_t prev_frameID; + nsecs_t prev_timestamp; + + /* Need to wait for buffer mapping before stream-on*/ + pthread_cond_t buf_cond; +} mm_stream_t; + +/* mm_channel */ +typedef enum { + MM_CHANNEL_STATE_NOTUSED = 0, /* not used */ + MM_CHANNEL_STATE_STOPPED, /* stopped */ + MM_CHANNEL_STATE_ACTIVE, /* active, at least one stream active */ + MM_CHANNEL_STATE_PAUSED, /* paused */ + MM_CHANNEL_STATE_MAX +} mm_channel_state_type_t; + +typedef enum { + MM_CHANNEL_EVT_ADD_STREAM, + MM_CHANNEL_EVT_DEL_STREAM, + MM_CHANNEL_EVT_LINK_STREAM, + MM_CHANNEL_EVT_CONFIG_STREAM, + MM_CHANNEL_EVT_GET_BUNDLE_INFO, + MM_CHANNEL_EVT_START, + MM_CHANNEL_EVT_STOP, + MM_CHANNEL_EVT_PAUSE, + MM_CHANNEL_EVT_RESUME, + MM_CHANNEL_EVT_REQUEST_SUPER_BUF, + MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF, + MM_CHANNEL_EVT_FLUSH_SUPER_BUF_QUEUE, + MM_CHANNEL_EVT_CONFIG_NOTIFY_MODE, + MM_CHANNEL_EVT_START_ZSL_SNAPSHOT, + MM_CHANNEL_EVT_STOP_ZSL_SNAPSHOT, + MM_CHANNEL_EVT_MAP_STREAM_BUF, + MM_CHANNEL_EVT_UNMAP_STREAM_BUF, + MM_CHANNEL_EVT_SET_STREAM_PARM, + MM_CHANNEL_EVT_GET_STREAM_PARM, + MM_CHANNEL_EVT_DO_STREAM_ACTION, + MM_CHANNEL_EVT_DELETE, + MM_CHANNEL_EVT_AF_BRACKETING, + MM_CHANNEL_EVT_AE_BRACKETING, + MM_CHANNEL_EVT_FLASH_BRACKETING, + MM_CHANNEL_EVT_ZOOM_1X, + MM_CAMERA_EVT_CAPTURE_SETTING, + MM_CHANNEL_EVT_GET_STREAM_QUEUED_BUF_COUNT, + MM_CHANNEL_EVT_MAP_STREAM_BUFS, + MM_CHANNEL_EVT_REG_STREAM_BUF_CB +} mm_channel_evt_type_t; + +typedef struct { + uint32_t stream_id; + mm_camera_stream_config_t *config; +} mm_evt_paylod_config_stream_t; + +typedef struct { + uint32_t stream_id; + cam_stream_parm_buffer_t *parms; +} mm_evt_paylod_set_get_stream_parms_t; + +typedef struct { + uint32_t stream_id; + void *actions; +} mm_evt_paylod_do_stream_action_t; + +typedef struct { + uint32_t stream_id; + mm_stream_data_cb_t buf_cb; +} mm_evt_paylod_reg_stream_buf_cb; + + +typedef struct { + uint8_t num_of_bufs; + mm_camera_buf_info_t super_buf[MAX_STREAM_NUM_IN_BUNDLE]; + uint8_t matched; + uint8_t expected_frame; + uint32_t frame_idx; + /* unmatched meta idx needed in case of low priority queue */ + uint32_t unmatched_meta_idx; +} mm_channel_queue_node_t; + +typedef struct { + cam_queue_t que; + uint8_t num_streams; + /* container for bundled stream handlers */ + uint32_t bundled_streams[MAX_STREAM_NUM_IN_BUNDLE]; + mm_camera_channel_attr_t attr; + uint32_t expected_frame_id; + uint32_t match_cnt; + uint32_t expected_frame_id_without_led; + uint32_t led_on_start_frame_id; + uint32_t led_off_start_frame_id; + uint32_t led_on_num_frames; + uint32_t once; + uint32_t frame_skip_count; + uint32_t good_frame_id; +} mm_channel_queue_t; + +typedef struct { + uint8_t is_active; /* flag to indicate if bundle is valid */ + /* queue to store bundled super buffers */ + mm_channel_queue_t superbuf_queue; + mm_camera_buf_notify_t super_buf_notify_cb; + void *user_data; +} mm_channel_bundle_t; + +/* Nodes used for frame sync */ +typedef struct { + /* Frame idx */ + uint32_t frame_idx; + /* Frame present for corresponding channel*/ + uint32_t frame_valid[MAX_NUM_CAMERA_PER_BUNDLE]; + /* Frame present in all channels*/ + uint32_t matched; +} mm_channel_sync_node_t; + +/* Frame sync information */ +typedef struct { + /* Number of camera channels that need to be synced*/ + uint8_t num_cam; + /* position of the next node to be updated */ + uint8_t pos; + /* circular node array used to store frame information */ + mm_channel_sync_node_t node[MM_CAMERA_FRAME_SYNC_NODES]; + /* Channel corresponding to each camera */ + struct mm_channel *ch_obj[MAX_NUM_CAMERA_PER_BUNDLE]; + /* Cb corresponding to each camera */ + mm_camera_buf_notify_t cb[MAX_NUM_CAMERA_PER_BUNDLE]; +} mm_channel_frame_sync_info_t; + +/* Node information for multiple superbuf callbacks +* This can be used to batch nodes before sending to upper layer */ +typedef struct { + /* Number of nodes to be sent*/ + uint8_t num_nodes; + /* queue node information*/ + mm_channel_queue_node_t *node[MAX_NUM_CAMERA_PER_BUNDLE]; + /* channel information*/ + struct mm_channel *ch_obj[MAX_NUM_CAMERA_PER_BUNDLE]; +} mm_channel_node_info_t; + +typedef enum { + MM_CHANNEL_BRACKETING_STATE_OFF, + MM_CHANNEL_BRACKETING_STATE_WAIT_GOOD_FRAME_IDX, + MM_CHANNEL_BRACKETING_STATE_ACTIVE, +} mm_channel_bracketing_state_t; + +typedef struct mm_channel { + uint32_t my_hdl; + mm_channel_state_type_t state; + pthread_mutex_t ch_lock; /* channel lock */ + + /* stream bundle info in the channel */ + mm_channel_bundle_t bundle; + + /* num of pending suferbuffers */ + uint32_t pending_cnt; + uint32_t pending_retro_cnt; + mm_camera_req_buf_type_t req_type; + uint32_t bWaitForPrepSnapshotDone; + uint32_t unLockAEC; + /* num of pending suferbuffers */ + uint8_t stopZslSnapshot; + + /* cmd thread for superbuffer dataCB and async stop*/ + mm_camera_cmd_thread_t cmd_thread; + + /* cb thread for sending data cb */ + mm_camera_cmd_thread_t cb_thread; + + /* data poll thread + * currently one data poll thread per channel + * could extended to support one data poll thread per stream in the channel */ + mm_camera_poll_thread_t poll_thread[MM_CAMERA_CHANNEL_POLL_THREAD_MAX]; + + /* container for all streams in channel */ + mm_stream_t streams[MAX_STREAM_NUM_IN_BUNDLE]; + + /* reference to parent cam_obj */ + struct mm_camera_obj* cam_obj; + + /* manual zsl snapshot control */ + uint8_t manualZSLSnapshot; + + /* control for zsl led */ + uint8_t startZSlSnapshotCalled; + uint8_t needLEDFlash; + mm_channel_bracketing_state_t bracketingState; + uint8_t isFlashBracketingEnabled; + uint8_t isZoom1xFrameRequested; + uint32_t burstSnapNum; + char threadName[THREAD_NAME_SIZE]; + + /*Buffer diverted*/ + uint8_t diverted_frame_id; + uint32_t sessionid; + + /*Frame capture configaration*/ + uint8_t isConfigCapture; + uint8_t cur_capture_idx; + uint32_t capture_frame_id[MAX_CAPTURE_BATCH_NUM]; + cam_capture_frame_config_t frameConfig; + uint8_t needLowLightZSL; +} mm_channel_t; + +typedef struct { + mm_channel_t *ch; + uint32_t stream_id; +} mm_camera_stream_link_t; + +/* struct to store information about pp cookie*/ +typedef struct { + uint32_t cam_hdl; + uint32_t ch_hdl; + uint32_t stream_hdl; + mm_channel_queue_node_t* super_buf; +} mm_channel_pp_info_t; + +/* mm_camera */ +typedef struct { + mm_camera_event_notify_t evt_cb; + void *user_data; +} mm_camera_evt_entry_t; + +typedef struct { + mm_camera_evt_entry_t evt[MM_CAMERA_EVT_ENTRY_MAX]; + /* reg_count <=0: infinite + * reg_count > 0: register only for required times */ + int reg_count; +} mm_camera_evt_obj_t; + +typedef struct mm_camera_obj { + uint32_t my_hdl; + int ref_count; + int32_t ctrl_fd; + int32_t ds_fd; /* domain socket fd */ + pthread_mutex_t cam_lock; + pthread_mutex_t cb_lock; /* lock for evt cb */ + mm_channel_t ch[MM_CAMERA_CHANNEL_MAX]; + mm_camera_evt_obj_t evt; + mm_camera_poll_thread_t evt_poll_thread; /* evt poll thread */ + mm_camera_cmd_thread_t evt_thread; /* thread for evt CB */ + mm_camera_vtbl_t vtbl; + + pthread_mutex_t evt_lock; + pthread_cond_t evt_cond; + mm_camera_event_t evt_rcvd; + + pthread_mutex_t msg_lock; /* lock for sending msg through socket */ + uint32_t sessionid; /* Camera server session id */ +} mm_camera_obj_t; + +typedef struct { + int8_t num_cam; + char video_dev_name[MM_CAMERA_MAX_NUM_SENSORS][MM_CAMERA_DEV_NAME_LEN]; + mm_camera_obj_t *cam_obj[MM_CAMERA_MAX_NUM_SENSORS]; + struct camera_info info[MM_CAMERA_MAX_NUM_SENSORS]; + cam_sync_type_t cam_type[MM_CAMERA_MAX_NUM_SENSORS]; + cam_sync_mode_t cam_mode[MM_CAMERA_MAX_NUM_SENSORS]; + uint8_t is_yuv[MM_CAMERA_MAX_NUM_SENSORS]; // 1=CAM_SENSOR_YUV, 0=CAM_SENSOR_RAW +} mm_camera_ctrl_t; + +typedef enum { + mm_camera_async_call, + mm_camera_sync_call +} mm_camera_call_type_t; + +/********************************************************************************** +* external function declare +***********************************************************************************/ +/* utility functions */ +/* set int32_t value */ +extern int32_t mm_camera_util_s_ctrl(int32_t fd, + uint32_t id, + int32_t *value); + +/* get int32_t value */ +extern int32_t mm_camera_util_g_ctrl(int32_t fd, + uint32_t id, + int32_t *value); + +/* send msg throught domain socket for fd mapping */ +extern int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj, + void *msg, + size_t buf_size, + int sendfd); + +/* send msg through domain socket for bundled fd mapping */ +extern int32_t mm_camera_util_bundled_sendmsg(mm_camera_obj_t *my_obj, + void *msg, + size_t buf_size, + int sendfds[CAM_MAX_NUM_BUFS_PER_STREAM], + int numfds); + +/* Check if hardware target is A family */ +uint8_t mm_camera_util_chip_is_a_family(void); + +/* mm-camera */ +extern int32_t mm_camera_open(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_close(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj, + mm_camera_event_notify_t evt_cb, + void * user_data); +extern int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj, + uint32_t ch_id, + mm_camera_buf_def_t *buf); +extern int32_t mm_camera_get_queued_buf_count(mm_camera_obj_t *my_obj, + uint32_t ch_id, uint32_t stream_id); +extern int32_t mm_camera_query_capability(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_set_parms(mm_camera_obj_t *my_obj, + parm_buffer_t *parms); +extern int32_t mm_camera_get_parms(mm_camera_obj_t *my_obj, + parm_buffer_t *parms); +extern int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj, + uint8_t buf_type, + int fd, + size_t size); +extern int32_t mm_camera_map_bufs(mm_camera_obj_t *my_obj, + const cam_buf_map_type_list *buf_map_list); +extern int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj, + uint8_t buf_type); +extern int32_t mm_camera_do_auto_focus(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_cancel_auto_focus(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj, + int32_t do_af_flag); +extern int32_t mm_camera_start_zsl_snapshot(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_stop_zsl_snapshot(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_flush(mm_camera_obj_t *my_obj); +extern int32_t mm_camera_start_zsl_snapshot_ch(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern int32_t mm_camera_stop_zsl_snapshot_ch(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj, + mm_camera_channel_attr_t *attr, + mm_camera_buf_notify_t channel_cb, + void *userdata); +extern int32_t mm_camera_del_channel(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern int32_t mm_camera_get_bundle_info(mm_camera_obj_t *my_obj, + uint32_t ch_id, + cam_bundle_config_t *bundle_info); +extern uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t stream_id); +extern uint32_t mm_camera_link_stream(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t stream_id, + uint32_t linked_ch_id); + +extern int32_t mm_camera_reg_stream_buf_cb(mm_camera_obj_t *my_obj, + uint32_t ch_id, uint32_t stream_id, mm_camera_buf_notify_t buf_cb, + mm_camera_stream_cb_type cb_type, void *userdata); + +extern int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t stream_id, + mm_camera_stream_config_t *config); +extern int32_t mm_camera_start_channel(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern int32_t mm_camera_stop_channel(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj, + uint32_t ch_id, mm_camera_req_buf_t *buf); +extern int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj, + uint32_t ch_id); +extern int32_t mm_camera_flush_super_buf_queue(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t frame_idx); +extern int32_t mm_camera_config_channel_notify(mm_camera_obj_t *my_obj, + uint32_t ch_id, + mm_camera_super_buf_notify_mode_t notify_mode); +extern int32_t mm_camera_set_stream_parms(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t s_id, + cam_stream_parm_buffer_t *parms); +extern int32_t mm_camera_get_stream_parms(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t s_id, + cam_stream_parm_buffer_t *parms); +extern int32_t mm_camera_register_event_notify_internal(mm_camera_obj_t *my_obj, + mm_camera_event_notify_t evt_cb, + void * user_data); +extern int32_t mm_camera_map_stream_buf(mm_camera_obj_t *my_obj, + 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); +extern int32_t mm_camera_map_stream_bufs(mm_camera_obj_t *my_obj, + uint32_t ch_id, + const cam_buf_map_type_list *buf_map_list); +extern int32_t mm_camera_unmap_stream_buf(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t stream_id, + uint8_t buf_type, + uint32_t buf_idx, + int32_t plane_idx); +extern int32_t mm_camera_do_stream_action(mm_camera_obj_t *my_obj, + uint32_t ch_id, + uint32_t stream_id, + void *actions); +extern int32_t mm_camera_get_session_id(mm_camera_obj_t *my_obj, + uint32_t* sessionid); +extern int32_t mm_camera_sync_related_sensors(mm_camera_obj_t *my_obj, + cam_sync_related_sensors_event_info_t *parms); + +/* mm_channel */ +extern int32_t mm_channel_fsm_fn(mm_channel_t *my_obj, + mm_channel_evt_type_t evt, + void * in_val, + void * out_val); +extern int32_t mm_channel_init(mm_channel_t *my_obj, + mm_camera_channel_attr_t *attr, + mm_camera_buf_notify_t channel_cb, + void *userdata); +/* qbuf is a special case that not going through state machine. + * This is to avoid deadlock when trying to aquire ch_lock, + * from the context of dataCB, but async stop is holding ch_lock */ +extern int32_t mm_channel_qbuf(mm_channel_t *my_obj, + mm_camera_buf_def_t *buf); +/* mm_stream */ +extern int32_t mm_stream_fsm_fn(mm_stream_t *my_obj, + mm_stream_evt_type_t evt, + void * in_val, + void * out_val); +/* Function to register special callback for stream buffer*/ +extern int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj, + mm_stream_data_cb_t val); +extern int32_t mm_stream_map_buf(mm_stream_t *my_obj, + uint8_t buf_type, + uint32_t frame_idx, + int32_t plane_idx, + int fd, + size_t size); +extern int32_t mm_stream_map_bufs(mm_stream_t *my_obj, + const cam_buf_map_type_list *buf_map_list); +extern int32_t mm_stream_unmap_buf(mm_stream_t *my_obj, + uint8_t buf_type, + uint32_t frame_idx, + int32_t plane_idx); + + +/* utiltity fucntion declared in mm-camera-inteface2.c + * and need be used by mm-camera and below*/ +uint32_t mm_camera_util_generate_handler(uint8_t index); +const char * mm_camera_util_get_dev_name(uint32_t cam_handler); +uint8_t mm_camera_util_get_index_by_handler(uint32_t handler); + +/* poll/cmd thread functions */ +extern int32_t mm_camera_poll_thread_launch( + mm_camera_poll_thread_t * poll_cb, + mm_camera_poll_thread_type_t poll_type); +extern int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb); +extern int32_t mm_camera_poll_thread_add_poll_fd( + mm_camera_poll_thread_t * poll_cb, + uint32_t handler, + int32_t fd, + mm_camera_poll_notify_t nofity_cb, + void *userdata, + mm_camera_call_type_t); +extern int32_t mm_camera_poll_thread_del_poll_fd( + mm_camera_poll_thread_t * poll_cb, + uint32_t handler, + mm_camera_call_type_t); +extern int32_t mm_camera_poll_thread_commit_updates( + mm_camera_poll_thread_t * poll_cb); +extern int32_t mm_camera_cmd_thread_launch( + mm_camera_cmd_thread_t * cmd_thread, + mm_camera_cmd_cb_t cb, + void* user_data); +extern int32_t mm_camera_cmd_thread_name(const char* name); +extern int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread); + +extern int32_t mm_camera_channel_advanced_capture(mm_camera_obj_t *my_obj, + uint32_t ch_id, mm_camera_advanced_capture_t type, + uint32_t trigger, void *in_value); +#endif /* __MM_CAMERA_H__ */ diff --git a/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_dbg.h b/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_dbg.h new file mode 100644 index 0000000..8298c78 --- /dev/null +++ b/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_dbg.h @@ -0,0 +1,134 @@ +/* Copyright (c) 2012, 2014, 2016, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef __MM_CAMERA_DBG_H__ +#define __MM_CAMERA_DBG_H__ + +// System dependencies +#include + +#ifdef QCAMERA_REDEFINE_LOG + +// Camera dependencies +#include "cam_types.h" + +typedef enum { + CAM_NO_MODULE, + CAM_HAL_MODULE, + CAM_MCI_MODULE, + CAM_JPEG_MODULE, + CAM_LAST_MODULE +} cam_modules_t; + +/* values that persist.camera.global.debug can be set to */ +/* all camera modules need to map their internal debug levels to this range */ +typedef enum { + CAM_GLBL_DBG_NONE = 0, + CAM_GLBL_DBG_ERR = 1, + CAM_GLBL_DBG_WARN = 2, + CAM_GLBL_DBG_HIGH = 3, + CAM_GLBL_DBG_DEBUG = 4, + CAM_GLBL_DBG_LOW = 5, + CAM_GLBL_DBG_INFO = 6 +} cam_global_debug_level_t; + +extern int g_cam_log[CAM_LAST_MODULE][CAM_GLBL_DBG_INFO + 1]; + +#define FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ## __VA_ARGS__) + +#undef CLOGx +#define CLOGx(module, level, fmt, args...) \ +{\ +if (g_cam_log[module][level]) { \ + mm_camera_debug_log(module, level, __func__, __LINE__, fmt, ##args); \ +}\ +} + +#undef CLOGI +#define CLOGI(module, fmt, args...) \ + CLOGx(module, CAM_GLBL_DBG_INFO, fmt, ##args) +#undef CLOGD +#define CLOGD(module, fmt, args...) \ + CLOGx(module, CAM_GLBL_DBG_DEBUG, fmt, ##args) +#undef CLOGL +#define CLOGL(module, fmt, args...) \ + CLOGx(module, CAM_GLBL_DBG_LOW, fmt, ##args) +#undef CLOGW +#define CLOGW(module, fmt, args...) \ + CLOGx(module, CAM_GLBL_DBG_WARN, fmt, ##args) +#undef CLOGH +#define CLOGH(module, fmt, args...) \ + CLOGx(module, CAM_GLBL_DBG_HIGH, fmt, ##args) +#undef CLOGE +#define CLOGE(module, fmt, args...) \ + CLOGx(module, CAM_GLBL_DBG_ERR, fmt, ##args) + +#ifndef CAM_MODULE +#define CAM_MODULE CAM_MCI_MODULE +#endif + +#undef LOGD +#define LOGD(fmt, args...) CLOGD(CAM_MODULE, fmt, ##args) +#undef LOGL +#define LOGL(fmt, args...) CLOGL(CAM_MODULE, fmt, ##args) +#undef LOGW +#define LOGW(fmt, args...) CLOGW(CAM_MODULE, fmt, ##args) +#undef LOGH +#define LOGH(fmt, args...) CLOGH(CAM_MODULE, fmt, ##args) +#undef LOGE +#define LOGE(fmt, args...) CLOGE(CAM_MODULE, fmt, ##args) +#undef LOGI +#define LOGI(fmt, args...) CLOGI(CAM_MODULE, fmt, ##args) + +/* reads and updates camera logging properties */ +void mm_camera_set_dbg_log_properties(void); + +/* generic logger function */ +void mm_camera_debug_log(const cam_modules_t module, + const cam_global_debug_level_t level, + const char *func, const int line, const char *fmt, ...); + +#else + +#undef LOGD +#define LOGD(fmt, args...) ALOGD(fmt, ##args) +#undef LOGL +#define LOGL(fmt, args...) ALOGD(fmt, ##args) +#undef LOGW +#define LOGW(fmt, args...) ALOGW(fmt, ##args) +#undef LOGH +#define LOGH(fmt, args...) ALOGD(fmt, ##args) +#undef LOGE +#define LOGE(fmt, args...) ALOGE(fmt, ##args) +#undef LOGI +#define LOGI(fmt, args...) ALOGV(fmt, ##args) + +#endif + +#endif /* __MM_CAMERA_DBG_H__ */ diff --git a/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_sock.h b/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_sock.h new file mode 100644 index 0000000..89d5040 --- /dev/null +++ b/camera/QCamera2/stack/mm-camera-interface/inc/mm_camera_sock.h @@ -0,0 +1,76 @@ +/* Copyright (c) 2012-2014, 2016, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef __MM_CAMERA_SOCKET_H__ +#define __MM_CAMERA_SOCKET_H__ + +// System dependencies +#define SOCKET_H +#include SOCKET_H +#define UN_H +#include UN_H + +// Camera dependencies +#include "cam_types.h" + +typedef enum { + MM_CAMERA_SOCK_TYPE_UDP, + MM_CAMERA_SOCK_TYPE_TCP, +} mm_camera_sock_type_t; + +typedef union { + struct sockaddr addr; + struct sockaddr_un addr_un; +} mm_camera_sock_addr_t; + +int mm_camera_socket_create(int cam_id, mm_camera_sock_type_t sock_type); + +int mm_camera_socket_sendmsg( + int fd, + void *msg, + size_t buf_size, + int sendfd); + +int mm_camera_socket_bundle_sendmsg( + int fd, + void *msg, + size_t buf_size, + int sendfds[CAM_MAX_NUM_BUFS_PER_STREAM], + int num_fds); + +int mm_camera_socket_recvmsg( + int fd, + void *msg, + uint32_t buf_size, + int *rcvdfd); + +void mm_camera_socket_close(int fd); + +#endif /*__MM_CAMERA_SOCKET_H__*/ + -- cgit v1.2.3