hdmi.c

   1/*
   2 * Copyright (C) 2012 Avionic Design GmbH
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sub license,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the
  12 * next paragraph) shall be included in all copies or substantial portions
  13 * of the Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21 * DEALINGS IN THE SOFTWARE.
  22 */
  23
  24#include <drm/display/drm_dp.h>
  25#include <linux/bitops.h>
  26#include <linux/bug.h>
  27#include <linux/errno.h>
  28#include <linux/export.h>
  29#include <linux/hdmi.h>
  30#include <linux/string.h>
  31#include <linux/device.h>
  32
  33#define hdmi_log(fmt, ...) dev_printk(level, dev, fmt, ##__VA_ARGS__)
  34
  35static u8 hdmi_infoframe_checksum(const u8 *ptr, size_t size)
  36{
  37	u8 csum = 0;
  38	size_t i;
  39
  40	/* compute checksum */
  41	for (i = 0; i < size; i++)
  42		csum += ptr[i];
  43
  44	return 256 - csum;
  45}
  46
  47static void hdmi_infoframe_set_checksum(void *buffer, size_t size)
  48{
  49	u8 *ptr = buffer;
  50
  51	ptr[3] = hdmi_infoframe_checksum(buffer, size);
  52}
  53
  54/**
  55 * hdmi_avi_infoframe_init() - initialize an HDMI AVI infoframe
  56 * @frame: HDMI AVI infoframe
  57 */
  58void hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame)
  59{
  60	memset(frame, 0, sizeof(*frame));
  61
  62	frame->type = HDMI_INFOFRAME_TYPE_AVI;
  63	frame->version = 2;
  64	frame->length = HDMI_AVI_INFOFRAME_SIZE;
  65}
  66EXPORT_SYMBOL(hdmi_avi_infoframe_init);
  67
  68static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe *frame)
  69{
  70	if (frame->type != HDMI_INFOFRAME_TYPE_AVI ||
  71	    frame->version != 2 ||
  72	    frame->length != HDMI_AVI_INFOFRAME_SIZE)
  73		return -EINVAL;
  74
  75	if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9)
  76		return -EINVAL;
  77
  78	return 0;
  79}
  80
  81/**
  82 * hdmi_avi_infoframe_check() - check a HDMI AVI infoframe
  83 * @frame: HDMI AVI infoframe
  84 *
  85 * Validates that the infoframe is consistent and updates derived fields
  86 * (eg. length) based on other fields.
  87 *
  88 * Returns 0 on success or a negative error code on failure.
  89 */
  90int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame)
  91{
  92	return hdmi_avi_infoframe_check_only(frame);
  93}
  94EXPORT_SYMBOL(hdmi_avi_infoframe_check);
  95
  96/**
  97 * hdmi_avi_infoframe_pack_only() - write HDMI AVI infoframe to binary buffer
  98 * @frame: HDMI AVI infoframe
  99 * @buffer: destination buffer
 100 * @size: size of buffer
 101 *
 102 * Packs the information contained in the @frame structure into a binary
 103 * representation that can be written into the corresponding controller
 104 * registers. Also computes the checksum as required by section 5.3.5 of
 105 * the HDMI 1.4 specification.
 106 *
 107 * Returns the number of bytes packed into the binary buffer or a negative
 108 * error code on failure.
 109 */
 110ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame,
 111				     void *buffer, size_t size)
 112{
 113	u8 *ptr = buffer;
 114	size_t length;
 115	int ret;
 116
 117	ret = hdmi_avi_infoframe_check_only(frame);
 118	if (ret)
 119		return ret;
 120
 121	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
 122
 123	if (size < length)
 124		return -ENOSPC;
 125
 126	memset(buffer, 0, size);
 127
 128	ptr[0] = frame->type;
 129	ptr[1] = frame->version;
 130	ptr[2] = frame->length;
 131	ptr[3] = 0; /* checksum */
 132
 133	/* start infoframe payload */
 134	ptr += HDMI_INFOFRAME_HEADER_SIZE;
 135
 136	ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3);
 137
 138	/*
 139	 * Data byte 1, bit 4 has to be set if we provide the active format
 140	 * aspect ratio
 141	 */
 142	if (frame->active_aspect & 0xf)
 143		ptr[0] |= BIT(4);
 144
 145	/* Bit 3 and 2 indicate if we transmit horizontal/vertical bar data */
 146	if (frame->top_bar || frame->bottom_bar)
 147		ptr[0] |= BIT(3);
 148
 149	if (frame->left_bar || frame->right_bar)
 150		ptr[0] |= BIT(2);
 151
 152	ptr[1] = ((frame->colorimetry & 0x3) << 6) |
 153		 ((frame->picture_aspect & 0x3) << 4) |
 154		 (frame->active_aspect & 0xf);
 155
 156	ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) |
 157		 ((frame->quantization_range & 0x3) << 2) |
 158		 (frame->nups & 0x3);
 159
 160	if (frame->itc)
 161		ptr[2] |= BIT(7);
 162
 163	ptr[3] = frame->video_code & 0x7f;
 164
 165	ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) |
 166		 ((frame->content_type & 0x3) << 4) |
 167		 (frame->pixel_repeat & 0xf);
 168
 169	ptr[5] = frame->top_bar & 0xff;
 170	ptr[6] = (frame->top_bar >> 8) & 0xff;
 171	ptr[7] = frame->bottom_bar & 0xff;
 172	ptr[8] = (frame->bottom_bar >> 8) & 0xff;
 173	ptr[9] = frame->left_bar & 0xff;
 174	ptr[10] = (frame->left_bar >> 8) & 0xff;
 175	ptr[11] = frame->right_bar & 0xff;
 176	ptr[12] = (frame->right_bar >> 8) & 0xff;
 177
 178	hdmi_infoframe_set_checksum(buffer, length);
 179
 180	return length;
 181}
 182EXPORT_SYMBOL(hdmi_avi_infoframe_pack_only);
 183
 184/**
 185 * hdmi_avi_infoframe_pack() - check a HDMI AVI infoframe,
 186 *                             and write it to binary buffer
 187 * @frame: HDMI AVI infoframe
 188 * @buffer: destination buffer
 189 * @size: size of buffer
 190 *
 191 * Validates that the infoframe is consistent and updates derived fields
 192 * (eg. length) based on other fields, after which it packs the information
 193 * contained in the @frame structure into a binary representation that
 194 * can be written into the corresponding controller registers. This function
 195 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 196 * specification.
 197 *
 198 * Returns the number of bytes packed into the binary buffer or a negative
 199 * error code on failure.
 200 */
 201ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame,
 202				void *buffer, size_t size)
 203{
 204	int ret;
 205
 206	ret = hdmi_avi_infoframe_check(frame);
 207	if (ret)
 208		return ret;
 209
 210	return hdmi_avi_infoframe_pack_only(frame, buffer, size);
 211}
 212EXPORT_SYMBOL(hdmi_avi_infoframe_pack);
 213
 214/**
 215 * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe
 216 * @frame: HDMI SPD infoframe
 217 * @vendor: vendor string
 218 * @product: product string
 219 *
 220 * Returns 0 on success or a negative error code on failure.
 221 */
 222int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame,
 223			    const char *vendor, const char *product)
 224{
 225	size_t len;
 226
 227	memset(frame, 0, sizeof(*frame));
 228
 229	frame->type = HDMI_INFOFRAME_TYPE_SPD;
 230	frame->version = 1;
 231	frame->length = HDMI_SPD_INFOFRAME_SIZE;
 232
 233	len = strlen(vendor);
 234	memcpy(frame->vendor, vendor, min(len, sizeof(frame->vendor)));
 235	len = strlen(product);
 236	memcpy(frame->product, product, min(len, sizeof(frame->product)));
 237
 238	return 0;
 239}
 240EXPORT_SYMBOL(hdmi_spd_infoframe_init);
 241
 242static int hdmi_spd_infoframe_check_only(const struct hdmi_spd_infoframe *frame)
 243{
 244	if (frame->type != HDMI_INFOFRAME_TYPE_SPD ||
 245	    frame->version != 1 ||
 246	    frame->length != HDMI_SPD_INFOFRAME_SIZE)
 247		return -EINVAL;
 248
 249	return 0;
 250}
 251
 252/**
 253 * hdmi_spd_infoframe_check() - check a HDMI SPD infoframe
 254 * @frame: HDMI SPD infoframe
 255 *
 256 * Validates that the infoframe is consistent and updates derived fields
 257 * (eg. length) based on other fields.
 258 *
 259 * Returns 0 on success or a negative error code on failure.
 260 */
 261int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame)
 262{
 263	return hdmi_spd_infoframe_check_only(frame);
 264}
 265EXPORT_SYMBOL(hdmi_spd_infoframe_check);
 266
 267/**
 268 * hdmi_spd_infoframe_pack_only() - write HDMI SPD infoframe to binary buffer
 269 * @frame: HDMI SPD infoframe
 270 * @buffer: destination buffer
 271 * @size: size of buffer
 272 *
 273 * Packs the information contained in the @frame structure into a binary
 274 * representation that can be written into the corresponding controller
 275 * registers. Also computes the checksum as required by section 5.3.5 of
 276 * the HDMI 1.4 specification.
 277 *
 278 * Returns the number of bytes packed into the binary buffer or a negative
 279 * error code on failure.
 280 */
 281ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame,
 282				     void *buffer, size_t size)
 283{
 284	u8 *ptr = buffer;
 285	size_t length;
 286	int ret;
 287
 288	ret = hdmi_spd_infoframe_check_only(frame);
 289	if (ret)
 290		return ret;
 291
 292	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
 293
 294	if (size < length)
 295		return -ENOSPC;
 296
 297	memset(buffer, 0, size);
 298
 299	ptr[0] = frame->type;
 300	ptr[1] = frame->version;
 301	ptr[2] = frame->length;
 302	ptr[3] = 0; /* checksum */
 303
 304	/* start infoframe payload */
 305	ptr += HDMI_INFOFRAME_HEADER_SIZE;
 306
 307	memcpy(ptr, frame->vendor, sizeof(frame->vendor));
 308	memcpy(ptr + 8, frame->product, sizeof(frame->product));
 309
 310	ptr[24] = frame->sdi;
 311
 312	hdmi_infoframe_set_checksum(buffer, length);
 313
 314	return length;
 315}
 316EXPORT_SYMBOL(hdmi_spd_infoframe_pack_only);
 317
 318/**
 319 * hdmi_spd_infoframe_pack() - check a HDMI SPD infoframe,
 320 *                             and write it to binary buffer
 321 * @frame: HDMI SPD infoframe
 322 * @buffer: destination buffer
 323 * @size: size of buffer
 324 *
 325 * Validates that the infoframe is consistent and updates derived fields
 326 * (eg. length) based on other fields, after which it packs the information
 327 * contained in the @frame structure into a binary representation that
 328 * can be written into the corresponding controller registers. This function
 329 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 330 * specification.
 331 *
 332 * Returns the number of bytes packed into the binary buffer or a negative
 333 * error code on failure.
 334 */
 335ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame,
 336				void *buffer, size_t size)
 337{
 338	int ret;
 339
 340	ret = hdmi_spd_infoframe_check(frame);
 341	if (ret)
 342		return ret;
 343
 344	return hdmi_spd_infoframe_pack_only(frame, buffer, size);
 345}
 346EXPORT_SYMBOL(hdmi_spd_infoframe_pack);
 347
 348/**
 349 * hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe
 350 * @frame: HDMI audio infoframe
 351 *
 352 * Returns 0 on success or a negative error code on failure.
 353 */
 354int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame)
 355{
 356	memset(frame, 0, sizeof(*frame));
 357
 358	frame->type = HDMI_INFOFRAME_TYPE_AUDIO;
 359	frame->version = 1;
 360	frame->length = HDMI_AUDIO_INFOFRAME_SIZE;
 361
 362	return 0;
 363}
 364EXPORT_SYMBOL(hdmi_audio_infoframe_init);
 365
 366static int hdmi_audio_infoframe_check_only(const struct hdmi_audio_infoframe *frame)
 367{
 368	if (frame->type != HDMI_INFOFRAME_TYPE_AUDIO ||
 369	    frame->version != 1 ||
 370	    frame->length != HDMI_AUDIO_INFOFRAME_SIZE)
 371		return -EINVAL;
 372
 373	return 0;
 374}
 375
 376/**
 377 * hdmi_audio_infoframe_check() - check a HDMI audio infoframe
 378 * @frame: HDMI audio infoframe
 379 *
 380 * Validates that the infoframe is consistent and updates derived fields
 381 * (eg. length) based on other fields.
 382 *
 383 * Returns 0 on success or a negative error code on failure.
 384 */
 385int hdmi_audio_infoframe_check(const struct hdmi_audio_infoframe *frame)
 386{
 387	return hdmi_audio_infoframe_check_only(frame);
 388}
 389EXPORT_SYMBOL(hdmi_audio_infoframe_check);
 390
 391static void
 392hdmi_audio_infoframe_pack_payload(const struct hdmi_audio_infoframe *frame,
 393				  u8 *buffer)
 394{
 395	u8 channels;
 396
 397	if (frame->channels >= 2)
 398		channels = frame->channels - 1;
 399	else
 400		channels = 0;
 401
 402	buffer[0] = ((frame->coding_type & 0xf) << 4) | (channels & 0x7);
 403	buffer[1] = ((frame->sample_frequency & 0x7) << 2) |
 404		 (frame->sample_size & 0x3);
 405	buffer[2] = frame->coding_type_ext & 0x1f;
 406	buffer[3] = frame->channel_allocation;
 407	buffer[4] = (frame->level_shift_value & 0xf) << 3;
 408
 409	if (frame->downmix_inhibit)
 410		buffer[4] |= BIT(7);
 411}
 412
 413/**
 414 * hdmi_audio_infoframe_pack_only() - write HDMI audio infoframe to binary buffer
 415 * @frame: HDMI audio infoframe
 416 * @buffer: destination buffer
 417 * @size: size of buffer
 418 *
 419 * Packs the information contained in the @frame structure into a binary
 420 * representation that can be written into the corresponding controller
 421 * registers. Also computes the checksum as required by section 5.3.5 of
 422 * the HDMI 1.4 specification.
 423 *
 424 * Returns the number of bytes packed into the binary buffer or a negative
 425 * error code on failure.
 426 */
 427ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame,
 428				       void *buffer, size_t size)
 429{
 430	u8 *ptr = buffer;
 431	size_t length;
 432	int ret;
 433
 434	ret = hdmi_audio_infoframe_check_only(frame);
 435	if (ret)
 436		return ret;
 437
 438	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
 439
 440	if (size < length)
 441		return -ENOSPC;
 442
 443	memset(buffer, 0, size);
 444
 445	ptr[0] = frame->type;
 446	ptr[1] = frame->version;
 447	ptr[2] = frame->length;
 448	ptr[3] = 0; /* checksum */
 449
 450	hdmi_audio_infoframe_pack_payload(frame,
 451					  ptr + HDMI_INFOFRAME_HEADER_SIZE);
 452
 453	hdmi_infoframe_set_checksum(buffer, length);
 454
 455	return length;
 456}
 457EXPORT_SYMBOL(hdmi_audio_infoframe_pack_only);
 458
 459/**
 460 * hdmi_audio_infoframe_pack() - check a HDMI Audio infoframe,
 461 *                               and write it to binary buffer
 462 * @frame: HDMI Audio infoframe
 463 * @buffer: destination buffer
 464 * @size: size of buffer
 465 *
 466 * Validates that the infoframe is consistent and updates derived fields
 467 * (eg. length) based on other fields, after which it packs the information
 468 * contained in the @frame structure into a binary representation that
 469 * can be written into the corresponding controller registers. This function
 470 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 471 * specification.
 472 *
 473 * Returns the number of bytes packed into the binary buffer or a negative
 474 * error code on failure.
 475 */
 476ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame,
 477				  void *buffer, size_t size)
 478{
 479	int ret;
 480
 481	ret = hdmi_audio_infoframe_check(frame);
 482	if (ret)
 483		return ret;
 484
 485	return hdmi_audio_infoframe_pack_only(frame, buffer, size);
 486}
 487EXPORT_SYMBOL(hdmi_audio_infoframe_pack);
 488
 489/**
 490 * hdmi_audio_infoframe_pack_for_dp - Pack a HDMI Audio infoframe for DisplayPort
 491 *
 492 * @frame:      HDMI Audio infoframe
 493 * @sdp:        Secondary data packet for DisplayPort.
 494 * @dp_version: DisplayPort version to be encoded in the header
 495 *
 496 * Packs a HDMI Audio Infoframe to be sent over DisplayPort. This function
 497 * fills the secondary data packet to be used for DisplayPort.
 498 *
 499 * Return: Number of total written bytes or a negative errno on failure.
 500 */
 501ssize_t
 502hdmi_audio_infoframe_pack_for_dp(const struct hdmi_audio_infoframe *frame,
 503				 struct dp_sdp *sdp, u8 dp_version)
 504{
 505	int ret;
 506
 507	ret = hdmi_audio_infoframe_check(frame);
 508	if (ret)
 509		return ret;
 510
 511	memset(sdp->db, 0, sizeof(sdp->db));
 512
 513	/* Secondary-data packet header */
 514	sdp->sdp_header.HB0 = 0;
 515	sdp->sdp_header.HB1 = frame->type;
 516	sdp->sdp_header.HB2 = DP_SDP_AUDIO_INFOFRAME_HB2;
 517	sdp->sdp_header.HB3 = (dp_version & 0x3f) << 2;
 518
 519	hdmi_audio_infoframe_pack_payload(frame, sdp->db);
 520
 521	/* Return size =  frame length + four HB for sdp_header */
 522	return frame->length + 4;
 523}
 524EXPORT_SYMBOL(hdmi_audio_infoframe_pack_for_dp);
 525
 526/**
 527 * hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe
 528 * @frame: HDMI vendor infoframe
 529 *
 530 * Returns 0 on success or a negative error code on failure.
 531 */
 532int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame)
 533{
 534	memset(frame, 0, sizeof(*frame));
 535
 536	frame->type = HDMI_INFOFRAME_TYPE_VENDOR;
 537	frame->version = 1;
 538
 539	frame->oui = HDMI_IEEE_OUI;
 540
 541	/*
 542	 * 0 is a valid value for s3d_struct, so we use a special "not set"
 543	 * value
 544	 */
 545	frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID;
 546	frame->length = HDMI_VENDOR_INFOFRAME_SIZE;
 547
 548	return 0;
 549}
 550EXPORT_SYMBOL(hdmi_vendor_infoframe_init);
 551
 552static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *frame)
 553{
 554	/* for side by side (half) we also need to provide 3D_Ext_Data */
 555	if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
 556		return 6;
 557	else if (frame->vic != 0 || frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
 558		return 5;
 559	else
 560		return 4;
 561}
 562
 563static int hdmi_vendor_infoframe_check_only(const struct hdmi_vendor_infoframe *frame)
 564{
 565	if (frame->type != HDMI_INFOFRAME_TYPE_VENDOR ||
 566	    frame->version != 1 ||
 567	    frame->oui != HDMI_IEEE_OUI)
 568		return -EINVAL;
 569
 570	/* only one of those can be supplied */
 571	if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
 572		return -EINVAL;
 573
 574	if (frame->length != hdmi_vendor_infoframe_length(frame))
 575		return -EINVAL;
 576
 577	return 0;
 578}
 579
 580/**
 581 * hdmi_vendor_infoframe_check() - check a HDMI vendor infoframe
 582 * @frame: HDMI infoframe
 583 *
 584 * Validates that the infoframe is consistent and updates derived fields
 585 * (eg. length) based on other fields.
 586 *
 587 * Returns 0 on success or a negative error code on failure.
 588 */
 589int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame)
 590{
 591	frame->length = hdmi_vendor_infoframe_length(frame);
 592
 593	return hdmi_vendor_infoframe_check_only(frame);
 594}
 595EXPORT_SYMBOL(hdmi_vendor_infoframe_check);
 596
 597/**
 598 * hdmi_vendor_infoframe_pack_only() - write a HDMI vendor infoframe to binary buffer
 599 * @frame: HDMI infoframe
 600 * @buffer: destination buffer
 601 * @size: size of buffer
 602 *
 603 * Packs the information contained in the @frame structure into a binary
 604 * representation that can be written into the corresponding controller
 605 * registers. Also computes the checksum as required by section 5.3.5 of
 606 * the HDMI 1.4 specification.
 607 *
 608 * Returns the number of bytes packed into the binary buffer or a negative
 609 * error code on failure.
 610 */
 611ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame,
 612					void *buffer, size_t size)
 613{
 614	u8 *ptr = buffer;
 615	size_t length;
 616	int ret;
 617
 618	ret = hdmi_vendor_infoframe_check_only(frame);
 619	if (ret)
 620		return ret;
 621
 622	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
 623
 624	if (size < length)
 625		return -ENOSPC;
 626
 627	memset(buffer, 0, size);
 628
 629	ptr[0] = frame->type;
 630	ptr[1] = frame->version;
 631	ptr[2] = frame->length;
 632	ptr[3] = 0; /* checksum */
 633
 634	/* HDMI OUI */
 635	ptr[4] = 0x03;
 636	ptr[5] = 0x0c;
 637	ptr[6] = 0x00;
 638
 639	if (frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) {
 640		ptr[7] = 0x2 << 5;	/* video format */
 641		ptr[8] = (frame->s3d_struct & 0xf) << 4;
 642		if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
 643			ptr[9] = (frame->s3d_ext_data & 0xf) << 4;
 644	} else if (frame->vic) {
 645		ptr[7] = 0x1 << 5;	/* video format */
 646		ptr[8] = frame->vic;
 647	} else {
 648		ptr[7] = 0x0 << 5;	/* video format */
 649	}
 650
 651	hdmi_infoframe_set_checksum(buffer, length);
 652
 653	return length;
 654}
 655EXPORT_SYMBOL(hdmi_vendor_infoframe_pack_only);
 656
 657/**
 658 * hdmi_vendor_infoframe_pack() - check a HDMI Vendor infoframe,
 659 *                                and write it to binary buffer
 660 * @frame: HDMI Vendor infoframe
 661 * @buffer: destination buffer
 662 * @size: size of buffer
 663 *
 664 * Validates that the infoframe is consistent and updates derived fields
 665 * (eg. length) based on other fields, after which it packs the information
 666 * contained in the @frame structure into a binary representation that
 667 * can be written into the corresponding controller registers. This function
 668 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 669 * specification.
 670 *
 671 * Returns the number of bytes packed into the binary buffer or a negative
 672 * error code on failure.
 673 */
 674ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame,
 675				   void *buffer, size_t size)
 676{
 677	int ret;
 678
 679	ret = hdmi_vendor_infoframe_check(frame);
 680	if (ret)
 681		return ret;
 682
 683	return hdmi_vendor_infoframe_pack_only(frame, buffer, size);
 684}
 685EXPORT_SYMBOL(hdmi_vendor_infoframe_pack);
 686
 687static int
 688hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe *frame)
 689{
 690	if (frame->any.type != HDMI_INFOFRAME_TYPE_VENDOR ||
 691	    frame->any.version != 1)
 692		return -EINVAL;
 693
 694	return 0;
 695}
 696
 697/**
 698 * hdmi_drm_infoframe_init() - initialize an HDMI Dynaminc Range and
 699 * mastering infoframe
 700 * @frame: HDMI DRM infoframe
 701 *
 702 * Returns 0 on success or a negative error code on failure.
 703 */
 704int hdmi_drm_infoframe_init(struct hdmi_drm_infoframe *frame)
 705{
 706	memset(frame, 0, sizeof(*frame));
 707
 708	frame->type = HDMI_INFOFRAME_TYPE_DRM;
 709	frame->version = 1;
 710	frame->length = HDMI_DRM_INFOFRAME_SIZE;
 711
 712	return 0;
 713}
 714EXPORT_SYMBOL(hdmi_drm_infoframe_init);
 715
 716static int hdmi_drm_infoframe_check_only(const struct hdmi_drm_infoframe *frame)
 717{
 718	if (frame->type != HDMI_INFOFRAME_TYPE_DRM ||
 719	    frame->version != 1)
 720		return -EINVAL;
 721
 722	if (frame->length != HDMI_DRM_INFOFRAME_SIZE)
 723		return -EINVAL;
 724
 725	return 0;
 726}
 727
 728/**
 729 * hdmi_drm_infoframe_check() - check a HDMI DRM infoframe
 730 * @frame: HDMI DRM infoframe
 731 *
 732 * Validates that the infoframe is consistent.
 733 * Returns 0 on success or a negative error code on failure.
 734 */
 735int hdmi_drm_infoframe_check(struct hdmi_drm_infoframe *frame)
 736{
 737	return hdmi_drm_infoframe_check_only(frame);
 738}
 739EXPORT_SYMBOL(hdmi_drm_infoframe_check);
 740
 741/**
 742 * hdmi_drm_infoframe_pack_only() - write HDMI DRM infoframe to binary buffer
 743 * @frame: HDMI DRM infoframe
 744 * @buffer: destination buffer
 745 * @size: size of buffer
 746 *
 747 * Packs the information contained in the @frame structure into a binary
 748 * representation that can be written into the corresponding controller
 749 * registers. Also computes the checksum as required by section 5.3.5 of
 750 * the HDMI 1.4 specification.
 751 *
 752 * Returns the number of bytes packed into the binary buffer or a negative
 753 * error code on failure.
 754 */
 755ssize_t hdmi_drm_infoframe_pack_only(const struct hdmi_drm_infoframe *frame,
 756				     void *buffer, size_t size)
 757{
 758	u8 *ptr = buffer;
 759	size_t length;
 760	int i;
 761
 762	length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
 763
 764	if (size < length)
 765		return -ENOSPC;
 766
 767	memset(buffer, 0, size);
 768
 769	ptr[0] = frame->type;
 770	ptr[1] = frame->version;
 771	ptr[2] = frame->length;
 772	ptr[3] = 0; /* checksum */
 773
 774	/* start infoframe payload */
 775	ptr += HDMI_INFOFRAME_HEADER_SIZE;
 776
 777	*ptr++ = frame->eotf;
 778	*ptr++ = frame->metadata_type;
 779
 780	for (i = 0; i < 3; i++) {
 781		*ptr++ = frame->display_primaries[i].x;
 782		*ptr++ = frame->display_primaries[i].x >> 8;
 783		*ptr++ = frame->display_primaries[i].y;
 784		*ptr++ = frame->display_primaries[i].y >> 8;
 785	}
 786
 787	*ptr++ = frame->white_point.x;
 788	*ptr++ = frame->white_point.x >> 8;
 789
 790	*ptr++ = frame->white_point.y;
 791	*ptr++ = frame->white_point.y >> 8;
 792
 793	*ptr++ = frame->max_display_mastering_luminance;
 794	*ptr++ = frame->max_display_mastering_luminance >> 8;
 795
 796	*ptr++ = frame->min_display_mastering_luminance;
 797	*ptr++ = frame->min_display_mastering_luminance >> 8;
 798
 799	*ptr++ = frame->max_cll;
 800	*ptr++ = frame->max_cll >> 8;
 801
 802	*ptr++ = frame->max_fall;
 803	*ptr++ = frame->max_fall >> 8;
 804
 805	hdmi_infoframe_set_checksum(buffer, length);
 806
 807	return length;
 808}
 809EXPORT_SYMBOL(hdmi_drm_infoframe_pack_only);
 810
 811/**
 812 * hdmi_drm_infoframe_pack() - check a HDMI DRM infoframe,
 813 *                             and write it to binary buffer
 814 * @frame: HDMI DRM infoframe
 815 * @buffer: destination buffer
 816 * @size: size of buffer
 817 *
 818 * Validates that the infoframe is consistent and updates derived fields
 819 * (eg. length) based on other fields, after which it packs the information
 820 * contained in the @frame structure into a binary representation that
 821 * can be written into the corresponding controller registers. This function
 822 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 823 * specification.
 824 *
 825 * Returns the number of bytes packed into the binary buffer or a negative
 826 * error code on failure.
 827 */
 828ssize_t hdmi_drm_infoframe_pack(struct hdmi_drm_infoframe *frame,
 829				void *buffer, size_t size)
 830{
 831	int ret;
 832
 833	ret = hdmi_drm_infoframe_check(frame);
 834	if (ret)
 835		return ret;
 836
 837	return hdmi_drm_infoframe_pack_only(frame, buffer, size);
 838}
 839EXPORT_SYMBOL(hdmi_drm_infoframe_pack);
 840
 841/*
 842 * hdmi_vendor_any_infoframe_check() - check a vendor infoframe
 843 */
 844static int
 845hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe *frame)
 846{
 847	int ret;
 848
 849	ret = hdmi_vendor_any_infoframe_check_only(frame);
 850	if (ret)
 851		return ret;
 852
 853	/* we only know about HDMI vendor infoframes */
 854	if (frame->any.oui != HDMI_IEEE_OUI)
 855		return -EINVAL;
 856
 857	return hdmi_vendor_infoframe_check(&frame->hdmi);
 858}
 859
 860/*
 861 * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer
 862 */
 863static ssize_t
 864hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe *frame,
 865				    void *buffer, size_t size)
 866{
 867	int ret;
 868
 869	ret = hdmi_vendor_any_infoframe_check_only(frame);
 870	if (ret)
 871		return ret;
 872
 873	/* we only know about HDMI vendor infoframes */
 874	if (frame->any.oui != HDMI_IEEE_OUI)
 875		return -EINVAL;
 876
 877	return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size);
 878}
 879
 880/*
 881 * hdmi_vendor_any_infoframe_pack() - check a vendor infoframe,
 882 *                                    and write it to binary buffer
 883 */
 884static ssize_t
 885hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame,
 886			       void *buffer, size_t size)
 887{
 888	int ret;
 889
 890	ret = hdmi_vendor_any_infoframe_check(frame);
 891	if (ret)
 892		return ret;
 893
 894	return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size);
 895}
 896
 897/**
 898 * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer
 899 * @frame: HDMI infoframe
 900 * @buffer: destination buffer
 901 * @size: size of buffer
 902 *
 903 * Packs the information contained in the @frame structure into a binary
 904 * representation that can be written into the corresponding controller
 905 * registers. Also computes the checksum as required by section 5.3.5 of
 906 * the HDMI 1.4 specification.
 907 *
 908 * Returns the number of bytes packed into the binary buffer or a negative
 909 * error code on failure.
 910 */
 911ssize_t
 912hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size)
 913{
 914	ssize_t length;
 915
 916	switch (frame->any.type) {
 917	case HDMI_INFOFRAME_TYPE_AVI:
 918		length = hdmi_avi_infoframe_pack_only(&frame->avi,
 919						      buffer, size);
 920		break;
 921	case HDMI_INFOFRAME_TYPE_DRM:
 922		length = hdmi_drm_infoframe_pack_only(&frame->drm,
 923						      buffer, size);
 924		break;
 925	case HDMI_INFOFRAME_TYPE_SPD:
 926		length = hdmi_spd_infoframe_pack_only(&frame->spd,
 927						      buffer, size);
 928		break;
 929	case HDMI_INFOFRAME_TYPE_AUDIO:
 930		length = hdmi_audio_infoframe_pack_only(&frame->audio,
 931							buffer, size);
 932		break;
 933	case HDMI_INFOFRAME_TYPE_VENDOR:
 934		length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor,
 935							     buffer, size);
 936		break;
 937	default:
 938		WARN(1, "Bad infoframe type %d\n", frame->any.type);
 939		length = -EINVAL;
 940	}
 941
 942	return length;
 943}
 944EXPORT_SYMBOL(hdmi_infoframe_pack_only);
 945
 946/**
 947 * hdmi_infoframe_pack() - check a HDMI infoframe,
 948 *                         and write it to binary buffer
 949 * @frame: HDMI infoframe
 950 * @buffer: destination buffer
 951 * @size: size of buffer
 952 *
 953 * Validates that the infoframe is consistent and updates derived fields
 954 * (eg. length) based on other fields, after which it packs the information
 955 * contained in the @frame structure into a binary representation that
 956 * can be written into the corresponding controller registers. This function
 957 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 958 * specification.
 959 *
 960 * Returns the number of bytes packed into the binary buffer or a negative
 961 * error code on failure.
 962 */
 963ssize_t
 964hdmi_infoframe_pack(union hdmi_infoframe *frame,
 965		    void *buffer, size_t size)
 966{
 967	ssize_t length;
 968
 969	switch (frame->any.type) {
 970	case HDMI_INFOFRAME_TYPE_AVI:
 971		length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size);
 972		break;
 973	case HDMI_INFOFRAME_TYPE_DRM:
 974		length = hdmi_drm_infoframe_pack(&frame->drm, buffer, size);
 975		break;
 976	case HDMI_INFOFRAME_TYPE_SPD:
 977		length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size);
 978		break;
 979	case HDMI_INFOFRAME_TYPE_AUDIO:
 980		length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size);
 981		break;
 982	case HDMI_INFOFRAME_TYPE_VENDOR:
 983		length = hdmi_vendor_any_infoframe_pack(&frame->vendor,
 984							buffer, size);
 985		break;
 986	default:
 987		WARN(1, "Bad infoframe type %d\n", frame->any.type);
 988		length = -EINVAL;
 989	}
 990
 991	return length;
 992}
 993EXPORT_SYMBOL(hdmi_infoframe_pack);
 994
 995static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type)
 996{
 997	if (type < 0x80 || type > 0x9f)
 998		return "Invalid";
 999	switch (type) {
1000	case HDMI_INFOFRAME_TYPE_VENDOR:
1001		return "Vendor";
1002	case HDMI_INFOFRAME_TYPE_AVI:
1003		return "Auxiliary Video Information (AVI)";
1004	case HDMI_INFOFRAME_TYPE_SPD:
1005		return "Source Product Description (SPD)";
1006	case HDMI_INFOFRAME_TYPE_AUDIO:
1007		return "Audio";
1008	case HDMI_INFOFRAME_TYPE_DRM:
1009		return "Dynamic Range and Mastering";
1010	}
1011	return "Reserved";
1012}
1013
1014static void hdmi_infoframe_log_header(const char *level,
1015				      struct device *dev,
1016				      const struct hdmi_any_infoframe *frame)
1017{
1018	hdmi_log("HDMI infoframe: %s, version %u, length %u\n",
1019		hdmi_infoframe_type_get_name(frame->type),
1020		frame->version, frame->length);
1021}
1022
1023static const char *hdmi_colorspace_get_name(enum hdmi_colorspace colorspace)
1024{
1025	switch (colorspace) {
1026	case HDMI_COLORSPACE_RGB:
1027		return "RGB";
1028	case HDMI_COLORSPACE_YUV422:
1029		return "YCbCr 4:2:2";
1030	case HDMI_COLORSPACE_YUV444:
1031		return "YCbCr 4:4:4";
1032	case HDMI_COLORSPACE_YUV420:
1033		return "YCbCr 4:2:0";
1034	case HDMI_COLORSPACE_RESERVED4:
1035		return "Reserved (4)";
1036	case HDMI_COLORSPACE_RESERVED5:
1037		return "Reserved (5)";
1038	case HDMI_COLORSPACE_RESERVED6:
1039		return "Reserved (6)";
1040	case HDMI_COLORSPACE_IDO_DEFINED:
1041		return "IDO Defined";
1042	}
1043	return "Invalid";
1044}
1045
1046static const char *hdmi_scan_mode_get_name(enum hdmi_scan_mode scan_mode)
1047{
1048	switch (scan_mode) {
1049	case HDMI_SCAN_MODE_NONE:
1050		return "No Data";
1051	case HDMI_SCAN_MODE_OVERSCAN:
1052		return "Overscan";
1053	case HDMI_SCAN_MODE_UNDERSCAN:
1054		return "Underscan";
1055	case HDMI_SCAN_MODE_RESERVED:
1056		return "Reserved";
1057	}
1058	return "Invalid";
1059}
1060
1061static const char *hdmi_colorimetry_get_name(enum hdmi_colorimetry colorimetry)
1062{
1063	switch (colorimetry) {
1064	case HDMI_COLORIMETRY_NONE:
1065		return "No Data";
1066	case HDMI_COLORIMETRY_ITU_601:
1067		return "ITU601";
1068	case HDMI_COLORIMETRY_ITU_709:
1069		return "ITU709";
1070	case HDMI_COLORIMETRY_EXTENDED:
1071		return "Extended";
1072	}
1073	return "Invalid";
1074}
1075
1076static const char *
1077hdmi_picture_aspect_get_name(enum hdmi_picture_aspect picture_aspect)
1078{
1079	switch (picture_aspect) {
1080	case HDMI_PICTURE_ASPECT_NONE:
1081		return "No Data";
1082	case HDMI_PICTURE_ASPECT_4_3:
1083		return "4:3";
1084	case HDMI_PICTURE_ASPECT_16_9:
1085		return "16:9";
1086	case HDMI_PICTURE_ASPECT_64_27:
1087		return "64:27";
1088	case HDMI_PICTURE_ASPECT_256_135:
1089		return "256:135";
1090	case HDMI_PICTURE_ASPECT_RESERVED:
1091		return "Reserved";
1092	}
1093	return "Invalid";
1094}
1095
1096static const char *
1097hdmi_active_aspect_get_name(enum hdmi_active_aspect active_aspect)
1098{
1099	if (active_aspect < 0 || active_aspect > 0xf)
1100		return "Invalid";
1101
1102	switch (active_aspect) {
1103	case HDMI_ACTIVE_ASPECT_16_9_TOP:
1104		return "16:9 Top";
1105	case HDMI_ACTIVE_ASPECT_14_9_TOP:
1106		return "14:9 Top";
1107	case HDMI_ACTIVE_ASPECT_16_9_CENTER:
1108		return "16:9 Center";
1109	case HDMI_ACTIVE_ASPECT_PICTURE:
1110		return "Same as Picture";
1111	case HDMI_ACTIVE_ASPECT_4_3:
1112		return "4:3";
1113	case HDMI_ACTIVE_ASPECT_16_9:
1114		return "16:9";
1115	case HDMI_ACTIVE_ASPECT_14_9:
1116		return "14:9";
1117	case HDMI_ACTIVE_ASPECT_4_3_SP_14_9:
1118		return "4:3 SP 14:9";
1119	case HDMI_ACTIVE_ASPECT_16_9_SP_14_9:
1120		return "16:9 SP 14:9";
1121	case HDMI_ACTIVE_ASPECT_16_9_SP_4_3:
1122		return "16:9 SP 4:3";
1123	}
1124	return "Reserved";
1125}
1126
1127static const char *
1128hdmi_extended_colorimetry_get_name(enum hdmi_extended_colorimetry ext_col)
1129{
1130	switch (ext_col) {
1131	case HDMI_EXTENDED_COLORIMETRY_XV_YCC_601:
1132		return "xvYCC 601";
1133	case HDMI_EXTENDED_COLORIMETRY_XV_YCC_709:
1134		return "xvYCC 709";
1135	case HDMI_EXTENDED_COLORIMETRY_S_YCC_601:
1136		return "sYCC 601";
1137	case HDMI_EXTENDED_COLORIMETRY_OPYCC_601:
1138		return "opYCC 601";
1139	case HDMI_EXTENDED_COLORIMETRY_OPRGB:
1140		return "opRGB";
1141	case HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM:
1142		return "BT.2020 Constant Luminance";
1143	case HDMI_EXTENDED_COLORIMETRY_BT2020:
1144		return "BT.2020";
1145	case HDMI_EXTENDED_COLORIMETRY_RESERVED:
1146		return "Reserved";
1147	}
1148	return "Invalid";
1149}
1150
1151static const char *
1152hdmi_quantization_range_get_name(enum hdmi_quantization_range qrange)
1153{
1154	switch (qrange) {
1155	case HDMI_QUANTIZATION_RANGE_DEFAULT:
1156		return "Default";
1157	case HDMI_QUANTIZATION_RANGE_LIMITED:
1158		return "Limited";
1159	case HDMI_QUANTIZATION_RANGE_FULL:
1160		return "Full";
1161	case HDMI_QUANTIZATION_RANGE_RESERVED:
1162		return "Reserved";
1163	}
1164	return "Invalid";
1165}
1166
1167static const char *hdmi_nups_get_name(enum hdmi_nups nups)
1168{
1169	switch (nups) {
1170	case HDMI_NUPS_UNKNOWN:
1171		return "Unknown Non-uniform Scaling";
1172	case HDMI_NUPS_HORIZONTAL:
1173		return "Horizontally Scaled";
1174	case HDMI_NUPS_VERTICAL:
1175		return "Vertically Scaled";
1176	case HDMI_NUPS_BOTH:
1177		return "Horizontally and Vertically Scaled";
1178	}
1179	return "Invalid";
1180}
1181
1182static const char *
1183hdmi_ycc_quantization_range_get_name(enum hdmi_ycc_quantization_range qrange)
1184{
1185	switch (qrange) {
1186	case HDMI_YCC_QUANTIZATION_RANGE_LIMITED:
1187		return "Limited";
1188	case HDMI_YCC_QUANTIZATION_RANGE_FULL:
1189		return "Full";
1190	}
1191	return "Invalid";
1192}
1193
1194static const char *
1195hdmi_content_type_get_name(enum hdmi_content_type content_type)
1196{
1197	switch (content_type) {
1198	case HDMI_CONTENT_TYPE_GRAPHICS:
1199		return "Graphics";
1200	case HDMI_CONTENT_TYPE_PHOTO:
1201		return "Photo";
1202	case HDMI_CONTENT_TYPE_CINEMA:
1203		return "Cinema";
1204	case HDMI_CONTENT_TYPE_GAME:
1205		return "Game";
1206	}
1207	return "Invalid";
1208}
1209
1210static void hdmi_avi_infoframe_log(const char *level,
1211				   struct device *dev,
1212				   const struct hdmi_avi_infoframe *frame)
1213{
1214	hdmi_infoframe_log_header(level, dev,
1215				  (const struct hdmi_any_infoframe *)frame);
1216
1217	hdmi_log("    colorspace: %s\n",
1218			hdmi_colorspace_get_name(frame->colorspace));
1219	hdmi_log("    scan mode: %s\n",
1220			hdmi_scan_mode_get_name(frame->scan_mode));
1221	hdmi_log("    colorimetry: %s\n",
1222			hdmi_colorimetry_get_name(frame->colorimetry));
1223	hdmi_log("    picture aspect: %s\n",
1224			hdmi_picture_aspect_get_name(frame->picture_aspect));
1225	hdmi_log("    active aspect: %s\n",
1226			hdmi_active_aspect_get_name(frame->active_aspect));
1227	hdmi_log("    itc: %s\n", frame->itc ? "IT Content" : "No Data");
1228	hdmi_log("    extended colorimetry: %s\n",
1229			hdmi_extended_colorimetry_get_name(frame->extended_colorimetry));
1230	hdmi_log("    quantization range: %s\n",
1231			hdmi_quantization_range_get_name(frame->quantization_range));
1232	hdmi_log("    nups: %s\n", hdmi_nups_get_name(frame->nups));
1233	hdmi_log("    video code: %u\n", frame->video_code);
1234	hdmi_log("    ycc quantization range: %s\n",
1235			hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range));
1236	hdmi_log("    hdmi content type: %s\n",
1237			hdmi_content_type_get_name(frame->content_type));
1238	hdmi_log("    pixel repeat: %u\n", frame->pixel_repeat);
1239	hdmi_log("    bar top %u, bottom %u, left %u, right %u\n",
1240			frame->top_bar, frame->bottom_bar,
1241			frame->left_bar, frame->right_bar);
1242}
1243
1244static const char *hdmi_spd_sdi_get_name(enum hdmi_spd_sdi sdi)
1245{
1246	if (sdi < 0 || sdi > 0xff)
1247		return "Invalid";
1248	switch (sdi) {
1249	case HDMI_SPD_SDI_UNKNOWN:
1250		return "Unknown";
1251	case HDMI_SPD_SDI_DSTB:
1252		return "Digital STB";
1253	case HDMI_SPD_SDI_DVDP:
1254		return "DVD Player";
1255	case HDMI_SPD_SDI_DVHS:
1256		return "D-VHS";
1257	case HDMI_SPD_SDI_HDDVR:
1258		return "HDD Videorecorder";
1259	case HDMI_SPD_SDI_DVC:
1260		return "DVC";
1261	case HDMI_SPD_SDI_DSC:
1262		return "DSC";
1263	case HDMI_SPD_SDI_VCD:
1264		return "Video CD";
1265	case HDMI_SPD_SDI_GAME:
1266		return "Game";
1267	case HDMI_SPD_SDI_PC:
1268		return "PC General";
1269	case HDMI_SPD_SDI_BD:
1270		return "Blu-Ray Disc (BD)";
1271	case HDMI_SPD_SDI_SACD:
1272		return "Super Audio CD";
1273	case HDMI_SPD_SDI_HDDVD:
1274		return "HD DVD";
1275	case HDMI_SPD_SDI_PMP:
1276		return "PMP";
1277	}
1278	return "Reserved";
1279}
1280
1281static void hdmi_spd_infoframe_log(const char *level,
1282				   struct device *dev,
1283				   const struct hdmi_spd_infoframe *frame)
1284{
1285	hdmi_infoframe_log_header(level, dev,
1286				  (const struct hdmi_any_infoframe *)frame);
1287
1288	hdmi_log("    vendor: %.8s\n", frame->vendor);
1289	hdmi_log("    product: %.16s\n", frame->product);
1290	hdmi_log("    source device information: %s (0x%x)\n",
1291		hdmi_spd_sdi_get_name(frame->sdi), frame->sdi);
1292}
1293
1294static const char *
1295hdmi_audio_coding_type_get_name(enum hdmi_audio_coding_type coding_type)
1296{
1297	switch (coding_type) {
1298	case HDMI_AUDIO_CODING_TYPE_STREAM:
1299		return "Refer to Stream Header";
1300	case HDMI_AUDIO_CODING_TYPE_PCM:
1301		return "PCM";
1302	case HDMI_AUDIO_CODING_TYPE_AC3:
1303		return "AC-3";
1304	case HDMI_AUDIO_CODING_TYPE_MPEG1:
1305		return "MPEG1";
1306	case HDMI_AUDIO_CODING_TYPE_MP3:
1307		return "MP3";
1308	case HDMI_AUDIO_CODING_TYPE_MPEG2:
1309		return "MPEG2";
1310	case HDMI_AUDIO_CODING_TYPE_AAC_LC:
1311		return "AAC";
1312	case HDMI_AUDIO_CODING_TYPE_DTS:
1313		return "DTS";
1314	case HDMI_AUDIO_CODING_TYPE_ATRAC:
1315		return "ATRAC";
1316	case HDMI_AUDIO_CODING_TYPE_DSD:
1317		return "One Bit Audio";
1318	case HDMI_AUDIO_CODING_TYPE_EAC3:
1319		return "Dolby Digital +";
1320	case HDMI_AUDIO_CODING_TYPE_DTS_HD:
1321		return "DTS-HD";
1322	case HDMI_AUDIO_CODING_TYPE_MLP:
1323		return "MAT (MLP)";
1324	case HDMI_AUDIO_CODING_TYPE_DST:
1325		return "DST";
1326	case HDMI_AUDIO_CODING_TYPE_WMA_PRO:
1327		return "WMA PRO";
1328	case HDMI_AUDIO_CODING_TYPE_CXT:
1329		return "Refer to CXT";
1330	}
1331	return "Invalid";
1332}
1333
1334static const char *
1335hdmi_audio_sample_size_get_name(enum hdmi_audio_sample_size sample_size)
1336{
1337	switch (sample_size) {
1338	case HDMI_AUDIO_SAMPLE_SIZE_STREAM:
1339		return "Refer to Stream Header";
1340	case HDMI_AUDIO_SAMPLE_SIZE_16:
1341		return "16 bit";
1342	case HDMI_AUDIO_SAMPLE_SIZE_20:
1343		return "20 bit";
1344	case HDMI_AUDIO_SAMPLE_SIZE_24:
1345		return "24 bit";
1346	}
1347	return "Invalid";
1348}
1349
1350static const char *
1351hdmi_audio_sample_frequency_get_name(enum hdmi_audio_sample_frequency freq)
1352{
1353	switch (freq) {
1354	case HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM:
1355		return "Refer to Stream Header";
1356	case HDMI_AUDIO_SAMPLE_FREQUENCY_32000:
1357		return "32 kHz";
1358	case HDMI_AUDIO_SAMPLE_FREQUENCY_44100:
1359		return "44.1 kHz (CD)";
1360	case HDMI_AUDIO_SAMPLE_FREQUENCY_48000:
1361		return "48 kHz";
1362	case HDMI_AUDIO_SAMPLE_FREQUENCY_88200:
1363		return "88.2 kHz";
1364	case HDMI_AUDIO_SAMPLE_FREQUENCY_96000:
1365		return "96 kHz";
1366	case HDMI_AUDIO_SAMPLE_FREQUENCY_176400:
1367		return "176.4 kHz";
1368	case HDMI_AUDIO_SAMPLE_FREQUENCY_192000:
1369		return "192 kHz";
1370	}
1371	return "Invalid";
1372}
1373
1374static const char *
1375hdmi_audio_coding_type_ext_get_name(enum hdmi_audio_coding_type_ext ctx)
1376{
1377	if (ctx < 0 || ctx > 0x1f)
1378		return "Invalid";
1379
1380	switch (ctx) {
1381	case HDMI_AUDIO_CODING_TYPE_EXT_CT:
1382		return "Refer to CT";
1383	case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC:
1384		return "HE AAC";
1385	case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2:
1386		return "HE AAC v2";
1387	case HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND:
1388		return "MPEG SURROUND";
1389	case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC:
1390		return "MPEG-4 HE AAC";
1391	case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2:
1392		return "MPEG-4 HE AAC v2";
1393	case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC:
1394		return "MPEG-4 AAC LC";
1395	case HDMI_AUDIO_CODING_TYPE_EXT_DRA:
1396		return "DRA";
1397	case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND:
1398		return "MPEG-4 HE AAC + MPEG Surround";
1399	case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND:
1400		return "MPEG-4 AAC LC + MPEG Surround";
1401	}
1402	return "Reserved";
1403}
1404
1405static void hdmi_audio_infoframe_log(const char *level,
1406				     struct device *dev,
1407				     const struct hdmi_audio_infoframe *frame)
1408{
1409	hdmi_infoframe_log_header(level, dev,
1410				  (const struct hdmi_any_infoframe *)frame);
1411
1412	if (frame->channels)
1413		hdmi_log("    channels: %u\n", frame->channels - 1);
1414	else
1415		hdmi_log("    channels: Refer to stream header\n");
1416	hdmi_log("    coding type: %s\n",
1417			hdmi_audio_coding_type_get_name(frame->coding_type));
1418	hdmi_log("    sample size: %s\n",
1419			hdmi_audio_sample_size_get_name(frame->sample_size));
1420	hdmi_log("    sample frequency: %s\n",
1421			hdmi_audio_sample_frequency_get_name(frame->sample_frequency));
1422	hdmi_log("    coding type ext: %s\n",
1423			hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext));
1424	hdmi_log("    channel allocation: 0x%x\n",
1425			frame->channel_allocation);
1426	hdmi_log("    level shift value: %u dB\n",
1427			frame->level_shift_value);
1428	hdmi_log("    downmix inhibit: %s\n",
1429			frame->downmix_inhibit ? "Yes" : "No");
1430}
1431
1432static void hdmi_drm_infoframe_log(const char *level,
1433				   struct device *dev,
1434				   const struct hdmi_drm_infoframe *frame)
1435{
1436	int i;
1437
1438	hdmi_infoframe_log_header(level, dev,
1439				  (struct hdmi_any_infoframe *)frame);
1440	hdmi_log("length: %d\n", frame->length);
1441	hdmi_log("metadata type: %d\n", frame->metadata_type);
1442	hdmi_log("eotf: %d\n", frame->eotf);
1443	for (i = 0; i < 3; i++) {
1444		hdmi_log("x[%d]: %d\n", i, frame->display_primaries[i].x);
1445		hdmi_log("y[%d]: %d\n", i, frame->display_primaries[i].y);
1446	}
1447
1448	hdmi_log("white point x: %d\n", frame->white_point.x);
1449	hdmi_log("white point y: %d\n", frame->white_point.y);
1450
1451	hdmi_log("max_display_mastering_luminance: %d\n",
1452		 frame->max_display_mastering_luminance);
1453	hdmi_log("min_display_mastering_luminance: %d\n",
1454		 frame->min_display_mastering_luminance);
1455
1456	hdmi_log("max_cll: %d\n", frame->max_cll);
1457	hdmi_log("max_fall: %d\n", frame->max_fall);
1458}
1459
1460static const char *
1461hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct)
1462{
1463	if (s3d_struct < 0 || s3d_struct > 0xf)
1464		return "Invalid";
1465
1466	switch (s3d_struct) {
1467	case HDMI_3D_STRUCTURE_FRAME_PACKING:
1468		return "Frame Packing";
1469	case HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE:
1470		return "Field Alternative";
1471	case HDMI_3D_STRUCTURE_LINE_ALTERNATIVE:
1472		return "Line Alternative";
1473	case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL:
1474		return "Side-by-side (Full)";
1475	case HDMI_3D_STRUCTURE_L_DEPTH:
1476		return "L + Depth";
1477	case HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH:
1478		return "L + Depth + Graphics + Graphics-depth";
1479	case HDMI_3D_STRUCTURE_TOP_AND_BOTTOM:
1480		return "Top-and-Bottom";
1481	case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF:
1482		return "Side-by-side (Half)";
1483	default:
1484		break;
1485	}
1486	return "Reserved";
1487}
1488
1489static void
1490hdmi_vendor_any_infoframe_log(const char *level,
1491			      struct device *dev,
1492			      const union hdmi_vendor_any_infoframe *frame)
1493{
1494	const struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1495
1496	hdmi_infoframe_log_header(level, dev,
1497				  (const struct hdmi_any_infoframe *)frame);
1498
1499	if (frame->any.oui != HDMI_IEEE_OUI) {
1500		hdmi_log("    not a HDMI vendor infoframe\n");
1501		return;
1502	}
1503	if (hvf->vic == 0 && hvf->s3d_struct == HDMI_3D_STRUCTURE_INVALID) {
1504		hdmi_log("    empty frame\n");
1505		return;
1506	}
1507
1508	if (hvf->vic)
1509		hdmi_log("    HDMI VIC: %u\n", hvf->vic);
1510	if (hvf->s3d_struct != HDMI_3D_STRUCTURE_INVALID) {
1511		hdmi_log("    3D structure: %s\n",
1512				hdmi_3d_structure_get_name(hvf->s3d_struct));
1513		if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
1514			hdmi_log("    3D extension data: %d\n",
1515					hvf->s3d_ext_data);
1516	}
1517}
1518
1519/**
1520 * hdmi_infoframe_log() - log info of HDMI infoframe
1521 * @level: logging level
1522 * @dev: device
1523 * @frame: HDMI infoframe
1524 */
1525void hdmi_infoframe_log(const char *level,
1526			struct device *dev,
1527			const union hdmi_infoframe *frame)
1528{
1529	switch (frame->any.type) {
1530	case HDMI_INFOFRAME_TYPE_AVI:
1531		hdmi_avi_infoframe_log(level, dev, &frame->avi);
1532		break;
1533	case HDMI_INFOFRAME_TYPE_SPD:
1534		hdmi_spd_infoframe_log(level, dev, &frame->spd);
1535		break;
1536	case HDMI_INFOFRAME_TYPE_AUDIO:
1537		hdmi_audio_infoframe_log(level, dev, &frame->audio);
1538		break;
1539	case HDMI_INFOFRAME_TYPE_VENDOR:
1540		hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor);
1541		break;
1542	case HDMI_INFOFRAME_TYPE_DRM:
1543		hdmi_drm_infoframe_log(level, dev, &frame->drm);
1544		break;
1545	}
1546}
1547EXPORT_SYMBOL(hdmi_infoframe_log);
1548
1549/**
1550 * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe
1551 * @frame: HDMI AVI infoframe
1552 * @buffer: source buffer
1553 * @size: size of buffer
1554 *
1555 * Unpacks the information contained in binary @buffer into a structured
1556 * @frame of the HDMI Auxiliary Video (AVI) information frame.
1557 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1558 * specification.
1559 *
1560 * Returns 0 on success or a negative error code on failure.
1561 */
1562static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame,
1563				     const void *buffer, size_t size)
1564{
1565	const u8 *ptr = buffer;
1566
1567	if (size < HDMI_INFOFRAME_SIZE(AVI))
1568		return -EINVAL;
1569
1570	if (ptr[0] != HDMI_INFOFRAME_TYPE_AVI ||
1571	    ptr[1] != 2 ||
1572	    ptr[2] != HDMI_AVI_INFOFRAME_SIZE)
1573		return -EINVAL;
1574
1575	if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AVI)) != 0)
1576		return -EINVAL;
1577
1578	hdmi_avi_infoframe_init(frame);
1579
1580	ptr += HDMI_INFOFRAME_HEADER_SIZE;
1581
1582	frame->colorspace = (ptr[0] >> 5) & 0x3;
1583	if (ptr[0] & 0x10)
1584		frame->active_aspect = ptr[1] & 0xf;
1585	if (ptr[0] & 0x8) {
1586		frame->top_bar = (ptr[6] << 8) | ptr[5];
1587		frame->bottom_bar = (ptr[8] << 8) | ptr[7];
1588	}
1589	if (ptr[0] & 0x4) {
1590		frame->left_bar = (ptr[10] << 8) | ptr[9];
1591		frame->right_bar = (ptr[12] << 8) | ptr[11];
1592	}
1593	frame->scan_mode = ptr[0] & 0x3;
1594
1595	frame->colorimetry = (ptr[1] >> 6) & 0x3;
1596	frame->picture_aspect = (ptr[1] >> 4) & 0x3;
1597	frame->active_aspect = ptr[1] & 0xf;
1598
1599	frame->itc = ptr[2] & 0x80 ? true : false;
1600	frame->extended_colorimetry = (ptr[2] >> 4) & 0x7;
1601	frame->quantization_range = (ptr[2] >> 2) & 0x3;
1602	frame->nups = ptr[2] & 0x3;
1603
1604	frame->video_code = ptr[3] & 0x7f;
1605	frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3;
1606	frame->content_type = (ptr[4] >> 4) & 0x3;
1607
1608	frame->pixel_repeat = ptr[4] & 0xf;
1609
1610	return 0;
1611}
1612
1613/**
1614 * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe
1615 * @frame: HDMI SPD infoframe
1616 * @buffer: source buffer
1617 * @size: size of buffer
1618 *
1619 * Unpacks the information contained in binary @buffer into a structured
1620 * @frame of the HDMI Source Product Description (SPD) information frame.
1621 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1622 * specification.
1623 *
1624 * Returns 0 on success or a negative error code on failure.
1625 */
1626static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame,
1627				     const void *buffer, size_t size)
1628{
1629	const u8 *ptr = buffer;
1630	int ret;
1631
1632	if (size < HDMI_INFOFRAME_SIZE(SPD))
1633		return -EINVAL;
1634
1635	if (ptr[0] != HDMI_INFOFRAME_TYPE_SPD ||
1636	    ptr[1] != 1 ||
1637	    ptr[2] != HDMI_SPD_INFOFRAME_SIZE) {
1638		return -EINVAL;
1639	}
1640
1641	if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(SPD)) != 0)
1642		return -EINVAL;
1643
1644	ptr += HDMI_INFOFRAME_HEADER_SIZE;
1645
1646	ret = hdmi_spd_infoframe_init(frame, ptr, ptr + 8);
1647	if (ret)
1648		return ret;
1649
1650	frame->sdi = ptr[24];
1651
1652	return 0;
1653}
1654
1655/**
1656 * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe
1657 * @frame: HDMI Audio infoframe
1658 * @buffer: source buffer
1659 * @size: size of buffer
1660 *
1661 * Unpacks the information contained in binary @buffer into a structured
1662 * @frame of the HDMI Audio information frame.
1663 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1664 * specification.
1665 *
1666 * Returns 0 on success or a negative error code on failure.
1667 */
1668static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame,
1669				       const void *buffer, size_t size)
1670{
1671	const u8 *ptr = buffer;
1672	int ret;
1673
1674	if (size < HDMI_INFOFRAME_SIZE(AUDIO))
1675		return -EINVAL;
1676
1677	if (ptr[0] != HDMI_INFOFRAME_TYPE_AUDIO ||
1678	    ptr[1] != 1 ||
1679	    ptr[2] != HDMI_AUDIO_INFOFRAME_SIZE) {
1680		return -EINVAL;
1681	}
1682
1683	if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AUDIO)) != 0)
1684		return -EINVAL;
1685
1686	ret = hdmi_audio_infoframe_init(frame);
1687	if (ret)
1688		return ret;
1689
1690	ptr += HDMI_INFOFRAME_HEADER_SIZE;
1691
1692	frame->channels = ptr[0] & 0x7;
1693	frame->coding_type = (ptr[0] >> 4) & 0xf;
1694	frame->sample_size = ptr[1] & 0x3;
1695	frame->sample_frequency = (ptr[1] >> 2) & 0x7;
1696	frame->coding_type_ext = ptr[2] & 0x1f;
1697	frame->channel_allocation = ptr[3];
1698	frame->level_shift_value = (ptr[4] >> 3) & 0xf;
1699	frame->downmix_inhibit = ptr[4] & 0x80 ? true : false;
1700
1701	return 0;
1702}
1703
1704/**
1705 * hdmi_vendor_any_infoframe_unpack() - unpack binary buffer to a HDMI
1706 * 	vendor infoframe
1707 * @frame: HDMI Vendor infoframe
1708 * @buffer: source buffer
1709 * @size: size of buffer
1710 *
1711 * Unpacks the information contained in binary @buffer into a structured
1712 * @frame of the HDMI Vendor information frame.
1713 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1714 * specification.
1715 *
1716 * Returns 0 on success or a negative error code on failure.
1717 */
1718static int
1719hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame,
1720				 const void *buffer, size_t size)
1721{
1722	const u8 *ptr = buffer;
1723	size_t length;
1724	int ret;
1725	u8 hdmi_video_format;
1726	struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1727
1728	if (size < HDMI_INFOFRAME_HEADER_SIZE)
1729		return -EINVAL;
1730
1731	if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR ||
1732	    ptr[1] != 1 ||
1733	    (ptr[2] != 4 && ptr[2] != 5 && ptr[2] != 6))
1734		return -EINVAL;
1735
1736	length = ptr[2];
1737
1738	if (size < HDMI_INFOFRAME_HEADER_SIZE + length)
1739		return -EINVAL;
1740
1741	if (hdmi_infoframe_checksum(buffer,
1742				    HDMI_INFOFRAME_HEADER_SIZE + length) != 0)
1743		return -EINVAL;
1744
1745	ptr += HDMI_INFOFRAME_HEADER_SIZE;
1746
1747	/* HDMI OUI */
1748	if ((ptr[0] != 0x03) ||
1749	    (ptr[1] != 0x0c) ||
1750	    (ptr[2] != 0x00))
1751		return -EINVAL;
1752
1753	hdmi_video_format = ptr[3] >> 5;
1754
1755	if (hdmi_video_format > 0x2)
1756		return -EINVAL;
1757
1758	ret = hdmi_vendor_infoframe_init(hvf);
1759	if (ret)
1760		return ret;
1761
1762	hvf->length = length;
1763
1764	if (hdmi_video_format == 0x2) {
1765		if (length != 5 && length != 6)
1766			return -EINVAL;
1767		hvf->s3d_struct = ptr[4] >> 4;
1768		if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) {
1769			if (length != 6)
1770				return -EINVAL;
1771			hvf->s3d_ext_data = ptr[5] >> 4;
1772		}
1773	} else if (hdmi_video_format == 0x1) {
1774		if (length != 5)
1775			return -EINVAL;
1776		hvf->vic = ptr[4];
1777	} else {
1778		if (length != 4)
1779			return -EINVAL;
1780	}
1781
1782	return 0;
1783}
1784
1785/**
1786 * hdmi_drm_infoframe_unpack_only() - unpack binary buffer of CTA-861-G DRM
1787 *                                    infoframe DataBytes to a HDMI DRM
1788 *                                    infoframe
1789 * @frame: HDMI DRM infoframe
1790 * @buffer: source buffer
1791 * @size: size of buffer
1792 *
1793 * Unpacks CTA-861-G DRM infoframe DataBytes contained in the binary @buffer
1794 * into a structured @frame of the HDMI Dynamic Range and Mastering (DRM)
1795 * infoframe.
1796 *
1797 * Returns 0 on success or a negative error code on failure.
1798 */
1799int hdmi_drm_infoframe_unpack_only(struct hdmi_drm_infoframe *frame,
1800				   const void *buffer, size_t size)
1801{
1802	const u8 *ptr = buffer;
1803	const u8 *temp;
1804	u8 x_lsb, x_msb;
1805	u8 y_lsb, y_msb;
1806	int ret;
1807	int i;
1808
1809	if (size < HDMI_DRM_INFOFRAME_SIZE)
1810		return -EINVAL;
1811
1812	ret = hdmi_drm_infoframe_init(frame);
1813	if (ret)
1814		return ret;
1815
1816	frame->eotf = ptr[0] & 0x7;
1817	frame->metadata_type = ptr[1] & 0x7;
1818
1819	temp = ptr + 2;
1820	for (i = 0; i < 3; i++) {
1821		x_lsb = *temp++;
1822		x_msb = *temp++;
1823		frame->display_primaries[i].x = (x_msb << 8) | x_lsb;
1824		y_lsb = *temp++;
1825		y_msb = *temp++;
1826		frame->display_primaries[i].y = (y_msb << 8) | y_lsb;
1827	}
1828
1829	frame->white_point.x = (ptr[15] << 8) | ptr[14];
1830	frame->white_point.y = (ptr[17] << 8) | ptr[16];
1831
1832	frame->max_display_mastering_luminance = (ptr[19] << 8) | ptr[18];
1833	frame->min_display_mastering_luminance = (ptr[21] << 8) | ptr[20];
1834	frame->max_cll = (ptr[23] << 8) | ptr[22];
1835	frame->max_fall = (ptr[25] << 8) | ptr[24];
1836
1837	return 0;
1838}
1839EXPORT_SYMBOL(hdmi_drm_infoframe_unpack_only);
1840
1841/**
1842 * hdmi_drm_infoframe_unpack() - unpack binary buffer to a HDMI DRM infoframe
1843 * @frame: HDMI DRM infoframe
1844 * @buffer: source buffer
1845 * @size: size of buffer
1846 *
1847 * Unpacks the CTA-861-G DRM infoframe contained in the binary @buffer into
1848 * a structured @frame of the HDMI Dynamic Range and Mastering (DRM)
1849 * infoframe. It also verifies the checksum as required by section 5.3.5 of
1850 * the HDMI 1.4 specification.
1851 *
1852 * Returns 0 on success or a negative error code on failure.
1853 */
1854static int hdmi_drm_infoframe_unpack(struct hdmi_drm_infoframe *frame,
1855				     const void *buffer, size_t size)
1856{
1857	const u8 *ptr = buffer;
1858	int ret;
1859
1860	if (size < HDMI_INFOFRAME_SIZE(DRM))
1861		return -EINVAL;
1862
1863	if (ptr[0] != HDMI_INFOFRAME_TYPE_DRM ||
1864	    ptr[1] != 1 ||
1865	    ptr[2] != HDMI_DRM_INFOFRAME_SIZE)
1866		return -EINVAL;
1867
1868	if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(DRM)) != 0)
1869		return -EINVAL;
1870
1871	ret = hdmi_drm_infoframe_unpack_only(frame, ptr + HDMI_INFOFRAME_HEADER_SIZE,
1872					     size - HDMI_INFOFRAME_HEADER_SIZE);
1873	return ret;
1874}
1875
1876/**
1877 * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe
1878 * @frame: HDMI infoframe
1879 * @buffer: source buffer
1880 * @size: size of buffer
1881 *
1882 * Unpacks the information contained in binary buffer @buffer into a structured
1883 * @frame of a HDMI infoframe.
1884 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1885 * specification.
1886 *
1887 * Returns 0 on success or a negative error code on failure.
1888 */
1889int hdmi_infoframe_unpack(union hdmi_infoframe *frame,
1890			  const void *buffer, size_t size)
1891{
1892	int ret;
1893	const u8 *ptr = buffer;
1894
1895	if (size < HDMI_INFOFRAME_HEADER_SIZE)
1896		return -EINVAL;
1897
1898	switch (ptr[0]) {
1899	case HDMI_INFOFRAME_TYPE_AVI:
1900		ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer, size);
1901		break;
1902	case HDMI_INFOFRAME_TYPE_DRM:
1903		ret = hdmi_drm_infoframe_unpack(&frame->drm, buffer, size);
1904		break;
1905	case HDMI_INFOFRAME_TYPE_SPD:
1906		ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer, size);
1907		break;
1908	case HDMI_INFOFRAME_TYPE_AUDIO:
1909		ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer, size);
1910		break;
1911	case HDMI_INFOFRAME_TYPE_VENDOR:
1912		ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer, size);
1913		break;
1914	default:
1915		ret = -EINVAL;
1916		break;
1917	}
1918
1919	return ret;
1920}
1921EXPORT_SYMBOL(hdmi_infoframe_unpack);