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 
gsmi_buf_alloc(void)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 
gsmi_buf_free(struct gsmi_buf * smibuf)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  */
gsmi_exec(u8 func,u8 sub)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 
gsmi_get_variable(efi_char16_t * name,efi_guid_t * vendor,u32 * attr,unsigned long * data_size,void * data)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(&param.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, &param, 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(&param, 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 
gsmi_get_next_variable(unsigned long * name_size,efi_char16_t * name,efi_guid_t * vendor)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(&param.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, &param, 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(&param, 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, &param.guid, sizeof(param.guid));
423 		ret = EFI_SUCCESS;
424 	}
425 
426 	spin_unlock_irqrestore(&gsmi_dev.lock, flags);
427 
428 	return ret;
429 }
430 
gsmi_set_variable(efi_char16_t * name,efi_guid_t * vendor,u32 attr,unsigned long data_size,void * data)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(&param.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, &param, 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 
eventlog_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t pos,size_t count)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, &param, 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 
gsmi_clear_eventlog_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)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, &param, 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 
gsmi_clear_config_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)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 
gsmi_shutdown_reason(int reason)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, &param, 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 
gsmi_reboot_callback(struct notifier_block * nb,unsigned long reason,void * arg)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 
gsmi_die_callback(struct notifier_block * nb,unsigned long reason,void * arg)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 
gsmi_panic_callback(struct notifier_block * nb,unsigned long reason,void * arg)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  */
local_hash_64(u64 val,unsigned bits)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 
hash_oem_table_id(char s[8])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 
gsmi_system_valid(void)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
gsmi_log_s0ix_info(u8 cmd)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 
gsmi_log_s0ix_suspend(struct device * dev)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 
gsmi_log_s0ix_resume(struct device * dev)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 
gsmi_platform_driver_probe(struct platform_device * dev)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 
gsmi_init(void)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 
gsmi_exit(void)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