loongson2_cpufreq.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
  1. /*
  2. * Cpufreq driver for the loongson-2 processors
  3. *
  4. * The 2E revision of loongson processor not support this feature.
  5. *
  6. * Copyright (C) 2006 - 2008 Lemote Inc. & Institute of Computing Technology
  7. * Author: Yanhua, yanh@lemote.com
  8. *
  9. * This file is subject to the terms and conditions of the GNU General Public
  10. * License. See the file "COPYING" in the main directory of this archive
  11. * for more details.
  12. */
  13. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14. #include <linux/cpufreq.h>
  15. #include <linux/module.h>
  16. #include <linux/err.h>
  17. #include <linux/sched.h> /* set_cpus_allowed() */
  18. #include <linux/delay.h>
  19. #include <linux/platform_device.h>
  20. #include <asm/clock.h>
  21. #include <asm/idle.h>
  22. #include <asm/mach-loongson64/loongson.h>
  23. static uint nowait;
  24. static void (*saved_cpu_wait) (void);
  25. static int loongson2_cpu_freq_notifier(struct notifier_block *nb,
  26. unsigned long val, void *data);
  27. static struct notifier_block loongson2_cpufreq_notifier_block = {
  28. .notifier_call = loongson2_cpu_freq_notifier
  29. };
  30. static int loongson2_cpu_freq_notifier(struct notifier_block *nb,
  31. unsigned long val, void *data)
  32. {
  33. if (val == CPUFREQ_POSTCHANGE)
  34. current_cpu_data.udelay_val = loops_per_jiffy;
  35. return 0;
  36. }
  37. /*
  38. * Here we notify other drivers of the proposed change and the final change.
  39. */
  40. static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
  41. unsigned int index)
  42. {
  43. unsigned int freq;
  44. freq =
  45. ((cpu_clock_freq / 1000) *
  46. loongson2_clockmod_table[index].driver_data) / 8;
  47. /* setting the cpu frequency */
  48. clk_set_rate(policy->clk, freq * 1000);
  49. return 0;
  50. }
  51. static int loongson2_cpufreq_cpu_init(struct cpufreq_policy *policy)
  52. {
  53. struct clk *cpuclk;
  54. int i;
  55. unsigned long rate;
  56. int ret;
  57. cpuclk = clk_get(NULL, "cpu_clk");
  58. if (IS_ERR(cpuclk)) {
  59. pr_err("couldn't get CPU clk\n");
  60. return PTR_ERR(cpuclk);
  61. }
  62. rate = cpu_clock_freq / 1000;
  63. if (!rate) {
  64. clk_put(cpuclk);
  65. return -EINVAL;
  66. }
  67. /* clock table init */
  68. for (i = 2;
  69. (loongson2_clockmod_table[i].frequency != CPUFREQ_TABLE_END);
  70. i++)
  71. loongson2_clockmod_table[i].frequency = (rate * i) / 8;
  72. ret = clk_set_rate(cpuclk, rate * 1000);
  73. if (ret) {
  74. clk_put(cpuclk);
  75. return ret;
  76. }
  77. policy->clk = cpuclk;
  78. return cpufreq_generic_init(policy, &loongson2_clockmod_table[0], 0);
  79. }
  80. static int loongson2_cpufreq_exit(struct cpufreq_policy *policy)
  81. {
  82. clk_put(policy->clk);
  83. return 0;
  84. }
  85. static struct cpufreq_driver loongson2_cpufreq_driver = {
  86. .name = "loongson2",
  87. .init = loongson2_cpufreq_cpu_init,
  88. .verify = cpufreq_generic_frequency_table_verify,
  89. .target_index = loongson2_cpufreq_target,
  90. .get = cpufreq_generic_get,
  91. .exit = loongson2_cpufreq_exit,
  92. .attr = cpufreq_generic_attr,
  93. };
  94. static const struct platform_device_id platform_device_ids[] = {
  95. {
  96. .name = "loongson2_cpufreq",
  97. },
  98. {}
  99. };
  100. MODULE_DEVICE_TABLE(platform, platform_device_ids);
  101. static struct platform_driver platform_driver = {
  102. .driver = {
  103. .name = "loongson2_cpufreq",
  104. },
  105. .id_table = platform_device_ids,
  106. };
  107. /*
  108. * This is the simple version of Loongson-2 wait, Maybe we need do this in
  109. * interrupt disabled context.
  110. */
  111. static DEFINE_SPINLOCK(loongson2_wait_lock);
  112. static void loongson2_cpu_wait(void)
  113. {
  114. unsigned long flags;
  115. u32 cpu_freq;
  116. spin_lock_irqsave(&loongson2_wait_lock, flags);
  117. cpu_freq = LOONGSON_CHIPCFG(0);
  118. LOONGSON_CHIPCFG(0) &= ~0x7; /* Put CPU into wait mode */
  119. LOONGSON_CHIPCFG(0) = cpu_freq; /* Restore CPU state */
  120. spin_unlock_irqrestore(&loongson2_wait_lock, flags);
  121. local_irq_enable();
  122. }
  123. static int __init cpufreq_init(void)
  124. {
  125. int ret;
  126. /* Register platform stuff */
  127. ret = platform_driver_register(&platform_driver);
  128. if (ret)
  129. return ret;
  130. pr_info("Loongson-2F CPU frequency driver\n");
  131. cpufreq_register_notifier(&loongson2_cpufreq_notifier_block,
  132. CPUFREQ_TRANSITION_NOTIFIER);
  133. ret = cpufreq_register_driver(&loongson2_cpufreq_driver);
  134. if (!ret && !nowait) {
  135. saved_cpu_wait = cpu_wait;
  136. cpu_wait = loongson2_cpu_wait;
  137. }
  138. return ret;
  139. }
  140. static void __exit cpufreq_exit(void)
  141. {
  142. if (!nowait && saved_cpu_wait)
  143. cpu_wait = saved_cpu_wait;
  144. cpufreq_unregister_driver(&loongson2_cpufreq_driver);
  145. cpufreq_unregister_notifier(&loongson2_cpufreq_notifier_block,
  146. CPUFREQ_TRANSITION_NOTIFIER);
  147. platform_driver_unregister(&platform_driver);
  148. }
  149. module_init(cpufreq_init);
  150. module_exit(cpufreq_exit);
  151. module_param(nowait, uint, 0644);
  152. MODULE_PARM_DESC(nowait, "Disable Loongson-2F specific wait");
  153. MODULE_AUTHOR("Yanhua <yanh@lemote.com>");
  154. MODULE_DESCRIPTION("cpufreq driver for Loongson2F");
  155. MODULE_LICENSE("GPL");