forked from Freescale/linux-fslc
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
tpm: two-phase chip management functions
tpm_register_hardware() and tpm_remove_hardware() are called often before initializing the device. The problem is that the device might not be fully initialized when it comes visible to the user space. This patch resolves the issue by diving initialization into two parts: - tpmm_chip_alloc() creates struct tpm_chip. - tpm_chip_register() sets up the character device and sysfs attributes. The framework takes care of freeing struct tpm_chip by using the devres API. The broken release callback has been wiped. ACPI drivers do not ever get this callback. Regards to Jason Gunthorpe for carefully reviewing this part of the code. Signed-off-by: Jarkko Sakkinen <[email protected]> Reviewed-by: Jasob Gunthorpe <[email protected]> Reviewed-by: Stefan Berger <[email protected]> Tested-by: Scot Doyle <[email protected]> Tested-by: Peter Huewe <[email protected]> [phuewe: update to upstream changes] Signed-off-by: Peter Huewe <[email protected]>
- Loading branch information
1 parent
87155b7
commit afb5abc
Showing
14 changed files
with
329 additions
and
338 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,199 @@ | ||
/* | ||
* Copyright (C) 2004 IBM Corporation | ||
* Copyright (C) 2014 Intel Corporation | ||
* | ||
* Authors: | ||
* Jarkko Sakkinen <[email protected]> | ||
* Leendert van Doorn <[email protected]> | ||
* Dave Safford <[email protected]> | ||
* Reiner Sailer <[email protected]> | ||
* Kylene Hall <[email protected]> | ||
* | ||
* Maintained by: <[email protected]> | ||
* | ||
* TPM chip management routines. | ||
* | ||
* This program is free software; you can redistribute it and/or | ||
* modify it under the terms of the GNU General Public License as | ||
* published by the Free Software Foundation, version 2 of the | ||
* License. | ||
* | ||
*/ | ||
|
||
#include <linux/poll.h> | ||
#include <linux/slab.h> | ||
#include <linux/mutex.h> | ||
#include <linux/spinlock.h> | ||
#include <linux/freezer.h> | ||
#include "tpm.h" | ||
#include "tpm_eventlog.h" | ||
|
||
static DECLARE_BITMAP(dev_mask, TPM_NUM_DEVICES); | ||
static LIST_HEAD(tpm_chip_list); | ||
static DEFINE_SPINLOCK(driver_lock); | ||
|
||
/* | ||
* tpm_chip_find_get - return tpm_chip for a given chip number | ||
* @chip_num the device number for the chip | ||
*/ | ||
struct tpm_chip *tpm_chip_find_get(int chip_num) | ||
{ | ||
struct tpm_chip *pos, *chip = NULL; | ||
|
||
rcu_read_lock(); | ||
list_for_each_entry_rcu(pos, &tpm_chip_list, list) { | ||
if (chip_num != TPM_ANY_NUM && chip_num != pos->dev_num) | ||
continue; | ||
|
||
if (try_module_get(pos->dev->driver->owner)) { | ||
chip = pos; | ||
break; | ||
} | ||
} | ||
rcu_read_unlock(); | ||
return chip; | ||
} | ||
|
||
/** | ||
* tpmm_chip_remove() - free chip memory and device number | ||
* @data: points to struct tpm_chip instance | ||
* | ||
* This is used internally by tpmm_chip_alloc() and called by devres | ||
* when the device is released. This function does the opposite of | ||
* tpmm_chip_alloc() freeing memory and the device number. | ||
*/ | ||
static void tpmm_chip_remove(void *data) | ||
{ | ||
struct tpm_chip *chip = (struct tpm_chip *) data; | ||
|
||
spin_lock(&driver_lock); | ||
clear_bit(chip->dev_num, dev_mask); | ||
spin_unlock(&driver_lock); | ||
kfree(chip); | ||
} | ||
|
||
/** | ||
* tpmm_chip_alloc() - allocate a new struct tpm_chip instance | ||
* @dev: device to which the chip is associated | ||
* @ops: struct tpm_class_ops instance | ||
* | ||
* Allocates a new struct tpm_chip instance and assigns a free | ||
* device number for it. Caller does not have to worry about | ||
* freeing the allocated resources. When the devices is removed | ||
* devres calls tpmm_chip_remove() to do the job. | ||
*/ | ||
struct tpm_chip *tpmm_chip_alloc(struct device *dev, | ||
const struct tpm_class_ops *ops) | ||
{ | ||
struct tpm_chip *chip; | ||
|
||
chip = kzalloc(sizeof(*chip), GFP_KERNEL); | ||
if (chip == NULL) | ||
return ERR_PTR(-ENOMEM); | ||
|
||
mutex_init(&chip->tpm_mutex); | ||
INIT_LIST_HEAD(&chip->list); | ||
|
||
chip->ops = ops; | ||
|
||
spin_lock(&driver_lock); | ||
chip->dev_num = find_first_zero_bit(dev_mask, TPM_NUM_DEVICES); | ||
spin_unlock(&driver_lock); | ||
|
||
if (chip->dev_num >= TPM_NUM_DEVICES) { | ||
dev_err(dev, "No available tpm device numbers\n"); | ||
kfree(chip); | ||
return ERR_PTR(-ENOMEM); | ||
} | ||
|
||
set_bit(chip->dev_num, dev_mask); | ||
|
||
scnprintf(chip->devname, sizeof(chip->devname), "tpm%d", chip->dev_num); | ||
|
||
chip->dev = dev; | ||
devm_add_action(dev, tpmm_chip_remove, chip); | ||
dev_set_drvdata(dev, chip); | ||
|
||
return chip; | ||
} | ||
EXPORT_SYMBOL_GPL(tpmm_chip_alloc); | ||
|
||
/* | ||
* tpm_chip_register() - create a misc driver for the TPM chip | ||
* @chip: TPM chip to use. | ||
* | ||
* Creates a misc driver for the TPM chip and adds sysfs interfaces for | ||
* the device, PPI and TCPA. As the last step this function adds the | ||
* chip to the list of TPM chips available for use. | ||
* | ||
* NOTE: This function should be only called after the chip initialization | ||
* is complete. | ||
* | ||
* Called from tpm_<specific>.c probe function only for devices | ||
* the driver has determined it should claim. Prior to calling | ||
* this function the specific probe function has called pci_enable_device | ||
* upon errant exit from this function specific probe function should call | ||
* pci_disable_device | ||
*/ | ||
int tpm_chip_register(struct tpm_chip *chip) | ||
{ | ||
int rc; | ||
|
||
rc = tpm_dev_add_device(chip); | ||
if (rc) | ||
return rc; | ||
|
||
rc = tpm_sysfs_add_device(chip); | ||
if (rc) | ||
goto del_misc; | ||
|
||
rc = tpm_add_ppi(&chip->dev->kobj); | ||
if (rc) | ||
goto del_sysfs; | ||
|
||
chip->bios_dir = tpm_bios_log_setup(chip->devname); | ||
|
||
/* Make the chip available. */ | ||
spin_lock(&driver_lock); | ||
list_add_rcu(&chip->list, &tpm_chip_list); | ||
spin_unlock(&driver_lock); | ||
|
||
chip->flags |= TPM_CHIP_FLAG_REGISTERED; | ||
|
||
return 0; | ||
del_sysfs: | ||
tpm_sysfs_del_device(chip); | ||
del_misc: | ||
tpm_dev_del_device(chip); | ||
return rc; | ||
} | ||
EXPORT_SYMBOL_GPL(tpm_chip_register); | ||
|
||
/* | ||
* tpm_chip_unregister() - release the TPM driver | ||
* @chip: TPM chip to use. | ||
* | ||
* Takes the chip first away from the list of available TPM chips and then | ||
* cleans up all the resources reserved by tpm_chip_register(). | ||
* | ||
* NOTE: This function should be only called before deinitializing chip | ||
* resources. | ||
*/ | ||
void tpm_chip_unregister(struct tpm_chip *chip) | ||
{ | ||
if (!(chip->flags & TPM_CHIP_FLAG_REGISTERED)) | ||
return; | ||
|
||
spin_lock(&driver_lock); | ||
list_del_rcu(&chip->list); | ||
spin_unlock(&driver_lock); | ||
synchronize_rcu(); | ||
|
||
if (chip->bios_dir) | ||
tpm_bios_log_teardown(chip->bios_dir); | ||
tpm_remove_ppi(&chip->dev->kobj); | ||
tpm_sysfs_del_device(chip); | ||
|
||
tpm_dev_del_device(chip); | ||
} | ||
EXPORT_SYMBOL_GPL(tpm_chip_unregister); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,5 +1,6 @@ | ||
/* | ||
* Copyright (C) 2004 IBM Corporation | ||
* Copyright (C) 2014 Intel Corporation | ||
* | ||
* Authors: | ||
* Leendert van Doorn <[email protected]> | ||
|
@@ -47,10 +48,6 @@ module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644); | |
MODULE_PARM_DESC(suspend_pcr, | ||
"PCR to use for dummy writes to faciltate flush on suspend."); | ||
|
||
static LIST_HEAD(tpm_chip_list); | ||
static DEFINE_SPINLOCK(driver_lock); | ||
static DECLARE_BITMAP(dev_mask, TPM_NUM_DEVICES); | ||
|
||
/* | ||
* Array with one entry per ordinal defining the maximum amount | ||
* of time the chip could take to return the result. The ordinal | ||
|
@@ -639,27 +636,6 @@ static int tpm_continue_selftest(struct tpm_chip *chip) | |
return rc; | ||
} | ||
|
||
/* | ||
* tpm_chip_find_get - return tpm_chip for given chip number | ||
*/ | ||
static struct tpm_chip *tpm_chip_find_get(int chip_num) | ||
{ | ||
struct tpm_chip *pos, *chip = NULL; | ||
|
||
rcu_read_lock(); | ||
list_for_each_entry_rcu(pos, &tpm_chip_list, list) { | ||
if (chip_num != TPM_ANY_NUM && chip_num != pos->dev_num) | ||
continue; | ||
|
||
if (try_module_get(pos->dev->driver->owner)) { | ||
chip = pos; | ||
break; | ||
} | ||
} | ||
rcu_read_unlock(); | ||
return chip; | ||
} | ||
|
||
#define TPM_ORDINAL_PCRREAD cpu_to_be32(21) | ||
#define READ_PCR_RESULT_SIZE 30 | ||
static struct tpm_input_header pcrread_header = { | ||
|
@@ -887,30 +863,6 @@ int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout, | |
} | ||
EXPORT_SYMBOL_GPL(wait_for_tpm_stat); | ||
|
||
void tpm_remove_hardware(struct device *dev) | ||
{ | ||
struct tpm_chip *chip = dev_get_drvdata(dev); | ||
|
||
if (chip == NULL) { | ||
dev_err(dev, "No device data found\n"); | ||
return; | ||
} | ||
|
||
spin_lock(&driver_lock); | ||
list_del_rcu(&chip->list); | ||
spin_unlock(&driver_lock); | ||
synchronize_rcu(); | ||
|
||
tpm_dev_del_device(chip); | ||
tpm_sysfs_del_device(chip); | ||
tpm_remove_ppi(&dev->kobj); | ||
tpm_bios_log_teardown(chip->bios_dir); | ||
|
||
/* write it this way to be explicit (chip->dev == dev) */ | ||
put_device(chip->dev); | ||
} | ||
EXPORT_SYMBOL_GPL(tpm_remove_hardware); | ||
|
||
#define TPM_ORD_SAVESTATE cpu_to_be32(152) | ||
#define SAVESTATE_RESULT_SIZE 10 | ||
|
||
|
@@ -1044,104 +996,6 @@ int tpm_get_random(u32 chip_num, u8 *out, size_t max) | |
} | ||
EXPORT_SYMBOL_GPL(tpm_get_random); | ||
|
||
/* In case vendor provided release function, call it too.*/ | ||
|
||
void tpm_dev_vendor_release(struct tpm_chip *chip) | ||
{ | ||
if (!chip) | ||
return; | ||
|
||
clear_bit(chip->dev_num, dev_mask); | ||
} | ||
EXPORT_SYMBOL_GPL(tpm_dev_vendor_release); | ||
|
||
|
||
/* | ||
* Once all references to platform device are down to 0, | ||
* release all allocated structures. | ||
*/ | ||
static void tpm_dev_release(struct device *dev) | ||
{ | ||
struct tpm_chip *chip = dev_get_drvdata(dev); | ||
|
||
if (!chip) | ||
return; | ||
|
||
tpm_dev_vendor_release(chip); | ||
|
||
chip->release(dev); | ||
kfree(chip); | ||
} | ||
|
||
/* | ||
* Called from tpm_<specific>.c probe function only for devices | ||
* the driver has determined it should claim. Prior to calling | ||
* this function the specific probe function has called pci_enable_device | ||
* upon errant exit from this function specific probe function should call | ||
* pci_disable_device | ||
*/ | ||
struct tpm_chip *tpm_register_hardware(struct device *dev, | ||
const struct tpm_class_ops *ops) | ||
{ | ||
struct tpm_chip *chip; | ||
|
||
/* Driver specific per-device data */ | ||
chip = kzalloc(sizeof(*chip), GFP_KERNEL); | ||
|
||
if (chip == NULL) | ||
return NULL; | ||
|
||
mutex_init(&chip->tpm_mutex); | ||
INIT_LIST_HEAD(&chip->list); | ||
|
||
chip->ops = ops; | ||
chip->dev_num = find_first_zero_bit(dev_mask, TPM_NUM_DEVICES); | ||
|
||
if (chip->dev_num >= TPM_NUM_DEVICES) { | ||
dev_err(dev, "No available tpm device numbers\n"); | ||
goto out_free; | ||
} | ||
|
||
set_bit(chip->dev_num, dev_mask); | ||
|
||
scnprintf(chip->devname, sizeof(chip->devname), "%s%d", "tpm", | ||
chip->dev_num); | ||
|
||
chip->dev = get_device(dev); | ||
chip->release = dev->release; | ||
dev->release = tpm_dev_release; | ||
dev_set_drvdata(dev, chip); | ||
|
||
if (tpm_dev_add_device(chip)) | ||
goto put_device; | ||
|
||
if (tpm_sysfs_add_device(chip)) | ||
goto del_misc; | ||
|
||
if (tpm_add_ppi(&dev->kobj)) | ||
goto del_sysfs; | ||
|
||
chip->bios_dir = tpm_bios_log_setup(chip->devname); | ||
|
||
/* Make chip available */ | ||
spin_lock(&driver_lock); | ||
list_add_tail_rcu(&chip->list, &tpm_chip_list); | ||
spin_unlock(&driver_lock); | ||
|
||
return chip; | ||
|
||
del_sysfs: | ||
tpm_sysfs_del_device(chip); | ||
del_misc: | ||
tpm_dev_del_device(chip); | ||
put_device: | ||
put_device(chip->dev); | ||
out_free: | ||
kfree(chip); | ||
return NULL; | ||
} | ||
EXPORT_SYMBOL_GPL(tpm_register_hardware); | ||
|
||
MODULE_AUTHOR("Leendert van Doorn ([email protected])"); | ||
MODULE_DESCRIPTION("TPM Driver"); | ||
MODULE_VERSION("2.0"); | ||
|
Oops, something went wrong.