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