int hdmi_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct hdmi_device *hdev = sd_to_hdmi_dev(sd);
struct device *dev = hdev->dev;
int ret = 0;
dev_dbg(dev, "%s start\n", __func__);
switch (ctrl->id) {
case V4L2_CID_TV_SET_DVI_MODE:
hdev->dvi_mode = ctrl->value;
break;
case V4L2_CID_TV_SET_ASPECT_RATIO:
hdev->aspect = ctrl->value;
break;
case V4L2_CID_TV_ENABLE_HDMI_AUDIO:
mutex_lock(&hdev->mutex);
hdev->audio_enable = !!ctrl->value;
if (is_hdmi_streaming(hdev)) {
hdmi_set_infoframe(hdev);
hdmi_audio_enable(hdev, hdev->audio_enable);
}
mutex_unlock(&hdev->mutex);
break;
case V4L2_CID_TV_SET_NUM_CHANNELS:
mutex_lock(&hdev->mutex);
hdmi_audio_information(hdev, ctrl->value);
if (is_hdmi_streaming(hdev)) {
hdmi_audio_enable(hdev, 0);
hdmi_set_infoframe(hdev);
hdmi_reg_i2s_audio_init(hdev);
hdmi_audio_enable(hdev, 1);
}
mutex_unlock(&hdev->mutex);
break;
case V4L2_CID_TV_SET_COLOR_RANGE:
hdev->color_range = ctrl->value;
break;
case V4L2_CID_TV_HDCP_ENABLE:
hdev->hdcp_info.hdcp_enable = ctrl->value;
dev_dbg(hdev->dev, "HDCP %s\n",
ctrl->value ? "enable" : "disable");
#ifdef CONFIG_SEC_MHL_HDCP
hdev->hdcp_info.hdcp_enable = false;
/*MHL8240 control the HDCP*/
dev_dbg(hdev->dev, "MHL control the HDCP\n");
#endif
break;
default:
dev_err(dev, "invalid control id\n");
ret = -EINVAL;
break;
}
return ret;
}
int hdmi_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct hdmi_device *hdev = sd_to_hdmi_dev(sd);
struct device *dev = hdev->dev;
int ret = 0;
dev_dbg(dev, "%s start\n", __func__);
switch (ctrl->id) {
case V4L2_CID_TV_SET_DVI_MODE:
hdev->dvi_mode = ctrl->value;
break;
case V4L2_CID_TV_SET_ASPECT_RATIO:
hdev->aspect = ctrl->value;
break;
case V4L2_CID_TV_ENABLE_HDMI_AUDIO:
mutex_lock(&hdev->mutex);
hdev->audio_enable = !!ctrl->value;
if (is_hdmi_streaming(hdev)) {
hdmi_set_infoframe(hdev);
hdmi_audio_enable(hdev, hdev->audio_enable);
}
mutex_unlock(&hdev->mutex);
break;
case V4L2_CID_TV_SET_NUM_CHANNELS:
mutex_lock(&hdev->mutex);
if ((ctrl->value == 2) || (ctrl->value == 6) ||
(ctrl->value == 8)) {
hdev->audio_channel_count = ctrl->value;
} else {
dev_err(dev, "invalid channel count\n");
hdev->audio_channel_count = 2;
}
if (is_hdmi_streaming(hdev))
hdmi_set_infoframe(hdev);
mutex_unlock(&hdev->mutex);
break;
case V4L2_CID_TV_SET_COLOR_RANGE:
hdev->color_range = ctrl->value;
break;
case V4L2_CID_TV_HDCP_ENABLE:
hdev->hdcp_info.hdcp_enable = ctrl->value;
dev_dbg(hdev->dev, "HDCP %s\n",
ctrl->value ? "enable" : "disable");
break;
default:
dev_err(dev, "invalid control id\n");
ret = -EINVAL;
break;
}
return ret;
}
static int hdmi_streamon(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
int ret;
u32 val0, val1, val2;
dev_dbg(dev, "%s\n", __func__);
/* 3D test */
hdmi_set_infoframe(hdev);
/* set packets for audio */
hdmi_set_packets(hdev);
/* init audio */
#if defined(CONFIG_VIDEO_EXYNOS_HDMI_AUDIO_I2S)
hdmi_reg_i2s_audio_init(hdev);
#elif defined(CONFIG_VIDEO_EXYNOS_HDMI_AUDIO_SPDIF)
hdmi_reg_spdif_audio_init(hdev);
#endif
/* enbale HDMI audio */
if (hdev->audio_enable)
hdmi_audio_enable(hdev, 1);
hdmi_set_dvi_mode(hdev);
/* controls the pixel value limitation */
hdmi_reg_set_limits(hdev);
/* enable HDMI and timing generator */
hdmi_enable(hdev, 1);
hdmi_tg_enable(hdev, 1);
hdev->streaming = HDMI_STREAMING;
/* change the HPD interrupt: External -> Internal */
disable_irq(hdev->ext_irq);
cancel_delayed_work_sync(&hdev->hpd_work_ext);
hdmi_reg_set_int_hpd(hdev);
enable_irq(hdev->int_irq);
dev_info(hdev->dev, "HDMI interrupt changed to internal\n");
/* start HDCP if enabled */
if (hdev->hdcp_info.hdcp_enable) {
ret = hdcp_start(hdev);
if (ret)
return ret;
}
val0 = hdmi_read(hdev, HDMI_ACR_MCTS0);
val1 = hdmi_read(hdev, HDMI_ACR_MCTS1);
val2 = hdmi_read(hdev, HDMI_ACR_MCTS2);
dev_dbg(dev, "HDMI_ACR_MCTS0 : 0x%08x\n", val0);
dev_dbg(dev, "HDMI_ACR_MCTS1 : 0x%08x\n", val1);
dev_dbg(dev, "HDMI_ACR_MCTS2 : 0x%08x\n", val2);
hdmi_dumpregs(hdev, "streamon");
return 0;
}
static int hdmi_streamon(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
int ret;
u32 val0, val1, val2;
dev_dbg(dev, "%s\n", __func__);
/* 3D test */
hdmi_set_infoframe(hdev);
/* set packets for audio */
hdmi_set_packets(hdev);
/* init audio */
#if defined(CONFIG_VIDEO_EXYNOS_HDMI_AUDIO_I2S)
//printk("=============================> HDMI IIS\n");
hdmi_reg_i2s_audio_init(hdev);
#elif defined(CONFIG_VIDEO_EXYNOS_HDMI_AUDIO_SPDIF)
hdmi_reg_spdif_audio_init(hdev);
#endif
/* enbale HDMI audio */
if (hdev->audio_enable)
{
//printk("<+++++++++++++++++++++++++++++++++++++++++++ HDMI ENABLE\n");
hdmi_audio_enable(hdev, 1);
//printk("<+++++++++++++++++++++++++++++++++++++++++++ HDMI ENABLE\n");
}
hdmi_set_dvi_mode(hdev);
/* controls the pixel value limitation */
hdmi_reg_set_limits(hdev);
/* enable HDMI and timing generator */
hdmi_enable(hdev, 1);
hdmi_tg_enable(hdev, 1);
hdmi_reg_set_int_hpd(hdev);
hdev->streaming = HDMI_STREAMING;
// if (edid_supports_hdmi(hdev)) {
#if 1
/* start HDCP if enabled */
if (hdev->hdcp_info.hdcp_enable) {
ret = hdcp_start(hdev);
if (ret)
return ret;
}
#endif
// }
val0 = hdmi_read(hdev, HDMI_ACR_MCTS0);
val1 = hdmi_read(hdev, HDMI_ACR_MCTS1);
val2 = hdmi_read(hdev, HDMI_ACR_MCTS2);
dev_dbg(dev, "HDMI_ACR_MCTS0 : 0x%08x\n", val0);
dev_dbg(dev, "HDMI_ACR_MCTS1 : 0x%08x\n", val1);
dev_dbg(dev, "HDMI_ACR_MCTS2 : 0x%08x\n", val2);
hdmi_dumpregs(hdev, "streamon");
return 0;
}
void egl_server_platform_display(uint32_t win, KHRN_IMAGE_T *image, uint32_t cb_arg)
{
#ifdef DISPLAY_IS_BROKEN
egl_callback(cb_arg);
#else
uint32_t display_width, display_height, display_zoom;
VC_RECT_T dr;
VC_IMAGE_T vc_image;
khrn_image_fill_vcimage(image, &vc_image);
if (vc_image.type == VC_IMAGE_RGBX32) vc_image.type = VC_IMAGE_RGBA32; /* XXX scalerlib can't handle it! */
#ifdef ARTS_AUTOMATION
arts_display_hook(&vc_image);
#endif
#ifdef BLOOM
VC_IMAGE_T *bloom_image;
vc_image.width &= ~63;
vc_image.height &= ~63;
bloom_i = (bloom_i + 1) % 3;
#endif
if (!inited) {
inited = 1;
dispmanx_init();
display = dispmanx_display_open(display_num);
#ifdef BLOOM
vcos_assert(bloom_handle == 0);
bloom_result[0] = vc_image_parmalloc(vc_image.type, "Bloom result", vc_image.width / 4, vc_image.height / 4);
bloom_result[1] = vc_image_parmalloc(vc_image.type, "Bloom result", vc_image.width / 4, vc_image.height / 4);
bloom_result[2] = vc_image_parmalloc(vc_image.type, "Bloom result", vc_image.width / 4, vc_image.height / 4);
bloom_handle = vcbloom_genbloom(bloom_result[0]->type, vc_image.type, 25, /*0,1*/7, 29, 1, 4, 1, 0, 0);
bloom_tmp = malloc(vcbloom_calctmpbuffersize(bloom_handle, bloom_result[0], &vc_image));
vcos_assert(bloom_handle != 0 && bloom_tmp != 0 && bloom_result[0] != 0 && bloom_result[1] != 0 && bloom_result[2] != 0);
#endif
}
#ifdef BLOOM
vc_image_lock(&vc_image, &vc_image);
vclib_obtain_VRF(1);
vcbloom_do(bloom_handle, bloom_result[bloom_i], &vc_image, bloom_tmp);
vclib_release_VRF();
vc_image_unlock(&vc_image);
bloom_image = bloom_result[bloom_i];
#endif
#ifdef ALWAYS_HDMI
frame++;
//hdmi_hotplug_checker(NULL);
if (display_num == 0)
{
#if 0
dispmanx_display_close(display);
vcos_assert(display_num == 0);
display_num = 2;
HDMI_RES_T hdmi_res = {HDMI_RES_GROUP_DMT, /*HDMI_DMT_SWXGAP_60*//*HDMI_DMT_SWXGAP_RB*/HDMI_DMT_UXGA_60};
hdmi_hotplug_checker(NULL);
//_vasm("bkpt");
hdmi_power_on(HDMI_MODE_DVI/*HDMI*/, hdmi_res, display_num);
vcos_sleep(1000);
#endif
HDMI_RES_T best_res = {HDMI_RES_GROUP_DMT, HDMI_DMT_SWXGAP_60/*HDMI_DMT_SWXGAP_RB*/};
HDMI_MODE_T mode = HDMI_MODE_HDMI;
if (1/*hdmi_get_mode() != VC_HDMI_UNPLUGGED*/)
{
int32_t hdmi_support;
//int result = hdmi_supported_modes(&mode, &preferred_res, cea_modes, dmt_modes);
//assert(result == 0);
get_hdmi_best_mode(&mode, &hdmi_support, &best_res.group, &best_res.mode);
#ifdef HDMI_14_3D
best_res.group = HDMI_RES_GROUP_CEA;
best_res.mode = HDMI_CEA_1080p60;
#endif
dispmanx_display_close(display);
uint32_t frame_rate, interlaced;
hdmi_get_screen_size(best_res, &hdmi_width, &hdmi_height, &frame_rate, &interlaced);
hdmi_power_on(mode, best_res, 2);
vcos_sleep(100);
display_num = 2;
while ((display = dispmanx_display_open(display_num)) == 0)
{
vcos_sleep(1000);
_vasm("bkpt");
}
#ifdef HDMI_14_3D
{
/* Set the info frame to enable 3D using half-height, full-width packed signals */
//uint8_t info_frame[HDMI_NUM_PACKET_BYTES] = {0x00, 0x03, 0x0c, 0x00, 0x40, 0x60, };
/* Set the info frame to enable 3D using full-height, half-width packed signals */
uint8_t info_frame[HDMI_NUM_PACKET_BYTES] = {0x00, 0x03, 0x0c, 0x00, 0x40, 0x80, 0x00, };
hdmi_set_infoframe(HDMI_INFOFRAME_VS, info_frame, /*5*/ 6);
}
#endif
}
}
else
{
if (0/*hdmi_get_mode() == VC_HDMI_UNPLUGGED*/)
{
dispmanx_display_close(display);
display_num = 0;
display = dispmanx_display_open(display_num);
}
}
#endif
#ifdef PRESSING_E_PUTS_IT_ON_HDMI
if (game_button_pressed(GAME_KEY_E))
{
dispmanx_display_close(display);
display_num ^= 2;
display = dispmanx_display_open(display_num);
}
#endif
#ifdef __VIDEOCORE4__
if (display_num)
{
display_width = hdmi_width;
display_height = hdmi_height;
display_zoom = 1;
}
else
{
display_width = 800;
display_height = 480;
display_zoom = 0;
}
#else
display_width = display_num ? 1280 : 800;
display_height = display_num ? 720 : 480;
display_zoom = display_num ? 1 : 0;
#endif
DISPMANX_UPDATE_HANDLE_T update = dispmanx_update_start(0);
remove_element(update, win);
if (display) {
uint32_t w,h;
DISPMANX_ALPHA_T alpha = {DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS, 255, 0};
w = vc_image.width;
h = vc_image.height;
#ifdef KHRN_SIMPLE_MULTISAMPLE
w /= 2;
h /= 2;
#endif
if (display_zoom)
{
float zoom0 = (float)display_width / (float)w;
float zoom1 = (float)display_height / (float)h;
if (zoom0 < zoom1)
{
w = (int)(w * zoom0);
h = (int)(h * zoom0);
}
else
{
w = (int)(w * zoom1);
h = (int)(h * zoom1);
}
}
dr.x = ((display_width - (UNPACK_NATIVE_WINDOW_N(win) * w)) >> 1) + (UNPACK_NATIVE_WINDOW_I(win) * w);
dr.width = w;
//VC_RECT_T sr = {0, 0, image->width<<8, image->height<<8};
if (h > display_height) {
dr.y = 0;
dr.height = display_height;
} else {
dr.y = display_height - h >> 1;
dr.height = h;
}
#ifdef BLOOM
add_element(dispmanx_element_add(update, display, 0, &dr, &vc_image, 0, DISPMANX_PROTECTION_NONE, &alpha, 0/*clamp*/,
flip_it(&vc_image) ? DISPMANX_FLIP_VERT : DISPMANX_NO_ROTATE), win);
if (bloom_amount)
{
alpha.opacity = bloom_amount;
add_element(dispmanx_element_add(update, display, 0, &dr, bloom_image, 0, DISPMANX_PROTECTION_NONE, &alpha, 0/*clamp*/,
DISPMANX_NO_ROTATE), win);
}
#else
add_element(dispmanx_element_add(update, display, 0, &dr, &vc_image, 0, DISPMANX_PROTECTION_NONE, &alpha, 0/*clamp*/,
flip_it(&vc_image) ? DISPMANX_FLIP_VERT : DISPMANX_NO_ROTATE), win);
#endif
}
dispmanx_update_submit(update, our_callback, (void *)cb_arg);
#endif
}
static int nxp_hdmi_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct nxp_hdmi_context *ctx;
struct nxp_hdmi *me = subdev_to_nxp_hdmi(sd);
ctx = &me->ctx;
pr_debug("%s\n", __func__);
switch (ctrl->id) {
case V4L2_CID_HDMI_SET_DVI_MODE:
mutex_lock(&ctx->mutex);
ctx->is_dvi = !!ctrl->value;
mutex_unlock(&ctx->mutex);
break;
case V4L2_CID_HDMI_SET_ASPECT_RATIO:
mutex_lock(&ctx->mutex);
ctx->aspect = ctrl->value;
mutex_unlock(&ctx->mutex);
break;
case V4L2_CID_HDMI_ENABLE_HDMI_AUDIO:
mutex_lock(&ctx->mutex);
hdmi_enable_audio(ctx, !!ctrl->value);
mutex_unlock(&ctx->mutex);
break;
case V4L2_CID_HDMI_SET_NUM_CHANNELS:
mutex_lock(&ctx->mutex);
if ((ctrl->value == 2) || (ctrl->value == 6) ||
(ctrl->value == 8)) {
ctx->audio_channel_count = ctrl->value;
} else {
pr_err("%s: invalid channel count(%d)\n", __func__, ctrl->value);
}
hdmi_set_infoframe(ctx);
mutex_unlock(&ctx->mutex);
break;
case V4L2_CID_HDMI_SET_COLOR_RANGE:
mutex_lock(&ctx->mutex);
ctx->color_range = ctrl->value;
mutex_unlock(&ctx->mutex);
break;
case V4L2_CID_HDMI_ON_OFF:
printk("%s: V4L2_CID_HDMI_ON_OFF val %d\n", __func__, ctrl->value);
if (ctrl->value > 0) {
u32 regval = NX_HDMI_GetReg(0, HDMI_LINK_HDMI_CON_0);
regval |= 0x01;
NX_HDMI_SetReg(0, HDMI_LINK_HDMI_CON_0, regval);
} else {
u32 regval = NX_HDMI_GetReg(0, HDMI_LINK_HDMI_CON_0);
regval &= ~0x01;
NX_HDMI_SetReg(0, HDMI_LINK_HDMI_CON_0, regval);
}
break;
default:
pr_err("%s: invalid control id(0x%x)\n", __func__, ctrl->id);
return -EINVAL;
}
return 0;
}
static int hdmi_streamon(struct hdmi_device *hdev)
{
struct device *dev = hdev->dev;
struct hdmi_resources *res = &hdev->res;
int ret, tries;
u32 val0, val1, val2;
dev_dbg(dev, "%s\n", __func__);
hdev->streaming = 1;
ret = v4l2_subdev_call(hdev->phy_sd, video, s_stream, 1);
if (ret)
return ret;
/* waiting for HDMIPHY's PLL to get to steady state */
for (tries = 100; tries; --tries) {
if (is_hdmiphy_ready(hdev))
break;
mdelay(1);
}
/* steady state not achieved */
if (tries == 0) {
dev_err(dev, "hdmiphy's pll could not reach steady state.\n");
v4l2_subdev_call(hdev->phy_sd, video, s_stream, 0);
hdmi_dumpregs(hdev, "s_stream");
return -EIO;
}
/* hdmiphy clock is used for HDMI in streaming mode */
clk_disable(res->sclk_hdmi);
clk_set_parent(res->sclk_hdmi, res->sclk_hdmiphy);
clk_enable(res->sclk_hdmi);
/* 3D test */
hdmi_set_infoframe(hdev);
/* set packets for audio */
hdmi_set_packets(hdev);
/* init audio */
#if defined(CONFIG_VIDEO_EXYNOS_HDMI_AUDIO_I2S)
hdmi_reg_i2s_audio_init(hdev);
#elif defined(CONFIG_VIDEO_EXYNOS_HDMI_AUDIO_SPDIF)
hdmi_reg_spdif_audio_init(hdev);
#endif
/* enbale HDMI audio */
if (hdev->audio_enable)
hdmi_audio_enable(hdev, 1);
hdmi_set_dvi_mode(hdev);
/* enable HDMI and timing generator */
hdmi_enable(hdev, 1);
hdmi_tg_enable(hdev, 1);
mdelay(5);
val0 = hdmi_read(hdev, HDMI_ACR_MCTS0);
val1 = hdmi_read(hdev, HDMI_ACR_MCTS1);
val2 = hdmi_read(hdev, HDMI_ACR_MCTS2);
dev_dbg(dev, "HDMI_ACR_MCTS0 : 0x%08x\n", val0);
dev_dbg(dev, "HDMI_ACR_MCTS1 : 0x%08x\n", val1);
dev_dbg(dev, "HDMI_ACR_MCTS2 : 0x%08x\n", val2);
/* start HDCP if enabled */
if (hdev->hdcp_info.hdcp_enable) {
ret = hdcp_start(hdev);
if (ret)
return ret;
}
hdmi_dumpregs(hdev, "streamon");
return 0;
}
