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 --- a/drivers/clk/qcom/Makefile
  27 +++ b/drivers/clk/qcom/Makefile
  28 @@ -1,5 +1,6 @@
  29  obj-$(CONFIG_COMMON_CLK_QCOM) += clk-qcom.o
  30
  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
  35 --- /dev/null
  36 +++ b/drivers/clk/qcom/common.c
  37 @@ -0,0 +1,99 @@
  38 +/*
  39 + * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
  40 + *
  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.
  44 + *
  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.
  49 + */
  50 +
  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>
  56 +
  57 +#include "common.h"
  58 +#include "clk-regmap.h"
  59 +#include "reset.h"
  60 +
  61 +struct qcom_cc {
  62 +       struct qcom_reset_controller reset;
  63 +       struct clk_onecell_data data;
  64 +       struct clk *clks[];
  65 +};
  66 +
  67 +int qcom_cc_probe(struct platform_device *pdev, const struct qcom_cc_desc *desc)
  68 +{
  69 +       void __iomem *base;
  70 +       struct resource *res;
  71 +       int i, ret;
  72 +       struct device *dev = &pdev->dev;
  73 +       struct clk *clk;
  74 +       struct clk_onecell_data *data;
  75 +       struct clk **clks;
  76 +       struct regmap *regmap;
  77 +       struct qcom_reset_controller *reset;
  78 +       struct qcom_cc *cc;
  79 +       size_t num_clks = desc->num_clks;
  80 +       struct clk_regmap **rclks = desc->clks;
  81 +
  82 +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  83 +       base = devm_ioremap_resource(dev, res);
  84 +       if (IS_ERR(base))
  85 +               return PTR_ERR(base);
  86 +
  87 +       regmap = devm_regmap_init_mmio(dev, base, desc->config);
  88 +       if (IS_ERR(regmap))
  89 +               return PTR_ERR(regmap);
  90 +
  91 +       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
  92 +                         GFP_KERNEL);
  93 +       if (!cc)
  94 +               return -ENOMEM;
  95 +
  96 +       clks = cc->clks;
  97 +       data = &cc->data;
  98 +       data->clks = clks;
  99 +       data->clk_num = num_clks;
 100 +
 101 +       for (i = 0; i < num_clks; i++) {
 102 +               if (!rclks[i])
 103 +                       continue;
 104 +               clk = devm_clk_register_regmap(dev, rclks[i]);
 105 +               if (IS_ERR(clk))
 106 +                       return PTR_ERR(clk);
 107 +               clks[i] = clk;
 108 +       }
 109 +
 110 +       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 111 +       if (ret)
 112 +               return ret;
 113 +
 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);
 122 +
 123 +       ret = reset_controller_register(&reset->rcdev);
 124 +       if (ret)
 125 +               of_clk_del_provider(dev->of_node);
 126 +
 127 +       return ret;
 128 +}
 129 +EXPORT_SYMBOL_GPL(qcom_cc_probe);
 130 +
 131 +void qcom_cc_remove(struct platform_device *pdev)
 132 +{
 133 +       of_clk_del_provider(pdev->dev.of_node);
 134 +       reset_controller_unregister(platform_get_drvdata(pdev));
 135 +}
 136 +EXPORT_SYMBOL_GPL(qcom_cc_remove);
 137 --- /dev/null
 138 +++ b/drivers/clk/qcom/common.h
 139 @@ -0,0 +1,34 @@
 140 +/*
 141 + * Copyright (c) 2014, The Linux Foundation. All rights reserved.
 142 + *
 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.
 146 + *
 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.
 151 + */
 152 +#ifndef __QCOM_CLK_COMMON_H__
 153 +#define __QCOM_CLK_COMMON_H__
 154 +
 155 +struct platform_device;
 156 +struct regmap_config;
 157 +struct clk_regmap;
 158 +struct qcom_reset_map;
 159 +
 160 +struct qcom_cc_desc {
 161 +       const struct regmap_config *config;
 162 +       struct clk_regmap **clks;
 163 +       size_t num_clks;
 164 +       const struct qcom_reset_map *resets;
 165 +       size_t num_resets;
 166 +};
 167 +
 168 +extern int qcom_cc_probe(struct platform_device *pdev,
 169 +                        const struct qcom_cc_desc *desc);
 170 +
 171 +extern void qcom_cc_remove(struct platform_device *pdev);
 172 +
 173 +#endif
 174 --- a/drivers/clk/qcom/gcc-msm8660.c
 175 +++ b/drivers/clk/qcom/gcc-msm8660.c
 176 @@ -25,6 +25,7 @@
 177  #include <dt-bindings/clock/qcom,gcc-msm8660.h>
 178  #include <dt-bindings/reset/qcom,gcc-msm8660.h>
 179
 180 +#include "common.h"
 181  #include "clk-regmap.h"
 182  #include "clk-pll.h"
 183  #include "clk-rcg.h"
 184 @@ -2701,94 +2702,28 @@ static const struct regmap_config gcc_ms
 185         .fast_io        = true,
 186  };
 187
 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),
 194 +};
 195 +
 196  static const struct of_device_id gcc_msm8660_match_table[] = {
 197         { .compatible = "qcom,gcc-msm8660" },
 198         { }
 199  };
 200  MODULE_DEVICE_TABLE(of, gcc_msm8660_match_table);
 201
 202 -struct qcom_cc {
 203 -       struct qcom_reset_controller reset;
 204 -       struct clk_onecell_data data;
 205 -       struct clk *clks[];
 206 -};
 207 -
 208  static int gcc_msm8660_probe(struct platform_device *pdev)
 209  {
 210 -       void __iomem *base;
 211 -       struct resource *res;
 212 -       int i, ret;
 213 -       struct device *dev = &pdev->dev;
 214 -       struct clk *clk;
 215 -       struct clk_onecell_data *data;
 216 -       struct clk **clks;
 217 -       struct regmap *regmap;
 218 -       size_t num_clks;
 219 -       struct qcom_reset_controller *reset;
 220 -       struct qcom_cc *cc;
 221 -
 222 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 223 -       base = devm_ioremap_resource(dev, res);
 224 -       if (IS_ERR(base))
 225 -               return PTR_ERR(base);
 226 -
 227 -       regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8660_regmap_config);
 228 -       if (IS_ERR(regmap))
 229 -               return PTR_ERR(regmap);
 230 -
 231 -       num_clks = ARRAY_SIZE(gcc_msm8660_clks);
 232 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 233 -                         GFP_KERNEL);
 234 -       if (!cc)
 235 -               return -ENOMEM;
 236 -
 237 -       clks = cc->clks;
 238 -       data = &cc->data;
 239 -       data->clks = clks;
 240 -       data->clk_num = num_clks;
 241 -
 242 -       /* Temporary until RPM clocks supported */
 243 -       clk = clk_register_fixed_rate(dev, "cxo", NULL, CLK_IS_ROOT, 19200000);
 244 -       if (IS_ERR(clk))
 245 -               return PTR_ERR(clk);
 246 -
 247 -       clk = clk_register_fixed_rate(dev, "pxo", NULL, CLK_IS_ROOT, 27000000);
 248 -       if (IS_ERR(clk))
 249 -               return PTR_ERR(clk);
 250 -
 251 -       for (i = 0; i < num_clks; i++) {
 252 -               if (!gcc_msm8660_clks[i])
 253 -                       continue;
 254 -               clk = devm_clk_register_regmap(dev, gcc_msm8660_clks[i]);
 255 -               if (IS_ERR(clk))
 256 -                       return PTR_ERR(clk);
 257 -               clks[i] = clk;
 258 -       }
 259 -
 260 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 261 -       if (ret)
 262 -               return ret;
 263 -
 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);
 272 -
 273 -       ret = reset_controller_register(&reset->rcdev);
 274 -       if (ret)
 275 -               of_clk_del_provider(dev->of_node);
 276 -
 277 -       return ret;
 278 +       return qcom_cc_probe(pdev, &gcc_msm8660_desc);
 279  }
 280
 281  static int gcc_msm8660_remove(struct platform_device *pdev)
 282  {
 283 -       of_clk_del_provider(pdev->dev.of_node);
 284 -       reset_controller_unregister(platform_get_drvdata(pdev));
 285 +       qcom_cc_remove(pdev);
 286         return 0;
 287  }
 288
 289 --- a/drivers/clk/qcom/gcc-msm8960.c
 290 +++ b/drivers/clk/qcom/gcc-msm8960.c
 291 @@ -25,6 +25,7 @@
 292  #include <dt-bindings/clock/qcom,gcc-msm8960.h>
 293  #include <dt-bindings/reset/qcom,gcc-msm8960.h>
 294
 295 +#include "common.h"
 296  #include "clk-regmap.h"
 297  #include "clk-pll.h"
 298  #include "clk-rcg.h"
 299 @@ -2875,51 +2876,24 @@ static const struct regmap_config gcc_ms
 300         .fast_io        = true,
 301  };
 302
 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),
 309 +};
 310 +
 311  static const struct of_device_id gcc_msm8960_match_table[] = {
 312         { .compatible = "qcom,gcc-msm8960" },
 313         { }
 314  };
 315  MODULE_DEVICE_TABLE(of, gcc_msm8960_match_table);
 316
 317 -struct qcom_cc {
 318 -       struct qcom_reset_controller reset;
 319 -       struct clk_onecell_data data;
 320 -       struct clk *clks[];
 321 -};
 322 -
 323  static int gcc_msm8960_probe(struct platform_device *pdev)
 324  {
 325 -       void __iomem *base;
 326 -       struct resource *res;
 327 -       int i, ret;
 328 -       struct device *dev = &pdev->dev;
 329         struct clk *clk;
 330 -       struct clk_onecell_data *data;
 331 -       struct clk **clks;
 332 -       struct regmap *regmap;
 333 -       size_t num_clks;
 334 -       struct qcom_reset_controller *reset;
 335 -       struct qcom_cc *cc;
 336 -
 337 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 338 -       base = devm_ioremap_resource(dev, res);
 339 -       if (IS_ERR(base))
 340 -               return PTR_ERR(base);
 341 -
 342 -       regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8960_regmap_config);
 343 -       if (IS_ERR(regmap))
 344 -               return PTR_ERR(regmap);
 345 -
 346 -       num_clks = ARRAY_SIZE(gcc_msm8960_clks);
 347 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 348 -                         GFP_KERNEL);
 349 -       if (!cc)
 350 -               return -ENOMEM;
 351 -
 352 -       clks = cc->clks;
 353 -       data = &cc->data;
 354 -       data->clks = clks;
 355 -       data->clk_num = num_clks;
 356 +       struct device *dev = &pdev->dev;
 357
 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
 361         if (IS_ERR(clk))
 362                 return PTR_ERR(clk);
 363
 364 -       for (i = 0; i < num_clks; i++) {
 365 -               if (!gcc_msm8960_clks[i])
 366 -                       continue;
 367 -               clk = devm_clk_register_regmap(dev, gcc_msm8960_clks[i]);
 368 -               if (IS_ERR(clk))
 369 -                       return PTR_ERR(clk);
 370 -               clks[i] = clk;
 371 -       }
 372 -
 373 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 374 -       if (ret)
 375 -               return ret;
 376 -
 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);
 385 -
 386 -       ret = reset_controller_register(&reset->rcdev);
 387 -       if (ret)
 388 -               of_clk_del_provider(dev->of_node);
 389 -
 390 -       return ret;
 391 +       return qcom_cc_probe(pdev, &gcc_msm8960_desc);
 392  }
 393
 394  static int gcc_msm8960_remove(struct platform_device *pdev)
 395  {
 396 -       of_clk_del_provider(pdev->dev.of_node);
 397 -       reset_controller_unregister(platform_get_drvdata(pdev));
 398 +       qcom_cc_remove(pdev);
 399         return 0;
 400  }
 401
 402 --- a/drivers/clk/qcom/gcc-msm8974.c
 403 +++ b/drivers/clk/qcom/gcc-msm8974.c
 404 @@ -25,6 +25,7 @@
 405  #include <dt-bindings/clock/qcom,gcc-msm8974.h>
 406  #include <dt-bindings/reset/qcom,gcc-msm8974.h>
 407
 408 +#include "common.h"
 409  #include "clk-regmap.h"
 410  #include "clk-pll.h"
 411  #include "clk-rcg.h"
 412 @@ -2574,51 +2575,24 @@ static const struct regmap_config gcc_ms
 413         .fast_io        = true,
 414  };
 415
 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),
 422 +};
 423 +
 424  static const struct of_device_id gcc_msm8974_match_table[] = {
 425         { .compatible = "qcom,gcc-msm8974" },
 426         { }
 427  };
 428  MODULE_DEVICE_TABLE(of, gcc_msm8974_match_table);
 429
 430 -struct qcom_cc {
 431 -       struct qcom_reset_controller reset;
 432 -       struct clk_onecell_data data;
 433 -       struct clk *clks[];
 434 -};
 435 -
 436  static int gcc_msm8974_probe(struct platform_device *pdev)
 437  {
 438 -       void __iomem *base;
 439 -       struct resource *res;
 440 -       int i, ret;
 441 -       struct device *dev = &pdev->dev;
 442         struct clk *clk;
 443 -       struct clk_onecell_data *data;
 444 -       struct clk **clks;
 445 -       struct regmap *regmap;
 446 -       size_t num_clks;
 447 -       struct qcom_reset_controller *reset;
 448 -       struct qcom_cc *cc;
 449 -
 450 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 451 -       base = devm_ioremap_resource(dev, res);
 452 -       if (IS_ERR(base))
 453 -               return PTR_ERR(base);
 454 -
 455 -       regmap = devm_regmap_init_mmio(dev, base, &gcc_msm8974_regmap_config);
 456 -       if (IS_ERR(regmap))
 457 -               return PTR_ERR(regmap);
 458 -
 459 -       num_clks = ARRAY_SIZE(gcc_msm8974_clocks);
 460 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 461 -                         GFP_KERNEL);
 462 -       if (!cc)
 463 -               return -ENOMEM;
 464 -
 465 -       clks = cc->clks;
 466 -       data = &cc->data;
 467 -       data->clks = clks;
 468 -       data->clk_num = num_clks;
 469 +       struct device *dev = &pdev->dev;
 470
 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
 474         if (IS_ERR(clk))
 475                 return PTR_ERR(clk);
 476
 477 -       for (i = 0; i < num_clks; i++) {
 478 -               if (!gcc_msm8974_clocks[i])
 479 -                       continue;
 480 -               clk = devm_clk_register_regmap(dev, gcc_msm8974_clocks[i]);
 481 -               if (IS_ERR(clk))
 482 -                       return PTR_ERR(clk);
 483 -               clks[i] = clk;
 484 -       }
 485 -
 486 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 487 -       if (ret)
 488 -               return ret;
 489 -
 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);
 498 -
 499 -       ret = reset_controller_register(&reset->rcdev);
 500 -       if (ret)
 501 -               of_clk_del_provider(dev->of_node);
 502 -
 503 -       return ret;
 504 +       return qcom_cc_probe(pdev, &gcc_msm8974_desc);
 505  }
 506
 507  static int gcc_msm8974_remove(struct platform_device *pdev)
 508  {
 509 -       of_clk_del_provider(pdev->dev.of_node);
 510 -       reset_controller_unregister(platform_get_drvdata(pdev));
 511 +       qcom_cc_remove(pdev);
 512         return 0;
 513  }
 514
 515 --- a/drivers/clk/qcom/mmcc-msm8960.c
 516 +++ b/drivers/clk/qcom/mmcc-msm8960.c
 517 @@ -26,6 +26,7 @@
 518  #include <dt-bindings/clock/qcom,mmcc-msm8960.h>
 519  #include <dt-bindings/reset/qcom,mmcc-msm8960.h>
 520
 521 +#include "common.h"
 522  #include "clk-regmap.h"
 523  #include "clk-pll.h"
 524  #include "clk-rcg.h"
 525 @@ -2224,85 +2225,28 @@ static const struct regmap_config mmcc_m
 526         .fast_io        = true,
 527  };
 528
 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),
 535 +};
 536 +
 537  static const struct of_device_id mmcc_msm8960_match_table[] = {
 538         { .compatible = "qcom,mmcc-msm8960" },
 539         { }
 540  };
 541  MODULE_DEVICE_TABLE(of, mmcc_msm8960_match_table);
 542
 543 -struct qcom_cc {
 544 -       struct qcom_reset_controller reset;
 545 -       struct clk_onecell_data data;
 546 -       struct clk *clks[];
 547 -};
 548 -
 549  static int mmcc_msm8960_probe(struct platform_device *pdev)
 550  {
 551 -       void __iomem *base;
 552 -       struct resource *res;
 553 -       int i, ret;
 554 -       struct device *dev = &pdev->dev;
 555 -       struct clk *clk;
 556 -       struct clk_onecell_data *data;
 557 -       struct clk **clks;
 558 -       struct regmap *regmap;
 559 -       size_t num_clks;
 560 -       struct qcom_reset_controller *reset;
 561 -       struct qcom_cc *cc;
 562 -
 563 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 564 -       base = devm_ioremap_resource(dev, res);
 565 -       if (IS_ERR(base))
 566 -               return PTR_ERR(base);
 567 -
 568 -       regmap = devm_regmap_init_mmio(dev, base, &mmcc_msm8960_regmap_config);
 569 -       if (IS_ERR(regmap))
 570 -               return PTR_ERR(regmap);
 571 -
 572 -       num_clks = ARRAY_SIZE(mmcc_msm8960_clks);
 573 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 574 -                         GFP_KERNEL);
 575 -       if (!cc)
 576 -               return -ENOMEM;
 577 -
 578 -       clks = cc->clks;
 579 -       data = &cc->data;
 580 -       data->clks = clks;
 581 -       data->clk_num = num_clks;
 582 -
 583 -       for (i = 0; i < num_clks; i++) {
 584 -               if (!mmcc_msm8960_clks[i])
 585 -                       continue;
 586 -               clk = devm_clk_register_regmap(dev, mmcc_msm8960_clks[i]);
 587 -               if (IS_ERR(clk))
 588 -                       return PTR_ERR(clk);
 589 -               clks[i] = clk;
 590 -       }
 591 -
 592 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 593 -       if (ret)
 594 -               return ret;
 595 -
 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);
 604 -
 605 -       ret = reset_controller_register(&reset->rcdev);
 606 -       if (ret)
 607 -               of_clk_del_provider(dev->of_node);
 608 -
 609 -       return ret;
 610 +       return qcom_cc_probe(pdev, &mmcc_msm8960_desc);
 611  }
 612
 613  static int mmcc_msm8960_remove(struct platform_device *pdev)
 614  {
 615 -       of_clk_del_provider(pdev->dev.of_node);
 616 -       reset_controller_unregister(platform_get_drvdata(pdev));
 617 +       qcom_cc_remove(pdev);
 618         return 0;
 619  }
 620
 621 --- a/drivers/clk/qcom/mmcc-msm8974.c
 622 +++ b/drivers/clk/qcom/mmcc-msm8974.c
 623 @@ -25,6 +25,7 @@
 624  #include <dt-bindings/clock/qcom,mmcc-msm8974.h>
 625  #include <dt-bindings/reset/qcom,mmcc-msm8974.h>
 626
 627 +#include "common.h"
 628  #include "clk-regmap.h"
 629  #include "clk-pll.h"
 630  #include "clk-rcg.h"
 631 @@ -2527,88 +2528,39 @@ static const struct regmap_config mmcc_m
 632         .fast_io        = true,
 633  };
 634
 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),
 641 +};
 642 +
 643  static const struct of_device_id mmcc_msm8974_match_table[] = {
 644         { .compatible = "qcom,mmcc-msm8974" },
 645         { }
 646  };
 647  MODULE_DEVICE_TABLE(of, mmcc_msm8974_match_table);
 648
 649 -struct qcom_cc {
 650 -       struct qcom_reset_controller reset;
 651 -       struct clk_onecell_data data;
 652 -       struct clk *clks[];
 653 -};
 654 -
 655  static int mmcc_msm8974_probe(struct platform_device *pdev)
 656  {
 657 -       void __iomem *base;
 658 -       struct resource *res;
 659 -       int i, ret;
 660 -       struct device *dev = &pdev->dev;
 661 -       struct clk *clk;
 662 -       struct clk_onecell_data *data;
 663 -       struct clk **clks;
 664 +       int ret;
 665         struct regmap *regmap;
 666 -       size_t num_clks;
 667 -       struct qcom_reset_controller *reset;
 668 -       struct qcom_cc *cc;
 669 -
 670 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 671 -       base = devm_ioremap_resource(dev, res);
 672 -       if (IS_ERR(base))
 673 -               return PTR_ERR(base);
 674 -
 675 -       regmap = devm_regmap_init_mmio(dev, base, &mmcc_msm8974_regmap_config);
 676 -       if (IS_ERR(regmap))
 677 -               return PTR_ERR(regmap);
 678 -
 679 -       num_clks = ARRAY_SIZE(mmcc_msm8974_clocks);
 680 -       cc = devm_kzalloc(dev, sizeof(*cc) + sizeof(*clks) * num_clks,
 681 -                         GFP_KERNEL);
 682 -       if (!cc)
 683 -               return -ENOMEM;
 684 -
 685 -       clks = cc->clks;
 686 -       data = &cc->data;
 687 -       data->clks = clks;
 688 -       data->clk_num = num_clks;
 689 -
 690 -       clk_pll_configure_sr_hpm_lp(&mmpll1, regmap, &mmpll1_config, true);
 691 -       clk_pll_configure_sr_hpm_lp(&mmpll3, regmap, &mmpll3_config, false);
 692
 693 -       for (i = 0; i < num_clks; i++) {
 694 -               if (!mmcc_msm8974_clocks[i])
 695 -                       continue;
 696 -               clk = devm_clk_register_regmap(dev, mmcc_msm8974_clocks[i]);
 697 -               if (IS_ERR(clk))
 698 -                       return PTR_ERR(clk);
 699 -               clks[i] = clk;
 700 -       }
 701 -
 702 -       ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, data);
 703 +       ret = qcom_cc_probe(pdev, &mmcc_msm8974_desc);
 704         if (ret)
 705                 return ret;
 706
 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);
 715 -
 716 -       ret = reset_controller_register(&reset->rcdev);
 717 -       if (ret)
 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);
 722
 723 -       return ret;
 724 +       return 0;
 725  }
 726
 727  static int mmcc_msm8974_remove(struct platform_device *pdev)
 728  {
 729 -       of_clk_del_provider(pdev->dev.of_node);
 730 -       reset_controller_unregister(platform_get_drvdata(pdev));
 731 +       qcom_cc_remove(pdev);
 732         return 0;
 733  }
 734