diff options
28 files changed, 1115 insertions, 257 deletions
diff --git a/arch/arm/boot/dts/qcom/apq8098-v2.1-mediabox.dts b/arch/arm/boot/dts/qcom/apq8098-v2.1-mediabox.dts index 1fa49d8a060d..74edd4e9ac0f 100644 --- a/arch/arm/boot/dts/qcom/apq8098-v2.1-mediabox.dts +++ b/arch/arm/boot/dts/qcom/apq8098-v2.1-mediabox.dts @@ -1,4 +1,4 @@ -/* Copyright (c) 2016-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2016-2017,2019 The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -38,6 +38,12 @@ qcom,display-type = "primary"; }; +&mdss_fb2 { + qcom,cont-splash-memory { + linux,contiguous-region = <&cont_splash_mem>; + }; +}; + &slim_aud { tasha_codec { wsa_spkr_sd1: msm_cdc_pinctrll { diff --git a/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c b/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c index 1af55fe257af..9d83bf2a4ad4 100644 --- a/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c +++ b/drivers/media/platform/msm/camera_v2/isp/msm_isp_axi_util.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2019, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -879,6 +879,9 @@ static void msm_isp_sync_dual_cam_frame_id( ms_res->src_info[i]->dual_hw_ms_info.index); } } + /* the number of frames that are dropped */ + vfe_dev->isp_page->dual_cam_drop = + frame_id - (src_info->frame_id + 1); ms_res->active_src_mask |= (1 << src_info->dual_hw_ms_info.index); src_info->frame_id = frame_id; src_info->dual_hw_ms_info.sync_state = MSM_ISP_DUAL_CAM_SYNC; @@ -916,6 +919,8 @@ void msm_isp_increment_frame_id(struct vfe_device *vfe_dev, src_info->dual_hw_ms_info.index)) { pr_err_ratelimited("Frame out of sync on vfe %d\n", vfe_dev->pdev->id); + /* Notify to do reconfig at SW sync drop*/ + vfe_dev->isp_page->dual_cam_drop_detected = 1; /* * set this isp as async mode to force *it sync again at the next sof @@ -2258,8 +2263,8 @@ static int msm_isp_process_done_buf(struct vfe_device *vfe_dev, MSM_ISP_BUFFER_STATE_PUT_BUF; buf->buf_debug.put_state_last ^= 1; rc = vfe_dev->buf_mgr->ops->buf_done(vfe_dev->buf_mgr, - buf->bufq_handle, buf->buf_idx, time_stamp, - frame_id, stream_info->runtime_output_format); + buf->bufq_handle, buf->buf_idx, time_stamp, + frame_id, stream_info->runtime_output_format); if (rc == -EFAULT) { msm_isp_halt_send_error(vfe_dev, ISP_EVENT_BUF_FATAL_ERROR); diff --git a/drivers/misc/hdcp.c b/drivers/misc/hdcp.c index cc11ede6a456..ea81ccda4ee5 100644 --- a/drivers/misc/hdcp.c +++ b/drivers/misc/hdcp.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -2085,7 +2085,8 @@ static void hdcp_lib_clean(struct hdcp_lib_handle *handle) handle->authenticated = false; /* AV mute the sink first to avoid artifacts */ - handle->client_ops->mute_sink(handle->client_ctx); + if (handle->client_ops->mute_sink) + handle->client_ops->mute_sink(handle->client_ctx); hdcp_lib_txmtr_deinit(handle); if (!handle->legacy_app) @@ -2332,19 +2333,20 @@ bool hdcp1_check_if_supported_load_app(void) /* start hdcp1 app */ if (hdcp1_supported && !hdcp1_handle->qsee_handle) { + mutex_init(&hdcp1_ta_cmd_lock); rc = qseecom_start_app(&hdcp1_handle->qsee_handle, HDCP1_APP_NAME, QSEECOM_SBUFF_SIZE); if (rc) { pr_err("hdcp1 qseecom_start_app failed %d\n", rc); hdcp1_supported = false; + hdcp1_srm_supported = false; kfree(hdcp1_handle); } } /* if hdcp1 app succeeds load SRM TA as well */ if (hdcp1_supported && !hdcp1_handle->srm_handle) { - mutex_init(&hdcp1_ta_cmd_lock); rc = qseecom_start_app(&hdcp1_handle->srm_handle, SRMAPP_NAME, QSEECOM_SBUFF_SIZE); @@ -2395,13 +2397,19 @@ int hdcp1_set_keys(uint32_t *aksv_msb, uint32_t *aksv_lsb) if (aksv_msb == NULL || aksv_lsb == NULL) return -EINVAL; - if (!hdcp1_supported || !hdcp1_handle) - return -EINVAL; + mutex_lock(&hdcp1_ta_cmd_lock); + + if (!hdcp1_supported || !hdcp1_handle) { + rc = -EINVAL; + goto end; + } hdcp1_qsee_handle = hdcp1_handle->qsee_handle; - if (!hdcp1_qsee_handle) - return -EINVAL; + if (!hdcp1_qsee_handle) { + rc = -EINVAL; + goto end; + } /* set keys and request aksv */ key_set_req = (struct hdcp1_key_set_req *)hdcp1_qsee_handle->sbuf; @@ -2417,13 +2425,15 @@ int hdcp1_set_keys(uint32_t *aksv_msb, uint32_t *aksv_lsb) if (rc < 0) { pr_err("qseecom cmd failed err=%d\n", rc); - return -ENOKEY; + rc = -ENOKEY; + goto end; } rc = key_set_rsp->ret; if (rc) { pr_err("set key cmd failed, rsp=%d\n", key_set_rsp->ret); - return -ENOKEY; + rc = -ENOKEY; + goto end; } /* copy bytes into msb and lsb */ @@ -2436,7 +2446,9 @@ int hdcp1_set_keys(uint32_t *aksv_msb, uint32_t *aksv_lsb) *aksv_lsb |= key_set_rsp->ksv[6] << 8; *aksv_lsb |= key_set_rsp->ksv[7]; - return 0; +end: + mutex_unlock(&hdcp1_ta_cmd_lock); + return rc; } int hdcp1_validate_receiver_ids(struct hdcp_srm_device_id_t *device_ids, @@ -2576,8 +2588,10 @@ int hdcp1_set_enc(bool enable) hdcp1_qsee_handle = hdcp1_handle->qsee_handle; - if (!hdcp1_qsee_handle) - return -EINVAL; + if (!hdcp1_qsee_handle) { + rc = -EINVAL; + goto end; + } if (hdcp1_enc_enabled == enable) { pr_info("already %s\n", enable ? "enabled" : "disabled"); diff --git a/drivers/video/fbdev/msm/mdss_cec_core.c b/drivers/video/fbdev/msm/mdss_cec_core.c index 1d9950494d65..ab7a8056016a 100644 --- a/drivers/video/fbdev/msm/mdss_cec_core.c +++ b/drivers/video/fbdev/msm/mdss_cec_core.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2017, 2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -594,6 +594,41 @@ end: return ret; } +static ssize_t cec_wta_clear_logical_addr(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + int clear_flag; + unsigned long flags; + ssize_t ret; + struct cec_ctl *ctl = cec_get_ctl(dev); + struct cec_ops *ops; + + if (!ctl) { + pr_err("Invalid ctl\n"); + ret = -EINVAL; + goto end; + } + + ops = ctl->init_data.ops; + + ret = kstrtoint(buf, 10, &clear_flag); + if (ret) { + pr_err("kstrtoint failed\n"); + goto end; + } + + ret = count; + + spin_lock_irqsave(&ctl->lock, flags); + if (ctl->enabled) { + if (ops && ops->clear_logical_addr) + ops->clear_logical_addr(ops->data, !!clear_flag); + } + spin_unlock_irqrestore(&ctl->lock, flags); +end: + return ret; +} + static ssize_t cec_rda_msg(struct device *dev, struct device_attribute *attr, char *buf) { @@ -703,6 +738,8 @@ static DEVICE_ATTR(enable_compliance, S_IRUGO | S_IWUSR, cec_rda_enable_compliance, cec_wta_enable_compliance); static DEVICE_ATTR(logical_addr, S_IRUSR | S_IWUSR, cec_rda_logical_addr, cec_wta_logical_addr); +static DEVICE_ATTR(clear_logical_addr, 0200, + NULL, cec_wta_clear_logical_addr); static DEVICE_ATTR(rd_msg, S_IRUGO, cec_rda_msg, NULL); static DEVICE_ATTR(wr_msg, S_IWUSR | S_IRUSR, NULL, cec_wta_msg); @@ -710,6 +747,7 @@ static struct attribute *cec_fs_attrs[] = { &dev_attr_enable.attr, &dev_attr_enable_compliance.attr, &dev_attr_logical_addr.attr, + &dev_attr_clear_logical_addr.attr, &dev_attr_rd_msg.attr, &dev_attr_wr_msg.attr, NULL, diff --git a/drivers/video/fbdev/msm/mdss_cec_core.h b/drivers/video/fbdev/msm/mdss_cec_core.h index 12b7677c5dee..481884a732d8 100644 --- a/drivers/video/fbdev/msm/mdss_cec_core.h +++ b/drivers/video/fbdev/msm/mdss_cec_core.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2016, 2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -67,6 +67,7 @@ struct cec_ops { int (*send_msg)(void *data, struct cec_msg *msg); void (*wt_logical_addr)(void *data, u8 addr); + void (*clear_logical_addr)(void *data, bool flag); void (*wakeup_en)(void *data, bool en); bool (*is_wakeup_en)(void *data); void (*device_suspend)(void *data, bool suspend); diff --git a/drivers/video/fbdev/msm/mdss_fb.c b/drivers/video/fbdev/msm/mdss_fb.c index f56e50d516cd..31f4ef83b8b3 100644 --- a/drivers/video/fbdev/msm/mdss_fb.c +++ b/drivers/video/fbdev/msm/mdss_fb.c @@ -1,7 +1,7 @@ /* * Core MDSS framebuffer driver. * - * Copyright (c) 2008-2019, The Linux Foundation. All rights reserved. + * Copyright (c) 2008-2020, The Linux Foundation. All rights reserved. * Copyright (C) 2007 Google Incorporated * * This software is licensed under the terms of the GNU General Public @@ -3507,16 +3507,19 @@ static int mdss_fb_pan_display(struct fb_var_screeninfo *var, { struct mdp_display_commit disp_commit; struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)info->par; + struct mdss_data_type *mdata = mfd_to_mdata(mfd); /* - * during mode switch through mode sysfs node, it will trigger a - * pan_display after switch. This assumes that fb has been adjusted, - * however when using overlays we may not have the right size at this - * point, so it needs to go through PREPARE first. Abort pan_display - * operations until that happens + * Abort pan_display operations in following cases: + * 1. during mode switch through mode sysfs node, it will trigger a + * pan_display after switch. This assumes that fb has been adjusted, + * however when using overlays we may not have the right size at this + * point, so it needs to go through PREPARE first. + * 2. When the splash handoff is pending. */ - if (mfd->switch_state != MDSS_MDP_NO_UPDATE_REQUESTED) { - pr_debug("fb%d: pan_display skipped during switch\n", + if ((mfd->switch_state != MDSS_MDP_NO_UPDATE_REQUESTED) || + (mdss_fb_is_hdmi_primary(mfd) && mdata->handoff_pending)) { + pr_debug("fb%d: pan_display skipped during switch or handoff\n", mfd->index); return 0; } @@ -4072,17 +4075,23 @@ static int mdss_fb_set_par(struct fb_info *info) mfd->fbi->fix.smem_len = PAGE_ALIGN(mfd->fbi->fix.line_length * mfd->fbi->var.yres) * mfd->fb_page; - old_format = mdss_grayscale_to_mdp_format(var->grayscale); - if (!IS_ERR_VALUE(old_format)) { + old_format = mfd->panel_info->out_format; + mfd->panel_info->out_format = + mdss_grayscale_to_mdp_format(var->grayscale); + if (!IS_ERR_VALUE(mfd->panel_info->out_format)) { if (old_format != mfd->panel_info->out_format) mfd->panel_reconfig = true; } + if (mdss_fb_is_hdmi_primary(mfd) && mfd->panel_reconfig) + mfd->force_null_commit = true; + if (mfd->panel_reconfig || (mfd->fb_imgType != old_imgType)) { mdss_fb_blank_sub(FB_BLANK_POWERDOWN, info, mfd->op_enable); mdss_fb_var_to_panelinfo(var, mfd->panel_info); mdss_fb_blank_sub(FB_BLANK_UNBLANK, info, mfd->op_enable); mfd->panel_reconfig = false; + mfd->force_null_commit = false; } return ret; diff --git a/drivers/video/fbdev/msm/mdss_fb.h b/drivers/video/fbdev/msm/mdss_fb.h index 301c1386a639..4d2888246b7c 100644 --- a/drivers/video/fbdev/msm/mdss_fb.h +++ b/drivers/video/fbdev/msm/mdss_fb.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2008-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2008-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -292,6 +292,7 @@ struct msm_fb_data_type { int op_enable; u32 fb_imgType; int panel_reconfig; + int force_null_commit; u32 panel_orientation; u32 dst_format; diff --git a/drivers/video/fbdev/msm/mdss_hdcp_1x.c b/drivers/video/fbdev/msm/mdss_hdcp_1x.c index 8df9080129b9..0b394ea270cd 100644 --- a/drivers/video/fbdev/msm/mdss_hdcp_1x.c +++ b/drivers/video/fbdev/msm/mdss_hdcp_1x.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -1348,16 +1348,16 @@ static int hdcp_1x_authentication_part2(struct hdcp_1x *hdcp) } do { - rc = hdcp_1x_transfer_v_h(hdcp); - if (rc) - goto error; - /* do not proceed further if no device connected */ if (!hdcp->current_tp.dev_count) { rc = -EINVAL; goto error; } + rc = hdcp_1x_transfer_v_h(hdcp); + if (rc) + goto error; + rc = hdcp_1x_write_ksv_fifo(hdcp); } while (--v_retry && rc); error: diff --git a/drivers/video/fbdev/msm/mdss_hdmi_cec.c b/drivers/video/fbdev/msm/mdss_hdmi_cec.c index a4ed01210e04..3eda29edff4d 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_cec.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_cec.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2017, 2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -17,6 +17,7 @@ #include <linux/slab.h> #include <linux/device.h> #include <linux/input.h> +#include <linux/circ_buf.h> #include "mdss_hdmi_cec.h" #include "mdss_panel.h" @@ -33,12 +34,19 @@ #define CEC_OP_KEY_PRESS 0x44 #define CEC_OP_STANDBY 0x36 +#define CEC_RECV_Q_SIZE 4 +#define CEC_RECV_Q_MASK 3 + struct hdmi_cec_ctrl { bool cec_enabled; bool cec_wakeup_en; bool cec_device_suspend; - + bool cec_clear_logical_addr; + u32 cec_logical_addr; u32 cec_msg_wr_status; + struct cec_msg recv_msg[CEC_RECV_Q_SIZE]; + u32 head; + u32 tail; spinlock_t lock; struct work_struct cec_read_work; struct completion cec_msg_wr_done; @@ -60,6 +68,20 @@ static int hdmi_cec_msg_send(void *data, struct cec_msg *msg) return -EINVAL; } + if (msg->sender_id != cec_ctrl->cec_logical_addr && + msg->recvr_id == 0xF) { + /* + * If the current logical address is not the + * same as the sender_id and if the message is + * broadcasting, the message is looping back. + * Abort the message sending in that case + */ + DEV_ERR("%s: abort potential MAL msg %d:%d logical %d\n", + __func__, msg->sender_id, msg->recvr_id, + cec_ctrl->cec_logical_addr); + return -EINVAL; + } + io = cec_ctrl->init_data.io; reinit_completion(&cec_ctrl->cec_msg_wr_done); @@ -164,88 +186,130 @@ static void hdmi_cec_deinit_input_event(struct hdmi_cec_ctrl *cec_ctrl) cec_ctrl->input = NULL; } -static void hdmi_cec_msg_recv(struct work_struct *work) +static int hdmi_cec_msg_read(struct hdmi_cec_ctrl *cec_ctrl) { - int i; - u32 data; - struct hdmi_cec_ctrl *cec_ctrl = NULL; struct dss_io_data *io = NULL; - struct cec_msg msg; - struct cec_cbs *cbs; + struct cec_msg *msg; + u32 data; + int i; + u32 head; + u32 tail; - cec_ctrl = container_of(work, struct hdmi_cec_ctrl, cec_read_work); if (!cec_ctrl || !cec_ctrl->init_data.io) { DEV_ERR("%s: invalid input\n", __func__); - return; + return -EINVAL; } if (!cec_ctrl->cec_enabled) { DEV_ERR("%s: cec not enabled\n", __func__); - return; + return -ENODEV; } - io = cec_ctrl->init_data.io; - cbs = cec_ctrl->init_data.cbs; + head = cec_ctrl->head; + tail = READ_ONCE(cec_ctrl->tail); + if (CIRC_SPACE(head, tail, CEC_RECV_Q_SIZE) < 1) { + DEV_ERR("%s: no more space to hold the buffer\n", __func__); + return 0; /* Let's just kick the thread */ + } - data = DSS_REG_R(io, HDMI_CEC_RD_DATA); + msg = &cec_ctrl->recv_msg[head]; - msg.recvr_id = (data & 0x000F); - msg.sender_id = (data & 0x00F0) >> 4; - msg.frame_size = (data & 0x1F00) >> 8; - DEV_DBG("%s: Recvd init=[%u] dest=[%u] size=[%u]\n", __func__, - msg.sender_id, msg.recvr_id, - msg.frame_size); + io = cec_ctrl->init_data.io; + data = DSS_REG_R(io, HDMI_CEC_RD_DATA); - if (msg.frame_size < 1 || msg.frame_size > MAX_CEC_FRAME_SIZE) { + msg->recvr_id = (data & 0x000F); + msg->sender_id = (data & 0x00F0) >> 4; + msg->frame_size = (data & 0x1F00) >> 8; + if (msg->frame_size < 1 || msg->frame_size > MAX_CEC_FRAME_SIZE) { DEV_ERR("%s: invalid message (frame length = %d)\n", - __func__, msg.frame_size); - return; - } else if (msg.frame_size == 1) { + __func__, msg->frame_size); + return -EINVAL; + } else if (msg->frame_size == 1) { DEV_DBG("%s: polling message (dest[%x] <- init[%x])\n", - __func__, msg.recvr_id, msg.sender_id); - return; + __func__, msg->recvr_id, msg->sender_id); + return -EINVAL; } /* data block 0 : opcode */ data = DSS_REG_R_ND(io, HDMI_CEC_RD_DATA); - msg.opcode = data & 0xFF; + msg->opcode = data & 0xFF; /* data block 1-14 : operand 0-13 */ - for (i = 0; i < msg.frame_size - 2; i++) { + for (i = 0; i < msg->frame_size - 2; i++) { data = DSS_REG_R_ND(io, HDMI_CEC_RD_DATA); - msg.operand[i] = data & 0xFF; + msg->operand[i] = data & 0xFF; } for (; i < MAX_OPERAND_SIZE; i++) - msg.operand[i] = 0; + msg->operand[i] = 0; + + /* + * Clearing the logical address is used when the system doesn't + * need to process CEC command any more. + */ + if (cec_ctrl->cec_clear_logical_addr) + return -EINVAL; + + /* Update head */ + smp_store_release(&cec_ctrl->head, (head + 1) & CEC_RECV_Q_MASK); DEV_DBG("%s: opcode 0x%x, wakup_en %d, device_suspend %d\n", __func__, - msg.opcode, cec_ctrl->cec_wakeup_en, + msg->opcode, cec_ctrl->cec_wakeup_en, cec_ctrl->cec_device_suspend); - if ((msg.opcode == CEC_OP_SET_STREAM_PATH || - msg.opcode == CEC_OP_KEY_PRESS) && - cec_ctrl->input && cec_ctrl->cec_wakeup_en && - cec_ctrl->cec_device_suspend) { - DEV_DBG("%s: Sending power on at wakeup\n", __func__); - input_report_key(cec_ctrl->input, KEY_POWER, 1); - input_sync(cec_ctrl->input); - input_report_key(cec_ctrl->input, KEY_POWER, 0); - input_sync(cec_ctrl->input); - } - - if ((msg.opcode == CEC_OP_STANDBY) && - cec_ctrl->input && cec_ctrl->cec_wakeup_en && - !cec_ctrl->cec_device_suspend) { - DEV_DBG("%s: Sending power off on standby\n", __func__); - input_report_key(cec_ctrl->input, KEY_POWER, 1); - input_sync(cec_ctrl->input); - input_report_key(cec_ctrl->input, KEY_POWER, 0); - input_sync(cec_ctrl->input); - } - - if (cbs && cbs->msg_recv_notify) - cbs->msg_recv_notify(cbs->data, &msg); + return 0; +} + +static void hdmi_cec_msg_recv(struct work_struct *work) +{ + struct hdmi_cec_ctrl *cec_ctrl = NULL; + struct cec_msg msg; + struct cec_cbs *cbs; + u32 head; + u32 tail; + + cec_ctrl = container_of(work, struct hdmi_cec_ctrl, cec_read_work); + if (!cec_ctrl || !cec_ctrl->init_data.io) { + DEV_ERR("%s: invalid input\n", __func__); + return; + } + + cbs = cec_ctrl->init_data.cbs; + + /* Read head before reading contents */ + head = smp_load_acquire(&cec_ctrl->head); + tail = cec_ctrl->tail; + while (CIRC_CNT(head, tail, CEC_RECV_Q_SIZE) >= 1) { + memcpy(&msg, &cec_ctrl->recv_msg[tail], sizeof(msg)); + tail = (tail + 1) & CEC_RECV_Q_MASK; + + /* Finishing reading before incrementing tail */ + smp_store_release(&cec_ctrl->tail, tail); + + if ((msg.opcode == CEC_OP_SET_STREAM_PATH || + msg.opcode == CEC_OP_KEY_PRESS) && + cec_ctrl->input && cec_ctrl->cec_wakeup_en && + cec_ctrl->cec_device_suspend) { + DEV_DBG("%s: Sending power on at wakeup\n", __func__); + input_report_key(cec_ctrl->input, KEY_POWER, 1); + input_sync(cec_ctrl->input); + input_report_key(cec_ctrl->input, KEY_POWER, 0); + input_sync(cec_ctrl->input); + } + + if ((msg.opcode == CEC_OP_STANDBY) && + cec_ctrl->input && cec_ctrl->cec_wakeup_en && + !cec_ctrl->cec_device_suspend) { + DEV_DBG("%s: Sending power off on standby\n", __func__); + input_report_key(cec_ctrl->input, KEY_POWER, 1); + input_sync(cec_ctrl->input); + input_report_key(cec_ctrl->input, KEY_POWER, 0); + input_sync(cec_ctrl->input); + } + + if (cbs && cbs->msg_recv_notify) + cbs->msg_recv_notify(cbs->data, &msg); + } } /** @@ -308,8 +372,12 @@ int hdmi_cec_isr(void *input) if ((cec_intr & BIT(6)) && (cec_intr & BIT(7))) { DEV_DBG("%s: CEC_IRQ_FRAME_RD_DONE\n", __func__); + rc = hdmi_cec_msg_read(cec_ctrl); + if (!rc) + queue_work(cec_ctrl->init_data.workq, + &cec_ctrl->cec_read_work); + DSS_REG_W(io, HDMI_CEC_INT, cec_intr | BIT(6)); - queue_work(cec_ctrl->init_data.workq, &cec_ctrl->cec_read_work); } return rc; @@ -360,8 +428,23 @@ static void hdmi_cec_write_logical_addr(void *input, u8 addr) return; } - if (cec_ctrl->cec_enabled) + if (cec_ctrl->cec_enabled) { DSS_REG_W(cec_ctrl->init_data.io, HDMI_CEC_ADDR, addr & 0xF); + cec_ctrl->cec_logical_addr = addr & 0xF; + } +} + +static void hdmi_cec_clear_logical_addr(void *input, bool clear_flag) +{ + struct hdmi_cec_ctrl *cec_ctrl = (struct hdmi_cec_ctrl *)input; + + if (!cec_ctrl || !cec_ctrl->init_data.io) { + DEV_ERR("%s: Invalid input\n", __func__); + return; + } + + if (cec_ctrl->cec_enabled) + cec_ctrl->cec_clear_logical_addr = clear_flag; } static int hdmi_cec_enable(void *input, bool enable) @@ -474,6 +557,7 @@ void *hdmi_cec_init(struct hdmi_cec_init_data *init_data) /* populate hardware specific operations to client */ ops->send_msg = hdmi_cec_msg_send; ops->wt_logical_addr = hdmi_cec_write_logical_addr; + ops->clear_logical_addr = hdmi_cec_clear_logical_addr; ops->enable = hdmi_cec_enable; ops->data = cec_ctrl; ops->wakeup_en = hdmi_cec_wakeup_en; diff --git a/drivers/video/fbdev/msm/mdss_hdmi_edid.c b/drivers/video/fbdev/msm/mdss_hdmi_edid.c index 0c04fd35c0d5..cb4ef1781dfb 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_edid.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_edid.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -51,6 +51,9 @@ /* Support for first 5 EDID blocks */ #define MAX_EDID_SIZE (EDID_BLOCK_SIZE * MAX_EDID_BLOCKS) +/* Max refresh rate supported in Hz */ +#define MAX_REFRESH_RATE_SUPPORTED 60 + #define BUFF_SIZE_3D 128 #define DTD_MAX 0x04 @@ -89,6 +92,7 @@ enum extended_data_block_types { VIDEO_CAPABILITY_DATA_BLOCK = 0x0, VENDOR_SPECIFIC_VIDEO_DATA_BLOCK = 0x01, HDMI_VIDEO_DATA_BLOCK = 0x04, + COLORIMETRY_DATA_BLOCK = 0x05, HDR_STATIC_METADATA_DATA_BLOCK = 0x06, Y420_VIDEO_DATA_BLOCK = 0x0E, VIDEO_FORMAT_PREFERENCE_DATA_BLOCK = 0x0D, @@ -122,6 +126,16 @@ struct hdmi_edid_sink_caps { bool ind_view_support; }; +struct hdmi_edid_y420_cmdb { + u8 *vic_list; + u32 len; +}; + +struct hdmi_edid_colorimetry { + u8 standards; + u8 metadata_profiles; +}; + struct hdmi_edid_ctrl { u8 pt_scan_info; u8 it_scan_info; @@ -147,12 +161,18 @@ struct hdmi_edid_ctrl { bool keep_resv_timings; bool edid_override; bool hdr_supported; + bool override_default_vic; + + bool y420_cmdb_present; + bool y420_cmdb_supports_all; + struct hdmi_edid_y420_cmdb y420_cmdb; struct hdmi_edid_sink_data sink_data; struct hdmi_edid_init_data init_data; struct hdmi_edid_sink_caps sink_caps; struct hdmi_edid_override_data override_data; struct hdmi_edid_hdr_data hdr_data; + struct hdmi_edid_colorimetry colorimetry; }; static bool hdmi_edid_is_mode_supported(struct hdmi_edid_ctrl *edid_ctrl, @@ -187,6 +207,9 @@ static int hdmi_edid_reset_parser(struct hdmi_edid_ctrl *edid_ctrl) edid_ctrl->sink_data.num_of_elements = 0; + /* reset deep color */ + edid_ctrl->deep_color = 0; + /* reset scan info data */ edid_ctrl->pt_scan_info = 0; edid_ctrl->it_scan_info = 0; @@ -200,6 +223,7 @@ static int hdmi_edid_reset_parser(struct hdmi_edid_ctrl *edid_ctrl) /* reset resolution related sink data */ memset(&edid_ctrl->sink_data, 0, sizeof(edid_ctrl->sink_data)); + memset(&edid_ctrl->sink_caps, 0, sizeof(edid_ctrl->sink_caps)); /* reset audio related data */ memset(edid_ctrl->audio_data_block, 0, @@ -224,6 +248,10 @@ static int hdmi_edid_reset_parser(struct hdmi_edid_ctrl *edid_ctrl) edid_ctrl->hdr_data.avg_luminance = 0; edid_ctrl->hdr_data.min_luminance = 0; + edid_ctrl->y420_cmdb_present = false; + edid_ctrl->y420_cmdb_supports_all = false; + kfree(edid_ctrl->y420_cmdb.vic_list); + memset(&edid_ctrl->y420_cmdb, 0, sizeof(edid_ctrl->y420_cmdb)); return 0; } @@ -915,28 +943,6 @@ static const u8 *hdmi_edid_find_hfvsdb(const u8 *in_buf) return vsd; } -static void hdmi_edid_set_y420_support(struct hdmi_edid_ctrl *edid_ctrl, - u32 video_format) -{ - u32 i = 0; - - if (!edid_ctrl) { - DEV_ERR("%s: Invalid input\n", __func__); - return; - } - - for (i = 0; i < edid_ctrl->sink_data.num_of_elements; ++i) { - if (video_format == - edid_ctrl->sink_data.disp_mode_list[i].video_format) { - edid_ctrl->sink_data.disp_mode_list[i].y420_support = - true; - DEV_DBG("%s: Yuv420 supported for format %d\n", - __func__, - edid_ctrl->sink_data.disp_mode_list[i].video_format); - } - } -} - static void hdmi_edid_add_sink_y420_format(struct hdmi_edid_ctrl *edid_ctrl, u32 video_format) { @@ -963,6 +969,17 @@ static void hdmi_edid_add_sink_y420_format(struct hdmi_edid_ctrl *edid_ctrl, video_format, msm_hdmi_mode_2string(video_format), supported ? "Supported" : "Not-Supported"); + /* override the default resolution */ + if (edid_ctrl->override_default_vic) { + if (!ret && supported) { + sink->disp_mode_list[0].video_format = video_format; + sink->disp_mode_list[0].y420_support = true; + sink->disp_mode_list[0].rgb_support = false; + edid_ctrl->override_default_vic = false; + return; + } + } + if (!ret && supported) { sink->disp_mode_list[sink->num_of_elements].video_format = video_format; @@ -1039,10 +1056,12 @@ static void hdmi_edid_parse_Y420CMDB(struct hdmi_edid_ctrl *edid_ctrl, { u32 offset = 0; u8 svd_len = 0; - u32 i = 0, j = 0; + u32 i = 0, j = 0, k = 0; u32 video_format = 0; u32 len = 0; const u8 *svd = NULL; + struct hdmi_edid_y420_cmdb *y420_cmdb = NULL; + if (!edid_ctrl) { DEV_ERR("%s: invalid input\n", __func__); @@ -1053,6 +1072,18 @@ static void hdmi_edid_parse_Y420CMDB(struct hdmi_edid_ctrl *edid_ctrl, len = in_buf[0] & 0x1F; /* + * When the Length field is set to L==1, the Y420CMDB does not include + * a YCBCR 4:2:0 Capability Bit Map and all the SVDs in the regular + * Video Data Block support YCBCR 4:2:0 sampling mode. + */ + if (len == 1) { + DEV_DBG("%s: All SVDs supports Y420 sampling mode, len = %d\n", + __func__, len); + edid_ctrl->y420_cmdb_supports_all = true; + return; + } + + /* * The Y420 Capability map data block should be parsed along with the * video data block. Each bit in Y420CMDB maps to each SVD in data * block @@ -1060,16 +1091,33 @@ static void hdmi_edid_parse_Y420CMDB(struct hdmi_edid_ctrl *edid_ctrl, svd = hdmi_edid_find_block(edid_ctrl->edid_buf+0x80, DBC_START_OFFSET, VIDEO_DATA_BLOCK, &svd_len); + if (!svd_len) + return; + + y420_cmdb = &edid_ctrl->y420_cmdb; + y420_cmdb->vic_list = kzalloc(svd_len, GFP_KERNEL); + if (!y420_cmdb->vic_list) { + DEV_ERR("%s: failed to allocated memory for y420 vic_list\n", + __func__); + return; + } + ++svd; - for (i = 0; i < svd_len; i++, j++) { + + for (i = 0, k = 0; i < svd_len; i++, svd++) { video_format = *svd & 0x7F; - if (in_buf[offset] & (1 << j)) - hdmi_edid_set_y420_support(edid_ctrl, video_format); + if (in_buf[offset] & (1 << j)) { + y420_cmdb->vic_list[k++] = video_format; + DEV_DBG("%s: Y420 capability for VIC %d\n", + __func__, video_format); + y420_cmdb->len++; + } - if (j & 0x80) { - j = j/8; + j++; + if (j & 0x8) { + j = 0; offset++; - if (offset >= len) + if (offset >= len + 1) break; } } @@ -1104,6 +1152,26 @@ static void hdmi_edid_parse_hvdb(struct hdmi_edid_ctrl *edid_ctrl, } +static void hdmi_edid_parse_colorimetry( + struct hdmi_edid_ctrl *edid_ctrl, const u8 *in_buf) +{ + u8 len = 0; + + if (!edid_ctrl) { + DEV_ERR("%s: invalid input\n", __func__); + return; + } + + len = in_buf[0] & 0x1F; + if ((in_buf[1] != COLORIMETRY_DATA_BLOCK) || (len < 3)) { + DEV_ERR("%s: Not a Colorimetry tag code\n", __func__); + return; + } + + edid_ctrl->colorimetry.standards = in_buf[2]; + edid_ctrl->colorimetry.metadata_profiles = in_buf[3]; +} + static void hdmi_edid_extract_extended_data_blocks( struct hdmi_edid_ctrl *edid_ctrl, const u8 *in_buf) { @@ -1130,8 +1198,8 @@ static void hdmi_edid_extract_extended_data_blocks( break; } - /* The extended data block should at least be 2 bytes long */ - if (len < 2) { + /* The extended data block should at least be 1 bytes long */ + if (len < 1) { DEV_DBG("%s: invalid block size\n", __func__); continue; } @@ -1173,6 +1241,7 @@ static void hdmi_edid_extract_extended_data_blocks( case Y420_CAPABILITY_MAP_DATA_BLOCK: DEV_DBG("%s found Y420CMDB byte 3 = 0x%x", __func__, etag[2]); + edid_ctrl->y420_cmdb_present = true; hdmi_edid_parse_Y420CMDB(edid_ctrl, etag); break; case Y420_VIDEO_DATA_BLOCK: @@ -1186,6 +1255,11 @@ static void hdmi_edid_extract_extended_data_blocks( hdmi_edid_parse_hdrdb(edid_ctrl, etag); edid_ctrl->hdr_supported = true; break; + case COLORIMETRY_DATA_BLOCK: + DEV_DBG("%s found COLORIMETRY block. byte 3 = 0x%x", + __func__, etag[2]); + hdmi_edid_parse_colorimetry(edid_ctrl, etag); + break; default: DEV_DBG("%s: Tag Code %d not supported\n", __func__, etag[1]); @@ -1216,6 +1290,9 @@ static void hdmi_edid_extract_3d_present(struct hdmi_edid_ctrl *edid_ctrl, } offset = HDMI_VSDB_3D_EVF_DATA_OFFSET(vsd); + if (offset >= len - 1) + return; + DEV_DBG("%s: EDID: 3D present @ 0x%x = %02x\n", __func__, offset, vsd[offset]); @@ -1331,7 +1408,10 @@ static void hdmi_edid_extract_sink_caps(struct hdmi_edid_ctrl *edid_ctrl, return; /* Max TMDS clock is in multiples of 5Mhz. */ - edid_ctrl->sink_caps.max_pclk_in_hz = vsd[7] * 5000000; + if (len >= 7 && vsd[7]) { + edid_ctrl->sink_caps.max_pclk_in_hz = vsd[7] * 5000000; + DEV_DBG("%s: MaxTMDS=%dMHz\n", __func__, (u32)vsd[7] * 5); + } vsd = hdmi_edid_find_hfvsdb(in_buf); @@ -1344,9 +1424,13 @@ static void hdmi_edid_extract_sink_caps(struct hdmi_edid_ctrl *edid_ctrl, * the sink shall set this filed to 0. The max TMDS support * clock Rate = Max_TMDS_Character_Rates * 5Mhz. */ - if (vsd[5] != 0) + if (vsd[5] != 0) { edid_ctrl->sink_caps.max_pclk_in_hz = vsd[5] * 5000000; + DEV_DBG("%s: HF-VSDB: MaxTMDS=%dMHz\n", + __func__, (u32)vsd[5] * 5); + } + edid_ctrl->sink_caps.scdc_present = (vsd[6] & 0x80) ? true : false; edid_ctrl->sink_caps.scramble_support = @@ -1376,8 +1460,19 @@ static void hdmi_edid_extract_latency_fields(struct hdmi_edid_ctrl *edid_ctrl, vsd = hdmi_edid_find_block(in_buf, DBC_START_OFFSET, VENDOR_SPECIFIC_DATA_BLOCK, &len); - if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE || - !(vsd[8] & BIT(7))) { + if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE) { + DEV_DBG("%s: No/Invalid vendor Specific Data Block\n", + __func__); + return; + } + + if (len < 8) { + DEV_DBG("%s: No extra Vendor Specific information present\n", + __func__); + return; + } + + if (!(vsd[8] & BIT(7))) { edid_ctrl->video_latency = (u16)-1; edid_ctrl->audio_latency = (u16)-1; DEV_DBG("%s: EDID: No audio/video latency present\n", __func__); @@ -1410,8 +1505,8 @@ static u32 hdmi_edid_extract_ieee_reg_id(struct hdmi_edid_ctrl *edid_ctrl, return 0; } - DEV_DBG("%s: EDID: VSD PhyAddr=%04x, MaxTMDS=%dMHz\n", __func__, - ((u32)vsd[4] << 8) + (u32)vsd[5], (u32)vsd[7] * 5); + DEV_DBG("%s: EDID: VSD PhyAddr=%04x\n", __func__, + ((u32)vsd[4] << 8) + (u32)vsd[5]); edid_ctrl->physical_address = ((u16)vsd[4] << 8) + (u16)vsd[5]; @@ -1455,7 +1550,9 @@ static void hdmi_edid_extract_dc(struct hdmi_edid_ctrl *edid_ctrl, if (vsd == NULL || len == 0 || len > MAX_DATA_BLOCK_SIZE) return; - edid_ctrl->deep_color = (vsd[6] >> 0x3) & 0xF; + edid_ctrl->deep_color = 0; + if (len >= 6) + edid_ctrl->deep_color = (vsd[6] >> 0x3) & 0xF; vsd = hdmi_edid_find_hfvsdb(in_buf); @@ -1650,7 +1747,12 @@ static void hdmi_edid_detail_desc(struct hdmi_edid_ctrl *edid_ctrl, timing.pixel_freq = pixel_clk; timing.refresh_rate = refresh_rate; timing.interlaced = interlaced; - timing.supported = true; + if (!interlaced) + timing.supported = true; + + if (refresh_rate > (MAX_REFRESH_RATE_SUPPORTED * khz_to_hz)) + timing.supported = false; + timing.ar = aspect_ratio_4_3 ? HDMI_RES_AR_4_3 : (aspect_ratio_5_4 ? HDMI_RES_AR_5_4 : HDMI_RES_AR_16_9); @@ -1718,6 +1820,7 @@ static void hdmi_edid_add_sink_video_format(struct hdmi_edid_ctrl *edid_ctrl, struct hdmi_edid_sink_data *sink_data = &edid_ctrl->sink_data; struct disp_mode_info *disp_mode_list = sink_data->disp_mode_list; u32 i = 0; + bool y420_supported = false; if (video_format >= HDMI_VFRMT_MAX) { DEV_ERR("%s: video format: %s is not supported\n", __func__, @@ -1729,21 +1832,56 @@ static void hdmi_edid_add_sink_video_format(struct hdmi_edid_ctrl *edid_ctrl, video_format, msm_hdmi_mode_2string(video_format), supported ? "Supported" : "Not-Supported"); + if (edid_ctrl->y420_cmdb_present && video_format < HDMI_VFRMT_END) { + if (edid_ctrl->y420_cmdb_supports_all) { + y420_supported = true; + goto done; + } + + for (i = 0; i < edid_ctrl->y420_cmdb.len; i++) { + if (video_format == edid_ctrl->y420_cmdb.vic_list[i]) { + y420_supported = true; + break; + } + } + } + +done: + /* override the default resolution */ + if (edid_ctrl->override_default_vic) { + if (!ret && supported) { + disp_mode_list[0].video_format = video_format; + disp_mode_list[0].rgb_support = true; + if (y420_supported) + disp_mode_list[0].y420_support = true; + edid_ctrl->override_default_vic = false; + return; + } + } + for (i = 0; i < sink_data->num_of_elements; i++) { u32 vic = disp_mode_list[i].video_format; if (vic == video_format) { DEV_DBG("%s: vic %d already added\n", __func__, vic); + if (supported) + disp_mode_list[i].rgb_support = true; + if (y420_supported) + disp_mode_list[i].y420_support = true; return; } } - if (!ret && supported) { + if (!ret && (supported || y420_supported)) { /* todo: MHL */ disp_mode_list[sink_data->num_of_elements].video_format = video_format; - disp_mode_list[sink_data->num_of_elements].rgb_support = - true; + if (supported) + disp_mode_list[sink_data->num_of_elements]. + rgb_support = true; + if (y420_supported) + disp_mode_list[sink_data->num_of_elements]. + y420_support = true; sink_data->num_of_elements++; } } /* hdmi_edid_add_sink_video_format */ @@ -1914,6 +2052,12 @@ static void hdmi_edid_get_extended_video_formats( return; } + if (db_len < 8) { + DEV_DBG("%s: No extra Vendor Specific information present\n", + __func__); + return; + } + /* check if HDMI_Video_present flag is set or not */ if (!(vsd[8] & BIT(5))) { DEV_DBG("%s: extended vfmts are not supported by the sink.\n", @@ -2289,6 +2433,9 @@ int hdmi_edid_parser(void *input) u16 ieee_reg_id; int status = 0; u32 i = 0; + u32 cea_idx = 1; + u32 sink_caps_pclk_khz = 0; + u32 max_pclk_khz = 0; struct hdmi_edid_ctrl *edid_ctrl = (struct hdmi_edid_ctrl *)input; if (!edid_ctrl) { @@ -2315,7 +2462,7 @@ int hdmi_edid_parser(void *input) /* EDID_CEA_EXTENSION_FLAG[0x7E] - CEC extension byte */ num_of_cea_blocks = edid_buf[EDID_BLOCK_SIZE - 2]; - DEV_DBG("%s: No. of CEA blocks is [%u]\n", __func__, + DEV_DBG("%s: No. of CEA/Extended EDID blocks is [%u]\n", __func__, num_of_cea_blocks); /* Find out any CEA extension blocks following block 0 */ @@ -2334,30 +2481,42 @@ int hdmi_edid_parser(void *input) num_of_cea_blocks = MAX_EDID_BLOCKS - 1; } - /* check for valid CEA block */ - if (edid_buf[EDID_BLOCK_SIZE] != 2) { - DEV_ERR("%s: Invalid CEA block\n", __func__); - num_of_cea_blocks = 0; - goto bail; + if (edid_buf[EDID_BLOCK_SIZE] == 0xF0) { + DEV_DBG("%s: Extended EDID Block Map found\n", __func__); + edid_buf += EDID_BLOCK_SIZE; + cea_idx++; } - /* goto to CEA extension edid block */ - edid_buf += EDID_BLOCK_SIZE; + for (i = cea_idx; i <= num_of_cea_blocks; i++) { - ieee_reg_id = hdmi_edid_extract_ieee_reg_id(edid_ctrl, edid_buf); - DEV_DBG("%s: ieee_reg_id = 0x%08x\n", __func__, ieee_reg_id); - if (ieee_reg_id == EDID_IEEE_REG_ID) - edid_ctrl->sink_mode = SINK_MODE_HDMI; - else - edid_ctrl->sink_mode = SINK_MODE_DVI; + /* check for valid CEA block */ + if (edid_buf[EDID_BLOCK_SIZE] != 2) { + DEV_ERR("%s: Not a CEA block\n", __func__); + edid_buf += EDID_BLOCK_SIZE; + continue; + } + + /* goto to CEA extension edid block */ + edid_buf += EDID_BLOCK_SIZE; + + ieee_reg_id = hdmi_edid_extract_ieee_reg_id(edid_ctrl, + edid_buf); + DEV_DBG("%s: ieee_reg_id = 0x%06x\n", __func__, ieee_reg_id); + if (ieee_reg_id == EDID_IEEE_REG_ID) + edid_ctrl->sink_mode = SINK_MODE_HDMI; + else + edid_ctrl->sink_mode = SINK_MODE_DVI; - hdmi_edid_extract_sink_caps(edid_ctrl, edid_buf); - hdmi_edid_extract_latency_fields(edid_ctrl, edid_buf); - hdmi_edid_extract_dc(edid_ctrl, edid_buf); - hdmi_edid_extract_speaker_allocation_data(edid_ctrl, edid_buf); - hdmi_edid_extract_audio_data_blocks(edid_ctrl, edid_buf); - hdmi_edid_extract_3d_present(edid_ctrl, edid_buf); - hdmi_edid_extract_extended_data_blocks(edid_ctrl, edid_buf); + if (ieee_reg_id == EDID_IEEE_REG_ID) { + hdmi_edid_extract_sink_caps(edid_ctrl, edid_buf); + hdmi_edid_extract_latency_fields(edid_ctrl, edid_buf); + hdmi_edid_extract_dc(edid_ctrl, edid_buf); + hdmi_edid_extract_3d_present(edid_ctrl, edid_buf); + } + hdmi_edid_extract_speaker_allocation_data(edid_ctrl, edid_buf); + hdmi_edid_extract_audio_data_blocks(edid_ctrl, edid_buf); + hdmi_edid_extract_extended_data_blocks(edid_ctrl, edid_buf); + } bail: for (i = 1; i <= num_of_cea_blocks; i++) { @@ -2369,6 +2528,13 @@ bail: edid_ctrl->cea_blks = num_of_cea_blocks; + sink_caps_pclk_khz = + hdmi_edid_get_sink_caps_max_tmds_clk(edid_ctrl) / 1000; + max_pclk_khz = hdmi_edid_get_max_pclk(edid_ctrl); + if (sink_caps_pclk_khz && max_pclk_khz) + hdmi_edid_set_max_pclk_rate(edid_ctrl, + min(max_pclk_khz, sink_caps_pclk_khz)); + hdmi_edid_get_display_mode(edid_ctrl); if (edid_ctrl->keep_resv_timings) @@ -2561,6 +2727,18 @@ void hdmi_edid_get_hdr_data(void *input, *hdr_data = &edid_ctrl->hdr_data; } +u8 hdmi_edid_get_colorimetry(void *input) +{ + struct hdmi_edid_ctrl *edid_ctrl = (struct hdmi_edid_ctrl *)input; + + if (!edid_ctrl) { + DEV_ERR("%s: invalid input\n", __func__); + return 0; + } + + return edid_ctrl->colorimetry.standards; +} + bool hdmi_edid_is_s3d_mode_supported(void *input, u32 video_mode, u32 s3d_mode) { int i; @@ -2687,6 +2865,7 @@ void hdmi_edid_set_video_resolution(void *input, u32 resolution, bool reset) edid_ctrl->sink_data.disp_mode_list[0].video_format = resolution; edid_ctrl->sink_data.disp_mode_list[0].rgb_support = true; + edid_ctrl->override_default_vic = true; } } /* hdmi_edid_set_video_resolution */ diff --git a/drivers/video/fbdev/msm/mdss_hdmi_edid.h b/drivers/video/fbdev/msm/mdss_hdmi_edid.h index 63785e95bd59..ae4f47ca42aa 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_edid.h +++ b/drivers/video/fbdev/msm/mdss_hdmi_edid.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -20,6 +20,15 @@ #define EDID_BLOCK_ADDR 0xA0 #define MAX_EDID_BLOCKS 5 +#define EDID_COLORIMETRY_xvYCC_601 (1 << 0) +#define EDID_COLORIMETRY_xvYCC_709 (1 << 1) +#define EDID_COLORIMETRY_sYCC_601 (1 << 2) +#define EDID_COLORIMETRY_ADBYCC_601 (1 << 3) +#define EDID_COLORIMETRY_ADB_RGB (1 << 4) +#define EDID_COLORIMETRY_BT2020_CYCC (1 << 5) +#define EDID_COLORIMETRY_BT2020_YCC (1 << 6) +#define EDID_COLORIMETRY_BT2020_RGB (1 << 7) + struct hdmi_edid_init_data { struct kobject *kobj; struct hdmi_util_ds_data ds_data; @@ -83,5 +92,6 @@ void hdmi_edid_config_override(void *input, bool enable, void hdmi_edid_set_max_pclk_rate(void *input, u32 max_pclk_khz); bool hdmi_edid_is_audio_supported(void *input); u32 hdmi_edid_get_sink_caps_max_tmds_clk(void *input); +u8 hdmi_edid_get_colorimetry(void *input); #endif /* __HDMI_EDID_H__ */ diff --git a/drivers/video/fbdev/msm/mdss_hdmi_hdcp2p2.c b/drivers/video/fbdev/msm/mdss_hdmi_hdcp2p2.c index 46e289b6dbd3..b922662d25aa 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_hdcp2p2.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_hdcp2p2.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -393,31 +393,22 @@ exit: return count; } -static ssize_t hdmi_hdcp2p2_sysfs_wta_min_level_change(struct device *dev, - struct device_attribute *attr, const char *buf, size_t count) +static void mdss_hdmi_hdcp2p2_min_level_change(void *client_ctx, + int min_enc_level) { struct hdmi_hdcp2p2_ctrl *ctrl = - hdmi_get_featuredata_from_sysfs_dev(dev, HDMI_TX_FEAT_HDCP2P2); + (struct hdmi_hdcp2p2_ctrl *)client_ctx; struct hdcp_lib_wakeup_data cdata = { HDCP_LIB_WKUP_CMD_QUERY_STREAM_TYPE}; bool enc_notify = true; enum hdcp_states enc_lvl; - int min_enc_lvl; - int rc; if (!ctrl) { pr_err("invalid input\n"); - rc = -EINVAL; - goto exit; - } - - rc = kstrtoint(buf, 10, &min_enc_lvl); - if (rc) { - DEV_ERR("%s: kstrtoint failed. rc=%d\n", __func__, rc); - goto exit; + return; } - switch (min_enc_lvl) { + switch (min_enc_level) { case 0: enc_lvl = HDCP_STATE_AUTH_ENC_NONE; break; @@ -431,7 +422,7 @@ static ssize_t hdmi_hdcp2p2_sysfs_wta_min_level_change(struct device *dev, enc_notify = false; } - pr_debug("enc level changed %d\n", min_enc_lvl); + pr_debug("enc level changed %d\n", min_enc_level); cdata.context = ctrl->lib_ctx; hdmi_hdcp2p2_wakeup_lib(ctrl, &cdata); @@ -441,10 +432,6 @@ static ssize_t hdmi_hdcp2p2_sysfs_wta_min_level_change(struct device *dev, if (enc_notify && ctrl->init_data.notify_status) ctrl->init_data.notify_status(ctrl->init_data.cb_data, enc_lvl); - - rc = count; -exit: - return rc; } static void hdmi_hdcp2p2_auth_failed(struct hdmi_hdcp2p2_ctrl *ctrl) @@ -584,13 +571,10 @@ static int hdmi_hdcp2p2_read_version(struct hdmi_hdcp2p2_ctrl *ctrl, return rc; } -static DEVICE_ATTR(min_level_change, S_IWUSR, NULL, - hdmi_hdcp2p2_sysfs_wta_min_level_change); static DEVICE_ATTR(tethered, S_IRUGO | S_IWUSR, hdmi_hdcp2p2_sysfs_rda_tethered, hdmi_hdcp2p2_sysfs_wta_tethered); static struct attribute *hdmi_hdcp2p2_fs_attrs[] = { - &dev_attr_min_level_change.attr, &dev_attr_tethered.attr, NULL, }; @@ -1030,6 +1014,7 @@ void *hdmi_hdcp2p2_init(struct hdcp_init_data *init_data) static struct hdcp_client_ops client_ops = { .wakeup = hdmi_hdcp2p2_wakeup, + .notify_lvl_change = mdss_hdmi_hdcp2p2_min_level_change, .srm_cb = hdmi_hdcp2p2_srm_cb, }; diff --git a/drivers/video/fbdev/msm/mdss_hdmi_panel.c b/drivers/video/fbdev/msm/mdss_hdmi_panel.c index af72973a3988..20afa08155c1 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_panel.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_panel.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -137,12 +137,36 @@ enum { DATA_BYTE_13, }; +enum hdmi_colorimetry { + HDMI_COLORIMETRY_DEFAULT, + HDMI_COLORIMETRY_ITU_R_601, + HDMI_COLORIMETRY_ITU_R_709, + HDMI_COLORIMETRY_EXTENDED +}; + +enum hdmi_ext_colorimetry { + HDMI_COLORIMETRY_XV_YCC_601, + HDMI_COLORIMETRY_XV_YCC_709, + HDMI_COLORIMETRY_S_YCC_601, + HDMI_COLORIMETRY_ADOBE_YCC_601, + HDMI_COLORIMETRY_ADOBE_RGB, + HDMI_COLORIMETRY_C_YCBCR_BT2020, + HDMI_COLORIMETRY_YCBCR_BT2020, + HDMI_COLORIMETRY_RESERVED + +}; + enum hdmi_quantization_range { HDMI_QUANTIZATION_DEFAULT, HDMI_QUANTIZATION_LIMITED_RANGE, HDMI_QUANTIZATION_FULL_RANGE }; +enum hdmi_ycc_quantization_range { + HDMI_YCC_QUANTIZATION_LIMITED_RANGE, + HDMI_YCC_QUANTIZATION_FULL_RANGE +}; + enum hdmi_scaling_info { HDMI_SCALING_NONE, HDMI_SCALING_HORZ, @@ -189,12 +213,29 @@ static int hdmi_panel_config_avi(struct hdmi_panel *panel) avi->bar_info.start_of_right_bar = timing->active_h + 1; avi->act_fmt_info_present = true; - avi->rgb_quantization_range = HDMI_QUANTIZATION_DEFAULT; - avi->yuv_quantization_range = HDMI_QUANTIZATION_DEFAULT; + if (pinfo->is_ce_mode) { + avi->rgb_quantization_range = + HDMI_QUANTIZATION_LIMITED_RANGE; + avi->yuv_quantization_range = + HDMI_YCC_QUANTIZATION_LIMITED_RANGE; + } else { + avi->rgb_quantization_range = + HDMI_QUANTIZATION_FULL_RANGE; + avi->yuv_quantization_range = + HDMI_YCC_QUANTIZATION_FULL_RANGE; + } avi->scaling_info = HDMI_SCALING_NONE; - avi->colorimetry_info = 0; + if (avi->pixel_format == MDP_Y_CBCR_H2V2) { + if (pinfo->yres < 720) + avi->colorimetry_info = HDMI_COLORIMETRY_ITU_R_601; + else + avi->colorimetry_info = HDMI_COLORIMETRY_ITU_R_709; + } else { + avi->colorimetry_info = HDMI_COLORIMETRY_DEFAULT; + } + avi->ext_colorimetry_info = 0; avi->pixel_rpt_factor = 0; @@ -602,13 +643,29 @@ end: return rc; } +static inline int get_bitdepth(enum hdmi_deep_color_depth bitdepth) +{ + switch (bitdepth) { + case HDMI_DEEP_COLOR_DEPTH_24BPP: + return 24; + case HDMI_DEEP_COLOR_DEPTH_30BPP: + return 30; + case HDMI_DEEP_COLOR_DEPTH_36BPP: + return 36; + default: + return 0; + } +} + static int hdmi_panel_setup_dc(struct hdmi_panel *panel) { u32 hdmi_ctrl_reg; u32 vbi_pkt_reg; int rc = 0; - pr_debug("Deep Color: %s\n", panel->data->dc_enable ? "ON" : "OFF"); + pr_debug("Deep Color: %s, bitdepth = %d\n", + panel->data->dc_enable ? "ON" : "OFF", + get_bitdepth(panel->data->bitdepth)); /* enable deep color if supported */ if (panel->data->dc_enable) { @@ -789,6 +846,53 @@ end: return panel->vic; } +static int hdmi_panel_avi_update_colorimetry(void *input, + bool use_bt2020) +{ + struct hdmi_panel *panel = input; + struct mdss_panel_info *pinfo; + struct hdmi_video_config *vid_cfg; + struct hdmi_avi_infoframe_config *avi; + int rc = 0; + + if (!panel) { + DEV_ERR("%s: invalid hdmi panel\n", __func__); + rc = -EINVAL; + goto error; + } + + /* Configure AVI infoframe */ + rc = hdmi_panel_config_avi(panel); + if (rc) { + DEV_ERR("%s: failed to configure AVI\n", __func__); + goto error; + } + + pinfo = panel->data->pinfo; + vid_cfg = &panel->vid_cfg; + avi = &vid_cfg->avi_iframe; + + /* Update Colorimetry */ + avi->ext_colorimetry_info = 0; + + if (use_bt2020) { + avi->colorimetry_info = HDMI_COLORIMETRY_EXTENDED; + avi->ext_colorimetry_info = HDMI_COLORIMETRY_YCBCR_BT2020; + } else if (avi->pixel_format == MDP_Y_CBCR_H2V2) { + if (pinfo->yres < 720) + avi->colorimetry_info = HDMI_COLORIMETRY_ITU_R_601; + else + avi->colorimetry_info = HDMI_COLORIMETRY_ITU_R_709; + } else { + avi->colorimetry_info = HDMI_COLORIMETRY_DEFAULT; + } + + hdmi_panel_set_avi_infoframe(panel); + +error: + return rc; +} + static int hdmi_panel_power_on(void *input) { int rc = 0; @@ -915,6 +1019,8 @@ void *hdmi_panel_init(struct hdmi_panel_init_data *data) data->ops->off = hdmi_panel_power_off; data->ops->vendor = hdmi_panel_set_vendor_specific_infoframe; data->ops->update_fps = hdmi_panel_update_fps; + data->ops->update_colorimetry = + hdmi_panel_avi_update_colorimetry; } end: return panel; diff --git a/drivers/video/fbdev/msm/mdss_hdmi_panel.h b/drivers/video/fbdev/msm/mdss_hdmi_panel.h index cb40f0cad55e..04cd971e2db0 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_panel.h +++ b/drivers/video/fbdev/msm/mdss_hdmi_panel.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2016-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -16,6 +16,13 @@ #include "mdss_panel.h" #include "mdss_hdmi_util.h" +enum hdmi_deep_color_depth { + HDMI_DEEP_COLOR_DEPTH_24BPP, + HDMI_DEEP_COLOR_DEPTH_30BPP, + HDMI_DEEP_COLOR_DEPTH_36BPP, + HDMI_DEEP_COLOR_DEPTH_RESERVED, +}; + /** * struct hdmi_panel_data - panel related data information * @@ -29,6 +36,7 @@ * @is_it_content: set to true if content is IT * @scrambler: set to true if scrambler needs to be enabled * @dc_enable: set to true if deep color is enabled + * @bitdepth: set the output bitdepth like 24/30 bpp */ struct hdmi_panel_data { struct mdss_panel_info *pinfo; @@ -41,6 +49,7 @@ struct hdmi_panel_data { bool is_it_content; bool scrambler; bool dc_enable; + enum hdmi_deep_color_depth bitdepth; }; /** @@ -56,6 +65,7 @@ struct hdmi_panel_ops { int (*off)(void *input); void (*vendor)(void *input); int (*update_fps)(void *input, u32 fps); + int (*update_colorimetry)(void *input, bool use_bt2020); }; /** diff --git a/drivers/video/fbdev/msm/mdss_hdmi_tx.c b/drivers/video/fbdev/msm/mdss_hdmi_tx.c index 0778e43fe0ff..79a6a16d4fed 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_tx.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_tx.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, 2019, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -122,6 +122,11 @@ static int hdmi_tx_get_cable_status(struct platform_device *pdev, u32 vote); static int hdmi_tx_update_ppm(struct hdmi_tx_ctrl *hdmi_ctrl, s32 ppm); static int hdmi_tx_enable_pll_update(struct hdmi_tx_ctrl *hdmi_ctrl, int enable); +static void hdmi_tx_hpd_polarity_setup(struct hdmi_tx_ctrl *hdmi_ctrl, + bool polarity); +static int hdmi_tx_notify_events(struct hdmi_tx_ctrl *hdmi_ctrl, int val); +static void hdmi_panel_update_colorimetry(struct hdmi_tx_ctrl *ctrl, + bool use_bt2020); static struct mdss_hw hdmi_tx_hw = { .hw_ndx = MDSS_HW_HDMI, @@ -305,7 +310,7 @@ static inline bool hdmi_tx_metadata_type_one(struct hdmi_tx_ctrl *hdmi_ctrl) return hdr_data->metadata_type_one; } -static inline bool hdmix_tx_sink_dc_support(struct hdmi_tx_ctrl *hdmi_ctrl) +static inline bool hdmi_tx_sink_dc_support(struct hdmi_tx_ctrl *hdmi_ctrl) { void *edid_fd = hdmi_tx_get_fd(HDMI_TX_FEAT_EDID); @@ -325,8 +330,7 @@ static inline bool hdmi_tx_dc_support(struct hdmi_tx_ctrl *hdmi_ctrl) true); return hdmi_ctrl->dc_feature_on && - hdmi_ctrl->dc_support && - hdmix_tx_sink_dc_support(hdmi_ctrl) && + hdmi_tx_sink_dc_support(hdmi_ctrl) && (tmds_clk_with_dc <= hdmi_edid_get_max_pclk(edid_fd)); } @@ -429,9 +433,17 @@ static inline void hdmi_tx_send_audio_notification( } } -static inline void hdmi_tx_send_video_notification( +static inline int hdmi_tx_send_video_notification( struct hdmi_tx_ctrl *hdmi_ctrl, int val, bool async) { + int ret = 0; + + if (!hdmi_ctrl) { + pr_err("invalid hdmi_ctrl input\n"); + ret = -EINVAL; + goto end; + } + if (hdmi_ctrl && hdmi_ctrl->ext_audio_data.intf_ops.hpd) { u32 flags = 0; @@ -440,9 +452,13 @@ static inline void hdmi_tx_send_video_notification( else flags |= MSM_EXT_DISP_HPD_VIDEO; - hdmi_ctrl->ext_audio_data.intf_ops.hpd(hdmi_ctrl->ext_pdev, - hdmi_ctrl->ext_audio_data.type, val, flags); + ret = hdmi_ctrl->ext_audio_data.intf_ops.hpd( + hdmi_ctrl->ext_pdev, + hdmi_ctrl->ext_audio_data.type, + val, flags); } +end: + return ret; } static inline void hdmi_tx_ack_state( @@ -548,8 +564,8 @@ static ssize_t hdmi_tx_sysfs_rda_connected(struct device *dev, } mutex_lock(&hdmi_ctrl->tx_lock); - ret = snprintf(buf, PAGE_SIZE, "%d\n", hdmi_ctrl->hpd_state); - DEV_DBG("%s: '%d'\n", __func__, hdmi_ctrl->hpd_state); + ret = snprintf(buf, PAGE_SIZE, "%d\n", hdmi_ctrl->notification_status); + DEV_DBG("%s: '%d'\n", __func__, hdmi_ctrl->notification_status); mutex_unlock(&hdmi_ctrl->tx_lock); return ret; @@ -883,8 +899,7 @@ static ssize_t hdmi_tx_sysfs_wta_hpd(struct device *dev, * No need to blocking wait for display/audio in this * case since HAL is not up so no ACK can be expected. */ - hdmi_tx_send_audio_notification(hdmi_ctrl, 0); - hdmi_tx_send_video_notification(hdmi_ctrl, 0, true); + hdmi_tx_notify_events(hdmi_ctrl, 0); } break; @@ -1329,9 +1344,13 @@ static ssize_t hdmi_tx_sysfs_wta_hdr_stream(struct device *dev, hdr_op = hdmi_hdr_get_ops(ctrl->curr_hdr_state, ctrl->hdr_ctrl.hdr_state); - if (hdr_op == HDR_SEND_INFO) + if (hdr_op == HDR_SEND_INFO) { hdmi_panel_set_hdr_infoframe(ctrl); - else if (hdr_op == HDR_CLEAR_INFO) + if (ctrl->hdr_ctrl.hdr_stream.eotf) + hdmi_panel_update_colorimetry(ctrl, true); + else + hdmi_panel_update_colorimetry(ctrl, false); + } else if (hdr_op == HDR_CLEAR_INFO) hdmi_panel_clear_hdr_infoframe(ctrl); ctrl->curr_hdr_state = ctrl->hdr_ctrl.hdr_state; @@ -1848,7 +1867,6 @@ static int hdmi_tx_read_edid(struct hdmi_tx_ctrl *hdmi_ctrl) } } while ((cea_blks-- > 0) && (block++ < MAX_EDID_BLOCKS)); end: - return ret; } @@ -2429,11 +2447,60 @@ static void hdmi_tx_update_hdr_info(struct hdmi_tx_ctrl *hdmi_ctrl) } } +static int hdmi_tx_notify_events(struct hdmi_tx_ctrl *hdmi_ctrl, int val) +{ + int rc = 0; + + if (val == hdmi_ctrl->notification_status) { + pr_debug("%s: No change in notification status %d -> %d\n", + __func__, hdmi_ctrl->notification_status, val); + goto end; + } + + reinit_completion(&hdmi_ctrl->notification_comp); + if (atomic_read(&hdmi_ctrl->notification_pending)) { + pr_debug("%s: wait for previous event to finish\n", __func__); + rc = wait_for_completion_timeout( + &hdmi_ctrl->notification_comp, HZ); + if (rc <= 0) { + pr_debug("%s: wait for pending notification timed out\n", + __func__); + hdmi_ctrl->pending_event = val; + hdmi_ctrl->handle_pe = true; + rc = -ETIMEDOUT; + goto end; + } + } + + hdmi_ctrl->notification_status = val; + atomic_set(&hdmi_ctrl->notification_pending, 1); + + if (val) { + rc = hdmi_tx_send_video_notification(hdmi_ctrl, val, true); + } else { + hdmi_tx_send_audio_notification(hdmi_ctrl, val); + rc = hdmi_tx_send_video_notification(hdmi_ctrl, val, true); + } + + if (!rc) { + pr_debug("%s: Successfully sent %s notification\n", __func__, + val ? "CONNECT" : "DISCONNECT"); + } else { + pr_err("%s: %s notification failed\n", __func__, + val ? "CONNECT" : "DISCONNECT"); + atomic_set(&hdmi_ctrl->notification_pending, 0); + } +end: + return rc; +} + static void hdmi_tx_hpd_int_work(struct work_struct *work) { struct hdmi_tx_ctrl *hdmi_ctrl = NULL; int rc = -EINVAL; int retry = MAX_EDID_READ_RETRY; + unsigned long flags; + u32 hpd_state; hdmi_ctrl = container_of(work, struct hdmi_tx_ctrl, hpd_int_work); if (!hdmi_ctrl) { @@ -2441,36 +2508,39 @@ static void hdmi_tx_hpd_int_work(struct work_struct *work) return; } - mutex_lock(&hdmi_ctrl->tx_lock); - if (!hdmi_ctrl->hpd_initialized) { DEV_DBG("hpd not initialized\n"); - mutex_unlock(&hdmi_ctrl->tx_lock); return; } + spin_lock_irqsave(&hdmi_ctrl->hpd_state_lock, flags); + hpd_state = hdmi_ctrl->hpd_state; + spin_unlock_irqrestore(&hdmi_ctrl->hpd_state_lock, flags); + DEV_DBG("%s: %s\n", __func__, - hdmi_ctrl->hpd_state ? "CONNECT" : "DISCONNECT"); + hpd_state ? "CONNECT" : "DISCONNECT"); + + if (hpd_state) { + hdmi_tx_hpd_polarity_setup(hdmi_ctrl, + HPD_DISCONNECT_POLARITY); - if (hdmi_ctrl->hpd_state) { while (rc && retry--) rc = hdmi_tx_read_sink_info(hdmi_ctrl); if (!retry && rc) pr_warn_ratelimited("%s: EDID read failed\n", __func__); hdmi_tx_update_deep_color(hdmi_ctrl); hdmi_tx_update_hdr_info(hdmi_ctrl); - } - mutex_unlock(&hdmi_ctrl->tx_lock); + hdmi_tx_notify_events(hdmi_ctrl, hpd_state); - if (hdmi_ctrl->hpd_state) - hdmi_tx_send_video_notification(hdmi_ctrl, - hdmi_ctrl->hpd_state, true); - else { - hdmi_tx_send_audio_notification(hdmi_ctrl, - hdmi_ctrl->hpd_state); - hdmi_tx_send_video_notification(hdmi_ctrl, - hdmi_ctrl->hpd_state, true); + } else { + rc = hdmi_tx_notify_events(hdmi_ctrl, hpd_state); + + if (!rc && !hdmi_ctrl->panel_power_on) { + atomic_set(&hdmi_ctrl->notification_pending, 0); + hdmi_tx_hpd_polarity_setup(hdmi_ctrl, + HPD_CONNECT_POLARITY); + } } } /* hdmi_tx_hpd_int_work */ @@ -3065,6 +3135,34 @@ static void hdmi_panel_clear_hdr_infoframe(struct hdmi_tx_ctrl *ctrl) DSS_REG_W(io, HDMI_GEN_PKT_CTRL, packet_control); } +static void hdmi_panel_update_colorimetry(struct hdmi_tx_ctrl *hdmi_ctrl, + bool use_bt2020) +{ + void *pdata; + + if (!hdmi_ctrl) { + DEV_ERR("%s: invalid hdmi ctrl data\n", __func__); + return; + } + + pdata = hdmi_tx_get_fd(HDMI_TX_FEAT_PANEL); + if (!pdata) { + DEV_ERR("%s: invalid panel data\n", __func__); + return; + } + + /* If there is no change in colorimetry, just return */ + if (use_bt2020 && hdmi_ctrl->use_bt2020) + return; + else if (!use_bt2020 && !hdmi_ctrl->use_bt2020) + return; + + if (hdmi_ctrl->panel_ops.update_colorimetry) + hdmi_ctrl->panel_ops.update_colorimetry(pdata, use_bt2020); + + hdmi_ctrl->use_bt2020 = use_bt2020; +} + static int hdmi_tx_audio_info_setup(struct platform_device *pdev, struct msm_ext_disp_audio_setup_params *params) { @@ -3289,7 +3387,7 @@ static int hdmi_tx_power_off(struct hdmi_tx_ctrl *hdmi_ctrl) hdmi_tx_core_off(hdmi_ctrl); hdmi_ctrl->panel_power_on = false; - hdmi_ctrl->dc_support = false; + hdmi_ctrl->vic = 0; if (hdmi_ctrl->hpd_off_pending || hdmi_ctrl->panel_suspend) hdmi_tx_hpd_off(hdmi_ctrl); @@ -3337,6 +3435,10 @@ static int hdmi_tx_power_on(struct hdmi_tx_ctrl *hdmi_ctrl) hdmi_ctrl->panel.scrambler = hdmi_edid_get_sink_scrambler_support( edata); hdmi_ctrl->panel.dc_enable = hdmi_tx_dc_support(hdmi_ctrl); + if (hdmi_ctrl->panel.dc_enable) + hdmi_ctrl->panel.bitdepth = HDMI_DEEP_COLOR_DEPTH_30BPP; + else + hdmi_ctrl->panel.bitdepth = HDMI_DEEP_COLOR_DEPTH_24BPP; if (hdmi_ctrl->panel_ops.on) hdmi_ctrl->panel_ops.on(pdata); @@ -3362,8 +3464,6 @@ static int hdmi_tx_power_on(struct hdmi_tx_ctrl *hdmi_ctrl) hdmi_ctrl->panel_power_on = true; - hdmi_tx_hpd_polarity_setup(hdmi_ctrl, HPD_DISCONNECT_POLARITY); - if (hdmi_ctrl->hdmi_tx_hpd_done) hdmi_ctrl->hdmi_tx_hpd_done(hdmi_ctrl->downstream_data); @@ -3415,6 +3515,7 @@ static void hdmi_tx_hpd_off(struct hdmi_tx_ctrl *hdmi_ctrl) hdmi_ctrl->hpd_initialized = false; hdmi_ctrl->hpd_off_pending = false; + hdmi_ctrl->dc_support = false; DEV_DBG("%s: HPD is now OFF\n", __func__); } /* hdmi_tx_hpd_off */ @@ -3473,6 +3574,7 @@ static int hdmi_tx_hpd_on(struct hdmi_tx_ctrl *hdmi_ctrl) /* Turn on HPD HW circuit */ DSS_REG_W(io, HDMI_HPD_CTRL, reg_val | BIT(28)); + atomic_set(&hdmi_ctrl->notification_pending, 0); hdmi_tx_hpd_polarity_setup(hdmi_ctrl, HPD_CONNECT_POLARITY); DEV_DBG("%s: HPD is now ON\n", __func__); } @@ -3697,6 +3799,11 @@ static int hdmi_tx_dev_init(struct hdmi_tx_ctrl *hdmi_ctrl) spin_lock_init(&hdmi_ctrl->hpd_state_lock); + hdmi_ctrl->pending_event = 0; + hdmi_ctrl->handle_pe = false; + atomic_set(&hdmi_ctrl->notification_pending, 0); + init_completion(&hdmi_ctrl->notification_comp); + return 0; fail_create_workq: @@ -3972,9 +4079,11 @@ sysfs_err: static int hdmi_tx_evt_handle_check_param(struct hdmi_tx_ctrl *hdmi_ctrl) { + struct mdss_panel_info *pinfo = &hdmi_ctrl->panel_data.panel_info; int new_vic = -1; int rc = 0; + pinfo->is_ce_mode = false; new_vic = hdmi_panel_get_vic(hdmi_ctrl->evt_arg, &hdmi_ctrl->ds_data); if ((new_vic < 0) || (new_vic > HDMI_VFRMT_MAX)) { @@ -3991,7 +4100,20 @@ static int hdmi_tx_evt_handle_check_param(struct hdmi_tx_ctrl *hdmi_ctrl) rc = 1; DEV_DBG("%s: res change %d ==> %d\n", __func__, hdmi_ctrl->vic, new_vic); + goto done; + } + + /* + * Since bootloader doesn't support DC return 1 + * for panel reconfig. + */ + if (hdmi_ctrl->panel_data.panel_info.cont_splash_enabled + && hdmi_tx_dc_support(hdmi_ctrl)) { + rc = 1; + DEV_DBG("%s: Bitdepth changed\n", __func__); } +done: + pinfo->is_ce_mode = hdmi_util_is_ce_mode(new_vic); end: return rc; } @@ -4012,6 +4134,9 @@ static int hdmi_tx_evt_handle_resume(struct hdmi_tx_ctrl *hdmi_ctrl) goto end; } + if (hdmi_tx_is_cec_wakeup_en(hdmi_ctrl)) + hdmi_ctrl->mdss_util->disable_wake_irq(&hdmi_tx_hw); + end: return rc; } @@ -4070,6 +4195,9 @@ static int hdmi_tx_evt_handle_suspend(struct hdmi_tx_ctrl *hdmi_ctrl) if (!hdmi_ctrl->hpd_state && !hdmi_ctrl->panel_power_on) hdmi_tx_hpd_off(hdmi_ctrl); + if (hdmi_tx_is_cec_wakeup_en(hdmi_ctrl)) + hdmi_ctrl->mdss_util->enable_wake_irq(&hdmi_tx_hw); + hdmi_ctrl->panel_suspend = true; hdmi_tx_cec_device_suspend(hdmi_ctrl); end: @@ -4113,8 +4241,12 @@ end: static int hdmi_tx_evt_handle_close(struct hdmi_tx_ctrl *hdmi_ctrl) { if (hdmi_ctrl->hpd_feature_on && hdmi_ctrl->hpd_initialized && - !hdmi_ctrl->hpd_state) + !hdmi_ctrl->notification_status) { + atomic_set(&hdmi_ctrl->notification_pending, 0); + complete_all(&hdmi_ctrl->notification_comp); + hdmi_tx_hpd_polarity_setup(hdmi_ctrl, HPD_CONNECT_POLARITY); + } return 0; } @@ -4166,6 +4298,15 @@ static int hdmi_tx_post_evt_handle_unblank(struct hdmi_tx_ctrl *hdmi_ctrl) { hdmi_tx_ack_state(hdmi_ctrl, true); hdmi_tx_send_audio_notification(hdmi_ctrl, true); + + atomic_set(&hdmi_ctrl->notification_pending, 0); + complete_all(&hdmi_ctrl->notification_comp); + + if (hdmi_ctrl->handle_pe) { + hdmi_ctrl->handle_pe = false; + hdmi_tx_notify_events(hdmi_ctrl, hdmi_ctrl->pending_event); + } + return 0; } @@ -4182,8 +4323,7 @@ static int hdmi_tx_post_evt_handle_resume(struct hdmi_tx_ctrl *hdmi_ctrl) &hdmi_ctrl->hpd_int_done, HZ/10); if (!timeout) { pr_debug("cable removed during suspend\n"); - hdmi_tx_send_audio_notification(hdmi_ctrl, 0); - hdmi_tx_send_video_notification(hdmi_ctrl, 0, true); + hdmi_tx_notify_events(hdmi_ctrl, 0); } } @@ -4194,8 +4334,7 @@ static int hdmi_tx_post_evt_handle_panel_on(struct hdmi_tx_ctrl *hdmi_ctrl) { if (hdmi_ctrl->panel_suspend) { pr_debug("panel suspend has triggered\n"); - hdmi_tx_send_audio_notification(hdmi_ctrl, 0); - hdmi_tx_send_video_notification(hdmi_ctrl, 0, true); + hdmi_tx_notify_events(hdmi_ctrl, 0); } return 0; @@ -4259,6 +4398,38 @@ static int hdmi_tx_event_handler(struct mdss_panel_data *panel_data, return rc; } +static enum mdss_mdp_csc_type mdss_hdmi_get_csc_type( + struct mdss_panel_data *panel_data) +{ + struct mdss_panel_info *pinfo; + struct mdp_hdr_stream_ctrl *hdr_ctrl; + struct mdp_hdr_stream *hdr_data; + enum mdss_mdp_csc_type csc_type = MDSS_MDP_CSC_RGB2YUV_709L; + + struct hdmi_tx_ctrl *hdmi_ctrl = + hdmi_tx_get_drvdata_from_panel_data(panel_data); + + if (!hdmi_ctrl) { + DEV_ERR("%s: invalid hdmi ctrl data\n", __func__); + goto error; + } + + pinfo = &hdmi_ctrl->panel_data.panel_info; + hdr_ctrl = &hdmi_ctrl->hdr_ctrl; + hdr_data = &hdr_ctrl->hdr_stream; + + if ((hdr_ctrl->hdr_state == HDR_ENABLE) && + (hdr_data->eotf != 0)) + csc_type = MDSS_MDP_CSC_RGB2YUV_2020L; + else if (pinfo->is_ce_mode) + csc_type = MDSS_MDP_CSC_RGB2YUV_709L; + else + csc_type = MDSS_MDP_CSC_RGB2YUV_709FR; + +error: + return csc_type; +} + static int hdmi_tx_register_panel(struct hdmi_tx_ctrl *hdmi_ctrl) { int rc = 0; @@ -4269,6 +4440,7 @@ static int hdmi_tx_register_panel(struct hdmi_tx_ctrl *hdmi_ctrl) } hdmi_ctrl->panel_data.event_handler = hdmi_tx_event_handler; + hdmi_ctrl->panel_data.get_csc_type = mdss_hdmi_get_csc_type; if (!hdmi_ctrl->pdata.primary) hdmi_ctrl->vic = DEFAULT_VIDEO_RESOLUTION; @@ -5005,6 +5177,7 @@ static int hdmi_tx_probe(struct platform_device *pdev) hdmi_ctrl->pdata.primary = true; hdmi_ctrl->vic = vic; hdmi_ctrl->panel_data.panel_info.is_prim_panel = true; + hdmi_ctrl->panel_data.panel_info.is_ce_mode = true; hdmi_ctrl->panel_data.panel_info.cont_splash_enabled = hdmi_ctrl->mdss_util->panel_intf_status(DISPLAY_1, MDSS_PANEL_INTF_HDMI) ? true : false; diff --git a/drivers/video/fbdev/msm/mdss_hdmi_tx.h b/drivers/video/fbdev/msm/mdss_hdmi_tx.h index 92b9d84e9107..7eb749fde97d 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_tx.h +++ b/drivers/video/fbdev/msm/mdss_hdmi_tx.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -93,6 +93,12 @@ struct hdmi_tx_ctrl { struct work_struct fps_work; struct mdp_hdr_stream_ctrl hdr_ctrl; + int pending_event; + bool handle_pe; + atomic_t notification_pending; + struct completion notification_comp; + u32 notification_status; + spinlock_t hpd_state_lock; u32 panel_power_on; @@ -132,6 +138,7 @@ struct hdmi_tx_ctrl { bool power_data_enable[HDMI_TX_MAX_PM]; bool dc_support; bool dc_feature_on; + bool use_bt2020; void (*hdmi_tx_hpd_done)(void *data); void *downstream_data; diff --git a/drivers/video/fbdev/msm/mdss_hdmi_util.c b/drivers/video/fbdev/msm/mdss_hdmi_util.c index 8e854c54bae8..88bceabc4783 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_util.c +++ b/drivers/video/fbdev/msm/mdss_hdmi_util.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, 2019, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -566,6 +566,67 @@ int msm_hdmi_get_timing_info( return ret; } +static u32 cea_mode_alternate_clock(struct msm_hdmi_mode_timing_info *info) +{ + u32 clock = info->pixel_freq; + + if (info->refresh_rate % 6 != 0) + return clock; + + clock = DIV_ROUND_CLOSEST(clock * 1000, 1001); + + return clock; +} + +bool hdmi_util_is_ce_mode(u32 vic) +{ + struct msm_hdmi_mode_timing_info info1 = {0}; + struct msm_hdmi_mode_timing_info info2 = {0}; + u32 mode = 0; + u32 clock1, clock2, clock2_alt; + bool is_ce_mode = false; + + if (vic <= HDMI_VFRMT_640x480p60_4_3) { + is_ce_mode = false; + goto end; + } + + if (vic >= HDMI_VFRMT_720x480p60_4_3 && + vic <= HDMI_VFRMT_3840x2160p60_64_27) { + is_ce_mode = true; + goto end; + } + + msm_hdmi_get_timing_info(&info1, vic); + + for (mode = HDMI_VFRMT_720x480p60_4_3; mode < HDMI_VFRMT_END; mode++) { + + msm_hdmi_get_timing_info(&info2, mode); + + clock1 = info1.pixel_freq; + clock2 = info2.pixel_freq; + clock2_alt = cea_mode_alternate_clock(&info2); + + if ((clock1 == clock2) || (clock1 == clock2_alt)) { + if (info1.active_h == info2.active_h && + info1.front_porch_h == info2.front_porch_h && + info1.pulse_width_h == info2.pulse_width_h && + info1.back_porch_h == info2.back_porch_h && + info1.active_v == info2.active_v && + info1.front_porch_v == info2.front_porch_v && + info1.pulse_width_v == info2.pulse_width_v && + info1.back_porch_v == info2.back_porch_v) { + is_ce_mode = true; + break; + } + } + continue; + } +end: + pr_debug("%s: vic = %d, is_ce_mode = %d\n", __func__, vic, is_ce_mode); + return is_ce_mode; +} + int hdmi_get_supported_mode(struct msm_hdmi_mode_timing_info *info, struct hdmi_util_ds_data *ds_data, u32 mode) { diff --git a/drivers/video/fbdev/msm/mdss_hdmi_util.h b/drivers/video/fbdev/msm/mdss_hdmi_util.h index fe554f8e9e67..2f752dc79c7a 100644 --- a/drivers/video/fbdev/msm/mdss_hdmi_util.h +++ b/drivers/video/fbdev/msm/mdss_hdmi_util.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -490,6 +490,7 @@ static inline int hdmi_tx_get_h_total(const struct msm_hdmi_mode_timing_info *t) return 0; } +bool hdmi_util_is_ce_mode(u32 vic); /* video timing related utility routines */ int hdmi_get_video_id_code(struct msm_hdmi_mode_timing_info *timing_in, struct hdmi_util_ds_data *ds_data); diff --git a/drivers/video/fbdev/msm/mdss_mdp.c b/drivers/video/fbdev/msm/mdss_mdp.c index a77e5c4435bb..98172233b5aa 100644 --- a/drivers/video/fbdev/msm/mdss_mdp.c +++ b/drivers/video/fbdev/msm/mdss_mdp.c @@ -1,7 +1,7 @@ /* * MDSS MDP Interface (used by framebuffer core) * - * Copyright (c) 2007-2018, The Linux Foundation. All rights reserved. + * Copyright (c) 2007-2019, The Linux Foundation. All rights reserved. * Copyright (C) 2007 Google Incorporated * * This software is licensed under the terms of the GNU General Public @@ -3117,7 +3117,8 @@ static int mdss_mdp_probe(struct platform_device *pdev) MDSS_MDP_REG_SPLIT_DISPLAY_EN); if (intf_sel != 0) { for (i = 0; i < 4; i++) - num_of_display_on += ((intf_sel >> i*8) & 0x000000FF); + num_of_display_on += + (((intf_sel >> i*8) & 0x000000FF) ? 1 : 0); /* * For split display enabled - DSI0, DSI1 interfaces are diff --git a/drivers/video/fbdev/msm/mdss_mdp.h b/drivers/video/fbdev/msm/mdss_mdp.h index 90a38b79e561..9c93c500d127 100644 --- a/drivers/video/fbdev/msm/mdss_mdp.h +++ b/drivers/video/fbdev/msm/mdss_mdp.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. + * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -271,10 +271,12 @@ enum mdss_mdp_csc_type { MDSS_MDP_CSC_RGB2YUV_601L, MDSS_MDP_CSC_RGB2YUV_601FR, MDSS_MDP_CSC_RGB2YUV_709L, + MDSS_MDP_CSC_RGB2YUV_709FR, MDSS_MDP_CSC_RGB2YUV_2020L, MDSS_MDP_CSC_RGB2YUV_2020FR, MDSS_MDP_CSC_YUV2YUV, MDSS_MDP_CSC_RGB2RGB, + MDSS_MDP_CSC_RGB2RGB_L, MDSS_MDP_MAX_CSC }; diff --git a/drivers/video/fbdev/msm/mdss_mdp_cdm.c b/drivers/video/fbdev/msm/mdss_mdp_cdm.c index 10928e6bceaa..7fede8fa1709 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_cdm.c +++ b/drivers/video/fbdev/msm/mdss_mdp_cdm.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2014-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -116,6 +116,7 @@ struct mdss_mdp_cdm *mdss_mdp_cdm_init(struct mdss_mdp_ctl *ctl, u32 intf_type) cdm->out_intf = intf_type; cdm->is_bypassed = true; + cdm->is_only_clamped = false; memset(&cdm->setup, 0x0, sizeof(struct mdp_cdm_cfg)); return cdm; @@ -137,11 +138,22 @@ static int mdss_mdp_cdm_csc_setup(struct mdss_mdp_cdm *cdm, if ((data->csc_type == MDSS_MDP_CSC_RGB2YUV_601L) || (data->csc_type == MDSS_MDP_CSC_RGB2YUV_601FR) || - (data->csc_type == MDSS_MDP_CSC_RGB2YUV_709L)) { + (data->csc_type == MDSS_MDP_CSC_RGB2YUV_709L) || + (data->csc_type == MDSS_MDP_CSC_RGB2YUV_709FR) || + (data->csc_type == MDSS_MDP_CSC_RGB2YUV_2020L) || + (data->csc_type == MDSS_MDP_CSC_RGB2YUV_2020FR)) { op_mode |= BIT(2); /* DST_DATA_FORMAT = YUV */ op_mode &= ~BIT(1); /* SRC_DATA_FORMAT = RGB */ op_mode |= BIT(0); /* EN = 1 */ cdm->is_bypassed = false; + } else if ((cdm->out_intf == MDP_CDM_CDWN_OUTPUT_HDMI) && + ((data->csc_type == MDSS_MDP_CSC_RGB2RGB_L) || + (data->csc_type == MDSS_MDP_CSC_RGB2RGB))) { + op_mode &= ~BIT(2); /* DST_DATA_FORMAT = RGB */ + op_mode &= ~BIT(1); /* SRC_DATA_FORMAT = RGB */ + op_mode |= BIT(0); /* EN = 1 */ + cdm->is_bypassed = false; + cdm->is_only_clamped = true; } else { op_mode = 0; cdm->is_bypassed = true; @@ -299,8 +311,11 @@ static int mdss_mdp_cdm_out_packer_setup(struct mdss_mdp_cdm *cdm, } opmode &= ~0x6; opmode |= (fmt->chroma_sample << 1); - if (!cdm->is_bypassed) + if (!cdm->is_bypassed) { cdm_enable |= BIT(19); + if (cdm->is_only_clamped) + opmode = 0; + } } else { /* Disable HDMI pacler for WB */ diff --git a/drivers/video/fbdev/msm/mdss_mdp_cdm.h b/drivers/video/fbdev/msm/mdss_mdp_cdm.h index 3b7fdced6623..b2897d41044d 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_cdm.h +++ b/drivers/video/fbdev/msm/mdss_mdp_cdm.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014,2016, The Linux Foundation. All rights reserved. + * Copyright (c) 2014-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -60,6 +60,7 @@ struct mdss_mdp_cdm { bool is_bypassed; struct mdp_cdm_cfg setup; struct completion free_comp; + bool is_only_clamped; }; struct mdss_mdp_cdm *mdss_mdp_cdm_init(struct mdss_mdp_ctl *ctl, diff --git a/drivers/video/fbdev/msm/mdss_mdp_intf_video.c b/drivers/video/fbdev/msm/mdss_mdp_intf_video.c index e27f6bc49892..29fe0f861593 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_intf_video.c +++ b/drivers/video/fbdev/msm/mdss_mdp_intf_video.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -103,6 +103,9 @@ struct mdss_mdp_video_ctx { u32 intf_irq_mask; spinlock_t mdss_mdp_video_lock; spinlock_t mdss_mdp_intf_intr_lock; + + enum mdss_mdp_csc_type cdm_csc_type; + bool yuv_conv; }; static void mdss_mdp_fetch_start_config(struct mdss_mdp_video_ctx *ctx, @@ -1023,6 +1026,8 @@ static int mdss_mdp_video_ctx_stop(struct mdss_mdp_ctl *ctl, mdss_mdp_set_intf_intr_callback(ctx, MDSS_MDP_INTF_IRQ_PROG_LINE, NULL, NULL); + ctx->yuv_conv = false; + ctx->ref_cnt--; end: mutex_unlock(&ctl->offlock); @@ -1645,6 +1650,75 @@ end: return rc; } +static int mdss_mdp_update_csc_matrix(struct mdss_mdp_ctl *ctl) +{ + struct mdss_mdp_video_ctx *ctx; + struct mdss_data_type *mdata; + struct mdss_panel_data *pdata; + struct mdss_panel_info *pinfo; + struct mdss_mdp_format_params *fmt; + enum mdss_mdp_csc_type csc_type; + int rc = 0; + + ctx = (struct mdss_mdp_video_ctx *) ctl->intf_ctx[MASTER_CTX]; + if (!ctx) { + pr_err("%s: invalid ctx\n", __func__); + return -ENODEV; + } + + mdata = ctl->mdata; + pdata = ctl->panel_data; + pinfo = &pdata->panel_info; + + if (!mdss_mdp_is_cdm_supported(mdata, ctl->intf_type, 0)) { + pr_debug("%s: CDM is not supported\n", __func__); + goto error; + } + + if (IS_ERR_OR_NULL(ctl->cdm)) { + pr_debug("%s: CDM is not initialized\n", __func__); + goto error; + } + + if (!ctx->yuv_conv) { + pr_debug("%s: CDM not configured to convert to YUV yet\n", + __func__); + goto error; + } + + fmt = mdss_mdp_get_format_params(pinfo->out_format); + if (fmt->is_yuv) { + csc_type = MDSS_MDP_CSC_RGB2YUV_709L; + if (pdata->get_csc_type) + csc_type = pdata->get_csc_type(pdata); + + pr_debug("cdm_csc_type = %d csc_type = %d\n", + ctx->cdm_csc_type, csc_type); + if (ctx->cdm_csc_type != csc_type) { + + mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON); + rc = mdss_mdp_csc_setup(MDSS_MDP_BLOCK_CDM, + ctl->cdm->num, csc_type); + mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF); + + if (rc) { + pr_err("%s: CDM CSC setup failed, rc = %d\n", + __func__, rc); + goto error; + } + + pr_debug("%s: updating csc %d to %d\n", __func__, + ctx->cdm_csc_type, csc_type); + + ctx->cdm_csc_type = csc_type; + pinfo->csc_type = csc_type; + ctl->flush_bits |= BIT(26); + } + } +error: + return rc; +} + static int mdss_mdp_video_display(struct mdss_mdp_ctl *ctl, void *arg) { struct mdss_mdp_video_ctx *ctx; @@ -1736,6 +1810,8 @@ static int mdss_mdp_video_display(struct mdss_mdp_ctl *ctl, void *arg) CTL_INTF_EVENT_FLAG_DEFAULT); } + rc = mdss_mdp_update_csc_matrix(ctl); + rc = mdss_mdp_video_avr_trigger_setup(ctl); if (rc) { pr_err("avr trigger setup failed\n"); @@ -1955,10 +2031,24 @@ static int mdss_mdp_video_cdm_setup(struct mdss_mdp_cdm *cdm, { struct mdp_cdm_cfg setup; - if (fmt->is_yuv) - setup.csc_type = MDSS_MDP_CSC_RGB2YUV_601FR; - else - setup.csc_type = MDSS_MDP_CSC_RGB2RGB; + if (fmt->is_yuv) { + if (pinfo->is_ce_mode) { + if (pinfo->yres < 720) + setup.csc_type = MDSS_MDP_CSC_RGB2YUV_601L; + else + setup.csc_type = MDSS_MDP_CSC_RGB2YUV_709L; + } else { + if (pinfo->yres < 720) + setup.csc_type = MDSS_MDP_CSC_RGB2YUV_601FR; + else + setup.csc_type = MDSS_MDP_CSC_RGB2YUV_709FR; + } + } else { + if (pinfo->is_ce_mode) + setup.csc_type = MDSS_MDP_CSC_RGB2RGB_L; + else + setup.csc_type = MDSS_MDP_CSC_RGB2RGB; + } switch (fmt->chroma_sample) { case MDSS_MDP_CHROMA_RGB: @@ -1984,8 +2074,10 @@ static int mdss_mdp_video_cdm_setup(struct mdss_mdp_cdm *cdm, return -EINVAL; } + pinfo->csc_type = setup.csc_type; + setup.out_format = pinfo->out_format; - setup.mdp_csc_bit_depth = MDP_CDM_CSC_8BIT; + setup.mdp_csc_bit_depth = MDP_CDM_CSC_10BIT; setup.output_width = pinfo->xres + pinfo->lcdc.xres_pad; setup.output_height = pinfo->yres + pinfo->lcdc.yres_pad; return mdss_mdp_cdm_setup(cdm, &setup); @@ -2120,6 +2212,7 @@ static int mdss_mdp_video_ctx_setup(struct mdss_mdp_ctl *ctl, } if (mdss_mdp_is_cdm_supported(mdata, ctl->intf_type, 0)) { + bool needs_qr_conversion = false; fmt = mdss_mdp_get_format_params(pinfo->out_format); if (!fmt) { @@ -2127,7 +2220,11 @@ static int mdss_mdp_video_ctx_setup(struct mdss_mdp_ctl *ctl, pinfo->out_format); return -EINVAL; } - if (fmt->is_yuv) { + + if (ctl->intf_type == MDSS_INTF_HDMI && pinfo->is_ce_mode) + needs_qr_conversion = true; + + if (fmt->is_yuv || needs_qr_conversion) { ctl->cdm = mdss_mdp_cdm_init(ctl, MDP_CDM_CDWN_OUTPUT_HDMI); if (!IS_ERR_OR_NULL(ctl->cdm)) { @@ -2137,6 +2234,10 @@ static int mdss_mdp_video_ctx_setup(struct mdss_mdp_ctl *ctl, __func__); return -EINVAL; } + if (fmt->is_yuv) + ctx->yuv_conv = true; + + ctx->cdm_csc_type = pinfo->csc_type; ctl->flush_bits |= BIT(26); } else { pr_err("%s: failed to initialize cdm\n", diff --git a/drivers/video/fbdev/msm/mdss_mdp_pp.c b/drivers/video/fbdev/msm/mdss_mdp_pp.c index 5b9798e2c24e..79e1277c9ca6 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_pp.c +++ b/drivers/video/fbdev/msm/mdss_mdp_pp.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -120,6 +120,18 @@ struct mdp_csc_cfg mdp_csc_8bit_convert[MDSS_MDP_MAX_CSC] = { { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff,}, { 0x0010, 0x00eb, 0x0010, 0x00f0, 0x0010, 0x00f0,}, }, + [MDSS_MDP_CSC_RGB2YUV_709FR] = { + 0, + { + 0x006d, 0x016e, 0x0025, + 0xffc5, 0xff3b, 0x0100, + 0x0100, 0xff17, 0xffe9 + }, + { 0x0, 0x0, 0x0,}, + { 0x0, 0x0080, 0x0080,}, + { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff,}, + { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff,}, + }, [MDSS_MDP_CSC_RGB2YUV_2020L] = { 0, { @@ -168,6 +180,18 @@ struct mdp_csc_cfg mdp_csc_8bit_convert[MDSS_MDP_MAX_CSC] = { { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff,}, { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff,}, }, + [MDSS_MDP_CSC_RGB2RGB_L] = { + 0, + { + 0x01b7, 0x0000, 0x0000, + 0x0000, 0x01b7, 0x0000, + 0x0000, 0x0000, 0x01b7, + }, + { 0x0, 0x0, 0x0,}, + { 0x10, 0x10, 0x10,}, + { 0x0, 0xff, 0x0, 0xff, 0x0, 0xff,}, + { 0x10, 0xeb, 0x10, 0xeb, 0x10, 0xeb,}, + }, }; struct mdp_csc_cfg mdp_csc_10bit_convert[MDSS_MDP_MAX_CSC] = { @@ -267,6 +291,18 @@ struct mdp_csc_cfg mdp_csc_10bit_convert[MDSS_MDP_MAX_CSC] = { { 0x0, 0x3ff, 0x0, 0x3ff, 0x0, 0x3ff,}, { 0x0040, 0x03ac, 0x0040, 0x03c0, 0x0040, 0x03c0,}, }, + [MDSS_MDP_CSC_RGB2YUV_709FR] = { + 0, + { + 0x006d, 0x016e, 0x0025, + 0xffc5, 0xff3b, 0x0100, + 0x0100, 0xff17, 0xffe9 + }, + { 0x0, 0x0, 0x0,}, + { 0x0, 0x0200, 0x0200,}, + { 0x0, 0x3ff, 0x0, 0x3ff, 0x0, 0x3ff,}, + { 0x0, 0x3ff, 0x0, 0x3ff, 0x0, 0x3ff,}, + }, [MDSS_MDP_CSC_RGB2YUV_2020L] = { 0, { @@ -315,6 +351,18 @@ struct mdp_csc_cfg mdp_csc_10bit_convert[MDSS_MDP_MAX_CSC] = { { 0x0, 0x3ff, 0x0, 0x3ff, 0x0, 0x3ff,}, { 0x0, 0x3ff, 0x0, 0x3ff, 0x0, 0x3ff,}, }, + [MDSS_MDP_CSC_RGB2RGB_L] = { + 0, + { + 0x01b7, 0x0000, 0x0000, + 0x0000, 0x01b7, 0x0000, + 0x0000, 0x0000, 0x01b7, + }, + { 0x0, 0x0, 0x0,}, + { 0x40, 0x40, 0x40,}, + { 0x0, 0x3ff, 0x0, 0x3ff, 0x0, 0x3ff,}, + { 0x40, 0x3ac, 0x40, 0x3ac, 0x40, 0x3ac,}, + }, }; static struct mdss_mdp_format_params dest_scaler_fmt = { diff --git a/drivers/video/fbdev/msm/mdss_mdp_splash_logo.c b/drivers/video/fbdev/msm/mdss_mdp_splash_logo.c index 5df1ed7c89a5..b55a6824ffc1 100644 --- a/drivers/video/fbdev/msm/mdss_mdp_splash_logo.c +++ b/drivers/video/fbdev/msm/mdss_mdp_splash_logo.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, 2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -286,8 +286,9 @@ int mdss_mdp_splash_cleanup(struct msm_fb_data_type *mfd, /* 1-to-1 mapping */ mdss_mdp_splash_iommu_attach(mfd); - if (use_borderfill && mdp5_data->handoff && - !mfd->splash_info.iommu_dynamic_attached) { + if ((use_borderfill && mdp5_data->handoff && + !mfd->splash_info.iommu_dynamic_attached) || + mfd->force_null_commit) { /* * Set up border-fill on the handed off pipes. * This is needed to ensure that there are no memory diff --git a/drivers/video/fbdev/msm/mdss_panel.h b/drivers/video/fbdev/msm/mdss_panel.h index f8993f3774e6..1e0ae618b501 100644 --- a/drivers/video/fbdev/msm/mdss_panel.h +++ b/drivers/video/fbdev/msm/mdss_panel.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2008-2018, The Linux Foundation. All rights reserved. +/* Copyright (c) 2008-2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -800,6 +800,8 @@ struct mdss_panel_info { u32 rst_seq_len; u32 vic; /* video identification code */ u32 deep_color; + bool is_ce_mode; /* CE video format */ + u8 csc_type; struct mdss_rect roi; struct mdss_dsi_dual_pu_roi dual_roi; int pwm_pmic_gpio; @@ -990,6 +992,7 @@ struct mdss_panel_data { * and teardown. */ int (*event_handler) (struct mdss_panel_data *pdata, int e, void *arg); + enum mdss_mdp_csc_type (*get_csc_type)(struct mdss_panel_data *pdata); struct device_node *(*get_fb_node)(struct platform_device *pdev); struct list_head timings_list; diff --git a/include/uapi/media/msmb_isp.h b/include/uapi/media/msmb_isp.h index 40e5c273011f..b1c02f297e91 100644 --- a/include/uapi/media/msmb_isp.h +++ b/include/uapi/media/msmb_isp.h @@ -33,6 +33,8 @@ struct isp_kstate { uint32_t kernel_sofid; uint32_t drop_reconfig; uint32_t vfeid; + uint32_t dual_cam_drop_detected; + uint32_t dual_cam_drop; }; enum ISP_START_PIXEL_PATTERN { diff --git a/net/ipc_router/ipc_router_security.c b/net/ipc_router/ipc_router_security.c index 539c72f8158a..ab4e5003c05d 100644 --- a/net/ipc_router/ipc_router_security.c +++ b/net/ipc_router/ipc_router_security.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2014,2020, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -101,7 +101,7 @@ EXPORT_SYMBOL(check_permissions); int msm_ipc_config_sec_rules(void *arg) { struct config_sec_rules_args sec_rules_arg; - struct security_rule *rule, *temp_rule; + struct security_rule *rule; int key; size_t kgroup_info_sz; int ret; @@ -117,6 +117,10 @@ int msm_ipc_config_sec_rules(void *arg) if (ret) return -EFAULT; + /* Default rule change from config util not allowed */ + if (sec_rules_arg.service_id == ALL_SERVICE) + return -EINVAL; + if (sec_rules_arg.num_group_info <= 0) return -EINVAL; @@ -174,21 +178,11 @@ int msm_ipc_config_sec_rules(void *arg) key = rule->service_id & (SEC_RULES_HASH_SZ - 1); down_write(&security_rules_lock_lha4); - if (rule->service_id == ALL_SERVICE) { - temp_rule = list_first_entry(&security_rules[key], - struct security_rule, list); - list_del(&temp_rule->list); - kfree(temp_rule->group_id); - kfree(temp_rule); - } list_add_tail(&rule->list, &security_rules[key]); up_write(&security_rules_lock_lha4); - if (rule->service_id == ALL_SERVICE) - msm_ipc_sync_default_sec_rule((void *)rule); - else - msm_ipc_sync_sec_rule(rule->service_id, rule->instance_id, - (void *)rule); + msm_ipc_sync_sec_rule(rule->service_id, + rule->instance_id, (void *)rule); return 0; } |