lkml.org 
[lkml]   [2017]   [Aug]   [31]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH v2 15/18] clk: add support for clocks provided by SCMI
On 08/04, Sudeep Holla wrote:
> diff --git a/drivers/clk/clk-scmi.c b/drivers/clk/clk-scmi.c
> new file mode 100644
> index 000000000000..37f98a6439a0
> --- /dev/null
> +++ b/drivers/clk/clk-scmi.c
> @@ -0,0 +1,216 @@
> +/*
> + * System Control and Power Interface (SCMI) Protocol based clock driver
> + *
> + * Copyright (C) 2017 ARM Ltd.
> + *
> + * This program is free software; you can redistribute it and/or modify it
> + * under the terms and conditions of the GNU General Public License,
> + * version 2, as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope it will be useful, but WITHOUT
> + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
> + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
> + * more details.
> + *
> + * You should have received a copy of the GNU General Public License along with
> + * this program. If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <linux/clk-provider.h>
> +#include <linux/device.h>
> +#include <linux/err.h>
> +#include <linux/of.h>
> +#include <linux/module.h>
> +#include <linux/of_platform.h>

Is this include used?

> +#include <linux/platform_device.h>
> +#include <linux/scmi_protocol.h>
> +
> +struct scmi_clk {
> + u32 id;
> + struct clk_hw hw;
> + const struct scmi_clock_info *info;
> + const struct scmi_handle *handle;
> +};
> +
> +#define to_scmi_clk(clk) container_of(clk, struct scmi_clk, hw)
> +
> +static unsigned long scmi_clk_recalc_rate(struct clk_hw *hw,
> + unsigned long parent_rate)
> +{
> + int ret;
> + u64 rate;
> + struct scmi_clk *clk = to_scmi_clk(hw);
> +
> + ret = clk->handle->clk_ops->rate_get(clk->handle, clk->id, &rate);
> + if (ret)
> + return 0;
> + return rate;
> +}
> +
> +static long scmi_clk_round_rate(struct clk_hw *hw, unsigned long rate,
> + unsigned long *parent_rate)
> +{
> + u64 fmin, fmax, ftmp;
> + struct scmi_clk *clk = to_scmi_clk(hw);
> +
> + /*
> + * We can't figure out what rate it will be, so just return the
> + * rate back to the caller. scmi_clk_recalc_rate() will be called
> + * after the rate is set and we'll know what rate the clock is
> + * running at then.
> + */
> + if (clk->info->rate_discrete)
> + return rate;
> +
> + fmin = clk->info->range.min_rate;
> + fmax = clk->info->range.max_rate;
> + for (ftmp = fmin; ftmp <= fmax; ftmp += clk->info->range.step_size) {
> + if (ftmp >= rate) {
> + if (ftmp <= fmax)
> + fmax = ftmp;
> + break;
> + } else if (ftmp >= fmin) {
> + fmin = ftmp;
> + }
> + }

Are the max_rate and min_rate potentially unaligned with the
step_size? Do any of these things change at runtime? It seems
like we could do some simple math instead of this for loop unless
I missed something.

