loongson1-cpufreq.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222
  1. /*
  2. * CPU Frequency Scaling for Loongson 1 SoC
  3. *
  4. * Copyright (C) 2014-2016 Zhang, Keguang <keguang.zhang@gmail.com>
  5. *
  6. * This file is licensed under the terms of the GNU General Public
  7. * License version 2. This program is licensed "as is" without any
  8. * warranty of any kind, whether express or implied.
  9. */
  10. #include <linux/clk.h>
  11. #include <linux/clk-provider.h>
  12. #include <linux/cpu.h>
  13. #include <linux/cpufreq.h>
  14. #include <linux/delay.h>
  15. #include <linux/io.h>
  16. #include <linux/module.h>
  17. #include <linux/platform_device.h>
  18. #include <linux/slab.h>
  19. #include <cpufreq.h>
  20. #include <loongson1.h>
  21. struct ls1x_cpufreq {
  22. struct device *dev;
  23. struct clk *clk; /* CPU clk */
  24. struct clk *mux_clk; /* MUX of CPU clk */
  25. struct clk *pll_clk; /* PLL clk */
  26. struct clk *osc_clk; /* OSC clk */
  27. unsigned int max_freq;
  28. unsigned int min_freq;
  29. };
  30. static struct ls1x_cpufreq *cpufreq;
  31. static int ls1x_cpufreq_notifier(struct notifier_block *nb,
  32. unsigned long val, void *data)
  33. {
  34. if (val == CPUFREQ_POSTCHANGE)
  35. current_cpu_data.udelay_val = loops_per_jiffy;
  36. return NOTIFY_OK;
  37. }
  38. static struct notifier_block ls1x_cpufreq_notifier_block = {
  39. .notifier_call = ls1x_cpufreq_notifier
  40. };
  41. static int ls1x_cpufreq_target(struct cpufreq_policy *policy,
  42. unsigned int index)
  43. {
  44. struct device *cpu_dev = get_cpu_device(policy->cpu);
  45. unsigned int old_freq, new_freq;
  46. old_freq = policy->cur;
  47. new_freq = policy->freq_table[index].frequency;
  48. /*
  49. * The procedure of reconfiguring CPU clk is as below.
  50. *
  51. * - Reparent CPU clk to OSC clk
  52. * - Reset CPU clock (very important)
  53. * - Reconfigure CPU DIV
  54. * - Reparent CPU clk back to CPU DIV clk
  55. */
  56. clk_set_parent(policy->clk, cpufreq->osc_clk);
  57. __raw_writel(__raw_readl(LS1X_CLK_PLL_DIV) | RST_CPU_EN | RST_CPU,
  58. LS1X_CLK_PLL_DIV);
  59. __raw_writel(__raw_readl(LS1X_CLK_PLL_DIV) & ~(RST_CPU_EN | RST_CPU),
  60. LS1X_CLK_PLL_DIV);
  61. clk_set_rate(cpufreq->mux_clk, new_freq * 1000);
  62. clk_set_parent(policy->clk, cpufreq->mux_clk);
  63. dev_dbg(cpu_dev, "%u KHz --> %u KHz\n", old_freq, new_freq);
  64. return 0;
  65. }
  66. static int ls1x_cpufreq_init(struct cpufreq_policy *policy)
  67. {
  68. struct device *cpu_dev = get_cpu_device(policy->cpu);
  69. struct cpufreq_frequency_table *freq_tbl;
  70. unsigned int pll_freq, freq;
  71. int steps, i;
  72. pll_freq = clk_get_rate(cpufreq->pll_clk) / 1000;
  73. steps = 1 << DIV_CPU_WIDTH;
  74. freq_tbl = kcalloc(steps, sizeof(*freq_tbl), GFP_KERNEL);
  75. if (!freq_tbl)
  76. return -ENOMEM;
  77. for (i = 0; i < (steps - 1); i++) {
  78. freq = pll_freq / (i + 1);
  79. if ((freq < cpufreq->min_freq) || (freq > cpufreq->max_freq))
  80. freq_tbl[i].frequency = CPUFREQ_ENTRY_INVALID;
  81. else
  82. freq_tbl[i].frequency = freq;
  83. dev_dbg(cpu_dev,
  84. "cpufreq table: index %d: frequency %d\n", i,
  85. freq_tbl[i].frequency);
  86. }
  87. freq_tbl[i].frequency = CPUFREQ_TABLE_END;
  88. policy->clk = cpufreq->clk;
  89. cpufreq_generic_init(policy, freq_tbl, 0);
  90. return 0;
  91. }
  92. static int ls1x_cpufreq_exit(struct cpufreq_policy *policy)
  93. {
  94. kfree(policy->freq_table);
  95. return 0;
  96. }
  97. static struct cpufreq_driver ls1x_cpufreq_driver = {
  98. .name = "cpufreq-ls1x",
  99. .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
  100. .verify = cpufreq_generic_frequency_table_verify,
  101. .target_index = ls1x_cpufreq_target,
  102. .get = cpufreq_generic_get,
  103. .init = ls1x_cpufreq_init,
  104. .exit = ls1x_cpufreq_exit,
  105. .attr = cpufreq_generic_attr,
  106. };
  107. static int ls1x_cpufreq_remove(struct platform_device *pdev)
  108. {
  109. cpufreq_unregister_notifier(&ls1x_cpufreq_notifier_block,
  110. CPUFREQ_TRANSITION_NOTIFIER);
  111. cpufreq_unregister_driver(&ls1x_cpufreq_driver);
  112. return 0;
  113. }
  114. static int ls1x_cpufreq_probe(struct platform_device *pdev)
  115. {
  116. struct plat_ls1x_cpufreq *pdata = dev_get_platdata(&pdev->dev);
  117. struct clk *clk;
  118. int ret;
  119. if (!pdata || !pdata->clk_name || !pdata->osc_clk_name) {
  120. dev_err(&pdev->dev, "platform data missing\n");
  121. return -EINVAL;
  122. }
  123. cpufreq =
  124. devm_kzalloc(&pdev->dev, sizeof(struct ls1x_cpufreq), GFP_KERNEL);
  125. if (!cpufreq)
  126. return -ENOMEM;
  127. cpufreq->dev = &pdev->dev;
  128. clk = devm_clk_get(&pdev->dev, pdata->clk_name);
  129. if (IS_ERR(clk)) {
  130. dev_err(&pdev->dev, "unable to get %s clock\n",
  131. pdata->clk_name);
  132. return PTR_ERR(clk);
  133. }
  134. cpufreq->clk = clk;
  135. clk = clk_get_parent(clk);
  136. if (IS_ERR(clk)) {
  137. dev_err(&pdev->dev, "unable to get parent of %s clock\n",
  138. __clk_get_name(cpufreq->clk));
  139. return PTR_ERR(clk);
  140. }
  141. cpufreq->mux_clk = clk;
  142. clk = clk_get_parent(clk);
  143. if (IS_ERR(clk)) {
  144. dev_err(&pdev->dev, "unable to get parent of %s clock\n",
  145. __clk_get_name(cpufreq->mux_clk));
  146. return PTR_ERR(clk);
  147. }
  148. cpufreq->pll_clk = clk;
  149. clk = devm_clk_get(&pdev->dev, pdata->osc_clk_name);
  150. if (IS_ERR(clk)) {
  151. dev_err(&pdev->dev, "unable to get %s clock\n",
  152. pdata->osc_clk_name);
  153. return PTR_ERR(clk);
  154. }
  155. cpufreq->osc_clk = clk;
  156. cpufreq->max_freq = pdata->max_freq;
  157. cpufreq->min_freq = pdata->min_freq;
  158. ret = cpufreq_register_driver(&ls1x_cpufreq_driver);
  159. if (ret) {
  160. dev_err(&pdev->dev,
  161. "failed to register CPUFreq driver: %d\n", ret);
  162. return ret;
  163. }
  164. ret = cpufreq_register_notifier(&ls1x_cpufreq_notifier_block,
  165. CPUFREQ_TRANSITION_NOTIFIER);
  166. if (ret) {
  167. dev_err(&pdev->dev,
  168. "failed to register CPUFreq notifier: %d\n",ret);
  169. cpufreq_unregister_driver(&ls1x_cpufreq_driver);
  170. }
  171. return ret;
  172. }
  173. static struct platform_driver ls1x_cpufreq_platdrv = {
  174. .probe = ls1x_cpufreq_probe,
  175. .remove = ls1x_cpufreq_remove,
  176. .driver = {
  177. .name = "ls1x-cpufreq",
  178. },
  179. };
  180. module_platform_driver(ls1x_cpufreq_platdrv);
  181. MODULE_ALIAS("platform:ls1x-cpufreq");
  182. MODULE_AUTHOR("Kelvin Cheung <keguang.zhang@gmail.com>");
  183. MODULE_DESCRIPTION("Loongson1 CPUFreq driver");
  184. MODULE_LICENSE("GPL");