1 #include <linux/component.h> 2 #include <linux/export.h> 3 #include <linux/list.h> 4 #include <linux/of_graph.h> 5 #include <drm/drmP.h> 6 #include <drm/drm_bridge.h> 7 #include <drm/drm_crtc.h> 8 #include <drm/drm_encoder.h> 9 #include <drm/drm_panel.h> 10 #include <drm/drm_of.h> 11 12 /** 13 * DOC: overview 14 * 15 * A set of helper functions to aid DRM drivers in parsing standard DT 16 * properties. 17 */ 18 19 static void drm_release_of(struct device *dev, void *data) 20 { 21 of_node_put(data); 22 } 23 24 /** 25 * drm_of_crtc_port_mask - find the mask of a registered CRTC by port OF node 26 * @dev: DRM device 27 * @port: port OF node 28 * 29 * Given a port OF node, return the possible mask of the corresponding 30 * CRTC within a device's list of CRTCs. Returns zero if not found. 31 */ 32 uint32_t drm_of_crtc_port_mask(struct drm_device *dev, 33 struct device_node *port) 34 { 35 unsigned int index = 0; 36 struct drm_crtc *tmp; 37 38 drm_for_each_crtc(tmp, dev) { 39 if (tmp->port == port) 40 return 1 << index; 41 42 index++; 43 } 44 45 return 0; 46 } 47 EXPORT_SYMBOL(drm_of_crtc_port_mask); 48 49 /** 50 * drm_of_find_possible_crtcs - find the possible CRTCs for an encoder port 51 * @dev: DRM device 52 * @port: encoder port to scan for endpoints 53 * 54 * Scan all endpoints attached to a port, locate their attached CRTCs, 55 * and generate the DRM mask of CRTCs which may be attached to this 56 * encoder. 57 * 58 * See Documentation/devicetree/bindings/graph.txt for the bindings. 59 */ 60 uint32_t drm_of_find_possible_crtcs(struct drm_device *dev, 61 struct device_node *port) 62 { 63 struct device_node *remote_port, *ep; 64 uint32_t possible_crtcs = 0; 65 66 for_each_endpoint_of_node(port, ep) { 67 remote_port = of_graph_get_remote_port(ep); 68 if (!remote_port) { 69 of_node_put(ep); 70 return 0; 71 } 72 73 possible_crtcs |= drm_of_crtc_port_mask(dev, remote_port); 74 75 of_node_put(remote_port); 76 } 77 78 return possible_crtcs; 79 } 80 EXPORT_SYMBOL(drm_of_find_possible_crtcs); 81 82 /** 83 * drm_of_component_match_add - Add a component helper OF node match rule 84 * @master: master device 85 * @matchptr: component match pointer 86 * @compare: compare function used for matching component 87 * @node: of_node 88 */ 89 void drm_of_component_match_add(struct device *master, 90 struct component_match **matchptr, 91 int (*compare)(struct device *, void *), 92 struct device_node *node) 93 { 94 of_node_get(node); 95 component_match_add_release(master, matchptr, drm_release_of, 96 compare, node); 97 } 98 EXPORT_SYMBOL_GPL(drm_of_component_match_add); 99 100 /** 101 * drm_of_component_probe - Generic probe function for a component based master 102 * @dev: master device containing the OF node 103 * @compare_of: compare function used for matching components 104 * @m_ops: component master ops to be used 105 * 106 * Parse the platform device OF node and bind all the components associated 107 * with the master. Interface ports are added before the encoders in order to 108 * satisfy their .bind requirements 109 * See Documentation/devicetree/bindings/graph.txt for the bindings. 110 * 111 * Returns zero if successful, or one of the standard error codes if it fails. 112 */ 113 int drm_of_component_probe(struct device *dev, 114 int (*compare_of)(struct device *, void *), 115 const struct component_master_ops *m_ops) 116 { 117 struct device_node *ep, *port, *remote; 118 struct component_match *match = NULL; 119 int i; 120 121 if (!dev->of_node) 122 return -EINVAL; 123 124 /* 125 * Bind the crtc's ports first, so that drm_of_find_possible_crtcs() 126 * called from encoder's .bind callbacks works as expected 127 */ 128 for (i = 0; ; i++) { 129 port = of_parse_phandle(dev->of_node, "ports", i); 130 if (!port) 131 break; 132 133 if (of_device_is_available(port->parent)) 134 drm_of_component_match_add(dev, &match, compare_of, 135 port); 136 137 of_node_put(port); 138 } 139 140 if (i == 0) { 141 dev_err(dev, "missing 'ports' property\n"); 142 return -ENODEV; 143 } 144 145 if (!match) { 146 dev_err(dev, "no available port\n"); 147 return -ENODEV; 148 } 149 150 /* 151 * For bound crtcs, bind the encoders attached to their remote endpoint 152 */ 153 for (i = 0; ; i++) { 154 port = of_parse_phandle(dev->of_node, "ports", i); 155 if (!port) 156 break; 157 158 if (!of_device_is_available(port->parent)) { 159 of_node_put(port); 160 continue; 161 } 162 163 for_each_child_of_node(port, ep) { 164 remote = of_graph_get_remote_port_parent(ep); 165 if (!remote || !of_device_is_available(remote)) { 166 of_node_put(remote); 167 continue; 168 } else if (!of_device_is_available(remote->parent)) { 169 dev_warn(dev, "parent device of %pOF is not available\n", 170 remote); 171 of_node_put(remote); 172 continue; 173 } 174 175 drm_of_component_match_add(dev, &match, compare_of, 176 remote); 177 of_node_put(remote); 178 } 179 of_node_put(port); 180 } 181 182 return component_master_add_with_match(dev, m_ops, match); 183 } 184 EXPORT_SYMBOL(drm_of_component_probe); 185 186 /* 187 * drm_of_encoder_active_endpoint - return the active encoder endpoint 188 * @node: device tree node containing encoder input ports 189 * @encoder: drm_encoder 190 * 191 * Given an encoder device node and a drm_encoder with a connected crtc, 192 * parse the encoder endpoint connecting to the crtc port. 193 */ 194 int drm_of_encoder_active_endpoint(struct device_node *node, 195 struct drm_encoder *encoder, 196 struct of_endpoint *endpoint) 197 { 198 struct device_node *ep; 199 struct drm_crtc *crtc = encoder->crtc; 200 struct device_node *port; 201 int ret; 202 203 if (!node || !crtc) 204 return -EINVAL; 205 206 for_each_endpoint_of_node(node, ep) { 207 port = of_graph_get_remote_port(ep); 208 of_node_put(port); 209 if (port == crtc->port) { 210 ret = of_graph_parse_endpoint(ep, endpoint); 211 of_node_put(ep); 212 return ret; 213 } 214 } 215 216 return -EINVAL; 217 } 218 EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint); 219 220 /** 221 * drm_of_find_panel_or_bridge - return connected panel or bridge device 222 * @np: device tree node containing encoder output ports 223 * @port: port in the device tree node 224 * @endpoint: endpoint in the device tree node 225 * @panel: pointer to hold returned drm_panel 226 * @bridge: pointer to hold returned drm_bridge 227 * 228 * Given a DT node's port and endpoint number, find the connected node and 229 * return either the associated struct drm_panel or drm_bridge device. Either 230 * @panel or @bridge must not be NULL. 231 * 232 * Returns zero if successful, or one of the standard error codes if it fails. 233 */ 234 int drm_of_find_panel_or_bridge(const struct device_node *np, 235 int port, int endpoint, 236 struct drm_panel **panel, 237 struct drm_bridge **bridge) 238 { 239 int ret = -EPROBE_DEFER; 240 struct device_node *remote; 241 242 if (!panel && !bridge) 243 return -EINVAL; 244 if (panel) 245 *panel = NULL; 246 247 remote = of_graph_get_remote_node(np, port, endpoint); 248 if (!remote) 249 return -ENODEV; 250 251 if (!of_device_is_available(remote)) { 252 of_node_put(remote); 253 return -ENODEV; 254 } 255 256 if (panel) { 257 *panel = of_drm_find_panel(remote); 258 if (!IS_ERR(*panel)) 259 ret = 0; 260 else 261 *panel = NULL; 262 } 263 264 /* No panel found yet, check for a bridge next. */ 265 if (bridge) { 266 if (ret) { 267 *bridge = of_drm_find_bridge(remote); 268 if (*bridge) 269 ret = 0; 270 } else { 271 *bridge = NULL; 272 } 273 274 } 275 276 of_node_put(remote); 277 return ret; 278 } 279 EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge); 280