Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2004 IBM Corporation |
| 3 | * Copyright (C) 2014 Intel Corporation |
| 4 | * |
| 5 | * Authors: |
| 6 | * Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> |
| 7 | * Leendert van Doorn <leendert@watson.ibm.com> |
| 8 | * Dave Safford <safford@watson.ibm.com> |
| 9 | * Reiner Sailer <sailer@watson.ibm.com> |
| 10 | * Kylene Hall <kjhall@us.ibm.com> |
| 11 | * |
| 12 | * Maintained by: <tpmdd-devel@lists.sourceforge.net> |
| 13 | * |
| 14 | * TPM chip management routines. |
| 15 | * |
| 16 | * This program is free software; you can redistribute it and/or |
| 17 | * modify it under the terms of the GNU General Public License as |
| 18 | * published by the Free Software Foundation, version 2 of the |
| 19 | * License. |
| 20 | * |
| 21 | */ |
| 22 | |
| 23 | #include <linux/poll.h> |
| 24 | #include <linux/slab.h> |
| 25 | #include <linux/mutex.h> |
| 26 | #include <linux/spinlock.h> |
| 27 | #include <linux/freezer.h> |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 28 | #include <linux/major.h> |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 29 | #include "tpm.h" |
| 30 | #include "tpm_eventlog.h" |
| 31 | |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 32 | DEFINE_IDR(dev_nums_idr); |
| 33 | static DEFINE_MUTEX(idr_lock); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 34 | |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 35 | struct class *tpm_class; |
| 36 | dev_t tpm_devt; |
| 37 | |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 38 | /** |
| 39 | * tpm_try_get_ops() - Get a ref to the tpm_chip |
| 40 | * @chip: Chip to ref |
| 41 | * |
| 42 | * The caller must already have some kind of locking to ensure that chip is |
| 43 | * valid. This function will lock the chip so that the ops member can be |
| 44 | * accessed safely. The locking prevents tpm_chip_unregister from |
| 45 | * completing, so it should not be held for long periods. |
| 46 | * |
| 47 | * Returns -ERRNO if the chip could not be got. |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 48 | */ |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 49 | int tpm_try_get_ops(struct tpm_chip *chip) |
| 50 | { |
| 51 | int rc = -EIO; |
| 52 | |
| 53 | get_device(&chip->dev); |
| 54 | |
| 55 | down_read(&chip->ops_sem); |
| 56 | if (!chip->ops) |
| 57 | goto out_lock; |
| 58 | |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 59 | return 0; |
| 60 | out_lock: |
| 61 | up_read(&chip->ops_sem); |
| 62 | put_device(&chip->dev); |
| 63 | return rc; |
| 64 | } |
| 65 | EXPORT_SYMBOL_GPL(tpm_try_get_ops); |
| 66 | |
| 67 | /** |
| 68 | * tpm_put_ops() - Release a ref to the tpm_chip |
| 69 | * @chip: Chip to put |
| 70 | * |
| 71 | * This is the opposite pair to tpm_try_get_ops(). After this returns chip may |
| 72 | * be kfree'd. |
| 73 | */ |
| 74 | void tpm_put_ops(struct tpm_chip *chip) |
| 75 | { |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 76 | up_read(&chip->ops_sem); |
| 77 | put_device(&chip->dev); |
| 78 | } |
| 79 | EXPORT_SYMBOL_GPL(tpm_put_ops); |
| 80 | |
| 81 | /** |
| 82 | * tpm_chip_find_get() - return tpm_chip for a given chip number |
| 83 | * @chip_num: id to find |
| 84 | * |
| 85 | * The return'd chip has been tpm_try_get_ops'd and must be released via |
| 86 | * tpm_put_ops |
| 87 | */ |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 88 | struct tpm_chip *tpm_chip_find_get(int chip_num) |
| 89 | { |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 90 | struct tpm_chip *chip, *res = NULL; |
| 91 | int chip_prev; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 92 | |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 93 | mutex_lock(&idr_lock); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 94 | |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 95 | if (chip_num == TPM_ANY_NUM) { |
| 96 | chip_num = 0; |
| 97 | do { |
| 98 | chip_prev = chip_num; |
| 99 | chip = idr_get_next(&dev_nums_idr, &chip_num); |
| 100 | if (chip && !tpm_try_get_ops(chip)) { |
| 101 | res = chip; |
| 102 | break; |
| 103 | } |
| 104 | } while (chip_prev != chip_num); |
| 105 | } else { |
| 106 | chip = idr_find_slowpath(&dev_nums_idr, chip_num); |
| 107 | if (chip && !tpm_try_get_ops(chip)) |
| 108 | res = chip; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 109 | } |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 110 | |
| 111 | mutex_unlock(&idr_lock); |
| 112 | |
| 113 | return res; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | /** |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 117 | * tpm_dev_release() - free chip memory and the device number |
| 118 | * @dev: the character device for the TPM chip |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 119 | * |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 120 | * This is used as the release function for the character device. |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 121 | */ |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 122 | static void tpm_dev_release(struct device *dev) |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 123 | { |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 124 | struct tpm_chip *chip = container_of(dev, struct tpm_chip, dev); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 125 | |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 126 | mutex_lock(&idr_lock); |
| 127 | idr_remove(&dev_nums_idr, chip->dev_num); |
| 128 | mutex_unlock(&idr_lock); |
| 129 | |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 130 | kfree(chip); |
| 131 | } |
| 132 | |
| 133 | /** |
Jason Gunthorpe | 3897cd9 | 2016-02-11 12:45:48 -0700 | [diff] [blame] | 134 | * tpm_chip_alloc() - allocate a new struct tpm_chip instance |
| 135 | * @pdev: device to which the chip is associated |
| 136 | * At this point pdev mst be initialized, but does not have to |
| 137 | * be registered |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 138 | * @ops: struct tpm_class_ops instance |
| 139 | * |
| 140 | * Allocates a new struct tpm_chip instance and assigns a free |
Jason Gunthorpe | 3897cd9 | 2016-02-11 12:45:48 -0700 | [diff] [blame] | 141 | * device number for it. Must be paired with put_device(&chip->dev). |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 142 | */ |
Jason Gunthorpe | 3897cd9 | 2016-02-11 12:45:48 -0700 | [diff] [blame] | 143 | struct tpm_chip *tpm_chip_alloc(struct device *dev, |
| 144 | const struct tpm_class_ops *ops) |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 145 | { |
| 146 | struct tpm_chip *chip; |
Jarkko Sakkinen | 4f3b193 | 2016-02-13 11:58:16 +0200 | [diff] [blame] | 147 | int rc; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 148 | |
| 149 | chip = kzalloc(sizeof(*chip), GFP_KERNEL); |
| 150 | if (chip == NULL) |
| 151 | return ERR_PTR(-ENOMEM); |
| 152 | |
| 153 | mutex_init(&chip->tpm_mutex); |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 154 | init_rwsem(&chip->ops_sem); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 155 | |
| 156 | chip->ops = ops; |
| 157 | |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 158 | mutex_lock(&idr_lock); |
| 159 | rc = idr_alloc(&dev_nums_idr, NULL, 0, TPM_NUM_DEVICES, GFP_KERNEL); |
| 160 | mutex_unlock(&idr_lock); |
| 161 | if (rc < 0) { |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 162 | dev_err(dev, "No available tpm device numbers\n"); |
| 163 | kfree(chip); |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 164 | return ERR_PTR(rc); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 165 | } |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 166 | chip->dev_num = rc; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 167 | |
Jason Gunthorpe | 3635e2e | 2016-02-29 12:29:48 -0500 | [diff] [blame] | 168 | device_initialize(&chip->dev); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 169 | |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 170 | chip->dev.class = tpm_class; |
| 171 | chip->dev.release = tpm_dev_release; |
Jason Gunthorpe | 8cfffc9 | 2016-02-29 12:29:47 -0500 | [diff] [blame] | 172 | chip->dev.parent = dev; |
Jarkko Sakkinen | 9b774d5 | 2015-04-14 17:56:48 +0300 | [diff] [blame] | 173 | #ifdef CONFIG_ACPI |
| 174 | chip->dev.groups = chip->groups; |
| 175 | #endif |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 176 | |
| 177 | if (chip->dev_num == 0) |
| 178 | chip->dev.devt = MKDEV(MISC_MAJOR, TPM_MINOR); |
| 179 | else |
| 180 | chip->dev.devt = MKDEV(MAJOR(tpm_devt), chip->dev_num); |
| 181 | |
Jason Gunthorpe | 3635e2e | 2016-02-29 12:29:48 -0500 | [diff] [blame] | 182 | rc = dev_set_name(&chip->dev, "tpm%d", chip->dev_num); |
| 183 | if (rc) |
| 184 | goto out; |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 185 | |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 186 | cdev_init(&chip->cdev, &tpm_fops); |
Stefan Berger | 2072df4 | 2016-02-29 08:53:01 -0500 | [diff] [blame] | 187 | chip->cdev.owner = THIS_MODULE; |
Jason Gunthorpe | ba0ef85 | 2015-06-30 13:15:31 -0600 | [diff] [blame] | 188 | chip->cdev.kobj.parent = &chip->dev.kobj; |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 189 | |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 190 | return chip; |
Jason Gunthorpe | 3635e2e | 2016-02-29 12:29:48 -0500 | [diff] [blame] | 191 | |
| 192 | out: |
| 193 | put_device(&chip->dev); |
| 194 | return ERR_PTR(rc); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 195 | } |
Jason Gunthorpe | 3897cd9 | 2016-02-11 12:45:48 -0700 | [diff] [blame] | 196 | EXPORT_SYMBOL_GPL(tpm_chip_alloc); |
| 197 | |
| 198 | /** |
| 199 | * tpmm_chip_alloc() - allocate a new struct tpm_chip instance |
| 200 | * @pdev: parent device to which the chip is associated |
| 201 | * @ops: struct tpm_class_ops instance |
| 202 | * |
| 203 | * Same as tpm_chip_alloc except devm is used to do the put_device |
| 204 | */ |
| 205 | struct tpm_chip *tpmm_chip_alloc(struct device *pdev, |
| 206 | const struct tpm_class_ops *ops) |
| 207 | { |
| 208 | struct tpm_chip *chip; |
| 209 | int rc; |
| 210 | |
| 211 | chip = tpm_chip_alloc(pdev, ops); |
| 212 | if (IS_ERR(chip)) |
| 213 | return chip; |
| 214 | |
| 215 | rc = devm_add_action(pdev, (void (*)(void *)) put_device, &chip->dev); |
| 216 | if (rc) { |
| 217 | put_device(&chip->dev); |
| 218 | return ERR_PTR(rc); |
| 219 | } |
| 220 | |
| 221 | dev_set_drvdata(pdev, chip); |
| 222 | |
| 223 | return chip; |
| 224 | } |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 225 | EXPORT_SYMBOL_GPL(tpmm_chip_alloc); |
| 226 | |
Jarkko Sakkinen | 72c91ce | 2016-01-29 09:47:22 -0800 | [diff] [blame] | 227 | static int tpm_add_char_device(struct tpm_chip *chip) |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 228 | { |
| 229 | int rc; |
| 230 | |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 231 | rc = cdev_add(&chip->cdev, chip->dev.devt, 1); |
| 232 | if (rc) { |
| 233 | dev_err(&chip->dev, |
| 234 | "unable to cdev_add() %s, major %d, minor %d, err=%d\n", |
Jason Gunthorpe | 3635e2e | 2016-02-29 12:29:48 -0500 | [diff] [blame] | 235 | dev_name(&chip->dev), MAJOR(chip->dev.devt), |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 236 | MINOR(chip->dev.devt), rc); |
| 237 | |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 238 | return rc; |
| 239 | } |
| 240 | |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 241 | rc = device_add(&chip->dev); |
| 242 | if (rc) { |
| 243 | dev_err(&chip->dev, |
| 244 | "unable to device_register() %s, major %d, minor %d, err=%d\n", |
Jason Gunthorpe | 3635e2e | 2016-02-29 12:29:48 -0500 | [diff] [blame] | 245 | dev_name(&chip->dev), MAJOR(chip->dev.devt), |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 246 | MINOR(chip->dev.devt), rc); |
| 247 | |
Jarkko Sakkinen | 72c91ce | 2016-01-29 09:47:22 -0800 | [diff] [blame] | 248 | cdev_del(&chip->cdev); |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 249 | return rc; |
| 250 | } |
| 251 | |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 252 | /* Make the chip available. */ |
| 253 | mutex_lock(&idr_lock); |
| 254 | idr_replace(&dev_nums_idr, chip, chip->dev_num); |
| 255 | mutex_unlock(&idr_lock); |
| 256 | |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 257 | return rc; |
| 258 | } |
| 259 | |
Jarkko Sakkinen | 72c91ce | 2016-01-29 09:47:22 -0800 | [diff] [blame] | 260 | static void tpm_del_char_device(struct tpm_chip *chip) |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 261 | { |
| 262 | cdev_del(&chip->cdev); |
Stefan Berger | 1551678 | 2016-02-29 08:53:02 -0500 | [diff] [blame] | 263 | device_del(&chip->dev); |
| 264 | |
| 265 | /* Make the chip unavailable. */ |
| 266 | mutex_lock(&idr_lock); |
| 267 | idr_replace(&dev_nums_idr, NULL, chip->dev_num); |
| 268 | mutex_unlock(&idr_lock); |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 269 | |
| 270 | /* Make the driver uncallable. */ |
| 271 | down_write(&chip->ops_sem); |
Jarkko Sakkinen | c0dff1f | 2016-04-25 12:20:07 +0300 | [diff] [blame] | 272 | if (chip->flags & TPM_CHIP_FLAG_TPM2) |
| 273 | tpm2_shutdown(chip, TPM2_SU_CLEAR); |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 274 | chip->ops = NULL; |
| 275 | up_write(&chip->ops_sem); |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 276 | } |
| 277 | |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 278 | static int tpm1_chip_register(struct tpm_chip *chip) |
| 279 | { |
| 280 | int rc; |
| 281 | |
| 282 | if (chip->flags & TPM_CHIP_FLAG_TPM2) |
| 283 | return 0; |
| 284 | |
| 285 | rc = tpm_sysfs_add_device(chip); |
| 286 | if (rc) |
| 287 | return rc; |
| 288 | |
Jason Gunthorpe | 3635e2e | 2016-02-29 12:29:48 -0500 | [diff] [blame] | 289 | chip->bios_dir = tpm_bios_log_setup(dev_name(&chip->dev)); |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 290 | |
| 291 | return 0; |
| 292 | } |
| 293 | |
| 294 | static void tpm1_chip_unregister(struct tpm_chip *chip) |
| 295 | { |
| 296 | if (chip->flags & TPM_CHIP_FLAG_TPM2) |
| 297 | return; |
| 298 | |
| 299 | if (chip->bios_dir) |
| 300 | tpm_bios_log_teardown(chip->bios_dir); |
| 301 | |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 302 | tpm_sysfs_del_device(chip); |
| 303 | } |
| 304 | |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 305 | /* |
Jarkko Sakkinen | 313d21e | 2014-12-12 11:46:37 -0800 | [diff] [blame] | 306 | * tpm_chip_register() - create a character device for the TPM chip |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 307 | * @chip: TPM chip to use. |
| 308 | * |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 309 | * Creates a character device for the TPM chip and adds sysfs attributes for |
| 310 | * the device. As the last step this function adds the chip to the list of TPM |
| 311 | * chips available for in-kernel use. |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 312 | * |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 313 | * This function should be only called after the chip initialization is |
| 314 | * complete. |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 315 | */ |
| 316 | int tpm_chip_register(struct tpm_chip *chip) |
| 317 | { |
| 318 | int rc; |
| 319 | |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 320 | rc = tpm1_chip_register(chip); |
| 321 | if (rc) |
| 322 | return rc; |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 323 | |
Jarkko Sakkinen | 9b774d5 | 2015-04-14 17:56:48 +0300 | [diff] [blame] | 324 | tpm_add_ppi(chip); |
| 325 | |
Jarkko Sakkinen | 72c91ce | 2016-01-29 09:47:22 -0800 | [diff] [blame] | 326 | rc = tpm_add_char_device(chip); |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 327 | if (rc) |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 328 | goto out_err; |
Jarkko Sakkinen | d972b05 | 2015-03-01 23:55:47 +0200 | [diff] [blame] | 329 | |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 330 | chip->flags |= TPM_CHIP_FLAG_REGISTERED; |
| 331 | |
Jarkko Sakkinen | d56e4f7 | 2015-11-07 13:33:25 +0200 | [diff] [blame] | 332 | if (!(chip->flags & TPM_CHIP_FLAG_TPM2)) { |
Jason Gunthorpe | 8cfffc9 | 2016-02-29 12:29:47 -0500 | [diff] [blame] | 333 | rc = __compat_only_sysfs_link_entry_to_kobj( |
| 334 | &chip->dev.parent->kobj, &chip->dev.kobj, "ppi"); |
Jarkko Sakkinen | d56e4f7 | 2015-11-07 13:33:25 +0200 | [diff] [blame] | 335 | if (rc && rc != -ENOENT) { |
| 336 | tpm_chip_unregister(chip); |
| 337 | return rc; |
| 338 | } |
| 339 | } |
| 340 | |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 341 | return 0; |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 342 | out_err: |
| 343 | tpm1_chip_unregister(chip); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 344 | return rc; |
| 345 | } |
| 346 | EXPORT_SYMBOL_GPL(tpm_chip_register); |
| 347 | |
| 348 | /* |
| 349 | * tpm_chip_unregister() - release the TPM driver |
| 350 | * @chip: TPM chip to use. |
| 351 | * |
| 352 | * Takes the chip first away from the list of available TPM chips and then |
| 353 | * cleans up all the resources reserved by tpm_chip_register(). |
| 354 | * |
Jason Gunthorpe | 4e26195 | 2016-02-12 20:29:53 -0700 | [diff] [blame] | 355 | * Once this function returns the driver call backs in 'op's will not be |
| 356 | * running and will no longer start. |
| 357 | * |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 358 | * NOTE: This function should be only called before deinitializing chip |
| 359 | * resources. |
| 360 | */ |
| 361 | void tpm_chip_unregister(struct tpm_chip *chip) |
| 362 | { |
| 363 | if (!(chip->flags & TPM_CHIP_FLAG_REGISTERED)) |
| 364 | return; |
| 365 | |
Jarkko Sakkinen | 9b774d5 | 2015-04-14 17:56:48 +0300 | [diff] [blame] | 366 | if (!(chip->flags & TPM_CHIP_FLAG_TPM2)) |
Jason Gunthorpe | 8cfffc9 | 2016-02-29 12:29:47 -0500 | [diff] [blame] | 367 | sysfs_remove_link(&chip->dev.parent->kobj, "ppi"); |
Jarkko Sakkinen | 9b774d5 | 2015-04-14 17:56:48 +0300 | [diff] [blame] | 368 | |
Jarkko Sakkinen | 34d47b6 | 2015-03-18 08:17:14 +0200 | [diff] [blame] | 369 | tpm1_chip_unregister(chip); |
Jarkko Sakkinen | 72c91ce | 2016-01-29 09:47:22 -0800 | [diff] [blame] | 370 | tpm_del_char_device(chip); |
Jarkko Sakkinen | afb5abc | 2014-12-12 11:46:34 -0800 | [diff] [blame] | 371 | } |
| 372 | EXPORT_SYMBOL_GPL(tpm_chip_unregister); |