• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Rockchip Video Decoder driver
4  *
5  * Copyright (C) 2019 Collabora, Ltd.
6  *
7  * Based on rkvdec driver by Google LLC. (Tomasz Figa <tfiga@chromium.org>)
8  * Based on s5p-mfc driver by Samsung Electronics Co., Ltd.
9  * Copyright (C) 2011 Samsung Electronics Co., Ltd.
10  */
11 
12 #include <linux/clk.h>
13 #include <linux/interrupt.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/slab.h>
20 #include <linux/videodev2.h>
21 #include <linux/workqueue.h>
22 #include <media/v4l2-event.h>
23 #include <media/v4l2-mem2mem.h>
24 #include <media/videobuf2-core.h>
25 #include <media/videobuf2-vmalloc.h>
26 
27 #include "rkvdec.h"
28 #include "rkvdec-regs.h"
29 
rkvdec_try_ctrl(struct v4l2_ctrl * ctrl)30 static int rkvdec_try_ctrl(struct v4l2_ctrl *ctrl)
31 {
32 	if (ctrl->id == V4L2_CID_STATELESS_H264_SPS) {
33 		const struct v4l2_ctrl_h264_sps *sps = ctrl->p_new.p_h264_sps;
34 		/*
35 		 * TODO: The hardware supports 10-bit and 4:2:2 profiles,
36 		 * but it's currently broken in the driver.
37 		 * Reject them for now, until it's fixed.
38 		 */
39 		if (sps->chroma_format_idc > 1)
40 			/* Only 4:0:0 and 4:2:0 are supported */
41 			return -EINVAL;
42 		if (sps->bit_depth_luma_minus8 != sps->bit_depth_chroma_minus8)
43 			/* Luma and chroma bit depth mismatch */
44 			return -EINVAL;
45 		if (sps->bit_depth_luma_minus8 != 0)
46 			/* Only 8-bit is supported */
47 			return -EINVAL;
48 	}
49 	return 0;
50 }
51 
52 static const struct v4l2_ctrl_ops rkvdec_ctrl_ops = {
53 	.try_ctrl = rkvdec_try_ctrl,
54 };
55 
56 static const struct rkvdec_ctrl_desc rkvdec_h264_ctrl_descs[] = {
57 	{
58 		.cfg.id = V4L2_CID_STATELESS_H264_DECODE_PARAMS,
59 	},
60 	{
61 		.cfg.id = V4L2_CID_STATELESS_H264_SPS,
62 		.cfg.ops = &rkvdec_ctrl_ops,
63 	},
64 	{
65 		.cfg.id = V4L2_CID_STATELESS_H264_PPS,
66 	},
67 	{
68 		.cfg.id = V4L2_CID_STATELESS_H264_SCALING_MATRIX,
69 	},
70 	{
71 		.cfg.id = V4L2_CID_STATELESS_H264_DECODE_MODE,
72 		.cfg.min = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
73 		.cfg.max = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
74 		.cfg.def = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
75 	},
76 	{
77 		.cfg.id = V4L2_CID_STATELESS_H264_START_CODE,
78 		.cfg.min = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
79 		.cfg.def = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
80 		.cfg.max = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
81 	},
82 	{
83 		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
84 		.cfg.min = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
85 		.cfg.max = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
86 		.cfg.menu_skip_mask =
87 			BIT(V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED),
88 		.cfg.def = V4L2_MPEG_VIDEO_H264_PROFILE_MAIN,
89 	},
90 	{
91 		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
92 		.cfg.min = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
93 		.cfg.max = V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
94 	},
95 };
96 
97 static const struct rkvdec_ctrls rkvdec_h264_ctrls = {
98 	.ctrls = rkvdec_h264_ctrl_descs,
99 	.num_ctrls = ARRAY_SIZE(rkvdec_h264_ctrl_descs),
100 };
101 
102 static const u32 rkvdec_h264_decoded_fmts[] = {
103 	V4L2_PIX_FMT_NV12,
104 };
105 
106 static const struct rkvdec_coded_fmt_desc rkvdec_coded_fmts[] = {
107 	{
108 		.fourcc = V4L2_PIX_FMT_H264_SLICE,
109 		.frmsize = {
110 			.min_width = 48,
111 			.max_width = 4096,
112 			.step_width = 16,
113 			.min_height = 48,
114 			.max_height = 2560,
115 			.step_height = 16,
116 		},
117 		.ctrls = &rkvdec_h264_ctrls,
118 		.ops = &rkvdec_h264_fmt_ops,
119 		.num_decoded_fmts = ARRAY_SIZE(rkvdec_h264_decoded_fmts),
120 		.decoded_fmts = rkvdec_h264_decoded_fmts,
121 	}
122 };
123 
124 static const struct rkvdec_coded_fmt_desc *
rkvdec_find_coded_fmt_desc(u32 fourcc)125 rkvdec_find_coded_fmt_desc(u32 fourcc)
126 {
127 	unsigned int i;
128 
129 	for (i = 0; i < ARRAY_SIZE(rkvdec_coded_fmts); i++) {
130 		if (rkvdec_coded_fmts[i].fourcc == fourcc)
131 			return &rkvdec_coded_fmts[i];
132 	}
133 
134 	return NULL;
135 }
136 
rkvdec_reset_fmt(struct rkvdec_ctx * ctx,struct v4l2_format * f,u32 fourcc)137 static void rkvdec_reset_fmt(struct rkvdec_ctx *ctx, struct v4l2_format *f,
138 			     u32 fourcc)
139 {
140 	memset(f, 0, sizeof(*f));
141 	f->fmt.pix_mp.pixelformat = fourcc;
142 	f->fmt.pix_mp.field = V4L2_FIELD_NONE;
143 	f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_REC709;
144 	f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
145 	f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT;
146 	f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT;
147 }
148 
rkvdec_reset_coded_fmt(struct rkvdec_ctx * ctx)149 static void rkvdec_reset_coded_fmt(struct rkvdec_ctx *ctx)
150 {
151 	struct v4l2_format *f = &ctx->coded_fmt;
152 
153 	ctx->coded_fmt_desc = &rkvdec_coded_fmts[0];
154 	rkvdec_reset_fmt(ctx, f, ctx->coded_fmt_desc->fourcc);
155 
156 	f->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
157 	f->fmt.pix_mp.width = ctx->coded_fmt_desc->frmsize.min_width;
158 	f->fmt.pix_mp.height = ctx->coded_fmt_desc->frmsize.min_height;
159 
160 	if (ctx->coded_fmt_desc->ops->adjust_fmt)
161 		ctx->coded_fmt_desc->ops->adjust_fmt(ctx, f);
162 }
163 
rkvdec_reset_decoded_fmt(struct rkvdec_ctx * ctx)164 static void rkvdec_reset_decoded_fmt(struct rkvdec_ctx *ctx)
165 {
166 	struct v4l2_format *f = &ctx->decoded_fmt;
167 
168 	rkvdec_reset_fmt(ctx, f, ctx->coded_fmt_desc->decoded_fmts[0]);
169 	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
170 	v4l2_fill_pixfmt_mp(&f->fmt.pix_mp,
171 			    ctx->coded_fmt_desc->decoded_fmts[0],
172 			    ctx->coded_fmt.fmt.pix_mp.width,
173 			    ctx->coded_fmt.fmt.pix_mp.height);
174 	f->fmt.pix_mp.plane_fmt[0].sizeimage += 128 *
175 		DIV_ROUND_UP(f->fmt.pix_mp.width, 16) *
176 		DIV_ROUND_UP(f->fmt.pix_mp.height, 16);
177 }
178 
rkvdec_enum_framesizes(struct file * file,void * priv,struct v4l2_frmsizeenum * fsize)179 static int rkvdec_enum_framesizes(struct file *file, void *priv,
180 				  struct v4l2_frmsizeenum *fsize)
181 {
182 	const struct rkvdec_coded_fmt_desc *fmt;
183 
184 	if (fsize->index != 0)
185 		return -EINVAL;
186 
187 	fmt = rkvdec_find_coded_fmt_desc(fsize->pixel_format);
188 	if (!fmt)
189 		return -EINVAL;
190 
191 	fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
192 	fsize->stepwise = fmt->frmsize;
193 	return 0;
194 }
195 
rkvdec_querycap(struct file * file,void * priv,struct v4l2_capability * cap)196 static int rkvdec_querycap(struct file *file, void *priv,
197 			   struct v4l2_capability *cap)
198 {
199 	struct rkvdec_dev *rkvdec = video_drvdata(file);
200 	struct video_device *vdev = video_devdata(file);
201 
202 	strscpy(cap->driver, rkvdec->dev->driver->name,
203 		sizeof(cap->driver));
204 	strscpy(cap->card, vdev->name, sizeof(cap->card));
205 	snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
206 		 rkvdec->dev->driver->name);
207 	return 0;
208 }
209 
rkvdec_try_capture_fmt(struct file * file,void * priv,struct v4l2_format * f)210 static int rkvdec_try_capture_fmt(struct file *file, void *priv,
211 				  struct v4l2_format *f)
212 {
213 	struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
214 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
215 	const struct rkvdec_coded_fmt_desc *coded_desc;
216 	unsigned int i;
217 
218 	/*
219 	 * The codec context should point to a coded format desc, if the format
220 	 * on the coded end has not been set yet, it should point to the
221 	 * default value.
222 	 */
223 	coded_desc = ctx->coded_fmt_desc;
224 	if (WARN_ON(!coded_desc))
225 		return -EINVAL;
226 
227 	for (i = 0; i < coded_desc->num_decoded_fmts; i++) {
228 		if (coded_desc->decoded_fmts[i] == pix_mp->pixelformat)
229 			break;
230 	}
231 
232 	if (i == coded_desc->num_decoded_fmts)
233 		pix_mp->pixelformat = coded_desc->decoded_fmts[0];
234 
235 	/* Always apply the frmsize constraint of the coded end. */
236 	v4l2_apply_frmsize_constraints(&pix_mp->width,
237 				       &pix_mp->height,
238 				       &coded_desc->frmsize);
239 
240 	v4l2_fill_pixfmt_mp(pix_mp, pix_mp->pixelformat,
241 			    pix_mp->width, pix_mp->height);
242 	pix_mp->plane_fmt[0].sizeimage +=
243 		128 *
244 		DIV_ROUND_UP(pix_mp->width, 16) *
245 		DIV_ROUND_UP(pix_mp->height, 16);
246 	pix_mp->field = V4L2_FIELD_NONE;
247 
248 	return 0;
249 }
250 
rkvdec_try_output_fmt(struct file * file,void * priv,struct v4l2_format * f)251 static int rkvdec_try_output_fmt(struct file *file, void *priv,
252 				 struct v4l2_format *f)
253 {
254 	struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
255 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
256 	const struct rkvdec_coded_fmt_desc *desc;
257 
258 	desc = rkvdec_find_coded_fmt_desc(pix_mp->pixelformat);
259 	if (!desc) {
260 		pix_mp->pixelformat = rkvdec_coded_fmts[0].fourcc;
261 		desc = &rkvdec_coded_fmts[0];
262 	}
263 
264 	v4l2_apply_frmsize_constraints(&pix_mp->width,
265 				       &pix_mp->height,
266 				       &desc->frmsize);
267 
268 	pix_mp->field = V4L2_FIELD_NONE;
269 	/* All coded formats are considered single planar for now. */
270 	pix_mp->num_planes = 1;
271 
272 	if (desc->ops->adjust_fmt) {
273 		int ret;
274 
275 		ret = desc->ops->adjust_fmt(ctx, f);
276 		if (ret)
277 			return ret;
278 	}
279 
280 	return 0;
281 }
282 
rkvdec_s_capture_fmt(struct file * file,void * priv,struct v4l2_format * f)283 static int rkvdec_s_capture_fmt(struct file *file, void *priv,
284 				struct v4l2_format *f)
285 {
286 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
287 	struct vb2_queue *vq;
288 	int ret;
289 
290 	/* Change not allowed if queue is busy */
291 	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
292 			     V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
293 	if (vb2_is_busy(vq))
294 		return -EBUSY;
295 
296 	ret = rkvdec_try_capture_fmt(file, priv, f);
297 	if (ret)
298 		return ret;
299 
300 	ctx->decoded_fmt = *f;
301 	return 0;
302 }
303 
rkvdec_s_output_fmt(struct file * file,void * priv,struct v4l2_format * f)304 static int rkvdec_s_output_fmt(struct file *file, void *priv,
305 			       struct v4l2_format *f)
306 {
307 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
308 	struct v4l2_m2m_ctx *m2m_ctx = ctx->fh.m2m_ctx;
309 	const struct rkvdec_coded_fmt_desc *desc;
310 	struct v4l2_format *cap_fmt;
311 	struct vb2_queue *peer_vq, *vq;
312 	int ret;
313 
314 	/*
315 	 * In order to support dynamic resolution change, the decoder admits
316 	 * a resolution change, as long as the pixelformat remains. Can't be
317 	 * done if streaming.
318 	 */
319 	vq = v4l2_m2m_get_vq(m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
320 	if (vb2_is_streaming(vq) ||
321 	    (vb2_is_busy(vq) &&
322 	     f->fmt.pix_mp.pixelformat != ctx->coded_fmt.fmt.pix_mp.pixelformat))
323 		return -EBUSY;
324 
325 	/*
326 	 * Since format change on the OUTPUT queue will reset the CAPTURE
327 	 * queue, we can't allow doing so when the CAPTURE queue has buffers
328 	 * allocated.
329 	 */
330 	peer_vq = v4l2_m2m_get_vq(m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
331 	if (vb2_is_busy(peer_vq))
332 		return -EBUSY;
333 
334 	ret = rkvdec_try_output_fmt(file, priv, f);
335 	if (ret)
336 		return ret;
337 
338 	desc = rkvdec_find_coded_fmt_desc(f->fmt.pix_mp.pixelformat);
339 	if (!desc)
340 		return -EINVAL;
341 	ctx->coded_fmt_desc = desc;
342 	ctx->coded_fmt = *f;
343 
344 	/*
345 	 * Current decoded format might have become invalid with newly
346 	 * selected codec, so reset it to default just to be safe and
347 	 * keep internal driver state sane. User is mandated to set
348 	 * the decoded format again after we return, so we don't need
349 	 * anything smarter.
350 	 *
351 	 * Note that this will propagates any size changes to the decoded format.
352 	 */
353 	rkvdec_reset_decoded_fmt(ctx);
354 
355 	/* Propagate colorspace information to capture. */
356 	cap_fmt = &ctx->decoded_fmt;
357 	cap_fmt->fmt.pix_mp.colorspace = f->fmt.pix_mp.colorspace;
358 	cap_fmt->fmt.pix_mp.xfer_func = f->fmt.pix_mp.xfer_func;
359 	cap_fmt->fmt.pix_mp.ycbcr_enc = f->fmt.pix_mp.ycbcr_enc;
360 	cap_fmt->fmt.pix_mp.quantization = f->fmt.pix_mp.quantization;
361 
362 	return 0;
363 }
364 
rkvdec_g_output_fmt(struct file * file,void * priv,struct v4l2_format * f)365 static int rkvdec_g_output_fmt(struct file *file, void *priv,
366 			       struct v4l2_format *f)
367 {
368 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
369 
370 	*f = ctx->coded_fmt;
371 	return 0;
372 }
373 
rkvdec_g_capture_fmt(struct file * file,void * priv,struct v4l2_format * f)374 static int rkvdec_g_capture_fmt(struct file *file, void *priv,
375 				struct v4l2_format *f)
376 {
377 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
378 
379 	*f = ctx->decoded_fmt;
380 	return 0;
381 }
382 
rkvdec_enum_output_fmt(struct file * file,void * priv,struct v4l2_fmtdesc * f)383 static int rkvdec_enum_output_fmt(struct file *file, void *priv,
384 				  struct v4l2_fmtdesc *f)
385 {
386 	if (f->index >= ARRAY_SIZE(rkvdec_coded_fmts))
387 		return -EINVAL;
388 
389 	f->pixelformat = rkvdec_coded_fmts[f->index].fourcc;
390 	return 0;
391 }
392 
rkvdec_enum_capture_fmt(struct file * file,void * priv,struct v4l2_fmtdesc * f)393 static int rkvdec_enum_capture_fmt(struct file *file, void *priv,
394 				   struct v4l2_fmtdesc *f)
395 {
396 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
397 
398 	if (WARN_ON(!ctx->coded_fmt_desc))
399 		return -EINVAL;
400 
401 	if (f->index >= ctx->coded_fmt_desc->num_decoded_fmts)
402 		return -EINVAL;
403 
404 	f->pixelformat = ctx->coded_fmt_desc->decoded_fmts[f->index];
405 	return 0;
406 }
407 
408 static const struct v4l2_ioctl_ops rkvdec_ioctl_ops = {
409 	.vidioc_querycap = rkvdec_querycap,
410 	.vidioc_enum_framesizes = rkvdec_enum_framesizes,
411 
412 	.vidioc_try_fmt_vid_cap_mplane = rkvdec_try_capture_fmt,
413 	.vidioc_try_fmt_vid_out_mplane = rkvdec_try_output_fmt,
414 	.vidioc_s_fmt_vid_out_mplane = rkvdec_s_output_fmt,
415 	.vidioc_s_fmt_vid_cap_mplane = rkvdec_s_capture_fmt,
416 	.vidioc_g_fmt_vid_out_mplane = rkvdec_g_output_fmt,
417 	.vidioc_g_fmt_vid_cap_mplane = rkvdec_g_capture_fmt,
418 	.vidioc_enum_fmt_vid_out = rkvdec_enum_output_fmt,
419 	.vidioc_enum_fmt_vid_cap = rkvdec_enum_capture_fmt,
420 
421 	.vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
422 	.vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
423 	.vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
424 	.vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
425 	.vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
426 	.vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
427 	.vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
428 
429 	.vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
430 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
431 
432 	.vidioc_streamon = v4l2_m2m_ioctl_streamon,
433 	.vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
434 };
435 
rkvdec_queue_setup(struct vb2_queue * vq,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])436 static int rkvdec_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers,
437 			      unsigned int *num_planes, unsigned int sizes[],
438 			      struct device *alloc_devs[])
439 {
440 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(vq);
441 	struct v4l2_format *f;
442 	unsigned int i;
443 
444 	if (V4L2_TYPE_IS_OUTPUT(vq->type))
445 		f = &ctx->coded_fmt;
446 	else
447 		f = &ctx->decoded_fmt;
448 
449 	if (*num_planes) {
450 		if (*num_planes != f->fmt.pix_mp.num_planes)
451 			return -EINVAL;
452 
453 		for (i = 0; i < f->fmt.pix_mp.num_planes; i++) {
454 			if (sizes[i] < f->fmt.pix_mp.plane_fmt[i].sizeimage)
455 				return -EINVAL;
456 		}
457 	} else {
458 		*num_planes = f->fmt.pix_mp.num_planes;
459 		for (i = 0; i < f->fmt.pix_mp.num_planes; i++)
460 			sizes[i] = f->fmt.pix_mp.plane_fmt[i].sizeimage;
461 	}
462 
463 	return 0;
464 }
465 
rkvdec_buf_prepare(struct vb2_buffer * vb)466 static int rkvdec_buf_prepare(struct vb2_buffer *vb)
467 {
468 	struct vb2_queue *vq = vb->vb2_queue;
469 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(vq);
470 	struct v4l2_format *f;
471 	unsigned int i;
472 
473 	if (V4L2_TYPE_IS_OUTPUT(vq->type))
474 		f = &ctx->coded_fmt;
475 	else
476 		f = &ctx->decoded_fmt;
477 
478 	for (i = 0; i < f->fmt.pix_mp.num_planes; ++i) {
479 		u32 sizeimage = f->fmt.pix_mp.plane_fmt[i].sizeimage;
480 
481 		if (vb2_plane_size(vb, i) < sizeimage)
482 			return -EINVAL;
483 	}
484 
485 	/*
486 	 * Buffer's bytesused must be written by driver for CAPTURE buffers.
487 	 * (for OUTPUT buffers, if userspace passes 0 bytesused, v4l2-core sets
488 	 * it to buffer length).
489 	 */
490 	if (V4L2_TYPE_IS_CAPTURE(vq->type))
491 		vb2_set_plane_payload(vb, 0, f->fmt.pix_mp.plane_fmt[0].sizeimage);
492 
493 	return 0;
494 }
495 
rkvdec_buf_queue(struct vb2_buffer * vb)496 static void rkvdec_buf_queue(struct vb2_buffer *vb)
497 {
498 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
499 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
500 
501 	v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
502 }
503 
rkvdec_buf_out_validate(struct vb2_buffer * vb)504 static int rkvdec_buf_out_validate(struct vb2_buffer *vb)
505 {
506 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
507 
508 	vbuf->field = V4L2_FIELD_NONE;
509 	return 0;
510 }
511 
rkvdec_buf_request_complete(struct vb2_buffer * vb)512 static void rkvdec_buf_request_complete(struct vb2_buffer *vb)
513 {
514 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
515 
516 	v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->ctrl_hdl);
517 }
518 
rkvdec_start_streaming(struct vb2_queue * q,unsigned int count)519 static int rkvdec_start_streaming(struct vb2_queue *q, unsigned int count)
520 {
521 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(q);
522 	const struct rkvdec_coded_fmt_desc *desc;
523 	int ret;
524 
525 	if (V4L2_TYPE_IS_CAPTURE(q->type))
526 		return 0;
527 
528 	desc = ctx->coded_fmt_desc;
529 	if (WARN_ON(!desc))
530 		return -EINVAL;
531 
532 	if (desc->ops->start) {
533 		ret = desc->ops->start(ctx);
534 		if (ret)
535 			return ret;
536 	}
537 
538 	return 0;
539 }
540 
rkvdec_queue_cleanup(struct vb2_queue * vq,u32 state)541 static void rkvdec_queue_cleanup(struct vb2_queue *vq, u32 state)
542 {
543 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(vq);
544 
545 	while (true) {
546 		struct vb2_v4l2_buffer *vbuf;
547 
548 		if (V4L2_TYPE_IS_OUTPUT(vq->type))
549 			vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
550 		else
551 			vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
552 
553 		if (!vbuf)
554 			break;
555 
556 		v4l2_ctrl_request_complete(vbuf->vb2_buf.req_obj.req,
557 					   &ctx->ctrl_hdl);
558 		v4l2_m2m_buf_done(vbuf, state);
559 	}
560 }
561 
rkvdec_stop_streaming(struct vb2_queue * q)562 static void rkvdec_stop_streaming(struct vb2_queue *q)
563 {
564 	struct rkvdec_ctx *ctx = vb2_get_drv_priv(q);
565 
566 	if (V4L2_TYPE_IS_OUTPUT(q->type)) {
567 		const struct rkvdec_coded_fmt_desc *desc = ctx->coded_fmt_desc;
568 
569 		if (WARN_ON(!desc))
570 			return;
571 
572 		if (desc->ops->stop)
573 			desc->ops->stop(ctx);
574 	}
575 
576 	rkvdec_queue_cleanup(q, VB2_BUF_STATE_ERROR);
577 }
578 
579 static const struct vb2_ops rkvdec_queue_ops = {
580 	.queue_setup = rkvdec_queue_setup,
581 	.buf_prepare = rkvdec_buf_prepare,
582 	.buf_queue = rkvdec_buf_queue,
583 	.buf_out_validate = rkvdec_buf_out_validate,
584 	.buf_request_complete = rkvdec_buf_request_complete,
585 	.start_streaming = rkvdec_start_streaming,
586 	.stop_streaming = rkvdec_stop_streaming,
587 	.wait_prepare = vb2_ops_wait_prepare,
588 	.wait_finish = vb2_ops_wait_finish,
589 };
590 
rkvdec_request_validate(struct media_request * req)591 static int rkvdec_request_validate(struct media_request *req)
592 {
593 	unsigned int count;
594 
595 	count = vb2_request_buffer_cnt(req);
596 	if (!count)
597 		return -ENOENT;
598 	else if (count > 1)
599 		return -EINVAL;
600 
601 	return vb2_request_validate(req);
602 }
603 
604 static const struct media_device_ops rkvdec_media_ops = {
605 	.req_validate = rkvdec_request_validate,
606 	.req_queue = v4l2_m2m_request_queue,
607 };
608 
rkvdec_job_finish_no_pm(struct rkvdec_ctx * ctx,enum vb2_buffer_state result)609 static void rkvdec_job_finish_no_pm(struct rkvdec_ctx *ctx,
610 				    enum vb2_buffer_state result)
611 {
612 	if (ctx->coded_fmt_desc->ops->done) {
613 		struct vb2_v4l2_buffer *src_buf, *dst_buf;
614 
615 		src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
616 		dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
617 		ctx->coded_fmt_desc->ops->done(ctx, src_buf, dst_buf, result);
618 	}
619 
620 	v4l2_m2m_buf_done_and_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx,
621 					 result);
622 }
623 
rkvdec_job_finish(struct rkvdec_ctx * ctx,enum vb2_buffer_state result)624 static void rkvdec_job_finish(struct rkvdec_ctx *ctx,
625 			      enum vb2_buffer_state result)
626 {
627 	struct rkvdec_dev *rkvdec = ctx->dev;
628 
629 	pm_runtime_mark_last_busy(rkvdec->dev);
630 	pm_runtime_put_autosuspend(rkvdec->dev);
631 	rkvdec_job_finish_no_pm(ctx, result);
632 }
633 
rkvdec_run_preamble(struct rkvdec_ctx * ctx,struct rkvdec_run * run)634 void rkvdec_run_preamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run)
635 {
636 	struct media_request *src_req;
637 
638 	memset(run, 0, sizeof(*run));
639 
640 	run->bufs.src = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
641 	run->bufs.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
642 
643 	/* Apply request(s) controls if needed. */
644 	src_req = run->bufs.src->vb2_buf.req_obj.req;
645 	if (src_req)
646 		v4l2_ctrl_request_setup(src_req, &ctx->ctrl_hdl);
647 
648 	v4l2_m2m_buf_copy_metadata(run->bufs.src, run->bufs.dst, true);
649 }
650 
rkvdec_run_postamble(struct rkvdec_ctx * ctx,struct rkvdec_run * run)651 void rkvdec_run_postamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run)
652 {
653 	struct media_request *src_req = run->bufs.src->vb2_buf.req_obj.req;
654 
655 	if (src_req)
656 		v4l2_ctrl_request_complete(src_req, &ctx->ctrl_hdl);
657 }
658 
rkvdec_device_run(void * priv)659 static void rkvdec_device_run(void *priv)
660 {
661 	struct rkvdec_ctx *ctx = priv;
662 	struct rkvdec_dev *rkvdec = ctx->dev;
663 	const struct rkvdec_coded_fmt_desc *desc = ctx->coded_fmt_desc;
664 	int ret;
665 
666 	if (WARN_ON(!desc))
667 		return;
668 
669 	ret = pm_runtime_resume_and_get(rkvdec->dev);
670 	if (ret < 0) {
671 		rkvdec_job_finish_no_pm(ctx, VB2_BUF_STATE_ERROR);
672 		return;
673 	}
674 
675 	ret = desc->ops->run(ctx);
676 	if (ret)
677 		rkvdec_job_finish(ctx, VB2_BUF_STATE_ERROR);
678 }
679 
680 static struct v4l2_m2m_ops rkvdec_m2m_ops = {
681 	.device_run = rkvdec_device_run,
682 };
683 
rkvdec_queue_init(void * priv,struct vb2_queue * src_vq,struct vb2_queue * dst_vq)684 static int rkvdec_queue_init(void *priv,
685 			     struct vb2_queue *src_vq,
686 			     struct vb2_queue *dst_vq)
687 {
688 	struct rkvdec_ctx *ctx = priv;
689 	struct rkvdec_dev *rkvdec = ctx->dev;
690 	int ret;
691 
692 	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
693 	src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
694 	src_vq->drv_priv = ctx;
695 	src_vq->ops = &rkvdec_queue_ops;
696 	src_vq->mem_ops = &vb2_dma_contig_memops;
697 
698 	/*
699 	 * Driver does mostly sequential access, so sacrifice TLB efficiency
700 	 * for faster allocation. Also, no CPU access on the source queue,
701 	 * so no kernel mapping needed.
702 	 */
703 	src_vq->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES |
704 			    DMA_ATTR_NO_KERNEL_MAPPING;
705 	src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
706 	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
707 	src_vq->lock = &rkvdec->vdev_lock;
708 	src_vq->dev = rkvdec->v4l2_dev.dev;
709 	src_vq->supports_requests = true;
710 	src_vq->requires_requests = true;
711 
712 	ret = vb2_queue_init(src_vq);
713 	if (ret)
714 		return ret;
715 
716 	dst_vq->bidirectional = true;
717 	dst_vq->mem_ops = &vb2_dma_contig_memops;
718 	dst_vq->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES |
719 			    DMA_ATTR_NO_KERNEL_MAPPING;
720 	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
721 	dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
722 	dst_vq->drv_priv = ctx;
723 	dst_vq->ops = &rkvdec_queue_ops;
724 	dst_vq->buf_struct_size = sizeof(struct rkvdec_decoded_buffer);
725 	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
726 	dst_vq->lock = &rkvdec->vdev_lock;
727 	dst_vq->dev = rkvdec->v4l2_dev.dev;
728 
729 	return vb2_queue_init(dst_vq);
730 }
731 
rkvdec_add_ctrls(struct rkvdec_ctx * ctx,const struct rkvdec_ctrls * ctrls)732 static int rkvdec_add_ctrls(struct rkvdec_ctx *ctx,
733 			    const struct rkvdec_ctrls *ctrls)
734 {
735 	unsigned int i;
736 
737 	for (i = 0; i < ctrls->num_ctrls; i++) {
738 		const struct v4l2_ctrl_config *cfg = &ctrls->ctrls[i].cfg;
739 
740 		v4l2_ctrl_new_custom(&ctx->ctrl_hdl, cfg, ctx);
741 		if (ctx->ctrl_hdl.error)
742 			return ctx->ctrl_hdl.error;
743 	}
744 
745 	return 0;
746 }
747 
rkvdec_init_ctrls(struct rkvdec_ctx * ctx)748 static int rkvdec_init_ctrls(struct rkvdec_ctx *ctx)
749 {
750 	unsigned int i, nctrls = 0;
751 	int ret;
752 
753 	for (i = 0; i < ARRAY_SIZE(rkvdec_coded_fmts); i++)
754 		nctrls += rkvdec_coded_fmts[i].ctrls->num_ctrls;
755 
756 	v4l2_ctrl_handler_init(&ctx->ctrl_hdl, nctrls);
757 
758 	for (i = 0; i < ARRAY_SIZE(rkvdec_coded_fmts); i++) {
759 		ret = rkvdec_add_ctrls(ctx, rkvdec_coded_fmts[i].ctrls);
760 		if (ret)
761 			goto err_free_handler;
762 	}
763 
764 	ret = v4l2_ctrl_handler_setup(&ctx->ctrl_hdl);
765 	if (ret)
766 		goto err_free_handler;
767 
768 	ctx->fh.ctrl_handler = &ctx->ctrl_hdl;
769 	return 0;
770 
771 err_free_handler:
772 	v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
773 	return ret;
774 }
775 
rkvdec_open(struct file * filp)776 static int rkvdec_open(struct file *filp)
777 {
778 	struct rkvdec_dev *rkvdec = video_drvdata(filp);
779 	struct rkvdec_ctx *ctx;
780 	int ret;
781 
782 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
783 	if (!ctx)
784 		return -ENOMEM;
785 
786 	ctx->dev = rkvdec;
787 	rkvdec_reset_coded_fmt(ctx);
788 	rkvdec_reset_decoded_fmt(ctx);
789 	v4l2_fh_init(&ctx->fh, video_devdata(filp));
790 
791 	ret = rkvdec_init_ctrls(ctx);
792 	if (ret)
793 		goto err_free_ctx;
794 
795 	ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(rkvdec->m2m_dev, ctx,
796 					    rkvdec_queue_init);
797 	if (IS_ERR(ctx->fh.m2m_ctx)) {
798 		ret = PTR_ERR(ctx->fh.m2m_ctx);
799 		goto err_cleanup_ctrls;
800 	}
801 
802 	filp->private_data = &ctx->fh;
803 	v4l2_fh_add(&ctx->fh);
804 
805 	return 0;
806 
807 err_cleanup_ctrls:
808 	v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
809 
810 err_free_ctx:
811 	kfree(ctx);
812 	return ret;
813 }
814 
rkvdec_release(struct file * filp)815 static int rkvdec_release(struct file *filp)
816 {
817 	struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(filp->private_data);
818 
819 	v4l2_fh_del(&ctx->fh);
820 	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
821 	v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
822 	v4l2_fh_exit(&ctx->fh);
823 	kfree(ctx);
824 
825 	return 0;
826 }
827 
828 static const struct v4l2_file_operations rkvdec_fops = {
829 	.owner = THIS_MODULE,
830 	.open = rkvdec_open,
831 	.release = rkvdec_release,
832 	.poll = v4l2_m2m_fop_poll,
833 	.unlocked_ioctl = video_ioctl2,
834 	.mmap = v4l2_m2m_fop_mmap,
835 };
836 
rkvdec_v4l2_init(struct rkvdec_dev * rkvdec)837 static int rkvdec_v4l2_init(struct rkvdec_dev *rkvdec)
838 {
839 	int ret;
840 
841 	ret = v4l2_device_register(rkvdec->dev, &rkvdec->v4l2_dev);
842 	if (ret) {
843 		dev_err(rkvdec->dev, "Failed to register V4L2 device\n");
844 		return ret;
845 	}
846 
847 	rkvdec->m2m_dev = v4l2_m2m_init(&rkvdec_m2m_ops);
848 	if (IS_ERR(rkvdec->m2m_dev)) {
849 		v4l2_err(&rkvdec->v4l2_dev, "Failed to init mem2mem device\n");
850 		ret = PTR_ERR(rkvdec->m2m_dev);
851 		goto err_unregister_v4l2;
852 	}
853 
854 	rkvdec->mdev.dev = rkvdec->dev;
855 	strscpy(rkvdec->mdev.model, "rkvdec", sizeof(rkvdec->mdev.model));
856 	strscpy(rkvdec->mdev.bus_info, "platform:rkvdec",
857 		sizeof(rkvdec->mdev.bus_info));
858 	media_device_init(&rkvdec->mdev);
859 	rkvdec->mdev.ops = &rkvdec_media_ops;
860 	rkvdec->v4l2_dev.mdev = &rkvdec->mdev;
861 
862 	rkvdec->vdev.lock = &rkvdec->vdev_lock;
863 	rkvdec->vdev.v4l2_dev = &rkvdec->v4l2_dev;
864 	rkvdec->vdev.fops = &rkvdec_fops;
865 	rkvdec->vdev.release = video_device_release_empty;
866 	rkvdec->vdev.vfl_dir = VFL_DIR_M2M;
867 	rkvdec->vdev.device_caps = V4L2_CAP_STREAMING |
868 				   V4L2_CAP_VIDEO_M2M_MPLANE;
869 	rkvdec->vdev.ioctl_ops = &rkvdec_ioctl_ops;
870 	video_set_drvdata(&rkvdec->vdev, rkvdec);
871 	strscpy(rkvdec->vdev.name, "rkvdec", sizeof(rkvdec->vdev.name));
872 
873 	ret = video_register_device(&rkvdec->vdev, VFL_TYPE_VIDEO, -1);
874 	if (ret) {
875 		v4l2_err(&rkvdec->v4l2_dev, "Failed to register video device\n");
876 		goto err_cleanup_mc;
877 	}
878 
879 	ret = v4l2_m2m_register_media_controller(rkvdec->m2m_dev, &rkvdec->vdev,
880 						 MEDIA_ENT_F_PROC_VIDEO_DECODER);
881 	if (ret) {
882 		v4l2_err(&rkvdec->v4l2_dev,
883 			 "Failed to initialize V4L2 M2M media controller\n");
884 		goto err_unregister_vdev;
885 	}
886 
887 	ret = media_device_register(&rkvdec->mdev);
888 	if (ret) {
889 		v4l2_err(&rkvdec->v4l2_dev, "Failed to register media device\n");
890 		goto err_unregister_mc;
891 	}
892 
893 	return 0;
894 
895 err_unregister_mc:
896 	v4l2_m2m_unregister_media_controller(rkvdec->m2m_dev);
897 
898 err_unregister_vdev:
899 	video_unregister_device(&rkvdec->vdev);
900 
901 err_cleanup_mc:
902 	media_device_cleanup(&rkvdec->mdev);
903 	v4l2_m2m_release(rkvdec->m2m_dev);
904 
905 err_unregister_v4l2:
906 	v4l2_device_unregister(&rkvdec->v4l2_dev);
907 	return ret;
908 }
909 
rkvdec_v4l2_cleanup(struct rkvdec_dev * rkvdec)910 static void rkvdec_v4l2_cleanup(struct rkvdec_dev *rkvdec)
911 {
912 	media_device_unregister(&rkvdec->mdev);
913 	v4l2_m2m_unregister_media_controller(rkvdec->m2m_dev);
914 	video_unregister_device(&rkvdec->vdev);
915 	media_device_cleanup(&rkvdec->mdev);
916 	v4l2_m2m_release(rkvdec->m2m_dev);
917 	v4l2_device_unregister(&rkvdec->v4l2_dev);
918 }
919 
rkvdec_irq_handler(int irq,void * priv)920 static irqreturn_t rkvdec_irq_handler(int irq, void *priv)
921 {
922 	struct rkvdec_dev *rkvdec = priv;
923 	enum vb2_buffer_state state;
924 	u32 status;
925 
926 	status = readl(rkvdec->regs + RKVDEC_REG_INTERRUPT);
927 	state = (status & RKVDEC_RDY_STA) ?
928 		VB2_BUF_STATE_DONE : VB2_BUF_STATE_ERROR;
929 
930 	writel(0, rkvdec->regs + RKVDEC_REG_INTERRUPT);
931 	if (cancel_delayed_work(&rkvdec->watchdog_work)) {
932 		struct rkvdec_ctx *ctx;
933 
934 		ctx = v4l2_m2m_get_curr_priv(rkvdec->m2m_dev);
935 		rkvdec_job_finish(ctx, state);
936 	}
937 
938 	return IRQ_HANDLED;
939 }
940 
rkvdec_watchdog_func(struct work_struct * work)941 static void rkvdec_watchdog_func(struct work_struct *work)
942 {
943 	struct rkvdec_dev *rkvdec;
944 	struct rkvdec_ctx *ctx;
945 
946 	rkvdec = container_of(to_delayed_work(work), struct rkvdec_dev,
947 			      watchdog_work);
948 	ctx = v4l2_m2m_get_curr_priv(rkvdec->m2m_dev);
949 	if (ctx) {
950 		dev_err(rkvdec->dev, "Frame processing timed out!\n");
951 		writel(RKVDEC_IRQ_DIS, rkvdec->regs + RKVDEC_REG_INTERRUPT);
952 		writel(0, rkvdec->regs + RKVDEC_REG_SYSCTRL);
953 		rkvdec_job_finish(ctx, VB2_BUF_STATE_ERROR);
954 	}
955 }
956 
957 static const struct of_device_id of_rkvdec_match[] = {
958 	{ .compatible = "rockchip,rk3399-vdec" },
959 	{ /* sentinel */ }
960 };
961 MODULE_DEVICE_TABLE(of, of_rkvdec_match);
962 
963 static const char * const rkvdec_clk_names[] = {
964 	"axi", "ahb", "cabac", "core"
965 };
966 
rkvdec_probe(struct platform_device * pdev)967 static int rkvdec_probe(struct platform_device *pdev)
968 {
969 	struct rkvdec_dev *rkvdec;
970 	unsigned int i;
971 	int ret, irq;
972 
973 	rkvdec = devm_kzalloc(&pdev->dev, sizeof(*rkvdec), GFP_KERNEL);
974 	if (!rkvdec)
975 		return -ENOMEM;
976 
977 	platform_set_drvdata(pdev, rkvdec);
978 	rkvdec->dev = &pdev->dev;
979 	mutex_init(&rkvdec->vdev_lock);
980 	INIT_DELAYED_WORK(&rkvdec->watchdog_work, rkvdec_watchdog_func);
981 
982 	rkvdec->clocks = devm_kcalloc(&pdev->dev, ARRAY_SIZE(rkvdec_clk_names),
983 				      sizeof(*rkvdec->clocks), GFP_KERNEL);
984 	if (!rkvdec->clocks)
985 		return -ENOMEM;
986 
987 	for (i = 0; i < ARRAY_SIZE(rkvdec_clk_names); i++)
988 		rkvdec->clocks[i].id = rkvdec_clk_names[i];
989 
990 	ret = devm_clk_bulk_get(&pdev->dev, ARRAY_SIZE(rkvdec_clk_names),
991 				rkvdec->clocks);
992 	if (ret)
993 		return ret;
994 
995 	/*
996 	 * Bump ACLK to max. possible freq. (500 MHz) to improve performance
997 	 * When 4k video playback.
998 	 */
999 	clk_set_rate(rkvdec->clocks[0].clk, 500 * 1000 * 1000);
1000 
1001 	rkvdec->regs = devm_platform_ioremap_resource(pdev, 0);
1002 	if (IS_ERR(rkvdec->regs))
1003 		return PTR_ERR(rkvdec->regs);
1004 
1005 	ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
1006 	if (ret) {
1007 		dev_err(&pdev->dev, "Could not set DMA coherent mask.\n");
1008 		return ret;
1009 	}
1010 
1011 	vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
1012 
1013 	irq = platform_get_irq(pdev, 0);
1014 	if (irq <= 0)
1015 		return -ENXIO;
1016 
1017 	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1018 					rkvdec_irq_handler, IRQF_ONESHOT,
1019 					dev_name(&pdev->dev), rkvdec);
1020 	if (ret) {
1021 		dev_err(&pdev->dev, "Could not request vdec IRQ\n");
1022 		return ret;
1023 	}
1024 
1025 	pm_runtime_set_autosuspend_delay(&pdev->dev, 100);
1026 	pm_runtime_use_autosuspend(&pdev->dev);
1027 	pm_runtime_enable(&pdev->dev);
1028 
1029 	ret = rkvdec_v4l2_init(rkvdec);
1030 	if (ret)
1031 		goto err_disable_runtime_pm;
1032 
1033 	return 0;
1034 
1035 err_disable_runtime_pm:
1036 	pm_runtime_dont_use_autosuspend(&pdev->dev);
1037 	pm_runtime_disable(&pdev->dev);
1038 	return ret;
1039 }
1040 
rkvdec_remove(struct platform_device * pdev)1041 static int rkvdec_remove(struct platform_device *pdev)
1042 {
1043 	struct rkvdec_dev *rkvdec = platform_get_drvdata(pdev);
1044 
1045 	cancel_delayed_work_sync(&rkvdec->watchdog_work);
1046 
1047 	rkvdec_v4l2_cleanup(rkvdec);
1048 	pm_runtime_disable(&pdev->dev);
1049 	pm_runtime_dont_use_autosuspend(&pdev->dev);
1050 	return 0;
1051 }
1052 
1053 #ifdef CONFIG_PM
rkvdec_runtime_resume(struct device * dev)1054 static int rkvdec_runtime_resume(struct device *dev)
1055 {
1056 	struct rkvdec_dev *rkvdec = dev_get_drvdata(dev);
1057 
1058 	return clk_bulk_prepare_enable(ARRAY_SIZE(rkvdec_clk_names),
1059 				       rkvdec->clocks);
1060 }
1061 
rkvdec_runtime_suspend(struct device * dev)1062 static int rkvdec_runtime_suspend(struct device *dev)
1063 {
1064 	struct rkvdec_dev *rkvdec = dev_get_drvdata(dev);
1065 
1066 	clk_bulk_disable_unprepare(ARRAY_SIZE(rkvdec_clk_names),
1067 				   rkvdec->clocks);
1068 	return 0;
1069 }
1070 #endif
1071 
1072 static const struct dev_pm_ops rkvdec_pm_ops = {
1073 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1074 				pm_runtime_force_resume)
1075 	SET_RUNTIME_PM_OPS(rkvdec_runtime_suspend, rkvdec_runtime_resume, NULL)
1076 };
1077 
1078 static struct platform_driver rkvdec_driver = {
1079 	.probe = rkvdec_probe,
1080 	.remove = rkvdec_remove,
1081 	.driver = {
1082 		   .name = "rkvdec",
1083 		   .of_match_table = of_rkvdec_match,
1084 		   .pm = &rkvdec_pm_ops,
1085 	},
1086 };
1087 module_platform_driver(rkvdec_driver);
1088 
1089 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@collabora.com>");
1090 MODULE_DESCRIPTION("Rockchip Video Decoder driver");
1091 MODULE_LICENSE("GPL v2");
1092