[v2,2/2] drm: tegra: Add HDMI support

Commit Message

Thierry Reding Nov. 12, 2012, 9:55 p.m. UTC

This commit adds support for the HDMI output on the Tegra20 SoC. Only
one such output is available, but it can be driven by either of the two
display controllers.

A lot of work on this patch has been contributed by NVIDIA's Mark Zhang
<[e-mail]> and many other people at NVIDIA were very helpful in
getting the HDMI support and surrounding infrastructure to work.

Signed-off-by: Thierry Reding <[e-mail]>
---
Changes in v2:
- reuse debugfs infrastructure provided by the DRM core

 drivers/gpu/drm/tegra/Makefile |    2 +-
 drivers/gpu/drm/tegra/drm.h    |    2 +
 drivers/gpu/drm/tegra/hdmi.c   | 1324 ++++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/tegra/hdmi.h   |  575 +++++++++++++++++
 drivers/gpu/drm/tegra/host1x.c |    8 +
 5 files changed, 1910 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/tegra/hdmi.c
 create mode 100644 drivers/gpu/drm/tegra/hdmi.h

Comments

Mark Zhang Nov. 13, 2012, 7:27 a.m. UTC | #1

The patch is OK. Acknowledged. Thanks.

Mark
On 11/13/2012 05:55 AM, Thierry Reding wrote:
> This commit adds support for the HDMI output on the Tegra20 SoC. Only
> one such output is available, but it can be driven by either of the two
> display controllers.
> 
> A lot of work on this patch has been contributed by NVIDIA's Mark Zhang
> <[e-mail]> and many other people at NVIDIA were very helpful in
> getting the HDMI support and surrounding infrastructure to work.
> 
> Signed-off-by: Thierry Reding <[e-mail]>
> ---
> Changes in v2:
> - reuse debugfs infrastructure provided by the DRM core
> 
>  drivers/gpu/drm/tegra/Makefile |    2 +-
>  drivers/gpu/drm/tegra/drm.h    |    2 +
>  drivers/gpu/drm/tegra/hdmi.c   | 1324 ++++++++++++++++++++++++++++++++++++++++
>  drivers/gpu/drm/tegra/hdmi.h   |  575 +++++++++++++++++
>  drivers/gpu/drm/tegra/host1x.c |    8 +
>  5 files changed, 1910 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/tegra/hdmi.c
>  create mode 100644 drivers/gpu/drm/tegra/hdmi.h
> 
> diff --git a/drivers/gpu/drm/tegra/Makefile b/drivers/gpu/drm/tegra/Makefile
> index 624a807..80f73d1 100644
> --- a/drivers/gpu/drm/tegra/Makefile
> +++ b/drivers/gpu/drm/tegra/Makefile
> @@ -2,6 +2,6 @@ ccflags-y := -Iinclude/drm
>  ccflags-$(CONFIG_DRM_TEGRA_DEBUG) += -DDEBUG
> 
>  tegra-drm-y := drm.o fb.o dc.o host1x.o
> -tegra-drm-y += output.o rgb.o
> +tegra-drm-y += output.o rgb.o hdmi.o
> 
>  obj-$(CONFIG_DRM_TEGRA) += tegra-drm.o
> diff --git a/drivers/gpu/drm/tegra/drm.h b/drivers/gpu/drm/tegra/drm.h
> index a1a891e..c2c4d16 100644
> --- a/drivers/gpu/drm/tegra/drm.h
> +++ b/drivers/gpu/drm/tegra/drm.h
> @@ -131,6 +131,7 @@ struct tegra_output_ops {
> 
>  enum tegra_output_type {
>         TEGRA_OUTPUT_RGB,
> +       TEGRA_OUTPUT_HDMI,
>  };
> 
>  struct tegra_output {
> @@ -225,6 +226,7 @@ extern int tegra_drm_fb_init(struct drm_device *drm);
>  extern void tegra_drm_fb_exit(struct drm_device *drm);
> 
>  extern struct platform_driver tegra_host1x_driver;
> +extern struct platform_driver tegra_hdmi_driver;
>  extern struct platform_driver tegra_dc_driver;
>  extern struct drm_driver tegra_drm_driver;
> 
> diff --git a/drivers/gpu/drm/tegra/hdmi.c b/drivers/gpu/drm/tegra/hdmi.c
> new file mode 100644
> index 0000000..61a1d14
> --- /dev/null
> +++ b/drivers/gpu/drm/tegra/hdmi.c
> @@ -0,0 +1,1324 @@
> +/*
> + * Copyright (C) 2012 Avionic Design GmbH
> + * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/debugfs.h>
> +#include <linux/gpio.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +#include <linux/regulator/consumer.h>
> +
> +#include <mach/clk.h>
> +
> +#include "hdmi.h"
> +#include "drm.h"
> +#include "dc.h"
> +
> +struct tegra_hdmi {
> +       struct host1x_client client;
> +       struct tegra_output output;
> +       struct device *dev;
> +
> +       struct regulator *vdd;
> +       struct regulator *pll;
> +
> +       void __iomem *regs;
> +       unsigned int irq;
> +
> +       struct clk *clk_parent;
> +       struct clk *clk;
> +
> +       unsigned int audio_source;
> +       unsigned int audio_freq;
> +       bool stereo;
> +       bool dvi;
> +
> +       struct drm_info_list *debugfs_files;
> +       struct drm_minor *minor;
> +       struct dentry *debugfs;
> +};
> +
> +static inline struct tegra_hdmi *
> +host1x_client_to_hdmi(struct host1x_client *client)
> +{
> +       return container_of(client, struct tegra_hdmi, client);
> +}
> +
> +static inline struct tegra_hdmi *to_hdmi(struct tegra_output *output)
> +{
> +       return container_of(output, struct tegra_hdmi, output);
> +}
> +
> +#define HDMI_AUDIOCLK_FREQ 216000000
> +#define HDMI_REKEY_DEFAULT 56
> +
> +enum {
> +       AUTO = 0,
> +       SPDIF,
> +       HDA,
> +};
> +
> +static inline unsigned long tegra_hdmi_readl(struct tegra_hdmi *hdmi,
> +                                            unsigned long reg)
> +{
> +       return readl(hdmi->regs + (reg << 2));
> +}
> +
> +static inline void tegra_hdmi_writel(struct tegra_hdmi *hdmi, unsigned long val,
> +                                    unsigned long reg)
> +{
> +       writel(val, hdmi->regs + (reg << 2));
> +}
> +
> +struct tegra_hdmi_audio_config {
> +       unsigned int pclk;
> +       unsigned int n;
> +       unsigned int cts;
> +       unsigned int aval;
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_32k[] = {
> +       {  25200000, 4096,  25200, 24000 },
> +       {  27000000, 4096,  27000, 24000 },
> +       {  74250000, 4096,  74250, 24000 },
> +       { 148500000, 4096, 148500, 24000 },
> +       {         0,    0,      0,     0 },
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_44_1k[] = {
> +       {  25200000, 5880,  26250, 25000 },
> +       {  27000000, 5880,  28125, 25000 },
> +       {  74250000, 4704,  61875, 20000 },
> +       { 148500000, 4704, 123750, 20000 },
> +       {         0,    0,      0,     0 },
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_48k[] = {
> +       {  25200000, 6144,  25200, 24000 },
> +       {  27000000, 6144,  27000, 24000 },
> +       {  74250000, 6144,  74250, 24000 },
> +       { 148500000, 6144, 148500, 24000 },
> +       {         0,    0,      0,     0 },
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_88_2k[] = {
> +       {  25200000, 11760,  26250, 25000 },
> +       {  27000000, 11760,  28125, 25000 },
> +       {  74250000,  9408,  61875, 20000 },
> +       { 148500000,  9408, 123750, 20000 },
> +       {         0,     0,      0,     0 },
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_96k[] = {
> +       {  25200000, 12288,  25200, 24000 },
> +       {  27000000, 12288,  27000, 24000 },
> +       {  74250000, 12288,  74250, 24000 },
> +       { 148500000, 12288, 148500, 24000 },
> +       {         0,     0,      0,     0 },
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_176_4k[] = {
> +       {  25200000, 23520,  26250, 25000 },
> +       {  27000000, 23520,  28125, 25000 },
> +       {  74250000, 18816,  61875, 20000 },
> +       { 148500000, 18816, 123750, 20000 },
> +       {         0,     0,      0,     0 },
> +};
> +
> +static const struct tegra_hdmi_audio_config tegra_hdmi_audio_192k[] = {
> +       {  25200000, 24576,  25200, 24000 },
> +       {  27000000, 24576,  27000, 24000 },
> +       {  74250000, 24576,  74250, 24000 },
> +       { 148500000, 24576, 148500, 24000 },
> +       {         0,     0,      0,     0 },
> +};
> +
> +struct tmds_config {
> +       unsigned int pclk;
> +       u32 pll0;
> +       u32 pll1;
> +       u32 pe_current;
> +       u32 drive_current;
> +};
> +
> +static const struct tmds_config tegra2_tmds_config[] = {
> +       { /* 480p modes */
> +               .pclk = 27000000,
> +               .pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
> +                       SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(0) |
> +                       SOR_PLL_TX_REG_LOAD(3),
> +               .pll1 = SOR_PLL_TMDS_TERM_ENABLE,
> +               .pe_current = PE_CURRENT0(PE_CURRENT_0_0_mA) |
> +                       PE_CURRENT1(PE_CURRENT_0_0_mA) |
> +                       PE_CURRENT2(PE_CURRENT_0_0_mA) |
> +                       PE_CURRENT3(PE_CURRENT_0_0_mA),
> +               .drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE1(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE2(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE3(DRIVE_CURRENT_7_125_mA),
> +       }, { /* 720p modes */
> +               .pclk = 74250000,
> +               .pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
> +                       SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(1) |
> +                       SOR_PLL_TX_REG_LOAD(3),
> +               .pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
> +               .pe_current = PE_CURRENT0(PE_CURRENT_6_0_mA) |
> +                       PE_CURRENT1(PE_CURRENT_6_0_mA) |
> +                       PE_CURRENT2(PE_CURRENT_6_0_mA) |
> +                       PE_CURRENT3(PE_CURRENT_6_0_mA),
> +               .drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE1(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE2(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE3(DRIVE_CURRENT_7_125_mA),
> +       }, { /* 1080p modes */
> +               .pclk = UINT_MAX,
> +               .pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
> +                       SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(1) |
> +                       SOR_PLL_TX_REG_LOAD(3),
> +               .pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
> +               .pe_current = PE_CURRENT0(PE_CURRENT_6_0_mA) |
> +                       PE_CURRENT1(PE_CURRENT_6_0_mA) |
> +                       PE_CURRENT2(PE_CURRENT_6_0_mA) |
> +                       PE_CURRENT3(PE_CURRENT_6_0_mA),
> +               .drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE1(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE2(DRIVE_CURRENT_7_125_mA) |
> +                       DRIVE_CURRENT_LANE3(DRIVE_CURRENT_7_125_mA),
> +       },
> +};
> +
> +static const struct tmds_config tegra3_tmds_config[] = {
> +       { /* 480p modes */
> +               .pclk = 27000000,
> +               .pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
> +                       SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(0) |
> +                       SOR_PLL_TX_REG_LOAD(0),
> +               .pll1 = SOR_PLL_TMDS_TERM_ENABLE,
> +               .pe_current = PE_CURRENT0(PE_CURRENT_0_0_mA) |
> +                       PE_CURRENT1(PE_CURRENT_0_0_mA) |
> +                       PE_CURRENT2(PE_CURRENT_0_0_mA) |
> +                       PE_CURRENT3(PE_CURRENT_0_0_mA),
> +               .drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE1(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE2(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE3(DRIVE_CURRENT_5_250_mA),
> +       }, { /* 720p modes */
> +               .pclk = 74250000,
> +               .pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
> +                       SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(1) |
> +                       SOR_PLL_TX_REG_LOAD(0),
> +               .pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
> +               .pe_current = PE_CURRENT0(PE_CURRENT_5_0_mA) |
> +                       PE_CURRENT1(PE_CURRENT_5_0_mA) |
> +                       PE_CURRENT2(PE_CURRENT_5_0_mA) |
> +                       PE_CURRENT3(PE_CURRENT_5_0_mA),
> +               .drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE1(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE2(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE3(DRIVE_CURRENT_5_250_mA),
> +       }, { /* 1080p modes */
> +               .pclk = UINT_MAX,
> +               .pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
> +                       SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(3) |
> +                       SOR_PLL_TX_REG_LOAD(0),
> +               .pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
> +               .pe_current = PE_CURRENT0(PE_CURRENT_5_0_mA) |
> +                       PE_CURRENT1(PE_CURRENT_5_0_mA) |
> +                       PE_CURRENT2(PE_CURRENT_5_0_mA) |
> +                       PE_CURRENT3(PE_CURRENT_5_0_mA),
> +               .drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE1(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE2(DRIVE_CURRENT_5_250_mA) |
> +                       DRIVE_CURRENT_LANE3(DRIVE_CURRENT_5_250_mA),
> +       },
> +};
> +
> +static const struct tegra_hdmi_audio_config *
> +tegra_hdmi_get_audio_config(unsigned int audio_freq, unsigned int pclk)
> +{
> +       const struct tegra_hdmi_audio_config *table;
> +
> +       switch (audio_freq) {
> +       case 32000:
> +               table = tegra_hdmi_audio_32k;
> +               break;
> +
> +       case 44100:
> +               table = tegra_hdmi_audio_44_1k;
> +               break;
> +
> +       case 48000:
> +               table = tegra_hdmi_audio_48k;
> +               break;
> +
> +       case 88200:
> +               table = tegra_hdmi_audio_88_2k;
> +               break;
> +
> +       case 96000:
> +               table = tegra_hdmi_audio_96k;
> +               break;
> +
> +       case 176400:
> +               table = tegra_hdmi_audio_176_4k;
> +               break;
> +
> +       case 192000:
> +               table = tegra_hdmi_audio_192k;
> +               break;
> +
> +       default:
> +               return NULL;
> +       }
> +
> +       while (table->pclk) {
> +               if (table->pclk == pclk)
> +                       return table;
> +
> +               table++;
> +       }
> +
> +       return NULL;
> +}
> +
> +static void tegra_hdmi_setup_audio_fs_tables(struct tegra_hdmi *hdmi)
> +{
> +       const unsigned int freqs[] = {
> +               32000, 44100, 48000, 88200, 96000, 176400, 192000
> +       };
> +       unsigned int i;
> +
> +       for (i = 0; i < ARRAY_SIZE(freqs); i++) {
> +               unsigned int f = freqs[i];
> +               unsigned int eight_half;
> +               unsigned long value;
> +               unsigned int delta;
> +
> +               if (f > 96000)
> +                       delta = 2;
> +               else if (f > 480000)
> +                       delta = 6;
> +               else
> +                       delta = 9;
> +
> +               eight_half = (8 * HDMI_AUDIOCLK_FREQ) / (f * 128);
> +               value = AUDIO_FS_LOW(eight_half - delta) |
> +                       AUDIO_FS_HIGH(eight_half + delta);
> +               tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_FS(i));
> +       }
> +}
> +
> +static int tegra_hdmi_setup_audio(struct tegra_hdmi *hdmi, unsigned int pclk)
> +{
> +       struct device_node *node = hdmi->dev->of_node;
> +       const struct tegra_hdmi_audio_config *config;
> +       unsigned int offset = 0;
> +       unsigned long value;
> +
> +       switch (hdmi->audio_source) {
> +       case HDA:
> +               value = AUDIO_CNTRL0_SOURCE_SELECT_HDAL;
> +               break;
> +
> +       case SPDIF:
> +               value = AUDIO_CNTRL0_SOURCE_SELECT_SPDIF;
> +               break;
> +
> +       default:
> +               value = AUDIO_CNTRL0_SOURCE_SELECT_AUTO;
> +               break;
> +       }
> +
> +       if (of_device_is_compatible(node, "nvidia,tegra30-hdmi")) {
> +               value |= AUDIO_CNTRL0_ERROR_TOLERANCE(6) |
> +                        AUDIO_CNTRL0_FRAMES_PER_BLOCK(0xc0);
> +               tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_CNTRL0);
> +       } else {
> +               value |= AUDIO_CNTRL0_INJECT_NULLSMPL;
> +               tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_AUDIO_CNTRL0);
> +
> +               value = AUDIO_CNTRL0_ERROR_TOLERANCE(6) |
> +                       AUDIO_CNTRL0_FRAMES_PER_BLOCK(0xc0);
> +               tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_CNTRL0);
> +       }
> +
> +       config = tegra_hdmi_get_audio_config(hdmi->audio_freq, pclk);
> +       if (!config) {
> +               dev_err(hdmi->dev, "cannot set audio to %u at %u pclk\n",
> +                       hdmi->audio_freq, pclk);
> +               return -EINVAL;
> +       }
> +
> +       tegra_hdmi_writel(hdmi, 0, HDMI_NV_PDISP_HDMI_ACR_CTRL);
> +
> +       value = AUDIO_N_RESETF | AUDIO_N_GENERATE_ALTERNATE |
> +               AUDIO_N_VALUE(config->n - 1);
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_N);
> +
> +       tegra_hdmi_writel(hdmi, ACR_SUBPACK_N(config->n) | ACR_ENABLE,
> +                         HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_HIGH);
> +
> +       value = ACR_SUBPACK_CTS(config->cts);
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_LOW);
> +
> +       value = SPARE_HW_CTS | SPARE_FORCE_SW_CTS | SPARE_CTS_RESET_VAL(1);
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_SPARE);
> +
> +       value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_AUDIO_N);
> +       value &= ~AUDIO_N_RESETF;
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_N);
> +
> +       if (of_device_is_compatible(node, "nvidia,tegra30-hdmi")) {
> +               switch (hdmi->audio_freq) {
> +               case 32000:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0320;
> +                       break;
> +
> +               case 44100:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0441;
> +                       break;
> +
> +               case 48000:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0480;
> +                       break;
> +
> +               case 88200:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0882;
> +                       break;
> +
> +               case 96000:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0960;
> +                       break;
> +
> +               case 176400:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_1764;
> +                       break;
> +
> +               case 192000:
> +                       offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_1920;
> +                       break;
> +               }
> +
> +               tegra_hdmi_writel(hdmi, config->aval, offset);
> +       }
> +
> +       tegra_hdmi_setup_audio_fs_tables(hdmi);
> +
> +       return 0;
> +}
> +
> +static void tegra_hdmi_write_infopack(struct tegra_hdmi *hdmi,
> +                                     unsigned int offset, u8 type,
> +                                     u8 version, void *data, size_t size)
> +{
> +       unsigned long value;
> +       u8 *ptr = data;
> +       u32 subpack[2];
> +       size_t i;
> +       u8 csum;
> +
> +       /* first byte of data is the checksum */
> +       csum = type + version + size - 1;
> +
> +       for (i = 1; i < size; i++)
> +               csum += ptr[i];
> +
> +       ptr[0] = 0x100 - csum;
> +
> +       value = INFOFRAME_HEADER_TYPE(type) |
> +               INFOFRAME_HEADER_VERSION(version) |
> +               INFOFRAME_HEADER_LEN(size - 1);
> +       tegra_hdmi_writel(hdmi, value, offset);
> +
> +       /* The audio inforame only has one set of subpack registers.  The hdmi
> +        * block pads the rest of the data as per the spec so we have to fixup
> +        * the length before filling in the subpacks.
> +        */
> +       if (offset == HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER)
> +               size = 6;
> +
> +       /* each subpack 7 bytes devided into:
> +        *   subpack_low - bytes 0 - 3
> +        *   subpack_high - bytes 4 - 6 (with byte 7 padded to 0x00)
> +        */
> +       for (i = 0; i < size; i++) {
> +               size_t index = i % 7;
> +
> +               if (index == 0)
> +                       memset(subpack, 0x0, sizeof(subpack));
> +
> +               ((u8 *)subpack)[index] = ptr[i];
> +
> +               if (index == 6 || (i + 1 == size)) {
> +                       unsigned int reg = offset + 1 + (i / 7) * 2;
> +
> +                       tegra_hdmi_writel(hdmi, subpack[0], reg);
> +                       tegra_hdmi_writel(hdmi, subpack[1], reg + 1);
> +               }
> +       }
> +}
> +
> +static void tegra_hdmi_setup_avi_infoframe(struct tegra_hdmi *hdmi,
> +                                          struct drm_display_mode *mode)
> +{
> +       struct hdmi_avi_infoframe frame;
> +       unsigned int h_front_porch;
> +       unsigned int hsize = 16;
> +       unsigned int vsize = 9;
> +
> +       if (hdmi->dvi) {
> +               tegra_hdmi_writel(hdmi, 0,
> +                                 HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL);
> +               return;
> +       }
> +
> +       h_front_porch = mode->htotal - mode->hsync_end;
> +       memset(&frame, 0, sizeof(frame));
> +       frame.r = HDMI_AVI_R_SAME;
> +
> +       switch (mode->vdisplay) {
> +       case 480:
> +               if (mode->hdisplay == 640) {
> +                       frame.m = HDMI_AVI_M_4_3;
> +                       frame.vic = 1;
> +               } else {
> +                       frame.m = HDMI_AVI_M_16_9;
> +                       frame.vic = 3;
> +               }
> +               break;
> +
> +       case 576:
> +               if (((hsize * 10) / vsize) > 14) {
> +                       frame.m = HDMI_AVI_M_16_9;
> +                       frame.vic = 18;
> +               } else {
> +                       frame.m = HDMI_AVI_M_4_3;
> +                       frame.vic = 17;
> +               }
> +               break;
> +
> +       case 720:
> +       case 1470: /* stereo mode */
> +               frame.m = HDMI_AVI_M_16_9;
> +
> +               if (h_front_porch == 110)
> +                       frame.vic = 4;
> +               else
> +                       frame.vic = 19;
> +               break;
> +
> +       case 1080:
> +       case 2205: /* stereo mode */
> +               frame.m = HDMI_AVI_M_16_9;
> +
> +               switch (h_front_porch) {
> +               case 88:
> +                       frame.vic = 16;
> +                       break;
> +
> +               case 528:
> +                       frame.vic = 31;
> +                       break;
> +
> +               default:
> +                       frame.vic = 32;
> +                       break;
> +               }
> +               break;
> +
> +       default:
> +               frame.m = HDMI_AVI_M_16_9;
> +               frame.vic = 0;
> +               break;
> +       }
> +
> +       tegra_hdmi_write_infopack(hdmi, HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_HEADER,
> +                                 HDMI_INFOFRAME_TYPE_AVI, HDMI_AVI_VERSION,
> +                                 &frame, sizeof(frame));
> +
> +       tegra_hdmi_writel(hdmi, INFOFRAME_CTRL_ENABLE,
> +                         HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL);
> +}
> +
> +static void tegra_hdmi_setup_audio_infoframe(struct tegra_hdmi *hdmi)
> +{
> +       struct hdmi_audio_infoframe frame;
> +
> +       if (hdmi->dvi) {
> +               tegra_hdmi_writel(hdmi, 0,
> +                                 HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL);
> +               return;
> +       }
> +
> +       memset(&frame, 0, sizeof(frame));
> +       frame.cc = HDMI_AUDIO_CC_2;
> +
> +       tegra_hdmi_write_infopack(hdmi,
> +                                 HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER,
> +                                 HDMI_INFOFRAME_TYPE_AUDIO,
> +                                 HDMI_AUDIO_VERSION,
> +                                 &frame, sizeof(frame));
> +
> +       tegra_hdmi_writel(hdmi, INFOFRAME_CTRL_ENABLE,
> +                         HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL);
> +}
> +
> +static void tegra_hdmi_setup_stereo_infoframe(struct tegra_hdmi *hdmi)
> +{
> +       struct hdmi_stereo_infoframe frame;
> +       unsigned long value;
> +
> +       if (!hdmi->stereo) {
> +               value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +               value &= ~GENERIC_CTRL_ENABLE;
> +               tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +               return;
> +       }
> +
> +       memset(&frame, 0, sizeof(frame));
> +       frame.regid0 = 0x03;
> +       frame.regid1 = 0x0c;
> +       frame.regid2 = 0x00;
> +       frame.hdmi_video_format = 2;
> +
> +       /* TODO: 74 MHz limit? */
> +       if (1) {
> +               frame._3d_structure = 0;
> +       } else {
> +               frame._3d_structure = 8;
> +               frame._3d_ext_data = 0;
> +       }
> +
> +       tegra_hdmi_write_infopack(hdmi, HDMI_NV_PDISP_HDMI_GENERIC_HEADER,
> +                                 HDMI_INFOFRAME_TYPE_VENDOR,
> +                                 HDMI_VENDOR_VERSION, &frame, 6);
> +
> +       value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +       value |= GENERIC_CTRL_ENABLE;
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +}
> +
> +static void tegra_hdmi_setup_tmds(struct tegra_hdmi *hdmi,
> +                                 const struct tmds_config *tmds)
> +{
> +       unsigned long value;
> +
> +       tegra_hdmi_writel(hdmi, tmds->pll0, HDMI_NV_PDISP_SOR_PLL0);
> +       tegra_hdmi_writel(hdmi, tmds->pll1, HDMI_NV_PDISP_SOR_PLL1);
> +       tegra_hdmi_writel(hdmi, tmds->pe_current, HDMI_NV_PDISP_PE_CURRENT);
> +
> +       value = tmds->drive_current | DRIVE_CURRENT_FUSE_OVERRIDE;
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_LANE_DRIVE_CURRENT);
> +}
> +
> +static int tegra_output_hdmi_enable(struct tegra_output *output)
> +{
> +       unsigned int h_sync_width, h_front_porch, h_back_porch, i, rekey;
> +       struct tegra_dc *dc = to_tegra_dc(output->encoder.crtc);
> +       struct drm_display_mode *mode = &dc->base.mode;
> +       struct tegra_hdmi *hdmi = to_hdmi(output);
> +       struct device_node *node = hdmi->dev->of_node;
> +       unsigned int pulse_start, div82, pclk;
> +       const struct tmds_config *tmds;
> +       unsigned int num_tmds;
> +       unsigned long value;
> +       int retries = 1000;
> +       int err;
> +
> +       pclk = mode->clock * 1000;
> +       h_sync_width = mode->hsync_end - mode->hsync_start;
> +       h_front_porch = mode->htotal - mode->hsync_end;
> +       h_back_porch = mode->hsync_start - mode->hdisplay;
> +       dev_dbg(output->dev, "SW/FP/BP: %u %u %u\n",
> +                       h_sync_width, h_front_porch, h_back_porch);
> +
> +       err = regulator_enable(hdmi->vdd);
> +       if (err < 0) {
> +               dev_err(hdmi->dev, "failed to enable VDD regulator: %d\n", err);
> +               return err;
> +       }
> +
> +       err = regulator_enable(hdmi->pll);
> +       if (err < 0) {
> +               dev_err(hdmi->dev, "failed to enable PLL regulator: %d\n", err);
> +               return err;
> +       }
> +
> +       /*
> +        * This assumes that the display controller will divide its parent
> +        * clock by 2 to generate the pixel clock.
> +        */
> +       err = tegra_output_setup_clock(output, hdmi->clk, pclk * 2);
> +       if (err < 0) {
> +               dev_err(hdmi->dev, "failed to setup clock: %d\n", err);
> +               return err;
> +       }
> +
> +       err = clk_set_rate(hdmi->clk, pclk);
> +       if (err < 0)
> +               return err;
> +
> +       err = clk_enable(hdmi->clk);
> +       if (err < 0) {
> +               dev_err(hdmi->dev, "failed to enable clock: %d\n", err);
> +               return err;
> +       }
> +
> +       tegra_periph_reset_assert(hdmi->clk);
> +       usleep_range(1000, 2000);
> +       tegra_periph_reset_deassert(hdmi->clk);
> +
> +       tegra_dc_writel(dc, VSYNC_H_POSITION(1),
> +                       DC_DISP_DISP_TIMING_OPTIONS);
> +       tegra_dc_writel(dc, DITHER_CONTROL_DISABLE | BASE_COLOR_SIZE888,
> +                       DC_DISP_DISP_COLOR_CONTROL);
> +
> +       /* video_preamble uses h_pulse2 */
> +       pulse_start = 1 + h_sync_width + h_back_porch - 10;
> +
> +       tegra_dc_writel(dc, H_PULSE_2_ENABLE, DC_DISP_DISP_SIGNAL_OPTIONS0);
> +
> +       value = PULSE_MODE_NORMAL | PULSE_POLARITY_HIGH | PULSE_QUAL_VACTIVE |
> +               PULSE_LAST_END_A;
> +       tegra_dc_writel(dc, value, DC_DISP_H_PULSE2_CONTROL);
> +
> +       value = PULSE_START(pulse_start) | PULSE_END(pulse_start + 8);
> +       tegra_dc_writel(dc, value, DC_DISP_H_PULSE2_POSITION_A);
> +
> +       value = VSYNC_WINDOW_END(0x210) | VSYNC_WINDOW_START(0x200) |
> +               VSYNC_WINDOW_ENABLE;
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_VSYNC_WINDOW);
> +
> +       if (dc->pipe)
> +               value = HDMI_SRC_DISPLAYB;
> +       else
> +               value = HDMI_SRC_DISPLAYA;
> +
> +       if ((mode->hdisplay == 720) && ((mode->vdisplay == 480) ||
> +                                       (mode->vdisplay == 576)))
> +               tegra_hdmi_writel(hdmi,
> +                                 value | ARM_VIDEO_RANGE_FULL,
> +                                 HDMI_NV_PDISP_INPUT_CONTROL);
> +       else
> +               tegra_hdmi_writel(hdmi,
> +                                 value | ARM_VIDEO_RANGE_LIMITED,
> +                                 HDMI_NV_PDISP_INPUT_CONTROL);
> +
> +       div82 = clk_get_rate(hdmi->clk) / 1000000 * 4;
> +       value = SOR_REFCLK_DIV_INT(div82 >> 2) | SOR_REFCLK_DIV_FRAC(div82);
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_REFCLK);
> +
> +       if (!hdmi->dvi) {
> +               err = tegra_hdmi_setup_audio(hdmi, pclk);
> +               if (err < 0)
> +                       hdmi->dvi = true;
> +       }
> +
> +       if (of_device_is_compatible(node, "nvidia,tegra20-hdmi")) {
> +               /*
> +                * TODO: add ELD support
> +                */
> +       }
> +
> +       rekey = HDMI_REKEY_DEFAULT;
> +       value = HDMI_CTRL_REKEY(rekey);
> +       value |= HDMI_CTRL_MAX_AC_PACKET((h_sync_width + h_back_porch +
> +                                         h_front_porch - rekey - 18) / 32);
> +
> +       if (!hdmi->dvi)
> +               value |= HDMI_CTRL_ENABLE;
> +
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_CTRL);
> +
> +       if (hdmi->dvi)
> +               tegra_hdmi_writel(hdmi, 0x0,
> +                                 HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +       else
> +               tegra_hdmi_writel(hdmi, GENERIC_CTRL_AUDIO,
> +                                 HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +
> +       tegra_hdmi_setup_avi_infoframe(hdmi, mode);
> +       tegra_hdmi_setup_audio_infoframe(hdmi);
> +       tegra_hdmi_setup_stereo_infoframe(hdmi);
> +
> +       /* TMDS CONFIG */
> +       if (of_device_is_compatible(node, "nvidia,tegra30-hdmi")) {
> +               num_tmds = ARRAY_SIZE(tegra3_tmds_config);
> +               tmds = tegra3_tmds_config;
> +       } else {
> +               num_tmds = ARRAY_SIZE(tegra2_tmds_config);
> +               tmds = tegra2_tmds_config;
> +       }
> +
> +       for (i = 0; i < num_tmds; i++) {
> +               if (pclk <= tmds[i].pclk) {
> +                       tegra_hdmi_setup_tmds(hdmi, &tmds[i]);
> +                       break;
> +               }
> +       }
> +
> +       tegra_hdmi_writel(hdmi,
> +                         SOR_SEQ_CTL_PU_PC(0) |
> +                         SOR_SEQ_PU_PC_ALT(0) |
> +                         SOR_SEQ_PD_PC(8) |
> +                         SOR_SEQ_PD_PC_ALT(8),
> +                         HDMI_NV_PDISP_SOR_SEQ_CTL);
> +
> +       value = SOR_SEQ_INST_WAIT_TIME(1) |
> +               SOR_SEQ_INST_WAIT_UNITS_VSYNC |
> +               SOR_SEQ_INST_HALT |
> +               SOR_SEQ_INST_PIN_A_LOW |
> +               SOR_SEQ_INST_PIN_B_LOW |
> +               SOR_SEQ_INST_DRIVE_PWM_OUT_LO;
> +
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_SEQ_INST(0));
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_SEQ_INST(8));
> +
> +       value = 0x1c800;
> +       value &= ~SOR_CSTM_ROTCLK(~0);
> +       value |= SOR_CSTM_ROTCLK(2);
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_CSTM);
> +
> +       tegra_dc_writel(dc, DISP_CTRL_MODE_STOP, DC_CMD_DISPLAY_COMMAND);
> +       tegra_dc_writel(dc, GENERAL_ACT_REQ << 8, DC_CMD_STATE_CONTROL);
> +       tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
> +
> +       /* start SOR */
> +       tegra_hdmi_writel(hdmi,
> +                         SOR_PWR_NORMAL_STATE_PU |
> +                         SOR_PWR_NORMAL_START_NORMAL |
> +                         SOR_PWR_SAFE_STATE_PD |
> +                         SOR_PWR_SETTING_NEW_TRIGGER,
> +                         HDMI_NV_PDISP_SOR_PWR);
> +       tegra_hdmi_writel(hdmi,
> +                         SOR_PWR_NORMAL_STATE_PU |
> +                         SOR_PWR_NORMAL_START_NORMAL |
> +                         SOR_PWR_SAFE_STATE_PD |
> +                         SOR_PWR_SETTING_NEW_DONE,
> +                         HDMI_NV_PDISP_SOR_PWR);
> +
> +       do {
> +               BUG_ON(--retries < 0);
> +               value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_SOR_PWR);
> +       } while (value & SOR_PWR_SETTING_NEW_PENDING);
> +
> +       value = SOR_STATE_ASY_CRCMODE_COMPLETE |
> +               SOR_STATE_ASY_OWNER_HEAD0 |
> +               SOR_STATE_ASY_SUBOWNER_BOTH |
> +               SOR_STATE_ASY_PROTOCOL_SINGLE_TMDS_A |
> +               SOR_STATE_ASY_DEPOL_POS;
> +
> +       /* setup sync polarities */
> +       if (mode->flags & DRM_MODE_FLAG_PHSYNC)
> +               value |= SOR_STATE_ASY_HSYNCPOL_POS;
> +
> +       if (mode->flags & DRM_MODE_FLAG_NHSYNC)
> +               value |= SOR_STATE_ASY_HSYNCPOL_NEG;
> +
> +       if (mode->flags & DRM_MODE_FLAG_PVSYNC)
> +               value |= SOR_STATE_ASY_VSYNCPOL_POS;
> +
> +       if (mode->flags & DRM_MODE_FLAG_NVSYNC)
> +               value |= SOR_STATE_ASY_VSYNCPOL_NEG;
> +
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_STATE2);
> +
> +       value = SOR_STATE_ASY_HEAD_OPMODE_AWAKE | SOR_STATE_ASY_ORMODE_NORMAL;
> +       tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_STATE1);
> +
> +       tegra_hdmi_writel(hdmi, 0, HDMI_NV_PDISP_SOR_STATE0);
> +       tegra_hdmi_writel(hdmi, SOR_STATE_UPDATE, HDMI_NV_PDISP_SOR_STATE0);
> +       tegra_hdmi_writel(hdmi, value | SOR_STATE_ATTACHED,
> +                         HDMI_NV_PDISP_SOR_STATE1);
> +       tegra_hdmi_writel(hdmi, 0, HDMI_NV_PDISP_SOR_STATE0);
> +
> +       tegra_dc_writel(dc, HDMI_ENABLE, DC_DISP_DISP_WIN_OPTIONS);
> +
> +       value = PW0_ENABLE | PW1_ENABLE | PW2_ENABLE | PW3_ENABLE |
> +               PW4_ENABLE | PM0_ENABLE | PM1_ENABLE;
> +       tegra_dc_writel(dc, value, DC_CMD_DISPLAY_POWER_CONTROL);
> +
> +       value = DISP_CTRL_MODE_C_DISPLAY;
> +       tegra_dc_writel(dc, value, DC_CMD_DISPLAY_COMMAND);
> +
> +       tegra_dc_writel(dc, GENERAL_ACT_REQ << 8, DC_CMD_STATE_CONTROL);
> +       tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
> +
> +       /* TODO: add HDCP support */
> +
> +       return 0;
> +}
> +
> +static int tegra_output_hdmi_disable(struct tegra_output *output)
> +{
> +       struct tegra_hdmi *hdmi = to_hdmi(output);
> +
> +       tegra_periph_reset_assert(hdmi->clk);
> +       clk_disable(hdmi->clk);
> +       regulator_disable(hdmi->pll);
> +       regulator_disable(hdmi->vdd);
> +
> +       return 0;
> +}
> +
> +static int tegra_output_hdmi_setup_clock(struct tegra_output *output,
> +                                        struct clk *clk, unsigned long pclk)
> +{
> +       struct tegra_hdmi *hdmi = to_hdmi(output);
> +       struct clk *base;
> +       int err;
> +
> +       err = clk_set_parent(clk, hdmi->clk_parent);
> +       if (err < 0) {
> +               dev_err(output->dev, "failed to set parent: %d\n", err);
> +               return err;
> +       }
> +
> +       base = clk_get_parent(hdmi->clk_parent);
> +
> +       /*
> +        * This assumes that the parent clock is pll_d_out0 or pll_d2_out
> +        * respectively, each of which divides the base pll_d by 2.
> +        */
> +       err = clk_set_rate(base, pclk * 2);
> +       if (err < 0)
> +               dev_err(output->dev,
> +                       "failed to set base clock rate to %lu Hz\n",
> +                       pclk * 2);
> +
> +       return 0;
> +}
> +
> +static int tegra_output_hdmi_check_mode(struct tegra_output *output,
> +                                       struct drm_display_mode *mode,
> +                                       enum drm_mode_status *status)
> +{
> +       struct tegra_hdmi *hdmi = to_hdmi(output);
> +       unsigned long pclk = mode->clock * 1000;
> +       struct clk *parent;
> +       long err;
> +
> +       parent = clk_get_parent(hdmi->clk_parent);
> +
> +       err = clk_round_rate(parent, pclk * 4);
> +       if (err < 0)
> +               *status = MODE_NOCLOCK;
> +       else
> +               *status = MODE_OK;
> +
> +       return 0;
> +}
> +
> +static const struct tegra_output_ops hdmi_ops = {
> +       .enable = tegra_output_hdmi_enable,
> +       .disable = tegra_output_hdmi_disable,
> +       .setup_clock = tegra_output_hdmi_setup_clock,
> +       .check_mode = tegra_output_hdmi_check_mode,
> +};
> +
> +static int tegra_hdmi_show_regs(struct seq_file *s, void *data)
> +{
> +       struct drm_info_node *node = s->private;
> +       struct tegra_hdmi *hdmi = node->info_ent->data;
> +
> +#define DUMP_REG(name)                                         \
> +       seq_printf(s, "%-56s %#05x %08lx\n", #name, name,       \
> +               tegra_hdmi_readl(hdmi, name))
> +
> +       DUMP_REG(HDMI_CTXSW);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_STATE0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_STATE1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_STATE2);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AN_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AN_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CN_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CN_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AKSV_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AKSV_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_BKSV_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_BKSV_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CKSV_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CKSV_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_DKSV_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_DKSV_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CMODE);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_MPRIME_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_MPRIME_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_SPRIME_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB2);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB1);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_RI);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CS_MSB);
> +       DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CS_LSB);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU0);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU_RDATA0);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU1);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU2);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_STATUS);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_STATUS);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_HEADER);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_STATUS);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_HEADER);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_LOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_HIGH);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_VSYNC_KEEPOUT);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_VSYNC_WINDOW);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GCP_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GCP_STATUS);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_GCP_SUBPACK);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_CHANNEL_STATUS1);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_CHANNEL_STATUS2);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_EMU0);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_EMU1);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_EMU1_RDATA);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_SPARE);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS1);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS2);
> +       DUMP_REG(HDMI_NV_PDISP_HDMI_HDCPRIF_ROM_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_CAP);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_PWR);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_TEST);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_PLL0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_PLL1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_PLL2);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_CSTM);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_LVDS);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_CRCA);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_CRCB);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_BLANK);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_CTL);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(0));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(1));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(2));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(3));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(4));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(5));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(6));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(7));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(8));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(9));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(10));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(11));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(12));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(13));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(14));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(15));
> +       DUMP_REG(HDMI_NV_PDISP_SOR_VCRCA0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_VCRCA1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_CCRCA0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_CCRCA1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_EDATAA0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_EDATAA1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_COUNTA0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_COUNTA1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_DEBUGA0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_DEBUGA1);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_TRIG);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_MSCHECK);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_LANE_DRIVE_CURRENT);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_DEBUG0);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_DEBUG1);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_DEBUG2);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(0));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(1));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(2));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(3));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(4));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(5));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(6));
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_PULSE_WIDTH);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_THRESHOLD);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_CNTRL0);
> +       DUMP_REG(HDMI_NV_PDISP_AUDIO_N);
> +       DUMP_REG(HDMI_NV_PDISP_HDCPRIF_ROM_TIMING);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_REFCLK);
> +       DUMP_REG(HDMI_NV_PDISP_CRC_CONTROL);
> +       DUMP_REG(HDMI_NV_PDISP_INPUT_CONTROL);
> +       DUMP_REG(HDMI_NV_PDISP_SCRATCH);
> +       DUMP_REG(HDMI_NV_PDISP_PE_CURRENT);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_CTRL);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_DEBUG0);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_DEBUG1);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_DEBUG2);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_0);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_1);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_2);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_3);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_TRIG);
> +       DUMP_REG(HDMI_NV_PDISP_KEY_SKEY_INDEX);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_AUDIO_CNTRL0);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_AUDIO_HDA_ELD_BUFWR);
> +       DUMP_REG(HDMI_NV_PDISP_SOR_AUDIO_HDA_PRESENSE);
> +
> +#undef DUMP_REG
> +
> +       return 0;
> +}
> +
> +static struct drm_info_list debugfs_files[] = {
> +       { "regs", tegra_hdmi_show_regs, 0, NULL },
> +};
> +
> +static int tegra_hdmi_debugfs_init(struct tegra_hdmi *hdmi,
> +                                  struct drm_minor *minor)
> +{
> +       unsigned int i;
> +       int err;
> +
> +       hdmi->debugfs = debugfs_create_dir("hdmi", minor->debugfs_root);
> +       if (!hdmi->debugfs)
> +               return -ENOMEM;
> +
> +       hdmi->debugfs_files = kmemdup(debugfs_files, sizeof(debugfs_files),
> +                                     GFP_KERNEL);
> +       if (!hdmi->debugfs_files) {
> +               err = -ENOMEM;
> +               goto remove;
> +       }
> +
> +       for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
> +               hdmi->debugfs_files[i].data = hdmi;
> +
> +       err = drm_debugfs_create_files(hdmi->debugfs_files,
> +                                      ARRAY_SIZE(debugfs_files),
> +                                      hdmi->debugfs, minor);
> +       if (err < 0)
> +               goto free;
> +
> +       hdmi->minor = minor;
> +
> +       return 0;
> +
> +free:
> +       kfree(hdmi->debugfs_files);
> +       hdmi->debugfs_files = NULL;
> +remove:
> +       debugfs_remove(hdmi->debugfs);
> +       hdmi->debugfs = NULL;
> +
> +       return err;
> +}
> +
> +static int tegra_hdmi_debugfs_exit(struct tegra_hdmi *hdmi)
> +{
> +       drm_debugfs_remove_files(hdmi->debugfs_files, ARRAY_SIZE(debugfs_files),
> +                                hdmi->minor);
> +       hdmi->minor = NULL;
> +
> +       kfree(hdmi->debugfs_files);
> +       hdmi->debugfs_files = NULL;
> +
> +       debugfs_remove(hdmi->debugfs);
> +       hdmi->debugfs = NULL;
> +
> +       return 0;
> +}
> +
> +static int tegra_hdmi_drm_init(struct host1x_client *client,
> +                              struct drm_device *drm)
> +{
> +       struct tegra_hdmi *hdmi = host1x_client_to_hdmi(client);
> +       int err;
> +
> +       hdmi->output.type = TEGRA_OUTPUT_HDMI;
> +       hdmi->output.dev = client->dev;
> +       hdmi->output.ops = &hdmi_ops;
> +
> +       err = tegra_output_init(drm, &hdmi->output);
> +       if (err < 0) {
> +               dev_err(client->dev, "output setup failed: %d\n", err);
> +               return err;
> +       }
> +
> +       if (IS_ENABLED(CONFIG_DEBUG_FS)) {
> +               err = tegra_hdmi_debugfs_init(hdmi, drm->primary);
> +               if (err < 0)
> +                       dev_err(client->dev, "debugfs setup failed: %d\n", err);
> +       }
> +
> +       return 0;
> +}
> +
> +static int tegra_hdmi_drm_exit(struct host1x_client *client)
> +{
> +       struct tegra_hdmi *hdmi = host1x_client_to_hdmi(client);
> +       int err;
> +
> +       if (IS_ENABLED(CONFIG_DEBUG_FS)) {
> +               err = tegra_hdmi_debugfs_exit(hdmi);
> +               if (err < 0)
> +                       dev_err(client->dev, "debugfs cleanup failed: %d\n",
> +                               err);
> +       }
> +
> +       err = tegra_output_exit(&hdmi->output);
> +       if (err < 0) {
> +               dev_err(client->dev, "output cleanup failed: %d\n", err);
> +               return err;
> +       }
> +
> +       return 0;
> +}
> +
> +static const struct host1x_client_ops hdmi_client_ops = {
> +       .drm_init = tegra_hdmi_drm_init,
> +       .drm_exit = tegra_hdmi_drm_exit,
> +};
> +
> +static int tegra_hdmi_probe(struct platform_device *pdev)
> +{
> +       struct host1x *host1x = dev_get_drvdata(pdev->dev.parent);
> +       struct tegra_hdmi *hdmi;
> +       struct resource *regs;
> +       int err;
> +
> +       hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL);
> +       if (!hdmi)
> +               return -ENOMEM;
> +
> +       hdmi->dev = &pdev->dev;
> +       hdmi->audio_source = AUTO;
> +       hdmi->audio_freq = 44100;
> +       hdmi->stereo = false;
> +       hdmi->dvi = false;
> +
> +       hdmi->clk = devm_clk_get(&pdev->dev, NULL);
> +       if (IS_ERR_OR_NULL(hdmi->clk))
> +               return PTR_ERR(hdmi->clk);
> +
> +       err = clk_prepare(hdmi->clk);
> +       if (err < 0)
> +               return err;
> +
> +       hdmi->clk_parent = devm_clk_get(&pdev->dev, "parent");
> +       if (IS_ERR_OR_NULL(hdmi->clk_parent))
> +               return PTR_ERR(hdmi->clk_parent);
> +
> +       err = clk_prepare(hdmi->clk_parent);
> +       if (err < 0)
> +               return err;
> +
> +       err = clk_set_parent(hdmi->clk, hdmi->clk_parent);
> +       if (err < 0) {
> +               dev_err(&pdev->dev, "failed to setup clocks: %d\n", err);
> +               return err;
> +       }
> +
> +       hdmi->vdd = devm_regulator_get(&pdev->dev, "vdd");
> +       if (IS_ERR_OR_NULL(hdmi->vdd)) {
> +               err = PTR_ERR(hdmi->vdd);
> +               dev_err(&pdev->dev, "failed to get VDD regulator: %d\n", err);
> +               return err;
> +       }
> +
> +       hdmi->pll = devm_regulator_get(&pdev->dev, "pll");
> +       if (IS_ERR_OR_NULL(hdmi->pll)) {
> +               err = PTR_ERR(hdmi->pll);
> +               dev_err(&pdev->dev, "failed to get PLL regulator: %d\n", err);
> +               return err;
> +       }
> +
> +       regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +       if (!regs)
> +               return -ENXIO;
> +
> +       hdmi->regs = devm_request_and_ioremap(&pdev->dev, regs);
> +       if (!hdmi->regs)
> +               return -EADDRNOTAVAIL;
> +
> +       err = platform_get_irq(pdev, 0);
> +       if (err < 0)
> +               return err;
> +
> +       hdmi->irq = err;
> +
> +       hdmi->client.ops = &hdmi_client_ops;
> +       INIT_LIST_HEAD(&hdmi->client.list);
> +       hdmi->client.dev = &pdev->dev;
> +
> +       err = host1x_register_client(host1x, &hdmi->client);
> +       if (err < 0) {
> +               dev_err(&pdev->dev, "failed to register host1x client: %d\n",
> +                       err);
> +               return err;
> +       }
> +
> +       platform_set_drvdata(pdev, hdmi);
> +
> +       return 0;
> +}
> +
> +static int tegra_hdmi_remove(struct platform_device *pdev)
> +{
> +       struct host1x *host1x = dev_get_drvdata(pdev->dev.parent);
> +       struct tegra_hdmi *hdmi = platform_get_drvdata(pdev);
> +       int err;
> +
> +       err = host1x_unregister_client(host1x, &hdmi->client);
> +       if (err < 0) {
> +               dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
> +                       err);
> +               return err;
> +       }
> +
> +       clk_unprepare(hdmi->clk_parent);
> +       clk_unprepare(hdmi->clk);
> +
> +       return 0;
> +}
> +
> +static struct of_device_id tegra_hdmi_of_match[] = {
> +       { .compatible = "nvidia,tegra20-hdmi", },
> +       { .compatible = "nvidia,tegra30-hdmi", },
> +       { },
> +};
> +
> +struct platform_driver tegra_hdmi_driver = {
> +       .driver = {
> +               .name = "tegra-hdmi",
> +               .owner = THIS_MODULE,
> +               .of_match_table = tegra_hdmi_of_match,
> +       },
> +       .probe = tegra_hdmi_probe,
> +       .remove = tegra_hdmi_remove,
> +};
> diff --git a/drivers/gpu/drm/tegra/hdmi.h b/drivers/gpu/drm/tegra/hdmi.h
> new file mode 100644
> index 0000000..1477f36
> --- /dev/null
> +++ b/drivers/gpu/drm/tegra/hdmi.h
> @@ -0,0 +1,575 @@
> +/*
> + * Copyright (C) 2012 Avionic Design GmbH
> + * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + */
> +
> +#ifndef TEGRA_HDMI_H
> +#define TEGRA_HDMI_H 1
> +
> +#define HDMI_INFOFRAME_TYPE_VENDOR   0x81
> +#define HDMI_INFOFRAME_TYPE_AVI      0x82
> +#define HDMI_INFOFRAME_TYPE_SPD      0x83
> +#define HDMI_INFOFRAME_TYPE_AUDIO    0x84
> +#define HDMI_INFOFRAME_TYPE_MPEG_SRC 0x85
> +#define HDMI_INFOFRAME_TYPE_NTSC_VBI 0x86
> +
> +/* all fields little endian */
> +struct hdmi_avi_infoframe {
> +       /* PB0 */
> +       u8 csum;
> +
> +       /* PB1 */
> +       unsigned s:2; /* scan information */
> +       unsigned b:2; /* bar info data valid */
> +       unsigned a:1; /* active info present */
> +       unsigned y:2; /* RGB or YCbCr */
> +       unsigned res1:1;
> +
> +       /* PB2 */
> +       unsigned r:4; /* active format aspect ratio */
> +       unsigned m:2; /* picture aspect ratio */
> +       unsigned c:2; /* colorimetry */
> +
> +       /* PB3 */
> +       unsigned sc:2;  /* scan information */
> +       unsigned q:2;   /* quantization range */
> +       unsigned ec:3;  /* extended colorimetry */
> +       unsigned itc:1; /* it content */
> +
> +       /* PB4 */
> +       unsigned vic:7; /* video format id code */
> +       unsigned res4:1;
> +
> +       /* PB5 */
> +       unsigned pr:4; /* pixel repetition factor */
> +       unsigned cn:2; /* it content type*/
> +       unsigned yq:2; /* ycc quantization range */
> +
> +       /* PB6-7 */
> +       u16 top_bar_end_line;
> +
> +       /* PB8-9 */
> +       u16 bot_bar_start_line;
> +
> +       /* PB10-11 */
> +       u16 left_bar_end_pixel;
> +
> +       /* PB12-13 */
> +       u16 right_bar_start_pixel;
> +} __packed;
> +
> +#define HDMI_AVI_VERSION 0x02
> +
> +#define HDMI_AVI_Y_RGB       0x0
> +#define HDMI_AVI_Y_YCBCR_422 0x1
> +#define HDMI_AVI_Y_YCBCR_444 0x2
> +
> +#define HDMI_AVI_B_VERT  0x1
> +#define HDMI_AVI_B_HORIZ 0x2
> +
> +#define HDMI_AVI_S_NONE      0x0
> +#define HDMI_AVI_S_OVERSCAN  0x1
> +#define HDMI_AVI_S_UNDERSCAN 0x2
> +
> +#define HDMI_AVI_C_NONE     0x0
> +#define HDMI_AVI_C_SMPTE    0x1
> +#define HDMI_AVI_C_ITU_R    0x2
> +#define HDMI_AVI_C_EXTENDED 0x4
> +
> +#define HDMI_AVI_M_4_3  0x1
> +#define HDMI_AVI_M_16_9 0x2
> +
> +#define HDMI_AVI_R_SAME        0x8
> +#define HDMI_AVI_R_4_3_CENTER  0x9
> +#define HDMI_AVI_R_16_9_CENTER 0xa
> +#define HDMI_AVI_R_14_9_CENTER 0xb
> +
> +/* all fields little endian */
> +struct hdmi_audio_infoframe {
> +       /* PB0 */
> +       u8 csum;
> +
> +       /* PB1 */
> +       unsigned cc:3; /* channel count */
> +       unsigned res1:1;
> +       unsigned ct:4; /* coding type */
> +
> +       /* PB2 */
> +       unsigned ss:2; /* sample size */
> +       unsigned sf:3; /* sample frequency */
> +       unsigned res2:3;
> +
> +       /* PB3 */
> +       unsigned cxt:5; /* coding extention type */
> +       unsigned res3:3;
> +
> +       /* PB4 */
> +       u8 ca; /* channel/speaker allocation */
> +
> +       /* PB5 */
> +       unsigned res5:3;
> +       unsigned lsv:4; /* level shift value */
> +       unsigned dm_inh:1; /* downmix inhibit */
> +
> +       /* PB6-10 reserved */
> +       u8 res6;
> +       u8 res7;
> +       u8 res8;
> +       u8 res9;
> +       u8 res10;
> +} __packed;
> +
> +#define HDMI_AUDIO_VERSION 0x01
> +
> +#define HDMI_AUDIO_CC_STREAM 0x0 /* specified by audio stream */
> +#define HDMI_AUDIO_CC_2      0x1
> +#define HDMI_AUDIO_CC_3      0x2
> +#define HDMI_AUDIO_CC_4      0x3
> +#define HDMI_AUDIO_CC_5      0x4
> +#define HDMI_AUDIO_CC_6      0x5
> +#define HDMI_AUDIO_CC_7      0x6
> +#define HDMI_AUDIO_CC_8      0x7
> +
> +#define HDMI_AUDIO_CT_STREAM  0x0 /* specified by audio stream */
> +#define HDMI_AUDIO_CT_PCM     0x1
> +#define HDMI_AUDIO_CT_AC3     0x2
> +#define HDMI_AUDIO_CT_MPEG1   0x3
> +#define HDMI_AUDIO_CT_MP3     0x4
> +#define HDMI_AUDIO_CT_MPEG2   0x5
> +#define HDMI_AUDIO_CT_AAC_LC  0x6
> +#define HDMI_AUDIO_CT_DTS     0x7
> +#define HDMI_AUDIO_CT_ATRAC   0x8
> +#define HDMI_AUDIO_CT_DSD     0x9
> +#define HDMI_AUDIO_CT_E_AC3   0xa
> +#define HDMI_AUDIO_CT_DTS_HD  0xb
> +#define HDMI_AUDIO_CT_MLP     0xc
> +#define HDMI_AUDIO_CT_DST     0xd
> +#define HDMI_AUDIO_CT_WMA_PRO 0xe
> +#define HDMI_AUDIO_CT_CXT     0xf
> +
> +#define HDMI_AUDIO_SF_STREAM 0x0 /* specified by audio stream */
> +#define HDMI_AUIDO_SF_32K    0x1
> +#define HDMI_AUDIO_SF_44_1K  0x2
> +#define HDMI_AUDIO_SF_48K    0x3
> +#define HDMI_AUDIO_SF_88_2K  0x4
> +#define HDMI_AUDIO_SF_96K    0x5
> +#define HDMI_AUDIO_SF_176_4K 0x6
> +#define HDMI_AUDIO_SF_192K   0x7
> +
> +#define HDMI_AUDIO_SS_STREAM 0x0 /* specified by audio stream */
> +#define HDMI_AUDIO_SS_16BIT  0x1
> +#define HDMI_AUDIO_SS_20BIT  0x2
> +#define HDMI_AUDIO_SS_24BIT  0x3
> +
> +#define HDMI_AUDIO_CXT_CT            0x0 /* refer to coding in CT */
> +#define HDMI_AUDIO_CXT_HE_AAC        0x1
> +#define HDMI_AUDIO_CXT_HE_AAC_V2     0x2
> +#define HDMI_AUDIO_CXT_MPEG_SURROUND 0x3
> +
> +/* all fields little endian */
> +struct hdmi_stereo_infoframe {
> +       /* PB0 */
> +       u8 csum;
> +
> +       /* PB1 */
> +       u8 regid0;
> +
> +       /* PB2 */
> +       u8 regid1;
> +
> +       /* PB3 */
> +       u8 regid2;
> +
> +       /* PB4 */
> +       unsigned res1:5;
> +       unsigned hdmi_video_format:3;
> +
> +       /* PB5 */
> +       unsigned res2:4;
> +       unsigned _3d_structure:4;
> +
> +       /* PB6*/
> +       unsigned res3:4;
> +       unsigned _3d_ext_data:4;
> +} __packed;
> +
> +#define HDMI_VENDOR_VERSION 0x01
> +
> +/* register definitions */
> +#define HDMI_CTXSW                                             0x00
> +
> +#define HDMI_NV_PDISP_SOR_STATE0                               0x01
> +#define SOR_STATE_UPDATE (1 << 0)
> +
> +#define HDMI_NV_PDISP_SOR_STATE1                               0x02
> +#define SOR_STATE_ASY_HEAD_OPMODE_AWAKE (2 << 0)
> +#define SOR_STATE_ASY_ORMODE_NORMAL     (1 << 2)
> +#define SOR_STATE_ATTACHED              (1 << 3)
> +
> +#define HDMI_NV_PDISP_SOR_STATE2                               0x03
> +#define SOR_STATE_ASY_OWNER_NONE         (0 <<  0)
> +#define SOR_STATE_ASY_OWNER_HEAD0        (1 <<  0)
> +#define SOR_STATE_ASY_SUBOWNER_NONE      (0 <<  4)
> +#define SOR_STATE_ASY_SUBOWNER_SUBHEAD0  (1 <<  4)
> +#define SOR_STATE_ASY_SUBOWNER_SUBHEAD1  (2 <<  4)
> +#define SOR_STATE_ASY_SUBOWNER_BOTH      (3 <<  4)
> +#define SOR_STATE_ASY_CRCMODE_ACTIVE     (0 <<  6)
> +#define SOR_STATE_ASY_CRCMODE_COMPLETE   (1 <<  6)
> +#define SOR_STATE_ASY_CRCMODE_NON_ACTIVE (2 <<  6)
> +#define SOR_STATE_ASY_PROTOCOL_SINGLE_TMDS_A (1 << 8)
> +#define SOR_STATE_ASY_PROTOCOL_CUSTOM        (15 << 8)
> +#define SOR_STATE_ASY_HSYNCPOL_POS       (0 << 12)
> +#define SOR_STATE_ASY_HSYNCPOL_NEG       (1 << 12)
> +#define SOR_STATE_ASY_VSYNCPOL_POS       (0 << 13)
> +#define SOR_STATE_ASY_VSYNCPOL_NEG       (1 << 13)
> +#define SOR_STATE_ASY_DEPOL_POS          (0 << 14)
> +#define SOR_STATE_ASY_DEPOL_NEG          (1 << 14)
> +
> +#define HDMI_NV_PDISP_RG_HDCP_AN_MSB                           0x04
> +#define HDMI_NV_PDISP_RG_HDCP_AN_LSB                           0x05
> +#define HDMI_NV_PDISP_RG_HDCP_CN_MSB                           0x06
> +#define HDMI_NV_PDISP_RG_HDCP_CN_LSB                           0x07
> +#define HDMI_NV_PDISP_RG_HDCP_AKSV_MSB                         0x08
> +#define HDMI_NV_PDISP_RG_HDCP_AKSV_LSB                         0x09
> +#define HDMI_NV_PDISP_RG_HDCP_BKSV_MSB                         0x0a
> +#define HDMI_NV_PDISP_RG_HDCP_BKSV_LSB                         0x0b
> +#define HDMI_NV_PDISP_RG_HDCP_CKSV_MSB                         0x0c
> +#define HDMI_NV_PDISP_RG_HDCP_CKSV_LSB                         0x0d
> +#define HDMI_NV_PDISP_RG_HDCP_DKSV_MSB                         0x0e
> +#define HDMI_NV_PDISP_RG_HDCP_DKSV_LSB                         0x0f
> +#define HDMI_NV_PDISP_RG_HDCP_CTRL                             0x10
> +#define HDMI_NV_PDISP_RG_HDCP_CMODE                            0x11
> +#define HDMI_NV_PDISP_RG_HDCP_MPRIME_MSB                       0x12
> +#define HDMI_NV_PDISP_RG_HDCP_MPRIME_LSB                       0x13
> +#define HDMI_NV_PDISP_RG_HDCP_SPRIME_MSB                       0x14
> +#define HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB2                      0x15
> +#define HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB1                      0x16
> +#define HDMI_NV_PDISP_RG_HDCP_RI                               0x17
> +#define HDMI_NV_PDISP_RG_HDCP_CS_MSB                           0x18
> +#define HDMI_NV_PDISP_RG_HDCP_CS_LSB                           0x19
> +#define HDMI_NV_PDISP_HDMI_AUDIO_EMU0                          0x1a
> +#define HDMI_NV_PDISP_HDMI_AUDIO_EMU_RDATA0                    0x1b
> +#define HDMI_NV_PDISP_HDMI_AUDIO_EMU1                          0x1c
> +#define HDMI_NV_PDISP_HDMI_AUDIO_EMU2                          0x1d
> +
> +#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL                        0x1e
> +#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_STATUS              0x1f
> +#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER              0x20
> +#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_LOW                0x21
> +#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_HIGH       0x22
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL                  0x23
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_STATUS                        0x24
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_HEADER                        0x25
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_LOW          0x26
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_HIGH         0x27
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_LOW          0x28
> +#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_HIGH         0x29
> +
> +#define INFOFRAME_CTRL_ENABLE (1 << 0)
> +
> +#define INFOFRAME_HEADER_TYPE(x)    (((x) & 0xff) <<  0)
> +#define INFOFRAME_HEADER_VERSION(x) (((x) & 0xff) <<  8)
> +#define INFOFRAME_HEADER_LEN(x)     (((x) & 0x0f) << 16)
> +
> +#define HDMI_NV_PDISP_HDMI_GENERIC_CTRL                                0x2a
> +#define GENERIC_CTRL_ENABLE (1 <<  0)
> +#define GENERIC_CTRL_OTHER  (1 <<  4)
> +#define GENERIC_CTRL_SINGLE (1 <<  8)
> +#define GENERIC_CTRL_HBLANK (1 << 12)
> +#define GENERIC_CTRL_AUDIO  (1 << 16)
> +
> +#define HDMI_NV_PDISP_HDMI_GENERIC_STATUS                      0x2b
> +#define HDMI_NV_PDISP_HDMI_GENERIC_HEADER                      0x2c
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_LOW                        0x2d
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_HIGH               0x2e
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_LOW                        0x2f
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_HIGH               0x30
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_LOW                        0x31
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_HIGH               0x32
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_LOW                        0x33
> +#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_HIGH               0x34
> +
> +#define HDMI_NV_PDISP_HDMI_ACR_CTRL                            0x35
> +#define HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_LOW                        0x36
> +#define HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_HIGH               0x37
> +#define HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_LOW                        0x38
> +#define HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_HIGH               0x39
> +#define HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_LOW                        0x3a
> +#define HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_HIGH               0x3b
> +#define HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_LOW                        0x3c
> +#define HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_HIGH               0x3d
> +#define HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_LOW                        0x3e
> +#define HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_HIGH               0x3f
> +#define HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_LOW                        0x40
> +#define HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_HIGH               0x41
> +#define HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_LOW                        0x42
> +#define HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_HIGH               0x43
> +
> +#define ACR_SUBPACK_CTS(x) (((x) & 0xffffff) << 8)
> +#define ACR_SUBPACK_N(x)   (((x) & 0xffffff) << 0)
> +#define ACR_ENABLE         (1 << 31)
> +
> +#define HDMI_NV_PDISP_HDMI_CTRL                                        0x44
> +#define HDMI_CTRL_REKEY(x)         (((x) & 0x7f) <<  0)
> +#define HDMI_CTRL_MAX_AC_PACKET(x) (((x) & 0x1f) << 16)
> +#define HDMI_CTRL_ENABLE           (1 << 30)
> +
> +#define HDMI_NV_PDISP_HDMI_VSYNC_KEEPOUT                       0x45
> +#define HDMI_NV_PDISP_HDMI_VSYNC_WINDOW                                0x46
> +#define VSYNC_WINDOW_END(x)   (((x) & 0x3ff) <<  0)
> +#define VSYNC_WINDOW_START(x) (((x) & 0x3ff) << 16)
> +#define VSYNC_WINDOW_ENABLE   (1 << 31)
> +
> +#define HDMI_NV_PDISP_HDMI_GCP_CTRL                            0x47
> +#define HDMI_NV_PDISP_HDMI_GCP_STATUS                          0x48
> +#define HDMI_NV_PDISP_HDMI_GCP_SUBPACK                         0x49
> +#define HDMI_NV_PDISP_HDMI_CHANNEL_STATUS1                     0x4a
> +#define HDMI_NV_PDISP_HDMI_CHANNEL_STATUS2                     0x4b
> +#define HDMI_NV_PDISP_HDMI_EMU0                                        0x4c
> +#define HDMI_NV_PDISP_HDMI_EMU1                                        0x4d
> +#define HDMI_NV_PDISP_HDMI_EMU1_RDATA                          0x4e
> +
> +#define HDMI_NV_PDISP_HDMI_SPARE                               0x4f
> +#define SPARE_HW_CTS           (1 << 0)
> +#define SPARE_FORCE_SW_CTS     (1 << 1)
> +#define SPARE_CTS_RESET_VAL(x) (((x) & 0x7) << 16)
> +
> +#define HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS1                   0x50
> +#define HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS2                   0x51
> +#define HDMI_NV_PDISP_HDMI_HDCPRIF_ROM_CTRL                    0x53
> +#define HDMI_NV_PDISP_SOR_CAP                                  0x54
> +#define HDMI_NV_PDISP_SOR_PWR                                  0x55
> +#define SOR_PWR_NORMAL_STATE_PD     (0 <<  0)
> +#define SOR_PWR_NORMAL_STATE_PU     (1 <<  0)
> +#define SOR_PWR_NORMAL_START_NORMAL (0 <<  1)
> +#define SOR_PWR_NORMAL_START_ALT    (1 <<  1)
> +#define SOR_PWR_SAFE_STATE_PD       (0 << 16)
> +#define SOR_PWR_SAFE_STATE_PU       (1 << 16)
> +#define SOR_PWR_SETTING_NEW_DONE    (0 << 31)
> +#define SOR_PWR_SETTING_NEW_PENDING (1 << 31)
> +#define SOR_PWR_SETTING_NEW_TRIGGER (1 << 31)
> +
> +#define HDMI_NV_PDISP_SOR_TEST                                 0x56
> +#define HDMI_NV_PDISP_SOR_PLL0                                 0x57
> +#define SOR_PLL_PWR            (1 << 0)
> +#define SOR_PLL_PDBG           (1 << 1)
> +#define SOR_PLL_VCAPD          (1 << 2)
> +#define SOR_PLL_PDPORT         (1 << 3)
> +#define SOR_PLL_RESISTORSEL    (1 << 4)
> +#define SOR_PLL_PULLDOWN       (1 << 5)
> +#define SOR_PLL_VCOCAP(x)      (((x) & 0xf) <<  8)
> +#define SOR_PLL_BG_V17_S(x)    (((x) & 0xf) << 12)
> +#define SOR_PLL_FILTER(x)      (((x) & 0xf) << 16)
> +#define SOR_PLL_ICHPMP(x)      (((x) & 0xf) << 24)
> +#define SOR_PLL_TX_REG_LOAD(x) (((x) & 0xf) << 28)
> +
> +#define HDMI_NV_PDISP_SOR_PLL1                                 0x58
> +#define SOR_PLL_TMDS_TERM_ENABLE (1 << 8)
> +#define SOR_PLL_TMDS_TERMADJ(x)  (((x) & 0xf) <<  9)
> +#define SOR_PLL_LOADADJ(x)       (((x) & 0xf) << 20)
> +#define SOR_PLL_PE_EN            (1 << 28)
> +#define SOR_PLL_HALF_FULL_PE     (1 << 29)
> +#define SOR_PLL_S_D_PIN_PE       (1 << 30)
> +
> +#define HDMI_NV_PDISP_SOR_PLL2                                 0x59
> +
> +#define HDMI_NV_PDISP_SOR_CSTM                                 0x5a
> +#define SOR_CSTM_ROTCLK(x) (((x) & 0xf) << 24)
> +
> +#define HDMI_NV_PDISP_SOR_LVDS                                 0x5b
> +#define HDMI_NV_PDISP_SOR_CRCA                                 0x5c
> +#define HDMI_NV_PDISP_SOR_CRCB                                 0x5d
> +#define HDMI_NV_PDISP_SOR_BLANK                                        0x5e
> +#define HDMI_NV_PDISP_SOR_SEQ_CTL                              0x5f
> +#define SOR_SEQ_CTL_PU_PC(x) (((x) & 0xf) <<  0)
> +#define SOR_SEQ_PU_PC_ALT(x) (((x) & 0xf) <<  4)
> +#define SOR_SEQ_PD_PC(x)     (((x) & 0xf) <<  8)
> +#define SOR_SEQ_PD_PC_ALT(x) (((x) & 0xf) << 12)
> +#define SOR_SEQ_PC(x)        (((x) & 0xf) << 16)
> +#define SOR_SEQ_STATUS       (1 << 28)
> +#define SOR_SEQ_SWITCH       (1 << 30)
> +
> +#define HDMI_NV_PDISP_SOR_SEQ_INST(x)                          (0x60 + (x))
> +
> +#define SOR_SEQ_INST_WAIT_TIME(x)     (((x) & 0x3ff) << 0)
> +#define SOR_SEQ_INST_WAIT_UNITS_VSYNC (2 << 12)
> +#define SOR_SEQ_INST_HALT             (1 << 15)
> +#define SOR_SEQ_INST_PIN_A_LOW        (0 << 21)
> +#define SOR_SEQ_INST_PIN_A_HIGH       (1 << 21)
> +#define SOR_SEQ_INST_PIN_B_LOW        (0 << 22)
> +#define SOR_SEQ_INST_PIN_B_HIGH       (1 << 22)
> +#define SOR_SEQ_INST_DRIVE_PWM_OUT_LO (1 << 23)
> +
> +#define HDMI_NV_PDISP_SOR_VCRCA0                               0x72
> +#define HDMI_NV_PDISP_SOR_VCRCA1                               0x73
> +#define HDMI_NV_PDISP_SOR_CCRCA0                               0x74
> +#define HDMI_NV_PDISP_SOR_CCRCA1                               0x75
> +#define HDMI_NV_PDISP_SOR_EDATAA0                              0x76
> +#define HDMI_NV_PDISP_SOR_EDATAA1                              0x77
> +#define HDMI_NV_PDISP_SOR_COUNTA0                              0x78
> +#define HDMI_NV_PDISP_SOR_COUNTA1                              0x79
> +#define HDMI_NV_PDISP_SOR_DEBUGA0                              0x7a
> +#define HDMI_NV_PDISP_SOR_DEBUGA1                              0x7b
> +#define HDMI_NV_PDISP_SOR_TRIG                                 0x7c
> +#define HDMI_NV_PDISP_SOR_MSCHECK                              0x7d
> +
> +#define HDMI_NV_PDISP_SOR_LANE_DRIVE_CURRENT                   0x7e
> +#define DRIVE_CURRENT_LANE0(x)      (((x) & 0x3f) <<  0)
> +#define DRIVE_CURRENT_LANE1(x)      (((x) & 0x3f) <<  8)
> +#define DRIVE_CURRENT_LANE2(x)      (((x) & 0x3f) << 16)
> +#define DRIVE_CURRENT_LANE3(x)      (((x) & 0x3f) << 24)
> +#define DRIVE_CURRENT_FUSE_OVERRIDE (1 << 31)
> +
> +#define DRIVE_CURRENT_1_500_mA  0x00
> +#define DRIVE_CURRENT_1_875_mA  0x01
> +#define DRIVE_CURRENT_2_250_mA  0x02
> +#define DRIVE_CURRENT_2_625_mA  0x03
> +#define DRIVE_CURRENT_3_000_mA  0x04
> +#define DRIVE_CURRENT_3_375_mA  0x05
> +#define DRIVE_CURRENT_3_750_mA  0x06
> +#define DRIVE_CURRENT_4_125_mA  0x07
> +#define DRIVE_CURRENT_4_500_mA  0x08
> +#define DRIVE_CURRENT_4_875_mA  0x09
> +#define DRIVE_CURRENT_5_250_mA  0x0a
> +#define DRIVE_CURRENT_5_625_mA  0x0b
> +#define DRIVE_CURRENT_6_000_mA  0x0c
> +#define DRIVE_CURRENT_6_375_mA  0x0d
> +#define DRIVE_CURRENT_6_750_mA  0x0e
> +#define DRIVE_CURRENT_7_125_mA  0x0f
> +#define DRIVE_CURRENT_7_500_mA  0x10
> +#define DRIVE_CURRENT_7_875_mA  0x11
> +#define DRIVE_CURRENT_8_250_mA  0x12
> +#define DRIVE_CURRENT_8_625_mA  0x13
> +#define DRIVE_CURRENT_9_000_mA  0x14
> +#define DRIVE_CURRENT_9_375_mA  0x15
> +#define DRIVE_CURRENT_9_750_mA  0x16
> +#define DRIVE_CURRENT_10_125_mA 0x17
> +#define DRIVE_CURRENT_10_500_mA 0x18
> +#define DRIVE_CURRENT_10_875_mA 0x19
> +#define DRIVE_CURRENT_11_250_mA 0x1a
> +#define DRIVE_CURRENT_11_625_mA 0x1b
> +#define DRIVE_CURRENT_12_000_mA 0x1c
> +#define DRIVE_CURRENT_12_375_mA 0x1d
> +#define DRIVE_CURRENT_12_750_mA 0x1e
> +#define DRIVE_CURRENT_13_125_mA 0x1f
> +#define DRIVE_CURRENT_13_500_mA 0x20
> +#define DRIVE_CURRENT_13_875_mA 0x21
> +#define DRIVE_CURRENT_14_250_mA 0x22
> +#define DRIVE_CURRENT_14_625_mA 0x23
> +#define DRIVE_CURRENT_15_000_mA 0x24
> +#define DRIVE_CURRENT_15_375_mA 0x25
> +#define DRIVE_CURRENT_15_750_mA 0x26
> +#define DRIVE_CURRENT_16_125_mA 0x27
> +#define DRIVE_CURRENT_16_500_mA 0x28
> +#define DRIVE_CURRENT_16_875_mA 0x29
> +#define DRIVE_CURRENT_17_250_mA 0x2a
> +#define DRIVE_CURRENT_17_625_mA 0x2b
> +#define DRIVE_CURRENT_18_000_mA 0x2c
> +#define DRIVE_CURRENT_18_375_mA 0x2d
> +#define DRIVE_CURRENT_18_750_mA 0x2e
> +#define DRIVE_CURRENT_19_125_mA 0x2f
> +#define DRIVE_CURRENT_19_500_mA 0x30
> +#define DRIVE_CURRENT_19_875_mA 0x31
> +#define DRIVE_CURRENT_20_250_mA 0x32
> +#define DRIVE_CURRENT_20_625_mA 0x33
> +#define DRIVE_CURRENT_21_000_mA 0x34
> +#define DRIVE_CURRENT_21_375_mA 0x35
> +#define DRIVE_CURRENT_21_750_mA 0x36
> +#define DRIVE_CURRENT_22_125_mA 0x37
> +#define DRIVE_CURRENT_22_500_mA 0x38
> +#define DRIVE_CURRENT_22_875_mA 0x39
> +#define DRIVE_CURRENT_23_250_mA 0x3a
> +#define DRIVE_CURRENT_23_625_mA 0x3b
> +#define DRIVE_CURRENT_24_000_mA 0x3c
> +#define DRIVE_CURRENT_24_375_mA 0x3d
> +#define DRIVE_CURRENT_24_750_mA 0x3e
> +
> +#define HDMI_NV_PDISP_AUDIO_DEBUG0                             0x7f
> +#define HDMI_NV_PDISP_AUDIO_DEBUG1                             0x80
> +#define HDMI_NV_PDISP_AUDIO_DEBUG2                             0x81
> +
> +#define HDMI_NV_PDISP_AUDIO_FS(x)                              (0x82 + (x))
> +#define AUDIO_FS_LOW(x)  (((x) & 0xfff) <<  0)
> +#define AUDIO_FS_HIGH(x) (((x) & 0xfff) << 16)
> +
> +#define HDMI_NV_PDISP_AUDIO_PULSE_WIDTH                                0x89
> +#define HDMI_NV_PDISP_AUDIO_THRESHOLD                          0x8a
> +#define HDMI_NV_PDISP_AUDIO_CNTRL0                             0x8b
> +#define AUDIO_CNTRL0_ERROR_TOLERANCE(x)  (((x) & 0xff) << 0)
> +#define AUDIO_CNTRL0_SOURCE_SELECT_AUTO  (0 << 20)
> +#define AUDIO_CNTRL0_SOURCE_SELECT_SPDIF (1 << 20)
> +#define AUDIO_CNTRL0_SOURCE_SELECT_HDAL  (2 << 20)
> +#define AUDIO_CNTRL0_FRAMES_PER_BLOCK(x) (((x) & 0xff) << 24)
> +
> +#define HDMI_NV_PDISP_AUDIO_N                                  0x8c
> +#define AUDIO_N_VALUE(x)           (((x) & 0xfffff) << 0)
> +#define AUDIO_N_RESETF             (1 << 20)
> +#define AUDIO_N_GENERATE_NORMAL    (0 << 24)
> +#define AUDIO_N_GENERATE_ALTERNATE (1 << 24)
> +
> +#define HDMI_NV_PDISP_HDCPRIF_ROM_TIMING                       0x94
> +#define HDMI_NV_PDISP_SOR_REFCLK                               0x95
> +#define SOR_REFCLK_DIV_INT(x)  (((x) & 0xff) << 8)
> +#define SOR_REFCLK_DIV_FRAC(x) (((x) & 0x03) << 6)
> +
> +#define HDMI_NV_PDISP_CRC_CONTROL                              0x96
> +#define HDMI_NV_PDISP_INPUT_CONTROL                            0x97
> +#define HDMI_SRC_DISPLAYA       (0 << 0)
> +#define HDMI_SRC_DISPLAYB       (1 << 0)
> +#define ARM_VIDEO_RANGE_FULL    (0 << 1)
> +#define ARM_VIDEO_RANGE_LIMITED (1 << 1)
> +
> +#define HDMI_NV_PDISP_SCRATCH                                  0x98
> +#define HDMI_NV_PDISP_PE_CURRENT                               0x99
> +#define PE_CURRENT0(x) (((x) & 0xf) << 0)
> +#define PE_CURRENT1(x) (((x) & 0xf) << 8)
> +#define PE_CURRENT2(x) (((x) & 0xf) << 16)
> +#define PE_CURRENT3(x) (((x) & 0xf) << 24)
> +
> +#define PE_CURRENT_0_0_mA 0x0
> +#define PE_CURRENT_0_5_mA 0x1
> +#define PE_CURRENT_1_0_mA 0x2
> +#define PE_CURRENT_1_5_mA 0x3
> +#define PE_CURRENT_2_0_mA 0x4
> +#define PE_CURRENT_2_5_mA 0x5
> +#define PE_CURRENT_3_0_mA 0x6
> +#define PE_CURRENT_3_5_mA 0x7
> +#define PE_CURRENT_4_0_mA 0x8
> +#define PE_CURRENT_4_5_mA 0x9
> +#define PE_CURRENT_5_0_mA 0xa
> +#define PE_CURRENT_5_5_mA 0xb
> +#define PE_CURRENT_6_0_mA 0xc
> +#define PE_CURRENT_6_5_mA 0xd
> +#define PE_CURRENT_7_0_mA 0xe
> +#define PE_CURRENT_7_5_mA 0xf
> +
> +#define HDMI_NV_PDISP_KEY_CTRL                                 0x9a
> +#define HDMI_NV_PDISP_KEY_DEBUG0                               0x9b
> +#define HDMI_NV_PDISP_KEY_DEBUG1                               0x9c
> +#define HDMI_NV_PDISP_KEY_DEBUG2                               0x9d
> +#define HDMI_NV_PDISP_KEY_HDCP_KEY_0                           0x9e
> +#define HDMI_NV_PDISP_KEY_HDCP_KEY_1                           0x9f
> +#define HDMI_NV_PDISP_KEY_HDCP_KEY_2                           0xa0
> +#define HDMI_NV_PDISP_KEY_HDCP_KEY_3                           0xa1
> +#define HDMI_NV_PDISP_KEY_HDCP_KEY_TRIG                                0xa2
> +#define HDMI_NV_PDISP_KEY_SKEY_INDEX                           0xa3
> +
> +#define HDMI_NV_PDISP_SOR_AUDIO_CNTRL0                         0xac
> +#define AUDIO_CNTRL0_INJECT_NULLSMPL (1 << 29)
> +#define HDMI_NV_PDISP_SOR_AUDIO_HDA_ELD_BUFWR                  0xbc
> +#define HDMI_NV_PDISP_SOR_AUDIO_HDA_PRESENSE                   0xbd
> +
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0320    0xbf
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0441    0xc0
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0882    0xc1
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_1764    0xc2
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0480    0xc3
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0960    0xc4
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_1920    0xc5
> +#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_DEFAULT 0xc5
> +
> +#endif /* TEGRA_HDMI_H */
> diff --git a/drivers/gpu/drm/tegra/host1x.c b/drivers/gpu/drm/tegra/host1x.c
> index ed2af1a..9624326 100644
> --- a/drivers/gpu/drm/tegra/host1x.c
> +++ b/drivers/gpu/drm/tegra/host1x.c
> @@ -67,6 +67,7 @@ static int host1x_parse_dt(struct host1x *host1x)
>  {
>         static const char * const compat[] = {
>                 "nvidia,tegra20-dc",
> +               "nvidia,tegra20-hdmi",
>         };
>         unsigned int i;
>         int err;
> @@ -293,8 +294,14 @@ static int __init tegra_host1x_init(void)
>         if (err < 0)
>                 goto unregister_host1x;
> 
> +       err = platform_driver_register(&tegra_hdmi_driver);
> +       if (err < 0)
> +               goto unregister_dc;
> +
>         return 0;
> 
> +unregister_dc:
> +       platform_driver_unregister(&tegra_dc_driver);
>  unregister_host1x:
>         platform_driver_unregister(&tegra_host1x_driver);
>         return err;
> @@ -303,6 +310,7 @@ module_init(tegra_host1x_init);
> 
>  static void __exit tegra_host1x_exit(void)
>  {
> +       platform_driver_unregister(&tegra_hdmi_driver);
>         platform_driver_unregister(&tegra_dc_driver);
>         platform_driver_unregister(&tegra_host1x_driver);
>  }
> --
> 1.8.0
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-tegra" in
> the body of a message to [e-mail]
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>

Patch

diff --git a/drivers/gpu/drm/tegra/Makefile b/drivers/gpu/drm/tegra/Makefile
index 624a807..80f73d1 100644
--- a/drivers/gpu/drm/tegra/Makefile
+++ b/drivers/gpu/drm/tegra/Makefile
@@ -2,6 +2,6 @@  ccflags-y := -Iinclude/drm
 ccflags-$(CONFIG_DRM_TEGRA_DEBUG) += -DDEBUG
 
 tegra-drm-y := drm.o fb.o dc.o host1x.o
-tegra-drm-y += output.o rgb.o
+tegra-drm-y += output.o rgb.o hdmi.o
 
 obj-$(CONFIG_DRM_TEGRA) += tegra-drm.o
diff --git a/drivers/gpu/drm/tegra/drm.h b/drivers/gpu/drm/tegra/drm.h
index a1a891e..c2c4d16 100644
--- a/drivers/gpu/drm/tegra/drm.h
+++ b/drivers/gpu/drm/tegra/drm.h
@@ -131,6 +131,7 @@  struct tegra_output_ops {
 
 enum tegra_output_type {
 	TEGRA_OUTPUT_RGB,
+	TEGRA_OUTPUT_HDMI,
 };
 
 struct tegra_output {
@@ -225,6 +226,7 @@  extern int tegra_drm_fb_init(struct drm_device *drm);
 extern void tegra_drm_fb_exit(struct drm_device *drm);
 
 extern struct platform_driver tegra_host1x_driver;
+extern struct platform_driver tegra_hdmi_driver;
 extern struct platform_driver tegra_dc_driver;
 extern struct drm_driver tegra_drm_driver;
 
diff --git a/drivers/gpu/drm/tegra/hdmi.c b/drivers/gpu/drm/tegra/hdmi.c
new file mode 100644
index 0000000..61a1d14
--- /dev/null
+++ b/drivers/gpu/drm/tegra/hdmi.c
@@ -0,0 +1,1324 @@ 
+/*
+ * Copyright (C) 2012 Avionic Design GmbH
+ * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/clk.h>
+#include <linux/debugfs.h>
+#include <linux/gpio.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+
+#include <mach/clk.h>
+
+#include "hdmi.h"
+#include "drm.h"
+#include "dc.h"
+
+struct tegra_hdmi {
+	struct host1x_client client;
+	struct tegra_output output;
+	struct device *dev;
+
+	struct regulator *vdd;
+	struct regulator *pll;
+
+	void __iomem *regs;
+	unsigned int irq;
+
+	struct clk *clk_parent;
+	struct clk *clk;
+
+	unsigned int audio_source;
+	unsigned int audio_freq;
+	bool stereo;
+	bool dvi;
+
+	struct drm_info_list *debugfs_files;
+	struct drm_minor *minor;
+	struct dentry *debugfs;
+};
+
+static inline struct tegra_hdmi *
+host1x_client_to_hdmi(struct host1x_client *client)
+{
+	return container_of(client, struct tegra_hdmi, client);
+}
+
+static inline struct tegra_hdmi *to_hdmi(struct tegra_output *output)
+{
+	return container_of(output, struct tegra_hdmi, output);
+}
+
+#define HDMI_AUDIOCLK_FREQ 216000000
+#define HDMI_REKEY_DEFAULT 56
+
+enum {
+	AUTO = 0,
+	SPDIF,
+	HDA,
+};
+
+static inline unsigned long tegra_hdmi_readl(struct tegra_hdmi *hdmi,
+					     unsigned long reg)
+{
+	return readl(hdmi->regs + (reg << 2));
+}
+
+static inline void tegra_hdmi_writel(struct tegra_hdmi *hdmi, unsigned long val,
+				     unsigned long reg)
+{
+	writel(val, hdmi->regs + (reg << 2));
+}
+
+struct tegra_hdmi_audio_config {
+	unsigned int pclk;
+	unsigned int n;
+	unsigned int cts;
+	unsigned int aval;
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_32k[] = {
+	{  25200000, 4096,  25200, 24000 },
+	{  27000000, 4096,  27000, 24000 },
+	{  74250000, 4096,  74250, 24000 },
+	{ 148500000, 4096, 148500, 24000 },
+	{         0,    0,      0,     0 },
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_44_1k[] = {
+	{  25200000, 5880,  26250, 25000 },
+	{  27000000, 5880,  28125, 25000 },
+	{  74250000, 4704,  61875, 20000 },
+	{ 148500000, 4704, 123750, 20000 },
+	{         0,    0,      0,     0 },
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_48k[] = {
+	{  25200000, 6144,  25200, 24000 },
+	{  27000000, 6144,  27000, 24000 },
+	{  74250000, 6144,  74250, 24000 },
+	{ 148500000, 6144, 148500, 24000 },
+	{         0,    0,      0,     0 },
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_88_2k[] = {
+	{  25200000, 11760,  26250, 25000 },
+	{  27000000, 11760,  28125, 25000 },
+	{  74250000,  9408,  61875, 20000 },
+	{ 148500000,  9408, 123750, 20000 },
+	{         0,     0,      0,     0 },
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_96k[] = {
+	{  25200000, 12288,  25200, 24000 },
+	{  27000000, 12288,  27000, 24000 },
+	{  74250000, 12288,  74250, 24000 },
+	{ 148500000, 12288, 148500, 24000 },
+	{         0,     0,      0,     0 },
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_176_4k[] = {
+	{  25200000, 23520,  26250, 25000 },
+	{  27000000, 23520,  28125, 25000 },
+	{  74250000, 18816,  61875, 20000 },
+	{ 148500000, 18816, 123750, 20000 },
+	{         0,     0,      0,     0 },
+};
+
+static const struct tegra_hdmi_audio_config tegra_hdmi_audio_192k[] = {
+	{  25200000, 24576,  25200, 24000 },
+	{  27000000, 24576,  27000, 24000 },
+	{  74250000, 24576,  74250, 24000 },
+	{ 148500000, 24576, 148500, 24000 },
+	{         0,     0,      0,     0 },
+};
+
+struct tmds_config {
+	unsigned int pclk;
+	u32 pll0;
+	u32 pll1;
+	u32 pe_current;
+	u32 drive_current;
+};
+
+static const struct tmds_config tegra2_tmds_config[] = {
+	{ /* 480p modes */
+		.pclk = 27000000,
+		.pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
+			SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(0) |
+			SOR_PLL_TX_REG_LOAD(3),
+		.pll1 = SOR_PLL_TMDS_TERM_ENABLE,
+		.pe_current = PE_CURRENT0(PE_CURRENT_0_0_mA) |
+			PE_CURRENT1(PE_CURRENT_0_0_mA) |
+			PE_CURRENT2(PE_CURRENT_0_0_mA) |
+			PE_CURRENT3(PE_CURRENT_0_0_mA),
+		.drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE1(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE2(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE3(DRIVE_CURRENT_7_125_mA),
+	}, { /* 720p modes */
+		.pclk = 74250000,
+		.pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
+			SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(1) |
+			SOR_PLL_TX_REG_LOAD(3),
+		.pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
+		.pe_current = PE_CURRENT0(PE_CURRENT_6_0_mA) |
+			PE_CURRENT1(PE_CURRENT_6_0_mA) |
+			PE_CURRENT2(PE_CURRENT_6_0_mA) |
+			PE_CURRENT3(PE_CURRENT_6_0_mA),
+		.drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE1(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE2(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE3(DRIVE_CURRENT_7_125_mA),
+	}, { /* 1080p modes */
+		.pclk = UINT_MAX,
+		.pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
+			SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(1) |
+			SOR_PLL_TX_REG_LOAD(3),
+		.pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
+		.pe_current = PE_CURRENT0(PE_CURRENT_6_0_mA) |
+			PE_CURRENT1(PE_CURRENT_6_0_mA) |
+			PE_CURRENT2(PE_CURRENT_6_0_mA) |
+			PE_CURRENT3(PE_CURRENT_6_0_mA),
+		.drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE1(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE2(DRIVE_CURRENT_7_125_mA) |
+			DRIVE_CURRENT_LANE3(DRIVE_CURRENT_7_125_mA),
+	},
+};
+
+static const struct tmds_config tegra3_tmds_config[] = {
+	{ /* 480p modes */
+		.pclk = 27000000,
+		.pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
+			SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(0) |
+			SOR_PLL_TX_REG_LOAD(0),
+		.pll1 = SOR_PLL_TMDS_TERM_ENABLE,
+		.pe_current = PE_CURRENT0(PE_CURRENT_0_0_mA) |
+			PE_CURRENT1(PE_CURRENT_0_0_mA) |
+			PE_CURRENT2(PE_CURRENT_0_0_mA) |
+			PE_CURRENT3(PE_CURRENT_0_0_mA),
+		.drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE1(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE2(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE3(DRIVE_CURRENT_5_250_mA),
+	}, { /* 720p modes */
+		.pclk = 74250000,
+		.pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
+			SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(1) |
+			SOR_PLL_TX_REG_LOAD(0),
+		.pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
+		.pe_current = PE_CURRENT0(PE_CURRENT_5_0_mA) |
+			PE_CURRENT1(PE_CURRENT_5_0_mA) |
+			PE_CURRENT2(PE_CURRENT_5_0_mA) |
+			PE_CURRENT3(PE_CURRENT_5_0_mA),
+		.drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE1(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE2(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE3(DRIVE_CURRENT_5_250_mA),
+	}, { /* 1080p modes */
+		.pclk = UINT_MAX,
+		.pll0 = SOR_PLL_BG_V17_S(3) | SOR_PLL_ICHPMP(1) |
+			SOR_PLL_RESISTORSEL | SOR_PLL_VCOCAP(3) |
+			SOR_PLL_TX_REG_LOAD(0),
+		.pll1 = SOR_PLL_TMDS_TERM_ENABLE | SOR_PLL_PE_EN,
+		.pe_current = PE_CURRENT0(PE_CURRENT_5_0_mA) |
+			PE_CURRENT1(PE_CURRENT_5_0_mA) |
+			PE_CURRENT2(PE_CURRENT_5_0_mA) |
+			PE_CURRENT3(PE_CURRENT_5_0_mA),
+		.drive_current = DRIVE_CURRENT_LANE0(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE1(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE2(DRIVE_CURRENT_5_250_mA) |
+			DRIVE_CURRENT_LANE3(DRIVE_CURRENT_5_250_mA),
+	},
+};
+
+static const struct tegra_hdmi_audio_config *
+tegra_hdmi_get_audio_config(unsigned int audio_freq, unsigned int pclk)
+{
+	const struct tegra_hdmi_audio_config *table;
+
+	switch (audio_freq) {
+	case 32000:
+		table = tegra_hdmi_audio_32k;
+		break;
+
+	case 44100:
+		table = tegra_hdmi_audio_44_1k;
+		break;
+
+	case 48000:
+		table = tegra_hdmi_audio_48k;
+		break;
+
+	case 88200:
+		table = tegra_hdmi_audio_88_2k;
+		break;
+
+	case 96000:
+		table = tegra_hdmi_audio_96k;
+		break;
+
+	case 176400:
+		table = tegra_hdmi_audio_176_4k;
+		break;
+
+	case 192000:
+		table = tegra_hdmi_audio_192k;
+		break;
+
+	default:
+		return NULL;
+	}
+
+	while (table->pclk) {
+		if (table->pclk == pclk)
+			return table;
+
+		table++;
+	}
+
+	return NULL;
+}
+
+static void tegra_hdmi_setup_audio_fs_tables(struct tegra_hdmi *hdmi)
+{
+	const unsigned int freqs[] = {
+		32000, 44100, 48000, 88200, 96000, 176400, 192000
+	};
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(freqs); i++) {
+		unsigned int f = freqs[i];
+		unsigned int eight_half;
+		unsigned long value;
+		unsigned int delta;
+
+		if (f > 96000)
+			delta = 2;
+		else if (f > 480000)
+			delta = 6;
+		else
+			delta = 9;
+
+		eight_half = (8 * HDMI_AUDIOCLK_FREQ) / (f * 128);
+		value = AUDIO_FS_LOW(eight_half - delta) |
+			AUDIO_FS_HIGH(eight_half + delta);
+		tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_FS(i));
+	}
+}
+
+static int tegra_hdmi_setup_audio(struct tegra_hdmi *hdmi, unsigned int pclk)
+{
+	struct device_node *node = hdmi->dev->of_node;
+	const struct tegra_hdmi_audio_config *config;
+	unsigned int offset = 0;
+	unsigned long value;
+
+	switch (hdmi->audio_source) {
+	case HDA:
+		value = AUDIO_CNTRL0_SOURCE_SELECT_HDAL;
+		break;
+
+	case SPDIF:
+		value = AUDIO_CNTRL0_SOURCE_SELECT_SPDIF;
+		break;
+
+	default:
+		value = AUDIO_CNTRL0_SOURCE_SELECT_AUTO;
+		break;
+	}
+
+	if (of_device_is_compatible(node, "nvidia,tegra30-hdmi")) {
+		value |= AUDIO_CNTRL0_ERROR_TOLERANCE(6) |
+			 AUDIO_CNTRL0_FRAMES_PER_BLOCK(0xc0);
+		tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_CNTRL0);
+	} else {
+		value |= AUDIO_CNTRL0_INJECT_NULLSMPL;
+		tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_AUDIO_CNTRL0);
+
+		value = AUDIO_CNTRL0_ERROR_TOLERANCE(6) |
+			AUDIO_CNTRL0_FRAMES_PER_BLOCK(0xc0);
+		tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_CNTRL0);
+	}
+
+	config = tegra_hdmi_get_audio_config(hdmi->audio_freq, pclk);
+	if (!config) {
+		dev_err(hdmi->dev, "cannot set audio to %u at %u pclk\n",
+			hdmi->audio_freq, pclk);
+		return -EINVAL;
+	}
+
+	tegra_hdmi_writel(hdmi, 0, HDMI_NV_PDISP_HDMI_ACR_CTRL);
+
+	value = AUDIO_N_RESETF | AUDIO_N_GENERATE_ALTERNATE |
+		AUDIO_N_VALUE(config->n - 1);
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_N);
+
+	tegra_hdmi_writel(hdmi, ACR_SUBPACK_N(config->n) | ACR_ENABLE,
+			  HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_HIGH);
+
+	value = ACR_SUBPACK_CTS(config->cts);
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_LOW);
+
+	value = SPARE_HW_CTS | SPARE_FORCE_SW_CTS | SPARE_CTS_RESET_VAL(1);
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_SPARE);
+
+	value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_AUDIO_N);
+	value &= ~AUDIO_N_RESETF;
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_AUDIO_N);
+
+	if (of_device_is_compatible(node, "nvidia,tegra30-hdmi")) {
+		switch (hdmi->audio_freq) {
+		case 32000:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0320;
+			break;
+
+		case 44100:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0441;
+			break;
+
+		case 48000:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0480;
+			break;
+
+		case 88200:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0882;
+			break;
+
+		case 96000:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_0960;
+			break;
+
+		case 176400:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_1764;
+			break;
+
+		case 192000:
+			offset = HDMI_NV_PDISP_SOR_AUDIO_AVAL_1920;
+			break;
+		}
+
+		tegra_hdmi_writel(hdmi, config->aval, offset);
+	}
+
+	tegra_hdmi_setup_audio_fs_tables(hdmi);
+
+	return 0;
+}
+
+static void tegra_hdmi_write_infopack(struct tegra_hdmi *hdmi,
+				      unsigned int offset, u8 type,
+				      u8 version, void *data, size_t size)
+{
+	unsigned long value;
+	u8 *ptr = data;
+	u32 subpack[2];
+	size_t i;
+	u8 csum;
+
+	/* first byte of data is the checksum */
+	csum = type + version + size - 1;
+
+	for (i = 1; i < size; i++)
+		csum += ptr[i];
+
+	ptr[0] = 0x100 - csum;
+
+	value = INFOFRAME_HEADER_TYPE(type) |
+		INFOFRAME_HEADER_VERSION(version) |
+		INFOFRAME_HEADER_LEN(size - 1);
+	tegra_hdmi_writel(hdmi, value, offset);
+
+	/* The audio inforame only has one set of subpack registers.  The hdmi
+	 * block pads the rest of the data as per the spec so we have to fixup
+	 * the length before filling in the subpacks.
+	 */
+	if (offset == HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER)
+		size = 6;
+
+	/* each subpack 7 bytes devided into:
+	 *   subpack_low - bytes 0 - 3
+	 *   subpack_high - bytes 4 - 6 (with byte 7 padded to 0x00)
+	 */
+	for (i = 0; i < size; i++) {
+		size_t index = i % 7;
+
+		if (index == 0)
+			memset(subpack, 0x0, sizeof(subpack));
+
+		((u8 *)subpack)[index] = ptr[i];
+
+		if (index == 6 || (i + 1 == size)) {
+			unsigned int reg = offset + 1 + (i / 7) * 2;
+
+			tegra_hdmi_writel(hdmi, subpack[0], reg);
+			tegra_hdmi_writel(hdmi, subpack[1], reg + 1);
+		}
+	}
+}
+
+static void tegra_hdmi_setup_avi_infoframe(struct tegra_hdmi *hdmi,
+					   struct drm_display_mode *mode)
+{
+	struct hdmi_avi_infoframe frame;
+	unsigned int h_front_porch;
+	unsigned int hsize = 16;
+	unsigned int vsize = 9;
+
+	if (hdmi->dvi) {
+		tegra_hdmi_writel(hdmi, 0,
+				  HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL);
+		return;
+	}
+
+	h_front_porch = mode->htotal - mode->hsync_end;
+	memset(&frame, 0, sizeof(frame));
+	frame.r = HDMI_AVI_R_SAME;
+
+	switch (mode->vdisplay) {
+	case 480:
+		if (mode->hdisplay == 640) {
+			frame.m = HDMI_AVI_M_4_3;
+			frame.vic = 1;
+		} else {
+			frame.m = HDMI_AVI_M_16_9;
+			frame.vic = 3;
+		}
+		break;
+
+	case 576:
+		if (((hsize * 10) / vsize) > 14) {
+			frame.m = HDMI_AVI_M_16_9;
+			frame.vic = 18;
+		} else {
+			frame.m = HDMI_AVI_M_4_3;
+			frame.vic = 17;
+		}
+		break;
+
+	case 720:
+	case 1470: /* stereo mode */
+		frame.m = HDMI_AVI_M_16_9;
+
+		if (h_front_porch == 110)
+			frame.vic = 4;
+		else
+			frame.vic = 19;
+		break;
+
+	case 1080:
+	case 2205: /* stereo mode */
+		frame.m = HDMI_AVI_M_16_9;
+
+		switch (h_front_porch) {
+		case 88:
+			frame.vic = 16;
+			break;
+
+		case 528:
+			frame.vic = 31;
+			break;
+
+		default:
+			frame.vic = 32;
+			break;
+		}
+		break;
+
+	default:
+		frame.m = HDMI_AVI_M_16_9;
+		frame.vic = 0;
+		break;
+	}
+
+	tegra_hdmi_write_infopack(hdmi, HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_HEADER,
+				  HDMI_INFOFRAME_TYPE_AVI, HDMI_AVI_VERSION,
+				  &frame, sizeof(frame));
+
+	tegra_hdmi_writel(hdmi, INFOFRAME_CTRL_ENABLE,
+			  HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL);
+}
+
+static void tegra_hdmi_setup_audio_infoframe(struct tegra_hdmi *hdmi)
+{
+	struct hdmi_audio_infoframe frame;
+
+	if (hdmi->dvi) {
+		tegra_hdmi_writel(hdmi, 0,
+				  HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL);
+		return;
+	}
+
+	memset(&frame, 0, sizeof(frame));
+	frame.cc = HDMI_AUDIO_CC_2;
+
+	tegra_hdmi_write_infopack(hdmi,
+				  HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER,
+				  HDMI_INFOFRAME_TYPE_AUDIO,
+				  HDMI_AUDIO_VERSION,
+				  &frame, sizeof(frame));
+
+	tegra_hdmi_writel(hdmi, INFOFRAME_CTRL_ENABLE,
+			  HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL);
+}
+
+static void tegra_hdmi_setup_stereo_infoframe(struct tegra_hdmi *hdmi)
+{
+	struct hdmi_stereo_infoframe frame;
+	unsigned long value;
+
+	if (!hdmi->stereo) {
+		value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+		value &= ~GENERIC_CTRL_ENABLE;
+		tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+		return;
+	}
+
+	memset(&frame, 0, sizeof(frame));
+	frame.regid0 = 0x03;
+	frame.regid1 = 0x0c;
+	frame.regid2 = 0x00;
+	frame.hdmi_video_format = 2;
+
+	/* TODO: 74 MHz limit? */
+	if (1) {
+		frame._3d_structure = 0;
+	} else {
+		frame._3d_structure = 8;
+		frame._3d_ext_data = 0;
+	}
+
+	tegra_hdmi_write_infopack(hdmi, HDMI_NV_PDISP_HDMI_GENERIC_HEADER,
+				  HDMI_INFOFRAME_TYPE_VENDOR,
+				  HDMI_VENDOR_VERSION, &frame, 6);
+
+	value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+	value |= GENERIC_CTRL_ENABLE;
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+}
+
+static void tegra_hdmi_setup_tmds(struct tegra_hdmi *hdmi,
+				  const struct tmds_config *tmds)
+{
+	unsigned long value;
+
+	tegra_hdmi_writel(hdmi, tmds->pll0, HDMI_NV_PDISP_SOR_PLL0);
+	tegra_hdmi_writel(hdmi, tmds->pll1, HDMI_NV_PDISP_SOR_PLL1);
+	tegra_hdmi_writel(hdmi, tmds->pe_current, HDMI_NV_PDISP_PE_CURRENT);
+
+	value = tmds->drive_current | DRIVE_CURRENT_FUSE_OVERRIDE;
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_LANE_DRIVE_CURRENT);
+}
+
+static int tegra_output_hdmi_enable(struct tegra_output *output)
+{
+	unsigned int h_sync_width, h_front_porch, h_back_porch, i, rekey;
+	struct tegra_dc *dc = to_tegra_dc(output->encoder.crtc);
+	struct drm_display_mode *mode = &dc->base.mode;
+	struct tegra_hdmi *hdmi = to_hdmi(output);
+	struct device_node *node = hdmi->dev->of_node;
+	unsigned int pulse_start, div82, pclk;
+	const struct tmds_config *tmds;
+	unsigned int num_tmds;
+	unsigned long value;
+	int retries = 1000;
+	int err;
+
+	pclk = mode->clock * 1000;
+	h_sync_width = mode->hsync_end - mode->hsync_start;
+	h_front_porch = mode->htotal - mode->hsync_end;
+	h_back_porch = mode->hsync_start - mode->hdisplay;
+	dev_dbg(output->dev, "SW/FP/BP: %u %u %u\n",
+			h_sync_width, h_front_porch, h_back_porch);
+
+	err = regulator_enable(hdmi->vdd);
+	if (err < 0) {
+		dev_err(hdmi->dev, "failed to enable VDD regulator: %d\n", err);
+		return err;
+	}
+
+	err = regulator_enable(hdmi->pll);
+	if (err < 0) {
+		dev_err(hdmi->dev, "failed to enable PLL regulator: %d\n", err);
+		return err;
+	}
+
+	/*
+	 * This assumes that the display controller will divide its parent
+	 * clock by 2 to generate the pixel clock.
+	 */
+	err = tegra_output_setup_clock(output, hdmi->clk, pclk * 2);
+	if (err < 0) {
+		dev_err(hdmi->dev, "failed to setup clock: %d\n", err);
+		return err;
+	}
+
+	err = clk_set_rate(hdmi->clk, pclk);
+	if (err < 0)
+		return err;
+
+	err = clk_enable(hdmi->clk);
+	if (err < 0) {
+		dev_err(hdmi->dev, "failed to enable clock: %d\n", err);
+		return err;
+	}
+
+	tegra_periph_reset_assert(hdmi->clk);
+	usleep_range(1000, 2000);
+	tegra_periph_reset_deassert(hdmi->clk);
+
+	tegra_dc_writel(dc, VSYNC_H_POSITION(1),
+			DC_DISP_DISP_TIMING_OPTIONS);
+	tegra_dc_writel(dc, DITHER_CONTROL_DISABLE | BASE_COLOR_SIZE888,
+			DC_DISP_DISP_COLOR_CONTROL);
+
+	/* video_preamble uses h_pulse2 */
+	pulse_start = 1 + h_sync_width + h_back_porch - 10;
+
+	tegra_dc_writel(dc, H_PULSE_2_ENABLE, DC_DISP_DISP_SIGNAL_OPTIONS0);
+
+	value = PULSE_MODE_NORMAL | PULSE_POLARITY_HIGH | PULSE_QUAL_VACTIVE |
+		PULSE_LAST_END_A;
+	tegra_dc_writel(dc, value, DC_DISP_H_PULSE2_CONTROL);
+
+	value = PULSE_START(pulse_start) | PULSE_END(pulse_start + 8);
+	tegra_dc_writel(dc, value, DC_DISP_H_PULSE2_POSITION_A);
+
+	value = VSYNC_WINDOW_END(0x210) | VSYNC_WINDOW_START(0x200) |
+		VSYNC_WINDOW_ENABLE;
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_VSYNC_WINDOW);
+
+	if (dc->pipe)
+		value = HDMI_SRC_DISPLAYB;
+	else
+		value = HDMI_SRC_DISPLAYA;
+
+	if ((mode->hdisplay == 720) && ((mode->vdisplay == 480) ||
+					(mode->vdisplay == 576)))
+		tegra_hdmi_writel(hdmi,
+				  value | ARM_VIDEO_RANGE_FULL,
+				  HDMI_NV_PDISP_INPUT_CONTROL);
+	else
+		tegra_hdmi_writel(hdmi,
+				  value | ARM_VIDEO_RANGE_LIMITED,
+				  HDMI_NV_PDISP_INPUT_CONTROL);
+
+	div82 = clk_get_rate(hdmi->clk) / 1000000 * 4;
+	value = SOR_REFCLK_DIV_INT(div82 >> 2) | SOR_REFCLK_DIV_FRAC(div82);
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_REFCLK);
+
+	if (!hdmi->dvi) {
+		err = tegra_hdmi_setup_audio(hdmi, pclk);
+		if (err < 0)
+			hdmi->dvi = true;
+	}
+
+	if (of_device_is_compatible(node, "nvidia,tegra20-hdmi")) {
+		/*
+		 * TODO: add ELD support
+		 */
+	}
+
+	rekey = HDMI_REKEY_DEFAULT;
+	value = HDMI_CTRL_REKEY(rekey);
+	value |= HDMI_CTRL_MAX_AC_PACKET((h_sync_width + h_back_porch +
+					  h_front_porch - rekey - 18) / 32);
+
+	if (!hdmi->dvi)
+		value |= HDMI_CTRL_ENABLE;
+
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_HDMI_CTRL);
+
+	if (hdmi->dvi)
+		tegra_hdmi_writel(hdmi, 0x0,
+				  HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+	else
+		tegra_hdmi_writel(hdmi, GENERIC_CTRL_AUDIO,
+				  HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+
+	tegra_hdmi_setup_avi_infoframe(hdmi, mode);
+	tegra_hdmi_setup_audio_infoframe(hdmi);
+	tegra_hdmi_setup_stereo_infoframe(hdmi);
+
+	/* TMDS CONFIG */
+	if (of_device_is_compatible(node, "nvidia,tegra30-hdmi")) {
+		num_tmds = ARRAY_SIZE(tegra3_tmds_config);
+		tmds = tegra3_tmds_config;
+	} else {
+		num_tmds = ARRAY_SIZE(tegra2_tmds_config);
+		tmds = tegra2_tmds_config;
+	}
+
+	for (i = 0; i < num_tmds; i++) {
+		if (pclk <= tmds[i].pclk) {
+			tegra_hdmi_setup_tmds(hdmi, &tmds[i]);
+			break;
+		}
+	}
+
+	tegra_hdmi_writel(hdmi,
+			  SOR_SEQ_CTL_PU_PC(0) |
+			  SOR_SEQ_PU_PC_ALT(0) |
+			  SOR_SEQ_PD_PC(8) |
+			  SOR_SEQ_PD_PC_ALT(8),
+			  HDMI_NV_PDISP_SOR_SEQ_CTL);
+
+	value = SOR_SEQ_INST_WAIT_TIME(1) |
+		SOR_SEQ_INST_WAIT_UNITS_VSYNC |
+		SOR_SEQ_INST_HALT |
+		SOR_SEQ_INST_PIN_A_LOW |
+		SOR_SEQ_INST_PIN_B_LOW |
+		SOR_SEQ_INST_DRIVE_PWM_OUT_LO;
+
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_SEQ_INST(0));
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_SEQ_INST(8));
+
+	value = 0x1c800;
+	value &= ~SOR_CSTM_ROTCLK(~0);
+	value |= SOR_CSTM_ROTCLK(2);
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_CSTM);
+
+	tegra_dc_writel(dc, DISP_CTRL_MODE_STOP, DC_CMD_DISPLAY_COMMAND);
+	tegra_dc_writel(dc, GENERAL_ACT_REQ << 8, DC_CMD_STATE_CONTROL);
+	tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
+
+	/* start SOR */
+	tegra_hdmi_writel(hdmi,
+			  SOR_PWR_NORMAL_STATE_PU |
+			  SOR_PWR_NORMAL_START_NORMAL |
+			  SOR_PWR_SAFE_STATE_PD |
+			  SOR_PWR_SETTING_NEW_TRIGGER,
+			  HDMI_NV_PDISP_SOR_PWR);
+	tegra_hdmi_writel(hdmi,
+			  SOR_PWR_NORMAL_STATE_PU |
+			  SOR_PWR_NORMAL_START_NORMAL |
+			  SOR_PWR_SAFE_STATE_PD |
+			  SOR_PWR_SETTING_NEW_DONE,
+			  HDMI_NV_PDISP_SOR_PWR);
+
+	do {
+		BUG_ON(--retries < 0);
+		value = tegra_hdmi_readl(hdmi, HDMI_NV_PDISP_SOR_PWR);
+	} while (value & SOR_PWR_SETTING_NEW_PENDING);
+
+	value = SOR_STATE_ASY_CRCMODE_COMPLETE |
+		SOR_STATE_ASY_OWNER_HEAD0 |
+		SOR_STATE_ASY_SUBOWNER_BOTH |
+		SOR_STATE_ASY_PROTOCOL_SINGLE_TMDS_A |
+		SOR_STATE_ASY_DEPOL_POS;
+
+	/* setup sync polarities */
+	if (mode->flags & DRM_MODE_FLAG_PHSYNC)
+		value |= SOR_STATE_ASY_HSYNCPOL_POS;
+
+	if (mode->flags & DRM_MODE_FLAG_NHSYNC)
+		value |= SOR_STATE_ASY_HSYNCPOL_NEG;
+
+	if (mode->flags & DRM_MODE_FLAG_PVSYNC)
+		value |= SOR_STATE_ASY_VSYNCPOL_POS;
+
+	if (mode->flags & DRM_MODE_FLAG_NVSYNC)
+		value |= SOR_STATE_ASY_VSYNCPOL_NEG;
+
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_STATE2);
+
+	value = SOR_STATE_ASY_HEAD_OPMODE_AWAKE | SOR_STATE_ASY_ORMODE_NORMAL;
+	tegra_hdmi_writel(hdmi, value, HDMI_NV_PDISP_SOR_STATE1);
+
+	tegra_hdmi_writel(hdmi, 0, HDMI_NV_PDISP_SOR_STATE0);
+	tegra_hdmi_writel(hdmi, SOR_STATE_UPDATE, HDMI_NV_PDISP_SOR_STATE0);
+	tegra_hdmi_writel(hdmi, value | SOR_STATE_ATTACHED,
+			  HDMI_NV_PDISP_SOR_STATE1);
+	tegra_hdmi_writel(hdmi, 0, HDMI_NV_PDISP_SOR_STATE0);
+
+	tegra_dc_writel(dc, HDMI_ENABLE, DC_DISP_DISP_WIN_OPTIONS);
+
+	value = PW0_ENABLE | PW1_ENABLE | PW2_ENABLE | PW3_ENABLE |
+		PW4_ENABLE | PM0_ENABLE | PM1_ENABLE;
+	tegra_dc_writel(dc, value, DC_CMD_DISPLAY_POWER_CONTROL);
+
+	value = DISP_CTRL_MODE_C_DISPLAY;
+	tegra_dc_writel(dc, value, DC_CMD_DISPLAY_COMMAND);
+
+	tegra_dc_writel(dc, GENERAL_ACT_REQ << 8, DC_CMD_STATE_CONTROL);
+	tegra_dc_writel(dc, GENERAL_ACT_REQ, DC_CMD_STATE_CONTROL);
+
+	/* TODO: add HDCP support */
+
+	return 0;
+}
+
+static int tegra_output_hdmi_disable(struct tegra_output *output)
+{
+	struct tegra_hdmi *hdmi = to_hdmi(output);
+
+	tegra_periph_reset_assert(hdmi->clk);
+	clk_disable(hdmi->clk);
+	regulator_disable(hdmi->pll);
+	regulator_disable(hdmi->vdd);
+
+	return 0;
+}
+
+static int tegra_output_hdmi_setup_clock(struct tegra_output *output,
+					 struct clk *clk, unsigned long pclk)
+{
+	struct tegra_hdmi *hdmi = to_hdmi(output);
+	struct clk *base;
+	int err;
+
+	err = clk_set_parent(clk, hdmi->clk_parent);
+	if (err < 0) {
+		dev_err(output->dev, "failed to set parent: %d\n", err);
+		return err;
+	}
+
+	base = clk_get_parent(hdmi->clk_parent);
+
+	/*
+	 * This assumes that the parent clock is pll_d_out0 or pll_d2_out
+	 * respectively, each of which divides the base pll_d by 2.
+	 */
+	err = clk_set_rate(base, pclk * 2);
+	if (err < 0)
+		dev_err(output->dev,
+			"failed to set base clock rate to %lu Hz\n",
+			pclk * 2);
+
+	return 0;
+}
+
+static int tegra_output_hdmi_check_mode(struct tegra_output *output,
+					struct drm_display_mode *mode,
+					enum drm_mode_status *status)
+{
+	struct tegra_hdmi *hdmi = to_hdmi(output);
+	unsigned long pclk = mode->clock * 1000;
+	struct clk *parent;
+	long err;
+
+	parent = clk_get_parent(hdmi->clk_parent);
+
+	err = clk_round_rate(parent, pclk * 4);
+	if (err < 0)
+		*status = MODE_NOCLOCK;
+	else
+		*status = MODE_OK;
+
+	return 0;
+}
+
+static const struct tegra_output_ops hdmi_ops = {
+	.enable = tegra_output_hdmi_enable,
+	.disable = tegra_output_hdmi_disable,
+	.setup_clock = tegra_output_hdmi_setup_clock,
+	.check_mode = tegra_output_hdmi_check_mode,
+};
+
+static int tegra_hdmi_show_regs(struct seq_file *s, void *data)
+{
+	struct drm_info_node *node = s->private;
+	struct tegra_hdmi *hdmi = node->info_ent->data;
+
+#define DUMP_REG(name)						\
+	seq_printf(s, "%-56s %#05x %08lx\n", #name, name,	\
+		tegra_hdmi_readl(hdmi, name))
+
+	DUMP_REG(HDMI_CTXSW);
+	DUMP_REG(HDMI_NV_PDISP_SOR_STATE0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_STATE1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_STATE2);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AN_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AN_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CN_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CN_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AKSV_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_AKSV_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_BKSV_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_BKSV_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CKSV_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CKSV_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_DKSV_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_DKSV_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CMODE);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_MPRIME_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_MPRIME_LSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_SPRIME_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB2);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB1);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_RI);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CS_MSB);
+	DUMP_REG(HDMI_NV_PDISP_RG_HDCP_CS_LSB);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU0);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU_RDATA0);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU1);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_EMU2);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_STATUS);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_STATUS);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_HEADER);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_STATUS);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_HEADER);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_LOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_HIGH);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_VSYNC_KEEPOUT);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_VSYNC_WINDOW);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GCP_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GCP_STATUS);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_GCP_SUBPACK);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_CHANNEL_STATUS1);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_CHANNEL_STATUS2);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_EMU0);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_EMU1);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_EMU1_RDATA);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_SPARE);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS1);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS2);
+	DUMP_REG(HDMI_NV_PDISP_HDMI_HDCPRIF_ROM_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_SOR_CAP);
+	DUMP_REG(HDMI_NV_PDISP_SOR_PWR);
+	DUMP_REG(HDMI_NV_PDISP_SOR_TEST);
+	DUMP_REG(HDMI_NV_PDISP_SOR_PLL0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_PLL1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_PLL2);
+	DUMP_REG(HDMI_NV_PDISP_SOR_CSTM);
+	DUMP_REG(HDMI_NV_PDISP_SOR_LVDS);
+	DUMP_REG(HDMI_NV_PDISP_SOR_CRCA);
+	DUMP_REG(HDMI_NV_PDISP_SOR_CRCB);
+	DUMP_REG(HDMI_NV_PDISP_SOR_BLANK);
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_CTL);
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(0));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(1));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(2));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(3));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(4));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(5));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(6));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(7));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(8));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(9));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(10));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(11));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(12));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(13));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(14));
+	DUMP_REG(HDMI_NV_PDISP_SOR_SEQ_INST(15));
+	DUMP_REG(HDMI_NV_PDISP_SOR_VCRCA0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_VCRCA1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_CCRCA0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_CCRCA1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_EDATAA0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_EDATAA1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_COUNTA0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_COUNTA1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_DEBUGA0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_DEBUGA1);
+	DUMP_REG(HDMI_NV_PDISP_SOR_TRIG);
+	DUMP_REG(HDMI_NV_PDISP_SOR_MSCHECK);
+	DUMP_REG(HDMI_NV_PDISP_SOR_LANE_DRIVE_CURRENT);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_DEBUG0);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_DEBUG1);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_DEBUG2);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(0));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(1));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(2));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(3));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(4));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(5));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_FS(6));
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_PULSE_WIDTH);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_THRESHOLD);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_CNTRL0);
+	DUMP_REG(HDMI_NV_PDISP_AUDIO_N);
+	DUMP_REG(HDMI_NV_PDISP_HDCPRIF_ROM_TIMING);
+	DUMP_REG(HDMI_NV_PDISP_SOR_REFCLK);
+	DUMP_REG(HDMI_NV_PDISP_CRC_CONTROL);
+	DUMP_REG(HDMI_NV_PDISP_INPUT_CONTROL);
+	DUMP_REG(HDMI_NV_PDISP_SCRATCH);
+	DUMP_REG(HDMI_NV_PDISP_PE_CURRENT);
+	DUMP_REG(HDMI_NV_PDISP_KEY_CTRL);
+	DUMP_REG(HDMI_NV_PDISP_KEY_DEBUG0);
+	DUMP_REG(HDMI_NV_PDISP_KEY_DEBUG1);
+	DUMP_REG(HDMI_NV_PDISP_KEY_DEBUG2);
+	DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_0);
+	DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_1);
+	DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_2);
+	DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_3);
+	DUMP_REG(HDMI_NV_PDISP_KEY_HDCP_KEY_TRIG);
+	DUMP_REG(HDMI_NV_PDISP_KEY_SKEY_INDEX);
+	DUMP_REG(HDMI_NV_PDISP_SOR_AUDIO_CNTRL0);
+	DUMP_REG(HDMI_NV_PDISP_SOR_AUDIO_HDA_ELD_BUFWR);
+	DUMP_REG(HDMI_NV_PDISP_SOR_AUDIO_HDA_PRESENSE);
+
+#undef DUMP_REG
+
+	return 0;
+}
+
+static struct drm_info_list debugfs_files[] = {
+	{ "regs", tegra_hdmi_show_regs, 0, NULL },
+};
+
+static int tegra_hdmi_debugfs_init(struct tegra_hdmi *hdmi,
+				   struct drm_minor *minor)
+{
+	unsigned int i;
+	int err;
+
+	hdmi->debugfs = debugfs_create_dir("hdmi", minor->debugfs_root);
+	if (!hdmi->debugfs)
+		return -ENOMEM;
+
+	hdmi->debugfs_files = kmemdup(debugfs_files, sizeof(debugfs_files),
+				      GFP_KERNEL);
+	if (!hdmi->debugfs_files) {
+		err = -ENOMEM;
+		goto remove;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
+		hdmi->debugfs_files[i].data = hdmi;
+
+	err = drm_debugfs_create_files(hdmi->debugfs_files,
+				       ARRAY_SIZE(debugfs_files),
+				       hdmi->debugfs, minor);
+	if (err < 0)
+		goto free;
+
+	hdmi->minor = minor;
+
+	return 0;
+
+free:
+	kfree(hdmi->debugfs_files);
+	hdmi->debugfs_files = NULL;
+remove:
+	debugfs_remove(hdmi->debugfs);
+	hdmi->debugfs = NULL;
+
+	return err;
+}
+
+static int tegra_hdmi_debugfs_exit(struct tegra_hdmi *hdmi)
+{
+	drm_debugfs_remove_files(hdmi->debugfs_files, ARRAY_SIZE(debugfs_files),
+				 hdmi->minor);
+	hdmi->minor = NULL;
+
+	kfree(hdmi->debugfs_files);
+	hdmi->debugfs_files = NULL;
+
+	debugfs_remove(hdmi->debugfs);
+	hdmi->debugfs = NULL;
+
+	return 0;
+}
+
+static int tegra_hdmi_drm_init(struct host1x_client *client,
+			       struct drm_device *drm)
+{
+	struct tegra_hdmi *hdmi = host1x_client_to_hdmi(client);
+	int err;
+
+	hdmi->output.type = TEGRA_OUTPUT_HDMI;
+	hdmi->output.dev = client->dev;
+	hdmi->output.ops = &hdmi_ops;
+
+	err = tegra_output_init(drm, &hdmi->output);
+	if (err < 0) {
+		dev_err(client->dev, "output setup failed: %d\n", err);
+		return err;
+	}
+
+	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
+		err = tegra_hdmi_debugfs_init(hdmi, drm->primary);
+		if (err < 0)
+			dev_err(client->dev, "debugfs setup failed: %d\n", err);
+	}
+
+	return 0;
+}
+
+static int tegra_hdmi_drm_exit(struct host1x_client *client)
+{
+	struct tegra_hdmi *hdmi = host1x_client_to_hdmi(client);
+	int err;
+
+	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
+		err = tegra_hdmi_debugfs_exit(hdmi);
+		if (err < 0)
+			dev_err(client->dev, "debugfs cleanup failed: %d\n",
+				err);
+	}
+
+	err = tegra_output_exit(&hdmi->output);
+	if (err < 0) {
+		dev_err(client->dev, "output cleanup failed: %d\n", err);
+		return err;
+	}
+
+	return 0;
+}
+
+static const struct host1x_client_ops hdmi_client_ops = {
+	.drm_init = tegra_hdmi_drm_init,
+	.drm_exit = tegra_hdmi_drm_exit,
+};
+
+static int tegra_hdmi_probe(struct platform_device *pdev)
+{
+	struct host1x *host1x = dev_get_drvdata(pdev->dev.parent);
+	struct tegra_hdmi *hdmi;
+	struct resource *regs;
+	int err;
+
+	hdmi = devm_kzalloc(&pdev->dev, sizeof(*hdmi), GFP_KERNEL);
+	if (!hdmi)
+		return -ENOMEM;
+
+	hdmi->dev = &pdev->dev;
+	hdmi->audio_source = AUTO;
+	hdmi->audio_freq = 44100;
+	hdmi->stereo = false;
+	hdmi->dvi = false;
+
+	hdmi->clk = devm_clk_get(&pdev->dev, NULL);
+	if (IS_ERR_OR_NULL(hdmi->clk))
+		return PTR_ERR(hdmi->clk);
+
+	err = clk_prepare(hdmi->clk);
+	if (err < 0)
+		return err;
+
+	hdmi->clk_parent = devm_clk_get(&pdev->dev, "parent");
+	if (IS_ERR_OR_NULL(hdmi->clk_parent))
+		return PTR_ERR(hdmi->clk_parent);
+
+	err = clk_prepare(hdmi->clk_parent);
+	if (err < 0)
+		return err;
+
+	err = clk_set_parent(hdmi->clk, hdmi->clk_parent);
+	if (err < 0) {
+		dev_err(&pdev->dev, "failed to setup clocks: %d\n", err);
+		return err;
+	}
+
+	hdmi->vdd = devm_regulator_get(&pdev->dev, "vdd");
+	if (IS_ERR_OR_NULL(hdmi->vdd)) {
+		err = PTR_ERR(hdmi->vdd);
+		dev_err(&pdev->dev, "failed to get VDD regulator: %d\n", err);
+		return err;
+	}
+
+	hdmi->pll = devm_regulator_get(&pdev->dev, "pll");
+	if (IS_ERR_OR_NULL(hdmi->pll)) {
+		err = PTR_ERR(hdmi->pll);
+		dev_err(&pdev->dev, "failed to get PLL regulator: %d\n", err);
+		return err;
+	}
+
+	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!regs)
+		return -ENXIO;
+
+	hdmi->regs = devm_request_and_ioremap(&pdev->dev, regs);
+	if (!hdmi->regs)
+		return -EADDRNOTAVAIL;
+
+	err = platform_get_irq(pdev, 0);
+	if (err < 0)
+		return err;
+
+	hdmi->irq = err;
+
+	hdmi->client.ops = &hdmi_client_ops;
+	INIT_LIST_HEAD(&hdmi->client.list);
+	hdmi->client.dev = &pdev->dev;
+
+	err = host1x_register_client(host1x, &hdmi->client);
+	if (err < 0) {
+		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+			err);
+		return err;
+	}
+
+	platform_set_drvdata(pdev, hdmi);
+
+	return 0;
+}
+
+static int tegra_hdmi_remove(struct platform_device *pdev)
+{
+	struct host1x *host1x = dev_get_drvdata(pdev->dev.parent);
+	struct tegra_hdmi *hdmi = platform_get_drvdata(pdev);
+	int err;
+
+	err = host1x_unregister_client(host1x, &hdmi->client);
+	if (err < 0) {
+		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+			err);
+		return err;
+	}
+
+	clk_unprepare(hdmi->clk_parent);
+	clk_unprepare(hdmi->clk);
+
+	return 0;
+}
+
+static struct of_device_id tegra_hdmi_of_match[] = {
+	{ .compatible = "nvidia,tegra20-hdmi", },
+	{ .compatible = "nvidia,tegra30-hdmi", },
+	{ },
+};
+
+struct platform_driver tegra_hdmi_driver = {
+	.driver = {
+		.name = "tegra-hdmi",
+		.owner = THIS_MODULE,
+		.of_match_table = tegra_hdmi_of_match,
+	},
+	.probe = tegra_hdmi_probe,
+	.remove = tegra_hdmi_remove,
+};
diff --git a/drivers/gpu/drm/tegra/hdmi.h b/drivers/gpu/drm/tegra/hdmi.h
new file mode 100644
index 0000000..1477f36
--- /dev/null
+++ b/drivers/gpu/drm/tegra/hdmi.h
@@ -0,0 +1,575 @@ 
+/*
+ * Copyright (C) 2012 Avionic Design GmbH
+ * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef TEGRA_HDMI_H
+#define TEGRA_HDMI_H 1
+
+#define HDMI_INFOFRAME_TYPE_VENDOR   0x81
+#define HDMI_INFOFRAME_TYPE_AVI      0x82
+#define HDMI_INFOFRAME_TYPE_SPD      0x83
+#define HDMI_INFOFRAME_TYPE_AUDIO    0x84
+#define HDMI_INFOFRAME_TYPE_MPEG_SRC 0x85
+#define HDMI_INFOFRAME_TYPE_NTSC_VBI 0x86
+
+/* all fields little endian */
+struct hdmi_avi_infoframe {
+	/* PB0 */
+	u8 csum;
+
+	/* PB1 */
+	unsigned s:2; /* scan information */
+	unsigned b:2; /* bar info data valid */
+	unsigned a:1; /* active info present */
+	unsigned y:2; /* RGB or YCbCr */
+	unsigned res1:1;
+
+	/* PB2 */
+	unsigned r:4; /* active format aspect ratio */
+	unsigned m:2; /* picture aspect ratio */
+	unsigned c:2; /* colorimetry */
+
+	/* PB3 */
+	unsigned sc:2;  /* scan information */
+	unsigned q:2;   /* quantization range */
+	unsigned ec:3;  /* extended colorimetry */
+	unsigned itc:1; /* it content */
+
+	/* PB4 */
+	unsigned vic:7; /* video format id code */
+	unsigned res4:1;
+
+	/* PB5 */
+	unsigned pr:4; /* pixel repetition factor */
+	unsigned cn:2; /* it content type*/
+	unsigned yq:2; /* ycc quantization range */
+
+	/* PB6-7 */
+	u16 top_bar_end_line;
+
+	/* PB8-9 */
+	u16 bot_bar_start_line;
+
+	/* PB10-11 */
+	u16 left_bar_end_pixel;
+
+	/* PB12-13 */
+	u16 right_bar_start_pixel;
+} __packed;
+
+#define HDMI_AVI_VERSION 0x02
+
+#define HDMI_AVI_Y_RGB       0x0
+#define HDMI_AVI_Y_YCBCR_422 0x1
+#define HDMI_AVI_Y_YCBCR_444 0x2
+
+#define HDMI_AVI_B_VERT  0x1
+#define HDMI_AVI_B_HORIZ 0x2
+
+#define HDMI_AVI_S_NONE      0x0
+#define HDMI_AVI_S_OVERSCAN  0x1
+#define HDMI_AVI_S_UNDERSCAN 0x2
+
+#define HDMI_AVI_C_NONE     0x0
+#define HDMI_AVI_C_SMPTE    0x1
+#define HDMI_AVI_C_ITU_R    0x2
+#define HDMI_AVI_C_EXTENDED 0x4
+
+#define HDMI_AVI_M_4_3  0x1
+#define HDMI_AVI_M_16_9 0x2
+
+#define HDMI_AVI_R_SAME        0x8
+#define HDMI_AVI_R_4_3_CENTER  0x9
+#define HDMI_AVI_R_16_9_CENTER 0xa
+#define HDMI_AVI_R_14_9_CENTER 0xb
+
+/* all fields little endian */
+struct hdmi_audio_infoframe {
+	/* PB0 */
+	u8 csum;
+
+	/* PB1 */
+	unsigned cc:3; /* channel count */
+	unsigned res1:1;
+	unsigned ct:4; /* coding type */
+
+	/* PB2 */
+	unsigned ss:2; /* sample size */
+	unsigned sf:3; /* sample frequency */
+	unsigned res2:3;
+
+	/* PB3 */
+	unsigned cxt:5; /* coding extention type */
+	unsigned res3:3;
+
+	/* PB4 */
+	u8 ca; /* channel/speaker allocation */
+
+	/* PB5 */
+	unsigned res5:3;
+	unsigned lsv:4; /* level shift value */
+	unsigned dm_inh:1; /* downmix inhibit */
+
+	/* PB6-10 reserved */
+	u8 res6;
+	u8 res7;
+	u8 res8;
+	u8 res9;
+	u8 res10;
+} __packed;
+
+#define HDMI_AUDIO_VERSION 0x01
+
+#define HDMI_AUDIO_CC_STREAM 0x0 /* specified by audio stream */
+#define HDMI_AUDIO_CC_2      0x1
+#define HDMI_AUDIO_CC_3      0x2
+#define HDMI_AUDIO_CC_4      0x3
+#define HDMI_AUDIO_CC_5      0x4
+#define HDMI_AUDIO_CC_6      0x5
+#define HDMI_AUDIO_CC_7      0x6
+#define HDMI_AUDIO_CC_8      0x7
+
+#define HDMI_AUDIO_CT_STREAM  0x0 /* specified by audio stream */
+#define HDMI_AUDIO_CT_PCM     0x1
+#define HDMI_AUDIO_CT_AC3     0x2
+#define HDMI_AUDIO_CT_MPEG1   0x3
+#define HDMI_AUDIO_CT_MP3     0x4
+#define HDMI_AUDIO_CT_MPEG2   0x5
+#define HDMI_AUDIO_CT_AAC_LC  0x6
+#define HDMI_AUDIO_CT_DTS     0x7
+#define HDMI_AUDIO_CT_ATRAC   0x8
+#define HDMI_AUDIO_CT_DSD     0x9
+#define HDMI_AUDIO_CT_E_AC3   0xa
+#define HDMI_AUDIO_CT_DTS_HD  0xb
+#define HDMI_AUDIO_CT_MLP     0xc
+#define HDMI_AUDIO_CT_DST     0xd
+#define HDMI_AUDIO_CT_WMA_PRO 0xe
+#define HDMI_AUDIO_CT_CXT     0xf
+
+#define HDMI_AUDIO_SF_STREAM 0x0 /* specified by audio stream */
+#define HDMI_AUIDO_SF_32K    0x1
+#define HDMI_AUDIO_SF_44_1K  0x2
+#define HDMI_AUDIO_SF_48K    0x3
+#define HDMI_AUDIO_SF_88_2K  0x4
+#define HDMI_AUDIO_SF_96K    0x5
+#define HDMI_AUDIO_SF_176_4K 0x6
+#define HDMI_AUDIO_SF_192K   0x7
+
+#define HDMI_AUDIO_SS_STREAM 0x0 /* specified by audio stream */
+#define HDMI_AUDIO_SS_16BIT  0x1
+#define HDMI_AUDIO_SS_20BIT  0x2
+#define HDMI_AUDIO_SS_24BIT  0x3
+
+#define HDMI_AUDIO_CXT_CT            0x0 /* refer to coding in CT */
+#define HDMI_AUDIO_CXT_HE_AAC        0x1
+#define HDMI_AUDIO_CXT_HE_AAC_V2     0x2
+#define HDMI_AUDIO_CXT_MPEG_SURROUND 0x3
+
+/* all fields little endian */
+struct hdmi_stereo_infoframe {
+	/* PB0 */
+	u8 csum;
+
+	/* PB1 */
+	u8 regid0;
+
+	/* PB2 */
+	u8 regid1;
+
+	/* PB3 */
+	u8 regid2;
+
+	/* PB4 */
+	unsigned res1:5;
+	unsigned hdmi_video_format:3;
+
+	/* PB5 */
+	unsigned res2:4;
+	unsigned _3d_structure:4;
+
+	/* PB6*/
+	unsigned res3:4;
+	unsigned _3d_ext_data:4;
+} __packed;
+
+#define HDMI_VENDOR_VERSION 0x01
+
+/* register definitions */
+#define HDMI_CTXSW						0x00
+
+#define HDMI_NV_PDISP_SOR_STATE0				0x01
+#define SOR_STATE_UPDATE (1 << 0)
+
+#define HDMI_NV_PDISP_SOR_STATE1				0x02
+#define SOR_STATE_ASY_HEAD_OPMODE_AWAKE (2 << 0)
+#define SOR_STATE_ASY_ORMODE_NORMAL     (1 << 2)
+#define SOR_STATE_ATTACHED              (1 << 3)
+
+#define HDMI_NV_PDISP_SOR_STATE2				0x03
+#define SOR_STATE_ASY_OWNER_NONE         (0 <<  0)
+#define SOR_STATE_ASY_OWNER_HEAD0        (1 <<  0)
+#define SOR_STATE_ASY_SUBOWNER_NONE      (0 <<  4)
+#define SOR_STATE_ASY_SUBOWNER_SUBHEAD0  (1 <<  4)
+#define SOR_STATE_ASY_SUBOWNER_SUBHEAD1  (2 <<  4)
+#define SOR_STATE_ASY_SUBOWNER_BOTH      (3 <<  4)
+#define SOR_STATE_ASY_CRCMODE_ACTIVE     (0 <<  6)
+#define SOR_STATE_ASY_CRCMODE_COMPLETE   (1 <<  6)
+#define SOR_STATE_ASY_CRCMODE_NON_ACTIVE (2 <<  6)
+#define SOR_STATE_ASY_PROTOCOL_SINGLE_TMDS_A (1 << 8)
+#define SOR_STATE_ASY_PROTOCOL_CUSTOM        (15 << 8)
+#define SOR_STATE_ASY_HSYNCPOL_POS       (0 << 12)
+#define SOR_STATE_ASY_HSYNCPOL_NEG       (1 << 12)
+#define SOR_STATE_ASY_VSYNCPOL_POS       (0 << 13)
+#define SOR_STATE_ASY_VSYNCPOL_NEG       (1 << 13)
+#define SOR_STATE_ASY_DEPOL_POS          (0 << 14)
+#define SOR_STATE_ASY_DEPOL_NEG          (1 << 14)
+
+#define HDMI_NV_PDISP_RG_HDCP_AN_MSB				0x04
+#define HDMI_NV_PDISP_RG_HDCP_AN_LSB				0x05
+#define HDMI_NV_PDISP_RG_HDCP_CN_MSB				0x06
+#define HDMI_NV_PDISP_RG_HDCP_CN_LSB				0x07
+#define HDMI_NV_PDISP_RG_HDCP_AKSV_MSB				0x08
+#define HDMI_NV_PDISP_RG_HDCP_AKSV_LSB				0x09
+#define HDMI_NV_PDISP_RG_HDCP_BKSV_MSB				0x0a
+#define HDMI_NV_PDISP_RG_HDCP_BKSV_LSB				0x0b
+#define HDMI_NV_PDISP_RG_HDCP_CKSV_MSB				0x0c
+#define HDMI_NV_PDISP_RG_HDCP_CKSV_LSB				0x0d
+#define HDMI_NV_PDISP_RG_HDCP_DKSV_MSB				0x0e
+#define HDMI_NV_PDISP_RG_HDCP_DKSV_LSB				0x0f
+#define HDMI_NV_PDISP_RG_HDCP_CTRL				0x10
+#define HDMI_NV_PDISP_RG_HDCP_CMODE				0x11
+#define HDMI_NV_PDISP_RG_HDCP_MPRIME_MSB			0x12
+#define HDMI_NV_PDISP_RG_HDCP_MPRIME_LSB			0x13
+#define HDMI_NV_PDISP_RG_HDCP_SPRIME_MSB			0x14
+#define HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB2			0x15
+#define HDMI_NV_PDISP_RG_HDCP_SPRIME_LSB1			0x16
+#define HDMI_NV_PDISP_RG_HDCP_RI				0x17
+#define HDMI_NV_PDISP_RG_HDCP_CS_MSB				0x18
+#define HDMI_NV_PDISP_RG_HDCP_CS_LSB				0x19
+#define HDMI_NV_PDISP_HDMI_AUDIO_EMU0				0x1a
+#define HDMI_NV_PDISP_HDMI_AUDIO_EMU_RDATA0			0x1b
+#define HDMI_NV_PDISP_HDMI_AUDIO_EMU1				0x1c
+#define HDMI_NV_PDISP_HDMI_AUDIO_EMU2				0x1d
+
+#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_CTRL			0x1e
+#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_STATUS		0x1f
+#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_HEADER		0x20
+#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_LOW		0x21
+#define HDMI_NV_PDISP_HDMI_AUDIO_INFOFRAME_SUBPACK0_HIGH	0x22
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_CTRL			0x23
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_STATUS			0x24
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_HEADER			0x25
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_LOW		0x26
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK0_HIGH		0x27
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_LOW		0x28
+#define HDMI_NV_PDISP_HDMI_AVI_INFOFRAME_SUBPACK1_HIGH		0x29
+
+#define INFOFRAME_CTRL_ENABLE (1 << 0)
+
+#define INFOFRAME_HEADER_TYPE(x)    (((x) & 0xff) <<  0)
+#define INFOFRAME_HEADER_VERSION(x) (((x) & 0xff) <<  8)
+#define INFOFRAME_HEADER_LEN(x)     (((x) & 0x0f) << 16)
+
+#define HDMI_NV_PDISP_HDMI_GENERIC_CTRL				0x2a
+#define GENERIC_CTRL_ENABLE (1 <<  0)
+#define GENERIC_CTRL_OTHER  (1 <<  4)
+#define GENERIC_CTRL_SINGLE (1 <<  8)
+#define GENERIC_CTRL_HBLANK (1 << 12)
+#define GENERIC_CTRL_AUDIO  (1 << 16)
+
+#define HDMI_NV_PDISP_HDMI_GENERIC_STATUS			0x2b
+#define HDMI_NV_PDISP_HDMI_GENERIC_HEADER			0x2c
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_LOW			0x2d
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK0_HIGH		0x2e
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_LOW			0x2f
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK1_HIGH		0x30
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_LOW			0x31
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK2_HIGH		0x32
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_LOW			0x33
+#define HDMI_NV_PDISP_HDMI_GENERIC_SUBPACK3_HIGH		0x34
+
+#define HDMI_NV_PDISP_HDMI_ACR_CTRL				0x35
+#define HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_LOW			0x36
+#define HDMI_NV_PDISP_HDMI_ACR_0320_SUBPACK_HIGH		0x37
+#define HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_LOW			0x38
+#define HDMI_NV_PDISP_HDMI_ACR_0441_SUBPACK_HIGH		0x39
+#define HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_LOW			0x3a
+#define HDMI_NV_PDISP_HDMI_ACR_0882_SUBPACK_HIGH		0x3b
+#define HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_LOW			0x3c
+#define HDMI_NV_PDISP_HDMI_ACR_1764_SUBPACK_HIGH		0x3d
+#define HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_LOW			0x3e
+#define HDMI_NV_PDISP_HDMI_ACR_0480_SUBPACK_HIGH		0x3f
+#define HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_LOW			0x40
+#define HDMI_NV_PDISP_HDMI_ACR_0960_SUBPACK_HIGH		0x41
+#define HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_LOW			0x42
+#define HDMI_NV_PDISP_HDMI_ACR_1920_SUBPACK_HIGH		0x43
+
+#define ACR_SUBPACK_CTS(x) (((x) & 0xffffff) << 8)
+#define ACR_SUBPACK_N(x)   (((x) & 0xffffff) << 0)
+#define ACR_ENABLE         (1 << 31)
+
+#define HDMI_NV_PDISP_HDMI_CTRL					0x44
+#define HDMI_CTRL_REKEY(x)         (((x) & 0x7f) <<  0)
+#define HDMI_CTRL_MAX_AC_PACKET(x) (((x) & 0x1f) << 16)
+#define HDMI_CTRL_ENABLE           (1 << 30)
+
+#define HDMI_NV_PDISP_HDMI_VSYNC_KEEPOUT			0x45
+#define HDMI_NV_PDISP_HDMI_VSYNC_WINDOW				0x46
+#define VSYNC_WINDOW_END(x)   (((x) & 0x3ff) <<  0)
+#define VSYNC_WINDOW_START(x) (((x) & 0x3ff) << 16)
+#define VSYNC_WINDOW_ENABLE   (1 << 31)
+
+#define HDMI_NV_PDISP_HDMI_GCP_CTRL				0x47
+#define HDMI_NV_PDISP_HDMI_GCP_STATUS				0x48
+#define HDMI_NV_PDISP_HDMI_GCP_SUBPACK				0x49
+#define HDMI_NV_PDISP_HDMI_CHANNEL_STATUS1			0x4a
+#define HDMI_NV_PDISP_HDMI_CHANNEL_STATUS2			0x4b
+#define HDMI_NV_PDISP_HDMI_EMU0					0x4c
+#define HDMI_NV_PDISP_HDMI_EMU1					0x4d
+#define HDMI_NV_PDISP_HDMI_EMU1_RDATA				0x4e
+
+#define HDMI_NV_PDISP_HDMI_SPARE				0x4f
+#define SPARE_HW_CTS           (1 << 0)
+#define SPARE_FORCE_SW_CTS     (1 << 1)
+#define SPARE_CTS_RESET_VAL(x) (((x) & 0x7) << 16)
+
+#define HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS1			0x50
+#define HDMI_NV_PDISP_HDMI_SPDIF_CHN_STATUS2			0x51
+#define HDMI_NV_PDISP_HDMI_HDCPRIF_ROM_CTRL			0x53
+#define HDMI_NV_PDISP_SOR_CAP					0x54
+#define HDMI_NV_PDISP_SOR_PWR					0x55
+#define SOR_PWR_NORMAL_STATE_PD     (0 <<  0)
+#define SOR_PWR_NORMAL_STATE_PU     (1 <<  0)
+#define SOR_PWR_NORMAL_START_NORMAL (0 <<  1)
+#define SOR_PWR_NORMAL_START_ALT    (1 <<  1)
+#define SOR_PWR_SAFE_STATE_PD       (0 << 16)
+#define SOR_PWR_SAFE_STATE_PU       (1 << 16)
+#define SOR_PWR_SETTING_NEW_DONE    (0 << 31)
+#define SOR_PWR_SETTING_NEW_PENDING (1 << 31)
+#define SOR_PWR_SETTING_NEW_TRIGGER (1 << 31)
+
+#define HDMI_NV_PDISP_SOR_TEST					0x56
+#define HDMI_NV_PDISP_SOR_PLL0					0x57
+#define SOR_PLL_PWR            (1 << 0)
+#define SOR_PLL_PDBG           (1 << 1)
+#define SOR_PLL_VCAPD          (1 << 2)
+#define SOR_PLL_PDPORT         (1 << 3)
+#define SOR_PLL_RESISTORSEL    (1 << 4)
+#define SOR_PLL_PULLDOWN       (1 << 5)
+#define SOR_PLL_VCOCAP(x)      (((x) & 0xf) <<  8)
+#define SOR_PLL_BG_V17_S(x)    (((x) & 0xf) << 12)
+#define SOR_PLL_FILTER(x)      (((x) & 0xf) << 16)
+#define SOR_PLL_ICHPMP(x)      (((x) & 0xf) << 24)
+#define SOR_PLL_TX_REG_LOAD(x) (((x) & 0xf) << 28)
+
+#define HDMI_NV_PDISP_SOR_PLL1					0x58
+#define SOR_PLL_TMDS_TERM_ENABLE (1 << 8)
+#define SOR_PLL_TMDS_TERMADJ(x)  (((x) & 0xf) <<  9)
+#define SOR_PLL_LOADADJ(x)       (((x) & 0xf) << 20)
+#define SOR_PLL_PE_EN            (1 << 28)
+#define SOR_PLL_HALF_FULL_PE     (1 << 29)
+#define SOR_PLL_S_D_PIN_PE       (1 << 30)
+
+#define HDMI_NV_PDISP_SOR_PLL2					0x59
+
+#define HDMI_NV_PDISP_SOR_CSTM					0x5a
+#define SOR_CSTM_ROTCLK(x) (((x) & 0xf) << 24)
+
+#define HDMI_NV_PDISP_SOR_LVDS					0x5b
+#define HDMI_NV_PDISP_SOR_CRCA					0x5c
+#define HDMI_NV_PDISP_SOR_CRCB					0x5d
+#define HDMI_NV_PDISP_SOR_BLANK					0x5e
+#define HDMI_NV_PDISP_SOR_SEQ_CTL				0x5f
+#define SOR_SEQ_CTL_PU_PC(x) (((x) & 0xf) <<  0)
+#define SOR_SEQ_PU_PC_ALT(x) (((x) & 0xf) <<  4)
+#define SOR_SEQ_PD_PC(x)     (((x) & 0xf) <<  8)
+#define SOR_SEQ_PD_PC_ALT(x) (((x) & 0xf) << 12)
+#define SOR_SEQ_PC(x)        (((x) & 0xf) << 16)
+#define SOR_SEQ_STATUS       (1 << 28)
+#define SOR_SEQ_SWITCH       (1 << 30)
+
+#define HDMI_NV_PDISP_SOR_SEQ_INST(x)				(0x60 + (x))
+
+#define SOR_SEQ_INST_WAIT_TIME(x)     (((x) & 0x3ff) << 0)
+#define SOR_SEQ_INST_WAIT_UNITS_VSYNC (2 << 12)
+#define SOR_SEQ_INST_HALT             (1 << 15)
+#define SOR_SEQ_INST_PIN_A_LOW        (0 << 21)
+#define SOR_SEQ_INST_PIN_A_HIGH       (1 << 21)
+#define SOR_SEQ_INST_PIN_B_LOW        (0 << 22)
+#define SOR_SEQ_INST_PIN_B_HIGH       (1 << 22)
+#define SOR_SEQ_INST_DRIVE_PWM_OUT_LO (1 << 23)
+
+#define HDMI_NV_PDISP_SOR_VCRCA0				0x72
+#define HDMI_NV_PDISP_SOR_VCRCA1				0x73
+#define HDMI_NV_PDISP_SOR_CCRCA0				0x74
+#define HDMI_NV_PDISP_SOR_CCRCA1				0x75
+#define HDMI_NV_PDISP_SOR_EDATAA0				0x76
+#define HDMI_NV_PDISP_SOR_EDATAA1				0x77
+#define HDMI_NV_PDISP_SOR_COUNTA0				0x78
+#define HDMI_NV_PDISP_SOR_COUNTA1				0x79
+#define HDMI_NV_PDISP_SOR_DEBUGA0				0x7a
+#define HDMI_NV_PDISP_SOR_DEBUGA1				0x7b
+#define HDMI_NV_PDISP_SOR_TRIG					0x7c
+#define HDMI_NV_PDISP_SOR_MSCHECK				0x7d
+
+#define HDMI_NV_PDISP_SOR_LANE_DRIVE_CURRENT			0x7e
+#define DRIVE_CURRENT_LANE0(x)      (((x) & 0x3f) <<  0)
+#define DRIVE_CURRENT_LANE1(x)      (((x) & 0x3f) <<  8)
+#define DRIVE_CURRENT_LANE2(x)      (((x) & 0x3f) << 16)
+#define DRIVE_CURRENT_LANE3(x)      (((x) & 0x3f) << 24)
+#define DRIVE_CURRENT_FUSE_OVERRIDE (1 << 31)
+
+#define DRIVE_CURRENT_1_500_mA  0x00
+#define DRIVE_CURRENT_1_875_mA  0x01
+#define DRIVE_CURRENT_2_250_mA  0x02
+#define DRIVE_CURRENT_2_625_mA  0x03
+#define DRIVE_CURRENT_3_000_mA  0x04
+#define DRIVE_CURRENT_3_375_mA  0x05
+#define DRIVE_CURRENT_3_750_mA  0x06
+#define DRIVE_CURRENT_4_125_mA  0x07
+#define DRIVE_CURRENT_4_500_mA  0x08
+#define DRIVE_CURRENT_4_875_mA  0x09
+#define DRIVE_CURRENT_5_250_mA  0x0a
+#define DRIVE_CURRENT_5_625_mA  0x0b
+#define DRIVE_CURRENT_6_000_mA  0x0c
+#define DRIVE_CURRENT_6_375_mA  0x0d
+#define DRIVE_CURRENT_6_750_mA  0x0e
+#define DRIVE_CURRENT_7_125_mA  0x0f
+#define DRIVE_CURRENT_7_500_mA  0x10
+#define DRIVE_CURRENT_7_875_mA  0x11
+#define DRIVE_CURRENT_8_250_mA  0x12
+#define DRIVE_CURRENT_8_625_mA  0x13
+#define DRIVE_CURRENT_9_000_mA  0x14
+#define DRIVE_CURRENT_9_375_mA  0x15
+#define DRIVE_CURRENT_9_750_mA  0x16
+#define DRIVE_CURRENT_10_125_mA 0x17
+#define DRIVE_CURRENT_10_500_mA 0x18
+#define DRIVE_CURRENT_10_875_mA 0x19
+#define DRIVE_CURRENT_11_250_mA 0x1a
+#define DRIVE_CURRENT_11_625_mA 0x1b
+#define DRIVE_CURRENT_12_000_mA 0x1c
+#define DRIVE_CURRENT_12_375_mA 0x1d
+#define DRIVE_CURRENT_12_750_mA 0x1e
+#define DRIVE_CURRENT_13_125_mA 0x1f
+#define DRIVE_CURRENT_13_500_mA 0x20
+#define DRIVE_CURRENT_13_875_mA 0x21
+#define DRIVE_CURRENT_14_250_mA 0x22
+#define DRIVE_CURRENT_14_625_mA 0x23
+#define DRIVE_CURRENT_15_000_mA 0x24
+#define DRIVE_CURRENT_15_375_mA 0x25
+#define DRIVE_CURRENT_15_750_mA 0x26
+#define DRIVE_CURRENT_16_125_mA 0x27
+#define DRIVE_CURRENT_16_500_mA 0x28
+#define DRIVE_CURRENT_16_875_mA 0x29
+#define DRIVE_CURRENT_17_250_mA 0x2a
+#define DRIVE_CURRENT_17_625_mA 0x2b
+#define DRIVE_CURRENT_18_000_mA 0x2c
+#define DRIVE_CURRENT_18_375_mA 0x2d
+#define DRIVE_CURRENT_18_750_mA 0x2e
+#define DRIVE_CURRENT_19_125_mA 0x2f
+#define DRIVE_CURRENT_19_500_mA 0x30
+#define DRIVE_CURRENT_19_875_mA 0x31
+#define DRIVE_CURRENT_20_250_mA 0x32
+#define DRIVE_CURRENT_20_625_mA 0x33
+#define DRIVE_CURRENT_21_000_mA 0x34
+#define DRIVE_CURRENT_21_375_mA 0x35
+#define DRIVE_CURRENT_21_750_mA 0x36
+#define DRIVE_CURRENT_22_125_mA 0x37
+#define DRIVE_CURRENT_22_500_mA 0x38
+#define DRIVE_CURRENT_22_875_mA 0x39
+#define DRIVE_CURRENT_23_250_mA 0x3a
+#define DRIVE_CURRENT_23_625_mA 0x3b
+#define DRIVE_CURRENT_24_000_mA 0x3c
+#define DRIVE_CURRENT_24_375_mA 0x3d
+#define DRIVE_CURRENT_24_750_mA 0x3e
+
+#define HDMI_NV_PDISP_AUDIO_DEBUG0				0x7f
+#define HDMI_NV_PDISP_AUDIO_DEBUG1				0x80
+#define HDMI_NV_PDISP_AUDIO_DEBUG2				0x81
+
+#define HDMI_NV_PDISP_AUDIO_FS(x)				(0x82 + (x))
+#define AUDIO_FS_LOW(x)  (((x) & 0xfff) <<  0)
+#define AUDIO_FS_HIGH(x) (((x) & 0xfff) << 16)
+
+#define HDMI_NV_PDISP_AUDIO_PULSE_WIDTH				0x89
+#define HDMI_NV_PDISP_AUDIO_THRESHOLD				0x8a
+#define HDMI_NV_PDISP_AUDIO_CNTRL0				0x8b
+#define AUDIO_CNTRL0_ERROR_TOLERANCE(x)  (((x) & 0xff) << 0)
+#define AUDIO_CNTRL0_SOURCE_SELECT_AUTO  (0 << 20)
+#define AUDIO_CNTRL0_SOURCE_SELECT_SPDIF (1 << 20)
+#define AUDIO_CNTRL0_SOURCE_SELECT_HDAL  (2 << 20)
+#define AUDIO_CNTRL0_FRAMES_PER_BLOCK(x) (((x) & 0xff) << 24)
+
+#define HDMI_NV_PDISP_AUDIO_N					0x8c
+#define AUDIO_N_VALUE(x)           (((x) & 0xfffff) << 0)
+#define AUDIO_N_RESETF             (1 << 20)
+#define AUDIO_N_GENERATE_NORMAL    (0 << 24)
+#define AUDIO_N_GENERATE_ALTERNATE (1 << 24)
+
+#define HDMI_NV_PDISP_HDCPRIF_ROM_TIMING			0x94
+#define HDMI_NV_PDISP_SOR_REFCLK				0x95
+#define SOR_REFCLK_DIV_INT(x)  (((x) & 0xff) << 8)
+#define SOR_REFCLK_DIV_FRAC(x) (((x) & 0x03) << 6)
+
+#define HDMI_NV_PDISP_CRC_CONTROL				0x96
+#define HDMI_NV_PDISP_INPUT_CONTROL				0x97
+#define HDMI_SRC_DISPLAYA       (0 << 0)
+#define HDMI_SRC_DISPLAYB       (1 << 0)
+#define ARM_VIDEO_RANGE_FULL    (0 << 1)
+#define ARM_VIDEO_RANGE_LIMITED (1 << 1)
+
+#define HDMI_NV_PDISP_SCRATCH					0x98
+#define HDMI_NV_PDISP_PE_CURRENT				0x99
+#define PE_CURRENT0(x) (((x) & 0xf) << 0)
+#define PE_CURRENT1(x) (((x) & 0xf) << 8)
+#define PE_CURRENT2(x) (((x) & 0xf) << 16)
+#define PE_CURRENT3(x) (((x) & 0xf) << 24)
+
+#define PE_CURRENT_0_0_mA 0x0
+#define PE_CURRENT_0_5_mA 0x1
+#define PE_CURRENT_1_0_mA 0x2
+#define PE_CURRENT_1_5_mA 0x3
+#define PE_CURRENT_2_0_mA 0x4
+#define PE_CURRENT_2_5_mA 0x5
+#define PE_CURRENT_3_0_mA 0x6
+#define PE_CURRENT_3_5_mA 0x7
+#define PE_CURRENT_4_0_mA 0x8
+#define PE_CURRENT_4_5_mA 0x9
+#define PE_CURRENT_5_0_mA 0xa
+#define PE_CURRENT_5_5_mA 0xb
+#define PE_CURRENT_6_0_mA 0xc
+#define PE_CURRENT_6_5_mA 0xd
+#define PE_CURRENT_7_0_mA 0xe
+#define PE_CURRENT_7_5_mA 0xf
+
+#define HDMI_NV_PDISP_KEY_CTRL					0x9a
+#define HDMI_NV_PDISP_KEY_DEBUG0				0x9b
+#define HDMI_NV_PDISP_KEY_DEBUG1				0x9c
+#define HDMI_NV_PDISP_KEY_DEBUG2				0x9d
+#define HDMI_NV_PDISP_KEY_HDCP_KEY_0				0x9e
+#define HDMI_NV_PDISP_KEY_HDCP_KEY_1				0x9f
+#define HDMI_NV_PDISP_KEY_HDCP_KEY_2				0xa0
+#define HDMI_NV_PDISP_KEY_HDCP_KEY_3				0xa1
+#define HDMI_NV_PDISP_KEY_HDCP_KEY_TRIG				0xa2
+#define HDMI_NV_PDISP_KEY_SKEY_INDEX				0xa3
+
+#define HDMI_NV_PDISP_SOR_AUDIO_CNTRL0				0xac
+#define AUDIO_CNTRL0_INJECT_NULLSMPL (1 << 29)
+#define HDMI_NV_PDISP_SOR_AUDIO_HDA_ELD_BUFWR			0xbc
+#define HDMI_NV_PDISP_SOR_AUDIO_HDA_PRESENSE			0xbd
+
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0320    0xbf
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0441    0xc0
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0882    0xc1
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_1764    0xc2
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0480    0xc3
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_0960    0xc4
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_1920    0xc5
+#define HDMI_NV_PDISP_SOR_AUDIO_AVAL_DEFAULT 0xc5
+
+#endif /* TEGRA_HDMI_H */
diff --git a/drivers/gpu/drm/tegra/host1x.c b/drivers/gpu/drm/tegra/host1x.c
index ed2af1a..9624326 100644
--- a/drivers/gpu/drm/tegra/host1x.c
+++ b/drivers/gpu/drm/tegra/host1x.c
@@ -67,6 +67,7 @@  static int host1x_parse_dt(struct host1x *host1x)
 {
 	static const char * const compat[] = {
 		"nvidia,tegra20-dc",
+		"nvidia,tegra20-hdmi",
 	};
 	unsigned int i;
 	int err;
@@ -293,8 +294,14 @@  static int __init tegra_host1x_init(void)
 	if (err < 0)
 		goto unregister_host1x;
 
+	err = platform_driver_register(&tegra_hdmi_driver);
+	if (err < 0)
+		goto unregister_dc;
+
 	return 0;
 
+unregister_dc:
+	platform_driver_unregister(&tegra_dc_driver);
 unregister_host1x:
 	platform_driver_unregister(&tegra_host1x_driver);
 	return err;
@@ -303,6 +310,7 @@  module_init(tegra_host1x_init);
 
 static void __exit tegra_host1x_exit(void)
 {
+	platform_driver_unregister(&tegra_hdmi_driver);
 	platform_driver_unregister(&tegra_dc_driver);
 	platform_driver_unregister(&tegra_host1x_driver);
 }