Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/parisc/kernel/power.c | |
3 | * HP PARISC soft power switch support driver | |
4 | * | |
8039de10 | 5 | * Copyright (c) 2001-2005 Helge Deller <deller@gmx.de> |
1da177e4 LT |
6 | * All rights reserved. |
7 | * | |
8 | * | |
9 | * Redistribution and use in source and binary forms, with or without | |
10 | * modification, are permitted provided that the following conditions | |
11 | * are met: | |
12 | * 1. Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions, and the following disclaimer, | |
14 | * without modification. | |
15 | * 2. The name of the author may not be used to endorse or promote products | |
16 | * derived from this software without specific prior written permission. | |
17 | * | |
18 | * Alternatively, this software may be distributed under the terms of the | |
19 | * GNU General Public License ("GPL"). | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND | |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR | |
25 | * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
30 | * | |
31 | * | |
32 | * | |
33 | * HINT: | |
34 | * Support of the soft power switch button may be enabled or disabled at | |
35 | * runtime through the "/proc/sys/kernel/power" procfs entry. | |
36 | */ | |
37 | ||
38 | #include <linux/config.h> | |
39 | #include <linux/module.h> | |
40 | #include <linux/init.h> | |
41 | #include <linux/kernel.h> | |
42 | #include <linux/string.h> | |
43 | #include <linux/notifier.h> | |
44 | #include <linux/reboot.h> | |
45 | #include <linux/sched.h> | |
46 | #include <linux/interrupt.h> | |
47 | #include <linux/workqueue.h> | |
48 | ||
49 | #include <asm/pdc.h> | |
50 | #include <asm/io.h> | |
51 | #include <asm/led.h> | |
52 | #include <asm/uaccess.h> | |
53 | ||
54 | ||
55 | #ifdef DEBUG | |
56 | # define DPRINTK(x...) printk(x) | |
57 | #else | |
58 | # define DPRINTK(x...) | |
59 | #endif | |
60 | ||
61 | ||
62 | /* filename in /proc which can be used to enable/disable the power switch */ | |
63 | #define SYSCTL_FILENAME "sys/kernel/power" | |
64 | ||
65 | ||
66 | #define DIAG_CODE(code) (0x14000000 + ((code)<<5)) | |
67 | ||
68 | /* this will go to processor.h or any other place... */ | |
69 | /* taken from PCXL ERS page 82 */ | |
70 | #define MFCPU_X(rDiagReg, t_ch, t_th, code) \ | |
71 | (DIAG_CODE(code) + ((rDiagReg)<<21) + ((t_ch)<<16) + ((t_th)<<0) ) | |
72 | ||
73 | #define MTCPU(dr, gr) MFCPU_X(dr, gr, 0, 0x12) /* move value of gr to dr[dr] */ | |
74 | #define MFCPU_C(dr, gr) MFCPU_X(dr, gr, 0, 0x30) /* for dr0 and dr8 only ! */ | |
75 | #define MFCPU_T(dr, gr) MFCPU_X(dr, 0, gr, 0xa0) /* all dr except dr0 and dr8 */ | |
76 | ||
77 | #define __getDIAG(dr) ( { \ | |
78 | register unsigned long __res asm("r28");\ | |
79 | __asm__ __volatile__ ( \ | |
80 | ".word %1\n nop\n" : "=&r" (__res) : "i" (MFCPU_T(dr,28)) \ | |
81 | ); \ | |
82 | __res; \ | |
83 | } ) | |
84 | ||
85 | ||
86 | static void deferred_poweroff(void *dummy) | |
87 | { | |
88 | extern int cad_pid; /* from kernel/sys.c */ | |
89 | if (kill_proc(cad_pid, SIGINT, 1)) { | |
90 | /* just in case killing init process failed */ | |
91 | machine_power_off(); | |
92 | } | |
93 | } | |
94 | ||
95 | /* | |
96 | * This function gets called from interrupt context. | |
97 | * As it's called within an interrupt, it wouldn't sync if we don't | |
98 | * use schedule_work(). | |
99 | */ | |
100 | ||
101 | static DECLARE_WORK(poweroff_work, deferred_poweroff, NULL); | |
102 | ||
103 | static void poweroff(void) | |
104 | { | |
8039de10 | 105 | static int powering_off __read_mostly; |
1da177e4 LT |
106 | |
107 | if (powering_off) | |
108 | return; | |
109 | ||
110 | powering_off++; | |
111 | schedule_work(&poweroff_work); | |
112 | } | |
113 | ||
114 | ||
115 | /* local time-counter for shutdown */ | |
8039de10 | 116 | static int shutdown_timer __read_mostly; |
1da177e4 LT |
117 | |
118 | /* check, give feedback and start shutdown after one second */ | |
119 | static void process_shutdown(void) | |
120 | { | |
121 | if (shutdown_timer == 0) | |
122 | DPRINTK(KERN_INFO "Shutdown requested...\n"); | |
123 | ||
124 | shutdown_timer++; | |
125 | ||
126 | /* wait until the button was pressed for 1 second */ | |
127 | if (shutdown_timer == HZ) { | |
128 | #if defined (DEBUG) || defined(CONFIG_CHASSIS_LCD_LED) | |
129 | static char msg[] = "Shutting down..."; | |
130 | #endif | |
131 | DPRINTK(KERN_INFO "%s\n", msg); | |
132 | lcd_print(msg); | |
133 | poweroff(); | |
134 | } | |
135 | } | |
136 | ||
137 | ||
138 | /* main power switch tasklet struct (scheduled from time.c) */ | |
139 | DECLARE_TASKLET_DISABLED(power_tasklet, NULL, 0); | |
140 | ||
141 | /* soft power switch enabled/disabled */ | |
8039de10 | 142 | int pwrsw_enabled __read_mostly = 1; |
1da177e4 LT |
143 | |
144 | /* | |
145 | * On gecko style machines (e.g. 712/xx and 715/xx) | |
146 | * the power switch status is stored in Bit 0 ("the highest bit") | |
147 | * of CPU diagnose register 25. | |
148 | * | |
149 | */ | |
150 | static void gecko_tasklet_func(unsigned long unused) | |
151 | { | |
8039de10 | 152 | if (unlikely(!pwrsw_enabled)) |
1da177e4 LT |
153 | return; |
154 | ||
155 | if (__getDIAG(25) & 0x80000000) { | |
156 | /* power switch button not pressed or released again */ | |
157 | /* Warning: Some machines do never reset this DIAG flag! */ | |
158 | shutdown_timer = 0; | |
159 | } else { | |
160 | process_shutdown(); | |
161 | } | |
162 | } | |
163 | ||
164 | ||
165 | ||
166 | /* | |
167 | * Check the power switch status which is read from the | |
168 | * real I/O location at soft_power_reg. | |
169 | * Bit 31 ("the lowest bit) is the status of the power switch. | |
170 | */ | |
171 | ||
172 | static void polling_tasklet_func(unsigned long soft_power_reg) | |
173 | { | |
174 | unsigned long current_status; | |
175 | ||
8039de10 | 176 | if (unlikely(!pwrsw_enabled)) |
1da177e4 LT |
177 | return; |
178 | ||
179 | current_status = gsc_readl(soft_power_reg); | |
180 | if (current_status & 0x1) { | |
181 | /* power switch button not pressed */ | |
182 | shutdown_timer = 0; | |
183 | } else { | |
184 | process_shutdown(); | |
185 | } | |
186 | } | |
187 | ||
188 | ||
189 | /* | |
190 | * powerfail interruption handler (irq IRQ_FROM_REGION(CPU_IRQ_REGION)+2) | |
191 | */ | |
192 | #if 0 | |
193 | static void powerfail_interrupt(int code, void *x, struct pt_regs *regs) | |
194 | { | |
195 | printk(KERN_CRIT "POWERFAIL INTERRUPTION !\n"); | |
196 | poweroff(); | |
197 | } | |
198 | #endif | |
199 | ||
200 | ||
201 | ||
202 | ||
203 | /* parisc_panic_event() is called by the panic handler. | |
204 | * As soon as a panic occurs, our tasklets above will not be | |
205 | * executed any longer. This function then re-enables the | |
206 | * soft-power switch and allows the user to switch off the system | |
207 | */ | |
208 | static int parisc_panic_event(struct notifier_block *this, | |
209 | unsigned long event, void *ptr) | |
210 | { | |
211 | /* re-enable the soft-power switch */ | |
212 | pdc_soft_power_button(0); | |
213 | return NOTIFY_DONE; | |
214 | } | |
215 | ||
216 | static struct notifier_block parisc_panic_block = { | |
217 | .notifier_call = parisc_panic_event, | |
218 | .priority = INT_MAX, | |
219 | }; | |
220 | ||
221 | ||
222 | static int __init power_init(void) | |
223 | { | |
224 | unsigned long ret; | |
225 | unsigned long soft_power_reg = 0; | |
226 | ||
227 | #if 0 | |
228 | request_irq( IRQ_FROM_REGION(CPU_IRQ_REGION)+2, &powerfail_interrupt, | |
229 | 0, "powerfail", NULL); | |
230 | #endif | |
231 | ||
232 | /* enable the soft power switch if possible */ | |
233 | ret = pdc_soft_power_info(&soft_power_reg); | |
234 | if (ret == PDC_OK) | |
235 | ret = pdc_soft_power_button(1); | |
236 | if (ret != PDC_OK) | |
237 | soft_power_reg = -1UL; | |
238 | ||
239 | switch (soft_power_reg) { | |
240 | case 0: printk(KERN_INFO "Gecko-style soft power switch enabled.\n"); | |
241 | power_tasklet.func = gecko_tasklet_func; | |
242 | break; | |
243 | ||
244 | case -1UL: printk(KERN_INFO "Soft power switch support not available.\n"); | |
245 | return -ENODEV; | |
246 | ||
247 | default: printk(KERN_INFO "Soft power switch enabled, polling @ 0x%08lx.\n", | |
248 | soft_power_reg); | |
249 | power_tasklet.data = soft_power_reg; | |
250 | power_tasklet.func = polling_tasklet_func; | |
251 | } | |
252 | ||
253 | /* Register a call for panic conditions. */ | |
254 | notifier_chain_register(&panic_notifier_list, &parisc_panic_block); | |
255 | ||
256 | tasklet_enable(&power_tasklet); | |
257 | ||
258 | return 0; | |
259 | } | |
260 | ||
261 | static void __exit power_exit(void) | |
262 | { | |
263 | if (!power_tasklet.func) | |
264 | return; | |
265 | ||
266 | tasklet_disable(&power_tasklet); | |
267 | notifier_chain_unregister(&panic_notifier_list, &parisc_panic_block); | |
268 | power_tasklet.func = NULL; | |
269 | pdc_soft_power_button(0); | |
270 | } | |
271 | ||
272 | module_init(power_init); | |
273 | module_exit(power_exit); | |
274 | ||
275 | ||
276 | MODULE_AUTHOR("Helge Deller"); | |
277 | MODULE_DESCRIPTION("Soft power switch driver"); | |
278 | MODULE_LICENSE("Dual BSD/GPL"); |