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