evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

drm/msm: Add DRM EDID parser for external displays

Browse source 
Add DRM EDID parser support for external displays
using MSM chipsets.

Change-Id: I066c4faac4db31dc548b2de1090deac26cb395c7
Signed-off-by: Abhinav Kumar <abhinavk@codeaurora.org>
This commit is contained in:
Abhinav Kumar 2017-03-26 22:21:46 -07:00
parent 7a5cee889a
commit ae930851e9
7 changed files with 711 additions and 325 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/gpu/drm/msm/Makefile
View file

@ -49,6 +49,7 @@ msm_drm-y := \
sde/sde_vbif.o \
sde_dbg_evtlog.o \
sde_io_util.o \
sde_edid_parser.o
# use drm gpu driver only if qcom_kgsl driver not available
ifneq ($(CONFIG_QCOM_KGSL),y)
@ -102,7 +103,6 @@ msm_drm-$(CONFIG_DRM_SDE_HDMI) += \
hdmi-staging/sde_hdmi.o \
hdmi-staging/sde_hdmi_bridge.o \
hdmi-staging/sde_hdmi_audio.o \
hdmi-staging/sde_hdmi_edid.o
msm_drm-$(CONFIG_DRM_MSM_DSI_PLL) += dsi/pll/dsi_pll.o \
dsi/pll/dsi_pll_28nm.o

85
drivers/gpu/drm/msm/hdmi-staging/sde_hdmi.c
View file

@ -411,20 +411,28 @@ static void _sde_hdmi_hotplug_work(struct work_struct *work)
struct sde_hdmi *sde_hdmi =
container_of(work, struct sde_hdmi, hpd_work);
struct drm_connector *connector;
struct hdmi *hdmi = NULL;
u32 hdmi_ctrl;
if (!sde_hdmi || !sde_hdmi->ctrl.ctrl ||
!sde_hdmi->ctrl.ctrl->connector) {
!sde_hdmi->ctrl.ctrl->connector ||
!sde_hdmi->edid_ctrl) {
SDE_ERROR("sde_hdmi=%p or hdmi or connector is NULL\n",
sde_hdmi);
return;
}
hdmi = sde_hdmi->ctrl.ctrl;
connector = sde_hdmi->ctrl.ctrl->connector;
if (sde_hdmi->connected)
sde_hdmi_get_edid(connector, sde_hdmi);
else
sde_hdmi_free_edid(sde_hdmi);
if (sde_hdmi->connected) {
hdmi_ctrl = hdmi_read(hdmi, REG_HDMI_CTRL);
hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl | HDMI_CTRL_ENABLE);
sde_get_edid(connector, hdmi->i2c,
(void **)&sde_hdmi->edid_ctrl);
hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl);
hdmi->hdmi_mode = sde_detect_hdmi_monitor(sde_hdmi->edid_ctrl);
} else
sde_free_edid((void **)&sde_hdmi->edid_ctrl);
sde_hdmi_notify_clients(connector, sde_hdmi->connected);
drm_helper_hpd_irq_event(connector->dev);
@ -447,7 +455,7 @@ static void _sde_hdmi_connector_irq(struct sde_hdmi *sde_hdmi)
hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL,
HDMI_HPD_INT_CTRL_INT_ACK);
DRM_DEBUG("status=%04x, ctrl=%04x", hpd_int_status,
SDE_HDMI_DEBUG("status=%04x, ctrl=%04x", hpd_int_status,
hpd_int_ctrl);
/* detect disconnect if we are connected or visa versa: */
@ -520,11 +528,11 @@ static int _sde_hdmi_get_audio_edid_blk(struct platform_device *pdev,
return -ENODEV;
}
blk->audio_data_blk = display->edid.audio_data_block;
blk->audio_data_blk_size = display->edid.adb_size;
blk->audio_data_blk = display->edid_ctrl->audio_data_block;
blk->audio_data_blk_size = display->edid_ctrl->adb_size;
blk->spk_alloc_data_blk = display->edid.spkr_alloc_data_block;
blk->spk_alloc_data_blk_size = display->edid.sadb_size;
blk->spk_alloc_data_blk = display->edid_ctrl->spkr_alloc_data_block;
blk->spk_alloc_data_blk_size = display->edid_ctrl->sadb_size;
return 0;
}
@ -650,7 +658,7 @@ void sde_hdmi_set_mode(struct hdmi *hdmi, bool power_on)
hdmi_write(hdmi, REG_HDMI_CTRL, ctrl);
spin_unlock_irqrestore(&hdmi->reg_lock, flags);
DRM_DEBUG("HDMI Core: %s, HDMI_CTRL=0x%08x\n",
SDE_HDMI_DEBUG("HDMI Core: %s, HDMI_CTRL=0x%08x\n",
power_on ? "Enable" : "Disable", ctrl);
}
@ -673,7 +681,7 @@ int sde_hdmi_ddc_read(struct hdmi *hdmi, u16 addr, u8 offset,
}
};
DRM_DEBUG("Start DDC read");
SDE_HDMI_DEBUG("Start DDC read");
retry:
rc = i2c_transfer(hdmi->i2c, msgs, 2);
@ -685,7 +693,7 @@ int sde_hdmi_ddc_read(struct hdmi *hdmi, u16 addr, u8 offset,
else
rc = -EIO;
DRM_DEBUG("End DDC read %d", rc);
SDE_HDMI_DEBUG("End DDC read %d", rc);
return rc;
}
@ -706,7 +714,7 @@ int sde_hdmi_ddc_write(struct hdmi *hdmi, u16 addr, u8 offset,
}
};
DRM_DEBUG("Start DDC write");
SDE_HDMI_DEBUG("Start DDC write");
if (data_len > (DDC_WRITE_MAX_BYTE_NUM - 1)) {
SDE_ERROR("%s: write size too big\n", __func__);
return -ERANGE;
@ -727,7 +735,7 @@ int sde_hdmi_ddc_write(struct hdmi *hdmi, u16 addr, u8 offset,
else
rc = -EIO;
DRM_DEBUG("End DDC write %d", rc);
SDE_HDMI_DEBUG("End DDC write %d", rc);
return rc;
}
@ -1030,8 +1038,6 @@ sde_hdmi_connector_detect(struct drm_connector *connector,
return status;
}
SDE_DEBUG("\n");
/* get display dsi_info */
memset(&info, 0x0, sizeof(info));
rc = sde_hdmi_get_info(&info, display);
@ -1052,25 +1058,6 @@ sde_hdmi_connector_detect(struct drm_connector *connector,
return status;
}
int _sde_hdmi_update_modes(struct drm_connector *connector,
struct sde_hdmi *display)
{
int rc = 0;
struct hdmi_edid_ctrl *edid_ctrl = &display->edid;
if (edid_ctrl->edid) {
drm_mode_connector_update_edid_property(connector,
edid_ctrl->edid);
rc = drm_add_edid_modes(connector, edid_ctrl->edid);
return rc;
}
drm_mode_connector_update_edid_property(connector, NULL);
return rc;
}
int sde_hdmi_connector_get_modes(struct drm_connector *connector, void *display)
{
struct sde_hdmi *hdmi_display = (struct sde_hdmi *)display;
@ -1083,8 +1070,6 @@ int sde_hdmi_connector_get_modes(struct drm_connector *connector, void *display)
return 0;
}
SDE_DEBUG("\n");
if (hdmi_display->non_pluggable) {
list_for_each_entry(mode, &hdmi_display->mode_list, head) {
m = drm_mode_duplicate(connector->dev, mode);
@ -1097,7 +1082,9 @@ int sde_hdmi_connector_get_modes(struct drm_connector *connector, void *display)
}
ret = hdmi_display->num_of_modes;
} else {
ret = _sde_hdmi_update_modes(connector, display);
/* pluggable case assumes EDID is read when HPD */
ret = _sde_edid_update_modes(connector,
hdmi_display->edid_ctrl);
}
return ret;
@ -1119,8 +1106,6 @@ enum drm_mode_status sde_hdmi_mode_valid(struct drm_connector *connector,
return 0;
}
SDE_DEBUG("\n");
hdmi = hdmi_display->ctrl.ctrl;
priv = connector->dev->dev_private;
kms = priv->kms;
@ -1128,7 +1113,7 @@ enum drm_mode_status sde_hdmi_mode_valid(struct drm_connector *connector,
actual = kms->funcs->round_pixclk(kms,
requested, hdmi->encoder);
SDE_DEBUG("requested=%ld, actual=%ld", requested, actual);
SDE_HDMI_DEBUG("requested=%ld, actual=%ld", requested, actual);
if (actual != requested)
return MODE_CLOCK_RANGE;
@ -1164,7 +1149,7 @@ static int sde_hdmi_bind(struct device *dev, struct device *master, void *data)
struct msm_drm_private *priv = NULL;
struct platform_device *pdev = to_platform_device(dev);
SDE_ERROR("E\n");
SDE_HDMI_DEBUG(" %s +\n", __func__);
if (!dev || !pdev || !master) {
pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
dev, pdev, master);
@ -1196,16 +1181,16 @@ static int sde_hdmi_bind(struct device *dev, struct device *master, void *data)
goto error;
}
rc = sde_hdmi_edid_init(display);
if (rc) {
SDE_ERROR("[%s]Ext Disp init failed, rc=%d\n",
display->name, rc);
display->edid_ctrl = sde_edid_init();
if (!display->edid_ctrl) {
SDE_ERROR("[%s]sde edid init failed\n",
display->name);
rc = -ENOMEM;
goto error;
}
display_ctrl = &display->ctrl;
display_ctrl->ctrl = priv->hdmi;
SDE_ERROR("display_ctrl->ctrl=%p\n", display_ctrl->ctrl);
display->drm_dev = drm;
error:
@ -1233,7 +1218,7 @@ static void sde_hdmi_unbind(struct device *dev, struct device *master,
}
mutex_lock(&display->display_lock);
(void)_sde_hdmi_debugfs_deinit(display);
(void)sde_hdmi_edid_deinit(display);
(void)sde_edid_deinit((void **)&display->edid_ctrl);
display->drm_dev = NULL;
mutex_unlock(&display->display_lock);
}

57
drivers/gpu/drm/msm/hdmi-staging/sde_hdmi.h
View file

@ -25,9 +25,13 @@
#include <drm/drm_crtc.h>
#include "hdmi.h"
#define MAX_NUMBER_ADB 5
#define MAX_AUDIO_DATA_BLOCK_SIZE 30
#define MAX_SPKR_ALLOC_DATA_BLOCK_SIZE 3
#include "sde_edid_parser.h"
#ifdef HDMI_DEBUG_ENABLE
#define SDE_HDMI_DEBUG(fmt, args...) SDE_ERROR(fmt, ##args)
#else
#define SDE_HDMI_DEBUG(fmt, args...) SDE_DEBUG(fmt, ##args)
#endif
/**
* struct sde_hdmi_info - defines hdmi display properties
@ -64,14 +68,6 @@ struct sde_hdmi_ctrl {
u32 hdmi_ctrl_idx;
};
struct hdmi_edid_ctrl {
struct edid *edid;
u8 audio_data_block[MAX_NUMBER_ADB * MAX_AUDIO_DATA_BLOCK_SIZE];
int adb_size;
u8 spkr_alloc_data_block[MAX_SPKR_ALLOC_DATA_BLOCK_SIZE];
int sadb_size;
};
/**
* struct sde_hdmi - hdmi display information
* @pdev: Pointer to platform device.
@ -102,7 +98,7 @@ struct sde_hdmi {
struct platform_device *ext_pdev;
struct msm_ext_disp_init_data ext_audio_data;
struct hdmi_edid_ctrl edid;
struct sde_edid_ctrl *edid_ctrl;
bool non_pluggable;
u32 num_of_modes;
@ -134,6 +130,8 @@ enum hdmi_tx_scdc_access_type {
HDMI_TX_SCDC_MAX,
};
#define HDMI_KHZ_TO_HZ 1000
#define HDMI_MHZ_TO_HZ 1000000
/**
* hdmi_tx_ddc_timer_type() - hdmi DDC timer functionalities.
*/
@ -146,7 +144,6 @@ enum hdmi_tx_ddc_timer_type {
HDMI_TX_DDC_TIMER_MAX,
};
#ifdef CONFIG_DRM_SDE_HDMI
/**
* sde_hdmi_get_num_of_displays() - returns number of display devices
@ -382,40 +379,6 @@ void sde_hdmi_notify_clients(struct drm_connector *connector,
void sde_hdmi_ack_state(struct drm_connector *connector,
enum drm_connector_status status);
/**
* sde_hdmi_edid_init() - init edid structure.
* @display: Handle to the sde_hdmi.
*
* Return: error code.
*/
int sde_hdmi_edid_init(struct sde_hdmi *display);
/**
* sde_hdmi_edid_deinit() - deinit edid structure.
* @display: Handle to the sde_hdmi.
*
* Return: error code.
*/
int sde_hdmi_edid_deinit(struct sde_hdmi *display);
/**
* sde_hdmi_get_edid() - get edid info.
* @connector: Handle to the drm_connector.
* @display: Handle to the sde_hdmi.
*
* Return: void.
*/
void sde_hdmi_get_edid(struct drm_connector *connector,
struct sde_hdmi *display);
/**
* sde_hdmi_free_edid() - free edid structure.
* @display: Handle to the sde_hdmi.
*
* Return: error code.
*/
int sde_hdmi_free_edid(struct sde_hdmi *display);
#else /*#ifdef CONFIG_DRM_SDE_HDMI*/
static inline u32 sde_hdmi_get_num_of_displays(void)

5
drivers/gpu/drm/msm/hdmi-staging/sde_hdmi_bridge.c
View file

@ -292,10 +292,13 @@ static int _sde_hdmi_bridge_setup_scrambler(struct hdmi *hdmi,
u32 tmds_clock_ratio = 0;
bool scrambler_on = false;
struct drm_connector *connector = NULL;
if (!hdmi || !mode) {
SDE_ERROR("invalid input\n");
return -EINVAL;
}
connector = hdmi->connector;
/* Read HDMI version */
reg_val = hdmi_read(hdmi, REG_HDMI_VERSION);
@ -309,6 +312,8 @@ static int _sde_hdmi_bridge_setup_scrambler(struct hdmi *hdmi,
if (mode->clock > HDMI_TX_SCRAMBLER_THRESHOLD_RATE_KHZ) {
scrambler_on = true;
tmds_clock_ratio = 1;
} else {
scrambler_on = connector->supports_scramble;
}
DRM_INFO("scrambler %s\n", scrambler_on ? "on" : "off");

227
drivers/gpu/drm/msm/hdmi-staging/sde_hdmi_edid.c
View file

@ -1,227 +0,0 @@
/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <drm/drm_edid.h>
#include "sde_kms.h"
#include "sde_hdmi.h"
/* TODO: copy from drm_edid.c and mdss_hdmi_edid.c. remove if using ELD */
#define DBC_START_OFFSET 4
#define EDID_DTD_LEN 18
enum data_block_types {
RESERVED,
AUDIO_DATA_BLOCK,
VIDEO_DATA_BLOCK,
VENDOR_SPECIFIC_DATA_BLOCK,
SPEAKER_ALLOCATION_DATA_BLOCK,
VESA_DTC_DATA_BLOCK,
RESERVED2,
USE_EXTENDED_TAG
};
static u8 *_sde_hdmi_edid_find_cea_extension(struct edid *edid)
{
u8 *edid_ext = NULL;
int i;
/* No EDID or EDID extensions */
if (edid == NULL || edid->extensions == 0)
return NULL;
/* Find CEA extension */
for (i = 0; i < edid->extensions; i++) {
edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1);
if (edid_ext[0] == CEA_EXT)
break;
}
if (i == edid->extensions)
return NULL;
return edid_ext;
}
static const u8 *_sde_hdmi_edid_find_block(const u8 *in_buf, u32 start_offset,
u8 type, u8 *len)
{
/* the start of data block collection, start of Video Data Block */
u32 offset = start_offset;
u32 dbc_offset = in_buf[2];
/*
* * edid buffer 1, byte 2 being 4 means no non-DTD/Data block
* collection present.
* * edid buffer 1, byte 2 being 0 means no non-DTD/DATA block
* collection present and no DTD data present.
*/
if ((dbc_offset == 0) || (dbc_offset == 4)) {
SDE_ERROR("EDID: no DTD or non-DTD data present\n");
return NULL;
}
while (offset < dbc_offset) {
u8 block_len = in_buf[offset] & 0x1F;
if ((offset + block_len <= dbc_offset) &&
(in_buf[offset] >> 5) == type) {
*len = block_len;
SDE_DEBUG("EDID: block=%d found @ 0x%x w/ len=%d\n",
type, offset, block_len);
return in_buf + offset;
}
offset += 1 + block_len;
}
return NULL;
}
static void _sde_hdmi_extract_audio_data_blocks(
struct hdmi_edid_ctrl *edid_ctrl)
{
u8 len = 0;
u8 adb_max = 0;
const u8 *adb = NULL;
u32 offset = DBC_START_OFFSET;
u8 *cea = NULL;
if (!edid_ctrl) {
SDE_ERROR("invalid edid_ctrl\n");
return;
}
cea = _sde_hdmi_edid_find_cea_extension(edid_ctrl->edid);
if (!cea) {
SDE_DEBUG("CEA extension not found\n");
return;
}
edid_ctrl->adb_size = 0;
memset(edid_ctrl->audio_data_block, 0,
sizeof(edid_ctrl->audio_data_block));
do {
len = 0;
adb = _sde_hdmi_edid_find_block(cea, offset, AUDIO_DATA_BLOCK,
&len);
if ((adb == NULL) || (len > MAX_AUDIO_DATA_BLOCK_SIZE ||
adb_max >= MAX_NUMBER_ADB)) {
if (!edid_ctrl->adb_size) {
SDE_DEBUG("No/Invalid Audio Data Block\n");
return;
}
continue;
}
memcpy(edid_ctrl->audio_data_block + edid_ctrl->adb_size,
adb + 1, len);
offset = (adb - cea) + 1 + len;
edid_ctrl->adb_size += len;
adb_max++;
} while (adb);
}
static void _sde_hdmi_extract_speaker_allocation_data(
struct hdmi_edid_ctrl *edid_ctrl)
{
u8 len;
const u8 *sadb = NULL;
u8 *cea = NULL;
if (!edid_ctrl) {
SDE_ERROR("invalid edid_ctrl\n");
return;
}
cea = _sde_hdmi_edid_find_cea_extension(edid_ctrl->edid);
if (!cea) {
SDE_DEBUG("CEA extension not found\n");
return;
}
sadb = _sde_hdmi_edid_find_block(cea, DBC_START_OFFSET,
SPEAKER_ALLOCATION_DATA_BLOCK, &len);
if ((sadb == NULL) || (len != MAX_SPKR_ALLOC_DATA_BLOCK_SIZE)) {
SDE_DEBUG("No/Invalid Speaker Allocation Data Block\n");
return;
}
memcpy(edid_ctrl->spkr_alloc_data_block, sadb + 1, len);
edid_ctrl->sadb_size = len;
SDE_DEBUG("EDID: speaker alloc data SP byte = %08x %s%s%s%s%s%s%s\n",
sadb[1],
(sadb[1] & BIT(0)) ? "FL/FR," : "",
(sadb[1] & BIT(1)) ? "LFE," : "",
(sadb[1] & BIT(2)) ? "FC," : "",
(sadb[1] & BIT(3)) ? "RL/RR," : "",
(sadb[1] & BIT(4)) ? "RC," : "",
(sadb[1] & BIT(5)) ? "FLC/FRC," : "",
(sadb[1] & BIT(6)) ? "RLC/RRC," : "");
}
int sde_hdmi_edid_init(struct sde_hdmi *display)
{
int rc = 0;
if (!display) {
SDE_ERROR("[%s]Invalid params\n", display->name);
return -EINVAL;
}
memset(&display->edid, 0, sizeof(display->edid));
return rc;
}
int sde_hdmi_free_edid(struct sde_hdmi *display)
{
struct hdmi_edid_ctrl *edid_ctrl = &display->edid;
kfree(edid_ctrl->edid);
edid_ctrl->edid = NULL;
return 0;
}
int sde_hdmi_edid_deinit(struct sde_hdmi *display)
{
return sde_hdmi_free_edid(display);
}
void sde_hdmi_get_edid(struct drm_connector *connector,
struct sde_hdmi *display)
{
u32 hdmi_ctrl;
struct hdmi_edid_ctrl *edid_ctrl = &display->edid;
struct hdmi *hdmi = display->ctrl.ctrl;
/* Read EDID */
hdmi_ctrl = hdmi_read(hdmi, REG_HDMI_CTRL);
hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl | HDMI_CTRL_ENABLE);
edid_ctrl->edid = drm_get_edid(connector, hdmi->i2c);
hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl);
if (edid_ctrl->edid) {
hdmi->hdmi_mode = drm_detect_hdmi_monitor(edid_ctrl->edid);
_sde_hdmi_extract_audio_data_blocks(edid_ctrl);
_sde_hdmi_extract_speaker_allocation_data(edid_ctrl);
}
};

512
drivers/gpu/drm/msm/sde_edid_parser.c Normal file
View file

@ -0,0 +1,512 @@
/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <drm/drm_edid.h>
#include "sde_kms.h"
#include "sde_edid_parser.h"
/* TODO: copy from drm_edid.c and mdss_hdmi_edid.c. remove if using ELD */
#define DBC_START_OFFSET 4
#define EDID_DTD_LEN 18
enum data_block_types {
RESERVED,
AUDIO_DATA_BLOCK,
VIDEO_DATA_BLOCK,
VENDOR_SPECIFIC_DATA_BLOCK,
SPEAKER_ALLOCATION_DATA_BLOCK,
VESA_DTC_DATA_BLOCK,
RESERVED2,
USE_EXTENDED_TAG
};
static u8 *sde_find_edid_extension(struct edid *edid, int ext_id)
{
u8 *edid_ext = NULL;
int i;
/* No EDID or EDID extensions */
if (edid == NULL || edid->extensions == 0)
return NULL;
/* Find CEA extension */
for (i = 0; i < edid->extensions; i++) {
edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1);
if (edid_ext[0] == ext_id)
break;
}
if (i == edid->extensions)
return NULL;
return edid_ext;
}
static u8 *sde_find_cea_extension(struct edid *edid)
{
return sde_find_edid_extension(edid, SDE_CEA_EXT);
}
static int
sde_cea_db_payload_len(const u8 *db)
{
return db[0] & 0x1f;
}
static int
sde_cea_db_tag(const u8 *db)
{
return db[0] >> 5;
}
static int
sde_cea_revision(const u8 *cea)
{
return cea[1];
}
static int
sde_cea_db_offsets(const u8 *cea, int *start, int *end)
{
/* Data block offset in CEA extension block */
*start = 4;
*end = cea[2];
if (*end == 0)
*end = 127;
if (*end < 4 || *end > 127)
return -ERANGE;
return 0;
}
#define sde_for_each_cea_db(cea, i, start, end) \
for ((i) = (start); \
(i) < (end) && (i) + sde_cea_db_payload_len(&(cea)[(i)]) < (end); \
(i) += sde_cea_db_payload_len(&(cea)[(i)]) + 1)
static u8 *sde_edid_find_extended_tag_block(struct edid *edid, int blk_id)
{
u8 *db = NULL;
u8 *cea = NULL;
if (!edid) {
pr_err("%s: invalid input\n", __func__);
return NULL;
}
cea = sde_find_cea_extension(edid);
if (cea && sde_cea_revision(cea) >= 3) {
int i, start, end;
if (sde_cea_db_offsets(cea, &start, &end))
return NULL;
sde_for_each_cea_db(cea, i, start, end) {
db = &cea[i];
if ((sde_cea_db_tag(db) == SDE_EXTENDED_TAG) &&
(db[1] == blk_id))
return db;
}
}
return NULL;
}
static u8 *
sde_edid_find_block(struct edid *edid, int blk_id)
{
u8 *db = NULL;
u8 *cea = NULL;
if (!edid) {
pr_err("%s: invalid input\n", __func__);
return NULL;
}
cea = sde_find_cea_extension(edid);
if (cea && sde_cea_revision(cea) >= 3) {
int i, start, end;
if (sde_cea_db_offsets(cea, &start, &end))
return 0;
sde_for_each_cea_db(cea, i, start, end) {
db = &cea[i];
if (sde_cea_db_tag(db) == blk_id)
return db;
}
}
return NULL;
}
static const u8 *_sde_edid_find_block(const u8 *in_buf, u32 start_offset,
u8 type, u8 *len)
{
/* the start of data block collection, start of Video Data Block */
u32 offset = start_offset;
u32 dbc_offset = in_buf[2];
SDE_EDID_DEBUG("%s +", __func__);
/*
* * edid buffer 1, byte 2 being 4 means no non-DTD/Data block
* collection present.
* * edid buffer 1, byte 2 being 0 means no non-DTD/DATA block
* collection present and no DTD data present.
*/
if ((dbc_offset == 0) || (dbc_offset == 4)) {
SDE_ERROR("EDID: no DTD or non-DTD data present\n");
return NULL;
}
while (offset < dbc_offset) {
u8 block_len = in_buf[offset] & 0x1F;
if ((offset + block_len <= dbc_offset) &&
(in_buf[offset] >> 5) == type) {
*len = block_len;
SDE_EDID_DEBUG("block=%d found @ 0x%x w/ len=%d\n",
type, offset, block_len);
return in_buf + offset;
}
offset += 1 + block_len;
}
return NULL;
}
static void sde_edid_extract_vendor_id(struct sde_edid_ctrl *edid_ctrl)
{
char *vendor_id;
u32 id_codes;
SDE_EDID_DEBUG("%s +", __func__);
if (!edid_ctrl) {
SDE_ERROR("%s: invalid input\n", __func__);
return;
}
vendor_id = edid_ctrl->vendor_id;
id_codes = ((u32)edid_ctrl->edid->mfg_id[0] << 8) +
edid_ctrl->edid->mfg_id[1];
vendor_id[0] = 'A' - 1 + ((id_codes >> 10) & 0x1F);
vendor_id[1] = 'A' - 1 + ((id_codes >> 5) & 0x1F);
vendor_id[2] = 'A' - 1 + (id_codes & 0x1F);
vendor_id[3] = 0;
SDE_EDID_DEBUG("vendor id is %s ", vendor_id);
SDE_EDID_DEBUG("%s -", __func__);
}
static void sde_edid_set_y420_support(struct drm_connector *connector,
u32 video_format)
{
u8 cea_mode = 0;
struct drm_display_mode *mode;
/* Need to add Y420 support flag to the modes */
list_for_each_entry(mode, &connector->probed_modes, head) {
cea_mode = drm_match_cea_mode(mode);
if ((cea_mode != 0) && (cea_mode == video_format)) {
SDE_EDID_DEBUG("%s found match for %d ", __func__,
video_format);
mode->flags |= DRM_MODE_FLAG_SUPPORTS_YUV;
}
}
}
static void sde_edid_parse_Y420CMDB(
struct drm_connector *connector, struct sde_edid_ctrl *edid_ctrl,
const u8 *db)
{
u32 offset = 0;
u8 len = 0;
u8 svd_len = 0;
const u8 *svd = NULL;
u32 i = 0, j = 0;
u32 video_format = 0;
if (!edid_ctrl) {
DEV_ERR("%s: edid_ctrl is NULL\n", __func__);
return;
}
if (!db) {
DEV_ERR("%s: invalid input\n", __func__);
return;
}
SDE_EDID_DEBUG("%s +\n", __func__);
len = db[0] & 0x1f;
if (len < 7)
return;
/* Byte 3 to L+1 contain SVDs */
offset += 2;
svd = sde_edid_find_block(edid_ctrl->edid, VIDEO_DATA_BLOCK);
if (svd) {
/*moving to the next byte as vic info begins there*/
++svd;
svd_len = svd[0] & 0x1f;
}
for (i = 0; i < svd_len; i++, j++) {
video_format = *svd & 0x7F;
if (db[offset] & (1 << j))
sde_edid_set_y420_support(connector, video_format);
if (j & 0x80) {
j = j/8;
offset++;
if (offset >= len)
break;
}
}
SDE_EDID_DEBUG("%s -\n", __func__);
}
static void sde_edid_parse_Y420VDB(
struct drm_connector *connector, struct sde_edid_ctrl *edid_ctrl,
const u8 *db)
{
u8 len = db[0] & 0x1f;
u32 i = 0;
u32 video_format = 0;
if (!edid_ctrl) {
DEV_ERR("%s: invalid input\n", __func__);
return;
}
SDE_EDID_DEBUG("%s +\n", __func__);
/* Offset to byte 3 */
db += 2;
for (i = 0; i < len - 1; i++) {
video_format = *(db + i) & 0x7F;
/*
* mode was already added in get_modes()
* only need to set the Y420 support flag
*/
sde_edid_set_y420_support(connector, video_format);
}
SDE_EDID_DEBUG("%s -", __func__);
}
static void sde_edid_set_mode_format(
struct drm_connector *connector, struct sde_edid_ctrl *edid_ctrl)
{
const u8 *db = NULL;
struct drm_display_mode *mode;
SDE_EDID_DEBUG("%s +\n", __func__);
/* Set YUV mode support flags for YCbcr420VDB */
db = sde_edid_find_extended_tag_block(edid_ctrl->edid,
Y420_VIDEO_DATA_BLOCK);
if (db)
sde_edid_parse_Y420VDB(connector, edid_ctrl, db);
else
SDE_EDID_DEBUG("YCbCr420 VDB is not present\n");
/* Set RGB supported on all modes where YUV is not set */
list_for_each_entry(mode, &connector->probed_modes, head) {
if (!(mode->flags & DRM_MODE_FLAG_SUPPORTS_YUV))
mode->flags |= DRM_MODE_FLAG_SUPPORTS_RGB;
}
db = sde_edid_find_extended_tag_block(edid_ctrl->edid,
Y420_CAPABILITY_MAP_DATA_BLOCK);
if (db)
sde_edid_parse_Y420CMDB(connector, edid_ctrl, db);
else
SDE_EDID_DEBUG("YCbCr420 CMDB is not present\n");
SDE_EDID_DEBUG("%s -\n", __func__);
}
static void _sde_edid_extract_audio_data_blocks(
struct sde_edid_ctrl *edid_ctrl)
{
u8 len = 0;
u8 adb_max = 0;
const u8 *adb = NULL;
u32 offset = DBC_START_OFFSET;
u8 *cea = NULL;
if (!edid_ctrl) {
SDE_ERROR("invalid edid_ctrl\n");
return;
}
SDE_EDID_DEBUG("%s +", __func__);
cea = sde_find_cea_extension(edid_ctrl->edid);
if (!cea) {
SDE_DEBUG("CEA extension not found\n");
return;
}
edid_ctrl->adb_size = 0;
memset(edid_ctrl->audio_data_block, 0,
sizeof(edid_ctrl->audio_data_block));
do {
len = 0;
adb = _sde_edid_find_block(cea, offset, AUDIO_DATA_BLOCK,
&len);
if ((adb == NULL) || (len > MAX_AUDIO_DATA_BLOCK_SIZE ||
adb_max >= MAX_NUMBER_ADB)) {
if (!edid_ctrl->adb_size) {
SDE_DEBUG("No/Invalid Audio Data Block\n");
return;
}
continue;
}
memcpy(edid_ctrl->audio_data_block + edid_ctrl->adb_size,
adb + 1, len);
offset = (adb - cea) + 1 + len;
edid_ctrl->adb_size += len;
adb_max++;
} while (adb);
SDE_EDID_DEBUG("%s -", __func__);
}
static void _sde_edid_extract_speaker_allocation_data(
struct sde_edid_ctrl *edid_ctrl)
{
u8 len;
const u8 *sadb = NULL;
u8 *cea = NULL;
if (!edid_ctrl) {
SDE_ERROR("invalid edid_ctrl\n");
return;
}
SDE_EDID_DEBUG("%s +", __func__);
cea = sde_find_cea_extension(edid_ctrl->edid);
if (!cea) {
SDE_DEBUG("CEA extension not found\n");
return;
}
sadb = _sde_edid_find_block(cea, DBC_START_OFFSET,
SPEAKER_ALLOCATION_DATA_BLOCK, &len);
if ((sadb == NULL) || (len != MAX_SPKR_ALLOC_DATA_BLOCK_SIZE)) {
SDE_DEBUG("No/Invalid Speaker Allocation Data Block\n");
return;
}
memcpy(edid_ctrl->spkr_alloc_data_block, sadb + 1, len);
edid_ctrl->sadb_size = len;
SDE_EDID_DEBUG("speaker alloc data SP byte = %08x %s%s%s%s%s%s%s\n",
sadb[1],
(sadb[1] & BIT(0)) ? "FL/FR," : "",
(sadb[1] & BIT(1)) ? "LFE," : "",
(sadb[1] & BIT(2)) ? "FC," : "",
(sadb[1] & BIT(3)) ? "RL/RR," : "",
(sadb[1] & BIT(4)) ? "RC," : "",
(sadb[1] & BIT(5)) ? "FLC/FRC," : "",
(sadb[1] & BIT(6)) ? "RLC/RRC," : "");
SDE_EDID_DEBUG("%s -", __func__);
}
struct sde_edid_ctrl *sde_edid_init(void)
{
struct sde_edid_ctrl *edid_ctrl = NULL;
SDE_EDID_DEBUG("%s +\n", __func__);
edid_ctrl = kzalloc(sizeof(*edid_ctrl), GFP_KERNEL);
if (!edid_ctrl) {
SDE_ERROR("edid_ctrl alloc failed\n");
return NULL;
}
memset((edid_ctrl), 0, sizeof(*edid_ctrl));
SDE_EDID_DEBUG("%s -\n", __func__);
return edid_ctrl;
}
void sde_free_edid(void **input)
{
struct sde_edid_ctrl *edid_ctrl = (struct sde_edid_ctrl *)(*input);
SDE_EDID_DEBUG("%s +", __func__);
kfree(edid_ctrl->edid);
edid_ctrl->edid = NULL;
}
void sde_edid_deinit(void **input)
{
struct sde_edid_ctrl *edid_ctrl = (struct sde_edid_ctrl *)(*input);
SDE_EDID_DEBUG("%s +", __func__);
sde_free_edid((void *)&edid_ctrl);
kfree(edid_ctrl);
SDE_EDID_DEBUG("%s -", __func__);
}
int _sde_edid_update_modes(struct drm_connector *connector,
void *input)
{
int rc = 0;
struct sde_edid_ctrl *edid_ctrl = (struct sde_edid_ctrl *)(input);
SDE_EDID_DEBUG("%s +", __func__);
if (edid_ctrl->edid) {
drm_mode_connector_update_edid_property(connector,
edid_ctrl->edid);
rc = drm_add_edid_modes(connector, edid_ctrl->edid);
sde_edid_set_mode_format(connector, edid_ctrl);
SDE_EDID_DEBUG("%s -", __func__);
return rc;
}
drm_mode_connector_update_edid_property(connector, NULL);
SDE_EDID_DEBUG("%s null edid -", __func__);
return rc;
}
bool sde_detect_hdmi_monitor(void *input)
{
struct sde_edid_ctrl *edid_ctrl = (struct sde_edid_ctrl *)(input);
return drm_detect_hdmi_monitor(edid_ctrl->edid);
}
void sde_get_edid(struct drm_connector *connector,
struct i2c_adapter *adapter, void **input)
{
struct sde_edid_ctrl *edid_ctrl = (struct sde_edid_ctrl *)(*input);
edid_ctrl->edid = drm_get_edid(connector, adapter);
SDE_EDID_DEBUG("%s +\n", __func__);
if (!edid_ctrl->edid)
SDE_ERROR("EDID read failed\n");
if (edid_ctrl->edid) {
sde_edid_extract_vendor_id(edid_ctrl);
_sde_edid_extract_audio_data_blocks(edid_ctrl);
_sde_edid_extract_speaker_allocation_data(edid_ctrl);
}
SDE_EDID_DEBUG("%s -\n", __func__);
};

