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 X-Spam-Level: X-Spam-Status: No, score=-8.4 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 70938C11D25 for ; Thu, 20 Feb 2020 22:13:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 44AB720801 for ; Thu, 20 Feb 2020 22:13:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="zQF06bXC" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727656AbgBTWNn (ORCPT ); Thu, 20 Feb 2020 17:13:43 -0500 Received: from mail-wm1-f65.google.com ([209.85.128.65]:40153 "EHLO mail-wm1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727790AbgBTWNn (ORCPT ); Thu, 20 Feb 2020 17:13:43 -0500 Received: by mail-wm1-f65.google.com with SMTP id t14so195340wmi.5 for ; Thu, 20 Feb 2020 14:13:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=jUfFdw2Zfk6+TsIEq3Y3zBZt8xh6o4BAYFw0Cy9piao=; b=zQF06bXCl/IGUk7BYlnpWi1JiaBtl7fo/6WBweQAl6ueyW0Jrr/sfglRUq2YLP+zzO q1b3rjcbVr0+qgm5GYT+kEKC2fYb8ibYIw0kQ/3RNQ+eBE/19l+62xcnsGxBdLG7CWJK QdDuHZNN4+xGYMuep9JOqG4pNYLaYr0x5yoI9vkkQGiN0twvDsK4ag1iL3dzbgsYBQB3 ASdK2HHYHGnJgcJ6KzylGKiwEv9cO4uXKx1M/4lZkCmllsYLH52L/4DdOWxYmOYxwdyD Eh62ASONNhc0enAOnjM1KIcF3dbUhuJFtZML1dTdaFKaCySRJTzitX1THz7aSaEqwBHv IjoQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=jUfFdw2Zfk6+TsIEq3Y3zBZt8xh6o4BAYFw0Cy9piao=; b=NRgq9xJvCqV8/c6C54ewG+0Du7idphT9xdAw8wuCn3yt+mHKgrfFIyjWhrbXPG9cgD 7q42G6Jc5hei5IRpC0kK5qVV1UBFCunowm62KQY6zjqmmYTMHBdUBic/MemRvmlm7tgL V4lr7KcO3W1ovUSZDsxZHBnE/e9yGOAL+pcjR1Qy9JSkNO+ofgT9O7pkWevtynVPT4Fx WsVPspdBq3kuwRwxGZ8OzUyTWgPssjK7YeKhTjYQPrddg3OgcY3i4+1pwn/CVMWZc+na enfUfStQWQLSE7hqw+4eFYydWNTqxdJKUbctxf+kJEKRzUDKZdLgcg/B+FTXGgqHEO/6 13VQ== X-Gm-Message-State: APjAAAXk0lOYfbEmovtVb/lt0gZUBd9DAWZLoft43x012EDk9ERwhfeM nqBtKr032Obo33MsmGrI52PeFw== X-Google-Smtp-Source: APXvYqwJ0m2BHYbBrNyBeCq8AfsLhyTtxU2RR8idQnaC4wf/hphDZP56noO66Bh678igOeXTb1GQQQ== X-Received: by 2002:a05:600c:21c5:: with SMTP id x5mr6791923wmj.72.1582236819746; Thu, 20 Feb 2020 14:13:39 -0800 (PST) Received: from linaro.org ([2a01:e34:ed2f:f020:2dfb:b5ce:9043:4adb]) by smtp.gmail.com with ESMTPSA id d204sm868990wmd.30.2020.02.20.14.13.37 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Thu, 20 Feb 2020 14:13:39 -0800 (PST) Date: Thu, 20 Feb 2020 23:13:34 +0100 From: Daniel Lezcano To: Keerthy Cc: rui.zhang@intel.com, robh+dt@kernel.org, amit.kucheria@verdurent.com, t-kristo@ti.com, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-pm@vger.kernel.org, mark.rutland@arm.com Subject: Re: [PATCH 2/4] thermal: k3: Add support for bandgap sensors Message-ID: <20200220221334.GA7119@linaro.org> References: <20200213102440.20539-1-j-keerthy@ti.com> <20200213102440.20539-3-j-keerthy@ti.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20200213102440.20539-3-j-keerthy@ti.com> User-Agent: Mutt/1.9.4 (2018-02-28) Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org On Thu, Feb 13, 2020 at 03:54:38PM +0530, Keerthy wrote: > The bandgap provides current and voltage reference for its internal > circuits and other analog IP blocks. The analog-to-digital > converter (ADC) produces an output value that is proportional > to the silicon temperature. > > Currently reading temperatures and trend computing is supported > as there are no active/passive cooling agent supported. > > Signed-off-by: Keerthy > --- > drivers/thermal/Kconfig | 12 ++ > drivers/thermal/Makefile | 1 + > drivers/thermal/k3_bandgap.c | 342 +++++++++++++++++++++++++++++++++++ > 3 files changed, 355 insertions(+) > create mode 100644 drivers/thermal/k3_bandgap.c > > diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig > index 5a05db5438d6..fa598eddc7ac 100644 > --- a/drivers/thermal/Kconfig > +++ b/drivers/thermal/Kconfig > @@ -251,6 +251,18 @@ config IMX_THERMAL > cpufreq is used as the cooling device to throttle CPUs when the > passive trip is crossed. > > +config K3_THERMAL > + bool "Texas Instruments K3 thermal support" > + depends on THERMAL All the Kconfig is under the THERMAL option, so this dependency is not necessary. > + depends on ARCH_K3 || COMPILE_TEST > + help > + If you say yes here you get thermal support for the Texas Instruments > + K3 SoC family. The current chip supported is: > + - AM654 > + > + This includes temperature reading functionality and also trend > + computation. > + [ ... ] > + > +#define K3_VTM_ADC_BEGIN_VAL 540 > +#define K3_VTM_ADC_END_VAL 944 > + > +static const int k3_adc_to_temp[K3_VTM_ADC_END_VAL - K3_VTM_ADC_BEGIN_VAL > + + 1] = { No need to specify a size for the array that can be done with: static const int k3_adc_to_temp[] = { And then use ARRAY_SIZE macro. > + -40000, -40000, -40000, -40000, -39800, -39400, -39000, -38600, -38200, > + -37800, -37400, -37000, -36600, -36200, -35800, -35300, -34700, -34200, > + -33800, -33400, -33000, -32600, -32200, -31800, -31400, -31000, -30600, > + -30200, -29800, -29400, -29000, -28600, -28200, -27700, -27100, -26600, > + -26200, -25800, -25400, -25000, -24600, -24200, -23800, -23400, -23000, > + -22600, -22200, -21800, -21400, -21000, -20500, -19900, -19400, -19000, > + -18600, -18200, -17800, -17400, -17000, -16600, -16200, -15800, -15400, > + -15000, -14600, -14200, -13800, -13400, -13000, -12500, -11900, -11400, > + -11000, -10600, -10200, -9800, -9400, -9000, -8600, -8200, -7800, -7400, > + -7000, -6600, -6200, -5800, -5400, -5000, -4500, -3900, -3400, -3000, > + -2600, -2200, -1800, -1400, -1000, -600, -200, 200, 600, 1000, 1400, > + 1800, 2200, 2600, 3000, 3400, 3900, 4500, 5000, 5400, 5800, 6200, 6600, > + 7000, 7400, 7800, 8200, 8600, 9000, 9400, 9800, 10200, 10600, 11000, > + 11400, 11800, 12200, 12700, 13300, 13800, 14200, 14600, 15000, 15400, > + 15800, 16200, 16600, 17000, 17400, 17800, 18200, 18600, 19000, 19400, > + 19800, 20200, 20600, 21000, 21400, 21900, 22500, 23000, 23400, 23800, > + 24200, 24600, 25000, 25400, 25800, 26200, 26600, 27000, 27400, 27800, > + 28200, 28600, 29000, 29400, 29800, 30200, 30600, 31000, 31400, 31900, > + 32500, 33000, 33400, 33800, 34200, 34600, 35000, 35400, 35800, 36200, > + 36600, 37000, 37400, 37800, 38200, 38600, 39000, 39400, 39800, 40200, > + 40600, 41000, 41400, 41800, 42200, 42600, 43100, 43700, 44200, 44600, > + 45000, 45400, 45800, 46200, 46600, 47000, 47400, 47800, 48200, 48600, > + 49000, 49400, 49800, 50200, 50600, 51000, 51400, 51800, 52200, 52600, > + 53000, 53400, 53800, 54200, 54600, 55000, 55400, 55900, 56500, 57000, > + 57400, 57800, 58200, 58600, 59000, 59400, 59800, 60200, 60600, 61000, > + 61400, 61800, 62200, 62600, 63000, 63400, 63800, 64200, 64600, 65000, > + 65400, 65800, 66200, 66600, 67000, 67400, 67800, 68200, 68600, 69000, > + 69400, 69800, 70200, 70600, 71000, 71500, 72100, 72600, 73000, 73400, > + 73800, 74200, 74600, 75000, 75400, 75800, 76200, 76600, 77000, 77400, > + 77800, 78200, 78600, 79000, 79400, 79800, 80200, 80600, 81000, 81400, > + 81800, 82200, 82600, 83000, 83400, 83800, 84200, 84600, 85000, 85400, > + 85800, 86200, 86600, 87000, 87400, 87800, 88200, 88600, 89000, 89400, > + 89800, 90200, 90600, 91000, 91400, 91800, 92200, 92600, 93000, 93400, > + 93800, 94200, 94600, 95000, 95400, 95800, 96200, 96600, 97000, 97500, > + 98100, 98600, 99000, 99400, 99800, 100200, 100600, 101000, 101400, > + 101800, 102200, 102600, 103000, 103400, 103800, 104200, 104600, 105000, > + 105400, 105800, 106200, 106600, 107000, 107400, 107800, 108200, 108600, > + 109000, 109400, 109800, 110200, 110600, 111000, 111400, 111800, 112200, > + 112600, 113000, 113400, 113800, 114200, 114600, 115000, 115400, 115800, > + 116200, 116600, 117000, 117400, 117800, 118200, 118600, 119000, 119400, > + 119800, 120200, 120600, 121000, 121400, 121800, 122200, 122600, 123000, > + 123400, 123800, 124200, 124600, 124900, 125000, > +}; > + > +struct k3_thermal_data; > + > +struct k3_bandgap { > + struct device *dev; This field is useless, the function using it can use the local dev variable > + void __iomem *base; > + const struct k3_bandgap_data *conf; > + spinlock_t lock; /* shields this struct */ Where is used this lock? > + int ts_cnt; This field is unused. > + u32 errata; > + struct k3_thermal_data *ts_data[K3_VTM_MAX_NUM_TS]; This field is unused. > +}; > + > +struct k3_vtm_driver_data { > + u32 errata; > +}; > + > +/* common data structures */ > +struct k3_thermal_data { > + struct thermal_zone_device *ti_thermal; > + struct thermal_cooling_device *cool_dev; This field is unused > + struct k3_bandgap *bgp; > + enum thermal_device_mode mode; This field is unused > + struct work_struct thermal_wq; Where is used this workq? > + int sensor_id; > + u32 ctrl_offset; > + u32 stat_offset; > + int prev_temp; > +}; > + > +static unsigned int vtm_get_best_value(unsigned int s0, unsigned int s1, > + unsigned int s2) > +{ > + int d01 = abs(s0 - s1); > + int d02 = abs(s0 - s2); > + int d12 = abs(s1 - s2); > + > + if (d01 <= d02 && d01 <= d12) > + return (s0 + s1) / 2; > + > + if (d02 <= d01 && d02 <= d12) > + return (s0 + s2) / 2; > + > + return (s1 + s2) / 2; > +} > + > +static int k3_bgp_read_temp(struct k3_thermal_data *devdata, > + int *temp) > +{ > + struct k3_bandgap *bgp; > + unsigned int dtemp, s0, s1, s2; > + > + bgp = devdata->bgp; nit: missing line > + /** > + * Errata is applicable for am654 pg 1.0 silicon. There > + * is a variation of the order for 8-10 degree centigrade. > + * Work around that by getting the average of two closest > + * readings out of three readings everytime we want to > + * report temperatures. > + * > + * Errata workaround. > + */ nit: extra line > + if (bgp->errata) { Right now only am654 is supported and has the errata. This test is pointless because no other compatible string is defined. If you want to set the scene for more platforms I suggest to add a get_temp function in the drvdata which does this 3 points averaging and get rid of this test (and the errata field). > + s0 = readl(bgp->base + devdata->stat_offset) & > + K3_VTM_TS_STAT_DTEMP_MASK; > + s1 = readl(bgp->base + devdata->stat_offset) & > + K3_VTM_TS_STAT_DTEMP_MASK; > + s2 = readl(bgp->base + devdata->stat_offset) & > + K3_VTM_TS_STAT_DTEMP_MASK; > + dtemp = vtm_get_best_value(s0, s1, s2); > + } else { > + dtemp = readl(bgp->base + devdata->stat_offset) & > + K3_VTM_TS_STAT_DTEMP_MASK; > + } > + > + if (dtemp < K3_VTM_ADC_BEGIN_VAL || dtemp > K3_VTM_ADC_END_VAL) > + return -EINVAL; > + > + *temp = k3_adc_to_temp[dtemp - K3_VTM_ADC_BEGIN_VAL]; > + > + return 0; > +} > + > +/* thermal zone ops */ > +/* Get temperature callback function for thermal zone */ Fix comment format /* * */ > +static int k3_thermal_get_temp(void *devdata, int *temp) > +{ > + struct k3_thermal_data *data = devdata; > + int ret = 0; > + > + ret = k3_bgp_read_temp(data, temp); > + if (ret) > + return ret; > + > + data->prev_temp = *temp; > + > + return ret; > +} > + > +static int k3_thermal_get_trend(void *p, int trip, enum thermal_trend *trend) > +{ > + struct k3_thermal_data *data = p; > + struct k3_bandgap *bgp; > + int ret = 0, temp = 0; > + > + bgp = data->bgp; > + > + ret = k3_bgp_read_temp(data, &temp); > + if (ret) > + return ret; > + > + if (temp > data->prev_temp) > + *trend = THERMAL_TREND_RAISING; > + else if (temp < data->prev_temp) > + *trend = THERMAL_TREND_DROPPING; > + else > + *trend = THERMAL_TREND_STABLE; > + > + return 0; > +} This function get_trend() is not really useful, it does what the governors do. It can be dropped. > +static const struct thermal_zone_of_device_ops k3_of_thermal_ops = { > + .get_temp = k3_thermal_get_temp, > + .get_trend = k3_thermal_get_trend, > +}; > + > +static void k3_thermal_work(struct work_struct *work) > +{ > + struct k3_thermal_data *data = container_of(work, > + struct k3_thermal_data, thermal_wq); > + > + thermal_zone_device_update(data->ti_thermal, THERMAL_EVENT_UNSPECIFIED); > + > + dev_dbg(&data->ti_thermal->device, "updated thermal zone %s\n", > + data->ti_thermal->type); > +} > + > +static const struct of_device_id of_k3_bandgap_match[]; > + > +static int k3_bandgap_probe(struct platform_device *pdev) > +{ > + int ret = 0, cnt, val, id, reg_cnt = 0; > + struct resource *res; > + struct device *dev = &pdev->dev; > + struct k3_bandgap *bgp; > + struct k3_thermal_data *data; > + const struct k3_vtm_driver_data *drv_data; > + > + bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL); > + if (!bgp) > + return -ENOMEM; > + > + drv_data = of_device_get_match_data(&pdev->dev); > + if (drv_data) > + bgp->errata = drv_data->errata; > + > + bgp->dev = dev; > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + bgp->base = devm_ioremap_resource(dev, res); > + if (IS_ERR(bgp->base)) > + return PTR_ERR(bgp->base); > + > + pm_runtime_enable(dev); > + ret = pm_runtime_get_sync(dev); > + if (ret < 0) { > + pm_runtime_put_noidle(dev); > + pm_runtime_disable(dev); > + return ret; > + } > + > + /* Get the sensor count in the VTM */ > + val = readl(bgp->base + K3_VTM_DEVINFO_PWR0_OFFSET); > + cnt = val & K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK; > + cnt >>= __ffs(K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK); > + bgp->ts_cnt = cnt; > + > + data = devm_kcalloc(bgp->dev, cnt, sizeof(*data), GFP_KERNEL); > + if (!data) { > + ret = -ENOMEM; > + goto err_alloc; > + } > + > + /* Register the thermal sensors */ > + for (id = 0; id < cnt; id++) { > + data[id].sensor_id = id; > + data[id].bgp = bgp; > + data[id].ctrl_offset = K3_VTM_TMPSENS0_CTRL_OFFSET + > + id * K3_VTM_REGS_PER_TS; > + data[id].stat_offset = data[id].ctrl_offset + 0x8; > + INIT_WORK(&data[id].thermal_wq, k3_thermal_work); > + > + val = readl(data[id].bgp->base + data[id].ctrl_offset); > + val |= (K3_VTM_TMPSENS_CTRL_SOC | > + K3_VTM_TMPSENS_CTRL_CLRZ | > + K3_VTM_TMPSENS_CTRL_CLKON_REQ); > + val &= ~K3_VTM_TMPSENS_CTRL_CBIASSEL; > + writel(val, data[id].bgp->base + data[id].ctrl_offset); > + > + bgp->ts_data[id] = &data[id]; > + data[id].ti_thermal = > + devm_thermal_zone_of_sensor_register(bgp->dev, id, > + &data[id], > + &k3_of_thermal_ops); > + if (IS_ERR(data[id].ti_thermal)) { > + dev_err(bgp->dev, "thermal zone device is NULL\n"); > + ret = PTR_ERR(data[id].ti_thermal); > + goto err_alloc; > + } > + > + reg_cnt++; > + > + /* Initialize Previous temp */ > + k3_thermal_get_temp(&data[id], &data[id].prev_temp); > + } > + > + platform_set_drvdata(pdev, bgp); > + > + return 0; > + > +err_alloc: > + pm_runtime_put_sync(&pdev->dev); > + pm_runtime_disable(&pdev->dev); > + > + return ret; > +} > + > +static int k3_bandgap_remove(struct platform_device *pdev) > +{ > + pm_runtime_put_sync(&pdev->dev); > + pm_runtime_disable(&pdev->dev); > + > + return 0; > +} > + > +static const struct k3_vtm_driver_data am654_data = { > + .errata = 1, > +}; > + > +static const struct of_device_id of_k3_bandgap_match[] = { > + { > + .compatible = "ti,am654-vtm", > + .data = &am654_data, > + }, > + { /* sentinel */ }, > +}; > +MODULE_DEVICE_TABLE(of, of_k3_bandgap_match); > + > +static struct platform_driver k3_bandgap_sensor_driver = { > + .probe = k3_bandgap_probe, > + .remove = k3_bandgap_remove, > + .driver = { > + .name = "k3-soc-thermal", > + .of_match_table = of_k3_bandgap_match, > + }, > +}; > + > +module_platform_driver(k3_bandgap_sensor_driver); > + > +MODULE_DESCRIPTION("K3 bandgap temperature sensor driver"); > +MODULE_LICENSE("GPL v2"); > +MODULE_AUTHOR("J Keerthy "); > -- > 2.17.1 > -- Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog 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 X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D3232C11D00 for ; Thu, 20 Feb 2020 22:13:56 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id A09C920801 for ; Thu, 20 Feb 2020 22:13:56 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="gzkuGTMk"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="zQF06bXC" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A09C920801 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=MyMCvlQmMTt7Ywrqvqq4AaeUKNoZykPpZGk4QeGHs0M=; b=gzkuGTMkSAdQqd 9W1I2hT+hS6lcFyZrM8s1aX/hyulVGSQg3ZRSwJncGnsIVFtgSd6pVfxfWDXROaOepz+eaHf8xnr4 cx1oOX/9XJf8YuO355xbX7Iez3HfWnQATDSdWz6a2rnPloSPS/hkOTKEDjJPNP3ii4kzrS70sP920 08xYspbFEiODtrzTksIRVqzP3hL9ys9LrsYV944GpXrdFnaBYi66FZ5W1gRPLKjgU1mSjiyWcfvIg LiStmqXk9+fZe+x6dHRisKTh+xhk0Ny6xFfj+HOeIGmNjrZqXDHpjDVoqvYgxjDwJ3EHSyQnuoeOZ JF80EVvSRCn6w8OuoVQw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j4u4o-0005HX-LM; Thu, 20 Feb 2020 22:13:46 +0000 Received: from mail-wm1-x344.google.com ([2a00:1450:4864:20::344]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1j4u4l-0005H5-Gl for linux-arm-kernel@lists.infradead.org; Thu, 20 Feb 2020 22:13:45 +0000 Received: by mail-wm1-x344.google.com with SMTP id a6so210736wme.2 for ; Thu, 20 Feb 2020 14:13:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=jUfFdw2Zfk6+TsIEq3Y3zBZt8xh6o4BAYFw0Cy9piao=; b=zQF06bXCl/IGUk7BYlnpWi1JiaBtl7fo/6WBweQAl6ueyW0Jrr/sfglRUq2YLP+zzO q1b3rjcbVr0+qgm5GYT+kEKC2fYb8ibYIw0kQ/3RNQ+eBE/19l+62xcnsGxBdLG7CWJK QdDuHZNN4+xGYMuep9JOqG4pNYLaYr0x5yoI9vkkQGiN0twvDsK4ag1iL3dzbgsYBQB3 ASdK2HHYHGnJgcJ6KzylGKiwEv9cO4uXKx1M/4lZkCmllsYLH52L/4DdOWxYmOYxwdyD Eh62ASONNhc0enAOnjM1KIcF3dbUhuJFtZML1dTdaFKaCySRJTzitX1THz7aSaEqwBHv IjoQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=jUfFdw2Zfk6+TsIEq3Y3zBZt8xh6o4BAYFw0Cy9piao=; b=r5BfpCWJlun5a1D7I/SF3Se9GhsqkywMxdrPsWDhuzY01iYjNL7q9XSJPzugkSx/8Q 91s5OmggomYa8JpGKJX/CXHKG+Pc1DWdI6A4Xjmb1Em+LefktLM9DtiDPhWbCnHeeRn8 25jFVTI9qnlJfnr/rRNAJzg0Gda71pJ149DYTrpCLj2DWH1houUItdH2akGl6oJSiECD WK8ApPbd9dQHcF4YKKjZhiwr6gfT5R8vS0Av40PNg0ulVL1tNfsHieXHz6xMiMPVHEin oM2URFt74xKUhEs6RLv+s3PgZ0nsFtdEERlUKLtaCtEKQS6+dKQEA3cla3vDDYm5KIrX +Vyw== X-Gm-Message-State: APjAAAVTi92cuxAkR1GlSishQvp/AksgPmYFpD/NBX44LChtJuwmF56c jJ2zK4WlUlYLQMSFxYwsdWIlOg== X-Google-Smtp-Source: APXvYqwJ0m2BHYbBrNyBeCq8AfsLhyTtxU2RR8idQnaC4wf/hphDZP56noO66Bh678igOeXTb1GQQQ== X-Received: by 2002:a05:600c:21c5:: with SMTP id x5mr6791923wmj.72.1582236819746; Thu, 20 Feb 2020 14:13:39 -0800 (PST) Received: from linaro.org ([2a01:e34:ed2f:f020:2dfb:b5ce:9043:4adb]) by smtp.gmail.com with ESMTPSA id d204sm868990wmd.30.2020.02.20.14.13.37 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Thu, 20 Feb 2020 14:13:39 -0800 (PST) Date: Thu, 20 Feb 2020 23:13:34 +0100 From: Daniel Lezcano To: Keerthy Subject: Re: [PATCH 2/4] thermal: k3: Add support for bandgap sensors Message-ID: <20200220221334.GA7119@linaro.org> References: <20200213102440.20539-1-j-keerthy@ti.com> <20200213102440.20539-3-j-keerthy@ti.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20200213102440.20539-3-j-keerthy@ti.com> User-Agent: Mutt/1.9.4 (2018-02-28) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200220_141343_572502_15E9B9F4 X-CRM114-Status: GOOD ( 30.92 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: mark.rutland@arm.com, devicetree@vger.kernel.org, amit.kucheria@verdurent.com, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, t-kristo@ti.com, robh+dt@kernel.org, rui.zhang@intel.com, linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gVGh1LCBGZWIgMTMsIDIwMjAgYXQgMDM6NTQ6MzhQTSArMDUzMCwgS2VlcnRoeSB3cm90ZToK PiBUaGUgYmFuZGdhcCBwcm92aWRlcyBjdXJyZW50IGFuZCB2b2x0YWdlIHJlZmVyZW5jZSBmb3Ig aXRzIGludGVybmFsCj4gY2lyY3VpdHMgYW5kIG90aGVyIGFuYWxvZyBJUCBibG9ja3MuIFRoZSBh bmFsb2ctdG8tZGlnaXRhbAo+IGNvbnZlcnRlciAoQURDKSBwcm9kdWNlcyBhbiBvdXRwdXQgdmFs dWUgdGhhdCBpcyBwcm9wb3J0aW9uYWwKPiB0byB0aGUgc2lsaWNvbiB0ZW1wZXJhdHVyZS4KPiAK PiBDdXJyZW50bHkgcmVhZGluZyB0ZW1wZXJhdHVyZXMgYW5kIHRyZW5kIGNvbXB1dGluZyBpcyBz dXBwb3J0ZWQKPiBhcyB0aGVyZSBhcmUgbm8gYWN0aXZlL3Bhc3NpdmUgY29vbGluZyBhZ2VudCBz dXBwb3J0ZWQuCj4gCj4gU2lnbmVkLW9mZi1ieTogS2VlcnRoeSA8ai1rZWVydGh5QHRpLmNvbT4K PiAtLS0KPiAgZHJpdmVycy90aGVybWFsL0tjb25maWcgICAgICB8ICAxMiArKwo+ICBkcml2ZXJz L3RoZXJtYWwvTWFrZWZpbGUgICAgIHwgICAxICsKPiAgZHJpdmVycy90aGVybWFsL2szX2JhbmRn YXAuYyB8IDM0MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICAzIGZpbGVz IGNoYW5nZWQsIDM1NSBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L3RoZXJtYWwvazNfYmFuZGdhcC5jCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGhlcm1hbC9L Y29uZmlnIGIvZHJpdmVycy90aGVybWFsL0tjb25maWcKPiBpbmRleCA1YTA1ZGI1NDM4ZDYuLmZh NTk4ZWRkYzdhYyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3RoZXJtYWwvS2NvbmZpZwo+ICsrKyBi L2RyaXZlcnMvdGhlcm1hbC9LY29uZmlnCj4gQEAgLTI1MSw2ICsyNTEsMTggQEAgY29uZmlnIElN WF9USEVSTUFMCj4gIAkgIGNwdWZyZXEgaXMgdXNlZCBhcyB0aGUgY29vbGluZyBkZXZpY2UgdG8g dGhyb3R0bGUgQ1BVcyB3aGVuIHRoZQo+ICAJICBwYXNzaXZlIHRyaXAgaXMgY3Jvc3NlZC4KPiAg Cj4gK2NvbmZpZyBLM19USEVSTUFMCj4gKwlib29sICJUZXhhcyBJbnN0cnVtZW50cyBLMyB0aGVy bWFsIHN1cHBvcnQiCj4gKwlkZXBlbmRzIG9uIFRIRVJNQUwKCkFsbCB0aGUgS2NvbmZpZyBpcyB1 bmRlciB0aGUgVEhFUk1BTCBvcHRpb24sIHNvIHRoaXMgZGVwZW5kZW5jeSBpcyBub3QKbmVjZXNz YXJ5LgoKPiArCWRlcGVuZHMgb24gQVJDSF9LMyB8fCBDT01QSUxFX1RFU1QKPiArCWhlbHAKPiAr CSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHRoZXJtYWwgc3VwcG9ydCBmb3IgdGhlIFRl eGFzIEluc3RydW1lbnRzCj4gKwkgIEszIFNvQyBmYW1pbHkuIFRoZSBjdXJyZW50IGNoaXAgc3Vw cG9ydGVkIGlzOgo+ICsJICAgLSBBTTY1NAo+ICsKPiArCSAgVGhpcyBpbmNsdWRlcyB0ZW1wZXJh dHVyZSByZWFkaW5nIGZ1bmN0aW9uYWxpdHkgYW5kIGFsc28gdHJlbmQKPiArCSAgY29tcHV0YXRp b24uCj4gKwoKWyAuLi4gXQoKPiArCj4gKyNkZWZpbmUgSzNfVlRNX0FEQ19CRUdJTl9WQUwJCTU0 MAo+ICsjZGVmaW5lIEszX1ZUTV9BRENfRU5EX1ZBTAkJOTQ0Cj4gKwo+ICtzdGF0aWMgY29uc3Qg aW50IGszX2FkY190b190ZW1wW0szX1ZUTV9BRENfRU5EX1ZBTCAtIEszX1ZUTV9BRENfQkVHSU5f VkFMCj4gKwkJCQkrIDFdID0gewoKTm8gbmVlZCB0byBzcGVjaWZ5IGEgc2l6ZSBmb3IgdGhlIGFy cmF5IHRoYXQgY2FuIGJlIGRvbmUgd2l0aDoKCnN0YXRpYyBjb25zdCBpbnQgazNfYWRjX3RvX3Rl bXBbXSA9IHsKCkFuZCB0aGVuIHVzZSBBUlJBWV9TSVpFIG1hY3JvLgoKPiArCS00MDAwMCwgLTQw MDAwLCAtNDAwMDAsIC00MDAwMCwgLTM5ODAwLCAtMzk0MDAsIC0zOTAwMCwgLTM4NjAwLCAtMzgy MDAsCj4gKwktMzc4MDAsIC0zNzQwMCwgLTM3MDAwLCAtMzY2MDAsIC0zNjIwMCwgLTM1ODAwLCAt MzUzMDAsIC0zNDcwMCwgLTM0MjAwLAo+ICsJLTMzODAwLCAtMzM0MDAsIC0zMzAwMCwgLTMyNjAw LCAtMzIyMDAsIC0zMTgwMCwgLTMxNDAwLCAtMzEwMDAsIC0zMDYwMCwKPiArCS0zMDIwMCwgLTI5 ODAwLCAtMjk0MDAsIC0yOTAwMCwgLTI4NjAwLCAtMjgyMDAsIC0yNzcwMCwgLTI3MTAwLCAtMjY2 MDAsCj4gKwktMjYyMDAsIC0yNTgwMCwgLTI1NDAwLCAtMjUwMDAsIC0yNDYwMCwgLTI0MjAwLCAt MjM4MDAsIC0yMzQwMCwgLTIzMDAwLAo+ICsJLTIyNjAwLCAtMjIyMDAsIC0yMTgwMCwgLTIxNDAw LCAtMjEwMDAsIC0yMDUwMCwgLTE5OTAwLCAtMTk0MDAsIC0xOTAwMCwKPiArCS0xODYwMCwgLTE4 MjAwLCAtMTc4MDAsIC0xNzQwMCwgLTE3MDAwLCAtMTY2MDAsIC0xNjIwMCwgLTE1ODAwLCAtMTU0 MDAsCj4gKwktMTUwMDAsIC0xNDYwMCwgLTE0MjAwLCAtMTM4MDAsIC0xMzQwMCwgLTEzMDAwLCAt MTI1MDAsIC0xMTkwMCwgLTExNDAwLAo+ICsJLTExMDAwLCAtMTA2MDAsIC0xMDIwMCwgLTk4MDAs IC05NDAwLCAtOTAwMCwgLTg2MDAsIC04MjAwLCAtNzgwMCwgLTc0MDAsCj4gKwktNzAwMCwgLTY2 MDAsIC02MjAwLCAtNTgwMCwgLTU0MDAsIC01MDAwLCAtNDUwMCwgLTM5MDAsIC0zNDAwLCAtMzAw MCwKPiArCS0yNjAwLCAtMjIwMCwgLTE4MDAsIC0xNDAwLCAtMTAwMCwgLTYwMCwgLTIwMCwgMjAw LCA2MDAsIDEwMDAsIDE0MDAsCj4gKwkxODAwLCAyMjAwLCAyNjAwLCAzMDAwLCAzNDAwLCAzOTAw LCA0NTAwLCA1MDAwLCA1NDAwLCA1ODAwLCA2MjAwLCA2NjAwLAo+ICsJNzAwMCwgNzQwMCwgNzgw MCwgODIwMCwgODYwMCwgOTAwMCwgOTQwMCwgOTgwMCwgMTAyMDAsIDEwNjAwLCAxMTAwMCwKPiAr CTExNDAwLCAxMTgwMCwgMTIyMDAsIDEyNzAwLCAxMzMwMCwgMTM4MDAsIDE0MjAwLCAxNDYwMCwg MTUwMDAsIDE1NDAwLAo+ICsJMTU4MDAsIDE2MjAwLCAxNjYwMCwgMTcwMDAsIDE3NDAwLCAxNzgw MCwgMTgyMDAsIDE4NjAwLCAxOTAwMCwgMTk0MDAsCj4gKwkxOTgwMCwgMjAyMDAsIDIwNjAwLCAy MTAwMCwgMjE0MDAsIDIxOTAwLCAyMjUwMCwgMjMwMDAsIDIzNDAwLCAyMzgwMCwKPiArCTI0MjAw LCAyNDYwMCwgMjUwMDAsIDI1NDAwLCAyNTgwMCwgMjYyMDAsIDI2NjAwLCAyNzAwMCwgMjc0MDAs IDI3ODAwLAo+ICsJMjgyMDAsIDI4NjAwLCAyOTAwMCwgMjk0MDAsIDI5ODAwLCAzMDIwMCwgMzA2 MDAsIDMxMDAwLCAzMTQwMCwgMzE5MDAsCj4gKwkzMjUwMCwgMzMwMDAsIDMzNDAwLCAzMzgwMCwg MzQyMDAsIDM0NjAwLCAzNTAwMCwgMzU0MDAsIDM1ODAwLCAzNjIwMCwKPiArCTM2NjAwLCAzNzAw MCwgMzc0MDAsIDM3ODAwLCAzODIwMCwgMzg2MDAsIDM5MDAwLCAzOTQwMCwgMzk4MDAsIDQwMjAw LAo+ICsJNDA2MDAsIDQxMDAwLCA0MTQwMCwgNDE4MDAsIDQyMjAwLCA0MjYwMCwgNDMxMDAsIDQz NzAwLCA0NDIwMCwgNDQ2MDAsCj4gKwk0NTAwMCwgNDU0MDAsIDQ1ODAwLCA0NjIwMCwgNDY2MDAs IDQ3MDAwLCA0NzQwMCwgNDc4MDAsIDQ4MjAwLCA0ODYwMCwKPiArCTQ5MDAwLCA0OTQwMCwgNDk4 MDAsIDUwMjAwLCA1MDYwMCwgNTEwMDAsIDUxNDAwLCA1MTgwMCwgNTIyMDAsIDUyNjAwLAo+ICsJ NTMwMDAsIDUzNDAwLCA1MzgwMCwgNTQyMDAsIDU0NjAwLCA1NTAwMCwgNTU0MDAsIDU1OTAwLCA1 NjUwMCwgNTcwMDAsCj4gKwk1NzQwMCwgNTc4MDAsIDU4MjAwLCA1ODYwMCwgNTkwMDAsIDU5NDAw LCA1OTgwMCwgNjAyMDAsIDYwNjAwLCA2MTAwMCwKPiArCTYxNDAwLCA2MTgwMCwgNjIyMDAsIDYy NjAwLCA2MzAwMCwgNjM0MDAsIDYzODAwLCA2NDIwMCwgNjQ2MDAsIDY1MDAwLAo+ICsJNjU0MDAs IDY1ODAwLCA2NjIwMCwgNjY2MDAsIDY3MDAwLCA2NzQwMCwgNjc4MDAsIDY4MjAwLCA2ODYwMCwg NjkwMDAsCj4gKwk2OTQwMCwgNjk4MDAsIDcwMjAwLCA3MDYwMCwgNzEwMDAsIDcxNTAwLCA3MjEw MCwgNzI2MDAsIDczMDAwLCA3MzQwMCwKPiArCTczODAwLCA3NDIwMCwgNzQ2MDAsIDc1MDAwLCA3 NTQwMCwgNzU4MDAsIDc2MjAwLCA3NjYwMCwgNzcwMDAsIDc3NDAwLAo+ICsJNzc4MDAsIDc4MjAw LCA3ODYwMCwgNzkwMDAsIDc5NDAwLCA3OTgwMCwgODAyMDAsIDgwNjAwLCA4MTAwMCwgODE0MDAs Cj4gKwk4MTgwMCwgODIyMDAsIDgyNjAwLCA4MzAwMCwgODM0MDAsIDgzODAwLCA4NDIwMCwgODQ2 MDAsIDg1MDAwLCA4NTQwMCwKPiArCTg1ODAwLCA4NjIwMCwgODY2MDAsIDg3MDAwLCA4NzQwMCwg ODc4MDAsIDg4MjAwLCA4ODYwMCwgODkwMDAsIDg5NDAwLAo+ICsJODk4MDAsIDkwMjAwLCA5MDYw MCwgOTEwMDAsIDkxNDAwLCA5MTgwMCwgOTIyMDAsIDkyNjAwLCA5MzAwMCwgOTM0MDAsCj4gKwk5 MzgwMCwgOTQyMDAsIDk0NjAwLCA5NTAwMCwgOTU0MDAsIDk1ODAwLCA5NjIwMCwgOTY2MDAsIDk3 MDAwLCA5NzUwMCwKPiArCTk4MTAwLCA5ODYwMCwgOTkwMDAsIDk5NDAwLCA5OTgwMCwgMTAwMjAw LCAxMDA2MDAsIDEwMTAwMCwgMTAxNDAwLAo+ICsJMTAxODAwLCAxMDIyMDAsIDEwMjYwMCwgMTAz MDAwLCAxMDM0MDAsIDEwMzgwMCwgMTA0MjAwLCAxMDQ2MDAsIDEwNTAwMCwKPiArCTEwNTQwMCwg MTA1ODAwLCAxMDYyMDAsIDEwNjYwMCwgMTA3MDAwLCAxMDc0MDAsIDEwNzgwMCwgMTA4MjAwLCAx MDg2MDAsCj4gKwkxMDkwMDAsIDEwOTQwMCwgMTA5ODAwLCAxMTAyMDAsIDExMDYwMCwgMTExMDAw LCAxMTE0MDAsIDExMTgwMCwgMTEyMjAwLAo+ICsJMTEyNjAwLCAxMTMwMDAsIDExMzQwMCwgMTEz ODAwLCAxMTQyMDAsIDExNDYwMCwgMTE1MDAwLCAxMTU0MDAsIDExNTgwMCwKPiArCTExNjIwMCwg MTE2NjAwLCAxMTcwMDAsIDExNzQwMCwgMTE3ODAwLCAxMTgyMDAsIDExODYwMCwgMTE5MDAwLCAx MTk0MDAsCj4gKwkxMTk4MDAsIDEyMDIwMCwgMTIwNjAwLCAxMjEwMDAsIDEyMTQwMCwgMTIxODAw LCAxMjIyMDAsIDEyMjYwMCwgMTIzMDAwLAo+ICsJMTIzNDAwLCAxMjM4MDAsIDEyNDIwMCwgMTI0 NjAwLCAxMjQ5MDAsIDEyNTAwMCwKPiArfTsKPiArCj4gK3N0cnVjdCBrM190aGVybWFsX2RhdGE7 Cj4gKwo+ICtzdHJ1Y3QgazNfYmFuZGdhcCB7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXY7CgpUaGlz IGZpZWxkIGlzIHVzZWxlc3MsIHRoZSBmdW5jdGlvbiB1c2luZyBpdCBjYW4gdXNlIHRoZSBsb2Nh bCBkZXYgdmFyaWFibGUKCj4gKwl2b2lkIF9faW9tZW0gKmJhc2U7Cj4gKwljb25zdCBzdHJ1Y3Qg azNfYmFuZGdhcF9kYXRhICpjb25mOwo+ICsJc3BpbmxvY2tfdCBsb2NrOyAvKiBzaGllbGRzIHRo aXMgc3RydWN0ICovCgpXaGVyZSBpcyB1c2VkIHRoaXMgbG9jaz8KCj4gKwlpbnQgdHNfY250OwoK VGhpcyBmaWVsZCBpcyB1bnVzZWQuCgo+ICsJdTMyIGVycmF0YTsKPiArCXN0cnVjdCBrM190aGVy bWFsX2RhdGEgKnRzX2RhdGFbSzNfVlRNX01BWF9OVU1fVFNdOwoKVGhpcyBmaWVsZCBpcyB1bnVz ZWQuCgo+ICt9Owo+ICsKPiArc3RydWN0IGszX3Z0bV9kcml2ZXJfZGF0YSB7Cj4gKwl1MzIgZXJy YXRhOwo+ICt9Owo+ICsKPiArLyogY29tbW9uIGRhdGEgc3RydWN0dXJlcyAqLwo+ICtzdHJ1Y3Qg azNfdGhlcm1hbF9kYXRhIHsKPiArCXN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlICp0aV90aGVy bWFsOwo+ICsJc3RydWN0IHRoZXJtYWxfY29vbGluZ19kZXZpY2UgKmNvb2xfZGV2OwoKVGhpcyBm aWVsZCBpcyB1bnVzZWQKCj4gKwlzdHJ1Y3QgazNfYmFuZGdhcCAqYmdwOwo+ICsJZW51bSB0aGVy bWFsX2RldmljZV9tb2RlIG1vZGU7CgpUaGlzIGZpZWxkIGlzIHVudXNlZAoKPiArCXN0cnVjdCB3 b3JrX3N0cnVjdCB0aGVybWFsX3dxOwoKV2hlcmUgaXMgdXNlZCB0aGlzIHdvcmtxPwoKPiArCWlu dCBzZW5zb3JfaWQ7Cj4gKwl1MzIgY3RybF9vZmZzZXQ7Cj4gKwl1MzIgc3RhdF9vZmZzZXQ7Cj4g KwlpbnQgcHJldl90ZW1wOwo+ICt9Owo+ICsKPiArc3RhdGljIHVuc2lnbmVkIGludCB2dG1fZ2V0 X2Jlc3RfdmFsdWUodW5zaWduZWQgaW50IHMwLCB1bnNpZ25lZCBpbnQgczEsCj4gKwkJCQkgICAg ICAgdW5zaWduZWQgaW50IHMyKQo+ICt7Cj4gKwlpbnQgZDAxID0gYWJzKHMwIC0gczEpOwo+ICsJ aW50IGQwMiA9IGFicyhzMCAtIHMyKTsKPiArCWludCBkMTIgPSBhYnMoczEgLSBzMik7Cj4gKwo+ ICsJaWYgKGQwMSA8PSBkMDIgJiYgZDAxIDw9IGQxMikKPiArCQlyZXR1cm4gKHMwICsgczEpIC8g MjsKPiArCj4gKwlpZiAoZDAyIDw9IGQwMSAmJiBkMDIgPD0gZDEyKQo+ICsJCXJldHVybiAoczAg KyBzMikgLyAyOwo+ICsKPiArCXJldHVybiAoczEgKyBzMikgLyAyOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW50IGszX2JncF9yZWFkX3RlbXAoc3RydWN0IGszX3RoZXJtYWxfZGF0YSAqZGV2ZGF0YSwK PiArCQkJICAgIGludCAqdGVtcCkKPiArewo+ICsJc3RydWN0IGszX2JhbmRnYXAgKmJncDsKPiAr CXVuc2lnbmVkIGludCBkdGVtcCwgczAsIHMxLCBzMjsKPiArCj4gKwliZ3AgPSBkZXZkYXRhLT5i Z3A7CgpuaXQ6IG1pc3NpbmcgbGluZQoKPiArCS8qKgo+ICsJICogRXJyYXRhIGlzIGFwcGxpY2Fi bGUgZm9yIGFtNjU0IHBnIDEuMCBzaWxpY29uLiBUaGVyZQo+ICsJICogaXMgYSB2YXJpYXRpb24g b2YgdGhlIG9yZGVyIGZvciA4LTEwIGRlZ3JlZSBjZW50aWdyYWRlLgo+ICsJICogV29yayBhcm91 bmQgdGhhdCBieSBnZXR0aW5nIHRoZSBhdmVyYWdlIG9mIHR3byBjbG9zZXN0Cj4gKwkgKiByZWFk aW5ncyBvdXQgb2YgdGhyZWUgcmVhZGluZ3MgZXZlcnl0aW1lIHdlIHdhbnQgdG8KPiArCSAqIHJl cG9ydCB0ZW1wZXJhdHVyZXMuCj4gKwkgKgo+ICsJICogRXJyYXRhIHdvcmthcm91bmQuCj4gKwkg Ki8KCm5pdDogZXh0cmEgbGluZQoKPiArCWlmIChiZ3AtPmVycmF0YSkgewoKUmlnaHQgbm93IG9u bHkgYW02NTQgaXMgc3VwcG9ydGVkIGFuZCBoYXMgdGhlIGVycmF0YS4gVGhpcyB0ZXN0IGlzIHBv aW50bGVzcwpiZWNhdXNlIG5vIG90aGVyIGNvbXBhdGlibGUgc3RyaW5nIGlzIGRlZmluZWQuIElm IHlvdSB3YW50IHRvIHNldCB0aGUgc2NlbmUgZm9yCm1vcmUgcGxhdGZvcm1zIEkgc3VnZ2VzdCB0 byBhZGQgYSBnZXRfdGVtcCBmdW5jdGlvbiBpbiB0aGUgZHJ2ZGF0YSB3aGljaCBkb2VzCnRoaXMg MyBwb2ludHMgYXZlcmFnaW5nIGFuZCBnZXQgcmlkIG9mIHRoaXMgdGVzdCAoYW5kIHRoZSBlcnJh dGEgZmllbGQpLgoKPiArCQlzMCA9IHJlYWRsKGJncC0+YmFzZSArIGRldmRhdGEtPnN0YXRfb2Zm c2V0KSAmCj4gKwkJCUszX1ZUTV9UU19TVEFUX0RURU1QX01BU0s7Cj4gKwkJczEgPSByZWFkbChi Z3AtPmJhc2UgKyBkZXZkYXRhLT5zdGF0X29mZnNldCkgJgo+ICsJCQlLM19WVE1fVFNfU1RBVF9E VEVNUF9NQVNLOwo+ICsJCXMyID0gcmVhZGwoYmdwLT5iYXNlICsgZGV2ZGF0YS0+c3RhdF9vZmZz ZXQpICYKPiArCQkJSzNfVlRNX1RTX1NUQVRfRFRFTVBfTUFTSzsKPiArCQlkdGVtcCA9IHZ0bV9n ZXRfYmVzdF92YWx1ZShzMCwgczEsIHMyKTsKPiArCX0gZWxzZSB7Cj4gKwkJZHRlbXAgPSByZWFk bChiZ3AtPmJhc2UgKyBkZXZkYXRhLT5zdGF0X29mZnNldCkgJgo+ICsJCQkJSzNfVlRNX1RTX1NU QVRfRFRFTVBfTUFTSzsKPiArCX0KPiArCj4gKwlpZiAoZHRlbXAgPCBLM19WVE1fQURDX0JFR0lO X1ZBTCB8fCBkdGVtcCA+IEszX1ZUTV9BRENfRU5EX1ZBTCkKPiArCQlyZXR1cm4gLUVJTlZBTDsK PiArCj4gKwkqdGVtcCA9IGszX2FkY190b190ZW1wW2R0ZW1wIC0gSzNfVlRNX0FEQ19CRUdJTl9W QUxdOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICsvKiB0aGVybWFsIHpvbmUgb3BzICov Cj4gKy8qIEdldCB0ZW1wZXJhdHVyZSBjYWxsYmFjayBmdW5jdGlvbiBmb3IgdGhlcm1hbCB6b25l ICovCgpGaXggY29tbWVudCBmb3JtYXQKCi8qCiAqCiAqLwoKPiArc3RhdGljIGludCBrM190aGVy bWFsX2dldF90ZW1wKHZvaWQgKmRldmRhdGEsIGludCAqdGVtcCkKPiArewo+ICsJc3RydWN0IGsz X3RoZXJtYWxfZGF0YSAqZGF0YSA9IGRldmRhdGE7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwly ZXQgPSBrM19iZ3BfcmVhZF90ZW1wKGRhdGEsIHRlbXApOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1 cm4gcmV0Owo+ICsKPiArCWRhdGEtPnByZXZfdGVtcCA9ICp0ZW1wOwo+ICsKPiArCXJldHVybiBy ZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgazNfdGhlcm1hbF9nZXRfdHJlbmQodm9pZCAqcCwg aW50IHRyaXAsIGVudW0gdGhlcm1hbF90cmVuZCAqdHJlbmQpCj4gK3sKPiArCXN0cnVjdCBrM190 aGVybWFsX2RhdGEgKmRhdGEgPSBwOwo+ICsJc3RydWN0IGszX2JhbmRnYXAgKmJncDsKPiArCWlu dCByZXQgPSAwLCB0ZW1wID0gMDsKPiArCj4gKwliZ3AgPSBkYXRhLT5iZ3A7Cj4gKwo+ICsJcmV0 ID0gazNfYmdwX3JlYWRfdGVtcChkYXRhLCAmdGVtcCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVy biByZXQ7Cj4gKwo+ICsJaWYgKHRlbXAgPiBkYXRhLT5wcmV2X3RlbXApCj4gKwkJKnRyZW5kID0g VEhFUk1BTF9UUkVORF9SQUlTSU5HOwo+ICsJZWxzZSBpZiAodGVtcCA8IGRhdGEtPnByZXZfdGVt cCkKPiArCQkqdHJlbmQgPSBUSEVSTUFMX1RSRU5EX0RST1BQSU5HOwo+ICsJZWxzZQo+ICsJCSp0 cmVuZCA9IFRIRVJNQUxfVFJFTkRfU1RBQkxFOwo+ICsKPiArCXJldHVybiAwOwo+ICt9CgpUaGlz IGZ1bmN0aW9uIGdldF90cmVuZCgpIGlzIG5vdCByZWFsbHkgdXNlZnVsLCBpdCBkb2VzIHdoYXQg dGhlIGdvdmVybm9ycyBkby4KCkl0IGNhbiBiZSBkcm9wcGVkLgoKPiArc3RhdGljIGNvbnN0IHN0 cnVjdCB0aGVybWFsX3pvbmVfb2ZfZGV2aWNlX29wcyBrM19vZl90aGVybWFsX29wcyA9IHsKPiAr CS5nZXRfdGVtcCA9IGszX3RoZXJtYWxfZ2V0X3RlbXAsCj4gKwkuZ2V0X3RyZW5kID0gazNfdGhl cm1hbF9nZXRfdHJlbmQsCj4gK307Cj4gKwo+ICtzdGF0aWMgdm9pZCBrM190aGVybWFsX3dvcmso c3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQo+ICt7Cj4gKwlzdHJ1Y3QgazNfdGhlcm1hbF9kYXRh ICpkYXRhID0gY29udGFpbmVyX29mKHdvcmssCj4gKwkJCQkJc3RydWN0IGszX3RoZXJtYWxfZGF0 YSwgdGhlcm1hbF93cSk7Cj4gKwo+ICsJdGhlcm1hbF96b25lX2RldmljZV91cGRhdGUoZGF0YS0+ dGlfdGhlcm1hbCwgVEhFUk1BTF9FVkVOVF9VTlNQRUNJRklFRCk7Cj4gKwo+ICsJZGV2X2RiZygm ZGF0YS0+dGlfdGhlcm1hbC0+ZGV2aWNlLCAidXBkYXRlZCB0aGVybWFsIHpvbmUgJXNcbiIsCj4g KwkJZGF0YS0+dGlfdGhlcm1hbC0+dHlwZSk7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3Qgb2ZfZGV2aWNlX2lkIG9mX2szX2JhbmRnYXBfbWF0Y2hbXTsKPiArCj4gK3N0YXRpYyBpbnQg azNfYmFuZGdhcF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwlp bnQgcmV0ID0gMCwgY250LCB2YWwsIGlkLCByZWdfY250ID0gMDsKPiArCXN0cnVjdCByZXNvdXJj ZSAqcmVzOwo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiArCXN0cnVjdCBr M19iYW5kZ2FwICpiZ3A7Cj4gKwlzdHJ1Y3QgazNfdGhlcm1hbF9kYXRhICpkYXRhOwo+ICsJY29u c3Qgc3RydWN0IGszX3Z0bV9kcml2ZXJfZGF0YSAqZHJ2X2RhdGE7Cj4gKwo+ICsJYmdwID0gZGV2 bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqYmdwKSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAo IWJncCkKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlkcnZfZGF0YSA9IG9mX2RldmljZV9n ZXRfbWF0Y2hfZGF0YSgmcGRldi0+ZGV2KTsKPiArCWlmIChkcnZfZGF0YSkKPiArCQliZ3AtPmVy cmF0YSA9IGRydl9kYXRhLT5lcnJhdGE7Cj4gKwo+ICsJYmdwLT5kZXYgPSBkZXY7Cj4gKwlyZXMg PSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOwo+ICsJYmdw LT5iYXNlID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKGRldiwgcmVzKTsKPiArCWlmIChJU19FUlIo YmdwLT5iYXNlKSkKPiArCQlyZXR1cm4gUFRSX0VSUihiZ3AtPmJhc2UpOwo+ICsKPiArCXBtX3J1 bnRpbWVfZW5hYmxlKGRldik7Cj4gKwlyZXQgPSBwbV9ydW50aW1lX2dldF9zeW5jKGRldik7Cj4g KwlpZiAocmV0IDwgMCkgewo+ICsJCXBtX3J1bnRpbWVfcHV0X25vaWRsZShkZXYpOwo+ICsJCXBt X3J1bnRpbWVfZGlzYWJsZShkZXYpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJLyog R2V0IHRoZSBzZW5zb3IgY291bnQgaW4gdGhlIFZUTSAqLwo+ICsJdmFsID0gcmVhZGwoYmdwLT5i YXNlICsgSzNfVlRNX0RFVklORk9fUFdSMF9PRkZTRVQpOwo+ICsJY250ID0gdmFsICYgSzNfVlRN X0RFVklORk9fUFdSMF9URU1QU0VOU19DVF9NQVNLOwo+ICsJY250ID4+PSBfX2ZmcyhLM19WVE1f REVWSU5GT19QV1IwX1RFTVBTRU5TX0NUX01BU0spOwo+ICsJYmdwLT50c19jbnQgPSBjbnQ7Cj4g Kwo+ICsJZGF0YSA9IGRldm1fa2NhbGxvYyhiZ3AtPmRldiwgY250LCBzaXplb2YoKmRhdGEpLCBH RlBfS0VSTkVMKTsKPiArCWlmICghZGF0YSkgewo+ICsJCXJldCA9IC1FTk9NRU07Cj4gKwkJZ290 byBlcnJfYWxsb2M7Cj4gKwl9Cj4gKwo+ICsJLyogUmVnaXN0ZXIgdGhlIHRoZXJtYWwgc2Vuc29y cyAqLwo+ICsJZm9yIChpZCA9IDA7IGlkIDwgY250OyBpZCsrKSB7Cj4gKwkJZGF0YVtpZF0uc2Vu c29yX2lkID0gaWQ7Cj4gKwkJZGF0YVtpZF0uYmdwID0gYmdwOwo+ICsJCWRhdGFbaWRdLmN0cmxf b2Zmc2V0ID0gSzNfVlRNX1RNUFNFTlMwX0NUUkxfT0ZGU0VUICsKPiArCQkJCQlpZCAqIEszX1ZU TV9SRUdTX1BFUl9UUzsKPiArCQlkYXRhW2lkXS5zdGF0X29mZnNldCA9IGRhdGFbaWRdLmN0cmxf b2Zmc2V0ICsgMHg4Owo+ICsJCUlOSVRfV09SSygmZGF0YVtpZF0udGhlcm1hbF93cSwgazNfdGhl cm1hbF93b3JrKTsKPiArCj4gKwkJdmFsID0gcmVhZGwoZGF0YVtpZF0uYmdwLT5iYXNlICsgZGF0 YVtpZF0uY3RybF9vZmZzZXQpOwo+ICsJCXZhbCB8PSAoSzNfVlRNX1RNUFNFTlNfQ1RSTF9TT0Mg fAo+ICsJCQlLM19WVE1fVE1QU0VOU19DVFJMX0NMUlogfAo+ICsJCQlLM19WVE1fVE1QU0VOU19D VFJMX0NMS09OX1JFUSk7Cj4gKwkJdmFsICY9IH5LM19WVE1fVE1QU0VOU19DVFJMX0NCSUFTU0VM Owo+ICsJCXdyaXRlbCh2YWwsIGRhdGFbaWRdLmJncC0+YmFzZSArIGRhdGFbaWRdLmN0cmxfb2Zm c2V0KTsKPiArCj4gKwkJYmdwLT50c19kYXRhW2lkXSA9ICZkYXRhW2lkXTsKPiArCQlkYXRhW2lk XS50aV90aGVybWFsID0KPiArCQlkZXZtX3RoZXJtYWxfem9uZV9vZl9zZW5zb3JfcmVnaXN0ZXIo YmdwLT5kZXYsIGlkLAo+ICsJCQkJCQkgICAgICZkYXRhW2lkXSwKPiArCQkJCQkJICAgICAmazNf b2ZfdGhlcm1hbF9vcHMpOwo+ICsJCWlmIChJU19FUlIoZGF0YVtpZF0udGlfdGhlcm1hbCkpIHsK PiArCQkJZGV2X2VycihiZ3AtPmRldiwgInRoZXJtYWwgem9uZSBkZXZpY2UgaXMgTlVMTFxuIik7 Cj4gKwkJCXJldCA9IFBUUl9FUlIoZGF0YVtpZF0udGlfdGhlcm1hbCk7Cj4gKwkJCWdvdG8gZXJy X2FsbG9jOwo+ICsJCX0KPiArCj4gKwkJcmVnX2NudCsrOwo+ICsKPiArCQkvKiBJbml0aWFsaXpl IFByZXZpb3VzIHRlbXAgKi8KPiArCQlrM190aGVybWFsX2dldF90ZW1wKCZkYXRhW2lkXSwgJmRh dGFbaWRdLnByZXZfdGVtcCk7Cj4gKwl9Cj4gKwo+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRl diwgYmdwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArCj4gK2Vycl9hbGxvYzoKPiArCXBtX3J1bnRp bWVfcHV0X3N5bmMoJnBkZXYtPmRldik7Cj4gKwlwbV9ydW50aW1lX2Rpc2FibGUoJnBkZXYtPmRl dik7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCBrM19iYW5kZ2Fw X3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwlwbV9ydW50aW1l X3B1dF9zeW5jKCZwZGV2LT5kZXYpOwo+ICsJcG1fcnVudGltZV9kaXNhYmxlKCZwZGV2LT5kZXYp Owo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGszX3Z0 bV9kcml2ZXJfZGF0YSBhbTY1NF9kYXRhID0gewo+ICsJLmVycmF0YSA9IDEsCj4gK307Cj4gKwo+ ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBvZl9rM19iYW5kZ2FwX21hdGNoW10g PSB7Cj4gKwl7Cj4gKwkJLmNvbXBhdGlibGUgPSAidGksYW02NTQtdnRtIiwKPiArCQkuZGF0YSA9 ICZhbTY1NF9kYXRhLAo+ICsJfSwKPiArCXsgLyogc2VudGluZWwgKi8gfSwKPiArfTsKPiArTU9E VUxFX0RFVklDRV9UQUJMRShvZiwgb2ZfazNfYmFuZGdhcF9tYXRjaCk7Cj4gKwo+ICtzdGF0aWMg c3RydWN0IHBsYXRmb3JtX2RyaXZlciBrM19iYW5kZ2FwX3NlbnNvcl9kcml2ZXIgPSB7Cj4gKwku cHJvYmUgPSBrM19iYW5kZ2FwX3Byb2JlLAo+ICsJLnJlbW92ZSA9IGszX2JhbmRnYXBfcmVtb3Zl LAo+ICsJLmRyaXZlciA9IHsKPiArCQkubmFtZSA9ICJrMy1zb2MtdGhlcm1hbCIsCj4gKwkJLm9m X21hdGNoX3RhYmxlCT0gb2ZfazNfYmFuZGdhcF9tYXRjaCwKPiArCX0sCj4gK307Cj4gKwo+ICtt b2R1bGVfcGxhdGZvcm1fZHJpdmVyKGszX2JhbmRnYXBfc2Vuc29yX2RyaXZlcik7Cj4gKwo+ICtN T0RVTEVfREVTQ1JJUFRJT04oIkszIGJhbmRnYXAgdGVtcGVyYXR1cmUgc2Vuc29yIGRyaXZlciIp Owo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Cj4gK01PRFVMRV9BVVRIT1IoIkogS2VlcnRo eSA8ai1rZWVydGh5QHRpLmNvbT4iKTsKPiAtLSAKPiAyLjE3LjEKPiAKCi0tIAoKIDxodHRwOi8v d3d3LmxpbmFyby5vcmcvPiBMaW5hcm8ub3JnIOKUgiBPcGVuIHNvdXJjZSBzb2Z0d2FyZSBmb3Ig QVJNIFNvQ3MKCkZvbGxvdyBMaW5hcm86ICA8aHR0cDovL3d3dy5mYWNlYm9vay5jb20vcGFnZXMv TGluYXJvPiBGYWNlYm9vayB8CjxodHRwOi8vdHdpdHRlci5jb20vIyEvbGluYXJvb3JnPiBUd2l0 dGVyIHwKPGh0dHA6Ly93d3cubGluYXJvLm9yZy9saW5hcm8tYmxvZy8+IEJsb2cKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwg bWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8v bGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK