// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2015 VanguardiaSur - www.vanguardiasur.com.ar
 *
 * Based on original driver by Krzysztof Ha?asa:
 * Copyright (C) 2015 Industrial Research Institute for Automation
 * and Measurements PIAP
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <media/v4l2-common.h>
#include <media/v4l2-event.h>
#include <media/videobuf2-dma-contig.h>
#include <media/videobuf2-dma-sg.h>
#include <media/videobuf2-vmalloc.h>
#include "tw686x.h"
#include "tw686x-regs.h"

#define TW686X_INPUTS_PER_CH            4
#define TW686X_VIDEO_WIDTH              720
#define TW686X_VIDEO_HEIGHT(id)         ((id & V4L2_STD_525_60) ? 480 : 576)
#define TW686X_MAX_FPS(id)              ((id & V4L2_STD_525_60) ? 30 : 25)

#define TW686X_MAX_SG_ENTRY_SIZE        4096
#define TW686X_MAX_SG_DESC_COUNT        256 /* PAL 720x576 needs 203 4-KB pages */
#define TW686X_SG_TABLE_SIZE            (TW686X_MAX_SG_DESC_COUNT * sizeof(struct tw686x_sg_desc))

static const struct tw686x_format formats[] = {
        {
                .fourcc = V4L2_PIX_FMT_UYVY,
                .mode = 0,
                .depth = 16,
        }, {
                .fourcc = V4L2_PIX_FMT_RGB565,
                .mode = 5,
                .depth = 16,
        }, {
                .fourcc = V4L2_PIX_FMT_YUYV,
                .mode = 6,
                .depth = 16,
        }
};

static void tw686x_buf_done(struct tw686x_video_channel *vc,
                            unsigned int pb)
{
        struct tw686x_dma_desc *desc = &vc->dma_descs[pb];
        struct tw686x_dev *dev = vc->dev;
        struct vb2_v4l2_buffer *vb;
        struct vb2_buffer *vb2_buf;

        if (vc->curr_bufs[pb]) {
                vb = &vc->curr_bufs[pb]->vb;

                vb->field = dev->dma_ops->field;
                vb->sequence = vc->sequence++;
                vb2_buf = &vb->vb2_buf;

                if (dev->dma_mode == TW686X_DMA_MODE_MEMCPY)
                        memcpy(vb2_plane_vaddr(vb2_buf, 0), desc->virt,
                               desc->size);
                vb2_buf->timestamp = ktime_get_ns();
                vb2_buffer_done(vb2_buf, VB2_BUF_STATE_DONE);
        }

        vc->pb = !pb;
}

/*
 * We can call this even when alloc_dma failed for the given channel
 */
static void tw686x_memcpy_dma_free(struct tw686x_video_channel *vc,
                                   unsigned int pb)
{
        struct tw686x_dma_desc *desc = &vc->dma_descs[pb];
        struct tw686x_dev *dev = vc->dev;
        struct pci_dev *pci_dev;
        unsigned long flags;

        /* Check device presence. Shouldn't really happen! */
        spin_lock_irqsave(&dev->lock, flags);
        pci_dev = dev->pci_dev;
        spin_unlock_irqrestore(&dev->lock, flags);
        if (!pci_dev) {
                WARN(1, "trying to deallocate on missing device\n");
                return;
        }

        if (desc->virt) {
                dma_free_coherent(&dev->pci_dev->dev, desc->size, desc->virt,
                                  desc->phys);
                desc->virt = NULL;
        }
}

static int tw686x_memcpy_dma_alloc(struct tw686x_video_channel *vc,
                                   unsigned int pb)
{
        struct tw686x_dev *dev = vc->dev;
        u32 reg = pb ? VDMA_B_ADDR[vc->ch] : VDMA_P_ADDR[vc->ch];
        unsigned int len;
        void *virt;

        WARN(vc->dma_descs[pb].virt,
             "Allocating buffer but previous still here\n");

        len = (vc->width * vc->height * vc->format->depth) >> 3;
        virt = dma_alloc_coherent(&dev->pci_dev->dev, len,
                                  &vc->dma_descs[pb].phys, GFP_KERNEL);
        if (!virt) {
                v4l2_err(&dev->v4l2_dev,
                         "dma%d: unable to allocate %s-buffer\n",
                         vc->ch, pb ? "B" : "P");
                return -ENOMEM;
        }
        vc->dma_descs[pb].size = len;
        vc->dma_descs[pb].virt = virt;
        reg_write(dev, reg, vc->dma_descs[pb].phys);

        return 0;
}

static void tw686x_memcpy_buf_refill(struct tw686x_video_channel *vc,
                                     unsigned int pb)
{
        struct tw686x_v4l2_buf *buf;

        while (!list_empty(&vc->vidq_queued)) {

                buf = list_first_entry(&vc->vidq_queued,
                        struct tw686x_v4l2_buf, list);
                list_del(&buf->list);

                vc->curr_bufs[pb] = buf;
                return;
        }
        vc->curr_bufs[pb] = NULL;
}

static const struct tw686x_dma_ops memcpy_dma_ops = {
        .alloc          = tw686x_memcpy_dma_alloc,
        .free           = tw686x_memcpy_dma_free,
        .buf_refill     = tw686x_memcpy_buf_refill,
        .mem_ops        = &vb2_vmalloc_memops,
        .hw_dma_mode    = TW686X_FRAME_MODE,
        .field          = V4L2_FIELD_INTERLACED,
};