> + return fmax != clk->info->range.max_rate ? fmax : fmin;
> +}
> +
> +static int scmi_clk_set_rate(struct clk_hw *hw, unsigned long rate,
> + unsigned long parent_rate)
> +{
> + struct scmi_clk *clk = to_scmi_clk(hw);
> +
> + return clk->handle->clk_ops->rate_set(clk->handle, clk->id, 0, rate);
> +}
> +
> +static int scmi_clk_enable(struct clk_hw *hw)
> +{
> + struct scmi_clk *clk = to_scmi_clk(hw);
> +
> + return clk->handle->clk_ops->enable(clk->handle, clk->id);
> +}
> +
> +static void scmi_clk_disable(struct clk_hw *hw)
> +{
> + struct scmi_clk *clk = to_scmi_clk(hw);
> +
> + clk->handle->clk_ops->disable(clk->handle, clk->id);
> +}
> +
> +static const struct clk_ops scmi_clk_ops = {
> + .recalc_rate = scmi_clk_recalc_rate,
> + .round_rate = scmi_clk_round_rate,
> + .set_rate = scmi_clk_set_rate,
> + /*
> + * We can't provide enable/disable callback as we can't perform the same
> + * in atomic context. Since the clock framework provides standard API
> + * clk_prepare_enable that helps cases using clk_enable in non-atomic
> + * context, it should be fine providing prepare/unprepare.
> + */
> + .prepare = scmi_clk_enable,
> + .unprepare = scmi_clk_disable,
> +};
> +
> +static int scmi_clk_ops_init(struct device *dev, struct scmi_clk *sclk)
> +{
> + int ret;
> + struct clk_init_data init;

Best to do = { } here in case we add something else to the init
structure in future.

> +
> + init.flags = CLK_GET_RATE_NOCACHE;
> + init.num_parents = 0;
> + init.ops = &scmi_clk_ops;
> + init.name = sclk->info->name;
> + sclk->hw.init = &init;
> +
> + ret = devm_clk_hw_register(dev, &sclk->hw);
> + if (!ret)
> + clk_hw_set_rate_range(&sclk->hw, sclk->info->range.min_rate,
> + sclk->info->range.max_rate);
> + return ret;
> +}
> +
> +static int scmi_clk_add(struct device *dev, struct device_node *np,
> + const struct scmi_handle *handle)
> +{
> + int idx, count, err;
> + struct clk_hw **hws;
> + struct clk_hw_onecell_data *clk_data;
> +
> + count = handle->clk_ops->count_get(handle);
> + if (count < 0) {
> + dev_err(dev, "%s: invalid clock output count\n", np->name);
> + return -EINVAL;
> + }
> +
> + clk_data = devm_kzalloc(dev, sizeof(*clk_data) +
> + sizeof(*clk_data->hws) * count, GFP_KERNEL);
> + if (!clk_data)
> + return -ENOMEM;
> +
> + clk_data->num = count;
> + hws = clk_data->hws;
> +
> + for (idx = 0; idx < count; idx++) {
> + struct scmi_clk *sclk;
> +
> + sclk = devm_kzalloc(dev, sizeof(*sclk), GFP_KERNEL);
> + if (!sclk)
> + return -ENOMEM;
> +
> + sclk->info = handle->clk_ops->info_get(handle, idx);
> + if (!sclk->info) {
> + dev_dbg(dev, "invalid clock info for idx %d\n", idx);
> + continue;
> + }
> +
> + sclk->id = idx;
> + sclk->handle = handle;
> +
> + err = scmi_clk_ops_init(dev, sclk);
> + if (err) {
> + dev_err(dev, "failed to register clock %d\n", idx);
> + devm_kfree(dev, sclk);
> + hws[idx] = NULL;
> + } else {
> + dev_dbg(dev, "Registered clock:%s\n", sclk->info->name);
> + hws[idx] = &sclk->hw;
> + }
> + }
> +
> + return of_clk_add_hw_provider(np, of_clk_hw_onecell_get, clk_data);
> +}
> +
> +static int scmi_clocks_remove(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct device_node *np = dev->of_node;
> +
> + of_clk_del_provider(np);
> + return 0;
> +}
> +
> +static int scmi_clocks_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct device_node *np = dev->of_node;
> + const struct scmi_handle *handle = devm_scmi_handle_get(dev);
> +
> + if (IS_ERR_OR_NULL(handle) || !handle->clk_ops)
> + return -EPROBE_DEFER;
> +
> + return scmi_clk_add(dev, np, handle);

Why the function? We support more than just platform devices?
Just fold scmi_clk_add() into this function instead please.

> +}
> +
> +static struct platform_driver scmi_clocks_driver = {
> + .driver = {
> + .name = "scmi-clocks",
> + },
> + .probe = scmi_clocks_probe,
> + .remove = scmi_clocks_remove,
> +};
> +module_platform_driver(scmi_clocks_driver);
> +
> +MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
> +MODULE_DESCRIPTION("ARM SCMI clock driver");
> +MODULE_LICENSE("GPL v2");
> --
> 2.7.4
>

--
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project

\
 
 \ /
  Last update: 2017-09-01 02:19    [W:0.234 / U:8.484 seconds]
©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site