/* * Copyright (C) 2012 Avionic Design GmbH * * 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, sub license, * 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 NON-INFRINGEMENT. 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. */ #include <linux/bitops.h> #include <linux/bug.h> #include <linux/errno.h> #include <linux/export.h> #include <linux/hdmi.h> #include <linux/string.h> #include <linux/device.h> #define hdmi_log(fmt, ...) dev_printk(level, dev, fmt, ##__VA_ARGS__) static u8 hdmi_infoframe_checksum(u8 *ptr, size_t size) { u8 csum = 0; size_t i; /* compute checksum */ for (i = 0; i < size; i++) csum += ptr[i]; return 256 - csum; } static void hdmi_infoframe_set_checksum(void *buffer, size_t size) { u8 *ptr = buffer; ptr[3] = hdmi_infoframe_checksum(buffer, size); } /** * hdmi_avi_infoframe_init() - initialize an HDMI AVI infoframe * @frame: HDMI AVI infoframe * * Returns 0 on success or a negative error code on failure. */ int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame) { memset(frame, 0, sizeof(*frame)); frame->type = HDMI_INFOFRAME_TYPE_AVI; frame->version = 2; frame->length = HDMI_AVI_INFOFRAME_SIZE; return 0; } EXPORT_SYMBOL(hdmi_avi_infoframe_init); /** * hdmi_avi_infoframe_pack() - write HDMI AVI infoframe to binary buffer * @frame: HDMI AVI infoframe * @buffer: destination buffer * @size: size of buffer * * Packs the information contained in the @frame structure into a binary * representation that can be written into the corresponding controller * registers. Also computes the checksum as required by section 5.3.5 of * the HDMI 1.4 specification. * * Returns the number of bytes packed into the binary buffer or a negative * error code on failure. */ ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, size_t size) { u8 *ptr = buffer; size_t length; length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; if (size < length) return -ENOSPC; memset(buffer, 0, size); ptr[0] = frame->type; ptr[1] = frame->version; ptr[2] = frame->length; ptr[3] = 0; /* checksum */ /* start infoframe payload */ ptr += HDMI_INFOFRAME_HEADER_SIZE; ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3); /* * Data byte 1, bit 4 has to be set if we provide the active format * aspect ratio */ if (frame->active_aspect & 0xf) ptr[0] |= BIT(4); /* Bit 3 and 2 indicate if we transmit horizontal/vertical bar data */ if (frame->top_bar || frame->bottom_bar) ptr[0] |= BIT(3); if (frame->left_bar || frame->right_bar) ptr[0] |= BIT(2); ptr[1] = ((frame->colorimetry & 0x3) << 6) | ((frame->picture_aspect & 0x3) << 4) | (frame->active_aspect & 0xf); ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) | ((frame->quantization_range & 0x3) << 2) | (frame->nups & 0x3); if (frame->itc) ptr[2] |= BIT(7); ptr[3] = frame->video_code & 0x7f; ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) | ((frame->content_type & 0x3) << 4) | (frame->pixel_repeat & 0xf); ptr[5] = frame->top_bar & 0xff; ptr[6] = (frame->top_bar >> 8) & 0xff; ptr[7] = frame->bottom_bar & 0xff; ptr[8] = (frame->bottom_bar >> 8) & 0xff; ptr[9] = frame->left_bar & 0xff; ptr[10] = (frame->left_bar >> 8) & 0xff; ptr[11] = frame->right_bar & 0xff; ptr[12] = (frame->right_bar >> 8) & 0xff; hdmi_infoframe_set_checksum(buffer, length); return length; } EXPORT_SYMBOL(hdmi_avi_infoframe_pack); /** * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe * @frame: HDMI SPD infoframe * @vendor: vendor string * @product: product string * * Returns 0 on success or a negative error code on failure. */ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, const char *vendor, const char *product) { memset(frame, 0, sizeof(*frame)); frame->type = HDMI_INFOFRAME_TYPE_SPD; frame->version = 1; frame->length = HDMI_SPD_INFOFRAME_SIZE; strncpy(frame->vendor, vendor, sizeof(frame->vendor)); strncpy(frame->product, product, sizeof(frame->product)); return 0; } EXPORT_SYMBOL(hdmi_spd_infoframe_init); /** * hdmi_spd_infoframe_pack() - write HDMI SPD infoframe to binary buffer * @frame: HDMI SPD infoframe * @buffer: destination buffer * @size: size of buffer * * Pack<style>.highlight .hll { background-color: #ffffcc } .highlight .c { color: #888888 } /* Comment */ .highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */ .highlight .k { color: #008800; font-weight: bold } /* Keyword */ .highlight .ch { color: #888888 } /* Comment.Hashbang */ .highlight .cm { color: #888888 } /* Comment.Multiline */ .highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */ .highlight .cpf { color: #888888 } /* Comment.PreprocFile */ .highlight .c1 { color: #888888 } /* Comment.Single */ .highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */ .highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */ .highlight .ge { font-style: italic } /* Generic.Emph */ .highlight .gr { color: #aa0000 } /* Generic.Error */ .highlight .gh { color: #333333 } /* Generic.Heading */ .highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */ .highlight .go { color: #888888 } /* Generic.Output */ .highlight .gp { color: #555555 } /* Generic.Prompt */ .highlight .gs { font-weight: bold } /* Generic.Strong */ .highlight .gu { color: #666666 } /* Generic.Subheading */ .highlight .gt { color: #aa0000 } /* Generic.Traceback */ .highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */ .highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */ .highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */ .highlight .kp { color: #008800 } /* Keyword.Pseudo */ .highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */ .highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="c1">##############################################################################</span> <span class="c1"># Copyright (c) 2017 Huawei Technologies Co.,Ltd and others.</span> <span class="c1">#</span> <span class="c1"># All rights reserved. This program and the accompanying materials</span> <span class="c1"># are made available under the terms of the Apache License, Version 2.0</span> <span class="c1"># which accompanies this distribution, and is available at</span> <span class="c1"># http://www.apache.org/licenses/LICENSE-2.0</span> <span class="c1">##############################################################################</span> <span class="nn">---</span> <span class="c1"># Sample benchmark task config file</span> <span class="c1"># measure storage performance using fio</span> <span class="c1"># Jinja2 Syntax is supported</span> <span class="c1"># using built-in functions ( Jinja2 for-endfor construct ) to test complex tasks</span> <span class="c1"># Test block sizes of 4KB, 8KB, 64KB, 1MB</span> <span class="c1"># Test 5 workloads: 4 corners and 1 mixed :read, write, randwrite, randread, rw</span> <span class="l l-Scalar l-Scalar-Plain">schema</span><span class="p p-Indicator">:</span> <span class="s">"yardstick:task:0.1"</span> <span class="l l-Scalar l-Scalar-Plain">scenarios</span><span class="p p-Indicator">:</span> <span class="p p-Indicator">{</span><span class="err">%</span> <span class="nv">for rw in</span> <span class="p p-Indicator">[</span><span class="s">'read'</span><span class="p p-Indicator">,</span> <span class="s">'write'</span><span class="p p-Indicator">,</span> <span class="s">'randwrite'</span><span class="p p-Indicator">,</span> <span class="s">'randread'</span><span class="p p-Indicator">,</span> <span class="s">'rw'</span><span class="p p-Indicator">]</span> <span class="err">%</span><span class="p p-Indicator">}</span> <span class="p p-Indicator">{</span><span class="err">%</span> <span class="nv">for bs in</span> <span class="p p-Indicator">[</span><span class="s">'4k'</span><span class="p p-Indicator">,</span> <span class="s">'8k'</span><span class="p p-Indicator">,</span> <span class="s">'64k'</span><span class="p p-Indicator">,</span> <span class="s">'1024k'</span><span class="p p-Indicator">]</span> <span class="err">%</span><span class="p p-Indicator">}</span> <span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">type</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Fio</span> <span class="l l-Scalar l-Scalar-Plain">options</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">filename</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">/home/ubuntu/data.raw</span> <span class="l l-Scalar l-Scalar-Plain">bs</span><span class="p p-Indicator">:</span> <span class="p p-Indicator">{{</span><span class="nv">bs</span><span class="p p-Indicator">}}</span> <span class="l l-Scalar l-Scalar-Plain">rw</span><span class="p p-Indicator">:</span> <span class="p p-Indicator">{{</span><span class="nv">rw</span><span class="p p-Indicator">}}</span> <span class="l l-Scalar l-Scalar-Plain">ramp_time</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">10</span> <span class="l l-Scalar l-Scalar-Plain">duration</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">20</span> <span class="l l-Scalar l-Scalar-Plain">host</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">fio.demo</span> <span class="l l-Scalar l-Scalar-Plain">runner</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">type</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">Iteration</span> <span class="l l-Scalar l-Scalar-Plain">iterations</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">2</span> <span class="l l-Scalar l-Scalar-Plain">interval</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">1</span> <span class="p p-Indicator">{</span><span class="err">%</span> <span class="nv">endfor %</span><span class="p p-Indicator">}</span> <span class="p p-Indicator">{</span><span class="err">%</span> <span class="nv">endfor %</span><span class="p p-Indicator">}</span> <span class="l l-Scalar l-Scalar-Plain">context</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">name</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">demo</span> <span class="l l-Scalar l-Scalar-Plain">image</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">yardstick-image</span> <span class="l l-Scalar l-Scalar-Plain">flavor</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">yardstick-flavor</span> <span class="l l-Scalar l-Scalar-Plain">user</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">ubuntu</span> <span class="l l-Scalar l-Scalar-Plain">servers</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">fio</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">floating_ip</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">true</span> <span class="l l-Scalar l-Scalar-Plain">networks</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">test</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">cidr</span><span class="p p-Indicator">:</span> <span class="s">"10.0.1.0/24"</span> </pre></div> </code></pre></td></tr></table> </div> <!-- class=content --> <div id="lfcollabprojects-footer"> <div class="gray-diagonal"> <div class="footer-inner"> <p> © 2015 <a href="https://opnfv.org/">Open Platform for NFV Project, Inc</a>., a Linux Foundation Collaborative Project. All Rights Reserved. </p> <p> Open Platform for NFV and OPNFV are trademarks of the Open Platform for NFV Project, Inc. </p> <p> Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered <a href="http://www.linuxfoundation.org/programs/legal/trademark" title="Linux Mark Institute" >trademark</a > of Linus Torvalds. </p> <p> Please see our <a href="https://opnfv.org/about/bylaws-and-policies/terms-use" >terms of use</a >, <a href="https://opnfv.org/about/bylaws-and-policies/trademarks" >trademark policy</a >, and <a href="https://opnfv.org/about/bylaws-and-policies/privacy-policy" >privacy policy</a >. </p> </div> </div> </div> </div> <!-- id=cgit --> </body> </html> ONTENT_TYPE_GAME: return "Game"; } return "Invalid"; } /** * hdmi_avi_infoframe_log() - log info of HDMI AVI infoframe * @level: logging level * @dev: device * @frame: HDMI AVI infoframe */ static void hdmi_avi_infoframe_log(const char *level, struct device *dev, struct hdmi_avi_infoframe *frame) { hdmi_infoframe_log_header(level, dev, (struct hdmi_any_infoframe *)frame); hdmi_log(" colorspace: %s\n", hdmi_colorspace_get_name(frame->colorspace)); hdmi_log(" scan mode: %s\n", hdmi_scan_mode_get_name(frame->scan_mode)); hdmi_log(" colorimetry: %s\n", hdmi_colorimetry_get_name(frame->colorimetry)); hdmi_log(" picture aspect: %s\n", hdmi_picture_aspect_get_name(frame->picture_aspect)); hdmi_log(" active aspect: %s\n", hdmi_active_aspect_get_name(frame->active_aspect)); hdmi_log(" itc: %s\n", frame->itc ? "IT Content" : "No Data"); hdmi_log(" extended colorimetry: %s\n", hdmi_extended_colorimetry_get_name(frame->extended_colorimetry)); hdmi_log(" quantization range: %s\n", hdmi_quantization_range_get_name(frame->quantization_range)); hdmi_log(" nups: %s\n", hdmi_nups_get_name(frame->nups)); hdmi_log(" video code: %u\n", frame->video_code); hdmi_log(" ycc quantization range: %s\n", hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range)); hdmi_log(" hdmi content type: %s\n", hdmi_content_type_get_name(frame->content_type)); hdmi_log(" pixel repeat: %u\n", frame->pixel_repeat); hdmi_log(" bar top %u, bottom %u, left %u, right %u\n", frame->top_bar, frame->bottom_bar, frame->left_bar, frame->right_bar); } static const char *hdmi_spd_sdi_get_name(enum hdmi_spd_sdi sdi) { if (sdi < 0 || sdi > 0xff) return "Invalid"; switch (sdi) { case HDMI_SPD_SDI_UNKNOWN: return "Unknown"; case HDMI_SPD_SDI_DSTB: return "Digital STB"; case HDMI_SPD_SDI_DVDP: return "DVD Player"; case HDMI_SPD_SDI_DVHS: return "D-VHS"; case HDMI_SPD_SDI_HDDVR: return "HDD Videorecorder"; case HDMI_SPD_SDI_DVC: return "DVC"; case HDMI_SPD_SDI_DSC: return "DSC"; case HDMI_SPD_SDI_VCD: return "Video CD"; case HDMI_SPD_SDI_GAME: return "Game"; case HDMI_SPD_SDI_PC: return "PC General"; case HDMI_SPD_SDI_BD: return "Blu-Ray Disc (BD)"; case HDMI_SPD_SDI_SACD: return "Super Audio CD"; case HDMI_SPD_SDI_HDDVD: return "HD DVD"; case HDMI_SPD_SDI_PMP: return "PMP"; } return "Reserved"; } /** * hdmi_spd_infoframe_log() - log info of HDMI SPD infoframe * @level: logging level * @dev: device * @frame: HDMI SPD infoframe */ static void hdmi_spd_infoframe_log(const char *level, struct device *dev, struct hdmi_spd_infoframe *frame) { u8 buf[17]; hdmi_infoframe_log_header(level, dev, (struct hdmi_any_infoframe *)frame); memset(buf, 0, sizeof(buf)); strncpy(buf, frame->vendor, 8); hdmi_log(" vendor: %s\n", buf); strncpy(buf, frame->product, 16); hdmi_log(" product: %s\n", buf); hdmi_log(" source device information: %s (0x%x)\n", hdmi_spd_sdi_get_name(frame->sdi), frame->sdi); } static const char * hdmi_audio_coding_type_get_name(enum hdmi_audio_coding_type coding_type) { switch (coding_type) { case HDMI_AUDIO_CODING_TYPE_STREAM: return "Refer to Stream Header"; case HDMI_AUDIO_CODING_TYPE_PCM: return "PCM"; case HDMI_AUDIO_CODING_TYPE_AC3: return "AC-3"; case HDMI_AUDIO_CODING_TYPE_MPEG1: return "MPEG1"; case HDMI_AUDIO_CODING_TYPE_MP3: return "MP3"; case HDMI_AUDIO_CODING_TYPE_MPEG2: return "MPEG2"; case HDMI_AUDIO_CODING_TYPE_AAC_LC: return "AAC"; case HDMI_AUDIO_CODING_TYPE_DTS: return "DTS"; case HDMI_AUDIO_CODING_TYPE_ATRAC: return "ATRAC"; case HDMI_AUDIO_CODING_TYPE_DSD: return "One Bit Audio"; case HDMI_AUDIO_CODING_TYPE_EAC3: return "Dolby Digital +"; case HDMI_AUDIO_CODING_TYPE_DTS_HD: return "DTS-HD"; case HDMI_AUDIO_CODING_TYPE_MLP: return "MAT (MLP)"; case HDMI_AUDIO_CODING_TYPE_DST: return "DST"; case HDMI_AUDIO_CODING_TYPE_WMA_PRO: return "WMA PRO"; case HDMI_AUDIO_CODING_TYPE_CXT: return "Refer to CXT"; } return "Invalid"; } static const char * hdmi_audio_sample_size_get_name(enum hdmi_audio_sample_size sample_size) { switch (sample_size) { case HDMI_AUDIO_SAMPLE_SIZE_STREAM: return "Refer to Stream Header"; case HDMI_AUDIO_SAMPLE_SIZE_16: return "16 bit"; case HDMI_AUDIO_SAMPLE_SIZE_20: return "20 bit"; case HDMI_AUDIO_SAMPLE_SIZE_24: return "24 bit"; } return "Invalid"; } static const char * hdmi_audio_sample_frequency_get_name(enum hdmi_audio_sample_frequency freq) { switch (freq) { case HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM: return "Refer to Stream Header"; case HDMI_AUDIO_SAMPLE_FREQUENCY_32000: return "32 kHz"; case HDMI_AUDIO_SAMPLE_FREQUENCY_44100: return "44.1 kHz (CD)"; case HDMI_AUDIO_SAMPLE_FREQUENCY_48000: return "48 kHz"; case HDMI_AUDIO_SAMPLE_FREQUENCY_88200: return "88.2 kHz"; case HDMI_AUDIO_SAMPLE_FREQUENCY_96000: return "96 kHz"; case HDMI_AUDIO_SAMPLE_FREQUENCY_176400: return "176.4 kHz"; case HDMI_AUDIO_SAMPLE_FREQUENCY_192000: return "192 kHz"; } return "Invalid"; } static const char * hdmi_audio_coding_type_ext_get_name(enum hdmi_audio_coding_type_ext ctx) { if (ctx < 0 || ctx > 0x1f) return "Invalid"; switch (ctx) { case HDMI_AUDIO_CODING_TYPE_EXT_CT: return "Refer to CT"; case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC: return "HE AAC"; case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2: return "HE AAC v2"; case HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND: return "MPEG SURROUND"; case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC: return "MPEG-4 HE AAC"; case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2: return "MPEG-4 HE AAC v2"; case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC: return "MPEG-4 AAC LC"; case HDMI_AUDIO_CODING_TYPE_EXT_DRA: return "DRA"; case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND: return "MPEG-4 HE AAC + MPEG Surround"; case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND: return "MPEG-4 AAC LC + MPEG Surround"; } return "Reserved"; } /** * hdmi_audio_infoframe_log() - log info of HDMI AUDIO infoframe * @level: logging level * @dev: device * @frame: HDMI AUDIO infoframe */ static void hdmi_audio_infoframe_log(const char *level, struct device *dev, struct hdmi_audio_infoframe *frame) { hdmi_infoframe_log_header(level, dev, (struct hdmi_any_infoframe *)frame); if (frame->channels) hdmi_log(" channels: %u\n", frame->channels - 1); else hdmi_log(" channels: Refer to stream header\n"); hdmi_log(" coding type: %s\n", hdmi_audio_coding_type_get_name(frame->coding_type)); hdmi_log(" sample size: %s\n", hdmi_audio_sample_size_get_name(frame->sample_size)); hdmi_log(" sample frequency: %s\n", hdmi_audio_sample_frequency_get_name(frame->sample_frequency)); hdmi_log(" coding type ext: %s\n", hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext)); hdmi_log(" channel allocation: 0x%x\n", frame->channel_allocation); hdmi_log(" level shift value: %u dB\n", frame->level_shift_value); hdmi_log(" downmix inhibit: %s\n", frame->downmix_inhibit ? "Yes" : "No"); } static const char * hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct) { if (s3d_struct < 0 || s3d_struct > 0xf) return "Invalid"; switch (s3d_struct) { case HDMI_3D_STRUCTURE_FRAME_PACKING: return "Frame Packing"; case HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE: return "Field Alternative"; case HDMI_3D_STRUCTURE_LINE_ALTERNATIVE: return "Line Alternative"; case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL: return "Side-by-side (Full)"; case HDMI_3D_STRUCTURE_L_DEPTH: return "L + Depth"; case HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH: return "L + Depth + Graphics + Graphics-depth"; case HDMI_3D_STRUCTURE_TOP_AND_BOTTOM: return "Top-and-Bottom"; case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF: return "Side-by-side (Half)"; default: break; } return "Reserved"; } /** * hdmi_vendor_infoframe_log() - log info of HDMI VENDOR infoframe * @level: logging level * @dev: device * @frame: HDMI VENDOR infoframe */ static void hdmi_vendor_any_infoframe_log(const char *level, struct device *dev, union hdmi_vendor_any_infoframe *frame) { struct hdmi_vendor_infoframe *hvf = &frame->hdmi; hdmi_infoframe_log_header(level, dev, (struct hdmi_any_infoframe *)frame); if (frame->any.oui != HDMI_IEEE_OUI) { hdmi_log(" not a HDMI vendor infoframe\n"); return; } if (hvf->vic == 0 && hvf->s3d_struct == HDMI_3D_STRUCTURE_INVALID) { hdmi_log(" empty frame\n"); return; } if (hvf->vic) hdmi_log(" HDMI VIC: %u\n", hvf->vic); if (hvf->s3d_struct != HDMI_3D_STRUCTURE_INVALID) { hdmi_log(" 3D structure: %s\n", hdmi_3d_structure_get_name(hvf->s3d_struct)); if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) hdmi_log(" 3D extension data: %d\n", hvf->s3d_ext_data); } } /** * hdmi_infoframe_log() - log info of HDMI infoframe * @level: logging level * @dev: device * @frame: HDMI infoframe */ void hdmi_infoframe_log(const char *level, struct device *dev, union hdmi_infoframe *frame) { switch (frame->any.type) { case HDMI_INFOFRAME_TYPE_AVI: hdmi_avi_infoframe_log(level, dev, &frame->avi); break; case HDMI_INFOFRAME_TYPE_SPD: hdmi_spd_infoframe_log(level, dev, &frame->spd); break; case HDMI_INFOFRAME_TYPE_AUDIO: hdmi_audio_infoframe_log(level, dev, &frame->audio); break; case HDMI_INFOFRAME_TYPE_VENDOR: hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor); break; } } EXPORT_SYMBOL(hdmi_infoframe_log); /** * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe * @buffer: source buffer * @frame: HDMI AVI infoframe * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Auxiliary Video (AVI) information frame. * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 * specification. * * Returns 0 on success or a negative error code on failure. */ static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame, void *buffer) { u8 *ptr = buffer; int ret; if (ptr[0] != HDMI_INFOFRAME_TYPE_AVI || ptr[1] != 2 || ptr[2] != HDMI_AVI_INFOFRAME_SIZE) return -EINVAL; if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AVI)) != 0) return -EINVAL; ret = hdmi_avi_infoframe_init(frame); if (ret) return ret; ptr += HDMI_INFOFRAME_HEADER_SIZE; frame->colorspace = (ptr[0] >> 5) & 0x3; if (ptr[0] & 0x10) frame->active_aspect = ptr[1] & 0xf; if (ptr[0] & 0x8) { frame->top_bar = (ptr[5] << 8) + ptr[6]; frame->bottom_bar = (ptr[7] << 8) + ptr[8]; } if (ptr[0] & 0x4) { frame->left_bar = (ptr[9] << 8) + ptr[10]; frame->right_bar = (ptr[11] << 8) + ptr[12]; } frame->scan_mode = ptr[0] & 0x3; frame->colorimetry = (ptr[1] >> 6) & 0x3; frame->picture_aspect = (ptr[1] >> 4) & 0x3; frame->active_aspect = ptr[1] & 0xf; frame->itc = ptr[2] & 0x80 ? true : false; frame->extended_colorimetry = (ptr[2] >> 4) & 0x7; frame->quantization_range = (ptr[2] >> 2) & 0x3; frame->nups = ptr[2] & 0x3; frame->video_code = ptr[3] & 0x7f; frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3; frame->content_type = (ptr[4] >> 4) & 0x3; frame->pixel_repeat = ptr[4] & 0xf; return 0; } /** * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe * @buffer: source buffer * @frame: HDMI SPD infoframe * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Source Product Description (SPD) information frame. * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 * specification. * * Returns 0 on success or a negative error code on failure. */ static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame, void *buffer) { u8 *ptr = buffer; int ret; if (ptr[0] != HDMI_INFOFRAME_TYPE_SPD || ptr[1] != 1 || ptr[2] != HDMI_SPD_INFOFRAME_SIZE) { return -EINVAL; } if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(SPD)) != 0) return -EINVAL; ptr += HDMI_INFOFRAME_HEADER_SIZE; ret = hdmi_spd_infoframe_init(frame, ptr, ptr + 8); if (ret) return ret; frame->sdi = ptr[24]; return 0; } /** * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe * @buffer: source buffer * @frame: HDMI Audio infoframe * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Audio information frame. * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 * specification. * * Returns 0 on success or a negative error code on failure. */ static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame, void *buffer) { u8 *ptr = buffer; int ret; if (ptr[0] != HDMI_INFOFRAME_TYPE_AUDIO || ptr[1] != 1 || ptr[2] != HDMI_AUDIO_INFOFRAME_SIZE) { return -EINVAL; } if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AUDIO)) != 0) return -EINVAL; ret = hdmi_audio_infoframe_init(frame); if (ret) return ret; ptr += HDMI_INFOFRAME_HEADER_SIZE; frame->channels = ptr[0] & 0x7; frame->coding_type = (ptr[0] >> 4) & 0xf; frame->sample_size = ptr[1] & 0x3; frame->sample_frequency = (ptr[1] >> 2) & 0x7; frame->coding_type_ext = ptr[2] & 0x1f; frame->channel_allocation = ptr[3]; frame->level_shift_value = (ptr[4] >> 3) & 0xf; frame->downmix_inhibit = ptr[4] & 0x80 ? true : false; return 0; } /** * hdmi_vendor_infoframe_unpack() - unpack binary buffer to a HDMI vendor infoframe * @buffer: source buffer * @frame: HDMI Vendor infoframe * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Vendor information frame. * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 * specification. * * Returns 0 on success or a negative error code on failure. */ static int hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, void *buffer) { u8 *ptr = buffer; size_t length; int ret; u8 hdmi_video_format; struct hdmi_vendor_infoframe *hvf = &frame->hdmi; if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR || ptr[1] != 1 || (ptr[2] != 5 && ptr[2] != 6)) return -EINVAL; length = ptr[2]; if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_HEADER_SIZE + length) != 0) return -EINVAL; ptr += HDMI_INFOFRAME_HEADER_SIZE; /* HDMI OUI */ if ((ptr[0] != 0x03) || (ptr[1] != 0x0c) || (ptr[2] != 0x00)) return -EINVAL; hdmi_video_format = ptr[3] >> 5; if (hdmi_video_format > 0x2) return -EINVAL; ret = hdmi_vendor_infoframe_init(hvf); if (ret) return ret; hvf->length = length; if (hdmi_video_format == 0x1) { hvf->vic = ptr[4]; } else if (hdmi_video_format == 0x2) { hvf->s3d_struct = ptr[4] >> 4; if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) { if (length == 6) hvf->s3d_ext_data = ptr[5] >> 4; else return -EINVAL; } } return 0; } /** * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe * @buffer: source buffer * @frame: HDMI infoframe * * Unpacks the information contained in binary buffer @buffer into a structured * @frame of a HDMI infoframe. * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 * specification. * * Returns 0 on success or a negative error code on failure. */ int hdmi_infoframe_unpack(union hdmi_infoframe *frame, void *buffer) { int ret; u8 *ptr = buffer; switch (ptr[0]) { case HDMI_INFOFRAME_TYPE_AVI: ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer); break; case HDMI_INFOFRAME_TYPE_SPD: ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer); break; case HDMI_INFOFRAME_TYPE_AUDIO: ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer); break; case HDMI_INFOFRAME_TYPE_VENDOR: ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer); break; default: ret = -EINVAL; break; } return ret; } EXPORT_SYMBOL(hdmi_infoframe_unpack);