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