| Message ID | 20190301170848.6598-6-kieran.bingham@ideasonboard.com (mailing list archive) |
|---|---|
| State | New |
| Delegated to: | Kieran Bingham |
| Headers | show |
| Series | media: vsp1: Partition phased overlap support | expand |
On 01/03/2019 17:08, Kieran Bingham wrote: > From: Kieran Bingham <kieran.bingham+renesas@ideasonboard.com> > > To improve image quality when scaling using the UDS we need to correctly > determine the start phase value for each partition window, and apply a > margin to overlap discontinous pixels. > > Provide helper functions for calculating the phase parameters, and source > locations for a given output position and use these values to calculate our > parition window parameters. > > Extend the partition algorithm to sweep first backwards, then forwards > through the entity list. Each entity is given the opportunity to expand it's window on the reverse sweep, and clip An oddly long line there - I'll rewrap on next iteration. > or increase the offset on the forwards sweep. > > Signed-off-by: Kieran Bingham <kieran.bingham+renesas@ideasonboard.com> > > --- > v2: > - Configure HSTP and HEDP in uds_configure_partition for single partitions > - refactored to use individual functions for various phase and position calculations > - squashed forwards and backwards propagation work to a single patch > - Fixed a few 'off-by-ones' > - considerable other changes :) > --- > drivers/media/platform/vsp1/vsp1_entity.h | 2 +- > drivers/media/platform/vsp1/vsp1_pipe.c | 40 +++++- > drivers/media/platform/vsp1/vsp1_pipe.h | 6 + > drivers/media/platform/vsp1/vsp1_rpf.c | 8 +- > drivers/media/platform/vsp1/vsp1_sru.c | 37 +++++- > drivers/media/platform/vsp1/vsp1_uds.c | 151 +++++++++++++++++++++- > drivers/media/platform/vsp1/vsp1_video.c | 1 + > drivers/media/platform/vsp1/vsp1_wpf.c | 16 ++- > 8 files changed, 242 insertions(+), 19 deletions(-) > > diff --git a/drivers/media/platform/vsp1/vsp1_entity.h b/drivers/media/platform/vsp1/vsp1_entity.h > index 97acb7795cf1..772492877764 100644 > --- a/drivers/media/platform/vsp1/vsp1_entity.h > +++ b/drivers/media/platform/vsp1/vsp1_entity.h > @@ -88,7 +88,7 @@ struct vsp1_entity_operations { > unsigned int (*max_width)(struct vsp1_entity *, struct vsp1_pipeline *); > void (*partition)(struct vsp1_entity *, struct vsp1_pipeline *, > struct vsp1_partition *, unsigned int, > - struct vsp1_partition_window *); > + struct vsp1_partition_window *, bool); > }; > > struct vsp1_entity { > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.c b/drivers/media/platform/vsp1/vsp1_pipe.c > index f1bd21a01bcd..137ebe0ecad2 100644 > --- a/drivers/media/platform/vsp1/vsp1_pipe.c > +++ b/drivers/media/platform/vsp1/vsp1_pipe.c > @@ -375,10 +375,32 @@ bool vsp1_pipeline_partitioned(struct vsp1_pipeline *pipe) > /* > * Propagate the partition calculations through the pipeline > * > - * Work backwards through the pipe, allowing each entity to update the partition > - * parameters based on its configuration, and the entity connected to its > - * source. Each entity must produce the partition required for the previous > - * entity in the pipeline. > + * Work backwards through the pipe, allowing each entity to update the > + * partition parameters based on its configuration. Each entity must produce > + * the partition window required for the previous entity in the pipeline > + * to generate. This window can be passed through if no changes are necessary. > + * > + * Entities are processed in reverse order: > + * DDDD = Destination pixels > + * SSSS = Source pixels > + * ==== = Intermediate pixels > + * ____ = Disposable pixels > + * > + * WPF |DDDD| WPF determines it's required partition > + * SRU |====| Interconnected entities pass through > + * UDS(source) |<====>| UDS Source requests overlap > + * UDS(sink) |<-|======|->| UDS Sink calculates input size > + * RPF |__SSSSSSSS__| RPF provides extra pixels > + * > + * Then work forwards through the pipe allowing entities to communicate any > + * clipping required based on any overlap and expansions they may have > + * generated. > + * > + * RPF |__SSSSSSSS__| Partition window is propagated forwards > + * UDS(sink) |============| > + * UDS(source) |<====>| UDS Source reports overlap > + * SRU |======| Interconnected entities are updated > + * WPF |_DDDD_| WPF handles clipping > */ > void vsp1_pipeline_propagate_partition(struct vsp1_pipeline *pipe, > struct vsp1_partition *partition, > @@ -387,10 +409,18 @@ void vsp1_pipeline_propagate_partition(struct vsp1_pipeline *pipe, > { > struct vsp1_entity *entity; > > + /* Move backwards through the pipeline to propagate any expansion. */ > list_for_each_entry_reverse(entity, &pipe->entities, list_pipe) { > if (entity->ops->partition) > entity->ops->partition(entity, pipe, partition, index, > - window); > + window, false); > + } > + > + /* Move forwards through the pipeline and propagate any updates. */ > + list_for_each_entry(entity, &pipe->entities, list_pipe) { > + if (entity->ops->partition) > + entity->ops->partition(entity, pipe, partition, index, > + window, true); > } > } > > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.h b/drivers/media/platform/vsp1/vsp1_pipe.h > index dd8b2cdc6452..3e263a60f79b 100644 > --- a/drivers/media/platform/vsp1/vsp1_pipe.h > +++ b/drivers/media/platform/vsp1/vsp1_pipe.h > @@ -58,10 +58,12 @@ enum vsp1_pipeline_state { > * @left: horizontal coordinate of the partition start in pixels relative to the > * left edge of the image > * @width: partition width in pixels > + * @offset: The number of pixels from the left edge of the window to clip > */ > struct vsp1_partition_window { > unsigned int left; > unsigned int width; > + unsigned int offset; > }; > > /* > @@ -71,6 +73,8 @@ struct vsp1_partition_window { > * @uds_source: The UDS output partition window configuration > * @sru: The SRU partition window configuration > * @wpf: The WPF partition window configuration > + * @start_phase: The UDS start phase for this partition > + * @end_phase: The UDS end phase for this partition > */ > struct vsp1_partition { > struct vsp1_partition_window rpf; > @@ -78,6 +82,8 @@ struct vsp1_partition { > struct vsp1_partition_window uds_source; > struct vsp1_partition_window sru; > struct vsp1_partition_window wpf; > + unsigned int start_phase; > + unsigned int end_phase; > }; > > /* > diff --git a/drivers/media/platform/vsp1/vsp1_rpf.c b/drivers/media/platform/vsp1/vsp1_rpf.c > index ef9bf5dd55a0..46d270644fe2 100644 > --- a/drivers/media/platform/vsp1/vsp1_rpf.c > +++ b/drivers/media/platform/vsp1/vsp1_rpf.c > @@ -324,9 +324,13 @@ static void rpf_partition(struct vsp1_entity *entity, > struct vsp1_pipeline *pipe, > struct vsp1_partition *partition, > unsigned int partition_idx, > - struct vsp1_partition_window *window) > + struct vsp1_partition_window *window, > + bool forwards) > { > - partition->rpf = *window; > + if (forwards) > + *window = partition->rpf; > + else > + partition->rpf = *window; > } > > static const struct vsp1_entity_operations rpf_entity_ops = { > diff --git a/drivers/media/platform/vsp1/vsp1_sru.c b/drivers/media/platform/vsp1/vsp1_sru.c > index b1617cb1f2b9..39f6e80a02a9 100644 > --- a/drivers/media/platform/vsp1/vsp1_sru.c > +++ b/drivers/media/platform/vsp1/vsp1_sru.c > @@ -327,24 +327,57 @@ static void sru_partition(struct vsp1_entity *entity, > struct vsp1_pipeline *pipe, > struct vsp1_partition *partition, > unsigned int partition_idx, > - struct vsp1_partition_window *window) > + struct vsp1_partition_window *window, > + bool forwards) > { > struct vsp1_sru *sru = to_sru(&entity->subdev); > struct v4l2_mbus_framefmt *input; > struct v4l2_mbus_framefmt *output; > + int scale_up; > + > + /* The partition->sru represents the SRU sink pad configuration. */ In actual fact, only the 'offset' needs to be stored for the SRU. It's more of a passive entity, and no partition parameters get programmed at runtime. For consistency, I think it's still worth keeping partition->sru the same type as the other entities. I'll remove this line and update the comment where the structure is stored... > > input = vsp1_entity_get_pad_format(&sru->entity, sru->entity.config, > SRU_PAD_SINK); > output = vsp1_entity_get_pad_format(&sru->entity, sru->entity.config, > SRU_PAD_SOURCE); > > + scale_up = (input->width != output->width); > + > + if (forwards) { > + /* Propagate the clipping offsets forwards. */ > + window->offset += partition->sru.offset; > + > + if (scale_up) > + window->offset *= 2; > + > + return; > + } > + > /* Adapt if SRUx2 is enabled. */ > - if (input->width != output->width) { > + if (scale_up) { > + /* Clipping offsets are not back-propagated. */ > window->width /= 2; > window->left /= 2; > + > + /* SRUx2 requires an extra pixel at the right edge. */ > + window->width++; > } > > + /* Store our adapted sink window. */ /* * The partition->sru represents the SRU sink pad configuration. * However, the SRU is a passive component in the partition algorithm. */ > partition->sru = *window;> + > + /* Expand to the left edge. */ > + if (window->left != 0) { > + window->left--; > + window->width++; > + partition->sru.offset = 1; > + } else { > + partition->sru.offset = 0; > + } > + > + /* Expand to the right edge. */ > + window->width++; > } > > static const struct vsp1_entity_operations sru_entity_ops = { > diff --git a/drivers/media/platform/vsp1/vsp1_uds.c b/drivers/media/platform/vsp1/vsp1_uds.c > index c71c24363d54..e2bd44740ad6 100644 > --- a/drivers/media/platform/vsp1/vsp1_uds.c > +++ b/drivers/media/platform/vsp1/vsp1_uds.c > @@ -58,6 +58,85 @@ static unsigned int uds_multiplier(int ratio) > return mp < 4 ? 1 : (mp < 8 ? 2 : 4); > } > > +/* > + * These functions all assume a starting phase of 0. > + * i.e. the left edge of the image. > + */ > + > +/* > + * uds_residual - Return the residual phase cycle at the given position > + * @pos: source destination position Source destination position is horrible here. I think I'll reword this (and the others) as @pos: source output position. Even that might need some more thought... > + * @ratio: scaling ratio in U4.12 fixed-point format > + */ > +static unsigned int uds_residual(unsigned int pos, unsigned int ratio) > +{ > + unsigned int mp = uds_multiplier(ratio); > + unsigned int residual = (pos * ratio) % (mp * 4096); > + > + return residual; > +} > + > +/* > + * uds_left_src_pixel - Return the sink pixel location for the given source > + * position > + * > + * @pos: source destination position > + * @ratio: scaling ratio in U4.12 fixed-point format > + */ > +static unsigned int uds_left_src_pixel(unsigned int pos, unsigned int ratio) This function needs to be renamed to uds_left_sink_pixel s/src/sink/... > +{ > + unsigned int mp = uds_multiplier(ratio); > + unsigned int prefilter_out = (pos * ratio) / (mp * 4096); > + unsigned int residual = (pos * ratio) % (mp * 4096); > + > + /* Todo: Section 32.3.7.5 : Procedure 3 > + * > + * A restriction is described where the destination position must > + * satisfy the following conditions: > + * > + * (pos * ratio) must be a multiple of mp > + * > + * This is not yet guaranteed and thus this check is in place > + * until the pull-back is correctly calculated for all ratio > + * and position values. > + */ > + WARN_ONCE((mp == 2 && (residual & 0x01)) || > + (mp == 4 && (residual & 0x03)), > + "uds_left_pixel restrictions failed"); > + > + return mp * (prefilter_out + (residual ? 1 : 0)); > +} > + > +/* > + * uds_right_src_pixel - Return the sink pixel location for the given source > + * position > + * > + * @pos: source destination position > + * @ratio: scaling ratio in U4.12 fixed-point format > + */ > +static unsigned int uds_right_src_pixel(unsigned int pos, unsigned int ratio) And the same here, it should be uds_right_sink_pixel. It's the 'source' of the UDS - but in our system the input to the UDS is the 'sink' > +{ > + unsigned int mp = uds_multiplier(ratio); > + unsigned int prefilter_out = (pos * ratio) / (mp * 4096); > + > + return mp * (prefilter_out + 2) + (mp / 2); > +} > + > +/* > + * uds_start_phase - Return the sink pixel location for the given source > + * position > + * > + * @pos: source destination position > + * @ratio: scaling ratio in U4.12 fixed-point format > + */ > +static unsigned int uds_start_phase(unsigned int pos, unsigned int ratio) > +{ > + unsigned int mp = uds_multiplier(ratio); > + unsigned int residual = (pos * ratio) % (mp * 4096); > + > + return residual ? (4096 - residual / mp) : 0; > +} > + > /* > * uds_output_size - Return the output size for an input size and scaling ratio > * @input: input size in pixels > @@ -270,6 +349,7 @@ static void uds_configure_stream(struct vsp1_entity *entity, > const struct v4l2_mbus_framefmt *input; > unsigned int hscale; > unsigned int vscale; > + bool manual_phase = vsp1_pipeline_partitioned(pipe); > bool multitap; > > input = vsp1_entity_get_pad_format(&uds->entity, uds->entity.config, > @@ -294,7 +374,8 @@ static void uds_configure_stream(struct vsp1_entity *entity, > > vsp1_uds_write(uds, dlb, VI6_UDS_CTRL, > (uds->scale_alpha ? VI6_UDS_CTRL_AON : 0) | > - (multitap ? VI6_UDS_CTRL_BC : 0)); > + (multitap ? VI6_UDS_CTRL_BC : 0) | > + (manual_phase ? VI6_UDS_CTRL_AMDSLH : 0)); > > vsp1_uds_write(uds, dlb, VI6_UDS_PASS_BWIDTH, > (uds_passband_width(hscale) > @@ -332,6 +413,12 @@ static void uds_configure_partition(struct vsp1_entity *entity, > << VI6_UDS_CLIP_SIZE_HSIZE_SHIFT) | > (output->height > << VI6_UDS_CLIP_SIZE_VSIZE_SHIFT)); > + > + vsp1_uds_write(uds, dlb, VI6_UDS_HPHASE, > + (partition->start_phase > + << VI6_UDS_HPHASE_HSTP_SHIFT) | > + (partition->end_phase > + << VI6_UDS_HPHASE_HEDP_SHIFT)); > } > > static unsigned int uds_max_width(struct vsp1_entity *entity, > @@ -374,11 +461,23 @@ static void uds_partition(struct vsp1_entity *entity, > struct vsp1_pipeline *pipe, > struct vsp1_partition *partition, > unsigned int partition_idx, > - struct vsp1_partition_window *window) > + struct vsp1_partition_window *window, > + bool forwards) > { > struct vsp1_uds *uds = to_uds(&entity->subdev); > const struct v4l2_mbus_framefmt *output; > const struct v4l2_mbus_framefmt *input; > + unsigned int hscale; > + unsigned int right_sink; > + unsigned int margin; > + unsigned int left; > + unsigned int right; > + > + /* For forwards propagation - simply pass on our output. */ > + if (forwards) { > + *window = partition->uds_source; > + return; > + } > > /* Initialise the partition state. */ > partition->uds_sink = *window; > @@ -389,11 +488,51 @@ static void uds_partition(struct vsp1_entity *entity, > output = vsp1_entity_get_pad_format(&uds->entity, uds->entity.config, > UDS_PAD_SOURCE); > > - partition->uds_sink.width = window->width * input->width > - / output->width; > - partition->uds_sink.left = window->left * input->width > - / output->width; > + hscale = uds_compute_ratio(input->width, output->width); > + > + /* > + * Quantify the margin required for discontinuous overlap, and expand > + * the window no further than the limits of the image. > + */ > + margin = hscale < 0x200 ? 32 : /* 8 < scale */ > + hscale < 0x400 ? 16 : /* 4 < scale <= 8 */ > + hscale < 0x800 ? 8 : /* 2 < scale <= 4 */ > + 4; /* scale <= 2 */ > + > + left = max_t(int, 0, window->left - margin); > + right = min_t(int, output->width - 1, > + window->left + window->width - 1 + margin); > + > + /* > + * Handle our output partition configuration. > + * We can clip the pixels from the right edge, thus the > + * uds_source.width does not include the right margin. > + */ > + partition->uds_source.left = left; > + partition->uds_source.width = window->left - left + window->width; > + > + /* > + * The UDS can not clip the left pixels so this value will be > + * propagated forwards until it reaches the WPF. > + */ > + partition->uds_source.offset = window->left - left; > + > + /* Identify the input positions from the expanded partition. */ > + partition->uds_sink.left = uds_left_src_pixel(left, hscale); > + > + right_sink = uds_right_src_pixel(right, hscale); > + partition->uds_sink.width = right_sink - partition->uds_sink.left; > + > + /* > + * We do not currently use VI6_UDS_CTRL_AMD from VI6_UDS_CTRL. > + * In the event that we enable VI6_UDS_CTRL_AMD, we must set the end > + * phase for the final partition to the phase_edge. > + */ > + partition->end_phase = 0; > + partition->start_phase = uds_start_phase(partition->uds_source.left, > + hscale); > > + /* Pass a copy of our sink down to the previous entity. */ > *window = partition->uds_sink; > } > > diff --git a/drivers/media/platform/vsp1/vsp1_video.c b/drivers/media/platform/vsp1/vsp1_video.c > index d1ecc3d91290..3638a4e9bb19 100644 > --- a/drivers/media/platform/vsp1/vsp1_video.c > +++ b/drivers/media/platform/vsp1/vsp1_video.c > @@ -221,6 +221,7 @@ static void vsp1_video_calculate_partition(struct vsp1_pipeline *pipe, > /* Initialise the partition with sane starting conditions. */ > window.left = index * div_size; > window.width = div_size; > + window.offset = 0; > > modulus = format->width % div_size; > > diff --git a/drivers/media/platform/vsp1/vsp1_wpf.c b/drivers/media/platform/vsp1/vsp1_wpf.c > index 9e8dbf99878b..2e8cc4195c31 100644 > --- a/drivers/media/platform/vsp1/vsp1_wpf.c > +++ b/drivers/media/platform/vsp1/vsp1_wpf.c > @@ -371,16 +371,19 @@ static void wpf_configure_partition(struct vsp1_entity *entity, > RWPF_PAD_SINK); > width = sink_format->width; > height = sink_format->height; > + offset = 0; > > /* > * Cropping. The partition algorithm can split the image into > * multiple slices. > */ > - if (vsp1_pipeline_partitioned(pipe)) > + if (vsp1_pipeline_partitioned(pipe)) { > width = pipe->partition->wpf.width; > + offset = pipe->partition->wpf.offset; > + } > > vsp1_wpf_write(wpf, dlb, VI6_WPF_HSZCLIP, VI6_WPF_SZCLIP_EN | > - (0 << VI6_WPF_SZCLIP_OFST_SHIFT) | > + (offset << VI6_WPF_SZCLIP_OFST_SHIFT) | > (width << VI6_WPF_SZCLIP_SIZE_SHIFT)); > vsp1_wpf_write(wpf, dlb, VI6_WPF_VSZCLIP, VI6_WPF_SZCLIP_EN | > (0 << VI6_WPF_SZCLIP_OFST_SHIFT) | > @@ -491,8 +494,15 @@ static void wpf_partition(struct vsp1_entity *entity, > struct vsp1_pipeline *pipe, > struct vsp1_partition *partition, > unsigned int partition_idx, > - struct vsp1_partition_window *window) > + struct vsp1_partition_window *window, > + bool forwards) > { > + if (forwards) { > + /* Only handle incoming cropping requirements. */ > + partition->wpf.offset = window->offset; > + return; > + } > + > partition->wpf = *window; > } > >
diff --git a/drivers/media/platform/vsp1/vsp1_entity.h b/drivers/media/platform/vsp1/vsp1_entity.h index 97acb7795cf1..772492877764 100644 --- a/drivers/media/platform/vsp1/vsp1_entity.h +++ b/drivers/media/platform/vsp1/vsp1_entity.h @@ -88,7 +88,7 @@ struct vsp1_entity_operations { unsigned int (*max_width)(struct vsp1_entity *, struct vsp1_pipeline *); void (*partition)(struct vsp1_entity *, struct vsp1_pipeline *, struct vsp1_partition *, unsigned int, - struct vsp1_partition_window *); + struct vsp1_partition_window *, bool); }; struct vsp1_entity { diff --git a/drivers/media/platform/vsp1/vsp1_pipe.c b/drivers/media/platform/vsp1/vsp1_pipe.c index f1bd21a01bcd..137ebe0ecad2 100644 --- a/drivers/media/platform/vsp1/vsp1_pipe.c +++ b/drivers/media/platform/vsp1/vsp1_pipe.c @@ -375,10 +375,32 @@ bool vsp1_pipeline_partitioned(struct vsp1_pipeline *pipe) /* * Propagate the partition calculations through the pipeline * - * Work backwards through the pipe, allowing each entity to update the partition - * parameters based on its configuration, and the entity connected to its - * source. Each entity must produce the partition required for the previous - * entity in the pipeline. + * Work backwards through the pipe, allowing each entity to update the + * partition parameters based on its configuration. Each entity must produce + * the partition window required for the previous entity in the pipeline + * to generate. This window can be passed through if no changes are necessary. + * + * Entities are processed in reverse order: + * DDDD = Destination pixels + * SSSS = Source pixels + * ==== = Intermediate pixels + * ____ = Disposable pixels + * + * WPF |DDDD| WPF determines it's required partition + * SRU |====| Interconnected entities pass through + * UDS(source) |<====>| UDS Source requests overlap + * UDS(sink) |<-|======|->| UDS Sink calculates input size + * RPF |__SSSSSSSS__| RPF provides extra pixels + * + * Then work forwards through the pipe allowing entities to communicate any + * clipping required based on any overlap and expansions they may have + * generated. + * + * RPF |__SSSSSSSS__| Partition window is propagated forwards + * UDS(sink) |============| + * UDS(source) |<====>| UDS Source reports overlap + * SRU |======| Interconnected entities are updated + * WPF |_DDDD_| WPF handles clipping */ void vsp1_pipeline_propagate_partition(struct vsp1_pipeline *pipe, struct vsp1_partition *partition, @@ -387,10 +409,18 @@ void vsp1_pipeline_propagate_partition(struct vsp1_pipeline *pipe, { struct vsp1_entity *entity; + /* Move backwards through the pipeline to propagate any expansion. */ list_for_each_entry_reverse(entity, &pipe->entities, list_pipe) { if (entity->ops->partition) entity->ops->partition(entity, pipe, partition, index, - window); + window, false); + } + + /* Move forwards through the pipeline and propagate any updates. */ + list_for_each_entry(entity, &pipe->entities, list_pipe) { + if (entity->ops->partition) + entity->ops->partition(entity, pipe, partition, index, + window, true); } } diff --git a/drivers/media/platform/vsp1/vsp1_pipe.h b/drivers/media/platform/vsp1/vsp1_pipe.h index dd8b2cdc6452..3e263a60f79b 100644 --- a/drivers/media/platform/vsp1/vsp1_pipe.h +++ b/drivers/media/platform/vsp1/vsp1_pipe.h @@ -58,10 +58,12 @@ enum vsp1_pipeline_state { * @left: horizontal coordinate of the partition start in pixels relative to the * left edge of the image * @width: partition width in pixels + * @offset: The number of pixels from the left edge of the window to clip */ struct vsp1_partition_window { unsigned int left; unsigned int width; + unsigned int offset; }; /* @@ -71,6 +73,8 @@ struct vsp1_partition_window { * @uds_source: The UDS output partition window configuration * @sru: The SRU partition window configuration * @wpf: The WPF partition window configuration + * @start_phase: The UDS start phase for this partition + * @end_phase: The UDS end phase for this partition */ struct vsp1_partition { struct vsp1_partition_window rpf; @@ -78,6 +82,8 @@ struct vsp1_partition { struct vsp1_partition_window uds_source; struct vsp1_partition_window sru; struct vsp1_partition_window wpf; + unsigned int start_phase; + unsigned int end_phase; }; /* diff --git a/drivers/media/platform/vsp1/vsp1_rpf.c b/drivers/media/platform/vsp1/vsp1_rpf.c index ef9bf5dd55a0..46d270644fe2 100644 --- a/drivers/media/platform/vsp1/vsp1_rpf.c +++ b/drivers/media/platform/vsp1/vsp1_rpf.c @@ -324,9 +324,13 @@ static void rpf_partition(struct vsp1_entity *entity, struct vsp1_pipeline *pipe, struct vsp1_partition *partition, unsigned int partition_idx, - struct vsp1_partition_window *window) + struct vsp1_partition_window *window, + bool forwards) { - partition->rpf = *window; + if (forwards) + *window = partition->rpf; + else + partition->rpf = *window; } static const struct vsp1_entity_operations rpf_entity_ops = { diff --git a/drivers/media/platform/vsp1/vsp1_sru.c b/drivers/media/platform/vsp1/vsp1_sru.c index b1617cb1f2b9..39f6e80a02a9 100644 --- a/drivers/media/platform/vsp1/vsp1_sru.c +++ b/drivers/media/platform/vsp1/vsp1_sru.c @@ -327,24 +327,57 @@ static void sru_partition(struct vsp1_entity *entity, struct vsp1_pipeline *pipe, struct vsp1_partition *partition, unsigned int partition_idx, - struct vsp1_partition_window *window) + struct vsp1_partition_window *window, + bool forwards) { struct vsp1_sru *sru = to_sru(&entity->subdev); struct v4l2_mbus_framefmt *input; struct v4l2_mbus_framefmt *output; + int scale_up; + + /* The partition->sru represents the SRU sink pad configuration. */ input = vsp1_entity_get_pad_format(&sru->entity, sru->entity.config, SRU_PAD_SINK); output = vsp1_entity_get_pad_format(&sru->entity, sru->entity.config, SRU_PAD_SOURCE); + scale_up = (input->width != output->width); + + if (forwards) { + /* Propagate the clipping offsets forwards. */ + window->offset += partition->sru.offset; + + if (scale_up) + window->offset *= 2; + + return; + } + /* Adapt if SRUx2 is enabled. */ - if (input->width != output->width) { + if (scale_up) { + /* Clipping offsets are not back-propagated. */ window->width /= 2; window->left /= 2; + + /* SRUx2 requires an extra pixel at the right edge. */ + window->width++; } + /* Store our adapted sink window. */ partition->sru = *window; + + /* Expand to the left edge. */ + if (window->left != 0) { + window->left--; + window->width++; + partition->sru.offset = 1; + } else { + partition->sru.offset = 0; + } + + /* Expand to the right edge. */ + window->width++; } static const struct vsp1_entity_operations sru_entity_ops = { diff --git a/drivers/media/platform/vsp1/vsp1_uds.c b/drivers/media/platform/vsp1/vsp1_uds.c index c71c24363d54..e2bd44740ad6 100644 --- a/drivers/media/platform/vsp1/vsp1_uds.c +++ b/drivers/media/platform/vsp1/vsp1_uds.c @@ -58,6 +58,85 @@ static unsigned int uds_multiplier(int ratio) return mp < 4 ? 1 : (mp < 8 ? 2 : 4); } +/* + * These functions all assume a starting phase of 0. + * i.e. the left edge of the image. + */ + +/* + * uds_residual - Return the residual phase cycle at the given position + * @pos: source destination position + * @ratio: scaling ratio in U4.12 fixed-point format + */ +static unsigned int uds_residual(unsigned int pos, unsigned int ratio) +{ + unsigned int mp = uds_multiplier(ratio); + unsigned int residual = (pos * ratio) % (mp * 4096); + + return residual; +} + +/* + * uds_left_src_pixel - Return the sink pixel location for the given source + * position + * + * @pos: source destination position + * @ratio: scaling ratio in U4.12 fixed-point format + */ +static unsigned int uds_left_src_pixel(unsigned int pos, unsigned int ratio) +{ + unsigned int mp = uds_multiplier(ratio); + unsigned int prefilter_out = (pos * ratio) / (mp * 4096); + unsigned int residual = (pos * ratio) % (mp * 4096); + + /* Todo: Section 32.3.7.5 : Procedure 3 + * + * A restriction is described where the destination position must + * satisfy the following conditions: + * + * (pos * ratio) must be a multiple of mp + * + * This is not yet guaranteed and thus this check is in place + * until the pull-back is correctly calculated for all ratio + * and position values. + */ + WARN_ONCE((mp == 2 && (residual & 0x01)) || + (mp == 4 && (residual & 0x03)), + "uds_left_pixel restrictions failed"); + + return mp * (prefilter_out + (residual ? 1 : 0)); +} + +/* + * uds_right_src_pixel - Return the sink pixel location for the given source + * position + * + * @pos: source destination position + * @ratio: scaling ratio in U4.12 fixed-point format + */ +static unsigned int uds_right_src_pixel(unsigned int pos, unsigned int ratio) +{ + unsigned int mp = uds_multiplier(ratio); + unsigned int prefilter_out = (pos * ratio) / (mp * 4096); + + return mp * (prefilter_out + 2) + (mp / 2); +} + +/* + * uds_start_phase - Return the sink pixel location for the given source + * position + * + * @pos: source destination position + * @ratio: scaling ratio in U4.12 fixed-point format + */ +static unsigned int uds_start_phase(unsigned int pos, unsigned int ratio) +{ + unsigned int mp = uds_multiplier(ratio); + unsigned int residual = (pos * ratio) % (mp * 4096); + + return residual ? (4096 - residual / mp) : 0; +} + /* * uds_output_size - Return the output size for an input size and scaling ratio * @input: input size in pixels @@ -270,6 +349,7 @@ static void uds_configure_stream(struct vsp1_entity *entity, const struct v4l2_mbus_framefmt *input; unsigned int hscale; unsigned int vscale; + bool manual_phase = vsp1_pipeline_partitioned(pipe); bool multitap; input = vsp1_entity_get_pad_format(&uds->entity, uds->entity.config, @@ -294,7 +374,8 @@ static void uds_configure_stream(struct vsp1_entity *entity, vsp1_uds_write(uds, dlb, VI6_UDS_CTRL, (uds->scale_alpha ? VI6_UDS_CTRL_AON : 0) | - (multitap ? VI6_UDS_CTRL_BC : 0)); + (multitap ? VI6_UDS_CTRL_BC : 0) | + (manual_phase ? VI6_UDS_CTRL_AMDSLH : 0)); vsp1_uds_write(uds, dlb, VI6_UDS_PASS_BWIDTH, (uds_passband_width(hscale) @@ -332,6 +413,12 @@ static void uds_configure_partition(struct vsp1_entity *entity, << VI6_UDS_CLIP_SIZE_HSIZE_SHIFT) | (output->height << VI6_UDS_CLIP_SIZE_VSIZE_SHIFT)); + + vsp1_uds_write(uds, dlb, VI6_UDS_HPHASE, + (partition->start_phase + << VI6_UDS_HPHASE_HSTP_SHIFT) | + (partition->end_phase + << VI6_UDS_HPHASE_HEDP_SHIFT)); } static unsigned int uds_max_width(struct vsp1_entity *entity, @@ -374,11 +461,23 @@ static void uds_partition(struct vsp1_entity *entity, struct vsp1_pipeline *pipe, struct vsp1_partition *partition, unsigned int partition_idx, - struct vsp1_partition_window *window) + struct vsp1_partition_window *window, + bool forwards) { struct vsp1_uds *uds = to_uds(&entity->subdev); const struct v4l2_mbus_framefmt *output; const struct v4l2_mbus_framefmt *input; + unsigned int hscale; + unsigned int right_sink; + unsigned int margin; + unsigned int left; + unsigned int right; + + /* For forwards propagation - simply pass on our output. */ + if (forwards) { + *window = partition->uds_source; + return; + } /* Initialise the partition state. */ partition->uds_sink = *window; @@ -389,11 +488,51 @@ static void uds_partition(struct vsp1_entity *entity, output = vsp1_entity_get_pad_format(&uds->entity, uds->entity.config, UDS_PAD_SOURCE); - partition->uds_sink.width = window->width * input->width - / output->width; - partition->uds_sink.left = window->left * input->width - / output->width; + hscale = uds_compute_ratio(input->width, output->width); + + /* + * Quantify the margin required for discontinuous overlap, and expand + * the window no further than the limits of the image. + */ + margin = hscale < 0x200 ? 32 : /* 8 < scale */ + hscale < 0x400 ? 16 : /* 4 < scale <= 8 */ + hscale < 0x800 ? 8 : /* 2 < scale <= 4 */ + 4; /* scale <= 2 */ + + left = max_t(int, 0, window->left - margin); + right = min_t(int, output->width - 1, + window->left + window->width - 1 + margin); + + /* + * Handle our output partition configuration. + * We can clip the pixels from the right edge, thus the + * uds_source.width does not include the right margin. + */ + partition->uds_source.left = left; + partition->uds_source.width = window->left - left + window->width; + + /* + * The UDS can not clip the left pixels so this value will be + * propagated forwards until it reaches the WPF. + */ + partition->uds_source.offset = window->left - left; + + /* Identify the input positions from the expanded partition. */ + partition->uds_sink.left = uds_left_src_pixel(left, hscale); + + right_sink = uds_right_src_pixel(right, hscale); + partition->uds_sink.width = right_sink - partition->uds_sink.left; + + /* + * We do not currently use VI6_UDS_CTRL_AMD from VI6_UDS_CTRL. + * In the event that we enable VI6_UDS_CTRL_AMD, we must set the end + * phase for the final partition to the phase_edge. + */ + partition->end_phase = 0; + partition->start_phase = uds_start_phase(partition->uds_source.left, + hscale); + /* Pass a copy of our sink down to the previous entity. */ *window = partition->uds_sink; } diff --git a/drivers/media/platform/vsp1/vsp1_video.c b/drivers/media/platform/vsp1/vsp1_video.c index d1ecc3d91290..3638a4e9bb19 100644 --- a/drivers/media/platform/vsp1/vsp1_video.c +++ b/drivers/media/platform/vsp1/vsp1_video.c @@ -221,6 +221,7 @@ static void vsp1_video_calculate_partition(struct vsp1_pipeline *pipe, /* Initialise the partition with sane starting conditions. */ window.left = index * div_size; window.width = div_size; + window.offset = 0; modulus = format->width % div_size; diff --git a/drivers/media/platform/vsp1/vsp1_wpf.c b/drivers/media/platform/vsp1/vsp1_wpf.c index 9e8dbf99878b..2e8cc4195c31 100644 --- a/drivers/media/platform/vsp1/vsp1_wpf.c +++ b/drivers/media/platform/vsp1/vsp1_wpf.c @@ -371,16 +371,19 @@ static void wpf_configure_partition(struct vsp1_entity *entity, RWPF_PAD_SINK); width = sink_format->width; height = sink_format->height; + offset = 0; /* * Cropping. The partition algorithm can split the image into * multiple slices. */ - if (vsp1_pipeline_partitioned(pipe)) + if (vsp1_pipeline_partitioned(pipe)) { width = pipe->partition->wpf.width; + offset = pipe->partition->wpf.offset; + } vsp1_wpf_write(wpf, dlb, VI6_WPF_HSZCLIP, VI6_WPF_SZCLIP_EN | - (0 << VI6_WPF_SZCLIP_OFST_SHIFT) | + (offset << VI6_WPF_SZCLIP_OFST_SHIFT) | (width << VI6_WPF_SZCLIP_SIZE_SHIFT)); vsp1_wpf_write(wpf, dlb, VI6_WPF_VSZCLIP, VI6_WPF_SZCLIP_EN | (0 << VI6_WPF_SZCLIP_OFST_SHIFT) | @@ -491,8 +494,15 @@ static void wpf_partition(struct vsp1_entity *entity, struct vsp1_pipeline *pipe, struct vsp1_partition *partition, unsigned int partition_idx, - struct vsp1_partition_window *window) + struct vsp1_partition_window *window, + bool forwards) { + if (forwards) { + /* Only handle incoming cropping requirements. */ + partition->wpf.offset = window->offset; + return; + } + partition->wpf = *window; }