1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 2010 Google Inc. All Rights Reserved.
4 * Author: dlaurie@google.com (Duncan Laurie)
6 * Re-worked to expose sysfs APIs by mikew@google.com (Mike Waychison)
8 * EFI SMI interface for Google platforms
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>
21 #include <linux/slab.h>
22 #include <linux/panic_notifier.h>
23 #include <linux/ioctl.h>
24 #include <linux/acpi.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>
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 */
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
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
67 #define QUIRKY_BOARD_HASH 0x78a30a50
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
81 /* Magic entry type for kernel events */
82 #define GSMI_LOG_ENTRY_TYPE_KERNEL 0xDEAD
84 /* SMI buffers must be in 32bit physical address space */
86 u8
*start
; /* start of buffer */
87 size_t length
; /* length of buffer */
88 u32 address
; /* physical address of buffer */
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 */
102 /* Packed structures for communicating with the firmware */
103 struct gsmi_nvram_var_param
{
111 struct gsmi_get_next_var_param
{
112 u8 guid
[GSMI_GUID_SIZE
];
117 struct gsmi_set_eventlog_param
{
123 /* Event log formats */
124 struct gsmi_log_entry_type_1
{
130 * Some platforms don't have explicit SMI handshake
131 * and need to wait for SMI to complete.
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.");
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
149 static bool s0ix_logging_enable
= true;
150 module_param(s0ix_logging_enable
, bool, 0600);
152 static struct gsmi_buf
*gsmi_buf_alloc(void)
154 struct gsmi_buf
*smibuf
;
156 smibuf
= kzalloc(sizeof(*smibuf
), GFP_KERNEL
);
158 printk(KERN_ERR
"gsmi: out of memory\n");
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");
170 /* fill in the buffer handle */
171 smibuf
->length
= GSMI_BUF_SIZE
;
172 smibuf
->address
= (u32
)virt_to_phys(smibuf
->start
);
177 static void gsmi_buf_free(struct gsmi_buf
*smibuf
)
181 kmem_cache_free(gsmi_dev
.mem_pool
, smibuf
->start
);
187 * Make a call to gsmi func(sub). GSMI error codes are translated to
188 * in-kernel errnos (0 on success, -ERRNO on error).
190 static int gsmi_exec(u8 func
, u8 sub
)
192 u16 cmd
= (sub
<< 8) | func
;
197 * AH : Subfunction number
198 * AL : Function number
199 * EBX : Parameter block address
200 * DX : SMI command port
202 * Three protocols here. See also the comment in gsmi_init().
204 if (gsmi_dev
.handshake_type
== GSMI_HANDSHAKE_CF
) {
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
218 "d" (gsmi_dev
.smi_cmd
),
219 "b" (gsmi_dev
.param_buf
->address
)
222 } else if (gsmi_dev
.handshake_type
== GSMI_HANDSHAKE_SPIN
) {
224 * If handshake_type == HANDSHAKE_SPIN we spin a
225 * hundred-ish usecs to ensure the SMI has triggered.
232 "d" (gsmi_dev
.smi_cmd
),
233 "b" (gsmi_dev
.param_buf
->address
),
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.
244 "outb %%al, %%dx\n\t"
247 "d" (gsmi_dev
.smi_cmd
),
248 "b" (gsmi_dev
.param_buf
->address
)
253 /* check return code from SMI handler */
257 case GSMI_VAR_NOT_FOUND
:
258 /* not really an error, but let the caller know */
261 case GSMI_INVALID_PARAMETER
:
262 printk(KERN_ERR
"gsmi: exec 0x%04x: Invalid parameter\n", cmd
);
265 case GSMI_BUFFER_TOO_SMALL
:
266 printk(KERN_ERR
"gsmi: exec 0x%04x: Buffer too small\n", cmd
);
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",
277 printk(KERN_ERR
"gsmi: exec 0x%04x: Not ready\n", cmd
);
280 case GSMI_DEVICE_ERROR
:
281 printk(KERN_ERR
"gsmi: exec 0x%04x: Device error\n", cmd
);
285 printk(KERN_ERR
"gsmi: exec 0x%04x: Data not found\n", cmd
);
289 printk(KERN_ERR
"gsmi: exec 0x%04x: Log full\n", cmd
);
292 case GSMI_HANDSHAKE_CF
:
293 case GSMI_HANDSHAKE_SPIN
:
294 case GSMI_HANDSHAKE_NONE
:
298 printk(KERN_ERR
"gsmi: exec 0x%04x: Unknown error 0x%04x\n",
308 static struct efivars efivars
;
310 static efi_status_t
gsmi_get_variable(efi_char16_t
*name
,
311 efi_guid_t
*vendor
, u32
*attr
,
312 unsigned long *data_size
,
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
,
320 efi_status_t ret
= EFI_SUCCESS
;
322 size_t name_len
= ucs2_strnlen(name
, GSMI_BUF_SIZE
/ 2);
325 if (name_len
>= GSMI_BUF_SIZE
/ 2)
326 return EFI_BAD_BUFFER_SIZE
;
328 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
331 memcpy(¶m
.guid
, vendor
, sizeof(param
.guid
));
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);
338 memset(gsmi_dev
.data_buf
->start
, 0, gsmi_dev
.data_buf
->length
);
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
));
344 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_GET_NVRAM_VAR
);
346 printk(KERN_ERR
"gsmi: Get Variable failed\n");
347 ret
= EFI_LOAD_ERROR
;
348 } else if (rc
== 1) {
349 /* variable was not found */
352 /* Get the arguments back */
353 memcpy(¶m
, gsmi_dev
.param_buf
->start
, sizeof(param
));
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
);
360 /* Copy data back to return buffer. */
361 memcpy(data
, gsmi_dev
.data_buf
->start
, *data_size
);
363 /* All variables are have the following attributes */
365 *attr
= EFI_VARIABLE_NON_VOLATILE
|
366 EFI_VARIABLE_BOOTSERVICE_ACCESS
|
367 EFI_VARIABLE_RUNTIME_ACCESS
;
370 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
375 static efi_status_t
gsmi_get_next_variable(unsigned long *name_size
,
379 struct gsmi_get_next_var_param param
= {
380 .name_ptr
= gsmi_dev
.name_buf
->address
,
381 .name_len
= gsmi_dev
.name_buf
->length
,
383 efi_status_t ret
= EFI_SUCCESS
;
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
;
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
;
395 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
398 memcpy(¶m
.guid
, vendor
, sizeof(param
.guid
));
400 /* variable name, already in UTF-16 */
401 memcpy(gsmi_dev
.name_buf
->start
, name
, *name_size
);
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
));
407 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_GET_NEXT_VAR
);
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 */
415 /* copy variable data back to return buffer */
416 memcpy(¶m
, gsmi_dev
.param_buf
->start
, sizeof(param
));
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;
422 /* copy guid to return buffer */
423 memcpy(vendor
, ¶m
.guid
, sizeof(param
.guid
));
427 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
432 static efi_status_t
gsmi_set_variable(efi_char16_t
*name
,
435 unsigned long data_size
,
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
,
446 size_t name_len
= ucs2_strnlen(name
, GSMI_BUF_SIZE
/ 2);
447 efi_status_t ret
= EFI_SUCCESS
;
451 if (name_len
>= GSMI_BUF_SIZE
/ 2)
452 return EFI_BAD_BUFFER_SIZE
;
454 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
457 memcpy(¶m
.guid
, vendor
, sizeof(param
.guid
));
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);
464 memset(gsmi_dev
.data_buf
->start
, 0, gsmi_dev
.data_buf
->length
);
465 memcpy(gsmi_dev
.data_buf
->start
, data
, data_size
);
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
));
471 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_SET_NVRAM_VAR
);
473 printk(KERN_ERR
"gsmi: Set Variable failed\n");
474 ret
= EFI_INVALID_PARAMETER
;
477 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
482 static 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
,
488 #endif /* CONFIG_EFI */
490 static 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
)
494 struct gsmi_set_eventlog_param param
= {
495 .data_ptr
= gsmi_dev
.data_buf
->address
,
500 /* Pull the type out */
501 if (count
< sizeof(u32
))
503 param
.type
= *(u32
*)buf
;
506 /* The remaining buffer is the data payload */
507 if ((count
- sizeof(u32
)) > gsmi_dev
.data_buf
->length
)
509 param
.data_len
= count
- sizeof(u32
);
511 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
514 memset(gsmi_dev
.data_buf
->start
, 0, gsmi_dev
.data_buf
->length
);
515 memcpy(gsmi_dev
.data_buf
->start
, buf
, param
.data_len
);
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
));
521 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_SET_EVENT_LOG
);
523 printk(KERN_ERR
"gsmi: Set Event Log failed\n");
525 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
527 return (rc
== 0) ? count
: rc
;
531 static struct bin_attribute eventlog_bin_attr
= {
532 .attr
= {.name
= "append_to_eventlog", .mode
= 0200},
533 .write
= eventlog_write
,
536 static ssize_t
gsmi_clear_eventlog_store(struct kobject
*kobj
,
537 struct kobj_attribute
*attr
,
538 const char *buf
, size_t count
)
548 rc
= kstrtoul(buf
, 0, &val
);
553 * Value entered is a percentage, 0 through 100, anything else
559 /* data_type here selects the smbios event log. */
560 param
.percentage
= val
;
563 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
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
));
569 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_CLEAR_EVENT_LOG
);
571 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
578 static struct kobj_attribute gsmi_clear_eventlog_attr
= {
579 .attr
= {.name
= "clear_eventlog", .mode
= 0200},
580 .store
= gsmi_clear_eventlog_store
,
583 static ssize_t
gsmi_clear_config_store(struct kobject
*kobj
,
584 struct kobj_attribute
*attr
,
585 const char *buf
, size_t count
)
590 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
592 /* clear parameter buffer */
593 memset(gsmi_dev
.param_buf
->start
, 0, gsmi_dev
.param_buf
->length
);
595 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_CLEAR_CONFIG
);
597 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
604 static struct kobj_attribute gsmi_clear_config_attr
= {
605 .attr
= {.name
= "clear_config", .mode
= 0200},
606 .store
= gsmi_clear_config_store
,
609 static const struct attribute
*gsmi_attrs
[] = {
610 &gsmi_clear_config_attr
.attr
,
611 &gsmi_clear_eventlog_attr
.attr
,
615 static int gsmi_shutdown_reason(int reason
)
617 struct gsmi_log_entry_type_1 entry
= {
618 .type
= GSMI_LOG_ENTRY_TYPE_KERNEL
,
621 struct gsmi_set_eventlog_param param
= {
622 .data_len
= sizeof(entry
),
625 static int saved_reason
;
629 /* avoid duplicate entries in the log */
630 if (saved_reason
& (1 << reason
))
633 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
635 saved_reason
|= (1 << reason
);
638 memset(gsmi_dev
.data_buf
->start
, 0, gsmi_dev
.data_buf
->length
);
639 memcpy(gsmi_dev
.data_buf
->start
, &entry
, sizeof(entry
));
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
));
646 rc
= gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_SET_EVENT_LOG
);
648 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
651 printk(KERN_ERR
"gsmi: Log Shutdown Reason failed\n");
653 printk(KERN_EMERG
"gsmi: Log Shutdown Reason 0x%02x\n",
659 static int gsmi_reboot_callback(struct notifier_block
*nb
,
660 unsigned long reason
, void *arg
)
662 gsmi_shutdown_reason(GSMI_SHUTDOWN_CLEAN
);
666 static struct notifier_block gsmi_reboot_notifier
= {
667 .notifier_call
= gsmi_reboot_callback
670 static int gsmi_die_callback(struct notifier_block
*nb
,
671 unsigned long reason
, void *arg
)
673 if (reason
== DIE_OOPS
)
674 gsmi_shutdown_reason(GSMI_SHUTDOWN_OOPS
);
678 static struct notifier_block gsmi_die_notifier
= {
679 .notifier_call
= gsmi_die_callback
682 static int gsmi_panic_callback(struct notifier_block
*nb
,
683 unsigned long reason
, void *arg
)
687 * Panic callbacks are executed with all other CPUs stopped,
688 * so we must not attempt to spin waiting for gsmi_dev.lock
691 if (spin_is_locked(&gsmi_dev
.lock
))
694 gsmi_shutdown_reason(GSMI_SHUTDOWN_PANIC
);
698 static struct notifier_block gsmi_panic_notifier
= {
699 .notifier_call
= gsmi_panic_callback
,
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 a
705 * quirk within this driver.
707 * Please do not remove this copy of the function as any changes to the
708 * global utility hash_64() function would break this driver's ability
709 * to identify a board and provide the appropriate quirk -- mikew@google.com
711 static u64 __init
local_hash_64(u64 val
, unsigned bits
)
715 /* Sigh, gcc can't optimise this alone like it does for 32 bits. */
730 /* High bits are more random, so use them. */
731 return hash
>> (64 - bits
);
734 static u32 __init
hash_oem_table_id(char s
[8])
737 memcpy(&input
, s
, 8);
738 return local_hash_64(input
, 32);
741 static const struct dmi_system_id gsmi_dmi_table
[] __initconst
= {
743 .ident
= "Google Board",
745 DMI_MATCH(DMI_BOARD_VENDOR
, "Google, Inc."),
749 .ident
= "Coreboot Firmware",
751 DMI_MATCH(DMI_BIOS_VENDOR
, "coreboot"),
756 MODULE_DEVICE_TABLE(dmi
, gsmi_dmi_table
);
758 static __init
int gsmi_system_valid(void)
763 if (!dmi_check_system(gsmi_dmi_table
))
767 * Only newer firmware supports the gsmi interface. All older
768 * firmware that didn't support this interface used to plug the
769 * 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 the
771 * discriminant factor. We have to do this in order to
772 * whitewash our board names out of the public driver.
774 if (!strncmp(acpi_gbl_FADT
.header
.oem_table_id
, "FACP", 4)) {
775 printk(KERN_INFO
"gsmi: Board is too old\n");
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",
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");
796 /* Test the smihandler with a bogus command. If it leaves the
797 * calling argument in %ax untouched, there is no handler for
800 cmd
= GSMI_CALLBACK
| GSMI_CMD_RESERVED
<< 8;
802 "outb %%al, %%dx\n\t"
805 "d" (acpi_gbl_FADT
.smi_command
)
809 pr_info("gsmi: no gsmi handler in firmware\n");
817 static struct kobject
*gsmi_kobj
;
819 static const struct platform_device_info gsmi_dev_info
= {
822 /* SMI callbacks require 32bit addresses */
823 .dma_mask
= DMA_BIT_MASK(32),
827 static void gsmi_log_s0ix_info(u8 cmd
)
832 * If platform has not enabled S0ix logging, then no action is
835 if (!s0ix_logging_enable
)
838 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
840 memset(gsmi_dev
.param_buf
->start
, 0, gsmi_dev
.param_buf
->length
);
842 gsmi_exec(GSMI_CALLBACK
, cmd
);
844 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
847 static int gsmi_log_s0ix_suspend(struct device
*dev
)
850 * If system is not suspending via firmware using the standard ACPI Sx
851 * types, then make a GSMI call to log the suspend info.
853 if (!pm_suspend_via_firmware())
854 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_SUSPEND
);
857 * Always return success, since we do not want suspend
858 * to fail just because of logging failure.
863 static int gsmi_log_s0ix_resume(struct device
*dev
)
866 * If system did not resume via firmware, then make a GSMI call to log
867 * the resume info and wake source.
869 if (!pm_resume_via_firmware())
870 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_RESUME
);
873 * Always return success, since we do not want resume
874 * to fail just because of logging failure.
879 static const struct dev_pm_ops gsmi_pm_ops
= {
880 .suspend_noirq
= gsmi_log_s0ix_suspend
,
881 .resume_noirq
= gsmi_log_s0ix_resume
,
884 static int gsmi_platform_driver_probe(struct platform_device
*dev
)
889 static struct platform_driver gsmi_driver_info
= {
894 .probe
= gsmi_platform_driver_probe
,
898 static __init
int gsmi_init(void)
903 ret
= gsmi_system_valid();
907 gsmi_dev
.smi_cmd
= acpi_gbl_FADT
.smi_command
;
910 ret
= platform_driver_register(&gsmi_driver_info
);
912 printk(KERN_ERR
"gsmi: unable to register platform driver\n");
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 ret
= PTR_ERR(gsmi_dev
.pdev
);
925 /* SMI access needs to be serialized */
926 spin_lock_init(&gsmi_dev
.lock
);
931 * SLAB cache is created using SLAB_CACHE_DMA32 to ensure that the
932 * allocations for gsmi_buf come from the DMA32 memory zone. These
933 * buffers have nothing to do with DMA. They are required for
934 * communication with firmware executing in SMI mode which can only
935 * access the bottom 4GiB of physical memory. Since DMA32 memory zone
936 * guarantees allocation under the 4GiB boundary, this driver creates
937 * a SLAB cache with SLAB_CACHE_DMA32 flag.
939 gsmi_dev
.mem_pool
= kmem_cache_create("gsmi", GSMI_BUF_SIZE
,
941 SLAB_CACHE_DMA32
, NULL
);
942 if (!gsmi_dev
.mem_pool
)
946 * pre-allocate buffers because sometimes we are called when
947 * this is not feasible: oops, panic, die, mce, etc
949 gsmi_dev
.name_buf
= gsmi_buf_alloc();
950 if (!gsmi_dev
.name_buf
) {
951 printk(KERN_ERR
"gsmi: failed to allocate name buffer\n");
955 gsmi_dev
.data_buf
= gsmi_buf_alloc();
956 if (!gsmi_dev
.data_buf
) {
957 printk(KERN_ERR
"gsmi: failed to allocate data buffer\n");
961 gsmi_dev
.param_buf
= gsmi_buf_alloc();
962 if (!gsmi_dev
.param_buf
) {
963 printk(KERN_ERR
"gsmi: failed to allocate param buffer\n");
968 * Determine type of handshake used to serialize the SMI
969 * entry. See also gsmi_exec().
971 * There's a "behavior" present on some chipsets where writing the
972 * SMI trigger register in the southbridge doesn't result in an
973 * immediate SMI. Rather, the processor can execute "a few" more
974 * instructions before the SMI takes effect. To ensure synchronous
975 * behavior, implement a handshake between the kernel driver and the
976 * firmware handler to spin until released. This ioctl determines
977 * the type of handshake.
979 * NONE: The firmware handler does not implement any
980 * handshake. Either it doesn't need to, or it's legacy firmware
981 * that doesn't know it needs to and never will.
983 * CF: The firmware handler will clear the CF in the saved
984 * state before returning. The driver may set the CF and test for
985 * it to clear before proceeding.
987 * SPIN: The firmware handler does not implement any handshake
988 * but the driver should spin for a hundred or so microseconds
989 * to ensure the SMI has triggered.
991 * Finally, the handler will return -ENOSYS if
992 * GSMI_CMD_HANDSHAKE_TYPE is unimplemented, which implies
995 spin_lock_irqsave(&gsmi_dev
.lock
, flags
);
996 gsmi_dev
.handshake_type
= GSMI_HANDSHAKE_SPIN
;
997 gsmi_dev
.handshake_type
=
998 gsmi_exec(GSMI_CALLBACK
, GSMI_CMD_HANDSHAKE_TYPE
);
999 if (gsmi_dev
.handshake_type
== -ENOSYS
)
1000 gsmi_dev
.handshake_type
= GSMI_HANDSHAKE_NONE
;
1001 spin_unlock_irqrestore(&gsmi_dev
.lock
, flags
);
1003 /* Remove and clean up gsmi if the handshake could not complete. */
1004 if (gsmi_dev
.handshake_type
== -ENXIO
) {
1005 printk(KERN_INFO
"gsmi version " DRIVER_VERSION
1006 " failed to load\n");
1011 /* Register in the firmware directory */
1013 gsmi_kobj
= kobject_create_and_add("gsmi", firmware_kobj
);
1015 printk(KERN_INFO
"gsmi: Failed to create firmware kobj\n");
1019 /* Setup eventlog access */
1020 ret
= sysfs_create_bin_file(gsmi_kobj
, &eventlog_bin_attr
);
1022 printk(KERN_INFO
"gsmi: Failed to setup eventlog");
1026 /* Other attributes */
1027 ret
= sysfs_create_files(gsmi_kobj
, gsmi_attrs
);
1029 printk(KERN_INFO
"gsmi: Failed to add attrs");
1030 goto out_remove_bin_file
;
1034 ret
= efivars_register(&efivars
, &efivar_ops
);
1036 printk(KERN_INFO
"gsmi: Failed to register efivars\n");
1037 sysfs_remove_files(gsmi_kobj
, gsmi_attrs
);
1038 goto out_remove_bin_file
;
1042 register_reboot_notifier(&gsmi_reboot_notifier
);
1043 register_die_notifier(&gsmi_die_notifier
);
1044 atomic_notifier_chain_register(&panic_notifier_list
,
1045 &gsmi_panic_notifier
);
1047 printk(KERN_INFO
"gsmi version " DRIVER_VERSION
" loaded\n");
1051 out_remove_bin_file
:
1052 sysfs_remove_bin_file(gsmi_kobj
, &eventlog_bin_attr
);
1054 kobject_put(gsmi_kobj
);
1055 gsmi_buf_free(gsmi_dev
.param_buf
);
1056 gsmi_buf_free(gsmi_dev
.data_buf
);
1057 gsmi_buf_free(gsmi_dev
.name_buf
);
1058 kmem_cache_destroy(gsmi_dev
.mem_pool
);
1059 platform_device_unregister(gsmi_dev
.pdev
);
1062 platform_driver_unregister(&gsmi_driver_info
);
1064 pr_info("gsmi: failed to load: %d\n", ret
);
1068 static void __exit
gsmi_exit(void)
1070 unregister_reboot_notifier(&gsmi_reboot_notifier
);
1071 unregister_die_notifier(&gsmi_die_notifier
);
1072 atomic_notifier_chain_unregister(&panic_notifier_list
,
1073 &gsmi_panic_notifier
);
1075 efivars_unregister(&efivars
);
1078 sysfs_remove_files(gsmi_kobj
, gsmi_attrs
);
1079 sysfs_remove_bin_file(gsmi_kobj
, &eventlog_bin_attr
);
1080 kobject_put(gsmi_kobj
);
1081 gsmi_buf_free(gsmi_dev
.param_buf
);
1082 gsmi_buf_free(gsmi_dev
.data_buf
);
1083 gsmi_buf_free(gsmi_dev
.name_buf
);
1084 kmem_cache_destroy(gsmi_dev
.mem_pool
);
1085 platform_device_unregister(gsmi_dev
.pdev
);
1087 platform_driver_unregister(&gsmi_driver_info
);
1091 module_init(gsmi_init
);
1092 module_exit(gsmi_exit
);
1094 MODULE_AUTHOR("Google, Inc.");
1095 MODULE_DESCRIPTION("EFI SMI interface for Google platforms");
1096 MODULE_LICENSE("GPL");