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  * Returns 0 on success or a negative error code on failure.
  58  */
  59 int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame)
  60 {
  61         memset(frame, 0, sizeof(*frame));
  62
  63         frame->type = HDMI_INFOFRAME_TYPE_AVI;
  64         frame->version = 2;
  65         frame->length = HDMI_AVI_INFOFRAME_SIZE;
  66
  67         return 0;
  68 }
  69 EXPORT_SYMBOL(hdmi_avi_infoframe_init);
  70
  71 static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe *frame)
  72 {
  73         if (frame->type != HDMI_INFOFRAME_TYPE_AVI ||
  74             frame->version != 2 ||
  75             frame->length != HDMI_AVI_INFOFRAME_SIZE)
  76                 return -EINVAL;
  77
  78         if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9)
  79                 return -EINVAL;
  80
  81         return 0;
  82 }
  83
  84 /**
  85  * hdmi_avi_infoframe_check() - check a HDMI AVI infoframe
  86  * @frame: HDMI AVI infoframe
  87  *
  88  * Validates that the infoframe is consistent and updates derived fields
  89  * (eg. length) based on other fields.
  90  *
  91  * Returns 0 on success or a negative error code on failure.
  92  */
  93 int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame)
  94 {
  95         return hdmi_avi_infoframe_check_only(frame);
  96 }
  97 EXPORT_SYMBOL(hdmi_avi_infoframe_check);
  98
  99 /**
 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
 104  *
 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.
 109  *
 110  * Returns the number of bytes packed into the binary buffer or a negative
 111  * error code on failure.
 112  */
 113 ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame,
 114                                      void *buffer, size_t size)
 115 {
 116         u8 *ptr = buffer;
 117         size_t length;
 118         int ret;
 119
 120         ret = hdmi_avi_infoframe_check_only(frame);
 121         if (ret)
 122                 return ret;
 123
 124         length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
 125
 126         if (size < length)
 127                 return -ENOSPC;
 128
 129         memset(buffer, 0, size);
 130
 131         ptr[0] = frame->type;
 132         ptr[1] = frame->version;
 133         ptr[2] = frame->length;
 134         ptr[3] = 0; /* checksum */
 135
 136         /* start infoframe payload */
 137         ptr += HDMI_INFOFRAME_HEADER_SIZE;
 138
 139         ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3);
 140
 141         /*
 142          * Data byte 1, bit 4 has to be set if we provide the active format
 143          * aspect ratio
 144          */
 145         if (frame->active_aspect & 0xf)
 146                 ptr[0] |= BIT(4);
 147
 148         /* Bit 3 and 2 indicate if we transmit horizontal/vertical bar data */
 149         if (frame->top_bar || frame->bottom_bar)
 150                 ptr[0] |= BIT(3);
 151
 152         if (frame->left_bar || frame->right_bar)
 153                 ptr[0] |= BIT(2);
 154
 155         ptr[1] = ((frame->colorimetry & 0x3) << 6) |
 156                  ((frame->picture_aspect & 0x3) << 4) |
 157                  (frame->active_aspect & 0xf);
 158
 159         ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) |
 160                  ((frame->quantization_range & 0x3) << 2) |
 161                  (frame->nups & 0x3);
 162
 163         if (frame->itc)
 164                 ptr[2] |= BIT(7);
 165
 166         ptr[3] = frame->video_code & 0x7f;
 167
 168         ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) |
 169                  ((frame->content_type & 0x3) << 4) |
 170                  (frame->pixel_repeat & 0xf);
 171
 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;
 180
 181         hdmi_infoframe_set_checksum(buffer, length);
 182
 183         return length;
 184 }
 185 EXPORT_SYMBOL(hdmi_avi_infoframe_pack_only);
 186
 187 /**
 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
 193  *
 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
 199  * specification.
 200  *
 201  * Returns the number of bytes packed into the binary buffer or a negative
 202  * error code on failure.
 203  */
 204 ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame,
 205                                 void *buffer, size_t size)
 206 {
 207         int ret;
 208
 209         ret = hdmi_avi_infoframe_check(frame);
 210         if (ret)
 211                 return ret;
 212
 213         return hdmi_avi_infoframe_pack_only(frame, buffer, size);
 214 }
 215 EXPORT_SYMBOL(hdmi_avi_infoframe_pack);
 216
 217 /**
 218  * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe
 219  * @frame: HDMI SPD infoframe
 220  * @vendor: vendor string
 221  * @product: product string
 222  *
 223  * Returns 0 on success or a negative error code on failure.
 224  */
 225 int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame,
 226                             const char *vendor, const char *product)
 227 {
 228         memset(frame, 0, sizeof(*frame));
 229
 230         frame->type = HDMI_INFOFRAME_TYPE_SPD;
 231         frame->version = 1;
 232         frame->length = HDMI_SPD_INFOFRAME_SIZE;
 233
 234         strncpy(frame->vendor, vendor, sizeof(frame->vendor));
 235         strncpy(frame->product, product, 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 = 4;
 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_vendor_any_infoframe_check() - check a vendor infoframe
 655  */
 656 static int
 657 hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe *frame)
 658 {
 659         int ret;
 660
 661         ret = hdmi_vendor_any_infoframe_check_only(frame);
 662         if (ret)
 663                 return ret;
 664
 665         /* we only know about HDMI vendor infoframes */
 666         if (frame->any.oui != HDMI_IEEE_OUI)
 667                 return -EINVAL;
 668
 669         return hdmi_vendor_infoframe_check(&frame->hdmi);
 670 }
 671
 672 /*
 673  * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer
 674  */
 675 static ssize_t
 676 hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe *frame,
 677                                     void *buffer, size_t size)
 678 {
 679         int ret;
 680
 681         ret = hdmi_vendor_any_infoframe_check_only(frame);
 682         if (ret)
 683                 return ret;
 684
 685         /* we only know about HDMI vendor infoframes */
 686         if (frame->any.oui != HDMI_IEEE_OUI)
 687                 return -EINVAL;
 688
 689         return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size);
 690 }
 691
 692 /*
 693  * hdmi_vendor_any_infoframe_pack() - check a vendor infoframe,
 694  *                                    and write it to binary buffer
 695  */
 696 static ssize_t
 697 hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame,
 698                                void *buffer, size_t size)
 699 {
 700         int ret;
 701
 702         ret = hdmi_vendor_any_infoframe_check(frame);
 703         if (ret)
 704                 return ret;
 705
 706         return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size);
 707 }
 708
 709 /**
 710  * hdmi_infoframe_check() - check a HDMI infoframe
 711  * @frame: HDMI infoframe
 712  *
 713  * Validates that the infoframe is consistent and updates derived fields
 714  * (eg. length) based on other fields.
 715  *
 716  * Returns 0 on success or a negative error code on failure.
 717  */
 718 int
 719 hdmi_infoframe_check(union hdmi_infoframe *frame)
 720 {
 721         switch (frame->any.type) {
 722         case HDMI_INFOFRAME_TYPE_AVI:
 723                 return hdmi_avi_infoframe_check(&frame->avi);
 724         case HDMI_INFOFRAME_TYPE_SPD:
 725                 return hdmi_spd_infoframe_check(&frame->spd);
 726         case HDMI_INFOFRAME_TYPE_AUDIO:
 727                 return hdmi_audio_infoframe_check(&frame->audio);
 728         case HDMI_INFOFRAME_TYPE_VENDOR:
 729                 return hdmi_vendor_any_infoframe_check(&frame->vendor);
 730         default:
 731                 WARN(1, "Bad infoframe type %d\n", frame->any.type);
 732                 return -EINVAL;
 733         }
 734 }
 735 EXPORT_SYMBOL(hdmi_infoframe_check);
 736
 737 /**
 738  * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer
 739  * @frame: HDMI infoframe
 740  * @buffer: destination buffer
 741  * @size: size of buffer
 742  *
 743  * Packs the information contained in the @frame structure into a binary
 744  * representation that can be written into the corresponding controller
 745  * registers. Also computes the checksum as required by section 5.3.5 of
 746  * the HDMI 1.4 specification.
 747  *
 748  * Returns the number of bytes packed into the binary buffer or a negative
 749  * error code on failure.
 750  */
 751 ssize_t
 752 hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size)
 753 {
 754         ssize_t length;
 755
 756         switch (frame->any.type) {
 757         case HDMI_INFOFRAME_TYPE_AVI:
 758                 length = hdmi_avi_infoframe_pack_only(&frame->avi,
 759                                                       buffer, size);
 760                 break;
 761         case HDMI_INFOFRAME_TYPE_SPD:
 762                 length = hdmi_spd_infoframe_pack_only(&frame->spd,
 763                                                       buffer, size);
 764                 break;
 765         case HDMI_INFOFRAME_TYPE_AUDIO:
 766                 length = hdmi_audio_infoframe_pack_only(&frame->audio,
 767                                                         buffer, size);
 768                 break;
 769         case HDMI_INFOFRAME_TYPE_VENDOR:
 770                 length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor,
 771                                                              buffer, size);
 772                 break;
 773         default:
 774                 WARN(1, "Bad infoframe type %d\n", frame->any.type);
 775                 length = -EINVAL;
 776         }
 777
 778         return length;
 779 }
 780 EXPORT_SYMBOL(hdmi_infoframe_pack_only);
 781
 782 /**
 783  * hdmi_infoframe_pack() - check a HDMI infoframe,
 784  *                         and write it to binary buffer
 785  * @frame: HDMI infoframe
 786  * @buffer: destination buffer
 787  * @size: size of buffer
 788  *
 789  * Validates that the infoframe is consistent and updates derived fields
 790  * (eg. length) based on other fields, after which it packs the information
 791  * contained in the @frame structure into a binary representation that
 792  * can be written into the corresponding controller registers. This function
 793  * also computes the checksum as required by section 5.3.5 of the HDMI 1.4
 794  * specification.
 795  *
 796  * Returns the number of bytes packed into the binary buffer or a negative
 797  * error code on failure.
 798  */
 799 ssize_t
 800 hdmi_infoframe_pack(union hdmi_infoframe *frame,
 801                     void *buffer, size_t size)
 802 {
 803         ssize_t length;
 804
 805         switch (frame->any.type) {
 806         case HDMI_INFOFRAME_TYPE_AVI:
 807                 length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size);
 808                 break;
 809         case HDMI_INFOFRAME_TYPE_SPD:
 810                 length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size);
 811                 break;
 812         case HDMI_INFOFRAME_TYPE_AUDIO:
 813                 length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size);
 814                 break;
 815         case HDMI_INFOFRAME_TYPE_VENDOR:
 816                 length = hdmi_vendor_any_infoframe_pack(&frame->vendor,
 817                                                         buffer, size);
 818                 break;
 819         default:
 820                 WARN(1, "Bad infoframe type %d\n", frame->any.type);
 821                 length = -EINVAL;
 822         }
 823
 824         return length;
 825 }
 826 EXPORT_SYMBOL(hdmi_infoframe_pack);
 827
 828 static const char *hdmi_infoframe_type_get_name(enum hdmi_infoframe_type type)
 829 {
 830         if (type < 0x80 || type > 0x9f)
 831                 return "Invalid";
 832         switch (type) {
 833         case HDMI_INFOFRAME_TYPE_VENDOR:
 834                 return "Vendor";
 835         case HDMI_INFOFRAME_TYPE_AVI:
 836                 return "Auxiliary Video Information (AVI)";
 837         case HDMI_INFOFRAME_TYPE_SPD:
 838                 return "Source Product Description (SPD)";
 839         case HDMI_INFOFRAME_TYPE_AUDIO:
 840                 return "Audio";
 841         }
 842         return "Reserved";
 843 }
 844
 845 static void hdmi_infoframe_log_header(const char *level,
 846                                       struct device *dev,
 847                                       const struct hdmi_any_infoframe *frame)
 848 {
 849         hdmi_log("HDMI infoframe: %s, version %u, length %u\n",
 850                 hdmi_infoframe_type_get_name(frame->type),
 851                 frame->version, frame->length);
 852 }
 853
 854 static const char *hdmi_colorspace_get_name(enum hdmi_colorspace colorspace)
 855 {
 856         switch (colorspace) {
 857         case HDMI_COLORSPACE_RGB:
 858                 return "RGB";
 859         case HDMI_COLORSPACE_YUV422:
 860                 return "YCbCr 4:2:2";
 861         case HDMI_COLORSPACE_YUV444:
 862                 return "YCbCr 4:4:4";
 863         case HDMI_COLORSPACE_YUV420:
 864                 return "YCbCr 4:2:0";
 865         case HDMI_COLORSPACE_RESERVED4:
 866                 return "Reserved (4)";
 867         case HDMI_COLORSPACE_RESERVED5:
 868                 return "Reserved (5)";
 869         case HDMI_COLORSPACE_RESERVED6:
 870                 return "Reserved (6)";
 871         case HDMI_COLORSPACE_IDO_DEFINED:
 872                 return "IDO Defined";
 873         }
 874         return "Invalid";
 875 }
 876
 877 static const char *hdmi_scan_mode_get_name(enum hdmi_scan_mode scan_mode)
 878 {
 879         switch (scan_mode) {
 880         case HDMI_SCAN_MODE_NONE:
 881                 return "No Data";
 882         case HDMI_SCAN_MODE_OVERSCAN:
 883                 return "Overscan";
 884         case HDMI_SCAN_MODE_UNDERSCAN:
 885                 return "Underscan";
 886         case HDMI_SCAN_MODE_RESERVED:
 887                 return "Reserved";
 888         }
 889         return "Invalid";
 890 }
 891
 892 static const char *hdmi_colorimetry_get_name(enum hdmi_colorimetry colorimetry)
 893 {
 894         switch (colorimetry) {
 895         case HDMI_COLORIMETRY_NONE:
 896                 return "No Data";
 897         case HDMI_COLORIMETRY_ITU_601:
 898                 return "ITU601";
 899         case HDMI_COLORIMETRY_ITU_709:
 900                 return "ITU709";
 901         case HDMI_COLORIMETRY_EXTENDED:
 902                 return "Extended";
 903         }
 904         return "Invalid";
 905 }
 906
 907 static const char *
 908 hdmi_picture_aspect_get_name(enum hdmi_picture_aspect picture_aspect)
 909 {
 910         switch (picture_aspect) {
 911         case HDMI_PICTURE_ASPECT_NONE:
 912                 return "No Data";
 913         case HDMI_PICTURE_ASPECT_4_3:
 914                 return "4:3";
 915         case HDMI_PICTURE_ASPECT_16_9:
 916                 return "16:9";
 917         case HDMI_PICTURE_ASPECT_64_27:
 918                 return "64:27";
 919         case HDMI_PICTURE_ASPECT_256_135:
 920                 return "256:135";
 921         case HDMI_PICTURE_ASPECT_RESERVED:
 922                 return "Reserved";
 923         }
 924         return "Invalid";
 925 }
 926
 927 static const char *
 928 hdmi_active_aspect_get_name(enum hdmi_active_aspect active_aspect)
 929 {
 930         if (active_aspect < 0 || active_aspect > 0xf)
 931                 return "Invalid";
 932
 933         switch (active_aspect) {
 934         case HDMI_ACTIVE_ASPECT_16_9_TOP:
 935                 return "16:9 Top";
 936         case HDMI_ACTIVE_ASPECT_14_9_TOP:
 937                 return "14:9 Top";
 938         case HDMI_ACTIVE_ASPECT_16_9_CENTER:
 939                 return "16:9 Center";
 940         case HDMI_ACTIVE_ASPECT_PICTURE:
 941                 return "Same as Picture";
 942         case HDMI_ACTIVE_ASPECT_4_3:
 943                 return "4:3";
 944         case HDMI_ACTIVE_ASPECT_16_9:
 945                 return "16:9";
 946         case HDMI_ACTIVE_ASPECT_14_9:
 947                 return "14:9";
 948         case HDMI_ACTIVE_ASPECT_4_3_SP_14_9:
 949                 return "4:3 SP 14:9";
 950         case HDMI_ACTIVE_ASPECT_16_9_SP_14_9:
 951                 return "16:9 SP 14:9";
 952         case HDMI_ACTIVE_ASPECT_16_9_SP_4_3:
 953                 return "16:9 SP 4:3";
 954         }
 955         return "Reserved";
 956 }
 957
 958 static const char *
 959 hdmi_extended_colorimetry_get_name(enum hdmi_extended_colorimetry ext_col)
 960 {
 961         switch (ext_col) {
 962         case HDMI_EXTENDED_COLORIMETRY_XV_YCC_601:
 963                 return "xvYCC 601";
 964         case HDMI_EXTENDED_COLORIMETRY_XV_YCC_709:
 965                 return "xvYCC 709";
 966         case HDMI_EXTENDED_COLORIMETRY_S_YCC_601:
 967                 return "sYCC 601";
 968         case HDMI_EXTENDED_COLORIMETRY_OPYCC_601:
 969                 return "opYCC 601";
 970         case HDMI_EXTENDED_COLORIMETRY_OPRGB:
 971                 return "opRGB";
 972         case HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM:
 973                 return "BT.2020 Constant Luminance";
 974         case HDMI_EXTENDED_COLORIMETRY_BT2020:
 975                 return "BT.2020";
 976         case HDMI_EXTENDED_COLORIMETRY_RESERVED:
 977                 return "Reserved";
 978         }
 979         return "Invalid";
 980 }
 981
 982 static const char *
 983 hdmi_quantization_range_get_name(enum hdmi_quantization_range qrange)
 984 {
 985         switch (qrange) {
 986         case HDMI_QUANTIZATION_RANGE_DEFAULT:
 987                 return "Default";
 988         case HDMI_QUANTIZATION_RANGE_LIMITED:
 989                 return "Limited";
 990         case HDMI_QUANTIZATION_RANGE_FULL:
 991                 return "Full";
 992         case HDMI_QUANTIZATION_RANGE_RESERVED:
 993                 return "Reserved";
 994         }
 995         return "Invalid";
 996 }
 997
 998 static const char *hdmi_nups_get_name(enum hdmi_nups nups)
 999 {
1000         switch (nups) {
1001         case HDMI_NUPS_UNKNOWN:
1002                 return "Unknown Non-uniform Scaling";
1003         case HDMI_NUPS_HORIZONTAL:
1004                 return "Horizontally Scaled";
1005         case HDMI_NUPS_VERTICAL:
1006                 return "Vertically Scaled";
1007         case HDMI_NUPS_BOTH:
1008                 return "Horizontally and Vertically Scaled";
1009         }
1010         return "Invalid";
1011 }
1012
1013 static const char *
1014 hdmi_ycc_quantization_range_get_name(enum hdmi_ycc_quantization_range qrange)
1015 {
1016         switch (qrange) {
1017         case HDMI_YCC_QUANTIZATION_RANGE_LIMITED:
1018                 return "Limited";
1019         case HDMI_YCC_QUANTIZATION_RANGE_FULL:
1020                 return "Full";
1021         }
1022         return "Invalid";
1023 }
1024
1025 static const char *
1026 hdmi_content_type_get_name(enum hdmi_content_type content_type)
1027 {
1028         switch (content_type) {
1029         case HDMI_CONTENT_TYPE_GRAPHICS:
1030                 return "Graphics";
1031         case HDMI_CONTENT_TYPE_PHOTO:
1032                 return "Photo";
1033         case HDMI_CONTENT_TYPE_CINEMA:
1034                 return "Cinema";
1035         case HDMI_CONTENT_TYPE_GAME:
1036                 return "Game";
1037         }
1038         return "Invalid";
1039 }
1040
1041 /**
1042  * hdmi_avi_infoframe_log() - log info of HDMI AVI infoframe
1043  * @level: logging level
1044  * @dev: device
1045  * @frame: HDMI AVI infoframe
1046  */
1047 static void hdmi_avi_infoframe_log(const char *level,
1048                                    struct device *dev,
1049                                    const struct hdmi_avi_infoframe *frame)
1050 {
1051         hdmi_infoframe_log_header(level, dev,
1052                                   (const struct hdmi_any_infoframe *)frame);
1053
1054         hdmi_log("    colorspace: %s\n",
1055                         hdmi_colorspace_get_name(frame->colorspace));
1056         hdmi_log("    scan mode: %s\n",
1057                         hdmi_scan_mode_get_name(frame->scan_mode));
1058         hdmi_log("    colorimetry: %s\n",
1059                         hdmi_colorimetry_get_name(frame->colorimetry));
1060         hdmi_log("    picture aspect: %s\n",
1061                         hdmi_picture_aspect_get_name(frame->picture_aspect));
1062         hdmi_log("    active aspect: %s\n",
1063                         hdmi_active_aspect_get_name(frame->active_aspect));
1064         hdmi_log("    itc: %s\n", frame->itc ? "IT Content" : "No Data");
1065         hdmi_log("    extended colorimetry: %s\n",
1066                         hdmi_extended_colorimetry_get_name(frame->extended_colorimetry));
1067         hdmi_log("    quantization range: %s\n",
1068                         hdmi_quantization_range_get_name(frame->quantization_range));
1069         hdmi_log("    nups: %s\n", hdmi_nups_get_name(frame->nups));
1070         hdmi_log("    video code: %u\n", frame->video_code);
1071         hdmi_log("    ycc quantization range: %s\n",
1072                         hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range));
1073         hdmi_log("    hdmi content type: %s\n",
1074                         hdmi_content_type_get_name(frame->content_type));
1075         hdmi_log("    pixel repeat: %u\n", frame->pixel_repeat);
1076         hdmi_log("    bar top %u, bottom %u, left %u, right %u\n",
1077                         frame->top_bar, frame->bottom_bar,
1078                         frame->left_bar, frame->right_bar);
1079 }
1080
1081 static const char *hdmi_spd_sdi_get_name(enum hdmi_spd_sdi sdi)
1082 {
1083         if (sdi < 0 || sdi > 0xff)
1084                 return "Invalid";
1085         switch (sdi) {
1086         case HDMI_SPD_SDI_UNKNOWN:
1087                 return "Unknown";
1088         case HDMI_SPD_SDI_DSTB:
1089                 return "Digital STB";
1090         case HDMI_SPD_SDI_DVDP:
1091                 return "DVD Player";
1092         case HDMI_SPD_SDI_DVHS:
1093                 return "D-VHS";
1094         case HDMI_SPD_SDI_HDDVR:
1095                 return "HDD Videorecorder";
1096         case HDMI_SPD_SDI_DVC:
1097                 return "DVC";
1098         case HDMI_SPD_SDI_DSC:
1099                 return "DSC";
1100         case HDMI_SPD_SDI_VCD:
1101                 return "Video CD";
1102         case HDMI_SPD_SDI_GAME:
1103                 return "Game";
1104         case HDMI_SPD_SDI_PC:
1105                 return "PC General";
1106         case HDMI_SPD_SDI_BD:
1107                 return "Blu-Ray Disc (BD)";
1108         case HDMI_SPD_SDI_SACD:
1109                 return "Super Audio CD";
1110         case HDMI_SPD_SDI_HDDVD:
1111                 return "HD DVD";
1112         case HDMI_SPD_SDI_PMP:
1113                 return "PMP";
1114         }
1115         return "Reserved";
1116 }
1117
1118 /**
1119  * hdmi_spd_infoframe_log() - log info of HDMI SPD infoframe
1120  * @level: logging level
1121  * @dev: device
1122  * @frame: HDMI SPD infoframe
1123  */
1124 static void hdmi_spd_infoframe_log(const char *level,
1125                                    struct device *dev,
1126                                    const struct hdmi_spd_infoframe *frame)
1127 {
1128         u8 buf[17];
1129
1130         hdmi_infoframe_log_header(level, dev,
1131                                   (const struct hdmi_any_infoframe *)frame);
1132
1133         memset(buf, 0, sizeof(buf));
1134
1135         strncpy(buf, frame->vendor, 8);
1136         hdmi_log("    vendor: %s\n", buf);
1137         strncpy(buf, frame->product, 16);
1138         hdmi_log("    product: %s\n", buf);
1139         hdmi_log("    source device information: %s (0x%x)\n",
1140                 hdmi_spd_sdi_get_name(frame->sdi), frame->sdi);
1141 }
1142
1143 static const char *
1144 hdmi_audio_coding_type_get_name(enum hdmi_audio_coding_type coding_type)
1145 {
1146         switch (coding_type) {
1147         case HDMI_AUDIO_CODING_TYPE_STREAM:
1148                 return "Refer to Stream Header";
1149         case HDMI_AUDIO_CODING_TYPE_PCM:
1150                 return "PCM";
1151         case HDMI_AUDIO_CODING_TYPE_AC3:
1152                 return "AC-3";
1153         case HDMI_AUDIO_CODING_TYPE_MPEG1:
1154                 return "MPEG1";
1155         case HDMI_AUDIO_CODING_TYPE_MP3:
1156                 return "MP3";
1157         case HDMI_AUDIO_CODING_TYPE_MPEG2:
1158                 return "MPEG2";
1159         case HDMI_AUDIO_CODING_TYPE_AAC_LC:
1160                 return "AAC";
1161         case HDMI_AUDIO_CODING_TYPE_DTS:
1162                 return "DTS";
1163         case HDMI_AUDIO_CODING_TYPE_ATRAC:
1164                 return "ATRAC";
1165         case HDMI_AUDIO_CODING_TYPE_DSD:
1166                 return "One Bit Audio";
1167         case HDMI_AUDIO_CODING_TYPE_EAC3:
1168                 return "Dolby Digital +";
1169         case HDMI_AUDIO_CODING_TYPE_DTS_HD:
1170                 return "DTS-HD";
1171         case HDMI_AUDIO_CODING_TYPE_MLP:
1172                 return "MAT (MLP)";
1173         case HDMI_AUDIO_CODING_TYPE_DST:
1174                 return "DST";
1175         case HDMI_AUDIO_CODING_TYPE_WMA_PRO:
1176                 return "WMA PRO";
1177         case HDMI_AUDIO_CODING_TYPE_CXT:
1178                 return "Refer to CXT";
1179         }
1180         return "Invalid";
1181 }
1182
1183 static const char *
1184 hdmi_audio_sample_size_get_name(enum hdmi_audio_sample_size sample_size)
1185 {
1186         switch (sample_size) {
1187         case HDMI_AUDIO_SAMPLE_SIZE_STREAM:
1188                 return "Refer to Stream Header";
1189         case HDMI_AUDIO_SAMPLE_SIZE_16:
1190                 return "16 bit";
1191         case HDMI_AUDIO_SAMPLE_SIZE_20:
1192                 return "20 bit";
1193         case HDMI_AUDIO_SAMPLE_SIZE_24:
1194                 return "24 bit";
1195         }
1196         return "Invalid";
1197 }
1198
1199 static const char *
1200 hdmi_audio_sample_frequency_get_name(enum hdmi_audio_sample_frequency freq)
1201 {
1202         switch (freq) {
1203         case HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM:
1204                 return "Refer to Stream Header";
1205         case HDMI_AUDIO_SAMPLE_FREQUENCY_32000:
1206                 return "32 kHz";
1207         case HDMI_AUDIO_SAMPLE_FREQUENCY_44100:
1208                 return "44.1 kHz (CD)";
1209         case HDMI_AUDIO_SAMPLE_FREQUENCY_48000:
1210                 return "48 kHz";
1211         case HDMI_AUDIO_SAMPLE_FREQUENCY_88200:
1212                 return "88.2 kHz";
1213         case HDMI_AUDIO_SAMPLE_FREQUENCY_96000:
1214                 return "96 kHz";
1215         case HDMI_AUDIO_SAMPLE_FREQUENCY_176400:
1216                 return "176.4 kHz";
1217         case HDMI_AUDIO_SAMPLE_FREQUENCY_192000:
1218                 return "192 kHz";
1219         }
1220         return "Invalid";
1221 }
1222
1223 static const char *
1224 hdmi_audio_coding_type_ext_get_name(enum hdmi_audio_coding_type_ext ctx)
1225 {
1226         if (ctx < 0 || ctx > 0x1f)
1227                 return "Invalid";
1228
1229         switch (ctx) {
1230         case HDMI_AUDIO_CODING_TYPE_EXT_CT:
1231                 return "Refer to CT";
1232         case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC:
1233                 return "HE AAC";
1234         case HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2:
1235                 return "HE AAC v2";
1236         case HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND:
1237                 return "MPEG SURROUND";
1238         case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC:
1239                 return "MPEG-4 HE AAC";
1240         case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2:
1241                 return "MPEG-4 HE AAC v2";
1242         case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC:
1243                 return "MPEG-4 AAC LC";
1244         case HDMI_AUDIO_CODING_TYPE_EXT_DRA:
1245                 return "DRA";
1246         case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND:
1247                 return "MPEG-4 HE AAC + MPEG Surround";
1248         case HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND:
1249                 return "MPEG-4 AAC LC + MPEG Surround";
1250         }
1251         return "Reserved";
1252 }
1253
1254 /**
1255  * hdmi_audio_infoframe_log() - log info of HDMI AUDIO infoframe
1256  * @level: logging level
1257  * @dev: device
1258  * @frame: HDMI AUDIO infoframe
1259  */
1260 static void hdmi_audio_infoframe_log(const char *level,
1261                                      struct device *dev,
1262                                      const struct hdmi_audio_infoframe *frame)
1263 {
1264         hdmi_infoframe_log_header(level, dev,
1265                                   (const struct hdmi_any_infoframe *)frame);
1266
1267         if (frame->channels)
1268                 hdmi_log("    channels: %u\n", frame->channels - 1);
1269         else
1270                 hdmi_log("    channels: Refer to stream header\n");
1271         hdmi_log("    coding type: %s\n",
1272                         hdmi_audio_coding_type_get_name(frame->coding_type));
1273         hdmi_log("    sample size: %s\n",
1274                         hdmi_audio_sample_size_get_name(frame->sample_size));
1275         hdmi_log("    sample frequency: %s\n",
1276                         hdmi_audio_sample_frequency_get_name(frame->sample_frequency));
1277         hdmi_log("    coding type ext: %s\n",
1278                         hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext));
1279         hdmi_log("    channel allocation: 0x%x\n",
1280                         frame->channel_allocation);
1281         hdmi_log("    level shift value: %u dB\n",
1282                         frame->level_shift_value);
1283         hdmi_log("    downmix inhibit: %s\n",
1284                         frame->downmix_inhibit ? "Yes" : "No");
1285 }
1286
1287 static const char *
1288 hdmi_3d_structure_get_name(enum hdmi_3d_structure s3d_struct)
1289 {
1290         if (s3d_struct < 0 || s3d_struct > 0xf)
1291                 return "Invalid";
1292
1293         switch (s3d_struct) {
1294         case HDMI_3D_STRUCTURE_FRAME_PACKING:
1295                 return "Frame Packing";
1296         case HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE:
1297                 return "Field Alternative";
1298         case HDMI_3D_STRUCTURE_LINE_ALTERNATIVE:
1299                 return "Line Alternative";
1300         case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL:
1301                 return "Side-by-side (Full)";
1302         case HDMI_3D_STRUCTURE_L_DEPTH:
1303                 return "L + Depth";
1304         case HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH:
1305                 return "L + Depth + Graphics + Graphics-depth";
1306         case HDMI_3D_STRUCTURE_TOP_AND_BOTTOM:
1307                 return "Top-and-Bottom";
1308         case HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF:
1309                 return "Side-by-side (Half)";
1310         default:
1311                 break;
1312         }
1313         return "Reserved";
1314 }
1315
1316 /**
1317  * hdmi_vendor_infoframe_log() - log info of HDMI VENDOR infoframe
1318  * @level: logging level
1319  * @dev: device
1320  * @frame: HDMI VENDOR infoframe
1321  */
1322 static void
1323 hdmi_vendor_any_infoframe_log(const char *level,
1324                               struct device *dev,
1325                               const union hdmi_vendor_any_infoframe *frame)
1326 {
1327         const struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1328
1329         hdmi_infoframe_log_header(level, dev,
1330                                   (const struct hdmi_any_infoframe *)frame);
1331
1332         if (frame->any.oui != HDMI_IEEE_OUI) {
1333                 hdmi_log("    not a HDMI vendor infoframe\n");
1334                 return;
1335         }
1336         if (hvf->vic == 0 && hvf->s3d_struct == HDMI_3D_STRUCTURE_INVALID) {
1337                 hdmi_log("    empty frame\n");
1338                 return;
1339         }
1340
1341         if (hvf->vic)
1342                 hdmi_log("    HDMI VIC: %u\n", hvf->vic);
1343         if (hvf->s3d_struct != HDMI_3D_STRUCTURE_INVALID) {
1344                 hdmi_log("    3D structure: %s\n",
1345                                 hdmi_3d_structure_get_name(hvf->s3d_struct));
1346                 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
1347                         hdmi_log("    3D extension data: %d\n",
1348                                         hvf->s3d_ext_data);
1349         }
1350 }
1351
1352 /**
1353  * hdmi_infoframe_log() - log info of HDMI infoframe
1354  * @level: logging level
1355  * @dev: device
1356  * @frame: HDMI infoframe
1357  */
1358 void hdmi_infoframe_log(const char *level,
1359                         struct device *dev,
1360                         const union hdmi_infoframe *frame)
1361 {
1362         switch (frame->any.type) {
1363         case HDMI_INFOFRAME_TYPE_AVI:
1364                 hdmi_avi_infoframe_log(level, dev, &frame->avi);
1365                 break;
1366         case HDMI_INFOFRAME_TYPE_SPD:
1367                 hdmi_spd_infoframe_log(level, dev, &frame->spd);
1368                 break;
1369         case HDMI_INFOFRAME_TYPE_AUDIO:
1370                 hdmi_audio_infoframe_log(level, dev, &frame->audio);
1371                 break;
1372         case HDMI_INFOFRAME_TYPE_VENDOR:
1373                 hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor);
1374                 break;
1375         }
1376 }
1377 EXPORT_SYMBOL(hdmi_infoframe_log);
1378
1379 /**
1380  * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe
1381  * @frame: HDMI AVI infoframe
1382  * @buffer: source buffer
1383  * @size: size of buffer
1384  *
1385  * Unpacks the information contained in binary @buffer into a structured
1386  * @frame of the HDMI Auxiliary Video (AVI) information frame.
1387  * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1388  * specification.
1389  *
1390  * Returns 0 on success or a negative error code on failure.
1391  */
1392 static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame,
1393                                      const void *buffer, size_t size)
1394 {
1395         const u8 *ptr = buffer;
1396         int ret;
1397
1398         if (size < HDMI_INFOFRAME_SIZE(AVI))
1399                 return -EINVAL;
1400
1401         if (ptr[0] != HDMI_INFOFRAME_TYPE_AVI ||
1402             ptr[1] != 2 ||
1403             ptr[2] != HDMI_AVI_INFOFRAME_SIZE)
1404                 return -EINVAL;
1405
1406         if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AVI)) != 0)
1407                 return -EINVAL;
1408
1409         ret = hdmi_avi_infoframe_init(frame);
1410         if (ret)
1411                 return ret;
1412
1413         ptr += HDMI_INFOFRAME_HEADER_SIZE;
1414
1415         frame->colorspace = (ptr[0] >> 5) & 0x3;
1416         if (ptr[0] & 0x10)
1417                 frame->active_aspect = ptr[1] & 0xf;
1418         if (ptr[0] & 0x8) {
1419                 frame->top_bar = (ptr[5] << 8) + ptr[6];
1420                 frame->bottom_bar = (ptr[7] << 8) + ptr[8];
1421         }
1422         if (ptr[0] & 0x4) {
1423                 frame->left_bar = (ptr[9] << 8) + ptr[10];
1424                 frame->right_bar = (ptr[11] << 8) + ptr[12];
1425         }
1426         frame->scan_mode = ptr[0] & 0x3;
1427
1428         frame->colorimetry = (ptr[1] >> 6) & 0x3;
1429         frame->picture_aspect = (ptr[1] >> 4) & 0x3;
1430         frame->active_aspect = ptr[1] & 0xf;
1431
1432         frame->itc = ptr[2] & 0x80 ? true : false;
1433         frame->extended_colorimetry = (ptr[2] >> 4) & 0x7;
1434         frame->quantization_range = (ptr[2] >> 2) & 0x3;
1435         frame->nups = ptr[2] & 0x3;
1436
1437         frame->video_code = ptr[3] & 0x7f;
1438         frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3;
1439         frame->content_type = (ptr[4] >> 4) & 0x3;
1440
1441         frame->pixel_repeat = ptr[4] & 0xf;
1442
1443         return 0;
1444 }
1445
1446 /**
1447  * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe
1448  * @frame: HDMI SPD infoframe
1449  * @buffer: source buffer
1450  * @size: size of buffer
1451  *
1452  * Unpacks the information contained in binary @buffer into a structured
1453  * @frame of the HDMI Source Product Description (SPD) information frame.
1454  * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1455  * specification.
1456  *
1457  * Returns 0 on success or a negative error code on failure.
1458  */
1459 static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame,
1460                                      const void *buffer, size_t size)
1461 {
1462         const u8 *ptr = buffer;
1463         int ret;
1464
1465         if (size < HDMI_INFOFRAME_SIZE(SPD))
1466                 return -EINVAL;
1467
1468         if (ptr[0] != HDMI_INFOFRAME_TYPE_SPD ||
1469             ptr[1] != 1 ||
1470             ptr[2] != HDMI_SPD_INFOFRAME_SIZE) {
1471                 return -EINVAL;
1472         }
1473
1474         if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(SPD)) != 0)
1475                 return -EINVAL;
1476
1477         ptr += HDMI_INFOFRAME_HEADER_SIZE;
1478
1479         ret = hdmi_spd_infoframe_init(frame, ptr, ptr + 8);
1480         if (ret)
1481                 return ret;
1482
1483         frame->sdi = ptr[24];
1484
1485         return 0;
1486 }
1487
1488 /**
1489  * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe
1490  * @frame: HDMI Audio infoframe
1491  * @buffer: source buffer
1492  * @size: size of buffer
1493  *
1494  * Unpacks the information contained in binary @buffer into a structured
1495  * @frame of the HDMI Audio information frame.
1496  * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1497  * specification.
1498  *
1499  * Returns 0 on success or a negative error code on failure.
1500  */
1501 static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame,
1502                                        const void *buffer, size_t size)
1503 {
1504         const u8 *ptr = buffer;
1505         int ret;
1506
1507         if (size < HDMI_INFOFRAME_SIZE(AUDIO))
1508                 return -EINVAL;
1509
1510         if (ptr[0] != HDMI_INFOFRAME_TYPE_AUDIO ||
1511             ptr[1] != 1 ||
1512             ptr[2] != HDMI_AUDIO_INFOFRAME_SIZE) {
1513                 return -EINVAL;
1514         }
1515
1516         if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_SIZE(AUDIO)) != 0)
1517                 return -EINVAL;
1518
1519         ret = hdmi_audio_infoframe_init(frame);
1520         if (ret)
1521                 return ret;
1522
1523         ptr += HDMI_INFOFRAME_HEADER_SIZE;
1524
1525         frame->channels = ptr[0] & 0x7;
1526         frame->coding_type = (ptr[0] >> 4) & 0xf;
1527         frame->sample_size = ptr[1] & 0x3;
1528         frame->sample_frequency = (ptr[1] >> 2) & 0x7;
1529         frame->coding_type_ext = ptr[2] & 0x1f;
1530         frame->channel_allocation = ptr[3];
1531         frame->level_shift_value = (ptr[4] >> 3) & 0xf;
1532         frame->downmix_inhibit = ptr[4] & 0x80 ? true : false;
1533
1534         return 0;
1535 }
1536
1537 /**
1538  * hdmi_vendor_infoframe_unpack() - unpack binary buffer to a HDMI vendor infoframe
1539  * @frame: HDMI Vendor infoframe
1540  * @buffer: source buffer
1541  * @size: size of buffer
1542  *
1543  * Unpacks the information contained in binary @buffer into a structured
1544  * @frame of the HDMI Vendor information frame.
1545  * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1546  * specification.
1547  *
1548  * Returns 0 on success or a negative error code on failure.
1549  */
1550 static int
1551 hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame,
1552                                  const void *buffer, size_t size)
1553 {
1554         const u8 *ptr = buffer;
1555         size_t length;
1556         int ret;
1557         u8 hdmi_video_format;
1558         struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1559
1560         if (size < HDMI_INFOFRAME_HEADER_SIZE)
1561                 return -EINVAL;
1562
1563         if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR ||
1564             ptr[1] != 1 ||
1565             (ptr[2] != 4 && ptr[2] != 5 && ptr[2] != 6))
1566                 return -EINVAL;
1567
1568         length = ptr[2];
1569
1570         if (size < HDMI_INFOFRAME_HEADER_SIZE + length)
1571                 return -EINVAL;
1572
1573         if (hdmi_infoframe_checksum(buffer,
1574                                     HDMI_INFOFRAME_HEADER_SIZE + length) != 0)
1575                 return -EINVAL;
1576
1577         ptr += HDMI_INFOFRAME_HEADER_SIZE;
1578
1579         /* HDMI OUI */
1580         if ((ptr[0] != 0x03) ||
1581             (ptr[1] != 0x0c) ||
1582             (ptr[2] != 0x00))
1583                 return -EINVAL;
1584
1585         hdmi_video_format = ptr[3] >> 5;
1586
1587         if (hdmi_video_format > 0x2)
1588                 return -EINVAL;
1589
1590         ret = hdmi_vendor_infoframe_init(hvf);
1591         if (ret)
1592                 return ret;
1593
1594         hvf->length = length;
1595
1596         if (hdmi_video_format == 0x2) {
1597                 if (length != 5 && length != 6)
1598                         return -EINVAL;
1599                 hvf->s3d_struct = ptr[4] >> 4;
1600                 if (hvf->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF) {
1601                         if (length != 6)
1602                                 return -EINVAL;
1603                         hvf->s3d_ext_data = ptr[5] >> 4;
1604                 }
1605         } else if (hdmi_video_format == 0x1) {
1606                 if (length != 5)
1607                         return -EINVAL;
1608                 hvf->vic = ptr[4];
1609         } else {
1610                 if (length != 4)
1611                         return -EINVAL;
1612         }
1613
1614         return 0;
1615 }
1616
1617 /**
1618  * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe
1619  * @frame: HDMI infoframe
1620  * @buffer: source buffer
1621  * @size: size of buffer
1622  *
1623  * Unpacks the information contained in binary buffer @buffer into a structured
1624  * @frame of a HDMI infoframe.
1625  * Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4
1626  * specification.
1627  *
1628  * Returns 0 on success or a negative error code on failure.
1629  */
1630 int hdmi_infoframe_unpack(union hdmi_infoframe *frame,
1631                           const void *buffer, size_t size)
1632 {
1633         int ret;
1634         const u8 *ptr = buffer;
1635
1636         if (size < HDMI_INFOFRAME_HEADER_SIZE)
1637                 return -EINVAL;
1638
1639         switch (ptr[0]) {
1640         case HDMI_INFOFRAME_TYPE_AVI:
1641                 ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer, size);
1642                 break;
1643         case HDMI_INFOFRAME_TYPE_SPD:
1644                 ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer, size);
1645                 break;
1646         case HDMI_INFOFRAME_TYPE_AUDIO:
1647                 ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer, size);
1648                 break;
1649         case HDMI_INFOFRAME_TYPE_VENDOR:
1650                 ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer, size);
1651                 break;
1652         default:
1653                 ret = -EINVAL;
1654                 break;
1655         }
1656
1657         return ret;
1658 }
1659 EXPORT_SYMBOL(hdmi_infoframe_unpack);