drm/vc4: hdmi: Support the 4k @ 60Hz modes
Subsystems (4)
v3 cover drm/vc4: hdmi: Support the 4k @ 60Hz modes
Hi,
Here is a series that enables the higher resolutions on the HDMI0 Controller found in the BCM2711 (RPi4).
In order to work it needs a few adjustments to config.txt, most notably to enable the enable_hdmi_4kp60 option.
The firmware also has a glitch at the moment and will not properly release the BSC controllers, which will make the EDID retrieval fail.
We can work around this using the following config.txt options:
disable_fw_kms_setup=1
hdmi_edid_file:0=1
hdmi_edid_filename:0=1366x768.bin
hdmi_ignore_edid:0=1
hdmi_edid_file:1=1
hdmi_edid_filename:1=1366x768.bin
hdmi_ignore_edid:1=1
A fix will come for the firmware eventually.
Let me know what you think,
Maxime
---
Changes from v2:
- Gathered the various tags
- Added Cc stable when relevant
- Split out the check to test whether the scrambler is required into an helper
- Fixed a bug where the scrambler state wouldn't be tracked properly if it was enabled at boot
Changes from v1:
- Dropped the range accessors
- Drop the mention of force_turbo
- Reordered the SCRAMBLER_CTL register to match the offset
- Removed duplicate HDMI_14_MAX_TMDS_CLK define
- Warn about enable_hdmi_4kp60 only if there's some modes that can't be reached
- Rework the BVB clock computation
Maxime Ripard (9):
drm/vc4: txp: Properly set the possible_crtcs mask drm/vc4: crtc: Skip the TXP
drm/vc4: Rework the encoder retrieval code
drm/vc4: hdmi: Prevent clock unbalance
drm/vc4: hvs: Make the HVS bind first
drm/vc4: hdmi: Properly compute the BVB clock rate drm/vc4: hdmi: Check and warn if we can't reach 4kp60 frequencies drm/vc4: hdmi: Enable the scrambler
drm/vc4: hdmi: Raise the maximum clock rate
drivers/gpu/drm/vc4/vc4_crtc.c | 28 ++++++- drivers/gpu/drm/vc4/vc4_drv.c | 47 ++++++++++- drivers/gpu/drm/vc4/vc4_drv.h | 10 +++ drivers/gpu/drm/vc4/vc4_hdmi.c | 122 ++++++++++++++++++++++++++-- drivers/gpu/drm/vc4/vc4_hdmi.h | 8 ++ drivers/gpu/drm/vc4/vc4_hdmi_regs.h | 3 + drivers/gpu/drm/vc4/vc4_txp.c | 2 +- 7 files changed, 207 insertions(+), 13 deletions(-)
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 1/9 drm/vc4: txp: Properly set the possible_crtcs mask
The current code does a binary OR on the possible_crtcs variable of the TXP encoder, while we want to set it to that value instead.
--- drivers/gpu/drm/vc4/vc4_txp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_txp.c +1 -1
@@ -507,7 +507,7 @@ static int vc4_txp_bind(struct device *dev, struct device *master, void *data)return ret; encoder = &txp->connector.encoder; - encoder->possible_crtcs |=drm_crtc_mask (crtc); + encoder->possible_crtcs =drm_crtc_mask (crtc); ret =devm_request_irq (dev, irq, vc4_txp_interrupt,0 ,dev_name (dev), txp);
Signature · 1 line
2.30.2
PATCH v3 2/9 drm/vc4: crtc: Skip the TXP
In reply to Maxime RipardThe vc4_set_crtc_possible_masks is meant to run over all the encoders and then set their possible_crtcs mask to their associated pixelvalve.
However, since the commit 39fcb2808376 ("drm/vc4: txp: Turn the TXP into a CRTC of its own"), the TXP has been turned to a CRTC and encoder of its own, and while it does indeed register an encoder, it no longer has an associated pixelvalve. The code will thus run over the TXP encoder and set a bogus possible_crtcs mask, overriding the one set in the TXP bind function.
In order to fix this, let's skip any virtual encoder.
--- drivers/gpu/drm/vc4/vc4_crtc.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/gpu/drm/vc4/vc4_crtc.c +3 -0
@@ -1018,6 +1018,9 @@ static void vc4_set_crtc_possible_masks(struct drm_device *drm,struct vc4_encoder *vc4_encoder;int i; +if (encoder->encoder_type ==DRM_MODE_ENCODER_VIRTUAL ) +continue ; + vc4_encoder =to_vc4_encoder (encoder);for (i =0 ; i <ARRAY_SIZE (pv_data->encoder_types); i++) {if (vc4_encoder->type == encoder_types[i]) {
Signature · 1 line
2.30.2
PATCH v3 3/9 drm/vc4: Rework the encoder retrieval code
In reply to Maxime RipardDue to a FIFO that cannot be flushed between the pixelvalve and the HDMI controllers on BCM2711, we need to carefully disable both at boot time if they were left enabled by the firmware.
However, at the time we're running that code, the struct drm_connector encoder pointer isn't set yet, and thus we cannot retrieve the encoder associated to our CRTC.
We can however make use of the fact that we have a less flexible setup than what DRM allows where we have a 1:1 relationship between our CRTCs and encoders (and connectors), and thus store the crtc associated to our encoder at boot time.
We cannot do that at the time the encoders are probed though, since the CRTCs won't be probed yet and thus we don't know at that time which CRTC index we're going to get, so let's do this in two passes: we can first bind all the components and then once they all are bound, we can iterate over all the encoders to find their associated CRTC and set the pointer.
This is similar to what we're doing to set the possible_crtcs field.
--- drivers/gpu/drm/vc4/vc4_crtc.c | 25 +++++++++++++++++++++-- drivers/gpu/drm/vc4/vc4_drv.c | 36 ++++++++++++++++++++++++++++++++++ drivers/gpu/drm/vc4/vc4_drv.h | 10 ++++++++++ 3 files changed, 69 insertions(+), 2 deletions(-)
drivers/gpu/drm/vc4/vc4_crtc.c +23 -2
@@ -255,6 +255,19 @@ static u32 vc4_crtc_get_fifo_full_level_bits(struct vc4_crtc *vc4_crtc, PV_CONTROL_FIFO_LEVEL); } +static struct drm_encoder *vc4_get_connector_encoder (struct drm_connector *connector) +{ +struct drm_encoder *encoder; + +if (drm_WARN_ON (connector->dev,hweight32 (connector->possible_encoders) !=1 )) +return NULL ; + +drm_connector_for_each_possible_encoder (connector, encoder) +return encoder; + +return NULL ; +} +/* * Returns the encoder attached to the CRTC. *
@@ -269,9 +282,17 @@ static struct drm_encoder *vc4_get_crtc_encoder(struct drm_crtc *crtc)drm_connector_list_iter_begin (crtc->dev, &conn_iter);drm_for_each_connector_iter (connector, &conn_iter) { -if (connector->state->crtc == crtc) { +struct drm_encoder *encoder; +struct vc4_encoder *vc4_encoder; + + encoder =vc4_get_connector_encoder (connector); +if (!encoder) +continue ; + + vc4_encoder =to_vc4_encoder (encoder); +if (vc4_encoder->crtc == crtc) {drm_connector_list_iter_end (&conn_iter); -return connector->encoder; +return encoder; } }drm_connector_list_iter_end (&conn_iter);
drivers/gpu/drm/vc4/vc4_drv.c +36 -0
@@ -199,6 +199,41 @@ static int compare_dev(struct device *dev, void *data)return dev == data; } +static struct drm_crtc *vc4_drv_find_crtc (struct drm_device *drm, +struct drm_encoder *encoder) +{ +struct drm_crtc *crtc; + +if (WARN_ON (hweight32 (encoder->possible_crtcs) !=1 )) +return NULL ; + +drm_for_each_crtc (crtc, drm) { +if (!drm_encoder_crtc_ok (encoder, crtc)) +continue ; + +return crtc; + } + +return NULL ; +} + +static void vc4_drv_set_encoder_data (struct drm_device *drm) +{ +struct drm_encoder *encoder; + +drm_for_each_encoder (encoder, drm) { +struct vc4_encoder *vc4_encoder; +struct drm_crtc *crtc; + + crtc =vc4_drv_find_crtc (drm, encoder); +if (WARN_ON (!crtc)) +return ; + + vc4_encoder =to_vc4_encoder (encoder); + vc4_encoder->crtc = crtc; + } +} + static void vc4_match_add_drivers(struct device *dev, struct component_match **match, struct platform_driver *const *drivers,
@@ -261,6 +296,7 @@ static int vc4_drm_bind(struct device *dev) ret =component_bind_all (dev, drm);if (ret)return ret; +vc4_drv_set_encoder_data (drm); ret =vc4_plane_create_additional_planes (drm);if (ret)
drivers/gpu/drm/vc4/vc4_drv.h +10 -0
@@ -438,6 +438,16 @@ enum vc4_encoder_type {struct vc4_encoder {struct drm_encoder base; + +/* +* At boot time, we need to be able to retrieve the CRTC for a given +* connector in order to run the disable hooks below to avoid the stuck +* pixel issue. Unfortunately the drm_connector->encoder pointer is +* NULL at that time so we can't move up the chain, so we'll store it +* ourselves here. +*/ +struct drm_crtc *crtc; +enum vc4_encoder_type type;u32 clock_select;
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 4/9 drm/vc4: hdmi: Prevent clock unbalance
In reply to Maxime RipardSince we fixed the hooks to disable the encoder at boot, we now have an unbalanced clk_disable call at boot since we never enabled them in the first place.
Let's mimic the state of the hardware and enable the clocks at boot if the controller is enabled to get the use-count right.
--- drivers/gpu/drm/vc4/vc4_hdmi.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/gpu/drm/vc4/vc4_hdmi.c +8 -0
@@ -1995,6 +1995,14 @@ static int vc4_hdmi_bind(struct device *dev, struct device *master, void *data)if (vc4_hdmi->variant->reset) vc4_hdmi->variant->reset (vc4_hdmi); +if ((of_device_is_compatible (dev->of_node,"brcm,bcm2711-hdmi0" ) || +of_device_is_compatible (dev->of_node,"brcm,bcm2711-hdmi1" )) && +HDMI_READ (HDMI_VID_CTL ) &VC4_HD_VID_CTL_ENABLE ) { +clk_prepare_enable (vc4_hdmi->pixel_clock); +clk_prepare_enable (vc4_hdmi->hsm_clock); +clk_prepare_enable (vc4_hdmi->pixel_bvb_clock); + } +pm_runtime_enable (dev);drm_simple_encoder_init (drm, encoder,DRM_MODE_ENCODER_TMDS );
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 5/9 drm/vc4: hvs: Make the HVS bind first
In reply to Maxime RipardWe'll need to have the HVS binding before the HDMI controllers so that we can check whether the firmware allows to run in 4kp60. Reorder a bit the component list, and document the current constraints we're aware of.
--- drivers/gpu/drm/vc4/vc4_drv.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_drv.c +10 -1
@@ -339,12 +339,21 @@ static const struct component_master_ops vc4_drm_ops = { .unbind = vc4_drm_unbind, }; +/* +* This list determines the binding order of our components, and we have +* a few constraints: +* - The TXP driver needs to be bound before the PixelValves (CRTC) +* but after the HVS to set the possible_crtc field properly +* - The HDMI driver needs to be bound after the HVS so that we can +* lookup the HVS maximum core clock rate and figure out if we +* support 4kp60 or not. +*/ static struct platform_driver *const component_drivers[] = { + &vc4_hvs_driver, &vc4_hdmi_driver, &vc4_vec_driver, &vc4_dpi_driver, &vc4_dsi_driver, - &vc4_hvs_driver, &vc4_txp_driver, &vc4_crtc_driver, &vc4_v3d_driver,
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 6/9 drm/vc4: hdmi: Properly compute the BVB clock rate
In reply to Maxime RipardThe BVB clock rate computation doesn't take into account a mode clock of 594MHz that we're going to need to support 4k60.
--- drivers/gpu/drm/vc4/vc4_hdmi.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)
drivers/gpu/drm/vc4/vc4_hdmi.c +9 -8
@@ -91,7 +91,6 @@# define VC4_HD_M_ENABLE BIT(0)#define CEC_CLOCK_FREQ 40000 -#define VC4_HSM_MID_CLOCK 149985000#define HDMI_14_MAX_TMDS_CLK (340 * 1000 * 1000)
@@ -739,7 +738,7 @@ static void vc4_hdmi_encoder_pre_crtc_configure(struct drm_encoder *encoder,conn_state_to_vc4_hdmi_conn_state (conn_state);struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;struct vc4_hdmi *vc4_hdmi =encoder_to_vc4_hdmi (encoder); -unsigned long pixel_rate, hsm_rate; +unsigned long bvb_rate, pixel_rate, hsm_rate;int ret; ret =pm_runtime_get_sync (&vc4_hdmi->pdev->dev);
@@ -793,12 +792,14 @@ static void vc4_hdmi_encoder_pre_crtc_configure(struct drm_encoder *encoder,vc4_hdmi_cec_update_clk_div (vc4_hdmi); -/* -* FIXME: When the pixel freq is 594MHz (4k60), this needs to be setup -* at 300MHz. -*/ - ret =clk_set_min_rate (vc4_hdmi->pixel_bvb_clock, - (hsm_rate >VC4_HSM_MID_CLOCK ?150000000 :75000000 )); +if (pixel_rate >297000000 ) + bvb_rate =300000000 ; +else if (pixel_rate >148500000 ) + bvb_rate =150000000 ; +else + bvb_rate =75000000 ; + + ret =clk_set_min_rate (vc4_hdmi->pixel_bvb_clock, bvb_rate);if (ret) {DRM_ERROR ("Failed to set pixel bvb clock rate: %d\n" , ret);clk_disable_unprepare (vc4_hdmi->hsm_clock);
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 7/9 drm/vc4: hdmi: Check and warn if we can't reach 4kp60 frequencies
In reply to Maxime RipardIn order to reach the frequencies needed to output at 594MHz, the firmware needs to be configured with the appropriate parameters in the config.txt file (enable_hdmi_4kp60 and force_turbo).
Let's detect it at bind time, warn the user if we can't, and filter out the relevant modes.
--- drivers/gpu/drm/vc4/vc4_hdmi.c | 31 +++++++++++++++++++++++++++++++ drivers/gpu/drm/vc4/vc4_hdmi.h | 8 ++++++++ 2 files changed, 39 insertions(+)
drivers/gpu/drm/vc4/vc4_hdmi.c +31 -0
@@ -94,6 +94,11 @@#define HDMI_14_MAX_TMDS_CLK (340 * 1000 * 1000) +static bool vc4_hdmi_mode_needs_scrambling (const struct drm_display_mode *mode) +{ +return (mode->clock *1000 ) >HDMI_14_MAX_TMDS_CLK ; +} +static int vc4_hdmi_debugfs_regs (struct seq_file *m,void *unused) {struct drm_info_node *node = (struct drm_info_node *)m->private;
@@ -210,6 +215,18 @@ static int vc4_hdmi_connector_get_modes(struct drm_connector *connector) ret =drm_add_edid_modes (connector, edid);kfree (edid); +if (vc4_hdmi->disable_4kp60) { +struct drm_device *drm = connector->dev; +struct drm_display_mode *mode; + +list_for_each_entry (mode, &connector->probed_modes, head) { +if (vc4_hdmi_mode_needs_scrambling (mode)) { +drm_warn_once (drm,"The core clock cannot reach frequencies high enough to support 4k @ 60Hz." ); +drm_warn_once (drm,"Please change your config.txt file to add hdmi_enable_4kp60." ); + } + } + } +return ret; }
@@ -959,6 +976,9 @@ static int vc4_hdmi_encoder_atomic_check(struct drm_encoder *encoder,if (pixel_rate > vc4_hdmi->variant->max_pixel_clock)return -EINVAL ; +if (vc4_hdmi->disable_4kp60 && (pixel_rate >HDMI_14_MAX_TMDS_CLK )) +return -EINVAL ; + vc4_state->pixel_rate = pixel_rate;return 0 ;
@@ -978,6 +998,9 @@ vc4_hdmi_encoder_mode_valid(struct drm_encoder *encoder,if ((mode->clock *1000 ) > vc4_hdmi->variant->max_pixel_clock)return MODE_CLOCK_HIGH ; +if (vc4_hdmi->disable_4kp60 &&vc4_hdmi_mode_needs_scrambling (mode)) +return MODE_CLOCK_HIGH ; +return MODE_OK ; }
@@ -1993,6 +2016,14 @@ static int vc4_hdmi_bind(struct device *dev, struct device *master, void *data) vc4_hdmi->disable_wifi_frequencies =of_property_read_bool (dev->of_node,"wifi-2.4ghz-coexistence" ); +if (variant->max_pixel_clock ==600000000 ) { +struct vc4_dev *vc4 =to_vc4_dev (drm); +long max_rate =clk_round_rate (vc4->hvs->core_clk,550000000 ); + +if (max_rate <550000000 ) + vc4_hdmi->disable_4kp60 = true; + } +if (vc4_hdmi->variant->reset) vc4_hdmi->variant->reset (vc4_hdmi);
drivers/gpu/drm/vc4/vc4_hdmi.h +8 -0
@@ -154,6 +154,14 @@ struct vc4_hdmi {*/ bool disable_wifi_frequencies; +/* +* Even if HDMI0 on the RPi4 can output modes requiring a pixel +* rate higher than 297MHz, it needs some adjustments in the +* config.txt file to be able to do so and thus won't always be +* available. +*/ +bool disable_4kp60; +struct cec_adapter *cec_adap;struct cec_msg cec_rx_msg;bool cec_tx_ok;
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 8/9 drm/vc4: hdmi: Enable the scrambler
In reply to Maxime RipardThe HDMI controller on the BCM2711 includes a scrambler in order to reach the HDMI 2.0 modes that require it. Let's add the support for it.
--- drivers/gpu/drm/vc4/vc4_hdmi.c | 64 +++++++++++++++++++++++++++++ drivers/gpu/drm/vc4/vc4_hdmi_regs.h | 3 ++ 2 files changed, 67 insertions(+)
drivers/gpu/drm/vc4/vc4_hdmi.c +64 -0
@@ -35,6 +35,7 @@#include <drm/drm_edid.h> #include <drm/drm_probe_helper.h> #include <drm/drm_simple_kms_helper.h> +#include <drm/drm_scdc_helper.h> #include <linux/clk.h> #include <linux/component.h> #include <linux/i2c.h>
@@ -76,6 +77,8 @@#define VC5_HDMI_VERTB_VSPO_SHIFT 16#define VC5_HDMI_VERTB_VSPO_MASK VC4_MASK(29, 16) +#define VC5_HDMI_SCRAMBLER_CTL_ENABLE BIT(0) +#define VC5_HDMI_DEEP_COLOR_CONFIG_1_INIT_PACK_PHASE_SHIFT 8#define VC5_HDMI_DEEP_COLOR_CONFIG_1_INIT_PACK_PHASE_MASK VC4_MASK(10, 8)
@@ -462,6 +465,64 @@ static void vc4_hdmi_set_infoframes(struct drm_encoder *encoder)vc4_hdmi_set_audio_infoframe (encoder); } +static bool vc4_hdmi_supports_scrambling (struct drm_encoder *encoder, +struct drm_display_mode *mode) +{ +struct vc4_hdmi_encoder *vc4_encoder =to_vc4_hdmi_encoder (encoder); +struct vc4_hdmi *vc4_hdmi =encoder_to_vc4_hdmi (encoder); +struct drm_display_info *display = &vc4_hdmi->connector.display_info; + +if (!vc4_encoder->hdmi_monitor) +return false; + +if (!display->hdmi.scdc.supported || + !display->hdmi.scdc.scrambling.supported) +return false; + +return true; +} + +static void vc4_hdmi_enable_scrambling (struct drm_encoder *encoder) +{ +struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode; +struct vc4_hdmi *vc4_hdmi =encoder_to_vc4_hdmi (encoder); + +if (!vc4_hdmi_supports_scrambling (encoder, mode)) +return ; + +if (!vc4_hdmi_mode_needs_scrambling (mode)) +return ; + +drm_scdc_set_high_tmds_clock_ratio (vc4_hdmi->ddc, true); +drm_scdc_set_scrambling (vc4_hdmi->ddc, true); + +HDMI_WRITE (HDMI_SCRAMBLER_CTL ,HDMI_READ (HDMI_SCRAMBLER_CTL ) | +VC5_HDMI_SCRAMBLER_CTL_ENABLE ); +} + +static void vc4_hdmi_disable_scrambling (struct drm_encoder *encoder) +{ +struct vc4_hdmi *vc4_hdmi =encoder_to_vc4_hdmi (encoder); +struct drm_crtc *crtc = encoder->crtc; + +/* +* At boot, encoder->crtc will be NULL. Since we don't know the +* state of the scrambler and in order to avoid any +* inconsistency, let's disable it all the time. +*/ +if (crtc && !vc4_hdmi_supports_scrambling (encoder, &crtc->mode)) +return ; + +if (crtc && !vc4_hdmi_mode_needs_scrambling (&crtc->mode)) +return ; + +HDMI_WRITE (HDMI_SCRAMBLER_CTL ,HDMI_READ (HDMI_SCRAMBLER_CTL ) & + ~VC5_HDMI_SCRAMBLER_CTL_ENABLE ); + +drm_scdc_set_scrambling (vc4_hdmi->ddc, false); +drm_scdc_set_high_tmds_clock_ratio (vc4_hdmi->ddc, false); +} +static void vc4_hdmi_encoder_post_crtc_disable (struct drm_encoder *encoder,struct drm_atomic_state *state) {
@@ -474,6 +535,8 @@ static void vc4_hdmi_encoder_post_crtc_disable(struct drm_encoder *encoder,HDMI_WRITE (HDMI_VID_CTL ,HDMI_READ (HDMI_VID_CTL ) |VC4_HD_VID_CTL_BLANKPIX ); + +vc4_hdmi_disable_scrambling (encoder); } static void vc4_hdmi_encoder_post_crtc_powerdown(struct drm_encoder *encoder,
@@ -924,6 +987,7 @@ static void vc4_hdmi_encoder_post_crtc_enable(struct drm_encoder *encoder, }vc4_hdmi_recenter_fifo (vc4_hdmi); +vc4_hdmi_enable_scrambling (encoder); }static void vc4_hdmi_encoder_enable (struct drm_encoder *encoder)
drivers/gpu/drm/vc4/vc4_hdmi_regs.h +3 -0
@@ -100,6 +100,7 @@ enum vc4_hdmi_field {HDMI_RM_FORMAT ,HDMI_RM_OFFSET ,HDMI_SCHEDULER_CONTROL , +HDMI_SCRAMBLER_CTL ,HDMI_SW_RESET_CONTROL ,HDMI_TX_PHY_CHANNEL_SWAP , HDMI_TX_PHY_CLK_DIV,
@@ -238,6 +239,7 @@ static const struct vc4_hdmi_register __maybe_unused vc5_hdmi_hdmi0_fields[] = {VC4_HDMI_REG (HDMI_GCP_CONFIG ,0x178 ),VC4_HDMI_REG (HDMI_GCP_WORD_1 ,0x17c ),VC4_HDMI_REG (HDMI_HOTPLUG ,0x1a8 ), +VC4_HDMI_REG (HDMI_SCRAMBLER_CTL ,0x1c4 ),VC5_DVP_REG (HDMI_CLOCK_STOP ,0x0bc ), VC5_DVP_REG(HDMI_VEC_INTERFACE_XBAR, 0x0f0),
@@ -317,6 +319,7 @@ static const struct vc4_hdmi_register __maybe_unused vc5_hdmi_hdmi1_fields[] = {VC4_HDMI_REG (HDMI_GCP_CONFIG ,0x178 ),VC4_HDMI_REG (HDMI_GCP_WORD_1 ,0x17c ),VC4_HDMI_REG (HDMI_HOTPLUG ,0x1a8 ), +VC4_HDMI_REG (HDMI_SCRAMBLER_CTL ,0x1c4 ),VC5_DVP_REG (HDMI_CLOCK_STOP ,0x0bc ), VC5_DVP_REG(HDMI_VEC_INTERFACE_XBAR, 0x0f0),
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v3 9/9 drm/vc4: hdmi: Raise the maximum clock rate
In reply to Maxime RipardNow that we have the infrastructure in place, we can raise the maximum pixel rate we can reach for HDMI0 on the BCM2711.
HDMI1 is left untouched since its pixelvalve has a smaller FIFO and would need a clock faster than what we can provide to support the same modes.
--- drivers/gpu/drm/vc4/vc4_hdmi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/vc4/vc4_hdmi.c +1 -1
@@ -2212,7 +2212,7 @@ static const struct vc4_hdmi_variant bcm2711_hdmi0_variant = { .encoder_type = VC4_ENCODER_TYPE_HDMI0, .debugfs_name = "hdmi0_regs", .card_name = "vc4-hdmi-0", - .max_pixel_clock = HDMI_14_MAX_TMDS_CLK, + .max_pixel_clock = 600000000, .registers = vc5_hdmi_hdmi0_fields, .num_registers = ARRAY_SIZE(vc5_hdmi_hdmi0_fields), .phy_lane_mapping = {
Signature · 6 lines
2.30.2 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel