1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2015 Broadcom
4 * Copyright (c) 2014 The Linux Foundation. All rights reserved.
5 * Copyright (C) 2013 Red Hat
6 * Author: Rob Clark <robdclark@gmail.com>
10 * DOC: VC4 Falcon HDMI module
12 * The HDMI core has a state machine and a PHY. On BCM2835, most of
13 * the unit operates off of the HSM clock from CPRMAN. It also
14 * internally uses the PLLH_PIX clock for the PHY.
16 * HDMI infoframes are kept within a small packet ram, where each
17 * packet can be individually enabled for including in a frame.
19 * HDMI audio is implemented entirely within the HDMI IP block. A
20 * register in the HDMI encoder takes SPDIF frames from the DMA engine
21 * and transfers them over an internal MAI (multi-channel audio
22 * interconnect) bus to the encoder side for insertion into the video
25 * The driver's HDMI encoder does not yet support power management.
26 * The HDMI encoder's power domain and the HSM/pixel clocks are kept
27 * continuously running, and only the HDMI logic and packet ram are
28 * powered off/on at disable/enable time.
30 * The driver does not yet support CEC control, though the HDMI
31 * encoder block has CEC support.
34 #include <drm/drm_atomic_helper.h>
35 #include <drm/drm_edid.h>
36 #include <drm/drm_probe_helper.h>
37 #include <drm/drm_simple_kms_helper.h>
38 #include <drm/drm_scdc_helper.h>
39 #include <linux/clk.h>
40 #include <linux/component.h>
41 #include <linux/i2c.h>
42 #include <linux/of_address.h>
43 #include <linux/of_gpio.h>
44 #include <linux/of_platform.h>
45 #include <linux/pm_runtime.h>
46 #include <linux/rational.h>
47 #include <linux/reset.h>
48 #include <sound/dmaengine_pcm.h>
49 #include <sound/hdmi-codec.h>
50 #include <sound/pcm_drm_eld.h>
51 #include <sound/pcm_params.h>
52 #include <sound/soc.h>
53 #include "media/cec.h"
56 #include "vc4_hdmi_regs.h"
59 #define VC5_HDMI_HORZA_HFP_SHIFT 16
60 #define VC5_HDMI_HORZA_HFP_MASK VC4_MASK(28, 16)
61 #define VC5_HDMI_HORZA_VPOS BIT(15)
62 #define VC5_HDMI_HORZA_HPOS BIT(14)
63 #define VC5_HDMI_HORZA_HAP_SHIFT 0
64 #define VC5_HDMI_HORZA_HAP_MASK VC4_MASK(13, 0)
66 #define VC5_HDMI_HORZB_HBP_SHIFT 16
67 #define VC5_HDMI_HORZB_HBP_MASK VC4_MASK(26, 16)
68 #define VC5_HDMI_HORZB_HSP_SHIFT 0
69 #define VC5_HDMI_HORZB_HSP_MASK VC4_MASK(10, 0)
71 #define VC5_HDMI_VERTA_VSP_SHIFT 24
72 #define VC5_HDMI_VERTA_VSP_MASK VC4_MASK(28, 24)
73 #define VC5_HDMI_VERTA_VFP_SHIFT 16
74 #define VC5_HDMI_VERTA_VFP_MASK VC4_MASK(22, 16)
75 #define VC5_HDMI_VERTA_VAL_SHIFT 0
76 #define VC5_HDMI_VERTA_VAL_MASK VC4_MASK(12, 0)
78 #define VC5_HDMI_VERTB_VSPO_SHIFT 16
79 #define VC5_HDMI_VERTB_VSPO_MASK VC4_MASK(29, 16)
81 #define VC5_HDMI_SCRAMBLER_CTL_ENABLE BIT(0)
83 #define VC5_HDMI_DEEP_COLOR_CONFIG_1_INIT_PACK_PHASE_SHIFT 8
84 #define VC5_HDMI_DEEP_COLOR_CONFIG_1_INIT_PACK_PHASE_MASK VC4_MASK(10, 8)
86 #define VC5_HDMI_DEEP_COLOR_CONFIG_1_COLOR_DEPTH_SHIFT 0
87 #define VC5_HDMI_DEEP_COLOR_CONFIG_1_COLOR_DEPTH_MASK VC4_MASK(3, 0)
89 #define VC5_HDMI_GCP_CONFIG_GCP_ENABLE BIT(31)
91 #define VC5_HDMI_GCP_WORD_1_GCP_SUBPACKET_BYTE_1_SHIFT 8
92 #define VC5_HDMI_GCP_WORD_1_GCP_SUBPACKET_BYTE_1_MASK VC4_MASK(15, 8)
94 # define VC4_HD_M_SW_RST BIT(2)
95 # define VC4_HD_M_ENABLE BIT(0)
97 #define HSM_MIN_CLOCK_FREQ 120000000
98 #define CEC_CLOCK_FREQ 40000
100 #define HDMI_14_MAX_TMDS_CLK (340 * 1000 * 1000)
102 static bool vc4_hdmi_mode_needs_scrambling(const struct drm_display_mode *mode)
104 return (mode->clock * 1000) > HDMI_14_MAX_TMDS_CLK;
107 static int vc4_hdmi_debugfs_regs(struct seq_file *m, void *unused)
109 struct drm_info_node *node = (struct drm_info_node *)m->private;
110 struct vc4_hdmi *vc4_hdmi = node->info_ent->data;
111 struct drm_printer p = drm_seq_file_printer(m);
113 drm_print_regset32(&p, &vc4_hdmi->hdmi_regset);
114 drm_print_regset32(&p, &vc4_hdmi->hd_regset);
119 static void vc4_hdmi_reset(struct vc4_hdmi *vc4_hdmi)
123 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
125 HDMI_WRITE(HDMI_M_CTL, VC4_HD_M_SW_RST);
127 HDMI_WRITE(HDMI_M_CTL, 0);
129 HDMI_WRITE(HDMI_M_CTL, VC4_HD_M_ENABLE);
131 HDMI_WRITE(HDMI_SW_RESET_CONTROL,
132 VC4_HDMI_SW_RESET_HDMI |
133 VC4_HDMI_SW_RESET_FORMAT_DETECT);
135 HDMI_WRITE(HDMI_SW_RESET_CONTROL, 0);
137 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
140 static void vc5_hdmi_reset(struct vc4_hdmi *vc4_hdmi)
144 reset_control_reset(vc4_hdmi->reset);
146 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
148 HDMI_WRITE(HDMI_DVP_CTL, 0);
150 HDMI_WRITE(HDMI_CLOCK_STOP,
151 HDMI_READ(HDMI_CLOCK_STOP) | VC4_DVP_HT_CLOCK_STOP_PIXEL);
153 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
156 #ifdef CONFIG_DRM_VC4_HDMI_CEC
157 static void vc4_hdmi_cec_update_clk_div(struct vc4_hdmi *vc4_hdmi)
159 unsigned long cec_rate = clk_get_rate(vc4_hdmi->cec_clock);
164 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
166 value = HDMI_READ(HDMI_CEC_CNTRL_1);
167 value &= ~VC4_HDMI_CEC_DIV_CLK_CNT_MASK;
170 * Set the clock divider: the hsm_clock rate and this divider
171 * setting will give a 40 kHz CEC clock.
173 clk_cnt = cec_rate / CEC_CLOCK_FREQ;
174 value |= clk_cnt << VC4_HDMI_CEC_DIV_CLK_CNT_SHIFT;
175 HDMI_WRITE(HDMI_CEC_CNTRL_1, value);
177 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
180 static void vc4_hdmi_cec_update_clk_div(struct vc4_hdmi *vc4_hdmi) {}
183 static void vc4_hdmi_enable_scrambling(struct drm_encoder *encoder);
185 static enum drm_connector_status
186 vc4_hdmi_connector_detect(struct drm_connector *connector, bool force)
188 struct vc4_hdmi *vc4_hdmi = connector_to_vc4_hdmi(connector);
189 bool connected = false;
191 mutex_lock(&vc4_hdmi->mutex);
193 WARN_ON(pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev));
195 if (vc4_hdmi->hpd_gpio) {
196 if (gpiod_get_value_cansleep(vc4_hdmi->hpd_gpio))
199 if (vc4_hdmi->variant->hp_detect &&
200 vc4_hdmi->variant->hp_detect(vc4_hdmi))
205 if (connector->status != connector_status_connected) {
206 struct edid *edid = drm_get_edid(connector, vc4_hdmi->ddc);
209 cec_s_phys_addr_from_edid(vc4_hdmi->cec_adap, edid);
210 vc4_hdmi->encoder.hdmi_monitor = drm_detect_hdmi_monitor(edid);
215 vc4_hdmi_enable_scrambling(&vc4_hdmi->encoder.base.base);
216 pm_runtime_put(&vc4_hdmi->pdev->dev);
217 mutex_unlock(&vc4_hdmi->mutex);
218 return connector_status_connected;
221 cec_phys_addr_invalidate(vc4_hdmi->cec_adap);
222 pm_runtime_put(&vc4_hdmi->pdev->dev);
223 mutex_unlock(&vc4_hdmi->mutex);
224 return connector_status_disconnected;
227 static void vc4_hdmi_connector_destroy(struct drm_connector *connector)
229 drm_connector_unregister(connector);
230 drm_connector_cleanup(connector);
233 static int vc4_hdmi_connector_get_modes(struct drm_connector *connector)
235 struct vc4_hdmi *vc4_hdmi = connector_to_vc4_hdmi(connector);
236 struct vc4_hdmi_encoder *vc4_encoder = &vc4_hdmi->encoder;
240 mutex_lock(&vc4_hdmi->mutex);
242 edid = drm_get_edid(connector, vc4_hdmi->ddc);
243 cec_s_phys_addr_from_edid(vc4_hdmi->cec_adap, edid);
249 vc4_encoder->hdmi_monitor = drm_detect_hdmi_monitor(edid);
251 drm_connector_update_edid_property(connector, edid);
252 ret = drm_add_edid_modes(connector, edid);
255 if (vc4_hdmi->disable_4kp60) {
256 struct drm_device *drm = connector->dev;
257 struct drm_display_mode *mode;
259 list_for_each_entry(mode, &connector->probed_modes, head) {
260 if (vc4_hdmi_mode_needs_scrambling(mode)) {
261 drm_warn_once(drm, "The core clock cannot reach frequencies high enough to support 4k @ 60Hz.");
262 drm_warn_once(drm, "Please change your config.txt file to add hdmi_enable_4kp60.");
268 mutex_unlock(&vc4_hdmi->mutex);
273 static int vc4_hdmi_connector_atomic_check(struct drm_connector *connector,
274 struct drm_atomic_state *state)
276 struct drm_connector_state *old_state =
277 drm_atomic_get_old_connector_state(state, connector);
278 struct drm_connector_state *new_state =
279 drm_atomic_get_new_connector_state(state, connector);
280 struct drm_crtc *crtc = new_state->crtc;
285 if (old_state->colorspace != new_state->colorspace ||
286 !drm_connector_atomic_hdr_metadata_equal(old_state, new_state)) {
287 struct drm_crtc_state *crtc_state;
289 crtc_state = drm_atomic_get_crtc_state(state, crtc);
290 if (IS_ERR(crtc_state))
291 return PTR_ERR(crtc_state);
293 crtc_state->mode_changed = true;
299 static void vc4_hdmi_connector_reset(struct drm_connector *connector)
301 struct vc4_hdmi_connector_state *old_state =
302 conn_state_to_vc4_hdmi_conn_state(connector->state);
303 struct vc4_hdmi_connector_state *new_state =
304 kzalloc(sizeof(*new_state), GFP_KERNEL);
306 if (connector->state)
307 __drm_atomic_helper_connector_destroy_state(connector->state);
310 __drm_atomic_helper_connector_reset(connector, &new_state->base);
315 new_state->base.max_bpc = 8;
316 new_state->base.max_requested_bpc = 8;
317 drm_atomic_helper_connector_tv_reset(connector);
320 static struct drm_connector_state *
321 vc4_hdmi_connector_duplicate_state(struct drm_connector *connector)
323 struct drm_connector_state *conn_state = connector->state;
324 struct vc4_hdmi_connector_state *vc4_state = conn_state_to_vc4_hdmi_conn_state(conn_state);
325 struct vc4_hdmi_connector_state *new_state;
327 new_state = kzalloc(sizeof(*new_state), GFP_KERNEL);
331 new_state->pixel_rate = vc4_state->pixel_rate;
332 __drm_atomic_helper_connector_duplicate_state(connector, &new_state->base);
334 return &new_state->base;
337 static const struct drm_connector_funcs vc4_hdmi_connector_funcs = {
338 .detect = vc4_hdmi_connector_detect,
339 .fill_modes = drm_helper_probe_single_connector_modes,
340 .destroy = vc4_hdmi_connector_destroy,
341 .reset = vc4_hdmi_connector_reset,
342 .atomic_duplicate_state = vc4_hdmi_connector_duplicate_state,
343 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
346 static const struct drm_connector_helper_funcs vc4_hdmi_connector_helper_funcs = {
347 .get_modes = vc4_hdmi_connector_get_modes,
348 .atomic_check = vc4_hdmi_connector_atomic_check,
351 static int vc4_hdmi_connector_init(struct drm_device *dev,
352 struct vc4_hdmi *vc4_hdmi)
354 struct drm_connector *connector = &vc4_hdmi->connector;
355 struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
358 drm_connector_init_with_ddc(dev, connector,
359 &vc4_hdmi_connector_funcs,
360 DRM_MODE_CONNECTOR_HDMIA,
362 drm_connector_helper_add(connector, &vc4_hdmi_connector_helper_funcs);
365 * Some of the properties below require access to state, like bpc.
366 * Allocate some default initial connector state with our reset helper.
368 if (connector->funcs->reset)
369 connector->funcs->reset(connector);
371 /* Create and attach TV margin props to this connector. */
372 ret = drm_mode_create_tv_margin_properties(dev);
376 ret = drm_mode_create_hdmi_colorspace_property(connector);
380 drm_connector_attach_colorspace_property(connector);
381 drm_connector_attach_tv_margin_properties(connector);
382 drm_connector_attach_max_bpc_property(connector, 8, 12);
384 connector->polled = (DRM_CONNECTOR_POLL_CONNECT |
385 DRM_CONNECTOR_POLL_DISCONNECT);
387 connector->interlace_allowed = 1;
388 connector->doublescan_allowed = 0;
390 if (vc4_hdmi->variant->supports_hdr)
391 drm_connector_attach_hdr_output_metadata_property(connector);
393 drm_connector_attach_encoder(connector, encoder);
398 static int vc4_hdmi_stop_packet(struct drm_encoder *encoder,
399 enum hdmi_infoframe_type type,
402 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
403 u32 packet_id = type - 0x80;
406 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
407 HDMI_WRITE(HDMI_RAM_PACKET_CONFIG,
408 HDMI_READ(HDMI_RAM_PACKET_CONFIG) & ~BIT(packet_id));
409 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
414 return wait_for(!(HDMI_READ(HDMI_RAM_PACKET_STATUS) &
415 BIT(packet_id)), 100);
418 static void vc4_hdmi_write_infoframe(struct drm_encoder *encoder,
419 union hdmi_infoframe *frame)
421 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
422 u32 packet_id = frame->any.type - 0x80;
423 const struct vc4_hdmi_register *ram_packet_start =
424 &vc4_hdmi->variant->registers[HDMI_RAM_PACKET_START];
425 u32 packet_reg = ram_packet_start->offset + VC4_HDMI_PACKET_STRIDE * packet_id;
426 void __iomem *base = __vc4_hdmi_get_field_base(vc4_hdmi,
427 ram_packet_start->reg);
428 uint8_t buffer[VC4_HDMI_PACKET_STRIDE];
433 WARN_ONCE(!(HDMI_READ(HDMI_RAM_PACKET_CONFIG) &
434 VC4_HDMI_RAM_PACKET_ENABLE),
435 "Packet RAM has to be on to store the packet.");
437 len = hdmi_infoframe_pack(frame, buffer, sizeof(buffer));
441 ret = vc4_hdmi_stop_packet(encoder, frame->any.type, true);
443 DRM_ERROR("Failed to wait for infoframe to go idle: %d\n", ret);
447 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
449 for (i = 0; i < len; i += 7) {
450 writel(buffer[i + 0] << 0 |
456 writel(buffer[i + 3] << 0 |
458 buffer[i + 5] << 16 |
464 HDMI_WRITE(HDMI_RAM_PACKET_CONFIG,
465 HDMI_READ(HDMI_RAM_PACKET_CONFIG) | BIT(packet_id));
467 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
469 ret = wait_for((HDMI_READ(HDMI_RAM_PACKET_STATUS) &
470 BIT(packet_id)), 100);
472 DRM_ERROR("Failed to wait for infoframe to start: %d\n", ret);
475 static void vc4_hdmi_set_avi_infoframe(struct drm_encoder *encoder)
477 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
478 struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
479 struct drm_connector *connector = &vc4_hdmi->connector;
480 struct drm_connector_state *cstate = connector->state;
481 const struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
482 union hdmi_infoframe frame;
485 lockdep_assert_held(&vc4_hdmi->mutex);
487 ret = drm_hdmi_avi_infoframe_from_display_mode(&frame.avi,
490 DRM_ERROR("couldn't fill AVI infoframe\n");
494 drm_hdmi_avi_infoframe_quant_range(&frame.avi,
496 vc4_encoder->limited_rgb_range ?
497 HDMI_QUANTIZATION_RANGE_LIMITED :
498 HDMI_QUANTIZATION_RANGE_FULL);
499 drm_hdmi_avi_infoframe_colorspace(&frame.avi, cstate);
500 drm_hdmi_avi_infoframe_bars(&frame.avi, cstate);
502 vc4_hdmi_write_infoframe(encoder, &frame);
505 static void vc4_hdmi_set_spd_infoframe(struct drm_encoder *encoder)
507 union hdmi_infoframe frame;
510 ret = hdmi_spd_infoframe_init(&frame.spd, "Broadcom", "Videocore");
512 DRM_ERROR("couldn't fill SPD infoframe\n");
516 frame.spd.sdi = HDMI_SPD_SDI_PC;
518 vc4_hdmi_write_infoframe(encoder, &frame);
521 static void vc4_hdmi_set_audio_infoframe(struct drm_encoder *encoder)
523 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
524 struct hdmi_audio_infoframe *audio = &vc4_hdmi->audio.infoframe;
525 union hdmi_infoframe frame;
527 memcpy(&frame.audio, audio, sizeof(*audio));
528 vc4_hdmi_write_infoframe(encoder, &frame);
531 static void vc4_hdmi_set_hdr_infoframe(struct drm_encoder *encoder)
533 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
534 struct drm_connector *connector = &vc4_hdmi->connector;
535 struct drm_connector_state *conn_state = connector->state;
536 union hdmi_infoframe frame;
538 lockdep_assert_held(&vc4_hdmi->mutex);
540 if (!vc4_hdmi->variant->supports_hdr)
543 if (!conn_state->hdr_output_metadata)
546 if (drm_hdmi_infoframe_set_hdr_metadata(&frame.drm, conn_state))
549 vc4_hdmi_write_infoframe(encoder, &frame);
552 static void vc4_hdmi_set_infoframes(struct drm_encoder *encoder)
554 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
556 lockdep_assert_held(&vc4_hdmi->mutex);
558 vc4_hdmi_set_avi_infoframe(encoder);
559 vc4_hdmi_set_spd_infoframe(encoder);
561 * If audio was streaming, then we need to reenabled the audio
562 * infoframe here during encoder_enable.
564 if (vc4_hdmi->audio.streaming)
565 vc4_hdmi_set_audio_infoframe(encoder);
567 vc4_hdmi_set_hdr_infoframe(encoder);
570 static bool vc4_hdmi_supports_scrambling(struct drm_encoder *encoder,
571 struct drm_display_mode *mode)
573 struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
574 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
575 struct drm_display_info *display = &vc4_hdmi->connector.display_info;
577 lockdep_assert_held(&vc4_hdmi->mutex);
579 if (!vc4_encoder->hdmi_monitor)
582 if (!display->hdmi.scdc.supported ||
583 !display->hdmi.scdc.scrambling.supported)
589 #define SCRAMBLING_POLLING_DELAY_MS 1000
591 static void vc4_hdmi_enable_scrambling(struct drm_encoder *encoder)
593 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
594 struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
597 lockdep_assert_held(&vc4_hdmi->mutex);
599 if (!vc4_hdmi_supports_scrambling(encoder, mode))
602 if (!vc4_hdmi_mode_needs_scrambling(mode))
605 drm_scdc_set_high_tmds_clock_ratio(vc4_hdmi->ddc, true);
606 drm_scdc_set_scrambling(vc4_hdmi->ddc, true);
608 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
609 HDMI_WRITE(HDMI_SCRAMBLER_CTL, HDMI_READ(HDMI_SCRAMBLER_CTL) |
610 VC5_HDMI_SCRAMBLER_CTL_ENABLE);
611 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
613 vc4_hdmi->scdc_enabled = true;
615 queue_delayed_work(system_wq, &vc4_hdmi->scrambling_work,
616 msecs_to_jiffies(SCRAMBLING_POLLING_DELAY_MS));
619 static void vc4_hdmi_disable_scrambling(struct drm_encoder *encoder)
621 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
624 lockdep_assert_held(&vc4_hdmi->mutex);
626 if (!vc4_hdmi->scdc_enabled)
629 vc4_hdmi->scdc_enabled = false;
631 if (delayed_work_pending(&vc4_hdmi->scrambling_work))
632 cancel_delayed_work_sync(&vc4_hdmi->scrambling_work);
634 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
635 HDMI_WRITE(HDMI_SCRAMBLER_CTL, HDMI_READ(HDMI_SCRAMBLER_CTL) &
636 ~VC5_HDMI_SCRAMBLER_CTL_ENABLE);
637 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
639 drm_scdc_set_scrambling(vc4_hdmi->ddc, false);
640 drm_scdc_set_high_tmds_clock_ratio(vc4_hdmi->ddc, false);
643 static void vc4_hdmi_scrambling_wq(struct work_struct *work)
645 struct vc4_hdmi *vc4_hdmi = container_of(to_delayed_work(work),
649 if (drm_scdc_get_scrambling_status(vc4_hdmi->ddc))
652 drm_scdc_set_high_tmds_clock_ratio(vc4_hdmi->ddc, true);
653 drm_scdc_set_scrambling(vc4_hdmi->ddc, true);
655 queue_delayed_work(system_wq, &vc4_hdmi->scrambling_work,
656 msecs_to_jiffies(SCRAMBLING_POLLING_DELAY_MS));
659 static void vc4_hdmi_encoder_post_crtc_disable(struct drm_encoder *encoder,
660 struct drm_atomic_state *state)
662 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
665 mutex_lock(&vc4_hdmi->mutex);
667 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
669 HDMI_WRITE(HDMI_RAM_PACKET_CONFIG, 0);
671 HDMI_WRITE(HDMI_VID_CTL, HDMI_READ(HDMI_VID_CTL) | VC4_HD_VID_CTL_CLRRGB);
673 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
677 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
678 HDMI_WRITE(HDMI_VID_CTL,
679 HDMI_READ(HDMI_VID_CTL) & ~VC4_HD_VID_CTL_ENABLE);
680 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
682 vc4_hdmi_disable_scrambling(encoder);
684 mutex_unlock(&vc4_hdmi->mutex);
687 static void vc4_hdmi_encoder_post_crtc_powerdown(struct drm_encoder *encoder,
688 struct drm_atomic_state *state)
690 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
694 mutex_lock(&vc4_hdmi->mutex);
696 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
697 HDMI_WRITE(HDMI_VID_CTL,
698 HDMI_READ(HDMI_VID_CTL) | VC4_HD_VID_CTL_BLANKPIX);
699 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
701 if (vc4_hdmi->variant->phy_disable)
702 vc4_hdmi->variant->phy_disable(vc4_hdmi);
704 clk_disable_unprepare(vc4_hdmi->pixel_bvb_clock);
705 clk_disable_unprepare(vc4_hdmi->pixel_clock);
707 ret = pm_runtime_put(&vc4_hdmi->pdev->dev);
709 DRM_ERROR("Failed to release power domain: %d\n", ret);
711 mutex_unlock(&vc4_hdmi->mutex);
714 static void vc4_hdmi_encoder_disable(struct drm_encoder *encoder)
716 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
718 mutex_lock(&vc4_hdmi->mutex);
719 vc4_hdmi->output_enabled = false;
720 mutex_unlock(&vc4_hdmi->mutex);
723 static void vc4_hdmi_csc_setup(struct vc4_hdmi *vc4_hdmi, bool enable)
728 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
730 csc_ctl = VC4_SET_FIELD(VC4_HD_CSC_CTL_ORDER_BGR,
731 VC4_HD_CSC_CTL_ORDER);
734 /* CEA VICs other than #1 requre limited range RGB
735 * output unless overridden by an AVI infoframe.
736 * Apply a colorspace conversion to squash 0-255 down
737 * to 16-235. The matrix here is:
744 csc_ctl |= VC4_HD_CSC_CTL_ENABLE;
745 csc_ctl |= VC4_HD_CSC_CTL_RGB2YCC;
746 csc_ctl |= VC4_SET_FIELD(VC4_HD_CSC_CTL_MODE_CUSTOM,
747 VC4_HD_CSC_CTL_MODE);
749 HDMI_WRITE(HDMI_CSC_12_11, (0x000 << 16) | 0x000);
750 HDMI_WRITE(HDMI_CSC_14_13, (0x100 << 16) | 0x6e0);
751 HDMI_WRITE(HDMI_CSC_22_21, (0x6e0 << 16) | 0x000);
752 HDMI_WRITE(HDMI_CSC_24_23, (0x100 << 16) | 0x000);
753 HDMI_WRITE(HDMI_CSC_32_31, (0x000 << 16) | 0x6e0);
754 HDMI_WRITE(HDMI_CSC_34_33, (0x100 << 16) | 0x000);
757 /* The RGB order applies even when CSC is disabled. */
758 HDMI_WRITE(HDMI_CSC_CTL, csc_ctl);
760 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
763 static void vc5_hdmi_csc_setup(struct vc4_hdmi *vc4_hdmi, bool enable)
768 csc_ctl = 0x07; /* RGB_CONVERT_MODE = custom matrix, || USE_RGB_TO_YCBCR */
770 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
773 /* CEA VICs other than #1 requre limited range RGB
774 * output unless overridden by an AVI infoframe.
775 * Apply a colorspace conversion to squash 0-255 down
776 * to 16-235. The matrix here is:
782 * Matrix is signed 2p13 fixed point, with signed 9p6 offsets
784 HDMI_WRITE(HDMI_CSC_12_11, (0x0000 << 16) | 0x1b80);
785 HDMI_WRITE(HDMI_CSC_14_13, (0x0400 << 16) | 0x0000);
786 HDMI_WRITE(HDMI_CSC_22_21, (0x1b80 << 16) | 0x0000);
787 HDMI_WRITE(HDMI_CSC_24_23, (0x0400 << 16) | 0x0000);
788 HDMI_WRITE(HDMI_CSC_32_31, (0x0000 << 16) | 0x0000);
789 HDMI_WRITE(HDMI_CSC_34_33, (0x0400 << 16) | 0x1b80);
791 /* Still use the matrix for full range, but make it unity.
792 * Matrix is signed 2p13 fixed point, with signed 9p6 offsets
794 HDMI_WRITE(HDMI_CSC_12_11, (0x0000 << 16) | 0x2000);
795 HDMI_WRITE(HDMI_CSC_14_13, (0x0000 << 16) | 0x0000);
796 HDMI_WRITE(HDMI_CSC_22_21, (0x2000 << 16) | 0x0000);
797 HDMI_WRITE(HDMI_CSC_24_23, (0x0000 << 16) | 0x0000);
798 HDMI_WRITE(HDMI_CSC_32_31, (0x0000 << 16) | 0x0000);
799 HDMI_WRITE(HDMI_CSC_34_33, (0x0000 << 16) | 0x2000);
802 HDMI_WRITE(HDMI_CSC_CTL, csc_ctl);
804 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
807 static void vc4_hdmi_set_timings(struct vc4_hdmi *vc4_hdmi,
808 struct drm_connector_state *state,
809 struct drm_display_mode *mode)
811 bool hsync_pos = mode->flags & DRM_MODE_FLAG_PHSYNC;
812 bool vsync_pos = mode->flags & DRM_MODE_FLAG_PVSYNC;
813 bool interlaced = mode->flags & DRM_MODE_FLAG_INTERLACE;
814 u32 pixel_rep = (mode->flags & DRM_MODE_FLAG_DBLCLK) ? 2 : 1;
815 u32 verta = (VC4_SET_FIELD(mode->crtc_vsync_end - mode->crtc_vsync_start,
816 VC4_HDMI_VERTA_VSP) |
817 VC4_SET_FIELD(mode->crtc_vsync_start - mode->crtc_vdisplay,
818 VC4_HDMI_VERTA_VFP) |
819 VC4_SET_FIELD(mode->crtc_vdisplay, VC4_HDMI_VERTA_VAL));
820 u32 vertb = (VC4_SET_FIELD(0, VC4_HDMI_VERTB_VSPO) |
821 VC4_SET_FIELD(mode->crtc_vtotal - mode->crtc_vsync_end,
822 VC4_HDMI_VERTB_VBP));
823 u32 vertb_even = (VC4_SET_FIELD(0, VC4_HDMI_VERTB_VSPO) |
824 VC4_SET_FIELD(mode->crtc_vtotal -
825 mode->crtc_vsync_end -
827 VC4_HDMI_VERTB_VBP));
830 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
832 HDMI_WRITE(HDMI_HORZA,
833 (vsync_pos ? VC4_HDMI_HORZA_VPOS : 0) |
834 (hsync_pos ? VC4_HDMI_HORZA_HPOS : 0) |
835 VC4_SET_FIELD(mode->hdisplay * pixel_rep,
836 VC4_HDMI_HORZA_HAP));
838 HDMI_WRITE(HDMI_HORZB,
839 VC4_SET_FIELD((mode->htotal -
840 mode->hsync_end) * pixel_rep,
841 VC4_HDMI_HORZB_HBP) |
842 VC4_SET_FIELD((mode->hsync_end -
843 mode->hsync_start) * pixel_rep,
844 VC4_HDMI_HORZB_HSP) |
845 VC4_SET_FIELD((mode->hsync_start -
846 mode->hdisplay) * pixel_rep,
847 VC4_HDMI_HORZB_HFP));
849 HDMI_WRITE(HDMI_VERTA0, verta);
850 HDMI_WRITE(HDMI_VERTA1, verta);
852 HDMI_WRITE(HDMI_VERTB0, vertb_even);
853 HDMI_WRITE(HDMI_VERTB1, vertb);
855 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
858 static void vc5_hdmi_set_timings(struct vc4_hdmi *vc4_hdmi,
859 struct drm_connector_state *state,
860 struct drm_display_mode *mode)
862 bool hsync_pos = mode->flags & DRM_MODE_FLAG_PHSYNC;
863 bool vsync_pos = mode->flags & DRM_MODE_FLAG_PVSYNC;
864 bool interlaced = mode->flags & DRM_MODE_FLAG_INTERLACE;
865 u32 pixel_rep = (mode->flags & DRM_MODE_FLAG_DBLCLK) ? 2 : 1;
866 u32 verta = (VC4_SET_FIELD(mode->crtc_vsync_end - mode->crtc_vsync_start,
867 VC5_HDMI_VERTA_VSP) |
868 VC4_SET_FIELD(mode->crtc_vsync_start - mode->crtc_vdisplay,
869 VC5_HDMI_VERTA_VFP) |
870 VC4_SET_FIELD(mode->crtc_vdisplay, VC5_HDMI_VERTA_VAL));
871 u32 vertb = (VC4_SET_FIELD(0, VC5_HDMI_VERTB_VSPO) |
872 VC4_SET_FIELD(mode->crtc_vtotal - mode->crtc_vsync_end,
873 VC4_HDMI_VERTB_VBP));
874 u32 vertb_even = (VC4_SET_FIELD(0, VC5_HDMI_VERTB_VSPO) |
875 VC4_SET_FIELD(mode->crtc_vtotal -
876 mode->crtc_vsync_end -
878 VC4_HDMI_VERTB_VBP));
884 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
886 HDMI_WRITE(HDMI_VEC_INTERFACE_XBAR, 0x354021);
887 HDMI_WRITE(HDMI_HORZA,
888 (vsync_pos ? VC5_HDMI_HORZA_VPOS : 0) |
889 (hsync_pos ? VC5_HDMI_HORZA_HPOS : 0) |
890 VC4_SET_FIELD(mode->hdisplay * pixel_rep,
891 VC5_HDMI_HORZA_HAP) |
892 VC4_SET_FIELD((mode->hsync_start -
893 mode->hdisplay) * pixel_rep,
894 VC5_HDMI_HORZA_HFP));
896 HDMI_WRITE(HDMI_HORZB,
897 VC4_SET_FIELD((mode->htotal -
898 mode->hsync_end) * pixel_rep,
899 VC5_HDMI_HORZB_HBP) |
900 VC4_SET_FIELD((mode->hsync_end -
901 mode->hsync_start) * pixel_rep,
902 VC5_HDMI_HORZB_HSP));
904 HDMI_WRITE(HDMI_VERTA0, verta);
905 HDMI_WRITE(HDMI_VERTA1, verta);
907 HDMI_WRITE(HDMI_VERTB0, vertb_even);
908 HDMI_WRITE(HDMI_VERTB1, vertb);
910 switch (state->max_bpc) {
926 reg = HDMI_READ(HDMI_DEEP_COLOR_CONFIG_1);
927 reg &= ~(VC5_HDMI_DEEP_COLOR_CONFIG_1_INIT_PACK_PHASE_MASK |
928 VC5_HDMI_DEEP_COLOR_CONFIG_1_COLOR_DEPTH_MASK);
929 reg |= VC4_SET_FIELD(2, VC5_HDMI_DEEP_COLOR_CONFIG_1_INIT_PACK_PHASE) |
930 VC4_SET_FIELD(gcp, VC5_HDMI_DEEP_COLOR_CONFIG_1_COLOR_DEPTH);
931 HDMI_WRITE(HDMI_DEEP_COLOR_CONFIG_1, reg);
933 reg = HDMI_READ(HDMI_GCP_WORD_1);
934 reg &= ~VC5_HDMI_GCP_WORD_1_GCP_SUBPACKET_BYTE_1_MASK;
935 reg |= VC4_SET_FIELD(gcp, VC5_HDMI_GCP_WORD_1_GCP_SUBPACKET_BYTE_1);
936 HDMI_WRITE(HDMI_GCP_WORD_1, reg);
938 reg = HDMI_READ(HDMI_GCP_CONFIG);
939 reg &= ~VC5_HDMI_GCP_CONFIG_GCP_ENABLE;
940 reg |= gcp_en ? VC5_HDMI_GCP_CONFIG_GCP_ENABLE : 0;
941 HDMI_WRITE(HDMI_GCP_CONFIG, reg);
943 HDMI_WRITE(HDMI_CLOCK_STOP, 0);
945 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
948 static void vc4_hdmi_recenter_fifo(struct vc4_hdmi *vc4_hdmi)
954 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
956 drift = HDMI_READ(HDMI_FIFO_CTL);
957 drift &= VC4_HDMI_FIFO_VALID_WRITE_MASK;
959 HDMI_WRITE(HDMI_FIFO_CTL,
960 drift & ~VC4_HDMI_FIFO_CTL_RECENTER);
961 HDMI_WRITE(HDMI_FIFO_CTL,
962 drift | VC4_HDMI_FIFO_CTL_RECENTER);
964 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
966 usleep_range(1000, 1100);
968 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
970 HDMI_WRITE(HDMI_FIFO_CTL,
971 drift & ~VC4_HDMI_FIFO_CTL_RECENTER);
972 HDMI_WRITE(HDMI_FIFO_CTL,
973 drift | VC4_HDMI_FIFO_CTL_RECENTER);
975 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
977 ret = wait_for(HDMI_READ(HDMI_FIFO_CTL) &
978 VC4_HDMI_FIFO_CTL_RECENTER_DONE, 1);
979 WARN_ONCE(ret, "Timeout waiting for "
980 "VC4_HDMI_FIFO_CTL_RECENTER_DONE");
983 static struct drm_connector_state *
984 vc4_hdmi_encoder_get_connector_state(struct drm_encoder *encoder,
985 struct drm_atomic_state *state)
987 struct drm_connector_state *conn_state;
988 struct drm_connector *connector;
991 for_each_new_connector_in_state(state, connector, conn_state, i) {
992 if (conn_state->best_encoder == encoder)
999 static void vc4_hdmi_encoder_pre_crtc_configure(struct drm_encoder *encoder,
1000 struct drm_atomic_state *state)
1002 struct drm_connector_state *conn_state =
1003 vc4_hdmi_encoder_get_connector_state(encoder, state);
1004 struct vc4_hdmi_connector_state *vc4_conn_state =
1005 conn_state_to_vc4_hdmi_conn_state(conn_state);
1006 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1007 struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
1008 unsigned long pixel_rate = vc4_conn_state->pixel_rate;
1009 unsigned long bvb_rate, hsm_rate;
1010 unsigned long flags;
1013 mutex_lock(&vc4_hdmi->mutex);
1016 * As stated in RPi's vc4 firmware "HDMI state machine (HSM) clock must
1017 * be faster than pixel clock, infinitesimally faster, tested in
1018 * simulation. Otherwise, exact value is unimportant for HDMI
1019 * operation." This conflicts with bcm2835's vc4 documentation, which
1020 * states HSM's clock has to be at least 108% of the pixel clock.
1022 * Real life tests reveal that vc4's firmware statement holds up, and
1023 * users are able to use pixel clocks closer to HSM's, namely for
1024 * 1920x1200@60Hz. So it was decided to have leave a 1% margin between
1025 * both clocks. Which, for RPi0-3 implies a maximum pixel clock of
1028 * Additionally, the AXI clock needs to be at least 25% of
1029 * pixel clock, but HSM ends up being the limiting factor.
1031 hsm_rate = max_t(unsigned long, 120000000, (pixel_rate / 100) * 101);
1032 ret = clk_set_min_rate(vc4_hdmi->hsm_clock, hsm_rate);
1034 DRM_ERROR("Failed to set HSM clock rate: %d\n", ret);
1038 ret = pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev);
1040 DRM_ERROR("Failed to retain power domain: %d\n", ret);
1044 ret = clk_set_rate(vc4_hdmi->pixel_clock, pixel_rate);
1046 DRM_ERROR("Failed to set pixel clock rate: %d\n", ret);
1047 goto err_put_runtime_pm;
1050 ret = clk_prepare_enable(vc4_hdmi->pixel_clock);
1052 DRM_ERROR("Failed to turn on pixel clock: %d\n", ret);
1053 goto err_put_runtime_pm;
1057 vc4_hdmi_cec_update_clk_div(vc4_hdmi);
1059 if (pixel_rate > 297000000)
1060 bvb_rate = 300000000;
1061 else if (pixel_rate > 148500000)
1062 bvb_rate = 150000000;
1064 bvb_rate = 75000000;
1066 ret = clk_set_min_rate(vc4_hdmi->pixel_bvb_clock, bvb_rate);
1068 DRM_ERROR("Failed to set pixel bvb clock rate: %d\n", ret);
1069 goto err_disable_pixel_clock;
1072 ret = clk_prepare_enable(vc4_hdmi->pixel_bvb_clock);
1074 DRM_ERROR("Failed to turn on pixel bvb clock: %d\n", ret);
1075 goto err_disable_pixel_clock;
1078 if (vc4_hdmi->variant->phy_init)
1079 vc4_hdmi->variant->phy_init(vc4_hdmi, vc4_conn_state);
1081 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1083 HDMI_WRITE(HDMI_SCHEDULER_CONTROL,
1084 HDMI_READ(HDMI_SCHEDULER_CONTROL) |
1085 VC4_HDMI_SCHEDULER_CONTROL_MANUAL_FORMAT |
1086 VC4_HDMI_SCHEDULER_CONTROL_IGNORE_VSYNC_PREDICTS);
1088 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1090 if (vc4_hdmi->variant->set_timings)
1091 vc4_hdmi->variant->set_timings(vc4_hdmi, conn_state, mode);
1093 mutex_unlock(&vc4_hdmi->mutex);
1097 err_disable_pixel_clock:
1098 clk_disable_unprepare(vc4_hdmi->pixel_clock);
1100 pm_runtime_put(&vc4_hdmi->pdev->dev);
1102 mutex_unlock(&vc4_hdmi->mutex);
1106 static void vc4_hdmi_encoder_pre_crtc_enable(struct drm_encoder *encoder,
1107 struct drm_atomic_state *state)
1109 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1110 struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
1111 struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
1112 unsigned long flags;
1114 mutex_lock(&vc4_hdmi->mutex);
1116 if (vc4_encoder->hdmi_monitor &&
1117 drm_default_rgb_quant_range(mode) == HDMI_QUANTIZATION_RANGE_LIMITED) {
1118 if (vc4_hdmi->variant->csc_setup)
1119 vc4_hdmi->variant->csc_setup(vc4_hdmi, true);
1121 vc4_encoder->limited_rgb_range = true;
1123 if (vc4_hdmi->variant->csc_setup)
1124 vc4_hdmi->variant->csc_setup(vc4_hdmi, false);
1126 vc4_encoder->limited_rgb_range = false;
1129 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1130 HDMI_WRITE(HDMI_FIFO_CTL, VC4_HDMI_FIFO_CTL_MASTER_SLAVE_N);
1131 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1133 mutex_unlock(&vc4_hdmi->mutex);
1136 static void vc4_hdmi_encoder_post_crtc_enable(struct drm_encoder *encoder,
1137 struct drm_atomic_state *state)
1139 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1140 struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
1141 struct vc4_hdmi_encoder *vc4_encoder = to_vc4_hdmi_encoder(encoder);
1142 bool hsync_pos = mode->flags & DRM_MODE_FLAG_PHSYNC;
1143 bool vsync_pos = mode->flags & DRM_MODE_FLAG_PVSYNC;
1144 unsigned long flags;
1147 mutex_lock(&vc4_hdmi->mutex);
1149 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1151 HDMI_WRITE(HDMI_VID_CTL,
1152 VC4_HD_VID_CTL_ENABLE |
1153 VC4_HD_VID_CTL_CLRRGB |
1154 VC4_HD_VID_CTL_UNDERFLOW_ENABLE |
1155 VC4_HD_VID_CTL_FRAME_COUNTER_RESET |
1156 (vsync_pos ? 0 : VC4_HD_VID_CTL_VSYNC_LOW) |
1157 (hsync_pos ? 0 : VC4_HD_VID_CTL_HSYNC_LOW));
1159 HDMI_WRITE(HDMI_VID_CTL,
1160 HDMI_READ(HDMI_VID_CTL) & ~VC4_HD_VID_CTL_BLANKPIX);
1162 if (vc4_encoder->hdmi_monitor) {
1163 HDMI_WRITE(HDMI_SCHEDULER_CONTROL,
1164 HDMI_READ(HDMI_SCHEDULER_CONTROL) |
1165 VC4_HDMI_SCHEDULER_CONTROL_MODE_HDMI);
1167 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1169 ret = wait_for(HDMI_READ(HDMI_SCHEDULER_CONTROL) &
1170 VC4_HDMI_SCHEDULER_CONTROL_HDMI_ACTIVE, 1000);
1171 WARN_ONCE(ret, "Timeout waiting for "
1172 "VC4_HDMI_SCHEDULER_CONTROL_HDMI_ACTIVE\n");
1174 HDMI_WRITE(HDMI_RAM_PACKET_CONFIG,
1175 HDMI_READ(HDMI_RAM_PACKET_CONFIG) &
1176 ~(VC4_HDMI_RAM_PACKET_ENABLE));
1177 HDMI_WRITE(HDMI_SCHEDULER_CONTROL,
1178 HDMI_READ(HDMI_SCHEDULER_CONTROL) &
1179 ~VC4_HDMI_SCHEDULER_CONTROL_MODE_HDMI);
1181 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1183 ret = wait_for(!(HDMI_READ(HDMI_SCHEDULER_CONTROL) &
1184 VC4_HDMI_SCHEDULER_CONTROL_HDMI_ACTIVE), 1000);
1185 WARN_ONCE(ret, "Timeout waiting for "
1186 "!VC4_HDMI_SCHEDULER_CONTROL_HDMI_ACTIVE\n");
1189 if (vc4_encoder->hdmi_monitor) {
1190 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1192 WARN_ON(!(HDMI_READ(HDMI_SCHEDULER_CONTROL) &
1193 VC4_HDMI_SCHEDULER_CONTROL_HDMI_ACTIVE));
1194 HDMI_WRITE(HDMI_SCHEDULER_CONTROL,
1195 HDMI_READ(HDMI_SCHEDULER_CONTROL) |
1196 VC4_HDMI_SCHEDULER_CONTROL_VERT_ALWAYS_KEEPOUT);
1198 HDMI_WRITE(HDMI_RAM_PACKET_CONFIG,
1199 VC4_HDMI_RAM_PACKET_ENABLE);
1201 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1203 vc4_hdmi_set_infoframes(encoder);
1206 vc4_hdmi_recenter_fifo(vc4_hdmi);
1207 vc4_hdmi_enable_scrambling(encoder);
1209 mutex_unlock(&vc4_hdmi->mutex);
1212 static void vc4_hdmi_encoder_enable(struct drm_encoder *encoder)
1214 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1216 mutex_lock(&vc4_hdmi->mutex);
1217 vc4_hdmi->output_enabled = true;
1218 mutex_unlock(&vc4_hdmi->mutex);
1221 static void vc4_hdmi_encoder_atomic_mode_set(struct drm_encoder *encoder,
1222 struct drm_crtc_state *crtc_state,
1223 struct drm_connector_state *conn_state)
1225 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1227 mutex_lock(&vc4_hdmi->mutex);
1228 memcpy(&vc4_hdmi->saved_adjusted_mode,
1229 &crtc_state->adjusted_mode,
1230 sizeof(vc4_hdmi->saved_adjusted_mode));
1231 mutex_unlock(&vc4_hdmi->mutex);
1234 #define WIFI_2_4GHz_CH1_MIN_FREQ 2400000000ULL
1235 #define WIFI_2_4GHz_CH1_MAX_FREQ 2422000000ULL
1237 static int vc4_hdmi_encoder_atomic_check(struct drm_encoder *encoder,
1238 struct drm_crtc_state *crtc_state,
1239 struct drm_connector_state *conn_state)
1241 struct vc4_hdmi_connector_state *vc4_state = conn_state_to_vc4_hdmi_conn_state(conn_state);
1242 struct drm_display_mode *mode = &crtc_state->adjusted_mode;
1243 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1244 unsigned long long pixel_rate = mode->clock * 1000;
1245 unsigned long long tmds_rate;
1247 if (vc4_hdmi->variant->unsupported_odd_h_timings &&
1248 !(mode->flags & DRM_MODE_FLAG_DBLCLK) &&
1249 ((mode->hdisplay % 2) || (mode->hsync_start % 2) ||
1250 (mode->hsync_end % 2) || (mode->htotal % 2)))
1254 * The 1440p@60 pixel rate is in the same range than the first
1255 * WiFi channel (between 2.4GHz and 2.422GHz with 22MHz
1256 * bandwidth). Slightly lower the frequency to bring it out of
1259 tmds_rate = pixel_rate * 10;
1260 if (vc4_hdmi->disable_wifi_frequencies &&
1261 (tmds_rate >= WIFI_2_4GHz_CH1_MIN_FREQ &&
1262 tmds_rate <= WIFI_2_4GHz_CH1_MAX_FREQ)) {
1263 mode->clock = 238560;
1264 pixel_rate = mode->clock * 1000;
1267 if (conn_state->max_bpc == 12) {
1268 pixel_rate = pixel_rate * 150;
1269 do_div(pixel_rate, 100);
1270 } else if (conn_state->max_bpc == 10) {
1271 pixel_rate = pixel_rate * 125;
1272 do_div(pixel_rate, 100);
1275 if (mode->flags & DRM_MODE_FLAG_DBLCLK)
1276 pixel_rate = pixel_rate * 2;
1278 if (pixel_rate > vc4_hdmi->variant->max_pixel_clock)
1281 if (vc4_hdmi->disable_4kp60 && (pixel_rate > HDMI_14_MAX_TMDS_CLK))
1284 vc4_state->pixel_rate = pixel_rate;
1289 static enum drm_mode_status
1290 vc4_hdmi_encoder_mode_valid(struct drm_encoder *encoder,
1291 const struct drm_display_mode *mode)
1293 struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
1295 if (vc4_hdmi->variant->unsupported_odd_h_timings &&
1296 !(mode->flags & DRM_MODE_FLAG_DBLCLK) &&
1297 ((mode->hdisplay % 2) || (mode->hsync_start % 2) ||
1298 (mode->hsync_end % 2) || (mode->htotal % 2)))
1299 return MODE_H_ILLEGAL;
1301 if ((mode->clock * 1000) > vc4_hdmi->variant->max_pixel_clock)
1302 return MODE_CLOCK_HIGH;
1304 if (vc4_hdmi->disable_4kp60 && vc4_hdmi_mode_needs_scrambling(mode))
1305 return MODE_CLOCK_HIGH;
1310 static const struct drm_encoder_helper_funcs vc4_hdmi_encoder_helper_funcs = {
1311 .atomic_check = vc4_hdmi_encoder_atomic_check,
1312 .atomic_mode_set = vc4_hdmi_encoder_atomic_mode_set,
1313 .mode_valid = vc4_hdmi_encoder_mode_valid,
1314 .disable = vc4_hdmi_encoder_disable,
1315 .enable = vc4_hdmi_encoder_enable,
1318 static u32 vc4_hdmi_channel_map(struct vc4_hdmi *vc4_hdmi, u32 channel_mask)
1321 u32 channel_map = 0;
1323 for (i = 0; i < 8; i++) {
1324 if (channel_mask & BIT(i))
1325 channel_map |= i << (3 * i);
1330 static u32 vc5_hdmi_channel_map(struct vc4_hdmi *vc4_hdmi, u32 channel_mask)
1333 u32 channel_map = 0;
1335 for (i = 0; i < 8; i++) {
1336 if (channel_mask & BIT(i))
1337 channel_map |= i << (4 * i);
1342 static bool vc5_hdmi_hp_detect(struct vc4_hdmi *vc4_hdmi)
1344 unsigned long flags;
1347 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1348 hotplug = HDMI_READ(HDMI_HOTPLUG);
1349 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1351 return !!(hotplug & VC4_HDMI_HOTPLUG_CONNECTED);
1354 /* HDMI audio codec callbacks */
1355 static void vc4_hdmi_audio_set_mai_clock(struct vc4_hdmi *vc4_hdmi,
1356 unsigned int samplerate)
1358 u32 hsm_clock = clk_get_rate(vc4_hdmi->audio_clock);
1359 unsigned long flags;
1362 rational_best_approximation(hsm_clock, samplerate,
1363 VC4_HD_MAI_SMP_N_MASK >>
1364 VC4_HD_MAI_SMP_N_SHIFT,
1365 (VC4_HD_MAI_SMP_M_MASK >>
1366 VC4_HD_MAI_SMP_M_SHIFT) + 1,
1369 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1370 HDMI_WRITE(HDMI_MAI_SMP,
1371 VC4_SET_FIELD(n, VC4_HD_MAI_SMP_N) |
1372 VC4_SET_FIELD(m - 1, VC4_HD_MAI_SMP_M));
1373 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1376 static void vc4_hdmi_set_n_cts(struct vc4_hdmi *vc4_hdmi, unsigned int samplerate)
1378 const struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
1382 lockdep_assert_held(&vc4_hdmi->mutex);
1383 lockdep_assert_held(&vc4_hdmi->hw_lock);
1385 n = 128 * samplerate / 1000;
1386 tmp = (u64)(mode->clock * 1000) * n;
1387 do_div(tmp, 128 * samplerate);
1390 HDMI_WRITE(HDMI_CRP_CFG,
1391 VC4_HDMI_CRP_CFG_EXTERNAL_CTS_EN |
1392 VC4_SET_FIELD(n, VC4_HDMI_CRP_CFG_N));
1395 * We could get slightly more accurate clocks in some cases by
1396 * providing a CTS_1 value. The two CTS values are alternated
1397 * between based on the period fields
1399 HDMI_WRITE(HDMI_CTS_0, cts);
1400 HDMI_WRITE(HDMI_CTS_1, cts);
1403 static inline struct vc4_hdmi *dai_to_hdmi(struct snd_soc_dai *dai)
1405 struct snd_soc_card *card = snd_soc_dai_get_drvdata(dai);
1407 return snd_soc_card_get_drvdata(card);
1410 static bool vc4_hdmi_audio_can_stream(struct vc4_hdmi *vc4_hdmi)
1412 lockdep_assert_held(&vc4_hdmi->mutex);
1415 * If the controller is disabled, prevent any ALSA output.
1417 if (!vc4_hdmi->output_enabled)
1421 * If the encoder is currently in DVI mode, treat the codec DAI
1424 if (!(HDMI_READ(HDMI_RAM_PACKET_CONFIG) & VC4_HDMI_RAM_PACKET_ENABLE))
1430 static int vc4_hdmi_audio_startup(struct device *dev, void *data)
1432 struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
1433 unsigned long flags;
1435 mutex_lock(&vc4_hdmi->mutex);
1437 if (!vc4_hdmi_audio_can_stream(vc4_hdmi)) {
1438 mutex_unlock(&vc4_hdmi->mutex);
1442 vc4_hdmi->audio.streaming = true;
1444 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1445 HDMI_WRITE(HDMI_MAI_CTL,
1446 VC4_HD_MAI_CTL_RESET |
1447 VC4_HD_MAI_CTL_FLUSH |
1448 VC4_HD_MAI_CTL_DLATE |
1449 VC4_HD_MAI_CTL_ERRORE |
1450 VC4_HD_MAI_CTL_ERRORF);
1451 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1453 if (vc4_hdmi->variant->phy_rng_enable)
1454 vc4_hdmi->variant->phy_rng_enable(vc4_hdmi);
1456 mutex_unlock(&vc4_hdmi->mutex);
1461 static void vc4_hdmi_audio_reset(struct vc4_hdmi *vc4_hdmi)
1463 struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
1464 struct device *dev = &vc4_hdmi->pdev->dev;
1465 unsigned long flags;
1468 lockdep_assert_held(&vc4_hdmi->mutex);
1470 vc4_hdmi->audio.streaming = false;
1471 ret = vc4_hdmi_stop_packet(encoder, HDMI_INFOFRAME_TYPE_AUDIO, false);
1473 dev_err(dev, "Failed to stop audio infoframe: %d\n", ret);
1475 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1477 HDMI_WRITE(HDMI_MAI_CTL, VC4_HD_MAI_CTL_RESET);
1478 HDMI_WRITE(HDMI_MAI_CTL, VC4_HD_MAI_CTL_ERRORF);
1479 HDMI_WRITE(HDMI_MAI_CTL, VC4_HD_MAI_CTL_FLUSH);
1481 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1484 static void vc4_hdmi_audio_shutdown(struct device *dev, void *data)
1486 struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
1487 unsigned long flags;
1489 mutex_lock(&vc4_hdmi->mutex);
1491 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1493 HDMI_WRITE(HDMI_MAI_CTL,
1494 VC4_HD_MAI_CTL_DLATE |
1495 VC4_HD_MAI_CTL_ERRORE |
1496 VC4_HD_MAI_CTL_ERRORF);
1498 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1500 if (vc4_hdmi->variant->phy_rng_disable)
1501 vc4_hdmi->variant->phy_rng_disable(vc4_hdmi);
1503 vc4_hdmi->audio.streaming = false;
1504 vc4_hdmi_audio_reset(vc4_hdmi);
1506 mutex_unlock(&vc4_hdmi->mutex);
1509 static int sample_rate_to_mai_fmt(int samplerate)
1511 switch (samplerate) {
1513 return VC4_HDMI_MAI_SAMPLE_RATE_8000;
1515 return VC4_HDMI_MAI_SAMPLE_RATE_11025;
1517 return VC4_HDMI_MAI_SAMPLE_RATE_12000;
1519 return VC4_HDMI_MAI_SAMPLE_RATE_16000;
1521 return VC4_HDMI_MAI_SAMPLE_RATE_22050;
1523 return VC4_HDMI_MAI_SAMPLE_RATE_24000;
1525 return VC4_HDMI_MAI_SAMPLE_RATE_32000;
1527 return VC4_HDMI_MAI_SAMPLE_RATE_44100;
1529 return VC4_HDMI_MAI_SAMPLE_RATE_48000;
1531 return VC4_HDMI_MAI_SAMPLE_RATE_64000;
1533 return VC4_HDMI_MAI_SAMPLE_RATE_88200;
1535 return VC4_HDMI_MAI_SAMPLE_RATE_96000;
1537 return VC4_HDMI_MAI_SAMPLE_RATE_128000;
1539 return VC4_HDMI_MAI_SAMPLE_RATE_176400;
1541 return VC4_HDMI_MAI_SAMPLE_RATE_192000;
1543 return VC4_HDMI_MAI_SAMPLE_RATE_NOT_INDICATED;
1547 /* HDMI audio codec callbacks */
1548 static int vc4_hdmi_audio_prepare(struct device *dev, void *data,
1549 struct hdmi_codec_daifmt *daifmt,
1550 struct hdmi_codec_params *params)
1552 struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
1553 struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
1554 unsigned int sample_rate = params->sample_rate;
1555 unsigned int channels = params->channels;
1556 unsigned long flags;
1557 u32 audio_packet_config, channel_mask;
1559 u32 mai_audio_format;
1560 u32 mai_sample_rate;
1562 dev_dbg(dev, "%s: %u Hz, %d bit, %d channels\n", __func__,
1563 sample_rate, params->sample_width, channels);
1565 mutex_lock(&vc4_hdmi->mutex);
1567 if (!vc4_hdmi_audio_can_stream(vc4_hdmi)) {
1568 mutex_unlock(&vc4_hdmi->mutex);
1572 vc4_hdmi_audio_set_mai_clock(vc4_hdmi, sample_rate);
1574 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
1575 HDMI_WRITE(HDMI_MAI_CTL,
1576 VC4_SET_FIELD(channels, VC4_HD_MAI_CTL_CHNUM) |
1577 VC4_HD_MAI_CTL_WHOLSMP |
1578 VC4_HD_MAI_CTL_CHALIGN |
1579 VC4_HD_MAI_CTL_ENABLE);
1581 mai_sample_rate = sample_rate_to_mai_fmt(sample_rate);
1582 if (params->iec.status[0] & IEC958_AES0_NONAUDIO &&
1583 params->channels == 8)
1584 mai_audio_format = VC4_HDMI_MAI_FORMAT_HBR;
1586 mai_audio_format = VC4_HDMI_MAI_FORMAT_PCM;
1587 HDMI_WRITE(HDMI_MAI_FMT,
1588 VC4_SET_FIELD(mai_sample_rate,
1589 VC4_HDMI_MAI_FORMAT_SAMPLE_RATE) |
1590 VC4_SET_FIELD(mai_audio_format,
1591 VC4_HDMI_MAI_FORMAT_AUDIO_FORMAT));
1593 /* The B frame identifier should match the value used by alsa-lib (8) */
1594 audio_packet_config =
1595 VC4_HDMI_AUDIO_PACKET_ZERO_DATA_ON_SAMPLE_FLAT |
1596 VC4_HDMI_AUDIO_PACKET_ZERO_DATA_ON_INACTIVE_CHANNELS |
1597 VC4_SET_FIELD(0x8, VC4_HDMI_AUDIO_PACKET_B_FRAME_IDENTIFIER);
1599 channel_mask = GENMASK(channels - 1, 0);
1600 audio_packet_config |= VC4_SET_FIELD(channel_mask,
1601 VC4_HDMI_AUDIO_PACKET_CEA_MASK);
1603 /* Set the MAI threshold */
1604 HDMI_WRITE(HDMI_MAI_THR,
1605 VC4_SET_FIELD(0x10, VC4_HD_MAI_THR_PANICHIGH) |
1606 VC4_SET_FIELD(0x10, VC4_HD_MAI_THR_PANICLOW) |
1607 VC4_SET_FIELD(0x10, VC4_HD_MAI_THR_DREQHIGH) |
1608 VC4_SET_FIELD(0x10, VC4_HD_MAI_THR_DREQLOW));
1610 HDMI_WRITE(HDMI_MAI_CONFIG,
1611 VC4_HDMI_MAI_CONFIG_BIT_REVERSE |
1612 VC4_HDMI_MAI_CONFIG_FORMAT_REVERSE |
1613 VC4_SET_FIELD(channel_mask, VC4_HDMI_MAI_CHANNEL_MASK));
1615 channel_map = vc4_hdmi->variant->channel_map(vc4_hdmi, channel_mask);
1616 HDMI_WRITE(HDMI_MAI_CHANNEL_MAP, channel_map);
1617 HDMI_WRITE(HDMI_AUDIO_PACKET_CONFIG, audio_packet_config);
1619 vc4_hdmi_set_n_cts(vc4_hdmi, sample_rate);
1621 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
1623 memcpy(&vc4_hdmi->audio.infoframe, ¶ms->cea, sizeof(params->cea));
1624 vc4_hdmi_set_audio_infoframe(encoder);
1626 mutex_unlock(&vc4_hdmi->mutex);
1631 static const struct snd_soc_component_driver vc4_hdmi_audio_cpu_dai_comp = {
1632 .name = "vc4-hdmi-cpu-dai-component",
1635 static int vc4_hdmi_audio_cpu_dai_probe(struct snd_soc_dai *dai)
1637 struct vc4_hdmi *vc4_hdmi = dai_to_hdmi(dai);
1639 snd_soc_dai_init_dma_data(dai, &vc4_hdmi->audio.dma_data, NULL);
1644 static struct snd_soc_dai_driver vc4_hdmi_audio_cpu_dai_drv = {
1645 .name = "vc4-hdmi-cpu-dai",
1646 .probe = vc4_hdmi_audio_cpu_dai_probe,
1648 .stream_name = "Playback",
1651 .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
1652 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |
1653 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |
1654 SNDRV_PCM_RATE_192000,
1655 .formats = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE,
1659 static const struct snd_dmaengine_pcm_config pcm_conf = {
1660 .chan_names[SNDRV_PCM_STREAM_PLAYBACK] = "audio-rx",
1661 .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
1664 static int vc4_hdmi_audio_get_eld(struct device *dev, void *data,
1665 uint8_t *buf, size_t len)
1667 struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
1668 struct drm_connector *connector = &vc4_hdmi->connector;
1670 mutex_lock(&vc4_hdmi->mutex);
1671 memcpy(buf, connector->eld, min(sizeof(connector->eld), len));
1672 mutex_unlock(&vc4_hdmi->mutex);
1677 static const struct hdmi_codec_ops vc4_hdmi_codec_ops = {
1678 .get_eld = vc4_hdmi_audio_get_eld,
1679 .prepare = vc4_hdmi_audio_prepare,
1680 .audio_shutdown = vc4_hdmi_audio_shutdown,
1681 .audio_startup = vc4_hdmi_audio_startup,
1684 static struct hdmi_codec_pdata vc4_hdmi_codec_pdata = {
1685 .ops = &vc4_hdmi_codec_ops,
1686 .max_i2s_channels = 8,
1690 static int vc4_hdmi_audio_init(struct vc4_hdmi *vc4_hdmi)
1692 const struct vc4_hdmi_register *mai_data =
1693 &vc4_hdmi->variant->registers[HDMI_MAI_DATA];
1694 struct snd_soc_dai_link *dai_link = &vc4_hdmi->audio.link;
1695 struct snd_soc_card *card = &vc4_hdmi->audio.card;
1696 struct device *dev = &vc4_hdmi->pdev->dev;
1697 struct platform_device *codec_pdev;
1702 if (!of_find_property(dev->of_node, "dmas", NULL)) {
1704 "'dmas' DT property is missing, no HDMI audio\n");
1708 if (mai_data->reg != VC4_HD) {
1709 WARN_ONCE(true, "MAI isn't in the HD block\n");
1714 * Get the physical address of VC4_HD_MAI_DATA. We need to retrieve
1715 * the bus address specified in the DT, because the physical address
1716 * (the one returned by platform_get_resource()) is not appropriate
1717 * for DMA transfers.
1718 * This VC/MMU should probably be exposed to avoid this kind of hacks.
1720 index = of_property_match_string(dev->of_node, "reg-names", "hd");
1721 /* Before BCM2711, we don't have a named register range */
1725 addr = of_get_address(dev->of_node, index, NULL, NULL);
1727 vc4_hdmi->audio.dma_data.addr = be32_to_cpup(addr) + mai_data->offset;
1728 vc4_hdmi->audio.dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
1729 vc4_hdmi->audio.dma_data.maxburst = 2;
1731 ret = devm_snd_dmaengine_pcm_register(dev, &pcm_conf, 0);
1733 dev_err(dev, "Could not register PCM component: %d\n", ret);
1737 ret = devm_snd_soc_register_component(dev, &vc4_hdmi_audio_cpu_dai_comp,
1738 &vc4_hdmi_audio_cpu_dai_drv, 1);
1740 dev_err(dev, "Could not register CPU DAI: %d\n", ret);
1744 codec_pdev = platform_device_register_data(dev, HDMI_CODEC_DRV_NAME,
1745 PLATFORM_DEVID_AUTO,
1746 &vc4_hdmi_codec_pdata,
1747 sizeof(vc4_hdmi_codec_pdata));
1748 if (IS_ERR(codec_pdev)) {
1749 dev_err(dev, "Couldn't register the HDMI codec: %ld\n", PTR_ERR(codec_pdev));
1750 return PTR_ERR(codec_pdev);
1753 dai_link->cpus = &vc4_hdmi->audio.cpu;
1754 dai_link->codecs = &vc4_hdmi->audio.codec;
1755 dai_link->platforms = &vc4_hdmi->audio.platform;
1757 dai_link->num_cpus = 1;
1758 dai_link->num_codecs = 1;
1759 dai_link->num_platforms = 1;
1761 dai_link->name = "MAI";
1762 dai_link->stream_name = "MAI PCM";
1763 dai_link->codecs->dai_name = "i2s-hifi";
1764 dai_link->cpus->dai_name = dev_name(dev);
1765 dai_link->codecs->name = dev_name(&codec_pdev->dev);
1766 dai_link->platforms->name = dev_name(dev);
1768 card->dai_link = dai_link;
1769 card->num_links = 1;
1770 card->name = vc4_hdmi->variant->card_name;
1771 card->driver_name = "vc4-hdmi";
1773 card->owner = THIS_MODULE;
1776 * Be careful, snd_soc_register_card() calls dev_set_drvdata() and
1777 * stores a pointer to the snd card object in dev->driver_data. This
1778 * means we cannot use it for something else. The hdmi back-pointer is
1779 * now stored in card->drvdata and should be retrieved with
1780 * snd_soc_card_get_drvdata() if needed.
1782 snd_soc_card_set_drvdata(card, vc4_hdmi);
1783 ret = devm_snd_soc_register_card(dev, card);
1785 dev_err_probe(dev, ret, "Could not register sound card\n");
1791 static irqreturn_t vc4_hdmi_hpd_irq_thread(int irq, void *priv)
1793 struct vc4_hdmi *vc4_hdmi = priv;
1794 struct drm_connector *connector = &vc4_hdmi->connector;
1795 struct drm_device *dev = connector->dev;
1797 if (dev && dev->registered)
1798 drm_connector_helper_hpd_irq_event(connector);
1803 static int vc4_hdmi_hotplug_init(struct vc4_hdmi *vc4_hdmi)
1805 struct drm_connector *connector = &vc4_hdmi->connector;
1806 struct platform_device *pdev = vc4_hdmi->pdev;
1809 if (vc4_hdmi->variant->external_irq_controller) {
1810 unsigned int hpd_con = platform_get_irq_byname(pdev, "hpd-connected");
1811 unsigned int hpd_rm = platform_get_irq_byname(pdev, "hpd-removed");
1813 ret = request_threaded_irq(hpd_con,
1815 vc4_hdmi_hpd_irq_thread, IRQF_ONESHOT,
1816 "vc4 hdmi hpd connected", vc4_hdmi);
1820 ret = request_threaded_irq(hpd_rm,
1822 vc4_hdmi_hpd_irq_thread, IRQF_ONESHOT,
1823 "vc4 hdmi hpd disconnected", vc4_hdmi);
1825 free_irq(hpd_con, vc4_hdmi);
1829 connector->polled = DRM_CONNECTOR_POLL_HPD;
1835 static void vc4_hdmi_hotplug_exit(struct vc4_hdmi *vc4_hdmi)
1837 struct platform_device *pdev = vc4_hdmi->pdev;
1839 if (vc4_hdmi->variant->external_irq_controller) {
1840 free_irq(platform_get_irq_byname(pdev, "hpd-connected"), vc4_hdmi);
1841 free_irq(platform_get_irq_byname(pdev, "hpd-removed"), vc4_hdmi);
1845 #ifdef CONFIG_DRM_VC4_HDMI_CEC
1846 static irqreturn_t vc4_cec_irq_handler_rx_thread(int irq, void *priv)
1848 struct vc4_hdmi *vc4_hdmi = priv;
1850 if (vc4_hdmi->cec_rx_msg.len)
1851 cec_received_msg(vc4_hdmi->cec_adap,
1852 &vc4_hdmi->cec_rx_msg);
1857 static irqreturn_t vc4_cec_irq_handler_tx_thread(int irq, void *priv)
1859 struct vc4_hdmi *vc4_hdmi = priv;
1861 if (vc4_hdmi->cec_tx_ok) {
1862 cec_transmit_done(vc4_hdmi->cec_adap, CEC_TX_STATUS_OK,
1866 * This CEC implementation makes 1 retry, so if we
1867 * get a NACK, then that means it made 2 attempts.
1869 cec_transmit_done(vc4_hdmi->cec_adap, CEC_TX_STATUS_NACK,
1875 static irqreturn_t vc4_cec_irq_handler_thread(int irq, void *priv)
1877 struct vc4_hdmi *vc4_hdmi = priv;
1880 if (vc4_hdmi->cec_irq_was_rx)
1881 ret = vc4_cec_irq_handler_rx_thread(irq, priv);
1883 ret = vc4_cec_irq_handler_tx_thread(irq, priv);
1888 static void vc4_cec_read_msg(struct vc4_hdmi *vc4_hdmi, u32 cntrl1)
1890 struct drm_device *dev = vc4_hdmi->connector.dev;
1891 struct cec_msg *msg = &vc4_hdmi->cec_rx_msg;
1894 lockdep_assert_held(&vc4_hdmi->hw_lock);
1896 msg->len = 1 + ((cntrl1 & VC4_HDMI_CEC_REC_WRD_CNT_MASK) >>
1897 VC4_HDMI_CEC_REC_WRD_CNT_SHIFT);
1899 if (msg->len > 16) {
1900 drm_err(dev, "Attempting to read too much data (%d)\n", msg->len);
1904 for (i = 0; i < msg->len; i += 4) {
1905 u32 val = HDMI_READ(HDMI_CEC_RX_DATA_1 + (i >> 2));
1907 msg->msg[i] = val & 0xff;
1908 msg->msg[i + 1] = (val >> 8) & 0xff;
1909 msg->msg[i + 2] = (val >> 16) & 0xff;
1910 msg->msg[i + 3] = (val >> 24) & 0xff;
1914 static irqreturn_t vc4_cec_irq_handler_tx_bare_locked(struct vc4_hdmi *vc4_hdmi)
1918 lockdep_assert_held(&vc4_hdmi->hw_lock);
1920 cntrl1 = HDMI_READ(HDMI_CEC_CNTRL_1);
1921 vc4_hdmi->cec_tx_ok = cntrl1 & VC4_HDMI_CEC_TX_STATUS_GOOD;
1922 cntrl1 &= ~VC4_HDMI_CEC_START_XMIT_BEGIN;
1923 HDMI_WRITE(HDMI_CEC_CNTRL_1, cntrl1);
1925 return IRQ_WAKE_THREAD;
1928 static irqreturn_t vc4_cec_irq_handler_tx_bare(int irq, void *priv)
1930 struct vc4_hdmi *vc4_hdmi = priv;
1933 spin_lock(&vc4_hdmi->hw_lock);
1934 ret = vc4_cec_irq_handler_tx_bare_locked(vc4_hdmi);
1935 spin_unlock(&vc4_hdmi->hw_lock);
1940 static irqreturn_t vc4_cec_irq_handler_rx_bare_locked(struct vc4_hdmi *vc4_hdmi)
1944 lockdep_assert_held(&vc4_hdmi->hw_lock);
1946 vc4_hdmi->cec_rx_msg.len = 0;
1947 cntrl1 = HDMI_READ(HDMI_CEC_CNTRL_1);
1948 vc4_cec_read_msg(vc4_hdmi, cntrl1);
1949 cntrl1 |= VC4_HDMI_CEC_CLEAR_RECEIVE_OFF;
1950 HDMI_WRITE(HDMI_CEC_CNTRL_1, cntrl1);
1951 cntrl1 &= ~VC4_HDMI_CEC_CLEAR_RECEIVE_OFF;
1953 HDMI_WRITE(HDMI_CEC_CNTRL_1, cntrl1);
1955 return IRQ_WAKE_THREAD;
1958 static irqreturn_t vc4_cec_irq_handler_rx_bare(int irq, void *priv)
1960 struct vc4_hdmi *vc4_hdmi = priv;
1963 spin_lock(&vc4_hdmi->hw_lock);
1964 ret = vc4_cec_irq_handler_rx_bare_locked(vc4_hdmi);
1965 spin_unlock(&vc4_hdmi->hw_lock);
1970 static irqreturn_t vc4_cec_irq_handler(int irq, void *priv)
1972 struct vc4_hdmi *vc4_hdmi = priv;
1973 u32 stat = HDMI_READ(HDMI_CEC_CPU_STATUS);
1977 if (!(stat & VC4_HDMI_CPU_CEC))
1980 spin_lock(&vc4_hdmi->hw_lock);
1981 cntrl5 = HDMI_READ(HDMI_CEC_CNTRL_5);
1982 vc4_hdmi->cec_irq_was_rx = cntrl5 & VC4_HDMI_CEC_RX_CEC_INT;
1983 if (vc4_hdmi->cec_irq_was_rx)
1984 ret = vc4_cec_irq_handler_rx_bare_locked(vc4_hdmi);
1986 ret = vc4_cec_irq_handler_tx_bare_locked(vc4_hdmi);
1988 HDMI_WRITE(HDMI_CEC_CPU_CLEAR, VC4_HDMI_CPU_CEC);
1989 spin_unlock(&vc4_hdmi->hw_lock);
1994 static int vc4_hdmi_cec_enable(struct cec_adapter *adap)
1996 struct vc4_hdmi *vc4_hdmi = cec_get_drvdata(adap);
1997 /* clock period in microseconds */
1998 const u32 usecs = 1000000 / CEC_CLOCK_FREQ;
1999 unsigned long flags;
2004 * NOTE: This function should really take vc4_hdmi->mutex, but doing so
2005 * results in a reentrancy since cec_s_phys_addr_from_edid() called in
2006 * .detect or .get_modes might call .adap_enable, which leads to this
2007 * function being called with that mutex held.
2009 * Concurrency is not an issue for the moment since we don't share any
2010 * state with KMS, so we can ignore the lock for now, but we need to
2011 * keep it in mind if we were to change that assumption.
2014 ret = pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev);
2018 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
2020 val = HDMI_READ(HDMI_CEC_CNTRL_5);
2021 val &= ~(VC4_HDMI_CEC_TX_SW_RESET | VC4_HDMI_CEC_RX_SW_RESET |
2022 VC4_HDMI_CEC_CNT_TO_4700_US_MASK |
2023 VC4_HDMI_CEC_CNT_TO_4500_US_MASK);
2024 val |= ((4700 / usecs) << VC4_HDMI_CEC_CNT_TO_4700_US_SHIFT) |
2025 ((4500 / usecs) << VC4_HDMI_CEC_CNT_TO_4500_US_SHIFT);
2027 HDMI_WRITE(HDMI_CEC_CNTRL_5, val |
2028 VC4_HDMI_CEC_TX_SW_RESET | VC4_HDMI_CEC_RX_SW_RESET);
2029 HDMI_WRITE(HDMI_CEC_CNTRL_5, val);
2030 HDMI_WRITE(HDMI_CEC_CNTRL_2,
2031 ((1500 / usecs) << VC4_HDMI_CEC_CNT_TO_1500_US_SHIFT) |
2032 ((1300 / usecs) << VC4_HDMI_CEC_CNT_TO_1300_US_SHIFT) |
2033 ((800 / usecs) << VC4_HDMI_CEC_CNT_TO_800_US_SHIFT) |
2034 ((600 / usecs) << VC4_HDMI_CEC_CNT_TO_600_US_SHIFT) |
2035 ((400 / usecs) << VC4_HDMI_CEC_CNT_TO_400_US_SHIFT));
2036 HDMI_WRITE(HDMI_CEC_CNTRL_3,
2037 ((2750 / usecs) << VC4_HDMI_CEC_CNT_TO_2750_US_SHIFT) |
2038 ((2400 / usecs) << VC4_HDMI_CEC_CNT_TO_2400_US_SHIFT) |
2039 ((2050 / usecs) << VC4_HDMI_CEC_CNT_TO_2050_US_SHIFT) |
2040 ((1700 / usecs) << VC4_HDMI_CEC_CNT_TO_1700_US_SHIFT));
2041 HDMI_WRITE(HDMI_CEC_CNTRL_4,
2042 ((4300 / usecs) << VC4_HDMI_CEC_CNT_TO_4300_US_SHIFT) |
2043 ((3900 / usecs) << VC4_HDMI_CEC_CNT_TO_3900_US_SHIFT) |
2044 ((3600 / usecs) << VC4_HDMI_CEC_CNT_TO_3600_US_SHIFT) |
2045 ((3500 / usecs) << VC4_HDMI_CEC_CNT_TO_3500_US_SHIFT));
2047 if (!vc4_hdmi->variant->external_irq_controller)
2048 HDMI_WRITE(HDMI_CEC_CPU_MASK_CLEAR, VC4_HDMI_CPU_CEC);
2050 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
2055 static int vc4_hdmi_cec_disable(struct cec_adapter *adap)
2057 struct vc4_hdmi *vc4_hdmi = cec_get_drvdata(adap);
2058 unsigned long flags;
2061 * NOTE: This function should really take vc4_hdmi->mutex, but doing so
2062 * results in a reentrancy since cec_s_phys_addr_from_edid() called in
2063 * .detect or .get_modes might call .adap_enable, which leads to this
2064 * function being called with that mutex held.
2066 * Concurrency is not an issue for the moment since we don't share any
2067 * state with KMS, so we can ignore the lock for now, but we need to
2068 * keep it in mind if we were to change that assumption.
2071 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
2073 if (!vc4_hdmi->variant->external_irq_controller)
2074 HDMI_WRITE(HDMI_CEC_CPU_MASK_SET, VC4_HDMI_CPU_CEC);
2076 HDMI_WRITE(HDMI_CEC_CNTRL_5, HDMI_READ(HDMI_CEC_CNTRL_5) |
2077 VC4_HDMI_CEC_TX_SW_RESET | VC4_HDMI_CEC_RX_SW_RESET);
2079 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
2081 pm_runtime_put(&vc4_hdmi->pdev->dev);
2086 static int vc4_hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
2089 return vc4_hdmi_cec_enable(adap);
2091 return vc4_hdmi_cec_disable(adap);
2094 static int vc4_hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
2096 struct vc4_hdmi *vc4_hdmi = cec_get_drvdata(adap);
2097 unsigned long flags;
2100 * NOTE: This function should really take vc4_hdmi->mutex, but doing so
2101 * results in a reentrancy since cec_s_phys_addr_from_edid() called in
2102 * .detect or .get_modes might call .adap_enable, which leads to this
2103 * function being called with that mutex held.
2105 * Concurrency is not an issue for the moment since we don't share any
2106 * state with KMS, so we can ignore the lock for now, but we need to
2107 * keep it in mind if we were to change that assumption.
2110 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
2111 HDMI_WRITE(HDMI_CEC_CNTRL_1,
2112 (HDMI_READ(HDMI_CEC_CNTRL_1) & ~VC4_HDMI_CEC_ADDR_MASK) |
2113 (log_addr & 0xf) << VC4_HDMI_CEC_ADDR_SHIFT);
2114 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
2119 static int vc4_hdmi_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
2120 u32 signal_free_time, struct cec_msg *msg)
2122 struct vc4_hdmi *vc4_hdmi = cec_get_drvdata(adap);
2123 struct drm_device *dev = vc4_hdmi->connector.dev;
2124 unsigned long flags;
2129 * NOTE: This function should really take vc4_hdmi->mutex, but doing so
2130 * results in a reentrancy since cec_s_phys_addr_from_edid() called in
2131 * .detect or .get_modes might call .adap_enable, which leads to this
2132 * function being called with that mutex held.
2134 * Concurrency is not an issue for the moment since we don't share any
2135 * state with KMS, so we can ignore the lock for now, but we need to
2136 * keep it in mind if we were to change that assumption.
2139 if (msg->len > 16) {
2140 drm_err(dev, "Attempting to transmit too much data (%d)\n", msg->len);
2144 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
2146 for (i = 0; i < msg->len; i += 4)
2147 HDMI_WRITE(HDMI_CEC_TX_DATA_1 + (i >> 2),
2149 (msg->msg[i + 1] << 8) |
2150 (msg->msg[i + 2] << 16) |
2151 (msg->msg[i + 3] << 24));
2153 val = HDMI_READ(HDMI_CEC_CNTRL_1);
2154 val &= ~VC4_HDMI_CEC_START_XMIT_BEGIN;
2155 HDMI_WRITE(HDMI_CEC_CNTRL_1, val);
2156 val &= ~VC4_HDMI_CEC_MESSAGE_LENGTH_MASK;
2157 val |= (msg->len - 1) << VC4_HDMI_CEC_MESSAGE_LENGTH_SHIFT;
2158 val |= VC4_HDMI_CEC_START_XMIT_BEGIN;
2160 HDMI_WRITE(HDMI_CEC_CNTRL_1, val);
2162 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
2167 static const struct cec_adap_ops vc4_hdmi_cec_adap_ops = {
2168 .adap_enable = vc4_hdmi_cec_adap_enable,
2169 .adap_log_addr = vc4_hdmi_cec_adap_log_addr,
2170 .adap_transmit = vc4_hdmi_cec_adap_transmit,
2173 static int vc4_hdmi_cec_init(struct vc4_hdmi *vc4_hdmi)
2175 struct cec_connector_info conn_info;
2176 struct platform_device *pdev = vc4_hdmi->pdev;
2177 struct device *dev = &pdev->dev;
2178 unsigned long flags;
2182 if (!of_find_property(dev->of_node, "interrupts", NULL)) {
2183 dev_warn(dev, "'interrupts' DT property is missing, no CEC\n");
2187 vc4_hdmi->cec_adap = cec_allocate_adapter(&vc4_hdmi_cec_adap_ops,
2190 CEC_CAP_CONNECTOR_INFO, 1);
2191 ret = PTR_ERR_OR_ZERO(vc4_hdmi->cec_adap);
2195 cec_fill_conn_info_from_drm(&conn_info, &vc4_hdmi->connector);
2196 cec_s_conn_info(vc4_hdmi->cec_adap, &conn_info);
2198 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
2199 value = HDMI_READ(HDMI_CEC_CNTRL_1);
2200 /* Set the logical address to Unregistered */
2201 value |= VC4_HDMI_CEC_ADDR_MASK;
2202 HDMI_WRITE(HDMI_CEC_CNTRL_1, value);
2203 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
2205 vc4_hdmi_cec_update_clk_div(vc4_hdmi);
2207 if (vc4_hdmi->variant->external_irq_controller) {
2208 ret = request_threaded_irq(platform_get_irq_byname(pdev, "cec-rx"),
2209 vc4_cec_irq_handler_rx_bare,
2210 vc4_cec_irq_handler_rx_thread, 0,
2211 "vc4 hdmi cec rx", vc4_hdmi);
2213 goto err_delete_cec_adap;
2215 ret = request_threaded_irq(platform_get_irq_byname(pdev, "cec-tx"),
2216 vc4_cec_irq_handler_tx_bare,
2217 vc4_cec_irq_handler_tx_thread, 0,
2218 "vc4 hdmi cec tx", vc4_hdmi);
2220 goto err_remove_cec_rx_handler;
2222 spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
2223 HDMI_WRITE(HDMI_CEC_CPU_MASK_SET, 0xffffffff);
2224 spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
2226 ret = request_threaded_irq(platform_get_irq(pdev, 0),
2227 vc4_cec_irq_handler,
2228 vc4_cec_irq_handler_thread, 0,
2229 "vc4 hdmi cec", vc4_hdmi);
2231 goto err_delete_cec_adap;
2234 ret = cec_register_adapter(vc4_hdmi->cec_adap, &pdev->dev);
2236 goto err_remove_handlers;
2240 err_remove_handlers:
2241 if (vc4_hdmi->variant->external_irq_controller)
2242 free_irq(platform_get_irq_byname(pdev, "cec-tx"), vc4_hdmi);
2244 free_irq(platform_get_irq(pdev, 0), vc4_hdmi);
2246 err_remove_cec_rx_handler:
2247 if (vc4_hdmi->variant->external_irq_controller)
2248 free_irq(platform_get_irq_byname(pdev, "cec-rx"), vc4_hdmi);
2250 err_delete_cec_adap:
2251 cec_delete_adapter(vc4_hdmi->cec_adap);
2256 static void vc4_hdmi_cec_exit(struct vc4_hdmi *vc4_hdmi)
2258 struct platform_device *pdev = vc4_hdmi->pdev;
2260 if (vc4_hdmi->variant->external_irq_controller) {
2261 free_irq(platform_get_irq_byname(pdev, "cec-rx"), vc4_hdmi);
2262 free_irq(platform_get_irq_byname(pdev, "cec-tx"), vc4_hdmi);
2264 free_irq(platform_get_irq(pdev, 0), vc4_hdmi);
2267 cec_unregister_adapter(vc4_hdmi->cec_adap);
2270 static int vc4_hdmi_cec_init(struct vc4_hdmi *vc4_hdmi)
2275 static void vc4_hdmi_cec_exit(struct vc4_hdmi *vc4_hdmi) {};
2279 static int vc4_hdmi_build_regset(struct vc4_hdmi *vc4_hdmi,
2280 struct debugfs_regset32 *regset,
2281 enum vc4_hdmi_regs reg)
2283 const struct vc4_hdmi_variant *variant = vc4_hdmi->variant;
2284 struct debugfs_reg32 *regs, *new_regs;
2285 unsigned int count = 0;
2288 regs = kcalloc(variant->num_registers, sizeof(*regs),
2293 for (i = 0; i < variant->num_registers; i++) {
2294 const struct vc4_hdmi_register *field = &variant->registers[i];
2296 if (field->reg != reg)
2299 regs[count].name = field->name;
2300 regs[count].offset = field->offset;
2304 new_regs = krealloc(regs, count * sizeof(*regs), GFP_KERNEL);
2308 regset->base = __vc4_hdmi_get_field_base(vc4_hdmi, reg);
2309 regset->regs = new_regs;
2310 regset->nregs = count;
2315 static int vc4_hdmi_init_resources(struct vc4_hdmi *vc4_hdmi)
2317 struct platform_device *pdev = vc4_hdmi->pdev;
2318 struct device *dev = &pdev->dev;
2321 vc4_hdmi->hdmicore_regs = vc4_ioremap_regs(pdev, 0);
2322 if (IS_ERR(vc4_hdmi->hdmicore_regs))
2323 return PTR_ERR(vc4_hdmi->hdmicore_regs);
2325 vc4_hdmi->hd_regs = vc4_ioremap_regs(pdev, 1);
2326 if (IS_ERR(vc4_hdmi->hd_regs))
2327 return PTR_ERR(vc4_hdmi->hd_regs);
2329 ret = vc4_hdmi_build_regset(vc4_hdmi, &vc4_hdmi->hd_regset, VC4_HD);
2333 ret = vc4_hdmi_build_regset(vc4_hdmi, &vc4_hdmi->hdmi_regset, VC4_HDMI);
2337 vc4_hdmi->pixel_clock = devm_clk_get(dev, "pixel");
2338 if (IS_ERR(vc4_hdmi->pixel_clock)) {
2339 ret = PTR_ERR(vc4_hdmi->pixel_clock);
2340 if (ret != -EPROBE_DEFER)
2341 DRM_ERROR("Failed to get pixel clock\n");
2345 vc4_hdmi->hsm_clock = devm_clk_get(dev, "hdmi");
2346 if (IS_ERR(vc4_hdmi->hsm_clock)) {
2347 DRM_ERROR("Failed to get HDMI state machine clock\n");
2348 return PTR_ERR(vc4_hdmi->hsm_clock);
2350 vc4_hdmi->audio_clock = vc4_hdmi->hsm_clock;
2351 vc4_hdmi->cec_clock = vc4_hdmi->hsm_clock;
2356 static int vc5_hdmi_init_resources(struct vc4_hdmi *vc4_hdmi)
2358 struct platform_device *pdev = vc4_hdmi->pdev;
2359 struct device *dev = &pdev->dev;
2360 struct resource *res;
2362 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "hdmi");
2366 vc4_hdmi->hdmicore_regs = devm_ioremap(dev, res->start,
2367 resource_size(res));
2368 if (!vc4_hdmi->hdmicore_regs)
2371 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "hd");
2375 vc4_hdmi->hd_regs = devm_ioremap(dev, res->start, resource_size(res));
2376 if (!vc4_hdmi->hd_regs)
2379 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cec");
2383 vc4_hdmi->cec_regs = devm_ioremap(dev, res->start, resource_size(res));
2384 if (!vc4_hdmi->cec_regs)
2387 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "csc");
2391 vc4_hdmi->csc_regs = devm_ioremap(dev, res->start, resource_size(res));
2392 if (!vc4_hdmi->csc_regs)
2395 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dvp");
2399 vc4_hdmi->dvp_regs = devm_ioremap(dev, res->start, resource_size(res));
2400 if (!vc4_hdmi->dvp_regs)
2403 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phy");
2407 vc4_hdmi->phy_regs = devm_ioremap(dev, res->start, resource_size(res));
2408 if (!vc4_hdmi->phy_regs)
2411 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "packet");
2415 vc4_hdmi->ram_regs = devm_ioremap(dev, res->start, resource_size(res));
2416 if (!vc4_hdmi->ram_regs)
2419 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rm");
2423 vc4_hdmi->rm_regs = devm_ioremap(dev, res->start, resource_size(res));
2424 if (!vc4_hdmi->rm_regs)
2427 vc4_hdmi->hsm_clock = devm_clk_get(dev, "hdmi");
2428 if (IS_ERR(vc4_hdmi->hsm_clock)) {
2429 DRM_ERROR("Failed to get HDMI state machine clock\n");
2430 return PTR_ERR(vc4_hdmi->hsm_clock);
2433 vc4_hdmi->pixel_bvb_clock = devm_clk_get(dev, "bvb");
2434 if (IS_ERR(vc4_hdmi->pixel_bvb_clock)) {
2435 DRM_ERROR("Failed to get pixel bvb clock\n");
2436 return PTR_ERR(vc4_hdmi->pixel_bvb_clock);
2439 vc4_hdmi->audio_clock = devm_clk_get(dev, "audio");
2440 if (IS_ERR(vc4_hdmi->audio_clock)) {
2441 DRM_ERROR("Failed to get audio clock\n");
2442 return PTR_ERR(vc4_hdmi->audio_clock);
2445 vc4_hdmi->cec_clock = devm_clk_get(dev, "cec");
2446 if (IS_ERR(vc4_hdmi->cec_clock)) {
2447 DRM_ERROR("Failed to get CEC clock\n");
2448 return PTR_ERR(vc4_hdmi->cec_clock);
2451 vc4_hdmi->reset = devm_reset_control_get(dev, NULL);
2452 if (IS_ERR(vc4_hdmi->reset)) {
2453 DRM_ERROR("Failed to get HDMI reset line\n");
2454 return PTR_ERR(vc4_hdmi->reset);
2460 static int __maybe_unused vc4_hdmi_runtime_suspend(struct device *dev)
2462 struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
2464 clk_disable_unprepare(vc4_hdmi->hsm_clock);
2469 static int vc4_hdmi_runtime_resume(struct device *dev)
2471 struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
2474 ret = clk_prepare_enable(vc4_hdmi->hsm_clock);
2481 static int vc4_hdmi_bind(struct device *dev, struct device *master, void *data)
2483 const struct vc4_hdmi_variant *variant = of_device_get_match_data(dev);
2484 struct platform_device *pdev = to_platform_device(dev);
2485 struct drm_device *drm = dev_get_drvdata(master);
2486 struct vc4_hdmi *vc4_hdmi;
2487 struct drm_encoder *encoder;
2488 struct device_node *ddc_node;
2491 vc4_hdmi = devm_kzalloc(dev, sizeof(*vc4_hdmi), GFP_KERNEL);
2494 mutex_init(&vc4_hdmi->mutex);
2495 spin_lock_init(&vc4_hdmi->hw_lock);
2496 INIT_DELAYED_WORK(&vc4_hdmi->scrambling_work, vc4_hdmi_scrambling_wq);
2498 dev_set_drvdata(dev, vc4_hdmi);
2499 encoder = &vc4_hdmi->encoder.base.base;
2500 vc4_hdmi->encoder.base.type = variant->encoder_type;
2501 vc4_hdmi->encoder.base.pre_crtc_configure = vc4_hdmi_encoder_pre_crtc_configure;
2502 vc4_hdmi->encoder.base.pre_crtc_enable = vc4_hdmi_encoder_pre_crtc_enable;
2503 vc4_hdmi->encoder.base.post_crtc_enable = vc4_hdmi_encoder_post_crtc_enable;
2504 vc4_hdmi->encoder.base.post_crtc_disable = vc4_hdmi_encoder_post_crtc_disable;
2505 vc4_hdmi->encoder.base.post_crtc_powerdown = vc4_hdmi_encoder_post_crtc_powerdown;
2506 vc4_hdmi->pdev = pdev;
2507 vc4_hdmi->variant = variant;
2510 * Since we don't know the state of the controller and its
2511 * display (if any), let's assume it's always enabled.
2512 * vc4_hdmi_disable_scrambling() will thus run at boot, make
2513 * sure it's disabled, and avoid any inconsistency.
2515 if (variant->max_pixel_clock > HDMI_14_MAX_TMDS_CLK)
2516 vc4_hdmi->scdc_enabled = true;
2518 ret = variant->init_resources(vc4_hdmi);
2522 ddc_node = of_parse_phandle(dev->of_node, "ddc", 0);
2524 DRM_ERROR("Failed to find ddc node in device tree\n");
2528 vc4_hdmi->ddc = of_find_i2c_adapter_by_node(ddc_node);
2529 of_node_put(ddc_node);
2530 if (!vc4_hdmi->ddc) {
2531 DRM_DEBUG("Failed to get ddc i2c adapter by node\n");
2532 return -EPROBE_DEFER;
2535 /* Only use the GPIO HPD pin if present in the DT, otherwise
2536 * we'll use the HDMI core's register.
2538 vc4_hdmi->hpd_gpio = devm_gpiod_get_optional(dev, "hpd", GPIOD_IN);
2539 if (IS_ERR(vc4_hdmi->hpd_gpio)) {
2540 ret = PTR_ERR(vc4_hdmi->hpd_gpio);
2544 vc4_hdmi->disable_wifi_frequencies =
2545 of_property_read_bool(dev->of_node, "wifi-2.4ghz-coexistence");
2547 if (variant->max_pixel_clock == 600000000) {
2548 struct vc4_dev *vc4 = to_vc4_dev(drm);
2549 long max_rate = clk_round_rate(vc4->hvs->core_clk, 550000000);
2551 if (max_rate < 550000000)
2552 vc4_hdmi->disable_4kp60 = true;
2556 * If we boot without any cable connected to the HDMI connector,
2557 * the firmware will skip the HSM initialization and leave it
2558 * with a rate of 0, resulting in a bus lockup when we're
2559 * accessing the registers even if it's enabled.
2561 * Let's put a sensible default at runtime_resume so that we
2562 * don't end up in this situation.
2564 ret = clk_set_min_rate(vc4_hdmi->hsm_clock, HSM_MIN_CLOCK_FREQ);
2569 * We need to have the device powered up at this point to call
2570 * our reset hook and for the CEC init.
2572 ret = vc4_hdmi_runtime_resume(dev);
2576 pm_runtime_get_noresume(dev);
2577 pm_runtime_set_active(dev);
2578 pm_runtime_enable(dev);
2580 if (vc4_hdmi->variant->reset)
2581 vc4_hdmi->variant->reset(vc4_hdmi);
2583 if ((of_device_is_compatible(dev->of_node, "brcm,bcm2711-hdmi0") ||
2584 of_device_is_compatible(dev->of_node, "brcm,bcm2711-hdmi1")) &&
2585 HDMI_READ(HDMI_VID_CTL) & VC4_HD_VID_CTL_ENABLE) {
2586 clk_prepare_enable(vc4_hdmi->pixel_clock);
2587 clk_prepare_enable(vc4_hdmi->hsm_clock);
2588 clk_prepare_enable(vc4_hdmi->pixel_bvb_clock);
2591 drm_simple_encoder_init(drm, encoder, DRM_MODE_ENCODER_TMDS);
2592 drm_encoder_helper_add(encoder, &vc4_hdmi_encoder_helper_funcs);
2594 ret = vc4_hdmi_connector_init(drm, vc4_hdmi);
2596 goto err_destroy_encoder;
2598 ret = vc4_hdmi_hotplug_init(vc4_hdmi);
2600 goto err_destroy_conn;
2602 ret = vc4_hdmi_cec_init(vc4_hdmi);
2604 goto err_free_hotplug;
2606 ret = vc4_hdmi_audio_init(vc4_hdmi);
2610 vc4_debugfs_add_file(drm, variant->debugfs_name,
2611 vc4_hdmi_debugfs_regs,
2614 pm_runtime_put_sync(dev);
2619 vc4_hdmi_cec_exit(vc4_hdmi);
2621 vc4_hdmi_hotplug_exit(vc4_hdmi);
2623 vc4_hdmi_connector_destroy(&vc4_hdmi->connector);
2624 err_destroy_encoder:
2625 drm_encoder_cleanup(encoder);
2626 pm_runtime_put_sync(dev);
2627 pm_runtime_disable(dev);
2629 put_device(&vc4_hdmi->ddc->dev);
2634 static void vc4_hdmi_unbind(struct device *dev, struct device *master,
2637 struct vc4_hdmi *vc4_hdmi;
2640 * ASoC makes it a bit hard to retrieve a pointer to the
2641 * vc4_hdmi structure. Registering the card will overwrite our
2642 * device drvdata with a pointer to the snd_soc_card structure,
2643 * which can then be used to retrieve whatever drvdata we want
2646 * However, that doesn't fly in the case where we wouldn't
2647 * register an ASoC card (because of an old DT that is missing
2648 * the dmas properties for example), then the card isn't
2649 * registered and the device drvdata wouldn't be set.
2651 * We can deal with both cases by making sure a snd_soc_card
2652 * pointer and a vc4_hdmi structure are pointing to the same
2653 * memory address, so we can treat them indistinctly without any
2656 BUILD_BUG_ON(offsetof(struct vc4_hdmi_audio, card) != 0);
2657 BUILD_BUG_ON(offsetof(struct vc4_hdmi, audio) != 0);
2658 vc4_hdmi = dev_get_drvdata(dev);
2660 kfree(vc4_hdmi->hdmi_regset.regs);
2661 kfree(vc4_hdmi->hd_regset.regs);
2663 vc4_hdmi_cec_exit(vc4_hdmi);
2664 vc4_hdmi_hotplug_exit(vc4_hdmi);
2665 vc4_hdmi_connector_destroy(&vc4_hdmi->connector);
2666 drm_encoder_cleanup(&vc4_hdmi->encoder.base.base);
2668 pm_runtime_disable(dev);
2670 put_device(&vc4_hdmi->ddc->dev);
2673 static const struct component_ops vc4_hdmi_ops = {
2674 .bind = vc4_hdmi_bind,
2675 .unbind = vc4_hdmi_unbind,
2678 static int vc4_hdmi_dev_probe(struct platform_device *pdev)
2680 return component_add(&pdev->dev, &vc4_hdmi_ops);
2683 static int vc4_hdmi_dev_remove(struct platform_device *pdev)
2685 component_del(&pdev->dev, &vc4_hdmi_ops);
2689 static const struct vc4_hdmi_variant bcm2835_variant = {
2690 .encoder_type = VC4_ENCODER_TYPE_HDMI0,
2691 .debugfs_name = "hdmi_regs",
2692 .card_name = "vc4-hdmi",
2693 .max_pixel_clock = 162000000,
2694 .registers = vc4_hdmi_fields,
2695 .num_registers = ARRAY_SIZE(vc4_hdmi_fields),
2697 .init_resources = vc4_hdmi_init_resources,
2698 .csc_setup = vc4_hdmi_csc_setup,
2699 .reset = vc4_hdmi_reset,
2700 .set_timings = vc4_hdmi_set_timings,
2701 .phy_init = vc4_hdmi_phy_init,
2702 .phy_disable = vc4_hdmi_phy_disable,
2703 .phy_rng_enable = vc4_hdmi_phy_rng_enable,
2704 .phy_rng_disable = vc4_hdmi_phy_rng_disable,
2705 .channel_map = vc4_hdmi_channel_map,
2706 .supports_hdr = false,
2709 static const struct vc4_hdmi_variant bcm2711_hdmi0_variant = {
2710 .encoder_type = VC4_ENCODER_TYPE_HDMI0,
2711 .debugfs_name = "hdmi0_regs",
2712 .card_name = "vc4-hdmi-0",
2713 .max_pixel_clock = 600000000,
2714 .registers = vc5_hdmi_hdmi0_fields,
2715 .num_registers = ARRAY_SIZE(vc5_hdmi_hdmi0_fields),
2716 .phy_lane_mapping = {
2722 .unsupported_odd_h_timings = true,
2723 .external_irq_controller = true,
2725 .init_resources = vc5_hdmi_init_resources,
2726 .csc_setup = vc5_hdmi_csc_setup,
2727 .reset = vc5_hdmi_reset,
2728 .set_timings = vc5_hdmi_set_timings,
2729 .phy_init = vc5_hdmi_phy_init,
2730 .phy_disable = vc5_hdmi_phy_disable,
2731 .phy_rng_enable = vc5_hdmi_phy_rng_enable,
2732 .phy_rng_disable = vc5_hdmi_phy_rng_disable,
2733 .channel_map = vc5_hdmi_channel_map,
2734 .supports_hdr = true,
2735 .hp_detect = vc5_hdmi_hp_detect,
2738 static const struct vc4_hdmi_variant bcm2711_hdmi1_variant = {
2739 .encoder_type = VC4_ENCODER_TYPE_HDMI1,
2740 .debugfs_name = "hdmi1_regs",
2741 .card_name = "vc4-hdmi-1",
2742 .max_pixel_clock = HDMI_14_MAX_TMDS_CLK,
2743 .registers = vc5_hdmi_hdmi1_fields,
2744 .num_registers = ARRAY_SIZE(vc5_hdmi_hdmi1_fields),
2745 .phy_lane_mapping = {
2751 .unsupported_odd_h_timings = true,
2752 .external_irq_controller = true,
2754 .init_resources = vc5_hdmi_init_resources,
2755 .csc_setup = vc5_hdmi_csc_setup,
2756 .reset = vc5_hdmi_reset,
2757 .set_timings = vc5_hdmi_set_timings,
2758 .phy_init = vc5_hdmi_phy_init,
2759 .phy_disable = vc5_hdmi_phy_disable,
2760 .phy_rng_enable = vc5_hdmi_phy_rng_enable,
2761 .phy_rng_disable = vc5_hdmi_phy_rng_disable,
2762 .channel_map = vc5_hdmi_channel_map,
2763 .supports_hdr = true,
2764 .hp_detect = vc5_hdmi_hp_detect,
2767 static const struct of_device_id vc4_hdmi_dt_match[] = {
2768 { .compatible = "brcm,bcm2835-hdmi", .data = &bcm2835_variant },
2769 { .compatible = "brcm,bcm2711-hdmi0", .data = &bcm2711_hdmi0_variant },
2770 { .compatible = "brcm,bcm2711-hdmi1", .data = &bcm2711_hdmi1_variant },
2774 static const struct dev_pm_ops vc4_hdmi_pm_ops = {
2775 SET_RUNTIME_PM_OPS(vc4_hdmi_runtime_suspend,
2776 vc4_hdmi_runtime_resume,
2780 struct platform_driver vc4_hdmi_driver = {
2781 .probe = vc4_hdmi_dev_probe,
2782 .remove = vc4_hdmi_dev_remove,
2785 .of_match_table = vc4_hdmi_dt_match,
2786 .pm = &vc4_hdmi_pm_ops,