A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-10 14:19:09 -04:00
Code Issues Projects Releases Packages Wiki Activity

firmware: qcom: add encrypted tz and qsee log support

Browse source 
make changes to support encrypted tz and qsee logs.

Change-Id: I4ad882845507f512a1a3edccbf6cb2d07bd3af5c
Signed-off-by: Zhen Kong <zkong@codeaurora.org>
This commit is contained in:
Zhen Kong 2020-03-19 11:22:20 -07:00
commit 3d96e601a6
5 changed files with 422 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

412
drivers/firmware/qcom/tz_log.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
*/
#include <linux/debugfs.h>
#include <linux/errno.h>
@ -23,6 +23,9 @@
/* QSEE_LOG_BUF_SIZE = 32K */
#define QSEE_LOG_BUF_SIZE 0x8000
/* MAX_ENCR_LOG_BUFF_SIZE = 36K (include header, and page align) */
#define MAX_ENCR_LOG_BUFF_SIZE (QSEE_LOG_BUF_SIZE + PAGE_SIZE)
/* TZ Diagnostic Area legacy version number */
#define TZBSP_DIAG_MAJOR_VERSION_LEGACY 2
/*
@ -58,6 +61,9 @@
#define TZBSP_NONCE_LEN 12
#define TZBSP_TAG_LEN 16
#define ENCRYPTED_TZ_LOG_ID 0
#define ENCRYPTED_QSEE_LOG_ID 1
/*
* VMID Table
*/
@ -285,6 +291,8 @@ enum tzdbg_stats_type {
};
struct tzdbg_stat {
size_t display_len;
size_t display_offset;
char *name;
char *data;
};
@ -300,6 +308,33 @@ struct tzdbg {
uint32_t hyp_debug_rw_buf_size;
bool is_hyplog_enabled;
uint32_t tz_version;
bool is_encrypted_log_enabled;
};
struct tzbsp_encr_log_t {
/* Magic Number */
uint32_t magic_num;
/* version NUMBER */
uint32_t version;
/* encrypted log size */
uint32_t encr_log_buff_size;
/* Wrap value*/
uint16_t wrap_count;
/* AES encryption key wrapped up with oem public key*/
uint8_t key[TZBSP_AES_256_ENCRYPTED_KEY_SIZE];
/* Nonce used for encryption*/
uint8_t nonce[TZBSP_NONCE_LEN];
/* Tag to be used for Validation */
uint8_t tag[TZBSP_TAG_LEN];
/* Encrypted log buffer */
uint8_t log_buf[1];
};
struct encrypted_log_info {
phys_addr_t paddr;
void *vaddr;
size_t size;
uint64_t shmb_handle;
};
static struct tzdbg tzdbg = {
@ -317,7 +352,12 @@ static struct tzdbg tzdbg = {
static struct tzdbg_log_t *g_qsee_log;
static dma_addr_t coh_pmem;
static uint32_t debug_rw_buf_size;
static uint32_t display_buf_size;
static phys_addr_t disp_buf_paddr;
static uint64_t qseelog_shmbridge_handle;
static struct encrypted_log_info enc_qseelog_info;
static struct encrypted_log_info enc_tzlog_info;
/*
* Debugfs data structure and functions
@ -704,6 +744,87 @@ static int __disp_hyp_log_stats(uint8_t *log,
return len;
}
static int print_text(char *intro_message,
unsigned char *text_addr,
unsigned int size,
char *buf, uint32_t buf_len)
{
unsigned int i;
int len = 0;
pr_debug("begin address %p, size %d\n", text_addr, size);
len += scnprintf(buf + len, buf_len - len, "%s\n", intro_message);
for (i = 0; i < size; i++) {
if (buf_len <= len + 6) {
pr_err("buffer not enough, buf_len %d, len %d\n",
buf_len, len);
return buf_len;
}
len += scnprintf(buf + len, buf_len - len, "%02hhx ",
text_addr[i]);
if ((i & 0x1f) == 0x1f)
len += scnprintf(buf + len, buf_len - len, "%c", '\n');
}
len += scnprintf(buf + len, buf_len - len, "%c", '\n');
return len;
}
static int _disp_encrpted_log_stats(struct encrypted_log_info *enc_log_info,
enum tzdbg_stats_type type, uint32_t log_id)
{
int ret = 0, len = 0;
struct tzbsp_encr_log_t *encr_log_head;
uint32_t size = 0;
ret = qcom_scm_request_encrypted_log(enc_log_info->paddr,
enc_log_info->size, log_id);
if (ret)
return 0;
encr_log_head = (struct tzbsp_encr_log_t *)(enc_log_info->vaddr);
pr_debug("display_buf_size = %d, encr_log_buff_size = %d\n",
display_buf_size, encr_log_head->encr_log_buff_size);
size = encr_log_head->encr_log_buff_size;
len += scnprintf(tzdbg.disp_buf + len,
(display_buf_size - 1) - len,
"\n-------- New Encrypted %s --------\n",
((log_id == ENCRYPTED_QSEE_LOG_ID) ?
"QSEE Log" : "TZ Dialog"));
len += scnprintf(tzdbg.disp_buf + len,
(display_buf_size - 1) - len,
"\nMagic_Num :\n0x%x\n"
"\nVerion :\n%d\n"
"\nEncr_Log_Buff_Size :\n%d\n"
"\nWrap_Count :\n%d\n",
encr_log_head->magic_num,
encr_log_head->version,
encr_log_head->encr_log_buff_size,
encr_log_head->wrap_count);
len += print_text("\nKey : ", encr_log_head->key,
TZBSP_AES_256_ENCRYPTED_KEY_SIZE,
tzdbg.disp_buf + len, display_buf_size);
len += print_text("\nNonce : ", encr_log_head->nonce,
TZBSP_NONCE_LEN,
tzdbg.disp_buf + len, display_buf_size - len);
len += print_text("\nTag : ", encr_log_head->tag,
TZBSP_TAG_LEN,
tzdbg.disp_buf + len, display_buf_size - len);
if (len > display_buf_size - size)
pr_warn("Cannot fit all info into the buffer\n");
pr_debug("encrypted log size %d, disply buffer size %d, used len %d\n",
size, display_buf_size, len);
len += print_text("\nLog : ", encr_log_head->log_buf, size,
tzdbg.disp_buf + len, display_buf_size - len);
memset(enc_log_info->vaddr, 0, enc_log_info->size);
tzdbg.stat[type].data = tzdbg.disp_buf;
return len;
}
static int _disp_tz_log_stats(size_t count)
{
static struct tzdbg_log_pos_t log_start = {0};
@ -774,23 +895,24 @@ static int _disp_hyp_general_stats(size_t count)
return len;
}
static ssize_t tzdbgfs_read(struct file *file, char __user *buf,
static ssize_t tzdbgfs_read_unencrypted(struct file *file, char __user *buf,
size_t count, loff_t *offp)
{
int len = 0;
int *tz_id = file->private_data;
int tz_id = *(int *)(file->private_data);
if (*tz_id == TZDBG_BOOT || *tz_id == TZDBG_RESET ||
*tz_id == TZDBG_INTERRUPT || *tz_id == TZDBG_GENERAL ||
*tz_id == TZDBG_VMID || *tz_id == TZDBG_LOG)
if (tz_id == TZDBG_BOOT || tz_id == TZDBG_RESET ||
tz_id == TZDBG_INTERRUPT || tz_id == TZDBG_GENERAL ||
tz_id == TZDBG_VMID || tz_id == TZDBG_LOG)
memcpy_fromio((void *)tzdbg.diag_buf, tzdbg.virt_iobase,
debug_rw_buf_size);
if (*tz_id == TZDBG_HYP_GENERAL || *tz_id == TZDBG_HYP_LOG)
memcpy_fromio((void *)tzdbg.hyp_diag_buf, tzdbg.hyp_virt_iobase,
tzdbg.hyp_debug_rw_buf_size);
if (tz_id == TZDBG_HYP_GENERAL || tz_id == TZDBG_HYP_LOG)
memcpy_fromio((void *)tzdbg.hyp_diag_buf,
tzdbg.hyp_virt_iobase,
tzdbg.hyp_debug_rw_buf_size);
switch (*tz_id) {
switch (tz_id) {
case TZDBG_BOOT:
len = _disp_tz_boot_stats();
break;
@ -834,7 +956,60 @@ static ssize_t tzdbgfs_read(struct file *file, char __user *buf,
len = count;
return simple_read_from_buffer(buf, len, offp,
tzdbg.stat[(*tz_id)].data, len);
tzdbg.stat[tz_id].data, len);
}
static ssize_t tzdbgfs_read_encrypted(struct file *file, char __user *buf,
size_t count, loff_t *offp)
{
int len = 0, ret = 0;
int tz_id = *(int *)(file->private_data);
struct tzdbg_stat *stat = &(tzdbg.stat[tz_id]);
pr_debug("tz_id = %d\n", tz_id);
if (tz_id >= TZDBG_STATS_MAX) {
pr_err("invalid encrypted log id %d\n", tz_id);
return ret;
}
if (!stat->display_len) {
if (tz_id == TZDBG_QSEE_LOG)
stat->display_len = _disp_encrpted_log_stats(
&enc_qseelog_info,
tz_id, ENCRYPTED_QSEE_LOG_ID);
else
stat->display_len = _disp_encrpted_log_stats(
&enc_tzlog_info,
tz_id, ENCRYPTED_TZ_LOG_ID);
stat->display_offset = 0;
}
len = stat->display_len;
if (len > count)
len = count;
*offp = 0;
ret = simple_read_from_buffer(buf, len, offp,
tzdbg.stat[tz_id].data + stat->display_offset,
count);
stat->display_offset += ret;
stat->display_len -= ret;
pr_debug("ret = %d, offset = %d\n", ret, (int)(*offp));
pr_debug("display_len = %d, offset = %d\n",
stat->display_len, stat->display_offset);
return ret;
}
static ssize_t tzdbgfs_read(struct file *file, char __user *buf,
size_t count, loff_t *offp)
{
int tz_id = *(int *)(file->private_data);
if (!tzdbg.is_encrypted_log_enabled ||
(tz_id == TZDBG_HYP_GENERAL || tz_id == TZDBG_HYP_LOG))
return tzdbgfs_read_unencrypted(file, buf, count, offp);
else
return tzdbgfs_read_encrypted(file, buf, count, offp);
}
static const struct file_operations tzdbg_fops = {
@ -846,7 +1021,7 @@ static const struct file_operations tzdbg_fops = {
/*
* Allocates log buffer from ION, registers the buffer at TZ
*/
static void tzdbg_register_qsee_log_buf(struct platform_device *pdev)
static int tzdbg_register_qsee_log_buf(struct platform_device *pdev)
{
size_t len = QSEE_LOG_BUF_SIZE;
int ret = 0;
@ -857,33 +1032,116 @@ static void tzdbg_register_qsee_log_buf(struct platform_device *pdev)
buf = dma_alloc_coherent(&pdev->dev, len, &coh_pmem, GFP_KERNEL);
if (buf == NULL)
return;
return -ENOMEM;
ret = qtee_shmbridge_register(coh_pmem,
if (!tzdbg.is_encrypted_log_enabled) {
ret = qtee_shmbridge_register(coh_pmem,
len, ns_vmids, ns_vm_perms, ns_vm_nums,
PERM_READ | PERM_WRITE, &qseelog_shmbridge_handle);
if (ret) {
pr_err("failed to create bridge for qsee_log buffer\n");
dma_free_coherent(&pdev->dev, len, (void *)g_qsee_log,
coh_pmem);
return;
PERM_READ | PERM_WRITE,
&qseelog_shmbridge_handle);
if (ret) {
pr_err("failed to create bridge for qsee_log buf\n");
goto exit_free_mem;
}
}
g_qsee_log = (struct tzdbg_log_t *)buf;
g_qsee_log->log_pos.wrap = g_qsee_log->log_pos.offset = 0;
ret = qcom_scm_register_qsee_log_buf(coh_pmem, len);
if (ret != QSEOS_RESULT_SUCCESS) {
pr_err(
"%s: scm_call to register log buf failed, resp result =%lld\n",
__func__, ret);
goto err;
goto exit_dereg_bridge;
}
g_qsee_log->log_pos.wrap = g_qsee_log->log_pos.offset = 0;
return;
return ret;
err:
qtee_shmbridge_deregister(qseelog_shmbridge_handle);
exit_dereg_bridge:
if (!tzdbg.is_encrypted_log_enabled)
qtee_shmbridge_deregister(qseelog_shmbridge_handle);
exit_free_mem:
dma_free_coherent(&pdev->dev, len, (void *)g_qsee_log, coh_pmem);
return ret;
}
static void tzdbg_free_qsee_log_buf(struct platform_device *pdev)
{
size_t len = QSEE_LOG_BUF_SIZE;
if (!tzdbg.is_encrypted_log_enabled)
qtee_shmbridge_deregister(qseelog_shmbridge_handle);
dma_free_coherent(&pdev->dev, len, (void *)g_qsee_log, coh_pmem);
}
static int tzdbg_allocate_encrypted_log_buf(struct platform_device *pdev)
{
int ret = 0;
uint32_t ns_vmids[] = {VMID_HLOS};
uint32_t ns_vm_perms[] = {PERM_READ | PERM_WRITE};
uint32_t ns_vm_nums = 1;
if (!tzdbg.is_encrypted_log_enabled)
return 0;
enc_qseelog_info.size = MAX_ENCR_LOG_BUFF_SIZE;
enc_qseelog_info.vaddr = dma_alloc_coherent(&pdev->dev,
enc_qseelog_info.size,
&enc_qseelog_info.paddr, GFP_KERNEL);
if (enc_qseelog_info.vaddr == NULL)
return -ENOMEM;
ret = qtee_shmbridge_register(enc_qseelog_info.paddr,
enc_qseelog_info.size, ns_vmids,
ns_vm_perms, ns_vm_nums,
PERM_READ | PERM_WRITE, &enc_qseelog_info.shmb_handle);
if (ret) {
pr_err("failed to create encr_qsee_log bridge, ret %d\n", ret);
goto exit_free_qseelog;
}
pr_debug("Alloc memory for encr_qsee_log, size = %zu\n",
enc_qseelog_info.size);
enc_tzlog_info.size = debug_rw_buf_size;
enc_tzlog_info.vaddr = dma_alloc_coherent(&pdev->dev,
enc_tzlog_info.size,
&enc_tzlog_info.paddr, GFP_KERNEL);
if (enc_tzlog_info.vaddr == NULL)
goto exit_unreg_qseelog;
ret = qtee_shmbridge_register(enc_tzlog_info.paddr,
enc_tzlog_info.size, ns_vmids, ns_vm_perms, ns_vm_nums,
PERM_READ | PERM_WRITE, &enc_tzlog_info.shmb_handle);
if (ret) {
pr_err("failed to create encr_tz_log bridge, ret = %d\n", ret);
goto exit_free_tzlog;
}
pr_debug("Alloc memory for encr_tz_log, size %zu\n",
enc_qseelog_info.size);
return 0;
exit_free_tzlog:
dma_free_coherent(&pdev->dev, enc_tzlog_info.size,
enc_tzlog_info.vaddr, enc_tzlog_info.paddr);
exit_unreg_qseelog:
qtee_shmbridge_deregister(enc_qseelog_info.shmb_handle);
exit_free_qseelog:
dma_free_coherent(&pdev->dev, enc_qseelog_info.size,
enc_qseelog_info.vaddr, enc_qseelog_info.paddr);
return -ENOMEM;
}
static void tzdbg_free_encrypted_log_buf(struct platform_device *pdev)
{
qtee_shmbridge_deregister(enc_tzlog_info.shmb_handle);
dma_free_coherent(&pdev->dev, enc_tzlog_info.size,
enc_tzlog_info.vaddr, enc_tzlog_info.paddr);
qtee_shmbridge_deregister(enc_qseelog_info.shmb_handle);
dma_free_coherent(&pdev->dev, enc_qseelog_info.size,
enc_qseelog_info.vaddr, enc_qseelog_info.paddr);
}
static int tzdbgfs_init(struct platform_device *pdev)
@ -910,11 +1168,6 @@ static int tzdbgfs_init(struct platform_device *pdev)
goto err;
}
}
tzdbg.disp_buf = kzalloc(max(debug_rw_buf_size,
tzdbg.hyp_debug_rw_buf_size), GFP_KERNEL);
if (tzdbg.disp_buf == NULL)
goto err;
platform_set_drvdata(pdev, dent_dir);
return 0;
err:
@ -994,6 +1247,21 @@ static void tzdbg_get_tz_version(void)
tzdbg.tz_version = version;
}
static void tzdbg_query_encrypted_log(void)
{
int ret = 0;
uint64_t enabled;
ret = qcom_scm_query_encrypted_log_feature(&enabled);
if (ret) {
pr_err("scm_call QUERY_ENCR_LOG_FEATURE failed ret %d\n", ret);
tzdbg.is_encrypted_log_enabled = false;
} else {
pr_info("encrypted qseelog enabled is %d\n", enabled);
tzdbg.is_encrypted_log_enabled = enabled;
}
}
/*
* Driver functions
*/
@ -1039,12 +1307,13 @@ static int tz_log_probe(struct platform_device *pdev)
if (tzdbg.is_hyplog_enabled) {
ret = __update_hypdbg_base(pdev, virt_iobase);
if (ret) {
dev_err(&pdev->dev, "%s() failed to get device tree data ret = %d\n",
__func__, ret);
dev_err(&pdev->dev,
"%s: fail to get hypdbg_base ret %d\n",
__func__, ret);
return -EINVAL;
}
} else {
dev_info(&pdev->dev, "Hyp log service is not supported\n");
dev_info(&pdev->dev, "Hyp log service not support\n");
}
} else {
dev_dbg(&pdev->dev, "Device tree data is not found\n");
@ -1055,46 +1324,79 @@ static int tz_log_probe(struct platform_device *pdev)
*/
tzdiag_phy_iobase = readl_relaxed(virt_iobase);
tzdbg_query_encrypted_log();
/*
* Map the diagnostic information area
* Map the diagnostic information area if encryption is disabled
*/
tzdbg.virt_iobase = devm_ioremap_nocache(&pdev->dev,
if (!tzdbg.is_encrypted_log_enabled) {
tzdbg.virt_iobase = devm_ioremap_nocache(&pdev->dev,
tzdiag_phy_iobase, debug_rw_buf_size);
if (!tzdbg.virt_iobase) {
dev_err(&pdev->dev,
"%s: ERROR could not ioremap: start=%pr, len=%u\n",
__func__, &tzdiag_phy_iobase,
debug_rw_buf_size);
return -ENXIO;
if (!tzdbg.virt_iobase) {
dev_err(&pdev->dev,
"%s: could not ioremap: start=%pr, len=%u\n",
__func__, &tzdiag_phy_iobase,
debug_rw_buf_size);
return -ENXIO;
}
/* allocate diag_buf */
ptr = kzalloc(debug_rw_buf_size, GFP_KERNEL);
if (ptr == NULL)
return -ENOMEM;
tzdbg.diag_buf = (struct tzdbg_t *)ptr;
}
ptr = kzalloc(debug_rw_buf_size, GFP_KERNEL);
if (ptr == NULL)
return -ENOMEM;
/* allocate display_buf */
display_buf_size = QSEE_LOG_BUF_SIZE * 4;
tzdbg.disp_buf = dma_alloc_coherent(&pdev->dev, display_buf_size,
&disp_buf_paddr, GFP_KERNEL);
if (tzdbg.disp_buf == NULL) {
ret = -ENOMEM;
goto exit_free_diag_buf;
}
tzdbg.diag_buf = (struct tzdbg_t *)ptr;
/* register unencrypted qsee log buffer */
ret = tzdbg_register_qsee_log_buf(pdev);
if (ret)
goto exit_free_disp_buf;
if (tzdbgfs_init(pdev))
goto err;
tzdbg_register_qsee_log_buf(pdev);
/* allocate encrypted qsee and tz log buffer */
ret = tzdbg_allocate_encrypted_log_buf(pdev);
if (ret) {
dev_err(&pdev->dev,
"Failed to allocate encrypted log buffer\n",
__func__);
goto exit_free_qsee_log_buf;
}
tzdbg_get_tz_version();
if (tzdbgfs_init(pdev))
goto exit_free_encr_log_buf;
return 0;
err:
kfree(tzdbg.diag_buf);
exit_free_encr_log_buf:
tzdbg_free_encrypted_log_buf(pdev);
exit_free_qsee_log_buf:
tzdbg_free_qsee_log_buf(pdev);
exit_free_disp_buf:
dma_free_coherent(&pdev->dev, display_buf_size,
(void *)tzdbg.disp_buf, disp_buf_paddr);
exit_free_diag_buf:
if (!tzdbg.is_encrypted_log_enabled)
kfree(tzdbg.diag_buf);
return -ENXIO;
}
static int tz_log_remove(struct platform_device *pdev)
{
kzfree(tzdbg.diag_buf);
kzfree(tzdbg.hyp_diag_buf);
tzdbgfs_exit(pdev);
tzdbg_free_encrypted_log_buf(pdev);
tzdbg_free_qsee_log_buf(pdev);
dma_free_coherent(&pdev->dev, display_buf_size,
(void *)tzdbg.disp_buf, disp_buf_paddr);
if (!tzdbg.is_encrypted_log_enabled)
kfree(tzdbg.diag_buf);
return 0;
}

38
drivers/firmware/qcom_scm-smc.c
View file

@ -1918,6 +1918,44 @@ int __qcom_scm_register_qsee_log_buf(struct device *dev, phys_addr_t buf,
return ret ? : desc.res[0];
}
int __qcom_scm_query_encrypted_log_feature(struct device *dev, u64 *enabled)
{
int ret;
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_QSEELOG,
.cmd = QCOM_SCM_QUERY_ENCR_LOG_FEAT_ID,
.owner = ARM_SMCCC_OWNER_TRUSTED_OS
};
desc.arginfo = QCOM_SCM_ARGS(0);
ret = qcom_scm_call(dev, &desc);
if (enabled)
*enabled = desc.res[0];
return ret;
}
int __qcom_scm_request_encrypted_log(struct device *dev, phys_addr_t buf,
size_t len, uint32_t log_id)
{
int ret;
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_QSEELOG,
.cmd = QCOM_SCM_REQUEST_ENCR_LOG_ID,
.owner = ARM_SMCCC_OWNER_TRUSTED_OS
};
desc.args[0] = buf;
desc.args[1] = len;
desc.args[2] = log_id;
desc.arginfo = QCOM_SCM_ARGS(3, QCOM_SCM_RW);
ret = qcom_scm_call(dev, &desc);
return ret ? : desc.res[0];
}
int __qcom_scm_invoke_smc(struct device *dev, phys_addr_t in_buf,
size_t in_buf_size, phys_addr_t out_buf, size_t out_buf_size,
int32_t *result, u64 *response_type, unsigned int *data)