static void tw686x_contig_buf_refill(struct tw686x_video_channel *vc,
                                     unsigned int pb)
{
        struct tw686x_v4l2_buf *buf;

        while (!list_empty(&vc->vidq_queued)) {
                u32 reg = pb ? VDMA_B_ADDR[vc->ch] : VDMA_P_ADDR[vc->ch];
                dma_addr_t phys;

                buf = list_first_entry(&vc->vidq_queued,
                        struct tw686x_v4l2_buf, list);
                list_del(&buf->list);

                phys = vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 0);
                reg_write(vc->dev, reg, phys);

                buf->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
                vc->curr_bufs[pb] = buf;
                return;
        }
        vc->curr_bufs[pb] = NULL;
}

static const struct tw686x_dma_ops contig_dma_ops = {
        .buf_refill     = tw686x_contig_buf_refill,
        .mem_ops        = &vb2_dma_contig_memops,
        .hw_dma_mode    = TW686X_FRAME_MODE,
        .field          = V4L2_FIELD_INTERLACED,
};

static int tw686x_sg_desc_fill(struct tw686x_sg_desc *descs,
                               struct tw686x_v4l2_buf *buf,
                               unsigned int buf_len)
{
        struct sg_table *vbuf = vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0);
        unsigned int len, entry_len;
        struct scatterlist *sg;
        int i, count;

        /* Clear the scatter-gather table */
        memset(descs, 0, TW686X_SG_TABLE_SIZE);

        count = 0;
        for_each_sg(vbuf->sgl, sg, vbuf->nents, i) {
                dma_addr_t phys = sg_dma_address(sg);
                len = sg_dma_len(sg);

                while (len && buf_len) {

                        if (count == TW686X_MAX_SG_DESC_COUNT)
                                return -ENOMEM;

                        entry_len = min_t(unsigned int, len,
                                          TW686X_MAX_SG_ENTRY_SIZE);
                        entry_len = min_t(unsigned int, entry_len, buf_len);
                        descs[count].phys = cpu_to_le32(phys);
                        descs[count++].flags_length =
                                        cpu_to_le32(BIT(30) | entry_len);
                        phys += entry_len;
                        len -= entry_len;
                        buf_len -= entry_len;
                }

                if (!buf_len)
                        return 0;
        }

        return -ENOMEM;
}

static void tw686x_sg_buf_refill(struct tw686x_video_channel *vc,
                                 unsigned int pb)
{
        struct tw686x_dev *dev = vc->dev;
        struct tw686x_v4l2_buf *buf;

        while (!list_empty(&vc->vidq_queued)) {
                unsigned int buf_len;

                buf = list_first_entry(&vc->vidq_queued,
                        struct tw686x_v4l2_buf, list);
                list_del(&buf->list);

                buf_len = (vc->width * vc->height * vc->format->depth) >> 3;
                if (tw686x_sg_desc_fill(vc->sg_descs[pb], buf, buf_len)) {
                        v4l2_err(&dev->v4l2_dev,
                                 "dma%d: unable to fill %s-buffer\n",
                                 vc->ch, pb ? "B" : "P");
                        vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
                        continue;
                }

                buf->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
                vc->curr_bufs[pb] = buf;
                return;
        }

        vc->curr_bufs[pb] = NULL;
}

static void tw686x_sg_dma_free(struct tw686x_video_channel *vc,
                               unsigned int pb)
{
        struct tw686x_dma_desc *desc = &vc->dma_descs[pb];
        struct tw686x_dev *dev = vc->dev;

        if (desc->size) {
                dma_free_coherent(&dev->pci_dev->dev, desc->size, desc->virt,
                                  desc->phys);
                desc->virt = NULL;
        }

        vc->sg_descs[pb] = NULL;
}

static int tw686x_sg_dma_alloc(struct tw686x_video_channel *vc,
                               unsigned int pb)
{
        struct tw686x_dma_desc *desc = &vc->dma_descs[pb];
        struct tw686x_dev *dev = vc->dev;
        u32 reg = pb ? DMA_PAGE_TABLE1_ADDR[vc->ch] :
                       DMA_PAGE_TABLE0_ADDR[vc->ch];
        void *virt;

        if (desc->size) {
                virt = dma_alloc_coherent(&dev->pci_dev->dev, desc->size,
                                          &desc->phys, GFP_KERNEL);
                if (!virt) {
                        v4l2_err(&dev->v4l2_dev,
                                 "dma%d: unable to allocate %s-buffer\n",
                                 vc->ch, pb ? "B" : "P");
                        return -ENOMEM;
                }
                desc->virt = virt;
                reg_write(dev, reg, desc->phys);
        } else {
                virt = dev->video_channels[0].dma_descs[pb].virt +
                       vc->ch * TW686X_SG_TABLE_SIZE;
        }

        vc->sg_descs[pb] = virt;
        return 0;
}

static int tw686x_sg_setup(struct tw686x_dev *dev)
{
        unsigned int sg_table_size, pb, ch, channels;

        if (is_second_gen(dev)) {
                /*
                 * TW6865/TW6869: each channel needs a pair of
                 * P-B descriptor tables.
                 */
                channels = max_channels(dev);
                sg_table_size = TW686X_SG_TABLE_SIZE;
        } else {
                /*
                 * TW6864/TW6868: we need to allocate a pair of
                 * P-B descriptor tables, common for all channels.
                 * Each table will be bigger than 4 KB.
                 */
                channels = 1;
                sg_table_size = max_channels(dev) * TW686X_SG_TABLE_SIZE;
        }

        for (ch = 0; ch < channels; ch++) {
                struct tw686x_video_channel *vc = &dev->video_channels[ch];

                for (pb = 0; pb < 2; pb++)
                        vc->dma_descs[pb].size = sg_table_size;
        }

        return 0;
}

static const struct tw686x_dma_ops sg_dma_ops = {
        .setup          = tw686x_sg_setup,
        .alloc          = tw686x_sg_dma_alloc,
        .free           = tw686x_sg_dma_free,
        .buf_refill     = tw686x_sg_buf_refill,
        .mem_ops        = &vb2_dma_sg_memops,
        .hw_dma_mode    = TW686X_SG_MODE,
        .field          = V4L2_FIELD_SEQ_TB,
};

