tree a4d990862b2bec34a30736366213b8dcea6a8164
parent 48d1d28eec5cd7ebb8bb30009078feb438172cf2
author Chandan Uddaraju <chandanu@codeaurora.org> 1548716333 -0800
committer Sean Paul <seanpaul@chromium.org> 1549385200 -0500

drm: add definitions for DP Audio/Video compliance tests

This change adds definitions needed for DP audio compliance testing.
It also adds missing definition for DP video compliance.

Changes in V2:
-- Delete cover letter for this patch.
-- Move the description from cover letter into patch commit message.
-- Remove DPU from subject prefix

Reviewed-by: Sean Paul <sean@poorly.run>
Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch> # for merging through -msm.
Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
Signed-off-by: Sean Paul <seanpaul@chromium.org>

