Re: [PATCH] tpm: Make timeout logic simpler and more robust

Mimi Zohar
2019-03-12T17:05:27Z

On Mon, 2019-03-11 at 16:54 -0700, Calvin Owens wrote:
> We're having lots of problems with TPM commands timing out, and we're
> seeing these problems across lots of different hardware (both v1/v2).
>
> I instrumented the driver to collect latency data, but I wasn't able to
> find any specific timeout to fix: it seems like many of them are too
> aggressive. So I tried replacing all the timeout logic with a single
> universal long timeout, and found that makes our TPMs 100% reliable.
>
> Given that this timeout logic is very complex, problematic, and appears
> to serve no real purpose, I propose simply deleting all of it.

Normally before sending such a massive change like this, included in
the bug report or patch description, there would be some indication as
to which kernel introduced a regression.  Has this always been a
problem?  Is this something new?  How new?

Mimi

>
> Signed-off-by: Calvin Owens <calvinowens@fb.com>
> ---
> drivers/char/tpm/st33zp24/st33zp24.c | 28 +-
> drivers/char/tpm/tpm-interface.c | 41 +--
> drivers/char/tpm/tpm-sysfs.c | 34 ---
> drivers/char/tpm/tpm.h | 60 +---
> drivers/char/tpm/tpm1-cmd.c | 423 ++-------------------------
> drivers/char/tpm/tpm2-cmd.c | 120 --------
> drivers/char/tpm/tpm_crb.c | 20 +-
> drivers/char/tpm/tpm_i2c_atmel.c | 6 -
> drivers/char/tpm/tpm_i2c_infineon.c | 33 +--
> drivers/char/tpm/tpm_i2c_nuvoton.c | 42 +--
> drivers/char/tpm/tpm_nsc.c | 6 +-
> drivers/char/tpm/tpm_tis_core.c | 96 +-----
> drivers/char/tpm/xen-tpmfront.c | 17 +-
> 13 files changed, 108 insertions(+), 818 deletions(-)
>
> diff --git a/drivers/char/tpm/st33zp24/st33zp24.c b/drivers/char/tpm/st33zp24/st33zp24.c
> index 64dc560859f2..433b9a72f0ef 100644
> --- a/drivers/char/tpm/st33zp24/st33zp24.c
> +++ b/drivers/char/tpm/st33zp24/st33zp24.c
> @@ -154,13 +154,13 @@ static int request_locality(struct tpm_chip *chip)
> if (ret < 0)
> return ret;
>
> - stop = jiffies + chip->timeout_a;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
>
> /* Request locality is usually effective after the request */
> do {
> if (check_locality(chip))
> return tpm_dev->locality;
> - msleep(TPM_TIMEOUT);
> + msleep(TPM_TIMEOUT_POLL_MS);
> } while (time_before(jiffies, stop));
>
> /* could not get locality */
> @@ -193,7 +193,7 @@ static int get_burstcount(struct tpm_chip *chip)
> int burstcnt, status;
> u8 temp;
>
> - stop = jiffies + chip->timeout_d;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> status = tpm_dev->ops->recv(tpm_dev->phy_id, TPM_STS + 1,
> &temp, 1);
> @@ -209,7 +209,7 @@ static int get_burstcount(struct tpm_chip *chip)
> burstcnt |= temp << 8;
> if (burstcnt)
> return burstcnt;
> - msleep(TPM_TIMEOUT);
> + msleep(TPM_TIMEOUT_POLL_MS);
> } while (time_before(jiffies, stop));
> return -EBUSY;
> } /* get_burstcount() */
> @@ -248,11 +248,11 @@ static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
> * @param: check_cancel, does the command can be cancelled ?
> * @return: the tpm status, 0 if success, -ETIME if timeout is reached.
> */
> -static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
> +static int wait_for_stat(struct tpm_chip *chip, u8 mask,
> wait_queue_head_t *queue, bool check_cancel)
> {
> struct st33zp24_dev *tpm_dev = dev_get_drvdata(&chip->dev);
> - unsigned long stop;
> + unsigned long stop, timeout;
> int ret = 0;
> bool canceled = false;
> bool condition;
> @@ -264,7 +264,7 @@ static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
> if ((status & mask) == mask)
> return 0;
>
> - stop = jiffies + timeout;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
>
> if (chip->flags & TPM_CHIP_FLAG_IRQ) {
> cur_intrs = tpm_dev->intrs;
> @@ -296,7 +296,7 @@ static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
>
> } else {
> do {
> - msleep(TPM_TIMEOUT);
> + msleep(TPM_TIMEOUT_POLL_MS);
> status = chip->ops->status(chip);
> if ((status & mask) == mask)
> return 0;
> @@ -321,7 +321,6 @@ static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
> while (size < count &&
> wait_for_stat(chip,
> TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> - chip->timeout_c,
> &tpm_dev->read_queue, true) == 0) {
> burstcnt = get_burstcount(chip);
> if (burstcnt < 0)
> @@ -384,7 +383,7 @@ static int st33zp24_send(struct tpm_chip *chip, unsigned char *buf,
> if ((status & TPM_STS_COMMAND_READY) == 0) {
> st33zp24_cancel(chip);
> if (wait_for_stat
> - (chip, TPM_STS_COMMAND_READY, chip->timeout_b,
> + (chip, TPM_STS_COMMAND_READY,
> &tpm_dev->read_queue, false) < 0) {
> ret = -ETIME;
> goto out_err;
> @@ -430,7 +429,6 @@ static int st33zp24_send(struct tpm_chip *chip, unsigned char *buf,
> ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
>
> ret = wait_for_stat(chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> - tpm_calc_ordinal_duration(chip, ordinal),
> &tpm_dev->read_queue, false);
> if (ret < 0)
> goto out_err;
> @@ -539,12 +537,6 @@ int st33zp24_probe(void *phy_id, const struct st33zp24_phy_ops *ops,
> tpm_dev->phy_id = phy_id;
> tpm_dev->ops = ops;
> dev_set_drvdata(&chip->dev, tpm_dev);
> -
> - chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
> - chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
> - chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
> - chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
> -
> tpm_dev->locality = LOCALITY0;
>
> if (irq) {
> @@ -644,7 +636,7 @@ int st33zp24_pm_resume(struct device *dev)
> if (gpio_is_valid(tpm_dev->io_lpcpd)) {
> gpio_set_value(tpm_dev->io_lpcpd, 1);
> ret = wait_for_stat(chip,
> - TPM_STS_VALID, chip->timeout_b,
> + TPM_STS_VALID,
> &tpm_dev->read_queue, false);
> } else {
> ret = tpm_pm_resume(dev);
> diff --git a/drivers/char/tpm/tpm-interface.c b/drivers/char/tpm/tpm-interface.c
> index d9439f9abe78..7ceefe02ca32 100644
> --- a/drivers/char/tpm/tpm-interface.c
> +++ b/drivers/char/tpm/tpm-interface.c
> @@ -43,25 +43,6 @@ module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
> MODULE_PARM_DESC(suspend_pcr,
> "PCR to use for dummy writes to facilitate flush on suspend.");
>
> -/**
> - * tpm_calc_ordinal_duration() - calculate the maximum command duration
> - * @chip: TPM chip to use.
> - * @ordinal: TPM command ordinal.
> - *
> - * The function returns the maximum amount of time the chip could take
> - * to return the result for a particular ordinal in jiffies.
> - *
> - * Return: A maximal duration time for an ordinal in jiffies.
> - */
> -unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
> -{
> - if (chip->flags & TPM_CHIP_FLAG_TPM2)
> - return tpm2_calc_ordinal_duration(chip, ordinal);
> - else
> - return tpm1_calc_ordinal_duration(chip, ordinal);
> -}
> -EXPORT_SYMBOL_GPL(tpm_calc_ordinal_duration);
> -
> static int tpm_validate_command(struct tpm_chip *chip,
> struct tpm_space *space,
> const u8 *cmd,
> @@ -237,7 +218,7 @@ static ssize_t tpm_try_transmit(struct tpm_chip *chip,
> if (chip->flags & TPM_CHIP_FLAG_IRQ)
> goto out_recv;
>
> - stop = jiffies + tpm_calc_ordinal_duration(chip, ordinal);
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> u8 status = chip->ops->status(chip);
> if ((status & chip->ops->req_complete_mask) ==
> @@ -250,7 +231,7 @@ static ssize_t tpm_try_transmit(struct tpm_chip *chip,
> goto out;
> }
>
> - tpm_msleep(TPM_TIMEOUT_POLL);
> + tpm_msleep(TPM_TIMEOUT_POLL_MS);
> rmb();
> } while (time_before(jiffies, stop));
>
> @@ -307,7 +288,7 @@ static ssize_t tpm_try_transmit(struct tpm_chip *chip,
> *
> * A wrapper around tpm_try_transmit that handles TPM2_RC_RETRY
> * returns from the TPM and retransmits the command after a delay up
> - * to a maximum wait of TPM2_DURATION_LONG.
> + * to a maximum wait of TPM_UNIVERSAL_TIMEOUT_MS.
> *
> * Note: TPM1 never returns TPM2_RC_RETRY so the retry logic is TPM2
> * only
> @@ -322,7 +303,7 @@ ssize_t tpm_transmit(struct tpm_chip *chip, struct tpm_space *space,
> struct tpm_output_header *header = (struct tpm_output_header *)buf;
> /* space for header and handles */
> u8 save[TPM_HEADER_SIZE + 3*sizeof(u32)];
> - unsigned int delay_msec = TPM2_DURATION_SHORT;
> + unsigned int delay_msec = 20;
> u32 rc = 0;
> ssize_t ret;
> const size_t save_size = min(space ? sizeof(save) : TPM_HEADER_SIZE,
> @@ -351,7 +332,7 @@ ssize_t tpm_transmit(struct tpm_chip *chip, struct tpm_space *space,
> if (rc == TPM2_RC_TESTING && cc == TPM2_CC_SELF_TEST)
> break;
>
> - if (delay_msec > TPM2_DURATION_LONG) {
> + if (delay_msec > TPM_UNIVERSAL_TIMEOUT_MS) {
> if (rc == TPM2_RC_RETRY)
> dev_err(&chip->dev, "in retry loop\n");
> else
> @@ -410,18 +391,6 @@ ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_space *space,
> }
> EXPORT_SYMBOL_GPL(tpm_transmit_cmd);
>
> -int tpm_get_timeouts(struct tpm_chip *chip)
> -{
> - if (chip->flags & TPM_CHIP_FLAG_HAVE_TIMEOUTS)
> - return 0;
> -
> - if (chip->flags & TPM_CHIP_FLAG_TPM2)
> - return tpm2_get_timeouts(chip);
> - else
> - return tpm1_get_timeouts(chip);
> -}
> -EXPORT_SYMBOL_GPL(tpm_get_timeouts);
> -
> /**
> * tpm_is_tpm2 - do we a have a TPM2 chip?
> * @chip: a &struct tpm_chip instance, %NULL for the default chip
> diff --git a/drivers/char/tpm/tpm-sysfs.c b/drivers/char/tpm/tpm-sysfs.c
> index b88e08ec2c59..f1813afe8d9b 100644
> --- a/drivers/char/tpm/tpm-sysfs.c
> +++ b/drivers/char/tpm/tpm-sysfs.c
> @@ -252,38 +252,6 @@ static ssize_t cancel_store(struct device *dev, struct device_attribute *attr,
> }
> static DEVICE_ATTR_WO(cancel);
>
> -static ssize_t durations_show(struct device *dev, struct device_attribute *attr,
> - char *buf)
> -{
> - struct tpm_chip *chip = to_tpm_chip(dev);
> -
> - if (chip->duration[TPM_LONG] == 0)
> - return 0;
> -
> - return sprintf(buf, "%d %d %d [%s]\n",
> - jiffies_to_usecs(chip->duration[TPM_SHORT]),
> - jiffies_to_usecs(chip->duration[TPM_MEDIUM]),
> - jiffies_to_usecs(chip->duration[TPM_LONG]),
> - chip->duration_adjusted
> - ? "adjusted" : "original");
> -}
> -static DEVICE_ATTR_RO(durations);
> -
> -static ssize_t timeouts_show(struct device *dev, struct device_attribute *attr,
> - char *buf)
> -{
> - struct tpm_chip *chip = to_tpm_chip(dev);
> -
> - return sprintf(buf, "%d %d %d %d [%s]\n",
> - jiffies_to_usecs(chip->timeout_a),
> - jiffies_to_usecs(chip->timeout_b),
> - jiffies_to_usecs(chip->timeout_c),
> - jiffies_to_usecs(chip->timeout_d),
> - chip->timeout_adjusted
> - ? "adjusted" : "original");
> -}
> -static DEVICE_ATTR_RO(timeouts);
> -
> static struct attribute *tpm_dev_attrs[] = {
> &dev_attr_pubek.attr,
> &dev_attr_pcrs.attr,
> @@ -293,8 +261,6 @@ static struct attribute *tpm_dev_attrs[] = {
> &dev_attr_temp_deactivated.attr,
> &dev_attr_caps.attr,
> &dev_attr_cancel.attr,
> - &dev_attr_durations.attr,
> - &dev_attr_timeouts.attr,
> NULL,
> };
>
> diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
> index f27d1f38a93d..d5c1c7e52086 100644
> --- a/drivers/char/tpm/tpm.h
> +++ b/drivers/char/tpm/tpm.h
> @@ -50,14 +50,17 @@ enum tpm_const {
> TPM_NUM_EVENT_LOG_FILES = 3,
> };
>
> -enum tpm_timeout {
> - TPM_TIMEOUT = 5, /* msecs */
> - TPM_TIMEOUT_RETRY = 100, /* msecs */
> - TPM_TIMEOUT_RANGE_US = 300, /* usecs */
> - TPM_TIMEOUT_POLL = 1, /* msecs */
> - TPM_TIMEOUT_USECS_MIN = 100, /* usecs */
> - TPM_TIMEOUT_USECS_MAX = 500 /* usecs */
> -};
> +/*
> + * Universal timeout, long enough for all commands.
> + */
> +#define TPM_UNIVERSAL_TIMEOUT_MS 5000
> +#define TPM_UNIVERSAL_TIMEOUT_JIFFIES msecs_to_jiffies(TPM_UNIVERSAL_TIMEOUT_MS)
> +
> +#define TPM_TIMEOUT_POLL_MS 1
> +#define TPM_TIMEOUT_POLL_JIFFIES msecs_to_jiffies(TPM_TIMEOUT_POLL_MS)
> +
> +#define TPM_TIMEOUT_USECS_MIN 100
> +#define TPM_TIMEOUT_USECS_MAX 500
>
> /* TPM addresses */
> enum tpm_addr {
> @@ -65,16 +68,6 @@ enum tpm_addr {
> TPM_ADDR = 0x4E,
> };
>
> -/* Indexes the duration array */
> -enum tpm_duration {
> - TPM_SHORT = 0,
> - TPM_MEDIUM = 1,
> - TPM_LONG = 2,
> - TPM_LONG_LONG = 3,
> - TPM_UNDEFINED,
> - TPM_NUM_DURATIONS = TPM_UNDEFINED,
> -};
> -
> #define TPM_WARN_RETRY 0x800
> #define TPM_WARN_DOING_SELFTEST 0x802
> #define TPM_ERR_DEACTIVATED 0x6
> @@ -88,18 +81,6 @@ enum tpm2_const {
> TPM2_PCR_SELECT_MIN = ((TPM2_PLATFORM_PCR + 7) / 8),
> };
>
> -enum tpm2_timeouts {
> - TPM2_TIMEOUT_A = 750,
> - TPM2_TIMEOUT_B = 2000,
> - TPM2_TIMEOUT_C = 200,
> - TPM2_TIMEOUT_D = 30,
> - TPM2_DURATION_SHORT = 20,
> - TPM2_DURATION_MEDIUM = 750,
> - TPM2_DURATION_LONG = 2000,
> - TPM2_DURATION_LONG_LONG = 300000,
> - TPM2_DURATION_DEFAULT = 120000,
> -};
> -
> enum tpm2_structures {
> TPM2_ST_NO_SESSIONS = 0x8001,
> TPM2_ST_SESSIONS = 0x8002,
> @@ -244,14 +225,6 @@ struct tpm_chip {
>
> struct mutex tpm_mutex; /* tpm is processing */
>
> - unsigned long timeout_a; /* jiffies */
> - unsigned long timeout_b; /* jiffies */
> - unsigned long timeout_c; /* jiffies */
> - unsigned long timeout_d; /* jiffies */
> - bool timeout_adjusted;
> - unsigned long duration[TPM_NUM_DURATIONS]; /* jiffies */
> - bool duration_adjusted;
> -
> struct dentry *bios_dir[TPM_NUM_EVENT_LOG_FILES];
>
> const struct attribute_group *groups[3];
> @@ -506,29 +479,24 @@ ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_space *space,
> void *buf, size_t bufsiz,
> size_t min_rsp_body_length, unsigned int flags,
> const char *desc);
> -int tpm_get_timeouts(struct tpm_chip *);
> int tpm_auto_startup(struct tpm_chip *chip);
>
> int tpm1_pm_suspend(struct tpm_chip *chip, u32 tpm_suspend_pcr);
> int tpm1_auto_startup(struct tpm_chip *chip);
> int tpm1_do_selftest(struct tpm_chip *chip);
> -int tpm1_get_timeouts(struct tpm_chip *chip);
> -unsigned long tpm1_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal);
> int tpm1_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash,
> const char *log_msg);
> int tpm1_pcr_read(struct tpm_chip *chip, u32 pcr_idx, u8 *res_buf);
> ssize_t tpm1_getcap(struct tpm_chip *chip, u32 subcap_id, cap_t *cap,
> const char *desc, size_t min_cap_length);
> int tpm1_get_random(struct tpm_chip *chip, u8 *out, size_t max);
> -unsigned long tpm_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal);
> int tpm_pm_suspend(struct device *dev);
> int tpm_pm_resume(struct device *dev);
>
> static inline void tpm_msleep(unsigned int delay_msec)
> {
> - usleep_range((delay_msec * 1000) - TPM_TIMEOUT_RANGE_US,
> - delay_msec * 1000);
> -};
> + usleep_range((delay_msec * 1000) - 300, delay_msec * 1000);
> +}
>
> struct tpm_chip *tpm_find_get_ops(struct tpm_chip *chip);
> __must_check int tpm_try_get_ops(struct tpm_chip *chip);
> @@ -557,7 +525,6 @@ static inline u32 tpm2_rc_value(u32 rc)
> return (rc & BIT(7)) ? rc & 0xff : rc;
> }
>
> -int tpm2_get_timeouts(struct tpm_chip *chip);
> int tpm2_pcr_read(struct tpm_chip *chip, u32 pcr_idx, u8 *res_buf);
> int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count,
> struct tpm2_digest *digests);
> @@ -575,7 +542,6 @@ ssize_t tpm2_get_tpm_pt(struct tpm_chip *chip, u32 property_id,
>
> int tpm2_auto_startup(struct tpm_chip *chip);
> void tpm2_shutdown(struct tpm_chip *chip, u16 shutdown_type);
> -unsigned long tpm2_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal);
> int tpm2_probe(struct tpm_chip *chip);
> int tpm2_find_cc(struct tpm_chip *chip, u32 cc);
> int tpm2_init_space(struct tpm_space *space);
> diff --git a/drivers/char/tpm/tpm1-cmd.c b/drivers/char/tpm/tpm1-cmd.c
> index 6f306338953b..8c5255909f07 100644
> --- a/drivers/char/tpm/tpm1-cmd.c
> +++ b/drivers/char/tpm/tpm1-cmd.c
> @@ -24,293 +24,11 @@
>
> #define TPM_MAX_ORDINAL 243
>
> -/*
> - * Array with one entry per ordinal defining the maximum amount
> - * of time the chip could take to return the result. The ordinal
> - * designation of short, medium or long is defined in a table in
> - * TCG Specification TPM Main Part 2 TPM Structures Section 17. The
> - * values of the SHORT, MEDIUM, and LONG durations are retrieved
> - * from the chip during initialization with a call to tpm_get_timeouts.
> - */
> -static const u8 tpm1_ordinal_duration[TPM_MAX_ORDINAL] = {
> - TPM_UNDEFINED, /* 0 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 5 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 10 */
> - TPM_SHORT,
> - TPM_MEDIUM,
> - TPM_LONG,
> - TPM_LONG,
> - TPM_MEDIUM, /* 15 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_MEDIUM,
> - TPM_LONG,
> - TPM_SHORT, /* 20 */
> - TPM_SHORT,
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_SHORT, /* 25 */
> - TPM_SHORT,
> - TPM_MEDIUM,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_MEDIUM, /* 30 */
> - TPM_LONG,
> - TPM_MEDIUM,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT, /* 35 */
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_MEDIUM, /* 40 */
> - TPM_LONG,
> - TPM_MEDIUM,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT, /* 45 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_LONG,
> - TPM_MEDIUM, /* 50 */
> - TPM_MEDIUM,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 55 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_MEDIUM, /* 60 */
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_MEDIUM, /* 65 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 70 */
> - TPM_SHORT,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 75 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_LONG, /* 80 */
> - TPM_UNDEFINED,
> - TPM_MEDIUM,
> - TPM_LONG,
> - TPM_SHORT,
> - TPM_UNDEFINED, /* 85 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 90 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_UNDEFINED, /* 95 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_MEDIUM, /* 100 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 105 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 110 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT, /* 115 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_LONG, /* 120 */
> - TPM_LONG,
> - TPM_MEDIUM,
> - TPM_UNDEFINED,
> - TPM_SHORT,
> - TPM_SHORT, /* 125 */
> - TPM_SHORT,
> - TPM_LONG,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT, /* 130 */
> - TPM_MEDIUM,
> - TPM_UNDEFINED,
> - TPM_SHORT,
> - TPM_MEDIUM,
> - TPM_UNDEFINED, /* 135 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 140 */
> - TPM_SHORT,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 145 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 150 */
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_UNDEFINED, /* 155 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 160 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 165 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_LONG, /* 170 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 175 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_MEDIUM, /* 180 */
> - TPM_SHORT,
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_MEDIUM, /* 185 */
> - TPM_SHORT,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 190 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 195 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 200 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT,
> - TPM_SHORT, /* 205 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_MEDIUM, /* 210 */
> - TPM_UNDEFINED,
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_MEDIUM,
> - TPM_UNDEFINED, /* 215 */
> - TPM_MEDIUM,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT,
> - TPM_SHORT, /* 220 */
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_SHORT,
> - TPM_UNDEFINED, /* 225 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 230 */
> - TPM_LONG,
> - TPM_MEDIUM,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED, /* 235 */
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_UNDEFINED,
> - TPM_SHORT, /* 240 */
> - TPM_UNDEFINED,
> - TPM_MEDIUM,
> -};
> -
> -/**
> - * tpm1_calc_ordinal_duration() - calculate the maximum command duration
> - * @chip: TPM chip to use.
> - * @ordinal: TPM command ordinal.
> - *
> - * The function returns the maximum amount of time the chip could take
> - * to return the result for a particular ordinal in jiffies.
> - *
> - * Return: A maximal duration time for an ordinal in jiffies.
> - */
> -unsigned long tpm1_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
> -{
> - int duration_idx = TPM_UNDEFINED;
> - int duration = 0;
> -
> - /*
> - * We only have a duration table for protected commands, where the upper
> - * 16 bits are 0. For the few other ordinals the fallback will be used.
> - */
> - if (ordinal < TPM_MAX_ORDINAL)
> - duration_idx = tpm1_ordinal_duration[ordinal];
> -
> - if (duration_idx != TPM_UNDEFINED)
> - duration = chip->duration[duration_idx];
> - if (duration <= 0)
> - return 2 * 60 * HZ;
> - else
> - return duration;
> -}
> -
> #define TPM_ORD_STARTUP 153
> #define TPM_ST_CLEAR 1
>
> +#define TPM_TIMEOUT_RETRY 100
> +
> /**
> * tpm_startup() - turn on the TPM
> * @chip: TPM chip to use
> @@ -342,112 +60,6 @@ static int tpm1_startup(struct tpm_chip *chip)
> return rc;
> }
>
> -int tpm1_get_timeouts(struct tpm_chip *chip)
> -{
> - cap_t cap;
> - unsigned long timeout_old[4], timeout_chip[4], timeout_eff[4];
> - ssize_t rc;
> -
> - rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap, NULL,
> - sizeof(cap.timeout));
> - if (rc == TPM_ERR_INVALID_POSTINIT) {
> - if (tpm1_startup(chip))
> - return rc;
> -
> - rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &cap,
> - "attempting to determine the timeouts",
> - sizeof(cap.timeout));
> - }
> -
> - if (rc) {
> - dev_err(&chip->dev, "A TPM error (%zd) occurred attempting to determine the timeouts\n",
> - rc);
> - return rc;
> - }
> -
> - timeout_old[0] = jiffies_to_usecs(chip->timeout_a);
> - timeout_old[1] = jiffies_to_usecs(chip->timeout_b);
> - timeout_old[2] = jiffies_to_usecs(chip->timeout_c);
> - timeout_old[3] = jiffies_to_usecs(chip->timeout_d);
> - timeout_chip[0] = be32_to_cpu(cap.timeout.a);
> - timeout_chip[1] = be32_to_cpu(cap.timeout.b);
> - timeout_chip[2] = be32_to_cpu(cap.timeout.c);
> - timeout_chip[3] = be32_to_cpu(cap.timeout.d);
> - memcpy(timeout_eff, timeout_chip, sizeof(timeout_eff));
> -
> - /*
> - * Provide ability for vendor overrides of timeout values in case
> - * of misreporting.
> - */
> - if (chip->ops->update_timeouts)
> - chip->timeout_adjusted =
> - chip->ops->update_timeouts(chip, timeout_eff);
> -
> - if (!chip->timeout_adjusted) {
> - /* Restore default if chip reported 0 */
> - unsigned int i;
> -
> - for (i = 0; i < ARRAY_SIZE(timeout_eff); i++) {
> - if (timeout_eff[i])
> - continue;
> -
> - timeout_eff[i] = timeout_old[i];
> - chip->timeout_adjusted = true;
> - }
> -
> - if (timeout_eff[0] != 0 && timeout_eff[0] < 1000) {
> - /* timeouts in msec rather usec */
> - for (i = 0; i != ARRAY_SIZE(timeout_eff); i++)
> - timeout_eff[i] *= 1000;
> - chip->timeout_adjusted = true;
> - }
> - }
> -
> - /* Report adjusted timeouts */
> - if (chip->timeout_adjusted) {
> - dev_info(&chip->dev, HW_ERR "Adjusting reported timeouts: A %lu->%luus B %lu->%luus C %lu->%luus D %lu->%luus\n",
> - timeout_chip[0], timeout_eff[0],
> - timeout_chip[1], timeout_eff[1],
> - timeout_chip[2], timeout_eff[2],
> - timeout_chip[3], timeout_eff[3]);
> - }
> -
> - chip->timeout_a = usecs_to_jiffies(timeout_eff[0]);
> - chip->timeout_b = usecs_to_jiffies(timeout_eff[1]);
> - chip->timeout_c = usecs_to_jiffies(timeout_eff[2]);
> - chip->timeout_d = usecs_to_jiffies(timeout_eff[3]);
> -
> - rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_DURATION, &cap,
> - "attempting to determine the durations",
> - sizeof(cap.duration));
> - if (rc)
> - return rc;
> -
> - chip->duration[TPM_SHORT] =
> - usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_short));
> - chip->duration[TPM_MEDIUM] =
> - usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_medium));
> - chip->duration[TPM_LONG] =
> - usecs_to_jiffies(be32_to_cpu(cap.duration.tpm_long));
> - chip->duration[TPM_LONG_LONG] = 0; /* not used under 1.2 */
> -
> - /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above
> - * value wrong and apparently reports msecs rather than usecs. So we
> - * fix up the resulting too-small TPM_SHORT value to make things work.
> - * We also scale the TPM_MEDIUM and -_LONG values by 1000.
> - */
> - if (chip->duration[TPM_SHORT] < (HZ / 100)) {
> - chip->duration[TPM_SHORT] = HZ;
> - chip->duration[TPM_MEDIUM] *= 1000;
> - chip->duration[TPM_LONG] *= 1000;
> - chip->duration_adjusted = true;
> - dev_info(&chip->dev, "Adjusting TPM timeout parameters.");
> - }
> -
> - chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
> - return 0;
> -}
> -
> #define TPM_ORD_PCR_EXTEND 20
> int tpm1_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash,
> const char *log_msg)
> @@ -639,12 +251,9 @@ int tpm1_do_selftest(struct tpm_chip *chip)
> int rc;
> unsigned int loops;
> unsigned int delay_msec = 100;
> - unsigned long duration;
> u8 dummy[TPM_DIGEST_SIZE];
>
> - duration = tpm1_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);
> -
> - loops = jiffies_to_msecs(duration) / delay_msec;
> + loops = TPM_UNIVERSAL_TIMEOUT_MS / delay_msec;
>
> rc = tpm1_continue_selftest(chip);
> if (rc == TPM_ERR_INVALID_POSTINIT) {
> @@ -698,11 +307,31 @@ EXPORT_SYMBOL_GPL(tpm1_do_selftest);
> */
> int tpm1_auto_startup(struct tpm_chip *chip)
> {
> + cap_t unused;
> int rc;
>
> - rc = tpm1_get_timeouts(chip);
> - if (rc)
> - goto out;
> + /*
> + * We now ignore the timeouts the device specifies, but the original
> + * initialization sequence began by asking for them so we still do.
> + */
> +
> + rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &unused, NULL,
> + sizeof(unused.timeout));
> + if (rc == TPM_ERR_INVALID_POSTINIT) {
> + if (tpm1_startup(chip))
> + return rc;
> +
> + rc = tpm1_getcap(chip, TPM_CAP_PROP_TIS_TIMEOUT, &unused,
> + "attempting to determine the timeouts",
> + sizeof(unused.timeout));
> + }
> +
> +
> + if (rc) {
> + dev_err(&chip->dev, "TPM failed to init (%d)\n", rc);
> + return rc;
> + }
> +
> rc = tpm1_do_selftest(chip);
> if (rc) {
> dev_err(&chip->dev, "TPM self test failed\n");
> diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c
> index a6bec13afa69..ab4d6d42888e 100644
> --- a/drivers/char/tpm/tpm2-cmd.c
> +++ b/drivers/char/tpm/tpm2-cmd.c
> @@ -40,122 +40,6 @@ static struct tpm2_hash tpm2_hash_map[] = {
> {HASH_ALGO_SM3_256, TPM2_ALG_SM3_256},
> };
>
> -int tpm2_get_timeouts(struct tpm_chip *chip)
> -{
> - /* Fixed timeouts for TPM2 */
> - chip->timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A);
> - chip->timeout_b = msecs_to_jiffies(TPM2_TIMEOUT_B);
> - chip->timeout_c = msecs_to_jiffies(TPM2_TIMEOUT_C);
> - chip->timeout_d = msecs_to_jiffies(TPM2_TIMEOUT_D);
> -
> - /* PTP spec timeouts */
> - chip->duration[TPM_SHORT] = msecs_to_jiffies(TPM2_DURATION_SHORT);
> - chip->duration[TPM_MEDIUM] = msecs_to_jiffies(TPM2_DURATION_MEDIUM);
> - chip->duration[TPM_LONG] = msecs_to_jiffies(TPM2_DURATION_LONG);
> -
> - /* Key creation commands long timeouts */
> - chip->duration[TPM_LONG_LONG] =
> - msecs_to_jiffies(TPM2_DURATION_LONG_LONG);
> -
> - chip->flags |= TPM_CHIP_FLAG_HAVE_TIMEOUTS;
> -
> - return 0;
> -}
> -
> -/**
> - * tpm2_ordinal_duration_index() - returns an index to the chip duration table
> - * @ordinal: TPM command ordinal.
> - *
> - * The function returns an index to the chip duration table
> - * (enum tpm_duration), that describes the maximum amount of
> - * time the chip could take to return the result for a particular ordinal.
> - *
> - * The values of the MEDIUM, and LONG durations are taken
> - * from the PC Client Profile (PTP) specification (750, 2000 msec)
> - *
> - * LONG_LONG is for commands that generates keys which empirically takes
> - * a longer time on some systems.
> - *
> - * Return:
> - * * TPM_MEDIUM
> - * * TPM_LONG
> - * * TPM_LONG_LONG
> - * * TPM_UNDEFINED
> - */
> -static u8 tpm2_ordinal_duration_index(u32 ordinal)
> -{
> - switch (ordinal) {
> - /* Startup */
> - case TPM2_CC_STARTUP: /* 144 */
> - return TPM_MEDIUM;
> -
> - case TPM2_CC_SELF_TEST: /* 143 */
> - return TPM_LONG;
> -
> - case TPM2_CC_GET_RANDOM: /* 17B */
> - return TPM_LONG;
> -
> - case TPM2_CC_SEQUENCE_UPDATE: /* 15C */
> - return TPM_MEDIUM;
> - case TPM2_CC_SEQUENCE_COMPLETE: /* 13E */
> - return TPM_MEDIUM;
> - case TPM2_CC_EVENT_SEQUENCE_COMPLETE: /* 185 */
> - return TPM_MEDIUM;
> - case TPM2_CC_HASH_SEQUENCE_START: /* 186 */
> - return TPM_MEDIUM;
> -
> - case TPM2_CC_VERIFY_SIGNATURE: /* 177 */
> - return TPM_LONG;
> -
> - case TPM2_CC_PCR_EXTEND: /* 182 */
> - return TPM_MEDIUM;
> -
> - case TPM2_CC_HIERARCHY_CONTROL: /* 121 */
> - return TPM_LONG;
> - case TPM2_CC_HIERARCHY_CHANGE_AUTH: /* 129 */
> - return TPM_LONG;
> -
> - case TPM2_CC_GET_CAPABILITY: /* 17A */
> - return TPM_MEDIUM;
> -
> - case TPM2_CC_NV_READ: /* 14E */
> - return TPM_LONG;
> -
> - case TPM2_CC_CREATE_PRIMARY: /* 131 */
> - return TPM_LONG_LONG;
> - case TPM2_CC_CREATE: /* 153 */
> - return TPM_LONG_LONG;
> - case TPM2_CC_CREATE_LOADED: /* 191 */
> - return TPM_LONG_LONG;
> -
> - default:
> - return TPM_UNDEFINED;
> - }
> -}
> -
> -/**
> - * tpm2_calc_ordinal_duration() - calculate the maximum command duration
> - * @chip: TPM chip to use.
> - * @ordinal: TPM command ordinal.
> - *
> - * The function returns the maximum amount of time the chip could take
> - * to return the result for a particular ordinal in jiffies.
> - *
> - * Return: A maximal duration time for an ordinal in jiffies.
> - */
> -unsigned long tpm2_calc_ordinal_duration(struct tpm_chip *chip, u32 ordinal)
> -{
> - unsigned int index;
> -
> - index = tpm2_ordinal_duration_index(ordinal);
> -
> - if (index != TPM_UNDEFINED)
> - return chip->duration[index];
> - else
> - return msecs_to_jiffies(TPM2_DURATION_DEFAULT);
> -}
> -
> -
> struct tpm2_pcr_read_out {
> __be32 update_cnt;
> __be32 pcr_selects_cnt;
> @@ -987,10 +871,6 @@ int tpm2_auto_startup(struct tpm_chip *chip)
> {
> int rc;
>
> - rc = tpm2_get_timeouts(chip);
> - if (rc)
> - goto out;
> -
> rc = tpm2_do_selftest(chip);
> if (rc && rc != TPM2_RC_INITIALIZE)
> goto out;
> diff --git a/drivers/char/tpm/tpm_crb.c b/drivers/char/tpm/tpm_crb.c
> index 36952ef98f90..f683667ed0e4 100644
> --- a/drivers/char/tpm/tpm_crb.c
> +++ b/drivers/char/tpm/tpm_crb.c
> @@ -112,14 +112,13 @@ struct tpm2_crb_smc {
> u32 smc_func_id;
> };
>
> -static bool crb_wait_for_reg_32(u32 __iomem *reg, u32 mask, u32 value,
> - unsigned long timeout)
> +static bool crb_wait_for_reg_32(u32 __iomem *reg, u32 mask, u32 value)
> {
> ktime_t start;
> ktime_t stop;
>
> start = ktime_get();
> - stop = ktime_add(start, ms_to_ktime(timeout));
> + stop = ktime_add(start, ms_to_ktime(TPM_UNIVERSAL_TIMEOUT_MS));
>
> do {
> if ((ioread32(reg) & mask) == value)
> @@ -157,9 +156,7 @@ static int __crb_go_idle(struct device *dev, struct crb_priv *priv)
> iowrite32(CRB_CTRL_REQ_GO_IDLE, &priv->regs_t->ctrl_req);
>
> if (!crb_wait_for_reg_32(&priv->regs_t->ctrl_req,
> - CRB_CTRL_REQ_GO_IDLE/* mask */,
> - 0, /* value */
> - TPM2_TIMEOUT_C)) {
> + CRB_CTRL_REQ_GO_IDLE, 0)) {
> dev_warn(dev, "goIdle timed out\n");
> return -ETIME;
> }
> @@ -183,7 +180,6 @@ static int crb_go_idle(struct tpm_chip *chip)
> *
> * Write CRB_CTRL_REQ_CMD_READY to TPM_CRB_CTRL_REQ
> * and poll till the device acknowledge it by clearing the bit.
> - * The device should respond within TIMEOUT_C.
> *
> * The function does nothing for devices with ACPI-start method
> * or SMC-start method.
> @@ -199,9 +195,7 @@ static int __crb_cmd_ready(struct device *dev, struct crb_priv *priv)
>
> iowrite32(CRB_CTRL_REQ_CMD_READY, &priv->regs_t->ctrl_req);
> if (!crb_wait_for_reg_32(&priv->regs_t->ctrl_req,
> - CRB_CTRL_REQ_CMD_READY /* mask */,
> - 0, /* value */
> - TPM2_TIMEOUT_C)) {
> + CRB_CTRL_REQ_CMD_READY, 0)) {
> dev_warn(dev, "cmdReady timed out\n");
> return -ETIME;
> }
> @@ -227,8 +221,7 @@ static int __crb_request_locality(struct device *dev,
> return 0;
>
> iowrite32(CRB_LOC_CTRL_REQUEST_ACCESS, &priv->regs_h->loc_ctrl);
> - if (!crb_wait_for_reg_32(&priv->regs_h->loc_state, value, value,
> - TPM2_TIMEOUT_C)) {
> + if (!crb_wait_for_reg_32(&priv->regs_h->loc_state, value, value)) {
> dev_warn(dev, "TPM_LOC_STATE_x.requestAccess timed out\n");
> return -ETIME;
> }
> @@ -254,8 +247,7 @@ static int __crb_relinquish_locality(struct device *dev,
> return 0;
>
> iowrite32(CRB_LOC_CTRL_RELINQUISH, &priv->regs_h->loc_ctrl);
> - if (!crb_wait_for_reg_32(&priv->regs_h->loc_state, mask, value,
> - TPM2_TIMEOUT_C)) {
> + if (!crb_wait_for_reg_32(&priv->regs_h->loc_state, mask, value)) {
> dev_warn(dev, "TPM_LOC_STATE_x.requestAccess timed out\n");
> return -ETIME;
> }
> diff --git a/drivers/char/tpm/tpm_i2c_atmel.c b/drivers/char/tpm/tpm_i2c_atmel.c
> index 95ce2e9ccdc6..b058829eccf8 100644
> --- a/drivers/char/tpm/tpm_i2c_atmel.c
> +++ b/drivers/char/tpm/tpm_i2c_atmel.c
> @@ -169,12 +169,6 @@ static int i2c_atmel_probe(struct i2c_client *client,
> if (!priv)
> return -ENOMEM;
>
> - /* Default timeouts */
> - chip->timeout_a = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
> - chip->timeout_b = msecs_to_jiffies(TPM_I2C_LONG_TIMEOUT);
> - chip->timeout_c = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
> - chip->timeout_d = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
> -
> dev_set_drvdata(&chip->dev, priv);
>
> /* There is no known way to probe for this device, and all version
> diff --git a/drivers/char/tpm/tpm_i2c_infineon.c b/drivers/char/tpm/tpm_i2c_infineon.c
> index 9086edc9066b..6354cea0036b 100644
> --- a/drivers/char/tpm/tpm_i2c_infineon.c
> +++ b/drivers/char/tpm/tpm_i2c_infineon.c
> @@ -50,7 +50,7 @@
> #define SLEEP_DURATION_RESET_HI 2600
>
> /* we want to use usleep_range instead of msleep for the 5ms TPM_TIMEOUT */
> -#define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT * 1000)
> +#define TPM_TIMEOUT_US_LOW (TPM_TIMEOUT_POLL_MS * 1000)
> #define TPM_TIMEOUT_US_HI (TPM_TIMEOUT_US_LOW + 2000)
>
> /* expected value for DIDVID register */
> @@ -304,11 +304,6 @@ enum tis_status {
> TPM_STS_DATA_EXPECT = 0x08,
> };
>
> -enum tis_defaults {
> - TIS_SHORT_TIMEOUT = 750, /* ms */
> - TIS_LONG_TIMEOUT = 2000, /* 2 sec */
> -};
> -
> #define TPM_ACCESS(l) (0x0000 | ((l) << 4))
> #define TPM_STS(l) (0x0001 | ((l) << 4))
> #define TPM_DATA_FIFO(l) (0x0005 | ((l) << 4))
> @@ -357,7 +352,7 @@ static int request_locality(struct tpm_chip *chip, int loc)
> iic_tpm_write(TPM_ACCESS(loc), &buf, 1);
>
> /* wait for burstcount */
> - stop = jiffies + chip->timeout_a;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> if (check_locality(chip, loc))
> return loc;
> @@ -399,7 +394,7 @@ static ssize_t get_burstcount(struct tpm_chip *chip)
>
> /* wait for burstcount */
> /* which timeout value, spec has 2 answers (c & d) */
> - stop = jiffies + chip->timeout_d;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> /* Note: STS is little endian */
> if (iic_tpm_read(TPM_STS(tpm_dev.locality)+1, buf, 3) < 0)
> @@ -415,8 +410,7 @@ static ssize_t get_burstcount(struct tpm_chip *chip)
> return -EBUSY;
> }
>
> -static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
> - int *status)
> +static int wait_for_stat(struct tpm_chip *chip, u8 mask, int *status)
> {
> unsigned long stop;
>
> @@ -425,7 +419,7 @@ static int wait_for_stat(struct tpm_chip *chip, u8 mask, unsigned long timeout,
> if ((*status != 0xFF) && (*status & mask) == mask)
> return 0;
>
> - stop = jiffies + timeout;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> /* since we just checked the status, give the TPM some time */
> usleep_range(TPM_TIMEOUT_US_LOW, TPM_TIMEOUT_US_HI);
> @@ -502,7 +496,7 @@ static int tpm_tis_i2c_recv(struct tpm_chip *chip, u8 *buf, size_t count)
> goto out;
> }
>
> - wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
> + wait_for_stat(chip, TPM_STS_VALID, &status);
> if (status & TPM_STS_DATA_AVAIL) { /* retry? */
> dev_err(&chip->dev, "Error left over data\n");
> size = -EIO;
> @@ -536,9 +530,7 @@ static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
> status = tpm_tis_i2c_status(chip);
> if ((status & TPM_STS_COMMAND_READY) == 0) {
> tpm_tis_i2c_ready(chip);
> - if (wait_for_stat
> - (chip, TPM_STS_COMMAND_READY,
> - chip->timeout_b, &status) < 0) {
> + if (wait_for_stat(chip, TPM_STS_COMMAND_READY, &status) < 0) {
> rc = -ETIME;
> goto out_err;
> }
> @@ -567,8 +559,7 @@ static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
> goto out_err;
> }
>
> - wait_for_stat(chip, TPM_STS_VALID,
> - chip->timeout_c, &status);
> + wait_for_stat(chip, TPM_STS_VALID, &status);
>
> if ((status & TPM_STS_DATA_EXPECT) == 0) {
> rc = -EIO;
> @@ -578,7 +569,7 @@ static int tpm_tis_i2c_send(struct tpm_chip *chip, u8 *buf, size_t len)
>
> /* write last byte */
> iic_tpm_write(TPM_DATA_FIFO(tpm_dev.locality), &(buf[count]), 1);
> - wait_for_stat(chip, TPM_STS_VALID, chip->timeout_c, &status);
> + wait_for_stat(chip, TPM_STS_VALID, &status);
> if ((status & TPM_STS_DATA_EXPECT) != 0) {
> rc = -EIO;
> goto out_err;
> @@ -624,12 +615,6 @@ static int tpm_tis_i2c_init(struct device *dev)
> if (IS_ERR(chip))
> return PTR_ERR(chip);
>
> - /* Default timeouts */
> - chip->timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
> - chip->timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT);
> - chip->timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
> - chip->timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT);
> -
> if (request_locality(chip, 0) != 0) {
> dev_err(dev, "could not request locality\n");
> rc = -ENODEV;
> diff --git a/drivers/char/tpm/tpm_i2c_nuvoton.c b/drivers/char/tpm/tpm_i2c_nuvoton.c
> index 217f7f1cbde8..38ab38b8c4e5 100644
> --- a/drivers/char/tpm/tpm_i2c_nuvoton.c
> +++ b/drivers/char/tpm/tpm_i2c_nuvoton.c
> @@ -149,7 +149,7 @@ static void i2c_nuvoton_ready(struct tpm_chip *chip)
> static int i2c_nuvoton_get_burstcount(struct i2c_client *client,
> struct tpm_chip *chip)
> {
> - unsigned long stop = jiffies + chip->timeout_d;
> + unsigned long stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> s32 status;
> int burst_count = -1;
> u8 data;
> @@ -182,7 +182,7 @@ static bool i2c_nuvoton_check_status(struct tpm_chip *chip, u8 mask, u8 value)
> }
>
> static int i2c_nuvoton_wait_for_stat(struct tpm_chip *chip, u8 mask, u8 value,
> - u32 timeout, wait_queue_head_t *queue)
> + wait_queue_head_t *queue)
> {
> if ((chip->flags & TPM_CHIP_FLAG_IRQ) && queue) {
> s32 rc;
> @@ -192,7 +192,7 @@ static int i2c_nuvoton_wait_for_stat(struct tpm_chip *chip, u8 mask, u8 value,
> enable_irq(priv->irq);
> rc = wait_event_interruptible_timeout(*queue,
> cur_intrs != priv->intrs,
> - timeout);
> + TPM_UNIVERSAL_TIMEOUT_JIFFIES);
> if (rc > 0)
> return 0;
> /* At this point we know that the SINT pin is asserted, so we
> @@ -208,7 +208,7 @@ static int i2c_nuvoton_wait_for_stat(struct tpm_chip *chip, u8 mask, u8 value,
>
> /* use polling to wait for the event */
> ten_msec = jiffies + usecs_to_jiffies(TPM_I2C_RETRY_DELAY_LONG);
> - stop = jiffies + timeout;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> if (time_before(jiffies, ten_msec))
> usleep_range(TPM_I2C_RETRY_DELAY_SHORT,
> @@ -230,13 +230,13 @@ static int i2c_nuvoton_wait_for_stat(struct tpm_chip *chip, u8 mask, u8 value,
> }
>
> /* wait for dataAvail field to be set in the TPM_STS register */
> -static int i2c_nuvoton_wait_for_data_avail(struct tpm_chip *chip, u32 timeout,
> +static int i2c_nuvoton_wait_for_data_avail(struct tpm_chip *chip,
> wait_queue_head_t *queue)
> {
> return i2c_nuvoton_wait_for_stat(chip,
> TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> - timeout, queue);
> + queue);
> }
>
> /* Read @count bytes into @buf from TPM_RD_FIFO register */
> @@ -249,7 +249,6 @@ static int i2c_nuvoton_recv_data(struct i2c_client *client,
>
> while (size < count &&
> i2c_nuvoton_wait_for_data_avail(chip,
> - chip->timeout_c,
> &priv->read_queue) == 0) {
> burst_count = i2c_nuvoton_get_burstcount(client, chip);
> if (burst_count < 0) {
> @@ -303,7 +302,7 @@ static int i2c_nuvoton_recv(struct tpm_chip *chip, u8 *buf, size_t count)
> * tag, paramsize, and result
> */
> status = i2c_nuvoton_wait_for_data_avail(
> - chip, chip->timeout_c, &priv->read_queue);
> + chip, &priv->read_queue);
> if (status != 0) {
> dev_err(dev, "%s() timeout on dataAvail\n", __func__);
> size = -ETIMEDOUT;
> @@ -343,8 +342,7 @@ static int i2c_nuvoton_recv(struct tpm_chip *chip, u8 *buf, size_t count)
> }
> if (i2c_nuvoton_wait_for_stat(
> chip, TPM_STS_VALID | TPM_STS_DATA_AVAIL,
> - TPM_STS_VALID, chip->timeout_c,
> - NULL)) {
> + TPM_STS_VALID, NULL)) {
> dev_err(dev, "%s() error left over data\n", __func__);
> size = -ETIMEDOUT;
> continue;
> @@ -369,15 +367,13 @@ static int i2c_nuvoton_send(struct tpm_chip *chip, u8 *buf, size_t len)
> struct device *dev = chip->dev.parent;
> struct i2c_client *client = to_i2c_client(dev);
> u32 ordinal;
> - unsigned long duration;
> size_t count = 0;
> int burst_count, bytes2write, retries, rc = -EIO;
>
> for (retries = 0; retries < TPM_RETRY; retries++) {
> i2c_nuvoton_ready(chip);
> if (i2c_nuvoton_wait_for_stat(chip, TPM_STS_COMMAND_READY,
> - TPM_STS_COMMAND_READY,
> - chip->timeout_b, NULL)) {
> + TPM_STS_COMMAND_READY, NULL)) {
> dev_err(dev, "%s() timeout on commandReady\n",
> __func__);
> rc = -EIO;
> @@ -409,7 +405,6 @@ static int i2c_nuvoton_send(struct tpm_chip *chip, u8 *buf, size_t len)
> TPM_STS_EXPECT,
> TPM_STS_VALID |
> TPM_STS_EXPECT,
> - chip->timeout_c,
> NULL);
> if (rc < 0) {
> dev_err(dev, "%s() timeout on Expect\n",
> @@ -433,8 +428,7 @@ static int i2c_nuvoton_send(struct tpm_chip *chip, u8 *buf, size_t len)
> dev_dbg(dev, "%s(last): %02x", __func__, buf[count]);
> rc = i2c_nuvoton_wait_for_stat(chip,
> TPM_STS_VALID | TPM_STS_EXPECT,
> - TPM_STS_VALID,
> - chip->timeout_c, NULL);
> + TPM_STS_VALID, NULL);
> if (rc) {
> dev_err(dev, "%s() timeout on Expect to clear\n",
> __func__);
> @@ -456,12 +450,11 @@ static int i2c_nuvoton_send(struct tpm_chip *chip, u8 *buf, size_t len)
> return rc;
> }
> ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
> - duration = tpm_calc_ordinal_duration(chip, ordinal);
>
> - rc = i2c_nuvoton_wait_for_data_avail(chip, duration, &priv->read_queue);
> + rc = i2c_nuvoton_wait_for_data_avail(chip, &priv->read_queue);
> if (rc) {
> - dev_err(dev, "%s() timeout command duration %ld\n",
> - __func__, duration);
> + dev_err(dev, "%s() timeout command duration %d\n",
> + __func__, TPM_UNIVERSAL_TIMEOUT_MS);
> i2c_nuvoton_ready(chip);
> return rc;
> }
> @@ -572,12 +565,6 @@ static int i2c_nuvoton_probe(struct i2c_client *client,
>
> init_waitqueue_head(&priv->read_queue);
>
> - /* Default timeouts */
> - chip->timeout_a = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
> - chip->timeout_b = msecs_to_jiffies(TPM_I2C_LONG_TIMEOUT);
> - chip->timeout_c = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
> - chip->timeout_d = msecs_to_jiffies(TPM_I2C_SHORT_TIMEOUT);
> -
> dev_set_drvdata(&chip->dev, priv);
>
> /*
> @@ -605,7 +592,6 @@ static int i2c_nuvoton_probe(struct i2c_client *client,
> rc = i2c_nuvoton_wait_for_stat(chip,
> TPM_STS_COMMAND_READY,
> TPM_STS_COMMAND_READY,
> - chip->timeout_b,
> NULL);
> if (rc == 0) {
> /*
> @@ -622,7 +608,7 @@ static int i2c_nuvoton_probe(struct i2c_client *client,
> i2c_nuvoton_ready(chip);
> } else {
> /*
> - * timeout_b reached - command was
> + * timeout reached - command was
> * aborted. TIS should now be in idle state -
> * only TPM_STS_VALID should be set
> */
> diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
> index 5d6cce74cd3f..2cfe79458bdd 100644
> --- a/drivers/char/tpm/tpm_nsc.c
> +++ b/drivers/char/tpm/tpm_nsc.c
> @@ -85,7 +85,7 @@ static int wait_for_stat(struct tpm_chip *chip, u8 mask, u8 val, u8 * data)
> /* wait for status */
> stop = jiffies + 10 * HZ;
> do {
> - msleep(TPM_TIMEOUT);
> + msleep(TPM_TIMEOUT_POLL_MS);
> *data = inb(priv->base + 1);
> if ((*data & mask) == val)
> return 0;
> @@ -109,9 +109,9 @@ static int nsc_wait_for_ready(struct tpm_chip *chip)
> return 0;
>
> /* wait for status */
> - stop = jiffies + 100;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> - msleep(TPM_TIMEOUT);
> + msleep(TPM_TIMEOUT_POLL_MS);
> status = inb(priv->base + NSC_STATUS);
> if (status & NSC_STATUS_OBF)
> status = inb(priv->base + NSC_DATA);
> diff --git a/drivers/char/tpm/tpm_tis_core.c b/drivers/char/tpm/tpm_tis_core.c
> index bf7e49cfa643..0a592efb28c4 100644
> --- a/drivers/char/tpm/tpm_tis_core.c
> +++ b/drivers/char/tpm/tpm_tis_core.c
> @@ -49,10 +49,9 @@ static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
> }
>
> static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
> - unsigned long timeout, wait_queue_head_t *queue,
> - bool check_cancel)
> + wait_queue_head_t *queue, bool check_cancel)
> {
> - unsigned long stop;
> + unsigned long stop, timeout;
> long rc;
> u8 status;
> bool canceled = false;
> @@ -62,8 +61,7 @@ static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
> if ((status & mask) == mask)
> return 0;
>
> - stop = jiffies + timeout;
> -
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> if (chip->flags & TPM_CHIP_FLAG_IRQ) {
> again:
> timeout = stop - jiffies;
> @@ -102,7 +100,7 @@ static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
> static int wait_startup(struct tpm_chip *chip, int l)
> {
> struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
> - unsigned long stop = jiffies + chip->timeout_a;
> + unsigned long stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
>
> do {
> int rc;
> @@ -114,7 +112,7 @@ static int wait_startup(struct tpm_chip *chip, int l)
>
> if (access & TPM_ACCESS_VALID)
> return 0;
> - tpm_msleep(TPM_TIMEOUT);
> + tpm_msleep(TPM_TIMEOUT_POLL_MS);
> } while (time_before(jiffies, stop));
> return -1;
> }
> @@ -163,7 +161,7 @@ static int release_locality(struct tpm_chip *chip, int l)
>
> tpm_tis_write8(priv, TPM_ACCESS(l), TPM_ACCESS_ACTIVE_LOCALITY);
>
> - stop = jiffies + chip->timeout_a;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
>
> if (chip->flags & TPM_CHIP_FLAG_IRQ) {
> again:
> @@ -186,7 +184,7 @@ static int release_locality(struct tpm_chip *chip, int l)
> do {
> if (locality_inactive(chip, l))
> return 0;
> - tpm_msleep(TPM_TIMEOUT);
> + tpm_msleep(TPM_TIMEOUT_POLL_MS);
> } while (time_before(jiffies, stop));
> }
> return -1;
> @@ -205,7 +203,7 @@ static int request_locality(struct tpm_chip *chip, int l)
> if (rc < 0)
> return rc;
>
> - stop = jiffies + chip->timeout_a;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
>
> if (chip->flags & TPM_CHIP_FLAG_IRQ) {
> again:
> @@ -227,7 +225,7 @@ static int request_locality(struct tpm_chip *chip, int l)
> do {
> if (check_locality(chip, l))
> return l;
> - tpm_msleep(TPM_TIMEOUT);
> + tpm_msleep(TPM_TIMEOUT_POLL_MS);
> } while (time_before(jiffies, stop));
> }
> return -1;
> @@ -262,10 +260,7 @@ static int get_burstcount(struct tpm_chip *chip)
> u32 value;
>
> /* wait for burstcount */
> - if (chip->flags & TPM_CHIP_FLAG_TPM2)
> - stop = jiffies + chip->timeout_a;
> - else
> - stop = jiffies + chip->timeout_d;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
> do {
> rc = tpm_tis_read32(priv, TPM_STS(priv->locality), &value);
> if (rc < 0)
> @@ -287,7 +282,6 @@ static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
> while (size < count) {
> rc = wait_for_tpm_stat(chip,
> TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> - chip->timeout_c,
> &priv->read_queue, true);
> if (rc < 0)
> return rc;
> @@ -341,7 +335,7 @@ static int tpm_tis_recv(struct tpm_chip *chip, u8 *buf, size_t count)
> goto out;
> }
>
> - if (wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
> + if (wait_for_tpm_stat(chip, TPM_STS_VALID,
> &priv->int_queue, false) < 0) {
> size = -ETIME;
> goto out;
> @@ -374,7 +368,7 @@ static int tpm_tis_send_data(struct tpm_chip *chip, const u8 *buf, size_t len)
> if ((status & TPM_STS_COMMAND_READY) == 0) {
> tpm_tis_ready(chip);
> if (wait_for_tpm_stat
> - (chip, TPM_STS_COMMAND_READY, chip->timeout_b,
> + (chip, TPM_STS_COMMAND_READY,
> &priv->int_queue, false) < 0) {
> rc = -ETIME;
> goto out_err;
> @@ -396,7 +390,7 @@ static int tpm_tis_send_data(struct tpm_chip *chip, const u8 *buf, size_t len)
>
> count += burstcnt;
>
> - if (wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
> + if (wait_for_tpm_stat(chip, TPM_STS_VALID,
> &priv->int_queue, false) < 0) {
> rc = -ETIME;
> goto out_err;
> @@ -413,7 +407,7 @@ static int tpm_tis_send_data(struct tpm_chip *chip, const u8 *buf, size_t len)
> if (rc < 0)
> goto out_err;
>
> - if (wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
> + if (wait_for_tpm_stat(chip, TPM_STS_VALID,
> &priv->int_queue, false) < 0) {
> rc = -ETIME;
> goto out_err;
> @@ -459,7 +453,6 @@ static int tpm_tis_send_main(struct tpm_chip *chip, const u8 *buf, size_t len)
> struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
> int rc;
> u32 ordinal;
> - unsigned long dur;
>
> rc = tpm_tis_send_data(chip, buf, len);
> if (rc < 0)
> @@ -473,9 +466,8 @@ static int tpm_tis_send_main(struct tpm_chip *chip, const u8 *buf, size_t len)
> if (chip->flags & TPM_CHIP_FLAG_IRQ) {
> ordinal = be32_to_cpu(*((__be32 *) (buf + 6)));
>
> - dur = tpm_calc_ordinal_duration(chip, ordinal);
> if (wait_for_tpm_stat
> - (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID, dur,
> + (chip, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> &priv->read_queue, false) < 0) {
> rc = -ETIME;
> goto out_err;
> @@ -510,48 +502,6 @@ static int tpm_tis_send(struct tpm_chip *chip, u8 *buf, size_t len)
> return rc;
> }
>
> -struct tis_vendor_timeout_override {
> - u32 did_vid;
> - unsigned long timeout_us[4];
> -};
> -
> -static const struct tis_vendor_timeout_override vendor_timeout_overrides[] = {
> - /* Atmel 3204 */
> - { 0x32041114, { (TIS_SHORT_TIMEOUT*1000), (TIS_LONG_TIMEOUT*1000),
> - (TIS_SHORT_TIMEOUT*1000), (TIS_SHORT_TIMEOUT*1000) } },
> -};
> -
> -static bool tpm_tis_update_timeouts(struct tpm_chip *chip,
> - unsigned long *timeout_cap)
> -{
> - struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
> - int i, rc;
> - u32 did_vid;
> -
> - if (chip->ops->clk_enable != NULL)
> - chip->ops->clk_enable(chip, true);
> -
> - rc = tpm_tis_read32(priv, TPM_DID_VID(0), &did_vid);
> - if (rc < 0)
> - goto out;
> -
> - for (i = 0; i != ARRAY_SIZE(vendor_timeout_overrides); i++) {
> - if (vendor_timeout_overrides[i].did_vid != did_vid)
> - continue;
> - memcpy(timeout_cap, vendor_timeout_overrides[i].timeout_us,
> - sizeof(vendor_timeout_overrides[i].timeout_us));
> - rc = true;
> - }
> -
> - rc = false;
> -
> -out:
> - if (chip->ops->clk_enable != NULL)
> - chip->ops->clk_enable(chip, false);
> -
> - return rc;
> -}
> -
> /*
> * Early probing for iTPM with STS_DATA_EXPECT flaw.
> * Try sending command without itpm flag set and if that
> @@ -842,7 +792,6 @@ static const struct tpm_class_ops tpm_tis = {
> .recv = tpm_tis_recv,
> .send = tpm_tis_send,
> .cancel = tpm_tis_ready,
> - .update_timeouts = tpm_tis_update_timeouts,
> .req_complete_mask = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> .req_complete_val = TPM_STS_DATA_AVAIL | TPM_STS_VALID,
> .req_canceled = tpm_tis_req_canceled,
> @@ -873,11 +822,6 @@ int tpm_tis_core_init(struct device *dev, struct tpm_tis_data *priv, int irq,
>
> chip->hwrng.quality = priv->rng_quality;
>
> - /* Maximum timeouts */
> - chip->timeout_a = msecs_to_jiffies(TIS_TIMEOUT_A_MAX);
> - chip->timeout_b = msecs_to_jiffies(TIS_TIMEOUT_B_MAX);
> - chip->timeout_c = msecs_to_jiffies(TIS_TIMEOUT_C_MAX);
> - chip->timeout_d = msecs_to_jiffies(TIS_TIMEOUT_D_MAX);
> priv->phy_ops = phy_ops;
> dev_set_drvdata(&chip->dev, priv);
>
> @@ -967,16 +911,6 @@ int tpm_tis_core_init(struct device *dev, struct tpm_tis_data *priv, int irq,
> init_waitqueue_head(&priv->read_queue);
> init_waitqueue_head(&priv->int_queue);
> if (irq != -1) {
> - /* Before doing irq testing issue a command to the TPM in polling mode
> - * to make sure it works. May as well use that command to set the
> - * proper timeouts for the driver.
> - */
> - if (tpm_get_timeouts(chip)) {
> - dev_err(dev, "Could not get TPM timeouts and durations\n");
> - rc = -ENODEV;
> - goto out_err;
> - }
> -
> if (irq) {
> tpm_tis_probe_irq_single(chip, intmask, IRQF_SHARED,
> irq);
> diff --git a/drivers/char/tpm/xen-tpmfront.c b/drivers/char/tpm/xen-tpmfront.c
> index b150f87f38f5..fa9a1c94c12f 100644
> --- a/drivers/char/tpm/xen-tpmfront.c
> +++ b/drivers/char/tpm/xen-tpmfront.c
> @@ -56,10 +56,9 @@ static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
> }
>
> static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
> - unsigned long timeout, wait_queue_head_t *queue,
> - bool check_cancel)
> + wait_queue_head_t *queue, bool check_cancel)
> {
> - unsigned long stop;
> + unsigned long stop, timeout;
> long rc;
> u8 status;
> bool canceled = false;
> @@ -69,7 +68,7 @@ static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
> if ((status & mask) == mask)
> return 0;
>
> - stop = jiffies + timeout;
> + stop = jiffies + TPM_UNIVERSAL_TIMEOUT_JIFFIES;
>
> if (chip->flags & TPM_CHIP_FLAG_IRQ) {
> again:
> @@ -91,7 +90,7 @@ static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
> }
> } else {
> do {
> - tpm_msleep(TPM_TIMEOUT);
> + tpm_msleep(TPM_TIMEOUT_POLL_MS);
> status = chip->ops->status(chip);
> if ((status & mask) == mask)
> return 0;
> @@ -141,7 +140,6 @@ static int vtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
> unsigned int offset = shr_data_offset(shr);
>
> u32 ordinal;
> - unsigned long duration;
>
> if (offset > PAGE_SIZE)
> return -EINVAL;
> @@ -150,7 +148,7 @@ static int vtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
> return -EINVAL;
>
> /* Wait for completion of any existing command or cancellation */
> - if (wait_for_tpm_stat(chip, VTPM_STATUS_IDLE, chip->timeout_c,
> + if (wait_for_tpm_stat(chip, VTPM_STATUS_IDLE,
> &priv->read_queue, true) < 0) {
> vtpm_cancel(chip);
> return -ETIME;
> @@ -164,9 +162,8 @@ static int vtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
> notify_remote_via_evtchn(priv->evtchn);
>
> ordinal = be32_to_cpu(((struct tpm_input_header*)buf)->ordinal);
> - duration = tpm_calc_ordinal_duration(chip, ordinal);
>
> - if (wait_for_tpm_stat(chip, VTPM_STATUS_IDLE, duration,
> + if (wait_for_tpm_stat(chip, VTPM_STATUS_IDLE,
> &priv->read_queue, true) < 0) {
> /* got a signal or timeout, try to cancel */
> vtpm_cancel(chip);
> @@ -187,7 +184,7 @@ static int vtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count)
> return -ECANCELED;
>
> /* In theory the wait at the end of _send makes this one unnecessary */
> - if (wait_for_tpm_stat(chip, VTPM_STATUS_RESULT, chip->timeout_c,
> + if (wait_for_tpm_stat(chip, VTPM_STATUS_RESULT,
> &priv->read_queue, true) < 0) {
> vtpm_cancel(chip);
> return -ETIME;