static const unsigned int fps_map[15] = {
        /*
         * bit 31 enables selecting the field control register
         * bits 0-29 are a bitmask with fields that will be output.
         * For NTSC (and PAL-M, PAL-60), all 30 bits are used.
         * For other PAL standards, only the first 25 bits are used.
         */
        0x00000000, /* output all fields */
        0x80000006, /* 2 fps (60Hz), 2 fps (50Hz) */
        0x80018006, /* 4 fps (60Hz), 4 fps (50Hz) */
        0x80618006, /* 6 fps (60Hz), 6 fps (50Hz) */
        0x81818186, /* 8 fps (60Hz), 8 fps (50Hz) */
        0x86186186, /* 10 fps (60Hz), 8 fps (50Hz) */
        0x86619866, /* 12 fps (60Hz), 10 fps (50Hz) */
        0x86666666, /* 14 fps (60Hz), 12 fps (50Hz) */
        0x9999999e, /* 16 fps (60Hz), 14 fps (50Hz) */
        0x99e6799e, /* 18 fps (60Hz), 16 fps (50Hz) */
        0x9e79e79e, /* 20 fps (60Hz), 16 fps (50Hz) */
        0x9e7e7e7e, /* 22 fps (60Hz), 18 fps (50Hz) */
        0x9fe7f9fe, /* 24 fps (60Hz), 20 fps (50Hz) */
        0x9ffe7ffe, /* 26 fps (60Hz), 22 fps (50Hz) */
        0x9ffffffe, /* 28 fps (60Hz), 24 fps (50Hz) */
};

static unsigned int tw686x_real_fps(unsigned int index, unsigned int max_fps)
{
        unsigned long mask;

        if (!index || index >= ARRAY_SIZE(fps_map))
                return max_fps;

        mask = GENMASK(max_fps - 1, 0);
        return hweight_long(fps_map[index] & mask);
}

static unsigned int tw686x_fps_idx(unsigned int fps, unsigned int max_fps)
{
        unsigned int idx, real_fps;
        int delta;

        /* First guess */
        idx = (12 + 15 * fps) / max_fps;

        /* Minimal possible framerate is 2 frames per second */
        if (!idx)
                return 1;

        /* Check if the difference is bigger than abs(1) and adjust */
        real_fps = tw686x_real_fps(idx, max_fps);
        delta = real_fps - fps;
        if (delta < -1)
                idx++;
        else if (delta > 1)
                idx--;

        /* Max framerate */
        if (idx >= 15)
                return 0;

        return idx;
}

static void tw686x_set_framerate(struct tw686x_video_channel *vc,
                                 unsigned int fps)
{
        unsigned int i;

        i = tw686x_fps_idx(fps, TW686X_MAX_FPS(vc->video_standard));
        reg_write(vc->dev, VIDEO_FIELD_CTRL[vc->ch], fps_map[i]);
        vc->fps = tw686x_real_fps(i, TW686X_MAX_FPS(vc->video_standard));
}

static const struct tw686x_format *format_by_fourcc(unsigned int fourcc)
{
        unsigned int cnt;

        for (cnt = 0; cnt < ARRAY_SIZE(formats); cnt++)
                if (formats[cnt].fourcc == fourcc)
                        return &formats[cnt];
        return NULL;
}

static int tw686x_queue_setup(struct vb2_queue *vq,
                              unsigned int *nbuffers, unsigned int *nplanes,
                              unsigned int sizes[], struct device *alloc_devs[])
{
        struct tw686x_video_channel *vc = vb2_get_drv_priv(vq);
        unsigned int q_num_bufs = vb2_get_num_buffers(vq);
        unsigned int szimage =
                (vc->width * vc->height * vc->format->depth) >> 3;

        /*
         * Let's request at least three buffers: two for the
         * DMA engine and one for userspace.
         */
        if (q_num_bufs + *nbuffers < 3)
                *nbuffers = 3 - q_num_bufs;

        if (*nplanes) {
                if (*nplanes != 1 || sizes[0] < szimage)
                        return -EINVAL;
                return 0;
        }

        sizes[0] = szimage;
        *nplanes = 1;
        return 0;
}

static void tw686x_buf_queue(struct vb2_buffer *vb)
{
        struct tw686x_video_channel *vc = vb2_get_drv_priv(vb->vb2_queue);
        struct tw686x_dev *dev = vc->dev;
        struct pci_dev *pci_dev;
        unsigned long flags;
        struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
        struct tw686x_v4l2_buf *buf =
                container_of(vbuf, struct tw686x_v4l2_buf, vb);

        /* Check device presence */
        spin_lock_irqsave(&dev->lock, flags);
        pci_dev = dev->pci_dev;
        spin_unlock_irqrestore(&dev->lock, flags);
        if (!pci_dev) {
                vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
                return;
        }

        spin_lock_irqsave(&vc->qlock, flags);
        list_add_tail(&buf->list, &vc->vidq_queued);
        spin_unlock_irqrestore(&vc->qlock, flags);
}

static void tw686x_clear_queue(struct tw686x_video_channel *vc,
                               enum vb2_buffer_state state)
{
        unsigned int pb;

        while (!list_empty(&vc->vidq_queued)) {
                struct tw686x_v4l2_buf *buf;

                buf = list_first_entry(&vc->vidq_queued,
                        struct tw686x_v4l2_buf, list);
                list_del(&buf->list);
                vb2_buffer_done(&buf->vb.vb2_buf, state);
        }

