[PATCH v2 6/6] firmware: qcom: scm: Drop exported ICE wrapper functions

From: Harshal Dev

Date: Wed Nov 11 2026 - 09:26:53 EST


Drop the exported ICE wrapper functions from the SCM driver since the ICE
driver has now migrated to the TZ agnostic ICE APIs which allow runtime
routing of ICE secure calls to the appropriate TEE (QTEE or OPTEE).

Signed-off-by: Harshal Dev <harshal.dev@xxxxxxxxxxxxxxxx>
---
drivers/firmware/qcom/qcom_scm.c | 117 +++++++++------------------------
include/linux/firmware/qcom/qcom_scm.h | 20 ------
2 files changed, 31 insertions(+), 106 deletions(-)

diff --git a/drivers/firmware/qcom/qcom_scm.c b/drivers/firmware/qcom/qcom_scm.c
index 6b66bcedc84f..277334f71178 100644
--- a/drivers/firmware/qcom/qcom_scm.c
+++ b/drivers/firmware/qcom/qcom_scm.c
@@ -1399,25 +1399,20 @@ int qcom_scm_ocmem_unlock(enum qcom_scm_ocmem_client id, u32 offset, u32 size)
}
EXPORT_SYMBOL_GPL(qcom_scm_ocmem_unlock);

-bool __qcom_scm_ice_available(struct device *dev)
-{
- return __qcom_scm_is_call_available(dev, QCOM_SCM_SVC_ES,
- QCOM_SCM_ES_INVALIDATE_ICE_KEY) &&
- __qcom_scm_is_call_available(dev, QCOM_SCM_SVC_ES,
- QCOM_SCM_ES_CONFIG_SET_ICE_KEY);
-}
-
/**
* qcom_scm_ice_available() - Is the ICE key programming interface available?
+ * @dev: The SCM device
*
* Return: true iff the SCM calls wrapped by qcom_scm_ice_invalidate_key() and
* qcom_scm_ice_set_key() are available.
*/
-bool qcom_scm_ice_available(void)
+static bool qcom_scm_ice_available(struct device *dev)
{
- return __qcom_scm_ice_available(__scm->dev);
+ return __qcom_scm_is_call_available(dev, QCOM_SCM_SVC_ES,
+ QCOM_SCM_ES_INVALIDATE_ICE_KEY) &&
+ __qcom_scm_is_call_available(dev, QCOM_SCM_SVC_ES,
+ QCOM_SCM_ES_CONFIG_SET_ICE_KEY);
}
-EXPORT_SYMBOL_GPL(qcom_scm_ice_available);

/**
* qcom_scm_ice_invalidate_key() - Invalidate an inline encryption key
@@ -1431,7 +1426,7 @@ EXPORT_SYMBOL_GPL(qcom_scm_ice_available);
*
* Return: 0 on success; -errno on failure.
*/
-static int __qcom_scm_ice_invalidate_key(struct device *dev, u32 index)
+static int qcom_scm_ice_invalidate_key(struct device *dev, u32 index)
{
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_ES,
@@ -1444,12 +1439,6 @@ static int __qcom_scm_ice_invalidate_key(struct device *dev, u32 index)
return qcom_scm_call(dev, &desc, NULL);
}

-int qcom_scm_ice_invalidate_key(u32 index)
-{
- return __qcom_scm_ice_invalidate_key(__scm->dev, index);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_ice_invalidate_key);
-
/**
* qcom_scm_ice_set_key() - Set an inline encryption key
* @index: the keyslot into which to set the key
@@ -1471,10 +1460,10 @@ EXPORT_SYMBOL_GPL(qcom_scm_ice_invalidate_key);
*
* Return: 0 on success; -errno on failure.
*/
-static int __qcom_scm_ice_set_key(struct device *dev, u32 index,
- const u8 *key, u32 key_size,
- enum qcom_ice_cipher cipher,
- u32 data_unit_size)
+static int qcom_scm_ice_set_key(struct device *dev, u32 index,
+ const u8 *key, u32 key_size,
+ enum qcom_ice_cipher cipher,
+ u32 data_unit_size)
{
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_ES,
@@ -1506,16 +1495,7 @@ static int __qcom_scm_ice_set_key(struct device *dev, u32 index,
return ret;
}

-int qcom_scm_ice_set_key(u32 index, const u8 *key, u32 key_size,
- enum qcom_scm_ice_cipher cipher, u32 data_unit_size)
-{
- return __qcom_scm_ice_set_key(__scm->dev, index, key, key_size,
- (enum qcom_ice_cipher)cipher,
- data_unit_size);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_ice_set_key);
-
-static bool __qcom_scm_has_wrapped_key_support(struct device *dev)
+static bool qcom_scm_has_wrapped_key_support(struct device *dev)
{
return __qcom_scm_is_call_available(dev, QCOM_SCM_SVC_ES,
QCOM_SCM_ES_DERIVE_SW_SECRET) &&
@@ -1527,12 +1507,6 @@ static bool __qcom_scm_has_wrapped_key_support(struct device *dev)
QCOM_SCM_ES_IMPORT_ICE_KEY);
}

