1 From d79cb0c583772f38a9367af106d61bcf8bfa08e4 Mon Sep 17 00:00:00 2001
2 From: Stephen Boyd <sboyd@codeaurora.org>
3 Date: Fri, 21 Mar 2014 17:59:37 -0700
4 Subject: [PATCH 078/182] clk: qcom: Consolidate common probe code
6 Most of the probe code is the same between all the different
7 clock controllers. Consolidate the code into a common.c file.
8 This makes changes to the common probe parts easier and reduces
11 Signed-off-by: Stephen Boyd <sboyd@codeaurora.org>
12 Signed-off-by: Kumar Gala <galak@codeaurora.org>
14 drivers/clk/qcom/Makefile | 1 +
15 drivers/clk/qcom/common.c | 99 +++++++++++++++++++++++++++++++++++++++
16 drivers/clk/qcom/common.h | 34 ++++++++++++++
17 drivers/clk/qcom/gcc-msm8660.c | 87 +++++-----------------------------
18 drivers/clk/qcom/gcc-msm8960.c | 77 +++++-------------------------
19 drivers/clk/qcom/gcc-msm8974.c | 77 +++++-------------------------
20 drivers/clk/qcom/mmcc-msm8960.c | 78 +++++-------------------------
21 drivers/clk/qcom/mmcc-msm8974.c | 80 +++++++------------------------
22 8 files changed, 196 insertions(+), 337 deletions(-)
23 create mode 100644 drivers/clk/qcom/common.c
24 create mode 100644 drivers/clk/qcom/common.h
26 --- a/drivers/clk/qcom/Makefile
27 +++ b/drivers/clk/qcom/Makefile
29 obj-$(CONFIG_COMMON_CLK_QCOM) += clk-qcom.o
31 +clk-qcom-y += common.o
32 clk-qcom-y += clk-regmap.o
33 clk-qcom-y += clk-pll.o
34 clk-qcom-y += clk-rcg.o
36 +++ b/drivers/clk/qcom/common.c
39 + * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
41 + * This software is licensed under the terms of the GNU General Public
42 + * License version 2, as published by the Free Software Foundation, and
43 + * may be copied, distributed, and modified under those terms.
45 + * This program is distributed in the hope that it will be useful,
46 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
47 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
48 + * GNU General Public License for more details.
51 +#include <linux/export.h>
52 +#include <linux/regmap.h>
53 +#include <linux/platform_device.h>
54 +#include <linux/clk-provider.h>
55 +#include <linux/reset-controller.h>
58 +#include "clk-regmap.h"
62 + struct qcom_reset_controller reset;
63 + struct clk_onecell_data data;
67 +int qcom_cc_probe(struct platform_device *pdev, const struct qcom_cc_desc *desc)
70 + struct resource *res;
72 + struct device *dev = &pdev->dev;
74 + struct clk_onecell_data *data;
76 + struct regmap *regmap;
77 + struct qcom_reset_controller *reset;
79 + size_t num_clks = desc->num_clks;
80 + struct clk_regmap **rclks = desc->clks;
82 + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
83 + base = devm_ioremap_resource(dev, res);
85 + return PTR_ERR(base);
87 + regmap = devm_regmap_init_mmio(dev, base, desc->config);
89 + return PTR_ERR(regmap);
91 + cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
99 + data->clk_num = num_clks;
101 + for (i = 0; i < num_clks; i++) {
104 + clk = devm_clk_register_regmap(dev, rclks[i]);
106 + return PTR_ERR(clk);
110 + ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
114 + reset = &cc->reset;
115 + reset->rcdev.of_node = dev->of_node;
116 + reset->rcdev.ops = &qcom_reset_ops;
117 + reset->rcdev.owner = dev->driver->owner;
118 + reset->rcdev.nr_resets = desc->num_resets;
119 + reset->regmap = regmap;
120 + reset->reset_map = desc->resets;
121 + platform_set_drvdata(pdev, &reset->rcdev);
123 + ret = reset_controller_register(&reset->rcdev);
125 + of_clk_del_provider(dev->of_node);
129 +EXPORT_SYMBOL_GPL(qcom_cc_probe);
131 +void qcom_cc_remove(struct platform_device *pdev)
133 + of_clk_del_provider(pdev->dev.of_node);
134 + reset_controller_unregister(platform_get_drvdata(pdev));
136 +EXPORT_SYMBOL_GPL(qcom_cc_remove);
138 +++ b/drivers/clk/qcom/common.h
141 + * Copyright (c) 2014, The Linux Foundation. All rights reserved.
143 + * This software is licensed under the terms of the GNU General Public
144 + * License version 2, as published by the Free Software Foundation, and
145 + * may be copied, distributed, and modified under those terms.
147 + * This program is distributed in the hope that it will be useful,
148 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
149 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
150 + * GNU General Public License for more details.
152 +#ifndef __QCOM_CLK_COMMON_H__
153 +#define __QCOM_CLK_COMMON_H__
155 +struct platform_device;
156 +struct regmap_config;
158 +struct qcom_reset_map;
160 +struct qcom_cc_desc {
161 + const struct regmap_config *config;
162 + struct clk_regmap **clks;
164 + const struct qcom_reset_map *resets;
168 +extern int qcom_cc_probe(struct platform_device *pdev,
169 + const struct qcom_cc_desc *desc);
171 +extern void qcom_cc_remove(struct platform_device *pdev);
174 --- a/drivers/clk/qcom/gcc-msm8660.c
175 +++ b/drivers/clk/qcom/gcc-msm8660.c
177 #include <dt-bindings/clock/qcom,gcc-msm8660.h>
178 #include <dt-bindings/reset/qcom,gcc-msm8660.h>
181 #include "clk-regmap.h"
184 @@ -2701,94 +2702,28 @@ static const struct regmap_config gcc_ms
188 +static const struct qcom_cc_desc gcc_msm8660_desc = {
189 + .config = &gcc_msm8660_regmap_config,
190 + .clks = gcc_msm8660_clks,
191 + .num_clks = ARRAY_SIZE(gcc_msm8660_clks),
192 + .resets = gcc_msm8660_resets,
193 + .num_resets = ARRAY_SIZE(gcc_msm8660_resets),
196 static const struct of_device_id gcc_msm8660_match_table[] = {
197 { .compatible = "qcom,gcc-msm8660" },
200 MODULE_DEVICE_TABLE(of, gcc_msm8660_match_table);
203 - struct qcom_reset_controller reset;
204 - struct clk_onecell_data data;
205 - struct clk *clks[];
208 static int gcc_msm8660_probe(struct platform_device *pdev)
210 - void __iomem *base;
211 - struct resource *res;
213 - struct device *dev = &pdev->dev;
215 - struct clk_onecell_data *data;
217 - struct regmap *regmap;
219 - struct qcom_reset_controller *reset;
220 - struct qcom_cc *cc;
222 - res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
223 - base = devm_ioremap_resource(dev, res);
225 - return PTR_ERR(base);
227 - regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8660_regmap_config);
228 - if (IS_ERR(regmap))
229 - return PTR_ERR(regmap);
231 - num_clks = ARRAY_SIZE(gcc_msm8660_clks);
232 - cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
240 - data->clk_num = num_clks;
242 - /* Temporary until RPM clocks supported */
243 - clk = clk_register_fixed_rate(dev, "cxo", NULL, CLK_IS_ROOT, 19200000);
245 - return PTR_ERR(clk);
247 - clk = clk_register_fixed_rate(dev, "pxo", NULL, CLK_IS_ROOT, 27000000);
249 - return PTR_ERR(clk);
251 - for (i = 0; i < num_clks; i++) {
252 - if (!gcc_msm8660_clks[i])
254 - clk = devm_clk_register_regmap(dev, gcc_msm8660_clks[i]);
256 - return PTR_ERR(clk);
260 - ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
264 - reset = &cc->reset;
265 - reset->rcdev.of_node = dev->of_node;
266 - reset->rcdev.ops = &qcom_reset_ops,
267 - reset->rcdev.owner = THIS_MODULE,
268 - reset->rcdev.nr_resets = ARRAY_SIZE(gcc_msm8660_resets),
269 - reset->regmap = regmap;
270 - reset->reset_map = gcc_msm8660_resets,
271 - platform_set_drvdata(pdev, &reset->rcdev);
273 - ret = reset_controller_register(&reset->rcdev);
275 - of_clk_del_provider(dev->of_node);
278 + return qcom_cc_probe(pdev, &gcc_msm8660_desc);
281 static int gcc_msm8660_remove(struct platform_device *pdev)
283 - of_clk_del_provider(pdev->dev.of_node);
284 - reset_controller_unregister(platform_get_drvdata(pdev));
285 + qcom_cc_remove(pdev);
289 --- a/drivers/clk/qcom/gcc-msm8960.c
290 +++ b/drivers/clk/qcom/gcc-msm8960.c
292 #include <dt-bindings/clock/qcom,gcc-msm8960.h>
293 #include <dt-bindings/reset/qcom,gcc-msm8960.h>
296 #include "clk-regmap.h"
299 @@ -2875,51 +2876,24 @@ static const struct regmap_config gcc_ms
303 +static const struct qcom_cc_desc gcc_msm8960_desc = {
304 + .config = &gcc_msm8960_regmap_config,
305 + .clks = gcc_msm8960_clks,
306 + .num_clks = ARRAY_SIZE(gcc_msm8960_clks),
307 + .resets = gcc_msm8960_resets,
308 + .num_resets = ARRAY_SIZE(gcc_msm8960_resets),
311 static const struct of_device_id gcc_msm8960_match_table[] = {
312 { .compatible = "qcom,gcc-msm8960" },
315 MODULE_DEVICE_TABLE(of, gcc_msm8960_match_table);
318 - struct qcom_reset_controller reset;
319 - struct clk_onecell_data data;
320 - struct clk *clks[];
323 static int gcc_msm8960_probe(struct platform_device *pdev)
325 - void __iomem *base;
326 - struct resource *res;
328 - struct device *dev = &pdev->dev;
330 - struct clk_onecell_data *data;
332 - struct regmap *regmap;
334 - struct qcom_reset_controller *reset;
335 - struct qcom_cc *cc;
337 - res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
338 - base = devm_ioremap_resource(dev, res);
340 - return PTR_ERR(base);
342 - regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8960_regmap_config);
343 - if (IS_ERR(regmap))
344 - return PTR_ERR(regmap);
346 - num_clks = ARRAY_SIZE(gcc_msm8960_clks);
347 - cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
355 - data->clk_num = num_clks;
356 + struct device *dev = &pdev->dev;
358 /* Temporary until RPM clocks supported */
359 clk = clk_register_fixed_rate(dev, "cxo", NULL, CLK_IS_ROOT, 19200000);
360 @@ -2930,39 +2904,12 @@ static int gcc_msm8960_probe(struct plat
364 - for (i = 0; i < num_clks; i++) {
365 - if (!gcc_msm8960_clks[i])
367 - clk = devm_clk_register_regmap(dev, gcc_msm8960_clks[i]);
369 - return PTR_ERR(clk);
373 - ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
377 - reset = &cc->reset;
378 - reset->rcdev.of_node = dev->of_node;
379 - reset->rcdev.ops = &qcom_reset_ops,
380 - reset->rcdev.owner = THIS_MODULE,
381 - reset->rcdev.nr_resets = ARRAY_SIZE(gcc_msm8960_resets),
382 - reset->regmap = regmap;
383 - reset->reset_map = gcc_msm8960_resets,
384 - platform_set_drvdata(pdev, &reset->rcdev);
386 - ret = reset_controller_register(&reset->rcdev);
388 - of_clk_del_provider(dev->of_node);
391 + return qcom_cc_probe(pdev, &gcc_msm8960_desc);
394 static int gcc_msm8960_remove(struct platform_device *pdev)
396 - of_clk_del_provider(pdev->dev.of_node);
397 - reset_controller_unregister(platform_get_drvdata(pdev));
398 + qcom_cc_remove(pdev);
402 --- a/drivers/clk/qcom/gcc-msm8974.c
403 +++ b/drivers/clk/qcom/gcc-msm8974.c
405 #include <dt-bindings/clock/qcom,gcc-msm8974.h>
406 #include <dt-bindings/reset/qcom,gcc-msm8974.h>
409 #include "clk-regmap.h"
412 @@ -2574,51 +2575,24 @@ static const struct regmap_config gcc_ms
416 +static const struct qcom_cc_desc gcc_msm8974_desc = {
417 + .config = &gcc_msm8974_regmap_config,
418 + .clks = gcc_msm8974_clocks,
419 + .num_clks = ARRAY_SIZE(gcc_msm8974_clocks),
420 + .resets = gcc_msm8974_resets,
421 + .num_resets = ARRAY_SIZE(gcc_msm8974_resets),
424 static const struct of_device_id gcc_msm8974_match_table[] = {
425 { .compatible = "qcom,gcc-msm8974" },
428 MODULE_DEVICE_TABLE(of, gcc_msm8974_match_table);
431 - struct qcom_reset_controller reset;
432 - struct clk_onecell_data data;
433 - struct clk *clks[];
436 static int gcc_msm8974_probe(struct platform_device *pdev)
438 - void __iomem *base;
439 - struct resource *res;
441 - struct device *dev = &pdev->dev;
443 - struct clk_onecell_data *data;
445 - struct regmap *regmap;
447 - struct qcom_reset_controller *reset;
448 - struct qcom_cc *cc;
450 - res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
451 - base = devm_ioremap_resource(dev, res);
453 - return PTR_ERR(base);
455 - regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8974_regmap_config);
456 - if (IS_ERR(regmap))
457 - return PTR_ERR(regmap);
459 - num_clks = ARRAY_SIZE(gcc_msm8974_clocks);
460 - cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
468 - data->clk_num = num_clks;
469 + struct device *dev = &pdev->dev;
471 /* Temporary until RPM clocks supported */
472 clk = clk_register_fixed_rate(dev, "xo", NULL, CLK_IS_ROOT, 19200000);
473 @@ -2631,39 +2605,12 @@ static int gcc_msm8974_probe(struct plat
477 - for (i = 0; i < num_clks; i++) {
478 - if (!gcc_msm8974_clocks[i])
480 - clk = devm_clk_register_regmap(dev, gcc_msm8974_clocks[i]);
482 - return PTR_ERR(clk);
486 - ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
490 - reset = &cc->reset;
491 - reset->rcdev.of_node = dev->of_node;
492 - reset->rcdev.ops = &qcom_reset_ops,
493 - reset->rcdev.owner = THIS_MODULE,
494 - reset->rcdev.nr_resets = ARRAY_SIZE(gcc_msm8974_resets),
495 - reset->regmap = regmap;
496 - reset->reset_map = gcc_msm8974_resets,
497 - platform_set_drvdata(pdev, &reset->rcdev);
499 - ret = reset_controller_register(&reset->rcdev);
501 - of_clk_del_provider(dev->of_node);
504 + return qcom_cc_probe(pdev, &gcc_msm8974_desc);
507 static int gcc_msm8974_remove(struct platform_device *pdev)
509 - of_clk_del_provider(pdev->dev.of_node);
510 - reset_controller_unregister(platform_get_drvdata(pdev));
511 + qcom_cc_remove(pdev);
515 --- a/drivers/clk/qcom/mmcc-msm8960.c
516 +++ b/drivers/clk/qcom/mmcc-msm8960.c
518 #include <dt-bindings/clock/qcom,mmcc-msm8960.h>
519 #include <dt-bindings/reset/qcom,mmcc-msm8960.h>
522 #include "clk-regmap.h"
525 @@ -2224,85 +2225,28 @@ static const struct regmap_config mmcc_m
529 +static const struct qcom_cc_desc mmcc_msm8960_desc = {
530 + .config = &mmcc_msm8960_regmap_config,
531 + .clks = mmcc_msm8960_clks,
532 + .num_clks = ARRAY_SIZE(mmcc_msm8960_clks),
533 + .resets = mmcc_msm8960_resets,
534 + .num_resets = ARRAY_SIZE(mmcc_msm8960_resets),
537 static const struct of_device_id mmcc_msm8960_match_table[] = {
538 { .compatible = "qcom,mmcc-msm8960" },
541 MODULE_DEVICE_TABLE(of, mmcc_msm8960_match_table);
544 - struct qcom_reset_controller reset;
545 - struct clk_onecell_data data;
546 - struct clk *clks[];
549 static int mmcc_msm8960_probe(struct platform_device *pdev)
551 - void __iomem *base;
552 - struct resource *res;
554 - struct device *dev = &pdev->dev;
556 - struct clk_onecell_data *data;
558 - struct regmap *regmap;
560 - struct qcom_reset_controller *reset;
561 - struct qcom_cc *cc;
563 - res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
564 - base = devm_ioremap_resource(dev, res);
566 - return PTR_ERR(base);
568 - regmap = devm_regmap_init_mmio(dev, base, &mmcc_msm8960_regmap_config);
569 - if (IS_ERR(regmap))
570 - return PTR_ERR(regmap);
572 - num_clks = ARRAY_SIZE(mmcc_msm8960_clks);
573 - cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
581 - data->clk_num = num_clks;
583 - for (i = 0; i < num_clks; i++) {
584 - if (!mmcc_msm8960_clks[i])
586 - clk = devm_clk_register_regmap(dev, mmcc_msm8960_clks[i]);
588 - return PTR_ERR(clk);
592 - ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
596 - reset = &cc->reset;
597 - reset->rcdev.of_node = dev->of_node;
598 - reset->rcdev.ops = &qcom_reset_ops,
599 - reset->rcdev.owner = THIS_MODULE,
600 - reset->rcdev.nr_resets = ARRAY_SIZE(mmcc_msm8960_resets),
601 - reset->regmap = regmap;
602 - reset->reset_map = mmcc_msm8960_resets,
603 - platform_set_drvdata(pdev, &reset->rcdev);
605 - ret = reset_controller_register(&reset->rcdev);
607 - of_clk_del_provider(dev->of_node);
610 + return qcom_cc_probe(pdev, &mmcc_msm8960_desc);
613 static int mmcc_msm8960_remove(struct platform_device *pdev)
615 - of_clk_del_provider(pdev->dev.of_node);
616 - reset_controller_unregister(platform_get_drvdata(pdev));
617 + qcom_cc_remove(pdev);
621 --- a/drivers/clk/qcom/mmcc-msm8974.c
622 +++ b/drivers/clk/qcom/mmcc-msm8974.c
624 #include <dt-bindings/clock/qcom,mmcc-msm8974.h>
625 #include <dt-bindings/reset/qcom,mmcc-msm8974.h>
628 #include "clk-regmap.h"
631 @@ -2527,88 +2528,39 @@ static const struct regmap_config mmcc_m
635 +static const struct qcom_cc_desc mmcc_msm8974_desc = {
636 + .config = &mmcc_msm8974_regmap_config,
637 + .clks = mmcc_msm8974_clocks,
638 + .num_clks = ARRAY_SIZE(mmcc_msm8974_clocks),
639 + .resets = mmcc_msm8974_resets,
640 + .num_resets = ARRAY_SIZE(mmcc_msm8974_resets),
643 static const struct of_device_id mmcc_msm8974_match_table[] = {
644 { .compatible = "qcom,mmcc-msm8974" },
647 MODULE_DEVICE_TABLE(of, mmcc_msm8974_match_table);
650 - struct qcom_reset_controller reset;
651 - struct clk_onecell_data data;
652 - struct clk *clks[];
655 static int mmcc_msm8974_probe(struct platform_device *pdev)
657 - void __iomem *base;
658 - struct resource *res;
660 - struct device *dev = &pdev->dev;
662 - struct clk_onecell_data *data;
665 struct regmap *regmap;
667 - struct qcom_reset_controller *reset;
668 - struct qcom_cc *cc;
670 - res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
671 - base = devm_ioremap_resource(dev, res);
673 - return PTR_ERR(base);
675 - regmap = devm_regmap_init_mmio(dev, base, &mmcc_msm8974_regmap_config);
676 - if (IS_ERR(regmap))
677 - return PTR_ERR(regmap);
679 - num_clks = ARRAY_SIZE(mmcc_msm8974_clocks);
680 - cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
688 - data->clk_num = num_clks;
690 - clk_pll_configure_sr_hpm_lp(&mmpll1, regmap, &mmpll1_config, true);
691 - clk_pll_configure_sr_hpm_lp(&mmpll3, regmap, &mmpll3_config, false);
693 - for (i = 0; i < num_clks; i++) {
694 - if (!mmcc_msm8974_clocks[i])
696 - clk = devm_clk_register_regmap(dev, mmcc_msm8974_clocks[i]);
698 - return PTR_ERR(clk);
702 - ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
703 + ret = qcom_cc_probe(pdev, &mmcc_msm8974_desc);
707 - reset = &cc->reset;
708 - reset->rcdev.of_node = dev->of_node;
709 - reset->rcdev.ops = &qcom_reset_ops,
710 - reset->rcdev.owner = THIS_MODULE,
711 - reset->rcdev.nr_resets = ARRAY_SIZE(mmcc_msm8974_resets),
712 - reset->regmap = regmap;
713 - reset->reset_map = mmcc_msm8974_resets,
714 - platform_set_drvdata(pdev, &reset->rcdev);
716 - ret = reset_controller_register(&reset->rcdev);
718 - of_clk_del_provider(dev->of_node);
719 + regmap = dev_get_regmap(&pdev->dev, NULL);
720 + clk_pll_configure_sr_hpm_lp(&mmpll1, regmap, &mmpll1_config, true);
721 + clk_pll_configure_sr_hpm_lp(&mmpll3, regmap, &mmpll3_config, false);
727 static int mmcc_msm8974_remove(struct platform_device *pdev)
729 - of_clk_del_provider(pdev->dev.of_node);
730 - reset_controller_unregister(platform_get_drvdata(pdev));
731 + qcom_cc_remove(pdev);