maru-camera: modified linux module

Bug fixes, modify the logs, delete unnecessay macro.

Change-Id: I2a0051d18ec08da93911827496bb2f7e370ff660
Signed-off-by: Jinhyung Jo <jinhyung.jo@samsung.com>

diff --git a/tizen/src/hw/pci/maru_camera_linux.c b/tizen/src/hw/pci/maru_camera_linux.c
index 8748a8c17d2273d0414d3e5862850d18f5264803..818f796f46d29b290c66c6906006eaaa349bde5d 100644 (file)
--- a/tizen/src/hw/pci/maru_camera_linux.c
+++ b/tizen/src/hw/pci/maru_camera_linux.c
@@ -43,21 +43,14 @@
 
 MULTI_DEBUG_CHANNEL(tizen, camera);
 
-#define MAKE_BACKEND_V4L2(state) \
-    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend)
-
 #define CLEAR(x) memset(&(x), 0, sizeof(x))
 
 #define MARUCAM_DEFAULT_BUFFER_COUNT    4
 
-struct MCFormat {
-    uint32_t fmt;   /* fourcc */
-};
-
-static struct MCFormat support_fmts[] = {
-        { V4L2_PIX_FMT_YUYV },
-        { V4L2_PIX_FMT_YUV420 },
-        { V4L2_PIX_FMT_YVU420 },
+static uint32_t support_fmts[] = {
+    V4L2_PIX_FMT_YUYV,
+    V4L2_PIX_FMT_YUV420,
+    V4L2_PIX_FMT_YVU420,
 };
 
 struct MCFrame {
@@ -505,8 +498,8 @@ static int is_stream_paused(MaruCamState *state)
 /* TODO: add other pixel format method */
 static void __raise_dummy_intr(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
     void *buf = NULL;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     qemu_mutex_lock(&state->thread_mutex);
     if (state->streamon == _MC_THREAD_STREAMON && state->req_frame) {
@@ -552,8 +545,8 @@ static void __raise_err_intr(MaruCamState *state)
 static void
 notify_buffer_ready(MaruCamState *state, uint32_t buf_index)
 {
-    MAKE_BACKEND_V4L2(state);
     void *buf = NULL;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     qemu_mutex_lock(&state->thread_mutex);
     if (state->streamon == _MC_THREAD_STREAMON) {
@@ -581,8 +574,8 @@ notify_buffer_ready(MaruCamState *state, uint32_t buf_index)
 
 static int read_frame(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
     struct v4l2_buffer buf;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     CLEAR(buf);
     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@@ -618,10 +611,10 @@ static int read_frame(MaruCamState *state)
 
 static int __v4l2_streaming(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
     fd_set fds;
     struct timeval tv;
     int ret;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     FD_ZERO(&fds);
     FD_SET(backend->fd, &fds);
@@ -696,7 +689,7 @@ static int __v4l2_streaming(MaruCamState *state)
 static void *marucam_worker_thread(void *thread_param)
 {
     MaruCamState *state = (MaruCamState *)thread_param;
-    MAKE_BACKEND_V4L2(state);
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     while (1) {
         qemu_mutex_lock(&state->thread_mutex);
@@ -872,7 +865,7 @@ static void backend_v4l2_release(MaruCamState *state)
 
 static void backend_v4l2_open(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     backend->fd = v4l2_open(backend->dev_name, O_RDWR | O_NONBLOCK, 0);
     if (backend->fd < 0) {
@@ -910,7 +903,7 @@ static void backend_v4l2_open(MaruCamState *state)
 
 static void backend_v4l2_close(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     if (!is_stream_paused(state)) {
         state->backend->stream_off(state);
@@ -926,7 +919,7 @@ static void backend_v4l2_close(MaruCamState *state)
 
 static void backend_v4l2_stream_on(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     struct timespec req;
     req.tv_sec = 0;
@@ -974,11 +967,11 @@ static void backend_v4l2_stream_on(MaruCamState *state)
 
 static void backend_v4l2_stream_off(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
     struct timespec req;
     struct v4l2_requestbuffers reqbuf;
     req.tv_sec = 0;
     req.tv_nsec = 50000000;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     if (is_streamon(state)) {
         qemu_mutex_lock(&state->thread_mutex);
@@ -1023,7 +1016,7 @@ static void backend_v4l2_stream_off(MaruCamState *state)
 
 static void backend_v4l2_s_parm(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     /* If KVM enabled, We use default FPS of the webcam.
      * If KVM disabled, we use mininum FPS of the webcam */
@@ -1048,62 +1041,62 @@ static void backend_v4l2_g_parm(MaruCamState *state)
 
 static void backend_v4l2_s_fmt(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
-    struct v4l2_format *format = (struct v4l2_format *)state->io_ptr->data;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
+    struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data;
 
-    if (xioctl(backend->fd, VIDIOC_S_FMT, format) < 0) {
-        ERR("Failed to set video format: format(0x%x), width:height(%d:%d), "
-          "errstr(%s)\n", format->fmt.pix.pixelformat, format->fmt.pix.width,
-          format->fmt.pix.height, strerror(errno));
+    if (xioctl(backend->fd, VIDIOC_S_FMT, f) < 0) {
+        ERR("Failed to set video format: format(0x%x), w:h(%d:%d), "
+          "errstr(%s)\n", f->fmt.pix.pixelformat, f->fmt.pix.width,
+          f->fmt.pix.height, strerror(errno));
         state->io_ptr->err_code = errno;
         state->io_ptr->ret_val = -1;
         return;
     }
 
-    memcpy(&backend->dst_fmt, format, sizeof(struct v4l2_format));
-    TRACE("Set the format: w:h(%dx%d), fmt(0x%x), size(%d), "
-         "color(%d), field(%d)\n",
-         format->fmt.pix.width, format->fmt.pix.height,
-         format->fmt.pix.pixelformat, format->fmt.pix.sizeimage,
-         format->fmt.pix.colorspace, format->fmt.pix.field);
+    memcpy(&backend->dst_fmt, f, sizeof(struct v4l2_format));
+    TRACE("Set the format: w:h(%dx%d), fmt(0x%x), "
+          "bytesperline(%d), sizeimage(%d), colorspace(%d)\n",
+          f->fmt.pix.width, f->fmt.pix.height,
+          f->fmt.pix.pixelformat, f->fmt.pix.bytesperline,
+          f->fmt.pix.sizeimage, f->fmt.pix.colorspace);
 }
 
 static void backend_v4l2_g_fmt(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
-    struct v4l2_format *format = (struct v4l2_format *)state->io_ptr->data;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
+    struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data;
 
-    if (xioctl(backend->fd, VIDIOC_G_FMT, format) < 0) {
+    if (xioctl(backend->fd, VIDIOC_G_FMT, f) < 0) {
         ERR("Failed to get video format: %s\n", strerror(errno));
         state->io_ptr->err_code = errno;
         state->io_ptr->ret_val = -1;
         return;
     }
-    TRACE("Get the format: w:h(%dx%d), fmt(0x%x), size(%d), "
-          "color(%d), field(%d)\n",
-          format->fmt.pix.width, format->fmt.pix.height,
-          format->fmt.pix.pixelformat, format->fmt.pix.sizeimage,
-          format->fmt.pix.colorspace, format->fmt.pix.field);
+    TRACE("Get the format: w:h(%dx%d), fmt(0x%x), "
+          "bytesperline(%d), sizeimage(%d), colorspace(%d)\n",
+          f->fmt.pix.width, f->fmt.pix.height,
+          f->fmt.pix.pixelformat, f->fmt.pix.bytesperline,
+          f->fmt.pix.sizeimage, f->fmt.pix.colorspace);
 }
 
 static void backend_v4l2_try_fmt(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
-    struct v4l2_format *format = (struct v4l2_format *)state->io_ptr->data;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
+    struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data;
 
-    if (xioctl(backend->fd, VIDIOC_TRY_FMT, format) < 0) {
-        ERR("Failed to check video format: format(0x%x), width:height(%d:%d),"
-            " errstr(%s)\n", format->fmt.pix.pixelformat, format->fmt.pix.width,
-            format->fmt.pix.height, strerror(errno));
+    if (xioctl(backend->fd, VIDIOC_TRY_FMT, f) < 0) {
+        ERR("Failed to check video format: format(0x%x), w:h(%d:%d),"
+            " errstr(%s)\n", f->fmt.pix.pixelformat, f->fmt.pix.width,
+            f->fmt.pix.height, strerror(errno));
         state->io_ptr->err_code = errno;
         state->io_ptr->ret_val = -1;
         return;
     }
-    TRACE("Check the format: w:h(%dx%d), fmt(0x%x), size(%d), "
-         "color(%d), field(%d)\n",
-         format->fmt.pix.width, format->fmt.pix.height,
-         format->fmt.pix.pixelformat, format->fmt.pix.sizeimage,
-         format->fmt.pix.colorspace, format->fmt.pix.field);
+    TRACE("Check the format: w:h(%dx%d), pix_fmt(0x%x), "
+          "bytesperline(%d), sizeimage(%d), colorspace(%d)\n",
+          f->fmt.pix.width, f->fmt.pix.height,
+          f->fmt.pix.pixelformat, f->fmt.pix.bytesperline,
+          f->fmt.pix.sizeimage, f->fmt.pix.colorspace);
 }
 
 static void backend_v4l2_enum_fmt(MaruCamState *state)
@@ -1111,16 +1104,16 @@ static void backend_v4l2_enum_fmt(MaruCamState *state)
     struct v4l2_fmtdesc *f = (struct v4l2_fmtdesc *)state->io_ptr->data;
 
     if (f->index >= ARRAY_SIZE(support_fmts)) {
-        state->io_ptr->err_code = errno;
+        state->io_ptr->err_code = EINVAL;
         state->io_ptr->ret_val = -1;
         return;
     }
 
     f->flags = 0; /* flags = NONE */
-    f->pixelformat = support_fmts[f->index].fmt; /* pixelformat */
+    f->pixelformat = support_fmts[f->index]; /* pixelformat */
 
     /* set description */
-    switch (support_fmts[f->index].fmt) {
+    switch (support_fmts[f->index]) {
     case V4L2_PIX_FMT_YUYV:
         pstrcpy((char *)f->description, sizeof(f->description), "YUYV");
         break;
@@ -1140,9 +1133,9 @@ static void backend_v4l2_enum_fmt(MaruCamState *state)
 
 static void backend_v4l2_query_ctrl(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
-    struct v4l2_queryctrl *qc = (struct v4l2_queryctrl *)state->io_ptr->data;
     uint32_t i;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
+    struct v4l2_queryctrl *qc = (struct v4l2_queryctrl *)state->io_ptr->data;
 
     /* NOTICE: Tizen MMFW hardcoded for control name
                Do Not Modified the name
@@ -1234,9 +1227,9 @@ static void backend_v4l2_query_ctrl(MaruCamState *state)
 
 static void backend_v4l2_s_ctrl(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
-    struct v4l2_control *ctrl = (struct v4l2_control *)state->io_ptr->data;
     uint32_t i;
+    struct v4l2_control *ctrl = (struct v4l2_control *)state->io_ptr->data;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     switch (ctrl->id) {
     case V4L2_CID_BRIGHTNESS:
@@ -1275,9 +1268,9 @@ static void backend_v4l2_s_ctrl(MaruCamState *state)
 
 static void backend_v4l2_g_ctrl(MaruCamState *state)
 {
-    MAKE_BACKEND_V4L2(state);
-    struct v4l2_control *ctrl = (struct v4l2_control *)state->io_ptr->data;
     uint32_t i;
+    struct v4l2_control *ctrl = (struct v4l2_control *)state->io_ptr->data;
+    MCBackendV4l2 *backend = (MCBackendV4l2 *)(state->backend);
 
     switch (ctrl->id) {
     case V4L2_CID_BRIGHTNESS:
@@ -1325,7 +1318,7 @@ static void backend_v4l2_enum_fsizes(MaruCamState *state)
         return;
     }
     for (i = 0; i < ARRAY_SIZE(support_fmts); i++) {
-        if (support_fmts[i].fmt == fsize->pixel_format) {
+        if (support_fmts[i] == fsize->pixel_format) {
             break;
         }
     }
@@ -1366,6 +1359,7 @@ MaruCamBackend *marucam_backend_create(MaruCamState *state)
 
     backend_v4l2 = g_new0(MCBackendV4l2, 1);
 
+    backend_v4l2->base.state               = state;
     backend_v4l2->base.init                = backend_v4l2_init;
     backend_v4l2->base.reset               = backend_v4l2_reset;
     backend_v4l2->base.release             = backend_v4l2_release;