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 35 static 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 47 static 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 */ 58 void 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 } 66 EXPORT_SYMBOL(hdmi_avi_infoframe_init); 67 68 static 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 */ 90 int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame) 91 { 92 return hdmi_avi_infoframe_check_only(frame); 93 } 94 EXPORT_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 */ 110 ssize_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 } 182 EXPORT_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 */ 201 ssize_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 } 212 EXPORT_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 */ 222 int 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 } 240 EXPORT_SYMBOL(hdmi_spd_infoframe_init); 241 242 static 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 */ 261 int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame) 262 { 263 return hdmi_spd_infoframe_check_only(frame); 264 } 265 EXPORT_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 */ 281 ssize_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 } 316 EXPORT_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 */ 335 ssize_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 } 346 EXPORT_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 */ 354 int 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 } 364 EXPORT_SYMBOL(hdmi_audio_infoframe_init); 365 366 static 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 */ 385 int hdmi_audio_infoframe_check(const struct hdmi_audio_infoframe *frame) 386 { 387 return hdmi_audio_infoframe_check_only(frame); 388 } 389 EXPORT_SYMBOL(hdmi_audio_infoframe_check); 390 391 static void 392 hdmi_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 */ 427 ssize_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 } 457 EXPORT_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 */ 476 ssize_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 } 487 EXPORT_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 */ 501 ssize_t 502 hdmi_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 } 524 EXPORT_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 */ 532 int 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 } 550 EXPORT_SYMBOL(hdmi_vendor_infoframe_init); 551 552 static 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 563 static 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 */ 589 int 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 } 595 EXPORT_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 */ 611 ssize_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 } 655 EXPORT_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 */ 674 ssize_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 } 685 EXPORT_SYMBOL(hdmi_vendor_infoframe_pack); 686 687 static int 688 hdmi_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 */ 704 int 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 } 714 EXPORT_SYMBOL(hdmi_drm_infoframe_init); 715 716 static 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 */ 735 int hdmi_drm_infoframe_check(struct hdmi_drm_infoframe *frame) 736 { 737 return hdmi_drm_infoframe_check_only(frame); 738 } 739 EXPORT_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 */ 755 ssize_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 } 809 EXPORT_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 */ 828 ssize_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 } 839 EXPORT_SYMBOL(hdmi_drm_infoframe_pack); 840 841 /* 842 * hdmi_vendor_any_infoframe_check() - check a vendor infoframe 843 */ 844 static int 845 hdmi_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 */ 863 static ssize_t 864 hdmi_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 */ 884 static ssize_t 885 hdmi_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_check() - check a HDMI infoframe 899 * @frame: HDMI infoframe 900 * 901 * Validates that the infoframe is consistent and updates derived fields 902 * (eg. length) based on other fields. 903 * 904 * Returns 0 on success or a negative error code on failure. 905 */ 906 int 907 hdmi_infoframe_check(union hdmi_infoframe *frame) 908 { 909 switch (frame->any.type) { 910 case HDMI_INFOFRAME_TYPE_AVI: 911 return hdmi_avi_infoframe_check(&frame->avi); 912 case HDMI_INFOFRAME_TYPE_SPD: 913 return hdmi_spd_infoframe_check(&frame->spd); 914 case HDMI_INFOFRAME_TYPE_AUDIO: 915 return hdmi_audio_infoframe_check(&frame->audio); 916 case HDMI_INFOFRAME_TYPE_VENDOR: 917 return hdmi_vendor_any_infoframe_check(&frame->vendor); 918 default: 919 WARN(1, "Bad infoframe type %d\n", frame->any.type); 920 return -EINVAL; 921 } 922 } 923 EXPORT_SYMBOL(hdmi_infoframe_check); 924 925 /** 926 * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer 927 * @frame: HDMI infoframe 928 * @buffer: destination buffer 929 * @size: size of buffer 930 * 931 * Packs the information contained in the @frame structure into a binary 932 * representation that can be written into the corresponding controller 933 * registers. Also computes the checksum as required by section 5.3.5 of 934 * the HDMI 1.4 specification. 935 * 936 * Returns the number of bytes packed into the binary buffer or a negative 937 * error code on failure. 938 */ 939 ssize_t 940 hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size) 941 { 942 ssize_t length; 943 944 switch (frame->any.type) { 945 case HDMI_INFOFRAME_TYPE_AVI: 946 length = hdmi_avi_infoframe_pack_only(&frame->avi, 947 buffer, size); 948 break; 949 case HDMI_INFOFRAME_TYPE_DRM: 950 length = hdmi_drm_infoframe_pack_only(&frame->drm, 951 buffer, size); 952 break; 953 case HDMI_INFOFRAME_TYPE_SPD: 954 length = hdmi_spd_infoframe_pack_only(&frame->spd, 955 buffer, size); 956 break; 957 case HDMI_INFOFRAME_TYPE_AUDIO: 958 length = hdmi_audio_infoframe_pack_only(&frame->audio, 959 buffer, size); 960 break; 961 case HDMI_INFOFRAME_TYPE_VENDOR: 962 length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor, 963 buffer, size); 964 break; 965 default: 966 WARN(1, "Bad infoframe type %d\n", frame->any.type); 967 length = -EINVAL; 968 } 969 970 return length; 971 } 972 EXPORT_SYMBOL(hdmi_infoframe_pack_only); 973 974 /** 975 * hdmi_infoframe_pack() - check a HDMI infoframe, 976 * and write it to binary buffer 977 * @frame: HDMI infoframe 978 * @buffer: destination buffer 979 * @size: size of buffer 980 * 981 * Validates that the infoframe is consistent and updates derived fields 982 * (eg. length) based on other fields, after which it packs the information 983 * contained in the @frame structure into a binary representation that 984 * can be written into the corresponding controller registers. This function 985 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4 986 * specification. 987 * 988 * Returns the number of bytes packed into the binary buffer or a negative 989 * error code on failure. 990 */ 991 ssize_t 992 hdmi_infoframe_pack(union hdmi_infoframe *frame, 993 void *buffer, size_t size) 994 { 995 ssize_t length; 996 997 switch (frame->any.type) { 998 case HDMI_INFOFRAME_TYPE_AVI: 999 length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size); 1000 break; 1001 case HDMI_INFOFRAME_TYPE_DRM: 1002 length = hdmi_drm_infoframe_pack(&frame->drm, buffer, size); 1003 break; 1004 case HDMI_INFOFRAME_TYPE_SPD: 1005 length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size); 1006 break; 1007 case HDMI_INFOFRAME_TYPE_AUDIO: 1008 length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size); 1009 break; 1010 case HDMI_INFOFRAME_TYPE_VENDOR: 1011 length = hdmi_vendor_any_infoframe_pack(&frame->vendor, 1012 buffer, size); 1013 break; 1014 default: 1015 WARN(1, "Bad infoframe type %d\n", frame->any.type); 1016 length = -EINVAL; 1017 } 1018 1019 return length; 1020 } 1021 EXPORT_SYMBOL(hdmi_infoframe_pack); 1022 1023 static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type) 1024 { 1025 if (type < 0x80 || type > 0x9f) 1026 return "Invalid"; 1027 switch (type) { 1028 case HDMI_INFOFRAME_TYPE_VENDOR: 1029 return "Vendor"; 1030 case HDMI_INFOFRAME_TYPE_AVI: 1031 return "Auxiliary Video Information (AVI)"; 1032 case HDMI_INFOFRAME_TYPE_SPD: 1033 return "Source Product Description (SPD)"; 1034 case HDMI_INFOFRAME_TYPE_AUDIO: 1035 return "Audio"; 1036 case HDMI_INFOFRAME_TYPE_DRM: 1037 return "Dynamic Range and Mastering"; 1038 } 1039 return "Reserved"; 1040 } 1041 1042 static void hdmi_infoframe_log_header(const char *level, 1043 struct device *dev, 1044 const struct hdmi_any_infoframe *frame) 1045 { 1046 hdmi_log("HDMI infoframe: %s, version %u, length %u\n", 1047 hdmi_infoframe_type_get_name(frame->type), 1048 frame->version, frame->length); 1049 } 1050 1051 static const char *hdmi_colorspace_get_name(enum hdmi_colorspace colorspace) 1052 { 1053 switch (colorspace) { 1054 case HDMI_COLORSPACE_RGB: 1055 return "RGB"; 1056 case HDMI_COLORSPACE_YUV422: 1057 return "YCbCr 4:2:2"; 1058 case HDMI_COLORSPACE_YUV444: 1059 return "YCbCr 4:4:4"; 1060 case HDMI_COLORSPACE_YUV420: 1061 return "YCbCr 4:2:0"; 1062 case HDMI_COLORSPACE_RESERVED4: 1063 return "Reserved (4)"; 1064 case HDMI_COLORSPACE_RESERVED5: 1065 return "Reserved (5)"; 1066 case HDMI_COLORSPACE_RESERVED6: 1067 return "Reserved (6)"; 1068 case HDMI_COLORSPACE_IDO_DEFINED: 1069 return "IDO Defined"; 1070 } 1071 return "Invalid"; 1072 } 1073 1074 static const char *hdmi_scan_mode_get_name(enum hdmi_scan_mode scan_mode) 1075 { 1076 switch (scan_mode) { 1077 case HDMI_SCAN_MODE_NONE: 1078 return "No Data"; 1079 case HDMI_SCAN_MODE_OVERSCAN: 1080 return "Overscan"; 1081 case HDMI_SCAN_MODE_UNDERSCAN: 1082 return "Underscan"; 1083 case HDMI_SCAN_MODE_RESERVED: 1084 return "Reserved"; 1085 } 1086 return "Invalid"; 1087 } 1088 1089 static const char *hdmi_colorimetry_get_name(enum hdmi_colorimetry colorimetry) 1090 { 1091 switch (colorimetry) { 1092 case HDMI_COLORIMETRY_NONE: 1093 return "No Data"; 1094 case HDMI_COLORIMETRY_ITU_601: 1095 return "ITU601"; 1096 case HDMI_COLORIMETRY_ITU_709: 1097 return "ITU709"; 1098 case HDMI_COLORIMETRY_EXTENDED: 1099 return "Extended"; 1100 } 1101 return "Invalid"; 1102 } 1103 1104 static const char * 1105 hdmi_picture_aspect_get_name(enum hdmi_picture_aspect picture_aspect) 1106 { 1107 switch (picture_aspect) { 1108 case HDMI_PICTURE_ASPECT_NONE: 1109 return "No Data"; 1110 case HDMI_PICTURE_ASPECT_4_3: 1111 return "4:3"; 1112 case HDMI_PICTURE_ASPECT_16_9: 1113 return "16:9"; 1114 case HDMI_PICTURE_ASPECT_64_27: 1115 return "64:27"; 1116 case HDMI_PICTURE_ASPECT_256_135: 1117 return "256:135"; 1118 case HDMI_PICTURE_ASPECT_RESERVED: 1119 return "Reserved"; 1120 } 1121 return "Invalid"; 1122 } 1123 1124 static const char * 1125 hdmi_active_aspect_get_name(enum hdmi_active_aspect active_aspect) 1126 { 1127 if (active_aspect < 0 || active_aspect > 0xf) 1128 return "Invalid"; 1129 1130 switch (active_aspect) { 1131 case HDMI_ACTIVE_ASPECT_16_9_TOP: 1132 return "16:9 Top"; 1133 case HDMI_ACTIVE_ASPECT_14_9_TOP: 1134 return "14:9 Top"; 1135 case HDMI_ACTIVE_ASPECT_16_9_CENTER: 1136 return "16:9 Center"; 1137 case HDMI_ACTIVE_ASPECT_PICTURE: 1138 return "Same as Picture"; 1139 case HDMI_ACTIVE_ASPECT_4_3: 1140 return "4:3"; 1141 case HDMI_ACTIVE_ASPECT_16_9: 1142 return "16:9"; 1143 case HDMI_ACTIVE_ASPECT_14_9: 1144 return "14:9"; 1145 case HDMI_ACTIVE_ASPECT_4_3_SP_14_9: 1146 return "4:3 SP 14:9"; 1147 case HDMI_ACTIVE_ASPECT_16_9_SP_14_9: 1148 return "16:9 SP 14:9"; 1149 case HDMI_ACTIVE_ASPECT_16_9_SP_4_3: 1150 return "16:9 SP 4:3"; 1151 } 1152 return "Reserved"; 1153 } 1154 1155 static const char * 1156 hdmi_extended_colorimetry_get_name(enum hdmi_extended_colorimetry ext_col) 1157 { 1158 switch (ext_col) { 1159 case HDMI_EXTENDED_COLORIMETRY_XV_YCC_601: 1160 return "xvYCC 601"; 1161 case HDMI_EXTENDED_COLORIMETRY_XV_YCC_709: 1162 return "xvYCC 709"; 1163 case HDMI_EXTENDED_COLORIMETRY_S_YCC_601: 1164 return "sYCC 601"; 1165 case HDMI_EXTENDED_COLORIMETRY_OPYCC_601: 1166 return "opYCC 601"; 1167 case HDMI_EXTENDED_COLORIMETRY_OPRGB: 1168 return "opRGB"; 1169 case HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM: 1170 return "BT.2020 Constant Luminance"; 1171 case HDMI_EXTENDED_COLORIMETRY_BT2020: 1172 return "BT.2020"; 1173 case HDMI_EXTENDED_COLORIMETRY_RESERVED: 1174 return "Reserved"; 1175 } 1176 return "Invalid"; 1177 } 1178 1179 static const char * 1180 hdmi_quantization_range_get_name(enum hdmi_quantization_range qrange) 1181 { 1182 switch (qrange) { 1183 case HDMI_QUANTIZATION_RANGE_DEFAULT: 1184 return "Default"; 1185 case HDMI_QUANTIZATION_RANGE_LIMITED: 1186 return "Limited"; 1187 case HDMI_QUANTIZATION_RANGE_FULL: 1188 return "Full"; 1189 case HDMI_QUANTIZATION_RANGE_RESERVED: 1190 return "Reserved"; 1191 } 1192 return "Invalid"; 1193 } 1194 1195 static const char *hdmi_nups_get_name(enum hdmi_nups nups) 1196 { 1197 switch (nups) { 1198 case HDMI_NUPS_UNKNOWN: 1199 return "Unknown Non-uniform Scaling"; 1200 case HDMI_NUPS_HORIZONTAL: 1201 return "Horizontally Scaled"; 1202 case HDMI_NUPS_VERTICAL: 1203 return "Vertically Scaled"; 1204 case HDMI_NUPS_BOTH: 1205 return "Horizontally and Vertically Scaled"; 1206 } 1207 return "Invalid"; 1208 } 1209 1210 static const char * 1211 hdmi_ycc_quantization_range_get_name(enum hdmi_ycc_quantization_range qrange) 1212 { 1213 switch (qrange) { 1214 case HDMI_YCC_QUANTIZATION_RANGE_LIMITED: 1215 return "Limited"; 1216 case HDMI_YCC_QUANTIZATION_RANGE_FULL: 1217 return "Full"; 1218 } 1219 return "Invalid"; 1220 } 1221 1222 static const char * 1223 hdmi_content_type_get_name(enum hdmi_content_type content_type) 1224 { 1225 switch (content_type) { 1226 case HDMI_CONTENT_TYPE_GRAPHICS: 1227 return "Graphics"; 1228 case HDMI_CONTENT_TYPE_PHOTO: 1229 return "Photo"; 1230 case HDMI_CONTENT_TYPE_CINEMA: 1231 return "Cinema"; 1232 case HDMI_CONTENT_TYPE_GAME: 1233 return "Game"; 1234 } 1235 return "Invalid"; 1236 } 1237 1238 static void hdmi_avi_infoframe_log(const char *level, 1239 struct device *dev, 1240 const struct hdmi_avi_infoframe *frame) 1241 { 1242 hdmi_infoframe_log_header(level, dev, 1243 (const struct hdmi_any_infoframe *)frame); 1244 1245 hdmi_log(" colorspace: %s\n", 1246 hdmi_colorspace_get_name(frame->colorspace)); 1247 hdmi_log(" scan mode: %s\n", 1248 hdmi_scan_mode_get_name(frame->scan_mode)); 1249 hdmi_log(" colorimetry: %s\n", 1250 hdmi_colorimetry_get_name(frame->colorimetry)); 1251 hdmi_log(" picture aspect: %s\n", 1252 hdmi_picture_aspect_get_name(frame->picture_aspect)); 1253 hdmi_log(" active aspect: %s\n", 1254 hdmi_active_aspect_get_name(frame->active_aspect)); 1255 hdmi_log(" itc: %s\n", frame->itc ? "IT Content" : "No Data"); 1256 hdmi_log(" extended colorimetry: %s\n", 1257 hdmi_extended_colorimetry_get_name(frame->extended_colorimetry)); 1258 hdmi_log(" quantization range: %s\n", 1259 hdmi_quantization_range_get_name(frame->quantization_range)); 1260 hdmi_log(" nups: %s\n", hdmi_nups_get_name(frame->nups)); 1261 hdmi_log(" video code: %u\n", frame->video_code); 1262 hdmi_log(" ycc quantization range: %s\n", 1263 hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range)); 1264 hdmi_log(" hdmi content type: %s\n", 1265 hdmi_content_type_get_name(frame->content_type)); 1266 hdmi_log(" pixel repeat: %u\n", frame->pixel_repeat); 1267 hdmi_log(" bar top %u, bottom %u, left %u, right %u\n", 1268 frame->top_bar, frame->bottom_bar, 1269 frame->left_bar, frame->right_bar); 1270 } 1271 1272 static const char *hdmi_spd_sdi_get_name(enum hdmi_spd_sdi sdi) 1273 { 1274 if (sdi < 0 || sdi > 0xff) 1275 return "Invalid"; 1276 switch (sdi) { 1277 case HDMI_SPD_SDI_UNKNOWN: 1278 return "Unknown"; 1279 case HDMI_SPD_SDI_DSTB: 1280 return "Digital STB"; 1281 case HDMI_SPD_SDI_DVDP: 1282 return "DVD Player"; 1283 case HDMI_SPD_SDI_DVHS: 1284 return "D-VHS"; 1285 case HDMI_SPD_SDI_HDDVR: 1286 return "HDD Videorecorder"; 1287 case HDMI_SPD_SDI_DVC: 1288 return "DVC"; 1289 case HDMI_SPD_SDI_DSC: 1290 return "DSC"; 1291 case HDMI_SPD_SDI_VCD: 1292 return "Video CD"; 1293 case HDMI_SPD_SDI_GAME: 1294 return "Game"; 1295 case HDMI_SPD_SDI_PC: 1296 return "PC General"; 1297 case HDMI_SPD_SDI_BD: 1298 return "Blu-Ray Disc (BD)"; 1299 case HDMI_SPD_SDI_SACD: 1300 return "Super Audio CD"; 1301 case HDMI_SPD_SDI_HDDVD: 1302 return "HD DVD"; 1303 case HDMI_SPD_SDI_PMP: 1304 return "PMP"; 1305 } 1306 return "Reserved"; 1307 } 1308 1309 static void hdmi_spd_infoframe_log(const char *level, 1310 struct device *dev, 1311 const struct hdmi_spd_infoframe *frame) 1312 { 1313 hdmi_infoframe_log_header(level, dev, 1314 (const struct hdmi_any_infoframe *)frame); 1315 1316 hdmi_log(" vendor: %.8s\n", frame->vendor); 1317 hdmi_log(" product: %.16s\n", frame->product); 1318 hdmi_log(" source device information: %s (0x%x)\n", 1319 hdmi_spd_sdi_get_name(frame->sdi), frame->sdi); 1320 } 1321 1322 static const char * 1323 hdmi_audio_coding_type_get_name(enum hdmi_audio_coding_type coding_type) 1324 { 1325 switch (coding_type) { 1326 case HDMI_AUDIO_CODING_TYPE_STREAM: 1327 return "Refer to Stream Header"; 1328 case HDMI_AUDIO_CODING_TYPE_PCM: 1329 return "PCM"; 1330 case HDMI_AUDIO_CODING_TYPE_AC3: 1331 return "AC-3"; 1332 case HDMI_AUDIO_CODING_TYPE_MPEG1: 1333 return "MPEG1"; 1334 case HDMI_AUDIO_CODING_TYPE_MP3: 1335 return "MP3"; 1336 case HDMI_AUDIO_CODING_TYPE_MPEG2: 1337 return "MPEG2"; 1338 case HDMI_AUDIO_CODING_TYPE_AAC_LC: 1339 return "AAC"; 1340 case HDMI_AUDIO_CODING_TYPE_DTS: 1341 return "DTS"; 1342 case HDMI_AUDIO_CODING_TYPE_ATRAC: 1343 return "ATRAC"; 1344 case HDMI_AUDIO_CODING_TYPE_DSD: 1345 return "One Bit Audio"; 1346 case HDMI_AUDIO_CODING_TYPE_EAC3: 1347 return "Dolby Digital +"; 1348 case HDMI_AUDIO_CODING_TYPE_DTS_HD: 1349 return "DTS-HD"; 1350 case HDMI_AUDIO_CODING_TYPE_MLP: 1351 return "MAT (MLP)"; 1352 case HDMI_AUDIO_CODING_TYPE_DST: 1353 return "DST"; 1354 case HDMI_AUDIO_CODING_TYPE_WMA_PRO: 1355 return "WMA PRO"; 1356 case HDMI_AUDIO_CODING_TYPE_CXT: 1357 return "Refer to CXT"; 1358 } 1359 return "Invalid"; 1360 } 1361 1362 static const char * 1363 hdmi_audio_sample_size_get_name(enum hdmi_audio_sample_size sample_size) 1364 { 1365 switch (sample_size) { 1366 case HDMI_AUDIO_SAMPLE_SIZE_STREAM: 1367 return "Refer to Stream Header"; 1368 case HDMI_AUDIO_SAMPLE_SIZE_16: 1369 return "16 bit"; 1370 case HDMI_AUDIO_SAMPLE_SIZE_20: 1371 return "20 bit"; 1372 case HDMI_AUDIO_SAMPLE_SIZE_24: 1373 return "24 bit"; 1374 } 1375 return "Invalid"; 1376 } 1377 1378 static const char * 1379 hdmi_audio_sample_frequency_get_name(enum hdmi_audio_sample_frequency freq) 1380 { 1381 switch (freq) { 1382 case HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM: 1383 return "Refer to Stream Header"; 1384 case HDMI_AUDIO_SAMPLE_FREQUENCY_32000: 1385 return "32 kHz"; 1386 case HDMI_AUDIO_SAMPLE_FREQUENCY_44100: 1387 return "44.1 kHz (CD)"; 1388 case HDMI_AUDIO_SAMPLE_FREQUENCY_48000: 1389 return "48 kHz"; 1390 case HDMI_AUDIO_SAMPLE_FREQUENCY_88200: 1391 return "88.2 kHz"; 1392 case HDMI_AUDIO_SAMPLE_FREQUENCY_96000: 1393 return "96 kHz"; 1394 case HDMI_AUDIO_SAMPLE_FREQUENCY_176400: 1395 return "176.4 kHz"; 1396 case HDMI_AUDIO_SAMPLE_FREQUENCY_192000: 1397 return "192 kHz"; 1398 } 1399 return "Invalid"; 1400 } 1401 1402 static const char * 1403 hdmi_audio_coding_type_ext_get_name(enum hdmi_audio_coding_type_ext ctx) 1404 { 1405 if (ctx < 0 || ctx > 0x1f) 1406 return "Invalid"; 1407 1408 switch (ctx) { 1409 case HDMI_AUDIO_CODING_TYPE_EXT_CT: 1410 return "Refer to CT"; 1411 case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC: 1412 return "HE AAC"; 1413 case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2: 1414 return "HE AAC v2"; 1415 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND: 1416 return "MPEG SURROUND"; 1417 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC: 1418 return "MPEG-4 HE AAC"; 1419 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2: 1420 return "MPEG-4 HE AAC v2"; 1421 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC: 1422 return "MPEG-4 AAC LC"; 1423 case HDMI_AUDIO_CODING_TYPE_EXT_DRA: 1424 return "DRA"; 1425 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND: 1426 return "MPEG-4 HE AAC + MPEG Surround"; 1427 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND: 1428 return "MPEG-4 AAC LC + MPEG Surround"; 1429 } 1430 return "Reserved"; 1431 } 1432 1433 static void hdmi_audio_infoframe_log(const char *level, 1434 struct device *dev, 1435 const struct hdmi_audio_infoframe *frame) 1436 { 1437 hdmi_infoframe_log_header(level, dev, 1438 (const struct hdmi_any_infoframe *)frame); 1439 1440 if (frame->channels) 1441 hdmi_log(" channels: %u\n", frame->channels - 1); 1442 else 1443 hdmi_log(" channels: Refer to stream header\n"); 1444 hdmi_log(" coding type: %s\n", 1445 hdmi_audio_coding_type_get_name(frame->coding_type)); 1446 hdmi_log(" sample size: %s\n", 1447 hdmi_audio_sample_size_get_name(frame->sample_size)); 1448 hdmi_log(" sample frequency: %s\n", 1449 hdmi_audio_sample_frequency_get_name(frame->sample_frequency)); 1450 hdmi_log(" coding type ext: %s\n", 1451 hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext)); 1452 hdmi_log(" channel allocation: 0x%x\n", 1453 frame->channel_allocation); 1454 hdmi_log(" level shift value: %u dB\n", 1455 frame->level_shift_value); 1456 hdmi_log(" downmix inhibit: %s\n", 1457 frame->downmix_inhibit ? "Yes" : "No"); 1458 } 1459 1460 static void hdmi_drm_infoframe_log(const char *level, 1461 struct device *dev, 1462 const struct hdmi_drm_infoframe *frame) 1463 { 1464 int i; 1465 1466 hdmi_infoframe_log_header(level, dev, 1467 (struct hdmi_any_infoframe *)frame); 1468 hdmi_log("length: %d\n", frame->length); 1469 hdmi_log("metadata type: %d\n", frame->metadata_type); 1470 hdmi_log("eotf: %d\n", frame->eotf); 1471 for (i = 0; i < 3; i++) { 1472 hdmi_log("x[%d]: %d\n", i, frame->display_primaries[i].x); 1473 hdmi_log("y[%d]: %d\n", i, frame->display_primaries[i].y); 1474 } 1475 1476 hdmi_log("white point x: %d\n", frame->white_point.x); 1477 hdmi_log("white point y: %d\n", frame->white_point.y); 1478 1479 hdmi_log("max_display_mastering_luminance: %d\n", 1480 frame->max_display_mastering_luminance); 1481 hdmi_log("min_display_mastering_luminance: %d\n", 1482 frame->min_display_mastering_luminance); 1483 1484 hdmi_log("max_cll: %d\n", frame->max_cll); 1485 hdmi_log("max_fall: %d\n", frame->max_fall); 1486 } 1487 1488 static const char * 1489 hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct) 1490 { 1491 if (s3d_struct < 0 || s3d_struct > 0xf) 1492 return "Invalid"; 1493 1494 switch (s3d_struct) { 1495 case HDMI_3D_STRUCTURE_FRAME_PACKING: 1496 return "Frame Packing"; 1497 case HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE: 1498 return "Field Alternative"; 1499 case HDMI_3D_STRUCTURE_LINE_ALTERNATIVE: 1500 return "Line Alternative"; 1501 case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL: 1502 return "Side-by-side (Full)"; 1503 case HDMI_3D_STRUCTURE_L_DEPTH: 1504 return "L + Depth"; 1505 case HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH: 1506 return "L + Depth + Graphics + Graphics-depth"; 1507 case HDMI_3D_STRUCTURE_TOP_AND_BOTTOM: 1508 return "Top-and-Bottom"; 1509 case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF: 1510 return "Side-by-side (Half)"; 1511 default: 1512 break; 1513 } 1514 return "Reserved"; 1515 } 1516 1517 static void 1518 hdmi_vendor_any_infoframe_log(const char *level, 1519 struct device *dev, 1520 const union hdmi_vendor_any_infoframe *frame) 1521 { 1522 const struct hdmi_vendor_infoframe *hvf = &frame->hdmi; 1523 1524 hdmi_infoframe_log_header(level, dev, 1525 (const struct hdmi_any_infoframe *)frame); 1526 1527 if (frame->any.oui != HDMI_IEEE_OUI) { 1528 hdmi_log(" not a HDMI vendor infoframe\n"); 1529 return; 1530 } 1531 if (hvf->vic == 0 && hvf->s3d_struct == HDMI_3D_STRUCTURE_INVALID) { 1532 hdmi_log(" empty frame\n"); 1533 return; 1534 } 1535 1536 if (hvf->vic) 1537 hdmi_log(" HDMI VIC: %u\n", hvf->vic); 1538 if (hvf->s3d_struct != HDMI_3D_STRUCTURE_INVALID) { 1539 hdmi_log(" 3D structure: %s\n", 1540 hdmi_3d_structure_get_name(hvf->s3d_struct)); 1541 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) 1542 hdmi_log(" 3D extension data: %d\n", 1543 hvf->s3d_ext_data); 1544 } 1545 } 1546 1547 /** 1548 * hdmi_infoframe_log() - log info of HDMI infoframe 1549 * @level: logging level 1550 * @dev: device 1551 * @frame: HDMI infoframe 1552 */ 1553 void hdmi_infoframe_log(const char *level, 1554 struct device *dev, 1555 const union hdmi_infoframe *frame) 1556 { 1557 switch (frame->any.type) { 1558 case HDMI_INFOFRAME_TYPE_AVI: 1559 hdmi_avi_infoframe_log(level, dev, &frame->avi); 1560 break; 1561 case HDMI_INFOFRAME_TYPE_SPD: 1562 hdmi_spd_infoframe_log(level, dev, &frame->spd); 1563 break; 1564 case HDMI_INFOFRAME_TYPE_AUDIO: 1565 hdmi_audio_infoframe_log(level, dev, &frame->audio); 1566 break; 1567 case HDMI_INFOFRAME_TYPE_VENDOR: 1568 hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor); 1569 break; 1570 case HDMI_INFOFRAME_TYPE_DRM: 1571 hdmi_drm_infoframe_log(level, dev, &frame->drm); 1572 break; 1573 } 1574 } 1575 EXPORT_SYMBOL(hdmi_infoframe_log); 1576 1577 /** 1578 * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe 1579 * @frame: HDMI AVI infoframe 1580 * @buffer: source buffer 1581 * @size: size of buffer 1582 * 1583 * Unpacks the information contained in binary @buffer into a structured 1584 * @frame of the HDMI Auxiliary Video (AVI) information frame. 1585 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1586 * specification. 1587 * 1588 * Returns 0 on success or a negative error code on failure. 1589 */ 1590 static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame, 1591 const void *buffer, size_t size) 1592 { 1593 const u8 *ptr = buffer; 1594 1595 if (size < HDMI_INFOFRAME_SIZE(AVI)) 1596 return -EINVAL; 1597 1598 if (ptr[0] != HDMI_INFOFRAME_TYPE_AVI || 1599 ptr[1] != 2 || 1600 ptr[2] != HDMI_AVI_INFOFRAME_SIZE) 1601 return -EINVAL; 1602 1603 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AVI)) != 0) 1604 return -EINVAL; 1605 1606 hdmi_avi_infoframe_init(frame); 1607 1608 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1609 1610 frame->colorspace = (ptr[0] >> 5) & 0x3; 1611 if (ptr[0] & 0x10) 1612 frame->active_aspect = ptr[1] & 0xf; 1613 if (ptr[0] & 0x8) { 1614 frame->top_bar = (ptr[6] << 8) | ptr[5]; 1615 frame->bottom_bar = (ptr[8] << 8) | ptr[7]; 1616 } 1617 if (ptr[0] & 0x4) { 1618 frame->left_bar = (ptr[10] << 8) | ptr[9]; 1619 frame->right_bar = (ptr[12] << 8) | ptr[11]; 1620 } 1621 frame->scan_mode = ptr[0] & 0x3; 1622 1623 frame->colorimetry = (ptr[1] >> 6) & 0x3; 1624 frame->picture_aspect = (ptr[1] >> 4) & 0x3; 1625 frame->active_aspect = ptr[1] & 0xf; 1626 1627 frame->itc = ptr[2] & 0x80 ? true : false; 1628 frame->extended_colorimetry = (ptr[2] >> 4) & 0x7; 1629 frame->quantization_range = (ptr[2] >> 2) & 0x3; 1630 frame->nups = ptr[2] & 0x3; 1631 1632 frame->video_code = ptr[3] & 0x7f; 1633 frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3; 1634 frame->content_type = (ptr[4] >> 4) & 0x3; 1635 1636 frame->pixel_repeat = ptr[4] & 0xf; 1637 1638 return 0; 1639 } 1640 1641 /** 1642 * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe 1643 * @frame: HDMI SPD infoframe 1644 * @buffer: source buffer 1645 * @size: size of buffer 1646 * 1647 * Unpacks the information contained in binary @buffer into a structured 1648 * @frame of the HDMI Source Product Description (SPD) information frame. 1649 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1650 * specification. 1651 * 1652 * Returns 0 on success or a negative error code on failure. 1653 */ 1654 static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame, 1655 const void *buffer, size_t size) 1656 { 1657 const u8 *ptr = buffer; 1658 int ret; 1659 1660 if (size < HDMI_INFOFRAME_SIZE(SPD)) 1661 return -EINVAL; 1662 1663 if (ptr[0] != HDMI_INFOFRAME_TYPE_SPD || 1664 ptr[1] != 1 || 1665 ptr[2] != HDMI_SPD_INFOFRAME_SIZE) { 1666 return -EINVAL; 1667 } 1668 1669 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(SPD)) != 0) 1670 return -EINVAL; 1671 1672 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1673 1674 ret = hdmi_spd_infoframe_init(frame, ptr, ptr + 8); 1675 if (ret) 1676 return ret; 1677 1678 frame->sdi = ptr[24]; 1679 1680 return 0; 1681 } 1682 1683 /** 1684 * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe 1685 * @frame: HDMI Audio infoframe 1686 * @buffer: source buffer 1687 * @size: size of buffer 1688 * 1689 * Unpacks the information contained in binary @buffer into a structured 1690 * @frame of the HDMI Audio information frame. 1691 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1692 * specification. 1693 * 1694 * Returns 0 on success or a negative error code on failure. 1695 */ 1696 static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame, 1697 const void *buffer, size_t size) 1698 { 1699 const u8 *ptr = buffer; 1700 int ret; 1701 1702 if (size < HDMI_INFOFRAME_SIZE(AUDIO)) 1703 return -EINVAL; 1704 1705 if (ptr[0] != HDMI_INFOFRAME_TYPE_AUDIO || 1706 ptr[1] != 1 || 1707 ptr[2] != HDMI_AUDIO_INFOFRAME_SIZE) { 1708 return -EINVAL; 1709 } 1710 1711 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AUDIO)) != 0) 1712 return -EINVAL; 1713 1714 ret = hdmi_audio_infoframe_init(frame); 1715 if (ret) 1716 return ret; 1717 1718 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1719 1720 frame->channels = ptr[0] & 0x7; 1721 frame->coding_type = (ptr[0] >> 4) & 0xf; 1722 frame->sample_size = ptr[1] & 0x3; 1723 frame->sample_frequency = (ptr[1] >> 2) & 0x7; 1724 frame->coding_type_ext = ptr[2] & 0x1f; 1725 frame->channel_allocation = ptr[3]; 1726 frame->level_shift_value = (ptr[4] >> 3) & 0xf; 1727 frame->downmix_inhibit = ptr[4] & 0x80 ? true : false; 1728 1729 return 0; 1730 } 1731 1732 /** 1733 * hdmi_vendor_any_infoframe_unpack() - unpack binary buffer to a HDMI 1734 * vendor infoframe 1735 * @frame: HDMI Vendor infoframe 1736 * @buffer: source buffer 1737 * @size: size of buffer 1738 * 1739 * Unpacks the information contained in binary @buffer into a structured 1740 * @frame of the HDMI Vendor information frame. 1741 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1742 * specification. 1743 * 1744 * Returns 0 on success or a negative error code on failure. 1745 */ 1746 static int 1747 hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, 1748 const void *buffer, size_t size) 1749 { 1750 const u8 *ptr = buffer; 1751 size_t length; 1752 int ret; 1753 u8 hdmi_video_format; 1754 struct hdmi_vendor_infoframe *hvf = &frame->hdmi; 1755 1756 if (size < HDMI_INFOFRAME_HEADER_SIZE) 1757 return -EINVAL; 1758 1759 if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR || 1760 ptr[1] != 1 || 1761 (ptr[2] != 4 && ptr[2] != 5 && ptr[2] != 6)) 1762 return -EINVAL; 1763 1764 length = ptr[2]; 1765 1766 if (size < HDMI_INFOFRAME_HEADER_SIZE + length) 1767 return -EINVAL; 1768 1769 if (hdmi_infoframe_checksum(buffer, 1770 HDMI_INFOFRAME_HEADER_SIZE + length) != 0) 1771 return -EINVAL; 1772 1773 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1774 1775 /* HDMI OUI */ 1776 if ((ptr[0] != 0x03) || 1777 (ptr[1] != 0x0c) || 1778 (ptr[2] != 0x00)) 1779 return -EINVAL; 1780 1781 hdmi_video_format = ptr[3] >> 5; 1782 1783 if (hdmi_video_format > 0x2) 1784 return -EINVAL; 1785 1786 ret = hdmi_vendor_infoframe_init(hvf); 1787 if (ret) 1788 return ret; 1789 1790 hvf->length = length; 1791 1792 if (hdmi_video_format == 0x2) { 1793 if (length != 5 && length != 6) 1794 return -EINVAL; 1795 hvf->s3d_struct = ptr[4] >> 4; 1796 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) { 1797 if (length != 6) 1798 return -EINVAL; 1799 hvf->s3d_ext_data = ptr[5] >> 4; 1800 } 1801 } else if (hdmi_video_format == 0x1) { 1802 if (length != 5) 1803 return -EINVAL; 1804 hvf->vic = ptr[4]; 1805 } else { 1806 if (length != 4) 1807 return -EINVAL; 1808 } 1809 1810 return 0; 1811 } 1812 1813 /** 1814 * hdmi_drm_infoframe_unpack_only() - unpack binary buffer of CTA-861-G DRM 1815 * infoframe DataBytes to a HDMI DRM 1816 * infoframe 1817 * @frame: HDMI DRM infoframe 1818 * @buffer: source buffer 1819 * @size: size of buffer 1820 * 1821 * Unpacks CTA-861-G DRM infoframe DataBytes contained in the binary @buffer 1822 * into a structured @frame of the HDMI Dynamic Range and Mastering (DRM) 1823 * infoframe. 1824 * 1825 * Returns 0 on success or a negative error code on failure. 1826 */ 1827 int hdmi_drm_infoframe_unpack_only(struct hdmi_drm_infoframe *frame, 1828 const void *buffer, size_t size) 1829 { 1830 const u8 *ptr = buffer; 1831 const u8 *temp; 1832 u8 x_lsb, x_msb; 1833 u8 y_lsb, y_msb; 1834 int ret; 1835 int i; 1836 1837 if (size < HDMI_DRM_INFOFRAME_SIZE) 1838 return -EINVAL; 1839 1840 ret = hdmi_drm_infoframe_init(frame); 1841 if (ret) 1842 return ret; 1843 1844 frame->eotf = ptr[0] & 0x7; 1845 frame->metadata_type = ptr[1] & 0x7; 1846 1847 temp = ptr + 2; 1848 for (i = 0; i < 3; i++) { 1849 x_lsb = *temp++; 1850 x_msb = *temp++; 1851 frame->display_primaries[i].x = (x_msb << 8) | x_lsb; 1852 y_lsb = *temp++; 1853 y_msb = *temp++; 1854 frame->display_primaries[i].y = (y_msb << 8) | y_lsb; 1855 } 1856 1857 frame->white_point.x = (ptr[15] << 8) | ptr[14]; 1858 frame->white_point.y = (ptr[17] << 8) | ptr[16]; 1859 1860 frame->max_display_mastering_luminance = (ptr[19] << 8) | ptr[18]; 1861 frame->min_display_mastering_luminance = (ptr[21] << 8) | ptr[20]; 1862 frame->max_cll = (ptr[23] << 8) | ptr[22]; 1863 frame->max_fall = (ptr[25] << 8) | ptr[24]; 1864 1865 return 0; 1866 } 1867 EXPORT_SYMBOL(hdmi_drm_infoframe_unpack_only); 1868 1869 /** 1870 * hdmi_drm_infoframe_unpack() - unpack binary buffer to a HDMI DRM infoframe 1871 * @frame: HDMI DRM infoframe 1872 * @buffer: source buffer 1873 * @size: size of buffer 1874 * 1875 * Unpacks the CTA-861-G DRM infoframe contained in the binary @buffer into 1876 * a structured @frame of the HDMI Dynamic Range and Mastering (DRM) 1877 * infoframe. It also verifies the checksum as required by section 5.3.5 of 1878 * the HDMI 1.4 specification. 1879 * 1880 * Returns 0 on success or a negative error code on failure. 1881 */ 1882 static int hdmi_drm_infoframe_unpack(struct hdmi_drm_infoframe *frame, 1883 const void *buffer, size_t size) 1884 { 1885 const u8 *ptr = buffer; 1886 int ret; 1887 1888 if (size < HDMI_INFOFRAME_SIZE(DRM)) 1889 return -EINVAL; 1890 1891 if (ptr[0] != HDMI_INFOFRAME_TYPE_DRM || 1892 ptr[1] != 1 || 1893 ptr[2] != HDMI_DRM_INFOFRAME_SIZE) 1894 return -EINVAL; 1895 1896 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(DRM)) != 0) 1897 return -EINVAL; 1898 1899 ret = hdmi_drm_infoframe_unpack_only(frame, ptr + HDMI_INFOFRAME_HEADER_SIZE, 1900 size - HDMI_INFOFRAME_HEADER_SIZE); 1901 return ret; 1902 } 1903 1904 /** 1905 * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe 1906 * @frame: HDMI infoframe 1907 * @buffer: source buffer 1908 * @size: size of buffer 1909 * 1910 * Unpacks the information contained in binary buffer @buffer into a structured 1911 * @frame of a HDMI infoframe. 1912 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1913 * specification. 1914 * 1915 * Returns 0 on success or a negative error code on failure. 1916 */ 1917 int hdmi_infoframe_unpack(union hdmi_infoframe *frame, 1918 const void *buffer, size_t size) 1919 { 1920 int ret; 1921 const u8 *ptr = buffer; 1922 1923 if (size < HDMI_INFOFRAME_HEADER_SIZE) 1924 return -EINVAL; 1925 1926 switch (ptr[0]) { 1927 case HDMI_INFOFRAME_TYPE_AVI: 1928 ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer, size); 1929 break; 1930 case HDMI_INFOFRAME_TYPE_DRM: 1931 ret = hdmi_drm_infoframe_unpack(&frame->drm, buffer, size); 1932 break; 1933 case HDMI_INFOFRAME_TYPE_SPD: 1934 ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer, size); 1935 break; 1936 case HDMI_INFOFRAME_TYPE_AUDIO: 1937 ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer, size); 1938 break; 1939 case HDMI_INFOFRAME_TYPE_VENDOR: 1940 ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer, size); 1941 break; 1942 default: 1943 ret = -EINVAL; 1944 break; 1945 } 1946 1947 return ret; 1948 } 1949 EXPORT_SYMBOL(hdmi_infoframe_unpack); 1950