blob: cf15bb1962efb69e5022ccbdf508bdcd87e2579c [file] [log] [blame]
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001/*
2 * Copyright (C) 2009 Texas Instruments Inc
Lad, Prabhakar96787eb2014-05-16 10:33:55 -03003 * Copyright (C) 2014 Lad, Prabhakar <prabhakar.csengg@gmail.com>
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03004 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * TODO : add support for VBI & HBI data service
20 * add static buffer allocation
21 */
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030022
Lad, Prabhakar012eef72013-04-19 05:53:29 -030023#include <linux/module.h>
24#include <linux/interrupt.h>
25#include <linux/platform_device.h>
26#include <linux/slab.h>
27
Lad, Prabhakar012eef72013-04-19 05:53:29 -030028#include <media/v4l2-ioctl.h>
29
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030030#include "vpif.h"
Lad, Prabhakar012eef72013-04-19 05:53:29 -030031#include "vpif_capture.h"
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030032
33MODULE_DESCRIPTION("TI DaVinci VPIF Capture driver");
34MODULE_LICENSE("GPL");
Mauro Carvalho Chehab64dc3c12011-06-25 11:28:37 -030035MODULE_VERSION(VPIF_CAPTURE_VERSION);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030036
37#define vpif_err(fmt, arg...) v4l2_err(&vpif_obj.v4l2_dev, fmt, ## arg)
38#define vpif_dbg(level, debug, fmt, arg...) \
39 v4l2_dbg(level, debug, &vpif_obj.v4l2_dev, fmt, ## arg)
40
41static int debug = 1;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030042
43module_param(debug, int, 0644);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030044
45MODULE_PARM_DESC(debug, "Debug level 0-1");
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030046
Lad, Prabhakare75ea0c2014-05-16 10:33:46 -030047#define VPIF_DRIVER_NAME "vpif_capture"
48
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030049/* global variables */
50static struct vpif_device vpif_obj = { {NULL} };
51static struct device *vpif_dev;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -030052static void vpif_calculate_offsets(struct channel_obj *ch);
53static void vpif_config_addr(struct channel_obj *ch, int muxmode);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030054
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -030055static u8 channel_first_int[VPIF_NUMBER_OF_OBJECTS][2] = { {1, 1} };
56
Lad, Prabhakarc66238f2014-05-16 10:33:45 -030057/* Is set to 1 in case of SDTV formats, 2 in case of HDTV formats. */
58static int ycmux_mode;
59
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -030060static inline struct vpif_cap_buffer *to_vpif_buffer(struct vb2_buffer *vb)
61{
62 return container_of(vb, struct vpif_cap_buffer, vb);
63}
64
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030065/**
Lad, Prabhakar23e76a22014-05-16 10:33:37 -030066 * vpif_buffer_prepare : callback function for buffer prepare
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -030067 * @vb: ptr to vb2_buffer
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030068 *
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -030069 * This is the callback function for buffer prepare when vb2_qbuf()
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030070 * function is called. The buffer is prepared and user space virtual address
71 * or user address is converted into physical address
72 */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -030073static int vpif_buffer_prepare(struct vb2_buffer *vb)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030074{
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -030075 struct vb2_queue *q = vb->vb2_queue;
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -030076 struct channel_obj *ch = vb2_get_drv_priv(q);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030077 struct common_obj *common;
78 unsigned long addr;
79
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030080 vpif_dbg(2, debug, "vpif_buffer_prepare\n");
81
82 common = &ch->common[VPIF_VIDEO_INDEX];
83
Lad, Prabhakar23e76a22014-05-16 10:33:37 -030084 vb2_set_plane_payload(vb, 0, common->fmt.fmt.pix.sizeimage);
85 if (vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
86 return -EINVAL;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030087
Lad, Prabhakar23e76a22014-05-16 10:33:37 -030088 vb->v4l2_buf.field = common->fmt.fmt.pix.field;
89
90 addr = vb2_dma_contig_plane_dma_addr(vb, 0);
91 if (!IS_ALIGNED((addr + common->ytop_off), 8) ||
92 !IS_ALIGNED((addr + common->ybtm_off), 8) ||
93 !IS_ALIGNED((addr + common->ctop_off), 8) ||
94 !IS_ALIGNED((addr + common->cbtm_off), 8)) {
95 vpif_dbg(1, debug, "offset is not aligned\n");
96 return -EINVAL;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030097 }
Lad, Prabhakar23e76a22014-05-16 10:33:37 -030098
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -030099 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300100}
101
102/**
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300103 * vpif_buffer_queue_setup : Callback function for buffer setup.
104 * @vq: vb2_queue ptr
105 * @fmt: v4l2 format
106 * @nbuffers: ptr to number of buffers requested by application
107 * @nplanes:: contains number of distinct video planes needed to hold a frame
108 * @sizes[]: contains the size (in bytes) of each plane.
109 * @alloc_ctxs: ptr to allocation context
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300110 *
111 * This callback function is called when reqbuf() is called to adjust
112 * the buffer count and buffer size
113 */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300114static int vpif_buffer_queue_setup(struct vb2_queue *vq,
115 const struct v4l2_format *fmt,
116 unsigned int *nbuffers, unsigned int *nplanes,
117 unsigned int sizes[], void *alloc_ctxs[])
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300118{
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -0300119 struct channel_obj *ch = vb2_get_drv_priv(vq);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300120 struct common_obj *common;
121
122 common = &ch->common[VPIF_VIDEO_INDEX];
123
124 vpif_dbg(2, debug, "vpif_buffer_setup\n");
125
Lad, Prabhakar837939d2014-05-16 10:33:38 -0300126 if (fmt && fmt->fmt.pix.sizeimage < common->fmt.fmt.pix.sizeimage)
127 return -EINVAL;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300128
Lad, Prabhakar837939d2014-05-16 10:33:38 -0300129 if (vq->num_buffers + *nbuffers < 3)
130 *nbuffers = 3 - vq->num_buffers;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300131
132 *nplanes = 1;
Lad, Prabhakar837939d2014-05-16 10:33:38 -0300133 sizes[0] = fmt ? fmt->fmt.pix.sizeimage : common->fmt.fmt.pix.sizeimage;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300134 alloc_ctxs[0] = common->alloc_ctx;
135
Lad, Prabhakar837939d2014-05-16 10:33:38 -0300136 /* Calculate the offset for Y and C data in the buffer */
137 vpif_calculate_offsets(ch);
138
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300139 return 0;
140}
141
142/**
143 * vpif_buffer_queue : Callback function to add buffer to DMA queue
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300144 * @vb: ptr to vb2_buffer
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300145 */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300146static void vpif_buffer_queue(struct vb2_buffer *vb)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300147{
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -0300148 struct channel_obj *ch = vb2_get_drv_priv(vb->vb2_queue);
149 struct vpif_cap_buffer *buf = to_vpif_buffer(vb);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300150 struct common_obj *common;
Hans Verkuilaec96832012-11-16 12:03:06 -0300151 unsigned long flags;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300152
153 common = &ch->common[VPIF_VIDEO_INDEX];
154
155 vpif_dbg(2, debug, "vpif_buffer_queue\n");
156
Hans Verkuilaec96832012-11-16 12:03:06 -0300157 spin_lock_irqsave(&common->irqlock, flags);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300158 /* add the buffer to the DMA queue */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300159 list_add_tail(&buf->list, &common->dma_queue);
Hans Verkuilaec96832012-11-16 12:03:06 -0300160 spin_unlock_irqrestore(&common->irqlock, flags);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300161}
162
Lad, Prabhakar41b9f242014-05-16 10:33:39 -0300163/**
164 * vpif_start_streaming : Starts the DMA engine for streaming
165 * @vb: ptr to vb2_buffer
166 * @count: number of buffers
167 */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300168static int vpif_start_streaming(struct vb2_queue *vq, unsigned int count)
169{
170 struct vpif_capture_config *vpif_config_data =
171 vpif_dev->platform_data;
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -0300172 struct channel_obj *ch = vb2_get_drv_priv(vq);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300173 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
174 struct vpif_params *vpif = &ch->vpifparams;
Lad, Prabhakarbebd8d12014-05-16 10:33:35 -0300175 struct vpif_cap_buffer *buf, *tmp;
176 unsigned long addr, flags;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300177 int ret;
178
Hans Verkuilaec96832012-11-16 12:03:06 -0300179 spin_lock_irqsave(&common->irqlock, flags);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300180
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300181 /* Initialize field_id */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300182 ch->field_id = 0;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300183
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300184 /* configure 1 or 2 channel mode */
Lad, Prabhakarf4ad8d72012-09-27 02:33:12 -0300185 if (vpif_config_data->setup_input_channel_mode) {
186 ret = vpif_config_data->
187 setup_input_channel_mode(vpif->std_info.ycmux_mode);
188 if (ret < 0) {
189 vpif_dbg(1, debug, "can't set vpif channel mode\n");
Lad, Prabhakarbebd8d12014-05-16 10:33:35 -0300190 goto err;
Lad, Prabhakarf4ad8d72012-09-27 02:33:12 -0300191 }
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300192 }
193
Lad, Prabhakard9a3b132014-05-16 10:33:42 -0300194 ret = v4l2_subdev_call(ch->sd, video, s_stream, 1);
195 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) {
196 vpif_dbg(1, debug, "stream on failed in subdev\n");
197 goto err;
198 }
199
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300200 /* Call vpif_set_params function to set the parameters and addresses */
201 ret = vpif_set_video_params(vpif, ch->channel_id);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300202 if (ret < 0) {
203 vpif_dbg(1, debug, "can't set video params\n");
Lad, Prabhakarbebd8d12014-05-16 10:33:35 -0300204 goto err;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300205 }
206
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300207 ycmux_mode = ret;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300208 vpif_config_addr(ch, ret);
209
Lad, Prabhakarbebd8d12014-05-16 10:33:35 -0300210 /* Get the next frame from the buffer queue */
211 common->cur_frm = common->next_frm = list_entry(common->dma_queue.next,
212 struct vpif_cap_buffer, list);
213 /* Remove buffer from the buffer queue */
214 list_del(&common->cur_frm->list);
215 spin_unlock_irqrestore(&common->irqlock, flags);
216 /* Mark state of the current frame to active */
217 common->cur_frm->vb.state = VB2_BUF_STATE_ACTIVE;
218
219 addr = vb2_dma_contig_plane_dma_addr(&common->cur_frm->vb, 0);
220
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300221 common->set_addr(addr + common->ytop_off,
222 addr + common->ybtm_off,
223 addr + common->ctop_off,
224 addr + common->cbtm_off);
225
226 /**
227 * Set interrupt for both the fields in VPIF Register enable channel in
228 * VPIF register
229 */
Lad, Prabhakar9e184042012-09-14 10:22:24 -0300230 channel_first_int[VPIF_VIDEO_INDEX][ch->channel_id] = 1;
Lad, Prabhakar41b9f242014-05-16 10:33:39 -0300231 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300232 channel0_intr_assert();
233 channel0_intr_enable(1);
234 enable_channel0(1);
235 }
Lad, Prabhakar41b9f242014-05-16 10:33:39 -0300236 if (VPIF_CHANNEL1_VIDEO == ch->channel_id ||
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300237 ycmux_mode == 2) {
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300238 channel1_intr_assert();
239 channel1_intr_enable(1);
240 enable_channel1(1);
241 }
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300242
243 return 0;
Lad, Prabhakarbebd8d12014-05-16 10:33:35 -0300244
245err:
246 list_for_each_entry_safe(buf, tmp, &common->dma_queue, list) {
247 list_del(&buf->list);
248 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_QUEUED);
249 }
Dan Carpenter92491962014-06-12 04:01:45 -0300250 spin_unlock_irqrestore(&common->irqlock, flags);
Lad, Prabhakarbebd8d12014-05-16 10:33:35 -0300251
252 return ret;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300253}
254
Lad, Prabhakar41b9f242014-05-16 10:33:39 -0300255/**
256 * vpif_stop_streaming : Stop the DMA engine
257 * @vq: ptr to vb2_queue
258 *
259 * This callback stops the DMA engine and any remaining buffers
260 * in the DMA queue are released.
261 */
Hans Verkuile37559b2014-04-17 02:47:21 -0300262static void vpif_stop_streaming(struct vb2_queue *vq)
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300263{
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -0300264 struct channel_obj *ch = vb2_get_drv_priv(vq);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300265 struct common_obj *common;
Hans Verkuilaec96832012-11-16 12:03:06 -0300266 unsigned long flags;
Lad, Prabhakard9a3b132014-05-16 10:33:42 -0300267 int ret;
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300268
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300269 common = &ch->common[VPIF_VIDEO_INDEX];
270
Lad, Prabhakare6ba3db2014-03-22 08:03:07 -0300271 /* Disable channel as per its device type and channel id */
272 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
273 enable_channel0(0);
274 channel0_intr_enable(0);
275 }
Lad, Prabhakar41b9f242014-05-16 10:33:39 -0300276 if (VPIF_CHANNEL1_VIDEO == ch->channel_id ||
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300277 ycmux_mode == 2) {
Lad, Prabhakare6ba3db2014-03-22 08:03:07 -0300278 enable_channel1(0);
279 channel1_intr_enable(0);
280 }
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300281
282 ycmux_mode = 0;
Lad, Prabhakare6ba3db2014-03-22 08:03:07 -0300283
Lad, Prabhakard9a3b132014-05-16 10:33:42 -0300284 ret = v4l2_subdev_call(ch->sd, video, s_stream, 0);
285 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV)
286 vpif_dbg(1, debug, "stream off failed in subdev\n");
287
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300288 /* release all active buffers */
Hans Verkuilaec96832012-11-16 12:03:06 -0300289 spin_lock_irqsave(&common->irqlock, flags);
Lad, Prabhakare6ba3db2014-03-22 08:03:07 -0300290 if (common->cur_frm == common->next_frm) {
291 vb2_buffer_done(&common->cur_frm->vb, VB2_BUF_STATE_ERROR);
292 } else {
293 if (common->cur_frm != NULL)
294 vb2_buffer_done(&common->cur_frm->vb,
295 VB2_BUF_STATE_ERROR);
296 if (common->next_frm != NULL)
297 vb2_buffer_done(&common->next_frm->vb,
298 VB2_BUF_STATE_ERROR);
299 }
300
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300301 while (!list_empty(&common->dma_queue)) {
302 common->next_frm = list_entry(common->dma_queue.next,
303 struct vpif_cap_buffer, list);
304 list_del(&common->next_frm->list);
305 vb2_buffer_done(&common->next_frm->vb, VB2_BUF_STATE_ERROR);
306 }
Hans Verkuilaec96832012-11-16 12:03:06 -0300307 spin_unlock_irqrestore(&common->irqlock, flags);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300308}
309
310static struct vb2_ops video_qops = {
311 .queue_setup = vpif_buffer_queue_setup,
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300312 .buf_prepare = vpif_buffer_prepare,
313 .start_streaming = vpif_start_streaming,
314 .stop_streaming = vpif_stop_streaming,
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300315 .buf_queue = vpif_buffer_queue,
316};
317
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300318/**
319 * vpif_process_buffer_complete: process a completed buffer
320 * @common: ptr to common channel object
321 *
322 * This function time stamp the buffer and mark it as DONE. It also
323 * wake up any process waiting on the QUEUE and set the next buffer
324 * as current
325 */
326static void vpif_process_buffer_complete(struct common_obj *common)
327{
Sakari Ailus8e6057b2012-09-15 15:14:42 -0300328 v4l2_get_timestamp(&common->cur_frm->vb.v4l2_buf.timestamp);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300329 vb2_buffer_done(&common->cur_frm->vb,
330 VB2_BUF_STATE_DONE);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300331 /* Make curFrm pointing to nextFrm */
332 common->cur_frm = common->next_frm;
333}
334
335/**
336 * vpif_schedule_next_buffer: set next buffer address for capture
337 * @common : ptr to common channel object
338 *
339 * This function will get next buffer from the dma queue and
340 * set the buffer address in the vpif register for capture.
341 * the buffer is marked active
342 */
343static void vpif_schedule_next_buffer(struct common_obj *common)
344{
345 unsigned long addr = 0;
346
Hans Verkuilaec96832012-11-16 12:03:06 -0300347 spin_lock(&common->irqlock);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300348 common->next_frm = list_entry(common->dma_queue.next,
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300349 struct vpif_cap_buffer, list);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300350 /* Remove that buffer from the buffer queue */
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300351 list_del(&common->next_frm->list);
Hans Verkuilaec96832012-11-16 12:03:06 -0300352 spin_unlock(&common->irqlock);
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300353 common->next_frm->vb.state = VB2_BUF_STATE_ACTIVE;
354 addr = vb2_dma_contig_plane_dma_addr(&common->next_frm->vb, 0);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300355
356 /* Set top and bottom field addresses in VPIF registers */
357 common->set_addr(addr + common->ytop_off,
358 addr + common->ybtm_off,
359 addr + common->ctop_off,
360 addr + common->cbtm_off);
361}
362
363/**
364 * vpif_channel_isr : ISR handler for vpif capture
365 * @irq: irq number
366 * @dev_id: dev_id ptr
367 *
368 * It changes status of the captured buffer, takes next buffer from the queue
Mats Randgaard2c0ddd12010-12-16 12:17:45 -0300369 * and sets its address in VPIF registers
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300370 */
371static irqreturn_t vpif_channel_isr(int irq, void *dev_id)
372{
373 struct vpif_device *dev = &vpif_obj;
374 struct common_obj *common;
375 struct channel_obj *ch;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300376 int channel_id = 0;
377 int fid = -1, i;
378
379 channel_id = *(int *)(dev_id);
Manjunath Hadlib1fc4232012-04-13 04:43:10 -0300380 if (!vpif_intr_status(channel_id))
381 return IRQ_NONE;
382
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300383 ch = dev->dev[channel_id];
384
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300385 for (i = 0; i < VPIF_NUMBER_OF_OBJECTS; i++) {
386 common = &ch->common[i];
387 /* skip If streaming is not started in this channel */
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300388 /* Check the field format */
389 if (1 == ch->vpifparams.std_info.frm_fmt) {
390 /* Progressive mode */
Hans Verkuilaec96832012-11-16 12:03:06 -0300391 spin_lock(&common->irqlock);
392 if (list_empty(&common->dma_queue)) {
393 spin_unlock(&common->irqlock);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300394 continue;
Hans Verkuilaec96832012-11-16 12:03:06 -0300395 }
396 spin_unlock(&common->irqlock);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300397
398 if (!channel_first_int[i][channel_id])
399 vpif_process_buffer_complete(common);
400
401 channel_first_int[i][channel_id] = 0;
402
403 vpif_schedule_next_buffer(common);
404
405
406 channel_first_int[i][channel_id] = 0;
407 } else {
408 /**
409 * Interlaced mode. If it is first interrupt, ignore
410 * it
411 */
412 if (channel_first_int[i][channel_id]) {
413 channel_first_int[i][channel_id] = 0;
414 continue;
415 }
416 if (0 == i) {
417 ch->field_id ^= 1;
418 /* Get field id from VPIF registers */
419 fid = vpif_channel_getfid(ch->channel_id);
420 if (fid != ch->field_id) {
421 /**
422 * If field id does not match stored
423 * field id, make them in sync
424 */
425 if (0 == fid)
426 ch->field_id = fid;
427 return IRQ_HANDLED;
428 }
429 }
430 /* device field id and local field id are in sync */
431 if (0 == fid) {
432 /* this is even field */
433 if (common->cur_frm == common->next_frm)
434 continue;
435
436 /* mark the current buffer as done */
437 vpif_process_buffer_complete(common);
438 } else if (1 == fid) {
439 /* odd field */
Hans Verkuilaec96832012-11-16 12:03:06 -0300440 spin_lock(&common->irqlock);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300441 if (list_empty(&common->dma_queue) ||
Hans Verkuilaec96832012-11-16 12:03:06 -0300442 (common->cur_frm != common->next_frm)) {
443 spin_unlock(&common->irqlock);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300444 continue;
Hans Verkuilaec96832012-11-16 12:03:06 -0300445 }
446 spin_unlock(&common->irqlock);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300447
448 vpif_schedule_next_buffer(common);
449 }
450 }
451 }
452 return IRQ_HANDLED;
453}
454
455/**
456 * vpif_update_std_info() - update standard related info
457 * @ch: ptr to channel object
458 *
459 * For a given standard selected by application, update values
460 * in the device data structures
461 */
462static int vpif_update_std_info(struct channel_obj *ch)
463{
464 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
465 struct vpif_params *vpifparams = &ch->vpifparams;
466 const struct vpif_channel_config_params *config;
Mats Randgaard2c0ddd12010-12-16 12:17:45 -0300467 struct vpif_channel_config_params *std_info = &vpifparams->std_info;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300468 struct video_obj *vid_ch = &ch->video;
469 int index;
470
471 vpif_dbg(2, debug, "vpif_update_std_info\n");
472
Mats Randgaardaa444402010-12-16 12:17:42 -0300473 for (index = 0; index < vpif_ch_params_count; index++) {
Lad, Prabhakarced9b212013-03-20 01:28:27 -0300474 config = &vpif_ch_params[index];
Mats Randgaard40c8bce2010-12-16 12:17:43 -0300475 if (config->hd_sd == 0) {
476 vpif_dbg(2, debug, "SD format\n");
477 if (config->stdid & vid_ch->stdid) {
478 memcpy(std_info, config, sizeof(*config));
479 break;
480 }
481 } else {
482 vpif_dbg(2, debug, "HD format\n");
Hans Verkuil0598c172012-09-18 07:18:47 -0300483 if (!memcmp(&config->dv_timings, &vid_ch->dv_timings,
484 sizeof(vid_ch->dv_timings))) {
Mats Randgaard40c8bce2010-12-16 12:17:43 -0300485 memcpy(std_info, config, sizeof(*config));
486 break;
487 }
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300488 }
489 }
490
491 /* standard not found */
Mats Randgaardaa444402010-12-16 12:17:42 -0300492 if (index == vpif_ch_params_count)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300493 return -EINVAL;
494
495 common->fmt.fmt.pix.width = std_info->width;
496 common->width = std_info->width;
497 common->fmt.fmt.pix.height = std_info->height;
498 common->height = std_info->height;
Lad, Prabhakara4965c52014-05-16 10:33:54 -0300499 common->fmt.fmt.pix.sizeimage = common->height * common->width * 2;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300500 common->fmt.fmt.pix.bytesperline = std_info->width;
501 vpifparams->video_params.hpitch = std_info->width;
502 vpifparams->video_params.storage_mode = std_info->frm_fmt;
Mats Randgaard2c0ddd12010-12-16 12:17:45 -0300503
Lad, Prabhakara4965c52014-05-16 10:33:54 -0300504 if (vid_ch->stdid)
505 common->fmt.fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
506 else
507 common->fmt.fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
508
509 if (ch->vpifparams.std_info.frm_fmt)
510 common->fmt.fmt.pix.field = V4L2_FIELD_NONE;
511 else
512 common->fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
513
514 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER)
515 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8;
516 else
517 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
518
519 common->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
520
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300521 return 0;
522}
523
524/**
525 * vpif_calculate_offsets : This function calculates buffers offsets
526 * @ch : ptr to channel object
527 *
528 * This function calculates buffer offsets for Y and C in the top and
529 * bottom field
530 */
531static void vpif_calculate_offsets(struct channel_obj *ch)
532{
Mauro Carvalho Chehab24ab6332014-08-21 15:49:06 -0500533 unsigned int hpitch, sizeimage;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300534 struct video_obj *vid_ch = &(ch->video);
535 struct vpif_params *vpifparams = &ch->vpifparams;
536 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
537 enum v4l2_field field = common->fmt.fmt.pix.field;
538
539 vpif_dbg(2, debug, "vpif_calculate_offsets\n");
540
541 if (V4L2_FIELD_ANY == field) {
542 if (vpifparams->std_info.frm_fmt)
543 vid_ch->buf_field = V4L2_FIELD_NONE;
544 else
545 vid_ch->buf_field = V4L2_FIELD_INTERLACED;
546 } else
547 vid_ch->buf_field = common->fmt.fmt.pix.field;
548
Lad, Prabhakar60aa38d2012-06-28 09:28:05 -0300549 sizeimage = common->fmt.fmt.pix.sizeimage;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300550
551 hpitch = common->fmt.fmt.pix.bytesperline;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300552
553 if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
554 (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) {
555 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
556 common->ytop_off = 0;
557 common->ybtm_off = hpitch;
558 common->ctop_off = sizeimage / 2;
559 common->cbtm_off = sizeimage / 2 + hpitch;
560 } else if (V4L2_FIELD_SEQ_TB == vid_ch->buf_field) {
561 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
562 common->ytop_off = 0;
563 common->ybtm_off = sizeimage / 4;
564 common->ctop_off = sizeimage / 2;
565 common->cbtm_off = common->ctop_off + sizeimage / 4;
566 } else if (V4L2_FIELD_SEQ_BT == vid_ch->buf_field) {
567 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
568 common->ybtm_off = 0;
569 common->ytop_off = sizeimage / 4;
570 common->cbtm_off = sizeimage / 2;
571 common->ctop_off = common->cbtm_off + sizeimage / 4;
572 }
573 if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
574 (V4L2_FIELD_INTERLACED == vid_ch->buf_field))
575 vpifparams->video_params.storage_mode = 1;
576 else
577 vpifparams->video_params.storage_mode = 0;
578
579 if (1 == vpifparams->std_info.frm_fmt)
580 vpifparams->video_params.hpitch =
581 common->fmt.fmt.pix.bytesperline;
582 else {
583 if ((field == V4L2_FIELD_ANY)
584 || (field == V4L2_FIELD_INTERLACED))
585 vpifparams->video_params.hpitch =
586 common->fmt.fmt.pix.bytesperline * 2;
587 else
588 vpifparams->video_params.hpitch =
589 common->fmt.fmt.pix.bytesperline;
590 }
591
592 ch->vpifparams.video_params.stdid = vpifparams->std_info.stdid;
593}
594
595/**
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300596 * vpif_get_default_field() - Get default field type based on interface
597 * @vpif_params - ptr to vpif params
598 */
599static inline enum v4l2_field vpif_get_default_field(
600 struct vpif_interface *iface)
601{
602 return (iface->if_type == VPIF_IF_RAW_BAYER) ? V4L2_FIELD_NONE :
603 V4L2_FIELD_INTERLACED;
604}
605
606/**
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300607 * vpif_config_addr() - function to configure buffer address in vpif
608 * @ch - channel ptr
609 * @muxmode - channel mux mode
610 */
611static void vpif_config_addr(struct channel_obj *ch, int muxmode)
612{
613 struct common_obj *common;
614
615 vpif_dbg(2, debug, "vpif_config_addr\n");
616
617 common = &(ch->common[VPIF_VIDEO_INDEX]);
618
619 if (VPIF_CHANNEL1_VIDEO == ch->channel_id)
620 common->set_addr = ch1_set_videobuf_addr;
621 else if (2 == muxmode)
622 common->set_addr = ch0_set_videobuf_addr_yc_nmux;
623 else
624 common->set_addr = ch0_set_videobuf_addr;
625}
626
627/**
Hans Verkuil178cce12012-09-20 09:06:30 -0300628 * vpif_input_to_subdev() - Maps input to sub device
629 * @vpif_cfg - global config ptr
630 * @chan_cfg - channel config ptr
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300631 * @input_index - Given input index from application
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300632 *
633 * lookup the sub device information for a given input index.
634 * we report all the inputs to application. inputs table also
635 * has sub device name for the each input
636 */
Hans Verkuil178cce12012-09-20 09:06:30 -0300637static int vpif_input_to_subdev(
638 struct vpif_capture_config *vpif_cfg,
639 struct vpif_capture_chan_config *chan_cfg,
640 int input_index)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300641{
Hans Verkuil178cce12012-09-20 09:06:30 -0300642 struct vpif_subdev_info *subdev_info;
643 const char *subdev_name;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300644 int i;
645
Hans Verkuil178cce12012-09-20 09:06:30 -0300646 vpif_dbg(2, debug, "vpif_input_to_subdev\n");
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300647
Hans Verkuil178cce12012-09-20 09:06:30 -0300648 subdev_name = chan_cfg->inputs[input_index].subdev_name;
649 if (subdev_name == NULL)
650 return -1;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300651
652 /* loop through the sub device list to get the sub device info */
653 for (i = 0; i < vpif_cfg->subdev_count; i++) {
654 subdev_info = &vpif_cfg->subdev_info[i];
655 if (!strcmp(subdev_info->name, subdev_name))
Hans Verkuil178cce12012-09-20 09:06:30 -0300656 return i;
657 }
658 return -1;
659}
660
661/**
662 * vpif_set_input() - Select an input
663 * @vpif_cfg - global config ptr
664 * @ch - channel
665 * @_index - Given input index from application
666 *
667 * Select the given input.
668 */
669static int vpif_set_input(
670 struct vpif_capture_config *vpif_cfg,
671 struct channel_obj *ch,
672 int index)
673{
674 struct vpif_capture_chan_config *chan_cfg =
675 &vpif_cfg->chan_config[ch->channel_id];
676 struct vpif_subdev_info *subdev_info = NULL;
677 struct v4l2_subdev *sd = NULL;
678 u32 input = 0, output = 0;
679 int sd_index;
680 int ret;
681
682 sd_index = vpif_input_to_subdev(vpif_cfg, chan_cfg, index);
683 if (sd_index >= 0) {
684 sd = vpif_obj.sd[sd_index];
685 subdev_info = &vpif_cfg->subdev_info[sd_index];
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300686 }
687
Hans Verkuil178cce12012-09-20 09:06:30 -0300688 /* first setup input path from sub device to vpif */
689 if (sd && vpif_cfg->setup_input_path) {
690 ret = vpif_cfg->setup_input_path(ch->channel_id,
691 subdev_info->name);
692 if (ret < 0) {
693 vpif_dbg(1, debug, "couldn't setup input path for the" \
694 " sub device %s, for input index %d\n",
695 subdev_info->name, index);
696 return ret;
697 }
698 }
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300699
Hans Verkuil178cce12012-09-20 09:06:30 -0300700 if (sd) {
701 input = chan_cfg->inputs[index].input_route;
702 output = chan_cfg->inputs[index].output_route;
703 ret = v4l2_subdev_call(sd, video, s_routing,
704 input, output, 0);
705 if (ret < 0 && ret != -ENOIOCTLCMD) {
706 vpif_dbg(1, debug, "Failed to set input\n");
707 return ret;
708 }
709 }
710 ch->input_idx = index;
711 ch->sd = sd;
712 /* copy interface parameters to vpif */
Hans Verkuil0d4f35f2012-09-20 09:06:32 -0300713 ch->vpifparams.iface = chan_cfg->vpif_if;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300714
Hans Verkuil178cce12012-09-20 09:06:30 -0300715 /* update tvnorms from the sub device input info */
716 ch->video_dev->tvnorms = chan_cfg->inputs[index].input.std;
717 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300718}
719
720/**
721 * vpif_querystd() - querystd handler
722 * @file: file ptr
723 * @priv: file handle
724 * @std_id: ptr to std id
725 *
726 * This function is called to detect standard at the selected input
727 */
728static int vpif_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
729{
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300730 struct video_device *vdev = video_devdata(file);
731 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300732 int ret = 0;
733
734 vpif_dbg(2, debug, "vpif_querystd\n");
735
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300736 /* Call querystd function of decoder device */
Hans Verkuil178cce12012-09-20 09:06:30 -0300737 ret = v4l2_subdev_call(ch->sd, video, querystd, std_id);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300738
Hans Verkuil178cce12012-09-20 09:06:30 -0300739 if (ret == -ENOIOCTLCMD || ret == -ENODEV)
740 return -ENODATA;
741 if (ret) {
742 vpif_dbg(1, debug, "Failed to query standard for sub devices\n");
743 return ret;
744 }
745
746 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300747}
748
749/**
750 * vpif_g_std() - get STD handler
751 * @file: file ptr
752 * @priv: file handle
753 * @std_id: ptr to std id
754 */
755static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std)
756{
Lad, Prabhakard557b7d2014-05-16 10:33:52 -0300757 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300758 struct video_device *vdev = video_devdata(file);
759 struct channel_obj *ch = video_get_drvdata(vdev);
Lad, Prabhakard557b7d2014-05-16 10:33:52 -0300760 struct vpif_capture_chan_config *chan_cfg;
761 struct v4l2_input input;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300762
763 vpif_dbg(2, debug, "vpif_g_std\n");
764
Lad, Prabhakard557b7d2014-05-16 10:33:52 -0300765 if (config->chan_config[ch->channel_id].inputs == NULL)
766 return -ENODATA;
767
768 chan_cfg = &config->chan_config[ch->channel_id];
769 input = chan_cfg->inputs[ch->input_idx].input;
770 if (input.capabilities != V4L2_IN_CAP_STD)
771 return -ENODATA;
772
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300773 *std = ch->video.stdid;
774 return 0;
775}
776
777/**
778 * vpif_s_std() - set STD handler
779 * @file: file ptr
780 * @priv: file handle
781 * @std_id: ptr to std id
782 */
Hans Verkuil314527a2013-03-15 06:10:40 -0300783static int vpif_s_std(struct file *file, void *priv, v4l2_std_id std_id)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300784{
Lad, Prabhakard557b7d2014-05-16 10:33:52 -0300785 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300786 struct video_device *vdev = video_devdata(file);
787 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300788 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
Lad, Prabhakard557b7d2014-05-16 10:33:52 -0300789 struct vpif_capture_chan_config *chan_cfg;
790 struct v4l2_input input;
791 int ret;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300792
793 vpif_dbg(2, debug, "vpif_s_std\n");
794
Lad, Prabhakard557b7d2014-05-16 10:33:52 -0300795 if (config->chan_config[ch->channel_id].inputs == NULL)
796 return -ENODATA;
797
798 chan_cfg = &config->chan_config[ch->channel_id];
799 input = chan_cfg->inputs[ch->input_idx].input;
800 if (input.capabilities != V4L2_IN_CAP_STD)
801 return -ENODATA;
802
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300803 if (vb2_is_busy(&common->buffer_queue))
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300804 return -EBUSY;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300805
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300806 /* Call encoder subdevice function to set the standard */
Hans Verkuil314527a2013-03-15 06:10:40 -0300807 ch->video.stdid = std_id;
Hans Verkuil0598c172012-09-18 07:18:47 -0300808 memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings));
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300809
810 /* Get the information about the standard */
811 if (vpif_update_std_info(ch)) {
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300812 vpif_err("Error getting the standard info\n");
Hans Verkuil46656af2011-01-04 06:51:35 -0300813 return -EINVAL;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300814 }
815
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300816 /* set standard in the sub device */
Laurent Pinchart8774bed2014-04-28 16:53:01 -0300817 ret = v4l2_subdev_call(ch->sd, video, s_std, std_id);
Hans Verkuil178cce12012-09-20 09:06:30 -0300818 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) {
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300819 vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
Hans Verkuil178cce12012-09-20 09:06:30 -0300820 return ret;
821 }
822 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300823}
824
825/**
826 * vpif_enum_input() - ENUMINPUT handler
827 * @file: file ptr
828 * @priv: file handle
829 * @input: ptr to input structure
830 */
831static int vpif_enum_input(struct file *file, void *priv,
832 struct v4l2_input *input)
833{
834
835 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300836 struct video_device *vdev = video_devdata(file);
837 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300838 struct vpif_capture_chan_config *chan_cfg;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300839
840 chan_cfg = &config->chan_config[ch->channel_id];
841
Lad, Prabhakara4965c52014-05-16 10:33:54 -0300842 if (input->index >= chan_cfg->input_count)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300843 return -EINVAL;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300844
845 memcpy(input, &chan_cfg->inputs[input->index].input,
846 sizeof(*input));
847 return 0;
848}
849
850/**
851 * vpif_g_input() - Get INPUT handler
852 * @file: file ptr
853 * @priv: file handle
854 * @index: ptr to input index
855 */
856static int vpif_g_input(struct file *file, void *priv, unsigned int *index)
857{
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300858 struct video_device *vdev = video_devdata(file);
859 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300860
Hans Verkuil6f47c6c2012-09-20 09:06:22 -0300861 *index = ch->input_idx;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300862 return 0;
863}
864
865/**
866 * vpif_s_input() - Set INPUT handler
867 * @file: file ptr
868 * @priv: file handle
869 * @index: input index
870 */
871static int vpif_s_input(struct file *file, void *priv, unsigned int index)
872{
873 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300874 struct video_device *vdev = video_devdata(file);
875 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300876 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300877 struct vpif_capture_chan_config *chan_cfg;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300878
879 chan_cfg = &config->chan_config[ch->channel_id];
880
Hans Verkuil7aaad132012-09-20 09:06:25 -0300881 if (index >= chan_cfg->input_count)
882 return -EINVAL;
883
Lad, Prabhakarc66238f2014-05-16 10:33:45 -0300884 if (vb2_is_busy(&common->buffer_queue))
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300885 return -EBUSY;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300886
Hans Verkuil178cce12012-09-20 09:06:30 -0300887 return vpif_set_input(config, ch, index);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300888}
889
890/**
891 * vpif_enum_fmt_vid_cap() - ENUM_FMT handler
892 * @file: file ptr
893 * @priv: file handle
894 * @index: input index
895 */
896static int vpif_enum_fmt_vid_cap(struct file *file, void *priv,
897 struct v4l2_fmtdesc *fmt)
898{
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300899 struct video_device *vdev = video_devdata(file);
900 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300901
902 if (fmt->index != 0) {
903 vpif_dbg(1, debug, "Invalid format index\n");
904 return -EINVAL;
905 }
906
907 /* Fill in the information about format */
908 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) {
909 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
910 strcpy(fmt->description, "Raw Mode -Bayer Pattern GrRBGb");
911 fmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
912 } else {
913 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
914 strcpy(fmt->description, "YCbCr4:2:2 YC Planar");
915 fmt->pixelformat = V4L2_PIX_FMT_YUV422P;
916 }
917 return 0;
918}
919
920/**
921 * vpif_try_fmt_vid_cap() - TRY_FMT handler
922 * @file: file ptr
923 * @priv: file handle
924 * @fmt: ptr to v4l2 format structure
925 */
926static int vpif_try_fmt_vid_cap(struct file *file, void *priv,
927 struct v4l2_format *fmt)
928{
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300929 struct video_device *vdev = video_devdata(file);
930 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300931 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
Lad, Prabhakara4965c52014-05-16 10:33:54 -0300932 struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
933 struct vpif_params *vpif_params = &ch->vpifparams;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300934
Lad, Prabhakara4965c52014-05-16 10:33:54 -0300935 /*
936 * to supress v4l-compliance warnings silently correct
937 * the pixelformat
938 */
939 if (vpif_params->iface.if_type == VPIF_IF_RAW_BAYER) {
940 if (pixfmt->pixelformat != V4L2_PIX_FMT_SBGGR8)
941 pixfmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
942 } else {
943 if (pixfmt->pixelformat != V4L2_PIX_FMT_YUV422P)
944 pixfmt->pixelformat = V4L2_PIX_FMT_YUV422P;
945 }
946
947 common->fmt.fmt.pix.pixelformat = pixfmt->pixelformat;
948
949 vpif_update_std_info(ch);
950
951 pixfmt->field = common->fmt.fmt.pix.field;
952 pixfmt->colorspace = common->fmt.fmt.pix.colorspace;
953 pixfmt->bytesperline = common->fmt.fmt.pix.width;
954 pixfmt->width = common->fmt.fmt.pix.width;
955 pixfmt->height = common->fmt.fmt.pix.height;
956 pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height * 2;
957 pixfmt->priv = 0;
958
959 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300960}
961
962
963/**
964 * vpif_g_fmt_vid_cap() - Set INPUT handler
965 * @file: file ptr
966 * @priv: file handle
967 * @fmt: ptr to v4l2 format structure
968 */
969static int vpif_g_fmt_vid_cap(struct file *file, void *priv,
970 struct v4l2_format *fmt)
971{
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300972 struct video_device *vdev = video_devdata(file);
973 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300974 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
975
976 /* Check the validity of the buffer type */
977 if (common->fmt.type != fmt->type)
978 return -EINVAL;
979
980 /* Fill in the information about format */
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300981 *fmt = common->fmt;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300982 return 0;
983}
984
985/**
986 * vpif_s_fmt_vid_cap() - Set FMT handler
987 * @file: file ptr
988 * @priv: file handle
989 * @fmt: ptr to v4l2 format structure
990 */
991static int vpif_s_fmt_vid_cap(struct file *file, void *priv,
992 struct v4l2_format *fmt)
993{
Lad, Prabhakar7ff51192014-05-16 10:33:41 -0300994 struct video_device *vdev = video_devdata(file);
995 struct channel_obj *ch = video_get_drvdata(vdev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300996 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
Lad, Prabhakara4965c52014-05-16 10:33:54 -0300997 int ret;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -0300998
Mats Randgaard2c0ddd12010-12-16 12:17:45 -0300999 vpif_dbg(2, debug, "%s\n", __func__);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001000
Lad, Prabhakarc66238f2014-05-16 10:33:45 -03001001 if (vb2_is_busy(&common->buffer_queue))
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001002 return -EBUSY;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001003
Lad, Prabhakara4965c52014-05-16 10:33:54 -03001004 ret = vpif_try_fmt_vid_cap(file, priv, fmt);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001005 if (ret)
1006 return ret;
Lad, Prabhakara4965c52014-05-16 10:33:54 -03001007
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001008 /* store the format in the channel object */
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001009 common->fmt = *fmt;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001010 return 0;
1011}
1012
1013/**
1014 * vpif_querycap() - QUERYCAP handler
1015 * @file: file ptr
1016 * @priv: file handle
1017 * @cap: ptr to v4l2_capability structure
1018 */
1019static int vpif_querycap(struct file *file, void *priv,
1020 struct v4l2_capability *cap)
1021{
1022 struct vpif_capture_config *config = vpif_dev->platform_data;
1023
Lad, Prabhakar626d533f2012-09-25 11:21:55 -03001024 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1025 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
Lad, Prabhakare75ea0c2014-05-16 10:33:46 -03001026 strlcpy(cap->driver, VPIF_DRIVER_NAME, sizeof(cap->driver));
Lad, Prabhakar626d533f2012-09-25 11:21:55 -03001027 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1028 dev_name(vpif_dev));
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001029 strlcpy(cap->card, config->card_name, sizeof(cap->card));
1030
1031 return 0;
1032}
1033
1034/**
Hans Verkuil0598c172012-09-18 07:18:47 -03001035 * vpif_enum_dv_timings() - ENUM_DV_TIMINGS handler
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001036 * @file: file ptr
1037 * @priv: file handle
Hans Verkuil0598c172012-09-18 07:18:47 -03001038 * @timings: input timings
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001039 */
Hans Verkuil0598c172012-09-18 07:18:47 -03001040static int
1041vpif_enum_dv_timings(struct file *file, void *priv,
1042 struct v4l2_enum_dv_timings *timings)
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001043{
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001044 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001045 struct video_device *vdev = video_devdata(file);
1046 struct channel_obj *ch = video_get_drvdata(vdev);
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001047 struct vpif_capture_chan_config *chan_cfg;
1048 struct v4l2_input input;
Hans Verkuil178cce12012-09-20 09:06:30 -03001049 int ret;
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001050
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001051 if (config->chan_config[ch->channel_id].inputs == NULL)
1052 return -ENODATA;
1053
1054 chan_cfg = &config->chan_config[ch->channel_id];
1055 input = chan_cfg->inputs[ch->input_idx].input;
1056 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS)
1057 return -ENODATA;
1058
Laurent Pinchart10d21462014-01-31 09:04:19 -03001059 timings->pad = 0;
1060
1061 ret = v4l2_subdev_call(ch->sd, pad, enum_dv_timings, timings);
Wei Yongjune070f1b2012-10-30 09:45:00 -03001062 if (ret == -ENOIOCTLCMD || ret == -ENODEV)
Hans Verkuil178cce12012-09-20 09:06:30 -03001063 return -EINVAL;
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001064
Hans Verkuil178cce12012-09-20 09:06:30 -03001065 return ret;
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001066}
1067
1068/**
Hans Verkuil0598c172012-09-18 07:18:47 -03001069 * vpif_query_dv_timings() - QUERY_DV_TIMINGS handler
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001070 * @file: file ptr
1071 * @priv: file handle
Hans Verkuil0598c172012-09-18 07:18:47 -03001072 * @timings: input timings
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001073 */
Hans Verkuil0598c172012-09-18 07:18:47 -03001074static int
1075vpif_query_dv_timings(struct file *file, void *priv,
1076 struct v4l2_dv_timings *timings)
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001077{
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001078 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001079 struct video_device *vdev = video_devdata(file);
1080 struct channel_obj *ch = video_get_drvdata(vdev);
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001081 struct vpif_capture_chan_config *chan_cfg;
1082 struct v4l2_input input;
Hans Verkuil178cce12012-09-20 09:06:30 -03001083 int ret;
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001084
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001085 if (config->chan_config[ch->channel_id].inputs == NULL)
1086 return -ENODATA;
1087
1088 chan_cfg = &config->chan_config[ch->channel_id];
1089 input = chan_cfg->inputs[ch->input_idx].input;
1090 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS)
1091 return -ENODATA;
1092
Hans Verkuil178cce12012-09-20 09:06:30 -03001093 ret = v4l2_subdev_call(ch->sd, video, query_dv_timings, timings);
Wei Yongjune070f1b2012-10-30 09:45:00 -03001094 if (ret == -ENOIOCTLCMD || ret == -ENODEV)
Hans Verkuil178cce12012-09-20 09:06:30 -03001095 return -ENODATA;
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001096
Hans Verkuil178cce12012-09-20 09:06:30 -03001097 return ret;
Mats Randgaard40c8bce2010-12-16 12:17:43 -03001098}
1099
Mats Randgaardc027e162010-12-16 12:17:44 -03001100/**
1101 * vpif_s_dv_timings() - S_DV_TIMINGS handler
1102 * @file: file ptr
1103 * @priv: file handle
1104 * @timings: digital video timings
1105 */
1106static int vpif_s_dv_timings(struct file *file, void *priv,
1107 struct v4l2_dv_timings *timings)
1108{
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001109 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001110 struct video_device *vdev = video_devdata(file);
1111 struct channel_obj *ch = video_get_drvdata(vdev);
Mats Randgaardc027e162010-12-16 12:17:44 -03001112 struct vpif_params *vpifparams = &ch->vpifparams;
1113 struct vpif_channel_config_params *std_info = &vpifparams->std_info;
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001114 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
Mats Randgaardc027e162010-12-16 12:17:44 -03001115 struct video_obj *vid_ch = &ch->video;
Hans Verkuil0598c172012-09-18 07:18:47 -03001116 struct v4l2_bt_timings *bt = &vid_ch->dv_timings.bt;
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001117 struct vpif_capture_chan_config *chan_cfg;
1118 struct v4l2_input input;
Mats Randgaardc027e162010-12-16 12:17:44 -03001119 int ret;
1120
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001121 if (config->chan_config[ch->channel_id].inputs == NULL)
1122 return -ENODATA;
1123
1124 chan_cfg = &config->chan_config[ch->channel_id];
1125 input = chan_cfg->inputs[ch->input_idx].input;
1126 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS)
1127 return -ENODATA;
1128
Mats Randgaardc027e162010-12-16 12:17:44 -03001129 if (timings->type != V4L2_DV_BT_656_1120) {
1130 vpif_dbg(2, debug, "Timing type not defined\n");
1131 return -EINVAL;
1132 }
1133
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001134 if (vb2_is_busy(&common->buffer_queue))
1135 return -EBUSY;
1136
Mats Randgaardc027e162010-12-16 12:17:44 -03001137 /* Configure subdevice timings, if any */
Hans Verkuil178cce12012-09-20 09:06:30 -03001138 ret = v4l2_subdev_call(ch->sd, video, s_dv_timings, timings);
1139 if (ret == -ENOIOCTLCMD || ret == -ENODEV)
1140 ret = 0;
Mats Randgaardc027e162010-12-16 12:17:44 -03001141 if (ret < 0) {
1142 vpif_dbg(2, debug, "Error setting custom DV timings\n");
1143 return ret;
1144 }
1145
1146 if (!(timings->bt.width && timings->bt.height &&
1147 (timings->bt.hbackporch ||
1148 timings->bt.hfrontporch ||
1149 timings->bt.hsync) &&
1150 timings->bt.vfrontporch &&
1151 (timings->bt.vbackporch ||
1152 timings->bt.vsync))) {
1153 vpif_dbg(2, debug, "Timings for width, height, "
1154 "horizontal back porch, horizontal sync, "
1155 "horizontal front porch, vertical back porch, "
1156 "vertical sync and vertical back porch "
1157 "must be defined\n");
1158 return -EINVAL;
1159 }
1160
Hans Verkuil0598c172012-09-18 07:18:47 -03001161 vid_ch->dv_timings = *timings;
Mats Randgaardc027e162010-12-16 12:17:44 -03001162
1163 /* Configure video port timings */
1164
Hans Verkuile3655262013-07-29 08:41:00 -03001165 std_info->eav2sav = V4L2_DV_BT_BLANKING_WIDTH(bt) - 8;
Mats Randgaardc027e162010-12-16 12:17:44 -03001166 std_info->sav2eav = bt->width;
1167
1168 std_info->l1 = 1;
1169 std_info->l3 = bt->vsync + bt->vbackporch + 1;
1170
Hans Verkuile3655262013-07-29 08:41:00 -03001171 std_info->vsize = V4L2_DV_BT_FRAME_HEIGHT(bt);
Mats Randgaardc027e162010-12-16 12:17:44 -03001172 if (bt->interlaced) {
1173 if (bt->il_vbackporch || bt->il_vfrontporch || bt->il_vsync) {
Mats Randgaardc027e162010-12-16 12:17:44 -03001174 std_info->l5 = std_info->vsize/2 -
1175 (bt->vfrontporch - 1);
1176 std_info->l7 = std_info->vsize/2 + 1;
1177 std_info->l9 = std_info->l7 + bt->il_vsync +
1178 bt->il_vbackporch + 1;
1179 std_info->l11 = std_info->vsize -
1180 (bt->il_vfrontporch - 1);
1181 } else {
1182 vpif_dbg(2, debug, "Required timing values for "
1183 "interlaced BT format missing\n");
1184 return -EINVAL;
1185 }
1186 } else {
Mats Randgaardc027e162010-12-16 12:17:44 -03001187 std_info->l5 = std_info->vsize - (bt->vfrontporch - 1);
1188 }
1189 strncpy(std_info->name, "Custom timings BT656/1120", VPIF_MAX_NAME);
1190 std_info->width = bt->width;
1191 std_info->height = bt->height;
1192 std_info->frm_fmt = bt->interlaced ? 0 : 1;
1193 std_info->ycmux_mode = 0;
1194 std_info->capture_format = 0;
1195 std_info->vbi_supported = 0;
1196 std_info->hd_sd = 1;
1197 std_info->stdid = 0;
Mats Randgaardc027e162010-12-16 12:17:44 -03001198
1199 vid_ch->stdid = 0;
Mats Randgaardc027e162010-12-16 12:17:44 -03001200 return 0;
1201}
1202
1203/**
1204 * vpif_g_dv_timings() - G_DV_TIMINGS handler
1205 * @file: file ptr
1206 * @priv: file handle
1207 * @timings: digital video timings
1208 */
1209static int vpif_g_dv_timings(struct file *file, void *priv,
1210 struct v4l2_dv_timings *timings)
1211{
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001212 struct vpif_capture_config *config = vpif_dev->platform_data;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001213 struct video_device *vdev = video_devdata(file);
1214 struct channel_obj *ch = video_get_drvdata(vdev);
Mats Randgaardc027e162010-12-16 12:17:44 -03001215 struct video_obj *vid_ch = &ch->video;
Lad, Prabhakar1e8852af2014-05-16 10:33:51 -03001216 struct vpif_capture_chan_config *chan_cfg;
1217 struct v4l2_input input;
1218
1219 if (config->chan_config[ch->channel_id].inputs == NULL)
1220 return -ENODATA;
1221
1222 chan_cfg = &config->chan_config[ch->channel_id];
1223 input = chan_cfg->inputs[ch->input_idx].input;
1224 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS)
1225 return -ENODATA;
Mats Randgaardc027e162010-12-16 12:17:44 -03001226
Hans Verkuil0598c172012-09-18 07:18:47 -03001227 *timings = vid_ch->dv_timings;
Mats Randgaardc027e162010-12-16 12:17:44 -03001228
1229 return 0;
1230}
1231
Mats Randgaard7036d6a2010-12-16 12:17:41 -03001232/*
Mats Randgaard7036d6a2010-12-16 12:17:41 -03001233 * vpif_log_status() - Status information
1234 * @file: file ptr
1235 * @priv: file handle
1236 *
1237 * Returns zero.
1238 */
1239static int vpif_log_status(struct file *filep, void *priv)
1240{
1241 /* status for sub devices */
1242 v4l2_device_call_all(&vpif_obj.v4l2_dev, 0, core, log_status);
1243
1244 return 0;
1245}
1246
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001247/* vpif capture ioctl operations */
1248static const struct v4l2_ioctl_ops vpif_ioctl_ops = {
Lad, Prabhakar7b4657f2014-05-16 10:33:49 -03001249 .vidioc_querycap = vpif_querycap,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001250 .vidioc_enum_fmt_vid_cap = vpif_enum_fmt_vid_cap,
Lad, Prabhakar7b4657f2014-05-16 10:33:49 -03001251 .vidioc_g_fmt_vid_cap = vpif_g_fmt_vid_cap,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001252 .vidioc_s_fmt_vid_cap = vpif_s_fmt_vid_cap,
1253 .vidioc_try_fmt_vid_cap = vpif_try_fmt_vid_cap,
Lad, Prabhakar7b4657f2014-05-16 10:33:49 -03001254
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001255 .vidioc_enum_input = vpif_enum_input,
1256 .vidioc_s_input = vpif_s_input,
1257 .vidioc_g_input = vpif_g_input,
Lad, Prabhakard9a3b132014-05-16 10:33:42 -03001258
1259 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1260 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1261 .vidioc_querybuf = vb2_ioctl_querybuf,
1262 .vidioc_qbuf = vb2_ioctl_qbuf,
1263 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1264 .vidioc_expbuf = vb2_ioctl_expbuf,
1265 .vidioc_streamon = vb2_ioctl_streamon,
1266 .vidioc_streamoff = vb2_ioctl_streamoff,
1267
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001268 .vidioc_querystd = vpif_querystd,
Lad, Prabhakar7b4657f2014-05-16 10:33:49 -03001269 .vidioc_s_std = vpif_s_std,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001270 .vidioc_g_std = vpif_g_std,
Lad, Prabhakard9a3b132014-05-16 10:33:42 -03001271
Lad, Prabhakar7b4657f2014-05-16 10:33:49 -03001272 .vidioc_enum_dv_timings = vpif_enum_dv_timings,
1273 .vidioc_query_dv_timings = vpif_query_dv_timings,
1274 .vidioc_s_dv_timings = vpif_s_dv_timings,
1275 .vidioc_g_dv_timings = vpif_g_dv_timings,
1276
Mats Randgaard7036d6a2010-12-16 12:17:41 -03001277 .vidioc_log_status = vpif_log_status,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001278};
1279
1280/* vpif file operations */
1281static struct v4l2_file_operations vpif_fops = {
1282 .owner = THIS_MODULE,
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001283 .open = v4l2_fh_open,
1284 .release = vb2_fop_release,
Hans Verkuil46656af2011-01-04 06:51:35 -03001285 .unlocked_ioctl = video_ioctl2,
Lad, Prabhakard26d26b2014-05-16 10:33:40 -03001286 .mmap = vb2_fop_mmap,
1287 .poll = vb2_fop_poll
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001288};
1289
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001290/**
1291 * initialize_vpif() - Initialize vpif data structures
1292 *
1293 * Allocate memory for data structures and initialize them
1294 */
1295static int initialize_vpif(void)
1296{
Lad, Prabhakar4015bef2014-05-16 10:33:47 -03001297 int err, i, j;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001298 int free_channel_objects_index;
1299
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001300 /* Allocate memory for six channel objects */
1301 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1302 vpif_obj.dev[i] =
1303 kzalloc(sizeof(*vpif_obj.dev[i]), GFP_KERNEL);
1304 /* If memory allocation fails, return error */
1305 if (!vpif_obj.dev[i]) {
1306 free_channel_objects_index = i;
1307 err = -ENOMEM;
1308 goto vpif_init_free_channel_objects;
1309 }
1310 }
1311 return 0;
1312
1313vpif_init_free_channel_objects:
1314 for (j = 0; j < free_channel_objects_index; j++)
1315 kfree(vpif_obj.dev[j]);
1316 return err;
1317}
1318
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001319static int vpif_async_bound(struct v4l2_async_notifier *notifier,
1320 struct v4l2_subdev *subdev,
1321 struct v4l2_async_subdev *asd)
1322{
1323 int i;
1324
1325 for (i = 0; i < vpif_obj.config->subdev_count; i++)
1326 if (!strcmp(vpif_obj.config->subdev_info[i].name,
1327 subdev->name)) {
1328 vpif_obj.sd[i] = subdev;
1329 return 0;
1330 }
1331
1332 return -EINVAL;
1333}
1334
1335static int vpif_probe_complete(void)
1336{
1337 struct common_obj *common;
Lad, Prabhakard26d26b2014-05-16 10:33:40 -03001338 struct video_device *vdev;
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001339 struct channel_obj *ch;
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -03001340 struct vb2_queue *q;
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001341 int i, j, err, k;
1342
1343 for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) {
1344 ch = vpif_obj.dev[j];
1345 ch->channel_id = j;
1346 common = &(ch->common[VPIF_VIDEO_INDEX]);
1347 spin_lock_init(&common->irqlock);
1348 mutex_init(&common->lock);
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001349
1350 /* select input 0 */
1351 err = vpif_set_input(vpif_obj.config, ch, 0);
1352 if (err)
1353 goto probe_out;
1354
Lad, Prabhakara4965c52014-05-16 10:33:54 -03001355 /* set initial format */
1356 ch->video.stdid = V4L2_STD_525_60;
1357 memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings));
1358 vpif_update_std_info(ch);
1359
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -03001360 /* Initialize vb2 queue */
1361 q = &common->buffer_queue;
1362 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1363 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1364 q->drv_priv = ch;
1365 q->ops = &video_qops;
1366 q->mem_ops = &vb2_dma_contig_memops;
1367 q->buf_struct_size = sizeof(struct vpif_cap_buffer);
1368 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1369 q->min_buffers_needed = 1;
Lad, Prabhakar999ba692014-05-16 10:33:33 -03001370 q->lock = &common->lock;
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -03001371
1372 err = vb2_queue_init(q);
1373 if (err) {
1374 vpif_err("vpif_capture: vb2_queue_init() failed\n");
1375 goto probe_out;
1376 }
1377
1378 common->alloc_ctx = vb2_dma_contig_init_ctx(vpif_dev);
1379 if (IS_ERR(common->alloc_ctx)) {
1380 vpif_err("Failed to get the context\n");
1381 err = PTR_ERR(common->alloc_ctx);
1382 goto probe_out;
1383 }
1384
1385 INIT_LIST_HEAD(&common->dma_queue);
1386
Lad, Prabhakare75ea0c2014-05-16 10:33:46 -03001387 /* Initialize the video_device structure */
Lad, Prabhakard26d26b2014-05-16 10:33:40 -03001388 vdev = ch->video_dev;
Lad, Prabhakare75ea0c2014-05-16 10:33:46 -03001389 strlcpy(vdev->name, VPIF_DRIVER_NAME, sizeof(vdev->name));
1390 vdev->release = video_device_release;
1391 vdev->fops = &vpif_fops;
1392 vdev->ioctl_ops = &vpif_ioctl_ops;
1393 vdev->v4l2_dev = &vpif_obj.v4l2_dev;
1394 vdev->vfl_dir = VFL_DIR_RX;
Lad, Prabhakard26d26b2014-05-16 10:33:40 -03001395 vdev->queue = q;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001396 vdev->lock = &common->lock;
Lad, Prabhakar7ff51192014-05-16 10:33:41 -03001397 video_set_drvdata(ch->video_dev, ch);
Lad, Prabhakard26d26b2014-05-16 10:33:40 -03001398 err = video_register_device(vdev,
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001399 VFL_TYPE_GRABBER, (j ? 1 : 0));
1400 if (err)
1401 goto probe_out;
1402 }
1403
1404 v4l2_info(&vpif_obj.v4l2_dev, "VPIF capture driver initialized\n");
1405 return 0;
1406
1407probe_out:
1408 for (k = 0; k < j; k++) {
1409 /* Get the pointer to the channel object */
1410 ch = vpif_obj.dev[k];
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -03001411 common = &ch->common[k];
1412 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001413 /* Unregister video device */
1414 video_unregister_device(ch->video_dev);
1415 }
1416 kfree(vpif_obj.sd);
1417 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1418 ch = vpif_obj.dev[i];
1419 /* Note: does nothing if ch->video_dev == NULL */
1420 video_device_release(ch->video_dev);
1421 }
1422 v4l2_device_unregister(&vpif_obj.v4l2_dev);
1423
1424 return err;
1425}
1426
1427static int vpif_async_complete(struct v4l2_async_notifier *notifier)
1428{
1429 return vpif_probe_complete();
1430}
1431
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001432/**
1433 * vpif_probe : This function probes the vpif capture driver
1434 * @pdev: platform device pointer
1435 *
1436 * This creates device entries by register itself to the V4L2 driver and
1437 * initializes fields of each channel objects
1438 */
1439static __init int vpif_probe(struct platform_device *pdev)
1440{
1441 struct vpif_subdev_info *subdevdata;
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001442 int i, j, err;
Hans Verkuil5be452c2012-09-20 09:06:29 -03001443 int res_idx = 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001444 struct i2c_adapter *i2c_adap;
1445 struct channel_obj *ch;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001446 struct video_device *vfd;
1447 struct resource *res;
1448 int subdev_count;
1449
1450 vpif_dev = &pdev->dev;
1451
1452 err = initialize_vpif();
1453 if (err) {
1454 v4l2_err(vpif_dev->driver, "Error initializing vpif\n");
1455 return err;
1456 }
1457
Hans Verkuild2f7a1a2011-12-13 05:44:42 -03001458 err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
1459 if (err) {
1460 v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
1461 return err;
1462 }
1463
Hans Verkuil5be452c2012-09-20 09:06:29 -03001464 while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, res_idx))) {
Lad, Prabhakara76a0b32013-06-17 11:20:47 -03001465 err = devm_request_irq(&pdev->dev, res->start, vpif_channel_isr,
Lad, Prabhakare75ea0c2014-05-16 10:33:46 -03001466 IRQF_SHARED, VPIF_DRIVER_NAME,
Lad, Prabhakara76a0b32013-06-17 11:20:47 -03001467 (void *)(&vpif_obj.dev[res_idx]->
1468 channel_id));
1469 if (err) {
1470 err = -EINVAL;
1471 goto vpif_unregister;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001472 }
Hans Verkuil5be452c2012-09-20 09:06:29 -03001473 res_idx++;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001474 }
1475
1476 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1477 /* Get the pointer to the channel object */
1478 ch = vpif_obj.dev[i];
1479 /* Allocate memory for video device */
1480 vfd = video_device_alloc();
1481 if (NULL == vfd) {
1482 for (j = 0; j < i; j++) {
1483 ch = vpif_obj.dev[j];
1484 video_device_release(ch->video_dev);
1485 }
1486 err = -ENOMEM;
Lad, Prabhakarb2de4f22013-06-17 11:20:46 -03001487 goto vpif_unregister;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001488 }
1489
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001490 /* Set video_dev to the video device */
1491 ch->video_dev = vfd;
1492 }
1493
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001494 vpif_obj.config = pdev->dev.platform_data;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001495
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001496 subdev_count = vpif_obj.config->subdev_count;
Mats Randgaard1f8766b2010-08-30 10:30:37 -03001497 vpif_obj.sd = kzalloc(sizeof(struct v4l2_subdev *) * subdev_count,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001498 GFP_KERNEL);
1499 if (vpif_obj.sd == NULL) {
1500 vpif_err("unable to allocate memory for subdevice pointers\n");
1501 err = -ENOMEM;
Hans Verkuil5be452c2012-09-20 09:06:29 -03001502 goto vpif_sd_error;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001503 }
1504
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001505 if (!vpif_obj.config->asd_sizes) {
1506 i2c_adap = i2c_get_adapter(1);
1507 for (i = 0; i < subdev_count; i++) {
1508 subdevdata = &vpif_obj.config->subdev_info[i];
1509 vpif_obj.sd[i] =
1510 v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev,
1511 i2c_adap,
1512 &subdevdata->
1513 board_info,
1514 NULL);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001515
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001516 if (!vpif_obj.sd[i]) {
1517 vpif_err("Error registering v4l2 subdevice\n");
Wei Yongjun2fcd9dc2013-09-02 05:06:10 -03001518 err = -ENODEV;
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001519 goto probe_subdev_out;
1520 }
1521 v4l2_info(&vpif_obj.v4l2_dev,
1522 "registered sub device %s\n",
1523 subdevdata->name);
1524 }
1525 vpif_probe_complete();
1526 } else {
Sylwester Nawrockie8419d02013-07-19 12:31:10 -03001527 vpif_obj.notifier.subdevs = vpif_obj.config->asd;
Lad, Prabhakar873229e2013-06-25 11:17:34 -03001528 vpif_obj.notifier.num_subdevs = vpif_obj.config->asd_sizes[0];
1529 vpif_obj.notifier.bound = vpif_async_bound;
1530 vpif_obj.notifier.complete = vpif_async_complete;
1531 err = v4l2_async_notifier_register(&vpif_obj.v4l2_dev,
1532 &vpif_obj.notifier);
1533 if (err) {
1534 vpif_err("Error registering async notifier\n");
1535 err = -EINVAL;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001536 goto probe_subdev_out;
1537 }
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001538 }
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001539
1540 return 0;
1541
Hans Verkuilb65814e2012-09-20 09:06:26 -03001542probe_subdev_out:
1543 /* free sub devices memory */
1544 kfree(vpif_obj.sd);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001545
Hans Verkuil5be452c2012-09-20 09:06:29 -03001546vpif_sd_error:
1547 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1548 ch = vpif_obj.dev[i];
1549 /* Note: does nothing if ch->video_dev == NULL */
1550 video_device_release(ch->video_dev);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001551 }
Lad, Prabhakarb2de4f22013-06-17 11:20:46 -03001552vpif_unregister:
Hans Verkuild2f7a1a2011-12-13 05:44:42 -03001553 v4l2_device_unregister(&vpif_obj.v4l2_dev);
Lad, Prabhakarb2de4f22013-06-17 11:20:46 -03001554
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001555 return err;
1556}
1557
1558/**
1559 * vpif_remove() - driver remove handler
1560 * @device: ptr to platform device structure
1561 *
1562 * The vidoe device is unregistered
1563 */
1564static int vpif_remove(struct platform_device *device)
1565{
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -03001566 struct common_obj *common;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001567 struct channel_obj *ch;
Lad, Prabhakarb2de4f22013-06-17 11:20:46 -03001568 int i;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001569
1570 v4l2_device_unregister(&vpif_obj.v4l2_dev);
1571
Lad, Prabhakar410ca602013-06-17 11:20:44 -03001572 kfree(vpif_obj.sd);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001573 /* un-register device */
1574 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1575 /* Get the pointer to the channel object */
1576 ch = vpif_obj.dev[i];
Prabhakar Lade9b58722014-07-18 13:31:51 -03001577 common = &ch->common[VPIF_VIDEO_INDEX];
Lad, Prabhakarfa09acc2014-05-16 10:33:31 -03001578 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001579 /* Unregister video device */
1580 video_unregister_device(ch->video_dev);
Lad, Prabhakar410ca602013-06-17 11:20:44 -03001581 kfree(vpif_obj.dev[i]);
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001582 }
1583 return 0;
1584}
1585
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001586#ifdef CONFIG_PM_SLEEP
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001587/**
1588 * vpif_suspend: vpif device suspend
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001589 */
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001590static int vpif_suspend(struct device *dev)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001591{
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001592
1593 struct common_obj *common;
1594 struct channel_obj *ch;
1595 int i;
1596
1597 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1598 /* Get the pointer to the channel object */
1599 ch = vpif_obj.dev[i];
1600 common = &ch->common[VPIF_VIDEO_INDEX];
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001601
1602 if (!vb2_is_streaming(&common->buffer_queue))
1603 continue;
1604
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001605 mutex_lock(&common->lock);
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001606 /* Disable channel */
1607 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) {
1608 enable_channel0(0);
1609 channel0_intr_enable(0);
1610 }
1611 if (ch->channel_id == VPIF_CHANNEL1_VIDEO ||
1612 ycmux_mode == 2) {
1613 enable_channel1(0);
1614 channel1_intr_enable(0);
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001615 }
1616 mutex_unlock(&common->lock);
1617 }
1618
1619 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001620}
1621
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001622/*
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001623 * vpif_resume: vpif device suspend
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001624 */
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001625static int vpif_resume(struct device *dev)
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001626{
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001627 struct common_obj *common;
1628 struct channel_obj *ch;
1629 int i;
1630
1631 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
1632 /* Get the pointer to the channel object */
1633 ch = vpif_obj.dev[i];
1634 common = &ch->common[VPIF_VIDEO_INDEX];
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001635
1636 if (!vb2_is_streaming(&common->buffer_queue))
1637 continue;
1638
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001639 mutex_lock(&common->lock);
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001640 /* Enable channel */
1641 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) {
1642 enable_channel0(1);
1643 channel0_intr_enable(1);
1644 }
1645 if (ch->channel_id == VPIF_CHANNEL1_VIDEO ||
1646 ycmux_mode == 2) {
1647 enable_channel1(1);
1648 channel1_intr_enable(1);
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001649 }
1650 mutex_unlock(&common->lock);
1651 }
1652
1653 return 0;
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001654}
Manjunath Hadli3d5946d2012-04-13 04:50:55 -03001655#endif
1656
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001657static SIMPLE_DEV_PM_OPS(vpif_pm_ops, vpif_suspend, vpif_resume);
1658
Mats Randgaardffa1b392010-08-30 10:30:36 -03001659static __refdata struct platform_driver vpif_driver = {
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001660 .driver = {
Lad, Prabhakare75ea0c2014-05-16 10:33:46 -03001661 .name = VPIF_DRIVER_NAME,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001662 .owner = THIS_MODULE,
Lad, Prabhakarb7047712014-05-16 10:33:50 -03001663 .pm = &vpif_pm_ops,
Muralidharan Karicheri6ffefff2009-09-16 14:31:10 -03001664 },
1665 .probe = vpif_probe,
1666 .remove = vpif_remove,
1667};
1668
Lad, Prabhakarfe424b22013-06-17 11:20:45 -03001669module_platform_driver(vpif_driver);