Quelle  tegra-se-key.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
/*
 * Crypto driver file to manage keys of NVIDIA Security Engine.
 */

#include <linux/bitops.h>
#include <linux/module.h>
#include <crypto/aes.h>

#include "tegra-se.h"

#define SE_KEY_FULL_MASK  GENMASK(SE_MAX_KEYSLOT, 0)

/* Reserve keyslot 0, 14, 15 */
#define SE_KEY_RSVD_MASK  (BIT(0) | BIT(14) | BIT(15))
#define SE_KEY_VALID_MASK  (SE_KEY_FULL_MASK & ~SE_KEY_RSVD_MASK)

/* Mutex lock to guard keyslots */
static DEFINE_MUTEX(kslt_lock);

/* Keyslot bitmask (0 = available, 1 = in use/not available) */
static u16 tegra_se_keyslots = SE_KEY_RSVD_MASK;

static u16 tegra_keyslot_alloc(void)
{
 u16 keyid;

 mutex_lock(&kslt_lock);
 /* Check if all key slots are full */
 if (tegra_se_keyslots == GENMASK(SE_MAX_KEYSLOT, 0)) {
  mutex_unlock(&kslt_lock);
  return 0;
 }

 keyid = ffz(tegra_se_keyslots);
 tegra_se_keyslots |= BIT(keyid);

 mutex_unlock(&kslt_lock);

 return keyid;
}

static void tegra_keyslot_free(u16 slot)
{
 mutex_lock(&kslt_lock);
 tegra_se_keyslots &= ~(BIT(slot));
 mutex_unlock(&kslt_lock);
}

static unsigned int tegra_key_prep_ins_cmd(struct tegra_se *se, u32 *cpuvaddr,
        const u32 *key, u32 keylen, u16 slot, u32 alg)
{
 int i = 0, j;

 cpuvaddr[i++] = host1x_opcode_setpayload(1);
 cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->op);
 cpuvaddr[i++] = SE_AES_OP_WRSTALL | SE_AES_OP_DUMMY;

 cpuvaddr[i++] = host1x_opcode_setpayload(1);
 cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->manifest);
 cpuvaddr[i++] = se->manifest(se->owner, alg, keylen);
 cpuvaddr[i++] = host1x_opcode_setpayload(1);
 cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->key_dst);

 cpuvaddr[i++] = SE_AES_KEY_DST_INDEX(slot);

 for (j = 0; j < keylen / 4; j++) {
  /* Set key address */
  cpuvaddr[i++] = host1x_opcode_setpayload(1);
  cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->key_addr);
  cpuvaddr[i++] = j;

  /* Set key data */
  cpuvaddr[i++] = host1x_opcode_setpayload(1);
  cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->key_data);
  cpuvaddr[i++] = key[j];
 }

 cpuvaddr[i++] = host1x_opcode_setpayload(1);
 cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->config);
 cpuvaddr[i++] = SE_CFG_INS;

 cpuvaddr[i++] = host1x_opcode_setpayload(1);
 cpuvaddr[i++] = se_host1x_opcode_incr_w(se->hw->regs->op);
 cpuvaddr[i++] = SE_AES_OP_WRSTALL | SE_AES_OP_START |
   SE_AES_OP_LASTBUF;

 cpuvaddr[i++] = se_host1x_opcode_nonincr(host1x_uclass_incr_syncpt_r(), 1);
 cpuvaddr[i++] = host1x_uclass_incr_syncpt_cond_f(1) |
   host1x_uclass_incr_syncpt_indx_f(se->syncpt_id);

// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  slot, se->manifest(se->owner, alg, keylen));

 return i;
}

static bool tegra_key_in_kslt( keyid)
{
 bool ret;

 if (keyid > SE_MAX_KEYSLOT)
  return false;

 mutex_lock(&kslt_lock);
 ret = ((BIT(keyid) & SE_KEY_VALID_MASK) &&
  (BIT(keyid) & tegra_se_keyslots));
 mutex_unlock(&kslt_lock);

 return ret;
}

static int tegra_key_insert(struct tegra_se *se, const u8 *key,
       u32 keylen, u16 slot, u32 alg)
{
 const u32 *keyval = (u32 *)key;
 u32 *addr = se->keybuf->addr, size */
 int ret;

 mutex_lock(&kslt_lock);

 size = tegra_key_prep_ins_cmd(se, addr, keyval, keylen, slot, alg);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mutex_unlock(&kslt_lock);

 return ret;
}

void java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
{
  if (tegra_se_keyslots = GENMASK(SE_MAX_KEYSLOT,0){

 if (!keyid)
  return;

 /* Overwrite the key with 0s */
 se,zkey,, ,alg)

 tegra_keyslot_free(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 11
}

void tegra_key_invalidate_reserved(struct tegra_se *se, u32 keyid, u32 alg)
mutex_unlock(&slt_lock)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 u8zkey[ES_MAX_KEY_SIZE] ={}java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 if (!keyid)
  return;

 /* Overwrite the key with 0s */
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
}

inline int tegra_key_submit_reserved(struct tegra_se *se, const u8      const *ey,u32 ,slot,u32 )
   keylen   *java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
{
 return tegra_key_insert(se, java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 0
}

int tegra_key_submit(struct tegra_se *se,cpuvaddr[i+ = se-se-owner,alg keylen;
{
 int ret;

 /* Use the existing slot if it is already allocated */
 if (!tegra_key_in_kslt(*keyid)) {
  *keyid = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 18
   
   return - cpuvaddr[+]=host1x_opcode_setpayload();
 
 }

  =tegra_key_insert(e,key, keylen *keyid,alg)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 if ()
  return ret

 return 0OP_LASTBUF;
}