From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga02.intel.com ([134.134.136.20]:11961 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755172AbeDZN1v (ORCPT ); Thu, 26 Apr 2018 09:27:51 -0400 Date: Thu, 26 Apr 2018 16:27:44 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Laurent Pinchart Cc: dri-devel@lists.freedesktop.org, Thomas Hellstrom , Joonas Lahtinen , Russell King , linux-renesas-soc@vger.kernel.org, Ben Skeggs , Rodrigo Vivi , Alexandru Gheorghe , linux-media@vger.kernel.org Subject: Re: [PATCH/RFC 1/4] drm: Add colorkey properties Message-ID: <20180426132744.GI23723@intel.com> References: <20171217001724.1348-1-laurent.pinchart+renesas@ideasonboard.com> <20171217001724.1348-2-laurent.pinchart+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20171217001724.1348-2-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-media-owner@vger.kernel.org List-ID: On Sun, Dec 17, 2017 at 02:17:21AM +0200, Laurent Pinchart wrote: > Color keying is the action of replacing pixels matching a given color > (or range of colors) with transparent pixels in an overlay when > performing blitting. Depending on the hardware capabilities, the > matching pixel can either become fully transparent, or gain a > programmable alpha value. > > Color keying is found in a large number of devices whose capabilities > often differ, but they still have enough common features in range to > standardize color key properties. This commit adds four properties > related to color keying named colorkey.min, colorkey.max, colorkey.alpha > and colorkey.mode. Additional properties can be defined by drivers to > expose device-specific features. > > Signed-off-by: Laurent Pinchart > --- > drivers/gpu/drm/drm_atomic.c | 16 +++++++ > drivers/gpu/drm/drm_blend.c | 108 +++++++++++++++++++++++++++++++++++++++++++ > include/drm/drm_blend.h | 4 ++ > include/drm/drm_plane.h | 28 ++++++++++- > 4 files changed, 155 insertions(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > index 37445d50816a..4f57ec25e04d 100644 > --- a/drivers/gpu/drm/drm_atomic.c > +++ b/drivers/gpu/drm/drm_atomic.c > @@ -756,6 +756,14 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane, > state->rotation = val; > } else if (property == plane->zpos_property) { > state->zpos = val; > + } else if (property == plane->colorkey.mode_property) { > + state->colorkey.mode = val; > + } else if (property == plane->colorkey.min_property) { > + state->colorkey.min = val; > + } else if (property == plane->colorkey.max_property) { > + state->colorkey.max = val; > + } else if (property == plane->colorkey.value_property) { > + state->colorkey.value = val; > } else if (plane->funcs->atomic_set_property) { > return plane->funcs->atomic_set_property(plane, state, > property, val); > @@ -815,6 +823,14 @@ drm_atomic_plane_get_property(struct drm_plane *plane, > *val = state->rotation; > } else if (property == plane->zpos_property) { > *val = state->zpos; > + } else if (property == plane->colorkey.mode_property) { > + *val = state->colorkey.mode; > + } else if (property == plane->colorkey.min_property) { > + *val = state->colorkey.min; > + } else if (property == plane->colorkey.max_property) { > + *val = state->colorkey.max; > + } else if (property == plane->colorkey.value_property) { > + *val = state->colorkey.value; > } else if (plane->funcs->atomic_get_property) { > return plane->funcs->atomic_get_property(plane, state, property, val); > } else { > diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c > index 2e5e089dd912..79da7d8a22e2 100644 > --- a/drivers/gpu/drm/drm_blend.c > +++ b/drivers/gpu/drm/drm_blend.c > @@ -98,6 +98,10 @@ > * planes. Without this property the primary plane is always below the cursor > * plane, and ordering between all other planes is undefined. > * > + * - Color keying is set up with drm_plane_create_colorkey_properties(). It adds > + * support for replacing a range of colors with a transparent color in the > + * plane. > + * > * Note that all the property extensions described here apply either to the > * plane or the CRTC (e.g. for the background color, which currently is not > * exposed and assumed to be black). > @@ -405,3 +409,107 @@ int drm_atomic_normalize_zpos(struct drm_device *dev, > return 0; > } > EXPORT_SYMBOL(drm_atomic_normalize_zpos); > + > +/** > + * drm_plane_create_colorkey_properties - create colorkey properties > + * @plane: drm plane > + * @modes: array of supported color keying modes > + * @num_modes: number of modes in the modes array > + * @replace: if true create the colorkey.replacement property > + * > + * This function creates the generic color keying properties and attach them to > + * the plane to enable color keying control for blending operations. > + * > + * Color keying is controlled through four properties: > + * > + * colorkey.mode: > + * The mode is an enumerated property that controls how color keying > + * operates. Modes are driver-specific, except for a "disabled" mode that > + * disables color keying and is guaranteed to exist if color keying is > + * supported. I don't see why we need driver specific modes. It should be possible to come up with some standard modes. I suppose a simple src vs. dst doesn't suffice, but if we combine that with a bit more information it should be good enough? Eg. i915 would expose something like src-min-max and dst-value-mask. > + * > + * colorkey.min, colorkey.max: > + * Those two properties specify the colors that are replaced by transparent > + * pixels. Pixel whose values are in the [min, max] range are replaced, all > + * other pixels are left untouched. The minimum and maximum values are > + * expressed as a 64-bit integer in AXYZ16161616 format, where A is the > + * alpha value and X, Y and Z correspond to the color components of the > + * plane's pixel format. In most cases XYZ will be either RGB or YUV. > + * > + * When a single color key is supported instead of a range, userspace shall > + * set the min and max properties to the same value, and drivers return an > + * error from their plane atomic check when the min and max values differ. > + * > + * Note that depending on the selected mode, not all components might be > + * used for comparison. For instance a device could support color keying in > + * YUV format using luma (Y) matching only, ignoring the chroma components. > + * This behaviour is driver-specific. This doesn't quite seem to support the common value+mask approach. Your luma matching thing could maybe be expressed via the mask by just setting both the key value and mask to zero for any component that shouldn't participate in the match. Although I suppose for i915 we'd need to have a src-min-max-mask type of mode for that, and we couldn't actually support arbitrary masks in that case (just 0 and ~0). So maybe there should be separate mode for that to indicate that particular restriction. > + * > + * colorkey.value: "value" makes me think of the key value. replacement-value or some such would be a bit more descriptive. > + * This property specifies the color value that replaces pixels matching > + * the [min, max] range. The value is expressed in AXYZ16161616 format as > + * the min and max properties. > + * > + * This property is optional and only present when the device supports > + * configurable color replacement for matching pixels in the plane. If > + * color keying capabilities of the device are limited to making the > + * matching pixels fully transparent the colorkey.value property won't be > + * created. > + * > + * Note that depending on the device, or the selected mode, not all > + * components might be used for value replacement. For instance a device > + * could support replacing the alpha value of the matching pixels but not > + * its color components. This behaviour is driver-specific. > + * > + * The @modes parameter points to an array of all color keying modes supported > + * by the plane. The first mode has to be named "disabled" and have value 0. All > + * other modes are driver-specific, and at least one mode has to be provided in > + * addition to the "disabled" mode. > + * > + * Returns: > + * Zero on success, negative errno on failure. > + */ > +int drm_plane_create_colorkey_properties(struct drm_plane *plane, > + const struct drm_prop_enum_list *modes, > + unsigned int num_modes, bool replace) > +{ > +#define CREATE_COLORKEY_PROP(plane, name, type, args...) ({ \ > + prop = drm_property_create_##type(plane->dev, 0, "colorkey." #name, \ > + args); \ > + if (prop) { \ > + drm_object_attach_property(&plane->base, prop, 0); \ > + plane->colorkey.name##_property = prop; \ > + } \ > + prop; \ > +}) > + > + struct drm_property *prop; > + > + /* > + * A minimum of two modes are required, with the first mode must named > + * "disabled". > + */ > + if (!modes || num_modes == 0 || strcmp(modes[0].name, "disabled")) > + return -EINVAL; > + > + prop = CREATE_COLORKEY_PROP(plane, mode, enum, modes, num_modes); > + if (!prop) > + return -ENOMEM; > + > + prop = CREATE_COLORKEY_PROP(plane, min, range, 0, U64_MAX); > + if (!prop) > + return -ENOMEM; > + > + prop = CREATE_COLORKEY_PROP(plane, max, range, 0, U64_MAX); > + if (!prop) > + return -ENOMEM; > + > + if (replace) { > + prop = CREATE_COLORKEY_PROP(plane, value, range, 0, U64_MAX); > + if (!prop) > + return -ENOMEM; > + } > + > + return 0; > +} > +EXPORT_SYMBOL(drm_plane_create_colorkey_properties); > diff --git a/include/drm/drm_blend.h b/include/drm/drm_blend.h > index 17606026590b..1d4c965dd5e2 100644 > --- a/include/drm/drm_blend.h > +++ b/include/drm/drm_blend.h > @@ -49,4 +49,8 @@ int drm_plane_create_zpos_immutable_property(struct drm_plane *plane, > unsigned int zpos); > int drm_atomic_normalize_zpos(struct drm_device *dev, > struct drm_atomic_state *state); > + > +int drm_plane_create_colorkey_properties(struct drm_plane *plane, > + const struct drm_prop_enum_list *modes, > + unsigned int num_modes, bool replace); > #endif > diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h > index 8185e3468a23..a5804a4ea5c3 100644 > --- a/include/drm/drm_plane.h > +++ b/include/drm/drm_plane.h > @@ -52,6 +52,13 @@ struct drm_modeset_acquire_ctx; > * where N is the number of active planes for given crtc. Note that > * the driver must call drm_atomic_normalize_zpos() to update this before > * it can be trusted. > + * @colorkey.mode: color key mode. 0 disabled color keying, other values are > + * driver-specific. > + * @colorkey.min: color key range minimum. The value is stored in AXYZ16161616 > + * format, where A is the alpha value and X, Y and Z correspond to the > + * color components of the plane's pixel format (usually RGB or YUV). > + * @colorkey.max: color key range maximum (in AXYZ16161616 format) > + * @colorkey.value: color key replacement value (in in AXYZ16161616 format) > * @src: clipped source coordinates of the plane (in 16.16) > * @dst: clipped destination coordinates of the plane > * @state: backpointer to global drm_atomic_state > @@ -112,6 +119,14 @@ struct drm_plane_state { > unsigned int zpos; > unsigned int normalized_zpos; > > + /* Plane colorkey */ > + struct { > + unsigned int mode; > + u64 min; > + u64 max; > + u64 value; > + } colorkey; > + > /* Clipped coordinates */ > struct drm_rect src, dst; > > @@ -481,9 +496,13 @@ enum drm_plane_type { > * @funcs: helper functions > * @properties: property tracking for this plane > * @type: type of plane (overlay, primary, cursor) > + * @helper_private: mid-layer private data > * @zpos_property: zpos property for this plane > * @rotation_property: rotation property for this plane > - * @helper_private: mid-layer private data > + * @colorkey.mode_property: color key mode property > + * @colorkey.min_property: color key range minimum property > + * @colorkey.max_property: color key range maximum property > + * @colorkey.value_property: color key replacement value property > */ > struct drm_plane { > struct drm_device *dev; > @@ -558,6 +577,13 @@ struct drm_plane { > > struct drm_property *zpos_property; > struct drm_property *rotation_property; > + > + struct { > + struct drm_property *mode_property; > + struct drm_property *min_property; > + struct drm_property *max_property; > + struct drm_property *value_property; > + } colorkey; > }; > > #define obj_to_plane(x) container_of(x, struct drm_plane, base) > -- > Regards, > > Laurent Pinchart > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Ville Syrjälä Intel From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga02.intel.com ([134.134.136.20]:11961 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755172AbeDZN1v (ORCPT ); Thu, 26 Apr 2018 09:27:51 -0400 Date: Thu, 26 Apr 2018 16:27:44 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Laurent Pinchart Cc: dri-devel@lists.freedesktop.org, Thomas Hellstrom , Joonas Lahtinen , Russell King , linux-renesas-soc@vger.kernel.org, Ben Skeggs , Rodrigo Vivi , Alexandru Gheorghe , linux-media@vger.kernel.org Subject: Re: [PATCH/RFC 1/4] drm: Add colorkey properties Message-ID: <20180426132744.GI23723@intel.com> References: <20171217001724.1348-1-laurent.pinchart+renesas@ideasonboard.com> <20171217001724.1348-2-laurent.pinchart+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20171217001724.1348-2-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: On Sun, Dec 17, 2017 at 02:17:21AM +0200, Laurent Pinchart wrote: > Color keying is the action of replacing pixels matching a given color > (or range of colors) with transparent pixels in an overlay when > performing blitting. Depending on the hardware capabilities, the > matching pixel can either become fully transparent, or gain a > programmable alpha value. > > Color keying is found in a large number of devices whose capabilities > often differ, but they still have enough common features in range to > standardize color key properties. This commit adds four properties > related to color keying named colorkey.min, colorkey.max, colorkey.alpha > and colorkey.mode. Additional properties can be defined by drivers to > expose device-specific features. > > Signed-off-by: Laurent Pinchart > --- > drivers/gpu/drm/drm_atomic.c | 16 +++++++ > drivers/gpu/drm/drm_blend.c | 108 +++++++++++++++++++++++++++++++++++++++++++ > include/drm/drm_blend.h | 4 ++ > include/drm/drm_plane.h | 28 ++++++++++- > 4 files changed, 155 insertions(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > index 37445d50816a..4f57ec25e04d 100644 > --- a/drivers/gpu/drm/drm_atomic.c > +++ b/drivers/gpu/drm/drm_atomic.c > @@ -756,6 +756,14 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane, > state->rotation = val; > } else if (property == plane->zpos_property) { > state->zpos = val; > + } else if (property == plane->colorkey.mode_property) { > + state->colorkey.mode = val; > + } else if (property == plane->colorkey.min_property) { > + state->colorkey.min = val; > + } else if (property == plane->colorkey.max_property) { > + state->colorkey.max = val; > + } else if (property == plane->colorkey.value_property) { > + state->colorkey.value = val; > } else if (plane->funcs->atomic_set_property) { > return plane->funcs->atomic_set_property(plane, state, > property, val); > @@ -815,6 +823,14 @@ drm_atomic_plane_get_property(struct drm_plane *plane, > *val = state->rotation; > } else if (property == plane->zpos_property) { > *val = state->zpos; > + } else if (property == plane->colorkey.mode_property) { > + *val = state->colorkey.mode; > + } else if (property == plane->colorkey.min_property) { > + *val = state->colorkey.min; > + } else if (property == plane->colorkey.max_property) { > + *val = state->colorkey.max; > + } else if (property == plane->colorkey.value_property) { > + *val = state->colorkey.value; > } else if (plane->funcs->atomic_get_property) { > return plane->funcs->atomic_get_property(plane, state, property, val); > } else { > diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c > index 2e5e089dd912..79da7d8a22e2 100644 > --- a/drivers/gpu/drm/drm_blend.c > +++ b/drivers/gpu/drm/drm_blend.c > @@ -98,6 +98,10 @@ > * planes. Without this property the primary plane is always below the cursor > * plane, and ordering between all other planes is undefined. > * > + * - Color keying is set up with drm_plane_create_colorkey_properties(). It adds > + * support for replacing a range of colors with a transparent color in the > + * plane. > + * > * Note that all the property extensions described here apply either to the > * plane or the CRTC (e.g. for the background color, which currently is not > * exposed and assumed to be black). > @@ -405,3 +409,107 @@ int drm_atomic_normalize_zpos(struct drm_device *dev, > return 0; > } > EXPORT_SYMBOL(drm_atomic_normalize_zpos); > + > +/** > + * drm_plane_create_colorkey_properties - create colorkey properties > + * @plane: drm plane > + * @modes: array of supported color keying modes > + * @num_modes: number of modes in the modes array > + * @replace: if true create the colorkey.replacement property > + * > + * This function creates the generic color keying properties and attach them to > + * the plane to enable color keying control for blending operations. > + * > + * Color keying is controlled through four properties: > + * > + * colorkey.mode: > + * The mode is an enumerated property that controls how color keying > + * operates. Modes are driver-specific, except for a "disabled" mode that > + * disables color keying and is guaranteed to exist if color keying is > + * supported. I don't see why we need driver specific modes. It should be possible to come up with some standard modes. I suppose a simple src vs. dst doesn't suffice, but if we combine that with a bit more information it should be good enough? Eg. i915 would expose something like src-min-max and dst-value-mask. > + * > + * colorkey.min, colorkey.max: > + * Those two properties specify the colors that are replaced by transparent > + * pixels. Pixel whose values are in the [min, max] range are replaced, all > + * other pixels are left untouched. The minimum and maximum values are > + * expressed as a 64-bit integer in AXYZ16161616 format, where A is the > + * alpha value and X, Y and Z correspond to the color components of the > + * plane's pixel format. In most cases XYZ will be either RGB or YUV. > + * > + * When a single color key is supported instead of a range, userspace shall > + * set the min and max properties to the same value, and drivers return an > + * error from their plane atomic check when the min and max values differ. > + * > + * Note that depending on the selected mode, not all components might be > + * used for comparison. For instance a device could support color keying in > + * YUV format using luma (Y) matching only, ignoring the chroma components. > + * This behaviour is driver-specific. This doesn't quite seem to support the common value+mask approach. Your luma matching thing could maybe be expressed via the mask by just setting both the key value and mask to zero for any component that shouldn't participate in the match. Although I suppose for i915 we'd need to have a src-min-max-mask type of mode for that, and we couldn't actually support arbitrary masks in that case (just 0 and ~0). So maybe there should be separate mode for that to indicate that particular restriction. > + * > + * colorkey.value: "value" makes me think of the key value. replacement-value or some such would be a bit more descriptive. > + * This property specifies the color value that replaces pixels matching > + * the [min, max] range. The value is expressed in AXYZ16161616 format as > + * the min and max properties. > + * > + * This property is optional and only present when the device supports > + * configurable color replacement for matching pixels in the plane. If > + * color keying capabilities of the device are limited to making the > + * matching pixels fully transparent the colorkey.value property won't be > + * created. > + * > + * Note that depending on the device, or the selected mode, not all > + * components might be used for value replacement. For instance a device > + * could support replacing the alpha value of the matching pixels but not > + * its color components. This behaviour is driver-specific. > + * > + * The @modes parameter points to an array of all color keying modes supported > + * by the plane. The first mode has to be named "disabled" and have value 0. All > + * other modes are driver-specific, and at least one mode has to be provided in > + * addition to the "disabled" mode. > + * > + * Returns: > + * Zero on success, negative errno on failure. > + */ > +int drm_plane_create_colorkey_properties(struct drm_plane *plane, > + const struct drm_prop_enum_list *modes, > + unsigned int num_modes, bool replace) > +{ > +#define CREATE_COLORKEY_PROP(plane, name, type, args...) ({ \ > + prop = drm_property_create_##type(plane->dev, 0, "colorkey." #name, \ > + args); \ > + if (prop) { \ > + drm_object_attach_property(&plane->base, prop, 0); \ > + plane->colorkey.name##_property = prop; \ > + } \ > + prop; \ > +}) > + > + struct drm_property *prop; > + > + /* > + * A minimum of two modes are required, with the first mode must named > + * "disabled". > + */ > + if (!modes || num_modes == 0 || strcmp(modes[0].name, "disabled")) > + return -EINVAL; > + > + prop = CREATE_COLORKEY_PROP(plane, mode, enum, modes, num_modes); > + if (!prop) > + return -ENOMEM; > + > + prop = CREATE_COLORKEY_PROP(plane, min, range, 0, U64_MAX); > + if (!prop) > + return -ENOMEM; > + > + prop = CREATE_COLORKEY_PROP(plane, max, range, 0, U64_MAX); > + if (!prop) > + return -ENOMEM; > + > + if (replace) { > + prop = CREATE_COLORKEY_PROP(plane, value, range, 0, U64_MAX); > + if (!prop) > + return -ENOMEM; > + } > + > + return 0; > +} > +EXPORT_SYMBOL(drm_plane_create_colorkey_properties); > diff --git a/include/drm/drm_blend.h b/include/drm/drm_blend.h > index 17606026590b..1d4c965dd5e2 100644 > --- a/include/drm/drm_blend.h > +++ b/include/drm/drm_blend.h > @@ -49,4 +49,8 @@ int drm_plane_create_zpos_immutable_property(struct drm_plane *plane, > unsigned int zpos); > int drm_atomic_normalize_zpos(struct drm_device *dev, > struct drm_atomic_state *state); > + > +int drm_plane_create_colorkey_properties(struct drm_plane *plane, > + const struct drm_prop_enum_list *modes, > + unsigned int num_modes, bool replace); > #endif > diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h > index 8185e3468a23..a5804a4ea5c3 100644 > --- a/include/drm/drm_plane.h > +++ b/include/drm/drm_plane.h > @@ -52,6 +52,13 @@ struct drm_modeset_acquire_ctx; > * where N is the number of active planes for given crtc. Note that > * the driver must call drm_atomic_normalize_zpos() to update this before > * it can be trusted. > + * @colorkey.mode: color key mode. 0 disabled color keying, other values are > + * driver-specific. > + * @colorkey.min: color key range minimum. The value is stored in AXYZ16161616 > + * format, where A is the alpha value and X, Y and Z correspond to the > + * color components of the plane's pixel format (usually RGB or YUV). > + * @colorkey.max: color key range maximum (in AXYZ16161616 format) > + * @colorkey.value: color key replacement value (in in AXYZ16161616 format) > * @src: clipped source coordinates of the plane (in 16.16) > * @dst: clipped destination coordinates of the plane > * @state: backpointer to global drm_atomic_state > @@ -112,6 +119,14 @@ struct drm_plane_state { > unsigned int zpos; > unsigned int normalized_zpos; > > + /* Plane colorkey */ > + struct { > + unsigned int mode; > + u64 min; > + u64 max; > + u64 value; > + } colorkey; > + > /* Clipped coordinates */ > struct drm_rect src, dst; > > @@ -481,9 +496,13 @@ enum drm_plane_type { > * @funcs: helper functions > * @properties: property tracking for this plane > * @type: type of plane (overlay, primary, cursor) > + * @helper_private: mid-layer private data > * @zpos_property: zpos property for this plane > * @rotation_property: rotation property for this plane > - * @helper_private: mid-layer private data > + * @colorkey.mode_property: color key mode property > + * @colorkey.min_property: color key range minimum property > + * @colorkey.max_property: color key range maximum property > + * @colorkey.value_property: color key replacement value property > */ > struct drm_plane { > struct drm_device *dev; > @@ -558,6 +577,13 @@ struct drm_plane { > > struct drm_property *zpos_property; > struct drm_property *rotation_property; > + > + struct { > + struct drm_property *mode_property; > + struct drm_property *min_property; > + struct drm_property *max_property; > + struct drm_property *value_property; > + } colorkey; > }; > > #define obj_to_plane(x) container_of(x, struct drm_plane, base) > -- > Regards, > > Laurent Pinchart > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Ville Syrj�l� Intel From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH/RFC 1/4] drm: Add colorkey properties Date: Thu, 26 Apr 2018 16:27:44 +0300 Message-ID: <20180426132744.GI23723@intel.com> References: <20171217001724.1348-1-laurent.pinchart+renesas@ideasonboard.com> <20171217001724.1348-2-laurent.pinchart+renesas@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id DDD636E6D4 for ; Thu, 26 Apr 2018 13:27:50 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20171217001724.1348-2-laurent.pinchart+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Laurent Pinchart Cc: Thomas Hellstrom , Russell King , dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, Ben Skeggs , Rodrigo Vivi , Alexandru Gheorghe , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gU3VuLCBEZWMgMTcsIDIwMTcgYXQgMDI6MTc6MjFBTSArMDIwMCwgTGF1cmVudCBQaW5jaGFy dCB3cm90ZToKPiBDb2xvciBrZXlpbmcgaXMgdGhlIGFjdGlvbiBvZiByZXBsYWNpbmcgcGl4ZWxz IG1hdGNoaW5nIGEgZ2l2ZW4gY29sb3IKPiAob3IgcmFuZ2Ugb2YgY29sb3JzKSB3aXRoIHRyYW5z cGFyZW50IHBpeGVscyBpbiBhbiBvdmVybGF5IHdoZW4KPiBwZXJmb3JtaW5nIGJsaXR0aW5nLiBE ZXBlbmRpbmcgb24gdGhlIGhhcmR3YXJlIGNhcGFiaWxpdGllcywgdGhlCj4gbWF0Y2hpbmcgcGl4 ZWwgY2FuIGVpdGhlciBiZWNvbWUgZnVsbHkgdHJhbnNwYXJlbnQsIG9yIGdhaW4gYQo+IHByb2dy YW1tYWJsZSBhbHBoYSB2YWx1ZS4KPiAKPiBDb2xvciBrZXlpbmcgaXMgZm91bmQgaW4gYSBsYXJn ZSBudW1iZXIgb2YgZGV2aWNlcyB3aG9zZSBjYXBhYmlsaXRpZXMKPiBvZnRlbiBkaWZmZXIsIGJ1 dCB0aGV5IHN0aWxsIGhhdmUgZW5vdWdoIGNvbW1vbiBmZWF0dXJlcyBpbiByYW5nZSB0bwo+IHN0 YW5kYXJkaXplIGNvbG9yIGtleSBwcm9wZXJ0aWVzLiBUaGlzIGNvbW1pdCBhZGRzIGZvdXIgcHJv cGVydGllcwo+IHJlbGF0ZWQgdG8gY29sb3Iga2V5aW5nIG5hbWVkIGNvbG9ya2V5Lm1pbiwgY29s b3JrZXkubWF4LCBjb2xvcmtleS5hbHBoYQo+IGFuZCBjb2xvcmtleS5tb2RlLiBBZGRpdGlvbmFs IHByb3BlcnRpZXMgY2FuIGJlIGRlZmluZWQgYnkgZHJpdmVycyB0bwo+IGV4cG9zZSBkZXZpY2Ut c3BlY2lmaWMgZmVhdHVyZXMuCj4gCj4gU2lnbmVkLW9mZi1ieTogTGF1cmVudCBQaW5jaGFydCA8 bGF1cmVudC5waW5jaGFydCtyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4gLS0tCj4gIGRyaXZl cnMvZ3B1L2RybS9kcm1fYXRvbWljLmMgfCAgMTYgKysrKysrKwo+ICBkcml2ZXJzL2dwdS9kcm0v ZHJtX2JsZW5kLmMgIHwgMTA4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKPiAgaW5jbHVkZS9kcm0vZHJtX2JsZW5kLmggICAgICB8ICAgNCArKwo+ICBpbmNsdWRl L2RybS9kcm1fcGxhbmUuaCAgICAgIHwgIDI4ICsrKysrKysrKystCj4gIDQgZmlsZXMgY2hhbmdl ZCwgMTU1IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMK PiBpbmRleCAzNzQ0NWQ1MDgxNmEuLjRmNTdlYzI1ZTA0ZCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vZHJtX2F0b21pYy5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMu Ywo+IEBAIC03NTYsNiArNzU2LDE0IEBAIHN0YXRpYyBpbnQgZHJtX2F0b21pY19wbGFuZV9zZXRf cHJvcGVydHkoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCj4gIAkJc3RhdGUtPnJvdGF0aW9uID0g dmFsOwo+ICAJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+enBvc19wcm9wZXJ0eSkgewo+ ICAJCXN0YXRlLT56cG9zID0gdmFsOwo+ICsJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+ Y29sb3JrZXkubW9kZV9wcm9wZXJ0eSkgewo+ICsJCXN0YXRlLT5jb2xvcmtleS5tb2RlID0gdmFs Owo+ICsJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+Y29sb3JrZXkubWluX3Byb3BlcnR5 KSB7Cj4gKwkJc3RhdGUtPmNvbG9ya2V5Lm1pbiA9IHZhbDsKPiArCX0gZWxzZSBpZiAocHJvcGVy dHkgPT0gcGxhbmUtPmNvbG9ya2V5Lm1heF9wcm9wZXJ0eSkgewo+ICsJCXN0YXRlLT5jb2xvcmtl eS5tYXggPSB2YWw7Cj4gKwl9IGVsc2UgaWYgKHByb3BlcnR5ID09IHBsYW5lLT5jb2xvcmtleS52 YWx1ZV9wcm9wZXJ0eSkgewo+ICsJCXN0YXRlLT5jb2xvcmtleS52YWx1ZSA9IHZhbDsKPiAgCX0g ZWxzZSBpZiAocGxhbmUtPmZ1bmNzLT5hdG9taWNfc2V0X3Byb3BlcnR5KSB7Cj4gIAkJcmV0dXJu IHBsYW5lLT5mdW5jcy0+YXRvbWljX3NldF9wcm9wZXJ0eShwbGFuZSwgc3RhdGUsCj4gIAkJCQlw cm9wZXJ0eSwgdmFsKTsKPiBAQCAtODE1LDYgKzgyMywxNCBAQCBkcm1fYXRvbWljX3BsYW5lX2dl dF9wcm9wZXJ0eShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiAgCQkqdmFsID0gc3RhdGUtPnJv dGF0aW9uOwo+ICAJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+enBvc19wcm9wZXJ0eSkg ewo+ICAJCSp2YWwgPSBzdGF0ZS0+enBvczsKPiArCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gcGxh bmUtPmNvbG9ya2V5Lm1vZGVfcHJvcGVydHkpIHsKPiArCQkqdmFsID0gc3RhdGUtPmNvbG9ya2V5 Lm1vZGU7Cj4gKwl9IGVsc2UgaWYgKHByb3BlcnR5ID09IHBsYW5lLT5jb2xvcmtleS5taW5fcHJv cGVydHkpIHsKPiArCQkqdmFsID0gc3RhdGUtPmNvbG9ya2V5Lm1pbjsKPiArCX0gZWxzZSBpZiAo cHJvcGVydHkgPT0gcGxhbmUtPmNvbG9ya2V5Lm1heF9wcm9wZXJ0eSkgewo+ICsJCSp2YWwgPSBz dGF0ZS0+Y29sb3JrZXkubWF4Owo+ICsJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+Y29s b3JrZXkudmFsdWVfcHJvcGVydHkpIHsKPiArCQkqdmFsID0gc3RhdGUtPmNvbG9ya2V5LnZhbHVl Owo+ICAJfSBlbHNlIGlmIChwbGFuZS0+ZnVuY3MtPmF0b21pY19nZXRfcHJvcGVydHkpIHsKPiAg CQlyZXR1cm4gcGxhbmUtPmZ1bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KHBsYW5lLCBzdGF0ZSwg cHJvcGVydHksIHZhbCk7Cj4gIAl9IGVsc2Ugewo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2JsZW5kLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2JsZW5kLmMKPiBpbmRleCAyZTVl MDg5ZGQ5MTIuLjc5ZGE3ZDhhMjJlMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJt X2JsZW5kLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2JsZW5kLmMKPiBAQCAtOTgsNiAr OTgsMTAgQEAKPiAgICogICBwbGFuZXMuIFdpdGhvdXQgdGhpcyBwcm9wZXJ0eSB0aGUgcHJpbWFy eSBwbGFuZSBpcyBhbHdheXMgYmVsb3cgdGhlIGN1cnNvcgo+ICAgKiAgIHBsYW5lLCBhbmQgb3Jk ZXJpbmcgYmV0d2VlbiBhbGwgb3RoZXIgcGxhbmVzIGlzIHVuZGVmaW5lZC4KPiAgICoKPiArICog LSBDb2xvciBrZXlpbmcgaXMgc2V0IHVwIHdpdGggZHJtX3BsYW5lX2NyZWF0ZV9jb2xvcmtleV9w cm9wZXJ0aWVzKCkuIEl0IGFkZHMKPiArICogICBzdXBwb3J0IGZvciByZXBsYWNpbmcgYSByYW5n ZSBvZiBjb2xvcnMgd2l0aCBhIHRyYW5zcGFyZW50IGNvbG9yIGluIHRoZQo+ICsgKiAgIHBsYW5l Lgo+ICsgKgo+ICAgKiBOb3RlIHRoYXQgYWxsIHRoZSBwcm9wZXJ0eSBleHRlbnNpb25zIGRlc2Ny aWJlZCBoZXJlIGFwcGx5IGVpdGhlciB0byB0aGUKPiAgICogcGxhbmUgb3IgdGhlIENSVEMgKGUu Zy4gZm9yIHRoZSBiYWNrZ3JvdW5kIGNvbG9yLCB3aGljaCBjdXJyZW50bHkgaXMgbm90Cj4gICAq IGV4cG9zZWQgYW5kIGFzc3VtZWQgdG8gYmUgYmxhY2spLgo+IEBAIC00MDUsMyArNDA5LDEwNyBA QCBpbnQgZHJtX2F0b21pY19ub3JtYWxpemVfenBvcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ ICAJcmV0dXJuIDA7Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChkcm1fYXRvbWljX25vcm1hbGl6ZV96 cG9zKTsKPiArCj4gKy8qKgo+ICsgKiBkcm1fcGxhbmVfY3JlYXRlX2NvbG9ya2V5X3Byb3BlcnRp ZXMgLSBjcmVhdGUgY29sb3JrZXkgcHJvcGVydGllcwo+ICsgKiBAcGxhbmU6IGRybSBwbGFuZQo+ ICsgKiBAbW9kZXM6IGFycmF5IG9mIHN1cHBvcnRlZCBjb2xvciBrZXlpbmcgbW9kZXMKPiArICog QG51bV9tb2RlczogbnVtYmVyIG9mIG1vZGVzIGluIHRoZSBtb2RlcyBhcnJheQo+ICsgKiBAcmVw bGFjZTogaWYgdHJ1ZSBjcmVhdGUgdGhlIGNvbG9ya2V5LnJlcGxhY2VtZW50IHByb3BlcnR5Cj4g KyAqCj4gKyAqIFRoaXMgZnVuY3Rpb24gY3JlYXRlcyB0aGUgZ2VuZXJpYyBjb2xvciBrZXlpbmcg cHJvcGVydGllcyBhbmQgYXR0YWNoIHRoZW0gdG8KPiArICogdGhlIHBsYW5lIHRvIGVuYWJsZSBj b2xvciBrZXlpbmcgY29udHJvbCBmb3IgYmxlbmRpbmcgb3BlcmF0aW9ucy4KPiArICoKPiArICog Q29sb3Iga2V5aW5nIGlzIGNvbnRyb2xsZWQgdGhyb3VnaCBmb3VyIHByb3BlcnRpZXM6Cj4gKyAq Cj4gKyAqIGNvbG9ya2V5Lm1vZGU6Cj4gKyAqCVRoZSBtb2RlIGlzIGFuIGVudW1lcmF0ZWQgcHJv cGVydHkgdGhhdCBjb250cm9scyBob3cgY29sb3Iga2V5aW5nCj4gKyAqCW9wZXJhdGVzLiBNb2Rl cyBhcmUgZHJpdmVyLXNwZWNpZmljLCBleGNlcHQgZm9yIGEgImRpc2FibGVkIiBtb2RlIHRoYXQK PiArICoJZGlzYWJsZXMgY29sb3Iga2V5aW5nIGFuZCBpcyBndWFyYW50ZWVkIHRvIGV4aXN0IGlm IGNvbG9yIGtleWluZyBpcwo+ICsgKglzdXBwb3J0ZWQuCgpJIGRvbid0IHNlZSB3aHkgd2UgbmVl ZCBkcml2ZXIgc3BlY2lmaWMgbW9kZXMuIEl0IHNob3VsZCBiZSBwb3NzaWJsZSB0bwpjb21lIHVw IHdpdGggc29tZSBzdGFuZGFyZCBtb2Rlcy4gSSBzdXBwb3NlIGEgc2ltcGxlIHNyYyB2cy4gZHN0 IGRvZXNuJ3QKc3VmZmljZSwgYnV0IGlmIHdlIGNvbWJpbmUgdGhhdCB3aXRoIGEgYml0IG1vcmUg aW5mb3JtYXRpb24gaXQgc2hvdWxkIGJlCmdvb2QgZW5vdWdoPyBFZy4gaTkxNSB3b3VsZCBleHBv c2Ugc29tZXRoaW5nIGxpa2Ugc3JjLW1pbi1tYXggYW5kCmRzdC12YWx1ZS1tYXNrLgoKPiArICoK PiArICogY29sb3JrZXkubWluLCBjb2xvcmtleS5tYXg6Cj4gKyAqCVRob3NlIHR3byBwcm9wZXJ0 aWVzIHNwZWNpZnkgdGhlIGNvbG9ycyB0aGF0IGFyZSByZXBsYWNlZCBieSB0cmFuc3BhcmVudAo+ ICsgKglwaXhlbHMuIFBpeGVsIHdob3NlIHZhbHVlcyBhcmUgaW4gdGhlIFttaW4sIG1heF0gcmFu Z2UgYXJlIHJlcGxhY2VkLCBhbGwKPiArICoJb3RoZXIgcGl4ZWxzIGFyZSBsZWZ0IHVudG91Y2hl ZC4gVGhlIG1pbmltdW0gYW5kIG1heGltdW0gdmFsdWVzIGFyZQo+ICsgKglleHByZXNzZWQgYXMg YSA2NC1iaXQgaW50ZWdlciBpbiBBWFlaMTYxNjE2MTYgZm9ybWF0LCB3aGVyZSBBIGlzIHRoZQo+ ICsgKglhbHBoYSB2YWx1ZSBhbmQgWCwgWSBhbmQgWiBjb3JyZXNwb25kIHRvIHRoZSBjb2xvciBj b21wb25lbnRzIG9mIHRoZQo+ICsgKglwbGFuZSdzIHBpeGVsIGZvcm1hdC4gSW4gbW9zdCBjYXNl cyBYWVogd2lsbCBiZSBlaXRoZXIgUkdCIG9yIFlVVi4KPiArICoKPiArICoJV2hlbiBhIHNpbmds ZSBjb2xvciBrZXkgaXMgc3VwcG9ydGVkIGluc3RlYWQgb2YgYSByYW5nZSwgdXNlcnNwYWNlIHNo YWxsCj4gKyAqCXNldCB0aGUgbWluIGFuZCBtYXggcHJvcGVydGllcyB0byB0aGUgc2FtZSB2YWx1 ZSwgYW5kIGRyaXZlcnMgcmV0dXJuIGFuCj4gKyAqCWVycm9yIGZyb20gdGhlaXIgcGxhbmUgYXRv bWljIGNoZWNrIHdoZW4gdGhlIG1pbiBhbmQgbWF4IHZhbHVlcyBkaWZmZXIuCj4gKyAqCj4gKyAq CU5vdGUgdGhhdCBkZXBlbmRpbmcgb24gdGhlIHNlbGVjdGVkIG1vZGUsIG5vdCBhbGwgY29tcG9u ZW50cyBtaWdodCBiZQo+ICsgKgl1c2VkIGZvciBjb21wYXJpc29uLiBGb3IgaW5zdGFuY2UgYSBk ZXZpY2UgY291bGQgc3VwcG9ydCBjb2xvciBrZXlpbmcgaW4KPiArICoJWVVWIGZvcm1hdCB1c2lu ZyBsdW1hIChZKSBtYXRjaGluZyBvbmx5LCBpZ25vcmluZyB0aGUgY2hyb21hIGNvbXBvbmVudHMu Cj4gKyAqCVRoaXMgYmVoYXZpb3VyIGlzIGRyaXZlci1zcGVjaWZpYy4KClRoaXMgZG9lc24ndCBx dWl0ZSBzZWVtIHRvIHN1cHBvcnQgdGhlIGNvbW1vbiB2YWx1ZSttYXNrIGFwcHJvYWNoLgoKWW91 ciBsdW1hIG1hdGNoaW5nIHRoaW5nIGNvdWxkIG1heWJlIGJlIGV4cHJlc3NlZCB2aWEgdGhlIG1h c2sgYnkKanVzdCBzZXR0aW5nIGJvdGggdGhlIGtleSB2YWx1ZSBhbmQgbWFzayB0byB6ZXJvIGZv ciBhbnkgY29tcG9uZW50CnRoYXQgc2hvdWxkbid0IHBhcnRpY2lwYXRlIGluIHRoZSBtYXRjaC4g QWx0aG91Z2ggSSBzdXBwb3NlIGZvciBpOTE1CndlJ2QgbmVlZCB0byBoYXZlIGEgc3JjLW1pbi1t YXgtbWFzayB0eXBlIG9mIG1vZGUgZm9yIHRoYXQsIGFuZCB3ZQpjb3VsZG4ndCBhY3R1YWxseSBz dXBwb3J0IGFyYml0cmFyeSBtYXNrcyBpbiB0aGF0IGNhc2UgKGp1c3QgMCBhbmQgfjApLgpTbyBt YXliZSB0aGVyZSBzaG91bGQgYmUgc2VwYXJhdGUgbW9kZSBmb3IgdGhhdCB0byBpbmRpY2F0ZSB0 aGF0CnBhcnRpY3VsYXIgcmVzdHJpY3Rpb24uCgo+ICsgKgo+ICsgKiBjb2xvcmtleS52YWx1ZToK CiJ2YWx1ZSIgbWFrZXMgbWUgdGhpbmsgb2YgdGhlIGtleSB2YWx1ZS4gcmVwbGFjZW1lbnQtdmFs dWUgb3Igc29tZQpzdWNoIHdvdWxkIGJlIGEgYml0IG1vcmUgZGVzY3JpcHRpdmUuCgo+ICsgKglU aGlzIHByb3BlcnR5IHNwZWNpZmllcyB0aGUgY29sb3IgdmFsdWUgdGhhdCByZXBsYWNlcyBwaXhl bHMgbWF0Y2hpbmcKPiArICoJdGhlIFttaW4sIG1heF0gcmFuZ2UuIFRoZSB2YWx1ZSBpcyBleHBy ZXNzZWQgaW4gQVhZWjE2MTYxNjE2IGZvcm1hdCBhcwo+ICsgKgl0aGUgbWluIGFuZCBtYXggcHJv cGVydGllcy4KPiArICoKPiArICoJVGhpcyBwcm9wZXJ0eSBpcyBvcHRpb25hbCBhbmQgb25seSBw cmVzZW50IHdoZW4gdGhlIGRldmljZSBzdXBwb3J0cwo+ICsgKgljb25maWd1cmFibGUgY29sb3Ig cmVwbGFjZW1lbnQgZm9yIG1hdGNoaW5nIHBpeGVscyBpbiB0aGUgcGxhbmUuIElmCj4gKyAqCWNv bG9yIGtleWluZyBjYXBhYmlsaXRpZXMgb2YgdGhlIGRldmljZSBhcmUgbGltaXRlZCB0byBtYWtp bmcgdGhlCj4gKyAqCW1hdGNoaW5nIHBpeGVscyBmdWxseSB0cmFuc3BhcmVudCB0aGUgY29sb3Jr ZXkudmFsdWUgcHJvcGVydHkgd29uJ3QgYmUKPiArICoJY3JlYXRlZC4KPiArICoKPiArICoJTm90 ZSB0aGF0IGRlcGVuZGluZyBvbiB0aGUgZGV2aWNlLCBvciB0aGUgc2VsZWN0ZWQgbW9kZSwgbm90 IGFsbAo+ICsgKgljb21wb25lbnRzIG1pZ2h0IGJlIHVzZWQgZm9yIHZhbHVlIHJlcGxhY2VtZW50 LiBGb3IgaW5zdGFuY2UgYSBkZXZpY2UKPiArICoJY291bGQgc3VwcG9ydCByZXBsYWNpbmcgdGhl IGFscGhhIHZhbHVlIG9mIHRoZSBtYXRjaGluZyBwaXhlbHMgYnV0IG5vdAo+ICsgKglpdHMgY29s b3IgY29tcG9uZW50cy4gVGhpcyBiZWhhdmlvdXIgaXMgZHJpdmVyLXNwZWNpZmljLgo+ICsgKgo+ ICsgKiBUaGUgQG1vZGVzIHBhcmFtZXRlciBwb2ludHMgdG8gYW4gYXJyYXkgb2YgYWxsIGNvbG9y IGtleWluZyBtb2RlcyBzdXBwb3J0ZWQKPiArICogYnkgdGhlIHBsYW5lLiBUaGUgZmlyc3QgbW9k ZSBoYXMgdG8gYmUgbmFtZWQgImRpc2FibGVkIiBhbmQgaGF2ZSB2YWx1ZSAwLiBBbGwKPiArICog b3RoZXIgbW9kZXMgYXJlIGRyaXZlci1zcGVjaWZpYywgYW5kIGF0IGxlYXN0IG9uZSBtb2RlIGhh cyB0byBiZSBwcm92aWRlZCBpbgo+ICsgKiBhZGRpdGlvbiB0byB0aGUgImRpc2FibGVkIiBtb2Rl Lgo+ICsgKgo+ICsgKiBSZXR1cm5zOgo+ICsgKiBaZXJvIG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVy cm5vIG9uIGZhaWx1cmUuCj4gKyAqLwo+ICtpbnQgZHJtX3BsYW5lX2NyZWF0ZV9jb2xvcmtleV9w cm9wZXJ0aWVzKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICsJCQkJCSBjb25zdCBzdHJ1Y3Qg ZHJtX3Byb3BfZW51bV9saXN0ICptb2RlcywKPiArCQkJCQkgdW5zaWduZWQgaW50IG51bV9tb2Rl cywgYm9vbCByZXBsYWNlKQo+ICt7Cj4gKyNkZWZpbmUgQ1JFQVRFX0NPTE9SS0VZX1BST1AocGxh bmUsIG5hbWUsIHR5cGUsIGFyZ3MuLi4pICh7CQkgICAgICAgXAo+ICsJcHJvcCA9IGRybV9wcm9w ZXJ0eV9jcmVhdGVfIyN0eXBlKHBsYW5lLT5kZXYsIDAsICJjb2xvcmtleS4iICNuYW1lLCAgICBc Cj4gKwkJCQkJICBhcmdzKTsJCQkgICAgICAgXAo+ICsJaWYgKHByb3ApIHsJCQkJCQkJICAgICAg IFwKPiArCQlkcm1fb2JqZWN0X2F0dGFjaF9wcm9wZXJ0eSgmcGxhbmUtPmJhc2UsIHByb3AsIDAp OwkgICAgICAgXAo+ICsJCXBsYW5lLT5jb2xvcmtleS5uYW1lIyNfcHJvcGVydHkgPSBwcm9wOwkJ CSAgICAgICBcCj4gKwl9CQkJCQkJCQkgICAgICAgXAo+ICsJcHJvcDsJCQkJCQkJCSAgICAgICBc Cj4gK30pCj4gKwo+ICsJc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcDsKPiArCj4gKwkvKgo+ICsJ ICogQSBtaW5pbXVtIG9mIHR3byBtb2RlcyBhcmUgcmVxdWlyZWQsIHdpdGggdGhlIGZpcnN0IG1v ZGUgbXVzdCBuYW1lZAo+ICsJICogImRpc2FibGVkIi4KPiArCSAqLwo+ICsJaWYgKCFtb2RlcyB8 fCBudW1fbW9kZXMgPT0gMCB8fCBzdHJjbXAobW9kZXNbMF0ubmFtZSwgImRpc2FibGVkIikpCj4g KwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcHJvcCA9IENSRUFURV9DT0xPUktFWV9QUk9QKHBs YW5lLCBtb2RlLCBlbnVtLCBtb2RlcywgbnVtX21vZGVzKTsKPiArCWlmICghcHJvcCkKPiArCQly ZXR1cm4gLUVOT01FTTsKPiArCj4gKwlwcm9wID0gQ1JFQVRFX0NPTE9SS0VZX1BST1AocGxhbmUs IG1pbiwgcmFuZ2UsIDAsIFU2NF9NQVgpOwo+ICsJaWYgKCFwcm9wKQo+ICsJCXJldHVybiAtRU5P TUVNOwo+ICsKPiArCXByb3AgPSBDUkVBVEVfQ09MT1JLRVlfUFJPUChwbGFuZSwgbWF4LCByYW5n ZSwgMCwgVTY0X01BWCk7Cj4gKwlpZiAoIXByb3ApCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ ICsJaWYgKHJlcGxhY2UpIHsKPiArCQlwcm9wID0gQ1JFQVRFX0NPTE9SS0VZX1BST1AocGxhbmUs IHZhbHVlLCByYW5nZSwgMCwgVTY0X01BWCk7Cj4gKwkJaWYgKCFwcm9wKQo+ICsJCQlyZXR1cm4g LUVOT01FTTsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRy bV9wbGFuZV9jcmVhdGVfY29sb3JrZXlfcHJvcGVydGllcyk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1 ZGUvZHJtL2RybV9ibGVuZC5oIGIvaW5jbHVkZS9kcm0vZHJtX2JsZW5kLmgKPiBpbmRleCAxNzYw NjAyNjU5MGIuLjFkNGM5NjVkZDVlMiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9kcm1fYmxl bmQuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9ibGVuZC5oCj4gQEAgLTQ5LDQgKzQ5LDggQEAg aW50IGRybV9wbGFuZV9jcmVhdGVfenBvc19pbW11dGFibGVfcHJvcGVydHkoc3RydWN0IGRybV9w bGFuZSAqcGxhbmUsCj4gIAkJCQkJICAgICB1bnNpZ25lZCBpbnQgenBvcyk7Cj4gIGludCBkcm1f YXRvbWljX25vcm1hbGl6ZV96cG9zKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJCSAgICAg IHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSk7Cj4gKwo+ICtpbnQgZHJtX3BsYW5lX2Ny ZWF0ZV9jb2xvcmtleV9wcm9wZXJ0aWVzKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICsJCQkJ CSBjb25zdCBzdHJ1Y3QgZHJtX3Byb3BfZW51bV9saXN0ICptb2RlcywKPiArCQkJCQkgdW5zaWdu ZWQgaW50IG51bV9tb2RlcywgYm9vbCByZXBsYWNlKTsKPiAgI2VuZGlmCj4gZGlmZiAtLWdpdCBh L2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oIGIvaW5jbHVkZS9kcm0vZHJtX3BsYW5lLmgKPiBpbmRl eCA4MTg1ZTM0NjhhMjMuLmE1ODA0YTRlYTVjMyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9k cm1fcGxhbmUuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oCj4gQEAgLTUyLDYgKzUy LDEzIEBAIHN0cnVjdCBkcm1fbW9kZXNldF9hY3F1aXJlX2N0eDsKPiAgICoJd2hlcmUgTiBpcyB0 aGUgbnVtYmVyIG9mIGFjdGl2ZSBwbGFuZXMgZm9yIGdpdmVuIGNydGMuIE5vdGUgdGhhdAo+ICAg Kgl0aGUgZHJpdmVyIG11c3QgY2FsbCBkcm1fYXRvbWljX25vcm1hbGl6ZV96cG9zKCkgdG8gdXBk YXRlIHRoaXMgYmVmb3JlCj4gICAqCWl0IGNhbiBiZSB0cnVzdGVkLgo+ICsgKiBAY29sb3JrZXku bW9kZTogY29sb3Iga2V5IG1vZGUuIDAgZGlzYWJsZWQgY29sb3Iga2V5aW5nLCBvdGhlciB2YWx1 ZXMgYXJlCj4gKyAqCWRyaXZlci1zcGVjaWZpYy4KPiArICogQGNvbG9ya2V5Lm1pbjogY29sb3Ig a2V5IHJhbmdlIG1pbmltdW0uIFRoZSB2YWx1ZSBpcyBzdG9yZWQgaW4gQVhZWjE2MTYxNjE2Cj4g KyAqCWZvcm1hdCwgd2hlcmUgQSBpcyB0aGUgYWxwaGEgdmFsdWUgYW5kIFgsIFkgYW5kIFogY29y cmVzcG9uZCB0byB0aGUKPiArICoJY29sb3IgY29tcG9uZW50cyBvZiB0aGUgcGxhbmUncyBwaXhl bCBmb3JtYXQgKHVzdWFsbHkgUkdCIG9yIFlVVikuCj4gKyAqIEBjb2xvcmtleS5tYXg6IGNvbG9y IGtleSByYW5nZSBtYXhpbXVtIChpbiBBWFlaMTYxNjE2MTYgZm9ybWF0KQo+ICsgKiBAY29sb3Jr ZXkudmFsdWU6IGNvbG9yIGtleSByZXBsYWNlbWVudCB2YWx1ZSAoaW4gaW4gQVhZWjE2MTYxNjE2 IGZvcm1hdCkKPiAgICogQHNyYzogY2xpcHBlZCBzb3VyY2UgY29vcmRpbmF0ZXMgb2YgdGhlIHBs YW5lIChpbiAxNi4xNikKPiAgICogQGRzdDogY2xpcHBlZCBkZXN0aW5hdGlvbiBjb29yZGluYXRl cyBvZiB0aGUgcGxhbmUKPiAgICogQHN0YXRlOiBiYWNrcG9pbnRlciB0byBnbG9iYWwgZHJtX2F0 b21pY19zdGF0ZQo+IEBAIC0xMTIsNiArMTE5LDE0IEBAIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUg ewo+ICAJdW5zaWduZWQgaW50IHpwb3M7Cj4gIAl1bnNpZ25lZCBpbnQgbm9ybWFsaXplZF96cG9z Owo+ICAKPiArCS8qIFBsYW5lIGNvbG9ya2V5ICovCj4gKwlzdHJ1Y3Qgewo+ICsJCXVuc2lnbmVk IGludCBtb2RlOwo+ICsJCXU2NCBtaW47Cj4gKwkJdTY0IG1heDsKPiArCQl1NjQgdmFsdWU7Cj4g Kwl9IGNvbG9ya2V5Owo+ICsKPiAgCS8qIENsaXBwZWQgY29vcmRpbmF0ZXMgKi8KPiAgCXN0cnVj dCBkcm1fcmVjdCBzcmMsIGRzdDsKPiAgCj4gQEAgLTQ4MSw5ICs0OTYsMTMgQEAgZW51bSBkcm1f cGxhbmVfdHlwZSB7Cj4gICAqIEBmdW5jczogaGVscGVyIGZ1bmN0aW9ucwo+ICAgKiBAcHJvcGVy dGllczogcHJvcGVydHkgdHJhY2tpbmcgZm9yIHRoaXMgcGxhbmUKPiAgICogQHR5cGU6IHR5cGUg b2YgcGxhbmUgKG92ZXJsYXksIHByaW1hcnksIGN1cnNvcikKPiArICogQGhlbHBlcl9wcml2YXRl OiBtaWQtbGF5ZXIgcHJpdmF0ZSBkYXRhCj4gICAqIEB6cG9zX3Byb3BlcnR5OiB6cG9zIHByb3Bl cnR5IGZvciB0aGlzIHBsYW5lCj4gICAqIEByb3RhdGlvbl9wcm9wZXJ0eTogcm90YXRpb24gcHJv cGVydHkgZm9yIHRoaXMgcGxhbmUKPiAtICogQGhlbHBlcl9wcml2YXRlOiBtaWQtbGF5ZXIgcHJp dmF0ZSBkYXRhCj4gKyAqIEBjb2xvcmtleS5tb2RlX3Byb3BlcnR5OiBjb2xvciBrZXkgbW9kZSBw cm9wZXJ0eQo+ICsgKiBAY29sb3JrZXkubWluX3Byb3BlcnR5OiBjb2xvciBrZXkgcmFuZ2UgbWlu aW11bSBwcm9wZXJ0eQo+ICsgKiBAY29sb3JrZXkubWF4X3Byb3BlcnR5OiBjb2xvciBrZXkgcmFu Z2UgbWF4aW11bSBwcm9wZXJ0eQo+ICsgKiBAY29sb3JrZXkudmFsdWVfcHJvcGVydHk6IGNvbG9y IGtleSByZXBsYWNlbWVudCB2YWx1ZSBwcm9wZXJ0eQo+ICAgKi8KPiAgc3RydWN0IGRybV9wbGFu ZSB7Cj4gIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2Owo+IEBAIC01NTgsNiArNTc3LDEzIEBAIHN0 cnVjdCBkcm1fcGxhbmUgewo+ICAKPiAgCXN0cnVjdCBkcm1fcHJvcGVydHkgKnpwb3NfcHJvcGVy dHk7Cj4gIAlzdHJ1Y3QgZHJtX3Byb3BlcnR5ICpyb3RhdGlvbl9wcm9wZXJ0eTsKPiArCj4gKwlz dHJ1Y3Qgewo+ICsJCXN0cnVjdCBkcm1fcHJvcGVydHkgKm1vZGVfcHJvcGVydHk7Cj4gKwkJc3Ry dWN0IGRybV9wcm9wZXJ0eSAqbWluX3Byb3BlcnR5Owo+ICsJCXN0cnVjdCBkcm1fcHJvcGVydHkg Km1heF9wcm9wZXJ0eTsKPiArCQlzdHJ1Y3QgZHJtX3Byb3BlcnR5ICp2YWx1ZV9wcm9wZXJ0eTsK PiArCX0gY29sb3JrZXk7Cj4gIH07Cj4gIAo+ICAjZGVmaW5lIG9ial90b19wbGFuZSh4KSBjb250 YWluZXJfb2YoeCwgc3RydWN0IGRybV9wbGFuZSwgYmFzZSkKPiAtLSAKPiBSZWdhcmRzLAo+IAo+ IExhdXJlbnQgUGluY2hhcnQKPiAKPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwo+IGRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKPiBkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCj4gaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9kcmktZGV2ZWwKCi0tIApWaWxsZSBTeXJqw6Rsw6QKSW50ZWwKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==