drivers/char/tpm/tpm_ppi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012-2014 Intel Corporation
   4  *
   5  * Authors:
   6  * Xiaoyan Zhang <xiaoyan.zhang@intel.com>
   7  * Jiang Liu <jiang.liu@linux.intel.com>
   8  * Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
   9  *
  10  * Maintained by: <tpmdd-devel@lists.sourceforge.net>
  11  *
  12  * This file contains implementation of the sysfs interface for PPI.
  13  */
  14
  15
  16 #include <linux/acpi.h>
  17 #include "tpm.h"
  18
  19 #define TPM_PPI_REVISION_ID_1   1
  20 #define TPM_PPI_REVISION_ID_2   2
  21 #define TPM_PPI_FN_VERSION      1
  22 #define TPM_PPI_FN_SUBREQ       2
  23 #define TPM_PPI_FN_GETREQ       3
  24 #define TPM_PPI_FN_GETACT       4
  25 #define TPM_PPI_FN_GETRSP       5
  26 #define TPM_PPI_FN_SUBREQ2      7
  27 #define TPM_PPI_FN_GETOPR       8
  28 #define PPI_TPM_REQ_MAX         101 /* PPI 1.3 for TPM 2 */
  29 #define PPI_VS_REQ_START        128
  30 #define PPI_VS_REQ_END          255
  31
  32 static const guid_t tpm_ppi_guid =
  33         GUID_INIT(0x3DDDFAA6, 0x361B, 0x4EB4,
  34                   0xA4, 0x24, 0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53);
  35
  36 static bool tpm_ppi_req_has_parameter(u64 req)
  37 {
  38         return req == 23;
  39 }
  40
  41 static inline union acpi_object *
  42 tpm_eval_dsm(acpi_handle ppi_handle, int func, acpi_object_type type,
  43              union acpi_object *argv4, u64 rev)
  44 {
  45         BUG_ON(!ppi_handle);
  46         return acpi_evaluate_dsm_typed(ppi_handle, &tpm_ppi_guid,
  47                                        rev, func, argv4, type);
  48 }
  49
  50 static ssize_t tpm_show_ppi_version(struct device *dev,
  51                                     struct device_attribute *attr, char *buf)
  52 {
  53         struct tpm_chip *chip = to_tpm_chip(dev);
  54
  55         return scnprintf(buf, PAGE_SIZE, "%s\n", chip->ppi_version);
  56 }
  57
  58 static ssize_t tpm_show_ppi_request(struct device *dev,
  59                                     struct device_attribute *attr, char *buf)
  60 {
  61         ssize_t size = -EINVAL;
  62         union acpi_object *obj;
  63         struct tpm_chip *chip = to_tpm_chip(dev);
  64         u64 rev = TPM_PPI_REVISION_ID_2;
  65         u64 req;
  66
  67         if (strcmp(chip->ppi_version, "1.2") < 0)
  68                 rev = TPM_PPI_REVISION_ID_1;
  69
  70         obj = tpm_eval_dsm(chip->acpi_dev_handle, TPM_PPI_FN_GETREQ,
  71                            ACPI_TYPE_PACKAGE, NULL, rev);
  72         if (!obj)
  73                 return -ENXIO;
  74
  75         /*
  76          * output.pointer should be of package type, including two integers.
  77          * The first is function return code, 0 means success and 1 means
  78          * error. The second is pending TPM operation requested by the OS, 0
  79          * means none and >0 means operation value.
  80          */
  81         if (obj->package.count == 3 &&
  82             obj->package.elements[0].type == ACPI_TYPE_INTEGER &&
  83             obj->package.elements[1].type == ACPI_TYPE_INTEGER &&
  84             obj->package.elements[2].type == ACPI_TYPE_INTEGER) {
  85                 if (obj->package.elements[0].integer.value)
  86                         size = -EFAULT;
  87                 else {
  88                         req = obj->package.elements[1].integer.value;
  89                         if (tpm_ppi_req_has_parameter(req))
  90                                 size = scnprintf(buf, PAGE_SIZE,
  91                                     "%llu %llu\n", req,
  92                                     obj->package.elements[2].integer.value);
  93                         else
  94                                 size = scnprintf(buf, PAGE_SIZE,
  95                                                 "%llu\n", req);
  96                 }
  97         } else if (obj->package.count == 2 &&
  98             obj->package.elements[0].type == ACPI_TYPE_INTEGER &&
  99             obj->package.elements[1].type == ACPI_TYPE_INTEGER) {
 100                 if (obj->package.elements[0].integer.value)
 101                         size = -EFAULT;
 102                 else
 103                         size = scnprintf(buf, PAGE_SIZE, "%llu\n",
 104                                  obj->package.elements[1].integer.value);
 105         }
 106
 107         ACPI_FREE(obj);
 108
 109         return size;
 110 }
 111
 112 static ssize_t tpm_store_ppi_request(struct device *dev,
 113                                      struct device_attribute *attr,
 114                                      const char *buf, size_t count)
 115 {
 116         u32 req;
 117         u64 ret;
 118         int func = TPM_PPI_FN_SUBREQ;
 119         union acpi_object *obj, tmp[2];
 120         union acpi_object argv4 = ACPI_INIT_DSM_ARGV4(2, tmp);
 121         struct tpm_chip *chip = to_tpm_chip(dev);
 122         u64 rev = TPM_PPI_REVISION_ID_1;
 123
 124         /*
 125          * the function to submit TPM operation request to pre-os environment
 126          * is updated with function index from SUBREQ to SUBREQ2 since PPI
 127          * version 1.1
 128          */
 129         if (acpi_check_dsm(chip->acpi_dev_handle, &tpm_ppi_guid,
 130                            TPM_PPI_REVISION_ID_1, 1 << TPM_PPI_FN_SUBREQ2))
 131                 func = TPM_PPI_FN_SUBREQ2;
 132
 133         /*
 134          * PPI spec defines params[3].type as ACPI_TYPE_PACKAGE. Some BIOS
 135          * accept buffer/string/integer type, but some BIOS accept buffer/
 136          * string/package type. For PPI version 1.0 and 1.1, use buffer type
 137          * for compatibility, and use package type since 1.2 according to spec.
 138          */
 139         if (strcmp(chip->ppi_version, "1.3") == 0) {
 140                 if (sscanf(buf, "%llu %llu", &tmp[0].integer.value,
 141                            &tmp[1].integer.value) != 2)
 142                         goto ppi12;
 143                 rev = TPM_PPI_REVISION_ID_2;
 144                 tmp[0].type = ACPI_TYPE_INTEGER;
 145                 tmp[1].type = ACPI_TYPE_INTEGER;
 146         } else if (strcmp(chip->ppi_version, "1.2") < 0) {
 147                 if (sscanf(buf, "%d", &req) != 1)
 148                         return -EINVAL;
 149                 argv4.type = ACPI_TYPE_BUFFER;
 150                 argv4.buffer.length = sizeof(req);
 151                 argv4.buffer.pointer = (u8 *)&req;
 152         } else {
 153 ppi12:
 154                 argv4.package.count = 1;
 155                 tmp[0].type = ACPI_TYPE_INTEGER;
 156                 if (sscanf(buf, "%llu", &tmp[0].integer.value) != 1)
 157                         return -EINVAL;
 158         }
 159
 160         obj = tpm_eval_dsm(chip->acpi_dev_handle, func, ACPI_TYPE_INTEGER,
 161                            &argv4, rev);
 162         if (!obj) {
 163                 return -ENXIO;
 164         } else {
 165                 ret = obj->integer.value;
 166                 ACPI_FREE(obj);
 167         }
 168
 169         if (ret == 0)
 170                 return (acpi_status)count;
 171
 172         return (ret == 1) ? -EPERM : -EFAULT;
 173 }
 174
 175 static ssize_t tpm_show_ppi_transition_action(struct device *dev,
 176                                               struct device_attribute *attr,
 177                                               char *buf)
 178 {
 179         u32 ret;
 180         acpi_status status;
 181         union acpi_object *obj = NULL;
 182         union acpi_object tmp = {
 183                 .buffer.type = ACPI_TYPE_BUFFER,
 184                 .buffer.length = 0,
 185                 .buffer.pointer = NULL
 186         };
 187         struct tpm_chip *chip = to_tpm_chip(dev);
 188
 189         static char *info[] = {
 190                 "None",
 191                 "Shutdown",
 192                 "Reboot",
 193                 "OS Vendor-specific",
 194                 "Error",
 195         };
 196
 197         /*
 198          * PPI spec defines params[3].type as empty package, but some platforms
 199          * (e.g. Capella with PPI 1.0) need integer/string/buffer type, so for
 200          * compatibility, define params[3].type as buffer, if PPI version < 1.2
 201          */
 202         if (strcmp(chip->ppi_version, "1.2") < 0)
 203                 obj = &tmp;
 204         obj = tpm_eval_dsm(chip->acpi_dev_handle, TPM_PPI_FN_GETACT,
 205                            ACPI_TYPE_INTEGER, obj, TPM_PPI_REVISION_ID_1);
 206         if (!obj) {
 207                 return -ENXIO;
 208         } else {
 209                 ret = obj->integer.value;
 210                 ACPI_FREE(obj);
 211         }
 212
 213         if (ret < ARRAY_SIZE(info) - 1)
 214                 status = scnprintf(buf, PAGE_SIZE, "%d: %s\n", ret, info[ret]);
 215         else
 216                 status = scnprintf(buf, PAGE_SIZE, "%d: %s\n", ret,
 217                                    info[ARRAY_SIZE(info)-1]);
 218         return status;
 219 }
 220
 221 static ssize_t tpm_show_ppi_response(struct device *dev,
 222                                      struct device_attribute *attr,
 223                                      char *buf)
 224 {
 225         acpi_status status = -EINVAL;
 226         union acpi_object *obj, *ret_obj;
 227         u64 req, res;
 228         struct tpm_chip *chip = to_tpm_chip(dev);
 229
 230         obj = tpm_eval_dsm(chip->acpi_dev_handle, TPM_PPI_FN_GETRSP,
 231                            ACPI_TYPE_PACKAGE, NULL, TPM_PPI_REVISION_ID_1);
 232         if (!obj)
 233                 return -ENXIO;
 234
 235         /*
 236          * parameter output.pointer should be of package type, including
 237          * 3 integers. The first means function return code, the second means
 238          * most recent TPM operation request, and the last means response to
 239          * the most recent TPM operation request. Only if the first is 0, and
 240          * the second integer is not 0, the response makes sense.
 241          */
 242         ret_obj = obj->package.elements;
 243         if (obj->package.count < 3 ||
 244             ret_obj[0].type != ACPI_TYPE_INTEGER ||
 245             ret_obj[1].type != ACPI_TYPE_INTEGER ||
 246             ret_obj[2].type != ACPI_TYPE_INTEGER)
 247                 goto cleanup;
 248
 249         if (ret_obj[0].integer.value) {
 250                 status = -EFAULT;
 251                 goto cleanup;
 252         }
 253
 254         req = ret_obj[1].integer.value;
 255         res = ret_obj[2].integer.value;
 256         if (req) {
 257                 if (res == 0)
 258                         status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
 259                                            "0: Success");
 260                 else if (res == 0xFFFFFFF0)
 261                         status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
 262                                            "0xFFFFFFF0: User Abort");
 263                 else if (res == 0xFFFFFFF1)
 264                         status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
 265                                            "0xFFFFFFF1: BIOS Failure");
 266                 else if (res >= 1 && res <= 0x00000FFF)
 267                         status = scnprintf(buf, PAGE_SIZE, "%llu %llu: %s\n",
 268                                            req, res, "Corresponding TPM error");
 269                 else
 270                         status = scnprintf(buf, PAGE_SIZE, "%llu %llu: %s\n",
 271                                            req, res, "Error");
 272         } else {
 273                 status = scnprintf(buf, PAGE_SIZE, "%llu: %s\n",
 274                                    req, "No Recent Request");
 275         }
 276
 277 cleanup:
 278         ACPI_FREE(obj);
 279         return status;
 280 }
 281
 282 static ssize_t show_ppi_operations(acpi_handle dev_handle, char *buf, u32 start,
 283                                    u32 end)
 284 {
 285         int i;
 286         u32 ret;
 287         char *str = buf;
 288         union acpi_object *obj, tmp;
 289         union acpi_object argv = ACPI_INIT_DSM_ARGV4(1, &tmp);
 290
 291         static char *info[] = {
 292                 "Not implemented",
 293                 "BIOS only",
 294                 "Blocked for OS by BIOS",
 295                 "User required",
 296                 "User not required",
 297         };
 298
 299         if (!acpi_check_dsm(dev_handle, &tpm_ppi_guid, TPM_PPI_REVISION_ID_1,
 300                             1 << TPM_PPI_FN_GETOPR))
 301                 return -EPERM;
 302
 303         tmp.integer.type = ACPI_TYPE_INTEGER;
 304         for (i = start; i <= end; i++) {
 305                 tmp.integer.value = i;
 306                 obj = tpm_eval_dsm(dev_handle, TPM_PPI_FN_GETOPR,
 307                                    ACPI_TYPE_INTEGER, &argv,
 308                                    TPM_PPI_REVISION_ID_1);
 309                 if (!obj) {
 310                         return -ENOMEM;
 311                 } else {
 312                         ret = obj->integer.value;
 313                         ACPI_FREE(obj);
 314                 }
 315
 316                 if (ret > 0 && ret < ARRAY_SIZE(info))
 317                         str += scnprintf(str, PAGE_SIZE, "%d %d: %s\n",
 318                                          i, ret, info[ret]);
 319         }
 320
 321         return str - buf;
 322 }
 323
 324 static ssize_t tpm_show_ppi_tcg_operations(struct device *dev,
 325                                            struct device_attribute *attr,
 326                                            char *buf)
 327 {
 328         struct tpm_chip *chip = to_tpm_chip(dev);
 329
 330         return show_ppi_operations(chip->acpi_dev_handle, buf, 0,
 331                                    PPI_TPM_REQ_MAX);
 332 }
 333
 334 static ssize_t tpm_show_ppi_vs_operations(struct device *dev,
 335                                           struct device_attribute *attr,
 336                                           char *buf)
 337 {
 338         struct tpm_chip *chip = to_tpm_chip(dev);
 339
 340         return show_ppi_operations(chip->acpi_dev_handle, buf, PPI_VS_REQ_START,
 341                                    PPI_VS_REQ_END);
 342 }
 343
 344 static DEVICE_ATTR(version, S_IRUGO, tpm_show_ppi_version, NULL);
 345 static DEVICE_ATTR(request, S_IRUGO | S_IWUSR | S_IWGRP,
 346                    tpm_show_ppi_request, tpm_store_ppi_request);
 347 static DEVICE_ATTR(transition_action, S_IRUGO,
 348                    tpm_show_ppi_transition_action, NULL);
 349 static DEVICE_ATTR(response, S_IRUGO, tpm_show_ppi_response, NULL);
 350 static DEVICE_ATTR(tcg_operations, S_IRUGO, tpm_show_ppi_tcg_operations, NULL);
 351 static DEVICE_ATTR(vs_operations, S_IRUGO, tpm_show_ppi_vs_operations, NULL);
 352
 353 static struct attribute *ppi_attrs[] = {
 354         &dev_attr_version.attr,
 355         &dev_attr_request.attr,
 356         &dev_attr_transition_action.attr,
 357         &dev_attr_response.attr,
 358         &dev_attr_tcg_operations.attr,
 359         &dev_attr_vs_operations.attr, NULL,
 360 };
 361 static struct attribute_group ppi_attr_grp = {
 362         .name = "ppi",
 363         .attrs = ppi_attrs
 364 };
 365
 366 void tpm_add_ppi(struct tpm_chip *chip)
 367 {
 368         union acpi_object *obj;
 369
 370         if (!chip->acpi_dev_handle)
 371                 return;
 372
 373         if (!acpi_check_dsm(chip->acpi_dev_handle, &tpm_ppi_guid,
 374                             TPM_PPI_REVISION_ID_1, 1 << TPM_PPI_FN_VERSION))
 375                 return;
 376
 377         /* Cache PPI version string. */
 378         obj = acpi_evaluate_dsm_typed(chip->acpi_dev_handle, &tpm_ppi_guid,
 379                                       TPM_PPI_REVISION_ID_1,
 380                                       TPM_PPI_FN_VERSION,
 381                                       NULL, ACPI_TYPE_STRING);
 382         if (obj) {
 383                 strlcpy(chip->ppi_version, obj->string.pointer,
 384                         sizeof(chip->ppi_version));
 385                 ACPI_FREE(obj);
 386         }
 387
 388         chip->groups[chip->groups_cnt++] = &ppi_attr_grp;
 389 }