clk.c 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <linux/io.h>
  3. #include <linux/clk-provider.h>
  4. #include <linux/slab.h>
  5. #include <linux/of.h>
  6. #include <linux/of_address.h>
  7. #include "clk.h"
  8. void mmp_clk_init(struct device_node *np, struct mmp_clk_unit *unit,
  9. int nr_clks)
  10. {
  11. struct clk **clk_table;
  12. clk_table = kcalloc(nr_clks, sizeof(struct clk *), GFP_KERNEL);
  13. if (!clk_table)
  14. return;
  15. unit->clk_table = clk_table;
  16. unit->nr_clks = nr_clks;
  17. unit->clk_data.clks = clk_table;
  18. unit->clk_data.clk_num = nr_clks;
  19. of_clk_add_provider(np, of_clk_src_onecell_get, &unit->clk_data);
  20. }
  21. void mmp_register_fixed_rate_clks(struct mmp_clk_unit *unit,
  22. struct mmp_param_fixed_rate_clk *clks,
  23. int size)
  24. {
  25. int i;
  26. struct clk *clk;
  27. for (i = 0; i < size; i++) {
  28. clk = clk_register_fixed_rate(NULL, clks[i].name,
  29. clks[i].parent_name,
  30. clks[i].flags,
  31. clks[i].fixed_rate);
  32. if (IS_ERR(clk)) {
  33. pr_err("%s: failed to register clock %s\n",
  34. __func__, clks[i].name);
  35. continue;
  36. }
  37. if (clks[i].id)
  38. unit->clk_table[clks[i].id] = clk;
  39. }
  40. }
  41. void mmp_register_fixed_factor_clks(struct mmp_clk_unit *unit,
  42. struct mmp_param_fixed_factor_clk *clks,
  43. int size)
  44. {
  45. struct clk *clk;
  46. int i;
  47. for (i = 0; i < size; i++) {
  48. clk = clk_register_fixed_factor(NULL, clks[i].name,
  49. clks[i].parent_name,
  50. clks[i].flags, clks[i].mult,
  51. clks[i].div);
  52. if (IS_ERR(clk)) {
  53. pr_err("%s: failed to register clock %s\n",
  54. __func__, clks[i].name);
  55. continue;
  56. }
  57. if (clks[i].id)
  58. unit->clk_table[clks[i].id] = clk;
  59. }
  60. }
  61. void mmp_register_general_gate_clks(struct mmp_clk_unit *unit,
  62. struct mmp_param_general_gate_clk *clks,
  63. void __iomem *base, int size)
  64. {
  65. struct clk *clk;
  66. int i;
  67. for (i = 0; i < size; i++) {
  68. clk = clk_register_gate(NULL, clks[i].name,
  69. clks[i].parent_name,
  70. clks[i].flags,
  71. base + clks[i].offset,
  72. clks[i].bit_idx,
  73. clks[i].gate_flags,
  74. clks[i].lock);
  75. if (IS_ERR(clk)) {
  76. pr_err("%s: failed to register clock %s\n",
  77. __func__, clks[i].name);
  78. continue;
  79. }
  80. if (clks[i].id)
  81. unit->clk_table[clks[i].id] = clk;
  82. }
  83. }
  84. void mmp_register_gate_clks(struct mmp_clk_unit *unit,
  85. struct mmp_param_gate_clk *clks,
  86. void __iomem *base, int size)
  87. {
  88. struct clk *clk;
  89. int i;
  90. for (i = 0; i < size; i++) {
  91. clk = mmp_clk_register_gate(NULL, clks[i].name,
  92. clks[i].parent_name,
  93. clks[i].flags,
  94. base + clks[i].offset,
  95. clks[i].mask,
  96. clks[i].val_enable,
  97. clks[i].val_disable,
  98. clks[i].gate_flags,
  99. clks[i].lock);
  100. if (IS_ERR(clk)) {
  101. pr_err("%s: failed to register clock %s\n",
  102. __func__, clks[i].name);
  103. continue;
  104. }
  105. if (clks[i].id)
  106. unit->clk_table[clks[i].id] = clk;
  107. }
  108. }
  109. void mmp_register_mux_clks(struct mmp_clk_unit *unit,
  110. struct mmp_param_mux_clk *clks,
  111. void __iomem *base, int size)
  112. {
  113. struct clk *clk;
  114. int i;
  115. for (i = 0; i < size; i++) {
  116. clk = clk_register_mux(NULL, clks[i].name,
  117. clks[i].parent_name,
  118. clks[i].num_parents,
  119. clks[i].flags,
  120. base + clks[i].offset,
  121. clks[i].shift,
  122. clks[i].width,
  123. clks[i].mux_flags,
  124. clks[i].lock);
  125. if (IS_ERR(clk)) {
  126. pr_err("%s: failed to register clock %s\n",
  127. __func__, clks[i].name);
  128. continue;
  129. }
  130. if (clks[i].id)
  131. unit->clk_table[clks[i].id] = clk;
  132. }
  133. }
  134. void mmp_register_div_clks(struct mmp_clk_unit *unit,
  135. struct mmp_param_div_clk *clks,
  136. void __iomem *base, int size)
  137. {
  138. struct clk *clk;
  139. int i;
  140. for (i = 0; i < size; i++) {
  141. clk = clk_register_divider(NULL, clks[i].name,
  142. clks[i].parent_name,
  143. clks[i].flags,
  144. base + clks[i].offset,
  145. clks[i].shift,
  146. clks[i].width,
  147. clks[i].div_flags,
  148. clks[i].lock);
  149. if (IS_ERR(clk)) {
  150. pr_err("%s: failed to register clock %s\n",
  151. __func__, clks[i].name);
  152. continue;
  153. }
  154. if (clks[i].id)
  155. unit->clk_table[clks[i].id] = clk;
  156. }
  157. }
  158. void mmp_clk_add(struct mmp_clk_unit *unit, unsigned int id,
  159. struct clk *clk)
  160. {
  161. if (IS_ERR_OR_NULL(clk)) {
  162. pr_err("CLK %d has invalid pointer %p\n", id, clk);
  163. return;
  164. }
  165. if (id >= unit->nr_clks) {
  166. pr_err("CLK %d is invalid\n", id);
  167. return;
  168. }
  169. unit->clk_table[id] = clk;
  170. }