148
drivers/gpu/drm/msm/sde_edid_parser.h Normal file
View file

@ -0,0 +1,148 @@
/*
* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#ifndef _SDE_EDID_PARSER_H_
#define _SDE_EDID_PARSER_H_
#include <linux/types.h>
#include <linux/bitops.h>
#include <linux/debugfs.h>
#include <linux/of_device.h>
#include <linux/i2c.h>
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_edid.h>
#define MAX_NUMBER_ADB 5
#define MAX_AUDIO_DATA_BLOCK_SIZE 30
#define MAX_SPKR_ALLOC_DATA_BLOCK_SIZE 3
#define EDID_VENDOR_ID_SIZE 4
#define SDE_CEA_EXT 0x02
#define SDE_EXTENDED_TAG 0x07
enum extended_data_block_types {
VIDEO_CAPABILITY_DATA_BLOCK = 0x0,
VENDOR_SPECIFIC_VIDEO_DATA_BLOCK = 0x01,
HDMI_VIDEO_DATA_BLOCK = 0x04,
HDR_STATIC_METADATA_DATA_BLOCK = 0x06,
Y420_VIDEO_DATA_BLOCK = 0x0E,
VIDEO_FORMAT_PREFERENCE_DATA_BLOCK = 0x0D,
Y420_CAPABILITY_MAP_DATA_BLOCK = 0x0F,
VENDOR_SPECIFIC_AUDIO_DATA_BLOCK = 0x11,
INFOFRAME_DATA_BLOCK = 0x20,
};
#ifdef SDE_EDID_DEBUG_ENABLE
#define SDE_EDID_DEBUG(fmt, args...) SDE_ERROR(fmt, ##args)
#else
#define SDE_EDID_DEBUG(fmt, args...) SDE_DEBUG(fmt, ##args)
#endif
/*
* struct hdmi_edid_hdr_data - HDR Static Metadata
* @eotf: Electro-Optical Transfer Function
* @metadata_type_one: Static Metadata Type 1 support
* @max_luminance: Desired Content Maximum Luminance
* @avg_luminance: Desired Content Frame-average Luminance
* @min_luminance: Desired Content Minimum Luminance
*/
struct sde_edid_hdr_data {
u32 eotf;
bool metadata_type_one;
u32 max_luminance;
u32 avg_luminance;
u32 min_luminance;
};
struct sde_edid_sink_caps {
u32 max_pclk_in_hz;
bool scdc_present;
bool scramble_support; /* scramble support for less than 340Mcsc */
bool read_req_support;
bool osd_disparity;
bool dual_view_support;
bool ind_view_support;
};
struct sde_edid_ctrl {
struct edid *edid;
u8 pt_scan_info;
u8 it_scan_info;
u8 ce_scan_info;
u8 audio_data_block[MAX_NUMBER_ADB * MAX_AUDIO_DATA_BLOCK_SIZE];
int adb_size;
u8 spkr_alloc_data_block[MAX_SPKR_ALLOC_DATA_BLOCK_SIZE];
int sadb_size;
bool hdr_supported;
char vendor_id[EDID_VENDOR_ID_SIZE];
struct sde_edid_sink_caps sink_caps;
struct sde_edid_hdr_data hdr_data;
};
/**
* sde_edid_init() - init edid structure.
* @edid_ctrl: Handle to the edid_ctrl structure.
* Return: handle to sde_edid_ctrl for the client.
*/
struct sde_edid_ctrl *sde_edid_init(void);
/**
* sde_edid_deinit() - deinit edid structure.
* @edid_ctrl: Handle to the edid_ctrl structure.
*
* Return: void.
*/
void sde_edid_deinit(void **edid_ctrl);
/**
* sde_get_edid() - get edid info.
* @connector: Handle to the drm_connector.
* @adapter: handle to i2c adapter for DDC read
* @edid_ctrl: Handle to the edid_ctrl structure.
*
* Return: void.
*/
void sde_get_edid(struct drm_connector *connector,
struct i2c_adapter *adapter,
void **edid_ctrl);
/**
* sde_free_edid() - free edid structure.
* @edid_ctrl: Handle to the edid_ctrl structure.
*
* Return: void.
*/
void sde_free_edid(void **edid_ctrl);
/**
* sde_detect_hdmi_monitor() - detect HDMI mode.
* @edid_ctrl: Handle to the edid_ctrl structure.
*
* Return: error code.
*/
bool sde_detect_hdmi_monitor(void *edid_ctrl);
/**
* _sde_edid_update_modes() - populate EDID modes.
* @edid_ctrl: Handle to the edid_ctrl structure.
*
* Return: error code.
*/
int _sde_edid_update_modes(struct drm_connector *connector,
void *edid_ctrl);
#endif /* _SDE_EDID_PARSER_H_ */