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

Merge "drm/msm: Add DRM EDID parser for external displays"

Browse source
This commit is contained in:
Linux Build Service Account 2017-04-12 16:10:05 -07:00 • committed by Gerrit - the friendly Code Review server
commit 5ccdda59a4
11 changed files with 1787 additions and 323 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

454
drivers/gpu/drm/drm_edid.c
View file

@ -89,6 +89,14 @@ struct detailed_mode_closure {
#define LEVEL_GTF2 2 #define LEVEL_GTF2 2
#define LEVEL_CVT 3 #define LEVEL_CVT 3
/*Enum storing luminance types for HDR blocks in EDID*/
enum luminance_value {
NO_LUMINANCE_DATA = 3,
MAXIMUM_LUMINANCE = 4,
FRAME_AVERAGE_LUMINANCE = 5,
MINIMUM_LUMINANCE = 6
};
static struct edid_quirk { static struct edid_quirk {
char vendor[4]; char vendor[4];
int product_id; int product_id;
@ -992,6 +1000,221 @@ static const struct drm_display_mode edid_cea_modes[] = {
2492, 2640, 0, 1080, 1084, 1094, 1125, 0, 2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC), DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, }, .vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9, },
/* 65 - 1280x720@24Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 59400, 1280, 3040,
3080, 3300, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 66 - 1280x720@25Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 3700,
3740, 3960, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 67 - 1280x720@30Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 3040,
3080, 3300, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 68 - 1280x720@50Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1720,
1760, 1980, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 69 - 1280x720@60Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74250, 1280, 1390,
1430, 1650, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 70 - 1280x720@100Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1720,
1760, 1980, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 71 - 1280x720@120Hz */
{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 148500, 1280, 1390,
1430, 1650, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 72 - 1920x1080@24Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2558,
2602, 2750, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 73 - 1920x1080@25Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2448,
2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 74 - 1920x1080@30Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 74250, 1920, 2008,
2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 75 - 1920x1080@50Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2448,
2492, 2640, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 76 - 1920x1080@60Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2008,
2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 77 - 1920x1080@100Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2448,
2492, 2640, 0, 1080, 1084, 1094, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 78 - 1920x1080@120Hz */
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 297000, 1920, 2008,
2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 79 - 1680x720@24Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 59400, 1680, 3040,
3080, 3300, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 80 - 1680x720@25Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 59400, 1680, 2908,
2948, 3168, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 81 - 1680x720@30Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 59400, 1680, 2380,
2420, 2640, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 82 - 1680x720@50Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 82500, 1680, 1940,
1980, 2200, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 83 - 1680x720@60Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 99000, 1680, 1940,
1980, 2200, 0, 720, 725, 730, 750, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 84 - 1680x720@100Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 165000, 1680, 1740,
1780, 2000, 0, 720, 725, 730, 825, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 85 - 1680x720@120Hz */
{ DRM_MODE("1680x720", DRM_MODE_TYPE_DRIVER, 198000, 1680, 1740,
1780, 2000, 0, 720, 725, 730, 825, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 86 - 2560x1080@24Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 99000, 2560, 3558,
3602, 3750, 0, 1080, 1084, 1089, 1100, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 87 - 2560x1080@25Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 90000, 2560, 3008,
3052, 3200, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 88 - 2560x1080@30Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 118800, 2560, 3328,
3372, 3520, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 89 - 2560x1080@50Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 185625, 2560, 3108,
3152, 3300, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 90 - 2560x1080@60Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 198000, 2560, 2808,
2852, 3000, 0, 1080, 1084, 1089, 1100, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 91 - 2560x1080@100Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 371250, 2560, 2778,
2822, 2970, 0, 1080, 1084, 1089, 1250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 100, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 92 - 2560x1080@120Hz */
{ DRM_MODE("2560x1080", DRM_MODE_TYPE_DRIVER, 495000, 2560, 3108,
3152, 3300, 0, 1080, 1084, 1089, 1250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 120, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27, },
/* 93 - 3840x2160p@24Hz 16:9 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000, 3840, 5116,
5204, 5500, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9,},
/* 94 - 3840x2160p@25Hz 16:9 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000, 3840, 4896,
4984, 5280, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9},
/* 95 - 3840x2160p@30Hz 16:9 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000, 3840, 4016,
4104, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9},
/* 96 - 3840x2160p@50Hz 16:9 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 594000, 3840, 4896,
4984, 5280, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9},
/* 97 - 3840x2160p@60Hz 16:9 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 594000, 3840, 4016,
4104, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9},
/* 98 - 4096x2160p@24Hz 256:135 */
{ DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 297000, 4096, 5116,
5204, 5500, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_256_135},
/* 99 - 4096x2160p@25Hz 256:135 */
{ DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 297000, 4096, 5064,
5152, 5280, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_256_135},
/* 100 - 4096x2160p@30Hz 256:135 */
{ DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 297000, 4096, 4184,
4272, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_256_135},
/* 101 - 4096x2160p@50Hz 256:135 */
{ DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 594000, 4096, 5064,
5152, 5280, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_256_135},
/* 102 - 4096x2160p@60Hz 256:135 */
{ DRM_MODE("4096x2160", DRM_MODE_TYPE_DRIVER, 594000, 4096, 4184,
4272, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_256_135},
/* 103 - 3840x2160p@24Hz 64:27 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000, 3840, 5116,
5204, 5500, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 24, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27},
/* 104 - 3840x2160p@25Hz 64:27 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000, 3840, 4016,
4104, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 25, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27},
/* 105 - 3840x2160p@30Hz 64:27 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 297000, 3840, 4016,
4104, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 30, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27},
/* 106 - 3840x2160p@50Hz 64:27 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 594000, 3840, 4896,
4984, 5280, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 50, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27},
/* 107 - 3840x2160p@60Hz 64:27 */
{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 594000, 3840, 4016,
4104, 4400, 0, 2160, 2168, 2178, 2250, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, .picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27},
}; };
/* /*
@ -2482,12 +2705,15 @@ add_detailed_modes(struct drm_connector *connector, struct edid *edid,
return closure.modes; return closure.modes;
} }
#define VIDEO_CAPABILITY_EXTENDED_DATA_BLOCK 0x0
#define AUDIO_BLOCK 0x01 #define AUDIO_BLOCK 0x01
#define VIDEO_BLOCK 0x02 #define VIDEO_BLOCK 0x02
#define VENDOR_BLOCK 0x03 #define VENDOR_BLOCK 0x03
#define SPEAKER_BLOCK 0x04 #define SPEAKER_BLOCK 0x04
#define HDR_STATIC_METADATA_EXTENDED_DATA_BLOCK 0x06
#define EXTENDED_TAG 0x07
#define VIDEO_CAPABILITY_BLOCK 0x07 #define VIDEO_CAPABILITY_BLOCK 0x07
#define Y420_VIDEO_DATA_BLOCK 0x0E
#define EDID_BASIC_AUDIO (1 << 6) #define EDID_BASIC_AUDIO (1 << 6)
#define EDID_CEA_YCRCB444 (1 << 5) #define EDID_CEA_YCRCB444 (1 << 5)
#define EDID_CEA_YCRCB422 (1 << 4) #define EDID_CEA_YCRCB422 (1 << 4)
@ -3244,6 +3470,227 @@ parse_hdmi_hf_vsdb(struct drm_connector *connector, const u8 *db)
"supported" : "not supported"); "supported" : "not supported");
} }
static void
drm_hdmi_extract_vsdbs_info(struct drm_connector *connector, struct edid *edid)
{
const u8 *cea = drm_find_cea_extension(edid);
const u8 *db = NULL;
if (cea && cea_revision(cea) >= 3) {
int i, start, end;
if (cea_db_offsets(cea, &start, &end))
return;
for_each_cea_db(cea, i, start, end) {
db = &cea[i];
if (cea_db_tag(db) == VENDOR_BLOCK) {
/* HDMI Vendor-Specific Data Block */
if (cea_db_is_hdmi_vsdb(db))
parse_hdmi_vsdb(connector, db);
/* HDMI Forum Vendor-Specific Data Block */
else if (cea_db_is_hdmi_hf_vsdb(db))
parse_hdmi_hf_vsdb(connector, db);
}
}
}
}
/*
* drm_extract_vcdb_info - Parse the HDMI Video Capability Data Block
* @connector: connector corresponding to the HDMI sink
* @db: start of the CEA vendor specific block
*
* Parses the HDMI VCDB to extract sink info for @connector.
*/
static void
drm_extract_vcdb_info(struct drm_connector *connector, const u8 *db)
{
/*
* Check if the sink specifies underscan
* support for:
* BIT 5: preferred video format
* BIT 3: IT video format
* BIT 1: CE video format
*/
connector->pt_scan_info =
(db[2] & (BIT(4) | BIT(5))) >> 4;
connector->it_scan_info =
(db[2] & (BIT(3) | BIT(2))) >> 2;
connector->ce_scan_info =
db[2] & (BIT(1) | BIT(0));
DRM_DEBUG_KMS("Scan Info (pt|it|ce): (%d|%d|%d)",
(int) connector->pt_scan_info,
(int) connector->it_scan_info,
(int) connector->ce_scan_info);
}
static bool drm_edid_is_luminance_value_present(
u32 block_length, enum luminance_value value)
{
return block_length > NO_LUMINANCE_DATA && value <= block_length;
}
/*
* drm_extract_hdr_db - Parse the HDMI HDR extended block
* @connector: connector corresponding to the HDMI sink
* @db: start of the HDMI HDR extended block
*
* Parses the HDMI HDR extended block to extract sink info for @connector.
*/
static void
drm_extract_hdr_db(struct drm_connector *connector, const u8 *db)
{
u8 len = 0;
if (!db) {
DRM_ERROR("invalid db\n");
return;
}
len = db[0] & 0x1f;
/* Byte 3: Electro-Optical Transfer Functions */
connector->hdr_eotf = db[2] & 0x3F;
/* Byte 4: Static Metadata Descriptor Type 1 */
connector->hdr_metadata_type_one = (db[3] & BIT(0));
/* Byte 5: Desired Content Maximum Luminance */
if (drm_edid_is_luminance_value_present(len, MAXIMUM_LUMINANCE))
connector->hdr_max_luminance =
db[MAXIMUM_LUMINANCE];
/* Byte 6: Desired Content Max Frame-average Luminance */
if (drm_edid_is_luminance_value_present(len, FRAME_AVERAGE_LUMINANCE))
connector->hdr_avg_luminance =
db[FRAME_AVERAGE_LUMINANCE];
/* Byte 7: Desired Content Min Luminance */
if (drm_edid_is_luminance_value_present(len, MINIMUM_LUMINANCE))
connector->hdr_min_luminance =
db[MINIMUM_LUMINANCE];
connector->hdr_supported = true;
DRM_DEBUG_KMS("HDR electro-optical %d\n", connector->hdr_eotf);
DRM_DEBUG_KMS("metadata desc 1 %d\n", connector->hdr_metadata_type_one);
DRM_DEBUG_KMS("max luminance %d\n", connector->hdr_max_luminance);
DRM_DEBUG_KMS("avg luminance %d\n", connector->hdr_avg_luminance);
DRM_DEBUG_KMS("min luminance %d\n", connector->hdr_min_luminance);
}
/*
* drm_hdmi_extract_extended_blk_info - Parse the HDMI extended tag blocks
* @connector: connector corresponding to the HDMI sink
* @edid: handle to the EDID structure
* Parses the all extended tag blocks extract sink info for @connector.
*/
static void
drm_hdmi_extract_extended_blk_info(struct drm_connector *connector,
struct edid *edid)
{
const u8 *cea = drm_find_cea_extension(edid);
const u8 *db = NULL;
if (cea && cea_revision(cea) >= 3) {
int i, start, end;
if (cea_db_offsets(cea, &start, &end))
return;
for_each_cea_db(cea, i, start, end) {
db = &cea[i];
if (cea_db_tag(db) == EXTENDED_TAG) {
DRM_DEBUG_KMS("found extended tag block = %d\n",
db[1]);
switch (db[1]) {
case VIDEO_CAPABILITY_EXTENDED_DATA_BLOCK:
drm_extract_vcdb_info(connector, db);
break;
case HDR_STATIC_METADATA_EXTENDED_DATA_BLOCK:
drm_extract_hdr_db(connector, db);
break;
default:
break;
}
}
}
}
}
static u8 *
drm_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 = drm_find_cea_extension(edid);
if (cea && cea_revision(cea) >= 3) {
int i, start, end;
if (cea_db_offsets(cea, &start, &end))
return NULL;
for_each_cea_db(cea, i, start, end) {
db = &cea[i];
if ((cea_db_tag(db) == EXTENDED_TAG) &&
(db[1] == blk_id))
return db;
}
}
return NULL;
}
/*
* add_YCbCr420VDB_modes - add the modes found in Ycbcr420 VDB block
* @connector: connector corresponding to the HDMI sink
* @edid: handle to the EDID structure
* Parses the YCbCr420 VDB block and adds the modes to @connector.
*/
static int
add_YCbCr420VDB_modes(struct drm_connector *connector, struct edid *edid)
{
const u8 *db = NULL;
u32 i = 0;
u32 modes = 0;
u32 video_format = 0;
u8 len = 0;
/*Find the YCbCr420 VDB*/
db = drm_edid_find_extended_tag_block(edid, Y420_VIDEO_DATA_BLOCK);
/* Offset to byte 3 */
if (db) {
len = db[0] & 0x1F;
db += 2;
for (i = 0; i < len - 1; i++) {
struct drm_display_mode *mode;
video_format = *(db + i) & 0x7F;
mode = drm_display_mode_from_vic_index(connector,
db, len-1, i);
if (mode) {
DRM_DEBUG_KMS("Adding mode for vic = %d\n",
video_format);
drm_mode_probed_add(connector, mode);
modes++;
}
}
}
return modes;
}
static void static void
monitor_name(struct detailed_timing *t, void *data) monitor_name(struct detailed_timing *t, void *data)
{ {
@ -3782,6 +4229,10 @@ static void drm_add_display_info(struct edid *edid,
info->color_formats |= DRM_COLOR_FORMAT_YCRCB422; info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
} }
/* Extract audio and video latency fields for the sink */
drm_hdmi_extract_vsdbs_info(connector, edid);
/* Extract info from extended tag blocks */
drm_hdmi_extract_extended_blk_info(connector, edid);
/* HDMI deep color modes supported? Assign to info, if so */ /* HDMI deep color modes supported? Assign to info, if so */
drm_assign_hdmi_deep_color_info(edid, info, connector); drm_assign_hdmi_deep_color_info(edid, info, connector);
@ -4012,6 +4463,7 @@ int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid)
num_modes += add_cea_modes(connector, edid); num_modes += add_cea_modes(connector, edid);
num_modes += add_alternate_cea_modes(connector, edid); num_modes += add_alternate_cea_modes(connector, edid);
num_modes += add_displayid_detailed_modes(connector, edid); num_modes += add_displayid_detailed_modes(connector, edid);
num_modes += add_YCbCr420VDB_modes(connector, edid);
if (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF) if (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF)
num_modes += add_inferred_modes(connector, edid); num_modes += add_inferred_modes(connector, edid);

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

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

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

