1 /*
2 * sh-mobile VEU mem2mem driver
3 *
4 * Copyright (C) 2012 Renesas Electronics Corporation
5 * Author: Guennadi Liakhovetski, <g.liakhovetski@gmx.de>
6 * Copyright (C) 2008 Magnus Damm
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the version 2 of the GNU General Public License as
10 * published by the Free Software Foundation
11 */
12
13 #include <linux/err.h>
14 #include <linux/fs.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/interrupt.h>
18 #include <linux/io.h>
19 #include <linux/platform_device.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/slab.h>
22 #include <linux/types.h>
23 #include <linux/videodev2.h>
24
25 #include <media/v4l2-dev.h>
26 #include <media/v4l2-device.h>
27 #include <media/v4l2-ioctl.h>
28 #include <media/v4l2-mem2mem.h>
29 #include <media/v4l2-image-sizes.h>
30 #include <media/videobuf2-dma-contig.h>
31
32 #define VEU_STR 0x00 /* start register */
33 #define VEU_SWR 0x10 /* src: line length */
34 #define VEU_SSR 0x14 /* src: image size */
35 #define VEU_SAYR 0x18 /* src: y/rgb plane address */
36 #define VEU_SACR 0x1c /* src: c plane address */
37 #define VEU_BSSR 0x20 /* bundle mode register */
38 #define VEU_EDWR 0x30 /* dst: line length */
39 #define VEU_DAYR 0x34 /* dst: y/rgb plane address */
40 #define VEU_DACR 0x38 /* dst: c plane address */
41 #define VEU_TRCR 0x50 /* transform control */
42 #define VEU_RFCR 0x54 /* resize scale */
43 #define VEU_RFSR 0x58 /* resize clip */
44 #define VEU_ENHR 0x5c /* enhance */
45 #define VEU_FMCR 0x70 /* filter mode */
46 #define VEU_VTCR 0x74 /* lowpass vertical */
47 #define VEU_HTCR 0x78 /* lowpass horizontal */
48 #define VEU_APCR 0x80 /* color match */
49 #define VEU_ECCR 0x84 /* color replace */
50 #define VEU_AFXR 0x90 /* fixed mode */
51 #define VEU_SWPR 0x94 /* swap */
52 #define VEU_EIER 0xa0 /* interrupt mask */
53 #define VEU_EVTR 0xa4 /* interrupt event */
54 #define VEU_STAR 0xb0 /* status */
55 #define VEU_BSRR 0xb4 /* reset */
56
57 #define VEU_MCR00 0x200 /* color conversion matrix coefficient 00 */
58 #define VEU_MCR01 0x204 /* color conversion matrix coefficient 01 */
59 #define VEU_MCR02 0x208 /* color conversion matrix coefficient 02 */
60 #define VEU_MCR10 0x20c /* color conversion matrix coefficient 10 */
61 #define VEU_MCR11 0x210 /* color conversion matrix coefficient 11 */
62 #define VEU_MCR12 0x214 /* color conversion matrix coefficient 12 */
63 #define VEU_MCR20 0x218 /* color conversion matrix coefficient 20 */
64 #define VEU_MCR21 0x21c /* color conversion matrix coefficient 21 */
65 #define VEU_MCR22 0x220 /* color conversion matrix coefficient 22 */
66 #define VEU_COFFR 0x224 /* color conversion offset */
67 #define VEU_CBR 0x228 /* color conversion clip */
68
69 /*
70 * 4092x4092 max size is the normal case. In some cases it can be reduced to
71 * 2048x2048, in other cases it can be 4092x8188 or even 8188x8188.
72 */
73 #define MAX_W 4092
74 #define MAX_H 4092
75 #define MIN_W 8
76 #define MIN_H 8
77 #define ALIGN_W 4
78
79 /* 3 buffers of 2048 x 1536 - 3 megapixels @ 16bpp */
80 #define VIDEO_MEM_LIMIT ALIGN(2048 * 1536 * 2 * 3, 1024 * 1024)
81
82 #define MEM2MEM_DEF_TRANSLEN 1
83
84 struct sh_veu_dev;
85
86 struct sh_veu_file {
87 struct sh_veu_dev *veu_dev;
88 bool cfg_needed;
89 };
90
91 struct sh_veu_format {
92 char *name;
93 u32 fourcc;
94 unsigned int depth;
95 unsigned int ydepth;
96 };
97
98 /* video data format */
99 struct sh_veu_vfmt {
100 /* Replace with v4l2_rect */
101 struct v4l2_rect frame;
102 unsigned int bytesperline;
103 unsigned int offset_y;
104 unsigned int offset_c;
105 const struct sh_veu_format *fmt;
106 };
107
108 struct sh_veu_dev {
109 struct v4l2_device v4l2_dev;
110 struct video_device vdev;
111 struct v4l2_m2m_dev *m2m_dev;
112 struct device *dev;
113 struct v4l2_m2m_ctx *m2m_ctx;
114 struct sh_veu_vfmt vfmt_out;
115 struct sh_veu_vfmt vfmt_in;
116 /* Only single user per direction so far */
117 struct sh_veu_file *capture;
118 struct sh_veu_file *output;
119 struct mutex fop_lock;
120 void __iomem *base;
121 struct vb2_alloc_ctx *alloc_ctx;
122 spinlock_t lock;
123 bool is_2h;
124 unsigned int xaction;
125 bool aborting;
126 };
127
128 enum sh_veu_fmt_idx {
129 SH_VEU_FMT_NV12,
130 SH_VEU_FMT_NV16,
131 SH_VEU_FMT_NV24,
132 SH_VEU_FMT_RGB332,
133 SH_VEU_FMT_RGB444,
134 SH_VEU_FMT_RGB565,
135 SH_VEU_FMT_RGB666,
136 SH_VEU_FMT_RGB24,
137 };
138
139 #define DEFAULT_IN_WIDTH VGA_WIDTH
140 #define DEFAULT_IN_HEIGHT VGA_HEIGHT
141 #define DEFAULT_IN_FMTIDX SH_VEU_FMT_NV12
142 #define DEFAULT_OUT_WIDTH VGA_WIDTH
143 #define DEFAULT_OUT_HEIGHT VGA_HEIGHT
144 #define DEFAULT_OUT_FMTIDX SH_VEU_FMT_RGB565
145
146 /*
147 * Alignment: Y-plane should be 4-byte aligned for NV12 and NV16, and 8-byte
148 * aligned for NV24.
149 */
150 static const struct sh_veu_format sh_veu_fmt[] = {
151 [SH_VEU_FMT_NV12] = { .ydepth = 8, .depth = 12, .name = "NV12", .fourcc = V4L2_PIX_FMT_NV12 },
152 [SH_VEU_FMT_NV16] = { .ydepth = 8, .depth = 16, .name = "NV16", .fourcc = V4L2_PIX_FMT_NV16 },
153 [SH_VEU_FMT_NV24] = { .ydepth = 8, .depth = 24, .name = "NV24", .fourcc = V4L2_PIX_FMT_NV24 },
154 [SH_VEU_FMT_RGB332] = { .ydepth = 8, .depth = 8, .name = "RGB332", .fourcc = V4L2_PIX_FMT_RGB332 },
155 [SH_VEU_FMT_RGB444] = { .ydepth = 16, .depth = 16, .name = "RGB444", .fourcc = V4L2_PIX_FMT_RGB444 },
156 [SH_VEU_FMT_RGB565] = { .ydepth = 16, .depth = 16, .name = "RGB565", .fourcc = V4L2_PIX_FMT_RGB565 },
157 [SH_VEU_FMT_RGB666] = { .ydepth = 32, .depth = 32, .name = "BGR666", .fourcc = V4L2_PIX_FMT_BGR666 },
158 [SH_VEU_FMT_RGB24] = { .ydepth = 24, .depth = 24, .name = "RGB24", .fourcc = V4L2_PIX_FMT_RGB24 },
159 };
160
161 #define DEFAULT_IN_VFMT (struct sh_veu_vfmt){ \
162 .frame = { \
163 .width = VGA_WIDTH, \
164 .height = VGA_HEIGHT, \
165 }, \
166 .bytesperline = (VGA_WIDTH * sh_veu_fmt[DEFAULT_IN_FMTIDX].ydepth) >> 3, \
167 .fmt = &sh_veu_fmt[DEFAULT_IN_FMTIDX], \
168 }
169
170 #define DEFAULT_OUT_VFMT (struct sh_veu_vfmt){ \
171 .frame = { \
172 .width = VGA_WIDTH, \
173 .height = VGA_HEIGHT, \
174 }, \
175 .bytesperline = (VGA_WIDTH * sh_veu_fmt[DEFAULT_OUT_FMTIDX].ydepth) >> 3, \
176 .fmt = &sh_veu_fmt[DEFAULT_OUT_FMTIDX], \
177 }
178
179 /*
180 * TODO: add support for further output formats:
181 * SH_VEU_FMT_NV12,
182 * SH_VEU_FMT_NV16,
183 * SH_VEU_FMT_NV24,
184 * SH_VEU_FMT_RGB332,
185 * SH_VEU_FMT_RGB444,
186 * SH_VEU_FMT_RGB666,
187 * SH_VEU_FMT_RGB24,
188 */
189
190 static const int sh_veu_fmt_out[] = {
191 SH_VEU_FMT_RGB565,
192 };
193
194 /*
195 * TODO: add support for further input formats:
196 * SH_VEU_FMT_NV16,
197 * SH_VEU_FMT_NV24,
198 * SH_VEU_FMT_RGB565,
199 * SH_VEU_FMT_RGB666,
200 * SH_VEU_FMT_RGB24,
201 */
202 static const int sh_veu_fmt_in[] = {
203 SH_VEU_FMT_NV12,
204 };
205
sh_veu_4cc2cspace(u32 fourcc)206 static enum v4l2_colorspace sh_veu_4cc2cspace(u32 fourcc)
207 {
208 switch (fourcc) {
209 default:
210 BUG();
211 case V4L2_PIX_FMT_NV12:
212 case V4L2_PIX_FMT_NV16:
213 case V4L2_PIX_FMT_NV24:
214 return V4L2_COLORSPACE_SMPTE170M;
215 case V4L2_PIX_FMT_RGB332:
216 case V4L2_PIX_FMT_RGB444:
217 case V4L2_PIX_FMT_RGB565:
218 case V4L2_PIX_FMT_BGR666:
219 case V4L2_PIX_FMT_RGB24:
220 return V4L2_COLORSPACE_SRGB;
221 }
222 }
223
sh_veu_reg_read(struct sh_veu_dev * veu,unsigned int reg)224 static u32 sh_veu_reg_read(struct sh_veu_dev *veu, unsigned int reg)
225 {
226 return ioread32(veu->base + reg);
227 }
228
sh_veu_reg_write(struct sh_veu_dev * veu,unsigned int reg,u32 value)229 static void sh_veu_reg_write(struct sh_veu_dev *veu, unsigned int reg,
230 u32 value)
231 {
232 iowrite32(value, veu->base + reg);
233 }
234
235 /* ========== mem2mem callbacks ========== */
236
sh_veu_job_abort(void * priv)237 static void sh_veu_job_abort(void *priv)
238 {
239 struct sh_veu_dev *veu = priv;
240
241 /* Will cancel the transaction in the next interrupt handler */
242 veu->aborting = true;
243 }
244
sh_veu_process(struct sh_veu_dev * veu,struct vb2_buffer * src_buf,struct vb2_buffer * dst_buf)245 static void sh_veu_process(struct sh_veu_dev *veu,
246 struct vb2_buffer *src_buf,
247 struct vb2_buffer *dst_buf)
248 {
249 dma_addr_t addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
250
251 sh_veu_reg_write(veu, VEU_DAYR, addr + veu->vfmt_out.offset_y);
252 sh_veu_reg_write(veu, VEU_DACR, veu->vfmt_out.offset_c ?
253 addr + veu->vfmt_out.offset_c : 0);
254 dev_dbg(veu->dev, "%s(): dst base %lx, y: %x, c: %x\n", __func__,
255 (unsigned long)addr,
256 veu->vfmt_out.offset_y, veu->vfmt_out.offset_c);
257
258 addr = vb2_dma_contig_plane_dma_addr(src_buf, 0);
259 sh_veu_reg_write(veu, VEU_SAYR, addr + veu->vfmt_in.offset_y);
260 sh_veu_reg_write(veu, VEU_SACR, veu->vfmt_in.offset_c ?
261 addr + veu->vfmt_in.offset_c : 0);
262 dev_dbg(veu->dev, "%s(): src base %lx, y: %x, c: %x\n", __func__,
263 (unsigned long)addr,
264 veu->vfmt_in.offset_y, veu->vfmt_in.offset_c);
265
266 sh_veu_reg_write(veu, VEU_STR, 1);
267
268 sh_veu_reg_write(veu, VEU_EIER, 1); /* enable interrupt in VEU */
269 }
270
271 /**
272 * sh_veu_device_run() - prepares and starts the device
273 *
274 * This will be called by the framework when it decides to schedule a particular
275 * instance.
276 */
sh_veu_device_run(void * priv)277 static void sh_veu_device_run(void *priv)
278 {
279 struct sh_veu_dev *veu = priv;
280 struct vb2_v4l2_buffer *src_buf, *dst_buf;
281
282 src_buf = v4l2_m2m_next_src_buf(veu->m2m_ctx);
283 dst_buf = v4l2_m2m_next_dst_buf(veu->m2m_ctx);
284
285 if (src_buf && dst_buf)
286 sh_veu_process(veu, &src_buf->vb2_buf, &dst_buf->vb2_buf);
287 }
288
289 /* ========== video ioctls ========== */
290
sh_veu_is_streamer(struct sh_veu_dev * veu,struct sh_veu_file * veu_file,enum v4l2_buf_type type)291 static bool sh_veu_is_streamer(struct sh_veu_dev *veu, struct sh_veu_file *veu_file,
292 enum v4l2_buf_type type)
293 {
294 return (type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
295 veu_file == veu->capture) ||
296 (type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
297 veu_file == veu->output);
298 }
299
300 static int sh_veu_queue_init(void *priv, struct vb2_queue *src_vq,
301 struct vb2_queue *dst_vq);
302
303 /*
304 * It is not unusual to have video nodes open()ed multiple times. While some
305 * V4L2 operations are non-intrusive, like querying formats and various
306 * parameters, others, like setting formats, starting and stopping streaming,
307 * queuing and dequeuing buffers, directly affect hardware configuration and /
308 * or execution. This function verifies availability of the requested interface
309 * and, if available, reserves it for the requesting user.
310 */
sh_veu_stream_init(struct sh_veu_dev * veu,struct sh_veu_file * veu_file,enum v4l2_buf_type type)311 static int sh_veu_stream_init(struct sh_veu_dev *veu, struct sh_veu_file *veu_file,
312 enum v4l2_buf_type type)
313 {
314 struct sh_veu_file **stream;
315
316 switch (type) {
317 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
318 stream = &veu->capture;
319 break;
320 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
321 stream = &veu->output;
322 break;
323 default:
324 return -EINVAL;
325 }
326
327 if (*stream == veu_file)
328 return 0;
329
330 if (*stream)
331 return -EBUSY;
332
333 *stream = veu_file;
334
335 return 0;
336 }
337
sh_veu_context_init(struct sh_veu_dev * veu)338 static int sh_veu_context_init(struct sh_veu_dev *veu)
339 {
340 if (veu->m2m_ctx)
341 return 0;
342
343 veu->m2m_ctx = v4l2_m2m_ctx_init(veu->m2m_dev, veu,
344 sh_veu_queue_init);
345
346 return PTR_ERR_OR_ZERO(veu->m2m_ctx);
347 }
348
sh_veu_querycap(struct file * file,void * priv,struct v4l2_capability * cap)349 static int sh_veu_querycap(struct file *file, void *priv,
350 struct v4l2_capability *cap)
351 {
352 strlcpy(cap->driver, "sh-veu", sizeof(cap->driver));
353 strlcpy(cap->card, "sh-mobile VEU", sizeof(cap->card));
354 strlcpy(cap->bus_info, "platform:sh-veu", sizeof(cap->bus_info));
355 cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
356 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
357
358 return 0;
359 }
360
sh_veu_enum_fmt(struct v4l2_fmtdesc * f,const int * fmt,int fmt_num)361 static int sh_veu_enum_fmt(struct v4l2_fmtdesc *f, const int *fmt, int fmt_num)
362 {
363 if (f->index >= fmt_num)
364 return -EINVAL;
365
366 strlcpy(f->description, sh_veu_fmt[fmt[f->index]].name, sizeof(f->description));
367 f->pixelformat = sh_veu_fmt[fmt[f->index]].fourcc;
368 return 0;
369 }
370
sh_veu_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)371 static int sh_veu_enum_fmt_vid_cap(struct file *file, void *priv,
372 struct v4l2_fmtdesc *f)
373 {
374 return sh_veu_enum_fmt(f, sh_veu_fmt_out, ARRAY_SIZE(sh_veu_fmt_out));
375 }
376
sh_veu_enum_fmt_vid_out(struct file * file,void * priv,struct v4l2_fmtdesc * f)377 static int sh_veu_enum_fmt_vid_out(struct file *file, void *priv,
378 struct v4l2_fmtdesc *f)
379 {
380 return sh_veu_enum_fmt(f, sh_veu_fmt_in, ARRAY_SIZE(sh_veu_fmt_in));
381 }
382
sh_veu_get_vfmt(struct sh_veu_dev * veu,enum v4l2_buf_type type)383 static struct sh_veu_vfmt *sh_veu_get_vfmt(struct sh_veu_dev *veu,
384 enum v4l2_buf_type type)
385 {
386 switch (type) {
387 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
388 return &veu->vfmt_out;
389 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
390 return &veu->vfmt_in;
391 default:
392 return NULL;
393 }
394 }
395
sh_veu_g_fmt(struct sh_veu_file * veu_file,struct v4l2_format * f)396 static int sh_veu_g_fmt(struct sh_veu_file *veu_file, struct v4l2_format *f)
397 {
398 struct v4l2_pix_format *pix = &f->fmt.pix;
399 struct sh_veu_dev *veu = veu_file->veu_dev;
400 struct sh_veu_vfmt *vfmt;
401
402 vfmt = sh_veu_get_vfmt(veu, f->type);
403
404 pix->width = vfmt->frame.width;
405 pix->height = vfmt->frame.height;
406 pix->field = V4L2_FIELD_NONE;
407 pix->pixelformat = vfmt->fmt->fourcc;
408 pix->colorspace = sh_veu_4cc2cspace(pix->pixelformat);
409 pix->bytesperline = vfmt->bytesperline;
410 pix->sizeimage = vfmt->bytesperline * pix->height *
411 vfmt->fmt->depth / vfmt->fmt->ydepth;
412 dev_dbg(veu->dev, "%s(): type: %d, size %u @ %ux%u, fmt %x\n", __func__,
413 f->type, pix->sizeimage, pix->width, pix->height, pix->pixelformat);
414
415 return 0;
416 }
417
sh_veu_g_fmt_vid_out(struct file * file,void * priv,struct v4l2_format * f)418 static int sh_veu_g_fmt_vid_out(struct file *file, void *priv,
419 struct v4l2_format *f)
420 {
421 return sh_veu_g_fmt(priv, f);
422 }
423
sh_veu_g_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)424 static int sh_veu_g_fmt_vid_cap(struct file *file, void *priv,
425 struct v4l2_format *f)
426 {
427 return sh_veu_g_fmt(priv, f);
428 }
429
sh_veu_try_fmt(struct v4l2_format * f,const struct sh_veu_format * fmt)430 static int sh_veu_try_fmt(struct v4l2_format *f, const struct sh_veu_format *fmt)
431 {
432 struct v4l2_pix_format *pix = &f->fmt.pix;
433 unsigned int y_bytes_used;
434
435 /*
436 * V4L2 specification suggests, that the driver should correct the
437 * format struct if any of the dimensions is unsupported
438 */
439 switch (pix->field) {
440 default:
441 case V4L2_FIELD_ANY:
442 pix->field = V4L2_FIELD_NONE;
443 /* fall through: continue handling V4L2_FIELD_NONE */
444 case V4L2_FIELD_NONE:
445 break;
446 }
447
448 v4l_bound_align_image(&pix->width, MIN_W, MAX_W, ALIGN_W,
449 &pix->height, MIN_H, MAX_H, 0, 0);
450
451 y_bytes_used = (pix->width * fmt->ydepth) >> 3;
452
453 if (pix->bytesperline < y_bytes_used)
454 pix->bytesperline = y_bytes_used;
455 pix->sizeimage = pix->height * pix->bytesperline * fmt->depth / fmt->ydepth;
456
457 pix->pixelformat = fmt->fourcc;
458 pix->colorspace = sh_veu_4cc2cspace(pix->pixelformat);
459
460 pr_debug("%s(): type: %d, size %u\n", __func__, f->type, pix->sizeimage);
461
462 return 0;
463 }
464
sh_veu_find_fmt(const struct v4l2_format * f)465 static const struct sh_veu_format *sh_veu_find_fmt(const struct v4l2_format *f)
466 {
467 const int *fmt;
468 int i, n, dflt;
469
470 pr_debug("%s(%d;%d)\n", __func__, f->type, f->fmt.pix.field);
471
472 switch (f->type) {
473 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
474 fmt = sh_veu_fmt_out;
475 n = ARRAY_SIZE(sh_veu_fmt_out);
476 dflt = DEFAULT_OUT_FMTIDX;
477 break;
478 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
479 default:
480 fmt = sh_veu_fmt_in;
481 n = ARRAY_SIZE(sh_veu_fmt_in);
482 dflt = DEFAULT_IN_FMTIDX;
483 break;
484 }
485
486 for (i = 0; i < n; i++)
487 if (sh_veu_fmt[fmt[i]].fourcc == f->fmt.pix.pixelformat)
488 return &sh_veu_fmt[fmt[i]];
489
490 return &sh_veu_fmt[dflt];
491 }
492
sh_veu_try_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)493 static int sh_veu_try_fmt_vid_cap(struct file *file, void *priv,
494 struct v4l2_format *f)
495 {
496 const struct sh_veu_format *fmt;
497
498 fmt = sh_veu_find_fmt(f);
499 if (!fmt)
500 /* wrong buffer type */
501 return -EINVAL;
502
503 return sh_veu_try_fmt(f, fmt);
504 }
505
sh_veu_try_fmt_vid_out(struct file * file,void * priv,struct v4l2_format * f)506 static int sh_veu_try_fmt_vid_out(struct file *file, void *priv,
507 struct v4l2_format *f)
508 {
509 const struct sh_veu_format *fmt;
510
511 fmt = sh_veu_find_fmt(f);
512 if (!fmt)
513 /* wrong buffer type */
514 return -EINVAL;
515
516 return sh_veu_try_fmt(f, fmt);
517 }
518
sh_veu_colour_offset(struct sh_veu_dev * veu,struct sh_veu_vfmt * vfmt)519 static void sh_veu_colour_offset(struct sh_veu_dev *veu, struct sh_veu_vfmt *vfmt)
520 {
521 /* dst_left and dst_top validity will be verified in CROP / COMPOSE */
522 unsigned int left = vfmt->frame.left & ~0x03;
523 unsigned int top = vfmt->frame.top;
524 dma_addr_t offset = ((left * veu->vfmt_out.fmt->depth) >> 3) +
525 top * veu->vfmt_out.bytesperline;
526 unsigned int y_line;
527
528 vfmt->offset_y = offset;
529
530 switch (vfmt->fmt->fourcc) {
531 case V4L2_PIX_FMT_NV12:
532 case V4L2_PIX_FMT_NV16:
533 case V4L2_PIX_FMT_NV24:
534 y_line = ALIGN(vfmt->frame.width, 16);
535 vfmt->offset_c = offset + y_line * vfmt->frame.height;
536 break;
537 case V4L2_PIX_FMT_RGB332:
538 case V4L2_PIX_FMT_RGB444:
539 case V4L2_PIX_FMT_RGB565:
540 case V4L2_PIX_FMT_BGR666:
541 case V4L2_PIX_FMT_RGB24:
542 vfmt->offset_c = 0;
543 break;
544 default:
545 BUG();
546 }
547 }
548
sh_veu_s_fmt(struct sh_veu_file * veu_file,struct v4l2_format * f)549 static int sh_veu_s_fmt(struct sh_veu_file *veu_file, struct v4l2_format *f)
550 {
551 struct v4l2_pix_format *pix = &f->fmt.pix;
552 struct sh_veu_dev *veu = veu_file->veu_dev;
553 struct sh_veu_vfmt *vfmt;
554 struct vb2_queue *vq;
555 int ret = sh_veu_context_init(veu);
556 if (ret < 0)
557 return ret;
558
559 vq = v4l2_m2m_get_vq(veu->m2m_ctx, f->type);
560 if (!vq)
561 return -EINVAL;
562
563 if (vb2_is_busy(vq)) {
564 v4l2_err(&veu_file->veu_dev->v4l2_dev, "%s queue busy\n", __func__);
565 return -EBUSY;
566 }
567
568 vfmt = sh_veu_get_vfmt(veu, f->type);
569 /* called after try_fmt(), hence vfmt != NULL. Implicit BUG_ON() below */
570
571 vfmt->fmt = sh_veu_find_fmt(f);
572 /* vfmt->fmt != NULL following the same argument as above */
573 vfmt->frame.width = pix->width;
574 vfmt->frame.height = pix->height;
575 vfmt->bytesperline = pix->bytesperline;
576
577 sh_veu_colour_offset(veu, vfmt);
578
579 /*
580 * We could also verify and require configuration only if any parameters
581 * actually have changed, but it is unlikely, that the user requests the
582 * same configuration several times without closing the device.
583 */
584 veu_file->cfg_needed = true;
585
586 dev_dbg(veu->dev,
587 "Setting format for type %d, wxh: %dx%d, fmt: %x\n",
588 f->type, pix->width, pix->height, vfmt->fmt->fourcc);
589
590 return 0;
591 }
592
sh_veu_s_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)593 static int sh_veu_s_fmt_vid_cap(struct file *file, void *priv,
594 struct v4l2_format *f)
595 {
596 int ret = sh_veu_try_fmt_vid_cap(file, priv, f);
597 if (ret)
598 return ret;
599
600 return sh_veu_s_fmt(priv, f);
601 }
602
sh_veu_s_fmt_vid_out(struct file * file,void * priv,struct v4l2_format * f)603 static int sh_veu_s_fmt_vid_out(struct file *file, void *priv,
604 struct v4l2_format *f)
605 {
606 int ret = sh_veu_try_fmt_vid_out(file, priv, f);
607 if (ret)
608 return ret;
609
610 return sh_veu_s_fmt(priv, f);
611 }
612
sh_veu_reqbufs(struct file * file,void * priv,struct v4l2_requestbuffers * reqbufs)613 static int sh_veu_reqbufs(struct file *file, void *priv,
614 struct v4l2_requestbuffers *reqbufs)
615 {
616 struct sh_veu_file *veu_file = priv;
617 struct sh_veu_dev *veu = veu_file->veu_dev;
618 int ret = sh_veu_context_init(veu);
619 if (ret < 0)
620 return ret;
621
622 ret = sh_veu_stream_init(veu, veu_file, reqbufs->type);
623 if (ret < 0)
624 return ret;
625
626 return v4l2_m2m_reqbufs(file, veu->m2m_ctx, reqbufs);
627 }
628
sh_veu_querybuf(struct file * file,void * priv,struct v4l2_buffer * buf)629 static int sh_veu_querybuf(struct file *file, void *priv,
630 struct v4l2_buffer *buf)
631 {
632 struct sh_veu_file *veu_file = priv;
633
634 if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
635 return -EBUSY;
636
637 return v4l2_m2m_querybuf(file, veu_file->veu_dev->m2m_ctx, buf);
638 }
639
sh_veu_qbuf(struct file * file,void * priv,struct v4l2_buffer * buf)640 static int sh_veu_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
641 {
642 struct sh_veu_file *veu_file = priv;
643
644 dev_dbg(veu_file->veu_dev->dev, "%s(%d)\n", __func__, buf->type);
645 if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
646 return -EBUSY;
647
648 return v4l2_m2m_qbuf(file, veu_file->veu_dev->m2m_ctx, buf);
649 }
650
sh_veu_dqbuf(struct file * file,void * priv,struct v4l2_buffer * buf)651 static int sh_veu_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
652 {
653 struct sh_veu_file *veu_file = priv;
654
655 dev_dbg(veu_file->veu_dev->dev, "%s(%d)\n", __func__, buf->type);
656 if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
657 return -EBUSY;
658
659 return v4l2_m2m_dqbuf(file, veu_file->veu_dev->m2m_ctx, buf);
660 }
661
sh_veu_calc_scale(struct sh_veu_dev * veu,int size_in,int size_out,int crop_out,u32 * mant,u32 * frac,u32 * rep)662 static void sh_veu_calc_scale(struct sh_veu_dev *veu,
663 int size_in, int size_out, int crop_out,
664 u32 *mant, u32 *frac, u32 *rep)
665 {
666 u32 fixpoint;
667
668 /* calculate FRAC and MANT */
669 *rep = *mant = *frac = 0;
670
671 if (size_in == size_out) {
672 if (crop_out != size_out)
673 *mant = 1; /* needed for cropping */
674 return;
675 }
676
677 /* VEU2H special upscale */
678 if (veu->is_2h && size_out > size_in) {
679 u32 fixpoint = (4096 * size_in) / size_out;
680 *mant = fixpoint / 4096;
681 *frac = (fixpoint - (*mant * 4096)) & ~0x07;
682
683 switch (*frac) {
684 case 0x800:
685 *rep = 1;
686 break;
687 case 0x400:
688 *rep = 3;
689 break;
690 case 0x200:
691 *rep = 7;
692 break;
693 }
694 if (*rep)
695 return;
696 }
697
698 fixpoint = (4096 * (size_in - 1)) / (size_out + 1);
699 *mant = fixpoint / 4096;
700 *frac = fixpoint - (*mant * 4096);
701
702 if (*frac & 0x07) {
703 /*
704 * FIXME: do we really have to round down twice in the
705 * up-scaling case?
706 */
707 *frac &= ~0x07;
708 if (size_out > size_in)
709 *frac -= 8; /* round down if scaling up */
710 else
711 *frac += 8; /* round up if scaling down */
712 }
713 }
714
sh_veu_scale_v(struct sh_veu_dev * veu,int size_in,int size_out,int crop_out)715 static unsigned long sh_veu_scale_v(struct sh_veu_dev *veu,
716 int size_in, int size_out, int crop_out)
717 {
718 u32 mant, frac, value, rep;
719
720 sh_veu_calc_scale(veu, size_in, size_out, crop_out, &mant, &frac, &rep);
721
722 /* set scale */
723 value = (sh_veu_reg_read(veu, VEU_RFCR) & ~0xffff0000) |
724 (((mant << 12) | frac) << 16);
725
726 sh_veu_reg_write(veu, VEU_RFCR, value);
727
728 /* set clip */
729 value = (sh_veu_reg_read(veu, VEU_RFSR) & ~0xffff0000) |
730 (((rep << 12) | crop_out) << 16);
731
732 sh_veu_reg_write(veu, VEU_RFSR, value);
733
734 return ALIGN((size_in * crop_out) / size_out, 4);
735 }
736
sh_veu_scale_h(struct sh_veu_dev * veu,int size_in,int size_out,int crop_out)737 static unsigned long sh_veu_scale_h(struct sh_veu_dev *veu,
738 int size_in, int size_out, int crop_out)
739 {
740 u32 mant, frac, value, rep;
741
742 sh_veu_calc_scale(veu, size_in, size_out, crop_out, &mant, &frac, &rep);
743
744 /* set scale */
745 value = (sh_veu_reg_read(veu, VEU_RFCR) & ~0xffff) |
746 (mant << 12) | frac;
747
748 sh_veu_reg_write(veu, VEU_RFCR, value);
749
750 /* set clip */
751 value = (sh_veu_reg_read(veu, VEU_RFSR) & ~0xffff) |
752 (rep << 12) | crop_out;
753
754 sh_veu_reg_write(veu, VEU_RFSR, value);
755
756 return ALIGN((size_in * crop_out) / size_out, 4);
757 }
758
sh_veu_configure(struct sh_veu_dev * veu)759 static void sh_veu_configure(struct sh_veu_dev *veu)
760 {
761 u32 src_width, src_stride, src_height;
762 u32 dst_width, dst_stride, dst_height;
763 u32 real_w, real_h;
764
765 /* reset VEU */
766 sh_veu_reg_write(veu, VEU_BSRR, 0x100);
767
768 src_width = veu->vfmt_in.frame.width;
769 src_height = veu->vfmt_in.frame.height;
770 src_stride = ALIGN(veu->vfmt_in.frame.width, 16);
771
772 dst_width = real_w = veu->vfmt_out.frame.width;
773 dst_height = real_h = veu->vfmt_out.frame.height;
774 /* Datasheet is unclear - whether it's always number of bytes or not */
775 dst_stride = veu->vfmt_out.bytesperline;
776
777 /*
778 * So far real_w == dst_width && real_h == dst_height, but it wasn't
779 * necessarily the case in the original vidix driver, so, it may change
780 * here in the future too.
781 */
782 src_width = sh_veu_scale_h(veu, src_width, real_w, dst_width);
783 src_height = sh_veu_scale_v(veu, src_height, real_h, dst_height);
784
785 sh_veu_reg_write(veu, VEU_SWR, src_stride);
786 sh_veu_reg_write(veu, VEU_SSR, src_width | (src_height << 16));
787 sh_veu_reg_write(veu, VEU_BSSR, 0); /* not using bundle mode */
788
789 sh_veu_reg_write(veu, VEU_EDWR, dst_stride);
790 sh_veu_reg_write(veu, VEU_DACR, 0); /* unused for RGB */
791
792 sh_veu_reg_write(veu, VEU_SWPR, 0x67);
793 sh_veu_reg_write(veu, VEU_TRCR, (6 << 16) | (0 << 14) | 2 | 4);
794
795 if (veu->is_2h) {
796 sh_veu_reg_write(veu, VEU_MCR00, 0x0cc5);
797 sh_veu_reg_write(veu, VEU_MCR01, 0x0950);
798 sh_veu_reg_write(veu, VEU_MCR02, 0x0000);
799
800 sh_veu_reg_write(veu, VEU_MCR10, 0x397f);
801 sh_veu_reg_write(veu, VEU_MCR11, 0x0950);
802 sh_veu_reg_write(veu, VEU_MCR12, 0x3ccd);
803
804 sh_veu_reg_write(veu, VEU_MCR20, 0x0000);
805 sh_veu_reg_write(veu, VEU_MCR21, 0x0950);
806 sh_veu_reg_write(veu, VEU_MCR22, 0x1023);
807
808 sh_veu_reg_write(veu, VEU_COFFR, 0x00800010);
809 }
810 }
811
sh_veu_streamon(struct file * file,void * priv,enum v4l2_buf_type type)812 static int sh_veu_streamon(struct file *file, void *priv,
813 enum v4l2_buf_type type)
814 {
815 struct sh_veu_file *veu_file = priv;
816
817 if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, type))
818 return -EBUSY;
819
820 if (veu_file->cfg_needed) {
821 struct sh_veu_dev *veu = veu_file->veu_dev;
822 veu_file->cfg_needed = false;
823 sh_veu_configure(veu_file->veu_dev);
824 veu->xaction = 0;
825 veu->aborting = false;
826 }
827
828 return v4l2_m2m_streamon(file, veu_file->veu_dev->m2m_ctx, type);
829 }
830
sh_veu_streamoff(struct file * file,void * priv,enum v4l2_buf_type type)831 static int sh_veu_streamoff(struct file *file, void *priv,
832 enum v4l2_buf_type type)
833 {
834 struct sh_veu_file *veu_file = priv;
835
836 if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, type))
837 return -EBUSY;
838
839 return v4l2_m2m_streamoff(file, veu_file->veu_dev->m2m_ctx, type);
840 }
841
842 static const struct v4l2_ioctl_ops sh_veu_ioctl_ops = {
843 .vidioc_querycap = sh_veu_querycap,
844
845 .vidioc_enum_fmt_vid_cap = sh_veu_enum_fmt_vid_cap,
846 .vidioc_g_fmt_vid_cap = sh_veu_g_fmt_vid_cap,
847 .vidioc_try_fmt_vid_cap = sh_veu_try_fmt_vid_cap,
848 .vidioc_s_fmt_vid_cap = sh_veu_s_fmt_vid_cap,
849
850 .vidioc_enum_fmt_vid_out = sh_veu_enum_fmt_vid_out,
851 .vidioc_g_fmt_vid_out = sh_veu_g_fmt_vid_out,
852 .vidioc_try_fmt_vid_out = sh_veu_try_fmt_vid_out,
853 .vidioc_s_fmt_vid_out = sh_veu_s_fmt_vid_out,
854
855 .vidioc_reqbufs = sh_veu_reqbufs,
856 .vidioc_querybuf = sh_veu_querybuf,
857
858 .vidioc_qbuf = sh_veu_qbuf,
859 .vidioc_dqbuf = sh_veu_dqbuf,
860
861 .vidioc_streamon = sh_veu_streamon,
862 .vidioc_streamoff = sh_veu_streamoff,
863 };
864
865 /* ========== Queue operations ========== */
866
sh_veu_queue_setup(struct vb2_queue * vq,const void * parg,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],void * alloc_ctxs[])867 static int sh_veu_queue_setup(struct vb2_queue *vq,
868 const void *parg,
869 unsigned int *nbuffers, unsigned int *nplanes,
870 unsigned int sizes[], void *alloc_ctxs[])
871 {
872 const struct v4l2_format *f = parg;
873 struct sh_veu_dev *veu = vb2_get_drv_priv(vq);
874 struct sh_veu_vfmt *vfmt;
875 unsigned int size, count = *nbuffers;
876
877 if (f) {
878 const struct v4l2_pix_format *pix = &f->fmt.pix;
879 const struct sh_veu_format *fmt = sh_veu_find_fmt(f);
880 struct v4l2_format ftmp = *f;
881
882 if (fmt->fourcc != pix->pixelformat)
883 return -EINVAL;
884 sh_veu_try_fmt(&ftmp, fmt);
885 if (ftmp.fmt.pix.width != pix->width ||
886 ftmp.fmt.pix.height != pix->height)
887 return -EINVAL;
888 size = pix->bytesperline ? pix->bytesperline * pix->height * fmt->depth / fmt->ydepth :
889 pix->width * pix->height * fmt->depth / fmt->ydepth;
890 } else {
891 vfmt = sh_veu_get_vfmt(veu, vq->type);
892 size = vfmt->bytesperline * vfmt->frame.height * vfmt->fmt->depth / vfmt->fmt->ydepth;
893 }
894
895 if (count < 2)
896 *nbuffers = count = 2;
897
898 if (size * count > VIDEO_MEM_LIMIT) {
899 count = VIDEO_MEM_LIMIT / size;
900 *nbuffers = count;
901 }
902
903 *nplanes = 1;
904 sizes[0] = size;
905 alloc_ctxs[0] = veu->alloc_ctx;
906
907 dev_dbg(veu->dev, "get %d buffer(s) of size %d each.\n", count, size);
908
909 return 0;
910 }
911
sh_veu_buf_prepare(struct vb2_buffer * vb)912 static int sh_veu_buf_prepare(struct vb2_buffer *vb)
913 {
914 struct sh_veu_dev *veu = vb2_get_drv_priv(vb->vb2_queue);
915 struct sh_veu_vfmt *vfmt;
916 unsigned int sizeimage;
917
918 vfmt = sh_veu_get_vfmt(veu, vb->vb2_queue->type);
919 sizeimage = vfmt->bytesperline * vfmt->frame.height *
920 vfmt->fmt->depth / vfmt->fmt->ydepth;
921
922 if (vb2_plane_size(vb, 0) < sizeimage) {
923 dev_dbg(veu->dev, "%s data will not fit into plane (%lu < %u)\n",
924 __func__, vb2_plane_size(vb, 0), sizeimage);
925 return -EINVAL;
926 }
927
928 vb2_set_plane_payload(vb, 0, sizeimage);
929
930 return 0;
931 }
932
sh_veu_buf_queue(struct vb2_buffer * vb)933 static void sh_veu_buf_queue(struct vb2_buffer *vb)
934 {
935 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
936 struct sh_veu_dev *veu = vb2_get_drv_priv(vb->vb2_queue);
937 dev_dbg(veu->dev, "%s(%d)\n", __func__, vb->type);
938 v4l2_m2m_buf_queue(veu->m2m_ctx, vbuf);
939 }
940
941 static const struct vb2_ops sh_veu_qops = {
942 .queue_setup = sh_veu_queue_setup,
943 .buf_prepare = sh_veu_buf_prepare,
944 .buf_queue = sh_veu_buf_queue,
945 .wait_prepare = vb2_ops_wait_prepare,
946 .wait_finish = vb2_ops_wait_finish,
947 };
948
sh_veu_queue_init(void * priv,struct vb2_queue * src_vq,struct vb2_queue * dst_vq)949 static int sh_veu_queue_init(void *priv, struct vb2_queue *src_vq,
950 struct vb2_queue *dst_vq)
951 {
952 struct sh_veu_dev *veu = priv;
953 int ret;
954
955 memset(src_vq, 0, sizeof(*src_vq));
956 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
957 src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
958 src_vq->drv_priv = veu;
959 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
960 src_vq->ops = &sh_veu_qops;
961 src_vq->mem_ops = &vb2_dma_contig_memops;
962 src_vq->lock = &veu->fop_lock;
963 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
964
965 ret = vb2_queue_init(src_vq);
966 if (ret < 0)
967 return ret;
968
969 memset(dst_vq, 0, sizeof(*dst_vq));
970 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
971 dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
972 dst_vq->drv_priv = veu;
973 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
974 dst_vq->ops = &sh_veu_qops;
975 dst_vq->mem_ops = &vb2_dma_contig_memops;
976 dst_vq->lock = &veu->fop_lock;
977 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
978
979 return vb2_queue_init(dst_vq);
980 }
981
982 /* ========== File operations ========== */
983
sh_veu_open(struct file * file)984 static int sh_veu_open(struct file *file)
985 {
986 struct sh_veu_dev *veu = video_drvdata(file);
987 struct sh_veu_file *veu_file;
988
989 veu_file = kzalloc(sizeof(*veu_file), GFP_KERNEL);
990 if (!veu_file)
991 return -ENOMEM;
992
993 veu_file->veu_dev = veu;
994 veu_file->cfg_needed = true;
995
996 file->private_data = veu_file;
997
998 pm_runtime_get_sync(veu->dev);
999
1000 dev_dbg(veu->dev, "Created instance %p\n", veu_file);
1001
1002 return 0;
1003 }
1004
sh_veu_release(struct file * file)1005 static int sh_veu_release(struct file *file)
1006 {
1007 struct sh_veu_dev *veu = video_drvdata(file);
1008 struct sh_veu_file *veu_file = file->private_data;
1009
1010 dev_dbg(veu->dev, "Releasing instance %p\n", veu_file);
1011
1012 if (veu_file == veu->capture) {
1013 veu->capture = NULL;
1014 vb2_queue_release(v4l2_m2m_get_vq(veu->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE));
1015 }
1016
1017 if (veu_file == veu->output) {
1018 veu->output = NULL;
1019 vb2_queue_release(v4l2_m2m_get_vq(veu->m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT));
1020 }
1021
1022 if (!veu->output && !veu->capture && veu->m2m_ctx) {
1023 v4l2_m2m_ctx_release(veu->m2m_ctx);
1024 veu->m2m_ctx = NULL;
1025 }
1026
1027 pm_runtime_put(veu->dev);
1028
1029 kfree(veu_file);
1030
1031 return 0;
1032 }
1033
sh_veu_poll(struct file * file,struct poll_table_struct * wait)1034 static unsigned int sh_veu_poll(struct file *file,
1035 struct poll_table_struct *wait)
1036 {
1037 struct sh_veu_file *veu_file = file->private_data;
1038
1039 return v4l2_m2m_poll(file, veu_file->veu_dev->m2m_ctx, wait);
1040 }
1041
sh_veu_mmap(struct file * file,struct vm_area_struct * vma)1042 static int sh_veu_mmap(struct file *file, struct vm_area_struct *vma)
1043 {
1044 struct sh_veu_file *veu_file = file->private_data;
1045
1046 return v4l2_m2m_mmap(file, veu_file->veu_dev->m2m_ctx, vma);
1047 }
1048
1049 static const struct v4l2_file_operations sh_veu_fops = {
1050 .owner = THIS_MODULE,
1051 .open = sh_veu_open,
1052 .release = sh_veu_release,
1053 .poll = sh_veu_poll,
1054 .unlocked_ioctl = video_ioctl2,
1055 .mmap = sh_veu_mmap,
1056 };
1057
1058 static const struct video_device sh_veu_videodev = {
1059 .name = "sh-veu",
1060 .fops = &sh_veu_fops,
1061 .ioctl_ops = &sh_veu_ioctl_ops,
1062 .minor = -1,
1063 .release = video_device_release_empty,
1064 .vfl_dir = VFL_DIR_M2M,
1065 };
1066
1067 static const struct v4l2_m2m_ops sh_veu_m2m_ops = {
1068 .device_run = sh_veu_device_run,
1069 .job_abort = sh_veu_job_abort,
1070 };
1071
sh_veu_bh(int irq,void * dev_id)1072 static irqreturn_t sh_veu_bh(int irq, void *dev_id)
1073 {
1074 struct sh_veu_dev *veu = dev_id;
1075
1076 if (veu->xaction == MEM2MEM_DEF_TRANSLEN || veu->aborting) {
1077 v4l2_m2m_job_finish(veu->m2m_dev, veu->m2m_ctx);
1078 veu->xaction = 0;
1079 } else {
1080 sh_veu_device_run(veu);
1081 }
1082
1083 return IRQ_HANDLED;
1084 }
1085
sh_veu_isr(int irq,void * dev_id)1086 static irqreturn_t sh_veu_isr(int irq, void *dev_id)
1087 {
1088 struct sh_veu_dev *veu = dev_id;
1089 struct vb2_v4l2_buffer *dst;
1090 struct vb2_v4l2_buffer *src;
1091 u32 status = sh_veu_reg_read(veu, VEU_EVTR);
1092
1093 /* bundle read mode not used */
1094 if (!(status & 1))
1095 return IRQ_NONE;
1096
1097 /* disable interrupt in VEU */
1098 sh_veu_reg_write(veu, VEU_EIER, 0);
1099 /* halt operation */
1100 sh_veu_reg_write(veu, VEU_STR, 0);
1101 /* ack int, write 0 to clear bits */
1102 sh_veu_reg_write(veu, VEU_EVTR, status & ~1);
1103
1104 /* conversion completed */
1105 dst = v4l2_m2m_dst_buf_remove(veu->m2m_ctx);
1106 src = v4l2_m2m_src_buf_remove(veu->m2m_ctx);
1107 if (!src || !dst)
1108 return IRQ_NONE;
1109
1110 dst->timestamp = src->timestamp;
1111 dst->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
1112 dst->flags |=
1113 src->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
1114 dst->timecode = src->timecode;
1115
1116 spin_lock(&veu->lock);
1117 v4l2_m2m_buf_done(src, VB2_BUF_STATE_DONE);
1118 v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);
1119 spin_unlock(&veu->lock);
1120
1121 veu->xaction++;
1122
1123 return IRQ_WAKE_THREAD;
1124 }
1125
sh_veu_probe(struct platform_device * pdev)1126 static int sh_veu_probe(struct platform_device *pdev)
1127 {
1128 struct sh_veu_dev *veu;
1129 struct resource *reg_res;
1130 struct video_device *vdev;
1131 int irq, ret;
1132
1133 reg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1134 irq = platform_get_irq(pdev, 0);
1135
1136 if (!reg_res || irq <= 0) {
1137 dev_err(&pdev->dev, "Insufficient VEU platform information.\n");
1138 return -ENODEV;
1139 }
1140
1141 veu = devm_kzalloc(&pdev->dev, sizeof(*veu), GFP_KERNEL);
1142 if (!veu)
1143 return -ENOMEM;
1144
1145 veu->is_2h = resource_size(reg_res) == 0x22c;
1146
1147 veu->base = devm_ioremap_resource(&pdev->dev, reg_res);
1148 if (IS_ERR(veu->base))
1149 return PTR_ERR(veu->base);
1150
1151 ret = devm_request_threaded_irq(&pdev->dev, irq, sh_veu_isr, sh_veu_bh,
1152 0, "veu", veu);
1153 if (ret < 0)
1154 return ret;
1155
1156 ret = v4l2_device_register(&pdev->dev, &veu->v4l2_dev);
1157 if (ret < 0) {
1158 dev_err(&pdev->dev, "Error registering v4l2 device\n");
1159 return ret;
1160 }
1161
1162 vdev = &veu->vdev;
1163
1164 veu->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
1165 if (IS_ERR(veu->alloc_ctx)) {
1166 ret = PTR_ERR(veu->alloc_ctx);
1167 goto einitctx;
1168 }
1169
1170 *vdev = sh_veu_videodev;
1171 vdev->v4l2_dev = &veu->v4l2_dev;
1172 spin_lock_init(&veu->lock);
1173 mutex_init(&veu->fop_lock);
1174 vdev->lock = &veu->fop_lock;
1175
1176 video_set_drvdata(vdev, veu);
1177
1178 veu->dev = &pdev->dev;
1179 veu->vfmt_out = DEFAULT_OUT_VFMT;
1180 veu->vfmt_in = DEFAULT_IN_VFMT;
1181
1182 veu->m2m_dev = v4l2_m2m_init(&sh_veu_m2m_ops);
1183 if (IS_ERR(veu->m2m_dev)) {
1184 ret = PTR_ERR(veu->m2m_dev);
1185 v4l2_err(&veu->v4l2_dev, "Failed to init mem2mem device: %d\n", ret);
1186 goto em2minit;
1187 }
1188
1189 pm_runtime_enable(&pdev->dev);
1190 pm_runtime_resume(&pdev->dev);
1191
1192 ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1193 pm_runtime_suspend(&pdev->dev);
1194 if (ret < 0)
1195 goto evidreg;
1196
1197 return ret;
1198
1199 evidreg:
1200 pm_runtime_disable(&pdev->dev);
1201 v4l2_m2m_release(veu->m2m_dev);
1202 em2minit:
1203 vb2_dma_contig_cleanup_ctx(veu->alloc_ctx);
1204 einitctx:
1205 v4l2_device_unregister(&veu->v4l2_dev);
1206 return ret;
1207 }
1208
sh_veu_remove(struct platform_device * pdev)1209 static int sh_veu_remove(struct platform_device *pdev)
1210 {
1211 struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
1212 struct sh_veu_dev *veu = container_of(v4l2_dev,
1213 struct sh_veu_dev, v4l2_dev);
1214
1215 video_unregister_device(&veu->vdev);
1216 pm_runtime_disable(&pdev->dev);
1217 v4l2_m2m_release(veu->m2m_dev);
1218 vb2_dma_contig_cleanup_ctx(veu->alloc_ctx);
1219 v4l2_device_unregister(&veu->v4l2_dev);
1220
1221 return 0;
1222 }
1223
1224 static struct platform_driver __refdata sh_veu_pdrv = {
1225 .remove = sh_veu_remove,
1226 .driver = {
1227 .name = "sh_veu",
1228 },
1229 };
1230
1231 module_platform_driver_probe(sh_veu_pdrv, sh_veu_probe);
1232
1233 MODULE_DESCRIPTION("sh-mobile VEU mem2mem driver");
1234 MODULE_AUTHOR("Guennadi Liakhovetski, <g.liakhovetski@gmx.de>");
1235 MODULE_LICENSE("GPL v2");
1236