| Message ID | 1522763873-23041-10-git-send-email-ramalingam.c@intel.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
Hi Ramalingam,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on drm-intel/for-linux-next]
[also build test ERROR on next-20180403]
[cannot apply to v4.16]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Ramalingam-C/drm-i915-Implement-HDCP2-2/20180404-031743
base: git://anongit.freedesktop.org/drm-intel for-linux-next
config: i386-allmodconfig (attached as .config)
compiler: gcc-7 (Debian 7.3.0-1) 7.3.0
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All errors (new ones prefixed by >>):
drivers/misc/mei/hdcp/mei_hdcp.c:52:5: error: redefinition of 'mei_initiate_hdcp2_session'
int mei_initiate_hdcp2_session(struct mei_cl_device *cldev,
^~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
include/linux/mei_hdcp.h:129:5: note: previous definition of 'mei_initiate_hdcp2_session' was here
int mei_initiate_hdcp2_session(struct mei_cl_device *cldev,
^~~~~~~~~~~~~~~~~~~~~~~~~~
>> drivers/misc/mei/hdcp/mei_hdcp.c:122:1: error: redefinition of 'mei_verify_receiver_cert_prepare_km'
mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
include/linux/mei_hdcp.h:136:1: note: previous definition of 'mei_verify_receiver_cert_prepare_km' was here
mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/misc/mei/hdcp/mei_hdcp.c:199:5: error: redefinition of 'mei_cldev_register_notify'
int mei_cldev_register_notify(struct notifier_block *nb)
^~~~~~~~~~~~~~~~~~~~~~~~~
In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
include/linux/mei_hdcp.h:120:12: note: previous definition of 'mei_cldev_register_notify' was here
static int mei_cldev_register_notify(struct notifier_block *nb)
^~~~~~~~~~~~~~~~~~~~~~~~~
drivers/misc/mei/hdcp/mei_hdcp.c:205:5: error: redefinition of 'mei_cldev_unregister_notify'
int mei_cldev_unregister_notify(struct notifier_block *nb)
^~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from drivers/misc/mei/hdcp/mei_hdcp.c:35:0:
include/linux/mei_hdcp.h:124:12: note: previous definition of 'mei_cldev_unregister_notify' was here
static int mei_cldev_unregister_notify(struct notifier_block *nb)
^~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/mei_hdcp.h:124:12: warning: 'mei_cldev_unregister_notify' defined but not used [-Wunused-function]
include/linux/mei_hdcp.h:120:12: warning: 'mei_cldev_register_notify' defined but not used [-Wunused-function]
static int mei_cldev_register_notify(struct notifier_block *nb)
^~~~~~~~~~~~~~~~~~~~~~~~~
vim +/mei_verify_receiver_cert_prepare_km +122 drivers/misc/mei/hdcp/mei_hdcp.c
41
42 /**
43 * mei_initiate_hdcp2_session:
44 * Function to start a Wired HDCP2.2 Tx Session with ME FW
45 *
46 * @cldev : Pointer for mei client device
47 * @data : Intel HW specific Data
48 * @ake_data : ptr to store AKE_Init
49 *
50 * Returns 0 on Success, <0 on Failure.
51 */
> 52 int mei_initiate_hdcp2_session(struct mei_cl_device *cldev,
53 struct mei_hdcp_data *data,
54 struct hdcp2_ake_init *ake_data)
55 {
56 struct wired_cmd_initiate_hdcp2_session_in session_init_in = { { 0 } };
57 struct wired_cmd_initiate_hdcp2_session_out
58 session_init_out = { { 0 } };
59 struct device *dev;
60 ssize_t byte;
61
62 if (!data || !ake_data)
63 return -EINVAL;
64
65 dev = &cldev->dev;
66
67 session_init_in.header.api_version = HDCP_API_VERSION;
68 session_init_in.header.command_id = WIRED_INITIATE_HDCP2_SESSION;
69 session_init_in.header.status = ME_HDCP_STATUS_SUCCESS;
70 session_init_in.header.buffer_len =
71 WIRED_CMD_BUF_LEN_INITIATE_HDCP2_SESSION_IN;
72
73 session_init_in.port.integrated_port_type = data->port_type;
74 session_init_in.port.physical_port = data->port;
75 session_init_in.protocol = (uint8_t)data->protocol;
76
77 byte = mei_cldev_send(cldev, (u8 *)&session_init_in,
78 sizeof(session_init_in));
79 if (byte < 0) {
80 dev_dbg(dev, "mei_cldev_send failed. %d\n", (int)byte);
81 return byte;
82 }
83
84 byte = mei_cldev_recv(cldev, (u8 *)&session_init_out,
85 sizeof(session_init_out));
86 if (byte < 0) {
87 dev_dbg(dev, "mei_cldev_recv failed. %d\n", (int)byte);
88 return byte;
89 }
90
91 if (session_init_out.header.status != ME_HDCP_STATUS_SUCCESS) {
92 dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",
93 WIRED_INITIATE_HDCP2_SESSION,
94 session_init_out.header.status);
95 return -1;
96 }
97
98 ake_data->msg_id = HDCP_2_2_AKE_INIT;
99 ake_data->tx_caps = session_init_out.tx_caps;
100 memcpy(ake_data->r_tx, session_init_out.r_tx,
101 sizeof(session_init_out.r_tx));
102
103 return 0;
104 }
105 EXPORT_SYMBOL(mei_initiate_hdcp2_session);
106
107 /**
108 * mei_verify_receiver_cert_prepare_km:
109 * Function to verify the Receiver Certificate AKE_Send_Cert
110 * and prepare AKE_Stored_Km or AKE_No_Stored_Km
111 *
112 * @cldev : Pointer for mei client device
113 * @data : Intel HW specific Data
114 * @rx_cert : Pointer for AKE_Send_Cert
115 * @km_stored : Pointer for pairing status flag
116 * @ek_pub_km : Pointer for output msg
117 * @msg_sz : Pointer for size of AKE_XXXXX_Km
118 *
119 * Returns 0 on Success, <0 on Failure
120 */
121 int
> 122 mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev,
123 struct mei_hdcp_data *data,
124 struct hdcp2_ake_send_cert *rx_cert,
125 bool *km_stored,
126 struct hdcp2_ake_no_stored_km *ek_pub_km,
127 size_t *msg_sz)
128 {
129 struct wired_cmd_verify_receiver_cert_in verify_rxcert_in = { { 0 } };
130 struct wired_cmd_verify_receiver_cert_out verify_rxcert_out = { { 0 } };
131 struct device *dev;
132 ssize_t byte;
133
134 if (!data || !rx_cert || !km_stored || !ek_pub_km || !msg_sz)
135 return -EINVAL;
136
137 dev = &cldev->dev;
138
139 verify_rxcert_in.header.api_version = HDCP_API_VERSION;
140 verify_rxcert_in.header.command_id = WIRED_VERIFY_RECEIVER_CERT;
141 verify_rxcert_in.header.status = ME_HDCP_STATUS_SUCCESS;
142 verify_rxcert_in.header.buffer_len =
143 WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN;
144
145 verify_rxcert_in.port.integrated_port_type = data->port_type;
146 verify_rxcert_in.port.physical_port = data->port;
147
148 memcpy(&verify_rxcert_in.cert_rx, &rx_cert->cert_rx,
149 sizeof(rx_cert->cert_rx));
150 memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, sizeof(rx_cert->r_rx));
151 memcpy(verify_rxcert_in.rx_caps, rx_cert->rx_caps, HDCP_2_2_RXCAPS_LEN);
152
153 byte = mei_cldev_send(cldev, (u8 *)&verify_rxcert_in,
154 sizeof(verify_rxcert_in));
155 if (byte < 0) {
156 dev_dbg(dev, "mei_cldev_send failed: %d\n", (int)byte);
157 return byte;
158 }
159
160 byte = mei_cldev_recv(cldev, (u8 *)&verify_rxcert_out,
161 sizeof(verify_rxcert_out));
162 if (byte < 0) {
163 dev_dbg(dev, "mei_cldev_recv failed: %d\n", (int)byte);
164 return byte;
165 }
166
167 if (verify_rxcert_out.header.status != ME_HDCP_STATUS_SUCCESS) {
168 dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n",
169 WIRED_VERIFY_RECEIVER_CERT,
170 verify_rxcert_out.header.status);
171 return -1;
172 }
173
174 *km_stored = verify_rxcert_out.km_stored;
175 if (verify_rxcert_out.km_stored) {
176 ek_pub_km->msg_id = HDCP_2_2_AKE_STORED_KM;
177 *msg_sz = sizeof(struct hdcp2_ake_stored_km);
178 } else {
179 ek_pub_km->msg_id = HDCP_2_2_AKE_NO_STORED_KM;
180 *msg_sz = sizeof(struct hdcp2_ake_no_stored_km);
181 }
182
183 memcpy(ek_pub_km->e_kpub_km, &verify_rxcert_out.ekm_buff,
184 sizeof(verify_rxcert_out.ekm_buff));
185 return 0;
186 }
187 EXPORT_SYMBOL(mei_verify_receiver_cert_prepare_km);
188
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
diff --git a/drivers/misc/mei/hdcp/mei_hdcp.c b/drivers/misc/mei/hdcp/mei_hdcp.c index 7caee0947761..181994529058 100644 --- a/drivers/misc/mei/hdcp/mei_hdcp.c +++ b/drivers/misc/mei/hdcp/mei_hdcp.c @@ -104,6 +104,88 @@ int mei_initiate_hdcp2_session(struct mei_cl_device *cldev, } EXPORT_SYMBOL(mei_initiate_hdcp2_session); +/** + * mei_verify_receiver_cert_prepare_km: + * Function to verify the Receiver Certificate AKE_Send_Cert + * and prepare AKE_Stored_Km or AKE_No_Stored_Km + * + * @cldev : Pointer for mei client device + * @data : Intel HW specific Data + * @rx_cert : Pointer for AKE_Send_Cert + * @km_stored : Pointer for pairing status flag + * @ek_pub_km : Pointer for output msg + * @msg_sz : Pointer for size of AKE_XXXXX_Km + * + * Returns 0 on Success, <0 on Failure + */ +int +mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev, + struct mei_hdcp_data *data, + struct hdcp2_ake_send_cert *rx_cert, + bool *km_stored, + struct hdcp2_ake_no_stored_km *ek_pub_km, + size_t *msg_sz) +{ + struct wired_cmd_verify_receiver_cert_in verify_rxcert_in = { { 0 } }; + struct wired_cmd_verify_receiver_cert_out verify_rxcert_out = { { 0 } }; + struct device *dev; + ssize_t byte; + + if (!data || !rx_cert || !km_stored || !ek_pub_km || !msg_sz) + return -EINVAL; + + dev = &cldev->dev; + + verify_rxcert_in.header.api_version = HDCP_API_VERSION; + verify_rxcert_in.header.command_id = WIRED_VERIFY_RECEIVER_CERT; + verify_rxcert_in.header.status = ME_HDCP_STATUS_SUCCESS; + verify_rxcert_in.header.buffer_len = + WIRED_CMD_BUF_LEN_VERIFY_RECEIVER_CERT_IN; + + verify_rxcert_in.port.integrated_port_type = data->port_type; + verify_rxcert_in.port.physical_port = data->port; + + memcpy(&verify_rxcert_in.cert_rx, &rx_cert->cert_rx, + sizeof(rx_cert->cert_rx)); + memcpy(verify_rxcert_in.r_rx, &rx_cert->r_rx, sizeof(rx_cert->r_rx)); + memcpy(verify_rxcert_in.rx_caps, rx_cert->rx_caps, HDCP_2_2_RXCAPS_LEN); + + byte = mei_cldev_send(cldev, (u8 *)&verify_rxcert_in, + sizeof(verify_rxcert_in)); + if (byte < 0) { + dev_dbg(dev, "mei_cldev_send failed: %d\n", (int)byte); + return byte; + } + + byte = mei_cldev_recv(cldev, (u8 *)&verify_rxcert_out, + sizeof(verify_rxcert_out)); + if (byte < 0) { + dev_dbg(dev, "mei_cldev_recv failed: %d\n", (int)byte); + return byte; + } + + if (verify_rxcert_out.header.status != ME_HDCP_STATUS_SUCCESS) { + dev_dbg(dev, "ME cmd 0x%08X Failed. Status: 0x%X\n", + WIRED_VERIFY_RECEIVER_CERT, + verify_rxcert_out.header.status); + return -1; + } + + *km_stored = verify_rxcert_out.km_stored; + if (verify_rxcert_out.km_stored) { + ek_pub_km->msg_id = HDCP_2_2_AKE_STORED_KM; + *msg_sz = sizeof(struct hdcp2_ake_stored_km); + } else { + ek_pub_km->msg_id = HDCP_2_2_AKE_NO_STORED_KM; + *msg_sz = sizeof(struct hdcp2_ake_no_stored_km); + } + + memcpy(ek_pub_km->e_kpub_km, &verify_rxcert_out.ekm_buff, + sizeof(verify_rxcert_out.ekm_buff)); + return 0; +} +EXPORT_SYMBOL(mei_verify_receiver_cert_prepare_km); + void mei_cldev_state_notify_clients(struct mei_cl_device *cldev, bool enabled) { if (enabled) diff --git a/include/linux/mei_hdcp.h b/include/linux/mei_hdcp.h index bb4f27d3abcb..314b15f6afc0 100644 --- a/include/linux/mei_hdcp.h +++ b/include/linux/mei_hdcp.h @@ -109,6 +109,13 @@ int mei_cldev_unregister_notify(struct notifier_block *nb); int mei_initiate_hdcp2_session(struct mei_cl_device *cldev, struct mei_hdcp_data *data, struct hdcp2_ake_init *ake_data); +int +mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev, + struct mei_hdcp_data *data, + struct hdcp2_ake_send_cert *rx_cert, + bool *km_stored, + struct hdcp2_ake_no_stored_km *ek_pub_km, + size_t *msg_sz); #else static int mei_cldev_register_notify(struct notifier_block *nb) { @@ -125,5 +132,15 @@ int mei_initiate_hdcp2_session(struct mei_cl_device *cldev, { return -ENODEV; } +static inline int +mei_verify_receiver_cert_prepare_km(struct mei_cl_device *cldev, + struct mei_hdcp_data *data, + struct hdcp2_ake_send_cert *rx_cert, + bool *km_stored, + struct hdcp2_ake_no_stored_km *ek_pub_km, + size_t *msg_sz) +{ + return -ENODEV; +} #endif /* defined (CONFIG_INTEL_MEI_HDCP) */ #endif /* defined (_LINUX_MEI_HDCP_H) */
Requests for verification for receiver certification and also the preparation for next AKE auth message with km. On Success ME FW validate the HDCP2.2 receivers certificate and do the revocation check on the receiver ID. AKE_Stored_Km will be prepared if the receiver is already paired, else AKE_No_Stored_Km will be prepared. Here AKE_Stored_Km and AKE_No_Stored_Km are HDCP2.2 protocol msgs. v2: Rebased. v3: cldev is passed as first parameter [Tomas] Redundant comments and cast are removed [Tomas] Signed-off-by: Ramalingam C <ramalingam.c@intel.com> --- drivers/misc/mei/hdcp/mei_hdcp.c | 82 ++++++++++++++++++++++++++++++++++++++++ include/linux/mei_hdcp.h | 17 +++++++++ 2 files changed, 99 insertions(+)