|
|
@@ -1,813 +0,0 @@
|
|
|
-/*
|
|
|
- * Copyright (C) 2015 Industrial Research Institute for Automation
|
|
|
- * and Measurements PIAP
|
|
|
- *
|
|
|
- * Written by Krzysztof Ha?asa.
|
|
|
- *
|
|
|
- * This program is free software; you can redistribute it and/or modify it
|
|
|
- * under the terms of version 2 of the GNU General Public License
|
|
|
- * as published by the Free Software Foundation.
|
|
|
- */
|
|
|
-
|
|
|
-#include <linux/init.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 "tw686x-kh.h"
|
|
|
-#include "tw686x-kh-regs.h"
|
|
|
-
|
|
|
-#define MAX_SG_ENTRY_SIZE (/* 8192 - 128 */ 4096)
|
|
|
-#define MAX_SG_DESC_COUNT 256 /* PAL 704x576 needs up to 198 4-KB pages */
|
|
|
-
|
|
|
-static const struct tw686x_format formats[] = {
|
|
|
- {
|
|
|
- .name = "4:2:2 packed, UYVY", /* aka Y422 */
|
|
|
- .fourcc = V4L2_PIX_FMT_UYVY,
|
|
|
- .mode = 0,
|
|
|
- .depth = 16,
|
|
|
- }, {
|
|
|
-#if 0
|
|
|
- .name = "4:2:0 packed, YUV",
|
|
|
- .mode = 1, /* non-standard */
|
|
|
- .depth = 12,
|
|
|
- }, {
|
|
|
- .name = "4:1:1 packed, YUV",
|
|
|
- .mode = 2, /* non-standard */
|
|
|
- .depth = 12,
|
|
|
- }, {
|
|
|
-#endif
|
|
|
- .name = "4:1:1 packed, YUV",
|
|
|
- .fourcc = V4L2_PIX_FMT_Y41P,
|
|
|
- .mode = 3,
|
|
|
- .depth = 12,
|
|
|
- }, {
|
|
|
- .name = "15 bpp RGB",
|
|
|
- .fourcc = V4L2_PIX_FMT_RGB555,
|
|
|
- .mode = 4,
|
|
|
- .depth = 16,
|
|
|
- }, {
|
|
|
- .name = "16 bpp RGB",
|
|
|
- .fourcc = V4L2_PIX_FMT_RGB565,
|
|
|
- .mode = 5,
|
|
|
- .depth = 16,
|
|
|
- }, {
|
|
|
- .name = "4:2:2 packed, YUYV",
|
|
|
- .fourcc = V4L2_PIX_FMT_YUYV,
|
|
|
- .mode = 6,
|
|
|
- .depth = 16,
|
|
|
- }
|
|
|
- /* mode 7 is "reserved" */
|
|
|
-};
|
|
|
-
|
|
|
-static const v4l2_std_id video_standards[7] = {
|
|
|
- V4L2_STD_NTSC,
|
|
|
- V4L2_STD_PAL,
|
|
|
- V4L2_STD_SECAM,
|
|
|
- V4L2_STD_NTSC_443,
|
|
|
- V4L2_STD_PAL_M,
|
|
|
- V4L2_STD_PAL_N,
|
|
|
- V4L2_STD_PAL_60,
|
|
|
-};
|
|
|
-
|
|
|
-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 void tw686x_get_format(struct tw686x_video_channel *vc,
|
|
|
- struct v4l2_format *f)
|
|
|
-{
|
|
|
- const struct tw686x_format *format;
|
|
|
- unsigned int width, height, height_div = 1;
|
|
|
-
|
|
|
- format = format_by_fourcc(f->fmt.pix.pixelformat);
|
|
|
- if (!format) {
|
|
|
- format = &formats[0];
|
|
|
- f->fmt.pix.pixelformat = format->fourcc;
|
|
|
- }
|
|
|
-
|
|
|
- width = 704;
|
|
|
- if (f->fmt.pix.width < width * 3 / 4 /* halfway */)
|
|
|
- width /= 2;
|
|
|
-
|
|
|
- height = (vc->video_standard & V4L2_STD_625_50) ? 576 : 480;
|
|
|
- if (f->fmt.pix.height < height * 3 / 4 /* halfway */)
|
|
|
- height_div = 2;
|
|
|
-
|
|
|
- switch (f->fmt.pix.field) {
|
|
|
- case V4L2_FIELD_TOP:
|
|
|
- case V4L2_FIELD_BOTTOM:
|
|
|
- height_div = 2;
|
|
|
- break;
|
|
|
- case V4L2_FIELD_SEQ_BT:
|
|
|
- if (height_div > 1)
|
|
|
- f->fmt.pix.field = V4L2_FIELD_BOTTOM;
|
|
|
- break;
|
|
|
- default:
|
|
|
- if (height_div > 1)
|
|
|
- f->fmt.pix.field = V4L2_FIELD_TOP;
|
|
|
- else
|
|
|
- f->fmt.pix.field = V4L2_FIELD_SEQ_TB;
|
|
|
- }
|
|
|
- height /= height_div;
|
|
|
-
|
|
|
- f->fmt.pix.width = width;
|
|
|
- f->fmt.pix.height = 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;
|
|
|
-}
|
|
|
-
|
|
|
-/* video queue operations */
|
|
|
-
|
|
|
-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 size = vc->width * vc->height * vc->format->depth / 8;
|
|
|
-
|
|
|
- if (*nbuffers < 2)
|
|
|
- *nbuffers = 2;
|
|
|
-
|
|
|
- if (*nplanes)
|
|
|
- return sizes[0] < size ? -EINVAL : 0;
|
|
|
-
|
|
|
- sizes[0] = size;
|
|
|
- *nplanes = 1; /* packed formats only */
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static void tw686x_buf_queue(struct vb2_buffer *vb)
|
|
|
-{
|
|
|
- struct tw686x_video_channel *vc = vb2_get_drv_priv(vb->vb2_queue);
|
|
|
- struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
|
|
|
- struct tw686x_vb2_buf *buf;
|
|
|
-
|
|
|
- buf = container_of(vbuf, struct tw686x_vb2_buf, vb);
|
|
|
-
|
|
|
- spin_lock(&vc->qlock);
|
|
|
- list_add_tail(&buf->list, &vc->vidq_queued);
|
|
|
- spin_unlock(&vc->qlock);
|
|
|
-}
|
|
|
-
|
|
|
-static void setup_descs(struct tw686x_video_channel *vc, unsigned int n)
|
|
|
-{
|
|
|
-loop:
|
|
|
- while (!list_empty(&vc->vidq_queued)) {
|
|
|
- struct vdma_desc *descs = vc->sg_descs[n];
|
|
|
- struct tw686x_vb2_buf *buf;
|
|
|
- struct sg_table *vbuf;
|
|
|
- struct scatterlist *sg;
|
|
|
- unsigned int buf_len, count = 0;
|
|
|
- int i;
|
|
|
-
|
|
|
- buf = list_first_entry(&vc->vidq_queued, struct tw686x_vb2_buf,
|
|
|
- list);
|
|
|
- list_del(&buf->list);
|
|
|
-
|
|
|
- buf_len = vc->width * vc->height * vc->format->depth / 8;
|
|
|
- if (vb2_plane_size(&buf->vb.vb2_buf, 0) < buf_len) {
|
|
|
- pr_err("Video buffer size too small\n");
|
|
|
- vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
|
|
|
- goto loop; /* try another */
|
|
|
- }
|
|
|
-
|
|
|
- vbuf = vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0);
|
|
|
- for_each_sg(vbuf->sgl, sg, vbuf->nents, i) {
|
|
|
- dma_addr_t phys = sg_dma_address(sg);
|
|
|
- unsigned int len = sg_dma_len(sg);
|
|
|
-
|
|
|
- while (len && buf_len) {
|
|
|
- unsigned int entry_len = min_t(unsigned int, len,
|
|
|
- MAX_SG_ENTRY_SIZE);
|
|
|
- entry_len = min(entry_len, buf_len);
|
|
|
- if (count == MAX_SG_DESC_COUNT) {
|
|
|
- pr_err("Video buffer size too fragmented\n");
|
|
|
- vb2_buffer_done(&buf->vb.vb2_buf,
|
|
|
- VB2_BUF_STATE_ERROR);
|
|
|
- goto loop;
|
|
|
- }
|
|
|
- descs[count].phys = cpu_to_le32(phys);
|
|
|
- descs[count++].flags_length =
|
|
|
- cpu_to_le32(0x40000000 /* available */ |
|
|
|
- entry_len);
|
|
|
- phys += entry_len;
|
|
|
- len -= entry_len;
|
|
|
- buf_len -= entry_len;
|
|
|
- }
|
|
|
- if (!buf_len)
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- /* clear the remaining entries */
|
|
|
- while (count < MAX_SG_DESC_COUNT) {
|
|
|
- descs[count].phys = 0;
|
|
|
- descs[count++].flags_length = 0; /* unavailable */
|
|
|
- }
|
|
|
-
|
|
|
- buf->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
|
|
|
- vc->curr_bufs[n] = buf;
|
|
|
- return;
|
|
|
- }
|
|
|
- vc->curr_bufs[n] = NULL;
|
|
|
-}
|
|
|
-
|
|
|
-/* On TW6864 and TW6868, all channels share the pair of video DMA SG tables,
|
|
|
- with 10-bit start_idx and end_idx determining start and end of frame buffer
|
|
|
- for particular channel.
|
|
|
- TW6868 with all its 8 channels would be problematic (only 127 SG entries per
|
|
|
- channel) but we support only 4 channels on this chip anyway (the first
|
|
|
- 4 channels are driven with internal video decoder, the other 4 would require
|
|
|
- an external TW286x part).
|
|
|
-
|
|
|
- On TW6865 and TW6869, each channel has its own DMA SG table, with indexes
|
|
|
- starting with 0. Both chips have complete sets of internal video decoders
|
|
|
- (respectively 4 or 8-channel).
|
|
|
-
|
|
|
- All chips have separate SG tables for two video frames. */
|
|
|
-
|
|
|
-static void setup_dma_cfg(struct tw686x_video_channel *vc)
|
|
|
-{
|
|
|
- unsigned int field_width = 704;
|
|
|
- unsigned int field_height = (vc->video_standard & V4L2_STD_625_50) ?
|
|
|
- 288 : 240;
|
|
|
- unsigned int start_idx = is_second_gen(vc->dev) ? 0 :
|
|
|
- vc->ch * MAX_SG_DESC_COUNT;
|
|
|
- unsigned int end_idx = start_idx + MAX_SG_DESC_COUNT - 1;
|
|
|
- u32 dma_cfg = (0 << 30) /* input selection */ |
|
|
|
- (1 << 29) /* field2 dropped (if any) */ |
|
|
|
- ((vc->height < 300) << 28) /* field dropping */ |
|
|
|
- (1 << 27) /* master */ |
|
|
|
- (0 << 25) /* master channel (for slave only) */ |
|
|
|
- (0 << 24) /* (no) vertical (line) decimation */ |
|
|
|
- ((vc->width < 400) << 23) /* horizontal decimation */ |
|
|
|
- (vc->format->mode << 20) /* output video format */ |
|
|
|
- (end_idx << 10) /* DMA end index */ |
|
|
|
- start_idx /* DMA start index */;
|
|
|
- u32 reg;
|
|
|
-
|
|
|
- reg_write(vc->dev, VDMA_CHANNEL_CONFIG[vc->ch], dma_cfg);
|
|
|
- reg_write(vc->dev, VIDEO_SIZE[vc->ch], (1 << 31) | (field_height << 16)
|
|
|
- | field_width);
|
|
|
- reg = reg_read(vc->dev, VIDEO_CONTROL1);
|
|
|
- if (vc->video_standard & V4L2_STD_625_50)
|
|
|
- reg |= 1 << (vc->ch + 13);
|
|
|
- else
|
|
|
- reg &= ~(1 << (vc->ch + 13));
|
|
|
- reg_write(vc->dev, VIDEO_CONTROL1, reg);
|
|
|
-}
|
|
|
-
|
|
|
-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;
|
|
|
- u32 dma_ch_mask;
|
|
|
- unsigned int n;
|
|
|
-
|
|
|
- setup_dma_cfg(vc);
|
|
|
-
|
|
|
- /* queue video buffers if available */
|
|
|
- spin_lock(&vc->qlock);
|
|
|
- for (n = 0; n < 2; n++)
|
|
|
- setup_descs(vc, n);
|
|
|
- spin_unlock(&vc->qlock);
|
|
|
-
|
|
|
- dev->video_active |= 1 << vc->ch;
|
|
|
- vc->seq = 0;
|
|
|
- dma_ch_mask = reg_read(dev, DMA_CHANNEL_ENABLE) | (1 << vc->ch);
|
|
|
- reg_write(dev, DMA_CHANNEL_ENABLE, dma_ch_mask);
|
|
|
- reg_write(dev, DMA_CMD, (1 << 31) | dma_ch_mask);
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-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;
|
|
|
- u32 dma_ch_mask = reg_read(dev, DMA_CHANNEL_ENABLE);
|
|
|
- u32 dma_cmd = reg_read(dev, DMA_CMD);
|
|
|
- unsigned int n;
|
|
|
-
|
|
|
- dma_ch_mask &= ~(1 << vc->ch);
|
|
|
- reg_write(dev, DMA_CHANNEL_ENABLE, dma_ch_mask);
|
|
|
-
|
|
|
- dev->video_active &= ~(1 << vc->ch);
|
|
|
-
|
|
|
- dma_cmd &= ~(1 << vc->ch);
|
|
|
- reg_write(dev, DMA_CMD, dma_cmd);
|
|
|
-
|
|
|
- if (!dev->video_active) {
|
|
|
- reg_write(dev, DMA_CMD, 0);
|
|
|
- reg_write(dev, DMA_CHANNEL_ENABLE, 0);
|
|
|
- }
|
|
|
-
|
|
|
- spin_lock(&vc->qlock);
|
|
|
- while (!list_empty(&vc->vidq_queued)) {
|
|
|
- struct tw686x_vb2_buf *buf;
|
|
|
-
|
|
|
- buf = list_entry(vc->vidq_queued.next, struct tw686x_vb2_buf,
|
|
|
- list);
|
|
|
- list_del(&buf->list);
|
|
|
- vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
|
|
|
- }
|
|
|
-
|
|
|
- for (n = 0; n < 2; n++)
|
|
|
- if (vc->curr_bufs[n])
|
|
|
- vb2_buffer_done(&vc->curr_bufs[n]->vb.vb2_buf,
|
|
|
- VB2_BUF_STATE_ERROR);
|
|
|
-
|
|
|
- spin_unlock(&vc->qlock);
|
|
|
-}
|
|
|
-
|
|
|
-static struct vb2_ops tw686x_video_qops = {
|
|
|
- .queue_setup = tw686x_queue_setup,
|
|
|
- .buf_queue = tw686x_buf_queue,
|
|
|
- .start_streaming = tw686x_start_streaming,
|
|
|
- .stop_streaming = tw686x_stop_streaming,
|
|
|
- .wait_prepare = vb2_ops_wait_prepare,
|
|
|
- .wait_finish = vb2_ops_wait_finish,
|
|
|
-};
|
|
|
-
|
|
|
-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);
|
|
|
-
|
|
|
- f->fmt.pix.width = vc->width;
|
|
|
- f->fmt.pix.height = vc->height;
|
|
|
- f->fmt.pix.field = vc->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)
|
|
|
-{
|
|
|
- tw686x_get_format(video_drvdata(file), f);
|
|
|
- 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);
|
|
|
-
|
|
|
- tw686x_get_format(vc, f);
|
|
|
- vc->format = format_by_fourcc(f->fmt.pix.pixelformat);
|
|
|
- vc->field = f->fmt.pix.field;
|
|
|
- vc->width = f->fmt.pix.width;
|
|
|
- vc->height = f->fmt.pix.height;
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-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;
|
|
|
-
|
|
|
- strcpy(cap->driver, "tw686x-kh");
|
|
|
- strcpy(cap->card, dev->name);
|
|
|
- sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci_dev));
|
|
|
- cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
|
|
|
- cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int tw686x_s_std(struct file *file, void *priv, v4l2_std_id id)
|
|
|
-{
|
|
|
- struct tw686x_video_channel *vc = video_drvdata(file);
|
|
|
- unsigned int cnt;
|
|
|
- u32 sdt = 0; /* default */
|
|
|
-
|
|
|
- for (cnt = 0; cnt < ARRAY_SIZE(video_standards); cnt++)
|
|
|
- if (id & video_standards[cnt]) {
|
|
|
- sdt = cnt;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- reg_write(vc->dev, SDT[vc->ch], sdt);
|
|
|
- vc->video_standard = video_standards[sdt];
|
|
|
- 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_fmt_vid_cap(struct file *file, void *priv,
|
|
|
- struct v4l2_fmtdesc *f)
|
|
|
-{
|
|
|
- if (f->index >= ARRAY_SIZE(formats))
|
|
|
- return -EINVAL;
|
|
|
-
|
|
|
- strlcpy(f->description, formats[f->index].name, sizeof(f->description));
|
|
|
- f->pixelformat = formats[f->index].fourcc;
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int tw686x_g_parm(struct file *file, void *priv,
|
|
|
- struct v4l2_streamparm *sp)
|
|
|
-{
|
|
|
- struct tw686x_video_channel *vc = video_drvdata(file);
|
|
|
-
|
|
|
- if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
|
|
- return -EINVAL;
|
|
|
- memset(&sp->parm.capture, 0, sizeof(sp->parm.capture));
|
|
|
- sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
|
|
|
- v4l2_video_std_frame_period(vc->video_standard,
|
|
|
- &sp->parm.capture.timeperframe);
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int tw686x_enum_input(struct file *file, void *priv,
|
|
|
- struct v4l2_input *inp)
|
|
|
-{
|
|
|
- /* the chip has internal multiplexer, support can be added
|
|
|
- if the actual hw uses it */
|
|
|
- if (inp->index)
|
|
|
- return -EINVAL;
|
|
|
-
|
|
|
- snprintf(inp->name, sizeof(inp->name), "Composite");
|
|
|
- inp->type = V4L2_INPUT_TYPE_CAMERA;
|
|
|
- inp->std = V4L2_STD_ALL;
|
|
|
- inp->capabilities = V4L2_IN_CAP_STD;
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int tw686x_g_input(struct file *file, void *priv, unsigned int *v)
|
|
|
-{
|
|
|
- *v = 0;
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int tw686x_s_input(struct file *file, void *priv, unsigned int v)
|
|
|
-{
|
|
|
- if (v)
|
|
|
- return -EINVAL;
|
|
|
- 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_enum_fmt_vid_cap = tw686x_enum_fmt_vid_cap,
|
|
|
- .vidioc_g_fmt_vid_cap = tw686x_g_fmt_vid_cap,
|
|
|
- .vidioc_s_fmt_vid_cap = tw686x_s_fmt_vid_cap,
|
|
|
- .vidioc_try_fmt_vid_cap = tw686x_try_fmt_vid_cap,
|
|
|
- .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_g_std = tw686x_g_std,
|
|
|
- .vidioc_s_std = tw686x_s_std,
|
|
|
- .vidioc_g_parm = tw686x_g_parm,
|
|
|
- .vidioc_enum_input = tw686x_enum_input,
|
|
|
- .vidioc_g_input = tw686x_g_input,
|
|
|
- .vidioc_s_input = tw686x_s_input,
|
|
|
- .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
|
|
|
- .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
|
|
|
-};
|
|
|
-
|
|
|
-static int video_thread(void *arg)
|
|
|
-{
|
|
|
- struct tw686x_dev *dev = arg;
|
|
|
- DECLARE_WAITQUEUE(wait, current);
|
|
|
-
|
|
|
- set_freezable();
|
|
|
- add_wait_queue(&dev->video_thread_wait, &wait);
|
|
|
-
|
|
|
- while (1) {
|
|
|
- long timeout = schedule_timeout_interruptible(HZ);
|
|
|
- unsigned int ch;
|
|
|
-
|
|
|
- if (timeout == -ERESTARTSYS || kthread_should_stop())
|
|
|
- break;
|
|
|
-
|
|
|
- for (ch = 0; ch < max_channels(dev); ch++) {
|
|
|
- struct tw686x_video_channel *vc;
|
|
|
- unsigned long flags;
|
|
|
- u32 request, n, stat = VB2_BUF_STATE_DONE;
|
|
|
-
|
|
|
- vc = &dev->video_channels[ch];
|
|
|
- if (!(dev->video_active & (1 << ch)))
|
|
|
- continue;
|
|
|
-
|
|
|
- spin_lock_irq(&dev->irq_lock);
|
|
|
- request = dev->dma_requests & (0x01000001 << ch);
|
|
|
- if (request)
|
|
|
- dev->dma_requests &= ~request;
|
|
|
- spin_unlock_irq(&dev->irq_lock);
|
|
|
-
|
|
|
- if (!request)
|
|
|
- continue;
|
|
|
-
|
|
|
- request >>= ch;
|
|
|
-
|
|
|
- /* handle channel events */
|
|
|
- if ((request & 0x01000000) |
|
|
|
- (reg_read(dev, VIDEO_FIFO_STATUS) & (0x01010001 << ch)) |
|
|
|
- (reg_read(dev, VIDEO_PARSER_STATUS) & (0x00000101 << ch))) {
|
|
|
- /* DMA Errors - reset channel */
|
|
|
- u32 reg;
|
|
|
-
|
|
|
- spin_lock_irqsave(&dev->irq_lock, flags);
|
|
|
- reg = reg_read(dev, DMA_CMD);
|
|
|
- /* Reset DMA channel */
|
|
|
- reg_write(dev, DMA_CMD, reg & ~(1 << ch));
|
|
|
- reg_write(dev, DMA_CMD, reg);
|
|
|
- spin_unlock_irqrestore(&dev->irq_lock, flags);
|
|
|
- stat = VB2_BUF_STATE_ERROR;
|
|
|
- }
|
|
|
-
|
|
|
- /* handle video stream */
|
|
|
- mutex_lock(&vc->vb_mutex);
|
|
|
- spin_lock(&vc->qlock);
|
|
|
- n = !!(reg_read(dev, PB_STATUS) & (1 << ch));
|
|
|
- if (vc->curr_bufs[n]) {
|
|
|
- struct vb2_v4l2_buffer *vb;
|
|
|
-
|
|
|
- vb = &vc->curr_bufs[n]->vb;
|
|
|
- vb->vb2_buf.timestamp = ktime_get_ns();
|
|
|
- vb->field = vc->field;
|
|
|
- if (V4L2_FIELD_HAS_BOTH(vc->field))
|
|
|
- vb->sequence = vc->seq++;
|
|
|
- else
|
|
|
- vb->sequence = (vc->seq++) / 2;
|
|
|
- vb2_set_plane_payload(&vb->vb2_buf, 0,
|
|
|
- vc->width * vc->height * vc->format->depth / 8);
|
|
|
- vb2_buffer_done(&vb->vb2_buf, stat);
|
|
|
- }
|
|
|
- setup_descs(vc, n);
|
|
|
- spin_unlock(&vc->qlock);
|
|
|
- mutex_unlock(&vc->vb_mutex);
|
|
|
- }
|
|
|
- try_to_freeze();
|
|
|
- }
|
|
|
-
|
|
|
- remove_wait_queue(&dev->video_thread_wait, &wait);
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-int tw686x_kh_video_irq(struct tw686x_dev *dev)
|
|
|
-{
|
|
|
- unsigned long flags, handled = 0;
|
|
|
- u32 requests;
|
|
|
-
|
|
|
- spin_lock_irqsave(&dev->irq_lock, flags);
|
|
|
- requests = dev->dma_requests;
|
|
|
- spin_unlock_irqrestore(&dev->irq_lock, flags);
|
|
|
-
|
|
|
- if (requests & dev->video_active) {
|
|
|
- wake_up_interruptible_all(&dev->video_thread_wait);
|
|
|
- handled = 1;
|
|
|
- }
|
|
|
- return handled;
|
|
|
-}
|
|
|
-
|
|
|
-void tw686x_kh_video_free(struct tw686x_dev *dev)
|
|
|
-{
|
|
|
- unsigned int ch, n;
|
|
|
-
|
|
|
- if (dev->video_thread)
|
|
|
- kthread_stop(dev->video_thread);
|
|
|
-
|
|
|
- for (ch = 0; ch < max_channels(dev); ch++) {
|
|
|
- struct tw686x_video_channel *vc = &dev->video_channels[ch];
|
|
|
-
|
|
|
- v4l2_ctrl_handler_free(&vc->ctrl_handler);
|
|
|
- if (vc->device)
|
|
|
- video_unregister_device(vc->device);
|
|
|
- for (n = 0; n < 2; n++) {
|
|
|
- struct dma_desc *descs = &vc->sg_tables[n];
|
|
|
-
|
|
|
- if (descs->virt)
|
|
|
- pci_free_consistent(dev->pci_dev, descs->size,
|
|
|
- descs->virt, descs->phys);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- v4l2_device_unregister(&dev->v4l2_dev);
|
|
|
-}
|
|
|
-
|
|
|
-#define SG_TABLE_SIZE (MAX_SG_DESC_COUNT * sizeof(struct vdma_desc))
|
|
|
-
|
|
|
-int tw686x_kh_video_init(struct tw686x_dev *dev)
|
|
|
-{
|
|
|
- unsigned int ch, n;
|
|
|
- int err;
|
|
|
-
|
|
|
- init_waitqueue_head(&dev->video_thread_wait);
|
|
|
-
|
|
|
- err = v4l2_device_register(&dev->pci_dev->dev, &dev->v4l2_dev);
|
|
|
- if (err)
|
|
|
- return err;
|
|
|
-
|
|
|
- reg_write(dev, VIDEO_CONTROL1, 0); /* NTSC, disable scaler */
|
|
|
- reg_write(dev, PHASE_REF, 0x00001518); /* Scatter-gather DMA mode */
|
|
|
-
|
|
|
- /* setup required SG table sizes */
|
|
|
- for (n = 0; n < 2; n++)
|
|
|
- if (is_second_gen(dev)) {
|
|
|
- /* TW 6865, TW6869 - each channel needs a pair of
|
|
|
- descriptor tables */
|
|
|
- for (ch = 0; ch < max_channels(dev); ch++)
|
|
|
- dev->video_channels[ch].sg_tables[n].size =
|
|
|
- SG_TABLE_SIZE;
|
|
|
-
|
|
|
- } else
|
|
|
- /* TW 6864, TW6868 - we need to allocate a pair of
|
|
|
- descriptor tables, common for all channels.
|
|
|
- Each table will be bigger than 4 KB. */
|
|
|
- dev->video_channels[0].sg_tables[n].size =
|
|
|
- max_channels(dev) * SG_TABLE_SIZE;
|
|
|
-
|
|
|
- /* allocate SG tables and initialize video channels */
|
|
|
- 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);
|
|
|
-
|
|
|
- vc->dev = dev;
|
|
|
- vc->ch = ch;
|
|
|
-
|
|
|
- /* default settings: NTSC */
|
|
|
- vc->format = &formats[0];
|
|
|
- vc->video_standard = V4L2_STD_NTSC;
|
|
|
- reg_write(vc->dev, SDT[vc->ch], 0);
|
|
|
- vc->field = V4L2_FIELD_SEQ_BT;
|
|
|
- vc->width = 704;
|
|
|
- vc->height = 480;
|
|
|
-
|
|
|
- for (n = 0; n < 2; n++) {
|
|
|
- void *cpu;
|
|
|
-
|
|
|
- if (vc->sg_tables[n].size) {
|
|
|
- unsigned int reg = n ? DMA_PAGE_TABLE1_ADDR[ch] :
|
|
|
- DMA_PAGE_TABLE0_ADDR[ch];
|
|
|
-
|
|
|
- cpu = pci_alloc_consistent(dev->pci_dev,
|
|
|
- vc->sg_tables[n].size,
|
|
|
- &vc->sg_tables[n].phys);
|
|
|
- if (!cpu) {
|
|
|
- pr_err("Error allocating video DMA scatter-gather tables\n");
|
|
|
- err = -ENOMEM;
|
|
|
- goto error;
|
|
|
- }
|
|
|
- vc->sg_tables[n].virt = cpu;
|
|
|
- reg_write(dev, reg, vc->sg_tables[n].phys);
|
|
|
- } else
|
|
|
- cpu = dev->video_channels[0].sg_tables[n].virt +
|
|
|
- ch * SG_TABLE_SIZE;
|
|
|
-
|
|
|
- vc->sg_descs[n] = cpu;
|
|
|
- }
|
|
|
-
|
|
|
- reg_write(dev, VCTRL1[0], 0x24);
|
|
|
- reg_write(dev, LOOP[0], 0xA5);
|
|
|
- if (max_channels(dev) > 4) {
|
|
|
- reg_write(dev, VCTRL1[1], 0x24);
|
|
|
- reg_write(dev, LOOP[1], 0xA5);
|
|
|
- }
|
|
|
- reg_write(dev, VIDEO_FIELD_CTRL[ch], 0);
|
|
|
- reg_write(dev, VDELAY_LO[ch], 0x14);
|
|
|
-
|
|
|
- vdev = video_device_alloc();
|
|
|
- if (!vdev) {
|
|
|
- pr_warn("Unable to allocate video device\n");
|
|
|
- err = -ENOMEM;
|
|
|
- goto error;
|
|
|
- }
|
|
|
-
|
|
|
- vc->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
|
- vc->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
|
|
|
- vc->vidq.drv_priv = vc;
|
|
|
- vc->vidq.buf_struct_size = sizeof(struct tw686x_vb2_buf);
|
|
|
- vc->vidq.ops = &tw686x_video_qops;
|
|
|
- vc->vidq.mem_ops = &vb2_dma_sg_memops;
|
|
|
- vc->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
|
|
|
- vc->vidq.min_buffers_needed = 2;
|
|
|
- vc->vidq.lock = &vc->vb_mutex;
|
|
|
- vc->vidq.dev = &dev->pci_dev->dev;
|
|
|
- vc->vidq.gfp_flags = GFP_DMA32;
|
|
|
-
|
|
|
- err = vb2_queue_init(&vc->vidq);
|
|
|
- if (err)
|
|
|
- goto error;
|
|
|
-
|
|
|
- strcpy(vdev->name, "TW686x-video");
|
|
|
- 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_ALL;
|
|
|
- vdev->minor = -1;
|
|
|
- vdev->lock = &vc->vb_mutex;
|
|
|
-
|
|
|
- dev->video_channels[ch].device = vdev;
|
|
|
- video_set_drvdata(vdev, vc);
|
|
|
- err = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
|
|
|
- if (err < 0)
|
|
|
- goto error;
|
|
|
-
|
|
|
- v4l2_ctrl_handler_init(&vc->ctrl_handler,
|
|
|
- 4 /* number of controls */);
|
|
|
- vdev->ctrl_handler = &vc->ctrl_handler;
|
|
|
- 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, 64);
|
|
|
- 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,
|
|
|
- -124, 127, 1, 0);
|
|
|
- err = vc->ctrl_handler.error;
|
|
|
- if (err)
|
|
|
- goto error;
|
|
|
-
|
|
|
- v4l2_ctrl_handler_setup(&vc->ctrl_handler);
|
|
|
- }
|
|
|
-
|
|
|
- dev->video_thread = kthread_run(video_thread, dev, "tw686x_video");
|
|
|
- if (IS_ERR(dev->video_thread)) {
|
|
|
- err = PTR_ERR(dev->video_thread);
|
|
|
- goto error;
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
-
|
|
|
-error:
|
|
|
- tw686x_kh_video_free(dev);
|
|
|
- return err;
|
|
|
-}
|
Hans Verkuil