From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755363AbeDWM7s (ORCPT ); Mon, 23 Apr 2018 08:59:48 -0400 Received: from perceval.ideasonboard.com ([213.167.242.64]:53716 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754905AbeDWM7p (ORCPT ); Mon, 23 Apr 2018 08:59:45 -0400 From: Laurent Pinchart To: jacopo mondi Cc: Peter Rosin , Jacopo Mondi , architt@codeaurora.org, a.hajda@samsung.com, airlied@linux.ie, daniel@ffwll.ch, linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, devicetree@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH 6/8] drm: rcar-du: rcar-lvds: Add bridge format support Date: Mon, 23 Apr 2018 15:59:56 +0300 Message-ID: <5001798.Des3fEuz24@avalon> Organization: Ideas on Board Oy In-Reply-To: <20180423084728.GD17088@w540> References: <1524130269-32688-1-git-send-email-jacopo+renesas@jmondi.org> <9378eadb-1dbf-ecfe-9bd1-40bec21c4648@axentia.se> <20180423084728.GD17088@w540> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hello, On Monday, 23 April 2018 11:47:28 EEST jacopo mondi wrote: > On Mon, Apr 23, 2018 at 09:59:22AM +0200, Peter Rosin wrote: > > On 2018-04-23 09:28, jacopo mondi wrote: > >> On Sun, Apr 22, 2018 at 10:08:21PM +0200, Peter Rosin wrote: > >>> On 2018-04-19 11:31, Jacopo Mondi wrote: > >>>> With the introduction of static input image format enumeration in DRM > >>>> bridges, add support to retrieve the format in rcar-lvds LVDS encoder > >>>> from both panel or bridge, to set the desired LVDS mode. > >>>> > >>>> Do not rely on 'DRM_BUS_FLAG_DATA_LSB_TO_MSB' flag to mirror the LVDS > >>>> format, as it is only defined for drm connectors, but use the newly > >>>> introduced _LE version of LVDS mbus image formats. > >>>> > >>>> Signed-off-by: Jacopo Mondi > >>>> --- > >>>> > >>>> drivers/gpu/drm/rcar-du/rcar_lvds.c | 64 +++++++++++++++++++--------- > >>>> 1 file changed, 44 insertions(+), 20 deletions(-) > >>>> > >>>> diff --git a/drivers/gpu/drm/rcar-du/rcar_lvds.c > >>>> b/drivers/gpu/drm/rcar-du/rcar_lvds.c index 3d2d3bb..2fa875f 100644 > >>>> --- a/drivers/gpu/drm/rcar-du/rcar_lvds.c > >>>> +++ b/drivers/gpu/drm/rcar-du/rcar_lvds.c > >>>> @@ -280,41 +280,65 @@ static bool rcar_lvds_mode_fixup(struct > >>>> drm_bridge *bridge, > >>>> return true; > >>>> } > >>>> > >>>> -static void rcar_lvds_get_lvds_mode(struct rcar_lvds *lvds) > >>>> +static int rcar_lvds_get_lvds_mode_from_connector(struct rcar_lvds > >>>> *lvds, > >>>> + unsigned int *bus_fmt) > >>>> { > >>>> struct drm_display_info *info = &lvds->connector.display_info; > >>>> - enum rcar_lvds_mode mode; > >>>> - > >>>> - /* > >>>> - * There is no API yet to retrieve LVDS mode from a bridge, only > >>>> panels > >>>> - * are supported. > >>>> - */ > >>>> - if (!lvds->panel) > >>>> - return; > >>>> > >>>> if (!info->num_bus_formats || !info->bus_formats) { > >>>> dev_err(lvds->dev, "no LVDS bus format reported\n"); > >>>> - return; > >>>> + return -EINVAL; > >>>> + } > >>>> + > >>>> + *bus_fmt = info->bus_formats[0]; > >>>> + > >>>> + return 0; > >>>> +} > >>>> + > >>>> +static int rcar_lvds_get_lvds_mode_from_bridge(struct rcar_lvds > >>>> *lvds, > >>>> + unsigned int *bus_fmt) > >>>> +{ > >>>> + if (!lvds->next_bridge->num_bus_formats || > >>>> + !lvds->next_bridge->bus_formats) { > >>>> + dev_err(lvds->dev, "no LVDS bus format reported\n"); > >>>> + return -EINVAL; > >>>> } > >>>> > >>>> - switch (info->bus_formats[0]) { > >>>> + *bus_fmt = lvds->next_bridge->bus_formats[0]; > >>> > >>> What makes the first reported format the best choice? > >> > >> It already was the selection 'policy' in place in this driver before > >> introducing bridge formats. As you can see from the switch I have here > >> removed, the first format was selected even when only the format > >> reported by the connector was inspected. > > > > Well, *if* some bridge/panel do support more than one format, and your > > driver depends on it being the first reported format, then I can easily > > see that some other driver also requires its expected format to be first. > > Then we might end up in a war over what format should be reported as the > > first so that this multi-input bridge/panel could be used by both drivers. In that case we would have to implement a format negotiation procedure for bridges. It won't work transparently anyway, if a bridge supports multiple formats, one will need to be selected, and the bridge hardware will need to be configured accordingly. I don't think this is a problem for now. The bridge we're using reports a single format, as it supports a single format at the hardware level. If an LVDS decoder accepting multiple formats later needs to be supported I'd be happy to participate in the design of a bridge format negotiation procedure and API. > >> And, anyway, as DRM lacks a format negotiation API, there is no way to > >> tell a bridge/panel "use this format instead of this other one" (which > >> makes me wonders why more formats can be reported, but the > >> bus_formats[] helpers for connectors allow that, so I thought it made > >> sense to do the same for bridges). > > > > Since there is no way to negotiate, I would assume that the other end > > really does support all reported formats (in some automagical way). In practice it does, because it supports a single format. Selection is thus pretty easy :-) > > To me, the only sensible approach is to loop over the formats and see if > > *any* of them fits, and assume that something else deals with the > > details. > > I see. I agree looping may be a better way of handling this actually... I don't think so, for the reasons explained above. If the bridge supports multiple incompatible formats we will need to select one of them and configure the bridge hardware appropriately. There is no magic autoselection, so looping won't help, we will need more than that. Using the first first is thus good enough here. Let's not forget that this patch is against the internal LVDS encoder driver, so we're guaranteed that the next bridge in the chain accepts LVDS. This limits the cases that need to be supported for now. > >>>> + > >>>> + return 0; > >>>> +} > >>>> + > >>>> +static void rcar_lvds_get_lvds_mode(struct rcar_lvds *lvds) > >>>> +{ > >>>> + unsigned int bus_fmt; > >>>> + int ret; > >>>> + > >>>> + if (lvds->panel) > >>>> + ret = rcar_lvds_get_lvds_mode_from_connector(lvds, &bus_fmt); > >>>> + else > >>>> + ret = rcar_lvds_get_lvds_mode_from_bridge(lvds, &bus_fmt); > >>> > >>> What if no bridge reports any format, shouldn't the connector be > >>> examined then? > >> > >> There is no fallback selection policy at the moment as you can see, or > >> either, as it was before, the LVDS mode is not set for the rcar_lvds > >> component if it's not reported by the next element in the pipeline (and > >> I should probably return 0, not an error here in that case). > >> > >> The connector associated with a panel is only inspected if it's next in > >> the pipeline. > > > > But by not going to the connector for the case where no bridge in the > > pipeline has any info on the format, you effectively demand that at > > least some bridge in the pipeline should report supported input > > format(s). That excludes a lot of existing bridge combinations from > > being used. Or do you see it as a requirement that bridges must > > report their supported input formats? Perhaps only when used with > > this driver? We demand that the next component in the chain, bridge or panel, reports the LVDS mode it requires through the bus format API. I don't think that's an issue, if we later need to use a different bridge that doesn't comply with this requirement (is there even other LVDS decoder bridge drivers in mainline ?) then we'll implement bus format support in that bridge driver. It will not break any existing platform. Looking at the connector won't help as the connector will likely not report an LVDS bus format if there's an LVDS decoder bridge in the chain. However, given that the Lager board currently uses a DT hack and connects the DU LVDS output to an HDMI encoder without modeling the on-board LVDS decoder in DT, we need to ensure that backward compatibility is preserved by not returning a fatal error if the next bridge doesn't report bus formats. > That's a point that should be discussed imho. > > Daniel in his reply to your original series suggested format should be > reported by bridges when they get registered [1]. I have not enforced that > though, as it requires all mainline bridge drivers (which are not that > many -yet-) to register a format before bridge_add(). If there is > consensus on this, all other drivers should be updated (I'm not even > sure it is possible for all of them honestly). I wouldn't make it mandatory yet, because I'm also not sure if all bridges accept a single input format. > Anyway, the only thing I'm sure is that I don't want to make this > driver 'special', I would prefer that in case format is not there, > we'll ignore the LVDS mode configuration as it was before this series. Yes, that seems the best option to me. You can print a warning message to ensure that DT and/or bridge drivers gets updated, but we should default to the same LVDS mode as before. > [1] https://lkml.org/lkml/2018/4/4/50 > > >>>> + if (ret) > >>>> + return; > >>>> + > >>>> + switch (bus_fmt) { > >>>> + case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG_LE: > >>>> + case MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA_LE: > >>>> + lvds->mode |= RCAR_LVDS_MODE_MIRROR; > >>>> > >>>> case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG: > >>>> > >>>> case MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA: > >>>> - mode = RCAR_LVDS_MODE_JEIDA; > >>>> + lvds->mode = RCAR_LVDS_MODE_JEIDA; > >>> > >>> This is b0rken, first the mirror bit is ORed into some unknown > >>> preexisting value, then the code falls through (without any fall > >>> through comment, btw) and forcibly sets the mode, thus discarding the > >>> mirror bit which was carefully ORed in. > >> > >> You are correct, the second assignment should have been an |= and not > >> a plain assignment. The variable is 0ed though, as 'struct rcar_lvds > >> *lvds' is kzalloc-ed in probe function. > > > > The code would be clearer if you explicitly zeroed the mode in this > > function. Or do you rely on this function to not clobber other bits? > > In that case apply some bit-mask. > > > >>>> break; > >>>> + > >>>> + case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG_LE: > >>>> + lvds->mode |= RCAR_LVDS_MODE_MIRROR; > >>>> > >>>> case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG: > >>>> - mode = RCAR_LVDS_MODE_VESA; > >>>> + lvds->mode = RCAR_LVDS_MODE_VESA; > >>> > >>> Dito. > >>> > >>>> break; > >>>> > >>>> default: > >>>> dev_err(lvds->dev, "unsupported LVDS bus format 0x%04x\n", > >>>> - info->bus_formats[0]); > >>>> - return; > >>>> + bus_fmt); > >>>> } > >>>> - > >>>> - if (info->bus_flags & DRM_BUS_FLAG_DATA_LSB_TO_MSB) > >>>> - mode |= RCAR_LVDS_MODE_MIRROR; > >>>> - > >>>> - lvds->mode = mode; > >>>> } > >>>> > >>>> static void rcar_lvds_mode_set(struct drm_bridge *bridge, -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH 6/8] drm: rcar-du: rcar-lvds: Add bridge format support Date: Mon, 23 Apr 2018 15:59:56 +0300 Message-ID: <5001798.Des3fEuz24@avalon> References: <1524130269-32688-1-git-send-email-jacopo+renesas@jmondi.org> <9378eadb-1dbf-ecfe-9bd1-40bec21c4648@axentia.se> <20180423084728.GD17088@w540> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180423084728.GD17088@w540> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: jacopo mondi Cc: devicetree@vger.kernel.org, airlied@linux.ie, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, Jacopo Mondi , Peter Rosin , linux-media@vger.kernel.org List-Id: devicetree@vger.kernel.org SGVsbG8sCgpPbiBNb25kYXksIDIzIEFwcmlsIDIwMTggMTE6NDc6MjggRUVTVCBqYWNvcG8gbW9u ZGkgd3JvdGU6Cj4gT24gTW9uLCBBcHIgMjMsIDIwMTggYXQgMDk6NTk6MjJBTSArMDIwMCwgUGV0 ZXIgUm9zaW4gd3JvdGU6Cj4gPiBPbiAyMDE4LTA0LTIzIDA5OjI4LCBqYWNvcG8gbW9uZGkgd3Jv dGU6Cj4gPj4gT24gU3VuLCBBcHIgMjIsIDIwMTggYXQgMTA6MDg6MjFQTSArMDIwMCwgUGV0ZXIg Um9zaW4gd3JvdGU6Cj4gPj4+IE9uIDIwMTgtMDQtMTkgMTE6MzEsIEphY29wbyBNb25kaSB3cm90 ZToKPiA+Pj4+IFdpdGggdGhlIGludHJvZHVjdGlvbiBvZiBzdGF0aWMgaW5wdXQgaW1hZ2UgZm9y bWF0IGVudW1lcmF0aW9uIGluIERSTQo+ID4+Pj4gYnJpZGdlcywgYWRkIHN1cHBvcnQgdG8gcmV0 cmlldmUgdGhlIGZvcm1hdCBpbiByY2FyLWx2ZHMgTFZEUyBlbmNvZGVyCj4gPj4+PiBmcm9tIGJv dGggcGFuZWwgb3IgYnJpZGdlLCB0byBzZXQgdGhlIGRlc2lyZWQgTFZEUyBtb2RlLgo+ID4+Pj4g Cj4gPj4+PiBEbyBub3QgcmVseSBvbiAnRFJNX0JVU19GTEFHX0RBVEFfTFNCX1RPX01TQicgZmxh ZyB0byBtaXJyb3IgdGhlIExWRFMKPiA+Pj4+IGZvcm1hdCwgYXMgaXQgaXMgb25seSBkZWZpbmVk IGZvciBkcm0gY29ubmVjdG9ycywgYnV0IHVzZSB0aGUgbmV3bHkKPiA+Pj4+IGludHJvZHVjZWQg X0xFIHZlcnNpb24gb2YgTFZEUyBtYnVzIGltYWdlIGZvcm1hdHMuCj4gPj4+PiAKPiA+Pj4+IFNp Z25lZC1vZmYtYnk6IEphY29wbyBNb25kaSA8amFjb3BvK3JlbmVzYXNAam1vbmRpLm9yZz4KPiA+ Pj4+IC0tLQo+ID4+Pj4gCj4gPj4+PiAgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9sdmRz LmMgfCA2NCArKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCj4gPj4+PiAgMSBmaWxlIGNoYW5n ZWQsIDQ0IGluc2VydGlvbnMoKyksIDIwIGRlbGV0aW9ucygtKQo+ID4+Pj4gCj4gPj4+PiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9sdmRzLmMKPiA+Pj4+IGIvZHJp dmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9sdmRzLmMgaW5kZXggM2QyZDNiYi4uMmZhODc1ZiAx MDA2NDQKPiA+Pj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfbHZkcy5jCj4g Pj4+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2x2ZHMuYwo+ID4+Pj4gQEAg LTI4MCw0MSArMjgwLDY1IEBAIHN0YXRpYyBib29sIHJjYXJfbHZkc19tb2RlX2ZpeHVwKHN0cnVj dAo+ID4+Pj4gZHJtX2JyaWRnZSAqYnJpZGdlLAo+ID4+Pj4gIAlyZXR1cm4gdHJ1ZTsKPiA+Pj4+ ICB9Cj4gPj4+PiAKPiA+Pj4+IC1zdGF0aWMgdm9pZCByY2FyX2x2ZHNfZ2V0X2x2ZHNfbW9kZShz dHJ1Y3QgcmNhcl9sdmRzICpsdmRzKQo+ID4+Pj4gK3N0YXRpYyBpbnQgcmNhcl9sdmRzX2dldF9s dmRzX21vZGVfZnJvbV9jb25uZWN0b3Ioc3RydWN0IHJjYXJfbHZkcwo+ID4+Pj4gKmx2ZHMsCj4g Pj4+PiArCQkJCQkJICB1bnNpZ25lZCBpbnQgKmJ1c19mbXQpCj4gPj4+PiAgewo+ID4+Pj4gIAlz dHJ1Y3QgZHJtX2Rpc3BsYXlfaW5mbyAqaW5mbyA9ICZsdmRzLT5jb25uZWN0b3IuZGlzcGxheV9p bmZvOwo+ID4+Pj4gLQllbnVtIHJjYXJfbHZkc19tb2RlIG1vZGU7Cj4gPj4+PiAtCj4gPj4+PiAt CS8qCj4gPj4+PiAtCSAqIFRoZXJlIGlzIG5vIEFQSSB5ZXQgdG8gcmV0cmlldmUgTFZEUyBtb2Rl IGZyb20gYSBicmlkZ2UsIG9ubHkKPiA+Pj4+IHBhbmVscwo+ID4+Pj4gLQkgKiBhcmUgc3VwcG9y dGVkLgo+ID4+Pj4gLQkgKi8KPiA+Pj4+IC0JaWYgKCFsdmRzLT5wYW5lbCkKPiA+Pj4+IC0JCXJl dHVybjsKPiA+Pj4+IAo+ID4+Pj4gIAlpZiAoIWluZm8tPm51bV9idXNfZm9ybWF0cyB8fCAhaW5m by0+YnVzX2Zvcm1hdHMpIHsKPiA+Pj4+ICAJCWRldl9lcnIobHZkcy0+ZGV2LCAibm8gTFZEUyBi dXMgZm9ybWF0IHJlcG9ydGVkXG4iKTsKPiA+Pj4+IC0JCXJldHVybjsKPiA+Pj4+ICsJCXJldHVy biAtRUlOVkFMOwo+ID4+Pj4gKwl9Cj4gPj4+PiArCj4gPj4+PiArCSpidXNfZm10ID0gaW5mby0+ YnVzX2Zvcm1hdHNbMF07Cj4gPj4+PiArCj4gPj4+PiArCXJldHVybiAwOwo+ID4+Pj4gK30KPiA+ Pj4+ICsKPiA+Pj4+ICtzdGF0aWMgaW50IHJjYXJfbHZkc19nZXRfbHZkc19tb2RlX2Zyb21fYnJp ZGdlKHN0cnVjdCByY2FyX2x2ZHMKPiA+Pj4+ICpsdmRzLAo+ID4+Pj4gKwkJCQkJICAgICAgIHVu c2lnbmVkIGludCAqYnVzX2ZtdCkKPiA+Pj4+ICt7Cj4gPj4+PiArCWlmICghbHZkcy0+bmV4dF9i cmlkZ2UtPm51bV9idXNfZm9ybWF0cyB8fAo+ID4+Pj4gKwkgICAgIWx2ZHMtPm5leHRfYnJpZGdl LT5idXNfZm9ybWF0cykgewo+ID4+Pj4gKwkJZGV2X2VycihsdmRzLT5kZXYsICJubyBMVkRTIGJ1 cyBmb3JtYXQgcmVwb3J0ZWRcbiIpOwo+ID4+Pj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gPj4+PiAg CX0KPiA+Pj4+IAo+ID4+Pj4gLQlzd2l0Y2ggKGluZm8tPmJ1c19mb3JtYXRzWzBdKSB7Cj4gPj4+ PiArCSpidXNfZm10ID0gbHZkcy0+bmV4dF9icmlkZ2UtPmJ1c19mb3JtYXRzWzBdOwo+ID4+PiAK PiA+Pj4gV2hhdCBtYWtlcyB0aGUgZmlyc3QgcmVwb3J0ZWQgZm9ybWF0IHRoZSBiZXN0IGNob2lj ZT8KPiA+PiAKPiA+PiBJdCBhbHJlYWR5IHdhcyB0aGUgc2VsZWN0aW9uICdwb2xpY3knIGluIHBs YWNlIGluIHRoaXMgZHJpdmVyIGJlZm9yZQo+ID4+IGludHJvZHVjaW5nIGJyaWRnZSBmb3JtYXRz LiBBcyB5b3UgY2FuIHNlZSBmcm9tIHRoZSBzd2l0Y2ggSSBoYXZlIGhlcmUKPiA+PiByZW1vdmVk LCB0aGUgZmlyc3QgZm9ybWF0IHdhcyBzZWxlY3RlZCBldmVuIHdoZW4gb25seSB0aGUgZm9ybWF0 Cj4gPj4gcmVwb3J0ZWQgYnkgdGhlIGNvbm5lY3RvciB3YXMgaW5zcGVjdGVkLgo+ID4gCj4gPiBX ZWxsLCAqaWYqIHNvbWUgYnJpZGdlL3BhbmVsIGRvIHN1cHBvcnQgbW9yZSB0aGFuIG9uZSBmb3Jt YXQsIGFuZCB5b3VyCj4gPiBkcml2ZXIgZGVwZW5kcyBvbiBpdCBiZWluZyB0aGUgZmlyc3QgcmVw b3J0ZWQgZm9ybWF0LCB0aGVuIEkgY2FuIGVhc2lseQo+ID4gc2VlIHRoYXQgc29tZSBvdGhlciBk cml2ZXIgYWxzbyByZXF1aXJlcyBpdHMgZXhwZWN0ZWQgZm9ybWF0IHRvIGJlIGZpcnN0Lgo+ID4g VGhlbiB3ZSBtaWdodCBlbmQgdXAgaW4gYSB3YXIgb3ZlciB3aGF0IGZvcm1hdCBzaG91bGQgYmUg cmVwb3J0ZWQgYXMgdGhlCj4gPiBmaXJzdCBzbyB0aGF0IHRoaXMgbXVsdGktaW5wdXQgYnJpZGdl L3BhbmVsIGNvdWxkIGJlIHVzZWQgYnkgYm90aCBkcml2ZXJzLgoKSW4gdGhhdCBjYXNlIHdlIHdv dWxkIGhhdmUgdG8gaW1wbGVtZW50IGEgZm9ybWF0IG5lZ290aWF0aW9uIHByb2NlZHVyZSBmb3Ig CmJyaWRnZXMuIEl0IHdvbid0IHdvcmsgdHJhbnNwYXJlbnRseSBhbnl3YXksIGlmIGEgYnJpZGdl IHN1cHBvcnRzIG11bHRpcGxlIApmb3JtYXRzLCBvbmUgd2lsbCBuZWVkIHRvIGJlIHNlbGVjdGVk LCBhbmQgdGhlIGJyaWRnZSBoYXJkd2FyZSB3aWxsIG5lZWQgdG8gYmUgCmNvbmZpZ3VyZWQgYWNj b3JkaW5nbHkuCgpJIGRvbid0IHRoaW5rIHRoaXMgaXMgYSBwcm9ibGVtIGZvciBub3cuIFRoZSBi cmlkZ2Ugd2UncmUgdXNpbmcgcmVwb3J0cyBhIApzaW5nbGUgZm9ybWF0LCBhcyBpdCBzdXBwb3J0 cyBhIHNpbmdsZSBmb3JtYXQgYXQgdGhlIGhhcmR3YXJlIGxldmVsLiBJZiBhbiAKTFZEUyBkZWNv ZGVyIGFjY2VwdGluZyBtdWx0aXBsZSBmb3JtYXRzIGxhdGVyIG5lZWRzIHRvIGJlIHN1cHBvcnRl ZCBJJ2QgYmUgCmhhcHB5IHRvIHBhcnRpY2lwYXRlIGluIHRoZSBkZXNpZ24gb2YgYSBicmlkZ2Ug Zm9ybWF0IG5lZ290aWF0aW9uIHByb2NlZHVyZSAKYW5kIEFQSS4KCj4gPj4gQW5kLCBhbnl3YXks IGFzIERSTSBsYWNrcyBhIGZvcm1hdCBuZWdvdGlhdGlvbiBBUEksIHRoZXJlIGlzIG5vIHdheSB0 bwo+ID4+IHRlbGwgYSBicmlkZ2UvcGFuZWwgInVzZSB0aGlzIGZvcm1hdCBpbnN0ZWFkIG9mIHRo aXMgb3RoZXIgb25lIiAod2hpY2gKPiA+PiBtYWtlcyBtZSB3b25kZXJzIHdoeSBtb3JlIGZvcm1h dHMgY2FuIGJlIHJlcG9ydGVkLCBidXQgdGhlCj4gPj4gYnVzX2Zvcm1hdHNbXSBoZWxwZXJzIGZv ciBjb25uZWN0b3JzIGFsbG93IHRoYXQsIHNvIEkgdGhvdWdodCBpdCBtYWRlCj4gPj4gc2Vuc2Ug dG8gZG8gdGhlIHNhbWUgZm9yIGJyaWRnZXMpLgo+ID4gCj4gPiBTaW5jZSB0aGVyZSBpcyBubyB3 YXkgdG8gbmVnb3RpYXRlLCBJIHdvdWxkIGFzc3VtZSB0aGF0IHRoZSBvdGhlciBlbmQKPiA+IHJl YWxseSBkb2VzIHN1cHBvcnQgYWxsIHJlcG9ydGVkIGZvcm1hdHMgKGluIHNvbWUgYXV0b21hZ2lj YWwgd2F5KS4KCkluIHByYWN0aWNlIGl0IGRvZXMsIGJlY2F1c2UgaXQgc3VwcG9ydHMgYSBzaW5n bGUgZm9ybWF0LiBTZWxlY3Rpb24gaXMgdGh1cyAKcHJldHR5IGVhc3kgOi0pCgo+ID4gVG8gbWUs IHRoZSBvbmx5IHNlbnNpYmxlIGFwcHJvYWNoIGlzIHRvIGxvb3Agb3ZlciB0aGUgZm9ybWF0cyBh bmQgc2VlIGlmCj4gPiAqYW55KiBvZiB0aGVtIGZpdHMsIGFuZCBhc3N1bWUgdGhhdCBzb21ldGhp bmcgZWxzZTx0bT4gZGVhbHMgd2l0aCB0aGUKPiA+IGRldGFpbHMuCj4gCj4gSSBzZWUuIEkgYWdy ZWUgbG9vcGluZyBtYXkgYmUgYSBiZXR0ZXIgd2F5IG9mIGhhbmRsaW5nIHRoaXMgYWN0dWFsbHku Li4KCkkgZG9uJ3QgdGhpbmsgc28sIGZvciB0aGUgcmVhc29ucyBleHBsYWluZWQgYWJvdmUuIElm IHRoZSBicmlkZ2Ugc3VwcG9ydHMgCm11bHRpcGxlIGluY29tcGF0aWJsZSBmb3JtYXRzIHdlIHdp bGwgbmVlZCB0byBzZWxlY3Qgb25lIG9mIHRoZW0gYW5kIGNvbmZpZ3VyZSAKdGhlIGJyaWRnZSBo YXJkd2FyZSBhcHByb3ByaWF0ZWx5LiBUaGVyZSBpcyBubyBtYWdpYyBhdXRvc2VsZWN0aW9uLCBz byBsb29waW5nIAp3b24ndCBoZWxwLCB3ZSB3aWxsIG5lZWQgbW9yZSB0aGFuIHRoYXQuIFVzaW5n IHRoZSBmaXJzdCBmaXJzdCBpcyB0aHVzIGdvb2QgCmVub3VnaCBoZXJlLiBMZXQncyBub3QgZm9y Z2V0IHRoYXQgdGhpcyBwYXRjaCBpcyBhZ2FpbnN0IHRoZSBpbnRlcm5hbCBMVkRTIAplbmNvZGVy IGRyaXZlciwgc28gd2UncmUgZ3VhcmFudGVlZCB0aGF0IHRoZSBuZXh0IGJyaWRnZSBpbiB0aGUg Y2hhaW4gYWNjZXB0cyAKTFZEUy4gVGhpcyBsaW1pdHMgdGhlIGNhc2VzIHRoYXQgbmVlZCB0byBi ZSBzdXBwb3J0ZWQgZm9yIG5vdy4KCj4gPj4+PiArCj4gPj4+PiArCXJldHVybiAwOwo+ID4+Pj4g K30KPiA+Pj4+ICsKPiA+Pj4+ICtzdGF0aWMgdm9pZCByY2FyX2x2ZHNfZ2V0X2x2ZHNfbW9kZShz dHJ1Y3QgcmNhcl9sdmRzICpsdmRzKQo+ID4+Pj4gK3sKPiA+Pj4+ICsJdW5zaWduZWQgaW50IGJ1 c19mbXQ7Cj4gPj4+PiArCWludCByZXQ7Cj4gPj4+PiArCj4gPj4+PiArCWlmIChsdmRzLT5wYW5l bCkKPiA+Pj4+ICsJCXJldCA9IHJjYXJfbHZkc19nZXRfbHZkc19tb2RlX2Zyb21fY29ubmVjdG9y KGx2ZHMsICZidXNfZm10KTsKPiA+Pj4+ICsJZWxzZQo+ID4+Pj4gKwkJcmV0ID0gcmNhcl9sdmRz X2dldF9sdmRzX21vZGVfZnJvbV9icmlkZ2UobHZkcywgJmJ1c19mbXQpOwo+ID4+PiAKPiA+Pj4g V2hhdCBpZiBubyBicmlkZ2UgcmVwb3J0cyBhbnkgZm9ybWF0LCBzaG91bGRuJ3QgdGhlIGNvbm5l Y3RvciBiZQo+ID4+PiBleGFtaW5lZCB0aGVuPwo+ID4+IAo+ID4+IFRoZXJlIGlzIG5vIGZhbGxi YWNrIHNlbGVjdGlvbiBwb2xpY3kgYXQgdGhlIG1vbWVudCBhcyB5b3UgY2FuIHNlZSwgb3IKPiA+ PiBlaXRoZXIsIGFzIGl0IHdhcyBiZWZvcmUsIHRoZSBMVkRTIG1vZGUgaXMgbm90IHNldCBmb3Ig dGhlIHJjYXJfbHZkcwo+ID4+IGNvbXBvbmVudCAgaWYgaXQncyBub3QgcmVwb3J0ZWQgYnkgdGhl IG5leHQgZWxlbWVudCBpbiB0aGUgcGlwZWxpbmUgKGFuZAo+ID4+IEkgc2hvdWxkIHByb2JhYmx5 IHJldHVybiAwLCBub3QgYW4gZXJyb3IgaGVyZSBpbiB0aGF0IGNhc2UpLgo+ID4+IAo+ID4+IFRo ZSBjb25uZWN0b3IgYXNzb2NpYXRlZCB3aXRoIGEgcGFuZWwgaXMgb25seSBpbnNwZWN0ZWQgaWYg aXQncyBuZXh0IGluCj4gPj4gdGhlIHBpcGVsaW5lLgo+ID4gCj4gPiBCdXQgYnkgbm90IGdvaW5n IHRvIHRoZSBjb25uZWN0b3IgZm9yIHRoZSBjYXNlIHdoZXJlIG5vIGJyaWRnZSBpbiB0aGUKPiA+ IHBpcGVsaW5lIGhhcyBhbnkgaW5mbyBvbiB0aGUgZm9ybWF0LCB5b3UgZWZmZWN0aXZlbHkgZGVt YW5kIHRoYXQgYXQKPiA+IGxlYXN0IHNvbWUgYnJpZGdlIGluIHRoZSBwaXBlbGluZSBzaG91bGQg cmVwb3J0IHN1cHBvcnRlZCBpbnB1dAo+ID4gZm9ybWF0KHMpLiBUaGF0IGV4Y2x1ZGVzIGEgbG90 IG9mIGV4aXN0aW5nIGJyaWRnZSBjb21iaW5hdGlvbnMgZnJvbQo+ID4gYmVpbmcgdXNlZC4gT3Ig ZG8geW91IHNlZSBpdCBhcyBhIHJlcXVpcmVtZW50IHRoYXQgYnJpZGdlcyBtdXN0Cj4gPiByZXBv cnQgdGhlaXIgc3VwcG9ydGVkIGlucHV0IGZvcm1hdHM/IFBlcmhhcHMgb25seSB3aGVuIHVzZWQg d2l0aAo+ID4gdGhpcyBkcml2ZXI/CgpXZSBkZW1hbmQgdGhhdCB0aGUgbmV4dCBjb21wb25lbnQg aW4gdGhlIGNoYWluLCBicmlkZ2Ugb3IgcGFuZWwsIHJlcG9ydHMgdGhlIApMVkRTIG1vZGUgaXQg cmVxdWlyZXMgdGhyb3VnaCB0aGUgYnVzIGZvcm1hdCBBUEkuIEkgZG9uJ3QgdGhpbmsgdGhhdCdz IGFuIAppc3N1ZSwgaWYgd2UgbGF0ZXIgbmVlZCB0byB1c2UgYSBkaWZmZXJlbnQgYnJpZGdlIHRo YXQgZG9lc24ndCBjb21wbHkgd2l0aCAKdGhpcyByZXF1aXJlbWVudCAoaXMgdGhlcmUgZXZlbiBv dGhlciBMVkRTIGRlY29kZXIgYnJpZGdlIGRyaXZlcnMgaW4gbWFpbmxpbmUgCj8pIHRoZW4gd2Un bGwgaW1wbGVtZW50IGJ1cyBmb3JtYXQgc3VwcG9ydCBpbiB0aGF0IGJyaWRnZSBkcml2ZXIuIEl0 IHdpbGwgbm90IApicmVhayBhbnkgZXhpc3RpbmcgcGxhdGZvcm0uCgpMb29raW5nIGF0IHRoZSBj b25uZWN0b3Igd29uJ3QgaGVscCBhcyB0aGUgY29ubmVjdG9yIHdpbGwgbGlrZWx5IG5vdCByZXBv cnQgYW4gCkxWRFMgYnVzIGZvcm1hdCBpZiB0aGVyZSdzIGFuIExWRFMgZGVjb2RlciBicmlkZ2Ug aW4gdGhlIGNoYWluLgoKSG93ZXZlciwgZ2l2ZW4gdGhhdCB0aGUgTGFnZXIgYm9hcmQgY3VycmVu dGx5IHVzZXMgYSBEVCBoYWNrIGFuZCBjb25uZWN0cyB0aGUgCkRVIExWRFMgb3V0cHV0IHRvIGFu IEhETUkgZW5jb2RlciB3aXRob3V0IG1vZGVsaW5nIHRoZSBvbi1ib2FyZCBMVkRTIGRlY29kZXIg CmluIERULCB3ZSBuZWVkIHRvIGVuc3VyZSB0aGF0IGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgaXMg cHJlc2VydmVkIGJ5IG5vdCAKcmV0dXJuaW5nIGEgZmF0YWwgZXJyb3IgaWYgdGhlIG5leHQgYnJp ZGdlIGRvZXNuJ3QgcmVwb3J0IGJ1cyBmb3JtYXRzLgoKPiBUaGF0J3MgYSBwb2ludCB0aGF0IHNo b3VsZCBiZSBkaXNjdXNzZWQgaW1oby4KPiAKPiBEYW5pZWwgaW4gaGlzIHJlcGx5IHRvIHlvdXIg b3JpZ2luYWwgc2VyaWVzIHN1Z2dlc3RlZCBmb3JtYXQgc2hvdWxkIGJlCj4gcmVwb3J0ZWQgYnkg YnJpZGdlcyB3aGVuIHRoZXkgZ2V0IHJlZ2lzdGVyZWQgWzFdLiBJIGhhdmUgbm90IGVuZm9yY2Vk IHRoYXQKPiB0aG91Z2gsIGFzIGl0IHJlcXVpcmVzIGFsbCBtYWlubGluZSBicmlkZ2UgZHJpdmVy cyAod2hpY2ggYXJlIG5vdCB0aGF0Cj4gbWFueSAteWV0LSkgdG8gcmVnaXN0ZXIgYSBmb3JtYXQg YmVmb3JlIGJyaWRnZV9hZGQoKS4gSWYgdGhlcmUgaXMKPiBjb25zZW5zdXMgb24gdGhpcywgYWxs IG90aGVyIGRyaXZlcnMgc2hvdWxkIGJlIHVwZGF0ZWQgKEknbSBub3QgZXZlbgo+IHN1cmUgaXQg aXMgcG9zc2libGUgZm9yIGFsbCBvZiB0aGVtIGhvbmVzdGx5KS4KCkkgd291bGRuJ3QgbWFrZSBp dCBtYW5kYXRvcnkgeWV0LCBiZWNhdXNlIEknbSBhbHNvIG5vdCBzdXJlIGlmIGFsbCBicmlkZ2Vz IAphY2NlcHQgYSBzaW5nbGUgaW5wdXQgZm9ybWF0LgoKPiBBbnl3YXksIHRoZSBvbmx5IHRoaW5n IEknbSBzdXJlIGlzIHRoYXQgSSBkb24ndCB3YW50IHRvIG1ha2UgdGhpcwo+IGRyaXZlciAnc3Bl Y2lhbCcsIEkgd291bGQgcHJlZmVyIHRoYXQgaW4gY2FzZSBmb3JtYXQgaXMgbm90IHRoZXJlLAo+ IHdlJ2xsIGlnbm9yZSB0aGUgTFZEUyBtb2RlIGNvbmZpZ3VyYXRpb24gYXMgaXQgd2FzIGJlZm9y ZSB0aGlzIHNlcmllcy4KClllcywgdGhhdCBzZWVtcyB0aGUgYmVzdCBvcHRpb24gdG8gbWUuIFlv dSBjYW4gcHJpbnQgYSB3YXJuaW5nIG1lc3NhZ2UgdG8gCmVuc3VyZSB0aGF0IERUIGFuZC9vciBi cmlkZ2UgZHJpdmVycyBnZXRzIHVwZGF0ZWQsIGJ1dCB3ZSBzaG91bGQgZGVmYXVsdCB0byAKdGhl IHNhbWUgTFZEUyBtb2RlIGFzIGJlZm9yZS4KCj4gWzFdIGh0dHBzOi8vbGttbC5vcmcvbGttbC8y MDE4LzQvNC81MAo+IAo+ID4+Pj4gKwlpZiAocmV0KQo+ID4+Pj4gKwkJcmV0dXJuOwo+ID4+Pj4g Kwo+ID4+Pj4gKwlzd2l0Y2ggKGJ1c19mbXQpIHsKPiA+Pj4+ICsJY2FzZSBNRURJQV9CVVNfRk1U X1JHQjY2Nl8xWDdYM19TUFdHX0xFOgo+ID4+Pj4gKwljYXNlIE1FRElBX0JVU19GTVRfUkdCODg4 XzFYN1g0X0pFSURBX0xFOgo+ID4+Pj4gKwkJbHZkcy0+bW9kZSB8PSBSQ0FSX0xWRFNfTU9ERV9N SVJST1I7Cj4gPj4+PiAKPiA+Pj4+ICAJY2FzZSBNRURJQV9CVVNfRk1UX1JHQjY2Nl8xWDdYM19T UFdHOgo+ID4+Pj4gCj4gPj4+PiAgCWNhc2UgTUVESUFfQlVTX0ZNVF9SR0I4ODhfMVg3WDRfSkVJ REE6Cj4gPj4+PiAtCQltb2RlID0gUkNBUl9MVkRTX01PREVfSkVJREE7Cj4gPj4+PiArCQlsdmRz LT5tb2RlID0gUkNBUl9MVkRTX01PREVfSkVJREE7Cj4gPj4+IAo+ID4+PiBUaGlzIGlzIGIwcmtl biwgZmlyc3QgdGhlIG1pcnJvciBiaXQgaXMgT1JlZCBpbnRvIHNvbWUgdW5rbm93bgo+ID4+PiBw cmVleGlzdGluZyB2YWx1ZSwgdGhlbiB0aGUgY29kZSBmYWxscyB0aHJvdWdoICh3aXRob3V0IGFu eSBmYWxsCj4gPj4+IHRocm91Z2ggY29tbWVudCwgYnR3KSBhbmQgZm9yY2libHkgc2V0cyB0aGUg bW9kZSwgdGh1cyBkaXNjYXJkaW5nIHRoZQo+ID4+PiBtaXJyb3IgYml0IHdoaWNoIHdhcyBjYXJl ZnVsbHkgT1JlZCBpbi4KPiA+PiAKPiA+PiBZb3UgYXJlIGNvcnJlY3QsIHRoZSBzZWNvbmQgYXNz aWdubWVudCBzaG91bGQgaGF2ZSBiZWVuIGFuIHw9IGFuZCBub3QKPiA+PiBhIHBsYWluIGFzc2ln bm1lbnQuIFRoZSB2YXJpYWJsZSBpcyAwZWQgdGhvdWdoLCBhcyAnc3RydWN0IHJjYXJfbHZkcwo+ ID4+ICpsdmRzJyBpcyBremFsbG9jLWVkIGluIHByb2JlIGZ1bmN0aW9uLgo+ID4gCj4gPiBUaGUg Y29kZSB3b3VsZCBiZSBjbGVhcmVyIGlmIHlvdSBleHBsaWNpdGx5IHplcm9lZCB0aGUgbW9kZSBp biB0aGlzCj4gPiBmdW5jdGlvbi4gT3IgZG8geW91IHJlbHkgb24gdGhpcyBmdW5jdGlvbiB0byBu b3QgY2xvYmJlciBvdGhlciBiaXRzPwo+ID4gSW4gdGhhdCBjYXNlIGFwcGx5IHNvbWUgYml0LW1h c2suCj4gPgo+ID4+Pj4gIAkJYnJlYWs7Cj4gPj4+PiArCj4gPj4+PiArCWNhc2UgTUVESUFfQlVT X0ZNVF9SR0I4ODhfMVg3WDRfU1BXR19MRToKPiA+Pj4+ICsJCWx2ZHMtPm1vZGUgfD0gUkNBUl9M VkRTX01PREVfTUlSUk9SOwo+ID4+Pj4gCj4gPj4+PiAgCWNhc2UgTUVESUFfQlVTX0ZNVF9SR0I4 ODhfMVg3WDRfU1BXRzoKPiA+Pj4+IC0JCW1vZGUgPSBSQ0FSX0xWRFNfTU9ERV9WRVNBOwo+ID4+ Pj4gKwkJbHZkcy0+bW9kZSA9IFJDQVJfTFZEU19NT0RFX1ZFU0E7Cj4gPj4+IAo+ID4+PiBEaXRv Lgo+ID4+PiAKPiA+Pj4+ICAJCWJyZWFrOwo+ID4+Pj4gIAkKPiA+Pj4+ICAJZGVmYXVsdDoKPiA+ Pj4+ICAJCWRldl9lcnIobHZkcy0+ZGV2LCAidW5zdXBwb3J0ZWQgTFZEUyBidXMgZm9ybWF0IDB4 JTA0eFxuIiwKPiA+Pj4+IC0JCQlpbmZvLT5idXNfZm9ybWF0c1swXSk7Cj4gPj4+PiAtCQlyZXR1 cm47Cj4gPj4+PiArCQkJYnVzX2ZtdCk7Cj4gPj4+PiAgCX0KPiA+Pj4+IC0KPiA+Pj4+IC0JaWYg KGluZm8tPmJ1c19mbGFncyAmIERSTV9CVVNfRkxBR19EQVRBX0xTQl9UT19NU0IpCj4gPj4+PiAt CQltb2RlIHw9IFJDQVJfTFZEU19NT0RFX01JUlJPUjsKPiA+Pj4+IC0KPiA+Pj4+IC0JbHZkcy0+ bW9kZSA9IG1vZGU7Cj4gPj4+PiAgfQo+ID4+Pj4gIAo+ID4+Pj4gIHN0YXRpYyB2b2lkIHJjYXJf bHZkc19tb2RlX3NldChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAoKLS0gClJlZ2FyZHMsCgpM YXVyZW50IFBpbmNoYXJ0CgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbAo=