1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) STMicroelectronics SA 2015
4 * Authors: Hugues Fruchet <hugues.fruchet@st.com>
5 * Jean-Christophe Trotin <jean-christophe.trotin@st.com>
6 * for STMicroelectronics.
7 */
8
9 #include <linux/clk.h>
10 #include <linux/module.h>
11 #include <linux/platform_device.h>
12 #include <linux/pm_runtime.h>
13 #include <linux/slab.h>
14
15 #include <media/v4l2-ioctl.h>
16 #include <media/v4l2-event.h>
17 #include <media/videobuf2-dma-contig.h>
18
19 #include "delta.h"
20 #include "delta-debug.h"
21 #include "delta-ipc.h"
22
23 #define DELTA_NAME "st-delta"
24
25 #define DELTA_PREFIX "[---:----]"
26
file_to_ctx(struct file * filp)27 static inline struct delta_ctx *file_to_ctx(struct file *filp)
28 {
29 return container_of(file_to_v4l2_fh(filp), struct delta_ctx, fh);
30 }
31
32 #define to_au(__vbuf) container_of(__vbuf, struct delta_au, vbuf)
33 #define to_frame(__vbuf) container_of(__vbuf, struct delta_frame, vbuf)
34
35 #define call_dec_op(dec, op, args...)\
36 ((dec && (dec)->op) ? (dec)->op(args) : 0)
37
38 /* registry of available decoders */
39 static const struct delta_dec *delta_decoders[] = {
40 #ifdef CONFIG_VIDEO_STI_DELTA_MJPEG
41 &mjpegdec,
42 #endif
43 };
44
frame_size(u32 w,u32 h,u32 fmt)45 static inline int frame_size(u32 w, u32 h, u32 fmt)
46 {
47 switch (fmt) {
48 case V4L2_PIX_FMT_NV12:
49 return (w * h * 3) / 2;
50 default:
51 return 0;
52 }
53 }
54
frame_stride(u32 w,u32 fmt)55 static inline int frame_stride(u32 w, u32 fmt)
56 {
57 switch (fmt) {
58 case V4L2_PIX_FMT_NV12:
59 return w;
60 default:
61 return 0;
62 }
63 }
64
dump_au(struct delta_ctx * ctx,struct delta_au * au)65 static void dump_au(struct delta_ctx *ctx, struct delta_au *au)
66 {
67 struct delta_dev *delta = ctx->dev;
68 u32 size = 10; /* dump first & last 10 bytes */
69 u8 *data = (u8 *)(au->vaddr);
70
71 if (au->size <= (size * 2))
72 dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph\n",
73 ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,
74 au->size, data);
75 else
76 dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph..%*ph\n",
77 ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,
78 size, data, size, data + au->size - size);
79 }
80
dump_frame(struct delta_ctx * ctx,struct delta_frame * frame)81 static void dump_frame(struct delta_ctx *ctx, struct delta_frame *frame)
82 {
83 struct delta_dev *delta = ctx->dev;
84 u32 size = 10; /* dump first 10 bytes */
85 u8 *data = (u8 *)(frame->vaddr);
86
87 dev_dbg(delta->dev, "%s dump frame[%d] dts=%lld type=%s field=%s data=%*ph\n",
88 ctx->name, frame->index, frame->dts,
89 frame_type_str(frame->flags),
90 frame_field_str(frame->field),
91 size, data);
92 }
93
delta_au_done(struct delta_ctx * ctx,struct delta_au * au,int err)94 static void delta_au_done(struct delta_ctx *ctx, struct delta_au *au, int err)
95 {
96 struct vb2_v4l2_buffer *vbuf;
97
98 vbuf = &au->vbuf;
99 vbuf->sequence = ctx->au_num++;
100 v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
101 }
102
delta_frame_done(struct delta_ctx * ctx,struct delta_frame * frame,int err)103 static void delta_frame_done(struct delta_ctx *ctx, struct delta_frame *frame,
104 int err)
105 {
106 struct vb2_v4l2_buffer *vbuf;
107
108 dump_frame(ctx, frame);
109
110 /* decoded frame is now output to user */
111 frame->state |= DELTA_FRAME_OUT;
112
113 vbuf = &frame->vbuf;
114 vbuf->sequence = ctx->frame_num++;
115 v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
116
117 if (frame->info.size) /* ignore EOS */
118 ctx->output_frames++;
119 }
120
requeue_free_frames(struct delta_ctx * ctx)121 static void requeue_free_frames(struct delta_ctx *ctx)
122 {
123 struct vb2_v4l2_buffer *vbuf;
124 struct delta_frame *frame;
125 unsigned int i;
126
127 /* requeue all free frames */
128 for (i = 0; i < ctx->nb_of_frames; i++) {
129 frame = ctx->frames[i];
130 if (frame->state == DELTA_FRAME_FREE) {
131 vbuf = &frame->vbuf;
132 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
133 frame->state = DELTA_FRAME_M2M;
134 }
135 }
136 }
137
delta_recycle(struct delta_ctx * ctx,struct delta_frame * frame)138 static int delta_recycle(struct delta_ctx *ctx, struct delta_frame *frame)
139 {
140 const struct delta_dec *dec = ctx->dec;
141
142 /* recycle frame on decoder side */
143 call_dec_op(dec, recycle, ctx, frame);
144
145 /* this frame is no more output */
146 frame->state &= ~DELTA_FRAME_OUT;
147
148 /* requeue free frame */
149 if (frame->state == DELTA_FRAME_FREE) {
150 struct vb2_v4l2_buffer *vbuf = &frame->vbuf;
151
152 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
153 frame->state = DELTA_FRAME_M2M;
154 }
155
156 /* reset other frame fields */
157 frame->flags = 0;
158 frame->dts = 0;
159
160 return 0;
161 }
162
delta_push_dts(struct delta_ctx * ctx,u64 val)163 static void delta_push_dts(struct delta_ctx *ctx, u64 val)
164 {
165 struct delta_dts *dts;
166
167 dts = kzalloc_obj(*dts);
168 if (!dts)
169 return;
170
171 INIT_LIST_HEAD(&dts->list);
172
173 /*
174 * protected by global lock acquired
175 * by V4L2 when calling delta_vb2_au_queue
176 */
177 dts->val = val;
178 list_add_tail(&dts->list, &ctx->dts);
179 }
180
delta_pop_dts(struct delta_ctx * ctx,u64 * val)181 static void delta_pop_dts(struct delta_ctx *ctx, u64 *val)
182 {
183 struct delta_dev *delta = ctx->dev;
184 struct delta_dts *dts;
185
186 /*
187 * protected by global lock acquired
188 * by V4L2 when calling delta_vb2_au_queue
189 */
190 if (list_empty(&ctx->dts)) {
191 dev_warn(delta->dev, "%s no dts to pop ... output dts = 0\n",
192 ctx->name);
193 *val = 0;
194 return;
195 }
196
197 dts = list_first_entry(&ctx->dts, struct delta_dts, list);
198 list_del(&dts->list);
199
200 *val = dts->val;
201
202 kfree(dts);
203 }
204
delta_flush_dts(struct delta_ctx * ctx)205 static void delta_flush_dts(struct delta_ctx *ctx)
206 {
207 struct delta_dts *dts;
208 struct delta_dts *next;
209
210 /*
211 * protected by global lock acquired
212 * by V4L2 when calling delta_vb2_au_queue
213 */
214
215 /* free all pending dts */
216 list_for_each_entry_safe(dts, next, &ctx->dts, list)
217 kfree(dts);
218
219 /* reset list */
220 INIT_LIST_HEAD(&ctx->dts);
221 }
222
frame_alignment(u32 fmt)223 static inline int frame_alignment(u32 fmt)
224 {
225 switch (fmt) {
226 case V4L2_PIX_FMT_NV12:
227 case V4L2_PIX_FMT_NV21:
228 /* multiple of 2 */
229 return 2;
230 default:
231 return 1;
232 }
233 }
234
estimated_au_size(u32 w,u32 h)235 static inline int estimated_au_size(u32 w, u32 h)
236 {
237 /*
238 * for a MJPEG stream encoded from YUV422 pixel format,
239 * assuming a compression ratio of 2, the maximum size
240 * of an access unit is (width x height x 2) / 2,
241 * so (width x height)
242 */
243 return (w * h);
244 }
245
set_default_params(struct delta_ctx * ctx)246 static void set_default_params(struct delta_ctx *ctx)
247 {
248 struct delta_frameinfo *frameinfo = &ctx->frameinfo;
249 struct delta_streaminfo *streaminfo = &ctx->streaminfo;
250
251 memset(frameinfo, 0, sizeof(*frameinfo));
252 frameinfo->pixelformat = V4L2_PIX_FMT_NV12;
253 frameinfo->width = DELTA_DEFAULT_WIDTH;
254 frameinfo->height = DELTA_DEFAULT_HEIGHT;
255 frameinfo->aligned_width = ALIGN(frameinfo->width,
256 DELTA_WIDTH_ALIGNMENT);
257 frameinfo->aligned_height = ALIGN(frameinfo->height,
258 DELTA_HEIGHT_ALIGNMENT);
259 frameinfo->size = frame_size(frameinfo->aligned_width,
260 frameinfo->aligned_height,
261 frameinfo->pixelformat);
262 frameinfo->field = V4L2_FIELD_NONE;
263 frameinfo->colorspace = V4L2_COLORSPACE_REC709;
264 frameinfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;
265 frameinfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
266 frameinfo->quantization = V4L2_QUANTIZATION_DEFAULT;
267
268 memset(streaminfo, 0, sizeof(*streaminfo));
269 streaminfo->streamformat = DELTA_DEFAULT_STREAMFORMAT;
270 streaminfo->width = DELTA_DEFAULT_WIDTH;
271 streaminfo->height = DELTA_DEFAULT_HEIGHT;
272 streaminfo->field = V4L2_FIELD_NONE;
273 streaminfo->colorspace = V4L2_COLORSPACE_REC709;
274 streaminfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;
275 streaminfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
276 streaminfo->quantization = V4L2_QUANTIZATION_DEFAULT;
277
278 ctx->max_au_size = estimated_au_size(streaminfo->width,
279 streaminfo->height);
280 }
281
delta_find_decoder(struct delta_ctx * ctx,u32 streamformat,u32 pixelformat)282 static const struct delta_dec *delta_find_decoder(struct delta_ctx *ctx,
283 u32 streamformat,
284 u32 pixelformat)
285 {
286 struct delta_dev *delta = ctx->dev;
287 const struct delta_dec *dec;
288 unsigned int i;
289
290 for (i = 0; i < delta->nb_of_decoders; i++) {
291 dec = delta->decoders[i];
292 if ((dec->pixelformat == pixelformat) &&
293 (dec->streamformat == streamformat))
294 return dec;
295 }
296
297 return NULL;
298 }
299
register_format(u32 format,u32 formats[],u32 * nb_of_formats)300 static void register_format(u32 format, u32 formats[], u32 *nb_of_formats)
301 {
302 u32 i;
303
304 for (i = 0; i < *nb_of_formats; i++) {
305 if (format == formats[i])
306 return;
307 }
308
309 formats[(*nb_of_formats)++] = format;
310 }
311
register_formats(struct delta_dev * delta)312 static void register_formats(struct delta_dev *delta)
313 {
314 unsigned int i;
315
316 for (i = 0; i < delta->nb_of_decoders; i++) {
317 register_format(delta->decoders[i]->pixelformat,
318 delta->pixelformats,
319 &delta->nb_of_pixelformats);
320
321 register_format(delta->decoders[i]->streamformat,
322 delta->streamformats,
323 &delta->nb_of_streamformats);
324 }
325 }
326
register_decoders(struct delta_dev * delta)327 static void register_decoders(struct delta_dev *delta)
328 {
329 unsigned int i;
330
331 for (i = 0; i < ARRAY_SIZE(delta_decoders); i++) {
332 if (delta->nb_of_decoders >= DELTA_MAX_DECODERS) {
333 dev_dbg(delta->dev,
334 "%s failed to register %s decoder (%d maximum reached)\n",
335 DELTA_PREFIX, delta_decoders[i]->name,
336 DELTA_MAX_DECODERS);
337 return;
338 }
339
340 delta->decoders[delta->nb_of_decoders++] = delta_decoders[i];
341 dev_info(delta->dev, "%s %s decoder registered\n",
342 DELTA_PREFIX, delta_decoders[i]->name);
343 }
344 }
345
delta_open_decoder(struct delta_ctx * ctx,u32 streamformat,u32 pixelformat,const struct delta_dec ** pdec)346 static int delta_open_decoder(struct delta_ctx *ctx, u32 streamformat,
347 u32 pixelformat, const struct delta_dec **pdec)
348 {
349 struct delta_dev *delta = ctx->dev;
350 const struct delta_dec *dec;
351 int ret;
352
353 dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);
354 if (!dec) {
355 dev_err(delta->dev, "%s no decoder found matching %4.4s => %4.4s\n",
356 ctx->name, (char *)&streamformat, (char *)&pixelformat);
357 return -EINVAL;
358 }
359
360 dev_dbg(delta->dev, "%s one decoder matching %4.4s => %4.4s\n",
361 ctx->name, (char *)&streamformat, (char *)&pixelformat);
362
363 /* update instance name */
364 snprintf(ctx->name, sizeof(ctx->name), "[%3d:%4.4s]",
365 delta->instance_id, (char *)&streamformat);
366
367 /* open decoder instance */
368 ret = call_dec_op(dec, open, ctx);
369 if (ret) {
370 dev_err(delta->dev, "%s failed to open decoder instance (%d)\n",
371 ctx->name, ret);
372 return ret;
373 }
374
375 dev_dbg(delta->dev, "%s %s decoder opened\n", ctx->name, dec->name);
376
377 *pdec = dec;
378
379 return ret;
380 }
381
382 /*
383 * V4L2 ioctl operations
384 */
385
delta_querycap(struct file * file,void * priv,struct v4l2_capability * cap)386 static int delta_querycap(struct file *file, void *priv,
387 struct v4l2_capability *cap)
388 {
389 struct delta_ctx *ctx = file_to_ctx(file);
390 struct delta_dev *delta = ctx->dev;
391
392 strscpy(cap->driver, DELTA_NAME, sizeof(cap->driver));
393 strscpy(cap->card, delta->vdev->name, sizeof(cap->card));
394 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
395 delta->pdev->name);
396
397 return 0;
398 }
399
delta_enum_fmt_stream(struct file * file,void * priv,struct v4l2_fmtdesc * f)400 static int delta_enum_fmt_stream(struct file *file, void *priv,
401 struct v4l2_fmtdesc *f)
402 {
403 struct delta_ctx *ctx = file_to_ctx(file);
404 struct delta_dev *delta = ctx->dev;
405
406 if (unlikely(f->index >= delta->nb_of_streamformats))
407 return -EINVAL;
408
409 f->pixelformat = delta->streamformats[f->index];
410
411 return 0;
412 }
413
delta_enum_fmt_frame(struct file * file,void * priv,struct v4l2_fmtdesc * f)414 static int delta_enum_fmt_frame(struct file *file, void *priv,
415 struct v4l2_fmtdesc *f)
416 {
417 struct delta_ctx *ctx = file_to_ctx(file);
418 struct delta_dev *delta = ctx->dev;
419
420 if (unlikely(f->index >= delta->nb_of_pixelformats))
421 return -EINVAL;
422
423 f->pixelformat = delta->pixelformats[f->index];
424
425 return 0;
426 }
427
delta_g_fmt_stream(struct file * file,void * fh,struct v4l2_format * f)428 static int delta_g_fmt_stream(struct file *file, void *fh,
429 struct v4l2_format *f)
430 {
431 struct delta_ctx *ctx = file_to_ctx(file);
432 struct delta_dev *delta = ctx->dev;
433 struct v4l2_pix_format *pix = &f->fmt.pix;
434 struct delta_streaminfo *streaminfo = &ctx->streaminfo;
435 unsigned char str[100] = "";
436
437 if (!(ctx->flags & DELTA_FLAG_STREAMINFO))
438 dev_dbg(delta->dev,
439 "%s V4L2 GET_FMT (OUTPUT): no stream information available, default to %s\n",
440 ctx->name,
441 delta_streaminfo_str(streaminfo, str, sizeof(str)));
442
443 pix->pixelformat = streaminfo->streamformat;
444 pix->width = streaminfo->width;
445 pix->height = streaminfo->height;
446 pix->field = streaminfo->field;
447 pix->bytesperline = 0;
448 pix->sizeimage = ctx->max_au_size;
449 pix->colorspace = streaminfo->colorspace;
450 pix->xfer_func = streaminfo->xfer_func;
451 pix->ycbcr_enc = streaminfo->ycbcr_enc;
452 pix->quantization = streaminfo->quantization;
453
454 return 0;
455 }
456
delta_g_fmt_frame(struct file * file,void * fh,struct v4l2_format * f)457 static int delta_g_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)
458 {
459 struct delta_ctx *ctx = file_to_ctx(file);
460 struct delta_dev *delta = ctx->dev;
461 struct v4l2_pix_format *pix = &f->fmt.pix;
462 struct delta_frameinfo *frameinfo = &ctx->frameinfo;
463 struct delta_streaminfo *streaminfo = &ctx->streaminfo;
464 unsigned char str[100] = "";
465
466 if (!(ctx->flags & DELTA_FLAG_FRAMEINFO))
467 dev_dbg(delta->dev,
468 "%s V4L2 GET_FMT (CAPTURE): no frame information available, default to %s\n",
469 ctx->name,
470 delta_frameinfo_str(frameinfo, str, sizeof(str)));
471
472 pix->pixelformat = frameinfo->pixelformat;
473 pix->width = frameinfo->aligned_width;
474 pix->height = frameinfo->aligned_height;
475 pix->field = frameinfo->field;
476 pix->bytesperline = frame_stride(frameinfo->aligned_width,
477 frameinfo->pixelformat);
478 pix->sizeimage = frameinfo->size;
479
480 if (ctx->flags & DELTA_FLAG_STREAMINFO) {
481 /* align colorspace & friends on stream ones if any set */
482 frameinfo->colorspace = streaminfo->colorspace;
483 frameinfo->xfer_func = streaminfo->xfer_func;
484 frameinfo->ycbcr_enc = streaminfo->ycbcr_enc;
485 frameinfo->quantization = streaminfo->quantization;
486 }
487 pix->colorspace = frameinfo->colorspace;
488 pix->xfer_func = frameinfo->xfer_func;
489 pix->ycbcr_enc = frameinfo->ycbcr_enc;
490 pix->quantization = frameinfo->quantization;
491
492 return 0;
493 }
494
delta_try_fmt_stream(struct file * file,void * priv,struct v4l2_format * f)495 static int delta_try_fmt_stream(struct file *file, void *priv,
496 struct v4l2_format *f)
497 {
498 struct delta_ctx *ctx = file_to_ctx(file);
499 struct delta_dev *delta = ctx->dev;
500 struct v4l2_pix_format *pix = &f->fmt.pix;
501 u32 streamformat = pix->pixelformat;
502 const struct delta_dec *dec;
503 u32 width, height;
504 u32 au_size;
505
506 dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);
507 if (!dec) {
508 dev_dbg(delta->dev,
509 "%s V4L2 TRY_FMT (OUTPUT): unsupported format %4.4s\n",
510 ctx->name, (char *)&pix->pixelformat);
511 return -EINVAL;
512 }
513
514 /* adjust width & height */
515 width = pix->width;
516 height = pix->height;
517 v4l_bound_align_image
518 (&pix->width,
519 DELTA_MIN_WIDTH,
520 dec->max_width ? dec->max_width : DELTA_MAX_WIDTH,
521 0,
522 &pix->height,
523 DELTA_MIN_HEIGHT,
524 dec->max_height ? dec->max_height : DELTA_MAX_HEIGHT,
525 0, 0);
526
527 if ((pix->width != width) || (pix->height != height))
528 dev_dbg(delta->dev,
529 "%s V4L2 TRY_FMT (OUTPUT): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",
530 ctx->name, width, height,
531 pix->width, pix->height);
532
533 au_size = estimated_au_size(pix->width, pix->height);
534 if (pix->sizeimage < au_size) {
535 dev_dbg(delta->dev,
536 "%s V4L2 TRY_FMT (OUTPUT): size updated %d -> %d to fit estimated size\n",
537 ctx->name, pix->sizeimage, au_size);
538 pix->sizeimage = au_size;
539 }
540
541 pix->bytesperline = 0;
542
543 if (pix->field == V4L2_FIELD_ANY)
544 pix->field = V4L2_FIELD_NONE;
545
546 return 0;
547 }
548
delta_try_fmt_frame(struct file * file,void * priv,struct v4l2_format * f)549 static int delta_try_fmt_frame(struct file *file, void *priv,
550 struct v4l2_format *f)
551 {
552 struct delta_ctx *ctx = file_to_ctx(file);
553 struct delta_dev *delta = ctx->dev;
554 struct v4l2_pix_format *pix = &f->fmt.pix;
555 u32 pixelformat = pix->pixelformat;
556 const struct delta_dec *dec;
557 u32 width, height;
558
559 dec = delta_find_decoder(ctx, ctx->streaminfo.streamformat,
560 pixelformat);
561 if (!dec) {
562 dev_dbg(delta->dev,
563 "%s V4L2 TRY_FMT (CAPTURE): unsupported format %4.4s\n",
564 ctx->name, (char *)&pixelformat);
565 return -EINVAL;
566 }
567
568 /* adjust width & height */
569 width = pix->width;
570 height = pix->height;
571 v4l_bound_align_image(&pix->width,
572 DELTA_MIN_WIDTH, DELTA_MAX_WIDTH,
573 frame_alignment(pixelformat) - 1,
574 &pix->height,
575 DELTA_MIN_HEIGHT, DELTA_MAX_HEIGHT,
576 frame_alignment(pixelformat) - 1, 0);
577
578 if ((pix->width != width) || (pix->height != height))
579 dev_dbg(delta->dev,
580 "%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",
581 ctx->name, width, height, pix->width, pix->height);
582
583 /* default decoder alignment constraint */
584 width = ALIGN(pix->width, DELTA_WIDTH_ALIGNMENT);
585 height = ALIGN(pix->height, DELTA_HEIGHT_ALIGNMENT);
586 if ((pix->width != width) || (pix->height != height))
587 dev_dbg(delta->dev,
588 "%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit decoder alignment\n",
589 ctx->name, width, height, pix->width, pix->height);
590
591 if (!pix->colorspace) {
592 pix->colorspace = V4L2_COLORSPACE_REC709;
593 pix->xfer_func = V4L2_XFER_FUNC_DEFAULT;
594 pix->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
595 pix->quantization = V4L2_QUANTIZATION_DEFAULT;
596 }
597
598 pix->width = width;
599 pix->height = height;
600 pix->bytesperline = frame_stride(pix->width, pixelformat);
601 pix->sizeimage = frame_size(pix->width, pix->height, pixelformat);
602
603 if (pix->field == V4L2_FIELD_ANY)
604 pix->field = V4L2_FIELD_NONE;
605
606 return 0;
607 }
608
delta_s_fmt_stream(struct file * file,void * fh,struct v4l2_format * f)609 static int delta_s_fmt_stream(struct file *file, void *fh,
610 struct v4l2_format *f)
611 {
612 struct delta_ctx *ctx = file_to_ctx(file);
613 struct delta_dev *delta = ctx->dev;
614 struct vb2_queue *vq;
615 struct v4l2_pix_format *pix = &f->fmt.pix;
616 int ret;
617
618 ret = delta_try_fmt_stream(file, fh, f);
619 if (ret) {
620 dev_dbg(delta->dev,
621 "%s V4L2 S_FMT (OUTPUT): unsupported format %4.4s\n",
622 ctx->name, (char *)&pix->pixelformat);
623 return ret;
624 }
625
626 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
627 if (vb2_is_streaming(vq)) {
628 dev_dbg(delta->dev, "%s V4L2 S_FMT (OUTPUT): queue busy\n",
629 ctx->name);
630 return -EBUSY;
631 }
632
633 ctx->max_au_size = pix->sizeimage;
634 ctx->streaminfo.width = pix->width;
635 ctx->streaminfo.height = pix->height;
636 ctx->streaminfo.streamformat = pix->pixelformat;
637 ctx->streaminfo.colorspace = pix->colorspace;
638 ctx->streaminfo.xfer_func = pix->xfer_func;
639 ctx->streaminfo.ycbcr_enc = pix->ycbcr_enc;
640 ctx->streaminfo.quantization = pix->quantization;
641 ctx->flags |= DELTA_FLAG_STREAMINFO;
642
643 return 0;
644 }
645
delta_s_fmt_frame(struct file * file,void * fh,struct v4l2_format * f)646 static int delta_s_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)
647 {
648 struct delta_ctx *ctx = file_to_ctx(file);
649 struct delta_dev *delta = ctx->dev;
650 const struct delta_dec *dec = ctx->dec;
651 struct v4l2_pix_format *pix = &f->fmt.pix;
652 struct delta_frameinfo frameinfo;
653 unsigned char str[100] = "";
654 struct vb2_queue *vq;
655 int ret;
656
657 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
658 if (vb2_is_streaming(vq)) {
659 dev_dbg(delta->dev, "%s V4L2 S_FMT (CAPTURE): queue busy\n",
660 ctx->name);
661 return -EBUSY;
662 }
663
664 if (ctx->state < DELTA_STATE_READY) {
665 /*
666 * decoder not yet opened and valid stream header not found,
667 * could not negotiate format with decoder, check at least
668 * pixel format & negotiate resolution boundaries
669 * and alignment...
670 */
671 ret = delta_try_fmt_frame(file, fh, f);
672 if (ret) {
673 dev_dbg(delta->dev,
674 "%s V4L2 S_FMT (CAPTURE): unsupported format %4.4s\n",
675 ctx->name, (char *)&pix->pixelformat);
676 return ret;
677 }
678
679 return 0;
680 }
681
682 /* set frame information to decoder */
683 memset(&frameinfo, 0, sizeof(frameinfo));
684 frameinfo.pixelformat = pix->pixelformat;
685 frameinfo.width = pix->width;
686 frameinfo.height = pix->height;
687 frameinfo.aligned_width = pix->width;
688 frameinfo.aligned_height = pix->height;
689 frameinfo.size = pix->sizeimage;
690 frameinfo.field = pix->field;
691 frameinfo.colorspace = pix->colorspace;
692 frameinfo.xfer_func = pix->xfer_func;
693 frameinfo.ycbcr_enc = pix->ycbcr_enc;
694 frameinfo.quantization = pix->quantization;
695 ret = call_dec_op(dec, set_frameinfo, ctx, &frameinfo);
696 if (ret)
697 return ret;
698
699 /* then get what decoder can really do */
700 ret = call_dec_op(dec, get_frameinfo, ctx, &frameinfo);
701 if (ret)
702 return ret;
703
704 ctx->flags |= DELTA_FLAG_FRAMEINFO;
705 ctx->frameinfo = frameinfo;
706 dev_dbg(delta->dev,
707 "%s V4L2 SET_FMT (CAPTURE): frameinfo updated to %s\n",
708 ctx->name,
709 delta_frameinfo_str(&frameinfo, str, sizeof(str)));
710
711 pix->pixelformat = frameinfo.pixelformat;
712 pix->width = frameinfo.aligned_width;
713 pix->height = frameinfo.aligned_height;
714 pix->bytesperline = frame_stride(pix->width, pix->pixelformat);
715 pix->sizeimage = frameinfo.size;
716 pix->field = frameinfo.field;
717 pix->colorspace = frameinfo.colorspace;
718 pix->xfer_func = frameinfo.xfer_func;
719 pix->ycbcr_enc = frameinfo.ycbcr_enc;
720 pix->quantization = frameinfo.quantization;
721
722 return 0;
723 }
724
delta_g_selection(struct file * file,void * fh,struct v4l2_selection * s)725 static int delta_g_selection(struct file *file, void *fh,
726 struct v4l2_selection *s)
727 {
728 struct delta_ctx *ctx = file_to_ctx(file);
729 struct delta_frameinfo *frameinfo = &ctx->frameinfo;
730 struct v4l2_rect crop;
731
732 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
733 return -EINVAL;
734
735 if ((ctx->flags & DELTA_FLAG_FRAMEINFO) &&
736 (frameinfo->flags & DELTA_FRAMEINFO_FLAG_CROP)) {
737 crop = frameinfo->crop;
738 } else {
739 /* default to video dimensions */
740 crop.left = 0;
741 crop.top = 0;
742 crop.width = frameinfo->width;
743 crop.height = frameinfo->height;
744 }
745
746 switch (s->target) {
747 case V4L2_SEL_TGT_COMPOSE:
748 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
749 /* visible area inside video */
750 s->r = crop;
751 break;
752 case V4L2_SEL_TGT_COMPOSE_PADDED:
753 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
754 /* up to aligned dimensions */
755 s->r.left = 0;
756 s->r.top = 0;
757 s->r.width = frameinfo->aligned_width;
758 s->r.height = frameinfo->aligned_height;
759 break;
760 default:
761 return -EINVAL;
762 }
763
764 return 0;
765 }
766
delta_complete_eos(struct delta_ctx * ctx,struct delta_frame * frame)767 static void delta_complete_eos(struct delta_ctx *ctx,
768 struct delta_frame *frame)
769 {
770 struct delta_dev *delta = ctx->dev;
771 const struct v4l2_event ev = {.type = V4L2_EVENT_EOS};
772
773 /*
774 * Send EOS to user:
775 * - by returning an empty frame flagged to V4L2_BUF_FLAG_LAST
776 * - and then send EOS event
777 */
778
779 /* empty frame */
780 frame->info.size = 0;
781
782 /* set the last buffer flag */
783 frame->flags |= V4L2_BUF_FLAG_LAST;
784
785 /* release frame to user */
786 delta_frame_done(ctx, frame, 0);
787
788 /* send EOS event */
789 v4l2_event_queue_fh(&ctx->fh, &ev);
790
791 dev_dbg(delta->dev, "%s EOS completed\n", ctx->name);
792 }
793
delta_try_decoder_cmd(struct file * file,void * fh,struct v4l2_decoder_cmd * cmd)794 static int delta_try_decoder_cmd(struct file *file, void *fh,
795 struct v4l2_decoder_cmd *cmd)
796 {
797 if (cmd->cmd != V4L2_DEC_CMD_STOP)
798 return -EINVAL;
799
800 if (cmd->flags & V4L2_DEC_CMD_STOP_TO_BLACK)
801 return -EINVAL;
802
803 if (!(cmd->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) &&
804 (cmd->stop.pts != 0))
805 return -EINVAL;
806
807 return 0;
808 }
809
delta_decoder_stop_cmd(struct delta_ctx * ctx)810 static int delta_decoder_stop_cmd(struct delta_ctx *ctx)
811 {
812 const struct delta_dec *dec = ctx->dec;
813 struct delta_dev *delta = ctx->dev;
814 struct delta_frame *frame = NULL;
815 int ret = 0;
816
817 dev_dbg(delta->dev, "%s EOS received\n", ctx->name);
818
819 if (ctx->state != DELTA_STATE_READY)
820 return 0;
821
822 /* drain the decoder */
823 call_dec_op(dec, drain, ctx);
824
825 /* release to user drained frames */
826 while (1) {
827 frame = NULL;
828 ret = call_dec_op(dec, get_frame, ctx, &frame);
829 if (ret == -ENODATA) {
830 /* no more decoded frames */
831 break;
832 }
833 if (frame) {
834 dev_dbg(delta->dev, "%s drain frame[%d]\n",
835 ctx->name, frame->index);
836
837 /* pop timestamp and mark frame with it */
838 delta_pop_dts(ctx, &frame->dts);
839
840 /* release decoded frame to user */
841 delta_frame_done(ctx, frame, 0);
842 }
843 }
844
845 /* try to complete EOS */
846 ret = delta_get_free_frame(ctx, &frame);
847 if (ret)
848 goto delay_eos;
849
850 /* new frame available, EOS can now be completed */
851 delta_complete_eos(ctx, frame);
852
853 ctx->state = DELTA_STATE_EOS;
854
855 return 0;
856
857 delay_eos:
858 /*
859 * EOS completion from driver is delayed because
860 * we don't have a free empty frame available.
861 * EOS completion is so delayed till next frame_queue() call
862 * to be sure to have a free empty frame available.
863 */
864 ctx->state = DELTA_STATE_WF_EOS;
865 dev_dbg(delta->dev, "%s EOS delayed\n", ctx->name);
866
867 return 0;
868 }
869
delta_decoder_cmd(struct file * file,void * fh,struct v4l2_decoder_cmd * cmd)870 static int delta_decoder_cmd(struct file *file, void *fh,
871 struct v4l2_decoder_cmd *cmd)
872 {
873 struct delta_ctx *ctx = file_to_ctx(file);
874 int ret = 0;
875
876 ret = delta_try_decoder_cmd(file, fh, cmd);
877 if (ret)
878 return ret;
879
880 return delta_decoder_stop_cmd(ctx);
881 }
882
delta_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)883 static int delta_subscribe_event(struct v4l2_fh *fh,
884 const struct v4l2_event_subscription *sub)
885 {
886 switch (sub->type) {
887 case V4L2_EVENT_EOS:
888 return v4l2_event_subscribe(fh, sub, 2, NULL);
889 default:
890 return -EINVAL;
891 }
892
893 return 0;
894 }
895
896 /* v4l2 ioctl ops */
897 static const struct v4l2_ioctl_ops delta_ioctl_ops = {
898 .vidioc_querycap = delta_querycap,
899 .vidioc_enum_fmt_vid_cap = delta_enum_fmt_frame,
900 .vidioc_g_fmt_vid_cap = delta_g_fmt_frame,
901 .vidioc_try_fmt_vid_cap = delta_try_fmt_frame,
902 .vidioc_s_fmt_vid_cap = delta_s_fmt_frame,
903 .vidioc_enum_fmt_vid_out = delta_enum_fmt_stream,
904 .vidioc_g_fmt_vid_out = delta_g_fmt_stream,
905 .vidioc_try_fmt_vid_out = delta_try_fmt_stream,
906 .vidioc_s_fmt_vid_out = delta_s_fmt_stream,
907 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
908 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
909 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
910 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
911 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
912 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
913 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
914 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
915 .vidioc_g_selection = delta_g_selection,
916 .vidioc_try_decoder_cmd = delta_try_decoder_cmd,
917 .vidioc_decoder_cmd = delta_decoder_cmd,
918 .vidioc_subscribe_event = delta_subscribe_event,
919 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
920 };
921
922 /*
923 * mem-to-mem operations
924 */
925
delta_run_work(struct work_struct * work)926 static void delta_run_work(struct work_struct *work)
927 {
928 struct delta_ctx *ctx = container_of(work, struct delta_ctx, run_work);
929 struct delta_dev *delta = ctx->dev;
930 const struct delta_dec *dec = ctx->dec;
931 struct delta_au *au;
932 struct delta_frame *frame = NULL;
933 int ret = 0;
934 bool discard = false;
935 struct vb2_v4l2_buffer *vbuf;
936
937 if (!dec) {
938 dev_err(delta->dev, "%s no decoder opened yet\n", ctx->name);
939 return;
940 }
941
942 /* protect instance against reentrancy */
943 mutex_lock(&ctx->lock);
944
945 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
946 if (!vbuf) {
947 dev_err(delta->dev, "%s no buffer to decode\n", ctx->name);
948 mutex_unlock(&ctx->lock);
949 return;
950 }
951 au = to_au(vbuf);
952 au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);
953 au->dts = vbuf->vb2_buf.timestamp;
954
955 /* dump access unit */
956 dump_au(ctx, au);
957
958 /* enable the hardware */
959 if (!dec->pm) {
960 ret = delta_get_sync(ctx);
961 if (ret)
962 goto err;
963 }
964
965 /* decode this access unit */
966 ret = call_dec_op(dec, decode, ctx, au);
967
968 /*
969 * if the (-ENODATA) value is returned, it refers to the interlaced
970 * stream case for which 2 access units are needed to get 1 frame.
971 * So, this returned value doesn't mean that the decoding fails, but
972 * indicates that the timestamp information of the access unit shall
973 * not be taken into account, and that the V4L2 buffer associated with
974 * the access unit shall be flagged with V4L2_BUF_FLAG_ERROR to inform
975 * the user of this situation
976 */
977 if (ret == -ENODATA) {
978 discard = true;
979 } else if (ret) {
980 dev_err(delta->dev, "%s decoding failed (%d)\n",
981 ctx->name, ret);
982
983 /* disable the hardware */
984 if (!dec->pm)
985 delta_put_autosuspend(ctx);
986
987 goto err;
988 }
989
990 /* disable the hardware */
991 if (!dec->pm)
992 delta_put_autosuspend(ctx);
993
994 /* push au timestamp in FIFO */
995 if (!discard)
996 delta_push_dts(ctx, au->dts);
997
998 /* get available decoded frames */
999 while (1) {
1000 ret = call_dec_op(dec, get_frame, ctx, &frame);
1001 if (ret == -ENODATA) {
1002 /* no more decoded frames */
1003 goto out;
1004 }
1005 if (ret) {
1006 dev_err(delta->dev, "%s cannot get decoded frame (%d)\n",
1007 ctx->name, ret);
1008 goto out;
1009 }
1010 if (!frame) {
1011 dev_err(delta->dev,
1012 "%s NULL decoded frame\n",
1013 ctx->name);
1014 goto out;
1015 }
1016
1017 /* pop timestamp and mark frame with it */
1018 delta_pop_dts(ctx, &frame->dts);
1019
1020 /* release decoded frame to user */
1021 delta_frame_done(ctx, frame, 0);
1022 }
1023
1024 out:
1025 requeue_free_frames(ctx);
1026 delta_au_done(ctx, au, (discard ? -ENODATA : 0));
1027 mutex_unlock(&ctx->lock);
1028 v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);
1029 return;
1030
1031 err:
1032 requeue_free_frames(ctx);
1033 delta_au_done(ctx, au, ret);
1034 mutex_unlock(&ctx->lock);
1035 v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);
1036 }
1037
delta_device_run(void * priv)1038 static void delta_device_run(void *priv)
1039 {
1040 struct delta_ctx *ctx = priv;
1041 struct delta_dev *delta = ctx->dev;
1042
1043 queue_work(delta->work_queue, &ctx->run_work);
1044 }
1045
delta_job_abort(void * priv)1046 static void delta_job_abort(void *priv)
1047 {
1048 struct delta_ctx *ctx = priv;
1049 struct delta_dev *delta = ctx->dev;
1050
1051 dev_dbg(delta->dev, "%s aborting job\n", ctx->name);
1052
1053 ctx->aborting = true;
1054 }
1055
delta_job_ready(void * priv)1056 static int delta_job_ready(void *priv)
1057 {
1058 struct delta_ctx *ctx = priv;
1059 struct delta_dev *delta = ctx->dev;
1060 int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx);
1061
1062 if (!src_bufs) {
1063 dev_dbg(delta->dev, "%s not ready: not enough video buffers.\n",
1064 ctx->name);
1065 return 0;
1066 }
1067
1068 if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) {
1069 dev_dbg(delta->dev, "%s not ready: not enough video capture buffers.\n",
1070 ctx->name);
1071 return 0;
1072 }
1073
1074 if (ctx->aborting) {
1075 dev_dbg(delta->dev, "%s job not ready: aborting\n", ctx->name);
1076 return 0;
1077 }
1078
1079 dev_dbg(delta->dev, "%s job ready\n", ctx->name);
1080
1081 return 1;
1082 }
1083
1084 /* mem-to-mem ops */
1085 static const struct v4l2_m2m_ops delta_m2m_ops = {
1086 .device_run = delta_device_run,
1087 .job_ready = delta_job_ready,
1088 .job_abort = delta_job_abort,
1089 };
1090
1091 /*
1092 * VB2 queue operations
1093 */
1094
delta_vb2_au_queue_setup(struct vb2_queue * vq,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])1095 static int delta_vb2_au_queue_setup(struct vb2_queue *vq,
1096 unsigned int *num_buffers,
1097 unsigned int *num_planes,
1098 unsigned int sizes[],
1099 struct device *alloc_devs[])
1100 {
1101 struct delta_ctx *ctx = vb2_get_drv_priv(vq);
1102 unsigned int size = ctx->max_au_size;
1103
1104 if (*num_planes)
1105 return sizes[0] < size ? -EINVAL : 0;
1106
1107 *num_planes = 1;
1108 if (*num_buffers < 1)
1109 *num_buffers = 1;
1110 if (*num_buffers > DELTA_MAX_AUS)
1111 *num_buffers = DELTA_MAX_AUS;
1112
1113 sizes[0] = size;
1114
1115 return 0;
1116 }
1117
delta_vb2_au_prepare(struct vb2_buffer * vb)1118 static int delta_vb2_au_prepare(struct vb2_buffer *vb)
1119 {
1120 struct vb2_queue *q = vb->vb2_queue;
1121 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1122 struct delta_dev *delta = ctx->dev;
1123 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1124 struct delta_au *au = to_au(vbuf);
1125
1126 if (!au->prepared) {
1127 /* get memory addresses */
1128 au->vaddr = vb2_plane_vaddr(&au->vbuf.vb2_buf, 0);
1129 au->paddr = vb2_dma_contig_plane_dma_addr
1130 (&au->vbuf.vb2_buf, 0);
1131 au->prepared = true;
1132 dev_dbg(delta->dev, "%s au[%d] prepared; virt=0x%p, phy=0x%pad\n",
1133 ctx->name, vb->index, au->vaddr, &au->paddr);
1134 }
1135
1136 if (vbuf->field == V4L2_FIELD_ANY)
1137 vbuf->field = V4L2_FIELD_NONE;
1138
1139 return 0;
1140 }
1141
delta_setup_frame(struct delta_ctx * ctx,struct delta_frame * frame)1142 static int delta_setup_frame(struct delta_ctx *ctx,
1143 struct delta_frame *frame)
1144 {
1145 struct delta_dev *delta = ctx->dev;
1146 const struct delta_dec *dec = ctx->dec;
1147
1148 if (frame->index >= DELTA_MAX_FRAMES) {
1149 dev_err(delta->dev,
1150 "%s frame index=%d exceeds output frame count (%d)\n",
1151 ctx->name, frame->index, DELTA_MAX_FRAMES);
1152 return -EINVAL;
1153 }
1154
1155 if (ctx->nb_of_frames >= DELTA_MAX_FRAMES) {
1156 dev_err(delta->dev,
1157 "%s number of frames exceeds output frame count (%d > %d)\n",
1158 ctx->name, ctx->nb_of_frames, DELTA_MAX_FRAMES);
1159 return -EINVAL;
1160 }
1161
1162 if (frame->index != ctx->nb_of_frames) {
1163 dev_warn(delta->dev,
1164 "%s frame index discontinuity detected, expected %d, got %d\n",
1165 ctx->name, ctx->nb_of_frames, frame->index);
1166 }
1167
1168 frame->state = DELTA_FRAME_FREE;
1169 ctx->frames[ctx->nb_of_frames] = frame;
1170 ctx->nb_of_frames++;
1171
1172 /* setup frame on decoder side */
1173 return call_dec_op(dec, setup_frame, ctx, frame);
1174 }
1175
1176 /*
1177 * default implementation of get_frameinfo decoder ops
1178 * matching frame information from stream information
1179 * & with default pixel format & default alignment.
1180 */
delta_get_frameinfo_default(struct delta_ctx * ctx,struct delta_frameinfo * frameinfo)1181 int delta_get_frameinfo_default(struct delta_ctx *ctx,
1182 struct delta_frameinfo *frameinfo)
1183 {
1184 struct delta_streaminfo *streaminfo = &ctx->streaminfo;
1185
1186 memset(frameinfo, 0, sizeof(*frameinfo));
1187 frameinfo->pixelformat = V4L2_PIX_FMT_NV12;
1188 frameinfo->width = streaminfo->width;
1189 frameinfo->height = streaminfo->height;
1190 frameinfo->aligned_width = ALIGN(streaminfo->width,
1191 DELTA_WIDTH_ALIGNMENT);
1192 frameinfo->aligned_height = ALIGN(streaminfo->height,
1193 DELTA_HEIGHT_ALIGNMENT);
1194 frameinfo->size = frame_size(frameinfo->aligned_width,
1195 frameinfo->aligned_height,
1196 frameinfo->pixelformat);
1197 if (streaminfo->flags & DELTA_STREAMINFO_FLAG_CROP) {
1198 frameinfo->flags |= DELTA_FRAMEINFO_FLAG_CROP;
1199 frameinfo->crop = streaminfo->crop;
1200 }
1201 if (streaminfo->flags & DELTA_STREAMINFO_FLAG_PIXELASPECT) {
1202 frameinfo->flags |= DELTA_FRAMEINFO_FLAG_PIXELASPECT;
1203 frameinfo->pixelaspect = streaminfo->pixelaspect;
1204 }
1205 frameinfo->field = streaminfo->field;
1206
1207 return 0;
1208 }
1209
1210 /*
1211 * default implementation of recycle decoder ops
1212 * consisting to relax the "decoded" frame state
1213 */
delta_recycle_default(struct delta_ctx * pctx,struct delta_frame * frame)1214 int delta_recycle_default(struct delta_ctx *pctx,
1215 struct delta_frame *frame)
1216 {
1217 frame->state &= ~DELTA_FRAME_DEC;
1218
1219 return 0;
1220 }
1221
dump_frames_status(struct delta_ctx * ctx)1222 static void dump_frames_status(struct delta_ctx *ctx)
1223 {
1224 struct delta_dev *delta = ctx->dev;
1225 unsigned int i;
1226 struct delta_frame *frame;
1227 unsigned char str[100] = "";
1228
1229 dev_info(delta->dev,
1230 "%s dumping frames status...\n", ctx->name);
1231
1232 for (i = 0; i < ctx->nb_of_frames; i++) {
1233 frame = ctx->frames[i];
1234 dev_info(delta->dev,
1235 "%s frame[%d] %s\n",
1236 ctx->name, frame->index,
1237 frame_state_str(frame->state,
1238 str, sizeof(str)));
1239 }
1240 }
1241
delta_get_free_frame(struct delta_ctx * ctx,struct delta_frame ** pframe)1242 int delta_get_free_frame(struct delta_ctx *ctx,
1243 struct delta_frame **pframe)
1244 {
1245 struct delta_dev *delta = ctx->dev;
1246 struct vb2_v4l2_buffer *vbuf;
1247 struct delta_frame *frame;
1248
1249 *pframe = NULL;
1250
1251 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1252 if (!vbuf) {
1253 dev_err(delta->dev, "%s no frame available",
1254 ctx->name);
1255 return -EIO;
1256 }
1257
1258 frame = to_frame(vbuf);
1259 frame->state &= ~DELTA_FRAME_M2M;
1260 if (frame->state != DELTA_FRAME_FREE) {
1261 dev_err(delta->dev,
1262 "%s frame[%d] is not free\n",
1263 ctx->name, frame->index);
1264 dump_frames_status(ctx);
1265 return -ENODATA;
1266 }
1267
1268 dev_dbg(delta->dev,
1269 "%s get free frame[%d]\n", ctx->name, frame->index);
1270
1271 *pframe = frame;
1272 return 0;
1273 }
1274
delta_get_sync(struct delta_ctx * ctx)1275 int delta_get_sync(struct delta_ctx *ctx)
1276 {
1277 struct delta_dev *delta = ctx->dev;
1278 int ret = 0;
1279
1280 /* enable the hardware */
1281 ret = pm_runtime_resume_and_get(delta->dev);
1282 if (ret < 0) {
1283 dev_err(delta->dev, "%s pm_runtime_resume_and_get failed (%d)\n",
1284 __func__, ret);
1285 return ret;
1286 }
1287
1288 return 0;
1289 }
1290
delta_put_autosuspend(struct delta_ctx * ctx)1291 void delta_put_autosuspend(struct delta_ctx *ctx)
1292 {
1293 struct delta_dev *delta = ctx->dev;
1294
1295 pm_runtime_put_autosuspend(delta->dev);
1296 }
1297
delta_vb2_au_queue(struct vb2_buffer * vb)1298 static void delta_vb2_au_queue(struct vb2_buffer *vb)
1299 {
1300 struct vb2_queue *q = vb->vb2_queue;
1301 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1302 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1303
1304 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
1305 }
1306
delta_vb2_au_start_streaming(struct vb2_queue * q,unsigned int count)1307 static int delta_vb2_au_start_streaming(struct vb2_queue *q,
1308 unsigned int count)
1309 {
1310 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1311 struct delta_dev *delta = ctx->dev;
1312 const struct delta_dec *dec = ctx->dec;
1313 struct delta_au *au;
1314 int ret = 0;
1315 struct vb2_v4l2_buffer *vbuf = NULL;
1316 struct delta_streaminfo *streaminfo = &ctx->streaminfo;
1317 struct delta_frameinfo *frameinfo = &ctx->frameinfo;
1318 unsigned char str1[100] = "";
1319 unsigned char str2[100] = "";
1320
1321 if ((ctx->state != DELTA_STATE_WF_FORMAT) &&
1322 (ctx->state != DELTA_STATE_WF_STREAMINFO))
1323 return 0;
1324
1325 if (ctx->state == DELTA_STATE_WF_FORMAT) {
1326 /* open decoder if not yet done */
1327 ret = delta_open_decoder(ctx,
1328 ctx->streaminfo.streamformat,
1329 ctx->frameinfo.pixelformat, &dec);
1330 if (ret)
1331 goto err;
1332 ctx->dec = dec;
1333 ctx->state = DELTA_STATE_WF_STREAMINFO;
1334 }
1335
1336 /*
1337 * first buffer should contain stream header,
1338 * decode it to get the infos related to stream
1339 * such as width, height, dpb, ...
1340 */
1341 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1342 if (!vbuf) {
1343 dev_err(delta->dev, "%s failed to start streaming, no stream header buffer enqueued\n",
1344 ctx->name);
1345 ret = -EINVAL;
1346 goto err;
1347 }
1348 au = to_au(vbuf);
1349 au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);
1350 au->dts = vbuf->vb2_buf.timestamp;
1351
1352 delta_push_dts(ctx, au->dts);
1353
1354 /* dump access unit */
1355 dump_au(ctx, au);
1356
1357 /* decode this access unit */
1358 ret = call_dec_op(dec, decode, ctx, au);
1359 if (ret) {
1360 dev_err(delta->dev, "%s failed to start streaming, header decoding failed (%d)\n",
1361 ctx->name, ret);
1362 goto err;
1363 }
1364
1365 ret = call_dec_op(dec, get_streaminfo, ctx, streaminfo);
1366 if (ret) {
1367 dev_dbg_ratelimited(delta->dev,
1368 "%s failed to start streaming, valid stream header not yet decoded\n",
1369 ctx->name);
1370 goto err;
1371 }
1372 ctx->flags |= DELTA_FLAG_STREAMINFO;
1373
1374 ret = call_dec_op(dec, get_frameinfo, ctx, frameinfo);
1375 if (ret)
1376 goto err;
1377 ctx->flags |= DELTA_FLAG_FRAMEINFO;
1378
1379 ctx->state = DELTA_STATE_READY;
1380
1381 dev_dbg(delta->dev, "%s %s => %s\n", ctx->name,
1382 delta_streaminfo_str(streaminfo, str1, sizeof(str1)),
1383 delta_frameinfo_str(frameinfo, str2, sizeof(str2)));
1384
1385 delta_au_done(ctx, au, ret);
1386 return 0;
1387
1388 err:
1389 /*
1390 * return all buffers to vb2 in QUEUED state.
1391 * This will give ownership back to userspace
1392 */
1393 if (vbuf)
1394 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);
1395
1396 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1397 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);
1398 return ret;
1399 }
1400
delta_vb2_au_stop_streaming(struct vb2_queue * q)1401 static void delta_vb2_au_stop_streaming(struct vb2_queue *q)
1402 {
1403 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1404 struct vb2_v4l2_buffer *vbuf;
1405
1406 delta_flush_dts(ctx);
1407
1408 /* return all buffers to vb2 in ERROR state */
1409 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1410 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
1411
1412 ctx->au_num = 0;
1413
1414 ctx->aborting = false;
1415 }
1416
delta_vb2_frame_queue_setup(struct vb2_queue * vq,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])1417 static int delta_vb2_frame_queue_setup(struct vb2_queue *vq,
1418 unsigned int *num_buffers,
1419 unsigned int *num_planes,
1420 unsigned int sizes[],
1421 struct device *alloc_devs[])
1422 {
1423 struct delta_ctx *ctx = vb2_get_drv_priv(vq);
1424 struct delta_dev *delta = ctx->dev;
1425 struct delta_streaminfo *streaminfo = &ctx->streaminfo;
1426 struct delta_frameinfo *frameinfo = &ctx->frameinfo;
1427 unsigned int size = frameinfo->size;
1428
1429 /*
1430 * the number of output buffers needed for decoding =
1431 * user need (*num_buffers given, usually for display pipeline) +
1432 * stream need (streaminfo->dpb) +
1433 * decoding peak smoothing (depends on DELTA IP perf)
1434 */
1435 if (*num_buffers < DELTA_MIN_FRAME_USER) {
1436 dev_dbg(delta->dev,
1437 "%s num_buffers too low (%d), increasing to %d\n",
1438 ctx->name, *num_buffers, DELTA_MIN_FRAME_USER);
1439 *num_buffers = DELTA_MIN_FRAME_USER;
1440 }
1441
1442 *num_buffers += streaminfo->dpb + DELTA_PEAK_FRAME_SMOOTHING;
1443
1444 if (*num_buffers > DELTA_MAX_FRAMES) {
1445 dev_dbg(delta->dev,
1446 "%s output frame count too high (%d), cut to %d\n",
1447 ctx->name, *num_buffers, DELTA_MAX_FRAMES);
1448 *num_buffers = DELTA_MAX_FRAMES;
1449 }
1450
1451 if (*num_planes)
1452 return sizes[0] < size ? -EINVAL : 0;
1453
1454 /* single plane for Y and CbCr */
1455 *num_planes = 1;
1456
1457 sizes[0] = size;
1458
1459 ctx->nb_of_frames = 0;
1460
1461 return 0;
1462 }
1463
delta_vb2_frame_prepare(struct vb2_buffer * vb)1464 static int delta_vb2_frame_prepare(struct vb2_buffer *vb)
1465 {
1466 struct vb2_queue *q = vb->vb2_queue;
1467 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1468 struct delta_dev *delta = ctx->dev;
1469 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1470 struct delta_frame *frame = to_frame(vbuf);
1471 int ret = 0;
1472
1473 if (!frame->prepared) {
1474 frame->index = vbuf->vb2_buf.index;
1475 frame->vaddr = vb2_plane_vaddr(&vbuf->vb2_buf, 0);
1476 frame->paddr = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0);
1477 frame->info = ctx->frameinfo;
1478
1479 ret = delta_setup_frame(ctx, frame);
1480 if (ret) {
1481 dev_err(delta->dev,
1482 "%s setup_frame() failed (%d)\n",
1483 ctx->name, ret);
1484 return ret;
1485 }
1486 frame->prepared = true;
1487 dev_dbg(delta->dev,
1488 "%s frame[%d] prepared; virt=0x%p, phy=0x%pad\n",
1489 ctx->name, vb->index, frame->vaddr,
1490 &frame->paddr);
1491 }
1492
1493 frame->flags = vbuf->flags;
1494
1495 return 0;
1496 }
1497
delta_vb2_frame_finish(struct vb2_buffer * vb)1498 static void delta_vb2_frame_finish(struct vb2_buffer *vb)
1499 {
1500 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1501 struct delta_frame *frame = to_frame(vbuf);
1502
1503 /* update V4L2 fields for user */
1504 vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->info.size);
1505 vb->timestamp = frame->dts;
1506 vbuf->field = frame->field;
1507 vbuf->flags = frame->flags;
1508 }
1509
delta_vb2_frame_queue(struct vb2_buffer * vb)1510 static void delta_vb2_frame_queue(struct vb2_buffer *vb)
1511 {
1512 struct vb2_queue *q = vb->vb2_queue;
1513 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1514 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1515 struct delta_frame *frame = to_frame(vbuf);
1516
1517 if (ctx->state == DELTA_STATE_WF_EOS) {
1518 /* new frame available, EOS can now be completed */
1519 delta_complete_eos(ctx, frame);
1520
1521 ctx->state = DELTA_STATE_EOS;
1522
1523 /* return, no need to recycle this buffer to decoder */
1524 return;
1525 }
1526
1527 /* recycle this frame */
1528 delta_recycle(ctx, frame);
1529 }
1530
delta_vb2_frame_stop_streaming(struct vb2_queue * q)1531 static void delta_vb2_frame_stop_streaming(struct vb2_queue *q)
1532 {
1533 struct delta_ctx *ctx = vb2_get_drv_priv(q);
1534 struct vb2_v4l2_buffer *vbuf;
1535 struct delta_frame *frame;
1536 const struct delta_dec *dec = ctx->dec;
1537 unsigned int i;
1538
1539 delta_flush_dts(ctx);
1540
1541 call_dec_op(dec, flush, ctx);
1542
1543 /*
1544 * return all buffers to vb2 in ERROR state
1545 * & reset each frame state to OUT
1546 */
1547 for (i = 0; i < ctx->nb_of_frames; i++) {
1548 frame = ctx->frames[i];
1549 if (!(frame->state & DELTA_FRAME_OUT)) {
1550 vbuf = &frame->vbuf;
1551 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
1552 }
1553 frame->state = DELTA_FRAME_OUT;
1554 }
1555
1556 ctx->frame_num = 0;
1557
1558 ctx->aborting = false;
1559 }
1560
1561 /* VB2 queue ops */
1562 static const struct vb2_ops delta_vb2_au_ops = {
1563 .queue_setup = delta_vb2_au_queue_setup,
1564 .buf_prepare = delta_vb2_au_prepare,
1565 .buf_queue = delta_vb2_au_queue,
1566 .start_streaming = delta_vb2_au_start_streaming,
1567 .stop_streaming = delta_vb2_au_stop_streaming,
1568 };
1569
1570 static const struct vb2_ops delta_vb2_frame_ops = {
1571 .queue_setup = delta_vb2_frame_queue_setup,
1572 .buf_prepare = delta_vb2_frame_prepare,
1573 .buf_finish = delta_vb2_frame_finish,
1574 .buf_queue = delta_vb2_frame_queue,
1575 .stop_streaming = delta_vb2_frame_stop_streaming,
1576 };
1577
1578 /*
1579 * V4L2 file operations
1580 */
1581
queue_init(void * priv,struct vb2_queue * src_vq,struct vb2_queue * dst_vq)1582 static int queue_init(void *priv,
1583 struct vb2_queue *src_vq, struct vb2_queue *dst_vq)
1584 {
1585 struct vb2_queue *q;
1586 struct delta_ctx *ctx = priv;
1587 struct delta_dev *delta = ctx->dev;
1588 int ret;
1589
1590 /* setup vb2 queue for stream input */
1591 q = src_vq;
1592 q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1593 q->io_modes = VB2_MMAP | VB2_DMABUF;
1594 q->drv_priv = ctx;
1595 /* overload vb2 buf with private au struct */
1596 q->buf_struct_size = sizeof(struct delta_au);
1597 q->ops = &delta_vb2_au_ops;
1598 q->mem_ops = &vb2_dma_contig_memops;
1599 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1600 q->lock = &delta->lock;
1601 q->dev = delta->dev;
1602
1603 ret = vb2_queue_init(q);
1604 if (ret)
1605 return ret;
1606
1607 /* setup vb2 queue for frame output */
1608 q = dst_vq;
1609 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1610 q->io_modes = VB2_MMAP | VB2_DMABUF;
1611 q->drv_priv = ctx;
1612 /* overload vb2 buf with private frame struct */
1613 q->buf_struct_size = sizeof(struct delta_frame)
1614 + DELTA_MAX_FRAME_PRIV_SIZE;
1615 q->ops = &delta_vb2_frame_ops;
1616 q->mem_ops = &vb2_dma_contig_memops;
1617 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1618 q->lock = &delta->lock;
1619 q->dev = delta->dev;
1620
1621 return vb2_queue_init(q);
1622 }
1623
delta_open(struct file * file)1624 static int delta_open(struct file *file)
1625 {
1626 struct delta_dev *delta = video_drvdata(file);
1627 struct delta_ctx *ctx = NULL;
1628 int ret = 0;
1629
1630 mutex_lock(&delta->lock);
1631
1632 ctx = kzalloc_obj(*ctx);
1633 if (!ctx) {
1634 ret = -ENOMEM;
1635 goto err;
1636 }
1637 ctx->dev = delta;
1638
1639 v4l2_fh_init(&ctx->fh, video_devdata(file));
1640 v4l2_fh_add(&ctx->fh, file);
1641
1642 INIT_WORK(&ctx->run_work, delta_run_work);
1643 mutex_init(&ctx->lock);
1644
1645 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(delta->m2m_dev, ctx,
1646 queue_init);
1647 if (IS_ERR(ctx->fh.m2m_ctx)) {
1648 ret = PTR_ERR(ctx->fh.m2m_ctx);
1649 dev_err(delta->dev, "%s failed to initialize m2m context (%d)\n",
1650 DELTA_PREFIX, ret);
1651 goto err_fh_del;
1652 }
1653
1654 /*
1655 * wait stream format to determine which
1656 * decoder to open
1657 */
1658 ctx->state = DELTA_STATE_WF_FORMAT;
1659
1660 INIT_LIST_HEAD(&ctx->dts);
1661
1662 /* set the instance name */
1663 delta->instance_id++;
1664 snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]",
1665 delta->instance_id);
1666
1667 /* default parameters for frame and stream */
1668 set_default_params(ctx);
1669
1670 /* enable ST231 clocks */
1671 if (clk_prepare_enable(delta->clk_st231))
1672 dev_warn(delta->dev, "failed to enable st231 clk\n");
1673
1674 /* enable FLASH_PROMIP clock */
1675 if (clk_prepare_enable(delta->clk_flash_promip))
1676 dev_warn(delta->dev, "failed to enable delta promip clk\n");
1677
1678 mutex_unlock(&delta->lock);
1679
1680 dev_dbg(delta->dev, "%s decoder instance created\n", ctx->name);
1681
1682 return 0;
1683
1684 err_fh_del:
1685 v4l2_fh_del(&ctx->fh, file);
1686 v4l2_fh_exit(&ctx->fh);
1687 kfree(ctx);
1688 err:
1689 mutex_unlock(&delta->lock);
1690
1691 return ret;
1692 }
1693
delta_release(struct file * file)1694 static int delta_release(struct file *file)
1695 {
1696 struct delta_ctx *ctx = file_to_ctx(file);
1697 struct delta_dev *delta = ctx->dev;
1698 const struct delta_dec *dec = ctx->dec;
1699
1700 mutex_lock(&delta->lock);
1701
1702 /* close decoder */
1703 call_dec_op(dec, close, ctx);
1704
1705 /*
1706 * trace a summary of instance
1707 * before closing (debug purpose)
1708 */
1709 delta_trace_summary(ctx);
1710
1711 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1712
1713 v4l2_fh_del(&ctx->fh, file);
1714 v4l2_fh_exit(&ctx->fh);
1715
1716 /* disable ST231 clocks */
1717 clk_disable_unprepare(delta->clk_st231);
1718
1719 /* disable FLASH_PROMIP clock */
1720 clk_disable_unprepare(delta->clk_flash_promip);
1721
1722 dev_dbg(delta->dev, "%s decoder instance released\n", ctx->name);
1723
1724 kfree(ctx);
1725
1726 mutex_unlock(&delta->lock);
1727 return 0;
1728 }
1729
1730 /* V4L2 file ops */
1731 static const struct v4l2_file_operations delta_fops = {
1732 .owner = THIS_MODULE,
1733 .open = delta_open,
1734 .release = delta_release,
1735 .unlocked_ioctl = video_ioctl2,
1736 .mmap = v4l2_m2m_fop_mmap,
1737 .poll = v4l2_m2m_fop_poll,
1738 };
1739
1740 /*
1741 * Platform device operations
1742 */
1743
delta_register_device(struct delta_dev * delta)1744 static int delta_register_device(struct delta_dev *delta)
1745 {
1746 int ret;
1747 struct video_device *vdev;
1748
1749 if (!delta)
1750 return -ENODEV;
1751
1752 delta->m2m_dev = v4l2_m2m_init(&delta_m2m_ops);
1753 if (IS_ERR(delta->m2m_dev)) {
1754 dev_err(delta->dev, "%s failed to initialize v4l2-m2m device\n",
1755 DELTA_PREFIX);
1756 ret = PTR_ERR(delta->m2m_dev);
1757 goto err;
1758 }
1759
1760 vdev = video_device_alloc();
1761 if (!vdev) {
1762 dev_err(delta->dev, "%s failed to allocate video device\n",
1763 DELTA_PREFIX);
1764 ret = -ENOMEM;
1765 goto err_m2m_release;
1766 }
1767
1768 vdev->fops = &delta_fops;
1769 vdev->ioctl_ops = &delta_ioctl_ops;
1770 vdev->release = video_device_release;
1771 vdev->lock = &delta->lock;
1772 vdev->vfl_dir = VFL_DIR_M2M;
1773 vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
1774 vdev->v4l2_dev = &delta->v4l2_dev;
1775 snprintf(vdev->name, sizeof(vdev->name), "%s-%s",
1776 DELTA_NAME, DELTA_FW_VERSION);
1777
1778 ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1779 if (ret) {
1780 dev_err(delta->dev, "%s failed to register video device\n",
1781 DELTA_PREFIX);
1782 goto err_vdev_release;
1783 }
1784
1785 delta->vdev = vdev;
1786 video_set_drvdata(vdev, delta);
1787 return 0;
1788
1789 err_vdev_release:
1790 video_device_release(vdev);
1791 err_m2m_release:
1792 v4l2_m2m_release(delta->m2m_dev);
1793 err:
1794 return ret;
1795 }
1796
delta_unregister_device(struct delta_dev * delta)1797 static void delta_unregister_device(struct delta_dev *delta)
1798 {
1799 if (!delta)
1800 return;
1801
1802 if (delta->m2m_dev)
1803 v4l2_m2m_release(delta->m2m_dev);
1804
1805 video_unregister_device(delta->vdev);
1806 }
1807
delta_probe(struct platform_device * pdev)1808 static int delta_probe(struct platform_device *pdev)
1809 {
1810 struct delta_dev *delta;
1811 struct device *dev = &pdev->dev;
1812 int ret;
1813
1814 delta = devm_kzalloc(dev, sizeof(*delta), GFP_KERNEL);
1815 if (!delta) {
1816 ret = -ENOMEM;
1817 goto err;
1818 }
1819
1820 delta->dev = dev;
1821 delta->pdev = pdev;
1822 platform_set_drvdata(pdev, delta);
1823
1824 mutex_init(&delta->lock);
1825
1826 /* get clock resources */
1827 delta->clk_delta = devm_clk_get(dev, "delta");
1828 if (IS_ERR(delta->clk_delta)) {
1829 dev_dbg(dev, "%s can't get delta clock\n", DELTA_PREFIX);
1830 delta->clk_delta = NULL;
1831 }
1832
1833 delta->clk_st231 = devm_clk_get(dev, "delta-st231");
1834 if (IS_ERR(delta->clk_st231)) {
1835 dev_dbg(dev, "%s can't get delta-st231 clock\n", DELTA_PREFIX);
1836 delta->clk_st231 = NULL;
1837 }
1838
1839 delta->clk_flash_promip = devm_clk_get(dev, "delta-flash-promip");
1840 if (IS_ERR(delta->clk_flash_promip)) {
1841 dev_dbg(dev, "%s can't get delta-flash-promip clock\n",
1842 DELTA_PREFIX);
1843 delta->clk_flash_promip = NULL;
1844 }
1845
1846 /* init pm_runtime used for power management */
1847 pm_runtime_set_autosuspend_delay(dev, DELTA_HW_AUTOSUSPEND_DELAY_MS);
1848 pm_runtime_use_autosuspend(dev);
1849 pm_runtime_set_suspended(dev);
1850 pm_runtime_enable(dev);
1851
1852 /* init firmware ipc channel */
1853 ret = delta_ipc_init(delta);
1854 if (ret) {
1855 dev_err(delta->dev, "%s failed to initialize firmware ipc channel\n",
1856 DELTA_PREFIX);
1857 goto err_pm_disable;
1858 }
1859
1860 /* register all available decoders */
1861 register_decoders(delta);
1862
1863 /* register all supported formats */
1864 register_formats(delta);
1865
1866 /* register on V4L2 */
1867 ret = v4l2_device_register(dev, &delta->v4l2_dev);
1868 if (ret) {
1869 dev_err(delta->dev, "%s failed to register V4L2 device\n",
1870 DELTA_PREFIX);
1871 goto err_pm_disable;
1872 }
1873
1874 delta->work_queue = create_workqueue(DELTA_NAME);
1875 if (!delta->work_queue) {
1876 dev_err(delta->dev, "%s failed to allocate work queue\n",
1877 DELTA_PREFIX);
1878 ret = -ENOMEM;
1879 goto err_v4l2;
1880 }
1881
1882 /* register device */
1883 ret = delta_register_device(delta);
1884 if (ret)
1885 goto err_work_queue;
1886
1887 dev_info(dev, "%s %s registered as /dev/video%d\n",
1888 DELTA_PREFIX, delta->vdev->name, delta->vdev->num);
1889
1890 return 0;
1891
1892 err_work_queue:
1893 destroy_workqueue(delta->work_queue);
1894 err_v4l2:
1895 v4l2_device_unregister(&delta->v4l2_dev);
1896 err_pm_disable:
1897 pm_runtime_disable(dev);
1898 err:
1899 return ret;
1900 }
1901
delta_remove(struct platform_device * pdev)1902 static void delta_remove(struct platform_device *pdev)
1903 {
1904 struct delta_dev *delta = platform_get_drvdata(pdev);
1905
1906 delta_ipc_exit(delta);
1907
1908 delta_unregister_device(delta);
1909
1910 destroy_workqueue(delta->work_queue);
1911
1912 pm_runtime_put_autosuspend(delta->dev);
1913 pm_runtime_disable(delta->dev);
1914
1915 v4l2_device_unregister(&delta->v4l2_dev);
1916 }
1917
delta_runtime_suspend(struct device * dev)1918 static int delta_runtime_suspend(struct device *dev)
1919 {
1920 struct delta_dev *delta = dev_get_drvdata(dev);
1921
1922 clk_disable_unprepare(delta->clk_delta);
1923
1924 return 0;
1925 }
1926
delta_runtime_resume(struct device * dev)1927 static int delta_runtime_resume(struct device *dev)
1928 {
1929 struct delta_dev *delta = dev_get_drvdata(dev);
1930
1931 if (clk_prepare_enable(delta->clk_delta))
1932 dev_warn(dev, "failed to prepare/enable delta clk\n");
1933
1934 return 0;
1935 }
1936
1937 /* PM ops */
1938 static const struct dev_pm_ops delta_pm_ops = {
1939 .runtime_suspend = delta_runtime_suspend,
1940 .runtime_resume = delta_runtime_resume,
1941 };
1942
1943 static const struct of_device_id delta_match_types[] = {
1944 {
1945 .compatible = "st,st-delta",
1946 },
1947 {
1948 /* end node */
1949 }
1950 };
1951
1952 MODULE_DEVICE_TABLE(of, delta_match_types);
1953
1954 static struct platform_driver delta_driver = {
1955 .probe = delta_probe,
1956 .remove = delta_remove,
1957 .driver = {
1958 .name = DELTA_NAME,
1959 .of_match_table = delta_match_types,
1960 .pm = &delta_pm_ops},
1961 };
1962
1963 module_platform_driver(delta_driver);
1964
1965 MODULE_LICENSE("GPL");
1966 MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");
1967 MODULE_DESCRIPTION("STMicroelectronics DELTA video decoder V4L2 driver");
1968