Loading...
1/* Copyright (c) 2010-2015, The Linux Foundation. All rights reserved.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 */
13
14#include "hdmi.h"
15#include <linux/qcom_scm.h>
16
17#define HDCP_REG_ENABLE 0x01
18#define HDCP_REG_DISABLE 0x00
19#define HDCP_PORT_ADDR 0x74
20
21#define HDCP_INT_STATUS_MASK ( \
22 HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_INT | \
23 HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT | \
24 HDMI_HDCP_INT_CTRL_AUTH_XFER_REQ_INT | \
25 HDMI_HDCP_INT_CTRL_AUTH_XFER_DONE_INT)
26
27#define AUTH_WORK_RETRIES_TIME 100
28#define AUTH_RETRIES_TIME 30
29
30/* QFPROM Registers for HDMI/HDCP */
31#define QFPROM_RAW_FEAT_CONFIG_ROW0_LSB 0x000000F8
32#define QFPROM_RAW_FEAT_CONFIG_ROW0_MSB 0x000000FC
33#define HDCP_KSV_LSB 0x000060D8
34#define HDCP_KSV_MSB 0x000060DC
35
36enum DS_TYPE { /* type of downstream device */
37 DS_UNKNOWN,
38 DS_RECEIVER,
39 DS_REPEATER,
40};
41
42enum hdmi_hdcp_state {
43 HDCP_STATE_NO_AKSV,
44 HDCP_STATE_INACTIVE,
45 HDCP_STATE_AUTHENTICATING,
46 HDCP_STATE_AUTHENTICATED,
47 HDCP_STATE_AUTH_FAILED
48};
49
50struct hdmi_hdcp_reg_data {
51 u32 reg_id;
52 u32 off;
53 char *name;
54 u32 reg_val;
55};
56
57struct hdmi_hdcp_ctrl {
58 struct hdmi *hdmi;
59 u32 auth_retries;
60 bool tz_hdcp;
61 enum hdmi_hdcp_state hdcp_state;
62 struct work_struct hdcp_auth_work;
63 struct work_struct hdcp_reauth_work;
64
65#define AUTH_ABORT_EV 1
66#define AUTH_RESULT_RDY_EV 2
67 unsigned long auth_event;
68 wait_queue_head_t auth_event_queue;
69
70 u32 ksv_fifo_w_index;
71 /*
72 * store aksv from qfprom
73 */
74 u32 aksv_lsb;
75 u32 aksv_msb;
76 bool aksv_valid;
77 u32 ds_type;
78 u32 bksv_lsb;
79 u32 bksv_msb;
80 u8 dev_count;
81 u8 depth;
82 u8 ksv_list[5 * 127];
83 bool max_cascade_exceeded;
84 bool max_dev_exceeded;
85};
86
87static int msm_hdmi_ddc_read(struct hdmi *hdmi, u16 addr, u8 offset,
88 u8 *data, u16 data_len)
89{
90 int rc;
91 int retry = 5;
92 struct i2c_msg msgs[] = {
93 {
94 .addr = addr >> 1,
95 .flags = 0,
96 .len = 1,
97 .buf = &offset,
98 }, {
99 .addr = addr >> 1,
100 .flags = I2C_M_RD,
101 .len = data_len,
102 .buf = data,
103 }
104 };
105
106 DBG("Start DDC read");
107retry:
108 rc = i2c_transfer(hdmi->i2c, msgs, 2);
109
110 retry--;
111 if (rc == 2)
112 rc = 0;
113 else if (retry > 0)
114 goto retry;
115 else
116 rc = -EIO;
117
118 DBG("End DDC read %d", rc);
119
120 return rc;
121}
122
123#define HDCP_DDC_WRITE_MAX_BYTE_NUM 32
124
125static int msm_hdmi_ddc_write(struct hdmi *hdmi, u16 addr, u8 offset,
126 u8 *data, u16 data_len)
127{
128 int rc;
129 int retry = 10;
130 u8 buf[HDCP_DDC_WRITE_MAX_BYTE_NUM];
131 struct i2c_msg msgs[] = {
132 {
133 .addr = addr >> 1,
134 .flags = 0,
135 .len = 1,
136 }
137 };
138
139 DBG("Start DDC write");
140 if (data_len > (HDCP_DDC_WRITE_MAX_BYTE_NUM - 1)) {
141 pr_err("%s: write size too big\n", __func__);
142 return -ERANGE;
143 }
144
145 buf[0] = offset;
146 memcpy(&buf[1], data, data_len);
147 msgs[0].buf = buf;
148 msgs[0].len = data_len + 1;
149retry:
150 rc = i2c_transfer(hdmi->i2c, msgs, 1);
151
152 retry--;
153 if (rc == 1)
154 rc = 0;
155 else if (retry > 0)
156 goto retry;
157 else
158 rc = -EIO;
159
160 DBG("End DDC write %d", rc);
161
162 return rc;
163}
164
165static int msm_hdmi_hdcp_scm_wr(struct hdmi_hdcp_ctrl *hdcp_ctrl, u32 *preg,
166 u32 *pdata, u32 count)
167{
168 struct hdmi *hdmi = hdcp_ctrl->hdmi;
169 struct qcom_scm_hdcp_req scm_buf[QCOM_SCM_HDCP_MAX_REQ_CNT];
170 u32 resp, phy_addr, idx = 0;
171 int i, ret = 0;
172
173 WARN_ON(!pdata || !preg || (count == 0));
174
175 if (hdcp_ctrl->tz_hdcp) {
176 phy_addr = (u32)hdmi->mmio_phy_addr;
177
178 while (count) {
179 memset(scm_buf, 0, sizeof(scm_buf));
180 for (i = 0; i < count && i < QCOM_SCM_HDCP_MAX_REQ_CNT;
181 i++) {
182 scm_buf[i].addr = phy_addr + preg[idx];
183 scm_buf[i].val = pdata[idx];
184 idx++;
185 }
186 ret = qcom_scm_hdcp_req(scm_buf, i, &resp);
187
188 if (ret || resp) {
189 pr_err("%s: error: scm_call ret=%d resp=%u\n",
190 __func__, ret, resp);
191 ret = -EINVAL;
192 break;
193 }
194
195 count -= i;
196 }
197 } else {
198 for (i = 0; i < count; i++)
199 hdmi_write(hdmi, preg[i], pdata[i]);
200 }
201
202 return ret;
203}
204
205void msm_hdmi_hdcp_irq(struct hdmi_hdcp_ctrl *hdcp_ctrl)
206{
207 struct hdmi *hdmi = hdcp_ctrl->hdmi;
208 u32 reg_val, hdcp_int_status;
209 unsigned long flags;
210
211 spin_lock_irqsave(&hdmi->reg_lock, flags);
212 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_INT_CTRL);
213 hdcp_int_status = reg_val & HDCP_INT_STATUS_MASK;
214 if (!hdcp_int_status) {
215 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
216 return;
217 }
218 /* Clear Interrupts */
219 reg_val |= hdcp_int_status << 1;
220 /* Clear AUTH_FAIL_INFO as well */
221 if (hdcp_int_status & HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT)
222 reg_val |= HDMI_HDCP_INT_CTRL_AUTH_FAIL_INFO_ACK;
223 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL, reg_val);
224 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
225
226 DBG("hdcp irq %x", hdcp_int_status);
227
228 if (hdcp_int_status & HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_INT) {
229 pr_info("%s:AUTH_SUCCESS_INT received\n", __func__);
230 if (HDCP_STATE_AUTHENTICATING == hdcp_ctrl->hdcp_state) {
231 set_bit(AUTH_RESULT_RDY_EV, &hdcp_ctrl->auth_event);
232 wake_up_all(&hdcp_ctrl->auth_event_queue);
233 }
234 }
235
236 if (hdcp_int_status & HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT) {
237 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
238 pr_info("%s: AUTH_FAIL_INT rcvd, LINK0_STATUS=0x%08x\n",
239 __func__, reg_val);
240 if (HDCP_STATE_AUTHENTICATED == hdcp_ctrl->hdcp_state)
241 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_reauth_work);
242 else if (HDCP_STATE_AUTHENTICATING ==
243 hdcp_ctrl->hdcp_state) {
244 set_bit(AUTH_RESULT_RDY_EV, &hdcp_ctrl->auth_event);
245 wake_up_all(&hdcp_ctrl->auth_event_queue);
246 }
247 }
248}
249
250static int msm_hdmi_hdcp_msleep(struct hdmi_hdcp_ctrl *hdcp_ctrl, u32 ms, u32 ev)
251{
252 int rc;
253
254 rc = wait_event_timeout(hdcp_ctrl->auth_event_queue,
255 !!test_bit(ev, &hdcp_ctrl->auth_event),
256 msecs_to_jiffies(ms));
257 if (rc) {
258 pr_info("%s: msleep is canceled by event %d\n",
259 __func__, ev);
260 clear_bit(ev, &hdcp_ctrl->auth_event);
261 return -ECANCELED;
262 }
263
264 return 0;
265}
266
267static int msm_hdmi_hdcp_read_validate_aksv(struct hdmi_hdcp_ctrl *hdcp_ctrl)
268{
269 struct hdmi *hdmi = hdcp_ctrl->hdmi;
270
271 /* Fetch aksv from QFPROM, this info should be public. */
272 hdcp_ctrl->aksv_lsb = hdmi_qfprom_read(hdmi, HDCP_KSV_LSB);
273 hdcp_ctrl->aksv_msb = hdmi_qfprom_read(hdmi, HDCP_KSV_MSB);
274
275 /* check there are 20 ones in AKSV */
276 if ((hweight32(hdcp_ctrl->aksv_lsb) + hweight32(hdcp_ctrl->aksv_msb))
277 != 20) {
278 pr_err("%s: AKSV QFPROM doesn't have 20 1's, 20 0's\n",
279 __func__);
280 pr_err("%s: QFPROM AKSV chk failed (AKSV=%02x%08x)\n",
281 __func__, hdcp_ctrl->aksv_msb,
282 hdcp_ctrl->aksv_lsb);
283 return -EINVAL;
284 }
285 DBG("AKSV=%02x%08x", hdcp_ctrl->aksv_msb, hdcp_ctrl->aksv_lsb);
286
287 return 0;
288}
289
290static int msm_reset_hdcp_ddc_failures(struct hdmi_hdcp_ctrl *hdcp_ctrl)
291{
292 struct hdmi *hdmi = hdcp_ctrl->hdmi;
293 u32 reg_val, failure, nack0;
294 int rc = 0;
295
296 /* Check for any DDC transfer failures */
297 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS);
298 failure = reg_val & HDMI_HDCP_DDC_STATUS_FAILED;
299 nack0 = reg_val & HDMI_HDCP_DDC_STATUS_NACK0;
300 DBG("HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d",
301 reg_val, failure, nack0);
302
303 if (failure) {
304 /*
305 * Indicates that the last HDCP HW DDC transfer failed.
306 * This occurs when a transfer is attempted with HDCP DDC
307 * disabled (HDCP_DDC_DISABLE=1) or the number of retries
308 * matches HDCP_DDC_RETRY_CNT.
309 * Failure occurred, let's clear it.
310 */
311 DBG("DDC failure detected");
312
313 /* First, Disable DDC */
314 hdmi_write(hdmi, REG_HDMI_HDCP_DDC_CTRL_0,
315 HDMI_HDCP_DDC_CTRL_0_DISABLE);
316
317 /* ACK the Failure to Clear it */
318 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_CTRL_1);
319 reg_val |= HDMI_HDCP_DDC_CTRL_1_FAILED_ACK;
320 hdmi_write(hdmi, REG_HDMI_HDCP_DDC_CTRL_1, reg_val);
321
322 /* Check if the FAILURE got Cleared */
323 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS);
324 if (reg_val & HDMI_HDCP_DDC_STATUS_FAILED)
325 pr_info("%s: Unable to clear HDCP DDC Failure\n",
326 __func__);
327
328 /* Re-Enable HDCP DDC */
329 hdmi_write(hdmi, REG_HDMI_HDCP_DDC_CTRL_0, 0);
330 }
331
332 if (nack0) {
333 DBG("Before: HDMI_DDC_SW_STATUS=0x%08x",
334 hdmi_read(hdmi, REG_HDMI_DDC_SW_STATUS));
335 /* Reset HDMI DDC software status */
336 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
337 reg_val |= HDMI_DDC_CTRL_SW_STATUS_RESET;
338 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
339
340 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
341
342 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
343 reg_val &= ~HDMI_DDC_CTRL_SW_STATUS_RESET;
344 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
345
346 /* Reset HDMI DDC Controller */
347 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
348 reg_val |= HDMI_DDC_CTRL_SOFT_RESET;
349 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
350
351 /* If previous msleep is aborted, skip this msleep */
352 if (!rc)
353 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
354
355 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
356 reg_val &= ~HDMI_DDC_CTRL_SOFT_RESET;
357 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
358 DBG("After: HDMI_DDC_SW_STATUS=0x%08x",
359 hdmi_read(hdmi, REG_HDMI_DDC_SW_STATUS));
360 }
361
362 return rc;
363}
364
365static int msm_hdmi_hdcp_hw_ddc_clean(struct hdmi_hdcp_ctrl *hdcp_ctrl)
366{
367 int rc;
368 u32 hdcp_ddc_status, ddc_hw_status;
369 u32 xfer_done, xfer_req, hw_done;
370 bool hw_not_ready;
371 u32 timeout_count;
372 struct hdmi *hdmi = hdcp_ctrl->hdmi;
373
374 if (hdmi_read(hdmi, REG_HDMI_DDC_HW_STATUS) == 0)
375 return 0;
376
377 /* Wait to be clean on DDC HW engine */
378 timeout_count = 100;
379 do {
380 hdcp_ddc_status = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS);
381 ddc_hw_status = hdmi_read(hdmi, REG_HDMI_DDC_HW_STATUS);
382
383 xfer_done = hdcp_ddc_status & HDMI_HDCP_DDC_STATUS_XFER_DONE;
384 xfer_req = hdcp_ddc_status & HDMI_HDCP_DDC_STATUS_XFER_REQ;
385 hw_done = ddc_hw_status & HDMI_DDC_HW_STATUS_DONE;
386 hw_not_ready = !xfer_done || xfer_req || !hw_done;
387
388 if (hw_not_ready)
389 break;
390
391 timeout_count--;
392 if (!timeout_count) {
393 pr_warn("%s: hw_ddc_clean failed\n", __func__);
394 return -ETIMEDOUT;
395 }
396
397 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
398 if (rc)
399 return rc;
400 } while (1);
401
402 return 0;
403}
404
405static void msm_hdmi_hdcp_reauth_work(struct work_struct *work)
406{
407 struct hdmi_hdcp_ctrl *hdcp_ctrl = container_of(work,
408 struct hdmi_hdcp_ctrl, hdcp_reauth_work);
409 struct hdmi *hdmi = hdcp_ctrl->hdmi;
410 unsigned long flags;
411 u32 reg_val;
412
413 DBG("HDCP REAUTH WORK");
414 /*
415 * Disable HPD circuitry.
416 * This is needed to reset the HDCP cipher engine so that when we
417 * attempt a re-authentication, HW would clear the AN0_READY and
418 * AN1_READY bits in HDMI_HDCP_LINK0_STATUS register
419 */
420 spin_lock_irqsave(&hdmi->reg_lock, flags);
421 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
422 reg_val &= ~HDMI_HPD_CTRL_ENABLE;
423 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
424
425 /* Disable HDCP interrupts */
426 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL, 0);
427 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
428
429 hdmi_write(hdmi, REG_HDMI_HDCP_RESET,
430 HDMI_HDCP_RESET_LINK0_DEAUTHENTICATE);
431
432 /* Wait to be clean on DDC HW engine */
433 if (msm_hdmi_hdcp_hw_ddc_clean(hdcp_ctrl)) {
434 pr_info("%s: reauth work aborted\n", __func__);
435 return;
436 }
437
438 /* Disable encryption and disable the HDCP block */
439 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL, 0);
440
441 /* Enable HPD circuitry */
442 spin_lock_irqsave(&hdmi->reg_lock, flags);
443 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
444 reg_val |= HDMI_HPD_CTRL_ENABLE;
445 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
446 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
447
448 /*
449 * Only retry defined times then abort current authenticating process
450 */
451 if (++hdcp_ctrl->auth_retries == AUTH_RETRIES_TIME) {
452 hdcp_ctrl->hdcp_state = HDCP_STATE_INACTIVE;
453 hdcp_ctrl->auth_retries = 0;
454 pr_info("%s: abort reauthentication!\n", __func__);
455
456 return;
457 }
458
459 DBG("Queue AUTH WORK");
460 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTHENTICATING;
461 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_auth_work);
462}
463
464static int msm_hdmi_hdcp_auth_prepare(struct hdmi_hdcp_ctrl *hdcp_ctrl)
465{
466 struct hdmi *hdmi = hdcp_ctrl->hdmi;
467 u32 link0_status;
468 u32 reg_val;
469 unsigned long flags;
470 int rc;
471
472 if (!hdcp_ctrl->aksv_valid) {
473 rc = msm_hdmi_hdcp_read_validate_aksv(hdcp_ctrl);
474 if (rc) {
475 pr_err("%s: ASKV validation failed\n", __func__);
476 hdcp_ctrl->hdcp_state = HDCP_STATE_NO_AKSV;
477 return -ENOTSUPP;
478 }
479 hdcp_ctrl->aksv_valid = true;
480 }
481
482 spin_lock_irqsave(&hdmi->reg_lock, flags);
483 /* disable HDMI Encrypt */
484 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
485 reg_val &= ~HDMI_CTRL_ENCRYPTED;
486 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
487
488 /* Enabling Software DDC */
489 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_ARBITRATION);
490 reg_val &= ~HDMI_DDC_ARBITRATION_HW_ARBITRATION;
491 hdmi_write(hdmi, REG_HDMI_DDC_ARBITRATION, reg_val);
492 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
493
494 /*
495 * Write AKSV read from QFPROM to the HDCP registers.
496 * This step is needed for HDCP authentication and must be
497 * written before enabling HDCP.
498 */
499 hdmi_write(hdmi, REG_HDMI_HDCP_SW_LOWER_AKSV, hdcp_ctrl->aksv_lsb);
500 hdmi_write(hdmi, REG_HDMI_HDCP_SW_UPPER_AKSV, hdcp_ctrl->aksv_msb);
501
502 /*
503 * HDCP setup prior to enabling HDCP_CTRL.
504 * Setup seed values for random number An.
505 */
506 hdmi_write(hdmi, REG_HDMI_HDCP_ENTROPY_CTRL0, 0xB1FFB0FF);
507 hdmi_write(hdmi, REG_HDMI_HDCP_ENTROPY_CTRL1, 0xF00DFACE);
508
509 /* Disable the RngCipher state */
510 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DEBUG_CTRL);
511 reg_val &= ~HDMI_HDCP_DEBUG_CTRL_RNG_CIPHER;
512 hdmi_write(hdmi, REG_HDMI_HDCP_DEBUG_CTRL, reg_val);
513 DBG("HDCP_DEBUG_CTRL=0x%08x",
514 hdmi_read(hdmi, REG_HDMI_HDCP_DEBUG_CTRL));
515
516 /*
517 * Ensure that all register writes are completed before
518 * enabling HDCP cipher
519 */
520 wmb();
521
522 /*
523 * Enable HDCP
524 * This needs to be done as early as possible in order for the
525 * hardware to make An available to read
526 */
527 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL, HDMI_HDCP_CTRL_ENABLE);
528
529 /*
530 * If we had stale values for the An ready bit, it should most
531 * likely be cleared now after enabling HDCP cipher
532 */
533 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
534 DBG("After enabling HDCP Link0_Status=0x%08x", link0_status);
535 if (!(link0_status &
536 (HDMI_HDCP_LINK0_STATUS_AN_0_READY |
537 HDMI_HDCP_LINK0_STATUS_AN_1_READY)))
538 DBG("An not ready after enabling HDCP");
539
540 /* Clear any DDC failures from previous tries before enable HDCP*/
541 rc = msm_reset_hdcp_ddc_failures(hdcp_ctrl);
542
543 return rc;
544}
545
546static void msm_hdmi_hdcp_auth_fail(struct hdmi_hdcp_ctrl *hdcp_ctrl)
547{
548 struct hdmi *hdmi = hdcp_ctrl->hdmi;
549 u32 reg_val;
550 unsigned long flags;
551
552 DBG("hdcp auth failed, queue reauth work");
553 /* clear HDMI Encrypt */
554 spin_lock_irqsave(&hdmi->reg_lock, flags);
555 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
556 reg_val &= ~HDMI_CTRL_ENCRYPTED;
557 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
558 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
559
560 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTH_FAILED;
561 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_reauth_work);
562}
563
564static void msm_hdmi_hdcp_auth_done(struct hdmi_hdcp_ctrl *hdcp_ctrl)
565{
566 struct hdmi *hdmi = hdcp_ctrl->hdmi;
567 u32 reg_val;
568 unsigned long flags;
569
570 /*
571 * Disable software DDC before going into part3 to make sure
572 * there is no Arbitration between software and hardware for DDC
573 */
574 spin_lock_irqsave(&hdmi->reg_lock, flags);
575 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_ARBITRATION);
576 reg_val |= HDMI_DDC_ARBITRATION_HW_ARBITRATION;
577 hdmi_write(hdmi, REG_HDMI_DDC_ARBITRATION, reg_val);
578 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
579
580 /* enable HDMI Encrypt */
581 spin_lock_irqsave(&hdmi->reg_lock, flags);
582 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
583 reg_val |= HDMI_CTRL_ENCRYPTED;
584 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
585 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
586
587 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTHENTICATED;
588 hdcp_ctrl->auth_retries = 0;
589}
590
591/*
592 * hdcp authenticating part 1
593 * Wait Key/An ready
594 * Read BCAPS from sink
595 * Write BCAPS and AKSV into HDCP engine
596 * Write An and AKSV to sink
597 * Read BKSV from sink and write into HDCP engine
598 */
599static int msm_hdmi_hdcp_wait_key_an_ready(struct hdmi_hdcp_ctrl *hdcp_ctrl)
600{
601 int rc;
602 struct hdmi *hdmi = hdcp_ctrl->hdmi;
603 u32 link0_status, keys_state;
604 u32 timeout_count;
605 bool an_ready;
606
607 /* Wait for HDCP keys to be checked and validated */
608 timeout_count = 100;
609 do {
610 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
611 keys_state = (link0_status >> 28) & 0x7;
612 if (keys_state == HDCP_KEYS_STATE_VALID)
613 break;
614
615 DBG("Keys not ready(%d). s=%d, l0=%0x08x",
616 timeout_count, keys_state, link0_status);
617
618 timeout_count--;
619 if (!timeout_count) {
620 pr_err("%s: Wait key state timedout", __func__);
621 return -ETIMEDOUT;
622 }
623
624 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
625 if (rc)
626 return rc;
627 } while (1);
628
629 timeout_count = 100;
630 do {
631 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
632 an_ready = (link0_status & HDMI_HDCP_LINK0_STATUS_AN_0_READY)
633 && (link0_status & HDMI_HDCP_LINK0_STATUS_AN_1_READY);
634 if (an_ready)
635 break;
636
637 DBG("An not ready(%d). l0_status=0x%08x",
638 timeout_count, link0_status);
639
640 timeout_count--;
641 if (!timeout_count) {
642 pr_err("%s: Wait An timedout", __func__);
643 return -ETIMEDOUT;
644 }
645
646 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
647 if (rc)
648 return rc;
649 } while (1);
650
651 return 0;
652}
653
654static int msm_hdmi_hdcp_send_aksv_an(struct hdmi_hdcp_ctrl *hdcp_ctrl)
655{
656 int rc = 0;
657 struct hdmi *hdmi = hdcp_ctrl->hdmi;
658 u32 link0_aksv_0, link0_aksv_1;
659 u32 link0_an[2];
660 u8 aksv[5];
661
662 /* Read An0 and An1 */
663 link0_an[0] = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA5);
664 link0_an[1] = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA6);
665
666 /* Read AKSV */
667 link0_aksv_0 = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA3);
668 link0_aksv_1 = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA4);
669
670 DBG("Link ASKV=%08x%08x", link0_aksv_0, link0_aksv_1);
671 /* Copy An and AKSV to byte arrays for transmission */
672 aksv[0] = link0_aksv_0 & 0xFF;
673 aksv[1] = (link0_aksv_0 >> 8) & 0xFF;
674 aksv[2] = (link0_aksv_0 >> 16) & 0xFF;
675 aksv[3] = (link0_aksv_0 >> 24) & 0xFF;
676 aksv[4] = link0_aksv_1 & 0xFF;
677
678 /* Write An to offset 0x18 */
679 rc = msm_hdmi_ddc_write(hdmi, HDCP_PORT_ADDR, 0x18, (u8 *)link0_an,
680 (u16)sizeof(link0_an));
681 if (rc) {
682 pr_err("%s:An write failed\n", __func__);
683 return rc;
684 }
685 DBG("Link0-An=%08x%08x", link0_an[0], link0_an[1]);
686
687 /* Write AKSV to offset 0x10 */
688 rc = msm_hdmi_ddc_write(hdmi, HDCP_PORT_ADDR, 0x10, aksv, 5);
689 if (rc) {
690 pr_err("%s:AKSV write failed\n", __func__);
691 return rc;
692 }
693 DBG("Link0-AKSV=%02x%08x", link0_aksv_1 & 0xFF, link0_aksv_0);
694
695 return 0;
696}
697
698static int msm_hdmi_hdcp_recv_bksv(struct hdmi_hdcp_ctrl *hdcp_ctrl)
699{
700 int rc = 0;
701 struct hdmi *hdmi = hdcp_ctrl->hdmi;
702 u8 bksv[5];
703 u32 reg[2], data[2];
704
705 /* Read BKSV at offset 0x00 */
706 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x00, bksv, 5);
707 if (rc) {
708 pr_err("%s:BKSV read failed\n", __func__);
709 return rc;
710 }
711
712 hdcp_ctrl->bksv_lsb = bksv[0] | (bksv[1] << 8) |
713 (bksv[2] << 16) | (bksv[3] << 24);
714 hdcp_ctrl->bksv_msb = bksv[4];
715 DBG(":BKSV=%02x%08x", hdcp_ctrl->bksv_msb, hdcp_ctrl->bksv_lsb);
716
717 /* check there are 20 ones in BKSV */
718 if ((hweight32(hdcp_ctrl->bksv_lsb) + hweight32(hdcp_ctrl->bksv_msb))
719 != 20) {
720 pr_err(": BKSV doesn't have 20 1's and 20 0's\n");
721 pr_err(": BKSV chk fail. BKSV=%02x%02x%02x%02x%02x\n",
722 bksv[4], bksv[3], bksv[2], bksv[1], bksv[0]);
723 return -EINVAL;
724 }
725
726 /* Write BKSV read from sink to HDCP registers */
727 reg[0] = REG_HDMI_HDCP_RCVPORT_DATA0;
728 data[0] = hdcp_ctrl->bksv_lsb;
729 reg[1] = REG_HDMI_HDCP_RCVPORT_DATA1;
730 data[1] = hdcp_ctrl->bksv_msb;
731 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, reg, data, 2);
732
733 return rc;
734}
735
736static int msm_hdmi_hdcp_recv_bcaps(struct hdmi_hdcp_ctrl *hdcp_ctrl)
737{
738 int rc = 0;
739 struct hdmi *hdmi = hdcp_ctrl->hdmi;
740 u32 reg, data;
741 u8 bcaps;
742
743 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x40, &bcaps, 1);
744 if (rc) {
745 pr_err("%s:BCAPS read failed\n", __func__);
746 return rc;
747 }
748 DBG("BCAPS=%02x", bcaps);
749
750 /* receiver (0), repeater (1) */
751 hdcp_ctrl->ds_type = (bcaps & BIT(6)) ? DS_REPEATER : DS_RECEIVER;
752
753 /* Write BCAPS to the hardware */
754 reg = REG_HDMI_HDCP_RCVPORT_DATA12;
755 data = (u32)bcaps;
756 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, ®, &data, 1);
757
758 return rc;
759}
760
761static int msm_hdmi_hdcp_auth_part1_key_exchange(struct hdmi_hdcp_ctrl *hdcp_ctrl)
762{
763 struct hdmi *hdmi = hdcp_ctrl->hdmi;
764 unsigned long flags;
765 int rc;
766
767 /* Wait for AKSV key and An ready */
768 rc = msm_hdmi_hdcp_wait_key_an_ready(hdcp_ctrl);
769 if (rc) {
770 pr_err("%s: wait key and an ready failed\n", __func__);
771 return rc;
772 };
773
774 /* Read BCAPS and send to HDCP engine */
775 rc = msm_hdmi_hdcp_recv_bcaps(hdcp_ctrl);
776 if (rc) {
777 pr_err("%s: read bcaps error, abort\n", __func__);
778 return rc;
779 }
780
781 /*
782 * 1.1_Features turned off by default.
783 * No need to write AInfo since 1.1_Features is disabled.
784 */
785 hdmi_write(hdmi, REG_HDMI_HDCP_RCVPORT_DATA4, 0);
786
787 /* Send AKSV and An to sink */
788 rc = msm_hdmi_hdcp_send_aksv_an(hdcp_ctrl);
789 if (rc) {
790 pr_err("%s:An/Aksv write failed\n", __func__);
791 return rc;
792 }
793
794 /* Read BKSV and send to HDCP engine*/
795 rc = msm_hdmi_hdcp_recv_bksv(hdcp_ctrl);
796 if (rc) {
797 pr_err("%s:BKSV Process failed\n", __func__);
798 return rc;
799 }
800
801 /* Enable HDCP interrupts and ack/clear any stale interrupts */
802 spin_lock_irqsave(&hdmi->reg_lock, flags);
803 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL,
804 HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_ACK |
805 HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_MASK |
806 HDMI_HDCP_INT_CTRL_AUTH_FAIL_ACK |
807 HDMI_HDCP_INT_CTRL_AUTH_FAIL_MASK |
808 HDMI_HDCP_INT_CTRL_AUTH_FAIL_INFO_ACK);
809 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
810
811 return 0;
812}
813
814/* read R0' from sink and pass it to HDCP engine */
815static int msm_hdmi_hdcp_auth_part1_recv_r0(struct hdmi_hdcp_ctrl *hdcp_ctrl)
816{
817 struct hdmi *hdmi = hdcp_ctrl->hdmi;
818 int rc = 0;
819 u8 buf[2];
820
821 /*
822 * HDCP Compliance Test case 1A-01:
823 * Wait here at least 100ms before reading R0'
824 */
825 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 125, AUTH_ABORT_EV);
826 if (rc)
827 return rc;
828
829 /* Read R0' at offset 0x08 */
830 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x08, buf, 2);
831 if (rc) {
832 pr_err("%s:R0' read failed\n", __func__);
833 return rc;
834 }
835 DBG("R0'=%02x%02x", buf[1], buf[0]);
836
837 /* Write R0' to HDCP registers and check to see if it is a match */
838 hdmi_write(hdmi, REG_HDMI_HDCP_RCVPORT_DATA2_0,
839 (((u32)buf[1]) << 8) | buf[0]);
840
841 return 0;
842}
843
844/* Wait for authenticating result: R0/R0' are matched or not */
845static int msm_hdmi_hdcp_auth_part1_verify_r0(struct hdmi_hdcp_ctrl *hdcp_ctrl)
846{
847 struct hdmi *hdmi = hdcp_ctrl->hdmi;
848 u32 link0_status;
849 int rc;
850
851 /* wait for hdcp irq, 10 sec should be long enough */
852 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 10000, AUTH_RESULT_RDY_EV);
853 if (!rc) {
854 pr_err("%s: Wait Auth IRQ timeout\n", __func__);
855 return -ETIMEDOUT;
856 }
857
858 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
859 if (!(link0_status & HDMI_HDCP_LINK0_STATUS_RI_MATCHES)) {
860 pr_err("%s: Authentication Part I failed\n", __func__);
861 return -EINVAL;
862 }
863
864 /* Enable HDCP Encryption */
865 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL,
866 HDMI_HDCP_CTRL_ENABLE |
867 HDMI_HDCP_CTRL_ENCRYPTION_ENABLE);
868
869 return 0;
870}
871
872static int msm_hdmi_hdcp_recv_check_bstatus(struct hdmi_hdcp_ctrl *hdcp_ctrl,
873 u16 *pbstatus)
874{
875 int rc;
876 struct hdmi *hdmi = hdcp_ctrl->hdmi;
877 bool max_devs_exceeded = false, max_cascade_exceeded = false;
878 u32 repeater_cascade_depth = 0, down_stream_devices = 0;
879 u16 bstatus;
880 u8 buf[2];
881
882 /* Read BSTATUS at offset 0x41 */
883 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x41, buf, 2);
884 if (rc) {
885 pr_err("%s: BSTATUS read failed\n", __func__);
886 goto error;
887 }
888 *pbstatus = bstatus = (buf[1] << 8) | buf[0];
889
890
891 down_stream_devices = bstatus & 0x7F;
892 repeater_cascade_depth = (bstatus >> 8) & 0x7;
893 max_devs_exceeded = (bstatus & BIT(7)) ? true : false;
894 max_cascade_exceeded = (bstatus & BIT(11)) ? true : false;
895
896 if (down_stream_devices == 0) {
897 /*
898 * If no downstream devices are attached to the repeater
899 * then part II fails.
900 * todo: The other approach would be to continue PART II.
901 */
902 pr_err("%s: No downstream devices\n", __func__);
903 rc = -EINVAL;
904 goto error;
905 }
906
907 /*
908 * HDCP Compliance 1B-05:
909 * Check if no. of devices connected to repeater
910 * exceed max_devices_connected from bit 7 of Bstatus.
911 */
912 if (max_devs_exceeded) {
913 pr_err("%s: no. of devs connected exceeds max allowed",
914 __func__);
915 rc = -EINVAL;
916 goto error;
917 }
918
919 /*
920 * HDCP Compliance 1B-06:
921 * Check if no. of cascade connected to repeater
922 * exceed max_cascade_connected from bit 11 of Bstatus.
923 */
924 if (max_cascade_exceeded) {
925 pr_err("%s: no. of cascade conn exceeds max allowed",
926 __func__);
927 rc = -EINVAL;
928 goto error;
929 }
930
931error:
932 hdcp_ctrl->dev_count = down_stream_devices;
933 hdcp_ctrl->max_cascade_exceeded = max_cascade_exceeded;
934 hdcp_ctrl->max_dev_exceeded = max_devs_exceeded;
935 hdcp_ctrl->depth = repeater_cascade_depth;
936 return rc;
937}
938
939static int msm_hdmi_hdcp_auth_part2_wait_ksv_fifo_ready(
940 struct hdmi_hdcp_ctrl *hdcp_ctrl)
941{
942 int rc;
943 struct hdmi *hdmi = hdcp_ctrl->hdmi;
944 u32 reg, data;
945 u32 timeout_count;
946 u16 bstatus;
947 u8 bcaps;
948
949 /*
950 * Wait until READY bit is set in BCAPS, as per HDCP specifications
951 * maximum permitted time to check for READY bit is five seconds.
952 */
953 timeout_count = 100;
954 do {
955 /* Read BCAPS at offset 0x40 */
956 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x40, &bcaps, 1);
957 if (rc) {
958 pr_err("%s: BCAPS read failed\n", __func__);
959 return rc;
960 }
961
962 if (bcaps & BIT(5))
963 break;
964
965 timeout_count--;
966 if (!timeout_count) {
967 pr_err("%s: Wait KSV fifo ready timedout", __func__);
968 return -ETIMEDOUT;
969 }
970
971 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
972 if (rc)
973 return rc;
974 } while (1);
975
976 rc = msm_hdmi_hdcp_recv_check_bstatus(hdcp_ctrl, &bstatus);
977 if (rc) {
978 pr_err("%s: bstatus error\n", __func__);
979 return rc;
980 }
981
982 /* Write BSTATUS and BCAPS to HDCP registers */
983 reg = REG_HDMI_HDCP_RCVPORT_DATA12;
984 data = bcaps | (bstatus << 8);
985 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, ®, &data, 1);
986 if (rc) {
987 pr_err("%s: BSTATUS write failed\n", __func__);
988 return rc;
989 }
990
991 return 0;
992}
993
994/*
995 * hdcp authenticating part 2: 2nd
996 * read ksv fifo from sink
997 * transfer V' from sink to HDCP engine
998 * reset SHA engine
999 */
1000static int msm_hdmi_hdcp_transfer_v_h(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1001{
1002 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1003 int rc = 0;
1004 struct hdmi_hdcp_reg_data reg_data[] = {
1005 {REG_HDMI_HDCP_RCVPORT_DATA7, 0x20, "V' H0"},
1006 {REG_HDMI_HDCP_RCVPORT_DATA8, 0x24, "V' H1"},
1007 {REG_HDMI_HDCP_RCVPORT_DATA9, 0x28, "V' H2"},
1008 {REG_HDMI_HDCP_RCVPORT_DATA10, 0x2C, "V' H3"},
1009 {REG_HDMI_HDCP_RCVPORT_DATA11, 0x30, "V' H4"},
1010 };
1011 struct hdmi_hdcp_reg_data *rd;
1012 u32 size = ARRAY_SIZE(reg_data);
1013 u32 reg[ARRAY_SIZE(reg_data)];
1014 u32 data[ARRAY_SIZE(reg_data)];
1015 int i;
1016
1017 for (i = 0; i < size; i++) {
1018 rd = ®_data[i];
1019 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR,
1020 rd->off, (u8 *)&data[i], (u16)sizeof(data[i]));
1021 if (rc) {
1022 pr_err("%s: Read %s failed\n", __func__, rd->name);
1023 goto error;
1024 }
1025
1026 DBG("%s =%x", rd->name, data[i]);
1027 reg[i] = reg_data[i].reg_id;
1028 }
1029
1030 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, reg, data, size);
1031
1032error:
1033 return rc;
1034}
1035
1036static int msm_hdmi_hdcp_recv_ksv_fifo(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1037{
1038 int rc;
1039 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1040 u32 ksv_bytes;
1041
1042 ksv_bytes = 5 * hdcp_ctrl->dev_count;
1043
1044 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x43,
1045 hdcp_ctrl->ksv_list, ksv_bytes);
1046 if (rc)
1047 pr_err("%s: KSV FIFO read failed\n", __func__);
1048
1049 return rc;
1050}
1051
1052static int msm_hdmi_hdcp_reset_sha_engine(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1053{
1054 u32 reg[2], data[2];
1055 u32 rc = 0;
1056
1057 reg[0] = REG_HDMI_HDCP_SHA_CTRL;
1058 data[0] = HDCP_REG_ENABLE;
1059 reg[1] = REG_HDMI_HDCP_SHA_CTRL;
1060 data[1] = HDCP_REG_DISABLE;
1061
1062 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, reg, data, 2);
1063
1064 return rc;
1065}
1066
1067static int msm_hdmi_hdcp_auth_part2_recv_ksv_fifo(
1068 struct hdmi_hdcp_ctrl *hdcp_ctrl)
1069{
1070 int rc;
1071 u32 timeout_count;
1072
1073 /*
1074 * Read KSV FIFO over DDC
1075 * Key Selection vector FIFO Used to pull downstream KSVs
1076 * from HDCP Repeaters.
1077 * All bytes (DEVICE_COUNT * 5) must be read in a single,
1078 * auto incrementing access.
1079 * All bytes read as 0x00 for HDCP Receivers that are not
1080 * HDCP Repeaters (REPEATER == 0).
1081 */
1082 timeout_count = 100;
1083 do {
1084 rc = msm_hdmi_hdcp_recv_ksv_fifo(hdcp_ctrl);
1085 if (!rc)
1086 break;
1087
1088 timeout_count--;
1089 if (!timeout_count) {
1090 pr_err("%s: Recv ksv fifo timedout", __func__);
1091 return -ETIMEDOUT;
1092 }
1093
1094 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 25, AUTH_ABORT_EV);
1095 if (rc)
1096 return rc;
1097 } while (1);
1098
1099 rc = msm_hdmi_hdcp_transfer_v_h(hdcp_ctrl);
1100 if (rc) {
1101 pr_err("%s: transfer V failed\n", __func__);
1102 return rc;
1103 }
1104
1105 /* reset SHA engine before write ksv fifo */
1106 rc = msm_hdmi_hdcp_reset_sha_engine(hdcp_ctrl);
1107 if (rc) {
1108 pr_err("%s: fail to reset sha engine\n", __func__);
1109 return rc;
1110 }
1111
1112 return 0;
1113}
1114
1115/*
1116 * Write KSV FIFO to HDCP_SHA_DATA.
1117 * This is done 1 byte at time starting with the LSB.
1118 * Once 64 bytes have been written, we need to poll for
1119 * HDCP_SHA_BLOCK_DONE before writing any further
1120 * If the last byte is written, we need to poll for
1121 * HDCP_SHA_COMP_DONE to wait until HW finish
1122 */
1123static int msm_hdmi_hdcp_write_ksv_fifo(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1124{
1125 int i;
1126 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1127 u32 ksv_bytes, last_byte = 0;
1128 u8 *ksv_fifo = NULL;
1129 u32 reg_val, data, reg;
1130 u32 rc = 0;
1131
1132 ksv_bytes = 5 * hdcp_ctrl->dev_count;
1133
1134 /* Check if need to wait for HW completion */
1135 if (hdcp_ctrl->ksv_fifo_w_index) {
1136 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_SHA_STATUS);
1137 DBG("HDCP_SHA_STATUS=%08x", reg_val);
1138 if (hdcp_ctrl->ksv_fifo_w_index == ksv_bytes) {
1139 /* check COMP_DONE if last write */
1140 if (reg_val & HDMI_HDCP_SHA_STATUS_COMP_DONE) {
1141 DBG("COMP_DONE");
1142 return 0;
1143 } else {
1144 return -EAGAIN;
1145 }
1146 } else {
1147 /* check BLOCK_DONE if not last write */
1148 if (!(reg_val & HDMI_HDCP_SHA_STATUS_BLOCK_DONE))
1149 return -EAGAIN;
1150
1151 DBG("BLOCK_DONE");
1152 }
1153 }
1154
1155 ksv_bytes -= hdcp_ctrl->ksv_fifo_w_index;
1156 if (ksv_bytes <= 64)
1157 last_byte = 1;
1158 else
1159 ksv_bytes = 64;
1160
1161 ksv_fifo = hdcp_ctrl->ksv_list;
1162 ksv_fifo += hdcp_ctrl->ksv_fifo_w_index;
1163
1164 for (i = 0; i < ksv_bytes; i++) {
1165 /* Write KSV byte and set DONE bit[0] for last byte*/
1166 reg_val = ksv_fifo[i] << 16;
1167 if ((i == (ksv_bytes - 1)) && last_byte)
1168 reg_val |= HDMI_HDCP_SHA_DATA_DONE;
1169
1170 reg = REG_HDMI_HDCP_SHA_DATA;
1171 data = reg_val;
1172 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, ®, &data, 1);
1173
1174 if (rc)
1175 return rc;
1176 }
1177
1178 hdcp_ctrl->ksv_fifo_w_index += ksv_bytes;
1179
1180 /*
1181 *return -EAGAIN to notify caller to wait for COMP_DONE or BLOCK_DONE
1182 */
1183 return -EAGAIN;
1184}
1185
1186/* write ksv fifo into HDCP engine */
1187static int msm_hdmi_hdcp_auth_part2_write_ksv_fifo(
1188 struct hdmi_hdcp_ctrl *hdcp_ctrl)
1189{
1190 int rc;
1191 u32 timeout_count;
1192
1193 hdcp_ctrl->ksv_fifo_w_index = 0;
1194 timeout_count = 100;
1195 do {
1196 rc = msm_hdmi_hdcp_write_ksv_fifo(hdcp_ctrl);
1197 if (!rc)
1198 break;
1199
1200 if (rc != -EAGAIN)
1201 return rc;
1202
1203 timeout_count--;
1204 if (!timeout_count) {
1205 pr_err("%s: Write KSV fifo timedout", __func__);
1206 return -ETIMEDOUT;
1207 }
1208
1209 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
1210 if (rc)
1211 return rc;
1212 } while (1);
1213
1214 return 0;
1215}
1216
1217static int msm_hdmi_hdcp_auth_part2_check_v_match(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1218{
1219 int rc = 0;
1220 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1221 u32 link0_status;
1222 u32 timeout_count = 100;
1223
1224 do {
1225 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
1226 if (link0_status & HDMI_HDCP_LINK0_STATUS_V_MATCHES)
1227 break;
1228
1229 timeout_count--;
1230 if (!timeout_count) {
1231 pr_err("%s: HDCP V Match timedout", __func__);
1232 return -ETIMEDOUT;
1233 }
1234
1235 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
1236 if (rc)
1237 return rc;
1238 } while (1);
1239
1240 return 0;
1241}
1242
1243static void msm_hdmi_hdcp_auth_work(struct work_struct *work)
1244{
1245 struct hdmi_hdcp_ctrl *hdcp_ctrl = container_of(work,
1246 struct hdmi_hdcp_ctrl, hdcp_auth_work);
1247 int rc;
1248
1249 rc = msm_hdmi_hdcp_auth_prepare(hdcp_ctrl);
1250 if (rc) {
1251 pr_err("%s: auth prepare failed %d\n", __func__, rc);
1252 goto end;
1253 }
1254
1255 /* HDCP PartI */
1256 rc = msm_hdmi_hdcp_auth_part1_key_exchange(hdcp_ctrl);
1257 if (rc) {
1258 pr_err("%s: key exchange failed %d\n", __func__, rc);
1259 goto end;
1260 }
1261
1262 rc = msm_hdmi_hdcp_auth_part1_recv_r0(hdcp_ctrl);
1263 if (rc) {
1264 pr_err("%s: receive r0 failed %d\n", __func__, rc);
1265 goto end;
1266 }
1267
1268 rc = msm_hdmi_hdcp_auth_part1_verify_r0(hdcp_ctrl);
1269 if (rc) {
1270 pr_err("%s: verify r0 failed %d\n", __func__, rc);
1271 goto end;
1272 }
1273 pr_info("%s: Authentication Part I successful\n", __func__);
1274 if (hdcp_ctrl->ds_type == DS_RECEIVER)
1275 goto end;
1276
1277 /* HDCP PartII */
1278 rc = msm_hdmi_hdcp_auth_part2_wait_ksv_fifo_ready(hdcp_ctrl);
1279 if (rc) {
1280 pr_err("%s: wait ksv fifo ready failed %d\n", __func__, rc);
1281 goto end;
1282 }
1283
1284 rc = msm_hdmi_hdcp_auth_part2_recv_ksv_fifo(hdcp_ctrl);
1285 if (rc) {
1286 pr_err("%s: recv ksv fifo failed %d\n", __func__, rc);
1287 goto end;
1288 }
1289
1290 rc = msm_hdmi_hdcp_auth_part2_write_ksv_fifo(hdcp_ctrl);
1291 if (rc) {
1292 pr_err("%s: write ksv fifo failed %d\n", __func__, rc);
1293 goto end;
1294 }
1295
1296 rc = msm_hdmi_hdcp_auth_part2_check_v_match(hdcp_ctrl);
1297 if (rc)
1298 pr_err("%s: check v match failed %d\n", __func__, rc);
1299
1300end:
1301 if (rc == -ECANCELED) {
1302 pr_info("%s: hdcp authentication canceled\n", __func__);
1303 } else if (rc == -ENOTSUPP) {
1304 pr_info("%s: hdcp is not supported\n", __func__);
1305 } else if (rc) {
1306 pr_err("%s: hdcp authentication failed\n", __func__);
1307 msm_hdmi_hdcp_auth_fail(hdcp_ctrl);
1308 } else {
1309 msm_hdmi_hdcp_auth_done(hdcp_ctrl);
1310 }
1311}
1312
1313void msm_hdmi_hdcp_on(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1314{
1315 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1316 u32 reg_val;
1317 unsigned long flags;
1318
1319 if ((HDCP_STATE_INACTIVE != hdcp_ctrl->hdcp_state) ||
1320 (HDCP_STATE_NO_AKSV == hdcp_ctrl->hdcp_state)) {
1321 DBG("still active or activating or no askv. returning");
1322 return;
1323 }
1324
1325 /* clear HDMI Encrypt */
1326 spin_lock_irqsave(&hdmi->reg_lock, flags);
1327 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
1328 reg_val &= ~HDMI_CTRL_ENCRYPTED;
1329 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
1330 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
1331
1332 hdcp_ctrl->auth_event = 0;
1333 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTHENTICATING;
1334 hdcp_ctrl->auth_retries = 0;
1335 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_auth_work);
1336}
1337
1338void msm_hdmi_hdcp_off(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1339{
1340 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1341 unsigned long flags;
1342 u32 reg_val;
1343
1344 if ((HDCP_STATE_INACTIVE == hdcp_ctrl->hdcp_state) ||
1345 (HDCP_STATE_NO_AKSV == hdcp_ctrl->hdcp_state)) {
1346 DBG("hdcp inactive or no aksv. returning");
1347 return;
1348 }
1349
1350 /*
1351 * Disable HPD circuitry.
1352 * This is needed to reset the HDCP cipher engine so that when we
1353 * attempt a re-authentication, HW would clear the AN0_READY and
1354 * AN1_READY bits in HDMI_HDCP_LINK0_STATUS register
1355 */
1356 spin_lock_irqsave(&hdmi->reg_lock, flags);
1357 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
1358 reg_val &= ~HDMI_HPD_CTRL_ENABLE;
1359 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
1360
1361 /*
1362 * Disable HDCP interrupts.
1363 * Also, need to set the state to inactive here so that any ongoing
1364 * reauth works will know that the HDCP session has been turned off.
1365 */
1366 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL, 0);
1367 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
1368
1369 /*
1370 * Cancel any pending auth/reauth attempts.
1371 * If one is ongoing, this will wait for it to finish.
1372 * No more reauthentication attempts will be scheduled since we
1373 * set the current state to inactive.
1374 */
1375 set_bit(AUTH_ABORT_EV, &hdcp_ctrl->auth_event);
1376 wake_up_all(&hdcp_ctrl->auth_event_queue);
1377 cancel_work_sync(&hdcp_ctrl->hdcp_auth_work);
1378 cancel_work_sync(&hdcp_ctrl->hdcp_reauth_work);
1379
1380 hdmi_write(hdmi, REG_HDMI_HDCP_RESET,
1381 HDMI_HDCP_RESET_LINK0_DEAUTHENTICATE);
1382
1383 /* Disable encryption and disable the HDCP block */
1384 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL, 0);
1385
1386 spin_lock_irqsave(&hdmi->reg_lock, flags);
1387 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
1388 reg_val &= ~HDMI_CTRL_ENCRYPTED;
1389 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
1390
1391 /* Enable HPD circuitry */
1392 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
1393 reg_val |= HDMI_HPD_CTRL_ENABLE;
1394 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
1395 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
1396
1397 hdcp_ctrl->hdcp_state = HDCP_STATE_INACTIVE;
1398
1399 DBG("HDCP: Off");
1400}
1401
1402struct hdmi_hdcp_ctrl *msm_hdmi_hdcp_init(struct hdmi *hdmi)
1403{
1404 struct hdmi_hdcp_ctrl *hdcp_ctrl = NULL;
1405
1406 if (!hdmi->qfprom_mmio) {
1407 pr_err("%s: HDCP is not supported without qfprom\n",
1408 __func__);
1409 return ERR_PTR(-EINVAL);
1410 }
1411
1412 hdcp_ctrl = kzalloc(sizeof(*hdcp_ctrl), GFP_KERNEL);
1413 if (!hdcp_ctrl)
1414 return ERR_PTR(-ENOMEM);
1415
1416 INIT_WORK(&hdcp_ctrl->hdcp_auth_work, msm_hdmi_hdcp_auth_work);
1417 INIT_WORK(&hdcp_ctrl->hdcp_reauth_work, msm_hdmi_hdcp_reauth_work);
1418 init_waitqueue_head(&hdcp_ctrl->auth_event_queue);
1419 hdcp_ctrl->hdmi = hdmi;
1420 hdcp_ctrl->hdcp_state = HDCP_STATE_INACTIVE;
1421 hdcp_ctrl->aksv_valid = false;
1422
1423 if (qcom_scm_hdcp_available())
1424 hdcp_ctrl->tz_hdcp = true;
1425 else
1426 hdcp_ctrl->tz_hdcp = false;
1427
1428 return hdcp_ctrl;
1429}
1430
1431void msm_hdmi_hdcp_destroy(struct hdmi *hdmi)
1432{
1433 if (hdmi && hdmi->hdcp_ctrl) {
1434 kfree(hdmi->hdcp_ctrl);
1435 hdmi->hdcp_ctrl = NULL;
1436 }
1437}
1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright (c) 2010-2015, The Linux Foundation. All rights reserved.
3 */
4
5#include "hdmi.h"
6#include <linux/qcom_scm.h>
7
8#define HDCP_REG_ENABLE 0x01
9#define HDCP_REG_DISABLE 0x00
10#define HDCP_PORT_ADDR 0x74
11
12#define HDCP_INT_STATUS_MASK ( \
13 HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_INT | \
14 HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT | \
15 HDMI_HDCP_INT_CTRL_AUTH_XFER_REQ_INT | \
16 HDMI_HDCP_INT_CTRL_AUTH_XFER_DONE_INT)
17
18#define AUTH_WORK_RETRIES_TIME 100
19#define AUTH_RETRIES_TIME 30
20
21/* QFPROM Registers for HDMI/HDCP */
22#define QFPROM_RAW_FEAT_CONFIG_ROW0_LSB 0x000000F8
23#define QFPROM_RAW_FEAT_CONFIG_ROW0_MSB 0x000000FC
24#define HDCP_KSV_LSB 0x000060D8
25#define HDCP_KSV_MSB 0x000060DC
26
27enum DS_TYPE { /* type of downstream device */
28 DS_UNKNOWN,
29 DS_RECEIVER,
30 DS_REPEATER,
31};
32
33enum hdmi_hdcp_state {
34 HDCP_STATE_NO_AKSV,
35 HDCP_STATE_INACTIVE,
36 HDCP_STATE_AUTHENTICATING,
37 HDCP_STATE_AUTHENTICATED,
38 HDCP_STATE_AUTH_FAILED
39};
40
41struct hdmi_hdcp_reg_data {
42 u32 reg_id;
43 u32 off;
44 char *name;
45 u32 reg_val;
46};
47
48struct hdmi_hdcp_ctrl {
49 struct hdmi *hdmi;
50 u32 auth_retries;
51 bool tz_hdcp;
52 enum hdmi_hdcp_state hdcp_state;
53 struct work_struct hdcp_auth_work;
54 struct work_struct hdcp_reauth_work;
55
56#define AUTH_ABORT_EV 1
57#define AUTH_RESULT_RDY_EV 2
58 unsigned long auth_event;
59 wait_queue_head_t auth_event_queue;
60
61 u32 ksv_fifo_w_index;
62 /*
63 * store aksv from qfprom
64 */
65 u32 aksv_lsb;
66 u32 aksv_msb;
67 bool aksv_valid;
68 u32 ds_type;
69 u32 bksv_lsb;
70 u32 bksv_msb;
71 u8 dev_count;
72 u8 depth;
73 u8 ksv_list[5 * 127];
74 bool max_cascade_exceeded;
75 bool max_dev_exceeded;
76};
77
78static int msm_hdmi_ddc_read(struct hdmi *hdmi, u16 addr, u8 offset,
79 u8 *data, u16 data_len)
80{
81 int rc;
82 int retry = 5;
83 struct i2c_msg msgs[] = {
84 {
85 .addr = addr >> 1,
86 .flags = 0,
87 .len = 1,
88 .buf = &offset,
89 }, {
90 .addr = addr >> 1,
91 .flags = I2C_M_RD,
92 .len = data_len,
93 .buf = data,
94 }
95 };
96
97 DBG("Start DDC read");
98retry:
99 rc = i2c_transfer(hdmi->i2c, msgs, 2);
100
101 retry--;
102 if (rc == 2)
103 rc = 0;
104 else if (retry > 0)
105 goto retry;
106 else
107 rc = -EIO;
108
109 DBG("End DDC read %d", rc);
110
111 return rc;
112}
113
114#define HDCP_DDC_WRITE_MAX_BYTE_NUM 32
115
116static int msm_hdmi_ddc_write(struct hdmi *hdmi, u16 addr, u8 offset,
117 u8 *data, u16 data_len)
118{
119 int rc;
120 int retry = 10;
121 u8 buf[HDCP_DDC_WRITE_MAX_BYTE_NUM];
122 struct i2c_msg msgs[] = {
123 {
124 .addr = addr >> 1,
125 .flags = 0,
126 .len = 1,
127 }
128 };
129
130 DBG("Start DDC write");
131 if (data_len > (HDCP_DDC_WRITE_MAX_BYTE_NUM - 1)) {
132 pr_err("%s: write size too big\n", __func__);
133 return -ERANGE;
134 }
135
136 buf[0] = offset;
137 memcpy(&buf[1], data, data_len);
138 msgs[0].buf = buf;
139 msgs[0].len = data_len + 1;
140retry:
141 rc = i2c_transfer(hdmi->i2c, msgs, 1);
142
143 retry--;
144 if (rc == 1)
145 rc = 0;
146 else if (retry > 0)
147 goto retry;
148 else
149 rc = -EIO;
150
151 DBG("End DDC write %d", rc);
152
153 return rc;
154}
155
156static int msm_hdmi_hdcp_scm_wr(struct hdmi_hdcp_ctrl *hdcp_ctrl, u32 *preg,
157 u32 *pdata, u32 count)
158{
159 struct hdmi *hdmi = hdcp_ctrl->hdmi;
160 struct qcom_scm_hdcp_req scm_buf[QCOM_SCM_HDCP_MAX_REQ_CNT];
161 u32 resp, phy_addr, idx = 0;
162 int i, ret = 0;
163
164 WARN_ON(!pdata || !preg || (count == 0));
165
166 if (hdcp_ctrl->tz_hdcp) {
167 phy_addr = (u32)hdmi->mmio_phy_addr;
168
169 while (count) {
170 memset(scm_buf, 0, sizeof(scm_buf));
171 for (i = 0; i < count && i < QCOM_SCM_HDCP_MAX_REQ_CNT;
172 i++) {
173 scm_buf[i].addr = phy_addr + preg[idx];
174 scm_buf[i].val = pdata[idx];
175 idx++;
176 }
177 ret = qcom_scm_hdcp_req(scm_buf, i, &resp);
178
179 if (ret || resp) {
180 pr_err("%s: error: scm_call ret=%d resp=%u\n",
181 __func__, ret, resp);
182 ret = -EINVAL;
183 break;
184 }
185
186 count -= i;
187 }
188 } else {
189 for (i = 0; i < count; i++)
190 hdmi_write(hdmi, preg[i], pdata[i]);
191 }
192
193 return ret;
194}
195
196void msm_hdmi_hdcp_irq(struct hdmi_hdcp_ctrl *hdcp_ctrl)
197{
198 struct hdmi *hdmi = hdcp_ctrl->hdmi;
199 u32 reg_val, hdcp_int_status;
200 unsigned long flags;
201
202 spin_lock_irqsave(&hdmi->reg_lock, flags);
203 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_INT_CTRL);
204 hdcp_int_status = reg_val & HDCP_INT_STATUS_MASK;
205 if (!hdcp_int_status) {
206 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
207 return;
208 }
209 /* Clear Interrupts */
210 reg_val |= hdcp_int_status << 1;
211 /* Clear AUTH_FAIL_INFO as well */
212 if (hdcp_int_status & HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT)
213 reg_val |= HDMI_HDCP_INT_CTRL_AUTH_FAIL_INFO_ACK;
214 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL, reg_val);
215 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
216
217 DBG("hdcp irq %x", hdcp_int_status);
218
219 if (hdcp_int_status & HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_INT) {
220 pr_info("%s:AUTH_SUCCESS_INT received\n", __func__);
221 if (HDCP_STATE_AUTHENTICATING == hdcp_ctrl->hdcp_state) {
222 set_bit(AUTH_RESULT_RDY_EV, &hdcp_ctrl->auth_event);
223 wake_up_all(&hdcp_ctrl->auth_event_queue);
224 }
225 }
226
227 if (hdcp_int_status & HDMI_HDCP_INT_CTRL_AUTH_FAIL_INT) {
228 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
229 pr_info("%s: AUTH_FAIL_INT rcvd, LINK0_STATUS=0x%08x\n",
230 __func__, reg_val);
231 if (HDCP_STATE_AUTHENTICATED == hdcp_ctrl->hdcp_state)
232 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_reauth_work);
233 else if (HDCP_STATE_AUTHENTICATING ==
234 hdcp_ctrl->hdcp_state) {
235 set_bit(AUTH_RESULT_RDY_EV, &hdcp_ctrl->auth_event);
236 wake_up_all(&hdcp_ctrl->auth_event_queue);
237 }
238 }
239}
240
241static int msm_hdmi_hdcp_msleep(struct hdmi_hdcp_ctrl *hdcp_ctrl, u32 ms, u32 ev)
242{
243 int rc;
244
245 rc = wait_event_timeout(hdcp_ctrl->auth_event_queue,
246 !!test_bit(ev, &hdcp_ctrl->auth_event),
247 msecs_to_jiffies(ms));
248 if (rc) {
249 pr_info("%s: msleep is canceled by event %d\n",
250 __func__, ev);
251 clear_bit(ev, &hdcp_ctrl->auth_event);
252 return -ECANCELED;
253 }
254
255 return 0;
256}
257
258static int msm_hdmi_hdcp_read_validate_aksv(struct hdmi_hdcp_ctrl *hdcp_ctrl)
259{
260 struct hdmi *hdmi = hdcp_ctrl->hdmi;
261
262 /* Fetch aksv from QFPROM, this info should be public. */
263 hdcp_ctrl->aksv_lsb = hdmi_qfprom_read(hdmi, HDCP_KSV_LSB);
264 hdcp_ctrl->aksv_msb = hdmi_qfprom_read(hdmi, HDCP_KSV_MSB);
265
266 /* check there are 20 ones in AKSV */
267 if ((hweight32(hdcp_ctrl->aksv_lsb) + hweight32(hdcp_ctrl->aksv_msb))
268 != 20) {
269 pr_err("%s: AKSV QFPROM doesn't have 20 1's, 20 0's\n",
270 __func__);
271 pr_err("%s: QFPROM AKSV chk failed (AKSV=%02x%08x)\n",
272 __func__, hdcp_ctrl->aksv_msb,
273 hdcp_ctrl->aksv_lsb);
274 return -EINVAL;
275 }
276 DBG("AKSV=%02x%08x", hdcp_ctrl->aksv_msb, hdcp_ctrl->aksv_lsb);
277
278 return 0;
279}
280
281static int msm_reset_hdcp_ddc_failures(struct hdmi_hdcp_ctrl *hdcp_ctrl)
282{
283 struct hdmi *hdmi = hdcp_ctrl->hdmi;
284 u32 reg_val, failure, nack0;
285 int rc = 0;
286
287 /* Check for any DDC transfer failures */
288 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS);
289 failure = reg_val & HDMI_HDCP_DDC_STATUS_FAILED;
290 nack0 = reg_val & HDMI_HDCP_DDC_STATUS_NACK0;
291 DBG("HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d",
292 reg_val, failure, nack0);
293
294 if (failure) {
295 /*
296 * Indicates that the last HDCP HW DDC transfer failed.
297 * This occurs when a transfer is attempted with HDCP DDC
298 * disabled (HDCP_DDC_DISABLE=1) or the number of retries
299 * matches HDCP_DDC_RETRY_CNT.
300 * Failure occurred, let's clear it.
301 */
302 DBG("DDC failure detected");
303
304 /* First, Disable DDC */
305 hdmi_write(hdmi, REG_HDMI_HDCP_DDC_CTRL_0,
306 HDMI_HDCP_DDC_CTRL_0_DISABLE);
307
308 /* ACK the Failure to Clear it */
309 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_CTRL_1);
310 reg_val |= HDMI_HDCP_DDC_CTRL_1_FAILED_ACK;
311 hdmi_write(hdmi, REG_HDMI_HDCP_DDC_CTRL_1, reg_val);
312
313 /* Check if the FAILURE got Cleared */
314 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS);
315 if (reg_val & HDMI_HDCP_DDC_STATUS_FAILED)
316 pr_info("%s: Unable to clear HDCP DDC Failure\n",
317 __func__);
318
319 /* Re-Enable HDCP DDC */
320 hdmi_write(hdmi, REG_HDMI_HDCP_DDC_CTRL_0, 0);
321 }
322
323 if (nack0) {
324 DBG("Before: HDMI_DDC_SW_STATUS=0x%08x",
325 hdmi_read(hdmi, REG_HDMI_DDC_SW_STATUS));
326 /* Reset HDMI DDC software status */
327 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
328 reg_val |= HDMI_DDC_CTRL_SW_STATUS_RESET;
329 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
330
331 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
332
333 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
334 reg_val &= ~HDMI_DDC_CTRL_SW_STATUS_RESET;
335 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
336
337 /* Reset HDMI DDC Controller */
338 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
339 reg_val |= HDMI_DDC_CTRL_SOFT_RESET;
340 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
341
342 /* If previous msleep is aborted, skip this msleep */
343 if (!rc)
344 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
345
346 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_CTRL);
347 reg_val &= ~HDMI_DDC_CTRL_SOFT_RESET;
348 hdmi_write(hdmi, REG_HDMI_DDC_CTRL, reg_val);
349 DBG("After: HDMI_DDC_SW_STATUS=0x%08x",
350 hdmi_read(hdmi, REG_HDMI_DDC_SW_STATUS));
351 }
352
353 return rc;
354}
355
356static int msm_hdmi_hdcp_hw_ddc_clean(struct hdmi_hdcp_ctrl *hdcp_ctrl)
357{
358 int rc;
359 u32 hdcp_ddc_status, ddc_hw_status;
360 u32 xfer_done, xfer_req, hw_done;
361 bool hw_not_ready;
362 u32 timeout_count;
363 struct hdmi *hdmi = hdcp_ctrl->hdmi;
364
365 if (hdmi_read(hdmi, REG_HDMI_DDC_HW_STATUS) == 0)
366 return 0;
367
368 /* Wait to be clean on DDC HW engine */
369 timeout_count = 100;
370 do {
371 hdcp_ddc_status = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS);
372 ddc_hw_status = hdmi_read(hdmi, REG_HDMI_DDC_HW_STATUS);
373
374 xfer_done = hdcp_ddc_status & HDMI_HDCP_DDC_STATUS_XFER_DONE;
375 xfer_req = hdcp_ddc_status & HDMI_HDCP_DDC_STATUS_XFER_REQ;
376 hw_done = ddc_hw_status & HDMI_DDC_HW_STATUS_DONE;
377 hw_not_ready = !xfer_done || xfer_req || !hw_done;
378
379 if (hw_not_ready)
380 break;
381
382 timeout_count--;
383 if (!timeout_count) {
384 pr_warn("%s: hw_ddc_clean failed\n", __func__);
385 return -ETIMEDOUT;
386 }
387
388 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
389 if (rc)
390 return rc;
391 } while (1);
392
393 return 0;
394}
395
396static void msm_hdmi_hdcp_reauth_work(struct work_struct *work)
397{
398 struct hdmi_hdcp_ctrl *hdcp_ctrl = container_of(work,
399 struct hdmi_hdcp_ctrl, hdcp_reauth_work);
400 struct hdmi *hdmi = hdcp_ctrl->hdmi;
401 unsigned long flags;
402 u32 reg_val;
403
404 DBG("HDCP REAUTH WORK");
405 /*
406 * Disable HPD circuitry.
407 * This is needed to reset the HDCP cipher engine so that when we
408 * attempt a re-authentication, HW would clear the AN0_READY and
409 * AN1_READY bits in HDMI_HDCP_LINK0_STATUS register
410 */
411 spin_lock_irqsave(&hdmi->reg_lock, flags);
412 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
413 reg_val &= ~HDMI_HPD_CTRL_ENABLE;
414 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
415
416 /* Disable HDCP interrupts */
417 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL, 0);
418 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
419
420 hdmi_write(hdmi, REG_HDMI_HDCP_RESET,
421 HDMI_HDCP_RESET_LINK0_DEAUTHENTICATE);
422
423 /* Wait to be clean on DDC HW engine */
424 if (msm_hdmi_hdcp_hw_ddc_clean(hdcp_ctrl)) {
425 pr_info("%s: reauth work aborted\n", __func__);
426 return;
427 }
428
429 /* Disable encryption and disable the HDCP block */
430 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL, 0);
431
432 /* Enable HPD circuitry */
433 spin_lock_irqsave(&hdmi->reg_lock, flags);
434 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
435 reg_val |= HDMI_HPD_CTRL_ENABLE;
436 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
437 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
438
439 /*
440 * Only retry defined times then abort current authenticating process
441 */
442 if (++hdcp_ctrl->auth_retries == AUTH_RETRIES_TIME) {
443 hdcp_ctrl->hdcp_state = HDCP_STATE_INACTIVE;
444 hdcp_ctrl->auth_retries = 0;
445 pr_info("%s: abort reauthentication!\n", __func__);
446
447 return;
448 }
449
450 DBG("Queue AUTH WORK");
451 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTHENTICATING;
452 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_auth_work);
453}
454
455static int msm_hdmi_hdcp_auth_prepare(struct hdmi_hdcp_ctrl *hdcp_ctrl)
456{
457 struct hdmi *hdmi = hdcp_ctrl->hdmi;
458 u32 link0_status;
459 u32 reg_val;
460 unsigned long flags;
461 int rc;
462
463 if (!hdcp_ctrl->aksv_valid) {
464 rc = msm_hdmi_hdcp_read_validate_aksv(hdcp_ctrl);
465 if (rc) {
466 pr_err("%s: ASKV validation failed\n", __func__);
467 hdcp_ctrl->hdcp_state = HDCP_STATE_NO_AKSV;
468 return -ENOTSUPP;
469 }
470 hdcp_ctrl->aksv_valid = true;
471 }
472
473 spin_lock_irqsave(&hdmi->reg_lock, flags);
474 /* disable HDMI Encrypt */
475 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
476 reg_val &= ~HDMI_CTRL_ENCRYPTED;
477 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
478
479 /* Enabling Software DDC */
480 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_ARBITRATION);
481 reg_val &= ~HDMI_DDC_ARBITRATION_HW_ARBITRATION;
482 hdmi_write(hdmi, REG_HDMI_DDC_ARBITRATION, reg_val);
483 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
484
485 /*
486 * Write AKSV read from QFPROM to the HDCP registers.
487 * This step is needed for HDCP authentication and must be
488 * written before enabling HDCP.
489 */
490 hdmi_write(hdmi, REG_HDMI_HDCP_SW_LOWER_AKSV, hdcp_ctrl->aksv_lsb);
491 hdmi_write(hdmi, REG_HDMI_HDCP_SW_UPPER_AKSV, hdcp_ctrl->aksv_msb);
492
493 /*
494 * HDCP setup prior to enabling HDCP_CTRL.
495 * Setup seed values for random number An.
496 */
497 hdmi_write(hdmi, REG_HDMI_HDCP_ENTROPY_CTRL0, 0xB1FFB0FF);
498 hdmi_write(hdmi, REG_HDMI_HDCP_ENTROPY_CTRL1, 0xF00DFACE);
499
500 /* Disable the RngCipher state */
501 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_DEBUG_CTRL);
502 reg_val &= ~HDMI_HDCP_DEBUG_CTRL_RNG_CIPHER;
503 hdmi_write(hdmi, REG_HDMI_HDCP_DEBUG_CTRL, reg_val);
504 DBG("HDCP_DEBUG_CTRL=0x%08x",
505 hdmi_read(hdmi, REG_HDMI_HDCP_DEBUG_CTRL));
506
507 /*
508 * Ensure that all register writes are completed before
509 * enabling HDCP cipher
510 */
511 wmb();
512
513 /*
514 * Enable HDCP
515 * This needs to be done as early as possible in order for the
516 * hardware to make An available to read
517 */
518 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL, HDMI_HDCP_CTRL_ENABLE);
519
520 /*
521 * If we had stale values for the An ready bit, it should most
522 * likely be cleared now after enabling HDCP cipher
523 */
524 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
525 DBG("After enabling HDCP Link0_Status=0x%08x", link0_status);
526 if (!(link0_status &
527 (HDMI_HDCP_LINK0_STATUS_AN_0_READY |
528 HDMI_HDCP_LINK0_STATUS_AN_1_READY)))
529 DBG("An not ready after enabling HDCP");
530
531 /* Clear any DDC failures from previous tries before enable HDCP*/
532 rc = msm_reset_hdcp_ddc_failures(hdcp_ctrl);
533
534 return rc;
535}
536
537static void msm_hdmi_hdcp_auth_fail(struct hdmi_hdcp_ctrl *hdcp_ctrl)
538{
539 struct hdmi *hdmi = hdcp_ctrl->hdmi;
540 u32 reg_val;
541 unsigned long flags;
542
543 DBG("hdcp auth failed, queue reauth work");
544 /* clear HDMI Encrypt */
545 spin_lock_irqsave(&hdmi->reg_lock, flags);
546 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
547 reg_val &= ~HDMI_CTRL_ENCRYPTED;
548 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
549 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
550
551 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTH_FAILED;
552 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_reauth_work);
553}
554
555static void msm_hdmi_hdcp_auth_done(struct hdmi_hdcp_ctrl *hdcp_ctrl)
556{
557 struct hdmi *hdmi = hdcp_ctrl->hdmi;
558 u32 reg_val;
559 unsigned long flags;
560
561 /*
562 * Disable software DDC before going into part3 to make sure
563 * there is no Arbitration between software and hardware for DDC
564 */
565 spin_lock_irqsave(&hdmi->reg_lock, flags);
566 reg_val = hdmi_read(hdmi, REG_HDMI_DDC_ARBITRATION);
567 reg_val |= HDMI_DDC_ARBITRATION_HW_ARBITRATION;
568 hdmi_write(hdmi, REG_HDMI_DDC_ARBITRATION, reg_val);
569 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
570
571 /* enable HDMI Encrypt */
572 spin_lock_irqsave(&hdmi->reg_lock, flags);
573 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
574 reg_val |= HDMI_CTRL_ENCRYPTED;
575 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
576 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
577
578 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTHENTICATED;
579 hdcp_ctrl->auth_retries = 0;
580}
581
582/*
583 * hdcp authenticating part 1
584 * Wait Key/An ready
585 * Read BCAPS from sink
586 * Write BCAPS and AKSV into HDCP engine
587 * Write An and AKSV to sink
588 * Read BKSV from sink and write into HDCP engine
589 */
590static int msm_hdmi_hdcp_wait_key_an_ready(struct hdmi_hdcp_ctrl *hdcp_ctrl)
591{
592 int rc;
593 struct hdmi *hdmi = hdcp_ctrl->hdmi;
594 u32 link0_status, keys_state;
595 u32 timeout_count;
596 bool an_ready;
597
598 /* Wait for HDCP keys to be checked and validated */
599 timeout_count = 100;
600 do {
601 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
602 keys_state = (link0_status >> 28) & 0x7;
603 if (keys_state == HDCP_KEYS_STATE_VALID)
604 break;
605
606 DBG("Keys not ready(%d). s=%d, l0=%0x08x",
607 timeout_count, keys_state, link0_status);
608
609 timeout_count--;
610 if (!timeout_count) {
611 pr_err("%s: Wait key state timedout", __func__);
612 return -ETIMEDOUT;
613 }
614
615 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
616 if (rc)
617 return rc;
618 } while (1);
619
620 timeout_count = 100;
621 do {
622 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
623 an_ready = (link0_status & HDMI_HDCP_LINK0_STATUS_AN_0_READY)
624 && (link0_status & HDMI_HDCP_LINK0_STATUS_AN_1_READY);
625 if (an_ready)
626 break;
627
628 DBG("An not ready(%d). l0_status=0x%08x",
629 timeout_count, link0_status);
630
631 timeout_count--;
632 if (!timeout_count) {
633 pr_err("%s: Wait An timedout", __func__);
634 return -ETIMEDOUT;
635 }
636
637 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
638 if (rc)
639 return rc;
640 } while (1);
641
642 return 0;
643}
644
645static int msm_hdmi_hdcp_send_aksv_an(struct hdmi_hdcp_ctrl *hdcp_ctrl)
646{
647 int rc = 0;
648 struct hdmi *hdmi = hdcp_ctrl->hdmi;
649 u32 link0_aksv_0, link0_aksv_1;
650 u32 link0_an[2];
651 u8 aksv[5];
652
653 /* Read An0 and An1 */
654 link0_an[0] = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA5);
655 link0_an[1] = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA6);
656
657 /* Read AKSV */
658 link0_aksv_0 = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA3);
659 link0_aksv_1 = hdmi_read(hdmi, REG_HDMI_HDCP_RCVPORT_DATA4);
660
661 DBG("Link ASKV=%08x%08x", link0_aksv_0, link0_aksv_1);
662 /* Copy An and AKSV to byte arrays for transmission */
663 aksv[0] = link0_aksv_0 & 0xFF;
664 aksv[1] = (link0_aksv_0 >> 8) & 0xFF;
665 aksv[2] = (link0_aksv_0 >> 16) & 0xFF;
666 aksv[3] = (link0_aksv_0 >> 24) & 0xFF;
667 aksv[4] = link0_aksv_1 & 0xFF;
668
669 /* Write An to offset 0x18 */
670 rc = msm_hdmi_ddc_write(hdmi, HDCP_PORT_ADDR, 0x18, (u8 *)link0_an,
671 (u16)sizeof(link0_an));
672 if (rc) {
673 pr_err("%s:An write failed\n", __func__);
674 return rc;
675 }
676 DBG("Link0-An=%08x%08x", link0_an[0], link0_an[1]);
677
678 /* Write AKSV to offset 0x10 */
679 rc = msm_hdmi_ddc_write(hdmi, HDCP_PORT_ADDR, 0x10, aksv, 5);
680 if (rc) {
681 pr_err("%s:AKSV write failed\n", __func__);
682 return rc;
683 }
684 DBG("Link0-AKSV=%02x%08x", link0_aksv_1 & 0xFF, link0_aksv_0);
685
686 return 0;
687}
688
689static int msm_hdmi_hdcp_recv_bksv(struct hdmi_hdcp_ctrl *hdcp_ctrl)
690{
691 int rc = 0;
692 struct hdmi *hdmi = hdcp_ctrl->hdmi;
693 u8 bksv[5];
694 u32 reg[2], data[2];
695
696 /* Read BKSV at offset 0x00 */
697 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x00, bksv, 5);
698 if (rc) {
699 pr_err("%s:BKSV read failed\n", __func__);
700 return rc;
701 }
702
703 hdcp_ctrl->bksv_lsb = bksv[0] | (bksv[1] << 8) |
704 (bksv[2] << 16) | (bksv[3] << 24);
705 hdcp_ctrl->bksv_msb = bksv[4];
706 DBG(":BKSV=%02x%08x", hdcp_ctrl->bksv_msb, hdcp_ctrl->bksv_lsb);
707
708 /* check there are 20 ones in BKSV */
709 if ((hweight32(hdcp_ctrl->bksv_lsb) + hweight32(hdcp_ctrl->bksv_msb))
710 != 20) {
711 pr_err(": BKSV doesn't have 20 1's and 20 0's\n");
712 pr_err(": BKSV chk fail. BKSV=%02x%02x%02x%02x%02x\n",
713 bksv[4], bksv[3], bksv[2], bksv[1], bksv[0]);
714 return -EINVAL;
715 }
716
717 /* Write BKSV read from sink to HDCP registers */
718 reg[0] = REG_HDMI_HDCP_RCVPORT_DATA0;
719 data[0] = hdcp_ctrl->bksv_lsb;
720 reg[1] = REG_HDMI_HDCP_RCVPORT_DATA1;
721 data[1] = hdcp_ctrl->bksv_msb;
722 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, reg, data, 2);
723
724 return rc;
725}
726
727static int msm_hdmi_hdcp_recv_bcaps(struct hdmi_hdcp_ctrl *hdcp_ctrl)
728{
729 int rc = 0;
730 struct hdmi *hdmi = hdcp_ctrl->hdmi;
731 u32 reg, data;
732 u8 bcaps;
733
734 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x40, &bcaps, 1);
735 if (rc) {
736 pr_err("%s:BCAPS read failed\n", __func__);
737 return rc;
738 }
739 DBG("BCAPS=%02x", bcaps);
740
741 /* receiver (0), repeater (1) */
742 hdcp_ctrl->ds_type = (bcaps & BIT(6)) ? DS_REPEATER : DS_RECEIVER;
743
744 /* Write BCAPS to the hardware */
745 reg = REG_HDMI_HDCP_RCVPORT_DATA12;
746 data = (u32)bcaps;
747 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, ®, &data, 1);
748
749 return rc;
750}
751
752static int msm_hdmi_hdcp_auth_part1_key_exchange(struct hdmi_hdcp_ctrl *hdcp_ctrl)
753{
754 struct hdmi *hdmi = hdcp_ctrl->hdmi;
755 unsigned long flags;
756 int rc;
757
758 /* Wait for AKSV key and An ready */
759 rc = msm_hdmi_hdcp_wait_key_an_ready(hdcp_ctrl);
760 if (rc) {
761 pr_err("%s: wait key and an ready failed\n", __func__);
762 return rc;
763 }
764
765 /* Read BCAPS and send to HDCP engine */
766 rc = msm_hdmi_hdcp_recv_bcaps(hdcp_ctrl);
767 if (rc) {
768 pr_err("%s: read bcaps error, abort\n", __func__);
769 return rc;
770 }
771
772 /*
773 * 1.1_Features turned off by default.
774 * No need to write AInfo since 1.1_Features is disabled.
775 */
776 hdmi_write(hdmi, REG_HDMI_HDCP_RCVPORT_DATA4, 0);
777
778 /* Send AKSV and An to sink */
779 rc = msm_hdmi_hdcp_send_aksv_an(hdcp_ctrl);
780 if (rc) {
781 pr_err("%s:An/Aksv write failed\n", __func__);
782 return rc;
783 }
784
785 /* Read BKSV and send to HDCP engine*/
786 rc = msm_hdmi_hdcp_recv_bksv(hdcp_ctrl);
787 if (rc) {
788 pr_err("%s:BKSV Process failed\n", __func__);
789 return rc;
790 }
791
792 /* Enable HDCP interrupts and ack/clear any stale interrupts */
793 spin_lock_irqsave(&hdmi->reg_lock, flags);
794 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL,
795 HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_ACK |
796 HDMI_HDCP_INT_CTRL_AUTH_SUCCESS_MASK |
797 HDMI_HDCP_INT_CTRL_AUTH_FAIL_ACK |
798 HDMI_HDCP_INT_CTRL_AUTH_FAIL_MASK |
799 HDMI_HDCP_INT_CTRL_AUTH_FAIL_INFO_ACK);
800 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
801
802 return 0;
803}
804
805/* read R0' from sink and pass it to HDCP engine */
806static int msm_hdmi_hdcp_auth_part1_recv_r0(struct hdmi_hdcp_ctrl *hdcp_ctrl)
807{
808 struct hdmi *hdmi = hdcp_ctrl->hdmi;
809 int rc = 0;
810 u8 buf[2];
811
812 /*
813 * HDCP Compliance Test case 1A-01:
814 * Wait here at least 100ms before reading R0'
815 */
816 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 125, AUTH_ABORT_EV);
817 if (rc)
818 return rc;
819
820 /* Read R0' at offset 0x08 */
821 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x08, buf, 2);
822 if (rc) {
823 pr_err("%s:R0' read failed\n", __func__);
824 return rc;
825 }
826 DBG("R0'=%02x%02x", buf[1], buf[0]);
827
828 /* Write R0' to HDCP registers and check to see if it is a match */
829 hdmi_write(hdmi, REG_HDMI_HDCP_RCVPORT_DATA2_0,
830 (((u32)buf[1]) << 8) | buf[0]);
831
832 return 0;
833}
834
835/* Wait for authenticating result: R0/R0' are matched or not */
836static int msm_hdmi_hdcp_auth_part1_verify_r0(struct hdmi_hdcp_ctrl *hdcp_ctrl)
837{
838 struct hdmi *hdmi = hdcp_ctrl->hdmi;
839 u32 link0_status;
840 int rc;
841
842 /* wait for hdcp irq, 10 sec should be long enough */
843 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 10000, AUTH_RESULT_RDY_EV);
844 if (!rc) {
845 pr_err("%s: Wait Auth IRQ timeout\n", __func__);
846 return -ETIMEDOUT;
847 }
848
849 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
850 if (!(link0_status & HDMI_HDCP_LINK0_STATUS_RI_MATCHES)) {
851 pr_err("%s: Authentication Part I failed\n", __func__);
852 return -EINVAL;
853 }
854
855 /* Enable HDCP Encryption */
856 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL,
857 HDMI_HDCP_CTRL_ENABLE |
858 HDMI_HDCP_CTRL_ENCRYPTION_ENABLE);
859
860 return 0;
861}
862
863static int msm_hdmi_hdcp_recv_check_bstatus(struct hdmi_hdcp_ctrl *hdcp_ctrl,
864 u16 *pbstatus)
865{
866 int rc;
867 struct hdmi *hdmi = hdcp_ctrl->hdmi;
868 bool max_devs_exceeded = false, max_cascade_exceeded = false;
869 u32 repeater_cascade_depth = 0, down_stream_devices = 0;
870 u16 bstatus;
871 u8 buf[2];
872
873 /* Read BSTATUS at offset 0x41 */
874 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x41, buf, 2);
875 if (rc) {
876 pr_err("%s: BSTATUS read failed\n", __func__);
877 goto error;
878 }
879 *pbstatus = bstatus = (buf[1] << 8) | buf[0];
880
881
882 down_stream_devices = bstatus & 0x7F;
883 repeater_cascade_depth = (bstatus >> 8) & 0x7;
884 max_devs_exceeded = (bstatus & BIT(7)) ? true : false;
885 max_cascade_exceeded = (bstatus & BIT(11)) ? true : false;
886
887 if (down_stream_devices == 0) {
888 /*
889 * If no downstream devices are attached to the repeater
890 * then part II fails.
891 * todo: The other approach would be to continue PART II.
892 */
893 pr_err("%s: No downstream devices\n", __func__);
894 rc = -EINVAL;
895 goto error;
896 }
897
898 /*
899 * HDCP Compliance 1B-05:
900 * Check if no. of devices connected to repeater
901 * exceed max_devices_connected from bit 7 of Bstatus.
902 */
903 if (max_devs_exceeded) {
904 pr_err("%s: no. of devs connected exceeds max allowed",
905 __func__);
906 rc = -EINVAL;
907 goto error;
908 }
909
910 /*
911 * HDCP Compliance 1B-06:
912 * Check if no. of cascade connected to repeater
913 * exceed max_cascade_connected from bit 11 of Bstatus.
914 */
915 if (max_cascade_exceeded) {
916 pr_err("%s: no. of cascade conn exceeds max allowed",
917 __func__);
918 rc = -EINVAL;
919 goto error;
920 }
921
922error:
923 hdcp_ctrl->dev_count = down_stream_devices;
924 hdcp_ctrl->max_cascade_exceeded = max_cascade_exceeded;
925 hdcp_ctrl->max_dev_exceeded = max_devs_exceeded;
926 hdcp_ctrl->depth = repeater_cascade_depth;
927 return rc;
928}
929
930static int msm_hdmi_hdcp_auth_part2_wait_ksv_fifo_ready(
931 struct hdmi_hdcp_ctrl *hdcp_ctrl)
932{
933 int rc;
934 struct hdmi *hdmi = hdcp_ctrl->hdmi;
935 u32 reg, data;
936 u32 timeout_count;
937 u16 bstatus;
938 u8 bcaps;
939
940 /*
941 * Wait until READY bit is set in BCAPS, as per HDCP specifications
942 * maximum permitted time to check for READY bit is five seconds.
943 */
944 timeout_count = 100;
945 do {
946 /* Read BCAPS at offset 0x40 */
947 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x40, &bcaps, 1);
948 if (rc) {
949 pr_err("%s: BCAPS read failed\n", __func__);
950 return rc;
951 }
952
953 if (bcaps & BIT(5))
954 break;
955
956 timeout_count--;
957 if (!timeout_count) {
958 pr_err("%s: Wait KSV fifo ready timedout", __func__);
959 return -ETIMEDOUT;
960 }
961
962 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
963 if (rc)
964 return rc;
965 } while (1);
966
967 rc = msm_hdmi_hdcp_recv_check_bstatus(hdcp_ctrl, &bstatus);
968 if (rc) {
969 pr_err("%s: bstatus error\n", __func__);
970 return rc;
971 }
972
973 /* Write BSTATUS and BCAPS to HDCP registers */
974 reg = REG_HDMI_HDCP_RCVPORT_DATA12;
975 data = bcaps | (bstatus << 8);
976 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, ®, &data, 1);
977 if (rc) {
978 pr_err("%s: BSTATUS write failed\n", __func__);
979 return rc;
980 }
981
982 return 0;
983}
984
985/*
986 * hdcp authenticating part 2: 2nd
987 * read ksv fifo from sink
988 * transfer V' from sink to HDCP engine
989 * reset SHA engine
990 */
991static int msm_hdmi_hdcp_transfer_v_h(struct hdmi_hdcp_ctrl *hdcp_ctrl)
992{
993 struct hdmi *hdmi = hdcp_ctrl->hdmi;
994 int rc = 0;
995 struct hdmi_hdcp_reg_data reg_data[] = {
996 {REG_HDMI_HDCP_RCVPORT_DATA7, 0x20, "V' H0"},
997 {REG_HDMI_HDCP_RCVPORT_DATA8, 0x24, "V' H1"},
998 {REG_HDMI_HDCP_RCVPORT_DATA9, 0x28, "V' H2"},
999 {REG_HDMI_HDCP_RCVPORT_DATA10, 0x2C, "V' H3"},
1000 {REG_HDMI_HDCP_RCVPORT_DATA11, 0x30, "V' H4"},
1001 };
1002 struct hdmi_hdcp_reg_data *rd;
1003 u32 size = ARRAY_SIZE(reg_data);
1004 u32 reg[ARRAY_SIZE(reg_data)];
1005 u32 data[ARRAY_SIZE(reg_data)];
1006 int i;
1007
1008 for (i = 0; i < size; i++) {
1009 rd = ®_data[i];
1010 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR,
1011 rd->off, (u8 *)&data[i], (u16)sizeof(data[i]));
1012 if (rc) {
1013 pr_err("%s: Read %s failed\n", __func__, rd->name);
1014 goto error;
1015 }
1016
1017 DBG("%s =%x", rd->name, data[i]);
1018 reg[i] = reg_data[i].reg_id;
1019 }
1020
1021 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, reg, data, size);
1022
1023error:
1024 return rc;
1025}
1026
1027static int msm_hdmi_hdcp_recv_ksv_fifo(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1028{
1029 int rc;
1030 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1031 u32 ksv_bytes;
1032
1033 ksv_bytes = 5 * hdcp_ctrl->dev_count;
1034
1035 rc = msm_hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x43,
1036 hdcp_ctrl->ksv_list, ksv_bytes);
1037 if (rc)
1038 pr_err("%s: KSV FIFO read failed\n", __func__);
1039
1040 return rc;
1041}
1042
1043static int msm_hdmi_hdcp_reset_sha_engine(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1044{
1045 u32 reg[2], data[2];
1046 u32 rc = 0;
1047
1048 reg[0] = REG_HDMI_HDCP_SHA_CTRL;
1049 data[0] = HDCP_REG_ENABLE;
1050 reg[1] = REG_HDMI_HDCP_SHA_CTRL;
1051 data[1] = HDCP_REG_DISABLE;
1052
1053 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, reg, data, 2);
1054
1055 return rc;
1056}
1057
1058static int msm_hdmi_hdcp_auth_part2_recv_ksv_fifo(
1059 struct hdmi_hdcp_ctrl *hdcp_ctrl)
1060{
1061 int rc;
1062 u32 timeout_count;
1063
1064 /*
1065 * Read KSV FIFO over DDC
1066 * Key Selection vector FIFO Used to pull downstream KSVs
1067 * from HDCP Repeaters.
1068 * All bytes (DEVICE_COUNT * 5) must be read in a single,
1069 * auto incrementing access.
1070 * All bytes read as 0x00 for HDCP Receivers that are not
1071 * HDCP Repeaters (REPEATER == 0).
1072 */
1073 timeout_count = 100;
1074 do {
1075 rc = msm_hdmi_hdcp_recv_ksv_fifo(hdcp_ctrl);
1076 if (!rc)
1077 break;
1078
1079 timeout_count--;
1080 if (!timeout_count) {
1081 pr_err("%s: Recv ksv fifo timedout", __func__);
1082 return -ETIMEDOUT;
1083 }
1084
1085 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 25, AUTH_ABORT_EV);
1086 if (rc)
1087 return rc;
1088 } while (1);
1089
1090 rc = msm_hdmi_hdcp_transfer_v_h(hdcp_ctrl);
1091 if (rc) {
1092 pr_err("%s: transfer V failed\n", __func__);
1093 return rc;
1094 }
1095
1096 /* reset SHA engine before write ksv fifo */
1097 rc = msm_hdmi_hdcp_reset_sha_engine(hdcp_ctrl);
1098 if (rc) {
1099 pr_err("%s: fail to reset sha engine\n", __func__);
1100 return rc;
1101 }
1102
1103 return 0;
1104}
1105
1106/*
1107 * Write KSV FIFO to HDCP_SHA_DATA.
1108 * This is done 1 byte at time starting with the LSB.
1109 * Once 64 bytes have been written, we need to poll for
1110 * HDCP_SHA_BLOCK_DONE before writing any further
1111 * If the last byte is written, we need to poll for
1112 * HDCP_SHA_COMP_DONE to wait until HW finish
1113 */
1114static int msm_hdmi_hdcp_write_ksv_fifo(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1115{
1116 int i;
1117 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1118 u32 ksv_bytes, last_byte = 0;
1119 u8 *ksv_fifo = NULL;
1120 u32 reg_val, data, reg;
1121 u32 rc = 0;
1122
1123 ksv_bytes = 5 * hdcp_ctrl->dev_count;
1124
1125 /* Check if need to wait for HW completion */
1126 if (hdcp_ctrl->ksv_fifo_w_index) {
1127 reg_val = hdmi_read(hdmi, REG_HDMI_HDCP_SHA_STATUS);
1128 DBG("HDCP_SHA_STATUS=%08x", reg_val);
1129 if (hdcp_ctrl->ksv_fifo_w_index == ksv_bytes) {
1130 /* check COMP_DONE if last write */
1131 if (reg_val & HDMI_HDCP_SHA_STATUS_COMP_DONE) {
1132 DBG("COMP_DONE");
1133 return 0;
1134 } else {
1135 return -EAGAIN;
1136 }
1137 } else {
1138 /* check BLOCK_DONE if not last write */
1139 if (!(reg_val & HDMI_HDCP_SHA_STATUS_BLOCK_DONE))
1140 return -EAGAIN;
1141
1142 DBG("BLOCK_DONE");
1143 }
1144 }
1145
1146 ksv_bytes -= hdcp_ctrl->ksv_fifo_w_index;
1147 if (ksv_bytes <= 64)
1148 last_byte = 1;
1149 else
1150 ksv_bytes = 64;
1151
1152 ksv_fifo = hdcp_ctrl->ksv_list;
1153 ksv_fifo += hdcp_ctrl->ksv_fifo_w_index;
1154
1155 for (i = 0; i < ksv_bytes; i++) {
1156 /* Write KSV byte and set DONE bit[0] for last byte*/
1157 reg_val = ksv_fifo[i] << 16;
1158 if ((i == (ksv_bytes - 1)) && last_byte)
1159 reg_val |= HDMI_HDCP_SHA_DATA_DONE;
1160
1161 reg = REG_HDMI_HDCP_SHA_DATA;
1162 data = reg_val;
1163 rc = msm_hdmi_hdcp_scm_wr(hdcp_ctrl, ®, &data, 1);
1164
1165 if (rc)
1166 return rc;
1167 }
1168
1169 hdcp_ctrl->ksv_fifo_w_index += ksv_bytes;
1170
1171 /*
1172 *return -EAGAIN to notify caller to wait for COMP_DONE or BLOCK_DONE
1173 */
1174 return -EAGAIN;
1175}
1176
1177/* write ksv fifo into HDCP engine */
1178static int msm_hdmi_hdcp_auth_part2_write_ksv_fifo(
1179 struct hdmi_hdcp_ctrl *hdcp_ctrl)
1180{
1181 int rc;
1182 u32 timeout_count;
1183
1184 hdcp_ctrl->ksv_fifo_w_index = 0;
1185 timeout_count = 100;
1186 do {
1187 rc = msm_hdmi_hdcp_write_ksv_fifo(hdcp_ctrl);
1188 if (!rc)
1189 break;
1190
1191 if (rc != -EAGAIN)
1192 return rc;
1193
1194 timeout_count--;
1195 if (!timeout_count) {
1196 pr_err("%s: Write KSV fifo timedout", __func__);
1197 return -ETIMEDOUT;
1198 }
1199
1200 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
1201 if (rc)
1202 return rc;
1203 } while (1);
1204
1205 return 0;
1206}
1207
1208static int msm_hdmi_hdcp_auth_part2_check_v_match(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1209{
1210 int rc = 0;
1211 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1212 u32 link0_status;
1213 u32 timeout_count = 100;
1214
1215 do {
1216 link0_status = hdmi_read(hdmi, REG_HDMI_HDCP_LINK0_STATUS);
1217 if (link0_status & HDMI_HDCP_LINK0_STATUS_V_MATCHES)
1218 break;
1219
1220 timeout_count--;
1221 if (!timeout_count) {
1222 pr_err("%s: HDCP V Match timedout", __func__);
1223 return -ETIMEDOUT;
1224 }
1225
1226 rc = msm_hdmi_hdcp_msleep(hdcp_ctrl, 20, AUTH_ABORT_EV);
1227 if (rc)
1228 return rc;
1229 } while (1);
1230
1231 return 0;
1232}
1233
1234static void msm_hdmi_hdcp_auth_work(struct work_struct *work)
1235{
1236 struct hdmi_hdcp_ctrl *hdcp_ctrl = container_of(work,
1237 struct hdmi_hdcp_ctrl, hdcp_auth_work);
1238 int rc;
1239
1240 rc = msm_hdmi_hdcp_auth_prepare(hdcp_ctrl);
1241 if (rc) {
1242 pr_err("%s: auth prepare failed %d\n", __func__, rc);
1243 goto end;
1244 }
1245
1246 /* HDCP PartI */
1247 rc = msm_hdmi_hdcp_auth_part1_key_exchange(hdcp_ctrl);
1248 if (rc) {
1249 pr_err("%s: key exchange failed %d\n", __func__, rc);
1250 goto end;
1251 }
1252
1253 rc = msm_hdmi_hdcp_auth_part1_recv_r0(hdcp_ctrl);
1254 if (rc) {
1255 pr_err("%s: receive r0 failed %d\n", __func__, rc);
1256 goto end;
1257 }
1258
1259 rc = msm_hdmi_hdcp_auth_part1_verify_r0(hdcp_ctrl);
1260 if (rc) {
1261 pr_err("%s: verify r0 failed %d\n", __func__, rc);
1262 goto end;
1263 }
1264 pr_info("%s: Authentication Part I successful\n", __func__);
1265 if (hdcp_ctrl->ds_type == DS_RECEIVER)
1266 goto end;
1267
1268 /* HDCP PartII */
1269 rc = msm_hdmi_hdcp_auth_part2_wait_ksv_fifo_ready(hdcp_ctrl);
1270 if (rc) {
1271 pr_err("%s: wait ksv fifo ready failed %d\n", __func__, rc);
1272 goto end;
1273 }
1274
1275 rc = msm_hdmi_hdcp_auth_part2_recv_ksv_fifo(hdcp_ctrl);
1276 if (rc) {
1277 pr_err("%s: recv ksv fifo failed %d\n", __func__, rc);
1278 goto end;
1279 }
1280
1281 rc = msm_hdmi_hdcp_auth_part2_write_ksv_fifo(hdcp_ctrl);
1282 if (rc) {
1283 pr_err("%s: write ksv fifo failed %d\n", __func__, rc);
1284 goto end;
1285 }
1286
1287 rc = msm_hdmi_hdcp_auth_part2_check_v_match(hdcp_ctrl);
1288 if (rc)
1289 pr_err("%s: check v match failed %d\n", __func__, rc);
1290
1291end:
1292 if (rc == -ECANCELED) {
1293 pr_info("%s: hdcp authentication canceled\n", __func__);
1294 } else if (rc == -ENOTSUPP) {
1295 pr_info("%s: hdcp is not supported\n", __func__);
1296 } else if (rc) {
1297 pr_err("%s: hdcp authentication failed\n", __func__);
1298 msm_hdmi_hdcp_auth_fail(hdcp_ctrl);
1299 } else {
1300 msm_hdmi_hdcp_auth_done(hdcp_ctrl);
1301 }
1302}
1303
1304void msm_hdmi_hdcp_on(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1305{
1306 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1307 u32 reg_val;
1308 unsigned long flags;
1309
1310 if ((HDCP_STATE_INACTIVE != hdcp_ctrl->hdcp_state) ||
1311 (HDCP_STATE_NO_AKSV == hdcp_ctrl->hdcp_state)) {
1312 DBG("still active or activating or no askv. returning");
1313 return;
1314 }
1315
1316 /* clear HDMI Encrypt */
1317 spin_lock_irqsave(&hdmi->reg_lock, flags);
1318 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
1319 reg_val &= ~HDMI_CTRL_ENCRYPTED;
1320 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
1321 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
1322
1323 hdcp_ctrl->auth_event = 0;
1324 hdcp_ctrl->hdcp_state = HDCP_STATE_AUTHENTICATING;
1325 hdcp_ctrl->auth_retries = 0;
1326 queue_work(hdmi->workq, &hdcp_ctrl->hdcp_auth_work);
1327}
1328
1329void msm_hdmi_hdcp_off(struct hdmi_hdcp_ctrl *hdcp_ctrl)
1330{
1331 struct hdmi *hdmi = hdcp_ctrl->hdmi;
1332 unsigned long flags;
1333 u32 reg_val;
1334
1335 if ((HDCP_STATE_INACTIVE == hdcp_ctrl->hdcp_state) ||
1336 (HDCP_STATE_NO_AKSV == hdcp_ctrl->hdcp_state)) {
1337 DBG("hdcp inactive or no aksv. returning");
1338 return;
1339 }
1340
1341 /*
1342 * Disable HPD circuitry.
1343 * This is needed to reset the HDCP cipher engine so that when we
1344 * attempt a re-authentication, HW would clear the AN0_READY and
1345 * AN1_READY bits in HDMI_HDCP_LINK0_STATUS register
1346 */
1347 spin_lock_irqsave(&hdmi->reg_lock, flags);
1348 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
1349 reg_val &= ~HDMI_HPD_CTRL_ENABLE;
1350 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
1351
1352 /*
1353 * Disable HDCP interrupts.
1354 * Also, need to set the state to inactive here so that any ongoing
1355 * reauth works will know that the HDCP session has been turned off.
1356 */
1357 hdmi_write(hdmi, REG_HDMI_HDCP_INT_CTRL, 0);
1358 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
1359
1360 /*
1361 * Cancel any pending auth/reauth attempts.
1362 * If one is ongoing, this will wait for it to finish.
1363 * No more reauthentication attempts will be scheduled since we
1364 * set the current state to inactive.
1365 */
1366 set_bit(AUTH_ABORT_EV, &hdcp_ctrl->auth_event);
1367 wake_up_all(&hdcp_ctrl->auth_event_queue);
1368 cancel_work_sync(&hdcp_ctrl->hdcp_auth_work);
1369 cancel_work_sync(&hdcp_ctrl->hdcp_reauth_work);
1370
1371 hdmi_write(hdmi, REG_HDMI_HDCP_RESET,
1372 HDMI_HDCP_RESET_LINK0_DEAUTHENTICATE);
1373
1374 /* Disable encryption and disable the HDCP block */
1375 hdmi_write(hdmi, REG_HDMI_HDCP_CTRL, 0);
1376
1377 spin_lock_irqsave(&hdmi->reg_lock, flags);
1378 reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
1379 reg_val &= ~HDMI_CTRL_ENCRYPTED;
1380 hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
1381
1382 /* Enable HPD circuitry */
1383 reg_val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
1384 reg_val |= HDMI_HPD_CTRL_ENABLE;
1385 hdmi_write(hdmi, REG_HDMI_HPD_CTRL, reg_val);
1386 spin_unlock_irqrestore(&hdmi->reg_lock, flags);
1387
1388 hdcp_ctrl->hdcp_state = HDCP_STATE_INACTIVE;
1389
1390 DBG("HDCP: Off");
1391}
1392
1393struct hdmi_hdcp_ctrl *msm_hdmi_hdcp_init(struct hdmi *hdmi)
1394{
1395 struct hdmi_hdcp_ctrl *hdcp_ctrl = NULL;
1396
1397 if (!hdmi->qfprom_mmio) {
1398 pr_err("%s: HDCP is not supported without qfprom\n",
1399 __func__);
1400 return ERR_PTR(-EINVAL);
1401 }
1402
1403 hdcp_ctrl = kzalloc(sizeof(*hdcp_ctrl), GFP_KERNEL);
1404 if (!hdcp_ctrl)
1405 return ERR_PTR(-ENOMEM);
1406
1407 INIT_WORK(&hdcp_ctrl->hdcp_auth_work, msm_hdmi_hdcp_auth_work);
1408 INIT_WORK(&hdcp_ctrl->hdcp_reauth_work, msm_hdmi_hdcp_reauth_work);
1409 init_waitqueue_head(&hdcp_ctrl->auth_event_queue);
1410 hdcp_ctrl->hdmi = hdmi;
1411 hdcp_ctrl->hdcp_state = HDCP_STATE_INACTIVE;
1412 hdcp_ctrl->aksv_valid = false;
1413
1414 if (qcom_scm_hdcp_available())
1415 hdcp_ctrl->tz_hdcp = true;
1416 else
1417 hdcp_ctrl->tz_hdcp = false;
1418
1419 return hdcp_ctrl;
1420}
1421
1422void msm_hdmi_hdcp_destroy(struct hdmi *hdmi)
1423{
1424 if (hdmi) {
1425 kfree(hdmi->hdcp_ctrl);
1426 hdmi->hdcp_ctrl = NULL;
1427 }
1428}