        for (pb = 0; pb < 2; pb++) {
                if (vc->curr_bufs[pb])
                        vb2_buffer_done(&vc->curr_bufs[pb]->vb.vb2_buf, state);
                vc->curr_bufs[pb] = NULL;
        }
}

static int tw686x_start_streaming(struct vb2_queue *vq, unsigned int count)
{
        struct tw686x_video_channel *vc = vb2_get_drv_priv(vq);
        struct tw686x_dev *dev = vc->dev;
        struct pci_dev *pci_dev;
        unsigned long flags;
        int pb, err;

        /* Check device presence */
        spin_lock_irqsave(&dev->lock, flags);
        pci_dev = dev->pci_dev;
        spin_unlock_irqrestore(&dev->lock, flags);
        if (!pci_dev) {
                err = -ENODEV;
                goto err_clear_queue;
        }

        spin_lock_irqsave(&vc->qlock, flags);

        /* Sanity check */
        if (dev->dma_mode == TW686X_DMA_MODE_MEMCPY &&
            (!vc->dma_descs[0].virt || !vc->dma_descs[1].virt)) {
                spin_unlock_irqrestore(&vc->qlock, flags);
                v4l2_err(&dev->v4l2_dev,
                         "video%d: refusing to start without DMA buffers\n",
                         vc->num);
                err = -ENOMEM;
                goto err_clear_queue;
        }

        for (pb = 0; pb < 2; pb++)
                dev->dma_ops->buf_refill(vc, pb);
        spin_unlock_irqrestore(&vc->qlock, flags);

        vc->sequence = 0;
        vc->pb = 0;

        spin_lock_irqsave(&dev->lock, flags);
        tw686x_enable_channel(dev, vc->ch);
        spin_unlock_irqrestore(&dev->lock, flags);

        mod_timer(&dev->dma_delay_timer, jiffies + msecs_to_jiffies(100));

        return 0;

err_clear_queue:
        spin_lock_irqsave(&vc->qlock, flags);
        tw686x_clear_queue(vc, VB2_BUF_STATE_QUEUED);
        spin_unlock_irqrestore(&vc->qlock, flags);
        return err;
}

static void tw686x_stop_streaming(struct vb2_queue *vq)
{
        struct tw686x_video_channel *vc = vb2_get_drv_priv(vq);
        struct tw686x_dev *dev = vc->dev;
        struct pci_dev *pci_dev;
        unsigned long flags;

        /* Check device presence */
        spin_lock_irqsave(&dev->lock, flags);
        pci_dev = dev->pci_dev;
        spin_unlock_irqrestore(&dev->lock, flags);
        if (pci_dev)
                tw686x_disable_channel(dev, vc->ch);

        spin_lock_irqsave(&vc->qlock, flags);
        tw686x_clear_queue(vc, VB2_BUF_STATE_ERROR);
        spin_unlock_irqrestore(&vc->qlock, flags);
}

static int tw686x_buf_prepare(struct vb2_buffer *vb)
{
        struct tw686x_video_channel *vc = vb2_get_drv_priv(vb->vb2_queue);
        unsigned int size =
                (vc->width * vc->height * vc->format->depth) >> 3;

        if (vb2_plane_size(vb, 0) < size)
                return -EINVAL;
        vb2_set_plane_payload(vb, 0, size);
        return 0;
}

static const struct vb2_ops tw686x_video_qops = {
        .queue_setup            = tw686x_queue_setup,
        .buf_queue              = tw686x_buf_queue,
        .buf_prepare            = tw686x_buf_prepare,
        .start_streaming        = tw686x_start_streaming,
        .stop_streaming         = tw686x_stop_streaming,
};

static int tw686x_s_ctrl(struct v4l2_ctrl *ctrl)
{
        struct tw686x_video_channel *vc;
        struct tw686x_dev *dev;
        unsigned int ch;

        vc = container_of(ctrl->handler, struct tw686x_video_channel,
                          ctrl_handler);
        dev = vc->dev;
        ch = vc->ch;

        switch (ctrl->id) {
        case V4L2_CID_BRIGHTNESS:
                reg_write(dev, BRIGHT[ch], ctrl->val & 0xff);
                return 0;

        case V4L2_CID_CONTRAST:
                reg_write(dev, CONTRAST[ch], ctrl->val);
                return 0;

        case V4L2_CID_SATURATION:
                reg_write(dev, SAT_U[ch], ctrl->val);
                reg_write(dev, SAT_V[ch], ctrl->val);
                return 0;

        case V4L2_CID_HUE:
                reg_write(dev, HUE[ch], ctrl->val & 0xff);
                return 0;
        }

        return -EINVAL;
}

static const struct v4l2_ctrl_ops ctrl_ops = {
        .s_ctrl = tw686x_s_ctrl,
};

static int tw686x_g_fmt_vid_cap(struct file *file, void *priv,
                                struct v4l2_format *f)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct tw686x_dev *dev = vc->dev;

        f->fmt.pix.width = vc->width;
        f->fmt.pix.height = vc->height;
        f->fmt.pix.field = dev->dma_ops->field;
        f->fmt.pix.pixelformat = vc->format->fourcc;
        f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
        f->fmt.pix.bytesperline = (f->fmt.pix.width * vc->format->depth) / 8;
        f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
        return 0;
}

static int tw686x_try_fmt_vid_cap(struct file *file, void *priv,
                                  struct v4l2_format *f)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct tw686x_dev *dev = vc->dev;
        unsigned int video_height = TW686X_VIDEO_HEIGHT(vc->video_standard);
        const struct tw686x_format *format;

        format = format_by_fourcc(f->fmt.pix.pixelformat);
        if (!format) {
                format = &formats[0];
                f->fmt.pix.pixelformat = format->fourcc;
        }

        if (f->fmt.pix.width <= TW686X_VIDEO_WIDTH / 2)
                f->fmt.pix.width = TW686X_VIDEO_WIDTH / 2;
        else
                f->fmt.pix.width = TW686X_VIDEO_WIDTH;

        if (f->fmt.pix.height <= video_height / 2)
                f->fmt.pix.height = video_height / 2;
        else
                f->fmt.pix.height = video_height;

        f->fmt.pix.bytesperline = (f->fmt.pix.width * format->depth) / 8;
        f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
        f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
        f->fmt.pix.field = dev->dma_ops->field;

        return 0;
}

