sh-cpufreq.c 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
  1. /*
  2. * cpufreq driver for the SuperH processors.
  3. *
  4. * Copyright (C) 2002 - 2012 Paul Mundt
  5. * Copyright (C) 2002 M. R. Brown
  6. *
  7. * Clock framework bits from arch/avr32/mach-at32ap/cpufreq.c
  8. *
  9. * Copyright (C) 2004-2007 Atmel Corporation
  10. *
  11. * This file is subject to the terms and conditions of the GNU General Public
  12. * License. See the file "COPYING" in the main directory of this archive
  13. * for more details.
  14. */
  15. #define pr_fmt(fmt) "cpufreq: " fmt
  16. #include <linux/types.h>
  17. #include <linux/cpufreq.h>
  18. #include <linux/kernel.h>
  19. #include <linux/module.h>
  20. #include <linux/init.h>
  21. #include <linux/err.h>
  22. #include <linux/cpumask.h>
  23. #include <linux/cpu.h>
  24. #include <linux/smp.h>
  25. #include <linux/sched.h> /* set_cpus_allowed() */
  26. #include <linux/clk.h>
  27. #include <linux/percpu.h>
  28. #include <linux/sh_clk.h>
  29. static DEFINE_PER_CPU(struct clk, sh_cpuclk);
  30. struct cpufreq_target {
  31. struct cpufreq_policy *policy;
  32. unsigned int freq;
  33. };
  34. static unsigned int sh_cpufreq_get(unsigned int cpu)
  35. {
  36. return (clk_get_rate(&per_cpu(sh_cpuclk, cpu)) + 500) / 1000;
  37. }
  38. static long __sh_cpufreq_target(void *arg)
  39. {
  40. struct cpufreq_target *target = arg;
  41. struct cpufreq_policy *policy = target->policy;
  42. int cpu = policy->cpu;
  43. struct clk *cpuclk = &per_cpu(sh_cpuclk, cpu);
  44. struct cpufreq_freqs freqs;
  45. struct device *dev;
  46. long freq;
  47. if (smp_processor_id() != cpu)
  48. return -ENODEV;
  49. dev = get_cpu_device(cpu);
  50. /* Convert target_freq from kHz to Hz */
  51. freq = clk_round_rate(cpuclk, target->freq * 1000);
  52. if (freq < (policy->min * 1000) || freq > (policy->max * 1000))
  53. return -EINVAL;
  54. dev_dbg(dev, "requested frequency %u Hz\n", target->freq * 1000);
  55. freqs.old = sh_cpufreq_get(cpu);
  56. freqs.new = (freq + 500) / 1000;
  57. freqs.flags = 0;
  58. cpufreq_freq_transition_begin(target->policy, &freqs);
  59. clk_set_rate(cpuclk, freq);
  60. cpufreq_freq_transition_end(target->policy, &freqs, 0);
  61. dev_dbg(dev, "set frequency %lu Hz\n", freq);
  62. return 0;
  63. }
  64. /*
  65. * Here we notify other drivers of the proposed change and the final change.
  66. */
  67. static int sh_cpufreq_target(struct cpufreq_policy *policy,
  68. unsigned int target_freq,
  69. unsigned int relation)
  70. {
  71. struct cpufreq_target data = { .policy = policy, .freq = target_freq };
  72. return work_on_cpu(policy->cpu, __sh_cpufreq_target, &data);
  73. }
  74. static int sh_cpufreq_verify(struct cpufreq_policy_data *policy)
  75. {
  76. struct clk *cpuclk = &per_cpu(sh_cpuclk, policy->cpu);
  77. struct cpufreq_frequency_table *freq_table;
  78. freq_table = cpuclk->nr_freqs ? cpuclk->freq_table : NULL;
  79. if (freq_table)
  80. return cpufreq_frequency_table_verify(policy, freq_table);
  81. cpufreq_verify_within_cpu_limits(policy);
  82. policy->min = (clk_round_rate(cpuclk, 1) + 500) / 1000;
  83. policy->max = (clk_round_rate(cpuclk, ~0UL) + 500) / 1000;
  84. cpufreq_verify_within_cpu_limits(policy);
  85. return 0;
  86. }
  87. static int sh_cpufreq_cpu_init(struct cpufreq_policy *policy)
  88. {
  89. unsigned int cpu = policy->cpu;
  90. struct clk *cpuclk = &per_cpu(sh_cpuclk, cpu);
  91. struct cpufreq_frequency_table *freq_table;
  92. struct device *dev;
  93. dev = get_cpu_device(cpu);
  94. cpuclk = clk_get(dev, "cpu_clk");
  95. if (IS_ERR(cpuclk)) {
  96. dev_err(dev, "couldn't get CPU clk\n");
  97. return PTR_ERR(cpuclk);
  98. }
  99. freq_table = cpuclk->nr_freqs ? cpuclk->freq_table : NULL;
  100. if (freq_table) {
  101. policy->freq_table = freq_table;
  102. } else {
  103. dev_notice(dev, "no frequency table found, falling back "
  104. "to rate rounding.\n");
  105. policy->min = policy->cpuinfo.min_freq =
  106. (clk_round_rate(cpuclk, 1) + 500) / 1000;
  107. policy->max = policy->cpuinfo.max_freq =
  108. (clk_round_rate(cpuclk, ~0UL) + 500) / 1000;
  109. }
  110. return 0;
  111. }
  112. static int sh_cpufreq_cpu_exit(struct cpufreq_policy *policy)
  113. {
  114. unsigned int cpu = policy->cpu;
  115. struct clk *cpuclk = &per_cpu(sh_cpuclk, cpu);
  116. clk_put(cpuclk);
  117. return 0;
  118. }
  119. static void sh_cpufreq_cpu_ready(struct cpufreq_policy *policy)
  120. {
  121. struct device *dev = get_cpu_device(policy->cpu);
  122. dev_info(dev, "CPU Frequencies - Minimum %u.%03u MHz, "
  123. "Maximum %u.%03u MHz.\n",
  124. policy->min / 1000, policy->min % 1000,
  125. policy->max / 1000, policy->max % 1000);
  126. }
  127. static struct cpufreq_driver sh_cpufreq_driver = {
  128. .name = "sh",
  129. .flags = CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING,
  130. .get = sh_cpufreq_get,
  131. .target = sh_cpufreq_target,
  132. .verify = sh_cpufreq_verify,
  133. .init = sh_cpufreq_cpu_init,
  134. .exit = sh_cpufreq_cpu_exit,
  135. .ready = sh_cpufreq_cpu_ready,
  136. .attr = cpufreq_generic_attr,
  137. };
  138. static int __init sh_cpufreq_module_init(void)
  139. {
  140. pr_notice("SuperH CPU frequency driver.\n");
  141. return cpufreq_register_driver(&sh_cpufreq_driver);
  142. }
  143. static void __exit sh_cpufreq_module_exit(void)
  144. {
  145. cpufreq_unregister_driver(&sh_cpufreq_driver);
  146. }
  147. module_init(sh_cpufreq_module_init);
  148. module_exit(sh_cpufreq_module_exit);
  149. MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
  150. MODULE_DESCRIPTION("cpufreq driver for SuperH");
  151. MODULE_LICENSE("GPL");