1095 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*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 platforms9 */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 1648#define GSMI_BUF_SIZE 102449#define GSMI_BUF_ALIGN sizeof(u64)50#define GSMI_CALLBACK 0xef51 52/* SMI return codes */53#define GSMI_SUCCESS 0x0054#define GSMI_UNSUPPORTED2 0x0355#define GSMI_LOG_FULL 0x0b56#define GSMI_VAR_NOT_FOUND 0x0e57#define GSMI_HANDSHAKE_SPIN 0x7d58#define GSMI_HANDSHAKE_CF 0x7e59#define GSMI_HANDSHAKE_NONE 0x7f60#define GSMI_INVALID_PARAMETER 0x8261#define GSMI_UNSUPPORTED 0x8362#define GSMI_BUFFER_TOO_SMALL 0x8563#define GSMI_NOT_READY 0x8664#define GSMI_DEVICE_ERROR 0x8765#define GSMI_NOT_FOUND 0x8e66 67#define QUIRKY_BOARD_HASH 0x78a30a5068 69/* Internally used commands passed to the firmware */70#define GSMI_CMD_GET_NVRAM_VAR 0x0171#define GSMI_CMD_GET_NEXT_VAR 0x0272#define GSMI_CMD_SET_NVRAM_VAR 0x0373#define GSMI_CMD_SET_EVENT_LOG 0x0874#define GSMI_CMD_CLEAR_EVENT_LOG 0x0975#define GSMI_CMD_LOG_S0IX_SUSPEND 0x0a76#define GSMI_CMD_LOG_S0IX_RESUME 0x0b77#define GSMI_CMD_CLEAR_CONFIG 0x2078#define GSMI_CMD_HANDSHAKE_TYPE 0xC179#define GSMI_CMD_RESERVED 0xff80 81/* Magic entry type for kernel events */82#define GSMI_LOG_ENTRY_TYPE_KERNEL 0xDEAD83 84/* SMI buffers must be in 32bit physical address space */85struct gsmi_buf {86 u8 *start; /* start of buffer */87 size_t length; /* length of buffer */88 u32 address; /* physical address of buffer */89};90 91static 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 */103struct 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 111struct gsmi_get_next_var_param {112 u8 guid[GSMI_GUID_SIZE];113 u32 name_ptr;114 u32 name_len;115} __packed;116 117struct gsmi_set_eventlog_param {118 u32 data_ptr;119 u32 data_len;120 u32 type;121} __packed;122 123/* Event log formats */124struct gsmi_log_entry_type_1 {125 u16 type;126 u32 instance;127} __packed;128 129/*130 * Some platforms don't have explicit SMI handshake131 * and need to wait for SMI to complete.132 */133#define GSMI_DEFAULT_SPINCOUNT 0x10000134static unsigned int spincount = GSMI_DEFAULT_SPINCOUNT;135module_param(spincount, uint, 0600);136MODULE_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 logging141 * in their GSMI handlers, and behaved poorly when resuming via power button142 * press if the logging was attempted. Updated firmware with proper behavior143 * has long since shipped, removing the need for this opt-in parameter. It144 * now exists as an opt-out parameter for folks defiantly running old145 * firmware, or unforeseen circumstances. After the change from opt-in to146 * opt-out has baked sufficiently, this parameter should probably be removed147 * entirely.148 */149static bool s0ix_logging_enable = true;150module_param(s0ix_logging_enable, bool, 0600);151 152static 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 177static 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 to188 * in-kernel errnos (0 on success, -ERRNO on error).189 */190static 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 number198 * AL : Function number199 * EBX : Parameter block address200 * DX : SMI command port201 *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 the207 * way in and wait for the handler to clear it; this avoids208 * corrupting register state on those chipsets which have209 * a delay between writing the SMI trigger register and210 * 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 a225 * 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 that241 * 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_EFI307 308static struct efivars efivars;309 310static 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 if (attr)365 *attr = EFI_VARIABLE_NON_VOLATILE |366 EFI_VARIABLE_BOOTSERVICE_ACCESS |367 EFI_VARIABLE_RUNTIME_ACCESS;368 }369 370 spin_unlock_irqrestore(&gsmi_dev.lock, flags);371 372 return ret;373}374 375static efi_status_t gsmi_get_next_variable(unsigned long *name_size,376 efi_char16_t *name,377 efi_guid_t *vendor)378{379 struct gsmi_get_next_var_param param = {380 .name_ptr = gsmi_dev.name_buf->address,381 .name_len = gsmi_dev.name_buf->length,382 };383 efi_status_t ret = EFI_SUCCESS;384 int rc;385 unsigned long flags;386 387 /* For the moment, only support buffers that exactly match in size */388 if (*name_size != GSMI_BUF_SIZE)389 return EFI_BAD_BUFFER_SIZE;390 391 /* Let's make sure the thing is at least null-terminated */392 if (ucs2_strnlen(name, GSMI_BUF_SIZE / 2) == GSMI_BUF_SIZE / 2)393 return EFI_INVALID_PARAMETER;394 395 spin_lock_irqsave(&gsmi_dev.lock, flags);396 397 /* guid */398 memcpy(¶m.guid, vendor, sizeof(param.guid));399 400 /* variable name, already in UTF-16 */401 memcpy(gsmi_dev.name_buf->start, name, *name_size);402 403 /* parameter buffer */404 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);405 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));406 407 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NEXT_VAR);408 if (rc < 0) {409 printk(KERN_ERR "gsmi: Get Next Variable Name failed\n");410 ret = EFI_LOAD_ERROR;411 } else if (rc == 1) {412 /* variable not found -- end of list */413 ret = EFI_NOT_FOUND;414 } else {415 /* copy variable data back to return buffer */416 memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param));417 418 /* Copy the name back */419 memcpy(name, gsmi_dev.name_buf->start, GSMI_BUF_SIZE);420 *name_size = ucs2_strnlen(name, GSMI_BUF_SIZE / 2) * 2;421 422 /* copy guid to return buffer */423 memcpy(vendor, ¶m.guid, sizeof(param.guid));424 ret = EFI_SUCCESS;425 }426 427 spin_unlock_irqrestore(&gsmi_dev.lock, flags);428 429 return ret;430}431 432static efi_status_t gsmi_set_variable(efi_char16_t *name,433 efi_guid_t *vendor,434 u32 attr,435 unsigned long data_size,436 void *data)437{438 struct gsmi_nvram_var_param param = {439 .name_ptr = gsmi_dev.name_buf->address,440 .data_ptr = gsmi_dev.data_buf->address,441 .data_len = (u32)data_size,442 .attributes = EFI_VARIABLE_NON_VOLATILE |443 EFI_VARIABLE_BOOTSERVICE_ACCESS |444 EFI_VARIABLE_RUNTIME_ACCESS,445 };446 size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2);447 efi_status_t ret = EFI_SUCCESS;448 int rc;449 unsigned long flags;450 451 if (name_len >= GSMI_BUF_SIZE / 2)452 return EFI_BAD_BUFFER_SIZE;453 454 spin_lock_irqsave(&gsmi_dev.lock, flags);455 456 /* guid */457 memcpy(¶m.guid, vendor, sizeof(param.guid));458 459 /* variable name, already in UTF-16 */460 memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length);461 memcpy(gsmi_dev.name_buf->start, name, name_len * 2);462 463 /* data pointer */464 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);465 memcpy(gsmi_dev.data_buf->start, data, data_size);466 467 /* parameter buffer */468 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);469 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));470 471 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_NVRAM_VAR);472 if (rc < 0) {473 printk(KERN_ERR "gsmi: Set Variable failed\n");474 ret = EFI_INVALID_PARAMETER;475 }476 477 spin_unlock_irqrestore(&gsmi_dev.lock, flags);478 479 return ret;480}481 482static const struct efivar_operations efivar_ops = {483 .get_variable = gsmi_get_variable,484 .set_variable = gsmi_set_variable,485 .get_next_variable = gsmi_get_next_variable,486};487 488#endif /* CONFIG_EFI */489 490static ssize_t eventlog_write(struct file *filp, struct kobject *kobj,491 struct bin_attribute *bin_attr,492 char *buf, loff_t pos, size_t count)493{494 struct gsmi_set_eventlog_param param = {495 .data_ptr = gsmi_dev.data_buf->address,496 };497 int rc = 0;498 unsigned long flags;499 500 /* Pull the type out */501 if (count < sizeof(u32))502 return -EINVAL;503 param.type = *(u32 *)buf;504 buf += sizeof(u32);505 506 /* The remaining buffer is the data payload */507 if ((count - sizeof(u32)) > gsmi_dev.data_buf->length)508 return -EINVAL;509 param.data_len = count - sizeof(u32);510 511 spin_lock_irqsave(&gsmi_dev.lock, flags);512 513 /* data pointer */514 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);515 memcpy(gsmi_dev.data_buf->start, buf, param.data_len);516 517 /* parameter buffer */518 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);519 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));520 521 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);522 if (rc < 0)523 printk(KERN_ERR "gsmi: Set Event Log failed\n");524 525 spin_unlock_irqrestore(&gsmi_dev.lock, flags);526 527 return (rc == 0) ? count : rc;528 529}530 531static struct bin_attribute eventlog_bin_attr = {532 .attr = {.name = "append_to_eventlog", .mode = 0200},533 .write = eventlog_write,534};535 536static ssize_t gsmi_clear_eventlog_store(struct kobject *kobj,537 struct kobj_attribute *attr,538 const char *buf, size_t count)539{540 int rc;541 unsigned long flags;542 unsigned long val;543 struct {544 u32 percentage;545 u32 data_type;546 } param;547 548 rc = kstrtoul(buf, 0, &val);549 if (rc)550 return rc;551 552 /*553 * Value entered is a percentage, 0 through 100, anything else554 * is invalid.555 */556 if (val > 100)557 return -EINVAL;558 559 /* data_type here selects the smbios event log. */560 param.percentage = val;561 param.data_type = 0;562 563 spin_lock_irqsave(&gsmi_dev.lock, flags);564 565 /* parameter buffer */566 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);567 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));568 569 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_EVENT_LOG);570 571 spin_unlock_irqrestore(&gsmi_dev.lock, flags);572 573 if (rc)574 return rc;575 return count;576}577 578static struct kobj_attribute gsmi_clear_eventlog_attr = {579 .attr = {.name = "clear_eventlog", .mode = 0200},580 .store = gsmi_clear_eventlog_store,581};582 583static ssize_t gsmi_clear_config_store(struct kobject *kobj,584 struct kobj_attribute *attr,585 const char *buf, size_t count)586{587 int rc;588 unsigned long flags;589 590 spin_lock_irqsave(&gsmi_dev.lock, flags);591 592 /* clear parameter buffer */593 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);594 595 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_CONFIG);596 597 spin_unlock_irqrestore(&gsmi_dev.lock, flags);598 599 if (rc)600 return rc;601 return count;602}603 604static struct kobj_attribute gsmi_clear_config_attr = {605 .attr = {.name = "clear_config", .mode = 0200},606 .store = gsmi_clear_config_store,607};608 609static const struct attribute *gsmi_attrs[] = {610 &gsmi_clear_config_attr.attr,611 &gsmi_clear_eventlog_attr.attr,612 NULL,613};614 615static int gsmi_shutdown_reason(int reason)616{617 struct gsmi_log_entry_type_1 entry = {618 .type = GSMI_LOG_ENTRY_TYPE_KERNEL,619 .instance = reason,620 };621 struct gsmi_set_eventlog_param param = {622 .data_len = sizeof(entry),623 .type = 1,624 };625 static int saved_reason;626 int rc = 0;627 unsigned long flags;628 629 /* avoid duplicate entries in the log */630 if (saved_reason & (1 << reason))631 return 0;632 633 spin_lock_irqsave(&gsmi_dev.lock, flags);634 635 saved_reason |= (1 << reason);636 637 /* data pointer */638 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);639 memcpy(gsmi_dev.data_buf->start, &entry, sizeof(entry));640 641 /* parameter buffer */642 param.data_ptr = gsmi_dev.data_buf->address;643 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);644 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));645 646 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);647 648 spin_unlock_irqrestore(&gsmi_dev.lock, flags);649 650 if (rc < 0)651 printk(KERN_ERR "gsmi: Log Shutdown Reason failed\n");652 else653 printk(KERN_EMERG "gsmi: Log Shutdown Reason 0x%02x\n",654 reason);655 656 return rc;657}658 659static int gsmi_reboot_callback(struct notifier_block *nb,660 unsigned long reason, void *arg)661{662 gsmi_shutdown_reason(GSMI_SHUTDOWN_CLEAN);663 return NOTIFY_DONE;664}665 666static struct notifier_block gsmi_reboot_notifier = {667 .notifier_call = gsmi_reboot_callback668};669 670static int gsmi_die_callback(struct notifier_block *nb,671 unsigned long reason, void *arg)672{673 if (reason == DIE_OOPS)674 gsmi_shutdown_reason(GSMI_SHUTDOWN_OOPS);675 return NOTIFY_DONE;676}677 678static struct notifier_block gsmi_die_notifier = {679 .notifier_call = gsmi_die_callback680};681 682static int gsmi_panic_callback(struct notifier_block *nb,683 unsigned long reason, void *arg)684{685 686 /*687 * Panic callbacks are executed with all other CPUs stopped,688 * so we must not attempt to spin waiting for gsmi_dev.lock689 * to be released.690 */691 if (spin_is_locked(&gsmi_dev.lock))692 return NOTIFY_DONE;693 694 gsmi_shutdown_reason(GSMI_SHUTDOWN_PANIC);695 return NOTIFY_DONE;696}697 698static struct notifier_block gsmi_panic_notifier = {699 .notifier_call = gsmi_panic_callback,700};701 702/*703 * This hash function was blatantly copied from include/linux/hash.h.704 * It is used by this driver to obfuscate a board name that requires a705 * quirk within this driver.706 *707 * Please do not remove this copy of the function as any changes to the708 * global utility hash_64() function would break this driver's ability709 * to identify a board and provide the appropriate quirk -- mikew@google.com710 */711static u64 __init local_hash_64(u64 val, unsigned bits)712{713 u64 hash = val;714 715 /* Sigh, gcc can't optimise this alone like it does for 32 bits. */716 u64 n = hash;717 n <<= 18;718 hash -= n;719 n <<= 33;720 hash -= n;721 n <<= 3;722 hash += n;723 n <<= 3;724 hash -= n;725 n <<= 4;726 hash += n;727 n <<= 2;728 hash += n;729 730 /* High bits are more random, so use them. */731 return hash >> (64 - bits);732}733 734static u32 __init hash_oem_table_id(char s[8])735{736 u64 input;737 memcpy(&input, s, 8);738 return local_hash_64(input, 32);739}740 741static const struct dmi_system_id gsmi_dmi_table[] __initconst = {742 {743 .ident = "Google Board",744 .matches = {745 DMI_MATCH(DMI_BOARD_VENDOR, "Google, Inc."),746 },747 },748 {749 .ident = "Coreboot Firmware",750 .matches = {751 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),752 },753 },754 {}755};756MODULE_DEVICE_TABLE(dmi, gsmi_dmi_table);757 758static __init int gsmi_system_valid(void)759{760 u32 hash;761 u16 cmd, result;762 763 if (!dmi_check_system(gsmi_dmi_table))764 return -ENODEV;765 766 /*767 * Only newer firmware supports the gsmi interface. All older768 * firmware that didn't support this interface used to plug the769 * table name in the first four bytes of the oem_table_id field.770 * Newer firmware doesn't do that though, so use that as the771 * discriminant factor. We have to do this in order to772 * whitewash our board names out of the public driver.773 */774 if (!strncmp(acpi_gbl_FADT.header.oem_table_id, "FACP", 4)) {775 printk(KERN_INFO "gsmi: Board is too old\n");776 return -ENODEV;777 }778 779 /* Disable on board with 1.0 BIOS due to Google bug 2602657 */780 hash = hash_oem_table_id(acpi_gbl_FADT.header.oem_table_id);781 if (hash == QUIRKY_BOARD_HASH) {782 const char *bios_ver = dmi_get_system_info(DMI_BIOS_VERSION);783 if (strncmp(bios_ver, "1.0", 3) == 0) {784 pr_info("gsmi: disabled on this board's BIOS %s\n",785 bios_ver);786 return -ENODEV;787 }788 }789 790 /* check for valid SMI command port in ACPI FADT */791 if (acpi_gbl_FADT.smi_command == 0) {792 pr_info("gsmi: missing smi_command\n");793 return -ENODEV;794 }795 796 /* Test the smihandler with a bogus command. If it leaves the797 * calling argument in %ax untouched, there is no handler for798 * GSMI commands.799 */800 cmd = GSMI_CALLBACK | GSMI_CMD_RESERVED << 8;801 asm volatile (802 "outb %%al, %%dx\n\t"803 : "=a" (result)804 : "0" (cmd),805 "d" (acpi_gbl_FADT.smi_command)806 : "memory", "cc"807 );808 if (cmd == result) {809 pr_info("gsmi: no gsmi handler in firmware\n");810 return -ENODEV;811 }812 813 /* Found */814 return 0;815}816 817static struct kobject *gsmi_kobj;818 819static const struct platform_device_info gsmi_dev_info = {820 .name = "gsmi",821 .id = -1,822 /* SMI callbacks require 32bit addresses */823 .dma_mask = DMA_BIT_MASK(32),824};825 826#ifdef CONFIG_PM827static void gsmi_log_s0ix_info(u8 cmd)828{829 unsigned long flags;830 831 /*832 * If platform has not enabled S0ix logging, then no action is833 * necessary.834 */835 if (!s0ix_logging_enable)836 return;837 838 spin_lock_irqsave(&gsmi_dev.lock, flags);839 840 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);841 842 gsmi_exec(GSMI_CALLBACK, cmd);843 844 spin_unlock_irqrestore(&gsmi_dev.lock, flags);845}846 847static int gsmi_log_s0ix_suspend(struct device *dev)848{849 /*850 * If system is not suspending via firmware using the standard ACPI Sx851 * types, then make a GSMI call to log the suspend info.852 */853 if (!pm_suspend_via_firmware())854 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_SUSPEND);855 856 /*857 * Always return success, since we do not want suspend858 * to fail just because of logging failure.859 */860 return 0;861}862 863static int gsmi_log_s0ix_resume(struct device *dev)864{865 /*866 * If system did not resume via firmware, then make a GSMI call to log867 * the resume info and wake source.868 */869 if (!pm_resume_via_firmware())870 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_RESUME);871 872 /*873 * Always return success, since we do not want resume874 * to fail just because of logging failure.875 */876 return 0;877}878 879static const struct dev_pm_ops gsmi_pm_ops = {880 .suspend_noirq = gsmi_log_s0ix_suspend,881 .resume_noirq = gsmi_log_s0ix_resume,882};883 884static int gsmi_platform_driver_probe(struct platform_device *dev)885{886 return 0;887}888 889static struct platform_driver gsmi_driver_info = {890 .driver = {891 .name = "gsmi",892 .pm = &gsmi_pm_ops,893 },894 .probe = gsmi_platform_driver_probe,895};896#endif897 898static __init int gsmi_init(void)899{900 unsigned long flags;901 int ret;902 903 ret = gsmi_system_valid();904 if (ret)905 return ret;906 907 gsmi_dev.smi_cmd = acpi_gbl_FADT.smi_command;908 909#ifdef CONFIG_PM910 ret = platform_driver_register(&gsmi_driver_info);911 if (unlikely(ret)) {912 printk(KERN_ERR "gsmi: unable to register platform driver\n");913 return ret;914 }915#endif916 917 /* register device */918 gsmi_dev.pdev = platform_device_register_full(&gsmi_dev_info);919 if (IS_ERR(gsmi_dev.pdev)) {920 printk(KERN_ERR "gsmi: unable to register platform device\n");921 return PTR_ERR(gsmi_dev.pdev);922 }923 924 /* SMI access needs to be serialized */925 spin_lock_init(&gsmi_dev.lock);926 927 ret = -ENOMEM;928 929 /*930 * SLAB cache is created using SLAB_CACHE_DMA32 to ensure that the931 * allocations for gsmi_buf come from the DMA32 memory zone. These932 * buffers have nothing to do with DMA. They are required for933 * communication with firmware executing in SMI mode which can only934 * access the bottom 4GiB of physical memory. Since DMA32 memory zone935 * guarantees allocation under the 4GiB boundary, this driver creates936 * a SLAB cache with SLAB_CACHE_DMA32 flag.937 */938 gsmi_dev.mem_pool = kmem_cache_create("gsmi", GSMI_BUF_SIZE,939 GSMI_BUF_ALIGN,940 SLAB_CACHE_DMA32, NULL);941 if (!gsmi_dev.mem_pool)942 goto out_err;943 944 /*945 * pre-allocate buffers because sometimes we are called when946 * this is not feasible: oops, panic, die, mce, etc947 */948 gsmi_dev.name_buf = gsmi_buf_alloc();949 if (!gsmi_dev.name_buf) {950 printk(KERN_ERR "gsmi: failed to allocate name buffer\n");951 goto out_err;952 }953 954 gsmi_dev.data_buf = gsmi_buf_alloc();955 if (!gsmi_dev.data_buf) {956 printk(KERN_ERR "gsmi: failed to allocate data buffer\n");957 goto out_err;958 }959 960 gsmi_dev.param_buf = gsmi_buf_alloc();961 if (!gsmi_dev.param_buf) {962 printk(KERN_ERR "gsmi: failed to allocate param buffer\n");963 goto out_err;964 }965 966 /*967 * Determine type of handshake used to serialize the SMI968 * entry. See also gsmi_exec().969 *970 * There's a "behavior" present on some chipsets where writing the971 * SMI trigger register in the southbridge doesn't result in an972 * immediate SMI. Rather, the processor can execute "a few" more973 * instructions before the SMI takes effect. To ensure synchronous974 * behavior, implement a handshake between the kernel driver and the975 * firmware handler to spin until released. This ioctl determines976 * the type of handshake.977 *978 * NONE: The firmware handler does not implement any979 * handshake. Either it doesn't need to, or it's legacy firmware980 * that doesn't know it needs to and never will.981 *982 * CF: The firmware handler will clear the CF in the saved983 * state before returning. The driver may set the CF and test for984 * it to clear before proceeding.985 *986 * SPIN: The firmware handler does not implement any handshake987 * but the driver should spin for a hundred or so microseconds988 * to ensure the SMI has triggered.989 *990 * Finally, the handler will return -ENOSYS if991 * GSMI_CMD_HANDSHAKE_TYPE is unimplemented, which implies992 * HANDSHAKE_NONE.993 */994 spin_lock_irqsave(&gsmi_dev.lock, flags);995 gsmi_dev.handshake_type = GSMI_HANDSHAKE_SPIN;996 gsmi_dev.handshake_type =997 gsmi_exec(GSMI_CALLBACK, GSMI_CMD_HANDSHAKE_TYPE);998 if (gsmi_dev.handshake_type == -ENOSYS)999 gsmi_dev.handshake_type = GSMI_HANDSHAKE_NONE;1000 spin_unlock_irqrestore(&gsmi_dev.lock, flags);1001 1002 /* Remove and clean up gsmi if the handshake could not complete. */1003 if (gsmi_dev.handshake_type == -ENXIO) {1004 printk(KERN_INFO "gsmi version " DRIVER_VERSION1005 " failed to load\n");1006 ret = -ENODEV;1007 goto out_err;1008 }1009 1010 /* Register in the firmware directory */1011 ret = -ENOMEM;1012 gsmi_kobj = kobject_create_and_add("gsmi", firmware_kobj);1013 if (!gsmi_kobj) {1014 printk(KERN_INFO "gsmi: Failed to create firmware kobj\n");1015 goto out_err;1016 }1017 1018 /* Setup eventlog access */1019 ret = sysfs_create_bin_file(gsmi_kobj, &eventlog_bin_attr);1020 if (ret) {1021 printk(KERN_INFO "gsmi: Failed to setup eventlog");1022 goto out_err;1023 }1024 1025 /* Other attributes */1026 ret = sysfs_create_files(gsmi_kobj, gsmi_attrs);1027 if (ret) {1028 printk(KERN_INFO "gsmi: Failed to add attrs");1029 goto out_remove_bin_file;1030 }1031 1032#ifdef CONFIG_EFI1033 ret = efivars_register(&efivars, &efivar_ops);1034 if (ret) {1035 printk(KERN_INFO "gsmi: Failed to register efivars\n");1036 sysfs_remove_files(gsmi_kobj, gsmi_attrs);1037 goto out_remove_bin_file;1038 }1039#endif1040 1041 register_reboot_notifier(&gsmi_reboot_notifier);1042 register_die_notifier(&gsmi_die_notifier);1043 atomic_notifier_chain_register(&panic_notifier_list,1044 &gsmi_panic_notifier);1045 1046 printk(KERN_INFO "gsmi version " DRIVER_VERSION " loaded\n");1047 1048 return 0;1049 1050out_remove_bin_file:1051 sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);1052out_err:1053 kobject_put(gsmi_kobj);1054 gsmi_buf_free(gsmi_dev.param_buf);1055 gsmi_buf_free(gsmi_dev.data_buf);1056 gsmi_buf_free(gsmi_dev.name_buf);1057 kmem_cache_destroy(gsmi_dev.mem_pool);1058 platform_device_unregister(gsmi_dev.pdev);1059 pr_info("gsmi: failed to load: %d\n", ret);1060#ifdef CONFIG_PM1061 platform_driver_unregister(&gsmi_driver_info);1062#endif1063 return ret;1064}1065 1066static void __exit gsmi_exit(void)1067{1068 unregister_reboot_notifier(&gsmi_reboot_notifier);1069 unregister_die_notifier(&gsmi_die_notifier);1070 atomic_notifier_chain_unregister(&panic_notifier_list,1071 &gsmi_panic_notifier);1072#ifdef CONFIG_EFI1073 efivars_unregister(&efivars);1074#endif1075 1076 sysfs_remove_files(gsmi_kobj, gsmi_attrs);1077 sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);1078 kobject_put(gsmi_kobj);1079 gsmi_buf_free(gsmi_dev.param_buf);1080 gsmi_buf_free(gsmi_dev.data_buf);1081 gsmi_buf_free(gsmi_dev.name_buf);1082 kmem_cache_destroy(gsmi_dev.mem_pool);1083 platform_device_unregister(gsmi_dev.pdev);1084#ifdef CONFIG_PM1085 platform_driver_unregister(&gsmi_driver_info);1086#endif1087}1088 1089module_init(gsmi_init);1090module_exit(gsmi_exit);1091 1092MODULE_AUTHOR("Google, Inc.");1093MODULE_DESCRIPTION("EFI SMI interface for Google platforms");1094MODULE_LICENSE("GPL");1095