blob: c57ce3f1f2e281b2c38a7de860d390cbc08e5fd0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * FR-V Power Management Routines
3 *
4 * Copyright (c) 2004 Red Hat, Inc.
5 *
6 * Based on SA1100 version:
7 * Copyright (c) 2001 Cliff Brake <cbrake@accelent.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License.
11 *
12 */
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/init.h>
David Howells40234402006-01-08 01:01:19 -080015#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/pm.h>
Jeff Garzikbca73e42005-11-13 16:06:25 -080017#include <linux/pm_legacy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/sched.h>
19#include <linux/interrupt.h>
20#include <linux/sysctl.h>
21#include <linux/errno.h>
22#include <linux/delay.h>
23#include <asm/uaccess.h>
24
25#include <asm/mb86943a.h>
26
27#include "local.h"
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029/*
30 * Debug macros
31 */
32#define DEBUG
33
34int pm_do_suspend(void)
35{
36 local_irq_disable();
37
38 __set_LEDS(0xb1);
39
40 /* go zzz */
41 frv_cpu_suspend(pdm_suspend_mode);
42
43 __set_LEDS(0xb2);
44
45 local_irq_enable();
46
47 return 0;
48}
49
50static unsigned long __irq_mask;
51
52/*
53 * Setup interrupt masks, etc to enable wakeup by power switch
54 */
55static void __default_power_switch_setup(void)
56{
57 /* default is to mask all interrupt sources. */
58 __irq_mask = *(unsigned long *)0xfeff9820;
59 *(unsigned long *)0xfeff9820 = 0xfffe0000;
60}
61
62/*
63 * Cleanup interrupt masks, etc after wakeup by power switch
64 */
65static void __default_power_switch_cleanup(void)
66{
67 *(unsigned long *)0xfeff9820 = __irq_mask;
68}
69
70/*
71 * Return non-zero if wakeup irq was caused by power switch
72 */
73static int __default_power_switch_check(void)
74{
75 return 1;
76}
77
78void (*__power_switch_wake_setup)(void) = __default_power_switch_setup;
79int (*__power_switch_wake_check)(void) = __default_power_switch_check;
80void (*__power_switch_wake_cleanup)(void) = __default_power_switch_cleanup;
81
82int pm_do_bus_sleep(void)
83{
84 local_irq_disable();
85
86 /*
87 * Here is where we need some platform-dependent setup
88 * of the interrupt state so that appropriate wakeup
89 * sources are allowed and all others are masked.
90 */
91 __power_switch_wake_setup();
92
93 __set_LEDS(0xa1);
94
95 /* go zzz
96 *
97 * This is in a loop in case power switch shares an irq with other
98 * devices. The wake_check() tells us if we need to finish waking
99 * or go back to sleep.
100 */
101 do {
102 frv_cpu_suspend(HSR0_PDM_BUS_SLEEP);
103 } while (__power_switch_wake_check && !__power_switch_wake_check());
104
105 __set_LEDS(0xa2);
106
107 /*
108 * Here is where we need some platform-dependent restore
109 * of the interrupt state prior to being called.
110 */
111 __power_switch_wake_cleanup();
112
113 local_irq_enable();
114
115 return 0;
116}
117
118unsigned long sleep_phys_sp(void *sp)
119{
120 return virt_to_phys(sp);
121}
122
123#ifdef CONFIG_SYSCTL
124/*
125 * Use a temporary sysctl number. Horrid, but will be cleaned up in 2.6
126 * when all the PM interfaces exist nicely.
127 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128#define CTL_PM_SUSPEND 1
129#define CTL_PM_CMODE 2
130#define CTL_PM_P0 4
131#define CTL_PM_CM 5
132
Al Viro7ab76d72006-06-23 02:04:05 -0700133static int user_atoi(char __user *ubuf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
135 char buf[16];
136 unsigned long ret;
137
138 if (len > 15)
139 return -EINVAL;
140
141 if (copy_from_user(buf, ubuf, len))
142 return -EFAULT;
143
144 buf[len] = 0;
145 ret = simple_strtoul(buf, NULL, 0);
146 if (ret > INT_MAX)
147 return -ERANGE;
148 return ret;
149}
150
151/*
152 * Send us to sleep.
153 */
154static int sysctl_pm_do_suspend(ctl_table *ctl, int write, struct file *filp,
Al Viro7ab76d72006-06-23 02:04:05 -0700155 void __user *buffer, size_t *lenp, loff_t *fpos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
157 int retval, mode;
158
159 if (*lenp <= 0)
160 return -EIO;
161
162 mode = user_atoi(buffer, *lenp);
163 if ((mode != 1) && (mode != 5))
164 return -EINVAL;
165
166 retval = pm_send_all(PM_SUSPEND, (void *)3);
167
168 if (retval == 0) {
169 if (mode == 5)
170 retval = pm_do_bus_sleep();
171 else
172 retval = pm_do_suspend();
173 pm_send_all(PM_RESUME, (void *)0);
174 }
175
176 return retval;
177}
178
179static int try_set_cmode(int new_cmode)
180{
181 if (new_cmode > 15)
182 return -EINVAL;
183 if (!(clock_cmodes_permitted & (1<<new_cmode)))
184 return -EINVAL;
185
186 /* tell all the drivers we're suspending */
187 pm_send_all(PM_SUSPEND, (void *)3);
188
189 /* now change cmode */
190 local_irq_disable();
191 frv_dma_pause_all();
192
193 frv_change_cmode(new_cmode);
194
195 determine_clocks(0);
196 time_divisor_init();
197
198#ifdef DEBUG
199 determine_clocks(1);
200#endif
201 frv_dma_resume_all();
202 local_irq_enable();
203
204 /* tell all the drivers we're resuming */
205 pm_send_all(PM_RESUME, (void *)0);
206 return 0;
207}
208
209
210static int cmode_procctl(ctl_table *ctl, int write, struct file *filp,
Al Viro7ab76d72006-06-23 02:04:05 -0700211 void __user *buffer, size_t *lenp, loff_t *fpos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
213 int new_cmode;
214
215 if (!write)
216 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
217
218 new_cmode = user_atoi(buffer, *lenp);
219
220 return try_set_cmode(new_cmode)?:*lenp;
221}
222
Al Viro7ab76d72006-06-23 02:04:05 -0700223static int cmode_sysctl(ctl_table *table, int __user *name, int nlen,
224 void __user *oldval, size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -0800225 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
227 if (oldval && oldlenp) {
228 size_t oldlen;
229
230 if (get_user(oldlen, oldlenp))
231 return -EFAULT;
232
233 if (oldlen != sizeof(int))
234 return -EINVAL;
235
Al Viro7ab76d72006-06-23 02:04:05 -0700236 if (put_user(clock_cmode_current, (unsigned __user *)oldval) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 put_user(sizeof(int), oldlenp))
238 return -EFAULT;
239 }
240 if (newval && newlen) {
241 int new_cmode;
242
243 if (newlen != sizeof(int))
244 return -EINVAL;
245
Al Viro7ab76d72006-06-23 02:04:05 -0700246 if (get_user(new_cmode, (int __user *)newval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return -EFAULT;
248
249 return try_set_cmode(new_cmode)?:1;
250 }
251 return 1;
252}
253
254static int try_set_p0(int new_p0)
255{
256 unsigned long flags, clkc;
257
258 if (new_p0 < 0 || new_p0 > 1)
259 return -EINVAL;
260
261 local_irq_save(flags);
262 __set_PSR(flags & ~PSR_ET);
263
264 frv_dma_pause_all();
265
266 clkc = __get_CLKC();
267 if (new_p0)
268 clkc |= CLKC_P0;
269 else
270 clkc &= ~CLKC_P0;
271 __set_CLKC(clkc);
272
273 determine_clocks(0);
274 time_divisor_init();
275
276#ifdef DEBUG
277 determine_clocks(1);
278#endif
279 frv_dma_resume_all();
280 local_irq_restore(flags);
281 return 0;
282}
283
284static int try_set_cm(int new_cm)
285{
286 unsigned long flags, clkc;
287
288 if (new_cm < 0 || new_cm > 1)
289 return -EINVAL;
290
291 local_irq_save(flags);
292 __set_PSR(flags & ~PSR_ET);
293
294 frv_dma_pause_all();
295
296 clkc = __get_CLKC();
297 clkc &= ~CLKC_CM;
298 clkc |= new_cm;
299 __set_CLKC(clkc);
300
301 determine_clocks(0);
302 time_divisor_init();
303
304#if 1 //def DEBUG
305 determine_clocks(1);
306#endif
307
308 frv_dma_resume_all();
309 local_irq_restore(flags);
310 return 0;
311}
312
313static int p0_procctl(ctl_table *ctl, int write, struct file *filp,
Al Viro7ab76d72006-06-23 02:04:05 -0700314 void __user *buffer, size_t *lenp, loff_t *fpos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 int new_p0;
317
318 if (!write)
319 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
320
321 new_p0 = user_atoi(buffer, *lenp);
322
323 return try_set_p0(new_p0)?:*lenp;
324}
325
Al Viro7ab76d72006-06-23 02:04:05 -0700326static int p0_sysctl(ctl_table *table, int __user *name, int nlen,
327 void __user *oldval, size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -0800328 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329{
330 if (oldval && oldlenp) {
331 size_t oldlen;
332
333 if (get_user(oldlen, oldlenp))
334 return -EFAULT;
335
336 if (oldlen != sizeof(int))
337 return -EINVAL;
338
Al Viro7ab76d72006-06-23 02:04:05 -0700339 if (put_user(clock_p0_current, (unsigned __user *)oldval) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 put_user(sizeof(int), oldlenp))
341 return -EFAULT;
342 }
343 if (newval && newlen) {
344 int new_p0;
345
346 if (newlen != sizeof(int))
347 return -EINVAL;
348
Al Viro7ab76d72006-06-23 02:04:05 -0700349 if (get_user(new_p0, (int __user *)newval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return -EFAULT;
351
352 return try_set_p0(new_p0)?:1;
353 }
354 return 1;
355}
356
357static int cm_procctl(ctl_table *ctl, int write, struct file *filp,
Al Viro7ab76d72006-06-23 02:04:05 -0700358 void __user *buffer, size_t *lenp, loff_t *fpos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
360 int new_cm;
361
362 if (!write)
363 return proc_dointvec(ctl, write, filp, buffer, lenp, fpos);
364
365 new_cm = user_atoi(buffer, *lenp);
366
367 return try_set_cm(new_cm)?:*lenp;
368}
369
Al Viro7ab76d72006-06-23 02:04:05 -0700370static int cm_sysctl(ctl_table *table, int __user *name, int nlen,
371 void __user *oldval, size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -0800372 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
374 if (oldval && oldlenp) {
375 size_t oldlen;
376
377 if (get_user(oldlen, oldlenp))
378 return -EFAULT;
379
380 if (oldlen != sizeof(int))
381 return -EINVAL;
382
Al Viro7ab76d72006-06-23 02:04:05 -0700383 if (put_user(clock_cm_current, (unsigned __user *)oldval) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 put_user(sizeof(int), oldlenp))
385 return -EFAULT;
386 }
387 if (newval && newlen) {
388 int new_cm;
389
390 if (newlen != sizeof(int))
391 return -EINVAL;
392
Al Viro7ab76d72006-06-23 02:04:05 -0700393 if (get_user(new_cm, (int __user *)newval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return -EFAULT;
395
396 return try_set_cm(new_cm)?:1;
397 }
398 return 1;
399}
400
401
402static struct ctl_table pm_table[] =
403{
Eric W. Biedermandfd007a2007-02-14 00:33:39 -0800404 {
405 .ctl_name = CTL_PM_SUSPEND,
406 .procname = "suspend",
407 .data = NULL,
408 .maxlen = 0,
409 .mode = 0200,
410 .proc_handler = &sysctl_pm_do_suspend,
411 },
412 {
413 .ctl_name = CTL_PM_CMODE,
414 .procname = "cmode",
415 .data = &clock_cmode_current,
416 .maxlen = sizeof(int),
417 .mode = 0644,
418 .proc_handler = &cmode_procctl,
419 .strategy = &cmode_sysctl,
420 },
421 {
422 .ctl_name = CTL_PM_P0,
423 .procname = "p0",
424 .data = &clock_p0_current,
425 .maxlen = sizeof(int),
426 .mode = 0644,
427 .proc_handler = &p0_procctl,
428 .strategy = &p0_sysctl,
429 },
430 {
431 .ctl_name = CTL_PM_CM,
432 .procname = "cm",
433 .data = &clock_cm_current,
434 .maxlen = sizeof(int),
435 .mode = 0644,
436 .proc_handler = &cm_procctl,
437 .strategy = &cm_sysctl,
438 },
439 { .ctl_name = 0}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440};
441
442static struct ctl_table pm_dir_table[] =
443{
Eric W. Biedermandfd007a2007-02-14 00:33:39 -0800444 {
445 .ctl_name = CTL_PM,
446 .procname = "pm",
447 .mode = 0555,
448 .child = pm_table,
449 },
450 { .ctl_name = 0}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451};
452
453/*
454 * Initialize power interface
455 */
456static int __init pm_init(void)
457{
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800458 register_sysctl_table(pm_dir_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return 0;
460}
461
462__initcall(pm_init);
463
464#endif