Merge a9fbe05aa57d8386caa4333829cb7b0e2aaa07c2 on remote branch

Change-Id: I295ffafd4818989f94d6b294f3991471d89b4dd5

Android.mk

@@ -12,10 +12,42 @@ ifeq ($(TARGET_KERNEL_DLKM_DISABLE), true)
   endif
 endif
 
+ifeq ($(ENABLE_SECUREMSM_DLKM), true)
+  ENABLE_QCRYPTO_DLKM := true
+  ENABLE_HDCP_QSEECOM_DLKM := true
+  ENABLE_QRNG_DLKM := true
+  ifeq ($(TARGET_USES_SMMU_PROXY), true)
+    ENABLE_SMMU_PROXY := true
+  endif #TARGET_USES_SMMU_PROXY
+endif #ENABLE_SECUREMSM_DLKM
+
+ifeq ($(ENABLE_SECUREMSM_QTEE_DLKM), true)
+  ENABLE_SMCINVOKE_DLKM := true
+  ENABLE_TZLOG_DLKM := true
+  #Enable Qseecom if TARGET_ENABLE_QSEECOM or TARGET_BOARD_AUTO is set to true
+  ifneq (, $(filter true, $(TARGET_ENABLE_QSEECOM) $(TARGET_BOARD_AUTO)))
+    ENABLE_QSEECOM_DLKM := true
+  endif #TARGET_ENABLE_QSEECOM OR TARGET_BOARD_AUTO
+endif #ENABLE_SECUREMSM_QTEE_DLKM
+
+ifeq ($(TARGET_USES_GY), true)
+  ENABLE_QCRYPTO_DLKM := false
+  ENABLE_HDCP_QSEECOM_DLKM := false
+  ENABLE_QRNG_DLKM := false
+  ENABLE_SMMU_PROXY := false
+  ENABLE_SMCINVOKE_DLKM := true
+  ENABLE_TZLOG_DLKM := false
+  ENABLE_QSEECOM_DLKM := false
+endif #TARGET_USES_GY
+
 LOCAL_PATH := $(call my-dir)
-DLKM_DIR := $(TOP)/device/qcom/common/dlkm
 
-SEC_KERNEL_DIR := $(TOP)/vendor/qcom/opensource/securemsm-kernel
+VENDOR_OPENSOURCE_DIR ?= vendor/qcom/opensource
+VENDOR_COMMON_DIR ?= device/qcom/common
+
+DLKM_DIR := $(TOP)/$(VENDOR_COMMON_DIR)/dlkm
+
+SEC_KERNEL_DIR := $(TOP)/$(VENDOR_OPENSOURCE_DIR)/securemsm-kernel
 
 LOCAL_EXPORT_KO_INCLUDE_DIRS := $(LOCAL_PATH)/include/ \
                                 $(LOCAL_PATH)/include/uapi
@@ -43,7 +75,7 @@ LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
 endif
 
-ifeq ($(ENABLE_SECUREMSM_QTEE_DLKM), true)
+ifeq ($(ENABLE_SMCINVOKE_DLKM), true)
 include $(CLEAR_VARS)
 #LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_MODULE              := smcinvoke_dlkm.ko
@@ -53,8 +85,10 @@ LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_HEADER_LIBRARIES    := smcinvoke_kernel_headers
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
+endif #ENABLE_SMCINVOKE_DLKM
 ###################################################
 ###################################################
+ifeq ($(ENABLE_TZLOG_DLKM), true)
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_MODULE              := tz_log_dlkm.ko
@@ -63,7 +97,9 @@ LOCAL_MODULE_TAGS         := optional
 LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
+endif #ENABLE_TZLOG_DLKM
 
+ifeq ($(ENABLE_QSEECOM_DLKM), true)
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_MODULE              := qseecom_dlkm.ko
@@ -72,11 +108,11 @@ LOCAL_MODULE_TAGS         := optional
 LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
-endif #ENABLE_SECUREMSM_QTEE_DLKM
+endif #ENABLE_QSEECOM_DLKM
 ###################################################
 ###################################################
 
-ifeq ($(ENABLE_SECUREMSM_DLKM), true)
+ifeq ($(ENABLE_QCRYPTO_DLKM), true)
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_MODULE              := qce50_dlkm.ko
@@ -105,8 +141,10 @@ LOCAL_MODULE_TAGS         := optional
 LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
