| @@ -650,6 +650,150 @@ hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe *fram · 649 unmodified lines |
| 650 | 650 | return 0; |
| 651 | 651 | } |
| 652 | 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 | + |
| 653 | 797 | /* |
| 654 | 798 | * hdmi_vendor_any_infoframe_check() - check a vendor infoframe |
| 655 | 799 | */ |
| @@ -758,6 +902,10 @@ hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t · 102 unmodified lines |
| 758 | 902 | length = hdmi_avi_infoframe_pack_only(&frame->avi, |
| 759 | 903 | buffer, size); |
| 760 | 904 | break; |
| 905 | + case HDMI_INFOFRAME_TYPE_DRM: |
| 906 | + length = hdmi_drm_infoframe_pack_only(&frame->drm, |
| 907 | + buffer, size); |
| 908 | + break; |
| 761 | 909 | case HDMI_INFOFRAME_TYPE_SPD: |
| 762 | 910 | length = hdmi_spd_infoframe_pack_only(&frame->spd, |
| 763 | 911 | buffer, size); |
| @@ -806,6 +954,9 @@ hdmi_infoframe_pack(union hdmi_infoframe *frame, · 42 unmodified lines |
| 806 | 954 | case HDMI_INFOFRAME_TYPE_AVI: |
| 807 | 955 | length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size); |
| 808 | 956 | break; |
| 957 | + case HDMI_INFOFRAME_TYPE_DRM: |
| 958 | + length = hdmi_drm_infoframe_pack(&frame->drm, buffer, size); |
| 959 | + break; |
| 809 | 960 | case HDMI_INFOFRAME_TYPE_SPD: |
| 810 | 961 | length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size); |
| 811 | 962 | break; |
| @@ -838,6 +989,8 @@ static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type) · 26 unmodified lines |
| 838 | 989 | return "Source Product Description (SPD)"; |
| 839 | 990 | case HDMI_INFOFRAME_TYPE_AUDIO: |
| 840 | 991 | return "Audio"; |
| 992 | + case HDMI_INFOFRAME_TYPE_DRM: |
| 993 | + return "Dynamic Range and Mastering"; |
| 841 | 994 | } |
| 842 | 995 | return "Reserved"; |
| 843 | 996 | } |
| @@ -1284,6 +1437,40 @@ static void hdmi_audio_infoframe_log(const char *level, · 440 unmodified lines |
| 1284 | 1437 | frame->downmix_inhibit ? "Yes" : "No"); |
| 1285 | 1438 | } |
| 1286 | 1439 | |
| 1440 | +/** |
| 1441 | + * hdmi_drm_infoframe_log() - log info of HDMI DRM infoframe |
| 1442 | + * @level: logging level |
| 1443 | + * @dev: device |
| 1444 | + * @frame: HDMI DRM infoframe |
| 1445 | + */ |
| 1446 | +static void hdmi_drm_infoframe_log(const char *level, |
| 1447 | + struct device *dev, |
| 1448 | + const struct hdmi_drm_infoframe *frame) |
| 1449 | +{ |
| 1450 | + int i; |
| 1451 | + |
| 1452 | + hdmi_infoframe_log_header(level, dev, |
| 1453 | + (struct hdmi_any_infoframe *)frame); |
| 1454 | + hdmi_log("length: %d\n", frame->length); |
| 1455 | + hdmi_log("metadata type: %d\n", frame->metadata_type); |
| 1456 | + hdmi_log("eotf: %d\n", frame->eotf); |
| 1457 | + for (i = 0; i < 3; i++) { |
| 1458 | + hdmi_log("x[%d]: %d\n", i, frame->display_primaries[i].x); |
| 1459 | + hdmi_log("y[%d]: %d\n", i, frame->display_primaries[i].y); |
| 1460 | + } |
| 1461 | + |
| 1462 | + hdmi_log("white point x: %d\n", frame->white_point.x); |
| 1463 | + hdmi_log("white point y: %d\n", frame->white_point.y); |
| 1464 | + |
| 1465 | + hdmi_log("max_display_mastering_luminance: %d\n", |
| 1466 | + frame->max_display_mastering_luminance); |
| 1467 | + hdmi_log("min_display_mastering_luminance: %d\n", |
| 1468 | + frame->min_display_mastering_luminance); |
| 1469 | + |
| 1470 | + hdmi_log("max_cll: %d\n", frame->max_cll); |
| 1471 | + hdmi_log("max_fall: %d\n", frame->max_fall); |
| 1472 | +} |
| 1473 | + |
| 1287 | 1474 | static const char * |
| 1288 | 1475 | hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct) |
| 1289 | 1476 | { |
| @@ -1372,6 +1559,9 @@ void hdmi_infoframe_log(const char *level, · 82 unmodified lines |
| 1372 | 1559 | case HDMI_INFOFRAME_TYPE_VENDOR: |
| 1373 | 1560 | hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor); |
| 1374 | 1561 | break; |
| 1562 | + case HDMI_INFOFRAME_TYPE_DRM: |
| 1563 | + hdmi_drm_infoframe_log(level, dev, &frame->drm); |
| 1564 | + break; |
| 1375 | 1565 | } |
| 1376 | 1566 | } |
| 1377 | 1567 | EXPORT_SYMBOL(hdmi_infoframe_log); |