?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Don't clone maps from parent when synthesizing forks
[linux/fpc-iii.git] / drivers / media / platform / davinci / vpbe_display.c
blobb0eb3d899eb44bfcca33eac2b50194eeb2b70838
1 /*
2 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
3 *
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.
7 *
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.
12 */
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>
23 #include <linux/mm.h>
24 #include <linux/mutex.h>
25 #include <linux/videodev2.h>
26 #include <linux/slab.h>
27
28 #include <asm/pgtable.h>
29
30 #ifdef CONFIG_ARCH_DAVINCI
31 #include <mach/cputype.h>
32 #endif
33
34 #include <media/v4l2-dev.h>
35 #include <media/v4l2-common.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/v4l2-device.h>
38 #include <media/davinci/vpbe_display.h>
39 #include <media/davinci/vpbe_types.h>
40 #include <media/davinci/vpbe.h>
41 #include <media/davinci/vpbe_venc.h>
42 #include <media/davinci/vpbe_osd.h>
43 #include "vpbe_venc_regs.h"
44
45 #define VPBE_DISPLAY_DRIVER "vpbe-v4l2"
46
47 static int debug;
48
49 #define VPBE_DEFAULT_NUM_BUFS 3
50
51 module_param(debug, int, 0644);
52
53 static int vpbe_set_osd_display_params(struct vpbe_display *disp_dev,
54 struct vpbe_layer *layer);
55
56 static int venc_is_second_field(struct vpbe_display *disp_dev)
57 {
58 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
59 int ret, val;
60
61 ret = v4l2_subdev_call(vpbe_dev->venc,
62 core,
63 ioctl,
64 VENC_GET_FLD,
65 &val);
66 if (ret < 0) {
67 v4l2_err(&vpbe_dev->v4l2_dev,
68 "Error in getting Field ID 0\n");
69 return 1;
70 }
71 return val;
72 }
73
74 static void vpbe_isr_even_field(struct vpbe_display *disp_obj,
75 struct vpbe_layer *layer)
76 {
77 if (layer->cur_frm == layer->next_frm)
78 return;
79
80 layer->cur_frm->vb.vb2_buf.timestamp = ktime_get_ns();
81 vb2_buffer_done(&layer->cur_frm->vb.vb2_buf, VB2_BUF_STATE_DONE);
82 /* Make cur_frm pointing to next_frm */
83 layer->cur_frm = layer->next_frm;
84 }
85
86 static void vpbe_isr_odd_field(struct vpbe_display *disp_obj,
87 struct vpbe_layer *layer)
88 {
89 struct osd_state *osd_device = disp_obj->osd_device;
90 unsigned long addr;
91
92 spin_lock(&disp_obj->dma_queue_lock);
93 if (list_empty(&layer->dma_queue) ||
94 (layer->cur_frm != layer->next_frm)) {
95 spin_unlock(&disp_obj->dma_queue_lock);
96 return;
97 }
98 /*
99 * one field is displayed configure
100 * the next frame if it is available
101 * otherwise hold on current frame
102 * Get next from the buffer queue
103 */
104 layer->next_frm = list_entry(layer->dma_queue.next,
105 struct vpbe_disp_buffer, list);
106 /* Remove that from the buffer queue */
107 list_del(&layer->next_frm->list);
108 spin_unlock(&disp_obj->dma_queue_lock);
109 /* Mark state of the frame to active */
110 layer->next_frm->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
111 addr = vb2_dma_contig_plane_dma_addr(&layer->next_frm->vb.vb2_buf, 0);
112 osd_device->ops.start_layer(osd_device,
113 layer->layer_info.id,
114 addr,
115 disp_obj->cbcr_ofst);
116 }
117
118 /* interrupt service routine */
119 static irqreturn_t venc_isr(int irq, void *arg)
120 {
121 struct vpbe_display *disp_dev = (struct vpbe_display *)arg;
122 struct vpbe_layer *layer;
123 static unsigned last_event;
124 unsigned event = 0;
125 int fid;
126 int i;
127
128 if (!arg || !disp_dev->dev[0])
129 return IRQ_HANDLED;
130
131 if (venc_is_second_field(disp_dev))
132 event |= VENC_SECOND_FIELD;
133 else
134 event |= VENC_FIRST_FIELD;
135
136 if (event == (last_event & ~VENC_END_OF_FRAME)) {
137 /*
138 * If the display is non-interlaced, then we need to flag the
139 * end-of-frame event at every interrupt regardless of the
140 * value of the FIDST bit. We can conclude that the display is
141 * non-interlaced if the value of the FIDST bit is unchanged
142 * from the previous interrupt.
143 */
144 event |= VENC_END_OF_FRAME;
145 } else if (event == VENC_SECOND_FIELD) {
146 /* end-of-frame for interlaced display */
147 event |= VENC_END_OF_FRAME;
148 }
149 last_event = event;
150
151 for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
152 layer = disp_dev->dev[i];
153
154 if (!vb2_start_streaming_called(&layer->buffer_queue))
155 continue;
156
157 if (layer->layer_first_int) {
158 layer->layer_first_int = 0;
159 continue;
160 }
161 /* Check the field format */
162 if ((V4L2_FIELD_NONE == layer->pix_fmt.field) &&
163 (event & VENC_END_OF_FRAME)) {
164 /* Progressive mode */
165
166 vpbe_isr_even_field(disp_dev, layer);
167 vpbe_isr_odd_field(disp_dev, layer);
168 } else {
169 /* Interlaced mode */
170
171 layer->field_id ^= 1;
172 if (event & VENC_FIRST_FIELD)
173 fid = 0;
174 else
175 fid = 1;
176
177 /*
178 * If field id does not match with store
179 * field id
180 */
181 if (fid != layer->field_id) {
182 /* Make them in sync */
183 layer->field_id = fid;
184 continue;
185 }
186 /*
187 * device field id and local field id are
188 * in sync. If this is even field
189 */
190 if (0 == fid)
191 vpbe_isr_even_field(disp_dev, layer);
192 else /* odd field */
193 vpbe_isr_odd_field(disp_dev, layer);
194 }
195 }
196
197 return IRQ_HANDLED;
198 }
199
200 /*
201 * vpbe_buffer_prepare()
202 * This is the callback function called from vb2_qbuf() function
203 * the buffer is prepared and user space virtual address is converted into
204 * physical address
205 */
206 static int vpbe_buffer_prepare(struct vb2_buffer *vb)
207 {
208 struct vb2_queue *q = vb->vb2_queue;
209 struct vpbe_layer *layer = vb2_get_drv_priv(q);
210 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
211 unsigned long addr;
212
213 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
214 "vpbe_buffer_prepare\n");
215
216 vb2_set_plane_payload(vb, 0, layer->pix_fmt.sizeimage);
217 if (vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
218 return -EINVAL;
219
220 addr = vb2_dma_contig_plane_dma_addr(vb, 0);
221 if (!IS_ALIGNED(addr, 8)) {
222 v4l2_err(&vpbe_dev->v4l2_dev,
223 "buffer_prepare:offset is not aligned to 32 bytes\n");
224 return -EINVAL;
225 }
226 return 0;
227 }
228
229 /*
230 * vpbe_buffer_setup()
231 * This function allocates memory for the buffers
232 */
233 static int
234 vpbe_buffer_queue_setup(struct vb2_queue *vq,
235 unsigned int *nbuffers, unsigned int *nplanes,
236 unsigned int sizes[], struct device *alloc_devs[])
237
238 {
239 /* Get the file handle object and layer object */
240 struct vpbe_layer *layer = vb2_get_drv_priv(vq);
241 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
242
243 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_buffer_setup\n");
244
245 /* Store number of buffers allocated in numbuffer member */
246 if (vq->num_buffers + *nbuffers < VPBE_DEFAULT_NUM_BUFS)
247 *nbuffers = VPBE_DEFAULT_NUM_BUFS - vq->num_buffers;
248
249 if (*nplanes)
250 return sizes[0] < layer->pix_fmt.sizeimage ? -EINVAL : 0;
251
252 *nplanes = 1;
253 sizes[0] = layer->pix_fmt.sizeimage;
254
255 return 0;
256 }
257
258 /*
259 * vpbe_buffer_queue()
260 * This function adds the buffer to DMA queue
261 */
262 static void vpbe_buffer_queue(struct vb2_buffer *vb)
263 {
264 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
265 /* Get the file handle object and layer object */
266 struct vpbe_disp_buffer *buf = container_of(vbuf,
267 struct vpbe_disp_buffer, vb);
268 struct vpbe_layer *layer = vb2_get_drv_priv(vb->vb2_queue);
269 struct vpbe_display *disp = layer->disp_dev;
270 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
271 unsigned long flags;
272
273 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
274 "vpbe_buffer_queue\n");
275
276 /* add the buffer to the DMA queue */
277 spin_lock_irqsave(&disp->dma_queue_lock, flags);
278 list_add_tail(&buf->list, &layer->dma_queue);
279 spin_unlock_irqrestore(&disp->dma_queue_lock, flags);
280 }
281
282 static int vpbe_start_streaming(struct vb2_queue *vq, unsigned int count)
283 {
284 struct vpbe_layer *layer = vb2_get_drv_priv(vq);
285 struct osd_state *osd_device = layer->disp_dev->osd_device;
286 int ret;
287
288 osd_device->ops.disable_layer(osd_device, layer->layer_info.id);
289
290 /* Get the next frame from the buffer queue */
291 layer->next_frm = layer->cur_frm = list_entry(layer->dma_queue.next,
292 struct vpbe_disp_buffer, list);
293 /* Remove buffer from the buffer queue */
294 list_del(&layer->cur_frm->list);
295 /* Mark state of the current frame to active */
296 layer->cur_frm->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
297 /* Initialize field_id and started member */
298 layer->field_id = 0;
299
300 /* Set parameters in OSD and VENC */
301 ret = vpbe_set_osd_display_params(layer->disp_dev, layer);
302 if (ret < 0) {
303 struct vpbe_disp_buffer *buf, *tmp;
304
305 vb2_buffer_done(&layer->cur_frm->vb.vb2_buf,
306 VB2_BUF_STATE_QUEUED);
307 list_for_each_entry_safe(buf, tmp, &layer->dma_queue, list) {
308 list_del(&buf->list);
309 vb2_buffer_done(&buf->vb.vb2_buf,
310 VB2_BUF_STATE_QUEUED);
311 }
312
313 return ret;
314 }
315
316 /*
317 * if request format is yuv420 semiplanar, need to
318 * enable both video windows
319 */
320 layer->layer_first_int = 1;
321
322 return ret;
323 }
324
325 static void vpbe_stop_streaming(struct vb2_queue *vq)
326 {
327 struct vpbe_layer *layer = vb2_get_drv_priv(vq);
328 struct osd_state *osd_device = layer->disp_dev->osd_device;
329 struct vpbe_display *disp = layer->disp_dev;
330 unsigned long flags;
331
332 if (!vb2_is_streaming(vq))
333 return;
334
335 osd_device->ops.disable_layer(osd_device, layer->layer_info.id);
336
337 /* release all active buffers */
338 spin_lock_irqsave(&disp->dma_queue_lock, flags);
339 if (layer->cur_frm == layer->next_frm) {
340 vb2_buffer_done(&layer->cur_frm->vb.vb2_buf,
341 VB2_BUF_STATE_ERROR);
342 } else {
343 if (layer->cur_frm)
344 vb2_buffer_done(&layer->cur_frm->vb.vb2_buf,
345 VB2_BUF_STATE_ERROR);
346 if (layer->next_frm)
347 vb2_buffer_done(&layer->next_frm->vb.vb2_buf,
348 VB2_BUF_STATE_ERROR);
349 }
350
351 while (!list_empty(&layer->dma_queue)) {
352 layer->next_frm = list_entry(layer->dma_queue.next,
353 struct vpbe_disp_buffer, list);
354 list_del(&layer->next_frm->list);
355 vb2_buffer_done(&layer->next_frm->vb.vb2_buf,
356 VB2_BUF_STATE_ERROR);
357 }
358 spin_unlock_irqrestore(&disp->dma_queue_lock, flags);
359 }
360
361 static const struct vb2_ops video_qops = {
362 .queue_setup = vpbe_buffer_queue_setup,
363 .wait_prepare = vb2_ops_wait_prepare,
364 .wait_finish = vb2_ops_wait_finish,
365 .buf_prepare = vpbe_buffer_prepare,
366 .start_streaming = vpbe_start_streaming,
367 .stop_streaming = vpbe_stop_streaming,
368 .buf_queue = vpbe_buffer_queue,
369 };
370
371 static
372 struct vpbe_layer*
373 _vpbe_display_get_other_win_layer(struct vpbe_display *disp_dev,
374 struct vpbe_layer *layer)
375 {
376 enum vpbe_display_device_id thiswin, otherwin;
377 thiswin = layer->device_id;
378
379 otherwin = (thiswin == VPBE_DISPLAY_DEVICE_0) ?
380 VPBE_DISPLAY_DEVICE_1 : VPBE_DISPLAY_DEVICE_0;
381 return disp_dev->dev[otherwin];
382 }
383
384 static int vpbe_set_osd_display_params(struct vpbe_display *disp_dev,
385 struct vpbe_layer *layer)
386 {
387 struct osd_layer_config *cfg = &layer->layer_info.config;
388 struct osd_state *osd_device = disp_dev->osd_device;
389 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
390 unsigned long addr;
391 int ret;
392
393 addr = vb2_dma_contig_plane_dma_addr(&layer->cur_frm->vb.vb2_buf, 0);
394 /* Set address in the display registers */
395 osd_device->ops.start_layer(osd_device,
396 layer->layer_info.id,
397 addr,
398 disp_dev->cbcr_ofst);
399
400 ret = osd_device->ops.enable_layer(osd_device,
401 layer->layer_info.id, 0);
402 if (ret < 0) {
403 v4l2_err(&vpbe_dev->v4l2_dev,
404 "Error in enabling osd window layer 0\n");
405 return -1;
406 }
407
408 /* Enable the window */
409 layer->layer_info.enable = 1;
410 if (cfg->pixfmt == PIXFMT_NV12) {
411 struct vpbe_layer *otherlayer =
412 _vpbe_display_get_other_win_layer(disp_dev, layer);
413
414 ret = osd_device->ops.enable_layer(osd_device,
415 otherlayer->layer_info.id, 1);
416 if (ret < 0) {
417 v4l2_err(&vpbe_dev->v4l2_dev,
418 "Error in enabling osd window layer 1\n");
419 return -1;
420 }
421 otherlayer->layer_info.enable = 1;
422 }
423 return 0;
424 }
425
426 static void
427 vpbe_disp_calculate_scale_factor(struct vpbe_display *disp_dev,
428 struct vpbe_layer *layer,
429 int expected_xsize, int expected_ysize)
430 {
431 struct display_layer_info *layer_info = &layer->layer_info;
432 struct v4l2_pix_format *pixfmt = &layer->pix_fmt;
433 struct osd_layer_config *cfg = &layer->layer_info.config;
434 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
435 int calculated_xsize;
436 int h_exp = 0;
437 int v_exp = 0;
438 int h_scale;
439 int v_scale;
440
441 v4l2_std_id standard_id = vpbe_dev->current_timings.std_id;
442
443 /*
444 * Application initially set the image format. Current display
445 * size is obtained from the vpbe display controller. expected_xsize
446 * and expected_ysize are set through S_SELECTION ioctl. Based on this,
447 * driver will calculate the scale factors for vertical and
448 * horizontal direction so that the image is displayed scaled
449 * and expanded. Application uses expansion to display the image
450 * in a square pixel. Otherwise it is displayed using displays
451 * pixel aspect ratio.It is expected that application chooses
452 * the crop coordinates for cropped or scaled display. if crop
453 * size is less than the image size, it is displayed cropped or
454 * it is displayed scaled and/or expanded.
455 *
456 * to begin with, set the crop window same as expected. Later we
457 * will override with scaled window size
458 */
459
460 cfg->xsize = pixfmt->width;
461 cfg->ysize = pixfmt->height;
462 layer_info->h_zoom = ZOOM_X1; /* no horizontal zoom */
463 layer_info->v_zoom = ZOOM_X1; /* no horizontal zoom */
464 layer_info->h_exp = H_EXP_OFF; /* no horizontal zoom */
465 layer_info->v_exp = V_EXP_OFF; /* no horizontal zoom */
466
467 if (pixfmt->width < expected_xsize) {
468 h_scale = vpbe_dev->current_timings.xres / pixfmt->width;
469 if (h_scale < 2)
470 h_scale = 1;
471 else if (h_scale >= 4)
472 h_scale = 4;
473 else
474 h_scale = 2;
475 cfg->xsize *= h_scale;
476 if (cfg->xsize < expected_xsize) {
477 if ((standard_id & V4L2_STD_525_60) ||
478 (standard_id & V4L2_STD_625_50)) {
479 calculated_xsize = (cfg->xsize *
480 VPBE_DISPLAY_H_EXP_RATIO_N) /
481 VPBE_DISPLAY_H_EXP_RATIO_D;
482 if (calculated_xsize <= expected_xsize) {
483 h_exp = 1;
484 cfg->xsize = calculated_xsize;
485 }
486 }
487 }
488 if (h_scale == 2)
489 layer_info->h_zoom = ZOOM_X2;
490 else if (h_scale == 4)
491 layer_info->h_zoom = ZOOM_X4;
492 if (h_exp)
493 layer_info->h_exp = H_EXP_9_OVER_8;
494 } else {
495 /* no scaling, only cropping. Set display area to crop area */
496 cfg->xsize = expected_xsize;
497 }
498
499 if (pixfmt->height < expected_ysize) {
500 v_scale = expected_ysize / pixfmt->height;
501 if (v_scale < 2)
502 v_scale = 1;
503 else if (v_scale >= 4)
504 v_scale = 4;
505 else
506 v_scale = 2;
507 cfg->ysize *= v_scale;
508 if (cfg->ysize < expected_ysize) {
509 if ((standard_id & V4L2_STD_625_50)) {
510 calculated_xsize = (cfg->ysize *
511 VPBE_DISPLAY_V_EXP_RATIO_N) /
512 VPBE_DISPLAY_V_EXP_RATIO_D;
513 if (calculated_xsize <= expected_ysize) {
514 v_exp = 1;
515 cfg->ysize = calculated_xsize;
516 }
517 }
518 }
519 if (v_scale == 2)
520 layer_info->v_zoom = ZOOM_X2;
521 else if (v_scale == 4)
522 layer_info->v_zoom = ZOOM_X4;
523 if (v_exp)
524 layer_info->h_exp = V_EXP_6_OVER_5;
525 } else {
526 /* no scaling, only cropping. Set display area to crop area */
527 cfg->ysize = expected_ysize;
528 }
529 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
530 "crop display xsize = %d, ysize = %d\n",
531 cfg->xsize, cfg->ysize);
532 }
533
534 static void vpbe_disp_adj_position(struct vpbe_display *disp_dev,
535 struct vpbe_layer *layer,
536 int top, int left)
537 {
538 struct osd_layer_config *cfg = &layer->layer_info.config;
539 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
540
541 cfg->xpos = min((unsigned int)left,
542 vpbe_dev->current_timings.xres - cfg->xsize);
543 cfg->ypos = min((unsigned int)top,
544 vpbe_dev->current_timings.yres - cfg->ysize);
545
546 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
547 "new xpos = %d, ypos = %d\n",
548 cfg->xpos, cfg->ypos);
549 }
550
551 static void vpbe_disp_check_window_params(struct vpbe_display *disp_dev,
552 struct v4l2_rect *c)
553 {
554 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
555
556 if ((c->width == 0) ||
557 ((c->width + c->left) > vpbe_dev->current_timings.xres))
558 c->width = vpbe_dev->current_timings.xres - c->left;
559
560 if ((c->height == 0) || ((c->height + c->top) >
561 vpbe_dev->current_timings.yres))
562 c->height = vpbe_dev->current_timings.yres - c->top;
563
564 /* window height must be even for interlaced display */
565 if (vpbe_dev->current_timings.interlaced)
566 c->height &= (~0x01);
567
568 }
569
570 /*
571 * vpbe_try_format()
572 * If user application provides width and height, and have bytesperline set
573 * to zero, driver calculates bytesperline and sizeimage based on hardware
574 * limits.
575 */
576 static int vpbe_try_format(struct vpbe_display *disp_dev,
577 struct v4l2_pix_format *pixfmt, int check)
578 {
579 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
580 int min_height = 1;
581 int min_width = 32;
582 int max_height;
583 int max_width;
584 int bpp;
585
586 if ((pixfmt->pixelformat != V4L2_PIX_FMT_UYVY) &&
587 (pixfmt->pixelformat != V4L2_PIX_FMT_NV12))
588 /* choose default as V4L2_PIX_FMT_UYVY */
589 pixfmt->pixelformat = V4L2_PIX_FMT_UYVY;
590
591 /* Check the field format */
592 if ((pixfmt->field != V4L2_FIELD_INTERLACED) &&
593 (pixfmt->field != V4L2_FIELD_NONE)) {
594 if (vpbe_dev->current_timings.interlaced)
595 pixfmt->field = V4L2_FIELD_INTERLACED;
596 else
597 pixfmt->field = V4L2_FIELD_NONE;
598 }
599
600 if (pixfmt->field == V4L2_FIELD_INTERLACED)
601 min_height = 2;
602
603 if (pixfmt->pixelformat == V4L2_PIX_FMT_NV12)
604 bpp = 1;
605 else
606 bpp = 2;
607
608 max_width = vpbe_dev->current_timings.xres;
609 max_height = vpbe_dev->current_timings.yres;
610
611 min_width /= bpp;
612
613 if (!pixfmt->width || (pixfmt->width < min_width) ||
614 (pixfmt->width > max_width)) {
615 pixfmt->width = vpbe_dev->current_timings.xres;
616 }
617
618 if (!pixfmt->height || (pixfmt->height < min_height) ||
619 (pixfmt->height > max_height)) {
620 pixfmt->height = vpbe_dev->current_timings.yres;
621 }
622
623 if (pixfmt->bytesperline < (pixfmt->width * bpp))
624 pixfmt->bytesperline = pixfmt->width * bpp;
625
626 /* Make the bytesperline 32 byte aligned */
627 pixfmt->bytesperline = ((pixfmt->width * bpp + 31) & ~31);
628
629 if (pixfmt->pixelformat == V4L2_PIX_FMT_NV12)
630 pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height +
631 (pixfmt->bytesperline * pixfmt->height >> 1);
632 else
633 pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height;
634
635 return 0;
636 }
637
638 static int vpbe_display_querycap(struct file *file, void *priv,
639 struct v4l2_capability *cap)
640 {
641 struct vpbe_layer *layer = video_drvdata(file);
642 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
643
644 cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
645 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
646 snprintf(cap->driver, sizeof(cap->driver), "%s",
647 dev_name(vpbe_dev->pdev));
648 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
649 dev_name(vpbe_dev->pdev));
650 strlcpy(cap->card, vpbe_dev->cfg->module_name, sizeof(cap->card));
651
652 return 0;
653 }
654
655 static int vpbe_display_s_selection(struct file *file, void *priv,
656 struct v4l2_selection *sel)
657 {
658 struct vpbe_layer *layer = video_drvdata(file);
659 struct vpbe_display *disp_dev = layer->disp_dev;
660 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
661 struct osd_layer_config *cfg = &layer->layer_info.config;
662 struct osd_state *osd_device = disp_dev->osd_device;
663 struct v4l2_rect rect = sel->r;
664 int ret;
665
666 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
667 "VIDIOC_S_SELECTION, layer id = %d\n", layer->device_id);
668
669 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
670 sel->target != V4L2_SEL_TGT_CROP)
671 return -EINVAL;
672
673 if (rect.top < 0)
674 rect.top = 0;
675 if (rect.left < 0)
676 rect.left = 0;
677
678 vpbe_disp_check_window_params(disp_dev, &rect);
679
680 osd_device->ops.get_layer_config(osd_device,
681 layer->layer_info.id, cfg);
682
683 vpbe_disp_calculate_scale_factor(disp_dev, layer,
684 rect.width,
685 rect.height);
686 vpbe_disp_adj_position(disp_dev, layer, rect.top,
687 rect.left);
688 ret = osd_device->ops.set_layer_config(osd_device,
689 layer->layer_info.id, cfg);
690 if (ret < 0) {
691 v4l2_err(&vpbe_dev->v4l2_dev,
692 "Error in set layer config:\n");
693 return -EINVAL;
694 }
695
696 /* apply zooming and h or v expansion */
697 osd_device->ops.set_zoom(osd_device,
698 layer->layer_info.id,
699 layer->layer_info.h_zoom,
700 layer->layer_info.v_zoom);
701 ret = osd_device->ops.set_vid_expansion(osd_device,
702 layer->layer_info.h_exp,
703 layer->layer_info.v_exp);
704 if (ret < 0) {
705 v4l2_err(&vpbe_dev->v4l2_dev,
706 "Error in set vid expansion:\n");
707 return -EINVAL;
708 }
709
710 if ((layer->layer_info.h_zoom != ZOOM_X1) ||
711 (layer->layer_info.v_zoom != ZOOM_X1) ||
712 (layer->layer_info.h_exp != H_EXP_OFF) ||
713 (layer->layer_info.v_exp != V_EXP_OFF))
714 /* Enable expansion filter */
715 osd_device->ops.set_interpolation_filter(osd_device, 1);
716 else
717 osd_device->ops.set_interpolation_filter(osd_device, 0);
718
719 sel->r = rect;
720 return 0;
721 }
722
723 static int vpbe_display_g_selection(struct file *file, void *priv,
724 struct v4l2_selection *sel)
725 {
726 struct vpbe_layer *layer = video_drvdata(file);
727 struct osd_layer_config *cfg = &layer->layer_info.config;
728 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
729 struct osd_state *osd_device = layer->disp_dev->osd_device;
730 struct v4l2_rect *rect = &sel->r;
731
732 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
733 "VIDIOC_G_SELECTION, layer id = %d\n",
734 layer->device_id);
735
736 if (sel->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
737 return -EINVAL;
738
739 switch (sel->target) {
740 case V4L2_SEL_TGT_CROP:
741 osd_device->ops.get_layer_config(osd_device,
742 layer->layer_info.id, cfg);
743 rect->top = cfg->ypos;
744 rect->left = cfg->xpos;
745 rect->width = cfg->xsize;
746 rect->height = cfg->ysize;
747 break;
748 case V4L2_SEL_TGT_CROP_DEFAULT:
749 case V4L2_SEL_TGT_CROP_BOUNDS:
750 rect->left = 0;
751 rect->top = 0;
752 rect->width = vpbe_dev->current_timings.xres;
753 rect->height = vpbe_dev->current_timings.yres;
754 break;
755 default:
756 return -EINVAL;
757 }
758
759 return 0;
760 }
761
762 static int vpbe_display_cropcap(struct file *file, void *priv,
763 struct v4l2_cropcap *cropcap)
764 {
765 struct vpbe_layer *layer = video_drvdata(file);
766 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
767
768 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_CROPCAP ioctl\n");
769
770 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
771 return -EINVAL;
772
773 cropcap->pixelaspect = vpbe_dev->current_timings.aspect;
774 return 0;
775 }
776
777 static int vpbe_display_g_fmt(struct file *file, void *priv,
778 struct v4l2_format *fmt)
779 {
780 struct vpbe_layer *layer = video_drvdata(file);
781 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
782
783 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
784 "VIDIOC_G_FMT, layer id = %d\n",
785 layer->device_id);
786
787 /* If buffer type is video output */
788 if (V4L2_BUF_TYPE_VIDEO_OUTPUT != fmt->type) {
789 v4l2_err(&vpbe_dev->v4l2_dev, "invalid type\n");
790 return -EINVAL;
791 }
792 /* Fill in the information about format */
793 fmt->fmt.pix = layer->pix_fmt;
794
795 return 0;
796 }
797
798 static int vpbe_display_enum_fmt(struct file *file, void *priv,
799 struct v4l2_fmtdesc *fmt)
800 {
801 struct vpbe_layer *layer = video_drvdata(file);
802 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
803 unsigned int index = 0;
804
805 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
806 "VIDIOC_ENUM_FMT, layer id = %d\n",
807 layer->device_id);
808 if (fmt->index > 1) {
809 v4l2_err(&vpbe_dev->v4l2_dev, "Invalid format index\n");
810 return -EINVAL;
811 }
812
813 /* Fill in the information about format */
814 index = fmt->index;
815 memset(fmt, 0, sizeof(*fmt));
816 fmt->index = index;
817 fmt->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
818 if (index == 0) {
819 strcpy(fmt->description, "YUV 4:2:2 - UYVY");
820 fmt->pixelformat = V4L2_PIX_FMT_UYVY;
821 } else {
822 strcpy(fmt->description, "Y/CbCr 4:2:0");
823 fmt->pixelformat = V4L2_PIX_FMT_NV12;
824 }
825
826 return 0;
827 }
828
829 static int vpbe_display_s_fmt(struct file *file, void *priv,
830 struct v4l2_format *fmt)
831 {
832 struct vpbe_layer *layer = video_drvdata(file);
833 struct vpbe_display *disp_dev = layer->disp_dev;
834 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
835 struct osd_layer_config *cfg = &layer->layer_info.config;
836 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
837 struct osd_state *osd_device = disp_dev->osd_device;
838 int ret;
839
840 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
841 "VIDIOC_S_FMT, layer id = %d\n",
842 layer->device_id);
843
844 if (vb2_is_busy(&layer->buffer_queue))
845 return -EBUSY;
846
847 if (V4L2_BUF_TYPE_VIDEO_OUTPUT != fmt->type) {
848 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "invalid type\n");
849 return -EINVAL;
850 }
851 /* Check for valid pixel format */
852 ret = vpbe_try_format(disp_dev, pixfmt, 1);
853 if (ret)
854 return ret;
855
856 /* YUV420 is requested, check availability of the
857 other video window */
858
859 layer->pix_fmt = *pixfmt;
860 if (pixfmt->pixelformat == V4L2_PIX_FMT_NV12) {
861 struct vpbe_layer *otherlayer;
862
863 otherlayer = _vpbe_display_get_other_win_layer(disp_dev, layer);
864 /* if other layer is available, only
865 * claim it, do not configure it
866 */
867 ret = osd_device->ops.request_layer(osd_device,
868 otherlayer->layer_info.id);
869 if (ret < 0) {
870 v4l2_err(&vpbe_dev->v4l2_dev,
871 "Display Manager failed to allocate layer\n");
872 return -EBUSY;
873 }
874 }
875
876 /* Get osd layer config */
877 osd_device->ops.get_layer_config(osd_device,
878 layer->layer_info.id, cfg);
879 /* Store the pixel format in the layer object */
880 cfg->xsize = pixfmt->width;
881 cfg->ysize = pixfmt->height;
882 cfg->line_length = pixfmt->bytesperline;
883 cfg->ypos = 0;
884 cfg->xpos = 0;
885 cfg->interlaced = vpbe_dev->current_timings.interlaced;
886
887 if (V4L2_PIX_FMT_UYVY == pixfmt->pixelformat)
888 cfg->pixfmt = PIXFMT_YCBCRI;
889
890 /* Change of the default pixel format for both video windows */
891 if (V4L2_PIX_FMT_NV12 == pixfmt->pixelformat) {
892 struct vpbe_layer *otherlayer;
893 cfg->pixfmt = PIXFMT_NV12;
894 otherlayer = _vpbe_display_get_other_win_layer(disp_dev,
895 layer);
896 otherlayer->layer_info.config.pixfmt = PIXFMT_NV12;
897 }
898
899 /* Set the layer config in the osd window */
900 ret = osd_device->ops.set_layer_config(osd_device,
901 layer->layer_info.id, cfg);
902 if (ret < 0) {
903 v4l2_err(&vpbe_dev->v4l2_dev,
904 "Error in S_FMT params:\n");
905 return -EINVAL;
906 }
907
908 /* Readback and fill the local copy of current pix format */
909 osd_device->ops.get_layer_config(osd_device,
910 layer->layer_info.id, cfg);
911
912 return 0;
913 }
914
915 static int vpbe_display_try_fmt(struct file *file, void *priv,
916 struct v4l2_format *fmt)
917 {
918 struct vpbe_layer *layer = video_drvdata(file);
919 struct vpbe_display *disp_dev = layer->disp_dev;
920 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
921 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
922
923 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_TRY_FMT\n");
924
925 if (V4L2_BUF_TYPE_VIDEO_OUTPUT != fmt->type) {
926 v4l2_err(&vpbe_dev->v4l2_dev, "invalid type\n");
927 return -EINVAL;
928 }
929
930 /* Check for valid field format */
931 return vpbe_try_format(disp_dev, pixfmt, 0);
932
933 }
934
935 /*
936 * vpbe_display_s_std - Set the given standard in the encoder
937 *
938 * Sets the standard if supported by the current encoder. Return the status.
939 * 0 - success & -EINVAL on error
940 */
941 static int vpbe_display_s_std(struct file *file, void *priv,
942 v4l2_std_id std_id)
943 {
944 struct vpbe_layer *layer = video_drvdata(file);
945 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
946 int ret;
947
948 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_S_STD\n");
949
950 if (vb2_is_busy(&layer->buffer_queue))
951 return -EBUSY;
952
953 if (vpbe_dev->ops.s_std) {
954 ret = vpbe_dev->ops.s_std(vpbe_dev, std_id);
955 if (ret) {
956 v4l2_err(&vpbe_dev->v4l2_dev,
957 "Failed to set standard for sub devices\n");
958 return -EINVAL;
959 }
960 } else {
961 return -EINVAL;
962 }
963
964 return 0;
965 }
966
967 /*
968 * vpbe_display_g_std - Get the standard in the current encoder
969 *
970 * Get the standard in the current encoder. Return the status. 0 - success
971 * -EINVAL on error
972 */
973 static int vpbe_display_g_std(struct file *file, void *priv,
974 v4l2_std_id *std_id)
975 {
976 struct vpbe_layer *layer = video_drvdata(file);
977 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
978
979 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_G_STD\n");
980
981 /* Get the standard from the current encoder */
982 if (vpbe_dev->current_timings.timings_type & VPBE_ENC_STD) {
983 *std_id = vpbe_dev->current_timings.std_id;
984 return 0;
985 }
986
987 return -EINVAL;
988 }
989
990 /*
991 * vpbe_display_enum_output - enumerate outputs
992 *
993 * Enumerates the outputs available at the vpbe display
994 * returns the status, -EINVAL if end of output list
995 */
996 static int vpbe_display_enum_output(struct file *file, void *priv,
997 struct v4l2_output *output)
998 {
999 struct vpbe_layer *layer = video_drvdata(file);
1000 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
1001 int ret;
1002
1003 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_ENUM_OUTPUT\n");
1004
1005 /* Enumerate outputs */
1006 if (!vpbe_dev->ops.enum_outputs)
1007 return -EINVAL;
1008
1009 ret = vpbe_dev->ops.enum_outputs(vpbe_dev, output);
1010 if (ret) {
1011 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
1012 "Failed to enumerate outputs\n");
1013 return -EINVAL;
1014 }
1015
1016 return 0;
1017 }
1018
1019 /*
1020 * vpbe_display_s_output - Set output to
1021 * the output specified by the index
1022 */
1023 static int vpbe_display_s_output(struct file *file, void *priv,
1024 unsigned int i)
1025 {
1026 struct vpbe_layer *layer = video_drvdata(file);
1027 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
1028 int ret;
1029
1030 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_S_OUTPUT\n");
1031
1032 if (vb2_is_busy(&layer->buffer_queue))
1033 return -EBUSY;
1034
1035 if (!vpbe_dev->ops.set_output)
1036 return -EINVAL;
1037
1038 ret = vpbe_dev->ops.set_output(vpbe_dev, i);
1039 if (ret) {
1040 v4l2_err(&vpbe_dev->v4l2_dev,
1041 "Failed to set output for sub devices\n");
1042 return -EINVAL;
1043 }
1044
1045 return 0;
1046 }
1047
1048 /*
1049 * vpbe_display_g_output - Get output from subdevice
1050 * for a given by the index
1051 */
1052 static int vpbe_display_g_output(struct file *file, void *priv,
1053 unsigned int *i)
1054 {
1055 struct vpbe_layer *layer = video_drvdata(file);
1056 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
1057
1058 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_G_OUTPUT\n");
1059 /* Get the standard from the current encoder */
1060 *i = vpbe_dev->current_out_index;
1061
1062 return 0;
1063 }
1064
1065 /*
1066 * vpbe_display_enum_dv_timings - Enumerate the dv timings
1067 *
1068 * enum the timings in the current encoder. Return the status. 0 - success
1069 * -EINVAL on error
1070 */
1071 static int
1072 vpbe_display_enum_dv_timings(struct file *file, void *priv,
1073 struct v4l2_enum_dv_timings *timings)
1074 {
1075 struct vpbe_layer *layer = video_drvdata(file);
1076 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
1077 int ret;
1078
1079 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_ENUM_DV_TIMINGS\n");
1080
1081 /* Enumerate outputs */
1082 if (!vpbe_dev->ops.enum_dv_timings)
1083 return -EINVAL;
1084
1085 ret = vpbe_dev->ops.enum_dv_timings(vpbe_dev, timings);
1086 if (ret) {
1087 v4l2_err(&vpbe_dev->v4l2_dev,
1088 "Failed to enumerate dv timings info\n");
1089 return -EINVAL;
1090 }
1091
1092 return 0;
1093 }
1094
1095 /*
1096 * vpbe_display_s_dv_timings - Set the dv timings
1097 *
1098 * Set the timings in the current encoder. Return the status. 0 - success
1099 * -EINVAL on error
1100 */
1101 static int
1102 vpbe_display_s_dv_timings(struct file *file, void *priv,
1103 struct v4l2_dv_timings *timings)
1104 {
1105 struct vpbe_layer *layer = video_drvdata(file);
1106 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
1107 int ret;
1108
1109 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_S_DV_TIMINGS\n");
1110
1111 if (vb2_is_busy(&layer->buffer_queue))
1112 return -EBUSY;
1113
1114 /* Set the given standard in the encoder */
1115 if (!vpbe_dev->ops.s_dv_timings)
1116 return -EINVAL;
1117
1118 ret = vpbe_dev->ops.s_dv_timings(vpbe_dev, timings);
1119 if (ret) {
1120 v4l2_err(&vpbe_dev->v4l2_dev,
1121 "Failed to set the dv timings info\n");
1122 return -EINVAL;
1123 }
1124
1125 return 0;
1126 }
1127
1128 /*
1129 * vpbe_display_g_dv_timings - Set the dv timings
1130 *
1131 * Get the timings in the current encoder. Return the status. 0 - success
1132 * -EINVAL on error
1133 */
1134 static int
1135 vpbe_display_g_dv_timings(struct file *file, void *priv,
1136 struct v4l2_dv_timings *dv_timings)
1137 {
1138 struct vpbe_layer *layer = video_drvdata(file);
1139 struct vpbe_device *vpbe_dev = layer->disp_dev->vpbe_dev;
1140
1141 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "VIDIOC_G_DV_TIMINGS\n");
1142
1143 /* Get the given standard in the encoder */
1144
1145 if (vpbe_dev->current_timings.timings_type &
1146 VPBE_ENC_DV_TIMINGS) {
1147 *dv_timings = vpbe_dev->current_timings.dv_timings;
1148 } else {
1149 return -EINVAL;
1150 }
1151
1152 return 0;
1153 }
1154
1155 /*
1156 * vpbe_display_open()
1157 * It creates object of file handle structure and stores it in private_data
1158 * member of filepointer
1159 */
1160 static int vpbe_display_open(struct file *file)
1161 {
1162 struct vpbe_layer *layer = video_drvdata(file);
1163 struct vpbe_display *disp_dev = layer->disp_dev;
1164 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
1165 struct osd_state *osd_device = disp_dev->osd_device;
1166 int err;
1167
1168 /* creating context for file descriptor */
1169 err = v4l2_fh_open(file);
1170 if (err) {
1171 v4l2_err(&vpbe_dev->v4l2_dev, "v4l2_fh_open failed\n");
1172 return err;
1173 }
1174
1175 /* leaving if layer is already initialized */
1176 if (!v4l2_fh_is_singular_file(file))
1177 return err;
1178
1179 if (!layer->usrs) {
1180 if (mutex_lock_interruptible(&layer->opslock))
1181 return -ERESTARTSYS;
1182 /* First claim the layer for this device */
1183 err = osd_device->ops.request_layer(osd_device,
1184 layer->layer_info.id);
1185 mutex_unlock(&layer->opslock);
1186 if (err < 0) {
1187 /* Couldn't get layer */
1188 v4l2_err(&vpbe_dev->v4l2_dev,
1189 "Display Manager failed to allocate layer\n");
1190 v4l2_fh_release(file);
1191 return -EINVAL;
1192 }
1193 }
1194 /* Increment layer usrs counter */
1195 layer->usrs++;
1196 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
1197 "vpbe display device opened successfully\n");
1198 return 0;
1199 }
1200
1201 /*
1202 * vpbe_display_release()
1203 * This function deletes buffer queue, frees the buffers and the davinci
1204 * display file * handle
1205 */
1206 static int vpbe_display_release(struct file *file)
1207 {
1208 struct vpbe_layer *layer = video_drvdata(file);
1209 struct osd_layer_config *cfg = &layer->layer_info.config;
1210 struct vpbe_display *disp_dev = layer->disp_dev;
1211 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
1212 struct osd_state *osd_device = disp_dev->osd_device;
1213
1214 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_display_release\n");
1215
1216 mutex_lock(&layer->opslock);
1217
1218 osd_device->ops.disable_layer(osd_device,
1219 layer->layer_info.id);
1220 /* Decrement layer usrs counter */
1221 layer->usrs--;
1222 /* If this file handle has initialize encoder device, reset it */
1223 if (!layer->usrs) {
1224 if (cfg->pixfmt == PIXFMT_NV12) {
1225 struct vpbe_layer *otherlayer;
1226 otherlayer =
1227 _vpbe_display_get_other_win_layer(disp_dev, layer);
1228 osd_device->ops.disable_layer(osd_device,
1229 otherlayer->layer_info.id);
1230 osd_device->ops.release_layer(osd_device,
1231 otherlayer->layer_info.id);
1232 }
1233 osd_device->ops.disable_layer(osd_device,
1234 layer->layer_info.id);
1235 osd_device->ops.release_layer(osd_device,
1236 layer->layer_info.id);
1237 }
1238
1239 _vb2_fop_release(file, NULL);
1240 mutex_unlock(&layer->opslock);
1241
1242 disp_dev->cbcr_ofst = 0;
1243
1244 return 0;
1245 }
1246
1247 /* vpbe capture ioctl operations */
1248 static const struct v4l2_ioctl_ops vpbe_ioctl_ops = {
1249 .vidioc_querycap = vpbe_display_querycap,
1250 .vidioc_g_fmt_vid_out = vpbe_display_g_fmt,
1251 .vidioc_enum_fmt_vid_out = vpbe_display_enum_fmt,
1252 .vidioc_s_fmt_vid_out = vpbe_display_s_fmt,
1253 .vidioc_try_fmt_vid_out = vpbe_display_try_fmt,
1254
1255 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1256 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1257 .vidioc_querybuf = vb2_ioctl_querybuf,
1258 .vidioc_qbuf = vb2_ioctl_qbuf,
1259 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1260 .vidioc_streamon = vb2_ioctl_streamon,
1261 .vidioc_streamoff = vb2_ioctl_streamoff,
1262 .vidioc_expbuf = vb2_ioctl_expbuf,
1263
1264 .vidioc_cropcap = vpbe_display_cropcap,
1265 .vidioc_g_selection = vpbe_display_g_selection,
1266 .vidioc_s_selection = vpbe_display_s_selection,
1267
1268 .vidioc_s_std = vpbe_display_s_std,
1269 .vidioc_g_std = vpbe_display_g_std,
1270
1271 .vidioc_enum_output = vpbe_display_enum_output,
1272 .vidioc_s_output = vpbe_display_s_output,
1273 .vidioc_g_output = vpbe_display_g_output,
1274
1275 .vidioc_s_dv_timings = vpbe_display_s_dv_timings,
1276 .vidioc_g_dv_timings = vpbe_display_g_dv_timings,
1277 .vidioc_enum_dv_timings = vpbe_display_enum_dv_timings,
1278 };
1279
1280 static const struct v4l2_file_operations vpbe_fops = {
1281 .owner = THIS_MODULE,
1282 .open = vpbe_display_open,
1283 .release = vpbe_display_release,
1284 .unlocked_ioctl = video_ioctl2,
1285 .mmap = vb2_fop_mmap,
1286 .poll = vb2_fop_poll,
1287 };
1288
1289 static int vpbe_device_get(struct device *dev, void *data)
1290 {
1291 struct platform_device *pdev = to_platform_device(dev);
1292 struct vpbe_display *vpbe_disp = data;
1293
1294 if (strcmp("vpbe_controller", pdev->name) == 0)
1295 vpbe_disp->vpbe_dev = platform_get_drvdata(pdev);
1296
1297 if (strstr(pdev->name, "vpbe-osd"))
1298 vpbe_disp->osd_device = platform_get_drvdata(pdev);
1299
1300 return 0;
1301 }
1302
1303 static int init_vpbe_layer(int i, struct vpbe_display *disp_dev,
1304 struct platform_device *pdev)
1305 {
1306 struct vpbe_layer *vpbe_display_layer = NULL;
1307 struct video_device *vbd = NULL;
1308
1309 /* Allocate memory for four plane display objects */
1310 disp_dev->dev[i] = kzalloc(sizeof(*disp_dev->dev[i]), GFP_KERNEL);
1311 if (!disp_dev->dev[i])
1312 return -ENOMEM;
1313
1314 spin_lock_init(&disp_dev->dev[i]->irqlock);
1315 mutex_init(&disp_dev->dev[i]->opslock);
1316
1317 /* Get the pointer to the layer object */
1318 vpbe_display_layer = disp_dev->dev[i];
1319 vbd = &vpbe_display_layer->video_dev;
1320 /* Initialize field of video device */
1321 vbd->release = video_device_release_empty;
1322 vbd->fops = &vpbe_fops;
1323 vbd->ioctl_ops = &vpbe_ioctl_ops;
1324 vbd->minor = -1;
1325 vbd->v4l2_dev = &disp_dev->vpbe_dev->v4l2_dev;
1326 vbd->lock = &vpbe_display_layer->opslock;
1327 vbd->vfl_dir = VFL_DIR_TX;
1328
1329 if (disp_dev->vpbe_dev->current_timings.timings_type &
1330 VPBE_ENC_STD)
1331 vbd->tvnorms = (V4L2_STD_525_60 | V4L2_STD_625_50);
1332
1333 snprintf(vbd->name, sizeof(vbd->name),
1334 "DaVinci_VPBE Display_DRIVER_V%d.%d.%d",
1335 (VPBE_DISPLAY_VERSION_CODE >> 16) & 0xff,
1336 (VPBE_DISPLAY_VERSION_CODE >> 8) & 0xff,
1337 (VPBE_DISPLAY_VERSION_CODE) & 0xff);
1338
1339 vpbe_display_layer->device_id = i;
1340
1341 vpbe_display_layer->layer_info.id =
1342 ((i == VPBE_DISPLAY_DEVICE_0) ? WIN_VID0 : WIN_VID1);
1343
1344
1345 return 0;
1346 }
1347
1348 static int register_device(struct vpbe_layer *vpbe_display_layer,
1349 struct vpbe_display *disp_dev,
1350 struct platform_device *pdev)
1351 {
1352 int err;
1353
1354 v4l2_info(&disp_dev->vpbe_dev->v4l2_dev,
1355 "Trying to register VPBE display device.\n");
1356 v4l2_info(&disp_dev->vpbe_dev->v4l2_dev,
1357 "layer=%p,layer->video_dev=%p\n",
1358 vpbe_display_layer,
1359 &vpbe_display_layer->video_dev);
1360
1361 vpbe_display_layer->video_dev.queue = &vpbe_display_layer->buffer_queue;
1362 err = video_register_device(&vpbe_display_layer->video_dev,
1363 VFL_TYPE_GRABBER,
1364 -1);
1365 if (err)
1366 return -ENODEV;
1367
1368 vpbe_display_layer->disp_dev = disp_dev;
1369 /* set the driver data in platform device */
1370 platform_set_drvdata(pdev, disp_dev);
1371 video_set_drvdata(&vpbe_display_layer->video_dev,
1372 vpbe_display_layer);
1373
1374 return 0;
1375 }
1376
1377
1378
1379 /*
1380 * vpbe_display_probe()
1381 * This function creates device entries by register itself to the V4L2 driver
1382 * and initializes fields of each layer objects
1383 */
1384 static int vpbe_display_probe(struct platform_device *pdev)
1385 {
1386 struct vpbe_display *disp_dev;
1387 struct v4l2_device *v4l2_dev;
1388 struct resource *res = NULL;
1389 struct vb2_queue *q;
1390 int k;
1391 int i;
1392 int err;
1393 int irq;
1394
1395 printk(KERN_DEBUG "vpbe_display_probe\n");
1396 /* Allocate memory for vpbe_display */
1397 disp_dev = devm_kzalloc(&pdev->dev, sizeof(*disp_dev), GFP_KERNEL);
1398 if (!disp_dev)
1399 return -ENOMEM;
1400
1401 spin_lock_init(&disp_dev->dma_queue_lock);
1402 /*
1403 * Scan all the platform devices to find the vpbe
1404 * controller device and get the vpbe_dev object
1405 */
1406 err = bus_for_each_dev(&platform_bus_type, NULL, disp_dev,
1407 vpbe_device_get);
1408 if (err < 0)
1409 return err;
1410
1411 v4l2_dev = &disp_dev->vpbe_dev->v4l2_dev;
1412 /* Initialize the vpbe display controller */
1413 if (disp_dev->vpbe_dev->ops.initialize) {
1414 err = disp_dev->vpbe_dev->ops.initialize(&pdev->dev,
1415 disp_dev->vpbe_dev);
1416 if (err) {
1417 v4l2_err(v4l2_dev, "Error initing vpbe\n");
1418 err = -ENOMEM;
1419 goto probe_out;
1420 }
1421 }
1422
1423 for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
1424 if (init_vpbe_layer(i, disp_dev, pdev)) {
1425 err = -ENODEV;
1426 goto probe_out;
1427 }
1428 }
1429
1430 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1431 if (!res) {
1432 v4l2_err(v4l2_dev, "Unable to get VENC interrupt resource\n");
1433 err = -ENODEV;
1434 goto probe_out;
1435 }
1436
1437 irq = res->start;
1438 err = devm_request_irq(&pdev->dev, irq, venc_isr, 0,
1439 VPBE_DISPLAY_DRIVER, disp_dev);
1440 if (err) {
1441 v4l2_err(v4l2_dev, "VPBE IRQ request failed\n");
1442 goto probe_out;
1443 }
1444
1445 for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
1446 /* initialize vb2 queue */
1447 q = &disp_dev->dev[i]->buffer_queue;
1448 memset(q, 0, sizeof(*q));
1449 q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1450 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1451 q->drv_priv = disp_dev->dev[i];
1452 q->ops = &video_qops;
1453 q->mem_ops = &vb2_dma_contig_memops;
1454 q->buf_struct_size = sizeof(struct vpbe_disp_buffer);
1455 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1456 q->min_buffers_needed = 1;
1457 q->lock = &disp_dev->dev[i]->opslock;
1458 q->dev = disp_dev->vpbe_dev->pdev;
1459 err = vb2_queue_init(q);
1460 if (err) {
1461 v4l2_err(v4l2_dev, "vb2_queue_init() failed\n");
1462 goto probe_out;
1463 }
1464
1465 INIT_LIST_HEAD(&disp_dev->dev[i]->dma_queue);
1466
1467 if (register_device(disp_dev->dev[i], disp_dev, pdev)) {
1468 err = -ENODEV;
1469 goto probe_out;
1470 }
1471 }
1472
1473 v4l2_dbg(1, debug, v4l2_dev,
1474 "Successfully completed the probing of vpbe v4l2 device\n");
1475
1476 return 0;
1477
1478 probe_out:
1479 for (k = 0; k < VPBE_DISPLAY_MAX_DEVICES; k++) {
1480 /* Unregister video device */
1481 if (disp_dev->dev[k]) {
1482 video_unregister_device(&disp_dev->dev[k]->video_dev);
1483 kfree(disp_dev->dev[k]);
1484 }
1485 }
1486 return err;
1487 }
1488
1489 /*
1490 * vpbe_display_remove()
1491 * It un-register hardware layer from V4L2 driver
1492 */
1493 static int vpbe_display_remove(struct platform_device *pdev)
1494 {
1495 struct vpbe_layer *vpbe_display_layer;
1496 struct vpbe_display *disp_dev = platform_get_drvdata(pdev);
1497 struct vpbe_device *vpbe_dev = disp_dev->vpbe_dev;
1498 int i;
1499
1500 v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev, "vpbe_display_remove\n");
1501
1502 /* deinitialize the vpbe display controller */
1503 if (vpbe_dev->ops.deinitialize)
1504 vpbe_dev->ops.deinitialize(&pdev->dev, vpbe_dev);
1505 /* un-register device */
1506 for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
1507 /* Get the pointer to the layer object */
1508 vpbe_display_layer = disp_dev->dev[i];
1509 /* Unregister video device */
1510 video_unregister_device(&vpbe_display_layer->video_dev);
1511
1512 }
1513 for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
1514 kfree(disp_dev->dev[i]);
1515 disp_dev->dev[i] = NULL;
1516 }
1517
1518 return 0;
1519 }
1520
1521 static struct platform_driver vpbe_display_driver = {
1522 .driver = {
1523 .name = VPBE_DISPLAY_DRIVER,
1524 .bus = &platform_bus_type,
1525 },
1526 .probe = vpbe_display_probe,
1527 .remove = vpbe_display_remove,
1528 };
1529
1530 module_platform_driver(vpbe_display_driver);
1531
1532 MODULE_DESCRIPTION("TI DM644x/DM355/DM365 VPBE Display controller");
1533 MODULE_LICENSE("GPL");
1534 MODULE_AUTHOR("Texas Instruments");
Linux with added FPC-III support