[IA64-SGI] snsc_event.c new file

Forgot the "bk new" to add this file. Part of the patch
from Greg Howard

Signed-off-by: Tony Luck <tony.luck@intel.com>

diff --git a/drivers/char/snsc_event.c b/drivers/char/snsc_event.c
new file mode 100644 (file)
index 0000000..d692af5
--- /dev/null
+++ b/drivers/char/snsc_event.c
@@ -0,0 +1,304 @@
+/*
+ * 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 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/byteorder/generic.h>
+#include <asm/sn/sn_sal.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 pt_regs *regs)
+{
+       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 = be32_to_cpup((__be32 *)event);
+       event += 4;                     /* move on to event code */
+
+       /* record the system controller's event code */
+       *code = be32_to_cpup((__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 = be32_to_cpup((__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)
+{
+       int code, esp_code, src;
+       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);
+
+       if ((code & EV_CLASS_MASK) == EV_CLASS_PWRD_NOTIFY) {
+               struct task_struct *p;
+
+               /* give a SIGPWR signal to init proc */
+
+               /* first find init's task */
+               read_lock(&tasklist_lock);
+               for_each_process(p) {
+                       if (p->pid == 1)
+                               break;
+               }
+               if (p) { /* we found init's task */
+                       printk(KERN_EMERG "Power off indication received. Initiating power fail sequence...\n");
+                       force_sig(SIGPWR, p);
+               } else { /* failed to find init's task - just give message(s) */
+                       printk(KERN_WARNING "Failed to find init proc to handle power off!\n");
+                       printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
+               }
+               read_unlock(&tasklist_lock);
+       } 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 = kmalloc(sizeof (struct subch_data_s), GFP_KERNEL);
+       if (event_sd == NULL) {
+               printk(KERN_WARNING "%s: couldn't allocate subchannel info"
+                      " for event monitoring\n", __FUNCTION__);
+               return;
+       }
+
+       /* initialize subch_data_s fields */
+       memset(event_sd, 0, sizeof (struct subch_data_s));
+       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",
+                      __FUNCTION__);
+               return;
+       }
+
+       /* hook event subchannel up to the system controller interrupt */
+       rv = request_irq(SGI_UART_VECTOR, scdrv_event_interrupt,
+                        SA_SHIRQ | SA_INTERRUPT,
+                        "system controller events", event_sd);
+       if (rv) {
+               printk(KERN_WARNING "%s: irq request failed (%d)\n",
+                      __FUNCTION__, rv);
+               ia64_sn_irtr_close(event_sd->sd_nasid, event_sd->sd_subch);
+               kfree(event_sd);
+               return;
+       }
+}
+
+