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