13
drivers/firmware/qcom_scm.c
View file

@ -940,6 +940,19 @@ int qcom_scm_register_qsee_log_buf(phys_addr_t buf, size_t len)
}
EXPORT_SYMBOL(qcom_scm_register_qsee_log_buf);
int qcom_scm_query_encrypted_log_feature(u64 *enabled)
{
return __qcom_scm_query_encrypted_log_feature(__scm->dev, enabled);
}
EXPORT_SYMBOL(qcom_scm_query_encrypted_log_feature);
int qcom_scm_request_encrypted_log(phys_addr_t buf, size_t len,
uint32_t log_id)
{
return __qcom_scm_request_encrypted_log(__scm->dev, buf, len, log_id);
}
EXPORT_SYMBOL(qcom_scm_request_encrypted_log);
int qcom_scm_invoke_smc(phys_addr_t in_buf, size_t in_buf_size,
phys_addr_t out_buf, size_t out_buf_size, int32_t *result,
u64 *response_type, unsigned int *data)

6
drivers/firmware/qcom_scm.h
View file

@ -238,6 +238,12 @@ extern int __qcom_scm_tsens_reinit(struct device *dev, int *tsens_ret);
extern int __qcom_scm_register_qsee_log_buf(struct device *dev, phys_addr_t buf,
size_t len);
#define QCOM_SCM_FEAT_LOG_ID 0x0a
#define QCOM_SCM_QUERY_ENCR_LOG_FEAT_ID 0x0b
extern int __qcom_scm_query_encrypted_log_feature(struct device *dev,
u64 *enabled);
#define QCOM_SCM_REQUEST_ENCR_LOG_ID 0x0c
extern int __qcom_scm_request_encrypted_log(struct device *dev, phys_addr_t buf,
size_t len, uint32_t log_id);
#define QCOM_SCM_SVC_KEYSTORE 0x05
#define QCOM_SCM_ICE_RESTORE_KEY_ID 0x06

