f58e151b38d495a5105478b551e74ebb92b9b2a0
[linux-2.6.git] / arch / mips / alchemy / common / power.c
1 /*
2  * BRIEF MODULE DESCRIPTION
3  *      Au1xx0 Power Management routines.
4  *
5  * Copyright 2001, 2008 MontaVista Software Inc.
6  * Author: MontaVista Software, Inc. <source@mvista.com>
7  *
8  *  Some of the routines are right out of init/main.c, whose
9  *  copyrights apply here.
10  *
11  *  This program is free software; you can redistribute  it and/or modify it
12  *  under  the terms of  the GNU General  Public License as published by the
13  *  Free Software Foundation;  either version 2 of the  License, or (at your
14  *  option) any later version.
15  *
16  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
17  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
18  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
19  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
20  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
22  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
24  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  *
27  *  You should have received a copy of the  GNU General Public License along
28  *  with this program; if not, write  to the Free Software Foundation, Inc.,
29  *  675 Mass Ave, Cambridge, MA 02139, USA.
30  */
31
32 #include <linux/init.h>
33 #include <linux/pm.h>
34 #include <linux/sysctl.h>
35 #include <linux/jiffies.h>
36
37 #include <asm/uaccess.h>
38 #include <asm/mach-au1x00/au1000.h>
39 #if defined(CONFIG_SOC_AU1550) || defined(CONFIG_SOC_AU1200)
40 #include <asm/mach-au1x00/au1xxx_dbdma.h>
41 #endif
42
43 #ifdef CONFIG_PM
44
45 #define DEBUG 1
46 #ifdef  DEBUG
47 #define DPRINTK(fmt, args...)   printk(KERN_DEBUG "%s: " fmt, __func__, ## args)
48 #else
49 #define DPRINTK(fmt, args...)
50 #endif
51
52 extern unsigned long save_local_and_disable(int controller);
53 extern void restore_local_and_enable(int controller, unsigned long mask);
54
55 static DEFINE_SPINLOCK(pm_lock);
56
57 /*
58  * We need to save/restore a bunch of core registers that are
59  * either volatile or reset to some state across a processor sleep.
60  * If reading a register doesn't provide a proper result for a
61  * later restore, we have to provide a function for loading that
62  * register and save a copy.
63  *
64  * We only have to save/restore registers that aren't otherwise
65  * done as part of a driver pm_* function.
66  */
67 static unsigned int sleep_uart0_inten;
68 static unsigned int sleep_uart0_fifoctl;
69 static unsigned int sleep_uart0_linectl;
70 static unsigned int sleep_uart0_clkdiv;
71 static unsigned int sleep_uart0_enable;
72 static unsigned int sleep_usb[2];
73 static unsigned int sleep_sys_clocks[5];
74 static unsigned int sleep_sys_pinfunc;
75 static unsigned int sleep_static_memctlr[4][3];
76
77 /*
78  * Define this to cause the value you write to /proc/sys/pm/sleep to
79  * set the TOY timer for the amount of time you want to sleep.
80  * This is done mainly for testing, but may be useful in other cases.
81  * The value is number of 32KHz ticks to sleep.
82  */
83 #define SLEEP_TEST_TIMEOUT 1
84 #ifdef  SLEEP_TEST_TIMEOUT
85 static int sleep_ticks;
86 static void wakeup_counter0_set(int ticks)
87 {
88         au_writel(au_readl(SYS_TOYREAD) + ticks, SYS_TOYMATCH2);
89         au_sync();
90 }
91 #endif
92
93 static void save_core_regs(void)
94 {
95         extern void save_au1xxx_intctl(void);
96         extern void pm_eth0_shutdown(void);
97
98         /*
99          * Do the serial ports.....these really should be a pm_*
100          * registered function by the driver......but of course the
101          * standard serial driver doesn't understand our Au1xxx
102          * unique registers.
103          */
104         sleep_uart0_inten = au_readl(UART0_ADDR + UART_IER);
105         sleep_uart0_fifoctl = au_readl(UART0_ADDR + UART_FCR);
106         sleep_uart0_linectl = au_readl(UART0_ADDR + UART_LCR);
107         sleep_uart0_clkdiv = au_readl(UART0_ADDR + UART_CLK);
108         sleep_uart0_enable = au_readl(UART0_ADDR + UART_MOD_CNTRL);
109         au_sync();
110
111 #ifndef CONFIG_SOC_AU1200
112         /* Shutdown USB host/device. */
113         sleep_usb[0] = au_readl(USB_HOST_CONFIG);
114
115         /* There appears to be some undocumented reset register.... */
116         au_writel(0, 0xb0100004);
117         au_sync();
118         au_writel(0, USB_HOST_CONFIG);
119         au_sync();
120
121         sleep_usb[1] = au_readl(USBD_ENABLE);
122         au_writel(0, USBD_ENABLE);
123         au_sync();
124
125 #else   /* AU1200 */
126
127         /* enable access to OTG mmio so we can save OTG CAP/MUX.
128          * FIXME: write an OTG driver and move this stuff there!
129          */
130         au_writel(au_readl(USB_MSR_BASE + 4) | (1 << 6), USB_MSR_BASE + 4);
131         au_sync();
132         sleep_usb[0] = au_readl(0xb4020020);    /* OTG_CAP */
133         sleep_usb[1] = au_readl(0xb4020024);    /* OTG_MUX */
134 #endif
135
136         /* Save interrupt controller state. */
137         save_au1xxx_intctl();
138
139         /* Clocks and PLLs. */
140         sleep_sys_clocks[0] = au_readl(SYS_FREQCTRL0);
141         sleep_sys_clocks[1] = au_readl(SYS_FREQCTRL1);
142         sleep_sys_clocks[2] = au_readl(SYS_CLKSRC);
143         sleep_sys_clocks[3] = au_readl(SYS_CPUPLL);
144         sleep_sys_clocks[4] = au_readl(SYS_AUXPLL);
145
146         /* pin mux config */
147         sleep_sys_pinfunc = au_readl(SYS_PINFUNC);
148
149         /* Save the static memory controller configuration. */
150         sleep_static_memctlr[0][0] = au_readl(MEM_STCFG0);
151         sleep_static_memctlr[0][1] = au_readl(MEM_STTIME0);
152         sleep_static_memctlr[0][2] = au_readl(MEM_STADDR0);
153         sleep_static_memctlr[1][0] = au_readl(MEM_STCFG1);
154         sleep_static_memctlr[1][1] = au_readl(MEM_STTIME1);
155         sleep_static_memctlr[1][2] = au_readl(MEM_STADDR1);
156         sleep_static_memctlr[2][0] = au_readl(MEM_STCFG2);
157         sleep_static_memctlr[2][1] = au_readl(MEM_STTIME2);
158         sleep_static_memctlr[2][2] = au_readl(MEM_STADDR2);
159         sleep_static_memctlr[3][0] = au_readl(MEM_STCFG3);
160         sleep_static_memctlr[3][1] = au_readl(MEM_STTIME3);
161         sleep_static_memctlr[3][2] = au_readl(MEM_STADDR3);
162
163 #if defined(CONFIG_SOC_AU1550) || defined(CONFIG_SOC_AU1200)
164         au1xxx_dbdma_suspend();
165 #endif
166 }
167
168 static void restore_core_regs(void)
169 {
170         /* restore clock configuration.  Writing CPUPLL last will
171          * stall a bit and stabilize other clocks (unless this is
172          * one of those Au1000 with a write-only PLL, where we dont
173          * have a valid value)
174          */
175         au_writel(sleep_sys_clocks[0], SYS_FREQCTRL0);
176         au_writel(sleep_sys_clocks[1], SYS_FREQCTRL1);
177         au_writel(sleep_sys_clocks[2], SYS_CLKSRC);
178         au_writel(sleep_sys_clocks[4], SYS_AUXPLL);
179         if (!au1xxx_cpu_has_pll_wo())
180                 au_writel(sleep_sys_clocks[3], SYS_CPUPLL);
181         au_sync();
182
183         au_writel(sleep_sys_pinfunc, SYS_PINFUNC);
184         au_sync();
185
186 #ifndef CONFIG_SOC_AU1200
187         au_writel(sleep_usb[0], USB_HOST_CONFIG);
188         au_writel(sleep_usb[1], USBD_ENABLE);
189         au_sync();
190 #else
191         /* enable accces to OTG memory */
192         au_writel(au_readl(USB_MSR_BASE + 4) | (1 << 6), USB_MSR_BASE + 4);
193         au_sync();
194
195         /* restore OTG caps and port mux. */
196         au_writel(sleep_usb[0], 0xb4020020 + 0);        /* OTG_CAP */
197         au_sync();
198         au_writel(sleep_usb[1], 0xb4020020 + 4);        /* OTG_MUX */
199         au_sync();
200 #endif
201
202         /* Restore the static memory controller configuration. */
203         au_writel(sleep_static_memctlr[0][0], MEM_STCFG0);
204         au_writel(sleep_static_memctlr[0][1], MEM_STTIME0);
205         au_writel(sleep_static_memctlr[0][2], MEM_STADDR0);
206         au_writel(sleep_static_memctlr[1][0], MEM_STCFG1);
207         au_writel(sleep_static_memctlr[1][1], MEM_STTIME1);
208         au_writel(sleep_static_memctlr[1][2], MEM_STADDR1);
209         au_writel(sleep_static_memctlr[2][0], MEM_STCFG2);
210         au_writel(sleep_static_memctlr[2][1], MEM_STTIME2);
211         au_writel(sleep_static_memctlr[2][2], MEM_STADDR2);
212         au_writel(sleep_static_memctlr[3][0], MEM_STCFG3);
213         au_writel(sleep_static_memctlr[3][1], MEM_STTIME3);
214         au_writel(sleep_static_memctlr[3][2], MEM_STADDR3);
215
216         /*
217          * Enable the UART if it was enabled before sleep.
218          * I guess I should define module control bits........
219          */
220         if (sleep_uart0_enable & 0x02) {
221                 au_writel(0, UART0_ADDR + UART_MOD_CNTRL); au_sync();
222                 au_writel(1, UART0_ADDR + UART_MOD_CNTRL); au_sync();
223                 au_writel(3, UART0_ADDR + UART_MOD_CNTRL); au_sync();
224                 au_writel(sleep_uart0_inten, UART0_ADDR + UART_IER); au_sync();
225                 au_writel(sleep_uart0_fifoctl, UART0_ADDR + UART_FCR); au_sync();
226                 au_writel(sleep_uart0_linectl, UART0_ADDR + UART_LCR); au_sync();
227                 au_writel(sleep_uart0_clkdiv, UART0_ADDR + UART_CLK); au_sync();
228         }
229
230         restore_au1xxx_intctl();
231
232 #if defined(CONFIG_SOC_AU1550) || defined(CONFIG_SOC_AU1200)
233         au1xxx_dbdma_resume();
234 #endif
235 }
236
237 unsigned long suspend_mode;
238
239 void wakeup_from_suspend(void)
240 {
241         suspend_mode = 0;
242 }
243
244 void au_sleep(void)
245 {
246         save_core_regs();
247         au1xxx_save_and_sleep();
248         restore_core_regs();
249 }
250
251 static int pm_do_sleep(ctl_table *ctl, int write, struct file *file,
252                        void __user *buffer, size_t *len, loff_t *ppos)
253 {
254         unsigned long wakeup, flags;
255         int ret;
256 #ifdef SLEEP_TEST_TIMEOUT
257 #define TMPBUFLEN2 16
258         char buf[TMPBUFLEN2], *p;
259 #endif
260
261         spin_lock_irqsave(&pm_lock, flags);
262
263         if (!write) {
264                 *len = 0;
265                 ret = 0;
266                 goto out_unlock;
267         };
268
269 #ifdef SLEEP_TEST_TIMEOUT
270         if (*len > TMPBUFLEN2 - 1) {
271                 ret = -EFAULT;
272                 goto out_unlock;
273         }
274         if (copy_from_user(buf, buffer, *len)) {
275                 return -EFAULT;
276                 goto out_unlock;
277         }
278         buf[*len] = 0;
279         p = buf;
280         sleep_ticks = simple_strtoul(p, &p, 0);
281         wakeup_counter0_set(sleep_ticks);
282 #endif
283
284         /**
285          ** The code below is all system dependent and we should probably
286          ** have a function call out of here to set this up.  You need
287          ** to configure the GPIO or timer interrupts that will bring
288          ** you out of sleep.
289          ** For testing, the TOY counter wakeup is useful.
290          **/
291 #if 0
292         au_writel(au_readl(SYS_PINSTATERD) & ~(1 << 11), SYS_PINSTATERD);
293
294         /* GPIO 6 can cause a wake up event */
295         wakeup = au_readl(SYS_WAKEMSK);
296         wakeup &= ~(1 << 8);    /* turn off match20 wakeup */
297         wakeup |= 1 << 6;       /* turn on  GPIO  6 wakeup */
298 #else
299         /* For testing, allow match20 to wake us up. */
300         wakeup = 1 << 8;        /* turn on match20 wakeup   */
301         wakeup = 0;
302 #endif
303         au_writel(1, SYS_WAKESRC);      /* clear cause */
304         au_sync();
305         au_writel(wakeup, SYS_WAKEMSK);
306         au_sync();
307
308         au_sleep();
309         ret = 0;
310
311 out_unlock:
312         spin_unlock_irqrestore(&pm_lock, flags);
313         return ret;
314 }
315
316 #if !defined(CONFIG_SOC_AU1200) && !defined(CONFIG_SOC_AU1550)
317
318 /*
319  * This is right out of init/main.c
320  */
321
322 /*
323  * This is the number of bits of precision for the loops_per_jiffy.
324  * Each bit takes on average 1.5/HZ seconds.  This (like the original)
325  * is a little better than 1%.
326  */
327 #define LPS_PREC 8
328
329 static void au1000_calibrate_delay(void)
330 {
331         unsigned long ticks, loopbit;
332         int lps_precision = LPS_PREC;
333
334         loops_per_jiffy = 1 << 12;
335
336         while (loops_per_jiffy <<= 1) {
337                 /* Wait for "start of" clock tick */
338                 ticks = jiffies;
339                 while (ticks == jiffies)
340                         /* nothing */ ;
341                 /* Go ... */
342                 ticks = jiffies;
343                 __delay(loops_per_jiffy);
344                 ticks = jiffies - ticks;
345                 if (ticks)
346                         break;
347         }
348
349         /*
350          * Do a binary approximation to get loops_per_jiffy set to be equal
351          * one clock (up to lps_precision bits)
352          */
353         loops_per_jiffy >>= 1;
354         loopbit = loops_per_jiffy;
355         while (lps_precision-- && (loopbit >>= 1)) {
356                 loops_per_jiffy |= loopbit;
357                 ticks = jiffies;
358                 while (ticks == jiffies);
359                 ticks = jiffies;
360                 __delay(loops_per_jiffy);
361                 if (jiffies != ticks)   /* longer than 1 tick */
362                         loops_per_jiffy &= ~loopbit;
363         }
364 }
365
366 static int pm_do_freq(ctl_table *ctl, int write, struct file *file,
367                       void __user *buffer, size_t *len, loff_t *ppos)
368 {
369         int retval = 0, i;
370         unsigned long val, pll;
371 #define TMPBUFLEN 64
372 #define MAX_CPU_FREQ 396
373         char buf[TMPBUFLEN], *p;
374         unsigned long flags, intc0_mask, intc1_mask;
375         unsigned long old_baud_base, old_cpu_freq, old_clk, old_refresh;
376         unsigned long new_baud_base, new_cpu_freq, new_clk, new_refresh;
377         unsigned long baud_rate;
378
379         spin_lock_irqsave(&pm_lock, flags);
380         if (!write)
381                 *len = 0;
382         else {
383                 /* Parse the new frequency */
384                 if (*len > TMPBUFLEN - 1) {
385                         spin_unlock_irqrestore(&pm_lock, flags);
386                         return -EFAULT;
387                 }
388                 if (copy_from_user(buf, buffer, *len)) {
389                         spin_unlock_irqrestore(&pm_lock, flags);
390                         return -EFAULT;
391                 }
392                 buf[*len] = 0;
393                 p = buf;
394                 val = simple_strtoul(p, &p, 0);
395                 if (val > MAX_CPU_FREQ) {
396                         spin_unlock_irqrestore(&pm_lock, flags);
397                         return -EFAULT;
398                 }
399
400                 pll = val / 12;
401                 if ((pll > 33) || (pll < 7)) {  /* 396 MHz max, 84 MHz min */
402                         /* Revisit this for higher speed CPUs */
403                         spin_unlock_irqrestore(&pm_lock, flags);
404                         return -EFAULT;
405                 }
406
407                 old_baud_base = get_au1x00_uart_baud_base();
408                 old_cpu_freq = get_au1x00_speed();
409
410                 new_cpu_freq = pll * 12 * 1000000;
411                 new_baud_base = (new_cpu_freq / (2 * ((int)(au_readl(SYS_POWERCTRL)
412                                                             & 0x03) + 2) * 16));
413                 set_au1x00_speed(new_cpu_freq);
414                 set_au1x00_uart_baud_base(new_baud_base);
415
416                 old_refresh = au_readl(MEM_SDREFCFG) & 0x1ffffff;
417                 new_refresh = ((old_refresh * new_cpu_freq) / old_cpu_freq) |
418                               (au_readl(MEM_SDREFCFG) & ~0x1ffffff);
419
420                 au_writel(pll, SYS_CPUPLL);
421                 au_sync_delay(1);
422                 au_writel(new_refresh, MEM_SDREFCFG);
423                 au_sync_delay(1);
424
425                 for (i = 0; i < 4; i++)
426                         if (au_readl(UART_BASE + UART_MOD_CNTRL +
427                                      i * 0x00100000) == 3) {
428                                 old_clk = au_readl(UART_BASE + UART_CLK +
429                                                    i * 0x00100000);
430                                 baud_rate = old_baud_base / old_clk;
431                                 /*
432                                  * We won't get an exact baud rate and the error
433                                  * could be significant enough that our new
434                                  * calculation will result in a clock that will
435                                  * give us a baud rate that's too far off from
436                                  * what we really want.
437                                  */
438                                 if (baud_rate > 100000)
439                                         baud_rate = 115200;
440                                 else if (baud_rate > 50000)
441                                         baud_rate = 57600;
442                                 else if (baud_rate > 30000)
443                                         baud_rate = 38400;
444                                 else if (baud_rate > 17000)
445                                         baud_rate = 19200;
446                                 else
447                                         baud_rate = 9600;
448                                 new_clk = new_baud_base / baud_rate;
449                                 au_writel(new_clk, UART_BASE + UART_CLK +
450                                           i * 0x00100000);
451                                 au_sync_delay(10);
452                         }
453         }
454
455         /*
456          * We don't want _any_ interrupts other than match20. Otherwise our
457          * au1000_calibrate_delay() calculation will be off, potentially a lot.
458          */
459         intc0_mask = save_local_and_disable(0);
460         intc1_mask = save_local_and_disable(1);
461         val = 1 << (AU1000_TOY_MATCH2_INT - AU1000_INTC0_INT_BASE);
462         au_writel(val, IC0_MASKSET);    /* unmask */
463         au_writel(val, IC0_WAKESET);    /* enable wake-from-sleep */
464         au_sync();
465         spin_unlock_irqrestore(&pm_lock, flags);
466         au1000_calibrate_delay();
467         restore_local_and_enable(0, intc0_mask);
468         restore_local_and_enable(1, intc1_mask);
469
470         return retval;
471 }
472 #endif
473
474 static struct ctl_table pm_table[] = {
475         {
476                 .ctl_name       = CTL_UNNUMBERED,
477                 .procname       = "sleep",
478                 .data           = NULL,
479                 .maxlen         = 0,
480                 .mode           = 0600,
481                 .proc_handler   = &pm_do_sleep
482         },
483 #if !defined(CONFIG_SOC_AU1200) && !defined(CONFIG_SOC_AU1550)
484         {
485                 .ctl_name       = CTL_UNNUMBERED,
486                 .procname       = "freq",
487                 .data           = NULL,
488                 .maxlen         = 0,
489                 .mode           = 0600,
490                 .proc_handler   = &pm_do_freq
491         },
492 #endif
493         {}
494 };
495
496 static struct ctl_table pm_dir_table[] = {
497         {
498                 .ctl_name       = CTL_UNNUMBERED,
499                 .procname       = "pm",
500                 .mode           = 0555,
501                 .child          = pm_table
502         },
503         {}
504 };
505
506 /*
507  * Initialize power interface
508  */
509 static int __init pm_init(void)
510 {
511         /* init TOY to tick at 1Hz. No need to wait for access bits
512          * since there's plenty of time between here and the first
513          * suspend cycle.
514          */
515         if (au_readl(SYS_TOYTRIM) != 32767) {
516                 au_writel(32767, SYS_TOYTRIM);
517                 au_sync();
518         }
519
520         register_sysctl_table(pm_dir_table);
521         return 0;
522 }
523
524 __initcall(pm_init);
525
526 #endif  /* CONFIG_PM */