static int tw686x_set_format(struct tw686x_video_channel *vc,
                             unsigned int pixelformat, unsigned int width,
                             unsigned int height, bool realloc)
{
        struct tw686x_dev *dev = vc->dev;
        u32 val, dma_width, dma_height, dma_line_width;
        int err, pb;

        vc->format = format_by_fourcc(pixelformat);
        vc->width = width;
        vc->height = height;

        /* We need new DMA buffers if the framesize has changed */
        if (dev->dma_ops->alloc && realloc) {
                for (pb = 0; pb < 2; pb++)
                        dev->dma_ops->free(vc, pb);

                for (pb = 0; pb < 2; pb++) {
                        err = dev->dma_ops->alloc(vc, pb);
                        if (err) {
                                if (pb > 0)
                                        dev->dma_ops->free(vc, 0);
                                return err;
                        }
                }
        }

        val = reg_read(vc->dev, VDMA_CHANNEL_CONFIG[vc->ch]);

        if (vc->width <= TW686X_VIDEO_WIDTH / 2)
                val |= BIT(23);
        else
                val &= ~BIT(23);

        if (vc->height <= TW686X_VIDEO_HEIGHT(vc->video_standard) / 2)
                val |= BIT(24);
        else
                val &= ~BIT(24);

        val &= ~0x7ffff;

        /* Program the DMA scatter-gather */
        if (dev->dma_mode == TW686X_DMA_MODE_SG) {
                u32 start_idx, end_idx;

                start_idx = is_second_gen(dev) ?
                                0 : vc->ch * TW686X_MAX_SG_DESC_COUNT;
                end_idx = start_idx + TW686X_MAX_SG_DESC_COUNT - 1;

                val |= (end_idx << 10) | start_idx;
        }

        val &= ~(0x7 << 20);
        val |= vc->format->mode << 20;
        reg_write(vc->dev, VDMA_CHANNEL_CONFIG[vc->ch], val);

        /* Program the DMA frame size */
        dma_width = (vc->width * 2) & 0x7ff;
        dma_height = vc->height / 2;
        dma_line_width = (vc->width * 2) & 0x7ff;
        val = (dma_height << 22) | (dma_line_width << 11)  | dma_width;
        reg_write(vc->dev, VDMA_WHP[vc->ch], val);
        return 0;
}

static int tw686x_s_fmt_vid_cap(struct file *file, void *priv,
                                struct v4l2_format *f)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        unsigned long area;
        bool realloc;
        int err;

        if (vb2_is_busy(&vc->vidq))
                return -EBUSY;

        area = vc->width * vc->height;
        err = tw686x_try_fmt_vid_cap(file, priv, f);
        if (err)
                return err;

        realloc = area != (f->fmt.pix.width * f->fmt.pix.height);
        return tw686x_set_format(vc, f->fmt.pix.pixelformat,
                                 f->fmt.pix.width, f->fmt.pix.height,
                                 realloc);
}

static int tw686x_querycap(struct file *file, void *priv,
                           struct v4l2_capability *cap)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct tw686x_dev *dev = vc->dev;

        strscpy(cap->driver, "tw686x", sizeof(cap->driver));
        strscpy(cap->card, dev->name, sizeof(cap->card));
        return 0;
}

static int tw686x_set_standard(struct tw686x_video_channel *vc, v4l2_std_id id)
{
        u32 val;

        if (id & V4L2_STD_NTSC)
                val = 0;
        else if (id & V4L2_STD_PAL)
                val = 1;
        else if (id & V4L2_STD_SECAM)
                val = 2;
        else if (id & V4L2_STD_NTSC_443)
                val = 3;
        else if (id & V4L2_STD_PAL_M)
                val = 4;
        else if (id & V4L2_STD_PAL_Nc)
                val = 5;
        else if (id & V4L2_STD_PAL_60)
                val = 6;
        else
                return -EINVAL;

        vc->video_standard = id;
        reg_write(vc->dev, SDT[vc->ch], val);

        val = reg_read(vc->dev, VIDEO_CONTROL1);
        if (id & V4L2_STD_525_60)
                val &= ~(1 << (SYS_MODE_DMA_SHIFT + vc->ch));
        else
                val |= (1 << (SYS_MODE_DMA_SHIFT + vc->ch));
        reg_write(vc->dev, VIDEO_CONTROL1, val);

        return 0;
}

static int tw686x_s_std(struct file *file, void *priv, v4l2_std_id id)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct v4l2_format f;
        int ret;

        if (vc->video_standard == id)
                return 0;

        if (vb2_is_busy(&vc->vidq))
                return -EBUSY;

        ret = tw686x_set_standard(vc, id);
        if (ret)
                return ret;
        /*
         * Adjust format after V4L2_STD_525_60/V4L2_STD_625_50 change,
         * calling g_fmt and s_fmt will sanitize the height
         * according to the standard.
         */
        tw686x_g_fmt_vid_cap(file, priv, &f);
        tw686x_s_fmt_vid_cap(file, priv, &f);

        /*
         * Frame decimation depends on the chosen standard,
         * so reset it to the current value.
         */
        tw686x_set_framerate(vc, vc->fps);
        return 0;
}

