1 /* 2 * APEI Generic Hardware Error Source support 3 * 4 * Generic Hardware Error Source provides a way to report platform 5 * hardware errors (such as that from chipset). It works in so called 6 * "Firmware First" mode, that is, hardware errors are reported to 7 * firmware firstly, then reported to Linux by firmware. This way, 8 * some non-standard hardware error registers or non-standard hardware 9 * link can be checked by firmware to produce more hardware error 10 * information for Linux. 11 * 12 * For more information about Generic Hardware Error Source, please 13 * refer to ACPI Specification version 4.0, section 17.3.2.6 14 * 15 * Now, only SCI notification type and memory errors are 16 * supported. More notification type and hardware error type will be 17 * added later. 18 * 19 * Copyright 2010 Intel Corp. 20 * Author: Huang Ying <ying.huang@intel.com> 21 * 22 * This program is free software; you can redistribute it and/or 23 * modify it under the terms of the GNU General Public License version 24 * 2 as published by the Free Software Foundation; 25 * 26 * This program is distributed in the hope that it will be useful, 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 29 * GNU General Public License for more details. 30 * 31 * You should have received a copy of the GNU General Public License 32 * along with this program; if not, write to the Free Software 33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 34 */ 35 36 #include <linux/kernel.h> 37 #include <linux/module.h> 38 #include <linux/init.h> 39 #include <linux/acpi.h> 40 #include <linux/io.h> 41 #include <linux/interrupt.h> 42 #include <linux/cper.h> 43 #include <linux/kdebug.h> 44 #include <linux/platform_device.h> 45 #include <linux/mutex.h> 46 #include <acpi/apei.h> 47 #include <acpi/atomicio.h> 48 #include <acpi/hed.h> 49 #include <asm/mce.h> 50 51 #include "apei-internal.h" 52 53 #define GHES_PFX "GHES: " 54 55 #define GHES_ESTATUS_MAX_SIZE 65536 56 57 /* 58 * One struct ghes is created for each generic hardware error 59 * source. 60 * 61 * It provides the context for APEI hardware error timer/IRQ/SCI/NMI 62 * handler. Handler for one generic hardware error source is only 63 * triggered after the previous one is done. So handler can uses 64 * struct ghes without locking. 65 * 66 * estatus: memory buffer for error status block, allocated during 67 * HEST parsing. 68 */ 69 #define GHES_TO_CLEAR 0x0001 70 71 struct ghes { 72 struct acpi_hest_generic *generic; 73 struct acpi_hest_generic_status *estatus; 74 struct list_head list; 75 u64 buffer_paddr; 76 unsigned long flags; 77 }; 78 79 /* 80 * Error source lists, one list for each notification method. The 81 * members in lists are struct ghes. 82 * 83 * The list members are only added in HEST parsing and deleted during 84 * module_exit, that is, single-threaded. So no lock is needed for 85 * that. 86 * 87 * But the mutual exclusion is needed between members adding/deleting 88 * and timer/IRQ/SCI/NMI handler, which may traverse the list. RCU is 89 * used for that. 90 */ 91 static LIST_HEAD(ghes_sci); 92 static DEFINE_MUTEX(ghes_list_mutex); 93 94 static struct ghes *ghes_new(struct acpi_hest_generic *generic) 95 { 96 struct ghes *ghes; 97 unsigned int error_block_length; 98 int rc; 99 100 ghes = kzalloc(sizeof(*ghes), GFP_KERNEL); 101 if (!ghes) 102 return ERR_PTR(-ENOMEM); 103 ghes->generic = generic; 104 INIT_LIST_HEAD(&ghes->list); 105 rc = acpi_pre_map_gar(&generic->error_status_address); 106 if (rc) 107 goto err_free; 108 error_block_length = generic->error_block_length; 109 if (error_block_length > GHES_ESTATUS_MAX_SIZE) { 110 pr_warning(FW_WARN GHES_PFX 111 "Error status block length is too long: %u for " 112 "generic hardware error source: %d.\n", 113 error_block_length, generic->header.source_id); 114 error_block_length = GHES_ESTATUS_MAX_SIZE; 115 } 116 ghes->estatus = kmalloc(error_block_length, GFP_KERNEL); 117 if (!ghes->estatus) { 118 rc = -ENOMEM; 119 goto err_unmap; 120 } 121 122 return ghes; 123 124 err_unmap: 125 acpi_post_unmap_gar(&generic->error_status_address); 126 err_free: 127 kfree(ghes); 128 return ERR_PTR(rc); 129 } 130 131 static void ghes_fini(struct ghes *ghes) 132 { 133 kfree(ghes->estatus); 134 acpi_post_unmap_gar(&ghes->generic->error_status_address); 135 } 136 137 enum { 138 GHES_SEV_NO = 0x0, 139 GHES_SEV_CORRECTED = 0x1, 140 GHES_SEV_RECOVERABLE = 0x2, 141 GHES_SEV_PANIC = 0x3, 142 }; 143 144 static inline int ghes_severity(int severity) 145 { 146 switch (severity) { 147 case CPER_SEV_INFORMATIONAL: 148 return GHES_SEV_NO; 149 case CPER_SEV_CORRECTED: 150 return GHES_SEV_CORRECTED; 151 case CPER_SEV_RECOVERABLE: 152 return GHES_SEV_RECOVERABLE; 153 case CPER_SEV_FATAL: 154 return GHES_SEV_PANIC; 155 default: 156 /* Unkown, go panic */ 157 return GHES_SEV_PANIC; 158 } 159 } 160 161 /* SCI handler run in work queue, so ioremap can be used here */ 162 static int ghes_copy_tofrom_phys(void *buffer, u64 paddr, u32 len, 163 int from_phys) 164 { 165 void *vaddr; 166 167 vaddr = ioremap_cache(paddr, len); 168 if (!vaddr) 169 return -ENOMEM; 170 if (from_phys) 171 memcpy(buffer, vaddr, len); 172 else 173 memcpy(vaddr, buffer, len); 174 iounmap(vaddr); 175 176 return 0; 177 } 178 179 static int ghes_read_estatus(struct ghes *ghes, int silent) 180 { 181 struct acpi_hest_generic *g = ghes->generic; 182 u64 buf_paddr; 183 u32 len; 184 int rc; 185 186 rc = acpi_atomic_read(&buf_paddr, &g->error_status_address); 187 if (rc) { 188 if (!silent && printk_ratelimit()) 189 pr_warning(FW_WARN GHES_PFX 190 "Failed to read error status block address for hardware error source: %d.\n", 191 g->header.source_id); 192 return -EIO; 193 } 194 if (!buf_paddr) 195 return -ENOENT; 196 197 rc = ghes_copy_tofrom_phys(ghes->estatus, buf_paddr, 198 sizeof(*ghes->estatus), 1); 199 if (rc) 200 return rc; 201 if (!ghes->estatus->block_status) 202 return -ENOENT; 203 204 ghes->buffer_paddr = buf_paddr; 205 ghes->flags |= GHES_TO_CLEAR; 206 207 rc = -EIO; 208 len = apei_estatus_len(ghes->estatus); 209 if (len < sizeof(*ghes->estatus)) 210 goto err_read_block; 211 if (len > ghes->generic->error_block_length) 212 goto err_read_block; 213 if (apei_estatus_check_header(ghes->estatus)) 214 goto err_read_block; 215 rc = ghes_copy_tofrom_phys(ghes->estatus + 1, 216 buf_paddr + sizeof(*ghes->estatus), 217 len - sizeof(*ghes->estatus), 1); 218 if (rc) 219 return rc; 220 if (apei_estatus_check(ghes->estatus)) 221 goto err_read_block; 222 rc = 0; 223 224 err_read_block: 225 if (rc && !silent) 226 pr_warning(FW_WARN GHES_PFX 227 "Failed to read error status block!\n"); 228 return rc; 229 } 230 231 static void ghes_clear_estatus(struct ghes *ghes) 232 { 233 ghes->estatus->block_status = 0; 234 if (!(ghes->flags & GHES_TO_CLEAR)) 235 return; 236 ghes_copy_tofrom_phys(ghes->estatus, ghes->buffer_paddr, 237 sizeof(ghes->estatus->block_status), 0); 238 ghes->flags &= ~GHES_TO_CLEAR; 239 } 240 241 static void ghes_do_proc(struct ghes *ghes) 242 { 243 int sev, processed = 0; 244 struct acpi_hest_generic_data *gdata; 245 246 sev = ghes_severity(ghes->estatus->error_severity); 247 apei_estatus_for_each_section(ghes->estatus, gdata) { 248 #ifdef CONFIG_X86_MCE 249 if (!uuid_le_cmp(*(uuid_le *)gdata->section_type, 250 CPER_SEC_PLATFORM_MEM)) { 251 apei_mce_report_mem_error( 252 sev == GHES_SEV_CORRECTED, 253 (struct cper_sec_mem_err *)(gdata+1)); 254 processed = 1; 255 } 256 #endif 257 } 258 259 if (!processed && printk_ratelimit()) 260 pr_warning(GHES_PFX 261 "Unknown error record from generic hardware error source: %d\n", 262 ghes->generic->header.source_id); 263 } 264 265 static int ghes_proc(struct ghes *ghes) 266 { 267 int rc; 268 269 rc = ghes_read_estatus(ghes, 0); 270 if (rc) 271 goto out; 272 ghes_do_proc(ghes); 273 274 out: 275 ghes_clear_estatus(ghes); 276 return 0; 277 } 278 279 static int ghes_notify_sci(struct notifier_block *this, 280 unsigned long event, void *data) 281 { 282 struct ghes *ghes; 283 int ret = NOTIFY_DONE; 284 285 rcu_read_lock(); 286 list_for_each_entry_rcu(ghes, &ghes_sci, list) { 287 if (!ghes_proc(ghes)) 288 ret = NOTIFY_OK; 289 } 290 rcu_read_unlock(); 291 292 return ret; 293 } 294 295 static struct notifier_block ghes_notifier_sci = { 296 .notifier_call = ghes_notify_sci, 297 }; 298 299 static int __devinit ghes_probe(struct platform_device *ghes_dev) 300 { 301 struct acpi_hest_generic *generic; 302 struct ghes *ghes = NULL; 303 int rc = -EINVAL; 304 305 generic = ghes_dev->dev.platform_data; 306 if (!generic->enabled) 307 return -ENODEV; 308 309 if (generic->error_block_length < 310 sizeof(struct acpi_hest_generic_status)) { 311 pr_warning(FW_BUG GHES_PFX 312 "Invalid error block length: %u for generic hardware error source: %d\n", 313 generic->error_block_length, 314 generic->header.source_id); 315 goto err; 316 } 317 if (generic->records_to_preallocate == 0) { 318 pr_warning(FW_BUG GHES_PFX 319 "Invalid records to preallocate: %u for generic hardware error source: %d\n", 320 generic->records_to_preallocate, 321 generic->header.source_id); 322 goto err; 323 } 324 ghes = ghes_new(generic); 325 if (IS_ERR(ghes)) { 326 rc = PTR_ERR(ghes); 327 ghes = NULL; 328 goto err; 329 } 330 if (generic->notify.type == ACPI_HEST_NOTIFY_SCI) { 331 mutex_lock(&ghes_list_mutex); 332 if (list_empty(&ghes_sci)) 333 register_acpi_hed_notifier(&ghes_notifier_sci); 334 list_add_rcu(&ghes->list, &ghes_sci); 335 mutex_unlock(&ghes_list_mutex); 336 } else { 337 unsigned char *notify = NULL; 338 339 switch (generic->notify.type) { 340 case ACPI_HEST_NOTIFY_POLLED: 341 notify = "POLL"; 342 break; 343 case ACPI_HEST_NOTIFY_EXTERNAL: 344 case ACPI_HEST_NOTIFY_LOCAL: 345 notify = "IRQ"; 346 break; 347 case ACPI_HEST_NOTIFY_NMI: 348 notify = "NMI"; 349 break; 350 } 351 if (notify) { 352 pr_warning(GHES_PFX 353 "Generic hardware error source: %d notified via %s is not supported!\n", 354 generic->header.source_id, notify); 355 } else { 356 pr_warning(FW_WARN GHES_PFX 357 "Unknown notification type: %u for generic hardware error source: %d\n", 358 generic->notify.type, generic->header.source_id); 359 } 360 rc = -ENODEV; 361 goto err; 362 } 363 platform_set_drvdata(ghes_dev, ghes); 364 365 return 0; 366 err: 367 if (ghes) { 368 ghes_fini(ghes); 369 kfree(ghes); 370 } 371 return rc; 372 } 373 374 static int __devexit ghes_remove(struct platform_device *ghes_dev) 375 { 376 struct ghes *ghes; 377 struct acpi_hest_generic *generic; 378 379 ghes = platform_get_drvdata(ghes_dev); 380 generic = ghes->generic; 381 382 switch (generic->notify.type) { 383 case ACPI_HEST_NOTIFY_SCI: 384 mutex_lock(&ghes_list_mutex); 385 list_del_rcu(&ghes->list); 386 if (list_empty(&ghes_sci)) 387 unregister_acpi_hed_notifier(&ghes_notifier_sci); 388 mutex_unlock(&ghes_list_mutex); 389 break; 390 default: 391 BUG(); 392 break; 393 } 394 395 synchronize_rcu(); 396 ghes_fini(ghes); 397 kfree(ghes); 398 399 platform_set_drvdata(ghes_dev, NULL); 400 401 return 0; 402 } 403 404 static struct platform_driver ghes_platform_driver = { 405 .driver = { 406 .name = "GHES", 407 .owner = THIS_MODULE, 408 }, 409 .probe = ghes_probe, 410 .remove = ghes_remove, 411 }; 412 413 static int __init ghes_init(void) 414 { 415 if (acpi_disabled) 416 return -ENODEV; 417 418 if (hest_disable) { 419 pr_info(GHES_PFX "HEST is not enabled!\n"); 420 return -EINVAL; 421 } 422 423 return platform_driver_register(&ghes_platform_driver); 424 } 425 426 static void __exit ghes_exit(void) 427 { 428 platform_driver_unregister(&ghes_platform_driver); 429 } 430 431 module_init(ghes_init); 432 module_exit(ghes_exit); 433 434 MODULE_AUTHOR("Huang Ying"); 435 MODULE_DESCRIPTION("APEI Generic Hardware Error Source support"); 436 MODULE_LICENSE("GPL"); 437 MODULE_ALIAS("platform:GHES"); 438