+endif #ENABLE_QCRYPTO_DLKM
 ###################################################
 ###################################################
+ifeq ($(ENABLE_HDCP_QSEECOM_DLKM), true)
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_MODULE              := hdcp_qseecom_dlkm.ko
@@ -115,8 +153,10 @@ LOCAL_MODULE_TAGS         := optional
 LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
+endif #ENABLE_HDCP_QSEECOM_DLKM
 ###################################################
 ###################################################
+ifeq ($(ENABLE_QRNG_DLKM), true)
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_MODULE              := qrng_dlkm.ko
@@ -125,9 +165,10 @@ LOCAL_MODULE_TAGS         := optional
 LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
+endif #ENABLE_QRNG_DLKM
 ###################################################
 ###################################################
-ifeq ($(TARGET_USES_SMMU_PROXY), true)
+ifeq ($(ENABLE_SMMU_PROXY), true)
 include $(CLEAR_VARS)
 #LOCAL_SRC_FILES           := $(SSG_SRC_FILES)
 LOCAL_EXPORT_KO_INCLUDE_DIRS := $(LOCAL_PATH)/smmu-proxy/ $(LOCAL_PATH)/
@@ -137,7 +178,4 @@ LOCAL_MODULE_TAGS         := optional
 LOCAL_MODULE_DEBUG_ENABLE := true
 LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
-endif
-###################################################
-###################################################
-endif #COMPILE_SECUREMSM_DLKM check
+endif #ENABLE_SMMU_PROXY

hdcp/hdcp_main.c

@@ -105,7 +105,7 @@ bool hdcp2_feature_supported(void *data)
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp2_feature_supported);
+EXPORT_SYMBOL_GPL(hdcp2_feature_supported);
 
 int hdcp2_force_encryption(void *ctx, uint32_t enable)
 {
@@ -117,7 +117,7 @@ int hdcp2_force_encryption(void *ctx, uint32_t enable)
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp2_force_encryption);
+EXPORT_SYMBOL_GPL(hdcp2_force_encryption);
 
 int hdcp2_app_comm(void *ctx, enum hdcp2_app_cmd cmd,
 				   struct hdcp2_app_data *app_data)
@@ -168,7 +168,7 @@ error:
 	mutex_unlock(&hdcp2_mutex_g);
 	return ret;
 }
-EXPORT_SYMBOL(hdcp2_app_comm);
+EXPORT_SYMBOL_GPL(hdcp2_app_comm);
 
 int hdcp2_open_stream(void *ctx, uint8_t vc_payload_id, uint8_t stream_number,
 		  uint32_t *stream_id)
@@ -182,7 +182,7 @@ int hdcp2_open_stream(void *ctx, uint8_t vc_payload_id, uint8_t stream_number,
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp2_open_stream);
+EXPORT_SYMBOL_GPL(hdcp2_open_stream);
 
 int hdcp2_close_stream(void *ctx, uint32_t stream_id)
 {
@@ -194,7 +194,7 @@ int hdcp2_close_stream(void *ctx, uint32_t stream_id)
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp2_close_stream);
+EXPORT_SYMBOL_GPL(hdcp2_close_stream);
 
 void *hdcp2_init(u32 device_type)
 {
@@ -206,13 +206,23 @@ void *hdcp2_init(u32 device_type)
 
 	return data;
 }
-EXPORT_SYMBOL(hdcp2_init);
+EXPORT_SYMBOL_GPL(hdcp2_init);
+
+void hdcp2_set_hdcp_key_verify_retries(void *ctx, u32 max_hdcp_key_verify_retries)
+{
+	struct hdcp2_qsee_handle *handle = ctx;
+
+	handle->max_hdcp_key_verify_retries = max_hdcp_key_verify_retries;
+
+	pr_debug("hdcp2 max_hdcp_key_verify_retries %d\n", handle->max_hdcp_key_verify_retries);
+}
+EXPORT_SYMBOL_GPL(hdcp2_set_hdcp_key_verify_retries);
 
 void hdcp2_deinit(void *ctx)
 {
 	ta_interface.trusted_app_hdcp2_deinit(ctx);
 }
