linux/drivers/char/snsc_event.c
<<
>>
Prefs
   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}
 305
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.