1/*
  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 *
  8 * Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
  9 */
 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/slab.h>
 21#include <asm/byteorder.h>
 22#include <asm/sn/sn_sal.h>
 23#include <asm/unaligned.h>
 24#include "snsc.h"
 25
 26static struct subch_data_s *event_sd;
 27
 28void scdrv_event(unsigned long);
 29DECLARE_TASKLET(sn_sysctl_event, scdrv_event, 0);
 30
 31/*
 32 * scdrv_event_interrupt
 33 *
 34 * Pull incoming environmental events off the physical link to the
 35 * system controller and put them in a temporary holding area in SAL.
 36 * Schedule scdrv_event() to move them along to their ultimate
 37 * destination.
 38 */
 39static irqreturn_t
 40scdrv_event_interrupt(int irq, void *subch_data)
 41{
 42	struct subch_data_s *sd = subch_data;
 43	unsigned long flags;
 44	int status;
 45
 46	spin_lock_irqsave(&sd->sd_rlock, flags);
 47	status = ia64_sn_irtr_intr(sd->sd_nasid, sd->sd_subch);
 48
 49	if ((status > 0) && (status & SAL_IROUTER_INTR_RECV)) {
 50		tasklet_schedule(&sn_sysctl_event);
 51	}
 52	spin_unlock_irqrestore(&sd->sd_rlock, flags);
 53	return IRQ_HANDLED;
 54}
 55
 56
 57/*
 58 * scdrv_parse_event
 59 *
 60 * Break an event (as read from SAL) into useful pieces so we can decide
 61 * what to do with it.
 62 */
 63static int
 64scdrv_parse_event(char *event, int *src, int *code, int *esp_code, char *desc)
 65{
 66	char *desc_end;
 67
 68	/* record event source address */
 69	*src = get_unaligned_be32(event);
 70	event += 4; 			/* move on to event code */
 71
 72	/* record the system controller's event code */
 73	*code = get_unaligned_be32(event);
 74	event += 4;			/* move on to event arguments */
 75
 76	/* how many arguments are in the packet? */
 77	if (*event++ != 2) {
 78		/* if not 2, give up */
 79		return -1;
 80	}
 81
 82	/* parse out the ESP code */
 83	if (*event++ != IR_ARG_INT) {
 84		/* not an integer argument, so give up */
 85		return -1;
 86	}
 87	*esp_code = get_unaligned_be32(event);
 88	event += 4;
 89
 90	/* parse out the event description */
 91	if (*event++ != IR_ARG_ASCII) {
 92		/* not an ASCII string, so give up */
 93		return -1;
 94	}
 95	event[CHUNKSIZE-1] = '\0';	/* ensure this string ends! */
 96	event += 2; 			/* skip leading CR/LF */
 97	desc_end = desc + sprintf(desc, "%s", event);
 98
 99	/* strip trailing CR/LF (if any) */
100	for (desc_end--;
101	     (desc_end != desc) && ((*desc_end == 0xd) || (*desc_end == 0xa));
102	     desc_end--) {
103		*desc_end = '\0';
104	}
105
106	return 0;
107}
108
109
110/*
111 * scdrv_event_severity
112 *
113 * Figure out how urgent a message we should write to the console/syslog
114 * via printk.
115 */
116static char *
117scdrv_event_severity(int code)
118{
119	int ev_class = (code & EV_CLASS_MASK);
120	int ev_severity = (code & EV_SEVERITY_MASK);
121	char *pk_severity = KERN_NOTICE;
122
123	switch (ev_class) {
124	case EV_CLASS_POWER:
125		switch (ev_severity) {
126		case EV_SEVERITY_POWER_LOW_WARNING:
127		case EV_SEVERITY_POWER_HIGH_WARNING:
128			pk_severity = KERN_WARNING;
129			break;
130		case EV_SEVERITY_POWER_HIGH_FAULT:
131		case EV_SEVERITY_POWER_LOW_FAULT:
132			pk_severity = KERN_ALERT;
133			break;
134		}
135		break;
136	case EV_CLASS_FAN:
137		switch (ev_severity) {
138		case EV_SEVERITY_FAN_WARNING:
139			pk_severity = KERN_WARNING;
140			break;
141		case EV_SEVERITY_FAN_FAULT:
142			pk_severity = KERN_CRIT;
143			break;
144		}
145		break;
146	case EV_CLASS_TEMP:
147		switch (ev_severity) {
148		case EV_SEVERITY_TEMP_ADVISORY:
149			pk_severity = KERN_WARNING;
150			break;
151		case EV_SEVERITY_TEMP_CRITICAL:
152			pk_severity = KERN_CRIT;
153			break;
154		case EV_SEVERITY_TEMP_FAULT:
155			pk_severity = KERN_ALERT;
156			break;
157		}
158		break;
159	case EV_CLASS_ENV:
160		pk_severity = KERN_ALERT;
161		break;
162	case EV_CLASS_TEST_FAULT:
163		pk_severity = KERN_ALERT;
164		break;
165	case EV_CLASS_TEST_WARNING:
166		pk_severity = KERN_WARNING;
167		break;
168	case EV_CLASS_PWRD_NOTIFY:
169		pk_severity = KERN_ALERT;
170		break;
171	}
172
173	return pk_severity;
174}
175
176
177/*
178 * scdrv_dispatch_event
179 *
180 * Do the right thing with an incoming event.  That's often nothing
181 * more than printing it to the system log.  For power-down notifications
182 * we start a graceful shutdown.
183 */
184static void
185scdrv_dispatch_event(char *event, int len)
186{
187	static int snsc_shutting_down = 0;
188	int code, esp_code, src, class;
189	char desc[CHUNKSIZE];
190	char *severity;
191
192	if (scdrv_parse_event(event, &src, &code, &esp_code, desc) < 0) {
193		/* ignore uninterpretible event */
194		return;
195	}
196
197	/* how urgent is the message? */
198	severity = scdrv_event_severity(code);
199
200	class = (code & EV_CLASS_MASK);
201
202	if (class == EV_CLASS_PWRD_NOTIFY || code == ENV_PWRDN_PEND) {
203		if (snsc_shutting_down)
204			return;
205
206		snsc_shutting_down = 1;
207
208		/* give a message for each type of event */
209		if (class == EV_CLASS_PWRD_NOTIFY)
210			printk(KERN_NOTICE "Power off indication received."
211			       " Sending SIGPWR to init...\n");
212		else if (code == ENV_PWRDN_PEND)
213			printk(KERN_CRIT "WARNING: Shutting down the system"
214			       " due to a critical environmental condition."
215			       " Sending SIGPWR to init...\n");
216
217		/* give a SIGPWR signal to init proc */
218		kill_cad_pid(SIGPWR, 0);
219	} else {
220		/* print to system log */
221		printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
222	}
223}
224
225
226/*
227 * scdrv_event
228 *
229 * Called as a tasklet when an event arrives from the L1.  Read the event
230 * from where it's temporarily stored in SAL and call scdrv_dispatch_event()
231 * to send it on its way.  Keep trying to read events until SAL indicates
232 * that there are no more immediately available.
233 */
234void
235scdrv_event(unsigned long dummy)
236{
237	int status;
238	int len;
239	unsigned long flags;
240	struct subch_data_s *sd = event_sd;
241
242	/* anything to read? */
243	len = CHUNKSIZE;
244	spin_lock_irqsave(&sd->sd_rlock, flags);
245	status = ia64_sn_irtr_recv(sd->sd_nasid, sd->sd_subch,
246				   sd->sd_rb, &len);
247
248	while (!(status < 0)) {
249		spin_unlock_irqrestore(&sd->sd_rlock, flags);
250		scdrv_dispatch_event(sd->sd_rb, len);
251		len = CHUNKSIZE;
252		spin_lock_irqsave(&sd->sd_rlock, flags);
253		status = ia64_sn_irtr_recv(sd->sd_nasid, sd->sd_subch,
254					   sd->sd_rb, &len);
255	}
256	spin_unlock_irqrestore(&sd->sd_rlock, flags);
257}
258
259
260/*
261 * scdrv_event_init
262 *
263 * Sets up a system controller subchannel to begin receiving event
264 * messages. This is sort of a specialized version of scdrv_open()
265 * in drivers/char/sn_sysctl.c.
266 */
267void
268scdrv_event_init(struct sysctl_data_s *scd)
269{
270	int rv;
271
272	event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
273	if (event_sd == NULL) {
274		printk(KERN_WARNING "%s: couldn't allocate subchannel info"
275		       " for event monitoring\n", __func__);
276		return;
277	}
278
279	/* initialize subch_data_s fields */
280	event_sd->sd_nasid = scd->scd_nasid;
281	spin_lock_init(&event_sd->sd_rlock);
282
283	/* ask the system controllers to send events to this node */
284	event_sd->sd_subch = ia64_sn_sysctl_event_init(scd->scd_nasid);
285
286	if (event_sd->sd_subch < 0) {
287		kfree(event_sd);
288		printk(KERN_WARNING "%s: couldn't open event subchannel\n",
289		       __func__);
290		return;
291	}
292
293	/* hook event subchannel up to the system controller interrupt */
294	rv = request_irq(SGI_UART_VECTOR, scdrv_event_interrupt,
295			 IRQF_SHARED | IRQF_DISABLED,
296			 "system controller events", event_sd);
297	if (rv) {
298		printk(KERN_WARNING "%s: irq request failed (%d)\n",
299		       __func__, rv);
300		ia64_sn_irtr_close(event_sd->sd_nasid, event_sd->sd_subch);
301		kfree(event_sd);
302		return;
303	}
304}