linux基于DRM显示框架分析

图片来自https://blog.csdn.net/u014674293/article/details/105732627?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2_{aggregatepage}first_rank_v2~rank_aggregation-14-105732627.pc_agg_rank_aggregation&utm_term=drm%E6%98%BE%E7%A4%BA%E6%9E%B6%E6%9E%84&spm=1000.2123.3001.4430
图片来自https://www.eefocus.com/embedded/479281

display_subsystem: display-subsystem {
    compatible = "rockchip,display-subsystem";
    ports = <&vopl_out>, <&vopb_out>;
    clocks = <&cru PLL_VPLL>, <&cru PLL_CPLL>;
    clock-names = "hdmi-tmds-pll", "default-vop-pll";
    devfreq = <&dmc>;
    status = "disabled";
};

H:\RK3399\kernel\drivers\gpu\drm\rockchip\rockchip_drm_drv.c

vopl，vopb相当于是crtc，dp_in_vopl，dsi_in_vopl，edp_in_vopl，dp_in_vopl相当于是connector
static int rockchip_drm_platform_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct component_match *match = NULL;
struct device_node *np = dev->of_node;
struct device_node *port;
int i;

DRM_INFO("Rockchip DRM driver version: %s\n", DRIVER_VERSION);
if (!np)
    return -ENODEV;
/*
 * Bind the crtc ports first, so that
 * drm_of_find_possible_crtcs called from encoder .bind callbacks
 * works as expected.
 */
for (i = 0;; i++) {
    struct device_node *iommu;

    port = of_parse_phandle(np, "ports", i); //查找prots属性，找到它的 device_node节点，比如vopl_out节点
    if (!port)
        break;

    if (!of_device_is_available(port->parent)) {  //看vopl_out节点的父节点vopl是否可以使用 status 是否 "okay"或“ok”;
        of_node_put(port);
        continue;
    }

    iommu = of_parse_phandle(port->parent, "iommus", 0);  //找到其中的iommus的device_node节点
    if (!iommu || !of_device_is_available(iommu->parent)) {
        dev_dbg(dev, "no iommu attached for %s, using non-iommu buffers\n",
            port->parent->full_name);
        /*
         * if there is a crtc not support iommu, force set all
         * crtc use non-iommu buffer.
         */
        is_support_iommu = false;    //不存在或者父节点不可取就置为false
    }

    component_match_add(dev, &match, compare_of, port->parent); 在match中添加一个compare数组成员比如vopl，vopb，还会再将每个属性值关联的设备添加到match中
    of_node_put(port);
}

if (i == 0) {
    dev_err(dev, "missing 'ports' property\n");
    return -ENODEV;
}

if (!match) {
    dev_err(dev, "No available vop found for display-subsystem.\n");
    return -ENODEV;
}
/*
 * For each bound crtc, bind the encoders attached to its
 * remote endpoint.
 */
for (i = 0;; i++) {
    port = of_parse_phandle(np, "ports", i);
    if (!port)
        break;

    if (!of_device_is_available(port->parent)) {
        of_node_put(port);
        continue;
    }

    rockchip_add_endpoints(dev, &match, port);  //在match中添加一个remote-endpoint数组成员比如dp_in_vopl，dsi_in_vopl，edp_in_vopl，dp_in_vopl等
    of_node_put(port);
}

port = of_parse_phandle(np, "backlight", 0);
if (port && of_device_is_available(port)) {
    component_match_add(dev, &match, compare_of, port);
    of_node_put(port);
}

return component_master_add_with_match(dev, &rockchip_drm_ops, match); // 首先定义了一个component_master_ops 对象，为设备相关操作函数回调，当该master下的所有设备都初始化完成后，调用该回调的bind指针

}
static const struct component_master_ops rockchip_drm_ops = {
.bind = rockchip_drm_bind,
.unbind = rockchip_drm_unbind,
};

int component_master_add_with_match(struct device *dev,
const struct component_master_ops *ops,
struct component_match *match)
{
struct master *master;
int ret;

if (ops->add_components && match)
    return -EINVAL;

if (match) {
    /* Reallocate the match array for its true size */
    match = component_match_realloc(dev, match, match->num);
    if (IS_ERR(match))
        return PTR_ERR(match);
}

master = kzalloc(sizeof(*master), GFP_KERNEL);
if (!master)
    return -ENOMEM;

master->dev = dev;
master->ops = ops;   //把rockchip_drm_ops给了master->ops 为后面调用ops的bind做准备
master->match = match;
INIT_LIST_HEAD(&master->components);

/* Add to the list of available masters. */
mutex_lock(&component_mutex);
list_add(&master->node, &masters);

ret = try_to_bring_up_master(master, NULL); 这个函 数就是检查是否所有的componet都加载完成，完成了就调用rockchip_drm_bind函数，后面分析rockchip_drm_bind 

if (ret < 0) {
    /* Delete off the list if we weren't successful */
    list_del(&master->node);
    kfree(master);
}
mutex_unlock(&component_mutex);

return ret < 0 ? ret : 0;

}

