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