drivers/firmware/google/gsmi.c

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