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
 14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 15
 16#include <linux/cpufreq.h>
 17#include <linux/module.h>
 18#include <linux/err.h>
 
 19#include <linux/delay.h>
 20#include <linux/platform_device.h>
 21
 
 22#include <asm/idle.h>
 23
 24#include <asm/mach-loongson2ef/loongson.h>
 25
 26static uint nowait;
 27
 28static void (*saved_cpu_wait) (void);
 29
 30static int loongson2_cpu_freq_notifier(struct notifier_block *nb,
 31					unsigned long val, void *data);
 32
 33static struct notifier_block loongson2_cpufreq_notifier_block = {
 34	.notifier_call = loongson2_cpu_freq_notifier
 35};
 36
 37static int loongson2_cpu_freq_notifier(struct notifier_block *nb,
 38					unsigned long val, void *data)
 39{
 40	if (val == CPUFREQ_POSTCHANGE)
 41		current_cpu_data.udelay_val = loops_per_jiffy;
 42
 43	return 0;
 44}
 45
 46/*
 47 * Here we notify other drivers of the proposed change and the final change.
 48 */
 49static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
 50				     unsigned int index)
 51{
 52	unsigned int freq;
 53
 54	freq =
 55	    ((cpu_clock_freq / 1000) *
 56	     loongson2_clockmod_table[index].driver_data) / 8;
 57
 58	/* setting the cpu frequency */
 59	loongson2_cpu_set_rate(freq);
 60
 61	return 0;
 62}
 63
 64static int loongson2_cpufreq_cpu_init(struct cpufreq_policy *policy)
 65{
 
 66	int i;
 67	unsigned long rate;
 68	int ret;
 69
 
 
 
 
 
 
 70	rate = cpu_clock_freq / 1000;
 71	if (!rate)
 
 72		return -EINVAL;
 
 73
 74	/* clock table init */
 75	for (i = 2;
 76	     (loongson2_clockmod_table[i].frequency != CPUFREQ_TABLE_END);
 77	     i++)
 78		loongson2_clockmod_table[i].frequency = (rate * i) / 8;
 79
 80	ret = loongson2_cpu_set_rate(rate);
 81	if (ret)
 
 82		return ret;
 
 83
 84	cpufreq_generic_init(policy, &loongson2_clockmod_table[0], 0);
 
 
 
 
 
 
 85	return 0;
 86}
 87
 88static struct cpufreq_driver loongson2_cpufreq_driver = {
 89	.name = "loongson2",
 90	.init = loongson2_cpufreq_cpu_init,
 91	.verify = cpufreq_generic_frequency_table_verify,
 92	.target_index = loongson2_cpufreq_target,
 93	.get = cpufreq_generic_get,
 
 94	.attr = cpufreq_generic_attr,
 95};
 96
 97static const struct platform_device_id platform_device_ids[] = {
 98	{
 99		.name = "loongson2_cpufreq",
100	},
101	{}
102};
103
104MODULE_DEVICE_TABLE(platform, platform_device_ids);
105
106static struct platform_driver platform_driver = {
107	.driver = {
108		.name = "loongson2_cpufreq",
109	},
110	.id_table = platform_device_ids,
111};
112
113/*
114 * This is the simple version of Loongson-2 wait, Maybe we need do this in
115 * interrupt disabled context.
116 */
117
118static DEFINE_SPINLOCK(loongson2_wait_lock);
119
120static void loongson2_cpu_wait(void)
121{
122	unsigned long flags;
123	u32 cpu_freq;
124
125	spin_lock_irqsave(&loongson2_wait_lock, flags);
126	cpu_freq = readl(LOONGSON_CHIPCFG);
127	/* Put CPU into wait mode */
128	writel(readl(LOONGSON_CHIPCFG) & ~0x7, LOONGSON_CHIPCFG);
129	/* Restore CPU state */
130	writel(cpu_freq, LOONGSON_CHIPCFG);
131	spin_unlock_irqrestore(&loongson2_wait_lock, flags);
132	local_irq_enable();
133}
134
135static int __init cpufreq_init(void)
136{
137	int ret;
138
139	/* Register platform stuff */
140	ret = platform_driver_register(&platform_driver);
141	if (ret)
142		return ret;
143
144	pr_info("Loongson-2F CPU frequency driver\n");
145
146	cpufreq_register_notifier(&loongson2_cpufreq_notifier_block,
147				  CPUFREQ_TRANSITION_NOTIFIER);
148
149	ret = cpufreq_register_driver(&loongson2_cpufreq_driver);
150
151	if (ret) {
152		platform_driver_unregister(&platform_driver);
153	} else if (!nowait) {
154		saved_cpu_wait = cpu_wait;
155		cpu_wait = loongson2_cpu_wait;
156	}
157
158	return ret;
159}
160
161static void __exit cpufreq_exit(void)
162{
163	if (!nowait && saved_cpu_wait)
164		cpu_wait = saved_cpu_wait;
165	cpufreq_unregister_driver(&loongson2_cpufreq_driver);
166	cpufreq_unregister_notifier(&loongson2_cpufreq_notifier_block,
167				    CPUFREQ_TRANSITION_NOTIFIER);
168
169	platform_driver_unregister(&platform_driver);
170}
171
172module_init(cpufreq_init);
173module_exit(cpufreq_exit);
174
175module_param(nowait, uint, 0644);
176MODULE_PARM_DESC(nowait, "Disable Loongson-2F specific wait");
177
178MODULE_AUTHOR("Yanhua <yanh@lemote.com>");
179MODULE_DESCRIPTION("cpufreq driver for Loongson2F");
180MODULE_LICENSE("GPL");

  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
 14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 15
 16#include <linux/cpufreq.h>
 17#include <linux/module.h>
 18#include <linux/err.h>
 19#include <linux/sched.h>	/* set_cpus_allowed() */
 20#include <linux/delay.h>
 21#include <linux/platform_device.h>
 22
 23#include <asm/clock.h>
 24#include <asm/idle.h>
 25
 26#include <asm/mach-loongson64/loongson.h>
 27
 28static uint nowait;
 29
 30static void (*saved_cpu_wait) (void);
 31
 32static int loongson2_cpu_freq_notifier(struct notifier_block *nb,
 33					unsigned long val, void *data);
 34
 35static struct notifier_block loongson2_cpufreq_notifier_block = {
 36	.notifier_call = loongson2_cpu_freq_notifier
 37};
 38
 39static int loongson2_cpu_freq_notifier(struct notifier_block *nb,
 40					unsigned long val, void *data)
 41{
 42	if (val == CPUFREQ_POSTCHANGE)
 43		current_cpu_data.udelay_val = loops_per_jiffy;
 44
 45	return 0;
 46}
 47
 48/*
 49 * Here we notify other drivers of the proposed change and the final change.
 50 */
 51static int loongson2_cpufreq_target(struct cpufreq_policy *policy,
 52				     unsigned int index)
 53{
 54	unsigned int freq;
 55
 56	freq =
 57	    ((cpu_clock_freq / 1000) *
 58	     loongson2_clockmod_table[index].driver_data) / 8;
 59
 60	/* setting the cpu frequency */
 61	clk_set_rate(policy->clk, freq * 1000);
 62
 63	return 0;
 64}
 65
 66static int loongson2_cpufreq_cpu_init(struct cpufreq_policy *policy)
 67{
 68	struct clk *cpuclk;
 69	int i;
 70	unsigned long rate;
 71	int ret;
 72
 73	cpuclk = clk_get(NULL, "cpu_clk");
 74	if (IS_ERR(cpuclk)) {
 75		pr_err("couldn't get CPU clk\n");
 76		return PTR_ERR(cpuclk);
 77	}
 78
 79	rate = cpu_clock_freq / 1000;
 80	if (!rate) {
 81		clk_put(cpuclk);
 82		return -EINVAL;
 83	}
 84
 85	/* clock table init */
 86	for (i = 2;
 87	     (loongson2_clockmod_table[i].frequency != CPUFREQ_TABLE_END);
 88	     i++)
 89		loongson2_clockmod_table[i].frequency = (rate * i) / 8;
 90
 91	ret = clk_set_rate(cpuclk, rate * 1000);
 92	if (ret) {
 93		clk_put(cpuclk);
 94		return ret;
 95	}
 96
 97	policy->clk = cpuclk;
 98	return cpufreq_generic_init(policy, &loongson2_clockmod_table[0], 0);
 99}
