1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * vsp1_wpf.c  --  R-Car VSP1 Write Pixel Formatter
4  *
5  * Copyright (C) 2013-2014 Renesas Electronics Corporation
6  *
7  * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
8  */
9 
10 #include <linux/device.h>
11 
12 #include <media/v4l2-subdev.h>
13 
14 #include "vsp1.h"
15 #include "vsp1_dl.h"
16 #include "vsp1_pipe.h"
17 #include "vsp1_rwpf.h"
18 #include "vsp1_video.h"
19 
20 #define WPF_GEN2_MAX_WIDTH			2048U
21 #define WPF_GEN2_MAX_HEIGHT			2048U
22 #define WPF_GEN3_MAX_WIDTH			8190U
23 #define WPF_GEN3_MAX_HEIGHT			8190U
24 
25 /* -----------------------------------------------------------------------------
26  * Device Access
27  */
28 
29 static inline void vsp1_wpf_write(struct vsp1_rwpf *wpf,
30 				  struct vsp1_dl_body *dlb, u32 reg, u32 data)
31 {
32 	vsp1_dl_body_write(dlb, reg + wpf->entity.index * VI6_WPF_OFFSET, data);
33 }
34 
35 /* -----------------------------------------------------------------------------
36  * Controls
37  */
38 
39 enum wpf_flip_ctrl {
40 	WPF_CTRL_VFLIP = 0,
41 	WPF_CTRL_HFLIP = 1,
42 };
43 
44 static int vsp1_wpf_set_rotation(struct vsp1_rwpf *wpf, unsigned int rotation)
45 {
46 	struct vsp1_video *video = wpf->video;
47 	struct v4l2_mbus_framefmt *sink_format;
48 	struct v4l2_mbus_framefmt *source_format;
49 	bool rotate;
50 	int ret = 0;
51 
52 	/*
53 	 * Only consider the 0°/180° from/to 90°/270° modifications, the rest
54 	 * is taken care of by the flipping configuration.
55 	 */
56 	rotate = rotation == 90 || rotation == 270;
57 	if (rotate == wpf->flip.rotate)
58 		return 0;
59 
60 	/* Changing rotation isn't allowed when buffers are allocated. */
61 	mutex_lock(&video->lock);
62 
63 	if (vb2_is_busy(&video->queue)) {
64 		ret = -EBUSY;
65 		goto done;
66 	}
67 
68 	sink_format = vsp1_entity_get_pad_format(&wpf->entity,
69 						 wpf->entity.config,
70 						 RWPF_PAD_SINK);
71 	source_format = vsp1_entity_get_pad_format(&wpf->entity,
72 						   wpf->entity.config,
73 						   RWPF_PAD_SOURCE);
74 
75 	mutex_lock(&wpf->entity.lock);
76 
77 	if (rotate) {
78 		source_format->width = sink_format->height;
79 		source_format->height = sink_format->width;
80 	} else {
81 		source_format->width = sink_format->width;
82 		source_format->height = sink_format->height;
83 	}
84 
85 	wpf->flip.rotate = rotate;
86 
87 	mutex_unlock(&wpf->entity.lock);
88 
89 done:
90 	mutex_unlock(&video->lock);
91 	return ret;
92 }
93 
94 static int vsp1_wpf_s_ctrl(struct v4l2_ctrl *ctrl)
95 {
96 	struct vsp1_rwpf *wpf =
97 		container_of(ctrl->handler, struct vsp1_rwpf, ctrls);
98 	unsigned int rotation;
99 	u32 flip = 0;
100 	int ret;
101 
102 	/* Update the rotation. */
103 	rotation = wpf->flip.ctrls.rotate ? wpf->flip.ctrls.rotate->val : 0;
104 	ret = vsp1_wpf_set_rotation(wpf, rotation);
105 	if (ret < 0)
106 		return ret;
107 
108 	/*
109 	 * Compute the flip value resulting from all three controls, with
110 	 * rotation by 180° flipping the image in both directions. Store the
111 	 * result in the pending flip field for the next frame that will be
112 	 * processed.
113 	 */
114 	if (wpf->flip.ctrls.vflip->val)
115 		flip |= BIT(WPF_CTRL_VFLIP);
116 
117 	if (wpf->flip.ctrls.hflip && wpf->flip.ctrls.hflip->val)
118 		flip |= BIT(WPF_CTRL_HFLIP);
119 
120 	if (rotation == 180 || rotation == 270)
121 		flip ^= BIT(WPF_CTRL_VFLIP) | BIT(WPF_CTRL_HFLIP);
122 
123 	spin_lock_irq(&wpf->flip.lock);
124 	wpf->flip.pending = flip;
125 	spin_unlock_irq(&wpf->flip.lock);
126 
127 	return 0;
128 }
129 
130 static const struct v4l2_ctrl_ops vsp1_wpf_ctrl_ops = {
131 	.s_ctrl = vsp1_wpf_s_ctrl,
132 };
133 
134 static int wpf_init_controls(struct vsp1_rwpf *wpf)
135 {
136 	struct vsp1_device *vsp1 = wpf->entity.vsp1;
137 	unsigned int num_flip_ctrls;
138 
139 	spin_lock_init(&wpf->flip.lock);
140 
141 	if (wpf->entity.index != 0) {
142 		/* Only WPF0 supports flipping. */
143 		num_flip_ctrls = 0;
144 	} else if (vsp1_feature(vsp1, VSP1_HAS_WPF_HFLIP)) {
145 		/*
146 		 * When horizontal flip is supported the WPF implements three
147 		 * controls (horizontal flip, vertical flip and rotation).
148 		 */
149 		num_flip_ctrls = 3;
150 	} else if (vsp1_feature(vsp1, VSP1_HAS_WPF_VFLIP)) {
151 		/*
152 		 * When only vertical flip is supported the WPF implements a
153 		 * single control (vertical flip).
154 		 */
155 		num_flip_ctrls = 1;
156 	} else {
157 		/* Otherwise flipping is not supported. */
158 		num_flip_ctrls = 0;
159 	}
160 
161 	vsp1_rwpf_init_ctrls(wpf, num_flip_ctrls);
162 
163 	if (num_flip_ctrls >= 1) {
164 		wpf->flip.ctrls.vflip =
165 			v4l2_ctrl_new_std(&wpf->ctrls, &vsp1_wpf_ctrl_ops,
166 					  V4L2_CID_VFLIP, 0, 1, 1, 0);
167 	}
168 
169 	if (num_flip_ctrls == 3) {
170 		wpf->flip.ctrls.hflip =
171 			v4l2_ctrl_new_std(&wpf->ctrls, &vsp1_wpf_ctrl_ops,
172 					  V4L2_CID_HFLIP, 0, 1, 1, 0);
173 		wpf->flip.ctrls.rotate =
174 			v4l2_ctrl_new_std(&wpf->ctrls, &vsp1_wpf_ctrl_ops,
175 					  V4L2_CID_ROTATE, 0, 270, 90, 0);
176 		v4l2_ctrl_cluster(3, &wpf->flip.ctrls.vflip);
177 	}
178 
179 	if (wpf->ctrls.error) {
180 		dev_err(vsp1->dev, "wpf%u: failed to initialize controls\n",
181 			wpf->entity.index);
182 		return wpf->ctrls.error;
183 	}
184 
185 	return 0;
186 }
187 
188 /* -----------------------------------------------------------------------------
189  * V4L2 Subdevice Core Operations
190  */
191 
192 static int wpf_s_stream(struct v4l2_subdev *subdev, int enable)
193 {
194 	struct vsp1_rwpf *wpf = to_rwpf(subdev);
195 	struct vsp1_device *vsp1 = wpf->entity.vsp1;
196 
197 	if (enable)
198 		return 0;
199 
200 	/*
201 	 * Write to registers directly when stopping the stream as there will be
202 	 * no pipeline run to apply the display list.
203 	 */
204 	vsp1_write(vsp1, VI6_WPF_IRQ_ENB(wpf->entity.index), 0);
205 	vsp1_write(vsp1, wpf->entity.index * VI6_WPF_OFFSET +
206 		   VI6_WPF_SRCRPF, 0);
207 
208 	return 0;
209 }
210 
211 /* -----------------------------------------------------------------------------
212  * V4L2 Subdevice Operations
213  */
214 
215 static const struct v4l2_subdev_video_ops wpf_video_ops = {
216 	.s_stream = wpf_s_stream,
217 };
218 
219 static const struct v4l2_subdev_ops wpf_ops = {
220 	.video	= &wpf_video_ops,
221 	.pad    = &vsp1_rwpf_pad_ops,
222 };
223 
224 /* -----------------------------------------------------------------------------
225  * VSP1 Entity Operations
226  */
227 
228 static void vsp1_wpf_destroy(struct vsp1_entity *entity)
229 {
230 	struct vsp1_rwpf *wpf = entity_to_rwpf(entity);
231 
232 	vsp1_dlm_destroy(wpf->dlm);
233 }
234 
235 static int wpf_configure_writeback_chain(struct vsp1_rwpf *wpf,
236 					 struct vsp1_dl_list *dl)
237 {
238 	unsigned int index = wpf->entity.index;
239 	struct vsp1_dl_list *dl_next;
240 	struct vsp1_dl_body *dlb;
241 
242 	dl_next = vsp1_dl_list_get(wpf->dlm);
243 	if (!dl_next) {
244 		dev_err(wpf->entity.vsp1->dev,
245 			"Failed to obtain a dl list, disabling writeback\n");
246 		return -ENOMEM;
247 	}
248 
249 	dlb = vsp1_dl_list_get_body0(dl_next);
250 	vsp1_dl_body_write(dlb, VI6_WPF_WRBCK_CTRL(index), 0);
251 	vsp1_dl_list_add_chain(dl, dl_next);
252 
253 	return 0;
254 }
255 
256 static void wpf_configure_stream(struct vsp1_entity *entity,
257 				 struct vsp1_pipeline *pipe,
258 				 struct vsp1_dl_list *dl,
259 				 struct vsp1_dl_body *dlb)
260 {
261 	struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
262 	struct vsp1_device *vsp1 = wpf->entity.vsp1;
263 	const struct v4l2_mbus_framefmt *source_format;
264 	const struct v4l2_mbus_framefmt *sink_format;
265 	unsigned int index = wpf->entity.index;
266 	unsigned int i;
267 	u32 outfmt = 0;
268 	u32 srcrpf = 0;
269 	int ret;
270 
271 	sink_format = vsp1_entity_get_pad_format(&wpf->entity,
272 						 wpf->entity.config,
273 						 RWPF_PAD_SINK);
274 	source_format = vsp1_entity_get_pad_format(&wpf->entity,
275 						   wpf->entity.config,
276 						   RWPF_PAD_SOURCE);
277 
278 	/* Format */
279 	if (!pipe->lif || wpf->writeback) {
280 		const struct v4l2_pix_format_mplane *format = &wpf->format;
281 		const struct vsp1_format_info *fmtinfo = wpf->fmtinfo;
282 
283 		outfmt = fmtinfo->hwfmt << VI6_WPF_OUTFMT_WRFMT_SHIFT;
284 
285 		if (wpf->flip.rotate)
286 			outfmt |= VI6_WPF_OUTFMT_ROT;
287 
288 		if (fmtinfo->alpha)
289 			outfmt |= VI6_WPF_OUTFMT_PXA;
290 		if (fmtinfo->swap_yc)
291 			outfmt |= VI6_WPF_OUTFMT_SPYCS;
292 		if (fmtinfo->swap_uv)
293 			outfmt |= VI6_WPF_OUTFMT_SPUVS;
294 
295 		/* Destination stride and byte swapping. */
296 		vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_STRIDE_Y,
297 			       format->plane_fmt[0].bytesperline);
298 		if (format->num_planes > 1)
299 			vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_STRIDE_C,
300 				       format->plane_fmt[1].bytesperline);
301 
302 		vsp1_wpf_write(wpf, dlb, VI6_WPF_DSWAP, fmtinfo->swap);
303 
304 		if (vsp1_feature(vsp1, VSP1_HAS_WPF_HFLIP) && index == 0)
305 			vsp1_wpf_write(wpf, dlb, VI6_WPF_ROT_CTRL,
306 				       VI6_WPF_ROT_CTRL_LN16 |
307 				       (256 << VI6_WPF_ROT_CTRL_LMEM_WD_SHIFT));
308 	}
309 
310 	if (sink_format->code != source_format->code)
311 		outfmt |= VI6_WPF_OUTFMT_CSC;
312 
313 	wpf->outfmt = outfmt;
314 
315 	vsp1_dl_body_write(dlb, VI6_DPR_WPF_FPORCH(index),
316 			   VI6_DPR_WPF_FPORCH_FP_WPFN);
317 
318 	/*
319 	 * Sources. If the pipeline has a single input and BRx is not used,
320 	 * configure it as the master layer. Otherwise configure all
321 	 * inputs as sub-layers and select the virtual RPF as the master
322 	 * layer.
323 	 */
324 	for (i = 0; i < vsp1->info->rpf_count; ++i) {
325 		struct vsp1_rwpf *input = pipe->inputs[i];
326 
327 		if (!input)
328 			continue;
329 
330 		srcrpf |= (!pipe->brx && pipe->num_inputs == 1)
331 			? VI6_WPF_SRCRPF_RPF_ACT_MST(input->entity.index)
332 			: VI6_WPF_SRCRPF_RPF_ACT_SUB(input->entity.index);
333 	}
334 
335 	if (pipe->brx)
336 		srcrpf |= pipe->brx->type == VSP1_ENTITY_BRU
337 			? VI6_WPF_SRCRPF_VIRACT_MST
338 			: VI6_WPF_SRCRPF_VIRACT2_MST;
339 
340 	vsp1_wpf_write(wpf, dlb, VI6_WPF_SRCRPF, srcrpf);
341 
342 	/* Enable interrupts. */
343 	vsp1_dl_body_write(dlb, VI6_WPF_IRQ_STA(index), 0);
344 	vsp1_dl_body_write(dlb, VI6_WPF_IRQ_ENB(index),
345 			   VI6_WPF_IRQ_ENB_DFEE);
346 
347 	/*
348 	 * Configure writeback for display pipelines (the wpf writeback flag is
349 	 * never set for memory-to-memory pipelines). Start by adding a chained
350 	 * display list to disable writeback after a single frame, and process
351 	 * to enable writeback. If the display list allocation fails don't
352 	 * enable writeback as we wouldn't be able to safely disable it,
353 	 * resulting in possible memory corruption.
354 	 */
355 	if (wpf->writeback) {
356 		ret = wpf_configure_writeback_chain(wpf, dl);
357 		if (ret < 0)
358 			wpf->writeback = false;
359 	}
360 
361 	vsp1_dl_body_write(dlb, VI6_WPF_WRBCK_CTRL(index),
362 			   wpf->writeback ? VI6_WPF_WRBCK_CTRL_WBMD : 0);
363 }
364 
365 static void wpf_configure_frame(struct vsp1_entity *entity,
366 				struct vsp1_pipeline *pipe,
367 				struct vsp1_dl_list *dl,
368 				struct vsp1_dl_body *dlb)
369 {
370 	const unsigned int mask = BIT(WPF_CTRL_VFLIP)
371 				| BIT(WPF_CTRL_HFLIP);
372 	struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
373 	unsigned long flags;
374 	u32 outfmt;
375 
376 	spin_lock_irqsave(&wpf->flip.lock, flags);
377 	wpf->flip.active = (wpf->flip.active & ~mask)
378 			 | (wpf->flip.pending & mask);
379 	spin_unlock_irqrestore(&wpf->flip.lock, flags);
380 
381 	outfmt = (wpf->alpha << VI6_WPF_OUTFMT_PDV_SHIFT) | wpf->outfmt;
382 
383 	if (wpf->flip.active & BIT(WPF_CTRL_VFLIP))
384 		outfmt |= VI6_WPF_OUTFMT_FLP;
385 	if (wpf->flip.active & BIT(WPF_CTRL_HFLIP))
386 		outfmt |= VI6_WPF_OUTFMT_HFLP;
387 
388 	vsp1_wpf_write(wpf, dlb, VI6_WPF_OUTFMT, outfmt);
389 }
390 
391 static void wpf_configure_partition(struct vsp1_entity *entity,
392 				    struct vsp1_pipeline *pipe,
393 				    struct vsp1_dl_list *dl,
394 				    struct vsp1_dl_body *dlb)
395 {
396 	struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
397 	struct vsp1_device *vsp1 = wpf->entity.vsp1;
398 	struct vsp1_rwpf_memory mem = wpf->mem;
399 	const struct v4l2_mbus_framefmt *sink_format;
400 	const struct v4l2_pix_format_mplane *format = &wpf->format;
401 	const struct vsp1_format_info *fmtinfo = wpf->fmtinfo;
402 	unsigned int width;
403 	unsigned int height;
404 	unsigned int left;
405 	unsigned int offset;
406 	unsigned int flip;
407 	unsigned int i;
408 
409 	sink_format = vsp1_entity_get_pad_format(&wpf->entity,
410 						 wpf->entity.config,
411 						 RWPF_PAD_SINK);
412 	width = sink_format->width;
413 	height = sink_format->height;
414 	left = 0;
415 
416 	/*
417 	 * Cropping. The partition algorithm can split the image into
418 	 * multiple slices.
419 	 */
420 	if (pipe->partitions > 1) {
421 		width = pipe->partition->wpf.width;
422 		left = pipe->partition->wpf.left;
423 	}
424 
425 	vsp1_wpf_write(wpf, dlb, VI6_WPF_HSZCLIP, VI6_WPF_SZCLIP_EN |
426 		       (0 << VI6_WPF_SZCLIP_OFST_SHIFT) |
427 		       (width << VI6_WPF_SZCLIP_SIZE_SHIFT));
428 	vsp1_wpf_write(wpf, dlb, VI6_WPF_VSZCLIP, VI6_WPF_SZCLIP_EN |
429 		       (0 << VI6_WPF_SZCLIP_OFST_SHIFT) |
430 		       (height << VI6_WPF_SZCLIP_SIZE_SHIFT));
431 
432 	/*
433 	 * For display pipelines without writeback enabled there's no memory
434 	 * address to configure, return now.
435 	 */
436 	if (pipe->lif && !wpf->writeback)
437 		return;
438 
439 	/*
440 	 * Update the memory offsets based on flipping configuration.
441 	 * The destination addresses point to the locations where the
442 	 * VSP starts writing to memory, which can be any corner of the
443 	 * image depending on the combination of flipping and rotation.
444 	 */
445 
446 	/*
447 	 * First take the partition left coordinate into account.
448 	 * Compute the offset to order the partitions correctly on the
449 	 * output based on whether flipping is enabled. Consider
450 	 * horizontal flipping when rotation is disabled but vertical
451 	 * flipping when rotation is enabled, as rotating the image
452 	 * switches the horizontal and vertical directions. The offset
453 	 * is applied horizontally or vertically accordingly.
454 	 */
455 	flip = wpf->flip.active;
456 
457 	if (flip & BIT(WPF_CTRL_HFLIP) && !wpf->flip.rotate)
458 		offset = format->width - left - width;
459 	else if (flip & BIT(WPF_CTRL_VFLIP) && wpf->flip.rotate)
460 		offset = format->height - left - width;
461 	else
462 		offset = left;
463 
464 	for (i = 0; i < format->num_planes; ++i) {
465 		unsigned int hsub = i > 0 ? fmtinfo->hsub : 1;
466 		unsigned int vsub = i > 0 ? fmtinfo->vsub : 1;
467 
468 		if (wpf->flip.rotate)
469 			mem.addr[i] += offset / vsub
470 				     * format->plane_fmt[i].bytesperline;
471 		else
472 			mem.addr[i] += offset / hsub
473 				     * fmtinfo->bpp[i] / 8;
474 	}
475 
476 	if (flip & BIT(WPF_CTRL_VFLIP)) {
477 		/*
478 		 * When rotating the output (after rotation) image
479 		 * height is equal to the partition width (before
480 		 * rotation). Otherwise it is equal to the output
481 		 * image height.
482 		 */
483 		if (wpf->flip.rotate)
484 			height = width;
485 		else
486 			height = format->height;
487 
488 		mem.addr[0] += (height - 1)
489 			     * format->plane_fmt[0].bytesperline;
490 
491 		if (format->num_planes > 1) {
492 			offset = (height / fmtinfo->vsub - 1)
493 			       * format->plane_fmt[1].bytesperline;
494 			mem.addr[1] += offset;
495 			mem.addr[2] += offset;
496 		}
497 	}
498 
499 	if (wpf->flip.rotate && !(flip & BIT(WPF_CTRL_HFLIP))) {
500 		unsigned int hoffset = max(0, (int)format->width - 16);
501 
502 		/*
503 		 * Compute the output coordinate. The partition
504 		 * horizontal (left) offset becomes a vertical offset.
505 		 */
506 		for (i = 0; i < format->num_planes; ++i) {
507 			unsigned int hsub = i > 0 ? fmtinfo->hsub : 1;
508 
509 			mem.addr[i] += hoffset / hsub
510 				     * fmtinfo->bpp[i] / 8;
511 		}
512 	}
513 
514 	/*
515 	 * On Gen3+ hardware the SPUVS bit has no effect on 3-planar
516 	 * formats. Swap the U and V planes manually in that case.
517 	 */
518 	if (vsp1->info->gen >= 3 && format->num_planes == 3 &&
519 	    fmtinfo->swap_uv)
520 		swap(mem.addr[1], mem.addr[2]);
521 
522 	vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_ADDR_Y, mem.addr[0]);
523 	vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_ADDR_C0, mem.addr[1]);
524 	vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_ADDR_C1, mem.addr[2]);
525 
526 	/*
527 	 * Writeback operates in single-shot mode and lasts for a single frame,
528 	 * reset the writeback flag to false for the next frame.
529 	 */
530 	wpf->writeback = false;
531 }
532 
533 static unsigned int wpf_max_width(struct vsp1_entity *entity,
534 				  struct vsp1_pipeline *pipe)
535 {
536 	struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
537 
538 	return wpf->flip.rotate ? 256 : wpf->max_width;
539 }
540 
541 static void wpf_partition(struct vsp1_entity *entity,
542 			  struct vsp1_pipeline *pipe,
543 			  struct vsp1_partition *partition,
544 			  unsigned int partition_idx,
545 			  struct vsp1_partition_window *window)
546 {
547 	partition->wpf = *window;
548 }
549 
550 static const struct vsp1_entity_operations wpf_entity_ops = {
551 	.destroy = vsp1_wpf_destroy,
552 	.configure_stream = wpf_configure_stream,
553 	.configure_frame = wpf_configure_frame,
554 	.configure_partition = wpf_configure_partition,
555 	.max_width = wpf_max_width,
556 	.partition = wpf_partition,
557 };
558 
559 /* -----------------------------------------------------------------------------
560  * Initialization and Cleanup
561  */
562 
563 struct vsp1_rwpf *vsp1_wpf_create(struct vsp1_device *vsp1, unsigned int index)
564 {
565 	struct vsp1_rwpf *wpf;
566 	char name[6];
567 	int ret;
568 
569 	wpf = devm_kzalloc(vsp1->dev, sizeof(*wpf), GFP_KERNEL);
570 	if (wpf == NULL)
571 		return ERR_PTR(-ENOMEM);
572 
573 	if (vsp1->info->gen == 2) {
574 		wpf->max_width = WPF_GEN2_MAX_WIDTH;
575 		wpf->max_height = WPF_GEN2_MAX_HEIGHT;
576 	} else {
577 		wpf->max_width = WPF_GEN3_MAX_WIDTH;
578 		wpf->max_height = WPF_GEN3_MAX_HEIGHT;
579 	}
580 
581 	wpf->entity.ops = &wpf_entity_ops;
582 	wpf->entity.type = VSP1_ENTITY_WPF;
583 	wpf->entity.index = index;
584 
585 	sprintf(name, "wpf.%u", index);
586 	ret = vsp1_entity_init(vsp1, &wpf->entity, name, 2, &wpf_ops,
587 			       MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER);
588 	if (ret < 0)
589 		return ERR_PTR(ret);
590 
591 	/* Initialize the display list manager. */
592 	wpf->dlm = vsp1_dlm_create(vsp1, index, 64);
593 	if (!wpf->dlm) {
594 		ret = -ENOMEM;
595 		goto error;
596 	}
597 
598 	/* Initialize the control handler. */
599 	ret = wpf_init_controls(wpf);
600 	if (ret < 0) {
601 		dev_err(vsp1->dev, "wpf%u: failed to initialize controls\n",
602 			index);
603 		goto error;
604 	}
605 
606 	v4l2_ctrl_handler_setup(&wpf->ctrls);
607 
608 	return wpf;
609 
610 error:
611 	vsp1_entity_destroy(&wpf->entity);
612 	return ERR_PTR(ret);
613 }
614