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_obj(*output_fmts); 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 (!imx_pd_format_supported(output_fmt)) { 114 *num_input_fmts = 0; 115 return NULL; 116 } 117 118 *num_input_fmts = 1; 119 input_fmts = kmalloc_obj(*input_fmts); 120 if (!input_fmts) 121 return NULL; 122 123 /* 124 * Prefer bus format set via legacy "interface-pix-fmt" DT property 125 * over panel bus format. This is necessary to retain support for 126 * DTs which configure the IPUv3 parallel output as 24bit, but 127 * connect 18bit DPI panels to it with hardware swizzling. 128 */ 129 if (imxpd->bus_format && imxpd->bus_format != output_fmt) 130 input_fmts[0] = imxpd->bus_format; 131 else 132 input_fmts[0] = output_fmt; 133 134 return input_fmts; 135 } 136 137 static int imx_pd_bridge_atomic_check(struct drm_bridge *bridge, 138 struct drm_bridge_state *bridge_state, 139 struct drm_crtc_state *crtc_state, 140 struct drm_connector_state *conn_state) 141 { 142 struct imx_crtc_state *imx_crtc_state = to_imx_crtc_state(crtc_state); 143 struct drm_display_info *di = &conn_state->connector->display_info; 144 struct drm_bridge_state *next_bridge_state = NULL; 145 u32 bus_flags, bus_fmt; 146 147 struct drm_bridge *next_bridge __free(drm_bridge_put) = drm_bridge_get_next_bridge(bridge); 148 149 if (next_bridge) 150 next_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, 151 next_bridge); 152 153 if (next_bridge_state) 154 bus_flags = next_bridge_state->input_bus_cfg.flags; 155 else 156 bus_flags = di->bus_flags; 157 158 bus_fmt = bridge_state->input_bus_cfg.format; 159 if (!imx_pd_format_supported(bus_fmt)) 160 return -EINVAL; 161 162 bridge_state->output_bus_cfg.flags = bus_flags; 163 bridge_state->input_bus_cfg.flags = bus_flags; 164 imx_crtc_state->bus_flags = bus_flags; 165 imx_crtc_state->bus_format = bridge_state->input_bus_cfg.format; 166 imx_crtc_state->di_hsync_pin = 2; 167 imx_crtc_state->di_vsync_pin = 3; 168 169 return 0; 170 } 171 172 static int imx_pd_bridge_attach(struct drm_bridge *bridge, 173 struct drm_encoder *encoder, 174 enum drm_bridge_attach_flags flags) 175 { 176 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 177 178 return drm_bridge_attach(encoder, imxpd->next_bridge, bridge, flags); 179 } 180 181 static const struct drm_bridge_funcs imx_pd_bridge_funcs = { 182 .attach = imx_pd_bridge_attach, 183 .atomic_reset = drm_atomic_helper_bridge_reset, 184 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 185 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 186 .atomic_check = imx_pd_bridge_atomic_check, 187 .atomic_get_input_bus_fmts = imx_pd_bridge_atomic_get_input_bus_fmts, 188 .atomic_get_output_bus_fmts = imx_pd_bridge_atomic_get_output_bus_fmts, 189 }; 190 191 static int imx_pd_bind(struct device *dev, struct device *master, void *data) 192 { 193 struct drm_device *drm = data; 194 struct imx_parallel_display *imxpd = dev_get_drvdata(dev); 195 struct imx_parallel_display_encoder *imxpd_encoder; 196 struct drm_connector *connector; 197 struct drm_encoder *encoder; 198 struct drm_bridge *bridge; 199 int ret; 200 201 imxpd_encoder = drmm_simple_encoder_alloc(drm, struct imx_parallel_display_encoder, 202 encoder, DRM_MODE_ENCODER_NONE); 203 if (IS_ERR(imxpd_encoder)) 204 return PTR_ERR(imxpd_encoder); 205 206 encoder = &imxpd_encoder->encoder; 207 bridge = &imxpd->bridge; 208 209 ret = imx_drm_encoder_parse_of(drm, encoder, imxpd->dev->of_node); 210 if (ret) 211 return ret; 212 213 drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR); 214 215 connector = drm_bridge_connector_init(drm, encoder); 216 if (IS_ERR(connector)) 217 return PTR_ERR(connector); 218 219 drm_connector_attach_encoder(connector, encoder); 220 221 return 0; 222 } 223 224 static const struct component_ops imx_pd_ops = { 225 .bind = imx_pd_bind, 226 }; 227 228 static int imx_pd_probe(struct platform_device *pdev) 229 { 230 struct device *dev = &pdev->dev; 231 struct device_node *np = dev->of_node; 232 struct imx_parallel_display *imxpd; 233 int ret; 234 u32 bus_format = 0; 235 const char *fmt; 236 237 imxpd = devm_drm_bridge_alloc(dev, struct imx_parallel_display, bridge, 238 &imx_pd_bridge_funcs); 239 if (IS_ERR(imxpd)) 240 return PTR_ERR(imxpd); 241 242 /* port@1 is the output port */ 243 imxpd->next_bridge = devm_drm_of_get_bridge(dev, np, 1, 0); 244 if (imxpd->next_bridge == ERR_PTR(-ENODEV)) 245 imxpd->next_bridge = devm_imx_drm_legacy_bridge(dev, np, DRM_MODE_CONNECTOR_DPI); 246 if (IS_ERR(imxpd->next_bridge)) { 247 ret = PTR_ERR(imxpd->next_bridge); 248 return ret; 249 } 250 251 ret = of_property_read_string(np, "interface-pix-fmt", &fmt); 252 if (!ret) { 253 if (!strcmp(fmt, "rgb24")) 254 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 255 else if (!strcmp(fmt, "rgb565")) 256 bus_format = MEDIA_BUS_FMT_RGB565_1X16; 257 else if (!strcmp(fmt, "bgr666")) 258 bus_format = MEDIA_BUS_FMT_RGB666_1X18; 259 else if (!strcmp(fmt, "lvds666")) 260 bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI; 261 } 262 imxpd->bus_format = bus_format; 263 264 imxpd->dev = dev; 265 266 platform_set_drvdata(pdev, imxpd); 267 268 ret = devm_drm_bridge_add(dev, &imxpd->bridge); 269 if (ret) 270 return ret; 271 272 return component_add(dev, &imx_pd_ops); 273 } 274 275 static void imx_pd_remove(struct platform_device *pdev) 276 { 277 component_del(&pdev->dev, &imx_pd_ops); 278 } 279 280 static const struct of_device_id imx_pd_dt_ids[] = { 281 { .compatible = "fsl,imx-parallel-display", }, 282 { /* sentinel */ } 283 }; 284 MODULE_DEVICE_TABLE(of, imx_pd_dt_ids); 285 286 static struct platform_driver imx_pd_driver = { 287 .probe = imx_pd_probe, 288 .remove = imx_pd_remove, 289 .driver = { 290 .of_match_table = imx_pd_dt_ids, 291 .name = "imx-parallel-display", 292 }, 293 }; 294 295 module_platform_driver(imx_pd_driver); 296 297 MODULE_DESCRIPTION("i.MX parallel display driver"); 298 MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 299 MODULE_LICENSE("GPL"); 300