arch/powerpc/platforms/powernv/opal-hmi.c

   1 /*
   2  * OPAL hypervisor Maintenance interrupt handling support in PowreNV.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Copyright 2014 IBM Corporation
  18  * Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
  19  */
  20
  21 #undef DEBUG
  22
  23 #include <linux/kernel.h>
  24 #include <linux/init.h>
  25 #include <linux/of.h>
  26 #include <linux/mm.h>
  27 #include <linux/slab.h>
  28
  29 #include <asm/opal.h>
  30 #include <asm/cputable.h>
  31 #include <asm/machdep.h>
  32
  33 static int opal_hmi_handler_nb_init;
  34 struct OpalHmiEvtNode {
  35         struct list_head list;
  36         struct OpalHMIEvent hmi_evt;
  37 };
  38
  39 struct xstop_reason {
  40         uint32_t xstop_reason;
  41         const char *unit_failed;
  42         const char *description;
  43 };
  44
  45 static LIST_HEAD(opal_hmi_evt_list);
  46 static DEFINE_SPINLOCK(opal_hmi_evt_lock);
  47
  48 static void print_core_checkstop_reason(const char *level,
  49                                         struct OpalHMIEvent *hmi_evt)
  50 {
  51         int i;
  52         static const struct xstop_reason xstop_reason[] = {
  53                 { CORE_CHECKSTOP_IFU_REGFILE, "IFU",
  54                                 "RegFile core check stop" },
  55                 { CORE_CHECKSTOP_IFU_LOGIC, "IFU", "Logic core check stop" },
  56                 { CORE_CHECKSTOP_PC_DURING_RECOV, "PC",
  57                                 "Core checkstop during recovery" },
  58                 { CORE_CHECKSTOP_ISU_REGFILE, "ISU",
  59                                 "RegFile core check stop (mapper error)" },
  60                 { CORE_CHECKSTOP_ISU_LOGIC, "ISU", "Logic core check stop" },
  61                 { CORE_CHECKSTOP_FXU_LOGIC, "FXU", "Logic core check stop" },
  62                 { CORE_CHECKSTOP_VSU_LOGIC, "VSU", "Logic core check stop" },
  63                 { CORE_CHECKSTOP_PC_RECOV_IN_MAINT_MODE, "PC",
  64                                 "Recovery in maintenance mode" },
  65                 { CORE_CHECKSTOP_LSU_REGFILE, "LSU",
  66                                 "RegFile core check stop" },
  67                 { CORE_CHECKSTOP_PC_FWD_PROGRESS, "PC",
  68                                 "Forward Progress Error" },
  69                 { CORE_CHECKSTOP_LSU_LOGIC, "LSU", "Logic core check stop" },
  70                 { CORE_CHECKSTOP_PC_LOGIC, "PC", "Logic core check stop" },
  71                 { CORE_CHECKSTOP_PC_HYP_RESOURCE, "PC",
  72                                 "Hypervisor Resource error - core check stop" },
  73                 { CORE_CHECKSTOP_PC_HANG_RECOV_FAILED, "PC",
  74                                 "Hang Recovery Failed (core check stop)" },
  75                 { CORE_CHECKSTOP_PC_AMBI_HANG_DETECTED, "PC",
  76                                 "Ambiguous Hang Detected (unknown source)" },
  77                 { CORE_CHECKSTOP_PC_DEBUG_TRIG_ERR_INJ, "PC",
  78                                 "Debug Trigger Error inject" },
  79                 { CORE_CHECKSTOP_PC_SPRD_HYP_ERR_INJ, "PC",
  80                                 "Hypervisor check stop via SPRC/SPRD" },
  81         };
  82
  83         /* Validity check */
  84         if (!hmi_evt->u.xstop_error.xstop_reason) {
  85                 printk("%s      Unknown Core check stop.\n", level);
  86                 return;
  87         }
  88
  89         printk("%s      CPU PIR: %08x\n", level,
  90                         be32_to_cpu(hmi_evt->u.xstop_error.u.pir));
  91         for (i = 0; i < ARRAY_SIZE(xstop_reason); i++)
  92                 if (be32_to_cpu(hmi_evt->u.xstop_error.xstop_reason) &
  93                                         xstop_reason[i].xstop_reason)
  94                         printk("%s      [Unit: %-3s] %s\n", level,
  95                                         xstop_reason[i].unit_failed,
  96                                         xstop_reason[i].description);
  97 }
  98
  99 static void print_nx_checkstop_reason(const char *level,
 100                                         struct OpalHMIEvent *hmi_evt)
 101 {
 102         int i;
 103         static const struct xstop_reason xstop_reason[] = {
 104                 { NX_CHECKSTOP_SHM_INVAL_STATE_ERR, "DMA & Engine",
 105                                         "SHM invalid state error" },
 106                 { NX_CHECKSTOP_DMA_INVAL_STATE_ERR_1, "DMA & Engine",
 107                                         "DMA invalid state error bit 15" },
 108                 { NX_CHECKSTOP_DMA_INVAL_STATE_ERR_2, "DMA & Engine",
 109                                         "DMA invalid state error bit 16" },
 110                 { NX_CHECKSTOP_DMA_CH0_INVAL_STATE_ERR, "DMA & Engine",
 111                                         "Channel 0 invalid state error" },
 112                 { NX_CHECKSTOP_DMA_CH1_INVAL_STATE_ERR, "DMA & Engine",
 113                                         "Channel 1 invalid state error" },
 114                 { NX_CHECKSTOP_DMA_CH2_INVAL_STATE_ERR, "DMA & Engine",
 115                                         "Channel 2 invalid state error" },
 116                 { NX_CHECKSTOP_DMA_CH3_INVAL_STATE_ERR, "DMA & Engine",
 117                                         "Channel 3 invalid state error" },
 118                 { NX_CHECKSTOP_DMA_CH4_INVAL_STATE_ERR, "DMA & Engine",
 119                                         "Channel 4 invalid state error" },
 120                 { NX_CHECKSTOP_DMA_CH5_INVAL_STATE_ERR, "DMA & Engine",
 121                                         "Channel 5 invalid state error" },
 122                 { NX_CHECKSTOP_DMA_CH6_INVAL_STATE_ERR, "DMA & Engine",
 123                                         "Channel 6 invalid state error" },
 124                 { NX_CHECKSTOP_DMA_CH7_INVAL_STATE_ERR, "DMA & Engine",
 125                                         "Channel 7 invalid state error" },
 126                 { NX_CHECKSTOP_DMA_CRB_UE, "DMA & Engine",
 127                                         "UE error on CRB(CSB address, CCB)" },
 128                 { NX_CHECKSTOP_DMA_CRB_SUE, "DMA & Engine",
 129                                         "SUE error on CRB(CSB address, CCB)" },
 130                 { NX_CHECKSTOP_PBI_ISN_UE, "PowerBus Interface",
 131                 "CRB Kill ISN received while holding ISN with UE error" },
 132         };
 133
 134         /* Validity check */
 135         if (!hmi_evt->u.xstop_error.xstop_reason) {
 136                 printk("%s      Unknown NX check stop.\n", level);
 137                 return;
 138         }
 139
 140         printk("%s      NX checkstop on CHIP ID: %x\n", level,
 141                         be32_to_cpu(hmi_evt->u.xstop_error.u.chip_id));
 142         for (i = 0; i < ARRAY_SIZE(xstop_reason); i++)
 143                 if (be32_to_cpu(hmi_evt->u.xstop_error.xstop_reason) &
 144                                         xstop_reason[i].xstop_reason)
 145                         printk("%s      [Unit: %-3s] %s\n", level,
 146                                         xstop_reason[i].unit_failed,
 147                                         xstop_reason[i].description);
 148 }
 149
 150 static void print_checkstop_reason(const char *level,
 151                                         struct OpalHMIEvent *hmi_evt)
 152 {
 153         switch (hmi_evt->u.xstop_error.xstop_type) {
 154         case CHECKSTOP_TYPE_CORE:
 155                 print_core_checkstop_reason(level, hmi_evt);
 156                 break;
 157         case CHECKSTOP_TYPE_NX:
 158                 print_nx_checkstop_reason(level, hmi_evt);
 159                 break;
 160         case CHECKSTOP_TYPE_UNKNOWN:
 161                 printk("%s      Unknown Malfunction Alert.\n", level);
 162                 break;
 163         }
 164 }
 165
 166 static void print_hmi_event_info(struct OpalHMIEvent *hmi_evt)
 167 {
 168         const char *level, *sevstr, *error_info;
 169         static const char *hmi_error_types[] = {
 170                 "Malfunction Alert",
 171                 "Processor Recovery done",
 172                 "Processor recovery occurred again",
 173                 "Processor recovery occurred for masked error",
 174                 "Timer facility experienced an error",
 175                 "TFMR SPR is corrupted",
 176                 "UPS (Uniterrupted Power System) Overflow indication",
 177                 "An XSCOM operation failure",
 178                 "An XSCOM operation completed",
 179                 "SCOM has set a reserved FIR bit to cause recovery",
 180                 "Debug trigger has set a reserved FIR bit to cause recovery",
 181                 "A hypervisor resource error occurred"
 182         };
 183
 184         /* Print things out */
 185         if (hmi_evt->version < OpalHMIEvt_V1) {
 186                 pr_err("HMI Interrupt, Unknown event version %d !\n",
 187                         hmi_evt->version);
 188                 return;
 189         }
 190         switch (hmi_evt->severity) {
 191         case OpalHMI_SEV_NO_ERROR:
 192                 level = KERN_INFO;
 193                 sevstr = "Harmless";
 194                 break;
 195         case OpalHMI_SEV_WARNING:
 196                 level = KERN_WARNING;
 197                 sevstr = "";
 198                 break;
 199         case OpalHMI_SEV_ERROR_SYNC:
 200                 level = KERN_ERR;
 201                 sevstr = "Severe";
 202                 break;
 203         case OpalHMI_SEV_FATAL:
 204         default:
 205                 level = KERN_ERR;
 206                 sevstr = "Fatal";
 207                 break;
 208         }
 209
 210         printk("%s%s Hypervisor Maintenance interrupt [%s]\n",
 211                 level, sevstr,
 212                 hmi_evt->disposition == OpalHMI_DISPOSITION_RECOVERED ?
 213                 "Recovered" : "Not recovered");
 214         error_info = hmi_evt->type < ARRAY_SIZE(hmi_error_types) ?
 215                         hmi_error_types[hmi_evt->type]
 216                         : "Unknown";
 217         printk("%s Error detail: %s\n", level, error_info);
 218         printk("%s      HMER: %016llx\n", level, be64_to_cpu(hmi_evt->hmer));
 219         if ((hmi_evt->type == OpalHMI_ERROR_TFAC) ||
 220                 (hmi_evt->type == OpalHMI_ERROR_TFMR_PARITY))
 221                 printk("%s      TFMR: %016llx\n", level,
 222                                                 be64_to_cpu(hmi_evt->tfmr));
 223
 224         if (hmi_evt->version < OpalHMIEvt_V2)
 225                 return;
 226
 227         /* OpalHMIEvt_V2 and above provides reason for malfunction alert. */
 228         if (hmi_evt->type == OpalHMI_ERROR_MALFUNC_ALERT)
 229                 print_checkstop_reason(level, hmi_evt);
 230 }
 231
 232 static void hmi_event_handler(struct work_struct *work)
 233 {
 234         unsigned long flags;
 235         struct OpalHMIEvent *hmi_evt;
 236         struct OpalHmiEvtNode *msg_node;
 237         uint8_t disposition;
 238         struct opal_msg msg;
 239         int unrecoverable = 0;
 240
 241         spin_lock_irqsave(&opal_hmi_evt_lock, flags);
 242         while (!list_empty(&opal_hmi_evt_list)) {
 243                 msg_node = list_entry(opal_hmi_evt_list.next,
 244                                            struct OpalHmiEvtNode, list);
 245                 list_del(&msg_node->list);
 246                 spin_unlock_irqrestore(&opal_hmi_evt_lock, flags);
 247
 248                 hmi_evt = (struct OpalHMIEvent *) &msg_node->hmi_evt;
 249                 print_hmi_event_info(hmi_evt);
 250                 disposition = hmi_evt->disposition;
 251                 kfree(msg_node);
 252
 253                 /*
 254                  * Check if HMI event has been recovered or not. If not
 255                  * then kernel can't continue, we need to panic.
 256                  * But before we do that, display all the HMI event
 257                  * available on the list and set unrecoverable flag to 1.
 258                  */
 259                 if (disposition != OpalHMI_DISPOSITION_RECOVERED)
 260                         unrecoverable = 1;
 261
 262                 spin_lock_irqsave(&opal_hmi_evt_lock, flags);
 263         }
 264         spin_unlock_irqrestore(&opal_hmi_evt_lock, flags);
 265
 266         if (unrecoverable) {
 267                 int ret;
 268
 269                 /* Pull all HMI events from OPAL before we panic. */
 270                 while (opal_get_msg(__pa(&msg), sizeof(msg)) == OPAL_SUCCESS) {
 271                         u32 type;
 272
 273                         type = be32_to_cpu(msg.msg_type);
 274
 275                         /* skip if not HMI event */
 276                         if (type != OPAL_MSG_HMI_EVT)
 277                                 continue;
 278
 279                         /* HMI event info starts from param[0] */
 280                         hmi_evt = (struct OpalHMIEvent *)&msg.params[0];
 281                         print_hmi_event_info(hmi_evt);
 282                 }
 283
 284                 /*
 285                  * Unrecoverable HMI exception. We need to inform BMC/OCC
 286                  * about this error so that it can collect relevant data
 287                  * for error analysis before rebooting.
 288                  */
 289                 ret = opal_cec_reboot2(OPAL_REBOOT_PLATFORM_ERROR,
 290                         "Unrecoverable HMI exception");
 291                 if (ret == OPAL_UNSUPPORTED) {
 292                         pr_emerg("Reboot type %d not supported\n",
 293                                                 OPAL_REBOOT_PLATFORM_ERROR);
 294                 }
 295
 296                 /*
 297                  * Fall through and panic if opal_cec_reboot2() returns
 298                  * OPAL_UNSUPPORTED.
 299                  */
 300                 panic("Unrecoverable HMI exception");
 301         }
 302 }
 303
 304 static DECLARE_WORK(hmi_event_work, hmi_event_handler);
 305 /*
 306  * opal_handle_hmi_event - notifier handler that queues up HMI events
 307  * to be preocessed later.
 308  */
 309 static int opal_handle_hmi_event(struct notifier_block *nb,
 310                           unsigned long msg_type, void *msg)
 311 {
 312         unsigned long flags;
 313         struct OpalHMIEvent *hmi_evt;
 314         struct opal_msg *hmi_msg = msg;
 315         struct OpalHmiEvtNode *msg_node;
 316
 317         /* Sanity Checks */
 318         if (msg_type != OPAL_MSG_HMI_EVT)
 319                 return 0;
 320
 321         /* HMI event info starts from param[0] */
 322         hmi_evt = (struct OpalHMIEvent *)&hmi_msg->params[0];
 323
 324         /* Delay the logging of HMI events to workqueue. */
 325         msg_node = kzalloc(sizeof(*msg_node), GFP_ATOMIC);
 326         if (!msg_node) {
 327                 pr_err("HMI: out of memory, Opal message event not handled\n");
 328                 return -ENOMEM;
 329         }
 330         memcpy(&msg_node->hmi_evt, hmi_evt, sizeof(struct OpalHMIEvent));
 331
 332         spin_lock_irqsave(&opal_hmi_evt_lock, flags);
 333         list_add(&msg_node->list, &opal_hmi_evt_list);
 334         spin_unlock_irqrestore(&opal_hmi_evt_lock, flags);
 335
 336         schedule_work(&hmi_event_work);
 337         return 0;
 338 }
 339
 340 static struct notifier_block opal_hmi_handler_nb = {
 341         .notifier_call  = opal_handle_hmi_event,
 342         .next           = NULL,
 343         .priority       = 0,
 344 };
 345
 346 int __init opal_hmi_handler_init(void)
 347 {
 348         int ret;
 349
 350         if (!opal_hmi_handler_nb_init) {
 351                 ret = opal_message_notifier_register(
 352                                 OPAL_MSG_HMI_EVT, &opal_hmi_handler_nb);
 353                 if (ret) {
 354                         pr_err("%s: Can't register OPAL event notifier (%d)\n",
 355                                __func__, ret);
 356                         return ret;
 357                 }
 358                 opal_hmi_handler_nb_init = 1;
 359         }
 360         return 0;
 361 }