2 * Copyright (C) 2012 Avionic Design GmbH
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:
11 * The above copyright notice and this permission notice (including the
12 * next paragraph) shall be included in all copies or substantial portions
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.
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>
32 #define hdmi_log(fmt, ...) dev_printk(level, dev, fmt, ##__VA_ARGS__)
34 static u8
hdmi_infoframe_checksum(const u8
*ptr
, size_t size
)
39 /* compute checksum */
40 for (i
= 0; i
< size
; i
++)
46 static void hdmi_infoframe_set_checksum(void *buffer
, size_t size
)
50 ptr
[3] = hdmi_infoframe_checksum(buffer
, size
);
54 * hdmi_avi_infoframe_init() - initialize an HDMI AVI infoframe
55 * @frame: HDMI AVI infoframe
57 * Returns 0 on success or a negative error code on failure.
59 int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe
*frame
)
61 memset(frame
, 0, sizeof(*frame
));
63 frame
->type
= HDMI_INFOFRAME_TYPE_AVI
;
65 frame
->length
= HDMI_AVI_INFOFRAME_SIZE
;
69 EXPORT_SYMBOL(hdmi_avi_infoframe_init
);
71 static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe
*frame
)
73 if (frame
->type
!= HDMI_INFOFRAME_TYPE_AVI
||
74 frame
->version
!= 2 ||
75 frame
->length
!= HDMI_AVI_INFOFRAME_SIZE
)
78 if (frame
->picture_aspect
> HDMI_PICTURE_ASPECT_16_9
)
85 * hdmi_avi_infoframe_check() - check a HDMI AVI infoframe
86 * @frame: HDMI AVI infoframe
88 * Validates that the infoframe is consistent and updates derived fields
89 * (eg. length) based on other fields.
91 * Returns 0 on success or a negative error code on failure.
93 int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe
*frame
)
95 return hdmi_avi_infoframe_check_only(frame
);
97 EXPORT_SYMBOL(hdmi_avi_infoframe_check
);
100 * hdmi_avi_infoframe_pack_only() - write HDMI AVI infoframe to binary buffer
101 * @frame: HDMI AVI infoframe
102 * @buffer: destination buffer
103 * @size: size of buffer
105 * Packs the information contained in the @frame structure into a binary
106 * representation that can be written into the corresponding controller
107 * registers. Also computes the checksum as required by section 5.3.5 of
108 * the HDMI 1.4 specification.
110 * Returns the number of bytes packed into the binary buffer or a negative
111 * error code on failure.
113 ssize_t
hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe
*frame
,
114 void *buffer
, size_t size
)
120 ret
= hdmi_avi_infoframe_check_only(frame
);
124 length
= HDMI_INFOFRAME_HEADER_SIZE
+ frame
->length
;
129 memset(buffer
, 0, size
);
131 ptr
[0] = frame
->type
;
132 ptr
[1] = frame
->version
;
133 ptr
[2] = frame
->length
;
134 ptr
[3] = 0; /* checksum */
136 /* start infoframe payload */
137 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
139 ptr
[0] = ((frame
->colorspace
& 0x3) << 5) | (frame
->scan_mode
& 0x3);
142 * Data byte 1, bit 4 has to be set if we provide the active format
145 if (frame
->active_aspect
& 0xf)
148 /* Bit 3 and 2 indicate if we transmit horizontal/vertical bar data */
149 if (frame
->top_bar
|| frame
->bottom_bar
)
152 if (frame
->left_bar
|| frame
->right_bar
)
155 ptr
[1] = ((frame
->colorimetry
& 0x3) << 6) |
156 ((frame
->picture_aspect
& 0x3) << 4) |
157 (frame
->active_aspect
& 0xf);
159 ptr
[2] = ((frame
->extended_colorimetry
& 0x7) << 4) |
160 ((frame
->quantization_range
& 0x3) << 2) |
166 ptr
[3] = frame
->video_code
& 0x7f;
168 ptr
[4] = ((frame
->ycc_quantization_range
& 0x3) << 6) |
169 ((frame
->content_type
& 0x3) << 4) |
170 (frame
->pixel_repeat
& 0xf);
172 ptr
[5] = frame
->top_bar
& 0xff;
173 ptr
[6] = (frame
->top_bar
>> 8) & 0xff;
174 ptr
[7] = frame
->bottom_bar
& 0xff;
175 ptr
[8] = (frame
->bottom_bar
>> 8) & 0xff;
176 ptr
[9] = frame
->left_bar
& 0xff;
177 ptr
[10] = (frame
->left_bar
>> 8) & 0xff;
178 ptr
[11] = frame
->right_bar
& 0xff;
179 ptr
[12] = (frame
->right_bar
>> 8) & 0xff;
181 hdmi_infoframe_set_checksum(buffer
, length
);
185 EXPORT_SYMBOL(hdmi_avi_infoframe_pack_only
);
188 * hdmi_avi_infoframe_pack() - check a HDMI AVI infoframe,
189 * and write it to binary buffer
190 * @frame: HDMI AVI infoframe
191 * @buffer: destination buffer
192 * @size: size of buffer
194 * Validates that the infoframe is consistent and updates derived fields
195 * (eg. length) based on other fields, after which it packs the information
196 * contained in the @frame structure into a binary representation that
197 * can be written into the corresponding controller registers. This function
198 * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
201 * Returns the number of bytes packed into the binary buffer or a negative
202 * error code on failure.
204 ssize_t
hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe
*frame
,
205 void *buffer
, size_t size
)
209 ret
= hdmi_avi_infoframe_check(frame
);
213 return hdmi_avi_infoframe_pack_only(frame
, buffer
, size
);
215 EXPORT_SYMBOL(hdmi_avi_infoframe_pack
);
218 * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe
219 * @frame: HDMI SPD infoframe
220 * @vendor: vendor string
221 * @product: product string
223 * Returns 0 on success or a negative error code on failure.
225 int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe
*frame
,
226 const char *vendor
, const char *product
)
228 memset(frame
, 0, sizeof(*frame
));
230 frame
->type
= HDMI_INFOFRAME_TYPE_SPD
;
232 frame
->length
= HDMI_SPD_INFOFRAME_SIZE
;
234 strncpy(frame
->vendor
, vendor
, sizeof(frame
->vendor
));
235 strncpy(frame
->product
, product
, sizeof(frame
->product
));
239 EXPORT_SYMBOL(hdmi_spd_infoframe_init
);
241 static int hdmi_spd_infoframe_check_only(const struct hdmi_spd_infoframe
*frame
)
243 if (frame
->type
!= HDMI_INFOFRAME_TYPE_SPD
||
244 frame
->version
!= 1 ||
245 frame
->length
!= HDMI_SPD_INFOFRAME_SIZE
)
252 * hdmi_spd_infoframe_check() - check a HDMI SPD infoframe
253 * @frame: HDMI SPD infoframe
255 * Validates that the infoframe is consistent and updates derived fields
256 * (eg. length) based on other fields.
258 * Returns 0 on success or a negative error code on failure.
260 int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe
*frame
)
262 return hdmi_spd_infoframe_check_only(frame
);
264 EXPORT_SYMBOL(hdmi_spd_infoframe_check
);
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
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.
277 * Returns the number of bytes packed into the binary buffer or a negative
278 * error code on failure.
280 ssize_t
hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe
*frame
,
281 void *buffer
, size_t size
)
287 ret
= hdmi_spd_infoframe_check_only(frame
);
291 length
= HDMI_INFOFRAME_HEADER_SIZE
+ frame
->length
;
296 memset(buffer
, 0, size
);
298 ptr
[0] = frame
->type
;
299 ptr
[1] = frame
->version
;
300 ptr
[2] = frame
->length
;
301 ptr
[3] = 0; /* checksum */
303 /* start infoframe payload */
304 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
306 memcpy(ptr
, frame
->vendor
, sizeof(frame
->vendor
));
307 memcpy(ptr
+ 8, frame
->product
, sizeof(frame
->product
));
309 ptr
[24] = frame
->sdi
;
311 hdmi_infoframe_set_checksum(buffer
, length
);
315 EXPORT_SYMBOL(hdmi_spd_infoframe_pack_only
);
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
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
331 * Returns the number of bytes packed into the binary buffer or a negative
332 * error code on failure.
334 ssize_t
hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe
*frame
,
335 void *buffer
, size_t size
)
339 ret
= hdmi_spd_infoframe_check(frame
);
343 return hdmi_spd_infoframe_pack_only(frame
, buffer
, size
);
345 EXPORT_SYMBOL(hdmi_spd_infoframe_pack
);
348 * hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe
349 * @frame: HDMI audio infoframe
351 * Returns 0 on success or a negative error code on failure.
353 int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe
*frame
)
355 memset(frame
, 0, sizeof(*frame
));
357 frame
->type
= HDMI_INFOFRAME_TYPE_AUDIO
;
359 frame
->length
= HDMI_AUDIO_INFOFRAME_SIZE
;
363 EXPORT_SYMBOL(hdmi_audio_infoframe_init
);
365 static int hdmi_audio_infoframe_check_only(const struct hdmi_audio_infoframe
*frame
)
367 if (frame
->type
!= HDMI_INFOFRAME_TYPE_AUDIO
||
368 frame
->version
!= 1 ||
369 frame
->length
!= HDMI_AUDIO_INFOFRAME_SIZE
)
376 * hdmi_audio_infoframe_check() - check a HDMI audio infoframe
377 * @frame: HDMI audio infoframe
379 * Validates that the infoframe is consistent and updates derived fields
380 * (eg. length) based on other fields.
382 * Returns 0 on success or a negative error code on failure.
384 int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe
*frame
)
386 return hdmi_audio_infoframe_check_only(frame
);
388 EXPORT_SYMBOL(hdmi_audio_infoframe_check
);
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
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.
401 * Returns the number of bytes packed into the binary buffer or a negative
402 * error code on failure.
404 ssize_t
hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe
*frame
,
405 void *buffer
, size_t size
)
407 unsigned char channels
;
412 ret
= hdmi_audio_infoframe_check_only(frame
);
416 length
= HDMI_INFOFRAME_HEADER_SIZE
+ frame
->length
;
421 memset(buffer
, 0, size
);
423 if (frame
->channels
>= 2)
424 channels
= frame
->channels
- 1;
428 ptr
[0] = frame
->type
;
429 ptr
[1] = frame
->version
;
430 ptr
[2] = frame
->length
;
431 ptr
[3] = 0; /* checksum */
433 /* start infoframe payload */
434 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
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;
443 if (frame
->downmix_inhibit
)
446 hdmi_infoframe_set_checksum(buffer
, length
);
450 EXPORT_SYMBOL(hdmi_audio_infoframe_pack_only
);
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
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
466 * Returns the number of bytes packed into the binary buffer or a negative
467 * error code on failure.
469 ssize_t
hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe
*frame
,
470 void *buffer
, size_t size
)
474 ret
= hdmi_audio_infoframe_check(frame
);
478 return hdmi_audio_infoframe_pack_only(frame
, buffer
, size
);
480 EXPORT_SYMBOL(hdmi_audio_infoframe_pack
);
483 * hdmi_vendor_infoframe_init() - initialize an HDMI vendor infoframe
484 * @frame: HDMI vendor infoframe
486 * Returns 0 on success or a negative error code on failure.
488 int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe
*frame
)
490 memset(frame
, 0, sizeof(*frame
));
492 frame
->type
= HDMI_INFOFRAME_TYPE_VENDOR
;
495 frame
->oui
= HDMI_IEEE_OUI
;
498 * 0 is a valid value for s3d_struct, so we use a special "not set"
501 frame
->s3d_struct
= HDMI_3D_STRUCTURE_INVALID
;
506 EXPORT_SYMBOL(hdmi_vendor_infoframe_init
);
508 static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe
*frame
)
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
)
513 else if (frame
->vic
!= 0 || frame
->s3d_struct
!= HDMI_3D_STRUCTURE_INVALID
)
519 static int hdmi_vendor_infoframe_check_only(const struct hdmi_vendor_infoframe
*frame
)
521 if (frame
->type
!= HDMI_INFOFRAME_TYPE_VENDOR
||
522 frame
->version
!= 1 ||
523 frame
->oui
!= HDMI_IEEE_OUI
)
526 /* only one of those can be supplied */
527 if (frame
->vic
!= 0 && frame
->s3d_struct
!= HDMI_3D_STRUCTURE_INVALID
)
530 if (frame
->length
!= hdmi_vendor_infoframe_length(frame
))
537 * hdmi_vendor_infoframe_check() - check a HDMI vendor infoframe
538 * @frame: HDMI infoframe
540 * Validates that the infoframe is consistent and updates derived fields
541 * (eg. length) based on other fields.
543 * Returns 0 on success or a negative error code on failure.
545 int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe
*frame
)
547 frame
->length
= hdmi_vendor_infoframe_length(frame
);
549 return hdmi_vendor_infoframe_check_only(frame
);
551 EXPORT_SYMBOL(hdmi_vendor_infoframe_check
);
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
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.
564 * Returns the number of bytes packed into the binary buffer or a negative
565 * error code on failure.
567 ssize_t
hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe
*frame
,
568 void *buffer
, size_t size
)
574 ret
= hdmi_vendor_infoframe_check_only(frame
);
578 length
= HDMI_INFOFRAME_HEADER_SIZE
+ frame
->length
;
583 memset(buffer
, 0, size
);
585 ptr
[0] = frame
->type
;
586 ptr
[1] = frame
->version
;
587 ptr
[2] = frame
->length
;
588 ptr
[3] = 0; /* checksum */
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 */
604 ptr
[7] = 0x0 << 5; /* video format */
607 hdmi_infoframe_set_checksum(buffer
, length
);
611 EXPORT_SYMBOL(hdmi_vendor_infoframe_pack_only
);
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
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
627 * Returns the number of bytes packed into the binary buffer or a negative
628 * error code on failure.
630 ssize_t
hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe
*frame
,
631 void *buffer
, size_t size
)
635 ret
= hdmi_vendor_infoframe_check(frame
);
639 return hdmi_vendor_infoframe_pack_only(frame
, buffer
, size
);
641 EXPORT_SYMBOL(hdmi_vendor_infoframe_pack
);
644 hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe
*frame
)
646 if (frame
->any
.type
!= HDMI_INFOFRAME_TYPE_VENDOR
||
647 frame
->any
.version
!= 1)
654 * hdmi_drm_infoframe_init() - initialize an HDMI Dynaminc Range and
655 * mastering infoframe
656 * @frame: HDMI DRM infoframe
658 * Returns 0 on success or a negative error code on failure.
660 int hdmi_drm_infoframe_init(struct hdmi_drm_infoframe
*frame
)
662 memset(frame
, 0, sizeof(*frame
));
664 frame
->type
= HDMI_INFOFRAME_TYPE_DRM
;
666 frame
->length
= HDMI_DRM_INFOFRAME_SIZE
;
670 EXPORT_SYMBOL(hdmi_drm_infoframe_init
);
672 static int hdmi_drm_infoframe_check_only(const struct hdmi_drm_infoframe
*frame
)
674 if (frame
->type
!= HDMI_INFOFRAME_TYPE_DRM
||
678 if (frame
->length
!= HDMI_DRM_INFOFRAME_SIZE
)
685 * hdmi_drm_infoframe_check() - check a HDMI DRM infoframe
686 * @frame: HDMI DRM infoframe
688 * Validates that the infoframe is consistent.
689 * Returns 0 on success or a negative error code on failure.
691 int hdmi_drm_infoframe_check(struct hdmi_drm_infoframe
*frame
)
693 return hdmi_drm_infoframe_check_only(frame
);
695 EXPORT_SYMBOL(hdmi_drm_infoframe_check
);
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
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.
708 * Returns the number of bytes packed into the binary buffer or a negative
709 * error code on failure.
711 ssize_t
hdmi_drm_infoframe_pack_only(const struct hdmi_drm_infoframe
*frame
,
712 void *buffer
, size_t size
)
718 length
= HDMI_INFOFRAME_HEADER_SIZE
+ frame
->length
;
723 memset(buffer
, 0, size
);
725 ptr
[0] = frame
->type
;
726 ptr
[1] = frame
->version
;
727 ptr
[2] = frame
->length
;
728 ptr
[3] = 0; /* checksum */
730 /* start infoframe payload */
731 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
733 *ptr
++ = frame
->eotf
;
734 *ptr
++ = frame
->metadata_type
;
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;
743 *ptr
++ = frame
->white_point
.x
;
744 *ptr
++ = frame
->white_point
.x
>> 8;
746 *ptr
++ = frame
->white_point
.y
;
747 *ptr
++ = frame
->white_point
.y
>> 8;
749 *ptr
++ = frame
->max_display_mastering_luminance
;
750 *ptr
++ = frame
->max_display_mastering_luminance
>> 8;
752 *ptr
++ = frame
->min_display_mastering_luminance
;
753 *ptr
++ = frame
->min_display_mastering_luminance
>> 8;
755 *ptr
++ = frame
->max_cll
;
756 *ptr
++ = frame
->max_cll
>> 8;
758 *ptr
++ = frame
->max_fall
;
759 *ptr
++ = frame
->max_fall
>> 8;
761 hdmi_infoframe_set_checksum(buffer
, length
);
765 EXPORT_SYMBOL(hdmi_drm_infoframe_pack_only
);
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
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
781 * Returns the number of bytes packed into the binary buffer or a negative
782 * error code on failure.
784 ssize_t
hdmi_drm_infoframe_pack(struct hdmi_drm_infoframe
*frame
,
785 void *buffer
, size_t size
)
789 ret
= hdmi_drm_infoframe_check(frame
);
793 return hdmi_drm_infoframe_pack_only(frame
, buffer
, size
);
795 EXPORT_SYMBOL(hdmi_drm_infoframe_pack
);
798 * hdmi_vendor_any_infoframe_check() - check a vendor infoframe
801 hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe
*frame
)
805 ret
= hdmi_vendor_any_infoframe_check_only(frame
);
809 /* we only know about HDMI vendor infoframes */
810 if (frame
->any
.oui
!= HDMI_IEEE_OUI
)
813 return hdmi_vendor_infoframe_check(&frame
->hdmi
);
817 * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer
820 hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe
*frame
,
821 void *buffer
, size_t size
)
825 ret
= hdmi_vendor_any_infoframe_check_only(frame
);
829 /* we only know about HDMI vendor infoframes */
830 if (frame
->any
.oui
!= HDMI_IEEE_OUI
)
833 return hdmi_vendor_infoframe_pack_only(&frame
->hdmi
, buffer
, size
);
837 * hdmi_vendor_any_infoframe_pack() - check a vendor infoframe,
838 * and write it to binary buffer
841 hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe
*frame
,
842 void *buffer
, size_t size
)
846 ret
= hdmi_vendor_any_infoframe_check(frame
);
850 return hdmi_vendor_any_infoframe_pack_only(frame
, buffer
, size
);
854 * hdmi_infoframe_check() - check a HDMI infoframe
855 * @frame: HDMI infoframe
857 * Validates that the infoframe is consistent and updates derived fields
858 * (eg. length) based on other fields.
860 * Returns 0 on success or a negative error code on failure.
863 hdmi_infoframe_check(union hdmi_infoframe
*frame
)
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
);
875 WARN(1, "Bad infoframe type %d\n", frame
->any
.type
);
879 EXPORT_SYMBOL(hdmi_infoframe_check
);
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
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.
892 * Returns the number of bytes packed into the binary buffer or a negative
893 * error code on failure.
896 hdmi_infoframe_pack_only(const union hdmi_infoframe
*frame
, void *buffer
, size_t size
)
900 switch (frame
->any
.type
) {
901 case HDMI_INFOFRAME_TYPE_AVI
:
902 length
= hdmi_avi_infoframe_pack_only(&frame
->avi
,
905 case HDMI_INFOFRAME_TYPE_DRM
:
906 length
= hdmi_drm_infoframe_pack_only(&frame
->drm
,
909 case HDMI_INFOFRAME_TYPE_SPD
:
910 length
= hdmi_spd_infoframe_pack_only(&frame
->spd
,
913 case HDMI_INFOFRAME_TYPE_AUDIO
:
914 length
= hdmi_audio_infoframe_pack_only(&frame
->audio
,
917 case HDMI_INFOFRAME_TYPE_VENDOR
:
918 length
= hdmi_vendor_any_infoframe_pack_only(&frame
->vendor
,
922 WARN(1, "Bad infoframe type %d\n", frame
->any
.type
);
928 EXPORT_SYMBOL(hdmi_infoframe_pack_only
);
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
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
944 * Returns the number of bytes packed into the binary buffer or a negative
945 * error code on failure.
948 hdmi_infoframe_pack(union hdmi_infoframe
*frame
,
949 void *buffer
, size_t size
)
953 switch (frame
->any
.type
) {
954 case HDMI_INFOFRAME_TYPE_AVI
:
955 length
= hdmi_avi_infoframe_pack(&frame
->avi
, buffer
, size
);
957 case HDMI_INFOFRAME_TYPE_DRM
:
958 length
= hdmi_drm_infoframe_pack(&frame
->drm
, buffer
, size
);
960 case HDMI_INFOFRAME_TYPE_SPD
:
961 length
= hdmi_spd_infoframe_pack(&frame
->spd
, buffer
, size
);
963 case HDMI_INFOFRAME_TYPE_AUDIO
:
964 length
= hdmi_audio_infoframe_pack(&frame
->audio
, buffer
, size
);
966 case HDMI_INFOFRAME_TYPE_VENDOR
:
967 length
= hdmi_vendor_any_infoframe_pack(&frame
->vendor
,
971 WARN(1, "Bad infoframe type %d\n", frame
->any
.type
);
977 EXPORT_SYMBOL(hdmi_infoframe_pack
);
979 static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type
)
981 if (type
< 0x80 || type
> 0x9f)
984 case HDMI_INFOFRAME_TYPE_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
:
992 case HDMI_INFOFRAME_TYPE_DRM
:
993 return "Dynamic Range and Mastering";
998 static void hdmi_infoframe_log_header(const char *level
,
1000 const struct hdmi_any_infoframe
*frame
)
1002 hdmi_log("HDMI infoframe: %s, version %u, length %u\n",
1003 hdmi_infoframe_type_get_name(frame
->type
),
1004 frame
->version
, frame
->length
);
1007 static const char *hdmi_colorspace_get_name(enum hdmi_colorspace colorspace
)
1009 switch (colorspace
) {
1010 case HDMI_COLORSPACE_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";
1030 static const char *hdmi_scan_mode_get_name(enum hdmi_scan_mode scan_mode
)
1032 switch (scan_mode
) {
1033 case HDMI_SCAN_MODE_NONE
:
1035 case HDMI_SCAN_MODE_OVERSCAN
:
1037 case HDMI_SCAN_MODE_UNDERSCAN
:
1039 case HDMI_SCAN_MODE_RESERVED
:
1045 static const char *hdmi_colorimetry_get_name(enum hdmi_colorimetry colorimetry
)
1047 switch (colorimetry
) {
1048 case HDMI_COLORIMETRY_NONE
:
1050 case HDMI_COLORIMETRY_ITU_601
:
1052 case HDMI_COLORIMETRY_ITU_709
:
1054 case HDMI_COLORIMETRY_EXTENDED
:
1061 hdmi_picture_aspect_get_name(enum hdmi_picture_aspect picture_aspect
)
1063 switch (picture_aspect
) {
1064 case HDMI_PICTURE_ASPECT_NONE
:
1066 case HDMI_PICTURE_ASPECT_4_3
:
1068 case HDMI_PICTURE_ASPECT_16_9
:
1070 case HDMI_PICTURE_ASPECT_64_27
:
1072 case HDMI_PICTURE_ASPECT_256_135
:
1074 case HDMI_PICTURE_ASPECT_RESERVED
:
1081 hdmi_active_aspect_get_name(enum hdmi_active_aspect active_aspect
)
1083 if (active_aspect
< 0 || active_aspect
> 0xf)
1086 switch (active_aspect
) {
1087 case HDMI_ACTIVE_ASPECT_16_9_TOP
:
1089 case HDMI_ACTIVE_ASPECT_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
:
1097 case HDMI_ACTIVE_ASPECT_16_9
:
1099 case HDMI_ACTIVE_ASPECT_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";
1112 hdmi_extended_colorimetry_get_name(enum hdmi_extended_colorimetry ext_col
)
1115 case HDMI_EXTENDED_COLORIMETRY_XV_YCC_601
:
1117 case HDMI_EXTENDED_COLORIMETRY_XV_YCC_709
:
1119 case HDMI_EXTENDED_COLORIMETRY_S_YCC_601
:
1121 case HDMI_EXTENDED_COLORIMETRY_OPYCC_601
:
1123 case HDMI_EXTENDED_COLORIMETRY_OPRGB
:
1125 case HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM
:
1126 return "BT.2020 Constant Luminance";
1127 case HDMI_EXTENDED_COLORIMETRY_BT2020
:
1129 case HDMI_EXTENDED_COLORIMETRY_RESERVED
:
1136 hdmi_quantization_range_get_name(enum hdmi_quantization_range qrange
)
1139 case HDMI_QUANTIZATION_RANGE_DEFAULT
:
1141 case HDMI_QUANTIZATION_RANGE_LIMITED
:
1143 case HDMI_QUANTIZATION_RANGE_FULL
:
1145 case HDMI_QUANTIZATION_RANGE_RESERVED
:
1151 static const char *hdmi_nups_get_name(enum hdmi_nups 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";
1167 hdmi_ycc_quantization_range_get_name(enum hdmi_ycc_quantization_range qrange
)
1170 case HDMI_YCC_QUANTIZATION_RANGE_LIMITED
:
1172 case HDMI_YCC_QUANTIZATION_RANGE_FULL
:
1179 hdmi_content_type_get_name(enum hdmi_content_type content_type
)
1181 switch (content_type
) {
1182 case HDMI_CONTENT_TYPE_GRAPHICS
:
1184 case HDMI_CONTENT_TYPE_PHOTO
:
1186 case HDMI_CONTENT_TYPE_CINEMA
:
1188 case HDMI_CONTENT_TYPE_GAME
:
1194 static void hdmi_avi_infoframe_log(const char *level
,
1196 const struct hdmi_avi_infoframe
*frame
)
1198 hdmi_infoframe_log_header(level
, dev
,
1199 (const struct hdmi_any_infoframe
*)frame
);
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
);
1228 static const char *hdmi_spd_sdi_get_name(enum hdmi_spd_sdi sdi
)
1230 if (sdi
< 0 || sdi
> 0xff)
1233 case HDMI_SPD_SDI_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
:
1241 case HDMI_SPD_SDI_HDDVR
:
1242 return "HDD Videorecorder";
1243 case HDMI_SPD_SDI_DVC
:
1245 case HDMI_SPD_SDI_DSC
:
1247 case HDMI_SPD_SDI_VCD
:
1249 case HDMI_SPD_SDI_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
:
1259 case HDMI_SPD_SDI_PMP
:
1265 static void hdmi_spd_infoframe_log(const char *level
,
1267 const struct hdmi_spd_infoframe
*frame
)
1271 hdmi_infoframe_log_header(level
, dev
,
1272 (const struct hdmi_any_infoframe
*)frame
);
1274 memset(buf
, 0, sizeof(buf
));
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
);
1285 hdmi_audio_coding_type_get_name(enum hdmi_audio_coding_type coding_type
)
1287 switch (coding_type
) {
1288 case HDMI_AUDIO_CODING_TYPE_STREAM
:
1289 return "Refer to Stream Header";
1290 case HDMI_AUDIO_CODING_TYPE_PCM
:
1292 case HDMI_AUDIO_CODING_TYPE_AC3
:
1294 case HDMI_AUDIO_CODING_TYPE_MPEG1
:
1296 case HDMI_AUDIO_CODING_TYPE_MP3
:
1298 case HDMI_AUDIO_CODING_TYPE_MPEG2
:
1300 case HDMI_AUDIO_CODING_TYPE_AAC_LC
:
1302 case HDMI_AUDIO_CODING_TYPE_DTS
:
1304 case HDMI_AUDIO_CODING_TYPE_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
:
1312 case HDMI_AUDIO_CODING_TYPE_MLP
:
1314 case HDMI_AUDIO_CODING_TYPE_DST
:
1316 case HDMI_AUDIO_CODING_TYPE_WMA_PRO
:
1318 case HDMI_AUDIO_CODING_TYPE_CXT
:
1319 return "Refer to CXT";
1325 hdmi_audio_sample_size_get_name(enum hdmi_audio_sample_size sample_size
)
1327 switch (sample_size
) {
1328 case HDMI_AUDIO_SAMPLE_SIZE_STREAM
:
1329 return "Refer to Stream Header";
1330 case HDMI_AUDIO_SAMPLE_SIZE_16
:
1332 case HDMI_AUDIO_SAMPLE_SIZE_20
:
1334 case HDMI_AUDIO_SAMPLE_SIZE_24
:
1341 hdmi_audio_sample_frequency_get_name(enum hdmi_audio_sample_frequency freq
)
1344 case HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM
:
1345 return "Refer to Stream Header";
1346 case HDMI_AUDIO_SAMPLE_FREQUENCY_32000
:
1348 case HDMI_AUDIO_SAMPLE_FREQUENCY_44100
:
1349 return "44.1 kHz (CD)";
1350 case HDMI_AUDIO_SAMPLE_FREQUENCY_48000
:
1352 case HDMI_AUDIO_SAMPLE_FREQUENCY_88200
:
1354 case HDMI_AUDIO_SAMPLE_FREQUENCY_96000
:
1356 case HDMI_AUDIO_SAMPLE_FREQUENCY_176400
:
1358 case HDMI_AUDIO_SAMPLE_FREQUENCY_192000
:
1365 hdmi_audio_coding_type_ext_get_name(enum hdmi_audio_coding_type_ext ctx
)
1367 if (ctx
< 0 || ctx
> 0x1f)
1371 case HDMI_AUDIO_CODING_TYPE_EXT_CT
:
1372 return "Refer to CT";
1373 case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC
:
1375 case HDMI_AUDIO_CODING_TYPE_EXT_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
:
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";
1395 static void hdmi_audio_infoframe_log(const char *level
,
1397 const struct hdmi_audio_infoframe
*frame
)
1399 hdmi_infoframe_log_header(level
, dev
,
1400 (const struct hdmi_any_infoframe
*)frame
);
1402 if (frame
->channels
)
1403 hdmi_log(" channels: %u\n", frame
->channels
- 1);
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");
1422 static void hdmi_drm_infoframe_log(const char *level
,
1424 const struct hdmi_drm_infoframe
*frame
)
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
);
1438 hdmi_log("white point x: %d\n", frame
->white_point
.x
);
1439 hdmi_log("white point y: %d\n", frame
->white_point
.y
);
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
);
1446 hdmi_log("max_cll: %d\n", frame
->max_cll
);
1447 hdmi_log("max_fall: %d\n", frame
->max_fall
);
1451 hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct
)
1453 if (s3d_struct
< 0 || s3d_struct
> 0xf)
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
:
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)";
1480 hdmi_vendor_any_infoframe_log(const char *level
,
1482 const union hdmi_vendor_any_infoframe
*frame
)
1484 const struct hdmi_vendor_infoframe
*hvf
= &frame
->hdmi
;
1486 hdmi_infoframe_log_header(level
, dev
,
1487 (const struct hdmi_any_infoframe
*)frame
);
1489 if (frame
->any
.oui
!= HDMI_IEEE_OUI
) {
1490 hdmi_log(" not a HDMI vendor infoframe\n");
1493 if (hvf
->vic
== 0 && hvf
->s3d_struct
== HDMI_3D_STRUCTURE_INVALID
) {
1494 hdmi_log(" empty frame\n");
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",
1510 * hdmi_infoframe_log() - log info of HDMI infoframe
1511 * @level: logging level
1513 * @frame: HDMI infoframe
1515 void hdmi_infoframe_log(const char *level
,
1517 const union hdmi_infoframe
*frame
)
1519 switch (frame
->any
.type
) {
1520 case HDMI_INFOFRAME_TYPE_AVI
:
1521 hdmi_avi_infoframe_log(level
, dev
, &frame
->avi
);
1523 case HDMI_INFOFRAME_TYPE_SPD
:
1524 hdmi_spd_infoframe_log(level
, dev
, &frame
->spd
);
1526 case HDMI_INFOFRAME_TYPE_AUDIO
:
1527 hdmi_audio_infoframe_log(level
, dev
, &frame
->audio
);
1529 case HDMI_INFOFRAME_TYPE_VENDOR
:
1530 hdmi_vendor_any_infoframe_log(level
, dev
, &frame
->vendor
);
1532 case HDMI_INFOFRAME_TYPE_DRM
:
1533 hdmi_drm_infoframe_log(level
, dev
, &frame
->drm
);
1537 EXPORT_SYMBOL(hdmi_infoframe_log
);
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
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
1550 * Returns 0 on success or a negative error code on failure.
1552 static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe
*frame
,
1553 const void *buffer
, size_t size
)
1555 const u8
*ptr
= buffer
;
1558 if (size
< HDMI_INFOFRAME_SIZE(AVI
))
1561 if (ptr
[0] != HDMI_INFOFRAME_TYPE_AVI
||
1563 ptr
[2] != HDMI_AVI_INFOFRAME_SIZE
)
1566 if (hdmi_infoframe_checksum(buffer
, HDMI_INFOFRAME_SIZE(AVI
)) != 0)
1569 ret
= hdmi_avi_infoframe_init(frame
);
1573 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
1575 frame
->colorspace
= (ptr
[0] >> 5) & 0x3;
1577 frame
->active_aspect
= ptr
[1] & 0xf;
1579 frame
->top_bar
= (ptr
[6] << 8) | ptr
[5];
1580 frame
->bottom_bar
= (ptr
[8] << 8) | ptr
[7];
1583 frame
->left_bar
= (ptr
[10] << 8) | ptr
[9];
1584 frame
->right_bar
= (ptr
[12] << 8) | ptr
[11];
1586 frame
->scan_mode
= ptr
[0] & 0x3;
1588 frame
->colorimetry
= (ptr
[1] >> 6) & 0x3;
1589 frame
->picture_aspect
= (ptr
[1] >> 4) & 0x3;
1590 frame
->active_aspect
= ptr
[1] & 0xf;
1592 frame
->itc
= ptr
[2] & 0x80 ? true : false;
1593 frame
->extended_colorimetry
= (ptr
[2] >> 4) & 0x7;
1594 frame
->quantization_range
= (ptr
[2] >> 2) & 0x3;
1595 frame
->nups
= ptr
[2] & 0x3;
1597 frame
->video_code
= ptr
[3] & 0x7f;
1598 frame
->ycc_quantization_range
= (ptr
[4] >> 6) & 0x3;
1599 frame
->content_type
= (ptr
[4] >> 4) & 0x3;
1601 frame
->pixel_repeat
= ptr
[4] & 0xf;
1607 * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe
1608 * @frame: HDMI SPD infoframe
1609 * @buffer: source buffer
1610 * @size: size of buffer
1612 * Unpacks the information contained in binary @buffer into a structured
1613 * @frame of the HDMI Source Product Description (SPD) information frame.
1614 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1617 * Returns 0 on success or a negative error code on failure.
1619 static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe
*frame
,
1620 const void *buffer
, size_t size
)
1622 const u8
*ptr
= buffer
;
1625 if (size
< HDMI_INFOFRAME_SIZE(SPD
))
1628 if (ptr
[0] != HDMI_INFOFRAME_TYPE_SPD
||
1630 ptr
[2] != HDMI_SPD_INFOFRAME_SIZE
) {
1634 if (hdmi_infoframe_checksum(buffer
, HDMI_INFOFRAME_SIZE(SPD
)) != 0)
1637 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
1639 ret
= hdmi_spd_infoframe_init(frame
, ptr
, ptr
+ 8);
1643 frame
->sdi
= ptr
[24];
1649 * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe
1650 * @frame: HDMI Audio infoframe
1651 * @buffer: source buffer
1652 * @size: size of buffer
1654 * Unpacks the information contained in binary @buffer into a structured
1655 * @frame of the HDMI Audio information frame.
1656 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1659 * Returns 0 on success or a negative error code on failure.
1661 static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe
*frame
,
1662 const void *buffer
, size_t size
)
1664 const u8
*ptr
= buffer
;
1667 if (size
< HDMI_INFOFRAME_SIZE(AUDIO
))
1670 if (ptr
[0] != HDMI_INFOFRAME_TYPE_AUDIO
||
1672 ptr
[2] != HDMI_AUDIO_INFOFRAME_SIZE
) {
1676 if (hdmi_infoframe_checksum(buffer
, HDMI_INFOFRAME_SIZE(AUDIO
)) != 0)
1679 ret
= hdmi_audio_infoframe_init(frame
);
1683 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
1685 frame
->channels
= ptr
[0] & 0x7;
1686 frame
->coding_type
= (ptr
[0] >> 4) & 0xf;
1687 frame
->sample_size
= ptr
[1] & 0x3;
1688 frame
->sample_frequency
= (ptr
[1] >> 2) & 0x7;
1689 frame
->coding_type_ext
= ptr
[2] & 0x1f;
1690 frame
->channel_allocation
= ptr
[3];
1691 frame
->level_shift_value
= (ptr
[4] >> 3) & 0xf;
1692 frame
->downmix_inhibit
= ptr
[4] & 0x80 ? true : false;
1698 * hdmi_vendor_infoframe_unpack() - unpack binary buffer to a HDMI vendor infoframe
1699 * @frame: HDMI Vendor infoframe
1700 * @buffer: source buffer
1701 * @size: size of buffer
1703 * Unpacks the information contained in binary @buffer into a structured
1704 * @frame of the HDMI Vendor information frame.
1705 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1708 * Returns 0 on success or a negative error code on failure.
1711 hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe
*frame
,
1712 const void *buffer
, size_t size
)
1714 const u8
*ptr
= buffer
;
1717 u8 hdmi_video_format
;
1718 struct hdmi_vendor_infoframe
*hvf
= &frame
->hdmi
;
1720 if (size
< HDMI_INFOFRAME_HEADER_SIZE
)
1723 if (ptr
[0] != HDMI_INFOFRAME_TYPE_VENDOR
||
1725 (ptr
[2] != 4 && ptr
[2] != 5 && ptr
[2] != 6))
1730 if (size
< HDMI_INFOFRAME_HEADER_SIZE
+ length
)
1733 if (hdmi_infoframe_checksum(buffer
,
1734 HDMI_INFOFRAME_HEADER_SIZE
+ length
) != 0)
1737 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
1740 if ((ptr
[0] != 0x03) ||
1745 hdmi_video_format
= ptr
[3] >> 5;
1747 if (hdmi_video_format
> 0x2)
1750 ret
= hdmi_vendor_infoframe_init(hvf
);
1754 hvf
->length
= length
;
1756 if (hdmi_video_format
== 0x2) {
1757 if (length
!= 5 && length
!= 6)
1759 hvf
->s3d_struct
= ptr
[4] >> 4;
1760 if (hvf
->s3d_struct
>= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF
) {
1763 hvf
->s3d_ext_data
= ptr
[5] >> 4;
1765 } else if (hdmi_video_format
== 0x1) {
1778 * hdmi_drm_infoframe_unpack() - unpack binary buffer to a HDMI DRM infoframe
1779 * @frame: HDMI DRM infoframe
1780 * @buffer: source buffer
1781 * @size: size of buffer
1783 * Unpacks the information contained in binary @buffer into a structured
1784 * @frame of the HDMI Dynamic Range and Mastering (DRM) information frame.
1785 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1788 * Returns 0 on success or a negative error code on failure.
1790 static int hdmi_drm_infoframe_unpack(struct hdmi_drm_infoframe
*frame
,
1791 const void *buffer
, size_t size
)
1793 const u8
*ptr
= buffer
;
1800 if (size
< HDMI_INFOFRAME_SIZE(DRM
))
1803 if (ptr
[0] != HDMI_INFOFRAME_TYPE_DRM
||
1805 ptr
[2] != HDMI_DRM_INFOFRAME_SIZE
)
1808 if (hdmi_infoframe_checksum(buffer
, HDMI_INFOFRAME_SIZE(DRM
)) != 0)
1811 ret
= hdmi_drm_infoframe_init(frame
);
1815 ptr
+= HDMI_INFOFRAME_HEADER_SIZE
;
1817 frame
->eotf
= ptr
[0] & 0x7;
1818 frame
->metadata_type
= ptr
[1] & 0x7;
1821 for (i
= 0; i
< 3; i
++) {
1824 frame
->display_primaries
[i
].x
= (x_msb
<< 8) | x_lsb
;
1827 frame
->display_primaries
[i
].y
= (y_msb
<< 8) | y_lsb
;
1830 frame
->white_point
.x
= (ptr
[15] << 8) | ptr
[14];
1831 frame
->white_point
.y
= (ptr
[17] << 8) | ptr
[16];
1833 frame
->max_display_mastering_luminance
= (ptr
[19] << 8) | ptr
[18];
1834 frame
->min_display_mastering_luminance
= (ptr
[21] << 8) | ptr
[20];
1835 frame
->max_cll
= (ptr
[23] << 8) | ptr
[22];
1836 frame
->max_fall
= (ptr
[25] << 8) | ptr
[24];
1842 * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe
1843 * @frame: HDMI infoframe
1844 * @buffer: source buffer
1845 * @size: size of buffer
1847 * Unpacks the information contained in binary buffer @buffer into a structured
1848 * @frame of a HDMI infoframe.
1849 * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1852 * Returns 0 on success or a negative error code on failure.
1854 int hdmi_infoframe_unpack(union hdmi_infoframe
*frame
,
1855 const void *buffer
, size_t size
)
1858 const u8
*ptr
= buffer
;
1860 if (size
< HDMI_INFOFRAME_HEADER_SIZE
)
1864 case HDMI_INFOFRAME_TYPE_AVI
:
1865 ret
= hdmi_avi_infoframe_unpack(&frame
->avi
, buffer
, size
);
1867 case HDMI_INFOFRAME_TYPE_DRM
:
1868 ret
= hdmi_drm_infoframe_unpack(&frame
->drm
, buffer
, size
);
1870 case HDMI_INFOFRAME_TYPE_SPD
:
1871 ret
= hdmi_spd_infoframe_unpack(&frame
->spd
, buffer
, size
);
1873 case HDMI_INFOFRAME_TYPE_AUDIO
:
1874 ret
= hdmi_audio_infoframe_unpack(&frame
->audio
, buffer
, size
);
1876 case HDMI_INFOFRAME_TYPE_VENDOR
:
1877 ret
= hdmi_vendor_any_infoframe_unpack(&frame
->vendor
, buffer
, size
);
1886 EXPORT_SYMBOL(hdmi_infoframe_unpack
);