-EXPORT_SYMBOL(hdcp2_deinit);
+EXPORT_SYMBOL_GPL(hdcp2_deinit);
 
 void *hdcp1_init(void)
 {
@@ -224,13 +234,23 @@ void *hdcp1_init(void)
 
 	return data;
 }
-EXPORT_SYMBOL(hdcp1_init);
+EXPORT_SYMBOL_GPL(hdcp1_init);
+
+void hdcp1_set_hdcp_key_verify_retries(void *ctx, u32 max_hdcp_key_verify_retries)
+{
+	struct hdcp1_qsee_handle *handle = ctx;
+
+	handle->max_hdcp_key_verify_retries = max_hdcp_key_verify_retries;
+
+	pr_debug("hdcp1 max_hdcp_key_verify_retries %d\n", handle->max_hdcp_key_verify_retries);
+}
+EXPORT_SYMBOL_GPL(hdcp1_set_hdcp_key_verify_retries);
 
 void hdcp1_deinit(void *data)
 {
 	kfree(data);
 }
-EXPORT_SYMBOL(hdcp1_deinit);
+EXPORT_SYMBOL_GPL(hdcp1_deinit);
 
 bool hdcp1_feature_supported(void *data)
 {
@@ -242,7 +262,7 @@ bool hdcp1_feature_supported(void *data)
 
 	return supported;
 }
-EXPORT_SYMBOL(hdcp1_feature_supported);
+EXPORT_SYMBOL_GPL(hdcp1_feature_supported);
 
 int hdcp1_set_enc(void *data, bool enable)
 {
@@ -254,7 +274,7 @@ int hdcp1_set_enc(void *data, bool enable)
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp1_set_enc);
+EXPORT_SYMBOL_GPL(hdcp1_set_enc);
 
 int hdcp1_ops_notify(void *data, void *topo, bool is_authenticated)
 {
@@ -264,7 +284,7 @@ int hdcp1_ops_notify(void *data, void *topo, bool is_authenticated)
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp1_ops_notify);
+EXPORT_SYMBOL_GPL(hdcp1_ops_notify);
 
 int hdcp1_start(void *data, u32 *aksv_msb, u32 *aksv_lsb)
 {
@@ -276,7 +296,7 @@ int hdcp1_start(void *data, u32 *aksv_msb, u32 *aksv_lsb)
 
 	return ret;
 }
-EXPORT_SYMBOL(hdcp1_start);
+EXPORT_SYMBOL_GPL(hdcp1_start);
 
 void hdcp1_stop(void *data)
 {
@@ -284,7 +304,7 @@ void hdcp1_stop(void *data)
 	ta_interface.trusted_app_hdcp1_stop(data);
 	mutex_unlock(&hdcp1_mutex_g);
 }
-EXPORT_SYMBOL(hdcp1_stop);
+EXPORT_SYMBOL_GPL(hdcp1_stop);
 
 static int __init hdcp_module_init(void)
 {

hdcp/hdcp_main.h

@@ -56,6 +56,12 @@
 /* Wait 200ms after authentication */
 #define SLEEP_FORCE_ENCRYPTION_MS 200
 
+/* Error code when Qseecomd is not up at boot time */
+#define QSEECOMD_ERROR -4103
+
+/* Wait for 100ms on every retry to check if Qseecomd is up */
+#define SLEEP_QSEECOMD_WAIT_MS 100
+
 #define SLEEP_SET_HW_KEY_MS 300
 
 /* flags set by tz in response message */

hdcp/hdcp_qseecom.c

@@ -323,6 +323,12 @@ static int hdcp1_verify_key(struct hdcp1_qsee_handle *hdcp1_handle)
 	}
 
 	rc = key_verify_rsp->ret;
+
+	if (rc == QSEECOMD_ERROR)
+		qseecomd_down = true;
+	else
+		qseecomd_down = false;
+
 	if (rc) {
 		pr_err("key_verify failed, rsp=%d\n", key_verify_rsp->ret);
 		return -EINVAL;
@@ -385,6 +391,11 @@ static int hdcp2_verify_key(struct hdcp2_qsee_handle *handle)
 	rc = hdcp2_app_process_cmd(verify_key);
 	pr_debug("verify_key = %d\n", rc);
 
+	if (rsp_buf->status == QSEECOMD_ERROR)
+		qseecomd_down = true;
+	else
+		qseecomd_down = false;
+
 error:
 	return rc;
 }
