From patchwork Thu Mar 14 16:26:38 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Claudiu Beznea X-Patchwork-Id: 10853285 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id DAD1F1515 for ; Thu, 14 Mar 2019 16:27:07 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id BEE422A34B for ; Thu, 14 Mar 2019 16:27:07 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B25E42A4DF; Thu, 14 Mar 2019 16:27:07 +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=-5.2 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id A7C7A2A34B for ; Thu, 14 Mar 2019 16:27:06 +0000 (UTC) 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:MIME-Version:In-Reply-To:References: Message-ID:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=g92IyDR6XmNp9i70lvc9fgLe4rzfxfpXBKPCcah7g1w=; b=ZLka3TnnyynGWA Tm2KFIBxlVWtwHEQ9Of/rSA0LpzNeD+32ZFvLuS7L1Muyhg0fJLIoGkdIDnwPaoVN56nzOeV5f3Ly j++AZim2WEJzkc/6bK7pdxIaZI5AbYpsR+r87HSslz0Zgj2slOJm33i7rQjgYWRkgQTzYmltdgNvs GI8f0l2v/Jh6j6pql+F575rIn3Avs+oLTjeAXTbS4ng5ROutKppjnwvjNK967+HSVB5W7KGKu/nGw 34O3Evue0vvAVJ5OQQAZeI8lhbKkO4zDFPVDmXKrPIo4VlAW0AJ2IdGvo4z46b/491wDQ6KYnfkND pwkXVFOuXpGeiKvbwHgg==; 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 1h4TCC-0006O3-I0; Thu, 14 Mar 2019 16:27:04 +0000 Received: from esa3.microchip.iphmx.com ([68.232.153.233]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1h4TBq-0005w9-Vt for linux-arm-kernel@lists.infradead.org; Thu, 14 Mar 2019 16:26:48 +0000 X-IronPort-AV: E=Sophos;i="5.58,478,1544511600"; d="scan'208";a="28204156" Received: from smtpout.microchip.com (HELO email.microchip.com) ([198.175.253.82]) by esa3.microchip.iphmx.com with ESMTP/TLS/DHE-RSA-AES256-SHA; 14 Mar 2019 09:26:42 -0700 Received: from NAM04-CO1-obe.outbound.protection.outlook.com (10.10.215.89) by email.microchip.com (10.10.76.108) with Microsoft SMTP Server (TLS) id 14.3.352.0; Thu, 14 Mar 2019 09:26:41 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=microchiptechnology.onmicrosoft.com; s=selector1-microchiptechnology-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=qjK1sMJrwzdv6U8V6o+NXHiirtWnLpiPW/aCkKqpTNI=; b=k7cvtbE7zzxBBhfnHX7wrLKgKql3DnpQiB6+Y5nIV+qZjFUeFDC/Ikgo7f0BgrZlaaVuwRMXbd7E5cw2dB9WdPG5Dp/9aePL8A+MQC+NS1RuCfr33m1MHOEuUaKHXO97/3BcqnS8i4wCx4fM810WPLIJSmjLZAoyZXF/pXWvX4g= Received: from MWHPR11MB1549.namprd11.prod.outlook.com (10.172.54.17) by MWHPR11MB0061.namprd11.prod.outlook.com (10.164.204.33) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1709.13; Thu, 14 Mar 2019 16:26:39 +0000 Received: from MWHPR11MB1549.namprd11.prod.outlook.com ([fe80::54fe:95ed:b0cf:55a6]) by MWHPR11MB1549.namprd11.prod.outlook.com ([fe80::54fe:95ed:b0cf:55a6%9]) with mapi id 15.20.1686.021; Thu, 14 Mar 2019 16:26:39 +0000 From: To: , , , , , , Subject: [PATCH 2/5] clocksource/drivers/timer-microchip-pit64b: add Microchip PIT64B support Thread-Topic: [PATCH 2/5] clocksource/drivers/timer-microchip-pit64b: add Microchip PIT64B support Thread-Index: AQHU2oKzNY9L7o7MvUGRVNlgkbjplQ== Date: Thu, 14 Mar 2019 16:26:38 +0000 Message-ID: <1552580772-8499-3-git-send-email-claudiu.beznea@microchip.com> References: <1552580772-8499-1-git-send-email-claudiu.beznea@microchip.com> In-Reply-To: <1552580772-8499-1-git-send-email-claudiu.beznea@microchip.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: VI1PR0801CA0088.eurprd08.prod.outlook.com (2603:10a6:800:7d::32) To MWHPR11MB1549.namprd11.prod.outlook.com (2603:10b6:301:c::17) authentication-results: spf=none (sender IP is ) smtp.mailfrom=Claudiu.Beznea@microchip.com; x-ms-exchange-messagesentrepresentingtype: 1 x-mailer: git-send-email 2.7.4 x-originating-ip: [86.120.234.133] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: f683d25d-b5a4-4096-2f27-08d6a899d585 x-microsoft-antispam: BCL:0; PCL:0; RULEID:(2390118)(7020095)(4652040)(8989299)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(5600127)(711020)(4605104)(2017052603328)(7153060)(7193020); SRVR:MWHPR11MB0061; x-ms-traffictypediagnostic: MWHPR11MB0061: x-microsoft-antispam-prvs: x-forefront-prvs: 09760A0505 x-forefront-antispam-report: SFV:NSPM; SFS:(10009020)(376002)(136003)(39860400002)(346002)(366004)(396003)(189003)(199004)(107886003)(305945005)(106356001)(7736002)(14444005)(316002)(478600001)(86362001)(2201001)(72206003)(256004)(25786009)(99286004)(53936002)(6512007)(4326008)(8676002)(105586002)(81156014)(81166006)(54906003)(110136005)(50226002)(14454004)(6116002)(3846002)(66066001)(8936002)(97736004)(5660300002)(68736007)(2501003)(102836004)(6436002)(2906002)(71190400001)(446003)(386003)(2616005)(6506007)(476003)(186003)(71200400001)(26005)(30864003)(52116002)(11346002)(76176011)(36756003)(6486002)(486006); DIR:OUT; SFP:1101; SCL:1; SRVR:MWHPR11MB0061; H:MWHPR11MB1549.namprd11.prod.outlook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; received-spf: None (protection.outlook.com: microchip.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: jxwbRarGAOSTbK6wyfLSaogKmKq3a+rtyM4BPyDf9JiMprDnCCo5SVj/57fakSXCs7M01bPa80njvjBgveWfm0eSKacFU/nOCzjOWmMIfqZbyoxm53ioecviY1AjCmPwnigM/T7FIY1ziM8xHR809VBpqm+eDFI0DYV6FxU2JDgfteG6BKWnyVaFYwptY6jaKoV2YZhD5lqepCKREtBh5oYXDJxXXNR6pwFbr8k59A7FT/mZ5qYn3Uvd+ElJeikBVeykav+cb0b3DV4gytUTKKyZ0UHCNsmNd9Tvua9DqZFLsYQRyLqtRfq5YBnWK356gj2RR4Yd5KJ+4HCrg11w3vQ+PnWr2in+Wby3nzFZASlOPYQq15V0eMNWgtNytiQpy6fksSwH+hnosKQ9R/zM7+y+4te737PJNI6kCB/hvCs= MIME-Version: 1.0 X-MS-Exchange-CrossTenant-Network-Message-Id: f683d25d-b5a4-4096-2f27-08d6a899d585 X-MS-Exchange-CrossTenant-originalarrivaltime: 14 Mar 2019 16:26:38.9955 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 3f4057f3-b418-4d4e-ba84-d55b4e897d88 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR11MB0061 X-OriginatorOrg: microchip.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190314_092643_573423_B566AF1A X-CRM114-Status: GOOD ( 19.86 ) 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: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Claudiu.Beznea@microchip.com 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: Claudiu Beznea Add driver for Microchip PIT64B timer. Timer could be used in continuous mode or oneshot mode. The hardware has 2x32 bit registers for period emulating a 64 bit timer. The LSB_PR and MSB_PR registers are used to set the period value (compare value). TLSB and TMSB keeps the current value of the counter. After a compare the TLSB and TMSB register resets. Apart from this the hardware has SMOD bit in mode register that allow to reconfigure the timer without reset and start commands (start command while timer is active is ignored). The driver uses PIT64B timer as clocksource or clockevent. First requested timer would be registered as clockevent, second one would be registered as clocksource. Individual PIT64B hardware resources were used for clocksource and clockevent to be able to support high resolution timers with this hardware implementation. Signed-off-by: Claudiu Beznea Acked-by: Nicolas Ferre --- drivers/clocksource/Kconfig | 6 + drivers/clocksource/Makefile | 1 + drivers/clocksource/timer-microchip-pit64b.c | 464 +++++++++++++++++++++++++++ 3 files changed, 471 insertions(+) create mode 100644 drivers/clocksource/timer-microchip-pit64b.c diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig index 5d93e580e5dc..2ad6f881a0bb 100644 --- a/drivers/clocksource/Kconfig +++ b/drivers/clocksource/Kconfig @@ -448,6 +448,12 @@ config OXNAS_RPS_TIMER config SYS_SUPPORTS_SH_CMT bool +config MICROCHIP_PIT64B + bool "Microchip PIT64B support" + depends on OF || COMPILE_TEST + help + This option enables Microchip PIT64B timer. + config MTK_TIMER bool "Mediatek timer driver" if COMPILE_TEST depends on HAS_IOMEM diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile index c4a8e9ef932a..c53fa12b9b94 100644 --- a/drivers/clocksource/Makefile +++ b/drivers/clocksource/Makefile @@ -35,6 +35,7 @@ obj-$(CONFIG_U300_TIMER) += timer-u300.o obj-$(CONFIG_SUN4I_TIMER) += timer-sun4i.o obj-$(CONFIG_SUN5I_HSTIMER) += timer-sun5i.o obj-$(CONFIG_MESON6_TIMER) += timer-meson6.o +obj-$(CONFIG_MICROCHIP_PIT64B) += timer-microchip-pit64b.o obj-$(CONFIG_TEGRA_TIMER) += timer-tegra20.o obj-$(CONFIG_VT8500_TIMER) += timer-vt8500.o obj-$(CONFIG_NSPIRE_TIMER) += timer-zevio.o diff --git a/drivers/clocksource/timer-microchip-pit64b.c b/drivers/clocksource/timer-microchip-pit64b.c new file mode 100644 index 000000000000..6787aa98ef01 --- /dev/null +++ b/drivers/clocksource/timer-microchip-pit64b.c @@ -0,0 +1,464 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright (C) 2019 Microchip Technology Inc. +// Copyright (C) 2019 Claudiu Beznea (claudiu.beznea@microchip.com) + +#include +#include +#include +#include +#include +#include +#include + +#define MCHP_PIT64B_CR 0x00 /* Control Register */ +#define MCHP_PIT64B_CR_START BIT(0) +#define MCHP_PIT64B_CR_SWRST BIT(8) + +#define MCHP_PIT64B_MR 0x04 /* Mode Register */ +#define MCHP_PIT64B_MR_CONT BIT(0) +#define MCHP_PIT64B_MR_SGCLK BIT(3) +#define MCHP_PIT64B_MR_SMOD BIT(4) +#define MCHP_PIT64B_MR_PRES GENMASK(11, 8) + +#define MCHP_PIT64B_LSB_PR 0x08 /* LSB Period Register */ + +#define MCHP_PIT64B_MSB_PR 0x0C /* MSB Period Register */ + +#define MCHP_PIT64B_IER 0x10 /* Interrupt Enable Register */ +#define MCHP_PIT64B_IER_PERIOD BIT(0) + +#define MCHP_PIT64B_ISR 0x1C /* Interrupt Status Register */ +#define MCHP_PIT64B_ISR_PERIOD BIT(0) + +#define MCHP_PIT64B_TLSBR 0x20 /* Timer LSB Register */ + +#define MCHP_PIT64B_TMSBR 0x24 /* Timer MSB Register */ + +#define MCHP_PIT64B_PRES_MAX 0x10 +#define MCHP_PIT64B_DEF_FREQ 2500000UL /* 2.5 MHz */ +#define MCHP_PIT64B_LSBMASK GENMASK_ULL(31, 0) +#define MCHP_PIT64B_PRESCALER(p) (MCHP_PIT64B_MR_PRES & ((p) << 8)) + +#define MCHP_PIT64B_NAME "pit64b" + +struct mchp_pit64b_common_data { + void __iomem *base; + struct clk *pclk; + struct clk *gclk; + u64 cycles; + u8 pres; +}; + +struct mchp_pit64b_clksrc_data { + struct clocksource *clksrc; + struct mchp_pit64b_common_data *cd; +}; + +struct mchp_pit64b_clkevt_data { + struct clock_event_device *clkevt; + struct mchp_pit64b_common_data *cd; +}; + +static struct mchp_pit64b_data { + struct mchp_pit64b_clksrc_data *csd; + struct mchp_pit64b_clkevt_data *ced; +} data; + +static inline u32 mchp_pit64b_read(void __iomem *base, u32 offset) +{ + return readl_relaxed(base + offset); +} + +static inline void mchp_pit64b_write(void __iomem *base, u32 offset, u32 val) +{ + writel_relaxed(val, base + offset); +} + +static inline u64 mchp_pit64b_get_period(void __iomem *base) +{ + u32 lsb, msb; + + /* LSB must be read first to guarantee an atomic read of the 64 bit + * timer. + */ + lsb = mchp_pit64b_read(base, MCHP_PIT64B_TLSBR); + msb = mchp_pit64b_read(base, MCHP_PIT64B_TMSBR); + + return (((u64)msb << 32) | lsb); +} + +static inline void mchp_pit64b_set_period(void __iomem *base, u64 cycles) +{ + u32 lsb, msb; + + lsb = cycles & MCHP_PIT64B_LSBMASK; + msb = cycles >> 32; + + /* LSB must be write last to guarantee an atomic update of the timer + * even when SMOD=1. + */ + mchp_pit64b_write(base, MCHP_PIT64B_MSB_PR, msb); + mchp_pit64b_write(base, MCHP_PIT64B_LSB_PR, lsb); +} + +static inline void mchp_pit64b_reset(struct mchp_pit64b_common_data *data, + u32 mode, bool irq_ena) +{ + mode |= MCHP_PIT64B_PRESCALER(data->pres); + if (data->gclk) + mode |= MCHP_PIT64B_MR_SGCLK; + + mchp_pit64b_write(data->base, MCHP_PIT64B_CR, MCHP_PIT64B_CR_SWRST); + mchp_pit64b_write(data->base, MCHP_PIT64B_MR, mode); + mchp_pit64b_set_period(data->base, data->cycles); + if (irq_ena) + mchp_pit64b_write(data->base, MCHP_PIT64B_IER, + MCHP_PIT64B_IER_PERIOD); + mchp_pit64b_write(data->base, MCHP_PIT64B_CR, MCHP_PIT64B_CR_START); +} + +static u64 mchp_pit64b_read_clk(struct clocksource *cs) +{ + return mchp_pit64b_get_period(data.csd->cd->base); +} + +static u64 mchp_sched_read_clk(void) +{ + return mchp_pit64b_get_period(data.csd->cd->base); +} + +static struct clocksource mchp_pit64b_clksrc = { + .name = MCHP_PIT64B_NAME, + .mask = CLOCKSOURCE_MASK(64), + .flags = CLOCK_SOURCE_IS_CONTINUOUS, + .rating = 210, + .read = mchp_pit64b_read_clk, +}; + +static int mchp_pit64b_clkevt_shutdown(struct clock_event_device *cedev) +{ + mchp_pit64b_write(data.ced->cd->base, MCHP_PIT64B_CR, + MCHP_PIT64B_CR_SWRST); + + return 0; +} + +static int mchp_pit64b_clkevt_set_periodic(struct clock_event_device *cedev) +{ + mchp_pit64b_reset(data.ced->cd, MCHP_PIT64B_MR_CONT, true); + + return 0; +} + +static int mchp_pit64b_clkevt_set_oneshot(struct clock_event_device *cedev) +{ + mchp_pit64b_reset(data.ced->cd, MCHP_PIT64B_MR_SMOD, true); + + return 0; +} + +static int mchp_pit64b_clkevt_set_next_event(unsigned long evt, + struct clock_event_device *cedev) +{ + mchp_pit64b_set_period(data.ced->cd->base, evt); + mchp_pit64b_write(data.ced->cd->base, MCHP_PIT64B_CR, + MCHP_PIT64B_CR_START); + + return 0; +} + +static void mchp_pit64b_clkevt_suspend(struct clock_event_device *cedev) +{ + mchp_pit64b_write(data.ced->cd->base, MCHP_PIT64B_CR, + MCHP_PIT64B_CR_SWRST); + if (data.ced->cd->gclk) + clk_disable_unprepare(data.ced->cd->gclk); + clk_disable_unprepare(data.ced->cd->pclk); +} + +static void mchp_pit64b_clkevt_resume(struct clock_event_device *cedev) +{ + u32 mode = MCHP_PIT64B_MR_SMOD; + + clk_prepare_enable(data.ced->cd->pclk); + if (data.ced->cd->gclk) + clk_prepare_enable(data.ced->cd->gclk); + + if (clockevent_state_periodic(data.ced->clkevt)) + mode = MCHP_PIT64B_MR_CONT; + + mchp_pit64b_reset(data.ced->cd, mode, true); +} + +static struct clock_event_device mchp_pit64b_clkevt = { + .name = MCHP_PIT64B_NAME, + .features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC, + .rating = 150, + .set_state_shutdown = mchp_pit64b_clkevt_shutdown, + .set_state_periodic = mchp_pit64b_clkevt_set_periodic, + .set_state_oneshot = mchp_pit64b_clkevt_set_oneshot, + .set_next_event = mchp_pit64b_clkevt_set_next_event, + .suspend = mchp_pit64b_clkevt_suspend, + .resume = mchp_pit64b_clkevt_resume, +}; + +static irqreturn_t mchp_pit64b_interrupt(int irq, void *dev_id) +{ + struct mchp_pit64b_clkevt_data *irq_data = dev_id; + + if (data.ced != irq_data) + return IRQ_NONE; + + if (mchp_pit64b_read(irq_data->cd->base, MCHP_PIT64B_ISR) & + MCHP_PIT64B_ISR_PERIOD) { + irq_data->clkevt->event_handler(irq_data->clkevt); + return IRQ_HANDLED; + } + + return IRQ_NONE; +} + +static int __init mchp_pit64b_pres_compute(u32 *pres, u32 clk_rate, + u32 max_rate) +{ + u32 tmp; + + for (*pres = 0; *pres < MCHP_PIT64B_PRES_MAX; (*pres)++) { + tmp = clk_rate / (*pres + 1); + if (tmp <= max_rate) + break; + } + + if (*pres == MCHP_PIT64B_PRES_MAX) + return -EINVAL; + + return 0; +} + +static int __init mchp_pit64b_pres_prepare(struct mchp_pit64b_common_data *cd, + unsigned long max_rate) +{ + unsigned long pclk_rate, diff = 0, best_diff = ULONG_MAX; + long gclk_round = 0; + u32 pres, best_pres; + int ret = 0; + + pclk_rate = clk_get_rate(cd->pclk); + if (!pclk_rate) + return -EINVAL; + + if (cd->gclk) { + gclk_round = clk_round_rate(cd->gclk, max_rate); + if (gclk_round < 0) + goto pclk; + + if (pclk_rate / gclk_round < 3) + goto pclk; + + ret = mchp_pit64b_pres_compute(&pres, gclk_round, max_rate); + if (ret) + best_diff = abs(gclk_round - max_rate); + else + best_diff = abs(gclk_round / (pres + 1) - max_rate); + best_pres = pres; + } + +pclk: + /* Check if requested rate could be obtained using PCLK. */ + ret = mchp_pit64b_pres_compute(&pres, pclk_rate, max_rate); + if (ret) + diff = abs(pclk_rate - max_rate); + else + diff = abs(pclk_rate / (pres + 1) - max_rate); + + if (best_diff > diff) { + /* Use PCLK. */ + cd->gclk = NULL; + best_pres = pres; + } else { + clk_set_rate(cd->gclk, gclk_round); + } + + cd->pres = best_pres; + + pr_info("PIT64B: using clk=%s with prescaler %u, freq=%lu [Hz]\n", + cd->gclk ? "gclk" : "pclk", cd->pres, + cd->gclk ? gclk_round / (cd->pres + 1) + : pclk_rate / (cd->pres + 1)); + + return 0; +} + +static int __init mchp_pit64b_dt_init_clksrc(struct mchp_pit64b_common_data *cd) +{ + struct mchp_pit64b_clksrc_data *csd; + unsigned long clk_rate; + int ret; + + csd = kzalloc(sizeof(*csd), GFP_KERNEL); + if (!csd) + return -ENOMEM; + + csd->cd = cd; + + if (csd->cd->gclk) + clk_rate = clk_get_rate(csd->cd->gclk); + else + clk_rate = clk_get_rate(csd->cd->pclk); + + clk_rate = clk_rate / (cd->pres + 1); + csd->cd->cycles = ULLONG_MAX; + mchp_pit64b_reset(csd->cd, MCHP_PIT64B_MR_CONT, false); + + data.csd = csd; + + csd->clksrc = &mchp_pit64b_clksrc; + + ret = clocksource_register_hz(csd->clksrc, clk_rate); + if (ret) { + pr_debug("clksrc: Failed to register PIT64B clocksource!\n"); + goto free; + } + + sched_clock_register(mchp_sched_read_clk, 64, clk_rate); + + return 0; + +free: + kfree(csd); + data.csd = NULL; + + return ret; +} + +static int __init mchp_pit64b_dt_init_clkevt(struct mchp_pit64b_common_data *cd, + u32 irq) +{ + struct mchp_pit64b_clkevt_data *ced; + unsigned long clk_rate; + int ret; + + ced = kzalloc(sizeof(*ced), GFP_KERNEL); + if (!ced) + return -ENOMEM; + + ced->cd = cd; + + if (ced->cd->gclk) + clk_rate = clk_get_rate(ced->cd->gclk); + else + clk_rate = clk_get_rate(ced->cd->pclk); + + clk_rate = clk_rate / (ced->cd->pres + 1); + ced->cd->cycles = DIV_ROUND_CLOSEST(clk_rate, HZ); + + ret = request_irq(irq, mchp_pit64b_interrupt, IRQF_TIMER, "pit64b_tick", + ced); + if (ret) { + pr_debug("clkevt: Failed to setup PIT64B IRQ\n"); + goto free; + } + + data.ced = ced; + + /* Set up and register clockevents. */ + ced->clkevt = &mchp_pit64b_clkevt; + ced->clkevt->cpumask = cpumask_of(0); + ced->clkevt->irq = irq; + clockevents_config_and_register(ced->clkevt, clk_rate, 1, ULONG_MAX); + + return 0; + +free: + kfree(ced); + data.ced = NULL; + + return ret; +} + +static int __init mchp_pit64b_dt_init(struct device_node *node) +{ + struct mchp_pit64b_common_data *cd; + u32 irq, freq = MCHP_PIT64B_DEF_FREQ; + int ret; + + if (data.csd && data.ced) + return -EBUSY; + + cd = kzalloc(sizeof(*cd), GFP_KERNEL); + if (!cd) + return -ENOMEM; + + cd->pclk = of_clk_get_by_name(node, "pclk"); + if (IS_ERR(cd->pclk)) { + ret = PTR_ERR(cd->pclk); + goto free; + } + + cd->gclk = of_clk_get_by_name(node, "gclk"); + if (IS_ERR(cd->gclk)) + cd->gclk = NULL; + + ret = of_property_read_u32(node, "clock-frequency", &freq); + if (ret) + pr_debug("PIT64B: failed to read clock frequency. Using default!\n"); + + ret = mchp_pit64b_pres_prepare(cd, freq); + if (ret) + goto free; + + cd->base = of_iomap(node, 0); + if (!cd->base) { + pr_debug("%s: Could not map PIT64B address!\n", + MCHP_PIT64B_NAME); + ret = -ENXIO; + goto free; + } + + ret = clk_prepare_enable(cd->pclk); + if (ret) + goto unmap; + + if (cd->gclk) { + ret = clk_prepare_enable(cd->gclk); + if (ret) + goto pclk_unprepare; + } + + if (!data.ced) { + irq = irq_of_parse_and_map(node, 0); + if (!irq) { + pr_debug("%s: Failed to get PIT64B clockevent IRQ!\n", + MCHP_PIT64B_NAME); + ret = -ENODEV; + goto gclk_unprepare; + } + ret = mchp_pit64b_dt_init_clkevt(cd, irq); + if (ret) + goto irq_unmap; + } else { + ret = mchp_pit64b_dt_init_clksrc(cd); + if (ret) + goto gclk_unprepare; + } + + return 0; + +irq_unmap: + irq_dispose_mapping(irq); +gclk_unprepare: + if (cd->gclk) + clk_disable_unprepare(cd->gclk); +pclk_unprepare: + clk_disable_unprepare(cd->pclk); +unmap: + iounmap(cd->base); +free: + kfree(cd); + + return ret; +} + +TIMER_OF_DECLARE(mchp_pit64b_clksrc, "microchip,sam9x60-pit64b", + mchp_pit64b_dt_init);