target/linux/ipq806x/patches/0078-clk-qcom-Consolidate-common-probe-code.patch

   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
   5
   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
   9 chances for bugs.
  10
  11 Signed-off-by: Stephen Boyd <sboyd@codeaurora.org>
  12 Signed-off-by: Kumar Gala <galak@codeaurora.org>
  13 ---
  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
  25
  26 diff --git a/drivers/clk/qcom/Makefile b/drivers/clk/qcom/Makefile
  27 index f60db2e..689e05b 100644
  28 --- a/drivers/clk/qcom/Makefile
  29 +++ b/drivers/clk/qcom/Makefile
  30 @@ -1,5 +1,6 @@
  31  obj-$(CONFIG_COMMON_CLK_QCOM) += clk-qcom.o
  32
  33 +clk-qcom-y += common.o
  34  clk-qcom-y += clk-regmap.o
  35  clk-qcom-y += clk-pll.o
  36  clk-qcom-y += clk-rcg.o
  37 diff --git a/drivers/clk/qcom/common.c b/drivers/clk/qcom/common.c
  38 new file mode 100644
  39 index 0000000..86b45fb
  40 --- /dev/null
  41 +++ b/drivers/clk/qcom/common.c
  42 @@ -0,0 +1,99 @@
  43 +/*
  44 + * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
  45 + *
  46 + * This software is licensed under the terms of the GNU General Public
  47 + * License version 2, as published by the Free Software Foundation, and
  48 + * may be copied, distributed, and modified under those terms.
  49 + *
  50 + * This program is distributed in the hope that it will be useful,
  51 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  52 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  53 + * GNU General Public License for more details.
  54 + */
  55 +
  56 +#include <linux/export.h>
  57 +#include <linux/regmap.h>
  58 +#include <linux/platform_device.h>
  59 +#include <linux/clk-provider.h>
  60 +#include <linux/reset-controller.h>
  61 +
  62 +#include "common.h"
  63 +#include "clk-regmap.h"
  64 +#include "reset.h"
  65 +
  66 +struct qcom_cc {
  67 +       struct qcom_reset_controller reset;
  68 +       struct clk_onecell_data data;
  69 +       struct clk *clks[];
  70 +};
  71 +
  72 +int qcom_cc_probe(struct platform_device *pdev, const struct qcom_cc_desc *desc)
  73 +{
  74 +       void __iomem *base;
  75 +       struct resource *res;
  76 +       int i, ret;
  77 +       struct device *dev = &pdev->dev;
  78 +       struct clk *clk;
  79 +       struct clk_onecell_data *data;
  80 +       struct clk **clks;
  81 +       struct regmap *regmap;
  82 +       struct qcom_reset_controller *reset;
  83 +       struct qcom_cc *cc;
  84 +       size_t num_clks = desc->num_clks;
  85 +       struct clk_regmap **rclks = desc->clks;
  86 +
  87 +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  88 +       base = devm_ioremap_resource(dev, res);
  89 +       if (IS_ERR(base))
  90 +               return PTR_ERR(base);
  91 +
  92 +       regmap = devm_regmap_init_mmio(dev, base, desc->config);
  93 +       if (IS_ERR(regmap))
  94 +               return PTR_ERR(regmap);
  95 +
  96 +       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
  97 +                         GFP_KERNEL);
  98 +       if (!cc)
  99 +               return -ENOMEM;
 100 +
 101 +       clks = cc->clks;
 102 +       data = &cc->data;
 103 +       data->clks = clks;
 104 +       data->clk_num = num_clks;
 105 +
 106 +       for (i = 0; i < num_clks; i++) {
 107 +               if (!rclks[i])
 108 +                       continue;
 109 +               clk = devm_clk_register_regmap(dev, rclks[i]);
 110 +               if (IS_ERR(clk))
 111 +                       return PTR_ERR(clk);
 112 +               clks[i] = clk;
 113 +       }
 114 +
 115 +       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 116 +       if (ret)
 117 +               return ret;
 118 +
 119 +       reset = &cc->reset;
 120 +       reset->rcdev.of_node = dev->of_node;
 121 +       reset->rcdev.ops = &qcom_reset_ops;
 122 +       reset->rcdev.owner = dev->driver->owner;
 123 +       reset->rcdev.nr_resets = desc->num_resets;
 124 +       reset->regmap = regmap;
 125 +       reset->reset_map = desc->resets;
 126 +       platform_set_drvdata(pdev, &reset->rcdev);
 127 +
 128 +       ret = reset_controller_register(&reset->rcdev);
 129 +       if (ret)
 130 +               of_clk_del_provider(dev->of_node);
 131 +
 132 +       return ret;
 133 +}
 134 +EXPORT_SYMBOL_GPL(qcom_cc_probe);
 135 +
 136 +void qcom_cc_remove(struct platform_device *pdev)
 137 +{
 138 +       of_clk_del_provider(pdev->dev.of_node);
 139 +       reset_controller_unregister(platform_get_drvdata(pdev));
 140 +}
 141 +EXPORT_SYMBOL_GPL(qcom_cc_remove);
 142 diff --git a/drivers/clk/qcom/common.h b/drivers/clk/qcom/common.h
 143 new file mode 100644
 144 index 0000000..2c3cfc8
 145 --- /dev/null
 146 +++ b/drivers/clk/qcom/common.h
 147 @@ -0,0 +1,34 @@
 148 +/*
 149 + * Copyright (c) 2014, The Linux Foundation. All rights reserved.
 150 + *
 151 + * This software is licensed under the terms of the GNU General Public
 152 + * License version 2, as published by the Free Software Foundation, and
 153 + * may be copied, distributed, and modified under those terms.
 154 + *
 155 + * This program is distributed in the hope that it will be useful,
 156 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 157 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 158 + * GNU General Public License for more details.
 159 + */
 160 +#ifndef __QCOM_CLK_COMMON_H__
 161 +#define __QCOM_CLK_COMMON_H__
 162 +
 163 +struct platform_device;
 164 +struct regmap_config;
 165 +struct clk_regmap;
 166 +struct qcom_reset_map;
 167 +
 168 +struct qcom_cc_desc {
 169 +       const struct regmap_config *config;
 170 +       struct clk_regmap **clks;
 171 +       size_t num_clks;
 172 +       const struct qcom_reset_map *resets;
 173 +       size_t num_resets;
 174 +};
 175 +
 176 +extern int qcom_cc_probe(struct platform_device *pdev,
 177 +                        const struct qcom_cc_desc *desc);
 178 +
 179 +extern void qcom_cc_remove(struct platform_device *pdev);
 180 +
 181 +#endif
 182 diff --git a/drivers/clk/qcom/gcc-msm8660.c b/drivers/clk/qcom/gcc-msm8660.c
 183 index bc0b7f1..44bc6fa 100644
 184 --- a/drivers/clk/qcom/gcc-msm8660.c
 185 +++ b/drivers/clk/qcom/gcc-msm8660.c
 186 @@ -25,6 +25,7 @@
 187  #include <dt-bindings/clock/qcom,gcc-msm8660.h>
 188  #include <dt-bindings/reset/qcom,gcc-msm8660.h>
 189
 190 +#include "common.h"
 191  #include "clk-regmap.h"
 192  #include "clk-pll.h"
 193  #include "clk-rcg.h"
 194 @@ -2701,94 +2702,28 @@ static const struct regmap_config gcc_msm8660_regmap_config = {
 195         .fast_io        = true,
 196  };
 197
 198 +static const struct qcom_cc_desc gcc_msm8660_desc = {
 199 +       .config = &gcc_msm8660_regmap_config,
 200 +       .clks = gcc_msm8660_clks,
 201 +       .num_clks = ARRAY_SIZE(gcc_msm8660_clks),
 202 +       .resets = gcc_msm8660_resets,
 203 +       .num_resets = ARRAY_SIZE(gcc_msm8660_resets),
 204 +};
 205 +
 206  static const struct of_device_id gcc_msm8660_match_table[] = {
 207         { .compatible = "qcom,gcc-msm8660" },
 208         { }
 209  };
 210  MODULE_DEVICE_TABLE(of, gcc_msm8660_match_table);
 211
 212 -struct qcom_cc {
 213 -       struct qcom_reset_controller reset;
 214 -       struct clk_onecell_data data;
 215 -       struct clk *clks[];
 216 -};
 217 -
 218  static int gcc_msm8660_probe(struct platform_device *pdev)
 219  {
 220 -       void __iomem *base;
 221 -       struct resource *res;
 222 -       int i, ret;
 223 -       struct device *dev = &pdev->dev;
 224 -       struct clk *clk;
 225 -       struct clk_onecell_data *data;
 226 -       struct clk **clks;
 227 -       struct regmap *regmap;
 228 -       size_t num_clks;
 229 -       struct qcom_reset_controller *reset;
 230 -       struct qcom_cc *cc;
 231 -
 232 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 233 -       base = devm_ioremap_resource(dev, res);
 234 -       if (IS_ERR(base))
 235 -               return PTR_ERR(base);
 236 -
 237 -       regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8660_regmap_config);
 238 -       if (IS_ERR(regmap))
 239 -               return PTR_ERR(regmap);
 240 -
 241 -       num_clks = ARRAY_SIZE(gcc_msm8660_clks);
 242 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 243 -                         GFP_KERNEL);
 244 -       if (!cc)
 245 -               return -ENOMEM;
 246 -
 247 -       clks = cc->clks;
 248 -       data = &cc->data;
 249 -       data->clks = clks;
 250 -       data->clk_num = num_clks;
 251 -
 252 -       /* Temporary until RPM clocks supported */
 253 -       clk = clk_register_fixed_rate(dev, "cxo", NULL, CLK_IS_ROOT, 19200000);
 254 -       if (IS_ERR(clk))
 255 -               return PTR_ERR(clk);
 256 -
 257 -       clk = clk_register_fixed_rate(dev, "pxo", NULL, CLK_IS_ROOT, 27000000);
 258 -       if (IS_ERR(clk))
 259 -               return PTR_ERR(clk);
 260 -
 261 -       for (i = 0; i < num_clks; i++) {
 262 -               if (!gcc_msm8660_clks[i])
 263 -                       continue;
 264 -               clk = devm_clk_register_regmap(dev, gcc_msm8660_clks[i]);
 265 -               if (IS_ERR(clk))
 266 -                       return PTR_ERR(clk);
 267 -               clks[i] = clk;
 268 -       }
 269 -
 270 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 271 -       if (ret)
 272 -               return ret;
 273 -
 274 -       reset = &cc->reset;
 275 -       reset->rcdev.of_node = dev->of_node;
 276 -       reset->rcdev.ops = &qcom_reset_ops,
 277 -       reset->rcdev.owner = THIS_MODULE,
 278 -       reset->rcdev.nr_resets = ARRAY_SIZE(gcc_msm8660_resets),
 279 -       reset->regmap = regmap;
 280 -       reset->reset_map = gcc_msm8660_resets,
 281 -       platform_set_drvdata(pdev, &reset->rcdev);
 282 -
 283 -       ret = reset_controller_register(&reset->rcdev);
 284 -       if (ret)
 285 -               of_clk_del_provider(dev->of_node);
 286 -
 287 -       return ret;
 288 +       return qcom_cc_probe(pdev, &gcc_msm8660_desc);
 289  }
 290
 291  static int gcc_msm8660_remove(struct platform_device *pdev)
 292  {
 293 -       of_clk_del_provider(pdev->dev.of_node);
 294 -       reset_controller_unregister(platform_get_drvdata(pdev));
 295 +       qcom_cc_remove(pdev);
 296         return 0;
 297  }
 298
 299 diff --git a/drivers/clk/qcom/gcc-msm8960.c b/drivers/clk/qcom/gcc-msm8960.c
 300 index fd446ab..633b019 100644
 301 --- a/drivers/clk/qcom/gcc-msm8960.c
 302 +++ b/drivers/clk/qcom/gcc-msm8960.c
 303 @@ -25,6 +25,7 @@
 304  #include <dt-bindings/clock/qcom,gcc-msm8960.h>
 305  #include <dt-bindings/reset/qcom,gcc-msm8960.h>
 306
 307 +#include "common.h"
 308  #include "clk-regmap.h"
 309  #include "clk-pll.h"
 310  #include "clk-rcg.h"
 311 @@ -2875,51 +2876,24 @@ static const struct regmap_config gcc_msm8960_regmap_config = {
 312         .fast_io        = true,
 313  };
 314
 315 +static const struct qcom_cc_desc gcc_msm8960_desc = {
 316 +       .config = &gcc_msm8960_regmap_config,
 317 +       .clks = gcc_msm8960_clks,
 318 +       .num_clks = ARRAY_SIZE(gcc_msm8960_clks),
 319 +       .resets = gcc_msm8960_resets,
 320 +       .num_resets = ARRAY_SIZE(gcc_msm8960_resets),
 321 +};
 322 +
 323  static const struct of_device_id gcc_msm8960_match_table[] = {
 324         { .compatible = "qcom,gcc-msm8960" },
 325         { }
 326  };
 327  MODULE_DEVICE_TABLE(of, gcc_msm8960_match_table);
 328
 329 -struct qcom_cc {
 330 -       struct qcom_reset_controller reset;
 331 -       struct clk_onecell_data data;
 332 -       struct clk *clks[];
 333 -};
 334 -
 335  static int gcc_msm8960_probe(struct platform_device *pdev)
 336  {
 337 -       void __iomem *base;
 338 -       struct resource *res;
 339 -       int i, ret;
 340 -       struct device *dev = &pdev->dev;
 341         struct clk *clk;
 342 -       struct clk_onecell_data *data;
 343 -       struct clk **clks;
 344 -       struct regmap *regmap;
 345 -       size_t num_clks;
 346 -       struct qcom_reset_controller *reset;
 347 -       struct qcom_cc *cc;
 348 -
 349 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 350 -       base = devm_ioremap_resource(dev, res);
 351 -       if (IS_ERR(base))
 352 -               return PTR_ERR(base);
 353 -
 354 -       regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8960_regmap_config);
 355 -       if (IS_ERR(regmap))
 356 -               return PTR_ERR(regmap);
 357 -
 358 -       num_clks = ARRAY_SIZE(gcc_msm8960_clks);
 359 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 360 -                         GFP_KERNEL);
 361 -       if (!cc)
 362 -               return -ENOMEM;
 363 -
 364 -       clks = cc->clks;
 365 -       data = &cc->data;
 366 -       data->clks = clks;
 367 -       data->clk_num = num_clks;
 368 +       struct device *dev = &pdev->dev;
 369
 370         /* Temporary until RPM clocks supported */
 371         clk = clk_register_fixed_rate(dev, "cxo", NULL, CLK_IS_ROOT, 19200000);
 372 @@ -2930,39 +2904,12 @@ static int gcc_msm8960_probe(struct platform_device *pdev)
 373         if (IS_ERR(clk))
 374                 return PTR_ERR(clk);
 375
 376 -       for (i = 0; i < num_clks; i++) {
 377 -               if (!gcc_msm8960_clks[i])
 378 -                       continue;
 379 -               clk = devm_clk_register_regmap(dev, gcc_msm8960_clks[i]);
 380 -               if (IS_ERR(clk))
 381 -                       return PTR_ERR(clk);
 382 -               clks[i] = clk;
 383 -       }
 384 -
 385 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 386 -       if (ret)
 387 -               return ret;
 388 -
 389 -       reset = &cc->reset;
 390 -       reset->rcdev.of_node = dev->of_node;
 391 -       reset->rcdev.ops = &qcom_reset_ops,
 392 -       reset->rcdev.owner = THIS_MODULE,
 393 -       reset->rcdev.nr_resets = ARRAY_SIZE(gcc_msm8960_resets),
 394 -       reset->regmap = regmap;
 395 -       reset->reset_map = gcc_msm8960_resets,
 396 -       platform_set_drvdata(pdev, &reset->rcdev);
 397 -
 398 -       ret = reset_controller_register(&reset->rcdev);
 399 -       if (ret)
 400 -               of_clk_del_provider(dev->of_node);
 401 -
 402 -       return ret;
 403 +       return qcom_cc_probe(pdev, &gcc_msm8960_desc);
 404  }
 405
 406  static int gcc_msm8960_remove(struct platform_device *pdev)
 407  {
 408 -       of_clk_del_provider(pdev->dev.of_node);
 409 -       reset_controller_unregister(platform_get_drvdata(pdev));
 410 +       qcom_cc_remove(pdev);
 411         return 0;
 412  }
 413
 414 diff --git a/drivers/clk/qcom/gcc-msm8974.c b/drivers/clk/qcom/gcc-msm8974.c
 415 index 51d457e..0d1edc1 100644
 416 --- a/drivers/clk/qcom/gcc-msm8974.c
 417 +++ b/drivers/clk/qcom/gcc-msm8974.c
 418 @@ -25,6 +25,7 @@
 419  #include <dt-bindings/clock/qcom,gcc-msm8974.h>
 420  #include <dt-bindings/reset/qcom,gcc-msm8974.h>
 421
 422 +#include "common.h"
 423  #include "clk-regmap.h"
 424  #include "clk-pll.h"
 425  #include "clk-rcg.h"
 426 @@ -2574,51 +2575,24 @@ static const struct regmap_config gcc_msm8974_regmap_config = {
 427         .fast_io        = true,
 428  };
 429
 430 +static const struct qcom_cc_desc gcc_msm8974_desc = {
 431 +       .config = &gcc_msm8974_regmap_config,
 432 +       .clks = gcc_msm8974_clocks,
 433 +       .num_clks = ARRAY_SIZE(gcc_msm8974_clocks),
 434 +       .resets = gcc_msm8974_resets,
 435 +       .num_resets = ARRAY_SIZE(gcc_msm8974_resets),
 436 +};
 437 +
 438  static const struct of_device_id gcc_msm8974_match_table[] = {
 439         { .compatible = "qcom,gcc-msm8974" },
 440         { }
 441  };
 442  MODULE_DEVICE_TABLE(of, gcc_msm8974_match_table);
 443
 444 -struct qcom_cc {
 445 -       struct qcom_reset_controller reset;
 446 -       struct clk_onecell_data data;
 447 -       struct clk *clks[];
 448 -};
 449 -
 450  static int gcc_msm8974_probe(struct platform_device *pdev)
 451  {
 452 -       void __iomem *base;
 453 -       struct resource *res;
 454 -       int i, ret;
 455 -       struct device *dev = &pdev->dev;
 456         struct clk *clk;
 457 -       struct clk_onecell_data *data;
 458 -       struct clk **clks;
 459 -       struct regmap *regmap;
 460 -       size_t num_clks;
 461 -       struct qcom_reset_controller *reset;
 462 -       struct qcom_cc *cc;
 463 -
 464 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 465 -       base = devm_ioremap_resource(dev, res);
 466 -       if (IS_ERR(base))
 467 -               return PTR_ERR(base);
 468 -
 469 -       regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8974_regmap_config);
 470 -       if (IS_ERR(regmap))
 471 -               return PTR_ERR(regmap);
 472 -
 473 -       num_clks = ARRAY_SIZE(gcc_msm8974_clocks);
 474 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 475 -                         GFP_KERNEL);
 476 -       if (!cc)
 477 -               return -ENOMEM;
 478 -
 479 -       clks = cc->clks;
 480 -       data = &cc->data;
 481 -       data->clks = clks;
 482 -       data->clk_num = num_clks;
 483 +       struct device *dev = &pdev->dev;
 484
 485         /* Temporary until RPM clocks supported */
 486         clk = clk_register_fixed_rate(dev, "xo", NULL, CLK_IS_ROOT, 19200000);
 487 @@ -2631,39 +2605,12 @@ static int gcc_msm8974_probe(struct platform_device *pdev)
 488         if (IS_ERR(clk))
 489                 return PTR_ERR(clk);
 490
 491 -       for (i = 0; i < num_clks; i++) {
 492 -               if (!gcc_msm8974_clocks[i])
 493 -                       continue;
 494 -               clk = devm_clk_register_regmap(dev, gcc_msm8974_clocks[i]);
 495 -               if (IS_ERR(clk))
 496 -                       return PTR_ERR(clk);
 497 -               clks[i] = clk;
 498 -       }
 499 -
 500 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 501 -       if (ret)
 502 -               return ret;
 503 -
 504 -       reset = &cc->reset;
 505 -       reset->rcdev.of_node = dev->of_node;
 506 -       reset->rcdev.ops = &qcom_reset_ops,
 507 -       reset->rcdev.owner = THIS_MODULE,
 508 -       reset->rcdev.nr_resets = ARRAY_SIZE(gcc_msm8974_resets),
 509 -       reset->regmap = regmap;
 510 -       reset->reset_map = gcc_msm8974_resets,
 511 -       platform_set_drvdata(pdev, &reset->rcdev);
 512 -
 513 -       ret = reset_controller_register(&reset->rcdev);
 514 -       if (ret)
 515 -               of_clk_del_provider(dev->of_node);
 516 -
 517 -       return ret;
 518 +       return qcom_cc_probe(pdev, &gcc_msm8974_desc);
 519  }
 520
 521  static int gcc_msm8974_remove(struct platform_device *pdev)
 522  {
 523 -       of_clk_del_provider(pdev->dev.of_node);
 524 -       reset_controller_unregister(platform_get_drvdata(pdev));
 525 +       qcom_cc_remove(pdev);
 526         return 0;
 527  }
 528
 529 diff --git a/drivers/clk/qcom/mmcc-msm8960.c b/drivers/clk/qcom/mmcc-msm8960.c
 530 index f9b59c7..12f3c0b 100644
 531 --- a/drivers/clk/qcom/mmcc-msm8960.c
 532 +++ b/drivers/clk/qcom/mmcc-msm8960.c
 533 @@ -26,6 +26,7 @@
 534  #include <dt-bindings/clock/qcom,mmcc-msm8960.h>
 535  #include <dt-bindings/reset/qcom,mmcc-msm8960.h>
 536
 537 +#include "common.h"
 538  #include "clk-regmap.h"
 539  #include "clk-pll.h"
 540  #include "clk-rcg.h"
 541 @@ -2222,85 +2223,28 @@ static const struct regmap_config mmcc_msm8960_regmap_config = {
 542         .fast_io        = true,
 543  };
 544
 545 +static const struct qcom_cc_desc mmcc_msm8960_desc = {
 546 +       .config = &mmcc_msm8960_regmap_config,
 547 +       .clks = mmcc_msm8960_clks,
 548 +       .num_clks = ARRAY_SIZE(mmcc_msm8960_clks),
 549 +       .resets = mmcc_msm8960_resets,
 550 +       .num_resets = ARRAY_SIZE(mmcc_msm8960_resets),
 551 +};
 552 +
 553  static const struct of_device_id mmcc_msm8960_match_table[] = {
 554         { .compatible = "qcom,mmcc-msm8960" },
 555         { }
 556  };
 557  MODULE_DEVICE_TABLE(of, mmcc_msm8960_match_table);
 558
 559 -struct qcom_cc {
 560 -       struct qcom_reset_controller reset;
 561 -       struct clk_onecell_data data;
 562 -       struct clk *clks[];
 563 -};
 564 -
 565  static int mmcc_msm8960_probe(struct platform_device *pdev)
 566  {
 567 -       void __iomem *base;
 568 -       struct resource *res;
 569 -       int i, ret;
 570 -       struct device *dev = &pdev->dev;
 571 -       struct clk *clk;
 572 -       struct clk_onecell_data *data;
 573 -       struct clk **clks;
 574 -       struct regmap *regmap;
 575 -       size_t num_clks;
 576 -       struct qcom_reset_controller *reset;
 577 -       struct qcom_cc *cc;
 578 -
 579 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 580 -       base = devm_ioremap_resource(dev, res);
 581 -       if (IS_ERR(base))
 582 -               return PTR_ERR(base);
 583 -
 584 -       regmap = devm_regmap_init_mmio(dev, base, &mmcc_msm8960_regmap_config);
 585 -       if (IS_ERR(regmap))
 586 -               return PTR_ERR(regmap);
 587 -
 588 -       num_clks = ARRAY_SIZE(mmcc_msm8960_clks);
 589 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 590 -                         GFP_KERNEL);
 591 -       if (!cc)
 592 -               return -ENOMEM;
 593 -
 594 -       clks = cc->clks;
 595 -       data = &cc->data;
 596 -       data->clks = clks;
 597 -       data->clk_num = num_clks;
 598 -
 599 -       for (i = 0; i < num_clks; i++) {
 600 -               if (!mmcc_msm8960_clks[i])
 601 -                       continue;
 602 -               clk = devm_clk_register_regmap(dev, mmcc_msm8960_clks[i]);
 603 -               if (IS_ERR(clk))
 604 -                       return PTR_ERR(clk);
 605 -               clks[i] = clk;
 606 -       }
 607 -
 608 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 609 -       if (ret)
 610 -               return ret;
 611 -
 612 -       reset = &cc->reset;
 613 -       reset->rcdev.of_node = dev->of_node;
 614 -       reset->rcdev.ops = &qcom_reset_ops,
 615 -       reset->rcdev.owner = THIS_MODULE,
 616 -       reset->rcdev.nr_resets = ARRAY_SIZE(mmcc_msm8960_resets),
 617 -       reset->regmap = regmap;
 618 -       reset->reset_map = mmcc_msm8960_resets,
 619 -       platform_set_drvdata(pdev, &reset->rcdev);
 620 -
 621 -       ret = reset_controller_register(&reset->rcdev);
 622 -       if (ret)
 623 -               of_clk_del_provider(dev->of_node);
 624 -
 625 -       return ret;
 626 +       return qcom_cc_probe(pdev, &mmcc_msm8960_desc);
 627  }
 628
 629  static int mmcc_msm8960_remove(struct platform_device *pdev)
 630  {
 631 -       of_clk_del_provider(pdev->dev.of_node);
 632 -       reset_controller_unregister(platform_get_drvdata(pdev));
 633 +       qcom_cc_remove(pdev);
 634         return 0;
 635  }
 636
 637 diff --git a/drivers/clk/qcom/mmcc-msm8974.c b/drivers/clk/qcom/mmcc-msm8974.c
 638 index c957745..60b7c24 100644
 639 --- a/drivers/clk/qcom/mmcc-msm8974.c
 640 +++ b/drivers/clk/qcom/mmcc-msm8974.c
 641 @@ -25,6 +25,7 @@
 642  #include <dt-bindings/clock/qcom,mmcc-msm8974.h>
 643  #include <dt-bindings/reset/qcom,mmcc-msm8974.h>
 644
 645 +#include "common.h"
 646  #include "clk-regmap.h"
 647  #include "clk-pll.h"
 648  #include "clk-rcg.h"
 649 @@ -2524,88 +2525,39 @@ static const struct regmap_config mmcc_msm8974_regmap_config = {
 650         .fast_io        = true,
 651  };
 652
 653 +static const struct qcom_cc_desc mmcc_msm8974_desc = {
 654 +       .config = &mmcc_msm8974_regmap_config,
 655 +       .clks = mmcc_msm8974_clocks,
 656 +       .num_clks = ARRAY_SIZE(mmcc_msm8974_clocks),
 657 +       .resets = mmcc_msm8974_resets,
 658 +       .num_resets = ARRAY_SIZE(mmcc_msm8974_resets),
 659 +};
 660 +
 661  static const struct of_device_id mmcc_msm8974_match_table[] = {
 662         { .compatible = "qcom,mmcc-msm8974" },
 663         { }
 664  };
 665  MODULE_DEVICE_TABLE(of, mmcc_msm8974_match_table);
 666
 667 -struct qcom_cc {
 668 -       struct qcom_reset_controller reset;
 669 -       struct clk_onecell_data data;
 670 -       struct clk *clks[];
 671 -};
 672 -
 673  static int mmcc_msm8974_probe(struct platform_device *pdev)
 674  {
 675 -       void __iomem *base;
 676 -       struct resource *res;
 677 -       int i, ret;
 678 -       struct device *dev = &pdev->dev;
 679 -       struct clk *clk;
 680 -       struct clk_onecell_data *data;
 681 -       struct clk **clks;
 682 +       int ret;
 683         struct regmap *regmap;
 684 -       size_t num_clks;
 685 -       struct qcom_reset_controller *reset;
 686 -       struct qcom_cc *cc;
 687 -
 688 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 689 -       base = devm_ioremap_resource(dev, res);
 690 -       if (IS_ERR(base))
 691 -               return PTR_ERR(base);
 692 -
 693 -       regmap = devm_regmap_init_mmio(dev, base, &mmcc_msm8974_regmap_config);
 694 -       if (IS_ERR(regmap))
 695 -               return PTR_ERR(regmap);
 696 -
 697 -       num_clks = ARRAY_SIZE(mmcc_msm8974_clocks);
 698 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 699 -                         GFP_KERNEL);
 700 -       if (!cc)
 701 -               return -ENOMEM;
 702 -
 703 -       clks = cc->clks;
 704 -       data = &cc->data;
 705 -       data->clks = clks;
 706 -       data->clk_num = num_clks;
 707 -
 708 -       clk_pll_configure_sr_hpm_lp(&mmpll1, regmap, &mmpll1_config, true);
 709 -       clk_pll_configure_sr_hpm_lp(&mmpll3, regmap, &mmpll3_config, false);
 710
 711 -       for (i = 0; i < num_clks; i++) {
 712 -               if (!mmcc_msm8974_clocks[i])
 713 -                       continue;
 714 -               clk = devm_clk_register_regmap(dev, mmcc_msm8974_clocks[i]);
 715 -               if (IS_ERR(clk))
 716 -                       return PTR_ERR(clk);
 717 -               clks[i] = clk;
 718 -       }
 719 -
 720 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 721 +       ret = qcom_cc_probe(pdev, &mmcc_msm8974_desc);
 722         if (ret)
 723                 return ret;
 724
 725 -       reset = &cc->reset;
 726 -       reset->rcdev.of_node = dev->of_node;
 727 -       reset->rcdev.ops = &qcom_reset_ops,
 728 -       reset->rcdev.owner = THIS_MODULE,
 729 -       reset->rcdev.nr_resets = ARRAY_SIZE(mmcc_msm8974_resets),
 730 -       reset->regmap = regmap;
 731 -       reset->reset_map = mmcc_msm8974_resets,
 732 -       platform_set_drvdata(pdev, &reset->rcdev);
 733 -
 734 -       ret = reset_controller_register(&reset->rcdev);
 735 -       if (ret)
 736 -               of_clk_del_provider(dev->of_node);
 737 +       regmap = dev_get_regmap(&pdev->dev, NULL);
 738 +       clk_pll_configure_sr_hpm_lp(&mmpll1, regmap, &mmpll1_config, true);
 739 +       clk_pll_configure_sr_hpm_lp(&mmpll3, regmap, &mmpll3_config, false);
 740
 741 -       return ret;
 742 +       return 0;
 743  }
 744
 745  static int mmcc_msm8974_remove(struct platform_device *pdev)
 746  {
 747 -       of_clk_del_provider(pdev->dev.of_node);
 748 -       reset_controller_unregister(platform_get_drvdata(pdev));
 749 +       qcom_cc_remove(pdev);
 750         return 0;
 751  }
 752
 753 --
 754 1.7.10.4
 755