From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wm1-f46.google.com (mail-wm1-f46.google.com [209.85.128.46]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3D1087A for ; Fri, 10 Jun 2022 20:01:14 +0000 (UTC) Received: by mail-wm1-f46.google.com with SMTP id o37-20020a05600c512500b0039c4ba4c64dso1628827wms.2 for ; Fri, 10 Jun 2022 13:01:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:subject:from:to:cc:date:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=2YSKLRduvMh8Ck87NHw9tHP5D4LoKiAtBQhGBpQbX8A=; b=gR/G++1jfOEzvcHno81WYhGhDWujpMOrzQlWbw/Zh0c4i+KvoB9JLQId+negoXp1Sz aE9pnEjstwJwLA+hUxghqK35hRoOz62QkKF3gPxwQJ60YGwM5CxqUnt1LDlocalf80LM Lt/8BGddQB/CE21IkndMVeeGO3iH/lidVOjbX4poHomqAlHJ4nH3NxqUTdDBddZfDhCC SlXmbuGQDroEt9jmN0YFLC+p03mrdwZkyN6nxyTJ9h2uatv+H0aGATDgtomzZF32cEBO VOokeMPK16kt8DgGexcZvcyj7N0HXeDMWjw8ktki3yHnomdbYiXQeByD1BFfHepypTzz qrzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=2YSKLRduvMh8Ck87NHw9tHP5D4LoKiAtBQhGBpQbX8A=; b=Pw/isd/x+eo6E3tea+IQUNqYV0JV6kVNF6ySExIYN+t3Dw3ddDT7aQ9KvUtHykdxPj qAyOpZi+tAsaQ8fGwKzdyWCaTBh03i7m0dnOi1afDIXV+V1lhRGvISinp+z7RppTvAy9 oCzdB0f3cr/sLPqEao0kfc9UCFjGUMu3i27sjnFlgDgdby0yHBG1Q/OjjT961RTYlNYK POGyQqrHFWTzGCHr0zMDSNI29C/HZFI4Y+jbbO+Gd/O5vB2dxCA2I+/b8oFPoVpqEoct KLSL5BEdo05U8v9bwrwo8um8yniwvlXo+JZSD1AFls6gQGQG3Zhv4F0RBqJfumsjZZmK 6nsg== X-Gm-Message-State: AOAM533o6WKTVW4dMoy8D+m5TmNJXOEdxr2PB2gPzhwkYekIfgVF+Xla S/I9MFIGhV3bSJSdSM/xee0= X-Google-Smtp-Source: ABdhPJzrLLwHku4oE77pzyt+7olow27HPFl66zU7rgD6BG8IagfgMHfQBTHa/t06C9XmSrKuzPqjlQ== X-Received: by 2002:a05:600c:2105:b0:39c:381c:1e13 with SMTP id u5-20020a05600c210500b0039c381c1e13mr1303579wml.189.1654891272383; Fri, 10 Jun 2022 13:01:12 -0700 (PDT) Received: from ?IPv6:2001:a61:136e:3c01:8bd4:cf6f:76f1:a861? ([2001:a61:136e:3c01:8bd4:cf6f:76f1:a861]) by smtp.gmail.com with ESMTPSA id a4-20020adff7c4000000b0021033caa332sm338933wrq.42.2022.06.10.13.01.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Jun 2022 13:01:11 -0700 (PDT) Message-ID: <97b9278953d923008a4c1230ca9bd354117e7213.camel@gmail.com> Subject: Re: [PATCH 24/34] iio: inkern: move to fwnode properties From: Nuno =?ISO-8859-1?Q?S=E1?= To: Andy Shevchenko , Nuno =?ISO-8859-1?Q?S=E1?= Cc: dl-linux-imx , Linux-Renesas , "open list:BROADCOM NVRAM DRIVER" , linux-arm Mailing List , chrome-platform@lists.linux.dev, Lad Prabhakar , "moderated list:ARM/Mediatek SoC support" , linux-stm32@st-md-mailman.stormreply.com, linux-arm-msm , linux-iio , OpenBMC Maillist , Cai Huoqing , Benjamin Fair , Jishnu Prakash , Linus Walleij , Lars-Peter Clausen , Alexandre Torgue , Amit Kucheria , Andy Gross , Michael Hennerich , Haibo Chen , Benson Leung , "Rafael J. Wysocki" , Alexandre Belloni , Christophe Branchereau , Patrick Venture , Arnd Bergmann , Nancy Yuen , Sascha Hauer , Daniel Lezcano , Gwendal Grignou , Saravanan Sekar , Tali Perry , Maxime Coquelin , Paul Cercueil , Thara Gopinath , Avi Fishman , Lorenzo Bianconi , Claudiu Beznea , Pengutronix Kernel Team , Fabrice Gasnier , Matthias Brugger , Tomer Maimon , Bjorn Andersson , Nicolas Ferre , Jonathan Cameron , Zhang Rui , Shawn Guo , Guenter Roeck , Fabio Estevam , Olivier Moysan , Eugen Hristev , Miquel Raynal Date: Fri, 10 Jun 2022 22:01:09 +0200 In-Reply-To: References: <20220610084545.547700-1-nuno.sa@analog.com> <20220610084545.547700-25-nuno.sa@analog.com> Content-Type: text/plain; charset="UTF-8" User-Agent: Evolution 3.42.4 (3.42.4-2.fc35) Precedence: bulk X-Mailing-List: chrome-platform@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit On Fri, 2022-06-10 at 17:19 +0200, Andy Shevchenko wrote: > On Fri, Jun 10, 2022 at 10:48 AM Nuno Sá wrote: > > > > This moves the IIO in kernel interface to use fwnode properties and > > thus > > be firmware agnostic. > > > > Note that the interface is still not firmware agnostic. At this > > point we > > have both OF and fwnode interfaces so that we don't break any user. > > On > > top of this we also want to have a per driver conversion and that > > is the > > main reason we have both of_xlate() and fwnode_xlate() support. > > Reviewed-by: Andy Shevchenko > Thanks! > > A few nit-picks below, though. > > > Signed-off-by: Nuno Sá > > --- > >  drivers/iio/inkern.c         | 145 +++++++++++++++++++------------ > > ---- > >  include/linux/iio/consumer.h |  36 +++++---- > >  include/linux/iio/iio.h      |   5 ++ > >  3 files changed, 105 insertions(+), 81 deletions(-) > > > > diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c > > index dde47324b826..1d519b0cacea 100644 > > --- a/drivers/iio/inkern.c > > +++ b/drivers/iio/inkern.c > > @@ -5,6 +5,7 @@ > >   */ > >  #include > >  #include > > +#include > >  #include > >  #include > >  #include > > @@ -117,15 +118,13 @@ static const struct iio_chan_spec > >         return chan; > >  } > > > > -#ifdef CONFIG_OF > > - > >  static int iio_dev_node_match(struct device *dev, const void > > *data) > >  { > > -       return dev->of_node == data && dev->type == > > &iio_device_type; > > +       return device_match_fwnode(dev, data) && dev->type == > > &iio_device_type; > >  } > > > >  /** > > - * __of_iio_simple_xlate - translate iiospec to the IIO channel > > index > > + * __fwnode_iio_simple_xlate - translate iiospec to the IIO > > channel index > >   * @indio_dev: pointer to the iio_dev structure > >   * @iiospec:   IIO specifier as found in the device tree > >   * > > @@ -134,14 +133,14 @@ static int iio_dev_node_match(struct device > > *dev, const void *data) > >   * whether IIO index is less than num_channels (that is specified > > in the > >   * iio_dev). > >   */ > > -static int __of_iio_simple_xlate(struct iio_dev *indio_dev, > > -                               const struct of_phandle_args > > *iiospec) > > +static int __fwnode_iio_simple_xlate(struct iio_dev *indio_dev, > > +                                    const struct > > fwnode_reference_args *iiospec) > >  { > > -       if (!iiospec->args_count) > > +       if (!iiospec->nargs) > >                 return 0; > > > >         if (iiospec->args[0] >= indio_dev->num_channels) { > > -               dev_err(&indio_dev->dev, "invalid channel index > > %u\n", > > +               dev_err(&indio_dev->dev, "invalid channel index > > %llu\n", > >                         iiospec->args[0]); > >                 return -EINVAL; > >         } > > @@ -149,34 +148,56 @@ static int __of_iio_simple_xlate(struct > > iio_dev *indio_dev, > >         return iiospec->args[0]; > >  } > > > > -static int __of_iio_channel_get(struct iio_channel *channel, > > -                               struct device_node *np, int index) > > +/* > > + * Simple helper to copy fwnode_reference_args into > > of_phandle_args so we > > + * can pass it to of_xlate(). Ultimate goal is to drop this > > together with > > + * of_xlate(). > > + */ > > +static int __fwnode_to_of_xlate(struct iio_dev *indio_dev, > > +                               const struct fwnode_reference_args > > *iiospec) > > +{ > > +       struct of_phandle_args of_args; > > +       unsigned int i; > > + > > +       of_args.args_count = iiospec->nargs; > > +       of_args.np = to_of_node(iiospec->fwnode); > > + > > +       for (i = 0; i < MAX_PHANDLE_ARGS; i++) > > +               of_args.args[i] = i < iiospec->nargs ? iiospec- > > >args[i] : 0; > > + > > +       return indio_dev->info->of_xlate(indio_dev, &of_args); > > +} > > Ah, now I realized that it's a bit more complicated than just > to_of_node() :-) > Yeah, of_fwnode_get_reference_args() was helpfull. But I based myself too much on it. On a second look, I guess ARRAY_SIZE(of_args.args) would be better than MAX_PHANDLE_ARGS. > > +static int __fwnode_iio_channel_get(struct iio_channel *channel, > > +                                   struct fwnode_handle *fwnode, > > int index) > >  { > >         struct device *idev; > >         struct iio_dev *indio_dev; > >         int err; > > -       struct of_phandle_args iiospec; > > +       struct fwnode_reference_args iiospec; > > At the same point you can move it up in the block to make a long line > first. Can do that... > > > -       err = of_parse_phandle_with_args(np, "io-channels", > > -                                        "#io-channel-cells", > > -                                        index, &iiospec); > > +       err = fwnode_property_get_reference_args(fwnode, "io- > > channels", > > +                                                "#io-channel- > > cells", 0, > > +                                                index, &iiospec); > >         if (err) > >                 return err; > > > > -       idev = bus_find_device(&iio_bus_type, NULL, iiospec.np, > > +       idev = bus_find_device(&iio_bus_type, NULL, iiospec.fwnode, > >                                iio_dev_node_match); > > Wondering if this > https://elixir.bootlin.com/linux/v5.19-rc1/C/ident/bus_find_device_by_fwnode > can be utilized (yes, I noticed iio_device_type above). Hmm, at first glance I would say we can use it. AFAICT, we are already grabbing a node which contains "#io-channel-cells" which is very indicative that is an IIO device. I also find it very unlikely to have two IIO devices with the same fwnode (I guess it would be an issue even in the old code) and even more unlikely two devices of diferent types with the same fwnode? Anyways, I guess Jonathan can help in here... > > >         if (idev == NULL) { > > -               of_node_put(iiospec.np); > > +               fwnode_handle_put(iiospec.fwnode); > >                 return -EPROBE_DEFER; > >         } > > > >         indio_dev = dev_to_iio_dev(idev); > >         channel->indio_dev = indio_dev; > >         if (indio_dev->info->of_xlate) > > -               index = indio_dev->info->of_xlate(indio_dev, > > &iiospec); > > +               index = __fwnode_to_of_xlate(indio_dev, &iiospec); > > +       else if (indio_dev->info->fwnode_xlate) > > +               index = indio_dev->info->fwnode_xlate(indio_dev, > > &iiospec); > >         else > > -               index = __of_iio_simple_xlate(indio_dev, &iiospec); > > -       of_node_put(iiospec.np); > > +               index = __fwnode_iio_simple_xlate(indio_dev, > > &iiospec); > > +       fwnode_handle_put(iiospec.fwnode); > >         if (index < 0) > >                 goto err_put; > >         channel->channel = &indio_dev->channels[index]; > > @@ -188,7 +209,8 @@ static int __of_iio_channel_get(struct > > iio_channel *channel, > >         return index; > >  } > > > > -static struct iio_channel *of_iio_channel_get(struct device_node > > *np, int index) > > +static struct iio_channel *fwnode_iio_channel_get(struct > > fwnode_handle *fwnode, > > +                                                 int index) > >  { > >         struct iio_channel *channel; > >         int err; > > @@ -200,7 +222,7 @@ static struct iio_channel > > *of_iio_channel_get(struct device_node *np, int index) > >         if (channel == NULL) > >                 return ERR_PTR(-ENOMEM); > > > > -       err = __of_iio_channel_get(channel, np, index); > > +       err = __fwnode_iio_channel_get(channel, fwnode, index); > >         if (err) > >                 goto err_free_channel; > > > > @@ -211,9 +233,9 @@ static struct iio_channel > > *of_iio_channel_get(struct device_node *np, int index) > >         return ERR_PTR(err); > >  } > > > > -struct iio_channel *__of_iio_channel_get_by_name(struct > > device_node *np, > > -                                                const char *name, > > -                                                bool > > *parent_lookup) > > +struct iio_channel * > > +__fwnode_iio_channel_get_by_name(struct fwnode_handle *fwnode, > > const char *name, > > +                                bool *parent_lookup) > >  { > >         struct iio_channel *chan; > >         int index = 0; > > @@ -221,32 +243,34 @@ struct iio_channel > > *__of_iio_channel_get_by_name(struct device_node *np, > >         /* > >          * For named iio channels, first look up the name in the > >          * "io-channel-names" property.  If it cannot be found, the > > -        * index will be an error code, and of_iio_channel_get() > > +        * index will be an error code, and > > fwnode_iio_channel_get() > >          * will fail. > >          */ > >         if (name) > > -               index = of_property_match_string(np, "io-channel- > > names", name); > > +               index = fwnode_property_match_string(fwnode, "io- > > channel-names", > > +                                                    name); > > > > -       chan = of_iio_channel_get(np, index); > > +       chan = fwnode_iio_channel_get(fwnode, index); > >         if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER) { > >                 *parent_lookup = false; > >         } else if (name && index >= 0) { > > -               pr_err("ERROR: could not get IIO channel > > %pOF:%s(%i)\n", > > -                      np, name ? name : "", index); > > +               pr_err("ERROR: could not get IIO channel > > %pfw:%s(%i)\n", > > +                      fwnode, name ? name : "", index); > > Since you are touching this line can you switch to name ?: "" and > possibly move some parameters to the above line? If it does not cross the 80limit col, sure. > > >                 *parent_lookup = false; > >         } > > > >         return chan; > >  } > > > > -struct iio_channel *of_iio_channel_get_by_name(struct device_node > > *np, > > -                                              const char *name) > > +struct iio_channel *fwnode_iio_channel_get_by_name(struct > > fwnode_handle *fwnode, > > +                                                  const char > > *name) > >  { > >         struct iio_channel *chan; > > +       struct fwnode_handle *parent; > >         bool parent_lookup = true; > > > >         /* Walk up the tree of devices looking for a matching iio > > channel */ > > -       chan = __of_iio_channel_get_by_name(np, name, > > &parent_lookup); > > +       chan = __fwnode_iio_channel_get_by_name(fwnode, name, > > &parent_lookup); > >         if (!parent_lookup) > >                 return chan; > > > > @@ -255,33 +279,34 @@ struct iio_channel > > *of_iio_channel_get_by_name(struct device_node *np, > >          * If the parent node has a "io-channel-ranges" property, > >          * then we can try one of its channels. > >          */ > > -       np = np->parent; > > -       while (np) { > > -               if (!of_get_property(np, "io-channel-ranges", > > NULL)) > > +       fwnode_for_each_parent_node(fwnode, parent) { > > +               if (!fwnode_property_present(parent, "io-channel- > > ranges")) { > > +                       fwnode_handle_put(parent); > >                         return chan; > > break; ? The return in place was a request from Jonathan in the RFC... > > (Yes, I understand pros and cons of each variant, up to you) > > > +               } > > > > -               chan = __of_iio_channel_get_by_name(np, name, > > &parent_lookup); > > -               if (!parent_lookup) > > +               chan = __fwnode_iio_channel_get_by_name(parent, > > name, &parent_lookup); > > +               if (!parent_lookup) { > > +                       fwnode_handle_put(parent); > >                         return chan; > > Ditto. > > > -               np = np->parent; > > +               } > >         } > > > >         return chan; > >  } > > -EXPORT_SYMBOL_GPL(of_iio_channel_get_by_name); > > +EXPORT_SYMBOL_GPL(fwnode_iio_channel_get_by_name); > > Wondering if we may move this to the IIO namespace. I guess it makes sense but surely on a different patch... > > > -static struct iio_channel *of_iio_channel_get_all(struct device > > *dev) > > +static struct iio_channel *fwnode_iio_channel_get_all(struct > > device *dev) > >  { > > +       struct fwnode_handle *fwnode = dev_fwnode(dev); > >         struct iio_channel *chans; > >         int i, mapind, nummaps = 0; > >         int ret; > > > >         do { > > -               ret = of_parse_phandle_with_args(dev->of_node, > > -                                                "io-channels", > > -                                                "#io-channel- > > cells", > > -                                                nummaps, NULL); > > +               ret = fwnode_property_get_reference_args(fwnode, > > "io-channels", > > +                                                        "#io- > > channel-cells", 0, > > +                                                        nummaps, > > NULL); > >                 if (ret < 0) > >                         break; > >         } while (++nummaps); > > @@ -294,10 +319,9 @@ static struct iio_channel > > *of_iio_channel_get_all(struct device *dev) > >         if (chans == NULL) > >                 return ERR_PTR(-ENOMEM); > > > > -       /* Search for OF matches */ > > +       /* Search for FW matches */ > >         for (mapind = 0; mapind < nummaps; mapind++) { > > -               ret = __of_iio_channel_get(&chans[mapind], dev- > > >of_node, > > -                                          mapind); > > +               ret = __fwnode_iio_channel_get(&chans[mapind], > > fwnode, mapind); > >                 if (ret) > >                         goto error_free_chans; > >         } > > @@ -310,15 +334,6 @@ static struct iio_channel > > *of_iio_channel_get_all(struct device *dev) > >         return ERR_PTR(ret); > >  } > > > > -#else /* CONFIG_OF */ > > - > > -static inline struct iio_channel *of_iio_channel_get_all(struct > > device *dev) > > -{ > > -       return ERR_PTR(-ENODEV); > > -} > > - > > -#endif /* CONFIG_OF */ > > - > >  static struct iio_channel *iio_channel_get_sys(const char *name, > >                                                const char > > *channel_name) > >  { > > @@ -379,8 +394,8 @@ struct iio_channel *iio_channel_get(struct > > device *dev, > >         struct iio_channel *channel; > > > >         if (dev) { > > -               channel = of_iio_channel_get_by_name(dev->of_node, > > -                                                    channel_name); > > +               channel = > > fwnode_iio_channel_get_by_name(dev_fwnode(dev), > > +                                                        > > channel_name); > >                 if (!IS_ERR(channel) || PTR_ERR(channel) == - > > EPROBE_DEFER) > >                         return channel; > >         } > > @@ -421,14 +436,14 @@ struct iio_channel > > *devm_iio_channel_get(struct device *dev, > >  } > >  EXPORT_SYMBOL_GPL(devm_iio_channel_get); > > > > -struct iio_channel *devm_of_iio_channel_get_by_name(struct device > > *dev, > > -                                                   struct > > device_node *np, > > -                                                   const char > > *channel_name) > > +struct iio_channel *devm_fwnode_iio_channel_get_by_name(struct > > device *dev, > > +                                                       struct > > fwnode_handle *fwnode, > > +                                                       const char > > *channel_name) > >  { > >         struct iio_channel *channel; > >         int ret; > > > > -       channel = of_iio_channel_get_by_name(np, channel_name); > > +       channel = fwnode_iio_channel_get_by_name(fwnode, > > channel_name); > >         if (IS_ERR(channel)) > >                 return channel; > > > > @@ -438,7 +453,7 @@ struct iio_channel > > *devm_of_iio_channel_get_by_name(struct device *dev, > > > >         return channel; > >  } > > -EXPORT_SYMBOL_GPL(devm_of_iio_channel_get_by_name); > > +EXPORT_SYMBOL_GPL(devm_fwnode_iio_channel_get_by_name); > > > >  struct iio_channel *iio_channel_get_all(struct device *dev) > >  { > > @@ -452,7 +467,7 @@ struct iio_channel *iio_channel_get_all(struct > > device *dev) > >         if (dev == NULL) > >                 return ERR_PTR(-EINVAL); > > > > -       chans = of_iio_channel_get_all(dev); > > +       chans = fwnode_iio_channel_get_all(dev); > >         if (!IS_ERR(chans) || PTR_ERR(chans) == -EPROBE_DEFER) > >                 return chans; > > > > diff --git a/include/linux/iio/consumer.h > > b/include/linux/iio/consumer.h > > index 5fa5957586cf..a96a714b5fdc 100644 > > --- a/include/linux/iio/consumer.h > > +++ b/include/linux/iio/consumer.h > > @@ -9,11 +9,13 @@ > > > >  #include > >  #include > > > +#include > > Ordering. IIO has special meaning here, that's why it's last. ok... - Nuno Sá From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id C3DC2C43334 for ; Fri, 10 Jun 2022 20:01:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Date:Cc:To:From:Subject:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=YlIFpFE0BaGX/2AZqyyCkCk6KOFGR1TwYaBDGFrcO78=; b=TK/cbT87IELKZa 5cXpUFXQSO8r8wrRAx61zhGtWbVI7HTvnEQwCyH8zpdoJcNPMLLNZ+fHF5iR9wdcYOeE9jdCUjmJ1 Bk6BVC+jWJo0HdhRQCEBcHh5QaHEXDnEQW/3oMFoIAKvZogWa2kp2KHhmKzzkU+7aQZAUZuGTW+gU u36yb88KuEtRQ5CpB3oTRpa+68DgsARRRusnnFX/QxADJjNGDgWgwadoBRv/33+j4i1krCAnqk/Yl lTPPwQF2YrkMmkjP9WYejAF7dajoDLpbHcJsblbRUslgiTk93AMVuhDOqZj5PaOJBv3KosXQZ+lZP HPAAT6pvJOLc1M1Ivi+Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzkoq-009cyx-LP; Fri, 10 Jun 2022 20:01:20 +0000 Received: from mail-wm1-x333.google.com ([2a00:1450:4864:20::333]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzkok-009cx7-TF; Fri, 10 Jun 2022 20:01:17 +0000 Received: by mail-wm1-x333.google.com with SMTP id r187-20020a1c44c4000000b0039c76434147so1634701wma.1; Fri, 10 Jun 2022 13:01:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:subject:from:to:cc:date:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=2YSKLRduvMh8Ck87NHw9tHP5D4LoKiAtBQhGBpQbX8A=; b=gR/G++1jfOEzvcHno81WYhGhDWujpMOrzQlWbw/Zh0c4i+KvoB9JLQId+negoXp1Sz aE9pnEjstwJwLA+hUxghqK35hRoOz62QkKF3gPxwQJ60YGwM5CxqUnt1LDlocalf80LM Lt/8BGddQB/CE21IkndMVeeGO3iH/lidVOjbX4poHomqAlHJ4nH3NxqUTdDBddZfDhCC SlXmbuGQDroEt9jmN0YFLC+p03mrdwZkyN6nxyTJ9h2uatv+H0aGATDgtomzZF32cEBO VOokeMPK16kt8DgGexcZvcyj7N0HXeDMWjw8ktki3yHnomdbYiXQeByD1BFfHepypTzz qrzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=2YSKLRduvMh8Ck87NHw9tHP5D4LoKiAtBQhGBpQbX8A=; b=nRGD4yYClM9w6VFEACK6sf2vGlG157X3viti+HmNC8F8IVw3ZRNYu6A2eYzA7Pyi/I 9qcAoZUNeOuOzL7AnWlYwGngJR1a94Wcpi0+f6IQMZ/kg8/tn5km4ky/LNFkNsfXV5nT U+B4pHsLmahcoSf8Ym0FhKshpXXUQymcynvElwnzXCbwP4l2anQ2PEcNQu7aF/oCbIUg 26pD7ykTtAMtfw8h8ohjkI69cCLR2eayP5D3/KzpIppALURU8HW9huTQxSsalG6eccdk W2GRsf3hf8FxOKgbaOWQWWakRcHlrG1mkw2mF3+QSmGlApVB8vWzIkncdqiZ5a9ufbkS mTtQ== X-Gm-Message-State: AOAM532NfCrSZKzouJRr6WQ+l4JYkEtLfG2JkzYbqTFlYNK8gqtRcYLK UHg1TigDE6LPyvZI8Qz1KAI= X-Google-Smtp-Source: ABdhPJzrLLwHku4oE77pzyt+7olow27HPFl66zU7rgD6BG8IagfgMHfQBTHa/t06C9XmSrKuzPqjlQ== X-Received: by 2002:a05:600c:2105:b0:39c:381c:1e13 with SMTP id u5-20020a05600c210500b0039c381c1e13mr1303579wml.189.1654891272383; Fri, 10 Jun 2022 13:01:12 -0700 (PDT) Received: from ?IPv6:2001:a61:136e:3c01:8bd4:cf6f:76f1:a861? ([2001:a61:136e:3c01:8bd4:cf6f:76f1:a861]) by smtp.gmail.com with ESMTPSA id a4-20020adff7c4000000b0021033caa332sm338933wrq.42.2022.06.10.13.01.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Jun 2022 13:01:11 -0700 (PDT) Message-ID: <97b9278953d923008a4c1230ca9bd354117e7213.camel@gmail.com> Subject: Re: [PATCH 24/34] iio: inkern: move to fwnode properties From: Nuno =?ISO-8859-1?Q?S=E1?= To: Andy Shevchenko , Nuno =?ISO-8859-1?Q?S=E1?= Cc: dl-linux-imx , Linux-Renesas , "open list:BROADCOM NVRAM DRIVER" , linux-arm Mailing List , chrome-platform@lists.linux.dev, Lad Prabhakar , "moderated list:ARM/Mediatek SoC support" , linux-stm32@st-md-mailman.stormreply.com, linux-arm-msm , linux-iio , OpenBMC Maillist , Cai Huoqing , Benjamin Fair , Jishnu Prakash , Linus Walleij , Lars-Peter Clausen , Alexandre Torgue , Amit Kucheria , Andy Gross , Michael Hennerich , Haibo Chen , Benson Leung , "Rafael J. Wysocki" , Alexandre Belloni , Christophe Branchereau , Patrick Venture , Arnd Bergmann , Nancy Yuen , Sascha Hauer , Daniel Lezcano , Gwendal Grignou , Saravanan Sekar , Tali Perry , Maxime Coquelin , Paul Cercueil , Thara Gopinath , Avi Fishman , Lorenzo Bianconi , Claudiu Beznea , Pengutronix Kernel Team , Fabrice Gasnier , Matthias Brugger , Tomer Maimon , Bjorn Andersson , Nicolas Ferre , Jonathan Cameron , Zhang Rui , Shawn Guo , Guenter Roeck , Fabio Estevam , Olivier Moysan , Eugen Hristev , Miquel Raynal Date: Fri, 10 Jun 2022 22:01:09 +0200 In-Reply-To: References: <20220610084545.547700-1-nuno.sa@analog.com> <20220610084545.547700-25-nuno.sa@analog.com> User-Agent: Evolution 3.42.4 (3.42.4-2.fc35) MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220610_130115_024530_081D7586 X-CRM114-Status: GOOD ( 44.23 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org T24gRnJpLCAyMDIyLTA2LTEwIGF0IDE3OjE5ICswMjAwLCBBbmR5IFNoZXZjaGVua28gd3JvdGU6 Cj4gT24gRnJpLCBKdW4gMTAsIDIwMjIgYXQgMTA6NDggQU0gTnVubyBTw6EgPG51bm8uc2FAYW5h bG9nLmNvbT4gd3JvdGU6Cj4gPiAKPiA+IFRoaXMgbW92ZXMgdGhlIElJTyBpbiBrZXJuZWwgaW50 ZXJmYWNlIHRvIHVzZSBmd25vZGUgcHJvcGVydGllcyBhbmQKPiA+IHRodXMKPiA+IGJlIGZpcm13 YXJlIGFnbm9zdGljLgo+ID4gCj4gPiBOb3RlIHRoYXQgdGhlIGludGVyZmFjZSBpcyBzdGlsbCBu b3QgZmlybXdhcmUgYWdub3N0aWMuIEF0IHRoaXMKPiA+IHBvaW50IHdlCj4gPiBoYXZlIGJvdGgg T0YgYW5kIGZ3bm9kZSBpbnRlcmZhY2VzIHNvIHRoYXQgd2UgZG9uJ3QgYnJlYWsgYW55IHVzZXIu Cj4gPiBPbgo+ID4gdG9wIG9mIHRoaXMgd2UgYWxzbyB3YW50IHRvIGhhdmUgYSBwZXIgZHJpdmVy IGNvbnZlcnNpb24gYW5kIHRoYXQKPiA+IGlzIHRoZQo+ID4gbWFpbiByZWFzb24gd2UgaGF2ZSBi b3RoIG9mX3hsYXRlKCkgYW5kIGZ3bm9kZV94bGF0ZSgpIHN1cHBvcnQuCj4gCj4gUmV2aWV3ZWQt Ynk6IEFuZHkgU2hldmNoZW5rbyA8YW5keS5zaGV2Y2hlbmtvQGdtYWlsLmNvbT4KPiBUaGFua3Mh Cj4gCj4gQSBmZXcgbml0LXBpY2tzIGJlbG93LCB0aG91Z2guCj4gCj4gPiBTaWduZWQtb2ZmLWJ5 OiBOdW5vIFPDoSA8bnVuby5zYUBhbmFsb2cuY29tPgo+ID4gLS0tCj4gPiDCoGRyaXZlcnMvaWlv L2lua2Vybi5jwqDCoMKgwqDCoMKgwqDCoCB8IDE0NSArKysrKysrKysrKysrKysrKysrLS0tLS0t LS0tLS0tCj4gPiAtLS0tCj4gPiDCoGluY2x1ZGUvbGludXgvaWlvL2NvbnN1bWVyLmggfMKgIDM2 ICsrKysrLS0tLQo+ID4gwqBpbmNsdWRlL2xpbnV4L2lpby9paW8uaMKgwqDCoMKgwqAgfMKgwqAg NSArKwo+ID4gwqAzIGZpbGVzIGNoYW5nZWQsIDEwNSBpbnNlcnRpb25zKCspLCA4MSBkZWxldGlv bnMoLSkKPiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWlvL2lua2Vybi5jIGIvZHJpdmVy cy9paW8vaW5rZXJuLmMKPiA+IGluZGV4IGRkZTQ3MzI0YjgyNi4uMWQ1MTliMGNhY2VhIDEwMDY0 NAo+ID4gLS0tIGEvZHJpdmVycy9paW8vaW5rZXJuLmMKPiA+ICsrKyBiL2RyaXZlcnMvaWlvL2lu a2Vybi5jCj4gPiBAQCAtNSw2ICs1LDcgQEAKPiA+IMKgICovCj4gPiDCoCNpbmNsdWRlIDxsaW51 eC9lcnIuaD4KPiA+IMKgI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgo+ID4gKyNpbmNsdWRlIDxs aW51eC9wcm9wZXJ0eS5oPgo+ID4gwqAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ID4gwqAjaW5j bHVkZSA8bGludXgvbXV0ZXguaD4KPiA+IMKgI2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gPiBAQCAt MTE3LDE1ICsxMTgsMTMgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBpaW9fY2hhbl9zcGVjCj4gPiDC oMKgwqDCoMKgwqDCoCByZXR1cm4gY2hhbjsKPiA+IMKgfQo+ID4gCj4gPiAtI2lmZGVmIENPTkZJ R19PRgo+ID4gLQo+ID4gwqBzdGF0aWMgaW50IGlpb19kZXZfbm9kZV9tYXRjaChzdHJ1Y3QgZGV2 aWNlICpkZXYsIGNvbnN0IHZvaWQKPiA+ICpkYXRhKQo+ID4gwqB7Cj4gPiAtwqDCoMKgwqDCoMKg IHJldHVybiBkZXYtPm9mX25vZGUgPT0gZGF0YSAmJiBkZXYtPnR5cGUgPT0KPiA+ICZpaW9fZGV2 aWNlX3R5cGU7Cj4gPiArwqDCoMKgwqDCoMKgIHJldHVybiBkZXZpY2VfbWF0Y2hfZndub2RlKGRl diwgZGF0YSkgJiYgZGV2LT50eXBlID09Cj4gPiAmaWlvX2RldmljZV90eXBlOwo+ID4gwqB9Cj4g PiAKPiA+IMKgLyoqCj4gPiAtICogX19vZl9paW9fc2ltcGxlX3hsYXRlIC0gdHJhbnNsYXRlIGlp b3NwZWMgdG8gdGhlIElJTyBjaGFubmVsCj4gPiBpbmRleAo+ID4gKyAqIF9fZndub2RlX2lpb19z aW1wbGVfeGxhdGUgLSB0cmFuc2xhdGUgaWlvc3BlYyB0byB0aGUgSUlPCj4gPiBjaGFubmVsIGlu ZGV4Cj4gPiDCoCAqIEBpbmRpb19kZXY6IHBvaW50ZXIgdG8gdGhlIGlpb19kZXYgc3RydWN0dXJl Cj4gPiDCoCAqIEBpaW9zcGVjOsKgwqAgSUlPIHNwZWNpZmllciBhcyBmb3VuZCBpbiB0aGUgZGV2 aWNlIHRyZWUKPiA+IMKgICoKPiA+IEBAIC0xMzQsMTQgKzEzMywxNCBAQCBzdGF0aWMgaW50IGlp b19kZXZfbm9kZV9tYXRjaChzdHJ1Y3QgZGV2aWNlCj4gPiAqZGV2LCBjb25zdCB2b2lkICpkYXRh KQo+ID4gwqAgKiB3aGV0aGVyIElJTyBpbmRleCBpcyBsZXNzIHRoYW4gbnVtX2NoYW5uZWxzICh0 aGF0IGlzIHNwZWNpZmllZAo+ID4gaW4gdGhlCj4gPiDCoCAqIGlpb19kZXYpLgo+ID4gwqAgKi8K PiA+IC1zdGF0aWMgaW50IF9fb2ZfaWlvX3NpbXBsZV94bGF0ZShzdHJ1Y3QgaWlvX2RldiAqaW5k aW9fZGV2LAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBjb25zdCBzdHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzCj4gPiAqaWlvc3Bl YykKPiA+ICtzdGF0aWMgaW50IF9fZndub2RlX2lpb19zaW1wbGVfeGxhdGUoc3RydWN0IGlpb19k ZXYgKmluZGlvX2RldiwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNvbnN0IHN0cnVjdAo+ID4gZndub2Rl X3JlZmVyZW5jZV9hcmdzICppaW9zcGVjKQo+ID4gwqB7Cj4gPiAtwqDCoMKgwqDCoMKgIGlmICgh aWlvc3BlYy0+YXJnc19jb3VudCkKPiA+ICvCoMKgwqDCoMKgwqAgaWYgKCFpaW9zcGVjLT5uYXJn cykKPiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gMDsKPiA+IAo+ID4g wqDCoMKgwqDCoMKgwqAgaWYgKGlpb3NwZWMtPmFyZ3NbMF0gPj0gaW5kaW9fZGV2LT5udW1fY2hh bm5lbHMpIHsKPiA+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRldl9lcnIoJmluZGlv X2Rldi0+ZGV2LCAiaW52YWxpZCBjaGFubmVsIGluZGV4Cj4gPiAldVxuIiwKPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRldl9lcnIoJmluZGlvX2Rldi0+ZGV2LCAiaW52YWxpZCBj aGFubmVsIGluZGV4Cj4gPiAlbGx1XG4iLAo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCBpaW9zcGVjLT5hcmdzWzBdKTsKPiA+IMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPiA+IMKgwqDCoMKgwqDCoMKgIH0KPiA+ IEBAIC0xNDksMzQgKzE0OCw1NiBAQCBzdGF0aWMgaW50IF9fb2ZfaWlvX3NpbXBsZV94bGF0ZShz dHJ1Y3QKPiA+IGlpb19kZXYgKmluZGlvX2RldiwKPiA+IMKgwqDCoMKgwqDCoMKgIHJldHVybiBp aW9zcGVjLT5hcmdzWzBdOwo+ID4gwqB9Cj4gPiAKPiA+IC1zdGF0aWMgaW50IF9fb2ZfaWlvX2No YW5uZWxfZ2V0KHN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbm5lbCwKPiA+IC3CoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RydWN0IGRl dmljZV9ub2RlICpucCwgaW50IGluZGV4KQo+ID4gKy8qCj4gPiArICogU2ltcGxlIGhlbHBlciB0 byBjb3B5IGZ3bm9kZV9yZWZlcmVuY2VfYXJncyBpbnRvCj4gPiBvZl9waGFuZGxlX2FyZ3Mgc28g d2UKPiA+ICsgKiBjYW4gcGFzcyBpdCB0byBvZl94bGF0ZSgpLiBVbHRpbWF0ZSBnb2FsIGlzIHRv IGRyb3AgdGhpcwo+ID4gdG9nZXRoZXIgd2l0aAo+ID4gKyAqIG9mX3hsYXRlKCkuCj4gPiArICov Cj4gPiArc3RhdGljIGludCBfX2Z3bm9kZV90b19vZl94bGF0ZShzdHJ1Y3QgaWlvX2RldiAqaW5k aW9fZGV2LAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBjb25zdCBzdHJ1Y3QgZndub2RlX3JlZmVyZW5jZV9hcmdzCj4gPiAq aWlvc3BlYykKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgIHN0cnVjdCBvZl9waGFuZGxlX2FyZ3Mg b2ZfYXJnczsKPiA+ICvCoMKgwqDCoMKgwqAgdW5zaWduZWQgaW50IGk7Cj4gPiArCj4gPiArwqDC oMKgwqDCoMKgIG9mX2FyZ3MuYXJnc19jb3VudCA9IGlpb3NwZWMtPm5hcmdzOwo+ID4gK8KgwqDC oMKgwqDCoCBvZl9hcmdzLm5wID0gdG9fb2Zfbm9kZShpaW9zcGVjLT5md25vZGUpOwo+ID4gKwo+ ID4gK8KgwqDCoMKgwqDCoCBmb3IgKGkgPSAwOyBpIDwgTUFYX1BIQU5ETEVfQVJHUzsgaSsrKQo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgb2ZfYXJncy5hcmdzW2ldID0gaSA8IGlp b3NwZWMtPm5hcmdzID8gaWlvc3BlYy0KPiA+ID5hcmdzW2ldIDogMDsKPiA+ICsKPiA+ICvCoMKg wqDCoMKgwqAgcmV0dXJuIGluZGlvX2Rldi0+aW5mby0+b2ZfeGxhdGUoaW5kaW9fZGV2LCAmb2Zf YXJncyk7Cj4gPiArfQo+IAo+IEFoLCBub3cgSSByZWFsaXplZCB0aGF0IGl0J3MgYSBiaXQgbW9y ZSBjb21wbGljYXRlZCB0aGFuIGp1c3QKPiB0b19vZl9ub2RlKCkgOi0pCj4gCgpZZWFoLCBvZl9m d25vZGVfZ2V0X3JlZmVyZW5jZV9hcmdzKCkgd2FzIGhlbHBmdWxsLiBCdXQgSSBiYXNlZCBteXNl bGYKdG9vIG11Y2ggb24gaXQuIE9uIGEgc2Vjb25kIGxvb2ssIEkgZ3Vlc3MgQVJSQVlfU0laRShv Zl9hcmdzLmFyZ3MpCndvdWxkIGJlIGJldHRlciB0aGFuIE1BWF9QSEFORExFX0FSR1MuCgo+ID4g K3N0YXRpYyBpbnQgX19md25vZGVfaWlvX2NoYW5uZWxfZ2V0KHN0cnVjdCBpaW9fY2hhbm5lbCAq Y2hhbm5lbCwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgZndub2RlX2hhbmRsZSAqZndub2RlLAo+ ID4gaW50IGluZGV4KQo+ID4gwqB7Cj4gPiDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgZGV2aWNlICpp ZGV2Owo+ID4gwqDCoMKgwqDCoMKgwqAgc3RydWN0IGlpb19kZXYgKmluZGlvX2RldjsKPiA+IMKg wqDCoMKgwqDCoMKgIGludCBlcnI7Cj4gPiAtwqDCoMKgwqDCoMKgIHN0cnVjdCBvZl9waGFuZGxl X2FyZ3MgaWlvc3BlYzsKPiA+ICvCoMKgwqDCoMKgwqAgc3RydWN0IGZ3bm9kZV9yZWZlcmVuY2Vf YXJncyBpaW9zcGVjOwo+IAo+IEF0IHRoZSBzYW1lIHBvaW50IHlvdSBjYW4gbW92ZSBpdCB1cCBp biB0aGUgYmxvY2sgdG8gbWFrZSBhIGxvbmcgbGluZQo+IGZpcnN0LgoKQ2FuIGRvIHRoYXQuLi4K Cj4gCj4gPiAtwqDCoMKgwqDCoMKgIGVyciA9IG9mX3BhcnNlX3BoYW5kbGVfd2l0aF9hcmdzKG5w LCAiaW8tY2hhbm5lbHMiLAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAiI2lvLWNoYW5uZWwt Y2VsbHMiLAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbmRleCwgJmlpb3NwZWMpOwo+ID4g K8KgwqDCoMKgwqDCoCBlcnIgPSBmd25vZGVfcHJvcGVydHlfZ2V0X3JlZmVyZW5jZV9hcmdzKGZ3 bm9kZSwgImlvLQo+ID4gY2hhbm5lbHMiLAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgIiNpby1jaGFubmVsLQo+ID4gY2VsbHMiLCAwLAo+ID4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaW5kZXgsICZpaW9zcGVjKTsKPiA+IMKgwqDCoMKg wqDCoMKgIGlmIChlcnIpCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJu IGVycjsKPiA+IAo+ID4gLcKgwqDCoMKgwqDCoCBpZGV2ID0gYnVzX2ZpbmRfZGV2aWNlKCZpaW9f YnVzX3R5cGUsIE5VTEwsIGlpb3NwZWMubnAsCj4gPiArwqDCoMKgwqDCoMKgIGlkZXYgPSBidXNf ZmluZF9kZXZpY2UoJmlpb19idXNfdHlwZSwgTlVMTCwgaWlvc3BlYy5md25vZGUsCj4gPiDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg aWlvX2Rldl9ub2RlX21hdGNoKTsKPiAKPiBXb25kZXJpbmcgaWYgdGhpcwo+IGh0dHBzOi8vZWxp eGlyLmJvb3RsaW4uY29tL2xpbnV4L3Y1LjE5LXJjMS9DL2lkZW50L2J1c19maW5kX2RldmljZV9i eV9md25vZGUKPiBjYW4gYmUgdXRpbGl6ZWQgKHllcywgSSBub3RpY2VkIGlpb19kZXZpY2VfdHlw ZSBhYm92ZSkuCgpIbW0sIGF0IGZpcnN0IGdsYW5jZSBJIHdvdWxkIHNheSB3ZSBjYW4gdXNlIGl0 LiBBRkFJQ1QsIHdlIGFyZSBhbHJlYWR5CmdyYWJiaW5nIGEgbm9kZSB3aGljaCBjb250YWlucyAi I2lvLWNoYW5uZWwtY2VsbHMiIHdoaWNoIGlzIHZlcnkKaW5kaWNhdGl2ZSB0aGF0IGlzIGFuIElJ TyBkZXZpY2UuIEkgYWxzbyBmaW5kIGl0IHZlcnkgdW5saWtlbHkgdG8gaGF2ZQp0d28gSUlPIGRl dmljZXMgd2l0aCB0aGUgc2FtZSBmd25vZGUgKEkgZ3Vlc3MgaXQgd291bGQgYmUgYW4gaXNzdWUg ZXZlbgppbiB0aGUgb2xkIGNvZGUpIGFuZCBldmVuIG1vcmUgdW5saWtlbHkgdHdvIGRldmljZXMg b2YgZGlmZXJlbnQgdHlwZXMKd2l0aCB0aGUgc2FtZSBmd25vZGU/CgpBbnl3YXlzLCBJIGd1ZXNz IEpvbmF0aGFuIGNhbiBoZWxwIGluIGhlcmUuLi4KCgo+IAo+ID4gwqDCoMKgwqDCoMKgwqAgaWYg KGlkZXYgPT0gTlVMTCkgewo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgb2Zfbm9k ZV9wdXQoaWlvc3BlYy5ucCk7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBmd25v ZGVfaGFuZGxlX3B1dChpaW9zcGVjLmZ3bm9kZSk7Cj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgcmV0dXJuIC1FUFJPQkVfREVGRVI7Cj4gPiDCoMKgwqDCoMKgwqDCoCB9Cj4gPiAK PiA+IMKgwqDCoMKgwqDCoMKgIGluZGlvX2RldiA9IGRldl90b19paW9fZGV2KGlkZXYpOwo+ID4g wqDCoMKgwqDCoMKgwqAgY2hhbm5lbC0+aW5kaW9fZGV2ID0gaW5kaW9fZGV2Owo+ID4gwqDCoMKg wqDCoMKgwqAgaWYgKGluZGlvX2Rldi0+aW5mby0+b2ZfeGxhdGUpCj4gPiAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBpbmRleCA9IGluZGlvX2Rldi0+aW5mby0+b2ZfeGxhdGUoaW5kaW9f ZGV2LAo+ID4gJmlpb3NwZWMpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaW5k ZXggPSBfX2Z3bm9kZV90b19vZl94bGF0ZShpbmRpb19kZXYsICZpaW9zcGVjKTsKPiA+ICvCoMKg wqDCoMKgwqAgZWxzZSBpZiAoaW5kaW9fZGV2LT5pbmZvLT5md25vZGVfeGxhdGUpCj4gPiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbmRleCA9IGluZGlvX2Rldi0+aW5mby0+Zndub2Rl X3hsYXRlKGluZGlvX2RldiwKPiA+ICZpaW9zcGVjKTsKPiA+IMKgwqDCoMKgwqDCoMKgIGVsc2UK PiA+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGluZGV4ID0gX19vZl9paW9fc2ltcGxl X3hsYXRlKGluZGlvX2RldiwgJmlpb3NwZWMpOwo+ID4gLcKgwqDCoMKgwqDCoCBvZl9ub2RlX3B1 dChpaW9zcGVjLm5wKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGluZGV4ID0g X19md25vZGVfaWlvX3NpbXBsZV94bGF0ZShpbmRpb19kZXYsCj4gPiAmaWlvc3BlYyk7Cj4gPiAr wqDCoMKgwqDCoMKgIGZ3bm9kZV9oYW5kbGVfcHV0KGlpb3NwZWMuZndub2RlKTsKPiA+IMKgwqDC oMKgwqDCoMKgIGlmIChpbmRleCA8IDApCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgZ290byBlcnJfcHV0Owo+ID4gwqDCoMKgwqDCoMKgwqAgY2hhbm5lbC0+Y2hhbm5lbCA9ICZp bmRpb19kZXYtPmNoYW5uZWxzW2luZGV4XTsKPiA+IEBAIC0xODgsNyArMjA5LDggQEAgc3RhdGlj IGludCBfX29mX2lpb19jaGFubmVsX2dldChzdHJ1Y3QKPiA+IGlpb19jaGFubmVsICpjaGFubmVs LAo+ID4gwqDCoMKgwqDCoMKgwqAgcmV0dXJuIGluZGV4Owo+ID4gwqB9Cj4gPiAKPiA+IC1zdGF0 aWMgc3RydWN0IGlpb19jaGFubmVsICpvZl9paW9fY2hhbm5lbF9nZXQoc3RydWN0IGRldmljZV9u b2RlCj4gPiAqbnAsIGludCBpbmRleCkKPiA+ICtzdGF0aWMgc3RydWN0IGlpb19jaGFubmVsICpm d25vZGVfaWlvX2NoYW5uZWxfZ2V0KHN0cnVjdAo+ID4gZndub2RlX2hhbmRsZSAqZndub2RlLAo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbnQgaW5kZXgpCj4g PiDCoHsKPiA+IMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbm5lbDsKPiA+ IMKgwqDCoMKgwqDCoMKgIGludCBlcnI7Cj4gPiBAQCAtMjAwLDcgKzIyMiw3IEBAIHN0YXRpYyBz dHJ1Y3QgaWlvX2NoYW5uZWwKPiA+ICpvZl9paW9fY2hhbm5lbF9nZXQoc3RydWN0IGRldmljZV9u b2RlICpucCwgaW50IGluZGV4KQo+ID4gwqDCoMKgwqDCoMKgwqAgaWYgKGNoYW5uZWwgPT0gTlVM TCkKPiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gRVJSX1BUUigtRU5P TUVNKTsKPiA+IAo+ID4gLcKgwqDCoMKgwqDCoCBlcnIgPSBfX29mX2lpb19jaGFubmVsX2dldChj aGFubmVsLCBucCwgaW5kZXgpOwo+ID4gK8KgwqDCoMKgwqDCoCBlcnIgPSBfX2Z3bm9kZV9paW9f Y2hhbm5lbF9nZXQoY2hhbm5lbCwgZndub2RlLCBpbmRleCk7Cj4gPiDCoMKgwqDCoMKgwqDCoCBp ZiAoZXJyKQo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGdvdG8gZXJyX2ZyZWVf Y2hhbm5lbDsKPiA+IAo+ID4gQEAgLTIxMSw5ICsyMzMsOSBAQCBzdGF0aWMgc3RydWN0IGlpb19j aGFubmVsCj4gPiAqb2ZfaWlvX2NoYW5uZWxfZ2V0KHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsIGlu dCBpbmRleCkKPiA+IMKgwqDCoMKgwqDCoMKgIHJldHVybiBFUlJfUFRSKGVycik7Cj4gPiDCoH0K PiA+IAo+ID4gLXN0cnVjdCBpaW9fY2hhbm5lbCAqX19vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFt ZShzdHJ1Y3QKPiA+IGRldmljZV9ub2RlICpucCwKPiA+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIGNvbnN0IGNoYXIgKm5hbWUsCj4gPiAtwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCBib29sCj4gPiAqcGFyZW50X2xvb2t1cCkKPiA+ICtzdHJ1Y3Qg aWlvX2NoYW5uZWwgKgo+ID4gK19fZndub2RlX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKHN0cnVj dCBmd25vZGVfaGFuZGxlICpmd25vZGUsCj4gPiBjb25zdCBjaGFyICpuYW1lLAo+ID4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGJvb2wgKnBhcmVudF9sb29rdXApCj4gPiDCoHsKPiA+IMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBp aW9fY2hhbm5lbCAqY2hhbjsKPiA+IMKgwqDCoMKgwqDCoMKgIGludCBpbmRleCA9IDA7Cj4gPiBA QCAtMjIxLDMyICsyNDMsMzQgQEAgc3RydWN0IGlpb19jaGFubmVsCj4gPiAqX19vZl9paW9fY2hh bm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAo+ID4gwqDCoMKgwqDCoMKg wqAgLyoKPiA+IMKgwqDCoMKgwqDCoMKgwqAgKiBGb3IgbmFtZWQgaWlvIGNoYW5uZWxzLCBmaXJz dCBsb29rIHVwIHRoZSBuYW1lIGluIHRoZQo+ID4gwqDCoMKgwqDCoMKgwqDCoCAqICJpby1jaGFu bmVsLW5hbWVzIiBwcm9wZXJ0eS7CoCBJZiBpdCBjYW5ub3QgYmUgZm91bmQsIHRoZQo+ID4gLcKg wqDCoMKgwqDCoMKgICogaW5kZXggd2lsbCBiZSBhbiBlcnJvciBjb2RlLCBhbmQgb2ZfaWlvX2No YW5uZWxfZ2V0KCkKPiA+ICvCoMKgwqDCoMKgwqDCoCAqIGluZGV4IHdpbGwgYmUgYW4gZXJyb3Ig Y29kZSwgYW5kCj4gPiBmd25vZGVfaWlvX2NoYW5uZWxfZ2V0KCkKPiA+IMKgwqDCoMKgwqDCoMKg wqAgKiB3aWxsIGZhaWwuCj4gPiDCoMKgwqDCoMKgwqDCoMKgICovCj4gPiDCoMKgwqDCoMKgwqDC oCBpZiAobmFtZSkKPiA+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGluZGV4ID0gb2Zf cHJvcGVydHlfbWF0Y2hfc3RyaW5nKG5wLCAiaW8tY2hhbm5lbC0KPiA+IG5hbWVzIiwgbmFtZSk7 Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbmRleCA9IGZ3bm9kZV9wcm9wZXJ0 eV9tYXRjaF9zdHJpbmcoZndub2RlLCAiaW8tCj4gPiBjaGFubmVsLW5hbWVzIiwKPiA+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbmFtZSk7Cj4gPiAKPiA+ IC3CoMKgwqDCoMKgwqAgY2hhbiA9IG9mX2lpb19jaGFubmVsX2dldChucCwgaW5kZXgpOwo+ID4g K8KgwqDCoMKgwqDCoCBjaGFuID0gZndub2RlX2lpb19jaGFubmVsX2dldChmd25vZGUsIGluZGV4 KTsKPiA+IMKgwqDCoMKgwqDCoMKgIGlmICghSVNfRVJSKGNoYW4pIHx8IFBUUl9FUlIoY2hhbikg PT0gLUVQUk9CRV9ERUZFUikgewo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICpw YXJlbnRfbG9va3VwID0gZmFsc2U7Cj4gPiDCoMKgwqDCoMKgwqDCoCB9IGVsc2UgaWYgKG5hbWUg JiYgaW5kZXggPj0gMCkgewo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcHJfZXJy KCJFUlJPUjogY291bGQgbm90IGdldCBJSU8gY2hhbm5lbAo+ID4gJXBPRjolcyglaSlcbiIsCj4g PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG5wLCBuYW1lID8g bmFtZSA6ICIiLCBpbmRleCk7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwcl9l cnIoIkVSUk9SOiBjb3VsZCBub3QgZ2V0IElJTyBjaGFubmVsCj4gPiAlcGZ3OiVzKCVpKVxuIiwK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZndub2RlLCBu YW1lID8gbmFtZSA6ICIiLCBpbmRleCk7Cj4gCj4gU2luY2UgeW91IGFyZSB0b3VjaGluZyB0aGlz IGxpbmUgY2FuIHlvdSBzd2l0Y2ggdG8gbmFtZSA/OiAiIiBhbmQKPiBwb3NzaWJseSBtb3ZlIHNv bWUgcGFyYW1ldGVycyB0byB0aGUgYWJvdmUgbGluZT8KCklmIGl0IGRvZXMgbm90IGNyb3NzIHRo ZSA4MGxpbWl0IGNvbCwgc3VyZS4gCj4gCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgKnBhcmVudF9sb29rdXAgPSBmYWxzZTsKPiA+IMKgwqDCoMKgwqDCoMKgIH0KPiA+IAo+ID4g wqDCoMKgwqDCoMKgwqAgcmV0dXJuIGNoYW47Cj4gPiDCoH0KPiA+IAo+ID4gLXN0cnVjdCBpaW9f Y2hhbm5lbCAqb2ZfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoc3RydWN0IGRldmljZV9ub2RlCj4g PiAqbnAsCj4gPiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNvbnN0IGNoYXIg Km5hbWUpCj4gPiArc3RydWN0IGlpb19jaGFubmVsICpmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5 X25hbWUoc3RydWN0Cj4gPiBmd25vZGVfaGFuZGxlICpmd25vZGUsCj4gPiArwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY29uc3QgY2hhcgo+ID4gKm5hbWUpCj4gPiDC oHsKPiA+IMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbjsKPiA+ICvCoMKg wqDCoMKgwqAgc3RydWN0IGZ3bm9kZV9oYW5kbGUgKnBhcmVudDsKPiA+IMKgwqDCoMKgwqDCoMKg IGJvb2wgcGFyZW50X2xvb2t1cCA9IHRydWU7Cj4gPiAKPiA+IMKgwqDCoMKgwqDCoMKgIC8qIFdh bGsgdXAgdGhlIHRyZWUgb2YgZGV2aWNlcyBsb29raW5nIGZvciBhIG1hdGNoaW5nIGlpbwo+ID4g Y2hhbm5lbCAqLwo+ID4gLcKgwqDCoMKgwqDCoCBjaGFuID0gX19vZl9paW9fY2hhbm5lbF9nZXRf YnlfbmFtZShucCwgbmFtZSwKPiA+ICZwYXJlbnRfbG9va3VwKTsKPiA+ICvCoMKgwqDCoMKgwqAg Y2hhbiA9IF9fZndub2RlX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKGZ3bm9kZSwgbmFtZSwKPiA+ ICZwYXJlbnRfbG9va3VwKTsKPiA+IMKgwqDCoMKgwqDCoMKgIGlmICghcGFyZW50X2xvb2t1cCkK PiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gY2hhbjsKPiA+IAo+ID4g QEAgLTI1NSwzMyArMjc5LDM0IEBAIHN0cnVjdCBpaW9fY2hhbm5lbAo+ID4gKm9mX2lpb19jaGFu bmVsX2dldF9ieV9uYW1lKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsCj4gPiDCoMKgwqDCoMKgwqDC oMKgICogSWYgdGhlIHBhcmVudCBub2RlIGhhcyBhICJpby1jaGFubmVsLXJhbmdlcyIgcHJvcGVy dHksCj4gPiDCoMKgwqDCoMKgwqDCoMKgICogdGhlbiB3ZSBjYW4gdHJ5IG9uZSBvZiBpdHMgY2hh bm5lbHMuCj4gPiDCoMKgwqDCoMKgwqDCoMKgICovCj4gPiAtwqDCoMKgwqDCoMKgIG5wID0gbnAt PnBhcmVudDsKPiA+IC3CoMKgwqDCoMKgwqAgd2hpbGUgKG5wKSB7Cj4gPiAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBpZiAoIW9mX2dldF9wcm9wZXJ0eShucCwgImlvLWNoYW5uZWwtcmFu Z2VzIiwKPiA+IE5VTEwpKQo+ID4gK8KgwqDCoMKgwqDCoCBmd25vZGVfZm9yX2VhY2hfcGFyZW50 X25vZGUoZndub2RlLCBwYXJlbnQpIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGlmICghZndub2RlX3Byb3BlcnR5X3ByZXNlbnQocGFyZW50LCAiaW8tY2hhbm5lbC0KPiA+IHJh bmdlcyIpKSB7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgZndub2RlX2hhbmRsZV9wdXQocGFyZW50KTsKPiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIGNoYW47Cj4gCj4gYnJlYWs7ID8KClRoZSBy ZXR1cm4gaW4gcGxhY2Ugd2FzIGEgcmVxdWVzdCBmcm9tIEpvbmF0aGFuIGluIHRoZSBSRkMuLi4K Cj4gCj4gKFllcywgSSB1bmRlcnN0YW5kIHByb3MgYW5kIGNvbnMgb2YgZWFjaCB2YXJpYW50LCB1 cCB0byB5b3UpCj4gCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB9Cj4gPiAKPiA+ IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNoYW4gPSBfX29mX2lpb19jaGFubmVsX2dl dF9ieV9uYW1lKG5wLCBuYW1lLAo+ID4gJnBhcmVudF9sb29rdXApOwo+ID4gLcKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgaWYgKCFwYXJlbnRfbG9va3VwKQo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgY2hhbiA9IF9fZndub2RlX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKHBh cmVudCwKPiA+IG5hbWUsICZwYXJlbnRfbG9va3VwKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGlmICghcGFyZW50X2xvb2t1cCkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGZ3bm9kZV9oYW5kbGVfcHV0KHBhcmVudCk7Cj4gPiDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBjaGFu Owo+IAo+IERpdHRvLgo+IAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbnAgPSBu cC0+cGFyZW50Owo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfQo+ID4gwqDCoMKg wqDCoMKgwqAgfQo+ID4gCj4gPiDCoMKgwqDCoMKgwqDCoCByZXR1cm4gY2hhbjsKPiA+IMKgfQo+ ID4gLUVYUE9SVF9TWU1CT0xfR1BMKG9mX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKTsKPiA+ICtF WFBPUlRfU1lNQk9MX0dQTChmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUpOwo+IAo+IFdv bmRlcmluZyBpZiB3ZSBtYXkgbW92ZSB0aGlzIHRvIHRoZSBJSU8gbmFtZXNwYWNlLgoKSSBndWVz cyBpdCBtYWtlcyBzZW5zZSBidXQgc3VyZWx5IG9uIGEgZGlmZmVyZW50IHBhdGNoLi4uCgo+IAo+ ID4gLXN0YXRpYyBzdHJ1Y3QgaWlvX2NoYW5uZWwgKm9mX2lpb19jaGFubmVsX2dldF9hbGwoc3Ry dWN0IGRldmljZQo+ID4gKmRldikKPiA+ICtzdGF0aWMgc3RydWN0IGlpb19jaGFubmVsICpmd25v ZGVfaWlvX2NoYW5uZWxfZ2V0X2FsbChzdHJ1Y3QKPiA+IGRldmljZSAqZGV2KQo+ID4gwqB7Cj4g PiArwqDCoMKgwqDCoMKgIHN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUgPSBkZXZfZndub2Rl KGRldik7Cj4gPiDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgaWlvX2NoYW5uZWwgKmNoYW5zOwo+ID4g wqDCoMKgwqDCoMKgwqAgaW50IGksIG1hcGluZCwgbnVtbWFwcyA9IDA7Cj4gPiDCoMKgwqDCoMKg wqDCoCBpbnQgcmV0Owo+ID4gCj4gPiDCoMKgwqDCoMKgwqDCoCBkbyB7Cj4gPiAtwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCByZXQgPSBvZl9wYXJzZV9waGFuZGxlX3dpdGhfYXJncyhkZXYt Pm9mX25vZGUsCj4gPiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAiaW8t Y2hhbm5lbHMiLAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgIiNp by1jaGFubmVsLQo+ID4gY2VsbHMiLAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgbnVtbWFwcywgTlVMTCk7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCByZXQgPSBmd25vZGVfcHJvcGVydHlfZ2V0X3JlZmVyZW5jZV9hcmdzKGZ3bm9kZSwKPiA+ICJp by1jaGFubmVscyIsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgIiNpby0KPiA+IGNoYW5uZWwtY2VsbHMiLCAwLAo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG51bW1hcHMsCj4g PiBOVUxMKTsKPiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZiAocmV0IDwgMCkK PiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgYnJlYWs7 Cj4gPiDCoMKgwqDCoMKgwqDCoCB9IHdoaWxlICgrK251bW1hcHMpOwo+ID4gQEAgLTI5NCwxMCAr MzE5LDkgQEAgc3RhdGljIHN0cnVjdCBpaW9fY2hhbm5lbAo+ID4gKm9mX2lpb19jaGFubmVsX2dl dF9hbGwoc3RydWN0IGRldmljZSAqZGV2KQo+ID4gwqDCoMKgwqDCoMKgwqAgaWYgKGNoYW5zID09 IE5VTEwpCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIEVSUl9QVFIo LUVOT01FTSk7Cj4gPiAKPiA+IC3CoMKgwqDCoMKgwqAgLyogU2VhcmNoIGZvciBPRiBtYXRjaGVz ICovCj4gPiArwqDCoMKgwqDCoMKgIC8qIFNlYXJjaCBmb3IgRlcgbWF0Y2hlcyAqLwo+ID4gwqDC oMKgwqDCoMKgwqAgZm9yIChtYXBpbmQgPSAwOyBtYXBpbmQgPCBudW1tYXBzOyBtYXBpbmQrKykg ewo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0ID0gX19vZl9paW9fY2hhbm5l bF9nZXQoJmNoYW5zW21hcGluZF0sIGRldi0KPiA+ID5vZl9ub2RlLAo+ID4gLcKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgbWFwaW5kKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHJldCA9IF9fZndub2RlX2lpb19jaGFubmVsX2dldCgmY2hhbnNbbWFwaW5kXSwKPiA+IGZ3bm9k ZSwgbWFwaW5kKTsKPiA+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZiAocmV0KQo+ ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIGVy cm9yX2ZyZWVfY2hhbnM7Cj4gPiDCoMKgwqDCoMKgwqDCoCB9Cj4gPiBAQCAtMzEwLDE1ICszMzQs NiBAQCBzdGF0aWMgc3RydWN0IGlpb19jaGFubmVsCj4gPiAqb2ZfaWlvX2NoYW5uZWxfZ2V0X2Fs bChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gPiDCoMKgwqDCoMKgwqDCoCByZXR1cm4gRVJSX1BUUihy ZXQpOwo+ID4gwqB9Cj4gPiAKPiA+IC0jZWxzZSAvKiBDT05GSUdfT0YgKi8KPiA+IC0KPiA+IC1z dGF0aWMgaW5saW5lIHN0cnVjdCBpaW9fY2hhbm5lbCAqb2ZfaWlvX2NoYW5uZWxfZ2V0X2FsbChz dHJ1Y3QKPiA+IGRldmljZSAqZGV2KQo+ID4gLXsKPiA+IC3CoMKgwqDCoMKgwqAgcmV0dXJuIEVS Ul9QVFIoLUVOT0RFVik7Cj4gPiAtfQo+ID4gLQo+ID4gLSNlbmRpZiAvKiBDT05GSUdfT0YgKi8K PiA+IC0KPiA+IMKgc3RhdGljIHN0cnVjdCBpaW9fY2hhbm5lbCAqaWlvX2NoYW5uZWxfZ2V0X3N5 cyhjb25zdCBjaGFyICpuYW1lLAo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgY29uc3QgY2hhcgo+ID4gKmNoYW5uZWxfbmFtZSkKPiA+IMKgewo+ID4gQEAgLTM3OSw4ICsz OTQsOCBAQCBzdHJ1Y3QgaWlvX2NoYW5uZWwgKmlpb19jaGFubmVsX2dldChzdHJ1Y3QKPiA+IGRl dmljZSAqZGV2LAo+ID4gwqDCoMKgwqDCoMKgwqAgc3RydWN0IGlpb19jaGFubmVsICpjaGFubmVs Owo+ID4gCj4gPiDCoMKgwqDCoMKgwqDCoCBpZiAoZGV2KSB7Cj4gPiAtwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCBjaGFubmVsID0gb2ZfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoZGV2LT5v Zl9ub2RlLAo+ID4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBjaGFubmVsX25hbWUpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY2hhbm5l bCA9Cj4gPiBmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoZGV2X2Z3bm9kZShkZXYpLAo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg Cj4gPiBjaGFubmVsX25hbWUpOwo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlm ICghSVNfRVJSKGNoYW5uZWwpIHx8IFBUUl9FUlIoY2hhbm5lbCkgPT0gLQo+ID4gRVBST0JFX0RF RkVSKQo+ID4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBy ZXR1cm4gY2hhbm5lbDsKPiA+IMKgwqDCoMKgwqDCoMKgIH0KPiA+IEBAIC00MjEsMTQgKzQzNiwx NCBAQCBzdHJ1Y3QgaWlvX2NoYW5uZWwKPiA+ICpkZXZtX2lpb19jaGFubmVsX2dldChzdHJ1Y3Qg ZGV2aWNlICpkZXYsCj4gPiDCoH0KPiA+IMKgRVhQT1JUX1NZTUJPTF9HUEwoZGV2bV9paW9fY2hh bm5lbF9nZXQpOwo+ID4gCj4gPiAtc3RydWN0IGlpb19jaGFubmVsICpkZXZtX29mX2lpb19jaGFu bmVsX2dldF9ieV9uYW1lKHN0cnVjdCBkZXZpY2UKPiA+ICpkZXYsCj4gPiAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QKPiA+IGRldmljZV9ub2RlICpu cCwKPiA+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNvbnN0 IGNoYXIKPiA+ICpjaGFubmVsX25hbWUpCj4gPiArc3RydWN0IGlpb19jaGFubmVsICpkZXZtX2Z3 bm9kZV9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QKPiA+IGRldmljZSAqZGV2LAo+ID4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1 Y3QKPiA+IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY29uc3QgY2hhcgo+ID4gKmNoYW5uZWxfbmFt ZSkKPiA+IMKgewo+ID4gwqDCoMKgwqDCoMKgwqAgc3RydWN0IGlpb19jaGFubmVsICpjaGFubmVs Owo+ID4gwqDCoMKgwqDCoMKgwqAgaW50IHJldDsKPiA+IAo+ID4gLcKgwqDCoMKgwqDCoCBjaGFu bmVsID0gb2ZfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUobnAsIGNoYW5uZWxfbmFtZSk7Cj4gPiAr wqDCoMKgwqDCoMKgIGNoYW5uZWwgPSBmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoZndu b2RlLAo+ID4gY2hhbm5lbF9uYW1lKTsKPiA+IMKgwqDCoMKgwqDCoMKgIGlmIChJU19FUlIoY2hh bm5lbCkpCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIGNoYW5uZWw7 Cj4gPiAKPiA+IEBAIC00MzgsNyArNDUzLDcgQEAgc3RydWN0IGlpb19jaGFubmVsCj4gPiAqZGV2 bV9vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gPiAKPiA+ IMKgwqDCoMKgwqDCoMKgIHJldHVybiBjaGFubmVsOwo+ID4gwqB9Cj4gPiAtRVhQT1JUX1NZTUJP TF9HUEwoZGV2bV9vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZSk7Cj4gPiArRVhQT1JUX1NZTUJP TF9HUEwoZGV2bV9md25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUpOwo+ID4gCj4gPiDCoHN0 cnVjdCBpaW9fY2hhbm5lbCAqaWlvX2NoYW5uZWxfZ2V0X2FsbChzdHJ1Y3QgZGV2aWNlICpkZXYp Cj4gPiDCoHsKPiA+IEBAIC00NTIsNyArNDY3LDcgQEAgc3RydWN0IGlpb19jaGFubmVsICppaW9f Y2hhbm5lbF9nZXRfYWxsKHN0cnVjdAo+ID4gZGV2aWNlICpkZXYpCj4gPiDCoMKgwqDCoMKgwqDC oCBpZiAoZGV2ID09IE5VTEwpCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0 dXJuIEVSUl9QVFIoLUVJTlZBTCk7Cj4gPiAKPiA+IC3CoMKgwqDCoMKgwqAgY2hhbnMgPSBvZl9p aW9fY2hhbm5lbF9nZXRfYWxsKGRldik7Cj4gPiArwqDCoMKgwqDCoMKgIGNoYW5zID0gZndub2Rl X2lpb19jaGFubmVsX2dldF9hbGwoZGV2KTsKPiA+IMKgwqDCoMKgwqDCoMKgIGlmICghSVNfRVJS KGNoYW5zKSB8fCBQVFJfRVJSKGNoYW5zKSA9PSAtRVBST0JFX0RFRkVSKQo+ID4gwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBjaGFuczsKPiA+IAo+ID4gZGlmZiAtLWdpdCBh L2luY2x1ZGUvbGludXgvaWlvL2NvbnN1bWVyLmgKPiA+IGIvaW5jbHVkZS9saW51eC9paW8vY29u c3VtZXIuaAo+ID4gaW5kZXggNWZhNTk1NzU4NmNmLi5hOTZhNzE0YjVmZGMgMTAwNjQ0Cj4gPiAt LS0gYS9pbmNsdWRlL2xpbnV4L2lpby9jb25zdW1lci5oCj4gPiArKysgYi9pbmNsdWRlL2xpbnV4 L2lpby9jb25zdW1lci5oCj4gPiBAQCAtOSwxMSArOSwxMyBAQAo+ID4gCj4gPiDCoCNpbmNsdWRl IDxsaW51eC90eXBlcy5oPgo+ID4gwqAjaW5jbHVkZSA8bGludXgvaWlvL3R5cGVzLmg+Cj4gCj4g PiArI2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gCj4gT3JkZXJpbmcuIElJTyBoYXMgc3BlY2lhbCBt ZWFuaW5nIGhlcmUsIHRoYXQncyB3aHkgaXQncyBsYXN0LgoKb2suLi4KCi0gTnVubyBTw6EKCgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtbWVk aWF0ZWsgbWFpbGluZyBsaXN0CkxpbnV4LW1lZGlhdGVrQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0 cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1tZWRpYXRlawo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.ozlabs.org (lists.ozlabs.org [112.213.38.117]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A544EC43334 for ; Thu, 16 Jun 2022 02:26:33 +0000 (UTC) Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4LNmJS2BMSz3fPP for ; Thu, 16 Jun 2022 12:26:32 +1000 (AEST) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=gR/G++1j; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gmail.com (client-ip=2a00:1450:4864:20::32f; helo=mail-wm1-x32f.google.com; envelope-from=noname.nuno@gmail.com; receiver=) Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20210112 header.b=gR/G++1j; dkim-atps=neutral Received: from mail-wm1-x32f.google.com (mail-wm1-x32f.google.com [IPv6:2a00:1450:4864:20::32f]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4LKX0F3HK2z2yMf for ; Sat, 11 Jun 2022 06:01:16 +1000 (AEST) Received: by mail-wm1-x32f.google.com with SMTP id r187-20020a1c44c4000000b0039c76434147so1634700wma.1 for ; Fri, 10 Jun 2022 13:01:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:subject:from:to:cc:date:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=2YSKLRduvMh8Ck87NHw9tHP5D4LoKiAtBQhGBpQbX8A=; b=gR/G++1jfOEzvcHno81WYhGhDWujpMOrzQlWbw/Zh0c4i+KvoB9JLQId+negoXp1Sz aE9pnEjstwJwLA+hUxghqK35hRoOz62QkKF3gPxwQJ60YGwM5CxqUnt1LDlocalf80LM Lt/8BGddQB/CE21IkndMVeeGO3iH/lidVOjbX4poHomqAlHJ4nH3NxqUTdDBddZfDhCC SlXmbuGQDroEt9jmN0YFLC+p03mrdwZkyN6nxyTJ9h2uatv+H0aGATDgtomzZF32cEBO VOokeMPK16kt8DgGexcZvcyj7N0HXeDMWjw8ktki3yHnomdbYiXQeByD1BFfHepypTzz qrzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=2YSKLRduvMh8Ck87NHw9tHP5D4LoKiAtBQhGBpQbX8A=; b=jJVpSoJjOhpWwGmL2WS8YOA4ZlNi8Xr+ZydKwAYLZqMPYUKJd8iTiXImxtlxx2RW/7 quSpt3zbGr5g9viIaQrGxu1eEyhaHGHXZuAARKMj61HwFQANQvPdFezIyCl+BbiquUli bL2L4koWgGUHRXTNExhSjf4oHqrKamuET1yKFi9ZvPTyFvdEE4QAXyJ0kIifDPXQZWWI 0ARhKJNk06ae8aZI9Vf5MUrzKiBQqZypV51ClZRVIqnLXJk8mlUZL70I9Qdd7cpfWu0F yvCsz/jbSEDaYV+QBEVsDp5s2RJ9ajBTLLIzZBxO8oWfv8iO2jyii5Egj/Wqrh2TVdHm FgCg== X-Gm-Message-State: AOAM531XztA8wVVJlA7wcolggM5KUKtjYTxIJaVa6Gzl1EAN93S7v6oX 5WEzPkbaoFIMVhlpDEwsSWI= X-Google-Smtp-Source: ABdhPJzrLLwHku4oE77pzyt+7olow27HPFl66zU7rgD6BG8IagfgMHfQBTHa/t06C9XmSrKuzPqjlQ== X-Received: by 2002:a05:600c:2105:b0:39c:381c:1e13 with SMTP id u5-20020a05600c210500b0039c381c1e13mr1303579wml.189.1654891272383; Fri, 10 Jun 2022 13:01:12 -0700 (PDT) Received: from ?IPv6:2001:a61:136e:3c01:8bd4:cf6f:76f1:a861? ([2001:a61:136e:3c01:8bd4:cf6f:76f1:a861]) by smtp.gmail.com with ESMTPSA id a4-20020adff7c4000000b0021033caa332sm338933wrq.42.2022.06.10.13.01.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Jun 2022 13:01:11 -0700 (PDT) Message-ID: <97b9278953d923008a4c1230ca9bd354117e7213.camel@gmail.com> Subject: Re: [PATCH 24/34] iio: inkern: move to fwnode properties From: Nuno =?ISO-8859-1?Q?S=E1?= To: Andy Shevchenko , Nuno =?ISO-8859-1?Q?S=E1?= Date: Fri, 10 Jun 2022 22:01:09 +0200 In-Reply-To: References: <20220610084545.547700-1-nuno.sa@analog.com> <20220610084545.547700-25-nuno.sa@analog.com> Content-Type: text/plain; charset="UTF-8" User-Agent: Evolution 3.42.4 (3.42.4-2.fc35) MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Mailman-Approved-At: Thu, 16 Jun 2022 12:05:36 +1000 X-BeenThere: openbmc@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Development list for OpenBMC List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Alexandre Belloni , Daniel Lezcano , Tomer Maimon , "Rafael J. Wysocki" , linux-iio , Linus Walleij , Amit Kucheria , Alexandre Torgue , Tali Perry , Paul Cercueil , Miquel Raynal , Guenter Roeck , Fabio Estevam , linux-stm32@st-md-mailman.stormreply.com, chrome-platform@lists.linux.dev, Lars-Peter Clausen , Benjamin Fair , OpenBMC Maillist , Jishnu Prakash , Haibo Chen , Andy Gross , dl-linux-imx , Olivier Moysan , Zhang Rui , Christophe Branchereau , Saravanan Sekar , Michael Hennerich , linux-arm-msm , Sascha Hauer , Nicolas Ferre , Lad Prabhakar , Fabrice Gasnier , "moderated list:ARM/Mediatek SoC support" , Eugen Hristev , Matthias Brugger , Gwendal Grignou , Bjorn Andersson , Benson Leung , Pengutronix Kernel Team , linux-arm Mailing List , Lorenzo Bianconi , Avi Fishman , Patrick Venture , "open list:BROADCOM NVRAM DRIVER" , Thara Gopinath , Linux-Renesas , Arnd Bergmann , Maxime Coquelin , Cai Huoqing , Shawn Guo , Claudiu Beznea , Jonathan Cameron Errors-To: openbmc-bounces+openbmc=archiver.kernel.org@lists.ozlabs.org Sender: "openbmc" On Fri, 2022-06-10 at 17:19 +0200, Andy Shevchenko wrote: > On Fri, Jun 10, 2022 at 10:48 AM Nuno Sá wrote: > > > > This moves the IIO in kernel interface to use fwnode properties and > > thus > > be firmware agnostic. > > > > Note that the interface is still not firmware agnostic. At this > > point we > > have both OF and fwnode interfaces so that we don't break any user. > > On > > top of this we also want to have a per driver conversion and that > > is the > > main reason we have both of_xlate() and fwnode_xlate() support. > > Reviewed-by: Andy Shevchenko > Thanks! > > A few nit-picks below, though. > > > Signed-off-by: Nuno Sá > > --- > >  drivers/iio/inkern.c         | 145 +++++++++++++++++++------------ > > ---- > >  include/linux/iio/consumer.h |  36 +++++---- > >  include/linux/iio/iio.h      |   5 ++ > >  3 files changed, 105 insertions(+), 81 deletions(-) > > > > diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c > > index dde47324b826..1d519b0cacea 100644 > > --- a/drivers/iio/inkern.c > > +++ b/drivers/iio/inkern.c > > @@ -5,6 +5,7 @@ > >   */ > >  #include > >  #include > > +#include > >  #include > >  #include > >  #include > > @@ -117,15 +118,13 @@ static const struct iio_chan_spec > >         return chan; > >  } > > > > -#ifdef CONFIG_OF > > - > >  static int iio_dev_node_match(struct device *dev, const void > > *data) > >  { > > -       return dev->of_node == data && dev->type == > > &iio_device_type; > > +       return device_match_fwnode(dev, data) && dev->type == > > &iio_device_type; > >  } > > > >  /** > > - * __of_iio_simple_xlate - translate iiospec to the IIO channel > > index > > + * __fwnode_iio_simple_xlate - translate iiospec to the IIO > > channel index > >   * @indio_dev: pointer to the iio_dev structure > >   * @iiospec:   IIO specifier as found in the device tree > >   * > > @@ -134,14 +133,14 @@ static int iio_dev_node_match(struct device > > *dev, const void *data) > >   * whether IIO index is less than num_channels (that is specified > > in the > >   * iio_dev). > >   */ > > -static int __of_iio_simple_xlate(struct iio_dev *indio_dev, > > -                               const struct of_phandle_args > > *iiospec) > > +static int __fwnode_iio_simple_xlate(struct iio_dev *indio_dev, > > +                                    const struct > > fwnode_reference_args *iiospec) > >  { > > -       if (!iiospec->args_count) > > +       if (!iiospec->nargs) > >                 return 0; > > > >         if (iiospec->args[0] >= indio_dev->num_channels) { > > -               dev_err(&indio_dev->dev, "invalid channel index > > %u\n", > > +               dev_err(&indio_dev->dev, "invalid channel index > > %llu\n", > >                         iiospec->args[0]); > >                 return -EINVAL; > >         } > > @@ -149,34 +148,56 @@ static int __of_iio_simple_xlate(struct > > iio_dev *indio_dev, > >         return iiospec->args[0]; > >  } > > > > -static int __of_iio_channel_get(struct iio_channel *channel, > > -                               struct device_node *np, int index) > > +/* > > + * Simple helper to copy fwnode_reference_args into > > of_phandle_args so we > > + * can pass it to of_xlate(). Ultimate goal is to drop this > > together with > > + * of_xlate(). > > + */ > > +static int __fwnode_to_of_xlate(struct iio_dev *indio_dev, > > +                               const struct fwnode_reference_args > > *iiospec) > > +{ > > +       struct of_phandle_args of_args; > > +       unsigned int i; > > + > > +       of_args.args_count = iiospec->nargs; > > +       of_args.np = to_of_node(iiospec->fwnode); > > + > > +       for (i = 0; i < MAX_PHANDLE_ARGS; i++) > > +               of_args.args[i] = i < iiospec->nargs ? iiospec- > > >args[i] : 0; > > + > > +       return indio_dev->info->of_xlate(indio_dev, &of_args); > > +} > > Ah, now I realized that it's a bit more complicated than just > to_of_node() :-) > Yeah, of_fwnode_get_reference_args() was helpfull. But I based myself too much on it. On a second look, I guess ARRAY_SIZE(of_args.args) would be better than MAX_PHANDLE_ARGS. > > +static int __fwnode_iio_channel_get(struct iio_channel *channel, > > +                                   struct fwnode_handle *fwnode, > > int index) > >  { > >         struct device *idev; > >         struct iio_dev *indio_dev; > >         int err; > > -       struct of_phandle_args iiospec; > > +       struct fwnode_reference_args iiospec; > > At the same point you can move it up in the block to make a long line > first. Can do that... > > > -       err = of_parse_phandle_with_args(np, "io-channels", > > -                                        "#io-channel-cells", > > -                                        index, &iiospec); > > +       err = fwnode_property_get_reference_args(fwnode, "io- > > channels", > > +                                                "#io-channel- > > cells", 0, > > +                                                index, &iiospec); > >         if (err) > >                 return err; > > > > -       idev = bus_find_device(&iio_bus_type, NULL, iiospec.np, > > +       idev = bus_find_device(&iio_bus_type, NULL, iiospec.fwnode, > >                                iio_dev_node_match); > > Wondering if this > https://elixir.bootlin.com/linux/v5.19-rc1/C/ident/bus_find_device_by_fwnode > can be utilized (yes, I noticed iio_device_type above). Hmm, at first glance I would say we can use it. AFAICT, we are already grabbing a node which contains "#io-channel-cells" which is very indicative that is an IIO device. I also find it very unlikely to have two IIO devices with the same fwnode (I guess it would be an issue even in the old code) and even more unlikely two devices of diferent types with the same fwnode? Anyways, I guess Jonathan can help in here... > > >         if (idev == NULL) { > > -               of_node_put(iiospec.np); > > +               fwnode_handle_put(iiospec.fwnode); > >                 return -EPROBE_DEFER; > >         } > > > >         indio_dev = dev_to_iio_dev(idev); > >         channel->indio_dev = indio_dev; > >         if (indio_dev->info->of_xlate) > > -               index = indio_dev->info->of_xlate(indio_dev, > > &iiospec); > > +               index = __fwnode_to_of_xlate(indio_dev, &iiospec); > > +       else if (indio_dev->info->fwnode_xlate) > > +               index = indio_dev->info->fwnode_xlate(indio_dev, > > &iiospec); > >         else > > -               index = __of_iio_simple_xlate(indio_dev, &iiospec); > > -       of_node_put(iiospec.np); > > +               index = __fwnode_iio_simple_xlate(indio_dev, > > &iiospec); > > +       fwnode_handle_put(iiospec.fwnode); > >         if (index < 0) > >                 goto err_put; > >         channel->channel = &indio_dev->channels[index]; > > @@ -188,7 +209,8 @@ static int __of_iio_channel_get(struct > > iio_channel *channel, > >         return index; > >  } > > > > -static struct iio_channel *of_iio_channel_get(struct device_node > > *np, int index) > > +static struct iio_channel *fwnode_iio_channel_get(struct > > fwnode_handle *fwnode, > > +                                                 int index) > >  { > >         struct iio_channel *channel; > >         int err; > > @@ -200,7 +222,7 @@ static struct iio_channel > > *of_iio_channel_get(struct device_node *np, int index) > >         if (channel == NULL) > >                 return ERR_PTR(-ENOMEM); > > > > -       err = __of_iio_channel_get(channel, np, index); > > +       err = __fwnode_iio_channel_get(channel, fwnode, index); > >         if (err) > >                 goto err_free_channel; > > > > @@ -211,9 +233,9 @@ static struct iio_channel > > *of_iio_channel_get(struct device_node *np, int index) > >         return ERR_PTR(err); > >  } > > > > -struct iio_channel *__of_iio_channel_get_by_name(struct > > device_node *np, > > -                                                const char *name, > > -                                                bool > > *parent_lookup) > > +struct iio_channel * > > +__fwnode_iio_channel_get_by_name(struct fwnode_handle *fwnode, > > const char *name, > > +                                bool *parent_lookup) > >  { > >         struct iio_channel *chan; > >         int index = 0; > > @@ -221,32 +243,34 @@ struct iio_channel > > *__of_iio_channel_get_by_name(struct device_node *np, > >         /* > >          * For named iio channels, first look up the name in the > >          * "io-channel-names" property.  If it cannot be found, the > > -        * index will be an error code, and of_iio_channel_get() > > +        * index will be an error code, and > > fwnode_iio_channel_get() > >          * will fail. > >          */ > >         if (name) > > -               index = of_property_match_string(np, "io-channel- > > names", name); > > +               index = fwnode_property_match_string(fwnode, "io- > > channel-names", > > +                                                    name); > > > > -       chan = of_iio_channel_get(np, index); > > +       chan = fwnode_iio_channel_get(fwnode, index); > >         if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER) { > >                 *parent_lookup = false; > >         } else if (name && index >= 0) { > > -               pr_err("ERROR: could not get IIO channel > > %pOF:%s(%i)\n", > > -                      np, name ? name : "", index); > > +               pr_err("ERROR: could not get IIO channel > > %pfw:%s(%i)\n", > > +                      fwnode, name ? name : "", index); > > Since you are touching this line can you switch to name ?: "" and > possibly move some parameters to the above line? If it does not cross the 80limit col, sure. > > >                 *parent_lookup = false; > >         } > > > >         return chan; > >  } > > > > -struct iio_channel *of_iio_channel_get_by_name(struct device_node > > *np, > > -                                              const char *name) > > +struct iio_channel *fwnode_iio_channel_get_by_name(struct > > fwnode_handle *fwnode, > > +                                                  const char > > *name) > >  { > >         struct iio_channel *chan; > > +       struct fwnode_handle *parent; > >         bool parent_lookup = true; > > > >         /* Walk up the tree of devices looking for a matching iio > > channel */ > > -       chan = __of_iio_channel_get_by_name(np, name, > > &parent_lookup); > > +       chan = __fwnode_iio_channel_get_by_name(fwnode, name, > > &parent_lookup); > >         if (!parent_lookup) > >                 return chan; > > > > @@ -255,33 +279,34 @@ struct iio_channel > > *of_iio_channel_get_by_name(struct device_node *np, > >          * If the parent node has a "io-channel-ranges" property, > >          * then we can try one of its channels. > >          */ > > -       np = np->parent; > > -       while (np) { > > -               if (!of_get_property(np, "io-channel-ranges", > > NULL)) > > +       fwnode_for_each_parent_node(fwnode, parent) { > > +               if (!fwnode_property_present(parent, "io-channel- > > ranges")) { > > +                       fwnode_handle_put(parent); > >                         return chan; > > break; ? The return in place was a request from Jonathan in the RFC... > > (Yes, I understand pros and cons of each variant, up to you) > > > +               } > > > > -               chan = __of_iio_channel_get_by_name(np, name, > > &parent_lookup); > > -               if (!parent_lookup) > > +               chan = __fwnode_iio_channel_get_by_name(parent, > > name, &parent_lookup); > > +               if (!parent_lookup) { > > +                       fwnode_handle_put(parent); > >                         return chan; > > Ditto. > > > -               np = np->parent; > > +               } > >         } > > > >         return chan; > >  } > > -EXPORT_SYMBOL_GPL(of_iio_channel_get_by_name); > > +EXPORT_SYMBOL_GPL(fwnode_iio_channel_get_by_name); > > Wondering if we may move this to the IIO namespace. I guess it makes sense but surely on a different patch... > > > -static struct iio_channel *of_iio_channel_get_all(struct device > > *dev) > > +static struct iio_channel *fwnode_iio_channel_get_all(struct > > device *dev) > >  { > > +       struct fwnode_handle *fwnode = dev_fwnode(dev); > >         struct iio_channel *chans; > >         int i, mapind, nummaps = 0; > >         int ret; > > > >         do { > > -               ret = of_parse_phandle_with_args(dev->of_node, > > -                                                "io-channels", > > -                                                "#io-channel- > > cells", > > -                                                nummaps, NULL); > > +               ret = fwnode_property_get_reference_args(fwnode, > > "io-channels", > > +                                                        "#io- > > channel-cells", 0, > > +                                                        nummaps, > > NULL); > >                 if (ret < 0) > >                         break; > >         } while (++nummaps); > > @@ -294,10 +319,9 @@ static struct iio_channel > > *of_iio_channel_get_all(struct device *dev) > >         if (chans == NULL) > >                 return ERR_PTR(-ENOMEM); > > > > -       /* Search for OF matches */ > > +       /* Search for FW matches */ > >         for (mapind = 0; mapind < nummaps; mapind++) { > > -               ret = __of_iio_channel_get(&chans[mapind], dev- > > >of_node, > > -                                          mapind); > > +               ret = __fwnode_iio_channel_get(&chans[mapind], > > fwnode, mapind); > >                 if (ret) > >                         goto error_free_chans; > >         } > > @@ -310,15 +334,6 @@ static struct iio_channel > > *of_iio_channel_get_all(struct device *dev) > >         return ERR_PTR(ret); > >  } > > > > -#else /* CONFIG_OF */ > > - > > -static inline struct iio_channel *of_iio_channel_get_all(struct > > device *dev) > > -{ > > -       return ERR_PTR(-ENODEV); > > -} > > - > > -#endif /* CONFIG_OF */ > > - > >  static struct iio_channel *iio_channel_get_sys(const char *name, > >                                                const char > > *channel_name) > >  { > > @@ -379,8 +394,8 @@ struct iio_channel *iio_channel_get(struct > > device *dev, > >         struct iio_channel *channel; > > > >         if (dev) { > > -               channel = of_iio_channel_get_by_name(dev->of_node, > > -                                                    channel_name); > > +               channel = > > fwnode_iio_channel_get_by_name(dev_fwnode(dev), > > +                                                        > > channel_name); > >                 if (!IS_ERR(channel) || PTR_ERR(channel) == - > > EPROBE_DEFER) > >                         return channel; > >         } > > @@ -421,14 +436,14 @@ struct iio_channel > > *devm_iio_channel_get(struct device *dev, > >  } > >  EXPORT_SYMBOL_GPL(devm_iio_channel_get); > > > > -struct iio_channel *devm_of_iio_channel_get_by_name(struct device > > *dev, > > -                                                   struct > > device_node *np, > > -                                                   const char > > *channel_name) > > +struct iio_channel *devm_fwnode_iio_channel_get_by_name(struct > > device *dev, > > +                                                       struct > > fwnode_handle *fwnode, > > +                                                       const char > > *channel_name) > >  { > >         struct iio_channel *channel; > >         int ret; > > > > -       channel = of_iio_channel_get_by_name(np, channel_name); > > +       channel = fwnode_iio_channel_get_by_name(fwnode, > > channel_name); > >         if (IS_ERR(channel)) > >                 return channel; > > > > @@ -438,7 +453,7 @@ struct iio_channel > > *devm_of_iio_channel_get_by_name(struct device *dev, > > > >         return channel; > >  } > > -EXPORT_SYMBOL_GPL(devm_of_iio_channel_get_by_name); > > +EXPORT_SYMBOL_GPL(devm_fwnode_iio_channel_get_by_name); > > > >  struct iio_channel *iio_channel_get_all(struct device *dev) > >  { > > @@ -452,7 +467,7 @@ struct iio_channel *iio_channel_get_all(struct > > device *dev) > >         if (dev == NULL) > >                 return ERR_PTR(-EINVAL); > > > > -       chans = of_iio_channel_get_all(dev); > > +       chans = fwnode_iio_channel_get_all(dev); > >         if (!IS_ERR(chans) || PTR_ERR(chans) == -EPROBE_DEFER) > >                 return chans; > > > > diff --git a/include/linux/iio/consumer.h > > b/include/linux/iio/consumer.h > > index 5fa5957586cf..a96a714b5fdc 100644 > > --- a/include/linux/iio/consumer.h > > +++ b/include/linux/iio/consumer.h > > @@ -9,11 +9,13 @@ > > > >  #include > >  #include > > > +#include > > Ordering. IIO has special meaning here, that's why it's last. ok... - Nuno Sá