static int try_to_bring_up_master(struct master *master,
struct component *component)
{
int ret;

if (master->bound)
    return 0;

/*
 * Search the list of components, looking for components that
 * belong to this master, and attach them to the master.
 */
if (find_components(master)) {    //从component_list链表中找到所有属于本master的components，如果有component没有添加完成，就返回退出，不会调用下面的bind，如果全部找到就往下走调用bind，下面进入函数分析

        /* Failed to find all components */
        ret = 0;
        goto out;
    }

    if (component && component->master != master) {
        ret = 0;
        goto out;
    }

    if (!devres_open_group(master->dev, NULL, GFP_KERNEL)) {
        ret = -ENOMEM;
        goto out;
    }

    /* Found all components */
    ret = master->ops->bind(master->dev);//调用之前传来的rockchip_drm_ops->bind，这里  .bind = rockchip_drm_bind,
    if (ret < 0) {
        devres_release_group(master->dev, NULL);
        dev_info(master->dev, "master bind failed: %d\n", ret);
        goto out;
    }

    master->bound = true;
    return 1;

out:
    master_remove_components(master);

    return ret;
}

static int find_components(struct master *master)
{
    struct component_match *match = master->match;
    size_t i;
    int ret = 0;

    if (!match) {
        /*
         * Search the list of components, looking for components that
         * belong to this master, and attach them to the master.
         */
        return master->ops->add_components(master->dev, master);
    }

    /*
     * Scan the array of match functions and attach
     * any components which are found to this master.
     */
    for (i = 0; i < match->num; i++) { //本match已经添加的crtc跟连接器connector
        ret = component_master_add_child(master,   下面分析
                         match->compare[i].fn,
                         match->compare[i].data);
        if (ret)
            break;
    }
    return ret;
}
int component_master_add_child(struct master *master,
    int (*compare)(struct device *, void *), void *compare_data)
{
    struct component *c;
    int ret = -ENXIO;

    list_for_each_entry(c, &component_list, node) {  查找component_list链表，找到属于本master的component
        if (c->master && c->master != master)
            continue;

        if (compare(c->dev, compare_data)) {  //比较这个设备的节点是不是这个器件，通过component_match_add绑定好的，下面分析
            if (!c->master)
                component_attach_master(master, c); 把这个component添加到master的component链表
            ret = 0;     找到就返回0
            break;
        }
    }

    return ret;  没找到返回错误
}

static int compare_of(struct device *dev, void *data)
{
struct device_node *np = data;

return dev->of_node == np;   判断这个节点跟传入的是不是一个

}
主drm驱动的加载过程结束

rockchip_drm_bind H:\RK3399\kernel\drivers\gpu\drm\rockchip\rockchip_drm_drv.c
component_bind_all

int component_bind_all(struct device *master_dev, void *data)
{
    struct master *master;
    struct component *c;
    int ret = 0;

    WARN_ON(!mutex_is_locked(&component_mutex));

    master = __master_find(master_dev, NULL);
    if (!master)
        return -EINVAL;

    list_for_each_entry(c, &master->components, master_node) {
        ret = component_bind(c, master, data);   //调用各components的bind函数
        if (ret)
            break;
    }

    if (ret != 0) {
        list_for_each_entry_continue_reverse(c, &master->components,
                             master_node)
            component_unbind(c, master, data);
    }

    return ret;
}

2.component从器件mipi的添加过程分析

dw_mipi_dsi_probe H:\RK3399\kernel\drivers\gpu\drm\rockchip\dw-mipi-dsi.c
component_add(dev, &dw_mipi_dsi_ops); 下面分析
static const struct component_ops dw_mipi_dsi_ops = {
.bind = dw_mipi_dsi_bind, 这个方法在rockchip_drm_bind中会被调用到
.unbind = dw_mipi_dsi_unbind,
};

int component_add(struct device *dev, const struct component_ops *ops) H:\RK3399\kernel\drivers\base\component.c
{
    struct component *component;
    int ret;

    component = kzalloc(sizeof(*component), GFP_KERNEL);
    if (!component)
        return -ENOMEM;

    component->ops = ops;
    component->dev = dev;

    dev_dbg(dev, "adding component (ops %ps)\n", ops);

    mutex_lock(&component_mutex);
    list_add_tail(&component->node, &component_list);

    ret = try_to_bring_up_masters(component);  查找masters链表中所有的master，下面分析
    if (ret < 0) {
        list_del(&component->node);

        kfree(component);
    }
    mutex_unlock(&component_mutex);

    return ret < 0 ? ret : 0;
}

static int try_to_bring_up_masters(struct component *component)
{
    struct master *m;
    int ret = 0;

    list_for_each_entry(m, &masters, node) {   查找masters链表中所有的master
        ret = try_to_bring_up_master(m, component); 这 个函数上面master的时候分析过，从component引发到master检查它所有的component是否加载完成，完成之后调用master上面的bind函数，没完成则退出，master上的bind函数又会调用componet上的bind函数
        if (ret != 0)
            break;
    }

    return ret;
}

If a required resource is not available yet, a driver can

