aboutsummaryrefslogtreecommitdiffstats
path: root/target/linux/bcm27xx/patches-5.4/950-0573-drm-vc4-hdmi-Rename-hdmi-to-vc4_hdmi.patch
diff options
context:
space:
mode:
Diffstat (limited to 'target/linux/bcm27xx/patches-5.4/950-0573-drm-vc4-hdmi-Rename-hdmi-to-vc4_hdmi.patch')
-rw-r--r--target/linux/bcm27xx/patches-5.4/950-0573-drm-vc4-hdmi-Rename-hdmi-to-vc4_hdmi.patch682
1 files changed, 682 insertions, 0 deletions
diff --git a/target/linux/bcm27xx/patches-5.4/950-0573-drm-vc4-hdmi-Rename-hdmi-to-vc4_hdmi.patch b/target/linux/bcm27xx/patches-5.4/950-0573-drm-vc4-hdmi-Rename-hdmi-to-vc4_hdmi.patch
new file mode 100644
index 0000000000..75c44a564a
--- /dev/null
+++ b/target/linux/bcm27xx/patches-5.4/950-0573-drm-vc4-hdmi-Rename-hdmi-to-vc4_hdmi.patch
@@ -0,0 +1,682 @@
+From 02b7a6ed6b9fc110dd26598d26c31c0837af6184 Mon Sep 17 00:00:00 2001
+From: Maxime Ripard <maxime@cerno.tech>
+Date: Mon, 6 Jan 2020 18:07:05 +0100
+Subject: [PATCH] drm/vc4: hdmi: Rename hdmi to vc4_hdmi
+
+The driver isn't consistent with the name given to the vc4_hdmi
+structure pointer in its functions. Make sure to use a consistent name.
+
+Signed-off-by: Maxime Ripard <maxime@cerno.tech>
+---
+ drivers/gpu/drm/vc4/vc4_hdmi.c | 271 +++++++++++++++++----------------
+ 1 file changed, 136 insertions(+), 135 deletions(-)
+
+--- a/drivers/gpu/drm/vc4/vc4_hdmi.c
++++ b/drivers/gpu/drm/vc4/vc4_hdmi.c
+@@ -108,11 +108,11 @@ static const struct debugfs_reg32 hd_reg
+ static int vc4_hdmi_debugfs_regs(struct seq_file *m, void *unused)
+ {
+ struct drm_info_node *node = (struct drm_info_node *)m->private;
+- struct vc4_hdmi *hdmi = node->info_ent->data;
++ struct vc4_hdmi *vc4_hdmi = node->info_ent->data;
+ struct drm_printer p = drm_seq_file_printer(m);
+
+- drm_print_regset32(&p, &hdmi->hdmi_regset);
+- drm_print_regset32(&p, &hdmi->hd_regset);
++ drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
++ drm_print_regset32(&p, &vc4_hdmi->hd_regset);
+
+ return 0;
+ }
+@@ -297,8 +297,8 @@ static void vc4_hdmi_set_avi_infoframe(s
+ {
+ struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
+ struct vc4_dev *vc4 = encoder->dev->dev_private;
+- struct vc4_hdmi *hdmi = vc4->hdmi;
+- struct drm_connector *connector = &hdmi->connector.base;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
++ struct drm_connector *connector = &vc4_hdmi->connector.base;
+ struct drm_connector_state *cstate = connector->state;
+ struct drm_crtc *crtc = encoder->crtc;
+ const struct drm_display_mode *mode = &crtc->state->adjusted_mode;
+@@ -346,7 +346,7 @@ static void vc4_hdmi_set_audio_infoframe
+ {
+ struct drm_device *drm = encoder->dev;
+ struct vc4_dev *vc4 = drm->dev_private;
+- struct vc4_hdmi *hdmi = vc4->hdmi;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
+ union hdmi_infoframe frame;
+ int ret;
+
+@@ -355,7 +355,7 @@ static void vc4_hdmi_set_audio_infoframe
+ frame.audio.coding_type = HDMI_AUDIO_CODING_TYPE_STREAM;
+ frame.audio.sample_frequency = HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM;
+ frame.audio.sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM;
+- frame.audio.channels = hdmi->audio.channels;
++ frame.audio.channels = vc4_hdmi->audio.channels;
+
+ vc4_hdmi_write_infoframe(encoder, &frame);
+ }
+@@ -370,7 +370,7 @@ static void vc4_hdmi_encoder_disable(str
+ {
+ struct drm_device *dev = encoder->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(dev);
+- struct vc4_hdmi *hdmi = vc4->hdmi;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
+ int ret;
+
+ HDMI_WRITE(VC4_HDMI_RAM_PACKET_CONFIG, 0);
+@@ -379,9 +379,9 @@ static void vc4_hdmi_encoder_disable(str
+ HD_WRITE(VC4_HD_VID_CTL,
+ HD_READ(VC4_HD_VID_CTL) & ~VC4_HD_VID_CTL_ENABLE);
+
+- clk_disable_unprepare(hdmi->pixel_clock);
++ clk_disable_unprepare(vc4_hdmi->pixel_clock);
+
+- ret = pm_runtime_put(&hdmi->pdev->dev);
++ ret = pm_runtime_put(&vc4_hdmi->pdev->dev);
+ if (ret < 0)
+ DRM_ERROR("Failed to release power domain: %d\n", ret);
+ }
+@@ -392,7 +392,7 @@ static void vc4_hdmi_encoder_enable(stru
+ struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
+ struct drm_device *dev = encoder->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(dev);
+- struct vc4_hdmi *hdmi = vc4->hdmi;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
+ bool debug_dump_regs = false;
+ bool hsync_pos = mode->flags & DRM_MODE_FLAG_PHSYNC;
+ bool vsync_pos = mode->flags & DRM_MODE_FLAG_PVSYNC;
+@@ -414,13 +414,13 @@ static void vc4_hdmi_encoder_enable(stru
+ u32 csc_ctl;
+ int ret;
+
+- ret = pm_runtime_get_sync(&hdmi->pdev->dev);
++ ret = pm_runtime_get_sync(&vc4_hdmi->pdev->dev);
+ if (ret < 0) {
+ DRM_ERROR("Failed to retain power domain: %d\n", ret);
+ return;
+ }
+
+- ret = clk_set_rate(hdmi->pixel_clock,
++ ret = clk_set_rate(vc4_hdmi->pixel_clock,
+ mode->clock * 1000 *
+ ((mode->flags & DRM_MODE_FLAG_DBLCLK) ? 2 : 1));
+ if (ret) {
+@@ -428,7 +428,7 @@ static void vc4_hdmi_encoder_enable(stru
+ return;
+ }
+
+- ret = clk_prepare_enable(hdmi->pixel_clock);
++ ret = clk_prepare_enable(vc4_hdmi->pixel_clock);
+ if (ret) {
+ DRM_ERROR("Failed to turn on pixel clock: %d\n", ret);
+ return;
+@@ -448,11 +448,11 @@ static void vc4_hdmi_encoder_enable(stru
+ HDMI_WRITE(VC4_HDMI_TX_PHY_RESET_CTL, 0);
+
+ if (debug_dump_regs) {
+- struct drm_printer p = drm_info_printer(&hdmi->pdev->dev);
++ struct drm_printer p = drm_info_printer(&vc4_hdmi->pdev->dev);
+
+- dev_info(&hdmi->pdev->dev, "HDMI regs before:\n");
+- drm_print_regset32(&p, &hdmi->hdmi_regset);
+- drm_print_regset32(&p, &hdmi->hd_regset);
++ dev_info(&vc4_hdmi->pdev->dev, "HDMI regs before:\n");
++ drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
++ drm_print_regset32(&p, &vc4_hdmi->hd_regset);
+ }
+
+ HD_WRITE(VC4_HD_VID_CTL, 0);
+@@ -527,11 +527,11 @@ static void vc4_hdmi_encoder_enable(stru
+ HDMI_WRITE(VC4_HDMI_FIFO_CTL, VC4_HDMI_FIFO_CTL_MASTER_SLAVE_N);
+
+ if (debug_dump_regs) {
+- struct drm_printer p = drm_info_printer(&hdmi->pdev->dev);
++ struct drm_printer p = drm_info_printer(&vc4_hdmi->pdev->dev);
+
+- dev_info(&hdmi->pdev->dev, "HDMI regs after:\n");
+- drm_print_regset32(&p, &hdmi->hdmi_regset);
+- drm_print_regset32(&p, &hdmi->hd_regset);
++ dev_info(&vc4_hdmi->pdev->dev, "HDMI regs after:\n");
++ drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
++ drm_print_regset32(&p, &vc4_hdmi->hd_regset);
+ }
+
+ HD_WRITE(VC4_HD_VID_CTL,
+@@ -630,15 +630,15 @@ static const struct drm_encoder_helper_f
+ };
+
+ /* HDMI audio codec callbacks */
+-static void vc4_hdmi_audio_set_mai_clock(struct vc4_hdmi *hdmi)
++static void vc4_hdmi_audio_set_mai_clock(struct vc4_hdmi *vc4_hdmi)
+ {
+- struct drm_encoder *encoder = &hdmi->encoder.base.base;
++ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
+ struct drm_device *drm = encoder->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(drm);
+- u32 hsm_clock = clk_get_rate(hdmi->hsm_clock);
++ u32 hsm_clock = clk_get_rate(vc4_hdmi->hsm_clock);
+ unsigned long n, m;
+
+- rational_best_approximation(hsm_clock, hdmi->audio.samplerate,
++ rational_best_approximation(hsm_clock, vc4_hdmi->audio.samplerate,
+ VC4_HD_MAI_SMP_N_MASK >>
+ VC4_HD_MAI_SMP_N_SHIFT,
+ (VC4_HD_MAI_SMP_M_MASK >>
+@@ -650,14 +650,14 @@ static void vc4_hdmi_audio_set_mai_clock
+ VC4_SET_FIELD(m - 1, VC4_HD_MAI_SMP_M));
+ }
+
+-static void vc4_hdmi_set_n_cts(struct vc4_hdmi *hdmi)
++static void vc4_hdmi_set_n_cts(struct vc4_hdmi *vc4_hdmi)
+ {
+- struct drm_encoder *encoder = &hdmi->encoder.base.base;
++ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
+ struct drm_crtc *crtc = encoder->crtc;
+ struct drm_device *drm = encoder->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(drm);
+ const struct drm_display_mode *mode = &crtc->state->adjusted_mode;
+- u32 samplerate = hdmi->audio.samplerate;
++ u32 samplerate = vc4_hdmi->audio.samplerate;
+ u32 n, cts;
+ u64 tmp;
+
+@@ -689,16 +689,16 @@ static inline struct vc4_hdmi *dai_to_hd
+ static int vc4_hdmi_audio_startup(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+ {
+- struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
+- struct drm_encoder *encoder = &hdmi->encoder.base.base;
+- struct drm_connector *connector = &hdmi->connector.base;
++ struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
++ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
++ struct drm_connector *connector = &vc4_hdmi->connector.base;
+ struct vc4_dev *vc4 = to_vc4_dev(encoder->dev);
+ int ret;
+
+- if (hdmi->audio.substream && hdmi->audio.substream != substream)
++ if (vc4_hdmi->audio.substream && vc4_hdmi->audio.substream != substream)
+ return -EINVAL;
+
+- hdmi->audio.substream = substream;
++ vc4_hdmi->audio.substream = substream;
+
+ /*
+ * If the HDMI encoder hasn't probed, or the encoder is
+@@ -720,11 +720,11 @@ static int vc4_hdmi_audio_set_fmt(struct
+ return 0;
+ }
+
+-static void vc4_hdmi_audio_reset(struct vc4_hdmi *hdmi)
++static void vc4_hdmi_audio_reset(struct vc4_hdmi *vc4_hdmi)
+ {
+- struct drm_encoder *encoder = &hdmi->encoder.base.base;
++ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
+ struct drm_device *drm = encoder->dev;
+- struct device *dev = &hdmi->pdev->dev;
++ struct device *dev = &vc4_hdmi->pdev->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(drm);
+ int ret;
+
+@@ -740,14 +740,14 @@ static void vc4_hdmi_audio_reset(struct
+ static void vc4_hdmi_audio_shutdown(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+ {
+- struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
++ struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
+
+- if (substream != hdmi->audio.substream)
++ if (substream != vc4_hdmi->audio.substream)
+ return;
+
+- vc4_hdmi_audio_reset(hdmi);
++ vc4_hdmi_audio_reset(vc4_hdmi);
+
+- hdmi->audio.substream = NULL;
++ vc4_hdmi->audio.substream = NULL;
+ }
+
+ /* HDMI audio codec callbacks */
+@@ -755,23 +755,23 @@ static int vc4_hdmi_audio_hw_params(stru
+ struct snd_pcm_hw_params *params,
+ struct snd_soc_dai *dai)
+ {
+- struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
+- struct drm_encoder *encoder = &hdmi->encoder.base.base;
++ struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
++ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
+ struct drm_device *drm = encoder->dev;
+- struct device *dev = &hdmi->pdev->dev;
++ struct device *dev = &vc4_hdmi->pdev->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(drm);
+ u32 audio_packet_config, channel_mask;
+ u32 channel_map, i;
+
+- if (substream != hdmi->audio.substream)
++ if (substream != vc4_hdmi->audio.substream)
+ return -EINVAL;
+
+ dev_dbg(dev, "%s: %u Hz, %d bit, %d channels\n", __func__,
+ params_rate(params), params_width(params),
+ params_channels(params));
+
+- hdmi->audio.channels = params_channels(params);
+- hdmi->audio.samplerate = params_rate(params);
++ vc4_hdmi->audio.channels = params_channels(params);
++ vc4_hdmi->audio.samplerate = params_rate(params);
+
+ HD_WRITE(VC4_HD_MAI_CTL,
+ VC4_HD_MAI_CTL_RESET |
+@@ -780,23 +780,23 @@ static int vc4_hdmi_audio_hw_params(stru
+ VC4_HD_MAI_CTL_ERRORE |
+ VC4_HD_MAI_CTL_ERRORF);
+
+- vc4_hdmi_audio_set_mai_clock(hdmi);
++ vc4_hdmi_audio_set_mai_clock(vc4_hdmi);
+
+ audio_packet_config =
+ VC4_HDMI_AUDIO_PACKET_ZERO_DATA_ON_SAMPLE_FLAT |
+ VC4_HDMI_AUDIO_PACKET_ZERO_DATA_ON_INACTIVE_CHANNELS |
+ VC4_SET_FIELD(0xf, VC4_HDMI_AUDIO_PACKET_B_FRAME_IDENTIFIER);
+
+- channel_mask = GENMASK(hdmi->audio.channels - 1, 0);
++ channel_mask = GENMASK(vc4_hdmi->audio.channels - 1, 0);
+ audio_packet_config |= VC4_SET_FIELD(channel_mask,
+ VC4_HDMI_AUDIO_PACKET_CEA_MASK);
+
+ /* Set the MAI threshold. This logic mimics the firmware's. */
+- if (hdmi->audio.samplerate > 96000) {
++ if (vc4_hdmi->audio.samplerate > 96000) {
+ HD_WRITE(VC4_HD_MAI_THR,
+ VC4_SET_FIELD(0x12, VC4_HD_MAI_THR_DREQHIGH) |
+ VC4_SET_FIELD(0x12, VC4_HD_MAI_THR_DREQLOW));
+- } else if (hdmi->audio.samplerate > 48000) {
++ } else if (vc4_hdmi->audio.samplerate > 48000) {
+ HD_WRITE(VC4_HD_MAI_THR,
+ VC4_SET_FIELD(0x14, VC4_HD_MAI_THR_DREQHIGH) |
+ VC4_SET_FIELD(0x12, VC4_HD_MAI_THR_DREQLOW));
+@@ -820,7 +820,7 @@ static int vc4_hdmi_audio_hw_params(stru
+
+ HDMI_WRITE(VC4_HDMI_MAI_CHANNEL_MAP, channel_map);
+ HDMI_WRITE(VC4_HDMI_AUDIO_PACKET_CONFIG, audio_packet_config);
+- vc4_hdmi_set_n_cts(hdmi);
++ vc4_hdmi_set_n_cts(vc4_hdmi);
+
+ return 0;
+ }
+@@ -828,8 +828,8 @@ static int vc4_hdmi_audio_hw_params(stru
+ static int vc4_hdmi_audio_trigger(struct snd_pcm_substream *substream, int cmd,
+ struct snd_soc_dai *dai)
+ {
+- struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
+- struct drm_encoder *encoder = &hdmi->encoder.base.base;
++ struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
++ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
+ struct drm_device *drm = encoder->dev;
+ struct vc4_dev *vc4 = to_vc4_dev(drm);
+
+@@ -840,7 +840,7 @@ static int vc4_hdmi_audio_trigger(struct
+ HDMI_READ(VC4_HDMI_TX_PHY_CTL0) &
+ ~VC4_HDMI_TX_PHY_RNG_PWRDN);
+ HD_WRITE(VC4_HD_MAI_CTL,
+- VC4_SET_FIELD(hdmi->audio.channels,
++ VC4_SET_FIELD(vc4_hdmi->audio.channels,
+ VC4_HD_MAI_CTL_CHNUM) |
+ VC4_HD_MAI_CTL_ENABLE);
+ break;
+@@ -872,8 +872,8 @@ static int vc4_hdmi_audio_eld_ctl_info(s
+ struct snd_ctl_elem_info *uinfo)
+ {
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+- struct vc4_hdmi *hdmi = snd_component_to_hdmi(component);
+- struct drm_connector *connector = &hdmi->connector.base;
++ struct vc4_hdmi *vc4_hdmi = snd_component_to_hdmi(component);
++ struct drm_connector *connector = &vc4_hdmi->connector.base;
+
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
+ uinfo->count = sizeof(connector->eld);
+@@ -885,8 +885,8 @@ static int vc4_hdmi_audio_eld_ctl_get(st
+ struct snd_ctl_elem_value *ucontrol)
+ {
+ struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+- struct vc4_hdmi *hdmi = snd_component_to_hdmi(component);
+- struct drm_connector *connector = &hdmi->connector.base;
++ struct vc4_hdmi *vc4_hdmi = snd_component_to_hdmi(component);
++ struct drm_connector *connector = &vc4_hdmi->connector.base;
+
+ memcpy(ucontrol->value.bytes.data, connector->eld,
+ sizeof(connector->eld));
+@@ -954,9 +954,9 @@ static const struct snd_soc_component_dr
+
+ static int vc4_hdmi_audio_cpu_dai_probe(struct snd_soc_dai *dai)
+ {
+- struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
++ struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
+
+- snd_soc_dai_init_dma_data(dai, &hdmi->audio.dma_data, NULL);
++ snd_soc_dai_init_dma_data(dai, &vc4_hdmi->audio.dma_data, NULL);
+
+ return 0;
+ }
+@@ -982,11 +982,11 @@ static const struct snd_dmaengine_pcm_co
+ .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
+ };
+
+-static int vc4_hdmi_audio_init(struct vc4_hdmi *hdmi)
++static int vc4_hdmi_audio_init(struct vc4_hdmi *vc4_hdmi)
+ {
+- struct snd_soc_dai_link *dai_link = &hdmi->audio.link;
+- struct snd_soc_card *card = &hdmi->audio.card;
+- struct device *dev = &hdmi->pdev->dev;
++ struct snd_soc_dai_link *dai_link = &vc4_hdmi->audio.link;
++ struct snd_soc_card *card = &vc4_hdmi->audio.card;
++ struct device *dev = &vc4_hdmi->pdev->dev;
+ const __be32 *addr;
+ int ret;
+ int len;
+@@ -1006,9 +1006,9 @@ static int vc4_hdmi_audio_init(struct vc
+ * This VC/MMU should probably be exposed to avoid this kind of hacks.
+ */
+ addr = of_get_address(dev->of_node, 1, NULL, NULL);
+- hdmi->audio.dma_data.addr = be32_to_cpup(addr) + VC4_HD_MAI_DATA;
+- hdmi->audio.dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+- hdmi->audio.dma_data.maxburst = 2;
++ vc4_hdmi->audio.dma_data.addr = be32_to_cpup(addr) + VC4_HD_MAI_DATA;
++ vc4_hdmi->audio.dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
++ vc4_hdmi->audio.dma_data.maxburst = 2;
+
+ ret = devm_snd_dmaengine_pcm_register(dev, &pcm_conf, 0);
+ if (ret) {
+@@ -1031,9 +1031,9 @@ static int vc4_hdmi_audio_init(struct vc
+ return ret;
+ }
+
+- dai_link->cpus = &hdmi->audio.cpu;
+- dai_link->codecs = &hdmi->audio.codec;
+- dai_link->platforms = &hdmi->audio.platform;
++ dai_link->cpus = &vc4_hdmi->audio.cpu;
++ dai_link->codecs = &vc4_hdmi->audio.codec;
++ dai_link->platforms = &vc4_hdmi->audio.platform;
+
+ dai_link->num_cpus = 1;
+ dai_link->num_codecs = 1;
+@@ -1058,7 +1058,7 @@ static int vc4_hdmi_audio_init(struct vc
+ * now stored in card->drvdata and should be retrieved with
+ * snd_soc_card_get_drvdata() if needed.
+ */
+- snd_soc_card_set_drvdata(card, hdmi);
++ snd_soc_card_set_drvdata(card, vc4_hdmi);
+ ret = devm_snd_soc_register_card(dev, card);
+ if (ret)
+ dev_err(dev, "Could not register sound card: %d\n", ret);
+@@ -1071,20 +1071,21 @@ static int vc4_hdmi_audio_init(struct vc
+ static irqreturn_t vc4_cec_irq_handler_thread(int irq, void *priv)
+ {
+ struct vc4_dev *vc4 = priv;
+- struct vc4_hdmi *hdmi = vc4->hdmi;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
+
+- if (hdmi->cec_irq_was_rx) {
+- if (hdmi->cec_rx_msg.len)
+- cec_received_msg(hdmi->cec_adap, &hdmi->cec_rx_msg);
+- } else if (hdmi->cec_tx_ok) {
+- cec_transmit_done(hdmi->cec_adap, CEC_TX_STATUS_OK,
++ if (vc4_hdmi->cec_irq_was_rx) {
++ if (vc4_hdmi->cec_rx_msg.len)
++ cec_received_msg(vc4_hdmi->cec_adap,
++ &vc4_hdmi->cec_rx_msg);
++ } else if (vc4_hdmi->cec_tx_ok) {
++ cec_transmit_done(vc4_hdmi->cec_adap, CEC_TX_STATUS_OK,
+ 0, 0, 0, 0);
+ } else {
+ /*
+ * This CEC implementation makes 1 retry, so if we
+ * get a NACK, then that means it made 2 attempts.
+ */
+- cec_transmit_done(hdmi->cec_adap, CEC_TX_STATUS_NACK,
++ cec_transmit_done(vc4_hdmi->cec_adap, CEC_TX_STATUS_NACK,
+ 0, 2, 0, 0);
+ }
+ return IRQ_HANDLED;
+@@ -1110,23 +1111,23 @@ static void vc4_cec_read_msg(struct vc4_
+ static irqreturn_t vc4_cec_irq_handler(int irq, void *priv)
+ {
+ struct vc4_dev *vc4 = priv;
+- struct vc4_hdmi *hdmi = vc4->hdmi;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
+ u32 stat = HDMI_READ(VC4_HDMI_CPU_STATUS);
+ u32 cntrl1, cntrl5;
+
+ if (!(stat & VC4_HDMI_CPU_CEC))
+ return IRQ_NONE;
+- hdmi->cec_rx_msg.len = 0;
++ vc4_hdmi->cec_rx_msg.len = 0;
+ cntrl1 = HDMI_READ(VC4_HDMI_CEC_CNTRL_1);
+ cntrl5 = HDMI_READ(VC4_HDMI_CEC_CNTRL_5);
+- hdmi->cec_irq_was_rx = cntrl5 & VC4_HDMI_CEC_RX_CEC_INT;
+- if (hdmi->cec_irq_was_rx) {
++ vc4_hdmi->cec_irq_was_rx = cntrl5 & VC4_HDMI_CEC_RX_CEC_INT;
++ if (vc4_hdmi->cec_irq_was_rx) {
+ vc4_cec_read_msg(vc4, cntrl1);
+ cntrl1 |= VC4_HDMI_CEC_CLEAR_RECEIVE_OFF;
+ HDMI_WRITE(VC4_HDMI_CEC_CNTRL_1, cntrl1);
+ cntrl1 &= ~VC4_HDMI_CEC_CLEAR_RECEIVE_OFF;
+ } else {
+- hdmi->cec_tx_ok = cntrl1 & VC4_HDMI_CEC_TX_STATUS_GOOD;
++ vc4_hdmi->cec_tx_ok = cntrl1 & VC4_HDMI_CEC_TX_STATUS_GOOD;
+ cntrl1 &= ~VC4_HDMI_CEC_START_XMIT_BEGIN;
+ }
+ HDMI_WRITE(VC4_HDMI_CEC_CNTRL_1, cntrl1);
+@@ -1228,44 +1229,44 @@ static int vc4_hdmi_bind(struct device *
+ struct platform_device *pdev = to_platform_device(dev);
+ struct drm_device *drm = dev_get_drvdata(master);
+ struct vc4_dev *vc4 = drm->dev_private;
+- struct vc4_hdmi *hdmi;
++ struct vc4_hdmi *vc4_hdmi;
+ struct drm_encoder *encoder;
+ struct device_node *ddc_node;
+ u32 value;
+ int ret;
+
+- hdmi = devm_kzalloc(dev, sizeof(*hdmi), GFP_KERNEL);
+- if (!hdmi)
++ vc4_hdmi = devm_kzalloc(dev, sizeof(*vc4_hdmi), GFP_KERNEL);
++ if (!vc4_hdmi)
+ return -ENOMEM;
+
+- hdmi->pdev = pdev;
+- encoder = &hdmi->encoder.base.base;
++ vc4_hdmi->pdev = pdev;
++ encoder = &vc4_hdmi->encoder.base.base;
+ encoder->base.type = VC4_ENCODER_TYPE_HDMI0;
+
+- hdmi->hdmicore_regs = vc4_ioremap_regs(pdev, 0);
+- if (IS_ERR(hdmi->hdmicore_regs))
+- return PTR_ERR(hdmi->hdmicore_regs);
+-
+- hdmi->hd_regs = vc4_ioremap_regs(pdev, 1);
+- if (IS_ERR(hdmi->hd_regs))
+- return PTR_ERR(hdmi->hd_regs);
+-
+- hdmi->hdmi_regset.base = hdmi->hdmicore_regs;
+- hdmi->hdmi_regset.regs = hdmi_regs;
+- hdmi->hdmi_regset.nregs = ARRAY_SIZE(hdmi_regs);
+- hdmi->hd_regset.base = hdmi->hd_regs;
+- hdmi->hd_regset.regs = hd_regs;
+- hdmi->hd_regset.nregs = ARRAY_SIZE(hd_regs);
++ vc4_hdmi->hdmicore_regs = vc4_ioremap_regs(pdev, 0);
++ if (IS_ERR(vc4_hdmi->hdmicore_regs))
++ return PTR_ERR(vc4_hdmi->hdmicore_regs);
++
++ vc4_hdmi->hd_regs = vc4_ioremap_regs(pdev, 1);
++ if (IS_ERR(vc4_hdmi->hd_regs))
++ return PTR_ERR(vc4_hdmi->hd_regs);
++
++ vc4_hdmi->hdmi_regset.base = vc4_hdmi->hdmicore_regs;
++ vc4_hdmi->hdmi_regset.regs = hdmi_regs;
++ vc4_hdmi->hdmi_regset.nregs = ARRAY_SIZE(hdmi_regs);
++ vc4_hdmi->hd_regset.base = vc4_hdmi->hd_regs;
++ vc4_hdmi->hd_regset.regs = hd_regs;
++ vc4_hdmi->hd_regset.nregs = ARRAY_SIZE(hd_regs);
+
+- hdmi->pixel_clock = devm_clk_get(dev, "pixel");
+- if (IS_ERR(hdmi->pixel_clock)) {
++ vc4_hdmi->pixel_clock = devm_clk_get(dev, "pixel");
++ if (IS_ERR(vc4_hdmi->pixel_clock)) {
+ DRM_ERROR("Failed to get pixel clock\n");
+- return PTR_ERR(hdmi->pixel_clock);
++ return PTR_ERR(vc4_hdmi->pixel_clock);
+ }
+- hdmi->hsm_clock = devm_clk_get(dev, "hdmi");
+- if (IS_ERR(hdmi->hsm_clock)) {
++ vc4_hdmi->hsm_clock = devm_clk_get(dev, "hdmi");
++ if (IS_ERR(vc4_hdmi->hsm_clock)) {
+ DRM_ERROR("Failed to get HDMI state machine clock\n");
+- return PTR_ERR(hdmi->hsm_clock);
++ return PTR_ERR(vc4_hdmi->hsm_clock);
+ }
+
+ ddc_node = of_parse_phandle(dev->of_node, "ddc", 0);
+@@ -1274,9 +1275,9 @@ static int vc4_hdmi_bind(struct device *
+ return -ENODEV;
+ }
+
+- hdmi->ddc = of_find_i2c_adapter_by_node(ddc_node);
++ vc4_hdmi->ddc = of_find_i2c_adapter_by_node(ddc_node);
+ of_node_put(ddc_node);
+- if (!hdmi->ddc) {
++ if (!vc4_hdmi->ddc) {
+ DRM_DEBUG("Failed to get ddc i2c adapter by node\n");
+ return -EPROBE_DEFER;
+ }
+@@ -1285,13 +1286,13 @@ static int vc4_hdmi_bind(struct device *
+ * needs to be a bit higher than the pixel clock rate
+ * (generally 148.5Mhz).
+ */
+- ret = clk_set_rate(hdmi->hsm_clock, HSM_CLOCK_FREQ);
++ ret = clk_set_rate(vc4_hdmi->hsm_clock, HSM_CLOCK_FREQ);
+ if (ret) {
+ DRM_ERROR("Failed to set HSM clock rate: %d\n", ret);
+ goto err_put_i2c;
+ }
+
+- ret = clk_prepare_enable(hdmi->hsm_clock);
++ ret = clk_prepare_enable(vc4_hdmi->hsm_clock);
+ if (ret) {
+ DRM_ERROR("Failed to turn on HDMI state machine clock: %d\n",
+ ret);
+@@ -1304,18 +1305,18 @@ static int vc4_hdmi_bind(struct device *
+ if (of_find_property(dev->of_node, "hpd-gpios", &value)) {
+ enum of_gpio_flags hpd_gpio_flags;
+
+- hdmi->hpd_gpio = of_get_named_gpio_flags(dev->of_node,
++ vc4_hdmi->hpd_gpio = of_get_named_gpio_flags(dev->of_node,
+ "hpd-gpios", 0,
+ &hpd_gpio_flags);
+- if (hdmi->hpd_gpio < 0) {
+- ret = hdmi->hpd_gpio;
++ if (vc4_hdmi->hpd_gpio < 0) {
++ ret = vc4_hdmi->hpd_gpio;
+ goto err_unprepare_hsm;
+ }
+
+- hdmi->hpd_active_low = hpd_gpio_flags & OF_GPIO_ACTIVE_LOW;
++ vc4_hdmi->hpd_active_low = hpd_gpio_flags & OF_GPIO_ACTIVE_LOW;
+ }
+
+- vc4->hdmi = hdmi;
++ vc4->hdmi = vc4_hdmi;
+
+ /* HDMI core must be enabled. */
+ if (!(HD_READ(VC4_HD_M_CTL) & VC4_HD_M_ENABLE)) {
+@@ -1331,21 +1332,21 @@ static int vc4_hdmi_bind(struct device *
+ DRM_MODE_ENCODER_TMDS, NULL);
+ drm_encoder_helper_add(encoder, &vc4_hdmi_encoder_helper_funcs);
+
+- ret = vc4_hdmi_connector_init(drm, hdmi);
++ ret = vc4_hdmi_connector_init(drm, vc4_hdmi);
+ if (ret)
+ goto err_destroy_encoder;
+
+ #ifdef CONFIG_DRM_VC4_HDMI_CEC
+- hdmi->cec_adap = cec_allocate_adapter(&vc4_hdmi_cec_adap_ops,
++ vc4_hdmi->cec_adap = cec_allocate_adapter(&vc4_hdmi_cec_adap_ops,
+ vc4, "vc4",
+ CEC_CAP_DEFAULTS |
+ CEC_CAP_CONNECTOR_INFO, 1);
+- ret = PTR_ERR_OR_ZERO(hdmi->cec_adap);
++ ret = PTR_ERR_OR_ZERO(vc4_hdmi->cec_adap);
+ if (ret < 0)
+ goto err_destroy_conn;
+
+- cec_fill_conn_info_from_drm(&conn_info, &hdmi->connector.base);
+- cec_s_conn_info(hdmi->cec_adap, &conn_info);
++ cec_fill_conn_info_from_drm(&conn_info, &vc4_hdmi->connector.base);
++ cec_s_conn_info(vc4_hdmi->cec_adap, &conn_info);
+
+ HDMI_WRITE(VC4_HDMI_CPU_MASK_SET, 0xffffffff);
+ value = HDMI_READ(VC4_HDMI_CEC_CNTRL_1);
+@@ -1364,32 +1365,32 @@ static int vc4_hdmi_bind(struct device *
+ "vc4 hdmi cec", vc4);
+ if (ret)
+ goto err_delete_cec_adap;
+- ret = cec_register_adapter(hdmi->cec_adap, dev);
++ ret = cec_register_adapter(vc4_hdmi->cec_adap, dev);
+ if (ret < 0)
+ goto err_delete_cec_adap;
+ #endif
+
+- ret = vc4_hdmi_audio_init(hdmi);
++ ret = vc4_hdmi_audio_init(vc4_hdmi);
+ if (ret)
+ goto err_destroy_encoder;
+
+- vc4_debugfs_add_file(drm, "hdmi_regs", vc4_hdmi_debugfs_regs, hdmi);
++ vc4_debugfs_add_file(drm, "hdmi_regs", vc4_hdmi_debugfs_regs, vc4_hdmi);
+
+ return 0;
+
+ #ifdef CONFIG_DRM_VC4_HDMI_CEC
+ err_delete_cec_adap:
+- cec_delete_adapter(hdmi->cec_adap);
++ cec_delete_adapter(vc4_hdmi->cec_adap);
+ err_destroy_conn:
+- vc4_hdmi_connector_destroy(&hdmi->connector.base);
++ vc4_hdmi_connector_destroy(&vc4_hdmi->connector.base);
+ #endif
+ err_destroy_encoder:
+ vc4_hdmi_encoder_destroy(encoder);
+ err_unprepare_hsm:
+- clk_disable_unprepare(hdmi->hsm_clock);
++ clk_disable_unprepare(vc4_hdmi->hsm_clock);
+ pm_runtime_disable(dev);
+ err_put_i2c:
+- put_device(&hdmi->ddc->dev);
++ put_device(&vc4_hdmi->ddc->dev);
+
+ return ret;
+ }
+@@ -1399,16 +1400,16 @@ static void vc4_hdmi_unbind(struct devic
+ {
+ struct drm_device *drm = dev_get_drvdata(master);
+ struct vc4_dev *vc4 = drm->dev_private;
+- struct vc4_hdmi *hdmi = vc4->hdmi;
++ struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
+
+- cec_unregister_adapter(hdmi->cec_adap);
+- vc4_hdmi_connector_destroy(&hdmi->connector.base);
+- vc4_hdmi_encoder_destroy(&hdmi->encoder.base.base);
++ cec_unregister_adapter(vc4_hdmi->cec_adap);
++ vc4_hdmi_connector_destroy(&vc4_hdmi->connector.base);
++ vc4_hdmi_encoder_destroy(&vc4_hdmi->encoder.base.base);
+
+- clk_disable_unprepare(hdmi->hsm_clock);
++ clk_disable_unprepare(vc4_hdmi->hsm_clock);
+ pm_runtime_disable(dev);
+
+- put_device(&hdmi->ddc->dev);
++ put_device(&vc4_hdmi->ddc->dev);
+
+ vc4->hdmi = NULL;
+ }