// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2021-2024, Qualcomm Innovation Center, Inc. All rights reserved. * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include #include #include #include #include #include #include #if !defined(CONFIG_SECDP) #include #endif #include #include #include #include "sde_connector.h" #include "msm_drv.h" #include "dp_hpd.h" #include "dp_parser.h" #include "dp_power.h" #include "dp_catalog.h" #include "dp_aux.h" #include "dp_link.h" #include "dp_panel.h" #include "dp_ctrl.h" #include "dp_audio.h" #include "dp_display.h" #include "sde_hdcp.h" #include "dp_debug.h" #include "dp_pll.h" #include "sde_dbg.h" #ifdef CONFIG_UML #include "kunit_test/dp_kunit_macro.h" #endif #if defined(CONFIG_SECDP) #include #include #include #include #include #include #include "secdp.h" #include "secdp_sysfs.h" #if defined(CONFIG_SECDP_BIGDATA) #include #endif /*#undef CONFIG_SECDP_SWITCH*/ #if defined(CONFIG_SECDP_SWITCH) #include static struct switch_dev switch_secdp_msg = { .name = "secdp_msg", }; #endif extern int dwc3_msm_set_dp_mode_for_ss(bool dp_connected); #endif/*CONFIG_SECDP*/ #define DRM_DP_IPC_NUM_PAGES 10 #define DP_MST_DEBUG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__) #define dp_display_state_show(x) { \ DP_ERR("%s: state (0x%x): %s\n", x, dp->state, \ dp_display_state_name(dp->state)); \ SDE_EVT32_EXTERNAL(dp->state); } #define dp_display_state_warn(x) { \ DP_WARN("%s: state (0x%x): %s\n", x, dp->state, \ dp_display_state_name(dp->state)); \ SDE_EVT32_EXTERNAL(dp->state); } #define dp_display_state_log(x) { \ DP_DEBUG("%s: state (0x%x): %s\n", x, dp->state, \ dp_display_state_name(dp->state)); \ SDE_EVT32_EXTERNAL(dp->state); } #define dp_display_state_is(x) (dp->state & (x)) #define dp_display_state_add(x) { \ (dp->state |= (x)); \ dp_display_state_log("add "#x); } #define dp_display_state_remove(x) { \ (dp->state &= ~(x)); \ dp_display_state_log("remove "#x); } #define MAX_TMDS_CLOCK_HDMI_1_4 340000 enum dp_display_states { DP_STATE_DISCONNECTED = 0, DP_STATE_CONFIGURED = BIT(0), DP_STATE_INITIALIZED = BIT(1), DP_STATE_READY = BIT(2), DP_STATE_CONNECTED = BIT(3), DP_STATE_CONNECT_NOTIFIED = BIT(4), DP_STATE_DISCONNECT_NOTIFIED = BIT(5), DP_STATE_ENABLED = BIT(6), DP_STATE_SUSPENDED = BIT(7), DP_STATE_ABORTED = BIT(8), DP_STATE_HDCP_ABORTED = BIT(9), DP_STATE_SRC_PWRDN = BIT(10), DP_STATE_TUI_ACTIVE = BIT(11), }; static char *dp_display_state_name(enum dp_display_states state) { static char buf[SZ_1K]; u32 len = 0; memset(buf, 0, SZ_1K); if (state & DP_STATE_CONFIGURED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "CONFIGURED"); if (state & DP_STATE_INITIALIZED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "INITIALIZED"); if (state & DP_STATE_READY) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "READY"); if (state & DP_STATE_CONNECTED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "CONNECTED"); if (state & DP_STATE_CONNECT_NOTIFIED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "CONNECT_NOTIFIED"); if (state & DP_STATE_DISCONNECT_NOTIFIED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "DISCONNECT_NOTIFIED"); if (state & DP_STATE_ENABLED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "ENABLED"); if (state & DP_STATE_SUSPENDED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "SUSPENDED"); if (state & DP_STATE_ABORTED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "ABORTED"); if (state & DP_STATE_HDCP_ABORTED) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "HDCP_ABORTED"); if (state & DP_STATE_SRC_PWRDN) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "SRC_PWRDN"); if (state & DP_STATE_TUI_ACTIVE) len += scnprintf(buf + len, sizeof(buf) - len, "|%s|", "TUI_ACTIVE"); if (!strlen(buf)) return "DISCONNECTED"; return buf; } static struct dp_display *g_dp_display; #define HPD_STRING_SIZE 30 struct dp_hdcp_dev { void *fd; struct sde_hdcp_ops *ops; enum sde_hdcp_version ver; }; struct dp_hdcp { void *data; struct sde_hdcp_ops *ops; u32 source_cap; struct dp_hdcp_dev dev[HDCP_VERSION_MAX]; }; struct dp_mst { bool mst_active; bool drm_registered; struct dp_mst_drm_cbs cbs; }; struct dp_display_private { char *name; int irq; enum drm_connector_status cached_connector_status; enum dp_display_states state; enum dp_aux_switch_type switch_type; struct platform_device *pdev; struct device_node *aux_switch_node; bool aux_switch_ready; struct dp_aux_bridge *aux_bridge; struct dentry *root; struct completion notification_comp; struct completion attention_comp; struct dp_hpd *hpd; struct dp_parser *parser; struct dp_power *power; struct dp_catalog *catalog; struct dp_aux *aux; struct dp_link *link; struct dp_panel *panel; struct dp_ctrl *ctrl; struct dp_debug *debug; struct dp_pll *pll; struct dp_panel *active_panels[DP_STREAM_MAX]; struct dp_hdcp hdcp; struct dp_hpd_cb hpd_cb; struct dp_display_mode mode; struct dp_display dp_display; struct msm_drm_private *priv; struct workqueue_struct *wq; struct delayed_work hdcp_cb_work; struct work_struct connect_work; struct work_struct attention_work; struct work_struct disconnect_work; struct mutex session_lock; struct mutex accounting_lock; bool hdcp_delayed_off; bool no_aux_switch; u32 active_stream_cnt; struct dp_mst mst; u32 tot_dsc_blks_in_use; u32 tot_lm_blks_in_use; bool process_hpd_connect; struct dev_pm_qos_request pm_qos_req[NR_CPUS]; bool pm_qos_requested; #if !defined(CONFIG_SECDP) struct notifier_block usb_nb; #else struct secdp_misc sec; #endif }; static const struct of_device_id dp_dt_match[] = { {.compatible = "qcom,dp-display"}, {} }; #if defined(CONFIG_SECDP) static void dp_audio_enable(struct dp_display_private *dp, bool enable); #ifndef SECDP_USE_WAKELOCK static void secdp_init_wakelock(struct dp_display_private *dp) { do {} while (0); } static void secdp_destroy_wakelock(struct dp_display_private *dp) { do {} while (0); } static void secdp_set_wakelock(struct dp_display_private *dp, bool en) { do {} while (0); } #else static void secdp_init_wakelock(struct dp_display_private *dp) { dp->sec.ws = wakeup_source_register(&dp->pdev->dev, "secdp_ws"); } static void secdp_destroy_wakelock(struct dp_display_private *dp) { wakeup_source_unregister(dp->sec.ws); } static void secdp_set_wakelock(struct dp_display_private *dp, bool en) { struct wakeup_source *ws = dp->sec.ws; bool active_before = ws->active; if (en) __pm_stay_awake(ws); else __pm_relax(ws); DP_DEBUG("en:%d, active:%d->%d\n", en, active_before, ws->active); } #endif static int secdp_param_lpcharge; module_param(secdp_param_lpcharge, int, 0444); bool secdp_get_lpm_mode(struct secdp_misc *sec) { if (!sec) { DP_INFO("SECDP is not ready yet\n"); return false; } DP_INFO("lpcharge:%d\n", sec->lpm_booting); return sec->lpm_booting; } static void secdp_send_poor_connection_event(struct dp_display_private *dp, bool edid_fail) { DP_INFO("poor connection++ %d\n", edid_fail); if (!edid_fail) dp->link->poor_connection = true; #if defined(CONFIG_SECDP_SWITCH) switch_set_state(&switch_secdp_msg, 1); switch_set_state(&switch_secdp_msg, 0); #else { struct drm_device *dev = NULL; struct drm_connector *connector; char *envp[3]; connector = dp->dp_display.base_connector; if (!connector) { DP_ERR("connector not set\n"); return; } dev = connector->dev; envp[0] = "DEVPATH=/devices/virtual/switch/secdp_msg"; envp[1] = "SWITCH_STATE=1"; envp[2] = NULL; DP_DEBUG("[%s]:[%s]\n", envp[0], envp[1]); kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); } #endif dp->sec.dex.prev = dp->sec.dex.curr = DEX_DISABLED; } static void secdp_show_clk_status(struct dp_display_private *dp) { struct dp_power *dp_power; bool core, link, stream0, stream1; if (!dp || !dp->power) return; dp_power = dp->power; core = dp_power->clk_status(dp_power, DP_CORE_PM); link = dp_power->clk_status(dp_power, DP_LINK_PM); stream0 = dp_power->clk_status(dp_power, DP_STREAM0_PM); stream1 = dp_power->clk_status(dp_power, DP_STREAM1_PM); DP_DEBUG("core:%d link:%d strm0:%d strm1:%d\n", core, link, stream0, stream1); } /** check if dp has powered on */ bool secdp_get_power_status(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); return dp_display_state_is(DP_STATE_ENABLED); } /** check if dp cable has connected or not */ bool secdp_get_cable_status(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); return dp->sec.cable_connected; } /** check if hpd high has come or not */ int secdp_get_hpd_status(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); return atomic_read(&dp->sec.hpd.val); } #define DP_HAL_INIT_TIME 30/*sec*/ /** * retval wait if booting time has not yet passed over DP_HAL_INIT_TIME * how long to wait [DP_HAL_INIT_TIME - curr_time] * retval 0 otherwise */ static int secdp_check_boot_time(void) { int wait = 0; u64 curr_time; unsigned long nsec; curr_time = local_clock(); nsec = do_div(curr_time, 1000000000); if ((unsigned long)curr_time < DP_HAL_INIT_TIME) wait = DP_HAL_INIT_TIME - (unsigned long)curr_time; DP_INFO("curr_time: %lu[s], wait: %d\n", (unsigned long)curr_time, wait); return wait; } /** * read dongle's information */ int secdp_read_branch_revision(struct dp_display_private *dp) { struct secdp_adapter *adapter; struct drm_dp_aux *drm_aux; char *ieee_oui, *devid_str, *fw_ver; int rlen = 0; if (!dp || !dp->aux || !dp->aux->drm_aux) { DP_ERR("invalid param\n"); goto end; } drm_aux = dp->aux->drm_aux; adapter = &dp->sec.adapter; ieee_oui = adapter->ieee_oui; devid_str = adapter->devid_str; fw_ver = adapter->fw_ver; rlen = drm_dp_dpcd_read(drm_aux, DPCD_IEEE_OUI, ieee_oui, 3); if (rlen < 3) { DP_ERR("oui read fail:%d\n", rlen); goto end; } DP_INFO("oui:%02x%02x%02x\n", ieee_oui[0], ieee_oui[1], ieee_oui[2]); rlen = drm_dp_dpcd_read(drm_aux, DPCD_DEVID_STR, devid_str, 6); if (rlen < 6) { DP_ERR("devid read fail:%d\n", rlen); goto end; } print_hex_dump(KERN_DEBUG, "devid:", DUMP_PREFIX_NONE, 16, 1, devid_str, 6, true); secdp_logger_hex_dump(devid_str, "devid:", 6); rlen = drm_dp_dpcd_read(drm_aux, DPCD_BRANCH_HW_REV, fw_ver, LEN_BRANCH_REV); if (rlen < LEN_BRANCH_REV) { DP_ERR("fw_ver read fail:%d\n", rlen); goto end; } DP_INFO("branch revision: HW:0x%X, SW:0x%X,0x%X\n", fw_ver[0], fw_ver[1], fw_ver[2]); #if defined(CONFIG_SECDP_BIGDATA) secdp_bigdata_save_item(BD_ADAPTER_HWID, fw_ver[0]); secdp_bigdata_save_item(BD_ADAPTER_FWVER, (fw_ver[1] << 8) | fw_ver[2]); #endif end: return rlen; } void secdp_clear_branch_info(struct dp_display_private *dp) { int i; char *fw_ver; if (!dp) goto end; fw_ver = dp->sec.adapter.fw_ver; for (i = 0; i < LEN_BRANCH_REV; i++) fw_ver[i] = 0; end: return; } /** * get max dex resolution of current dongle/cable. * it's decided by secdp_check_adapter_type() at connection moment. */ static enum dex_support_res_t secdp_get_dex_res(struct dp_display_private *dp) { enum dex_support_res_t res = dp->sec.dex.res; if (dp->sec.dex.adapter_check_skip) res = DEX_RES_MAX; return res; } /** * check if dex is running */ static bool secdp_check_dex_mode(struct dp_display_private *dp) { bool mode = false; if (secdp_get_dex_res(dp) == DEX_RES_NOT_SUPPORT) goto end; if (dp->sec.dex.setting_ui == DEX_DISABLED && dp->sec.dex.curr == DEX_DISABLED) goto end; mode = true; end: return mode; } bool secdp_adapter_check_parade(struct secdp_misc *sec) { struct secdp_adapter *adapter = &sec->adapter; if (adapter->ieee_oui[0] == 0x00 && adapter->ieee_oui[1] == 0x1c && adapter->ieee_oui[2] == 0xf8) return true; return false; } bool secdp_adapter_check_ps176(struct secdp_misc *sec) { struct secdp_adapter *adapter = &sec->adapter; if (adapter->devid_str[0] == '1' && adapter->devid_str[1] == '7' && adapter->devid_str[2] == '6') return true; return false; } bool secdp_adapter_check_ps176_legacy(struct secdp_misc *sec) { struct secdp_adapter *adapter = &sec->adapter; if (!secdp_adapter_check_parade(sec)) return false; if (!secdp_adapter_check_ps176(sec)) return false; if (adapter->fw_ver[1] != 0x07) return false; if (adapter->fw_ver[2] <= 0x40) return false; return true; } bool secdp_adapter_check_realtek(struct secdp_misc *sec) { struct secdp_adapter *adapter = &sec->adapter; if (adapter->ieee_oui[0] == 0x00 && adapter->ieee_oui[1] == 0xe0 && adapter->ieee_oui[2] == 0x4c) return true; return false; } bool secdp_adapter_is_legacy(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec = &dp->sec; struct secdp_adapter *adapter = &dp->sec.adapter; bool rc = false; if (adapter->ss_legacy) { DP_INFO("ss_legacy\n"); return true; } if (secdp_adapter_check_realtek(sec)) { DP_INFO("realtek_legacy\n"); return true; } rc = secdp_adapter_check_ps176_legacy(sec); DP_INFO("ps176_legacy:%d\n", rc); return rc; } struct drm_connector *secdp_get_connector(void) { struct dp_display *dp_disp = g_dp_display; struct drm_connector *connector = NULL; if (dp_disp) connector = dp_disp->base_connector; return connector; } static int secdp_reboot_cb(struct notifier_block *nb, unsigned long action, void *data) { struct secdp_misc *sec = container_of(nb, struct secdp_misc, reboot_nb); if (IS_ERR_OR_NULL(sec)) { DP_ERR("dp is null!\n"); goto end; } if (!secdp_get_cable_status()) { DP_DEBUG("cable is out\n"); goto end; } DP_DEBUG("reboot:%d\n", sec->reboot); sec->reboot = true; #ifndef SECDP_TEST_HDCP2P2_REAUTH msleep(300); #endif end: return NOTIFY_OK; } bool secdp_get_reboot_status(void) { struct dp_display_private *dp; bool ret = false; if (!g_dp_display) { DP_DEBUG("dp display not initialized\n"); goto end; } dp = container_of(g_dp_display, struct dp_display_private, dp_display); if (IS_ERR_OR_NULL(dp)) { DP_ERR("dp is null!\n"); goto end; } DP_DEBUG("reboot:%d\n", dp->sec.reboot); ret = dp->sec.reboot; #ifdef SECDP_TEST_HDCP2P2_REAUTH ret = false; DP_DEBUG("[SECDP_TEST_HDCP2P2_REAUTH]\n"); #endif end: return ret; } /** * convert VID/PID string to uint in hexadecimal * @tok [in] 4bytes, char * @result [inout] converted value */ static int _secdp_strtoint(char *tok, uint *result) { int ret = 0, len; if (!tok || !result) { DP_ERR("invalid arg!\n"); ret = -EINVAL; goto end; } len = strlen(tok); if (len == 5 && tok[len - 1] == 0xa/*LF*/) { /* continue since it's ended with line feed */ } else if ((len == 4 && tok[len - 1] == 0xa/*LF*/) || (len != 4)) { DP_ERR("wrong! tok:%s, len:%d\n", tok, len); ret = -EINVAL; goto end; } ret = kstrtouint(tok, 16, result); if (ret) { DP_ERR("fail to convert %s! ret:%d\n", tok, ret); goto end; } end: return ret; } #if defined(CONFIG_SECDP_DBG) int secdp_debug_set_ssc(struct secdp_misc *sec, bool onoff) { struct dp_display_private *dp = container_of(sec, struct dp_display_private, sec); dp->pll->ssc_en = onoff; DP_DEBUG("set ssc_en %d\n", dp->pll->ssc_en); return 0; } bool secdp_debug_get_ssc(struct secdp_misc *sec) { struct dp_display_private *dp = container_of(sec, struct dp_display_private, sec); DP_DEBUG("get ssc_en %d\n", dp->pll->ssc_en); return dp->pll->ssc_en; } int secdp_show_hmd_dev(struct secdp_misc *sec, char *buf) { struct secdp_sink_dev *hmd_list; int i, rc = 0; hmd_list = sec->hmd.list; if (!hmd_list) { DP_ERR("hmd_list is null!\n"); rc = -ENOMEM; goto end; } for (i = 0; i < MAX_NUM_HMD; i++) { if (strlen(hmd_list[i].monitor_name) > 0) { if (buf) { rc += scnprintf(buf + rc, PAGE_SIZE - rc, "%s,0x%04x,0x%04x\n", hmd_list[i].monitor_name, hmd_list[i].ven_id, hmd_list[i].prod_id); } } } end: return rc; } #endif/*CONFIG_SECDP_DBG*/ enum { DEX_HMD_MON = 0, /* monitor name field */ DEX_HMD_VID, /* vid field */ DEX_HMD_PID, /* pid field */ DEX_HMD_FIELD_MAX, }; int secdp_store_hmd_dev(struct secdp_misc *sec, char *str, size_t len, int num_hmd) { struct secdp_sink_dev *hmd_list; struct secdp_sink_dev hmd_bak[MAX_NUM_HMD] = {0,}; bool backup = false; char *tok; int i, j, ret = 0, rmdr; uint value; if (num_hmd <= 0 || num_hmd > MAX_NUM_HMD) { DP_ERR("invalid num_hmd! %d\n", num_hmd); ret = -EINVAL; goto end; } DP_INFO("%s,%lu,%d\n", str, len, num_hmd); hmd_list = sec->hmd.list; /* backup and reset */ for (j = 0; j < MAX_NUM_HMD; j++) { memcpy(&hmd_bak[j], &hmd_list[j], sizeof(struct secdp_sink_dev)); memset(&hmd_list[j], 0, sizeof(struct secdp_sink_dev)); } backup = true; tok = strsep(&str, ","); i = 0, j = 0; while (tok != NULL && *tok != 0xa/*LF*/) { if (i >= num_hmd * DEX_HMD_FIELD_MAX) { DP_ERR("num of tok cannot exceed <%dx%d>!\n", num_hmd, DEX_HMD_FIELD_MAX); break; } if (j >= MAX_NUM_HMD) { DP_ERR("num of HMD cannot exceed %d!\n", MAX_NUM_HMD); break; } rmdr = i % DEX_HMD_FIELD_MAX; switch (rmdr) { case DEX_HMD_MON: strlcpy(hmd_list[j].monitor_name, tok, MON_NAME_LEN); break; case DEX_HMD_VID: case DEX_HMD_PID: ret = _secdp_strtoint(tok, &value); if (ret) goto end; if (rmdr == DEX_HMD_VID) { hmd_list[j].ven_id = value; } else { hmd_list[j].prod_id = value; j++; /* move next */ } break; } tok = strsep(&str, ","); i++; } for (j = 0; j < MAX_NUM_HMD; j++) { if (strlen(hmd_list[j].monitor_name) > 0) DP_INFO("%s,0x%04x,0x%04x\n", hmd_list[j].monitor_name, hmd_list[j].ven_id, hmd_list[j].prod_id); } end: if (backup && ret) { DP_INFO("restore hmd list!\n"); for (j = 0; j < MAX_NUM_HMD; j++) { memcpy(&hmd_list[j], &hmd_bak[j], sizeof(struct secdp_sink_dev)); } } return ret; } /** * check if connected sink is HMD device from hmd_list or not */ static bool _secdp_check_hmd_dev(struct dp_display_private *dp, const struct secdp_sink_dev *hmd) { bool ret = false; if (!dp || !hmd) { DP_ERR("invalid args!\n"); goto end; } if (dp->sec.adapter.ven_id != hmd->ven_id) goto end; if (dp->sec.adapter.prod_id != hmd->prod_id) goto end; if (strncmp(dp->panel->monitor_name, hmd->monitor_name, strlen(dp->panel->monitor_name))) goto end; ret = true; end: return ret; } /** * check if connected sink is predefined HMD(AR/VR) device or not * @param string to search * if NULL, check if one of HMD devices in list are connected * @retval true if found, false otherwise */ bool secdp_check_hmd_dev(struct secdp_misc *sec, const char *name_to_search) { struct dp_display_private *dp; struct secdp_hmd *hmd; struct secdp_sink_dev *hmd_list; int i, list_size; bool found = false; dp = container_of(sec, struct dp_display_private, sec); hmd = &dp->sec.hmd; hmd_list = hmd->list; mutex_lock(&hmd->lock); list_size = MAX_NUM_HMD; for (i = 0; i < list_size; i++) { if (name_to_search != NULL && strncmp(name_to_search, hmd_list[i].monitor_name, strlen(name_to_search))) continue; found = _secdp_check_hmd_dev(dp, &hmd_list[i]); if (found) break; } if (found) DP_INFO("hmd <%s>\n", hmd_list[i].monitor_name); mutex_unlock(&hmd->lock); return found; } #define PRN_MODE_COUNT 3 static void secdp_mode_count_init(struct dp_display_private *dp) { struct secdp_misc *sec = &dp->sec; secdp_logger_set_mode_max_count(PRN_MODE_COUNT); sec->mode_cnt = PRN_MODE_COUNT + 1; } static void secdp_mode_count_dec(struct dp_display_private *dp) { struct secdp_misc *sec = &dp->sec; secdp_logger_dec_mode_count(); if (sec->mode_cnt > 0) sec->mode_cnt--; } static bool secdp_mode_count_check(struct dp_display_private *dp) { struct secdp_misc *sec = &dp->sec; return sec->mode_cnt ? true : false; } static int secdp_send_hpd_event(struct secdp_misc *sec, bool hpd) { struct dp_display_private *dp; struct drm_device *dev; struct drm_connector *connector; u32 val = 0; char buf[HPD_STRING_SIZE] = { 0, }; char *envp[3]; int rc = 0; dp = container_of(sec, struct dp_display_private, sec); if (!dp->parser->rf_tx_backoff) { DP_DEBUG("RF TX backoff disabled\n"); return 0; } connector = dp->dp_display.base_connector; if (!connector) { DP_ERR("connector not set\n"); return 0; } if (hpd == sec->hpd.prev_evt) { DP_DEBUG("already sent %d\n", hpd); return 0; } if (!hpd) { val = 0; } else { val = 1; } snprintf(buf, HPD_STRING_SIZE, "hpd=%d", val); DP_INFO("[%s]\n", buf); dev = connector->dev; envp[0] = "DEVPATH=/devices/virtual/sec/secdp"; envp[1] = buf; envp[2] = NULL; rc = kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); if (!rc) sec->hpd.prev_evt = hpd; else DP_INFO("hpd uevent failed %d\n", rc); return rc; } #endif static inline bool dp_display_is_hdcp_enabled(struct dp_display_private *dp) { return dp->link->hdcp_status.hdcp_version && dp->hdcp.ops; } static irqreturn_t dp_display_irq(int irq, void *dev_id) { struct dp_display_private *dp = dev_id; if (!dp) { DP_ERR("invalid data\n"); return IRQ_NONE; } /* DP HPD isr */ if (dp->hpd->type == DP_HPD_LPHW) dp->hpd->isr(dp->hpd); /* DP controller isr */ dp->ctrl->isr(dp->ctrl); /* DP aux isr */ dp->aux->isr(dp->aux); /* HDCP isr */ if (dp_display_is_hdcp_enabled(dp) && dp->hdcp.ops->isr) { if (dp->hdcp.ops->isr(dp->hdcp.data)) DP_ERR("dp_hdcp_isr failed\n"); } return IRQ_HANDLED; } static bool dp_display_is_ds_bridge(struct dp_panel *panel) { return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT); } static bool dp_display_is_sink_count_zero(struct dp_display_private *dp) { return dp_display_is_ds_bridge(dp->panel) && (dp->link->sink_count.count == 0); } static bool dp_display_is_ready(struct dp_display_private *dp) { return dp->hpd->hpd_high && dp_display_state_is(DP_STATE_CONNECTED) && !dp_display_is_sink_count_zero(dp) && dp->hpd->alt_mode_cfg_done; } static void dp_audio_enable(struct dp_display_private *dp, bool enable) { struct dp_panel *dp_panel; int idx; for (idx = DP_STREAM_0; idx < DP_STREAM_MAX; idx++) { if (!dp->active_panels[idx]) continue; dp_panel = dp->active_panels[idx]; if (dp_panel->audio_supported) { if (enable) { dp_panel->audio->bw_code = dp->link->link_params.bw_code; dp_panel->audio->lane_count = dp->link->link_params.lane_count; dp_panel->audio->on(dp_panel->audio); } else { dp_panel->audio->off(dp_panel->audio, false); } } } } static void dp_display_qos_request(struct dp_display_private *dp, bool add_vote) { struct device *cpu_dev; int cpu = 0; struct cpumask *cpu_mask; u32 latency = dp->parser->qos_cpu_latency; unsigned long mask = dp->parser->qos_cpu_mask; if (!dp->parser->qos_cpu_mask || (dp->pm_qos_requested == add_vote)) return; cpu_mask = to_cpumask(&mask); for_each_cpu(cpu, cpu_mask) { cpu_dev = get_cpu_device(cpu); if (!cpu_dev) { SDE_DEBUG("%s: failed to get cpu%d device\n", __func__, cpu); continue; } if (add_vote) dev_pm_qos_add_request(cpu_dev, &dp->pm_qos_req[cpu], DEV_PM_QOS_RESUME_LATENCY, latency); else dev_pm_qos_remove_request(&dp->pm_qos_req[cpu]); } SDE_EVT32_EXTERNAL(add_vote, mask, latency); dp->pm_qos_requested = add_vote; } static void dp_display_update_hdcp_status(struct dp_display_private *dp, bool reset) { if (reset) { dp->link->hdcp_status.hdcp_state = HDCP_STATE_INACTIVE; dp->link->hdcp_status.hdcp_version = HDCP_VERSION_NONE; } memset(dp->debug->hdcp_status, 0, sizeof(dp->debug->hdcp_status)); snprintf(dp->debug->hdcp_status, sizeof(dp->debug->hdcp_status), "%s: %s\ncaps: %d\n", sde_hdcp_version(dp->link->hdcp_status.hdcp_version), sde_hdcp_state_name(dp->link->hdcp_status.hdcp_state), dp->hdcp.source_cap); } static void dp_display_update_hdcp_info(struct dp_display_private *dp) { void *fd = NULL; struct dp_hdcp_dev *dev = NULL; struct sde_hdcp_ops *ops = NULL; int i = HDCP_VERSION_2P2; dp_display_update_hdcp_status(dp, true); dp->hdcp.data = NULL; dp->hdcp.ops = NULL; if (dp->debug->hdcp_disabled || dp->debug->sim_mode) return; while (i) { dev = &dp->hdcp.dev[i]; ops = dev->ops; fd = dev->fd; i >>= 1; if (!(dp->hdcp.source_cap & dev->ver)) continue; if (ops->sink_support(fd)) { dp->hdcp.data = fd; dp->hdcp.ops = ops; dp->link->hdcp_status.hdcp_version = dev->ver; break; } } DP_DEBUG("HDCP version supported: %s\n", sde_hdcp_version(dp->link->hdcp_status.hdcp_version)); } static void dp_display_check_source_hdcp_caps(struct dp_display_private *dp) { int i; struct dp_hdcp_dev *hdcp_dev = dp->hdcp.dev; if (dp->debug->hdcp_disabled) { DP_DEBUG("hdcp disabled\n"); return; } for (i = 0; i < HDCP_VERSION_MAX; i++) { struct dp_hdcp_dev *dev = &hdcp_dev[i]; struct sde_hdcp_ops *ops = dev->ops; void *fd = dev->fd; if (!fd || !ops) continue; if (ops->set_mode && ops->set_mode(fd, dp->mst.mst_active)) continue; if (!(dp->hdcp.source_cap & dev->ver) && ops->feature_supported && ops->feature_supported(fd)) dp->hdcp.source_cap |= dev->ver; } #if defined(CONFIG_SECDP_BIGDATA) secdp_bigdata_save_item(BD_HDCP_VER, (dp->hdcp.source_cap & HDCP_VERSION_2P2) ? "hdcp2" : ((dp->hdcp.source_cap & HDCP_VERSION_1X) ? "hdcp1" : "X")); #endif dp_display_update_hdcp_status(dp, false); } static void dp_display_hdcp_register_streams(struct dp_display_private *dp) { int rc; size_t i; struct sde_hdcp_ops *ops = dp->hdcp.ops; void *data = dp->hdcp.data; if (dp_display_is_ready(dp) && dp->mst.mst_active && ops && ops->register_streams){ struct stream_info streams[DP_STREAM_MAX]; int index = 0; DP_DEBUG("Registering all active panel streams with HDCP\n"); for (i = DP_STREAM_0; i < DP_STREAM_MAX; i++) { if (!dp->active_panels[i]) continue; streams[index].stream_id = i; streams[index].virtual_channel = dp->active_panels[i]->vcpi; index++; } if (index > 0) { rc = ops->register_streams(data, index, streams); if (rc) DP_ERR("failed to register streams. rc = %d\n", rc); } } } static void dp_display_hdcp_deregister_stream(struct dp_display_private *dp, enum dp_stream_id stream_id) { if (dp->hdcp.ops->deregister_streams && dp->active_panels[stream_id]) { struct stream_info stream = {stream_id, dp->active_panels[stream_id]->vcpi}; DP_DEBUG("Deregistering stream within HDCP library\n"); dp->hdcp.ops->deregister_streams(dp->hdcp.data, 1, &stream); } } static void dp_display_hdcp_process_delayed_off(struct dp_display_private *dp) { if (dp->hdcp_delayed_off) { if (dp->hdcp.ops && dp->hdcp.ops->off) dp->hdcp.ops->off(dp->hdcp.data); dp_display_update_hdcp_status(dp, true); dp->hdcp_delayed_off = false; } } static int dp_display_hdcp_process_sink_sync(struct dp_display_private *dp) { u8 sink_status = 0; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY); if (dp->debug->hdcp_wait_sink_sync) { drm_dp_dpcd_readb(dp->aux->drm_aux, DP_SINK_STATUS, &sink_status); sink_status &= (DP_RECEIVE_PORT_0_STATUS | DP_RECEIVE_PORT_1_STATUS); #if !defined(CONFIG_SECDP) if (sink_status < 1) { DP_DEBUG("Sink not synchronized. Queuing again then exiting\n"); queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ); return -EAGAIN; } #else if (sink_status < 1 && !secdp_get_link_train_status(dp->ctrl)) { DP_INFO("hdcp retry: %d\n", dp->sec.hdcp.retry); if (dp->sec.hdcp.retry >= MAX_CNT_HDCP_RETRY) { DP_DEBUG("stop queueing!\n"); schedule_delayed_work(&dp->sec.poor_discon_work, msecs_to_jiffies(10)); return -EAGAIN; } dp->sec.hdcp.retry++; DP_DEBUG("Sink not synchronized. Queuing again then exiting\n"); queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ); return -EAGAIN; } #endif /* * Some sinks need more time to stabilize after synchronization * and before it can handle an HDCP authentication request. * Adding the delay for better interoperability. */ msleep(6000); } SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT); return 0; } static int dp_display_hdcp_start(struct dp_display_private *dp) { if (dp->link->hdcp_status.hdcp_state != HDCP_STATE_INACTIVE) return -EINVAL; dp_display_check_source_hdcp_caps(dp); dp_display_update_hdcp_info(dp); if (dp_display_is_hdcp_enabled(dp)) { if (dp->hdcp.ops && dp->hdcp.ops->on && dp->hdcp.ops->on(dp->hdcp.data)) { dp_display_update_hdcp_status(dp, true); return 0; } } else { dp_display_update_hdcp_status(dp, true); return 0; } return -EINVAL; } static void dp_display_hdcp_print_auth_state(struct dp_display_private *dp) { u32 hdcp_auth_state; int rc; rc = dp->catalog->ctrl.read_hdcp_status(&dp->catalog->ctrl); if (rc >= 0) { hdcp_auth_state = (rc >> 20) & 0x3; DP_DEBUG("hdcp auth state %d\n", hdcp_auth_state); } } static void dp_display_hdcp_process_state(struct dp_display_private *dp) { struct dp_link_hdcp_status *status; struct sde_hdcp_ops *ops; void *data; int rc = 0; status = &dp->link->hdcp_status; ops = dp->hdcp.ops; data = dp->hdcp.data; #if defined(CONFIG_SECDP) if (secdp_get_reboot_status()) { DP_INFO("shutdown\n"); return; } #endif if (status->hdcp_state != HDCP_STATE_AUTHENTICATED && dp->debug->force_encryption && ops && ops->force_encryption) ops->force_encryption(data, dp->debug->force_encryption); if (status->hdcp_state == HDCP_STATE_AUTHENTICATED) dp_display_qos_request(dp, false); else dp_display_qos_request(dp, true); switch (status->hdcp_state) { case HDCP_STATE_INACTIVE: dp_display_hdcp_register_streams(dp); #if defined(CONFIG_SECDP) if (!dp->panel->tbox) secdp_read_link_status(dp->link); #endif if (dp->hdcp.ops && dp->hdcp.ops->authenticate) rc = dp->hdcp.ops->authenticate(data); if (!rc) status->hdcp_state = HDCP_STATE_AUTHENTICATING; break; case HDCP_STATE_AUTH_FAIL: #if defined(CONFIG_SECDP_BIGDATA) secdp_bigdata_inc_error_cnt(ERR_HDCP_AUTH); #endif if (dp_display_is_ready(dp) && dp_display_state_is(DP_STATE_ENABLED)) { if (ops && ops->on && ops->on(data)) { dp_display_update_hdcp_status(dp, true); return; } dp_display_hdcp_register_streams(dp); if (ops && ops->reauthenticate) { rc = ops->reauthenticate(data); if (rc) DP_ERR("failed rc=%d\n", rc); } status->hdcp_state = HDCP_STATE_AUTHENTICATING; } else { DP_DEBUG("not reauthenticating, cable disconnected\n"); } break; default: dp_display_hdcp_register_streams(dp); break; } } static void dp_display_abort_hdcp(struct dp_display_private *dp, bool abort) { u8 i = HDCP_VERSION_2P2; struct dp_hdcp_dev *dev = NULL; while (i) { dev = &dp->hdcp.dev[i]; i >>= 1; if (!(dp->hdcp.source_cap & dev->ver)) continue; dev->ops->abort(dev->fd, abort); } } static void dp_display_hdcp_cb_work(struct work_struct *work) { struct dp_display_private *dp; struct delayed_work *dw = to_delayed_work(work); struct dp_link_hdcp_status *status; int rc = 0; dp = container_of(dw, struct dp_display_private, hdcp_cb_work); if (!dp_display_state_is(DP_STATE_ENABLED | DP_STATE_CONNECTED) || dp_display_state_is(DP_STATE_ABORTED | DP_STATE_HDCP_ABORTED)) return; if (dp_display_state_is(DP_STATE_SUSPENDED)) { DP_DEBUG("System suspending. Delay HDCP operations\n"); queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ); return; } dp_display_hdcp_process_delayed_off(dp); rc = dp_display_hdcp_process_sink_sync(dp); if (rc) return; rc = dp_display_hdcp_start(dp); if (!rc) return; dp_display_hdcp_print_auth_state(dp); status = &dp->link->hdcp_status; DP_DEBUG("%s: %s\n", sde_hdcp_version(status->hdcp_version), sde_hdcp_state_name(status->hdcp_state)); dp_display_update_hdcp_status(dp, false); dp_display_hdcp_process_state(dp); } static void dp_display_notify_hdcp_status_cb(void *ptr, enum sde_hdcp_state state) { struct dp_display_private *dp = ptr; if (!dp) { DP_ERR("invalid input\n"); return; } SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->link->hdcp_status.hdcp_state); dp->link->hdcp_status.hdcp_state = state; queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ/4); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->link->hdcp_status.hdcp_state); } static void dp_display_deinitialize_hdcp(struct dp_display_private *dp) { if (!dp) { DP_ERR("invalid input\n"); return; } sde_hdcp_1x_deinit(dp->hdcp.dev[HDCP_VERSION_1X].fd); sde_dp_hdcp2p2_deinit(dp->hdcp.dev[HDCP_VERSION_2P2].fd); } static int dp_display_initialize_hdcp(struct dp_display_private *dp) { struct sde_hdcp_init_data hdcp_init_data; struct dp_parser *parser; void *fd; int rc = 0; if (!dp) { DP_ERR("invalid input\n"); return -EINVAL; } parser = dp->parser; hdcp_init_data.client_id = HDCP_CLIENT_DP; hdcp_init_data.drm_aux = dp->aux->drm_aux; hdcp_init_data.cb_data = (void *)dp; hdcp_init_data.workq = dp->wq; hdcp_init_data.sec_access = true; hdcp_init_data.notify_status = dp_display_notify_hdcp_status_cb; hdcp_init_data.dp_ahb = &parser->get_io(parser, "dp_ahb")->io; hdcp_init_data.dp_aux = &parser->get_io(parser, "dp_aux")->io; hdcp_init_data.dp_link = &parser->get_io(parser, "dp_link")->io; hdcp_init_data.dp_p0 = &parser->get_io(parser, "dp_p0")->io; hdcp_init_data.hdcp_io = &parser->get_io(parser, "hdcp_physical")->io; hdcp_init_data.revision = &dp->panel->link_info.revision; hdcp_init_data.msm_hdcp_dev = dp->parser->msm_hdcp_dev; fd = sde_hdcp_1x_init(&hdcp_init_data); if (IS_ERR_OR_NULL(fd)) { DP_DEBUG("Error initializing HDCP 1.x\n"); return -EINVAL; } dp->hdcp.dev[HDCP_VERSION_1X].fd = fd; dp->hdcp.dev[HDCP_VERSION_1X].ops = sde_hdcp_1x_get(fd); dp->hdcp.dev[HDCP_VERSION_1X].ver = HDCP_VERSION_1X; DP_INFO("HDCP 1.3 initialized\n"); fd = sde_dp_hdcp2p2_init(&hdcp_init_data); if (IS_ERR_OR_NULL(fd)) { DP_DEBUG("Error initializing HDCP 2.x\n"); rc = -EINVAL; goto error; } dp->hdcp.dev[HDCP_VERSION_2P2].fd = fd; dp->hdcp.dev[HDCP_VERSION_2P2].ops = sde_dp_hdcp2p2_get(fd); dp->hdcp.dev[HDCP_VERSION_2P2].ver = HDCP_VERSION_2P2; DP_INFO("HDCP 2.2 initialized\n"); return 0; error: sde_hdcp_1x_deinit(dp->hdcp.dev[HDCP_VERSION_1X].fd); return rc; } static void dp_display_pause_audio(struct dp_display_private *dp, bool pause) { struct dp_panel *dp_panel; int idx; for (idx = DP_STREAM_0; idx < DP_STREAM_MAX; idx++) { if (!dp->active_panels[idx]) continue; dp_panel = dp->active_panels[idx]; if (dp_panel->audio_supported) dp_panel->audio->tui_active = pause; } } static int dp_display_pre_hw_release(void *data) { struct dp_display_private *dp; struct dp_display *dp_display = data; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY); if (!dp_display) return -EINVAL; dp = container_of(dp_display, struct dp_display_private, dp_display); mutex_lock(&dp->session_lock); dp_display_state_add(DP_STATE_TUI_ACTIVE); cancel_work_sync(&dp->connect_work); cancel_work_sync(&dp->attention_work); cancel_work_sync(&dp->disconnect_work); flush_workqueue(dp->wq); dp_display_pause_audio(dp, true); disable_irq(dp->irq); mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT); return 0; } static int dp_display_post_hw_acquire(void *data) { struct dp_display_private *dp; struct dp_display *dp_display = data; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY); if (!dp_display) return -EINVAL; dp = container_of(dp_display, struct dp_display_private, dp_display); mutex_lock(&dp->session_lock); dp_display_state_remove(DP_STATE_TUI_ACTIVE); dp_display_pause_audio(dp, false); enable_irq(dp->irq); mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT); return 0; } static int dp_display_bind(struct device *dev, struct device *master, void *data) { int rc = 0; struct dp_display_private *dp; struct drm_device *drm; struct platform_device *pdev = to_platform_device(dev); struct msm_vm_ops vm_event_ops = { .vm_pre_hw_release = dp_display_pre_hw_release, .vm_post_hw_acquire = dp_display_post_hw_acquire, }; if (!dev || !pdev || !master) { DP_ERR("invalid param(s), dev %pK, pdev %pK, master %pK\n", dev, pdev, master); rc = -EINVAL; goto end; } drm = dev_get_drvdata(master); dp = platform_get_drvdata(pdev); if (!drm || !dp) { DP_ERR("invalid param(s), drm %pK, dp %pK\n", drm, dp); rc = -EINVAL; goto end; } dp->dp_display.drm_dev = drm; dp->priv = drm->dev_private; msm_register_vm_event(master, dev, &vm_event_ops, (void *)&dp->dp_display); end: return rc; } static void dp_display_unbind(struct device *dev, struct device *master, void *data) { struct dp_display_private *dp; struct platform_device *pdev = to_platform_device(dev); if (!dev || !pdev) { DP_ERR("invalid param(s)\n"); return; } dp = platform_get_drvdata(pdev); if (!dp) { DP_ERR("Invalid params\n"); return; } if (dp->power) (void)dp->power->power_client_deinit(dp->power); if (dp->aux) (void)dp->aux->drm_aux_deregister(dp->aux); dp_display_deinitialize_hdcp(dp); } static const struct component_ops dp_display_comp_ops = { .bind = dp_display_bind, .unbind = dp_display_unbind, }; static bool dp_display_send_hpd_event(struct dp_display_private *dp) { struct drm_device *dev = NULL; struct drm_connector *connector; char name[HPD_STRING_SIZE], status[HPD_STRING_SIZE], bpp[HPD_STRING_SIZE], pattern[HPD_STRING_SIZE]; char *envp[5]; struct dp_display *display; int rc = 0; connector = dp->dp_display.base_connector; display = &dp->dp_display; if (!connector) { DP_ERR("connector not set\n"); return false; } connector->status = display->is_sst_connected ? connector_status_connected : connector_status_disconnected; if (dp->cached_connector_status == connector->status) { DP_DEBUG("connector status (%d) unchanged, skipping uevent\n", dp->cached_connector_status); return false; } dp->cached_connector_status = connector->status; dev = connector->dev; if (dp->debug->skip_uevent) { DP_INFO("skipping uevent\n"); return false; } #if defined(CONFIG_SECDP) msleep(100); atomic_set(&dp->sec.noti_status, 1); secdp_mode_count_init(dp); #endif snprintf(name, HPD_STRING_SIZE, "name=%s", connector->name); snprintf(status, HPD_STRING_SIZE, "status=%s", drm_get_connector_status_name(connector->status)); snprintf(bpp, HPD_STRING_SIZE, "bpp=%d", dp_link_bit_depth_to_bpp( dp->link->test_video.test_bit_depth)); snprintf(pattern, HPD_STRING_SIZE, "pattern=%d", dp->link->test_video.test_video_pattern); DP_INFO("[%s]:[%s] [%s] [%s]\n", name, status, bpp, pattern); envp[0] = name; envp[1] = status; envp[2] = bpp; envp[3] = pattern; envp[4] = NULL; rc = kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); DP_INFO("uevent %s: %d\n", rc ? "failure" : "success", rc); return true; } static int dp_display_send_hpd_notification(struct dp_display_private *dp, bool skip_wait) { int ret = 0; bool hpd = !!dp_display_state_is(DP_STATE_CONNECTED); #if defined(CONFIG_SECDP) struct secdp_misc *sec = &dp->sec; if (hpd && !secdp_get_cable_status()) { DP_INFO("cable is out\n"); return -EIO; } DP_ENTER("\n"); mutex_lock(&sec->notify_lock); #endif SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state, hpd); /* * Send the notification only if there is any change. This check is * necessary since it is possible that the connect_work may or may not * skip sending the notification in order to respond to a pending * attention message. Attention work thread will always attempt to * send the notification after successfully handling the attention * message. This check here will avoid any unintended duplicate * notifications. */ if (dp_display_state_is(DP_STATE_CONNECT_NOTIFIED) && hpd) { DP_DEBUG("connection notified already, skip notification\n"); goto skip_wait; } else if (dp_display_state_is(DP_STATE_DISCONNECT_NOTIFIED) && !hpd) { DP_DEBUG("disonnect notified already, skip notification\n"); goto skip_wait; } dp->aux->state |= DP_STATE_NOTIFICATION_SENT; reinit_completion(&dp->notification_comp); if (!dp->mst.mst_active) { dp->dp_display.is_sst_connected = hpd; if (!dp_display_send_hpd_event(dp)) goto skip_wait; } else { dp->dp_display.is_sst_connected = false; if (!dp->mst.cbs.hpd) goto skip_wait; dp->mst.cbs.hpd(&dp->dp_display, hpd); } if (hpd) { dp_display_state_add(DP_STATE_CONNECT_NOTIFIED); dp_display_state_remove(DP_STATE_DISCONNECT_NOTIFIED); } else { dp_display_state_add(DP_STATE_DISCONNECT_NOTIFIED); dp_display_state_remove(DP_STATE_CONNECT_NOTIFIED); } #if defined(CONFIG_SECDP) if (!hpd && !dp_display_state_is(DP_STATE_ENABLED)) { DP_INFO("DP is already off, no wait\n"); goto skip_wait; } #endif /* * Skip the wait if TUI is active considering that the user mode will * not act on the notification until after the TUI session is over. */ if (dp_display_state_is(DP_STATE_TUI_ACTIVE)) { dp_display_state_log("[TUI is active, skipping wait]"); goto skip_wait; } if (skip_wait || (hpd && dp->mst.mst_active)) goto skip_wait; if (!dp->mst.mst_active && (!!dp_display_state_is(DP_STATE_ENABLED) == hpd)) goto skip_wait; #if !defined(CONFIG_SECDP) // wait 2 seconds if (wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) #else if (wait_for_completion_timeout(&dp->notification_comp, HZ * 17)) #endif goto skip_wait; //resend notification if (dp->mst.mst_active) dp->mst.cbs.hpd(&dp->dp_display, hpd); else dp_display_send_hpd_event(dp); // wait another 3 seconds if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 3)) { DP_WARN("%s timeout\n", hpd ? "connect" : "disconnect"); ret = -EINVAL; } skip_wait: SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, hpd, ret); #if defined(CONFIG_SECDP) DP_LEAVE("\n"); mutex_unlock(&sec->notify_lock); #endif return ret; } static void dp_display_update_mst_state(struct dp_display_private *dp, bool state) { dp->mst.mst_active = state; dp->panel->mst_state = state; } static void dp_display_mst_init(struct dp_display_private *dp) { bool is_mst_receiver; const unsigned long clear_mstm_ctrl_timeout_us = 100000; u8 old_mstm_ctrl; int ret; if (!dp->parser->has_mst || !dp->mst.drm_registered) { DP_MST_DEBUG("mst not enabled. has_mst:%d, registered:%d\n", dp->parser->has_mst, dp->mst.drm_registered); return; } is_mst_receiver = dp->panel->read_mst_cap(dp->panel); if (!is_mst_receiver) { DP_MST_DEBUG("sink doesn't support mst\n"); return; } /* clear sink mst state */ drm_dp_dpcd_readb(dp->aux->drm_aux, DP_MSTM_CTRL, &old_mstm_ctrl); drm_dp_dpcd_writeb(dp->aux->drm_aux, DP_MSTM_CTRL, 0); /* add extra delay if MST state is not cleared */ if (old_mstm_ctrl) { DP_MST_DEBUG("MSTM_CTRL is not cleared, wait %luus\n", clear_mstm_ctrl_timeout_us); usleep_range(clear_mstm_ctrl_timeout_us, clear_mstm_ctrl_timeout_us + 1000); } ret = drm_dp_dpcd_writeb(dp->aux->drm_aux, DP_MSTM_CTRL, DP_MST_EN | DP_UP_REQ_EN | DP_UPSTREAM_IS_SRC); if (ret < 0) { DP_ERR("sink mst enablement failed\n"); return; } dp_display_update_mst_state(dp, true); } static void dp_display_set_mst_mgr_state(struct dp_display_private *dp, bool state) { if (!dp->mst.mst_active) return; if (dp->mst.cbs.set_mgr_state) dp->mst.cbs.set_mgr_state(&dp->dp_display, state); DP_MST_DEBUG("mst_mgr_state: %d\n", state); } static int dp_display_host_init(struct dp_display_private *dp) { bool flip = false; bool reset; int rc = 0; if (dp_display_state_is(DP_STATE_INITIALIZED)) { dp_display_state_log("[already initialized]"); return rc; } if (dp->hpd->orientation == ORIENTATION_CC2) flip = true; reset = dp->debug->sim_mode ? false : !dp->hpd->multi_func; rc = dp->power->init(dp->power, flip); if (rc) { DP_WARN("Power init failed.\n"); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_CASE1, dp->state); return rc; } dp->hpd->host_init(dp->hpd, &dp->catalog->hpd); rc = dp->ctrl->init(dp->ctrl, flip, reset); if (rc) { DP_WARN("Ctrl init Failed.\n"); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_CASE2, dp->state); goto error_ctrl; } enable_irq(dp->irq); dp_display_abort_hdcp(dp, false); dp_display_state_add(DP_STATE_INITIALIZED); /* log this as it results from user action of cable connection */ DP_INFO("[OK]\n"); return rc; error_ctrl: dp->hpd->host_deinit(dp->hpd, &dp->catalog->hpd); dp->power->deinit(dp->power); return rc; } static int dp_display_host_ready(struct dp_display_private *dp) { int rc = 0; if (!dp_display_state_is(DP_STATE_INITIALIZED)) { rc = dp_display_host_init(dp); if (rc) { dp_display_state_show("[not initialized]"); return rc; } } if (dp_display_state_is(DP_STATE_READY)) { dp_display_state_log("[already ready]"); return rc; } /* * Reset the aborted state for AUX and CTRL modules. This will * allow these modules to execute normally in response to the * cable connection event. * * One corner case still exists. While the execution flow ensures * that cable disconnection flushes all pending work items on the DP * workqueue, and waits for the user module to clean up the DP * connection session, it is possible that the system delays can * lead to timeouts in the connect path. As a result, the actual * connection callback from user modules can come in late and can * race against a subsequent connection event here which would have * reset the aborted flags. There is no clear solution for this since * the connect/disconnect notifications do not currently have any * sessions IDs. */ dp->aux->abort(dp->aux, false); dp->ctrl->abort(dp->ctrl, false); dp->aux->init(dp->aux, dp->parser->aux_cfg); dp->panel->init(dp->panel); dp_display_state_add(DP_STATE_READY); /* log this as it results from user action of cable connection */ DP_INFO("[OK]\n"); return rc; } static void dp_display_host_unready(struct dp_display_private *dp) { if (!dp_display_state_is(DP_STATE_INITIALIZED)) { dp_display_state_warn("[not initialized]"); return; } if (!dp_display_state_is(DP_STATE_READY)) { dp_display_state_show("[not ready]"); return; } dp_display_state_remove(DP_STATE_READY); dp->aux->deinit(dp->aux); /* log this as it results from user action of cable disconnection */ DP_INFO("[OK]\n"); } static void dp_display_host_deinit(struct dp_display_private *dp) { if (dp->active_stream_cnt) { SDE_EVT32_EXTERNAL(dp->state, dp->active_stream_cnt); DP_DEBUG("active stream present\n"); return; } if (!dp_display_state_is(DP_STATE_INITIALIZED)) { dp_display_state_show("[not initialized]"); return; } if (dp_display_state_is(DP_STATE_READY)) { DP_DEBUG("dp deinit before unready\n"); dp_display_host_unready(dp); } dp_display_abort_hdcp(dp, true); dp->ctrl->deinit(dp->ctrl); dp->hpd->host_deinit(dp->hpd, &dp->catalog->hpd); dp->power->deinit(dp->power); disable_irq(dp->irq); dp->aux->state = 0; dp_display_state_remove(DP_STATE_INITIALIZED); /* log this as it results from user action of cable dis-connection */ DP_INFO("[OK]\n"); } static bool dp_display_hpd_irq_pending(struct dp_display_private *dp) { unsigned long wait_timeout_ms = 0; unsigned long t_out = 0; unsigned long wait_time = 0; do { /* * If an IRQ HPD is pending, then do not send a connect notification. * Once this work returns, the IRQ HPD would be processed and any * required actions (such as link maintenance) would be done which * will subsequently send the HPD notification. To keep things simple, * do this only for SST use-cases. MST use cases require additional * care in order to handle the side-band communications as well. * * One of the main motivations for this is DP LL 1.4 CTS use case * where it is possible that we could get a test request right after * a connection, and the strict timing requriements of the test can * only be met if we do not wait for the e2e connection to be set up. */ if (!dp->mst.mst_active && (work_busy(&dp->attention_work) == WORK_BUSY_PENDING)) { SDE_EVT32_EXTERNAL(dp->state, 99, jiffies_to_msecs(t_out)); DP_DEBUG("Attention pending, skip HPD notification\n"); return true; } /* * If no IRQ HPD, delay the HPD connect notification for * MAX_CONNECT_NOTIFICATION_DELAY_MS to see if sink generates any IRQ HPDs * after the HPD high. Wait for * MAX_CONNECT_NOTIFICATION_DELAY_MS to make sure any IRQ HPD from test * requests aren't missed. */ reinit_completion(&dp->attention_comp); wait_timeout_ms = min_t(unsigned long, dp->debug->connect_notification_delay_ms, (unsigned long) MAX_CONNECT_NOTIFICATION_DELAY_MS - wait_time); t_out = wait_for_completion_timeout(&dp->attention_comp, msecs_to_jiffies(wait_timeout_ms)); wait_time += (t_out == 0) ? wait_timeout_ms : t_out; } while ((wait_timeout_ms < wait_time) && (wait_time < MAX_CONNECT_NOTIFICATION_DELAY_MS)); DP_DEBUG("wait_timeout=%lu ms, time_waited=%lu ms\n", wait_timeout_ms, wait_time); return false; } static int dp_display_process_hpd_high(struct dp_display_private *dp) { int rc = -EINVAL; #if defined(CONFIG_SECDP) bool core_off = false; #endif SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); if (dp_display_state_is(DP_STATE_CONNECTED)) { DP_DEBUG("dp already connected, skipping hpd high\n"); mutex_unlock(&dp->session_lock); return -EISCONN; } dp_display_state_add(DP_STATE_CONNECTED); dp->dp_display.max_pclk_khz = min(dp->parser->max_pclk_khz, dp->debug->max_pclk_khz); if (!dp->debug->sim_mode && !dp->no_aux_switch && !dp->parser->gpio_aux_switch && dp->aux_switch_node && dp->aux->switch_configure) { rc = dp->aux->switch_configure(dp->aux, true, dp->hpd->orientation); if (rc) goto err_state; } #if defined(CONFIG_SECDP) secdp_set_wakelock(dp, true); #endif /* * If dp video session is not restored from a previous session teardown * by userspace, ensure the host_init is executed, in such a scenario, * so that all the required DP resources are enabled. * * Below is one of the sequences of events which describe the above * scenario: * a. Source initiated power down resulting in host_deinit. * b. Sink issues hpd low attention without physical cable disconnect. * c. Source initiated power up sequence returns early because hpd is * not high. * d. Sink issues a hpd high attention event. */ if (dp_display_state_is(DP_STATE_SRC_PWRDN) && dp_display_state_is(DP_STATE_CONFIGURED)) { rc = dp_display_host_init(dp); if (rc) { DP_WARN("Host init Failed"); if (!dp_display_state_is(DP_STATE_SUSPENDED)) { /* * If not suspended no point of going forward if * resource is not enabled. */ dp_display_state_remove(DP_STATE_CONNECTED); } goto err_unlock; } /* * If device is suspended and host_init fails, there is * one more chance for host init to happen in prepare which * is why DP_STATE_SRC_PWRDN is removed only at success. */ dp_display_state_remove(DP_STATE_SRC_PWRDN); } rc = dp_display_host_ready(dp); if (rc) { dp_display_state_show("[ready failed]"); goto err_state; } dp->link->psm_config(dp->link, &dp->panel->link_info, false); dp->debug->psm_enabled = false; if (!dp->dp_display.base_connector) goto err_unready; rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.base_connector, dp->hpd->multi_func); #if defined(CONFIG_SECDP) if (!secdp_get_hpd_status() || !secdp_get_cable_status()) { DP_INFO("hpd_low or cable_lost or AUX failure: %d\n", rc); rc = -EIO; core_off = true; goto err_mst; } #endif /* * ETIMEDOUT --> cable may have been removed * ENOTCONN --> no downstream device connected */ #if !defined(CONFIG_SECDP) if (rc == -ETIMEDOUT || rc == -ENOTCONN) goto err_unready; #else if (rc == -ENOTCONN) goto err_unready; if (rc == -ETIMEDOUT) { core_off = true; goto err_unready; } if (rc == -EINVAL) { /* read EDID is corrupted or invalid, failsafe case */ secdp_send_poor_connection_event(dp, true); } dp->sec.dex.prev = secdp_check_dex_mode(dp); DP_INFO("dex.ui:%d,dex.curr:%d\n", dp->sec.dex.setting_ui, dp->sec.dex.curr); secdp_read_branch_revision(dp); dp->sec.hmd.exist = secdp_check_hmd_dev(&dp->sec, NULL); #if defined(CONFIG_SECDP_BIGDATA) if (dp->sec.dex.prev != DEX_DISABLED) secdp_bigdata_save_item(BD_DP_MODE, "DEX"); else secdp_bigdata_save_item(BD_DP_MODE, "MIRROR"); #endif #endif/*CONFIG_SECDP*/ dp->link->process_request(dp->link); dp->panel->handle_sink_request(dp->panel); dp_display_mst_init(dp); rc = dp->ctrl->on(dp->ctrl, dp->mst.mst_active, dp->panel->fec_en, dp->panel->dsc_en, false); if (rc) { #if defined(CONFIG_SECDP) core_off = true; #endif goto err_mst; } dp->process_hpd_connect = false; dp_display_set_mst_mgr_state(dp, true); mutex_unlock(&dp->session_lock); #if defined(CONFIG_SECDP) { int wait = secdp_check_boot_time(); if (!rc && !dp_display_state_is(DP_STATE_ABORTED) && wait) { DP_INFO("deferred HPD noti at boot time! wait: %d\n", wait); schedule_delayed_work(&dp->sec.hpd.noti_work, msecs_to_jiffies(wait * 1000)); dp->sec.hpd.noti_deferred = true; return rc; } } #endif if (dp_display_hpd_irq_pending(dp)) goto end; if (!rc && !dp_display_state_is(DP_STATE_ABORTED)) dp_display_send_hpd_notification(dp, false); #if defined(CONFIG_SECDP) if (rc || dp_display_state_is(DP_STATE_ABORTED)) secdp_set_wakelock(dp, false); #endif goto end; err_mst: dp_display_update_mst_state(dp, false); err_unready: dp_display_host_unready(dp); err_state: dp_display_state_remove(DP_STATE_CONNECTED); err_unlock: #if defined(CONFIG_SECDP) secdp_send_hpd_event(&dp->sec, false); secdp_set_wakelock(dp, false); if (core_off) { dp_display_host_deinit(dp); secdp_send_poor_connection_event(dp, false); } #endif mutex_unlock(&dp->session_lock); end: SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, rc); return rc; } static void dp_display_process_mst_hpd_low(struct dp_display_private *dp, bool skip_wait) { int rc = 0; if (dp->mst.mst_active) { DP_MST_DEBUG("mst_hpd_low work\n"); /* * HPD unplug callflow: * 1. send hpd unplug on base connector so usermode can disable * all external displays. * 2. unset mst state in the topology mgr so the branch device * can be cleaned up. */ if ((dp_display_state_is(DP_STATE_CONNECT_NOTIFIED) || dp_display_state_is(DP_STATE_ENABLED))) rc = dp_display_send_hpd_notification(dp, skip_wait); dp_display_set_mst_mgr_state(dp, false); dp_display_update_mst_state(dp, false); } DP_MST_DEBUG("mst_hpd_low. mst_active:%d\n", dp->mst.mst_active); } static int dp_display_process_hpd_low(struct dp_display_private *dp, bool skip_wait) { int rc = 0; dp_display_state_remove(DP_STATE_CONNECTED); dp->process_hpd_connect = false; #if defined(CONFIG_SECDP) secdp_send_hpd_event(&dp->sec, false); cancel_delayed_work(&dp->sec.hpd.noti_work); cancel_delayed_work_sync(&dp->sec.hdcp.start_work); cancel_delayed_work(&dp->sec.link_status_work); cancel_delayed_work(&dp->sec.poor_discon_work); secdp_link_backoff_stop(); #endif dp_audio_enable(dp, false); if (dp->mst.mst_active) { dp_display_process_mst_hpd_low(dp, skip_wait); } else { if ((dp_display_state_is(DP_STATE_CONNECT_NOTIFIED) || dp_display_state_is(DP_STATE_ENABLED))) rc = dp_display_send_hpd_notification(dp, skip_wait); } mutex_lock(&dp->session_lock); if (!dp->active_stream_cnt) dp->ctrl->off(dp->ctrl); mutex_unlock(&dp->session_lock); dp->panel->video_test = false; #if defined(CONFIG_SECDP) secdp_set_wakelock(dp, false); #endif return rc; } static int dp_display_aux_switch_callback(struct notifier_block *self, unsigned long event, void *data) { return 0; } static int dp_display_init_aux_switch(struct dp_display_private *dp) { int rc = 0; struct notifier_block nb; const u32 max_retries = 50; u32 retry; if (dp->aux_switch_ready) return rc; if (!dp->aux->switch_register_notifier) return rc; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY); nb.notifier_call = dp_display_aux_switch_callback; nb.priority = 0; /* * Iteratively wait for reg notifier which confirms that fsa driver is probed. * Bootup DP with cable connected usecase can hit this scenario. */ for (retry = 0; retry < max_retries; retry++) { rc = dp->aux->switch_register_notifier(&nb, dp->aux_switch_node); if (rc == 0) { DP_DEBUG("registered notifier successfully\n"); dp->aux_switch_ready = true; break; } else { DP_DEBUG("failed to register notifier retry=%d rc=%d\n", retry, rc); msleep(100); } } if (retry == max_retries) { DP_WARN("Failed to register fsa notifier\n"); dp->aux_switch_ready = false; return rc; } if (dp->aux->switch_unregister_notifier) dp->aux->switch_unregister_notifier(&nb, dp->aux_switch_node); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, rc); return rc; } static int dp_display_usbpd_configure_cb(struct device *dev) { int rc = 0; struct dp_display_private *dp; if (!dev) { DP_ERR("invalid dev\n"); return -EINVAL; } dp = dev_get_drvdata(dev); if (!dp) { DP_ERR("no driver data found\n"); return -ENODEV; } if (!dp->debug->sim_mode && !dp->no_aux_switch && !dp->parser->gpio_aux_switch && dp->aux_switch_node && dp->aux->switch_configure) { rc = dp_display_init_aux_switch(dp); if (rc) return rc; rc = dp->aux->switch_configure(dp->aux, true, dp->hpd->orientation); if (rc) return rc; } mutex_lock(&dp->session_lock); if (dp_display_state_is(DP_STATE_TUI_ACTIVE)) { dp_display_state_log("[TUI is active]"); mutex_unlock(&dp->session_lock); return 0; } dp_display_state_remove(DP_STATE_ABORTED); dp_display_state_add(DP_STATE_CONFIGURED); rc = dp_display_host_init(dp); if (rc) { DP_ERR("Host init Failed"); mutex_unlock(&dp->session_lock); return rc; } /* check for hpd high */ if (dp->hpd->hpd_high) queue_work(dp->wq, &dp->connect_work); else dp->process_hpd_connect = true; mutex_unlock(&dp->session_lock); return 0; } static void dp_display_clear_reservation(struct dp_display *dp, struct dp_panel *panel) { struct dp_display_private *dp_display; if (!dp || !panel) { DP_ERR("invalid params\n"); return; } dp_display = container_of(dp, struct dp_display_private, dp_display); mutex_lock(&dp_display->accounting_lock); dp_display->tot_lm_blks_in_use -= panel->max_lm; panel->max_lm = 0; if (!dp_display->active_stream_cnt) dp_display->tot_lm_blks_in_use = 0; mutex_unlock(&dp_display->accounting_lock); } static void dp_display_clear_dsc_resources(struct dp_display_private *dp, struct dp_panel *panel) { dp->tot_dsc_blks_in_use -= panel->dsc_blks_in_use; panel->dsc_blks_in_use = 0; } static int dp_display_get_mst_pbn_div(struct dp_display *dp_display) { struct dp_display_private *dp; u32 link_rate, lane_count; if (!dp_display) { DP_ERR("invalid params\n"); return 0; } dp = container_of(dp_display, struct dp_display_private, dp_display); link_rate = drm_dp_bw_code_to_link_rate(dp->link->link_params.bw_code); lane_count = dp->link->link_params.lane_count; return link_rate * lane_count / 54000; } static int dp_display_stream_pre_disable(struct dp_display_private *dp, struct dp_panel *dp_panel) { if (!dp->active_stream_cnt) { DP_WARN("streams already disabled cnt=%d\n", dp->active_stream_cnt); return 0; } dp->ctrl->stream_pre_off(dp->ctrl, dp_panel); return 0; } static void dp_display_stream_disable(struct dp_display_private *dp, struct dp_panel *dp_panel) { if (!dp->active_stream_cnt) { DP_WARN("streams already disabled cnt=%d\n", dp->active_stream_cnt); return; } if (dp_panel->stream_id == DP_STREAM_MAX || !dp->active_panels[dp_panel->stream_id]) { DP_ERR("panel is already disabled\n"); return; } dp_display_clear_dsc_resources(dp, dp_panel); DP_DEBUG("stream_id=%d, active_stream_cnt=%d, tot_dsc_blks_in_use=%d\n", dp_panel->stream_id, dp->active_stream_cnt, dp->tot_dsc_blks_in_use); dp->ctrl->stream_off(dp->ctrl, dp_panel); dp->active_panels[dp_panel->stream_id] = NULL; dp->active_stream_cnt--; } static void dp_display_clean(struct dp_display_private *dp, bool skip_wait) { int idx; struct dp_panel *dp_panel; struct dp_link_hdcp_status *status = &dp->link->hdcp_status; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); if (dp_display_state_is(DP_STATE_TUI_ACTIVE)) { DP_WARN("TUI is active\n"); return; } #if defined(CONFIG_SECDP) cancel_delayed_work(&dp->sec.hpd.noti_work); cancel_delayed_work_sync(&dp->sec.hdcp.start_work); cancel_delayed_work(&dp->sec.link_status_work); cancel_delayed_work(&dp->sec.poor_discon_work); secdp_link_backoff_stop(); #endif if (dp_display_is_hdcp_enabled(dp) && status->hdcp_state != HDCP_STATE_INACTIVE) { cancel_delayed_work_sync(&dp->hdcp_cb_work); if (dp->hdcp.ops->off) dp->hdcp.ops->off(dp->hdcp.data); dp_display_update_hdcp_status(dp, true); } for (idx = DP_STREAM_0; idx < DP_STREAM_MAX; idx++) { if (!dp->active_panels[idx]) continue; dp_panel = dp->active_panels[idx]; if (dp_panel->audio_supported) dp_panel->audio->off(dp_panel->audio, skip_wait); if (!skip_wait) dp_display_stream_pre_disable(dp, dp_panel); dp_display_stream_disable(dp, dp_panel); dp_display_clear_reservation(&dp->dp_display, dp_panel); dp_panel->deinit(dp_panel, 0); } dp_display_state_remove(DP_STATE_ENABLED | DP_STATE_CONNECTED); dp->ctrl->off(dp->ctrl); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); } static int dp_display_handle_disconnect(struct dp_display_private *dp, bool skip_wait) { int rc; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); rc = dp_display_process_hpd_low(dp, skip_wait); if (rc) { /* cancel any pending request */ dp->ctrl->abort(dp->ctrl, true); dp->aux->abort(dp->aux, true); } mutex_lock(&dp->session_lock); if (dp_display_state_is(DP_STATE_ENABLED)) dp_display_clean(dp, skip_wait); dp_display_host_unready(dp); dp->tot_lm_blks_in_use = 0; mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return rc; } static void dp_display_disconnect_sync(struct dp_display_private *dp) { int disconnect_delay_ms; #if defined(CONFIG_SECDP) DP_ENTER("\n"); if (dp->link->poor_connection) { secdp_send_poor_connection_event(dp, false); dp->link->status_update_cnt = 0; dp->sec.hdcp.retry = 0; } #endif SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); /* cancel any pending request */ dp_display_state_add(DP_STATE_ABORTED); dp->ctrl->abort(dp->ctrl, true); dp->aux->abort(dp->aux, true); /* wait for idle state */ cancel_work_sync(&dp->connect_work); cancel_work_sync(&dp->attention_work); cancel_work_sync(&dp->disconnect_work); flush_workqueue(dp->wq); /* * Delay the teardown of the mainlink for better interop experience. * It is possible that certain sinks can issue an HPD high immediately * following an HPD low as soon as they detect the mainlink being * turned off. This can sometimes result in the HPD low pulse getting * lost with certain cable. This issue is commonly seen when running * DP LL CTS test 4.2.1.3. */ disconnect_delay_ms = min_t(u32, dp->debug->disconnect_delay_ms, (u32) MAX_DISCONNECT_DELAY_MS); DP_DEBUG("disconnect delay = %d ms\n", disconnect_delay_ms); msleep(disconnect_delay_ms); dp_display_handle_disconnect(dp, false); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, disconnect_delay_ms); } static int dp_display_usbpd_disconnect_cb(struct device *dev) { int rc = 0; struct dp_display_private *dp; if (!dev) { DP_ERR("invalid dev\n"); rc = -EINVAL; goto end; } dp = dev_get_drvdata(dev); if (!dp) { DP_ERR("no driver data found\n"); rc = -ENODEV; goto end; } #if defined(CONFIG_SECDP) DP_ENTER("\n"); if (atomic_read(&dp->sec.noti_status)) { reinit_completion(&dp->notification_comp); DP_INFO("wait++, psm:%d\n", dp->debug->psm_enabled); if (atomic_read(&dp->sec.noti_status) && !wait_for_completion_timeout(&dp->notification_comp, HZ * 5)) { DP_ERR("notification_comp timeout!\n"); } DP_INFO("wait--\n"); } #endif SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state, dp->debug->psm_enabled); /* skip if a disconnect is already in progress */ if (dp_display_state_is(DP_STATE_ABORTED) && dp_display_state_is(DP_STATE_READY)) { DP_DEBUG("disconnect already in progress\n"); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_CASE1, dp->state); return 0; } if (dp->debug->psm_enabled && dp_display_state_is(DP_STATE_READY)) dp->link->psm_config(dp->link, &dp->panel->link_info, true); dp->ctrl->abort(dp->ctrl, true); dp->aux->abort(dp->aux, true); if (!dp->debug->sim_mode && !dp->no_aux_switch && !dp->parser->gpio_aux_switch && dp->aux->switch_configure) dp->aux->switch_configure(dp->aux, false, ORIENTATION_NONE); dp_display_disconnect_sync(dp); mutex_lock(&dp->session_lock); dp_display_host_deinit(dp); dp_display_state_remove(DP_STATE_CONFIGURED); mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); #if defined(CONFIG_SECDP) /* unset should be here because it's set at above * "dp_display_disconnect_sync()" */ atomic_set(&dp->sec.noti_status, 0); complete(&dp->sec.dp_off_comp); DP_DEBUG("[usbpd_disconnect_cb] done\n"); #endif end: return rc; } static int dp_display_stream_enable(struct dp_display_private *dp, struct dp_panel *dp_panel) { int rc = 0; rc = dp->ctrl->stream_on(dp->ctrl, dp_panel); if (dp->debug->tpg_pattern) dp_panel->tpg_config(dp_panel, dp->debug->tpg_pattern); if (!rc) { dp->active_panels[dp_panel->stream_id] = dp_panel; dp->active_stream_cnt++; } DP_DEBUG("dp active_stream_cnt:%d, tot_dsc_blks_in_use=%d\n", dp->active_stream_cnt, dp->tot_dsc_blks_in_use); return rc; } static void dp_display_mst_attention(struct dp_display_private *dp) { if (dp->mst.mst_active && dp->mst.cbs.hpd_irq) dp->mst.cbs.hpd_irq(&dp->dp_display); DP_MST_DEBUG("mst_attention_work. mst_active:%d\n", dp->mst.mst_active); } static void dp_display_attention_work(struct work_struct *work) { struct dp_display_private *dp = container_of(work, struct dp_display_private, attention_work); int rc = 0; #if defined(CONFIG_SECDP) if (!secdp_get_hpd_status() || !secdp_get_cable_status()) { DP_INFO("hpd_low or cable_lost\n"); return; } DP_DEBUG("request:0x%x\n", dp->link->sink_request); #endif SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); SDE_EVT32_EXTERNAL(dp->state); if (dp_display_state_is(DP_STATE_ABORTED)) { DP_INFO("Hpd off, not handling any attention\n"); mutex_unlock(&dp->session_lock); goto exit; } if (!dp_display_state_is(DP_STATE_READY)) { mutex_unlock(&dp->session_lock); goto mst_attention; } if (dp->link->process_request(dp->link)) { mutex_unlock(&dp->session_lock); goto cp_irq; } mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(dp->state, dp->link->sink_request); if (dp->link->sink_request & DS_PORT_STATUS_CHANGED) { SDE_EVT32_EXTERNAL(dp->state, DS_PORT_STATUS_CHANGED); if (!dp->mst.mst_active) { if (dp_display_is_sink_count_zero(dp)) { dp_display_handle_disconnect(dp, false); } else { /* * connect work should take care of sending * the HPD notification. */ queue_work(dp->wq, &dp->connect_work); } } #if defined(CONFIG_SECDP) /*add some delay to guarantee hpd event handling in framework*/ msleep(60); #endif goto mst_attention; } if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) { SDE_EVT32_EXTERNAL(dp->state, DP_TEST_LINK_VIDEO_PATTERN); dp_display_handle_disconnect(dp, false); dp->panel->video_test = true; /* * connect work should take care of sending * the HPD notification. */ queue_work(dp->wq, &dp->connect_work); goto mst_attention; } if (dp->link->sink_request & (DP_TEST_LINK_PHY_TEST_PATTERN | DP_TEST_LINK_TRAINING | DP_LINK_STATUS_UPDATED)) { mutex_lock(&dp->session_lock); dp_audio_enable(dp, false); if (dp->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) { SDE_EVT32_EXTERNAL(dp->state, DP_TEST_LINK_PHY_TEST_PATTERN); dp->ctrl->process_phy_test_request(dp->ctrl); } if (dp->link->sink_request & DP_TEST_LINK_TRAINING) { SDE_EVT32_EXTERNAL(dp->state, DP_TEST_LINK_TRAINING); dp->link->send_test_response(dp->link); rc = dp->ctrl->link_maintenance(dp->ctrl); } if (dp->link->sink_request & DP_LINK_STATUS_UPDATED) { SDE_EVT32_EXTERNAL(dp->state, DP_LINK_STATUS_UPDATED); rc = dp->ctrl->link_maintenance(dp->ctrl); } if (!rc) dp_audio_enable(dp, true); mutex_unlock(&dp->session_lock); if (rc) goto exit; if (dp->link->sink_request & (DP_TEST_LINK_PHY_TEST_PATTERN | DP_TEST_LINK_TRAINING)) goto mst_attention; } cp_irq: if (dp_display_is_hdcp_enabled(dp) && dp->hdcp.ops->cp_irq) dp->hdcp.ops->cp_irq(dp->hdcp.data); if (!dp->mst.mst_active) { #if defined(CONFIG_SECDP) if (dp->sec.hpd.noti_deferred) { DP_INFO("noti_deferred! skip noti\n"); goto exit; } #endif /* * It is possible that the connect_work skipped sending * the HPD notification if the attention message was * already pending. Send the notification here to * account for that. It is possible that the test sequence * can trigger an unplug after DP_LINK_STATUS_UPDATED, before * starting the next test case. Make sure to check the HPD status. */ if (!dp_display_state_is(DP_STATE_ABORTED)) dp_display_send_hpd_notification(dp, false); } mst_attention: dp_display_mst_attention(dp); exit: #if defined(CONFIG_SECDP) if (dp->link->status_update_cnt > 9 && !dp->link->poor_connection) { dp->link->poor_connection = true; dp->sec.dex.status = dp->sec.dex.prev = dp->sec.dex.curr = DEX_DISABLED; schedule_delayed_work(&dp->sec.link_status_work, msecs_to_jiffies(10)); } #endif SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); } static int dp_display_usbpd_attention_cb(struct device *dev) { struct dp_display_private *dp; if (!dev) { DP_ERR("invalid dev\n"); return -EINVAL; } dp = dev_get_drvdata(dev); if (!dp) { DP_ERR("no driver data found\n"); return -ENODEV; } DP_DEBUG("hpd_irq:%d, hpd_high:%d, power_on:%d, is_connected:%d\n", dp->hpd->hpd_irq, dp->hpd->hpd_high, !!dp_display_state_is(DP_STATE_ENABLED), !!dp_display_state_is(DP_STATE_CONNECTED)); SDE_EVT32_EXTERNAL(dp->state, dp->hpd->hpd_irq, dp->hpd->hpd_high, !!dp_display_state_is(DP_STATE_ENABLED), !!dp_display_state_is(DP_STATE_CONNECTED)); #if !defined(CONFIG_SECDP) if (!dp->hpd->hpd_high) { dp_display_disconnect_sync(dp); return 0; } /* * Ignore all the attention messages except HPD LOW when TUI is * active, so user mode can be notified of the disconnect event. This * allows user mode to tear down the control path after the TUI * session is over. Ideally this should never happen, but on the off * chance that there is a race condition in which there is a IRQ HPD * during tear down of DP at TUI start then this check might help avoid * a potential issue accessing registers in attention processing. */ if (dp_display_state_is(DP_STATE_TUI_ACTIVE)) { DP_WARN("TUI is active\n"); return 0; } if (dp->hpd->hpd_irq && dp_display_state_is(DP_STATE_READY)) { queue_work(dp->wq, &dp->attention_work); complete_all(&dp->attention_comp); } else if (dp->process_hpd_connect || !dp_display_state_is(DP_STATE_CONNECTED)) { dp_display_state_remove(DP_STATE_ABORTED); queue_work(dp->wq, &dp->connect_work); } else { DP_DEBUG("ignored\n"); } #endif return 0; } #if defined(CONFIG_SECDP) #ifdef SECDP_SELF_TEST static void secdp_hdcp_start_work(struct work_struct *work); static void secdp_self_test_hdcp_on(void) { DP_ENTER("\n"); secdp_hdcp_start_work(NULL); } static void secdp_self_test_hdcp_off(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct dp_link_hdcp_status *status; DP_ENTER("\n"); if (secdp_get_cable_status() && dp_display_state_is(DP_STATE_ENABLED)) { status = &dp->link->hdcp_status; if (dp_display_is_hdcp_enabled(dp) && status->hdcp_state != HDCP_STATE_INACTIVE) { cancel_delayed_work(&dp->hdcp_cb_work); usleep_range(3000, 5000); if (dp->hdcp.ops->off) dp->hdcp.ops->off(dp->hdcp.data); dp_display_update_hdcp_status(dp, true); } } } #endif #if IS_ENABLED(CONFIG_PDIC_NOTIFIER) /** true if it's DP_DISCONNECT event, false otherwise */ static bool secdp_is_disconnect(PD_NOTI_TYPEDEF *noti) { bool ret = false; if (noti->id == PDIC_NOTIFY_ID_DP_CONNECT && noti->sub1 == PDIC_NOTIFY_DETACH) ret = true; return ret; } /** true if it's HPD_IRQ event, false otherwise */ static bool secdp_is_hpd_irq(PD_NOTI_TYPEDEF *noti) { bool ret = false; if (noti->id == PDIC_NOTIFY_ID_DP_HPD && noti->sub1 == PDIC_NOTIFY_HIGH && noti->sub2 == PDIC_NOTIFY_IRQ) ret = true; return ret; } /** true if it's HPD_LOW event, false otherwise */ static bool secdp_is_hpd_low(PD_NOTI_TYPEDEF *noti) { bool ret = false; if (noti->id == PDIC_NOTIFY_ID_DP_HPD && noti->sub1 == PDIC_NOTIFY_LOW) ret = true; return ret; } static void secdp_process_attention(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti) { struct secdp_misc *sec = NULL; if (!noti || !dp) goto end; DP_DEBUG("sub1:%d sub2:%d sub3:%d\n", noti->sub1, noti->sub2, noti->sub3); sec = &dp->sec; sec->dex.reconnecting = false; if (secdp_is_disconnect(noti)) { cancel_delayed_work_sync(&sec->poor_discon_work); dp_display_usbpd_disconnect_cb(&dp->pdev->dev); goto end; } if (secdp_is_hpd_low(noti)) { sec->dex.status = sec->dex.prev = sec->dex.curr = DEX_DISABLED; secdp_clear_link_status_cnt(dp->link); dp_display_disconnect_sync(dp); DP_INFO("active_stream_cnt %d\n", dp->active_stream_cnt); if (!dp->active_stream_cnt) dp_display_host_deinit(dp); goto end; } /* * see "dp_display_usbpd_attention_cb" at sm8350 post-cs2 * * Ignore all the attention messages except HPD LOW when TUI is * active, so user mode can be notified of the disconnect event. This * allows user mode to tear down the control path after the TUI * session is over. Ideally this should never happen, but on the off * chance that there is a race condition in which there is a IRQ HPD * during tear down of DP at TUI start then this check might help avoid * a potential issue accessing registers in attention processing. */ if (dp_display_state_is(DP_STATE_TUI_ACTIVE)) { DP_WARN("TUI is active\n"); goto end; } if (secdp_is_hpd_irq(noti)) { if (secdp_get_reboot_status()) { DP_INFO("shutdown!\n"); goto end; } if (!secdp_get_cable_status()) { DP_INFO("cable is out!\n"); goto end; } if (dp->link->poor_connection) { DP_INFO("poor connection!\n"); goto end; } if (!dp_display_state_is(DP_STATE_ENABLED)) { if (dp->mst.mst_active) goto attention; /* SECDP_ADT_SST */ if (dp->link->poor_connection) { DP_INFO("poor connection!!\n"); goto end; } if (!dp_display_state_is(DP_STATE_CONNECTED)) { /* aux timeout happens whenever DeX * reconnect scenario, init aux here */ dp_display_host_unready(dp); dp_display_host_deinit(dp); usleep_range(5000, 6000); DP_DEBUG("handle HPD_IRQ as HPD_HIGH!\n"); goto hpd_high; } } attention: /* irq_hpd: do the same with: dp_display_usbpd_attention_cb */ queue_work(dp->wq, &dp->attention_work); complete_all(&dp->attention_comp); goto end; } hpd_high: if (sec->extdisp_off) { DP_INFO("extdisp_off\n"); goto end; } /* hpd high: do the same with: dp_display_usbpd_attention_cb */ DP_INFO("connected:%d\n", dp_display_state_is(DP_STATE_CONNECTED)); if (!dp_display_state_is(DP_STATE_CONNECTED)) { secdp_clear_link_status_cnt(dp->link); dp_display_state_remove(DP_STATE_ABORTED); queue_work(dp->wq, &dp->connect_work); } end: return; } static void secdp_adapter_init(struct dp_display_private *dp) { struct secdp_adapter *adapter = &dp->sec.adapter; memset(adapter, 0, sizeof(struct secdp_adapter)); } static void secdp_adapter_check_legacy(struct dp_display_private *dp) { struct secdp_adapter *adapter = &dp->sec.adapter; bool legacy = false; if (adapter->ven_id != SAMSUNG_VENDOR_ID) goto end; switch (adapter->prod_id) { case DEXPAD_PRODUCT_ID: case DEXCABLE_PRODUCT_ID: case MPA2_PRODUCT_ID: case MPA3_PRODUCT_ID: legacy = true; break; default: break; } DP_INFO("ss_legacy:%d\n", legacy); end: adapter->ss_legacy = legacy; } /** * check connected dongle type with given vid and pid. Based upon this info, * we can decide maximum dex resolution for that cable/adapter. */ static void secdp_adapter_check_dex(struct dp_display_private *dp) { struct secdp_adapter *adapter = &dp->sec.adapter; enum dex_support_res_t dex_type = DEX_RES_DFT; bool ss_fan = false; #ifdef NOT_SUPPORT_DEX_RES_CHANGE adapter->dex_type = DEX_RES_NOT_SUPPORT; return; #endif if (dp->parser->dex_dft_res > DEX_RES_NOT_SUPPORT) { dex_type = dp->parser->dex_dft_res; goto end; } if (adapter->ven_id != SAMSUNG_VENDOR_ID) goto end; switch (adapter->prod_id) { case DEXDOCK_PRODUCT_ID: case DEXPAD_PRODUCT_ID: dex_type = DEX_RES_MAX; ss_fan = true; break; default: break; } end: DP_INFO("fan:%d %s\n", ss_fan, secdp_dex_res_to_string(dex_type)); adapter->dex_type = dex_type; } static void secdp_adapter_check(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti, bool connect) { struct secdp_adapter *adapter = &dp->sec.adapter; secdp_adapter_init(dp); if (!connect) goto end; adapter->ven_id = (uint)(noti->sub2); adapter->prod_id = (uint)(noti->sub3); if (adapter->ven_id == SAMSUNG_VENDOR_ID) adapter->ss_genuine = true; DP_INFO("venId:0x%04x prodId:0x%04x genuine:%d\n", adapter->ven_id, adapter->prod_id, adapter->ss_genuine); secdp_adapter_check_dex(dp); secdp_adapter_check_legacy(dp); end: return; } static void secdp_pdic_connect_init(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti, bool connect) { struct secdp_misc *sec = &dp->sec; dp->hpd->orientation = connect ? secdp_get_plug_orientation(dp->power) : ORIENTATION_NONE; dp->hpd->multi_func = false; sec->pdic_noti.reset = false; sec->cable_connected = dp->hpd->alt_mode_cfg_done = connect; sec->link_conf = false; sec->hdcp.retry = 0; secdp_adapter_check(dp, noti, connect); /* set flags here as soon as disconnected * resource clear will be made later at "secdp_process_attention" */ sec->dex.res = connect ? sec->adapter.dex_type : DEX_RES_NOT_SUPPORT; sec->dex.prev = sec->dex.curr = sec->dex.status = DEX_DISABLED; sec->dex.reconnecting = false; secdp_clear_branch_info(dp); secdp_clear_link_status_cnt(dp->link); #if defined(CONFIG_SECDP_BIGDATA) if (connect) { secdp_bigdata_connection(); secdp_bigdata_save_item(BD_ORIENTATION, (dp->hpd->orientation == ORIENTATION_CC1) ? "CC1" : "CC2"); secdp_bigdata_save_item(BD_ADT_VID, noti->sub2); secdp_bigdata_save_item(BD_ADT_PID, noti->sub3); } else { secdp_bigdata_disconnection(); } #endif } static void secdp_pdic_handle_connect(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti) { secdp_pdic_connect_init(dp, noti, true); #ifndef SECDP_USB_CONCURRENCY /* see dp_display_usbpd_configure_cb() */ dp_display_host_init(dp); #endif #ifdef SECDP_SELF_TEST if (secdp_self_test_status(ST_CONNECTION_TEST) >= 0) secdp_self_test_start_reconnect(dp->sec.sysfs, secdp_reconnect); #endif } static void secdp_pdic_handle_disconnect(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti) { struct secdp_misc *sec = &dp->sec; sec->dp_disconnecting = true; atomic_set(&sec->hpd.val, 0); dp->hpd->hpd_high = false; secdp_power_unset_gpio(dp->power); secdp_redriver_onoff(dp->power, false, 0); secdp_pdic_connect_init(dp, noti, false); } static void secdp_pdic_handle_linkconf(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti) { struct secdp_misc *sec = &dp->sec; sec->link_conf = true; /* see dp_display_usbpd_configure_cb() */ dp_display_state_remove(DP_STATE_ABORTED); dp_display_state_add(DP_STATE_CONFIGURED); #ifdef SECDP_USB_CONCURRENCY if (noti->sub1 == PDIC_NOTIFY_DP_PIN_B || noti->sub1 == PDIC_NOTIFY_DP_PIN_D || noti->sub1 == PDIC_NOTIFY_DP_PIN_F) { dp->hpd->multi_func = true; secdp_redriver_onoff(dp->power, true, 2); } else { dp->hpd->multi_func = false; secdp_redriver_onoff(dp->power, true, 4); } DP_INFO("multi_func:%d\n", dp->hpd->multi_func); #endif #if defined(CONFIG_SECDP_BIGDATA) secdp_bigdata_save_item(BD_LINK_CONFIGURE, noti->sub1 + 'A' - 1); #endif } static void secdp_pdic_handle_hpd(struct dp_display_private *dp, PD_NOTI_TYPEDEF *noti) { struct secdp_misc *sec = &dp->sec; if (noti->sub1 == PDIC_NOTIFY_HIGH) { bool flip = false; atomic_set(&sec->hpd.val, 1); dp->hpd->hpd_high = true; secdp_send_hpd_event(&dp->sec, true); if (dp->hpd->orientation == ORIENTATION_CC2) flip = true; secdp_power_set_gpio(dp->power, flip); } else/* if (noti->sub1 == PDIC_NOTIFY_LOW)*/ { atomic_set(&sec->hpd.val, 0); dp->hpd->hpd_high = false; secdp_power_unset_gpio(dp->power); } } static int secdp_pdic_noti_cb(struct notifier_block *nb, unsigned long action, void *data) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec = &dp->sec; PD_NOTI_TYPEDEF noti = *(PD_NOTI_TYPEDEF *)data; int rc = 0; if (noti.dest != PDIC_NOTIFY_DEV_DP) { /*DP_DEBUG("not DP, skip\n");*/ goto end; } switch (noti.id) { case PDIC_NOTIFY_ID_ATTACH: DP_INFO("PDIC_NOTIFY_ID_ATTACH\n"); break; case PDIC_NOTIFY_ID_DP_CONNECT: secdp_logger_set_max_count(300); DP_INFO("PDIC_NOTIFY_ID_DP_CONNECT<%d>\n", noti.sub1); if (noti.sub1 == PDIC_NOTIFY_ATTACH) { secdp_pdic_handle_connect(dp, ¬i); } else if (noti.sub1 == PDIC_NOTIFY_DETACH) { if (!secdp_get_cable_status()) { DP_INFO("already disconnected\n"); goto end; } secdp_pdic_handle_disconnect(dp, ¬i); } break; case PDIC_NOTIFY_ID_DP_LINK_CONF: DP_INFO("PDIC_NOTIFY_ID_DP_LINK_CONF<%c>\n", noti.sub1 + 'A' - 1); if (!secdp_get_cable_status()) { DP_INFO("cable is out\n"); goto end; } secdp_pdic_handle_linkconf(dp, ¬i); break; case PDIC_NOTIFY_ID_DP_HPD: if (!secdp_is_hpd_irq(¬i)) secdp_logger_set_max_count(300); DP_INFO("PDIC_NOTIFY_ID_DP_HPD<%s><%s>\n", (noti.sub1 == PDIC_NOTIFY_HIGH) ? "high" : ((noti.sub1 == PDIC_NOTIFY_LOW) ? "low" : "."), (noti.sub2 == PDIC_NOTIFY_IRQ) ? "irq" : "."); if (!secdp_get_cable_status()) { DP_INFO("cable is out\n"); goto end; } secdp_pdic_handle_hpd(dp, ¬i); break; default: break; } if ((sec->link_conf && secdp_get_hpd_status()) ||/*hpd high or hpd_irq*/ secdp_is_hpd_low(¬i) || secdp_is_disconnect(¬i)) { /* see "secdp_handle_attention()" */ mutex_lock(&sec->attention_lock); secdp_process_attention(dp, ¬i); mutex_unlock(&sec->attention_lock); if (secdp_is_disconnect(¬i)) { cancel_work_sync(&dp->connect_work); if (dp_display_state_is(DP_STATE_ENABLED) || atomic_read(&sec->noti_status)) { u64 ret; DP_DEBUG("wait for detach complete\n"); init_completion(&sec->dp_off_comp); ret = wait_for_completion_timeout(&sec->dp_off_comp, msecs_to_jiffies(13500)); if (!ret) { DP_ERR("dp_off_comp timeout\n"); complete_all(&dp->notification_comp); msleep(100); } else { DP_DEBUG("detach complete!\n"); } atomic_set(&sec->noti_status, 0); } sec->dp_disconnecting = false; DP_INFO("DP disconnection complete\n"); dwc3_msm_set_dp_mode_for_ss(false); complete(&sec->dp_discon_comp); } } end: return rc; } #endif /** * returns 0 if DP disconnect is completed * returns -1 if DP disconnect is not completed until timeout */ int secdp_wait_for_disconnect_complete(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec = NULL; u64 rc; int ret = 0; if (!dp) { DP_INFO("dp driver is not initialized completely"); ret = -1; goto end; } sec = &dp->sec; if (!sec->dp_disconnecting) { DP_INFO("DP is not disconnecting now\n"); goto end; } DP_INFO("wait start\n"); init_completion(&sec->dp_discon_comp); rc = wait_for_completion_timeout(&sec->dp_discon_comp, msecs_to_jiffies(17000)); if (!rc) { DP_ERR("DP disconnect timeout\n"); dp->sec.pdic_noti.reset = true; ret = -1; goto end; } DP_INFO("DP disconnect complete!\n"); end: return ret; } EXPORT_SYMBOL(secdp_wait_for_disconnect_complete); /** * if SSUSB gets reset, it needs to call this callback to let DP know, since * DP shares PHY with SSUSB (combo PHY) * return 0 if success * return -1 otherwise */ int secdp_pdic_reset_cb(bool reset) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec; int ret = -1; if (!dp) { DP_INFO("DP is not yet initialized\n"); goto end; } DP_INFO("[reset_cb] %d\n", reset); sec = &dp->sec; if (secdp_get_cable_status()) { bool lnk_cnf = sec->link_conf; int hpd_val = secdp_get_hpd_status(); if (lnk_cnf && hpd_val) { DP_ERR("DP connected and [LNK_CNF:%d,HPD:%d], abnormal!\n", lnk_cnf, hpd_val); goto abnormal; } else { DP_DEBUG("DP connected but [LNK_CNF:%d,HPD:%d], normal\n", lnk_cnf, hpd_val); goto end; } } else { if (sec->dp_disconnecting) { DP_ERR("DP disconnection under processing!\n"); goto abnormal; } else { DP_DEBUG("DP is not connected or disconnection complete\n"); goto end; } } abnormal: sec->pdic_noti.reset = reset; ret = 0; end: return ret; } EXPORT_SYMBOL(secdp_pdic_reset_cb); /** * returns true if PHY has reset after DP connection unexpectedly * returns false otherwise */ bool secdp_phy_reset_check(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); bool ret = false; if (!dp || !dp->power) goto end; /* check if core clk is off */ if (!dp->power->clk_status(dp->power, DP_CORE_PM)) { ret = true; goto end; } /* check if PDIC or SSUSB PHY went reset */ ret = dp->sec.pdic_noti.reset; end: return ret; } int secdp_pdic_noti_register_ex(struct secdp_misc *sec, bool retry) { struct secdp_pdic_noti *pdic_noti = &sec->pdic_noti; int rc = -1; #if IS_ENABLED(CONFIG_USB_TYPEC_MANAGER_NOTIFIER) rc = manager_notifier_register(&pdic_noti->nb, secdp_pdic_noti_cb, MANAGER_NOTIFY_PDIC_DP); if (!rc) { pdic_noti->registered = true; DP_INFO("noti register success\n"); goto exit; } #endif DP_ERR("noti register fail, rc:%d\n", rc); if (!retry) goto exit; DP_ERR("manager_dev is not ready, try again in %d[ms]\n", PDIC_DP_NOTI_REG_DELAY); schedule_delayed_work(&pdic_noti->reg_work, msecs_to_jiffies(PDIC_DP_NOTI_REG_DELAY)); exit: return rc; } static void secdp_pdic_noti_register(struct work_struct *work) { struct delayed_work *dw; struct secdp_pdic_noti *pdic_noti; struct secdp_misc *sec; int rc; dw = to_delayed_work(work); pdic_noti = container_of(dw, struct secdp_pdic_noti, reg_work); sec = container_of(pdic_noti, struct secdp_misc, pdic_noti); mutex_lock(&sec->notifier_lock); if (secdp_get_lpm_mode(sec)) { DP_INFO("it's LPM mode. skip\n"); goto exit; } if (pdic_noti->registered) { DP_INFO("already registered\n"); goto exit; } rc = secdp_pdic_noti_register_ex(sec, true); if (rc) { DP_ERR("fail, rc(%d)\n", rc); goto exit; } pdic_noti->registered = true; /* cancel immediately */ rc = cancel_delayed_work(&pdic_noti->reg_work); DP_DEBUG("cancel_work,%d\n", rc); destroy_delayed_work_on_stack(&pdic_noti->reg_work); exit: mutex_unlock(&sec->notifier_lock); } int secdp_send_deferred_hpd_noti(struct secdp_misc *sec) { struct dp_display_private *dp; int rc = 0; dp = container_of(sec, struct dp_display_private, sec); DP_INFO("noti_deferred %d\n", sec->hpd.noti_deferred); cancel_delayed_work_sync(&sec->hpd.noti_work); if (sec->hpd.noti_deferred) { rc = dp_display_send_hpd_notification(dp, false); sec->hpd.noti_deferred = false; } return rc; } static void secdp_hpd_noti_work(struct work_struct *work) { struct delayed_work *dw; struct secdp_hpd *hpd; struct secdp_misc *sec; struct dp_display_private *dp; dw = to_delayed_work(work); hpd = container_of(dw, struct secdp_hpd, noti_work); sec = container_of(hpd, struct secdp_misc, hpd); dp = container_of(sec, struct dp_display_private, sec); DP_INFO("hpd_noti_work %d\n", hpd->noti_deferred); dp_display_send_hpd_notification(dp, false); hpd->noti_deferred = false; } static void secdp_hdcp_start_work(struct work_struct *work) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); DP_ENTER("\n"); if (secdp_get_cable_status() && dp_display_state_is(DP_STATE_ENABLED)) { cancel_delayed_work_sync(&dp->hdcp_cb_work); queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ / 4); } } static void secdp_poor_disconnect_work(struct work_struct *work) { struct delayed_work *dw; struct secdp_misc *sec; struct dp_display_private *dp; dw = to_delayed_work(work); sec = container_of(dw, struct secdp_misc, poor_discon_work); dp = container_of(sec, struct dp_display_private, sec); DP_INFO("poor %d\n", dp->link->poor_connection); if (!dp->link->poor_connection) dp->link->poor_connection = true; dp_display_disconnect_sync(dp); mutex_lock(&dp->session_lock); dp_display_host_deinit(dp); dp_display_state_remove(DP_STATE_CONFIGURED); mutex_unlock(&dp->session_lock); } #define LINK_BACKOFF_TIMER 120000 /*2min*/ void secdp_link_backoff_start(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec = &dp->sec; if (sec->backoff_start) { //DP_DEBUG("[backoff] already queued\n"); return; } schedule_delayed_work(&sec->link_backoff_work, msecs_to_jiffies(LINK_BACKOFF_TIMER)); sec->backoff_start = true; DP_INFO("[backoff] started\n"); } void secdp_link_backoff_stop(void) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec = &dp->sec; if (!sec->backoff_start) { //DP_DEBUG("[backoff] already cancelled\n"); return; } cancel_delayed_work(&sec->link_backoff_work); sec->backoff_start = false; DP_INFO("[backoff] stopped\n"); } static void secdp_link_backoff_work(struct work_struct *work) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); struct secdp_misc *sec = &dp->sec; if (!secdp_get_cable_status() || !dp_display_state_is(DP_STATE_ENABLED)) return; //DP_DEBUG("[backoff] status_update_cnt %d\n", dp->link->status_update_cnt); if (dp->link->status_update_cnt > 0) dp->link->status_update_cnt--; if (!dp->link->status_update_cnt) { sec->backoff_start = false; DP_INFO("[backoff] finished\n"); return; } schedule_delayed_work(&sec->link_backoff_work, msecs_to_jiffies(LINK_BACKOFF_TIMER)); DP_INFO("[backoff] re-started %d\n", dp->link->status_update_cnt); } /** * This logic is to check poor DP connection. if link train is failed or * HPD_IRQ is coming more than 4th times in 13 sec, regard it as a poor * connection and do DP disconnection */ static void secdp_link_status_work(struct work_struct *work) { struct delayed_work *dw; struct secdp_misc *sec; struct dp_display_private *dp; int status_update_cnt; dw = to_delayed_work(work); sec = container_of(dw, struct secdp_misc, link_status_work); dp = container_of(sec, struct dp_display_private, sec); status_update_cnt = dp->link->status_update_cnt; DP_INFO("[link_work] status_update_cnt %d\n", status_update_cnt); if (dp->link->poor_connection) { DP_INFO("[link_work] poor connection!\n"); goto poor_disconnect; } if (secdp_get_cable_status() && dp_display_state_is(DP_STATE_ENABLED) && sec->dex.curr != DEX_DISABLED) { if (!secdp_get_link_train_status(dp->ctrl) || status_update_cnt > MAX_CNT_LINK_STATUS_UPDATE) { DP_INFO("poor!\n"); goto poor_disconnect; } if (!secdp_check_link_stable(dp->link)) { DP_INFO("Check poor connection, again\n"); schedule_delayed_work(&sec->link_status_work, msecs_to_jiffies(3000)); } } DP_LEAVE("\n"); return; poor_disconnect: schedule_delayed_work(&sec->poor_discon_work, msecs_to_jiffies(10)); } #ifdef MODEM_RF_INFO /* CP notity format (HEX raw format) * 10 00 AA BB 27 01 03 XX YY YY YY YY ZZ ZZ ZZ ZZ * * 00 10 (0x0010) - len * AA BB - not used * 27 - MAIN CMD (SYSTEM CMD : 0x27) * 01 - SUB CMD (CP Channel Info : 0x01) * 03 - NOTI CMD (0x03) * XX - RAT MODE * YY YY YY YY - BAND MODE * ZZ ZZ ZZ ZZ - FREQ INFO */ int secdp_modem_rfinfo_cb(struct notifier_block *nb, unsigned long size, void *data) { struct secdp_misc *sec = container_of(nb, struct secdp_misc, modem_rfinfo_nb); struct dev_ril_bridge_msg *msg = (struct dev_ril_bridge_msg *)data; int ret = NOTIFY_DONE; DP_INFO("RF_info: size %lu, dev_id %d, len %d\n", size, msg->dev_id, msg->data_len); if (msg->dev_id == IPC_SYSTEM_CP_CHANNEL_INFO && msg->data_len == sizeof(struct rf_information)) { memcpy(&sec->rf_info, msg->data, sizeof(struct rf_information)); DP_INFO("RAT %u, BAND %u, ARFCN %u\n", sec->rf_info.rat, sec->rf_info.band, sec->rf_info.arfcn); //.TODO: } return ret; } #endif static int secdp_init(struct dp_display_private *dp) { struct secdp_misc *sec; int rc = -1; if (!dp) { DP_ERR("error! no dp structure\n"); goto end; } secdp_logger_init(); sec = &dp->sec; sec->lpm_booting = (secdp_param_lpcharge == 1) ? true : false; init_completion(&sec->dp_off_comp); init_completion(&sec->dp_discon_comp); atomic_set(&sec->noti_status, 0); INIT_DELAYED_WORK(&sec->hpd.noti_work, secdp_hpd_noti_work); INIT_DELAYED_WORK(&sec->hdcp.start_work, secdp_hdcp_start_work); INIT_DELAYED_WORK(&sec->link_status_work, secdp_link_status_work); INIT_DELAYED_WORK(&sec->link_backoff_work, secdp_link_backoff_work); INIT_DELAYED_WORK(&sec->poor_discon_work, secdp_poor_disconnect_work); INIT_DELAYED_WORK(&sec->pdic_noti.reg_work, secdp_pdic_noti_register); schedule_delayed_work(&sec->pdic_noti.reg_work, msecs_to_jiffies(PDIC_DP_NOTI_REG_DELAY)); rc = secdp_power_request_gpios(dp->power); if (rc) DP_ERR("DRM DP gpio request failed:%d\n", rc); mutex_init(&sec->notify_lock); mutex_init(&sec->attention_lock); mutex_init(&sec->notifier_lock); mutex_init(&sec->hmd.lock); secdp_init_wakelock(dp); /* reboot notifier callback */ sec->reboot_nb.notifier_call = secdp_reboot_cb; #ifndef CONFIG_UML register_reboot_notifier(&sec->reboot_nb); #endif #if defined(CONFIG_SECDP_SWITCH) rc = switch_dev_register(&switch_secdp_msg); if (rc) DP_INFO("Failed to register secdp_msg switch:%d\n", rc); #endif if (dp->parser->rf_tx_backoff) { /* DEVPATH=/devices/virtual/sec/secdp */ sec->uevent_dev = sec_device_create(NULL, "secdp"); } #ifdef MODEM_RF_INFO //sec->modem_rfinfo_nb.priority = 0; sec->modem_rfinfo_nb.notifier_call = secdp_modem_rfinfo_cb; register_dev_ril_bridge_event_notifier(&sec->modem_rfinfo_nb); #endif /* add default AR/VR here */ strlcpy(sec->hmd.list[0].monitor_name, "PicoVR", MON_NAME_LEN); sec->hmd.list[0].ven_id = 0x2d40; sec->hmd.list[0].prod_id = 0x0000; DP_INFO("secdp init done\n"); end: return rc; } static void secdp_deinit(struct dp_display_private *dp) { struct secdp_misc *sec; if (!dp) { DP_ERR("error! no dp structure\n"); goto end; } sec = &dp->sec; if (dp->parser->rf_tx_backoff) sec_device_destroy(sec->uevent_dev->devt); #ifdef MODEM_RF_INFO unregister_dev_ril_bridge_event_notifier(&sec->modem_rfinfo_nb); #endif secdp_destroy_wakelock(dp); secdp_logger_deinit(); mutex_destroy(&sec->notify_lock); mutex_destroy(&sec->attention_lock); mutex_destroy(&sec->notifier_lock); mutex_destroy(&sec->hmd.lock); sec->sysfs = NULL; #if defined(CONFIG_SECDP_SWITCH) switch_dev_unregister(&switch_secdp_msg); #endif end: return; } #endif static void dp_display_connect_work(struct work_struct *work) { int rc = 0; struct dp_display_private *dp = container_of(work, struct dp_display_private, connect_work); if (dp_display_state_is(DP_STATE_TUI_ACTIVE)) { dp_display_state_log("[TUI is active]"); return; } if (dp_display_state_is(DP_STATE_ABORTED)) { DP_WARN("HPD off requested\n"); return; } if (!dp->hpd->hpd_high) { DP_WARN("Sink disconnected\n"); return; } #if defined(CONFIG_SECDP) DP_ENTER("\n"); dp_display_host_init(dp); /* fix for PHY CTS v1.2 - 8.1 AUX Manchester - Channel EYE Test failure. * whenever HPD goes high, AUX init makes RC delay and actual AUX * transfer starts even when RC is not yet stabilized. To make RC * waveform to be stable, put some delay here */ msleep(200); #endif rc = dp_display_process_hpd_high(dp); if (!rc && dp->panel->video_test) dp->link->send_test_response(dp->link); } static void dp_display_disconnect_work(struct work_struct *work) { struct dp_display_private *dp = container_of(work, struct dp_display_private, disconnect_work); dp_display_handle_disconnect(dp, false); if (dp->debug->sim_mode && dp_display_state_is(DP_STATE_ABORTED)) dp_display_host_deinit(dp); dp->debug->abort(dp->debug); } #if !defined(CONFIG_SECDP) static int dp_display_usb_notifier(struct notifier_block *nb, unsigned long action, void *data) { struct dp_display_private *dp = container_of(nb, struct dp_display_private, usb_nb); SDE_EVT32_EXTERNAL(dp->state, dp->debug->sim_mode, action); if (!action && dp->debug->sim_mode) { DP_WARN("usb disconnected during simulation\n"); dp_display_state_add(DP_STATE_ABORTED); dp->ctrl->abort(dp->ctrl, true); dp->aux->abort(dp->aux, true); dp->power->park_clocks(dp->power); queue_work(dp->wq, &dp->disconnect_work); } SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, NOTIFY_DONE); return NOTIFY_DONE; } static void dp_display_register_usb_notifier(struct dp_display_private *dp) { int rc = 0; const char *phandle = "usb-phy"; struct usb_phy *usbphy; usbphy = devm_usb_get_phy_by_phandle(&dp->pdev->dev, phandle, 0); if (IS_ERR_OR_NULL(usbphy)) { DP_DEBUG("unable to get usbphy\n"); return; } dp->usb_nb.notifier_call = dp_display_usb_notifier; dp->usb_nb.priority = 2; rc = usb_register_notifier(usbphy, &dp->usb_nb); if (rc) DP_DEBUG("failed to register for usb event: %d\n", rc); } #endif int dp_display_mmrm_callback(struct mmrm_client_notifier_data *notifier_data) { struct dss_clk_mmrm_cb *mmrm_cb_data = (struct dss_clk_mmrm_cb *)notifier_data->pvt_data; struct dp_display *dp_display = (struct dp_display *)mmrm_cb_data->phandle; struct dp_display_private *dp = container_of(dp_display, struct dp_display_private, dp_display); int ret = 0; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state, notifier_data->cb_type); if (notifier_data->cb_type == MMRM_CLIENT_RESOURCE_VALUE_CHANGE && dp_display_state_is(DP_STATE_ENABLED) && !dp_display_state_is(DP_STATE_ABORTED)) { ret = dp_display_handle_disconnect(dp, false); if (ret) DP_ERR("mmrm callback error reducing clk, ret:%d\n", ret); } DP_DEBUG("mmrm callback handled, state: 0x%x rc:%d\n", dp->state, ret); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, notifier_data->cb_type); return ret; } static void dp_display_deinit_sub_modules(struct dp_display_private *dp) { #if defined(CONFIG_SECDP) struct device *dev = &dp->pdev->dev; DP_ENTER("\n"); secdp_deinit(dp); secdp_sysfs_put(dev, dp->sec.sysfs); #endif dp_debug_put(dp->debug); dp_hpd_put(dp->hpd); if (dp->panel) dp_audio_put(dp->panel->audio); dp_ctrl_put(dp->ctrl); dp_panel_put(dp->panel); dp_link_put(dp->link); dp_power_put(dp->power); dp_pll_put(dp->pll); dp_aux_put(dp->aux); dp_catalog_put(dp->catalog); dp_parser_put(dp->parser); mutex_destroy(&dp->session_lock); } static int dp_init_sub_modules(struct dp_display_private *dp) { int rc = 0; u32 dp_core_revision = 0; bool hdcp_disabled; const char *phandle = "qcom,dp-aux-switch"; struct device *dev = &dp->pdev->dev; struct dp_hpd_cb *cb = &dp->hpd_cb; struct dp_ctrl_in ctrl_in = { .dev = dev, }; struct dp_panel_in panel_in = { .dev = dev, }; struct dp_debug_in debug_in = { .dev = dev, }; struct dp_pll_in pll_in = { .pdev = dp->pdev, }; #if defined(CONFIG_SECDP) struct secdp_sysfs_in sysfs_in = { .dev = dev, }; #endif mutex_init(&dp->session_lock); mutex_init(&dp->accounting_lock); dp->parser = dp_parser_get(dp->pdev); if (IS_ERR(dp->parser)) { rc = PTR_ERR(dp->parser); DP_ERR("failed to initialize parser, rc = %d\n", rc); dp->parser = NULL; goto error; } rc = dp->parser->parse(dp->parser); if (rc) { DP_ERR("device tree parsing failed\n"); goto error_catalog; } g_dp_display->is_mst_supported = dp->parser->has_mst; g_dp_display->dsc_cont_pps = dp->parser->dsc_continuous_pps; dp->catalog = dp_catalog_get(dev, dp->parser); if (IS_ERR(dp->catalog)) { rc = PTR_ERR(dp->catalog); DP_ERR("failed to initialize catalog, rc = %d\n", rc); dp->catalog = NULL; goto error_catalog; } dp_core_revision = dp_catalog_get_dp_core_version(dp->catalog); dp->aux_switch_node = of_parse_phandle(dp->pdev->dev.of_node, phandle, 0); if (!dp->aux_switch_node) { dp->no_aux_switch = true; DP_WARN("Aux switch node not found, assigning bypass mode as switch type\n"); dp->switch_type = DP_AUX_SWITCH_BYPASS; goto skip_node_name; } if (!strcmp(dp->aux_switch_node->name, "fsa4480")) dp->switch_type = DP_AUX_SWITCH_FSA4480; else if (!strcmp(dp->aux_switch_node->name, "wcd939x_i2c")) dp->switch_type = DP_AUX_SWITCH_WCD939x; else dp->switch_type = DP_AUX_SWITCH_BYPASS; skip_node_name: dp->aux = dp_aux_get(dev, &dp->catalog->aux, dp->parser, #if !defined(CONFIG_SECDP) dp->aux_switch_node, dp->aux_bridge, g_dp_display->dp_aux_ipc_log); #else dp->aux_switch_node, dp->aux_bridge, g_dp_display->dp_aux_ipc_log, (void*)&dp->sec); #endif if (IS_ERR(dp->aux)) { rc = PTR_ERR(dp->aux); DP_ERR("failed to initialize aux, rc = %d\n", rc); dp->aux = NULL; goto error_aux; } rc = dp->aux->drm_aux_register(dp->aux, dp->dp_display.drm_dev); if (rc) { DP_ERR("DRM DP AUX register failed\n"); goto error_pll; } pll_in.aux = dp->aux; pll_in.parser = dp->parser; pll_in.dp_core_revision = dp_core_revision; dp->pll = dp_pll_get(&pll_in); if (IS_ERR(dp->pll)) { rc = PTR_ERR(dp->pll); DP_ERR("failed to initialize pll, rc = %d\n", rc); dp->pll = NULL; goto error_pll; } dp->power = dp_power_get(dp->parser, dp->pll); if (IS_ERR(dp->power)) { rc = PTR_ERR(dp->power); DP_ERR("failed to initialize power, rc = %d\n", rc); dp->power = NULL; goto error_power; } rc = dp->power->power_client_init(dp->power, &dp->priv->phandle, dp->dp_display.drm_dev); if (rc) { DP_ERR("Power client create failed\n"); goto error_link; } rc = dp->power->power_mmrm_init(dp->power, &dp->priv->phandle, (void *)&dp->dp_display, dp_display_mmrm_callback); if (rc) { DP_ERR("failed to initialize mmrm, rc = %d\n", rc); goto error_link; } dp->link = dp_link_get(dev, dp->aux, dp_core_revision); if (IS_ERR(dp->link)) { rc = PTR_ERR(dp->link); DP_ERR("failed to initialize link, rc = %d\n", rc); dp->link = NULL; goto error_link; } panel_in.aux = dp->aux; panel_in.catalog = &dp->catalog->panel; panel_in.link = dp->link; panel_in.connector = dp->dp_display.base_connector; panel_in.base_panel = NULL; panel_in.parser = dp->parser; #if defined(CONFIG_SECDP) panel_in.sec = &dp->sec; #endif dp->panel = dp_panel_get(&panel_in); if (IS_ERR(dp->panel)) { rc = PTR_ERR(dp->panel); DP_ERR("failed to initialize panel, rc = %d\n", rc); dp->panel = NULL; goto error_panel; } ctrl_in.link = dp->link; ctrl_in.panel = dp->panel; ctrl_in.aux = dp->aux; ctrl_in.power = dp->power; ctrl_in.catalog = &dp->catalog->ctrl; ctrl_in.parser = dp->parser; ctrl_in.pll = dp->pll; #if defined(CONFIG_SECDP) ctrl_in.sec = &dp->sec; #endif dp->ctrl = dp_ctrl_get(&ctrl_in); if (IS_ERR(dp->ctrl)) { rc = PTR_ERR(dp->ctrl); DP_ERR("failed to initialize ctrl, rc = %d\n", rc); dp->ctrl = NULL; goto error_ctrl; } dp->panel->audio = dp_audio_get(dp->pdev, dp->panel, &dp->catalog->audio); if (IS_ERR(dp->panel->audio)) { rc = PTR_ERR(dp->panel->audio); DP_ERR("failed to initialize audio, rc = %d\n", rc); dp->panel->audio = NULL; goto error_audio; } #if defined(CONFIG_SECDP) #if defined(CONFIG_SECDP_SWITCH) dp->panel->audio->has_mst = dp->parser->has_mst; secdp_audio_register_switch(dp->panel->audio); #endif sysfs_in.parser = dp->parser; sysfs_in.panel = dp->panel; sysfs_in.power = dp->power; sysfs_in.link = dp->link; sysfs_in.ctrl = dp->ctrl; sysfs_in.catalog = dp->catalog; sysfs_in.sec = &dp->sec; dp->sec.sysfs = secdp_sysfs_get(&sysfs_in); if (IS_ERR(dp->sec.sysfs)) { rc = PTR_ERR(dp->sec.sysfs); DP_ERR("failed to initialize sysfs, rc = %d\n", rc); dp->sec.sysfs = NULL; goto error_sysfs; } rc = secdp_init(dp); if (rc) DP_ERR("secdp_init failed\n"); #endif/*CONFIG_SECDP*/ memset(&dp->mst, 0, sizeof(dp->mst)); dp->active_stream_cnt = 0; cb->configure = dp_display_usbpd_configure_cb; cb->disconnect = dp_display_usbpd_disconnect_cb; cb->attention = dp_display_usbpd_attention_cb; dp->hpd = dp_hpd_get(dev, dp->parser, &dp->catalog->hpd, dp->aux_bridge, cb); if (IS_ERR(dp->hpd)) { rc = PTR_ERR(dp->hpd); DP_ERR("failed to initialize hpd, rc = %d\n", rc); dp->hpd = NULL; goto error_hpd; } hdcp_disabled = !!dp_display_initialize_hdcp(dp); debug_in.panel = dp->panel; debug_in.hpd = dp->hpd; debug_in.link = dp->link; debug_in.aux = dp->aux; debug_in.connector = &dp->dp_display.base_connector; debug_in.catalog = dp->catalog; debug_in.parser = dp->parser; debug_in.ctrl = dp->ctrl; debug_in.pll = dp->pll; debug_in.display = &dp->dp_display; dp->debug = dp_debug_get(&debug_in); if (IS_ERR(dp->debug)) { rc = PTR_ERR(dp->debug); DP_ERR("failed to initialize debug, rc = %d\n", rc); dp->debug = NULL; goto error_debug; } dp->cached_connector_status = connector_status_disconnected; dp->tot_dsc_blks_in_use = 0; dp->tot_lm_blks_in_use = 0; dp->debug->hdcp_disabled = hdcp_disabled; dp_display_update_hdcp_status(dp, true); #if !defined(CONFIG_SECDP) dp_display_register_usb_notifier(dp); #endif if (dp->hpd->register_hpd) { rc = dp->hpd->register_hpd(dp->hpd); if (rc) { DP_ERR("failed register hpd\n"); goto error_hpd_reg; } } return rc; error_hpd_reg: dp_debug_put(dp->debug); error_debug: dp_hpd_put(dp->hpd); error_hpd: dp_audio_put(dp->panel->audio); error_audio: dp_ctrl_put(dp->ctrl); error_ctrl: dp_panel_put(dp->panel); error_panel: dp_link_put(dp->link); #if defined(CONFIG_SECDP) error_sysfs: secdp_sysfs_put(dev, dp->sec.sysfs); #endif error_link: dp_power_put(dp->power); error_power: dp_pll_put(dp->pll); error_pll: dp_aux_put(dp->aux); error_aux: dp_catalog_put(dp->catalog); error_catalog: dp_parser_put(dp->parser); error: mutex_destroy(&dp->session_lock); return rc; } static int dp_display_post_init(struct dp_display *dp_display) { int rc = 0; struct dp_display_private *dp; if (!dp_display) { DP_ERR("invalid input\n"); rc = -EINVAL; goto end; } dp = container_of(dp_display, struct dp_display_private, dp_display); if (IS_ERR_OR_NULL(dp)) { DP_ERR("invalid params\n"); rc = -EINVAL; goto end; } rc = dp_init_sub_modules(dp); if (rc) goto end; dp_display->post_init = NULL; end: DP_DEBUG("%s\n", rc ? "failed" : "success"); return rc; } static int dp_display_set_mode(struct dp_display *dp_display, void *panel, struct dp_display_mode *mode) { const u32 num_components = 3, default_bpp = 24; struct dp_display_private *dp; struct dp_panel *dp_panel; bool dsc_en = (mode->capabilities & DP_PANEL_CAPS_DSC) ? true : false; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp_panel = panel; if (!dp_panel->connector) { DP_ERR("invalid connector input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state, mode->timing.h_active, mode->timing.v_active, mode->timing.refresh_rate); mutex_lock(&dp->session_lock); mode->timing.bpp = dp_panel->connector->display_info.bpc * num_components; if (!mode->timing.bpp) mode->timing.bpp = default_bpp; mode->timing.bpp = dp->panel->get_mode_bpp(dp->panel, mode->timing.bpp, mode->timing.pixel_clk_khz, dsc_en); if (dp->mst.mst_active) dp->mst.cbs.set_mst_mode_params(&dp->dp_display, mode); dp_panel->pinfo = mode->timing; mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } static int dp_display_prepare(struct dp_display *dp_display, void *panel) { struct dp_display_private *dp; struct dp_panel *dp_panel; int rc = 0; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp_panel = panel; if (!dp_panel->connector) { DP_ERR("invalid connector input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); /* * If DP video session is restored by the userspace after display * disconnect notification from dongle i.e. typeC cable connected to * source but disconnected at the display side, the DP controller is * not restored to the desired configured state. So, ensure host_init * is executed in such a scenario so that all the DP controller * resources are enabled for the next connection event. */ if (dp_display_state_is(DP_STATE_SRC_PWRDN) && dp_display_state_is(DP_STATE_CONFIGURED)) { rc = dp_display_host_init(dp); if (rc) { /* * Skip all the events that are similar to abort case, just that * the stream clks should be enabled so that no commit failure can * be seen. */ DP_ERR("Host init failed.\n"); goto end; } /* * Remove DP_STATE_SRC_PWRDN flag on successful host_init to * prevent cases such as below. * 1. MST stream 1 failed to do host init then stream 2 can retry again. * 2. Resume path fails, now sink sends hpd_high=0 and hpd_high=1. */ dp_display_state_remove(DP_STATE_SRC_PWRDN); } /* * If the physical connection to the sink is already lost by the time * we try to set up the connection, we can just skip all the steps * here safely. */ if (dp_display_state_is(DP_STATE_ABORTED)) { dp_display_state_log("[aborted]"); goto end; } /* * If DP_STATE_ENABLED, there is nothing left to do. * This would happen during MST flow. So, log this. */ if (dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_warn("[already enabled]"); goto end; } if (!dp_display_is_ready(dp)) { dp_display_state_show("[not ready]"); goto end; } /* For supporting DP_PANEL_SRC_INITIATED_POWER_DOWN case */ rc = dp_display_host_ready(dp); if (rc) { dp_display_state_show("[ready failed]"); goto end; } if (dp->debug->psm_enabled) { dp->link->psm_config(dp->link, &dp->panel->link_info, false); dp->debug->psm_enabled = false; } /* * Execute the dp controller power on in shallow mode here. * In normal cases, controller should have been powered on * by now. In some cases like suspend/resume or framework * reboot, we end up here without a powered on controller. * Cable may have been removed in suspended state. In that * case, link training is bound to fail on system resume. * So, we execute in shallow mode here to do only minimal * and required things. */ rc = dp->ctrl->on(dp->ctrl, dp->mst.mst_active, dp_panel->fec_en, dp_panel->dsc_en, true); if (rc) goto end; end: mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, rc); return rc; } static int dp_display_set_stream_info(struct dp_display *dp_display, void *panel, u32 strm_id, u32 start_slot, u32 num_slots, u32 pbn, int vcpi) { int rc = 0; struct dp_panel *dp_panel; struct dp_display_private *dp; const int max_slots = 64; if (!dp_display) { DP_ERR("invalid input\n"); return -EINVAL; } if (strm_id >= DP_STREAM_MAX) { DP_ERR("invalid stream id:%d\n", strm_id); return -EINVAL; } if (start_slot + num_slots > max_slots) { DP_ERR("invalid channel info received. start:%d, slots:%d\n", start_slot, num_slots); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state, strm_id, start_slot, num_slots); mutex_lock(&dp->session_lock); dp->ctrl->set_mst_channel_info(dp->ctrl, strm_id, start_slot, num_slots); if (panel) { dp_panel = panel; dp_panel->set_stream_info(dp_panel, strm_id, start_slot, num_slots, pbn, vcpi); } mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, rc); return rc; } static int dp_display_enable(struct dp_display *dp_display, void *panel) { int rc = 0; struct dp_display_private *dp; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); /* * If DP_STATE_READY is not set, we should not do any HW * programming. */ if (!dp_display_state_is(DP_STATE_READY)) { dp_display_state_show("[host not ready]"); goto end; } /* * It is possible that by the time we get call back to establish * the DP pipeline e2e, the physical DP connection to the sink is * already lost. In such cases, the DP_STATE_ABORTED would be set. * However, it is necessary to NOT abort the display setup here so as * to ensure that the rest of the system is in a stable state prior to * handling the disconnect notification. */ if (dp_display_state_is(DP_STATE_ABORTED)) dp_display_state_log("[aborted, but continue on]"); rc = dp_display_stream_enable(dp, panel); if (rc) goto end; dp_display_state_add(DP_STATE_ENABLED); end: mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, rc); return rc; } static void dp_display_stream_post_enable(struct dp_display_private *dp, struct dp_panel *dp_panel) { dp_panel->spd_config(dp_panel); dp_panel->setup_hdr(dp_panel, NULL, false, 0, true); } static int dp_display_post_enable(struct dp_display *dp_display, void *panel) { struct dp_display_private *dp; struct dp_panel *dp_panel; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); dp_panel = panel; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); /* * If DP_STATE_READY is not set, we should not do any HW * programming. */ if (!dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_show("[not enabled]"); goto end; } #if !defined(CONFIG_SECDP) /* * If the physical connection to the sink is already lost by the time * we try to set up the connection, we can just skip all the steps * here safely. */ if (dp_display_state_is(DP_STATE_ABORTED)) { dp_display_state_log("[aborted]"); goto end; } if (!dp_display_is_ready(dp) || !dp_display_state_is(DP_STATE_READY)) { #else if (!dp_display_state_is(DP_STATE_READY)) { #endif dp_display_state_show("[not ready]"); goto end; } dp_display_stream_post_enable(dp, dp_panel); #if !defined(CONFIG_SECDP) cancel_delayed_work_sync(&dp->hdcp_cb_work); queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ); #else #ifdef SECDP_HDCP_DISABLE DP_INFO("skip hdcp\n"); #else schedule_delayed_work(&dp->sec.hdcp.start_work, msecs_to_jiffies(3500)); #endif #ifdef SECDP_SELF_TEST if (secdp_self_test_status(ST_HDCP_TEST) >= 0) { cancel_delayed_work_sync(&dp->sec.hdcp.start_work); secdp_self_test_start_hdcp_test(dp->sec.sysfs, secdp_self_test_hdcp_on, secdp_self_test_hdcp_off); } #endif /* check poor connection only if it's dex mode */ if (secdp_check_dex_mode(dp)) schedule_delayed_work(&dp->sec.link_status_work, msecs_to_jiffies(13000)); #endif if (dp_panel->audio_supported) { dp_panel->audio->bw_code = dp->link->link_params.bw_code; dp_panel->audio->lane_count = dp->link->link_params.lane_count; dp_panel->audio->on(dp_panel->audio); } dp->aux->state &= ~DP_STATE_CTRL_POWERED_OFF; dp->aux->state |= DP_STATE_CTRL_POWERED_ON; #if defined(CONFIG_SECDP) atomic_set(&dp->sec.noti_status, 0); #endif complete_all(&dp->notification_comp); DP_DEBUG("display post enable complete. state: 0x%x\n", dp->state); end: mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } static void dp_display_clear_colorspaces(struct dp_display *dp_display) { struct drm_connector *connector; struct sde_connector *sde_conn; connector = dp_display->base_connector; sde_conn = to_sde_connector(connector); sde_conn->color_enc_fmt = 0; } static int dp_display_pre_disable(struct dp_display *dp_display, void *panel) { struct dp_display_private *dp; struct dp_panel *dp_panel = panel; struct dp_link_hdcp_status *status; int rc = 0; size_t i; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); status = &dp->link->hdcp_status; if (!dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_show("[not enabled]"); goto end; } #if defined(CONFIG_SECDP) if (!dp_display_state_is(DP_STATE_READY)) { dp_display_state_show("[not ready]"); goto end; } #endif dp_display_state_add(DP_STATE_HDCP_ABORTED); cancel_delayed_work_sync(&dp->hdcp_cb_work); if (dp_display_is_hdcp_enabled(dp) && status->hdcp_state != HDCP_STATE_INACTIVE) { bool off = true; if (dp_display_state_is(DP_STATE_SUSPENDED)) { DP_DEBUG("Can't perform HDCP cleanup while suspended. Defer\n"); dp->hdcp_delayed_off = true; goto clean; } flush_delayed_work(&dp->hdcp_cb_work); if (dp->mst.mst_active) { dp_display_hdcp_deregister_stream(dp, dp_panel->stream_id); for (i = DP_STREAM_0; i < DP_STREAM_MAX; i++) { if (i != dp_panel->stream_id && dp->active_panels[i]) { DP_DEBUG("Streams are still active. Skip disabling HDCP\n"); off = false; } } } if (off) { if (dp->hdcp.ops->off) dp->hdcp.ops->off(dp->hdcp.data); dp_display_update_hdcp_status(dp, true); } } dp_display_clear_colorspaces(dp_display); clean: #if defined(CONFIG_SECDP) cancel_delayed_work(&dp->sec.hpd.noti_work); cancel_delayed_work_sync(&dp->sec.hdcp.start_work); cancel_delayed_work(&dp->sec.link_status_work); cancel_delayed_work(&dp->sec.poor_discon_work); secdp_link_backoff_stop(); #endif if (dp_panel->audio_supported) dp_panel->audio->off(dp_panel->audio, false); rc = dp_display_stream_pre_disable(dp, dp_panel); end: mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } static int dp_display_disable(struct dp_display *dp_display, void *panel) { int i; struct dp_display_private *dp = NULL; struct dp_panel *dp_panel = NULL; struct dp_link_hdcp_status *status; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); dp_panel = panel; status = &dp->link->hdcp_status; SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); if (!dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_show("[not enabled]"); goto end; } if (!dp_display_state_is(DP_STATE_READY)) { dp_display_state_show("[not ready]"); goto end; } dp_display_stream_disable(dp, dp_panel); dp_display_state_remove(DP_STATE_HDCP_ABORTED); for (i = DP_STREAM_0; i < DP_STREAM_MAX; i++) { if (dp->active_panels[i]) { if (status->hdcp_state != HDCP_STATE_AUTHENTICATED) queue_delayed_work(dp->wq, &dp->hdcp_cb_work, HZ/4); break; } } end: #if defined(CONFIG_SECDP) atomic_set(&dp->sec.noti_status, 0); #endif mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } static int dp_request_irq(struct dp_display *dp_display) { int rc = 0; struct dp_display_private *dp; if (!dp_display) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0); if (dp->irq < 0) { rc = dp->irq; DP_ERR("failed to get irq: %d\n", rc); return rc; } rc = devm_request_irq(&dp->pdev->dev, dp->irq, dp_display_irq, IRQF_TRIGGER_HIGH, "dp_display_isr", dp); if (rc < 0) { DP_ERR("failed to request IRQ%u: %d\n", dp->irq, rc); return rc; } disable_irq(dp->irq); return 0; } static struct dp_debug *dp_get_debug(struct dp_display *dp_display) { struct dp_display_private *dp; if (!dp_display) { DP_ERR("invalid input\n"); return ERR_PTR(-EINVAL); } dp = container_of(dp_display, struct dp_display_private, dp_display); return dp->debug; } static int dp_display_unprepare(struct dp_display *dp_display, void *panel) { struct dp_display_private *dp; struct dp_panel *dp_panel = panel; u32 flags = 0; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); /* * Check if the power off sequence was triggered * by a source initialated action like framework * reboot or suspend-resume but not from normal * hot plug. If connector is in MST mode, skip * powering down host as aux needs to be kept * alive to handle hot-plug sideband message. */ if (dp_display_is_ready(dp) && (dp_display_state_is(DP_STATE_SUSPENDED) || !dp->mst.mst_active)) flags |= DP_PANEL_SRC_INITIATED_POWER_DOWN; if (dp->active_stream_cnt) goto end; if (flags & DP_PANEL_SRC_INITIATED_POWER_DOWN) { dp->link->psm_config(dp->link, &dp->panel->link_info, true); dp->debug->psm_enabled = true; dp->ctrl->off(dp->ctrl); dp_display_host_unready(dp); dp_display_host_deinit(dp); dp_display_state_add(DP_STATE_SRC_PWRDN); } dp_display_state_remove(DP_STATE_ENABLED); dp->aux->state &= ~DP_STATE_CTRL_POWERED_ON; dp->aux->state |= DP_STATE_CTRL_POWERED_OFF; complete_all(&dp->notification_comp); /* log this as it results from user action of cable dis-connection */ DP_INFO("[OK]\n"); end: mutex_lock(&dp->accounting_lock); dp->tot_lm_blks_in_use -= dp_panel->max_lm; dp_panel->max_lm = 0; mutex_unlock(&dp->accounting_lock); dp_panel->deinit(dp_panel, flags); mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } #if defined(CONFIG_SECDP) static enum mon_aspect_ratio_t secdp_get_aspect_ratio(struct drm_display_mode *mode) { enum mon_aspect_ratio_t aspect_ratio = MON_RATIO_NA; int hdisplay = mode->hdisplay; int vdisplay = mode->vdisplay; if ((hdisplay == 4096 && vdisplay == 2160) || (hdisplay == 3840 && vdisplay == 2160) || (hdisplay == 2560 && vdisplay == 1440) || (hdisplay == 1920 && vdisplay == 1080) || (hdisplay == 1600 && vdisplay == 900) || (hdisplay == 1366 && vdisplay == 768) || (hdisplay == 1280 && vdisplay == 720)) aspect_ratio = MON_RATIO_16_9; else if ((hdisplay == 2560 && vdisplay == 1600) || (hdisplay == 1920 && vdisplay == 1200) || (hdisplay == 1680 && vdisplay == 1050) || (hdisplay == 1440 && vdisplay == 900) || (hdisplay == 1280 && vdisplay == 800)) aspect_ratio = MON_RATIO_16_10; else if ((hdisplay == 3840 && vdisplay == 1600) || (hdisplay == 3440 && vdisplay == 1440) || (hdisplay == 2560 && vdisplay == 1080)) aspect_ratio = MON_RATIO_21_9; else if ((hdisplay == 1720 && vdisplay == 1440) || (hdisplay == 1280 && vdisplay == 1080)) aspect_ratio = MON_RATIO_10P5_9; else if (hdisplay == 2520 && vdisplay == 1200) aspect_ratio = MON_RATIO_21_10; else if (hdisplay == 1320 && vdisplay == 1200) aspect_ratio = MON_RATIO_11_10; else if ((hdisplay == 5120 && vdisplay == 1440) || (hdisplay == 3840 && vdisplay == 1080)) aspect_ratio = MON_RATIO_32_9; else if (hdisplay == 3840 && vdisplay == 1200) aspect_ratio = MON_RATIO_32_10; else if (hdisplay == 1440 && vdisplay == 900) aspect_ratio = MON_RATIO_8_5; else if ((hdisplay == 1280 && vdisplay == 1024) || (hdisplay == 720 && vdisplay == 576)) aspect_ratio = MON_RATIO_5_4; else if (hdisplay == 1280 && vdisplay == 768) aspect_ratio = MON_RATIO_5_3; else if ((hdisplay == 2200 && vdisplay == 1650) || (hdisplay == 1152 && vdisplay == 864) || (hdisplay == 1024 && vdisplay == 768) || (hdisplay == 800 && vdisplay == 600) || (hdisplay == 640 && vdisplay == 480)) aspect_ratio = MON_RATIO_4_3; else if ((hdisplay == 1920 && vdisplay == 1280) || (hdisplay == 720 && vdisplay == 480)) aspect_ratio = MON_RATIO_3_2; return aspect_ratio; } /* * @target [inout] timing to be updated (prefer/mirror/dex) * @mode [in] timing info to compare */ static bool secdp_update_max_timing(struct secdp_display_timing *target, struct drm_display_mode *mode) { u64 mode_total = 0; int mode_refresh; if (!mode) { /* reset */ memset(target, 0, sizeof(struct secdp_display_timing)); target->mon_ratio = MON_RATIO_NA; return true; } mode_refresh = drm_mode_vrefresh(mode); mode_total = (u64)mode->hdisplay * (u64)mode->vdisplay; if (mode_total < target->total) return false; if (mode_total > target->total) goto update; if (mode_refresh < target->refresh_rate) return false; if (mode_refresh > target->refresh_rate) goto update; return false; update: target->active_h = mode->hdisplay; target->active_v = mode->vdisplay; target->refresh_rate = mode_refresh; target->clock = mode->clock; target->mon_ratio = secdp_get_aspect_ratio(mode); target->total = mode_total; return true; } static void secdp_show_max_timing(struct dp_display_private *dp) { struct secdp_display_timing *prf_timing, *mrr_timing, *dex_timing; prf_timing = &dp->sec.prf_timing; mrr_timing = &dp->sec.mrr_timing; dex_timing = &dp->sec.dex_timing; DP_INFO("prf:%ux%u@%uhz mrr:%ux%u@%uhz dex:%ux%u@%uhz\n", prf_timing->active_h, prf_timing->active_v, prf_timing->refresh_rate, mrr_timing->active_h, mrr_timing->active_v, mrr_timing->refresh_rate, dex_timing->active_h, dex_timing->active_v, dex_timing->refresh_rate); } void secdp_timing_init(struct secdp_misc *sec) { struct secdp_prefer *prefer = &sec->prefer; struct secdp_dex *dex = &sec->dex; secdp_update_max_timing(&sec->prf_timing, NULL); secdp_update_max_timing(&sec->mrr_timing, NULL); secdp_update_max_timing(&sec->dex_timing, NULL); prefer->ratio = MON_RATIO_NA; prefer->exist = false; prefer->hdisp = 0; prefer->vdisp = 0; prefer->refresh = 0; dex->ignore_prefer_ratio = false; } /** * check if reconnection is needed when mode is changing between mirror and dex * @return false if dex and mirror resolutions are same * @return true otherwise */ bool secdp_check_reconnect(struct secdp_misc *sec) { struct dp_display_private *dp; struct secdp_display_timing *dex_timing, *compare; bool ret = false; if (sec->hmd.exist) goto end; dp = container_of(sec, struct dp_display_private, sec); secdp_show_max_timing(dp); dex_timing = &sec->dex_timing; if (sec->prefer.exist) compare = &sec->prf_timing; else compare = &sec->mrr_timing; if (compare->active_h == dex_timing->active_h && compare->active_v == dex_timing->active_v && compare->refresh_rate == dex_timing->refresh_rate) goto end; ret = true; end: return ret; } /** * do reconnect when mode is changing from dex to mirror and vice versa. * it's needed only when resolution changing is required between mirror and dex. */ void secdp_reconnect(struct secdp_misc *sec) { struct dp_display_private *dp; secdp_logger_set_max_count(300); dp = container_of(sec, struct dp_display_private, sec); if (dp->link->poor_connection) { DP_INFO("poor! skip reconnect\n"); return; } if (dp->mst.mst_active) { DP_INFO("MST! skip reconnect\n"); return; } mutex_lock(&dp->sec.attention_lock); DP_INFO("dex_reconnect hpd low++\n"); dp->sec.dex.reconnecting = true; dp->sec.dex.status = DEX_MODE_CHANGING; if (dp->sec.dex.curr == DEX_ENABLED) dp->sec.dex.curr = DEX_MODE_CHANGING; dp->hpd->hpd_high = false; dp_display_host_init(dp); dp_display_process_hpd_low(dp, false); DP_INFO("dex_reconnect hpd low--\n"); mutex_unlock(&dp->sec.attention_lock); /* give some time for display hal to handle disconnect event */ msleep(400); mutex_lock(&dp->sec.attention_lock); if (!dp_display_state_is(DP_STATE_ENABLED) && dp->sec.dex.reconnecting && !dp_display_state_is(DP_STATE_CONNECTED)) { DP_INFO("dex_reconnect hpd high++\n"); secdp_send_hpd_event(sec, true); if (dp_display_state_is(DP_STATE_INITIALIZED)) { /* aux timeout happens whenever DeX reconnect scenario, * init aux here */ dp_display_host_unready(dp); dp_display_host_deinit(dp); usleep_range(5000, 6000); } dp->hpd->hpd_high = true; dp_display_host_init(dp); dp_display_process_hpd_high(dp); DP_INFO("dex_reconnect hpd high--\n"); } dp->sec.dex.reconnecting = false; mutex_unlock(&dp->sec.attention_lock); } void secdp_extdisp_off(struct secdp_misc *sec) { struct dp_display_private *dp; dp = container_of(sec, struct dp_display_private, sec); if (!dp_display_state_is(DP_STATE_ENABLED)) { DP_INFO("[extdisp_off] DP is not enabled\n"); return; } DP_INFO("[extdisp_off] ++\n"); dp->link->psm_config(dp->link, &dp->panel->link_info, true); dp->debug->psm_enabled = true; dp_display_state_add(DP_STATE_SRC_PWRDN); dp->hpd->hpd_high = false; /* see secdp_process_attention() */ secdp_clear_link_status_cnt(dp->link); dp_display_disconnect_sync(dp); dp_display_host_deinit(dp); DP_INFO("[extdisp_off] --\n"); } void secdp_extdisp_on(struct secdp_misc *sec) { struct dp_display_private *dp; dp = container_of(sec, struct dp_display_private, sec); if (!dp_display_state_is(DP_STATE_CONFIGURED) || !secdp_get_cable_status()) { DP_INFO("[extdisp_on] cable is out\n"); return; } if (dp_display_state_is(DP_STATE_CONNECTED)) { DP_INFO("[extdisp_on] already connected\n"); return; } DP_INFO("[extdisp_on] ++\n"); dp->hpd->hpd_high = true; /* see secdp_process_attention() */ secdp_clear_link_status_cnt(dp->link); dp_display_state_remove(DP_STATE_ABORTED); queue_work(dp->wq, &dp->connect_work); DP_INFO("[extdisp_on] --\n"); } /** * check if given mode(timing) is fail-safe or not */ static bool secdp_check_fail_safe(struct drm_display_mode *mode) { bool ret = false; if (mode->hdisplay == 640 && mode->vdisplay == 480) ret = true; return ret; } /** * check if given ratio is one of dex ratios (16:9, 16:10, 21:9) */ static bool secdp_check_dex_ratio(enum mon_aspect_ratio_t ratio) { bool ret = false; switch (ratio) { case MON_RATIO_16_9: case MON_RATIO_16_10: case MON_RATIO_21_9: ret = true; break; default: break; } return ret; } /** * check if mode's active_h, active_v are within max dex rows/cols */ static bool secdp_check_dex_rowcol(struct dp_display_private *dp, struct drm_display_mode *mode) { int max_cols = DEX_DFT_COL, max_rows = DEX_DFT_ROW; bool ret = false; if (secdp_get_dex_res(dp) == DEX_RES_MAX) { max_cols = DEX_MAX_COL; max_rows = DEX_MAX_ROW; } if ((mode->hdisplay <= max_cols) && (mode->vdisplay <= max_rows)) ret = true; return ret; } /** * check if current refresh_rate meets in dex mode */ static bool secdp_check_dex_refresh(struct dp_display_private *dp, struct drm_display_mode *mode) { int mode_refresh = drm_mode_vrefresh(mode); bool ret = false; if (mode_refresh < DEX_REFRESH_MIN) goto end; #if 0 if (dp->sec.dex.adapter_check_skip) { ret = true; goto end; } #endif if (mode_refresh <= DEX_REFRESH_MAX) { ret = true; goto end; } end: return ret; } static bool secdp_exceed_mst_max_pclk(struct dp_display_private *dp, struct drm_display_mode *mode) { bool ret = false; if (!dp->mst.mst_active) { /* it's SST. No need to check pclk */ goto end; } if (mode->clock <= MST_MAX_PCLK) { /* it's MST, and current pclk is less than MST's max pclk */ goto end; } /* it's MST, and current pclk is bigger than MST's max pclk */ ret = true; end: return ret; } static bool secdp_check_prefer_resolution(struct dp_display_private *dp, struct drm_display_mode *mode) { struct secdp_misc *sec; bool ret = false; if (!dp || !mode) goto end; sec = &dp->sec; if (!sec || sec->debug.prefer_check_skip) goto end; if (mode->type & DRM_MODE_TYPE_PREFERRED) ret = true; end: return ret; } static bool secdp_has_higher_refresh(struct dp_display_private *dp, struct drm_display_mode *mode, int mode_refresh) { struct secdp_prefer *prefer = &dp->sec.prefer; bool ret = false; if (dp->panel->tbox || secdp_check_prefer_resolution(dp, mode)) goto end; if (mode->hdisplay == prefer->hdisp && mode->vdisplay == prefer->vdisp && mode_refresh > prefer->refresh) ret = true; end: return ret; } /** * check if current timing(mode) is valid compared to prefer timing * return true if it's valid. false otherwise */ static bool secdp_check_hdisp_vdisp(struct dp_display_private *dp, struct drm_display_mode *mode) { struct secdp_prefer *prefer = &dp->sec.prefer; bool ret = true; if (dp->panel->tbox || secdp_check_prefer_resolution(dp, mode)) goto end; if (prefer->hdisp > prefer->vdisp) { if (mode->hdisplay < mode->vdisplay) ret = false; goto end; } if (prefer->hdisp < prefer->vdisp) { if (mode->hdisplay > mode->vdisplay) ret = false; } end: if (!ret) { DP_INFO("weird timing! %dx%d@%dhz\n", mode->hdisplay, mode->vdisplay, drm_mode_vrefresh(mode)); } return ret; } #ifndef SECDP_MAX_HBR2 /** * check if current timing is g.t. 8K */ static bool secdp_check_uhd2(struct dp_display_private *dp, struct drm_display_mode *mode) { bool ret = false; if (dp->panel->tbox || secdp_check_prefer_resolution(dp, mode)) goto end; if (mode->hdisplay >= 7680 && mode->vdisplay >= 4320) ret = true; end: return ret; } #endif #define __NA (-1) /* not available */ static struct secdp_display_timing secdp_dex_resolution[] = { {1600, 900, __NA, false, __NA, DEX_RES_1600X900, MON_RATIO_16_9}, {1920, 1080, __NA, false, __NA, DEX_RES_1920X1080, MON_RATIO_16_9}, {1920, 1200, __NA, false, __NA, DEX_RES_1920X1200, MON_RATIO_16_10}, {2560, 1080, __NA, false, __NA, DEX_RES_2560X1080, MON_RATIO_21_9}, {2560, 1440, __NA, false, __NA, DEX_RES_2560X1440, MON_RATIO_16_9}, {2560, 1600, __NA, false, __NA, DEX_RES_2560X1600, MON_RATIO_16_10}, {3440, 1440, __NA, false, __NA, DEX_RES_3440X1440, MON_RATIO_21_9}, }; #define DEX_FAIL_SAFE 2073600 /* 1920x1080 */ static bool secdp_dex_fail_safe(struct drm_display_mode *mode) { if ((mode->hdisplay * mode->vdisplay) < DEX_FAIL_SAFE) return true; return false; } static bool secdp_check_dex_resolution(struct dp_display_private *dp, struct drm_display_mode *mode, bool *fail_safe) { struct secdp_display_timing *dex_table = secdp_dex_resolution; struct secdp_misc *sec = &dp->sec; struct secdp_prefer *prefer = &sec->prefer; struct secdp_dex *dex = &sec->dex; enum mon_aspect_ratio_t mode_ratio = secdp_get_aspect_ratio(mode); u64 i; bool mode_interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE); bool prefer_support = dp->parser->prefer_support; bool prefer_mode = secdp_check_prefer_resolution(dp, mode); bool ret = false; if (dex->ignore_prefer_ratio && secdp_dex_fail_safe(mode)) { *fail_safe = ret = true; goto end; } if (!secdp_check_dex_refresh(dp, mode)) goto end; if (prefer_support && prefer_mode && secdp_check_dex_rowcol(dp, mode) && secdp_check_dex_ratio(mode_ratio)) { ret = true; goto end; } for (i = 0; i < ARRAY_SIZE(secdp_dex_resolution); i++) { if ((mode_interlaced != dex_table[i].interlaced) || (mode->hdisplay != dex_table[i].active_h) || (mode->vdisplay != dex_table[i].active_v)) continue; if (!dex->ignore_prefer_ratio && dex_table[i].mon_ratio != prefer->ratio) continue; if (dex_table[i].dex_res <= secdp_get_dex_res(dp)) { ret = true; break; } } end: return ret; } #if defined(REMOVE_YUV420_AT_PREFER) static bool secdp_prefer_remove_yuv420(struct dp_display_private *dp, struct drm_display_mode *mode) { struct drm_connector *connector = dp->dp_display.base_connector; u8 vic; bool result = false; if (!secdp_check_prefer_resolution(dp, mode)) goto exit; if (!drm_mode_is_420_only(&connector->display_info, mode)) goto exit; vic = drm_match_cea_mode(mode); /* HACK: prevent preferred from becomming ycbcr420 */ bitmap_clear(connector->display_info.hdmi.y420_vdb_modes, vic, 1); DP_INFO("unset ycbcr420 of vic %d\n", vic); result = true; exit: return result; } #endif static bool secdp_check_resolution(struct dp_display_private *dp, struct drm_display_mode *mode, bool supported) { struct secdp_misc *sec = &dp->sec; struct secdp_prefer *prefer = &sec->prefer; struct secdp_dex *dex = &sec->dex; struct secdp_display_timing *prf_timing, *mrr_timing, *dex_timing; bool prefer_support = dp->parser->prefer_support; bool prefer_mode, ret = false, dex_supported = false; bool dex_fail_safe = false, ratio_check = false; int mode_refresh = drm_mode_vrefresh(mode); prf_timing = &sec->prf_timing; mrr_timing = &sec->mrr_timing; dex_timing = &sec->dex_timing; prefer_mode = secdp_check_prefer_resolution(dp, mode); if (prefer_mode) { secdp_mode_count_dec(dp); secdp_show_max_timing(dp); if ((mrr_timing->clock || prf_timing->clock) && !dex_timing->clock) { dex->ignore_prefer_ratio = true; DP_INFO("[dex] ignore prefer ratio\n"); } prefer->hdisp = mode->hdisplay; prefer->vdisp = mode->vdisplay; prefer->refresh = mode_refresh; prefer->ratio = secdp_get_aspect_ratio(mode); DP_INFO_M("prefer timing found! %dx%d@%dhz, %s\n", prefer->hdisp, prefer->vdisp, prefer->refresh, secdp_aspect_ratio_to_string(prefer->ratio)); #if defined(REMOVE_YUV420_AT_PREFER) secdp_prefer_remove_yuv420(dp, mode); #endif if (!prefer_support) { DP_INFO("remove prefer!\n"); mode->type &= (~DRM_MODE_TYPE_PREFERRED); } } if (prefer->ratio == MON_RATIO_NA) { dex->ignore_prefer_ratio = true; DP_INFO("prefer timing is absent, ignore!\n"); } if (!supported || secdp_exceed_mst_max_pclk(dp, mode) || mode_refresh < MIRROR_REFRESH_MIN) { ret = false; goto end; } ratio_check = secdp_check_hdisp_vdisp(dp, mode); if (prefer_mode) { prefer->exist = true; secdp_update_max_timing(prf_timing, mode); } else if (prefer->refresh > 0 && secdp_has_higher_refresh(dp, mode, mode_refresh)) { /* found same h/v display but higher refresh * rate than preferred timing */ secdp_update_max_timing(prf_timing, mode); mode->type |= DRM_MODE_TYPE_PREFERRED; #ifndef SECDP_MAX_HBR2 } else if (secdp_check_uhd2(dp, mode)) { secdp_update_max_timing(prf_timing, mode); mode->type |= DRM_MODE_TYPE_PREFERRED; #endif } else { if (ratio_check) secdp_update_max_timing(mrr_timing, mode); } if (sec->hmd.exist) { /* skip dex resolution check as HMD doesn't have DeX */ ret = true; goto end; } dex_supported = secdp_check_dex_resolution(dp, mode, &dex_fail_safe); if (dex_supported && !dex_fail_safe) secdp_update_max_timing(dex_timing, mode); if (!secdp_check_dex_mode(dp)) ret = ratio_check ? supported : false; else ret = dex_supported; if (!ret && secdp_check_fail_safe(mode)) ret = true; end: return ret; } #endif/*CONFIG_SECDP*/ static int dp_display_validate_link_clock(struct dp_display_private *dp, struct drm_display_mode *mode, struct dp_display_mode dp_mode) { u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0; u32 mode_bpc = 0, tmds_clock = 0; bool dsc_en; int rate; struct msm_compression_info *c_info = &dp_mode.timing.comp_info; dsc_en = c_info->enabled; if (dsc_en) { mode_bpp = DSC_BPP(c_info->dsc_info.config); mode_bpc = c_info->dsc_info.config.bits_per_component; } else { mode_bpp = dp_mode.timing.bpp; mode_bpc = mode_bpp / 3; } mode_rate_khz = mode->clock * mode_bpp; rate = drm_dp_bw_code_to_link_rate(dp->link->link_params.bw_code); tmds_clock = mode->clock * mode_bpc / 8; /* * For a HBR 2 dongle, limit TMDS clock to ensure a max resolution * of 4k@30fps for each MST port */ if (dp->mst.mst_active && rate <= 540000 && tmds_clock > MAX_TMDS_CLOCK_HDMI_1_4) { DP_DEBUG("Limit mode clock: %d kHz\n", mode->clock); return -EPERM; } supported_rate_khz = dp->link->link_params.lane_count * rate * 8; if (mode_rate_khz > supported_rate_khz) { DP_DEBUG("mode_rate: %d kHz, supported_rate: %d kHz\n", mode_rate_khz, supported_rate_khz); return -EPERM; } return 0; } static int dp_display_validate_pixel_clock(struct dp_display_mode dp_mode, u32 max_pclk_khz) { u32 pclk_khz = dp_mode.timing.widebus_en ? (dp_mode.timing.pixel_clk_khz >> 1) : dp_mode.timing.pixel_clk_khz; if (pclk_khz > max_pclk_khz) { DP_DEBUG("clk: %d kHz, max: %d kHz\n", pclk_khz, max_pclk_khz); return -EPERM; } return 0; } static int dp_display_validate_topology(struct dp_display_private *dp, struct dp_panel *dp_panel, struct drm_display_mode *mode, struct dp_display_mode *dp_mode, const struct msm_resource_caps_info *avail_res) { int rc; struct msm_drm_private *priv = dp->priv; const u32 dual = 2, quad = 4; u32 num_lm = 0, num_dsc = 0, num_3dmux = 0; bool dsc_capable = dp_mode->capabilities & DP_PANEL_CAPS_DSC; u32 fps = dp_mode->timing.refresh_rate; int avail_lm = 0; mutex_lock(&dp->accounting_lock); rc = msm_get_mixer_count(priv, mode, avail_res, &num_lm); if (rc) { DP_ERR("error getting mixer count. rc:%d\n", rc); goto end; } /* Merge using DSC, if enabled */ if (dp_panel->dsc_en && dsc_capable) { rc = msm_get_dsc_count(priv, mode->hdisplay, &num_dsc); if (rc) { DP_ERR("error getting dsc count. rc:%d\n", rc); goto end; } num_dsc = max(num_lm, num_dsc); if ((num_dsc > avail_res->num_lm) || (num_dsc > avail_res->num_dsc)) { DP_DEBUG("mode %sx%d: not enough resources for dsc %d dsc_a:%d lm_a:%d\n", mode->name, fps, num_dsc, avail_res->num_dsc, avail_res->num_lm); /* Clear DSC caps and retry */ dp_mode->capabilities &= ~DP_PANEL_CAPS_DSC; rc = -EAGAIN; goto end; } else { /* Only DSCMERGE is supported on DP */ num_lm = num_dsc; } } if (!num_dsc && (num_lm == 2) && avail_res->num_3dmux) { num_3dmux = 1; } avail_lm = avail_res->num_lm + avail_res->num_lm_in_use - dp->tot_lm_blks_in_use + dp_panel->max_lm; if (num_lm > avail_lm) { DP_DEBUG("mode %sx%d is invalid, not enough lm req:%d avail:%d\n", mode->name, fps, num_lm, avail_lm); rc = -EPERM; goto end; } else if (!num_dsc && (num_lm == dual && !num_3dmux)) { DP_DEBUG("mode %sx%d is invalid, not enough 3dmux %d %d\n", mode->name, fps, num_3dmux, avail_res->num_3dmux); rc = -EPERM; goto end; } else if (num_lm == quad && num_dsc != quad) { DP_DEBUG("mode %sx%d is invalid, unsupported DP topology lm:%d dsc:%d\n", mode->name, fps, num_lm, num_dsc); rc = -EPERM; goto end; } #if !defined(CONFIG_SECDP) DP_DEBUG_V("mode %sx%d is valid, supported DP topology lm:%d dsc:%d 3dmux:%d\n", mode->name, fps, num_lm, num_dsc, num_3dmux); #endif dp_mode->lm_count = num_lm; rc = 0; end: mutex_unlock(&dp->accounting_lock); return rc; } static enum drm_mode_status dp_display_validate_mode( struct dp_display *dp_display, void *panel, struct drm_display_mode *mode, const struct msm_resource_caps_info *avail_res) { struct dp_display_private *dp; struct dp_panel *dp_panel; struct dp_debug *debug; enum drm_mode_status mode_status = MODE_BAD; struct dp_display_mode dp_mode; int rc = 0; if (!dp_display || !mode || !panel || !avail_res || !avail_res->max_mixer_width) { DP_ERR("invalid params\n"); return mode_status; } dp = container_of(dp_display, struct dp_display_private, dp_display); mutex_lock(&dp->session_lock); dp_panel = panel; if (!dp_panel->connector) { DP_ERR("invalid connector\n"); goto end; } debug = dp->debug; if (!debug) goto end; dp_display->convert_to_dp_mode(dp_display, panel, mode, &dp_mode); /* As per spec, 640x480 mode should always be present as fail-safe */ if ((dp_mode.timing.h_active == 640) && (dp_mode.timing.v_active == 480) && (dp_mode.timing.pixel_clk_khz == 25175)) { goto skip_validation; } rc = dp_display_validate_topology(dp, dp_panel, mode, &dp_mode, avail_res); if (rc == -EAGAIN) { dp_panel->convert_to_dp_mode(dp_panel, mode, &dp_mode); rc = dp_display_validate_topology(dp, dp_panel, mode, &dp_mode, avail_res); } if (rc) goto end; rc = dp_display_validate_link_clock(dp, mode, dp_mode); if (rc) goto end; rc = dp_display_validate_pixel_clock(dp_mode, dp_display->max_pclk_khz); if (rc) goto end; skip_validation: mode_status = MODE_OK; if (!avail_res->num_lm_in_use) { mutex_lock(&dp->accounting_lock); dp->tot_lm_blks_in_use -= dp_panel->max_lm; dp_panel->max_lm = max(dp_panel->max_lm, dp_mode.lm_count); dp->tot_lm_blks_in_use += dp_panel->max_lm; mutex_unlock(&dp->accounting_lock); } end: mutex_unlock(&dp->session_lock); #if !defined(CONFIG_SECDP) DP_DEBUG_V("[%s clk:%d] mode is %s\n", mode->name, mode->clock, (mode_status == MODE_OK) ? "valid" : "invalid"); #else { u32 mode_bpp = 0; bool dsc_en; /* see "dp_display_validate_link_clock()" */ dsc_en = dp_mode.timing.comp_info.enabled; mode_bpp = dsc_en ? DSC_BPP(dp_mode.timing.comp_info.dsc_info.config) : dp_mode.timing.bpp; if (!secdp_check_resolution(dp, mode, mode_status == MODE_OK)) mode_status = MODE_BAD; if (secdp_mode_count_check(dp)) { DP_INFO_M("%9s@%dhz | %s | max:%7d cur:%7d | vt:%d bpp:%u\n", mode->name, drm_mode_vrefresh(mode), mode_status == MODE_BAD ? "NG" : "OK", dp_display->max_pclk_khz, mode->clock, dp_panel->video_test, mode_bpp); } } #endif return mode_status; } static int dp_display_get_available_dp_resources(struct dp_display *dp_display, const struct msm_resource_caps_info *avail_res, struct msm_resource_caps_info *max_dp_avail_res) { if (!dp_display || !avail_res || !max_dp_avail_res) { DP_ERR("invalid arguments\n"); return -EINVAL; } memcpy(max_dp_avail_res, avail_res, sizeof(struct msm_resource_caps_info)); max_dp_avail_res->num_lm = min(avail_res->num_lm, dp_display->max_mixer_count); max_dp_avail_res->num_dsc = min(avail_res->num_dsc, dp_display->max_dsc_count); #if !defined(CONFIG_SECDP) DP_DEBUG_V("max_lm:%d, avail_lm:%d, dp_avail_lm:%d\n", dp_display->max_mixer_count, avail_res->num_lm, max_dp_avail_res->num_lm); DP_DEBUG_V("max_dsc:%d, avail_dsc:%d, dp_avail_dsc:%d\n", dp_display->max_dsc_count, avail_res->num_dsc, max_dp_avail_res->num_dsc); #endif return 0; } static int dp_display_get_modes(struct dp_display *dp, void *panel, struct dp_display_mode *dp_mode) { struct dp_display_private *dp_display; struct dp_panel *dp_panel; int ret = 0; if (!dp || !panel) { DP_ERR("invalid params\n"); return 0; } dp_panel = panel; if (!dp_panel->connector) { DP_ERR("invalid connector\n"); return 0; } dp_display = container_of(dp, struct dp_display_private, dp_display); ret = dp_panel->get_modes(dp_panel, dp_panel->connector, dp_mode); if (dp_mode->timing.pixel_clk_khz) dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz; return ret; } static void dp_display_convert_to_dp_mode(struct dp_display *dp_display, void *panel, const struct drm_display_mode *drm_mode, struct dp_display_mode *dp_mode) { int rc; struct dp_display_private *dp; struct dp_panel *dp_panel; u32 free_dsc_blks = 0, required_dsc_blks = 0, curr_dsc = 0, new_dsc = 0; if (!dp_display || !drm_mode || !dp_mode || !panel) { DP_ERR("invalid input\n"); return; } dp = container_of(dp_display, struct dp_display_private, dp_display); dp_panel = panel; memset(dp_mode, 0, sizeof(*dp_mode)); if (dp_panel->dsc_en) { free_dsc_blks = dp_display->max_dsc_count - dp->tot_dsc_blks_in_use + dp_panel->dsc_blks_in_use; #if !defined(CONFIG_SECDP) DP_DEBUG_V("Before: in_use:%d, max:%d, free:%d\n", dp->tot_dsc_blks_in_use, dp_display->max_dsc_count, free_dsc_blks); #endif rc = msm_get_dsc_count(dp->priv, drm_mode->hdisplay, &required_dsc_blks); if (rc) { DP_ERR("error getting dsc count. rc:%d\n", rc); return; } curr_dsc = dp_panel->dsc_blks_in_use; dp->tot_dsc_blks_in_use -= dp_panel->dsc_blks_in_use; dp_panel->dsc_blks_in_use = 0; if (free_dsc_blks >= required_dsc_blks) { dp_mode->capabilities |= DP_PANEL_CAPS_DSC; new_dsc = max(curr_dsc, required_dsc_blks); dp_panel->dsc_blks_in_use = new_dsc; dp->tot_dsc_blks_in_use += new_dsc; } #if !defined(CONFIG_SECDP) DP_DEBUG_V("After: in_use:%d, max:%d, free:%d, req:%d, caps:0x%x\n", dp->tot_dsc_blks_in_use, dp_display->max_dsc_count, free_dsc_blks, required_dsc_blks, dp_mode->capabilities); #endif } dp_panel->convert_to_dp_mode(dp_panel, drm_mode, dp_mode); } static int dp_display_config_hdr(struct dp_display *dp_display, void *panel, struct drm_msm_ext_hdr_metadata *hdr, bool dhdr_update) { struct dp_panel *dp_panel; struct sde_connector *sde_conn; struct dp_display_private *dp; u64 core_clk_rate; bool flush_hdr; if (!dp_display || !panel) { DP_ERR("invalid input\n"); return -EINVAL; } dp_panel = panel; dp = container_of(dp_display, struct dp_display_private, dp_display); sde_conn = to_sde_connector(dp_panel->connector); core_clk_rate = dp->power->clk_get_rate(dp->power, "core_clk"); if (!core_clk_rate) { DP_ERR("invalid rate for core_clk\n"); return -EINVAL; } if (!dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_show("[not enabled]"); return 0; } /* * In rare cases where HDR metadata is updated independently * flush the HDR metadata immediately instead of relying on * the colorspace */ flush_hdr = !sde_conn->colorspace_updated; if (flush_hdr) DP_DEBUG("flushing the HDR metadata\n"); else DP_DEBUG("piggy-backing with colorspace\n"); return dp_panel->setup_hdr(dp_panel, hdr, dhdr_update, core_clk_rate, flush_hdr); } static int dp_display_setup_colospace(struct dp_display *dp_display, void *panel, u32 colorspace) { struct dp_panel *dp_panel; struct dp_display_private *dp; if (!dp_display || !panel) { pr_err("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); if (!dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_show("[not enabled]"); return 0; } dp_panel = panel; return dp_panel->set_colorspace(dp_panel, colorspace); } static int dp_display_create_workqueue(struct dp_display_private *dp) { dp->wq = create_singlethread_workqueue("drm_dp"); if (IS_ERR_OR_NULL(dp->wq)) { DP_ERR("Error creating wq\n"); return -EPERM; } INIT_DELAYED_WORK(&dp->hdcp_cb_work, dp_display_hdcp_cb_work); INIT_WORK(&dp->connect_work, dp_display_connect_work); INIT_WORK(&dp->attention_work, dp_display_attention_work); INIT_WORK(&dp->disconnect_work, dp_display_disconnect_work); return 0; } static int dp_display_bridge_internal_hpd(void *dev, bool hpd, bool hpd_irq) { struct dp_display_private *dp = dev; struct drm_device *drm_dev = dp->dp_display.drm_dev; if (!drm_dev || !drm_dev->mode_config.poll_enabled) return -EBUSY; if (hpd_irq) dp_display_mst_attention(dp); else dp->hpd->simulate_connect(dp->hpd, hpd); return 0; } static int dp_display_init_aux_bridge(struct dp_display_private *dp) { int rc = 0; const char *phandle = "qcom,dp-aux-bridge"; struct device_node *bridge_node; if (!dp->pdev->dev.of_node) { pr_err("cannot find dev.of_node\n"); rc = -ENODEV; goto end; } bridge_node = of_parse_phandle(dp->pdev->dev.of_node, phandle, 0); if (!bridge_node) goto end; dp->aux_bridge = of_dp_aux_find_bridge(bridge_node); if (!dp->aux_bridge) { pr_err("failed to find dp aux bridge\n"); rc = -EPROBE_DEFER; goto end; } if (dp->aux_bridge->register_hpd && !(dp->aux_bridge->flag & DP_AUX_BRIDGE_HPD)) dp->aux_bridge->register_hpd(dp->aux_bridge, dp_display_bridge_internal_hpd, dp); end: return rc; } static int dp_display_mst_install(struct dp_display *dp_display, struct dp_mst_drm_install_info *mst_install_info) { struct dp_display_private *dp; if (!dp_display || !mst_install_info) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); if (!mst_install_info->cbs->hpd || !mst_install_info->cbs->hpd_irq) { DP_ERR("invalid mst cbs\n"); return -EINVAL; } dp_display->dp_mst_prv_info = mst_install_info->dp_mst_prv_info; if (!dp->parser->has_mst) { DP_DEBUG("mst not enabled\n"); return -EPERM; } memcpy(&dp->mst.cbs, mst_install_info->cbs, sizeof(dp->mst.cbs)); dp->mst.drm_registered = true; DP_MST_DEBUG("dp mst drm installed\n"); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } static int dp_display_mst_uninstall(struct dp_display *dp_display) { struct dp_display_private *dp; if (!dp_display) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); if (!dp->mst.drm_registered) { DP_DEBUG("drm mst not registered\n"); return -EPERM; } dp = container_of(dp_display, struct dp_display_private, dp_display); memset(&dp->mst.cbs, 0, sizeof(dp->mst.cbs)); dp->mst.drm_registered = false; DP_MST_DEBUG("dp mst drm uninstalled\n"); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return 0; } static int dp_display_mst_connector_install(struct dp_display *dp_display, struct drm_connector *connector) { int rc = 0; struct dp_panel_in panel_in; struct dp_panel *dp_panel; struct dp_display_private *dp; if (!dp_display || !connector) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); if (!dp->mst.drm_registered) { DP_DEBUG("drm mst not registered\n"); rc = -EPERM; goto end; } panel_in.dev = &dp->pdev->dev; panel_in.aux = dp->aux; panel_in.catalog = &dp->catalog->panel; panel_in.link = dp->link; panel_in.connector = connector; panel_in.base_panel = dp->panel; panel_in.parser = dp->parser; dp_panel = dp_panel_get(&panel_in); if (IS_ERR(dp_panel)) { rc = PTR_ERR(dp_panel); DP_ERR("failed to initialize panel, rc = %d\n", rc); goto end; } dp_panel->audio = dp_audio_get(dp->pdev, dp_panel, &dp->catalog->audio); if (IS_ERR(dp_panel->audio)) { rc = PTR_ERR(dp_panel->audio); DP_ERR("[mst] failed to initialize audio, rc = %d\n", rc); dp_panel->audio = NULL; goto end; } #if defined(CONFIG_SECDP_SWITCH) dp_panel->audio->has_mst = dp->parser->has_mst; #endif DP_MST_DEBUG("dp mst connector installed. conn:%d\n", connector->base.id); end: mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state, rc); return rc; } static int dp_display_mst_connector_uninstall(struct dp_display *dp_display, struct drm_connector *connector) { int rc = 0; struct sde_connector *sde_conn; struct dp_panel *dp_panel; struct dp_display_private *dp; struct dp_audio *audio = NULL; if (!dp_display || !connector) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, dp->state); mutex_lock(&dp->session_lock); if (!dp->mst.drm_registered) { DP_DEBUG("drm mst not registered\n"); mutex_unlock(&dp->session_lock); return -EPERM; } sde_conn = to_sde_connector(connector); if (!sde_conn->drv_panel) { DP_ERR("invalid panel for connector:%d\n", connector->base.id); mutex_unlock(&dp->session_lock); return -EINVAL; } dp_panel = sde_conn->drv_panel; /* Make a copy of audio structure to call into dp_audio_put later */ audio = dp_panel->audio; dp_panel_put(dp_panel); DP_MST_DEBUG("dp mst connector uninstalled. conn:%d\n", connector->base.id); mutex_unlock(&dp->session_lock); dp_audio_put(audio); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); return rc; } static int dp_display_mst_connector_update_edid(struct dp_display *dp_display, struct drm_connector *connector, struct edid *edid) { int rc = 0; struct sde_connector *sde_conn; struct dp_panel *dp_panel; struct dp_display_private *dp; if (!dp_display || !connector || !edid) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); if (!dp->mst.drm_registered) { DP_DEBUG("drm mst not registered\n"); return -EPERM; } sde_conn = to_sde_connector(connector); if (!sde_conn->drv_panel) { DP_ERR("invalid panel for connector:%d\n", connector->base.id); return -EINVAL; } dp_panel = sde_conn->drv_panel; rc = dp_panel->update_edid(dp_panel, edid); DP_MST_DEBUG("dp mst connector:%d edid updated. mode_cnt:%d\n", connector->base.id, rc); return rc; } static int dp_display_update_pps(struct dp_display *dp_display, struct drm_connector *connector, char *pps_cmd) { struct sde_connector *sde_conn; struct dp_panel *dp_panel; struct dp_display_private *dp; dp = container_of(dp_display, struct dp_display_private, dp_display); sde_conn = to_sde_connector(connector); if (!sde_conn->drv_panel) { DP_ERR("invalid panel for connector:%d\n", connector->base.id); return -EINVAL; } if (!dp_display_state_is(DP_STATE_ENABLED)) { dp_display_state_show("[not enabled]"); return 0; } dp_panel = sde_conn->drv_panel; dp_panel->update_pps(dp_panel, pps_cmd); return 0; } static int dp_display_mst_connector_update_link_info( struct dp_display *dp_display, struct drm_connector *connector) { int rc = 0; struct sde_connector *sde_conn; struct dp_panel *dp_panel; struct dp_display_private *dp; if (!dp_display || !connector) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); if (!dp->mst.drm_registered) { DP_DEBUG("drm mst not registered\n"); return -EPERM; } sde_conn = to_sde_connector(connector); if (!sde_conn->drv_panel) { DP_ERR("invalid panel for connector:%d\n", connector->base.id); return -EINVAL; } dp_panel = sde_conn->drv_panel; memcpy(dp_panel->dpcd, dp->panel->dpcd, DP_RECEIVER_CAP_SIZE + 1); memcpy(dp_panel->dsc_dpcd, dp->panel->dsc_dpcd, DP_RECEIVER_DSC_CAP_SIZE + 1); memcpy(&dp_panel->link_info, &dp->panel->link_info, sizeof(dp_panel->link_info)); DP_MST_DEBUG("dp mst connector:%d link info updated\n", connector->base.id); return rc; } static int dp_display_mst_get_fixed_topology_port( struct dp_display *dp_display, u32 strm_id, u32 *port_num) { struct dp_display_private *dp; u32 port; if (!dp_display) { DP_ERR("invalid input\n"); return -EINVAL; } if (strm_id >= DP_STREAM_MAX) { DP_ERR("invalid stream id:%d\n", strm_id); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); port = dp->parser->mst_fixed_port[strm_id]; if (!port || port > 255) return -ENOENT; if (port_num) *port_num = port; return 0; } static int dp_display_get_mst_caps(struct dp_display *dp_display, struct dp_mst_caps *mst_caps) { int rc = 0; struct dp_display_private *dp; if (!dp_display || !mst_caps) { DP_ERR("invalid input\n"); return -EINVAL; } dp = container_of(dp_display, struct dp_display_private, dp_display); mst_caps->has_mst = dp->parser->has_mst; mst_caps->max_streams_supported = (mst_caps->has_mst) ? 2 : 0; mst_caps->max_dpcd_transaction_bytes = (mst_caps->has_mst) ? 16 : 0; mst_caps->drm_aux = dp->aux->drm_aux; return rc; } static void dp_display_wakeup_phy_layer(struct dp_display *dp_display, bool wakeup) { struct dp_display_private *dp; struct dp_hpd *hpd; if (!dp_display) { DP_ERR("invalid input\n"); return; } dp = container_of(dp_display, struct dp_display_private, dp_display); if (!dp->mst.drm_registered) { DP_DEBUG("drm mst not registered\n"); return; } hpd = dp->hpd; if (hpd && hpd->wakeup_phy) hpd->wakeup_phy(hpd, wakeup); } static int dp_display_probe(struct platform_device *pdev) { int rc = 0; struct dp_display_private *dp; if (!pdev || !pdev->dev.of_node) { DP_ERR("pdev not found\n"); rc = -ENODEV; goto bail; } dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL); if (!dp) { rc = -ENOMEM; goto bail; } init_completion(&dp->notification_comp); init_completion(&dp->attention_comp); dp->pdev = pdev; dp->name = "drm_dp"; memset(&dp->mst, 0, sizeof(dp->mst)); rc = dp_display_init_aux_bridge(dp); if (rc) goto error; rc = dp_display_create_workqueue(dp); if (rc) { DP_ERR("Failed to create workqueue\n"); goto error; } platform_set_drvdata(pdev, dp); g_dp_display = &dp->dp_display; g_dp_display->dp_ipc_log = ipc_log_context_create(DRM_DP_IPC_NUM_PAGES, "drm_dp", 0); if (!g_dp_display->dp_ipc_log) DP_WARN("Error in creating ipc_log_context for drm_dp\n"); g_dp_display->dp_aux_ipc_log = ipc_log_context_create(DRM_DP_IPC_NUM_PAGES, "drm_dp_aux", 0); if (!g_dp_display->dp_aux_ipc_log) DP_WARN("Error in creating ipc_log_context for drm_dp_aux\n"); g_dp_display->enable = dp_display_enable; g_dp_display->post_enable = dp_display_post_enable; g_dp_display->pre_disable = dp_display_pre_disable; g_dp_display->disable = dp_display_disable; g_dp_display->set_mode = dp_display_set_mode; g_dp_display->validate_mode = dp_display_validate_mode; g_dp_display->get_modes = dp_display_get_modes; g_dp_display->prepare = dp_display_prepare; g_dp_display->unprepare = dp_display_unprepare; g_dp_display->request_irq = dp_request_irq; g_dp_display->get_debug = dp_get_debug; g_dp_display->post_open = NULL; g_dp_display->post_init = dp_display_post_init; g_dp_display->config_hdr = dp_display_config_hdr; g_dp_display->mst_install = dp_display_mst_install; g_dp_display->mst_uninstall = dp_display_mst_uninstall; g_dp_display->mst_connector_install = dp_display_mst_connector_install; g_dp_display->mst_connector_uninstall = dp_display_mst_connector_uninstall; g_dp_display->mst_connector_update_edid = dp_display_mst_connector_update_edid; g_dp_display->mst_connector_update_link_info = dp_display_mst_connector_update_link_info; g_dp_display->get_mst_caps = dp_display_get_mst_caps; g_dp_display->set_stream_info = dp_display_set_stream_info; g_dp_display->update_pps = dp_display_update_pps; g_dp_display->convert_to_dp_mode = dp_display_convert_to_dp_mode; g_dp_display->mst_get_fixed_topology_port = dp_display_mst_get_fixed_topology_port; g_dp_display->wakeup_phy_layer = dp_display_wakeup_phy_layer; g_dp_display->set_colorspace = dp_display_setup_colospace; g_dp_display->get_available_dp_resources = dp_display_get_available_dp_resources; g_dp_display->clear_reservation = dp_display_clear_reservation; g_dp_display->get_mst_pbn_div = dp_display_get_mst_pbn_div; rc = component_add(&pdev->dev, &dp_display_comp_ops); if (rc) { DP_ERR("component add failed, rc=%d\n", rc); goto error; } return 0; error: devm_kfree(&pdev->dev, dp); bail: return rc; } int dp_display_get_displays(void **displays, int count) { if (!displays) { DP_ERR("invalid data\n"); return -EINVAL; } if (count != 1) { DP_ERR("invalid number of displays\n"); return -EINVAL; } displays[0] = g_dp_display; return count; } int dp_display_get_num_of_displays(void) { if (!g_dp_display) return 0; return 1; } int dp_display_get_num_of_streams(void) { return DP_STREAM_MAX; } static void dp_display_set_mst_state(void *dp_display, enum dp_drv_state mst_state) { struct dp_display_private *dp; if (!g_dp_display) { DP_DEBUG("dp display not initialized\n"); return; } dp = container_of(g_dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(mst_state, dp->mst.mst_active); if (dp->mst.mst_active && dp->mst.cbs.set_drv_state) dp->mst.cbs.set_drv_state(g_dp_display, mst_state); } static int dp_display_remove(struct platform_device *pdev) { struct dp_display_private *dp; if (!pdev) return -EINVAL; dp = platform_get_drvdata(pdev); dp_display_deinit_sub_modules(dp); if (dp->wq) destroy_workqueue(dp->wq); platform_set_drvdata(pdev, NULL); devm_kfree(&pdev->dev, dp); if (g_dp_display->dp_ipc_log) { ipc_log_context_destroy(g_dp_display->dp_ipc_log); g_dp_display->dp_ipc_log = NULL; } if (g_dp_display->dp_aux_ipc_log) { ipc_log_context_destroy(g_dp_display->dp_aux_ipc_log); g_dp_display->dp_aux_ipc_log = NULL; } return 0; } static int dp_pm_prepare(struct device *dev) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY); mutex_lock(&dp->session_lock); dp_display_set_mst_state(g_dp_display, PM_SUSPEND); /* * There are a few instances where the DP is hotplugged when the device * is in PM suspend state. After hotplug, it is observed the device * enters and exits the PM suspend multiple times while aux transactions * are taking place. This may sometimes cause an unclocked register * access error. So, abort aux transactions when such a situation * arises i.e. when DP is connected but display not enabled yet. */ if (dp_display_state_is(DP_STATE_CONNECTED) && !dp_display_state_is(DP_STATE_ENABLED)) { dp->aux->abort(dp->aux, true); dp->ctrl->abort(dp->ctrl, true); } dp_display_state_add(DP_STATE_SUSPENDED); mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); #if defined(CONFIG_SECDP) secdp_show_clk_status(dp); #endif return 0; } static void dp_pm_complete(struct device *dev) { struct dp_display_private *dp = container_of(g_dp_display, struct dp_display_private, dp_display); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY); mutex_lock(&dp->session_lock); dp_display_set_mst_state(g_dp_display, PM_DEFAULT); /* * There are multiple PM suspend entry and exits observed before * the connect uevent is issued to userspace. The aux transactions are * aborted during PM suspend entry in dp_pm_prepare to prevent unclocked * register access. On PM suspend exit, there will be no host_init call * to reset the abort flags for ctrl and aux incase DP is connected * but display not enabled. So, resetting abort flags for aux and ctrl. */ if (dp_display_state_is(DP_STATE_CONNECTED) && !dp_display_state_is(DP_STATE_ENABLED)) { dp->aux->abort(dp->aux, false); dp->ctrl->abort(dp->ctrl, false); } dp_display_state_remove(DP_STATE_SUSPENDED); mutex_unlock(&dp->session_lock); SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, dp->state); } void *get_ipc_log_context(void) { if (g_dp_display && g_dp_display->dp_ipc_log) return g_dp_display->dp_ipc_log; return NULL; } static const struct dev_pm_ops dp_pm_ops = { .prepare = dp_pm_prepare, .complete = dp_pm_complete, }; static struct platform_driver dp_display_driver = { .probe = dp_display_probe, .remove = dp_display_remove, .driver = { .name = "msm-dp-display", .of_match_table = dp_dt_match, .suppress_bind_attrs = true, .pm = &dp_pm_ops, }, }; void __init dp_display_register(void) { platform_driver_register(&dp_display_driver); } void __exit dp_display_unregister(void) { platform_driver_unregister(&dp_display_driver); }