-bool qcom_scm_has_wrapped_key_support(void)
-{
- return __qcom_scm_has_wrapped_key_support(__scm->dev);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_has_wrapped_key_support);
-
/**
* qcom_scm_derive_sw_secret() - Derive software secret from wrapped key
* @eph_key: an ephemerally-wrapped key
@@ -1549,9 +1523,9 @@ EXPORT_SYMBOL_GPL(qcom_scm_has_wrapped_key_support);
*
* Return: 0 on success; -errno on failure.
*/
-static int __qcom_scm_derive_sw_secret(struct device *dev,
- const u8 *eph_key, size_t eph_key_size,
- u8 *sw_secret, size_t sw_secret_size)
+static int qcom_scm_derive_sw_secret(struct device *dev,
+ const u8 *eph_key, size_t eph_key_size,
+ u8 *sw_secret, size_t sw_secret_size)
{
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_ES,
@@ -1589,13 +1563,6 @@ static int __qcom_scm_derive_sw_secret(struct device *dev,
return ret;
}

-int qcom_scm_derive_sw_secret(const u8 *eph_key, size_t eph_key_size,
- u8 *sw_secret, size_t sw_secret_size)
-{
- return __qcom_scm_derive_sw_secret(__scm->dev, eph_key, eph_key_size,
- sw_secret, sw_secret_size);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_derive_sw_secret);

/**
* qcom_scm_generate_ice_key() - Generate a wrapped key for storage encryption
@@ -1608,8 +1575,8 @@ EXPORT_SYMBOL_GPL(qcom_scm_derive_sw_secret);
*
* Return: 0 on success; -errno on failure.
*/
-static int __qcom_scm_generate_ice_key(struct device *dev,
- u8 *lt_key, size_t lt_key_size)
+static int qcom_scm_generate_ice_key(struct device *dev,
+ u8 *lt_key, size_t lt_key_size)
{
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_ES,
@@ -1636,12 +1603,6 @@ static int __qcom_scm_generate_ice_key(struct device *dev,
return ret;
}

-int qcom_scm_generate_ice_key(u8 *lt_key, size_t lt_key_size)
-{
- return __qcom_scm_generate_ice_key(__scm->dev, lt_key, lt_key_size);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_generate_ice_key);
-
/**
* qcom_scm_prepare_ice_key() - Re-wrap a key with the per-boot ephemeral key
* @lt_key: a long-term wrapped key
@@ -1655,9 +1616,9 @@ EXPORT_SYMBOL_GPL(qcom_scm_generate_ice_key);
*
* Return: 0 on success; -errno on failure.
*/
-static int __qcom_scm_prepare_ice_key(struct device *dev,
- const u8 *lt_key, size_t lt_key_size,
- u8 *eph_key, size_t eph_key_size)
+static int qcom_scm_prepare_ice_key(struct device *dev,
+ const u8 *lt_key, size_t lt_key_size,
+ u8 *eph_key, size_t eph_key_size)
{
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_ES,
@@ -1695,14 +1656,6 @@ static int __qcom_scm_prepare_ice_key(struct device *dev,
return ret;
}

-int qcom_scm_prepare_ice_key(const u8 *lt_key, size_t lt_key_size,
- u8 *eph_key, size_t eph_key_size)
-{
- return __qcom_scm_prepare_ice_key(__scm->dev, lt_key, lt_key_size,
- eph_key, eph_key_size);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_prepare_ice_key);
-
/**
* qcom_scm_import_ice_key() - Import key for storage encryption
* @raw_key: the raw key to import
@@ -1716,9 +1669,9 @@ EXPORT_SYMBOL_GPL(qcom_scm_prepare_ice_key);
*
* Return: 0 on success; -errno on failure.
*/
-static int __qcom_scm_import_ice_key(struct device *dev,
- const u8 *raw_key, size_t raw_key_size,
- u8 *lt_key, size_t lt_key_size)
+static int qcom_scm_import_ice_key(struct device *dev,
+ const u8 *raw_key, size_t raw_key_size,
+ u8 *lt_key, size_t lt_key_size)
{
struct qcom_scm_desc desc = {
.svc = QCOM_SCM_SVC_ES,
@@ -1756,23 +1709,15 @@ static int __qcom_scm_import_ice_key(struct device *dev,
return ret;
}

-int qcom_scm_import_ice_key(const u8 *raw_key, size_t raw_key_size,
- u8 *lt_key, size_t lt_key_size)
-{
- return __qcom_scm_import_ice_key(__scm->dev, raw_key, raw_key_size,
- lt_key, lt_key_size);
-}
-EXPORT_SYMBOL_GPL(qcom_scm_import_ice_key);
-
static struct qcom_ice_tz_ops qcom_ice_scm_ops = {
.drv_name = "qcom_scm",
- .ice_invalidate_key = __qcom_scm_ice_invalidate_key,
- .ice_set_key = __qcom_scm_ice_set_key,
- .ice_has_wrapped_key_support = __qcom_scm_has_wrapped_key_support,
- .ice_derive_sw_secret = __qcom_scm_derive_sw_secret,
- .ice_generate_key = __qcom_scm_generate_ice_key,
- .ice_prepare_key = __qcom_scm_prepare_ice_key,
- .ice_import_key = __qcom_scm_import_ice_key,
+ .ice_invalidate_key = qcom_scm_ice_invalidate_key,
+ .ice_set_key = qcom_scm_ice_set_key,
+ .ice_has_wrapped_key_support = qcom_scm_has_wrapped_key_support,
+ .ice_derive_sw_secret = qcom_scm_derive_sw_secret,
+ .ice_generate_key = qcom_scm_generate_ice_key,
+ .ice_prepare_key = qcom_scm_prepare_ice_key,
+ .ice_import_key = qcom_scm_import_ice_key,
};

/**
@@ -2894,7 +2839,7 @@ static int qcom_scm_probe(struct platform_device *pdev)
* ICE driver could attempt to call the ICE SCM pointers before
* they are registered and assume that they aren't available.
*/
- if (__qcom_scm_ice_available(scm->dev)) {
+ if (qcom_scm_ice_available(scm->dev)) {
qcom_ice_scm_ops.dev = scm->dev;
ret = qcom_ice_tz_ops_register(&qcom_ice_scm_ops);
WARN(ret < 0, "failed to register ice SCM ops: %d\n", ret);
diff --git a/include/linux/firmware/qcom/qcom_scm.h b/include/linux/firmware/qcom/qcom_scm.h
index a0a6bc0229c4..36b87be82804 100644
--- a/include/linux/firmware/qcom/qcom_scm.h
+++ b/include/linux/firmware/qcom/qcom_scm.h
@@ -46,13 +46,6 @@ enum qcom_scm_sec_dev_id {
QCOM_SCM_ICE_DEV_ID = 20,
};

-enum qcom_scm_ice_cipher {
- QCOM_SCM_ICE_CIPHER_AES_128_XTS = 0,
- QCOM_SCM_ICE_CIPHER_AES_128_CBC = 1,
- QCOM_SCM_ICE_CIPHER_AES_256_XTS = 3,
- QCOM_SCM_ICE_CIPHER_AES_256_CBC = 4,
-};
-
#define QCOM_SCM_PERM_READ 0x4
#define QCOM_SCM_PERM_WRITE 0x2
#define QCOM_SCM_PERM_EXEC 0x1
@@ -86,19 +79,6 @@ int qcom_scm_ocmem_lock(enum qcom_scm_ocmem_client id, u32 offset, u32 size,
u32 mode);
int qcom_scm_ocmem_unlock(enum qcom_scm_ocmem_client id, u32 offset, u32 size);

-bool qcom_scm_ice_available(void);
-int qcom_scm_ice_invalidate_key(u32 index);
-int qcom_scm_ice_set_key(u32 index, const u8 *key, u32 key_size,
- enum qcom_scm_ice_cipher cipher, u32 data_unit_size);
-bool qcom_scm_has_wrapped_key_support(void);
-int qcom_scm_derive_sw_secret(const u8 *eph_key, size_t eph_key_size,
- u8 *sw_secret, size_t sw_secret_size);
-int qcom_scm_generate_ice_key(u8 *lt_key, size_t lt_key_size);
-int qcom_scm_prepare_ice_key(const u8 *lt_key, size_t lt_key_size,
- u8 *eph_key, size_t eph_key_size);
-int qcom_scm_import_ice_key(const u8 *raw_key, size_t raw_key_size,
- u8 *lt_key, size_t lt_key_size);
-
bool qcom_scm_hdcp_available(void);
int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp);


--
2.34.1