blob: 8b2210b633dfc2845396451d573507d69f566fd2 [file] [log] [blame]
Greg Howardfc626b22005-04-25 13:29:46 -07001/*
2 * SN Platform system controller communication support
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
6 * for more details.
7 *
Aaron Young28ff6b9b2006-01-23 09:00:51 -08008 * Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
Greg Howardfc626b22005-04-25 13:29:46 -07009 */
10
11/*
12 * System controller event handler
13 *
14 * These routines deal with environmental events arriving from the
15 * system controllers.
16 */
17
18#include <linux/interrupt.h>
19#include <linux/sched.h>
20#include <linux/byteorder/generic.h>
21#include <asm/sn/sn_sal.h>
Greg Howard1a402aa2005-08-15 13:00:00 -070022#include <asm/unaligned.h>
Greg Howardfc626b22005-04-25 13:29:46 -070023#include "snsc.h"
24
25static struct subch_data_s *event_sd;
26
27void scdrv_event(unsigned long);
28DECLARE_TASKLET(sn_sysctl_event, scdrv_event, 0);
29
30/*
31 * scdrv_event_interrupt
32 *
33 * Pull incoming environmental events off the physical link to the
34 * system controller and put them in a temporary holding area in SAL.
35 * Schedule scdrv_event() to move them along to their ultimate
36 * destination.
37 */
38static irqreturn_t
39scdrv_event_interrupt(int irq, void *subch_data, struct pt_regs *regs)
40{
41 struct subch_data_s *sd = subch_data;
42 unsigned long flags;
43 int status;
44
45 spin_lock_irqsave(&sd->sd_rlock, flags);
46 status = ia64_sn_irtr_intr(sd->sd_nasid, sd->sd_subch);
47
48 if ((status > 0) && (status & SAL_IROUTER_INTR_RECV)) {
49 tasklet_schedule(&sn_sysctl_event);
50 }
51 spin_unlock_irqrestore(&sd->sd_rlock, flags);
52 return IRQ_HANDLED;
53}
54
55
56/*
57 * scdrv_parse_event
58 *
59 * Break an event (as read from SAL) into useful pieces so we can decide
60 * what to do with it.
61 */
62static int
63scdrv_parse_event(char *event, int *src, int *code, int *esp_code, char *desc)
64{
65 char *desc_end;
Greg Howard1a402aa2005-08-15 13:00:00 -070066 __be32 from_buf;
Greg Howardfc626b22005-04-25 13:29:46 -070067
68 /* record event source address */
Greg Howard1a402aa2005-08-15 13:00:00 -070069 from_buf = get_unaligned((__be32 *)event);
70 *src = be32_to_cpup(&from_buf);
Greg Howardfc626b22005-04-25 13:29:46 -070071 event += 4; /* move on to event code */
72
73 /* record the system controller's event code */
Greg Howard1a402aa2005-08-15 13:00:00 -070074 from_buf = get_unaligned((__be32 *)event);
75 *code = be32_to_cpup(&from_buf);
Greg Howardfc626b22005-04-25 13:29:46 -070076 event += 4; /* move on to event arguments */
77
78 /* how many arguments are in the packet? */
79 if (*event++ != 2) {
80 /* if not 2, give up */
81 return -1;
82 }
83
84 /* parse out the ESP code */
85 if (*event++ != IR_ARG_INT) {
86 /* not an integer argument, so give up */
87 return -1;
88 }
Greg Howard1a402aa2005-08-15 13:00:00 -070089 from_buf = get_unaligned((__be32 *)event);
90 *esp_code = be32_to_cpup(&from_buf);
Greg Howardfc626b22005-04-25 13:29:46 -070091 event += 4;
92
93 /* parse out the event description */
94 if (*event++ != IR_ARG_ASCII) {
95 /* not an ASCII string, so give up */
96 return -1;
97 }
98 event[CHUNKSIZE-1] = '\0'; /* ensure this string ends! */
99 event += 2; /* skip leading CR/LF */
100 desc_end = desc + sprintf(desc, "%s", event);
101
102 /* strip trailing CR/LF (if any) */
103 for (desc_end--;
104 (desc_end != desc) && ((*desc_end == 0xd) || (*desc_end == 0xa));
105 desc_end--) {
106 *desc_end = '\0';
107 }
108
109 return 0;
110}
111
112
113/*
114 * scdrv_event_severity
115 *
116 * Figure out how urgent a message we should write to the console/syslog
117 * via printk.
118 */
119static char *
120scdrv_event_severity(int code)
121{
122 int ev_class = (code & EV_CLASS_MASK);
123 int ev_severity = (code & EV_SEVERITY_MASK);
124 char *pk_severity = KERN_NOTICE;
125
126 switch (ev_class) {
127 case EV_CLASS_POWER:
128 switch (ev_severity) {
129 case EV_SEVERITY_POWER_LOW_WARNING:
130 case EV_SEVERITY_POWER_HIGH_WARNING:
131 pk_severity = KERN_WARNING;
132 break;
133 case EV_SEVERITY_POWER_HIGH_FAULT:
134 case EV_SEVERITY_POWER_LOW_FAULT:
135 pk_severity = KERN_ALERT;
136 break;
137 }
138 break;
139 case EV_CLASS_FAN:
140 switch (ev_severity) {
141 case EV_SEVERITY_FAN_WARNING:
142 pk_severity = KERN_WARNING;
143 break;
144 case EV_SEVERITY_FAN_FAULT:
145 pk_severity = KERN_CRIT;
146 break;
147 }
148 break;
149 case EV_CLASS_TEMP:
150 switch (ev_severity) {
151 case EV_SEVERITY_TEMP_ADVISORY:
152 pk_severity = KERN_WARNING;
153 break;
154 case EV_SEVERITY_TEMP_CRITICAL:
155 pk_severity = KERN_CRIT;
156 break;
157 case EV_SEVERITY_TEMP_FAULT:
158 pk_severity = KERN_ALERT;
159 break;
160 }
161 break;
162 case EV_CLASS_ENV:
163 pk_severity = KERN_ALERT;
164 break;
165 case EV_CLASS_TEST_FAULT:
166 pk_severity = KERN_ALERT;
167 break;
168 case EV_CLASS_TEST_WARNING:
169 pk_severity = KERN_WARNING;
170 break;
171 case EV_CLASS_PWRD_NOTIFY:
172 pk_severity = KERN_ALERT;
173 break;
174 }
175
176 return pk_severity;
177}
178
179
180/*
181 * scdrv_dispatch_event
182 *
183 * Do the right thing with an incoming event. That's often nothing
184 * more than printing it to the system log. For power-down notifications
185 * we start a graceful shutdown.
186 */
187static void
188scdrv_dispatch_event(char *event, int len)
189{
Aaron Young28ff6b9b2006-01-23 09:00:51 -0800190 static int snsc_shutting_down = 0;
191 int code, esp_code, src, class;
Greg Howardfc626b22005-04-25 13:29:46 -0700192 char desc[CHUNKSIZE];
193 char *severity;
194
195 if (scdrv_parse_event(event, &src, &code, &esp_code, desc) < 0) {
196 /* ignore uninterpretible event */
197 return;
198 }
199
200 /* how urgent is the message? */
201 severity = scdrv_event_severity(code);
202
Aaron Young28ff6b9b2006-01-23 09:00:51 -0800203 class = (code & EV_CLASS_MASK);
204
205 if (class == EV_CLASS_PWRD_NOTIFY || code == ENV_PWRDN_PEND) {
Greg Howardfc626b22005-04-25 13:29:46 -0700206 struct task_struct *p;
207
Aaron Young28ff6b9b2006-01-23 09:00:51 -0800208 if (snsc_shutting_down)
209 return;
210
211 snsc_shutting_down = 1;
212
213 /* give a message for each type of event */
214 if (class == EV_CLASS_PWRD_NOTIFY)
215 printk(KERN_NOTICE "Power off indication received."
216 " Sending SIGPWR to init...\n");
217 else if (code == ENV_PWRDN_PEND)
218 printk(KERN_CRIT "WARNING: Shutting down the system"
219 " due to a critical environmental condition."
220 " Sending SIGPWR to init...\n");
221
Greg Howardfc626b22005-04-25 13:29:46 -0700222 /* give a SIGPWR signal to init proc */
223
224 /* first find init's task */
225 read_lock(&tasklist_lock);
226 for_each_process(p) {
227 if (p->pid == 1)
228 break;
229 }
Aaron Young28ff6b9b2006-01-23 09:00:51 -0800230 if (p) {
Greg Howardfc626b22005-04-25 13:29:46 -0700231 force_sig(SIGPWR, p);
Aaron Young28ff6b9b2006-01-23 09:00:51 -0800232 } else {
233 printk(KERN_ERR "Failed to signal init!\n");
234 snsc_shutting_down = 0; /* so can try again (?) */
Greg Howardfc626b22005-04-25 13:29:46 -0700235 }
236 read_unlock(&tasklist_lock);
237 } else {
238 /* print to system log */
239 printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
240 }
241}
242
243
244/*
245 * scdrv_event
246 *
247 * Called as a tasklet when an event arrives from the L1. Read the event
248 * from where it's temporarily stored in SAL and call scdrv_dispatch_event()
249 * to send it on its way. Keep trying to read events until SAL indicates
250 * that there are no more immediately available.
251 */
252void
253scdrv_event(unsigned long dummy)
254{
255 int status;
256 int len;
257 unsigned long flags;
258 struct subch_data_s *sd = event_sd;
259
260 /* anything to read? */
261 len = CHUNKSIZE;
262 spin_lock_irqsave(&sd->sd_rlock, flags);
263 status = ia64_sn_irtr_recv(sd->sd_nasid, sd->sd_subch,
264 sd->sd_rb, &len);
265
266 while (!(status < 0)) {
267 spin_unlock_irqrestore(&sd->sd_rlock, flags);
268 scdrv_dispatch_event(sd->sd_rb, len);
269 len = CHUNKSIZE;
270 spin_lock_irqsave(&sd->sd_rlock, flags);
271 status = ia64_sn_irtr_recv(sd->sd_nasid, sd->sd_subch,
272 sd->sd_rb, &len);
273 }
274 spin_unlock_irqrestore(&sd->sd_rlock, flags);
275}
276
277
278/*
279 * scdrv_event_init
280 *
281 * Sets up a system controller subchannel to begin receiving event
282 * messages. This is sort of a specialized version of scdrv_open()
283 * in drivers/char/sn_sysctl.c.
284 */
285void
286scdrv_event_init(struct sysctl_data_s *scd)
287{
288 int rv;
289
Jes Sorensen40953ed2006-03-23 03:00:49 -0800290 event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
Greg Howardfc626b22005-04-25 13:29:46 -0700291 if (event_sd == NULL) {
292 printk(KERN_WARNING "%s: couldn't allocate subchannel info"
293 " for event monitoring\n", __FUNCTION__);
294 return;
295 }
296
297 /* initialize subch_data_s fields */
Greg Howardfc626b22005-04-25 13:29:46 -0700298 event_sd->sd_nasid = scd->scd_nasid;
299 spin_lock_init(&event_sd->sd_rlock);
300
301 /* ask the system controllers to send events to this node */
302 event_sd->sd_subch = ia64_sn_sysctl_event_init(scd->scd_nasid);
303
304 if (event_sd->sd_subch < 0) {
305 kfree(event_sd);
306 printk(KERN_WARNING "%s: couldn't open event subchannel\n",
307 __FUNCTION__);
308 return;
309 }
310
311 /* hook event subchannel up to the system controller interrupt */
312 rv = request_irq(SGI_UART_VECTOR, scdrv_event_interrupt,
Thomas Gleixner0f2ed4c2006-07-01 19:29:33 -0700313 IRQF_SHARED | IRQF_DISABLED,
Greg Howardfc626b22005-04-25 13:29:46 -0700314 "system controller events", event_sd);
315 if (rv) {
316 printk(KERN_WARNING "%s: irq request failed (%d)\n",
317 __FUNCTION__, rv);
318 ia64_sn_irtr_close(event_sd->sd_nasid, event_sd->sd_subch);
319 kfree(event_sd);
320 return;
321 }
322}