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