Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e6ee3e1c authored by qctecmdr Service's avatar qctecmdr Service Committed by Gerrit - the friendly Code Review server
Browse files

Merge "hdcp_qseecom: updating error codes"

parents ec99805e 34dc5b84

drivers/misc/hdcp_qseecom.c

+78 −119
Original line number Diff line number Diff line
@@ -77,44 +77,76 @@ 


/* hdcp command status */

#define HDCP_SUCCESS                    0

#define HDCP_FAIL                       1

#define HDCP_HMAC_FAIL                  2

#define HDCP_AES_FAIL                   3

#define HDCP_BAD_PARAM                  4

#define HDCP_HASH_FAIL                  5

#define HDCP_OUT_OF_MEM                 6

#define HDCP_WRONG_MESSAGE_ID           7

#define HDCP_UNSUPPORTED_TXMTR          8

#define HDCP_WRONG_TXMTR_CAPAB_MASK     9

#define HDCP_UNSUPPORTED_RCVR           10

#define HDCP_WRONG_RCVR_CAPAB_MASK      11

#define HDCP_MAXLC_RETRIES_TRIED        12

#define HDCP_STATE_UNAUTHENTICATED      13

#define HDCP_CE_FAIL                    14

#define HDCP_RSA_FAIL                   15

#define HDCP_GET_RANDOM_FAIL            16

#define HDCP_SFS_FAIL                   17

#define HDCP_HPRIME_MISMATCH            18

#define HDCP_RCVRID_NOT_FOUND           19

#define HDCP_WRONG_STATE                20

#define HDCP_WRONG_V_RETURNED           21

#define HDCP_MAX_DEVICE_EXCEEDED        22

#define HDCP_MAX_CASCADE_EXCEEDED       23

#define HDCP_V_ROLLOVER                 24

#define HDCP_V_MISMATCH                 25

#define HDCP_MPRIME_MISMATCH            26

#define HDCP_NO_RECEIVERIDLIST          27

#define HDCP_TIMEOUT_EXPIRED            28

#define HDCP_SRM_CHECK_FAILURE          29

#define HDCP_INVALID_TXMTR_KEY_FORMAT   30

#define HDCP_INVALID_TXMTR_CONTEXT      31

#define HDCP_INVALID_RCVR_CONTEXT       32

#define HDCP_GENERIC_PROV_FAIL          33

#define HDCP_CONFIG_FAIL                34

#define HDCP_KEY_ALREADY_PROVISIONED    35

#define HDCP_KEY_NOT_PROVISIONED        36

#define HDCP_CALL_TOO_SOON              37

#define HDCP_FORCE_ENCRYPTION_FAILED    38



