aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/davinci/vpif_capture.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/davinci/vpif_capture.c')
-rw-r--r--drivers/media/video/davinci/vpif_capture.c2456
1 files changed, 0 insertions, 2456 deletions
diff --git a/drivers/media/video/davinci/vpif_capture.c b/drivers/media/video/davinci/vpif_capture.c
deleted file mode 100644
index 1b625b065c32..000000000000
--- a/drivers/media/video/davinci/vpif_capture.c
+++ /dev/null
@@ -1,2456 +0,0 @@
1/*
2 * Copyright (C) 2009 Texas Instruments Inc
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * TODO : add support for VBI & HBI data service
19 * add static buffer allocation
20 */
21#include <linux/kernel.h>
22#include <linux/init.h>
23#include <linux/module.h>
24#include <linux/errno.h>
25#include <linux/fs.h>
26#include <linux/mm.h>
27#include <linux/interrupt.h>
28#include <linux/workqueue.h>
29#include <linux/string.h>
30#include <linux/videodev2.h>
31#include <linux/wait.h>
32#include <linux/time.h>
33#include <linux/i2c.h>
34#include <linux/platform_device.h>
35#include <linux/io.h>
36#include <linux/slab.h>
37#include <media/v4l2-device.h>
38#include <media/v4l2-ioctl.h>
39#include <media/v4l2-chip-ident.h>
40
41#include "vpif_capture.h"
42#include "vpif.h"
43
44MODULE_DESCRIPTION("TI DaVinci VPIF Capture driver");
45MODULE_LICENSE("GPL");
46MODULE_VERSION(VPIF_CAPTURE_VERSION);
47
48#define vpif_err(fmt, arg...) v4l2_err(&vpif_obj.v4l2_dev, fmt, ## arg)
49#define vpif_dbg(level, debug, fmt, arg...) \
50 v4l2_dbg(level, debug, &vpif_obj.v4l2_dev, fmt, ## arg)
51
52static int debug = 1;
53static u32 ch0_numbuffers = 3;
54static u32 ch1_numbuffers = 3;
55static u32 ch0_bufsize = 1920 * 1080 * 2;
56static u32 ch1_bufsize = 720 * 576 * 2;
57
58module_param(debug, int, 0644);
59module_param(ch0_numbuffers, uint, S_IRUGO);
60module_param(ch1_numbuffers, uint, S_IRUGO);
61module_param(ch0_bufsize, uint, S_IRUGO);
62module_param(ch1_bufsize, uint, S_IRUGO);
63
64MODULE_PARM_DESC(debug, "Debug level 0-1");
65MODULE_PARM_DESC(ch2_numbuffers, "Channel0 buffer count (default:3)");
66MODULE_PARM_DESC(ch3_numbuffers, "Channel1 buffer count (default:3)");
67MODULE_PARM_DESC(ch2_bufsize, "Channel0 buffer size (default:1920 x 1080 x 2)");
68MODULE_PARM_DESC(ch3_bufsize, "Channel1 buffer size (default:720 x 576 x 2)");
69
70static struct vpif_config_params config_params = {
71 .min_numbuffers = 3,
72 .numbuffers[0] = 3,
73 .numbuffers[1] = 3,
74 .min_bufsize[0] = 720 * 480 * 2,
75 .min_bufsize[1] = 720 * 480 * 2,
76 .channel_bufsize[0] = 1920 * 1080 * 2,
77 .channel_bufsize[1] = 720 * 576 * 2,
78};
79
80/* global variables */
81static struct vpif_device vpif_obj = { {NULL} };
82static struct device *vpif_dev;
83static void vpif_calculate_offsets(struct channel_obj *ch);
84static void vpif_config_addr(struct channel_obj *ch, int muxmode);
85
86/**
87 * buffer_prepare : callback function for buffer prepare
88 * @vb: ptr to vb2_buffer
89 *
90 * This is the callback function for buffer prepare when vb2_qbuf()
91 * function is called. The buffer is prepared and user space virtual address
92 * or user address is converted into physical address
93 */
94static int vpif_buffer_prepare(struct vb2_buffer *vb)
95{
96 /* Get the file handle object and channel object */
97 struct vpif_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
98 struct vb2_queue *q = vb->vb2_queue;
99 struct channel_obj *ch = fh->channel;
100 struct common_obj *common;
101 unsigned long addr;
102
103 vpif_dbg(2, debug, "vpif_buffer_prepare\n");
104
105 common = &ch->common[VPIF_VIDEO_INDEX];
106
107 if (vb->state != VB2_BUF_STATE_ACTIVE &&
108 vb->state != VB2_BUF_STATE_PREPARED) {
109 vb2_set_plane_payload(vb, 0, common->fmt.fmt.pix.sizeimage);
110 if (vb2_plane_vaddr(vb, 0) &&
111 vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
112 goto exit;
113 addr = vb2_dma_contig_plane_dma_addr(vb, 0);
114
115 if (q->streaming) {
116 if (!IS_ALIGNED((addr + common->ytop_off), 8) ||
117 !IS_ALIGNED((addr + common->ybtm_off), 8) ||
118 !IS_ALIGNED((addr + common->ctop_off), 8) ||
119 !IS_ALIGNED((addr + common->cbtm_off), 8))
120 goto exit;
121 }
122 }
123 return 0;
124exit:
125 vpif_dbg(1, debug, "buffer_prepare:offset is not aligned to 8 bytes\n");
126 return -EINVAL;
127}
128
129/**
130 * vpif_buffer_queue_setup : Callback function for buffer setup.
131 * @vq: vb2_queue ptr
132 * @fmt: v4l2 format
133 * @nbuffers: ptr to number of buffers requested by application
134 * @nplanes:: contains number of distinct video planes needed to hold a frame
135 * @sizes[]: contains the size (in bytes) of each plane.
136 * @alloc_ctxs: ptr to allocation context
137 *
138 * This callback function is called when reqbuf() is called to adjust
139 * the buffer count and buffer size
140 */
141static int vpif_buffer_queue_setup(struct vb2_queue *vq,
142 const struct v4l2_format *fmt,
143 unsigned int *nbuffers, unsigned int *nplanes,
144 unsigned int sizes[], void *alloc_ctxs[])
145{
146 /* Get the file handle object and channel object */
147 struct vpif_fh *fh = vb2_get_drv_priv(vq);
148 struct channel_obj *ch = fh->channel;
149 struct common_obj *common;
150 unsigned long size;
151
152 common = &ch->common[VPIF_VIDEO_INDEX];
153
154 vpif_dbg(2, debug, "vpif_buffer_setup\n");
155
156 /* If memory type is not mmap, return */
157 if (V4L2_MEMORY_MMAP == common->memory) {
158 /* Calculate the size of the buffer */
159 size = config_params.channel_bufsize[ch->channel_id];
160 /*
161 * Checking if the buffer size exceeds the available buffer
162 * ycmux_mode = 0 means 1 channel mode HD and
163 * ycmux_mode = 1 means 2 channels mode SD
164 */
165 if (ch->vpifparams.std_info.ycmux_mode == 0) {
166 if (config_params.video_limit[ch->channel_id])
167 while (size * *nbuffers >
168 (config_params.video_limit[0]
169 + config_params.video_limit[1]))
170 (*nbuffers)--;
171 } else {
172 if (config_params.video_limit[ch->channel_id])
173 while (size * *nbuffers >
174 config_params.video_limit[ch->channel_id])
175 (*nbuffers)--;
176 }
177
178 } else {
179 size = common->fmt.fmt.pix.sizeimage;
180 }
181
182 if (*nbuffers < config_params.min_numbuffers)
183 *nbuffers = config_params.min_numbuffers;
184
185 *nplanes = 1;
186 sizes[0] = size;
187 alloc_ctxs[0] = common->alloc_ctx;
188
189 return 0;
190}
191
192/**
193 * vpif_buffer_queue : Callback function to add buffer to DMA queue
194 * @vb: ptr to vb2_buffer
195 */
196static void vpif_buffer_queue(struct vb2_buffer *vb)
197{
198 /* Get the file handle object and channel object */
199 struct vpif_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
200 struct channel_obj *ch = fh->channel;
201 struct vpif_cap_buffer *buf = container_of(vb,
202 struct vpif_cap_buffer, vb);
203 struct common_obj *common;
204
205 common = &ch->common[VPIF_VIDEO_INDEX];
206
207 vpif_dbg(2, debug, "vpif_buffer_queue\n");
208
209 /* add the buffer to the DMA queue */
210 list_add_tail(&buf->list, &common->dma_queue);
211}
212
213/**
214 * vpif_buf_cleanup : Callback function to free buffer
215 * @vb: ptr to vb2_buffer
216 *
217 * This function is called from the videobuf2 layer to free memory
218 * allocated to the buffers
219 */
220static void vpif_buf_cleanup(struct vb2_buffer *vb)
221{
222 /* Get the file handle object and channel object */
223 struct vpif_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
224 struct vpif_cap_buffer *buf = container_of(vb,
225 struct vpif_cap_buffer, vb);
226 struct channel_obj *ch = fh->channel;
227 struct common_obj *common;
228 unsigned long flags;
229
230 common = &ch->common[VPIF_VIDEO_INDEX];
231
232 spin_lock_irqsave(&common->irqlock, flags);
233 if (vb->state == VB2_BUF_STATE_ACTIVE)
234 list_del_init(&buf->list);
235 spin_unlock_irqrestore(&common->irqlock, flags);
236
237}
238
239static void vpif_wait_prepare(struct vb2_queue *vq)
240{
241 struct vpif_fh *fh = vb2_get_drv_priv(vq);
242 struct channel_obj *ch = fh->channel;
243 struct common_obj *common;
244
245 common = &ch->common[VPIF_VIDEO_INDEX];
246 mutex_unlock(&common->lock);
247}
248
249static void vpif_wait_finish(struct vb2_queue *vq)
250{
251 struct vpif_fh *fh = vb2_get_drv_priv(vq);
252 struct channel_obj *ch = fh->channel;
253 struct common_obj *common;
254
255 common = &ch->common[VPIF_VIDEO_INDEX];
256 mutex_lock(&common->lock);
257}
258
259static int vpif_buffer_init(struct vb2_buffer *vb)
260{
261 struct vpif_cap_buffer *buf = container_of(vb,
262 struct vpif_cap_buffer, vb);
263
264 INIT_LIST_HEAD(&buf->list);
265
266 return 0;
267}
268
269static u8 channel_first_int[VPIF_NUMBER_OF_OBJECTS][2] =
270 { {1, 1} };
271
272static int vpif_start_streaming(struct vb2_queue *vq, unsigned int count)
273{
274 struct vpif_capture_config *vpif_config_data =
275 vpif_dev->platform_data;
276 struct vpif_fh *fh = vb2_get_drv_priv(vq);
277 struct channel_obj *ch = fh->channel;
278 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
279 struct vpif_params *vpif = &ch->vpifparams;
280 unsigned long addr = 0;
281 int ret;
282
283 /* If buffer queue is empty, return error */
284 if (list_empty(&common->dma_queue)) {
285 vpif_dbg(1, debug, "buffer queue is empty\n");
286 return -EIO;
287 }
288
289 /* Get the next frame from the buffer queue */
290 common->cur_frm = common->next_frm = list_entry(common->dma_queue.next,
291 struct vpif_cap_buffer, list);
292 /* Remove buffer from the buffer queue */
293 list_del(&common->cur_frm->list);
294 /* Mark state of the current frame to active */
295 common->cur_frm->vb.state = VB2_BUF_STATE_ACTIVE;
296 /* Initialize field_id and started member */
297 ch->field_id = 0;
298 common->started = 1;
299 addr = vb2_dma_contig_plane_dma_addr(&common->cur_frm->vb, 0);
300
301 /* Calculate the offset for Y and C data in the buffer */
302 vpif_calculate_offsets(ch);
303
304 if ((vpif->std_info.frm_fmt &&
305 ((common->fmt.fmt.pix.field != V4L2_FIELD_NONE) &&
306 (common->fmt.fmt.pix.field != V4L2_FIELD_ANY))) ||
307 (!vpif->std_info.frm_fmt &&
308 (common->fmt.fmt.pix.field == V4L2_FIELD_NONE))) {
309 vpif_dbg(1, debug, "conflict in field format and std format\n");
310 return -EINVAL;
311 }
312
313 /* configure 1 or 2 channel mode */
314 ret = vpif_config_data->setup_input_channel_mode
315 (vpif->std_info.ycmux_mode);
316
317 if (ret < 0) {
318 vpif_dbg(1, debug, "can't set vpif channel mode\n");
319 return ret;
320 }
321
322 /* Call vpif_set_params function to set the parameters and addresses */
323 ret = vpif_set_video_params(vpif, ch->channel_id);
324
325 if (ret < 0) {
326 vpif_dbg(1, debug, "can't set video params\n");
327 return ret;
328 }
329
330 common->started = ret;
331 vpif_config_addr(ch, ret);
332
333 common->set_addr(addr + common->ytop_off,
334 addr + common->ybtm_off,
335 addr + common->ctop_off,
336 addr + common->cbtm_off);
337
338 /**
339 * Set interrupt for both the fields in VPIF Register enable channel in
340 * VPIF register
341 */
342 if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)) {
343 channel0_intr_assert();
344 channel0_intr_enable(1);
345 enable_channel0(1);
346 }
347 if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
348 (common->started == 2)) {
349 channel1_intr_assert();
350 channel1_intr_enable(1);
351 enable_channel1(1);
352 }
353 channel_first_int[VPIF_VIDEO_INDEX][ch->channel_id] = 1;
354
355 return 0;
356}
357
358/* abort streaming and wait for last buffer */
359static int vpif_stop_streaming(struct vb2_queue *vq)
360{
361 struct vpif_fh *fh = vb2_get_drv_priv(vq);
362 struct channel_obj *ch = fh->channel;
363 struct common_obj *common;
364
365 if (!vb2_is_streaming(vq))
366 return 0;
367
368 common = &ch->common[VPIF_VIDEO_INDEX];
369
370 /* release all active buffers */
371 while (!list_empty(&common->dma_queue)) {
372 common->next_frm = list_entry(common->dma_queue.next,
373 struct vpif_cap_buffer, list);
374 list_del(&common->next_frm->list);
375 vb2_buffer_done(&common->next_frm->vb, VB2_BUF_STATE_ERROR);
376 }
377
378 return 0;
379}
380
381static struct vb2_ops video_qops = {
382 .queue_setup = vpif_buffer_queue_setup,
383 .wait_prepare = vpif_wait_prepare,
384 .wait_finish = vpif_wait_finish,
385 .buf_init = vpif_buffer_init,
386 .buf_prepare = vpif_buffer_prepare,
387 .start_streaming = vpif_start_streaming,
388 .stop_streaming = vpif_stop_streaming,
389 .buf_cleanup = vpif_buf_cleanup,
390 .buf_queue = vpif_buffer_queue,
391};
392
393/**
394 * vpif_process_buffer_complete: process a completed buffer
395 * @common: ptr to common channel object
396 *
397 * This function time stamp the buffer and mark it as DONE. It also
398 * wake up any process waiting on the QUEUE and set the next buffer
399 * as current
400 */
401static void vpif_process_buffer_complete(struct common_obj *common)
402{
403 do_gettimeofday(&common->cur_frm->vb.v4l2_buf.timestamp);
404 vb2_buffer_done(&common->cur_frm->vb,
405 VB2_BUF_STATE_DONE);
406 /* Make curFrm pointing to nextFrm */
407 common->cur_frm = common->next_frm;
408}
409
410/**
411 * vpif_schedule_next_buffer: set next buffer address for capture
412 * @common : ptr to common channel object
413 *
414 * This function will get next buffer from the dma queue and
415 * set the buffer address in the vpif register for capture.
416 * the buffer is marked active
417 */
418static void vpif_schedule_next_buffer(struct common_obj *common)
419{
420 unsigned long addr = 0;
421
422 common->next_frm = list_entry(common->dma_queue.next,
423 struct vpif_cap_buffer, list);
424 /* Remove that buffer from the buffer queue */
425 list_del(&common->next_frm->list);
426 common->next_frm->vb.state = VB2_BUF_STATE_ACTIVE;
427 addr = vb2_dma_contig_plane_dma_addr(&common->next_frm->vb, 0);
428
429 /* Set top and bottom field addresses in VPIF registers */
430 common->set_addr(addr + common->ytop_off,
431 addr + common->ybtm_off,
432 addr + common->ctop_off,
433 addr + common->cbtm_off);
434}
435
436/**
437 * vpif_channel_isr : ISR handler for vpif capture
438 * @irq: irq number
439 * @dev_id: dev_id ptr
440 *
441 * It changes status of the captured buffer, takes next buffer from the queue
442 * and sets its address in VPIF registers
443 */
444static irqreturn_t vpif_channel_isr(int irq, void *dev_id)
445{
446 struct vpif_device *dev = &vpif_obj;
447 struct common_obj *common;
448 struct channel_obj *ch;
449 enum v4l2_field field;
450 int channel_id = 0;
451 int fid = -1, i;
452
453 channel_id = *(int *)(dev_id);
454 if (!vpif_intr_status(channel_id))
455 return IRQ_NONE;
456
457 ch = dev->dev[channel_id];
458
459 field = ch->common[VPIF_VIDEO_INDEX].fmt.fmt.pix.field;
460
461 for (i = 0; i < VPIF_NUMBER_OF_OBJECTS; i++) {
462 common = &ch->common[i];
463 /* skip If streaming is not started in this channel */
464 if (0 == common->started)
465 continue;
466
467 /* Check the field format */
468 if (1 == ch->vpifparams.std_info.frm_fmt) {
469 /* Progressive mode */
470 if (list_empty(&common->dma_queue))
471 continue;
472
473 if (!channel_first_int[i][channel_id])
474 vpif_process_buffer_complete(common);
475
476 channel_first_int[i][channel_id] = 0;
477
478 vpif_schedule_next_buffer(common);
479
480
481 channel_first_int[i][channel_id] = 0;
482 } else {
483 /**
484 * Interlaced mode. If it is first interrupt, ignore
485 * it
486 */
487 if (channel_first_int[i][channel_id]) {
488 channel_first_int[i][channel_id] = 0;
489 continue;
490 }
491 if (0 == i) {
492 ch->field_id ^= 1;
493 /* Get field id from VPIF registers */
494 fid = vpif_channel_getfid(ch->channel_id);
495 if (fid != ch->field_id) {
496 /**
497 * If field id does not match stored
498 * field id, make them in sync
499 */
500 if (0 == fid)
501 ch->field_id = fid;
502 return IRQ_HANDLED;
503 }
504 }
505 /* device field id and local field id are in sync */
506 if (0 == fid) {
507 /* this is even field */
508 if (common->cur_frm == common->next_frm)
509 continue;
510
511 /* mark the current buffer as done */
512 vpif_process_buffer_complete(common);
513 } else if (1 == fid) {
514 /* odd field */
515 if (list_empty(&common->dma_queue) ||
516 (common->cur_frm != common->next_frm))
517 continue;
518
519 vpif_schedule_next_buffer(common);
520 }
521 }
522 }
523 return IRQ_HANDLED;
524}
525
526/**
527 * vpif_update_std_info() - update standard related info
528 * @ch: ptr to channel object
529 *
530 * For a given standard selected by application, update values
531 * in the device data structures
532 */
533static int vpif_update_std_info(struct channel_obj *ch)
534{
535 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
536 struct vpif_params *vpifparams = &ch->vpifparams;
537 const struct vpif_channel_config_params *config;
538 struct vpif_channel_config_params *std_info = &vpifparams->std_info;
539 struct video_obj *vid_ch = &ch->video;
540 int index;
541
542 vpif_dbg(2, debug, "vpif_update_std_info\n");
543
544 for (index = 0; index < vpif_ch_params_count; index++) {
545 config = &ch_params[index];
546 if (config->hd_sd == 0) {
547 vpif_dbg(2, debug, "SD format\n");
548 if (config->stdid & vid_ch->stdid) {
549 memcpy(std_info, config, sizeof(*config));
550 break;
551 }
552 } else {
553 vpif_dbg(2, debug, "HD format\n");
554 if (config->dv_preset == vid_ch->dv_preset) {
555 memcpy(std_info, config, sizeof(*config));
556 break;
557 }
558 }
559 }
560
561 /* standard not found */
562 if (index == vpif_ch_params_count)
563 return -EINVAL;
564
565 common->fmt.fmt.pix.width = std_info->width;
566 common->width = std_info->width;
567 common->fmt.fmt.pix.height = std_info->height;
568 common->height = std_info->height;
569 common->fmt.fmt.pix.bytesperline = std_info->width;
570 vpifparams->video_params.hpitch = std_info->width;
571 vpifparams->video_params.storage_mode = std_info->frm_fmt;
572
573 return 0;
574}
575
576/**
577 * vpif_calculate_offsets : This function calculates buffers offsets
578 * @ch : ptr to channel object
579 *
580 * This function calculates buffer offsets for Y and C in the top and
581 * bottom field
582 */
583static void vpif_calculate_offsets(struct channel_obj *ch)
584{
585 unsigned int hpitch, vpitch, sizeimage;
586 struct video_obj *vid_ch = &(ch->video);
587 struct vpif_params *vpifparams = &ch->vpifparams;
588 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
589 enum v4l2_field field = common->fmt.fmt.pix.field;
590
591 vpif_dbg(2, debug, "vpif_calculate_offsets\n");
592
593 if (V4L2_FIELD_ANY == field) {
594 if (vpifparams->std_info.frm_fmt)
595 vid_ch->buf_field = V4L2_FIELD_NONE;
596 else
597 vid_ch->buf_field = V4L2_FIELD_INTERLACED;
598 } else
599 vid_ch->buf_field = common->fmt.fmt.pix.field;
600
601 sizeimage = common->fmt.fmt.pix.sizeimage;
602
603 hpitch = common->fmt.fmt.pix.bytesperline;
604 vpitch = sizeimage / (hpitch * 2);
605
606 if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
607 (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) {
608 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
609 common->ytop_off = 0;
610 common->ybtm_off = hpitch;
611 common->ctop_off = sizeimage / 2;
612 common->cbtm_off = sizeimage / 2 + hpitch;
613 } else if (V4L2_FIELD_SEQ_TB == vid_ch->buf_field) {
614 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
615 common->ytop_off = 0;
616 common->ybtm_off = sizeimage / 4;
617 common->ctop_off = sizeimage / 2;
618 common->cbtm_off = common->ctop_off + sizeimage / 4;
619 } else if (V4L2_FIELD_SEQ_BT == vid_ch->buf_field) {
620 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
621 common->ybtm_off = 0;
622 common->ytop_off = sizeimage / 4;
623 common->cbtm_off = sizeimage / 2;
624 common->ctop_off = common->cbtm_off + sizeimage / 4;
625 }
626 if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
627 (V4L2_FIELD_INTERLACED == vid_ch->buf_field))
628 vpifparams->video_params.storage_mode = 1;
629 else
630 vpifparams->video_params.storage_mode = 0;
631
632 if (1 == vpifparams->std_info.frm_fmt)
633 vpifparams->video_params.hpitch =
634 common->fmt.fmt.pix.bytesperline;
635 else {
636 if ((field == V4L2_FIELD_ANY)
637 || (field == V4L2_FIELD_INTERLACED))
638 vpifparams->video_params.hpitch =
639 common->fmt.fmt.pix.bytesperline * 2;
640 else
641 vpifparams->video_params.hpitch =
642 common->fmt.fmt.pix.bytesperline;
643 }
644
645 ch->vpifparams.video_params.stdid = vpifparams->std_info.stdid;
646}
647
648/**
649 * vpif_config_format: configure default frame format in the device
650 * ch : ptr to channel object
651 */
652static void vpif_config_format(struct channel_obj *ch)
653{
654 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
655
656 vpif_dbg(2, debug, "vpif_config_format\n");
657
658 common->fmt.fmt.pix.field = V4L2_FIELD_ANY;
659 if (config_params.numbuffers[ch->channel_id] == 0)
660 common->memory = V4L2_MEMORY_USERPTR;
661 else
662 common->memory = V4L2_MEMORY_MMAP;
663
664 common->fmt.fmt.pix.sizeimage
665 = config_params.channel_bufsize[ch->channel_id];
666
667 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER)
668 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8;
669 else
670 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
671 common->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
672}
673
674/**
675 * vpif_get_default_field() - Get default field type based on interface
676 * @vpif_params - ptr to vpif params
677 */
678static inline enum v4l2_field vpif_get_default_field(
679 struct vpif_interface *iface)
680{
681 return (iface->if_type == VPIF_IF_RAW_BAYER) ? V4L2_FIELD_NONE :
682 V4L2_FIELD_INTERLACED;
683}
684
685/**
686 * vpif_check_format() - check given pixel format for compatibility
687 * @ch - channel ptr
688 * @pixfmt - Given pixel format
689 * @update - update the values as per hardware requirement
690 *
691 * Check the application pixel format for S_FMT and update the input
692 * values as per hardware limits for TRY_FMT. The default pixel and
693 * field format is selected based on interface type.
694 */
695static int vpif_check_format(struct channel_obj *ch,
696 struct v4l2_pix_format *pixfmt,
697 int update)
698{
699 struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
700 struct vpif_params *vpif_params = &ch->vpifparams;
701 enum v4l2_field field = pixfmt->field;
702 u32 sizeimage, hpitch, vpitch;
703 int ret = -EINVAL;
704
705 vpif_dbg(2, debug, "vpif_check_format\n");
706 /**
707 * first check for the pixel format. If if_type is Raw bayer,
708 * only V4L2_PIX_FMT_SBGGR8 format is supported. Otherwise only
709 * V4L2_PIX_FMT_YUV422P is supported
710 */
711 if (vpif_params->iface.if_type == VPIF_IF_RAW_BAYER) {
712 if (pixfmt->pixelformat != V4L2_PIX_FMT_SBGGR8) {
713 if (!update) {
714 vpif_dbg(2, debug, "invalid pix format\n");
715 goto exit;
716 }
717 pixfmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
718 }
719 } else {
720 if (pixfmt->pixelformat != V4L2_PIX_FMT_YUV422P) {
721 if (!update) {
722 vpif_dbg(2, debug, "invalid pixel format\n");
723 goto exit;
724 }
725 pixfmt->pixelformat = V4L2_PIX_FMT_YUV422P;
726 }
727 }
728
729 if (!(VPIF_VALID_FIELD(field))) {
730 if (!update) {
731 vpif_dbg(2, debug, "invalid field format\n");
732 goto exit;
733 }
734 /**
735 * By default use FIELD_NONE for RAW Bayer capture
736 * and FIELD_INTERLACED for other interfaces
737 */
738 field = vpif_get_default_field(&vpif_params->iface);
739 } else if (field == V4L2_FIELD_ANY)
740 /* unsupported field. Use default */
741 field = vpif_get_default_field(&vpif_params->iface);
742
743 /* validate the hpitch */
744 hpitch = pixfmt->bytesperline;
745 if (hpitch < vpif_params->std_info.width) {
746 if (!update) {
747 vpif_dbg(2, debug, "invalid hpitch\n");
748 goto exit;
749 }
750 hpitch = vpif_params->std_info.width;
751 }
752
753 sizeimage = pixfmt->sizeimage;
754
755 vpitch = sizeimage / (hpitch * 2);
756
757 /* validate the vpitch */
758 if (vpitch < vpif_params->std_info.height) {
759 if (!update) {
760 vpif_dbg(2, debug, "Invalid vpitch\n");
761 goto exit;
762 }
763 vpitch = vpif_params->std_info.height;
764 }
765
766 /* Check for 8 byte alignment */
767 if (!ALIGN(hpitch, 8)) {
768 if (!update) {
769 vpif_dbg(2, debug, "invalid pitch alignment\n");
770 goto exit;
771 }
772 /* adjust to next 8 byte boundary */
773 hpitch = (((hpitch + 7) / 8) * 8);
774 }
775 /* if update is set, modify the bytesperline and sizeimage */
776 if (update) {
777 pixfmt->bytesperline = hpitch;
778 pixfmt->sizeimage = hpitch * vpitch * 2;
779 }
780 /**
781 * Image width and height is always based on current standard width and
782 * height
783 */
784 pixfmt->width = common->fmt.fmt.pix.width;
785 pixfmt->height = common->fmt.fmt.pix.height;
786 return 0;
787exit:
788 return ret;
789}
790
791/**
792 * vpif_config_addr() - function to configure buffer address in vpif
793 * @ch - channel ptr
794 * @muxmode - channel mux mode
795 */
796static void vpif_config_addr(struct channel_obj *ch, int muxmode)
797{
798 struct common_obj *common;
799
800 vpif_dbg(2, debug, "vpif_config_addr\n");
801
802 common = &(ch->common[VPIF_VIDEO_INDEX]);
803
804 if (VPIF_CHANNEL1_VIDEO == ch->channel_id)
805 common->set_addr = ch1_set_videobuf_addr;
806 else if (2 == muxmode)
807 common->set_addr = ch0_set_videobuf_addr_yc_nmux;
808 else
809 common->set_addr = ch0_set_videobuf_addr;
810}
811
812/**
813 * vpif_mmap : It is used to map kernel space buffers into user spaces
814 * @filep: file pointer
815 * @vma: ptr to vm_area_struct
816 */
817static int vpif_mmap(struct file *filep, struct vm_area_struct *vma)
818{
819 /* Get the channel object and file handle object */
820 struct vpif_fh *fh = filep->private_data;
821 struct channel_obj *ch = fh->channel;
822 struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
823 int ret;
824
825 vpif_dbg(2, debug, "vpif_mmap\n");
826
827 if (mutex_lock_interruptible(&common->lock))
828 return -ERESTARTSYS;
829 ret = vb2_mmap(&common->buffer_queue, vma);
830 mutex_unlock(&common->lock);
831 return ret;
832}
833
834/**
835 * vpif_poll: It is used for select/poll system call
836 * @filep: file pointer
837 * @wait: poll table to wait
838 */
839static unsigned int vpif_poll(struct file *filep, poll_table * wait)
840{
841 struct vpif_fh *fh = filep->private_data;
842 struct channel_obj *channel = fh->channel;
843 struct common_obj *common = &(channel->common[VPIF_VIDEO_INDEX]);
844 unsigned int res = 0;
845
846 vpif_dbg(2, debug, "vpif_poll\n");
847
848 if (common->started) {
849 mutex_lock(&common->lock);
850 res = vb2_poll(&common->buffer_queue, filep, wait);
851 mutex_unlock(&common->lock);
852 }
853 return res;
854}
855
856/**
857 * vpif_open : vpif open handler
858 * @filep: file ptr
859 *
860 * It creates object of file handle structure and stores it in private_data
861 * member of filepointer
862 */
863static int vpif_open(struct file *filep)
864{
865 struct vpif_capture_config *config = vpif_dev->platform_data;
866 struct video_device *vdev = video_devdata(filep);
867 struct common_obj *common;
868 struct video_obj *vid_ch;
869 struct channel_obj *ch;
870 struct vpif_fh *fh;
871 int i;
872
873 vpif_dbg(2, debug, "vpif_open\n");
874
875 ch = video_get_drvdata(vdev);
876
877 vid_ch = &ch->video;
878 common = &ch->common[VPIF_VIDEO_INDEX];
879
880 if (NULL == ch->curr_subdev_info) {
881 /**
882 * search through the sub device to see a registered
883 * sub device and make it as current sub device
884 */
885 for (i = 0; i < config->subdev_count; i++) {
886 if (vpif_obj.sd[i]) {
887 /* the sub device is registered */
888 ch->curr_subdev_info = &config->subdev_info[i];
889 /* make first input as the current input */
890 vid_ch->input_idx = 0;
891 break;
892 }
893 }
894 if (i == config->subdev_count) {
895 vpif_err("No sub device registered\n");
896 return -ENOENT;
897 }
898 }
899
900 /* Allocate memory for the file handle object */
901 fh = kzalloc(sizeof(struct vpif_fh), GFP_KERNEL);
902 if (NULL == fh) {
903 vpif_err("unable to allocate memory for file handle object\n");
904 return -ENOMEM;
905 }
906
907 if (mutex_lock_interruptible(&common->lock)) {
908 kfree(fh);
909 return -ERESTARTSYS;
910 }
911 /* store pointer to fh in private_data member of filep */
912 filep->private_data = fh;
913 fh->channel = ch;
914 fh->initialized = 0;
915 /* If decoder is not initialized. initialize it */
916 if (!ch->initialized) {
917 fh->initialized = 1;
918 ch->initialized = 1;
919 memset(&(ch->vpifparams), 0, sizeof(struct vpif_params));
920 }
921 /* Increment channel usrs counter */
922 ch->usrs++;
923 /* Set io_allowed member to false */
924 fh->io_allowed[VPIF_VIDEO_INDEX] = 0;
925 /* Initialize priority of this instance to default priority */
926 fh->prio = V4L2_PRIORITY_UNSET;
927 v4l2_prio_open(&ch->prio, &fh->prio);
928 mutex_unlock(&common->lock);
929 return 0;
930}
931
932/**
933 * vpif_release : function to clean up file close
934 * @filep: file pointer
935 *
936 * This function deletes buffer queue, frees the buffers and the vpif file
937 * handle
938 */
939static int vpif_release(struct file *filep)
940{
941 struct vpif_fh *fh = filep->private_data;
942 struct channel_obj *ch = fh->channel;
943 struct common_obj *common;
944
945 vpif_dbg(2, debug, "vpif_release\n");
946
947 common = &ch->common[VPIF_VIDEO_INDEX];
948
949 mutex_lock(&common->lock);
950 /* if this instance is doing IO */
951 if (fh->io_allowed[VPIF_VIDEO_INDEX]) {
952 /* Reset io_usrs member of channel object */
953 common->io_usrs = 0;
954 /* Disable channel as per its device type and channel id */
955 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
956 enable_channel0(0);
957 channel0_intr_enable(0);
958 }
959 if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
960 (2 == common->started)) {
961 enable_channel1(0);
962 channel1_intr_enable(0);
963 }
964 common->started = 0;
965 /* Free buffers allocated */
966 vb2_queue_release(&common->buffer_queue);
967 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
968 }
969
970 /* Decrement channel usrs counter */
971 ch->usrs--;
972
973 /* Close the priority */
974 v4l2_prio_close(&ch->prio, fh->prio);
975
976 if (fh->initialized)
977 ch->initialized = 0;
978
979 mutex_unlock(&common->lock);
980 filep->private_data = NULL;
981 kfree(fh);
982 return 0;
983}
984
985/**
986 * vpif_reqbufs() - request buffer handler
987 * @file: file ptr
988 * @priv: file handle
989 * @reqbuf: request buffer structure ptr
990 */
991static int vpif_reqbufs(struct file *file, void *priv,
992 struct v4l2_requestbuffers *reqbuf)
993{
994 struct vpif_fh *fh = priv;
995 struct channel_obj *ch = fh->channel;
996 struct common_obj *common;
997 u8 index = 0;
998 struct vb2_queue *q;
999
1000 vpif_dbg(2, debug, "vpif_reqbufs\n");
1001
1002 /**
1003 * This file handle has not initialized the channel,
1004 * It is not allowed to do settings
1005 */
1006 if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)
1007 || (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1008 if (!fh->initialized) {
1009 vpif_dbg(1, debug, "Channel Busy\n");
1010 return -EBUSY;
1011 }
1012 }
1013
1014 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type || !vpif_dev)
1015 return -EINVAL;
1016
1017 index = VPIF_VIDEO_INDEX;
1018
1019 common = &ch->common[index];
1020
1021 if (0 != common->io_usrs)
1022 return -EBUSY;
1023
1024 /* Initialize videobuf2 queue as per the buffer type */
1025 common->alloc_ctx = vb2_dma_contig_init_ctx(vpif_dev);
1026 if (!common->alloc_ctx) {
1027 vpif_err("Failed to get the context\n");
1028 return -EINVAL;
1029 }
1030 q = &common->buffer_queue;
1031 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1032 q->io_modes = VB2_MMAP | VB2_USERPTR;
1033 q->drv_priv = fh;
1034 q->ops = &video_qops;
1035 q->mem_ops = &vb2_dma_contig_memops;
1036 q->buf_struct_size = sizeof(struct vpif_cap_buffer);
1037
1038 vb2_queue_init(q);
1039
1040 /* Set io allowed member of file handle to TRUE */
1041 fh->io_allowed[index] = 1;
1042 /* Increment io usrs member of channel object to 1 */
1043 common->io_usrs = 1;
1044 /* Store type of memory requested in channel object */
1045 common->memory = reqbuf->memory;
1046 INIT_LIST_HEAD(&common->dma_queue);
1047
1048 /* Allocate buffers */
1049 return vb2_reqbufs(&common->buffer_queue, reqbuf);
1050}
1051
1052/**
1053 * vpif_querybuf() - query buffer handler
1054 * @file: file ptr
1055 * @priv: file handle
1056 * @buf: v4l2 buffer structure ptr
1057 */
1058static int vpif_querybuf(struct file *file, void *priv,
1059 struct v4l2_buffer *buf)
1060{
1061 struct vpif_fh *fh = priv;
1062 struct channel_obj *ch = fh->channel;
1063 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1064
1065 vpif_dbg(2, debug, "vpif_querybuf\n");
1066
1067 if (common->fmt.type != buf->type)
1068 return -EINVAL;
1069
1070 if (common->memory != V4L2_MEMORY_MMAP) {
1071 vpif_dbg(1, debug, "Invalid memory\n");
1072 return -EINVAL;
1073 }
1074
1075 return vb2_querybuf(&common->buffer_queue, buf);
1076}
1077
1078/**
1079 * vpif_qbuf() - query buffer handler
1080 * @file: file ptr
1081 * @priv: file handle
1082 * @buf: v4l2 buffer structure ptr
1083 */
1084static int vpif_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1085{
1086
1087 struct vpif_fh *fh = priv;
1088 struct channel_obj *ch = fh->channel;
1089 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1090 struct v4l2_buffer tbuf = *buf;
1091
1092 vpif_dbg(2, debug, "vpif_qbuf\n");
1093
1094 if (common->fmt.type != tbuf.type) {
1095 vpif_err("invalid buffer type\n");
1096 return -EINVAL;
1097 }
1098
1099 if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
1100 vpif_err("fh io not allowed\n");
1101 return -EACCES;
1102 }
1103
1104 return vb2_qbuf(&common->buffer_queue, buf);
1105}
1106
1107/**
1108 * vpif_dqbuf() - query buffer handler
1109 * @file: file ptr
1110 * @priv: file handle
1111 * @buf: v4l2 buffer structure ptr
1112 */
1113static int vpif_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1114{
1115 struct vpif_fh *fh = priv;
1116 struct channel_obj *ch = fh->channel;
1117 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1118
1119 vpif_dbg(2, debug, "vpif_dqbuf\n");
1120
1121 return vb2_dqbuf(&common->buffer_queue, buf,
1122 (file->f_flags & O_NONBLOCK));
1123}
1124
1125/**
1126 * vpif_streamon() - streamon handler
1127 * @file: file ptr
1128 * @priv: file handle
1129 * @buftype: v4l2 buffer type
1130 */
1131static int vpif_streamon(struct file *file, void *priv,
1132 enum v4l2_buf_type buftype)
1133{
1134
1135 struct vpif_fh *fh = priv;
1136 struct channel_obj *ch = fh->channel;
1137 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1138 struct channel_obj *oth_ch = vpif_obj.dev[!ch->channel_id];
1139 struct vpif_params *vpif;
1140 int ret = 0;
1141
1142 vpif_dbg(2, debug, "vpif_streamon\n");
1143
1144 vpif = &ch->vpifparams;
1145
1146 if (buftype != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1147 vpif_dbg(1, debug, "buffer type not supported\n");
1148 return -EINVAL;
1149 }
1150
1151 /* If file handle is not allowed IO, return error */
1152 if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
1153 vpif_dbg(1, debug, "io not allowed\n");
1154 return -EACCES;
1155 }
1156
1157 /* If Streaming is already started, return error */
1158 if (common->started) {
1159 vpif_dbg(1, debug, "channel->started\n");
1160 return -EBUSY;
1161 }
1162
1163 if ((ch->channel_id == VPIF_CHANNEL0_VIDEO &&
1164 oth_ch->common[VPIF_VIDEO_INDEX].started &&
1165 vpif->std_info.ycmux_mode == 0) ||
1166 ((ch->channel_id == VPIF_CHANNEL1_VIDEO) &&
1167 (2 == oth_ch->common[VPIF_VIDEO_INDEX].started))) {
1168 vpif_dbg(1, debug, "other channel is being used\n");
1169 return -EBUSY;
1170 }
1171
1172 ret = vpif_check_format(ch, &common->fmt.fmt.pix, 0);
1173 if (ret)
1174 return ret;
1175
1176 /* Enable streamon on the sub device */
1177 ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], video,
1178 s_stream, 1);
1179
1180 if (ret && (ret != -ENOIOCTLCMD)) {
1181 vpif_dbg(1, debug, "stream on failed in subdev\n");
1182 return ret;
1183 }
1184
1185 /* Call vb2_streamon to start streaming in videobuf2 */
1186 ret = vb2_streamon(&common->buffer_queue, buftype);
1187 if (ret) {
1188 vpif_dbg(1, debug, "vb2_streamon\n");
1189 return ret;
1190 }
1191
1192 return ret;
1193}
1194
1195/**
1196 * vpif_streamoff() - streamoff handler
1197 * @file: file ptr
1198 * @priv: file handle
1199 * @buftype: v4l2 buffer type
1200 */
1201static int vpif_streamoff(struct file *file, void *priv,
1202 enum v4l2_buf_type buftype)
1203{
1204
1205 struct vpif_fh *fh = priv;
1206 struct channel_obj *ch = fh->channel;
1207 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1208 int ret;
1209
1210 vpif_dbg(2, debug, "vpif_streamoff\n");
1211
1212 if (buftype != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1213 vpif_dbg(1, debug, "buffer type not supported\n");
1214 return -EINVAL;
1215 }
1216
1217 /* If io is allowed for this file handle, return error */
1218 if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
1219 vpif_dbg(1, debug, "io not allowed\n");
1220 return -EACCES;
1221 }
1222
1223 /* If streaming is not started, return error */
1224 if (!common->started) {
1225 vpif_dbg(1, debug, "channel->started\n");
1226 return -EINVAL;
1227 }
1228
1229 /* disable channel */
1230 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
1231 enable_channel0(0);
1232 channel0_intr_enable(0);
1233 } else {
1234 enable_channel1(0);
1235 channel1_intr_enable(0);
1236 }
1237
1238 common->started = 0;
1239
1240 ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], video,
1241 s_stream, 0);
1242
1243 if (ret && (ret != -ENOIOCTLCMD))
1244 vpif_dbg(1, debug, "stream off failed in subdev\n");
1245
1246 return vb2_streamoff(&common->buffer_queue, buftype);
1247}
1248
1249/**
1250 * vpif_map_sub_device_to_input() - Maps sub device to input
1251 * @ch - ptr to channel
1252 * @config - ptr to capture configuration
1253 * @input_index - Given input index from application
1254 * @sub_device_index - index into sd table
1255 *
1256 * lookup the sub device information for a given input index.
1257 * we report all the inputs to application. inputs table also
1258 * has sub device name for the each input
1259 */
1260static struct vpif_subdev_info *vpif_map_sub_device_to_input(
1261 struct channel_obj *ch,
1262 struct vpif_capture_config *vpif_cfg,
1263 int input_index,
1264 int *sub_device_index)
1265{
1266 struct vpif_capture_chan_config *chan_cfg;
1267 struct vpif_subdev_info *subdev_info = NULL;
1268 const char *subdev_name = NULL;
1269 int i;
1270
1271 vpif_dbg(2, debug, "vpif_map_sub_device_to_input\n");
1272
1273 chan_cfg = &vpif_cfg->chan_config[ch->channel_id];
1274
1275 /**
1276 * search through the inputs to find the sub device supporting
1277 * the input
1278 */
1279 for (i = 0; i < chan_cfg->input_count; i++) {
1280 /* For each sub device, loop through input */
1281 if (i == input_index) {
1282 subdev_name = chan_cfg->inputs[i].subdev_name;
1283 break;
1284 }
1285 }
1286
1287 /* if reached maximum. return null */
1288 if (i == chan_cfg->input_count || (NULL == subdev_name))
1289 return subdev_info;
1290
1291 /* loop through the sub device list to get the sub device info */
1292 for (i = 0; i < vpif_cfg->subdev_count; i++) {
1293 subdev_info = &vpif_cfg->subdev_info[i];
1294 if (!strcmp(subdev_info->name, subdev_name))
1295 break;
1296 }
1297
1298 if (i == vpif_cfg->subdev_count)
1299 return subdev_info;
1300
1301 /* check if the sub device is registered */
1302 if (NULL == vpif_obj.sd[i])
1303 return NULL;
1304
1305 *sub_device_index = i;
1306 return subdev_info;
1307}
1308
1309/**
1310 * vpif_querystd() - querystd handler
1311 * @file: file ptr
1312 * @priv: file handle
1313 * @std_id: ptr to std id
1314 *
1315 * This function is called to detect standard at the selected input
1316 */
1317static int vpif_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
1318{
1319 struct vpif_fh *fh = priv;
1320 struct channel_obj *ch = fh->channel;
1321 int ret = 0;
1322
1323 vpif_dbg(2, debug, "vpif_querystd\n");
1324
1325 /* Call querystd function of decoder device */
1326 ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], video,
1327 querystd, std_id);
1328 if (ret < 0)
1329 vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
1330
1331 return ret;
1332}
1333
1334/**
1335 * vpif_g_std() - get STD handler
1336 * @file: file ptr
1337 * @priv: file handle
1338 * @std_id: ptr to std id
1339 */
1340static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std)
1341{
1342 struct vpif_fh *fh = priv;
1343 struct channel_obj *ch = fh->channel;
1344
1345 vpif_dbg(2, debug, "vpif_g_std\n");
1346
1347 *std = ch->video.stdid;
1348 return 0;
1349}
1350
1351/**
1352 * vpif_s_std() - set STD handler
1353 * @file: file ptr
1354 * @priv: file handle
1355 * @std_id: ptr to std id
1356 */
1357static int vpif_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
1358{
1359 struct vpif_fh *fh = priv;
1360 struct channel_obj *ch = fh->channel;
1361 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1362 int ret = 0;
1363
1364 vpif_dbg(2, debug, "vpif_s_std\n");
1365
1366 if (common->started) {
1367 vpif_err("streaming in progress\n");
1368 return -EBUSY;
1369 }
1370
1371 if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1372 (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1373 if (!fh->initialized) {
1374 vpif_dbg(1, debug, "Channel Busy\n");
1375 return -EBUSY;
1376 }
1377 }
1378
1379 ret = v4l2_prio_check(&ch->prio, fh->prio);
1380 if (0 != ret)
1381 return ret;
1382
1383 fh->initialized = 1;
1384
1385 /* Call encoder subdevice function to set the standard */
1386 ch->video.stdid = *std_id;
1387 ch->video.dv_preset = V4L2_DV_INVALID;
1388 memset(&ch->video.bt_timings, 0, sizeof(ch->video.bt_timings));
1389
1390 /* Get the information about the standard */
1391 if (vpif_update_std_info(ch)) {
1392 vpif_err("Error getting the standard info\n");
1393 return -EINVAL;
1394 }
1395
1396 /* Configure the default format information */
1397 vpif_config_format(ch);
1398
1399 /* set standard in the sub device */
1400 ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], core,
1401 s_std, *std_id);
1402 if (ret < 0)
1403 vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
1404 return ret;
1405}
1406
1407/**
1408 * vpif_enum_input() - ENUMINPUT handler
1409 * @file: file ptr
1410 * @priv: file handle
1411 * @input: ptr to input structure
1412 */
1413static int vpif_enum_input(struct file *file, void *priv,
1414 struct v4l2_input *input)
1415{
1416
1417 struct vpif_capture_config *config = vpif_dev->platform_data;
1418 struct vpif_capture_chan_config *chan_cfg;
1419 struct vpif_fh *fh = priv;
1420 struct channel_obj *ch = fh->channel;
1421
1422 chan_cfg = &config->chan_config[ch->channel_id];
1423
1424 if (input->index >= chan_cfg->input_count) {
1425 vpif_dbg(1, debug, "Invalid input index\n");
1426 return -EINVAL;
1427 }
1428
1429 memcpy(input, &chan_cfg->inputs[input->index].input,
1430 sizeof(*input));
1431 return 0;
1432}
1433
1434/**
1435 * vpif_g_input() - Get INPUT handler
1436 * @file: file ptr
1437 * @priv: file handle
1438 * @index: ptr to input index
1439 */
1440static int vpif_g_input(struct file *file, void *priv, unsigned int *index)
1441{
1442 struct vpif_fh *fh = priv;
1443 struct channel_obj *ch = fh->channel;
1444 struct video_obj *vid_ch = &ch->video;
1445
1446 *index = vid_ch->input_idx;
1447
1448 return 0;
1449}
1450
1451/**
1452 * vpif_s_input() - Set INPUT handler
1453 * @file: file ptr
1454 * @priv: file handle
1455 * @index: input index
1456 */
1457static int vpif_s_input(struct file *file, void *priv, unsigned int index)
1458{
1459 struct vpif_capture_config *config = vpif_dev->platform_data;
1460 struct vpif_capture_chan_config *chan_cfg;
1461 struct vpif_fh *fh = priv;
1462 struct channel_obj *ch = fh->channel;
1463 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1464 struct video_obj *vid_ch = &ch->video;
1465 struct vpif_subdev_info *subdev_info;
1466 int ret = 0, sd_index = 0;
1467 u32 input = 0, output = 0;
1468
1469 chan_cfg = &config->chan_config[ch->channel_id];
1470
1471 if (common->started) {
1472 vpif_err("Streaming in progress\n");
1473 return -EBUSY;
1474 }
1475
1476 if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1477 (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1478 if (!fh->initialized) {
1479 vpif_dbg(1, debug, "Channel Busy\n");
1480 return -EBUSY;
1481 }
1482 }
1483
1484 ret = v4l2_prio_check(&ch->prio, fh->prio);
1485 if (0 != ret)
1486 return ret;
1487
1488 fh->initialized = 1;
1489 subdev_info = vpif_map_sub_device_to_input(ch, config, index,
1490 &sd_index);
1491 if (NULL == subdev_info) {
1492 vpif_dbg(1, debug,
1493 "couldn't lookup sub device for the input index\n");
1494 return -EINVAL;
1495 }
1496
1497 /* first setup input path from sub device to vpif */
1498 if (config->setup_input_path) {
1499 ret = config->setup_input_path(ch->channel_id,
1500 subdev_info->name);
1501 if (ret < 0) {
1502 vpif_dbg(1, debug, "couldn't setup input path for the"
1503 " sub device %s, for input index %d\n",
1504 subdev_info->name, index);
1505 return ret;
1506 }
1507 }
1508
1509 if (subdev_info->can_route) {
1510 input = subdev_info->input;
1511 output = subdev_info->output;
1512 ret = v4l2_subdev_call(vpif_obj.sd[sd_index], video, s_routing,
1513 input, output, 0);
1514 if (ret < 0) {
1515 vpif_dbg(1, debug, "Failed to set input\n");
1516 return ret;
1517 }
1518 }
1519 vid_ch->input_idx = index;
1520 ch->curr_subdev_info = subdev_info;
1521 ch->curr_sd_index = sd_index;
1522 /* copy interface parameters to vpif */
1523 ch->vpifparams.iface = subdev_info->vpif_if;
1524
1525 /* update tvnorms from the sub device input info */
1526 ch->video_dev->tvnorms = chan_cfg->inputs[index].input.std;
1527 return ret;
1528}
1529
1530/**
1531 * vpif_enum_fmt_vid_cap() - ENUM_FMT handler
1532 * @file: file ptr
1533 * @priv: file handle
1534 * @index: input index
1535 */
1536static int vpif_enum_fmt_vid_cap(struct file *file, void *priv,
1537 struct v4l2_fmtdesc *fmt)
1538{
1539 struct vpif_fh *fh = priv;
1540 struct channel_obj *ch = fh->channel;
1541
1542 if (fmt->index != 0) {
1543 vpif_dbg(1, debug, "Invalid format index\n");
1544 return -EINVAL;
1545 }
1546
1547 /* Fill in the information about format */
1548 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) {
1549 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1550 strcpy(fmt->description, "Raw Mode -Bayer Pattern GrRBGb");
1551 fmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
1552 } else {
1553 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1554 strcpy(fmt->description, "YCbCr4:2:2 YC Planar");
1555 fmt->pixelformat = V4L2_PIX_FMT_YUV422P;
1556 }
1557 return 0;
1558}
1559
1560/**
1561 * vpif_try_fmt_vid_cap() - TRY_FMT handler
1562 * @file: file ptr
1563 * @priv: file handle
1564 * @fmt: ptr to v4l2 format structure
1565 */
1566static int vpif_try_fmt_vid_cap(struct file *file, void *priv,
1567 struct v4l2_format *fmt)
1568{
1569 struct vpif_fh *fh = priv;
1570 struct channel_obj *ch = fh->channel;
1571 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
1572
1573 return vpif_check_format(ch, pixfmt, 1);
1574}
1575
1576
1577/**
1578 * vpif_g_fmt_vid_cap() - Set INPUT handler
1579 * @file: file ptr
1580 * @priv: file handle
1581 * @fmt: ptr to v4l2 format structure
1582 */
1583static int vpif_g_fmt_vid_cap(struct file *file, void *priv,
1584 struct v4l2_format *fmt)
1585{
1586 struct vpif_fh *fh = priv;
1587 struct channel_obj *ch = fh->channel;
1588 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1589
1590 /* Check the validity of the buffer type */
1591 if (common->fmt.type != fmt->type)
1592 return -EINVAL;
1593
1594 /* Fill in the information about format */
1595 *fmt = common->fmt;
1596 return 0;
1597}
1598
1599/**
1600 * vpif_s_fmt_vid_cap() - Set FMT handler
1601 * @file: file ptr
1602 * @priv: file handle
1603 * @fmt: ptr to v4l2 format structure
1604 */
1605static int vpif_s_fmt_vid_cap(struct file *file, void *priv,
1606 struct v4l2_format *fmt)
1607{
1608 struct vpif_fh *fh = priv;
1609 struct channel_obj *ch = fh->channel;
1610 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1611 struct v4l2_pix_format *pixfmt;
1612 int ret = 0;
1613
1614 vpif_dbg(2, debug, "%s\n", __func__);
1615
1616 /* If streaming is started, return error */
1617 if (common->started) {
1618 vpif_dbg(1, debug, "Streaming is started\n");
1619 return -EBUSY;
1620 }
1621
1622 if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1623 (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1624 if (!fh->initialized) {
1625 vpif_dbg(1, debug, "Channel Busy\n");
1626 return -EBUSY;
1627 }
1628 }
1629
1630 ret = v4l2_prio_check(&ch->prio, fh->prio);
1631 if (0 != ret)
1632 return ret;
1633
1634 fh->initialized = 1;
1635
1636 pixfmt = &fmt->fmt.pix;
1637 /* Check for valid field format */
1638 ret = vpif_check_format(ch, pixfmt, 0);
1639
1640 if (ret)
1641 return ret;
1642 /* store the format in the channel object */
1643 common->fmt = *fmt;
1644 return 0;
1645}
1646
1647/**
1648 * vpif_querycap() - QUERYCAP handler
1649 * @file: file ptr
1650 * @priv: file handle
1651 * @cap: ptr to v4l2_capability structure
1652 */
1653static int vpif_querycap(struct file *file, void *priv,
1654 struct v4l2_capability *cap)
1655{
1656 struct vpif_capture_config *config = vpif_dev->platform_data;
1657
1658 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1659 strlcpy(cap->driver, "vpif capture", sizeof(cap->driver));
1660 strlcpy(cap->bus_info, "VPIF Platform", sizeof(cap->bus_info));
1661 strlcpy(cap->card, config->card_name, sizeof(cap->card));
1662
1663 return 0;
1664}
1665
1666/**
1667 * vpif_g_priority() - get priority handler
1668 * @file: file ptr
1669 * @priv: file handle
1670 * @prio: ptr to v4l2_priority structure
1671 */
1672static int vpif_g_priority(struct file *file, void *priv,
1673 enum v4l2_priority *prio)
1674{
1675 struct vpif_fh *fh = priv;
1676 struct channel_obj *ch = fh->channel;
1677
1678 *prio = v4l2_prio_max(&ch->prio);
1679
1680 return 0;
1681}
1682
1683/**
1684 * vpif_s_priority() - set priority handler
1685 * @file: file ptr
1686 * @priv: file handle
1687 * @prio: ptr to v4l2_priority structure
1688 */
1689static int vpif_s_priority(struct file *file, void *priv, enum v4l2_priority p)
1690{
1691 struct vpif_fh *fh = priv;
1692 struct channel_obj *ch = fh->channel;
1693
1694 return v4l2_prio_change(&ch->prio, &fh->prio, p);
1695}
1696
1697/**
1698 * vpif_cropcap() - cropcap handler
1699 * @file: file ptr
1700 * @priv: file handle
1701 * @crop: ptr to v4l2_cropcap structure
1702 */
1703static int vpif_cropcap(struct file *file, void *priv,
1704 struct v4l2_cropcap *crop)
1705{
1706 struct vpif_fh *fh = priv;
1707 struct channel_obj *ch = fh->channel;
1708 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1709
1710 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != crop->type)
1711 return -EINVAL;
1712
1713 crop->bounds.left = 0;
1714 crop->bounds.top = 0;
1715 crop->bounds.height = common->height;
1716 crop->bounds.width = common->width;
1717 crop->defrect = crop->bounds;
1718 return 0;
1719}
1720
1721/**
1722 * vpif_enum_dv_presets() - ENUM_DV_PRESETS handler
1723 * @file: file ptr
1724 * @priv: file handle
1725 * @preset: input preset
1726 */
1727static int vpif_enum_dv_presets(struct file *file, void *priv,
1728 struct v4l2_dv_enum_preset *preset)
1729{
1730 struct vpif_fh *fh = priv;
1731 struct channel_obj *ch = fh->channel;
1732
1733 return v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index],
1734 video, enum_dv_presets, preset);
1735}
1736
1737/**
1738 * vpif_query_dv_presets() - QUERY_DV_PRESET handler
1739 * @file: file ptr
1740 * @priv: file handle
1741 * @preset: input preset
1742 */
1743static int vpif_query_dv_preset(struct file *file, void *priv,
1744 struct v4l2_dv_preset *preset)
1745{
1746 struct vpif_fh *fh = priv;
1747 struct channel_obj *ch = fh->channel;
1748
1749 return v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index],
1750 video, query_dv_preset, preset);
1751}
1752/**
1753 * vpif_s_dv_presets() - S_DV_PRESETS handler
1754 * @file: file ptr
1755 * @priv: file handle
1756 * @preset: input preset
1757 */
1758static int vpif_s_dv_preset(struct file *file, void *priv,
1759 struct v4l2_dv_preset *preset)
1760{
1761 struct vpif_fh *fh = priv;
1762 struct channel_obj *ch = fh->channel;
1763 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1764 int ret = 0;
1765
1766 if (common->started) {
1767 vpif_dbg(1, debug, "streaming in progress\n");
1768 return -EBUSY;
1769 }
1770
1771 if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1772 (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1773 if (!fh->initialized) {
1774 vpif_dbg(1, debug, "Channel Busy\n");
1775 return -EBUSY;
1776 }
1777 }
1778
1779 ret = v4l2_prio_check(&ch->prio, fh->prio);
1780 if (ret)
1781 return ret;
1782
1783 fh->initialized = 1;
1784
1785 /* Call encoder subdevice function to set the standard */
1786 if (mutex_lock_interruptible(&common->lock))
1787 return -ERESTARTSYS;
1788
1789 ch->video.dv_preset = preset->preset;
1790 ch->video.stdid = V4L2_STD_UNKNOWN;
1791 memset(&ch->video.bt_timings, 0, sizeof(ch->video.bt_timings));
1792
1793 /* Get the information about the standard */
1794 if (vpif_update_std_info(ch)) {
1795 vpif_dbg(1, debug, "Error getting the standard info\n");
1796 ret = -EINVAL;
1797 } else {
1798 /* Configure the default format information */
1799 vpif_config_format(ch);
1800
1801 ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index],
1802 video, s_dv_preset, preset);
1803 }
1804
1805 mutex_unlock(&common->lock);
1806
1807 return ret;
1808}
1809/**
1810 * vpif_g_dv_presets() - G_DV_PRESETS handler
1811 * @file: file ptr
1812 * @priv: file handle
1813 * @preset: input preset
1814 */
1815static int vpif_g_dv_preset(struct file *file, void *priv,
1816 struct v4l2_dv_preset *preset)
1817{
1818 struct vpif_fh *fh = priv;
1819 struct channel_obj *ch = fh->channel;
1820
1821 preset->preset = ch->video.dv_preset;
1822
1823 return 0;
1824}
1825
1826/**
1827 * vpif_s_dv_timings() - S_DV_TIMINGS handler
1828 * @file: file ptr
1829 * @priv: file handle
1830 * @timings: digital video timings
1831 */
1832static int vpif_s_dv_timings(struct file *file, void *priv,
1833 struct v4l2_dv_timings *timings)
1834{
1835 struct vpif_fh *fh = priv;
1836 struct channel_obj *ch = fh->channel;
1837 struct vpif_params *vpifparams = &ch->vpifparams;
1838 struct vpif_channel_config_params *std_info = &vpifparams->std_info;
1839 struct video_obj *vid_ch = &ch->video;
1840 struct v4l2_bt_timings *bt = &vid_ch->bt_timings;
1841 int ret;
1842
1843 if (timings->type != V4L2_DV_BT_656_1120) {
1844 vpif_dbg(2, debug, "Timing type not defined\n");
1845 return -EINVAL;
1846 }
1847
1848 /* Configure subdevice timings, if any */
1849 ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index],
1850 video, s_dv_timings, timings);
1851 if (ret == -ENOIOCTLCMD) {
1852 vpif_dbg(2, debug, "Custom DV timings not supported by "
1853 "subdevice\n");
1854 return -EINVAL;
1855 }
1856 if (ret < 0) {
1857 vpif_dbg(2, debug, "Error setting custom DV timings\n");
1858 return ret;
1859 }
1860
1861 if (!(timings->bt.width && timings->bt.height &&
1862 (timings->bt.hbackporch ||
1863 timings->bt.hfrontporch ||
1864 timings->bt.hsync) &&
1865 timings->bt.vfrontporch &&
1866 (timings->bt.vbackporch ||
1867 timings->bt.vsync))) {
1868 vpif_dbg(2, debug, "Timings for width, height, "
1869 "horizontal back porch, horizontal sync, "
1870 "horizontal front porch, vertical back porch, "
1871 "vertical sync and vertical back porch "
1872 "must be defined\n");
1873 return -EINVAL;
1874 }
1875
1876 *bt = timings->bt;
1877
1878 /* Configure video port timings */
1879
1880 std_info->eav2sav = bt->hbackporch + bt->hfrontporch +
1881 bt->hsync - 8;
1882 std_info->sav2eav = bt->width;
1883
1884 std_info->l1 = 1;
1885 std_info->l3 = bt->vsync + bt->vbackporch + 1;
1886
1887 if (bt->interlaced) {
1888 if (bt->il_vbackporch || bt->il_vfrontporch || bt->il_vsync) {
1889 std_info->vsize = bt->height * 2 +
1890 bt->vfrontporch + bt->vsync + bt->vbackporch +
1891 bt->il_vfrontporch + bt->il_vsync +
1892 bt->il_vbackporch;
1893 std_info->l5 = std_info->vsize/2 -
1894 (bt->vfrontporch - 1);
1895 std_info->l7 = std_info->vsize/2 + 1;
1896 std_info->l9 = std_info->l7 + bt->il_vsync +
1897 bt->il_vbackporch + 1;
1898 std_info->l11 = std_info->vsize -
1899 (bt->il_vfrontporch - 1);
1900 } else {
1901 vpif_dbg(2, debug, "Required timing values for "
1902 "interlaced BT format missing\n");
1903 return -EINVAL;
1904 }
1905 } else {
1906 std_info->vsize = bt->height + bt->vfrontporch +
1907 bt->vsync + bt->vbackporch;
1908 std_info->l5 = std_info->vsize - (bt->vfrontporch - 1);
1909 }
1910 strncpy(std_info->name, "Custom timings BT656/1120", VPIF_MAX_NAME);
1911 std_info->width = bt->width;
1912 std_info->height = bt->height;
1913 std_info->frm_fmt = bt->interlaced ? 0 : 1;
1914 std_info->ycmux_mode = 0;
1915 std_info->capture_format = 0;
1916 std_info->vbi_supported = 0;
1917 std_info->hd_sd = 1;
1918 std_info->stdid = 0;
1919 std_info->dv_preset = V4L2_DV_INVALID;
1920
1921 vid_ch->stdid = 0;
1922 vid_ch->dv_preset = V4L2_DV_INVALID;
1923 return 0;
1924}
1925
1926/**
1927 * vpif_g_dv_timings() - G_DV_TIMINGS handler
1928 * @file: file ptr
1929 * @priv: file handle
1930 * @timings: digital video timings
1931 */
1932static int vpif_g_dv_timings(struct file *file, void *priv,
1933 struct v4l2_dv_timings *timings)
1934{
1935 struct vpif_fh *fh = priv;
1936 struct channel_obj *ch = fh->channel;
1937 struct video_obj *vid_ch = &ch->video;
1938 struct v4l2_bt_timings *bt = &vid_ch->bt_timings;
1939
1940 timings->bt = *bt;
1941
1942 return 0;
1943}
1944
1945/*
1946 * vpif_g_chip_ident() - Identify the chip
1947 * @file: file ptr
1948 * @priv: file handle
1949 * @chip: chip identity
1950 *
1951 * Returns zero or -EINVAL if read operations fails.
1952 */
1953static int vpif_g_chip_ident(struct file *file, void *priv,
1954 struct v4l2_dbg_chip_ident *chip)
1955{
1956 chip->ident = V4L2_IDENT_NONE;
1957 chip->revision = 0;
1958 if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
1959 chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR) {
1960 vpif_dbg(2, debug, "match_type is invalid.\n");
1961 return -EINVAL;
1962 }
1963
1964 return v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 0, core,
1965 g_chip_ident, chip);
1966}
1967
1968#ifdef CONFIG_VIDEO_ADV_DEBUG
1969/*
1970 * vpif_dbg_g_register() - Read register
1971 * @file: file ptr
1972 * @priv: file handle
1973 * @reg: register to be read
1974 *
1975 * Debugging only
1976 * Returns zero or -EINVAL if read operations fails.
1977 */
1978static int vpif_dbg_g_register(struct file *file, void *priv,
1979 struct v4l2_dbg_register *reg){
1980 struct vpif_fh *fh = priv;
1981 struct channel_obj *ch = fh->channel;
1982
1983 return v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], core,
1984 g_register, reg);
1985}
1986
1987/*
1988 * vpif_dbg_s_register() - Write to register
1989 * @file: file ptr
1990 * @priv: file handle
1991 * @reg: register to be modified
1992 *
1993 * Debugging only
1994 * Returns zero or -EINVAL if write operations fails.
1995 */
1996static int vpif_dbg_s_register(struct file *file, void *priv,
1997 struct v4l2_dbg_register *reg){
1998 struct vpif_fh *fh = priv;
1999 struct channel_obj *ch = fh->channel;
2000
2001 return v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], core,
2002 s_register, reg);
2003}
2004#endif
2005
2006/*
2007 * vpif_log_status() - Status information
2008 * @file: file ptr
2009 * @priv: file handle
2010 *
2011 * Returns zero.
2012 */
2013static int vpif_log_status(struct file *filep, void *priv)
2014{
2015 /* status for sub devices */
2016 v4l2_device_call_all(&vpif_obj.v4l2_dev, 0, core, log_status);
2017
2018 return 0;
2019}
2020
2021/* vpif capture ioctl operations */
2022static const struct v4l2_ioctl_ops vpif_ioctl_ops = {
2023 .vidioc_querycap = vpif_querycap,
2024 .vidioc_g_priority = vpif_g_priority,
2025 .vidioc_s_priority = vpif_s_priority,
2026 .vidioc_enum_fmt_vid_cap = vpif_enum_fmt_vid_cap,
2027 .vidioc_g_fmt_vid_cap = vpif_g_fmt_vid_cap,
2028 .vidioc_s_fmt_vid_cap = vpif_s_fmt_vid_cap,
2029 .vidioc_try_fmt_vid_cap = vpif_try_fmt_vid_cap,
2030 .vidioc_enum_input = vpif_enum_input,
2031 .vidioc_s_input = vpif_s_input,
2032 .vidioc_g_input = vpif_g_input,
2033 .vidioc_reqbufs = vpif_reqbufs,
2034 .vidioc_querybuf = vpif_querybuf,
2035 .vidioc_querystd = vpif_querystd,
2036 .vidioc_s_std = vpif_s_std,
2037 .vidioc_g_std = vpif_g_std,
2038 .vidioc_qbuf = vpif_qbuf,
2039 .vidioc_dqbuf = vpif_dqbuf,
2040 .vidioc_streamon = vpif_streamon,
2041 .vidioc_streamoff = vpif_streamoff,
2042 .vidioc_cropcap = vpif_cropcap,
2043 .vidioc_enum_dv_presets = vpif_enum_dv_presets,
2044 .vidioc_s_dv_preset = vpif_s_dv_preset,
2045 .vidioc_g_dv_preset = vpif_g_dv_preset,
2046 .vidioc_query_dv_preset = vpif_query_dv_preset,
2047 .vidioc_s_dv_timings = vpif_s_dv_timings,
2048 .vidioc_g_dv_timings = vpif_g_dv_timings,
2049 .vidioc_g_chip_ident = vpif_g_chip_ident,
2050#ifdef CONFIG_VIDEO_ADV_DEBUG
2051 .vidioc_g_register = vpif_dbg_g_register,
2052 .vidioc_s_register = vpif_dbg_s_register,
2053#endif
2054 .vidioc_log_status = vpif_log_status,
2055};
2056
2057/* vpif file operations */
2058static struct v4l2_file_operations vpif_fops = {
2059 .owner = THIS_MODULE,
2060 .open = vpif_open,
2061 .release = vpif_release,
2062 .unlocked_ioctl = video_ioctl2,
2063 .mmap = vpif_mmap,
2064 .poll = vpif_poll
2065};
2066
2067/* vpif video template */
2068static struct video_device vpif_video_template = {
2069 .name = "vpif",
2070 .fops = &vpif_fops,
2071 .minor = -1,
2072 .ioctl_ops = &vpif_ioctl_ops,
2073};
2074
2075/**
2076 * initialize_vpif() - Initialize vpif data structures
2077 *
2078 * Allocate memory for data structures and initialize them
2079 */
2080static int initialize_vpif(void)
2081{
2082 int err = 0, i, j;
2083 int free_channel_objects_index;
2084
2085 /* Default number of buffers should be 3 */
2086 if ((ch0_numbuffers > 0) &&
2087 (ch0_numbuffers < config_params.min_numbuffers))
2088 ch0_numbuffers = config_params.min_numbuffers;
2089 if ((ch1_numbuffers > 0) &&
2090 (ch1_numbuffers < config_params.min_numbuffers))
2091 ch1_numbuffers = config_params.min_numbuffers;
2092
2093 /* Set buffer size to min buffers size if it is invalid */
2094 if (ch0_bufsize < config_params.min_bufsize[VPIF_CHANNEL0_VIDEO])
2095 ch0_bufsize =
2096 config_params.min_bufsize[VPIF_CHANNEL0_VIDEO];
2097 if (ch1_bufsize < config_params.min_bufsize[VPIF_CHANNEL1_VIDEO])
2098 ch1_bufsize =
2099 config_params.min_bufsize[VPIF_CHANNEL1_VIDEO];
2100
2101 config_params.numbuffers[VPIF_CHANNEL0_VIDEO] = ch0_numbuffers;
2102 config_params.numbuffers[VPIF_CHANNEL1_VIDEO] = ch1_numbuffers;
2103 if (ch0_numbuffers) {
2104 config_params.channel_bufsize[VPIF_CHANNEL0_VIDEO]
2105 = ch0_bufsize;
2106 }
2107 if (ch1_numbuffers) {
2108 config_params.channel_bufsize[VPIF_CHANNEL1_VIDEO]
2109 = ch1_bufsize;
2110 }
2111
2112 /* Allocate memory for six channel objects */
2113 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2114 vpif_obj.dev[i] =
2115 kzalloc(sizeof(*vpif_obj.dev[i]), GFP_KERNEL);
2116 /* If memory allocation fails, return error */
2117 if (!vpif_obj.dev[i]) {
2118 free_channel_objects_index = i;
2119 err = -ENOMEM;
2120 goto vpif_init_free_channel_objects;
2121 }
2122 }
2123 return 0;
2124
2125vpif_init_free_channel_objects:
2126 for (j = 0; j < free_channel_objects_index; j++)
2127 kfree(vpif_obj.dev[j]);
2128 return err;
2129}
2130
2131/**
2132 * vpif_probe : This function probes the vpif capture driver
2133 * @pdev: platform device pointer
2134 *
2135 * This creates device entries by register itself to the V4L2 driver and
2136 * initializes fields of each channel objects
2137 */
2138static __init int vpif_probe(struct platform_device *pdev)
2139{
2140 struct vpif_subdev_info *subdevdata;
2141 struct vpif_capture_config *config;
2142 int i, j, k, m, q, err;
2143 struct i2c_adapter *i2c_adap;
2144 struct channel_obj *ch;
2145 struct common_obj *common;
2146 struct video_device *vfd;
2147 struct resource *res;
2148 int subdev_count;
2149 size_t size;
2150
2151 vpif_dev = &pdev->dev;
2152
2153 err = initialize_vpif();
2154 if (err) {
2155 v4l2_err(vpif_dev->driver, "Error initializing vpif\n");
2156 return err;
2157 }
2158
2159 err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
2160 if (err) {
2161 v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
2162 return err;
2163 }
2164
2165 k = 0;
2166 while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, k))) {
2167 for (i = res->start; i <= res->end; i++) {
2168 if (request_irq(i, vpif_channel_isr, IRQF_SHARED,
2169 "VPIF_Capture",
2170 (void *)(&vpif_obj.dev[k]->channel_id))) {
2171 err = -EBUSY;
2172 i--;
2173 goto vpif_int_err;
2174 }
2175 }
2176 k++;
2177 }
2178
2179 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2180 /* Get the pointer to the channel object */
2181 ch = vpif_obj.dev[i];
2182 /* Allocate memory for video device */
2183 vfd = video_device_alloc();
2184 if (NULL == vfd) {
2185 for (j = 0; j < i; j++) {
2186 ch = vpif_obj.dev[j];
2187 video_device_release(ch->video_dev);
2188 }
2189 err = -ENOMEM;
2190 goto vpif_dev_alloc_err;
2191 }
2192
2193 /* Initialize field of video device */
2194 *vfd = vpif_video_template;
2195 vfd->v4l2_dev = &vpif_obj.v4l2_dev;
2196 vfd->release = video_device_release;
2197 snprintf(vfd->name, sizeof(vfd->name),
2198 "VPIF_Capture_DRIVER_V%s",
2199 VPIF_CAPTURE_VERSION);
2200 /* Set video_dev to the video device */
2201 ch->video_dev = vfd;
2202 }
2203
2204 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2205 if (res) {
2206 size = resource_size(res);
2207 /* The resources are divided into two equal memory and when we
2208 * have HD output we can add them together
2209 */
2210 for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) {
2211 ch = vpif_obj.dev[j];
2212 ch->channel_id = j;
2213 /* only enabled if second resource exists */
2214 config_params.video_limit[ch->channel_id] = 0;
2215 if (size)
2216 config_params.video_limit[ch->channel_id] =
2217 size/2;
2218 }
2219 }
2220
2221 for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) {
2222 ch = vpif_obj.dev[j];
2223 ch->channel_id = j;
2224 common = &(ch->common[VPIF_VIDEO_INDEX]);
2225 spin_lock_init(&common->irqlock);
2226 mutex_init(&common->lock);
2227 ch->video_dev->lock = &common->lock;
2228 /* Initialize prio member of channel object */
2229 v4l2_prio_init(&ch->prio);
2230 err = video_register_device(ch->video_dev,
2231 VFL_TYPE_GRABBER, (j ? 1 : 0));
2232 if (err)
2233 goto probe_out;
2234
2235 video_set_drvdata(ch->video_dev, ch);
2236
2237 }
2238
2239 i2c_adap = i2c_get_adapter(1);
2240 config = pdev->dev.platform_data;
2241
2242 subdev_count = config->subdev_count;
2243 vpif_obj.sd = kzalloc(sizeof(struct v4l2_subdev *) * subdev_count,
2244 GFP_KERNEL);
2245 if (vpif_obj.sd == NULL) {
2246 vpif_err("unable to allocate memory for subdevice pointers\n");
2247 err = -ENOMEM;
2248 goto probe_out;
2249 }
2250
2251 for (i = 0; i < subdev_count; i++) {
2252 subdevdata = &config->subdev_info[i];
2253 vpif_obj.sd[i] =
2254 v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev,
2255 i2c_adap,
2256 &subdevdata->board_info,
2257 NULL);
2258
2259 if (!vpif_obj.sd[i]) {
2260 vpif_err("Error registering v4l2 subdevice\n");
2261 goto probe_subdev_out;
2262 }
2263 v4l2_info(&vpif_obj.v4l2_dev, "registered sub device %s\n",
2264 subdevdata->name);
2265
2266 if (vpif_obj.sd[i])
2267 vpif_obj.sd[i]->grp_id = 1 << i;
2268 }
2269
2270 v4l2_info(&vpif_obj.v4l2_dev, "VPIF capture driver initialized\n");
2271 return 0;
2272
2273probe_subdev_out:
2274 /* free sub devices memory */
2275 kfree(vpif_obj.sd);
2276
2277 j = VPIF_CAPTURE_MAX_DEVICES;
2278probe_out:
2279 for (k = 0; k < j; k++) {
2280 /* Get the pointer to the channel object */
2281 ch = vpif_obj.dev[k];
2282 /* Unregister video device */
2283 video_unregister_device(ch->video_dev);
2284 }
2285
2286vpif_dev_alloc_err:
2287 k = VPIF_CAPTURE_MAX_DEVICES-1;
2288 res = platform_get_resource(pdev, IORESOURCE_IRQ, k);
2289 i = res->end;
2290
2291vpif_int_err:
2292 for (q = k; q >= 0; q--) {
2293 for (m = i; m >= (int)res->start; m--)
2294 free_irq(m, (void *)(&vpif_obj.dev[q]->channel_id));
2295
2296 res = platform_get_resource(pdev, IORESOURCE_IRQ, q-1);
2297 if (res)
2298 i = res->end;
2299 }
2300 v4l2_device_unregister(&vpif_obj.v4l2_dev);
2301 return err;
2302}
2303
2304/**
2305 * vpif_remove() - driver remove handler
2306 * @device: ptr to platform device structure
2307 *
2308 * The vidoe device is unregistered
2309 */
2310static int vpif_remove(struct platform_device *device)
2311{
2312 int i;
2313 struct channel_obj *ch;
2314
2315 v4l2_device_unregister(&vpif_obj.v4l2_dev);
2316
2317 /* un-register device */
2318 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2319 /* Get the pointer to the channel object */
2320 ch = vpif_obj.dev[i];
2321 /* Unregister video device */
2322 video_unregister_device(ch->video_dev);
2323 }
2324 return 0;
2325}
2326
2327#ifdef CONFIG_PM
2328/**
2329 * vpif_suspend: vpif device suspend
2330 */
2331static int vpif_suspend(struct device *dev)
2332{
2333
2334 struct common_obj *common;
2335 struct channel_obj *ch;
2336 int i;
2337
2338 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2339 /* Get the pointer to the channel object */
2340 ch = vpif_obj.dev[i];
2341 common = &ch->common[VPIF_VIDEO_INDEX];
2342 mutex_lock(&common->lock);
2343 if (ch->usrs && common->io_usrs) {
2344 /* Disable channel */
2345 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) {
2346 enable_channel0(0);
2347 channel0_intr_enable(0);
2348 }
2349 if (ch->channel_id == VPIF_CHANNEL1_VIDEO ||
2350 common->started == 2) {
2351 enable_channel1(0);
2352 channel1_intr_enable(0);
2353 }
2354 }
2355 mutex_unlock(&common->lock);
2356 }
2357
2358 return 0;
2359}
2360
2361/*
2362 * vpif_resume: vpif device suspend
2363 */
2364static int vpif_resume(struct device *dev)
2365{
2366 struct common_obj *common;
2367 struct channel_obj *ch;
2368 int i;
2369
2370 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2371 /* Get the pointer to the channel object */
2372 ch = vpif_obj.dev[i];
2373 common = &ch->common[VPIF_VIDEO_INDEX];
2374 mutex_lock(&common->lock);
2375 if (ch->usrs && common->io_usrs) {
2376 /* Disable channel */
2377 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) {
2378 enable_channel0(1);
2379 channel0_intr_enable(1);
2380 }
2381 if (ch->channel_id == VPIF_CHANNEL1_VIDEO ||
2382 common->started == 2) {
2383 enable_channel1(1);
2384 channel1_intr_enable(1);
2385 }
2386 }
2387 mutex_unlock(&common->lock);
2388 }
2389
2390 return 0;
2391}
2392
2393static const struct dev_pm_ops vpif_dev_pm_ops = {
2394 .suspend = vpif_suspend,
2395 .resume = vpif_resume,
2396};
2397
2398#define vpif_pm_ops (&vpif_dev_pm_ops)
2399#else
2400#define vpif_pm_ops NULL
2401#endif
2402
2403static __refdata struct platform_driver vpif_driver = {
2404 .driver = {
2405 .name = "vpif_capture",
2406 .owner = THIS_MODULE,
2407 .pm = vpif_pm_ops,
2408 },
2409 .probe = vpif_probe,
2410 .remove = vpif_remove,
2411};
2412
2413/**
2414 * vpif_init: initialize the vpif driver
2415 *
2416 * This function registers device and driver to the kernel, requests irq
2417 * handler and allocates memory
2418 * for channel objects
2419 */
2420static __init int vpif_init(void)
2421{
2422 return platform_driver_register(&vpif_driver);
2423}
2424
2425/**
2426 * vpif_cleanup : This function clean up the vpif capture resources
2427 *
2428 * This will un-registers device and driver to the kernel, frees
2429 * requested irq handler and de-allocates memory allocated for channel
2430 * objects.
2431 */
2432static void vpif_cleanup(void)
2433{
2434 struct platform_device *pdev;
2435 struct resource *res;
2436 int irq_num;
2437 int i = 0;
2438
2439 pdev = container_of(vpif_dev, struct platform_device, dev);
2440 while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, i))) {
2441 for (irq_num = res->start; irq_num <= res->end; irq_num++)
2442 free_irq(irq_num,
2443 (void *)(&vpif_obj.dev[i]->channel_id));
2444 i++;
2445 }
2446
2447 platform_driver_unregister(&vpif_driver);
2448
2449 kfree(vpif_obj.sd);
2450 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++)
2451 kfree(vpif_obj.dev[i]);
2452}
2453
2454/* Function for module initialization and cleanup */
2455module_init(vpif_init);
2456module_exit(vpif_cleanup);
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-22 03:47:28 -0400