drivers/clk/clk-qoriq.c

   1 /*
   2  * Copyright 2013 Freescale Semiconductor, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * clock driver for Freescale QorIQ SoCs.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/clk.h>
  14 #include <linux/clk-provider.h>
  15 #include <linux/clkdev.h>
  16 #include <linux/fsl/guts.h>
  17 #include <linux/io.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/of_address.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/of.h>
  23 #include <linux/slab.h>
  24
  25 #define PLL_DIV1        0
  26 #define PLL_DIV2        1
  27 #define PLL_DIV3        2
  28 #define PLL_DIV4        3
  29
  30 #define PLATFORM_PLL    0
  31 #define CGA_PLL1        1
  32 #define CGA_PLL2        2
  33 #define CGA_PLL3        3
  34 #define CGA_PLL4        4       /* only on clockgen-1.0, which lacks CGB */
  35 #define CGB_PLL1        4
  36 #define CGB_PLL2        5
  37
  38 struct clockgen_pll_div {
  39         struct clk *clk;
  40         char name[32];
  41 };
  42
  43 struct clockgen_pll {
  44         struct clockgen_pll_div div[8];
  45 };
  46
  47 #define CLKSEL_VALID    1
  48 #define CLKSEL_80PCT    2       /* Only allowed if PLL <= 80% of max cpu freq */
  49
  50 struct clockgen_sourceinfo {
  51         u32 flags;      /* CLKSEL_xxx */
  52         int pll;        /* CGx_PLLn */
  53         int div;        /* PLL_DIVn */
  54 };
  55
  56 #define NUM_MUX_PARENTS 16
  57
  58 struct clockgen_muxinfo {
  59         struct clockgen_sourceinfo clksel[NUM_MUX_PARENTS];
  60 };
  61
  62 #define NUM_HWACCEL     5
  63 #define NUM_CMUX        8
  64
  65 struct clockgen;
  66
  67 /*
  68  * cmux freq must be >= platform pll.
  69  * If not set, cmux freq must be >= platform pll/2
  70  */
  71 #define CG_CMUX_GE_PLAT         1
  72
  73 #define CG_PLL_8BIT             2       /* PLLCnGSR[CFG] is 8 bits, not 6 */
  74 #define CG_VER3                 4       /* version 3 cg: reg layout different */
  75 #define CG_LITTLE_ENDIAN        8
  76
  77 struct clockgen_chipinfo {
  78         const char *compat, *guts_compat;
  79         const struct clockgen_muxinfo *cmux_groups[2];
  80         const struct clockgen_muxinfo *hwaccel[NUM_HWACCEL];
  81         void (*init_periph)(struct clockgen *cg);
  82         int cmux_to_group[NUM_CMUX]; /* -1 terminates if fewer than NUM_CMUX */
  83         u32 pll_mask;   /* 1 << n bit set if PLL n is valid */
  84         u32 flags;      /* CG_xxx */
  85 };
  86
  87 struct clockgen {
  88         struct device_node *node;
  89         void __iomem *regs;
  90         struct clockgen_chipinfo info; /* mutable copy */
  91         struct clk *sysclk, *coreclk;
  92         struct clockgen_pll pll[6];
  93         struct clk *cmux[NUM_CMUX];
  94         struct clk *hwaccel[NUM_HWACCEL];
  95         struct clk *fman[2];
  96         struct ccsr_guts __iomem *guts;
  97 };
  98
  99 static struct clockgen clockgen;
 100
 101 static void cg_out(struct clockgen *cg, u32 val, u32 __iomem *reg)
 102 {
 103         if (cg->info.flags & CG_LITTLE_ENDIAN)
 104                 iowrite32(val, reg);
 105         else
 106                 iowrite32be(val, reg);
 107 }
 108
 109 static u32 cg_in(struct clockgen *cg, u32 __iomem *reg)
 110 {
 111         u32 val;
 112
 113         if (cg->info.flags & CG_LITTLE_ENDIAN)
 114                 val = ioread32(reg);
 115         else
 116                 val = ioread32be(reg);
 117
 118         return val;
 119 }
 120
 121 static const struct clockgen_muxinfo p2041_cmux_grp1 = {
 122         {
 123                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 124                 [1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 125                 [4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 126         }
 127 };
 128
 129 static const struct clockgen_muxinfo p2041_cmux_grp2 = {
 130         {
 131                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 132                 [4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 133                 [5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 134         }
 135 };
 136
 137 static const struct clockgen_muxinfo p5020_cmux_grp1 = {
 138         {
 139                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 140                 [1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 141                 [4] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL2, PLL_DIV1 },
 142         }
 143 };
 144
 145 static const struct clockgen_muxinfo p5020_cmux_grp2 = {
 146         {
 147                 [0] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV1 },
 148                 [4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 149                 [5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 150         }
 151 };
 152
 153 static const struct clockgen_muxinfo p5040_cmux_grp1 = {
 154         {
 155                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 156                 [1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 157                 [4] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL2, PLL_DIV1 },
 158                 [5] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL2, PLL_DIV2 },
 159         }
 160 };
 161
 162 static const struct clockgen_muxinfo p5040_cmux_grp2 = {
 163         {
 164                 [0] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV1 },
 165                 [1] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV2 },
 166                 [4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 167                 [5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 168         }
 169 };
 170
 171 static const struct clockgen_muxinfo p4080_cmux_grp1 = {
 172         {
 173                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 174                 [1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 175                 [4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 176                 [5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 177                 [8] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL3, PLL_DIV1 },
 178         }
 179 };
 180
 181 static const struct clockgen_muxinfo p4080_cmux_grp2 = {
 182         {
 183                 [0] = { CLKSEL_VALID | CLKSEL_80PCT, CGA_PLL1, PLL_DIV1 },
 184                 [8] = { CLKSEL_VALID, CGA_PLL3, PLL_DIV1 },
 185                 [9] = { CLKSEL_VALID, CGA_PLL3, PLL_DIV2 },
 186                 [12] = { CLKSEL_VALID, CGA_PLL4, PLL_DIV1 },
 187                 [13] = { CLKSEL_VALID, CGA_PLL4, PLL_DIV2 },
 188         }
 189 };
 190
 191 static const struct clockgen_muxinfo t1023_cmux = {
 192         {
 193                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 194                 [1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 195         }
 196 };
 197
 198 static const struct clockgen_muxinfo t1040_cmux = {
 199         {
 200                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 201                 [1] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 202                 [4] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 203                 [5] = { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 204         }
 205 };
 206
 207
 208 static const struct clockgen_muxinfo clockgen2_cmux_cga = {
 209         {
 210                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 211                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 212                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
 213                 {},
 214                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 215                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 216                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV4 },
 217                 {},
 218                 { CLKSEL_VALID, CGA_PLL3, PLL_DIV1 },
 219                 { CLKSEL_VALID, CGA_PLL3, PLL_DIV2 },
 220                 { CLKSEL_VALID, CGA_PLL3, PLL_DIV4 },
 221         },
 222 };
 223
 224 static const struct clockgen_muxinfo clockgen2_cmux_cga12 = {
 225         {
 226                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 227                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 228                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
 229                 {},
 230                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 231                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 232                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV4 },
 233         },
 234 };
 235
 236 static const struct clockgen_muxinfo clockgen2_cmux_cgb = {
 237         {
 238                 { CLKSEL_VALID, CGB_PLL1, PLL_DIV1 },
 239                 { CLKSEL_VALID, CGB_PLL1, PLL_DIV2 },
 240                 { CLKSEL_VALID, CGB_PLL1, PLL_DIV4 },
 241                 {},
 242                 { CLKSEL_VALID, CGB_PLL2, PLL_DIV1 },
 243                 { CLKSEL_VALID, CGB_PLL2, PLL_DIV2 },
 244                 { CLKSEL_VALID, CGB_PLL2, PLL_DIV4 },
 245         },
 246 };
 247
 248 static const struct clockgen_muxinfo ls1043a_hwa1 = {
 249         {
 250                 {},
 251                 {},
 252                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 253                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
 254                 {},
 255                 {},
 256                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 257                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 258         },
 259 };
 260
 261 static const struct clockgen_muxinfo ls1043a_hwa2 = {
 262         {
 263                 {},
 264                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 265                 {},
 266                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 267         },
 268 };
 269
 270 static const struct clockgen_muxinfo ls1046a_hwa1 = {
 271         {
 272                 {},
 273                 {},
 274                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 275                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
 276                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
 277                 { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
 278                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 279                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 280         },
 281 };
 282
 283 static const struct clockgen_muxinfo ls1046a_hwa2 = {
 284         {
 285                 {},
 286                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 287                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 288                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 289                 {},
 290                 {},
 291                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 292         },
 293 };
 294
 295 static const struct clockgen_muxinfo ls1012a_cmux = {
 296         {
 297                 [0] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 298                 {},
 299                 [2] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 300         }
 301 };
 302
 303 static const struct clockgen_muxinfo t1023_hwa1 = {
 304         {
 305                 {},
 306                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 307                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 308                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
 309         },
 310 };
 311
 312 static const struct clockgen_muxinfo t1023_hwa2 = {
 313         {
 314                 [6] = { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 315         },
 316 };
 317
 318 static const struct clockgen_muxinfo t2080_hwa1 = {
 319         {
 320                 {},
 321                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 322                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 323                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
 324                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
 325                 { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
 326                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 327                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 328         },
 329 };
 330
 331 static const struct clockgen_muxinfo t2080_hwa2 = {
 332         {
 333                 {},
 334                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV1 },
 335                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 336                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 337                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV4 },
 338                 { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
 339                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 340                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
 341         },
 342 };
 343
 344 static const struct clockgen_muxinfo t4240_hwa1 = {
 345         {
 346                 { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV2 },
 347                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV1 },
 348                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV2 },
 349                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV3 },
 350                 { CLKSEL_VALID, CGA_PLL1, PLL_DIV4 },
 351                 {},
 352                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV2 },
 353                 { CLKSEL_VALID, CGA_PLL2, PLL_DIV3 },
 354         },
 355 };
 356
 357 static const struct clockgen_muxinfo t4240_hwa4 = {
 358         {
 359                 [2] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV2 },
 360                 [3] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV3 },
 361                 [4] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV4 },
 362                 [5] = { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
 363                 [6] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV2 },
 364         },
 365 };
 366
 367 static const struct clockgen_muxinfo t4240_hwa5 = {
 368         {
 369                 [2] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV2 },
 370                 [3] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV3 },
 371                 [4] = { CLKSEL_VALID, CGB_PLL2, PLL_DIV4 },
 372                 [5] = { CLKSEL_VALID, PLATFORM_PLL, PLL_DIV1 },
 373                 [6] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV2 },
 374                 [7] = { CLKSEL_VALID, CGB_PLL1, PLL_DIV3 },
 375         },
 376 };
 377
 378 #define RCWSR7_FM1_CLK_SEL      0x40000000
 379 #define RCWSR7_FM2_CLK_SEL      0x20000000
 380 #define RCWSR7_HWA_ASYNC_DIV    0x04000000
 381
 382 static void __init p2041_init_periph(struct clockgen *cg)
 383 {
 384         u32 reg;
 385
 386         reg = ioread32be(&cg->guts->rcwsr[7]);
 387
 388         if (reg & RCWSR7_FM1_CLK_SEL)
 389                 cg->fman[0] = cg->pll[CGA_PLL2].div[PLL_DIV2].clk;
 390         else
 391                 cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
 392 }
 393
 394 static void __init p4080_init_periph(struct clockgen *cg)
 395 {
 396         u32 reg;
 397
 398         reg = ioread32be(&cg->guts->rcwsr[7]);
 399
 400         if (reg & RCWSR7_FM1_CLK_SEL)
 401                 cg->fman[0] = cg->pll[CGA_PLL3].div[PLL_DIV2].clk;
 402         else
 403                 cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
 404
 405         if (reg & RCWSR7_FM2_CLK_SEL)
 406                 cg->fman[1] = cg->pll[CGA_PLL3].div[PLL_DIV2].clk;
 407         else
 408                 cg->fman[1] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
 409 }
 410
 411 static void __init p5020_init_periph(struct clockgen *cg)
 412 {
 413         u32 reg;
 414         int div = PLL_DIV2;
 415
 416         reg = ioread32be(&cg->guts->rcwsr[7]);
 417         if (reg & RCWSR7_HWA_ASYNC_DIV)
 418                 div = PLL_DIV4;
 419
 420         if (reg & RCWSR7_FM1_CLK_SEL)
 421                 cg->fman[0] = cg->pll[CGA_PLL2].div[div].clk;
 422         else
 423                 cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
 424 }
 425
 426 static void __init p5040_init_periph(struct clockgen *cg)
 427 {
 428         u32 reg;
 429         int div = PLL_DIV2;
 430
 431         reg = ioread32be(&cg->guts->rcwsr[7]);
 432         if (reg & RCWSR7_HWA_ASYNC_DIV)
 433                 div = PLL_DIV4;
 434
 435         if (reg & RCWSR7_FM1_CLK_SEL)
 436                 cg->fman[0] = cg->pll[CGA_PLL3].div[div].clk;
 437         else
 438                 cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
 439
 440         if (reg & RCWSR7_FM2_CLK_SEL)
 441                 cg->fman[1] = cg->pll[CGA_PLL3].div[div].clk;
 442         else
 443                 cg->fman[1] = cg->pll[PLATFORM_PLL].div[PLL_DIV2].clk;
 444 }
 445
 446 static void __init t1023_init_periph(struct clockgen *cg)
 447 {
 448         cg->fman[0] = cg->hwaccel[1];
 449 }
 450
 451 static void __init t1040_init_periph(struct clockgen *cg)
 452 {
 453         cg->fman[0] = cg->pll[PLATFORM_PLL].div[PLL_DIV1].clk;
 454 }
 455
 456 static void __init t2080_init_periph(struct clockgen *cg)
 457 {
 458         cg->fman[0] = cg->hwaccel[0];
 459 }
 460
 461 static void __init t4240_init_periph(struct clockgen *cg)
 462 {
 463         cg->fman[0] = cg->hwaccel[3];
 464         cg->fman[1] = cg->hwaccel[4];
 465 }
 466
 467 static const struct clockgen_chipinfo chipinfo[] = {
 468         {
 469                 .compat = "fsl,b4420-clockgen",
 470                 .guts_compat = "fsl,b4860-device-config",
 471                 .init_periph = t2080_init_periph,
 472                 .cmux_groups = {
 473                         &clockgen2_cmux_cga12, &clockgen2_cmux_cgb
 474                 },
 475                 .hwaccel = {
 476                         &t2080_hwa1
 477                 },
 478                 .cmux_to_group = {
 479                         0, 1, 1, 1, -1
 480                 },
 481                 .pll_mask = 0x3f,
 482                 .flags = CG_PLL_8BIT,
 483         },
 484         {
 485                 .compat = "fsl,b4860-clockgen",
 486                 .guts_compat = "fsl,b4860-device-config",
 487                 .init_periph = t2080_init_periph,
 488                 .cmux_groups = {
 489                         &clockgen2_cmux_cga12, &clockgen2_cmux_cgb
 490                 },
 491                 .hwaccel = {
 492                         &t2080_hwa1
 493                 },
 494                 .cmux_to_group = {
 495                         0, 1, 1, 1, -1
 496                 },
 497                 .pll_mask = 0x3f,
 498                 .flags = CG_PLL_8BIT,
 499         },
 500         {
 501                 .compat = "fsl,ls1021a-clockgen",
 502                 .cmux_groups = {
 503                         &t1023_cmux
 504                 },
 505                 .cmux_to_group = {
 506                         0, -1
 507                 },
 508                 .pll_mask = 0x03,
 509         },
 510         {
 511                 .compat = "fsl,ls1043a-clockgen",
 512                 .init_periph = t2080_init_periph,
 513                 .cmux_groups = {
 514                         &t1040_cmux
 515                 },
 516                 .hwaccel = {
 517                         &ls1043a_hwa1, &ls1043a_hwa2
 518                 },
 519                 .cmux_to_group = {
 520                         0, -1
 521                 },
 522                 .pll_mask = 0x07,
 523                 .flags = CG_PLL_8BIT,
 524         },
 525         {
 526                 .compat = "fsl,ls1046a-clockgen",
 527                 .init_periph = t2080_init_periph,
 528                 .cmux_groups = {
 529                         &t1040_cmux
 530                 },
 531                 .hwaccel = {
 532                         &ls1046a_hwa1, &ls1046a_hwa2
 533                 },
 534                 .cmux_to_group = {
 535                         0, -1
 536                 },
 537                 .pll_mask = 0x07,
 538                 .flags = CG_PLL_8BIT,
 539         },
 540         {
 541                 .compat = "fsl,ls1088a-clockgen",
 542                 .cmux_groups = {
 543                         &clockgen2_cmux_cga12
 544                 },
 545                 .cmux_to_group = {
 546                         0, 0, -1
 547                 },
 548                 .pll_mask = 0x07,
 549                 .flags = CG_VER3 | CG_LITTLE_ENDIAN,
 550         },
 551         {
 552                 .compat = "fsl,ls1012a-clockgen",
 553                 .cmux_groups = {
 554                         &ls1012a_cmux
 555                 },
 556                 .cmux_to_group = {
 557                         0, -1
 558                 },
 559                 .pll_mask = 0x03,
 560         },
 561         {
 562                 .compat = "fsl,ls2080a-clockgen",
 563                 .cmux_groups = {
 564                         &clockgen2_cmux_cga12, &clockgen2_cmux_cgb
 565                 },
 566                 .cmux_to_group = {
 567                         0, 0, 1, 1, -1
 568                 },
 569                 .pll_mask = 0x37,
 570                 .flags = CG_VER3 | CG_LITTLE_ENDIAN,
 571         },
 572         {
 573                 .compat = "fsl,p2041-clockgen",
 574                 .guts_compat = "fsl,qoriq-device-config-1.0",
 575                 .init_periph = p2041_init_periph,
 576                 .cmux_groups = {
 577                         &p2041_cmux_grp1, &p2041_cmux_grp2
 578                 },
 579                 .cmux_to_group = {
 580                         0, 0, 1, 1, -1
 581                 },
 582                 .pll_mask = 0x07,
 583         },
 584         {
 585                 .compat = "fsl,p3041-clockgen",
 586                 .guts_compat = "fsl,qoriq-device-config-1.0",
 587                 .init_periph = p2041_init_periph,
 588                 .cmux_groups = {
 589                         &p2041_cmux_grp1, &p2041_cmux_grp2
 590                 },
 591                 .cmux_to_group = {
 592                         0, 0, 1, 1, -1
 593                 },
 594                 .pll_mask = 0x07,
 595         },
 596         {
 597                 .compat = "fsl,p4080-clockgen",
 598                 .guts_compat = "fsl,qoriq-device-config-1.0",
 599                 .init_periph = p4080_init_periph,
 600                 .cmux_groups = {
 601                         &p4080_cmux_grp1, &p4080_cmux_grp2
 602                 },
 603                 .cmux_to_group = {
 604                         0, 0, 0, 0, 1, 1, 1, 1
 605                 },
 606                 .pll_mask = 0x1f,
 607         },
 608         {
 609                 .compat = "fsl,p5020-clockgen",
 610                 .guts_compat = "fsl,qoriq-device-config-1.0",
 611                 .init_periph = p5020_init_periph,
 612                 .cmux_groups = {
 613                         &p2041_cmux_grp1, &p2041_cmux_grp2
 614                 },
 615                 .cmux_to_group = {
 616                         0, 1, -1
 617                 },
 618                 .pll_mask = 0x07,
 619         },
 620         {
 621                 .compat = "fsl,p5040-clockgen",
 622                 .guts_compat = "fsl,p5040-device-config",
 623                 .init_periph = p5040_init_periph,
 624                 .cmux_groups = {
 625                         &p5040_cmux_grp1, &p5040_cmux_grp2
 626                 },
 627                 .cmux_to_group = {
 628                         0, 0, 1, 1, -1
 629                 },
 630                 .pll_mask = 0x0f,
 631         },
 632         {
 633                 .compat = "fsl,t1023-clockgen",
 634                 .guts_compat = "fsl,t1023-device-config",
 635                 .init_periph = t1023_init_periph,
 636                 .cmux_groups = {
 637                         &t1023_cmux
 638                 },
 639                 .hwaccel = {
 640                         &t1023_hwa1, &t1023_hwa2
 641                 },
 642                 .cmux_to_group = {
 643                         0, 0, -1
 644                 },
 645                 .pll_mask = 0x03,
 646                 .flags = CG_PLL_8BIT,
 647         },
 648         {
 649                 .compat = "fsl,t1040-clockgen",
 650                 .guts_compat = "fsl,t1040-device-config",
 651                 .init_periph = t1040_init_periph,
 652                 .cmux_groups = {
 653                         &t1040_cmux
 654                 },
 655                 .cmux_to_group = {
 656                         0, 0, 0, 0, -1
 657                 },
 658                 .pll_mask = 0x07,
 659                 .flags = CG_PLL_8BIT,
 660         },
 661         {
 662                 .compat = "fsl,t2080-clockgen",
 663                 .guts_compat = "fsl,t2080-device-config",
 664                 .init_periph = t2080_init_periph,
 665                 .cmux_groups = {
 666                         &clockgen2_cmux_cga12
 667                 },
 668                 .hwaccel = {
 669                         &t2080_hwa1, &t2080_hwa2
 670                 },
 671                 .cmux_to_group = {
 672                         0, -1
 673                 },
 674                 .pll_mask = 0x07,
 675                 .flags = CG_PLL_8BIT,
 676         },
 677         {
 678                 .compat = "fsl,t4240-clockgen",
 679                 .guts_compat = "fsl,t4240-device-config",
 680                 .init_periph = t4240_init_periph,
 681                 .cmux_groups = {
 682                         &clockgen2_cmux_cga, &clockgen2_cmux_cgb
 683                 },
 684                 .hwaccel = {
 685                         &t4240_hwa1, NULL, NULL, &t4240_hwa4, &t4240_hwa5
 686                 },
 687                 .cmux_to_group = {
 688                         0, 0, 1, -1
 689                 },
 690                 .pll_mask = 0x3f,
 691                 .flags = CG_PLL_8BIT,
 692         },
 693         {},
 694 };
 695
 696 struct mux_hwclock {
 697         struct clk_hw hw;
 698         struct clockgen *cg;
 699         const struct clockgen_muxinfo *info;
 700         u32 __iomem *reg;
 701         u8 parent_to_clksel[NUM_MUX_PARENTS];
 702         s8 clksel_to_parent[NUM_MUX_PARENTS];
 703         int num_parents;
 704 };
 705
 706 #define to_mux_hwclock(p)       container_of(p, struct mux_hwclock, hw)
 707 #define CLKSEL_MASK             0x78000000
 708 #define CLKSEL_SHIFT            27
 709
 710 static int mux_set_parent(struct clk_hw *hw, u8 idx)
 711 {
 712         struct mux_hwclock *hwc = to_mux_hwclock(hw);
 713         u32 clksel;
 714
 715         if (idx >= hwc->num_parents)
 716                 return -EINVAL;
 717
 718         clksel = hwc->parent_to_clksel[idx];
 719         cg_out(hwc->cg, (clksel << CLKSEL_SHIFT) & CLKSEL_MASK, hwc->reg);
 720
 721         return 0;
 722 }
 723
 724 static u8 mux_get_parent(struct clk_hw *hw)
 725 {
 726         struct mux_hwclock *hwc = to_mux_hwclock(hw);
 727         u32 clksel;
 728         s8 ret;
 729
 730         clksel = (cg_in(hwc->cg, hwc->reg) & CLKSEL_MASK) >> CLKSEL_SHIFT;
 731
 732         ret = hwc->clksel_to_parent[clksel];
 733         if (ret < 0) {
 734                 pr_err("%s: mux at %p has bad clksel\n", __func__, hwc->reg);
 735                 return 0;
 736         }
 737
 738         return ret;
 739 }
 740
 741 static const struct clk_ops cmux_ops = {
 742         .get_parent = mux_get_parent,
 743         .set_parent = mux_set_parent,
 744 };
 745
 746 /*
 747  * Don't allow setting for now, as the clock options haven't been
 748  * sanitized for additional restrictions.
 749  */
 750 static const struct clk_ops hwaccel_ops = {
 751         .get_parent = mux_get_parent,
 752 };
 753
 754 static const struct clockgen_pll_div *get_pll_div(struct clockgen *cg,
 755                                                   struct mux_hwclock *hwc,
 756                                                   int idx)
 757 {
 758         int pll, div;
 759
 760         if (!(hwc->info->clksel[idx].flags & CLKSEL_VALID))
 761                 return NULL;
 762
 763         pll = hwc->info->clksel[idx].pll;
 764         div = hwc->info->clksel[idx].div;
 765
 766         return &cg->pll[pll].div[div];
 767 }
 768
 769 static struct clk * __init create_mux_common(struct clockgen *cg,
 770                                              struct mux_hwclock *hwc,
 771                                              const struct clk_ops *ops,
 772                                              unsigned long min_rate,
 773                                              unsigned long max_rate,
 774                                              unsigned long pct80_rate,
 775                                              const char *fmt, int idx)
 776 {
 777         struct clk_init_data init = {};
 778         struct clk *clk;
 779         const struct clockgen_pll_div *div;
 780         const char *parent_names[NUM_MUX_PARENTS];
 781         char name[32];
 782         int i, j;
 783
 784         snprintf(name, sizeof(name), fmt, idx);
 785
 786         for (i = 0, j = 0; i < NUM_MUX_PARENTS; i++) {
 787                 unsigned long rate;
 788
 789                 hwc->clksel_to_parent[i] = -1;
 790
 791                 div = get_pll_div(cg, hwc, i);
 792                 if (!div)
 793                         continue;
 794
 795                 rate = clk_get_rate(div->clk);
 796
 797                 if (hwc->info->clksel[i].flags & CLKSEL_80PCT &&
 798                     rate > pct80_rate)
 799                         continue;
 800                 if (rate < min_rate)
 801                         continue;
 802                 if (rate > max_rate)
 803                         continue;
 804
 805                 parent_names[j] = div->name;
 806                 hwc->parent_to_clksel[j] = i;
 807                 hwc->clksel_to_parent[i] = j;
 808                 j++;
 809         }
 810
 811         init.name = name;
 812         init.ops = ops;
 813         init.parent_names = parent_names;
 814         init.num_parents = hwc->num_parents = j;
 815         init.flags = 0;
 816         hwc->hw.init = &init;
 817         hwc->cg = cg;
 818
 819         clk = clk_register(NULL, &hwc->hw);
 820         if (IS_ERR(clk)) {
 821                 pr_err("%s: Couldn't register %s: %ld\n", __func__, name,
 822                        PTR_ERR(clk));
 823                 kfree(hwc);
 824                 return NULL;
 825         }
 826
 827         return clk;
 828 }
 829
 830 static struct clk * __init create_one_cmux(struct clockgen *cg, int idx)
 831 {
 832         struct mux_hwclock *hwc;
 833         const struct clockgen_pll_div *div;
 834         unsigned long plat_rate, min_rate;
 835         u64 max_rate, pct80_rate;
 836         u32 clksel;
 837
 838         hwc = kzalloc(sizeof(*hwc), GFP_KERNEL);
 839         if (!hwc)
 840                 return NULL;
 841
 842         if (cg->info.flags & CG_VER3)
 843                 hwc->reg = cg->regs + 0x70000 + 0x20 * idx;
 844         else
 845                 hwc->reg = cg->regs + 0x20 * idx;
 846
 847         hwc->info = cg->info.cmux_groups[cg->info.cmux_to_group[idx]];
 848
 849         /*
 850          * Find the rate for the default clksel, and treat it as the
 851          * maximum rated core frequency.  If this is an incorrect
 852          * assumption, certain clock options (possibly including the
 853          * default clksel) may be inappropriately excluded on certain
 854          * chips.
 855          */
 856         clksel = (cg_in(cg, hwc->reg) & CLKSEL_MASK) >> CLKSEL_SHIFT;
 857         div = get_pll_div(cg, hwc, clksel);
 858         if (!div) {
 859                 kfree(hwc);
 860                 return NULL;
 861         }
 862
 863         max_rate = clk_get_rate(div->clk);
 864         pct80_rate = max_rate * 8;
 865         do_div(pct80_rate, 10);
 866
 867         plat_rate = clk_get_rate(cg->pll[PLATFORM_PLL].div[PLL_DIV1].clk);
 868
 869         if (cg->info.flags & CG_CMUX_GE_PLAT)
 870                 min_rate = plat_rate;
 871         else
 872                 min_rate = plat_rate / 2;
 873
 874         return create_mux_common(cg, hwc, &cmux_ops, min_rate, max_rate,
 875                                  pct80_rate, "cg-cmux%d", idx);
 876 }
 877
 878 static struct clk * __init create_one_hwaccel(struct clockgen *cg, int idx)
 879 {
 880         struct mux_hwclock *hwc;
 881
 882         hwc = kzalloc(sizeof(*hwc), GFP_KERNEL);
 883         if (!hwc)
 884                 return NULL;
 885
 886         hwc->reg = cg->regs + 0x20 * idx + 0x10;
 887         hwc->info = cg->info.hwaccel[idx];
 888
 889         return create_mux_common(cg, hwc, &hwaccel_ops, 0, ULONG_MAX, 0,
 890                                  "cg-hwaccel%d", idx);
 891 }
 892
 893 static void __init create_muxes(struct clockgen *cg)
 894 {
 895         int i;
 896
 897         for (i = 0; i < ARRAY_SIZE(cg->cmux); i++) {
 898                 if (cg->info.cmux_to_group[i] < 0)
 899                         break;
 900                 if (cg->info.cmux_to_group[i] >=
 901                     ARRAY_SIZE(cg->info.cmux_groups)) {
 902                         WARN_ON_ONCE(1);
 903                         continue;
 904                 }
 905
 906                 cg->cmux[i] = create_one_cmux(cg, i);
 907         }
 908
 909         for (i = 0; i < ARRAY_SIZE(cg->hwaccel); i++) {
 910                 if (!cg->info.hwaccel[i])
 911                         continue;
 912
 913                 cg->hwaccel[i] = create_one_hwaccel(cg, i);
 914         }
 915 }
 916
 917 static void __init clockgen_init(struct device_node *np);
 918
 919 /*
 920  * Legacy nodes may get probed before the parent clockgen node.
 921  * It is assumed that device trees with legacy nodes will not
 922  * contain a "clocks" property -- otherwise the input clocks may
 923  * not be initialized at this point.
 924  */
 925 static void __init legacy_init_clockgen(struct device_node *np)
 926 {
 927         if (!clockgen.node)
 928                 clockgen_init(of_get_parent(np));
 929 }
 930
 931 /* Legacy node */
 932 static void __init core_mux_init(struct device_node *np)
 933 {
 934         struct clk *clk;
 935         struct resource res;
 936         int idx, rc;
 937
 938         legacy_init_clockgen(np);
 939
 940         if (of_address_to_resource(np, 0, &res))
 941                 return;
 942
 943         idx = (res.start & 0xf0) >> 5;
 944         clk = clockgen.cmux[idx];
 945
 946         rc = of_clk_add_provider(np, of_clk_src_simple_get, clk);
 947         if (rc) {
 948                 pr_err("%s: Couldn't register clk provider for node %pOFn: %d\n",
 949                        __func__, np, rc);
 950                 return;
 951         }
 952 }
 953
 954 static struct clk __init
 955 *sysclk_from_fixed(struct device_node *node, const char *name)
 956 {
 957         u32 rate;
 958
 959         if (of_property_read_u32(node, "clock-frequency", &rate))
 960                 return ERR_PTR(-ENODEV);
 961
 962         return clk_register_fixed_rate(NULL, name, NULL, 0, rate);
 963 }
 964
 965 static struct clk __init *input_clock(const char *name, struct clk *clk)
 966 {
 967         const char *input_name;
 968
 969         /* Register the input clock under the desired name. */
 970         input_name = __clk_get_name(clk);
 971         clk = clk_register_fixed_factor(NULL, name, input_name,
 972                                         0, 1, 1);
 973         if (IS_ERR(clk))
 974                 pr_err("%s: Couldn't register %s: %ld\n", __func__, name,
 975                        PTR_ERR(clk));
 976
 977         return clk;
 978 }
 979
 980 static struct clk __init *input_clock_by_name(const char *name,
 981                                               const char *dtname)
 982 {
 983         struct clk *clk;
 984
 985         clk = of_clk_get_by_name(clockgen.node, dtname);
 986         if (IS_ERR(clk))
 987                 return clk;
 988
 989         return input_clock(name, clk);
 990 }
 991
 992 static struct clk __init *input_clock_by_index(const char *name, int idx)
 993 {
 994         struct clk *clk;
 995
 996         clk = of_clk_get(clockgen.node, 0);
 997         if (IS_ERR(clk))
 998                 return clk;
 999
1000         return input_clock(name, clk);
1001 }
1002
1003 static struct clk * __init create_sysclk(const char *name)
1004 {
1005         struct device_node *sysclk;
1006         struct clk *clk;
1007
1008         clk = sysclk_from_fixed(clockgen.node, name);
1009         if (!IS_ERR(clk))
1010                 return clk;
1011
1012         clk = input_clock_by_name(name, "sysclk");
1013         if (!IS_ERR(clk))
1014                 return clk;
1015
1016         clk = input_clock_by_index(name, 0);
1017         if (!IS_ERR(clk))
1018                 return clk;
1019
1020         sysclk = of_get_child_by_name(clockgen.node, "sysclk");
1021         if (sysclk) {
1022                 clk = sysclk_from_fixed(sysclk, name);
1023                 if (!IS_ERR(clk))
1024                         return clk;
1025         }
1026
1027         pr_err("%s: No input sysclk\n", __func__);
1028         return NULL;
1029 }
1030
1031 static struct clk * __init create_coreclk(const char *name)
1032 {
1033         struct clk *clk;
1034
1035         clk = input_clock_by_name(name, "coreclk");
1036         if (!IS_ERR(clk))
1037                 return clk;
1038
1039         /*
1040          * This indicates a mix of legacy nodes with the new coreclk
1041          * mechanism, which should never happen.  If this error occurs,
1042          * don't use the wrong input clock just because coreclk isn't
1043          * ready yet.
1044          */
1045         if (WARN_ON(PTR_ERR(clk) == -EPROBE_DEFER))
1046                 return clk;
1047
1048         return NULL;
1049 }
1050
1051 /* Legacy node */
1052 static void __init sysclk_init(struct device_node *node)
1053 {
1054         struct clk *clk;
1055
1056         legacy_init_clockgen(node);
1057
1058         clk = clockgen.sysclk;
1059         if (clk)
1060                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
1061 }
1062
1063 #define PLL_KILL BIT(31)
1064
1065 static void __init create_one_pll(struct clockgen *cg, int idx)
1066 {
1067         u32 __iomem *reg;
1068         u32 mult;
1069         struct clockgen_pll *pll = &cg->pll[idx];
1070         const char *input = "cg-sysclk";
1071         int i;
1072
1073         if (!(cg->info.pll_mask & (1 << idx)))
1074                 return;
1075
1076         if (cg->coreclk && idx != PLATFORM_PLL) {
1077                 if (IS_ERR(cg->coreclk))
1078                         return;
1079
1080                 input = "cg-coreclk";
1081         }
1082
1083         if (cg->info.flags & CG_VER3) {
1084                 switch (idx) {
1085                 case PLATFORM_PLL:
1086                         reg = cg->regs + 0x60080;
1087                         break;
1088                 case CGA_PLL1:
1089                         reg = cg->regs + 0x80;
1090                         break;
1091                 case CGA_PLL2:
1092                         reg = cg->regs + 0xa0;
1093                         break;
1094                 case CGB_PLL1:
1095                         reg = cg->regs + 0x10080;
1096                         break;
1097                 case CGB_PLL2:
1098                         reg = cg->regs + 0x100a0;
1099                         break;
1100                 default:
1101                         WARN_ONCE(1, "index %d\n", idx);
1102                         return;
1103                 }
1104         } else {
1105                 if (idx == PLATFORM_PLL)
1106                         reg = cg->regs + 0xc00;
1107                 else
1108                         reg = cg->regs + 0x800 + 0x20 * (idx - 1);
1109         }
1110
1111         /* Get the multiple of PLL */
1112         mult = cg_in(cg, reg);
1113
1114         /* Check if this PLL is disabled */
1115         if (mult & PLL_KILL) {
1116                 pr_debug("%s(): pll %p disabled\n", __func__, reg);
1117                 return;
1118         }
1119
1120         if ((cg->info.flags & CG_VER3) ||
1121             ((cg->info.flags & CG_PLL_8BIT) && idx != PLATFORM_PLL))
1122                 mult = (mult & GENMASK(8, 1)) >> 1;
1123         else
1124                 mult = (mult & GENMASK(6, 1)) >> 1;
1125
1126         for (i = 0; i < ARRAY_SIZE(pll->div); i++) {
1127                 struct clk *clk;
1128                 int ret;
1129
1130                 /*
1131                  * For platform PLL, there are 8 divider clocks.
1132                  * For core PLL, there are 4 divider clocks at most.
1133                  */
1134                 if (idx != PLATFORM_PLL && i >= 4)
1135                         break;
1136
1137                 snprintf(pll->div[i].name, sizeof(pll->div[i].name),
1138                          "cg-pll%d-div%d", idx, i + 1);
1139
1140                 clk = clk_register_fixed_factor(NULL,
1141                                 pll->div[i].name, input, 0, mult, i + 1);
1142                 if (IS_ERR(clk)) {
1143                         pr_err("%s: %s: register failed %ld\n",
1144                                __func__, pll->div[i].name, PTR_ERR(clk));
1145                         continue;
1146                 }
1147
1148                 pll->div[i].clk = clk;
1149                 ret = clk_register_clkdev(clk, pll->div[i].name, NULL);
1150                 if (ret != 0)
1151                         pr_err("%s: %s: register to lookup table failed %ld\n",
1152                                __func__, pll->div[i].name, PTR_ERR(clk));
1153
1154         }
1155 }
1156
1157 static void __init create_plls(struct clockgen *cg)
1158 {
1159         int i;
1160
1161         for (i = 0; i < ARRAY_SIZE(cg->pll); i++)
1162                 create_one_pll(cg, i);
1163 }
1164
1165 static void __init legacy_pll_init(struct device_node *np, int idx)
1166 {
1167         struct clockgen_pll *pll;
1168         struct clk_onecell_data *onecell_data;
1169         struct clk **subclks;
1170         int count, rc;
1171
1172         legacy_init_clockgen(np);
1173
1174         pll = &clockgen.pll[idx];
1175         count = of_property_count_strings(np, "clock-output-names");
1176
1177         BUILD_BUG_ON(ARRAY_SIZE(pll->div) < 4);
1178         subclks = kcalloc(4, sizeof(struct clk *), GFP_KERNEL);
1179         if (!subclks)
1180                 return;
1181
1182         onecell_data = kmalloc(sizeof(*onecell_data), GFP_KERNEL);
1183         if (!onecell_data)
1184                 goto err_clks;
1185
1186         if (count <= 3) {
1187                 subclks[0] = pll->div[0].clk;
1188                 subclks[1] = pll->div[1].clk;
1189                 subclks[2] = pll->div[3].clk;
1190         } else {
1191                 subclks[0] = pll->div[0].clk;
1192                 subclks[1] = pll->div[1].clk;
1193                 subclks[2] = pll->div[2].clk;
1194                 subclks[3] = pll->div[3].clk;
1195         }
1196
1197         onecell_data->clks = subclks;
1198         onecell_data->clk_num = count;
1199
1200         rc = of_clk_add_provider(np, of_clk_src_onecell_get, onecell_data);
1201         if (rc) {
1202                 pr_err("%s: Couldn't register clk provider for node %pOFn: %d\n",
1203                        __func__, np, rc);
1204                 goto err_cell;
1205         }
1206
1207         return;
1208 err_cell:
1209         kfree(onecell_data);
1210 err_clks:
1211         kfree(subclks);
1212 }
1213
1214 /* Legacy node */
1215 static void __init pltfrm_pll_init(struct device_node *np)
1216 {
1217         legacy_pll_init(np, PLATFORM_PLL);
1218 }
1219
1220 /* Legacy node */
1221 static void __init core_pll_init(struct device_node *np)
1222 {
1223         struct resource res;
1224         int idx;
1225
1226         if (of_address_to_resource(np, 0, &res))
1227                 return;
1228
1229         if ((res.start & 0xfff) == 0xc00) {
1230                 /*
1231                  * ls1021a devtree labels the platform PLL
1232                  * with the core PLL compatible
1233                  */
1234                 pltfrm_pll_init(np);
1235         } else {
1236                 idx = (res.start & 0xf0) >> 5;
1237                 legacy_pll_init(np, CGA_PLL1 + idx);
1238         }
1239 }
1240
1241 static struct clk *clockgen_clk_get(struct of_phandle_args *clkspec, void *data)
1242 {
1243         struct clockgen *cg = data;
1244         struct clk *clk;
1245         struct clockgen_pll *pll;
1246         u32 type, idx;
1247
1248         if (clkspec->args_count < 2) {
1249                 pr_err("%s: insufficient phandle args\n", __func__);
1250                 return ERR_PTR(-EINVAL);
1251         }
1252
1253         type = clkspec->args[0];
1254         idx = clkspec->args[1];
1255
1256         switch (type) {
1257         case 0:
1258                 if (idx != 0)
1259                         goto bad_args;
1260                 clk = cg->sysclk;
1261                 break;
1262         case 1:
1263                 if (idx >= ARRAY_SIZE(cg->cmux))
1264                         goto bad_args;
1265                 clk = cg->cmux[idx];
1266                 break;
1267         case 2:
1268                 if (idx >= ARRAY_SIZE(cg->hwaccel))
1269                         goto bad_args;
1270                 clk = cg->hwaccel[idx];
1271                 break;
1272         case 3:
1273                 if (idx >= ARRAY_SIZE(cg->fman))
1274                         goto bad_args;
1275                 clk = cg->fman[idx];
1276                 break;
1277         case 4:
1278                 pll = &cg->pll[PLATFORM_PLL];
1279                 if (idx >= ARRAY_SIZE(pll->div))
1280                         goto bad_args;
1281                 clk = pll->div[idx].clk;
1282                 break;
1283         case 5:
1284                 if (idx != 0)
1285                         goto bad_args;
1286                 clk = cg->coreclk;
1287                 if (IS_ERR(clk))
1288                         clk = NULL;
1289                 break;
1290         default:
1291                 goto bad_args;
1292         }
1293
1294         if (!clk)
1295                 return ERR_PTR(-ENOENT);
1296         return clk;
1297
1298 bad_args:
1299         pr_err("%s: Bad phandle args %u %u\n", __func__, type, idx);
1300         return ERR_PTR(-EINVAL);
1301 }
1302
1303 #ifdef CONFIG_PPC
1304 #include <asm/mpc85xx.h>
1305
1306 static const u32 a4510_svrs[] __initconst = {
1307         (SVR_P2040 << 8) | 0x10,        /* P2040 1.0 */
1308         (SVR_P2040 << 8) | 0x11,        /* P2040 1.1 */
1309         (SVR_P2041 << 8) | 0x10,        /* P2041 1.0 */
1310         (SVR_P2041 << 8) | 0x11,        /* P2041 1.1 */
1311         (SVR_P3041 << 8) | 0x10,        /* P3041 1.0 */
1312         (SVR_P3041 << 8) | 0x11,        /* P3041 1.1 */
1313         (SVR_P4040 << 8) | 0x20,        /* P4040 2.0 */
1314         (SVR_P4080 << 8) | 0x20,        /* P4080 2.0 */
1315         (SVR_P5010 << 8) | 0x10,        /* P5010 1.0 */
1316         (SVR_P5010 << 8) | 0x20,        /* P5010 2.0 */
1317         (SVR_P5020 << 8) | 0x10,        /* P5020 1.0 */
1318         (SVR_P5021 << 8) | 0x10,        /* P5021 1.0 */
1319         (SVR_P5040 << 8) | 0x10,        /* P5040 1.0 */
1320 };
1321
1322 #define SVR_SECURITY    0x80000 /* The Security (E) bit */
1323
1324 static bool __init has_erratum_a4510(void)
1325 {
1326         u32 svr = mfspr(SPRN_SVR);
1327         int i;
1328
1329         svr &= ~SVR_SECURITY;
1330
1331         for (i = 0; i < ARRAY_SIZE(a4510_svrs); i++) {
1332                 if (svr == a4510_svrs[i])
1333                         return true;
1334         }
1335
1336         return false;
1337 }
1338 #else
1339 static bool __init has_erratum_a4510(void)
1340 {
1341         return false;
1342 }
1343 #endif
1344
1345 static void __init clockgen_init(struct device_node *np)
1346 {
1347         int i, ret;
1348         bool is_old_ls1021a = false;
1349
1350         /* May have already been called by a legacy probe */
1351         if (clockgen.node)
1352                 return;
1353
1354         clockgen.node = np;
1355         clockgen.regs = of_iomap(np, 0);
1356         if (!clockgen.regs &&
1357             of_device_is_compatible(of_root, "fsl,ls1021a")) {
1358                 /* Compatibility hack for old, broken device trees */
1359                 clockgen.regs = ioremap(0x1ee1000, 0x1000);
1360                 is_old_ls1021a = true;
1361         }
1362         if (!clockgen.regs) {
1363                 pr_err("%s(): %pOFn: of_iomap() failed\n", __func__, np);
1364                 return;
1365         }
1366
1367         for (i = 0; i < ARRAY_SIZE(chipinfo); i++) {
1368                 if (of_device_is_compatible(np, chipinfo[i].compat))
1369                         break;
1370                 if (is_old_ls1021a &&
1371                     !strcmp(chipinfo[i].compat, "fsl,ls1021a-clockgen"))
1372                         break;
1373         }
1374
1375         if (i == ARRAY_SIZE(chipinfo)) {
1376                 pr_err("%s: unknown clockgen node %pOF\n", __func__, np);
1377                 goto err;
1378         }
1379         clockgen.info = chipinfo[i];
1380
1381         if (clockgen.info.guts_compat) {
1382                 struct device_node *guts;
1383
1384                 guts = of_find_compatible_node(NULL, NULL,
1385                                                clockgen.info.guts_compat);
1386                 if (guts) {
1387                         clockgen.guts = of_iomap(guts, 0);
1388                         if (!clockgen.guts) {
1389                                 pr_err("%s: Couldn't map %pOF regs\n", __func__,
1390                                        guts);
1391                         }
1392                 }
1393
1394         }
1395
1396         if (has_erratum_a4510())
1397                 clockgen.info.flags |= CG_CMUX_GE_PLAT;
1398
1399         clockgen.sysclk = create_sysclk("cg-sysclk");
1400         clockgen.coreclk = create_coreclk("cg-coreclk");
1401         create_plls(&clockgen);
1402         create_muxes(&clockgen);
1403
1404         if (clockgen.info.init_periph)
1405                 clockgen.info.init_periph(&clockgen);
1406
1407         ret = of_clk_add_provider(np, clockgen_clk_get, &clockgen);
1408         if (ret) {
1409                 pr_err("%s: Couldn't register clk provider for node %pOFn: %d\n",
1410                        __func__, np, ret);
1411         }
1412
1413         return;
1414 err:
1415         iounmap(clockgen.regs);
1416         clockgen.regs = NULL;
1417 }
1418
1419 CLK_OF_DECLARE(qoriq_clockgen_1, "fsl,qoriq-clockgen-1.0", clockgen_init);
1420 CLK_OF_DECLARE(qoriq_clockgen_2, "fsl,qoriq-clockgen-2.0", clockgen_init);
1421 CLK_OF_DECLARE(qoriq_clockgen_ls1012a, "fsl,ls1012a-clockgen", clockgen_init);
1422 CLK_OF_DECLARE(qoriq_clockgen_ls1021a, "fsl,ls1021a-clockgen", clockgen_init);
1423 CLK_OF_DECLARE(qoriq_clockgen_ls1043a, "fsl,ls1043a-clockgen", clockgen_init);
1424 CLK_OF_DECLARE(qoriq_clockgen_ls1046a, "fsl,ls1046a-clockgen", clockgen_init);
1425 CLK_OF_DECLARE(qoriq_clockgen_ls1088a, "fsl,ls1088a-clockgen", clockgen_init);
1426 CLK_OF_DECLARE(qoriq_clockgen_ls2080a, "fsl,ls2080a-clockgen", clockgen_init);
1427
1428 /* Legacy nodes */
1429 CLK_OF_DECLARE(qoriq_sysclk_1, "fsl,qoriq-sysclk-1.0", sysclk_init);
1430 CLK_OF_DECLARE(qoriq_sysclk_2, "fsl,qoriq-sysclk-2.0", sysclk_init);
1431 CLK_OF_DECLARE(qoriq_core_pll_1, "fsl,qoriq-core-pll-1.0", core_pll_init);
1432 CLK_OF_DECLARE(qoriq_core_pll_2, "fsl,qoriq-core-pll-2.0", core_pll_init);
1433 CLK_OF_DECLARE(qoriq_core_mux_1, "fsl,qoriq-core-mux-1.0", core_mux_init);
1434 CLK_OF_DECLARE(qoriq_core_mux_2, "fsl,qoriq-core-mux-2.0", core_mux_init);
1435 CLK_OF_DECLARE(qoriq_pltfrm_pll_1, "fsl,qoriq-platform-pll-1.0", pltfrm_pll_init);
1436 CLK_OF_DECLARE(qoriq_pltfrm_pll_2, "fsl,qoriq-platform-pll-2.0", pltfrm_pll_init);