From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Date: Mon, 03 Jun 2019 08:23:16 +0000 Subject: Re: [PATCH 2/4] drm: Fix docbook warnings in hdr metadata helper structures Message-Id: <20190603082316.GI21222@phenom.ffwll.local> List-Id: References: <1559159944-21103-1-git-send-email-uma.shankar@intel.com> <1559159944-21103-3-git-send-email-uma.shankar@intel.com> In-Reply-To: <1559159944-21103-3-git-send-email-uma.shankar@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable To: Uma Shankar Cc: Sean Paul , linux-fbdev@vger.kernel.org, dcastagna@chromium.org, jonas@kwiboo.se, Maxime Ripard , intel-gfx@lists.freedesktop.org, Bartlomiej Zolnierkiewicz , emil.l.velikov@gmail.com, dri-devel@lists.freedesktop.org, Hans Verkuil , David Airlie , seanpaul@chromium.org On Thu, May 30, 2019 at 01:29:02AM +0530, Uma Shankar wrote: > Fixes the following warnings: > ./include/drm/drm_mode_config.h:841: warning: Incorrect use of > kernel-doc format: * hdr_output_metadata_property: Connector > property containing hdr > ./include/drm/drm_mode_config.h:918: warning: Function parameter or membe= r 'hdr_output_metadata_property' not described in 'drm_mode_config' > ./include/drm/drm_connector.h:1251: warning: Function parameter or member= 'hdr_output_metadata' not described in 'drm_connector' > ./include/drm/drm_connector.h:1251: warning: Function parameter or member= 'hdr_sink_metadata' not described in 'drm_connector' >=20 > Also adds some property documentation for HDR Metadata Connector > Property in connector property create function. >=20 > v2: Fixed Sean Paul's review comments. >=20 > v3: Fixed Daniel Vetter's review comments, added the UAPI structure > definition section in kernel docs. >=20 > Cc: Shashank Sharma > Cc: Ville Syrj=E4l=E4 > Cc: Maarten Lankhorst > Cc: Maxime Ripard > Cc: Sean Paul > Cc: David Airlie > Cc: Daniel Vetter > Cc: Bartlomiej Zolnierkiewicz > Cc: "Ville Syrj=E4l=E4" > Cc: Hans Verkuil > Cc: dri-devel@lists.freedesktop.org > Cc: linux-fbdev@vger.kernel.org > Reviewed-by: Sean Paul > Signed-off-by: Uma Shankar > --- > Documentation/gpu/drm-uapi.rst | 9 +++++++++ > drivers/gpu/drm/drm_connector.c | 31 +++++++++++++++++++++++++++++++ > include/drm/drm_connector.h | 1 + > include/drm/drm_mode_config.h | 4 ++-- > include/linux/hdmi.h | 1 + > include/uapi/drm/drm_mode.h | 37 +++++++++++++++++++++++++++++++++++= +- > 6 files changed, 80 insertions(+), 3 deletions(-) >=20 > diff --git a/Documentation/gpu/drm-uapi.rst b/Documentation/gpu/drm-uapi.= rst > index 05874d0..6b39e2c 100644 > --- a/Documentation/gpu/drm-uapi.rst > +++ b/Documentation/gpu/drm-uapi.rst > @@ -329,3 +329,12 @@ DRM_IOCTL_MODESET_CTL > mode setting, since on many devices the vertical blank counter is > reset to 0 at some point during modeset. Modern drivers should not > call this any more since with kernel mode setting it is a no-op. > + > +Userspace API Structures > +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D > + > +.. kernel-doc:: include/uapi/drm/drm_mode.h > + :doc: overview > + > +.. kernel-doc:: include/uapi/drm/drm_mode.h > + :internal: > diff --git a/drivers/gpu/drm/drm_connector.c b/drivers/gpu/drm/drm_connec= tor.c > index c9ac8b9..6a93527 100644 > --- a/drivers/gpu/drm/drm_connector.c > +++ b/drivers/gpu/drm/drm_connector.c > @@ -956,6 +956,37 @@ int drm_display_info_set_bus_formats(struct drm_disp= lay_info *info, > * is no longer protected and userspace should take appropriate action > * (whatever that might be). > * > + * HDR_OUTPUT_METADATA: > + * Connector property to enable userspace to send HDR Metadata to > + * driver. This metadata is based on the composition and blending > + * policies decided by user, taking into account the hardware and > + * sink capabilities. The driver gets this metadata and creates a > + * Dynamic Range and Mastering Infoframe (DRM) in case of HDMI, > + * SDP packet (Non-audio INFOFRAME SDP v1.3) for DP. This is then > + * sent to sink. This notifies the sink of the upcoming frame's Color > + * Encoding and Luminance parameters. > + * > + * Userspace first need to detect the HDR capabilities of sink by > + * reading and parsing the EDID. Details of HDR metadata for HDMI > + * are added in CTA 861.G spec. For DP , its defined in VESA DP > + * Standard v1.4. It needs to then get the metadata information > + * of the video/game/app content which are encoded in HDR (basically > + * using HDR transfer functions). With this information it needs to > + * decide on a blending policy and compose the relevant > + * layers/overlays into a common format. Once this blending is done, > + * userspace will be aware of the metadata of the composed frame to > + * be send to sink. It then uses this property to communicate this > + * metadata to driver which then make a Infoframe packet and sends > + * to sink based on the type of encoder connected. > + * > + * Userspace will be responsible to do Tone mapping operation in case: > + * - Some layers are HDR and others are SDR > + * - HDR layers luminance is not same as sink > + * It will even need to do colorspace conversion and get all layers > + * to one common colorspace for blending. It can use either GL, Media > + * or display engine to get this done based on the capabilties of the > + * associated hardware. I think it'd be good to add 1-2 sentences here about what this looks like for the driver side. E.g. which function drivers need to call to set up hdr, how to get at the metadata and whether there's any helpers for these. Here I'd point at hdr_output_metadata, hdr_sink_metadata, and drm_add_display_info() for filling in the former. I think with that this is a solid doc patch. > + * > * max bpc: > * This range property is used by userspace to limit the bit depth. When > * used the driver would limit the bpc in accordance with the valid range > diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h > index 5476561..47e749b 100644 > --- a/include/drm/drm_connector.h > +++ b/include/drm/drm_connector.h > @@ -1244,6 +1244,7 @@ struct drm_connector { > */ > struct llist_node free_node; > =20 > + /** @hdr_sink_metadata: HDR Metadata Information read from sink */ > struct hdr_sink_metadata hdr_sink_metadata; Something I realized while reading the code: This should probably be put into the drm_display_info struct, like all the other things we parse out of the edid. I think that would be a lot more consistent with the code - the driver interface function which calls this code is called drm_add_display_info() after all. Can you pls change that in a follow-up patch? > }; > =20 > diff --git a/include/drm/drm_mode_config.h b/include/drm/drm_mode_config.h > index 4f88cc9..759d462 100644 > --- a/include/drm/drm_mode_config.h > +++ b/include/drm/drm_mode_config.h > @@ -837,8 +837,8 @@ struct drm_mode_config { > struct drm_property *writeback_out_fence_ptr_property; > =20 > /** > - * hdr_output_metadata_property: Connector property containing hdr > - * metatda. This will be provided by userspace compositors based > + * @hdr_output_metadata_property: Connector property containing hdr > + * metatada. This will be provided by userspace compositors based > * on HDR content > */ > struct drm_property *hdr_output_metadata_property; > diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h > index ee55ba5..55c6db5 100644 > --- a/include/linux/hdmi.h > +++ b/include/linux/hdmi.h > @@ -398,6 +398,7 @@ ssize_t hdmi_vendor_infoframe_pack_only(const struct = hdmi_vendor_infoframe *fram > * @spd: spd infoframe > * @vendor: union of all vendor infoframes > * @audio: audio infoframe > + * @drm: Dynamic Range and Mastering infoframe > * > * This is used by the generic pack function. This works since all infof= rames > * have the same header which also indicates which type of infoframe sho= uld be > diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h > index 997a7e0..5d3964f 100644 > --- a/include/uapi/drm/drm_mode.h > +++ b/include/uapi/drm/drm_mode.h > @@ -33,6 +33,15 @@ > extern "C" { > #endif > =20 > +/** > + * DOC: overview > + * > + * DRM exposes many UAPI and structure definition to have a consistent > + * and standardized interface with user. > + * Userspace can refer to these structure definitions and UAPI formats > + * to communicate to driver > + */ > + > #define DRM_CONNECTOR_NAME_LEN 32 > #define DRM_DISPLAY_MODE_LEN 32 > #define DRM_PROP_NAME_LEN 32 > @@ -630,7 +639,26 @@ struct drm_color_lut { > __u16 reserved; > }; > =20 > -/* HDR Metadata Infoframe as per 861.G spec */ Keep the spec reference imo, maybe even add a note that this is supposed to perfectly match it. > +/** > + * struct hdr_metadata_infoframe - HDR Metadata Infoframe Data. > + * @eotf: Electro-Optical Transfer Function (EOTF) used in the stream. > + * @metadata_type: Static_Metadata_Descriptor_ID. > + * @display_primaries: Color Primaries of the Data. > + * @display_primaries.x: X cordinate of color primary. Would be good to spend a few more words about "in which standard/format" this color number is. I.e. fixed point or whatever, and color space. > + * @display_primaries.y: Y cordinate of color primary. > + * @white_point: White Point of Colorspace Data. > + * @white_point.x: X cordinate of whitepoint of color primary. > + * @white_point.y: Y cordinate of whitepoint of color primary. > + * @max_display_mastering_luminance: Max Mastering Display Luminance. > + * @min_display_mastering_luminance: Min Mastering Display Luminance. > + * @max_cll: Max Content Light Level. > + * @max_fall: Max Frame Average Light Level. btw for long structs I prefer the inline kerneldoc style. This one is just at the edge imo. > + * > + * With drm subsystem using struct drm_rect to manage rectangular area t= his struct &drm_rect to make it a hyperlink. Once we have drm_rect documented :-) > + * export it to user-space. > + * > + * Currently used by drm_mode_atomic blob property FB_DAMAGE_CLIPS. > + */ > struct hdr_metadata_infoframe { > __u8 eotf; > __u8 metadata_type; > @@ -646,6 +674,13 @@ struct hdr_metadata_infoframe { > __u16 max_fall; > }; > =20 > +/** > + * struct hdr_output_metadata - HDR output metadata > + * > + * Metadata Information to be passed from userspace > + * @metadata_type: Static_Metadata_Descriptor_ID. > + * @hdmi_metadata_type1: HDR Metadata Infoframe. If you want to move the member docs closer to their definition, go with the inline style. Thanks, Daniel > + */ > struct hdr_output_metadata { > __u32 metadata_type; > union { > --=20 > 1.9.1 >=20 --=20 Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 2/4] drm: Fix docbook warnings in hdr metadata helper structures Date: Mon, 3 Jun 2019 10:23:16 +0200 Message-ID: <20190603082316.GI21222@phenom.ffwll.local> References: <1559159944-21103-1-git-send-email-uma.shankar@intel.com> <1559159944-21103-3-git-send-email-uma.shankar@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-ed1-x543.google.com (mail-ed1-x543.google.com [IPv6:2a00:1450:4864:20::543]) by gabe.freedesktop.org (Postfix) with ESMTPS id 07E06891BA for ; Mon, 3 Jun 2019 08:23:21 +0000 (UTC) Received: by mail-ed1-x543.google.com with SMTP id w33so25686884edb.10 for ; Mon, 03 Jun 2019 01:23:20 -0700 (PDT) Content-Disposition: inline In-Reply-To: <1559159944-21103-3-git-send-email-uma.shankar@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Uma Shankar Cc: Sean Paul , linux-fbdev@vger.kernel.org, dcastagna@chromium.org, jonas@kwiboo.se, Maxime Ripard , intel-gfx@lists.freedesktop.org, Bartlomiej Zolnierkiewicz , emil.l.velikov@gmail.com, dri-devel@lists.freedesktop.org, Hans Verkuil , David Airlie , seanpaul@chromium.org List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBNYXkgMzAsIDIwMTkgYXQgMDE6Mjk6MDJBTSArMDUzMCwgVW1hIFNoYW5rYXIgd3Jv dGU6Cj4gRml4ZXMgdGhlIGZvbGxvd2luZyB3YXJuaW5nczoKPiAuL2luY2x1ZGUvZHJtL2RybV9t b2RlX2NvbmZpZy5oOjg0MTogd2FybmluZzogSW5jb3JyZWN0IHVzZSBvZgo+IGtlcm5lbC1kb2Mg Zm9ybWF0OiAgICAgICAgICAqIGhkcl9vdXRwdXRfbWV0YWRhdGFfcHJvcGVydHk6IENvbm5lY3Rv cgo+IHByb3BlcnR5IGNvbnRhaW5pbmcgaGRyCj4gLi9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25m aWcuaDo5MTg6IHdhcm5pbmc6IEZ1bmN0aW9uIHBhcmFtZXRlciBvciBtZW1iZXIgJ2hkcl9vdXRw dXRfbWV0YWRhdGFfcHJvcGVydHknIG5vdCBkZXNjcmliZWQgaW4gJ2RybV9tb2RlX2NvbmZpZycK PiAuL2luY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaDoxMjUxOiB3YXJuaW5nOiBGdW5jdGlvbiBw YXJhbWV0ZXIgb3IgbWVtYmVyICdoZHJfb3V0cHV0X21ldGFkYXRhJyBub3QgZGVzY3JpYmVkIGlu ICdkcm1fY29ubmVjdG9yJwo+IC4vaW5jbHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5oOjEyNTE6IHdh cm5pbmc6IEZ1bmN0aW9uIHBhcmFtZXRlciBvciBtZW1iZXIgJ2hkcl9zaW5rX21ldGFkYXRhJyBu b3QgZGVzY3JpYmVkIGluICdkcm1fY29ubmVjdG9yJwo+IAo+IEFsc28gYWRkcyBzb21lIHByb3Bl cnR5IGRvY3VtZW50YXRpb24gZm9yIEhEUiBNZXRhZGF0YSBDb25uZWN0b3IKPiBQcm9wZXJ0eSBp biBjb25uZWN0b3IgcHJvcGVydHkgY3JlYXRlIGZ1bmN0aW9uLgo+IAo+IHYyOiBGaXhlZCBTZWFu IFBhdWwncyByZXZpZXcgY29tbWVudHMuCj4gCj4gdjM6IEZpeGVkIERhbmllbCBWZXR0ZXIncyBy ZXZpZXcgY29tbWVudHMsIGFkZGVkIHRoZSBVQVBJIHN0cnVjdHVyZQo+IGRlZmluaXRpb24gc2Vj dGlvbiBpbiBrZXJuZWwgZG9jcy4KPiAKPiBDYzogU2hhc2hhbmsgU2hhcm1hIDxzaGFzaGFuay5z aGFybWFAaW50ZWwuY29tPgo+IENjOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGlu dXguaW50ZWwuY29tPgo+IENjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RA bGludXguaW50ZWwuY29tPgo+IENjOiBNYXhpbWUgUmlwYXJkIDxtYXhpbWUucmlwYXJkQGJvb3Rs aW4uY29tPgo+IENjOiBTZWFuIFBhdWwgPHNlYW5AcG9vcmx5LnJ1bj4KPiBDYzogRGF2aWQgQWly bGllIDxhaXJsaWVkQGxpbnV4LmllPgo+IENjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWxAZmZ3bGwu Y2g+Cj4gQ2M6IEJhcnRsb21pZWogWm9sbmllcmtpZXdpY3ogPGIuem9sbmllcmtpZUBzYW1zdW5n LmNvbT4KPiBDYzogIlZpbGxlIFN5cmrDpGzDpCIgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwu Y29tPgo+IENjOiBIYW5zIFZlcmt1aWwgPGhhbnN2ZXJrQGNpc2NvLmNvbT4KPiBDYzogZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IENjOiBsaW51eC1mYmRldkB2Z2VyLmtlcm5lbC5v cmcKPiBSZXZpZXdlZC1ieTogU2VhbiBQYXVsIDxzZWFuQHBvb3JseS5ydW4+Cj4gU2lnbmVkLW9m Zi1ieTogVW1hIFNoYW5rYXIgPHVtYS5zaGFua2FyQGludGVsLmNvbT4KPiAtLS0KPiAgRG9jdW1l bnRhdGlvbi9ncHUvZHJtLXVhcGkucnN0ICB8ICA5ICsrKysrKysrKwo+ICBkcml2ZXJzL2dwdS9k cm0vZHJtX2Nvbm5lY3Rvci5jIHwgMzEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ ICBpbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmggICAgIHwgIDEgKwo+ICBpbmNsdWRlL2RybS9k cm1fbW9kZV9jb25maWcuaCAgIHwgIDQgKystLQo+ICBpbmNsdWRlL2xpbnV4L2hkbWkuaCAgICAg ICAgICAgIHwgIDEgKwo+ICBpbmNsdWRlL3VhcGkvZHJtL2RybV9tb2RlLmggICAgIHwgMzcgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQo+ICA2IGZpbGVzIGNoYW5nZWQsIDgw IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vZ3B1L2RybS11YXBpLnJzdCBiL0RvY3VtZW50YXRpb24vZ3B1L2RybS11YXBpLnJzdAo+ IGluZGV4IDA1ODc0ZDAuLjZiMzllMmMgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUv ZHJtLXVhcGkucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLXVhcGkucnN0Cj4gQEAg LTMyOSwzICszMjksMTIgQEAgRFJNX0lPQ1RMX01PREVTRVRfQ1RMCj4gICAgICBtb2RlIHNldHRp bmcsIHNpbmNlIG9uIG1hbnkgZGV2aWNlcyB0aGUgdmVydGljYWwgYmxhbmsgY291bnRlciBpcwo+ ICAgICAgcmVzZXQgdG8gMCBhdCBzb21lIHBvaW50IGR1cmluZyBtb2Rlc2V0LiBNb2Rlcm4gZHJp dmVycyBzaG91bGQgbm90Cj4gICAgICBjYWxsIHRoaXMgYW55IG1vcmUgc2luY2Ugd2l0aCBrZXJu ZWwgbW9kZSBzZXR0aW5nIGl0IGlzIGEgbm8tb3AuCj4gKwo+ICtVc2Vyc3BhY2UgQVBJIFN0cnVj dHVyZXMKPiArPT09PT09PT09PT09PT09PT09PT09PT09Cj4gKwo+ICsuLiBrZXJuZWwtZG9jOjog aW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCj4gKyAgIDpkb2M6IG92ZXJ2aWV3Cj4gKwo+ICsu LiBrZXJuZWwtZG9jOjogaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCj4gKyAgIDppbnRlcm5h bDoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9jb25uZWN0b3IuYyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fY29ubmVjdG9yLmMKPiBpbmRleCBjOWFjOGI5Li42YTkzNTI3IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fY29ubmVjdG9yLmMKPiArKysgYi9kcml2ZXJz L2dwdS9kcm0vZHJtX2Nvbm5lY3Rvci5jCj4gQEAgLTk1Niw2ICs5NTYsMzcgQEAgaW50IGRybV9k aXNwbGF5X2luZm9fc2V0X2J1c19mb3JtYXRzKHN0cnVjdCBkcm1fZGlzcGxheV9pbmZvICppbmZv LAo+ICAgKgkgIGlzIG5vIGxvbmdlciBwcm90ZWN0ZWQgYW5kIHVzZXJzcGFjZSBzaG91bGQgdGFr ZSBhcHByb3ByaWF0ZSBhY3Rpb24KPiAgICoJICAod2hhdGV2ZXIgdGhhdCBtaWdodCBiZSkuCj4g ICAqCj4gKyAqIEhEUl9PVVRQVVRfTUVUQURBVEE6Cj4gKyAqCUNvbm5lY3RvciBwcm9wZXJ0eSB0 byBlbmFibGUgdXNlcnNwYWNlIHRvIHNlbmQgSERSIE1ldGFkYXRhIHRvCj4gKyAqCWRyaXZlci4g VGhpcyBtZXRhZGF0YSBpcyBiYXNlZCBvbiB0aGUgY29tcG9zaXRpb24gYW5kIGJsZW5kaW5nCj4g KyAqCXBvbGljaWVzIGRlY2lkZWQgYnkgdXNlciwgdGFraW5nIGludG8gYWNjb3VudCB0aGUgaGFy ZHdhcmUgYW5kCj4gKyAqCXNpbmsgY2FwYWJpbGl0aWVzLiBUaGUgZHJpdmVyIGdldHMgdGhpcyBt ZXRhZGF0YSBhbmQgY3JlYXRlcyBhCj4gKyAqCUR5bmFtaWMgUmFuZ2UgYW5kIE1hc3RlcmluZyBJ bmZvZnJhbWUgKERSTSkgaW4gY2FzZSBvZiBIRE1JLAo+ICsgKglTRFAgcGFja2V0IChOb24tYXVk aW8gSU5GT0ZSQU1FIFNEUCB2MS4zKSBmb3IgRFAuIFRoaXMgaXMgdGhlbgo+ICsgKglzZW50IHRv IHNpbmsuIFRoaXMgbm90aWZpZXMgdGhlIHNpbmsgb2YgdGhlIHVwY29taW5nIGZyYW1lJ3MgQ29s b3IKPiArICoJRW5jb2RpbmcgYW5kIEx1bWluYW5jZSBwYXJhbWV0ZXJzLgo+ICsgKgo+ICsgKglV c2Vyc3BhY2UgZmlyc3QgbmVlZCB0byBkZXRlY3QgdGhlIEhEUiBjYXBhYmlsaXRpZXMgb2Ygc2lu ayBieQo+ICsgKglyZWFkaW5nIGFuZCBwYXJzaW5nIHRoZSBFRElELiBEZXRhaWxzIG9mIEhEUiBt ZXRhZGF0YSBmb3IgSERNSQo+ICsgKglhcmUgYWRkZWQgaW4gQ1RBIDg2MS5HIHNwZWMuIEZvciBE UCAsIGl0cyBkZWZpbmVkIGluIFZFU0EgRFAKPiArICoJU3RhbmRhcmQgdjEuNC4gSXQgbmVlZHMg dG8gdGhlbiBnZXQgdGhlIG1ldGFkYXRhIGluZm9ybWF0aW9uCj4gKyAqCW9mIHRoZSB2aWRlby9n YW1lL2FwcCBjb250ZW50IHdoaWNoIGFyZSBlbmNvZGVkIGluIEhEUiAoYmFzaWNhbGx5Cj4gKyAq CXVzaW5nIEhEUiB0cmFuc2ZlciBmdW5jdGlvbnMpLiBXaXRoIHRoaXMgaW5mb3JtYXRpb24gaXQg bmVlZHMgdG8KPiArICoJZGVjaWRlIG9uIGEgYmxlbmRpbmcgcG9saWN5IGFuZCBjb21wb3NlIHRo ZSByZWxldmFudAo+ICsgKglsYXllcnMvb3ZlcmxheXMgaW50byBhIGNvbW1vbiBmb3JtYXQuIE9u Y2UgdGhpcyBibGVuZGluZyBpcyBkb25lLAo+ICsgKgl1c2Vyc3BhY2Ugd2lsbCBiZSBhd2FyZSBv ZiB0aGUgbWV0YWRhdGEgb2YgdGhlIGNvbXBvc2VkIGZyYW1lIHRvCj4gKyAqCWJlIHNlbmQgdG8g c2luay4gSXQgdGhlbiB1c2VzIHRoaXMgcHJvcGVydHkgdG8gY29tbXVuaWNhdGUgdGhpcwo+ICsg KgltZXRhZGF0YSB0byBkcml2ZXIgd2hpY2ggdGhlbiBtYWtlIGEgSW5mb2ZyYW1lIHBhY2tldCBh bmQgc2VuZHMKPiArICoJdG8gc2luayBiYXNlZCBvbiB0aGUgdHlwZSBvZiBlbmNvZGVyIGNvbm5l Y3RlZC4KPiArICoKPiArICoJVXNlcnNwYWNlIHdpbGwgYmUgcmVzcG9uc2libGUgdG8gZG8gVG9u ZSBtYXBwaW5nIG9wZXJhdGlvbiBpbiBjYXNlOgo+ICsgKgkJLSBTb21lIGxheWVycyBhcmUgSERS IGFuZCBvdGhlcnMgYXJlIFNEUgo+ICsgKgkJLSBIRFIgbGF5ZXJzIGx1bWluYW5jZSBpcyBub3Qg c2FtZSBhcyBzaW5rCj4gKyAqCUl0IHdpbGwgZXZlbiBuZWVkIHRvIGRvIGNvbG9yc3BhY2UgY29u dmVyc2lvbiBhbmQgZ2V0IGFsbCBsYXllcnMKPiArICoJdG8gb25lIGNvbW1vbiBjb2xvcnNwYWNl IGZvciBibGVuZGluZy4gSXQgY2FuIHVzZSBlaXRoZXIgR0wsIE1lZGlhCj4gKyAqCW9yIGRpc3Bs YXkgZW5naW5lIHRvIGdldCB0aGlzIGRvbmUgYmFzZWQgb24gdGhlIGNhcGFiaWx0aWVzIG9mIHRo ZQo+ICsgKglhc3NvY2lhdGVkIGhhcmR3YXJlLgoKSSB0aGluayBpdCdkIGJlIGdvb2QgdG8gYWRk IDEtMiBzZW50ZW5jZXMgaGVyZSBhYm91dCB3aGF0IHRoaXMgbG9va3MgbGlrZQpmb3IgdGhlIGRy aXZlciBzaWRlLiBFLmcuIHdoaWNoIGZ1bmN0aW9uIGRyaXZlcnMgbmVlZCB0byBjYWxsIHRvIHNl dCB1cApoZHIsIGhvdyB0byBnZXQgYXQgdGhlIG1ldGFkYXRhIGFuZCB3aGV0aGVyIHRoZXJlJ3Mg YW55IGhlbHBlcnMgZm9yIHRoZXNlLgoKSGVyZSBJJ2QgcG9pbnQgYXQgaGRyX291dHB1dF9tZXRh ZGF0YSwgaGRyX3NpbmtfbWV0YWRhdGEsIGFuZApkcm1fYWRkX2Rpc3BsYXlfaW5mbygpIGZvciBm aWxsaW5nIGluIHRoZSBmb3JtZXIuCgpJIHRoaW5rIHdpdGggdGhhdCB0aGlzIGlzIGEgc29saWQg ZG9jIHBhdGNoLgoKPiArICoKPiAgICogbWF4IGJwYzoKPiAgICoJVGhpcyByYW5nZSBwcm9wZXJ0 eSBpcyB1c2VkIGJ5IHVzZXJzcGFjZSB0byBsaW1pdCB0aGUgYml0IGRlcHRoLiBXaGVuCj4gICAq CXVzZWQgdGhlIGRyaXZlciB3b3VsZCBsaW1pdCB0aGUgYnBjIGluIGFjY29yZGFuY2Ugd2l0aCB0 aGUgdmFsaWQgcmFuZ2UKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5o IGIvaW5jbHVkZS9kcm0vZHJtX2Nvbm5lY3Rvci5oCj4gaW5kZXggNTQ3NjU2MS4uNDdlNzQ5YiAx MDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmgKPiArKysgYi9pbmNsdWRl L2RybS9kcm1fY29ubmVjdG9yLmgKPiBAQCAtMTI0NCw2ICsxMjQ0LDcgQEAgc3RydWN0IGRybV9j b25uZWN0b3Igewo+ICAJICovCj4gIAlzdHJ1Y3QgbGxpc3Rfbm9kZSBmcmVlX25vZGU7Cj4gIAo+ ICsJLyoqIEBoZHJfc2lua19tZXRhZGF0YTogSERSIE1ldGFkYXRhIEluZm9ybWF0aW9uIHJlYWQg ZnJvbSBzaW5rICovCj4gIAlzdHJ1Y3QgaGRyX3NpbmtfbWV0YWRhdGEgaGRyX3NpbmtfbWV0YWRh dGE7CgpTb21ldGhpbmcgSSByZWFsaXplZCB3aGlsZSByZWFkaW5nIHRoZSBjb2RlOiBUaGlzIHNo b3VsZCBwcm9iYWJseSBiZSBwdXQKaW50byB0aGUgZHJtX2Rpc3BsYXlfaW5mbyBzdHJ1Y3QsIGxp a2UgYWxsIHRoZSBvdGhlciB0aGluZ3Mgd2UgcGFyc2Ugb3V0Cm9mIHRoZSBlZGlkLiBJIHRoaW5r IHRoYXQgd291bGQgYmUgYSBsb3QgbW9yZSBjb25zaXN0ZW50IHdpdGggdGhlIGNvZGUgLQp0aGUg ZHJpdmVyIGludGVyZmFjZSBmdW5jdGlvbiB3aGljaCBjYWxscyB0aGlzIGNvZGUgaXMgY2FsbGVk CmRybV9hZGRfZGlzcGxheV9pbmZvKCkgYWZ0ZXIgYWxsLgoKQ2FuIHlvdSBwbHMgY2hhbmdlIHRo YXQgaW4gYSBmb2xsb3ctdXAgcGF0Y2g/Cgo+ICB9Owo+ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVk ZS9kcm0vZHJtX21vZGVfY29uZmlnLmggYi9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaAo+ IGluZGV4IDRmODhjYzkuLjc1OWQ0NjIgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9kcm0vZHJtX21v ZGVfY29uZmlnLmgKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaAo+IEBAIC04 MzcsOCArODM3LDggQEAgc3RydWN0IGRybV9tb2RlX2NvbmZpZyB7Cj4gIAlzdHJ1Y3QgZHJtX3By b3BlcnR5ICp3cml0ZWJhY2tfb3V0X2ZlbmNlX3B0cl9wcm9wZXJ0eTsKPiAgCj4gIAkvKioKPiAt CSAqIGhkcl9vdXRwdXRfbWV0YWRhdGFfcHJvcGVydHk6IENvbm5lY3RvciBwcm9wZXJ0eSBjb250 YWluaW5nIGhkcgo+IC0JICogbWV0YXRkYS4gVGhpcyB3aWxsIGJlIHByb3ZpZGVkIGJ5IHVzZXJz cGFjZSBjb21wb3NpdG9ycyBiYXNlZAo+ICsJICogQGhkcl9vdXRwdXRfbWV0YWRhdGFfcHJvcGVy dHk6IENvbm5lY3RvciBwcm9wZXJ0eSBjb250YWluaW5nIGhkcgo+ICsJICogbWV0YXRhZGEuIFRo aXMgd2lsbCBiZSBwcm92aWRlZCBieSB1c2Vyc3BhY2UgY29tcG9zaXRvcnMgYmFzZWQKPiAgCSAq IG9uIEhEUiBjb250ZW50Cj4gIAkgKi8KPiAgCXN0cnVjdCBkcm1fcHJvcGVydHkgKmhkcl9vdXRw dXRfbWV0YWRhdGFfcHJvcGVydHk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaGRtaS5o IGIvaW5jbHVkZS9saW51eC9oZG1pLmgKPiBpbmRleCBlZTU1YmE1Li41NWM2ZGI1IDEwMDY0NAo+ IC0tLSBhL2luY2x1ZGUvbGludXgvaGRtaS5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9oZG1pLmgK PiBAQCAtMzk4LDYgKzM5OCw3IEBAIHNzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tf b25seShjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtCj4gICAqIEBzcGQ6 IHNwZCBpbmZvZnJhbWUKPiAgICogQHZlbmRvcjogdW5pb24gb2YgYWxsIHZlbmRvciBpbmZvZnJh bWVzCj4gICAqIEBhdWRpbzogYXVkaW8gaW5mb2ZyYW1lCj4gKyAqIEBkcm06IER5bmFtaWMgUmFu Z2UgYW5kIE1hc3RlcmluZyBpbmZvZnJhbWUKPiAgICoKPiAgICogVGhpcyBpcyB1c2VkIGJ5IHRo ZSBnZW5lcmljIHBhY2sgZnVuY3Rpb24uIFRoaXMgd29ya3Mgc2luY2UgYWxsIGluZm9mcmFtZXMK PiAgICogaGF2ZSB0aGUgc2FtZSBoZWFkZXIgd2hpY2ggYWxzbyBpbmRpY2F0ZXMgd2hpY2ggdHlw ZSBvZiBpbmZvZnJhbWUgc2hvdWxkIGJlCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9kcm0v ZHJtX21vZGUuaCBiL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUuaAo+IGluZGV4IDk5N2E3ZTAu LjVkMzk2NGYgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCj4gKysr IGIvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCj4gQEAgLTMzLDYgKzMzLDE1IEBACj4gIGV4 dGVybiAiQyIgewo+ICAjZW5kaWYKPiAgCj4gKy8qKgo+ICsgKiBET0M6IG92ZXJ2aWV3Cj4gKyAq Cj4gKyAqIERSTSBleHBvc2VzIG1hbnkgVUFQSSBhbmQgc3RydWN0dXJlIGRlZmluaXRpb24gdG8g aGF2ZSBhIGNvbnNpc3RlbnQKPiArICogYW5kIHN0YW5kYXJkaXplZCBpbnRlcmZhY2Ugd2l0aCB1 c2VyLgo+ICsgKiBVc2Vyc3BhY2UgY2FuIHJlZmVyIHRvIHRoZXNlIHN0cnVjdHVyZSBkZWZpbml0 aW9ucyBhbmQgVUFQSSBmb3JtYXRzCj4gKyAqIHRvIGNvbW11bmljYXRlIHRvIGRyaXZlcgo+ICsg Ki8KPiArCj4gICNkZWZpbmUgRFJNX0NPTk5FQ1RPUl9OQU1FX0xFTgkzMgo+ICAjZGVmaW5lIERS TV9ESVNQTEFZX01PREVfTEVOCTMyCj4gICNkZWZpbmUgRFJNX1BST1BfTkFNRV9MRU4JMzIKPiBA QCAtNjMwLDcgKzYzOSwyNiBAQCBzdHJ1Y3QgZHJtX2NvbG9yX2x1dCB7Cj4gIAlfX3UxNiByZXNl cnZlZDsKPiAgfTsKPiAgCj4gLS8qIEhEUiBNZXRhZGF0YSBJbmZvZnJhbWUgYXMgcGVyIDg2MS5H IHNwZWMgKi8KCktlZXAgdGhlIHNwZWMgcmVmZXJlbmNlIGltbywgbWF5YmUgZXZlbiBhZGQgYSBu b3RlIHRoYXQgdGhpcyBpcyBzdXBwb3NlZAp0byBwZXJmZWN0bHkgbWF0Y2ggaXQuCgo+ICsvKioK PiArICogc3RydWN0IGhkcl9tZXRhZGF0YV9pbmZvZnJhbWUgLSBIRFIgTWV0YWRhdGEgSW5mb2Zy YW1lIERhdGEuCj4gKyAqIEBlb3RmOiBFbGVjdHJvLU9wdGljYWwgVHJhbnNmZXIgRnVuY3Rpb24g KEVPVEYpIHVzZWQgaW4gdGhlIHN0cmVhbS4KPiArICogQG1ldGFkYXRhX3R5cGU6IFN0YXRpY19N ZXRhZGF0YV9EZXNjcmlwdG9yX0lELgo+ICsgKiBAZGlzcGxheV9wcmltYXJpZXM6IENvbG9yIFBy aW1hcmllcyBvZiB0aGUgRGF0YS4KPiArICogQGRpc3BsYXlfcHJpbWFyaWVzLng6IFggY29yZGlu YXRlIG9mIGNvbG9yIHByaW1hcnkuCgpXb3VsZCBiZSBnb29kIHRvIHNwZW5kIGEgZmV3IG1vcmUg d29yZHMgYWJvdXQgImluIHdoaWNoIHN0YW5kYXJkL2Zvcm1hdCIKdGhpcyBjb2xvciBudW1iZXIg aXMuIEkuZS4gZml4ZWQgcG9pbnQgb3Igd2hhdGV2ZXIsIGFuZCBjb2xvciBzcGFjZS4KCj4gKyAq IEBkaXNwbGF5X3ByaW1hcmllcy55OiBZIGNvcmRpbmF0ZSBvZiBjb2xvciBwcmltYXJ5Lgo+ICsg KiBAd2hpdGVfcG9pbnQ6IFdoaXRlIFBvaW50IG9mIENvbG9yc3BhY2UgRGF0YS4KPiArICogQHdo aXRlX3BvaW50Lng6IFggY29yZGluYXRlIG9mIHdoaXRlcG9pbnQgb2YgY29sb3IgcHJpbWFyeS4K PiArICogQHdoaXRlX3BvaW50Lnk6IFkgY29yZGluYXRlIG9mIHdoaXRlcG9pbnQgb2YgY29sb3Ig cHJpbWFyeS4KPiArICogQG1heF9kaXNwbGF5X21hc3RlcmluZ19sdW1pbmFuY2U6IE1heCBNYXN0 ZXJpbmcgRGlzcGxheSBMdW1pbmFuY2UuCj4gKyAqIEBtaW5fZGlzcGxheV9tYXN0ZXJpbmdfbHVt aW5hbmNlOiBNaW4gTWFzdGVyaW5nIERpc3BsYXkgTHVtaW5hbmNlLgo+ICsgKiBAbWF4X2NsbDog TWF4IENvbnRlbnQgTGlnaHQgTGV2ZWwuCj4gKyAqIEBtYXhfZmFsbDogTWF4IEZyYW1lIEF2ZXJh Z2UgTGlnaHQgTGV2ZWwuCgpidHcgZm9yIGxvbmcgc3RydWN0cyBJIHByZWZlciB0aGUgaW5saW5l IGtlcm5lbGRvYyBzdHlsZS4gVGhpcyBvbmUgaXMganVzdAphdCB0aGUgZWRnZSBpbW8uCgo+ICsg Kgo+ICsgKiBXaXRoIGRybSBzdWJzeXN0ZW0gdXNpbmcgc3RydWN0IGRybV9yZWN0IHRvIG1hbmFn ZSByZWN0YW5ndWxhciBhcmVhIHRoaXMKCnN0cnVjdCAmZHJtX3JlY3QgdG8gbWFrZSBpdCBhIGh5 cGVybGluay4gT25jZSB3ZSBoYXZlIGRybV9yZWN0IGRvY3VtZW50ZWQKOi0pCgo+ICsgKiBleHBv cnQgaXQgdG8gdXNlci1zcGFjZS4KPiArICoKPiArICogQ3VycmVudGx5IHVzZWQgYnkgZHJtX21v ZGVfYXRvbWljIGJsb2IgcHJvcGVydHkgRkJfREFNQUdFX0NMSVBTLgo+ICsgKi8KPiAgc3RydWN0 IGhkcl9tZXRhZGF0YV9pbmZvZnJhbWUgewo+ICAJX191OCBlb3RmOwo+ICAJX191OCBtZXRhZGF0 YV90eXBlOwo+IEBAIC02NDYsNiArNjc0LDEzIEBAIHN0cnVjdCBoZHJfbWV0YWRhdGFfaW5mb2Zy YW1lIHsKPiAgCV9fdTE2IG1heF9mYWxsOwo+ICB9Owo+ICAKPiArLyoqCj4gKyAqIHN0cnVjdCBo ZHJfb3V0cHV0X21ldGFkYXRhIC0gSERSIG91dHB1dCBtZXRhZGF0YQo+ICsgKgo+ICsgKiBNZXRh ZGF0YSBJbmZvcm1hdGlvbiB0byBiZSBwYXNzZWQgZnJvbSB1c2Vyc3BhY2UKPiArICogQG1ldGFk YXRhX3R5cGU6IFN0YXRpY19NZXRhZGF0YV9EZXNjcmlwdG9yX0lELgo+ICsgKiBAaGRtaV9tZXRh ZGF0YV90eXBlMTogSERSIE1ldGFkYXRhIEluZm9mcmFtZS4KCklmIHlvdSB3YW50IHRvIG1vdmUg dGhlIG1lbWJlciBkb2NzIGNsb3NlciB0byB0aGVpciBkZWZpbml0aW9uLCBnbyB3aXRoCnRoZSBp bmxpbmUgc3R5bGUuCgpUaGFua3MsIERhbmllbAoKPiArICovCj4gIHN0cnVjdCBoZHJfb3V0cHV0 X21ldGFkYXRhIHsKPiAgCV9fdTMyIG1ldGFkYXRhX3R5cGU7Cj4gIAl1bmlvbiB7Cj4gLS0gCj4g MS45LjEKPiAKCi0tIApEYW5pZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jw b3JhdGlvbgpodHRwOi8vYmxvZy5mZndsbC5jaApfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0 cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9kcmktZGV2ZWw=