diff options
Diffstat (limited to 'drivers/staging/cdv/drv/psb_intel_hdmi.h')
| -rw-r--r-- | drivers/staging/cdv/drv/psb_intel_hdmi.h | 935 |
1 files changed, 935 insertions, 0 deletions
diff --git a/drivers/staging/cdv/drv/psb_intel_hdmi.h b/drivers/staging/cdv/drv/psb_intel_hdmi.h new file mode 100644 index 000000000000..175b706a8773 --- /dev/null +++ b/drivers/staging/cdv/drv/psb_intel_hdmi.h @@ -0,0 +1,935 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chunfeng Zhao <chunfeng.zhao@intel.com> + * Jim Liu <jim.liu@intel.com> + */ + +#ifndef __PSB_INTEL_HDMI_H__ +#define __PSB_INTEL_HDMI_H__ + +/* + * HDMI Parameters + */ + +/* GUID HDMI Parameters */ +#if 0 +//#ifdef DEFINE_GUID +//#undef DEFINE_GUID +#define DEFINE_GUID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) const GUID n GUID_SECT = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}} +//#endif /* DEFINE_GUID */ + +#define HDMI_PARAMETERS_GUID "{6FD3BE0E-80F9-4206-86B7-3714FA439634}" +DEFINE_GUID(GUID_HDMI_PARAMETERS, 0x6fd3be0e, 0x80f9, 0x4206, 0x86, 0xb7, 0x37, 0x14, 0xfa, 0x43, 0x96, 0x34); + +#define AVI_INFOFRAME_GUID "{DFCB113B-E54F-49A2-B5E3-78D0C6B4F4CB}" +DEFINE_GUID(GUID_AVI_INFOFRAME, 0xdfcb113b, 0xe54f, 0x49a2, 0xb5, 0xe3, 0x78, 0xd0, 0xc6, 0xb4, 0xf4, 0xcb); +#endif + +#define HDMI_DEVICE_NAME "ABC_VEND" +#define HDMI_DEVICE_DESC "XZ05 PC VIDEO" + +#define HDMI_MAX_PIXEL_REPETITION 0x04 // On Cantiga only upto 4X pixel repetition is supported +#define HDMI_HBR_AUDIO_SAMPLE_RATE 192000 // 192kHz is the sample rate corresponding to the HBR audio formats +#define HDMI_AUDIO_CLOCK_PACKET_RATE 1500 // Audio clock packet rate of 1.5kHz has to be considered while calculating audio BW + +#define HDMI_BAR_INFO_LENGTH 8 // 8 bytes of barinfo + +#define HDMI_MONITOR_NAME_LENGTH 20 + +// BaseLineDataLength. +// Total size is in multiple of 4 bytes. i.e, 80/4 = 20 +#define HDMI_EELD_BASELINE_DATA_LENGTH 0x14 + +// Header = 4, Baseline Data = 80 and Vendor (INTEL) specific = 2 as per EELD spec +// 4 + 80 + = 84 +#define HDMI_EELD_SIZE 84 + +// +// HDMI command types +// +typedef enum +{ + HDMI_COMMAND_GET, + HDMI_COMMAND_SET +} hdmi_command_t; + +#define HDMI_AVI_FLAG_ITCONTENT 0x00800000 +#define HDMI_AVI_FLAG_RGB_QUANT_RANGE 0x00040000 +#define HDMI_AVI_FLAG_SCAN_INFO 0x00000001 +#define HDMI_AVI_FLAG_BAR_INFO 0x00000010 +// +// CEA-861b definitions +// +#define HDMI_CEA_VERSION 0x00 +#define HDMI_ELD_VERSION 0x01 +#define HDMI_EELD_VERSION 0x02 +#define HDMI_BASE_ELD_SIZE 0x0E +#define HDMI_CEA_EDID_HEADER_SIZE 0x04 +#define HDMI_EELD_CEA_EDID_VERSION 0x03 +#define HDMI_CEA_EDID_BLOCK_SIZE 128 + +// +//Basic Audio support definitions +// + +#define HDMI_BASIC_AUDIO_SUPPORTED 0x40 +#define HDMI_CEA_EXTENSION_BLOCK_BYTE_3 3 +#define HDMI_FL_AND_FR_SPEAKERS_CONNECTED 0x1 + +// +// HDMI buffer/information types +// +typedef enum { + // Non-standard or non-HDMI type + HDMI_ELD_TYPE = 0x00, // ELD buffer type + HDMI_EELD_TYPE = 0x01, // EELD buffer type + + // Per HDMI Spec, refer Table 2-1 in HDMI EDS + // or Table 5-8 in HDMI spec + HDMI_VS_TYPE = 0x81, // Vendor-Specific InfoFrame type + HDMI_AVI_TYPE = 0x82, // AVI InfoFrame type + HDMI_SPD_TYPE = 0x83, // SPD InfoFrame type + HDMI_AUDIO_TYPE = 0x84, // Audio InfoFrame type + HDMI_MS_TYPE = 0x85, // MPEG Source InfoFrame type + + // Non-standard or non-HDMI types + HDMI_PR_PE_TYPE = 0x86, // Pixel Replication & Pixel Encoding(colorimetry) type + HDMI_AUDIO_CAPS_TYPE = 0x87, // Encoder Audio Capabilities type + HDMI_AUDIO_ENABLE_FLAGS_TYPE = 0x88 // Flags for enabling / disabling audio +} hdmi_info_type_t; + +// +// InfoFrame Version Information +// +typedef enum { + HDMI_VS_VERSION = 1, // Vendor-Specific InfoFrame Version 1 + HDMI_AVI_VERSION = 1, // AVI InfoFrame Version 1 + HDMI_AVI_VERSION2 = 2, // AVI InfoFrame Version 2 + HDMI_SPD_VERSION = 1, // SPD InfoFrame Version 1 + HDMI_AUDIO_VERSION = 1, // Audio InfoFrame Version 1 + HDMI_MS_VERSION = 1 // MPEG Source InfoFrame Version 1 +} infoframe_version_t; + +// +// InfoFrame Payload Length in bytes +// +typedef enum { + HDMI_VS_MAX_LENGTH = 27, // Vendor-Specific InfoFrame Payload Length, including IEEE reg ID + HDMI_AVI_LENGTH = 13, // AVI InfoFrame Payload Length + HDMI_SPD_LENGTH = 25, // SPD InfoFrame Payload Length + HDMI_AUDIO_LENGTH = 10, // Audio InfoFrame Payload Length + HDMI_MS_LENGTH = 10, // MPEG Source InfoFrame Payload Length + HDMI_PR_PE_LENGTH = 4, // Length of PR_PE_TYPE + HDMI_AUDIO_CAPS_LENGTH = 4 // Length of AUDIO_CAPS_TYPE +} infoframe_length_t; + +// +// InfoFrame TOTAL Length in bytes (includes header + payload) +// +typedef enum { + HDMI_VS_MAX_TOTAL_LENGTH = HDMI_VS_MAX_LENGTH + 4, // Max Total size of Vendor-Specific InfoFrame + HDMI_AVI_TOTAL_LENGTH = HDMI_AVI_LENGTH + 4, // Total size of AVI InfoFrame + HDMI_SPD_TOTAL_LENGTH = HDMI_SPD_LENGTH + 4, // Total size of SPD InfoFrame + HDMI_AUDIO_TOTAL_LENGTH = HDMI_AUDIO_LENGTH + 4, // Total size of Audio InfoFrame + HDMI_MS_TOTAL_LENGTH = HDMI_MS_LENGTH + 4, // Total size of MPEG Source InfoFrame +} infoframe_total_length_t; + + +// +// Pixel Replication multipliers +// +typedef enum { + HDMI_PR_ONE = 0, // No repetition (ie., pixel sent once) + HDMI_PR_TWO, // Pixel sent 2 times (ie.,repeated once) + HDMI_PR_THREE, // Pixel sent 3 times + HDMI_PR_FOUR, // Pixel sent 4 times + HDMI_PR_FIVE, // Pixel sent 5 times + HDMI_PR_SIX, // Pixel sent 6 times + HDMI_PR_SEVEN, // Pixel sent 7 times + HDMI_PR_EIGHT, // Pixel sent 8 times + HDMI_PR_NINE, // Pixel sent 9 times + HDMI_PR_TEN // Pixel sent 10 times +} hdmi_pixel_replication_t; + +// +// Pixel encoding modes +// +//typedef typedef enum { + // HDMI_RGB256 = 0x01, + // HDMI_RGB220 = 0x02, + // HDMI_YCrCb422 = 0x04, + // HDMI_YCrCb444 = 0x08 +//}HDMI_COLORIMETRY; + +// +// Pixel encoding modes +// +typedef enum { + HDMI_COLORIMETRY_RGB256 = 0x01, + HDMI_COLORIMETRY_RGB220 = 0x02, + HDMI_COLORIMETRY_YCrCb422 = 0x04, + HDMI_COLORIMETRY_YCrCb444 = 0x08 +} hdmi_colorimetry_t; + +// +// AVI InfoFrame definitions - start +// +// Scan Info +typedef enum { + HDMI_AVI_SCAN_NODATA = 0, // No data + HDMI_AVI_SCAN_OVERSCAN = 1, // Overscanned (TV) + HDMI_AVI_SCAN_UNDERSCAN = 2, // Underscanned (Computer) + HDMI_AVI_SCAN_FUTURE = 3 // Future +} avi_scan_info_t; + +// Bar Info +typedef enum { + HDMI_AVI_BAR_INVALID = 0, // Bar data not valid + HDMI_AVI_BAR_VALID_VERTICAL = 1, // Vertical Bar data valid + HDMI_AVI_BAR_VALID_HORIZONTAL= 2, // Horizontal Bar data valid + HDMI_AVI_BAR_VALID_BOTH = 3 // Vertical & Horizontal Bar data valid +} avi_bar_info_t; + +// Active Format Information +typedef enum { + HDMI_AVI_AFI_INVALID = 0, // No data + HDMI_AVI_AFI_VALID = 1 // Active Format Information valid +} avi_fi_info_t; + +// AVI Pixel Encoding modes +typedef enum { + HDMI_AVI_RGB_MODE = 0, // RGB pixel encoding mode + HDMI_AVI_YCRCB422_MODE = 1, // YCrCb 4:2:2 mode + HDMI_AVI_YCRCB444_MODE = 2, // YCrCb 4:4:4 mode + HDMI_AVI_FUTURE_MODE = 3 // Future mode +} avi_encoding_mode_t; + +// AVI Active Format Aspect Ratio +typedef enum { + HDMI_AVI_AFAR_SAME = 8, // same as picture aspect ratio + HDMI_AVI_AFAR_4_3 = 9, // 4:3 center + HDMI_AVI_AFAR_16_9 = 10, // 16:9 center + HDMI_AVI_AFAR_14_9 = 11 // 14:9 center +} avi_afar_info_t; + +// AVI Picture Aspect Ratio +typedef enum { + HDMI_AVI_PAR_NODATA = 0, // No Data + HDMI_AVI_PAR_4_3 = 1, // 4:3 + HDMI_AVI_PAR_16_9 = 2, // 16:9 + HDMI_AVI_PAR_FUTURE = 3 // Future +} avi_par_info_t; + +// AVI Colorimetry Information +typedef enum { + HDMI_AVI_COLOR_NODATA = 0, // No data + HDMI_AVI_COLOR_ITU601 = 1, // SMPTE 170M, ITU601 + HDMI_AVI_COLOR_ITU709 = 2, // ITU709 + HDMI_AVI_COLOR_FUTURE = 3 // Future +} avi_color_info_t; + +// AVI Non-uniform Picture Scaling Info +typedef enum { + HDMI_AVI_SCALING_NODATA = 0, // No scaling + HDMI_AVI_SCALING_HORIZONTAL = 1, // horizontal scaling + HDMI_AVI_SCALING_VERTICAL = 2, // vertical scaling + HDMI_AVI_SCALING_BOTH = 3 // horizontal & vertical scaling +} avi_scaling_infp_t; + +// AVI RGB Quantization Range +typedef enum { + HDMI_AVI_RGBQUANT_DEFAULT = 0, // Default value + HDMI_AVI_RGBQUANT_LIMITED = 1, // Limited Range + HDMI_AVI_RGBQUANT_FULL = 2, // Full Range + HDMI_AVI_RGBQUANT_FUTURE = 3 // Future use +} avi_rgbquant_range_t; + +// AVI IT Content +typedef enum { + HDMI_AVI_ITC_NODATA = 0, // No Data + HDMI_AVI_ITC_ITCONTENT = 1 //IT Content +} avi_it_content_t; + +// +// AVI InfoFrame definitions - end +// + +// +// SPD InfoFrame definitions - start +// +// SPD InfoFrame Data Byte 25, refer Table-17 in CEA-861b +typedef enum { + HDMI_SPD_SRC_UNKNOWN = 0x00, // unknown + HDMI_SPD_SRC_DIGITAL_STB = 0x01, // Digital STB + HDMI_SPD_SRC_DVD = 0x02, // DVD + HDMI_SPD_SRC_DVHS = 0x03, // D-VHS + HDMI_SPD_SRC_HDD_VIDEO = 0x04, // HDD Video + HDMI_SPD_SRC_DVC = 0x05, // DVC + HDMI_SPD_SRC_DSC = 0x06, // DSC + HDMI_SPD_SRC_VCD = 0x07, // Video CD + HDMI_SPD_SRC_GAME = 0x08, // Game + HDMI_SPD_SRC_PC = 0x09 // PC General +} spd_src_type_t; + +// SPD InfoFrame Vendor Name & Descriptor Length in bytes +typedef enum { + HDMI_SPD_VNAME_LENGTH = 8, // SPD Vendor Name Length in bytes + HDMI_SPD_VDESC_LENGTH = 16, // SPD Vendor Descriptor Length in bytes +} spd_namedesc_length_info_t; + +// +// SPD InfoFrame definitions - end +// + +// +// InfoFrame Packet Header - generic +// +typedef struct _if_header { + uint8_t type; // InfoFrame Type + uint8_t version; // InfoFrame Version + uint8_t length; // InfoFrame Length + uint8_t chksum; // Checksum of the InfoFrame +} if_header_t; + +// +// AVI InfoFrame structure +// +typedef union _avi_if { + uint8_t avi_buf[HDMI_AVI_TOTAL_LENGTH]; + #pragma pack(1) + struct + { + if_header_t avi_if_header; // AVI header data + union + { + uint8_t byte1; + struct + { + uint8_t scan_info:2; // scan information + uint8_t bar_info :2; // bar information + uint8_t format :1; // active format information + uint8_t enc_mode :2; // pixel encoding (RGB or YCrCb) + uint8_t b1rsvd :1; // reserved + }; + }; + union + { + uint8_t byte2; + struct + { + uint8_t afar :4; // Active Format Aspect Ratio + uint8_t par :2; // Picture Aspect Ratio + uint8_t colorimetry :2; // colorimetry + }; + }; + union + { + uint8_t byte3; + struct + { + uint8_t scaling_info :2; // Scaling information + uint8_t rgbquant_range :2; // RGB Quantization Range + uint8_t ext_colorimetry :3; //Extended Colorimetry + uint8_t it_content :1; //IT Content + }; + }; + union + { + uint8_t byte4; + struct + { + uint8_t vic :7; // Video Identification code (refer Table 13 in CEA-861b) + uint8_t b4rsvd :1; // reserved + }; + }; + union + { + uint8_t byte5; + struct + { + uint8_t pr :4; // pixel repetition (refer Table 15 in CEA-861b) + uint8_t b5rsvd :4; // reserved + }; + }; + uint8_t byte6; // end of top bar(lower), set to "00" + uint8_t byte7; // end of top bar(upper), set to "00" + uint8_t byte8; // start of bottom bar(lower), set to "00" + uint8_t byte9; // start of bottom bar(upper), set to "00" + uint8_t byte10; // end of left bar(lower), set to "00" + uint8_t byte11; // end of left bar(upper), set to "00" + uint8_t byte12; // start of right bar(lower), set to "00" + uint8_t byte13; // start of right bar(upper), set to "00" + }; + #pragma pack() +} avi_if_t; + +// +// SPD InfoFrame structure +// +typedef union _spd_if { + uint8_t spd_buf[HDMI_SPD_TOTAL_LENGTH]; + #pragma pack(1) + struct + { + if_header_t spd_if_header; // SPD header data + uint8_t name[8]; // Vendor Name, 8 characters + uint8_t desc[16]; // Product Description, 16 characters + uint8_t sdi; // Source Device Information + }; + #pragma pack() +} spd_if_t; + +// +// Vendor Specific InfoFrame structure +// +typedef union _vs_if +{ + uint8_t vs_buf[HDMI_VS_MAX_TOTAL_LENGTH]; + #pragma pack(1) + struct + { + if_header_t vs_if_header; // VS header data + uint8_t ieee_reg_id[3]; // 3-byte IEEE registration ID + uint8_t pay_load[24]; // Payload bytes + }; + #pragma pack() +} vs_if_t; + +// +// AVI Infoframe structure for customization +// + +typedef struct _avi_infoframe_custom { + //GUID guid; // GUID + int32_t command; // Command + int32_t flags; // Flags + uint32_t type_code; // Type code of AVI Infoframe + uint32_t version; // Version of AVI Infoframe + uint32_t length; // Length of AVI Info Frame + uint8_t r3r0_valid; // Reserved + uint8_t it_content; // IT Content + uint8_t bar_info[8]; // Reserved + int32_t active_format_aspect_ratio;// Reserved + int32_t non_uniform_scaling; // Reserved + int32_t rgb_ycc_indicator; // Reserved + int32_t ext_colorimetry; // Reserved + int32_t pixel_factor; // Reserved + int32_t bar_info_valid; // Reserved + int32_t colorimetry; // Reserved + int32_t aspect_ratio; // Reserved + int32_t quant_range; // Quantization Range + int32_t video_code; // Reserved + int32_t scan_info; // Scan Information +} avi_infoframe_custom_t; + + +// +// LinearPCM Consolidated Audio Data(CAD) structure +// +typedef union _lpcm_cad { + uint8_t value; + struct { + uint8_t maxch_cp_on :3; // Max channels-1 supported with CP turned ON + uint8_t maxch_cp_off :3; // Max channels-1 supported with CP turned OFF + uint8_t sp_20bit :1; // 20-bit sample support + uint8_t sp_24bit :1; // 24-bit sample support + }; +} lpcm_cad_t; + +// +// CEA Short Audio Descriptor +// +typedef struct _cea_861b_adb { +#pragma pack(1) + union + { + uint8_t byte1; + struct + { + uint8_t max_channels :3; // Bits[0-2] + uint8_t audio_format_code :4; // Bits[3-6], see AUDIO_FORMAT_CODES + uint8_t b1reserved :1; // Bit[7] - reserved + }; + }; + union + { + uint8_t byte2; + struct + { + uint8_t sp_rate_32kHz :1; // Bit[0] sample rate = 32kHz + uint8_t sp_rate_44kHz :1; // Bit[1] sample rate = 44kHz + uint8_t sp_rate_48kHz :1; // Bit[2] sample rate = 48kHz + uint8_t sp_rate_88kHz :1; // Bit[3] sample rate = 88kHz + uint8_t sp_rate_96kHz :1; // Bit[4] sample rate = 96kHz + uint8_t sp_rate_176kHz :1; // Bit[5] sample rate = 176kHz + uint8_t sp_rate_192kHz :1; // Bit[6] sample rate = 192kHz + uint8_t sp_rate_b2reserved :1; // Bit[7] - reserved + }; + }; + union + { + uint8_t byte3; // maximum bit rate divided by 8kHz + // following is the format of 3rd byte for uncompressed(LPCM) audio + struct + { + uint8_t bit_rate_16bit :1; // Bit[0] + uint8_t bit_rate_20bit :1; // Bit[1] + uint8_t bit_rate_24bit :1; // Bit[2] + uint8_t bit_rate_b3reserved :5; // Bits[3-7] + }; + }; +#pragma pack() +}cea_861b_adb_t; + +// +// Enhanced EDID Like Data aka EELD structure +// +typedef union _hdmi_eeld { + uint8_t eeld[HDMI_EELD_SIZE]; + #pragma pack(1) + struct + { + // Byte[0] = ELD Version Number + union + { + uint8_t byte0; + struct + { + uint8_t reserved:3; // Reserf + uint8_t eld_ver:5; // ELD Version Number + // 00000b - reserved + // 00001b - first rev + // 00010b:11111b - reserved for future + }; + }; + + // Byte[1] = Vendor Version Field + union + { + uint8_t vendor_version; + struct + { + uint8_t reserved1:3; + uint8_t veld_ver:5; // Version number of the ELD extension. + // This value is provisioned and unique to each vendor. + }; + }; + + // Byte[2] = Baseline Lenght field + uint8_t baseline_eld_length; // Length of the Baseline structure divided by Four. + + // Byte [3] = Reserved for future use + uint8_t byte3; + + // Starting of the BaseLine EELD structure + // Byte[4] = Monitor Name Length + union + { + uint8_t byte4; + struct + { + uint8_t mnl:5; + uint8_t cea_edid_rev_id:3; + }; + }; + + // Byte[5] = Capabilities + union + { + uint8_t capabilities; + struct + { + uint8_t hdcp:1; // Indicates HDCP support + uint8_t ai_support:1; // Inidcates AI support + uint8_t connection_type:2; // Indicates Connection type + // 00 - HDMI + // 01 - DP + // 10 -11 Reserved for future connection types + uint8_t sadc:4; // Indicates number of 3 bytes Short Audio Descriptors. + }; + }; + + // Byte[6] = Audio Synch Delay + uint8_t audio_synch_delay; // Amount of time reported by the sink that the video trails audio in milliseconds. + + // Byte[7] = Speaker Allocation Block + union + { + uint8_t speaker_allocation_block; + struct + { + uint8_t flr:1; // Front Left and Right channels + uint8_t lfe:1; // Low Frequency Effect channel + uint8_t fc:1; // Center transmission channel + uint8_t rlr:1; // Rear Left and Right channels + uint8_t rc:1; // Rear Center channel + uint8_t flrc:1; // Front left and Right of Center transmission channels + uint8_t rlrc:1; // Rear left and Right of Center transmission channels + uint8_t reserved3:1; // Reserved + }; + }; + + // Byte[8 - 15] - 8 Byte port identification value + uint8_t port_id_value[8]; + + // Byte[16 - 17] - 2 Byte Manufacturer ID + uint8_t manufacturer_id[2]; + + // Byte[18 - 19] - 2 Byte Product ID + uint8_t product_id[2]; + + // Byte [20-83] - 64 Bytes of BaseLine Data + uint8_t mn_sand_sads[64]; // This will include + // - ASCII string of Monitor name + // - List of 3 byte SADs + // - Zero padding + + // Vendor ELD Block should continue here! + // No Vendor ELD block defined as of now. + }; + #pragma pack() +} hdmi_eeld_t; + +// +// Data structure for misc HDMI data +// +typedef struct _misc_hdmi_data { + int32_t colorimetry :4; // + int32_t pr :4; // pixel repetition value + int32_t reserved :24;// reserved bits +} misc_hdmi_data_t; + +// +// Audio capability structure +// +typedef struct _device_audio_caps { + int32_t npl_design :8; // max number of audio packets device can + // deliver per line + int32_t k0 :8; // The overhead(in pixels) per line requied + // by device for setting up audio packets when + // CP is disabled + int32_t k1 :8; // The overhead(in pixels) per line requied + // by device for setting up audio packets when + // CP is enabled + // Misc data + int32_t pr :4; // Pixel Replication value + int32_t is_hdcp :1; // Driver, Device and Receiver support HDCP + int32_t is_rptr :1; // Receiver is HDCP repeater + int32_t reserved :2; // reserved bits +} device_audio_caps_t; + +typedef struct _audio_enable_flags { + int32_t is_hdmi_display :1; //1 if HDMI display, 0 if not HDMI display + int32_t is_eld_valid :1; //1 if ELD valid, 0 if ELD not valid + int32_t reserved1 :30; +} audio_enable_flags_t; + +// +// Data structure to exchange HDMI data through GetSetParameters interface +// +typedef struct _hdmi_parameters { + //GUID Guid; + hdmi_command_t command; + uint8_t type; + uint8_t size; + union { + hdmi_eeld_t eeld_buffer; + avi_if_t avi_infoframe; + spd_if_t spd_infoframe; + vs_if_t vs_infoframe; + union { + int32_t gen_data; + device_audio_caps_t audio_caps; + misc_hdmi_data_t misc_data; + audio_enable_flags_t fl_audio_enable_flags; + }; + }; +} hdmi_parameters_t; + +// +// Audio format codes +// +typedef enum { + AUDIO_LPCM = 0x0001, // Linear PCM (eg. IEC60958) + AUDIO_AC3 = 0x0002, // AC-3 + AUDIO_MPEG1 = 0x0003, // MPEG1 (Layers 1 & 2) + AUDIO_MP3 = 0x0004, // MP3 (MPEG1 Layer 3) + AUDIO_MPEG2 = 0x0005, // MPEG2 (multichannel) + AUDIO_AAC = 0x0006, // AAC + AUDIO_DTS = 0x0007, // DTS + AUDIO_ATRAC = 0x0008, // ATRAC + AUDIO_OBA = 0x0009, // One Bit Audio + AUDIO_DOLBY_DIGITAL = 0x000A, // Dolby Digital + AUDIO_DTS_HD = 0x000B, // DTS-HD + AUDIO_MAT = 0x000C, // MAT (MLP) + AUDIO_DST = 0x000D, // DST + AUDIO_WMA_PRO = 0x000E // WMA Pro +} audio_format_codes_t; + +// +// Data structure for byte #6 to 8 which has fixed definition +// +typedef struct _vsdb_char6_to_char8 +{ + #pragma pack(1) + + union + { + uint8_t byte1; + struct + { + uint8_t dvi_dual :1; // Bit[0] + uint8_t b1reserved :2; // Bits[1-2] + uint8_t dcy444 :1; // Bit[3] YCBCR 4:4:4 in Deep Color modes. + uint8_t dc30bit :1; //Bit[4] + uint8_t dc36bit :1; //Bit[5] + uint8_t dc48bit :1; //Bit[6] + uint8_t supports_ai :1; // Bit[7] + }; + }; + + uint8_t max_tmds_clock; + + union + { + uint8_t byte3; + struct + { + uint8_t b3reserved :6; // Bit[0-5] reserved + uint8_t i_latency_field_present :1;// Bit[6] + uint8_t latency_field_present :1;// Bits[7] + }; + }; + + #pragma pack() +} vsdb_byte6_to_byte8_t; + + +// +// Gamut metadata structure +// +// Note : The data is written in big endian format +#if 0 +// GUID for calling GBD interface +// {EEE24BDF-6D30-40bf-9BA2-139F0FFFC797} +#define DXVA_HDMI13_GBD_P0_GUID "{EEE24BDF-6D30-40BF-9BA2-139F0FFFC797}" +DEFINE_GUID(GUID_DXVA_HDMI13_GBD_P0, 0xeee24bdf, 0x6d30, 0x40bf, 0x9b, 0xa2, 0x13, 0x9f, 0xf, 0xff, 0xc7, 0x97); +#endif + +#define HDMI_GBD_PKT_TYPE 0x0A +#define HDMI_GBD_P0_DATA_SIZE 27 +#define HDMI_MAX_VERTICES_DATA 25 +#define HDMI_MAX_FACET_DATA 25 + +typedef enum { + VERTICES_AND_FACETS = 0, + RGB_MIN_MAX_RANGE = 1 +} gbd_format_flag_t; + +typedef enum { + GBD_8BIT_PRECISION = 0, + GBD_10BIT_PRECISION = 1, + GBD_12BIT_PRECISION = 2 +} gbd_color_precision_t; + +typedef enum { + RGB_BT709 = 0, + XVY_CC601 = 1, + XVY_CC709 = 2, + RESERVED_COLORSPACE +} gbd_color_space_t; + +typedef enum { + MIN_RED_INDEX = 0, + MAX_RED_INDEX = 1, + MIN_GREEN_INDEX = 2, + MAX_GREEN_INDEX = 3, + MIN_BLUE_INDEX = 4, + MAX_BLUE_INDEX = 5, + MAX_RANGE_DATA_INDEX_LIMIT = 6 +} gbd_rgb_range_data_index_t; + +// +// App needs to feel the data in this structure +// +typedef struct _gbd_p0_hdmi_1_3 { + uint8_t enable; // Enable/Disable GBD profile sending + gbd_format_flag_t format_flag; // uses GBD_FORMAT_FLAG_EN, this defines the gamut data format + gbd_color_precision_t color_precision; // uses GBD_COLOR_PRECISION, this is the bit precision of GBD vertex and range data + gbd_color_space_t color_space; // uses GBD_COLOR_SPACE_EN, this defines the color space being represented + + union + { + // If bFormatFlag is 0 + struct { + uint8_t facet_mode; // spec supports 0 alone right now + uint16_t num_vertices; // Number of vertices + uint16_t num_facets; // Number of faces + + // For 4 vertices of 12bits size is 18 + // Max possible with 0 facets and 28 bytes of GBD is 28-5=23 bytes + uint16_t vertices_data[HDMI_MAX_VERTICES_DATA]; // Vertices data representation + uint16_t facets_data[HDMI_MAX_FACET_DATA]; // kept it as input data but to be defined based on future spec + } vertices_facets_data; + + + // If eFormatFlag is 1 + struct { + uint16_t rgb_primary_data[MAX_RANGE_DATA_INDEX_LIMIT]; + } rgb_range_data; + }; + +} gbd_p0_hdmi_1_3_t; + +#define HDMI_GBD_MAX_SEQ_NUM_INDEX 16 + +// various GBD profiles +typedef enum { + P0_PROFILE = 0, + P1_PROFILE = 1, + P2_PROFILE = 2, + P3_PROFILE = 3, + INVALID_PROFILE +} gbd_profile_type_t; + +// various packet transmission options +typedef enum { + INTERMEDIATE_PKT_IN_SEQ = 0, + FIRST_PKT_IN_SEQ = 1, + LAST_PKT_IN_SEQ = 2, + ONLY_PKT_IN_SEQ = 3 +} gbd_pkt_seq_t; + +// +// Packet header defn as per HDMI spec +// +typedef struct _gamut_pkt_header { + uint8_t pkt_type; // Defines the pkt type + union{ + uint8_t field_byte; + struct{ + uint8_t affected_gamut_info :4; // BIT 3:0 + uint8_t gbd_profile :3; // BIT 6:4 ; uses GBD_PROFILE_TYPE_EN + uint8_t next_field :1; // BIT7 + }; + }; + + union{ + uint8_t gbd_seq_info; + struct{ + uint8_t current_gamut_info :4; // BIT 3:0 + uint8_t packet_seq :2; // BIT 5:4 ; use GBD_PKT_SEQ_EN + uint8_t reserved2 :1; // BIT 6 + uint8_t no_current_gbd :1; // BIT 7 + }; + }; +} gamut_pkt_header_t; + +// +// Gamut structure contains data in following format +// +typedef struct _gamut_metadata_struct { + #pragma pack(1) + gamut_pkt_header_t pkt_hdr; // Gamut Metadata header data + union + { + uint8_t byte1; + struct + { + uint8_t gbd_color_space :3; + // Note: GBD buffer is formatted based upon the color precision + // 8 bit precision : 1 sign bit, 2 bits of integer, 5 bits of fraction + // 10 bit precision : 1 sign bit, 2 bits of integer, 7 bits of fraction + // 12 bit precision : 1 sign bit, 2 bits of integer, 9 bits of fraction + uint8_t gbd_color_precision :2; + uint8_t reserved3 :1; + uint8_t facet_mode :1; // 0 - No facet info in GBD; 1 - Facet info in GBD + uint8_t format_flag :1; // uses GBD_FORMAT_FLAG_EN + }; + }; + + // For P0 profile below is the syntax in which data will be filled + // If Format is YUV + // char 2 : Higher 8 bits of number of vertices + // char 3 : Lower 8 bits of number of vertices + // char 4 to VSIZE+2 : Vertex data of size VSIZE, + // where VSIZE = 3*number of vertices*GBD color precision/8 + 0.99999 + // char VSIZE+3: Higher 8 bits of number of facets + // char VSIZE+4: Lower 8 bits of number of facets + // char VSIZE+5 to VSIZE+FSIZE+4 : Facet data + // where VSIZE = number of facet data + uint8_t gbd_data[HDMI_GBD_P0_DATA_SIZE]; // data will be filled + + #pragma pack() +} gamut_metadata_st_t; + +struct mid_intel_hdmi_priv { + u32 hdmi_reg; + u32 save_HDMIB; + bool has_hdmi_sink; + bool has_hdmi_audio; + /* Should set this when detect hotplug */ + bool hdmi_device_connected; + struct mdfld_hdmi_i2c *i2c_bus; + /* EELD packet holder*/ + hdmi_eeld_t eeld; + u32 hdmi_eeld_size; + cea_861b_adb_t lpcm_sad; + bool is_hdcp_supported; + struct i2c_adapter *hdmi_i2c_adapter; /* for control functions */ + struct drm_device *dev; +}; + +struct hdmi_edid_info { + char monitor_name[HDMI_MONITOR_NAME_LENGTH]; + char *edid_info; +}; + +#define HDMI_EDID_INFO(nm, info) \ + .monitor_name = nm, .edid_info = info + +#define MSIC_IRQLVL1_STATUS 0x02 + #define VREG_STATUS (1 << 5) +#define MSIC_VRINT_STATUS 0x0d + #define HDMI_HPD_STATUS (1 << 3) + #define HDMI_OCP_STATUS (1 << 2) + #define VR_OCP_STATUS (1 << 1) + #define VR_OVP_STATUS (1 << 0) +#define MSIC_VRINT_MASK 0x1c + #define HDMI_HPD_MASK (1 << 3) + #define HDMI_OCP_MASK (1 << 2) + #define VR_OCP_MASK (1 << 1) + #define VR_OVP_MASK (1 << 0) +#define MSIC_IRQLVL1_MASK 0x21 + #define VREG_MASK (1 << 5) +#define MSIC_VCC330CNT 0xd3 + #define VCC330_OFF 0x24 + #define VCC330_ON 0x37 +#define MSIC_VHDMICNT 0xde + #define VHDMI_OFF 0x25 + #define VHDMI_ON 0xa5 +#define MSIC_HDMI_STATUS 0x281 + #define HPD_SIGNAL_STATUS (1 << 0) + +#endif //__IHDMI_H__ |