From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pg1-f182.google.com (mail-pg1-f182.google.com [209.85.215.182]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 993091B96E; Fri, 12 Apr 2024 05:11:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898697; cv=none; b=Ytqk+QRYCxLDbK4pBJz3rCwP7pW6QNpGWb/psUxtJnTY164bnejbQM5Toz8Qxs04HXwzobVFO0pQiBP3pO6gsxWSREr/e8QZtpE5+CqhIYJvzKJXRBahJD8P+eCrHWBUCbqReYCig3S7gdklxD9BK+ljujBSbth6CaOiURvPq0Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898697; c=relaxed/simple; bh=nFRMU6xTbrzOS51FDYFjCaA/OJfcz6/qg6Mj1TgIBms=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=oJNdifQkwahUQ499Mi8A7VkNnUcIGfdh8ayOzcrnzmCKmaf28BuLB+Pl1CMIxwb7ZRjDo0/esURYog9z1IbyKCpSj1D4MkJx36SBVMPZDtj9hh186oB5HUsjF+Da4kM4WYrvNJo6LRftulG1rX3qU8O5FSO05znu21O1/7auT5A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=QlSDkAe0; arc=none smtp.client-ip=209.85.215.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="QlSDkAe0" Received: by mail-pg1-f182.google.com with SMTP id 41be03b00d2f7-5f415fd71f8so436175a12.3; Thu, 11 Apr 2024 22:11:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898694; x=1713503494; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=n8lUCW6/osKWYcttIWv//iPm23yYuW3M1dv6E9h9iCk=; b=QlSDkAe0r/mhPHWWi6CE7g+IOe5t0vHMsVVX2Jklk2K7sDEy1+viYAmLLNOIoU7ttZ 6YU0jT8l2gtQ6baHV6SwaB4gF4mKjU+LuQugMK6d4l9YLgRN8mZqHb+TVUs+SF6aE2tP 3uiLKik6k6nsqXG7+OP/hhJE66dFe5AQnccRdcAVaJbLKioemRC1fVBMlAztayodKKOk T7twBcIfIn/FCj4+/zT28M9Adye6IApP/TUJqDQ6O9pag2X2P4JinBr8OH1g3IZzMw+V r9lpyAFUW3rlrixKPtIqxEtRTOm6HnHIWYekvRgW4CtnW9cu152RPVtj1ur4yi+XEFvh bCCg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898694; x=1713503494; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=n8lUCW6/osKWYcttIWv//iPm23yYuW3M1dv6E9h9iCk=; b=O1TimZ+VeecoVhogR4atHpVB0wGMuldhYsE6fThcAOoMd8re56BVmEx3HG/mfCgpIJ tsY0J3blhxYvi1p0nBvMXmsQrdIfP0bENMqydx8wuWb3iIv/3alP3Ywst5MzlzJOuwnH zlDBXyrdOAFnanltia1vVqAnJh8T8IOsR6kWSz3vfg1XHLsUGa8uL9gkXiuvxSfml1cT hi+dRTPsyMUwfnLTcsq0aiaq4oRPxD17AqgCqWOL8B87LX0fkuCYcIZziVDSlLHcp6kj IuFMzQRSfgGTqSGIuddBZYprWm+ltU4jE/zYS1Q+tAusInleu+5oXx1p3DIEt1WPQoC5 7t2Q== X-Forwarded-Encrypted: i=1; AJvYcCXqCQAuBHK+WYrBSC2W0VBJ+p2381dtiZPsVs1DAm0Z/g//mgiKetIoaABatjBqsSwp9O9VdTU6N9bqcYurKLfLrjzYmuzjckFbmrUh X-Gm-Message-State: AOJu0YyavTZxboxHLtClj85BBAeHrGnFgQR3oGNSWifg6m2FQvuPS10c 186DOfnm56gA+fF0nGrz+wZYCLT8R6UlkEQAzTTUyvQ9kKPozSC8FkxH7hcA X-Google-Smtp-Source: AGHT+IEVLmU9vFuS48EaURASJcy1mMlp1gR9ddy3cNHA32KDC8xi4LBEMYC51l4qEPy62nO00Cl8cw== X-Received: by 2002:a17:90b:3d8:b0:2a2:399c:a859 with SMTP id go24-20020a17090b03d800b002a2399ca859mr1581025pjb.35.1712898694268; Thu, 11 Apr 2024 22:11:34 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:33 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 01/13] clk: hisilicon: Add helper functions for platform driver Date: Fri, 12 Apr 2024 13:10:30 +0800 Message-ID: <20240412051041.90376-3-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Helper functions extract common operations on platform drivers. During migration to devm APIs, (virtual) fixed clocks were found hard on devm APIs, since they often depended by crucial peripherals, thus require early initialization before device probing, and cannot use devm APIs. One solution to this problem is to add a "fixed-clock" node to device tree, independent to clock device, and make those peripherals depend on that. However, there is also some devices that do use fixed clocks provided by drivers, for example clk-hi3660.c . To simplify codes, we migrate clocks of other types to devm APIs, while keep fixed clocks self-managed, alongside with struct hisi_clock_data, and remove devm-managed hisi_clock_data. hisi_clk_alloc() will be removed in the following patch. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk.c | 157 ++++++++++++++++++++++++++++++++++ drivers/clk/hisilicon/clk.h | 46 +++++++++- drivers/clk/hisilicon/crg.h | 5 ++ drivers/clk/hisilicon/reset.c | 42 +++++++++ 4 files changed, 248 insertions(+), 2 deletions(-) diff --git a/drivers/clk/hisilicon/clk.c b/drivers/clk/hisilicon/clk.c index 09368fd32bef..e50115f8e236 100644 --- a/drivers/clk/hisilicon/clk.c +++ b/drivers/clk/hisilicon/clk.c @@ -88,6 +88,25 @@ struct hisi_clock_data *hisi_clk_init(struct device_node= *np, } EXPORT_SYMBOL_GPL(hisi_clk_init); =20 +void hisi_clk_free(struct device_node *np, struct hisi_clock_data *data) +{ + if (data->clks) { + if (data->clks->fixed_rate_clks_num) + hisi_clk_unregister_fixed_rate(data->clks->fixed_rate_clks, + data->clks->fixed_rate_clks_num, + data); + if (data->clks->fixed_factor_clks_num) + hisi_clk_unregister_fixed_factor(data->clks->fixed_factor_clks, + data->clks->fixed_factor_clks_num, + data); + } + + of_clk_del_provider(np); + kfree(data->clk_data.clks); + kfree(data); +} +EXPORT_SYMBOL_GPL(hisi_clk_free); + int hisi_clk_register_fixed_rate(const struct hisi_fixed_rate_clock *clks, int nums, struct hisi_clock_data *data) { @@ -341,3 +360,141 @@ void __init hi6220_clk_register_divider(const struct = hi6220_divider_clock *clks, data->clk_data.clks[clks[i].id] =3D clk; } } + +static size_t hisi_clocks_get_nr(const struct hisi_clocks *clks) +{ + if (clks->nr) + return clks->nr; + + return clks->fixed_rate_clks_num + clks->fixed_factor_clks_num + + clks->mux_clks_num + clks->phase_clks_num + + clks->divider_clks_num + clks->gate_clks_num + + clks->gate_sep_clks_num + clks->customized_clks_num; +} + +int hisi_clk_early_init(struct device_node *np, const struct hisi_clocks *= clks) +{ + struct hisi_clock_data *data; + int ret; + + data =3D hisi_clk_init(np, hisi_clocks_get_nr(clks)); + if (!data) + return -ENOMEM; + data->clks =3D clks; + + ret =3D hisi_clk_register_fixed_rate(clks->fixed_rate_clks, + clks->fixed_rate_clks_num, data); + if (ret) + goto err; + + ret =3D hisi_clk_register_fixed_factor(clks->fixed_factor_clks, + clks->fixed_factor_clks_num, data); + if (ret) + goto err; + + np->data =3D data; + return 0; + +err: + hisi_clk_free(np, data); + return ret; +} +EXPORT_SYMBOL_GPL(hisi_clk_early_init); + +static int hisi_clk_register(struct device *dev, const struct hisi_clocks = *clks, + struct hisi_clock_data *data) +{ + int ret; + + if (clks->mux_clks_num) { + ret =3D hisi_clk_register_mux(clks->mux_clks, + clks->mux_clks_num, data); + if (ret) + return ret; + } + + if (clks->phase_clks_num) { + ret =3D hisi_clk_register_phase(dev, clks->phase_clks, + clks->phase_clks_num, data); + if (ret) + return ret; + } + + if (clks->divider_clks_num) { + ret =3D hisi_clk_register_divider(clks->divider_clks, + clks->divider_clks_num, data); + if (ret) + return ret; + } + + if (clks->gate_clks_num) { + ret =3D hisi_clk_register_gate(clks->gate_clks, + clks->gate_clks_num, data); + if (ret) + return ret; + } + + if (clks->gate_sep_clks_num) { + hisi_clk_register_gate_sep(clks->gate_sep_clks, + clks->gate_sep_clks_num, data); + } + + if (clks->clk_register_customized && clks->customized_clks_num) { + ret =3D clks->clk_register_customized(dev, clks->customized_clks, + clks->customized_clks_num, data); + if (ret) + return ret; + } + + return 0; +} + +int hisi_clk_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct device_node *np =3D dev->of_node; + const struct hisi_clocks *clks; + struct hisi_clock_data *data; + int ret; + + clks =3D of_device_get_match_data(dev); + if (!clks) + return -ENOENT; + + if (!np->data) { + ret =3D hisi_clk_early_init(np, clks); + if (ret) + return ret; + } + + data =3D np->data; + np->data =3D NULL; + + if (clks->prologue) { + ret =3D clks->prologue(dev, data); + if (ret) + goto err; + } + + ret =3D hisi_clk_register(dev, clks, data); + if (ret) + goto err; + + platform_set_drvdata(pdev, data); + return 0; + +err: + hisi_clk_free(np, data); + return ret; +} +EXPORT_SYMBOL_GPL(hisi_clk_probe); + +void hisi_clk_remove(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct device_node *np =3D dev->of_node; + struct hisi_clock_data *data =3D platform_get_drvdata(pdev); + + hisi_clk_free(np, data); +} +EXPORT_SYMBOL_GPL(hisi_clk_remove); diff --git a/drivers/clk/hisilicon/clk.h b/drivers/clk/hisilicon/clk.h index 7a9b42e1b027..87b17e9b79a3 100644 --- a/drivers/clk/hisilicon/clk.h +++ b/drivers/clk/hisilicon/clk.h @@ -17,10 +17,12 @@ #include =20 struct platform_device; +struct hisi_clocks; =20 struct hisi_clock_data { - struct clk_onecell_data clk_data; - void __iomem *base; + struct clk_onecell_data clk_data; + void __iomem *base; + const struct hisi_clocks *clks; }; =20 struct hisi_fixed_rate_clock { @@ -103,6 +105,39 @@ struct hisi_gate_clock { const char *alias; }; =20 +struct hisi_clocks { + /* if 0, sum all *_num */ + size_t nr; + + int (*prologue)(struct device *dev, struct hisi_clock_data *data); + + const struct hisi_fixed_rate_clock *fixed_rate_clks; + size_t fixed_rate_clks_num; + + const struct hisi_fixed_factor_clock *fixed_factor_clks; + size_t fixed_factor_clks_num; + + const struct hisi_mux_clock *mux_clks; + size_t mux_clks_num; + + const struct hisi_phase_clock *phase_clks; + size_t phase_clks_num; + + const struct hisi_divider_clock *divider_clks; + size_t divider_clks_num; + + const struct hisi_gate_clock *gate_clks; + size_t gate_clks_num; + + const struct hisi_gate_clock *gate_sep_clks; + size_t gate_sep_clks_num; + + const void *customized_clks; + size_t customized_clks_num; + int (*clk_register_customized)(struct device *dev, const void *clks, + size_t num, struct hisi_clock_data *data); +}; + struct clk *hisi_register_clkgate_sep(struct device *, const char *, const char *, unsigned long, void __iomem *, u8, @@ -113,6 +148,7 @@ struct clk *hi6220_register_clkdiv(struct device *dev, = const char *name, =20 struct hisi_clock_data *hisi_clk_alloc(struct platform_device *, int); struct hisi_clock_data *hisi_clk_init(struct device_node *, int); +void hisi_clk_free(struct device_node *np, struct hisi_clock_data *data); int hisi_clk_register_fixed_rate(const struct hisi_fixed_rate_clock *, int, struct hisi_clock_data *); int hisi_clk_register_fixed_factor(const struct hisi_fixed_factor_clock *, @@ -154,4 +190,10 @@ hisi_clk_unregister(mux) hisi_clk_unregister(divider) hisi_clk_unregister(gate) =20 +/* helper functions for platform driver */ + +int hisi_clk_early_init(struct device_node *np, const struct hisi_clocks *= clks); +int hisi_clk_probe(struct platform_device *pdev); +void hisi_clk_remove(struct platform_device *pdev); + #endif /* __HISI_CLK_H */ diff --git a/drivers/clk/hisilicon/crg.h b/drivers/clk/hisilicon/crg.h index 803f6ba6d7a2..bd8e76b1f6d7 100644 --- a/drivers/clk/hisilicon/crg.h +++ b/drivers/clk/hisilicon/crg.h @@ -22,4 +22,9 @@ struct hisi_crg_dev { const struct hisi_crg_funcs *funcs; }; =20 +/* helper functions for platform driver */ + +int hisi_crg_probe(struct platform_device *pdev); +void hisi_crg_remove(struct platform_device *pdev); + #endif /* __HISI_CRG_H */ diff --git a/drivers/clk/hisilicon/reset.c b/drivers/clk/hisilicon/reset.c index 93cee17db8b1..c7d4c9ea7183 100644 --- a/drivers/clk/hisilicon/reset.c +++ b/drivers/clk/hisilicon/reset.c @@ -6,11 +6,15 @@ */ =20 #include +#include #include #include #include #include #include + +#include "clk.h" +#include "crg.h" #include "reset.h" =20 #define HISI_RESET_BIT_MASK 0x1f @@ -116,3 +120,41 @@ void hisi_reset_exit(struct hisi_reset_controller *rst= c) reset_controller_unregister(&rstc->rcdev); } EXPORT_SYMBOL_GPL(hisi_reset_exit); + +int hisi_crg_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct hisi_crg_dev *crg; + int ret; + + crg =3D devm_kmalloc(dev, sizeof(*crg), GFP_KERNEL); + if (!crg) + return -ENOMEM; + + ret =3D hisi_clk_probe(pdev); + if (ret) + return ret; + + crg->rstc =3D hisi_reset_init(pdev); + if (!crg->rstc) { + ret =3D -ENOMEM; + goto err; + } + + platform_set_drvdata(pdev, crg); + return 0; + +err: + hisi_clk_remove(pdev); + return ret; +} +EXPORT_SYMBOL_GPL(hisi_crg_probe); + +void hisi_crg_remove(struct platform_device *pdev) +{ + struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); + + hisi_reset_exit(crg->rstc); + hisi_clk_remove(pdev); +} +EXPORT_SYMBOL_GPL(hisi_crg_remove); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pj1-f41.google.com (mail-pj1-f41.google.com [209.85.216.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8F2501BC53; Fri, 12 Apr 2024 05:11:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898701; cv=none; b=pdt80qhM5FP0h3dTN4H+Pf17vGPeIPO2TjC1QgCdChBK1U2opw0hQWTs1DEJyZl2YyFx7HAZY7jENaX1RBi83XFtxcx+hJo+Yo28xE6/Dwrw429ZLRMwJT0Hxk93SCMiWRE1nrieRRe1xxRBvp0yJUs4JqCspWf43lRobHKSqWE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898701; c=relaxed/simple; bh=T6lQiVWmytZHVQJAW4xa+ziFT/0SMHSrOAt1hAa7bSA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=i/CP264X37DSGH5vPedKhsMDoqj0qlfy6vx6Tp3Huphwgs75gnbFc20tNmwU5+lw/yDjINZo+HLfig1UT4CyEdKvrbbnRAM7J9ju15EhG8eKlBEN4E/4c409JKT4Vop4DGbwPin9zzHu3cXKS8mHHbf3r65T6MK2OomatzRV/k4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=DFhXIgrd; arc=none smtp.client-ip=209.85.216.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="DFhXIgrd" Received: by mail-pj1-f41.google.com with SMTP id 98e67ed59e1d1-2a53eda3272so338455a91.2; Thu, 11 Apr 2024 22:11:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898698; x=1713503498; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=NNeTl78vZFNcKOErgWglz32ctBFQT/HCoAapAxi94qA=; b=DFhXIgrdDk7LiIf5PMQeF2AryVyacD0K0gRBoADZp4DiONmUmIjGIkioVenbypb1Ci kP/rcxwsmyYCVa6GQnWPWRP/BZ1fBmSQQ/ZowTY0KGBZFKYujkjAXXs6DGBgrMjNcS2G O6KMGpBGmbg+3cZYDRxJpPSbv7BXaZzQ59H2scGkdVgs5Bqz8SnQZKRku1N2nkZWDvtx TjP2u6G7KBIYGVyfcbW+bTNYnBdC52tsW0HcCriUPNHnogGb0rZ4GfBQPfcVOoHXKPrq s4uFc3XZGBJagmsZOiRbjMCRJSoeHg7Mv7F76ipEqZSEb5BZc2qQWRLaGR1fSi73rk2o GkLA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898698; x=1713503498; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=NNeTl78vZFNcKOErgWglz32ctBFQT/HCoAapAxi94qA=; b=WoD8XQyzhJ1T7tiav6USmFswkYNZ6LtaRijds2To+Pl78hscZUtSl8Zkz+04sRzgwa z1In3tsOYdGPImINyL/TBzPibGF6fW4QvNsUwF1vTsyeqzWnQMXQODQF9k5wjCiAWRva UH8QHcFbQ0SuFWi4zNr5zk3PH3kweta2A1c6AbCABUj74uOR/cWZyBGIeKvvb0un/MqT WGJid14cH+l9MU/1Be+z9ugOY37ttHHo1UC5MtCdYx18om6iNSpNg92kMgoJLLL8gyXj AQ/jKl2SecrGBfnrjQyjTpWFWIiEyT87SDG+kBx4yChCpLxH2XXBa75gI2gue5ZYNpRf 7WZg== X-Forwarded-Encrypted: i=1; AJvYcCUzJVv1F0O22XsTdd4f//5uvemQlXkbnWspJ9JMPwvpFL9xsxYxAAG+TVANkQ2XMVNA03Efo7ho770aUKb1OeDcAzor91U1j6aYgsW6 X-Gm-Message-State: AOJu0YysZZZ1ZIF30ZKZT4GFtBY++r5/4zHhyTPZWT9DqM0WaqCXyoGV GGfIvIK9CibgcDRTatBMO42ZAMMvTEp0lW1IwbVtw7GpU9mY7UYNxbZ3J3O/ X-Google-Smtp-Source: AGHT+IGs5u5VqZv8AKZlfsbiS0F2LxhFBio+upO+psOSzRsiAe10652K4/HwYVmuB4GXIbJRtz+BAQ== X-Received: by 2002:a17:90a:c687:b0:2a2:9f46:439 with SMTP id n7-20020a17090ac68700b002a29f460439mr1662384pjt.9.1712898698387; Thu, 11 Apr 2024 22:11:38 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:38 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 02/13] clk: hisilicon: hi3516cv300: Use helper functions Date: Fri, 12 Apr 2024 13:10:31 +0800 Message-ID: <20240412051041.90376-4-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/crg-hi3516cv300.c | 171 +++--------------------- 1 file changed, 17 insertions(+), 154 deletions(-) diff --git a/drivers/clk/hisilicon/crg-hi3516cv300.c b/drivers/clk/hisilico= n/crg-hi3516cv300.c index e602e65fbc38..0e6b95d00c68 100644 --- a/drivers/clk/hisilicon/crg-hi3516cv300.c +++ b/drivers/clk/hisilicon/crg-hi3516cv300.c @@ -12,7 +12,6 @@ #include #include "clk.h" #include "crg.h" -#include "reset.h" =20 /* hi3516CV300 core CRG */ #define HI3516CV300_INNER_CLK_OFFSET 64 @@ -126,67 +125,14 @@ static const struct hisi_gate_clock hi3516cv300_gate_= clks[] =3D { { HI3516CV300_USB2_PHY_CLK, "clk_usb2_phy", NULL, 0, 0xb8, 7, 0, }, }; =20 -static struct hisi_clock_data *hi3516cv300_clk_register( - struct platform_device *pdev) -{ - struct hisi_clock_data *clk_data; - int ret; - - clk_data =3D hisi_clk_alloc(pdev, HI3516CV300_CRG_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - ret =3D hisi_clk_register_fixed_rate(hi3516cv300_fixed_rate_clks, - ARRAY_SIZE(hi3516cv300_fixed_rate_clks), clk_data); - if (ret) - return ERR_PTR(ret); - - ret =3D hisi_clk_register_mux(hi3516cv300_mux_clks, - ARRAY_SIZE(hi3516cv300_mux_clks), clk_data); - if (ret) - goto unregister_fixed_rate; - - ret =3D hisi_clk_register_gate(hi3516cv300_gate_clks, - ARRAY_SIZE(hi3516cv300_gate_clks), clk_data); - if (ret) - goto unregister_mux; - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_gate; - - return clk_data; - -unregister_gate: - hisi_clk_unregister_gate(hi3516cv300_gate_clks, - ARRAY_SIZE(hi3516cv300_gate_clks), clk_data); -unregister_mux: - hisi_clk_unregister_mux(hi3516cv300_mux_clks, - ARRAY_SIZE(hi3516cv300_mux_clks), clk_data); -unregister_fixed_rate: - hisi_clk_unregister_fixed_rate(hi3516cv300_fixed_rate_clks, - ARRAY_SIZE(hi3516cv300_fixed_rate_clks), clk_data); - return ERR_PTR(ret); -} - -static void hi3516cv300_clk_unregister(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_gate(hi3516cv300_gate_clks, - ARRAY_SIZE(hi3516cv300_gate_clks), crg->clk_data); - hisi_clk_unregister_mux(hi3516cv300_mux_clks, - ARRAY_SIZE(hi3516cv300_mux_clks), crg->clk_data); - hisi_clk_unregister_fixed_rate(hi3516cv300_fixed_rate_clks, - ARRAY_SIZE(hi3516cv300_fixed_rate_clks), crg->clk_data); -} - -static const struct hisi_crg_funcs hi3516cv300_crg_funcs =3D { - .register_clks =3D hi3516cv300_clk_register, - .unregister_clks =3D hi3516cv300_clk_unregister, +static const struct hisi_clocks hi3516cv300_crg_clks =3D { + .nr =3D HI3516CV300_CRG_NR_CLKS, + .fixed_rate_clks =3D hi3516cv300_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3516cv300_fixed_rate_clks), + .mux_clks =3D hi3516cv300_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3516cv300_mux_clks), + .gate_clks =3D hi3516cv300_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3516cv300_gate_clks), }; =20 /* hi3516CV300 sysctrl CRG */ @@ -200,118 +146,35 @@ static const struct hisi_mux_clock hi3516cv300_sysct= rl_mux_clks[] =3D { CLK_SET_RATE_PARENT, 0x0, 23, 1, 0, wdt_mux_table, }, }; =20 -static struct hisi_clock_data *hi3516cv300_sysctrl_clk_register( - struct platform_device *pdev) -{ - struct hisi_clock_data *clk_data; - int ret; - - clk_data =3D hisi_clk_alloc(pdev, HI3516CV300_SYSCTRL_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - ret =3D hisi_clk_register_mux(hi3516cv300_sysctrl_mux_clks, - ARRAY_SIZE(hi3516cv300_sysctrl_mux_clks), clk_data); - if (ret) - return ERR_PTR(ret); - - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_mux; - - return clk_data; - -unregister_mux: - hisi_clk_unregister_mux(hi3516cv300_sysctrl_mux_clks, - ARRAY_SIZE(hi3516cv300_sysctrl_mux_clks), clk_data); - return ERR_PTR(ret); -} - -static void hi3516cv300_sysctrl_clk_unregister(struct platform_device *pde= v) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_mux(hi3516cv300_sysctrl_mux_clks, - ARRAY_SIZE(hi3516cv300_sysctrl_mux_clks), - crg->clk_data); -} - -static const struct hisi_crg_funcs hi3516cv300_sysctrl_funcs =3D { - .register_clks =3D hi3516cv300_sysctrl_clk_register, - .unregister_clks =3D hi3516cv300_sysctrl_clk_unregister, +static const struct hisi_clocks hi3516cv300_sysctrl_clks =3D { + .nr =3D HI3516CV300_SYSCTRL_NR_CLKS, + .mux_clks =3D hi3516cv300_sysctrl_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3516cv300_sysctrl_mux_clks), }; =20 static const struct of_device_id hi3516cv300_crg_match_table[] =3D { { .compatible =3D "hisilicon,hi3516cv300-crg", - .data =3D &hi3516cv300_crg_funcs + .data =3D &hi3516cv300_crg_clks, }, { .compatible =3D "hisilicon,hi3516cv300-sysctrl", - .data =3D &hi3516cv300_sysctrl_funcs + .data =3D &hi3516cv300_sysctrl_clks, }, { } }; MODULE_DEVICE_TABLE(of, hi3516cv300_crg_match_table); =20 -static int hi3516cv300_crg_probe(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg; - - crg =3D devm_kmalloc(&pdev->dev, sizeof(*crg), GFP_KERNEL); - if (!crg) - return -ENOMEM; - - crg->funcs =3D of_device_get_match_data(&pdev->dev); - if (!crg->funcs) - return -ENOENT; - - crg->rstc =3D hisi_reset_init(pdev); - if (!crg->rstc) - return -ENOMEM; - - crg->clk_data =3D crg->funcs->register_clks(pdev); - if (IS_ERR(crg->clk_data)) { - hisi_reset_exit(crg->rstc); - return PTR_ERR(crg->clk_data); - } - - platform_set_drvdata(pdev, crg); - return 0; -} - -static void hi3516cv300_crg_remove(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - hisi_reset_exit(crg->rstc); - crg->funcs->unregister_clks(pdev); -} - static struct platform_driver hi3516cv300_crg_driver =3D { - .probe =3D hi3516cv300_crg_probe, - .remove_new =3D hi3516cv300_crg_remove, + .probe =3D hisi_crg_probe, + .remove_new =3D hisi_crg_remove, .driver =3D { .name =3D "hi3516cv300-crg", .of_match_table =3D hi3516cv300_crg_match_table, }, }; =20 -static int __init hi3516cv300_crg_init(void) -{ - return platform_driver_register(&hi3516cv300_crg_driver); -} -core_initcall(hi3516cv300_crg_init); - -static void __exit hi3516cv300_crg_exit(void) -{ - platform_driver_unregister(&hi3516cv300_crg_driver); -} -module_exit(hi3516cv300_crg_exit); +module_platform_driver(hi3516cv300_crg_driver); =20 MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("HiSilicon Hi3516CV300 CRG Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pf1-f181.google.com (mail-pf1-f181.google.com [209.85.210.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A4C6B1DFF5; Fri, 12 Apr 2024 05:11:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898705; cv=none; b=i0tPk50iWcVOy9z1QbScdDePzgLmyRFPw1Y+O5P2WK5rTIld6hyJ9gsZvwRgzvO3xZQjdg4H0Q2e55D3NR9s7r8KBwd++Hz/vpgXP4SBuFLoPzDU0fYlJ394K6D1jvf2P6eXnE/ogb3CYCTzitVq2snhZo2e/9JJ1Mfj+Usr0pQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898705; c=relaxed/simple; bh=jqDNrGAyxsYzMLYgVvkvn3DsQMoDqzG2Abl6HqZwq3U=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=UP6L54Q9QNz8Ky3SUKWkcx8rvCr1pmivaHSTuECWMUVb35mgO1nAjYE4kfCkEG2UUBE2mmSs+lyh3WlDFryxNecBoLqtp+TkLh6bUMDPHzqamBMrDjpTz7hM2IIOFKwHJm9ui32/1h/hqTkA/cSqZIi/QBWriJD5Rrw+M2Q/34s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=CB2mVFq8; arc=none smtp.client-ip=209.85.210.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="CB2mVFq8" Received: by mail-pf1-f181.google.com with SMTP id d2e1a72fcca58-6ed04c91c46so606124b3a.0; Thu, 11 Apr 2024 22:11:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898702; x=1713503502; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=tC6rG1fD3ItI1XoGthXm2AMsyO+JK9+EA6lFFhllInI=; b=CB2mVFq8KOS2Y2A5FJE5A+KCYEn54t63/kntes8GApz3TcKzGZj97aQI42CWgWv32S DVlyj6+TRtITC5u/0bcxzTxBXWlyBsT7lYjgwhNz3LsYDkjoijUfZhAjAKsXusxD0Zl9 XSZcjcPaMryMOhO55pLmMYiTBlLzTE2z9t6VSRlDBtmMc/bzNHGpRXUN1vCiI+p+pusO sYNc8k3Lj43xgbEQMKH7iQ56w52Ibr/WIRLQAQkgUsVLnqmNicjPR36WUBJMvDAXUqtK golJwV0gmz++Cq8TtTC62vO6J7cmA0TUc2Sw/Vjl54CcrJI3uIopK2U6/jhWYQg5W33G jUTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898702; x=1713503502; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=tC6rG1fD3ItI1XoGthXm2AMsyO+JK9+EA6lFFhllInI=; b=Wg8FfZE2K5dIItwPB+Ui3RA+DHgEhlcjKel42zm2rMt01jTfOMRCFTDBvUnEVCqhTT mLjSOM3aW3JhkoWD5dQ4A/NwrgmcLXlKRrYOZUekSzgfA20s8LEEOSbYuDk6OA1z5bSl 9eld6HbxOVQNdSuRBmqK1tSEUHNACtePmC+xARS1s8yhBLSq+CkLw3KSMnIrycme0HIA EdJpWIkH+FsK2+/ZOBCGMyDYPJAm+9yHQZ00MjtHl4CkFksfdli0IbyUwA8YlrcPOYBq 0vuauBCY9l6LTcksnWBsKqPnrElmgkhoXQJTlQnkyndoxWXUkDhaMpuOcFD7uJKUM5pE JpuQ== X-Forwarded-Encrypted: i=1; AJvYcCWbMpjxYJNKRrMEKEsBfJX0SD1nPDaQF6Pa6OPIIgojh4q1hCAcTQWP+7JmyOK+WLe5wAgjBSLV23NKWXxS8adDU+WC1ps9R45lsafh X-Gm-Message-State: AOJu0YxUrjYFKHVLvgbgLItm2TxjlDFcWkqZu1WuJ6goMn9lFUTlEt/g FVNWytbOxCKTjrk9+TATACMOxbLJ4yAjFX+JWO6FVZn0fLnqNmhN+02bZmmb X-Google-Smtp-Source: AGHT+IFvEzqiuVhGHocDVtmsh+c8BjcBpxbHbhUWcq0prVOG9lCOh8+ctqqPR3ecrPuvIQCXPqDjag== X-Received: by 2002:a05:6a20:6597:b0:1a7:4aa2:9bbf with SMTP id p23-20020a056a20659700b001a74aa29bbfmr1571122pzh.60.1712898702499; Thu, 11 Apr 2024 22:11:42 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:42 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 03/13] clk: hisilicon: hi3798cv200: Use helper functions Date: Fri, 12 Apr 2024 13:10:32 +0800 Message-ID: <20240412051041.90376-5-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/crg-hi3798cv200.c | 200 +++--------------------- 1 file changed, 22 insertions(+), 178 deletions(-) diff --git a/drivers/clk/hisilicon/crg-hi3798cv200.c b/drivers/clk/hisilico= n/crg-hi3798cv200.c index f651b197e45a..9ce590cc4142 100644 --- a/drivers/clk/hisilicon/crg-hi3798cv200.c +++ b/drivers/clk/hisilicon/crg-hi3798cv200.c @@ -12,7 +12,6 @@ #include #include "clk.h" #include "crg.h" -#include "reset.h" =20 /* hi3798CV200 core CRG */ #define HI3798CV200_INNER_CLK_OFFSET 64 @@ -41,6 +40,7 @@ =20 #define HI3798CV200_CRG_NR_CLKS 128 =20 +#define HI3798CV200_SYSCTRL_NR_CLKS 16 static const struct hisi_fixed_rate_clock hi3798cv200_fixed_rate_clks[] = =3D { { HISTB_OSC_CLK, "clk_osc", NULL, 0, 24000000, }, { HISTB_APB_CLK, "clk_apb", NULL, 0, 100000000, }, @@ -193,90 +193,18 @@ static const struct hisi_gate_clock hi3798cv200_gate_= clks[] =3D { CLK_SET_RATE_PARENT, 0xb0, 18, 0 }, }; =20 -static struct hisi_clock_data *hi3798cv200_clk_register( - struct platform_device *pdev) -{ - struct hisi_clock_data *clk_data; - int ret; - - clk_data =3D hisi_clk_alloc(pdev, HI3798CV200_CRG_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - /* hisi_phase_clock is resource managed */ - ret =3D hisi_clk_register_phase(&pdev->dev, - hi3798cv200_phase_clks, - ARRAY_SIZE(hi3798cv200_phase_clks), - clk_data); - if (ret) - return ERR_PTR(ret); - - ret =3D hisi_clk_register_fixed_rate(hi3798cv200_fixed_rate_clks, - ARRAY_SIZE(hi3798cv200_fixed_rate_clks), - clk_data); - if (ret) - return ERR_PTR(ret); - - ret =3D hisi_clk_register_mux(hi3798cv200_mux_clks, - ARRAY_SIZE(hi3798cv200_mux_clks), - clk_data); - if (ret) - goto unregister_fixed_rate; - - ret =3D hisi_clk_register_gate(hi3798cv200_gate_clks, - ARRAY_SIZE(hi3798cv200_gate_clks), - clk_data); - if (ret) - goto unregister_mux; - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_gate; - - return clk_data; - -unregister_gate: - hisi_clk_unregister_gate(hi3798cv200_gate_clks, - ARRAY_SIZE(hi3798cv200_gate_clks), - clk_data); -unregister_mux: - hisi_clk_unregister_mux(hi3798cv200_mux_clks, - ARRAY_SIZE(hi3798cv200_mux_clks), - clk_data); -unregister_fixed_rate: - hisi_clk_unregister_fixed_rate(hi3798cv200_fixed_rate_clks, - ARRAY_SIZE(hi3798cv200_fixed_rate_clks), - clk_data); - return ERR_PTR(ret); -} - -static void hi3798cv200_clk_unregister(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_gate(hi3798cv200_gate_clks, - ARRAY_SIZE(hi3798cv200_gate_clks), - crg->clk_data); - hisi_clk_unregister_mux(hi3798cv200_mux_clks, - ARRAY_SIZE(hi3798cv200_mux_clks), - crg->clk_data); - hisi_clk_unregister_fixed_rate(hi3798cv200_fixed_rate_clks, - ARRAY_SIZE(hi3798cv200_fixed_rate_clks), - crg->clk_data); -} - -static const struct hisi_crg_funcs hi3798cv200_crg_funcs =3D { - .register_clks =3D hi3798cv200_clk_register, - .unregister_clks =3D hi3798cv200_clk_unregister, +static const struct hisi_clocks hi3798cv200_crg_clks =3D { + .nr =3D HI3798CV200_CRG_NR_CLKS, + .fixed_rate_clks =3D hi3798cv200_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3798cv200_fixed_rate_clks), + .mux_clks =3D hi3798cv200_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3798cv200_mux_clks), + .phase_clks =3D hi3798cv200_phase_clks, + .phase_clks_num =3D ARRAY_SIZE(hi3798cv200_phase_clks), + .gate_clks =3D hi3798cv200_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3798cv200_gate_clks), }; =20 -/* hi3798CV200 sysctrl CRG */ - -#define HI3798CV200_SYSCTRL_NR_CLKS 16 - static const struct hisi_gate_clock hi3798cv200_sysctrl_gate_clks[] =3D { { HISTB_IR_CLK, "clk_ir", "24m", CLK_SET_RATE_PARENT, 0x48, 4, 0, }, @@ -286,115 +214,31 @@ static const struct hisi_gate_clock hi3798cv200_sysc= trl_gate_clks[] =3D { CLK_SET_RATE_PARENT, 0x48, 10, 0, }, }; =20 -static struct hisi_clock_data *hi3798cv200_sysctrl_clk_register( - struct platform_device *pdev) -{ - struct hisi_clock_data *clk_data; - int ret; - - clk_data =3D hisi_clk_alloc(pdev, HI3798CV200_SYSCTRL_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - ret =3D hisi_clk_register_gate(hi3798cv200_sysctrl_gate_clks, - ARRAY_SIZE(hi3798cv200_sysctrl_gate_clks), - clk_data); - if (ret) - return ERR_PTR(ret); - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_gate; - - return clk_data; - -unregister_gate: - hisi_clk_unregister_gate(hi3798cv200_sysctrl_gate_clks, - ARRAY_SIZE(hi3798cv200_sysctrl_gate_clks), - clk_data); - return ERR_PTR(ret); -} - -static void hi3798cv200_sysctrl_clk_unregister(struct platform_device *pde= v) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_gate(hi3798cv200_sysctrl_gate_clks, - ARRAY_SIZE(hi3798cv200_sysctrl_gate_clks), - crg->clk_data); -} - -static const struct hisi_crg_funcs hi3798cv200_sysctrl_funcs =3D { - .register_clks =3D hi3798cv200_sysctrl_clk_register, - .unregister_clks =3D hi3798cv200_sysctrl_clk_unregister, +static const struct hisi_clocks hi3798cv200_sysctrl_clks =3D { + .nr =3D HI3798CV200_SYSCTRL_NR_CLKS, + .gate_clks =3D hi3798cv200_sysctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3798cv200_sysctrl_gate_clks), }; =20 static const struct of_device_id hi3798cv200_crg_match_table[] =3D { { .compatible =3D "hisilicon,hi3798cv200-crg", - .data =3D &hi3798cv200_crg_funcs }, + .data =3D &hi3798cv200_crg_clks }, { .compatible =3D "hisilicon,hi3798cv200-sysctrl", - .data =3D &hi3798cv200_sysctrl_funcs }, + .data =3D &hi3798cv200_sysctrl_clks }, { } }; MODULE_DEVICE_TABLE(of, hi3798cv200_crg_match_table); =20 -static int hi3798cv200_crg_probe(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg; - - crg =3D devm_kmalloc(&pdev->dev, sizeof(*crg), GFP_KERNEL); - if (!crg) - return -ENOMEM; - - crg->funcs =3D of_device_get_match_data(&pdev->dev); - if (!crg->funcs) - return -ENOENT; - - crg->rstc =3D hisi_reset_init(pdev); - if (!crg->rstc) - return -ENOMEM; - - crg->clk_data =3D crg->funcs->register_clks(pdev); - if (IS_ERR(crg->clk_data)) { - hisi_reset_exit(crg->rstc); - return PTR_ERR(crg->clk_data); - } - - platform_set_drvdata(pdev, crg); - return 0; -} - -static void hi3798cv200_crg_remove(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - hisi_reset_exit(crg->rstc); - crg->funcs->unregister_clks(pdev); -} - static struct platform_driver hi3798cv200_crg_driver =3D { - .probe =3D hi3798cv200_crg_probe, - .remove_new =3D hi3798cv200_crg_remove, - .driver =3D { - .name =3D "hi3798cv200-crg", + .probe =3D hisi_crg_probe, + .remove_new =3D hisi_crg_remove, + .driver =3D { + .name =3D "hi3798cv200-crg", .of_match_table =3D hi3798cv200_crg_match_table, }, }; =20 -static int __init hi3798cv200_crg_init(void) -{ - return platform_driver_register(&hi3798cv200_crg_driver); -} -core_initcall(hi3798cv200_crg_init); - -static void __exit hi3798cv200_crg_exit(void) -{ - platform_driver_unregister(&hi3798cv200_crg_driver); -} -module_exit(hi3798cv200_crg_exit); +module_platform_driver(hi3798cv200_crg_driver); =20 MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("HiSilicon Hi3798CV200 CRG Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pf1-f179.google.com (mail-pf1-f179.google.com [209.85.210.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C325D2230F; Fri, 12 Apr 2024 05:11:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898709; cv=none; b=iaBmLkOJpRVe4W0t0d7jqxRi/Q5RLR7wEj7JFYuxzXz9XRaIM4eVeUU4yeVUdOW4U0Hs+dZo2lfZu0AN/Vxx61veHW+yKdEYDwA3Vk2adsXGWK45byVCGZm3AjEJjlmWtE3NtPukIKENKRusj7Ev25y9JC1Gmg6ZGfmxDhe5oXc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898709; c=relaxed/simple; bh=m8UmET64JFRSVNpBc2wrAPbmY40xINLq85Nvqqp+9Sw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Ip2ufXRfEjUC2OMf+6uheArhfrE2lvcc3Zz8zst5CMGFbP/qalTIPVwqfdjLdII1rpprFeQ+J/D+jFNGRXoSOovC6VGMRLbsS1jD4fMoEbwXC9VDQY9pwOGogGasHLCCY1cxmWf9y715Yu1Asji89ypRMwEIm/oMl08Bjdp8V1A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=jnBS76uQ; arc=none smtp.client-ip=209.85.210.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="jnBS76uQ" Received: by mail-pf1-f179.google.com with SMTP id d2e1a72fcca58-6eced6fd98aso553007b3a.0; Thu, 11 Apr 2024 22:11:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898707; x=1713503507; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=n7qId9+jfJUCqQ/SkIwlhCGmFKyY/JbOZZwyRJiXokA=; b=jnBS76uQEPptrNNIuu1sp5Bib9/MTmwQVPv8iz2rJLZjuPq1NgGks1eXRqvLBc3S8D OPlZR/8yHdU9Qn49Kp3wEn6OTORHocT8evfTOCpL2uD+s+XBxOoajjUzeklZWXzBmwv+ mkmBSH4pG5OPOMwJc0NK9e6IblZIO3KitmauUNWhwtEuhkm/TymKTLhfhQds5kdMxLWn okzqgbJIiHZPhCc6bfDZa7hRoaIWgzxIqY38Wbwi8Nznbp/nVw4CZNM3SKAovbAIMBCa HX+tCay5gWqAPmNtcXHIoiQZhdOajf6isGya/5BDF6hAh0PN4O0OUGKFBYHNzGVDplPc 9HFQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898707; x=1713503507; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=n7qId9+jfJUCqQ/SkIwlhCGmFKyY/JbOZZwyRJiXokA=; b=DVFkauOaIB9dYvGHbQp7bs9xvknbWbdYwsBcSNmZ+cPx8e699tSqR/Z9p+vtu6JCQR q8R9/3m03WPrwPQAbllf7hq+WJ65Y0Gw2EiQCLpjHU19inIffwFqmOXI0F+iBvIEsHnd P2gCbbf98EawyNOa78X7crbM0/psYuVw+17KdgjF10aVvsjLnuPx1B4cpYeYcJMEBN/D aD/rddCX5k915MWyXZiaIuaf/R92EWyr7ZaGxbr/GYEuRX+x3ppgdEwMmFYHFjBI/4P2 tL2+kGfz1xAu5tRn+6qb0IPsfUq+CQ6MtxTjkbewQ7xNJJsLVmhBBEfkDy/R5ANKjpq9 ODUA== X-Forwarded-Encrypted: i=1; AJvYcCWaH1SIJWyVjJlORi81Jzp3VdksWRYcOEaU/zVFvP9p94svc9hZO+uaO7M1K0Ew9K9psSAES0U32EBhKnJ7SQ8iHhVlHt1CfzzKXDIV X-Gm-Message-State: AOJu0YwcDZxkoxmzUHBJHyIAtn3aVqIkV8j87MegyGRDOkv+OBMFF+VF xaf+Bc4DCZ3WkYNCn0yhWbUkOcOQRKpc9XmSLcLIH3tqHYmMGfjtGFFEHmt7 X-Google-Smtp-Source: AGHT+IEjzTZw44VqYWO0ZLqMwP+QTBp9hJHhPOoxfo0lSDGaTCAoe7WctbVTSCpKYyglPWJsMEiMCA== X-Received: by 2002:a05:6a21:6da4:b0:1a7:2e17:efd3 with SMTP id wl36-20020a056a216da400b001a72e17efd3mr2297800pzb.5.1712898707012; Thu, 11 Apr 2024 22:11:47 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:46 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 04/13] clk: hisilicon: Remove hisi_crg_funcs Date: Fri, 12 Apr 2024 13:10:33 +0800 Message-ID: <20240412051041.90376-6-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" After refactor, no one use hisi_crg_funcs. Signed-off-by: David Yang --- drivers/clk/hisilicon/crg.h | 6 ------ 1 file changed, 6 deletions(-) diff --git a/drivers/clk/hisilicon/crg.h b/drivers/clk/hisilicon/crg.h index bd8e76b1f6d7..db2324309d41 100644 --- a/drivers/clk/hisilicon/crg.h +++ b/drivers/clk/hisilicon/crg.h @@ -11,15 +11,9 @@ struct hisi_clock_data; struct hisi_reset_controller; =20 -struct hisi_crg_funcs { - struct hisi_clock_data* (*register_clks)(struct platform_device *pdev); - void (*unregister_clks)(struct platform_device *pdev); -}; - struct hisi_crg_dev { struct hisi_clock_data *clk_data; struct hisi_reset_controller *rstc; - const struct hisi_crg_funcs *funcs; }; =20 /* helper functions for platform driver */ --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pf1-f181.google.com (mail-pf1-f181.google.com [209.85.210.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 27FE62BCF4; Fri, 12 Apr 2024 05:11:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898713; cv=none; b=uPyHafim1J4oGJMCL+2IusMlOOOmhyVBcw2r+KL1HBRZRJmSuuSgqHEYUVM9oyGs9992ttMbQdLU0TYXcJ0SEcwUXLtfQzbWd/1WgufNhzEbBQhMUgPN8lRTWf7OtVAXp2Lb5FNO1vJ3KKGybO8ry5bHcnRduv2N+qcR/iuwhxQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898713; c=relaxed/simple; bh=O6604vi/bj5igXZdGKPwpCmuP/mf360WhfeWzANdq9k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ti7Y+xc+BX6Tbpx8luN+HPv6HvLrsBPXsIRTwIqQEo3uCtvDEpjsHLuF/oZPNlxH8DXblgsmsQ3a89sr08tSJEEif7JNEL80xMlVtN4k9ovmuweiA495qAE0sdYbvAwLwdm3w7wsLTxO8Pt0gejXyoUU3P8C0R2QrQH1GBFaqkk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=RMY7Ff5f; arc=none smtp.client-ip=209.85.210.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="RMY7Ff5f" Received: by mail-pf1-f181.google.com with SMTP id d2e1a72fcca58-6ed5109d924so535480b3a.0; Thu, 11 Apr 2024 22:11:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898711; x=1713503511; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=YBKLoEacHSWOE25HfyrDdRRp12aAe56L7a96hJM6/NY=; b=RMY7Ff5fRdvbLBS+IemeRvJDkdEOtGtkNS/KgpfJl6OvGDaG5D5CEn6RO98RaSGqjL LwxFn+ASsezH8wyahApahM4i36OKosVANctQ4KMVUZjkzt0BxDvfAWZseIJig65Z+woh oh7feZ8gkjzBhBU193JTeDAkmgwgc69oM9VhlYu4qrF1OgwByhXRlWpjTJ/8X/Rs0KYb C81uT2Y5my6Iq4mz0si5prwkdPq5Fg7euL4fBfjs8Rjn+QdG9cWbjQ5lCbbCR60g/BYU rJtpvgnqpMxTTMoyKh7rhmQgFCf2dLPsfPj6rZX7FW7twzpBrwcpTa0MxfddGr22tsJ1 q2mg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898711; x=1713503511; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=YBKLoEacHSWOE25HfyrDdRRp12aAe56L7a96hJM6/NY=; b=tDTN3dgvMLNsll1eBjb/1CWtWnIp280P78FJMc+lCXAPzDfZJPmjUAt3ldms+Ff2Fo sjlBK+B7ALz1hRc49PYh+s81S/+zDk74Z8gCvedPpjIOuEcBJ8OhFKsO0L8fgyC0Tvrc J7LclE9V+zjgc0YtDQLz2UHTmSm+szAFBuC519EF1gNgBAq3rLQOMlkXEyPq0ZJjTI50 YPqNNQWjCWHcP7dPKE88iNzVUibhKkfbmD6JhM/NmIkpfBqyh3nNj0adDejgjaa8M/Hw 6Uvo5rfo2QF36zrH1VCdx6d4OD8Snzp286Z3Sf7PQazDhisr0yR/V74mKzXBEJ9lVz+k HYTA== X-Forwarded-Encrypted: i=1; AJvYcCXkUk5uFDebINWH7dgJFM6Y7HVZw5zeswFgxp+VyxWP7NfvxCmplVs/LHA/x1A3u+qeFi3LN906BVMjSTlYvPvCcyRaXDW46gq6TDf5 X-Gm-Message-State: AOJu0Yyi8TPHqAI7hwbLzZeZhX/m2wW2zuKKgBeE0ppZinvgGNp50dcO YnHR6AkKmjIABAliYeMDv0tCRvOmqJs+1xrxyxeTXAPFrLlcRZMcs/XwOzBT X-Google-Smtp-Source: AGHT+IHyBPGnZMc5WJuMbCUxix9T7pF6Kbs6ArzEq88H0oipQ7Qn+Kwmca023sw6UVexKBltNPu+CQ== X-Received: by 2002:a05:6a20:918e:b0:1a9:11f8:4889 with SMTP id v14-20020a056a20918e00b001a911f84889mr2234584pzd.10.1712898711105; Thu, 11 Apr 2024 22:11:51 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:50 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 05/13] clk: hisilicon: hi3519: Use helper functions Date: Fri, 12 Apr 2024 13:10:34 +0800 Message-ID: <20240412051041.90376-7-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi3519.c | 127 ++++------------------------- 1 file changed, 15 insertions(+), 112 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi3519.c b/drivers/clk/hisilicon/clk= -hi3519.c index 141b727ff60d..cb541de752da 100644 --- a/drivers/clk/hisilicon/clk-hi3519.c +++ b/drivers/clk/hisilicon/clk-hi3519.c @@ -10,7 +10,7 @@ #include #include #include "clk.h" -#include "reset.h" +#include "crg.h" =20 #define HI3519_INNER_CLK_OFFSET 64 #define HI3519_FIXED_24M 65 @@ -73,130 +73,33 @@ static const struct hisi_gate_clock hi3519_gate_clks[]= =3D { CLK_SET_RATE_PARENT, 0xe4, 18, 0, }, }; =20 -static struct hisi_clock_data *hi3519_clk_register(struct platform_device = *pdev) -{ - struct hisi_clock_data *clk_data; - int ret; - - clk_data =3D hisi_clk_alloc(pdev, HI3519_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - ret =3D hisi_clk_register_fixed_rate(hi3519_fixed_rate_clks, - ARRAY_SIZE(hi3519_fixed_rate_clks), - clk_data); - if (ret) - return ERR_PTR(ret); - - ret =3D hisi_clk_register_mux(hi3519_mux_clks, - ARRAY_SIZE(hi3519_mux_clks), - clk_data); - if (ret) - goto unregister_fixed_rate; - - ret =3D hisi_clk_register_gate(hi3519_gate_clks, - ARRAY_SIZE(hi3519_gate_clks), - clk_data); - if (ret) - goto unregister_mux; - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_gate; - - return clk_data; - -unregister_fixed_rate: - hisi_clk_unregister_fixed_rate(hi3519_fixed_rate_clks, - ARRAY_SIZE(hi3519_fixed_rate_clks), - clk_data); - -unregister_mux: - hisi_clk_unregister_mux(hi3519_mux_clks, - ARRAY_SIZE(hi3519_mux_clks), - clk_data); -unregister_gate: - hisi_clk_unregister_gate(hi3519_gate_clks, - ARRAY_SIZE(hi3519_gate_clks), - clk_data); - return ERR_PTR(ret); -} - -static void hi3519_clk_unregister(struct platform_device *pdev) -{ - struct hi3519_crg_data *crg =3D platform_get_drvdata(pdev); - - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_gate(hi3519_gate_clks, - ARRAY_SIZE(hi3519_gate_clks), - crg->clk_data); - hisi_clk_unregister_mux(hi3519_mux_clks, - ARRAY_SIZE(hi3519_mux_clks), - crg->clk_data); - hisi_clk_unregister_fixed_rate(hi3519_fixed_rate_clks, - ARRAY_SIZE(hi3519_fixed_rate_clks), - crg->clk_data); -} - -static int hi3519_clk_probe(struct platform_device *pdev) -{ - struct hi3519_crg_data *crg; - - crg =3D devm_kmalloc(&pdev->dev, sizeof(*crg), GFP_KERNEL); - if (!crg) - return -ENOMEM; - - crg->rstc =3D hisi_reset_init(pdev); - if (!crg->rstc) - return -ENOMEM; - - crg->clk_data =3D hi3519_clk_register(pdev); - if (IS_ERR(crg->clk_data)) { - hisi_reset_exit(crg->rstc); - return PTR_ERR(crg->clk_data); - } - - platform_set_drvdata(pdev, crg); - return 0; -} - -static void hi3519_clk_remove(struct platform_device *pdev) -{ - struct hi3519_crg_data *crg =3D platform_get_drvdata(pdev); - - hisi_reset_exit(crg->rstc); - hi3519_clk_unregister(pdev); -} - +static const struct hisi_clocks hi3519_crg_clks =3D { + .nr =3D HI3519_NR_CLKS, + .fixed_rate_clks =3D hi3519_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3519_fixed_rate_clks), + .mux_clks =3D hi3519_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3519_mux_clks), + .gate_clks =3D hi3519_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3519_gate_clks), +}; =20 static const struct of_device_id hi3519_clk_match_table[] =3D { - { .compatible =3D "hisilicon,hi3519-crg" }, + { .compatible =3D "hisilicon,hi3519-crg", + .data =3D &hi3519_crg_clks }, { } }; MODULE_DEVICE_TABLE(of, hi3519_clk_match_table); =20 static struct platform_driver hi3519_clk_driver =3D { - .probe =3D hi3519_clk_probe, - .remove_new =3D hi3519_clk_remove, + .probe =3D hisi_crg_probe, + .remove_new =3D hisi_crg_remove, .driver =3D { .name =3D "hi3519-clk", .of_match_table =3D hi3519_clk_match_table, }, }; =20 -static int __init hi3519_clk_init(void) -{ - return platform_driver_register(&hi3519_clk_driver); -} -core_initcall(hi3519_clk_init); - -static void __exit hi3519_clk_exit(void) -{ - platform_driver_unregister(&hi3519_clk_driver); -} -module_exit(hi3519_clk_exit); +module_platform_driver(hi3519_clk_driver); =20 MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("HiSilicon Hi3519 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pj1-f53.google.com (mail-pj1-f53.google.com [209.85.216.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6E858405C7; Fri, 12 Apr 2024 05:11:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898718; cv=none; b=gJgWAP5aan1cyOi6HKLzd44phvj0JNQ3jHqd2vd5+akEkJEFuuW9o85pUGHcpeDAi8rLHvQNTFKIhDTrUSADv83fZqjX+Nd/toOcRUw3RoCW4RyACTK1FQTXPtERxoYR/ioVL95SzoTHnUTHt9oB5Hi3GrVHAbms01xYxDic7wY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898718; c=relaxed/simple; bh=HfJ1S5KdKHSPKA4RYbJNyHIQ3bzwY7tI4B4y7x9pmgY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Bhl6goGdZsi78f8A2i5/GJugo7Q9oxgsSf/qpXs4cztAtxhfleQXNcg10s+P9TK/ISH9BMX+ma/yT/w8XCRxmKIQrtEEtEGZZVoJqaTULBd0bbD6/mJNJdvH+5pKrHnzuMojtWbNhEPmIZQWzGu7dbxCz0xCeEssuae0o+vJKMQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=bZ75Gxfj; arc=none smtp.client-ip=209.85.216.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="bZ75Gxfj" Received: by mail-pj1-f53.google.com with SMTP id 98e67ed59e1d1-2a2d82537efso303015a91.2; Thu, 11 Apr 2024 22:11:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898715; x=1713503515; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=rtSXYkkVUyqDmHmEVpBee9BzMAYrcrXa3fsn+yc0wAY=; b=bZ75GxfjpW5EwZPvWbWUXglqvD9UY3NYZprT1z7ehZ+BBNl3Vz/rok8k/dbW+T0xQC tUXluAcxQhGMZ/R8g/CmP3VBHuS3WT5X/4jGpIkA4cVpRw7QPkY7T7vLOa6lHV9T9v/S GANst7Da0QFymA/Dl2sYEufX6xOweZ9dFkWHSJrKprAMqUINh/Q0uhi/5GCHcWem07qx fu6pe8bOXZj39UvYJtvCM1cJH0apHZRFKKr2f82tFkaTJ36nxyjYRKHAAN5S9QprUYCZ Jj5K6Khv+F4EV8SaOzhqHZ1FfUNFQU4VKmcTbk7UcFy2ms1YMYb9rrciN86KGWkK7N/4 /xVQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898715; x=1713503515; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=rtSXYkkVUyqDmHmEVpBee9BzMAYrcrXa3fsn+yc0wAY=; b=nVVNP3ECHWFNU0PvRxk0DglWRzGsa1SZR4HcJYcvS3civY6KcF85aXHUgTWOjBNtRP CTG5CmXYe1CmDiA4tdYJN/qpRkHzuQovT6pRSqjARojWG2r9y/2vckUskj9/S/LXz7bP 2vGEFm7v59MZ61Eyj08hl7CWO7G+BSsox55iy5/iyuNNvf5tH5BBQKQj2voCrN4qznPz /y/uCTxbNHDGIPRpTLmT4AbukP8xF/GdcmZklkmXU69x8eOyex0k412c4zr4BN/WiE0h wvgwpv2GBJlVlcBP7fhu/ClJIknHFBVnvJHzl2JLnh90sHBn+CPHYWhq+Bd425zWVZUG G66A== X-Forwarded-Encrypted: i=1; AJvYcCWxXqJq1LDhUSiWppbJ4DGB9GZQX3BXByjFgEyelXSkLcv+aZo6KhsjB//BBZY1loSEdKGweAQs/ViMwuqIG6vsnqBUIdNLdGUtv4Ot X-Gm-Message-State: AOJu0YyDIBw+xBvNVIQqDKAUMDhMKbAtXFiry/UXTOcpnHtHwySkmnQR zvWr8O3etz0bOnx3on2srjutB0rMpKYt7EUGXvGNC98S30yoGQZZytCP4Ss8 X-Google-Smtp-Source: AGHT+IE+Eiym0/V6QXMZ8BBFlkVkwFHjpiivMTsYgUAHHDtZU9j9GDcbac6/29E1Lue+s8XzqE3zJQ== X-Received: by 2002:a17:90a:e50e:b0:2a5:6e51:eebd with SMTP id t14-20020a17090ae50e00b002a56e51eebdmr1731499pjy.23.1712898715281; Thu, 11 Apr 2024 22:11:55 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:54 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 06/13] clk: hisilicon: hi3559a: Use helper functions Date: Fri, 12 Apr 2024 13:10:35 +0800 Message-ID: <20240412051041.90376-8-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi3559a.c | 230 +++++----------------------- 1 file changed, 37 insertions(+), 193 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi3559a.c b/drivers/clk/hisilicon/cl= k-hi3559a.c index c79a94f6d9d2..1902d943fe34 100644 --- a/drivers/clk/hisilicon/clk-hi3559a.c +++ b/drivers/clk/hisilicon/clk-hi3559a.c @@ -11,7 +11,6 @@ #include #include #include -#include =20 #include =20 @@ -452,9 +451,11 @@ static const struct clk_ops hisi_clk_pll_ops =3D { .recalc_rate =3D clk_pll_recalc_rate, }; =20 -static void hisi_clk_register_pll(struct hi3559av100_pll_clock *clks, - int nums, struct hisi_clock_data *data, struct device *dev) +static int +hisi_clk_register_pll(struct device *dev, const void *clocks, + size_t num, struct hisi_clock_data *data) { + const struct hi3559av100_pll_clock *clks =3D clocks; void __iomem *base =3D data->base; struct hi3559av100_clk_pll *p_clk =3D NULL; struct clk *clk =3D NULL; @@ -462,10 +463,11 @@ static void hisi_clk_register_pll(struct hi3559av100_= pll_clock *clks, int i; =20 p_clk =3D devm_kcalloc(dev, nums, sizeof(*p_clk), GFP_KERNEL); + if (!p_clk) - return; + return -ENOMEM; =20 - for (i =3D 0; i < nums; i++) { + for (i =3D 0; i < num; i++) { init.name =3D clks[i].name; init.flags =3D 0; init.parent_names =3D @@ -492,78 +494,27 @@ static void hisi_clk_register_pll(struct hi3559av100_= pll_clock *clks, if (IS_ERR(clk)) { dev_err(dev, "%s: failed to register clock %s\n", __func__, clks[i].name); - continue; + return PTR_ERR(clk); } =20 data->clk_data.clks[clks[i].id] =3D clk; p_clk++; } -} - -static struct hisi_clock_data *hi3559av100_clk_register( - struct platform_device *pdev) -{ - struct hisi_clock_data *clk_data; - int ret; - - clk_data =3D hisi_clk_alloc(pdev, HI3559AV100_CRG_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - ret =3D hisi_clk_register_fixed_rate(hi3559av100_fixed_rate_clks_crg, - ARRAY_SIZE(hi3559av100_fixed_rate_clks_crg), clk_data); - if (ret) - return ERR_PTR(ret); - - hisi_clk_register_pll(hi3559av100_pll_clks, - ARRAY_SIZE(hi3559av100_pll_clks), clk_data, &pdev->dev); - - ret =3D hisi_clk_register_mux(hi3559av100_mux_clks_crg, - ARRAY_SIZE(hi3559av100_mux_clks_crg), clk_data); - if (ret) - goto unregister_fixed_rate; - - ret =3D hisi_clk_register_gate(hi3559av100_gate_clks, - ARRAY_SIZE(hi3559av100_gate_clks), clk_data); - if (ret) - goto unregister_mux; - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_gate; - - return clk_data; - -unregister_gate: - hisi_clk_unregister_gate(hi3559av100_gate_clks, - ARRAY_SIZE(hi3559av100_gate_clks), clk_data); -unregister_mux: - hisi_clk_unregister_mux(hi3559av100_mux_clks_crg, - ARRAY_SIZE(hi3559av100_mux_clks_crg), clk_data); -unregister_fixed_rate: - hisi_clk_unregister_fixed_rate(hi3559av100_fixed_rate_clks_crg, - ARRAY_SIZE(hi3559av100_fixed_rate_clks_crg), clk_data); - return ERR_PTR(ret); -} - -static void hi3559av100_clk_unregister(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); =20 - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_gate(hi3559av100_gate_clks, - ARRAY_SIZE(hi3559av100_gate_clks), crg->clk_data); - hisi_clk_unregister_mux(hi3559av100_mux_clks_crg, - ARRAY_SIZE(hi3559av100_mux_clks_crg), crg->clk_data); - hisi_clk_unregister_fixed_rate(hi3559av100_fixed_rate_clks_crg, - ARRAY_SIZE(hi3559av100_fixed_rate_clks_crg), crg->clk_data); + return 0; } =20 -static const struct hisi_crg_funcs hi3559av100_crg_funcs =3D { - .register_clks =3D hi3559av100_clk_register, - .unregister_clks =3D hi3559av100_clk_unregister, +static const struct hisi_clocks hi3559av100_clks =3D { + .nr =3D HI3559AV100_CRG_NR_CLKS, + .fixed_rate_clks =3D hi3559av100_fixed_rate_clks_crg, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3559av100_fixed_rate_clks_crg), + .mux_clks =3D hi3559av100_mux_clks_crg, + .mux_clks_num =3D ARRAY_SIZE(hi3559av100_mux_clks_crg), + .gate_clks =3D hi3559av100_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3559av100_gate_clks), + .customized_clks =3D hi3559av100_pll_clks, + .customized_clks_num =3D ARRAY_SIZE(hi3559av100_pll_clks), + .clk_register_customized =3D hisi_clk_register_pll, }; =20 static struct hisi_fixed_rate_clock hi3559av100_shub_fixed_rate_clks[] =3D= { @@ -671,7 +622,7 @@ static struct hisi_gate_clock hi3559av100_shub_gate_clk= s[] =3D { }, }; =20 -static int hi3559av100_shub_default_clk_set(void) +static int hi3559av100_shub_default_clk_set(struct device *dev, struct his= i_clock_data *data) { void __iomem *crg_base; unsigned int val; @@ -694,148 +645,41 @@ static int hi3559av100_shub_default_clk_set(void) return 0; } =20 -static struct hisi_clock_data *hi3559av100_shub_clk_register( - struct platform_device *pdev) -{ - struct hisi_clock_data *clk_data =3D NULL; - int ret; - - hi3559av100_shub_default_clk_set(); - - clk_data =3D hisi_clk_alloc(pdev, HI3559AV100_SHUB_NR_CLKS); - if (!clk_data) - return ERR_PTR(-ENOMEM); - - ret =3D hisi_clk_register_fixed_rate(hi3559av100_shub_fixed_rate_clks, - ARRAY_SIZE(hi3559av100_shub_fixed_rate_clks), clk_data); - if (ret) - return ERR_PTR(ret); - - ret =3D hisi_clk_register_mux(hi3559av100_shub_mux_clks, - ARRAY_SIZE(hi3559av100_shub_mux_clks), clk_data); - if (ret) - goto unregister_fixed_rate; - - ret =3D hisi_clk_register_divider(hi3559av100_shub_div_clks, - ARRAY_SIZE(hi3559av100_shub_div_clks), clk_data); - if (ret) - goto unregister_mux; - - ret =3D hisi_clk_register_gate(hi3559av100_shub_gate_clks, - ARRAY_SIZE(hi3559av100_shub_gate_clks), clk_data); - if (ret) - goto unregister_factor; - - ret =3D of_clk_add_provider(pdev->dev.of_node, - of_clk_src_onecell_get, &clk_data->clk_data); - if (ret) - goto unregister_gate; - - return clk_data; - -unregister_gate: - hisi_clk_unregister_gate(hi3559av100_shub_gate_clks, - ARRAY_SIZE(hi3559av100_shub_gate_clks), clk_data); -unregister_factor: - hisi_clk_unregister_divider(hi3559av100_shub_div_clks, - ARRAY_SIZE(hi3559av100_shub_div_clks), clk_data); -unregister_mux: - hisi_clk_unregister_mux(hi3559av100_shub_mux_clks, - ARRAY_SIZE(hi3559av100_shub_mux_clks), clk_data); -unregister_fixed_rate: - hisi_clk_unregister_fixed_rate(hi3559av100_shub_fixed_rate_clks, - ARRAY_SIZE(hi3559av100_shub_fixed_rate_clks), clk_data); - return ERR_PTR(ret); -} - -static void hi3559av100_shub_clk_unregister(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - of_clk_del_provider(pdev->dev.of_node); - - hisi_clk_unregister_gate(hi3559av100_shub_gate_clks, - ARRAY_SIZE(hi3559av100_shub_gate_clks), crg->clk_data); - hisi_clk_unregister_divider(hi3559av100_shub_div_clks, - ARRAY_SIZE(hi3559av100_shub_div_clks), crg->clk_data); - hisi_clk_unregister_mux(hi3559av100_shub_mux_clks, - ARRAY_SIZE(hi3559av100_shub_mux_clks), crg->clk_data); - hisi_clk_unregister_fixed_rate(hi3559av100_shub_fixed_rate_clks, - ARRAY_SIZE(hi3559av100_shub_fixed_rate_clks), crg->clk_data); -} - -static const struct hisi_crg_funcs hi3559av100_shub_crg_funcs =3D { - .register_clks =3D hi3559av100_shub_clk_register, - .unregister_clks =3D hi3559av100_shub_clk_unregister, +static const struct hisi_clocks hi3559av100_shub_clks =3D { + .nr =3D HI3559AV100_SHUB_NR_CLKS, + .prologue =3D hi3559av100_shub_default_clk_set, + .fixed_rate_clks =3D hi3559av100_shub_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3559av100_shub_fixed_rate_clks), + .mux_clks =3D hi3559av100_shub_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3559av100_shub_mux_clks), + .divider_clks =3D hi3559av100_shub_div_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3559av100_shub_div_clks), + .gate_clks =3D hi3559av100_shub_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3559av100_shub_gate_clks), }; =20 static const struct of_device_id hi3559av100_crg_match_table[] =3D { { .compatible =3D "hisilicon,hi3559av100-clock", - .data =3D &hi3559av100_crg_funcs + .data =3D &hi3559av100_clks }, { .compatible =3D "hisilicon,hi3559av100-shub-clock", - .data =3D &hi3559av100_shub_crg_funcs + .data =3D &hi3559av100_shub_clks }, { } }; MODULE_DEVICE_TABLE(of, hi3559av100_crg_match_table); =20 -static int hi3559av100_crg_probe(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg; - - crg =3D devm_kmalloc(&pdev->dev, sizeof(*crg), GFP_KERNEL); - if (!crg) - return -ENOMEM; - - crg->funcs =3D of_device_get_match_data(&pdev->dev); - if (!crg->funcs) - return -ENOENT; - - crg->rstc =3D hisi_reset_init(pdev); - if (!crg->rstc) - return -ENOMEM; - - crg->clk_data =3D crg->funcs->register_clks(pdev); - if (IS_ERR(crg->clk_data)) { - hisi_reset_exit(crg->rstc); - return PTR_ERR(crg->clk_data); - } - - platform_set_drvdata(pdev, crg); - return 0; -} - -static void hi3559av100_crg_remove(struct platform_device *pdev) -{ - struct hisi_crg_dev *crg =3D platform_get_drvdata(pdev); - - hisi_reset_exit(crg->rstc); - crg->funcs->unregister_clks(pdev); -} - static struct platform_driver hi3559av100_crg_driver =3D { - .probe =3D hi3559av100_crg_probe, - .remove_new =3D hi3559av100_crg_remove, + .probe =3D hisi_crg_probe, + .remove_new =3D hisi_crg_remove, .driver =3D { .name =3D "hi3559av100-clock", .of_match_table =3D hi3559av100_crg_match_table, }, }; =20 -static int __init hi3559av100_crg_init(void) -{ - return platform_driver_register(&hi3559av100_crg_driver); -} -core_initcall(hi3559av100_crg_init); - -static void __exit hi3559av100_crg_exit(void) -{ - platform_driver_unregister(&hi3559av100_crg_driver); -} -module_exit(hi3559av100_crg_exit); - +module_platform_driver(hi3559av100_crg_driver); =20 MODULE_DESCRIPTION("HiSilicon Hi3559AV100 CRG Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pg1-f175.google.com (mail-pg1-f175.google.com [209.85.215.175]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CCAB23F9CC; Fri, 12 Apr 2024 05:12:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898722; cv=none; b=j7HwUx1kfuKtTLyY8DBWFvUCqAedLqoG4AGoFzzCTGIT25OCrfKLvl0pHZwgHBDRL7z6BLADhiNt3u1XHGvItP4kirG13513nQTow6+opJwnYLA5PP70BHEowp1un++dqyY4ROD/AfWvdnciOJnNNSZX5DdZ75JkBU1eJee5JGk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898722; c=relaxed/simple; bh=CoPdM7gWgxzc4l9ttrmWpcv9QLyj1sEO29fhIflzIZg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BwEUelhm0S16xLFUZU7Zj9dGhdqNbstEFDKgNJzvm/ET2UCDrTf84bKFXLmoVJ4XUPvkIoZUN40P7NHmIriTaWX6nad67tPls7nHTfUL7V+/W4W/96YJhE+2HHpju8Lk1gr9NtejMCpQVYVrMqgVt9drsLYTuQW3SsxArgbj6jA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=nXX5c/7/; arc=none smtp.client-ip=209.85.215.175 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="nXX5c/7/" Received: by mail-pg1-f175.google.com with SMTP id 41be03b00d2f7-5ca29c131ebso383730a12.0; Thu, 11 Apr 2024 22:12:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898719; x=1713503519; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=LVxLPB3ir51RqOrUeQ4RuKuT1LuXZfsGpQp9xlrvQqA=; b=nXX5c/7/H2tZFA0W/dn7VnqoXunPqWOgUDiGUkIuGAHOJhMPDIvfEzIHiEU+TIIzjI NZ9z/qK83dj3qG2XCV7NFo7VmjF49gQNopa4Qz+qPjVYe1JMz5eLwnmSOa5CnPFkDROl pgSbNie8Sj4ucJa2Hammdh4eTeM+RC0l73hQY1yBGIsvWIFaBPr8y/75/PixPq5+XwWU MAP1+YisjbLHBhhcoZwwBiV01+TbQ3AM5PCXsZvJfiCbGP7k86+BNaKNTNv1LVpUIfc6 cEAGhFTmbIMPcN4ZyAyimQQf3QL3syGeVX4dt4eaZ68qcAFG+4gVwGm3u0XJFisIiQCa hJrw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898719; x=1713503519; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=LVxLPB3ir51RqOrUeQ4RuKuT1LuXZfsGpQp9xlrvQqA=; b=qTcUELQhRVHqba2dVtKLHSZdZhvdPLR7F9UDInUoKwR43G9Cbni0B+z9BF0F2SSH3P HY89C1suAD89cIpuEjjM4gT3KyOj5jCpC1KfS9vCQg/jRRKlrKastxXcMjwr3vtzzn4W 7FJVzQErMMRuSqtavLlXlWBvmA1GUvQps3gqJ+5NqEnKLe30pyJcIcmYB7Kzrnajy2J/ as6UavwfmESP3xbmAU09wl+YfEngpnjHYpLsHeGagZcRt+e6mB3P2MjbGkvtSNT1PMEZ r8WGYTkF3JvALvaeM71eOLSwN3asocfI3urZQonplbwIRa+D1LJfcFvMkLbpZOrux057 9sZA== X-Forwarded-Encrypted: i=1; AJvYcCUezWah3Vj8WUyVJaIpRiiG6s6pcu8mkc6YJ2NCCj0Lurf2Dv7VfGLZxS9MOLpOlOJSHJwbjuY490WR/q8YNKXuJ5+fLz1+6hUKBRcz X-Gm-Message-State: AOJu0Yxek8FPOZ/qSUD7oKndqsHAB5JMWhqYM+DRJkk4jfCPN+RkQrZd 6dkxXx9RIJ04YvDTdgk6dDJ2TcbddHBJpORhSGphFgKveMAVmELFGO3dSaqN X-Google-Smtp-Source: AGHT+IGNJe6ntWWy0O3zY9TaBOK7Ai4JklhbrhqR7EPGK3N0Wa+SO+fbkfgXLS/Wf4w7ykqOtolxnA== X-Received: by 2002:a05:6a20:5649:b0:1a7:807:ca2 with SMTP id is9-20020a056a20564900b001a708070ca2mr1846518pzc.29.1712898719429; Thu, 11 Apr 2024 22:11:59 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:11:59 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 07/13] clk: hisilicon: hi3660: Convert into module Date: Fri, 12 Apr 2024 13:10:36 +0800 Message-ID: <20240412051041.90376-9-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi3660.c | 194 ++++++++--------------------- 1 file changed, 54 insertions(+), 140 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi3660.c b/drivers/clk/hisilicon/clk= -hi3660.c index 50f13dbb0e48..7fc5c16e5264 100644 --- a/drivers/clk/hisilicon/clk-hi3660.c +++ b/drivers/clk/hisilicon/clk-hi3660.c @@ -5,9 +5,13 @@ */ =20 #include + #include -#include +#include +#include +#include #include + #include "clk.h" =20 static const struct hisi_fixed_rate_clock hi3660_fixed_rate_clks[] =3D { @@ -469,169 +473,79 @@ static const struct hisi_gate_clock hi3660_iomcu_gat= e_sep_clks[] =3D { CLK_SET_RATE_PARENT, 0x90, 0, 0, }, }; =20 -static struct hisi_clock_data *clk_crgctrl_data; - -static void hi3660_clk_iomcu_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3660_iomcu_gate_sep_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate_sep(hi3660_iomcu_gate_sep_clks, - ARRAY_SIZE(hi3660_iomcu_gate_sep_clks), - clk_data); -} - -static void hi3660_clk_pmuctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3660_pmu_gate_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate(hi3660_pmu_gate_clks, - ARRAY_SIZE(hi3660_pmu_gate_clks), clk_data); -} +static const struct hisi_clocks hi3660_clk_iomcu_clks =3D { + .gate_sep_clks =3D hi3660_iomcu_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3660_iomcu_gate_sep_clks), +}; =20 -static void hi3660_clk_pctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3660_pctrl_gate_clks); +static const struct hisi_clocks hi3660_clk_pmuctrl_clks =3D { + .gate_clks =3D hi3660_pmu_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3660_pmu_gate_clks), +}; =20 - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - hisi_clk_register_gate(hi3660_pctrl_gate_clks, - ARRAY_SIZE(hi3660_pctrl_gate_clks), clk_data); -} +static const struct hisi_clocks hi3660_clk_pctrl_clks =3D { + .gate_clks =3D hi3660_pctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3660_pctrl_gate_clks), +}; =20 -static void hi3660_clk_sctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3660_sctrl_gate_clks) + - ARRAY_SIZE(hi3660_sctrl_gate_sep_clks) + - ARRAY_SIZE(hi3660_sctrl_mux_clks) + - ARRAY_SIZE(hi3660_sctrl_divider_clks); +static const struct hisi_clocks hi3660_clk_sctrl_clks =3D { + .mux_clks =3D hi3660_sctrl_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3660_sctrl_mux_clks), + .divider_clks =3D hi3660_sctrl_divider_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3660_sctrl_divider_clks), + .gate_clks =3D hi3660_sctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3660_sctrl_gate_clks), + .gate_sep_clks =3D hi3660_sctrl_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3660_sctrl_gate_sep_clks), +}; =20 - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - hisi_clk_register_gate(hi3660_sctrl_gate_clks, - ARRAY_SIZE(hi3660_sctrl_gate_clks), clk_data); - hisi_clk_register_gate_sep(hi3660_sctrl_gate_sep_clks, - ARRAY_SIZE(hi3660_sctrl_gate_sep_clks), - clk_data); - hisi_clk_register_mux(hi3660_sctrl_mux_clks, - ARRAY_SIZE(hi3660_sctrl_mux_clks), clk_data); - hisi_clk_register_divider(hi3660_sctrl_divider_clks, - ARRAY_SIZE(hi3660_sctrl_divider_clks), - clk_data); -} +static const struct hisi_clocks hi3660_clk_crgctrl_clks =3D { + .fixed_rate_clks =3D hi3660_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3660_fixed_rate_clks), + .fixed_factor_clks =3D hi3660_crg_fixed_factor_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hi3660_crg_fixed_factor_clks), + .mux_clks =3D hi3660_crgctrl_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3660_crgctrl_mux_clks), + .divider_clks =3D hi3660_crgctrl_divider_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3660_crgctrl_divider_clks), + .gate_clks =3D hi3660_crgctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3660_crgctrl_gate_clks), + .gate_sep_clks =3D hi3660_crgctrl_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3660_crgctrl_gate_sep_clks), +}; =20 static void hi3660_clk_crgctrl_early_init(struct device_node *np) { - int nr =3D ARRAY_SIZE(hi3660_fixed_rate_clks) + - ARRAY_SIZE(hi3660_crgctrl_gate_sep_clks) + - ARRAY_SIZE(hi3660_crgctrl_gate_clks) + - ARRAY_SIZE(hi3660_crgctrl_mux_clks) + - ARRAY_SIZE(hi3660_crg_fixed_factor_clks) + - ARRAY_SIZE(hi3660_crgctrl_divider_clks); - int i; - - clk_crgctrl_data =3D hisi_clk_init(np, nr); - if (!clk_crgctrl_data) - return; - - for (i =3D 0; i < nr; i++) - clk_crgctrl_data->clk_data.clks[i] =3D ERR_PTR(-EPROBE_DEFER); - - hisi_clk_register_fixed_rate(hi3660_fixed_rate_clks, - ARRAY_SIZE(hi3660_fixed_rate_clks), - clk_crgctrl_data); + hisi_clk_early_init(np, &hi3660_clk_crgctrl_clks); } CLK_OF_DECLARE_DRIVER(hi3660_clk_crgctrl, "hisilicon,hi3660-crgctrl", hi3660_clk_crgctrl_early_init); =20 -static void hi3660_clk_crgctrl_init(struct device_node *np) -{ - struct clk **clks; - int i; - - if (!clk_crgctrl_data) - hi3660_clk_crgctrl_early_init(np); - - /* clk_crgctrl_data initialization failed */ - if (!clk_crgctrl_data) - return; - - hisi_clk_register_gate_sep(hi3660_crgctrl_gate_sep_clks, - ARRAY_SIZE(hi3660_crgctrl_gate_sep_clks), - clk_crgctrl_data); - hisi_clk_register_gate(hi3660_crgctrl_gate_clks, - ARRAY_SIZE(hi3660_crgctrl_gate_clks), - clk_crgctrl_data); - hisi_clk_register_mux(hi3660_crgctrl_mux_clks, - ARRAY_SIZE(hi3660_crgctrl_mux_clks), - clk_crgctrl_data); - hisi_clk_register_fixed_factor(hi3660_crg_fixed_factor_clks, - ARRAY_SIZE(hi3660_crg_fixed_factor_clks), - clk_crgctrl_data); - hisi_clk_register_divider(hi3660_crgctrl_divider_clks, - ARRAY_SIZE(hi3660_crgctrl_divider_clks), - clk_crgctrl_data); - - clks =3D clk_crgctrl_data->clk_data.clks; - for (i =3D 0; i < clk_crgctrl_data->clk_data.clk_num; i++) { - if (IS_ERR(clks[i]) && PTR_ERR(clks[i]) !=3D -EPROBE_DEFER) - pr_err("Failed to register crgctrl clock[%d] err=3D%ld\n", - i, PTR_ERR(clks[i])); - } -} - static const struct of_device_id hi3660_clk_match_table[] =3D { { .compatible =3D "hisilicon,hi3660-crgctrl", - .data =3D hi3660_clk_crgctrl_init }, + .data =3D &hi3660_clk_crgctrl_clks }, { .compatible =3D "hisilicon,hi3660-pctrl", - .data =3D hi3660_clk_pctrl_init }, + .data =3D &hi3660_clk_pctrl_clks }, { .compatible =3D "hisilicon,hi3660-pmuctrl", - .data =3D hi3660_clk_pmuctrl_init }, + .data =3D &hi3660_clk_pmuctrl_clks }, { .compatible =3D "hisilicon,hi3660-sctrl", - .data =3D hi3660_clk_sctrl_init }, + .data =3D &hi3660_clk_sctrl_clks }, { .compatible =3D "hisilicon,hi3660-iomcu", - .data =3D hi3660_clk_iomcu_init }, + .data =3D &hi3660_clk_iomcu_clks }, { } }; - -static int hi3660_clk_probe(struct platform_device *pdev) -{ - struct device *dev =3D &pdev->dev; - struct device_node *np =3D pdev->dev.of_node; - void (*init_func)(struct device_node *np); - - init_func =3D of_device_get_match_data(dev); - if (!init_func) - return -ENODEV; - - init_func(np); - - return 0; -} +MODULE_DEVICE_TABLE(of, hi3660_clk_match_table); =20 static struct platform_driver hi3660_clk_driver =3D { - .probe =3D hi3660_clk_probe, + .probe =3D hisi_clk_probe, + .remove_new =3D hisi_clk_remove, .driver =3D { .name =3D "hi3660-clk", .of_match_table =3D hi3660_clk_match_table, }, }; =20 -static int __init hi3660_clk_init(void) -{ - return platform_driver_register(&hi3660_clk_driver); -} -core_initcall(hi3660_clk_init); +module_platform_driver(hi3660_clk_driver); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("HiSilicon Hi3660 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pg1-f179.google.com (mail-pg1-f179.google.com [209.85.215.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7B9A644C73; Fri, 12 Apr 2024 05:12:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898726; cv=none; b=DXYM2qgkF5ePEnMlqH+34lkivIO5cfD38JIMSwqZSIqkfFR6gUO5KglxqfoihjVSKAXaiWaHQGyN9G6daQTlLMB/pSSsiOFbONthW78JvwTq+F0y/5sXp35Diyvc1tRRBdQZ/Ah1CzRfKw31hy6ly8JGoNDtETaoKSnF7t08ncU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898726; c=relaxed/simple; bh=pk6yWl/RNdZzOeycoEC/b30bS65iojlOAy7XjiYgCzY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=W4IoDuRrJv/tb4LnOBmHykxH6WIZ8NFf8uX3JWJNfjsqtVc9BTWHeHtm2I3GWzYNT0t6nVJF7Vc4zBvCv4Yz7DA4VTzWU4bRn20yPd8sYbNgrEOIy9V2FruewCtWcWi/rYEvfgX13HtkoIjhLgY2iWclx8usjhyzrvSLaayFUDE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=LY3Kcb4G; arc=none smtp.client-ip=209.85.215.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="LY3Kcb4G" Received: by mail-pg1-f179.google.com with SMTP id 41be03b00d2f7-5c66b093b86so1163446a12.0; Thu, 11 Apr 2024 22:12:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898724; x=1713503524; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=JN8cCX+UgxQKSAyjiVn+CX8QDt1QPDveAfP0mG3Jhlw=; b=LY3Kcb4Gp0us/33TJLVPnwsBXKz6gbF0K8NYKio10YAZSmpFWwm4MdyNWm/wE9L/B+ c+yD3gTqPQX8m185gCAIVo8UY5DyqrwNpNMeR89nrqTLe7Otm8syBD9aIIo6N4KmYddf kCmpQNcUX7vECuBTuob9f4f86FUh8mI78NoLwSObuteMZ2JCj532aaRTrjn4t09KdPXC 7IqjnZ2g9iIf0lBapCbF+3S9DCRf9ox63wTQYs3fV96h+aVhySZRWdBHkFeaK5VaPxcw KiJnsCPrCDRqOrl/xd8KiBdI4fUoKtPj5KuE4sal8y8QENWWBf6AxpZHSD90M39+XYqM lwHQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898724; x=1713503524; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=JN8cCX+UgxQKSAyjiVn+CX8QDt1QPDveAfP0mG3Jhlw=; b=mW8E196xj4T9epUiQHQjwgXeEJuEDba3IOXGo4/ZyN4olu48RswNEp/uYR08c7VhDD gWmd817ySQOCKTv509hP5EfM4kyMX+SOO165okDGprIGsZ8vyP164r2jqS7Pu8syFWjx aXkjt7URFS5xYmmJkB51WWV7W1wGAxr2A9epse+Jts8PuN1c2UqgW0kWHgHskqCxm1/8 s0Cbkr9Ixaruj8lT7zlubfIvITegyCgffByyj8rkDgOzZ30qAQpFbvFVh1swBHnFFj01 hYvcoBcAMSb5Y0oNMbmTiVYeFCIJmuzW5T+ZoVFQh65o6dFG5dBYoKfGKe3OfZCeF9KZ +t7w== X-Forwarded-Encrypted: i=1; AJvYcCULrLegvfcgooP8P7TqnvL5JnkhqVDjYUodjrqWxq8eTuq3gVlsH7SwieG4dhQeN9dL5xVGCOFB1V+pZL9/26cYFwNKrPAnV1VsX7P2 X-Gm-Message-State: AOJu0YxsIf4K4pT3EqFOl+q/I4KgNnUnpAnuFSGw5t8YXolWon8u+Kx+ b6p1k+FPnqEti88YNtL5g4L+biU6LCd6nJwoXj4yobDfwezyEBtv4pbKn950 X-Google-Smtp-Source: AGHT+IHjl45YfDa/RI4Sygfm5ze0DN6Fz1sT/82NG54K+DW/SL/Wf+Y6vFoYDUWxtAJ2VAzfed/55g== X-Received: by 2002:a17:90b:8cb:b0:2a5:3c66:25a8 with SMTP id ds11-20020a17090b08cb00b002a53c6625a8mr6468109pjb.15.1712898723607; Thu, 11 Apr 2024 22:12:03 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.11.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:12:03 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 08/13] clk: hisilicon: hi3670: Convert into module Date: Fri, 12 Apr 2024 13:10:37 +0800 Message-ID: <20240412051041.90376-10-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi3670.c | 250 +++++++++-------------------- 1 file changed, 76 insertions(+), 174 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi3670.c b/drivers/clk/hisilicon/clk= -hi3670.c index fa20ad144c8e..b6005be71290 100644 --- a/drivers/clk/hisilicon/clk-hi3670.c +++ b/drivers/clk/hisilicon/clk-hi3670.c @@ -9,8 +9,11 @@ =20 #include #include -#include +#include +#include +#include #include + #include "clk.h" =20 static const struct hisi_fixed_rate_clock hi3670_fixed_rate_clks[] =3D { @@ -822,195 +825,94 @@ static const struct hisi_gate_clock hi3670_media2_ga= te_sep_clks[] =3D { CLK_SET_RATE_PARENT, 0x00, 2, 0, }, }; =20 -static void hi3670_clk_crgctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - int nr =3D ARRAY_SIZE(hi3670_fixed_rate_clks) + - ARRAY_SIZE(hi3670_crgctrl_gate_sep_clks) + - ARRAY_SIZE(hi3670_crgctrl_gate_clks) + - ARRAY_SIZE(hi3670_crgctrl_mux_clks) + - ARRAY_SIZE(hi3670_crg_fixed_factor_clks) + - ARRAY_SIZE(hi3670_crgctrl_divider_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_fixed_rate(hi3670_fixed_rate_clks, - ARRAY_SIZE(hi3670_fixed_rate_clks), - clk_data); - hisi_clk_register_gate_sep(hi3670_crgctrl_gate_sep_clks, - ARRAY_SIZE(hi3670_crgctrl_gate_sep_clks), - clk_data); - hisi_clk_register_gate(hi3670_crgctrl_gate_clks, - ARRAY_SIZE(hi3670_crgctrl_gate_clks), - clk_data); - hisi_clk_register_mux(hi3670_crgctrl_mux_clks, - ARRAY_SIZE(hi3670_crgctrl_mux_clks), - clk_data); - hisi_clk_register_fixed_factor(hi3670_crg_fixed_factor_clks, - ARRAY_SIZE(hi3670_crg_fixed_factor_clks), - clk_data); - hisi_clk_register_divider(hi3670_crgctrl_divider_clks, - ARRAY_SIZE(hi3670_crgctrl_divider_clks), - clk_data); -} - -static void hi3670_clk_pctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3670_pctrl_gate_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - hisi_clk_register_gate(hi3670_pctrl_gate_clks, - ARRAY_SIZE(hi3670_pctrl_gate_clks), clk_data); -} - -static void hi3670_clk_pmuctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3670_pmu_gate_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate(hi3670_pmu_gate_clks, - ARRAY_SIZE(hi3670_pmu_gate_clks), clk_data); -} - -static void hi3670_clk_sctrl_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3670_sctrl_gate_sep_clks) + - ARRAY_SIZE(hi3670_sctrl_gate_clks) + - ARRAY_SIZE(hi3670_sctrl_mux_clks) + - ARRAY_SIZE(hi3670_sctrl_divider_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate_sep(hi3670_sctrl_gate_sep_clks, - ARRAY_SIZE(hi3670_sctrl_gate_sep_clks), - clk_data); - hisi_clk_register_gate(hi3670_sctrl_gate_clks, - ARRAY_SIZE(hi3670_sctrl_gate_clks), - clk_data); - hisi_clk_register_mux(hi3670_sctrl_mux_clks, - ARRAY_SIZE(hi3670_sctrl_mux_clks), - clk_data); - hisi_clk_register_divider(hi3670_sctrl_divider_clks, - ARRAY_SIZE(hi3670_sctrl_divider_clks), - clk_data); -} - -static void hi3670_clk_iomcu_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi3670_iomcu_gate_sep_clks) + - ARRAY_SIZE(hi3670_iomcu_fixed_factor_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate(hi3670_iomcu_gate_sep_clks, - ARRAY_SIZE(hi3670_iomcu_gate_sep_clks), clk_data); - - hisi_clk_register_fixed_factor(hi3670_iomcu_fixed_factor_clks, - ARRAY_SIZE(hi3670_iomcu_fixed_factor_clks), - clk_data); -} - -static void hi3670_clk_media1_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - int nr =3D ARRAY_SIZE(hi3670_media1_gate_sep_clks) + - ARRAY_SIZE(hi3670_media1_gate_clks) + - ARRAY_SIZE(hi3670_media1_mux_clks) + - ARRAY_SIZE(hi3670_media1_divider_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate_sep(hi3670_media1_gate_sep_clks, - ARRAY_SIZE(hi3670_media1_gate_sep_clks), - clk_data); - hisi_clk_register_gate(hi3670_media1_gate_clks, - ARRAY_SIZE(hi3670_media1_gate_clks), - clk_data); - hisi_clk_register_mux(hi3670_media1_mux_clks, - ARRAY_SIZE(hi3670_media1_mux_clks), - clk_data); - hisi_clk_register_divider(hi3670_media1_divider_clks, - ARRAY_SIZE(hi3670_media1_divider_clks), - clk_data); -} - -static void hi3670_clk_media2_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - int nr =3D ARRAY_SIZE(hi3670_media2_gate_sep_clks); - - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; - - hisi_clk_register_gate_sep(hi3670_media2_gate_sep_clks, - ARRAY_SIZE(hi3670_media2_gate_sep_clks), - clk_data); -} +static const struct hisi_clocks hi3670_clk_crgctrl_clks =3D { + .fixed_rate_clks =3D hi3670_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3670_fixed_rate_clks), + .fixed_factor_clks =3D hi3670_crg_fixed_factor_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hi3670_crg_fixed_factor_clks), + .mux_clks =3D hi3670_crgctrl_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3670_crgctrl_mux_clks), + .divider_clks =3D hi3670_crgctrl_divider_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3670_crgctrl_divider_clks), + .gate_clks =3D hi3670_crgctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3670_crgctrl_gate_clks), + .gate_sep_clks =3D hi3670_crgctrl_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3670_crgctrl_gate_sep_clks), +}; + +static const struct hisi_clocks hi3670_clk_pctrl_clks =3D { + .gate_clks =3D hi3670_pctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3670_pctrl_gate_clks), +}; + +static const struct hisi_clocks hi3670_clk_pmuctrl_clks =3D { + .gate_clks =3D hi3670_pmu_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3670_pmu_gate_clks), +}; + +static const struct hisi_clocks hi3670_clk_sctrl_clks =3D { + .mux_clks =3D hi3670_sctrl_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3670_sctrl_mux_clks), + .divider_clks =3D hi3670_sctrl_divider_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3670_sctrl_divider_clks), + .gate_clks =3D hi3670_sctrl_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3670_sctrl_gate_clks), + .gate_sep_clks =3D hi3670_sctrl_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3670_sctrl_gate_sep_clks), +}; + +static const struct hisi_clocks hi3670_clk_iomcu_clks =3D { + .fixed_factor_clks =3D hi3670_iomcu_fixed_factor_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hi3670_iomcu_fixed_factor_clks), + .gate_clks =3D hi3670_iomcu_gate_sep_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3670_iomcu_gate_sep_clks), +}; + +static const struct hisi_clocks hi3670_clk_media1_clks =3D { + .mux_clks =3D hi3670_media1_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3670_media1_mux_clks), + .divider_clks =3D hi3670_media1_divider_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3670_media1_divider_clks), + .gate_clks =3D hi3670_media1_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hi3670_media1_gate_clks), + .gate_sep_clks =3D hi3670_media1_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3670_media1_gate_sep_clks), +}; + +static const struct hisi_clocks hi3670_clk_media2_clks =3D { + .gate_sep_clks =3D hi3670_media2_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3670_media2_gate_sep_clks), +}; =20 static const struct of_device_id hi3670_clk_match_table[] =3D { { .compatible =3D "hisilicon,hi3670-crgctrl", - .data =3D hi3670_clk_crgctrl_init }, + .data =3D &hi3670_clk_crgctrl_clks }, { .compatible =3D "hisilicon,hi3670-pctrl", - .data =3D hi3670_clk_pctrl_init }, + .data =3D &hi3670_clk_pctrl_clks }, { .compatible =3D "hisilicon,hi3670-pmuctrl", - .data =3D hi3670_clk_pmuctrl_init }, + .data =3D &hi3670_clk_pmuctrl_clks }, { .compatible =3D "hisilicon,hi3670-sctrl", - .data =3D hi3670_clk_sctrl_init }, + .data =3D &hi3670_clk_sctrl_clks }, { .compatible =3D "hisilicon,hi3670-iomcu", - .data =3D hi3670_clk_iomcu_init }, + .data =3D &hi3670_clk_iomcu_clks }, { .compatible =3D "hisilicon,hi3670-media1-crg", - .data =3D hi3670_clk_media1_init }, + .data =3D &hi3670_clk_media1_clks }, { .compatible =3D "hisilicon,hi3670-media2-crg", - .data =3D hi3670_clk_media2_init }, + .data =3D &hi3670_clk_media2_clks }, { } }; - -static int hi3670_clk_probe(struct platform_device *pdev) -{ - struct device *dev =3D &pdev->dev; - struct device_node *np =3D pdev->dev.of_node; - void (*init_func)(struct device_node *np); - - init_func =3D of_device_get_match_data(dev); - if (!init_func) - return -ENODEV; - - init_func(np); - - return 0; -} +MODULE_DEVICE_TABLE(of, hi3670_clk_match_table); =20 static struct platform_driver hi3670_clk_driver =3D { - .probe =3D hi3670_clk_probe, + .probe =3D hisi_clk_probe, + .remove_new =3D hisi_clk_remove, .driver =3D { .name =3D "hi3670-clk", .of_match_table =3D hi3670_clk_match_table, }, }; =20 -static int __init hi3670_clk_init(void) -{ - return platform_driver_register(&hi3670_clk_driver); -} -core_initcall(hi3670_clk_init); +module_platform_driver(hi3670_clk_driver); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("HiSilicon Hi3670 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pj1-f44.google.com (mail-pj1-f44.google.com [209.85.216.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E94AB45C0C; Fri, 12 Apr 2024 05:12:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898730; cv=none; b=Qt9Mm4Vf6nh47IFaImOJzdPUCpwQhkwA6mY2yxCFcAHHwXf2m7QhUingexVxjNhpnsX9Ml/zmfPSi37UqtUR4BqZgNlX19e+IN3mkGcgaWuJesXcJz4b06sDLALkizmaTXV7S0ACWZA6c6fv6YIk03o0ggzhV1WUlRB60Hqkqx8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898730; c=relaxed/simple; bh=THOlQNYQ3XLHFrKTZ3I/J83AKC7OEV1gCwIHkExt2KY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=PzcwZLYiHB4Q5xJIxs5N53WCVYJrGkIA7PfRDMKDLb64O8pQbhiNSScsDAMynSPhp9kACLSac4fSlUyKbkce5zGW+942uBjGTYgsdsQqKqUHVA1tQfh91L/oCe4jFP/32VFNC1TMZWM9gUM5rUOIU+peMw43P6Fz7iFmoajUluc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=U2hvAEiy; arc=none smtp.client-ip=209.85.216.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="U2hvAEiy" Received: by mail-pj1-f44.google.com with SMTP id 98e67ed59e1d1-2a2e5d86254so1079740a91.1; Thu, 11 Apr 2024 22:12:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898728; x=1713503528; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=cqQYS83u49eAatFebVywwsoQA2O7fC1IRiP+OSZwee8=; b=U2hvAEiycU3fdBenFrue6UTBU7bzTUqI6mFiUQ/ZebMeXyv/uG+lP32nPMA0ukaAHo 6R/ClcgHlQ0qL8fUwuPZeOco3THZ8csrEU7/u2hwaWN+BWwihYb5E27zhfj1aN0KvrRL hx+XMeWoyPNKkFgY6vbct16dQHkwFLfAiVgXlw1lyhLma/2Q8M9kj8K7xJocW2FGOt4p 0APLjqaIAnb/6GrDP25Iru6/uhN7tmYHSK1mAHjB4fPJ0E0WB2vhdR5VFbmugFv/cv31 P/0i9raOG+kaMKkbTJxW1hw+b8E0qTyzFBlYOakpgMnc1p9imiFovorY57VRUMsQgtPo xw+A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898728; x=1713503528; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=cqQYS83u49eAatFebVywwsoQA2O7fC1IRiP+OSZwee8=; b=Jk2DV4GDBHvIW3th/mlLY96wKoGt6mMgkNc+HJ3nrwMezM8zAkufPhhxAsqLIHkXD0 ae5dIVslQ+X8YYp723o2fPe09YOcosQuwpFLsCuCqHQFglWcN9OmMRZ+M89OaBP62nqo ePYr2FpwnfXY7Y7smIfDr8IFidvEjtt3iKljpv6u2kUmC7CcNz7kVE2J0Qglin7noJFy TACfj17SBBv2jwpOMGhYiJRGWGG1RdFSEbPoXiXpOvQuKbVJnqvhocr69ltHLh40qmCS W4LYozoUxnlnm4C7u3BzPcYNhouaIBx2TFPb0czX/PywwFLVAp/7345f2T6nUJdENQ9m pc0A== X-Forwarded-Encrypted: i=1; AJvYcCXzUNqjxYrPLst4RdddJmWrTdEhXOVpEJYTJncPH/TSF4mDC7JyY0jm3yo0Zl88/bR0WXOL4KEVIeQGNn7sr5a1VLbLtiwWaL+U5kLf X-Gm-Message-State: AOJu0YyzGaKZFKquNaFt3eTA2XvXC1AWMUTPffQzXjHfDZInqo3nlm6u InUJLxmIAJqfzVTpqdI06d+SpPHrOX9zQgz44n7e8uT2jd0SiMR6Sj2ypN/0 X-Google-Smtp-Source: AGHT+IGazTFnwUDM+1obdlY9KUYmTmZ6Ze0XINOxZtHkzmExlY8a1nGTRPZfBv89egNRfjuOIwrdJg== X-Received: by 2002:a17:90b:1047:b0:2a5:3367:604b with SMTP id gq7-20020a17090b104700b002a53367604bmr2453894pjb.19.1712898727813; Thu, 11 Apr 2024 22:12:07 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.12.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:12:07 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 09/13] clk: hisilicon: hi3620: Convert into platform driver module Date: Fri, 12 Apr 2024 13:10:38 +0800 Message-ID: <20240412051041.90376-11-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi3620.c | 192 +++++++++++++++-------------- 1 file changed, 97 insertions(+), 95 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi3620.c b/drivers/clk/hisilicon/clk= -hi3620.c index 5d0226530fdb..97108eda6cb6 100644 --- a/drivers/clk/hisilicon/clk-hi3620.c +++ b/drivers/clk/hisilicon/clk-hi3620.c @@ -12,8 +12,10 @@ #include #include #include +#include #include #include +#include #include =20 #include @@ -21,48 +23,48 @@ #include "clk.h" =20 /* clock parent list */ -static const char *const timer0_mux_p[] __initconst =3D { "osc32k", "timer= clk01", }; -static const char *const timer1_mux_p[] __initconst =3D { "osc32k", "timer= clk01", }; -static const char *const timer2_mux_p[] __initconst =3D { "osc32k", "timer= clk23", }; -static const char *const timer3_mux_p[] __initconst =3D { "osc32k", "timer= clk23", }; -static const char *const timer4_mux_p[] __initconst =3D { "osc32k", "timer= clk45", }; -static const char *const timer5_mux_p[] __initconst =3D { "osc32k", "timer= clk45", }; -static const char *const timer6_mux_p[] __initconst =3D { "osc32k", "timer= clk67", }; -static const char *const timer7_mux_p[] __initconst =3D { "osc32k", "timer= clk67", }; -static const char *const timer8_mux_p[] __initconst =3D { "osc32k", "timer= clk89", }; -static const char *const timer9_mux_p[] __initconst =3D { "osc32k", "timer= clk89", }; -static const char *const uart0_mux_p[] __initconst =3D { "osc26m", "pclk",= }; -static const char *const uart1_mux_p[] __initconst =3D { "osc26m", "pclk",= }; -static const char *const uart2_mux_p[] __initconst =3D { "osc26m", "pclk",= }; -static const char *const uart3_mux_p[] __initconst =3D { "osc26m", "pclk",= }; -static const char *const uart4_mux_p[] __initconst =3D { "osc26m", "pclk",= }; -static const char *const spi0_mux_p[] __initconst =3D { "osc26m", "rclk_cf= gaxi", }; -static const char *const spi1_mux_p[] __initconst =3D { "osc26m", "rclk_cf= gaxi", }; -static const char *const spi2_mux_p[] __initconst =3D { "osc26m", "rclk_cf= gaxi", }; +static const char *const timer0_mux_p[] =3D { "osc32k", "timerclk01", }; +static const char *const timer1_mux_p[] =3D { "osc32k", "timerclk01", }; +static const char *const timer2_mux_p[] =3D { "osc32k", "timerclk23", }; +static const char *const timer3_mux_p[] =3D { "osc32k", "timerclk23", }; +static const char *const timer4_mux_p[] =3D { "osc32k", "timerclk45", }; +static const char *const timer5_mux_p[] =3D { "osc32k", "timerclk45", }; +static const char *const timer6_mux_p[] =3D { "osc32k", "timerclk67", }; +static const char *const timer7_mux_p[] =3D { "osc32k", "timerclk67", }; +static const char *const timer8_mux_p[] =3D { "osc32k", "timerclk89", }; +static const char *const timer9_mux_p[] =3D { "osc32k", "timerclk89", }; +static const char *const uart0_mux_p[] =3D { "osc26m", "pclk", }; +static const char *const uart1_mux_p[] =3D { "osc26m", "pclk", }; +static const char *const uart2_mux_p[] =3D { "osc26m", "pclk", }; +static const char *const uart3_mux_p[] =3D { "osc26m", "pclk", }; +static const char *const uart4_mux_p[] =3D { "osc26m", "pclk", }; +static const char *const spi0_mux_p[] =3D { "osc26m", "rclk_cfgaxi", }; +static const char *const spi1_mux_p[] =3D { "osc26m", "rclk_cfgaxi", }; +static const char *const spi2_mux_p[] =3D { "osc26m", "rclk_cfgaxi", }; /* share axi parent */ -static const char *const saxi_mux_p[] __initconst =3D { "armpll3", "armpll= 2", }; -static const char *const pwm0_mux_p[] __initconst =3D { "osc32k", "osc26m"= , }; -static const char *const pwm1_mux_p[] __initconst =3D { "osc32k", "osc26m"= , }; -static const char *const sd_mux_p[] __initconst =3D { "armpll2", "armpll3"= , }; -static const char *const mmc1_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; -static const char *const mmc1_mux2_p[] __initconst =3D { "osc26m", "mmc1_d= iv", }; -static const char *const g2d_mux_p[] __initconst =3D { "armpll2", "armpll3= ", }; -static const char *const venc_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; -static const char *const vdec_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; -static const char *const vpp_mux_p[] __initconst =3D { "armpll2", "armpll3= ", }; -static const char *const edc0_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; -static const char *const ldi0_mux_p[] __initconst =3D { "armpll2", "armpll= 4", +static const char *const saxi_mux_p[] =3D { "armpll3", "armpll2", }; +static const char *const pwm0_mux_p[] =3D { "osc32k", "osc26m", }; +static const char *const pwm1_mux_p[] =3D { "osc32k", "osc26m", }; +static const char *const sd_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const mmc1_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const mmc1_mux2_p[] =3D { "osc26m", "mmc1_div", }; +static const char *const g2d_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const venc_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const vdec_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const vpp_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const edc0_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const ldi0_mux_p[] =3D { "armpll2", "armpll4", "armpll3", "armpll5", }; -static const char *const edc1_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; -static const char *const ldi1_mux_p[] __initconst =3D { "armpll2", "armpll= 4", +static const char *const edc1_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const ldi1_mux_p[] =3D { "armpll2", "armpll4", "armpll3", "armpll5", }; -static const char *const rclk_hsic_p[] __initconst =3D { "armpll3", "armpl= l2", }; -static const char *const mmc2_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; -static const char *const mmc3_mux_p[] __initconst =3D { "armpll2", "armpll= 3", }; +static const char *const rclk_hsic_p[] =3D { "armpll3", "armpll2", }; +static const char *const mmc2_mux_p[] =3D { "armpll2", "armpll3", }; +static const char *const mmc3_mux_p[] =3D { "armpll2", "armpll3", }; =20 =20 /* fixed rate clocks */ -static struct hisi_fixed_rate_clock hi3620_fixed_rate_clks[] __initdata = =3D { +static struct hisi_fixed_rate_clock hi3620_fixed_rate_clks[] =3D { { HI3620_OSC32K, "osc32k", NULL, 0, 32768, }, { HI3620_OSC26M, "osc26m", NULL, 0, 26000000, }, { HI3620_PCLK, "pclk", NULL, 0, 26000000, }, @@ -75,13 +77,13 @@ static struct hisi_fixed_rate_clock hi3620_fixed_rate_c= lks[] __initdata =3D { }; =20 /* fixed factor clocks */ -static struct hisi_fixed_factor_clock hi3620_fixed_factor_clks[] __initdat= a =3D { +static struct hisi_fixed_factor_clock hi3620_fixed_factor_clks[] =3D { { HI3620_RCLK_TCXO, "rclk_tcxo", "osc26m", 1, 4, 0, }, { HI3620_RCLK_CFGAXI, "rclk_cfgaxi", "armpll2", 1, 30, 0, }, { HI3620_RCLK_PICO, "rclk_pico", "hsic_div", 1, 40, 0, }, }; =20 -static struct hisi_mux_clock hi3620_mux_clks[] __initdata =3D { +static struct hisi_mux_clock hi3620_mux_clks[] =3D { { HI3620_TIMER0_MUX, "timer0_mux", timer0_mux_p, ARRAY_SIZE(timer0_mux_p)= , CLK_SET_RATE_PARENT, 0, 15, 2, 0, }, { HI3620_TIMER1_MUX, "timer1_mux", timer1_mux_p, ARRAY_SIZE(timer1_mux_p)= , CLK_SET_RATE_PARENT, 0, 17, 2, 0, }, { HI3620_TIMER2_MUX, "timer2_mux", timer2_mux_p, ARRAY_SIZE(timer2_mux_p)= , CLK_SET_RATE_PARENT, 0, 19, 2, 0, }, @@ -119,7 +121,7 @@ static struct hisi_mux_clock hi3620_mux_clks[] __initda= ta =3D { { HI3620_MMC3_MUX, "mmc3_mux", mmc3_mux_p, ARRAY_SIZE(mmc3_mux_p), = CLK_SET_RATE_PARENT, 0x140, 9, 1, CLK_MUX_HIWORD_MASK, }, }; =20 -static struct hisi_divider_clock hi3620_div_clks[] __initdata =3D { +static struct hisi_divider_clock hi3620_div_clks[] =3D { { HI3620_SHAREAXI_DIV, "saxi_div", "saxi_mux", 0, 0x100, 0, 5, CLK_DIV= IDER_HIWORD_MASK, NULL, }, { HI3620_CFGAXI_DIV, "cfgaxi_div", "saxi_div", 0, 0x100, 5, 2, CLK_DIV= IDER_HIWORD_MASK, NULL, }, { HI3620_SD_DIV, "sd_div", "sd_mux", 0, 0x108, 0, 4, CLK_DIVI= DER_HIWORD_MASK, NULL, }, @@ -129,7 +131,7 @@ static struct hisi_divider_clock hi3620_div_clks[] __in= itdata =3D { { HI3620_MMC3_DIV, "mmc3_div", "mmc3_mux", 0, 0x140, 5, 4, CLK_DIV= IDER_HIWORD_MASK, NULL, }, }; =20 -static struct hisi_gate_clock hi3620_separated_gate_clks[] __initdata =3D { +static struct hisi_gate_clock hi3620_separated_gate_clks[] =3D { { HI3620_TIMERCLK01, "timerclk01", "timer_rclk01", CLK_SET_RATE_PAREN= T, 0x20, 0, 0, }, { HI3620_TIMER_RCLK01, "timer_rclk01", "rclk_tcxo", CLK_SET_RATE_PAREN= T, 0x20, 1, 0, }, { HI3620_TIMERCLK23, "timerclk23", "timer_rclk23", CLK_SET_RATE_PAREN= T, 0x20, 2, 0, }, @@ -191,29 +193,19 @@ static struct hisi_gate_clock hi3620_separated_gate_c= lks[] __initdata =3D { { HI3620_MCU_CLK, "mcu_clk", "acp_clk", CLK_SET_RATE_PAREN= T, 0x50, 24, 0, }, }; =20 -static void __init hi3620_clk_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - clk_data =3D hisi_clk_init(np, HI3620_NR_CLKS); - if (!clk_data) - return; - - hisi_clk_register_fixed_rate(hi3620_fixed_rate_clks, - ARRAY_SIZE(hi3620_fixed_rate_clks), - clk_data); - hisi_clk_register_fixed_factor(hi3620_fixed_factor_clks, - ARRAY_SIZE(hi3620_fixed_factor_clks), - clk_data); - hisi_clk_register_mux(hi3620_mux_clks, ARRAY_SIZE(hi3620_mux_clks), - clk_data); - hisi_clk_register_divider(hi3620_div_clks, ARRAY_SIZE(hi3620_div_clks), - clk_data); - hisi_clk_register_gate_sep(hi3620_separated_gate_clks, - ARRAY_SIZE(hi3620_separated_gate_clks), - clk_data); -} -CLK_OF_DECLARE(hi3620_clk, "hisilicon,hi3620-clock", hi3620_clk_init); +static const struct hisi_clocks hi3620_clks =3D { + .nr =3D HI3620_NR_CLKS, + .fixed_rate_clks =3D hi3620_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi3620_fixed_rate_clks), + .fixed_factor_clks =3D hi3620_fixed_factor_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hi3620_fixed_factor_clks), + .mux_clks =3D hi3620_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hi3620_mux_clks), + .divider_clks =3D hi3620_div_clks, + .divider_clks_num =3D ARRAY_SIZE(hi3620_div_clks), + .gate_sep_clks =3D hi3620_separated_gate_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi3620_separated_gate_clks), +}; =20 struct hisi_mmc_clock { unsigned int id; @@ -251,7 +243,7 @@ struct clk_mmc { =20 #define to_mmc(_hw) container_of(_hw, struct clk_mmc, hw) =20 -static struct hisi_mmc_clock hi3620_mmc_clks[] __initdata =3D { +static struct hisi_mmc_clock hi3620_mmc_clks[] =3D { { HI3620_SD_CIUCLK, "sd_bclk1", "sd_clk", CLK_SET_RATE_PARENT, 0x1f8, 0, = 0x1f8, 1, 3, 0x1f8, 4, 4, 0x1f8, 8, 4}, { HI3620_MMC_CIUCLK1, "mmc_bclk1", "mmc_clk1", CLK_SET_RATE_PARENT, 0x1= f8, 12, 0x1f8, 13, 3, 0x1f8, 16, 4, 0x1f8, 20, 4}, { HI3620_MMC_CIUCLK2, "mmc_bclk2", "mmc_clk2", CLK_SET_RATE_PARENT, 0x1= f8, 24, 0x1f8, 25, 3, 0x1f8, 28, 4, 0x1fc, 0, 4}, @@ -407,8 +399,9 @@ static const struct clk_ops clk_mmc_ops =3D { .recalc_rate =3D mmc_clk_recalc_rate, }; =20 -static struct clk *hisi_register_clk_mmc(struct hisi_mmc_clock *mmc_clk, - void __iomem *base, struct device_node *np) +static struct clk * +clk_register_hisi_mmc(struct device *dev, const struct hisi_mmc_clock *mmc= _clk, + void __iomem *base) { struct clk_mmc *mclk; struct clk *clk; @@ -444,41 +437,50 @@ static struct clk *hisi_register_clk_mmc(struct hisi_= mmc_clock *mmc_clk, return clk; } =20 -static void __init hi3620_mmc_clk_init(struct device_node *node) +static int hisi_register_clk_mmc(struct device *dev, const void *clocks, + size_t num, struct hisi_clock_data *data) { - void __iomem *base; - int i, num =3D ARRAY_SIZE(hi3620_mmc_clks); - struct clk_onecell_data *clk_data; + const struct hisi_mmc_clock *clks =3D clocks; =20 - if (!node) { - pr_err("failed to find pctrl node in DTS\n"); - return; - } + for (int i =3D 0; i < num; i++) { + struct clk *clk =3D clk_register_hisi_mmc(dev, &clks[i], data->base); =20 - base =3D of_iomap(node, 0); - if (!base) { - pr_err("failed to map pctrl\n"); - return; + if (IS_ERR(clk)) { + pr_err("%s: failed to register clock %s\n", + __func__, clks[i].name); + return PTR_ERR(clk); + } + data->clk_data.clks[clks[i].id] =3D clk; } =20 - clk_data =3D kzalloc(sizeof(*clk_data), GFP_KERNEL); - if (WARN_ON(!clk_data)) - return; + return 0; +} =20 - clk_data->clks =3D kcalloc(num, sizeof(*clk_data->clks), GFP_KERNEL); - if (!clk_data->clks) { - kfree(clk_data); - return; - } +static const struct hisi_clocks hi3620_clks_mmc =3D { + .customized_clks =3D hi3620_mmc_clks, + .customized_clks_num =3D ARRAY_SIZE(hi3620_mmc_clks), + .clk_register_customized =3D hisi_register_clk_mmc, +}; =20 - for (i =3D 0; i < num; i++) { - struct hisi_mmc_clock *mmc_clk =3D &hi3620_mmc_clks[i]; - clk_data->clks[mmc_clk->id] =3D - hisi_register_clk_mmc(mmc_clk, base, node); - } +static const struct of_device_id hi3620_clk_match_table[] =3D { + { .compatible =3D "hisilicon,hi3620-clock", + .data =3D &hi3620_clks }, + { .compatible =3D "hisilicon,hi3620-mmc-clock", + .data =3D &hi3620_clks_mmc }, + { } +}; +MODULE_DEVICE_TABLE(of, hi3620_clk_match_table); + +static struct platform_driver hi3620_clk_driver =3D { + .probe =3D hisi_clk_probe, + .remove_new =3D hisi_clk_remove, + .driver =3D { + .name =3D "hi3620-clock", + .of_match_table =3D hi3620_clk_match_table, + }, +}; =20 - clk_data->clk_num =3D num; - of_clk_add_provider(node, of_clk_src_onecell_get, clk_data); -} +module_platform_driver(hi3620_clk_driver); =20 -CLK_OF_DECLARE(hi3620_mmc_clk, "hisilicon,hi3620-mmc-clock", hi3620_mmc_cl= k_init); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("HiSilicon Hi3620 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pf1-f170.google.com (mail-pf1-f170.google.com [209.85.210.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 25A3F44C73; Fri, 12 Apr 2024 05:12:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898734; cv=none; b=cCBM3dO1MidXTHokGvcD1sku6qK5vZHzOn0Nf9g5TUN94L0Sp77BFlrjFANghlYYKL+PvTXeTMovsdJjs3LG6v2MlDjjZFMNM3jD9NU7tbyFnzRcqwLknZOxojXkkRle482oVD/YRR7p34DpyphRiM40wDUhil856Y7o8epitBM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898734; c=relaxed/simple; bh=YyRJcteLXncUqtCEfD0Jsx5LZeQSucbBaH4ZBQQ4mgk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Rz5k4U35AjQNPyXr0JN5e2xs3Tgsl6kvzxN96NW4wmB4p7Ipep1vijHiOjJVTU12uVoHO227+iVTP+VPadnj5Uo/M5mEWipFj9U/ZZSBoSGT9dWKRL/0pI26izRBEXwMCXSz8N5zG+eYmOXAZaJ08AcRkuOWSZWWT1kbIzlQ0cg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=HbPzXppF; arc=none smtp.client-ip=209.85.210.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="HbPzXppF" Received: by mail-pf1-f170.google.com with SMTP id d2e1a72fcca58-6ed32341906so609456b3a.1; Thu, 11 Apr 2024 22:12:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898732; x=1713503532; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ob27jvTJN+B1fr8uBP//ECvtoP3UWxC1yG4yE6/lVIA=; b=HbPzXppF7kTTM9gRN1RjCMkqy/fir4E+GdMExJwDrWm7YBmTrkbfr3moyRJ18IFwvZ WH0EFBWc8ivHBvUslVmnRrMvH3q506MRhusZyZEscA2TUivBwYoLAOn7ZCdyWQb3KCbH SnOlo8eTTfD0W8VSrAr65N2DqED4sKH0cLTDDrGVa9BvTBQlIjO3mPX96Ekl0TxV7K62 ZFKWeIvm4TSw5GusSwhVoDCGP4GQg/rvmD2lsW5oRTqOmW9KdGEkF0nbkfWDU4h831Ck PCmGIMmCVRglkWzhxOOfq+g/N1rGK9eCT/8cQwWtEzW2Yd0sa2+87se2/M98KXTbp0aF Of/g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898732; x=1713503532; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ob27jvTJN+B1fr8uBP//ECvtoP3UWxC1yG4yE6/lVIA=; b=cozQ5fHjuiXOJLUcx2BGxV31CP8o8tLVb+tGBBTCRc7reXxJHkzfbwDyQnW1QDriiW PsZFblhpjSZNg714jOeVU2q1KmwhOWLZND5lSgRKiAyh209p0TAaOw0cUfT6QRtlziOc VSNzk+7aezW6ajhoSZRelpi4MtvCHLodd4YSRSRDhIj9P6xwzMNCQAa5W3QVeZCCWs28 FZrqy2uzG0dfIhZbwEBxXX30HRbG9sxmesEvGnZ6qxL0Flf+4k/4mz4SYQxcwRoAx2L2 Dj1GzJDlXTibTibihE1V/WlZYR5VvnoZUSl5S75YDf/Q4b8Ir6pZK4emgOmw+6WjulGh H9CQ== X-Forwarded-Encrypted: i=1; AJvYcCVcUnj61YFD6LQZIHA6CGAsHTr6aO/VngNMNDAYcC1OMFnkzrrt8jrS40ijSms6YQ4rKK9B+tECs3R7y+oMiwVivWlu4AqGVVRS7mPg X-Gm-Message-State: AOJu0Yyy8o708RzbY3KuW+54Pzm/YuvnCzXcuHqBxAXvwQqDthcVepXl 3tRXbiaJOEgr+4L6L0jtFizEitsb7l6I20PZB23vfHYSWV5bnvIOmMRItfri X-Google-Smtp-Source: AGHT+IGPlKSCy3m9mVz7Ra6qy2uoAgrke94XCMwxZPBL2qagE7Aci8pJicdiMwGUwk+HNUDzBR8XWg== X-Received: by 2002:a05:6a20:9147:b0:1a9:85a0:afeb with SMTP id x7-20020a056a20914700b001a985a0afebmr1984734pzc.20.1712898731991; Thu, 11 Apr 2024 22:12:11 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.12.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:12:11 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 10/13] clk: hisilicon: hi6220: Convert into platform driver module Date: Fri, 12 Apr 2024 13:10:39 +0800 Message-ID: <20240412051041.90376-12-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi6220.c | 230 ++++++++++++++--------------- 1 file changed, 113 insertions(+), 117 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi6220.c b/drivers/clk/hisilicon/clk= -hi6220.c index c9d5a88da053..1b40d0d90229 100644 --- a/drivers/clk/hisilicon/clk-hi6220.c +++ b/drivers/clk/hisilicon/clk-hi6220.c @@ -9,17 +9,24 @@ =20 #include #include -#include -#include -#include +#include +#include =20 #include =20 #include "clk.h" =20 +static int +hi6220_clk_register_divider_stub(struct device *dev, const void *clks, + size_t num, struct hisi_clock_data *data) +{ + /* INCOMPLETE PATCH */ + hi6220_clk_register_divider(clks, num, data); + return 0; +} =20 /* clocks in AO (always on) controller */ -static struct hisi_fixed_rate_clock hi6220_fixed_rate_clks[] __initdata = =3D { +static struct hisi_fixed_rate_clock hi6220_fixed_rate_clks[] =3D { { HI6220_REF32K, "ref32k", NULL, 0, 32764, }, { HI6220_CLK_TCXO, "clk_tcxo", NULL, 0, 19200000, }, { HI6220_MMC1_PAD, "mmc1_pad", NULL, 0, 100000000, }, @@ -35,7 +42,7 @@ static struct hisi_fixed_rate_clock hi6220_fixed_rate_clk= s[] __initdata =3D { { HI6220_PLL_DDR, "ddrpll0", NULL, 0, 1600000000,}, }; =20 -static struct hisi_fixed_factor_clock hi6220_fixed_factor_clks[] __initdat= a =3D { +static struct hisi_fixed_factor_clock hi6220_fixed_factor_clks[] =3D { { HI6220_300M, "clk_300m", "syspll", 1, 4, 0, }, { HI6220_150M, "clk_150m", "clk_300m", 1, 2, 0, }, { HI6220_PICOPHY_SRC, "picophy_src", "clk_150m", 1, 4, 0, }, @@ -48,7 +55,7 @@ static struct hisi_fixed_factor_clock hi6220_fixed_factor= _clks[] __initdata =3D { { HI6220_MMC2_SMP, "mmc2_sample", "mmc2_sel", 1, 8, 0, }, }; =20 -static struct hisi_gate_clock hi6220_separated_gate_clks_ao[] __initdata = =3D { +static struct hisi_gate_clock hi6220_separated_gate_clks_ao[] =3D { { HI6220_WDT0_PCLK, "wdt0_pclk", "ref32k", CLK_SET_RATE_PARENT|CLK_= IGNORE_UNUSED, 0x630, 12, 0, }, { HI6220_WDT1_PCLK, "wdt1_pclk", "ref32k", CLK_SET_RATE_PARENT|CLK_= IGNORE_UNUSED, 0x630, 13, 0, }, { HI6220_WDT2_PCLK, "wdt2_pclk", "ref32k", CLK_SET_RATE_PARENT|CLK_= IGNORE_UNUSED, 0x630, 14, 0, }, @@ -66,47 +73,43 @@ static struct hisi_gate_clock hi6220_separated_gate_clk= s_ao[] __initdata =3D { { HI6220_RTC1_PCLK, "rtc1_pclk", "clk_tcxo", CLK_SET_RATE_PARENT|CLK_= IGNORE_UNUSED, 0x630, 26, 0, }, }; =20 -static void __init hi6220_clk_ao_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data_ao; - - clk_data_ao =3D hisi_clk_init(np, HI6220_AO_NR_CLKS); - if (!clk_data_ao) - return; - - hisi_clk_register_fixed_rate(hi6220_fixed_rate_clks, - ARRAY_SIZE(hi6220_fixed_rate_clks), clk_data_ao); - - hisi_clk_register_fixed_factor(hi6220_fixed_factor_clks, - ARRAY_SIZE(hi6220_fixed_factor_clks), clk_data_ao); +static const struct hisi_clocks hi6220_ao_clks =3D { + .nr =3D HI6220_AO_NR_CLKS, + .fixed_rate_clks =3D hi6220_fixed_rate_clks, + .fixed_rate_clks_num =3D ARRAY_SIZE(hi6220_fixed_rate_clks), + .fixed_factor_clks =3D hi6220_fixed_factor_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hi6220_fixed_factor_clks), + .gate_sep_clks =3D hi6220_separated_gate_clks_ao, + .gate_sep_clks_num =3D ARRAY_SIZE(hi6220_separated_gate_clks_ao), +}; =20 - hisi_clk_register_gate_sep(hi6220_separated_gate_clks_ao, - ARRAY_SIZE(hi6220_separated_gate_clks_ao), clk_data_ao); +static void hi6220_clk_ao_early_init(struct device_node *np) +{ + hisi_clk_early_init(np, &hi6220_ao_clks); } /* Allow reset driver to probe as well */ -CLK_OF_DECLARE_DRIVER(hi6220_clk_ao, "hisilicon,hi6220-aoctrl", hi6220_clk= _ao_init); - +CLK_OF_DECLARE_DRIVER(hi6220_clk_ao, "hisilicon,hi6220-aoctrl", hi6220_clk= _ao_early_init); =20 /* clocks in sysctrl */ -static const char *mmc0_mux0_p[] __initdata =3D { "pll_ddr_gate", "syspll"= , }; -static const char *mmc0_mux1_p[] __initdata =3D { "mmc0_mux0", "pll_media_= gate", }; -static const char *mmc0_src_p[] __initdata =3D { "mmc0srcsel", "mmc0_div",= }; -static const char *mmc1_mux0_p[] __initdata =3D { "pll_ddr_gate", "syspll"= , }; -static const char *mmc1_mux1_p[] __initdata =3D { "mmc1_mux0", "pll_media_= gate", }; -static const char *mmc1_src_p[] __initdata =3D { "mmc1srcsel", "mmc1_div"= , }; -static const char *mmc2_mux0_p[] __initdata =3D { "pll_ddr_gate", "syspll"= , }; -static const char *mmc2_mux1_p[] __initdata =3D { "mmc2_mux0", "pll_media_= gate", }; -static const char *mmc2_src_p[] __initdata =3D { "mmc2srcsel", "mmc2_div"= , }; -static const char *mmc0_sample_in[] __initdata =3D { "mmc0_sample", "mmc0_= pad", }; -static const char *mmc1_sample_in[] __initdata =3D { "mmc1_sample", "mmc1_= pad", }; -static const char *mmc2_sample_in[] __initdata =3D { "mmc2_sample", "mmc2_= pad", }; -static const char *uart1_src[] __initdata =3D { "clk_tcxo", "clk_150m", }; -static const char *uart2_src[] __initdata =3D { "clk_tcxo", "clk_150m", }; -static const char *uart3_src[] __initdata =3D { "clk_tcxo", "clk_150m", }; -static const char *uart4_src[] __initdata =3D { "clk_tcxo", "clk_150m", }; -static const char *hifi_src[] __initdata =3D { "syspll", "pll_media_gate",= }; - -static struct hisi_gate_clock hi6220_separated_gate_clks_sys[] __initdata = =3D { +static const char *const mmc0_mux0_p[] =3D { "pll_ddr_gate", "syspll", }; +static const char *const mmc0_mux1_p[] =3D { "mmc0_mux0", "pll_media_gate"= , }; +static const char *const mmc0_src_p[] =3D { "mmc0srcsel", "mmc0_div", }; +static const char *const mmc1_mux0_p[] =3D { "pll_ddr_gate", "syspll", }; +static const char *const mmc1_mux1_p[] =3D { "mmc1_mux0", "pll_media_gate"= , }; +static const char *const mmc1_src_p[] =3D { "mmc1srcsel", "mmc1_div", }; +static const char *const mmc2_mux0_p[] =3D { "pll_ddr_gate", "syspll", }; +static const char *const mmc2_mux1_p[] =3D { "mmc2_mux0", "pll_media_gate"= , }; +static const char *const mmc2_src_p[] =3D { "mmc2srcsel", "mmc2_div", }; +static const char *const mmc0_sample_in[] =3D { "mmc0_sample", "mmc0_pad",= }; +static const char *const mmc1_sample_in[] =3D { "mmc1_sample", "mmc1_pad",= }; +static const char *const mmc2_sample_in[] =3D { "mmc2_sample", "mmc2_pad",= }; +static const char *const uart1_src[] =3D { "clk_tcxo", "clk_150m", }; +static const char *const uart2_src[] =3D { "clk_tcxo", "clk_150m", }; +static const char *const uart3_src[] =3D { "clk_tcxo", "clk_150m", }; +static const char *const uart4_src[] =3D { "clk_tcxo", "clk_150m", }; +static const char *const hifi_src[] =3D { "syspll", "pll_media_gate", }; + +static struct hisi_gate_clock hi6220_separated_gate_clks_sys[] =3D { { HI6220_MMC0_CLK, "mmc0_clk", "mmc0_src", CLK_SET_RATE_P= ARENT|CLK_IGNORE_UNUSED, 0x200, 0, 0, }, { HI6220_MMC0_CIUCLK, "mmc0_ciuclk", "mmc0_smp_in", CLK_SET_RATE_P= ARENT|CLK_IGNORE_UNUSED, 0x200, 0, 0, }, { HI6220_MMC1_CLK, "mmc1_clk", "mmc1_src", CLK_SET_RATE_P= ARENT|CLK_IGNORE_UNUSED, 0x200, 1, 0, }, @@ -143,7 +146,7 @@ static struct hisi_gate_clock hi6220_separated_gate_clk= s_sys[] __initdata =3D { { HI6220_CS_ATB_SYSPLL, "cs_atb_syspll", "syspll", CLK_SET_RATE_P= ARENT|CLK_IS_CRITICAL, 0x270, 12, 0, }, }; =20 -static struct hisi_mux_clock hi6220_mux_clks_sys[] __initdata =3D { +static struct hisi_mux_clock hi6220_mux_clks_sys[] =3D { { HI6220_MMC0_SRC, "mmc0_src", mmc0_src_p, ARRAY_SIZE(mmc0_src_= p), CLK_SET_RATE_PARENT, 0x4, 0, 1, 0, }, { HI6220_MMC0_SMP_IN, "mmc0_smp_in", mmc0_sample_in, ARRAY_SIZE(mmc0_samp= le_in), CLK_SET_RATE_PARENT, 0x4, 0, 1, 0, }, { HI6220_MMC1_SRC, "mmc1_src", mmc1_src_p, ARRAY_SIZE(mmc1_src_= p), CLK_SET_RATE_PARENT, 0x4, 2, 1, 0, }, @@ -163,7 +166,7 @@ static struct hisi_mux_clock hi6220_mux_clks_sys[] __in= itdata =3D { { HI6220_MMC2_MUX1, "mmc2_mux1", mmc2_mux1_p, ARRAY_SIZE(mmc2_mux1= _p), CLK_SET_RATE_PARENT, 0x400, 15, 1, CLK_MUX_HIWORD_MASK,}, }; =20 -static struct hi6220_divider_clock hi6220_div_clks_sys[] __initdata =3D { +static struct hi6220_divider_clock hi6220_div_clks_sys[] =3D { { HI6220_CLK_BUS, "clk_bus", "clk_300m", CLK_SET_RATE_PARENT= , 0x490, 0, 4, 7, }, { HI6220_MMC0_DIV, "mmc0_div", "mmc0_syspll", CLK_SET_RATE_PARENT= , 0x494, 0, 6, 7, }, { HI6220_MMC1_DIV, "mmc1_div", "mmc1_syspll", CLK_SET_RATE_PARENT= , 0x498, 0, 6, 7, }, @@ -174,32 +177,23 @@ static struct hi6220_divider_clock hi6220_div_clks_sy= s[] __initdata =3D { { HI6220_CS_ATB_DIV, "cs_atb_div", "cs_atb_syspll", CLK_SET_RATE_PARENT= , 0x4a4, 0, 4, 7, }, }; =20 -static void __init hi6220_clk_sys_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - clk_data =3D hisi_clk_init(np, HI6220_SYS_NR_CLKS); - if (!clk_data) - return; - - hisi_clk_register_gate_sep(hi6220_separated_gate_clks_sys, - ARRAY_SIZE(hi6220_separated_gate_clks_sys), clk_data); - - hisi_clk_register_mux(hi6220_mux_clks_sys, - ARRAY_SIZE(hi6220_mux_clks_sys), clk_data); - - hi6220_clk_register_divider(hi6220_div_clks_sys, - ARRAY_SIZE(hi6220_div_clks_sys), clk_data); -} -CLK_OF_DECLARE_DRIVER(hi6220_clk_sys, "hisilicon,hi6220-sysctrl", hi6220_c= lk_sys_init); - +static const struct hisi_clocks hi6220_sys_clks =3D { + .nr =3D HI6220_SYS_NR_CLKS, + .mux_clks =3D hi6220_mux_clks_sys, + .mux_clks_num =3D ARRAY_SIZE(hi6220_mux_clks_sys), + .gate_sep_clks =3D hi6220_separated_gate_clks_sys, + .gate_sep_clks_num =3D ARRAY_SIZE(hi6220_separated_gate_clks_sys), + .customized_clks =3D hi6220_div_clks_sys, + .customized_clks_num =3D ARRAY_SIZE(hi6220_div_clks_sys), + .clk_register_customized =3D hi6220_clk_register_divider_stub, +}; =20 /* clocks in media controller */ -static const char *clk_1000_1200_src[] __initdata =3D { "pll_gpu_gate", "m= edia_syspll_src", }; -static const char *clk_1440_1200_src[] __initdata =3D { "media_syspll_src"= , "media_pll_src", }; -static const char *clk_1000_1440_src[] __initdata =3D { "pll_gpu_gate", "m= edia_pll_src", }; +static const char *const clk_1000_1200_src[] =3D { "pll_gpu_gate", "media_= syspll_src", }; +static const char *const clk_1440_1200_src[] =3D { "media_syspll_src", "me= dia_pll_src", }; +static const char *const clk_1000_1440_src[] =3D { "pll_gpu_gate", "media_= pll_src", }; =20 -static struct hisi_gate_clock hi6220_separated_gate_clks_media[] __initdat= a =3D { +static struct hisi_gate_clock hi6220_separated_gate_clks_media[] =3D { { HI6220_DSI_PCLK, "dsi_pclk", "vpucodec", CLK_SET_RAT= E_PARENT|CLK_IGNORE_UNUSED, 0x520, 0, 0, }, { HI6220_G3D_PCLK, "g3d_pclk", "vpucodec", CLK_SET_RAT= E_PARENT|CLK_IGNORE_UNUSED, 0x520, 1, 0, }, { HI6220_ACLK_CODEC_VPU, "aclk_codec_vpu", "ade_core_src", CLK_SET_RAT= E_PARENT|CLK_IGNORE_UNUSED, 0x520, 3, 0, }, @@ -215,13 +209,13 @@ static struct hisi_gate_clock hi6220_separated_gate_c= lks_media[] __initdata =3D { { HI6220_MED_SYSPLL, "media_syspll_src", "media_syspll", CLK_SET_RAT= E_PARENT|CLK_IGNORE_UNUSED, 0x520, 17, 0, }, }; =20 -static struct hisi_mux_clock hi6220_mux_clks_media[] __initdata =3D { +static struct hisi_mux_clock hi6220_mux_clks_media[] =3D { { HI6220_1440_1200, "clk_1440_1200", clk_1440_1200_src, ARRAY_SIZE(clk_14= 40_1200_src), CLK_SET_RATE_PARENT, 0x51c, 0, 1, 0, }, { HI6220_1000_1200, "clk_1000_1200", clk_1000_1200_src, ARRAY_SIZE(clk_10= 00_1200_src), CLK_SET_RATE_PARENT, 0x51c, 1, 1, 0, }, { HI6220_1000_1440, "clk_1000_1440", clk_1000_1440_src, ARRAY_SIZE(clk_10= 00_1440_src), CLK_SET_RATE_PARENT, 0x51c, 6, 1, 0, }, }; =20 -static struct hi6220_divider_clock hi6220_div_clks_media[] __initdata =3D { +static struct hi6220_divider_clock hi6220_div_clks_media[] =3D { { HI6220_CODEC_JPEG, "codec_jpeg_aclk", "media_pll_src", CLK_SET_RATE= _PARENT, 0xcbc, 0, 4, 23, }, { HI6220_ISP_SCLK_SRC, "isp_sclk_src", "isp_sclk_gate", CLK_SET_RATE= _PARENT, 0xcbc, 8, 4, 15, }, { HI6220_ISP_SCLK1, "isp_sclk1", "isp_sclk_gate1", CLK_SET_RATE= _PARENT, 0xcbc, 24, 4, 31, }, @@ -231,28 +225,19 @@ static struct hi6220_divider_clock hi6220_div_clks_me= dia[] __initdata =3D { { HI6220_CODEC_VPU_SRC, "codec_vpu_src", "codec_vpu_gate", CLK_SET_RATE= _PARENT, 0xcc4, 24, 6, 31, }, }; =20 -static void __init hi6220_clk_media_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - clk_data =3D hisi_clk_init(np, HI6220_MEDIA_NR_CLKS); - if (!clk_data) - return; - - hisi_clk_register_gate_sep(hi6220_separated_gate_clks_media, - ARRAY_SIZE(hi6220_separated_gate_clks_media), clk_data); - - hisi_clk_register_mux(hi6220_mux_clks_media, - ARRAY_SIZE(hi6220_mux_clks_media), clk_data); - - hi6220_clk_register_divider(hi6220_div_clks_media, - ARRAY_SIZE(hi6220_div_clks_media), clk_data); -} -CLK_OF_DECLARE_DRIVER(hi6220_clk_media, "hisilicon,hi6220-mediactrl", hi62= 20_clk_media_init); - +static const struct hisi_clocks hi6220_media_clks =3D { + .nr =3D HI6220_MEDIA_NR_CLKS, + .mux_clks =3D hi6220_mux_clks_media, + .mux_clks_num =3D ARRAY_SIZE(hi6220_mux_clks_media), + .gate_sep_clks =3D hi6220_separated_gate_clks_media, + .gate_sep_clks_num =3D ARRAY_SIZE(hi6220_separated_gate_clks_media), + .customized_clks =3D hi6220_div_clks_media, + .customized_clks_num =3D ARRAY_SIZE(hi6220_div_clks_media), + .clk_register_customized =3D hi6220_clk_register_divider_stub, +}; =20 /* clocks in pmctrl */ -static struct hisi_gate_clock hi6220_gate_clks_power[] __initdata =3D { +static struct hisi_gate_clock hi6220_gate_clks_power[] =3D { { HI6220_PLL_GPU_GATE, "pll_gpu_gate", "gpupll", CLK_SET_RATE_PARE= NT|CLK_IGNORE_UNUSED, 0x8, 0, 0, }, { HI6220_PLL1_DDR_GATE, "pll1_ddr_gate", "ddrpll1", CLK_SET_RATE_PARE= NT|CLK_IGNORE_UNUSED, 0x10, 0, 0, }, { HI6220_PLL_DDR_GATE, "pll_ddr_gate", "ddrpll0", CLK_SET_RATE_PARE= NT|CLK_IGNORE_UNUSED, 0x18, 0, 0, }, @@ -260,26 +245,19 @@ static struct hisi_gate_clock hi6220_gate_clks_power[= ] __initdata =3D { { HI6220_PLL0_BBP_GATE, "pll0_bbp_gate", "bbppll0", CLK_SET_RATE_PARE= NT|CLK_IGNORE_UNUSED, 0x48, 0, 0, }, }; =20 -static struct hi6220_divider_clock hi6220_div_clks_power[] __initdata =3D { +static struct hi6220_divider_clock hi6220_div_clks_power[] =3D { { HI6220_DDRC_SRC, "ddrc_src", "ddr_sel_src", CLK_SET_RATE_PARENT, 0x5a= 8, 0, 4, 0, }, { HI6220_DDRC_AXI1, "ddrc_axi1", "ddrc_src", CLK_SET_RATE_PARENT, 0x5a= 8, 8, 2, 0, }, }; =20 -static void __init hi6220_clk_power_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - clk_data =3D hisi_clk_init(np, HI6220_POWER_NR_CLKS); - if (!clk_data) - return; - - hisi_clk_register_gate(hi6220_gate_clks_power, - ARRAY_SIZE(hi6220_gate_clks_power), clk_data); - - hi6220_clk_register_divider(hi6220_div_clks_power, - ARRAY_SIZE(hi6220_div_clks_power), clk_data); -} -CLK_OF_DECLARE(hi6220_clk_power, "hisilicon,hi6220-pmctrl", hi6220_clk_pow= er_init); +static const struct hisi_clocks hi6220_power_clks =3D { + .nr =3D HI6220_POWER_NR_CLKS, + .gate_clks =3D hi6220_gate_clks_power, + .gate_clks_num =3D ARRAY_SIZE(hi6220_gate_clks_power), + .customized_clks =3D hi6220_div_clks_power, + .customized_clks_num =3D ARRAY_SIZE(hi6220_div_clks_power), + .clk_register_customized =3D hi6220_clk_register_divider_stub, +}; =20 /* clocks in acpu */ static const struct hisi_gate_clock hi6220_acpu_sc_gate_sep_clks[] =3D { @@ -287,18 +265,36 @@ static const struct hisi_gate_clock hi6220_acpu_sc_ga= te_sep_clks[] =3D { CLK_SET_RATE_PARENT | CLK_IGNORE_UNUSED, 0xc, 11, 0, }, }; =20 -static void __init hi6220_clk_acpu_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - int nr =3D ARRAY_SIZE(hi6220_acpu_sc_gate_sep_clks); +static const struct hisi_clocks hi6220_acpu_clks =3D { + .gate_sep_clks =3D hi6220_acpu_sc_gate_sep_clks, + .gate_sep_clks_num =3D ARRAY_SIZE(hi6220_acpu_sc_gate_sep_clks), +}; =20 - clk_data =3D hisi_clk_init(np, nr); - if (!clk_data) - return; +static const struct of_device_id hi6220_clk_match_table[] =3D { + { .compatible =3D "hisilicon,hi6220-aoctrl", + .data =3D &hi6220_ao_clks }, + { .compatible =3D "hisilicon,hi6220-sysctrl", + .data =3D &hi6220_sys_clks }, + { .compatible =3D "hisilicon,hi6220-mediactrl", + .data =3D &hi6220_media_clks }, + { .compatible =3D "hisilicon,hi6220-pmctrl", + .data =3D &hi6220_power_clks }, + { .compatible =3D "hisilicon,hi6220-acpu-sctrl", + .data =3D &hi6220_acpu_clks }, + { } +}; +MODULE_DEVICE_TABLE(of, hi6220_clk_match_table); + +static struct platform_driver hi6220_clk_driver =3D { + .probe =3D hisi_clk_probe, + .remove_new =3D hisi_clk_remove, + .driver =3D { + .name =3D "hi6220-clock", + .of_match_table =3D hi6220_clk_match_table, + }, +}; =20 - hisi_clk_register_gate_sep(hi6220_acpu_sc_gate_sep_clks, - ARRAY_SIZE(hi6220_acpu_sc_gate_sep_clks), - clk_data); -} +module_platform_driver(hi6220_clk_driver); =20 -CLK_OF_DECLARE(hi6220_clk_acpu, "hisilicon,hi6220-acpu-sctrl", hi6220_clk_= acpu_init); +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("HiSilicon Hi6220 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pf1-f170.google.com (mail-pf1-f170.google.com [209.85.210.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3E25947F7A; Fri, 12 Apr 2024 05:12:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898738; cv=none; b=nsUBQp9BPppNhPZEDGX8kddtOs1XhfK5OXYhgGVnKWv+/pjuUtbZuX5Y/5pkzkuFZ6uKpriQgf5qrS8QHsw++Dth0Bd4kbdg9LGqbZsnnzhGquBZ/Ab4fuRIa6r/N27yck4+gCMUtN2C0HTvYWIX5dxcv5Qs7F5YCCkFxLImBzU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898738; c=relaxed/simple; bh=4hBDfyqNJGhczrAbriDJjBqzMZKnQpCmCElVDsfAepo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=DvZUu5QrAedp3GkNVgUmGj+ekPy/SoHOXL/lCWMH484CzXjzRff9CSxIltrDXLBpWZdL+1UImpcXFs4YXYJ4DzC8O0iWc9sVcNTRFOlAUavtK2SYdHP3rqxrznmrX4u+x6ipWQ5v5Ih7gtht0DagEWJXDt/70PvNfxJ2Ir7TnU4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=J999A89/; arc=none smtp.client-ip=209.85.210.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="J999A89/" Received: by mail-pf1-f170.google.com with SMTP id d2e1a72fcca58-6ed3cafd766so531680b3a.0; Thu, 11 Apr 2024 22:12:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898736; x=1713503536; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=L+nnU8lhrJvnMJXK2RHKJh1TRqnP2rEwLBbGg2+14B4=; b=J999A89/6C0k8wZMCkTeYCAK9XJ9YivuhcwZDehGJqIgRAZ+bTYgRmxpYfJGGPFFZK qN8A4rXa1KIxGPV6LS0weharCK8sdD7/tbcdjMxhEJ1gxP/nMHS4itIqSHef73XSuGzR WE6hmHChE8sDWyP7JiOAq02PGwH6X+Z7wiYq8IxYZKIyXB6gN37SH5a4Hi7CsnHf1v7J Zyx8yiYGGRJvwYts86da4TrG9KkyNSW2Y67hMxcYWKorchIuRKS55KHq/UHMjxWZHOIy gHZOkDJjhzdcsOedHewaFEtNI92TMI3jEdevO19XBbTbkovAklLtLO7NzcTWVrk4ECuy CDiw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898736; x=1713503536; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=L+nnU8lhrJvnMJXK2RHKJh1TRqnP2rEwLBbGg2+14B4=; b=Km29QOtaIx3G7YbkhNkbbdbLxeaQkf+6HAawnKsqxMVj2hzjKNDfQLCuvD2JMd9ScP ogQi9a8eEZsEzis6KYk2PNc7l2i1cEhD1MS0zRPKT5vfTqd8bCqNu1D2dM1PrH9hFEB4 i9hNtydpwpBN9h4Ff2TpFC2r+RGJflHgL/GxZ0vbB8YV09ErZLYperu3zx4/v2LTum9D NKf7shlVWw3Q2E2L2Uu6l4U8O0Kc6+4bckQJcCHI3d7vDkcDDw+b0++t77kUfCBUPHXl hNXJtUU1ufZ6GTFWPFEHl3odpqVN9mcXFIHAjXhr0Apc8GCyohjmkyxRcPgnkSMMYmfL MA3w== X-Forwarded-Encrypted: i=1; AJvYcCU5ucOy38pqs7Ul6O0jVs9dRPlyNMQzMtyfKUamo8Q2mmWfrzyWx6DVDOOkkOKVh8QqYJp2Qu934NjpJUCXvissLboLDSVWzpvrOW89 X-Gm-Message-State: AOJu0YzmhttmNdWXaz3VEUiq5bX1H4is2z5Q5zb/L+9QyY46ZEaWwX1r mG+DrPDxQ2AF/6DhMWkgVf8H2FuoBm0OhF3n8m98kLw6wxfi7wLzVEfgCIet X-Google-Smtp-Source: AGHT+IHkCONMYo0N1+GAWx3hBzOjQJE1wSaEQH37vzw8fjz0Ha0ZXa1nc57mG6r7eiSM6ewQSZlw5g== X-Received: by 2002:a05:6a21:271d:b0:1a7:a3cb:78f3 with SMTP id rm29-20020a056a21271d00b001a7a3cb78f3mr1670820pzb.12.1712898736123; Thu, 11 Apr 2024 22:12:16 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.12.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:12:15 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 11/13] clk: hisilicon: hip04: Convert into platform driver module Date: Fri, 12 Apr 2024 13:10:40 +0800 Message-ID: <20240412051041.90376-13-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hip04.c | 38 ++++++++++++++++++++----------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hip04.c b/drivers/clk/hisilicon/clk-= hip04.c index feb34e98af8c..8ba82675ff64 100644 --- a/drivers/clk/hisilicon/clk-hip04.c +++ b/drivers/clk/hisilicon/clk-hip04.c @@ -10,8 +10,8 @@ =20 #include #include -#include -#include +#include +#include =20 #include =20 @@ -24,16 +24,28 @@ static struct hisi_fixed_rate_clock hip04_fixed_rate_cl= ks[] __initdata =3D { { HIP04_CLK_168M, "clk168m", NULL, 0, 168750000, }, }; =20 -static void __init hip04_clk_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; +static const struct hisi_clocks hip04_clks =3D { + .fixed_rate_clks =3D hip04_fixed_rate_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hip04_fixed_rate_clks), +}; + +static const struct of_device_id hip04_clk_match_table[] =3D { + { .compatible =3D "hisilicon,hip04-clock", + .data =3D &hip04_clks }, + { } +}; +MODULE_DEVICE_TABLE(of, hip04_clk_match_table); + +static struct platform_driver hip04_clk_driver =3D { + .probe =3D hisi_clk_probe, + .remove_new =3D hisi_clk_remove, + .driver =3D { + .name =3D "hip04-clock", + .of_match_table =3D hip04_clk_match_table, + }, +}; =20 - clk_data =3D hisi_clk_init(np, HIP04_NR_CLKS); - if (!clk_data) - return; +module_platform_driver(hip04_clk_driver); =20 - hisi_clk_register_fixed_rate(hip04_fixed_rate_clks, - ARRAY_SIZE(hip04_fixed_rate_clks), - clk_data); -} -CLK_OF_DECLARE(hip04_clk, "hisilicon,hip04-clock", hip04_clk_init); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("HiSilicon HiP04 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pj1-f54.google.com (mail-pj1-f54.google.com [209.85.216.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4FDC94CB35; Fri, 12 Apr 2024 05:12:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898742; cv=none; b=LhZSvAxIdcSwirOgkumVAd/4QkLKVTV/j1kynUXJ261RAcdRyVQ/nuyFEs5TF1bIJ3nPGN7vbr31j0C5ZtDmsuSOUjeHzyexsXfdKyX3GTCPerxpCXmeule7wiKH91i42+3c4szqaUn+BqXxIT7vUah4kh4RQB53dTVY/kjPmyU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898742; c=relaxed/simple; bh=4hA8+z3f2ldZmeSXUpUNrydWtdec93hvgrr/De9O8Tg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=iNhsr0QHG6ZkJoNPkF2TEFQw18F8NKo57K9rsrjGYVh58msym5MnO3VOTbK7J7OXV1BRKGF8IIDw+gf3/eRReFbNd4AwqTL7aonQWElhRkMpQCsXTf7NKutI1hUEpI08+ghMi5z474nYbq5abdnq1nB/2c38lfcRFXaKBpQMhnc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Zm5D3u/u; arc=none smtp.client-ip=209.85.216.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Zm5D3u/u" Received: by mail-pj1-f54.google.com with SMTP id 98e67ed59e1d1-2a6ff4f91cbso90246a91.0; Thu, 11 Apr 2024 22:12:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898740; x=1713503540; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=uzYAusLgHA5dg3wxY39f8O7jqiLmZIOTBnC6DEHE96c=; b=Zm5D3u/ubBllrtfprwvTRUqNq7807em/UFt8CdWapymvrhyHaaKJEzfXaFbHU3uPRA 80mIvxy3iWvgHhGS12NtidOT82WnY6WGKeJMMAa3wxdVSDoy9jY4PZsFTWOmCZhxMJou a7TZczwsWzFdwPcPzBg2UHOffh7Nfi2iyZiTGfcKzcMt+JwdU/WT8CiUY5/Kty0ToBs7 47T3e5GeDlHXZsgyIsMEwBahH9Z+GYhMdn0lWtEt3SvnXX4QL/s9hF0Sm6YTuxyBLg/+ 2UzO5qRmZG2OedVW6c9ZCoRGFUK1X1Rf3nclZcbLG9nPM91PWW6YfMMPk1jcKipJybMI fymA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898740; x=1713503540; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=uzYAusLgHA5dg3wxY39f8O7jqiLmZIOTBnC6DEHE96c=; b=r7eYET3uZ3qe+Ga1NhLH5sGH2wObiahspHchmiz2RfNdz6TitS4VSA2ob0UlGGLUQX nPJtQHxY3VvDO4jns/gd6Z5TL17GkGmgf2/HL8azX8rmAiA2FsG9E7hIuRlO6hhMK1JE TE3iBTmTEXFKFTHXG1Kn6GoJiUGewdvlZCy/HQHlU65M6Yu3CFFi30hsCh/+Msv47k3O NK4aTK4BQuly9wncoO0h1xdzqK73XmzpMZXw7e8a++Wxeq/XsMboS9rGbYMUp+iGUPe1 nX5G/FHOLla2pCmgUtKeDfuLEJ9GtHW2bnJdozyksLSixpgBzNISDdti88AAsh38mC/4 cZvw== X-Forwarded-Encrypted: i=1; AJvYcCW6hLiaxyM/t0Fw53X2YIFA2Gj3sd+gXIOiXnNA28kf6uRq+T81j5Xk1wowJDUQe2vnTI6YJhmKLpAT2xLCx7cdWws1nwRSyRc+cirm X-Gm-Message-State: AOJu0Yy2TUGsk/Bg3NROdvsenKDmNyc4ScVqIlGocQoymGTspiDCNet9 OARVhPu5a4VhjwyM2Ce9s+1AhY1LfSt2BVFgsmPgYRxMn8a3f9AkEYGurO8n X-Google-Smtp-Source: AGHT+IEtsIR7DUK/r/E1QwkP8Ps5AqOEh+aFcTsx9H9SiXTsM2qjvzPWRf6RcNXHI3u9aSmM2YnfzA== X-Received: by 2002:a17:90a:e7c1:b0:2a6:fbf5:6d8b with SMTP id kb1-20020a17090ae7c100b002a6fbf56d8bmr396006pjb.3.1712898740269; Thu, 11 Apr 2024 22:12:20 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.12.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:12:19 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 12/13] clk: hisilicon: hix5hd2: Convert into platform driver module Date: Fri, 12 Apr 2024 13:10:41 +0800 Message-ID: <20240412051041.90376-14-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use common helper functions and register clks with a single of_device_id data. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hix5hd2.c | 85 ++++++++++++++++++----------- 1 file changed, 52 insertions(+), 33 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hix5hd2.c b/drivers/clk/hisilicon/cl= k-hix5hd2.c index 64bdd3f05725..0a3f1320d0d5 100644 --- a/drivers/clk/hisilicon/clk-hix5hd2.c +++ b/drivers/clk/hisilicon/clk-hix5hd2.c @@ -4,13 +4,17 @@ * Copyright (c) 2014 Hisilicon Limited. */ =20 -#include #include + #include #include +#include +#include +#include + #include "clk.h" =20 -static struct hisi_fixed_rate_clock hix5hd2_fixed_rate_clks[] __initdata = =3D { +static struct hisi_fixed_rate_clock hix5hd2_fixed_rate_clks[] =3D { { HIX5HD2_FIXED_1200M, "1200m", NULL, 0, 1200000000, }, { HIX5HD2_FIXED_400M, "400m", NULL, 0, 400000000, }, { HIX5HD2_FIXED_48M, "48m", NULL, 0, 48000000, }, @@ -43,19 +47,19 @@ static struct hisi_fixed_rate_clock hix5hd2_fixed_rate_= clks[] __initdata =3D { { HIX5HD2_FIXED_83M, "83m", NULL, 0, 83333333, }, }; =20 -static const char *const sfc_mux_p[] __initconst =3D { +static const char *const sfc_mux_p[] =3D { "24m", "150m", "200m", "100m", "75m", }; static u32 sfc_mux_table[] =3D {0, 4, 5, 6, 7}; =20 -static const char *const sdio_mux_p[] __initconst =3D { +static const char *const sdio_mux_p[] =3D { "75m", "100m", "50m", "15m", }; static u32 sdio_mux_table[] =3D {0, 1, 2, 3}; =20 -static const char *const fephy_mux_p[] __initconst =3D { "25m", "125m"}; +static const char *const fephy_mux_p[] =3D { "25m", "125m"}; static u32 fephy_mux_table[] =3D {0, 1}; =20 =20 -static struct hisi_mux_clock hix5hd2_mux_clks[] __initdata =3D { +static struct hisi_mux_clock hix5hd2_mux_clks[] =3D { { HIX5HD2_SFC_MUX, "sfc_mux", sfc_mux_p, ARRAY_SIZE(sfc_mux_p), CLK_SET_RATE_PARENT, 0x5c, 8, 3, 0, sfc_mux_table, }, { HIX5HD2_MMC_MUX, "mmc_mux", sdio_mux_p, ARRAY_SIZE(sdio_mux_p), @@ -67,7 +71,7 @@ static struct hisi_mux_clock hix5hd2_mux_clks[] __initdat= a =3D { CLK_SET_RATE_PARENT, 0x120, 8, 2, 0, fephy_mux_table, }, }; =20 -static struct hisi_gate_clock hix5hd2_gate_clks[] __initdata =3D { +static struct hisi_gate_clock hix5hd2_gate_clks[] =3D { /* sfc */ { HIX5HD2_SFC_CLK, "clk_sfc", "sfc_mux", CLK_SET_RATE_PARENT, 0x5c, 0, 0, }, @@ -153,7 +157,7 @@ struct hix5hd2_clk_complex { u32 phy_rst_mask; }; =20 -static struct hix5hd2_complex_clock hix5hd2_complex_clks[] __initdata =3D { +static struct hix5hd2_complex_clock hix5hd2_complex_clks[] =3D { {"clk_mac0", "clk_fephy", HIX5HD2_MAC0_CLK, 0xcc, 0xa, 0x500, 0x120, 0, 0x10, TYPE_ETHER}, {"clk_mac1", "clk_fwd_sys", HIX5HD2_MAC1_CLK, @@ -249,21 +253,22 @@ static const struct clk_ops clk_complex_ops =3D { .disable =3D clk_complex_disable, }; =20 -static void __init -hix5hd2_clk_register_complex(struct hix5hd2_complex_clock *clks, int nums, +static int +hix5hd2_clk_register_complex(struct device *dev, const void *clocks, size_= t num, struct hisi_clock_data *data) { + const struct hix5hd2_complex_clock *clks =3D clocks; void __iomem *base =3D data->base; int i; =20 - for (i =3D 0; i < nums; i++) { + for (i =3D 0; i < num; i++) { struct hix5hd2_clk_complex *p_clk; struct clk *clk; struct clk_init_data init; =20 p_clk =3D kzalloc(sizeof(*p_clk), GFP_KERNEL); if (!p_clk) - return; + return -ENOMEM; =20 init.name =3D clks[i].name; if (clks[i].type =3D=3D TYPE_ETHER) @@ -289,31 +294,45 @@ hix5hd2_clk_register_complex(struct hix5hd2_complex_c= lock *clks, int nums, kfree(p_clk); pr_err("%s: failed to register clock %s\n", __func__, clks[i].name); - continue; + return PTR_ERR(p_clk); } =20 data->clk_data.clks[clks[i].id] =3D clk; } -} =20 -static void __init hix5hd2_clk_init(struct device_node *np) -{ - struct hisi_clock_data *clk_data; - - clk_data =3D hisi_clk_init(np, HIX5HD2_NR_CLKS); - if (!clk_data) - return; - - hisi_clk_register_fixed_rate(hix5hd2_fixed_rate_clks, - ARRAY_SIZE(hix5hd2_fixed_rate_clks), - clk_data); - hisi_clk_register_mux(hix5hd2_mux_clks, ARRAY_SIZE(hix5hd2_mux_clks), - clk_data); - hisi_clk_register_gate(hix5hd2_gate_clks, - ARRAY_SIZE(hix5hd2_gate_clks), clk_data); - hix5hd2_clk_register_complex(hix5hd2_complex_clks, - ARRAY_SIZE(hix5hd2_complex_clks), - clk_data); + return 0; } =20 -CLK_OF_DECLARE(hix5hd2_clk, "hisilicon,hix5hd2-clock", hix5hd2_clk_init); +static const struct hisi_clocks hix5hd2_clks =3D { + .nr =3D HIX5HD2_NR_CLKS, + .fixed_rate_clks =3D hix5hd2_fixed_rate_clks, + .fixed_factor_clks_num =3D ARRAY_SIZE(hix5hd2_fixed_rate_clks), + .mux_clks =3D hix5hd2_mux_clks, + .mux_clks_num =3D ARRAY_SIZE(hix5hd2_mux_clks), + .gate_clks =3D hix5hd2_gate_clks, + .gate_clks_num =3D ARRAY_SIZE(hix5hd2_gate_clks), + .customized_clks =3D hix5hd2_complex_clks, + .customized_clks_num =3D ARRAY_SIZE(hix5hd2_complex_clks), + .clk_register_customized =3D hix5hd2_clk_register_complex, +}; + +static const struct of_device_id hix5hd2_clk_match_table[] =3D { + { .compatible =3D "hisilicon,hix5hd2-clock", + .data =3D &hix5hd2_clks }, + { } +}; +MODULE_DEVICE_TABLE(of, hix5hd2_clk_match_table); + +static struct platform_driver hix5hd2_clk_driver =3D { + .probe =3D hisi_clk_probe, + .remove_new =3D hisi_clk_remove, + .driver =3D { + .name =3D "hix5hd2-clock", + .of_match_table =3D hix5hd2_clk_match_table, + }, +}; + +module_platform_driver(hix5hd2_clk_driver); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("HiSilicon Hix5hd2 Clock Driver"); --=20 2.43.0 From nobody Mon Feb 9 17:56:31 2026 Received: from mail-pf1-f179.google.com (mail-pf1-f179.google.com [209.85.210.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8FF564D595; Fri, 12 Apr 2024 05:12:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898748; cv=none; b=lP0EpUxA8daumfIVDR4+9tiLyqNgaU7RpWyHZWMnRNbgC6s7ocyT7ePaCWxQxYYqcVnhPRS/isoaPKmk3jNdUby8M+eGVRylPLo18mx3JXGT1478KpVafDhv+CKRLdU4XQF7Z3NnAN+s9jo6uqkIRL28glHUcl6LsXgdKnI0JX4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712898748; c=relaxed/simple; bh=BqhMvxeJJm1zQ6YazPUThecbZh2WWWpwiaa9y7FpQIg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=RVPT5yt0fuWNTQva1EVsP6tCJz8mXJM+TsvpJWLhjOb0eVOzCwFVezLezemOQsWthu1d+cU8FO+3cjbtE2D9ZGCyXlzlciPDsDwCfryn9758BKue8mBkHVyAzBni/Aq/C+hAUC6+t3ZAv8Dp4OOlsQNu9i+DMmH9wO8sAbNlhOU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=ipHmS5BL; arc=none smtp.client-ip=209.85.210.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="ipHmS5BL" Received: by mail-pf1-f179.google.com with SMTP id d2e1a72fcca58-6eaf9565e6bso427786b3a.2; Thu, 11 Apr 2024 22:12:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1712898745; x=1713503545; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=STc0hWjt3FttkdIRn+Z2JfgyXSyKZ5+GjLcKdUQbhl4=; b=ipHmS5BLQvVmczw0vPcxC2cvcRgexvegBtrYIEg9+Vfch9VexSqZ71R204l6jmj3xc 7NQ0+vgM5MOblaAkeGRgDNlUNaDjKshGiHwCXxfEQsUweosaRGTzWYJEysK5UJEoU18o ndeplIGzC7s+36szuZytA6y7MUH40FqtWazmRGDcrzdtC+Idr2ebDmRwCFNkkJvhudel gEQgM+NpNrU3GyvD7rGtV08YjckUPiVRxK3V0lcYw//EOkB/ziA3qnPC4qG9Qt2IKE2e EGeuypoRS43RNN0KyhpXtzSelaYYoNTYp2Qy6lj7wkSR/kYDDIv2qzvbCva7huz1b/Si K0Cw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712898745; x=1713503545; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=STc0hWjt3FttkdIRn+Z2JfgyXSyKZ5+GjLcKdUQbhl4=; b=rEh898S1nTIaug7qQgf0RLFBnrz5QbBstwxbQr7zwiddF8D0qY/h1C+CvPJs1aYQj3 MmALGvXeSx5gNi/wY2S1BiJU8yT4Z9q/7RtoHmEnc68e08SQEGxhhF/JZx/HAQmHQwLe CuhgTxO7hqEY60pE5wtFC5cWU13sSQ/SvAfbeKDDXfokGeNOg+7f4bWcWlrwBfK9f0rc 7bTQr4FzFC4rDtwUYwymgC2wI+yAJ7+sUkmcC/5rO+l0pQqBv/QqQF5V5D0l31MbpKk4 RreSJ5gHtjsqAvtg3z3UxM/CbW0MrlOOEm12JJkwbboK+pJ+OdJ4utjcQVVFZViIlIXa IDAA== X-Forwarded-Encrypted: i=1; AJvYcCWQhaFmP4wR+X151ZzaHZc+uS4JNwws4EnCpm3E1t0kyL6mBOwtPHDAtz94J19v+D+uQSTtvffQ474x12gP0NGK5kBl0sz8S4YhEREv X-Gm-Message-State: AOJu0Yxv/+dTh/YN1O1rq/Ucn/O2ASDC06RMGSEz0io7pWPEN/gf+/Ue Wp1G5dagvQ058tXDXpbOhHYPo07iU25Cip6xwPqlxLkpBlJB0CTkh1Yezt3D X-Google-Smtp-Source: AGHT+IGgLebmGd4kVpuYGDc2UfLnT9+3/KorOzHmq2Gg5ouIEguugBxuAuhYva5kaNzp3L45LQpi5g== X-Received: by 2002:a05:6a20:9791:b0:1a7:7358:f108 with SMTP id hx17-20020a056a20979100b001a77358f108mr1750957pzc.24.1712898744502; Thu, 11 Apr 2024 22:12:24 -0700 (PDT) Received: from d.home.yangfl.dn42 ([104.28.213.200]) by smtp.gmail.com with ESMTPSA id fh16-20020a17090b035000b002a53b9cf356sm3734902pjb.0.2024.04.11.22.12.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Apr 2024 22:12:24 -0700 (PDT) From: David Yang To: linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, David Yang Subject: [PATCH v9 13/13] clk: hisilicon: Migrate devm APIs Date: Fri, 12 Apr 2024 13:10:42 +0800 Message-ID: <20240412051041.90376-15-mmyangfl@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240412051041.90376-2-mmyangfl@gmail.com> References: <20240412051041.90376-2-mmyangfl@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Migrates devm APIs for HiSilicon clock drivers. Signed-off-by: David Yang --- drivers/clk/hisilicon/clk-hi3559a.c | 27 +- drivers/clk/hisilicon/clk-hi3620.c | 31 +- drivers/clk/hisilicon/clk-hi6220-stub.c | 9 +- drivers/clk/hisilicon/clk-hi6220.c | 4 +- drivers/clk/hisilicon/clk-hisi-phase.c | 13 +- drivers/clk/hisilicon/clk-hix5hd2.c | 15 +- drivers/clk/hisilicon/clk.c | 430 +++++++--------------- drivers/clk/hisilicon/clk.h | 99 +++-- drivers/clk/hisilicon/clkdivider-hi6220.c | 24 +- drivers/clk/hisilicon/clkgate-separated.c | 26 +- 10 files changed, 267 insertions(+), 411 deletions(-) diff --git a/drivers/clk/hisilicon/clk-hi3559a.c b/drivers/clk/hisilicon/cl= k-hi3559a.c index 1902d943fe34..cc5a787125f6 100644 --- a/drivers/clk/hisilicon/clk-hi3559a.c +++ b/drivers/clk/hisilicon/clk-hi3559a.c @@ -457,17 +457,17 @@ hisi_clk_register_pll(struct device *dev, const void = *clocks, { const struct hi3559av100_pll_clock *clks =3D clocks; void __iomem *base =3D data->base; - struct hi3559av100_clk_pll *p_clk =3D NULL; - struct clk *clk =3D NULL; + struct hi3559av100_clk_pll *p_clk; struct clk_init_data init; int i; =20 - p_clk =3D devm_kcalloc(dev, nums, sizeof(*p_clk), GFP_KERNEL); - - if (!p_clk) - return -ENOMEM; + int ret; =20 for (i =3D 0; i < num; i++) { + p_clk =3D devm_kzalloc(dev, sizeof(*p_clk), GFP_KERNEL); + if (!p_clk) + return -ENOMEM; + init.name =3D clks[i].name; init.flags =3D 0; init.parent_names =3D @@ -490,15 +490,14 @@ hisi_clk_register_pll(struct device *dev, const void = *clocks, p_clk->refdiv_width =3D clks[i].refdiv_width; p_clk->hw.init =3D &init; =20 - clk =3D clk_register(NULL, &p_clk->hw); - if (IS_ERR(clk)) { + ret =3D devm_clk_hw_register(dev, &p_clk->hw); + if (ret) { dev_err(dev, "%s: failed to register clock %s\n", - __func__, clks[i].name); - return PTR_ERR(clk); + __func__, clks[i].name); + return ret; } =20 - data->clk_data.clks[clks[i].id] =3D clk; - p_clk++; + data->clk_data->hws[clks[i].id] =3D &p_clk->hw; } =20 return 0; @@ -627,7 +626,7 @@ static int hi3559av100_shub_default_clk_set(struct devi= ce *dev, struct hisi_cloc void __iomem *crg_base; unsigned int val; =20 - crg_base =3D ioremap(CRG_BASE_ADDR, SZ_4K); + crg_base =3D devm_ioremap(dev, CRG_BASE_ADDR, SZ_4K); =20 /* SSP: 192M/2 */ val =3D readl_relaxed(crg_base + 0x20); @@ -639,7 +638,7 @@ static int hi3559av100_shub_default_clk_set(struct devi= ce *dev, struct hisi_cloc val |=3D (0x1 << 28); writel_relaxed(val, crg_base + 0x1C); =20 - iounmap(crg_base); + devm_iounmap(dev, crg_base); crg_base =3D NULL; =20 return 0; diff --git a/drivers/clk/hisilicon/clk-hi3620.c b/drivers/clk/hisilicon/clk= -hi3620.c index 97108eda6cb6..6b381f07d4c7 100644 --- a/drivers/clk/hisilicon/clk-hi3620.c +++ b/drivers/clk/hisilicon/clk-hi3620.c @@ -11,12 +11,10 @@ =20 #include #include +#include #include #include -#include -#include -#include -#include +#include =20 #include =20 @@ -399,15 +397,15 @@ static const struct clk_ops clk_mmc_ops =3D { .recalc_rate =3D mmc_clk_recalc_rate, }; =20 -static struct clk * +static struct clk_hw * clk_register_hisi_mmc(struct device *dev, const struct hisi_mmc_clock *mmc= _clk, void __iomem *base) { struct clk_mmc *mclk; - struct clk *clk; struct clk_init_data init; + int ret; =20 - mclk =3D kzalloc(sizeof(*mclk), GFP_KERNEL); + mclk =3D devm_kzalloc(dev, sizeof(*mclk), GFP_KERNEL); if (!mclk) return ERR_PTR(-ENOMEM); =20 @@ -431,26 +429,31 @@ clk_register_hisi_mmc(struct device *dev, const struc= t hisi_mmc_clock *mmc_clk, mclk->sam_off =3D mmc_clk->sam_off; mclk->sam_bits =3D mmc_clk->sam_bits; =20 - clk =3D clk_register(NULL, &mclk->hw); - if (WARN_ON(IS_ERR(clk))) - kfree(mclk); - return clk; + ret =3D devm_clk_hw_register(dev, &mclk->hw); + if (ret) { + dev_err(dev, "%s: failed to register clock %s\n", + __func__, init.name); + return ERR_PTR(ret); + } + + return &mclk->hw; } =20 static int hisi_register_clk_mmc(struct device *dev, const void *clocks, size_t num, struct hisi_clock_data *data) { const struct hisi_mmc_clock *clks =3D clocks; + int i; =20 - for (int i =3D 0; i < num; i++) { - struct clk *clk =3D clk_register_hisi_mmc(dev, &clks[i], data->base); + for (i =3D 0; i < num; i++) { + struct clk_hw *clk =3D clk_register_hisi_mmc(dev, &clks[i], data->base); =20 if (IS_ERR(clk)) { pr_err("%s: failed to register clock %s\n", __func__, clks[i].name); return PTR_ERR(clk); } - data->clk_data.clks[clks[i].id] =3D clk; + data->clk_data->hws[clks[i].id] =3D clk; } =20 return 0; diff --git a/drivers/clk/hisilicon/clk-hi6220-stub.c b/drivers/clk/hisilico= n/clk-hi6220-stub.c index a8319795ed1c..f194c2394638 100644 --- a/drivers/clk/hisilicon/clk-hi6220-stub.c +++ b/drivers/clk/hisilicon/clk-hi6220-stub.c @@ -195,7 +195,6 @@ static int hi6220_stub_clk_probe(struct platform_device= *pdev) struct device *dev =3D &pdev->dev; struct clk_init_data init; struct hi6220_stub_clk *stub_clk; - struct clk *clk; struct device_node *np =3D pdev->dev.of_node; int ret; =20 @@ -233,11 +232,11 @@ static int hi6220_stub_clk_probe(struct platform_devi= ce *pdev) init.num_parents =3D 0; init.flags =3D 0; =20 - clk =3D devm_clk_register(dev, &stub_clk->hw); - if (IS_ERR(clk)) - return PTR_ERR(clk); + ret =3D devm_clk_hw_register(dev, &stub_clk->hw); + if (ret) + return ret; =20 - ret =3D of_clk_add_provider(np, of_clk_src_simple_get, clk); + ret =3D devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, &stub_clk-= >hw); if (ret) { dev_err(dev, "failed to register OF clock provider\n"); return ret; diff --git a/drivers/clk/hisilicon/clk-hi6220.c b/drivers/clk/hisilicon/clk= -hi6220.c index 1b40d0d90229..bf8345ce7a8c 100644 --- a/drivers/clk/hisilicon/clk-hi6220.c +++ b/drivers/clk/hisilicon/clk-hi6220.c @@ -20,9 +20,7 @@ static int hi6220_clk_register_divider_stub(struct device *dev, const void *clks, size_t num, struct hisi_clock_data *data) { - /* INCOMPLETE PATCH */ - hi6220_clk_register_divider(clks, num, data); - return 0; + return hi6220_clk_register_divider(dev, clks, num, data); } =20 /* clocks in AO (always on) controller */ diff --git a/drivers/clk/hisilicon/clk-hisi-phase.c b/drivers/clk/hisilicon= /clk-hisi-phase.c index ba6afad66a2b..15a23dd6edb1 100644 --- a/drivers/clk/hisilicon/clk-hisi-phase.c +++ b/drivers/clk/hisilicon/clk-hisi-phase.c @@ -5,11 +5,11 @@ * Simple HiSilicon phase clock implementation. */ =20 +#include #include #include #include #include -#include =20 #include "clk.h" =20 @@ -90,12 +90,13 @@ static const struct clk_ops clk_phase_ops =3D { .set_phase =3D hisi_clk_set_phase, }; =20 -struct clk *clk_register_hisi_phase(struct device *dev, +struct clk_hw *devm_clk_hw_register_hisi_phase(struct device *dev, const struct hisi_phase_clock *clks, void __iomem *base, spinlock_t *lock) { struct clk_hisi_phase *phase; struct clk_init_data init; + int ret; =20 phase =3D devm_kzalloc(dev, sizeof(struct clk_hisi_phase), GFP_KERNEL); if (!phase) @@ -116,6 +117,10 @@ struct clk *clk_register_hisi_phase(struct device *dev, phase->phase_num =3D clks->phase_num; phase->hw.init =3D &init; =20 - return devm_clk_register(dev, &phase->hw); + ret =3D devm_clk_hw_register(dev, &phase->hw); + if (ret) + return ERR_PTR(ret); + + return &phase->hw; } -EXPORT_SYMBOL_GPL(clk_register_hisi_phase); +EXPORT_SYMBOL_GPL(devm_clk_hw_register_hisi_phase); diff --git a/drivers/clk/hisilicon/clk-hix5hd2.c b/drivers/clk/hisilicon/cl= k-hix5hd2.c index 0a3f1320d0d5..66d4c232b28b 100644 --- a/drivers/clk/hisilicon/clk-hix5hd2.c +++ b/drivers/clk/hisilicon/clk-hix5hd2.c @@ -6,7 +6,7 @@ =20 #include =20 -#include +#include #include #include #include @@ -260,13 +260,13 @@ hix5hd2_clk_register_complex(struct device *dev, cons= t void *clocks, size_t num, const struct hix5hd2_complex_clock *clks =3D clocks; void __iomem *base =3D data->base; int i; + int ret; =20 for (i =3D 0; i < num; i++) { struct hix5hd2_clk_complex *p_clk; - struct clk *clk; struct clk_init_data init; =20 - p_clk =3D kzalloc(sizeof(*p_clk), GFP_KERNEL); + p_clk =3D devm_kzalloc(dev, sizeof(*p_clk), GFP_KERNEL); if (!p_clk) return -ENOMEM; =20 @@ -289,15 +289,14 @@ hix5hd2_clk_register_complex(struct device *dev, cons= t void *clocks, size_t num, p_clk->phy_rst_mask =3D clks[i].phy_rst_mask; p_clk->hw.init =3D &init; =20 - clk =3D clk_register(NULL, &p_clk->hw); - if (IS_ERR(clk)) { - kfree(p_clk); + ret =3D devm_clk_hw_register(dev, &p_clk->hw); + if (ret) { pr_err("%s: failed to register clock %s\n", __func__, clks[i].name); - return PTR_ERR(p_clk); + return ret; } =20 - data->clk_data.clks[clks[i].id] =3D clk; + data->clk_data->hws[clks[i].id] =3D &p_clk->hw; } =20 return 0; diff --git a/drivers/clk/hisilicon/clk.c b/drivers/clk/hisilicon/clk.c index e50115f8e236..53966db0781b 100644 --- a/drivers/clk/hisilicon/clk.c +++ b/drivers/clk/hisilicon/clk.c @@ -4,6 +4,7 @@ * * Copyright (c) 2012-2013 Hisilicon Limited. * Copyright (c) 2012-2013 Linaro Limited. + * Copyright (c) 2023 David Yang * * Author: Haojian Zhuang * Xin Li @@ -13,6 +14,8 @@ #include #include #include +#include +#include #include #include #include @@ -23,343 +26,214 @@ =20 static DEFINE_SPINLOCK(hisi_clk_lock); =20 -struct hisi_clock_data *hisi_clk_alloc(struct platform_device *pdev, - int nr_clks) +struct hisi_clock_data *hisi_clk_init(struct device_node *np, size_t nr) { - struct hisi_clock_data *clk_data; - struct resource *res; - struct clk **clk_table; - - clk_data =3D devm_kmalloc(&pdev->dev, sizeof(*clk_data), GFP_KERNEL); - if (!clk_data) - return NULL; - - res =3D platform_get_resource(pdev, IORESOURCE_MEM, 0); - if (!res) - return NULL; - clk_data->base =3D devm_ioremap(&pdev->dev, - res->start, resource_size(res)); - if (!clk_data->base) - return NULL; - - clk_table =3D devm_kmalloc_array(&pdev->dev, nr_clks, - sizeof(*clk_table), - GFP_KERNEL); - if (!clk_table) - return NULL; - - clk_data->clk_data.clks =3D clk_table; - clk_data->clk_data.clk_num =3D nr_clks; - - return clk_data; -} -EXPORT_SYMBOL_GPL(hisi_clk_alloc); - -struct hisi_clock_data *hisi_clk_init(struct device_node *np, - int nr_clks) -{ - struct hisi_clock_data *clk_data; - struct clk **clk_table; void __iomem *base; + struct hisi_clock_data *data; + int ret; + int i; =20 base =3D of_iomap(np, 0); if (!base) { pr_err("%s: failed to map clock registers\n", __func__); - goto err; + return NULL; } =20 - clk_data =3D kzalloc(sizeof(*clk_data), GFP_KERNEL); - if (!clk_data) - goto err; + data =3D kmalloc(sizeof(*data), GFP_KERNEL); + if (!data) + return NULL; =20 - clk_data->base =3D base; - clk_table =3D kcalloc(nr_clks, sizeof(*clk_table), GFP_KERNEL); - if (!clk_table) + data->clk_data =3D kzalloc(sizeof(*data->clk_data) + nr * sizeof(data->cl= k_data->hws[0]), + GFP_KERNEL); + if (!data->clk_data) goto err_data; =20 - clk_data->clk_data.clks =3D clk_table; - clk_data->clk_data.clk_num =3D nr_clks; - of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data->clk_data); - return clk_data; + ret =3D of_clk_add_hw_provider(np, of_clk_hw_onecell_get, data->clk_data); + if (ret) + goto err_clk; + + data->base =3D base; + data->clks =3D NULL; + data->clk_data->num =3D nr; + for (i =3D 0; i < nr; i++) + data->clk_data->hws[i] =3D ERR_PTR(-EPROBE_DEFER); + + return data; + +err_clk: + kfree(data->clk_data); err_data: - kfree(clk_data); -err: + kfree(data); return NULL; } EXPORT_SYMBOL_GPL(hisi_clk_init); =20 +#define hisi_clk_unregister_fn(type) \ +static void hisi_clk_unregister_##type(struct hisi_clock_data *data) \ +{ \ + for (int i =3D 0; i < data->clks->type##_clks_num; i++) { \ + struct clk_hw *clk =3D data->clk_data->hws[data->clks->type##_clks[i].id= ]; \ +\ + if (clk && !IS_ERR(clk)) \ + clk_hw_unregister_##type(clk); \ + } \ +} + +hisi_clk_unregister_fn(fixed_rate) +hisi_clk_unregister_fn(fixed_factor) + void hisi_clk_free(struct device_node *np, struct hisi_clock_data *data) { if (data->clks) { if (data->clks->fixed_rate_clks_num) - hisi_clk_unregister_fixed_rate(data->clks->fixed_rate_clks, - data->clks->fixed_rate_clks_num, - data); + hisi_clk_unregister_fixed_rate(data); if (data->clks->fixed_factor_clks_num) - hisi_clk_unregister_fixed_factor(data->clks->fixed_factor_clks, - data->clks->fixed_factor_clks_num, - data); + hisi_clk_unregister_fixed_factor(data); } =20 of_clk_del_provider(np); - kfree(data->clk_data.clks); + kfree(data->clk_data); kfree(data); } EXPORT_SYMBOL_GPL(hisi_clk_free); =20 int hisi_clk_register_fixed_rate(const struct hisi_fixed_rate_clock *clks, - int nums, struct hisi_clock_data *data) + size_t num, struct hisi_clock_data *data) { - struct clk *clk; + struct clk_hw *clk; int i; =20 - for (i =3D 0; i < nums; i++) { - clk =3D clk_register_fixed_rate(NULL, clks[i].name, - clks[i].parent_name, - clks[i].flags, - clks[i].fixed_rate); + for (i =3D 0; i < num; i++) { + const struct hisi_fixed_rate_clock *p_clk =3D &clks[i]; + + clk =3D clk_hw_register_fixed_rate(NULL, p_clk->name, p_clk->parent_name, + p_clk->flags, p_clk->fixed_rate); + if (IS_ERR(clk)) { pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); + __func__, p_clk->name); goto err; } - data->clk_data.clks[clks[i].id] =3D clk; + + data->clk_data->hws[p_clk->id] =3D clk; } =20 return 0; =20 err: while (i--) - clk_unregister_fixed_rate(data->clk_data.clks[clks[i].id]); - + clk_hw_unregister_fixed_rate(data->clk_data->hws[clks[i].id]); return PTR_ERR(clk); } EXPORT_SYMBOL_GPL(hisi_clk_register_fixed_rate); =20 int hisi_clk_register_fixed_factor(const struct hisi_fixed_factor_clock *c= lks, - int nums, - struct hisi_clock_data *data) + size_t num, struct hisi_clock_data *data) { - struct clk *clk; + struct clk_hw *clk; int i; =20 - for (i =3D 0; i < nums; i++) { - clk =3D clk_register_fixed_factor(NULL, clks[i].name, - clks[i].parent_name, - clks[i].flags, clks[i].mult, - clks[i].div); - if (IS_ERR(clk)) { - pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); - goto err; - } - data->clk_data.clks[clks[i].id] =3D clk; - } - - return 0; - -err: - while (i--) - clk_unregister_fixed_factor(data->clk_data.clks[clks[i].id]); - - return PTR_ERR(clk); -} -EXPORT_SYMBOL_GPL(hisi_clk_register_fixed_factor); + for (i =3D 0; i < num; i++) { + const struct hisi_fixed_factor_clock *p_clk =3D &clks[i]; =20 -int hisi_clk_register_mux(const struct hisi_mux_clock *clks, - int nums, struct hisi_clock_data *data) -{ - struct clk *clk; - void __iomem *base =3D data->base; - int i; - - for (i =3D 0; i < nums; i++) { - u32 mask =3D BIT(clks[i].width) - 1; + clk =3D clk_hw_register_fixed_factor(NULL, p_clk->name, p_clk->parent_na= me, + p_clk->flags, p_clk->mult, p_clk->div); =20 - clk =3D clk_register_mux_table(NULL, clks[i].name, - clks[i].parent_names, - clks[i].num_parents, clks[i].flags, - base + clks[i].offset, clks[i].shift, - mask, clks[i].mux_flags, - clks[i].table, &hisi_clk_lock); if (IS_ERR(clk)) { pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); + __func__, p_clk->name); goto err; } =20 - if (clks[i].alias) - clk_register_clkdev(clk, clks[i].alias, NULL); - - data->clk_data.clks[clks[i].id] =3D clk; + data->clk_data->hws[p_clk->id] =3D clk; } =20 return 0; =20 err: while (i--) - clk_unregister_mux(data->clk_data.clks[clks[i].id]); - + clk_hw_unregister_fixed_rate(data->clk_data->hws[clks[i].id]); return PTR_ERR(clk); } -EXPORT_SYMBOL_GPL(hisi_clk_register_mux); +EXPORT_SYMBOL_GPL(hisi_clk_register_fixed_factor); + +/* + * We ARE function creater. Commit message from checkpatch: + * Avoid warning on macros that use argument concatenation as + * those macros commonly create another function + */ +#define hisi_clk_register_fn(fn, type, stmt) \ +int fn(struct device *dev, const struct type *clks, \ + size_t num, struct hisi_clock_data *data) \ +{ \ + void __iomem *base =3D data->base; \ +\ + for (int i =3D 0; i < num; i++) { \ + const struct type *p_clk =3D &clks[i]; \ + struct clk_hw *clk =3D stmt; \ +\ + if (IS_ERR(clk)) { \ + pr_err("%s: failed to register clock %s\n", \ + __func__, p_clk->name); \ + return PTR_ERR(clk); \ + } \ +\ + if (p_clk->alias) \ + clk_hw_register_clkdev(clk, p_clk->alias, NULL); \ +\ + data->clk_data->hws[p_clk->id] =3D clk; \ + } \ +\ + return 0; \ +} \ +EXPORT_SYMBOL_GPL(fn); + +hisi_clk_register_fn(hisi_clk_register_mux, hisi_mux_clock, + __devm_clk_hw_register_mux(dev, NULL, p_clk->name, + p_clk->num_parents, p_clk->parent_names, NULL, NULL, + p_clk->flags, base + p_clk->offset, p_clk->shift, BIT(p_clk->width) - 1, + p_clk->mux_flags, p_clk->table, &hisi_clk_lock)) =20 int hisi_clk_register_phase(struct device *dev, const struct hisi_phase_clock *clks, - int nums, struct hisi_clock_data *data) + size_t num, struct hisi_clock_data *data) { void __iomem *base =3D data->base; - struct clk *clk; - int i; =20 - for (i =3D 0; i < nums; i++) { - clk =3D clk_register_hisi_phase(dev, &clks[i], base, - &hisi_clk_lock); + for (int i =3D 0; i < num; i++) { + const struct hisi_phase_clock *p_clk =3D &clks[i]; + struct clk_hw *clk =3D devm_clk_hw_register_hisi_phase(dev, + p_clk, base, &hisi_clk_lock); + if (IS_ERR(clk)) { pr_err("%s: failed to register clock %s\n", __func__, - clks[i].name); + p_clk->name); return PTR_ERR(clk); } =20 - data->clk_data.clks[clks[i].id] =3D clk; + data->clk_data->hws[p_clk->id] =3D clk; } =20 return 0; } EXPORT_SYMBOL_GPL(hisi_clk_register_phase); =20 -int hisi_clk_register_divider(const struct hisi_divider_clock *clks, - int nums, struct hisi_clock_data *data) -{ - struct clk *clk; - void __iomem *base =3D data->base; - int i; - - for (i =3D 0; i < nums; i++) { - clk =3D clk_register_divider_table(NULL, clks[i].name, - clks[i].parent_name, - clks[i].flags, - base + clks[i].offset, - clks[i].shift, clks[i].width, - clks[i].div_flags, - clks[i].table, - &hisi_clk_lock); - if (IS_ERR(clk)) { - pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); - goto err; - } - - if (clks[i].alias) - clk_register_clkdev(clk, clks[i].alias, NULL); - - data->clk_data.clks[clks[i].id] =3D clk; - } - - return 0; - -err: - while (i--) - clk_unregister_divider(data->clk_data.clks[clks[i].id]); - - return PTR_ERR(clk); -} -EXPORT_SYMBOL_GPL(hisi_clk_register_divider); - -int hisi_clk_register_gate(const struct hisi_gate_clock *clks, - int nums, struct hisi_clock_data *data) -{ - struct clk *clk; - void __iomem *base =3D data->base; - int i; - - for (i =3D 0; i < nums; i++) { - clk =3D clk_register_gate(NULL, clks[i].name, - clks[i].parent_name, - clks[i].flags, - base + clks[i].offset, - clks[i].bit_idx, - clks[i].gate_flags, - &hisi_clk_lock); - if (IS_ERR(clk)) { - pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); - goto err; - } - - if (clks[i].alias) - clk_register_clkdev(clk, clks[i].alias, NULL); - - data->clk_data.clks[clks[i].id] =3D clk; - } - - return 0; - -err: - while (i--) - clk_unregister_gate(data->clk_data.clks[clks[i].id]); - - return PTR_ERR(clk); -} -EXPORT_SYMBOL_GPL(hisi_clk_register_gate); - -void hisi_clk_register_gate_sep(const struct hisi_gate_clock *clks, - int nums, struct hisi_clock_data *data) -{ - struct clk *clk; - void __iomem *base =3D data->base; - int i; - - for (i =3D 0; i < nums; i++) { - clk =3D hisi_register_clkgate_sep(NULL, clks[i].name, - clks[i].parent_name, - clks[i].flags, - base + clks[i].offset, - clks[i].bit_idx, - clks[i].gate_flags, - &hisi_clk_lock); - if (IS_ERR(clk)) { - pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); - continue; - } - - if (clks[i].alias) - clk_register_clkdev(clk, clks[i].alias, NULL); - - data->clk_data.clks[clks[i].id] =3D clk; - } -} -EXPORT_SYMBOL_GPL(hisi_clk_register_gate_sep); - -void __init hi6220_clk_register_divider(const struct hi6220_divider_clock = *clks, - int nums, struct hisi_clock_data *data) -{ - struct clk *clk; - void __iomem *base =3D data->base; - int i; - - for (i =3D 0; i < nums; i++) { - clk =3D hi6220_register_clkdiv(NULL, clks[i].name, - clks[i].parent_name, - clks[i].flags, - base + clks[i].offset, - clks[i].shift, - clks[i].width, - clks[i].mask_bit, - &hisi_clk_lock); - if (IS_ERR(clk)) { - pr_err("%s: failed to register clock %s\n", - __func__, clks[i].name); - continue; - } - - if (clks[i].alias) - clk_register_clkdev(clk, clks[i].alias, NULL); - - data->clk_data.clks[clks[i].id] =3D clk; - } -} +hisi_clk_register_fn(hisi_clk_register_divider, hisi_divider_clock, + devm_clk_hw_register_divider_table(dev, p_clk->name, p_clk->parent_name, + p_clk->flags, base + p_clk->offset, p_clk->shift, p_clk->width, + p_clk->div_flags, p_clk->table, &hisi_clk_lock)) +hisi_clk_register_fn(hisi_clk_register_gate, hisi_gate_clock, + devm_clk_hw_register_gate(dev, p_clk->name, p_clk->parent_name, + p_clk->flags, base + p_clk->offset, p_clk->bit_idx, + p_clk->gate_flags, &hisi_clk_lock)) +hisi_clk_register_fn(hisi_clk_register_gate_sep, hisi_gate_clock, + devm_clk_hw_register_hisi_gate_sep(dev, p_clk->name, p_clk->parent_name, + p_clk->flags, base + p_clk->offset, p_clk->bit_idx, + p_clk->gate_flags, &hisi_clk_lock)) +hisi_clk_register_fn(hi6220_clk_register_divider, hi6220_divider_clock, + devm_clk_hw_register_hi6220_divider(dev, p_clk->name, p_clk->parent_name, + p_clk->flags, base + p_clk->offset, p_clk->shift, p_clk->width, + p_clk->mask_bit, &hisi_clk_lock)) =20 static size_t hisi_clocks_get_nr(const struct hisi_clocks *clks) { @@ -406,38 +280,20 @@ static int hisi_clk_register(struct device *dev, cons= t struct hisi_clocks *clks, { int ret; =20 - if (clks->mux_clks_num) { - ret =3D hisi_clk_register_mux(clks->mux_clks, - clks->mux_clks_num, data); - if (ret) - return ret; - } - - if (clks->phase_clks_num) { - ret =3D hisi_clk_register_phase(dev, clks->phase_clks, - clks->phase_clks_num, data); - if (ret) - return ret; - } - - if (clks->divider_clks_num) { - ret =3D hisi_clk_register_divider(clks->divider_clks, - clks->divider_clks_num, data); - if (ret) - return ret; - } - - if (clks->gate_clks_num) { - ret =3D hisi_clk_register_gate(clks->gate_clks, - clks->gate_clks_num, data); - if (ret) - return ret; - } - - if (clks->gate_sep_clks_num) { - hisi_clk_register_gate_sep(clks->gate_sep_clks, - clks->gate_sep_clks_num, data); - } +#define do_hisi_clk_register(type) do { \ + if (clks->type##_clks_num) { \ + ret =3D hisi_clk_register_##type(dev, clks->type##_clks, \ + clks->type##_clks_num, data); \ + if (ret) \ + return ret; \ + } \ +} while (0) + + do_hisi_clk_register(mux); + do_hisi_clk_register(phase); + do_hisi_clk_register(divider); + do_hisi_clk_register(gate); + do_hisi_clk_register(gate_sep); =20 if (clks->clk_register_customized && clks->customized_clks_num) { ret =3D clks->clk_register_customized(dev, clks->customized_clks, diff --git a/drivers/clk/hisilicon/clk.h b/drivers/clk/hisilicon/clk.h index 87b17e9b79a3..5a72d7ab5587 100644 --- a/drivers/clk/hisilicon/clk.h +++ b/drivers/clk/hisilicon/clk.h @@ -4,6 +4,7 @@ * * Copyright (c) 2012-2013 Hisilicon Limited. * Copyright (c) 2012-2013 Linaro Limited. + * Copyright (c) 2023 David Yang * * Author: Haojian Zhuang * Xin Li @@ -19,8 +20,18 @@ struct platform_device; struct hisi_clocks; =20 +/* + * (Virtual) fixed clocks, often depended by crucial peripherals, require + * early initialization before device probing, thus cannot use devm APIs. + * Otherwise, kernel will defer those peripherals, causing boot failure. + * + * fixed_rate and fixed_factor clocks are driver-managed. They are freed by + * `hisi_clk_free` altogether. + * + * Other clocks are devm-managed. + */ struct hisi_clock_data { - struct clk_onecell_data clk_data; + struct clk_hw_onecell_data *clk_data; void __iomem *base; const struct hisi_clocks *clks; }; @@ -138,57 +149,45 @@ struct hisi_clocks { size_t num, struct hisi_clock_data *data); }; =20 -struct clk *hisi_register_clkgate_sep(struct device *, const char *, - const char *, unsigned long, - void __iomem *, u8, - u8, spinlock_t *); -struct clk *hi6220_register_clkdiv(struct device *dev, const char *name, - const char *parent_name, unsigned long flags, void __iomem *reg, - u8 shift, u8 width, u32 mask_bit, spinlock_t *lock); - -struct hisi_clock_data *hisi_clk_alloc(struct platform_device *, int); -struct hisi_clock_data *hisi_clk_init(struct device_node *, int); -void hisi_clk_free(struct device_node *np, struct hisi_clock_data *data); -int hisi_clk_register_fixed_rate(const struct hisi_fixed_rate_clock *, - int, struct hisi_clock_data *); -int hisi_clk_register_fixed_factor(const struct hisi_fixed_factor_clock *, - int, struct hisi_clock_data *); -int hisi_clk_register_mux(const struct hisi_mux_clock *, int, - struct hisi_clock_data *); -struct clk *clk_register_hisi_phase(struct device *dev, - const struct hisi_phase_clock *clks, +struct clk_hw * +devm_clk_hw_register_hisi_phase(struct device *dev, const struct hisi_phas= e_clock *clks, void __iomem *base, spinlock_t *lock); +struct clk_hw * +devm_clk_hw_register_hisi_gate_sep(struct device *dev, const char *name, + const char *parent_name, unsigned long flags, + void __iomem *reg, u8 bit_idx, + u8 clk_gate_flags, spinlock_t *lock); +struct clk_hw * +devm_clk_hw_register_hi6220_divider(struct device *dev, const char *name, + const char *parent_name, unsigned long flags, + void __iomem *reg, u8 shift, + u8 width, u32 mask_bit, spinlock_t *lock); + +struct hisi_clock_data *hisi_clk_init(struct device_node *np, size_t nr); +void hisi_clk_free(struct device_node *np, struct hisi_clock_data *data); + +int hisi_clk_register_fixed_rate(const struct hisi_fixed_rate_clock *clks, + size_t num, struct hisi_clock_data *data); +int hisi_clk_register_fixed_factor(const struct hisi_fixed_factor_clock *c= lks, + size_t num, struct hisi_clock_data *data); + +int hisi_clk_register_mux(struct device *dev, const struct hisi_mux_clock = *clks, + size_t num, struct hisi_clock_data *data); int hisi_clk_register_phase(struct device *dev, - const struct hisi_phase_clock *clks, - int nums, struct hisi_clock_data *data); -int hisi_clk_register_divider(const struct hisi_divider_clock *, - int, struct hisi_clock_data *); -int hisi_clk_register_gate(const struct hisi_gate_clock *, - int, struct hisi_clock_data *); -void hisi_clk_register_gate_sep(const struct hisi_gate_clock *, - int, struct hisi_clock_data *); -void hi6220_clk_register_divider(const struct hi6220_divider_clock *, - int, struct hisi_clock_data *); - -#define hisi_clk_unregister(type) \ -static inline \ -void hisi_clk_unregister_##type(const struct hisi_##type##_clock *clks, \ - int nums, struct hisi_clock_data *data) \ -{ \ - struct clk **clocks =3D data->clk_data.clks; \ - int i; \ - for (i =3D 0; i < nums; i++) { \ - int id =3D clks[i].id; \ - if (clocks[id]) \ - clk_unregister_##type(clocks[id]); \ - } \ -} - -hisi_clk_unregister(fixed_rate) -hisi_clk_unregister(fixed_factor) -hisi_clk_unregister(mux) -hisi_clk_unregister(divider) -hisi_clk_unregister(gate) + const struct hisi_phase_clock *clks, + size_t num, struct hisi_clock_data *data); +int hisi_clk_register_divider(struct device *dev, + const struct hisi_divider_clock *clks, + size_t num, struct hisi_clock_data *data); +int hisi_clk_register_gate(struct device *dev, + const struct hisi_gate_clock *clks, + size_t num, struct hisi_clock_data *data); +int hisi_clk_register_gate_sep(struct device *dev, + const struct hisi_gate_clock *clks, + size_t num, struct hisi_clock_data *data); +int hi6220_clk_register_divider(struct device *dev, + const struct hi6220_divider_clock *clks, + size_t num, struct hisi_clock_data *data); =20 /* helper functions for platform driver */ =20 diff --git a/drivers/clk/hisilicon/clkdivider-hi6220.c b/drivers/clk/hisili= con/clkdivider-hi6220.c index 5348bafe694f..3c03b3e5b841 100644 --- a/drivers/clk/hisilicon/clkdivider-hi6220.c +++ b/drivers/clk/hisilicon/clkdivider-hi6220.c @@ -9,7 +9,7 @@ =20 #include #include -#include +#include #include #include #include @@ -97,19 +97,19 @@ static const struct clk_ops hi6220_clkdiv_ops =3D { .set_rate =3D hi6220_clkdiv_set_rate, }; =20 -struct clk *hi6220_register_clkdiv(struct device *dev, const char *name, +struct clk_hw *devm_clk_hw_register_hi6220_divider(struct device *dev, con= st char *name, const char *parent_name, unsigned long flags, void __iomem *reg, u8 shift, u8 width, u32 mask_bit, spinlock_t *lock) { struct hi6220_clk_divider *div; - struct clk *clk; struct clk_init_data init; struct clk_div_table *table; u32 max_div, min_div; int i; + int ret; =20 /* allocate the divider */ - div =3D kzalloc(sizeof(*div), GFP_KERNEL); + div =3D devm_kzalloc(dev, sizeof(*div), GFP_KERNEL); if (!div) return ERR_PTR(-ENOMEM); =20 @@ -117,11 +117,9 @@ struct clk *hi6220_register_clkdiv(struct device *dev,= const char *name, max_div =3D div_mask(width) + 1; min_div =3D 1; =20 - table =3D kcalloc(max_div + 1, sizeof(*table), GFP_KERNEL); - if (!table) { - kfree(div); + table =3D devm_kcalloc(dev, max_div + 1, sizeof(*table), GFP_KERNEL); + if (!table) return ERR_PTR(-ENOMEM); - } =20 for (i =3D 0; i < max_div; i++) { table[i].div =3D min_div + i; @@ -144,11 +142,9 @@ struct clk *hi6220_register_clkdiv(struct device *dev,= const char *name, div->table =3D table; =20 /* register the clock */ - clk =3D clk_register(dev, &div->hw); - if (IS_ERR(clk)) { - kfree(table); - kfree(div); - } + ret =3D devm_clk_hw_register(dev, &div->hw); + if (ret) + return ERR_PTR(ret); =20 - return clk; + return &div->hw; } diff --git a/drivers/clk/hisilicon/clkgate-separated.c b/drivers/clk/hisili= con/clkgate-separated.c index 90d858522967..dc64a8a0ab58 100644 --- a/drivers/clk/hisilicon/clkgate-separated.c +++ b/drivers/clk/hisilicon/clkgate-separated.c @@ -11,8 +11,8 @@ =20 #include #include +#include #include -#include =20 #include "clk.h" =20 @@ -80,17 +80,18 @@ static const struct clk_ops clkgate_separated_ops =3D { .is_enabled =3D clkgate_separated_is_enabled, }; =20 -struct clk *hisi_register_clkgate_sep(struct device *dev, const char *name, - const char *parent_name, - unsigned long flags, - void __iomem *reg, u8 bit_idx, - u8 clk_gate_flags, spinlock_t *lock) +struct clk_hw * +devm_clk_hw_register_hisi_gate_sep(struct device *dev, const char *name, + const char *parent_name, + unsigned long flags, + void __iomem *reg, u8 bit_idx, + u8 clk_gate_flags, spinlock_t *lock) { struct clkgate_separated *sclk; - struct clk *clk; struct clk_init_data init; + int ret; =20 - sclk =3D kzalloc(sizeof(*sclk), GFP_KERNEL); + sclk =3D devm_kzalloc(dev, sizeof(*sclk), GFP_KERNEL); if (!sclk) return ERR_PTR(-ENOMEM); =20 @@ -106,8 +107,9 @@ struct clk *hisi_register_clkgate_sep(struct device *de= v, const char *name, sclk->hw.init =3D &init; sclk->lock =3D lock; =20 - clk =3D clk_register(dev, &sclk->hw); - if (IS_ERR(clk)) - kfree(sclk); - return clk; + ret =3D devm_clk_hw_register(dev, &sclk->hw); + if (ret) + return ERR_PTR(ret); + + return &sclk->hw; } --=20 2.43.0