@@ -468,6 +479,7 @@ bool hdcp1_feature_supported_qseecom(void *data)
 	bool supported = false;
 	struct hdcp1_qsee_handle *handle = data;
 	int rc = 0;
+	int retry = 0;
 
 	if (!handle) {
 		pr_err("invalid handle\n");
@@ -480,11 +492,31 @@ bool hdcp1_feature_supported_qseecom(void *data)
 	}
 
 	rc = hdcp1_app_load(handle);
+
+	/* Other than in SUCCESS case, if there is a FAILURE when
+	 * handle is NULL, the hdcp1_app_load will return zero.
+	 * Checking the hdcp_state will ensure that the conditional
+	 * is ONLY true when hdcp1_app_load had no Failures.
+	 */
 	if (!rc && (handle->hdcp_state & HDCP_STATE_APP_LOADED)) {
-		if (!hdcp1_verify_key(handle)) {
-			pr_debug("HDCP 1.x supported\n");
-			handle->feature_supported = true;
-			supported = true;
+		do {
+			if (!hdcp1_verify_key(handle)) {
+				pr_debug("HDCP 1.x supported\n");
+				pr_debug("hdcp1_verify_key succeeded on %d retry.\n", retry);
+				handle->feature_supported = true;
+				supported = true;
+				break;
+			} else if (qseecomd_down) {
+				pr_debug("Qseecomd is not up. Going to sleep.\n");
+				msleep(SLEEP_QSEECOMD_WAIT_MS);
+				retry++;
+			} else
+				break;
+		} while (handle->max_hdcp_key_verify_retries >= retry);
+
+		if (qseecomd_down) {
+			pr_err("hdcp1_verify_key failed after %d retries as Qseecomd is not up.\n",
+				handle->max_hdcp_key_verify_retries);
 		}
 		hdcp1_app_unload(handle);
 	}
@@ -1252,6 +1284,7 @@ error:
 bool hdcp2_feature_supported_qseecom(void *ctx)
 {
 	int rc = 0;
+	int retry = 0;
 	bool supported = false;
 	struct hdcp2_qsee_handle *handle = (struct hdcp2_qsee_handle *)ctx;
 
@@ -1268,10 +1301,24 @@ bool hdcp2_feature_supported_qseecom(void *ctx)
 
 	rc = hdcp2_app_load(handle);
 	if (!rc) {
-		if (!hdcp2_verify_key(handle)) {
-			pr_debug("HDCP 2.2 supported\n");
-			handle->feature_supported = true;
-			supported = true;
+		do {
+			if (!hdcp2_verify_key(handle)) {
+				pr_debug("HDCP 2.2 supported.\n");
+				pr_debug("hdcp2_verify_key succeeded on %d retry.\n", retry);
+				handle->feature_supported = true;
+				supported = true;
+				break;
+			} else if (qseecomd_down) {
+				pr_debug("Qseecomd is not up. Going to sleep.\n");
+				msleep(SLEEP_QSEECOMD_WAIT_MS);
+				retry++;
+			} else
+				break;
+		} while (handle->max_hdcp_key_verify_retries >= retry);
+
+		if (qseecomd_down) {
+			pr_err("hdcp2_verify_key failed after %d retries as Qseecomd is not up.\n",
+				handle->max_hdcp_key_verify_retries);
 		}
 		hdcp2_app_unload(handle);
 	}

hdcp/hdcp_qseecom.h

@@ -13,6 +13,11 @@
 
 #include "hdcp_main.h"
 
+/*
+ * @max_hdcp_key_verify_retries - Max number of retries by default set to 0 which
+ *                                is equivalent to 0MS. Actual value will be the one
+ *                                from the dtsi file.
+ */
 struct hdcp1_qsee_handle {
 	struct qseecom_handle *qseecom_handle;
 	struct qseecom_handle *hdcpops_handle;
@@ -20,8 +25,22 @@ struct hdcp1_qsee_handle {
 	uint32_t device_type;
 	enum hdcp_state hdcp_state;
 	char *app_name;
+	uint32_t max_hdcp_key_verify_retries;
 };
 
+/*
+ * If Qseecomd starts late and hdcp key
+ * verification has already started, qseecomd_down
+ * flag will be set to true. It will be set to false
+ * once the Qseecomd is up. Initial assumption is
+ * that the Qseecomd will start in time.
+ */
+static bool qseecomd_down;
+/*
+ * @max_hdcp_key_verify_retries - Max number of retries by default set to 0 which
+ *                                is equivalent to 0MS. Actual value will be the one
+ *                                from the dtsi file.
+ */
 struct hdcp2_qsee_handle {
 	struct hdcp2_app_data app_data;
 	uint32_t tz_ctxhandle;
@@ -37,6 +56,7 @@ struct hdcp2_qsee_handle {
 	unsigned char *res_buf;
 	int (*app_init)(struct hdcp2_qsee_handle *handle);
 	int (*tx_init)(struct hdcp2_qsee_handle *handle);
+	uint32_t max_hdcp_key_verify_retries;
 };
 
 struct hdcp1_key_set_req {

securemsm_kernel_product_board.mk

@@ -13,24 +13,59 @@ ifeq ($(TARGET_KERNEL_DLKM_DISABLE), true)
 endif
 
 ifeq ($(ENABLE_SECUREMSM_DLKM), true)
+  ENABLE_QCRYPTO_DLKM := true
+  ENABLE_HDCP_QSEECOM_DLKM := true
+  ENABLE_QRNG_DLKM := true
+  ifeq ($(TARGET_USES_SMMU_PROXY), true)
+    ENABLE_SMMU_PROXY := true
+  endif #TARGET_USES_SMMU_PROXY
+endif #ENABLE_SECUREMSM_DLKM
+
+ifeq ($(ENABLE_SECUREMSM_QTEE_DLKM), true)
+  ENABLE_SMCINVOKE_DLKM := true
+  ENABLE_TZLOG_DLKM := true
+  #Enable Qseecom if TARGET_ENABLE_QSEECOM or TARGET_BOARD_AUTO is set to true
+  ifneq (, $(filter true, $(TARGET_ENABLE_QSEECOM) $(TARGET_BOARD_AUTO)))
+    ENABLE_QSEECOM_DLKM := true
+  endif #TARGET_ENABLE_QSEECOM OR TARGET_BOARD_AUTO
+endif #ENABLE_SECUREMSM_QTEE_DLKM
+
+ifeq ($(TARGET_USES_GY), true)
+  ENABLE_QCRYPTO_DLKM := false
+  ENABLE_HDCP_QSEECOM_DLKM := false
+  ENABLE_QRNG_DLKM := false
+  ENABLE_SMMU_PROXY := false
+  ENABLE_SMCINVOKE_DLKM := true
+  ENABLE_TZLOG_DLKM := false
+  ENABLE_QSEECOM_DLKM := false
+endif #TARGET_USES_GY
+
+ifeq ($(ENABLE_QCRYPTO_DLKM), true)
 PRODUCT_PACKAGES += qcedev-mod_dlkm.ko
 PRODUCT_PACKAGES += qce50_dlkm.ko
 PRODUCT_PACKAGES += qcrypto-msm_dlkm.ko
+endif #ENABLE_QCRYPTO_DLKM
+
+ifeq ($(ENABLE_HDCP_QSEECOM_DLKM), true)
 PRODUCT_PACKAGES += hdcp_qseecom_dlkm.ko
+endif #ENABLE_HDCP_QSEECOM_DLKM
+
+ifeq ($(ENABLE_QRNG_DLKM), true)
 PRODUCT_PACKAGES += qrng_dlkm.ko
+endif #ENABLE_QRNG_DLKM
 
-ifeq ($(TARGET_USES_SMMU_PROXY), true)
+ifeq ($(ENABLE_SMMU_PROXY), true)
 PRODUCT_PACKAGES += smmu_proxy_dlkm.ko
-endif
-endif #ENABLE_SECUREMSM_DLKM
+endif #ENABLE_SMMU_PROXY
 
-ifeq ($(ENABLE_SECUREMSM_QTEE_DLKM), true)
+ifeq ($(ENABLE_SMCINVOKE_DLKM), true)
 PRODUCT_PACKAGES += smcinvoke_dlkm.ko
-PRODUCT_PACKAGES += tz_log_dlkm.ko
-#Enable Qseecom if TARGET_ENABLE_QSEECOM or TARGET_BOARD_AUTO is set to true
-ifneq (, $(filter true, $(TARGET_ENABLE_QSEECOM) $(TARGET_BOARD_AUTO)))
-PRODUCT_PACKAGES += qseecom_dlkm.ko
-endif #TARGET_ENABLE_QSEECOM OR TARGET_BOARD_AUTO
-endif #ENABLE_SECUREMSM_QTEE_DLKM
+endif #ENABLE_SMCINVOKE_DLKM
 
+ifeq ($(ENABLE_TZLOG_DLKM), true)
+PRODUCT_PACKAGES += tz_log_dlkm.ko
+endif #ENABLE_TZLOG_DLKM
 
+ifeq ($(ENABLE_QSEECOM_DLKM), true)
+PRODUCT_PACKAGES += qseecom_dlkm.ko
+endif #ENABLE_QSEECOM_DLKM

securemsm_kernel_vendor_board.mk

@@ -11,32 +11,65 @@ ifeq ($(TARGET_KERNEL_DLKM_DISABLE), true)
 endif
 
 ifeq ($(ENABLE_SECUREMSM_DLKM), true)
+  ENABLE_QCRYPTO_DLKM := true
+  ENABLE_HDCP_QSEECOM_DLKM := true
+  ENABLE_QRNG_DLKM := true
+  ifeq ($(TARGET_USES_SMMU_PROXY), true)
+    ENABLE_SMMU_PROXY := true
+  endif #TARGET_USES_SMMU_PROXY
+endif #ENABLE_SECUREMSM_DLKM
+
+ifeq ($(ENABLE_SECUREMSM_QTEE_DLKM), true)
+  ENABLE_SMCINVOKE_DLKM := true
+  ENABLE_TZLOG_DLKM := true
+  #Enable Qseecom if TARGET_ENABLE_QSEECOM or TARGET_BOARD_AUTO is set to true
+  ifneq (, $(filter true, $(TARGET_ENABLE_QSEECOM) $(TARGET_BOARD_AUTO)))
+    ENABLE_QSEECOM_DLKM := true
+  endif #TARGET_ENABLE_QSEECOM OR TARGET_BOARD_AUTO
+endif #ENABLE_SECUREMSM_QTEE_DLKM
+
+ifeq ($(TARGET_USES_GY), true)
+  ENABLE_QCRYPTO_DLKM := false
+  ENABLE_HDCP_QSEECOM_DLKM := false
+  ENABLE_QRNG_DLKM := false
+  ENABLE_SMMU_PROXY := false
+  ENABLE_SMCINVOKE_DLKM := true
+  ENABLE_TZLOG_DLKM := false
+  ENABLE_QSEECOM_DLKM := false
+endif #TARGET_USES_GY
+
+ifeq ($(ENABLE_QCRYPTO_DLKM), true)
 BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/qcedev-mod_dlkm.ko \
       $(KERNEL_MODULES_OUT)/qcrypto-msm_dlkm.ko \
-      $(KERNEL_MODULES_OUT)/qce50_dlkm.ko \
-      $(KERNEL_MODULES_OUT)/hdcp_qseecom_dlkm.ko \
-      $(KERNEL_MODULES_OUT)/qrng_dlkm.ko \
+      $(KERNEL_MODULES_OUT)/qce50_dlkm.ko
+endif #ENABLE_QCRYPTO_DLKM
 
+ifeq ($(ENABLE_QRNG_DLKM), true)
+BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/qrng_dlkm.ko
+endif #ENABLE_QRNG_DLKM
+
+ifeq ($(ENABLE_HDCP_QSEECOM_DLKM), true)
+BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/hdcp_qseecom_dlkm.ko
 BOARD_VENDOR_RAMDISK_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/hdcp_qseecom_dlkm.ko
+endif #ENABLE_HDCP_QSEECOM_DLKM
 
-ifeq ($(TARGET_USES_SMMU_PROXY), true)
+ifeq ($(ENABLE_SMMU_PROXY), true)
 BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/smmu_proxy_dlkm.ko
-endif
-
-ifeq ($(ENABLE_SECUREMSM_QTEE_DLKM), true)
-
-BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/smcinvoke_dlkm.ko \
-			       $(KERNEL_MODULES_OUT)/tz_log_dlkm.ko \
-
-BOARD_VENDOR_RAMDISK_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/tz_log_dlkm.ko \
-                                       $(KERNEL_MODULES_OUT)/smcinvoke_dlkm.ko \
+endif #ENABLE_SMMU_PROXY
 
+ifeq ($(ENABLE_SMCINVOKE_DLKM), true)
+BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/smcinvoke_dlkm.ko
+BOARD_VENDOR_RAMDISK_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/smcinvoke_dlkm.ko
 BOARD_VENDOR_RAMDISK_RECOVERY_KERNEL_MODULES_LOAD += $(KERNEL_MODULES_OUT)/smcinvoke_dlkm.ko
+endif #ENABLE_SMCINVOKE_DLKM
 
+ifeq ($(ENABLE_TZLOG_DLKM), true)
+BOARD_VENDOR_KERNEL_MODULES +=  $(KERNEL_MODULES_OUT)/tz_log_dlkm.ko
+BOARD_VENDOR_RAMDISK_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/tz_log_dlkm.ko
+endif # ENABLE_TZLOG_DLKM
 
+ifeq ($(ENABLE_QSEECOM_DLKM), true)
 BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/qseecom_dlkm.ko
 BOARD_VENDOR_RAMDISK_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/qseecom_dlkm.ko
 BOARD_VENDOR_RAMDISK_RECOVERY_KERNEL_MODULES_LOAD += $(KERNEL_MODULES_OUT)/qseecom_dlkm.ko
-
-endif #ENABLE_SECUREMSM_QTEE_DLKM
-endif #ENABLE_SECUREMSM_DLKM
+endif #ENABLE_QSEECOM_DLKM

smcinvoke/smcinvoke.c

@@ -248,7 +248,7 @@ struct smcinvoke_msg_hdr {
 struct smcinvoke_tzcb_req {
 	int32_t result;
 	struct smcinvoke_msg_hdr hdr;
-	union smcinvoke_tz_args args[0];
+	union smcinvoke_tz_args args[];
 };
 
 struct smcinvoke_file_data {
@@ -263,7 +263,7 @@ struct smcinvoke_piggyback_msg {
 	uint32_t version;
 	uint32_t op;
 	uint32_t counts;
-	int32_t objs[0];
+	int32_t objs[];
 };
 
 /* Mapped memory object data

smcinvoke/trace_smcinvoke.h

@@ -7,10 +7,7 @@
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM smcinvoke
 
-#undef TRACE_INCLUDE_FILE
-#define TRACE_INCLUDE_FILE trace_smcinvoke
-
-#if !defined(_TRACE_SMCINVOKE) || defined(TRACE_HEADER_MULTI_READ)
+#if !defined(_TRACE_SMCINVOKE_H) || defined(TRACE_HEADER_MULTI_READ)
 #define _TRACE_SMCINVOKE_H
 #include <linux/types.h>
 #include <linux/tracepoint.h>

smmu-proxy/qti-smmu-proxy-tvm.c

@@ -73,13 +73,13 @@ static int iommu_unmap_and_relinquish(u32 hdl)
 	mutex_lock(&buffer_state_lock);
 	buf_state = xa_load(&buffer_state_arr, hdl);
 	if (!buf_state) {
-		pr_err("%s: handle 0x%llx unknown to proxy driver!\n", __func__, hdl);
+		pr_err("%s: handle 0x%x unknown to proxy driver!\n", __func__, hdl);
 		ret = -EINVAL;
 		goto out;
 	}
 
 	if (buf_state->locked) {
-		pr_err("%s: handle 0x%llx is locked!\n", __func__, hdl);
+		pr_err("%s: handle 0x%x is locked!\n", __func__, hdl);
 		ret = -EINVAL;
 		goto out;
 	}
@@ -178,7 +178,7 @@ struct sg_table *retrieve_and_iommu_map(struct mem_buf_retrieve_kernel_arg *retr
 			goto unlock;
 		}
 		if (buf_state->locked) {
-			pr_err("%s: handle 0x%llx is locked!\n", __func__,
+			pr_err("%s: handle 0x%x is locked!\n", __func__,
 			       retrieve_arg->memparcel_hdl);
 			ret = -EINVAL;
 			goto unlock_err;
@@ -299,7 +299,7 @@ static int process_map_request(struct smmu_proxy_map_req *req, size_t size)
 	 * to us by the message queue.
 	 */
 	if (map_req_len > size) {
-		pr_err("%s: Reported size of smmu_proxy_map_request (%d bytes) greater than message size given by message queue (%d bytes)\n",
+		pr_err("%s: Reported size of smmu_proxy_map_request (%ld bytes) greater than message size given by message queue (%ld bytes)\n",
 		       __func__, map_req_len, size);
 		return -EINVAL;
 	}
@@ -369,7 +369,7 @@ static void smmu_proxy_process_msg(void *buf, size_t size)
 	int ret = -EINVAL;
 
 	if (size < sizeof(*msg_hdr) || msg_hdr->msg_size != size) {
-		pr_err("%s: message received is not of a proper size: 0x%lx, 0x:%lx\n",
+		pr_err("%s: message received is not of a proper size: 0x%lx, 0x:%x\n",
 		       __func__, size, msg_hdr->msg_size);
 		goto handle_err;
 	}
@@ -443,7 +443,7 @@ static int smmu_proxy_ac_lock_toggle(int dma_buf_fd, bool lock)
 
 	dmabuf = dma_buf_get(dma_buf_fd);
 	if (IS_ERR(dmabuf)) {
-		pr_err("%s: unable to get dma-buf from FD %d, rc: %d", __func__,
+		pr_err("%s: unable to get dma-buf from FD %d, rc: %ld\n", __func__,
 		       dma_buf_fd, PTR_ERR(dmabuf));
 		return PTR_ERR(dmabuf);
 	}
@@ -457,13 +457,13 @@ static int smmu_proxy_ac_lock_toggle(int dma_buf_fd, bool lock)
 	mutex_lock(&buffer_state_lock);
 	buf_state = xa_load(&buffer_state_arr, handle);
 	if (!buf_state) {
-		pr_err("%s: handle 0x%llx unknown to proxy driver!\n", __func__, handle);
+		pr_err("%s: handle 0x%x unknown to proxy driver!\n", __func__, handle);
 		ret = -EINVAL;
 		goto out;
 	}
 
 	if (buf_state->locked == lock) {
-		pr_err("%s: handle 0x%llx already %s!\n", __func__, handle,
+		pr_err("%s: handle 0x%x already %s!\n", __func__, handle,
 		       lock ? "locked" : "unlocked");
 		ret = -EINVAL;
 		goto out;
@@ -644,7 +644,7 @@ static int receiver_probe_handler(struct device *dev)
 	msgq_hdl = gh_msgq_register(GH_MSGQ_LABEL_SMMU_PROXY);
 	if (IS_ERR(msgq_hdl)) {
 		ret = PTR_ERR(msgq_hdl);
-		dev_err(dev, "Queue registration failed: %d!\n", PTR_ERR(msgq_hdl));
+		dev_err(dev, "Queue registration failed: %ld!\n", PTR_ERR(msgq_hdl));
 		return ret;
 	}
 
@@ -652,7 +652,7 @@ static int receiver_probe_handler(struct device *dev)
 						   "smmu_proxy_msgq_handler");
 	if (IS_ERR(receiver_msgq_handler_thread)) {
 		ret = PTR_ERR(receiver_msgq_handler_thread);
-		dev_err(dev, "Failed to launch receiver_msgq_handler thread: %d\n",
+		dev_err(dev, "Failed to launch receiver_msgq_handler thread: %ld\n",
 			PTR_ERR(receiver_msgq_handler_thread));
 		goto free_msgq;
 	}
@@ -674,7 +674,7 @@ free_msgq:
 static int proxy_fault_handler(struct iommu_domain *domain, struct device *dev,
 			       unsigned long iova, int flags, void *token)
 {
-	dev_err(dev, "Context fault with IOVA %llx and fault flags %d\n", iova, flags);
+	dev_err(dev, "Context fault with IOVA %lx and fault flags %d\n", iova, flags);
 	return -EINVAL;
 }