• request probing to be deferred by returning -EPROBE_DEFER from its probe hook
  如果一个驱动在加载的过程中没有得到想要的资源，比如dsi0驱动没得到panel的话，就会返回一个-EPROBE_DEFER错误，而一旦返回这个错误的话，这个驱动就会被添加到延时probe线程进而再次进行probe，执行这个probe的函数就是deferred_probe_work_func，
  顺序如下：
  worker_thread->
  process_one_work->
  deferred_probe_work_func->
  bus_probe_device->
  __device_attach->
  bus_for_each_drv->
  bus_for_each_drv->
  driver_probe_device->
  platform_drv_probe->
  rockchip_drm_platform_probe->
  component_master_add_with_match->
  try_to_bring_up_master->
  rockchip_drm_bind-> display_subsystem驱动的bind函数
  component_bind_all -> 调用各个compnet的bind函数
  dw_mipi_dsi_bind mipi的bind函数

static int dw_mipi_dsi_bind(struct device *dev, struct device *master,
void *data)
{
struct drm_device *drm = data;
struct dw_mipi_dsi *dsi = dev_get_drvdata(dev);
int ret;

ret = dw_mipi_dsi_dual_channel_probe(dsi);
if (ret)
    return ret;

if (dsi->master)
    return 0;

dsi->panel = of_drm_find_panel(dsi->client);  //获取绑定到此dsi的panel设备，没有绑定好则检查是否绑定有bridge
if (!dsi->panel) {
    dsi->bridge = of_drm_find_bridge(dsi->client);  没有绑定bridge则退出返回-EPROBE_DEFER，一旦返回就把

本驱动又加入了延时probe线程，等会会再次进行probe，直到发现了panel，而panel的加载在H:\RK3399\kernel\drivers\gpu\drm\panel\panel-simple.c完成，这里同时注册了mipi跟lvds的驱动在一起，通过comptable判断区分

        if (!dsi->bridge)
            return -EPROBE_DEFER;
    }

    ret = dw_mipi_dsi_register(drm, dsi);  绑定编码器，连接器，panel
    if (ret) {
        dev_err(dev, "Failed to register mipi_dsi: %d\n", ret);
        return ret;
    }

    dev_set_drvdata(dev, dsi);

    pm_runtime_enable(dev);
    if (dsi->slave)
        pm_runtime_enable(dsi->slave->dev);

    return ret;
}

static int dw_mipi_dsi_register(struct drm_device *drm,
                      struct dw_mipi_dsi *dsi)
{
    struct drm_encoder *encoder = &dsi->encoder;
    struct drm_connector *connector = &dsi->connector;
    struct device *dev = dsi->dev;
    int ret;

    encoder->possible_crtcs = drm_of_find_possible_crtcs(drm,
                                 dev->of_node);
    /*
     * If we failed to find the CRTC(s) which this encoder is
     * supposed to be connected to, it's because the CRTC has
     * not been registered yet.  Defer probing, and hope that
     * the required CRTC is added later.
     */
    if (encoder->possible_crtcs == 0)
        return -EPROBE_DEFER;

    drm_encoder_helper_add(&dsi->encoder,
                   &dw_mipi_dsi_encoder_helper_funcs);
    ret = drm_encoder_init(drm, &dsi->encoder, &dw_mipi_dsi_encoder_funcs,   //初始化encoder，格式为DRM_MODE_ENCODER_DSI，功能函数为dw_mipi_dsi_encoder_funcs
             DRM_MODE_ENCODER_DSI, NULL);
    if (ret) {
        dev_err(dev, "Failed to initialize encoder with drm\n");
        return ret;
    }

    /* If there's a bridge, attach to it and let it create the connector. */
    if (dsi->bridge) {
        dsi->bridge->driver_private = &dsi->dsi_host;
        dsi->bridge->encoder = encoder;

        ret = drm_bridge_attach(drm, dsi->bridge);
        if (ret) {
            dev_err(dev, "Failed to attach bridge: %d\n", ret);
            goto encoder_cleanup;
        }

        encoder->bridge = dsi->bridge;
    /* Otherwise create our own connector and attach to a panel */
    } else {
        dsi->connector.port = dev->of_node;
        ret = drm_connector_init(drm, &dsi->connector,
                     &dw_mipi_dsi_atomic_connector_funcs,
                     DRM_MODE_CONNECTOR_DSI);
        if (ret) {
            dev_err(dev, "Failed to initialize connector\n");
            goto encoder_cleanup;
        }
        drm_connector_helper_add(connector,
                     &dw_mipi_dsi_connector_helper_funcs);
        drm_mode_connector_attach_encoder(connector, encoder); 把编码器绑定到连接器

        ret = drm_panel_attach(dsi->panel, &dsi->connector);  把panel绑定到连接器
        if (ret) {
            dev_err(dev, "Failed to attach panel: %d\n", ret);
            goto connector_cleanup;
        }
    }

    return 0;

connector_cleanup:
    drm_connector_cleanup(connector);
encoder_cleanup:
    drm_encoder_cleanup(encoder);
    return ret;
}