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