static int tw686x_querystd(struct file *file, void *priv, v4l2_std_id *std)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct tw686x_dev *dev = vc->dev;
        unsigned int old_std, detected_std = 0;
        unsigned long end;

        if (vb2_is_streaming(&vc->vidq))
                return -EBUSY;

        /* Enable and start standard detection */
        old_std = reg_read(dev, SDT[vc->ch]);
        reg_write(dev, SDT[vc->ch], 0x7);
        reg_write(dev, SDT_EN[vc->ch], 0xff);

        end = jiffies + msecs_to_jiffies(500);
        while (time_is_after_jiffies(end)) {

                detected_std = reg_read(dev, SDT[vc->ch]);
                if (!(detected_std & BIT(7)))
                        break;
                msleep(100);
        }
        reg_write(dev, SDT[vc->ch], old_std);

        /* Exit if still busy */
        if (detected_std & BIT(7))
                return 0;

        detected_std = (detected_std >> 4) & 0x7;
        switch (detected_std) {
        case TW686X_STD_NTSC_M:
                *std &= V4L2_STD_NTSC;
                break;
        case TW686X_STD_NTSC_443:
                *std &= V4L2_STD_NTSC_443;
                break;
        case TW686X_STD_PAL_M:
                *std &= V4L2_STD_PAL_M;
                break;
        case TW686X_STD_PAL_60:
                *std &= V4L2_STD_PAL_60;
                break;
        case TW686X_STD_PAL:
                *std &= V4L2_STD_PAL;
                break;
        case TW686X_STD_PAL_CN:
                *std &= V4L2_STD_PAL_Nc;
                break;
        case TW686X_STD_SECAM:
                *std &= V4L2_STD_SECAM;
                break;
        default:
                *std = 0;
        }
        return 0;
}

static int tw686x_g_std(struct file *file, void *priv, v4l2_std_id *id)
{
        struct tw686x_video_channel *vc = video_drvdata(file);

        *id = vc->video_standard;
        return 0;
}

static int tw686x_enum_framesizes(struct file *file, void *priv,
                                  struct v4l2_frmsizeenum *fsize)
{
        struct tw686x_video_channel *vc = video_drvdata(file);

        if (fsize->index)
                return -EINVAL;
        fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
        fsize->stepwise.max_width = TW686X_VIDEO_WIDTH;
        fsize->stepwise.min_width = fsize->stepwise.max_width / 2;
        fsize->stepwise.step_width = fsize->stepwise.min_width;
        fsize->stepwise.max_height = TW686X_VIDEO_HEIGHT(vc->video_standard);
        fsize->stepwise.min_height = fsize->stepwise.max_height / 2;
        fsize->stepwise.step_height = fsize->stepwise.min_height;
        return 0;
}

static int tw686x_enum_frameintervals(struct file *file, void *priv,
                                      struct v4l2_frmivalenum *ival)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        int max_fps = TW686X_MAX_FPS(vc->video_standard);
        int max_rates = DIV_ROUND_UP(max_fps, 2);

        if (ival->index >= max_rates)
                return -EINVAL;

        ival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
        ival->discrete.numerator = 1;
        if (ival->index < (max_rates - 1))
                ival->discrete.denominator = (ival->index + 1) * 2;
        else
                ival->discrete.denominator = max_fps;
        return 0;
}

static int tw686x_g_parm(struct file *file, void *priv,
                         struct v4l2_streamparm *sp)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct v4l2_captureparm *cp = &sp->parm.capture;

        if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
        sp->parm.capture.readbuffers = 3;

        cp->capability = V4L2_CAP_TIMEPERFRAME;
        cp->timeperframe.numerator = 1;
        cp->timeperframe.denominator = vc->fps;
        return 0;
}

static int tw686x_s_parm(struct file *file, void *priv,
                         struct v4l2_streamparm *sp)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        struct v4l2_captureparm *cp = &sp->parm.capture;
        unsigned int denominator = cp->timeperframe.denominator;
        unsigned int numerator = cp->timeperframe.numerator;
        unsigned int fps;

        if (vb2_is_busy(&vc->vidq))
                return -EBUSY;

        fps = (!numerator || !denominator) ? 0 : denominator / numerator;
        if (vc->fps != fps)
                tw686x_set_framerate(vc, fps);
        return tw686x_g_parm(file, priv, sp);
}

static int tw686x_enum_fmt_vid_cap(struct file *file, void *priv,
                                   struct v4l2_fmtdesc *f)
{
        if (f->index >= ARRAY_SIZE(formats))
                return -EINVAL;
        f->pixelformat = formats[f->index].fourcc;
        return 0;
}

static void tw686x_set_input(struct tw686x_video_channel *vc, unsigned int i)
{
        u32 val;

        vc->input = i;

        val = reg_read(vc->dev, VDMA_CHANNEL_CONFIG[vc->ch]);
        val &= ~(0x3 << 30);
        val |= i << 30;
        reg_write(vc->dev, VDMA_CHANNEL_CONFIG[vc->ch], val);
}

static int tw686x_s_input(struct file *file, void *priv, unsigned int i)
{
        struct tw686x_video_channel *vc = video_drvdata(file);

        if (i >= TW686X_INPUTS_PER_CH)
                return -EINVAL;
        if (i == vc->input)
                return 0;
        /*
         * Not sure we are able to support on the fly input change
         */
        if (vb2_is_busy(&vc->vidq))
                return -EBUSY;

        tw686x_set_input(vc, i);
        return 0;
}

static int tw686x_g_input(struct file *file, void *priv, unsigned int *i)
{
        struct tw686x_video_channel *vc = video_drvdata(file);

        *i = vc->input;
        return 0;
}

static int tw686x_enum_input(struct file *file, void *priv,
                             struct v4l2_input *i)
{
        struct tw686x_video_channel *vc = video_drvdata(file);
        unsigned int vidstat;

