From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753202AbeBSPpR (ORCPT ); Mon, 19 Feb 2018 10:45:17 -0500 Received: from mailout2.w1.samsung.com ([210.118.77.12]:59796 "EHLO mailout2.w1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753009AbeBSPpG (ORCPT ); Mon, 19 Feb 2018 10:45:06 -0500 DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.w1.samsung.com 20180219154503euoutp027caec951bbb542486dcc9b017d089762~UxJFsl3ba1439314393euoutp02Q X-AuditID: cbfec7f2-5ffe19c000011644-47-5a8af0faefb5 From: Maciej Purski To: linux-media@vger.kernel.org, linux-samsung-soc@vger.kernel.org, linux-arm-kernel@lists.infradead.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org Cc: Michael Turquette , Stephen Boyd , Inki Dae , Joonyoung Shim , Seung-Woo Kim , Kyungmin Park , David Airlie , Kukjin Kim , Krzysztof Kozlowski , Mauro Carvalho Chehab , Andrzej Pietrasiewicz , Jacek Anaszewski , Kamil Debski , Jeongtae Park , Andrzej Hajda , Russell King , Sylwester Nawrocki , Thibault Saunier , Javier Martinez Canillas , Hans Verkuil , Hoegeun Kwon , Bartlomiej Zolnierkiewicz , Marek Szyprowski , Maciej Purski Subject: [PATCH 1/8] clk: Add clk_bulk_alloc functions Date: Mon, 19 Feb 2018 16:43:59 +0100 Message-id: <1519055046-2399-2-git-send-email-m.purski@samsung.com> X-Mailer: git-send-email 2.7.4 In-reply-to: <1519055046-2399-1-git-send-email-m.purski@samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAAzWSa0iTYRTHe977zMXrtHrQWDIKupCmdHmgC4YGb2jghz6ExGzVi0lq452z VlFZ1Ny8X8pLVkKiMbTm2qxWRi1zpeXSyuwyFeyipWiZhVquzVe//c/5/875nw+HwWVOMphJ TkvnhTRVioLyIxpbJlxrJkeNCWsnWyLR+xvtJMptf4ahikE9gRrKbpLo9fgIhUYLywEaqTVS qKi3gEAfbGYCDQ3XYai5/g2GBno6CFT+VE+i/P7vOHK5zDR6cWaIRpb+LhL9yOkh0St7JYVy zDYSlbkeYMhxoQmgqsH3BKpvdtOoxvIXQx2t29HjIe+S6a4GApUVD1Jo7GERHiXnXnV14NxI 9zmaK5lqILm7FW6as5gMFHf7dx/J9WY7Me5W9SnOmu/t51lNgBuzyLnXzZl0vH+C3+YDfEpy Bi+Eb93rdzDnvJlUZ68+Wun6g58GEwojkDCQXQcnHYWYEfgxMvY6gJ7KG0AsxgC0TbnJOUpv uEaIRg2At3PbaLHwAOguyfc6DEOxq2CdPtE3EMS2AHjlbpyPwdnfNCyYfAR8RiC7ATpsvTOa YJfDzuZPwDcrZaOhrT9WDJPDd+0G3KclbAzsu9dE+fZAtoeGLf+GMRGKgc88VkrUgfCb00qL egk0ZD2aZY7DjnH7LHMCZn4wzzKb4FiRdSYAZxfAosZS3HcDZKUw67xMRDiYl/uZEPU2WK6v nTlZxpYCeLk7ugAEV4F5JrCY12pSk3hNRBp/JEyjStVo05LC9h9OtQDve7VNO3/eAeOd+xyA ZYDCX8q6jQkyUpWh0aU6AGRwRZA0rtvbkh5Q6Y7xwuFEQZvCaxwghCEUi6XKFScTZGySKp0/ xPNqXphzMUYSfBrMj9/t2PXx5craL1cLL1XZdc9/CU6TVh2wx7919P5lg7yteD3z4Kz2c8CK AaUyo29hdtVSt074qgvamVgXYXfcnJbsL0kUdigjFkUa48PzGrdUblR2RllNA1OtyWffTrvk oWRmdaDHv8Ju40zG1a4hj/LisuEnAaFNbVisOqRaQWgOqiJW4YJG9R+DFDWbWgMAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFprFIsWRmVeSWpSXmKPExsVy+t/xa7o/PnRFGTx+KGlxa905VovecyeZ LGa9bGex2DhjPavFla/v2Sw+TJzJaPF+eRebxaT7E1gsbm/dwGLx5u0aJosja68yWby4d5HF YuaJdlaL/sevmS3On9/AbnG26Q27xabH11gtPvbcY7W4vGsOm0XPhq2sFjPO72OyODR1L6PF gpe3WCzWHrnLbrFs0x8mi4unXC0OvwEa8u/aRhaLGZNfsll8PjCJ2UHO4/K1i8we72+0sntM +b2R1WPnrLvsHptWdbJ5bP/2gNXjfvdxJo/NS+o9tvQDxfu2rGL0+LxJzuPKkUb2AJ4oLpuU 1JzMstQifbsEroyetg2sBd3aFXPOf2duYPyp1MXIySEhYCLR3rmYpYuRi0NIYAmjxM9rW5kg nEYmib6elaxdjBwcbAJaEmva40HiIgLHGCUe3lnMCtLNLPCHXaKvoQDEFhYwkzi09T4jiM0i oCpx6cgTRpBeXgFnia2PvSGWyUncPNfJDGJzCrhIPNi9lw3EFgIqOX//EtsERp4FjAyrGEVS S4tz03OLDfWKE3OLS/PS9ZLzczcxAmNs27Gfm3cwXtoYfIhRgINRiYdX4G5XlBBrYllxZe4h RgkOZiURXp8bQCHelMTKqtSi/Pii0pzU4kOM0hwsSuK85w0qo4QE0hNLUrNTUwtSi2CyTByc Ug2M7C3vfOZeD/yyesr21hWh/zdfWuAR3sJZ7WN4JFzD1zdFtl4n+6H/zeSdXFuXMwa5n3QN 6yn5E1VXrViq9I0t0/fmpt/761V9ErS3cep8C3J42Kkr6qH/f7Wl0e2d+jr6jx+vsJ4asVcv NqlBNkk8SjjtjeXFdHPpKb5XOgQsCqcH2nybqKnEUpyRaKjFXFScCAAV15HkrQIAAA== X-CMS-MailID: 20180219154456eucas1p15f4073beaf61312238f142f217a8bb3c X-Msg-Generator: CA CMS-TYPE: 201P X-CMS-RootMailID: 20180219154456eucas1p15f4073beaf61312238f142f217a8bb3c X-RootMTR: 20180219154456eucas1p15f4073beaf61312238f142f217a8bb3c References: <1519055046-2399-1-git-send-email-m.purski@samsung.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org When a driver is going to use clk_bulk_get() function, it has to initialize an array of clk_bulk_data, by filling its id fields. Add a new function to the core, which dynamically allocates clk_bulk_data array and fills its id fields. Add clk_bulk_free() function, which frees the array allocated by clk_bulk_alloc() function. Add a managed version of clk_bulk_alloc(). Signed-off-by: Maciej Purski --- drivers/clk/clk-bulk.c | 16 ++++++++++++ drivers/clk/clk-devres.c | 37 +++++++++++++++++++++++++--- include/linux/clk.h | 64 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 113 insertions(+), 4 deletions(-) diff --git a/drivers/clk/clk-bulk.c b/drivers/clk/clk-bulk.c index 4c10456..2f16941 100644 --- a/drivers/clk/clk-bulk.c +++ b/drivers/clk/clk-bulk.c @@ -19,6 +19,22 @@ #include #include #include +#include + +struct clk_bulk_data *clk_bulk_alloc(int num_clocks, const char *const *clk_ids) +{ + struct clk_bulk_data *ptr; + int i; + + ptr = kcalloc(num_clocks, sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + for (i = 0; i < num_clocks; i++) + ptr[i].id = clk_ids[i]; + + return ptr; +} void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) { diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c index d854e26..2115b97 100644 --- a/drivers/clk/clk-devres.c +++ b/drivers/clk/clk-devres.c @@ -9,6 +9,39 @@ #include #include +struct clk_bulk_devres { + struct clk_bulk_data *clks; + int num_clks; +}; + +static void devm_clk_alloc_release(struct device *dev, void *res) +{ + struct clk_bulk_devres *devres = res; + + clk_bulk_free(devres->clks); +} + +struct clk_bulk_data *devm_clk_bulk_alloc(struct device *dev, int num_clks, + const char *const *clk_ids) +{ + struct clk_bulk_data **ptr, *clk_bulk; + + ptr = devres_alloc(devm_clk_alloc_release, + num_clks * sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + clk_bulk = clk_bulk_alloc(num_clks, clk_ids); + if (clk_bulk) { + *ptr = clk_bulk; + devres_add(dev, ptr); + } else { + devres_free(ptr); + } + + return clk_bulk; +} + static void devm_clk_release(struct device *dev, void *res) { clk_put(*(struct clk **)res); @@ -34,10 +67,6 @@ struct clk *devm_clk_get(struct device *dev, const char *id) } EXPORT_SYMBOL(devm_clk_get); -struct clk_bulk_devres { - struct clk_bulk_data *clks; - int num_clks; -}; static void devm_clk_bulk_release(struct device *dev, void *res) { diff --git a/include/linux/clk.h b/include/linux/clk.h index 4c4ef9f..7d66f41 100644 --- a/include/linux/clk.h +++ b/include/linux/clk.h @@ -15,6 +15,7 @@ #include #include #include +#include struct device; struct clk; @@ -240,6 +241,52 @@ static inline void clk_bulk_unprepare(int num_clks, struct clk_bulk_data *clks) #endif #ifdef CONFIG_HAVE_CLK + +/** + * clk_bulk_alloc - allocates an array of clk_bulk_data and fills their + * id field + * @num_clks: number of clk_bulk_data + * @clk_ids: array of clock consumer ID's + * + * This function allows drivers to dynamically create an array of clk_bulk_data + * and fill their id field in one operation. If successful, it allows calling + * clk_bulk_get on the pointer returned by this function. + * + * Returns a pointer to a clk_bulk_data array, or valid IS_ERR() condition + * containing errno. + */ +struct clk_bulk_data *clk_bulk_alloc(int num_clks, const char *const *clk_ids); + +/** + * devm_clk_bulk_alloc - allocates an array of clk_bulk_data and fills their + * id field + * @dev: device for clock "consumer" + * @num_clks: number of clk_bulk_data + * @clk_ids: array of clock consumer ID's + * + * This function allows drivers to dynamically create an array of clk_bulk_data + * and fill their id field in one operation with management, the array will + * automatically be freed when the device is unbound. If successful, it allows + * calling clk_bulk_get on the pointer returned by this function. + * + * Returns a pointer to a clk_bulk_data array, or valid IS_ERR() condition + * containing errno. + */ +struct clk_bulk_data *devm_clk_bulk_alloc(struct device *dev, int num_clks, + const char * const *clk_ids); + +/** + * clk_bulk_free - frees the array of clk_bulk_data + * @clks: pointer to clk_bulk_data array + * + * This function frees the array allocated by clk_bulk_data. It must be called + * when all clks are freed. + */ +static inline void clk_bulk_free(struct clk_bulk_data *clks) +{ + kfree(clks); +} + /** * clk_get - lookup and obtain a reference to a clock producer. * @dev: device for clock "consumer" @@ -598,6 +645,23 @@ struct clk *clk_get_sys(const char *dev_id, const char *con_id); #else /* !CONFIG_HAVE_CLK */ +static inline struct clk_bulk_data *clk_bulk_alloc(int num_clks, + const char **clk_ids) +{ + return NULL; +} + +static inline struct clk_bulk_data *devm_clk_bulk_alloc(struct device *dev, + int num_clks, + const char **clk_ids) +{ + return NULL; +} + +static inline void clk_bulk_free(struct clk_bulk_data *clks) +{ +} + static inline struct clk *clk_get(struct device *dev, const char *id) { return NULL; -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Maciej Purski Subject: [PATCH 1/8] clk: Add clk_bulk_alloc functions Date: Mon, 19 Feb 2018 16:43:59 +0100 Message-ID: <1519055046-2399-2-git-send-email-m.purski@samsung.com> References: <1519055046-2399-1-git-send-email-m.purski@samsung.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-reply-to: <1519055046-2399-1-git-send-email-m.purski@samsung.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-media@vger.kernel.org, linux-samsung-soc@vger.kernel.org, linux-arm-kernel@lists.infradead.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org Cc: David Airlie , Michael Turquette , Kamil Debski , Maciej Purski , Sylwester Nawrocki , Marek Szyprowski , Thibault Saunier , Russell King , Krzysztof Kozlowski , Javier Martinez Canillas , Kukjin Kim , Hoegeun Kwon , Bartlomiej Zolnierkiewicz , Jeongtae Park , Jacek Anaszewski , Andrzej Pietrasiewicz , Mauro Carvalho Chehab , Stephen Boyd , Seung-Woo Kim , Hans Verkuil , Kyungmin Park List-Id: linux-samsung-soc@vger.kernel.org V2hlbiBhIGRyaXZlciBpcyBnb2luZyB0byB1c2UgY2xrX2J1bGtfZ2V0KCkgZnVuY3Rpb24sIGl0 IGhhcyB0bwppbml0aWFsaXplIGFuIGFycmF5IG9mIGNsa19idWxrX2RhdGEsIGJ5IGZpbGxpbmcg aXRzIGlkIGZpZWxkcy4KCkFkZCBhIG5ldyBmdW5jdGlvbiB0byB0aGUgY29yZSwgd2hpY2ggZHlu YW1pY2FsbHkgYWxsb2NhdGVzCmNsa19idWxrX2RhdGEgYXJyYXkgYW5kIGZpbGxzIGl0cyBpZCBm aWVsZHMuIEFkZCBjbGtfYnVsa19mcmVlKCkKZnVuY3Rpb24sIHdoaWNoIGZyZWVzIHRoZSBhcnJh eSBhbGxvY2F0ZWQgYnkgY2xrX2J1bGtfYWxsb2MoKSBmdW5jdGlvbi4KQWRkIGEgbWFuYWdlZCB2 ZXJzaW9uIG9mIGNsa19idWxrX2FsbG9jKCkuCgpTaWduZWQtb2ZmLWJ5OiBNYWNpZWogUHVyc2tp IDxtLnB1cnNraUBzYW1zdW5nLmNvbT4KLS0tCiBkcml2ZXJzL2Nsay9jbGstYnVsay5jICAgfCAx NiArKysrKysrKysrKysKIGRyaXZlcnMvY2xrL2Nsay1kZXZyZXMuYyB8IDM3ICsrKysrKysrKysr KysrKysrKysrKysrKystLS0KIGluY2x1ZGUvbGludXgvY2xrLmggICAgICB8IDY0ICsrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2Vk LCAxMTMgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJz L2Nsay9jbGstYnVsay5jIGIvZHJpdmVycy9jbGsvY2xrLWJ1bGsuYwppbmRleCA0YzEwNDU2Li4y ZjE2OTQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Nsay9jbGstYnVsay5jCisrKyBiL2RyaXZlcnMv Y2xrL2Nsay1idWxrLmMKQEAgLTE5LDYgKzE5LDIyIEBACiAjaW5jbHVkZSA8bGludXgvY2xrLmg+ CiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+Cisj aW5jbHVkZSA8bGludXgvc2xhYi5oPgorCitzdHJ1Y3QgY2xrX2J1bGtfZGF0YSAqY2xrX2J1bGtf YWxsb2MoaW50IG51bV9jbG9ja3MsIGNvbnN0IGNoYXIgKmNvbnN0ICpjbGtfaWRzKQoreworCXN0 cnVjdCBjbGtfYnVsa19kYXRhICpwdHI7CisJaW50IGk7CisKKwlwdHIgPSBrY2FsbG9jKG51bV9j bG9ja3MsIHNpemVvZigqcHRyKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwdHIpCisJCXJldHVybiBF UlJfUFRSKC1FTk9NRU0pOworCisJZm9yIChpID0gMDsgaSA8IG51bV9jbG9ja3M7IGkrKykKKwkJ cHRyW2ldLmlkID0gY2xrX2lkc1tpXTsKKworCXJldHVybiBwdHI7Cit9CiAKIHZvaWQgY2xrX2J1 bGtfcHV0KGludCBudW1fY2xrcywgc3RydWN0IGNsa19idWxrX2RhdGEgKmNsa3MpCiB7CmRpZmYg LS1naXQgYS9kcml2ZXJzL2Nsay9jbGstZGV2cmVzLmMgYi9kcml2ZXJzL2Nsay9jbGstZGV2cmVz LmMKaW5kZXggZDg1NGUyNi4uMjExNWI5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9jbGsvY2xrLWRl dnJlcy5jCisrKyBiL2RyaXZlcnMvY2xrL2Nsay1kZXZyZXMuYwpAQCAtOSw2ICs5LDM5IEBACiAj aW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+CiAjaW5jbHVkZSA8bGludXgvZ2ZwLmg+CiAKK3N0cnVj dCBjbGtfYnVsa19kZXZyZXMgeworCXN0cnVjdCBjbGtfYnVsa19kYXRhICpjbGtzOworCWludCBu dW1fY2xrczsKK307CisKK3N0YXRpYyB2b2lkIGRldm1fY2xrX2FsbG9jX3JlbGVhc2Uoc3RydWN0 IGRldmljZSAqZGV2LCB2b2lkICpyZXMpCit7CisJc3RydWN0IGNsa19idWxrX2RldnJlcyAqZGV2 cmVzID0gcmVzOworCisJY2xrX2J1bGtfZnJlZShkZXZyZXMtPmNsa3MpOworfQorCitzdHJ1Y3Qg Y2xrX2J1bGtfZGF0YSAqZGV2bV9jbGtfYnVsa19hbGxvYyhzdHJ1Y3QgZGV2aWNlICpkZXYsIGlu dCBudW1fY2xrcywKKwkJCQkJICBjb25zdCBjaGFyICpjb25zdCAqY2xrX2lkcykKK3sKKwlzdHJ1 Y3QgY2xrX2J1bGtfZGF0YSAqKnB0ciwgKmNsa19idWxrOworCisJcHRyID0gZGV2cmVzX2FsbG9j KGRldm1fY2xrX2FsbG9jX3JlbGVhc2UsCisJCQkgICBudW1fY2xrcyAqIHNpemVvZigqcHRyKSwg R0ZQX0tFUk5FTCk7CisJaWYgKCFwdHIpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJ Y2xrX2J1bGsgPSBjbGtfYnVsa19hbGxvYyhudW1fY2xrcywgY2xrX2lkcyk7CisJaWYgKGNsa19i dWxrKSB7CisJCSpwdHIgPSBjbGtfYnVsazsKKwkJZGV2cmVzX2FkZChkZXYsIHB0cik7CisJfSBl bHNlIHsKKwkJZGV2cmVzX2ZyZWUocHRyKTsKKwl9CisKKwlyZXR1cm4gY2xrX2J1bGs7Cit9CisK IHN0YXRpYyB2b2lkIGRldm1fY2xrX3JlbGVhc2Uoc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpy ZXMpCiB7CiAJY2xrX3B1dCgqKHN0cnVjdCBjbGsgKiopcmVzKTsKQEAgLTM0LDEwICs2Nyw2IEBA IHN0cnVjdCBjbGsgKmRldm1fY2xrX2dldChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIg KmlkKQogfQogRVhQT1JUX1NZTUJPTChkZXZtX2Nsa19nZXQpOwogCi1zdHJ1Y3QgY2xrX2J1bGtf ZGV2cmVzIHsKLQlzdHJ1Y3QgY2xrX2J1bGtfZGF0YSAqY2xrczsKLQlpbnQgbnVtX2Nsa3M7Ci19 OwogCiBzdGF0aWMgdm9pZCBkZXZtX2Nsa19idWxrX3JlbGVhc2Uoc3RydWN0IGRldmljZSAqZGV2 LCB2b2lkICpyZXMpCiB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Nsay5oIGIvaW5jbHVk ZS9saW51eC9jbGsuaAppbmRleCA0YzRlZjlmLi43ZDY2ZjQxIDEwMDY0NAotLS0gYS9pbmNsdWRl L2xpbnV4L2Nsay5oCisrKyBiL2luY2x1ZGUvbGludXgvY2xrLmgKQEAgLTE1LDYgKzE1LDcgQEAK ICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNs dWRlIDxsaW51eC9ub3RpZmllci5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KIAogc3RydWN0 IGRldmljZTsKIHN0cnVjdCBjbGs7CkBAIC0yNDAsNiArMjQxLDUyIEBAIHN0YXRpYyBpbmxpbmUg dm9pZCBjbGtfYnVsa191bnByZXBhcmUoaW50IG51bV9jbGtzLCBzdHJ1Y3QgY2xrX2J1bGtfZGF0 YSAqY2xrcykKICNlbmRpZgogCiAjaWZkZWYgQ09ORklHX0hBVkVfQ0xLCisKKy8qKgorICogY2xr X2J1bGtfYWxsb2MgLSBhbGxvY2F0ZXMgYW4gYXJyYXkgb2YgY2xrX2J1bGtfZGF0YSBhbmQgZmls bHMgdGhlaXIKKyAqCQkgICAgaWQgZmllbGQKKyAqIEBudW1fY2xrczogbnVtYmVyIG9mIGNsa19i dWxrX2RhdGEKKyAqIEBjbGtfaWRzOiBhcnJheSBvZiBjbG9jayBjb25zdW1lciBJRCdzCisgKgor ICogVGhpcyBmdW5jdGlvbiBhbGxvd3MgZHJpdmVycyB0byBkeW5hbWljYWxseSBjcmVhdGUgYW4g YXJyYXkgb2YgY2xrX2J1bGtfZGF0YQorICogYW5kIGZpbGwgdGhlaXIgaWQgZmllbGQgaW4gb25l IG9wZXJhdGlvbi4gSWYgc3VjY2Vzc2Z1bCwgaXQgYWxsb3dzIGNhbGxpbmcKKyAqIGNsa19idWxr X2dldCBvbiB0aGUgcG9pbnRlciByZXR1cm5lZCBieSB0aGlzIGZ1bmN0aW9uLgorICoKKyAqIFJl dHVybnMgYSBwb2ludGVyIHRvIGEgY2xrX2J1bGtfZGF0YSBhcnJheSwgb3IgdmFsaWQgSVNfRVJS KCkgY29uZGl0aW9uCisgKiBjb250YWluaW5nIGVycm5vLgorICovCitzdHJ1Y3QgY2xrX2J1bGtf ZGF0YSAqY2xrX2J1bGtfYWxsb2MoaW50IG51bV9jbGtzLCBjb25zdCBjaGFyICpjb25zdCAqY2xr X2lkcyk7CisKKy8qKgorICogZGV2bV9jbGtfYnVsa19hbGxvYyAtIGFsbG9jYXRlcyBhbiBhcnJh eSBvZiBjbGtfYnVsa19kYXRhIGFuZCBmaWxscyB0aGVpcgorICoJCQkgaWQgZmllbGQKKyAqIEBk ZXY6IGRldmljZSBmb3IgY2xvY2sgImNvbnN1bWVyIgorICogQG51bV9jbGtzOiBudW1iZXIgb2Yg Y2xrX2J1bGtfZGF0YQorICogQGNsa19pZHM6IGFycmF5IG9mIGNsb2NrIGNvbnN1bWVyIElEJ3MK KyAqCisgKiBUaGlzIGZ1bmN0aW9uIGFsbG93cyBkcml2ZXJzIHRvIGR5bmFtaWNhbGx5IGNyZWF0 ZSBhbiBhcnJheSBvZiBjbGtfYnVsa19kYXRhCisgKiBhbmQgZmlsbCB0aGVpciBpZCBmaWVsZCBp biBvbmUgb3BlcmF0aW9uIHdpdGggbWFuYWdlbWVudCwgdGhlIGFycmF5IHdpbGwKKyAqIGF1dG9t YXRpY2FsbHkgYmUgZnJlZWQgd2hlbiB0aGUgZGV2aWNlIGlzIHVuYm91bmQuIElmIHN1Y2Nlc3Nm dWwsIGl0IGFsbG93cworICogY2FsbGluZyBjbGtfYnVsa19nZXQgb24gdGhlIHBvaW50ZXIgcmV0 dXJuZWQgYnkgdGhpcyBmdW5jdGlvbi4KKyAqCisgKiBSZXR1cm5zIGEgcG9pbnRlciB0byBhIGNs a19idWxrX2RhdGEgYXJyYXksIG9yIHZhbGlkIElTX0VSUigpIGNvbmRpdGlvbgorICogY29udGFp bmluZyBlcnJuby4KKyAqLworc3RydWN0IGNsa19idWxrX2RhdGEgKmRldm1fY2xrX2J1bGtfYWxs b2Moc3RydWN0IGRldmljZSAqZGV2LCBpbnQgbnVtX2Nsa3MsCisJCQkJCSAgY29uc3QgY2hhciAq IGNvbnN0ICpjbGtfaWRzKTsKKworLyoqCisgKiBjbGtfYnVsa19mcmVlIC0gZnJlZXMgdGhlIGFy cmF5IG9mIGNsa19idWxrX2RhdGEKKyAqIEBjbGtzOiBwb2ludGVyIHRvIGNsa19idWxrX2RhdGEg YXJyYXkKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGZyZWVzIHRoZSBhcnJheSBhbGxvY2F0ZWQgYnkg Y2xrX2J1bGtfZGF0YS4gSXQgbXVzdCBiZSBjYWxsZWQKKyAqIHdoZW4gYWxsIGNsa3MgYXJlIGZy ZWVkLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgY2xrX2J1bGtfZnJlZShzdHJ1Y3QgY2xrX2J1 bGtfZGF0YSAqY2xrcykKK3sKKwlrZnJlZShjbGtzKTsKK30KKwogLyoqCiAgKiBjbGtfZ2V0IC0g bG9va3VwIGFuZCBvYnRhaW4gYSByZWZlcmVuY2UgdG8gYSBjbG9jayBwcm9kdWNlci4KICAqIEBk ZXY6IGRldmljZSBmb3IgY2xvY2sgImNvbnN1bWVyIgpAQCAtNTk4LDYgKzY0NSwyMyBAQCBzdHJ1 Y3QgY2xrICpjbGtfZ2V0X3N5cyhjb25zdCBjaGFyICpkZXZfaWQsIGNvbnN0IGNoYXIgKmNvbl9p ZCk7CiAKICNlbHNlIC8qICFDT05GSUdfSEFWRV9DTEsgKi8KIAorc3RhdGljIGlubGluZSBzdHJ1 Y3QgY2xrX2J1bGtfZGF0YSAqY2xrX2J1bGtfYWxsb2MoaW50IG51bV9jbGtzLAorCQkJCQkJICAg Y29uc3QgY2hhciAqKmNsa19pZHMpCit7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBpbmxp bmUgc3RydWN0IGNsa19idWxrX2RhdGEgKmRldm1fY2xrX2J1bGtfYWxsb2Moc3RydWN0IGRldmlj ZSAqZGV2LAorCQkJCQkJCWludCBudW1fY2xrcywKKwkJCQkJCQljb25zdCBjaGFyICoqY2xrX2lk cykKK3sKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNsa19idWxrX2Zy ZWUoc3RydWN0IGNsa19idWxrX2RhdGEgKmNsa3MpCit7Cit9CisKIHN0YXRpYyBpbmxpbmUgc3Ry dWN0IGNsayAqY2xrX2dldChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKmlkKQogewog CXJldHVybiBOVUxMOwotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: m.purski@samsung.com (Maciej Purski) Date: Mon, 19 Feb 2018 16:43:59 +0100 Subject: [PATCH 1/8] clk: Add clk_bulk_alloc functions In-Reply-To: <1519055046-2399-1-git-send-email-m.purski@samsung.com> References: <1519055046-2399-1-git-send-email-m.purski@samsung.com> Message-ID: <1519055046-2399-2-git-send-email-m.purski@samsung.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org When a driver is going to use clk_bulk_get() function, it has to initialize an array of clk_bulk_data, by filling its id fields. Add a new function to the core, which dynamically allocates clk_bulk_data array and fills its id fields. Add clk_bulk_free() function, which frees the array allocated by clk_bulk_alloc() function. Add a managed version of clk_bulk_alloc(). Signed-off-by: Maciej Purski --- drivers/clk/clk-bulk.c | 16 ++++++++++++ drivers/clk/clk-devres.c | 37 +++++++++++++++++++++++++--- include/linux/clk.h | 64 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 113 insertions(+), 4 deletions(-) diff --git a/drivers/clk/clk-bulk.c b/drivers/clk/clk-bulk.c index 4c10456..2f16941 100644 --- a/drivers/clk/clk-bulk.c +++ b/drivers/clk/clk-bulk.c @@ -19,6 +19,22 @@ #include #include #include +#include + +struct clk_bulk_data *clk_bulk_alloc(int num_clocks, const char *const *clk_ids) +{ + struct clk_bulk_data *ptr; + int i; + + ptr = kcalloc(num_clocks, sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + for (i = 0; i < num_clocks; i++) + ptr[i].id = clk_ids[i]; + + return ptr; +} void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) { diff --git a/drivers/clk/clk-devres.c b/drivers/clk/clk-devres.c index d854e26..2115b97 100644 --- a/drivers/clk/clk-devres.c +++ b/drivers/clk/clk-devres.c @@ -9,6 +9,39 @@ #include #include +struct clk_bulk_devres { + struct clk_bulk_data *clks; + int num_clks; +}; + +static void devm_clk_alloc_release(struct device *dev, void *res) +{ + struct clk_bulk_devres *devres = res; + + clk_bulk_free(devres->clks); +} + +struct clk_bulk_data *devm_clk_bulk_alloc(struct device *dev, int num_clks, + const char *const *clk_ids) +{ + struct clk_bulk_data **ptr, *clk_bulk; + + ptr = devres_alloc(devm_clk_alloc_release, + num_clks * sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + clk_bulk = clk_bulk_alloc(num_clks, clk_ids); + if (clk_bulk) { + *ptr = clk_bulk; + devres_add(dev, ptr); + } else { + devres_free(ptr); + } + + return clk_bulk; +} + static void devm_clk_release(struct device *dev, void *res) { clk_put(*(struct clk **)res); @@ -34,10 +67,6 @@ struct clk *devm_clk_get(struct device *dev, const char *id) } EXPORT_SYMBOL(devm_clk_get); -struct clk_bulk_devres { - struct clk_bulk_data *clks; - int num_clks; -}; static void devm_clk_bulk_release(struct device *dev, void *res) { diff --git a/include/linux/clk.h b/include/linux/clk.h index 4c4ef9f..7d66f41 100644 --- a/include/linux/clk.h +++ b/include/linux/clk.h @@ -15,6 +15,7 @@ #include #include #include +#include struct device; struct clk; @@ -240,6 +241,52 @@ static inline void clk_bulk_unprepare(int num_clks, struct clk_bulk_data *clks) #endif #ifdef CONFIG_HAVE_CLK + +/** + * clk_bulk_alloc - allocates an array of clk_bulk_data and fills their + * id field + * @num_clks: number of clk_bulk_data + * @clk_ids: array of clock consumer ID's + * + * This function allows drivers to dynamically create an array of clk_bulk_data + * and fill their id field in one operation. If successful, it allows calling + * clk_bulk_get on the pointer returned by this function. + * + * Returns a pointer to a clk_bulk_data array, or valid IS_ERR() condition + * containing errno. + */ +struct clk_bulk_data *clk_bulk_alloc(int num_clks, const char *const *clk_ids); + +/** + * devm_clk_bulk_alloc - allocates an array of clk_bulk_data and fills their + * id field + * @dev: device for clock "consumer" + * @num_clks: number of clk_bulk_data + * @clk_ids: array of clock consumer ID's + * + * This function allows drivers to dynamically create an array of clk_bulk_data + * and fill their id field in one operation with management, the array will + * automatically be freed when the device is unbound. If successful, it allows + * calling clk_bulk_get on the pointer returned by this function. + * + * Returns a pointer to a clk_bulk_data array, or valid IS_ERR() condition + * containing errno. + */ +struct clk_bulk_data *devm_clk_bulk_alloc(struct device *dev, int num_clks, + const char * const *clk_ids); + +/** + * clk_bulk_free - frees the array of clk_bulk_data + * @clks: pointer to clk_bulk_data array + * + * This function frees the array allocated by clk_bulk_data. It must be called + * when all clks are freed. + */ +static inline void clk_bulk_free(struct clk_bulk_data *clks) +{ + kfree(clks); +} + /** * clk_get - lookup and obtain a reference to a clock producer. * @dev: device for clock "consumer" @@ -598,6 +645,23 @@ struct clk *clk_get_sys(const char *dev_id, const char *con_id); #else /* !CONFIG_HAVE_CLK */ +static inline struct clk_bulk_data *clk_bulk_alloc(int num_clks, + const char **clk_ids) +{ + return NULL; +} + +static inline struct clk_bulk_data *devm_clk_bulk_alloc(struct device *dev, + int num_clks, + const char **clk_ids) +{ + return NULL; +} + +static inline void clk_bulk_free(struct clk_bulk_data *clks) +{ +} + static inline struct clk *clk_get(struct device *dev, const char *id) { return NULL; -- 2.7.4