Lines Matching +full:buffer +full:- +full:size
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
35 static u8 hdmi_infoframe_checksum(const u8 *ptr, size_t size)
41 for (i = 0; i < size; i++)
44 return 256 - csum;
47 static void hdmi_infoframe_set_checksum(void *buffer, size_t size)
49 u8 *ptr = buffer;
51 ptr[3] = hdmi_infoframe_checksum(buffer, size);
55 * hdmi_avi_infoframe_init() - initialize an HDMI AVI infoframe
62 frame->type = HDMI_INFOFRAME_TYPE_AVI;
63 frame->version = 2;
64 frame->length = HDMI_AVI_INFOFRAME_SIZE;
70 if (frame->type != HDMI_INFOFRAME_TYPE_AVI ||
71 frame->version != 2 ||
72 frame->length != HDMI_AVI_INFOFRAME_SIZE)
73 return -EINVAL;
75 if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9)
76 return -EINVAL;
82 * hdmi_avi_infoframe_check() - check a HDMI AVI infoframe
97 * hdmi_avi_infoframe_pack_only() - write HDMI AVI infoframe to binary buffer
99 * @buffer: destination buffer
100 * @size: size of buffer
107 * Returns the number of bytes packed into the binary buffer or a negative
111 void *buffer, size_t size)
113 u8 *ptr = buffer;
121 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
123 if (size < length)
124 return -ENOSPC;
126 memset(buffer, 0, size);
128 ptr[0] = frame->type;
129 ptr[1] = frame->version;
130 ptr[2] = frame->length;
136 ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3);
142 if (frame->active_aspect & 0xf)
146 if (frame->top_bar || frame->bottom_bar)
149 if (frame->left_bar || frame->right_bar)
152 ptr[1] = ((frame->colorimetry & 0x3) << 6) |
153 ((frame->picture_aspect & 0x3) << 4) |
154 (frame->active_aspect & 0xf);
156 ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) |
157 ((frame->quantization_range & 0x3) << 2) |
158 (frame->nups & 0x3);
160 if (frame->itc)
163 ptr[3] = frame->video_code & 0x7f;
165 ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) |
166 ((frame->content_type & 0x3) << 4) |
167 (frame->pixel_repeat & 0xf);
169 ptr[5] = frame->top_bar & 0xff;
170 ptr[6] = (frame->top_bar >> 8) & 0xff;
171 ptr[7] = frame->bottom_bar & 0xff;
172 ptr[8] = (frame->bottom_bar >> 8) & 0xff;
173 ptr[9] = frame->left_bar & 0xff;
174 ptr[10] = (frame->left_bar >> 8) & 0xff;
175 ptr[11] = frame->right_bar & 0xff;
176 ptr[12] = (frame->right_bar >> 8) & 0xff;
178 hdmi_infoframe_set_checksum(buffer, length);
185 * hdmi_avi_infoframe_pack() - check a HDMI AVI infoframe,
186 * and write it to binary buffer
188 * @buffer: destination buffer
189 * @size: size of buffer
198 * Returns the number of bytes packed into the binary buffer or a negative
202 void *buffer, size_t size)
210 return hdmi_avi_infoframe_pack_only(frame, buffer, size);
215 * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe
229 frame->type = HDMI_INFOFRAME_TYPE_SPD;
230 frame->version = 1;
231 frame->length = HDMI_SPD_INFOFRAME_SIZE;
234 memcpy(frame->vendor, vendor, min(len, sizeof(frame->vendor)));
236 memcpy(frame->product, product, min(len, sizeof(frame->product)));
244 if (frame->type != HDMI_INFOFRAME_TYPE_SPD ||
245 frame->version != 1 ||
246 frame->length != HDMI_SPD_INFOFRAME_SIZE)
247 return -EINVAL;
253 * hdmi_spd_infoframe_check() - check a HDMI SPD infoframe
268 * hdmi_spd_infoframe_pack_only() - write HDMI SPD infoframe to binary buffer
270 * @buffer: destination buffer
271 * @size: size of buffer
278 * Returns the number of bytes packed into the binary buffer or a negative
282 void *buffer, size_t size)
284 u8 *ptr = buffer;
292 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
294 if (size < length)
295 return -ENOSPC;
297 memset(buffer, 0, size);
299 ptr[0] = frame->type;
300 ptr[1] = frame->version;
301 ptr[2] = frame->length;
307 memcpy(ptr, frame->vendor, sizeof(frame->vendor));
308 memcpy(ptr + 8, frame->product, sizeof(frame->product));
310 ptr[24] = frame->sdi;
312 hdmi_infoframe_set_checksum(buffer, length);
319 * hdmi_spd_infoframe_pack() - check a HDMI SPD infoframe,
320 * and write it to binary buffer
322 * @buffer: destination buffer
323 * @size: size of buffer
332 * Returns the number of bytes packed into the binary buffer or a negative
336 void *buffer, size_t size)
344 return hdmi_spd_infoframe_pack_only(frame, buffer, size);
349 * hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe
358 frame->type = HDMI_INFOFRAME_TYPE_AUDIO;
359 frame->version = 1;
360 frame->length = HDMI_AUDIO_INFOFRAME_SIZE;
368 if (frame->type != HDMI_INFOFRAME_TYPE_AUDIO ||
369 frame->version != 1 ||
370 frame->length != HDMI_AUDIO_INFOFRAME_SIZE)
371 return -EINVAL;
377 * hdmi_audio_infoframe_check() - check a HDMI audio infoframe
393 u8 *buffer)
397 if (frame->channels >= 2)
398 channels = frame->channels - 1;
402 buffer[0] = ((frame->coding_type & 0xf) << 4) | (channels & 0x7);
403 buffer[1] = ((frame->sample_frequency & 0x7) << 2) |
404 (frame->sample_size & 0x3);
405 buffer[2] = frame->coding_type_ext & 0x1f;
406 buffer[3] = frame->channel_allocation;
407 buffer[4] = (frame->level_shift_value & 0xf) << 3;
409 if (frame->downmix_inhibit)
410 buffer[4] |= BIT(7);
414 * hdmi_audio_infoframe_pack_only() - write HDMI audio infoframe to binary buffer
416 * @buffer: destination buffer
417 * @size: size of buffer
424 * Returns the number of bytes packed into the binary buffer or a negative
428 void *buffer, size_t size)
430 u8 *ptr = buffer;
438 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
440 if (size < length)
441 return -ENOSPC;
443 memset(buffer, 0, size);
445 ptr[0] = frame->type;
446 ptr[1] = frame->version;
447 ptr[2] = frame->length;
453 hdmi_infoframe_set_checksum(buffer, length);
460 * hdmi_audio_infoframe_pack() - check a HDMI Audio infoframe,
461 * and write it to binary buffer
463 * @buffer: destination buffer
464 * @size: size of buffer
473 * Returns the number of bytes packed into the binary buffer or a negative
477 void *buffer, size_t size)
485 return hdmi_audio_infoframe_pack_only(frame, buffer, size);
490 * hdmi_audio_infoframe_pack_for_dp - Pack a HDMI Audio infoframe for DisplayPort
511 memset(sdp->db, 0, sizeof(sdp->db));
513 /* Secondary-data packet header */
514 sdp->sdp_header.HB0 = 0;
515 sdp->sdp_header.HB1 = frame->type;
516 sdp->sdp_header.HB2 = DP_SDP_AUDIO_INFOFRAME_HB2;
517 sdp->sdp_header.HB3 = (dp_version & 0x3f) << 2;
519 hdmi_audio_infoframe_pack_payload(frame, sdp->db);
521 /* Return size = frame length + four HB for sdp_header */
522 return frame->length + 4;
527 * hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe
536 frame->type = HDMI_INFOFRAME_TYPE_VENDOR;
537 frame->version = 1;
539 frame->oui = HDMI_IEEE_OUI;
545 frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID;
546 frame->length = HDMI_VENDOR_INFOFRAME_SIZE;
555 if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
557 else if (frame->vic != 0 || frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
565 if (frame->type != HDMI_INFOFRAME_TYPE_VENDOR ||
566 frame->version != 1 ||
567 frame->oui != HDMI_IEEE_OUI)
568 return -EINVAL;
571 if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
572 return -EINVAL;
574 if (frame->length != hdmi_vendor_infoframe_length(frame))
575 return -EINVAL;
581 * hdmi_vendor_infoframe_check() - check a HDMI vendor infoframe
591 frame->length = hdmi_vendor_infoframe_length(frame);
598 * hdmi_vendor_infoframe_pack_only() - write a HDMI vendor infoframe to binary buffer
600 * @buffer: destination buffer
601 * @size: size of buffer
608 * Returns the number of bytes packed into the binary buffer or a negative
612 void *buffer, size_t size)
614 u8 *ptr = buffer;
622 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
624 if (size < length)
625 return -ENOSPC;
627 memset(buffer, 0, size);
629 ptr[0] = frame->type;
630 ptr[1] = frame->version;
631 ptr[2] = frame->length;
639 if (frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) {
641 ptr[8] = (frame->s3d_struct & 0xf) << 4;
642 if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
643 ptr[9] = (frame->s3d_ext_data & 0xf) << 4;
644 } else if (frame->vic) {
646 ptr[8] = frame->vic;
651 hdmi_infoframe_set_checksum(buffer, length);
658 * hdmi_vendor_infoframe_pack() - check a HDMI Vendor infoframe,
659 * and write it to binary buffer
661 * @buffer: destination buffer
662 * @size: size of buffer
671 * Returns the number of bytes packed into the binary buffer or a negative
675 void *buffer, size_t size)
683 return hdmi_vendor_infoframe_pack_only(frame, buffer, size);
690 if (frame->any.type != HDMI_INFOFRAME_TYPE_VENDOR ||
691 frame->any.version != 1)
692 return -EINVAL;
698 * hdmi_drm_infoframe_init() - initialize an HDMI Dynaminc Range and
708 frame->type = HDMI_INFOFRAME_TYPE_DRM;
709 frame->version = 1;
710 frame->length = HDMI_DRM_INFOFRAME_SIZE;
718 if (frame->type != HDMI_INFOFRAME_TYPE_DRM ||
719 frame->version != 1)
720 return -EINVAL;
722 if (frame->length != HDMI_DRM_INFOFRAME_SIZE)
723 return -EINVAL;
729 * hdmi_drm_infoframe_check() - check a HDMI DRM infoframe
742 * hdmi_drm_infoframe_pack_only() - write HDMI DRM infoframe to binary buffer
744 * @buffer: destination buffer
745 * @size: size of buffer
752 * Returns the number of bytes packed into the binary buffer or a negative
756 void *buffer, size_t size)
758 u8 *ptr = buffer;
762 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
764 if (size < length)
765 return -ENOSPC;
767 memset(buffer, 0, size);
769 ptr[0] = frame->type;
770 ptr[1] = frame->version;
771 ptr[2] = frame->length;
777 *ptr++ = frame->eotf;
778 *ptr++ = frame->metadata_type;
781 *ptr++ = frame->display_primaries[i].x;
782 *ptr++ = frame->display_primaries[i].x >> 8;
783 *ptr++ = frame->display_primaries[i].y;
784 *ptr++ = frame->display_primaries[i].y >> 8;
787 *ptr++ = frame->white_point.x;
788 *ptr++ = frame->white_point.x >> 8;
790 *ptr++ = frame->white_point.y;
791 *ptr++ = frame->white_point.y >> 8;
793 *ptr++ = frame->max_display_mastering_luminance;
794 *ptr++ = frame->max_display_mastering_luminance >> 8;
796 *ptr++ = frame->min_display_mastering_luminance;
797 *ptr++ = frame->min_display_mastering_luminance >> 8;
799 *ptr++ = frame->max_cll;
800 *ptr++ = frame->max_cll >> 8;
802 *ptr++ = frame->max_fall;
803 *ptr++ = frame->max_fall >> 8;
805 hdmi_infoframe_set_checksum(buffer, length);
812 * hdmi_drm_infoframe_pack() - check a HDMI DRM infoframe,
813 * and write it to binary buffer
815 * @buffer: destination buffer
816 * @size: size of buffer
825 * Returns the number of bytes packed into the binary buffer or a negative
829 void *buffer, size_t size)
837 return hdmi_drm_infoframe_pack_only(frame, buffer, size);
842 * hdmi_vendor_any_infoframe_check() - check a vendor infoframe
854 if (frame->any.oui != HDMI_IEEE_OUI)
855 return -EINVAL;
857 return hdmi_vendor_infoframe_check(&frame->hdmi);
861 * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer
865 void *buffer, size_t size)
874 if (frame->any.oui != HDMI_IEEE_OUI)
875 return -EINVAL;
877 return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size);
881 * hdmi_vendor_any_infoframe_pack() - check a vendor infoframe,
882 * and write it to binary buffer
886 void *buffer, size_t size)
894 return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size);
898 * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer
900 * @buffer: destination buffer
901 * @size: size of buffer
908 * Returns the number of bytes packed into the binary buffer or a negative
912 hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size)
916 switch (frame->any.type) {
918 length = hdmi_avi_infoframe_pack_only(&frame->avi,
919 buffer, size);
922 length = hdmi_drm_infoframe_pack_only(&frame->drm,
923 buffer, size);
926 length = hdmi_spd_infoframe_pack_only(&frame->spd,
927 buffer, size);
930 length = hdmi_audio_infoframe_pack_only(&frame->audio,
931 buffer, size);
934 length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor,
935 buffer, size);
938 WARN(1, "Bad infoframe type %d\n", frame->any.type);
939 length = -EINVAL;
947 * hdmi_infoframe_pack() - check a HDMI infoframe,
948 * and write it to binary buffer
950 * @buffer: destination buffer
951 * @size: size of buffer
960 * Returns the number of bytes packed into the binary buffer or a negative
965 void *buffer, size_t size)
969 switch (frame->any.type) {
971 length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size);
974 length = hdmi_drm_infoframe_pack(&frame->drm, buffer, size);
977 length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size);
980 length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size);
983 length = hdmi_vendor_any_infoframe_pack(&frame->vendor,
984 buffer, size);
987 WARN(1, "Bad infoframe type %d\n", frame->any.type);
988 length = -EINVAL;
1019 hdmi_infoframe_type_get_name(frame->type),
1020 frame->version, frame->length);
1171 return "Unknown Non-uniform Scaling";
1218 hdmi_colorspace_get_name(frame->colorspace));
1220 hdmi_scan_mode_get_name(frame->scan_mode));
1222 hdmi_colorimetry_get_name(frame->colorimetry));
1224 hdmi_picture_aspect_get_name(frame->picture_aspect));
1226 hdmi_active_aspect_get_name(frame->active_aspect));
1227 hdmi_log(" itc: %s\n", frame->itc ? "IT Content" : "No Data");
1229 hdmi_extended_colorimetry_get_name(frame->extended_colorimetry));
1231 hdmi_quantization_range_get_name(frame->quantization_range));
1232 hdmi_log(" nups: %s\n", hdmi_nups_get_name(frame->nups));
1233 hdmi_log(" video code: %u\n", frame->video_code);
1235 hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range));
1237 hdmi_content_type_get_name(frame->content_type));
1238 hdmi_log(" pixel repeat: %u\n", frame->pixel_repeat);
1240 frame->top_bar, frame->bottom_bar,
1241 frame->left_bar, frame->right_bar);
1256 return "D-VHS";
1270 return "Blu-Ray Disc (BD)";
1288 hdmi_log(" vendor: %.8s\n", frame->vendor);
1289 hdmi_log(" product: %.16s\n", frame->product);
1291 hdmi_spd_sdi_get_name(frame->sdi), frame->sdi);
1303 return "AC-3";
1321 return "DTS-HD";
1390 return "MPEG-4 HE AAC";
1392 return "MPEG-4 HE AAC v2";
1394 return "MPEG-4 AAC LC";
1398 return "MPEG-4 HE AAC + MPEG Surround";
1400 return "MPEG-4 AAC LC + MPEG Surround";
1412 if (frame->channels)
1413 hdmi_log(" channels: %u\n", frame->channels - 1);
1417 hdmi_audio_coding_type_get_name(frame->coding_type));
1418 hdmi_log(" sample size: %s\n",
1419 hdmi_audio_sample_size_get_name(frame->sample_size));
1421 hdmi_audio_sample_frequency_get_name(frame->sample_frequency));
1423 hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext));
1425 frame->channel_allocation);
1427 frame->level_shift_value);
1429 frame->downmix_inhibit ? "Yes" : "No");
1440 hdmi_log("length: %d\n", frame->length);
1441 hdmi_log("metadata type: %d\n", frame->metadata_type);
1442 hdmi_log("eotf: %d\n", frame->eotf);
1444 hdmi_log("x[%d]: %d\n", i, frame->display_primaries[i].x);
1445 hdmi_log("y[%d]: %d\n", i, frame->display_primaries[i].y);
1448 hdmi_log("white point x: %d\n", frame->white_point.x);
1449 hdmi_log("white point y: %d\n", frame->white_point.y);
1452 frame->max_display_mastering_luminance);
1454 frame->min_display_mastering_luminance);
1456 hdmi_log("max_cll: %d\n", frame->max_cll);
1457 hdmi_log("max_fall: %d\n", frame->max_fall);
1474 return "Side-by-side (Full)";
1478 return "L + Depth + Graphics + Graphics-depth";
1480 return "Top-and-Bottom";
1482 return "Side-by-side (Half)";
1494 const struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1499 if (frame->any.oui != HDMI_IEEE_OUI) {
1503 if (hvf->vic == 0 && hvf->s3d_struct == HDMI_3D_STRUCTURE_INVALID) {
1508 if (hvf->vic)
1509 hdmi_log(" HDMI VIC: %u\n", hvf->vic);
1510 if (hvf->s3d_struct != HDMI_3D_STRUCTURE_INVALID) {
1512 hdmi_3d_structure_get_name(hvf->s3d_struct));
1513 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
1515 hvf->s3d_ext_data);
1520 * hdmi_infoframe_log() - log info of HDMI infoframe
1529 switch (frame->any.type) {
1531 hdmi_avi_infoframe_log(level, dev, &frame->avi);
1534 hdmi_spd_infoframe_log(level, dev, &frame->spd);
1537 hdmi_audio_infoframe_log(level, dev, &frame->audio);
1540 hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor);
1543 hdmi_drm_infoframe_log(level, dev, &frame->drm);
1550 * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe
1552 * @buffer: source buffer
1553 * @size: size of buffer
1555 * Unpacks the information contained in binary @buffer into a structured
1563 const void *buffer, size_t size)
1565 const u8 *ptr = buffer;
1567 if (size < HDMI_INFOFRAME_SIZE(AVI))
1568 return -EINVAL;
1573 return -EINVAL;
1575 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AVI)) != 0)
1576 return -EINVAL;
1582 frame->colorspace = (ptr[0] >> 5) & 0x3;
1584 frame->active_aspect = ptr[1] & 0xf;
1586 frame->top_bar = (ptr[6] << 8) | ptr[5];
1587 frame->bottom_bar = (ptr[8] << 8) | ptr[7];
1590 frame->left_bar = (ptr[10] << 8) | ptr[9];
1591 frame->right_bar = (ptr[12] << 8) | ptr[11];
1593 frame->scan_mode = ptr[0] & 0x3;
1595 frame->colorimetry = (ptr[1] >> 6) & 0x3;
1596 frame->picture_aspect = (ptr[1] >> 4) & 0x3;
1597 frame->active_aspect = ptr[1] & 0xf;
1599 frame->itc = ptr[2] & 0x80 ? true : false;
1600 frame->extended_colorimetry = (ptr[2] >> 4) & 0x7;
1601 frame->quantization_range = (ptr[2] >> 2) & 0x3;
1602 frame->nups = ptr[2] & 0x3;
1604 frame->video_code = ptr[3] & 0x7f;
1605 frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3;
1606 frame->content_type = (ptr[4] >> 4) & 0x3;
1608 frame->pixel_repeat = ptr[4] & 0xf;
1614 * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe
1616 * @buffer: source buffer
1617 * @size: size of buffer
1619 * Unpacks the information contained in binary @buffer into a structured
1627 const void *buffer, size_t size)
1629 const u8 *ptr = buffer;
1632 if (size < HDMI_INFOFRAME_SIZE(SPD))
1633 return -EINVAL;
1638 return -EINVAL;
1641 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(SPD)) != 0)
1642 return -EINVAL;
1650 frame->sdi = ptr[24];
1656 * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe
1658 * @buffer: source buffer
1659 * @size: size of buffer
1661 * Unpacks the information contained in binary @buffer into a structured
1669 const void *buffer, size_t size)
1671 const u8 *ptr = buffer;
1674 if (size < HDMI_INFOFRAME_SIZE(AUDIO))
1675 return -EINVAL;
1680 return -EINVAL;
1683 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AUDIO)) != 0)
1684 return -EINVAL;
1692 frame->channels = ptr[0] & 0x7;
1693 frame->coding_type = (ptr[0] >> 4) & 0xf;
1694 frame->sample_size = ptr[1] & 0x3;
1695 frame->sample_frequency = (ptr[1] >> 2) & 0x7;
1696 frame->coding_type_ext = ptr[2] & 0x1f;
1697 frame->channel_allocation = ptr[3];
1698 frame->level_shift_value = (ptr[4] >> 3) & 0xf;
1699 frame->downmix_inhibit = ptr[4] & 0x80 ? true : false;
1705 * hdmi_vendor_any_infoframe_unpack() - unpack binary buffer to a HDMI
1708 * @buffer: source buffer
1709 * @size: size of buffer
1711 * Unpacks the information contained in binary @buffer into a structured
1720 const void *buffer, size_t size)
1722 const u8 *ptr = buffer;
1726 struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1728 if (size < HDMI_INFOFRAME_HEADER_SIZE)
1729 return -EINVAL;
1734 return -EINVAL;
1738 if (size < HDMI_INFOFRAME_HEADER_SIZE + length)
1739 return -EINVAL;
1741 if (hdmi_infoframe_checksum(buffer,
1743 return -EINVAL;
1751 return -EINVAL;
1756 return -EINVAL;
1762 hvf->length = length;
1766 return -EINVAL;
1767 hvf->s3d_struct = ptr[4] >> 4;
1768 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) {
1770 return -EINVAL;
1771 hvf->s3d_ext_data = ptr[5] >> 4;
1775 return -EINVAL;
1776 hvf->vic = ptr[4];
1779 return -EINVAL;
1786 * hdmi_drm_infoframe_unpack_only() - unpack binary buffer of CTA-861-G DRM
1790 * @buffer: source buffer
1791 * @size: size of buffer
1793 * Unpacks CTA-861-G DRM infoframe DataBytes contained in the binary @buffer
1800 const void *buffer, size_t size)
1802 const u8 *ptr = buffer;
1809 if (size < HDMI_DRM_INFOFRAME_SIZE)
1810 return -EINVAL;
1816 frame->eotf = ptr[0] & 0x7;
1817 frame->metadata_type = ptr[1] & 0x7;
1823 frame->display_primaries[i].x = (x_msb << 8) | x_lsb;
1826 frame->display_primaries[i].y = (y_msb << 8) | y_lsb;
1829 frame->white_point.x = (ptr[15] << 8) | ptr[14];
1830 frame->white_point.y = (ptr[17] << 8) | ptr[16];
1832 frame->max_display_mastering_luminance = (ptr[19] << 8) | ptr[18];
1833 frame->min_display_mastering_luminance = (ptr[21] << 8) | ptr[20];
1834 frame->max_cll = (ptr[23] << 8) | ptr[22];
1835 frame->max_fall = (ptr[25] << 8) | ptr[24];
1842 * hdmi_drm_infoframe_unpack() - unpack binary buffer to a HDMI DRM infoframe
1844 * @buffer: source buffer
1845 * @size: size of buffer
1847 * Unpacks the CTA-861-G DRM infoframe contained in the binary @buffer into
1855 const void *buffer, size_t size)
1857 const u8 *ptr = buffer;
1860 if (size < HDMI_INFOFRAME_SIZE(DRM))
1861 return -EINVAL;
1866 return -EINVAL;
1868 if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(DRM)) != 0)
1869 return -EINVAL;
1872 size - HDMI_INFOFRAME_HEADER_SIZE);
1877 * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe
1879 * @buffer: source buffer
1880 * @size: size of buffer
1882 * Unpacks the information contained in binary buffer @buffer into a structured
1890 const void *buffer, size_t size)
1893 const u8 *ptr = buffer;
1895 if (size < HDMI_INFOFRAME_HEADER_SIZE)
1896 return -EINVAL;
1900 ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer, size);
1903 ret = hdmi_drm_infoframe_unpack(&frame->drm, buffer, size);
1906 ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer, size);
1909 ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer, size);
1912 ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer, size);
1915 ret = -EINVAL;