// SPDX-License-Identifier: GPL-2.0-or-later
|
/*
|
* serdes-bridge.c -- drm bridge access for different serdes chips
|
*
|
* Copyright (c) 2023-2028 Rockchip Electronics Co. Ltd.
|
*
|
* Author: luowei <lw@rock-chips.com>
|
*/
|
|
#include "core.h"
|
|
static struct serdes_bridge *to_serdes_bridge(struct drm_bridge *bridge)
|
{
|
return container_of(bridge, struct serdes_bridge, base_bridge);
|
}
|
|
static struct mipi_dsi_device *serdes_attach_dsi(struct serdes_bridge *serdes_bridge,
|
struct device_node *dsi_node)
|
{
|
struct mipi_dsi_device_info info = { "serdes", 0, NULL };
|
struct serdes *serdes = serdes_bridge->parent;
|
struct mipi_dsi_device *dsi;
|
struct mipi_dsi_host *host;
|
int ret;
|
|
if (serdes->chip_data->name)
|
memcpy(&info.type, serdes->chip_data->name, ARRAY_SIZE(info.type));
|
|
SERDES_DBG_MFD("%s: type=%s, name=%s\n", __func__,
|
info.type, serdes->chip_data->name);
|
|
host = of_find_mipi_dsi_host_by_node(dsi_node);
|
if (!host) {
|
dev_err(serdes_bridge->dev, "failed to find serdes dsi host\n");
|
return ERR_PTR(-EPROBE_DEFER);
|
}
|
|
dsi = mipi_dsi_device_register_full(host, &info);
|
if (IS_ERR(dsi)) {
|
dev_err(serdes_bridge->dev, "failed to create serdes dsi device\n");
|
return dsi;
|
}
|
|
dsi->lanes = 4;
|
dsi->format = MIPI_DSI_FMT_RGB888;
|
|
if (serdes->chip_data->name) {
|
if ((!strcmp(serdes->chip_data->name, "bu18tl82")) ||
|
(!strcmp(serdes->chip_data->name, "bu18rl82"))) {
|
dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST |
|
MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_EOT_PACKET;
|
SERDES_DBG_MFD("%s: dsi mode MIPI_DSI_MODE_VIDEO_BURST 0x%lx\n",
|
__func__, dsi->mode_flags);
|
}
|
} else {
|
dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE;
|
SERDES_DBG_MFD("%s: dsi mode MIPI_DSI_MODE_VIDEO_SYNC_PULSE 0x%lx\n",
|
__func__, dsi->mode_flags);
|
}
|
|
ret = mipi_dsi_attach(dsi);
|
if (ret < 0) {
|
dev_err(serdes_bridge->dev, "failed to attach serdes dsi to host\n");
|
mipi_dsi_device_unregister(dsi);
|
return ERR_PTR(ret);
|
}
|
|
return dsi;
|
}
|
|
static int serdes_bridge_attach(struct drm_bridge *bridge,
|
enum drm_bridge_attach_flags flags)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
int ret = 0;
|
|
ret = drm_of_find_panel_or_bridge(bridge->of_node, 1, -1,
|
&serdes_bridge->panel, &serdes_bridge->next_bridge);
|
if (ret) {
|
dev_err(serdes_bridge->dev->parent, "failed to find serdes bridge, ret=%d\n", ret);
|
return ret;
|
}
|
|
if (serdes_bridge->sel_mipi) {
|
dev_info(serdes_bridge->dev->parent, "serdes sel_mipi %d\n",
|
serdes_bridge->sel_mipi);
|
/* Attach primary DSI */
|
serdes_bridge->dsi = serdes_attach_dsi(serdes_bridge, serdes_bridge->dsi_node);
|
if (IS_ERR(serdes_bridge->dsi))
|
return PTR_ERR(serdes_bridge->dsi);
|
}
|
|
if (serdes_bridge->next_bridge) {
|
ret = drm_bridge_attach(bridge->encoder, serdes_bridge->next_bridge,
|
bridge, flags);
|
if (ret) {
|
if (serdes_bridge->sel_mipi)
|
mipi_dsi_device_unregister(serdes_bridge->dsi);
|
|
dev_err(serdes_bridge->dev->parent,
|
"failed to attach bridge, ret=%d\n", ret);
|
return ret;
|
}
|
}
|
|
if (serdes->chip_data->bridge_ops->attach)
|
ret = serdes->chip_data->bridge_ops->attach(serdes);
|
|
SERDES_DBG_MFD("%s: ret=%d\n", __func__, ret);
|
|
return ret;
|
}
|
|
static void serdes_bridge_detach(struct drm_bridge *bridge)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
|
if (serdes_bridge->sel_mipi) {
|
mipi_dsi_detach(serdes_bridge->dsi);
|
mipi_dsi_device_unregister(serdes_bridge->dsi);
|
}
|
|
SERDES_DBG_MFD("%s\n", __func__);
|
}
|
|
static void serdes_bridge_disable(struct drm_bridge *bridge)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
int ret = 0;
|
|
if (serdes_bridge->panel)
|
drm_panel_disable(serdes_bridge->panel);
|
|
if (serdes->chip_data->bridge_ops->disable)
|
ret = serdes->chip_data->bridge_ops->disable(serdes);
|
|
extcon_set_state_sync(serdes->extcon, EXTCON_JACK_VIDEO_OUT, false);
|
|
SERDES_DBG_MFD("%s: ret=%d\n", __func__, ret);
|
}
|
|
static void serdes_bridge_post_disable(struct drm_bridge *bridge)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
int ret = 0;
|
|
serdes_set_pinctrl_sleep(serdes);
|
|
if (serdes_bridge->panel)
|
ret = drm_panel_unprepare(serdes_bridge->panel);
|
|
if (serdes->chip_data->bridge_ops->post_disable)
|
ret = serdes->chip_data->bridge_ops->post_disable(serdes);
|
|
SERDES_DBG_MFD("%s: ret=%d\n", __func__, ret);
|
}
|
|
static void serdes_bridge_pre_enable(struct drm_bridge *bridge)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
int ret = 0;
|
|
if (serdes->chip_data->bridge_ops->init)
|
ret = serdes->chip_data->bridge_ops->init(serdes);
|
|
if (serdes->chip_data->serdes_type == TYPE_DES)
|
serdes_i2c_set_sequence(serdes);
|
|
if (serdes_bridge->panel)
|
ret = drm_panel_prepare(serdes_bridge->panel);
|
|
if (serdes->chip_data->bridge_ops->pre_enable)
|
ret = serdes->chip_data->bridge_ops->pre_enable(serdes);
|
|
serdes_set_pinctrl_default(serdes);
|
|
SERDES_DBG_MFD("%s: %s ret=%d\n", __func__, dev_name(serdes->dev), ret);
|
}
|
|
static void serdes_bridge_enable(struct drm_bridge *bridge)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
int ret = 0;
|
|
if (serdes_bridge->panel)
|
ret = drm_panel_enable(serdes_bridge->panel);
|
|
if (serdes->chip_data->bridge_ops->enable)
|
ret = serdes->chip_data->bridge_ops->enable(serdes);
|
|
if (!ret) {
|
extcon_set_state_sync(serdes->extcon, EXTCON_JACK_VIDEO_OUT, true);
|
SERDES_DBG_MFD("%s: extcon is true\n", __func__);
|
}
|
|
SERDES_DBG_MFD("%s: %s ret=%d\n", __func__, dev_name(serdes->dev), ret);
|
}
|
|
static enum drm_connector_status
|
serdes_bridge_detect(struct drm_bridge *bridge)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
enum drm_connector_status status = connector_status_connected;
|
|
if (serdes->chip_data->bridge_ops->detect)
|
status = serdes->chip_data->bridge_ops->detect(serdes);
|
|
return status;
|
}
|
|
static int serdes_bridge_get_modes(struct drm_bridge *bridge,
|
struct drm_connector *connector)
|
{
|
struct serdes_bridge *serdes_bridge = to_serdes_bridge(bridge);
|
struct serdes *serdes = serdes_bridge->parent;
|
int ret = 0;
|
|
if (serdes->chip_data->bridge_ops->get_modes)
|
ret = serdes->chip_data->bridge_ops->get_modes(serdes);
|
|
if (serdes_bridge->next_bridge)
|
ret = drm_bridge_get_modes(serdes_bridge->next_bridge, connector);
|
|
if (serdes_bridge->panel)
|
ret = drm_panel_get_modes(serdes_bridge->panel, connector);
|
|
SERDES_DBG_MFD("%s:name=%s, type=%d\n", __func__,
|
serdes->chip_data->name, serdes->type);
|
|
return ret;
|
}
|
|
static const struct drm_bridge_funcs serdes_bridge_funcs = {
|
.attach = serdes_bridge_attach,
|
.detach = serdes_bridge_detach,
|
.disable = serdes_bridge_disable,
|
.post_disable = serdes_bridge_post_disable,
|
.pre_enable = serdes_bridge_pre_enable,
|
.enable = serdes_bridge_enable,
|
.detect = serdes_bridge_detect,
|
.get_modes = serdes_bridge_get_modes,
|
.atomic_get_input_bus_fmts = drm_atomic_helper_bridge_propagate_bus_fmt,
|
.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 serdes_bridge_probe(struct platform_device *pdev)
|
{
|
struct serdes *serdes = dev_get_drvdata(pdev->dev.parent);
|
struct device *dev = &pdev->dev;
|
struct serdes_bridge *serdes_bridge;
|
|
if (!serdes->dev)
|
return -1;
|
|
serdes_bridge = devm_kzalloc(dev, sizeof(*serdes_bridge), GFP_KERNEL);
|
if (!serdes_bridge)
|
return -ENOMEM;
|
|
serdes->serdes_bridge = serdes_bridge;
|
serdes_bridge->dev = dev;
|
serdes_bridge->parent = dev_get_drvdata(dev->parent);
|
platform_set_drvdata(pdev, serdes_bridge);
|
serdes_bridge->regmap = dev_get_regmap(dev->parent, NULL);
|
if (!serdes_bridge->regmap)
|
return dev_err_probe(dev, -ENODEV, "failed to get serdes regmap\n");
|
|
serdes_bridge->sel_mipi = of_property_read_bool(dev->parent->of_node, "sel-mipi");
|
if (serdes_bridge->sel_mipi) {
|
serdes_bridge->dsi_node = of_graph_get_remote_node(dev->parent->of_node, 0, -1);
|
if (!serdes_bridge->dsi_node)
|
return dev_err_probe(dev->parent, -ENODEV,
|
"failed to get remote node for serdes dsi\n");
|
|
SERDES_DBG_MFD("%s: sel_mipi=%d\n", __func__, serdes_bridge->sel_mipi);
|
}
|
|
serdes_bridge->base_bridge.funcs = &serdes_bridge_funcs;
|
serdes_bridge->base_bridge.of_node = dev->parent->of_node;
|
serdes_bridge->base_bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_MODES;
|
|
if (serdes_bridge->sel_mipi) {
|
serdes_bridge->base_bridge.type = DRM_MODE_CONNECTOR_DSI;
|
SERDES_DBG_MFD("%s: type DRM_MODE_CONNECTOR_DSI\n", __func__);
|
} else if (serdes_bridge->parent->chip_data->connector_type) {
|
serdes_bridge->base_bridge.type = serdes_bridge->parent->chip_data->connector_type;
|
SERDES_DBG_MFD("%s: type 0x%x\n", __func__, serdes_bridge->base_bridge.type);
|
} else {
|
serdes_bridge->base_bridge.type = DRM_MODE_CONNECTOR_eDP;
|
SERDES_DBG_MFD("%s: type DRM_MODE_CONNECTOR_LVDS\n", __func__);
|
}
|
|
drm_bridge_add(&serdes_bridge->base_bridge);
|
|
dev_info(dev, "serdes %s, serdes_bridge_probe successful mipi=%d, of_node=%s\n",
|
serdes->chip_data->name, serdes_bridge->sel_mipi,
|
serdes_bridge->base_bridge.of_node->name);
|
|
return 0;
|
}
|
|
static int serdes_bridge_remove(struct platform_device *pdev)
|
{
|
struct serdes_bridge *serdes_bridge = platform_get_drvdata(pdev);
|
|
drm_bridge_remove(&serdes_bridge->base_bridge);
|
|
return 0;
|
}
|
|
static const struct of_device_id serdes_bridge_of_match[] = {
|
{ .compatible = "rohm,bu18tl82-bridge", },
|
{ .compatible = "rohm,bu18rl82-bridge", },
|
{ .compatible = "maxim,max96745-bridge", },
|
{ .compatible = "maxim,max96752-bridge", },
|
{ .compatible = "maxim,max96755-bridge", },
|
{ .compatible = "maxim,max96772-bridge", },
|
{ .compatible = "rockchip,rkx111-bridge", },
|
{ .compatible = "rockchip,rkx121-bridge", },
|
{ }
|
};
|
|
static struct platform_driver serdes_bridge_driver = {
|
.driver = {
|
.name = "serdes-bridge",
|
.of_match_table = of_match_ptr(serdes_bridge_of_match),
|
},
|
.probe = serdes_bridge_probe,
|
.remove = serdes_bridge_remove,
|
};
|
|
static int __init serdes_bridge_init(void)
|
{
|
return platform_driver_register(&serdes_bridge_driver);
|
}
|
device_initcall(serdes_bridge_init);
|
|
static void __exit serdes_bridge_exit(void)
|
{
|
platform_driver_unregister(&serdes_bridge_driver);
|
}
|
module_exit(serdes_bridge_exit);
|
|
MODULE_AUTHOR("Luo Wei <lw@rock-chips.com>");
|
MODULE_DESCRIPTION("display bridge interface for different serdes");
|
MODULE_LICENSE("GPL");
|
MODULE_ALIAS("platform:serdes-bridge");
|
