1
2
3
4
5
6#ifndef __LINUX_CLK_PROVIDER_H
7#define __LINUX_CLK_PROVIDER_H
8
9#include <linux/of.h>
10#include <linux/of_clk.h>
11
12
13
14
15
16
17
18
19#define CLK_SET_RATE_GATE BIT(0)
20#define CLK_SET_PARENT_GATE BIT(1)
21#define CLK_SET_RATE_PARENT BIT(2)
22#define CLK_IGNORE_UNUSED BIT(3)
23
24
25#define CLK_GET_RATE_NOCACHE BIT(6)
26#define CLK_SET_RATE_NO_REPARENT BIT(7)
27#define CLK_GET_ACCURACY_NOCACHE BIT(8)
28#define CLK_RECALC_NEW_RATES BIT(9)
29#define CLK_SET_RATE_UNGATE BIT(10)
30#define CLK_IS_CRITICAL BIT(11)
31
32#define CLK_OPS_PARENT_ENABLE BIT(12)
33
34#define CLK_DUTY_CYCLE_PARENT BIT(13)
35
36struct clk;
37struct clk_hw;
38struct clk_core;
39struct dentry;
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55struct clk_rate_request {
56 unsigned long rate;
57 unsigned long min_rate;
58 unsigned long max_rate;
59 unsigned long best_parent_rate;
60 struct clk_hw *best_parent_hw;
61};
62
63
64
65
66
67
68
69struct clk_duty {
70 unsigned int num;
71 unsigned int den;
72};
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220struct clk_ops {
221 int (*prepare)(struct clk_hw *hw);
222 void (*unprepare)(struct clk_hw *hw);
223 int (*is_prepared)(struct clk_hw *hw);
224 void (*unprepare_unused)(struct clk_hw *hw);
225 int (*enable)(struct clk_hw *hw);
226 void (*disable)(struct clk_hw *hw);
227 int (*is_enabled)(struct clk_hw *hw);
228 void (*disable_unused)(struct clk_hw *hw);
229 int (*save_context)(struct clk_hw *hw);
230 void (*restore_context)(struct clk_hw *hw);
231 unsigned long (*recalc_rate)(struct clk_hw *hw,
232 unsigned long parent_rate);
233 long (*round_rate)(struct clk_hw *hw, unsigned long rate,
234 unsigned long *parent_rate);
235 int (*determine_rate)(struct clk_hw *hw,
236 struct clk_rate_request *req);
237 int (*set_parent)(struct clk_hw *hw, u8 index);
238 u8 (*get_parent)(struct clk_hw *hw);
239 int (*set_rate)(struct clk_hw *hw, unsigned long rate,
240 unsigned long parent_rate);
241 int (*set_rate_and_parent)(struct clk_hw *hw,
242 unsigned long rate,
243 unsigned long parent_rate, u8 index);
244 unsigned long (*recalc_accuracy)(struct clk_hw *hw,
245 unsigned long parent_accuracy);
246 int (*get_phase)(struct clk_hw *hw);
247 int (*set_phase)(struct clk_hw *hw, int degrees);
248 int (*get_duty_cycle)(struct clk_hw *hw,
249 struct clk_duty *duty);
250 int (*set_duty_cycle)(struct clk_hw *hw,
251 struct clk_duty *duty);
252 int (*init)(struct clk_hw *hw);
253 void (*terminate)(struct clk_hw *hw);
254 void (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
255};
256
257
258
259
260
261
262
263
264struct clk_parent_data {
265 const struct clk_hw *hw;
266 const char *fw_name;
267 const char *name;
268 int index;
269};
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285struct clk_init_data {
286 const char *name;
287 const struct clk_ops *ops;
288
289 const char * const *parent_names;
290 const struct clk_parent_data *parent_data;
291 const struct clk_hw **parent_hws;
292 u8 num_parents;
293 unsigned long flags;
294};
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312struct clk_hw {
313 struct clk_core *core;
314 struct clk *clk;
315 const struct clk_init_data *init;
316};
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338struct clk_fixed_rate {
339 struct clk_hw hw;
340 unsigned long fixed_rate;
341 unsigned long fixed_accuracy;
342 unsigned long flags;
343};
344
345#define CLK_FIXED_RATE_PARENT_ACCURACY BIT(0)
346
347extern const struct clk_ops clk_fixed_rate_ops;
348struct clk_hw *__clk_hw_register_fixed_rate(struct device *dev,
349 struct device_node *np, const char *name,
350 const char *parent_name, const struct clk_hw *parent_hw,
351 const struct clk_parent_data *parent_data, unsigned long flags,
352 unsigned long fixed_rate, unsigned long fixed_accuracy,
353 unsigned long clk_fixed_flags);
354struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
355 const char *parent_name, unsigned long flags,
356 unsigned long fixed_rate);
357
358
359
360
361
362
363
364
365
366#define clk_hw_register_fixed_rate(dev, name, parent_name, flags, fixed_rate) \
367 __clk_hw_register_fixed_rate((dev), NULL, (name), (parent_name), NULL, \
368 NULL, (flags), (fixed_rate), 0, 0)
369
370
371
372
373
374
375
376
377
378#define clk_hw_register_fixed_rate_parent_hw(dev, name, parent_hw, flags, \
379 fixed_rate) \
380 __clk_hw_register_fixed_rate((dev), NULL, (name), NULL, (parent_hw), \
381 NULL, (flags), (fixed_rate), 0, 0)
382
383
384
385
386
387
388
389
390
391#define clk_hw_register_fixed_rate_parent_data(dev, name, parent_hw, flags, \
392 fixed_rate) \
393 __clk_hw_register_fixed_rate((dev), NULL, (name), NULL, NULL, \
394 (parent_data), (flags), (fixed_rate), 0, \
395 0)
396
397
398
399
400
401
402
403
404
405
406#define clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name, \
407 flags, fixed_rate, \
408 fixed_accuracy) \
409 __clk_hw_register_fixed_rate((dev), NULL, (name), (parent_name), \
410 NULL, NULL, (flags), (fixed_rate), \
411 (fixed_accuracy), 0)
412
413
414
415
416
417
418
419
420
421
422#define clk_hw_register_fixed_rate_with_accuracy_parent_hw(dev, name, \
423 parent_hw, flags, fixed_rate, fixed_accuracy) \
424 __clk_hw_register_fixed_rate((dev), NULL, (name), NULL, (parent_hw) \
425 NULL, NULL, (flags), (fixed_rate), \
426 (fixed_accuracy), 0)
427
428
429
430
431
432
433
434
435
436
437#define clk_hw_register_fixed_rate_with_accuracy_parent_data(dev, name, \
438 parent_data, flags, fixed_rate, fixed_accuracy) \
439 __clk_hw_register_fixed_rate((dev), NULL, (name), NULL, NULL, \
440 (parent_data), NULL, (flags), \
441 (fixed_rate), (fixed_accuracy), 0)
442
443void clk_unregister_fixed_rate(struct clk *clk);
444void clk_hw_unregister_fixed_rate(struct clk_hw *hw);
445
446void of_fixed_clk_setup(struct device_node *np);
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471struct clk_gate {
472 struct clk_hw hw;
473 void __iomem *reg;
474 u8 bit_idx;
475 u8 flags;
476 spinlock_t *lock;
477};
478
479#define to_clk_gate(_hw) container_of(_hw, struct clk_gate, hw)
480
481#define CLK_GATE_SET_TO_DISABLE BIT(0)
482#define CLK_GATE_HIWORD_MASK BIT(1)
483#define CLK_GATE_BIG_ENDIAN BIT(2)
484
485extern const struct clk_ops clk_gate_ops;
486struct clk_hw *__clk_hw_register_gate(struct device *dev,
487 struct device_node *np, const char *name,
488 const char *parent_name, const struct clk_hw *parent_hw,
489 const struct clk_parent_data *parent_data,
490 unsigned long flags,
491 void __iomem *reg, u8 bit_idx,
492 u8 clk_gate_flags, spinlock_t *lock);
493struct clk *clk_register_gate(struct device *dev, const char *name,
494 const char *parent_name, unsigned long flags,
495 void __iomem *reg, u8 bit_idx,
496 u8 clk_gate_flags, spinlock_t *lock);
497
498
499
500
501
502
503
504
505
506
507
508#define clk_hw_register_gate(dev, name, parent_name, flags, reg, bit_idx, \
509 clk_gate_flags, lock) \
510 __clk_hw_register_gate((dev), NULL, (name), (parent_name), NULL, \
511 NULL, (flags), (reg), (bit_idx), \
512 (clk_gate_flags), (lock))
513
514
515
516
517
518
519
520
521
522
523
524
525#define clk_hw_register_gate_parent_hw(dev, name, parent_hw, flags, reg, \
526 bit_idx, clk_gate_flags, lock) \
527 __clk_hw_register_gate((dev), NULL, (name), NULL, (parent_hw), \
528 NULL, (flags), (reg), (bit_idx), \
529 (clk_gate_flags), (lock))
530
531
532
533
534
535
536
537
538
539
540
541
542#define clk_hw_register_gate_parent_data(dev, name, parent_data, flags, reg, \
543 bit_idx, clk_gate_flags, lock) \
544 __clk_hw_register_gate((dev), NULL, (name), NULL, NULL, (parent_data), \
545 (flags), (reg), (bit_idx), \
546 (clk_gate_flags), (lock))
547void clk_unregister_gate(struct clk *clk);
548void clk_hw_unregister_gate(struct clk_hw *hw);
549int clk_gate_is_enabled(struct clk_hw *hw);
550
551struct clk_div_table {
552 unsigned int val;
553 unsigned int div;
554};
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596struct clk_divider {
597 struct clk_hw hw;
598 void __iomem *reg;
599 u8 shift;
600 u8 width;
601 u8 flags;
602 const struct clk_div_table *table;
603 spinlock_t *lock;
604};
605
606#define clk_div_mask(width) ((1 << (width)) - 1)
607#define to_clk_divider(_hw) container_of(_hw, struct clk_divider, hw)
608
609#define CLK_DIVIDER_ONE_BASED BIT(0)
610#define CLK_DIVIDER_POWER_OF_TWO BIT(1)
611#define CLK_DIVIDER_ALLOW_ZERO BIT(2)
612#define CLK_DIVIDER_HIWORD_MASK BIT(3)
613#define CLK_DIVIDER_ROUND_CLOSEST BIT(4)
614#define CLK_DIVIDER_READ_ONLY BIT(5)
615#define CLK_DIVIDER_MAX_AT_ZERO BIT(6)
616#define CLK_DIVIDER_BIG_ENDIAN BIT(7)
617
618extern const struct clk_ops clk_divider_ops;
619extern const struct clk_ops clk_divider_ro_ops;
620
621unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate,
622 unsigned int val, const struct clk_div_table *table,
623 unsigned long flags, unsigned long width);
624long divider_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent,
625 unsigned long rate, unsigned long *prate,
626 const struct clk_div_table *table,
627 u8 width, unsigned long flags);
628long divider_ro_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent,
629 unsigned long rate, unsigned long *prate,
630 const struct clk_div_table *table, u8 width,
631 unsigned long flags, unsigned int val);
632int divider_determine_rate(struct clk_hw *hw, struct clk_rate_request *req,
633 const struct clk_div_table *table, u8 width,
634 unsigned long flags);
635int divider_ro_determine_rate(struct clk_hw *hw, struct clk_rate_request *req,
636 const struct clk_div_table *table, u8 width,
637 unsigned long flags, unsigned int val);
638int divider_get_val(unsigned long rate, unsigned long parent_rate,
639 const struct clk_div_table *table, u8 width,
640 unsigned long flags);
641
642struct clk_hw *__clk_hw_register_divider(struct device *dev,
643 struct device_node *np, const char *name,
644 const char *parent_name, const struct clk_hw *parent_hw,
645 const struct clk_parent_data *parent_data, unsigned long flags,
646 void __iomem *reg, u8 shift, u8 width, u8 clk_divider_flags,
647 const struct clk_div_table *table, spinlock_t *lock);
648struct clk_hw *__devm_clk_hw_register_divider(struct device *dev,
649 struct device_node *np, const char *name,
650 const char *parent_name, const struct clk_hw *parent_hw,
651 const struct clk_parent_data *parent_data, unsigned long flags,
652 void __iomem *reg, u8 shift, u8 width, u8 clk_divider_flags,
653 const struct clk_div_table *table, spinlock_t *lock);
654struct clk *clk_register_divider_table(struct device *dev, const char *name,
655 const char *parent_name, unsigned long flags,
656 void __iomem *reg, u8 shift, u8 width,
657 u8 clk_divider_flags, const struct clk_div_table *table,
658 spinlock_t *lock);
659
660
661
662
663
664
665
666
667
668
669
670
671#define clk_register_divider(dev, name, parent_name, flags, reg, shift, width, \
672 clk_divider_flags, lock) \
673 clk_register_divider_table((dev), (name), (parent_name), (flags), \
674 (reg), (shift), (width), \
675 (clk_divider_flags), NULL, (lock))
676
677
678
679
680
681
682
683
684
685
686
687
688#define clk_hw_register_divider(dev, name, parent_name, flags, reg, shift, \
689 width, clk_divider_flags, lock) \
690 __clk_hw_register_divider((dev), NULL, (name), (parent_name), NULL, \
691 NULL, (flags), (reg), (shift), (width), \
692 (clk_divider_flags), NULL, (lock))
693
694
695
696
697
698
699
700
701
702
703
704
705
706#define clk_hw_register_divider_parent_hw(dev, name, parent_hw, flags, reg, \
707 shift, width, clk_divider_flags, \
708 lock) \
709 __clk_hw_register_divider((dev), NULL, (name), NULL, (parent_hw), \
710 NULL, (flags), (reg), (shift), (width), \
711 (clk_divider_flags), NULL, (lock))
712
713
714
715
716
717
718
719
720
721
722
723
724
725#define clk_hw_register_divider_parent_data(dev, name, parent_data, flags, \
726 reg, shift, width, \
727 clk_divider_flags, lock) \
728 __clk_hw_register_divider((dev), NULL, (name), NULL, NULL, \
729 (parent_data), (flags), (reg), (shift), \
730 (width), (clk_divider_flags), NULL, (lock))
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745#define clk_hw_register_divider_table(dev, name, parent_name, flags, reg, \
746 shift, width, clk_divider_flags, table, \
747 lock) \
748 __clk_hw_register_divider((dev), NULL, (name), (parent_name), NULL, \
749 NULL, (flags), (reg), (shift), (width), \
750 (clk_divider_flags), (table), (lock))
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765#define clk_hw_register_divider_table_parent_hw(dev, name, parent_hw, flags, \
766 reg, shift, width, \
767 clk_divider_flags, table, \
768 lock) \
769 __clk_hw_register_divider((dev), NULL, (name), NULL, (parent_hw), \
770 NULL, (flags), (reg), (shift), (width), \
771 (clk_divider_flags), (table), (lock))
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786#define clk_hw_register_divider_table_parent_data(dev, name, parent_data, \
787 flags, reg, shift, width, \
788 clk_divider_flags, table, \
789 lock) \
790 __clk_hw_register_divider((dev), NULL, (name), NULL, NULL, \
791 (parent_data), (flags), (reg), (shift), \
792 (width), (clk_divider_flags), (table), \
793 (lock))
794
795
796
797
798
799
800
801
802
803
804
805
806#define devm_clk_hw_register_divider(dev, name, parent_name, flags, reg, shift, \
807 width, clk_divider_flags, lock) \
808 __devm_clk_hw_register_divider((dev), NULL, (name), (parent_name), NULL, \
809 NULL, (flags), (reg), (shift), (width), \
810 (clk_divider_flags), NULL, (lock))
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825#define devm_clk_hw_register_divider_table(dev, name, parent_name, flags, \
826 reg, shift, width, \
827 clk_divider_flags, table, lock) \
828 __devm_clk_hw_register_divider((dev), NULL, (name), (parent_name), \
829 NULL, NULL, (flags), (reg), (shift), \
830 (width), (clk_divider_flags), (table), \
831 (lock))
832
833void clk_unregister_divider(struct clk *clk);
834void clk_hw_unregister_divider(struct clk_hw *hw);
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865struct clk_mux {
866 struct clk_hw hw;
867 void __iomem *reg;
868 u32 *table;
869 u32 mask;
870 u8 shift;
871 u8 flags;
872 spinlock_t *lock;
873};
874
875#define to_clk_mux(_hw) container_of(_hw, struct clk_mux, hw)
876
877#define CLK_MUX_INDEX_ONE BIT(0)
878#define CLK_MUX_INDEX_BIT BIT(1)
879#define CLK_MUX_HIWORD_MASK BIT(2)
880#define CLK_MUX_READ_ONLY BIT(3)
881#define CLK_MUX_ROUND_CLOSEST BIT(4)
882#define CLK_MUX_BIG_ENDIAN BIT(5)
883
884extern const struct clk_ops clk_mux_ops;
885extern const struct clk_ops clk_mux_ro_ops;
886
887struct clk_hw *__clk_hw_register_mux(struct device *dev, struct device_node *np,
888 const char *name, u8 num_parents,
889 const char * const *parent_names,
890 const struct clk_hw **parent_hws,
891 const struct clk_parent_data *parent_data,
892 unsigned long flags, void __iomem *reg, u8 shift, u32 mask,
893 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
894struct clk_hw *__devm_clk_hw_register_mux(struct device *dev, struct device_node *np,
895 const char *name, u8 num_parents,
896 const char * const *parent_names,
897 const struct clk_hw **parent_hws,
898 const struct clk_parent_data *parent_data,
899 unsigned long flags, void __iomem *reg, u8 shift, u32 mask,
900 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
901struct clk *clk_register_mux_table(struct device *dev, const char *name,
902 const char * const *parent_names, u8 num_parents,
903 unsigned long flags, void __iomem *reg, u8 shift, u32 mask,
904 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
905
906#define clk_register_mux(dev, name, parent_names, num_parents, flags, reg, \
907 shift, width, clk_mux_flags, lock) \
908 clk_register_mux_table((dev), (name), (parent_names), (num_parents), \
909 (flags), (reg), (shift), BIT((width)) - 1, \
910 (clk_mux_flags), NULL, (lock))
911#define clk_hw_register_mux_table(dev, name, parent_names, num_parents, \
912 flags, reg, shift, mask, clk_mux_flags, \
913 table, lock) \
914 __clk_hw_register_mux((dev), NULL, (name), (num_parents), \
915 (parent_names), NULL, NULL, (flags), (reg), \
916 (shift), (mask), (clk_mux_flags), (table), \
917 (lock))
918#define clk_hw_register_mux(dev, name, parent_names, num_parents, flags, reg, \
919 shift, width, clk_mux_flags, lock) \
920 __clk_hw_register_mux((dev), NULL, (name), (num_parents), \
921 (parent_names), NULL, NULL, (flags), (reg), \
922 (shift), BIT((width)) - 1, (clk_mux_flags), \
923 NULL, (lock))
924#define clk_hw_register_mux_hws(dev, name, parent_hws, num_parents, flags, \
925 reg, shift, width, clk_mux_flags, lock) \
926 __clk_hw_register_mux((dev), NULL, (name), (num_parents), NULL, \
927 (parent_hws), NULL, (flags), (reg), (shift), \
928 BIT((width)) - 1, (clk_mux_flags), NULL, (lock))
929#define clk_hw_register_mux_parent_data(dev, name, parent_data, num_parents, \
930 flags, reg, shift, width, \
931 clk_mux_flags, lock) \
932 __clk_hw_register_mux((dev), NULL, (name), (num_parents), NULL, NULL, \
933 (parent_data), (flags), (reg), (shift), \
934 BIT((width)) - 1, (clk_mux_flags), NULL, (lock))
935#define devm_clk_hw_register_mux(dev, name, parent_names, num_parents, flags, reg, \
936 shift, width, clk_mux_flags, lock) \
937 __devm_clk_hw_register_mux((dev), NULL, (name), (num_parents), \
938 (parent_names), NULL, NULL, (flags), (reg), \
939 (shift), BIT((width)) - 1, (clk_mux_flags), \
940 NULL, (lock))
941
942int clk_mux_val_to_index(struct clk_hw *hw, u32 *table, unsigned int flags,
943 unsigned int val);
944unsigned int clk_mux_index_to_val(u32 *table, unsigned int flags, u8 index);
945
946void clk_unregister_mux(struct clk *clk);
947void clk_hw_unregister_mux(struct clk_hw *hw);
948
949void of_fixed_factor_clk_setup(struct device_node *node);
950
951
952
953
954
955
956
957
958
959
960
961
962
963struct clk_fixed_factor {
964 struct clk_hw hw;
965 unsigned int mult;
966 unsigned int div;
967};
968
969#define to_clk_fixed_factor(_hw) container_of(_hw, struct clk_fixed_factor, hw)
970
971extern const struct clk_ops clk_fixed_factor_ops;
972struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
973 const char *parent_name, unsigned long flags,
974 unsigned int mult, unsigned int div);
975void clk_unregister_fixed_factor(struct clk *clk);
976struct clk_hw *clk_hw_register_fixed_factor(struct device *dev,
977 const char *name, const char *parent_name, unsigned long flags,
978 unsigned int mult, unsigned int div);
979void clk_hw_unregister_fixed_factor(struct clk_hw *hw);
980struct clk_hw *devm_clk_hw_register_fixed_factor(struct device *dev,
981 const char *name, const char *parent_name, unsigned long flags,
982 unsigned int mult, unsigned int div);
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011struct clk_fractional_divider {
1012 struct clk_hw hw;
1013 void __iomem *reg;
1014 u8 mshift;
1015 u8 mwidth;
1016 u32 mmask;
1017 u8 nshift;
1018 u8 nwidth;
1019 u32 nmask;
1020 u8 flags;
1021 void (*approximation)(struct clk_hw *hw,
1022 unsigned long rate, unsigned long *parent_rate,
1023 unsigned long *m, unsigned long *n);
1024 spinlock_t *lock;
1025};
1026
1027#define to_clk_fd(_hw) container_of(_hw, struct clk_fractional_divider, hw)
1028
1029#define CLK_FRAC_DIVIDER_ZERO_BASED BIT(0)
1030#define CLK_FRAC_DIVIDER_BIG_ENDIAN BIT(1)
1031#define CLK_FRAC_DIVIDER_POWER_OF_TWO_PS BIT(2)
1032
1033struct clk *clk_register_fractional_divider(struct device *dev,
1034 const char *name, const char *parent_name, unsigned long flags,
1035 void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
1036 u8 clk_divider_flags, spinlock_t *lock);
1037struct clk_hw *clk_hw_register_fractional_divider(struct device *dev,
1038 const char *name, const char *parent_name, unsigned long flags,
1039 void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
1040 u8 clk_divider_flags, spinlock_t *lock);
1041void clk_hw_unregister_fractional_divider(struct clk_hw *hw);
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067struct clk_multiplier {
1068 struct clk_hw hw;
1069 void __iomem *reg;
1070 u8 shift;
1071 u8 width;
1072 u8 flags;
1073 spinlock_t *lock;
1074};
1075
1076#define to_clk_multiplier(_hw) container_of(_hw, struct clk_multiplier, hw)
1077
1078#define CLK_MULTIPLIER_ZERO_BYPASS BIT(0)
1079#define CLK_MULTIPLIER_ROUND_CLOSEST BIT(1)
1080#define CLK_MULTIPLIER_BIG_ENDIAN BIT(2)
1081
1082extern const struct clk_ops clk_multiplier_ops;
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095struct clk_composite {
1096 struct clk_hw hw;
1097 struct clk_ops ops;
1098
1099 struct clk_hw *mux_hw;
1100 struct clk_hw *rate_hw;
1101 struct clk_hw *gate_hw;
1102
1103 const struct clk_ops *mux_ops;
1104 const struct clk_ops *rate_ops;
1105 const struct clk_ops *gate_ops;
1106};
1107
1108#define to_clk_composite(_hw) container_of(_hw, struct clk_composite, hw)
1109
1110struct clk *clk_register_composite(struct device *dev, const char *name,
1111 const char * const *parent_names, int num_parents,
1112 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
1113 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
1114 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
1115 unsigned long flags);
1116struct clk *clk_register_composite_pdata(struct device *dev, const char *name,
1117 const struct clk_parent_data *parent_data, int num_parents,
1118 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
1119 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
1120 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
1121 unsigned long flags);
1122void clk_unregister_composite(struct clk *clk);
1123struct clk_hw *clk_hw_register_composite(struct device *dev, const char *name,
1124 const char * const *parent_names, int num_parents,
1125 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
1126 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
1127 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
1128 unsigned long flags);
1129struct clk_hw *clk_hw_register_composite_pdata(struct device *dev,
1130 const char *name,
1131 const struct clk_parent_data *parent_data, int num_parents,
1132 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
1133 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
1134 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
1135 unsigned long flags);
1136struct clk_hw *devm_clk_hw_register_composite_pdata(struct device *dev,
1137 const char *name, const struct clk_parent_data *parent_data,
1138 int num_parents,
1139 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
1140 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
1141 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
1142 unsigned long flags);
1143void clk_hw_unregister_composite(struct clk_hw *hw);
1144
1145struct clk *clk_register(struct device *dev, struct clk_hw *hw);
1146struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw);
1147
1148int __must_check clk_hw_register(struct device *dev, struct clk_hw *hw);
1149int __must_check devm_clk_hw_register(struct device *dev, struct clk_hw *hw);
1150int __must_check of_clk_hw_register(struct device_node *node, struct clk_hw *hw);
1151
1152void clk_unregister(struct clk *clk);
1153void devm_clk_unregister(struct device *dev, struct clk *clk);
1154
1155void clk_hw_unregister(struct clk_hw *hw);
1156void devm_clk_hw_unregister(struct device *dev, struct clk_hw *hw);
1157
1158
1159const char *__clk_get_name(const struct clk *clk);
1160const char *clk_hw_get_name(const struct clk_hw *hw);
1161#ifdef CONFIG_COMMON_CLK
1162struct clk_hw *__clk_get_hw(struct clk *clk);
1163#else
1164static inline struct clk_hw *__clk_get_hw(struct clk *clk)
1165{
1166 return (struct clk_hw *)clk;
1167}
1168#endif
1169
1170struct clk *clk_hw_get_clk(struct clk_hw *hw, const char *con_id);
1171struct clk *devm_clk_hw_get_clk(struct device *dev, struct clk_hw *hw,
1172 const char *con_id);
1173
1174unsigned int clk_hw_get_num_parents(const struct clk_hw *hw);
1175struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw);
1176struct clk_hw *clk_hw_get_parent_by_index(const struct clk_hw *hw,
1177 unsigned int index);
1178int clk_hw_get_parent_index(struct clk_hw *hw);
1179int clk_hw_set_parent(struct clk_hw *hw, struct clk_hw *new_parent);
1180unsigned int __clk_get_enable_count(struct clk *clk);
1181unsigned long clk_hw_get_rate(const struct clk_hw *hw);
1182unsigned long clk_hw_get_flags(const struct clk_hw *hw);
1183#define clk_hw_can_set_rate_parent(hw) \
1184 (clk_hw_get_flags((hw)) & CLK_SET_RATE_PARENT)
1185
1186bool clk_hw_is_prepared(const struct clk_hw *hw);
1187bool clk_hw_rate_is_protected(const struct clk_hw *hw);
1188bool clk_hw_is_enabled(const struct clk_hw *hw);
1189bool __clk_is_enabled(struct clk *clk);
1190struct clk *__clk_lookup(const char *name);
1191int __clk_mux_determine_rate(struct clk_hw *hw,
1192 struct clk_rate_request *req);
1193int __clk_determine_rate(struct clk_hw *core, struct clk_rate_request *req);
1194int __clk_mux_determine_rate_closest(struct clk_hw *hw,
1195 struct clk_rate_request *req);
1196int clk_mux_determine_rate_flags(struct clk_hw *hw,
1197 struct clk_rate_request *req,
1198 unsigned long flags);
1199void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent);
1200void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
1201 unsigned long max_rate);
1202
1203static inline void __clk_hw_set_clk(struct clk_hw *dst, struct clk_hw *src)
1204{
1205 dst->clk = src->clk;
1206 dst->core = src->core;
1207}
1208
1209static inline long divider_round_rate(struct clk_hw *hw, unsigned long rate,
1210 unsigned long *prate,
1211 const struct clk_div_table *table,
1212 u8 width, unsigned long flags)
1213{
1214 return divider_round_rate_parent(hw, clk_hw_get_parent(hw),
1215 rate, prate, table, width, flags);
1216}
1217
1218static inline long divider_ro_round_rate(struct clk_hw *hw, unsigned long rate,
1219 unsigned long *prate,
1220 const struct clk_div_table *table,
1221 u8 width, unsigned long flags,
1222 unsigned int val)
1223{
1224 return divider_ro_round_rate_parent(hw, clk_hw_get_parent(hw),
1225 rate, prate, table, width, flags,
1226 val);
1227}
1228
1229
1230
1231
1232unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate);
1233
1234struct clk_onecell_data {
1235 struct clk **clks;
1236 unsigned int clk_num;
1237};
1238
1239struct clk_hw_onecell_data {
1240 unsigned int num;
1241 struct clk_hw *hws[];
1242};
1243
1244#define CLK_OF_DECLARE(name, compat, fn) OF_DECLARE_1(clk, name, compat, fn)
1245
1246
1247
1248
1249
1250#define CLK_OF_DECLARE_DRIVER(name, compat, fn) \
1251 static void __init name##_of_clk_init_driver(struct device_node *np) \
1252 { \
1253 of_node_clear_flag(np, OF_POPULATED); \
1254 fn(np); \
1255 } \
1256 OF_DECLARE_1(clk, name, compat, name##_of_clk_init_driver)
1257
1258#define CLK_HW_INIT(_name, _parent, _ops, _flags) \
1259 (&(struct clk_init_data) { \
1260 .flags = _flags, \
1261 .name = _name, \
1262 .parent_names = (const char *[]) { _parent }, \
1263 .num_parents = 1, \
1264 .ops = _ops, \
1265 })
1266
1267#define CLK_HW_INIT_HW(_name, _parent, _ops, _flags) \
1268 (&(struct clk_init_data) { \
1269 .flags = _flags, \
1270 .name = _name, \
1271 .parent_hws = (const struct clk_hw*[]) { _parent }, \
1272 .num_parents = 1, \
1273 .ops = _ops, \
1274 })
1275
1276
1277
1278
1279
1280
1281#define CLK_HW_INIT_HWS(_name, _parent, _ops, _flags) \
1282 (&(struct clk_init_data) { \
1283 .flags = _flags, \
1284 .name = _name, \
1285 .parent_hws = _parent, \
1286 .num_parents = 1, \
1287 .ops = _ops, \
1288 })
1289
1290#define CLK_HW_INIT_FW_NAME(_name, _parent, _ops, _flags) \
1291 (&(struct clk_init_data) { \
1292 .flags = _flags, \
1293 .name = _name, \
1294 .parent_data = (const struct clk_parent_data[]) { \
1295 { .fw_name = _parent }, \
1296 }, \
1297 .num_parents = 1, \
1298 .ops = _ops, \
1299 })
1300
1301#define CLK_HW_INIT_PARENTS(_name, _parents, _ops, _flags) \
1302 (&(struct clk_init_data) { \
1303 .flags = _flags, \
1304 .name = _name, \
1305 .parent_names = _parents, \
1306 .num_parents = ARRAY_SIZE(_parents), \
1307 .ops = _ops, \
1308 })
1309
1310#define CLK_HW_INIT_PARENTS_HW(_name, _parents, _ops, _flags) \
1311 (&(struct clk_init_data) { \
1312 .flags = _flags, \
1313 .name = _name, \
1314 .parent_hws = _parents, \
1315 .num_parents = ARRAY_SIZE(_parents), \
1316 .ops = _ops, \
1317 })
1318
1319#define CLK_HW_INIT_PARENTS_DATA(_name, _parents, _ops, _flags) \
1320 (&(struct clk_init_data) { \
1321 .flags = _flags, \
1322 .name = _name, \
1323 .parent_data = _parents, \
1324 .num_parents = ARRAY_SIZE(_parents), \
1325 .ops = _ops, \
1326 })
1327
1328#define CLK_HW_INIT_NO_PARENT(_name, _ops, _flags) \
1329 (&(struct clk_init_data) { \
1330 .flags = _flags, \
1331 .name = _name, \
1332 .parent_names = NULL, \
1333 .num_parents = 0, \
1334 .ops = _ops, \
1335 })
1336
1337#define CLK_FIXED_FACTOR(_struct, _name, _parent, \
1338 _div, _mult, _flags) \
1339 struct clk_fixed_factor _struct = { \
1340 .div = _div, \
1341 .mult = _mult, \
1342 .hw.init = CLK_HW_INIT(_name, \
1343 _parent, \
1344 &clk_fixed_factor_ops, \
1345 _flags), \
1346 }
1347
1348#define CLK_FIXED_FACTOR_HW(_struct, _name, _parent, \
1349 _div, _mult, _flags) \
1350 struct clk_fixed_factor _struct = { \
1351 .div = _div, \
1352 .mult = _mult, \
1353 .hw.init = CLK_HW_INIT_HW(_name, \
1354 _parent, \
1355 &clk_fixed_factor_ops, \
1356 _flags), \
1357 }
1358
1359
1360
1361
1362
1363#define CLK_FIXED_FACTOR_HWS(_struct, _name, _parent, \
1364 _div, _mult, _flags) \
1365 struct clk_fixed_factor _struct = { \
1366 .div = _div, \
1367 .mult = _mult, \
1368 .hw.init = CLK_HW_INIT_HWS(_name, \
1369 _parent, \
1370 &clk_fixed_factor_ops, \
1371 _flags), \
1372 }
1373
1374#define CLK_FIXED_FACTOR_FW_NAME(_struct, _name, _parent, \
1375 _div, _mult, _flags) \
1376 struct clk_fixed_factor _struct = { \
1377 .div = _div, \
1378 .mult = _mult, \
1379 .hw.init = CLK_HW_INIT_FW_NAME(_name, \
1380 _parent, \
1381 &clk_fixed_factor_ops, \
1382 _flags), \
1383 }
1384
1385#ifdef CONFIG_OF
1386int of_clk_add_provider(struct device_node *np,
1387 struct clk *(*clk_src_get)(struct of_phandle_args *args,
1388 void *data),
1389 void *data);
1390int of_clk_add_hw_provider(struct device_node *np,
1391 struct clk_hw *(*get)(struct of_phandle_args *clkspec,
1392 void *data),
1393 void *data);
1394int devm_of_clk_add_hw_provider(struct device *dev,
1395 struct clk_hw *(*get)(struct of_phandle_args *clkspec,
1396 void *data),
1397 void *data);
1398void of_clk_del_provider(struct device_node *np);
1399void devm_of_clk_del_provider(struct device *dev);
1400struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
1401 void *data);
1402struct clk_hw *of_clk_hw_simple_get(struct of_phandle_args *clkspec,
1403 void *data);
1404struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
1405struct clk_hw *of_clk_hw_onecell_get(struct of_phandle_args *clkspec,
1406 void *data);
1407int of_clk_parent_fill(struct device_node *np, const char **parents,
1408 unsigned int size);
1409int of_clk_detect_critical(struct device_node *np, int index,
1410 unsigned long *flags);
1411
1412#else
1413
1414static inline int of_clk_add_provider(struct device_node *np,
1415 struct clk *(*clk_src_get)(struct of_phandle_args *args,
1416 void *data),
1417 void *data)
1418{
1419 return 0;
1420}
1421static inline int of_clk_add_hw_provider(struct device_node *np,
1422 struct clk_hw *(*get)(struct of_phandle_args *clkspec,
1423 void *data),
1424 void *data)
1425{
1426 return 0;
1427}
1428static inline int devm_of_clk_add_hw_provider(struct device *dev,
1429 struct clk_hw *(*get)(struct of_phandle_args *clkspec,
1430 void *data),
1431 void *data)
1432{
1433 return 0;
1434}
1435static inline void of_clk_del_provider(struct device_node *np) {}
1436static inline void devm_of_clk_del_provider(struct device *dev) {}
1437static inline struct clk *of_clk_src_simple_get(
1438 struct of_phandle_args *clkspec, void *data)
1439{
1440 return ERR_PTR(-ENOENT);
1441}
1442static inline struct clk_hw *
1443of_clk_hw_simple_get(struct of_phandle_args *clkspec, void *data)
1444{
1445 return ERR_PTR(-ENOENT);
1446}
1447static inline struct clk *of_clk_src_onecell_get(
1448 struct of_phandle_args *clkspec, void *data)
1449{
1450 return ERR_PTR(-ENOENT);
1451}
1452static inline struct clk_hw *
1453of_clk_hw_onecell_get(struct of_phandle_args *clkspec, void *data)
1454{
1455 return ERR_PTR(-ENOENT);
1456}
1457static inline int of_clk_parent_fill(struct device_node *np,
1458 const char **parents, unsigned int size)
1459{
1460 return 0;
1461}
1462static inline int of_clk_detect_critical(struct device_node *np, int index,
1463 unsigned long *flags)
1464{
1465 return 0;
1466}
1467#endif
1468
1469void clk_gate_restore_context(struct clk_hw *hw);
1470
1471#endif
1472