From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mx0a-00128a01.pphosted.com (mx0a-00128a01.pphosted.com [148.163.135.77]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5A5327C for ; Fri, 10 Jun 2022 08:48:42 +0000 (UTC) Received: from pps.filterd (m0167089.ppops.net [127.0.0.1]) by mx0a-00128a01.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 25A7h8EU005272; Fri, 10 Jun 2022 04:48:18 -0400 Received: from nwd2mta4.analog.com ([137.71.173.58]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3ghq33kqad-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 10 Jun 2022 04:48:17 -0400 Received: from ASHBMBX8.ad.analog.com (ASHBMBX8.ad.analog.com [10.64.17.5]) by nwd2mta4.analog.com (8.14.7/8.14.7) with ESMTP id 25A8mGbk027556 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 10 Jun 2022 04:48:16 -0400 Received: from ASHBCASHYB5.ad.analog.com (10.64.17.133) by ASHBMBX8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Fri, 10 Jun 2022 04:48:15 -0400 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBCASHYB5.ad.analog.com (10.64.17.133) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Fri, 10 Jun 2022 04:48:15 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Fri, 10 Jun 2022 04:48:15 -0400 Received: from nsa.ad.analog.com ([10.44.3.70]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 25A8imik014275; Fri, 10 Jun 2022 04:48:04 -0400 From: =?UTF-8?q?Nuno=20S=C3=A1?= To: , , , , , Lad Prabhakar , , , , , CC: 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 , Andy Shevchenko , 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 Subject: [PATCH 24/34] iio: inkern: move to fwnode properties Date: Fri, 10 Jun 2022 10:45:35 +0200 Message-ID: <20220610084545.547700-25-nuno.sa@analog.com> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220610084545.547700-1-nuno.sa@analog.com> References: <20220610084545.547700-1-nuno.sa@analog.com> Precedence: bulk X-Mailing-List: chrome-platform@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit X-ADIRuleOP-NewSCL: Rule Triggered X-Proofpoint-ORIG-GUID: SLrT9c5dbr2AGqM0_4SQx-b6M19QpuVb X-Proofpoint-GUID: SLrT9c5dbr2AGqM0_4SQx-b6M19QpuVb X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.874,Hydra:6.0.517,FMLib:17.11.64.514 definitions=2022-06-10_02,2022-06-09_02,2022-02-23_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 mlxlogscore=999 phishscore=0 priorityscore=1501 adultscore=0 clxscore=1015 lowpriorityscore=0 mlxscore=0 spamscore=0 impostorscore=0 bulkscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2204290000 definitions=main-2206100031 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. 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); +} + +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; - 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); 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); *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; + } - 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; - - np = np->parent; + } } return chan; } -EXPORT_SYMBOL_GPL(of_iio_channel_get_by_name); +EXPORT_SYMBOL_GPL(fwnode_iio_channel_get_by_name); -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 struct iio_dev; struct iio_chan_spec; struct device; struct device_node; +struct fwnode_handle; /** * struct iio_channel - everything needed for a consumer to use a channel @@ -99,26 +101,20 @@ void iio_channel_release_all(struct iio_channel *chan); struct iio_channel *devm_iio_channel_get_all(struct device *dev); /** - * of_iio_channel_get_by_name() - get description of all that is needed to access channel. - * @np: Pointer to consumer device tree node + * fwnode_iio_channel_get_by_name() - get description of all that is needed to access channel. + * @fwnode: Pointer to consumer Firmware node * @consumer_channel: Unique name to identify the channel on the consumer * side. This typically describes the channels use within * the consumer. E.g. 'battery_voltage' */ -#ifdef CONFIG_OF -struct iio_channel *of_iio_channel_get_by_name(struct device_node *np, const char *name); -#else -static inline struct iio_channel * -of_iio_channel_get_by_name(struct device_node *np, const char *name) -{ - return NULL; -} -#endif +struct iio_channel *fwnode_iio_channel_get_by_name(struct fwnode_handle *fwnode, + const char *name); /** - * devm_of_iio_channel_get_by_name() - Resource managed version of of_iio_channel_get_by_name(). + * devm_fwnode_iio_channel_get_by_name() - Resource managed version of + * fwnode_iio_channel_get_by_name(). * @dev: Pointer to consumer device. - * @np: Pointer to consumer device tree node + * @fwnode: Pointer to consumer Firmware node * @consumer_channel: Unique name to identify the channel on the consumer * side. This typically describes the channels use within * the consumer. E.g. 'battery_voltage' @@ -129,9 +125,17 @@ of_iio_channel_get_by_name(struct device_node *np, const char *name) * The allocated iio channel is automatically released when the device is * unbound. */ -struct iio_channel *devm_of_iio_channel_get_by_name(struct device *dev, - struct device_node *np, - const char *consumer_channel); +struct iio_channel *devm_fwnode_iio_channel_get_by_name(struct device *dev, + struct fwnode_handle *fwnode, + const char *consumer_channel); + +static inline struct iio_channel +*devm_of_iio_channel_get_by_name(struct device *dev, struct device_node *np, + const char *consumer_channel) +{ + return devm_fwnode_iio_channel_get_by_name(dev, of_fwnode_handle(np), + consumer_channel); +} struct iio_cb_buffer; /** diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h index d9b4a9ca9a0f..494abb63406e 100644 --- a/include/linux/iio/iio.h +++ b/include/linux/iio/iio.h @@ -18,6 +18,7 @@ */ struct of_phandle_args; +struct fwnode_reference_args; enum iio_shared_by { IIO_SEPARATE, @@ -429,6 +430,8 @@ struct iio_trigger; /* forward declaration */ * provide a custom of_xlate function that reads the * *args* and returns the appropriate index in registered * IIO channels array. + * @fwnode_xlate: fwnode based function pointer to obtain channel specifier index. + * Functionally the same as @of_xlate. * @hwfifo_set_watermark: function pointer to set the current hardware * fifo watermark level; see hwfifo_* entries in * Documentation/ABI/testing/sysfs-bus-iio for details on @@ -510,6 +513,8 @@ struct iio_info { unsigned *readval); int (*of_xlate)(struct iio_dev *indio_dev, const struct of_phandle_args *iiospec); + int (*fwnode_xlate)(struct iio_dev *indio_dev, + const struct fwnode_reference_args *iiospec); int (*hwfifo_set_watermark)(struct iio_dev *indio_dev, unsigned val); int (*hwfifo_flush_to_buffer)(struct iio_dev *indio_dev, unsigned count); -- 2.36.1 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 CF8C4C43334 for ; Fri, 10 Jun 2022 08:48:48 +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: Message-ID:Date:Subject:CC:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=hJ/AFrvmInTeMs4KXTbvzv2MQZxfg2fHMGyRbSb56Eo=; b=NcZl9iplBfKemN jJ/YyYMdZ3m0LcWNCIph0QahpCO5MJsq2MHPPEViCOvANzdsk0vBWEN1GSIkr1PfyW1dJDv0jGz1Z Evm542UENj7qV8LdW3hBSPg3uDr3JNw/T44QIY2asDvRrvR3y7tOofMUkyutJtSoUpPiBKSL84uGA EcJYVGRg2fIyh5iqC/GX0yIIxrmZTanD6mpyCCuOy8cY5Pb1awutXPNoCAsV6R7Yj3WVdut34/iUX X5ziG067ydW6FtksFyOsYJRcU57Lrhf3g8cNuO9MPPyuVQ4LeYavShCQvKWHU96NXzr83/3lxG9MC SU0bqsbfHjS2Qhh2IZyA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzaJu-006ul1-P0; Fri, 10 Jun 2022 08:48:42 +0000 Received: from mx0a-00128a01.pphosted.com ([148.163.135.77]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzaJr-006uit-LE; Fri, 10 Jun 2022 08:48:41 +0000 Received: from pps.filterd (m0167089.ppops.net [127.0.0.1]) by mx0a-00128a01.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 25A7h8EU005272; Fri, 10 Jun 2022 04:48:18 -0400 Received: from nwd2mta4.analog.com ([137.71.173.58]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3ghq33kqad-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 10 Jun 2022 04:48:17 -0400 Received: from ASHBMBX8.ad.analog.com (ASHBMBX8.ad.analog.com [10.64.17.5]) by nwd2mta4.analog.com (8.14.7/8.14.7) with ESMTP id 25A8mGbk027556 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 10 Jun 2022 04:48:16 -0400 Received: from ASHBCASHYB5.ad.analog.com (10.64.17.133) by ASHBMBX8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Fri, 10 Jun 2022 04:48:15 -0400 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBCASHYB5.ad.analog.com (10.64.17.133) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Fri, 10 Jun 2022 04:48:15 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Fri, 10 Jun 2022 04:48:15 -0400 Received: from nsa.ad.analog.com ([10.44.3.70]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 25A8imik014275; Fri, 10 Jun 2022 04:48:04 -0400 From: =?UTF-8?q?Nuno=20S=C3=A1?= To: , , , , , Lad Prabhakar , , , , , CC: 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 , Andy Shevchenko , 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 Subject: [PATCH 24/34] iio: inkern: move to fwnode properties Date: Fri, 10 Jun 2022 10:45:35 +0200 Message-ID: <20220610084545.547700-25-nuno.sa@analog.com> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220610084545.547700-1-nuno.sa@analog.com> References: <20220610084545.547700-1-nuno.sa@analog.com> MIME-Version: 1.0 X-ADIRuleOP-NewSCL: Rule Triggered X-Proofpoint-ORIG-GUID: SLrT9c5dbr2AGqM0_4SQx-b6M19QpuVb X-Proofpoint-GUID: SLrT9c5dbr2AGqM0_4SQx-b6M19QpuVb X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.874,Hydra:6.0.517,FMLib:17.11.64.514 definitions=2022-06-10_02,2022-06-09_02,2022-02-23_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 mlxlogscore=999 phishscore=0 priorityscore=1501 adultscore=0 clxscore=1015 lowpriorityscore=0 mlxscore=0 spamscore=0 impostorscore=0 bulkscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2204290000 definitions=main-2206100031 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220610_014839_732438_1117511D X-CRM114-Status: GOOD ( 29.54 ) 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 VGhpcyBtb3ZlcyB0aGUgSUlPIGluIGtlcm5lbCBpbnRlcmZhY2UgdG8gdXNlIGZ3bm9kZSBwcm9w ZXJ0aWVzIGFuZCB0aHVzCmJlIGZpcm13YXJlIGFnbm9zdGljLgoKTm90ZSB0aGF0IHRoZSBpbnRl cmZhY2UgaXMgc3RpbGwgbm90IGZpcm13YXJlIGFnbm9zdGljLiBBdCB0aGlzIHBvaW50IHdlCmhh dmUgYm90aCBPRiBhbmQgZndub2RlIGludGVyZmFjZXMgc28gdGhhdCB3ZSBkb24ndCBicmVhayBh bnkgdXNlci4gT24KdG9wIG9mIHRoaXMgd2UgYWxzbyB3YW50IHRvIGhhdmUgYSBwZXIgZHJpdmVy IGNvbnZlcnNpb24gYW5kIHRoYXQgaXMgdGhlCm1haW4gcmVhc29uIHdlIGhhdmUgYm90aCBvZl94 bGF0ZSgpIGFuZCBmd25vZGVfeGxhdGUoKSBzdXBwb3J0LgoKU2lnbmVkLW9mZi1ieTogTnVubyBT w6EgPG51bm8uc2FAYW5hbG9nLmNvbT4KLS0tCiBkcml2ZXJzL2lpby9pbmtlcm4uYyAgICAgICAg IHwgMTQ1ICsrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tCiBpbmNsdWRlL2xpbnV4 L2lpby9jb25zdW1lci5oIHwgIDM2ICsrKysrLS0tLQogaW5jbHVkZS9saW51eC9paW8vaWlvLmgg ICAgICB8ICAgNSArKwogMyBmaWxlcyBjaGFuZ2VkLCAxMDUgaW5zZXJ0aW9ucygrKSwgODEgZGVs ZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9paW8vaW5rZXJuLmMgYi9kcml2ZXJzL2lp by9pbmtlcm4uYwppbmRleCBkZGU0NzMyNGI4MjYuLjFkNTE5YjBjYWNlYSAxMDA2NDQKLS0tIGEv ZHJpdmVycy9paW8vaW5rZXJuLmMKKysrIGIvZHJpdmVycy9paW8vaW5rZXJuLmMKQEAgLTUsNiAr NSw3IEBACiAgKi8KICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9leHBv cnQuaD4KKyNpbmNsdWRlIDxsaW51eC9wcm9wZXJ0eS5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIu aD4KICNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgogI2luY2x1ZGUgPGxpbnV4L29mLmg+CkBAIC0x MTcsMTUgKzExOCwxMyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGlpb19jaGFuX3NwZWMKIAlyZXR1 cm4gY2hhbjsKIH0KIAotI2lmZGVmIENPTkZJR19PRgotCiBzdGF0aWMgaW50IGlpb19kZXZfbm9k ZV9tYXRjaChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHZvaWQgKmRhdGEpCiB7Ci0JcmV0dXJu IGRldi0+b2Zfbm9kZSA9PSBkYXRhICYmIGRldi0+dHlwZSA9PSAmaWlvX2RldmljZV90eXBlOwor CXJldHVybiBkZXZpY2VfbWF0Y2hfZndub2RlKGRldiwgZGF0YSkgJiYgZGV2LT50eXBlID09ICZp aW9fZGV2aWNlX3R5cGU7CiB9CiAKIC8qKgotICogX19vZl9paW9fc2ltcGxlX3hsYXRlIC0gdHJh bnNsYXRlIGlpb3NwZWMgdG8gdGhlIElJTyBjaGFubmVsIGluZGV4CisgKiBfX2Z3bm9kZV9paW9f c2ltcGxlX3hsYXRlIC0gdHJhbnNsYXRlIGlpb3NwZWMgdG8gdGhlIElJTyBjaGFubmVsIGluZGV4 CiAgKiBAaW5kaW9fZGV2Oglwb2ludGVyIHRvIHRoZSBpaW9fZGV2IHN0cnVjdHVyZQogICogQGlp b3NwZWM6CUlJTyBzcGVjaWZpZXIgYXMgZm91bmQgaW4gdGhlIGRldmljZSB0cmVlCiAgKgpAQCAt MTM0LDE0ICsxMzMsMTQgQEAgc3RhdGljIGludCBpaW9fZGV2X25vZGVfbWF0Y2goc3RydWN0IGRl dmljZSAqZGV2LCBjb25zdCB2b2lkICpkYXRhKQogICogd2hldGhlciBJSU8gaW5kZXggaXMgbGVz cyB0aGFuIG51bV9jaGFubmVscyAodGhhdCBpcyBzcGVjaWZpZWQgaW4gdGhlCiAgKiBpaW9fZGV2 KS4KICAqLwotc3RhdGljIGludCBfX29mX2lpb19zaW1wbGVfeGxhdGUoc3RydWN0IGlpb19kZXYg KmluZGlvX2RldiwKLQkJCQljb25zdCBzdHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzICppaW9zcGVjKQor c3RhdGljIGludCBfX2Z3bm9kZV9paW9fc2ltcGxlX3hsYXRlKHN0cnVjdCBpaW9fZGV2ICppbmRp b19kZXYsCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgZndub2RlX3JlZmVyZW5jZV9hcmdzICppaW9z cGVjKQogewotCWlmICghaWlvc3BlYy0+YXJnc19jb3VudCkKKwlpZiAoIWlpb3NwZWMtPm5hcmdz KQogCQlyZXR1cm4gMDsKIAogCWlmIChpaW9zcGVjLT5hcmdzWzBdID49IGluZGlvX2Rldi0+bnVt X2NoYW5uZWxzKSB7Ci0JCWRldl9lcnIoJmluZGlvX2Rldi0+ZGV2LCAiaW52YWxpZCBjaGFubmVs IGluZGV4ICV1XG4iLAorCQlkZXZfZXJyKCZpbmRpb19kZXYtPmRldiwgImludmFsaWQgY2hhbm5l bCBpbmRleCAlbGx1XG4iLAogCQkJaWlvc3BlYy0+YXJnc1swXSk7CiAJCXJldHVybiAtRUlOVkFM OwogCX0KQEAgLTE0OSwzNCArMTQ4LDU2IEBAIHN0YXRpYyBpbnQgX19vZl9paW9fc2ltcGxlX3hs YXRlKHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCiAJcmV0dXJuIGlpb3NwZWMtPmFyZ3NbMF07 CiB9CiAKLXN0YXRpYyBpbnQgX19vZl9paW9fY2hhbm5lbF9nZXQoc3RydWN0IGlpb19jaGFubmVs ICpjaGFubmVsLAotCQkJCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsIGludCBpbmRleCkKKy8qCisg KiBTaW1wbGUgaGVscGVyIHRvIGNvcHkgZndub2RlX3JlZmVyZW5jZV9hcmdzIGludG8gb2ZfcGhh bmRsZV9hcmdzIHNvIHdlCisgKiBjYW4gcGFzcyBpdCB0byBvZl94bGF0ZSgpLiBVbHRpbWF0ZSBn b2FsIGlzIHRvIGRyb3AgdGhpcyB0b2dldGhlciB3aXRoCisgKiBvZl94bGF0ZSgpLgorICovCitz dGF0aWMgaW50IF9fZndub2RlX3RvX29mX3hsYXRlKHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYs CisJCQkJY29uc3Qgc3RydWN0IGZ3bm9kZV9yZWZlcmVuY2VfYXJncyAqaWlvc3BlYykKK3sKKwlz dHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzIG9mX2FyZ3M7CisJdW5zaWduZWQgaW50IGk7CisKKwlvZl9h cmdzLmFyZ3NfY291bnQgPSBpaW9zcGVjLT5uYXJnczsKKwlvZl9hcmdzLm5wID0gdG9fb2Zfbm9k ZShpaW9zcGVjLT5md25vZGUpOworCisJZm9yIChpID0gMDsgaSA8IE1BWF9QSEFORExFX0FSR1M7 IGkrKykKKwkJb2ZfYXJncy5hcmdzW2ldID0gaSA8IGlpb3NwZWMtPm5hcmdzID8gaWlvc3BlYy0+ YXJnc1tpXSA6IDA7CisKKwlyZXR1cm4gaW5kaW9fZGV2LT5pbmZvLT5vZl94bGF0ZShpbmRpb19k ZXYsICZvZl9hcmdzKTsKK30KKworc3RhdGljIGludCBfX2Z3bm9kZV9paW9fY2hhbm5lbF9nZXQo c3RydWN0IGlpb19jaGFubmVsICpjaGFubmVsLAorCQkJCSAgICBzdHJ1Y3QgZndub2RlX2hhbmRs ZSAqZndub2RlLCBpbnQgaW5kZXgpCiB7CiAJc3RydWN0IGRldmljZSAqaWRldjsKIAlzdHJ1Y3Qg aWlvX2RldiAqaW5kaW9fZGV2OwogCWludCBlcnI7Ci0Jc3RydWN0IG9mX3BoYW5kbGVfYXJncyBp aW9zcGVjOworCXN0cnVjdCBmd25vZGVfcmVmZXJlbmNlX2FyZ3MgaWlvc3BlYzsKIAotCWVyciA9 IG9mX3BhcnNlX3BoYW5kbGVfd2l0aF9hcmdzKG5wLCAiaW8tY2hhbm5lbHMiLAotCQkJCQkgIiNp by1jaGFubmVsLWNlbGxzIiwKLQkJCQkJIGluZGV4LCAmaWlvc3BlYyk7CisJZXJyID0gZndub2Rl X3Byb3BlcnR5X2dldF9yZWZlcmVuY2VfYXJncyhmd25vZGUsICJpby1jaGFubmVscyIsCisJCQkJ CQkgIiNpby1jaGFubmVsLWNlbGxzIiwgMCwKKwkJCQkJCSBpbmRleCwgJmlpb3NwZWMpOwogCWlm IChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQlpZGV2ID0gYnVzX2ZpbmRfZGV2aWNlKCZpaW9fYnVz X3R5cGUsIE5VTEwsIGlpb3NwZWMubnAsCisJaWRldiA9IGJ1c19maW5kX2RldmljZSgmaWlvX2J1 c190eXBlLCBOVUxMLCBpaW9zcGVjLmZ3bm9kZSwKIAkJCSAgICAgICBpaW9fZGV2X25vZGVfbWF0 Y2gpOwogCWlmIChpZGV2ID09IE5VTEwpIHsKLQkJb2Zfbm9kZV9wdXQoaWlvc3BlYy5ucCk7CisJ CWZ3bm9kZV9oYW5kbGVfcHV0KGlpb3NwZWMuZndub2RlKTsKIAkJcmV0dXJuIC1FUFJPQkVfREVG RVI7CiAJfQogCiAJaW5kaW9fZGV2ID0gZGV2X3RvX2lpb19kZXYoaWRldik7CiAJY2hhbm5lbC0+ aW5kaW9fZGV2ID0gaW5kaW9fZGV2OwogCWlmIChpbmRpb19kZXYtPmluZm8tPm9mX3hsYXRlKQot CQlpbmRleCA9IGluZGlvX2Rldi0+aW5mby0+b2ZfeGxhdGUoaW5kaW9fZGV2LCAmaWlvc3BlYyk7 CisJCWluZGV4ID0gX19md25vZGVfdG9fb2ZfeGxhdGUoaW5kaW9fZGV2LCAmaWlvc3BlYyk7CisJ ZWxzZSBpZiAoaW5kaW9fZGV2LT5pbmZvLT5md25vZGVfeGxhdGUpCisJCWluZGV4ID0gaW5kaW9f ZGV2LT5pbmZvLT5md25vZGVfeGxhdGUoaW5kaW9fZGV2LCAmaWlvc3BlYyk7CiAJZWxzZQotCQlp bmRleCA9IF9fb2ZfaWlvX3NpbXBsZV94bGF0ZShpbmRpb19kZXYsICZpaW9zcGVjKTsKLQlvZl9u b2RlX3B1dChpaW9zcGVjLm5wKTsKKwkJaW5kZXggPSBfX2Z3bm9kZV9paW9fc2ltcGxlX3hsYXRl KGluZGlvX2RldiwgJmlpb3NwZWMpOworCWZ3bm9kZV9oYW5kbGVfcHV0KGlpb3NwZWMuZndub2Rl KTsKIAlpZiAoaW5kZXggPCAwKQogCQlnb3RvIGVycl9wdXQ7CiAJY2hhbm5lbC0+Y2hhbm5lbCA9 ICZpbmRpb19kZXYtPmNoYW5uZWxzW2luZGV4XTsKQEAgLTE4OCw3ICsyMDksOCBAQCBzdGF0aWMg aW50IF9fb2ZfaWlvX2NoYW5uZWxfZ2V0KHN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbm5lbCwKIAly ZXR1cm4gaW5kZXg7CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgaWlvX2NoYW5uZWwgKm9mX2lpb19jaGFu bmVsX2dldChzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLCBpbnQgaW5kZXgpCitzdGF0aWMgc3RydWN0 IGlpb19jaGFubmVsICpmd25vZGVfaWlvX2NoYW5uZWxfZ2V0KHN0cnVjdCBmd25vZGVfaGFuZGxl ICpmd25vZGUsCisJCQkJCQkgIGludCBpbmRleCkKIHsKIAlzdHJ1Y3QgaWlvX2NoYW5uZWwgKmNo YW5uZWw7CiAJaW50IGVycjsKQEAgLTIwMCw3ICsyMjIsNyBAQCBzdGF0aWMgc3RydWN0IGlpb19j aGFubmVsICpvZl9paW9fY2hhbm5lbF9nZXQoc3RydWN0IGRldmljZV9ub2RlICpucCwgaW50IGlu ZGV4KQogCWlmIChjaGFubmVsID09IE5VTEwpCiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwog Ci0JZXJyID0gX19vZl9paW9fY2hhbm5lbF9nZXQoY2hhbm5lbCwgbnAsIGluZGV4KTsKKwllcnIg PSBfX2Z3bm9kZV9paW9fY2hhbm5lbF9nZXQoY2hhbm5lbCwgZndub2RlLCBpbmRleCk7CiAJaWYg KGVycikKIAkJZ290byBlcnJfZnJlZV9jaGFubmVsOwogCkBAIC0yMTEsOSArMjMzLDkgQEAgc3Rh dGljIHN0cnVjdCBpaW9fY2hhbm5lbCAqb2ZfaWlvX2NoYW5uZWxfZ2V0KHN0cnVjdCBkZXZpY2Vf bm9kZSAqbnAsIGludCBpbmRleCkKIAlyZXR1cm4gRVJSX1BUUihlcnIpOwogfQogCi1zdHJ1Y3Qg aWlvX2NoYW5uZWwgKl9fb2ZfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoc3RydWN0IGRldmljZV9u b2RlICpucCwKLQkJCQkJCSBjb25zdCBjaGFyICpuYW1lLAotCQkJCQkJIGJvb2wgKnBhcmVudF9s b29rdXApCitzdHJ1Y3QgaWlvX2NoYW5uZWwgKgorX19md25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5 X25hbWUoc3RydWN0IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSwgY29uc3QgY2hhciAqbmFtZSwKKwkJ CQkgYm9vbCAqcGFyZW50X2xvb2t1cCkKIHsKIAlzdHJ1Y3QgaWlvX2NoYW5uZWwgKmNoYW47CiAJ aW50IGluZGV4ID0gMDsKQEAgLTIyMSwzMiArMjQzLDM0IEBAIHN0cnVjdCBpaW9fY2hhbm5lbCAq X19vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAogCS8q CiAJICogRm9yIG5hbWVkIGlpbyBjaGFubmVscywgZmlyc3QgbG9vayB1cCB0aGUgbmFtZSBpbiB0 aGUKIAkgKiAiaW8tY2hhbm5lbC1uYW1lcyIgcHJvcGVydHkuICBJZiBpdCBjYW5ub3QgYmUgZm91 bmQsIHRoZQotCSAqIGluZGV4IHdpbGwgYmUgYW4gZXJyb3IgY29kZSwgYW5kIG9mX2lpb19jaGFu bmVsX2dldCgpCisJICogaW5kZXggd2lsbCBiZSBhbiBlcnJvciBjb2RlLCBhbmQgZndub2RlX2lp b19jaGFubmVsX2dldCgpCiAJICogd2lsbCBmYWlsLgogCSAqLwogCWlmIChuYW1lKQotCQlpbmRl eCA9IG9mX3Byb3BlcnR5X21hdGNoX3N0cmluZyhucCwgImlvLWNoYW5uZWwtbmFtZXMiLCBuYW1l KTsKKwkJaW5kZXggPSBmd25vZGVfcHJvcGVydHlfbWF0Y2hfc3RyaW5nKGZ3bm9kZSwgImlvLWNo YW5uZWwtbmFtZXMiLAorCQkJCQkJICAgICBuYW1lKTsKIAotCWNoYW4gPSBvZl9paW9fY2hhbm5l bF9nZXQobnAsIGluZGV4KTsKKwljaGFuID0gZndub2RlX2lpb19jaGFubmVsX2dldChmd25vZGUs IGluZGV4KTsKIAlpZiAoIUlTX0VSUihjaGFuKSB8fCBQVFJfRVJSKGNoYW4pID09IC1FUFJPQkVf REVGRVIpIHsKIAkJKnBhcmVudF9sb29rdXAgPSBmYWxzZTsKIAl9IGVsc2UgaWYgKG5hbWUgJiYg aW5kZXggPj0gMCkgewotCQlwcl9lcnIoIkVSUk9SOiBjb3VsZCBub3QgZ2V0IElJTyBjaGFubmVs ICVwT0Y6JXMoJWkpXG4iLAotCQkgICAgICAgbnAsIG5hbWUgPyBuYW1lIDogIiIsIGluZGV4KTsK KwkJcHJfZXJyKCJFUlJPUjogY291bGQgbm90IGdldCBJSU8gY2hhbm5lbCAlcGZ3OiVzKCVpKVxu IiwKKwkJICAgICAgIGZ3bm9kZSwgbmFtZSA/IG5hbWUgOiAiIiwgaW5kZXgpOwogCQkqcGFyZW50 X2xvb2t1cCA9IGZhbHNlOwogCX0KIAogCXJldHVybiBjaGFuOwogfQogCi1zdHJ1Y3QgaWlvX2No YW5uZWwgKm9mX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAs Ci0JCQkJCSAgICAgICBjb25zdCBjaGFyICpuYW1lKQorc3RydWN0IGlpb19jaGFubmVsICpmd25v ZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoc3RydWN0IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSwK KwkJCQkJCSAgIGNvbnN0IGNoYXIgKm5hbWUpCiB7CiAJc3RydWN0IGlpb19jaGFubmVsICpjaGFu OworCXN0cnVjdCBmd25vZGVfaGFuZGxlICpwYXJlbnQ7CiAJYm9vbCBwYXJlbnRfbG9va3VwID0g dHJ1ZTsKIAogCS8qIFdhbGsgdXAgdGhlIHRyZWUgb2YgZGV2aWNlcyBsb29raW5nIGZvciBhIG1h dGNoaW5nIGlpbyBjaGFubmVsICovCi0JY2hhbiA9IF9fb2ZfaWlvX2NoYW5uZWxfZ2V0X2J5X25h bWUobnAsIG5hbWUsICZwYXJlbnRfbG9va3VwKTsKKwljaGFuID0gX19md25vZGVfaWlvX2NoYW5u ZWxfZ2V0X2J5X25hbWUoZndub2RlLCBuYW1lLCAmcGFyZW50X2xvb2t1cCk7CiAJaWYgKCFwYXJl bnRfbG9va3VwKQogCQlyZXR1cm4gY2hhbjsKIApAQCAtMjU1LDMzICsyNzksMzQgQEAgc3RydWN0 IGlpb19jaGFubmVsICpvZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlX25v ZGUgKm5wLAogCSAqIElmIHRoZSBwYXJlbnQgbm9kZSBoYXMgYSAiaW8tY2hhbm5lbC1yYW5nZXMi IHByb3BlcnR5LAogCSAqIHRoZW4gd2UgY2FuIHRyeSBvbmUgb2YgaXRzIGNoYW5uZWxzLgogCSAq LwotCW5wID0gbnAtPnBhcmVudDsKLQl3aGlsZSAobnApIHsKLQkJaWYgKCFvZl9nZXRfcHJvcGVy dHkobnAsICJpby1jaGFubmVsLXJhbmdlcyIsIE5VTEwpKQorCWZ3bm9kZV9mb3JfZWFjaF9wYXJl bnRfbm9kZShmd25vZGUsIHBhcmVudCkgeworCQlpZiAoIWZ3bm9kZV9wcm9wZXJ0eV9wcmVzZW50 KHBhcmVudCwgImlvLWNoYW5uZWwtcmFuZ2VzIikpIHsKKwkJCWZ3bm9kZV9oYW5kbGVfcHV0KHBh cmVudCk7CiAJCQlyZXR1cm4gY2hhbjsKKwkJfQogCi0JCWNoYW4gPSBfX29mX2lpb19jaGFubmVs X2dldF9ieV9uYW1lKG5wLCBuYW1lLCAmcGFyZW50X2xvb2t1cCk7Ci0JCWlmICghcGFyZW50X2xv b2t1cCkKKwkJY2hhbiA9IF9fZndub2RlX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKHBhcmVudCwg bmFtZSwgJnBhcmVudF9sb29rdXApOworCQlpZiAoIXBhcmVudF9sb29rdXApIHsKKwkJCWZ3bm9k ZV9oYW5kbGVfcHV0KHBhcmVudCk7CiAJCQlyZXR1cm4gY2hhbjsKLQotCQlucCA9IG5wLT5wYXJl bnQ7CisJCX0KIAl9CiAKIAlyZXR1cm4gY2hhbjsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKG9mX2lp b19jaGFubmVsX2dldF9ieV9uYW1lKTsKK0VYUE9SVF9TWU1CT0xfR1BMKGZ3bm9kZV9paW9fY2hh bm5lbF9nZXRfYnlfbmFtZSk7CiAKLXN0YXRpYyBzdHJ1Y3QgaWlvX2NoYW5uZWwgKm9mX2lpb19j aGFubmVsX2dldF9hbGwoc3RydWN0IGRldmljZSAqZGV2KQorc3RhdGljIHN0cnVjdCBpaW9fY2hh bm5lbCAqZndub2RlX2lpb19jaGFubmVsX2dldF9hbGwoc3RydWN0IGRldmljZSAqZGV2KQogewor CXN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUgPSBkZXZfZndub2RlKGRldik7CiAJc3RydWN0 IGlpb19jaGFubmVsICpjaGFuczsKIAlpbnQgaSwgbWFwaW5kLCBudW1tYXBzID0gMDsKIAlpbnQg cmV0OwogCiAJZG8gewotCQlyZXQgPSBvZl9wYXJzZV9waGFuZGxlX3dpdGhfYXJncyhkZXYtPm9m X25vZGUsCi0JCQkJCQkgImlvLWNoYW5uZWxzIiwKLQkJCQkJCSAiI2lvLWNoYW5uZWwtY2VsbHMi LAotCQkJCQkJIG51bW1hcHMsIE5VTEwpOworCQlyZXQgPSBmd25vZGVfcHJvcGVydHlfZ2V0X3Jl ZmVyZW5jZV9hcmdzKGZ3bm9kZSwgImlvLWNoYW5uZWxzIiwKKwkJCQkJCQkgIiNpby1jaGFubmVs LWNlbGxzIiwgMCwKKwkJCQkJCQkgbnVtbWFwcywgTlVMTCk7CiAJCWlmIChyZXQgPCAwKQogCQkJ YnJlYWs7CiAJfSB3aGlsZSAoKytudW1tYXBzKTsKQEAgLTI5NCwxMCArMzE5LDkgQEAgc3RhdGlj IHN0cnVjdCBpaW9fY2hhbm5lbCAqb2ZfaWlvX2NoYW5uZWxfZ2V0X2FsbChzdHJ1Y3QgZGV2aWNl ICpkZXYpCiAJaWYgKGNoYW5zID09IE5VTEwpCiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwog Ci0JLyogU2VhcmNoIGZvciBPRiBtYXRjaGVzICovCisJLyogU2VhcmNoIGZvciBGVyBtYXRjaGVz ICovCiAJZm9yIChtYXBpbmQgPSAwOyBtYXBpbmQgPCBudW1tYXBzOyBtYXBpbmQrKykgewotCQly ZXQgPSBfX29mX2lpb19jaGFubmVsX2dldCgmY2hhbnNbbWFwaW5kXSwgZGV2LT5vZl9ub2RlLAot CQkJCQkgICBtYXBpbmQpOworCQlyZXQgPSBfX2Z3bm9kZV9paW9fY2hhbm5lbF9nZXQoJmNoYW5z W21hcGluZF0sIGZ3bm9kZSwgbWFwaW5kKTsKIAkJaWYgKHJldCkKIAkJCWdvdG8gZXJyb3JfZnJl ZV9jaGFuczsKIAl9CkBAIC0zMTAsMTUgKzMzNCw2IEBAIHN0YXRpYyBzdHJ1Y3QgaWlvX2NoYW5u ZWwgKm9mX2lpb19jaGFubmVsX2dldF9hbGwoc3RydWN0IGRldmljZSAqZGV2KQogCXJldHVybiBF UlJfUFRSKHJldCk7CiB9CiAKLSNlbHNlIC8qIENPTkZJR19PRiAqLwotCi1zdGF0aWMgaW5saW5l IHN0cnVjdCBpaW9fY2hhbm5lbCAqb2ZfaWlvX2NoYW5uZWxfZ2V0X2FsbChzdHJ1Y3QgZGV2aWNl ICpkZXYpCi17Ci0JcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7Ci19Ci0KLSNlbmRpZiAvKiBDT05G SUdfT0YgKi8KLQogc3RhdGljIHN0cnVjdCBpaW9fY2hhbm5lbCAqaWlvX2NoYW5uZWxfZ2V0X3N5 cyhjb25zdCBjaGFyICpuYW1lLAogCQkJCQkgICAgICAgY29uc3QgY2hhciAqY2hhbm5lbF9uYW1l KQogewpAQCAtMzc5LDggKzM5NCw4IEBAIHN0cnVjdCBpaW9fY2hhbm5lbCAqaWlvX2NoYW5uZWxf Z2V0KHN0cnVjdCBkZXZpY2UgKmRldiwKIAlzdHJ1Y3QgaWlvX2NoYW5uZWwgKmNoYW5uZWw7CiAK IAlpZiAoZGV2KSB7Ci0JCWNoYW5uZWwgPSBvZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShkZXYt Pm9mX25vZGUsCi0JCQkJCQkgICAgIGNoYW5uZWxfbmFtZSk7CisJCWNoYW5uZWwgPSBmd25vZGVf aWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoZGV2X2Z3bm9kZShkZXYpLAorCQkJCQkJCSBjaGFubmVs X25hbWUpOwogCQlpZiAoIUlTX0VSUihjaGFubmVsKSB8fCBQVFJfRVJSKGNoYW5uZWwpID09IC1F UFJPQkVfREVGRVIpCiAJCQlyZXR1cm4gY2hhbm5lbDsKIAl9CkBAIC00MjEsMTQgKzQzNiwxNCBA QCBzdHJ1Y3QgaWlvX2NoYW5uZWwgKmRldm1faWlvX2NoYW5uZWxfZ2V0KHN0cnVjdCBkZXZpY2Ug KmRldiwKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGRldm1faWlvX2NoYW5uZWxfZ2V0KTsKIAotc3Ry dWN0IGlpb19jaGFubmVsICpkZXZtX29mX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKHN0cnVjdCBk ZXZpY2UgKmRldiwKLQkJCQkJCSAgICBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAotCQkJCQkJICAg IGNvbnN0IGNoYXIgKmNoYW5uZWxfbmFtZSkKK3N0cnVjdCBpaW9fY2hhbm5lbCAqZGV2bV9md25v ZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCQkJCXN0 cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUsCisJCQkJCQkJY29uc3QgY2hhciAqY2hhbm5lbF9u YW1lKQogewogCXN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbm5lbDsKIAlpbnQgcmV0OwogCi0JY2hh bm5lbCA9IG9mX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKG5wLCBjaGFubmVsX25hbWUpOworCWNo YW5uZWwgPSBmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoZndub2RlLCBjaGFubmVsX25h bWUpOwogCWlmIChJU19FUlIoY2hhbm5lbCkpCiAJCXJldHVybiBjaGFubmVsOwogCkBAIC00Mzgs NyArNDUzLDcgQEAgc3RydWN0IGlpb19jaGFubmVsICpkZXZtX29mX2lpb19jaGFubmVsX2dldF9i eV9uYW1lKHN0cnVjdCBkZXZpY2UgKmRldiwKIAogCXJldHVybiBjaGFubmVsOwogfQotRVhQT1JU X1NZTUJPTF9HUEwoZGV2bV9vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZSk7CitFWFBPUlRfU1lN Qk9MX0dQTChkZXZtX2Z3bm9kZV9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZSk7CiAKIHN0cnVjdCBp aW9fY2hhbm5lbCAqaWlvX2NoYW5uZWxfZ2V0X2FsbChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CkBA IC00NTIsNyArNDY3LDcgQEAgc3RydWN0IGlpb19jaGFubmVsICppaW9fY2hhbm5lbF9nZXRfYWxs KHN0cnVjdCBkZXZpY2UgKmRldikKIAlpZiAoZGV2ID09IE5VTEwpCiAJCXJldHVybiBFUlJfUFRS KC1FSU5WQUwpOwogCi0JY2hhbnMgPSBvZl9paW9fY2hhbm5lbF9nZXRfYWxsKGRldik7CisJY2hh bnMgPSBmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2FsbChkZXYpOwogCWlmICghSVNfRVJSKGNoYW5z KSB8fCBQVFJfRVJSKGNoYW5zKSA9PSAtRVBST0JFX0RFRkVSKQogCQlyZXR1cm4gY2hhbnM7CiAK ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaWlvL2NvbnN1bWVyLmggYi9pbmNsdWRlL2xpbnV4 L2lpby9jb25zdW1lci5oCmluZGV4IDVmYTU5NTc1ODZjZi4uYTk2YTcxNGI1ZmRjIDEwMDY0NAot LS0gYS9pbmNsdWRlL2xpbnV4L2lpby9jb25zdW1lci5oCisrKyBiL2luY2x1ZGUvbGludXgvaWlv L2NvbnN1bWVyLmgKQEAgLTksMTEgKzksMTMgQEAKIAogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+ CiAjaW5jbHVkZSA8bGludXgvaWlvL3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KIAog c3RydWN0IGlpb19kZXY7CiBzdHJ1Y3QgaWlvX2NoYW5fc3BlYzsKIHN0cnVjdCBkZXZpY2U7CiBz dHJ1Y3QgZGV2aWNlX25vZGU7CitzdHJ1Y3QgZndub2RlX2hhbmRsZTsKIAogLyoqCiAgKiBzdHJ1 Y3QgaWlvX2NoYW5uZWwgLSBldmVyeXRoaW5nIG5lZWRlZCBmb3IgYSBjb25zdW1lciB0byB1c2Ug YSBjaGFubmVsCkBAIC05OSwyNiArMTAxLDIwIEBAIHZvaWQgaWlvX2NoYW5uZWxfcmVsZWFzZV9h bGwoc3RydWN0IGlpb19jaGFubmVsICpjaGFuKTsKIHN0cnVjdCBpaW9fY2hhbm5lbCAqZGV2bV9p aW9fY2hhbm5lbF9nZXRfYWxsKHN0cnVjdCBkZXZpY2UgKmRldik7CiAKIC8qKgotICogb2ZfaWlv X2NoYW5uZWxfZ2V0X2J5X25hbWUoKSAtIGdldCBkZXNjcmlwdGlvbiBvZiBhbGwgdGhhdCBpcyBu ZWVkZWQgdG8gYWNjZXNzIGNoYW5uZWwuCi0gKiBAbnA6CQkJUG9pbnRlciB0byBjb25zdW1lciBk ZXZpY2UgdHJlZSBub2RlCisgKiBmd25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoKSAtIGdl dCBkZXNjcmlwdGlvbiBvZiBhbGwgdGhhdCBpcyBuZWVkZWQgdG8gYWNjZXNzIGNoYW5uZWwuCisg KiBAZndub2RlOgkJUG9pbnRlciB0byBjb25zdW1lciBGaXJtd2FyZSBub2RlCiAgKiBAY29uc3Vt ZXJfY2hhbm5lbDoJVW5pcXVlIG5hbWUgdG8gaWRlbnRpZnkgdGhlIGNoYW5uZWwgb24gdGhlIGNv bnN1bWVyCiAgKgkJCXNpZGUuIFRoaXMgdHlwaWNhbGx5IGRlc2NyaWJlcyB0aGUgY2hhbm5lbHMg dXNlIHdpdGhpbgogICoJCQl0aGUgY29uc3VtZXIuIEUuZy4gJ2JhdHRlcnlfdm9sdGFnZScKICAq LwotI2lmZGVmIENPTkZJR19PRgotc3RydWN0IGlpb19jaGFubmVsICpvZl9paW9fY2hhbm5lbF9n ZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLCBjb25zdCBjaGFyICpuYW1lKTsKLSNl bHNlCi1zdGF0aWMgaW5saW5lIHN0cnVjdCBpaW9fY2hhbm5lbCAqCi1vZl9paW9fY2hhbm5lbF9n ZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLCBjb25zdCBjaGFyICpuYW1lKQotewot CXJldHVybiBOVUxMOwotfQotI2VuZGlmCitzdHJ1Y3QgaWlvX2NoYW5uZWwgKmZ3bm9kZV9paW9f Y2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QgZndub2RlX2hhbmRsZSAqZndub2RlLAorCQkJCQkJ ICAgY29uc3QgY2hhciAqbmFtZSk7CiAKIC8qKgotICogZGV2bV9vZl9paW9fY2hhbm5lbF9nZXRf YnlfbmFtZSgpIC0gUmVzb3VyY2UgbWFuYWdlZCB2ZXJzaW9uIG9mIG9mX2lpb19jaGFubmVsX2dl dF9ieV9uYW1lKCkuCisgKiBkZXZtX2Z3bm9kZV9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZSgpIC0g UmVzb3VyY2UgbWFuYWdlZCB2ZXJzaW9uIG9mCisgKgkJCQkJICAgZndub2RlX2lpb19jaGFubmVs X2dldF9ieV9uYW1lKCkuCiAgKiBAZGV2OgkJUG9pbnRlciB0byBjb25zdW1lciBkZXZpY2UuCi0g KiBAbnA6CQkJUG9pbnRlciB0byBjb25zdW1lciBkZXZpY2UgdHJlZSBub2RlCisgKiBAZndub2Rl OgkJUG9pbnRlciB0byBjb25zdW1lciBGaXJtd2FyZSBub2RlCiAgKiBAY29uc3VtZXJfY2hhbm5l bDoJVW5pcXVlIG5hbWUgdG8gaWRlbnRpZnkgdGhlIGNoYW5uZWwgb24gdGhlIGNvbnN1bWVyCiAg KgkJCXNpZGUuIFRoaXMgdHlwaWNhbGx5IGRlc2NyaWJlcyB0aGUgY2hhbm5lbHMgdXNlIHdpdGhp bgogICoJCQl0aGUgY29uc3VtZXIuIEUuZy4gJ2JhdHRlcnlfdm9sdGFnZScKQEAgLTEyOSw5ICsx MjUsMTcgQEAgb2ZfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoc3RydWN0IGRldmljZV9ub2RlICpu cCwgY29uc3QgY2hhciAqbmFtZSkKICAqIFRoZSBhbGxvY2F0ZWQgaWlvIGNoYW5uZWwgaXMgYXV0 b21hdGljYWxseSByZWxlYXNlZCB3aGVuIHRoZSBkZXZpY2UgaXMKICAqIHVuYm91bmQuCiAgKi8K LXN0cnVjdCBpaW9fY2hhbm5lbCAqZGV2bV9vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1 Y3QgZGV2aWNlICpkZXYsCi0JCQkJCQkgICAgc3RydWN0IGRldmljZV9ub2RlICpucCwKLQkJCQkJ CSAgICBjb25zdCBjaGFyICpjb25zdW1lcl9jaGFubmVsKTsKK3N0cnVjdCBpaW9fY2hhbm5lbCAq ZGV2bV9md25vZGVfaWlvX2NoYW5uZWxfZ2V0X2J5X25hbWUoc3RydWN0IGRldmljZSAqZGV2LAor CQkJCQkJCXN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUsCisJCQkJCQkJY29uc3QgY2hhciAq Y29uc3VtZXJfY2hhbm5lbCk7CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGlpb19jaGFubmVsCisq ZGV2bV9vZl9paW9fY2hhbm5lbF9nZXRfYnlfbmFtZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCBkZXZpY2Vfbm9kZSAqbnAsCisJCQkJIGNvbnN0IGNoYXIgKmNvbnN1bWVyX2NoYW5uZWwpCit7 CisJcmV0dXJuIGRldm1fZndub2RlX2lpb19jaGFubmVsX2dldF9ieV9uYW1lKGRldiwgb2ZfZndu b2RlX2hhbmRsZShucCksCisJCQkJCQkgICBjb25zdW1lcl9jaGFubmVsKTsKK30KIAogc3RydWN0 IGlpb19jYl9idWZmZXI7CiAvKioKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaWlvL2lpby5o IGIvaW5jbHVkZS9saW51eC9paW8vaWlvLmgKaW5kZXggZDliNGE5Y2E5YTBmLi40OTRhYmI2MzQw NmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaWlvL2lpby5oCisrKyBiL2luY2x1ZGUvbGlu dXgvaWlvL2lpby5oCkBAIC0xOCw2ICsxOCw3IEBACiAgKi8KIAogc3RydWN0IG9mX3BoYW5kbGVf YXJnczsKK3N0cnVjdCBmd25vZGVfcmVmZXJlbmNlX2FyZ3M7CiAKIGVudW0gaWlvX3NoYXJlZF9i eSB7CiAJSUlPX1NFUEFSQVRFLApAQCAtNDI5LDYgKzQzMCw4IEBAIHN0cnVjdCBpaW9fdHJpZ2dl cjsgLyogZm9yd2FyZCBkZWNsYXJhdGlvbiAqLwogICoJCQlwcm92aWRlIGEgY3VzdG9tIG9mX3hs YXRlIGZ1bmN0aW9uIHRoYXQgcmVhZHMgdGhlCiAgKgkJCSphcmdzKiBhbmQgcmV0dXJucyB0aGUg YXBwcm9wcmlhdGUgaW5kZXggaW4gcmVnaXN0ZXJlZAogICoJCQlJSU8gY2hhbm5lbHMgYXJyYXku CisgKiBAZndub2RlX3hsYXRlOglmd25vZGUgYmFzZWQgZnVuY3Rpb24gcG9pbnRlciB0byBvYnRh aW4gY2hhbm5lbCBzcGVjaWZpZXIgaW5kZXguCisgKgkJCUZ1bmN0aW9uYWxseSB0aGUgc2FtZSBh cyBAb2ZfeGxhdGUuCiAgKiBAaHdmaWZvX3NldF93YXRlcm1hcms6IGZ1bmN0aW9uIHBvaW50ZXIg dG8gc2V0IHRoZSBjdXJyZW50IGhhcmR3YXJlCiAgKgkJCWZpZm8gd2F0ZXJtYXJrIGxldmVsOyBz ZWUgaHdmaWZvXyogZW50cmllcyBpbgogICoJCQlEb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5 c2ZzLWJ1cy1paW8gZm9yIGRldGFpbHMgb24KQEAgLTUxMCw2ICs1MTMsOCBAQCBzdHJ1Y3QgaWlv X2luZm8gewogCQkJCSAgdW5zaWduZWQgKnJlYWR2YWwpOwogCWludCAoKm9mX3hsYXRlKShzdHJ1 Y3QgaWlvX2RldiAqaW5kaW9fZGV2LAogCQkJY29uc3Qgc3RydWN0IG9mX3BoYW5kbGVfYXJncyAq aWlvc3BlYyk7CisJaW50ICgqZndub2RlX3hsYXRlKShzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2 LAorCQkJICAgIGNvbnN0IHN0cnVjdCBmd25vZGVfcmVmZXJlbmNlX2FyZ3MgKmlpb3NwZWMpOwog CWludCAoKmh3Zmlmb19zZXRfd2F0ZXJtYXJrKShzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LCB1 bnNpZ25lZCB2YWwpOwogCWludCAoKmh3Zmlmb19mbHVzaF90b19idWZmZXIpKHN0cnVjdCBpaW9f ZGV2ICppbmRpb19kZXYsCiAJCQkJICAgICAgdW5zaWduZWQgY291bnQpOwotLSAKMi4zNi4xCgoK 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 CF03CC43334 for ; Thu, 16 Jun 2022 02:13:19 +0000 (UTC) Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4LNm1B3mcKz3fFJ for ; Thu, 16 Jun 2022 12:13:18 +1000 (AEST) Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=analog.com (client-ip=148.163.135.77; helo=mx0a-00128a01.pphosted.com; envelope-from=nuno.sa@analog.com; receiver=) Received: from mx0a-00128a01.pphosted.com (mx0a-00128a01.pphosted.com [148.163.135.77]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4LKF4F35YWz3brl for ; Fri, 10 Jun 2022 18:48:45 +1000 (AEST) Received: from pps.filterd (m0167089.ppops.net [127.0.0.1]) by mx0a-00128a01.pphosted.com (8.17.1.5/8.17.1.5) with ESMTP id 25A7h8EU005272; Fri, 10 Jun 2022 04:48:18 -0400 Received: from nwd2mta4.analog.com ([137.71.173.58]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3ghq33kqad-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 10 Jun 2022 04:48:17 -0400 Received: from ASHBMBX8.ad.analog.com (ASHBMBX8.ad.analog.com [10.64.17.5]) by nwd2mta4.analog.com (8.14.7/8.14.7) with ESMTP id 25A8mGbk027556 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 10 Jun 2022 04:48:16 -0400 Received: from ASHBCASHYB5.ad.analog.com (10.64.17.133) by ASHBMBX8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Fri, 10 Jun 2022 04:48:15 -0400 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBCASHYB5.ad.analog.com (10.64.17.133) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.14; Fri, 10 Jun 2022 04:48:15 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Fri, 10 Jun 2022 04:48:15 -0400 Received: from nsa.ad.analog.com ([10.44.3.70]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 25A8imik014275; Fri, 10 Jun 2022 04:48:04 -0400 From: =?UTF-8?q?Nuno=20S=C3=A1?= To: , , , , , Lad Prabhakar , , , , , Subject: [PATCH 24/34] iio: inkern: move to fwnode properties Date: Fri, 10 Jun 2022 10:45:35 +0200 Message-ID: <20220610084545.547700-25-nuno.sa@analog.com> X-Mailer: git-send-email 2.36.1 In-Reply-To: <20220610084545.547700-1-nuno.sa@analog.com> References: <20220610084545.547700-1-nuno.sa@analog.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit X-ADIRuleOP-NewSCL: Rule Triggered X-Proofpoint-ORIG-GUID: SLrT9c5dbr2AGqM0_4SQx-b6M19QpuVb X-Proofpoint-GUID: SLrT9c5dbr2AGqM0_4SQx-b6M19QpuVb X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.874,Hydra:6.0.517,FMLib:17.11.64.514 definitions=2022-06-10_02,2022-06-09_02,2022-02-23_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 mlxlogscore=999 phishscore=0 priorityscore=1501 adultscore=0 clxscore=1015 lowpriorityscore=0 mlxscore=0 spamscore=0 impostorscore=0 bulkscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2204290000 definitions=main-2206100031 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" , Linus Walleij , Amit Kucheria , Alexandre Torgue , Tali Perry , Paul Cercueil , Miquel Raynal , Guenter Roeck , Fabio Estevam , Lars-Peter Clausen , Benjamin Fair , Jishnu Prakash , Haibo Chen , Andy Shevchenko , Andy Gross , Olivier Moysan , Zhang Rui , Christophe Branchereau , Saravanan Sekar , Michael Hennerich , Sascha Hauer , Fabrice Gasnier , Cai Huoqing , Matthias Brugger , Gwendal Grignou , Bjorn Andersson , Benson Leung , Pengutronix Kernel Team , Lorenzo Bianconi , Avi Fishman , Patrick Venture , Nicolas Ferre , Thara Gopinath , Arnd Bergmann , Maxime Coquelin , Eugen Hristev , Shawn Guo , Claudiu Beznea , Jonathan Cameron Errors-To: openbmc-bounces+openbmc=archiver.kernel.org@lists.ozlabs.org Sender: "openbmc" 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. 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); +} + +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; - 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); 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); *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; + } - 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; - - np = np->parent; + } } return chan; } -EXPORT_SYMBOL_GPL(of_iio_channel_get_by_name); +EXPORT_SYMBOL_GPL(fwnode_iio_channel_get_by_name); -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 struct iio_dev; struct iio_chan_spec; struct device; struct device_node; +struct fwnode_handle; /** * struct iio_channel - everything needed for a consumer to use a channel @@ -99,26 +101,20 @@ void iio_channel_release_all(struct iio_channel *chan); struct iio_channel *devm_iio_channel_get_all(struct device *dev); /** - * of_iio_channel_get_by_name() - get description of all that is needed to access channel. - * @np: Pointer to consumer device tree node + * fwnode_iio_channel_get_by_name() - get description of all that is needed to access channel. + * @fwnode: Pointer to consumer Firmware node * @consumer_channel: Unique name to identify the channel on the consumer * side. This typically describes the channels use within * the consumer. E.g. 'battery_voltage' */ -#ifdef CONFIG_OF -struct iio_channel *of_iio_channel_get_by_name(struct device_node *np, const char *name); -#else -static inline struct iio_channel * -of_iio_channel_get_by_name(struct device_node *np, const char *name) -{ - return NULL; -} -#endif +struct iio_channel *fwnode_iio_channel_get_by_name(struct fwnode_handle *fwnode, + const char *name); /** - * devm_of_iio_channel_get_by_name() - Resource managed version of of_iio_channel_get_by_name(). + * devm_fwnode_iio_channel_get_by_name() - Resource managed version of + * fwnode_iio_channel_get_by_name(). * @dev: Pointer to consumer device. - * @np: Pointer to consumer device tree node + * @fwnode: Pointer to consumer Firmware node * @consumer_channel: Unique name to identify the channel on the consumer * side. This typically describes the channels use within * the consumer. E.g. 'battery_voltage' @@ -129,9 +125,17 @@ of_iio_channel_get_by_name(struct device_node *np, const char *name) * The allocated iio channel is automatically released when the device is * unbound. */ -struct iio_channel *devm_of_iio_channel_get_by_name(struct device *dev, - struct device_node *np, - const char *consumer_channel); +struct iio_channel *devm_fwnode_iio_channel_get_by_name(struct device *dev, + struct fwnode_handle *fwnode, + const char *consumer_channel); + +static inline struct iio_channel +*devm_of_iio_channel_get_by_name(struct device *dev, struct device_node *np, + const char *consumer_channel) +{ + return devm_fwnode_iio_channel_get_by_name(dev, of_fwnode_handle(np), + consumer_channel); +} struct iio_cb_buffer; /** diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h index d9b4a9ca9a0f..494abb63406e 100644 --- a/include/linux/iio/iio.h +++ b/include/linux/iio/iio.h @@ -18,6 +18,7 @@ */ struct of_phandle_args; +struct fwnode_reference_args; enum iio_shared_by { IIO_SEPARATE, @@ -429,6 +430,8 @@ struct iio_trigger; /* forward declaration */ * provide a custom of_xlate function that reads the * *args* and returns the appropriate index in registered * IIO channels array. + * @fwnode_xlate: fwnode based function pointer to obtain channel specifier index. + * Functionally the same as @of_xlate. * @hwfifo_set_watermark: function pointer to set the current hardware * fifo watermark level; see hwfifo_* entries in * Documentation/ABI/testing/sysfs-bus-iio for details on @@ -510,6 +513,8 @@ struct iio_info { unsigned *readval); int (*of_xlate)(struct iio_dev *indio_dev, const struct of_phandle_args *iiospec); + int (*fwnode_xlate)(struct iio_dev *indio_dev, + const struct fwnode_reference_args *iiospec); int (*hwfifo_set_watermark)(struct iio_dev *indio_dev, unsigned val); int (*hwfifo_flush_to_buffer)(struct iio_dev *indio_dev, unsigned count); -- 2.36.1