mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 10:04:12 +08:00
8942b2d509
Add new GSMI commands (GSMI_CMD_LOG_S0IX_SUSPEND = 0xa, GSMI_CMD_LOG_S0IX_RESUME = 0xb) that allow firmware to log any information during S0ix suspend/resume paths. Traditional ACPI suspend S3 involves BIOS both during the suspend and the resume paths. However, modern suspend type like S0ix does not involve firmware on either of the paths. This command gives the firmware an opportunity to log any required information about the suspend and resume operations e.g. wake sources. Additionally, this change adds a module parameter to allow platforms to specifically enable S0ix logging if required. This prevents any other platforms from unnecessarily making a GSMI call which could have any side-effects. Tested by verifying that wake sources are correctly logged in eventlog. Signed-off-by: Furquan Shaikh <furquan@chromium.org> Reviewed-by: Aaron Durbin <adurbin@chromium.org> Reviewed-by: Rajat Jain <rajatja@chromium.org> Signed-off-by: Furquan Shaikh <furquan@google.com> Tested-by: Furquan Shaikh <furquan@chromium.org> Reviewed-by: Aaron Durbin <adurbin@chromium.org> [zwisler: update changelog for upstream] Signed-off-by: Ross Zwisler <zwisler@google.com> Reviewed-by: Guenter Roeck <groeck@chromium.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1046 lines
27 KiB
C
1046 lines
27 KiB
C
/*
|
|
* Copyright 2010 Google Inc. All Rights Reserved.
|
|
* Author: dlaurie@google.com (Duncan Laurie)
|
|
*
|
|
* Re-worked to expose sysfs APIs by mikew@google.com (Mike Waychison)
|
|
*
|
|
* EFI SMI interface for Google platforms
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/types.h>
|
|
#include <linux/device.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/string.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/dmapool.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/ioctl.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/io.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/dmi.h>
|
|
#include <linux/kdebug.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/efi.h>
|
|
#include <linux/module.h>
|
|
#include <linux/ucs2_string.h>
|
|
#include <linux/suspend.h>
|
|
|
|
#define GSMI_SHUTDOWN_CLEAN 0 /* Clean Shutdown */
|
|
/* TODO(mikew@google.com): Tie in HARDLOCKUP_DETECTOR with NMIWDT */
|
|
#define GSMI_SHUTDOWN_NMIWDT 1 /* NMI Watchdog */
|
|
#define GSMI_SHUTDOWN_PANIC 2 /* Panic */
|
|
#define GSMI_SHUTDOWN_OOPS 3 /* Oops */
|
|
#define GSMI_SHUTDOWN_DIE 4 /* Die -- No longer meaningful */
|
|
#define GSMI_SHUTDOWN_MCE 5 /* Machine Check */
|
|
#define GSMI_SHUTDOWN_SOFTWDT 6 /* Software Watchdog */
|
|
#define GSMI_SHUTDOWN_MBE 7 /* Uncorrected ECC */
|
|
#define GSMI_SHUTDOWN_TRIPLE 8 /* Triple Fault */
|
|
|
|
#define DRIVER_VERSION "1.0"
|
|
#define GSMI_GUID_SIZE 16
|
|
#define GSMI_BUF_SIZE 1024
|
|
#define GSMI_BUF_ALIGN sizeof(u64)
|
|
#define GSMI_CALLBACK 0xef
|
|
|
|
/* SMI return codes */
|
|
#define GSMI_SUCCESS 0x00
|
|
#define GSMI_UNSUPPORTED2 0x03
|
|
#define GSMI_LOG_FULL 0x0b
|
|
#define GSMI_VAR_NOT_FOUND 0x0e
|
|
#define GSMI_HANDSHAKE_SPIN 0x7d
|
|
#define GSMI_HANDSHAKE_CF 0x7e
|
|
#define GSMI_HANDSHAKE_NONE 0x7f
|
|
#define GSMI_INVALID_PARAMETER 0x82
|
|
#define GSMI_UNSUPPORTED 0x83
|
|
#define GSMI_BUFFER_TOO_SMALL 0x85
|
|
#define GSMI_NOT_READY 0x86
|
|
#define GSMI_DEVICE_ERROR 0x87
|
|
#define GSMI_NOT_FOUND 0x8e
|
|
|
|
#define QUIRKY_BOARD_HASH 0x78a30a50
|
|
|
|
/* Internally used commands passed to the firmware */
|
|
#define GSMI_CMD_GET_NVRAM_VAR 0x01
|
|
#define GSMI_CMD_GET_NEXT_VAR 0x02
|
|
#define GSMI_CMD_SET_NVRAM_VAR 0x03
|
|
#define GSMI_CMD_SET_EVENT_LOG 0x08
|
|
#define GSMI_CMD_CLEAR_EVENT_LOG 0x09
|
|
#define GSMI_CMD_LOG_S0IX_SUSPEND 0x0a
|
|
#define GSMI_CMD_LOG_S0IX_RESUME 0x0b
|
|
#define GSMI_CMD_CLEAR_CONFIG 0x20
|
|
#define GSMI_CMD_HANDSHAKE_TYPE 0xC1
|
|
|
|
/* Magic entry type for kernel events */
|
|
#define GSMI_LOG_ENTRY_TYPE_KERNEL 0xDEAD
|
|
|
|
/* SMI buffers must be in 32bit physical address space */
|
|
struct gsmi_buf {
|
|
u8 *start; /* start of buffer */
|
|
size_t length; /* length of buffer */
|
|
dma_addr_t handle; /* dma allocation handle */
|
|
u32 address; /* physical address of buffer */
|
|
};
|
|
|
|
static struct gsmi_device {
|
|
struct platform_device *pdev; /* platform device */
|
|
struct gsmi_buf *name_buf; /* variable name buffer */
|
|
struct gsmi_buf *data_buf; /* generic data buffer */
|
|
struct gsmi_buf *param_buf; /* parameter buffer */
|
|
spinlock_t lock; /* serialize access to SMIs */
|
|
u16 smi_cmd; /* SMI command port */
|
|
int handshake_type; /* firmware handler interlock type */
|
|
struct dma_pool *dma_pool; /* DMA buffer pool */
|
|
} gsmi_dev;
|
|
|
|
/* Packed structures for communicating with the firmware */
|
|
struct gsmi_nvram_var_param {
|
|
efi_guid_t guid;
|
|
u32 name_ptr;
|
|
u32 attributes;
|
|
u32 data_len;
|
|
u32 data_ptr;
|
|
} __packed;
|
|
|
|
struct gsmi_get_next_var_param {
|
|
u8 guid[GSMI_GUID_SIZE];
|
|
u32 name_ptr;
|
|
u32 name_len;
|
|
} __packed;
|
|
|
|
struct gsmi_set_eventlog_param {
|
|
u32 data_ptr;
|
|
u32 data_len;
|
|
u32 type;
|
|
} __packed;
|
|
|
|
/* Event log formats */
|
|
struct gsmi_log_entry_type_1 {
|
|
u16 type;
|
|
u32 instance;
|
|
} __packed;
|
|
|
|
/*
|
|
* Some platforms don't have explicit SMI handshake
|
|
* and need to wait for SMI to complete.
|
|
*/
|
|
#define GSMI_DEFAULT_SPINCOUNT 0x10000
|
|
static unsigned int spincount = GSMI_DEFAULT_SPINCOUNT;
|
|
module_param(spincount, uint, 0600);
|
|
MODULE_PARM_DESC(spincount,
|
|
"The number of loop iterations to use when using the spin handshake.");
|
|
|
|
/*
|
|
* Platforms might not support S0ix logging in their GSMI handlers. In order to
|
|
* avoid any side-effects of generating an SMI for S0ix logging, use the S0ix
|
|
* related GSMI commands only for those platforms that explicitly enable this
|
|
* option.
|
|
*/
|
|
static bool s0ix_logging_enable;
|
|
module_param(s0ix_logging_enable, bool, 0600);
|
|
|
|
static struct gsmi_buf *gsmi_buf_alloc(void)
|
|
{
|
|
struct gsmi_buf *smibuf;
|
|
|
|
smibuf = kzalloc(sizeof(*smibuf), GFP_KERNEL);
|
|
if (!smibuf) {
|
|
printk(KERN_ERR "gsmi: out of memory\n");
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate buffer in 32bit address space */
|
|
smibuf->start = dma_pool_alloc(gsmi_dev.dma_pool, GFP_KERNEL,
|
|
&smibuf->handle);
|
|
if (!smibuf->start) {
|
|
printk(KERN_ERR "gsmi: failed to allocate name buffer\n");
|
|
kfree(smibuf);
|
|
return NULL;
|
|
}
|
|
|
|
/* fill in the buffer handle */
|
|
smibuf->length = GSMI_BUF_SIZE;
|
|
smibuf->address = (u32)virt_to_phys(smibuf->start);
|
|
|
|
return smibuf;
|
|
}
|
|
|
|
static void gsmi_buf_free(struct gsmi_buf *smibuf)
|
|
{
|
|
if (smibuf) {
|
|
if (smibuf->start)
|
|
dma_pool_free(gsmi_dev.dma_pool, smibuf->start,
|
|
smibuf->handle);
|
|
kfree(smibuf);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make a call to gsmi func(sub). GSMI error codes are translated to
|
|
* in-kernel errnos (0 on success, -ERRNO on error).
|
|
*/
|
|
static int gsmi_exec(u8 func, u8 sub)
|
|
{
|
|
u16 cmd = (sub << 8) | func;
|
|
u16 result = 0;
|
|
int rc = 0;
|
|
|
|
/*
|
|
* AH : Subfunction number
|
|
* AL : Function number
|
|
* EBX : Parameter block address
|
|
* DX : SMI command port
|
|
*
|
|
* Three protocols here. See also the comment in gsmi_init().
|
|
*/
|
|
if (gsmi_dev.handshake_type == GSMI_HANDSHAKE_CF) {
|
|
/*
|
|
* If handshake_type == HANDSHAKE_CF then set CF on the
|
|
* way in and wait for the handler to clear it; this avoids
|
|
* corrupting register state on those chipsets which have
|
|
* a delay between writing the SMI trigger register and
|
|
* entering SMM.
|
|
*/
|
|
asm volatile (
|
|
"stc\n"
|
|
"outb %%al, %%dx\n"
|
|
"1: jc 1b\n"
|
|
: "=a" (result)
|
|
: "0" (cmd),
|
|
"d" (gsmi_dev.smi_cmd),
|
|
"b" (gsmi_dev.param_buf->address)
|
|
: "memory", "cc"
|
|
);
|
|
} else if (gsmi_dev.handshake_type == GSMI_HANDSHAKE_SPIN) {
|
|
/*
|
|
* If handshake_type == HANDSHAKE_SPIN we spin a
|
|
* hundred-ish usecs to ensure the SMI has triggered.
|
|
*/
|
|
asm volatile (
|
|
"outb %%al, %%dx\n"
|
|
"1: loop 1b\n"
|
|
: "=a" (result)
|
|
: "0" (cmd),
|
|
"d" (gsmi_dev.smi_cmd),
|
|
"b" (gsmi_dev.param_buf->address),
|
|
"c" (spincount)
|
|
: "memory", "cc"
|
|
);
|
|
} else {
|
|
/*
|
|
* If handshake_type == HANDSHAKE_NONE we do nothing;
|
|
* either we don't need to or it's legacy firmware that
|
|
* doesn't understand the CF protocol.
|
|
*/
|
|
asm volatile (
|
|
"outb %%al, %%dx\n\t"
|
|
: "=a" (result)
|
|
: "0" (cmd),
|
|
"d" (gsmi_dev.smi_cmd),
|
|
"b" (gsmi_dev.param_buf->address)
|
|
: "memory", "cc"
|
|
);
|
|
}
|
|
|
|
/* check return code from SMI handler */
|
|
switch (result) {
|
|
case GSMI_SUCCESS:
|
|
break;
|
|
case GSMI_VAR_NOT_FOUND:
|
|
/* not really an error, but let the caller know */
|
|
rc = 1;
|
|
break;
|
|
case GSMI_INVALID_PARAMETER:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Invalid parameter\n", cmd);
|
|
rc = -EINVAL;
|
|
break;
|
|
case GSMI_BUFFER_TOO_SMALL:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Buffer too small\n", cmd);
|
|
rc = -ENOMEM;
|
|
break;
|
|
case GSMI_UNSUPPORTED:
|
|
case GSMI_UNSUPPORTED2:
|
|
if (sub != GSMI_CMD_HANDSHAKE_TYPE)
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Not supported\n",
|
|
cmd);
|
|
rc = -ENOSYS;
|
|
break;
|
|
case GSMI_NOT_READY:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Not ready\n", cmd);
|
|
rc = -EBUSY;
|
|
break;
|
|
case GSMI_DEVICE_ERROR:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Device error\n", cmd);
|
|
rc = -EFAULT;
|
|
break;
|
|
case GSMI_NOT_FOUND:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Data not found\n", cmd);
|
|
rc = -ENOENT;
|
|
break;
|
|
case GSMI_LOG_FULL:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Log full\n", cmd);
|
|
rc = -ENOSPC;
|
|
break;
|
|
case GSMI_HANDSHAKE_CF:
|
|
case GSMI_HANDSHAKE_SPIN:
|
|
case GSMI_HANDSHAKE_NONE:
|
|
rc = result;
|
|
break;
|
|
default:
|
|
printk(KERN_ERR "gsmi: exec 0x%04x: Unknown error 0x%04x\n",
|
|
cmd, result);
|
|
rc = -ENXIO;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
#ifdef CONFIG_EFI_VARS
|
|
|
|
static struct efivars efivars;
|
|
|
|
static efi_status_t gsmi_get_variable(efi_char16_t *name,
|
|
efi_guid_t *vendor, u32 *attr,
|
|
unsigned long *data_size,
|
|
void *data)
|
|
{
|
|
struct gsmi_nvram_var_param param = {
|
|
.name_ptr = gsmi_dev.name_buf->address,
|
|
.data_ptr = gsmi_dev.data_buf->address,
|
|
.data_len = (u32)*data_size,
|
|
};
|
|
efi_status_t ret = EFI_SUCCESS;
|
|
unsigned long flags;
|
|
size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2);
|
|
int rc;
|
|
|
|
if (name_len >= GSMI_BUF_SIZE / 2)
|
|
return EFI_BAD_BUFFER_SIZE;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
/* Vendor guid */
|
|
memcpy(¶m.guid, vendor, sizeof(param.guid));
|
|
|
|
/* variable name, already in UTF-16 */
|
|
memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length);
|
|
memcpy(gsmi_dev.name_buf->start, name, name_len * 2);
|
|
|
|
/* data pointer */
|
|
memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
|
|
|
|
/* parameter buffer */
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NVRAM_VAR);
|
|
if (rc < 0) {
|
|
printk(KERN_ERR "gsmi: Get Variable failed\n");
|
|
ret = EFI_LOAD_ERROR;
|
|
} else if (rc == 1) {
|
|
/* variable was not found */
|
|
ret = EFI_NOT_FOUND;
|
|
} else {
|
|
/* Get the arguments back */
|
|
memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param));
|
|
|
|
/* The size reported is the min of all of our buffers */
|
|
*data_size = min_t(unsigned long, *data_size,
|
|
gsmi_dev.data_buf->length);
|
|
*data_size = min_t(unsigned long, *data_size, param.data_len);
|
|
|
|
/* Copy data back to return buffer. */
|
|
memcpy(data, gsmi_dev.data_buf->start, *data_size);
|
|
|
|
/* All variables are have the following attributes */
|
|
*attr = EFI_VARIABLE_NON_VOLATILE |
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS |
|
|
EFI_VARIABLE_RUNTIME_ACCESS;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static efi_status_t gsmi_get_next_variable(unsigned long *name_size,
|
|
efi_char16_t *name,
|
|
efi_guid_t *vendor)
|
|
{
|
|
struct gsmi_get_next_var_param param = {
|
|
.name_ptr = gsmi_dev.name_buf->address,
|
|
.name_len = gsmi_dev.name_buf->length,
|
|
};
|
|
efi_status_t ret = EFI_SUCCESS;
|
|
int rc;
|
|
unsigned long flags;
|
|
|
|
/* For the moment, only support buffers that exactly match in size */
|
|
if (*name_size != GSMI_BUF_SIZE)
|
|
return EFI_BAD_BUFFER_SIZE;
|
|
|
|
/* Let's make sure the thing is at least null-terminated */
|
|
if (ucs2_strnlen(name, GSMI_BUF_SIZE / 2) == GSMI_BUF_SIZE / 2)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
/* guid */
|
|
memcpy(¶m.guid, vendor, sizeof(param.guid));
|
|
|
|
/* variable name, already in UTF-16 */
|
|
memcpy(gsmi_dev.name_buf->start, name, *name_size);
|
|
|
|
/* parameter buffer */
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NEXT_VAR);
|
|
if (rc < 0) {
|
|
printk(KERN_ERR "gsmi: Get Next Variable Name failed\n");
|
|
ret = EFI_LOAD_ERROR;
|
|
} else if (rc == 1) {
|
|
/* variable not found -- end of list */
|
|
ret = EFI_NOT_FOUND;
|
|
} else {
|
|
/* copy variable data back to return buffer */
|
|
memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param));
|
|
|
|
/* Copy the name back */
|
|
memcpy(name, gsmi_dev.name_buf->start, GSMI_BUF_SIZE);
|
|
*name_size = ucs2_strnlen(name, GSMI_BUF_SIZE / 2) * 2;
|
|
|
|
/* copy guid to return buffer */
|
|
memcpy(vendor, ¶m.guid, sizeof(param.guid));
|
|
ret = EFI_SUCCESS;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static efi_status_t gsmi_set_variable(efi_char16_t *name,
|
|
efi_guid_t *vendor,
|
|
u32 attr,
|
|
unsigned long data_size,
|
|
void *data)
|
|
{
|
|
struct gsmi_nvram_var_param param = {
|
|
.name_ptr = gsmi_dev.name_buf->address,
|
|
.data_ptr = gsmi_dev.data_buf->address,
|
|
.data_len = (u32)data_size,
|
|
.attributes = EFI_VARIABLE_NON_VOLATILE |
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS |
|
|
EFI_VARIABLE_RUNTIME_ACCESS,
|
|
};
|
|
size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2);
|
|
efi_status_t ret = EFI_SUCCESS;
|
|
int rc;
|
|
unsigned long flags;
|
|
|
|
if (name_len >= GSMI_BUF_SIZE / 2)
|
|
return EFI_BAD_BUFFER_SIZE;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
/* guid */
|
|
memcpy(¶m.guid, vendor, sizeof(param.guid));
|
|
|
|
/* variable name, already in UTF-16 */
|
|
memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length);
|
|
memcpy(gsmi_dev.name_buf->start, name, name_len * 2);
|
|
|
|
/* data pointer */
|
|
memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
|
|
memcpy(gsmi_dev.data_buf->start, data, data_size);
|
|
|
|
/* parameter buffer */
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_NVRAM_VAR);
|
|
if (rc < 0) {
|
|
printk(KERN_ERR "gsmi: Set Variable failed\n");
|
|
ret = EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct efivar_operations efivar_ops = {
|
|
.get_variable = gsmi_get_variable,
|
|
.set_variable = gsmi_set_variable,
|
|
.get_next_variable = gsmi_get_next_variable,
|
|
};
|
|
|
|
#endif /* CONFIG_EFI_VARS */
|
|
|
|
static ssize_t eventlog_write(struct file *filp, struct kobject *kobj,
|
|
struct bin_attribute *bin_attr,
|
|
char *buf, loff_t pos, size_t count)
|
|
{
|
|
struct gsmi_set_eventlog_param param = {
|
|
.data_ptr = gsmi_dev.data_buf->address,
|
|
};
|
|
int rc = 0;
|
|
unsigned long flags;
|
|
|
|
/* Pull the type out */
|
|
if (count < sizeof(u32))
|
|
return -EINVAL;
|
|
param.type = *(u32 *)buf;
|
|
buf += sizeof(u32);
|
|
|
|
/* The remaining buffer is the data payload */
|
|
if ((count - sizeof(u32)) > gsmi_dev.data_buf->length)
|
|
return -EINVAL;
|
|
param.data_len = count - sizeof(u32);
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
/* data pointer */
|
|
memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
|
|
memcpy(gsmi_dev.data_buf->start, buf, param.data_len);
|
|
|
|
/* parameter buffer */
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);
|
|
if (rc < 0)
|
|
printk(KERN_ERR "gsmi: Set Event Log failed\n");
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
return (rc == 0) ? count : rc;
|
|
|
|
}
|
|
|
|
static struct bin_attribute eventlog_bin_attr = {
|
|
.attr = {.name = "append_to_eventlog", .mode = 0200},
|
|
.write = eventlog_write,
|
|
};
|
|
|
|
static ssize_t gsmi_clear_eventlog_store(struct kobject *kobj,
|
|
struct kobj_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
int rc;
|
|
unsigned long flags;
|
|
unsigned long val;
|
|
struct {
|
|
u32 percentage;
|
|
u32 data_type;
|
|
} param;
|
|
|
|
rc = kstrtoul(buf, 0, &val);
|
|
if (rc)
|
|
return rc;
|
|
|
|
/*
|
|
* Value entered is a percentage, 0 through 100, anything else
|
|
* is invalid.
|
|
*/
|
|
if (val > 100)
|
|
return -EINVAL;
|
|
|
|
/* data_type here selects the smbios event log. */
|
|
param.percentage = val;
|
|
param.data_type = 0;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
/* parameter buffer */
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_EVENT_LOG);
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
if (rc)
|
|
return rc;
|
|
return count;
|
|
}
|
|
|
|
static struct kobj_attribute gsmi_clear_eventlog_attr = {
|
|
.attr = {.name = "clear_eventlog", .mode = 0200},
|
|
.store = gsmi_clear_eventlog_store,
|
|
};
|
|
|
|
static ssize_t gsmi_clear_config_store(struct kobject *kobj,
|
|
struct kobj_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
int rc;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
/* clear parameter buffer */
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_CONFIG);
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
if (rc)
|
|
return rc;
|
|
return count;
|
|
}
|
|
|
|
static struct kobj_attribute gsmi_clear_config_attr = {
|
|
.attr = {.name = "clear_config", .mode = 0200},
|
|
.store = gsmi_clear_config_store,
|
|
};
|
|
|
|
static const struct attribute *gsmi_attrs[] = {
|
|
&gsmi_clear_config_attr.attr,
|
|
&gsmi_clear_eventlog_attr.attr,
|
|
NULL,
|
|
};
|
|
|
|
static int gsmi_shutdown_reason(int reason)
|
|
{
|
|
struct gsmi_log_entry_type_1 entry = {
|
|
.type = GSMI_LOG_ENTRY_TYPE_KERNEL,
|
|
.instance = reason,
|
|
};
|
|
struct gsmi_set_eventlog_param param = {
|
|
.data_len = sizeof(entry),
|
|
.type = 1,
|
|
};
|
|
static int saved_reason;
|
|
int rc = 0;
|
|
unsigned long flags;
|
|
|
|
/* avoid duplicate entries in the log */
|
|
if (saved_reason & (1 << reason))
|
|
return 0;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
saved_reason |= (1 << reason);
|
|
|
|
/* data pointer */
|
|
memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
|
|
memcpy(gsmi_dev.data_buf->start, &entry, sizeof(entry));
|
|
|
|
/* parameter buffer */
|
|
param.data_ptr = gsmi_dev.data_buf->address;
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
|
|
|
|
rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
if (rc < 0)
|
|
printk(KERN_ERR "gsmi: Log Shutdown Reason failed\n");
|
|
else
|
|
printk(KERN_EMERG "gsmi: Log Shutdown Reason 0x%02x\n",
|
|
reason);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int gsmi_reboot_callback(struct notifier_block *nb,
|
|
unsigned long reason, void *arg)
|
|
{
|
|
gsmi_shutdown_reason(GSMI_SHUTDOWN_CLEAN);
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static struct notifier_block gsmi_reboot_notifier = {
|
|
.notifier_call = gsmi_reboot_callback
|
|
};
|
|
|
|
static int gsmi_die_callback(struct notifier_block *nb,
|
|
unsigned long reason, void *arg)
|
|
{
|
|
if (reason == DIE_OOPS)
|
|
gsmi_shutdown_reason(GSMI_SHUTDOWN_OOPS);
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static struct notifier_block gsmi_die_notifier = {
|
|
.notifier_call = gsmi_die_callback
|
|
};
|
|
|
|
static int gsmi_panic_callback(struct notifier_block *nb,
|
|
unsigned long reason, void *arg)
|
|
{
|
|
gsmi_shutdown_reason(GSMI_SHUTDOWN_PANIC);
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static struct notifier_block gsmi_panic_notifier = {
|
|
.notifier_call = gsmi_panic_callback,
|
|
};
|
|
|
|
/*
|
|
* This hash function was blatantly copied from include/linux/hash.h.
|
|
* It is used by this driver to obfuscate a board name that requires a
|
|
* quirk within this driver.
|
|
*
|
|
* Please do not remove this copy of the function as any changes to the
|
|
* global utility hash_64() function would break this driver's ability
|
|
* to identify a board and provide the appropriate quirk -- mikew@google.com
|
|
*/
|
|
static u64 __init local_hash_64(u64 val, unsigned bits)
|
|
{
|
|
u64 hash = val;
|
|
|
|
/* Sigh, gcc can't optimise this alone like it does for 32 bits. */
|
|
u64 n = hash;
|
|
n <<= 18;
|
|
hash -= n;
|
|
n <<= 33;
|
|
hash -= n;
|
|
n <<= 3;
|
|
hash += n;
|
|
n <<= 3;
|
|
hash -= n;
|
|
n <<= 4;
|
|
hash += n;
|
|
n <<= 2;
|
|
hash += n;
|
|
|
|
/* High bits are more random, so use them. */
|
|
return hash >> (64 - bits);
|
|
}
|
|
|
|
static u32 __init hash_oem_table_id(char s[8])
|
|
{
|
|
u64 input;
|
|
memcpy(&input, s, 8);
|
|
return local_hash_64(input, 32);
|
|
}
|
|
|
|
static const struct dmi_system_id gsmi_dmi_table[] __initconst = {
|
|
{
|
|
.ident = "Google Board",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Google, Inc."),
|
|
},
|
|
},
|
|
{
|
|
.ident = "Coreboot Firmware",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
|
|
},
|
|
},
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(dmi, gsmi_dmi_table);
|
|
|
|
static __init int gsmi_system_valid(void)
|
|
{
|
|
u32 hash;
|
|
|
|
if (!dmi_check_system(gsmi_dmi_table))
|
|
return -ENODEV;
|
|
|
|
/*
|
|
* Only newer firmware supports the gsmi interface. All older
|
|
* firmware that didn't support this interface used to plug the
|
|
* table name in the first four bytes of the oem_table_id field.
|
|
* Newer firmware doesn't do that though, so use that as the
|
|
* discriminant factor. We have to do this in order to
|
|
* whitewash our board names out of the public driver.
|
|
*/
|
|
if (!strncmp(acpi_gbl_FADT.header.oem_table_id, "FACP", 4)) {
|
|
printk(KERN_INFO "gsmi: Board is too old\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* Disable on board with 1.0 BIOS due to Google bug 2602657 */
|
|
hash = hash_oem_table_id(acpi_gbl_FADT.header.oem_table_id);
|
|
if (hash == QUIRKY_BOARD_HASH) {
|
|
const char *bios_ver = dmi_get_system_info(DMI_BIOS_VERSION);
|
|
if (strncmp(bios_ver, "1.0", 3) == 0) {
|
|
pr_info("gsmi: disabled on this board's BIOS %s\n",
|
|
bios_ver);
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
|
|
/* check for valid SMI command port in ACPI FADT */
|
|
if (acpi_gbl_FADT.smi_command == 0) {
|
|
pr_info("gsmi: missing smi_command\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* Found */
|
|
return 0;
|
|
}
|
|
|
|
static struct kobject *gsmi_kobj;
|
|
|
|
static const struct platform_device_info gsmi_dev_info = {
|
|
.name = "gsmi",
|
|
.id = -1,
|
|
/* SMI callbacks require 32bit addresses */
|
|
.dma_mask = DMA_BIT_MASK(32),
|
|
};
|
|
|
|
#ifdef CONFIG_PM
|
|
static void gsmi_log_s0ix_info(u8 cmd)
|
|
{
|
|
unsigned long flags;
|
|
|
|
/*
|
|
* If platform has not enabled S0ix logging, then no action is
|
|
* necessary.
|
|
*/
|
|
if (!s0ix_logging_enable)
|
|
return;
|
|
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
|
|
memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
|
|
|
|
gsmi_exec(GSMI_CALLBACK, cmd);
|
|
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
}
|
|
|
|
static int gsmi_log_s0ix_suspend(struct device *dev)
|
|
{
|
|
/*
|
|
* If system is not suspending via firmware using the standard ACPI Sx
|
|
* types, then make a GSMI call to log the suspend info.
|
|
*/
|
|
if (!pm_suspend_via_firmware())
|
|
gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_SUSPEND);
|
|
|
|
/*
|
|
* Always return success, since we do not want suspend
|
|
* to fail just because of logging failure.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
static int gsmi_log_s0ix_resume(struct device *dev)
|
|
{
|
|
/*
|
|
* If system did not resume via firmware, then make a GSMI call to log
|
|
* the resume info and wake source.
|
|
*/
|
|
if (!pm_resume_via_firmware())
|
|
gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_RESUME);
|
|
|
|
/*
|
|
* Always return success, since we do not want resume
|
|
* to fail just because of logging failure.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
static const struct dev_pm_ops gsmi_pm_ops = {
|
|
.suspend_noirq = gsmi_log_s0ix_suspend,
|
|
.resume_noirq = gsmi_log_s0ix_resume,
|
|
};
|
|
|
|
static int gsmi_platform_driver_probe(struct platform_device *dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver gsmi_driver_info = {
|
|
.driver = {
|
|
.name = "gsmi",
|
|
.pm = &gsmi_pm_ops,
|
|
},
|
|
.probe = gsmi_platform_driver_probe,
|
|
};
|
|
#endif
|
|
|
|
static __init int gsmi_init(void)
|
|
{
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
ret = gsmi_system_valid();
|
|
if (ret)
|
|
return ret;
|
|
|
|
gsmi_dev.smi_cmd = acpi_gbl_FADT.smi_command;
|
|
|
|
#ifdef CONFIG_PM
|
|
ret = platform_driver_register(&gsmi_driver_info);
|
|
if (unlikely(ret)) {
|
|
printk(KERN_ERR "gsmi: unable to register platform driver\n");
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* register device */
|
|
gsmi_dev.pdev = platform_device_register_full(&gsmi_dev_info);
|
|
if (IS_ERR(gsmi_dev.pdev)) {
|
|
printk(KERN_ERR "gsmi: unable to register platform device\n");
|
|
return PTR_ERR(gsmi_dev.pdev);
|
|
}
|
|
|
|
/* SMI access needs to be serialized */
|
|
spin_lock_init(&gsmi_dev.lock);
|
|
|
|
ret = -ENOMEM;
|
|
gsmi_dev.dma_pool = dma_pool_create("gsmi", &gsmi_dev.pdev->dev,
|
|
GSMI_BUF_SIZE, GSMI_BUF_ALIGN, 0);
|
|
if (!gsmi_dev.dma_pool)
|
|
goto out_err;
|
|
|
|
/*
|
|
* pre-allocate buffers because sometimes we are called when
|
|
* this is not feasible: oops, panic, die, mce, etc
|
|
*/
|
|
gsmi_dev.name_buf = gsmi_buf_alloc();
|
|
if (!gsmi_dev.name_buf) {
|
|
printk(KERN_ERR "gsmi: failed to allocate name buffer\n");
|
|
goto out_err;
|
|
}
|
|
|
|
gsmi_dev.data_buf = gsmi_buf_alloc();
|
|
if (!gsmi_dev.data_buf) {
|
|
printk(KERN_ERR "gsmi: failed to allocate data buffer\n");
|
|
goto out_err;
|
|
}
|
|
|
|
gsmi_dev.param_buf = gsmi_buf_alloc();
|
|
if (!gsmi_dev.param_buf) {
|
|
printk(KERN_ERR "gsmi: failed to allocate param buffer\n");
|
|
goto out_err;
|
|
}
|
|
|
|
/*
|
|
* Determine type of handshake used to serialize the SMI
|
|
* entry. See also gsmi_exec().
|
|
*
|
|
* There's a "behavior" present on some chipsets where writing the
|
|
* SMI trigger register in the southbridge doesn't result in an
|
|
* immediate SMI. Rather, the processor can execute "a few" more
|
|
* instructions before the SMI takes effect. To ensure synchronous
|
|
* behavior, implement a handshake between the kernel driver and the
|
|
* firmware handler to spin until released. This ioctl determines
|
|
* the type of handshake.
|
|
*
|
|
* NONE: The firmware handler does not implement any
|
|
* handshake. Either it doesn't need to, or it's legacy firmware
|
|
* that doesn't know it needs to and never will.
|
|
*
|
|
* CF: The firmware handler will clear the CF in the saved
|
|
* state before returning. The driver may set the CF and test for
|
|
* it to clear before proceeding.
|
|
*
|
|
* SPIN: The firmware handler does not implement any handshake
|
|
* but the driver should spin for a hundred or so microseconds
|
|
* to ensure the SMI has triggered.
|
|
*
|
|
* Finally, the handler will return -ENOSYS if
|
|
* GSMI_CMD_HANDSHAKE_TYPE is unimplemented, which implies
|
|
* HANDSHAKE_NONE.
|
|
*/
|
|
spin_lock_irqsave(&gsmi_dev.lock, flags);
|
|
gsmi_dev.handshake_type = GSMI_HANDSHAKE_SPIN;
|
|
gsmi_dev.handshake_type =
|
|
gsmi_exec(GSMI_CALLBACK, GSMI_CMD_HANDSHAKE_TYPE);
|
|
if (gsmi_dev.handshake_type == -ENOSYS)
|
|
gsmi_dev.handshake_type = GSMI_HANDSHAKE_NONE;
|
|
spin_unlock_irqrestore(&gsmi_dev.lock, flags);
|
|
|
|
/* Remove and clean up gsmi if the handshake could not complete. */
|
|
if (gsmi_dev.handshake_type == -ENXIO) {
|
|
printk(KERN_INFO "gsmi version " DRIVER_VERSION
|
|
" failed to load\n");
|
|
ret = -ENODEV;
|
|
goto out_err;
|
|
}
|
|
|
|
/* Register in the firmware directory */
|
|
ret = -ENOMEM;
|
|
gsmi_kobj = kobject_create_and_add("gsmi", firmware_kobj);
|
|
if (!gsmi_kobj) {
|
|
printk(KERN_INFO "gsmi: Failed to create firmware kobj\n");
|
|
goto out_err;
|
|
}
|
|
|
|
/* Setup eventlog access */
|
|
ret = sysfs_create_bin_file(gsmi_kobj, &eventlog_bin_attr);
|
|
if (ret) {
|
|
printk(KERN_INFO "gsmi: Failed to setup eventlog");
|
|
goto out_err;
|
|
}
|
|
|
|
/* Other attributes */
|
|
ret = sysfs_create_files(gsmi_kobj, gsmi_attrs);
|
|
if (ret) {
|
|
printk(KERN_INFO "gsmi: Failed to add attrs");
|
|
goto out_remove_bin_file;
|
|
}
|
|
|
|
#ifdef CONFIG_EFI_VARS
|
|
ret = efivars_register(&efivars, &efivar_ops, gsmi_kobj);
|
|
if (ret) {
|
|
printk(KERN_INFO "gsmi: Failed to register efivars\n");
|
|
sysfs_remove_files(gsmi_kobj, gsmi_attrs);
|
|
goto out_remove_bin_file;
|
|
}
|
|
#endif
|
|
|
|
register_reboot_notifier(&gsmi_reboot_notifier);
|
|
register_die_notifier(&gsmi_die_notifier);
|
|
atomic_notifier_chain_register(&panic_notifier_list,
|
|
&gsmi_panic_notifier);
|
|
|
|
printk(KERN_INFO "gsmi version " DRIVER_VERSION " loaded\n");
|
|
|
|
return 0;
|
|
|
|
out_remove_bin_file:
|
|
sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);
|
|
out_err:
|
|
kobject_put(gsmi_kobj);
|
|
gsmi_buf_free(gsmi_dev.param_buf);
|
|
gsmi_buf_free(gsmi_dev.data_buf);
|
|
gsmi_buf_free(gsmi_dev.name_buf);
|
|
dma_pool_destroy(gsmi_dev.dma_pool);
|
|
platform_device_unregister(gsmi_dev.pdev);
|
|
pr_info("gsmi: failed to load: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
static void __exit gsmi_exit(void)
|
|
{
|
|
unregister_reboot_notifier(&gsmi_reboot_notifier);
|
|
unregister_die_notifier(&gsmi_die_notifier);
|
|
atomic_notifier_chain_unregister(&panic_notifier_list,
|
|
&gsmi_panic_notifier);
|
|
#ifdef CONFIG_EFI_VARS
|
|
efivars_unregister(&efivars);
|
|
#endif
|
|
|
|
sysfs_remove_files(gsmi_kobj, gsmi_attrs);
|
|
sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);
|
|
kobject_put(gsmi_kobj);
|
|
gsmi_buf_free(gsmi_dev.param_buf);
|
|
gsmi_buf_free(gsmi_dev.data_buf);
|
|
gsmi_buf_free(gsmi_dev.name_buf);
|
|
dma_pool_destroy(gsmi_dev.dma_pool);
|
|
platform_device_unregister(gsmi_dev.pdev);
|
|
}
|
|
|
|
module_init(gsmi_init);
|
|
module_exit(gsmi_exit);
|
|
|
|
MODULE_AUTHOR("Google, Inc.");
|
|
MODULE_LICENSE("GPL");
|