drivers/video/hdmi.c - kernel/msm-4.9 - Gitiles

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

 static void hdmi_infoframe_checksum(void *buffer, size_t size)
 {
 	u8 *ptr = buffer;
 	u8 csum = 0;
 	size_t i;

 	/* compute checksum */
 	for (i = 0; i < size; i++)
 		csum += ptr[i];

 	ptr[3] = 256 - csum;
 }

 /**
  * 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_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
  *
  * 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_spd_infoframe_pack(struct hdmi_spd_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;

 	memcpy(ptr, frame->vendor, sizeof(frame->vendor));
 	memcpy(ptr + 8, frame->product, sizeof(frame->product));

 	ptr[24] = frame->sdi;

 	hdmi_infoframe_checksum(buffer, length);

 	return length;
 }
 EXPORT_SYMBOL(hdmi_spd_infoframe_pack);

 /**
  * hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe
  * @frame: HDMI audio infoframe
  *
  * Returns 0 on success or a negative error code on failure.
  */
 int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame)
 {
 	memset(frame, 0, sizeof(*frame));

 	frame->type = HDMI_INFOFRAME_TYPE_AUDIO;
 	frame->version = 1;
 	frame->length = HDMI_AUDIO_INFOFRAME_SIZE;

 	return 0;
 }
 EXPORT_SYMBOL(hdmi_audio_infoframe_init);

 /**
  * hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer
  * @frame: HDMI audio 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_audio_infoframe_pack(struct hdmi_audio_infoframe *frame,
 				  void *buffer, size_t size)
 {
 	unsigned char channels;
 	u8 *ptr = buffer;
 	size_t length;

 	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;

 	if (size < length)
 		return -ENOSPC;

 	memset(buffer, 0, size);

 	if (frame->channels >= 2)
 		channels = frame->channels - 1;
 	else
 		channels = 0;

 	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->coding_type & 0xf) << 4) | (channels & 0x7);
 	ptr[1] = ((frame->sample_frequency & 0x7) << 2) |
 		 (frame->sample_size & 0x3);
 	ptr[2] = frame->coding_type_ext & 0x1f;
 	ptr[3] = frame->channel_allocation;
 	ptr[4] = (frame->level_shift_value & 0xf) << 3;

 	if (frame->downmix_inhibit)
 		ptr[4] |= BIT(7);

 	hdmi_infoframe_checksum(buffer, length);

 	return length;
 }
 EXPORT_SYMBOL(hdmi_audio_infoframe_pack);

 /**
  * hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe
  * @frame: HDMI vendor infoframe
  *
  * Returns 0 on success or a negative error code on failure.
  */
 int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame)
 {
 	memset(frame, 0, sizeof(*frame));

 	frame->type = HDMI_INFOFRAME_TYPE_VENDOR;
 	frame->version = 1;

 	frame->oui = HDMI_IEEE_OUI;

 	/*
 	 * 0 is a valid value for s3d_struct, so we use a special "not set"
 	 * value
 	 */
 	frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID;

 	return 0;
 }
 EXPORT_SYMBOL(hdmi_vendor_infoframe_init);

 /**
  * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer
  * @frame: HDMI 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_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame,
 				 void *buffer, size_t size)
 {
 	u8 *ptr = buffer;
 	size_t length;

 	/* empty info frame */
 	if (frame->vic == 0 && frame->s3d_struct == HDMI_3D_STRUCTURE_INVALID)
 		return -EINVAL;

 	/* only one of those can be supplied */
 	if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
 		return -EINVAL;

 	/* for side by side (half) we also need to provide 3D_Ext_Data */
 	if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
 		frame->length = 6;
 	else
 		frame->length = 5;

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

 	/* HDMI OUI */
 	ptr[4] = 0x03;
 	ptr[5] = 0x0c;
 	ptr[6] = 0x00;

 	if (frame->vic) {
 		ptr[7] = 0x1 << 5;	/* video format */
 		ptr[8] = frame->vic;
 	} else {
 		ptr[7] = 0x2 << 5;	/* video format */
 		ptr[8] = (frame->s3d_struct & 0xf) << 4;
 		if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
 			ptr[9] = (frame->s3d_ext_data & 0xf) << 4;
 	}

 	hdmi_infoframe_checksum(buffer, length);

 	return length;
 }
 EXPORT_SYMBOL(hdmi_vendor_infoframe_pack);

 /*
  * hdmi_vendor_any_infoframe_pack() - write a vendor infoframe to binary buffer
  */
 static ssize_t
 hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame,
 			   void *buffer, size_t size)
 {
 	/* we only know about HDMI vendor infoframes */
 	if (frame->any.oui != HDMI_IEEE_OUI)
 		return -EINVAL;

 	return hdmi_vendor_infoframe_pack(&frame->hdmi, buffer, size);
 }

 /**
  * hdmi_infoframe_pack() - write a HDMI infoframe to binary buffer
  * @frame: HDMI 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_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size)
 {
 	ssize_t length;

 	switch (frame->any.type) {
 	case HDMI_INFOFRAME_TYPE_AVI:
 		length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size);
 		break;
 	case HDMI_INFOFRAME_TYPE_SPD:
 		length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size);
 		break;
 	case HDMI_INFOFRAME_TYPE_AUDIO:
 		length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size);
 		break;
 	case HDMI_INFOFRAME_TYPE_VENDOR:
 		length = hdmi_vendor_any_infoframe_pack(&frame->vendor,
 							buffer, size);
 		break;
 	default:
 		WARN(1, "Bad infoframe type %d\n", frame->any.type);
 		length = -EINVAL;
 	}

 	return length;
 }
 EXPORT_SYMBOL(hdmi_infoframe_pack);
	/*
	* 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>

	static void hdmi_infoframe_checksum(void *buffer, size_t size)
	{
	u8 *ptr = buffer;
	u8 csum = 0;
	size_t i;

	/* compute checksum */
	for (i = 0; i < size; i++)
	csum += ptr[i];

	ptr[3] = 256 - csum;
	}

	/**
	* 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_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
	*
	* 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_spd_infoframe_pack(struct hdmi_spd_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;

	memcpy(ptr, frame->vendor, sizeof(frame->vendor));
	memcpy(ptr + 8, frame->product, sizeof(frame->product));

	ptr[24] = frame->sdi;

	hdmi_infoframe_checksum(buffer, length);

	return length;
	}
	EXPORT_SYMBOL(hdmi_spd_infoframe_pack);

	/**
	* hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe
	* @frame: HDMI audio infoframe
	*
	* Returns 0 on success or a negative error code on failure.
	*/
	int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame)
	{
	memset(frame, 0, sizeof(*frame));

	frame->type = HDMI_INFOFRAME_TYPE_AUDIO;
	frame->version = 1;
	frame->length = HDMI_AUDIO_INFOFRAME_SIZE;

	return 0;
	}
	EXPORT_SYMBOL(hdmi_audio_infoframe_init);

	/**
	* hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer
	* @frame: HDMI audio 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_audio_infoframe_pack(struct hdmi_audio_infoframe *frame,
	void *buffer, size_t size)
	{
	unsigned char channels;
	u8 *ptr = buffer;
	size_t length;

	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;

	if (size < length)
	return -ENOSPC;

	memset(buffer, 0, size);

	if (frame->channels >= 2)
	channels = frame->channels - 1;
	else
	channels = 0;

	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->coding_type & 0xf) << 4) \| (channels & 0x7);
	ptr[1] = ((frame->sample_frequency & 0x7) << 2) \|
	(frame->sample_size & 0x3);
	ptr[2] = frame->coding_type_ext & 0x1f;
	ptr[3] = frame->channel_allocation;
	ptr[4] = (frame->level_shift_value & 0xf) << 3;

	if (frame->downmix_inhibit)
	ptr[4] \|= BIT(7);

	hdmi_infoframe_checksum(buffer, length);

	return length;
	}
	EXPORT_SYMBOL(hdmi_audio_infoframe_pack);

	/**
	* hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe
	* @frame: HDMI vendor infoframe
	*
	* Returns 0 on success or a negative error code on failure.
	*/
	int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame)
	{
	memset(frame, 0, sizeof(*frame));

	frame->type = HDMI_INFOFRAME_TYPE_VENDOR;
	frame->version = 1;

	frame->oui = HDMI_IEEE_OUI;

	/*
	* 0 is a valid value for s3d_struct, so we use a special "not set"
	* value
	*/
	frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID;

	return 0;
	}
	EXPORT_SYMBOL(hdmi_vendor_infoframe_init);

	/**
	* hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer
	* @frame: HDMI 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_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame,
	void *buffer, size_t size)
	{
	u8 *ptr = buffer;
	size_t length;

	/* empty info frame */
	if (frame->vic == 0 && frame->s3d_struct == HDMI_3D_STRUCTURE_INVALID)
	return -EINVAL;

	/* only one of those can be supplied */
	if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
	return -EINVAL;

	/* for side by side (half) we also need to provide 3D_Ext_Data */
	if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
	frame->length = 6;
	else
	frame->length = 5;

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

	/* HDMI OUI */
	ptr[4] = 0x03;
	ptr[5] = 0x0c;
	ptr[6] = 0x00;

	if (frame->vic) {
	ptr[7] = 0x1 << 5; /* video format */
	ptr[8] = frame->vic;
	} else {
	ptr[7] = 0x2 << 5; /* video format */
	ptr[8] = (frame->s3d_struct & 0xf) << 4;
	if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
	ptr[9] = (frame->s3d_ext_data & 0xf) << 4;
	}

	hdmi_infoframe_checksum(buffer, length);

	return length;
	}
	EXPORT_SYMBOL(hdmi_vendor_infoframe_pack);

	/*
	* hdmi_vendor_any_infoframe_pack() - write a vendor infoframe to binary buffer
	*/
	static ssize_t
	hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame,
	void *buffer, size_t size)
	{
	/* we only know about HDMI vendor infoframes */
	if (frame->any.oui != HDMI_IEEE_OUI)
	return -EINVAL;

	return hdmi_vendor_infoframe_pack(&frame->hdmi, buffer, size);
	}

	/**
	* hdmi_infoframe_pack() - write a HDMI infoframe to binary buffer
	* @frame: HDMI 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_infoframe_pack(union hdmi_infoframe frame, void buffer, size_t size)
	{
	ssize_t length;

	switch (frame->any.type) {
	case HDMI_INFOFRAME_TYPE_AVI:
	length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size);
	break;
	case HDMI_INFOFRAME_TYPE_SPD:
	length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size);
	break;
	case HDMI_INFOFRAME_TYPE_AUDIO:
	length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size);
	break;
	case HDMI_INFOFRAME_TYPE_VENDOR:
	length = hdmi_vendor_any_infoframe_pack(&frame->vendor,
	buffer, size);
	break;
	default:
	WARN(1, "Bad infoframe type %d\n", frame->any.type);
	length = -EINVAL;
	}

	return length;
	}
	EXPORT_SYMBOL(hdmi_infoframe_pack);