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