@ -32,6 +32,22 @@
static DEFINE_MUTEX(sde_hdmi_list_lock); static DEFINE_MUTEX(sde_hdmi_list_lock);
static LIST_HEAD(sde_hdmi_list); static LIST_HEAD(sde_hdmi_list);
/* HDMI SCDC register offsets */
#define HDMI_SCDC_UPDATE_0 0x10
#define HDMI_SCDC_UPDATE_1 0x11
#define HDMI_SCDC_TMDS_CONFIG 0x20
#define HDMI_SCDC_SCRAMBLER_STATUS 0x21
#define HDMI_SCDC_CONFIG_0 0x30
#define HDMI_SCDC_STATUS_FLAGS_0 0x40
#define HDMI_SCDC_STATUS_FLAGS_1 0x41
#define HDMI_SCDC_ERR_DET_0_L 0x50
#define HDMI_SCDC_ERR_DET_0_H 0x51
#define HDMI_SCDC_ERR_DET_1_L 0x52
#define HDMI_SCDC_ERR_DET_1_H 0x53
#define HDMI_SCDC_ERR_DET_2_L 0x54
#define HDMI_SCDC_ERR_DET_2_H 0x55
#define HDMI_SCDC_ERR_DET_CHECKSUM 0x56
static const struct of_device_id sde_hdmi_dt_match[] = { static const struct of_device_id sde_hdmi_dt_match[] = {
{.compatible = "qcom,hdmi-display"}, {.compatible = "qcom,hdmi-display"},
{} {}
@ -395,20 +411,28 @@ static void _sde_hdmi_hotplug_work(struct work_struct *work)
struct sde_hdmi *sde_hdmi = struct sde_hdmi *sde_hdmi =
container_of(work, struct sde_hdmi, hpd_work); container_of(work, struct sde_hdmi, hpd_work);
struct drm_connector *connector; struct drm_connector *connector;
struct hdmi *hdmi = NULL;
u32 hdmi_ctrl;
if (!sde_hdmi || !sde_hdmi->ctrl.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_ERROR("sde_hdmi=%p or hdmi or connector is NULL\n",
sde_hdmi); sde_hdmi);
return; return;
} }
hdmi = sde_hdmi->ctrl.ctrl;
connector = sde_hdmi->ctrl.ctrl->connector; connector = sde_hdmi->ctrl.ctrl->connector;
if (sde_hdmi->connected) if (sde_hdmi->connected) {
sde_hdmi_get_edid(connector, sde_hdmi); hdmi_ctrl = hdmi_read(hdmi, REG_HDMI_CTRL);
else hdmi_write(hdmi, REG_HDMI_CTRL, hdmi_ctrl | HDMI_CTRL_ENABLE);
sde_hdmi_free_edid(sde_hdmi); 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); sde_hdmi_notify_clients(connector, sde_hdmi->connected);
drm_helper_hpd_irq_event(connector->dev); drm_helper_hpd_irq_event(connector->dev);
@ -431,7 +455,7 @@ static void _sde_hdmi_connector_irq(struct sde_hdmi *sde_hdmi)
hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL, hdmi_write(hdmi, REG_HDMI_HPD_INT_CTRL,
HDMI_HPD_INT_CTRL_INT_ACK); 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); hpd_int_ctrl);
/* detect disconnect if we are connected or visa versa: */ /* detect disconnect if we are connected or visa versa: */
@ -504,11 +528,11 @@ static int _sde_hdmi_get_audio_edid_blk(struct platform_device *pdev,
return -ENODEV; return -ENODEV;
} }
blk->audio_data_blk = display->edid.audio_data_block; blk->audio_data_blk = display->edid_ctrl->audio_data_block;
blk->audio_data_blk_size = display->edid.adb_size; 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 = display->edid_ctrl->spkr_alloc_data_block;
blk->spk_alloc_data_blk_size = display->edid.sadb_size; blk->spk_alloc_data_blk_size = display->edid_ctrl->sadb_size;
return 0; return 0;
} }
@ -634,10 +658,249 @@ void sde_hdmi_set_mode(struct hdmi *hdmi, bool power_on)
hdmi_write(hdmi, REG_HDMI_CTRL, ctrl); hdmi_write(hdmi, REG_HDMI_CTRL, ctrl);
spin_unlock_irqrestore(&hdmi->reg_lock, flags); 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); power_on ? "Enable" : "Disable", ctrl);
} }
int sde_hdmi_ddc_read(struct hdmi *hdmi, u16 addr, u8 offset,
u8 *data, u16 data_len)
{
int rc;
int retry = 5;
struct i2c_msg msgs[] = {
{
.addr = addr >> 1,
.flags = 0,
.len = 1,
.buf = &offset,
}, {
.addr = addr >> 1,
.flags = I2C_M_RD,
.len = data_len,
.buf = data,
}
};
SDE_HDMI_DEBUG("Start DDC read");
retry:
rc = i2c_transfer(hdmi->i2c, msgs, 2);
retry--;
if (rc == 2)
rc = 0;
else if (retry > 0)
goto retry;
else
rc = -EIO;
SDE_HDMI_DEBUG("End DDC read %d", rc);
return rc;
}
#define DDC_WRITE_MAX_BYTE_NUM 32
int sde_hdmi_ddc_write(struct hdmi *hdmi, u16 addr, u8 offset,
u8 *data, u16 data_len)
{
int rc;
int retry = 10;
u8 buf[DDC_WRITE_MAX_BYTE_NUM];
struct i2c_msg msgs[] = {
{
.addr = addr >> 1,
.flags = 0,
.len = 1,
}
};
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;
}
buf[0] = offset;
memcpy(&buf[1], data, data_len);
msgs[0].buf = buf;
msgs[0].len = data_len + 1;
retry:
rc = i2c_transfer(hdmi->i2c, msgs, 1);
retry--;
if (rc == 1)
rc = 0;
else if (retry > 0)
goto retry;
else
rc = -EIO;
SDE_HDMI_DEBUG("End DDC write %d", rc);
return rc;
}
int sde_hdmi_scdc_read(struct hdmi *hdmi, u32 data_type, u32 *val)
{
int rc = 0;
u8 data_buf[2] = {0};
u16 dev_addr, data_len;
u8 offset;
if (!hdmi || !hdmi->i2c || !val) {
SDE_ERROR("Bad Parameters\n");
return -EINVAL;
}
if (data_type >= HDMI_TX_SCDC_MAX) {
SDE_ERROR("Unsupported data type\n");
return -EINVAL;
}
dev_addr = 0xA8;
switch (data_type) {
case HDMI_TX_SCDC_SCRAMBLING_STATUS:
data_len = 1;
offset = HDMI_SCDC_SCRAMBLER_STATUS;
break;
case HDMI_TX_SCDC_SCRAMBLING_ENABLE:
case HDMI_TX_SCDC_TMDS_BIT_CLOCK_RATIO_UPDATE:
data_len = 1;
offset = HDMI_SCDC_TMDS_CONFIG;
break;
case HDMI_TX_SCDC_CLOCK_DET_STATUS:
case HDMI_TX_SCDC_CH0_LOCK_STATUS:
case HDMI_TX_SCDC_CH1_LOCK_STATUS:
case HDMI_TX_SCDC_CH2_LOCK_STATUS:
data_len = 1;
offset = HDMI_SCDC_STATUS_FLAGS_0;
break;
case HDMI_TX_SCDC_CH0_ERROR_COUNT:
data_len = 2;
offset = HDMI_SCDC_ERR_DET_0_L;
break;
case HDMI_TX_SCDC_CH1_ERROR_COUNT:
data_len = 2;
offset = HDMI_SCDC_ERR_DET_1_L;
break;
case HDMI_TX_SCDC_CH2_ERROR_COUNT:
data_len = 2;
offset = HDMI_SCDC_ERR_DET_2_L;
break;
case HDMI_TX_SCDC_READ_ENABLE:
data_len = 1;
offset = HDMI_SCDC_CONFIG_0;
break;
default:
break;
}
rc = sde_hdmi_ddc_read(hdmi, dev_addr, offset, data_buf, data_len);
if (rc) {
SDE_ERROR("DDC Read failed for %d\n", data_type);
return rc;
}
switch (data_type) {
case HDMI_TX_SCDC_SCRAMBLING_STATUS:
*val = (data_buf[0] & BIT(0)) ? 1 : 0;
break;
case HDMI_TX_SCDC_SCRAMBLING_ENABLE:
*val = (data_buf[0] & BIT(0)) ? 1 : 0;
break;
case HDMI_TX_SCDC_TMDS_BIT_CLOCK_RATIO_UPDATE:
*val = (data_buf[0] & BIT(1)) ? 1 : 0;
break;
case HDMI_TX_SCDC_CLOCK_DET_STATUS:
*val = (data_buf[0] & BIT(0)) ? 1 : 0;
break;
case HDMI_TX_SCDC_CH0_LOCK_STATUS:
*val = (data_buf[0] & BIT(1)) ? 1 : 0;
break;
case HDMI_TX_SCDC_CH1_LOCK_STATUS:
*val = (data_buf[0] & BIT(2)) ? 1 : 0;
break;
case HDMI_TX_SCDC_CH2_LOCK_STATUS:
*val = (data_buf[0] & BIT(3)) ? 1 : 0;
break;
case HDMI_TX_SCDC_CH0_ERROR_COUNT:
case HDMI_TX_SCDC_CH1_ERROR_COUNT:
case HDMI_TX_SCDC_CH2_ERROR_COUNT:
if (data_buf[1] & BIT(7))
*val = (data_buf[0] | ((data_buf[1] & 0x7F) << 8));
else
*val = 0;
break;
case HDMI_TX_SCDC_READ_ENABLE:
*val = (data_buf[0] & BIT(0)) ? 1 : 0;
break;
default:
break;
}
return 0;
}
int sde_hdmi_scdc_write(struct hdmi *hdmi, u32 data_type, u32 val)
{
int rc = 0;
u8 data_buf[2] = {0};
u8 read_val = 0;
u16 dev_addr, data_len;
u8 offset;
if (!hdmi || !hdmi->i2c) {
SDE_ERROR("Bad Parameters\n");
return -EINVAL;
}
if (data_type >= HDMI_TX_SCDC_MAX) {
SDE_ERROR("Unsupported data type\n");
return -EINVAL;
}
dev_addr = 0xA8;
switch (data_type) {
case HDMI_TX_SCDC_SCRAMBLING_ENABLE:
case HDMI_TX_SCDC_TMDS_BIT_CLOCK_RATIO_UPDATE:
dev_addr = 0xA8;
data_len = 1;
offset = HDMI_SCDC_TMDS_CONFIG;
rc = sde_hdmi_ddc_read(hdmi, dev_addr, offset, &read_val,
data_len);
if (rc) {
SDE_ERROR("scdc read failed\n");
return rc;
}
if (data_type == HDMI_TX_SCDC_SCRAMBLING_ENABLE) {
data_buf[0] = ((((u8)(read_val & 0xFF)) & (~BIT(0))) |
((u8)(val & BIT(0))));
} else {
data_buf[0] = ((((u8)(read_val & 0xFF)) & (~BIT(1))) |
(((u8)(val & BIT(0))) << 1));
}
break;
case HDMI_TX_SCDC_READ_ENABLE:
data_len = 1;
offset = HDMI_SCDC_CONFIG_0;
data_buf[0] = (u8)(val & 0x1);
break;
default:
SDE_ERROR("Cannot write to read only reg (%d)\n",
data_type);
return -EINVAL;
}
rc = sde_hdmi_ddc_write(hdmi, dev_addr, offset, data_buf, data_len);
if (rc) {
SDE_ERROR("DDC Read failed for %d\n", data_type);
return rc;
}
return 0;
}
int sde_hdmi_get_info(struct msm_display_info *info, int sde_hdmi_get_info(struct msm_display_info *info,
void *display) void *display)
{ {
@ -775,8 +1038,6 @@ sde_hdmi_connector_detect(struct drm_connector *connector,
return status; return status;
} }
SDE_DEBUG("\n");
/* get display dsi_info */ /* get display dsi_info */
memset(&info, 0x0, sizeof(info)); memset(&info, 0x0, sizeof(info));
rc = sde_hdmi_get_info(&info, display); rc = sde_hdmi_get_info(&info, display);
@ -797,25 +1058,6 @@ sde_hdmi_connector_detect(struct drm_connector *connector,
return status; 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) int sde_hdmi_connector_get_modes(struct drm_connector *connector, void *display)
{ {
struct sde_hdmi *hdmi_display = (struct sde_hdmi *)display; struct sde_hdmi *hdmi_display = (struct sde_hdmi *)display;
@ -828,8 +1070,6 @@ int sde_hdmi_connector_get_modes(struct drm_connector *connector, void *display)
return 0; return 0;
} }
SDE_DEBUG("\n");
if (hdmi_display->non_pluggable) { if (hdmi_display->non_pluggable) {
list_for_each_entry(mode, &hdmi_display->mode_list, head) { list_for_each_entry(mode, &hdmi_display->mode_list, head) {
m = drm_mode_duplicate(connector->dev, mode); m = drm_mode_duplicate(connector->dev, mode);
@ -842,7 +1082,9 @@ int sde_hdmi_connector_get_modes(struct drm_connector *connector, void *display)
} }
ret = hdmi_display->num_of_modes; ret = hdmi_display->num_of_modes;
} else { } 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; return ret;
@ -864,8 +1106,6 @@ enum drm_mode_status sde_hdmi_mode_valid(struct drm_connector *connector,
return 0; return 0;
} }
SDE_DEBUG("\n");
hdmi = hdmi_display->ctrl.ctrl; hdmi = hdmi_display->ctrl.ctrl;
priv = connector->dev->dev_private; priv = connector->dev->dev_private;
kms = priv->kms; kms = priv->kms;
@ -873,7 +1113,7 @@ enum drm_mode_status sde_hdmi_mode_valid(struct drm_connector *connector,
actual = kms->funcs->round_pixclk(kms, actual = kms->funcs->round_pixclk(kms,
requested, hdmi->encoder); requested, hdmi->encoder);
SDE_DEBUG("requested=%ld, actual=%ld", requested, actual); SDE_HDMI_DEBUG("requested=%ld, actual=%ld", requested, actual);
if (actual != requested) if (actual != requested)
return MODE_CLOCK_RANGE; return MODE_CLOCK_RANGE;
@ -909,7 +1149,7 @@ static int sde_hdmi_bind(struct device *dev, struct device *master, void *data)
struct msm_drm_private *priv = NULL; struct msm_drm_private *priv = NULL;
struct platform_device *pdev = to_platform_device(dev); struct platform_device *pdev = to_platform_device(dev);
SDE_ERROR("E\n"); SDE_HDMI_DEBUG(" %s +\n", __func__);
if (!dev || !pdev || !master) { if (!dev || !pdev || !master) {
pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n", pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
dev, pdev, master); dev, pdev, master);
@ -941,16 +1181,16 @@ static int sde_hdmi_bind(struct device *dev, struct device *master, void *data)
goto error; goto error;
} }
rc = sde_hdmi_edid_init(display); display->edid_ctrl = sde_edid_init();
if (rc) { if (!display->edid_ctrl) {
SDE_ERROR("[%s]Ext Disp init failed, rc=%d\n", SDE_ERROR("[%s]sde edid init failed\n",
display->name, rc); display->name);
rc = -ENOMEM;
goto error; goto error;
} }
display_ctrl = &display->ctrl; display_ctrl = &display->ctrl;
display_ctrl->ctrl = priv->hdmi; display_ctrl->ctrl = priv->hdmi;
SDE_ERROR("display_ctrl->ctrl=%p\n", display_ctrl->ctrl);
display->drm_dev = drm; display->drm_dev = drm;
error: error:
@ -978,7 +1218,7 @@ static void sde_hdmi_unbind(struct device *dev, struct device *master,
} }
mutex_lock(&display->display_lock); mutex_lock(&display->display_lock);
(void)_sde_hdmi_debugfs_deinit(display); (void)_sde_hdmi_debugfs_deinit(display);
(void)sde_hdmi_edid_deinit(display); (void)sde_edid_deinit((void **)&display->edid_ctrl);
display->drm_dev = NULL; display->drm_dev = NULL;
mutex_unlock(&display->display_lock); mutex_unlock(&display->display_lock);
} }

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