8
include/linux/qcom_scm.h
View file

@ -184,6 +184,9 @@ extern int qcom_scm_tsens_reinit(int *tsens_ret);
extern int qcom_scm_ice_restore_cfg(void);
extern int qcom_scm_get_tz_log_feat_id(u64 *version);
extern int qcom_scm_register_qsee_log_buf(phys_addr_t buf, size_t len);
extern int qcom_scm_query_encrypted_log_feature(u64 *enabled);
extern int qcom_scm_request_encrypted_log(phys_addr_t buf, size_t len,
uint32_t log_id);
extern int qcom_scm_invoke_smc(phys_addr_t in_buf, size_t in_buf_size,
phys_addr_t out_buf, size_t out_buf_size, int32_t *result,
u64 *response_type, unsigned int *data);
@ -345,6 +348,11 @@ static inline int qcom_scm_get_tz_log_feat_id(u64 *version)
{ return -ENODEV; }
static inline int qcom_scm_register_qsee_log_buf(phys_addr_t buf, size_t len)
{ return -ENODEV; }
static inline int qcom_scm_query_encrypted_log_feature(u64 *enabled)
{ return -ENODEV; }
static inline int qcom_scm_request_encrypted_log(phys_addr_t buf, size_t len,
uint32_t log_id)
{ return -ENODEV; }
static inline int qcom_scm_invoke_smc(phys_addr_t in_buf, size_t in_buf_size,
phys_addr_t out_buf, size_t out_buf_size, int32_t *result,
u64 *request_type, unsigned int *data) { return -ENODEV; }