const char *HdcpErrors[] = {

	"HDCP_SUCCESS",

	"HDCP_FAIL",

	"HDCP_BAD_PARAM",

	"HDCP_DEVICE_TYPE_UNSUPPORTED",

	"HDCP_INVALID_COMMAND",

	"HDCP_INVALID_COMMAND_HANDLE",

	"HDCP_ERROR_SIZE_IN",

	"HDCP_ERROR_SIZE_OUT",

	"HDCP_DATA_SIZE_INSUFFICIENT",

	"HDCP_UNSUPPORTED_RX_VERSION",

	"HDCP_WRONG_RX_CAPAB_MASK",

	"HDCP_WRONG_RX_RSVD",

	"HDCP_WRONG_RX_HDCP_CAPABLE",

	"HDCP_RSA_SIGNATURE_VERIFY_FAILED",

	"HDCP_VERIFY_H_PRIME_FAILED",

	"HDCP_LC_FAILED",

	"HDCP_MESSAGE_TIMEOUT",

	"HDCP_COUNTER_ROLL_OVER",

	"HDCP_WRONG_RXINFO_RSVD",

	"HDCP_RXINFO_MAX_DEVS",

	"HDCP_RXINFO_MAX_CASCADE",

	"HDCP_WRONG_INITIAL_SEQ_NUM_V",

	"HDCP_SEQ_NUM_V_ROLL_OVER",

	"HDCP_WRONG_SEQ_NUM_V",

	"HDCP_VERIFY_V_FAILED",

	"HDCP_RPT_METHOD_INVOKED",

	"HDCP_RPT_STRM_LEN_WRONG",

	"HDCP_VERIFY_STRM_M_FAILED",

	"HDCP_TRANSMITTER_NOT_FOUND",

	"HDCP_SESSION_NOT_FOUND",

	"HDCP_MAX_SESSION_EXCEEDED",

	"HDCP_MAX_CONNECTION_EXCEEDED",

	"HDCP_MAX_STREAMS_EXCEEDED",

	"HDCP_MAX_DEVICES",

	"HDCP_ALLOC_FAILED",

	"HDCP_CONNECTION_NOT_FOUND",

	"HDCP_HASH_FAILED",

	"HDCP_BN_FAILED",

	"HDCP_ENCRYPT_KM_FAILED",

	"HDCP_DECRYPT_KM_FAILED",

	"HDCP_HMAC_FAILED",

	"HDCP_GET_RANDOM_FAILED",

	"HDCP_INVALID_KEY_HEADER",

	"HDCP_INVALID_KEY_LC_HASH",

	"HDCP_INVALID_KEY_HASH",

	"HDCP_KEY_WRITE_FAILED",

	"HDCP_KEY_READ_FAILED",

	"HDCP_KEY_DECRYPT_FAILED",

	"HDCP_TEST_KEY_ON_SECURE_DEVICE",

	"HDCP_KEY_VERSION_UNSUPPORTED",

	"HDCP_RXID_NOT_FOUND",

	"HDCP_STORAGE_INIT_FAILED",

	"HDCP_STORAGE_FILE_OPEN_FAILED",

	"HDCP_STORAGE_FILE_READ_FAILED",

	"HDCP_STORAGE_FILE_WRITE_FAILED",

	"HDCP_STORAGE_ID_UNSUPPORTED",

	"HDCP_MUTUAL_EXCLUSIVE_DEVICE_PRESENT",

	"HDCP_INVALID_STATE",

	"HDCP_CONFIG_READ_FAILED",

	"HDCP_OPEN_TZ_SERVICE_FAILED",

	"HDCP_HW_CLOCK_OFF",

	"HDCP_SET_HW_KEY_FAILED",

	"HDCP_CLEAR_HW_KEY_FAILED",

	"HDCP_GET_CONTENT_LEVEL_FAILED",

	"HDCP_STREAMID_INUSE",

	"HDCP_STREAM_NOT_FOUND",

	"HDCP_FORCE_ENCRYPTION_FAILED"

};



/* flags set by tz in response message */

