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=-7.1 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,URIBL_BLOCKED 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 0B5E2C282DE for ; Thu, 23 May 2019 16:38:23 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C903221773 for ; Thu, 23 May 2019 16:38:22 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="xxuQx4Pm" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731207AbfEWQiW (ORCPT ); Thu, 23 May 2019 12:38:22 -0400 Received: from mail-wm1-f66.google.com ([209.85.128.66]:33236 "EHLO mail-wm1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730752AbfEWQiV (ORCPT ); Thu, 23 May 2019 12:38:21 -0400 Received: by mail-wm1-f66.google.com with SMTP id c66so7522113wme.0 for ; Thu, 23 May 2019 09:38:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=Uc/EZeoFWudzAAaizpZc7eAmy5xMsx8Uz2iUj7QK1iU=; b=xxuQx4PmAnDPT9Y12KQdAqxrHnAWLOJmILCkkXaiIfiO4lBiRonCFB+nWZ2INdQP6U EqSCbgJjK1tCZidcMH2CajpmE5eJ6LVCU1BRnCRlERChDPvN0ji+fxC6Pui30XJvTMXR EEuB+oz8oRraQX30DKyFPUlEIjJwECFJNtNX22ul5kBLN+K0KP8dJVyeQDg/sP5a9QMT iCT6caHMrsyteKdnltcEcgzzegmQj8HYcNWoHAqQt/goswJ/YBaZY9WloB+vwgM08NJA dJFNqi+VVX2ilFMJlc1S/H4WZv2lrYfGa7JAv6CqxbPPqTWhev8sACbGAqGkdRsFtqiE cSjw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=Uc/EZeoFWudzAAaizpZc7eAmy5xMsx8Uz2iUj7QK1iU=; b=UZVh8AgJJGpGQhk4rMwbJeg5bgZ/azmT9OWzXVI2ao6fFQOAora3aduqrNPu/UDld4 k4PwJLwcC0lGhtonubxeBlz+i1wHMbFjcUIGQARI/XDSI9ZxPL9CoDSxMlcSXg7fMF9H vp2pzEAJiMEcoaQ2T95bB/r4iMPQjOv+JCusjKIk3dlKFQpXEhdSGX60lf5oBsRNuT3m dcDyfeiuoF1QVv6VEQmVEjLYG9IhZBGqVNynb6MXd/fKwDCcUKxq63zEyOEUvTEwRXyL i3agc4M1Hgp3wGTU0YP0uj98RVnMyTelX6QWLYrJTgobQbAXORUpoRU3qHOzn7MZhHiO FN9A== X-Gm-Message-State: APjAAAWRu1XCoJeLeZExoikeOxXCDXw2Nxc98w6SaSamdbOmoBbU7QQ/ MbLOqk8shml19KCOjkiES90uNQ== X-Google-Smtp-Source: APXvYqwsh61PmjWJEGFJ6UHfJ+KqwQGNKlIWWaG+cRw1WBTYSoKmRqXzStwyuTej5U4VDuoqd2DD3g== X-Received: by 2002:a1c:9a83:: with SMTP id c125mr11609852wme.39.1558629497283; Thu, 23 May 2019 09:38:17 -0700 (PDT) Received: from [192.168.43.165] ([37.170.117.75]) by smtp.googlemail.com with ESMTPSA id s62sm21765wmf.24.2019.05.23.09.38.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 23 May 2019 09:38:16 -0700 (PDT) Subject: Re: [RFC v2 1/2] clocksource: davinci-timer: add support for clockevents To: Bartosz Golaszewski , Sekhar Nori , Kevin Hilman , Thomas Gleixner , David Lechner Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Bartosz Golaszewski References: <20190523125813.29506-1-brgl@bgdev.pl> <20190523125813.29506-2-brgl@bgdev.pl> From: Daniel Lezcano Message-ID: Date: Thu, 23 May 2019 18:38:14 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.6.1 MIME-Version: 1.0 In-Reply-To: <20190523125813.29506-2-brgl@bgdev.pl> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 23/05/2019 14:58, Bartosz Golaszewski wrote: > From: Bartosz Golaszewski > > Currently the clocksource and clockevent support for davinci platforms > lives in mach-davinci. It hard-codes many things, uses global variables, > implements functionalities unused by any platform and has code fragments > scattered across many (often unrelated) files. > > Implement a new, modern and simplified timer driver and put it into > drivers/clocksource. We still need to support legacy board files so > export a config structure and a function that allows machine code to > register the timer. > > The timer we're using is 64-bit but can be programmed in dual 32-bit > mode (both chained and unchained). We're using dual 32-bit mode to > have separate counters for clockevents and clocksource. > > This patch contains the core code and support for clockevent. The > clocksource code will be included in a subsequent patch. > > Signed-off-by: Bartosz Golaszewski > --- > drivers/clocksource/Kconfig | 5 + > drivers/clocksource/Makefile | 1 + > drivers/clocksource/timer-davinci.c | 285 ++++++++++++++++++++++++++++ > include/clocksource/timer-davinci.h | 44 +++++ > 4 files changed, 335 insertions(+) > create mode 100644 drivers/clocksource/timer-davinci.c > create mode 100644 include/clocksource/timer-davinci.h > > diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig > index 6bcaa4e2e72c..32dee6abd54a 100644 > --- a/drivers/clocksource/Kconfig > +++ b/drivers/clocksource/Kconfig > @@ -42,6 +42,11 @@ config BCM_KONA_TIMER > help > Enables the support for the BCM Kona mobile timer driver. > > +config DAVINCI_TIMER > + bool "Texas Instruments DaVinci timer driver" if COMPILE_TEST > + help > + Enables the support for the TI DaVinci timer driver. > + > config DIGICOLOR_TIMER > bool "Digicolor timer driver" if COMPILE_TEST > select CLKSRC_MMIO > diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile > index 236858fa7fbf..021831bcc567 100644 > --- a/drivers/clocksource/Makefile > +++ b/drivers/clocksource/Makefile > @@ -15,6 +15,7 @@ obj-$(CONFIG_SH_TIMER_TMU) += sh_tmu.o > obj-$(CONFIG_EM_TIMER_STI) += em_sti.o > obj-$(CONFIG_CLKBLD_I8253) += i8253.o > obj-$(CONFIG_CLKSRC_MMIO) += mmio.o > +obj-$(CONFIG_DAVINCI_TIMER) += timer-davinci.o > obj-$(CONFIG_DIGICOLOR_TIMER) += timer-digicolor.o > obj-$(CONFIG_OMAP_DM_TIMER) += timer-ti-dm.o > obj-$(CONFIG_DW_APB_TIMER) += dw_apb_timer.o > diff --git a/drivers/clocksource/timer-davinci.c b/drivers/clocksource/timer-davinci.c > new file mode 100644 > index 000000000000..a8fc7b3805c9 > --- /dev/null > +++ b/drivers/clocksource/timer-davinci.c > @@ -0,0 +1,285 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * TI DaVinci clocksource driver > + * > + * Copyright (C) 2019 Texas Instruments > + * Author: Bartosz Golaszewski > + * (with tiny parts adopted from code by Kevin Hilman ) > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#undef pr_fmt > +#define pr_fmt(fmt) "%s: " fmt "\n", __func__ > + > +#define DAVINCI_TIMER_REG_TIM12 0x10 > +#define DAVINCI_TIMER_REG_TIM34 0x14 > +#define DAVINCI_TIMER_REG_PRD12 0x18 > +#define DAVINCI_TIMER_REG_PRD34 0x1c > +#define DAVINCI_TIMER_REG_TCR 0x20 > +#define DAVINCI_TIMER_REG_TGCR 0x24 > + > +#define DAVINCI_TIMER_TIMMODE_MASK GENMASK(3, 2) > +#define DAVINCI_TIMER_RESET_MASK GENMASK(1, 0) > +#define DAVINCI_TIMER_TIMMODE_32BIT_UNCHAINED BIT(2) > +#define DAVINCI_TIMER_UNRESET GENMASK(1, 0) > + > +#define DAVINCI_TIMER_ENAMODE_MASK GENMASK(1, 0) > +#define DAVINCI_TIMER_ENAMODE_DISABLED 0x00 > +#define DAVINCI_TIMER_ENAMODE_ONESHOT BIT(0) > + > +#define DAVINCI_TIMER_ENAMODE_SHIFT_TIM12 6 > +#define DAVINCI_TIMER_ENAMODE_SHIFT_TIM34 22 > + > +#define DAVINCI_TIMER_MIN_DELTA 0x01 > +#define DAVINCI_TIMER_MAX_DELTA 0xfffffffe > + > +#define DAVINCI_TIMER_TGCR_DEFAULT \ > + (DAVINCI_TIMER_TIMMODE_32BIT_UNCHAINED | DAVINCI_TIMER_UNRESET) > + > +/* Cache the TCR register value. */ > +static unsigned int davinci_tcr; > + > +struct davinci_clockevent { > + struct clock_event_device dev; > + void __iomem *base; > + > + unsigned int tim_off; > + unsigned int prd_off; > + unsigned int cmp_off; > + > + unsigned int enamode_disabled; > + unsigned int enamode_oneshot; > + unsigned int enamode_mask; > +}; > + > +static struct davinci_clockevent * > +to_davinci_clockevent(struct clock_event_device *clockevent) > +{ > + return container_of(clockevent, struct davinci_clockevent, dev); > +} > + > +static unsigned int > +davinci_clockevent_read(struct davinci_clockevent *clockevent, > + unsigned int reg) > +{ > + return readl_relaxed(clockevent->base + reg); > +} > + > +static void davinci_clockevent_write(struct davinci_clockevent *clockevent, > + unsigned int reg, unsigned int val) > +{ > + writel_relaxed(val, clockevent->base + reg); > +} > + > +static void davinci_tcr_update(void __iomem *base, > + unsigned int mask, unsigned int val) > +{ > + davinci_tcr &= ~mask; > + davinci_tcr |= val & mask; I don't see when the davinci_tcr is initialized. > + writel_relaxed(davinci_tcr, base + DAVINCI_TIMER_REG_TCR); > +} > + > +static int davinci_clockevent_shutdown(struct clock_event_device *dev) > +{ > + struct davinci_clockevent *clockevent; > + > + clockevent = to_davinci_clockevent(dev); > + > + davinci_tcr_update(clockevent->base, > + clockevent->enamode_mask, > + clockevent->enamode_disabled); > + > + return 0; > +} > + > +static int davinci_clockevent_set_oneshot(struct clock_event_device *dev) > +{ > + struct davinci_clockevent *clockevent = to_davinci_clockevent(dev); > + > + davinci_clockevent_write(clockevent, clockevent->tim_off, 0x0); > + > + davinci_tcr_update(clockevent->base, > + clockevent->enamode_mask, > + clockevent->enamode_oneshot); > + > + return 0; > +} > + > +static int > +davinci_clockevent_set_next_event_std(unsigned long cycles, > + struct clock_event_device *dev) > +{ > + struct davinci_clockevent *clockevent = to_davinci_clockevent(dev); > + > + davinci_clockevent_shutdown(dev); > + > + davinci_clockevent_write(clockevent, clockevent->tim_off, 0x0); > + davinci_clockevent_write(clockevent, clockevent->prd_off, cycles); > + > + davinci_clockevent_set_oneshot(dev); > + > + return 0; > +} > + > +static int > +davinci_clockevent_set_next_event_cmp(unsigned long cycles, > + struct clock_event_device *dev) > +{ > + struct davinci_clockevent *clockevent = to_davinci_clockevent(dev); > + unsigned int curr_time; > + > + curr_time = davinci_clockevent_read(clockevent, clockevent->tim_off); > + davinci_clockevent_write(clockevent, > + clockevent->cmp_off, curr_time + cycles); > + > + return 0; > +} > + > +static irqreturn_t davinci_timer_irq_timer(int irq, void *data) > +{ > + struct davinci_clockevent *clockevent = data; > + > + if (!clockevent_state_oneshot(&clockevent->dev)) > + davinci_tcr_update(clockevent, > + clockevent->enamode_mask, > + clockevent->enamode_disabled); > + > + clockevent->dev.event_handler(&clockevent->dev); > + > + return IRQ_HANDLED; > +} > + > +static void davinci_timer_init(void __iomem *base) > +{ > + /* Set clock to internal mode and disable it. */ > + writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TCR); > + /* > + * Reset both 32-bit timers, set no prescaler for timer 34, set the > + * timer to dual 32-bit unchained mode, unreset both 32-bit timers. > + */ > + writel_relaxed(DAVINCI_TIMER_TGCR_DEFAULT, > + base + DAVINCI_TIMER_REG_TGCR); > + /* Init both counters to zero. */ > + writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TIM12); > + writel_relaxed(0x0, base + DAVINCI_TIMER_REG_TIM34); > +} > + > +int __init davinci_timer_register(struct clk *clk, > + const struct davinci_timer_cfg *timer_cfg) > +{ > + struct davinci_clockevent *clockevent; > + unsigned int tick_rate, shift; > + void __iomem *base; > + int rv; > + > + rv = clk_prepare_enable(clk); > + if (rv) { > + pr_err("Unable to prepare and enable the timer clock"); > + return rv; > + } > + > + base = request_mem_region(timer_cfg->reg.start, > + resource_size(&timer_cfg->reg), > + "davinci-timer"); > + if (!base) { > + pr_err("Unable to request memory region"); > + return -EBUSY; > + } > + > + base = ioremap(timer_cfg->reg.start, resource_size(&timer_cfg->reg)); > + if (!base) { > + pr_err("Unable to map the register range"); > + return -ENOMEM; > + } > + > + davinci_timer_init(base); > + tick_rate = clk_get_rate(clk); > + > + clockevent = kzalloc(sizeof(*clockevent), GFP_KERNEL); > + if (!clockevent) { > + pr_err("Error allocating memory for clockevent data"); > + return -ENOMEM; > + } > + > + clockevent->dev.name = "tim12"; > + clockevent->dev.features = CLOCK_EVT_FEAT_ONESHOT; > + clockevent->dev.cpumask = cpumask_of(0); > + > + clockevent->base = base; > + clockevent->tim_off = DAVINCI_TIMER_REG_TIM12; > + clockevent->prd_off = DAVINCI_TIMER_REG_PRD12; > + > + shift = DAVINCI_TIMER_ENAMODE_SHIFT_TIM12; > + clockevent->enamode_disabled = DAVINCI_TIMER_ENAMODE_DISABLED << shift; > + clockevent->enamode_oneshot = DAVINCI_TIMER_ENAMODE_ONESHOT << shift; > + clockevent->enamode_mask = DAVINCI_TIMER_ENAMODE_MASK << shift; > + > + clockevent->dev.set_state_shutdown = davinci_clockevent_shutdown; > + clockevent->dev.set_state_oneshot = davinci_clockevent_set_oneshot; > + > + if (timer_cfg->cmp_off) { > + clockevent->cmp_off = timer_cfg->cmp_off; > + clockevent->dev.set_next_event = > + davinci_clockevent_set_next_event_cmp; > + } else { > + clockevent->dev.set_next_event = > + davinci_clockevent_set_next_event_std; > + } > + > + rv = request_irq(timer_cfg->irq[DAVINCI_TIMER_CLOCKEVENT_IRQ].start, > + davinci_timer_irq_timer, IRQF_TIMER, > + "clockevent", clockevent); > + if (rv) { > + pr_err("Unable to request the clockevent interrupt"); > + return rv; > + } > + > + clockevents_config_and_register(&clockevent->dev, tick_rate, > + DAVINCI_TIMER_MIN_DELTA, > + DAVINCI_TIMER_MAX_DELTA); > + > + return 0; > +} > + > +static int __init of_davinci_timer_register(struct device_node *np) > +{ > + struct davinci_timer_cfg timer_cfg = { }; > + struct clk *clk; > + int rv; > + > + rv = of_address_to_resource(np, 0, &timer_cfg.reg); > + if (rv) { > + pr_err("Unable to get the register range for timer"); > + return rv; > + } > + > + rv = of_irq_to_resource_table(np, timer_cfg.irq, > + DAVINCI_TIMER_NUM_IRQS); > + if (rv != DAVINCI_TIMER_NUM_IRQS) { > + pr_err("Unable to get the interrupts for timer"); > + return rv; > + } > + > + clk = of_clk_get(np, 0); > + if (IS_ERR(clk)) { > + pr_err("Unable to get the timer clock"); > + return PTR_ERR(clk); > + } > + > + rv = davinci_timer_register(clk, &timer_cfg); > + if (rv) > + clk_put(clk); > + > + return rv; > +} > +TIMER_OF_DECLARE(davinci_timer, "ti,da830-timer", of_davinci_timer_register); > diff --git a/include/clocksource/timer-davinci.h b/include/clocksource/timer-davinci.h > new file mode 100644 > index 000000000000..1dcc1333fbc8 > --- /dev/null > +++ b/include/clocksource/timer-davinci.h > @@ -0,0 +1,44 @@ > +/* SPDX-License-Identifier: GPL-2.0-only */ > +/* > + * TI DaVinci clocksource driver > + * > + * Copyright (C) 2019 Texas Instruments > + * Author: Bartosz Golaszewski > + */ > + > +#ifndef __TIMER_DAVINCI_H__ > +#define __TIMER_DAVINCI_H__ > + > +#include > +#include > + > +enum { > + DAVINCI_TIMER_CLOCKEVENT_IRQ, > + DAVINCI_TIMER_CLOCKSOURCE_IRQ, > + DAVINCI_TIMER_NUM_IRQS, > +}; > + > +/** > + * struct davinci_timer_cfg - davinci clocksource driver configuration struct > + * @reg: register range resource > + * @irq: clockevent and clocksource interrupt resources > + * @cmp_off: if set - it specifies the compare register used for clockevent > + * > + * Note: if the compare register is specified, the driver will use the bottom > + * clock half for both clocksource and clockevent and the compare register > + * to generate event irqs. The user must supply the correct compare register > + * interrupt number. > + * > + * This is only used by da830 the DSP of which uses the top half. The timer > + * driver still configures the top half to run in free-run mode. > + */ > +struct davinci_timer_cfg { > + struct resource reg; > + struct resource irq[DAVINCI_TIMER_NUM_IRQS]; > + unsigned int cmp_off; > +}; > + > +int __init davinci_timer_register(struct clk *clk, > + const struct davinci_timer_cfg *data); > + > +#endif /* __TIMER_DAVINCI_H__ */ > -- 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=-7.0 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,T_DKIMWL_WL_HIGH,URIBL_BLOCKED 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 BBF2EC282DD for ; Thu, 23 May 2019 16:38:40 +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 8C15021773 for ; Thu, 23 May 2019 16:38:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="TtxM4nA9"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="xxuQx4Pm" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8C15021773 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:Date: Message-ID:From:References:To:Subject:Reply-To:Content-ID:Content-Description :Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Mg01tOP3+O1UxGXze5jSCTrzljfSoBZ4mukpLXjPtuI=; b=TtxM4nA9h7cncl 7v0gzUY7/Xc0JXXvF96SsHNxKyAmUxJ+efg3MOhjISdkFpFG+SKpeYVT3mZOrYirEEZMi5/AbPLUH +djAU5YY0OOmB4jdXkCOWnJq8r6jjgWfgy+qCH0zt4VjGZlwE4b/ueYv1hTSqIC2Zi1m2DwABnbOb Rs48NSw0Y2ZOQPjmu5d5iZhP2n4/NXmsNON0J9p2TmPdGFeBmax+lQ8wMwDULgVXRhw50guy7dCGB aQlwgnX0Tv8NoUMHWFvOaDw4FV653kirxfCVggVniB+7UV2Hx8Tk6MWyV6ETDctuuR66mwNFYl8cF Yw233gJ2Ux6i+NtIyE9g==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1hTqjh-0004kS-Br; Thu, 23 May 2019 16:38:33 +0000 Received: from mail-wm1-x343.google.com ([2a00:1450:4864:20::343]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1hTqjT-0004ar-C2 for linux-arm-kernel@lists.infradead.org; Thu, 23 May 2019 16:38:24 +0000 Received: by mail-wm1-x343.google.com with SMTP id 198so6536533wme.3 for ; Thu, 23 May 2019 09:38:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=Uc/EZeoFWudzAAaizpZc7eAmy5xMsx8Uz2iUj7QK1iU=; b=xxuQx4PmAnDPT9Y12KQdAqxrHnAWLOJmILCkkXaiIfiO4lBiRonCFB+nWZ2INdQP6U EqSCbgJjK1tCZidcMH2CajpmE5eJ6LVCU1BRnCRlERChDPvN0ji+fxC6Pui30XJvTMXR EEuB+oz8oRraQX30DKyFPUlEIjJwECFJNtNX22ul5kBLN+K0KP8dJVyeQDg/sP5a9QMT iCT6caHMrsyteKdnltcEcgzzegmQj8HYcNWoHAqQt/goswJ/YBaZY9WloB+vwgM08NJA dJFNqi+VVX2ilFMJlc1S/H4WZv2lrYfGa7JAv6CqxbPPqTWhev8sACbGAqGkdRsFtqiE cSjw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=Uc/EZeoFWudzAAaizpZc7eAmy5xMsx8Uz2iUj7QK1iU=; b=qR3oBzoZ9hFL4SgsU473SmbyepbVxQMpqdnU+C0Qy+uHTc9lEJ7DCz3fZy6GN6fVtv yrEBAUa90A8zlrw8STtq+csZAoYKrQZoEuw0IwzKcfh9rx5H6uXSSk/RcX+VS03d9Nkl hrASZg3NEgQJrRQx9mEoliGeSCa7HEx641eeyY7JKi8SqWnsfIjDb+IczZoVMhiOw50Q U5/ax5A9CkDe5hM+8k/Eb2iZb823e8lUzIC/l3b83ayV3lEYVsc93yC7l9i4G8x+tcrd 8bAOByc0JiFglrqCDSMm+Cx19taAq2Ay3K85JsufpTNdpV1kmdVT0+mtxavfbhmX/79r B1NQ== X-Gm-Message-State: APjAAAV0Jjpi3ZS861XQjmVNJb0H2Wg9xKPiSrUHHK71mBdpg5F+86oj 0oAyPqm4QAstxlzOecE12LDrgQ== X-Google-Smtp-Source: APXvYqwsh61PmjWJEGFJ6UHfJ+KqwQGNKlIWWaG+cRw1WBTYSoKmRqXzStwyuTej5U4VDuoqd2DD3g== X-Received: by 2002:a1c:9a83:: with SMTP id c125mr11609852wme.39.1558629497283; Thu, 23 May 2019 09:38:17 -0700 (PDT) Received: from [192.168.43.165] ([37.170.117.75]) by smtp.googlemail.com with ESMTPSA id s62sm21765wmf.24.2019.05.23.09.38.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 23 May 2019 09:38:16 -0700 (PDT) Subject: Re: [RFC v2 1/2] clocksource: davinci-timer: add support for clockevents To: Bartosz Golaszewski , Sekhar Nori , Kevin Hilman , Thomas Gleixner , David Lechner References: <20190523125813.29506-1-brgl@bgdev.pl> <20190523125813.29506-2-brgl@bgdev.pl> From: Daniel Lezcano Message-ID: Date: Thu, 23 May 2019 18:38:14 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.6.1 MIME-Version: 1.0 In-Reply-To: <20190523125813.29506-2-brgl@bgdev.pl> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190523_093822_352392_73ECB00F X-CRM114-Status: GOOD ( 34.01 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Bartosz Golaszewski , linux-kernel@vger.kernel.org, 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 T24gMjMvMDUvMjAxOSAxNDo1OCwgQmFydG9zeiBHb2xhc3pld3NraSB3cm90ZToKPiBGcm9tOiBC YXJ0b3N6IEdvbGFzemV3c2tpIDxiZ29sYXN6ZXdza2lAYmF5bGlicmUuY29tPgo+IAo+IEN1cnJl bnRseSB0aGUgY2xvY2tzb3VyY2UgYW5kIGNsb2NrZXZlbnQgc3VwcG9ydCBmb3IgZGF2aW5jaSBw bGF0Zm9ybXMKPiBsaXZlcyBpbiBtYWNoLWRhdmluY2kuIEl0IGhhcmQtY29kZXMgbWFueSB0aGlu Z3MsIHVzZXMgZ2xvYmFsIHZhcmlhYmxlcywKPiBpbXBsZW1lbnRzIGZ1bmN0aW9uYWxpdGllcyB1 bnVzZWQgYnkgYW55IHBsYXRmb3JtIGFuZCBoYXMgY29kZSBmcmFnbWVudHMKPiBzY2F0dGVyZWQg YWNyb3NzIG1hbnkgKG9mdGVuIHVucmVsYXRlZCkgZmlsZXMuCj4gCj4gSW1wbGVtZW50IGEgbmV3 LCBtb2Rlcm4gYW5kIHNpbXBsaWZpZWQgdGltZXIgZHJpdmVyIGFuZCBwdXQgaXQgaW50bwo+IGRy aXZlcnMvY2xvY2tzb3VyY2UuIFdlIHN0aWxsIG5lZWQgdG8gc3VwcG9ydCBsZWdhY3kgYm9hcmQg ZmlsZXMgc28KPiBleHBvcnQgYSBjb25maWcgc3RydWN0dXJlIGFuZCBhIGZ1bmN0aW9uIHRoYXQg YWxsb3dzIG1hY2hpbmUgY29kZSB0bwo+IHJlZ2lzdGVyIHRoZSB0aW1lci4KPiAKPiBUaGUgdGlt ZXIgd2UncmUgdXNpbmcgaXMgNjQtYml0IGJ1dCBjYW4gYmUgcHJvZ3JhbW1lZCBpbiBkdWFsIDMy LWJpdAo+IG1vZGUgKGJvdGggY2hhaW5lZCBhbmQgdW5jaGFpbmVkKS4gV2UncmUgdXNpbmcgZHVh bCAzMi1iaXQgbW9kZSB0bwo+IGhhdmUgc2VwYXJhdGUgY291bnRlcnMgZm9yIGNsb2NrZXZlbnRz IGFuZCBjbG9ja3NvdXJjZS4KPiAKPiBUaGlzIHBhdGNoIGNvbnRhaW5zIHRoZSBjb3JlIGNvZGUg YW5kIHN1cHBvcnQgZm9yIGNsb2NrZXZlbnQuIFRoZQo+IGNsb2Nrc291cmNlIGNvZGUgd2lsbCBi ZSBpbmNsdWRlZCBpbiBhIHN1YnNlcXVlbnQgcGF0Y2guCj4gCj4gU2lnbmVkLW9mZi1ieTogQmFy dG9zeiBHb2xhc3pld3NraSA8YmdvbGFzemV3c2tpQGJheWxpYnJlLmNvbT4KPiAtLS0KPiAgZHJp dmVycy9jbG9ja3NvdXJjZS9LY29uZmlnICAgICAgICAgfCAgIDUgKwo+ICBkcml2ZXJzL2Nsb2Nr c291cmNlL01ha2VmaWxlICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvY2xvY2tzb3VyY2UvdGlt ZXItZGF2aW5jaS5jIHwgMjg1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgaW5jbHVk ZS9jbG9ja3NvdXJjZS90aW1lci1kYXZpbmNpLmggfCAgNDQgKysrKysKPiAgNCBmaWxlcyBjaGFu Z2VkLCAzMzUgaW5zZXJ0aW9ucygrKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9jbG9j a3NvdXJjZS90aW1lci1kYXZpbmNpLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvY2xv Y2tzb3VyY2UvdGltZXItZGF2aW5jaS5oCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xvY2tz b3VyY2UvS2NvbmZpZyBiL2RyaXZlcnMvY2xvY2tzb3VyY2UvS2NvbmZpZwo+IGluZGV4IDZiY2Fh NGUyZTcyYy4uMzJkZWU2YWJkNTRhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvY2xvY2tzb3VyY2Uv S2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvY2xvY2tzb3VyY2UvS2NvbmZpZwo+IEBAIC00Miw2ICs0 MiwxMSBAQCBjb25maWcgQkNNX0tPTkFfVElNRVIKPiAgCWhlbHAKPiAgCSAgRW5hYmxlcyB0aGUg c3VwcG9ydCBmb3IgdGhlIEJDTSBLb25hIG1vYmlsZSB0aW1lciBkcml2ZXIuCj4gIAo+ICtjb25m aWcgREFWSU5DSV9USU1FUgo+ICsJYm9vbCAiVGV4YXMgSW5zdHJ1bWVudHMgRGFWaW5jaSB0aW1l ciBkcml2ZXIiIGlmIENPTVBJTEVfVEVTVAo+ICsJaGVscAo+ICsJICBFbmFibGVzIHRoZSBzdXBw b3J0IGZvciB0aGUgVEkgRGFWaW5jaSB0aW1lciBkcml2ZXIuCj4gKwo+ICBjb25maWcgRElHSUNP TE9SX1RJTUVSCj4gIAlib29sICJEaWdpY29sb3IgdGltZXIgZHJpdmVyIiBpZiBDT01QSUxFX1RF U1QKPiAgCXNlbGVjdCBDTEtTUkNfTU1JTwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsb2Nrc291 cmNlL01ha2VmaWxlIGIvZHJpdmVycy9jbG9ja3NvdXJjZS9NYWtlZmlsZQo+IGluZGV4IDIzNjg1 OGZhN2ZiZi4uMDIxODMxYmNjNTY3IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvY2xvY2tzb3VyY2Uv TWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2Nsb2Nrc291cmNlL01ha2VmaWxlCj4gQEAgLTE1LDYg KzE1LDcgQEAgb2JqLSQoQ09ORklHX1NIX1RJTUVSX1RNVSkJKz0gc2hfdG11Lm8KPiAgb2JqLSQo Q09ORklHX0VNX1RJTUVSX1NUSSkJKz0gZW1fc3RpLm8KPiAgb2JqLSQoQ09ORklHX0NMS0JMRF9J ODI1MykJKz0gaTgyNTMubwo+ICBvYmotJChDT05GSUdfQ0xLU1JDX01NSU8pCSs9IG1taW8ubwo+ ICtvYmotJChDT05GSUdfREFWSU5DSV9USU1FUikJKz0gdGltZXItZGF2aW5jaS5vCj4gIG9iai0k KENPTkZJR19ESUdJQ09MT1JfVElNRVIpCSs9IHRpbWVyLWRpZ2ljb2xvci5vCj4gIG9iai0kKENP TkZJR19PTUFQX0RNX1RJTUVSKQkrPSB0aW1lci10aS1kbS5vCj4gIG9iai0kKENPTkZJR19EV19B UEJfVElNRVIpCSs9IGR3X2FwYl90aW1lci5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xvY2tz b3VyY2UvdGltZXItZGF2aW5jaS5jIGIvZHJpdmVycy9jbG9ja3NvdXJjZS90aW1lci1kYXZpbmNp LmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uYThmYzdiMzgw NWM5Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvY2xvY2tzb3VyY2UvdGltZXItZGF2 aW5jaS5jCj4gQEAgLTAsMCArMSwyODUgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAtb25seQo+ICsvKgo+ICsgKiBUSSBEYVZpbmNpIGNsb2Nrc291cmNlIGRyaXZlcgo+ ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTkgVGV4YXMgSW5zdHJ1bWVudHMKPiArICogQXV0 aG9yOiBCYXJ0b3N6IEdvbGFzemV3c2tpIDxiZ29sYXN6ZXdza2lAYmF5bGlicmUuY29tPgo+ICsg KiAod2l0aCB0aW55IHBhcnRzIGFkb3B0ZWQgZnJvbSBjb2RlIGJ5IEtldmluIEhpbG1hbiA8a2hp bG1hbkBiYXlsaWJyZS5jb20+KQo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4K PiArI2luY2x1ZGUgPGxpbnV4L2Nsb2NrY2hpcHMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2ludGVy cnVwdC5oPgo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9v Zl9hZGRyZXNzLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZl9pcnEuaD4KPiArI2luY2x1ZGUgPGxp bnV4L3NjaGVkX2Nsb2NrLmg+Cj4gKwo+ICsjaW5jbHVkZSA8Y2xvY2tzb3VyY2UvdGltZXItZGF2 aW5jaS5oPgo+ICsKPiArI3VuZGVmIHByX2ZtdAo+ICsjZGVmaW5lIHByX2ZtdChmbXQpICIlczog IiBmbXQgIlxuIiwgX19mdW5jX18KPiArCj4gKyNkZWZpbmUgREFWSU5DSV9USU1FUl9SRUdfVElN MTIJCQkweDEwCj4gKyNkZWZpbmUgREFWSU5DSV9USU1FUl9SRUdfVElNMzQJCQkweDE0Cj4gKyNk ZWZpbmUgREFWSU5DSV9USU1FUl9SRUdfUFJEMTIJCQkweDE4Cj4gKyNkZWZpbmUgREFWSU5DSV9U SU1FUl9SRUdfUFJEMzQJCQkweDFjCj4gKyNkZWZpbmUgREFWSU5DSV9USU1FUl9SRUdfVENSCQkJ MHgyMAo+ICsjZGVmaW5lIERBVklOQ0lfVElNRVJfUkVHX1RHQ1IJCQkweDI0Cj4gKwo+ICsjZGVm aW5lIERBVklOQ0lfVElNRVJfVElNTU9ERV9NQVNLCQlHRU5NQVNLKDMsIDIpCj4gKyNkZWZpbmUg REFWSU5DSV9USU1FUl9SRVNFVF9NQVNLCQlHRU5NQVNLKDEsIDApCj4gKyNkZWZpbmUgREFWSU5D SV9USU1FUl9USU1NT0RFXzMyQklUX1VOQ0hBSU5FRAlCSVQoMikKPiArI2RlZmluZSBEQVZJTkNJ X1RJTUVSX1VOUkVTRVQJCQlHRU5NQVNLKDEsIDApCj4gKwo+ICsjZGVmaW5lIERBVklOQ0lfVElN RVJfRU5BTU9ERV9NQVNLCQlHRU5NQVNLKDEsIDApCj4gKyNkZWZpbmUgREFWSU5DSV9USU1FUl9F TkFNT0RFX0RJU0FCTEVECQkweDAwCj4gKyNkZWZpbmUgREFWSU5DSV9USU1FUl9FTkFNT0RFX09O RVNIT1QJCUJJVCgwKQo+ICsKPiArI2RlZmluZSBEQVZJTkNJX1RJTUVSX0VOQU1PREVfU0hJRlRf VElNMTIJNgo+ICsjZGVmaW5lIERBVklOQ0lfVElNRVJfRU5BTU9ERV9TSElGVF9USU0zNAkyMgo+ ICsKPiArI2RlZmluZSBEQVZJTkNJX1RJTUVSX01JTl9ERUxUQQkJCTB4MDEKPiArI2RlZmluZSBE QVZJTkNJX1RJTUVSX01BWF9ERUxUQQkJCTB4ZmZmZmZmZmUKPiArCj4gKyNkZWZpbmUgREFWSU5D SV9USU1FUl9UR0NSX0RFRkFVTFQgXAo+ICsJCShEQVZJTkNJX1RJTUVSX1RJTU1PREVfMzJCSVRf VU5DSEFJTkVEIHwgREFWSU5DSV9USU1FUl9VTlJFU0VUKQo+ICsKPiArLyogQ2FjaGUgdGhlIFRD UiByZWdpc3RlciB2YWx1ZS4gKi8KPiArc3RhdGljIHVuc2lnbmVkIGludCBkYXZpbmNpX3RjcjsK PiArCj4gK3N0cnVjdCBkYXZpbmNpX2Nsb2NrZXZlbnQgewo+ICsJc3RydWN0IGNsb2NrX2V2ZW50 X2RldmljZSBkZXY7Cj4gKwl2b2lkIF9faW9tZW0gKmJhc2U7Cj4gKwo+ICsJdW5zaWduZWQgaW50 IHRpbV9vZmY7Cj4gKwl1bnNpZ25lZCBpbnQgcHJkX29mZjsKPiArCXVuc2lnbmVkIGludCBjbXBf b2ZmOwo+ICsKPiArCXVuc2lnbmVkIGludCBlbmFtb2RlX2Rpc2FibGVkOwo+ICsJdW5zaWduZWQg aW50IGVuYW1vZGVfb25lc2hvdDsKPiArCXVuc2lnbmVkIGludCBlbmFtb2RlX21hc2s7Cj4gK307 Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGRhdmluY2lfY2xvY2tldmVudCAqCj4gK3RvX2RhdmluY2lf Y2xvY2tldmVudChzdHJ1Y3QgY2xvY2tfZXZlbnRfZGV2aWNlICpjbG9ja2V2ZW50KQo+ICt7Cj4g KwlyZXR1cm4gY29udGFpbmVyX29mKGNsb2NrZXZlbnQsIHN0cnVjdCBkYXZpbmNpX2Nsb2NrZXZl bnQsIGRldik7Cj4gK30KPiArCj4gK3N0YXRpYyB1bnNpZ25lZCBpbnQKPiArZGF2aW5jaV9jbG9j a2V2ZW50X3JlYWQoc3RydWN0IGRhdmluY2lfY2xvY2tldmVudCAqY2xvY2tldmVudCwKPiArCQkJ dW5zaWduZWQgaW50IHJlZykKPiArewo+ICsJcmV0dXJuIHJlYWRsX3JlbGF4ZWQoY2xvY2tldmVu dC0+YmFzZSArIHJlZyk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGRhdmluY2lfY2xvY2tldmVu dF93cml0ZShzdHJ1Y3QgZGF2aW5jaV9jbG9ja2V2ZW50ICpjbG9ja2V2ZW50LAo+ICsJCQkJICAg ICB1bnNpZ25lZCBpbnQgcmVnLCB1bnNpZ25lZCBpbnQgdmFsKQo+ICt7Cj4gKwl3cml0ZWxfcmVs YXhlZCh2YWwsIGNsb2NrZXZlbnQtPmJhc2UgKyByZWcpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9p ZCBkYXZpbmNpX3Rjcl91cGRhdGUodm9pZCBfX2lvbWVtICpiYXNlLAo+ICsJCQkgICAgICAgdW5z aWduZWQgaW50IG1hc2ssIHVuc2lnbmVkIGludCB2YWwpCj4gK3sKPiArCWRhdmluY2lfdGNyICY9 IH5tYXNrOwo+ICsJZGF2aW5jaV90Y3IgfD0gdmFsICYgbWFzazsKCgpJIGRvbid0IHNlZSB3aGVu IHRoZSBkYXZpbmNpX3RjciBpcyBpbml0aWFsaXplZC4KCj4gKwl3cml0ZWxfcmVsYXhlZChkYXZp bmNpX3RjciwgYmFzZSArIERBVklOQ0lfVElNRVJfUkVHX1RDUik7Cj4gK30KPiArCj4gK3N0YXRp YyBpbnQgZGF2aW5jaV9jbG9ja2V2ZW50X3NodXRkb3duKHN0cnVjdCBjbG9ja19ldmVudF9kZXZp Y2UgKmRldikKPiArewo+ICsJc3RydWN0IGRhdmluY2lfY2xvY2tldmVudCAqY2xvY2tldmVudDsK PiArCj4gKwljbG9ja2V2ZW50ID0gdG9fZGF2aW5jaV9jbG9ja2V2ZW50KGRldik7Cj4gKwo+ICsJ ZGF2aW5jaV90Y3JfdXBkYXRlKGNsb2NrZXZlbnQtPmJhc2UsCj4gKwkJCSAgIGNsb2NrZXZlbnQt PmVuYW1vZGVfbWFzaywKPiArCQkJICAgY2xvY2tldmVudC0+ZW5hbW9kZV9kaXNhYmxlZCk7Cj4g Kwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgZGF2aW5jaV9jbG9ja2V2ZW50 X3NldF9vbmVzaG90KHN0cnVjdCBjbG9ja19ldmVudF9kZXZpY2UgKmRldikKPiArewo+ICsJc3Ry dWN0IGRhdmluY2lfY2xvY2tldmVudCAqY2xvY2tldmVudCA9IHRvX2RhdmluY2lfY2xvY2tldmVu dChkZXYpOwo+ICsKPiArCWRhdmluY2lfY2xvY2tldmVudF93cml0ZShjbG9ja2V2ZW50LCBjbG9j a2V2ZW50LT50aW1fb2ZmLCAweDApOwo+ICsKPiArCWRhdmluY2lfdGNyX3VwZGF0ZShjbG9ja2V2 ZW50LT5iYXNlLAo+ICsJCQkgICBjbG9ja2V2ZW50LT5lbmFtb2RlX21hc2ssCj4gKwkJCSAgIGNs b2NrZXZlbnQtPmVuYW1vZGVfb25lc2hvdCk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQKPiArZGF2aW5jaV9jbG9ja2V2ZW50X3NldF9uZXh0X2V2ZW50X3N0ZCh1bnNp Z25lZCBsb25nIGN5Y2xlcywKPiArCQkJCSAgICAgIHN0cnVjdCBjbG9ja19ldmVudF9kZXZpY2Ug KmRldikKPiArewo+ICsJc3RydWN0IGRhdmluY2lfY2xvY2tldmVudCAqY2xvY2tldmVudCA9IHRv X2RhdmluY2lfY2xvY2tldmVudChkZXYpOwo+ICsKPiArCWRhdmluY2lfY2xvY2tldmVudF9zaHV0 ZG93bihkZXYpOwo+ICsKPiArCWRhdmluY2lfY2xvY2tldmVudF93cml0ZShjbG9ja2V2ZW50LCBj bG9ja2V2ZW50LT50aW1fb2ZmLCAweDApOwo+ICsJZGF2aW5jaV9jbG9ja2V2ZW50X3dyaXRlKGNs b2NrZXZlbnQsIGNsb2NrZXZlbnQtPnByZF9vZmYsIGN5Y2xlcyk7Cj4gKwo+ICsJZGF2aW5jaV9j bG9ja2V2ZW50X3NldF9vbmVzaG90KGRldik7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQKPiArZGF2aW5jaV9jbG9ja2V2ZW50X3NldF9uZXh0X2V2ZW50X2NtcCh1bnNp Z25lZCBsb25nIGN5Y2xlcywKPiArCQkJCSAgICAgIHN0cnVjdCBjbG9ja19ldmVudF9kZXZpY2Ug KmRldikKPiArewo+ICsJc3RydWN0IGRhdmluY2lfY2xvY2tldmVudCAqY2xvY2tldmVudCA9IHRv X2RhdmluY2lfY2xvY2tldmVudChkZXYpOwo+ICsJdW5zaWduZWQgaW50IGN1cnJfdGltZTsKPiAr Cj4gKwljdXJyX3RpbWUgPSBkYXZpbmNpX2Nsb2NrZXZlbnRfcmVhZChjbG9ja2V2ZW50LCBjbG9j a2V2ZW50LT50aW1fb2ZmKTsKPiArCWRhdmluY2lfY2xvY2tldmVudF93cml0ZShjbG9ja2V2ZW50 LAo+ICsJCQkJIGNsb2NrZXZlbnQtPmNtcF9vZmYsIGN1cnJfdGltZSArIGN5Y2xlcyk7Cj4gKwo+ ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpcnFyZXR1cm5fdCBkYXZpbmNpX3RpbWVy X2lycV90aW1lcihpbnQgaXJxLCB2b2lkICpkYXRhKQo+ICt7Cj4gKwlzdHJ1Y3QgZGF2aW5jaV9j bG9ja2V2ZW50ICpjbG9ja2V2ZW50ID0gZGF0YTsKPiArCj4gKwlpZiAoIWNsb2NrZXZlbnRfc3Rh dGVfb25lc2hvdCgmY2xvY2tldmVudC0+ZGV2KSkKPiArCQlkYXZpbmNpX3Rjcl91cGRhdGUoY2xv Y2tldmVudCwKPiArCQkJCSAgIGNsb2NrZXZlbnQtPmVuYW1vZGVfbWFzaywKPiArCQkJCSAgIGNs b2NrZXZlbnQtPmVuYW1vZGVfZGlzYWJsZWQpOwo+ICsKPiArCWNsb2NrZXZlbnQtPmRldi5ldmVu dF9oYW5kbGVyKCZjbG9ja2V2ZW50LT5kZXYpOwo+ICsKPiArCXJldHVybiBJUlFfSEFORExFRDsK PiArfQo+ICsKPiArc3RhdGljIHZvaWQgZGF2aW5jaV90aW1lcl9pbml0KHZvaWQgX19pb21lbSAq YmFzZSkKPiArewo+ICsJLyogU2V0IGNsb2NrIHRvIGludGVybmFsIG1vZGUgYW5kIGRpc2FibGUg aXQuICovCj4gKwl3cml0ZWxfcmVsYXhlZCgweDAsIGJhc2UgKyBEQVZJTkNJX1RJTUVSX1JFR19U Q1IpOwo+ICsJLyoKPiArCSAqIFJlc2V0IGJvdGggMzItYml0IHRpbWVycywgc2V0IG5vIHByZXNj YWxlciBmb3IgdGltZXIgMzQsIHNldCB0aGUKPiArCSAqIHRpbWVyIHRvIGR1YWwgMzItYml0IHVu Y2hhaW5lZCBtb2RlLCB1bnJlc2V0IGJvdGggMzItYml0IHRpbWVycy4KPiArCSAqLwo+ICsJd3Jp dGVsX3JlbGF4ZWQoREFWSU5DSV9USU1FUl9UR0NSX0RFRkFVTFQsCj4gKwkJICAgICAgIGJhc2Ug KyBEQVZJTkNJX1RJTUVSX1JFR19UR0NSKTsKPiArCS8qIEluaXQgYm90aCBjb3VudGVycyB0byB6 ZXJvLiAqLwo+ICsJd3JpdGVsX3JlbGF4ZWQoMHgwLCBiYXNlICsgREFWSU5DSV9USU1FUl9SRUdf VElNMTIpOwo+ICsJd3JpdGVsX3JlbGF4ZWQoMHgwLCBiYXNlICsgREFWSU5DSV9USU1FUl9SRUdf VElNMzQpOwo+ICt9Cj4gKwo+ICtpbnQgX19pbml0IGRhdmluY2lfdGltZXJfcmVnaXN0ZXIoc3Ry dWN0IGNsayAqY2xrLAo+ICsJCQkJICBjb25zdCBzdHJ1Y3QgZGF2aW5jaV90aW1lcl9jZmcgKnRp bWVyX2NmZykKPiArewo+ICsJc3RydWN0IGRhdmluY2lfY2xvY2tldmVudCAqY2xvY2tldmVudDsK PiArCXVuc2lnbmVkIGludCB0aWNrX3JhdGUsIHNoaWZ0Owo+ICsJdm9pZCBfX2lvbWVtICpiYXNl Owo+ICsJaW50IHJ2Owo+ICsKPiArCXJ2ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGNsayk7Cj4gKwlp ZiAocnYpIHsKPiArCQlwcl9lcnIoIlVuYWJsZSB0byBwcmVwYXJlIGFuZCBlbmFibGUgdGhlIHRp bWVyIGNsb2NrIik7Cj4gKwkJcmV0dXJuIHJ2Owo+ICsJfQo+ICsKPiArCWJhc2UgPSByZXF1ZXN0 X21lbV9yZWdpb24odGltZXJfY2ZnLT5yZWcuc3RhcnQsCj4gKwkJCQkgIHJlc291cmNlX3NpemUo JnRpbWVyX2NmZy0+cmVnKSwKPiArCQkJCSAgImRhdmluY2ktdGltZXIiKTsKPiArCWlmICghYmFz ZSkgewo+ICsJCXByX2VycigiVW5hYmxlIHRvIHJlcXVlc3QgbWVtb3J5IHJlZ2lvbiIpOwo+ICsJ CXJldHVybiAtRUJVU1k7Cj4gKwl9Cj4gKwo+ICsJYmFzZSA9IGlvcmVtYXAodGltZXJfY2ZnLT5y ZWcuc3RhcnQsIHJlc291cmNlX3NpemUoJnRpbWVyX2NmZy0+cmVnKSk7Cj4gKwlpZiAoIWJhc2Up IHsKPiArCQlwcl9lcnIoIlVuYWJsZSB0byBtYXAgdGhlIHJlZ2lzdGVyIHJhbmdlIik7Cj4gKwkJ cmV0dXJuIC1FTk9NRU07Cj4gKwl9Cj4gKwo+ICsJZGF2aW5jaV90aW1lcl9pbml0KGJhc2UpOwo+ ICsJdGlja19yYXRlID0gY2xrX2dldF9yYXRlKGNsayk7Cj4gKwo+ICsJY2xvY2tldmVudCA9IGt6 YWxsb2Moc2l6ZW9mKCpjbG9ja2V2ZW50KSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIWNsb2NrZXZl bnQpIHsKPiArCQlwcl9lcnIoIkVycm9yIGFsbG9jYXRpbmcgbWVtb3J5IGZvciBjbG9ja2V2ZW50 IGRhdGEiKTsKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCX0KPiArCj4gKwljbG9ja2V2ZW50LT5k ZXYubmFtZSA9ICJ0aW0xMiI7Cj4gKwljbG9ja2V2ZW50LT5kZXYuZmVhdHVyZXMgPSBDTE9DS19F VlRfRkVBVF9PTkVTSE9UOwo+ICsJY2xvY2tldmVudC0+ZGV2LmNwdW1hc2sgPSBjcHVtYXNrX29m KDApOwo+ICsKPiArCWNsb2NrZXZlbnQtPmJhc2UgPSBiYXNlOwo+ICsJY2xvY2tldmVudC0+dGlt X29mZiA9IERBVklOQ0lfVElNRVJfUkVHX1RJTTEyOwo+ICsJY2xvY2tldmVudC0+cHJkX29mZiA9 IERBVklOQ0lfVElNRVJfUkVHX1BSRDEyOwo+ICsKPiArCXNoaWZ0ID0gREFWSU5DSV9USU1FUl9F TkFNT0RFX1NISUZUX1RJTTEyOwo+ICsJY2xvY2tldmVudC0+ZW5hbW9kZV9kaXNhYmxlZCA9IERB VklOQ0lfVElNRVJfRU5BTU9ERV9ESVNBQkxFRCA8PCBzaGlmdDsKPiArCWNsb2NrZXZlbnQtPmVu YW1vZGVfb25lc2hvdCA9IERBVklOQ0lfVElNRVJfRU5BTU9ERV9PTkVTSE9UIDw8IHNoaWZ0Owo+ ICsJY2xvY2tldmVudC0+ZW5hbW9kZV9tYXNrID0gREFWSU5DSV9USU1FUl9FTkFNT0RFX01BU0sg PDwgc2hpZnQ7Cj4gKwo+ICsJY2xvY2tldmVudC0+ZGV2LnNldF9zdGF0ZV9zaHV0ZG93biA9IGRh dmluY2lfY2xvY2tldmVudF9zaHV0ZG93bjsKPiArCWNsb2NrZXZlbnQtPmRldi5zZXRfc3RhdGVf b25lc2hvdCA9IGRhdmluY2lfY2xvY2tldmVudF9zZXRfb25lc2hvdDsKPiArCj4gKwlpZiAodGlt ZXJfY2ZnLT5jbXBfb2ZmKSB7Cj4gKwkJY2xvY2tldmVudC0+Y21wX29mZiA9IHRpbWVyX2NmZy0+ Y21wX29mZjsKPiArCQljbG9ja2V2ZW50LT5kZXYuc2V0X25leHRfZXZlbnQgPQo+ICsJCQkJZGF2 aW5jaV9jbG9ja2V2ZW50X3NldF9uZXh0X2V2ZW50X2NtcDsKPiArCX0gZWxzZSB7Cj4gKwkJY2xv Y2tldmVudC0+ZGV2LnNldF9uZXh0X2V2ZW50ID0KPiArCQkJCWRhdmluY2lfY2xvY2tldmVudF9z ZXRfbmV4dF9ldmVudF9zdGQ7Cj4gKwl9Cj4gKwo+ICsJcnYgPSByZXF1ZXN0X2lycSh0aW1lcl9j ZmctPmlycVtEQVZJTkNJX1RJTUVSX0NMT0NLRVZFTlRfSVJRXS5zdGFydCwKPiArCQkJIGRhdmlu Y2lfdGltZXJfaXJxX3RpbWVyLCBJUlFGX1RJTUVSLAo+ICsJCQkgImNsb2NrZXZlbnQiLCBjbG9j a2V2ZW50KTsKPiArCWlmIChydikgewo+ICsJCXByX2VycigiVW5hYmxlIHRvIHJlcXVlc3QgdGhl IGNsb2NrZXZlbnQgaW50ZXJydXB0Iik7Cj4gKwkJcmV0dXJuIHJ2Owo+ICsJfQo+ICsKPiArCWNs b2NrZXZlbnRzX2NvbmZpZ19hbmRfcmVnaXN0ZXIoJmNsb2NrZXZlbnQtPmRldiwgdGlja19yYXRl LAo+ICsJCQkJCURBVklOQ0lfVElNRVJfTUlOX0RFTFRBLAo+ICsJCQkJCURBVklOQ0lfVElNRVJf TUFYX0RFTFRBKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBfX2lu aXQgb2ZfZGF2aW5jaV90aW1lcl9yZWdpc3RlcihzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wKQo+ICt7 Cj4gKwlzdHJ1Y3QgZGF2aW5jaV90aW1lcl9jZmcgdGltZXJfY2ZnID0geyB9Owo+ICsJc3RydWN0 IGNsayAqY2xrOwo+ICsJaW50IHJ2Owo+ICsKPiArCXJ2ID0gb2ZfYWRkcmVzc190b19yZXNvdXJj ZShucCwgMCwgJnRpbWVyX2NmZy5yZWcpOwo+ICsJaWYgKHJ2KSB7Cj4gKwkJcHJfZXJyKCJVbmFi bGUgdG8gZ2V0IHRoZSByZWdpc3RlciByYW5nZSBmb3IgdGltZXIiKTsKPiArCQlyZXR1cm4gcnY7 Cj4gKwl9Cj4gKwo+ICsJcnYgPSBvZl9pcnFfdG9fcmVzb3VyY2VfdGFibGUobnAsIHRpbWVyX2Nm Zy5pcnEsCj4gKwkJCQkgICAgICBEQVZJTkNJX1RJTUVSX05VTV9JUlFTKTsKPiArCWlmIChydiAh PSBEQVZJTkNJX1RJTUVSX05VTV9JUlFTKSB7Cj4gKwkJcHJfZXJyKCJVbmFibGUgdG8gZ2V0IHRo ZSBpbnRlcnJ1cHRzIGZvciB0aW1lciIpOwo+ICsJCXJldHVybiBydjsKPiArCX0KPiArCj4gKwlj bGsgPSBvZl9jbGtfZ2V0KG5wLCAwKTsKPiArCWlmIChJU19FUlIoY2xrKSkgewo+ICsJCXByX2Vy cigiVW5hYmxlIHRvIGdldCB0aGUgdGltZXIgY2xvY2siKTsKPiArCQlyZXR1cm4gUFRSX0VSUihj bGspOwo+ICsJfQo+ICsKPiArCXJ2ID0gZGF2aW5jaV90aW1lcl9yZWdpc3RlcihjbGssICZ0aW1l cl9jZmcpOwo+ICsJaWYgKHJ2KQo+ICsJCWNsa19wdXQoY2xrKTsKPiArCj4gKwlyZXR1cm4gcnY7 Cj4gK30KPiArVElNRVJfT0ZfREVDTEFSRShkYXZpbmNpX3RpbWVyLCAidGksZGE4MzAtdGltZXIi LCBvZl9kYXZpbmNpX3RpbWVyX3JlZ2lzdGVyKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9jbG9j a3NvdXJjZS90aW1lci1kYXZpbmNpLmggYi9pbmNsdWRlL2Nsb2Nrc291cmNlL3RpbWVyLWRhdmlu Y2kuaAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi4xZGNjMTMz M2ZiYzgKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvaW5jbHVkZS9jbG9ja3NvdXJjZS90aW1lci1k YXZpbmNpLmgKPiBAQCAtMCwwICsxLDQ0IEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wLW9ubHkgKi8KPiArLyoKPiArICogVEkgRGFWaW5jaSBjbG9ja3NvdXJjZSBkcml2 ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE5IFRleGFzIEluc3RydW1lbnRzCj4gKyAq IEF1dGhvcjogQmFydG9zeiBHb2xhc3pld3NraSA8YmdvbGFzemV3c2tpQGJheWxpYnJlLmNvbT4K PiArICovCj4gKwo+ICsjaWZuZGVmIF9fVElNRVJfREFWSU5DSV9IX18KPiArI2RlZmluZSBfX1RJ TUVSX0RBVklOQ0lfSF9fCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvY2xrLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9pb3BvcnQuaD4KPiArCj4gK2VudW0gewo+ICsJREFWSU5DSV9USU1FUl9DTE9DS0VW RU5UX0lSUSwKPiArCURBVklOQ0lfVElNRVJfQ0xPQ0tTT1VSQ0VfSVJRLAo+ICsJREFWSU5DSV9U SU1FUl9OVU1fSVJRUywKPiArfTsKPiArCj4gKy8qKgo+ICsgKiBzdHJ1Y3QgZGF2aW5jaV90aW1l cl9jZmcgLSBkYXZpbmNpIGNsb2Nrc291cmNlIGRyaXZlciBjb25maWd1cmF0aW9uIHN0cnVjdAo+ ICsgKiBAcmVnOiAgICAgICAgcmVnaXN0ZXIgcmFuZ2UgcmVzb3VyY2UKPiArICogQGlycTogICAg ICAgIGNsb2NrZXZlbnQgYW5kIGNsb2Nrc291cmNlIGludGVycnVwdCByZXNvdXJjZXMKPiArICog QGNtcF9vZmY6ICAgIGlmIHNldCAtIGl0IHNwZWNpZmllcyB0aGUgY29tcGFyZSByZWdpc3RlciB1 c2VkIGZvciBjbG9ja2V2ZW50Cj4gKyAqCj4gKyAqIE5vdGU6IGlmIHRoZSBjb21wYXJlIHJlZ2lz dGVyIGlzIHNwZWNpZmllZCwgdGhlIGRyaXZlciB3aWxsIHVzZSB0aGUgYm90dG9tCj4gKyAqIGNs b2NrIGhhbGYgZm9yIGJvdGggY2xvY2tzb3VyY2UgYW5kIGNsb2NrZXZlbnQgYW5kIHRoZSBjb21w YXJlIHJlZ2lzdGVyCj4gKyAqIHRvIGdlbmVyYXRlIGV2ZW50IGlycXMuIFRoZSB1c2VyIG11c3Qg c3VwcGx5IHRoZSBjb3JyZWN0IGNvbXBhcmUgcmVnaXN0ZXIKPiArICogaW50ZXJydXB0IG51bWJl ci4KPiArICoKPiArICogVGhpcyBpcyBvbmx5IHVzZWQgYnkgZGE4MzAgdGhlIERTUCBvZiB3aGlj aCB1c2VzIHRoZSB0b3AgaGFsZi4gVGhlIHRpbWVyCj4gKyAqIGRyaXZlciBzdGlsbCBjb25maWd1 cmVzIHRoZSB0b3AgaGFsZiB0byBydW4gaW4gZnJlZS1ydW4gbW9kZS4KPiArICovCj4gK3N0cnVj dCBkYXZpbmNpX3RpbWVyX2NmZyB7Cj4gKwlzdHJ1Y3QgcmVzb3VyY2UgcmVnOwo+ICsJc3RydWN0 IHJlc291cmNlIGlycVtEQVZJTkNJX1RJTUVSX05VTV9JUlFTXTsKPiArCXVuc2lnbmVkIGludCBj bXBfb2ZmOwo+ICt9Owo+ICsKPiAraW50IF9faW5pdCBkYXZpbmNpX3RpbWVyX3JlZ2lzdGVyKHN0 cnVjdCBjbGsgKmNsaywKPiArCQkJCSAgY29uc3Qgc3RydWN0IGRhdmluY2lfdGltZXJfY2ZnICpk YXRhKTsKPiArCj4gKyNlbmRpZiAvKiBfX1RJTUVSX0RBVklOQ0lfSF9fICovCj4gCgoKLS0gCiA8 aHR0cDovL3d3dy5saW5hcm8ub3JnLz4gTGluYXJvLm9yZyDilIIgT3BlbiBzb3VyY2Ugc29mdHdh cmUgZm9yIEFSTSBTb0NzCgpGb2xsb3cgTGluYXJvOiAgPGh0dHA6Ly93d3cuZmFjZWJvb2suY29t L3BhZ2VzL0xpbmFybz4gRmFjZWJvb2sgfAo8aHR0cDovL3R3aXR0ZXIuY29tLyMhL2xpbmFyb29y Zz4gVHdpdHRlciB8CjxodHRwOi8vd3d3LmxpbmFyby5vcmcvbGluYXJvLWJsb2cvPiBCbG9nCgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJt LWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtl cm5lbAo=