        if (i->index >= TW686X_INPUTS_PER_CH)
                return -EINVAL;

        snprintf(i->name, sizeof(i->name), "Composite%d", i->index);
        i->type = V4L2_INPUT_TYPE_CAMERA;
        i->std = vc->device->tvnorms;
        i->capabilities = V4L2_IN_CAP_STD;

        vidstat = reg_read(vc->dev, VIDSTAT[vc->ch]);
        i->status = 0;
        if (vidstat & TW686X_VIDSTAT_VDLOSS)
                i->status |= V4L2_IN_ST_NO_SIGNAL;
        if (!(vidstat & TW686X_VIDSTAT_HLOCK))
                i->status |= V4L2_IN_ST_NO_H_LOCK;

        return 0;
}

static const struct v4l2_file_operations tw686x_video_fops = {
        .owner          = THIS_MODULE,
        .open           = v4l2_fh_open,
        .unlocked_ioctl = video_ioctl2,
        .release        = vb2_fop_release,
        .poll           = vb2_fop_poll,
        .read           = vb2_fop_read,
        .mmap           = vb2_fop_mmap,
};

static const struct v4l2_ioctl_ops tw686x_video_ioctl_ops = {
        .vidioc_querycap                = tw686x_querycap,
        .vidioc_g_fmt_vid_cap           = tw686x_g_fmt_vid_cap,
        .vidioc_s_fmt_vid_cap           = tw686x_s_fmt_vid_cap,
        .vidioc_enum_fmt_vid_cap        = tw686x_enum_fmt_vid_cap,
        .vidioc_try_fmt_vid_cap         = tw686x_try_fmt_vid_cap,

        .vidioc_querystd                = tw686x_querystd,
        .vidioc_g_std                   = tw686x_g_std,
        .vidioc_s_std                   = tw686x_s_std,

        .vidioc_g_parm                  = tw686x_g_parm,
        .vidioc_s_parm                  = tw686x_s_parm,
        .vidioc_enum_framesizes         = tw686x_enum_framesizes,
        .vidioc_enum_frameintervals     = tw686x_enum_frameintervals,

        .vidioc_enum_input              = tw686x_enum_input,
        .vidioc_g_input                 = tw686x_g_input,
        .vidioc_s_input                 = tw686x_s_input,

        .vidioc_reqbufs                 = vb2_ioctl_reqbufs,
        .vidioc_querybuf                = vb2_ioctl_querybuf,
        .vidioc_qbuf                    = vb2_ioctl_qbuf,
        .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
        .vidioc_create_bufs             = vb2_ioctl_create_bufs,
        .vidioc_streamon                = vb2_ioctl_streamon,
        .vidioc_streamoff               = vb2_ioctl_streamoff,
        .vidioc_prepare_buf             = vb2_ioctl_prepare_buf,

        .vidioc_log_status              = v4l2_ctrl_log_status,
        .vidioc_subscribe_event         = v4l2_ctrl_subscribe_event,
        .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
};

void tw686x_video_irq(struct tw686x_dev *dev, unsigned long requests,
                      unsigned int pb_status, unsigned int fifo_status,
                      unsigned int *reset_ch)
{
        struct tw686x_video_channel *vc;
        unsigned long flags;
        unsigned int ch, pb;

        for_each_set_bit(ch, &requests, max_channels(dev)) {
                vc = &dev->video_channels[ch];

                /*
                 * This can either be a blue frame (with signal-lost bit set)
                 * or a good frame (with signal-lost bit clear). If we have just
                 * got signal, then this channel needs resetting.
                 */
                if (vc->no_signal && !(fifo_status & BIT(ch))) {
                        v4l2_printk(KERN_DEBUG, &dev->v4l2_dev,
                                    "video%d: signal recovered\n", vc->num);
                        vc->no_signal = false;
                        *reset_ch |= BIT(ch);
                        vc->pb = 0;
                        continue;
                }
                vc->no_signal = !!(fifo_status & BIT(ch));

                /* Check FIFO errors only if there's signal */
                if (!vc->no_signal) {
                        u32 fifo_ov, fifo_bad;

                        fifo_ov = (fifo_status >> 24) & BIT(ch);
                        fifo_bad = (fifo_status >> 16) & BIT(ch);
                        if (fifo_ov || fifo_bad) {
                                /* Mark this channel for reset */
                                v4l2_printk(KERN_DEBUG, &dev->v4l2_dev,
                                            "video%d: FIFO error\n", vc->num);
                                *reset_ch |= BIT(ch);
                                vc->pb = 0;
                                continue;
                        }
                }

                pb = !!(pb_status & BIT(ch));
                if (vc->pb != pb) {
                        /* Mark this channel for reset */
                        v4l2_printk(KERN_DEBUG, &dev->v4l2_dev,
                                    "video%d: unexpected p-b buffer!\n",
                                    vc->num);
                        *reset_ch |= BIT(ch);
                        vc->pb = 0;
                        continue;
                }

                spin_lock_irqsave(&vc->qlock, flags);
                tw686x_buf_done(vc, pb);
                dev->dma_ops->buf_refill(vc, pb);
                spin_unlock_irqrestore(&vc->qlock, flags);
        }
}

void tw686x_video_free(struct tw686x_dev *dev)
{
        unsigned int ch, pb;

        for (ch = 0; ch < max_channels(dev); ch++) {
                struct tw686x_video_channel *vc = &dev->video_channels[ch];

                video_unregister_device(vc->device);

                if (dev->dma_ops->free)
                        for (pb = 0; pb < 2; pb++)
                                dev->dma_ops->free(vc, pb);
        }
}

