Merge master.kernel.org:/pub/scm/linux/kernel/git/lethal/sh-2.6
[linux-2.6] / arch / sparc64 / kernel / power.c
1 /* $Id: power.c,v 1.10 2001/12/11 01:57:16 davem Exp $
2  * power.c: Power management driver.
3  *
4  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
5  */
6
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/sched.h>
11 #include <linux/signal.h>
12 #include <linux/delay.h>
13 #include <linux/interrupt.h>
14 #include <linux/pm.h>
15 #include <linux/syscalls.h>
16
17 #include <asm/system.h>
18 #include <asm/auxio.h>
19 #include <asm/prom.h>
20 #include <asm/of_device.h>
21 #include <asm/io.h>
22 #include <asm/sstate.h>
23
24 #include <linux/unistd.h>
25
26 /*
27  * sysctl - toggle power-off restriction for serial console 
28  * systems in machine_power_off()
29  */
30 int scons_pwroff = 1; 
31
32 #ifdef CONFIG_PCI
33 #include <linux/pci.h>
34 static void __iomem *power_reg;
35
36 static DECLARE_WAIT_QUEUE_HEAD(powerd_wait);
37 static int button_pressed;
38
39 static irqreturn_t power_handler(int irq, void *dev_id)
40 {
41         if (button_pressed == 0) {
42                 button_pressed = 1;
43                 wake_up(&powerd_wait);
44         }
45
46         /* FIXME: Check registers for status... */
47         return IRQ_HANDLED;
48 }
49 #endif /* CONFIG_PCI */
50
51 extern void machine_halt(void);
52 extern void machine_alt_power_off(void);
53 static void (*poweroff_method)(void) = machine_alt_power_off;
54
55 void machine_power_off(void)
56 {
57         sstate_poweroff();
58         if (!serial_console || scons_pwroff) {
59 #ifdef CONFIG_PCI
60                 if (power_reg) {
61                         /* Both register bits seem to have the
62                          * same effect, so until I figure out
63                          * what the difference is...
64                          */
65                         writel(AUXIO_PCIO_CPWR_OFF | AUXIO_PCIO_SPWR_OFF, power_reg);
66                 } else
67 #endif /* CONFIG_PCI */
68                         if (poweroff_method != NULL) {
69                                 poweroff_method();
70                                 /* not reached */
71                         }
72         }
73         machine_halt();
74 }
75
76 void (*pm_power_off)(void) = machine_power_off;
77 EXPORT_SYMBOL(pm_power_off);
78
79 #ifdef CONFIG_PCI
80 static int powerd(void *__unused)
81 {
82         static char *envp[] = { "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
83         char *argv[] = { "/sbin/shutdown", "-h", "now", NULL };
84         DECLARE_WAITQUEUE(wait, current);
85
86         daemonize("powerd");
87
88         add_wait_queue(&powerd_wait, &wait);
89 again:
90         for (;;) {
91                 set_task_state(current, TASK_INTERRUPTIBLE);
92                 if (button_pressed)
93                         break;
94                 flush_signals(current);
95                 schedule();
96         }
97         __set_current_state(TASK_RUNNING);
98         remove_wait_queue(&powerd_wait, &wait);
99
100         /* Ok, down we go... */
101         button_pressed = 0;
102         if (kernel_execve("/sbin/shutdown", argv, envp) < 0) {
103                 printk("powerd: shutdown execution failed\n");
104                 add_wait_queue(&powerd_wait, &wait);
105                 goto again;
106         }
107         return 0;
108 }
109
110 static int __init has_button_interrupt(unsigned int irq, struct device_node *dp)
111 {
112         if (irq == PCI_IRQ_NONE)
113                 return 0;
114         if (!of_find_property(dp, "button", NULL))
115                 return 0;
116
117         return 1;
118 }
119
120 static int __devinit power_probe(struct of_device *op, const struct of_device_id *match)
121 {
122         struct resource *res = &op->resource[0];
123         unsigned int irq= op->irqs[0];
124
125         power_reg = of_ioremap(res, 0, 0x4, "power");
126
127         printk("%s: Control reg at %lx ... ",
128                op->node->name, res->start);
129
130         poweroff_method = machine_halt;  /* able to use the standard halt */
131
132         if (has_button_interrupt(irq, op->node)) {
133                 if (kernel_thread(powerd, NULL, CLONE_FS) < 0) {
134                         printk("Failed to start power daemon.\n");
135                         return 0;
136                 }
137                 printk("powerd running.\n");
138
139                 if (request_irq(irq,
140                                 power_handler, 0, "power", NULL) < 0)
141                         printk("power: Error, cannot register IRQ handler.\n");
142         } else {
143                 printk("not using powerd.\n");
144         }
145
146         return 0;
147 }
148
149 static struct of_device_id power_match[] = {
150         {
151                 .name = "power",
152         },
153         {},
154 };
155
156 static struct of_platform_driver power_driver = {
157         .name           = "power",
158         .match_table    = power_match,
159         .probe          = power_probe,
160 };
161
162 void __init power_init(void)
163 {
164         of_register_driver(&power_driver, &of_bus_type);
165         return;
166 }
167 #endif /* CONFIG_PCI */