1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * i.MX drm driver - parallel display implementation 4 * 5 * Copyright (C) 2012 Sascha Hauer, Pengutronix 6 */ 7 8 #include <linux/component.h> 9 #include <linux/media-bus-format.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/platform_device.h> 13 #include <linux/videodev2.h> 14 15 #include <drm/drm_atomic_helper.h> 16 #include <drm/drm_bridge.h> 17 #include <drm/drm_bridge_connector.h> 18 #include <drm/drm_managed.h> 19 #include <drm/drm_of.h> 20 #include <drm/drm_probe_helper.h> 21 #include <drm/drm_simple_kms_helper.h> 22 #include <drm/bridge/imx.h> 23 24 #include "imx-drm.h" 25 26 struct imx_parallel_display_encoder { 27 struct drm_encoder encoder; 28 }; 29 30 struct imx_parallel_display { 31 struct device *dev; 32 u32 bus_format; 33 struct drm_bridge *next_bridge; 34 struct drm_bridge bridge; 35 }; 36 37 static inline struct imx_parallel_display *bridge_to_imxpd(struct drm_bridge *b) 38 { 39 return container_of(b, struct imx_parallel_display, bridge); 40 } 41 42 static const u32 imx_pd_bus_fmts[] = { 43 MEDIA_BUS_FMT_RGB888_1X24, 44 MEDIA_BUS_FMT_BGR888_1X24, 45 MEDIA_BUS_FMT_GBR888_1X24, 46 MEDIA_BUS_FMT_RGB666_1X18, 47 MEDIA_BUS_FMT_RGB666_1X24_CPADHI, 48 MEDIA_BUS_FMT_RGB565_1X16, 49 }; 50 51 static u32 * 52 imx_pd_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge, 53 struct drm_bridge_state *bridge_state, 54 struct drm_crtc_state *crtc_state, 55 struct drm_connector_state *conn_state, 56 unsigned int *num_output_fmts) 57 { 58 struct drm_display_info *di = &conn_state->connector->display_info; 59 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 60 u32 *output_fmts; 61 62 if (!imxpd->bus_format && !di->num_bus_formats) { 63 *num_output_fmts = ARRAY_SIZE(imx_pd_bus_fmts); 64 return kmemdup(imx_pd_bus_fmts, sizeof(imx_pd_bus_fmts), 65 GFP_KERNEL); 66 } 67 68 *num_output_fmts = 1; 69 output_fmts = kmalloc(sizeof(*output_fmts), GFP_KERNEL); 70 if (!output_fmts) 71 return NULL; 72 73 if (!imxpd->bus_format && di->num_bus_formats) 74 output_fmts[0] = di->bus_formats[0]; 75 else 76 output_fmts[0] = imxpd->bus_format; 77 78 return output_fmts; 79 } 80 81 static bool imx_pd_format_supported(u32 output_fmt) 82 { 83 unsigned int i; 84 85 for (i = 0; i < ARRAY_SIZE(imx_pd_bus_fmts); i++) { 86 if (imx_pd_bus_fmts[i] == output_fmt) 87 return true; 88 } 89 90 return false; 91 } 92 93 static u32 * 94 imx_pd_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge, 95 struct drm_bridge_state *bridge_state, 96 struct drm_crtc_state *crtc_state, 97 struct drm_connector_state *conn_state, 98 u32 output_fmt, 99 unsigned int *num_input_fmts) 100 { 101 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 102 u32 *input_fmts; 103 104 /* 105 * If the next bridge does not support bus format negotiation, let's 106 * use the static bus format definition (imxpd->bus_format) if it's 107 * specified, RGB888 when it's not. 108 */ 109 if (output_fmt == MEDIA_BUS_FMT_FIXED) 110 output_fmt = imxpd->bus_format ? : MEDIA_BUS_FMT_RGB888_1X24; 111 112 /* Now make sure the requested output format is supported. */ 113 if ((imxpd->bus_format && imxpd->bus_format != output_fmt) || 114 !imx_pd_format_supported(output_fmt)) { 115 *num_input_fmts = 0; 116 return NULL; 117 } 118 119 *num_input_fmts = 1; 120 input_fmts = kmalloc(sizeof(*input_fmts), GFP_KERNEL); 121 if (!input_fmts) 122 return NULL; 123 124 input_fmts[0] = output_fmt; 125 return input_fmts; 126 } 127 128 static int imx_pd_bridge_atomic_check(struct drm_bridge *bridge, 129 struct drm_bridge_state *bridge_state, 130 struct drm_crtc_state *crtc_state, 131 struct drm_connector_state *conn_state) 132 { 133 struct imx_crtc_state *imx_crtc_state = to_imx_crtc_state(crtc_state); 134 struct drm_display_info *di = &conn_state->connector->display_info; 135 struct drm_bridge_state *next_bridge_state = NULL; 136 struct drm_bridge *next_bridge; 137 u32 bus_flags, bus_fmt; 138 139 next_bridge = drm_bridge_get_next_bridge(bridge); 140 if (next_bridge) 141 next_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, 142 next_bridge); 143 144 if (next_bridge_state) 145 bus_flags = next_bridge_state->input_bus_cfg.flags; 146 else 147 bus_flags = di->bus_flags; 148 149 bus_fmt = bridge_state->input_bus_cfg.format; 150 if (!imx_pd_format_supported(bus_fmt)) 151 return -EINVAL; 152 153 bridge_state->output_bus_cfg.flags = bus_flags; 154 bridge_state->input_bus_cfg.flags = bus_flags; 155 imx_crtc_state->bus_flags = bus_flags; 156 imx_crtc_state->bus_format = bridge_state->input_bus_cfg.format; 157 imx_crtc_state->di_hsync_pin = 2; 158 imx_crtc_state->di_vsync_pin = 3; 159 160 return 0; 161 } 162 163 static int imx_pd_bridge_attach(struct drm_bridge *bridge, 164 struct drm_encoder *encoder, 165 enum drm_bridge_attach_flags flags) 166 { 167 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 168 169 return drm_bridge_attach(encoder, imxpd->next_bridge, bridge, flags); 170 } 171 172 static const struct drm_bridge_funcs imx_pd_bridge_funcs = { 173 .attach = imx_pd_bridge_attach, 174 .atomic_reset = drm_atomic_helper_bridge_reset, 175 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 176 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 177 .atomic_check = imx_pd_bridge_atomic_check, 178 .atomic_get_input_bus_fmts = imx_pd_bridge_atomic_get_input_bus_fmts, 179 .atomic_get_output_bus_fmts = imx_pd_bridge_atomic_get_output_bus_fmts, 180 }; 181 182 static int imx_pd_bind(struct device *dev, struct device *master, void *data) 183 { 184 struct drm_device *drm = data; 185 struct imx_parallel_display *imxpd = dev_get_drvdata(dev); 186 struct imx_parallel_display_encoder *imxpd_encoder; 187 struct drm_connector *connector; 188 struct drm_encoder *encoder; 189 struct drm_bridge *bridge; 190 int ret; 191 192 imxpd_encoder = drmm_simple_encoder_alloc(drm, struct imx_parallel_display_encoder, 193 encoder, DRM_MODE_ENCODER_NONE); 194 if (IS_ERR(imxpd_encoder)) 195 return PTR_ERR(imxpd_encoder); 196 197 encoder = &imxpd_encoder->encoder; 198 bridge = &imxpd->bridge; 199 200 ret = imx_drm_encoder_parse_of(drm, encoder, imxpd->dev->of_node); 201 if (ret) 202 return ret; 203 204 drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR); 205 206 connector = drm_bridge_connector_init(drm, encoder); 207 if (IS_ERR(connector)) 208 return PTR_ERR(connector); 209 210 drm_connector_attach_encoder(connector, encoder); 211 212 return 0; 213 } 214 215 static const struct component_ops imx_pd_ops = { 216 .bind = imx_pd_bind, 217 }; 218 219 static int imx_pd_probe(struct platform_device *pdev) 220 { 221 struct device *dev = &pdev->dev; 222 struct device_node *np = dev->of_node; 223 struct imx_parallel_display *imxpd; 224 int ret; 225 u32 bus_format = 0; 226 const char *fmt; 227 228 imxpd = devm_drm_bridge_alloc(dev, struct imx_parallel_display, bridge, 229 &imx_pd_bridge_funcs); 230 if (IS_ERR(imxpd)) 231 return PTR_ERR(imxpd); 232 233 /* port@1 is the output port */ 234 imxpd->next_bridge = devm_drm_of_get_bridge(dev, np, 1, 0); 235 if (imxpd->next_bridge == ERR_PTR(-ENODEV)) 236 imxpd->next_bridge = devm_imx_drm_legacy_bridge(dev, np, DRM_MODE_CONNECTOR_DPI); 237 if (IS_ERR(imxpd->next_bridge)) { 238 ret = PTR_ERR(imxpd->next_bridge); 239 return ret; 240 } 241 242 ret = of_property_read_string(np, "interface-pix-fmt", &fmt); 243 if (!ret) { 244 if (!strcmp(fmt, "rgb24")) 245 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 246 else if (!strcmp(fmt, "rgb565")) 247 bus_format = MEDIA_BUS_FMT_RGB565_1X16; 248 else if (!strcmp(fmt, "bgr666")) 249 bus_format = MEDIA_BUS_FMT_RGB666_1X18; 250 else if (!strcmp(fmt, "lvds666")) 251 bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI; 252 } 253 imxpd->bus_format = bus_format; 254 255 imxpd->dev = dev; 256 257 platform_set_drvdata(pdev, imxpd); 258 259 devm_drm_bridge_add(dev, &imxpd->bridge); 260 261 return component_add(dev, &imx_pd_ops); 262 } 263 264 static void imx_pd_remove(struct platform_device *pdev) 265 { 266 component_del(&pdev->dev, &imx_pd_ops); 267 } 268 269 static const struct of_device_id imx_pd_dt_ids[] = { 270 { .compatible = "fsl,imx-parallel-display", }, 271 { /* sentinel */ } 272 }; 273 MODULE_DEVICE_TABLE(of, imx_pd_dt_ids); 274 275 static struct platform_driver imx_pd_driver = { 276 .probe = imx_pd_probe, 277 .remove = imx_pd_remove, 278 .driver = { 279 .of_match_table = imx_pd_dt_ids, 280 .name = "imx-parallel-display", 281 }, 282 }; 283 284 module_platform_driver(imx_pd_driver); 285 286 MODULE_DESCRIPTION("i.MX parallel display driver"); 287 MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 288 MODULE_LICENSE("GPL"); 289 MODULE_ALIAS("platform:imx-parallel-display"); 290