drivers/firmware/google/gsmi.c

   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(&param.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, &param, 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(&param, gsmi_dev.param_buf->start, sizeof(param));
 346
 347                 /* The size reported is the min of all of our buffers */
 348                 *data_size = min_t(unsigned long, *data_size,
 349                                                 gsmi_dev.data_buf->length);
 350                 *data_size = min_t(unsigned long, *data_size, param.data_len);
 351
 352                 /* Copy data back to return buffer. */
 353                 memcpy(data, gsmi_dev.data_buf->start, *data_size);
 354
 355                 /* All variables are have the following attributes */
 356                 *attr = EFI_VARIABLE_NON_VOLATILE |
 357                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
 358                         EFI_VARIABLE_RUNTIME_ACCESS;
 359         }
 360
 361         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 362
 363         return ret;
 364 }
 365
 366 static efi_status_t gsmi_get_next_variable(unsigned long *name_size,
 367                                            efi_char16_t *name,
 368                                            efi_guid_t *vendor)
 369 {
 370         struct gsmi_get_next_var_param param = {
 371                 .name_ptr = gsmi_dev.name_buf->address,
 372                 .name_len = gsmi_dev.name_buf->length,
 373         };
 374         efi_status_t ret = EFI_SUCCESS;
 375         int rc;
 376         unsigned long flags;
 377
 378         /* For the moment, only support buffers that exactly match in size */
 379         if (*name_size != GSMI_BUF_SIZE)
 380                 return EFI_BAD_BUFFER_SIZE;
 381
 382         /* Let's make sure the thing is at least null-terminated */
 383         if (utf16_strlen(name, GSMI_BUF_SIZE / 2) == GSMI_BUF_SIZE / 2)
 384                 return EFI_INVALID_PARAMETER;
 385
 386         spin_lock_irqsave(&gsmi_dev.lock, flags);
 387
 388         /* guid */
 389         memcpy(&param.guid, vendor, sizeof(param.guid));
 390
 391         /* variable name, already in UTF-16 */
 392         memcpy(gsmi_dev.name_buf->start, name, *name_size);
 393
 394         /* parameter buffer */
 395         memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
 396         memcpy(gsmi_dev.param_buf->start, &param, sizeof(param));
 397
 398         rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NEXT_VAR);
 399         if (rc < 0) {
 400                 printk(KERN_ERR "gsmi: Get Next Variable Name failed\n");
 401                 ret = EFI_LOAD_ERROR;
 402         } else if (rc == 1) {
 403                 /* variable not found -- end of list */
 404                 ret = EFI_NOT_FOUND;
 405         } else {
 406                 /* copy variable data back to return buffer */
 407                 memcpy(&param, gsmi_dev.param_buf->start, sizeof(param));
 408
 409                 /* Copy the name back */
 410                 memcpy(name, gsmi_dev.name_buf->start, GSMI_BUF_SIZE);
 411                 *name_size = utf16_strlen(name, GSMI_BUF_SIZE / 2) * 2;
 412
 413                 /* copy guid to return buffer */
 414                 memcpy(vendor, &param.guid, sizeof(param.guid));
 415                 ret = EFI_SUCCESS;
 416         }
 417
 418         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 419
 420         return ret;
 421 }
 422
 423 static efi_status_t gsmi_set_variable(efi_char16_t *name,
 424                                       efi_guid_t *vendor,
 425                                       u32 attr,
 426                                       unsigned long data_size,
 427                                       void *data)
 428 {
 429         struct gsmi_nvram_var_param param = {
 430                 .name_ptr = gsmi_dev.name_buf->address,
 431                 .data_ptr = gsmi_dev.data_buf->address,
 432                 .data_len = (u32)data_size,
 433                 .attributes = EFI_VARIABLE_NON_VOLATILE |
 434                               EFI_VARIABLE_BOOTSERVICE_ACCESS |
 435                               EFI_VARIABLE_RUNTIME_ACCESS,
 436         };
 437         size_t name_len = utf16_strlen(name, GSMI_BUF_SIZE / 2);
 438         efi_status_t ret = EFI_SUCCESS;
 439         int rc;
 440         unsigned long flags;
 441
 442         if (name_len >= GSMI_BUF_SIZE / 2)
 443                 return EFI_BAD_BUFFER_SIZE;
 444
 445         spin_lock_irqsave(&gsmi_dev.lock, flags);
 446
 447         /* guid */
 448         memcpy(&param.guid, vendor, sizeof(param.guid));
 449
 450         /* variable name, already in UTF-16 */
 451         memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length);
 452         memcpy(gsmi_dev.name_buf->start, name, name_len * 2);
 453
 454         /* data pointer */
 455         memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
 456         memcpy(gsmi_dev.data_buf->start, data, data_size);
 457
 458         /* parameter buffer */
 459         memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
 460         memcpy(gsmi_dev.param_buf->start, &param, sizeof(param));
 461
 462         rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_NVRAM_VAR);
 463         if (rc < 0) {
 464                 printk(KERN_ERR "gsmi: Set Variable failed\n");
 465                 ret = EFI_INVALID_PARAMETER;
 466         }
 467
 468         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 469
 470         return ret;
 471 }
 472
 473 static const struct efivar_operations efivar_ops = {
 474         .get_variable = gsmi_get_variable,
 475         .set_variable = gsmi_set_variable,
 476         .get_next_variable = gsmi_get_next_variable,
 477 };
 478
 479 static ssize_t eventlog_write(struct file *filp, struct kobject *kobj,
 480                                struct bin_attribute *bin_attr,
 481                                char *buf, loff_t pos, size_t count)
 482 {
 483         struct gsmi_set_eventlog_param param = {
 484                 .data_ptr = gsmi_dev.data_buf->address,
 485         };
 486         int rc = 0;
 487         unsigned long flags;
 488
 489         /* Pull the type out */
 490         if (count < sizeof(u32))
 491                 return -EINVAL;
 492         param.type = *(u32 *)buf;
 493         count -= sizeof(u32);
 494         buf += sizeof(u32);
 495
 496         /* The remaining buffer is the data payload */
 497         if (count > gsmi_dev.data_buf->length)
 498                 return -EINVAL;
 499         param.data_len = count - sizeof(u32);
 500
 501         spin_lock_irqsave(&gsmi_dev.lock, flags);
 502
 503         /* data pointer */
 504         memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
 505         memcpy(gsmi_dev.data_buf->start, buf, param.data_len);
 506
 507         /* parameter buffer */
 508         memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
 509         memcpy(gsmi_dev.param_buf->start, &param, sizeof(param));
 510
 511         rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);
 512         if (rc < 0)
 513                 printk(KERN_ERR "gsmi: Set Event Log failed\n");
 514
 515         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 516
 517         return rc;
 518
 519 }
 520
 521 static struct bin_attribute eventlog_bin_attr = {
 522         .attr = {.name = "append_to_eventlog", .mode = 0200},
 523         .write = eventlog_write,
 524 };
 525
 526 static ssize_t gsmi_clear_eventlog_store(struct kobject *kobj,
 527                                          struct kobj_attribute *attr,
 528                                          const char *buf, size_t count)
 529 {
 530         int rc;
 531         unsigned long flags;
 532         unsigned long val;
 533         struct {
 534                 u32 percentage;
 535                 u32 data_type;
 536         } param;
 537
 538         rc = strict_strtoul(buf, 0, &val);
 539         if (rc)
 540                 return rc;
 541
 542         /*
 543          * Value entered is a percentage, 0 through 100, anything else
 544          * is invalid.
 545          */
 546         if (val > 100)
 547                 return -EINVAL;
 548
 549         /* data_type here selects the smbios event log. */
 550         param.percentage = val;
 551         param.data_type = 0;
 552
 553         spin_lock_irqsave(&gsmi_dev.lock, flags);
 554
 555         /* parameter buffer */
 556         memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
 557         memcpy(gsmi_dev.param_buf->start, &param, sizeof(param));
 558
 559         rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_EVENT_LOG);
 560
 561         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 562
 563         if (rc)
 564                 return rc;
 565         return count;
 566 }
 567
 568 static struct kobj_attribute gsmi_clear_eventlog_attr = {
 569         .attr = {.name = "clear_eventlog", .mode = 0200},
 570         .store = gsmi_clear_eventlog_store,
 571 };
 572
 573 static ssize_t gsmi_clear_config_store(struct kobject *kobj,
 574                                        struct kobj_attribute *attr,
 575                                        const char *buf, size_t count)
 576 {
 577         int rc;
 578         unsigned long flags;
 579
 580         spin_lock_irqsave(&gsmi_dev.lock, flags);
 581
 582         /* clear parameter buffer */
 583         memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
 584
 585         rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_CONFIG);
 586
 587         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 588
 589         if (rc)
 590                 return rc;
 591         return count;
 592 }
 593
 594 static struct kobj_attribute gsmi_clear_config_attr = {
 595         .attr = {.name = "clear_config", .mode = 0200},
 596         .store = gsmi_clear_config_store,
 597 };
 598
 599 static const struct attribute *gsmi_attrs[] = {
 600         &gsmi_clear_config_attr.attr,
 601         &gsmi_clear_eventlog_attr.attr,
 602         NULL,
 603 };
 604
 605 static int gsmi_shutdown_reason(int reason)
 606 {
 607         struct gsmi_log_entry_type_1 entry = {
 608                 .type     = GSMI_LOG_ENTRY_TYPE_KERNEL,
 609                 .instance = reason,
 610         };
 611         struct gsmi_set_eventlog_param param = {
 612                 .data_len = sizeof(entry),
 613                 .type     = 1,
 614         };
 615         static int saved_reason;
 616         int rc = 0;
 617         unsigned long flags;
 618
 619         /* avoid duplicate entries in the log */
 620         if (saved_reason & (1 << reason))
 621                 return 0;
 622
 623         spin_lock_irqsave(&gsmi_dev.lock, flags);
 624
 625         saved_reason |= (1 << reason);
 626
 627         /* data pointer */
 628         memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
 629         memcpy(gsmi_dev.data_buf->start, &entry, sizeof(entry));
 630
 631         /* parameter buffer */
 632         param.data_ptr = gsmi_dev.data_buf->address;
 633         memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
 634         memcpy(gsmi_dev.param_buf->start, &param, sizeof(param));
 635
 636         rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);
 637
 638         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 639
 640         if (rc < 0)
 641                 printk(KERN_ERR "gsmi: Log Shutdown Reason failed\n");
 642         else
 643                 printk(KERN_EMERG "gsmi: Log Shutdown Reason 0x%02x\n",
 644                        reason);
 645
 646         return rc;
 647 }
 648
 649 static int gsmi_reboot_callback(struct notifier_block *nb,
 650                                 unsigned long reason, void *arg)
 651 {
 652         gsmi_shutdown_reason(GSMI_SHUTDOWN_CLEAN);
 653         return NOTIFY_DONE;
 654 }
 655
 656 static struct notifier_block gsmi_reboot_notifier = {
 657         .notifier_call = gsmi_reboot_callback
 658 };
 659
 660 static int gsmi_die_callback(struct notifier_block *nb,
 661                              unsigned long reason, void *arg)
 662 {
 663         if (reason == DIE_OOPS)
 664                 gsmi_shutdown_reason(GSMI_SHUTDOWN_OOPS);
 665         return NOTIFY_DONE;
 666 }
 667
 668 static struct notifier_block gsmi_die_notifier = {
 669         .notifier_call = gsmi_die_callback
 670 };
 671
 672 static int gsmi_panic_callback(struct notifier_block *nb,
 673                                unsigned long reason, void *arg)
 674 {
 675         gsmi_shutdown_reason(GSMI_SHUTDOWN_PANIC);
 676         return NOTIFY_DONE;
 677 }
 678
 679 static struct notifier_block gsmi_panic_notifier = {
 680         .notifier_call = gsmi_panic_callback,
 681 };
 682
 683 /*
 684  * This hash function was blatantly copied from include/linux/hash.h.
 685  * It is used by this driver to obfuscate a board name that requires a
 686  * quirk within this driver.
 687  *
 688  * Please do not remove this copy of the function as any changes to the
 689  * global utility hash_64() function would break this driver's ability
 690  * to identify a board and provide the appropriate quirk -- mikew@google.com
 691  */
 692 static u64 __init local_hash_64(u64 val, unsigned bits)
 693 {
 694         u64 hash = val;
 695
 696         /*  Sigh, gcc can't optimise this alone like it does for 32 bits. */
 697         u64 n = hash;
 698         n <<= 18;
 699         hash -= n;
 700         n <<= 33;
 701         hash -= n;
 702         n <<= 3;
 703         hash += n;
 704         n <<= 3;
 705         hash -= n;
 706         n <<= 4;
 707         hash += n;
 708         n <<= 2;
 709         hash += n;
 710
 711         /* High bits are more random, so use them. */
 712         return hash >> (64 - bits);
 713 }
 714
 715 static u32 __init hash_oem_table_id(char s[8])
 716 {
 717         u64 input;
 718         memcpy(&input, s, 8);
 719         return local_hash_64(input, 32);
 720 }
 721
 722 static struct dmi_system_id gsmi_dmi_table[] __initdata = {
 723         {
 724                 .ident = "Google Board",
 725                 .matches = {
 726                         DMI_MATCH(DMI_BOARD_VENDOR, "Google, Inc."),
 727                 },
 728         },
 729         {}
 730 };
 731 MODULE_DEVICE_TABLE(dmi, gsmi_dmi_table);
 732
 733 static __init int gsmi_system_valid(void)
 734 {
 735         u32 hash;
 736
 737         if (!dmi_check_system(gsmi_dmi_table))
 738                 return -ENODEV;
 739
 740         /*
 741          * Only newer firmware supports the gsmi interface.  All older
 742          * firmware that didn't support this interface used to plug the
 743          * table name in the first four bytes of the oem_table_id field.
 744          * Newer firmware doesn't do that though, so use that as the
 745          * discriminant factor.  We have to do this in order to
 746          * whitewash our board names out of the public driver.
 747          */
 748         if (!strncmp(acpi_gbl_FADT.header.oem_table_id, "FACP", 4)) {
 749                 printk(KERN_INFO "gsmi: Board is too old\n");
 750                 return -ENODEV;
 751         }
 752
 753         /* Disable on board with 1.0 BIOS due to Google bug 2602657 */
 754         hash = hash_oem_table_id(acpi_gbl_FADT.header.oem_table_id);
 755         if (hash == QUIRKY_BOARD_HASH) {
 756                 const char *bios_ver = dmi_get_system_info(DMI_BIOS_VERSION);
 757                 if (strncmp(bios_ver, "1.0", 3) == 0) {
 758                         pr_info("gsmi: disabled on this board's BIOS %s\n",
 759                                 bios_ver);
 760                         return -ENODEV;
 761                 }
 762         }
 763
 764         /* check for valid SMI command port in ACPI FADT */
 765         if (acpi_gbl_FADT.smi_command == 0) {
 766                 pr_info("gsmi: missing smi_command\n");
 767                 return -ENODEV;
 768         }
 769
 770         /* Found */
 771         return 0;
 772 }
 773
 774 static struct kobject *gsmi_kobj;
 775 static struct efivars efivars;
 776
 777 static __init int gsmi_init(void)
 778 {
 779         unsigned long flags;
 780         int ret;
 781
 782         ret = gsmi_system_valid();
 783         if (ret)
 784                 return ret;
 785
 786         gsmi_dev.smi_cmd = acpi_gbl_FADT.smi_command;
 787
 788         /* register device */
 789         gsmi_dev.pdev = platform_device_register_simple("gsmi", -1, NULL, 0);
 790         if (IS_ERR(gsmi_dev.pdev)) {
 791                 printk(KERN_ERR "gsmi: unable to register platform device\n");
 792                 return PTR_ERR(gsmi_dev.pdev);
 793         }
 794
 795         /* SMI access needs to be serialized */
 796         spin_lock_init(&gsmi_dev.lock);
 797
 798         /* SMI callbacks require 32bit addresses */
 799         gsmi_dev.pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 800         gsmi_dev.pdev->dev.dma_mask =
 801                 &gsmi_dev.pdev->dev.coherent_dma_mask;
 802         ret = -ENOMEM;
 803         gsmi_dev.dma_pool = dma_pool_create("gsmi", &gsmi_dev.pdev->dev,
 804                                              GSMI_BUF_SIZE, GSMI_BUF_ALIGN, 0);
 805         if (!gsmi_dev.dma_pool)
 806                 goto out_err;
 807
 808         /*
 809          * pre-allocate buffers because sometimes we are called when
 810          * this is not feasible: oops, panic, die, mce, etc
 811          */
 812         gsmi_dev.name_buf = gsmi_buf_alloc();
 813         if (!gsmi_dev.name_buf) {
 814                 printk(KERN_ERR "gsmi: failed to allocate name buffer\n");
 815                 goto out_err;
 816         }
 817
 818         gsmi_dev.data_buf = gsmi_buf_alloc();
 819         if (!gsmi_dev.data_buf) {
 820                 printk(KERN_ERR "gsmi: failed to allocate data buffer\n");
 821                 goto out_err;
 822         }
 823
 824         gsmi_dev.param_buf = gsmi_buf_alloc();
 825         if (!gsmi_dev.param_buf) {
 826                 printk(KERN_ERR "gsmi: failed to allocate param buffer\n");
 827                 goto out_err;
 828         }
 829
 830         /*
 831          * Determine type of handshake used to serialize the SMI
 832          * entry. See also gsmi_exec().
 833          *
 834          * There's a "behavior" present on some chipsets where writing the
 835          * SMI trigger register in the southbridge doesn't result in an
 836          * immediate SMI. Rather, the processor can execute "a few" more
 837          * instructions before the SMI takes effect. To ensure synchronous
 838          * behavior, implement a handshake between the kernel driver and the
 839          * firmware handler to spin until released. This ioctl determines
 840          * the type of handshake.
 841          *
 842          * NONE: The firmware handler does not implement any
 843          * handshake. Either it doesn't need to, or it's legacy firmware
 844          * that doesn't know it needs to and never will.
 845          *
 846          * CF: The firmware handler will clear the CF in the saved
 847          * state before returning. The driver may set the CF and test for
 848          * it to clear before proceeding.
 849          *
 850          * SPIN: The firmware handler does not implement any handshake
 851          * but the driver should spin for a hundred or so microseconds
 852          * to ensure the SMI has triggered.
 853          *
 854          * Finally, the handler will return -ENOSYS if
 855          * GSMI_CMD_HANDSHAKE_TYPE is unimplemented, which implies
 856          * HANDSHAKE_NONE.
 857          */
 858         spin_lock_irqsave(&gsmi_dev.lock, flags);
 859         gsmi_dev.handshake_type = GSMI_HANDSHAKE_SPIN;
 860         gsmi_dev.handshake_type =
 861             gsmi_exec(GSMI_CALLBACK, GSMI_CMD_HANDSHAKE_TYPE);
 862         if (gsmi_dev.handshake_type == -ENOSYS)
 863                 gsmi_dev.handshake_type = GSMI_HANDSHAKE_NONE;
 864         spin_unlock_irqrestore(&gsmi_dev.lock, flags);
 865
 866         /* Remove and clean up gsmi if the handshake could not complete. */
 867         if (gsmi_dev.handshake_type == -ENXIO) {
 868                 printk(KERN_INFO "gsmi version " DRIVER_VERSION
 869                        " failed to load\n");
 870                 ret = -ENODEV;
 871                 goto out_err;
 872         }
 873
 874         /* Register in the firmware directory */
 875         ret = -ENOMEM;
 876         gsmi_kobj = kobject_create_and_add("gsmi", firmware_kobj);
 877         if (!gsmi_kobj) {
 878                 printk(KERN_INFO "gsmi: Failed to create firmware kobj\n");
 879                 goto out_err;
 880         }
 881
 882         /* Setup eventlog access */
 883         ret = sysfs_create_bin_file(gsmi_kobj, &eventlog_bin_attr);
 884         if (ret) {
 885                 printk(KERN_INFO "gsmi: Failed to setup eventlog");
 886                 goto out_err;
 887         }
 888
 889         /* Other attributes */
 890         ret = sysfs_create_files(gsmi_kobj, gsmi_attrs);
 891         if (ret) {
 892                 printk(KERN_INFO "gsmi: Failed to add attrs");
 893                 goto out_remove_bin_file;
 894         }
 895
 896         ret = register_efivars(&efivars, &efivar_ops, gsmi_kobj);
 897         if (ret) {
 898                 printk(KERN_INFO "gsmi: Failed to register efivars\n");
 899                 goto out_remove_sysfs_files;
 900         }
 901
 902         register_reboot_notifier(&gsmi_reboot_notifier);
 903         register_die_notifier(&gsmi_die_notifier);
 904         atomic_notifier_chain_register(&panic_notifier_list,
 905                                        &gsmi_panic_notifier);
 906
 907         printk(KERN_INFO "gsmi version " DRIVER_VERSION " loaded\n");
 908
 909         return 0;
 910
 911 out_remove_sysfs_files:
 912         sysfs_remove_files(gsmi_kobj, gsmi_attrs);
 913 out_remove_bin_file:
 914         sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);
 915 out_err:
 916         kobject_put(gsmi_kobj);
 917         gsmi_buf_free(gsmi_dev.param_buf);
 918         gsmi_buf_free(gsmi_dev.data_buf);
 919         gsmi_buf_free(gsmi_dev.name_buf);
 920         if (gsmi_dev.dma_pool)
 921                 dma_pool_destroy(gsmi_dev.dma_pool);
 922         platform_device_unregister(gsmi_dev.pdev);
 923         pr_info("gsmi: failed to load: %d\n", ret);
 924         return ret;
 925 }
 926
 927 static void __exit gsmi_exit(void)
 928 {
 929         unregister_reboot_notifier(&gsmi_reboot_notifier);
 930         unregister_die_notifier(&gsmi_die_notifier);
 931         atomic_notifier_chain_unregister(&panic_notifier_list,
 932                                          &gsmi_panic_notifier);
 933         unregister_efivars(&efivars);
 934
 935         sysfs_remove_files(gsmi_kobj, gsmi_attrs);
 936         sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);
 937         kobject_put(gsmi_kobj);
 938         gsmi_buf_free(gsmi_dev.param_buf);
 939         gsmi_buf_free(gsmi_dev.data_buf);
 940         gsmi_buf_free(gsmi_dev.name_buf);
 941         dma_pool_destroy(gsmi_dev.dma_pool);
 942         platform_device_unregister(gsmi_dev.pdev);
 943 }
 944
 945 module_init(gsmi_init);
 946 module_exit(gsmi_exit);
 947
 948 MODULE_AUTHOR("Google, Inc.");
 949 MODULE_LICENSE("GPL");