1 // SPDX-License-Identifier: GPL-2.0+
3 * vsp1_wpf.c -- R-Car VSP1 Write Pixel Formatter
5 * Copyright (C) 2013-2014 Renesas Electronics Corporation
7 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
10 #include <linux/device.h>
12 #include <media/v4l2-subdev.h>
16 #include "vsp1_pipe.h"
17 #include "vsp1_rwpf.h"
18 #include "vsp1_video.h"
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
25 /* -----------------------------------------------------------------------------
29 static inline void vsp1_wpf_write(struct vsp1_rwpf *wpf,
30 struct vsp1_dl_body *dlb, u32 reg, u32 data)
32 vsp1_dl_body_write(dlb, reg + wpf->entity.index * VI6_WPF_OFFSET, data);
35 /* -----------------------------------------------------------------------------
44 static int vsp1_wpf_set_rotation(struct vsp1_rwpf *wpf, unsigned int rotation)
46 struct vsp1_video *video = wpf->video;
47 struct v4l2_mbus_framefmt *sink_format;
48 struct v4l2_mbus_framefmt *source_format;
53 * Only consider the 0°/180° from/to 90°/270° modifications, the rest
54 * is taken care of by the flipping configuration.
56 rotate = rotation == 90 || rotation == 270;
57 if (rotate == wpf->flip.rotate)
60 /* Changing rotation isn't allowed when buffers are allocated. */
61 mutex_lock(&video->lock);
63 if (vb2_is_busy(&video->queue)) {
68 sink_format = vsp1_entity_get_pad_format(&wpf->entity,
71 source_format = vsp1_entity_get_pad_format(&wpf->entity,
75 mutex_lock(&wpf->entity.lock);
78 source_format->width = sink_format->height;
79 source_format->height = sink_format->width;
81 source_format->width = sink_format->width;
82 source_format->height = sink_format->height;
85 wpf->flip.rotate = rotate;
87 mutex_unlock(&wpf->entity.lock);
90 mutex_unlock(&video->lock);
94 static int vsp1_wpf_s_ctrl(struct v4l2_ctrl *ctrl)
96 struct vsp1_rwpf *wpf =
97 container_of(ctrl->handler, struct vsp1_rwpf, ctrls);
98 unsigned int rotation;
102 /* Update the rotation. */
103 rotation = wpf->flip.ctrls.rotate ? wpf->flip.ctrls.rotate->val : 0;
104 ret = vsp1_wpf_set_rotation(wpf, rotation);
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
114 if (wpf->flip.ctrls.vflip->val)
115 flip |= BIT(WPF_CTRL_VFLIP);
117 if (wpf->flip.ctrls.hflip && wpf->flip.ctrls.hflip->val)
118 flip |= BIT(WPF_CTRL_HFLIP);
120 if (rotation == 180 || rotation == 270)
121 flip ^= BIT(WPF_CTRL_VFLIP) | BIT(WPF_CTRL_HFLIP);
123 spin_lock_irq(&wpf->flip.lock);
124 wpf->flip.pending = flip;
125 spin_unlock_irq(&wpf->flip.lock);
130 static const struct v4l2_ctrl_ops vsp1_wpf_ctrl_ops = {
131 .s_ctrl = vsp1_wpf_s_ctrl,
134 static int wpf_init_controls(struct vsp1_rwpf *wpf)
136 struct vsp1_device *vsp1 = wpf->entity.vsp1;
137 unsigned int num_flip_ctrls;
139 spin_lock_init(&wpf->flip.lock);
141 if (wpf->entity.index != 0) {
142 /* Only WPF0 supports flipping. */
144 } else if (vsp1_feature(vsp1, VSP1_HAS_WPF_HFLIP)) {
146 * When horizontal flip is supported the WPF implements three
147 * controls (horizontal flip, vertical flip and rotation).
150 } else if (vsp1_feature(vsp1, VSP1_HAS_WPF_VFLIP)) {
152 * When only vertical flip is supported the WPF implements a
153 * single control (vertical flip).
157 /* Otherwise flipping is not supported. */
161 vsp1_rwpf_init_ctrls(wpf, num_flip_ctrls);
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);
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);
179 if (wpf->ctrls.error) {
180 dev_err(vsp1->dev, "wpf%u: failed to initialize controls\n",
182 return wpf->ctrls.error;
188 /* -----------------------------------------------------------------------------
189 * V4L2 Subdevice Core Operations
192 static int wpf_s_stream(struct v4l2_subdev *subdev, int enable)
194 struct vsp1_rwpf *wpf = to_rwpf(subdev);
195 struct vsp1_device *vsp1 = wpf->entity.vsp1;
201 * Write to registers directly when stopping the stream as there will be
202 * no pipeline run to apply the display list.
204 vsp1_write(vsp1, VI6_WPF_IRQ_ENB(wpf->entity.index), 0);
205 vsp1_write(vsp1, wpf->entity.index * VI6_WPF_OFFSET +
211 /* -----------------------------------------------------------------------------
212 * V4L2 Subdevice Operations
215 static const struct v4l2_subdev_video_ops wpf_video_ops = {
216 .s_stream = wpf_s_stream,
219 static const struct v4l2_subdev_ops wpf_ops = {
220 .video = &wpf_video_ops,
221 .pad = &vsp1_rwpf_pad_ops,
224 /* -----------------------------------------------------------------------------
225 * VSP1 Entity Operations
228 static void vsp1_wpf_destroy(struct vsp1_entity *entity)
230 struct vsp1_rwpf *wpf = entity_to_rwpf(entity);
232 vsp1_dlm_destroy(wpf->dlm);
235 static void wpf_configure_stream(struct vsp1_entity *entity,
236 struct vsp1_pipeline *pipe,
237 struct vsp1_dl_list *dl,
238 struct vsp1_dl_body *dlb)
240 struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
241 struct vsp1_device *vsp1 = wpf->entity.vsp1;
242 const struct v4l2_mbus_framefmt *source_format;
243 const struct v4l2_mbus_framefmt *sink_format;
248 sink_format = vsp1_entity_get_pad_format(&wpf->entity,
251 source_format = vsp1_entity_get_pad_format(&wpf->entity,
256 const struct v4l2_pix_format_mplane *format = &wpf->format;
257 const struct vsp1_format_info *fmtinfo = wpf->fmtinfo;
259 outfmt = fmtinfo->hwfmt << VI6_WPF_OUTFMT_WRFMT_SHIFT;
261 if (wpf->flip.rotate)
262 outfmt |= VI6_WPF_OUTFMT_ROT;
265 outfmt |= VI6_WPF_OUTFMT_PXA;
266 if (fmtinfo->swap_yc)
267 outfmt |= VI6_WPF_OUTFMT_SPYCS;
268 if (fmtinfo->swap_uv)
269 outfmt |= VI6_WPF_OUTFMT_SPUVS;
271 /* Destination stride and byte swapping. */
272 vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_STRIDE_Y,
273 format->plane_fmt[0].bytesperline);
274 if (format->num_planes > 1)
275 vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_STRIDE_C,
276 format->plane_fmt[1].bytesperline);
278 vsp1_wpf_write(wpf, dlb, VI6_WPF_DSWAP, fmtinfo->swap);
280 if (vsp1_feature(vsp1, VSP1_HAS_WPF_HFLIP) &&
281 wpf->entity.index == 0)
282 vsp1_wpf_write(wpf, dlb, VI6_WPF_ROT_CTRL,
283 VI6_WPF_ROT_CTRL_LN16 |
284 (256 << VI6_WPF_ROT_CTRL_LMEM_WD_SHIFT));
287 if (sink_format->code != source_format->code)
288 outfmt |= VI6_WPF_OUTFMT_CSC;
290 wpf->outfmt = outfmt;
292 vsp1_dl_body_write(dlb, VI6_DPR_WPF_FPORCH(wpf->entity.index),
293 VI6_DPR_WPF_FPORCH_FP_WPFN);
295 vsp1_dl_body_write(dlb, VI6_WPF_WRBCK_CTRL(wpf->entity.index), 0);
298 * Sources. If the pipeline has a single input and BRx is not used,
299 * configure it as the master layer. Otherwise configure all
300 * inputs as sub-layers and select the virtual RPF as the master
303 for (i = 0; i < vsp1->info->rpf_count; ++i) {
304 struct vsp1_rwpf *input = pipe->inputs[i];
309 srcrpf |= (!pipe->brx && pipe->num_inputs == 1)
310 ? VI6_WPF_SRCRPF_RPF_ACT_MST(input->entity.index)
311 : VI6_WPF_SRCRPF_RPF_ACT_SUB(input->entity.index);
315 srcrpf |= pipe->brx->type == VSP1_ENTITY_BRU
316 ? VI6_WPF_SRCRPF_VIRACT_MST
317 : VI6_WPF_SRCRPF_VIRACT2_MST;
319 vsp1_wpf_write(wpf, dlb, VI6_WPF_SRCRPF, srcrpf);
321 /* Enable interrupts. */
322 vsp1_dl_body_write(dlb, VI6_WPF_IRQ_STA(wpf->entity.index), 0);
323 vsp1_dl_body_write(dlb, VI6_WPF_IRQ_ENB(wpf->entity.index),
324 VI6_WFP_IRQ_ENB_DFEE);
327 static void wpf_configure_frame(struct vsp1_entity *entity,
328 struct vsp1_pipeline *pipe,
329 struct vsp1_dl_list *dl,
330 struct vsp1_dl_body *dlb)
332 const unsigned int mask = BIT(WPF_CTRL_VFLIP)
333 | BIT(WPF_CTRL_HFLIP);
334 struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
338 spin_lock_irqsave(&wpf->flip.lock, flags);
339 wpf->flip.active = (wpf->flip.active & ~mask)
340 | (wpf->flip.pending & mask);
341 spin_unlock_irqrestore(&wpf->flip.lock, flags);
343 outfmt = (wpf->alpha << VI6_WPF_OUTFMT_PDV_SHIFT) | wpf->outfmt;
345 if (wpf->flip.active & BIT(WPF_CTRL_VFLIP))
346 outfmt |= VI6_WPF_OUTFMT_FLP;
347 if (wpf->flip.active & BIT(WPF_CTRL_HFLIP))
348 outfmt |= VI6_WPF_OUTFMT_HFLP;
350 vsp1_wpf_write(wpf, dlb, VI6_WPF_OUTFMT, outfmt);
353 static void wpf_configure_partition(struct vsp1_entity *entity,
354 struct vsp1_pipeline *pipe,
355 struct vsp1_dl_list *dl,
356 struct vsp1_dl_body *dlb)
358 struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
359 struct vsp1_device *vsp1 = wpf->entity.vsp1;
360 struct vsp1_rwpf_memory mem = wpf->mem;
361 const struct v4l2_mbus_framefmt *sink_format;
362 const struct v4l2_pix_format_mplane *format = &wpf->format;
363 const struct vsp1_format_info *fmtinfo = wpf->fmtinfo;
371 sink_format = vsp1_entity_get_pad_format(&wpf->entity,
374 width = sink_format->width;
375 height = sink_format->height;
379 * Cropping. The partition algorithm can split the image into
382 if (pipe->partitions > 1) {
383 width = pipe->partition->wpf.width;
384 left = pipe->partition->wpf.left;
387 vsp1_wpf_write(wpf, dlb, VI6_WPF_HSZCLIP, VI6_WPF_SZCLIP_EN |
388 (0 << VI6_WPF_SZCLIP_OFST_SHIFT) |
389 (width << VI6_WPF_SZCLIP_SIZE_SHIFT));
390 vsp1_wpf_write(wpf, dlb, VI6_WPF_VSZCLIP, VI6_WPF_SZCLIP_EN |
391 (0 << VI6_WPF_SZCLIP_OFST_SHIFT) |
392 (height << VI6_WPF_SZCLIP_SIZE_SHIFT));
398 * Update the memory offsets based on flipping configuration.
399 * The destination addresses point to the locations where the
400 * VSP starts writing to memory, which can be any corner of the
401 * image depending on the combination of flipping and rotation.
405 * First take the partition left coordinate into account.
406 * Compute the offset to order the partitions correctly on the
407 * output based on whether flipping is enabled. Consider
408 * horizontal flipping when rotation is disabled but vertical
409 * flipping when rotation is enabled, as rotating the image
410 * switches the horizontal and vertical directions. The offset
411 * is applied horizontally or vertically accordingly.
413 flip = wpf->flip.active;
415 if (flip & BIT(WPF_CTRL_HFLIP) && !wpf->flip.rotate)
416 offset = format->width - left - width;
417 else if (flip & BIT(WPF_CTRL_VFLIP) && wpf->flip.rotate)
418 offset = format->height - left - width;
422 for (i = 0; i < format->num_planes; ++i) {
423 unsigned int hsub = i > 0 ? fmtinfo->hsub : 1;
424 unsigned int vsub = i > 0 ? fmtinfo->vsub : 1;
426 if (wpf->flip.rotate)
427 mem.addr[i] += offset / vsub
428 * format->plane_fmt[i].bytesperline;
430 mem.addr[i] += offset / hsub
431 * fmtinfo->bpp[i] / 8;
434 if (flip & BIT(WPF_CTRL_VFLIP)) {
436 * When rotating the output (after rotation) image
437 * height is equal to the partition width (before
438 * rotation). Otherwise it is equal to the output
441 if (wpf->flip.rotate)
444 height = format->height;
446 mem.addr[0] += (height - 1)
447 * format->plane_fmt[0].bytesperline;
449 if (format->num_planes > 1) {
450 offset = (height / fmtinfo->vsub - 1)
451 * format->plane_fmt[1].bytesperline;
452 mem.addr[1] += offset;
453 mem.addr[2] += offset;
457 if (wpf->flip.rotate && !(flip & BIT(WPF_CTRL_HFLIP))) {
458 unsigned int hoffset = max(0, (int)format->width - 16);
461 * Compute the output coordinate. The partition
462 * horizontal (left) offset becomes a vertical offset.
464 for (i = 0; i < format->num_planes; ++i) {
465 unsigned int hsub = i > 0 ? fmtinfo->hsub : 1;
467 mem.addr[i] += hoffset / hsub
468 * fmtinfo->bpp[i] / 8;
473 * On Gen3 hardware the SPUVS bit has no effect on 3-planar
474 * formats. Swap the U and V planes manually in that case.
476 if (vsp1->info->gen == 3 && format->num_planes == 3 &&
478 swap(mem.addr[1], mem.addr[2]);
480 vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_ADDR_Y, mem.addr[0]);
481 vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_ADDR_C0, mem.addr[1]);
482 vsp1_wpf_write(wpf, dlb, VI6_WPF_DSTM_ADDR_C1, mem.addr[2]);
485 static unsigned int wpf_max_width(struct vsp1_entity *entity,
486 struct vsp1_pipeline *pipe)
488 struct vsp1_rwpf *wpf = to_rwpf(&entity->subdev);
490 return wpf->flip.rotate ? 256 : wpf->max_width;
493 static void wpf_partition(struct vsp1_entity *entity,
494 struct vsp1_pipeline *pipe,
495 struct vsp1_partition *partition,
496 unsigned int partition_idx,
497 struct vsp1_partition_window *window)
499 partition->wpf = *window;
502 static const struct vsp1_entity_operations wpf_entity_ops = {
503 .destroy = vsp1_wpf_destroy,
504 .configure_stream = wpf_configure_stream,
505 .configure_frame = wpf_configure_frame,
506 .configure_partition = wpf_configure_partition,
507 .max_width = wpf_max_width,
508 .partition = wpf_partition,
511 /* -----------------------------------------------------------------------------
512 * Initialization and Cleanup
515 struct vsp1_rwpf *vsp1_wpf_create(struct vsp1_device *vsp1, unsigned int index)
517 struct vsp1_rwpf *wpf;
521 wpf = devm_kzalloc(vsp1->dev, sizeof(*wpf), GFP_KERNEL);
523 return ERR_PTR(-ENOMEM);
525 if (vsp1->info->gen == 2) {
526 wpf->max_width = WPF_GEN2_MAX_WIDTH;
527 wpf->max_height = WPF_GEN2_MAX_HEIGHT;
529 wpf->max_width = WPF_GEN3_MAX_WIDTH;
530 wpf->max_height = WPF_GEN3_MAX_HEIGHT;
533 wpf->entity.ops = &wpf_entity_ops;
534 wpf->entity.type = VSP1_ENTITY_WPF;
535 wpf->entity.index = index;
537 sprintf(name, "wpf.%u", index);
538 ret = vsp1_entity_init(vsp1, &wpf->entity, name, 2, &wpf_ops,
539 MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER);
543 /* Initialize the display list manager. */
544 wpf->dlm = vsp1_dlm_create(vsp1, index, 64);
550 /* Initialize the control handler. */
551 ret = wpf_init_controls(wpf);
553 dev_err(vsp1->dev, "wpf%u: failed to initialize controls\n",
558 v4l2_ctrl_handler_setup(&wpf->ctrls);
563 vsp1_entity_destroy(&wpf->entity);