/* linux/drivers/media/video/exynos/tv/hdcp_drv.c
*
* Copyright (c) 2011 Samsung Electronics
* http://www.samsung.com/
*
* HDCP function for Samsung TV driver
*
* This program is free software. you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/i2c.h>
#include <linux/io.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/workqueue.h>
#include "hdmi.h"
#include "regs-hdmi-5250.h"
#define AN_SIZE 8
#define AKSV_SIZE 5
#define BKSV_SIZE 5
#define MAX_KEY_SIZE 16
#define BKSV_RETRY_CNT 14
#define BKSV_DELAY 100
#define DDC_RETRY_CNT 400000
#define DDC_DELAY 25
#define KEY_LOAD_RETRY_CNT 1000
#define ENCRYPT_CHECK_CNT 10
#define KSV_FIFO_RETRY_CNT 50
#define KSV_FIFO_CHK_DELAY 100 /* ms */
#define KSV_LIST_RETRY_CNT 10000
#define BCAPS_SIZE 1
#define BSTATUS_SIZE 2
#define SHA_1_HASH_SIZE 20
#define HDCP_MAX_DEVS 128
#define HDCP_KSV_SIZE 5
/* offset of HDCP port */
#define HDCP_BKSV 0x00
#define HDCP_RI 0x08
#define HDCP_AKSV 0x10
#define HDCP_AN 0x18
#define HDCP_SHA1 0x20
#define HDCP_BCAPS 0x40
#define HDCP_BSTATUS 0x41
#define HDCP_KSVFIFO 0x43
#define KSV_FIFO_READY (0x1 << 5)
#define MAX_CASCADE_EXCEEDED_ERROR (-2)
#define MAX_DEVS_EXCEEDED_ERROR (-3)
#define REPEATER_ILLEGAL_DEVICE_ERROR (-4)
#define REPEATER_TIMEOUT_ERROR (-5)
#define MAX_CASCADE_EXCEEDED (0x1 << 3)
#define MAX_DEVS_EXCEEDED (0x1 << 7)
struct i2c_client *hdcp_client;
int hdcp_i2c_read(struct hdmi_device *hdev, u8 offset, int bytes, u8 *buf)
{
struct device *dev = hdev->dev;
struct i2c_client *i2c = hdcp_client;
int ret, cnt = 0;
struct i2c_msg msg[] = {
[0] = {
.addr = i2c->addr,
.flags = 0,
.len = 1,
.buf = &offset
},
[1] = {
.addr = i2c->addr,
.flags = I2C_M_RD,
.len = bytes,
.buf = buf
}
};
do {
if (!is_hdmi_streaming(hdev))
goto ddc_read_err;
ret = i2c_transfer(i2c->adapter, msg, 2);
if (ret < 0 || ret != 2)
dev_dbg(dev, "%s: can't read data, retry %d\n",
__func__, cnt);
else
break;
if (hdev->hdcp_info.auth_status == FIRST_AUTHENTICATION_DONE
|| hdev->hdcp_info.auth_status == SECOND_AUTHENTICATION_DONE)
goto ddc_read_err;
msleep(DDC_DELAY);
cnt++;
} while (cnt < DDC_RETRY_CNT);
if (cnt == DDC_RETRY_CNT)
goto ddc_read_err;
dev_dbg(dev, "%s: read data ok\n", __func__);
return 0;
ddc_read_err:
dev_err(dev, "%s: can't read data, timeout\n", __func__);
return -ETIME;
}
int hdcp_i2c_write(struct hdmi_device *hdev, u8 offset, int bytes, u8 *buf)
{
struct device *dev = hdev->dev;
struct i2c_client *i2c = hdcp_client;
u8 msg[bytes + 1];
int ret, cnt = 0;
msg[0] = offset;
memcpy(&msg[1], buf, bytes);
do {
if (!is_hdmi_streaming(hdev))
goto ddc_write_err;
ret = i2c_master_send(i2c, msg, bytes + 1);
if (ret < 0 || ret < bytes + 1)
dev_dbg(dev, "%s: can't write data, retry %d\n",
__func__, cnt);
else
break;
msleep(DDC_DELAY);
cnt++;
} while (cnt < DDC_RETRY_CNT);
if (cnt == DDC_RETRY_CNT)
goto ddc_write_err;
dev_dbg(dev, "%s: write data ok\n", __func__);
return 0;
ddc_write_err:
dev_err(dev, "%s: can't write data, timeout\n", __func__);
return -ETIME;
}
static int __devinit hdcp_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
int ret = 0;
hdcp_client = client;
dev_info(&client->adapter->dev, "attached exynos hdcp "
"into i2c adapter successfully\n");
return ret;
}
static int hdcp_remove(struct i2c_client *client)
{
dev_info(&client->adapter->dev, "detached exynos hdcp "
"from i2c adapter successfully\n");
return 0;
}
static int hdcp_suspend(struct i2c_client *cl, pm_message_t mesg)
{
return 0;
};
static int hdcp_resume(struct i2c_client *cl)
{
return 0;
};
static struct i2c_device_id hdcp_idtable[] = {
{"exynos_hdcp", 0},
};
MODULE_DEVICE_TABLE(i2c, hdcp_idtable);
static struct i2c_driver hdcp_driver = {
.driver = {
.name = "exynos_hdcp",
.owner = THIS_MODULE,
},
.id_table = hdcp_idtable,
.probe = hdcp_probe,
.remove = __devexit_p(hdcp_remove),
.suspend = hdcp_suspend,
.resume = hdcp_resume,
};
static int __init hdcp_init(void)
{
return i2c_add_driver(&hdcp_driver);
}
static void __exit hdcp_exit(void)
{
i2c_del_driver(&hdcp_driver);
}
module_init(hdcp_init);
module_exit(hdcp_exit);
/* internal functions of HDCP */
static void hdcp_encryption(struct hdmi_device *hdev, bool on)
{
if (on)
hdmi_write_mask(hdev, HDMI_ENC_EN, ~0, HDMI_HDCP_ENC_ENABLE);
else
hdmi_write_mask(hdev, HDMI_ENC_EN, 0, HDMI_HDCP_ENC_ENABLE);
hdmi_reg_mute(hdev, !on);
}
static int hdcp_write_key(struct hdmi_device *hdev, int size, int reg, int offset)
{
struct device *dev = hdev->dev;
u8 buf[MAX_KEY_SIZE];
int cnt, zero = 0;
int i;
memset(buf, 0, sizeof(buf));
hdmi_read_bytes(hdev, reg, buf, size);
for (cnt = 0; cnt < size; cnt++)
if (buf[cnt] == 0)
zero++;
if (zero == size) {
dev_dbg(dev, "%s: %s is null\n", __func__,
offset == HDCP_AN ? "An" : "Aksv");
goto write_key_err;
}
if (hdcp_i2c_write(hdev, offset, size, buf) < 0)
goto write_key_err;
for (i = 1; i < size + 1; i++)
dev_dbg(dev, "%s: %s[%d] : 0x%02x\n", __func__,
offset == HDCP_AN ? "An" : "Aksv", i, buf[i]);
return 0;
write_key_err:
dev_dbg(dev, "%s: write %s is failed\n", __func__,
offset == HDCP_AN ? "An" : "Aksv");
return -1;
}
static int hdcp_read_bcaps(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 bcaps = 0;
if (hdcp_i2c_read(hdev, HDCP_BCAPS, BCAPS_SIZE, &bcaps) < 0)
goto bcaps_read_err;
if (!is_hdmi_streaming(hdev))
goto bcaps_read_err;
hdmi_writeb(hdev, HDMI_HDCP_BCAPS, bcaps);
if (bcaps & HDMI_HDCP_BCAPS_REPEATER)
hdev->hdcp_info.is_repeater = 1;
else
hdev->hdcp_info.is_repeater = 0;
dev_dbg(dev, "%s: device is %s\n", __func__,
hdev->hdcp_info.is_repeater ? "REPEAT" : "SINK");
dev_dbg(dev, "%s: [i2c] bcaps : 0x%02x\n", __func__, bcaps);
return 0;
bcaps_read_err:
dev_err(dev, "can't read bcaps : timeout\n");
return -ETIME;
}
static int hdcp_read_bksv(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 bksv[BKSV_SIZE];
int i, j;
u32 one = 0, zero = 0, result = 0;
u32 cnt = 0;
memset(bksv, 0, sizeof(bksv));
do {
if (hdcp_i2c_read(hdev, HDCP_BKSV, BKSV_SIZE, bksv) < 0)
goto bksv_read_err;
for (i = 0; i < BKSV_SIZE; i++)
dev_dbg(dev, "%s: i2c read : bksv[%d]: 0x%x\n",
__func__, i, bksv[i]);
for (i = 0; i < BKSV_SIZE; i++) {
for (j = 0; j < 8; j++) {
result = bksv[i] & (0x1 << j);
if (result == 0)
zero++;
else
one++;
}
}
if (!is_hdmi_streaming(hdev))
goto bksv_read_err;
if ((zero == 20) && (one == 20)) {
hdmi_write_bytes(hdev, HDMI_HDCP_BKSV_(0), bksv, BKSV_SIZE);
break;
}
dev_dbg(dev, "%s: invalid bksv, retry : %d\n", __func__, cnt);
msleep(BKSV_DELAY);
cnt++;
} while (cnt < BKSV_RETRY_CNT);
if (cnt == BKSV_RETRY_CNT)
goto bksv_read_err;
dev_dbg(dev, "%s: bksv read OK, retry : %d\n", __func__, cnt);
return 0;
bksv_read_err:
dev_err(dev, "%s: can't read bksv : timeout\n", __func__);
return -ETIME;
}
static int hdcp_read_ri(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 ri[2] = {0, 0};
u8 rj[2] = {0, 0};
ri[0] = hdmi_readb(hdev, HDMI_HDCP_RI_0);
ri[1] = hdmi_readb(hdev, HDMI_HDCP_RI_1);
if (hdcp_i2c_read(hdev, HDCP_RI, 2, rj) < 0)
goto compare_err;
dev_dbg(dev, "%s: Rx -> rj[0]: 0x%02x, rj[1]: 0x%02x\n", __func__,
rj[0], rj[1]);
dev_dbg(dev, "%s: Tx -> ri[0]: 0x%02x, ri[1]: 0x%02x\n", __func__,
ri[0], ri[1]);
if ((ri[0] == rj[0]) && (ri[1] == rj[1]) && (ri[0] | ri[1]))
hdmi_writeb(hdev, HDMI_HDCP_CHECK_RESULT,
HDMI_HDCP_RI_MATCH_RESULT_Y);
else {
hdmi_writeb(hdev, HDMI_HDCP_CHECK_RESULT,
HDMI_HDCP_RI_MATCH_RESULT_N);
goto compare_err;
}
memset(ri, 0, sizeof(ri));
memset(rj, 0, sizeof(rj));
dev_dbg(dev, "%s: ri and ri' are matched\n", __func__);
return 0;
compare_err:
hdev->hdcp_info.event = HDCP_EVENT_STOP;
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
dev_err(dev, "%s: ri and ri' are mismatched\n", __func__);
msleep(10);
return -1;
}
static void hdcp_sw_reset(struct hdmi_device *hdev)
{
u8 val;
val = hdmi_get_int_mask(hdev);
hdmi_set_int_mask(hdev, HDMI_INTC_EN_HPD_PLUG, 0);
hdmi_set_int_mask(hdev, HDMI_INTC_EN_HPD_UNPLUG, 0);
hdmi_sw_hpd_enable(hdev, 1);
hdmi_sw_hpd_plug(hdev, 0);
hdmi_sw_hpd_plug(hdev, 1);
hdmi_sw_hpd_enable(hdev, 0);
if (val & HDMI_INTC_EN_HPD_PLUG)
hdmi_set_int_mask(hdev, HDMI_INTC_EN_HPD_PLUG, 1);
if (val & HDMI_INTC_EN_HPD_UNPLUG)
hdmi_set_int_mask(hdev, HDMI_INTC_EN_HPD_UNPLUG, 1);
}
static int hdcp_reset_auth(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 val;
unsigned long spin_flags;
if (!is_hdmi_streaming(hdev))
return -ENODEV;
spin_lock_irqsave(&hdev->hdcp_info.reset_lock, spin_flags);
hdev->hdcp_info.event = HDCP_EVENT_STOP;
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
hdmi_write(hdev, HDMI_HDCP_CTRL1, 0x0);
hdmi_write(hdev, HDMI_HDCP_CTRL2, 0x0);
hdmi_reg_mute(hdev, 1);
hdcp_encryption(hdev, 0);
dev_dbg(dev, "%s: reset authentication\n", __func__);
val = HDMI_UPDATE_RI_INT_EN | HDMI_WRITE_INT_EN |
HDMI_WATCHDOG_INT_EN | HDMI_WTFORACTIVERX_INT_EN;
hdmi_write_mask(hdev, HDMI_STATUS_EN, 0, val);
hdmi_writeb(hdev, HDMI_HDCP_CHECK_RESULT, HDMI_HDCP_CLR_ALL_RESULTS);
/* need some delay (at least 1 frame) */
mdelay(16);
hdcp_sw_reset(hdev);
val = HDMI_UPDATE_RI_INT_EN | HDMI_WRITE_INT_EN |
HDMI_WATCHDOG_INT_EN | HDMI_WTFORACTIVERX_INT_EN;
hdmi_write_mask(hdev, HDMI_STATUS_EN, ~0, val);
hdmi_write_mask(hdev, HDMI_HDCP_CTRL1, ~0, HDMI_HDCP_CP_DESIRED_EN);
spin_unlock_irqrestore(&hdev->hdcp_info.reset_lock, spin_flags);
return 0;
}
static int hdcp_loadkey(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 val;
int cnt = 0;
hdmi_write_mask(hdev, HDMI_EFUSE_CTRL, ~0, HDMI_EFUSE_CTRL_HDCP_KEY_READ);
do {
val = hdmi_readb(hdev, HDMI_EFUSE_STATUS);
if (val & HDMI_EFUSE_ECC_DONE)
break;
cnt++;
mdelay(1);
} while (cnt < KEY_LOAD_RETRY_CNT);
if (cnt == KEY_LOAD_RETRY_CNT)
goto key_load_err;
val = hdmi_readb(hdev, HDMI_EFUSE_STATUS);
if (val & HDMI_EFUSE_ECC_FAIL)
goto key_load_err;
dev_dbg(dev, "%s: load key is ok\n", __func__);
return 0;
key_load_err:
dev_err(dev, "%s: can't load key\n", __func__);
return -1;
}
static int hdmi_start_encryption(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 val;
u32 cnt = 0;
do {
val = hdmi_readb(hdev, HDMI_STATUS);
if (val & HDMI_AUTHEN_ACK_AUTH) {
hdcp_encryption(hdev, 1);
break;
}
mdelay(1);
cnt++;
} while (cnt < ENCRYPT_CHECK_CNT);
if (cnt == ENCRYPT_CHECK_CNT)
goto encrypt_err;
dev_dbg(dev, "%s: encryption is start\n", __func__);
return 0;
encrypt_err:
hdcp_encryption(hdev, 0);
dev_err(dev, "%s: encryption is failed\n", __func__);
return -1;
}
static int hdmi_check_repeater(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
int val, i;
int cnt = 0, cnt2 = 0;
u8 bcaps = 0;
u8 status[BSTATUS_SIZE];
u8 rx_v[SHA_1_HASH_SIZE];
u8 ksv_list[HDCP_MAX_DEVS * HDCP_KSV_SIZE];
u32 dev_cnt;
memset(status, 0, sizeof(status));
memset(rx_v, 0, sizeof(rx_v));
memset(ksv_list, 0, sizeof(ksv_list));
do {
if (hdcp_read_bcaps(hdev) < 0)
goto check_repeater_err;
bcaps = hdmi_readb(hdev, HDMI_HDCP_BCAPS);
if (bcaps & KSV_FIFO_READY) {
dev_dbg(dev, "%s: repeater : ksv fifo not ready\n",
__func__);
dev_dbg(dev, "%s: retries = %d\n", __func__, cnt);
break;
}
msleep(KSV_FIFO_CHK_DELAY);
cnt++;
} while (cnt < KSV_FIFO_RETRY_CNT);
if (cnt == KSV_FIFO_RETRY_CNT)
return REPEATER_TIMEOUT_ERROR;
dev_dbg(dev, "%s: repeater : ksv fifo ready\n", __func__);
if (hdcp_i2c_read(hdev, HDCP_BSTATUS, BSTATUS_SIZE, status) < 0)
goto check_repeater_err;
if (status[1] & MAX_CASCADE_EXCEEDED)
return MAX_CASCADE_EXCEEDED_ERROR;
else if (status[0] & MAX_DEVS_EXCEEDED)
return MAX_DEVS_EXCEEDED_ERROR;
hdmi_writeb(hdev, HDMI_HDCP_BSTATUS_0, status[0]);
hdmi_writeb(hdev, HDMI_HDCP_BSTATUS_1, status[1]);
dev_dbg(dev, "%s: status[0] :0x%02x\n", __func__, status[0]);
dev_dbg(dev, "%s: status[1] :0x%02x\n", __func__, status[1]);
dev_cnt = status[0] & 0x7f;
dev_dbg(dev, "%s: repeater : dev cnt = %d\n", __func__, dev_cnt);
if (dev_cnt) {
if (hdcp_i2c_read(hdev, HDCP_KSVFIFO, dev_cnt * HDCP_KSV_SIZE,
ksv_list) < 0)
goto check_repeater_err;
cnt = 0;
do {
hdmi_write_bytes(hdev, HDMI_HDCP_KSV_LIST_(0),
&ksv_list[cnt * 5], HDCP_KSV_SIZE);
val = HDMI_HDCP_KSV_WRITE_DONE;
if (cnt == dev_cnt - 1)
val |= HDMI_HDCP_KSV_END;
hdmi_write(hdev, HDMI_HDCP_KSV_LIST_CON, val);
if (cnt < dev_cnt - 1) {
cnt2 = 0;
do {
val = hdmi_readb(hdev,
HDMI_HDCP_KSV_LIST_CON);
if (val & HDMI_HDCP_KSV_READ)
break;
cnt2++;
} while (cnt2 < KSV_LIST_RETRY_CNT);
if (cnt2 == KSV_LIST_RETRY_CNT)
dev_dbg(dev, "%s: ksv list not readed\n",
__func__);
}
cnt++;
} while (cnt < dev_cnt);
} else
hdmi_writeb(hdev, HDMI_HDCP_KSV_LIST_CON, HDMI_HDCP_KSV_LIST_EMPTY);
if (hdcp_i2c_read(hdev, HDCP_SHA1, SHA_1_HASH_SIZE, rx_v) < 0)
goto check_repeater_err;
for (i = 0; i < SHA_1_HASH_SIZE; i++)
dev_dbg(dev, "%s: [i2c] SHA-1 rx :: %02x\n", __func__, rx_v[i]);
hdmi_write_bytes(hdev, HDMI_HDCP_SHA1_(0), rx_v, SHA_1_HASH_SIZE);
val = hdmi_readb(hdev, HDMI_HDCP_SHA_RESULT);
if (val & HDMI_HDCP_SHA_VALID_RD) {
if (val & HDMI_HDCP_SHA_VALID) {
dev_dbg(dev, "%s: SHA-1 result is ok\n", __func__);
hdmi_writeb(hdev, HDMI_HDCP_SHA_RESULT, 0x0);
} else {
dev_dbg(dev, "%s: SHA-1 result is not vaild\n", __func__);
hdmi_writeb(hdev, HDMI_HDCP_SHA_RESULT, 0x0);
goto check_repeater_err;
}
} else {
dev_dbg(dev, "%s: SHA-1 result is not ready\n", __func__);
hdmi_writeb(hdev, HDMI_HDCP_SHA_RESULT, 0x0);
goto check_repeater_err;
}
dev_dbg(dev, "%s: check repeater is ok\n", __func__);
return 0;
check_repeater_err:
dev_err(dev, "%s: check repeater is failed\n", __func__);
return -1;
}
static int hdcp_bksv(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
dev_dbg(dev, "%s\n", __func__);
hdev->hdcp_info.auth_status = RECEIVER_READ_READY;
if (hdcp_read_bcaps(hdev) < 0)
goto bksv_start_err;
hdev->hdcp_info.auth_status = BCAPS_READ_DONE;
if (hdcp_read_bksv(hdev) < 0)
goto bksv_start_err;
hdev->hdcp_info.auth_status = BKSV_READ_DONE;
dev_dbg(dev, "%s: bksv start is ok\n", __func__);
return 0;
bksv_start_err:
dev_err(dev, "%s: failed to start bksv\n", __func__);
msleep(100);
return -1;
}
static int hdcp_second_auth(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
int ret = 0;
dev_dbg(dev, "%s\n", __func__);
if (!hdev->hdcp_info.hdcp_start)
goto second_auth_err;
if (!is_hdmi_streaming(hdev))
goto second_auth_err;
ret = hdmi_check_repeater(hdev);
if (!ret) {
hdev->hdcp_info.auth_status = SECOND_AUTHENTICATION_DONE;
hdmi_start_encryption(hdev);
} else {
switch (ret) {
case REPEATER_ILLEGAL_DEVICE_ERROR:
hdmi_writeb(hdev, HDMI_HDCP_CTRL2, 0x1);
mdelay(1);
hdmi_writeb(hdev, HDMI_HDCP_CTRL2, 0x0);
dev_dbg(dev, "%s: repeater : illegal device\n",
__func__);
break;
case REPEATER_TIMEOUT_ERROR:
hdmi_write_mask(hdev, HDMI_HDCP_CTRL1, ~0,
HDMI_HDCP_SET_REPEATER_TIMEOUT);
hdmi_write_mask(hdev, HDMI_HDCP_CTRL1, 0,
HDMI_HDCP_SET_REPEATER_TIMEOUT);
dev_dbg(dev, "%s: repeater : timeout\n", __func__);
break;
case MAX_CASCADE_EXCEEDED_ERROR:
dev_dbg(dev, "%s: repeater : exceeded MAX_CASCADE\n",
__func__);
break;
case MAX_DEVS_EXCEEDED_ERROR:
dev_dbg(dev, "%s: repeater : exceeded MAX_DEVS\n",
__func__);
break;
default:
break;
}
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
goto second_auth_err;
}
dev_dbg(dev, "%s: second authentication is OK\n", __func__);
return 0;
second_auth_err:
dev_dbg(dev, "%s: second authentication is failed\n", __func__);
return -1;
}
static int hdcp_write_aksv(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
dev_dbg(dev, "%s\n", __func__);
if (hdev->hdcp_info.auth_status != BKSV_READ_DONE) {
dev_err(dev, "%s: bksv is not ready\n", __func__);
goto aksv_write_err;
}
if (!is_hdmi_streaming(hdev))
goto aksv_write_err;
if (hdcp_write_key(hdev, AN_SIZE, HDMI_HDCP_AN_(0), HDCP_AN) < 0)
goto aksv_write_err;
hdev->hdcp_info.auth_status = AN_WRITE_DONE;
dev_dbg(dev, "%s: write An is done\n", __func__);
if (hdcp_write_key(hdev, AKSV_SIZE, HDMI_HDCP_AKSV_(0), HDCP_AKSV) < 0)
goto aksv_write_err;
msleep(100);
hdev->hdcp_info.auth_status = AKSV_WRITE_DONE;
dev_dbg(dev, "%s: write aksv is done\n", __func__);
dev_dbg(dev, "%s: aksv start is OK\n", __func__);
return 0;
aksv_write_err:
dev_err(dev, "%s: aksv start is failed\n", __func__);
return -1;
}
static int hdcp_check_ri(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
dev_dbg(dev, "%s\n", __func__);
if (hdev->hdcp_info.auth_status < AKSV_WRITE_DONE) {
dev_dbg(dev, "%s: ri check is not ready\n", __func__);
goto check_ri_err;
}
if (!is_hdmi_streaming(hdev))
goto check_ri_err;
if (hdcp_read_ri(hdev) < 0)
goto check_ri_err;
if (hdev->hdcp_info.is_repeater)
hdev->hdcp_info.auth_status
= SECOND_AUTHENTICATION_RDY;
else {
hdev->hdcp_info.auth_status
= FIRST_AUTHENTICATION_DONE;
hdmi_start_encryption(hdev);
}
dev_dbg(dev, "%s: ri check is OK\n", __func__);
return 0;
check_ri_err:
dev_err(dev, "%s: ri check is failed\n", __func__);
return -1;
}
static void hdcp_work(struct work_struct *work)
{
struct hdmi_device *hdev = container_of(work, struct hdmi_device, work);
if (!hdev->hdcp_info.hdcp_start)
return;
if (!is_hdmi_streaming(hdev))
return;
if (hdev->hdcp_info.event & HDCP_EVENT_READ_BKSV_START) {
if (hdcp_bksv(hdev) < 0)
goto work_err;
else
hdev->hdcp_info.event &= ~HDCP_EVENT_READ_BKSV_START;
}
if (hdev->hdcp_info.event & HDCP_EVENT_SECOND_AUTH_START) {
if (hdcp_second_auth(hdev) < 0)
goto work_err;
else
hdev->hdcp_info.event &= ~HDCP_EVENT_SECOND_AUTH_START;
}
if (hdev->hdcp_info.event & HDCP_EVENT_WRITE_AKSV_START) {
if (hdcp_write_aksv(hdev) < 0)
goto work_err;
else
hdev->hdcp_info.event &= ~HDCP_EVENT_WRITE_AKSV_START;
}
if (hdev->hdcp_info.event & HDCP_EVENT_CHECK_RI_START) {
if (hdcp_check_ri(hdev) < 0)
goto work_err;
else
hdev->hdcp_info.event &= ~HDCP_EVENT_CHECK_RI_START;
}
return;
work_err:
if (!hdev->hdcp_info.hdcp_start)
return;
if (!is_hdmi_streaming(hdev))
return;
hdcp_reset_auth(hdev);
}
/* HDCP APIs for hdmi driver */
irqreturn_t hdcp_irq_handler(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u32 event = 0;
u8 flag;
event = 0;
if (!hdev->streaming) {
hdev->hdcp_info.event = HDCP_EVENT_STOP;
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
return IRQ_HANDLED;
}
flag = hdmi_readb(hdev, HDMI_STATUS);
if (flag & HDMI_WTFORACTIVERX_INT_OCC) {
event |= HDCP_EVENT_READ_BKSV_START;
hdmi_write_mask(hdev, HDMI_STATUS, ~0, HDMI_WTFORACTIVERX_INT_OCC);
hdmi_write(hdev, HDMI_HDCP_I2C_INT, 0x0);
}
if (flag & HDMI_WRITE_INT_OCC) {
event |= HDCP_EVENT_WRITE_AKSV_START;
hdmi_write_mask(hdev, HDMI_STATUS, ~0, HDMI_WRITE_INT_OCC);
hdmi_write(hdev, HDMI_HDCP_AN_INT, 0x0);
}
if (flag & HDMI_UPDATE_RI_INT_OCC) {
event |= HDCP_EVENT_CHECK_RI_START;
hdmi_write_mask(hdev, HDMI_STATUS, ~0, HDMI_UPDATE_RI_INT_OCC);
hdmi_write(hdev, HDMI_HDCP_RI_INT, 0x0);
}
if (flag & HDMI_WATCHDOG_INT_OCC) {
event |= HDCP_EVENT_SECOND_AUTH_START;
hdmi_write_mask(hdev, HDMI_STATUS, ~0, HDMI_WATCHDOG_INT_OCC);
hdmi_write(hdev, HDMI_HDCP_WDT_INT, 0x0);
}
if (!event) {
dev_dbg(dev, "%s: unknown irq\n", __func__);
return IRQ_HANDLED;
}
if (is_hdmi_streaming(hdev)) {
hdev->hdcp_info.event |= event;
queue_work(hdev->hdcp_wq, &hdev->work);
} else {
hdev->hdcp_info.event = HDCP_EVENT_STOP;
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
}
return IRQ_HANDLED;
}
int hdcp_prepare(struct hdmi_device *hdev)
{
hdev->hdcp_wq = create_workqueue("khdcpd");
if (hdev->hdcp_wq == NULL)
return -ENOMEM;
INIT_WORK(&hdev->work, hdcp_work);
spin_lock_init(&hdev->hdcp_info.reset_lock);
#if defined(CONFIG_VIDEO_EXYNOS_HDCP)
hdev->hdcp_info.hdcp_enable = 1;
#else
hdev->hdcp_info.hdcp_enable = 0;
#endif
return 0;
}
int hdcp_start(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
hdev->hdcp_info.event = HDCP_EVENT_STOP;
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
dev_dbg(dev, "%s\n", __func__);
hdcp_sw_reset(hdev);
dev_dbg(dev, "%s: stop encryption\n", __func__);
hdcp_encryption(hdev, 0);
msleep(120);
if (hdcp_loadkey(hdev) < 0)
return -1;
hdmi_write(hdev, HDMI_GCP_CON, HDMI_GCP_CON_NO_TRAN);
hdmi_write(hdev, HDMI_STATUS_EN, HDMI_INT_EN_ALL);
hdmi_write(hdev, HDMI_HDCP_CTRL1, HDMI_HDCP_CP_DESIRED_EN);
hdmi_set_int_mask(hdev, HDMI_INTC_EN_HDCP, 1);
hdev->hdcp_info.hdcp_start = 1;
return 0;
}
int hdcp_stop(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
u8 val;
dev_dbg(dev, "%s\n", __func__);
hdmi_set_int_mask(hdev, HDMI_INTC_EN_HDCP, 0);
hdev->hdcp_info.event = HDCP_EVENT_STOP;
hdev->hdcp_info.auth_status = NOT_AUTHENTICATED;
hdev->hdcp_info.hdcp_start = false;
hdmi_writeb(hdev, HDMI_HDCP_CTRL1, 0x0);
hdmi_sw_hpd_enable(hdev, 0);
val = HDMI_UPDATE_RI_INT_EN | HDMI_WRITE_INT_EN |
HDMI_WATCHDOG_INT_EN | HDMI_WTFORACTIVERX_INT_EN;
hdmi_write_mask(hdev, HDMI_STATUS_EN, 0, val);
hdmi_write_mask(hdev, HDMI_STATUS_EN, ~0, val);
hdmi_write_mask(hdev, HDMI_STATUS, ~0, HDMI_INT_EN_ALL);
dev_dbg(dev, "%s: stop encryption\n", __func__);
hdcp_encryption(hdev, 0);
hdmi_writeb(hdev, HDMI_HDCP_CHECK_RESULT, HDMI_HDCP_CLR_ALL_RESULTS);
return 0;
}
