Merge branch 'vip' into p-ti-linux-3.8.y-videop-ti-linux-3.8.y-video

* vip:
  v4l: ti-vps: vip: Different list_head for dequeue list
  v4l: ti-vps: vip: Populate sequence number for frame
  v4l: ti-vps: vip: Handle short frames irqs
  arm: dts: dra7xx: Add gpio properties for fpdlink camera
  i2c: fpdlink: Parse and set gpios in probe
  v4l: ti-vps: vip: Populate field ID for interlaced capture
  v4l: ti-vps: vpdma: Use write desciptor bit in dtd
  v4l: ti-vps: vpdma: Add enum for max width height
  v4l: ti-vps: vip: Dequeue only once while dropping
  v4l: ti-vps: vip: Improve buffer dropping logic

Conflicts:
	drivers/media/platform/ti-vps/vpdma.c
	drivers/media/platform/ti-vps/vpe.c

8 files changed, 219 insertions, 136 deletions

diff --git a/arch/arm/boot/dts/dra7-evm.dts b/arch/arm/boot/dts/dra7-evm.dts
index 763493311e1..81ddc3dac60 100644
--- a/arch/arm/boot/dts/dra7-evm.dts
+++ b/arch/arm/boot/dts/dra7-evm.dts
@@ -699,6 +699,8 @@
         fpdlink_camera {
                 compatible = "ti,fpdlink";
                 reg = <0x20>;
+                gpios = <&pcf_hdmi 3 0>,
+                        <&pcf_lcd3 8 0>;
                 port {
                         cam_fpdlink: endpoint {
                                 hsync-active = <1>;
diff --git a/drivers/media/i2c/fpdlink.c b/drivers/media/i2c/fpdlink.c
index 42e8bca6f51..7b927bd864c 100644
--- a/drivers/media/i2c/fpdlink.c
+++ b/drivers/media/i2c/fpdlink.c
@@ -1,5 +1,6 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
+#include <linux/gpio.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
 #include <linux/slab.h>
@@ -12,6 +13,8 @@
 #include <media/v4l2-ctrls.h>
 
 #include <linux/pm_runtime.h>
+#include <linux/of_gpio.h>
+
 
 struct fpdlink_color_format {
         enum v4l2_mbus_pixelcode code;
@@ -25,6 +28,57 @@ static const struct fpdlink_color_format fpdlink_cfmts[] = {
         },
 };
 
+struct fpdlink_priv {
+        struct v4l2_subdev              subdev;
+        int                             cam_fpd_mux_s0_gpio;
+        int                             sel_tvp_fpd_s0;
+};
+
+static int fpdlink_set_gpios(struct i2c_client *client)
+{
+        struct fpdlink_priv *priv = i2c_get_clientdata(client);
+        struct gpio gpios[] = {
+                { priv->sel_tvp_fpd_s0, GPIOF_OUT_INIT_HIGH,
+                        "tvp_fpd_mux_s0" },
+                { priv->cam_fpd_mux_s0_gpio, GPIOF_OUT_INIT_HIGH,
+                        "cam_fpd_mux_s0" },
+        };
+        int ret = -1;
+
+        ret = gpio_request_array(gpios, ARRAY_SIZE(gpios));
+        if (ret)
+                return ret;
+
+        gpio_free_array(gpios, ARRAY_SIZE(gpios));
+
+        return 0;
+}
+
+static int fpdlink_parse_gpios(struct i2c_client *client,
+                struct device_node *node)
+{
+
+        struct fpdlink_priv *priv = i2c_get_clientdata(client);
+        int gpio;
+
+        gpio = of_get_gpio(node, 0);
+        if (gpio_is_valid(gpio)) {
+                priv->cam_fpd_mux_s0_gpio = gpio;
+        } else {
+                dev_err(&client->dev, "failed to parse CAM_FPD_MUX_S0 gpio\n");
+                return -EINVAL;
+        }
+        gpio = of_get_gpio(node, 1);
+        if (gpio_is_valid(gpio)) {
+                priv->sel_tvp_fpd_s0 = gpio;
+        } else {
+                dev_err(&client->dev, "failed to parse TVP_FPD_MUX_S0 gpio\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int fpdlink_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
                         enum v4l2_mbus_pixelcode *code)
 {
@@ -51,6 +105,9 @@ static int fpdlink_try_fmt(struct v4l2_subdev *sd,
 static int fpdlink_s_fmt(struct v4l2_subdev *sd,
                 struct v4l2_mbus_framefmt *mf)
 {
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        fpdlink_set_gpios(client);
         return 0;
 }
 
@@ -88,20 +145,25 @@ static const struct of_device_id fpdlink_dt_id[] = {
 static int fpdlink_probe(struct i2c_client *client,
                          const struct i2c_device_id *did)
 {
+        struct fpdlink_priv *priv;
         struct v4l2_subdev *sd;
         int ret = -1;
 
-        sd = devm_kzalloc(&client->dev, sizeof(*sd), GFP_KERNEL);
-        if (!sd)
+        priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
                 return -ENOMEM;
+        i2c_set_clientdata(client, priv);
+
+        fpdlink_parse_gpios(client, client->dev.of_node);
+        fpdlink_set_gpios(client);
 
+        sd = &priv->subdev;
         v4l2_i2c_subdev_init(sd, client, &fpdlink_subdev_ops);
 
         /* V4l2 asyn subdev register */
         sd->dev = &client->dev;
         ret = v4l2_async_register_subdev(sd);
         if (!ret) {
-                i2c_set_clientdata(client, sd);
                 v4l2_info(sd, "Camera sensor driver registered\n");
                 pm_runtime_enable(&client->dev);
         }
diff --git a/drivers/media/platform/ti-vps/vip.c b/drivers/media/platform/ti-vps/vip.c
index 648baceb3cf..38982275f05 100644
--- a/drivers/media/platform/ti-vps/vip.c
+++ b/drivers/media/platform/ti-vps/vip.c
@@ -52,7 +52,7 @@ MODULE_VERSION("0.1");
 
 /*
  * Need a descriptor entry for each of up to 15 outputs,
- * and up to 2 control transfers.
+ * and up to 2 write descriptor.
  */
 #define VIP_DESC_LIST_SIZE      (17 * sizeof(struct vpdma_dtd))
 
@@ -757,6 +757,7 @@ static int add_out_dtd(struct vip_stream *stream, int srce_type)
         struct vip_fmt *fmt = port->fmt;
         struct vpdma_dtd *dtd;
         int channel, plane = 0;
+        int vpdma_max_width, vpdma_max_height;
         dma_addr_t dma_addr;
         u32 flags;
 
@@ -795,14 +796,8 @@ static int add_out_dtd(struct vip_stream *stream, int srce_type)
                 return -1;
         }
 
-        vpdma_add_out_dtd(&dev->desc_list, c_rect->width,
-                fmt->vpdma_fmt[plane], dma_addr, channel, flags);
-
         /*
-         * add_out_dtd sets the max WIDTH and HEIGHT to be 1920x1080
-         * Change this later so that max WIDTH and HEIGHT are taken from
-         * VPDMA_MAX_SIZE1 or VPDMA_MAX_SIZE2 register
-         * This allows to use different sets for different slices
+         * Use VPDMA_MAX_SIZE1 or VPDMA_MAX_SIZE2 register for slice0/1
          */
 
         dtd = dev->desc_list.buf.addr;
@@ -810,16 +805,20 @@ static int add_out_dtd(struct vip_stream *stream, int srce_type)
                 vpdma_set_max_size(dev->shared->vpdma, VPDMA_MAX_SIZE1,
                         stream->width, stream->height);
 
-                dtd_set_max_width_height(dtd,
-                        MAX_OUT_WIDTH_REG1, MAX_OUT_HEIGHT_REG1);
+                vpdma_max_width = MAX_OUT_WIDTH_REG1;
+                vpdma_max_height = MAX_OUT_HEIGHT_REG1;
         } else {
                 vpdma_set_max_size(dev->shared->vpdma, VPDMA_MAX_SIZE2,
                         stream->width, stream->height);
 
-                dtd_set_max_width_height(dtd,
-                        MAX_OUT_WIDTH_REG2, MAX_OUT_HEIGHT_REG2);
+                vpdma_max_width = MAX_OUT_WIDTH_REG2;
+                vpdma_max_height = MAX_OUT_HEIGHT_REG2;
         }
 
+        vpdma_add_out_dtd(&dev->desc_list, c_rect->width,
+                fmt->vpdma_fmt[plane], dma_addr,
+                vpdma_max_width, vpdma_max_height, channel, flags);
+
         return 0;
 }
 
@@ -892,6 +891,7 @@ static void populate_desc_list(struct vip_stream *stream)
 static void start_dma(struct vip_dev *dev, struct vip_buffer *buf)
 {
         struct vpdma_data *vpdma = dev->shared->vpdma;
+        struct vpdma_dtd *write_dtd;
         dma_addr_t dma_addr;
         int drop_data;
 
@@ -913,8 +913,12 @@ static void start_dma(struct vip_dev *dev, struct vip_buffer *buf)
 
         enable_irqs(dev, dev->slice_id);
 
+        vpdma_buf_unmap(dev->shared->vpdma, &dev->desc_list.buf);
+
         vpdma_update_dma_addr(dev->shared->vpdma, &dev->desc_list,
-                                dma_addr, drop_data);
+                dma_addr, dev->write_desc, drop_data);
+        vpdma_buf_map(dev->shared->vpdma, &dev->desc_list.buf);
+
         vpdma_submit_descs(dev->shared->vpdma, &dev->desc_list, dev->slice_id);
 }
 
@@ -926,59 +930,74 @@ static void vip_active_buf_next(struct vip_stream *stream)
 
         spin_lock_irqsave(&dev->slock, flags);
         if (list_empty(&stream->vidq)) {
-                v4l2_dbg(1, debug, &dev->v4l2_dev, "%s No buffers to queue, dropping frame, Queue faster or increase no of buffers");
-                buf = kzalloc(sizeof(*buf), GFP_KERNEL);
-                if (!buf) {
-                    v4l2_err(&dev->v4l2_dev, "No memory!!");
-                    spin_unlock_irqrestore(&dev->slock, flags);
-                    return;
-                }
-                buf->drop = true;
-                list_add_tail(&buf->list, &dev->vip_bufs);
-                spin_unlock_irqrestore(&dev->slock, flags);
-                start_dma(dev, NULL);
-        } else if (vb2_is_streaming(&stream->vb_vidq)) {
-                buf = list_entry(stream->vidq.next,
-                                struct vip_buffer, list);
-                list_move_tail(&buf->list, &dev->vip_bufs);
+                vip_dprintk(dev, "Dropping frame");
+                /* Increment drop_count for last buffer in the list */
+                buf = list_entry(dev->vip_bufs.prev,
+                                struct vip_buffer, dq_list);
+                buf->drop_count++;
+                buf = NULL;
+
+        } else if (vb2_is_streaming(&stream->vb_vidq)) {
+                buf = list_entry(stream->vidq.next, struct vip_buffer, list);
+                buf->drop_count = 0;
+                buf->allow_dq = true;
+                list_del(&buf->list);
+                list_add_tail(&buf->dq_list, &dev->vip_bufs);
+        } else {
+                v4l2_err(&dev->v4l2_dev, "IRQ occurred when not streaming");
                 spin_unlock_irqrestore(&dev->slock, flags);
-                start_dma(dev, buf);
-        } else
-            spin_unlock_irqrestore(&dev->slock, flags);
+                return;
+        }
 
-        if (list_empty(&dev->vip_bufs))
-                stream->cur_buf = NULL;
-        else
-                stream->cur_buf = list_first_entry(&dev->vip_bufs,
-                                struct vip_buffer, list);
+        spin_unlock_irqrestore(&dev->slock, flags);
+        start_dma(dev, buf);
 }
 
 static void vip_process_buffer_complete(struct vip_stream *stream)
 {
         struct vip_dev *dev = stream->port->dev;
         struct vb2_buffer *vb = NULL;
-        unsigned long flags;
+        struct vip_buffer *buf;
+        unsigned long flags, fld;
+
+        buf = list_first_entry(&dev->vip_bufs, struct vip_buffer, dq_list);
+
+        if (stream->port->flags & FLAG_INTERLACED) {
+                vpdma_buf_unmap(dev->shared->vpdma, &dev->desc_list.buf);
+
+                fld = dtd_get_field(dev->write_desc);
+                stream->field = fld ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
 
-        if (stream->cur_buf) {
-                vb = &stream->cur_buf->vb;
+                vpdma_buf_map(dev->shared->vpdma, &dev->desc_list.buf);
+        }
+
+        if (buf) {
+                vb = &buf->vb;
+                vb->v4l2_buf.field = stream->field;
+                vb->v4l2_buf.sequence = stream->sequence;
                 do_gettimeofday(&vb->v4l2_buf.timestamp);
 
-                spin_lock_irqsave(&dev->slock, flags);
-                list_del(&stream->cur_buf->list);
-                spin_unlock_irqrestore(&dev->slock, flags);
+                if (buf->drop_count-- == 0) {
+                        spin_lock_irqsave(&dev->slock, flags);
+                        list_del(&buf->dq_list);
+                        spin_unlock_irqrestore(&dev->slock, flags);
+                }
 
-                if (stream->cur_buf->drop)
-                    kfree(stream->cur_buf);
-                else
-                    vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
-        }
+                if (buf->allow_dq) {
+                        vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
+                        buf->allow_dq = false;
+                }
+        } else {
+                BUG();
+        }
 
-        vip_active_buf_next(stream);
+        stream->sequence++;
 }
 
 static irqreturn_t vip_irq(int irq_vip, void *data)
 {
         struct vip_dev *dev = (struct vip_dev *)data;
+        struct vip_stream *stream;
         int list_num = dev->slice_id;
         int irq_num = dev->slice_id;
         u32 irqst, reg_addr;
@@ -1003,14 +1022,17 @@ static irqreturn_t vip_irq(int irq_vip, void *data)
                 irqst &= ~((1 << list_num * 2));
         }
 
+        disable_irqs(dev, dev->slice_id);
+
+        stream = dev->ports[0]->cap_streams[0];
+
         if (dev->num_skip_irq) {
                 dev->num_skip_irq--;
-                return IRQ_HANDLED;
+        } else {
+                vip_process_buffer_complete(stream);
         }
 
-        /* disable_irqs(dev); */
-
-        vip_process_buffer_complete(dev->ports[0]->cap_streams[0]);
+        vip_active_buf_next(stream);
 
         return IRQ_HANDLED;
 }
@@ -1215,7 +1237,7 @@ static int vip_try_fmt_vid_cap(struct file *file, void *priv,
 
         if (field == V4L2_FIELD_ANY)
                 field = V4L2_FIELD_NONE;
-        else if (V4L2_FIELD_NONE != field)
+        else if (V4L2_FIELD_NONE != field && V4L2_FIELD_ALTERNATE != field)
                 return -EINVAL;
 
         f->fmt.pix.field = field;
@@ -1498,36 +1520,30 @@ static int vip_start_streaming(struct vb2_queue *vq, unsigned int count)
                 return -EIO;
         }
 
-        stream->cur_buf = list_entry(stream->vidq.next,
-                                struct vip_buffer, list);
-        stream->cur_buf->vb.state = VB2_BUF_STATE_ACTIVE;
+        buf = list_entry(stream->vidq.next, struct vip_buffer, list);
+        buf->drop_count = 0;
+        buf->allow_dq = true;
+
+        stream->cur_buf = buf;
+        stream->sequence = 0;
         stream->field = V4L2_FIELD_TOP;
 
         populate_desc_list(stream);
         dev->num_skip_irq = VIP_VPDMA_FIFO_SIZE;
 
-        for (i = 0; i < count; i++) {
-
-                spin_lock_irqsave(&dev->slock, flags);
-                if (!vpdma_list_busy(dev->shared->vpdma, dev->slice_id)) {
-
-                        buf = list_entry(stream->vidq.next,
-                                        struct vip_buffer, list);
-                        list_move_tail(&buf->list, &dev->vip_bufs);
-                        spin_unlock_irqrestore(&dev->slock, flags);
+        spin_lock_irqsave(&dev->slock, flags);
+        if (vpdma_list_busy(dev->shared->vpdma, dev->slice_id)) {
+                spin_unlock_irqrestore(&dev->slock, flags);
+                vpdma_buf_unmap(dev->shared->vpdma, &dev->desc_list.buf);
+                vpdma_reset_desc_list(&dev->desc_list);
+                return -EBUSY;
+        }
 
-                        if (!stream->cur_buf)
-                                stream->cur_buf = buf;
-                        start_dma(dev, buf);
+        list_del(&buf->list);
+        list_add_tail(&buf->dq_list, &dev->vip_bufs);
+        spin_unlock_irqrestore(&dev->slock, flags);
 
-                        if (i == VIP_VPDMA_FIFO_SIZE)
-                                break;
-                        while (vpdma_list_busy(dev->shared->vpdma,
-                                        dev->slice_id))
-                                ;
-                } else
-                        spin_unlock_irqrestore(&dev->slock, flags);
-        }
+        start_dma(dev, buf);
 
         return 0;
 }
@@ -1551,8 +1567,9 @@ static int vip_stop_streaming(struct vb2_queue *vq)
         disable_irqs(dev, dev->slice_id);
         /* release all active buffers */
         while (!list_empty(&dev->vip_bufs)) {
-                buf = list_entry(dev->vip_bufs.next, struct vip_buffer, list);
-                list_del(&buf->list);
+                buf = list_entry(dev->vip_bufs.next,
+                                struct vip_buffer, dq_list);
+                list_del(&buf->dq_list);
                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
         }
         while (!list_empty(&stream->vidq)) {
@@ -1606,6 +1623,8 @@ static int vip_init_dev(struct vip_dev *dev)
         if (ret != 0)
                 return ret;
 
+        dev->write_desc = (struct vpdma_dtd *)dev->desc_list.buf.addr
+                                + 15;
         vip_set_clock_enable(dev, 1);
 done:
         dev->num_ports++;
diff --git a/drivers/media/platform/ti-vps/vip.h b/drivers/media/platform/ti-vps/vip.h
index 8ff8d337e99..1b41164f788 100644
--- a/drivers/media/platform/ti-vps/vip.h
+++ b/drivers/media/platform/ti-vps/vip.h
@@ -38,7 +38,11 @@ struct vip_buffer {
         /* common v4l buffer stuff */
         struct vb2_buffer       vb;
         struct list_head        list;
-        bool                    drop;
+        struct list_head        dq_list;
+        /* Number of buffers to drop after this */
+        int                     drop_count;
+        /* To make sure same buffer isn't dequeued again */
+        bool                    allow_dq;
 };
 
 /*
@@ -89,6 +93,7 @@ struct vip_dev {
         void __iomem            *base;
 
         struct vpdma_desc_list  desc_list;      /* DMA descriptor list */
+        struct vpdma_dtd        *write_desc;
         void                    *desc_next;     /* next unused desc_list addr */
         struct list_head        vip_bufs;       /* vip_bufs to be DMAed */
         struct vb2_alloc_ctx    *alloc_ctx;
diff --git a/drivers/media/platform/ti-vps/vpdma.c b/drivers/media/platform/ti-vps/vpdma.c
index d8252d26856..370a8cc1846 100644
--- a/drivers/media/platform/ti-vps/vpdma.c
+++ b/drivers/media/platform/ti-vps/vpdma.c
@@ -343,7 +343,7 @@ void vpdma_buf_map(struct vpdma_data *vpdma, struct vpdma_buf *buf)
 
         WARN_ON(buf->mapped != 0);
         buf->dma_addr = dma_map_single(dev, buf->addr, buf->size,
-                                DMA_TO_DEVICE);
+                                DMA_BIDIRECTIONAL);
         buf->mapped = 1;
         WARN_ON(dma_mapping_error(dev, buf->dma_addr));
 }