@ -25,9 +25,13 @@
#include <drm/drm_crtc.h> #include <drm/drm_crtc.h>
#include "hdmi.h" #include "hdmi.h"
#define MAX_NUMBER_ADB 5 #include "sde_edid_parser.h"
#define MAX_AUDIO_DATA_BLOCK_SIZE 30
#define MAX_SPKR_ALLOC_DATA_BLOCK_SIZE 3 #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 * struct sde_hdmi_info - defines hdmi display properties
@ -64,14 +68,6 @@ struct sde_hdmi_ctrl {
u32 hdmi_ctrl_idx; 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 * struct sde_hdmi - hdmi display information
* @pdev: Pointer to platform device. * @pdev: Pointer to platform device.
@ -102,7 +98,7 @@ struct sde_hdmi {
struct platform_device *ext_pdev; struct platform_device *ext_pdev;
struct msm_ext_disp_init_data ext_audio_data; struct msm_ext_disp_init_data ext_audio_data;
struct hdmi_edid_ctrl edid; struct sde_edid_ctrl *edid_ctrl;
bool non_pluggable; bool non_pluggable;
u32 num_of_modes; u32 num_of_modes;
@ -116,6 +112,38 @@ struct sde_hdmi {
struct dentry *root; struct dentry *root;
}; };
/**
* hdmi_tx_scdc_access_type() - hdmi 2.0 DDC functionalities.
*/
enum hdmi_tx_scdc_access_type {
HDMI_TX_SCDC_SCRAMBLING_STATUS,
HDMI_TX_SCDC_SCRAMBLING_ENABLE,
HDMI_TX_SCDC_TMDS_BIT_CLOCK_RATIO_UPDATE,
HDMI_TX_SCDC_CLOCK_DET_STATUS,
HDMI_TX_SCDC_CH0_LOCK_STATUS,
HDMI_TX_SCDC_CH1_LOCK_STATUS,
HDMI_TX_SCDC_CH2_LOCK_STATUS,
HDMI_TX_SCDC_CH0_ERROR_COUNT,
HDMI_TX_SCDC_CH1_ERROR_COUNT,
HDMI_TX_SCDC_CH2_ERROR_COUNT,
HDMI_TX_SCDC_READ_ENABLE,
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.
*/
enum hdmi_tx_ddc_timer_type {
HDMI_TX_DDC_TIMER_HDCP2P2_RD_MSG,
HDMI_TX_DDC_TIMER_SCRAMBLER_STATUS,
HDMI_TX_DDC_TIMER_UPDATE_FLAGS,
HDMI_TX_DDC_TIMER_STATUS_FLAGS,
HDMI_TX_DDC_TIMER_CED,
HDMI_TX_DDC_TIMER_MAX,
};
#ifdef CONFIG_DRM_SDE_HDMI #ifdef CONFIG_DRM_SDE_HDMI
/** /**
* sde_hdmi_get_num_of_displays() - returns number of display devices * sde_hdmi_get_num_of_displays() - returns number of display devices
@ -258,6 +286,52 @@ struct drm_bridge *sde_hdmi_bridge_init(struct hdmi *hdmi);
*/ */
void sde_hdmi_set_mode(struct hdmi *hdmi, bool power_on); void sde_hdmi_set_mode(struct hdmi *hdmi, bool power_on);
/**
* sde_hdmi_ddc_read() - common hdmi ddc read API.
* @hdmi: Handle to the hdmi.
* @addr: Command address.
* @offset: Command offset.
* @data: Data buffer for read back.
* @data_len: Data buffer length.
*
* Return: error code.
*/
int sde_hdmi_ddc_read(struct hdmi *hdmi, u16 addr, u8 offset,
u8 *data, u16 data_len);
/**
* sde_hdmi_ddc_write() - common hdmi ddc write API.
* @hdmi: Handle to the hdmi.
* @addr: Command address.
* @offset: Command offset.
* @data: Data buffer for write.
* @data_len: Data buffer length.
*
* Return: error code.
*/
int sde_hdmi_ddc_write(struct hdmi *hdmi, u16 addr, u8 offset,
u8 *data, u16 data_len);
/**
* sde_hdmi_scdc_read() - hdmi 2.0 ddc read API.
* @hdmi: Handle to the hdmi.
* @data_type: DDC data type, refer to enum hdmi_tx_scdc_access_type.
* @val: Read back value.
*
* Return: error code.
*/
int sde_hdmi_scdc_read(struct hdmi *hdmi, u32 data_type, u32 *val);
/**
* sde_hdmi_scdc_write() - hdmi 2.0 ddc write API.
* @hdmi: Handle to the hdmi.
* @data_type: DDC data type, refer to enum hdmi_tx_scdc_access_type.
* @val: Value write through DDC.
*
* Return: error code.
*/
int sde_hdmi_scdc_write(struct hdmi *hdmi, u32 data_type, u32 val);
/** /**
* sde_hdmi_audio_on() - enable hdmi audio. * sde_hdmi_audio_on() - enable hdmi audio.
* @hdmi: Handle to the hdmi. * @hdmi: Handle to the hdmi.
@ -305,40 +379,6 @@ void sde_hdmi_notify_clients(struct drm_connector *connector,
void sde_hdmi_ack_state(struct drm_connector *connector, void sde_hdmi_ack_state(struct drm_connector *connector,
enum drm_connector_status status); 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*/ #else /*#ifdef CONFIG_DRM_SDE_HDMI*/
static inline u32 sde_hdmi_get_num_of_displays(void) static inline u32 sde_hdmi_get_num_of_displays(void)

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

@ -28,6 +28,13 @@ struct sde_hdmi_bridge {
}; };
#define to_hdmi_bridge(x) container_of(x, struct sde_hdmi_bridge, base) #define to_hdmi_bridge(x) container_of(x, struct sde_hdmi_bridge, base)
/* TX major version that supports scrambling */
#define HDMI_TX_SCRAMBLER_MIN_TX_VERSION 0x04
#define HDMI_TX_SCRAMBLER_THRESHOLD_RATE_KHZ 340000
#define HDMI_TX_SCRAMBLER_TIMEOUT_MSEC 200
/* default hsyncs for 4k@60 for 200ms */
#define HDMI_DEFAULT_TIMEOUT_HSYNC 28571
/* for AVI program */ /* for AVI program */
#define HDMI_AVI_INFOFRAME_BUFFER_SIZE \ #define HDMI_AVI_INFOFRAME_BUFFER_SIZE \
(HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE) (HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE)
@ -101,6 +108,265 @@ static void _sde_hdmi_bridge_power_off(struct drm_bridge *bridge)
} }
} }
static int _sde_hdmi_bridge_ddc_clear_irq(struct hdmi *hdmi,
char *what)
{
u32 ddc_int_ctrl, ddc_status, in_use, timeout;
u32 sw_done_mask = BIT(2);
u32 sw_done_ack = BIT(1);
u32 in_use_by_sw = BIT(0);
u32 in_use_by_hw = BIT(1);
/* clear and enable interrutps */
ddc_int_ctrl = sw_done_mask | sw_done_ack;
hdmi_write(hdmi, REG_HDMI_DDC_INT_CTRL, ddc_int_ctrl);
/* wait until DDC HW is free */
timeout = 100;
do {
ddc_status = hdmi_read(hdmi, REG_HDMI_DDC_HW_STATUS);
in_use = ddc_status & (in_use_by_sw | in_use_by_hw);
if (in_use) {
SDE_DEBUG("ddc is in use by %s, timeout(%d)\n",
ddc_status & in_use_by_sw ? "sw" : "hw",
timeout);
udelay(100);
}
} while (in_use && --timeout);
if (!timeout) {
SDE_ERROR("%s: timedout\n", what);
return -ETIMEDOUT;
}
return 0;
}
static int _sde_hdmi_bridge_scrambler_ddc_check_status(struct hdmi *hdmi)
{
int rc = 0;
u32 reg_val;
/* check for errors and clear status */
reg_val = hdmi_read(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_STATUS);
if (reg_val & BIT(4)) {
SDE_ERROR("ddc aborted\n");
reg_val |= BIT(5);
rc = -ECONNABORTED;
}
if (reg_val & BIT(8)) {
SDE_ERROR("timed out\n");
reg_val |= BIT(9);
rc = -ETIMEDOUT;
}
if (reg_val & BIT(12)) {
SDE_ERROR("NACK0\n");
reg_val |= BIT(13);
rc = -EIO;
}
if (reg_val & BIT(14)) {
SDE_ERROR("NACK1\n");
reg_val |= BIT(15);
rc = -EIO;
}
hdmi_write(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_STATUS, reg_val);
return rc;
}
static void _sde_hdmi_bridge_scrambler_ddc_reset(struct hdmi *hdmi)
{
u32 reg_val;
/* clear ack and disable interrupts */
reg_val = BIT(14) | BIT(9) | BIT(5) | BIT(1);
hdmi_write(hdmi, REG_HDMI_DDC_INT_CTRL2, reg_val);
/* Reset DDC timers */
reg_val = BIT(0) | hdmi_read(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_CTRL);
hdmi_write(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_CTRL, reg_val);
reg_val = hdmi_read(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_CTRL);
reg_val &= ~BIT(0);
hdmi_write(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_CTRL, reg_val);
}
static void _sde_hdmi_bridge_scrambler_ddc_disable(struct hdmi *hdmi)
{
u32 reg_val;
_sde_hdmi_bridge_scrambler_ddc_reset(hdmi);
/* Disable HW DDC access to RxStatus register */
reg_val = hdmi_read(hdmi, REG_HDMI_HW_DDC_CTRL);
reg_val &= ~(BIT(8) | BIT(9));
hdmi_write(hdmi, REG_HDMI_HW_DDC_CTRL, reg_val);
}
static int _sde_hdmi_bridge_scrambler_status_timer_setup(struct hdmi *hdmi,
u32 timeout_hsync)
{
u32 reg_val;
int rc;
_sde_hdmi_bridge_ddc_clear_irq(hdmi, "scrambler");
hdmi_write(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_TIMER_CTRL,
timeout_hsync);
hdmi_write(hdmi, REG_HDMI_SCRAMBLER_STATUS_DDC_TIMER_CTRL2,
timeout_hsync);
reg_val = hdmi_read(hdmi, REG_HDMI_DDC_INT_CTRL5);
reg_val |= BIT(10);
hdmi_write(hdmi, REG_HDMI_DDC_INT_CTRL5, reg_val);
reg_val = hdmi_read(hdmi, REG_HDMI_DDC_INT_CTRL2);
/* Trigger interrupt if scrambler status is 0 or DDC failure */
reg_val |= BIT(10);
reg_val &= ~(BIT(15) | BIT(16));
reg_val |= BIT(16);
hdmi_write(hdmi, REG_HDMI_DDC_INT_CTRL2, reg_val);
/* Enable DDC access */
reg_val = hdmi_read(hdmi, REG_HDMI_HW_DDC_CTRL);
reg_val &= ~(BIT(8) | BIT(9));
reg_val |= BIT(8);
hdmi_write(hdmi, REG_HDMI_HW_DDC_CTRL, reg_val);
/* WAIT for 200ms as per HDMI 2.0 standard for sink to respond */
msleep(200);
/* clear the scrambler status */
rc = _sde_hdmi_bridge_scrambler_ddc_check_status(hdmi);
if (rc)
SDE_ERROR("scrambling ddc error %d\n", rc);
_sde_hdmi_bridge_scrambler_ddc_disable(hdmi);
return rc;
}
static int _sde_hdmi_bridge_setup_ddc_timers(struct hdmi *hdmi,
u32 type, u32 to_in_num_lines)
{
if (type >= HDMI_TX_DDC_TIMER_MAX) {
SDE_ERROR("Invalid timer type %d\n", type);
return -EINVAL;
}
switch (type) {
case HDMI_TX_DDC_TIMER_SCRAMBLER_STATUS:
_sde_hdmi_bridge_scrambler_status_timer_setup(hdmi,
to_in_num_lines);
break;
default:
SDE_ERROR("%d type not supported\n", type);
return -EINVAL;
}
return 0;
}
static inline int _sde_hdmi_bridge_get_timeout_in_hysnc(
struct drm_display_mode *mode, u32 timeout_ms)
{
/*
* pixel clock = h_total * v_total * fps
* 1 sec = pixel clock number of pixels are transmitted.
* time taken by one line (h_total) = 1s / (v_total * fps).
* lines for give time = (time_ms * 1000) / (1000000 / (v_total * fps))
* = (time_ms * clock) / h_total
*/
return (timeout_ms * mode->clock / mode->htotal);
}
static int _sde_hdmi_bridge_setup_scrambler(struct hdmi *hdmi,
struct drm_display_mode *mode)
{
int rc = 0;
int timeout_hsync;
u32 reg_val = 0;
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);
reg_val = (reg_val & 0xF0000000) >> 28;
/* Scrambling is supported from HDMI TX 4.0 */
if (reg_val < HDMI_TX_SCRAMBLER_MIN_TX_VERSION) {
DRM_INFO("scrambling not supported by tx\n");
return 0;
}
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");
if (scrambler_on) {
rc = sde_hdmi_scdc_write(hdmi,
HDMI_TX_SCDC_TMDS_BIT_CLOCK_RATIO_UPDATE,
tmds_clock_ratio);
if (rc) {
SDE_ERROR("TMDS CLK RATIO ERR\n");
return rc;
}
reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
reg_val |= BIT(31); /* Enable Update DATAPATH_MODE */
reg_val |= BIT(28); /* Set SCRAMBLER_EN bit */
hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
rc = sde_hdmi_scdc_write(hdmi,
HDMI_TX_SCDC_SCRAMBLING_ENABLE, 0x1);
if (rc) {
SDE_ERROR("failed to enable scrambling\n");
return rc;
}
/*
* Setup hardware to periodically check for scrambler
* status bit on the sink. Sink should set this bit
* with in 200ms after scrambler is enabled.
*/
timeout_hsync = _sde_hdmi_bridge_get_timeout_in_hysnc(
mode,
HDMI_TX_SCRAMBLER_TIMEOUT_MSEC);
if (timeout_hsync <= 0) {
SDE_ERROR("err in timeout hsync calc\n");
timeout_hsync = HDMI_DEFAULT_TIMEOUT_HSYNC;
}
SDE_DEBUG("timeout for scrambling en: %d hsyncs\n",
timeout_hsync);
rc = _sde_hdmi_bridge_setup_ddc_timers(hdmi,
HDMI_TX_DDC_TIMER_SCRAMBLER_STATUS, timeout_hsync);
} else {
sde_hdmi_scdc_write(hdmi, HDMI_TX_SCDC_SCRAMBLING_ENABLE, 0x0);
reg_val = hdmi_read(hdmi, REG_HDMI_CTRL);
reg_val &= ~BIT(31); /* Disable Update DATAPATH_MODE */
reg_val &= ~BIT(28); /* Unset SCRAMBLER_EN bit */
hdmi_write(hdmi, REG_HDMI_CTRL, reg_val);
}
return rc;
}
static void _sde_hdmi_bridge_pre_enable(struct drm_bridge *bridge) static void _sde_hdmi_bridge_pre_enable(struct drm_bridge *bridge)
{ {
struct sde_hdmi_bridge *sde_hdmi_bridge = to_hdmi_bridge(bridge); struct sde_hdmi_bridge *sde_hdmi_bridge = to_hdmi_bridge(bridge);
@ -373,6 +639,7 @@ static void _sde_hdmi_bridge_mode_set(struct drm_bridge *bridge,
_sde_hdmi_bridge_set_spd_infoframe(hdmi, mode); _sde_hdmi_bridge_set_spd_infoframe(hdmi, mode);
DRM_DEBUG("hdmi setup info frame\n"); DRM_DEBUG("hdmi setup info frame\n");
} }
_sde_hdmi_bridge_setup_scrambler(hdmi, mode);
} }
static const struct drm_bridge_funcs _sde_hdmi_bridge_funcs = { static const struct drm_bridge_funcs _sde_hdmi_bridge_funcs = {

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);
}
};

