[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / char / snsc_event.c

/*
 * SN Platform system controller communication support
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
 */

/*
 * System controller event handler
 *
 * These routines deal with environmental events arriving from the
 * system controllers.
 */

#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <asm/byteorder.h>
#include <asm/sn/sn_sal.h>
#include <asm/unaligned.h>
#include "snsc.h"

static struct subch_data_s *event_sd;

void scdrv_event(unsigned long);
DECLARE_TASKLET(sn_sysctl_event, scdrv_event, 0);

/*
 * scdrv_event_interrupt
 *
 * Pull incoming environmental events off the physical link to the
 * system controller and put them in a temporary holding area in SAL.
 * Schedule scdrv_event() to move them along to their ultimate
 * destination.
 */
static irqreturn_t
scdrv_event_interrupt(int irq, void *subch_data)
{
	struct subch_data_s *sd = subch_data;
	unsigned long flags;
	int status;

	spin_lock_irqsave(&sd->sd_rlock, flags);
	status = ia64_sn_irtr_intr(sd->sd_nasid, sd->sd_subch);

	if ((status > 0) && (status & SAL_IROUTER_INTR_RECV)) {
		tasklet_schedule(&sn_sysctl_event);
	}
	spin_unlock_irqrestore(&sd->sd_rlock, flags);
	return IRQ_HANDLED;
}


/*
 * scdrv_parse_event
 *
 * Break an event (as read from SAL) into useful pieces so we can decide
 * what to do with it.
 */
static int
scdrv_parse_event(char *event, int *src, int *code, int *esp_code, char *desc)
{
	char *desc_end;

	/* record event source address */
	*src = get_unaligned_be32(event);
	event += 4; 			/* move on to event code */

	/* record the system controller's event code */
	*code = get_unaligned_be32(event);
	event += 4;			/* move on to event arguments */

	/* how many arguments are in the packet? */
	if (*event++ != 2) {
		/* if not 2, give up */
		return -1;
	}

	/* parse out the ESP code */
	if (*event++ != IR_ARG_INT) {
		/* not an integer argument, so give up */
		return -1;
	}
	*esp_code = get_unaligned_be32(event);
	event += 4;

	/* parse out the event description */
	if (*event++ != IR_ARG_ASCII) {
		/* not an ASCII string, so give up */
		return -1;
	}
	event[CHUNKSIZE-1] = '\0';	/* ensure this string ends! */
	event += 2; 			/* skip leading CR/LF */
	desc_end = desc + sprintf(desc, "%s", event);

	/* strip trailing CR/LF (if any) */
	for (desc_end--;
	     (desc_end != desc) && ((*desc_end == 0xd) || (*desc_end == 0xa));
	     desc_end--) {
		*desc_end = '\0';
	}

	return 0;
}


/*
 * scdrv_event_severity
 *
 * Figure out how urgent a message we should write to the console/syslog
 * via printk.
 */
static char *
scdrv_event_severity(int code)
{
	int ev_class = (code & EV_CLASS_MASK);
	int ev_severity = (code & EV_SEVERITY_MASK);
	char *pk_severity = KERN_NOTICE;

	switch (ev_class) {
	case EV_CLASS_POWER:
		switch (ev_severity) {
		case EV_SEVERITY_POWER_LOW_WARNING:
		case EV_SEVERITY_POWER_HIGH_WARNING:
			pk_severity = KERN_WARNING;
			break;
		case EV_SEVERITY_POWER_HIGH_FAULT:
		case EV_SEVERITY_POWER_LOW_FAULT:
			pk_severity = KERN_ALERT;
			break;
		}
		break;
	case EV_CLASS_FAN:
		switch (ev_severity) {
		case EV_SEVERITY_FAN_WARNING:
			pk_severity = KERN_WARNING;
			break;
		case EV_SEVERITY_FAN_FAULT:
			pk_severity = KERN_CRIT;
			break;
		}
		break;
	case EV_CLASS_TEMP:
		switch (ev_severity) {
		case EV_SEVERITY_TEMP_ADVISORY:
			pk_severity = KERN_WARNING;
			break;
		case EV_SEVERITY_TEMP_CRITICAL:
			pk_severity = KERN_CRIT;
			break;
		case EV_SEVERITY_TEMP_FAULT:
			pk_severity = KERN_ALERT;
			break;
		}
		break;
	case EV_CLASS_ENV:
		pk_severity = KERN_ALERT;
		break;
	case EV_CLASS_TEST_FAULT:
		pk_severity = KERN_ALERT;
		break;
	case EV_CLASS_TEST_WARNING:
		pk_severity = KERN_WARNING;
		break;
	case EV_CLASS_PWRD_NOTIFY:
		pk_severity = KERN_ALERT;
		break;
	}

	return pk_severity;
}


/*
 * scdrv_dispatch_event
 *
 * Do the right thing with an incoming event.  That's often nothing
 * more than printing it to the system log.  For power-down notifications
 * we start a graceful shutdown.
 */
static void
scdrv_dispatch_event(char *event, int len)
{
	static int snsc_shutting_down = 0;
	int code, esp_code, src, class;
	char desc[CHUNKSIZE];
	char *severity;

	if (scdrv_parse_event(event, &src, &code, &esp_code, desc) < 0) {
		/* ignore uninterpretible event */
		return;
	}

	/* how urgent is the message? */
	severity = scdrv_event_severity(code);

	class = (code & EV_CLASS_MASK);

	if (class == EV_CLASS_PWRD_NOTIFY || code == ENV_PWRDN_PEND) {
		if (snsc_shutting_down)
			return;

		snsc_shutting_down = 1;

		/* give a message for each type of event */
		if (class == EV_CLASS_PWRD_NOTIFY)
			printk(KERN_NOTICE "Power off indication received."
			       " Sending SIGPWR to init...\n");
		else if (code == ENV_PWRDN_PEND)
			printk(KERN_CRIT "WARNING: Shutting down the system"
			       " due to a critical environmental condition."
			       " Sending SIGPWR to init...\n");

		/* give a SIGPWR signal to init proc */
		kill_cad_pid(SIGPWR, 0);
	} else {
		/* print to system log */
		printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
	}
}


/*
 * scdrv_event
 *
 * Called as a tasklet when an event arrives from the L1.  Read the event
 * from where it's temporarily stored in SAL and call scdrv_dispatch_event()
 * to send it on its way.  Keep trying to read events until SAL indicates
 * that there are no more immediately available.
 */
void
scdrv_event(unsigned long dummy)
{
	int status;
	int len;
	unsigned long flags;
	struct subch_data_s *sd = event_sd;

	/* anything to read? */
	len = CHUNKSIZE;
	spin_lock_irqsave(&sd->sd_rlock, flags);
	status = ia64_sn_irtr_recv(sd->sd_nasid, sd->sd_subch,
				   sd->sd_rb, &len);

	while (!(status < 0)) {
		spin_unlock_irqrestore(&sd->sd_rlock, flags);
		scdrv_dispatch_event(sd->sd_rb, len);
		len = CHUNKSIZE;
		spin_lock_irqsave(&sd->sd_rlock, flags);
		status = ia64_sn_irtr_recv(sd->sd_nasid, sd->sd_subch,
					   sd->sd_rb, &len);
	}
	spin_unlock_irqrestore(&sd->sd_rlock, flags);
}


/*
 * scdrv_event_init
 *
 * Sets up a system controller subchannel to begin receiving event
 * messages. This is sort of a specialized version of scdrv_open()
 * in drivers/char/sn_sysctl.c.
 */
void
scdrv_event_init(struct sysctl_data_s *scd)
{
	int rv;

	event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
	if (event_sd == NULL) {
		printk(KERN_WARNING "%s: couldn't allocate subchannel info"
		       " for event monitoring\n", __func__);
		return;
	}

	/* initialize subch_data_s fields */
	event_sd->sd_nasid = scd->scd_nasid;
	spin_lock_init(&event_sd->sd_rlock);

	/* ask the system controllers to send events to this node */
	event_sd->sd_subch = ia64_sn_sysctl_event_init(scd->scd_nasid);

	if (event_sd->sd_subch < 0) {
		kfree(event_sd);
		printk(KERN_WARNING "%s: couldn't open event subchannel\n",
		       __func__);
		return;
	}

	/* hook event subchannel up to the system controller interrupt */
	rv = request_irq(SGI_UART_VECTOR, scdrv_event_interrupt,
			 IRQF_SHARED | IRQF_DISABLED,
			 "system controller events", event_sd);
	if (rv) {
		printk(KERN_WARNING "%s: irq request failed (%d)\n",
		       __func__, rv);
		ia64_sn_irtr_close(event_sd->sd_nasid, event_sd->sd_subch);
		kfree(event_sd);
		return;
	}
}
Commit	Line	Data
fc626b27 GH	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	*
28ff6b9b	8	* Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
fc626b27 GH	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>
5a0e3ad6	20	#include <linux/slab.h>
9a6ab769	21	#include <asm/byteorder.h>
fc626b27	22	#include <asm/sn/sn_sal.h>
1a402aac	23	#include <asm/unaligned.h>
fc626b27 GH	24	#include "snsc.h"
	25
	26	static struct subch_data_s *event_sd;
	27
	28	void scdrv_event(unsigned long);
	29	DECLARE_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	*/
	39	static irqreturn_t
7d12e780	40	scdrv_event_interrupt(int irq, void *subch_data)
fc626b27 GH	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	*/
	63	static int
	64	scdrv_parse_event(char event, int src, int code, int esp_code, char *desc)
	65	{
	66	char *desc_end;
	67
	68	/* record event source address */
973ea70c	69	*src = get_unaligned_be32(event);
fc626b27 GH	70	event += 4; /* move on to event code */
	71
	72	/* record the system controller's event code */
973ea70c	73	*code = get_unaligned_be32(event);
fc626b27 GH	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	}
973ea70c	87	*esp_code = get_unaligned_be32(event);
fc626b27 GH	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	*/
	116	static char *
	117	scdrv_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	*/
184	static void
185	scdrv_dispatch_event(char *event, int len)
186	{
28ff6b9b AY	187	static int snsc_shutting_down = 0;
28ff6b9b AY	188	int code, esp_code, src, class;
fc626b27 GH	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
28ff6b9b AY	200	class = (code & EV_CLASS_MASK);
	201
	202	if (class == EV_CLASS_PWRD_NOTIFY \|\| code == ENV_PWRDN_PEND) {
28ff6b9b AY	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
fc626b27	217	/* give a SIGPWR signal to init proc */
9ec52099	218	kill_cad_pid(SIGPWR, 0);
fc626b27 GH	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	*/
	234	void
	235	scdrv_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	*/
	267	void
	268	scdrv_event_init(struct sysctl_data_s *scd)
	269	{
	270	int rv;
	271
40953ed8	272	event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
fc626b27 GH	273	if (event_sd == NULL) {
fc626b27 GH	274	printk(KERN_WARNING "%s: couldn't allocate subchannel info"
bf9d8929	275	" for event monitoring\n", __func__);
fc626b27 GH	276	return;
	277	}
	278
	279	/* initialize subch_data_s fields */
fc626b27 GH	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",
bf9d8929	289	__func__);
fc626b27 GH	290	return;
	291	}
	292
	293	/* hook event subchannel up to the system controller interrupt */
	294	rv = request_irq(SGI_UART_VECTOR, scdrv_event_interrupt,
0f2ed4c6	295	IRQF_SHARED \| IRQF_DISABLED,
fc626b27 GH	296	"system controller events", event_sd);
	297	if (rv) {
	298	printk(KERN_WARNING "%s: irq request failed (%d)\n",
bf9d8929	299	__func__, rv);
fc626b27 GH	300	ia64_sn_irtr_close(event_sd->sd_nasid, event_sd->sd_subch);
	301	kfree(event_sd);
	302	return;
	303	}
	304	}