change otg to host mode

hc

2024-05-11 04dd17822334871b23ea2862f7798fb0e0007777

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
 */
 
#include "edp.h"
 
struct edp_bridge {
    struct drm_bridge base;
    struct msm_edp *edp;
};
#define to_edp_bridge(x) container_of(x, struct edp_bridge, base)
 
void edp_bridge_destroy(struct drm_bridge *bridge)
{
}
 
static void edp_bridge_pre_enable(struct drm_bridge *bridge)
{
    struct edp_bridge *edp_bridge = to_edp_bridge(bridge);
    struct msm_edp *edp = edp_bridge->edp;
 
    DBG("");
    msm_edp_ctrl_power(edp->ctrl, true);
}
 
static void edp_bridge_enable(struct drm_bridge *bridge)
{
    DBG("");
}
 
static void edp_bridge_disable(struct drm_bridge *bridge)
{
    DBG("");
}
 
static void edp_bridge_post_disable(struct drm_bridge *bridge)
{
    struct edp_bridge *edp_bridge = to_edp_bridge(bridge);
    struct msm_edp *edp = edp_bridge->edp;
 
    DBG("");
    msm_edp_ctrl_power(edp->ctrl, false);
}
 
static void edp_bridge_mode_set(struct drm_bridge *bridge,
        const struct drm_display_mode *mode,
        const struct drm_display_mode *adjusted_mode)
{
    struct drm_device *dev = bridge->dev;
    struct drm_connector *connector;
    struct edp_bridge *edp_bridge = to_edp_bridge(bridge);
    struct msm_edp *edp = edp_bridge->edp;
 
    DBG("set mode: " DRM_MODE_FMT, DRM_MODE_ARG(mode));
 
    list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
        struct drm_encoder *encoder = connector->encoder;
        struct drm_bridge *first_bridge;
 
        if (!connector->encoder)
            continue;
 
        first_bridge = drm_bridge_chain_get_first_bridge(encoder);
        if (bridge == first_bridge) {
            msm_edp_ctrl_timing_cfg(edp->ctrl,
                adjusted_mode, &connector->display_info);
            break;
        }
    }
}
 
static const struct drm_bridge_funcs edp_bridge_funcs = {
    .pre_enable = edp_bridge_pre_enable,
    .enable = edp_bridge_enable,
    .disable = edp_bridge_disable,
    .post_disable = edp_bridge_post_disable,
    .mode_set = edp_bridge_mode_set,
};
 
/* initialize bridge */
struct drm_bridge *msm_edp_bridge_init(struct msm_edp *edp)
{
    struct drm_bridge *bridge = NULL;
    struct edp_bridge *edp_bridge;
    int ret;
 
    edp_bridge = devm_kzalloc(edp->dev->dev,
            sizeof(*edp_bridge), GFP_KERNEL);
    if (!edp_bridge) {
        ret = -ENOMEM;
        goto fail;
    }
 
    edp_bridge->edp = edp;
 
    bridge = &edp_bridge->base;
    bridge->funcs = &edp_bridge_funcs;
 
    ret = drm_bridge_attach(edp->encoder, bridge, NULL, 0);
    if (ret)
        goto fail;
 
    return bridge;
 
fail:
    if (bridge)
        edp_bridge_destroy(bridge);
 
    return ERR_PTR(ret);
}