1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2010 Google Inc. All Rights Reserved. 4 * Author: dlaurie@google.com (Duncan Laurie) 5 * 6 * Re-worked to expose sysfs APIs by mikew@google.com (Mike Waychison) 7 * 8 * EFI SMI interface for Google platforms 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/init.h> 13 #include <linux/types.h> 14 #include <linux/device.h> 15 #include <linux/platform_device.h> 16 #include <linux/errno.h> 17 #include <linux/string.h> 18 #include <linux/spinlock.h> 19 #include <linux/dma-mapping.h> 20 #include <linux/fs.h> 21 #include <linux/slab.h> 22 #include <linux/panic_notifier.h> 23 #include <linux/ioctl.h> 24 #include <linux/acpi.h> 25 #include <linux/io.h> 26 #include <linux/uaccess.h> 27 #include <linux/dmi.h> 28 #include <linux/kdebug.h> 29 #include <linux/reboot.h> 30 #include <linux/efi.h> 31 #include <linux/module.h> 32 #include <linux/ucs2_string.h> 33 #include <linux/suspend.h> 34 35 #define GSMI_SHUTDOWN_CLEAN 0 /* Clean Shutdown */ 36 /* TODO(mikew@google.com): Tie in HARDLOCKUP_DETECTOR with NMIWDT */ 37 #define GSMI_SHUTDOWN_NMIWDT 1 /* NMI Watchdog */ 38 #define GSMI_SHUTDOWN_PANIC 2 /* Panic */ 39 #define GSMI_SHUTDOWN_OOPS 3 /* Oops */ 40 #define GSMI_SHUTDOWN_DIE 4 /* Die -- No longer meaningful */ 41 #define GSMI_SHUTDOWN_MCE 5 /* Machine Check */ 42 #define GSMI_SHUTDOWN_SOFTWDT 6 /* Software Watchdog */ 43 #define GSMI_SHUTDOWN_MBE 7 /* Uncorrected ECC */ 44 #define GSMI_SHUTDOWN_TRIPLE 8 /* Triple Fault */ 45 46 #define DRIVER_VERSION "1.0" 47 #define GSMI_GUID_SIZE 16 48 #define GSMI_BUF_SIZE 1024 49 #define GSMI_BUF_ALIGN sizeof(u64) 50 #define GSMI_CALLBACK 0xef 51 52 /* SMI return codes */ 53 #define GSMI_SUCCESS 0x00 54 #define GSMI_UNSUPPORTED2 0x03 55 #define GSMI_LOG_FULL 0x0b 56 #define GSMI_VAR_NOT_FOUND 0x0e 57 #define GSMI_HANDSHAKE_SPIN 0x7d 58 #define GSMI_HANDSHAKE_CF 0x7e 59 #define GSMI_HANDSHAKE_NONE 0x7f 60 #define GSMI_INVALID_PARAMETER 0x82 61 #define GSMI_UNSUPPORTED 0x83 62 #define GSMI_BUFFER_TOO_SMALL 0x85 63 #define GSMI_NOT_READY 0x86 64 #define GSMI_DEVICE_ERROR 0x87 65 #define GSMI_NOT_FOUND 0x8e 66 67 #define QUIRKY_BOARD_HASH 0x78a30a50 68 69 /* Internally used commands passed to the firmware */ 70 #define GSMI_CMD_GET_NVRAM_VAR 0x01 71 #define GSMI_CMD_GET_NEXT_VAR 0x02 72 #define GSMI_CMD_SET_NVRAM_VAR 0x03 73 #define GSMI_CMD_SET_EVENT_LOG 0x08 74 #define GSMI_CMD_CLEAR_EVENT_LOG 0x09 75 #define GSMI_CMD_LOG_S0IX_SUSPEND 0x0a 76 #define GSMI_CMD_LOG_S0IX_RESUME 0x0b 77 #define GSMI_CMD_CLEAR_CONFIG 0x20 78 #define GSMI_CMD_HANDSHAKE_TYPE 0xC1 79 #define GSMI_CMD_RESERVED 0xff 80 81 /* Magic entry type for kernel events */ 82 #define GSMI_LOG_ENTRY_TYPE_KERNEL 0xDEAD 83 84 /* SMI buffers must be in 32bit physical address space */ 85 struct gsmi_buf { 86 u8 *start; /* start of buffer */ 87 size_t length; /* length of buffer */ 88 u32 address; /* physical address of buffer */ 89 }; 90 91 static struct gsmi_device { 92 struct platform_device *pdev; /* platform device */ 93 struct gsmi_buf *name_buf; /* variable name buffer */ 94 struct gsmi_buf *data_buf; /* generic data buffer */ 95 struct gsmi_buf *param_buf; /* parameter buffer */ 96 spinlock_t lock; /* serialize access to SMIs */ 97 u16 smi_cmd; /* SMI command port */ 98 int handshake_type; /* firmware handler interlock type */ 99 struct kmem_cache *mem_pool; /* kmem cache for gsmi_buf allocations */ 100 } gsmi_dev; 101 102 /* Packed structures for communicating with the firmware */ 103 struct gsmi_nvram_var_param { 104 efi_guid_t guid; 105 u32 name_ptr; 106 u32 attributes; 107 u32 data_len; 108 u32 data_ptr; 109 } __packed; 110 111 struct gsmi_get_next_var_param { 112 u8 guid[GSMI_GUID_SIZE]; 113 u32 name_ptr; 114 u32 name_len; 115 } __packed; 116 117 struct gsmi_set_eventlog_param { 118 u32 data_ptr; 119 u32 data_len; 120 u32 type; 121 } __packed; 122 123 /* Event log formats */ 124 struct gsmi_log_entry_type_1 { 125 u16 type; 126 u32 instance; 127 } __packed; 128 129 /* 130 * Some platforms don't have explicit SMI handshake 131 * and need to wait for SMI to complete. 132 */ 133 #define GSMI_DEFAULT_SPINCOUNT 0x10000 134 static unsigned int spincount = GSMI_DEFAULT_SPINCOUNT; 135 module_param(spincount, uint, 0600); 136 MODULE_PARM_DESC(spincount, 137 "The number of loop iterations to use when using the spin handshake."); 138 139 /* 140 * Some older platforms with Apollo Lake chipsets do not support S0ix logging 141 * in their GSMI handlers, and behaved poorly when resuming via power button 142 * press if the logging was attempted. Updated firmware with proper behavior 143 * has long since shipped, removing the need for this opt-in parameter. It 144 * now exists as an opt-out parameter for folks defiantly running old 145 * firmware, or unforeseen circumstances. After the change from opt-in to 146 * opt-out has baked sufficiently, this parameter should probably be removed 147 * entirely. 148 */ 149 static bool s0ix_logging_enable = true; 150 module_param(s0ix_logging_enable, bool, 0600); 151 152 static struct gsmi_buf *gsmi_buf_alloc(void) 153 { 154 struct gsmi_buf *smibuf; 155 156 smibuf = kzalloc(sizeof(*smibuf), GFP_KERNEL); 157 if (!smibuf) { 158 printk(KERN_ERR "gsmi: out of memory\n"); 159 return NULL; 160 } 161 162 /* allocate buffer in 32bit address space */ 163 smibuf->start = kmem_cache_alloc(gsmi_dev.mem_pool, GFP_KERNEL); 164 if (!smibuf->start) { 165 printk(KERN_ERR "gsmi: failed to allocate name buffer\n"); 166 kfree(smibuf); 167 return NULL; 168 } 169 170 /* fill in the buffer handle */ 171 smibuf->length = GSMI_BUF_SIZE; 172 smibuf->address = (u32)virt_to_phys(smibuf->start); 173 174 return smibuf; 175 } 176 177 static void gsmi_buf_free(struct gsmi_buf *smibuf) 178 { 179 if (smibuf) { 180 if (smibuf->start) 181 kmem_cache_free(gsmi_dev.mem_pool, smibuf->start); 182 kfree(smibuf); 183 } 184 } 185 186 /* 187 * Make a call to gsmi func(sub). GSMI error codes are translated to 188 * in-kernel errnos (0 on success, -ERRNO on error). 189 */ 190 static int gsmi_exec(u8 func, u8 sub) 191 { 192 u16 cmd = (sub << 8) | func; 193 u16 result = 0; 194 int rc = 0; 195 196 /* 197 * AH : Subfunction number 198 * AL : Function number 199 * EBX : Parameter block address 200 * DX : SMI command port 201 * 202 * Three protocols here. See also the comment in gsmi_init(). 203 */ 204 if (gsmi_dev.handshake_type == GSMI_HANDSHAKE_CF) { 205 /* 206 * If handshake_type == HANDSHAKE_CF then set CF on the 207 * way in and wait for the handler to clear it; this avoids 208 * corrupting register state on those chipsets which have 209 * a delay between writing the SMI trigger register and 210 * entering SMM. 211 */ 212 asm volatile ( 213 "stc\n" 214 "outb %%al, %%dx\n" 215 "1: jc 1b\n" 216 : "=a" (result) 217 : "0" (cmd), 218 "d" (gsmi_dev.smi_cmd), 219 "b" (gsmi_dev.param_buf->address) 220 : "memory", "cc" 221 ); 222 } else if (gsmi_dev.handshake_type == GSMI_HANDSHAKE_SPIN) { 223 /* 224 * If handshake_type == HANDSHAKE_SPIN we spin a 225 * hundred-ish usecs to ensure the SMI has triggered. 226 */ 227 asm volatile ( 228 "outb %%al, %%dx\n" 229 "1: loop 1b\n" 230 : "=a" (result) 231 : "0" (cmd), 232 "d" (gsmi_dev.smi_cmd), 233 "b" (gsmi_dev.param_buf->address), 234 "c" (spincount) 235 : "memory", "cc" 236 ); 237 } else { 238 /* 239 * If handshake_type == HANDSHAKE_NONE we do nothing; 240 * either we don't need to or it's legacy firmware that 241 * doesn't understand the CF protocol. 242 */ 243 asm volatile ( 244 "outb %%al, %%dx\n\t" 245 : "=a" (result) 246 : "0" (cmd), 247 "d" (gsmi_dev.smi_cmd), 248 "b" (gsmi_dev.param_buf->address) 249 : "memory", "cc" 250 ); 251 } 252 253 /* check return code from SMI handler */ 254 switch (result) { 255 case GSMI_SUCCESS: 256 break; 257 case GSMI_VAR_NOT_FOUND: 258 /* not really an error, but let the caller know */ 259 rc = 1; 260 break; 261 case GSMI_INVALID_PARAMETER: 262 printk(KERN_ERR "gsmi: exec 0x%04x: Invalid parameter\n", cmd); 263 rc = -EINVAL; 264 break; 265 case GSMI_BUFFER_TOO_SMALL: 266 printk(KERN_ERR "gsmi: exec 0x%04x: Buffer too small\n", cmd); 267 rc = -ENOMEM; 268 break; 269 case GSMI_UNSUPPORTED: 270 case GSMI_UNSUPPORTED2: 271 if (sub != GSMI_CMD_HANDSHAKE_TYPE) 272 printk(KERN_ERR "gsmi: exec 0x%04x: Not supported\n", 273 cmd); 274 rc = -ENOSYS; 275 break; 276 case GSMI_NOT_READY: 277 printk(KERN_ERR "gsmi: exec 0x%04x: Not ready\n", cmd); 278 rc = -EBUSY; 279 break; 280 case GSMI_DEVICE_ERROR: 281 printk(KERN_ERR "gsmi: exec 0x%04x: Device error\n", cmd); 282 rc = -EFAULT; 283 break; 284 case GSMI_NOT_FOUND: 285 printk(KERN_ERR "gsmi: exec 0x%04x: Data not found\n", cmd); 286 rc = -ENOENT; 287 break; 288 case GSMI_LOG_FULL: 289 printk(KERN_ERR "gsmi: exec 0x%04x: Log full\n", cmd); 290 rc = -ENOSPC; 291 break; 292 case GSMI_HANDSHAKE_CF: 293 case GSMI_HANDSHAKE_SPIN: 294 case GSMI_HANDSHAKE_NONE: 295 rc = result; 296 break; 297 default: 298 printk(KERN_ERR "gsmi: exec 0x%04x: Unknown error 0x%04x\n", 299 cmd, result); 300 rc = -ENXIO; 301 } 302 303 return rc; 304 } 305 306 #ifdef CONFIG_EFI 307 308 static struct efivars efivars; 309 310 static efi_status_t gsmi_get_variable(efi_char16_t *name, 311 efi_guid_t *vendor, u32 *attr, 312 unsigned long *data_size, 313 void *data) 314 { 315 struct gsmi_nvram_var_param param = { 316 .name_ptr = gsmi_dev.name_buf->address, 317 .data_ptr = gsmi_dev.data_buf->address, 318 .data_len = (u32)*data_size, 319 }; 320 efi_status_t ret = EFI_SUCCESS; 321 unsigned long flags; 322 size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2); 323 int rc; 324 325 if (name_len >= GSMI_BUF_SIZE / 2) 326 return EFI_BAD_BUFFER_SIZE; 327 328 spin_lock_irqsave(&gsmi_dev.lock, flags); 329 330 /* Vendor guid */ 331 memcpy(¶m.guid, vendor, sizeof(param.guid)); 332 333 /* variable name, already in UTF-16 */ 334 memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length); 335 memcpy(gsmi_dev.name_buf->start, name, name_len * 2); 336 337 /* data pointer */ 338 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length); 339 340 /* parameter buffer */ 341 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 342 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param)); 343 344 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NVRAM_VAR); 345 if (rc < 0) { 346 printk(KERN_ERR "gsmi: Get Variable failed\n"); 347 ret = EFI_LOAD_ERROR; 348 } else if (rc == 1) { 349 /* variable was not found */ 350 ret = EFI_NOT_FOUND; 351 } else { 352 /* Get the arguments back */ 353 memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param)); 354 355 /* The size reported is the min of all of our buffers */ 356 *data_size = min_t(unsigned long, *data_size, 357 gsmi_dev.data_buf->length); 358 *data_size = min_t(unsigned long, *data_size, param.data_len); 359 360 /* Copy data back to return buffer. */ 361 memcpy(data, gsmi_dev.data_buf->start, *data_size); 362 363 /* All variables are have the following attributes */ 364 *attr = EFI_VARIABLE_NON_VOLATILE | 365 EFI_VARIABLE_BOOTSERVICE_ACCESS | 366 EFI_VARIABLE_RUNTIME_ACCESS; 367 } 368 369 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 370 371 return ret; 372 } 373 374 static efi_status_t gsmi_get_next_variable(unsigned long *name_size, 375 efi_char16_t *name, 376 efi_guid_t *vendor) 377 { 378 struct gsmi_get_next_var_param param = { 379 .name_ptr = gsmi_dev.name_buf->address, 380 .name_len = gsmi_dev.name_buf->length, 381 }; 382 efi_status_t ret = EFI_SUCCESS; 383 int rc; 384 unsigned long flags; 385 386 /* For the moment, only support buffers that exactly match in size */ 387 if (*name_size != GSMI_BUF_SIZE) 388 return EFI_BAD_BUFFER_SIZE; 389 390 /* Let's make sure the thing is at least null-terminated */ 391 if (ucs2_strnlen(name, GSMI_BUF_SIZE / 2) == GSMI_BUF_SIZE / 2) 392 return EFI_INVALID_PARAMETER; 393 394 spin_lock_irqsave(&gsmi_dev.lock, flags); 395 396 /* guid */ 397 memcpy(¶m.guid, vendor, sizeof(param.guid)); 398 399 /* variable name, already in UTF-16 */ 400 memcpy(gsmi_dev.name_buf->start, name, *name_size); 401 402 /* parameter buffer */ 403 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 404 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param)); 405 406 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NEXT_VAR); 407 if (rc < 0) { 408 printk(KERN_ERR "gsmi: Get Next Variable Name failed\n"); 409 ret = EFI_LOAD_ERROR; 410 } else if (rc == 1) { 411 /* variable not found -- end of list */ 412 ret = EFI_NOT_FOUND; 413 } else { 414 /* copy variable data back to return buffer */ 415 memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param)); 416 417 /* Copy the name back */ 418 memcpy(name, gsmi_dev.name_buf->start, GSMI_BUF_SIZE); 419 *name_size = ucs2_strnlen(name, GSMI_BUF_SIZE / 2) * 2; 420 421 /* copy guid to return buffer */ 422 memcpy(vendor, ¶m.guid, sizeof(param.guid)); 423 ret = EFI_SUCCESS; 424 } 425 426 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 427 428 return ret; 429 } 430 431 static efi_status_t gsmi_set_variable(efi_char16_t *name, 432 efi_guid_t *vendor, 433 u32 attr, 434 unsigned long data_size, 435 void *data) 436 { 437 struct gsmi_nvram_var_param param = { 438 .name_ptr = gsmi_dev.name_buf->address, 439 .data_ptr = gsmi_dev.data_buf->address, 440 .data_len = (u32)data_size, 441 .attributes = EFI_VARIABLE_NON_VOLATILE | 442 EFI_VARIABLE_BOOTSERVICE_ACCESS | 443 EFI_VARIABLE_RUNTIME_ACCESS, 444 }; 445 size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2); 446 efi_status_t ret = EFI_SUCCESS; 447 int rc; 448 unsigned long flags; 449 450 if (name_len >= GSMI_BUF_SIZE / 2) 451 return EFI_BAD_BUFFER_SIZE; 452 453 spin_lock_irqsave(&gsmi_dev.lock, flags); 454 455 /* guid */ 456 memcpy(¶m.guid, vendor, sizeof(param.guid)); 457 458 /* variable name, already in UTF-16 */ 459 memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length); 460 memcpy(gsmi_dev.name_buf->start, name, name_len * 2); 461 462 /* data pointer */ 463 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length); 464 memcpy(gsmi_dev.data_buf->start, data, data_size); 465 466 /* parameter buffer */ 467 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 468 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param)); 469 470 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_NVRAM_VAR); 471 if (rc < 0) { 472 printk(KERN_ERR "gsmi: Set Variable failed\n"); 473 ret = EFI_INVALID_PARAMETER; 474 } 475 476 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 477 478 return ret; 479 } 480 481 static const struct efivar_operations efivar_ops = { 482 .get_variable = gsmi_get_variable, 483 .set_variable = gsmi_set_variable, 484 .get_next_variable = gsmi_get_next_variable, 485 }; 486 487 #endif /* CONFIG_EFI */ 488 489 static ssize_t eventlog_write(struct file *filp, struct kobject *kobj, 490 struct bin_attribute *bin_attr, 491 char *buf, loff_t pos, size_t count) 492 { 493 struct gsmi_set_eventlog_param param = { 494 .data_ptr = gsmi_dev.data_buf->address, 495 }; 496 int rc = 0; 497 unsigned long flags; 498 499 /* Pull the type out */ 500 if (count < sizeof(u32)) 501 return -EINVAL; 502 param.type = *(u32 *)buf; 503 buf += sizeof(u32); 504 505 /* The remaining buffer is the data payload */ 506 if ((count - sizeof(u32)) > gsmi_dev.data_buf->length) 507 return -EINVAL; 508 param.data_len = count - sizeof(u32); 509 510 spin_lock_irqsave(&gsmi_dev.lock, flags); 511 512 /* data pointer */ 513 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length); 514 memcpy(gsmi_dev.data_buf->start, buf, param.data_len); 515 516 /* parameter buffer */ 517 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 518 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param)); 519 520 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG); 521 if (rc < 0) 522 printk(KERN_ERR "gsmi: Set Event Log failed\n"); 523 524 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 525 526 return (rc == 0) ? count : rc; 527 528 } 529 530 static struct bin_attribute eventlog_bin_attr = { 531 .attr = {.name = "append_to_eventlog", .mode = 0200}, 532 .write = eventlog_write, 533 }; 534 535 static ssize_t gsmi_clear_eventlog_store(struct kobject *kobj, 536 struct kobj_attribute *attr, 537 const char *buf, size_t count) 538 { 539 int rc; 540 unsigned long flags; 541 unsigned long val; 542 struct { 543 u32 percentage; 544 u32 data_type; 545 } param; 546 547 rc = kstrtoul(buf, 0, &val); 548 if (rc) 549 return rc; 550 551 /* 552 * Value entered is a percentage, 0 through 100, anything else 553 * is invalid. 554 */ 555 if (val > 100) 556 return -EINVAL; 557 558 /* data_type here selects the smbios event log. */ 559 param.percentage = val; 560 param.data_type = 0; 561 562 spin_lock_irqsave(&gsmi_dev.lock, flags); 563 564 /* parameter buffer */ 565 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 566 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param)); 567 568 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_EVENT_LOG); 569 570 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 571 572 if (rc) 573 return rc; 574 return count; 575 } 576 577 static struct kobj_attribute gsmi_clear_eventlog_attr = { 578 .attr = {.name = "clear_eventlog", .mode = 0200}, 579 .store = gsmi_clear_eventlog_store, 580 }; 581 582 static ssize_t gsmi_clear_config_store(struct kobject *kobj, 583 struct kobj_attribute *attr, 584 const char *buf, size_t count) 585 { 586 int rc; 587 unsigned long flags; 588 589 spin_lock_irqsave(&gsmi_dev.lock, flags); 590 591 /* clear parameter buffer */ 592 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 593 594 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_CONFIG); 595 596 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 597 598 if (rc) 599 return rc; 600 return count; 601 } 602 603 static struct kobj_attribute gsmi_clear_config_attr = { 604 .attr = {.name = "clear_config", .mode = 0200}, 605 .store = gsmi_clear_config_store, 606 }; 607 608 static const struct attribute *gsmi_attrs[] = { 609 &gsmi_clear_config_attr.attr, 610 &gsmi_clear_eventlog_attr.attr, 611 NULL, 612 }; 613 614 static int gsmi_shutdown_reason(int reason) 615 { 616 struct gsmi_log_entry_type_1 entry = { 617 .type = GSMI_LOG_ENTRY_TYPE_KERNEL, 618 .instance = reason, 619 }; 620 struct gsmi_set_eventlog_param param = { 621 .data_len = sizeof(entry), 622 .type = 1, 623 }; 624 static int saved_reason; 625 int rc = 0; 626 unsigned long flags; 627 628 /* avoid duplicate entries in the log */ 629 if (saved_reason & (1 << reason)) 630 return 0; 631 632 spin_lock_irqsave(&gsmi_dev.lock, flags); 633 634 saved_reason |= (1 << reason); 635 636 /* data pointer */ 637 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length); 638 memcpy(gsmi_dev.data_buf->start, &entry, sizeof(entry)); 639 640 /* parameter buffer */ 641 param.data_ptr = gsmi_dev.data_buf->address; 642 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 643 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param)); 644 645 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG); 646 647 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 648 649 if (rc < 0) 650 printk(KERN_ERR "gsmi: Log Shutdown Reason failed\n"); 651 else 652 printk(KERN_EMERG "gsmi: Log Shutdown Reason 0x%02x\n", 653 reason); 654 655 return rc; 656 } 657 658 static int gsmi_reboot_callback(struct notifier_block *nb, 659 unsigned long reason, void *arg) 660 { 661 gsmi_shutdown_reason(GSMI_SHUTDOWN_CLEAN); 662 return NOTIFY_DONE; 663 } 664 665 static struct notifier_block gsmi_reboot_notifier = { 666 .notifier_call = gsmi_reboot_callback 667 }; 668 669 static int gsmi_die_callback(struct notifier_block *nb, 670 unsigned long reason, void *arg) 671 { 672 if (reason == DIE_OOPS) 673 gsmi_shutdown_reason(GSMI_SHUTDOWN_OOPS); 674 return NOTIFY_DONE; 675 } 676 677 static struct notifier_block gsmi_die_notifier = { 678 .notifier_call = gsmi_die_callback 679 }; 680 681 static int gsmi_panic_callback(struct notifier_block *nb, 682 unsigned long reason, void *arg) 683 { 684 gsmi_shutdown_reason(GSMI_SHUTDOWN_PANIC); 685 return NOTIFY_DONE; 686 } 687 688 static struct notifier_block gsmi_panic_notifier = { 689 .notifier_call = gsmi_panic_callback, 690 }; 691 692 /* 693 * This hash function was blatantly copied from include/linux/hash.h. 694 * It is used by this driver to obfuscate a board name that requires a 695 * quirk within this driver. 696 * 697 * Please do not remove this copy of the function as any changes to the 698 * global utility hash_64() function would break this driver's ability 699 * to identify a board and provide the appropriate quirk -- mikew@google.com 700 */ 701 static u64 __init local_hash_64(u64 val, unsigned bits) 702 { 703 u64 hash = val; 704 705 /* Sigh, gcc can't optimise this alone like it does for 32 bits. */ 706 u64 n = hash; 707 n <<= 18; 708 hash -= n; 709 n <<= 33; 710 hash -= n; 711 n <<= 3; 712 hash += n; 713 n <<= 3; 714 hash -= n; 715 n <<= 4; 716 hash += n; 717 n <<= 2; 718 hash += n; 719 720 /* High bits are more random, so use them. */ 721 return hash >> (64 - bits); 722 } 723 724 static u32 __init hash_oem_table_id(char s[8]) 725 { 726 u64 input; 727 memcpy(&input, s, 8); 728 return local_hash_64(input, 32); 729 } 730 731 static const struct dmi_system_id gsmi_dmi_table[] __initconst = { 732 { 733 .ident = "Google Board", 734 .matches = { 735 DMI_MATCH(DMI_BOARD_VENDOR, "Google, Inc."), 736 }, 737 }, 738 { 739 .ident = "Coreboot Firmware", 740 .matches = { 741 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 742 }, 743 }, 744 {} 745 }; 746 MODULE_DEVICE_TABLE(dmi, gsmi_dmi_table); 747 748 static __init int gsmi_system_valid(void) 749 { 750 u32 hash; 751 u16 cmd, result; 752 753 if (!dmi_check_system(gsmi_dmi_table)) 754 return -ENODEV; 755 756 /* 757 * Only newer firmware supports the gsmi interface. All older 758 * firmware that didn't support this interface used to plug the 759 * table name in the first four bytes of the oem_table_id field. 760 * Newer firmware doesn't do that though, so use that as the 761 * discriminant factor. We have to do this in order to 762 * whitewash our board names out of the public driver. 763 */ 764 if (!strncmp(acpi_gbl_FADT.header.oem_table_id, "FACP", 4)) { 765 printk(KERN_INFO "gsmi: Board is too old\n"); 766 return -ENODEV; 767 } 768 769 /* Disable on board with 1.0 BIOS due to Google bug 2602657 */ 770 hash = hash_oem_table_id(acpi_gbl_FADT.header.oem_table_id); 771 if (hash == QUIRKY_BOARD_HASH) { 772 const char *bios_ver = dmi_get_system_info(DMI_BIOS_VERSION); 773 if (strncmp(bios_ver, "1.0", 3) == 0) { 774 pr_info("gsmi: disabled on this board's BIOS %s\n", 775 bios_ver); 776 return -ENODEV; 777 } 778 } 779 780 /* check for valid SMI command port in ACPI FADT */ 781 if (acpi_gbl_FADT.smi_command == 0) { 782 pr_info("gsmi: missing smi_command\n"); 783 return -ENODEV; 784 } 785 786 /* Test the smihandler with a bogus command. If it leaves the 787 * calling argument in %ax untouched, there is no handler for 788 * GSMI commands. 789 */ 790 cmd = GSMI_CALLBACK | GSMI_CMD_RESERVED << 8; 791 asm volatile ( 792 "outb %%al, %%dx\n\t" 793 : "=a" (result) 794 : "0" (cmd), 795 "d" (acpi_gbl_FADT.smi_command) 796 : "memory", "cc" 797 ); 798 if (cmd == result) { 799 pr_info("gsmi: no gsmi handler in firmware\n"); 800 return -ENODEV; 801 } 802 803 /* Found */ 804 return 0; 805 } 806 807 static struct kobject *gsmi_kobj; 808 809 static const struct platform_device_info gsmi_dev_info = { 810 .name = "gsmi", 811 .id = -1, 812 /* SMI callbacks require 32bit addresses */ 813 .dma_mask = DMA_BIT_MASK(32), 814 }; 815 816 #ifdef CONFIG_PM 817 static void gsmi_log_s0ix_info(u8 cmd) 818 { 819 unsigned long flags; 820 821 /* 822 * If platform has not enabled S0ix logging, then no action is 823 * necessary. 824 */ 825 if (!s0ix_logging_enable) 826 return; 827 828 spin_lock_irqsave(&gsmi_dev.lock, flags); 829 830 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length); 831 832 gsmi_exec(GSMI_CALLBACK, cmd); 833 834 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 835 } 836 837 static int gsmi_log_s0ix_suspend(struct device *dev) 838 { 839 /* 840 * If system is not suspending via firmware using the standard ACPI Sx 841 * types, then make a GSMI call to log the suspend info. 842 */ 843 if (!pm_suspend_via_firmware()) 844 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_SUSPEND); 845 846 /* 847 * Always return success, since we do not want suspend 848 * to fail just because of logging failure. 849 */ 850 return 0; 851 } 852 853 static int gsmi_log_s0ix_resume(struct device *dev) 854 { 855 /* 856 * If system did not resume via firmware, then make a GSMI call to log 857 * the resume info and wake source. 858 */ 859 if (!pm_resume_via_firmware()) 860 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_RESUME); 861 862 /* 863 * Always return success, since we do not want resume 864 * to fail just because of logging failure. 865 */ 866 return 0; 867 } 868 869 static const struct dev_pm_ops gsmi_pm_ops = { 870 .suspend_noirq = gsmi_log_s0ix_suspend, 871 .resume_noirq = gsmi_log_s0ix_resume, 872 }; 873 874 static int gsmi_platform_driver_probe(struct platform_device *dev) 875 { 876 return 0; 877 } 878 879 static struct platform_driver gsmi_driver_info = { 880 .driver = { 881 .name = "gsmi", 882 .pm = &gsmi_pm_ops, 883 }, 884 .probe = gsmi_platform_driver_probe, 885 }; 886 #endif 887 888 static __init int gsmi_init(void) 889 { 890 unsigned long flags; 891 int ret; 892 893 ret = gsmi_system_valid(); 894 if (ret) 895 return ret; 896 897 gsmi_dev.smi_cmd = acpi_gbl_FADT.smi_command; 898 899 #ifdef CONFIG_PM 900 ret = platform_driver_register(&gsmi_driver_info); 901 if (unlikely(ret)) { 902 printk(KERN_ERR "gsmi: unable to register platform driver\n"); 903 return ret; 904 } 905 #endif 906 907 /* register device */ 908 gsmi_dev.pdev = platform_device_register_full(&gsmi_dev_info); 909 if (IS_ERR(gsmi_dev.pdev)) { 910 printk(KERN_ERR "gsmi: unable to register platform device\n"); 911 return PTR_ERR(gsmi_dev.pdev); 912 } 913 914 /* SMI access needs to be serialized */ 915 spin_lock_init(&gsmi_dev.lock); 916 917 ret = -ENOMEM; 918 919 /* 920 * SLAB cache is created using SLAB_CACHE_DMA32 to ensure that the 921 * allocations for gsmi_buf come from the DMA32 memory zone. These 922 * buffers have nothing to do with DMA. They are required for 923 * communication with firmware executing in SMI mode which can only 924 * access the bottom 4GiB of physical memory. Since DMA32 memory zone 925 * guarantees allocation under the 4GiB boundary, this driver creates 926 * a SLAB cache with SLAB_CACHE_DMA32 flag. 927 */ 928 gsmi_dev.mem_pool = kmem_cache_create("gsmi", GSMI_BUF_SIZE, 929 GSMI_BUF_ALIGN, 930 SLAB_CACHE_DMA32, NULL); 931 if (!gsmi_dev.mem_pool) 932 goto out_err; 933 934 /* 935 * pre-allocate buffers because sometimes we are called when 936 * this is not feasible: oops, panic, die, mce, etc 937 */ 938 gsmi_dev.name_buf = gsmi_buf_alloc(); 939 if (!gsmi_dev.name_buf) { 940 printk(KERN_ERR "gsmi: failed to allocate name buffer\n"); 941 goto out_err; 942 } 943 944 gsmi_dev.data_buf = gsmi_buf_alloc(); 945 if (!gsmi_dev.data_buf) { 946 printk(KERN_ERR "gsmi: failed to allocate data buffer\n"); 947 goto out_err; 948 } 949 950 gsmi_dev.param_buf = gsmi_buf_alloc(); 951 if (!gsmi_dev.param_buf) { 952 printk(KERN_ERR "gsmi: failed to allocate param buffer\n"); 953 goto out_err; 954 } 955 956 /* 957 * Determine type of handshake used to serialize the SMI 958 * entry. See also gsmi_exec(). 959 * 960 * There's a "behavior" present on some chipsets where writing the 961 * SMI trigger register in the southbridge doesn't result in an 962 * immediate SMI. Rather, the processor can execute "a few" more 963 * instructions before the SMI takes effect. To ensure synchronous 964 * behavior, implement a handshake between the kernel driver and the 965 * firmware handler to spin until released. This ioctl determines 966 * the type of handshake. 967 * 968 * NONE: The firmware handler does not implement any 969 * handshake. Either it doesn't need to, or it's legacy firmware 970 * that doesn't know it needs to and never will. 971 * 972 * CF: The firmware handler will clear the CF in the saved 973 * state before returning. The driver may set the CF and test for 974 * it to clear before proceeding. 975 * 976 * SPIN: The firmware handler does not implement any handshake 977 * but the driver should spin for a hundred or so microseconds 978 * to ensure the SMI has triggered. 979 * 980 * Finally, the handler will return -ENOSYS if 981 * GSMI_CMD_HANDSHAKE_TYPE is unimplemented, which implies 982 * HANDSHAKE_NONE. 983 */ 984 spin_lock_irqsave(&gsmi_dev.lock, flags); 985 gsmi_dev.handshake_type = GSMI_HANDSHAKE_SPIN; 986 gsmi_dev.handshake_type = 987 gsmi_exec(GSMI_CALLBACK, GSMI_CMD_HANDSHAKE_TYPE); 988 if (gsmi_dev.handshake_type == -ENOSYS) 989 gsmi_dev.handshake_type = GSMI_HANDSHAKE_NONE; 990 spin_unlock_irqrestore(&gsmi_dev.lock, flags); 991 992 /* Remove and clean up gsmi if the handshake could not complete. */ 993 if (gsmi_dev.handshake_type == -ENXIO) { 994 printk(KERN_INFO "gsmi version " DRIVER_VERSION 995 " failed to load\n"); 996 ret = -ENODEV; 997 goto out_err; 998 } 999 1000 /* Register in the firmware directory */ 1001 ret = -ENOMEM; 1002 gsmi_kobj = kobject_create_and_add("gsmi", firmware_kobj); 1003 if (!gsmi_kobj) { 1004 printk(KERN_INFO "gsmi: Failed to create firmware kobj\n"); 1005 goto out_err; 1006 } 1007 1008 /* Setup eventlog access */ 1009 ret = sysfs_create_bin_file(gsmi_kobj, &eventlog_bin_attr); 1010 if (ret) { 1011 printk(KERN_INFO "gsmi: Failed to setup eventlog"); 1012 goto out_err; 1013 } 1014 1015 /* Other attributes */ 1016 ret = sysfs_create_files(gsmi_kobj, gsmi_attrs); 1017 if (ret) { 1018 printk(KERN_INFO "gsmi: Failed to add attrs"); 1019 goto out_remove_bin_file; 1020 } 1021 1022 #ifdef CONFIG_EFI 1023 ret = efivars_register(&efivars, &efivar_ops, gsmi_kobj); 1024 if (ret) { 1025 printk(KERN_INFO "gsmi: Failed to register efivars\n"); 1026 sysfs_remove_files(gsmi_kobj, gsmi_attrs); 1027 goto out_remove_bin_file; 1028 } 1029 #endif 1030 1031 register_reboot_notifier(&gsmi_reboot_notifier); 1032 register_die_notifier(&gsmi_die_notifier); 1033 atomic_notifier_chain_register(&panic_notifier_list, 1034 &gsmi_panic_notifier); 1035 1036 printk(KERN_INFO "gsmi version " DRIVER_VERSION " loaded\n"); 1037 1038 return 0; 1039 1040 out_remove_bin_file: 1041 sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr); 1042 out_err: 1043 kobject_put(gsmi_kobj); 1044 gsmi_buf_free(gsmi_dev.param_buf); 1045 gsmi_buf_free(gsmi_dev.data_buf); 1046 gsmi_buf_free(gsmi_dev.name_buf); 1047 kmem_cache_destroy(gsmi_dev.mem_pool); 1048 platform_device_unregister(gsmi_dev.pdev); 1049 pr_info("gsmi: failed to load: %d\n", ret); 1050 #ifdef CONFIG_PM 1051 platform_driver_unregister(&gsmi_driver_info); 1052 #endif 1053 return ret; 1054 } 1055 1056 static void __exit gsmi_exit(void) 1057 { 1058 unregister_reboot_notifier(&gsmi_reboot_notifier); 1059 unregister_die_notifier(&gsmi_die_notifier); 1060 atomic_notifier_chain_unregister(&panic_notifier_list, 1061 &gsmi_panic_notifier); 1062 #ifdef CONFIG_EFI 1063 efivars_unregister(&efivars); 1064 #endif 1065 1066 sysfs_remove_files(gsmi_kobj, gsmi_attrs); 1067 sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr); 1068 kobject_put(gsmi_kobj); 1069 gsmi_buf_free(gsmi_dev.param_buf); 1070 gsmi_buf_free(gsmi_dev.data_buf); 1071 gsmi_buf_free(gsmi_dev.name_buf); 1072 kmem_cache_destroy(gsmi_dev.mem_pool); 1073 platform_device_unregister(gsmi_dev.pdev); 1074 #ifdef CONFIG_PM 1075 platform_driver_unregister(&gsmi_driver_info); 1076 #endif 1077 } 1078 1079 module_init(gsmi_init); 1080 module_exit(gsmi_exit); 1081 1082 MODULE_AUTHOR("Google, Inc."); 1083 MODULE_LICENSE("GPL"); 1084