14
drivers/gpu/drm/msm/hdmi/hdmi.xml.h
View file

@ -563,6 +563,20 @@ static inline uint32_t HDMI_VSYNC_TOTAL_F2_V_TOTAL(uint32_t val)
#define REG_HDMI_CEC_WR_CHECK_CONFIG 0x00000370 #define REG_HDMI_CEC_WR_CHECK_CONFIG 0x00000370
#define REG_HDMI_DDC_INT_CTRL0 0x00000430
#define REG_HDMI_DDC_INT_CTRL1 0x00000434
#define REG_HDMI_DDC_INT_CTRL2 0x00000438
#define REG_HDMI_DDC_INT_CTRL3 0x0000043C
#define REG_HDMI_DDC_INT_CTRL4 0x00000440
#define REG_HDMI_DDC_INT_CTRL5 0x00000444
#define REG_HDMI_SCRAMBLER_STATUS_DDC_CTRL 0x00000464
#define REG_HDMI_SCRAMBLER_STATUS_DDC_TIMER_CTRL 0x00000468
#define REG_HDMI_SCRAMBLER_STATUS_DDC_TIMER_CTRL2 0x0000046C
#define REG_HDMI_SCRAMBLER_STATUS_DDC_STATUS 0x00000470
#define REG_HDMI_SCRAMBLER_STATUS_DDC_TIMER_STATUS 0x00000474
#define REG_HDMI_SCRAMBLER_STATUS_DDC_TIMER_STATUS2 0x00000478
#define REG_HDMI_HW_DDC_CTRL 0x000004CC
#define REG_HDMI_8x60_PHY_REG0 0x00000300 #define REG_HDMI_8x60_PHY_REG0 0x00000300
#define HDMI_8x60_PHY_REG0_DESER_DEL_CTRL__MASK 0x0000001c #define HDMI_8x60_PHY_REG0_DESER_DEL_CTRL__MASK 0x0000001c
#define HDMI_8x60_PHY_REG0_DESER_DEL_CTRL__SHIFT 2 #define HDMI_8x60_PHY_REG0_DESER_DEL_CTRL__SHIFT 2

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_ */

