drivers/clk/at91/dt-compat.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/clk-provider.h>
   3 #include <linux/clk/at91_pmc.h>
   4 #include <linux/of.h>
   5 #include <linux/mfd/syscon.h>
   6 #include <linux/regmap.h>
   7 #include <linux/slab.h>
   8
   9 #include "pmc.h"
  10
  11 #define MASTER_SOURCE_MAX       4
  12
  13 #define PERIPHERAL_AT91RM9200   0
  14 #define PERIPHERAL_AT91SAM9X5   1
  15
  16 #define PERIPHERAL_MAX          64
  17
  18 #define PERIPHERAL_ID_MIN       2
  19
  20 #define PROG_SOURCE_MAX         5
  21 #define PROG_ID_MAX             7
  22
  23 #define SYSTEM_MAX_ID           31
  24
  25 #define GCK_INDEX_DT_AUDIO_PLL  5
  26
  27 static DEFINE_SPINLOCK(mck_lock);
  28
  29 #ifdef CONFIG_HAVE_AT91_AUDIO_PLL
  30 static void __init of_sama5d2_clk_audio_pll_frac_setup(struct device_node *np)
  31 {
  32         struct clk_hw *hw;
  33         const char *name = np->name;
  34         const char *parent_name;
  35         struct regmap *regmap;
  36
  37         regmap = syscon_node_to_regmap(of_get_parent(np));
  38         if (IS_ERR(regmap))
  39                 return;
  40
  41         parent_name = of_clk_get_parent_name(np, 0);
  42
  43         hw = at91_clk_register_audio_pll_frac(regmap, name, parent_name);
  44         if (IS_ERR(hw))
  45                 return;
  46
  47         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
  48 }
  49 CLK_OF_DECLARE(of_sama5d2_clk_audio_pll_frac_setup,
  50                "atmel,sama5d2-clk-audio-pll-frac",
  51                of_sama5d2_clk_audio_pll_frac_setup);
  52
  53 static void __init of_sama5d2_clk_audio_pll_pad_setup(struct device_node *np)
  54 {
  55         struct clk_hw *hw;
  56         const char *name = np->name;
  57         const char *parent_name;
  58         struct regmap *regmap;
  59
  60         regmap = syscon_node_to_regmap(of_get_parent(np));
  61         if (IS_ERR(regmap))
  62                 return;
  63
  64         parent_name = of_clk_get_parent_name(np, 0);
  65
  66         hw = at91_clk_register_audio_pll_pad(regmap, name, parent_name);
  67         if (IS_ERR(hw))
  68                 return;
  69
  70         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
  71 }
  72 CLK_OF_DECLARE(of_sama5d2_clk_audio_pll_pad_setup,
  73                "atmel,sama5d2-clk-audio-pll-pad",
  74                of_sama5d2_clk_audio_pll_pad_setup);
  75
  76 static void __init of_sama5d2_clk_audio_pll_pmc_setup(struct device_node *np)
  77 {
  78         struct clk_hw *hw;
  79         const char *name = np->name;
  80         const char *parent_name;
  81         struct regmap *regmap;
  82
  83         regmap = syscon_node_to_regmap(of_get_parent(np));
  84         if (IS_ERR(regmap))
  85                 return;
  86
  87         parent_name = of_clk_get_parent_name(np, 0);
  88
  89         hw = at91_clk_register_audio_pll_pmc(regmap, name, parent_name);
  90         if (IS_ERR(hw))
  91                 return;
  92
  93         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
  94 }
  95 CLK_OF_DECLARE(of_sama5d2_clk_audio_pll_pmc_setup,
  96                "atmel,sama5d2-clk-audio-pll-pmc",
  97                of_sama5d2_clk_audio_pll_pmc_setup);
  98 #endif /* CONFIG_HAVE_AT91_AUDIO_PLL */
  99
 100 static const struct clk_pcr_layout dt_pcr_layout = {
 101         .offset = 0x10c,
 102         .cmd = BIT(12),
 103         .pid_mask = GENMASK(5, 0),
 104         .div_mask = GENMASK(17, 16),
 105         .gckcss_mask = GENMASK(10, 8),
 106 };
 107
 108 #ifdef CONFIG_HAVE_AT91_GENERATED_CLK
 109 #define GENERATED_SOURCE_MAX    6
 110
 111 #define GCK_ID_I2S0             54
 112 #define GCK_ID_I2S1             55
 113 #define GCK_ID_CLASSD           59
 114
 115 static void __init of_sama5d2_clk_generated_setup(struct device_node *np)
 116 {
 117         int num;
 118         u32 id;
 119         const char *name;
 120         struct clk_hw *hw;
 121         unsigned int num_parents;
 122         const char *parent_names[GENERATED_SOURCE_MAX];
 123         struct device_node *gcknp;
 124         struct clk_range range = CLK_RANGE(0, 0);
 125         struct regmap *regmap;
 126
 127         num_parents = of_clk_get_parent_count(np);
 128         if (num_parents == 0 || num_parents > GENERATED_SOURCE_MAX)
 129                 return;
 130
 131         of_clk_parent_fill(np, parent_names, num_parents);
 132
 133         num = of_get_child_count(np);
 134         if (!num || num > PERIPHERAL_MAX)
 135                 return;
 136
 137         regmap = syscon_node_to_regmap(of_get_parent(np));
 138         if (IS_ERR(regmap))
 139                 return;
 140
 141         for_each_child_of_node(np, gcknp) {
 142                 int chg_pid = INT_MIN;
 143
 144                 if (of_property_read_u32(gcknp, "reg", &id))
 145                         continue;
 146
 147                 if (id < PERIPHERAL_ID_MIN || id >= PERIPHERAL_MAX)
 148                         continue;
 149
 150                 if (of_property_read_string(np, "clock-output-names", &name))
 151                         name = gcknp->name;
 152
 153                 of_at91_get_clk_range(gcknp, "atmel,clk-output-range",
 154                                       &range);
 155
 156                 if (of_device_is_compatible(np, "atmel,sama5d2-clk-generated") &&
 157                     (id == GCK_ID_I2S0 || id == GCK_ID_I2S1 ||
 158                      id == GCK_ID_CLASSD))
 159                         chg_pid = GCK_INDEX_DT_AUDIO_PLL;
 160
 161                 hw = at91_clk_register_generated(regmap, &pmc_pcr_lock,
 162                                                  &dt_pcr_layout, name,
 163                                                  parent_names, NULL,
 164                                                  num_parents, id, &range,
 165                                                  chg_pid);
 166                 if (IS_ERR(hw))
 167                         continue;
 168
 169                 of_clk_add_hw_provider(gcknp, of_clk_hw_simple_get, hw);
 170         }
 171 }
 172 CLK_OF_DECLARE(of_sama5d2_clk_generated_setup, "atmel,sama5d2-clk-generated",
 173                of_sama5d2_clk_generated_setup);
 174 #endif /* CONFIG_HAVE_AT91_GENERATED_CLK */
 175
 176 #ifdef CONFIG_HAVE_AT91_H32MX
 177 static void __init of_sama5d4_clk_h32mx_setup(struct device_node *np)
 178 {
 179         struct clk_hw *hw;
 180         const char *name = np->name;
 181         const char *parent_name;
 182         struct regmap *regmap;
 183
 184         regmap = syscon_node_to_regmap(of_get_parent(np));
 185         if (IS_ERR(regmap))
 186                 return;
 187
 188         parent_name = of_clk_get_parent_name(np, 0);
 189
 190         hw = at91_clk_register_h32mx(regmap, name, parent_name);
 191         if (IS_ERR(hw))
 192                 return;
 193
 194         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 195 }
 196 CLK_OF_DECLARE(of_sama5d4_clk_h32mx_setup, "atmel,sama5d4-clk-h32mx",
 197                of_sama5d4_clk_h32mx_setup);
 198 #endif /* CONFIG_HAVE_AT91_H32MX */
 199
 200 #ifdef CONFIG_HAVE_AT91_I2S_MUX_CLK
 201 #define I2S_BUS_NR      2
 202
 203 static void __init of_sama5d2_clk_i2s_mux_setup(struct device_node *np)
 204 {
 205         struct regmap *regmap_sfr;
 206         u8 bus_id;
 207         const char *parent_names[2];
 208         struct device_node *i2s_mux_np;
 209         struct clk_hw *hw;
 210         int ret;
 211
 212         regmap_sfr = syscon_regmap_lookup_by_compatible("atmel,sama5d2-sfr");
 213         if (IS_ERR(regmap_sfr))
 214                 return;
 215
 216         for_each_child_of_node(np, i2s_mux_np) {
 217                 if (of_property_read_u8(i2s_mux_np, "reg", &bus_id))
 218                         continue;
 219
 220                 if (bus_id > I2S_BUS_NR)
 221                         continue;
 222
 223                 ret = of_clk_parent_fill(i2s_mux_np, parent_names, 2);
 224                 if (ret != 2)
 225                         continue;
 226
 227                 hw = at91_clk_i2s_mux_register(regmap_sfr, i2s_mux_np->name,
 228                                                parent_names, 2, bus_id);
 229                 if (IS_ERR(hw))
 230                         continue;
 231
 232                 of_clk_add_hw_provider(i2s_mux_np, of_clk_hw_simple_get, hw);
 233         }
 234 }
 235 CLK_OF_DECLARE(sama5d2_clk_i2s_mux, "atmel,sama5d2-clk-i2s-mux",
 236                of_sama5d2_clk_i2s_mux_setup);
 237 #endif /* CONFIG_HAVE_AT91_I2S_MUX_CLK */
 238
 239 static void __init of_at91rm9200_clk_main_osc_setup(struct device_node *np)
 240 {
 241         struct clk_hw *hw;
 242         const char *name = np->name;
 243         const char *parent_name;
 244         struct regmap *regmap;
 245         bool bypass;
 246
 247         of_property_read_string(np, "clock-output-names", &name);
 248         bypass = of_property_read_bool(np, "atmel,osc-bypass");
 249         parent_name = of_clk_get_parent_name(np, 0);
 250
 251         regmap = syscon_node_to_regmap(of_get_parent(np));
 252         if (IS_ERR(regmap))
 253                 return;
 254
 255         hw = at91_clk_register_main_osc(regmap, name, parent_name, bypass);
 256         if (IS_ERR(hw))
 257                 return;
 258
 259         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 260 }
 261 CLK_OF_DECLARE(at91rm9200_clk_main_osc, "atmel,at91rm9200-clk-main-osc",
 262                of_at91rm9200_clk_main_osc_setup);
 263
 264 static void __init of_at91sam9x5_clk_main_rc_osc_setup(struct device_node *np)
 265 {
 266         struct clk_hw *hw;
 267         u32 frequency = 0;
 268         u32 accuracy = 0;
 269         const char *name = np->name;
 270         struct regmap *regmap;
 271
 272         of_property_read_string(np, "clock-output-names", &name);
 273         of_property_read_u32(np, "clock-frequency", &frequency);
 274         of_property_read_u32(np, "clock-accuracy", &accuracy);
 275
 276         regmap = syscon_node_to_regmap(of_get_parent(np));
 277         if (IS_ERR(regmap))
 278                 return;
 279
 280         hw = at91_clk_register_main_rc_osc(regmap, name, frequency, accuracy);
 281         if (IS_ERR(hw))
 282                 return;
 283
 284         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 285 }
 286 CLK_OF_DECLARE(at91sam9x5_clk_main_rc_osc, "atmel,at91sam9x5-clk-main-rc-osc",
 287                of_at91sam9x5_clk_main_rc_osc_setup);
 288
 289 static void __init of_at91rm9200_clk_main_setup(struct device_node *np)
 290 {
 291         struct clk_hw *hw;
 292         const char *parent_name;
 293         const char *name = np->name;
 294         struct regmap *regmap;
 295
 296         parent_name = of_clk_get_parent_name(np, 0);
 297         of_property_read_string(np, "clock-output-names", &name);
 298
 299         regmap = syscon_node_to_regmap(of_get_parent(np));
 300         if (IS_ERR(regmap))
 301                 return;
 302
 303         hw = at91_clk_register_rm9200_main(regmap, name, parent_name);
 304         if (IS_ERR(hw))
 305                 return;
 306
 307         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 308 }
 309 CLK_OF_DECLARE(at91rm9200_clk_main, "atmel,at91rm9200-clk-main",
 310                of_at91rm9200_clk_main_setup);
 311
 312 static void __init of_at91sam9x5_clk_main_setup(struct device_node *np)
 313 {
 314         struct clk_hw *hw;
 315         const char *parent_names[2];
 316         unsigned int num_parents;
 317         const char *name = np->name;
 318         struct regmap *regmap;
 319
 320         num_parents = of_clk_get_parent_count(np);
 321         if (num_parents == 0 || num_parents > 2)
 322                 return;
 323
 324         of_clk_parent_fill(np, parent_names, num_parents);
 325         regmap = syscon_node_to_regmap(of_get_parent(np));
 326         if (IS_ERR(regmap))
 327                 return;
 328
 329         of_property_read_string(np, "clock-output-names", &name);
 330
 331         hw = at91_clk_register_sam9x5_main(regmap, name, parent_names,
 332                                            num_parents);
 333         if (IS_ERR(hw))
 334                 return;
 335
 336         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 337 }
 338 CLK_OF_DECLARE(at91sam9x5_clk_main, "atmel,at91sam9x5-clk-main",
 339                of_at91sam9x5_clk_main_setup);
 340
 341 static struct clk_master_characteristics * __init
 342 of_at91_clk_master_get_characteristics(struct device_node *np)
 343 {
 344         struct clk_master_characteristics *characteristics;
 345
 346         characteristics = kzalloc(sizeof(*characteristics), GFP_KERNEL);
 347         if (!characteristics)
 348                 return NULL;
 349
 350         if (of_at91_get_clk_range(np, "atmel,clk-output-range", &characteristics->output))
 351                 goto out_free_characteristics;
 352
 353         of_property_read_u32_array(np, "atmel,clk-divisors",
 354                                    characteristics->divisors, 4);
 355
 356         characteristics->have_div3_pres =
 357                 of_property_read_bool(np, "atmel,master-clk-have-div3-pres");
 358
 359         return characteristics;
 360
 361 out_free_characteristics:
 362         kfree(characteristics);
 363         return NULL;
 364 }
 365
 366 static void __init
 367 of_at91_clk_master_setup(struct device_node *np,
 368                          const struct clk_master_layout *layout)
 369 {
 370         struct clk_hw *hw;
 371         unsigned int num_parents;
 372         const char *parent_names[MASTER_SOURCE_MAX];
 373         const char *name = np->name;
 374         struct clk_master_characteristics *characteristics;
 375         struct regmap *regmap;
 376
 377         num_parents = of_clk_get_parent_count(np);
 378         if (num_parents == 0 || num_parents > MASTER_SOURCE_MAX)
 379                 return;
 380
 381         of_clk_parent_fill(np, parent_names, num_parents);
 382
 383         of_property_read_string(np, "clock-output-names", &name);
 384
 385         characteristics = of_at91_clk_master_get_characteristics(np);
 386         if (!characteristics)
 387                 return;
 388
 389         regmap = syscon_node_to_regmap(of_get_parent(np));
 390         if (IS_ERR(regmap))
 391                 return;
 392
 393         hw = at91_clk_register_master_pres(regmap, "masterck_pres", num_parents,
 394                                            parent_names, layout,
 395                                            characteristics, &mck_lock,
 396                                            CLK_SET_RATE_GATE, INT_MIN);
 397         if (IS_ERR(hw))
 398                 goto out_free_characteristics;
 399
 400         hw = at91_clk_register_master_div(regmap, name, "masterck_pres",
 401                                           layout, characteristics,
 402                                           &mck_lock, CLK_SET_RATE_GATE);
 403         if (IS_ERR(hw))
 404                 goto out_free_characteristics;
 405
 406         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 407         return;
 408
 409 out_free_characteristics:
 410         kfree(characteristics);
 411 }
 412
 413 static void __init of_at91rm9200_clk_master_setup(struct device_node *np)
 414 {
 415         of_at91_clk_master_setup(np, &at91rm9200_master_layout);
 416 }
 417 CLK_OF_DECLARE(at91rm9200_clk_master, "atmel,at91rm9200-clk-master",
 418                of_at91rm9200_clk_master_setup);
 419
 420 static void __init of_at91sam9x5_clk_master_setup(struct device_node *np)
 421 {
 422         of_at91_clk_master_setup(np, &at91sam9x5_master_layout);
 423 }
 424 CLK_OF_DECLARE(at91sam9x5_clk_master, "atmel,at91sam9x5-clk-master",
 425                of_at91sam9x5_clk_master_setup);
 426
 427 static void __init
 428 of_at91_clk_periph_setup(struct device_node *np, u8 type)
 429 {
 430         int num;
 431         u32 id;
 432         struct clk_hw *hw;
 433         const char *parent_name;
 434         const char *name;
 435         struct device_node *periphclknp;
 436         struct regmap *regmap;
 437
 438         parent_name = of_clk_get_parent_name(np, 0);
 439         if (!parent_name)
 440                 return;
 441
 442         num = of_get_child_count(np);
 443         if (!num || num > PERIPHERAL_MAX)
 444                 return;
 445
 446         regmap = syscon_node_to_regmap(of_get_parent(np));
 447         if (IS_ERR(regmap))
 448                 return;
 449
 450         for_each_child_of_node(np, periphclknp) {
 451                 if (of_property_read_u32(periphclknp, "reg", &id))
 452                         continue;
 453
 454                 if (id >= PERIPHERAL_MAX)
 455                         continue;
 456
 457                 if (of_property_read_string(np, "clock-output-names", &name))
 458                         name = periphclknp->name;
 459
 460                 if (type == PERIPHERAL_AT91RM9200) {
 461                         hw = at91_clk_register_peripheral(regmap, name,
 462                                                           parent_name, id);
 463                 } else {
 464                         struct clk_range range = CLK_RANGE(0, 0);
 465
 466                         of_at91_get_clk_range(periphclknp,
 467                                               "atmel,clk-output-range",
 468                                               &range);
 469
 470                         hw = at91_clk_register_sam9x5_peripheral(regmap,
 471                                                                  &pmc_pcr_lock,
 472                                                                  &dt_pcr_layout,
 473                                                                  name,
 474                                                                  parent_name,
 475                                                                  id, &range,
 476                                                                  INT_MIN);
 477                 }
 478
 479                 if (IS_ERR(hw))
 480                         continue;
 481
 482                 of_clk_add_hw_provider(periphclknp, of_clk_hw_simple_get, hw);
 483         }
 484 }
 485
 486 static void __init of_at91rm9200_clk_periph_setup(struct device_node *np)
 487 {
 488         of_at91_clk_periph_setup(np, PERIPHERAL_AT91RM9200);
 489 }
 490 CLK_OF_DECLARE(at91rm9200_clk_periph, "atmel,at91rm9200-clk-peripheral",
 491                of_at91rm9200_clk_periph_setup);
 492
 493 static void __init of_at91sam9x5_clk_periph_setup(struct device_node *np)
 494 {
 495         of_at91_clk_periph_setup(np, PERIPHERAL_AT91SAM9X5);
 496 }
 497 CLK_OF_DECLARE(at91sam9x5_clk_periph, "atmel,at91sam9x5-clk-peripheral",
 498                of_at91sam9x5_clk_periph_setup);
 499
 500 static struct clk_pll_characteristics * __init
 501 of_at91_clk_pll_get_characteristics(struct device_node *np)
 502 {
 503         int i;
 504         int offset;
 505         u32 tmp;
 506         int num_output;
 507         u32 num_cells;
 508         struct clk_range input;
 509         struct clk_range *output;
 510         u8 *out = NULL;
 511         u16 *icpll = NULL;
 512         struct clk_pll_characteristics *characteristics;
 513
 514         if (of_at91_get_clk_range(np, "atmel,clk-input-range", &input))
 515                 return NULL;
 516
 517         if (of_property_read_u32(np, "#atmel,pll-clk-output-range-cells",
 518                                  &num_cells))
 519                 return NULL;
 520
 521         if (num_cells < 2 || num_cells > 4)
 522                 return NULL;
 523
 524         if (!of_get_property(np, "atmel,pll-clk-output-ranges", &tmp))
 525                 return NULL;
 526         num_output = tmp / (sizeof(u32) * num_cells);
 527
 528         characteristics = kzalloc(sizeof(*characteristics), GFP_KERNEL);
 529         if (!characteristics)
 530                 return NULL;
 531
 532         output = kcalloc(num_output, sizeof(*output), GFP_KERNEL);
 533         if (!output)
 534                 goto out_free_characteristics;
 535
 536         if (num_cells > 2) {
 537                 out = kcalloc(num_output, sizeof(*out), GFP_KERNEL);
 538                 if (!out)
 539                         goto out_free_output;
 540         }
 541
 542         if (num_cells > 3) {
 543                 icpll = kcalloc(num_output, sizeof(*icpll), GFP_KERNEL);
 544                 if (!icpll)
 545                         goto out_free_output;
 546         }
 547
 548         for (i = 0; i < num_output; i++) {
 549                 offset = i * num_cells;
 550                 if (of_property_read_u32_index(np,
 551                                                "atmel,pll-clk-output-ranges",
 552                                                offset, &tmp))
 553                         goto out_free_output;
 554                 output[i].min = tmp;
 555                 if (of_property_read_u32_index(np,
 556                                                "atmel,pll-clk-output-ranges",
 557                                                offset + 1, &tmp))
 558                         goto out_free_output;
 559                 output[i].max = tmp;
 560
 561                 if (num_cells == 2)
 562                         continue;
 563
 564                 if (of_property_read_u32_index(np,
 565                                                "atmel,pll-clk-output-ranges",
 566                                                offset + 2, &tmp))
 567                         goto out_free_output;
 568                 out[i] = tmp;
 569
 570                 if (num_cells == 3)
 571                         continue;
 572
 573                 if (of_property_read_u32_index(np,
 574                                                "atmel,pll-clk-output-ranges",
 575                                                offset + 3, &tmp))
 576                         goto out_free_output;
 577                 icpll[i] = tmp;
 578         }
 579
 580         characteristics->input = input;
 581         characteristics->num_output = num_output;
 582         characteristics->output = output;
 583         characteristics->out = out;
 584         characteristics->icpll = icpll;
 585         return characteristics;
 586
 587 out_free_output:
 588         kfree(icpll);
 589         kfree(out);
 590         kfree(output);
 591 out_free_characteristics:
 592         kfree(characteristics);
 593         return NULL;
 594 }
 595
 596 static void __init
 597 of_at91_clk_pll_setup(struct device_node *np,
 598                       const struct clk_pll_layout *layout)
 599 {
 600         u32 id;
 601         struct clk_hw *hw;
 602         struct regmap *regmap;
 603         const char *parent_name;
 604         const char *name = np->name;
 605         struct clk_pll_characteristics *characteristics;
 606
 607         if (of_property_read_u32(np, "reg", &id))
 608                 return;
 609
 610         parent_name = of_clk_get_parent_name(np, 0);
 611
 612         of_property_read_string(np, "clock-output-names", &name);
 613
 614         regmap = syscon_node_to_regmap(of_get_parent(np));
 615         if (IS_ERR(regmap))
 616                 return;
 617
 618         characteristics = of_at91_clk_pll_get_characteristics(np);
 619         if (!characteristics)
 620                 return;
 621
 622         hw = at91_clk_register_pll(regmap, name, parent_name, id, layout,
 623                                    characteristics);
 624         if (IS_ERR(hw))
 625                 goto out_free_characteristics;
 626
 627         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 628         return;
 629
 630 out_free_characteristics:
 631         kfree(characteristics);
 632 }
 633
 634 static void __init of_at91rm9200_clk_pll_setup(struct device_node *np)
 635 {
 636         of_at91_clk_pll_setup(np, &at91rm9200_pll_layout);
 637 }
 638 CLK_OF_DECLARE(at91rm9200_clk_pll, "atmel,at91rm9200-clk-pll",
 639                of_at91rm9200_clk_pll_setup);
 640
 641 static void __init of_at91sam9g45_clk_pll_setup(struct device_node *np)
 642 {
 643         of_at91_clk_pll_setup(np, &at91sam9g45_pll_layout);
 644 }
 645 CLK_OF_DECLARE(at91sam9g45_clk_pll, "atmel,at91sam9g45-clk-pll",
 646                of_at91sam9g45_clk_pll_setup);
 647
 648 static void __init of_at91sam9g20_clk_pllb_setup(struct device_node *np)
 649 {
 650         of_at91_clk_pll_setup(np, &at91sam9g20_pllb_layout);
 651 }
 652 CLK_OF_DECLARE(at91sam9g20_clk_pllb, "atmel,at91sam9g20-clk-pllb",
 653                of_at91sam9g20_clk_pllb_setup);
 654
 655 static void __init of_sama5d3_clk_pll_setup(struct device_node *np)
 656 {
 657         of_at91_clk_pll_setup(np, &sama5d3_pll_layout);
 658 }
 659 CLK_OF_DECLARE(sama5d3_clk_pll, "atmel,sama5d3-clk-pll",
 660                of_sama5d3_clk_pll_setup);
 661
 662 static void __init
 663 of_at91sam9x5_clk_plldiv_setup(struct device_node *np)
 664 {
 665         struct clk_hw *hw;
 666         const char *parent_name;
 667         const char *name = np->name;
 668         struct regmap *regmap;
 669
 670         parent_name = of_clk_get_parent_name(np, 0);
 671
 672         of_property_read_string(np, "clock-output-names", &name);
 673
 674         regmap = syscon_node_to_regmap(of_get_parent(np));
 675         if (IS_ERR(regmap))
 676                 return;
 677
 678         hw = at91_clk_register_plldiv(regmap, name, parent_name);
 679         if (IS_ERR(hw))
 680                 return;
 681
 682         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 683 }
 684 CLK_OF_DECLARE(at91sam9x5_clk_plldiv, "atmel,at91sam9x5-clk-plldiv",
 685                of_at91sam9x5_clk_plldiv_setup);
 686
 687 static void __init
 688 of_at91_clk_prog_setup(struct device_node *np,
 689                        const struct clk_programmable_layout *layout,
 690                        u32 *mux_table)
 691 {
 692         int num;
 693         u32 id;
 694         struct clk_hw *hw;
 695         unsigned int num_parents;
 696         const char *parent_names[PROG_SOURCE_MAX];
 697         const char *name;
 698         struct device_node *progclknp;
 699         struct regmap *regmap;
 700
 701         num_parents = of_clk_get_parent_count(np);
 702         if (num_parents == 0 || num_parents > PROG_SOURCE_MAX)
 703                 return;
 704
 705         of_clk_parent_fill(np, parent_names, num_parents);
 706
 707         num = of_get_child_count(np);
 708         if (!num || num > (PROG_ID_MAX + 1))
 709                 return;
 710
 711         regmap = syscon_node_to_regmap(of_get_parent(np));
 712         if (IS_ERR(regmap))
 713                 return;
 714
 715         for_each_child_of_node(np, progclknp) {
 716                 if (of_property_read_u32(progclknp, "reg", &id))
 717                         continue;
 718
 719                 if (of_property_read_string(np, "clock-output-names", &name))
 720                         name = progclknp->name;
 721
 722                 hw = at91_clk_register_programmable(regmap, name,
 723                                                     parent_names, num_parents,
 724                                                     id, layout, mux_table);
 725                 if (IS_ERR(hw))
 726                         continue;
 727
 728                 of_clk_add_hw_provider(progclknp, of_clk_hw_simple_get, hw);
 729         }
 730 }
 731
 732 static void __init of_at91rm9200_clk_prog_setup(struct device_node *np)
 733 {
 734         of_at91_clk_prog_setup(np, &at91rm9200_programmable_layout, NULL);
 735 }
 736 CLK_OF_DECLARE(at91rm9200_clk_prog, "atmel,at91rm9200-clk-programmable",
 737                of_at91rm9200_clk_prog_setup);
 738
 739 static void __init of_at91sam9g45_clk_prog_setup(struct device_node *np)
 740 {
 741         of_at91_clk_prog_setup(np, &at91sam9g45_programmable_layout, NULL);
 742 }
 743 CLK_OF_DECLARE(at91sam9g45_clk_prog, "atmel,at91sam9g45-clk-programmable",
 744                of_at91sam9g45_clk_prog_setup);
 745
 746 static void __init of_at91sam9x5_clk_prog_setup(struct device_node *np)
 747 {
 748         of_at91_clk_prog_setup(np, &at91sam9x5_programmable_layout, NULL);
 749 }
 750 CLK_OF_DECLARE(at91sam9x5_clk_prog, "atmel,at91sam9x5-clk-programmable",
 751                of_at91sam9x5_clk_prog_setup);
 752
 753 static void __init of_at91sam9260_clk_slow_setup(struct device_node *np)
 754 {
 755         struct clk_hw *hw;
 756         const char *parent_names[2];
 757         unsigned int num_parents;
 758         const char *name = np->name;
 759         struct regmap *regmap;
 760
 761         num_parents = of_clk_get_parent_count(np);
 762         if (num_parents != 2)
 763                 return;
 764
 765         of_clk_parent_fill(np, parent_names, num_parents);
 766         regmap = syscon_node_to_regmap(of_get_parent(np));
 767         if (IS_ERR(regmap))
 768                 return;
 769
 770         of_property_read_string(np, "clock-output-names", &name);
 771
 772         hw = at91_clk_register_sam9260_slow(regmap, name, parent_names,
 773                                             num_parents);
 774         if (IS_ERR(hw))
 775                 return;
 776
 777         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 778 }
 779 CLK_OF_DECLARE(at91sam9260_clk_slow, "atmel,at91sam9260-clk-slow",
 780                of_at91sam9260_clk_slow_setup);
 781
 782 #ifdef CONFIG_HAVE_AT91_SMD
 783 #define SMD_SOURCE_MAX          2
 784
 785 static void __init of_at91sam9x5_clk_smd_setup(struct device_node *np)
 786 {
 787         struct clk_hw *hw;
 788         unsigned int num_parents;
 789         const char *parent_names[SMD_SOURCE_MAX];
 790         const char *name = np->name;
 791         struct regmap *regmap;
 792
 793         num_parents = of_clk_get_parent_count(np);
 794         if (num_parents == 0 || num_parents > SMD_SOURCE_MAX)
 795                 return;
 796
 797         of_clk_parent_fill(np, parent_names, num_parents);
 798
 799         of_property_read_string(np, "clock-output-names", &name);
 800
 801         regmap = syscon_node_to_regmap(of_get_parent(np));
 802         if (IS_ERR(regmap))
 803                 return;
 804
 805         hw = at91sam9x5_clk_register_smd(regmap, name, parent_names,
 806                                          num_parents);
 807         if (IS_ERR(hw))
 808                 return;
 809
 810         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 811 }
 812 CLK_OF_DECLARE(at91sam9x5_clk_smd, "atmel,at91sam9x5-clk-smd",
 813                of_at91sam9x5_clk_smd_setup);
 814 #endif /* CONFIG_HAVE_AT91_SMD */
 815
 816 static void __init of_at91rm9200_clk_sys_setup(struct device_node *np)
 817 {
 818         int num;
 819         u32 id;
 820         struct clk_hw *hw;
 821         const char *name;
 822         struct device_node *sysclknp;
 823         const char *parent_name;
 824         struct regmap *regmap;
 825
 826         num = of_get_child_count(np);
 827         if (num > (SYSTEM_MAX_ID + 1))
 828                 return;
 829
 830         regmap = syscon_node_to_regmap(of_get_parent(np));
 831         if (IS_ERR(regmap))
 832                 return;
 833
 834         for_each_child_of_node(np, sysclknp) {
 835                 if (of_property_read_u32(sysclknp, "reg", &id))
 836                         continue;
 837
 838                 if (of_property_read_string(np, "clock-output-names", &name))
 839                         name = sysclknp->name;
 840
 841                 parent_name = of_clk_get_parent_name(sysclknp, 0);
 842
 843                 hw = at91_clk_register_system(regmap, name, parent_name, id);
 844                 if (IS_ERR(hw))
 845                         continue;
 846
 847                 of_clk_add_hw_provider(sysclknp, of_clk_hw_simple_get, hw);
 848         }
 849 }
 850 CLK_OF_DECLARE(at91rm9200_clk_sys, "atmel,at91rm9200-clk-system",
 851                of_at91rm9200_clk_sys_setup);
 852
 853 #ifdef CONFIG_HAVE_AT91_USB_CLK
 854 #define USB_SOURCE_MAX          2
 855
 856 static void __init of_at91sam9x5_clk_usb_setup(struct device_node *np)
 857 {
 858         struct clk_hw *hw;
 859         unsigned int num_parents;
 860         const char *parent_names[USB_SOURCE_MAX];
 861         const char *name = np->name;
 862         struct regmap *regmap;
 863
 864         num_parents = of_clk_get_parent_count(np);
 865         if (num_parents == 0 || num_parents > USB_SOURCE_MAX)
 866                 return;
 867
 868         of_clk_parent_fill(np, parent_names, num_parents);
 869
 870         of_property_read_string(np, "clock-output-names", &name);
 871
 872         regmap = syscon_node_to_regmap(of_get_parent(np));
 873         if (IS_ERR(regmap))
 874                 return;
 875
 876         hw = at91sam9x5_clk_register_usb(regmap, name, parent_names,
 877                                          num_parents);
 878         if (IS_ERR(hw))
 879                 return;
 880
 881         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 882 }
 883 CLK_OF_DECLARE(at91sam9x5_clk_usb, "atmel,at91sam9x5-clk-usb",
 884                of_at91sam9x5_clk_usb_setup);
 885
 886 static void __init of_at91sam9n12_clk_usb_setup(struct device_node *np)
 887 {
 888         struct clk_hw *hw;
 889         const char *parent_name;
 890         const char *name = np->name;
 891         struct regmap *regmap;
 892
 893         parent_name = of_clk_get_parent_name(np, 0);
 894         if (!parent_name)
 895                 return;
 896
 897         of_property_read_string(np, "clock-output-names", &name);
 898
 899         regmap = syscon_node_to_regmap(of_get_parent(np));
 900         if (IS_ERR(regmap))
 901                 return;
 902
 903         hw = at91sam9n12_clk_register_usb(regmap, name, parent_name);
 904         if (IS_ERR(hw))
 905                 return;
 906
 907         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 908 }
 909 CLK_OF_DECLARE(at91sam9n12_clk_usb, "atmel,at91sam9n12-clk-usb",
 910                of_at91sam9n12_clk_usb_setup);
 911
 912 static void __init of_at91rm9200_clk_usb_setup(struct device_node *np)
 913 {
 914         struct clk_hw *hw;
 915         const char *parent_name;
 916         const char *name = np->name;
 917         u32 divisors[4] = {0, 0, 0, 0};
 918         struct regmap *regmap;
 919
 920         parent_name = of_clk_get_parent_name(np, 0);
 921         if (!parent_name)
 922                 return;
 923
 924         of_property_read_u32_array(np, "atmel,clk-divisors", divisors, 4);
 925         if (!divisors[0])
 926                 return;
 927
 928         of_property_read_string(np, "clock-output-names", &name);
 929
 930         regmap = syscon_node_to_regmap(of_get_parent(np));
 931         if (IS_ERR(regmap))
 932                 return;
 933         hw = at91rm9200_clk_register_usb(regmap, name, parent_name, divisors);
 934         if (IS_ERR(hw))
 935                 return;
 936
 937         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 938 }
 939 CLK_OF_DECLARE(at91rm9200_clk_usb, "atmel,at91rm9200-clk-usb",
 940                of_at91rm9200_clk_usb_setup);
 941 #endif /* CONFIG_HAVE_AT91_USB_CLK */
 942
 943 #ifdef CONFIG_HAVE_AT91_UTMI
 944 static void __init of_at91sam9x5_clk_utmi_setup(struct device_node *np)
 945 {
 946         struct clk_hw *hw;
 947         const char *parent_name;
 948         const char *name = np->name;
 949         struct regmap *regmap_pmc, *regmap_sfr;
 950
 951         parent_name = of_clk_get_parent_name(np, 0);
 952
 953         of_property_read_string(np, "clock-output-names", &name);
 954
 955         regmap_pmc = syscon_node_to_regmap(of_get_parent(np));
 956         if (IS_ERR(regmap_pmc))
 957                 return;
 958
 959         /*
 960          * If the device supports different mainck rates, this value has to be
 961          * set in the UTMI Clock Trimming register.
 962          * - 9x5: mainck supports several rates but it is indicated that a
 963          *   12 MHz is needed in case of USB.
 964          * - sama5d3 and sama5d2: mainck supports several rates. Configuring
 965          *   the FREQ field of the UTMI Clock Trimming register is mandatory.
 966          * - sama5d4: mainck is at 12 MHz.
 967          *
 968          * We only need to retrieve sama5d3 or sama5d2 sfr regmap.
 969          */
 970         regmap_sfr = syscon_regmap_lookup_by_compatible("atmel,sama5d3-sfr");
 971         if (IS_ERR(regmap_sfr)) {
 972                 regmap_sfr = syscon_regmap_lookup_by_compatible("atmel,sama5d2-sfr");
 973                 if (IS_ERR(regmap_sfr))
 974                         regmap_sfr = NULL;
 975         }
 976
 977         hw = at91_clk_register_utmi(regmap_pmc, regmap_sfr, name, parent_name);
 978         if (IS_ERR(hw))
 979                 return;
 980
 981         of_clk_add_hw_provider(np, of_clk_hw_simple_get, hw);
 982 }
 983 CLK_OF_DECLARE(at91sam9x5_clk_utmi, "atmel,at91sam9x5-clk-utmi",
 984                of_at91sam9x5_clk_utmi_setup);
 985 #endif /* CONFIG_HAVE_AT91_UTMI */