From patchwork Wed Sep 14 20:09:40 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: fu.wei@linaro.org X-Patchwork-Id: 9332447 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 4D9756077A for ; Wed, 14 Sep 2016 20:18:24 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 3B08529FC1 for ; Wed, 14 Sep 2016 20:18:24 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 2D80929FD2; Wed, 14 Sep 2016 20:18:24 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.1 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED,T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.9]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 7DDC629FC1 for ; Wed, 14 Sep 2016 20:18:23 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.85_2 #1 (Red Hat Linux)) id 1bkGbv-0001ri-6w; Wed, 14 Sep 2016 20:16:47 +0000 Received: from mail-wm0-x22a.google.com ([2a00:1450:400c:c09::22a]) by bombadil.infradead.org with esmtps (Exim 4.85_2 #1 (Red Hat Linux)) id 1bkGY1-0005hx-2X for linux-arm-kernel@lists.infradead.org; Wed, 14 Sep 2016 20:12:55 +0000 Received: by mail-wm0-x22a.google.com with SMTP id k186so28903194wmd.0 for ; Wed, 14 Sep 2016 13:12:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=jPqvOtBlhNEVseEGvJlf9S2JyOMClxcItSscMtGMtz8=; b=fiFbjAlH72gjYc4RS/9Wb6bSI57ciL0za/1q3IqlSmoBkhCFs3o6JTt0ofSCUeicBf UJ7ZLmtXI7TMWxUaRl+YhCoaP+HFtCkjnWbpLkaR+wHSyadMXqWvnhiqSWMvc6If7HeN wbEUMjDh48h6RwpRhu2O6PzsZJr0/YJEdjW9g= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=jPqvOtBlhNEVseEGvJlf9S2JyOMClxcItSscMtGMtz8=; b=bk4ithXY1RxLmRIr1guVzekoeppplAPXSb95ucNc5Kjwp+TgPBPcMNYBsAjVZxHAc7 eARE0U8WTOOoN/TaP8M2oXMPZV0DtAHQbY41zgY0aMR3LLKgzVqIzxbaZareTP/TJq59 Dx7cH30e5VOwwVdomF7Sy1bhqOqKkPxwvTEIMFrwiKF0fE8paqQ8CzuaM3gmAEBhJVPl JRqYZnuJ36CcYpjnm+1Ulnhv2hwqkYcHgNqmVivBXvRPJNg7vyTHQcyxU9NnWOf45OwV fUL5uasOgAJt5GJSb/ns97pb5ddHegQD4E6l4Bfp7p2OeaxEniwcDgrL0Im7w5O3l/pb hn2A== X-Gm-Message-State: AE9vXwNRQ6VTG0hRW4yoqrpqzP+iA4AHhgFvBXkV8Ol1h9Qd9ZNEIS1JunUvQ5QkxZpXnrqP X-Received: by 10.194.141.13 with SMTP id rk13mr4179143wjb.25.1473883942512; Wed, 14 Sep 2016 13:12:22 -0700 (PDT) Received: from Rei-Ayanami.localdomain.com ([59.58.254.106]) by smtp.googlemail.com with ESMTPSA id ab9sm1233449wjc.7.2016.09.14.13.12.11 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 14 Sep 2016 13:12:21 -0700 (PDT) From: fu.wei@linaro.org To: rjw@rjwysocki.net, lenb@kernel.org, daniel.lezcano@linaro.org, tglx@linutronix.de, marc.zyngier@arm.com, mark.rutland@arm.com, lorenzo.pieralisi@arm.com, sudeep.holla@arm.com, hanjun.guo@linaro.org Subject: [PATCH v13 7/8] clocksource/drivers/arm_arch_timer: Add GTDT support for memory-mapped timer Date: Thu, 15 Sep 2016 04:09:40 +0800 Message-Id: <1473883781-9571-8-git-send-email-fu.wei@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1473883781-9571-1-git-send-email-fu.wei@linaro.org> References: <1473883781-9571-1-git-send-email-fu.wei@linaro.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20160914_131246_222260_48BAFB99 X-CRM114-Status: GOOD ( 21.89 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linaro-acpi@lists.linaro.org, catalin.marinas@arm.com, will.deacon@arm.com, linux-kernel@vger.kernel.org, wim@iguana.be, Fu Wei , wei@redhat.com, al.stone@linaro.org, tn@semihalf.com, timur@codeaurora.org, linux-acpi@vger.kernel.org, linux@roeck-us.net, harba@codeaurora.org, julien.grall@arm.com, linux-watchdog@vger.kernel.org, arnd@arndb.de, jcm@redhat.com, cov@codeaurora.org, linux-arm-kernel@lists.infradead.org, graeme.gregory@linaro.org, rruigrok@codeaurora.org, leo.duran@amd.com, Suravee.Suthikulpanit@amd.com, christoffer.dall@linaro.org Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP From: Fu Wei The patch add memory-mapped timer register support by using the information provided by the new GTDT driver of ACPI. Also refactor original memory-mapped timer dt support for reusing some common code. Signed-off-by: Fu Wei --- drivers/clocksource/arm_arch_timer.c | 238 +++++++++++++++++++++++++---------- 1 file changed, 172 insertions(+), 66 deletions(-) diff --git a/drivers/clocksource/arm_arch_timer.c b/drivers/clocksource/arm_arch_timer.c index 0197ef9..ddca6e3 100644 --- a/drivers/clocksource/arm_arch_timer.c +++ b/drivers/clocksource/arm_arch_timer.c @@ -57,6 +57,7 @@ static unsigned arch_timers_present __initdata; static void __iomem *arch_counter_base; +static void __iomem *cntctlbase __initdata; struct arch_timer { void __iomem *base; @@ -656,15 +657,56 @@ out: return err; } -static int __init arch_timer_mem_register(void __iomem *base, unsigned int irq) +static int __init arch_timer_mem_register(struct device_node *np, void *frame) { - int ret; - irq_handler_t func; + struct device_node *frame_node = NULL; + struct gt_timer_data *frame_data = NULL; struct arch_timer *t; + void __iomem *base; + irq_handler_t func; + unsigned int irq; + int ret; + + if (np) { + frame_node = (struct device_node *)frame; + base = of_iomap(frame_node, 0); + arch_timer_detect_rate(base, np); + if (arch_timer_mem_use_virtual) + irq = irq_of_parse_and_map(frame_node, VIRT_SPI); + else + irq = irq_of_parse_and_map(frame_node, PHYS_SPI); + } else { + frame_data = (struct gt_timer_data *)frame; + /* + * According to ARMv8 Architecture Reference Manual(ARM), + * the size of CNTBaseN frames of memory-mapped timer + * is SZ_4K(Offset 0x000 – 0xFFF). + */ + base = ioremap(frame_data->cntbase_phy, SZ_4K); + if (arch_timer_mem_use_virtual) + irq = frame_data->virtual_irq; + else + irq = frame_data->irq; + } + + if (!base) { + pr_err("Can't map frame's registers\n"); + return -ENXIO; + } + if (!irq) { + pr_err("Frame missing %s irq", + arch_timer_mem_use_virtual ? "virt" : "phys"); + ret = -EINVAL; + goto out; + } + + arch_counter_base = base; t = kzalloc(sizeof(*t), GFP_KERNEL); - if (!t) + if (!t) { return -ENOMEM; + goto out; + } t->base = base; t->evt.irq = irq; @@ -676,11 +718,13 @@ static int __init arch_timer_mem_register(void __iomem *base, unsigned int irq) func = arch_timer_handler_phys_mem; ret = request_irq(irq, func, IRQF_TIMER, "arch_mem_timer", &t->evt); - if (ret) { - pr_err("Failed to request mem timer irq\n"); - kfree(t); - } + if (!ret) + return 0; + pr_err("Failed to request mem timer irq\n"); + kfree(t); +out: + iounmap(base); return ret; } @@ -769,7 +813,7 @@ static int __init arch_timer_init(void) return ret; arch_timer_kvm_info.virtual_irq = arch_timer_ppi[VIRT_PPI]; - + return 0; } @@ -803,21 +847,56 @@ static int __init arch_timer_of_init(struct device_node *np) CLOCKSOURCE_OF_DECLARE(armv7_arch_timer, "arm,armv7-timer", arch_timer_of_init); CLOCKSOURCE_OF_DECLARE(armv8_arch_timer, "arm,armv8-timer", arch_timer_of_init); -static int __init arch_timer_mem_init(struct device_node *np) +static int __init get_cnttidr(struct device_node *np, + struct gt_block_data *gt_block, u32 *cnttidr) { - struct device_node *frame, *best_frame = NULL; - void __iomem *cntctlbase, *base; - unsigned int irq, ret = -EINVAL; - u32 cnttidr; + if (np) + cntctlbase = of_iomap(np, 0); + else + cntctlbase = ioremap(gt_block->cntctlbase_phy, SZ_4K); + /* + * According to ARMv8 Architecture Reference Manual(ARM), + * the size of CNTCTLBase frame of memory-mapped timer + * is SZ_4K(Offset 0x000 – 0xFFF). + */ - arch_timers_present |= ARCH_MEM_TIMER; - cntctlbase = of_iomap(np, 0); if (!cntctlbase) { pr_err("Can't find CNTCTLBase\n"); return -ENXIO; } - cnttidr = readl_relaxed(cntctlbase + CNTTIDR); + *cnttidr = readl_relaxed(cntctlbase + CNTTIDR); + return 0; +} + +static bool __init is_best_frame(u32 cnttidr, int n) +{ + u32 cntacr = CNTACR_RFRQ | CNTACR_RWPT | CNTACR_RPCT | CNTACR_RWVT | + CNTACR_RVOFF | CNTACR_RVCT; + + /* Try enabling everything, and see what sticks */ + writel_relaxed(cntacr, cntctlbase + CNTACR(n)); + cntacr = readl_relaxed(cntctlbase + CNTACR(n)); + + if ((cnttidr & CNTTIDR_VIRT(n)) && + !(~cntacr & (CNTACR_RWVT | CNTACR_RVCT))) + arch_timer_mem_use_virtual = true; + else if (~cntacr & (CNTACR_RWPT | CNTACR_RPCT)) + return false; + + return true; +} + +static int __init arch_timer_mem_init(struct device_node *np) +{ + struct device_node *frame, *best_frame = NULL; + unsigned int ret = -EINVAL; + u32 cnttidr; + + arch_timers_present |= ARCH_MEM_TIMER; + + if (get_cnttidr(np, NULL, &cnttidr)) + return -ENXIO; /* * Try to find a virtual capable frame. Otherwise fall back to a @@ -825,60 +904,22 @@ static int __init arch_timer_mem_init(struct device_node *np) */ for_each_available_child_of_node(np, frame) { int n; - u32 cntacr; - if (of_property_read_u32(frame, "frame-number", &n)) { - pr_err("Missing frame-number\n"); + pr_err("Missing frame-number.\n"); of_node_put(frame); goto out; } - - /* Try enabling everything, and see what sticks */ - cntacr = CNTACR_RFRQ | CNTACR_RWPT | CNTACR_RPCT | - CNTACR_RWVT | CNTACR_RVOFF | CNTACR_RVCT; - writel_relaxed(cntacr, cntctlbase + CNTACR(n)); - cntacr = readl_relaxed(cntctlbase + CNTACR(n)); - - if ((cnttidr & CNTTIDR_VIRT(n)) && - !(~cntacr & (CNTACR_RWVT | CNTACR_RVCT))) { + if (is_best_frame(cnttidr, n)) { of_node_put(best_frame); - best_frame = frame; - arch_timer_mem_use_virtual = true; - break; + best_frame = of_node_get(frame); + if (arch_timer_mem_use_virtual) + break; } - - if (~cntacr & (CNTACR_RWPT | CNTACR_RPCT)) - continue; - - of_node_put(best_frame); - best_frame = of_node_get(frame); - } - - ret= -ENXIO; - base = arch_counter_base = of_iomap(best_frame, 0); - if (!base) { - pr_err("Can't map frame's registers\n"); - goto out; - } - - if (arch_timer_mem_use_virtual) - irq = irq_of_parse_and_map(best_frame, VIRT_SPI); - else - irq = irq_of_parse_and_map(best_frame, PHYS_SPI); - - ret = -EINVAL; - if (!irq) { - pr_err("Frame missing %s irq", - arch_timer_mem_use_virtual ? "virt" : "phys"); - goto out; } - arch_timer_detect_rate(base, np); - ret = arch_timer_mem_register(base, irq); - if (ret) - goto out; - - return arch_timer_common_init(); + ret = arch_timer_mem_register(np, best_frame); + if (!ret) + ret = arch_timer_common_init(); out: iounmap(cntctlbase); of_node_put(best_frame); @@ -888,7 +929,72 @@ CLOCKSOURCE_OF_DECLARE(armv7_arch_timer_mem, "arm,armv7-timer-mem", arch_timer_mem_init); #ifdef CONFIG_ACPI_GTDT -/* Initialize per-processor generic timer */ +static struct gt_timer_data __init *arch_timer_mem_get_timer( + struct gt_block_data *gt_blocks) +{ + struct gt_block_data *gt_block = gt_blocks; + struct gt_timer_data *best_frame = NULL; + u32 cnttidr; + int i; + + if (get_cnttidr(NULL, gt_block, &cnttidr)) + return NULL; + /* + * Try to find a virtual capable frame. Otherwise fall back to a + * physical capable frame. + */ + for (i = 0; i < gt_block->timer_count; i++) { + if (is_best_frame(cnttidr, gt_block->timer[i].frame_nr)) { + best_frame = >_block->timer[i]; + if (arch_timer_mem_use_virtual) + break; + } + } + iounmap(cntctlbase); + + return best_frame; +} + +static int __init arch_timer_mem_acpi_init(size_t timer_count) +{ + struct gt_block_data *gt_blocks; + struct gt_timer_data *gt_timer; + int ret = -EINVAL; + + /* + * If we don't have any Platform Timer Structures, just return. + */ + if (!timer_count) + return 0; + + /* + * before really check all the Platform Timer Structures, + * we assume they are GT block, and allocate memory for them. + * We will free these memory once we finish the initialization. + */ + gt_blocks = kcalloc(timer_count, sizeof(*gt_blocks), GFP_KERNEL); + if (!gt_blocks) + return -ENOMEM; + + if (gtdt_arch_timer_mem_init(gt_blocks) > 0) { + gt_timer = arch_timer_mem_get_timer(gt_blocks); + if (!gt_timer) { + pr_err("Failed to get mem timer info.\n"); + goto error; + } + ret = arch_timer_mem_register(NULL, gt_timer); + if (ret) { + pr_err("Failed to register mem timer.\n"); + goto error; + } + } + arch_timers_present |= ARCH_MEM_TIMER; +error: + kfree(gt_blocks); + return ret; +} + +/* Initialize per-processor generic timer and memory-mapped timer(if present) */ static int __init arch_timer_acpi_init(struct acpi_table_header *table) { int timer_count; @@ -912,8 +1018,8 @@ static int __init arch_timer_acpi_init(struct acpi_table_header *table) /* Get the frequency from CNTFRQ */ arch_timer_detect_rate(NULL, NULL); - if (timer_count < 0) - pr_err("Failed to get platform timer info.\n"); + if (timer_count < 0 || arch_timer_mem_acpi_init((size_t)timer_count)) + pr_err("Failed to initialize memory-mapped timer.\n"); return arch_timer_init(); }