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, "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