1 From 02b7a6ed6b9fc110dd26598d26c31c0837af6184 Mon Sep 17 00:00:00 2001
2 From: Maxime Ripard <maxime@cerno.tech>
3 Date: Mon, 6 Jan 2020 18:07:05 +0100
4 Subject: [PATCH] drm/vc4: hdmi: Rename hdmi to vc4_hdmi
6 The driver isn't consistent with the name given to the vc4_hdmi
7 structure pointer in its functions. Make sure to use a consistent name.
9 Signed-off-by: Maxime Ripard <maxime@cerno.tech>
11 drivers/gpu/drm/vc4/vc4_hdmi.c | 271 +++++++++++++++++----------------
12 1 file changed, 136 insertions(+), 135 deletions(-)
14 --- a/drivers/gpu/drm/vc4/vc4_hdmi.c
15 +++ b/drivers/gpu/drm/vc4/vc4_hdmi.c
16 @@ -108,11 +108,11 @@ static const struct debugfs_reg32 hd_reg
17 static int vc4_hdmi_debugfs_regs(struct seq_file *m, void *unused)
19 struct drm_info_node *node = (struct drm_info_node *)m->private;
20 - struct vc4_hdmi *hdmi = node->info_ent->data;
21 + struct vc4_hdmi *vc4_hdmi = node->info_ent->data;
22 struct drm_printer p = drm_seq_file_printer(m);
24 - drm_print_regset32(&p, &hdmi->hdmi_regset);
25 - drm_print_regset32(&p, &hdmi->hd_regset);
26 + drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
27 + drm_print_regset32(&p, &vc4_hdmi->hd_regset);
31 @@ -297,8 +297,8 @@ static void vc4_hdmi_set_avi_infoframe(s
33 struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
34 struct vc4_dev *vc4 = encoder->dev->dev_private;
35 - struct vc4_hdmi *hdmi = vc4->hdmi;
36 - struct drm_connector *connector = &hdmi->connector.base;
37 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
38 + struct drm_connector *connector = &vc4_hdmi->connector.base;
39 struct drm_connector_state *cstate = connector->state;
40 struct drm_crtc *crtc = encoder->crtc;
41 const struct drm_display_mode *mode = &crtc->state->adjusted_mode;
42 @@ -346,7 +346,7 @@ static void vc4_hdmi_set_audio_infoframe
44 struct drm_device *drm = encoder->dev;
45 struct vc4_dev *vc4 = drm->dev_private;
46 - struct vc4_hdmi *hdmi = vc4->hdmi;
47 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
48 union hdmi_infoframe frame;
51 @@ -355,7 +355,7 @@ static void vc4_hdmi_set_audio_infoframe
52 frame.audio.coding_type = HDMI_AUDIO_CODING_TYPE_STREAM;
53 frame.audio.sample_frequency = HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM;
54 frame.audio.sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM;
55 - frame.audio.channels = hdmi->audio.channels;
56 + frame.audio.channels = vc4_hdmi->audio.channels;
58 vc4_hdmi_write_infoframe(encoder, &frame);
60 @@ -370,7 +370,7 @@ static void vc4_hdmi_encoder_disable(str
62 struct drm_device *dev = encoder->dev;
63 struct vc4_dev *vc4 = to_vc4_dev(dev);
64 - struct vc4_hdmi *hdmi = vc4->hdmi;
65 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
68 HDMI_WRITE(VC4_HDMI_RAM_PACKET_CONFIG, 0);
69 @@ -379,9 +379,9 @@ static void vc4_hdmi_encoder_disable(str
70 HD_WRITE(VC4_HD_VID_CTL,
71 HD_READ(VC4_HD_VID_CTL) & ~VC4_HD_VID_CTL_ENABLE);
73 - clk_disable_unprepare(hdmi->pixel_clock);
74 + clk_disable_unprepare(vc4_hdmi->pixel_clock);
76 - ret = pm_runtime_put(&hdmi->pdev->dev);
77 + ret = pm_runtime_put(&vc4_hdmi->pdev->dev);
79 DRM_ERROR("Failed to release power domain: %d\n", ret);
81 @@ -392,7 +392,7 @@ static void vc4_hdmi_encoder_enable(stru
82 struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
83 struct drm_device *dev = encoder->dev;
84 struct vc4_dev *vc4 = to_vc4_dev(dev);
85 - struct vc4_hdmi *hdmi = vc4->hdmi;
86 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
87 bool debug_dump_regs = false;
88 bool hsync_pos = mode->flags & DRM_MODE_FLAG_PHSYNC;
89 bool vsync_pos = mode->flags & DRM_MODE_FLAG_PVSYNC;
90 @@ -414,13 +414,13 @@ static void vc4_hdmi_encoder_enable(stru
94 - ret = pm_runtime_get_sync(&hdmi->pdev->dev);
95 + ret = pm_runtime_get_sync(&vc4_hdmi->pdev->dev);
97 DRM_ERROR("Failed to retain power domain: %d\n", ret);
101 - ret = clk_set_rate(hdmi->pixel_clock,
102 + ret = clk_set_rate(vc4_hdmi->pixel_clock,
104 ((mode->flags & DRM_MODE_FLAG_DBLCLK) ? 2 : 1));
106 @@ -428,7 +428,7 @@ static void vc4_hdmi_encoder_enable(stru
110 - ret = clk_prepare_enable(hdmi->pixel_clock);
111 + ret = clk_prepare_enable(vc4_hdmi->pixel_clock);
113 DRM_ERROR("Failed to turn on pixel clock: %d\n", ret);
115 @@ -448,11 +448,11 @@ static void vc4_hdmi_encoder_enable(stru
116 HDMI_WRITE(VC4_HDMI_TX_PHY_RESET_CTL, 0);
118 if (debug_dump_regs) {
119 - struct drm_printer p = drm_info_printer(&hdmi->pdev->dev);
120 + struct drm_printer p = drm_info_printer(&vc4_hdmi->pdev->dev);
122 - dev_info(&hdmi->pdev->dev, "HDMI regs before:\n");
123 - drm_print_regset32(&p, &hdmi->hdmi_regset);
124 - drm_print_regset32(&p, &hdmi->hd_regset);
125 + dev_info(&vc4_hdmi->pdev->dev, "HDMI regs before:\n");
126 + drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
127 + drm_print_regset32(&p, &vc4_hdmi->hd_regset);
130 HD_WRITE(VC4_HD_VID_CTL, 0);
131 @@ -527,11 +527,11 @@ static void vc4_hdmi_encoder_enable(stru
132 HDMI_WRITE(VC4_HDMI_FIFO_CTL, VC4_HDMI_FIFO_CTL_MASTER_SLAVE_N);
134 if (debug_dump_regs) {
135 - struct drm_printer p = drm_info_printer(&hdmi->pdev->dev);
136 + struct drm_printer p = drm_info_printer(&vc4_hdmi->pdev->dev);
138 - dev_info(&hdmi->pdev->dev, "HDMI regs after:\n");
139 - drm_print_regset32(&p, &hdmi->hdmi_regset);
140 - drm_print_regset32(&p, &hdmi->hd_regset);
141 + dev_info(&vc4_hdmi->pdev->dev, "HDMI regs after:\n");
142 + drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
143 + drm_print_regset32(&p, &vc4_hdmi->hd_regset);
146 HD_WRITE(VC4_HD_VID_CTL,
147 @@ -630,15 +630,15 @@ static const struct drm_encoder_helper_f
150 /* HDMI audio codec callbacks */
151 -static void vc4_hdmi_audio_set_mai_clock(struct vc4_hdmi *hdmi)
152 +static void vc4_hdmi_audio_set_mai_clock(struct vc4_hdmi *vc4_hdmi)
154 - struct drm_encoder *encoder = &hdmi->encoder.base.base;
155 + struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
156 struct drm_device *drm = encoder->dev;
157 struct vc4_dev *vc4 = to_vc4_dev(drm);
158 - u32 hsm_clock = clk_get_rate(hdmi->hsm_clock);
159 + u32 hsm_clock = clk_get_rate(vc4_hdmi->hsm_clock);
162 - rational_best_approximation(hsm_clock, hdmi->audio.samplerate,
163 + rational_best_approximation(hsm_clock, vc4_hdmi->audio.samplerate,
164 VC4_HD_MAI_SMP_N_MASK >>
165 VC4_HD_MAI_SMP_N_SHIFT,
166 (VC4_HD_MAI_SMP_M_MASK >>
167 @@ -650,14 +650,14 @@ static void vc4_hdmi_audio_set_mai_clock
168 VC4_SET_FIELD(m - 1, VC4_HD_MAI_SMP_M));
171 -static void vc4_hdmi_set_n_cts(struct vc4_hdmi *hdmi)
172 +static void vc4_hdmi_set_n_cts(struct vc4_hdmi *vc4_hdmi)
174 - struct drm_encoder *encoder = &hdmi->encoder.base.base;
175 + struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
176 struct drm_crtc *crtc = encoder->crtc;
177 struct drm_device *drm = encoder->dev;
178 struct vc4_dev *vc4 = to_vc4_dev(drm);
179 const struct drm_display_mode *mode = &crtc->state->adjusted_mode;
180 - u32 samplerate = hdmi->audio.samplerate;
181 + u32 samplerate = vc4_hdmi->audio.samplerate;
185 @@ -689,16 +689,16 @@ static inline struct vc4_hdmi *dai_to_hd
186 static int vc4_hdmi_audio_startup(struct snd_pcm_substream *substream,
187 struct snd_soc_dai *dai)
189 - struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
190 - struct drm_encoder *encoder = &hdmi->encoder.base.base;
191 - struct drm_connector *connector = &hdmi->connector.base;
192 + struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
193 + struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
194 + struct drm_connector *connector = &vc4_hdmi->connector.base;
195 struct vc4_dev *vc4 = to_vc4_dev(encoder->dev);
198 - if (hdmi->audio.substream && hdmi->audio.substream != substream)
199 + if (vc4_hdmi->audio.substream && vc4_hdmi->audio.substream != substream)
202 - hdmi->audio.substream = substream;
203 + vc4_hdmi->audio.substream = substream;
206 * If the HDMI encoder hasn't probed, or the encoder is
207 @@ -720,11 +720,11 @@ static int vc4_hdmi_audio_set_fmt(struct
211 -static void vc4_hdmi_audio_reset(struct vc4_hdmi *hdmi)
212 +static void vc4_hdmi_audio_reset(struct vc4_hdmi *vc4_hdmi)
214 - struct drm_encoder *encoder = &hdmi->encoder.base.base;
215 + struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
216 struct drm_device *drm = encoder->dev;
217 - struct device *dev = &hdmi->pdev->dev;
218 + struct device *dev = &vc4_hdmi->pdev->dev;
219 struct vc4_dev *vc4 = to_vc4_dev(drm);
222 @@ -740,14 +740,14 @@ static void vc4_hdmi_audio_reset(struct
223 static void vc4_hdmi_audio_shutdown(struct snd_pcm_substream *substream,
224 struct snd_soc_dai *dai)
226 - struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
227 + struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
229 - if (substream != hdmi->audio.substream)
230 + if (substream != vc4_hdmi->audio.substream)
233 - vc4_hdmi_audio_reset(hdmi);
234 + vc4_hdmi_audio_reset(vc4_hdmi);
236 - hdmi->audio.substream = NULL;
237 + vc4_hdmi->audio.substream = NULL;
240 /* HDMI audio codec callbacks */
241 @@ -755,23 +755,23 @@ static int vc4_hdmi_audio_hw_params(stru
242 struct snd_pcm_hw_params *params,
243 struct snd_soc_dai *dai)
245 - struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
246 - struct drm_encoder *encoder = &hdmi->encoder.base.base;
247 + struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
248 + struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
249 struct drm_device *drm = encoder->dev;
250 - struct device *dev = &hdmi->pdev->dev;
251 + struct device *dev = &vc4_hdmi->pdev->dev;
252 struct vc4_dev *vc4 = to_vc4_dev(drm);
253 u32 audio_packet_config, channel_mask;
256 - if (substream != hdmi->audio.substream)
257 + if (substream != vc4_hdmi->audio.substream)
260 dev_dbg(dev, "%s: %u Hz, %d bit, %d channels\n", __func__,
261 params_rate(params), params_width(params),
262 params_channels(params));
264 - hdmi->audio.channels = params_channels(params);
265 - hdmi->audio.samplerate = params_rate(params);
266 + vc4_hdmi->audio.channels = params_channels(params);
267 + vc4_hdmi->audio.samplerate = params_rate(params);
269 HD_WRITE(VC4_HD_MAI_CTL,
270 VC4_HD_MAI_CTL_RESET |
271 @@ -780,23 +780,23 @@ static int vc4_hdmi_audio_hw_params(stru
272 VC4_HD_MAI_CTL_ERRORE |
273 VC4_HD_MAI_CTL_ERRORF);
275 - vc4_hdmi_audio_set_mai_clock(hdmi);
276 + vc4_hdmi_audio_set_mai_clock(vc4_hdmi);
278 audio_packet_config =
279 VC4_HDMI_AUDIO_PACKET_ZERO_DATA_ON_SAMPLE_FLAT |
280 VC4_HDMI_AUDIO_PACKET_ZERO_DATA_ON_INACTIVE_CHANNELS |
281 VC4_SET_FIELD(0xf, VC4_HDMI_AUDIO_PACKET_B_FRAME_IDENTIFIER);
283 - channel_mask = GENMASK(hdmi->audio.channels - 1, 0);
284 + channel_mask = GENMASK(vc4_hdmi->audio.channels - 1, 0);
285 audio_packet_config |= VC4_SET_FIELD(channel_mask,
286 VC4_HDMI_AUDIO_PACKET_CEA_MASK);
288 /* Set the MAI threshold. This logic mimics the firmware's. */
289 - if (hdmi->audio.samplerate > 96000) {
290 + if (vc4_hdmi->audio.samplerate > 96000) {
291 HD_WRITE(VC4_HD_MAI_THR,
292 VC4_SET_FIELD(0x12, VC4_HD_MAI_THR_DREQHIGH) |
293 VC4_SET_FIELD(0x12, VC4_HD_MAI_THR_DREQLOW));
294 - } else if (hdmi->audio.samplerate > 48000) {
295 + } else if (vc4_hdmi->audio.samplerate > 48000) {
296 HD_WRITE(VC4_HD_MAI_THR,
297 VC4_SET_FIELD(0x14, VC4_HD_MAI_THR_DREQHIGH) |
298 VC4_SET_FIELD(0x12, VC4_HD_MAI_THR_DREQLOW));
299 @@ -820,7 +820,7 @@ static int vc4_hdmi_audio_hw_params(stru
301 HDMI_WRITE(VC4_HDMI_MAI_CHANNEL_MAP, channel_map);
302 HDMI_WRITE(VC4_HDMI_AUDIO_PACKET_CONFIG, audio_packet_config);
303 - vc4_hdmi_set_n_cts(hdmi);
304 + vc4_hdmi_set_n_cts(vc4_hdmi);
308 @@ -828,8 +828,8 @@ static int vc4_hdmi_audio_hw_params(stru
309 static int vc4_hdmi_audio_trigger(struct snd_pcm_substream *substream, int cmd,
310 struct snd_soc_dai *dai)
312 - struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
313 - struct drm_encoder *encoder = &hdmi->encoder.base.base;
314 + struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
315 + struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
316 struct drm_device *drm = encoder->dev;
317 struct vc4_dev *vc4 = to_vc4_dev(drm);
319 @@ -840,7 +840,7 @@ static int vc4_hdmi_audio_trigger(struct
320 HDMI_READ(VC4_HDMI_TX_PHY_CTL0) &
321 ~VC4_HDMI_TX_PHY_RNG_PWRDN);
322 HD_WRITE(VC4_HD_MAI_CTL,
323 - VC4_SET_FIELD(hdmi->audio.channels,
324 + VC4_SET_FIELD(vc4_hdmi->audio.channels,
325 VC4_HD_MAI_CTL_CHNUM) |
326 VC4_HD_MAI_CTL_ENABLE);
328 @@ -872,8 +872,8 @@ static int vc4_hdmi_audio_eld_ctl_info(s
329 struct snd_ctl_elem_info *uinfo)
331 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
332 - struct vc4_hdmi *hdmi = snd_component_to_hdmi(component);
333 - struct drm_connector *connector = &hdmi->connector.base;
334 + struct vc4_hdmi *vc4_hdmi = snd_component_to_hdmi(component);
335 + struct drm_connector *connector = &vc4_hdmi->connector.base;
337 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
338 uinfo->count = sizeof(connector->eld);
339 @@ -885,8 +885,8 @@ static int vc4_hdmi_audio_eld_ctl_get(st
340 struct snd_ctl_elem_value *ucontrol)
342 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
343 - struct vc4_hdmi *hdmi = snd_component_to_hdmi(component);
344 - struct drm_connector *connector = &hdmi->connector.base;
345 + struct vc4_hdmi *vc4_hdmi = snd_component_to_hdmi(component);
346 + struct drm_connector *connector = &vc4_hdmi->connector.base;
348 memcpy(ucontrol->value.bytes.data, connector->eld,
349 sizeof(connector->eld));
350 @@ -954,9 +954,9 @@ static const struct snd_soc_component_dr
352 static int vc4_hdmi_audio_cpu_dai_probe(struct snd_soc_dai *dai)
354 - struct vc4_hdmi *hdmi = dai_to_hdmi(dai);
355 + struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
357 - snd_soc_dai_init_dma_data(dai, &hdmi->audio.dma_data, NULL);
358 + snd_soc_dai_init_dma_data(dai, &vc4_hdmi->audio.dma_data, NULL);
362 @@ -982,11 +982,11 @@ static const struct snd_dmaengine_pcm_co
363 .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
366 -static int vc4_hdmi_audio_init(struct vc4_hdmi *hdmi)
367 +static int vc4_hdmi_audio_init(struct vc4_hdmi *vc4_hdmi)
369 - struct snd_soc_dai_link *dai_link = &hdmi->audio.link;
370 - struct snd_soc_card *card = &hdmi->audio.card;
371 - struct device *dev = &hdmi->pdev->dev;
372 + struct snd_soc_dai_link *dai_link = &vc4_hdmi->audio.link;
373 + struct snd_soc_card *card = &vc4_hdmi->audio.card;
374 + struct device *dev = &vc4_hdmi->pdev->dev;
378 @@ -1006,9 +1006,9 @@ static int vc4_hdmi_audio_init(struct vc
379 * This VC/MMU should probably be exposed to avoid this kind of hacks.
381 addr = of_get_address(dev->of_node, 1, NULL, NULL);
382 - hdmi->audio.dma_data.addr = be32_to_cpup(addr) + VC4_HD_MAI_DATA;
383 - hdmi->audio.dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
384 - hdmi->audio.dma_data.maxburst = 2;
385 + vc4_hdmi->audio.dma_data.addr = be32_to_cpup(addr) + VC4_HD_MAI_DATA;
386 + vc4_hdmi->audio.dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
387 + vc4_hdmi->audio.dma_data.maxburst = 2;
389 ret = devm_snd_dmaengine_pcm_register(dev, &pcm_conf, 0);
391 @@ -1031,9 +1031,9 @@ static int vc4_hdmi_audio_init(struct vc
395 - dai_link->cpus = &hdmi->audio.cpu;
396 - dai_link->codecs = &hdmi->audio.codec;
397 - dai_link->platforms = &hdmi->audio.platform;
398 + dai_link->cpus = &vc4_hdmi->audio.cpu;
399 + dai_link->codecs = &vc4_hdmi->audio.codec;
400 + dai_link->platforms = &vc4_hdmi->audio.platform;
402 dai_link->num_cpus = 1;
403 dai_link->num_codecs = 1;
404 @@ -1058,7 +1058,7 @@ static int vc4_hdmi_audio_init(struct vc
405 * now stored in card->drvdata and should be retrieved with
406 * snd_soc_card_get_drvdata() if needed.
408 - snd_soc_card_set_drvdata(card, hdmi);
409 + snd_soc_card_set_drvdata(card, vc4_hdmi);
410 ret = devm_snd_soc_register_card(dev, card);
412 dev_err(dev, "Could not register sound card: %d\n", ret);
413 @@ -1071,20 +1071,21 @@ static int vc4_hdmi_audio_init(struct vc
414 static irqreturn_t vc4_cec_irq_handler_thread(int irq, void *priv)
416 struct vc4_dev *vc4 = priv;
417 - struct vc4_hdmi *hdmi = vc4->hdmi;
418 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
420 - if (hdmi->cec_irq_was_rx) {
421 - if (hdmi->cec_rx_msg.len)
422 - cec_received_msg(hdmi->cec_adap, &hdmi->cec_rx_msg);
423 - } else if (hdmi->cec_tx_ok) {
424 - cec_transmit_done(hdmi->cec_adap, CEC_TX_STATUS_OK,
425 + if (vc4_hdmi->cec_irq_was_rx) {
426 + if (vc4_hdmi->cec_rx_msg.len)
427 + cec_received_msg(vc4_hdmi->cec_adap,
428 + &vc4_hdmi->cec_rx_msg);
429 + } else if (vc4_hdmi->cec_tx_ok) {
430 + cec_transmit_done(vc4_hdmi->cec_adap, CEC_TX_STATUS_OK,
434 * This CEC implementation makes 1 retry, so if we
435 * get a NACK, then that means it made 2 attempts.
437 - cec_transmit_done(hdmi->cec_adap, CEC_TX_STATUS_NACK,
438 + cec_transmit_done(vc4_hdmi->cec_adap, CEC_TX_STATUS_NACK,
442 @@ -1110,23 +1111,23 @@ static void vc4_cec_read_msg(struct vc4_
443 static irqreturn_t vc4_cec_irq_handler(int irq, void *priv)
445 struct vc4_dev *vc4 = priv;
446 - struct vc4_hdmi *hdmi = vc4->hdmi;
447 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
448 u32 stat = HDMI_READ(VC4_HDMI_CPU_STATUS);
451 if (!(stat & VC4_HDMI_CPU_CEC))
453 - hdmi->cec_rx_msg.len = 0;
454 + vc4_hdmi->cec_rx_msg.len = 0;
455 cntrl1 = HDMI_READ(VC4_HDMI_CEC_CNTRL_1);
456 cntrl5 = HDMI_READ(VC4_HDMI_CEC_CNTRL_5);
457 - hdmi->cec_irq_was_rx = cntrl5 & VC4_HDMI_CEC_RX_CEC_INT;
458 - if (hdmi->cec_irq_was_rx) {
459 + vc4_hdmi->cec_irq_was_rx = cntrl5 & VC4_HDMI_CEC_RX_CEC_INT;
460 + if (vc4_hdmi->cec_irq_was_rx) {
461 vc4_cec_read_msg(vc4, cntrl1);
462 cntrl1 |= VC4_HDMI_CEC_CLEAR_RECEIVE_OFF;
463 HDMI_WRITE(VC4_HDMI_CEC_CNTRL_1, cntrl1);
464 cntrl1 &= ~VC4_HDMI_CEC_CLEAR_RECEIVE_OFF;
466 - hdmi->cec_tx_ok = cntrl1 & VC4_HDMI_CEC_TX_STATUS_GOOD;
467 + vc4_hdmi->cec_tx_ok = cntrl1 & VC4_HDMI_CEC_TX_STATUS_GOOD;
468 cntrl1 &= ~VC4_HDMI_CEC_START_XMIT_BEGIN;
470 HDMI_WRITE(VC4_HDMI_CEC_CNTRL_1, cntrl1);
471 @@ -1228,44 +1229,44 @@ static int vc4_hdmi_bind(struct device *
472 struct platform_device *pdev = to_platform_device(dev);
473 struct drm_device *drm = dev_get_drvdata(master);
474 struct vc4_dev *vc4 = drm->dev_private;
475 - struct vc4_hdmi *hdmi;
476 + struct vc4_hdmi *vc4_hdmi;
477 struct drm_encoder *encoder;
478 struct device_node *ddc_node;
482 - hdmi = devm_kzalloc(dev, sizeof(*hdmi), GFP_KERNEL);
484 + vc4_hdmi = devm_kzalloc(dev, sizeof(*vc4_hdmi), GFP_KERNEL);
489 - encoder = &hdmi->encoder.base.base;
490 + vc4_hdmi->pdev = pdev;
491 + encoder = &vc4_hdmi->encoder.base.base;
492 encoder->base.type = VC4_ENCODER_TYPE_HDMI0;
494 - hdmi->hdmicore_regs = vc4_ioremap_regs(pdev, 0);
495 - if (IS_ERR(hdmi->hdmicore_regs))
496 - return PTR_ERR(hdmi->hdmicore_regs);
498 - hdmi->hd_regs = vc4_ioremap_regs(pdev, 1);
499 - if (IS_ERR(hdmi->hd_regs))
500 - return PTR_ERR(hdmi->hd_regs);
502 - hdmi->hdmi_regset.base = hdmi->hdmicore_regs;
503 - hdmi->hdmi_regset.regs = hdmi_regs;
504 - hdmi->hdmi_regset.nregs = ARRAY_SIZE(hdmi_regs);
505 - hdmi->hd_regset.base = hdmi->hd_regs;
506 - hdmi->hd_regset.regs = hd_regs;
507 - hdmi->hd_regset.nregs = ARRAY_SIZE(hd_regs);
508 + vc4_hdmi->hdmicore_regs = vc4_ioremap_regs(pdev, 0);
509 + if (IS_ERR(vc4_hdmi->hdmicore_regs))
510 + return PTR_ERR(vc4_hdmi->hdmicore_regs);
512 + vc4_hdmi->hd_regs = vc4_ioremap_regs(pdev, 1);
513 + if (IS_ERR(vc4_hdmi->hd_regs))
514 + return PTR_ERR(vc4_hdmi->hd_regs);
516 + vc4_hdmi->hdmi_regset.base = vc4_hdmi->hdmicore_regs;
517 + vc4_hdmi->hdmi_regset.regs = hdmi_regs;
518 + vc4_hdmi->hdmi_regset.nregs = ARRAY_SIZE(hdmi_regs);
519 + vc4_hdmi->hd_regset.base = vc4_hdmi->hd_regs;
520 + vc4_hdmi->hd_regset.regs = hd_regs;
521 + vc4_hdmi->hd_regset.nregs = ARRAY_SIZE(hd_regs);
523 - hdmi->pixel_clock = devm_clk_get(dev, "pixel");
524 - if (IS_ERR(hdmi->pixel_clock)) {
525 + vc4_hdmi->pixel_clock = devm_clk_get(dev, "pixel");
526 + if (IS_ERR(vc4_hdmi->pixel_clock)) {
527 DRM_ERROR("Failed to get pixel clock\n");
528 - return PTR_ERR(hdmi->pixel_clock);
529 + return PTR_ERR(vc4_hdmi->pixel_clock);
531 - hdmi->hsm_clock = devm_clk_get(dev, "hdmi");
532 - if (IS_ERR(hdmi->hsm_clock)) {
533 + vc4_hdmi->hsm_clock = devm_clk_get(dev, "hdmi");
534 + if (IS_ERR(vc4_hdmi->hsm_clock)) {
535 DRM_ERROR("Failed to get HDMI state machine clock\n");
536 - return PTR_ERR(hdmi->hsm_clock);
537 + return PTR_ERR(vc4_hdmi->hsm_clock);
540 ddc_node = of_parse_phandle(dev->of_node, "ddc", 0);
541 @@ -1274,9 +1275,9 @@ static int vc4_hdmi_bind(struct device *
545 - hdmi->ddc = of_find_i2c_adapter_by_node(ddc_node);
546 + vc4_hdmi->ddc = of_find_i2c_adapter_by_node(ddc_node);
547 of_node_put(ddc_node);
549 + if (!vc4_hdmi->ddc) {
550 DRM_DEBUG("Failed to get ddc i2c adapter by node\n");
551 return -EPROBE_DEFER;
553 @@ -1285,13 +1286,13 @@ static int vc4_hdmi_bind(struct device *
554 * needs to be a bit higher than the pixel clock rate
555 * (generally 148.5Mhz).
557 - ret = clk_set_rate(hdmi->hsm_clock, HSM_CLOCK_FREQ);
558 + ret = clk_set_rate(vc4_hdmi->hsm_clock, HSM_CLOCK_FREQ);
560 DRM_ERROR("Failed to set HSM clock rate: %d\n", ret);
564 - ret = clk_prepare_enable(hdmi->hsm_clock);
565 + ret = clk_prepare_enable(vc4_hdmi->hsm_clock);
567 DRM_ERROR("Failed to turn on HDMI state machine clock: %d\n",
569 @@ -1304,18 +1305,18 @@ static int vc4_hdmi_bind(struct device *
570 if (of_find_property(dev->of_node, "hpd-gpios", &value)) {
571 enum of_gpio_flags hpd_gpio_flags;
573 - hdmi->hpd_gpio = of_get_named_gpio_flags(dev->of_node,
574 + vc4_hdmi->hpd_gpio = of_get_named_gpio_flags(dev->of_node,
577 - if (hdmi->hpd_gpio < 0) {
578 - ret = hdmi->hpd_gpio;
579 + if (vc4_hdmi->hpd_gpio < 0) {
580 + ret = vc4_hdmi->hpd_gpio;
581 goto err_unprepare_hsm;
584 - hdmi->hpd_active_low = hpd_gpio_flags & OF_GPIO_ACTIVE_LOW;
585 + vc4_hdmi->hpd_active_low = hpd_gpio_flags & OF_GPIO_ACTIVE_LOW;
589 + vc4->hdmi = vc4_hdmi;
591 /* HDMI core must be enabled. */
592 if (!(HD_READ(VC4_HD_M_CTL) & VC4_HD_M_ENABLE)) {
593 @@ -1331,21 +1332,21 @@ static int vc4_hdmi_bind(struct device *
594 DRM_MODE_ENCODER_TMDS, NULL);
595 drm_encoder_helper_add(encoder, &vc4_hdmi_encoder_helper_funcs);
597 - ret = vc4_hdmi_connector_init(drm, hdmi);
598 + ret = vc4_hdmi_connector_init(drm, vc4_hdmi);
600 goto err_destroy_encoder;
602 #ifdef CONFIG_DRM_VC4_HDMI_CEC
603 - hdmi->cec_adap = cec_allocate_adapter(&vc4_hdmi_cec_adap_ops,
604 + vc4_hdmi->cec_adap = cec_allocate_adapter(&vc4_hdmi_cec_adap_ops,
607 CEC_CAP_CONNECTOR_INFO, 1);
608 - ret = PTR_ERR_OR_ZERO(hdmi->cec_adap);
609 + ret = PTR_ERR_OR_ZERO(vc4_hdmi->cec_adap);
611 goto err_destroy_conn;
613 - cec_fill_conn_info_from_drm(&conn_info, &hdmi->connector.base);
614 - cec_s_conn_info(hdmi->cec_adap, &conn_info);
615 + cec_fill_conn_info_from_drm(&conn_info, &vc4_hdmi->connector.base);
616 + cec_s_conn_info(vc4_hdmi->cec_adap, &conn_info);
618 HDMI_WRITE(VC4_HDMI_CPU_MASK_SET, 0xffffffff);
619 value = HDMI_READ(VC4_HDMI_CEC_CNTRL_1);
620 @@ -1364,32 +1365,32 @@ static int vc4_hdmi_bind(struct device *
621 "vc4 hdmi cec", vc4);
623 goto err_delete_cec_adap;
624 - ret = cec_register_adapter(hdmi->cec_adap, dev);
625 + ret = cec_register_adapter(vc4_hdmi->cec_adap, dev);
627 goto err_delete_cec_adap;
630 - ret = vc4_hdmi_audio_init(hdmi);
631 + ret = vc4_hdmi_audio_init(vc4_hdmi);
633 goto err_destroy_encoder;
635 - vc4_debugfs_add_file(drm, "hdmi_regs", vc4_hdmi_debugfs_regs, hdmi);
636 + vc4_debugfs_add_file(drm, "hdmi_regs", vc4_hdmi_debugfs_regs, vc4_hdmi);
640 #ifdef CONFIG_DRM_VC4_HDMI_CEC
642 - cec_delete_adapter(hdmi->cec_adap);
643 + cec_delete_adapter(vc4_hdmi->cec_adap);
645 - vc4_hdmi_connector_destroy(&hdmi->connector.base);
646 + vc4_hdmi_connector_destroy(&vc4_hdmi->connector.base);
649 vc4_hdmi_encoder_destroy(encoder);
651 - clk_disable_unprepare(hdmi->hsm_clock);
652 + clk_disable_unprepare(vc4_hdmi->hsm_clock);
653 pm_runtime_disable(dev);
655 - put_device(&hdmi->ddc->dev);
656 + put_device(&vc4_hdmi->ddc->dev);
660 @@ -1399,16 +1400,16 @@ static void vc4_hdmi_unbind(struct devic
662 struct drm_device *drm = dev_get_drvdata(master);
663 struct vc4_dev *vc4 = drm->dev_private;
664 - struct vc4_hdmi *hdmi = vc4->hdmi;
665 + struct vc4_hdmi *vc4_hdmi = vc4->hdmi;
667 - cec_unregister_adapter(hdmi->cec_adap);
668 - vc4_hdmi_connector_destroy(&hdmi->connector.base);
669 - vc4_hdmi_encoder_destroy(&hdmi->encoder.base.base);
670 + cec_unregister_adapter(vc4_hdmi->cec_adap);
671 + vc4_hdmi_connector_destroy(&vc4_hdmi->connector.base);
672 + vc4_hdmi_encoder_destroy(&vc4_hdmi->encoder.base.base);
674 - clk_disable_unprepare(hdmi->hsm_clock);
675 + clk_disable_unprepare(vc4_hdmi->hsm_clock);
676 pm_runtime_disable(dev);
678 - put_device(&hdmi->ddc->dev);
679 + put_device(&vc4_hdmi->ddc->dev);