#define HDCP_TXMTR_SUBSTATE_INIT                              0
@@ -161,8 +193,9 @@ 
		req_buf, QSEECOM_ALIGN(sizeof(struct hdcp_##x##_req)), \

		rsp_buf, QSEECOM_ALIGN(sizeof(struct hdcp_##x##_rsp))); \

	if ((rc < 0) || (rsp_buf->status != HDCP_SUCCESS)) { \

		pr_err("qseecom cmd %s failed with err = %d, status = %s\n", \

			#x, rc, hdcp_cmd_status_to_str(rsp_buf->status)); \

		pr_err("qseecom cmd %s failed with err = %d, status = %d:%s\n" \

		, #x, rc, rsp_buf->status, \

		hdcp_cmd_status_to_str(rsp_buf->status)); \

		rc = -EINVAL; \

	} \

	rc; \
@@ -496,87 +529,13 @@ struct hdcp1_handle { 
#define HDCP_CMD_STATUS_TO_STR(x) #x

static const char *hdcp_cmd_status_to_str(uint32_t err)

{

	switch (err) {

	case HDCP_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_FAIL);

	case HDCP_HMAC_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_HMAC_FAIL);

	case HDCP_AES_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_AES_FAIL);

	case HDCP_BAD_PARAM:

		return HDCP_CMD_STATUS_TO_STR(HDCP_BAD_PARAM);

	case HDCP_HASH_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_HASH_FAIL);

	case HDCP_OUT_OF_MEM:

		return HDCP_CMD_STATUS_TO_STR(HDCP_OUT_OF_MEM);

	case HDCP_WRONG_MESSAGE_ID:

		return HDCP_CMD_STATUS_TO_STR(HDCP_WRONG_MESSAGE_ID);

	case HDCP_UNSUPPORTED_TXMTR:

		return HDCP_CMD_STATUS_TO_STR(HDCP_UNSUPPORTED_TXMTR);

	case HDCP_WRONG_TXMTR_CAPAB_MASK:

		return HDCP_CMD_STATUS_TO_STR(HDCP_WRONG_TXMTR_CAPAB_MASK);

	case HDCP_UNSUPPORTED_RCVR:

		return HDCP_CMD_STATUS_TO_STR(HDCP_UNSUPPORTED_RCVR);

	case HDCP_WRONG_RCVR_CAPAB_MASK:

		return HDCP_CMD_STATUS_TO_STR(HDCP_WRONG_RCVR_CAPAB_MASK);

	case HDCP_MAXLC_RETRIES_TRIED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_MAXLC_RETRIES_TRIED);

	case HDCP_STATE_UNAUTHENTICATED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_STATE_UNAUTHENTICATED);

	case HDCP_CE_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_CE_FAIL);

	case HDCP_RSA_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_RSA_FAIL);

	case HDCP_GET_RANDOM_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_GET_RANDOM_FAIL);

	case HDCP_SFS_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_SFS_FAIL);

	case HDCP_HPRIME_MISMATCH:

		return HDCP_CMD_STATUS_TO_STR(HDCP_HPRIME_MISMATCH);

	case HDCP_RCVRID_NOT_FOUND:

		return HDCP_CMD_STATUS_TO_STR(HDCP_RCVRID_NOT_FOUND);

	case HDCP_WRONG_STATE:

		return HDCP_CMD_STATUS_TO_STR(HDCP_WRONG_STATE);

	case HDCP_WRONG_V_RETURNED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_WRONG_V_RETURNED);

	case HDCP_MAX_DEVICE_EXCEEDED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_MAX_DEVICE_EXCEEDED);

	case HDCP_MAX_CASCADE_EXCEEDED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_MAX_CASCADE_EXCEEDED);

	case HDCP_V_ROLLOVER:

		return HDCP_CMD_STATUS_TO_STR(HDCP_V_ROLLOVER);

	case HDCP_V_MISMATCH:

		return HDCP_CMD_STATUS_TO_STR(HDCP_V_MISMATCH);

	case HDCP_MPRIME_MISMATCH:

		return HDCP_CMD_STATUS_TO_STR(HDCP_MPRIME_MISMATCH);

	case HDCP_NO_RECEIVERIDLIST:

		return HDCP_CMD_STATUS_TO_STR(HDCP_NO_RECEIVERIDLIST);

	case HDCP_TIMEOUT_EXPIRED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_TIMEOUT_EXPIRED);

	case HDCP_SRM_CHECK_FAILURE:

		return HDCP_CMD_STATUS_TO_STR(HDCP_SRM_CHECK_FAILURE);

	case HDCP_INVALID_TXMTR_KEY_FORMAT:

		return HDCP_CMD_STATUS_TO_STR(HDCP_INVALID_TXMTR_KEY_FORMAT);

	case HDCP_INVALID_TXMTR_CONTEXT:

		return HDCP_CMD_STATUS_TO_STR(HDCP_INVALID_TXMTR_CONTEXT);

	case HDCP_INVALID_RCVR_CONTEXT:

		return HDCP_CMD_STATUS_TO_STR(HDCP_INVALID_RCVR_CONTEXT);

	case HDCP_GENERIC_PROV_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_GENERIC_PROV_FAIL);

	case HDCP_CONFIG_FAIL:

		return HDCP_CMD_STATUS_TO_STR(HDCP_CONFIG_FAIL);

	case HDCP_KEY_ALREADY_PROVISIONED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_KEY_ALREADY_PROVISIONED);

	case HDCP_KEY_NOT_PROVISIONED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_KEY_NOT_PROVISIONED);

	case HDCP_CALL_TOO_SOON:

		return HDCP_CMD_STATUS_TO_STR(HDCP_CALL_TOO_SOON);

	case HDCP_FORCE_ENCRYPTION_FAILED:

		return HDCP_CMD_STATUS_TO_STR(HDCP_FORCE_ENCRYPTION_FAILED);

	default:

	int len = ARRAY_SIZE(HdcpErrors);



	if (err >= 0 && err < len)

		return HdcpErrors[err];

	else

		return "";

}

}



static int hdcp_get_version(struct hdcp2_handle *handle)

{