0,0 → 1,436 |
/* |
* 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); |