@@ -363,7 +363,8 @@ void vpdma_buf_unmap(struct vpdma_data *vpdma, struct vpdma_buf *buf)
         }
 
         if (buf->mapped)
-                dma_unmap_single(dev, buf->dma_addr, buf->size, DMA_TO_DEVICE);
+                dma_unmap_single(dev, buf->dma_addr, buf->size,
+                        DMA_BIDIRECTIONAL);
 
         buf->mapped = 0;
 }
@@ -450,24 +451,25 @@ int vpdma_submit_descs(struct vpdma_data *vpdma,
 EXPORT_SYMBOL(vpdma_submit_descs);
 
 void vpdma_update_dma_addr(struct vpdma_data *vpdma,
-                struct vpdma_desc_list *list, dma_addr_t dma_addr, int drop)
+        struct vpdma_desc_list *list, dma_addr_t dma_addr,
+        struct vpdma_dtd *write_dtd, int drop)
 {
         struct vpdma_dtd *dtd = list->buf.addr;
-        unsigned int write_desc_addr;
-
-        vpdma_buf_unmap(vpdma, &list->buf);
+        dma_addr_t write_desc_addr;
+        int offset;
 
         dtd_set_start_addr(dtd, dma_addr);
 
-        if (drop) {
-                write_desc_addr = virt_to_phys(
-                        (struct vpdma_dtd *)list->buf.dma_addr + 2);
+        /* Calculate write address from the offset of write_dtd from start
+         * of the list->buf
+         */
+        offset = (void *)write_dtd - list->buf.addr;
+        write_desc_addr = list->buf.dma_addr + offset;
 
+        if (drop)
                 dtd_set_desc_write_addr(dtd, write_desc_addr, 1, 1, 0);
-        } else
-                dtd_set_desc_write_addr(dtd, 0, 0, 0, 0);
-
-        vpdma_buf_map(vpdma, &list->buf);
+        else
+                dtd_set_desc_write_addr(dtd, write_desc_addr, 1, 0, 0);
 }
 EXPORT_SYMBOL(vpdma_update_dma_addr);
 