100
101static int loongson2_cpufreq_exit(struct cpufreq_policy *policy)
102{
103	clk_put(policy->clk);
104	return 0;
105}
106
107static struct cpufreq_driver loongson2_cpufreq_driver = {
108	.name = "loongson2",
109	.init = loongson2_cpufreq_cpu_init,
110	.verify = cpufreq_generic_frequency_table_verify,
111	.target_index = loongson2_cpufreq_target,
112	.get = cpufreq_generic_get,
113	.exit = loongson2_cpufreq_exit,
114	.attr = cpufreq_generic_attr,
115};
116
117static const struct platform_device_id platform_device_ids[] = {
118	{
119		.name = "loongson2_cpufreq",
120	},
121	{}
122};
123
124MODULE_DEVICE_TABLE(platform, platform_device_ids);
125
126static struct platform_driver platform_driver = {
127	.driver = {
128		.name = "loongson2_cpufreq",
129	},
130	.id_table = platform_device_ids,
131};
132
133/*
134 * This is the simple version of Loongson-2 wait, Maybe we need do this in
135 * interrupt disabled context.
136 */
137
138static DEFINE_SPINLOCK(loongson2_wait_lock);
139
140static void loongson2_cpu_wait(void)
141{
142	unsigned long flags;
143	u32 cpu_freq;
144
145	spin_lock_irqsave(&loongson2_wait_lock, flags);
146	cpu_freq = LOONGSON_CHIPCFG(0);
147	LOONGSON_CHIPCFG(0) &= ~0x7;	/* Put CPU into wait mode */
148	LOONGSON_CHIPCFG(0) = cpu_freq;	/* Restore CPU state */
 
 
149	spin_unlock_irqrestore(&loongson2_wait_lock, flags);
150	local_irq_enable();
151}
152
153static int __init cpufreq_init(void)
154{
155	int ret;
156
157	/* Register platform stuff */
158	ret = platform_driver_register(&platform_driver);
159	if (ret)
160		return ret;
161
162	pr_info("Loongson-2F CPU frequency driver\n");
163
164	cpufreq_register_notifier(&loongson2_cpufreq_notifier_block,
165				  CPUFREQ_TRANSITION_NOTIFIER);
166
167	ret = cpufreq_register_driver(&loongson2_cpufreq_driver);
168
169	if (!ret && !nowait) {
 
 
170		saved_cpu_wait = cpu_wait;
171		cpu_wait = loongson2_cpu_wait;
172	}
173
174	return ret;
175}
176
177static void __exit cpufreq_exit(void)
178{
179	if (!nowait && saved_cpu_wait)
180		cpu_wait = saved_cpu_wait;
181	cpufreq_unregister_driver(&loongson2_cpufreq_driver);
182	cpufreq_unregister_notifier(&loongson2_cpufreq_notifier_block,
183				    CPUFREQ_TRANSITION_NOTIFIER);
184
185	platform_driver_unregister(&platform_driver);
186}
187
188module_init(cpufreq_init);
189module_exit(cpufreq_exit);
190
191module_param(nowait, uint, 0644);
192MODULE_PARM_DESC(nowait, "Disable Loongson-2F specific wait");
193
194MODULE_AUTHOR("Yanhua <yanh@lemote.com>");
195MODULE_DESCRIPTION("cpufreq driver for Loongson2F");
196MODULE_LICENSE("GPL");