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