[media] coda: Fix 'driver_data' for mx53

[karo-tx-linux.git] / drivers / media / platform / coda.c

diff --git a/drivers/media/platform/coda.c b/drivers/media/platform/coda.c
index 0c55d67f8ac3e89f2796f17d41f2be6dcf1d6413..7b8b547f2d51867115f9bf5a510495e6c35baebb 100644 (file)
--- a/drivers/media/platform/coda.c
+++ b/drivers/media/platform/coda.c
@@ -141,6 +141,7 @@ struct coda_dev {
 };
 
 struct coda_params {
+       u8                      rot_mode;
        u8                      h264_intra_qp;
        u8                      h264_inter_qp;
        u8                      mpeg4_intra_qp;
@@ -150,6 +151,7 @@ struct coda_params {
        enum v4l2_mpeg_video_multi_slice_mode slice_mode;
        u32                     framerate;
        u16                     bitrate;
+       u32                     slice_max_bits;
        u32                     slice_max_mb;
 };
 
@@ -412,8 +414,8 @@ static int vidioc_try_fmt(struct coda_dev *dev, struct v4l2_format *f)
                                      W_ALIGN, &f->fmt.pix.height,
                                      MIN_H, MAX_H, H_ALIGN, S_ALIGN);
                f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 2);
-               f->fmt.pix.sizeimage = f->fmt.pix.height *
-                                       f->fmt.pix.bytesperline;
+               f->fmt.pix.sizeimage = f->fmt.pix.width *
+                                       f->fmt.pix.height * 3 / 2;
        } else { /*encoded formats h.264/mpeg4 */
                f->fmt.pix.bytesperline = 0;
                f->fmt.pix.sizeimage = CODA_MAX_FRAME_SIZE;
@@ -497,11 +499,7 @@ static int vidioc_s_fmt(struct coda_ctx *ctx, struct v4l2_format *f)
        q_data->fmt = find_format(ctx->dev, f);
        q_data->width = f->fmt.pix.width;
        q_data->height = f->fmt.pix.height;
-       if (q_data->fmt->fourcc == V4L2_PIX_FMT_YUV420) {
-               q_data->sizeimage = q_data->width * q_data->height * 3 / 2;
-       } else { /* encoded format h.264/mpeg-4 */
-               q_data->sizeimage = CODA_MAX_FRAME_SIZE;
-       }
+       q_data->sizeimage = f->fmt.pix.sizeimage;
 
        v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
                "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
@@ -704,7 +702,7 @@ static void coda_device_run(void *m2m_priv)
        }
 
        /* submit */
-       coda_write(dev, 0, CODA_CMD_ENC_PIC_ROT_MODE);
+       coda_write(dev, CODA_ROT_MIR_ENABLE | ctx->params.rot_mode, CODA_CMD_ENC_PIC_ROT_MODE);
        coda_write(dev, quant_param, CODA_CMD_ENC_PIC_QS);
 
 
@@ -820,18 +818,11 @@ static int coda_queue_setup(struct vb2_queue *vq,
                                unsigned int sizes[], void *alloc_ctxs[])
 {
        struct coda_ctx *ctx = vb2_get_drv_priv(vq);
+       struct coda_q_data *q_data;
        unsigned int size;
 
-       if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
-               if (fmt)
-                       size = fmt->fmt.pix.width *
-                               fmt->fmt.pix.height * 3 / 2;
-               else
-                       size = MAX_W *
-                               MAX_H * 3 / 2;
-       } else {
-               size = CODA_MAX_FRAME_SIZE;
-       }
+       q_data = get_q_data(ctx, vq->type);
+       size = q_data->sizeimage;
 
        *nplanes = 1;
        sizes[0] = size;
@@ -1064,12 +1055,23 @@ static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
                return -EINVAL;
        }
 