@@ -676,11 +678,14 @@ static void dump_dtd(struct vpdma_dtd *dtd)
  * @width: width of the image in pixels in memory
  * @fmt: vpdma data format of the buffer
  * dma_addr: dma address as seen by VPDMA
+ * max_width: enum for maximum width of data transfer
+ * max_height: enum for maximum height of data transfer
  * chan: VPDMA channel
  * flags: VPDMA flags to configure some descriptor fileds
  */
 int vpdma_add_out_dtd(struct vpdma_desc_list *list, int width,
                 const struct vpdma_data_format *fmt, dma_addr_t dma_addr,
+                enum vpdma_max_width max_w, enum vpdma_max_height max_h,
                 int channel, u32 flags)
 {
         int priority = 0;
@@ -714,7 +719,7 @@ int vpdma_add_out_dtd(struct vpdma_desc_list *list, int width,
                         channel, priority, next_chan);
 
         dtd_set_desc_write_addr(dtd, 0, 0, 0, 0);
-        dtd_set_max_width_height(dtd, MAX_OUT_WIDTH_1920, MAX_OUT_HEIGHT_1080);
+        dtd_set_max_width_height(dtd, max_w, max_h);
         dtd_set_client_attr0(dtd, 0);
         dtd_set_client_attr1(dtd, 0);
 
diff --git a/drivers/media/platform/ti-vps/vpdma.h b/drivers/media/platform/ti-vps/vpdma.h
index 657d8a842a5..55563a1d84f 100644
--- a/drivers/media/platform/ti-vps/vpdma.h
+++ b/drivers/media/platform/ti-vps/vpdma.h
@@ -28,7 +28,7 @@ struct vpdma_buf {
 
 struct vpdma_desc_list {
         struct vpdma_buf buf;
-        void *next;
+        void *next, *current_desc;
         int type;
 };
 
@@ -119,6 +119,30 @@ enum vpdma_frame_start_event {
         VPDMA_FSEVENT_CHANNEL_ACTIVE,
 };
 
+/* max width configurations */
+enum vpdma_max_width {
+        MAX_OUT_WIDTH_UNLIMITED = 0,
+        MAX_OUT_WIDTH_REG1,
+        MAX_OUT_WIDTH_REG2,
+        MAX_OUT_WIDTH_REG3,
+        MAX_OUT_WIDTH_352,
+        MAX_OUT_WIDTH_768,
+        MAX_OUT_WIDTH_1280,
+        MAX_OUT_WIDTH_1920,
+};
+
+/* max height configurations */
+enum vpdma_max_height {
+        MAX_OUT_HEIGHT_UNLIMITED = 0,
+        MAX_OUT_HEIGHT_REG1,
+        MAX_OUT_HEIGHT_REG2,
+        MAX_OUT_HEIGHT_REG3,
+        MAX_OUT_HEIGHT_288,
+        MAX_OUT_HEIGHT_576,
+        MAX_OUT_HEIGHT_720,
+        MAX_OUT_HEIGHT_1080,
+};
+
 #define VIP_CHAN_VIP2_OFFSET            70
 #define VIP_CHAN_MULT_PORTB_OFFSET      16
 #define VIP_CHAN_YUV_PORTB_OFFSET       2
@@ -177,6 +201,7 @@ void vpdma_add_cfd_adb(struct vpdma_desc_list *list, int client,
 void vpdma_add_sync_on_channel_ctd(struct vpdma_desc_list *list, int channel);
 int vpdma_add_out_dtd(struct vpdma_desc_list *list, int width,
                 const struct vpdma_data_format *fmt, dma_addr_t dma_addr,
+                enum vpdma_max_width max_w, enum vpdma_max_height max_h,
                 int channel, u32 flags);
 void vpdma_add_in_dtd(struct vpdma_desc_list *list, int width,
                 const struct v4l2_rect *c_rect,
@@ -190,7 +215,8 @@ void vpdma_free_desc_list(struct vpdma_desc_list *list);
 int vpdma_submit_descs(struct vpdma_data *vpdma,
         struct vpdma_desc_list *list, int list_num);
 void vpdma_update_dma_addr(struct vpdma_data *vpdma,
-                struct vpdma_desc_list *list, dma_addr_t dma_addr, int drop);
+        struct vpdma_desc_list *list, dma_addr_t dma_addr,
+        struct vpdma_dtd *write_dtd, int drop);
 
 void vpdma_enable_channel_3_irq(struct vpdma_data *vpdma, bool enable);
 void vpdma_set_max_size(struct vpdma_data *vpdma, int reg_addr,
diff --git a/drivers/media/platform/ti-vps/vpdma_priv.h b/drivers/media/platform/ti-vps/vpdma_priv.h
index 74881c5422f..78425eb75a7 100644
--- a/drivers/media/platform/ti-vps/vpdma_priv.h
+++ b/drivers/media/platform/ti-vps/vpdma_priv.h
@@ -219,7 +219,7 @@ struct vpdma_dtd {
 #define DTD_V_START_MASK        0xffff
 #define DTD_V_START_SHFT        0
 
-#define DTD_DESC_START_MASK     0xffe0
+#define DTD_DESC_START_MASK     0xffffffe0
 #define DTD_DESC_START_SHIFT    5
 #define DTD_WRITE_DESC_MASK     0x01
 #define DTD_WRITE_DESC_SHIFT    2
@@ -234,43 +234,6 @@ struct vpdma_dtd {
 #define DTD_MAX_HEIGHT_MASK     0x07
 #define DTD_MAX_HEIGHT_SHFT     0
 
-/* max width configurations */
- /* unlimited width */
-#define MAX_OUT_WIDTH_UNLIMITED         0
-/* as specified in max_size1 reg */
-#define MAX_OUT_WIDTH_REG1              1
-/* as specified in max_size2 reg */
-#define MAX_OUT_WIDTH_REG2              2
-/* as specified in max_size3 reg */
-#define MAX_OUT_WIDTH_REG3              3
-/* maximum of 352 pixels as width */
-#define MAX_OUT_WIDTH_352               4
-/* maximum of 768 pixels as width */
-#define MAX_OUT_WIDTH_768               5
-/* maximum of 1280 pixels width */
-#define MAX_OUT_WIDTH_1280              6
-/* maximum of 1920 pixels as width */
-#define MAX_OUT_WIDTH_1920              7
-
-/* max height configurations */
- /* unlimited height */
-#define MAX_OUT_HEIGHT_UNLIMITED        0
-/* as specified in max_size1 reg */
-#define MAX_OUT_HEIGHT_REG1             1
-/* as specified in max_size2 reg */
-#define MAX_OUT_HEIGHT_REG2             2
-/* as specified in max_size3 reg */
-#define MAX_OUT_HEIGHT_REG3             3
-/* maximum of 288 lines as height */
-#define MAX_OUT_HEIGHT_288              4
-/* maximum of 576 lines as height */
-#define MAX_OUT_HEIGHT_576              5
-/* maximum of 720 lines as height */
-#define MAX_OUT_HEIGHT_720              6
-/* maximum of 1080 lines as height */
-#define MAX_OUT_HEIGHT_1080             7
-
-
 /*
  * The following macros may be useful for structure initialization
  */
diff --git a/drivers/media/platform/ti-vps/vpe.c b/drivers/media/platform/ti-vps/vpe.c
index 2833f82f6b4..2256a8bbbd6 100644
--- a/drivers/media/platform/ti-vps/vpe.c
+++ b/drivers/media/platform/ti-vps/vpe.c
@@ -1039,6 +1039,7 @@ static void add_out_dtd(struct vpe_ctx *ctx, int port)
                 flags |= VPDMA_DATA_MODE_TILED;
 
         vpdma_add_out_dtd(&ctx->desc_list, q_data->width, vpdma_fmt, dma_addr,
+                MAX_OUT_WIDTH_1920, MAX_OUT_HEIGHT_1080,
                 p_data->channel, flags);
 }