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 B34617C for ; Fri, 10 Jun 2022 08:49:36 +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 25A7SjCp005350; Fri, 10 Jun 2022 04:49:13 -0400 Received: from nwd2mta3.analog.com ([137.71.173.56]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3ghq33kqem-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 10 Jun 2022 04:49:13 -0400 Received: from ASHBMBX9.ad.analog.com (ASHBMBX9.ad.analog.com [10.64.17.10]) by nwd2mta3.analog.com (8.14.7/8.14.7) with ESMTP id 25A8nCMi023344 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 10 Jun 2022 04:49:12 -0400 Received: from ASHBMBX8.ad.analog.com (10.64.17.5) by ASHBMBX9.ad.analog.com (10.64.17.10) 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:49:11 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Fri, 10 Jun 2022 04:49:08 -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 25A8imis014275; Fri, 10 Jun 2022 04:48:57 -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 32/34] iio: adc: stm32-adc: convert to device properties Date: Fri, 10 Jun 2022 10:45:43 +0200 Message-ID: <20220610084545.547700-33-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: _T5ULNt7aIz7kEBK-I7icaSifMJ0z1zY X-Proofpoint-GUID: _T5ULNt7aIz7kEBK-I7icaSifMJ0z1zY 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-2206100032 Make the conversion to firmware agnostic device properties. As part of the conversion the IIO inkern interface 'of_xlate()' is also converted to 'fwnode_xlate()'. The goal is to completely drop 'of_xlate' and hence OF dependencies from IIO. Signed-off-by: Nuno Sá --- drivers/iio/adc/stm32-adc.c | 128 ++++++++++++++++++++---------------- 1 file changed, 70 insertions(+), 58 deletions(-) diff --git a/drivers/iio/adc/stm32-adc.c b/drivers/iio/adc/stm32-adc.c index a68ecbda6480..87acef31ace1 100644 --- a/drivers/iio/adc/stm32-adc.c +++ b/drivers/iio/adc/stm32-adc.c @@ -21,11 +21,11 @@ #include #include #include +#include #include #include #include -#include -#include +#include #include "stm32-adc-core.h" @@ -1524,8 +1524,8 @@ static int stm32_adc_update_scan_mode(struct iio_dev *indio_dev, return ret; } -static int stm32_adc_of_xlate(struct iio_dev *indio_dev, - const struct of_phandle_args *iiospec) +static int stm32_adc_fwnode_xlate(struct iio_dev *indio_dev, + const struct fwnode_reference_args *iiospec) { int i; @@ -1579,7 +1579,7 @@ static const struct iio_info stm32_adc_iio_info = { .hwfifo_set_watermark = stm32_adc_set_watermark, .update_scan_mode = stm32_adc_update_scan_mode, .debugfs_reg_access = stm32_adc_debugfs_reg_access, - .of_xlate = stm32_adc_of_xlate, + .fwnode_xlate = stm32_adc_fwnode_xlate, }; static unsigned int stm32_adc_dma_residue(struct stm32_adc *adc) @@ -1776,14 +1776,14 @@ static const struct iio_chan_spec_ext_info stm32_adc_ext_info[] = { {}, }; -static int stm32_adc_of_get_resolution(struct iio_dev *indio_dev) +static int stm32_adc_fw_get_resolution(struct iio_dev *indio_dev) { - struct device_node *node = indio_dev->dev.of_node; + struct device *dev = &indio_dev->dev; struct stm32_adc *adc = iio_priv(indio_dev); unsigned int i; u32 res; - if (of_property_read_u32(node, "assigned-resolution-bits", &res)) + if (device_property_read_u32(dev, "assigned-resolution-bits", &res)) res = adc->cfg->adc_info->resolutions[0]; for (i = 0; i < adc->cfg->adc_info->num_res; i++) @@ -1867,11 +1867,11 @@ static void stm32_adc_chan_init_one(struct iio_dev *indio_dev, static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm32_adc *adc) { - struct device_node *node = indio_dev->dev.of_node; + struct device *dev = &indio_dev->dev; const struct stm32_adc_info *adc_info = adc->cfg->adc_info; int num_channels = 0, ret; - ret = of_property_count_u32_elems(node, "st,adc-channels"); + ret = device_property_count_u32(dev, "st,adc-channels"); if (ret > adc_info->max_channels) { dev_err(&indio_dev->dev, "Bad st,adc-channels?\n"); return -EINVAL; @@ -1879,18 +1879,17 @@ static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm num_channels += ret; } - ret = of_property_count_elems_of_size(node, "st,adc-diff-channels", - sizeof(struct stm32_adc_diff_channel)); - if (ret > adc_info->max_channels) { + ret = device_property_count_u32(dev, "st,adc-diff-channels"); + if ((ret / 2) > adc_info->max_channels) { dev_err(&indio_dev->dev, "Bad st,adc-diff-channels?\n"); return -EINVAL; - } else if (ret > 0) { - adc->num_diff = ret; - num_channels += ret; + } else if ((ret / 2) > 0) { + adc->num_diff = ret / 2; + num_channels += ret / 2; } /* Optional sample time is provided either for each, or all channels */ - ret = of_property_count_u32_elems(node, "st,min-sample-time-nsecs"); + ret = device_property_count_u32(dev, "st,min-sample-time-nsecs"); if (ret > 1 && ret != num_channels) { dev_err(&indio_dev->dev, "Invalid st,min-sample-time-nsecs\n"); return -EINVAL; @@ -1901,21 +1900,20 @@ static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm static int stm32_adc_legacy_chan_init(struct iio_dev *indio_dev, struct stm32_adc *adc, - struct iio_chan_spec *channels) + struct iio_chan_spec *channels, + int nchans) { - struct device_node *node = indio_dev->dev.of_node; const struct stm32_adc_info *adc_info = adc->cfg->adc_info; struct stm32_adc_diff_channel diff[STM32_ADC_CH_MAX]; + struct device *dev = &indio_dev->dev; u32 num_diff = adc->num_diff; int size = num_diff * sizeof(*diff) / sizeof(u32); - int scan_index = 0, val, ret, i; - struct property *prop; - const __be32 *cur; - u32 smp = 0; + int scan_index = 0, ret, i; + u32 smp = 0, nsmps, smps[STM32_ADC_CH_MAX], chans[STM32_ADC_CH_MAX]; if (num_diff) { - ret = of_property_read_u32_array(node, "st,adc-diff-channels", - (u32 *)diff, size); + ret = device_property_read_u32_array(dev, "st,adc-diff-channels", + (u32 *)diff, size); if (ret) { dev_err(&indio_dev->dev, "Failed to get diff channels %d\n", ret); return ret; @@ -1936,32 +1934,51 @@ static int stm32_adc_legacy_chan_init(struct iio_dev *indio_dev, } } - of_property_for_each_u32(node, "st,adc-channels", prop, cur, val) { - if (val >= adc_info->max_channels) { - dev_err(&indio_dev->dev, "Invalid channel %d\n", val); + ret = device_property_read_u32_array(dev, "st,adc-channels", chans, + nchans); + if (ret) + return ret; + + for (i = 0; i < nchans; i++) { + if (chans[i] >= adc_info->max_channels) { + dev_err(&indio_dev->dev, "Invalid channel %d\n", + chans[i]); return -EINVAL; } /* Channel can't be configured both as single-ended & diff */ for (i = 0; i < num_diff; i++) { - if (val == diff[i].vinp) { - dev_err(&indio_dev->dev, "channel %d misconfigured\n", val); + if (chans[i] == diff[i].vinp) { + dev_err(&indio_dev->dev, "channel %d misconfigured\n", chans[i]); return -EINVAL; } } - stm32_adc_chan_init_one(indio_dev, &channels[scan_index], val, - 0, scan_index, false); + stm32_adc_chan_init_one(indio_dev, &channels[scan_index], + chans[i], 0, scan_index, false); scan_index++; } + nsmps = device_property_count_u32(dev, "st,min-sample-time-nsecs"); + if (nsmps) { + if (nsmps >= nchans) + nsmps = nchans; + + ret = device_property_read_u32_array(dev, "st,min-sample-time-nsecs", + smps, nsmps); + if (ret) + return ret; + } + for (i = 0; i < scan_index; i++) { /* - * Using of_property_read_u32_index(), smp value will only be - * modified if valid u32 value can be decoded. This allows to - * get either no value, 1 shared value for all indexes, or one - * value per channel. + * This check is used with the above logic so that smp value + * will only be modified if valid u32 value can be decoded. This + * allows to get either no value, 1 shared value for all indexes, + * or one value per channel. The point is to have the same + * behavior as 'of_property_read_u32_index()'. */ - of_property_read_u32_index(node, "st,min-sample-time-nsecs", i, &smp); + if (i < nsmps) + smp = smps[i]; /* Prepare sampling time settings */ stm32_adc_smpr_init(adc, channels[i].channel, smp); @@ -2004,22 +2021,21 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, struct stm32_adc *adc, struct iio_chan_spec *channels) { - struct device_node *node = indio_dev->dev.of_node; const struct stm32_adc_info *adc_info = adc->cfg->adc_info; - struct device_node *child; + struct fwnode_handle *child; const char *name; int val, scan_index = 0, ret; bool differential; u32 vin[2]; - for_each_available_child_of_node(node, child) { - ret = of_property_read_u32(child, "reg", &val); + device_for_each_child_node(&indio_dev->dev, child) { + ret = fwnode_property_read_u32(child, "reg", &val); if (ret) { dev_err(&indio_dev->dev, "Missing channel index %d\n", ret); goto err; } - ret = of_property_read_string(child, "label", &name); + ret = fwnode_property_read_string(child, "label", &name); /* label is optional */ if (!ret) { if (strlen(name) >= STM32_ADC_CH_SZ) { @@ -2044,7 +2060,7 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, } differential = false; - ret = of_property_read_u32_array(child, "diff-channels", vin, 2); + ret = fwnode_property_read_u32_array(child, "diff-channels", vin, 2); /* diff-channels is optional */ if (!ret) { differential = true; @@ -2061,7 +2077,7 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, stm32_adc_chan_init_one(indio_dev, &channels[scan_index], val, vin[1], scan_index, differential); - ret = of_property_read_u32(child, "st,min-sample-time-ns", &val); + ret = fwnode_property_read_u32(child, "st,min-sample-time-ns", &val); /* st,min-sample-time-ns is optional */ if (!ret) { stm32_adc_smpr_init(adc, channels[scan_index].channel, val); @@ -2079,14 +2095,13 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, return scan_index; err: - of_node_put(child); + fwnode_handle_put(child); return ret; } -static int stm32_adc_chan_of_init(struct iio_dev *indio_dev, bool timestamping) +static int stm32_adc_chan_fw_init(struct iio_dev *indio_dev, bool timestamping) { - struct device_node *node = indio_dev->dev.of_node; struct stm32_adc *adc = iio_priv(indio_dev); const struct stm32_adc_info *adc_info = adc->cfg->adc_info; struct iio_chan_spec *channels; @@ -2096,7 +2111,7 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev, bool timestamping) for (i = 0; i < STM32_ADC_INT_CH_NB; i++) adc->int_ch[i] = STM32_ADC_INT_CH_NONE; - num_channels = of_get_available_child_count(node); + num_channels = device_get_child_node_count(&indio_dev->dev); /* If no channels have been found, fallback to channels legacy properties. */ if (!num_channels) { legacy = true; @@ -2127,7 +2142,8 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev, bool timestamping) return -ENOMEM; if (legacy) - ret = stm32_adc_legacy_chan_init(indio_dev, adc, channels); + ret = stm32_adc_legacy_chan_init(indio_dev, adc, channels, + num_channels); else ret = stm32_adc_generic_chan_init(indio_dev, adc, channels); if (ret < 0) @@ -2209,9 +2225,6 @@ static int stm32_adc_probe(struct platform_device *pdev) bool timestamping = false; int ret; - if (!pdev->dev.of_node) - return -ENODEV; - indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc)); if (!indio_dev) return -ENOMEM; @@ -2220,17 +2233,16 @@ static int stm32_adc_probe(struct platform_device *pdev) adc->common = dev_get_drvdata(pdev->dev.parent); spin_lock_init(&adc->lock); init_completion(&adc->completion); - adc->cfg = (const struct stm32_adc_cfg *) - of_match_device(dev->driver->of_match_table, dev)->data; + adc->cfg = device_get_match_data(dev); indio_dev->name = dev_name(&pdev->dev); - indio_dev->dev.of_node = pdev->dev.of_node; + device_set_node(&indio_dev->dev, dev_fwnode(&pdev->dev)); indio_dev->info = &stm32_adc_iio_info; indio_dev->modes = INDIO_DIRECT_MODE | INDIO_HARDWARE_TRIGGERED; platform_set_drvdata(pdev, indio_dev); - ret = of_property_read_u32(pdev->dev.of_node, "reg", &adc->offset); + ret = device_property_read_u32(dev, "reg", &adc->offset); if (ret != 0) { dev_err(&pdev->dev, "missing reg property\n"); return -EINVAL; @@ -2259,7 +2271,7 @@ static int stm32_adc_probe(struct platform_device *pdev) } } - ret = stm32_adc_of_get_resolution(indio_dev); + ret = stm32_adc_fw_get_resolution(indio_dev); if (ret < 0) return ret; @@ -2276,7 +2288,7 @@ static int stm32_adc_probe(struct platform_device *pdev) timestamping = true; } - ret = stm32_adc_chan_of_init(indio_dev, timestamping); + ret = stm32_adc_chan_fw_init(indio_dev, timestamping); if (ret < 0) goto err_dma_disable; -- 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 83473C433EF for ; Fri, 10 Jun 2022 08:49:45 +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=LhTqgJj0veISUxXMoD4Ixp6PWtThl1rAlcZqrCj8sMQ=; b=mWZNv6FuTRlgyZ bbgK+dxBLiDkBv5OMP8KCD0iRLzrwb45bxsboDxjnjQj11ph3M3ZWvNvzh7MxesteztLw/O0yjIHH tYXmqbrutHFXhQkTNKGbCvdrq1HXOFZCSZWnYadcJqw+M2hQKMqK09qg/loQHHI0UjvoCq75xV7wK mqpThIdz58WelSlNOwBf7ofBHVPucFh33I6ZYodftLeSp/wraI5A+1CXHLKSmfmKGNwLyJ85EtZXd +3Ixyf0TbVT9mAUnTrpsIZCF6kujQvQ6LZU1Tl5mVX4IzM++GwoGNFDUIDURaamuM4MzkYgtCd/Ez wFzmv9oMZdrMfxJE+LKw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzaKp-006vQn-0J; Fri, 10 Jun 2022 08:49:39 +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 1nzaKj-006vNP-JY; Fri, 10 Jun 2022 08:49:36 +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 25A7SjCp005350; Fri, 10 Jun 2022 04:49:13 -0400 Received: from nwd2mta3.analog.com ([137.71.173.56]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3ghq33kqem-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 10 Jun 2022 04:49:13 -0400 Received: from ASHBMBX9.ad.analog.com (ASHBMBX9.ad.analog.com [10.64.17.10]) by nwd2mta3.analog.com (8.14.7/8.14.7) with ESMTP id 25A8nCMi023344 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 10 Jun 2022 04:49:12 -0400 Received: from ASHBMBX8.ad.analog.com (10.64.17.5) by ASHBMBX9.ad.analog.com (10.64.17.10) 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:49:11 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Fri, 10 Jun 2022 04:49:08 -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 25A8imis014275; Fri, 10 Jun 2022 04:48:57 -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 32/34] iio: adc: stm32-adc: convert to device properties Date: Fri, 10 Jun 2022 10:45:43 +0200 Message-ID: <20220610084545.547700-33-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: _T5ULNt7aIz7kEBK-I7icaSifMJ0z1zY X-Proofpoint-GUID: _T5ULNt7aIz7kEBK-I7icaSifMJ0z1zY 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-2206100032 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220610_014933_710006_BBF05E64 X-CRM114-Status: GOOD ( 28.84 ) 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 TWFrZSB0aGUgY29udmVyc2lvbiB0byBmaXJtd2FyZSBhZ25vc3RpYyBkZXZpY2UgcHJvcGVydGll cy4gQXMgcGFydCBvZgp0aGUgY29udmVyc2lvbiB0aGUgSUlPIGlua2VybiBpbnRlcmZhY2UgJ29m X3hsYXRlKCknIGlzIGFsc28gY29udmVydGVkIHRvCidmd25vZGVfeGxhdGUoKScuIFRoZSBnb2Fs IGlzIHRvIGNvbXBsZXRlbHkgZHJvcCAnb2ZfeGxhdGUnIGFuZCBoZW5jZSBPRgpkZXBlbmRlbmNp ZXMgZnJvbSBJSU8uCgpTaWduZWQtb2ZmLWJ5OiBOdW5vIFPDoSA8bnVuby5zYUBhbmFsb2cuY29t PgotLS0KIGRyaXZlcnMvaWlvL2FkYy9zdG0zMi1hZGMuYyB8IDEyOCArKysrKysrKysrKysrKysr KysrKy0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCA3MCBpbnNlcnRpb25zKCspLCA1 OCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lpby9hZGMvc3RtMzItYWRjLmMg Yi9kcml2ZXJzL2lpby9hZGMvc3RtMzItYWRjLmMKaW5kZXggYTY4ZWNiZGE2NDgwLi44N2FjZWYz MWFjZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWlvL2FkYy9zdG0zMi1hZGMuYworKysgYi9kcml2 ZXJzL2lpby9hZGMvc3RtMzItYWRjLmMKQEAgLTIxLDExICsyMSwxMSBAQAogI2luY2x1ZGUgPGxp bnV4L2lvLmg+CiAjaW5jbHVkZSA8bGludXgvaW9wb2xsLmg+CiAjaW5jbHVkZSA8bGludXgvbW9k dWxlLmg+CisjaW5jbHVkZSA8bGludXgvbW9kX2RldmljZXRhYmxlLmg+CiAjaW5jbHVkZSA8bGlu dXgvbnZtZW0tY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4K ICNpbmNsdWRlIDxsaW51eC9wbV9ydW50aW1lLmg+Ci0jaW5jbHVkZSA8bGludXgvb2YuaD4KLSNp bmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wcm9wZXJ0eS5oPgog CiAjaW5jbHVkZSAic3RtMzItYWRjLWNvcmUuaCIKIApAQCAtMTUyNCw4ICsxNTI0LDggQEAgc3Rh dGljIGludCBzdG0zMl9hZGNfdXBkYXRlX3NjYW5fbW9kZShzdHJ1Y3QgaWlvX2RldiAqaW5kaW9f ZGV2LAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBpbnQgc3RtMzJfYWRjX29mX3hsYXRlKHN0 cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCi0JCQkgICAgICBjb25zdCBzdHJ1Y3Qgb2ZfcGhhbmRs ZV9hcmdzICppaW9zcGVjKQorc3RhdGljIGludCBzdG0zMl9hZGNfZndub2RlX3hsYXRlKHN0cnVj dCBpaW9fZGV2ICppbmRpb19kZXYsCisJCQkJICBjb25zdCBzdHJ1Y3QgZndub2RlX3JlZmVyZW5j ZV9hcmdzICppaW9zcGVjKQogewogCWludCBpOwogCkBAIC0xNTc5LDcgKzE1NzksNyBAQCBzdGF0 aWMgY29uc3Qgc3RydWN0IGlpb19pbmZvIHN0bTMyX2FkY19paW9faW5mbyA9IHsKIAkuaHdmaWZv X3NldF93YXRlcm1hcmsgPSBzdG0zMl9hZGNfc2V0X3dhdGVybWFyaywKIAkudXBkYXRlX3NjYW5f bW9kZSA9IHN0bTMyX2FkY191cGRhdGVfc2Nhbl9tb2RlLAogCS5kZWJ1Z2ZzX3JlZ19hY2Nlc3Mg PSBzdG0zMl9hZGNfZGVidWdmc19yZWdfYWNjZXNzLAotCS5vZl94bGF0ZSA9IHN0bTMyX2FkY19v Zl94bGF0ZSwKKwkuZndub2RlX3hsYXRlID0gc3RtMzJfYWRjX2Z3bm9kZV94bGF0ZSwKIH07CiAK IHN0YXRpYyB1bnNpZ25lZCBpbnQgc3RtMzJfYWRjX2RtYV9yZXNpZHVlKHN0cnVjdCBzdG0zMl9h ZGMgKmFkYykKQEAgLTE3NzYsMTQgKzE3NzYsMTQgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBpaW9f Y2hhbl9zcGVjX2V4dF9pbmZvIHN0bTMyX2FkY19leHRfaW5mb1tdID0gewogCXt9LAogfTsKIAot c3RhdGljIGludCBzdG0zMl9hZGNfb2ZfZ2V0X3Jlc29sdXRpb24oc3RydWN0IGlpb19kZXYgKmlu ZGlvX2RldikKK3N0YXRpYyBpbnQgc3RtMzJfYWRjX2Z3X2dldF9yZXNvbHV0aW9uKHN0cnVjdCBp aW9fZGV2ICppbmRpb19kZXYpCiB7Ci0Jc3RydWN0IGRldmljZV9ub2RlICpub2RlID0gaW5kaW9f ZGV2LT5kZXYub2Zfbm9kZTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmaW5kaW9fZGV2LT5kZXY7 CiAJc3RydWN0IHN0bTMyX2FkYyAqYWRjID0gaWlvX3ByaXYoaW5kaW9fZGV2KTsKIAl1bnNpZ25l ZCBpbnQgaTsKIAl1MzIgcmVzOwogCi0JaWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyKG5vZGUsICJh c3NpZ25lZC1yZXNvbHV0aW9uLWJpdHMiLCAmcmVzKSkKKwlpZiAoZGV2aWNlX3Byb3BlcnR5X3Jl YWRfdTMyKGRldiwgImFzc2lnbmVkLXJlc29sdXRpb24tYml0cyIsICZyZXMpKQogCQlyZXMgPSBh ZGMtPmNmZy0+YWRjX2luZm8tPnJlc29sdXRpb25zWzBdOwogCiAJZm9yIChpID0gMDsgaSA8IGFk Yy0+Y2ZnLT5hZGNfaW5mby0+bnVtX3JlczsgaSsrKQpAQCAtMTg2NywxMSArMTg2NywxMSBAQCBz dGF0aWMgdm9pZCBzdG0zMl9hZGNfY2hhbl9pbml0X29uZShzdHJ1Y3QgaWlvX2RldiAqaW5kaW9f ZGV2LAogCiBzdGF0aWMgaW50IHN0bTMyX2FkY19nZXRfbGVnYWN5X2NoYW5fY291bnQoc3RydWN0 IGlpb19kZXYgKmluZGlvX2Rldiwgc3RydWN0IHN0bTMyX2FkYyAqYWRjKQogewotCXN0cnVjdCBk ZXZpY2Vfbm9kZSAqbm9kZSA9IGluZGlvX2Rldi0+ZGV2Lm9mX25vZGU7CisJc3RydWN0IGRldmlj ZSAqZGV2ID0gJmluZGlvX2Rldi0+ZGV2OwogCWNvbnN0IHN0cnVjdCBzdG0zMl9hZGNfaW5mbyAq YWRjX2luZm8gPSBhZGMtPmNmZy0+YWRjX2luZm87CiAJaW50IG51bV9jaGFubmVscyA9IDAsIHJl dDsKIAotCXJldCA9IG9mX3Byb3BlcnR5X2NvdW50X3UzMl9lbGVtcyhub2RlLCAic3QsYWRjLWNo YW5uZWxzIik7CisJcmV0ID0gZGV2aWNlX3Byb3BlcnR5X2NvdW50X3UzMihkZXYsICJzdCxhZGMt Y2hhbm5lbHMiKTsKIAlpZiAocmV0ID4gYWRjX2luZm8tPm1heF9jaGFubmVscykgewogCQlkZXZf ZXJyKCZpbmRpb19kZXYtPmRldiwgIkJhZCBzdCxhZGMtY2hhbm5lbHM/XG4iKTsKIAkJcmV0dXJu IC1FSU5WQUw7CkBAIC0xODc5LDE4ICsxODc5LDE3IEBAIHN0YXRpYyBpbnQgc3RtMzJfYWRjX2dl dF9sZWdhY3lfY2hhbl9jb3VudChzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LCBzdHJ1Y3Qgc3Rt CiAJCW51bV9jaGFubmVscyArPSByZXQ7CiAJfQogCi0JcmV0ID0gb2ZfcHJvcGVydHlfY291bnRf ZWxlbXNfb2Zfc2l6ZShub2RlLCAic3QsYWRjLWRpZmYtY2hhbm5lbHMiLAotCQkJCQkgICAgICBz aXplb2Yoc3RydWN0IHN0bTMyX2FkY19kaWZmX2NoYW5uZWwpKTsKLQlpZiAocmV0ID4gYWRjX2lu Zm8tPm1heF9jaGFubmVscykgeworCXJldCA9IGRldmljZV9wcm9wZXJ0eV9jb3VudF91MzIoZGV2 LCAic3QsYWRjLWRpZmYtY2hhbm5lbHMiKTsKKwlpZiAoKHJldCAvIDIpID4gYWRjX2luZm8tPm1h eF9jaGFubmVscykgewogCQlkZXZfZXJyKCZpbmRpb19kZXYtPmRldiwgIkJhZCBzdCxhZGMtZGlm Zi1jaGFubmVscz9cbiIpOwogCQlyZXR1cm4gLUVJTlZBTDsKLQl9IGVsc2UgaWYgKHJldCA+IDAp IHsKLQkJYWRjLT5udW1fZGlmZiA9IHJldDsKLQkJbnVtX2NoYW5uZWxzICs9IHJldDsKKwl9IGVs c2UgaWYgKChyZXQgLyAyKSA+IDApIHsKKwkJYWRjLT5udW1fZGlmZiA9IHJldCAvIDI7CisJCW51 bV9jaGFubmVscyArPSByZXQgLyAyOwogCX0KIAogCS8qIE9wdGlvbmFsIHNhbXBsZSB0aW1lIGlz IHByb3ZpZGVkIGVpdGhlciBmb3IgZWFjaCwgb3IgYWxsIGNoYW5uZWxzICovCi0JcmV0ID0gb2Zf cHJvcGVydHlfY291bnRfdTMyX2VsZW1zKG5vZGUsICJzdCxtaW4tc2FtcGxlLXRpbWUtbnNlY3Mi KTsKKwlyZXQgPSBkZXZpY2VfcHJvcGVydHlfY291bnRfdTMyKGRldiwgInN0LG1pbi1zYW1wbGUt dGltZS1uc2VjcyIpOwogCWlmIChyZXQgPiAxICYmIHJldCAhPSBudW1fY2hhbm5lbHMpIHsKIAkJ ZGV2X2VycigmaW5kaW9fZGV2LT5kZXYsICJJbnZhbGlkIHN0LG1pbi1zYW1wbGUtdGltZS1uc2Vj c1xuIik7CiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTkwMSwyMSArMTkwMCwyMCBAQCBzdGF0aWMg aW50IHN0bTMyX2FkY19nZXRfbGVnYWN5X2NoYW5fY291bnQoc3RydWN0IGlpb19kZXYgKmluZGlv X2Rldiwgc3RydWN0IHN0bQogCiBzdGF0aWMgaW50IHN0bTMyX2FkY19sZWdhY3lfY2hhbl9pbml0 KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCiAJCQkJICAgICAgc3RydWN0IHN0bTMyX2FkYyAq YWRjLAotCQkJCSAgICAgIHN0cnVjdCBpaW9fY2hhbl9zcGVjICpjaGFubmVscykKKwkJCQkgICAg ICBzdHJ1Y3QgaWlvX2NoYW5fc3BlYyAqY2hhbm5lbHMsCisJCQkJICAgICAgaW50IG5jaGFucykK IHsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUgPSBpbmRpb19kZXYtPmRldi5vZl9ub2RlOwog CWNvbnN0IHN0cnVjdCBzdG0zMl9hZGNfaW5mbyAqYWRjX2luZm8gPSBhZGMtPmNmZy0+YWRjX2lu Zm87CiAJc3RydWN0IHN0bTMyX2FkY19kaWZmX2NoYW5uZWwgZGlmZltTVE0zMl9BRENfQ0hfTUFY XTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmaW5kaW9fZGV2LT5kZXY7CiAJdTMyIG51bV9kaWZm ID0gYWRjLT5udW1fZGlmZjsKIAlpbnQgc2l6ZSA9IG51bV9kaWZmICogc2l6ZW9mKCpkaWZmKSAv IHNpemVvZih1MzIpOwotCWludCBzY2FuX2luZGV4ID0gMCwgdmFsLCByZXQsIGk7Ci0Jc3RydWN0 IHByb3BlcnR5ICpwcm9wOwotCWNvbnN0IF9fYmUzMiAqY3VyOwotCXUzMiBzbXAgPSAwOworCWlu dCBzY2FuX2luZGV4ID0gMCwgcmV0LCBpOworCXUzMiBzbXAgPSAwLCBuc21wcywgc21wc1tTVE0z Ml9BRENfQ0hfTUFYXSwgY2hhbnNbU1RNMzJfQURDX0NIX01BWF07CiAKIAlpZiAobnVtX2RpZmYp IHsKLQkJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzJfYXJyYXkobm9kZSwgInN0LGFkYy1kaWZm LWNoYW5uZWxzIiwKLQkJCQkJCSAodTMyICopZGlmZiwgc2l6ZSk7CisJCXJldCA9IGRldmljZV9w cm9wZXJ0eV9yZWFkX3UzMl9hcnJheShkZXYsICJzdCxhZGMtZGlmZi1jaGFubmVscyIsCisJCQkJ CQkgICAgICh1MzIgKilkaWZmLCBzaXplKTsKIAkJaWYgKHJldCkgewogCQkJZGV2X2VycigmaW5k aW9fZGV2LT5kZXYsICJGYWlsZWQgdG8gZ2V0IGRpZmYgY2hhbm5lbHMgJWRcbiIsIHJldCk7CiAJ CQlyZXR1cm4gcmV0OwpAQCAtMTkzNiwzMiArMTkzNCw1MSBAQCBzdGF0aWMgaW50IHN0bTMyX2Fk Y19sZWdhY3lfY2hhbl9pbml0KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCiAJCX0KIAl9CiAK LQlvZl9wcm9wZXJ0eV9mb3JfZWFjaF91MzIobm9kZSwgInN0LGFkYy1jaGFubmVscyIsIHByb3As IGN1ciwgdmFsKSB7Ci0JCWlmICh2YWwgPj0gYWRjX2luZm8tPm1heF9jaGFubmVscykgewotCQkJ ZGV2X2VycigmaW5kaW9fZGV2LT5kZXYsICJJbnZhbGlkIGNoYW5uZWwgJWRcbiIsIHZhbCk7CisJ cmV0ID0gZGV2aWNlX3Byb3BlcnR5X3JlYWRfdTMyX2FycmF5KGRldiwgInN0LGFkYy1jaGFubmVs cyIsIGNoYW5zLAorCQkJCQkgICAgIG5jaGFucyk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsK KworCWZvciAoaSA9IDA7IGkgPCBuY2hhbnM7IGkrKykgeworCQlpZiAoY2hhbnNbaV0gPj0gYWRj X2luZm8tPm1heF9jaGFubmVscykgeworCQkJZGV2X2VycigmaW5kaW9fZGV2LT5kZXYsICJJbnZh bGlkIGNoYW5uZWwgJWRcbiIsCisJCQkJY2hhbnNbaV0pOwogCQkJcmV0dXJuIC1FSU5WQUw7CiAJ CX0KIAogCQkvKiBDaGFubmVsIGNhbid0IGJlIGNvbmZpZ3VyZWQgYm90aCBhcyBzaW5nbGUtZW5k ZWQgJiBkaWZmICovCiAJCWZvciAoaSA9IDA7IGkgPCBudW1fZGlmZjsgaSsrKSB7Ci0JCQlpZiAo dmFsID09IGRpZmZbaV0udmlucCkgewotCQkJCWRldl9lcnIoJmluZGlvX2Rldi0+ZGV2LCAiY2hh bm5lbCAlZCBtaXNjb25maWd1cmVkXG4iLAl2YWwpOworCQkJaWYgKGNoYW5zW2ldID09IGRpZmZb aV0udmlucCkgeworCQkJCWRldl9lcnIoJmluZGlvX2Rldi0+ZGV2LCAiY2hhbm5lbCAlZCBtaXNj b25maWd1cmVkXG4iLAljaGFuc1tpXSk7CiAJCQkJcmV0dXJuIC1FSU5WQUw7CiAJCQl9CiAJCX0K LQkJc3RtMzJfYWRjX2NoYW5faW5pdF9vbmUoaW5kaW9fZGV2LCAmY2hhbm5lbHNbc2Nhbl9pbmRl eF0sIHZhbCwKLQkJCQkJMCwgc2Nhbl9pbmRleCwgZmFsc2UpOworCQlzdG0zMl9hZGNfY2hhbl9p bml0X29uZShpbmRpb19kZXYsICZjaGFubmVsc1tzY2FuX2luZGV4XSwKKwkJCQkJY2hhbnNbaV0s IDAsIHNjYW5faW5kZXgsIGZhbHNlKTsKIAkJc2Nhbl9pbmRleCsrOwogCX0KIAorCW5zbXBzID0g ZGV2aWNlX3Byb3BlcnR5X2NvdW50X3UzMihkZXYsICJzdCxtaW4tc2FtcGxlLXRpbWUtbnNlY3Mi KTsKKwlpZiAobnNtcHMpIHsKKwkJaWYgKG5zbXBzID49IG5jaGFucykKKwkJCW5zbXBzID0gbmNo YW5zOworCisJCXJldCA9IGRldmljZV9wcm9wZXJ0eV9yZWFkX3UzMl9hcnJheShkZXYsICJzdCxt aW4tc2FtcGxlLXRpbWUtbnNlY3MiLAorCQkJCQkJICAgICBzbXBzLCBuc21wcyk7CisJCWlmIChy ZXQpCisJCQlyZXR1cm4gcmV0OworCX0KKwogCWZvciAoaSA9IDA7IGkgPCBzY2FuX2luZGV4OyBp KyspIHsKIAkJLyoKLQkJICogVXNpbmcgb2ZfcHJvcGVydHlfcmVhZF91MzJfaW5kZXgoKSwgc21w IHZhbHVlIHdpbGwgb25seSBiZQotCQkgKiBtb2RpZmllZCBpZiB2YWxpZCB1MzIgdmFsdWUgY2Fu IGJlIGRlY29kZWQuIFRoaXMgYWxsb3dzIHRvCi0JCSAqIGdldCBlaXRoZXIgbm8gdmFsdWUsIDEg c2hhcmVkIHZhbHVlIGZvciBhbGwgaW5kZXhlcywgb3Igb25lCi0JCSAqIHZhbHVlIHBlciBjaGFu bmVsLgorCQkgKiBUaGlzIGNoZWNrIGlzIHVzZWQgd2l0aCB0aGUgYWJvdmUgbG9naWMgc28gdGhh dCBzbXAgdmFsdWUKKwkJICogd2lsbCBvbmx5IGJlIG1vZGlmaWVkIGlmIHZhbGlkIHUzMiB2YWx1 ZSBjYW4gYmUgZGVjb2RlZC4gVGhpcworCQkgKiBhbGxvd3MgdG8gZ2V0IGVpdGhlciBubyB2YWx1 ZSwgMSBzaGFyZWQgdmFsdWUgZm9yIGFsbCBpbmRleGVzLAorCQkgKiBvciBvbmUgdmFsdWUgcGVy IGNoYW5uZWwuIFRoZSBwb2ludCBpcyB0byBoYXZlIHRoZSBzYW1lCisJCSAqIGJlaGF2aW9yIGFz ICdvZl9wcm9wZXJ0eV9yZWFkX3UzMl9pbmRleCgpJy4KIAkJICovCi0JCW9mX3Byb3BlcnR5X3Jl YWRfdTMyX2luZGV4KG5vZGUsICJzdCxtaW4tc2FtcGxlLXRpbWUtbnNlY3MiLCBpLCAmc21wKTsK KwkJaWYgKGkgPCBuc21wcykKKwkJCXNtcCA9IHNtcHNbaV07CiAKIAkJLyogUHJlcGFyZSBzYW1w bGluZyB0aW1lIHNldHRpbmdzICovCiAJCXN0bTMyX2FkY19zbXByX2luaXQoYWRjLCBjaGFubmVs c1tpXS5jaGFubmVsLCBzbXApOwpAQCAtMjAwNCwyMiArMjAyMSwyMSBAQCBzdGF0aWMgaW50IHN0 bTMyX2FkY19nZW5lcmljX2NoYW5faW5pdChzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LAogCQkJ CSAgICAgICBzdHJ1Y3Qgc3RtMzJfYWRjICphZGMsCiAJCQkJICAgICAgIHN0cnVjdCBpaW9fY2hh bl9zcGVjICpjaGFubmVscykKIHsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUgPSBpbmRpb19k ZXYtPmRldi5vZl9ub2RlOwogCWNvbnN0IHN0cnVjdCBzdG0zMl9hZGNfaW5mbyAqYWRjX2luZm8g PSBhZGMtPmNmZy0+YWRjX2luZm87Ci0Jc3RydWN0IGRldmljZV9ub2RlICpjaGlsZDsKKwlzdHJ1 Y3QgZndub2RlX2hhbmRsZSAqY2hpbGQ7CiAJY29uc3QgY2hhciAqbmFtZTsKIAlpbnQgdmFsLCBz Y2FuX2luZGV4ID0gMCwgcmV0OwogCWJvb2wgZGlmZmVyZW50aWFsOwogCXUzMiB2aW5bMl07CiAK LQlmb3JfZWFjaF9hdmFpbGFibGVfY2hpbGRfb2Zfbm9kZShub2RlLCBjaGlsZCkgewotCQlyZXQg PSBvZl9wcm9wZXJ0eV9yZWFkX3UzMihjaGlsZCwgInJlZyIsICZ2YWwpOworCWRldmljZV9mb3Jf ZWFjaF9jaGlsZF9ub2RlKCZpbmRpb19kZXYtPmRldiwgY2hpbGQpIHsKKwkJcmV0ID0gZndub2Rl X3Byb3BlcnR5X3JlYWRfdTMyKGNoaWxkLCAicmVnIiwgJnZhbCk7CiAJCWlmIChyZXQpIHsKIAkJ CWRldl9lcnIoJmluZGlvX2Rldi0+ZGV2LCAiTWlzc2luZyBjaGFubmVsIGluZGV4ICVkXG4iLCBy ZXQpOwogCQkJZ290byBlcnI7CiAJCX0KIAotCQlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3N0cmlu ZyhjaGlsZCwgImxhYmVsIiwgJm5hbWUpOworCQlyZXQgPSBmd25vZGVfcHJvcGVydHlfcmVhZF9z dHJpbmcoY2hpbGQsICJsYWJlbCIsICZuYW1lKTsKIAkJLyogbGFiZWwgaXMgb3B0aW9uYWwgKi8K IAkJaWYgKCFyZXQpIHsKIAkJCWlmIChzdHJsZW4obmFtZSkgPj0gU1RNMzJfQURDX0NIX1NaKSB7 CkBAIC0yMDQ0LDcgKzIwNjAsNyBAQCBzdGF0aWMgaW50IHN0bTMyX2FkY19nZW5lcmljX2NoYW5f aW5pdChzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LAogCQl9CiAKIAkJZGlmZmVyZW50aWFsID0g ZmFsc2U7Ci0JCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyX2FycmF5KGNoaWxkLCAiZGlmZi1j aGFubmVscyIsIHZpbiwgMik7CisJCXJldCA9IGZ3bm9kZV9wcm9wZXJ0eV9yZWFkX3UzMl9hcnJh eShjaGlsZCwgImRpZmYtY2hhbm5lbHMiLCB2aW4sIDIpOwogCQkvKiBkaWZmLWNoYW5uZWxzIGlz IG9wdGlvbmFsICovCiAJCWlmICghcmV0KSB7CiAJCQlkaWZmZXJlbnRpYWwgPSB0cnVlOwpAQCAt MjA2MSw3ICsyMDc3LDcgQEAgc3RhdGljIGludCBzdG0zMl9hZGNfZ2VuZXJpY19jaGFuX2luaXQo c3RydWN0IGlpb19kZXYgKmluZGlvX2RldiwKIAkJc3RtMzJfYWRjX2NoYW5faW5pdF9vbmUoaW5k aW9fZGV2LCAmY2hhbm5lbHNbc2Nhbl9pbmRleF0sIHZhbCwKIAkJCQkJdmluWzFdLCBzY2FuX2lu ZGV4LCBkaWZmZXJlbnRpYWwpOwogCi0JCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKGNoaWxk LCAic3QsbWluLXNhbXBsZS10aW1lLW5zIiwgJnZhbCk7CisJCXJldCA9IGZ3bm9kZV9wcm9wZXJ0 eV9yZWFkX3UzMihjaGlsZCwgInN0LG1pbi1zYW1wbGUtdGltZS1ucyIsICZ2YWwpOwogCQkvKiBz dCxtaW4tc2FtcGxlLXRpbWUtbnMgaXMgb3B0aW9uYWwgKi8KIAkJaWYgKCFyZXQpIHsKIAkJCXN0 bTMyX2FkY19zbXByX2luaXQoYWRjLCBjaGFubmVsc1tzY2FuX2luZGV4XS5jaGFubmVsLCB2YWwp OwpAQCAtMjA3OSwxNCArMjA5NSwxMyBAQCBzdGF0aWMgaW50IHN0bTMyX2FkY19nZW5lcmljX2No YW5faW5pdChzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LAogCXJldHVybiBzY2FuX2luZGV4Owog CiBlcnI6Ci0Jb2Zfbm9kZV9wdXQoY2hpbGQpOworCWZ3bm9kZV9oYW5kbGVfcHV0KGNoaWxkKTsK IAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBpbnQgc3RtMzJfYWRjX2NoYW5fb2ZfaW5pdChz dHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LCBib29sIHRpbWVzdGFtcGluZykKK3N0YXRpYyBpbnQg c3RtMzJfYWRjX2NoYW5fZndfaW5pdChzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LCBib29sIHRp bWVzdGFtcGluZykKIHsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUgPSBpbmRpb19kZXYtPmRl di5vZl9ub2RlOwogCXN0cnVjdCBzdG0zMl9hZGMgKmFkYyA9IGlpb19wcml2KGluZGlvX2Rldik7 CiAJY29uc3Qgc3RydWN0IHN0bTMyX2FkY19pbmZvICphZGNfaW5mbyA9IGFkYy0+Y2ZnLT5hZGNf aW5mbzsKIAlzdHJ1Y3QgaWlvX2NoYW5fc3BlYyAqY2hhbm5lbHM7CkBAIC0yMDk2LDcgKzIxMTEs NyBAQCBzdGF0aWMgaW50IHN0bTMyX2FkY19jaGFuX29mX2luaXQoc3RydWN0IGlpb19kZXYgKmlu ZGlvX2RldiwgYm9vbCB0aW1lc3RhbXBpbmcpCiAJZm9yIChpID0gMDsgaSA8IFNUTTMyX0FEQ19J TlRfQ0hfTkI7IGkrKykKIAkJYWRjLT5pbnRfY2hbaV0gPSBTVE0zMl9BRENfSU5UX0NIX05PTkU7 CiAKLQludW1fY2hhbm5lbHMgPSBvZl9nZXRfYXZhaWxhYmxlX2NoaWxkX2NvdW50KG5vZGUpOwor CW51bV9jaGFubmVscyA9IGRldmljZV9nZXRfY2hpbGRfbm9kZV9jb3VudCgmaW5kaW9fZGV2LT5k ZXYpOwogCS8qIElmIG5vIGNoYW5uZWxzIGhhdmUgYmVlbiBmb3VuZCwgZmFsbGJhY2sgdG8gY2hh bm5lbHMgbGVnYWN5IHByb3BlcnRpZXMuICovCiAJaWYgKCFudW1fY2hhbm5lbHMpIHsKIAkJbGVn YWN5ID0gdHJ1ZTsKQEAgLTIxMjcsNyArMjE0Miw4IEBAIHN0YXRpYyBpbnQgc3RtMzJfYWRjX2No YW5fb2ZfaW5pdChzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LCBib29sIHRpbWVzdGFtcGluZykK IAkJcmV0dXJuIC1FTk9NRU07CiAKIAlpZiAobGVnYWN5KQotCQlyZXQgPSBzdG0zMl9hZGNfbGVn YWN5X2NoYW5faW5pdChpbmRpb19kZXYsIGFkYywgY2hhbm5lbHMpOworCQlyZXQgPSBzdG0zMl9h ZGNfbGVnYWN5X2NoYW5faW5pdChpbmRpb19kZXYsIGFkYywgY2hhbm5lbHMsCisJCQkJCQkgbnVt X2NoYW5uZWxzKTsKIAllbHNlCiAJCXJldCA9IHN0bTMyX2FkY19nZW5lcmljX2NoYW5faW5pdChp bmRpb19kZXYsIGFkYywgY2hhbm5lbHMpOwogCWlmIChyZXQgPCAwKQpAQCAtMjIwOSw5ICsyMjI1 LDYgQEAgc3RhdGljIGludCBzdG0zMl9hZGNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq cGRldikKIAlib29sIHRpbWVzdGFtcGluZyA9IGZhbHNlOwogCWludCByZXQ7CiAKLQlpZiAoIXBk ZXYtPmRldi5vZl9ub2RlKQotCQlyZXR1cm4gLUVOT0RFVjsKLQogCWluZGlvX2RldiA9IGRldm1f aWlvX2RldmljZV9hbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmFkYykpOwogCWlmICghaW5kaW9f ZGV2KQogCQlyZXR1cm4gLUVOT01FTTsKQEAgLTIyMjAsMTcgKzIyMzMsMTYgQEAgc3RhdGljIGlu dCBzdG0zMl9hZGNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlhZGMtPmNv bW1vbiA9IGRldl9nZXRfZHJ2ZGF0YShwZGV2LT5kZXYucGFyZW50KTsKIAlzcGluX2xvY2tfaW5p dCgmYWRjLT5sb2NrKTsKIAlpbml0X2NvbXBsZXRpb24oJmFkYy0+Y29tcGxldGlvbik7Ci0JYWRj LT5jZmcgPSAoY29uc3Qgc3RydWN0IHN0bTMyX2FkY19jZmcgKikKLQkJb2ZfbWF0Y2hfZGV2aWNl KGRldi0+ZHJpdmVyLT5vZl9tYXRjaF90YWJsZSwgZGV2KS0+ZGF0YTsKKwlhZGMtPmNmZyA9IGRl dmljZV9nZXRfbWF0Y2hfZGF0YShkZXYpOwogCiAJaW5kaW9fZGV2LT5uYW1lID0gZGV2X25hbWUo JnBkZXYtPmRldik7Ci0JaW5kaW9fZGV2LT5kZXYub2Zfbm9kZSA9IHBkZXYtPmRldi5vZl9ub2Rl OworCWRldmljZV9zZXRfbm9kZSgmaW5kaW9fZGV2LT5kZXYsIGRldl9md25vZGUoJnBkZXYtPmRl dikpOwogCWluZGlvX2Rldi0+aW5mbyA9ICZzdG0zMl9hZGNfaWlvX2luZm87CiAJaW5kaW9fZGV2 LT5tb2RlcyA9IElORElPX0RJUkVDVF9NT0RFIHwgSU5ESU9fSEFSRFdBUkVfVFJJR0dFUkVEOwog CiAJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaW5kaW9fZGV2KTsKIAotCXJldCA9IG9mX3By b3BlcnR5X3JlYWRfdTMyKHBkZXYtPmRldi5vZl9ub2RlLCAicmVnIiwgJmFkYy0+b2Zmc2V0KTsK KwlyZXQgPSBkZXZpY2VfcHJvcGVydHlfcmVhZF91MzIoZGV2LCAicmVnIiwgJmFkYy0+b2Zmc2V0 KTsKIAlpZiAocmV0ICE9IDApIHsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAibWlzc2luZyByZWcg cHJvcGVydHlcbiIpOwogCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTIyNTksNyArMjI3MSw3IEBAIHN0 YXRpYyBpbnQgc3RtMzJfYWRjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJ CX0KIAl9CiAKLQlyZXQgPSBzdG0zMl9hZGNfb2ZfZ2V0X3Jlc29sdXRpb24oaW5kaW9fZGV2KTsK KwlyZXQgPSBzdG0zMl9hZGNfZndfZ2V0X3Jlc29sdXRpb24oaW5kaW9fZGV2KTsKIAlpZiAocmV0 IDwgMCkKIAkJcmV0dXJuIHJldDsKIApAQCAtMjI3Niw3ICsyMjg4LDcgQEAgc3RhdGljIGludCBz dG0zMl9hZGNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJdGltZXN0YW1w aW5nID0gdHJ1ZTsKIAl9CiAKLQlyZXQgPSBzdG0zMl9hZGNfY2hhbl9vZl9pbml0KGluZGlvX2Rl diwgdGltZXN0YW1waW5nKTsKKwlyZXQgPSBzdG0zMl9hZGNfY2hhbl9md19pbml0KGluZGlvX2Rl diwgdGltZXN0YW1waW5nKTsKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnJfZG1hX2Rpc2FibGU7 CiAKLS0gCjIuMzYuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCkxpbnV4LW1lZGlhdGVrIG1haWxpbmcgbGlzdApMaW51eC1tZWRpYXRla0BsaXN0cy5p bmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8v bGludXgtbWVkaWF0ZWsK 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 9FB72C43334 for ; Thu, 16 Jun 2022 02:16:37 +0000 (UTC) Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4LNm501DQKz3fBL for ; Thu, 16 Jun 2022 12:16:36 +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 4LKF5J0WMZz3btV for ; Fri, 10 Jun 2022 18:49:39 +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 25A7SjCp005350; Fri, 10 Jun 2022 04:49:13 -0400 Received: from nwd2mta3.analog.com ([137.71.173.56]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 3ghq33kqem-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 10 Jun 2022 04:49:13 -0400 Received: from ASHBMBX9.ad.analog.com (ASHBMBX9.ad.analog.com [10.64.17.10]) by nwd2mta3.analog.com (8.14.7/8.14.7) with ESMTP id 25A8nCMi023344 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 10 Jun 2022 04:49:12 -0400 Received: from ASHBMBX8.ad.analog.com (10.64.17.5) by ASHBMBX9.ad.analog.com (10.64.17.10) 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:49:11 -0400 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server id 15.2.986.14 via Frontend Transport; Fri, 10 Jun 2022 04:49:08 -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 25A8imis014275; Fri, 10 Jun 2022 04:48:57 -0400 From: =?UTF-8?q?Nuno=20S=C3=A1?= To: , , , , , Lad Prabhakar , , , , , Subject: [PATCH 32/34] iio: adc: stm32-adc: convert to device properties Date: Fri, 10 Jun 2022 10:45:43 +0200 Message-ID: <20220610084545.547700-33-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: _T5ULNt7aIz7kEBK-I7icaSifMJ0z1zY X-Proofpoint-GUID: _T5ULNt7aIz7kEBK-I7icaSifMJ0z1zY 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-2206100032 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" Make the conversion to firmware agnostic device properties. As part of the conversion the IIO inkern interface 'of_xlate()' is also converted to 'fwnode_xlate()'. The goal is to completely drop 'of_xlate' and hence OF dependencies from IIO. Signed-off-by: Nuno Sá --- drivers/iio/adc/stm32-adc.c | 128 ++++++++++++++++++++---------------- 1 file changed, 70 insertions(+), 58 deletions(-) diff --git a/drivers/iio/adc/stm32-adc.c b/drivers/iio/adc/stm32-adc.c index a68ecbda6480..87acef31ace1 100644 --- a/drivers/iio/adc/stm32-adc.c +++ b/drivers/iio/adc/stm32-adc.c @@ -21,11 +21,11 @@ #include #include #include +#include #include #include #include -#include -#include +#include #include "stm32-adc-core.h" @@ -1524,8 +1524,8 @@ static int stm32_adc_update_scan_mode(struct iio_dev *indio_dev, return ret; } -static int stm32_adc_of_xlate(struct iio_dev *indio_dev, - const struct of_phandle_args *iiospec) +static int stm32_adc_fwnode_xlate(struct iio_dev *indio_dev, + const struct fwnode_reference_args *iiospec) { int i; @@ -1579,7 +1579,7 @@ static const struct iio_info stm32_adc_iio_info = { .hwfifo_set_watermark = stm32_adc_set_watermark, .update_scan_mode = stm32_adc_update_scan_mode, .debugfs_reg_access = stm32_adc_debugfs_reg_access, - .of_xlate = stm32_adc_of_xlate, + .fwnode_xlate = stm32_adc_fwnode_xlate, }; static unsigned int stm32_adc_dma_residue(struct stm32_adc *adc) @@ -1776,14 +1776,14 @@ static const struct iio_chan_spec_ext_info stm32_adc_ext_info[] = { {}, }; -static int stm32_adc_of_get_resolution(struct iio_dev *indio_dev) +static int stm32_adc_fw_get_resolution(struct iio_dev *indio_dev) { - struct device_node *node = indio_dev->dev.of_node; + struct device *dev = &indio_dev->dev; struct stm32_adc *adc = iio_priv(indio_dev); unsigned int i; u32 res; - if (of_property_read_u32(node, "assigned-resolution-bits", &res)) + if (device_property_read_u32(dev, "assigned-resolution-bits", &res)) res = adc->cfg->adc_info->resolutions[0]; for (i = 0; i < adc->cfg->adc_info->num_res; i++) @@ -1867,11 +1867,11 @@ static void stm32_adc_chan_init_one(struct iio_dev *indio_dev, static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm32_adc *adc) { - struct device_node *node = indio_dev->dev.of_node; + struct device *dev = &indio_dev->dev; const struct stm32_adc_info *adc_info = adc->cfg->adc_info; int num_channels = 0, ret; - ret = of_property_count_u32_elems(node, "st,adc-channels"); + ret = device_property_count_u32(dev, "st,adc-channels"); if (ret > adc_info->max_channels) { dev_err(&indio_dev->dev, "Bad st,adc-channels?\n"); return -EINVAL; @@ -1879,18 +1879,17 @@ static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm num_channels += ret; } - ret = of_property_count_elems_of_size(node, "st,adc-diff-channels", - sizeof(struct stm32_adc_diff_channel)); - if (ret > adc_info->max_channels) { + ret = device_property_count_u32(dev, "st,adc-diff-channels"); + if ((ret / 2) > adc_info->max_channels) { dev_err(&indio_dev->dev, "Bad st,adc-diff-channels?\n"); return -EINVAL; - } else if (ret > 0) { - adc->num_diff = ret; - num_channels += ret; + } else if ((ret / 2) > 0) { + adc->num_diff = ret / 2; + num_channels += ret / 2; } /* Optional sample time is provided either for each, or all channels */ - ret = of_property_count_u32_elems(node, "st,min-sample-time-nsecs"); + ret = device_property_count_u32(dev, "st,min-sample-time-nsecs"); if (ret > 1 && ret != num_channels) { dev_err(&indio_dev->dev, "Invalid st,min-sample-time-nsecs\n"); return -EINVAL; @@ -1901,21 +1900,20 @@ static int stm32_adc_get_legacy_chan_count(struct iio_dev *indio_dev, struct stm static int stm32_adc_legacy_chan_init(struct iio_dev *indio_dev, struct stm32_adc *adc, - struct iio_chan_spec *channels) + struct iio_chan_spec *channels, + int nchans) { - struct device_node *node = indio_dev->dev.of_node; const struct stm32_adc_info *adc_info = adc->cfg->adc_info; struct stm32_adc_diff_channel diff[STM32_ADC_CH_MAX]; + struct device *dev = &indio_dev->dev; u32 num_diff = adc->num_diff; int size = num_diff * sizeof(*diff) / sizeof(u32); - int scan_index = 0, val, ret, i; - struct property *prop; - const __be32 *cur; - u32 smp = 0; + int scan_index = 0, ret, i; + u32 smp = 0, nsmps, smps[STM32_ADC_CH_MAX], chans[STM32_ADC_CH_MAX]; if (num_diff) { - ret = of_property_read_u32_array(node, "st,adc-diff-channels", - (u32 *)diff, size); + ret = device_property_read_u32_array(dev, "st,adc-diff-channels", + (u32 *)diff, size); if (ret) { dev_err(&indio_dev->dev, "Failed to get diff channels %d\n", ret); return ret; @@ -1936,32 +1934,51 @@ static int stm32_adc_legacy_chan_init(struct iio_dev *indio_dev, } } - of_property_for_each_u32(node, "st,adc-channels", prop, cur, val) { - if (val >= adc_info->max_channels) { - dev_err(&indio_dev->dev, "Invalid channel %d\n", val); + ret = device_property_read_u32_array(dev, "st,adc-channels", chans, + nchans); + if (ret) + return ret; + + for (i = 0; i < nchans; i++) { + if (chans[i] >= adc_info->max_channels) { + dev_err(&indio_dev->dev, "Invalid channel %d\n", + chans[i]); return -EINVAL; } /* Channel can't be configured both as single-ended & diff */ for (i = 0; i < num_diff; i++) { - if (val == diff[i].vinp) { - dev_err(&indio_dev->dev, "channel %d misconfigured\n", val); + if (chans[i] == diff[i].vinp) { + dev_err(&indio_dev->dev, "channel %d misconfigured\n", chans[i]); return -EINVAL; } } - stm32_adc_chan_init_one(indio_dev, &channels[scan_index], val, - 0, scan_index, false); + stm32_adc_chan_init_one(indio_dev, &channels[scan_index], + chans[i], 0, scan_index, false); scan_index++; } + nsmps = device_property_count_u32(dev, "st,min-sample-time-nsecs"); + if (nsmps) { + if (nsmps >= nchans) + nsmps = nchans; + + ret = device_property_read_u32_array(dev, "st,min-sample-time-nsecs", + smps, nsmps); + if (ret) + return ret; + } + for (i = 0; i < scan_index; i++) { /* - * Using of_property_read_u32_index(), smp value will only be - * modified if valid u32 value can be decoded. This allows to - * get either no value, 1 shared value for all indexes, or one - * value per channel. + * This check is used with the above logic so that smp value + * will only be modified if valid u32 value can be decoded. This + * allows to get either no value, 1 shared value for all indexes, + * or one value per channel. The point is to have the same + * behavior as 'of_property_read_u32_index()'. */ - of_property_read_u32_index(node, "st,min-sample-time-nsecs", i, &smp); + if (i < nsmps) + smp = smps[i]; /* Prepare sampling time settings */ stm32_adc_smpr_init(adc, channels[i].channel, smp); @@ -2004,22 +2021,21 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, struct stm32_adc *adc, struct iio_chan_spec *channels) { - struct device_node *node = indio_dev->dev.of_node; const struct stm32_adc_info *adc_info = adc->cfg->adc_info; - struct device_node *child; + struct fwnode_handle *child; const char *name; int val, scan_index = 0, ret; bool differential; u32 vin[2]; - for_each_available_child_of_node(node, child) { - ret = of_property_read_u32(child, "reg", &val); + device_for_each_child_node(&indio_dev->dev, child) { + ret = fwnode_property_read_u32(child, "reg", &val); if (ret) { dev_err(&indio_dev->dev, "Missing channel index %d\n", ret); goto err; } - ret = of_property_read_string(child, "label", &name); + ret = fwnode_property_read_string(child, "label", &name); /* label is optional */ if (!ret) { if (strlen(name) >= STM32_ADC_CH_SZ) { @@ -2044,7 +2060,7 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, } differential = false; - ret = of_property_read_u32_array(child, "diff-channels", vin, 2); + ret = fwnode_property_read_u32_array(child, "diff-channels", vin, 2); /* diff-channels is optional */ if (!ret) { differential = true; @@ -2061,7 +2077,7 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, stm32_adc_chan_init_one(indio_dev, &channels[scan_index], val, vin[1], scan_index, differential); - ret = of_property_read_u32(child, "st,min-sample-time-ns", &val); + ret = fwnode_property_read_u32(child, "st,min-sample-time-ns", &val); /* st,min-sample-time-ns is optional */ if (!ret) { stm32_adc_smpr_init(adc, channels[scan_index].channel, val); @@ -2079,14 +2095,13 @@ static int stm32_adc_generic_chan_init(struct iio_dev *indio_dev, return scan_index; err: - of_node_put(child); + fwnode_handle_put(child); return ret; } -static int stm32_adc_chan_of_init(struct iio_dev *indio_dev, bool timestamping) +static int stm32_adc_chan_fw_init(struct iio_dev *indio_dev, bool timestamping) { - struct device_node *node = indio_dev->dev.of_node; struct stm32_adc *adc = iio_priv(indio_dev); const struct stm32_adc_info *adc_info = adc->cfg->adc_info; struct iio_chan_spec *channels; @@ -2096,7 +2111,7 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev, bool timestamping) for (i = 0; i < STM32_ADC_INT_CH_NB; i++) adc->int_ch[i] = STM32_ADC_INT_CH_NONE; - num_channels = of_get_available_child_count(node); + num_channels = device_get_child_node_count(&indio_dev->dev); /* If no channels have been found, fallback to channels legacy properties. */ if (!num_channels) { legacy = true; @@ -2127,7 +2142,8 @@ static int stm32_adc_chan_of_init(struct iio_dev *indio_dev, bool timestamping) return -ENOMEM; if (legacy) - ret = stm32_adc_legacy_chan_init(indio_dev, adc, channels); + ret = stm32_adc_legacy_chan_init(indio_dev, adc, channels, + num_channels); else ret = stm32_adc_generic_chan_init(indio_dev, adc, channels); if (ret < 0) @@ -2209,9 +2225,6 @@ static int stm32_adc_probe(struct platform_device *pdev) bool timestamping = false; int ret; - if (!pdev->dev.of_node) - return -ENODEV; - indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc)); if (!indio_dev) return -ENOMEM; @@ -2220,17 +2233,16 @@ static int stm32_adc_probe(struct platform_device *pdev) adc->common = dev_get_drvdata(pdev->dev.parent); spin_lock_init(&adc->lock); init_completion(&adc->completion); - adc->cfg = (const struct stm32_adc_cfg *) - of_match_device(dev->driver->of_match_table, dev)->data; + adc->cfg = device_get_match_data(dev); indio_dev->name = dev_name(&pdev->dev); - indio_dev->dev.of_node = pdev->dev.of_node; + device_set_node(&indio_dev->dev, dev_fwnode(&pdev->dev)); indio_dev->info = &stm32_adc_iio_info; indio_dev->modes = INDIO_DIRECT_MODE | INDIO_HARDWARE_TRIGGERED; platform_set_drvdata(pdev, indio_dev); - ret = of_property_read_u32(pdev->dev.of_node, "reg", &adc->offset); + ret = device_property_read_u32(dev, "reg", &adc->offset); if (ret != 0) { dev_err(&pdev->dev, "missing reg property\n"); return -EINVAL; @@ -2259,7 +2271,7 @@ static int stm32_adc_probe(struct platform_device *pdev) } } - ret = stm32_adc_of_get_resolution(indio_dev); + ret = stm32_adc_fw_get_resolution(indio_dev); if (ret < 0) return ret; @@ -2276,7 +2288,7 @@ static int stm32_adc_probe(struct platform_device *pdev) timestamping = true; } - ret = stm32_adc_chan_of_init(indio_dev, timestamping); + ret = stm32_adc_chan_fw_init(indio_dev, timestamping); if (ret < 0) goto err_dma_disable; -- 2.36.1