19
include/drm/drm_crtc.h
View file

@ -649,6 +649,15 @@ struct drm_encoder {
* @rr_capable: when set the sink is capable of initiating an SCDC read request * @rr_capable: when set the sink is capable of initiating an SCDC read request
* @supports_scramble: when set the sink supports less than 340Mcsc scrambling * @supports_scramble: when set the sink supports less than 340Mcsc scrambling
* @flags_3d: 3D view(s) supported by the sink, see drm_edid.h (DRM_EDID_3D_*) * @flags_3d: 3D view(s) supported by the sink, see drm_edid.h (DRM_EDID_3D_*)
* @pt_scan_info: PT scan info obtained from the VCDB of EDID
* @it_scan_info: IT scan info obtained from the VCDB of EDID
* @ce_scan_info: CE scan info obtained from the VCDB of EDID
* @hdr_eotf: Electro optical transfer function obtained from HDR block
* @hdr_metadata_type_one: Metadata type one obtained from HDR block
* @hdr_max_luminance: desired max luminance obtained from HDR block
* @hdr_avg_luminance: desired avg luminance obtained from HDR block
* @hdr_min_luminance: desired min luminance obtained from HDR block
* @hdr_supported: does the sink support HDR content
* @edid_corrupt: indicates whether the last read EDID was corrupt * @edid_corrupt: indicates whether the last read EDID was corrupt
* @debugfs_entry: debugfs directory for this connector * @debugfs_entry: debugfs directory for this connector
* @state: current atomic state for this connector * @state: current atomic state for this connector
@ -728,7 +737,15 @@ struct drm_connector {
bool rr_capable; bool rr_capable;
bool supports_scramble; bool supports_scramble;
int flags_3d; int flags_3d;
u8 pt_scan_info;
u8 it_scan_info;
u8 ce_scan_info;
u32 hdr_eotf;
bool hdr_metadata_type_one;
u32 hdr_max_luminance;
u32 hdr_avg_luminance;
u32 hdr_min_luminance;
bool hdr_supported;
/* Flag for raw EDID header corruption - used in Displayport /* Flag for raw EDID header corruption - used in Displayport
* compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6 * compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
*/ */

3
include/uapi/drm/drm_mode.h
View file

@ -73,7 +73,8 @@
#define DRM_MODE_FLAG_3D_TOP_AND_BOTTOM (7<<14) #define DRM_MODE_FLAG_3D_TOP_AND_BOTTOM (7<<14)
#define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF (8<<14) #define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF (8<<14)
#define DRM_MODE_FLAG_SEAMLESS (1<<19) #define DRM_MODE_FLAG_SEAMLESS (1<<19)
#define DRM_MODE_FLAG_SUPPORTS_RGB (1<<20)
#define DRM_MODE_FLAG_SUPPORTS_YUV (1<<21)
/* DPMS flags */ /* DPMS flags */
/* bit compatible with the xorg definitions. */ /* bit compatible with the xorg definitions. */