LXR linux/drivers/char/snsc

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