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