int tw686x_video_init(struct tw686x_dev *dev)
{
        unsigned int ch, val;
        int err;

        if (dev->dma_mode == TW686X_DMA_MODE_MEMCPY)
                dev->dma_ops = &memcpy_dma_ops;
        else if (dev->dma_mode == TW686X_DMA_MODE_CONTIG)
                dev->dma_ops = &contig_dma_ops;
        else if (dev->dma_mode == TW686X_DMA_MODE_SG)
                dev->dma_ops = &sg_dma_ops;
        else
                return -EINVAL;

        err = v4l2_device_register(&dev->pci_dev->dev, &dev->v4l2_dev);
        if (err)
                return err;

        if (dev->dma_ops->setup) {
                err = dev->dma_ops->setup(dev);
                if (err)
                        return err;
        }

        /* Initialize vc->dev and vc->ch for the error path */
        for (ch = 0; ch < max_channels(dev); ch++) {
                struct tw686x_video_channel *vc = &dev->video_channels[ch];

                vc->dev = dev;
                vc->ch = ch;
        }

        for (ch = 0; ch < max_channels(dev); ch++) {
                struct tw686x_video_channel *vc = &dev->video_channels[ch];
                struct video_device *vdev;

                mutex_init(&vc->vb_mutex);
                spin_lock_init(&vc->qlock);
                INIT_LIST_HEAD(&vc->vidq_queued);

                /* default settings */
                err = tw686x_set_standard(vc, V4L2_STD_NTSC);
                if (err)
                        goto error;

                err = tw686x_set_format(vc, formats[0].fourcc,
                                TW686X_VIDEO_WIDTH,
                                TW686X_VIDEO_HEIGHT(vc->video_standard),
                                true);
                if (err)
                        goto error;

                tw686x_set_input(vc, 0);
                tw686x_set_framerate(vc, 30);
                reg_write(dev, VDELAY_LO[ch], 0x14);
                reg_write(dev, HACTIVE_LO[ch], 0xd0);
                reg_write(dev, VIDEO_SIZE[ch], 0);

                vc->vidq.io_modes = VB2_READ | VB2_MMAP | VB2_DMABUF;
                vc->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                vc->vidq.drv_priv = vc;
                vc->vidq.buf_struct_size = sizeof(struct tw686x_v4l2_buf);
                vc->vidq.ops = &tw686x_video_qops;
                vc->vidq.mem_ops = dev->dma_ops->mem_ops;
                vc->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                vc->vidq.min_queued_buffers = 2;
                vc->vidq.lock = &vc->vb_mutex;
                vc->vidq.gfp_flags = dev->dma_mode != TW686X_DMA_MODE_MEMCPY ?
                                     GFP_DMA32 : 0;
                vc->vidq.dev = &dev->pci_dev->dev;

                err = vb2_queue_init(&vc->vidq);
                if (err) {
                        v4l2_err(&dev->v4l2_dev,
                                 "dma%d: cannot init vb2 queue\n", ch);
                        goto error;
                }

                err = v4l2_ctrl_handler_init(&vc->ctrl_handler, 4);
                if (err) {
                        v4l2_err(&dev->v4l2_dev,
                                 "dma%d: cannot init ctrl handler\n", ch);
                        goto error;
                }
                v4l2_ctrl_new_std(&vc->ctrl_handler, &ctrl_ops,
                                  V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
                v4l2_ctrl_new_std(&vc->ctrl_handler, &ctrl_ops,
                                  V4L2_CID_CONTRAST, 0, 255, 1, 100);
                v4l2_ctrl_new_std(&vc->ctrl_handler, &ctrl_ops,
                                  V4L2_CID_SATURATION, 0, 255, 1, 128);
                v4l2_ctrl_new_std(&vc->ctrl_handler, &ctrl_ops,
                                  V4L2_CID_HUE, -128, 127, 1, 0);
                err = vc->ctrl_handler.error;
                if (err)
                        goto error;

                err = v4l2_ctrl_handler_setup(&vc->ctrl_handler);
                if (err)
                        goto error;

                vdev = video_device_alloc();
                if (!vdev) {
                        v4l2_err(&dev->v4l2_dev,
                                 "dma%d: unable to allocate device\n", ch);
                        err = -ENOMEM;
                        goto error;
                }

                snprintf(vdev->name, sizeof(vdev->name), "%s video", dev->name);
                vdev->fops = &tw686x_video_fops;
                vdev->ioctl_ops = &tw686x_video_ioctl_ops;
                vdev->release = video_device_release;
                vdev->v4l2_dev = &dev->v4l2_dev;
                vdev->queue = &vc->vidq;
                vdev->tvnorms = V4L2_STD_525_60 | V4L2_STD_625_50;
                vdev->minor = -1;
                vdev->lock = &vc->vb_mutex;
                vdev->ctrl_handler = &vc->ctrl_handler;
                vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE |
                                    V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
                vc->device = vdev;
                video_set_drvdata(vdev, vc);

                err = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
                if (err < 0) {
                        video_device_release(vdev);
                        goto error;
                }
                vc->num = vdev->num;
        }

        val = TW686X_DEF_PHASE_REF;
        for (ch = 0; ch < max_channels(dev); ch++)
                val |= dev->dma_ops->hw_dma_mode << (16 + ch * 2);
        reg_write(dev, PHASE_REF, val);

        reg_write(dev, MISC2[0], 0xe7);
        reg_write(dev, VCTRL1[0], 0xcc);
        reg_write(dev, LOOP[0], 0xa5);
        if (max_channels(dev) > 4) {
                reg_write(dev, VCTRL1[1], 0xcc);
                reg_write(dev, LOOP[1], 0xa5);
                reg_write(dev, MISC2[1], 0xe7);
        }
        return 0;

error:
        tw686x_video_free(dev);
        return err;
}