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(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 * Returns 0 on success or a negative error code on failure. 58 */ 59 int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame) 60 { 61 memset(frame, 0, sizeof(*frame)); 62 63 frame->type = HDMI_INFOFRAME_TYPE_AVI; 64 frame->version = 2; 65 frame->length = HDMI_AVI_INFOFRAME_SIZE; 66 67 return 0; 68 } 69 EXPORT_SYMBOL(hdmi_avi_infoframe_init); 70 71 /** 72 * hdmi_avi_infoframe_pack() - write HDMI AVI infoframe to binary buffer 73 * @frame: HDMI AVI infoframe 74 * @buffer: destination buffer 75 * @size: size of buffer 76 * 77 * Packs the information contained in the @frame structure into a binary 78 * representation that can be written into the corresponding controller 79 * registers. Also computes the checksum as required by section 5.3.5 of 80 * the HDMI 1.4 specification. 81 * 82 * Returns the number of bytes packed into the binary buffer or a negative 83 * error code on failure. 84 */ 85 ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, 86 size_t size) 87 { 88 u8 *ptr = buffer; 89 size_t length; 90 91 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; 92 93 if (size < length) 94 return -ENOSPC; 95 96 memset(buffer, 0, size); 97 98 ptr[0] = frame->type; 99 ptr[1] = frame->version; 100 ptr[2] = frame->length; 101 ptr[3] = 0; /* checksum */ 102 103 /* start infoframe payload */ 104 ptr += HDMI_INFOFRAME_HEADER_SIZE; 105 106 ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3); 107 108 /* 109 * Data byte 1, bit 4 has to be set if we provide the active format 110 * aspect ratio 111 */ 112 if (frame->active_aspect & 0xf) 113 ptr[0] |= BIT(4); 114 115 /* Bit 3 and 2 indicate if we transmit horizontal/vertical bar data */ 116 if (frame->top_bar || frame->bottom_bar) 117 ptr[0] |= BIT(3); 118 119 if (frame->left_bar || frame->right_bar) 120 ptr[0] |= BIT(2); 121 122 ptr[1] = ((frame->colorimetry & 0x3) << 6) | 123 ((frame->picture_aspect & 0x3) << 4) | 124 (frame->active_aspect & 0xf); 125 126 ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) | 127 ((frame->quantization_range & 0x3) << 2) | 128 (frame->nups & 0x3); 129 130 if (frame->itc) 131 ptr[2] |= BIT(7); 132 133 ptr[3] = frame->video_code & 0x7f; 134 135 ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) | 136 ((frame->content_type & 0x3) << 4) | 137 (frame->pixel_repeat & 0xf); 138 139 ptr[5] = frame->top_bar & 0xff; 140 ptr[6] = (frame->top_bar >> 8) & 0xff; 141 ptr[7] = frame->bottom_bar & 0xff; 142 ptr[8] = (frame->bottom_bar >> 8) & 0xff; 143 ptr[9] = frame->left_bar & 0xff; 144 ptr[10] = (frame->left_bar >> 8) & 0xff; 145 ptr[11] = frame->right_bar & 0xff; 146 ptr[12] = (frame->right_bar >> 8) & 0xff; 147 148 hdmi_infoframe_set_checksum(buffer, length); 149 150 return length; 151 } 152 EXPORT_SYMBOL(hdmi_avi_infoframe_pack); 153 154 /** 155 * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe 156 * @frame: HDMI SPD infoframe 157 * @vendor: vendor string 158 * @product: product string 159 * 160 * Returns 0 on success or a negative error code on failure. 161 */ 162 int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, 163 const char *vendor, const char *product) 164 { 165 memset(frame, 0, sizeof(*frame)); 166 167 frame->type = HDMI_INFOFRAME_TYPE_SPD; 168 frame->version = 1; 169 frame->length = HDMI_SPD_INFOFRAME_SIZE; 170 171 strncpy(frame->vendor, vendor, sizeof(frame->vendor)); 172 strncpy(frame->product, product, sizeof(frame->product)); 173 174 return 0; 175 } 176 EXPORT_SYMBOL(hdmi_spd_infoframe_init); 177 178 /** 179 * hdmi_spd_infoframe_pack() - write HDMI SPD infoframe to binary buffer 180 * @frame: HDMI SPD infoframe 181 * @buffer: destination buffer 182 * @size: size of buffer 183 * 184 * Packs the information contained in the @frame structure into a binary 185 * representation that can be written into the corresponding controller 186 * registers. Also computes the checksum as required by section 5.3.5 of 187 * the HDMI 1.4 specification. 188 * 189 * Returns the number of bytes packed into the binary buffer or a negative 190 * error code on failure. 191 */ 192 ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, 193 size_t size) 194 { 195 u8 *ptr = buffer; 196 size_t length; 197 198 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; 199 200 if (size < length) 201 return -ENOSPC; 202 203 memset(buffer, 0, size); 204 205 ptr[0] = frame->type; 206 ptr[1] = frame->version; 207 ptr[2] = frame->length; 208 ptr[3] = 0; /* checksum */ 209 210 /* start infoframe payload */ 211 ptr += HDMI_INFOFRAME_HEADER_SIZE; 212 213 memcpy(ptr, frame->vendor, sizeof(frame->vendor)); 214 memcpy(ptr + 8, frame->product, sizeof(frame->product)); 215 216 ptr[24] = frame->sdi; 217 218 hdmi_infoframe_set_checksum(buffer, length); 219 220 return length; 221 } 222 EXPORT_SYMBOL(hdmi_spd_infoframe_pack); 223 224 /** 225 * hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe 226 * @frame: HDMI audio infoframe 227 * 228 * Returns 0 on success or a negative error code on failure. 229 */ 230 int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame) 231 { 232 memset(frame, 0, sizeof(*frame)); 233 234 frame->type = HDMI_INFOFRAME_TYPE_AUDIO; 235 frame->version = 1; 236 frame->length = HDMI_AUDIO_INFOFRAME_SIZE; 237 238 return 0; 239 } 240 EXPORT_SYMBOL(hdmi_audio_infoframe_init); 241 242 /** 243 * hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer 244 * @frame: HDMI audio infoframe 245 * @buffer: destination buffer 246 * @size: size of buffer 247 * 248 * Packs the information contained in the @frame structure into a binary 249 * representation that can be written into the corresponding controller 250 * registers. Also computes the checksum as required by section 5.3.5 of 251 * the HDMI 1.4 specification. 252 * 253 * Returns the number of bytes packed into the binary buffer or a negative 254 * error code on failure. 255 */ 256 ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, 257 void *buffer, size_t size) 258 { 259 unsigned char channels; 260 u8 *ptr = buffer; 261 size_t length; 262 263 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; 264 265 if (size < length) 266 return -ENOSPC; 267 268 memset(buffer, 0, size); 269 270 if (frame->channels >= 2) 271 channels = frame->channels - 1; 272 else 273 channels = 0; 274 275 ptr[0] = frame->type; 276 ptr[1] = frame->version; 277 ptr[2] = frame->length; 278 ptr[3] = 0; /* checksum */ 279 280 /* start infoframe payload */ 281 ptr += HDMI_INFOFRAME_HEADER_SIZE; 282 283 ptr[0] = ((frame->coding_type & 0xf) << 4) | (channels & 0x7); 284 ptr[1] = ((frame->sample_frequency & 0x7) << 2) | 285 (frame->sample_size & 0x3); 286 ptr[2] = frame->coding_type_ext & 0x1f; 287 ptr[3] = frame->channel_allocation; 288 ptr[4] = (frame->level_shift_value & 0xf) << 3; 289 290 if (frame->downmix_inhibit) 291 ptr[4] |= BIT(7); 292 293 hdmi_infoframe_set_checksum(buffer, length); 294 295 return length; 296 } 297 EXPORT_SYMBOL(hdmi_audio_infoframe_pack); 298 299 /** 300 * hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe 301 * @frame: HDMI vendor infoframe 302 * 303 * Returns 0 on success or a negative error code on failure. 304 */ 305 int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame) 306 { 307 memset(frame, 0, sizeof(*frame)); 308 309 frame->type = HDMI_INFOFRAME_TYPE_VENDOR; 310 frame->version = 1; 311 312 frame->oui = HDMI_IEEE_OUI; 313 314 /* 315 * 0 is a valid value for s3d_struct, so we use a special "not set" 316 * value 317 */ 318 frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID; 319 320 return 0; 321 } 322 EXPORT_SYMBOL(hdmi_vendor_infoframe_init); 323 324 static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *frame) 325 { 326 /* for side by side (half) we also need to provide 3D_Ext_Data */ 327 if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) 328 return 6; 329 else if (frame->vic != 0 || frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) 330 return 5; 331 else 332 return 4; 333 } 334 335 /** 336 * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer 337 * @frame: HDMI infoframe 338 * @buffer: destination buffer 339 * @size: size of buffer 340 * 341 * Packs the information contained in the @frame structure into a binary 342 * representation that can be written into the corresponding controller 343 * registers. Also computes the checksum as required by section 5.3.5 of 344 * the HDMI 1.4 specification. 345 * 346 * Returns the number of bytes packed into the binary buffer or a negative 347 * error code on failure. 348 */ 349 ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, 350 void *buffer, size_t size) 351 { 352 u8 *ptr = buffer; 353 size_t length; 354 355 /* only one of those can be supplied */ 356 if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) 357 return -EINVAL; 358 359 frame->length = hdmi_vendor_infoframe_length(frame); 360 361 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; 362 363 if (size < length) 364 return -ENOSPC; 365 366 memset(buffer, 0, size); 367 368 ptr[0] = frame->type; 369 ptr[1] = frame->version; 370 ptr[2] = frame->length; 371 ptr[3] = 0; /* checksum */ 372 373 /* HDMI OUI */ 374 ptr[4] = 0x03; 375 ptr[5] = 0x0c; 376 ptr[6] = 0x00; 377 378 if (frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) { 379 ptr[7] = 0x2 << 5; /* video format */ 380 ptr[8] = (frame->s3d_struct & 0xf) << 4; 381 if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) 382 ptr[9] = (frame->s3d_ext_data & 0xf) << 4; 383 } else if (frame->vic) { 384 ptr[7] = 0x1 << 5; /* video format */ 385 ptr[8] = frame->vic; 386 } else { 387 ptr[7] = 0x0 << 5; /* video format */ 388 } 389 390 hdmi_infoframe_set_checksum(buffer, length); 391 392 return length; 393 } 394 EXPORT_SYMBOL(hdmi_vendor_infoframe_pack); 395 396 /* 397 * hdmi_vendor_any_infoframe_pack() - write a vendor infoframe to binary buffer 398 */ 399 static ssize_t 400 hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, 401 void *buffer, size_t size) 402 { 403 /* we only know about HDMI vendor infoframes */ 404 if (frame->any.oui != HDMI_IEEE_OUI) 405 return -EINVAL; 406 407 return hdmi_vendor_infoframe_pack(&frame->hdmi, buffer, size); 408 } 409 410 /** 411 * hdmi_infoframe_pack() - write a HDMI infoframe to binary buffer 412 * @frame: HDMI infoframe 413 * @buffer: destination buffer 414 * @size: size of buffer 415 * 416 * Packs the information contained in the @frame structure into a binary 417 * representation that can be written into the corresponding controller 418 * registers. Also computes the checksum as required by section 5.3.5 of 419 * the HDMI 1.4 specification. 420 * 421 * Returns the number of bytes packed into the binary buffer or a negative 422 * error code on failure. 423 */ 424 ssize_t 425 hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size) 426 { 427 ssize_t length; 428 429 switch (frame->any.type) { 430 case HDMI_INFOFRAME_TYPE_AVI: 431 length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size); 432 break; 433 case HDMI_INFOFRAME_TYPE_SPD: 434 length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size); 435 break; 436 case HDMI_INFOFRAME_TYPE_AUDIO: 437 length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size); 438 break; 439 case HDMI_INFOFRAME_TYPE_VENDOR: 440 length = hdmi_vendor_any_infoframe_pack(&frame->vendor, 441 buffer, size); 442 break; 443 default: 444 WARN(1, "Bad infoframe type %d\n", frame->any.type); 445 length = -EINVAL; 446 } 447 448 return length; 449 } 450 EXPORT_SYMBOL(hdmi_infoframe_pack); 451 452 static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type) 453 { 454 if (type < 0x80 || type > 0x9f) 455 return "Invalid"; 456 switch (type) { 457 case HDMI_INFOFRAME_TYPE_VENDOR: 458 return "Vendor"; 459 case HDMI_INFOFRAME_TYPE_AVI: 460 return "Auxiliary Video Information (AVI)"; 461 case HDMI_INFOFRAME_TYPE_SPD: 462 return "Source Product Description (SPD)"; 463 case HDMI_INFOFRAME_TYPE_AUDIO: 464 return "Audio"; 465 } 466 return "Reserved"; 467 } 468 469 static void hdmi_infoframe_log_header(const char *level, 470 struct device *dev, 471 struct hdmi_any_infoframe *frame) 472 { 473 hdmi_log("HDMI infoframe: %s, version %u, length %u\n", 474 hdmi_infoframe_type_get_name(frame->type), 475 frame->version, frame->length); 476 } 477 478 static const char *hdmi_colorspace_get_name(enum hdmi_colorspace colorspace) 479 { 480 switch (colorspace) { 481 case HDMI_COLORSPACE_RGB: 482 return "RGB"; 483 case HDMI_COLORSPACE_YUV422: 484 return "YCbCr 4:2:2"; 485 case HDMI_COLORSPACE_YUV444: 486 return "YCbCr 4:4:4"; 487 case HDMI_COLORSPACE_YUV420: 488 return "YCbCr 4:2:0"; 489 case HDMI_COLORSPACE_RESERVED4: 490 return "Reserved (4)"; 491 case HDMI_COLORSPACE_RESERVED5: 492 return "Reserved (5)"; 493 case HDMI_COLORSPACE_RESERVED6: 494 return "Reserved (6)"; 495 case HDMI_COLORSPACE_IDO_DEFINED: 496 return "IDO Defined"; 497 } 498 return "Invalid"; 499 } 500 501 static const char *hdmi_scan_mode_get_name(enum hdmi_scan_mode scan_mode) 502 { 503 switch (scan_mode) { 504 case HDMI_SCAN_MODE_NONE: 505 return "No Data"; 506 case HDMI_SCAN_MODE_OVERSCAN: 507 return "Overscan"; 508 case HDMI_SCAN_MODE_UNDERSCAN: 509 return "Underscan"; 510 case HDMI_SCAN_MODE_RESERVED: 511 return "Reserved"; 512 } 513 return "Invalid"; 514 } 515 516 static const char *hdmi_colorimetry_get_name(enum hdmi_colorimetry colorimetry) 517 { 518 switch (colorimetry) { 519 case HDMI_COLORIMETRY_NONE: 520 return "No Data"; 521 case HDMI_COLORIMETRY_ITU_601: 522 return "ITU601"; 523 case HDMI_COLORIMETRY_ITU_709: 524 return "ITU709"; 525 case HDMI_COLORIMETRY_EXTENDED: 526 return "Extended"; 527 } 528 return "Invalid"; 529 } 530 531 static const char * 532 hdmi_picture_aspect_get_name(enum hdmi_picture_aspect picture_aspect) 533 { 534 switch (picture_aspect) { 535 case HDMI_PICTURE_ASPECT_NONE: 536 return "No Data"; 537 case HDMI_PICTURE_ASPECT_4_3: 538 return "4:3"; 539 case HDMI_PICTURE_ASPECT_16_9: 540 return "16:9"; 541 case HDMI_PICTURE_ASPECT_64_27: 542 return "64:27"; 543 case HDMI_PICTURE_ASPECT_256_135: 544 return "256:135"; 545 case HDMI_PICTURE_ASPECT_RESERVED: 546 return "Reserved"; 547 } 548 return "Invalid"; 549 } 550 551 static const char * 552 hdmi_active_aspect_get_name(enum hdmi_active_aspect active_aspect) 553 { 554 if (active_aspect < 0 || active_aspect > 0xf) 555 return "Invalid"; 556 557 switch (active_aspect) { 558 case HDMI_ACTIVE_ASPECT_16_9_TOP: 559 return "16:9 Top"; 560 case HDMI_ACTIVE_ASPECT_14_9_TOP: 561 return "14:9 Top"; 562 case HDMI_ACTIVE_ASPECT_16_9_CENTER: 563 return "16:9 Center"; 564 case HDMI_ACTIVE_ASPECT_PICTURE: 565 return "Same as Picture"; 566 case HDMI_ACTIVE_ASPECT_4_3: 567 return "4:3"; 568 case HDMI_ACTIVE_ASPECT_16_9: 569 return "16:9"; 570 case HDMI_ACTIVE_ASPECT_14_9: 571 return "14:9"; 572 case HDMI_ACTIVE_ASPECT_4_3_SP_14_9: 573 return "4:3 SP 14:9"; 574 case HDMI_ACTIVE_ASPECT_16_9_SP_14_9: 575 return "16:9 SP 14:9"; 576 case HDMI_ACTIVE_ASPECT_16_9_SP_4_3: 577 return "16:9 SP 4:3"; 578 } 579 return "Reserved"; 580 } 581 582 static const char * 583 hdmi_extended_colorimetry_get_name(enum hdmi_extended_colorimetry ext_col) 584 { 585 switch (ext_col) { 586 case HDMI_EXTENDED_COLORIMETRY_XV_YCC_601: 587 return "xvYCC 601"; 588 case HDMI_EXTENDED_COLORIMETRY_XV_YCC_709: 589 return "xvYCC 709"; 590 case HDMI_EXTENDED_COLORIMETRY_S_YCC_601: 591 return "sYCC 601"; 592 case HDMI_EXTENDED_COLORIMETRY_ADOBE_YCC_601: 593 return "Adobe YCC 601"; 594 case HDMI_EXTENDED_COLORIMETRY_ADOBE_RGB: 595 return "Adobe RGB"; 596 case HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM: 597 return "BT.2020 Constant Luminance"; 598 case HDMI_EXTENDED_COLORIMETRY_BT2020: 599 return "BT.2020"; 600 case HDMI_EXTENDED_COLORIMETRY_RESERVED: 601 return "Reserved"; 602 } 603 return "Invalid"; 604 } 605 606 static const char * 607 hdmi_quantization_range_get_name(enum hdmi_quantization_range qrange) 608 { 609 switch (qrange) { 610 case HDMI_QUANTIZATION_RANGE_DEFAULT: 611 return "Default"; 612 case HDMI_QUANTIZATION_RANGE_LIMITED: 613 return "Limited"; 614 case HDMI_QUANTIZATION_RANGE_FULL: 615 return "Full"; 616 case HDMI_QUANTIZATION_RANGE_RESERVED: 617 return "Reserved"; 618 } 619 return "Invalid"; 620 } 621 622 static const char *hdmi_nups_get_name(enum hdmi_nups nups) 623 { 624 switch (nups) { 625 case HDMI_NUPS_UNKNOWN: 626 return "Unknown Non-uniform Scaling"; 627 case HDMI_NUPS_HORIZONTAL: 628 return "Horizontally Scaled"; 629 case HDMI_NUPS_VERTICAL: 630 return "Vertically Scaled"; 631 case HDMI_NUPS_BOTH: 632 return "Horizontally and Vertically Scaled"; 633 } 634 return "Invalid"; 635 } 636 637 static const char * 638 hdmi_ycc_quantization_range_get_name(enum hdmi_ycc_quantization_range qrange) 639 { 640 switch (qrange) { 641 case HDMI_YCC_QUANTIZATION_RANGE_LIMITED: 642 return "Limited"; 643 case HDMI_YCC_QUANTIZATION_RANGE_FULL: 644 return "Full"; 645 } 646 return "Invalid"; 647 } 648 649 static const char * 650 hdmi_content_type_get_name(enum hdmi_content_type content_type) 651 { 652 switch (content_type) { 653 case HDMI_CONTENT_TYPE_GRAPHICS: 654 return "Graphics"; 655 case HDMI_CONTENT_TYPE_PHOTO: 656 return "Photo"; 657 case HDMI_CONTENT_TYPE_CINEMA: 658 return "Cinema"; 659 case HDMI_CONTENT_TYPE_GAME: 660 return "Game"; 661 } 662 return "Invalid"; 663 } 664 665 /** 666 * hdmi_avi_infoframe_log() - log info of HDMI AVI infoframe 667 * @level: logging level 668 * @dev: device 669 * @frame: HDMI AVI infoframe 670 */ 671 static void hdmi_avi_infoframe_log(const char *level, 672 struct device *dev, 673 struct hdmi_avi_infoframe *frame) 674 { 675 hdmi_infoframe_log_header(level, dev, 676 (struct hdmi_any_infoframe *)frame); 677 678 hdmi_log(" colorspace: %s\n", 679 hdmi_colorspace_get_name(frame->colorspace)); 680 hdmi_log(" scan mode: %s\n", 681 hdmi_scan_mode_get_name(frame->scan_mode)); 682 hdmi_log(" colorimetry: %s\n", 683 hdmi_colorimetry_get_name(frame->colorimetry)); 684 hdmi_log(" picture aspect: %s\n", 685 hdmi_picture_aspect_get_name(frame->picture_aspect)); 686 hdmi_log(" active aspect: %s\n", 687 hdmi_active_aspect_get_name(frame->active_aspect)); 688 hdmi_log(" itc: %s\n", frame->itc ? "IT Content" : "No Data"); 689 hdmi_log(" extended colorimetry: %s\n", 690 hdmi_extended_colorimetry_get_name(frame->extended_colorimetry)); 691 hdmi_log(" quantization range: %s\n", 692 hdmi_quantization_range_get_name(frame->quantization_range)); 693 hdmi_log(" nups: %s\n", hdmi_nups_get_name(frame->nups)); 694 hdmi_log(" video code: %u\n", frame->video_code); 695 hdmi_log(" ycc quantization range: %s\n", 696 hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range)); 697 hdmi_log(" hdmi content type: %s\n", 698 hdmi_content_type_get_name(frame->content_type)); 699 hdmi_log(" pixel repeat: %u\n", frame->pixel_repeat); 700 hdmi_log(" bar top %u, bottom %u, left %u, right %u\n", 701 frame->top_bar, frame->bottom_bar, 702 frame->left_bar, frame->right_bar); 703 } 704 705 static const char *hdmi_spd_sdi_get_name(enum hdmi_spd_sdi sdi) 706 { 707 if (sdi < 0 || sdi > 0xff) 708 return "Invalid"; 709 switch (sdi) { 710 case HDMI_SPD_SDI_UNKNOWN: 711 return "Unknown"; 712 case HDMI_SPD_SDI_DSTB: 713 return "Digital STB"; 714 case HDMI_SPD_SDI_DVDP: 715 return "DVD Player"; 716 case HDMI_SPD_SDI_DVHS: 717 return "D-VHS"; 718 case HDMI_SPD_SDI_HDDVR: 719 return "HDD Videorecorder"; 720 case HDMI_SPD_SDI_DVC: 721 return "DVC"; 722 case HDMI_SPD_SDI_DSC: 723 return "DSC"; 724 case HDMI_SPD_SDI_VCD: 725 return "Video CD"; 726 case HDMI_SPD_SDI_GAME: 727 return "Game"; 728 case HDMI_SPD_SDI_PC: 729 return "PC General"; 730 case HDMI_SPD_SDI_BD: 731 return "Blu-Ray Disc (BD)"; 732 case HDMI_SPD_SDI_SACD: 733 return "Super Audio CD"; 734 case HDMI_SPD_SDI_HDDVD: 735 return "HD DVD"; 736 case HDMI_SPD_SDI_PMP: 737 return "PMP"; 738 } 739 return "Reserved"; 740 } 741 742 /** 743 * hdmi_spd_infoframe_log() - log info of HDMI SPD infoframe 744 * @level: logging level 745 * @dev: device 746 * @frame: HDMI SPD infoframe 747 */ 748 static void hdmi_spd_infoframe_log(const char *level, 749 struct device *dev, 750 struct hdmi_spd_infoframe *frame) 751 { 752 u8 buf[17]; 753 754 hdmi_infoframe_log_header(level, dev, 755 (struct hdmi_any_infoframe *)frame); 756 757 memset(buf, 0, sizeof(buf)); 758 759 strncpy(buf, frame->vendor, 8); 760 hdmi_log(" vendor: %s\n", buf); 761 strncpy(buf, frame->product, 16); 762 hdmi_log(" product: %s\n", buf); 763 hdmi_log(" source device information: %s (0x%x)\n", 764 hdmi_spd_sdi_get_name(frame->sdi), frame->sdi); 765 } 766 767 static const char * 768 hdmi_audio_coding_type_get_name(enum hdmi_audio_coding_type coding_type) 769 { 770 switch (coding_type) { 771 case HDMI_AUDIO_CODING_TYPE_STREAM: 772 return "Refer to Stream Header"; 773 case HDMI_AUDIO_CODING_TYPE_PCM: 774 return "PCM"; 775 case HDMI_AUDIO_CODING_TYPE_AC3: 776 return "AC-3"; 777 case HDMI_AUDIO_CODING_TYPE_MPEG1: 778 return "MPEG1"; 779 case HDMI_AUDIO_CODING_TYPE_MP3: 780 return "MP3"; 781 case HDMI_AUDIO_CODING_TYPE_MPEG2: 782 return "MPEG2"; 783 case HDMI_AUDIO_CODING_TYPE_AAC_LC: 784 return "AAC"; 785 case HDMI_AUDIO_CODING_TYPE_DTS: 786 return "DTS"; 787 case HDMI_AUDIO_CODING_TYPE_ATRAC: 788 return "ATRAC"; 789 case HDMI_AUDIO_CODING_TYPE_DSD: 790 return "One Bit Audio"; 791 case HDMI_AUDIO_CODING_TYPE_EAC3: 792 return "Dolby Digital +"; 793 case HDMI_AUDIO_CODING_TYPE_DTS_HD: 794 return "DTS-HD"; 795 case HDMI_AUDIO_CODING_TYPE_MLP: 796 return "MAT (MLP)"; 797 case HDMI_AUDIO_CODING_TYPE_DST: 798 return "DST"; 799 case HDMI_AUDIO_CODING_TYPE_WMA_PRO: 800 return "WMA PRO"; 801 case HDMI_AUDIO_CODING_TYPE_CXT: 802 return "Refer to CXT"; 803 } 804 return "Invalid"; 805 } 806 807 static const char * 808 hdmi_audio_sample_size_get_name(enum hdmi_audio_sample_size sample_size) 809 { 810 switch (sample_size) { 811 case HDMI_AUDIO_SAMPLE_SIZE_STREAM: 812 return "Refer to Stream Header"; 813 case HDMI_AUDIO_SAMPLE_SIZE_16: 814 return "16 bit"; 815 case HDMI_AUDIO_SAMPLE_SIZE_20: 816 return "20 bit"; 817 case HDMI_AUDIO_SAMPLE_SIZE_24: 818 return "24 bit"; 819 } 820 return "Invalid"; 821 } 822 823 static const char * 824 hdmi_audio_sample_frequency_get_name(enum hdmi_audio_sample_frequency freq) 825 { 826 switch (freq) { 827 case HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM: 828 return "Refer to Stream Header"; 829 case HDMI_AUDIO_SAMPLE_FREQUENCY_32000: 830 return "32 kHz"; 831 case HDMI_AUDIO_SAMPLE_FREQUENCY_44100: 832 return "44.1 kHz (CD)"; 833 case HDMI_AUDIO_SAMPLE_FREQUENCY_48000: 834 return "48 kHz"; 835 case HDMI_AUDIO_SAMPLE_FREQUENCY_88200: 836 return "88.2 kHz"; 837 case HDMI_AUDIO_SAMPLE_FREQUENCY_96000: 838 return "96 kHz"; 839 case HDMI_AUDIO_SAMPLE_FREQUENCY_176400: 840 return "176.4 kHz"; 841 case HDMI_AUDIO_SAMPLE_FREQUENCY_192000: 842 return "192 kHz"; 843 } 844 return "Invalid"; 845 } 846 847 static const char * 848 hdmi_audio_coding_type_ext_get_name(enum hdmi_audio_coding_type_ext ctx) 849 { 850 if (ctx < 0 || ctx > 0x1f) 851 return "Invalid"; 852 853 switch (ctx) { 854 case HDMI_AUDIO_CODING_TYPE_EXT_CT: 855 return "Refer to CT"; 856 case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC: 857 return "HE AAC"; 858 case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2: 859 return "HE AAC v2"; 860 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND: 861 return "MPEG SURROUND"; 862 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC: 863 return "MPEG-4 HE AAC"; 864 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2: 865 return "MPEG-4 HE AAC v2"; 866 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC: 867 return "MPEG-4 AAC LC"; 868 case HDMI_AUDIO_CODING_TYPE_EXT_DRA: 869 return "DRA"; 870 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND: 871 return "MPEG-4 HE AAC + MPEG Surround"; 872 case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND: 873 return "MPEG-4 AAC LC + MPEG Surround"; 874 } 875 return "Reserved"; 876 } 877 878 /** 879 * hdmi_audio_infoframe_log() - log info of HDMI AUDIO infoframe 880 * @level: logging level 881 * @dev: device 882 * @frame: HDMI AUDIO infoframe 883 */ 884 static void hdmi_audio_infoframe_log(const char *level, 885 struct device *dev, 886 struct hdmi_audio_infoframe *frame) 887 { 888 hdmi_infoframe_log_header(level, dev, 889 (struct hdmi_any_infoframe *)frame); 890 891 if (frame->channels) 892 hdmi_log(" channels: %u\n", frame->channels - 1); 893 else 894 hdmi_log(" channels: Refer to stream header\n"); 895 hdmi_log(" coding type: %s\n", 896 hdmi_audio_coding_type_get_name(frame->coding_type)); 897 hdmi_log(" sample size: %s\n", 898 hdmi_audio_sample_size_get_name(frame->sample_size)); 899 hdmi_log(" sample frequency: %s\n", 900 hdmi_audio_sample_frequency_get_name(frame->sample_frequency)); 901 hdmi_log(" coding type ext: %s\n", 902 hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext)); 903 hdmi_log(" channel allocation: 0x%x\n", 904 frame->channel_allocation); 905 hdmi_log(" level shift value: %u dB\n", 906 frame->level_shift_value); 907 hdmi_log(" downmix inhibit: %s\n", 908 frame->downmix_inhibit ? "Yes" : "No"); 909 } 910 911 static const char * 912 hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct) 913 { 914 if (s3d_struct < 0 || s3d_struct > 0xf) 915 return "Invalid"; 916 917 switch (s3d_struct) { 918 case HDMI_3D_STRUCTURE_FRAME_PACKING: 919 return "Frame Packing"; 920 case HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE: 921 return "Field Alternative"; 922 case HDMI_3D_STRUCTURE_LINE_ALTERNATIVE: 923 return "Line Alternative"; 924 case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL: 925 return "Side-by-side (Full)"; 926 case HDMI_3D_STRUCTURE_L_DEPTH: 927 return "L + Depth"; 928 case HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH: 929 return "L + Depth + Graphics + Graphics-depth"; 930 case HDMI_3D_STRUCTURE_TOP_AND_BOTTOM: 931 return "Top-and-Bottom"; 932 case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF: 933 return "Side-by-side (Half)"; 934 default: 935 break; 936 } 937 return "Reserved"; 938 } 939 940 /** 941 * hdmi_vendor_infoframe_log() - log info of HDMI VENDOR infoframe 942 * @level: logging level 943 * @dev: device 944 * @frame: HDMI VENDOR infoframe 945 */ 946 static void 947 hdmi_vendor_any_infoframe_log(const char *level, 948 struct device *dev, 949 union hdmi_vendor_any_infoframe *frame) 950 { 951 struct hdmi_vendor_infoframe *hvf = &frame->hdmi; 952 953 hdmi_infoframe_log_header(level, dev, 954 (struct hdmi_any_infoframe *)frame); 955 956 if (frame->any.oui != HDMI_IEEE_OUI) { 957 hdmi_log(" not a HDMI vendor infoframe\n"); 958 return; 959 } 960 if (hvf->vic == 0 && hvf->s3d_struct == HDMI_3D_STRUCTURE_INVALID) { 961 hdmi_log(" empty frame\n"); 962 return; 963 } 964 965 if (hvf->vic) 966 hdmi_log(" HDMI VIC: %u\n", hvf->vic); 967 if (hvf->s3d_struct != HDMI_3D_STRUCTURE_INVALID) { 968 hdmi_log(" 3D structure: %s\n", 969 hdmi_3d_structure_get_name(hvf->s3d_struct)); 970 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) 971 hdmi_log(" 3D extension data: %d\n", 972 hvf->s3d_ext_data); 973 } 974 } 975 976 /** 977 * hdmi_infoframe_log() - log info of HDMI infoframe 978 * @level: logging level 979 * @dev: device 980 * @frame: HDMI infoframe 981 */ 982 void hdmi_infoframe_log(const char *level, 983 struct device *dev, 984 union hdmi_infoframe *frame) 985 { 986 switch (frame->any.type) { 987 case HDMI_INFOFRAME_TYPE_AVI: 988 hdmi_avi_infoframe_log(level, dev, &frame->avi); 989 break; 990 case HDMI_INFOFRAME_TYPE_SPD: 991 hdmi_spd_infoframe_log(level, dev, &frame->spd); 992 break; 993 case HDMI_INFOFRAME_TYPE_AUDIO: 994 hdmi_audio_infoframe_log(level, dev, &frame->audio); 995 break; 996 case HDMI_INFOFRAME_TYPE_VENDOR: 997 hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor); 998 break; 999 } 1000 } 1001 EXPORT_SYMBOL(hdmi_infoframe_log); 1002 1003 /** 1004 * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe 1005 * @buffer: source buffer 1006 * @frame: HDMI AVI infoframe 1007 * 1008 * Unpacks the information contained in binary @buffer into a structured 1009 * @frame of the HDMI Auxiliary Video (AVI) information frame. 1010 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1011 * specification. 1012 * 1013 * Returns 0 on success or a negative error code on failure. 1014 */ 1015 static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame, 1016 void *buffer) 1017 { 1018 u8 *ptr = buffer; 1019 int ret; 1020 1021 if (ptr[0] != HDMI_INFOFRAME_TYPE_AVI || 1022 ptr[1] != 2 || 1023 ptr[2] != HDMI_AVI_INFOFRAME_SIZE) 1024 return -EINVAL; 1025 1026 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AVI)) != 0) 1027 return -EINVAL; 1028 1029 ret = hdmi_avi_infoframe_init(frame); 1030 if (ret) 1031 return ret; 1032 1033 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1034 1035 frame->colorspace = (ptr[0] >> 5) & 0x3; 1036 if (ptr[0] & 0x10) 1037 frame->active_aspect = ptr[1] & 0xf; 1038 if (ptr[0] & 0x8) { 1039 frame->top_bar = (ptr[5] << 8) + ptr[6]; 1040 frame->bottom_bar = (ptr[7] << 8) + ptr[8]; 1041 } 1042 if (ptr[0] & 0x4) { 1043 frame->left_bar = (ptr[9] << 8) + ptr[10]; 1044 frame->right_bar = (ptr[11] << 8) + ptr[12]; 1045 } 1046 frame->scan_mode = ptr[0] & 0x3; 1047 1048 frame->colorimetry = (ptr[1] >> 6) & 0x3; 1049 frame->picture_aspect = (ptr[1] >> 4) & 0x3; 1050 frame->active_aspect = ptr[1] & 0xf; 1051 1052 frame->itc = ptr[2] & 0x80 ? true : false; 1053 frame->extended_colorimetry = (ptr[2] >> 4) & 0x7; 1054 frame->quantization_range = (ptr[2] >> 2) & 0x3; 1055 frame->nups = ptr[2] & 0x3; 1056 1057 frame->video_code = ptr[3] & 0x7f; 1058 frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3; 1059 frame->content_type = (ptr[4] >> 4) & 0x3; 1060 1061 frame->pixel_repeat = ptr[4] & 0xf; 1062 1063 return 0; 1064 } 1065 1066 /** 1067 * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe 1068 * @buffer: source buffer 1069 * @frame: HDMI SPD infoframe 1070 * 1071 * Unpacks the information contained in binary @buffer into a structured 1072 * @frame of the HDMI Source Product Description (SPD) information frame. 1073 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1074 * specification. 1075 * 1076 * Returns 0 on success or a negative error code on failure. 1077 */ 1078 static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame, 1079 void *buffer) 1080 { 1081 u8 *ptr = buffer; 1082 int ret; 1083 1084 if (ptr[0] != HDMI_INFOFRAME_TYPE_SPD || 1085 ptr[1] != 1 || 1086 ptr[2] != HDMI_SPD_INFOFRAME_SIZE) { 1087 return -EINVAL; 1088 } 1089 1090 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(SPD)) != 0) 1091 return -EINVAL; 1092 1093 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1094 1095 ret = hdmi_spd_infoframe_init(frame, ptr, ptr + 8); 1096 if (ret) 1097 return ret; 1098 1099 frame->sdi = ptr[24]; 1100 1101 return 0; 1102 } 1103 1104 /** 1105 * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe 1106 * @buffer: source buffer 1107 * @frame: HDMI Audio infoframe 1108 * 1109 * Unpacks the information contained in binary @buffer into a structured 1110 * @frame of the HDMI Audio information frame. 1111 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1112 * specification. 1113 * 1114 * Returns 0 on success or a negative error code on failure. 1115 */ 1116 static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame, 1117 void *buffer) 1118 { 1119 u8 *ptr = buffer; 1120 int ret; 1121 1122 if (ptr[0] != HDMI_INFOFRAME_TYPE_AUDIO || 1123 ptr[1] != 1 || 1124 ptr[2] != HDMI_AUDIO_INFOFRAME_SIZE) { 1125 return -EINVAL; 1126 } 1127 1128 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AUDIO)) != 0) 1129 return -EINVAL; 1130 1131 ret = hdmi_audio_infoframe_init(frame); 1132 if (ret) 1133 return ret; 1134 1135 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1136 1137 frame->channels = ptr[0] & 0x7; 1138 frame->coding_type = (ptr[0] >> 4) & 0xf; 1139 frame->sample_size = ptr[1] & 0x3; 1140 frame->sample_frequency = (ptr[1] >> 2) & 0x7; 1141 frame->coding_type_ext = ptr[2] & 0x1f; 1142 frame->channel_allocation = ptr[3]; 1143 frame->level_shift_value = (ptr[4] >> 3) & 0xf; 1144 frame->downmix_inhibit = ptr[4] & 0x80 ? true : false; 1145 1146 return 0; 1147 } 1148 1149 /** 1150 * hdmi_vendor_infoframe_unpack() - unpack binary buffer to a HDMI vendor infoframe 1151 * @buffer: source buffer 1152 * @frame: HDMI Vendor infoframe 1153 * 1154 * Unpacks the information contained in binary @buffer into a structured 1155 * @frame of the HDMI Vendor information frame. 1156 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1157 * specification. 1158 * 1159 * Returns 0 on success or a negative error code on failure. 1160 */ 1161 static int 1162 hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, 1163 void *buffer) 1164 { 1165 u8 *ptr = buffer; 1166 size_t length; 1167 int ret; 1168 u8 hdmi_video_format; 1169 struct hdmi_vendor_infoframe *hvf = &frame->hdmi; 1170 1171 if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR || 1172 ptr[1] != 1 || 1173 (ptr[2] != 4 && ptr[2] != 5 && ptr[2] != 6)) 1174 return -EINVAL; 1175 1176 length = ptr[2]; 1177 1178 if (hdmi_infoframe_checksum(buffer, 1179 HDMI_INFOFRAME_HEADER_SIZE + length) != 0) 1180 return -EINVAL; 1181 1182 ptr += HDMI_INFOFRAME_HEADER_SIZE; 1183 1184 /* HDMI OUI */ 1185 if ((ptr[0] != 0x03) || 1186 (ptr[1] != 0x0c) || 1187 (ptr[2] != 0x00)) 1188 return -EINVAL; 1189 1190 hdmi_video_format = ptr[3] >> 5; 1191 1192 if (hdmi_video_format > 0x2) 1193 return -EINVAL; 1194 1195 ret = hdmi_vendor_infoframe_init(hvf); 1196 if (ret) 1197 return ret; 1198 1199 hvf->length = length; 1200 1201 if (hdmi_video_format == 0x2) { 1202 if (length != 5 && length != 6) 1203 return -EINVAL; 1204 hvf->s3d_struct = ptr[4] >> 4; 1205 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) { 1206 if (length != 6) 1207 return -EINVAL; 1208 hvf->s3d_ext_data = ptr[5] >> 4; 1209 } 1210 } else if (hdmi_video_format == 0x1) { 1211 if (length != 5) 1212 return -EINVAL; 1213 hvf->vic = ptr[4]; 1214 } else { 1215 if (length != 4) 1216 return -EINVAL; 1217 } 1218 1219 return 0; 1220 } 1221 1222 /** 1223 * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe 1224 * @buffer: source buffer 1225 * @frame: HDMI infoframe 1226 * 1227 * Unpacks the information contained in binary buffer @buffer into a structured 1228 * @frame of a HDMI infoframe. 1229 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 1230 * specification. 1231 * 1232 * Returns 0 on success or a negative error code on failure. 1233 */ 1234 int hdmi_infoframe_unpack(union hdmi_infoframe *frame, void *buffer) 1235 { 1236 int ret; 1237 u8 *ptr = buffer; 1238 1239 switch (ptr[0]) { 1240 case HDMI_INFOFRAME_TYPE_AVI: 1241 ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer); 1242 break; 1243 case HDMI_INFOFRAME_TYPE_SPD: 1244 ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer); 1245 break; 1246 case HDMI_INFOFRAME_TYPE_AUDIO: 1247 ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer); 1248 break; 1249 case HDMI_INFOFRAME_TYPE_VENDOR: 1250 ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer); 1251 break; 1252 default: 1253 ret = -EINVAL; 1254 break; 1255 } 1256 1257 return ret; 1258 } 1259 EXPORT_SYMBOL(hdmi_infoframe_unpack); 1260