-       value  = (ctx->params.slice_max_mb & CODA_SLICING_SIZE_MASK) << CODA_SLICING_SIZE_OFFSET;
-       value |= (1 & CODA_SLICING_UNIT_MASK) << CODA_SLICING_UNIT_OFFSET;
-       if (ctx->params.slice_mode == V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB)
+       switch (ctx->params.slice_mode) {
+       case V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE:
+               value = 0;
+               break;
+       case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB:
+               value  = (ctx->params.slice_max_mb & CODA_SLICING_SIZE_MASK) << CODA_SLICING_SIZE_OFFSET;
+               value |= (1 & CODA_SLICING_UNIT_MASK) << CODA_SLICING_UNIT_OFFSET;
                value |=  1 & CODA_SLICING_MODE_MASK;
+               break;
+       case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES:
+               value  = (ctx->params.slice_max_bits & CODA_SLICING_SIZE_MASK) << CODA_SLICING_SIZE_OFFSET;
+               value |= (0 & CODA_SLICING_UNIT_MASK) << CODA_SLICING_UNIT_OFFSET;
+               value |=  1 & CODA_SLICING_MODE_MASK;
+               break;
+       }
        coda_write(dev, value, CODA_CMD_ENC_SEQ_SLICE_MODE);
-       value  =  ctx->params.gop_size & CODA_GOP_SIZE_MASK;
+       value = ctx->params.gop_size & CODA_GOP_SIZE_MASK;
        coda_write(dev, value, CODA_CMD_ENC_SEQ_GOP_SIZE);
 
        if (ctx->params.bitrate) {
@@ -1280,6 +1282,18 @@ static int coda_s_ctrl(struct v4l2_ctrl *ctrl)
                 "s_ctrl: id = %d, val = %d\n", ctrl->id, ctrl->val);
 
        switch (ctrl->id) {
+       case V4L2_CID_HFLIP:
+               if (ctrl->val)
+                       ctx->params.rot_mode |= CODA_MIR_HOR;
+               else
+                       ctx->params.rot_mode &= ~CODA_MIR_HOR;
+               break;
+       case V4L2_CID_VFLIP:
+               if (ctrl->val)
+                       ctx->params.rot_mode |= CODA_MIR_VER;
+               else
+                       ctx->params.rot_mode &= ~CODA_MIR_VER;
+               break;
        case V4L2_CID_MPEG_VIDEO_BITRATE:
                ctx->params.bitrate = ctrl->val / 1000;
                break;
@@ -1304,6 +1318,9 @@ static int coda_s_ctrl(struct v4l2_ctrl *ctrl)
        case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
                ctx->params.slice_max_mb = ctrl->val;
                break;
+       case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
+               ctx->params.slice_max_bits = ctrl->val * 8;
+               break;
        case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
                break;
        default:
@@ -1324,6 +1341,10 @@ static int coda_ctrls_setup(struct coda_ctx *ctx)
 {
        v4l2_ctrl_handler_init(&ctx->ctrls, 9);
 
+       v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+               V4L2_CID_HFLIP, 0, 1, 1, 0);
+       v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+               V4L2_CID_VFLIP, 0, 1, 1, 0);
        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
                V4L2_CID_MPEG_VIDEO_BITRATE, 0, 32767000, 1, 0);
        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
@@ -1338,10 +1359,12 @@ static int coda_ctrls_setup(struct coda_ctx *ctx)
                V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP, 1, 31, 1, 2);
        v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,
                V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
-               V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB, 0,
-               V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB);
+               V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES, 0x0,
+               V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE);
        v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
                V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1, 0x3fffffff, 1, 1);
+       v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
+               V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, 1, 0x3fffffff, 1, 500);
        v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,
                V4L2_CID_MPEG_VIDEO_HEADER_MODE,
                V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
@@ -1517,7 +1540,7 @@ static irqreturn_t coda_irq_handler(int irq, void *data)
        u32 wr_ptr, start_ptr;
        struct coda_ctx *ctx;
 
-       __cancel_delayed_work(&dev->timeout);
+       cancel_delayed_work(&dev->timeout);
 
        /* read status register to attend the IRQ */
        coda_read(dev, CODA_REG_BIT_INT_STATUS);
@@ -1854,7 +1877,7 @@ static const struct coda_devtype coda_devdata[] = {
 
 static struct platform_device_id coda_platform_ids[] = {
        { .name = "coda-imx27", .driver_data = CODA_IMX27 },
-       { .name = "coda-imx53", .driver_data = CODA_7541 },
+       { .name = "coda-imx53", .driver_data = CODA_IMX53 },
        { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(platform, coda_platform_ids);