lkml.org 
[lkml]   [2020]   [Apr]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v7 4/7] tpm: tpm_tis: Fix expected bit handling and send all bytes in one shot without last byte in exception
    Date
    From: Amir Mizinski <amirmizi6@gmail.com>

    Incorrect implementation of send message was detected. We polled only
    TPM_STS.stsValid bit and then we single-checked the TPM_STS.expect bit
    value.
    TPM_STS.expected bit should be checked at the same time as
    TPM_STS.stsValid bit, and this should be repeated until timeout_A.

    To detect a TPM_STS.expected bit reset, the "wait_for_tpm_stat" function is
    modified to "wait_for_tpm_stat_result". This function regularly reads the
    status register and check the bits defined by "mask" to reach the value
    defined in "mask_result".

    This correct implementation is required for using the new CRC calculation
    on I2C TPM command bytes or I2C TPM answer bytes. TPM_STS.expected bit is
    reset after all bytes are acquired and the CRC result is inserted in the
    dedicated register. It introduces a normal latency for TPM_STS.expected
    bit reset.

    Respectively, to send a message, as defined in
    TCG_DesignPrinciples_TPM2p0Driver_vp24_pubrev.pdf, all bytes should be
    sent in one shot instead of sending the last byte separately.

    Suggested-by: Benoit Houyere <benoit.houyere@st.com>
    Signed-off-by: Amir Mizinski <amirmizi6@gmail.com>
    ---
    drivers/char/tpm/tpm_tis_core.c | 74 +++++++++++++++++------------------------
    1 file changed, 30 insertions(+), 44 deletions(-)

    diff --git a/drivers/char/tpm/tpm_tis_core.c b/drivers/char/tpm/tpm_tis_core.c
    index 682f950..f71ecd8 100644
    --- a/drivers/char/tpm/tpm_tis_core.c
    +++ b/drivers/char/tpm/tpm_tis_core.c
    @@ -44,9 +44,10 @@ static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
    return false;
    }

    -static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
    - unsigned long timeout, wait_queue_head_t *queue,
    - bool check_cancel)
    +static int wait_for_tpm_stat_result(struct tpm_chip *chip, u8 mask,
    + u8 mask_result, unsigned long timeout,
    + wait_queue_head_t *queue,
    + bool check_cancel)
    {
    unsigned long stop;
    long rc;
    @@ -55,7 +56,7 @@ static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,

    /* check current status */
    status = chip->ops->status(chip);
    - if ((status & mask) == mask)
    + if ((status & mask) == mask_result)
    return 0;

    stop = jiffies + timeout;
    @@ -83,7 +84,7 @@ static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
    usleep_range(TPM_TIMEOUT_USECS_MIN,
    TPM_TIMEOUT_USECS_MAX);
    status = chip->ops->status(chip);
    - if ((status & mask) == mask)
    + if ((status & mask) == mask_result)
    return 0;
    } while (time_before(jiffies, stop));
    }
    @@ -292,10 +293,13 @@ static int recv_data(struct tpm_chip *chip, u8 *buf, size_t count)
    int size = 0, burstcnt, rc;

    while (size < count) {
    - rc = wait_for_tpm_stat(chip,
    - TPM_STS_DATA_AVAIL | TPM_STS_VALID,
    - chip->timeout_c,
    - &priv->read_queue, true);
    + rc = wait_for_tpm_stat_result(chip,
    + TPM_STS_DATA_AVAIL |
    + TPM_STS_VALID,
    + TPM_STS_DATA_AVAIL |
    + TPM_STS_VALID,
    + chip->timeout_c,
    + &priv->read_queue, true);
    if (rc < 0)
    return rc;
    burstcnt = get_burstcount(chip);
    @@ -350,8 +354,9 @@ 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,
    - &priv->int_queue, false) < 0) {
    + if (wait_for_tpm_stat_result(chip, TPM_STS_VALID,
    + TPM_STS_VALID, chip->timeout_c,
    + &priv->int_queue, false) < 0) {
    size = -ETIME;
    goto out;
    }
    @@ -387,61 +392,40 @@ static int tpm_tis_send_data(struct tpm_chip *chip, const u8 *buf, size_t len)
    struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
    int rc, status, burstcnt;
    size_t count = 0;
    - bool itpm = priv->flags & TPM_TIS_ITPM_WORKAROUND;

    status = tpm_tis_status(chip);
    if ((status & TPM_STS_COMMAND_READY) == 0) {
    tpm_tis_ready(chip);
    - if (wait_for_tpm_stat
    - (chip, TPM_STS_COMMAND_READY, chip->timeout_b,
    - &priv->int_queue, false) < 0) {
    + if (wait_for_tpm_stat_result(chip, TPM_STS_COMMAND_READY,
    + TPM_STS_COMMAND_READY,
    + chip->timeout_b,
    + &priv->int_queue, false) < 0) {
    rc = -ETIME;
    goto out_err;
    }
    }

    - while (count < len - 1) {
    + while (count < len) {
    burstcnt = get_burstcount(chip);
    if (burstcnt < 0) {
    dev_err(&chip->dev, "Unable to read burstcount\n");
    rc = burstcnt;
    goto out_err;
    }
    - burstcnt = min_t(int, burstcnt, len - count - 1);
    + burstcnt = min_t(int, burstcnt, len - count);
    rc = tpm_tis_write_bytes(priv, TPM_DATA_FIFO(priv->locality),
    burstcnt, buf + count);
    if (rc < 0)
    goto out_err;

    count += burstcnt;
    -
    - if (wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
    - &priv->int_queue, false) < 0) {
    - rc = -ETIME;
    - goto out_err;
    - }
    - status = tpm_tis_status(chip);
    - if (!itpm && (status & TPM_STS_DATA_EXPECT) == 0) {
    - rc = -EIO;
    - goto out_err;
    - }
    }
    -
    - /* write last byte */
    - rc = tpm_tis_write8(priv, TPM_DATA_FIFO(priv->locality), buf[count]);
    - if (rc < 0)
    - goto out_err;
    -
    - if (wait_for_tpm_stat(chip, TPM_STS_VALID, chip->timeout_c,
    - &priv->int_queue, false) < 0) {
    + if (wait_for_tpm_stat_result(chip, TPM_STS_VALID | TPM_STS_DATA_EXPECT,
    + TPM_STS_VALID, chip->timeout_a,
    + &priv->int_queue, false) < 0) {
    rc = -ETIME;
    goto out_err;
    }
    - status = tpm_tis_status(chip);
    - if (!itpm && (status & TPM_STS_DATA_EXPECT) != 0) {
    - rc = -EIO;
    - goto out_err;
    - }

    return 0;

    @@ -498,9 +482,11 @@ static int tpm_tis_send_main(struct tpm_chip *chip, const u8 *buf, size_t len)
    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,
    - &priv->read_queue, false) < 0) {
    + if (wait_for_tpm_stat_result(chip,
    + TPM_STS_DATA_AVAIL | TPM_STS_VALID,
    + TPM_STS_DATA_AVAIL | TPM_STS_VALID,
    + dur,
    + &priv->read_queue, false) < 0) {
    rc = -ETIME;
    goto out_err;
    }
    --
    2.7.4
    \
     
     \ /
      Last update: 2020-04-27 14:52    [W:4.152 / U:0.024 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site