| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * Copyright (C) 2025 Icenowy Zheng <uwu@icenowy.me> |
| */ |
| |
| #include <linux/of.h> |
| #include <linux/regmap.h> |
| |
| #include <uapi/linux/media-bus-format.h> |
| |
| #include <drm/drm_atomic.h> |
| #include <drm/drm_atomic_helper.h> |
| #include <drm/drm_bridge.h> |
| #include <drm/drm_bridge_connector.h> |
| #include <drm/drm_connector.h> |
| #include <drm/drm_encoder.h> |
| #include <drm/drm_of.h> |
| #include <drm/drm_print.h> |
| #include <drm/drm_simple_kms_helper.h> |
| |
| #include "vs_bridge.h" |
| #include "vs_bridge_regs.h" |
| #include "vs_crtc.h" |
| #include "vs_dc.h" |
| |
| static int vs_bridge_attach(struct drm_bridge *bridge, |
| struct drm_encoder *encoder, |
| enum drm_bridge_attach_flags flags) |
| { |
| struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge); |
| |
| return drm_bridge_attach(encoder, vbridge->next_bridge, |
| bridge, flags); |
| } |
| |
| struct vsdc_dp_format { |
| u32 linux_fmt; |
| bool is_yuv; |
| u32 vsdc_fmt; |
| }; |
| |
| static struct vsdc_dp_format vsdc_dp_supported_fmts[] = { |
| /* default to RGB888 */ |
| { MEDIA_BUS_FMT_FIXED, false, VSDC_DISP_DP_CONFIG_FMT_RGB888 }, |
| { MEDIA_BUS_FMT_RGB888_1X24, false, VSDC_DISP_DP_CONFIG_FMT_RGB888 }, |
| { MEDIA_BUS_FMT_RGB565_1X16, false, VSDC_DISP_DP_CONFIG_FMT_RGB565 }, |
| { MEDIA_BUS_FMT_RGB666_1X18, false, VSDC_DISP_DP_CONFIG_FMT_RGB666 }, |
| { MEDIA_BUS_FMT_RGB101010_1X30, |
| false, VSDC_DISP_DP_CONFIG_FMT_RGB101010 }, |
| { MEDIA_BUS_FMT_UYVY8_1X16, true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYVY8 }, |
| { MEDIA_BUS_FMT_UYVY10_1X20, true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYVY10 }, |
| { MEDIA_BUS_FMT_YUV8_1X24, true, VSDC_DISP_DP_CONFIG_YUV_FMT_YUV8 }, |
| { MEDIA_BUS_FMT_YUV10_1X30, true, VSDC_DISP_DP_CONFIG_YUV_FMT_YUV10 }, |
| { MEDIA_BUS_FMT_UYYVYY8_0_5X24, |
| true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYYVYY8 }, |
| { MEDIA_BUS_FMT_UYYVYY10_0_5X30, |
| true, VSDC_DISP_DP_CONFIG_YUV_FMT_UYYVYY10 }, |
| }; |
| |
| static u32 *vs_bridge_atomic_get_output_bus_fmts_dpi(struct drm_bridge *bridge, |
| struct drm_bridge_state *bridge_state, |
| struct drm_crtc_state *crtc_state, |
| struct drm_connector_state *conn_state, |
| unsigned int *num_output_fmts) |
| { |
| u32 *output_fmts; |
| |
| *num_output_fmts = 2; |
| |
| output_fmts = kcalloc(*num_output_fmts, sizeof(*output_fmts), |
| GFP_KERNEL); |
| if (!output_fmts) |
| return NULL; |
| |
| /* TODO: support more DPI output formats */ |
| output_fmts[0] = MEDIA_BUS_FMT_RGB888_1X24; |
| output_fmts[1] = MEDIA_BUS_FMT_FIXED; |
| |
| return output_fmts; |
| } |
| |
| static u32 *vs_bridge_atomic_get_output_bus_fmts_dp(struct drm_bridge *bridge, |
| struct drm_bridge_state *bridge_state, |
| struct drm_crtc_state *crtc_state, |
| struct drm_connector_state *conn_state, |
| unsigned int *num_output_fmts) |
| { |
| u32 *output_fmts; |
| unsigned int i; |
| |
| *num_output_fmts = ARRAY_SIZE(vsdc_dp_supported_fmts); |
| |
| output_fmts = kcalloc(*num_output_fmts, sizeof(*output_fmts), |
| GFP_KERNEL); |
| if (!output_fmts) |
| return NULL; |
| |
| for (i = 0; i < *num_output_fmts; i++) |
| output_fmts[i] = vsdc_dp_supported_fmts[i].linux_fmt; |
| |
| return output_fmts; |
| } |
| |
| static bool vs_bridge_out_dp_fmt_supported(u32 out_fmt) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < ARRAY_SIZE(vsdc_dp_supported_fmts); i++) |
| if (vsdc_dp_supported_fmts[i].linux_fmt == out_fmt) |
| return true; |
| |
| return false; |
| } |
| |
| static u32 *vs_bridge_atomic_get_input_bus_fmts_dp(struct drm_bridge *bridge, |
| struct drm_bridge_state *bridge_state, |
| struct drm_crtc_state *crtc_state, |
| struct drm_connector_state *conn_state, |
| u32 output_fmt, |
| unsigned int *num_input_fmts) |
| { |
| if (!vs_bridge_out_dp_fmt_supported(output_fmt)) { |
| *num_input_fmts = 0; |
| return NULL; |
| } |
| |
| return drm_atomic_helper_bridge_propagate_bus_fmt(bridge, bridge_state, |
| crtc_state, |
| conn_state, |
| output_fmt, |
| num_input_fmts); |
| } |
| |
| static int vs_bridge_atomic_check_dp(struct drm_bridge *bridge, |
| struct drm_bridge_state *bridge_state, |
| struct drm_crtc_state *crtc_state, |
| struct drm_connector_state *conn_state) |
| { |
| if (!vs_bridge_out_dp_fmt_supported(bridge_state->output_bus_cfg.format)) |
| return -EINVAL; |
| |
| return 0; |
| } |
| |
| static void vs_bridge_enable_common(struct vs_crtc *crtc, |
| struct drm_bridge_state *br_state) |
| { |
| struct vs_dc *dc = crtc->dc; |
| unsigned int output = crtc->id; |
| |
| regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_DAT_POL); |
| regmap_assign_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_DE_POL, |
| br_state->output_bus_cfg.flags & |
| DRM_BUS_FLAG_DE_LOW); |
| regmap_assign_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_CLK_POL, |
| br_state->output_bus_cfg.flags & |
| DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE); |
| regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_DE_EN | |
| VSDC_DISP_PANEL_CONFIG_DAT_EN | |
| VSDC_DISP_PANEL_CONFIG_CLK_EN); |
| regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_RUNNING); |
| regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_START, |
| VSDC_DISP_PANEL_START_MULTI_DISP_SYNC); |
| regmap_set_bits(dc->regs, VSDC_DISP_PANEL_START, |
| VSDC_DISP_PANEL_START_RUNNING(output)); |
| |
| regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG_EX(crtc->id), |
| VSDC_DISP_PANEL_CONFIG_EX_COMMIT); |
| } |
| |
| static void vs_bridge_atomic_enable_dpi(struct drm_bridge *bridge, |
| struct drm_atomic_state *state) |
| { |
| struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge); |
| struct drm_bridge_state *br_state = |
| drm_atomic_get_new_bridge_state(state, bridge); |
| struct vs_crtc *crtc = vbridge->crtc; |
| struct vs_dc *dc = crtc->dc; |
| unsigned int output = crtc->id; |
| |
| regmap_clear_bits(dc->regs, VSDC_DISP_DP_CONFIG(output), |
| VSDC_DISP_DP_CONFIG_DP_EN); |
| regmap_write(dc->regs, VSDC_DISP_DPI_CONFIG(output), |
| VSDC_DISP_DPI_CONFIG_FMT_RGB888); |
| |
| vs_bridge_enable_common(crtc, br_state); |
| } |
| |
| static void vs_bridge_atomic_enable_dp(struct drm_bridge *bridge, |
| struct drm_atomic_state *state) |
| { |
| struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge); |
| struct drm_bridge_state *br_state = |
| drm_atomic_get_new_bridge_state(state, bridge); |
| struct vs_crtc *crtc = vbridge->crtc; |
| struct vs_dc *dc = crtc->dc; |
| unsigned int output = crtc->id; |
| u32 dp_fmt; |
| unsigned int i; |
| |
| for (i = 0; i < ARRAY_SIZE(vsdc_dp_supported_fmts); i++) { |
| if (vsdc_dp_supported_fmts[i].linux_fmt == |
| br_state->output_bus_cfg.format) |
| break; |
| } |
| if (WARN_ON_ONCE(i == ARRAY_SIZE(vsdc_dp_supported_fmts))) |
| return; |
| dp_fmt = vsdc_dp_supported_fmts[i].vsdc_fmt; |
| dp_fmt |= VSDC_DISP_DP_CONFIG_DP_EN; |
| regmap_write(dc->regs, VSDC_DISP_DP_CONFIG(output), dp_fmt); |
| regmap_assign_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_YUV, |
| vsdc_dp_supported_fmts[i].is_yuv); |
| |
| vs_bridge_enable_common(crtc, br_state); |
| } |
| |
| static void vs_bridge_atomic_disable(struct drm_bridge *bridge, |
| struct drm_atomic_state *state) |
| { |
| struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge); |
| struct vs_crtc *crtc = vbridge->crtc; |
| struct vs_dc *dc = crtc->dc; |
| unsigned int output = crtc->id; |
| |
| regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_START, |
| VSDC_DISP_PANEL_START_MULTI_DISP_SYNC | |
| VSDC_DISP_PANEL_START_RUNNING(output)); |
| regmap_clear_bits(dc->regs, VSDC_DISP_PANEL_CONFIG(output), |
| VSDC_DISP_PANEL_CONFIG_RUNNING); |
| |
| regmap_set_bits(dc->regs, VSDC_DISP_PANEL_CONFIG_EX(crtc->id), |
| VSDC_DISP_PANEL_CONFIG_EX_COMMIT); |
| } |
| |
| static const struct drm_bridge_funcs vs_dpi_bridge_funcs = { |
| .attach = vs_bridge_attach, |
| .atomic_enable = vs_bridge_atomic_enable_dpi, |
| .atomic_disable = vs_bridge_atomic_disable, |
| .atomic_get_input_bus_fmts = drm_atomic_helper_bridge_propagate_bus_fmt, |
| .atomic_get_output_bus_fmts = vs_bridge_atomic_get_output_bus_fmts_dpi, |
| .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, |
| .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, |
| .atomic_reset = drm_atomic_helper_bridge_reset, |
| }; |
| |
| static const struct drm_bridge_funcs vs_dp_bridge_funcs = { |
| .attach = vs_bridge_attach, |
| .atomic_enable = vs_bridge_atomic_enable_dp, |
| .atomic_disable = vs_bridge_atomic_disable, |
| .atomic_check = vs_bridge_atomic_check_dp, |
| .atomic_get_input_bus_fmts = vs_bridge_atomic_get_input_bus_fmts_dp, |
| .atomic_get_output_bus_fmts = vs_bridge_atomic_get_output_bus_fmts_dp, |
| .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, |
| .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, |
| .atomic_reset = drm_atomic_helper_bridge_reset, |
| }; |
| |
| static int vs_bridge_detect_output_interface(struct device_node *of_node, |
| unsigned int output) |
| { |
| int ret; |
| struct device_node *remote; |
| |
| remote = of_graph_get_remote_node(of_node, output, |
| VSDC_OUTPUT_INTERFACE_DPI); |
| if (remote) { |
| ret = VSDC_OUTPUT_INTERFACE_DPI; |
| } else { |
| remote = of_graph_get_remote_node(of_node, output, |
| VSDC_OUTPUT_INTERFACE_DP); |
| if (remote) |
| ret = VSDC_OUTPUT_INTERFACE_DP; |
| else |
| ret = -ENODEV; |
| } |
| |
| if (remote) |
| of_node_put(remote); |
| |
| return ret; |
| } |
| |
| struct vs_bridge *vs_bridge_init(struct drm_device *drm_dev, |
| struct vs_crtc *crtc) |
| { |
| unsigned int output = crtc->id; |
| struct vs_bridge *bridge; |
| struct drm_bridge *next; |
| enum vs_bridge_output_interface intf; |
| const struct drm_bridge_funcs *bridge_funcs; |
| int ret, enctype; |
| |
| intf = vs_bridge_detect_output_interface(drm_dev->dev->of_node, |
| output); |
| if (intf == -ENODEV) { |
| drm_dbg(drm_dev, "Skipping output %u\n", output); |
| return NULL; |
| } |
| |
| next = devm_drm_of_get_bridge(drm_dev->dev, drm_dev->dev->of_node, |
| output, intf); |
| if (IS_ERR(next)) { |
| ret = PTR_ERR(next); |
| if (ret != -EPROBE_DEFER) |
| drm_err(drm_dev, |
| "Cannot get downstream bridge of output %u\n", |
| output); |
| return ERR_PTR(ret); |
| } |
| |
| if (intf == VSDC_OUTPUT_INTERFACE_DPI) |
| bridge_funcs = &vs_dpi_bridge_funcs; |
| else |
| bridge_funcs = &vs_dp_bridge_funcs; |
| |
| bridge = devm_drm_bridge_alloc(drm_dev->dev, struct vs_bridge, base, |
| bridge_funcs); |
| if (IS_ERR(bridge)) |
| return ERR_PTR(PTR_ERR(bridge)); |
| |
| bridge->crtc = crtc; |
| bridge->intf = intf; |
| bridge->next_bridge = next; |
| |
| if (intf == VSDC_OUTPUT_INTERFACE_DPI) |
| enctype = DRM_MODE_ENCODER_DPI; |
| else |
| enctype = DRM_MODE_ENCODER_NONE; |
| |
| bridge->enc = drmm_plain_encoder_alloc(drm_dev, NULL, enctype, NULL); |
| if (IS_ERR(bridge->enc)) { |
| drm_err(drm_dev, |
| "Cannot initialize encoder for output %u\n", output); |
| ret = PTR_ERR(bridge->enc); |
| return ERR_PTR(ret); |
| } |
| |
| bridge->enc->possible_crtcs = drm_crtc_mask(&crtc->base); |
| |
| ret = devm_drm_bridge_add(drm_dev->dev, &bridge->base); |
| if (ret) { |
| drm_err(drm_dev, |
| "Cannot add bridge for output %u\n", output); |
| return ERR_PTR(ret); |
| } |
| |
| ret = drm_bridge_attach(bridge->enc, &bridge->base, NULL, |
| DRM_BRIDGE_ATTACH_NO_CONNECTOR); |
| if (ret) { |
| drm_err(drm_dev, |
| "Cannot attach bridge for output %u\n", output); |
| return ERR_PTR(ret); |
| } |
| |
| bridge->conn = drm_bridge_connector_init(drm_dev, bridge->enc); |
| if (IS_ERR(bridge->conn)) { |
| drm_err(drm_dev, |
| "Cannot create connector for output %u\n", output); |
| ret = PTR_ERR(bridge->conn); |
| return ERR_PTR(ret); |
| } |
| drm_connector_attach_encoder(bridge->conn, bridge->enc); |
| |
| return bridge; |
| } |
