maru_camera : remove Sonar violations

remove Sonar violations

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

diff --git a/drivers/maru/maru_camera.c b/drivers/maru/maru_camera.c
index 34fd451df8c6f0791340ad6b486a43dccf6686c3..2428e4142ad0a8357057bca145c0a24b67e3b57d 100644 (file)
--- a/drivers/maru/maru_camera.c
+++ b/drivers/maru/maru_camera.c
@@ -57,19 +57,20 @@
 static unsigned debug;
 
 #define marucam_err(fmt, arg...) \
-       printk(KERN_ERR "marucam[%s] : " fmt, __func__, ##arg)
+       printk(KERN_ERR "[ERR]marucam[%s]: " fmt, __func__, ##arg)
 
 #define marucam_warn(fmt, arg...) \
-       printk(KERN_WARNING "marucam[%s] : " fmt, __func__, ##arg)
+       printk(KERN_WARNING "[WARN]marucam[%s]: " fmt, __func__, ##arg)
 
 #define marucam_info(fmt, arg...) \
-       printk(KERN_INFO "marucam[%s] : " fmt, __func__, ##arg)
+       printk(KERN_INFO "[INFO]marucam[%s]: " fmt, __func__, ##arg)
 
 #define marucam_dbg(level, fmt, arg...) \
        do { \
-               if (debug >= (level)) \
-                       printk(KERN_DEBUG "marucam[%s] : " fmt, \
+               if (debug >= (level)) { \
+                       printk(KERN_DEBUG "[DBG]marucam[%s]: " fmt, \
                                                        __func__, ##arg); \
+               } \
        } while (0)
 
 #define MARUCAM_MODULE_NAME "marucam"
@@ -159,8 +160,8 @@ static struct marucam_device *marucam_instance;
 #define MAGIC_CHECK(is, should)        \
        do { \
                if (unlikely((is) != (should))) { \
-                       marucam_err("magic mismatch: %x (expected %x)\n", \
-                                                               is, should); \
+                       marucam_err("Invalid the magic number:" \
+                                " %x (expected %x)\n", is, should); \
                        BUG(); \
                } \
        } while (0)
@@ -190,15 +191,18 @@ static void videobuf_vm_close(struct vm_area_struct *vma)
 
                mutex_lock(&q->vb_lock);
 
-               if (q->streaming)
+               if (q->streaming) {
                        videobuf_queue_cancel(q);
+               }
 
                for (i = 0; i < VIDEO_MAX_FRAME; i++) {
-                       if (NULL == q->bufs[i])
+                       if (NULL == q->bufs[i]) {
                                continue;
+                       }
 
-                       if (q->bufs[i]->map != map)
+                       if (q->bufs[i]->map != map) {
                                continue;
+                       }
 
                        mem = q->bufs[i]->priv;
                        if (mem) {
@@ -230,7 +234,7 @@ static struct videobuf_buffer *__videobuf_alloc_vb(size_t size)
 
        vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
        if (vb == NULL) {
-               marucam_err("failed to memalloc\n");
+               marucam_err("Failed to allocate the video buffer\n");
                return vb;
        }
 
@@ -274,7 +278,7 @@ static int __videobuf_mmap_mapper(struct videobuf_queue *q,
 
        map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
        if (NULL == map) {
-               marucam_err("failed to memalloc\n");
+               marucam_err("Failed to allocate the video buffer map\n");
                return -ENOMEM;
        }
 
@@ -296,9 +300,11 @@ static int __videobuf_mmap_mapper(struct videobuf_queue *q,
                        + vma->vm_pgoff) >> PAGE_SHIFT,
                        pages, vma->vm_page_prot);
        if (retval < 0) {
-               marucam_err("remap failed with error %d.", retval);
+               marucam_err("Failed to remap with error: %d", retval);
                mem->mapped = 0;
-               goto error;
+               mem = NULL;
+               kfree(map);
+               return -ENOMEM;
        }
 
        vma->vm_ops             = &videobuf_vm_ops;
@@ -308,11 +314,6 @@ static int __videobuf_mmap_mapper(struct videobuf_queue *q,
        videobuf_vm_open(vma);
 
        return 0;
-
-error:
-       mem = NULL;
-       kfree(map);
-       return -ENOMEM;
 }
 
 static struct videobuf_qtype_ops qops = {
@@ -372,34 +373,35 @@ static void marucam_fillbuf(struct marucam_device *dev, uint32_t isr)
 
        spin_lock_irqsave(q->irqlock, flags);
        if (dev->opstate != S_RUNNING) {
-               marucam_err("state is not S_RUNNING\n");
-               goto done;
+               marucam_err("The device state is not S_RUNNING\n");
+               spin_unlock_irqrestore(q->irqlock, flags);
+               return;
        }
        if (list_empty(&dev->active)) {
-               marucam_err("list_empty failed\n");
-               goto done;
+               marucam_err("The active list is empty\n");
+               spin_unlock_irqrestore(q->irqlock, flags);
+               return;
        }
 
        buf = list_entry(dev->active.next, struct videobuf_buffer, queue);
        if (!waitqueue_active(&buf->done)) {
-               marucam_err("waitqueue_active failed\n");
-               goto done;
+               marucam_err("The list of wait queue is empty\n");
+               spin_unlock_irqrestore(q->irqlock, flags);
+               return;
        }
 
        list_del(&buf->queue);
 
        if (isr & 0x08) {
-               marucam_err("device state is invalid\n");
+               marucam_err("The device state is invalid\n");
                buf->state = 0xFF; /* invalid state */
        } else {
-               marucam_dbg(2, "video buffer is filled\n");
+               marucam_dbg(2, "The video buffer is filled\n");
                buf->state = VIDEOBUF_DONE;
        }
        do_gettimeofday(&buf->ts);
        buf->field_count++;
        wake_up_interruptible(&buf->done);
-
-done:
        spin_unlock_irqrestore(q->irqlock, flags);
 }
 
@@ -410,7 +412,7 @@ static irqreturn_t marucam_irq_handler(int irq, void *dev_id)
 
        isr = ioread32(dev->mmregs + MARUCAM_ISR);
        if (!isr) {
-               marucam_dbg(1, "this irq is not for this module\n");
+               marucam_dbg(1, "This irq is not for this module\n");
                return IRQ_NONE;
        }
 
@@ -439,20 +441,21 @@ static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *f)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
-       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+       if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                return -EINVAL;
+       }
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
        iowrite32(f->index, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_ENUM_FMT);
-       ret = ioread32(dev->mmregs + MARUCAM_ENUM_FMT);
-       if (ret > 0) {
+       ret = (int)ioread32(dev->mmregs + MARUCAM_ENUM_FMT);
+       if (ret) {
                mutex_unlock(&dev->mlock);
-               return (int)(-ret);
+               return -ret;
        }
 
        f->index        = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -468,17 +471,17 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
                                        struct v4l2_format *f)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
        iowrite32(0, dev->mmregs + MARUCAM_G_FMT);
-       ret = ioread32(dev->mmregs + MARUCAM_G_FMT);
-        if (ret > 0) {
-                marucam_err("MARUCAM_G_FMT failed with error %d.", -ret);
-                mutex_unlock(&dev->mlock);
-                return (int)(-ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_G_FMT);
+       if (ret) {
+               marucam_err("MARUCAM_G_FMT failed with error %d.", -ret);
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        f->fmt.pix.width        = ioread32(dev->mmregs + MARUCAM_G_DATA);
        f->fmt.pix.height       = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -503,7 +506,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                        struct v4l2_format *f)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
@@ -513,12 +516,12 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
        iowrite32(f->fmt.pix.field, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_TRY_FMT);
-       ret = ioread32(dev->mmregs + MARUCAM_TRY_FMT);
-        if (ret > 0) {
-                marucam_err("MARUCAM_TRY_FMT failed with error %d.", -ret);
-                mutex_unlock(&dev->mlock);
-                return (int)(-ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_TRY_FMT);
+       if (ret) {
+               marucam_err("MARUCAM_TRY_FMT failed with error %d.", -ret);
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        f->fmt.pix.width        = ioread32(dev->mmregs + MARUCAM_G_DATA);
        f->fmt.pix.height       = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -538,7 +541,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 {
        struct marucam_device *dev = priv;
        struct videobuf_queue *q = &dev->vb_vidq;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        if (dev->opstate != S_IDLE) {
@@ -562,11 +565,11 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
        iowrite32(f->fmt.pix.field, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_S_FMT);
-       ret = ioread32(dev->mmregs + MARUCAM_S_FMT);
-       if (ret > 0) {
+       ret = (int)ioread32(dev->mmregs + MARUCAM_S_FMT);
+       if (ret) {
                marucam_err("MARUCAM_S_FMT failed with error %d.", -ret);
                mutex_unlock(&dev->mlock);
-               return (int)(-ret);
+               return -ret;
        }
 
        f->fmt.pix.width        = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -597,8 +600,9 @@ static int vidioc_reqbufs(struct file *file, void *priv,
        dev->type = p->type;
 
        ret = videobuf_reqbufs(&dev->vb_vidq, p);
-       if (ret < 0)
+       if (ret) {
                marucam_err("failed to videobuf_reqbufs\n");
+       }
 
        return ret;
 }
@@ -609,8 +613,9 @@ static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
        struct marucam_device *dev = priv;
 
        ret = videobuf_querybuf(&dev->vb_vidq, p);
-       if (ret < 0)
+       if (ret) {
                marucam_err("failed to videobuf_querybuf\n");
+       }
 
        return ret;
 }
@@ -621,8 +626,9 @@ static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
        struct marucam_device *dev = priv;
 
        ret = videobuf_qbuf(&dev->vb_vidq, p);
-       if (ret < 0)
+       if (ret) {
                marucam_err("failed to videobuf_qbuf\n");
+       }
 
        return ret;
 }
@@ -633,8 +639,9 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
        struct marucam_device *dev = priv;
 
        ret = videobuf_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
-       if (ret < 0)
+       if (ret) {
                marucam_err("failed to videobuf_dqbuf\n");
+       }
 
        return ret;
 }
@@ -644,10 +651,12 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
        int ret = 0;
        struct marucam_device *dev = priv;
 
-       if (dev->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+       if (dev->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                return -EINVAL;
-       if (i != dev->type)
+       }
+       if (i != dev->type) {
                return -EINVAL;
+       }
 
        mutex_lock(&dev->mlock);
        if (dev->opstate != S_IDLE) {
@@ -682,10 +691,12 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
        int ret = 0;
        struct marucam_device *dev = priv;
 
-       if (dev->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+       if (dev->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                return -EINVAL;
-       if (i != dev->type)
+       }
+       if (i != dev->type) {
                return -EINVAL;
+       }
 
        mutex_lock(&dev->mlock);
        if (dev->opstate != S_RUNNING) {
@@ -721,8 +732,9 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
 static int vidioc_enum_input(struct file *file, void *priv,
                                struct v4l2_input *inp)
 {
-       if (inp->index != 0)
+       if (inp->index != 0) {
                return -EINVAL;
+       }
 
        inp->type = V4L2_INPUT_TYPE_CAMERA;
        sprintf(inp->name, "MARU Virtual Camera %u", inp->index);
@@ -748,17 +760,28 @@ static int vidioc_queryctrl(struct file *file, void *priv,
                            struct v4l2_queryctrl *qc)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
+       switch (qc->id) {
+       /* we only support followed items. */
+       case V4L2_CID_BRIGHTNESS:
+       case V4L2_CID_CONTRAST:
+       case V4L2_CID_SATURATION:
+       case V4L2_CID_SHARPNESS:
+               break;
+       default:
+               return -EINVAL;
+       }
+
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
        iowrite32(qc->id, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_QCTRL);
-       ret = ioread32(dev->mmregs + MARUCAM_QCTRL);
-       if (ret > 0) {
+       ret = (int)ioread32(dev->mmregs + MARUCAM_QCTRL);
+       if (ret) {
                mutex_unlock(&dev->mlock);
-               return -(ret);
+               return -ret;
        }
 
        qc->id                  = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -777,19 +800,18 @@ static int vidioc_g_ctrl(struct file *file, void *priv,
                         struct v4l2_control *ctrl)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
        iowrite32(ctrl->id, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_G_CTRL);
-       ret = ioread32(dev->mmregs + MARUCAM_G_CTRL);
-
-       if (ret > 0) {
+       ret = (int)ioread32(dev->mmregs + MARUCAM_G_CTRL);
+       if (ret) {
                marucam_err("MARUCAM_G_CTRL failed!\n");
                mutex_unlock(&dev->mlock);
-               return -(ret);
+               return -ret;
        }
 
        ctrl->value = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -802,7 +824,7 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
                                struct v4l2_control *ctrl)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
@@ -810,12 +832,12 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
        iowrite32(ctrl->value, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_S_CTRL);
-       ret = ioread32(dev->mmregs + MARUCAM_S_CTRL);
-        if (ret > 0) {
-                marucam_err("MARUCAM_S_CTRL failed!\n");
-                mutex_unlock(&dev->mlock);
-                return -(ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_S_CTRL);
+       if (ret) {
+               marucam_err("MARUCAM_S_CTRL failed!\n");
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        mutex_unlock(&dev->mlock);
        return 0;
@@ -826,10 +848,11 @@ static int vidioc_s_parm(struct file *file, void *priv,
 {
        struct marucam_device *dev = priv;
        struct v4l2_captureparm *cp = &parm->parm.capture;
-       uint32_t ret;
+       int ret;
 
-       if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+       if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                return -EINVAL;
+       }
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
@@ -837,12 +860,12 @@ static int vidioc_s_parm(struct file *file, void *priv,
        iowrite32(cp->timeperframe.denominator, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_S_PARAM);
-       ret = ioread32(dev->mmregs + MARUCAM_S_PARAM);
-        if (ret > 0) {
-                marucam_err("MARUCAM_S_PARAM failed!\n");
-                mutex_unlock(&dev->mlock);
-                return -(ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_S_PARAM);
+       if (ret) {
+               marucam_err("MARUCAM_S_PARAM failed!\n");
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        mutex_unlock(&dev->mlock);
        return 0;
@@ -853,20 +876,21 @@ static int vidioc_g_parm(struct file *file, void *priv,
 {
        struct marucam_device *dev = priv;
        struct v4l2_captureparm *cp = &parm->parm.capture;
-       uint32_t ret;
+       int ret;
 
-       if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+       if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                return -EINVAL;
+       }
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
        iowrite32(0, dev->mmregs + MARUCAM_G_PARAM);
-       ret = ioread32(dev->mmregs + MARUCAM_G_PARAM);
-        if (ret > 0) {
-                marucam_err("MARUCAM_G_PARAM failed!\n");
-                mutex_unlock(&dev->mlock);
-                return -(ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_G_PARAM);
+       if (ret) {
+               marucam_err("MARUCAM_G_PARAM failed!\n");
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        cp->capability = ioread32(dev->mmregs + MARUCAM_G_DATA);
        cp->timeperframe.numerator = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -880,7 +904,7 @@ static int vidioc_enum_framesizes(struct file *file, void *priv,
                                struct v4l2_frmsizeenum *fsize)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
@@ -888,11 +912,11 @@ static int vidioc_enum_framesizes(struct file *file, void *priv,
        iowrite32(fsize->pixel_format, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_ENUM_FSIZES);
-       ret = ioread32(dev->mmregs + MARUCAM_ENUM_FSIZES);
-        if (ret > 0) {
-                mutex_unlock(&dev->mlock);
-                return -(ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_ENUM_FSIZES);
+       if (ret) {
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
        fsize->discrete.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -906,7 +930,7 @@ static int vidioc_enum_frameintervals(struct file *file, void *priv,
                                struct v4l2_frmivalenum *fival)
 {
        struct marucam_device *dev = priv;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        iowrite32(0, dev->mmregs + MARUCAM_DTC);
@@ -916,11 +940,11 @@ static int vidioc_enum_frameintervals(struct file *file, void *priv,
        iowrite32(fival->height, dev->mmregs + MARUCAM_S_DATA);
 
        iowrite32(0, dev->mmregs + MARUCAM_ENUM_FINTV);
-       ret = ioread32(dev->mmregs + MARUCAM_ENUM_FINTV);
-        if (ret > 0) {
-                mutex_unlock(&dev->mlock);
-                return -(ret);
-        }
+       ret = (int)ioread32(dev->mmregs + MARUCAM_ENUM_FINTV);
+       if (ret) {
+               mutex_unlock(&dev->mlock);
+               return -ret;
+       }
 
        fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
        fival->discrete.numerator = ioread32(dev->mmregs + MARUCAM_G_DATA);
@@ -940,10 +964,11 @@ buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
 
        *size = get_image_size(dev);
 
-       if (*count > 2)
+       if (*count > 2) {
                *count = 2;
-       if (0 == *count)
+       } else if (*count == 0) {
                *count = 2;
+       }
 
        marucam_dbg(1, "count=%d, size=%d\n", *count, *size);
 
@@ -970,7 +995,8 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
                rc = videobuf_iolock(vq, vb, NULL);
                if (rc < 0) {
                        marucam_err("faile dto videobuf_iolock\n");
-                       goto fail;
+                       vb->state = VIDEOBUF_NEEDS_INIT;
+                       return rc;
                }
        }
 
@@ -980,10 +1006,6 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
        vb->state       = VIDEOBUF_PREPARED;
 
        return 0;
-
-fail:
-       vb->state = VIDEOBUF_NEEDS_INIT;
-       return rc;
 }
 
 static void
@@ -1024,7 +1046,7 @@ static int marucam_open(struct file *file)
 
        mutex_lock(&dev->mlock);
        if (dev->in_use) {
-               marucam_err("device already opend!!!!\n");
+               marucam_err("The device has been already opened\n");
                mutex_unlock(&dev->mlock);
                return -EBUSY;
        }
@@ -1037,7 +1059,8 @@ static int marucam_open(struct file *file)
        ret = request_irq(dev->pdev->irq, marucam_irq_handler,
                                IRQF_SHARED, MARUCAM_MODULE_NAME, dev);
        if (ret) {
-               marucam_err("request_irq failed!!! irq#(%d)\n", dev->pdev->irq);
+               marucam_err("Failed to request the irq: irq(#%d)\n",
+                               dev->pdev->irq);
                mutex_unlock(&dev->mlock);
                return ret;
        }
@@ -1049,8 +1072,8 @@ static int marucam_open(struct file *file)
 
        iowrite32(0, dev->mmregs + MARUCAM_OPEN);
        ret = (int)ioread32(dev->mmregs + MARUCAM_OPEN);
-       if (ret > 0) {
-               marucam_err("MARUCAM_OPEN failed\n");
+       if (ret) {
+               marucam_err("Failed to open the device\n");
                free_irq(dev->pdev->irq, dev);
                mutex_unlock(&dev->mlock);
                return -ret;
@@ -1064,26 +1087,25 @@ static int marucam_open(struct file *file)
 static int marucam_close(struct file *file)
 {
        struct marucam_device *dev = file->private_data;
-       uint32_t ret;
+       int ret;
 
        mutex_lock(&dev->mlock);
        if (dev->opstate == S_RUNNING) {
                marucam_err("The device has been terminated unexpectedly.\n");
                iowrite32(1, dev->mmregs + MARUCAM_STOP_PREVIEW);
                ret = (int)ioread32(dev->mmregs + MARUCAM_STOP_PREVIEW);
-               if (ret > 0) {
-                       marucam_err("MARUCAM_STOP_PREVIEW failed!\n");
+               if (ret) {
+                       marucam_err("Failed to stop the preview\n");
                        mutex_unlock(&dev->mlock);
-                       return -(ret);
+                       return -ret;
                }
 
                dev->opstate = S_IDLE;
                ret = videobuf_streamoff(&dev->vb_vidq);
-               if (ret < 0) {
-                       marucam_err("videobuf_streamoff failed! ret(%d)\n",
-                                        ret);
+               if (ret) {
+                       marucam_err("Failed to streamoff the videobuffer\n");
                        mutex_unlock(&dev->mlock);
-                       return -(ret);
+                       return ret;
                }
                INIT_LIST_HEAD(&dev->active);
        }
@@ -1094,11 +1116,11 @@ static int marucam_close(struct file *file)
        free_irq(dev->pdev->irq, dev);
 
        iowrite32(0, dev->mmregs + MARUCAM_CLOSE);
-       ret = ioread32(dev->mmregs + MARUCAM_CLOSE);
-       if (ret > 0) {
-               marucam_err("device close failed\n");
+       ret = (int)ioread32(dev->mmregs + MARUCAM_CLOSE);
+       if (ret) {
+               marucam_err("Failed to close the device\n");
                mutex_unlock(&dev->mlock);
-               return -(ret);
+               return -ret;
        }
 
        dev->in_use = 0;
@@ -1114,17 +1136,19 @@ marucam_poll(struct file *file, struct poll_table_struct *wait)
        unsigned int ret = 0;
        struct videobuf_buffer *buf = NULL;
 
-       if (q->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+       if (q->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                return POLLERR;
+       }
 
        mutex_lock(&q->vb_lock);
        if (q->streaming) {
-               if (!list_empty(&q->stream))
+               if (!list_empty(&q->stream)) {
                        buf = list_entry(q->stream.next,
                                                struct videobuf_buffer, stream);
+               }
        }
        if (!buf) {
-               marucam_err("video buffer list is empty\n");
+               marucam_err("The video buffer list is empty\n");
                ret = POLLERR;
        }
 
@@ -1132,10 +1156,11 @@ marucam_poll(struct file *file, struct poll_table_struct *wait)
                poll_wait(file, &buf->done, wait);
                if (buf->state == VIDEOBUF_DONE ||
                                buf->state == VIDEOBUF_ERROR ||
-                               buf->state == 0xFF)
+                               buf->state == 0xFF) {
                        ret = POLLIN | POLLRDNORM;
-               else
+               } else {
                        iowrite32(buf->i, dev->mmregs + MARUCAM_REQFRAME);
+               }
        }
        mutex_unlock(&q->vb_lock);
        return ret;
@@ -1219,7 +1244,7 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
        debug = MARUCAM_DEBUG_LEVEL;
 
        if (marucam_instance != NULL) {
-               marucam_err("only one device allowed!\n");
+               marucam_err("Only one device allowed\n");
                return -EBUSY;
        }
 
@@ -1231,8 +1256,12 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
        marucam_instance = dev;
 
        ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
-       if (ret)
-               goto out_free;
+       if (ret) {
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
+       }
 
        INIT_LIST_HEAD(&dev->active);
        spin_lock_init(&dev->slock);
@@ -1245,7 +1274,11 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
        dev->vfd = video_device_alloc();
        if (!dev->vfd) {
                marucam_err("video_device_alloc() failed!!\n");
-               goto out_unreg;
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
 
        memcpy(dev->vfd, &marucam_video_dev, sizeof(marucam_video_dev));
@@ -1256,7 +1289,12 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
        ret = pci_enable_device(dev->pdev);
        if (ret) {
                marucam_err("pci_enable_device failed!!\n");
-               goto rel_vdev;
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
        pci_set_master(dev->pdev);
 
@@ -1266,13 +1304,25 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
 
        if (!dev->mem_base) {
                marucam_err("pci_resource_start failed!!\n");
-               goto out_disable;
+               pci_disable_device(dev->pdev);
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
 
        if (!request_mem_region(dev->mem_base, dev->mem_size,
                                                MARUCAM_MODULE_NAME)) {
                marucam_err("request_mem_region(mem) failed!!\n");
-               goto out_disable;
+               pci_disable_device(dev->pdev);
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
 
        dev->io_base = pci_resource_start(dev->pdev, 1);
@@ -1280,25 +1330,56 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
 
        if (!dev->io_base) {
                marucam_err("pci_resource_start failed!!\n");
-               goto out_rel_mem_region;
+               release_mem_region(dev->mem_base, dev->mem_size);
+               pci_disable_device(dev->pdev);
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
 
        if (!request_mem_region(dev->io_base, dev->io_size,
                                                MARUCAM_MODULE_NAME)) {
                marucam_err("request_mem_region(io) failed!!\n");
-               goto out_disable;
+               release_mem_region(dev->mem_base, dev->mem_size);
+               pci_disable_device(dev->pdev);
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
 
        dev->mmregs = ioremap(dev->io_base, dev->io_size);
        if (!dev->mmregs) {
                marucam_err("ioremap failed!!\n");
-               goto out_rel_io_region;
+               release_mem_region(dev->io_base, dev->io_size);
+               release_mem_region(dev->mem_base, dev->mem_size);
+               pci_disable_device(dev->pdev);
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
 
        ret = video_register_device(dev->vfd, VFL_TYPE_GRABBER, 0);
        if (ret < 0) {
                marucam_err("video_register_device failed!!\n");
-               goto out_iounmap;
+               iounmap(dev->mmregs);
+               release_mem_region(dev->io_base, dev->io_size);
+               release_mem_region(dev->mem_base, dev->mem_size);
+               pci_disable_device(dev->pdev);
+               video_device_release(dev->vfd);
+               v4l2_device_unregister(&dev->v4l2_dev);
+               kfree(dev);
+               dev = NULL;
+               marucam_instance = NULL;
+               return ret;
        }
        video_set_drvdata(dev->vfd, dev);
        pci_set_drvdata(pdev, dev);
@@ -1309,25 +1390,6 @@ static int marucam_pci_initdev(struct pci_dev *pdev,
        marucam_info("V4L2 device registerd as /dev/video%d\n", dev->vfd->num);
 
        return 0;
-
-out_iounmap:
-       iounmap(dev->mmregs);
-out_rel_io_region:
-       release_mem_region(dev->io_base, dev->io_size);
-out_rel_mem_region:
-       release_mem_region(dev->mem_base, dev->mem_size);
-out_disable:
-       pci_disable_device(dev->pdev);
-rel_vdev:
-       video_device_release(dev->vfd);
-out_unreg:
-       v4l2_device_unregister(&dev->v4l2_dev);
-out_free:
-       kfree(dev);
-       dev = NULL;
-       marucam_instance = NULL;
-
-       return ret;
 }
 
 static void marucam_pci_removedev(struct pci_dev *pdev)