2 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation version 2.
8 * This program is distributed WITHOUT ANY WARRANTY of any
9 * kind, whether express or implied; without even the implied warranty
10 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/module.h>
16 #include <linux/errno.h>
17 #include <linux/interrupt.h>
18 #include <linux/string.h>
19 #include <linux/wait.h>
20 #include <linux/time.h>
21 #include <linux/platform_device.h>
22 #include <linux/irq.h>
24 #include <linux/mutex.h>
25 #include <linux/videodev2.h>
26 #include <linux/slab.h>
28 #include <asm/pgtable.h>
29 #include <mach/cputype.h>
31 #include <media/v4l2-dev.h>
32 #include <media/v4l2-common.h>
33 #include <media/v4l2-ioctl.h>
34 #include <media/v4l2-device.h>
35 #include <media/davinci/vpbe_display.h>
36 #include <media/davinci/vpbe_types.h>
37 #include <media/davinci/vpbe.h>
38 #include <media/davinci/vpbe_venc.h>
39 #include <media/davinci/vpbe_osd.h>
40 #include "vpbe_venc_regs.h"
42 #define VPBE_DISPLAY_DRIVER "vpbe-v4l2"
46 #define VPBE_DEFAULT_NUM_BUFS 3
48 module_param(debug
, int, 0644);
50 static int vpbe_set_osd_display_params(struct vpbe_display
*disp_dev
,
51 struct vpbe_layer
*layer
);
53 static int venc_is_second_field(struct vpbe_display
*disp_dev
)
55 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
59 ret
= v4l2_subdev_call(vpbe_dev
->venc
,
65 v4l2_err(&vpbe_dev
->v4l2_dev
,
66 "Error in getting Field ID 0\n");
71 static void vpbe_isr_even_field(struct vpbe_display
*disp_obj
,
72 struct vpbe_layer
*layer
)
74 if (layer
->cur_frm
== layer
->next_frm
)
77 layer
->cur_frm
->vb
.vb2_buf
.timestamp
= ktime_get_ns();
78 vb2_buffer_done(&layer
->cur_frm
->vb
.vb2_buf
, VB2_BUF_STATE_DONE
);
79 /* Make cur_frm pointing to next_frm */
80 layer
->cur_frm
= layer
->next_frm
;
83 static void vpbe_isr_odd_field(struct vpbe_display
*disp_obj
,
84 struct vpbe_layer
*layer
)
86 struct osd_state
*osd_device
= disp_obj
->osd_device
;
89 spin_lock(&disp_obj
->dma_queue_lock
);
90 if (list_empty(&layer
->dma_queue
) ||
91 (layer
->cur_frm
!= layer
->next_frm
)) {
92 spin_unlock(&disp_obj
->dma_queue_lock
);
96 * one field is displayed configure
97 * the next frame if it is available
98 * otherwise hold on current frame
99 * Get next from the buffer queue
101 layer
->next_frm
= list_entry(layer
->dma_queue
.next
,
102 struct vpbe_disp_buffer
, list
);
103 /* Remove that from the buffer queue */
104 list_del(&layer
->next_frm
->list
);
105 spin_unlock(&disp_obj
->dma_queue_lock
);
106 /* Mark state of the frame to active */
107 layer
->next_frm
->vb
.vb2_buf
.state
= VB2_BUF_STATE_ACTIVE
;
108 addr
= vb2_dma_contig_plane_dma_addr(&layer
->next_frm
->vb
.vb2_buf
, 0);
109 osd_device
->ops
.start_layer(osd_device
,
110 layer
->layer_info
.id
,
112 disp_obj
->cbcr_ofst
);
115 /* interrupt service routine */
116 static irqreturn_t
venc_isr(int irq
, void *arg
)
118 struct vpbe_display
*disp_dev
= (struct vpbe_display
*)arg
;
119 struct vpbe_layer
*layer
;
120 static unsigned last_event
;
125 if ((NULL
== arg
) || (NULL
== disp_dev
->dev
[0]))
128 if (venc_is_second_field(disp_dev
))
129 event
|= VENC_SECOND_FIELD
;
131 event
|= VENC_FIRST_FIELD
;
133 if (event
== (last_event
& ~VENC_END_OF_FRAME
)) {
135 * If the display is non-interlaced, then we need to flag the
136 * end-of-frame event at every interrupt regardless of the
137 * value of the FIDST bit. We can conclude that the display is
138 * non-interlaced if the value of the FIDST bit is unchanged
139 * from the previous interrupt.
141 event
|= VENC_END_OF_FRAME
;
142 } else if (event
== VENC_SECOND_FIELD
) {
143 /* end-of-frame for interlaced display */
144 event
|= VENC_END_OF_FRAME
;
148 for (i
= 0; i
< VPBE_DISPLAY_MAX_DEVICES
; i
++) {
149 layer
= disp_dev
->dev
[i
];
151 if (!vb2_start_streaming_called(&layer
->buffer_queue
))
154 if (layer
->layer_first_int
) {
155 layer
->layer_first_int
= 0;
158 /* Check the field format */
159 if ((V4L2_FIELD_NONE
== layer
->pix_fmt
.field
) &&
160 (event
& VENC_END_OF_FRAME
)) {
161 /* Progressive mode */
163 vpbe_isr_even_field(disp_dev
, layer
);
164 vpbe_isr_odd_field(disp_dev
, layer
);
166 /* Interlaced mode */
168 layer
->field_id
^= 1;
169 if (event
& VENC_FIRST_FIELD
)
175 * If field id does not match with store
178 if (fid
!= layer
->field_id
) {
179 /* Make them in sync */
180 layer
->field_id
= fid
;
184 * device field id and local field id are
185 * in sync. If this is even field
188 vpbe_isr_even_field(disp_dev
, layer
);
190 vpbe_isr_odd_field(disp_dev
, layer
);
198 * vpbe_buffer_prepare()
199 * This is the callback function called from vb2_qbuf() function
200 * the buffer is prepared and user space virtual address is converted into
203 static int vpbe_buffer_prepare(struct vb2_buffer
*vb
)
205 struct vb2_queue
*q
= vb
->vb2_queue
;
206 struct vpbe_layer
*layer
= vb2_get_drv_priv(q
);
207 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
210 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
211 "vpbe_buffer_prepare\n");
213 vb2_set_plane_payload(vb
, 0, layer
->pix_fmt
.sizeimage
);
214 if (vb2_get_plane_payload(vb
, 0) > vb2_plane_size(vb
, 0))
217 addr
= vb2_dma_contig_plane_dma_addr(vb
, 0);
218 if (!IS_ALIGNED(addr
, 8)) {
219 v4l2_err(&vpbe_dev
->v4l2_dev
,
220 "buffer_prepare:offset is not aligned to 32 bytes\n");
227 * vpbe_buffer_setup()
228 * This function allocates memory for the buffers
231 vpbe_buffer_queue_setup(struct vb2_queue
*vq
,
232 unsigned int *nbuffers
, unsigned int *nplanes
,
233 unsigned int sizes
[], struct device
*alloc_devs
[])
236 /* Get the file handle object and layer object */
237 struct vpbe_layer
*layer
= vb2_get_drv_priv(vq
);
238 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
240 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "vpbe_buffer_setup\n");
242 /* Store number of buffers allocated in numbuffer member */
243 if (vq
->num_buffers
+ *nbuffers
< VPBE_DEFAULT_NUM_BUFS
)
244 *nbuffers
= VPBE_DEFAULT_NUM_BUFS
- vq
->num_buffers
;
247 return sizes
[0] < layer
->pix_fmt
.sizeimage
? -EINVAL
: 0;
250 sizes
[0] = layer
->pix_fmt
.sizeimage
;
256 * vpbe_buffer_queue()
257 * This function adds the buffer to DMA queue
259 static void vpbe_buffer_queue(struct vb2_buffer
*vb
)
261 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
262 /* Get the file handle object and layer object */
263 struct vpbe_disp_buffer
*buf
= container_of(vbuf
,
264 struct vpbe_disp_buffer
, vb
);
265 struct vpbe_layer
*layer
= vb2_get_drv_priv(vb
->vb2_queue
);
266 struct vpbe_display
*disp
= layer
->disp_dev
;
267 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
270 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
271 "vpbe_buffer_queue\n");
273 /* add the buffer to the DMA queue */
274 spin_lock_irqsave(&disp
->dma_queue_lock
, flags
);
275 list_add_tail(&buf
->list
, &layer
->dma_queue
);
276 spin_unlock_irqrestore(&disp
->dma_queue_lock
, flags
);
279 static int vpbe_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
281 struct vpbe_layer
*layer
= vb2_get_drv_priv(vq
);
282 struct osd_state
*osd_device
= layer
->disp_dev
->osd_device
;
285 osd_device
->ops
.disable_layer(osd_device
, layer
->layer_info
.id
);
287 /* Get the next frame from the buffer queue */
288 layer
->next_frm
= layer
->cur_frm
= list_entry(layer
->dma_queue
.next
,
289 struct vpbe_disp_buffer
, list
);
290 /* Remove buffer from the buffer queue */
291 list_del(&layer
->cur_frm
->list
);
292 /* Mark state of the current frame to active */
293 layer
->cur_frm
->vb
.vb2_buf
.state
= VB2_BUF_STATE_ACTIVE
;
294 /* Initialize field_id and started member */
297 /* Set parameters in OSD and VENC */
298 ret
= vpbe_set_osd_display_params(layer
->disp_dev
, layer
);
300 struct vpbe_disp_buffer
*buf
, *tmp
;
302 vb2_buffer_done(&layer
->cur_frm
->vb
.vb2_buf
,
303 VB2_BUF_STATE_QUEUED
);
304 list_for_each_entry_safe(buf
, tmp
, &layer
->dma_queue
, list
) {
305 list_del(&buf
->list
);
306 vb2_buffer_done(&buf
->vb
.vb2_buf
,
307 VB2_BUF_STATE_QUEUED
);
314 * if request format is yuv420 semiplanar, need to
315 * enable both video windows
317 layer
->layer_first_int
= 1;
322 static void vpbe_stop_streaming(struct vb2_queue
*vq
)
324 struct vpbe_layer
*layer
= vb2_get_drv_priv(vq
);
325 struct osd_state
*osd_device
= layer
->disp_dev
->osd_device
;
326 struct vpbe_display
*disp
= layer
->disp_dev
;
329 if (!vb2_is_streaming(vq
))
332 osd_device
->ops
.disable_layer(osd_device
, layer
->layer_info
.id
);
334 /* release all active buffers */
335 spin_lock_irqsave(&disp
->dma_queue_lock
, flags
);
336 if (layer
->cur_frm
== layer
->next_frm
) {
337 vb2_buffer_done(&layer
->cur_frm
->vb
.vb2_buf
,
338 VB2_BUF_STATE_ERROR
);
340 if (layer
->cur_frm
!= NULL
)
341 vb2_buffer_done(&layer
->cur_frm
->vb
.vb2_buf
,
342 VB2_BUF_STATE_ERROR
);
343 if (layer
->next_frm
!= NULL
)
344 vb2_buffer_done(&layer
->next_frm
->vb
.vb2_buf
,
345 VB2_BUF_STATE_ERROR
);
348 while (!list_empty(&layer
->dma_queue
)) {
349 layer
->next_frm
= list_entry(layer
->dma_queue
.next
,
350 struct vpbe_disp_buffer
, list
);
351 list_del(&layer
->next_frm
->list
);
352 vb2_buffer_done(&layer
->next_frm
->vb
.vb2_buf
,
353 VB2_BUF_STATE_ERROR
);
355 spin_unlock_irqrestore(&disp
->dma_queue_lock
, flags
);
358 static struct vb2_ops video_qops
= {
359 .queue_setup
= vpbe_buffer_queue_setup
,
360 .wait_prepare
= vb2_ops_wait_prepare
,
361 .wait_finish
= vb2_ops_wait_finish
,
362 .buf_prepare
= vpbe_buffer_prepare
,
363 .start_streaming
= vpbe_start_streaming
,
364 .stop_streaming
= vpbe_stop_streaming
,
365 .buf_queue
= vpbe_buffer_queue
,
370 _vpbe_display_get_other_win_layer(struct vpbe_display
*disp_dev
,
371 struct vpbe_layer
*layer
)
373 enum vpbe_display_device_id thiswin
, otherwin
;
374 thiswin
= layer
->device_id
;
376 otherwin
= (thiswin
== VPBE_DISPLAY_DEVICE_0
) ?
377 VPBE_DISPLAY_DEVICE_1
: VPBE_DISPLAY_DEVICE_0
;
378 return disp_dev
->dev
[otherwin
];
381 static int vpbe_set_osd_display_params(struct vpbe_display
*disp_dev
,
382 struct vpbe_layer
*layer
)
384 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
385 struct osd_state
*osd_device
= disp_dev
->osd_device
;
386 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
390 addr
= vb2_dma_contig_plane_dma_addr(&layer
->cur_frm
->vb
.vb2_buf
, 0);
391 /* Set address in the display registers */
392 osd_device
->ops
.start_layer(osd_device
,
393 layer
->layer_info
.id
,
395 disp_dev
->cbcr_ofst
);
397 ret
= osd_device
->ops
.enable_layer(osd_device
,
398 layer
->layer_info
.id
, 0);
400 v4l2_err(&vpbe_dev
->v4l2_dev
,
401 "Error in enabling osd window layer 0\n");
405 /* Enable the window */
406 layer
->layer_info
.enable
= 1;
407 if (cfg
->pixfmt
== PIXFMT_NV12
) {
408 struct vpbe_layer
*otherlayer
=
409 _vpbe_display_get_other_win_layer(disp_dev
, layer
);
411 ret
= osd_device
->ops
.enable_layer(osd_device
,
412 otherlayer
->layer_info
.id
, 1);
414 v4l2_err(&vpbe_dev
->v4l2_dev
,
415 "Error in enabling osd window layer 1\n");
418 otherlayer
->layer_info
.enable
= 1;
424 vpbe_disp_calculate_scale_factor(struct vpbe_display
*disp_dev
,
425 struct vpbe_layer
*layer
,
426 int expected_xsize
, int expected_ysize
)
428 struct display_layer_info
*layer_info
= &layer
->layer_info
;
429 struct v4l2_pix_format
*pixfmt
= &layer
->pix_fmt
;
430 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
431 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
432 int calculated_xsize
;
438 v4l2_std_id standard_id
= vpbe_dev
->current_timings
.std_id
;
441 * Application initially set the image format. Current display
442 * size is obtained from the vpbe display controller. expected_xsize
443 * and expected_ysize are set through S_CROP ioctl. Based on this,
444 * driver will calculate the scale factors for vertical and
445 * horizontal direction so that the image is displayed scaled
446 * and expanded. Application uses expansion to display the image
447 * in a square pixel. Otherwise it is displayed using displays
448 * pixel aspect ratio.It is expected that application chooses
449 * the crop coordinates for cropped or scaled display. if crop
450 * size is less than the image size, it is displayed cropped or
451 * it is displayed scaled and/or expanded.
453 * to begin with, set the crop window same as expected. Later we
454 * will override with scaled window size
457 cfg
->xsize
= pixfmt
->width
;
458 cfg
->ysize
= pixfmt
->height
;
459 layer_info
->h_zoom
= ZOOM_X1
; /* no horizontal zoom */
460 layer_info
->v_zoom
= ZOOM_X1
; /* no horizontal zoom */
461 layer_info
->h_exp
= H_EXP_OFF
; /* no horizontal zoom */
462 layer_info
->v_exp
= V_EXP_OFF
; /* no horizontal zoom */
464 if (pixfmt
->width
< expected_xsize
) {
465 h_scale
= vpbe_dev
->current_timings
.xres
/ pixfmt
->width
;
468 else if (h_scale
>= 4)
472 cfg
->xsize
*= h_scale
;
473 if (cfg
->xsize
< expected_xsize
) {
474 if ((standard_id
& V4L2_STD_525_60
) ||
475 (standard_id
& V4L2_STD_625_50
)) {
476 calculated_xsize
= (cfg
->xsize
*
477 VPBE_DISPLAY_H_EXP_RATIO_N
) /
478 VPBE_DISPLAY_H_EXP_RATIO_D
;
479 if (calculated_xsize
<= expected_xsize
) {
481 cfg
->xsize
= calculated_xsize
;
486 layer_info
->h_zoom
= ZOOM_X2
;
487 else if (h_scale
== 4)
488 layer_info
->h_zoom
= ZOOM_X4
;
490 layer_info
->h_exp
= H_EXP_9_OVER_8
;
492 /* no scaling, only cropping. Set display area to crop area */
493 cfg
->xsize
= expected_xsize
;
496 if (pixfmt
->height
< expected_ysize
) {
497 v_scale
= expected_ysize
/ pixfmt
->height
;
500 else if (v_scale
>= 4)
504 cfg
->ysize
*= v_scale
;
505 if (cfg
->ysize
< expected_ysize
) {
506 if ((standard_id
& V4L2_STD_625_50
)) {
507 calculated_xsize
= (cfg
->ysize
*
508 VPBE_DISPLAY_V_EXP_RATIO_N
) /
509 VPBE_DISPLAY_V_EXP_RATIO_D
;
510 if (calculated_xsize
<= expected_ysize
) {
512 cfg
->ysize
= calculated_xsize
;
517 layer_info
->v_zoom
= ZOOM_X2
;
518 else if (v_scale
== 4)
519 layer_info
->v_zoom
= ZOOM_X4
;
521 layer_info
->h_exp
= V_EXP_6_OVER_5
;
523 /* no scaling, only cropping. Set display area to crop area */
524 cfg
->ysize
= expected_ysize
;
526 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
527 "crop display xsize = %d, ysize = %d\n",
528 cfg
->xsize
, cfg
->ysize
);
531 static void vpbe_disp_adj_position(struct vpbe_display
*disp_dev
,
532 struct vpbe_layer
*layer
,
535 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
536 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
538 cfg
->xpos
= min((unsigned int)left
,
539 vpbe_dev
->current_timings
.xres
- cfg
->xsize
);
540 cfg
->ypos
= min((unsigned int)top
,
541 vpbe_dev
->current_timings
.yres
- cfg
->ysize
);
543 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
544 "new xpos = %d, ypos = %d\n",
545 cfg
->xpos
, cfg
->ypos
);
548 static void vpbe_disp_check_window_params(struct vpbe_display
*disp_dev
,
551 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
553 if ((c
->width
== 0) ||
554 ((c
->width
+ c
->left
) > vpbe_dev
->current_timings
.xres
))
555 c
->width
= vpbe_dev
->current_timings
.xres
- c
->left
;
557 if ((c
->height
== 0) || ((c
->height
+ c
->top
) >
558 vpbe_dev
->current_timings
.yres
))
559 c
->height
= vpbe_dev
->current_timings
.yres
- c
->top
;
561 /* window height must be even for interlaced display */
562 if (vpbe_dev
->current_timings
.interlaced
)
563 c
->height
&= (~0x01);
569 * If user application provides width and height, and have bytesperline set
570 * to zero, driver calculates bytesperline and sizeimage based on hardware
573 static int vpbe_try_format(struct vpbe_display
*disp_dev
,
574 struct v4l2_pix_format
*pixfmt
, int check
)
576 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
583 if ((pixfmt
->pixelformat
!= V4L2_PIX_FMT_UYVY
) &&
584 (pixfmt
->pixelformat
!= V4L2_PIX_FMT_NV12
))
585 /* choose default as V4L2_PIX_FMT_UYVY */
586 pixfmt
->pixelformat
= V4L2_PIX_FMT_UYVY
;
588 /* Check the field format */
589 if ((pixfmt
->field
!= V4L2_FIELD_INTERLACED
) &&
590 (pixfmt
->field
!= V4L2_FIELD_NONE
)) {
591 if (vpbe_dev
->current_timings
.interlaced
)
592 pixfmt
->field
= V4L2_FIELD_INTERLACED
;
594 pixfmt
->field
= V4L2_FIELD_NONE
;
597 if (pixfmt
->field
== V4L2_FIELD_INTERLACED
)
600 if (pixfmt
->pixelformat
== V4L2_PIX_FMT_NV12
)
605 max_width
= vpbe_dev
->current_timings
.xres
;
606 max_height
= vpbe_dev
->current_timings
.yres
;
610 if (!pixfmt
->width
|| (pixfmt
->width
< min_width
) ||
611 (pixfmt
->width
> max_width
)) {
612 pixfmt
->width
= vpbe_dev
->current_timings
.xres
;
615 if (!pixfmt
->height
|| (pixfmt
->height
< min_height
) ||
616 (pixfmt
->height
> max_height
)) {
617 pixfmt
->height
= vpbe_dev
->current_timings
.yres
;
620 if (pixfmt
->bytesperline
< (pixfmt
->width
* bpp
))
621 pixfmt
->bytesperline
= pixfmt
->width
* bpp
;
623 /* Make the bytesperline 32 byte aligned */
624 pixfmt
->bytesperline
= ((pixfmt
->width
* bpp
+ 31) & ~31);
626 if (pixfmt
->pixelformat
== V4L2_PIX_FMT_NV12
)
627 pixfmt
->sizeimage
= pixfmt
->bytesperline
* pixfmt
->height
+
628 (pixfmt
->bytesperline
* pixfmt
->height
>> 1);
630 pixfmt
->sizeimage
= pixfmt
->bytesperline
* pixfmt
->height
;
635 static int vpbe_display_querycap(struct file
*file
, void *priv
,
636 struct v4l2_capability
*cap
)
638 struct vpbe_layer
*layer
= video_drvdata(file
);
639 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
641 cap
->device_caps
= V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_STREAMING
;
642 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
643 snprintf(cap
->driver
, sizeof(cap
->driver
), "%s",
644 dev_name(vpbe_dev
->pdev
));
645 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "platform:%s",
646 dev_name(vpbe_dev
->pdev
));
647 strlcpy(cap
->card
, vpbe_dev
->cfg
->module_name
, sizeof(cap
->card
));
652 static int vpbe_display_s_crop(struct file
*file
, void *priv
,
653 const struct v4l2_crop
*crop
)
655 struct vpbe_layer
*layer
= video_drvdata(file
);
656 struct vpbe_display
*disp_dev
= layer
->disp_dev
;
657 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
658 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
659 struct osd_state
*osd_device
= disp_dev
->osd_device
;
660 struct v4l2_rect rect
= crop
->c
;
663 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
664 "VIDIOC_S_CROP, layer id = %d\n", layer
->device_id
);
666 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
667 v4l2_err(&vpbe_dev
->v4l2_dev
, "Invalid buf type\n");
676 vpbe_disp_check_window_params(disp_dev
, &rect
);
678 osd_device
->ops
.get_layer_config(osd_device
,
679 layer
->layer_info
.id
, cfg
);
681 vpbe_disp_calculate_scale_factor(disp_dev
, layer
,
684 vpbe_disp_adj_position(disp_dev
, layer
, rect
.top
,
686 ret
= osd_device
->ops
.set_layer_config(osd_device
,
687 layer
->layer_info
.id
, cfg
);
689 v4l2_err(&vpbe_dev
->v4l2_dev
,
690 "Error in set layer config:\n");
694 /* apply zooming and h or v expansion */
695 osd_device
->ops
.set_zoom(osd_device
,
696 layer
->layer_info
.id
,
697 layer
->layer_info
.h_zoom
,
698 layer
->layer_info
.v_zoom
);
699 ret
= osd_device
->ops
.set_vid_expansion(osd_device
,
700 layer
->layer_info
.h_exp
,
701 layer
->layer_info
.v_exp
);
703 v4l2_err(&vpbe_dev
->v4l2_dev
,
704 "Error in set vid expansion:\n");
708 if ((layer
->layer_info
.h_zoom
!= ZOOM_X1
) ||
709 (layer
->layer_info
.v_zoom
!= ZOOM_X1
) ||
710 (layer
->layer_info
.h_exp
!= H_EXP_OFF
) ||
711 (layer
->layer_info
.v_exp
!= V_EXP_OFF
))
712 /* Enable expansion filter */
713 osd_device
->ops
.set_interpolation_filter(osd_device
, 1);
715 osd_device
->ops
.set_interpolation_filter(osd_device
, 0);
720 static int vpbe_display_g_crop(struct file
*file
, void *priv
,
721 struct v4l2_crop
*crop
)
723 struct vpbe_layer
*layer
= video_drvdata(file
);
724 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
725 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
726 struct osd_state
*osd_device
= layer
->disp_dev
->osd_device
;
727 struct v4l2_rect
*rect
= &crop
->c
;
729 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
730 "VIDIOC_G_CROP, layer id = %d\n",
733 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
734 v4l2_err(&vpbe_dev
->v4l2_dev
, "Invalid buf type\n");
737 osd_device
->ops
.get_layer_config(osd_device
,
738 layer
->layer_info
.id
, cfg
);
739 rect
->top
= cfg
->ypos
;
740 rect
->left
= cfg
->xpos
;
741 rect
->width
= cfg
->xsize
;
742 rect
->height
= cfg
->ysize
;
747 static int vpbe_display_cropcap(struct file
*file
, void *priv
,
748 struct v4l2_cropcap
*cropcap
)
750 struct vpbe_layer
*layer
= video_drvdata(file
);
751 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
753 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_CROPCAP ioctl\n");
755 cropcap
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
756 cropcap
->bounds
.left
= 0;
757 cropcap
->bounds
.top
= 0;
758 cropcap
->bounds
.width
= vpbe_dev
->current_timings
.xres
;
759 cropcap
->bounds
.height
= vpbe_dev
->current_timings
.yres
;
760 cropcap
->pixelaspect
= vpbe_dev
->current_timings
.aspect
;
761 cropcap
->defrect
= cropcap
->bounds
;
765 static int vpbe_display_g_fmt(struct file
*file
, void *priv
,
766 struct v4l2_format
*fmt
)
768 struct vpbe_layer
*layer
= video_drvdata(file
);
769 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
771 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
772 "VIDIOC_G_FMT, layer id = %d\n",
775 /* If buffer type is video output */
776 if (V4L2_BUF_TYPE_VIDEO_OUTPUT
!= fmt
->type
) {
777 v4l2_err(&vpbe_dev
->v4l2_dev
, "invalid type\n");
780 /* Fill in the information about format */
781 fmt
->fmt
.pix
= layer
->pix_fmt
;
786 static int vpbe_display_enum_fmt(struct file
*file
, void *priv
,
787 struct v4l2_fmtdesc
*fmt
)
789 struct vpbe_layer
*layer
= video_drvdata(file
);
790 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
791 unsigned int index
= 0;
793 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
794 "VIDIOC_ENUM_FMT, layer id = %d\n",
796 if (fmt
->index
> 1) {
797 v4l2_err(&vpbe_dev
->v4l2_dev
, "Invalid format index\n");
801 /* Fill in the information about format */
803 memset(fmt
, 0, sizeof(*fmt
));
805 fmt
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
807 strcpy(fmt
->description
, "YUV 4:2:2 - UYVY");
808 fmt
->pixelformat
= V4L2_PIX_FMT_UYVY
;
810 strcpy(fmt
->description
, "Y/CbCr 4:2:0");
811 fmt
->pixelformat
= V4L2_PIX_FMT_NV12
;
817 static int vpbe_display_s_fmt(struct file
*file
, void *priv
,
818 struct v4l2_format
*fmt
)
820 struct vpbe_layer
*layer
= video_drvdata(file
);
821 struct vpbe_display
*disp_dev
= layer
->disp_dev
;
822 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
823 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
824 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
825 struct osd_state
*osd_device
= disp_dev
->osd_device
;
828 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
829 "VIDIOC_S_FMT, layer id = %d\n",
832 if (vb2_is_busy(&layer
->buffer_queue
))
835 if (V4L2_BUF_TYPE_VIDEO_OUTPUT
!= fmt
->type
) {
836 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "invalid type\n");
839 /* Check for valid pixel format */
840 ret
= vpbe_try_format(disp_dev
, pixfmt
, 1);
844 /* YUV420 is requested, check availability of the
845 other video window */
847 layer
->pix_fmt
= *pixfmt
;
848 if (pixfmt
->pixelformat
== V4L2_PIX_FMT_NV12
) {
849 struct vpbe_layer
*otherlayer
;
851 otherlayer
= _vpbe_display_get_other_win_layer(disp_dev
, layer
);
852 /* if other layer is available, only
853 * claim it, do not configure it
855 ret
= osd_device
->ops
.request_layer(osd_device
,
856 otherlayer
->layer_info
.id
);
858 v4l2_err(&vpbe_dev
->v4l2_dev
,
859 "Display Manager failed to allocate layer\n");
864 /* Get osd layer config */
865 osd_device
->ops
.get_layer_config(osd_device
,
866 layer
->layer_info
.id
, cfg
);
867 /* Store the pixel format in the layer object */
868 cfg
->xsize
= pixfmt
->width
;
869 cfg
->ysize
= pixfmt
->height
;
870 cfg
->line_length
= pixfmt
->bytesperline
;
873 cfg
->interlaced
= vpbe_dev
->current_timings
.interlaced
;
875 if (V4L2_PIX_FMT_UYVY
== pixfmt
->pixelformat
)
876 cfg
->pixfmt
= PIXFMT_YCBCRI
;
878 /* Change of the default pixel format for both video windows */
879 if (V4L2_PIX_FMT_NV12
== pixfmt
->pixelformat
) {
880 struct vpbe_layer
*otherlayer
;
881 cfg
->pixfmt
= PIXFMT_NV12
;
882 otherlayer
= _vpbe_display_get_other_win_layer(disp_dev
,
884 otherlayer
->layer_info
.config
.pixfmt
= PIXFMT_NV12
;
887 /* Set the layer config in the osd window */
888 ret
= osd_device
->ops
.set_layer_config(osd_device
,
889 layer
->layer_info
.id
, cfg
);
891 v4l2_err(&vpbe_dev
->v4l2_dev
,
892 "Error in S_FMT params:\n");
896 /* Readback and fill the local copy of current pix format */
897 osd_device
->ops
.get_layer_config(osd_device
,
898 layer
->layer_info
.id
, cfg
);
903 static int vpbe_display_try_fmt(struct file
*file
, void *priv
,
904 struct v4l2_format
*fmt
)
906 struct vpbe_layer
*layer
= video_drvdata(file
);
907 struct vpbe_display
*disp_dev
= layer
->disp_dev
;
908 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
909 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
911 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_TRY_FMT\n");
913 if (V4L2_BUF_TYPE_VIDEO_OUTPUT
!= fmt
->type
) {
914 v4l2_err(&vpbe_dev
->v4l2_dev
, "invalid type\n");
918 /* Check for valid field format */
919 return vpbe_try_format(disp_dev
, pixfmt
, 0);
924 * vpbe_display_s_std - Set the given standard in the encoder
926 * Sets the standard if supported by the current encoder. Return the status.
927 * 0 - success & -EINVAL on error
929 static int vpbe_display_s_std(struct file
*file
, void *priv
,
932 struct vpbe_layer
*layer
= video_drvdata(file
);
933 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
936 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_S_STD\n");
938 if (vb2_is_busy(&layer
->buffer_queue
))
941 if (NULL
!= vpbe_dev
->ops
.s_std
) {
942 ret
= vpbe_dev
->ops
.s_std(vpbe_dev
, std_id
);
944 v4l2_err(&vpbe_dev
->v4l2_dev
,
945 "Failed to set standard for sub devices\n");
956 * vpbe_display_g_std - Get the standard in the current encoder
958 * Get the standard in the current encoder. Return the status. 0 - success
961 static int vpbe_display_g_std(struct file
*file
, void *priv
,
964 struct vpbe_layer
*layer
= video_drvdata(file
);
965 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
967 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_G_STD\n");
969 /* Get the standard from the current encoder */
970 if (vpbe_dev
->current_timings
.timings_type
& VPBE_ENC_STD
) {
971 *std_id
= vpbe_dev
->current_timings
.std_id
;
979 * vpbe_display_enum_output - enumerate outputs
981 * Enumerates the outputs available at the vpbe display
982 * returns the status, -EINVAL if end of output list
984 static int vpbe_display_enum_output(struct file
*file
, void *priv
,
985 struct v4l2_output
*output
)
987 struct vpbe_layer
*layer
= video_drvdata(file
);
988 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
991 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_ENUM_OUTPUT\n");
993 /* Enumerate outputs */
995 if (NULL
== vpbe_dev
->ops
.enum_outputs
)
998 ret
= vpbe_dev
->ops
.enum_outputs(vpbe_dev
, output
);
1000 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
1001 "Failed to enumerate outputs\n");
1009 * vpbe_display_s_output - Set output to
1010 * the output specified by the index
1012 static int vpbe_display_s_output(struct file
*file
, void *priv
,
1015 struct vpbe_layer
*layer
= video_drvdata(file
);
1016 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
1019 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_S_OUTPUT\n");
1021 if (vb2_is_busy(&layer
->buffer_queue
))
1024 if (NULL
== vpbe_dev
->ops
.set_output
)
1027 ret
= vpbe_dev
->ops
.set_output(vpbe_dev
, i
);
1029 v4l2_err(&vpbe_dev
->v4l2_dev
,
1030 "Failed to set output for sub devices\n");
1038 * vpbe_display_g_output - Get output from subdevice
1039 * for a given by the index
1041 static int vpbe_display_g_output(struct file
*file
, void *priv
,
1044 struct vpbe_layer
*layer
= video_drvdata(file
);
1045 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
1047 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_G_OUTPUT\n");
1048 /* Get the standard from the current encoder */
1049 *i
= vpbe_dev
->current_out_index
;
1055 * vpbe_display_enum_dv_timings - Enumerate the dv timings
1057 * enum the timings in the current encoder. Return the status. 0 - success
1061 vpbe_display_enum_dv_timings(struct file
*file
, void *priv
,
1062 struct v4l2_enum_dv_timings
*timings
)
1064 struct vpbe_layer
*layer
= video_drvdata(file
);
1065 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
1068 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_ENUM_DV_TIMINGS\n");
1070 /* Enumerate outputs */
1071 if (NULL
== vpbe_dev
->ops
.enum_dv_timings
)
1074 ret
= vpbe_dev
->ops
.enum_dv_timings(vpbe_dev
, timings
);
1076 v4l2_err(&vpbe_dev
->v4l2_dev
,
1077 "Failed to enumerate dv timings info\n");
1085 * vpbe_display_s_dv_timings - Set the dv timings
1087 * Set the timings in the current encoder. Return the status. 0 - success
1091 vpbe_display_s_dv_timings(struct file
*file
, void *priv
,
1092 struct v4l2_dv_timings
*timings
)
1094 struct vpbe_layer
*layer
= video_drvdata(file
);
1095 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
1098 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_S_DV_TIMINGS\n");
1100 if (vb2_is_busy(&layer
->buffer_queue
))
1103 /* Set the given standard in the encoder */
1104 if (!vpbe_dev
->ops
.s_dv_timings
)
1107 ret
= vpbe_dev
->ops
.s_dv_timings(vpbe_dev
, timings
);
1109 v4l2_err(&vpbe_dev
->v4l2_dev
,
1110 "Failed to set the dv timings info\n");
1118 * vpbe_display_g_dv_timings - Set the dv timings
1120 * Get the timings in the current encoder. Return the status. 0 - success
1124 vpbe_display_g_dv_timings(struct file
*file
, void *priv
,
1125 struct v4l2_dv_timings
*dv_timings
)
1127 struct vpbe_layer
*layer
= video_drvdata(file
);
1128 struct vpbe_device
*vpbe_dev
= layer
->disp_dev
->vpbe_dev
;
1130 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "VIDIOC_G_DV_TIMINGS\n");
1132 /* Get the given standard in the encoder */
1134 if (vpbe_dev
->current_timings
.timings_type
&
1135 VPBE_ENC_DV_TIMINGS
) {
1136 *dv_timings
= vpbe_dev
->current_timings
.dv_timings
;
1145 * vpbe_display_open()
1146 * It creates object of file handle structure and stores it in private_data
1147 * member of filepointer
1149 static int vpbe_display_open(struct file
*file
)
1151 struct vpbe_layer
*layer
= video_drvdata(file
);
1152 struct vpbe_display
*disp_dev
= layer
->disp_dev
;
1153 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
1154 struct osd_state
*osd_device
= disp_dev
->osd_device
;
1157 /* creating context for file descriptor */
1158 err
= v4l2_fh_open(file
);
1160 v4l2_err(&vpbe_dev
->v4l2_dev
, "v4l2_fh_open failed\n");
1164 /* leaving if layer is already initialized */
1165 if (!v4l2_fh_is_singular_file(file
))
1169 if (mutex_lock_interruptible(&layer
->opslock
))
1170 return -ERESTARTSYS
;
1171 /* First claim the layer for this device */
1172 err
= osd_device
->ops
.request_layer(osd_device
,
1173 layer
->layer_info
.id
);
1174 mutex_unlock(&layer
->opslock
);
1176 /* Couldn't get layer */
1177 v4l2_err(&vpbe_dev
->v4l2_dev
,
1178 "Display Manager failed to allocate layer\n");
1179 v4l2_fh_release(file
);
1183 /* Increment layer usrs counter */
1185 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
,
1186 "vpbe display device opened successfully\n");
1191 * vpbe_display_release()
1192 * This function deletes buffer queue, frees the buffers and the davinci
1193 * display file * handle
1195 static int vpbe_display_release(struct file
*file
)
1197 struct vpbe_layer
*layer
= video_drvdata(file
);
1198 struct osd_layer_config
*cfg
= &layer
->layer_info
.config
;
1199 struct vpbe_display
*disp_dev
= layer
->disp_dev
;
1200 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
1201 struct osd_state
*osd_device
= disp_dev
->osd_device
;
1203 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "vpbe_display_release\n");
1205 mutex_lock(&layer
->opslock
);
1207 osd_device
->ops
.disable_layer(osd_device
,
1208 layer
->layer_info
.id
);
1209 /* Decrement layer usrs counter */
1211 /* If this file handle has initialize encoder device, reset it */
1213 if (cfg
->pixfmt
== PIXFMT_NV12
) {
1214 struct vpbe_layer
*otherlayer
;
1216 _vpbe_display_get_other_win_layer(disp_dev
, layer
);
1217 osd_device
->ops
.disable_layer(osd_device
,
1218 otherlayer
->layer_info
.id
);
1219 osd_device
->ops
.release_layer(osd_device
,
1220 otherlayer
->layer_info
.id
);
1222 osd_device
->ops
.disable_layer(osd_device
,
1223 layer
->layer_info
.id
);
1224 osd_device
->ops
.release_layer(osd_device
,
1225 layer
->layer_info
.id
);
1228 _vb2_fop_release(file
, NULL
);
1229 mutex_unlock(&layer
->opslock
);
1231 disp_dev
->cbcr_ofst
= 0;
1236 /* vpbe capture ioctl operations */
1237 static const struct v4l2_ioctl_ops vpbe_ioctl_ops
= {
1238 .vidioc_querycap
= vpbe_display_querycap
,
1239 .vidioc_g_fmt_vid_out
= vpbe_display_g_fmt
,
1240 .vidioc_enum_fmt_vid_out
= vpbe_display_enum_fmt
,
1241 .vidioc_s_fmt_vid_out
= vpbe_display_s_fmt
,
1242 .vidioc_try_fmt_vid_out
= vpbe_display_try_fmt
,
1244 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1245 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1246 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1247 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1248 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1249 .vidioc_streamon
= vb2_ioctl_streamon
,
1250 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1251 .vidioc_expbuf
= vb2_ioctl_expbuf
,
1253 .vidioc_cropcap
= vpbe_display_cropcap
,
1254 .vidioc_g_crop
= vpbe_display_g_crop
,
1255 .vidioc_s_crop
= vpbe_display_s_crop
,
1257 .vidioc_s_std
= vpbe_display_s_std
,
1258 .vidioc_g_std
= vpbe_display_g_std
,
1260 .vidioc_enum_output
= vpbe_display_enum_output
,
1261 .vidioc_s_output
= vpbe_display_s_output
,
1262 .vidioc_g_output
= vpbe_display_g_output
,
1264 .vidioc_s_dv_timings
= vpbe_display_s_dv_timings
,
1265 .vidioc_g_dv_timings
= vpbe_display_g_dv_timings
,
1266 .vidioc_enum_dv_timings
= vpbe_display_enum_dv_timings
,
1269 static struct v4l2_file_operations vpbe_fops
= {
1270 .owner
= THIS_MODULE
,
1271 .open
= vpbe_display_open
,
1272 .release
= vpbe_display_release
,
1273 .unlocked_ioctl
= video_ioctl2
,
1274 .mmap
= vb2_fop_mmap
,
1275 .poll
= vb2_fop_poll
,
1278 static int vpbe_device_get(struct device
*dev
, void *data
)
1280 struct platform_device
*pdev
= to_platform_device(dev
);
1281 struct vpbe_display
*vpbe_disp
= data
;
1283 if (strcmp("vpbe_controller", pdev
->name
) == 0)
1284 vpbe_disp
->vpbe_dev
= platform_get_drvdata(pdev
);
1286 if (strstr(pdev
->name
, "vpbe-osd") != NULL
)
1287 vpbe_disp
->osd_device
= platform_get_drvdata(pdev
);
1292 static int init_vpbe_layer(int i
, struct vpbe_display
*disp_dev
,
1293 struct platform_device
*pdev
)
1295 struct vpbe_layer
*vpbe_display_layer
= NULL
;
1296 struct video_device
*vbd
= NULL
;
1298 /* Allocate memory for four plane display objects */
1301 kzalloc(sizeof(struct vpbe_layer
), GFP_KERNEL
);
1303 /* If memory allocation fails, return error */
1304 if (!disp_dev
->dev
[i
]) {
1305 printk(KERN_ERR
"ran out of memory\n");
1308 spin_lock_init(&disp_dev
->dev
[i
]->irqlock
);
1309 mutex_init(&disp_dev
->dev
[i
]->opslock
);
1311 /* Get the pointer to the layer object */
1312 vpbe_display_layer
= disp_dev
->dev
[i
];
1313 vbd
= &vpbe_display_layer
->video_dev
;
1314 /* Initialize field of video device */
1315 vbd
->release
= video_device_release_empty
;
1316 vbd
->fops
= &vpbe_fops
;
1317 vbd
->ioctl_ops
= &vpbe_ioctl_ops
;
1319 vbd
->v4l2_dev
= &disp_dev
->vpbe_dev
->v4l2_dev
;
1320 vbd
->lock
= &vpbe_display_layer
->opslock
;
1321 vbd
->vfl_dir
= VFL_DIR_TX
;
1323 if (disp_dev
->vpbe_dev
->current_timings
.timings_type
&
1325 vbd
->tvnorms
= (V4L2_STD_525_60
| V4L2_STD_625_50
);
1327 snprintf(vbd
->name
, sizeof(vbd
->name
),
1328 "DaVinci_VPBE Display_DRIVER_V%d.%d.%d",
1329 (VPBE_DISPLAY_VERSION_CODE
>> 16) & 0xff,
1330 (VPBE_DISPLAY_VERSION_CODE
>> 8) & 0xff,
1331 (VPBE_DISPLAY_VERSION_CODE
) & 0xff);
1333 vpbe_display_layer
->device_id
= i
;
1335 vpbe_display_layer
->layer_info
.id
=
1336 ((i
== VPBE_DISPLAY_DEVICE_0
) ? WIN_VID0
: WIN_VID1
);
1342 static int register_device(struct vpbe_layer
*vpbe_display_layer
,
1343 struct vpbe_display
*disp_dev
,
1344 struct platform_device
*pdev
)
1348 v4l2_info(&disp_dev
->vpbe_dev
->v4l2_dev
,
1349 "Trying to register VPBE display device.\n");
1350 v4l2_info(&disp_dev
->vpbe_dev
->v4l2_dev
,
1351 "layer=%x,layer->video_dev=%x\n",
1352 (int)vpbe_display_layer
,
1353 (int)&vpbe_display_layer
->video_dev
);
1355 vpbe_display_layer
->video_dev
.queue
= &vpbe_display_layer
->buffer_queue
;
1356 err
= video_register_device(&vpbe_display_layer
->video_dev
,
1362 vpbe_display_layer
->disp_dev
= disp_dev
;
1363 /* set the driver data in platform device */
1364 platform_set_drvdata(pdev
, disp_dev
);
1365 video_set_drvdata(&vpbe_display_layer
->video_dev
,
1366 vpbe_display_layer
);
1374 * vpbe_display_probe()
1375 * This function creates device entries by register itself to the V4L2 driver
1376 * and initializes fields of each layer objects
1378 static int vpbe_display_probe(struct platform_device
*pdev
)
1380 struct vpbe_display
*disp_dev
;
1381 struct v4l2_device
*v4l2_dev
;
1382 struct resource
*res
= NULL
;
1383 struct vb2_queue
*q
;
1389 printk(KERN_DEBUG
"vpbe_display_probe\n");
1390 /* Allocate memory for vpbe_display */
1391 disp_dev
= devm_kzalloc(&pdev
->dev
, sizeof(struct vpbe_display
),
1396 spin_lock_init(&disp_dev
->dma_queue_lock
);
1398 * Scan all the platform devices to find the vpbe
1399 * controller device and get the vpbe_dev object
1401 err
= bus_for_each_dev(&platform_bus_type
, NULL
, disp_dev
,
1406 v4l2_dev
= &disp_dev
->vpbe_dev
->v4l2_dev
;
1407 /* Initialize the vpbe display controller */
1408 if (NULL
!= disp_dev
->vpbe_dev
->ops
.initialize
) {
1409 err
= disp_dev
->vpbe_dev
->ops
.initialize(&pdev
->dev
,
1410 disp_dev
->vpbe_dev
);
1412 v4l2_err(v4l2_dev
, "Error initing vpbe\n");
1418 for (i
= 0; i
< VPBE_DISPLAY_MAX_DEVICES
; i
++) {
1419 if (init_vpbe_layer(i
, disp_dev
, pdev
)) {
1425 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1427 v4l2_err(v4l2_dev
, "Unable to get VENC interrupt resource\n");
1433 err
= devm_request_irq(&pdev
->dev
, irq
, venc_isr
, 0,
1434 VPBE_DISPLAY_DRIVER
, disp_dev
);
1436 v4l2_err(v4l2_dev
, "VPBE IRQ request failed\n");
1440 for (i
= 0; i
< VPBE_DISPLAY_MAX_DEVICES
; i
++) {
1441 /* initialize vb2 queue */
1442 q
= &disp_dev
->dev
[i
]->buffer_queue
;
1443 memset(q
, 0, sizeof(*q
));
1444 q
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1445 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
1446 q
->drv_priv
= disp_dev
->dev
[i
];
1447 q
->ops
= &video_qops
;
1448 q
->mem_ops
= &vb2_dma_contig_memops
;
1449 q
->buf_struct_size
= sizeof(struct vpbe_disp_buffer
);
1450 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1451 q
->min_buffers_needed
= 1;
1452 q
->lock
= &disp_dev
->dev
[i
]->opslock
;
1453 q
->dev
= disp_dev
->vpbe_dev
->pdev
;
1454 err
= vb2_queue_init(q
);
1456 v4l2_err(v4l2_dev
, "vb2_queue_init() failed\n");
1460 INIT_LIST_HEAD(&disp_dev
->dev
[i
]->dma_queue
);
1462 if (register_device(disp_dev
->dev
[i
], disp_dev
, pdev
)) {
1468 v4l2_dbg(1, debug
, v4l2_dev
,
1469 "Successfully completed the probing of vpbe v4l2 device\n");
1474 for (k
= 0; k
< VPBE_DISPLAY_MAX_DEVICES
; k
++) {
1475 /* Unregister video device */
1476 if (disp_dev
->dev
[k
] != NULL
) {
1477 video_unregister_device(&disp_dev
->dev
[k
]->video_dev
);
1478 kfree(disp_dev
->dev
[k
]);
1485 * vpbe_display_remove()
1486 * It un-register hardware layer from V4L2 driver
1488 static int vpbe_display_remove(struct platform_device
*pdev
)
1490 struct vpbe_layer
*vpbe_display_layer
;
1491 struct vpbe_display
*disp_dev
= platform_get_drvdata(pdev
);
1492 struct vpbe_device
*vpbe_dev
= disp_dev
->vpbe_dev
;
1495 v4l2_dbg(1, debug
, &vpbe_dev
->v4l2_dev
, "vpbe_display_remove\n");
1497 /* deinitialize the vpbe display controller */
1498 if (NULL
!= vpbe_dev
->ops
.deinitialize
)
1499 vpbe_dev
->ops
.deinitialize(&pdev
->dev
, vpbe_dev
);
1500 /* un-register device */
1501 for (i
= 0; i
< VPBE_DISPLAY_MAX_DEVICES
; i
++) {
1502 /* Get the pointer to the layer object */
1503 vpbe_display_layer
= disp_dev
->dev
[i
];
1504 /* Unregister video device */
1505 video_unregister_device(&vpbe_display_layer
->video_dev
);
1508 for (i
= 0; i
< VPBE_DISPLAY_MAX_DEVICES
; i
++) {
1509 kfree(disp_dev
->dev
[i
]);
1510 disp_dev
->dev
[i
] = NULL
;
1516 static struct platform_driver vpbe_display_driver
= {
1518 .name
= VPBE_DISPLAY_DRIVER
,
1519 .bus
= &platform_bus_type
,
1521 .probe
= vpbe_display_probe
,
1522 .remove
= vpbe_display_remove
,
1525 module_platform_driver(vpbe_display_driver
);
1527 MODULE_DESCRIPTION("TI DM644x/DM355/DM365 VPBE Display controller");
1528 MODULE_LICENSE("GPL");
1529 MODULE_AUTHOR("Texas Instruments");