vc4: scaling and YUV overlays for 4.6
Subsystems (3)
cover vc4: scaling and YUV overlays for 4.6
Here's the major series I have currently for 4.6: Overlay plane support. There's definitely more work to be done here, on better filter kernels at various sizes, choosing our scaling modes better, and being more aggressive on LBM allocation (right now I think we're barely allocating for YUV 1:1 at 1920x1080, but it could do more than that). However, I think this is a good base to build from and may unblock people trying to start building software stacks on the open driver.
Eric Anholt (10):
drm/vc4: Improve comments on vc4_plane_state members. drm/vc4: Add missing __iomem annotation to hw_dlist. drm/vc4: Move the plane clipping/scaling setup to a separate function. drm/vc4: Add a proper short-circut path for legacy cursor updates. drm/vc4: Make the CRTCs cooperate on allocating display lists. drm/vc4: Add more display planes to each CRTC.
drm/vc4: Fix which value is being used for source image size. drm/vc4: Add support for scaling of display planes. drm/vc4: Add support a few more RGB display plane formats. drm/vc4: Add support for YUV planes.
drivers/gpu/drm/vc4/vc4_crtc.c | 171 +++++++----- drivers/gpu/drm/vc4/vc4_drv.h | 12 +- drivers/gpu/drm/vc4/vc4_hvs.c | 98 +++++++ drivers/gpu/drm/vc4/vc4_kms.c | 9 + drivers/gpu/drm/vc4/vc4_plane.c | 598 ++++++++++++++++++++++++++++++++++++---- drivers/gpu/drm/vc4/vc4_regs.h | 102 ++++++- 6 files changed, 868 insertions(+), 122 deletions(-)
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 1/10 drm/vc4: Improve comments on vc4_plane_state members.
--- drivers/gpu/drm/vc4/vc4_plane.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
drivers/gpu/drm/vc4/vc4_plane.c +6 -3
@@ -26,16 +26,19 @@struct vc4_plane_state {struct drm_plane_state base; +/* System memory copy of the display list for this element, computed +* at atomic_check time. +*/ u32 *dlist; -u32 dlist_size;/* Number of dwords in allocated for the display list */ +u32 dlist_size;/* Number of dwords allocated for the display list */ u32 dlist_count;/* Number of used dwords in the display list. */ /* Offset in the dlist to pointer word 0. */ u32 pw0_offset;/* Offset where the plane's dlist was last stored in the -hardware at vc4_crtc_atomic_flush() time. -*/ +* hardware at vc4_crtc_atomic_flush() time. +*/ u32 *hw_dlist; };
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 2/10 drm/vc4: Add missing __iomem annotation to hw_dlist.
In reply to Eric AnholtThis is the pointer to the HVS device's memory where we stored the contents of *dlist.
--- drivers/gpu/drm/vc4/vc4_plane.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_plane.c +1 -1
@@ -39,7 +39,7 @@ struct vc4_plane_state {/* Offset where the plane's dlist was last stored in the * hardware at vc4_crtc_atomic_flush() time. */ -u32 *hw_dlist; +u32 __iomem *hw_dlist; }; static inline struct vc4_plane_state *
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 3/10 drm/vc4: Move the plane clipping/scaling setup to a separate function.
In reply to Eric AnholtAs we add actual scaling, this is going to get way more complicated.
--- drivers/gpu/drm/vc4/vc4_plane.c | 78 +++++++++++++++++++++++++++-------------- 1 file changed, 52 insertions(+), 26 deletions(-)
drivers/gpu/drm/vc4/vc4_plane.c +52 -26
@@ -40,6 +40,14 @@ struct vc4_plane_state {* hardware at vc4_crtc_atomic_flush() time. */ u32 __iomem *hw_dlist; + +/* Clipped coordinates of the plane on the display. */ +int crtc_x, crtc_y, crtc_w, crtc_h; + +/* Offset to start scanning out from the start of the plane's +* BO. +*/ +u32 offset; }; static inline struct vc4_plane_state *
@@ -151,22 +159,17 @@ static void vc4_dlist_write(struct vc4_plane_state *vc4_state, u32 val) vc4_state->dlist[vc4_state->dlist_count++] = val; } -/* Writes out a full display list for an active plane to the plane's -* private dlist state. -*/ -static int vc4_plane_mode_set (struct drm_plane *plane, -struct drm_plane_state *state) +static int vc4_plane_setup_clipping_and_scaling (struct drm_plane_state *state) {struct vc4_plane_state *vc4_state =to_vc4_plane_state (state);struct drm_framebuffer *fb = state->fb; -struct drm_gem_cma_object *bo =drm_fb_cma_get_gem_obj (fb,0 ); -u32 ctl0_offset = vc4_state->dlist_count; -const struct hvs_format *format =vc4_get_hvs_format (fb->pixel_format); -uint32_t offset = fb->offsets[0 ]; -int crtc_x = state->crtc_x; -int crtc_y = state->crtc_y; -int crtc_w = state->crtc_w; -int crtc_h = state->crtc_h; + + vc4_state->offset = fb->offsets[0 ]; + + vc4_state->crtc_x = state->crtc_x; + vc4_state->crtc_y = state->crtc_y; + vc4_state->crtc_w = state->crtc_w; + vc4_state->crtc_h = state->crtc_h;if (state->crtc_w <<16 != state->src_w || state->crtc_h <<16 != state->src_h) {
@@ -178,18 +181,41 @@ static int vc4_plane_mode_set(struct drm_plane *plane,return -EINVAL ; } -if (crtc_x <0 ) { - offset +=drm_format_plane_cpp (fb->pixel_format,0 ) * -crtc_x; - crtc_w += crtc_x; - crtc_x =0 ; +if (vc4_state->crtc_x <0 ) { + vc4_state->offset += (drm_format_plane_cpp (fb->pixel_format, +0 ) * + -vc4_state->crtc_x); + vc4_state->crtc_w += vc4_state->crtc_x; + vc4_state->crtc_x =0 ; } -if (crtc_y <0 ) { - offset += fb->pitches[0 ] * -crtc_y; - crtc_h += crtc_y; - crtc_y =0 ; +if (vc4_state->crtc_y <0 ) { + vc4_state->offset += fb->pitches[0 ] * -vc4_state->crtc_y; + vc4_state->crtc_h += vc4_state->crtc_y; + vc4_state->crtc_y =0 ; } +return 0 ; +} + + +/* Writes out a full display list for an active plane to the plane's +* private dlist state. +*/ +static int vc4_plane_mode_set (struct drm_plane *plane, +struct drm_plane_state *state) +{ +struct vc4_plane_state *vc4_state =to_vc4_plane_state (state); +struct drm_framebuffer *fb = state->fb; +struct drm_gem_cma_object *bo =drm_fb_cma_get_gem_obj (fb,0 ); +u32 ctl0_offset = vc4_state->dlist_count; +const struct hvs_format *format =vc4_get_hvs_format (fb->pixel_format); +int ret; + + ret =vc4_plane_setup_clipping_and_scaling (state); +if (ret) +return ret; + vc4_dlist_write(vc4_state, SCALER_CTL0_VALID | (format->pixel_order << SCALER_CTL0_ORDER_SHIFT) |
@@ -199,8 +225,8 @@ static int vc4_plane_mode_set(struct drm_plane *plane,/* Position Word 0: Image Positions and Alpha Value */ vc4_dlist_write (vc4_state,VC4_SET_FIELD (0xff ,SCALER_POS0_FIXED_ALPHA ) | -VC4_SET_FIELD (crtc_x,SCALER_POS0_START_X ) | -VC4_SET_FIELD (crtc_y,SCALER_POS0_START_Y )); +VC4_SET_FIELD (vc4_state->crtc_x,SCALER_POS0_START_X ) | +VC4_SET_FIELD (vc4_state->crtc_y,SCALER_POS0_START_Y ));/* Position Word 1: Scaled Image Dimensions. * Skipped due to SCALER_CTL0_UNITY scaling.
@@ -212,8 +238,8 @@ static int vc4_plane_mode_set(struct drm_plane *plane, SCALER_POS2_ALPHA_MODE_PIPELINE : SCALER_POS2_ALPHA_MODE_FIXED, SCALER_POS2_ALPHA_MODE) | -VC4_SET_FIELD (crtc_w,SCALER_POS2_WIDTH ) | - VC4_SET_FIELD(crtc_h, SCALER_POS2_HEIGHT)); +VC4_SET_FIELD (vc4_state->crtc_w,SCALER_POS2_WIDTH ) | + VC4_SET_FIELD(vc4_state->crtc_h, SCALER_POS2_HEIGHT));/* Position Word 3: Context. Written by the HVS. */ vc4_dlist_write (vc4_state,0xc0c0c0c0 );
@@ -221,7 +247,7 @@ static int vc4_plane_mode_set(struct drm_plane *plane, vc4_state->pw0_offset = vc4_state->dlist_count;/* Pointer Word 0: RGB / Y Pointer */ -vc4_dlist_write (vc4_state, bo->paddr + offset); +vc4_dlist_write (vc4_state, bo->paddr + vc4_state->offset);/* Pointer Context Word 0: Written by the HVS */ vc4_dlist_write (vc4_state,0xc0c0c0c0 );
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 4/10 drm/vc4: Add a proper short-circut path for legacy cursor updates.
In reply to Eric AnholtPreviously, on every modeset we would allocate new display list memory, recompute changed planes, write all of them to the new memory, and pointed scanout at the new list (which will latch approximately at the next line of scanout). We let drm_atomic_helper_wait_for_vblanks() decide whether we needed to wait for a vblank after a modeset before cleaning up the old state and letting the next modeset proceed, and on legacy cursor updates we wouldn't wait. If you moved the cursor fast enough, we could potentially wrap around the display list memory area and overwrite the existing display list while it was still being scanned out, resulting in the HVS scanning out garbage or just halting.
Instead of making cursor updates wait for scanout to move to the new display list area (which introduces significant cursor lag in X), we just rewrite our current display list.
--- drivers/gpu/drm/vc4/vc4_kms.c | 9 ++++ drivers/gpu/drm/vc4/vc4_plane.c | 93 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 95 insertions(+), 7 deletions(-)
drivers/gpu/drm/vc4/vc4_kms.c +9 -0
@@ -49,6 +49,15 @@ vc4_atomic_complete_commit(struct vc4_commit *c)drm_atomic_helper_commit_modeset_enables (dev, state); +/* Make sure that drm_atomic_helper_wait_for_vblanks() +* actually waits for vblank. If we're doing a full atomic +* modeset (as opposed to a vc4_update_plane() short circuit), +* then we need to wait for scanout to be done with our +* display lists before we free it and potentially reallocate +* and overwrite the dlist memory with a new modeset. +*/ + state->legacy_cursor_update = false; +drm_atomic_helper_wait_for_vblanks (dev, state);drm_atomic_helper_cleanup_planes (dev, state);
drivers/gpu/drm/vc4/vc4_plane.c +86 -7
136 lines not on this page · raw message
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 5/10 drm/vc4: Make the CRTCs cooperate on allocating display lists.
In reply to Eric AnholtSo far, we've only ever lit up one CRTC, so this has been fine. To extend to more displays or more planes, we need to make sure we don't run our display lists into each other.
--- drivers/gpu/drm/vc4/vc4_crtc.c | 115 +++++++++++++++++++++++------------------ drivers/gpu/drm/vc4/vc4_drv.h | 8 ++- drivers/gpu/drm/vc4/vc4_hvs.c | 13 +++++ 3 files changed, 84 insertions(+), 52 deletions(-)
drivers/gpu/drm/vc4/vc4_crtc.c +64 -51
@@ -49,22 +49,27 @@ struct vc4_crtc {/* Which HVS channel we're using for our CRTC. */ int channel; -/* Pointer to the actual hardware display list memory for the -* crtc. -*/ -u32 __iomem *dlist; - -u32 dlist_size;/* in dwords */ -struct drm_pending_vblank_event *event; }; +struct vc4_crtc_state { +struct drm_crtc_state base; +/* Dlist area for this CRTC configuration. */ +struct drm_mm_node mm; +}; +static inline struct vc4_crtc *to_vc4_crtc (struct drm_crtc *crtc) {return (struct vc4_crtc *)crtc; } +static inline struct vc4_crtc_state * +to_vc4_crtc_state (struct drm_crtc_state *crtc_state) +{ +return (struct vc4_crtc_state *)crtc_state; +} +struct vc4_crtc_data {/* Which channel of the HVS this pixelvalve sources from. */ int hvs_channel;
@@ -319,11 +324,13 @@ static void vc4_crtc_enable(struct drm_crtc *crtc)static int vc4_crtc_atomic_check (struct drm_crtc *crtc,struct drm_crtc_state *state) { +struct vc4_crtc_state *vc4_state =to_vc4_crtc_state (state);struct drm_device *dev = crtc->dev;struct vc4_dev *vc4 =to_vc4_dev (dev);struct drm_plane *plane; -struct vc4_crtc *vc4_crtc =to_vc4_crtc (crtc); +unsigned long flags;u32 dlist_count =0 ; +int ret;/* The pixelvalve can only feed one encoder (and encoders are * 1:1 with connectors.)
@@ -346,18 +353,12 @@ static int vc4_crtc_atomic_check(struct drm_crtc *crtc, dlist_count++;/* Account for SCALER_CTL0_END. */ -if (!vc4_crtc->dlist || dlist_count > vc4_crtc->dlist_size) { - vc4_crtc->dlist = ((u32 __iomem *)vc4->hvs->dlist + -HVS_BOOTLOADER_DLIST_END ); - vc4_crtc->dlist_size = ((SCALER_DLIST_SIZE >>2 ) - -HVS_BOOTLOADER_DLIST_END ); - -if (dlist_count > vc4_crtc->dlist_size) { -DRM_DEBUG_KMS ("dlist too large for CRTC (%d > %d).\n" , - dlist_count, vc4_crtc->dlist_size); -return -EINVAL ; - } - } +spin_lock_irqsave (&vc4->hvs->mm_lock, flags); + ret =drm_mm_insert_node (&vc4->hvs->dlist_mm, &vc4_state->mm, + dlist_count,1 ,0 ); +spin_unlock_irqrestore (&vc4->hvs->mm_lock, flags); +if (ret) +return ret;return 0 ; }
@@ -368,47 +369,29 @@ static void vc4_crtc_atomic_flush(struct drm_crtc *crtc,struct drm_device *dev = crtc->dev;struct vc4_dev *vc4 =to_vc4_dev (dev);struct vc4_crtc *vc4_crtc =to_vc4_crtc (crtc); +struct vc4_crtc_state *vc4_state =to_vc4_crtc_state (crtc->state);struct drm_plane *plane;bool debug_dump_regs = false; -u32 __iomem *dlist_next = vc4_crtc->dlist; +u32 __iomem *dlist_start = vc4->hvs->dlist + vc4_state->mm.start; +u32 __iomem *dlist_next = dlist_start;if (debug_dump_regs) {DRM_INFO ("CRTC %d HVS before:\n" ,drm_crtc_index (crtc));vc4_hvs_dump_state (dev); } -/* Copy all the active planes' dlist contents to the hardware dlist. -* -* XXX: If the new display list was large enough that it -* overlapped a currently-read display list, we need to do -* something like disable scanout before putting in the new -* list. For now, we're safe because we only have the two -* planes. -*/ +/* Copy all the active planes' dlist contents to the hardware dlist. */ drm_atomic_crtc_for_each_plane (plane, crtc) { dlist_next +=vc4_plane_write_dlist (plane, dlist_next); } -if (dlist_next == vc4_crtc->dlist) { -/* If no planes were enabled, use the SCALER_CTL0_END -* at the start of the display list memory (in the -* bootloader section). We'll rewrite that -* SCALER_CTL0_END, just in case, though. -*/ -writel (SCALER_CTL0_END , vc4->hvs->dlist); -HVS_WRITE (SCALER_DISPLISTX (vc4_crtc->channel),0 ); - }else { -writel (SCALER_CTL0_END , dlist_next); - dlist_next++; - -HVS_WRITE (SCALER_DISPLISTX (vc4_crtc->channel), - (u32 __iomem *)vc4_crtc->dlist - - (u32 __iomem *)vc4->hvs->dlist); - -/* Make the next display list start after ours. */ - vc4_crtc->dlist_size -= (dlist_next - vc4_crtc->dlist); - vc4_crtc->dlist = dlist_next; - } +writel (SCALER_CTL0_END , dlist_next); + dlist_next++; + +WARN_ON_ONCE (dlist_next - dlist_start != vc4_state->mm.size); + +HVS_WRITE (SCALER_DISPLISTX (vc4_crtc->channel), + vc4_state->mm.start);if (debug_dump_regs) {DRM_INFO ("CRTC %d HVS after:\n" ,drm_crtc_index (crtc));
@@ -573,6 +556,36 @@ static int vc4_page_flip(struct drm_crtc *crtc,return drm_atomic_helper_page_flip (crtc, fb, event, flags); } +static struct drm_crtc_state *vc4_crtc_duplicate_state (struct drm_crtc *crtc) +{ +struct vc4_crtc_state *vc4_state; + + vc4_state =kzalloc (sizeof (*vc4_state),GFP_KERNEL ); +if (!vc4_state) +return NULL ; + +__drm_atomic_helper_crtc_duplicate_state (crtc, &vc4_state->base); +return &vc4_state->base; +} + +static void vc4_crtc_destroy_state (struct drm_crtc *crtc, +struct drm_crtc_state *state) +{ +struct vc4_dev *vc4 =to_vc4_dev (crtc->dev); +struct vc4_crtc_state *vc4_state =to_vc4_crtc_state (state); + +if (vc4_state->mm.allocated) { +unsigned long flags; + +spin_lock_irqsave (&vc4->hvs->mm_lock, flags); +drm_mm_remove_node (&vc4_state->mm); +spin_unlock_irqrestore (&vc4->hvs->mm_lock, flags); + + } + +__drm_atomic_helper_crtc_destroy_state (crtc, state); +} +static const struct drm_crtc_funcs vc4_crtc_funcs = { .set_config = drm_atomic_helper_set_config, .destroy = vc4_crtc_destroy,
@@ -581,8 +594,8 @@ static const struct drm_crtc_funcs vc4_crtc_funcs = { .cursor_set = NULL, /* handled by drm_mode_cursor_universal */ .cursor_move = NULL, /* handled by drm_mode_cursor_universal */ .reset = drm_atomic_helper_crtc_reset, - .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, + .atomic_duplicate_state = vc4_crtc_duplicate_state, + .atomic_destroy_state = vc4_crtc_destroy_state, };static const struct drm_crtc_helper_funcs vc4_crtc_helper_funcs = {
drivers/gpu/drm/vc4/vc4_drv.h +7 -1
@@ -149,7 +149,13 @@ struct vc4_v3d {struct vc4_hvs {struct platform_device *pdev;void __iomem *regs; -void __iomem *dlist; +u32 __iomem *dlist; + +/* Memory manager for CRTCs to allocate space in the display +* list. Units are dwords. +*/ +struct drm_mm dlist_mm; +spinlock_t mm_lock; };struct vc4_plane {
drivers/gpu/drm/vc4/vc4_hvs.c +13 -0
@@ -119,6 +119,17 @@ static int vc4_hvs_bind(struct device *dev, struct device *master, void *data) hvs->dlist = hvs->regs +SCALER_DLIST_START ; +spin_lock_init (&hvs->mm_lock); + +/* Set up the HVS display list memory manager. We never +* overwrite the setup from the bootloader (just 128b out of +* our 16K), since we don't want to scramble the screen when +* transitioning from the firmware's boot setup to runtime. +*/ +drm_mm_init (&hvs->dlist_mm, +HVS_BOOTLOADER_DLIST_END , + (SCALER_DLIST_SIZE >>2 ) -HVS_BOOTLOADER_DLIST_END ); + vc4->hvs = hvs;return 0 ; }
@@ -129,6 +140,8 @@ static void vc4_hvs_unbind(struct device *dev, struct device *master,struct drm_device *drm =dev_get_drvdata (master);struct vc4_dev *vc4 = drm->dev_private; +drm_mm_takedown (&vc4->hvs->dlist_mm); + vc4->hvs =NULL ; }
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 6/10 drm/vc4: Add more display planes to each CRTC.
In reply to Eric AnholtPreviously we only did the primary and cursor plane, but overlay planes are useful and just require this setup to add, since all planes go into the HVS display list in the same way.
--- drivers/gpu/drm/vc4/vc4_crtc.c | 56 ++++++++++++++++++++++++++++++------------ 1 file changed, 40 insertions(+), 16 deletions(-)
drivers/gpu/drm/vc4/vc4_crtc.c +40 -16
@@ -677,9 +677,9 @@ static int vc4_crtc_bind(struct device *dev, struct device *master, void *data)struct vc4_dev *vc4 =to_vc4_dev (drm);struct vc4_crtc *vc4_crtc;struct drm_crtc *crtc; -struct drm_plane *primary_plane, *cursor_plane; +struct drm_plane *primary_plane, *cursor_plane, *destroy_plane, *temp;const struct of_device_id *match; -int ret; +int ret, i; vc4_crtc =devm_kzalloc (dev,sizeof (*vc4_crtc),GFP_KERNEL );if (!vc4_crtc)
@@ -708,27 +708,49 @@ static int vc4_crtc_bind(struct device *dev, struct device *master, void *data) goto err; } - cursor_plane =vc4_plane_init (drm,DRM_PLANE_TYPE_CURSOR ); -if (IS_ERR (cursor_plane)) { -dev_err (dev,"failed to construct cursor plane\n" ); - ret =PTR_ERR (cursor_plane); - goto err_primary; - } - -drm_crtc_init_with_planes (drm, crtc, primary_plane, cursor_plane, +drm_crtc_init_with_planes (drm, crtc, primary_plane,NULL , &vc4_crtc_funcs,NULL );drm_crtc_helper_add (crtc, &vc4_crtc_helper_funcs); primary_plane->crtc = crtc; - cursor_plane->crtc = crtc; vc4->crtc[drm_crtc_index (crtc)] = vc4_crtc; vc4_crtc->channel = vc4_crtc->data->hvs_channel; +/* Set up some arbitrary number of planes. We're not limited +* by a set number of physical registers, just the space in +* the HVS (16k) and how small an plane can be (28 bytes). +* However, each plane we set up takes up some memory, and +* increases the cost of looping over planes, which atomic +* modesetting does quite a bit. As a result, we pick a +* modest number of planes to expose, that should hopefully +* still cover any sane usecase. +*/ +for (i =0 ; i <8 ; i++) { +struct drm_plane *plane = +vc4_plane_init (drm,DRM_PLANE_TYPE_OVERLAY ); + +if (IS_ERR (plane)) +continue ; + + plane->possible_crtcs =1 <<drm_crtc_index (crtc); + } + +/* Set up the legacy cursor after overlay initialization, +* since we overlay planes on the CRTC in the order they were +* initialized. +*/ + cursor_plane =vc4_plane_init (drm,DRM_PLANE_TYPE_CURSOR ); +if (!IS_ERR (cursor_plane)) { + cursor_plane->possible_crtcs =1 <<drm_crtc_index (crtc); + cursor_plane->crtc = crtc; + crtc->cursor = cursor_plane; + } +CRTC_WRITE (PV_INTEN ,0 );CRTC_WRITE (PV_INTSTAT ,PV_INT_VFP_START ); ret =devm_request_irq (dev,platform_get_irq (pdev,0 ), vc4_crtc_irq_handler,0 ,"vc4 crtc" , vc4_crtc);if (ret) - goto err_cursor; + goto err_destroy_planes;vc4_set_crtc_possible_masks (drm, crtc);
@@ -736,10 +758,12 @@ static int vc4_crtc_bind(struct device *dev, struct device *master, void *data)return 0 ; -err_cursor: - cursor_plane->funcs->destroy (cursor_plane); -err_primary: - primary_plane->funcs->destroy (primary_plane); +err_destroy_planes: +list_for_each_entry_safe (destroy_plane, temp, + &drm->mode_config.plane_list, head) { +if (destroy_plane->possible_crtcs ==1 <<drm_crtc_index (crtc)) + destroy_plane->funcs->destroy (destroy_plane); + } err:return ret; }
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 7/10 drm/vc4: Fix which value is being used for source image size.
In reply to Eric AnholtThis doesn't matter yet since we only allow 1:1 scaling, but the comment clearly says we should be using the source size.
--- drivers/gpu/drm/vc4/vc4_plane.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)
drivers/gpu/drm/vc4/vc4_plane.c +14 -9
@@ -47,6 +47,8 @@ struct vc4_plane_state {/* Clipped coordinates of the plane on the display. */ int crtc_x, crtc_y, crtc_w, crtc_h; +/* Clipped size of the area scanned from in the FB. */ +u32 src_w, src_h;/* Offset to start scanning out from the start of the plane's * BO.
@@ -170,11 +172,6 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state) vc4_state->offset = fb->offsets[0 ]; - vc4_state->crtc_x = state->crtc_x; - vc4_state->crtc_y = state->crtc_y; - vc4_state->crtc_w = state->crtc_w; - vc4_state->crtc_h = state->crtc_h; -if (state->crtc_w <<16 != state->src_w || state->crtc_h <<16 != state->src_h) {/* We don't support scaling yet, which involves
@@ -185,17 +182,25 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)return -EINVAL ; } + vc4_state->src_w = state->src_w >>16 ; + vc4_state->src_h = state->src_h >>16 ; + + vc4_state->crtc_x = state->crtc_x; + vc4_state->crtc_y = state->crtc_y; + vc4_state->crtc_w = state->crtc_w; + vc4_state->crtc_h = state->crtc_h; +if (vc4_state->crtc_x <0 ) { vc4_state->offset += (drm_format_plane_cpp (fb->pixel_format,0 ) * -vc4_state->crtc_x); - vc4_state->crtc_w += vc4_state->crtc_x; + vc4_state->src_w += vc4_state->crtc_x; vc4_state->crtc_x =0 ; }if (vc4_state->crtc_y <0 ) { vc4_state->offset += fb->pitches[0 ] * -vc4_state->crtc_y; - vc4_state->crtc_h += vc4_state->crtc_y; + vc4_state->src_h += vc4_state->crtc_y; vc4_state->crtc_y =0 ; }
@@ -244,8 +249,8 @@ static int vc4_plane_mode_set(struct drm_plane *plane, SCALER_POS2_ALPHA_MODE_PIPELINE : SCALER_POS2_ALPHA_MODE_FIXED, SCALER_POS2_ALPHA_MODE) | -VC4_SET_FIELD (vc4_state->crtc_w,SCALER_POS2_WIDTH ) | - VC4_SET_FIELD(vc4_state->crtc_h, SCALER_POS2_HEIGHT)); +VC4_SET_FIELD (vc4_state->src_w,SCALER_POS2_WIDTH ) | + VC4_SET_FIELD(vc4_state->src_h, SCALER_POS2_HEIGHT));/* Position Word 3: Context. Written by the HVS. */ vc4_dlist_write (vc4_state,0xc0c0c0c0 );
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 8/10 drm/vc4: Add support for scaling of display planes.
In reply to Eric AnholtThis implements a simple policy for choosing scaling modes (trapezoidal for decimation, PPF for magnification), and a single PPF filter (Mitchell/Netravali's recommendation).
--- drivers/gpu/drm/vc4/vc4_drv.h | 4 + drivers/gpu/drm/vc4/vc4_hvs.c | 85 ++++++++++++++ drivers/gpu/drm/vc4/vc4_plane.c | 253 +++++++++++++++++++++++++++++++++++++--- drivers/gpu/drm/vc4/vc4_regs.h | 46 ++++++++ 4 files changed, 375 insertions(+), 13 deletions(-)
drivers/gpu/drm/vc4/vc4_drv.h +4 -0
@@ -155,7 +155,11 @@ struct vc4_hvs {* list. Units are dwords. */ struct drm_mm dlist_mm; +/* Memory manager for the LBM memory used by HVS scaling. */ +struct drm_mm lbm_mm;spinlock_t mm_lock; + +struct drm_mm_node mitchell_netravali_filter; };struct vc4_plane {
drivers/gpu/drm/vc4/vc4_hvs.c +85 -0
110 lines not on this page · raw message
drivers/gpu/drm/vc4/vc4_plane.c +240 -13
351 lines not on this page · raw message
drivers/gpu/drm/vc4/vc4_regs.h +46 -0
64 lines not on this page · raw message
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 9/10 drm/vc4: Add support a few more RGB display plane formats.
In reply to Eric AnholtThese were all touch-tested with modetest.
--- drivers/gpu/drm/vc4/vc4_plane.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
drivers/gpu/drm/vc4/vc4_plane.c +16 -0
@@ -88,6 +88,22 @@ static const struct hvs_format { .drm = DRM_FORMAT_ARGB8888, .hvs = HVS_PIXEL_FORMAT_RGBA8888, .pixel_order = HVS_PIXEL_ORDER_ABGR, .has_alpha = true, }, + { + .drm = DRM_FORMAT_RGB565, .hvs = HVS_PIXEL_FORMAT_RGB565, + .pixel_order = HVS_PIXEL_ORDER_XRGB, .has_alpha = false, + }, + { + .drm = DRM_FORMAT_BGR565, .hvs = HVS_PIXEL_FORMAT_RGB565, + .pixel_order = HVS_PIXEL_ORDER_XBGR, .has_alpha = false, + }, + { + .drm = DRM_FORMAT_ARGB1555, .hvs = HVS_PIXEL_FORMAT_RGBA5551, + .pixel_order = HVS_PIXEL_ORDER_ABGR, .has_alpha = true, + }, + { + .drm = DRM_FORMAT_XRGB1555, .hvs = HVS_PIXEL_FORMAT_RGBA5551, + .pixel_order = HVS_PIXEL_ORDER_ABGR, .has_alpha = false, + }, }; static const struct hvs_format *vc4_get_hvs_format(u32 drm_format)
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 10/10 drm/vc4: Add support for YUV planes.
In reply to Eric AnholtThis supports 420 and 422 subsampling with 2 or 3 planes, tested with modetest. It doesn't set up chroma subsampling position (which it appears KMS doesn't deal with yet).
The LBM memory is overallocated in many cases, but apparently the docs aren't quite correct and I'll probably need to look at the hardware source to really figure it out.
--- drivers/gpu/drm/vc4/vc4_plane.c | 252 +++++++++++++++++++++++++++++++--------- drivers/gpu/drm/vc4/vc4_regs.h | 56 ++++++++- 2 files changed, 249 insertions(+), 59 deletions(-)
drivers/gpu/drm/vc4/vc4_plane.c +194 -58
@@ -54,15 +54,19 @@ struct vc4_plane_state {/* Clipped coordinates of the plane on the display. */ int crtc_x, crtc_y, crtc_w, crtc_h;/* Clipped area being scanned from in the FB. */ -u32 src_x, src_y, src_w, src_h; +u32 src_x, src_y; -enum vc4_scaling_mode x_scaling, y_scaling; +u32 src_w[2 ], src_h[2 ]; + +/* Scaling selection for the RGB/Y plane and the Cb/Cr planes. */ +enum vc4_scaling_mode x_scaling[2 ], y_scaling[2 ];bool is_unity; +bool is_yuv;/* Offset to start scanning out from the start of the plane's * BO. */ -u32 offset; +u32 offsets[3 ];/* Our allocation in LBM for temporary storage during scaling. */ struct drm_mm_node lbm;
@@ -79,6 +83,7 @@ static const struct hvs_format {u32 hvs;/* HVS_FORMAT_* */ u32 pixel_order;bool has_alpha; +bool flip_cbcr; } hvs_formats[] = { { .drm = DRM_FORMAT_XRGB8888, .hvs = HVS_PIXEL_FORMAT_RGBA8888,
@@ -104,6 +109,32 @@ static const struct hvs_format { .drm = DRM_FORMAT_XRGB1555, .hvs = HVS_PIXEL_FORMAT_RGBA5551, .pixel_order = HVS_PIXEL_ORDER_ABGR, .has_alpha = false, }, + { + .drm = DRM_FORMAT_YUV422, + .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV422_3PLANE, + }, + { + .drm = DRM_FORMAT_YVU422, + .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV422_3PLANE, + .flip_cbcr = true, + }, + { + .drm = DRM_FORMAT_YUV420, + .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV420_3PLANE, + }, + { + .drm = DRM_FORMAT_YVU420, + .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV420_3PLANE, + .flip_cbcr = true, + }, + { + .drm = DRM_FORMAT_NV12, + .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV420_2PLANE, + }, + { + .drm = DRM_FORMAT_NV16, + .hvs = HVS_PIXEL_FORMAT_YCBCR_YUV422_2PLANE, + }, }; static const struct hvs_format *vc4_get_hvs_format(u32 drm_format)
@@ -219,11 +250,11 @@ static void vc4_dlist_write(struct vc4_plane_state *vc4_state, u32 val)* * This is a replication of a table from the spec. */ -static u32 vc4_get_scl_field (struct drm_plane_state *state) +static u32 vc4_get_scl_field (struct drm_plane_state *state,int plane) {struct vc4_plane_state *vc4_state =to_vc4_plane_state (state); -switch (vc4_state->x_scaling <<2 | vc4_state->y_scaling) { +switch (vc4_state->x_scaling[plane] <<2 | vc4_state->y_scaling[plane]) {case VC4_SCALING_PPF <<2 |VC4_SCALING_PPF :return SCALER_CTL0_SCL_H_PPF_V_PPF ;case VC4_SCALING_TPZ <<2 |VC4_SCALING_PPF :
@@ -254,9 +285,16 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)struct drm_plane *plane = state->plane;struct vc4_plane_state *vc4_state =to_vc4_plane_state (state);struct drm_framebuffer *fb = state->fb; +struct drm_gem_cma_object *bo =drm_fb_cma_get_gem_obj (fb,0 );u32 subpixel_src_mask = (1 <<16 ) -1 ; +u32 format = fb->pixel_format; +int num_planes =drm_format_num_planes (format); +u32 h_subsample =1 ; +u32 v_subsample =1 ; +int i; - vc4_state->offset = fb->offsets[0 ]; +for (i =0 ; i < num_planes; i++) + vc4_state->offsets[i] = bo->paddr + fb->offsets[i];/* We don't support subpixel source positioning for scaling. */ if ((state->src_x & subpixel_src_mask) ||
@@ -268,20 +306,48 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state) vc4_state->src_x = state->src_x >>16 ; vc4_state->src_y = state->src_y >>16 ; - vc4_state->src_w = state->src_w >>16 ; - vc4_state->src_h = state->src_h >>16 ; + vc4_state->src_w[0 ] = state->src_w >>16 ; + vc4_state->src_h[0 ] = state->src_h >>16 ; vc4_state->crtc_x = state->crtc_x; vc4_state->crtc_y = state->crtc_y; vc4_state->crtc_w = state->crtc_w; vc4_state->crtc_h = state->crtc_h; - vc4_state->x_scaling =vc4_get_scaling_mode (vc4_state->src_w, - vc4_state->crtc_w); - vc4_state->y_scaling =vc4_get_scaling_mode (vc4_state->src_h, - vc4_state->crtc_h); - vc4_state->is_unity = (vc4_state->x_scaling ==VC4_SCALING_NONE && - vc4_state->y_scaling ==VC4_SCALING_NONE ); + vc4_state->x_scaling[0 ] =vc4_get_scaling_mode (vc4_state->src_w[0 ], + vc4_state->crtc_w); + vc4_state->y_scaling[0 ] =vc4_get_scaling_mode (vc4_state->src_h[0 ], + vc4_state->crtc_h); + +if (num_planes >1 ) { + vc4_state->is_yuv = true; + + h_subsample =drm_format_horz_chroma_subsampling (format); + v_subsample =drm_format_vert_chroma_subsampling (format); + vc4_state->src_w[1 ] = vc4_state->src_w[0 ] / h_subsample; + vc4_state->src_h[1 ] = vc4_state->src_h[0 ] / v_subsample; + + vc4_state->x_scaling[1 ] = +vc4_get_scaling_mode (vc4_state->src_w[1 ], + vc4_state->crtc_w); + vc4_state->y_scaling[1 ] = +vc4_get_scaling_mode (vc4_state->src_h[1 ], + vc4_state->crtc_h); + +/* YUV conversion requires that scaling be enabled, +* even on a plane that's otherwise 1:1. Choose TPZ +* for simplicity. +*/ +if (vc4_state->x_scaling[0 ] ==VC4_SCALING_NONE ) + vc4_state->x_scaling[0 ] =VC4_SCALING_TPZ ; +if (vc4_state->y_scaling[0 ] ==VC4_SCALING_NONE ) + vc4_state->y_scaling[0 ] =VC4_SCALING_TPZ ; + } + + vc4_state->is_unity = (vc4_state->x_scaling[0 ] ==VC4_SCALING_NONE && + vc4_state->y_scaling[0 ] ==VC4_SCALING_NONE && + vc4_state->x_scaling[1 ] ==VC4_SCALING_NONE && + vc4_state->y_scaling[1 ] ==VC4_SCALING_NONE );/* No configuring scaling on the cursor plane, since it gets non-vblank-synced updates, and scaling requires requires
@@ -294,16 +360,27 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)* support negative y, and negative x wastes bandwidth. */ if (vc4_state->crtc_x <0 ) { - vc4_state->offset += (drm_format_plane_cpp (fb->pixel_format, -0 ) * - -vc4_state->crtc_x); - vc4_state->src_w += vc4_state->crtc_x; +for (i =0 ; i < num_planes; i++) { +u32 cpp =drm_format_plane_cpp (fb->pixel_format, i); +u32 subs = ((i ==0 ) ?1 : h_subsample); + + vc4_state->offsets[i] += (cpp * + (-vc4_state->crtc_x) / subs); + } + vc4_state->src_w[0 ] += vc4_state->crtc_x; + vc4_state->src_w[1 ] += vc4_state->crtc_x / h_subsample; vc4_state->crtc_x =0 ; }if (vc4_state->crtc_y <0 ) { - vc4_state->offset += fb->pitches[0 ] * -vc4_state->crtc_y; - vc4_state->src_h += vc4_state->crtc_y; +for (i =0 ; i < num_planes; i++) { +u32 subs = ((i ==0 ) ?1 : v_subsample); + + vc4_state->offsets[i] += (fb->pitches[i] * + (-vc4_state->crtc_y) / subs); + } + vc4_state->src_h[0 ] += vc4_state->crtc_y; + vc4_state->src_h[1 ] += vc4_state->crtc_y / v_subsample; vc4_state->crtc_y =0 ; }
@@ -344,15 +421,23 @@ static u32 vc4_lbm_size(struct drm_plane_state *state)/* This is the worst case number. One of the two sizes will * be used depending on the scaling configuration. */ -u32 pix_per_line =max (vc4_state->src_w, (u32 )vc4_state->crtc_w); +u32 pix_per_line =max (vc4_state->src_w[0 ], (u32 )vc4_state->crtc_w);u32 lbm; -if (vc4_state->is_unity) -return 0 ; -else if (vc4_state->y_scaling ==VC4_SCALING_TPZ ) - lbm = pix_per_line *8 ; -else { -/* In special cases, this multiplier might be 12. */ +if (!vc4_state->is_yuv) { +if (vc4_state->is_unity) +return 0 ; +else if (vc4_state->y_scaling[0 ] ==VC4_SCALING_TPZ ) + lbm = pix_per_line *8 ; +else { +/* In special cases, this multiplier might be 12. */ + lbm = pix_per_line *16 ; + } + }else { +/* There are cases for this going down to a multiplier +* of 2, but according to the firmware source, the +* table in the docs is somewhat wrong. +*/ lbm = pix_per_line *16 ; }
@@ -361,33 +446,34 @@ static u32 vc4_lbm_size(struct drm_plane_state *state)return lbm; } -static void vc4_write_scaling_parameters (struct drm_plane_state *state) +static void vc4_write_scaling_parameters (struct drm_plane_state *state, +int channel) {struct vc4_plane_state *vc4_state =to_vc4_plane_state (state);/* Ch0 H-PPF Word 0: Scaling Parameters */ -if (vc4_state->x_scaling ==VC4_SCALING_PPF ) { +if (vc4_state->x_scaling[channel] ==VC4_SCALING_PPF ) {vc4_write_ppf (vc4_state, - vc4_state->src_w, vc4_state->crtc_w); + vc4_state->src_w[channel], vc4_state->crtc_w); }/* Ch0 V-PPF Words 0-1: Scaling Parameters, Context */ -if (vc4_state->y_scaling ==VC4_SCALING_PPF ) { +if (vc4_state->y_scaling[channel] ==VC4_SCALING_PPF ) {vc4_write_ppf (vc4_state, - vc4_state->src_h, vc4_state->crtc_h); + vc4_state->src_h[channel], vc4_state->crtc_h);vc4_dlist_write (vc4_state,0xc0c0c0c0 ); }/* Ch0 H-TPZ Words 0-1: Scaling Parameters, Recip */ -if (vc4_state->x_scaling ==VC4_SCALING_TPZ ) { +if (vc4_state->x_scaling[channel] ==VC4_SCALING_TPZ ) {vc4_write_tpz (vc4_state, - vc4_state->src_w, vc4_state->crtc_w); + vc4_state->src_w[channel], vc4_state->crtc_w); }/* Ch0 V-TPZ Words 0-2: Scaling Parameters, Recip, Context */ -if (vc4_state->y_scaling ==VC4_SCALING_TPZ ) { +if (vc4_state->y_scaling[channel] ==VC4_SCALING_TPZ ) {vc4_write_tpz (vc4_state, - vc4_state->src_h, vc4_state->crtc_h); + vc4_state->src_h[channel], vc4_state->crtc_h);vc4_dlist_write (vc4_state,0xc0c0c0c0 ); } }
@@ -401,13 +487,13 @@ static int vc4_plane_mode_set(struct drm_plane *plane,struct vc4_dev *vc4 =to_vc4_dev (plane->dev);struct vc4_plane_state *vc4_state =to_vc4_plane_state (state);struct drm_framebuffer *fb = state->fb; -struct drm_gem_cma_object *bo =drm_fb_cma_get_gem_obj (fb,0 );u32 ctl0_offset = vc4_state->dlist_count;const struct hvs_format *format =vc4_get_hvs_format (fb->pixel_format); -u32 scl; +int num_planes =drm_format_num_planes (format->drm); +u32 scl0, scl1;u32 lbm_size;unsigned long irqflags; -int ret; +int ret, i; ret =vc4_plane_setup_clipping_and_scaling (state);if (ret)
@@ -432,7 +518,19 @@ static int vc4_plane_mode_set(struct drm_plane *plane,if (ret)return ret; - scl =vc4_get_scl_field (state); +/* SCL1 is used for Cb/Cr scaling of planar formats. For RGB +* and 4:4:4, scl1 should be set to scl0 so both channels of +* the scaler do the same thing. For YUV, the Y plane needs +* to be put in channel 1 and Cb/Cr in channel 0, so we swap +* the scl fields here. +*/ +if (num_planes ==1 ) { + scl0 =vc4_get_scl_field (state,1 ); + scl1 = scl0; + }else { + scl0 =vc4_get_scl_field (state,1 ); + scl1 =vc4_get_scl_field (state,0 ); + }/* Control word */ vc4_dlist_write(vc4_state,
@@ -440,8 +538,8 @@ static int vc4_plane_mode_set(struct drm_plane *plane, (format->pixel_order <<SCALER_CTL0_ORDER_SHIFT ) | (format->hvs <<SCALER_CTL0_PIXEL_FORMAT_SHIFT ) | (vc4_state->is_unity ?SCALER_CTL0_UNITY :0 ) | -VC4_SET_FIELD (scl,SCALER_CTL0_SCL0 ) | - VC4_SET_FIELD(scl, SCALER_CTL0_SCL1)); +VC4_SET_FIELD (scl0,SCALER_CTL0_SCL0 ) | + VC4_SET_FIELD(scl1, SCALER_CTL0_SCL1));/* Position Word 0: Image Positions and Alpha Value */ vc4_state->pos0_offset = vc4_state->dlist_count;
@@ -466,35 +564,68 @@ static int vc4_plane_mode_set(struct drm_plane *plane, SCALER_POS2_ALPHA_MODE_PIPELINE : SCALER_POS2_ALPHA_MODE_FIXED, SCALER_POS2_ALPHA_MODE) | -VC4_SET_FIELD (vc4_state->src_w,SCALER_POS2_WIDTH ) | - VC4_SET_FIELD(vc4_state->src_h, SCALER_POS2_HEIGHT)); +VC4_SET_FIELD (vc4_state->src_w[0 ],SCALER_POS2_WIDTH ) | + VC4_SET_FIELD(vc4_state->src_h[0], SCALER_POS2_HEIGHT));/* Position Word 3: Context. Written by the HVS. */ vc4_dlist_write (vc4_state,0xc0c0c0c0 ); -/* Pointer Word 0: RGB / Y Pointer */ + +/* Pointer Word 0/1/2: RGB / Y / Cb / Cr Pointers +* +* The pointers may be any byte address. +*/ vc4_state->ptr0_offset = vc4_state->dlist_count; -vc4_dlist_write (vc4_state, bo->paddr + vc4_state->offset); +if (!format->flip_cbcr) { +for (i =0 ; i < num_planes; i++) +vc4_dlist_write (vc4_state, vc4_state->offsets[i]); + }else { +WARN_ON_ONCE (num_planes !=3 ); +vc4_dlist_write (vc4_state, vc4_state->offsets[0 ]); +vc4_dlist_write (vc4_state, vc4_state->offsets[2 ]); +vc4_dlist_write (vc4_state, vc4_state->offsets[1 ]); + } -/* Pointer Context Word 0: Written by the HVS */ -vc4_dlist_write (vc4_state,0xc0c0c0c0 ); +/* Pointer Context Word 0/1/2: Written by the HVS */ +for (i =0 ; i < num_planes; i++) +vc4_dlist_write (vc4_state,0xc0c0c0c0 ); -/* Pitch word 0: Pointer 0 Pitch */ -vc4_dlist_write (vc4_state, -VC4_SET_FIELD (fb->pitches[0 ],SCALER_SRC_PITCH )); +/* Pitch word 0/1/2 */ +for (i =0 ; i < num_planes; i++) { +vc4_dlist_write (vc4_state, +VC4_SET_FIELD (fb->pitches[i],SCALER_SRC_PITCH )); + } + +/* Colorspace conversion words */ +if (vc4_state->is_yuv) { +vc4_dlist_write (vc4_state,SCALER_CSC0_ITR_R_601_5 ); +vc4_dlist_write (vc4_state,SCALER_CSC1_ITR_R_601_5 ); +vc4_dlist_write (vc4_state,SCALER_CSC2_ITR_R_601_5 ); + }if (!vc4_state->is_unity) {/* LBM Base Address. */ -if (vc4_state->y_scaling !=VC4_SCALING_NONE ) +if (vc4_state->y_scaling[0 ] !=VC4_SCALING_NONE || + vc4_state->y_scaling[1 ] !=VC4_SCALING_NONE ) {vc4_dlist_write (vc4_state, vc4_state->lbm.start); + } -vc4_write_scaling_parameters (state); +if (num_planes >1 ) { +/* Emit Cb/Cr as channel 0 and Y as channel +* 1. This matches how we set up scl0/scl1 +* above. +*/ +vc4_write_scaling_parameters (state,1 ); + } +vc4_write_scaling_parameters (state,0 );/* If any PPF setup was done, then all the kernel * pointers get uploaded. */ -if (vc4_state->x_scaling ==VC4_SCALING_PPF || - vc4_state->y_scaling ==VC4_SCALING_PPF ) { +if (vc4_state->x_scaling[0 ] ==VC4_SCALING_PPF || + vc4_state->y_scaling[0 ] ==VC4_SCALING_PPF || + vc4_state->x_scaling[1 ] ==VC4_SCALING_PPF || + vc4_state->y_scaling[1 ] ==VC4_SCALING_PPF ) {u32 kernel =VC4_SET_FIELD (vc4->hvs->mitchell_netravali_filter.start,SCALER_PPF_KERNEL_OFFSET );
@@ -697,6 +828,7 @@ struct drm_plane *vc4_plane_init(struct drm_device *dev,struct drm_plane *plane =NULL ;struct vc4_plane *vc4_plane;u32 formats[ARRAY_SIZE (hvs_formats)]; +u32 num_formats =0 ;int ret =0 ;unsigned i;
@@ -707,12 +839,16 @@ struct drm_plane *vc4_plane_init(struct drm_device *dev, goto fail; } -for (i =0 ; i <ARRAY_SIZE (hvs_formats); i++) - formats[i] = hvs_formats[i].drm; +for (i =0 ; i <ARRAY_SIZE (hvs_formats); i++) { +if (type !=DRM_PLANE_TYPE_CURSOR || + hvs_formats[i].hvs <HVS_PIXEL_FORMAT_YCBCR_YUV420_3PLANE ) { + formats[num_formats++] = hvs_formats[i].drm; + } + } plane = &vc4_plane->base; ret =drm_universal_plane_init (dev, plane,0xff , &vc4_plane_funcs, - formats,ARRAY_SIZE (formats), + formats, num_formats, type,NULL );drm_plane_helper_add (plane, &vc4_plane_helper_funcs);
drivers/gpu/drm/vc4/vc4_regs.h +55 -1
68 lines not on this page · raw message
Signature · 6 lines
2.7.0 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel