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 <video/of_display_timing.h> 16 17 #include <drm/drm_atomic_helper.h> 18 #include <drm/drm_bridge.h> 19 #include <drm/drm_managed.h> 20 #include <drm/drm_of.h> 21 #include <drm/drm_probe_helper.h> 22 #include <drm/drm_simple_kms_helper.h> 23 24 #include "imx-drm.h" 25 26 struct imx_parallel_display_encoder { 27 struct drm_connector connector; 28 struct drm_encoder encoder; 29 struct drm_bridge bridge; 30 struct imx_parallel_display *pd; 31 }; 32 33 struct imx_parallel_display { 34 struct device *dev; 35 u32 bus_format; 36 u32 bus_flags; 37 struct drm_display_mode mode; 38 struct drm_bridge *next_bridge; 39 }; 40 41 static inline struct imx_parallel_display *con_to_imxpd(struct drm_connector *c) 42 { 43 return container_of(c, struct imx_parallel_display_encoder, connector)->pd; 44 } 45 46 static inline struct imx_parallel_display *bridge_to_imxpd(struct drm_bridge *b) 47 { 48 return container_of(b, struct imx_parallel_display_encoder, bridge)->pd; 49 } 50 51 static int imx_pd_connector_get_modes(struct drm_connector *connector) 52 { 53 struct imx_parallel_display *imxpd = con_to_imxpd(connector); 54 struct device_node *np = imxpd->dev->of_node; 55 int num_modes; 56 57 if (np) { 58 struct drm_display_mode *mode = drm_mode_create(connector->dev); 59 int ret; 60 61 if (!mode) 62 return 0; 63 64 ret = of_get_drm_display_mode(np, &imxpd->mode, 65 &imxpd->bus_flags, 66 OF_USE_NATIVE_MODE); 67 if (ret) { 68 drm_mode_destroy(connector->dev, mode); 69 return 0; 70 } 71 72 drm_mode_copy(mode, &imxpd->mode); 73 mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 74 drm_mode_probed_add(connector, mode); 75 num_modes++; 76 } 77 78 return num_modes; 79 } 80 81 static const u32 imx_pd_bus_fmts[] = { 82 MEDIA_BUS_FMT_RGB888_1X24, 83 MEDIA_BUS_FMT_BGR888_1X24, 84 MEDIA_BUS_FMT_GBR888_1X24, 85 MEDIA_BUS_FMT_RGB666_1X18, 86 MEDIA_BUS_FMT_RGB666_1X24_CPADHI, 87 MEDIA_BUS_FMT_RGB565_1X16, 88 }; 89 90 static u32 * 91 imx_pd_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge, 92 struct drm_bridge_state *bridge_state, 93 struct drm_crtc_state *crtc_state, 94 struct drm_connector_state *conn_state, 95 unsigned int *num_output_fmts) 96 { 97 struct drm_display_info *di = &conn_state->connector->display_info; 98 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 99 u32 *output_fmts; 100 101 if (!imxpd->bus_format && !di->num_bus_formats) { 102 *num_output_fmts = ARRAY_SIZE(imx_pd_bus_fmts); 103 return kmemdup(imx_pd_bus_fmts, sizeof(imx_pd_bus_fmts), 104 GFP_KERNEL); 105 } 106 107 *num_output_fmts = 1; 108 output_fmts = kmalloc(sizeof(*output_fmts), GFP_KERNEL); 109 if (!output_fmts) 110 return NULL; 111 112 if (!imxpd->bus_format && di->num_bus_formats) 113 output_fmts[0] = di->bus_formats[0]; 114 else 115 output_fmts[0] = imxpd->bus_format; 116 117 return output_fmts; 118 } 119 120 static bool imx_pd_format_supported(u32 output_fmt) 121 { 122 unsigned int i; 123 124 for (i = 0; i < ARRAY_SIZE(imx_pd_bus_fmts); i++) { 125 if (imx_pd_bus_fmts[i] == output_fmt) 126 return true; 127 } 128 129 return false; 130 } 131 132 static u32 * 133 imx_pd_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge, 134 struct drm_bridge_state *bridge_state, 135 struct drm_crtc_state *crtc_state, 136 struct drm_connector_state *conn_state, 137 u32 output_fmt, 138 unsigned int *num_input_fmts) 139 { 140 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 141 u32 *input_fmts; 142 143 /* 144 * If the next bridge does not support bus format negotiation, let's 145 * use the static bus format definition (imxpd->bus_format) if it's 146 * specified, RGB888 when it's not. 147 */ 148 if (output_fmt == MEDIA_BUS_FMT_FIXED) 149 output_fmt = imxpd->bus_format ? : MEDIA_BUS_FMT_RGB888_1X24; 150 151 /* Now make sure the requested output format is supported. */ 152 if ((imxpd->bus_format && imxpd->bus_format != output_fmt) || 153 !imx_pd_format_supported(output_fmt)) { 154 *num_input_fmts = 0; 155 return NULL; 156 } 157 158 *num_input_fmts = 1; 159 input_fmts = kmalloc(sizeof(*input_fmts), GFP_KERNEL); 160 if (!input_fmts) 161 return NULL; 162 163 input_fmts[0] = output_fmt; 164 return input_fmts; 165 } 166 167 static int imx_pd_bridge_atomic_check(struct drm_bridge *bridge, 168 struct drm_bridge_state *bridge_state, 169 struct drm_crtc_state *crtc_state, 170 struct drm_connector_state *conn_state) 171 { 172 struct imx_crtc_state *imx_crtc_state = to_imx_crtc_state(crtc_state); 173 struct drm_display_info *di = &conn_state->connector->display_info; 174 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 175 struct drm_bridge_state *next_bridge_state = NULL; 176 struct drm_bridge *next_bridge; 177 u32 bus_flags, bus_fmt; 178 179 next_bridge = drm_bridge_get_next_bridge(bridge); 180 if (next_bridge) 181 next_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, 182 next_bridge); 183 184 if (next_bridge_state) 185 bus_flags = next_bridge_state->input_bus_cfg.flags; 186 else if (di->num_bus_formats) 187 bus_flags = di->bus_flags; 188 else 189 bus_flags = imxpd->bus_flags; 190 191 bus_fmt = bridge_state->input_bus_cfg.format; 192 if (!imx_pd_format_supported(bus_fmt)) 193 return -EINVAL; 194 195 bridge_state->output_bus_cfg.flags = bus_flags; 196 bridge_state->input_bus_cfg.flags = bus_flags; 197 imx_crtc_state->bus_flags = bus_flags; 198 imx_crtc_state->bus_format = bridge_state->input_bus_cfg.format; 199 imx_crtc_state->di_hsync_pin = 2; 200 imx_crtc_state->di_vsync_pin = 3; 201 202 return 0; 203 } 204 205 static const struct drm_connector_funcs imx_pd_connector_funcs = { 206 .fill_modes = drm_helper_probe_single_connector_modes, 207 .destroy = imx_drm_connector_destroy, 208 .reset = drm_atomic_helper_connector_reset, 209 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 210 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 211 }; 212 213 static const struct drm_connector_helper_funcs imx_pd_connector_helper_funcs = { 214 .get_modes = imx_pd_connector_get_modes, 215 }; 216 217 static const struct drm_bridge_funcs imx_pd_bridge_funcs = { 218 .atomic_reset = drm_atomic_helper_bridge_reset, 219 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 220 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 221 .atomic_check = imx_pd_bridge_atomic_check, 222 .atomic_get_input_bus_fmts = imx_pd_bridge_atomic_get_input_bus_fmts, 223 .atomic_get_output_bus_fmts = imx_pd_bridge_atomic_get_output_bus_fmts, 224 }; 225 226 static int imx_pd_bind(struct device *dev, struct device *master, void *data) 227 { 228 struct drm_device *drm = data; 229 struct imx_parallel_display *imxpd = dev_get_drvdata(dev); 230 struct imx_parallel_display_encoder *imxpd_encoder; 231 struct drm_connector *connector; 232 struct drm_encoder *encoder; 233 struct drm_bridge *bridge; 234 int ret; 235 236 imxpd_encoder = drmm_simple_encoder_alloc(drm, struct imx_parallel_display_encoder, 237 encoder, DRM_MODE_ENCODER_NONE); 238 if (IS_ERR(imxpd_encoder)) 239 return PTR_ERR(imxpd_encoder); 240 241 imxpd_encoder->pd = imxpd; 242 connector = &imxpd_encoder->connector; 243 encoder = &imxpd_encoder->encoder; 244 bridge = &imxpd_encoder->bridge; 245 246 ret = imx_drm_encoder_parse_of(drm, encoder, imxpd->dev->of_node); 247 if (ret) 248 return ret; 249 250 /* set the connector's dpms to OFF so that 251 * drm_helper_connector_dpms() won't return 252 * immediately since the current state is ON 253 * at this point. 254 */ 255 connector->dpms = DRM_MODE_DPMS_OFF; 256 257 bridge->funcs = &imx_pd_bridge_funcs; 258 drm_bridge_attach(encoder, bridge, NULL, 0); 259 260 if (imxpd->next_bridge) { 261 ret = drm_bridge_attach(encoder, imxpd->next_bridge, bridge, 0); 262 if (ret < 0) 263 return ret; 264 } else { 265 drm_connector_helper_add(connector, 266 &imx_pd_connector_helper_funcs); 267 drm_connector_init(drm, connector, &imx_pd_connector_funcs, 268 DRM_MODE_CONNECTOR_DPI); 269 270 drm_connector_attach_encoder(connector, encoder); 271 } 272 273 return 0; 274 } 275 276 static const struct component_ops imx_pd_ops = { 277 .bind = imx_pd_bind, 278 }; 279 280 static int imx_pd_probe(struct platform_device *pdev) 281 { 282 struct device *dev = &pdev->dev; 283 struct device_node *np = dev->of_node; 284 struct imx_parallel_display *imxpd; 285 int ret; 286 u32 bus_format = 0; 287 const char *fmt; 288 289 imxpd = devm_kzalloc(dev, sizeof(*imxpd), GFP_KERNEL); 290 if (!imxpd) 291 return -ENOMEM; 292 293 /* port@1 is the output port */ 294 imxpd->next_bridge = devm_drm_of_get_bridge(dev, np, 1, 0); 295 if (IS_ERR(imxpd->next_bridge)) { 296 ret = PTR_ERR(imxpd->next_bridge); 297 if (ret != -ENODEV) 298 return ret; 299 300 imxpd->next_bridge = NULL; 301 } 302 303 ret = of_property_read_string(np, "interface-pix-fmt", &fmt); 304 if (!ret) { 305 if (!strcmp(fmt, "rgb24")) 306 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 307 else if (!strcmp(fmt, "rgb565")) 308 bus_format = MEDIA_BUS_FMT_RGB565_1X16; 309 else if (!strcmp(fmt, "bgr666")) 310 bus_format = MEDIA_BUS_FMT_RGB666_1X18; 311 else if (!strcmp(fmt, "lvds666")) 312 bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI; 313 } 314 imxpd->bus_format = bus_format; 315 316 imxpd->dev = dev; 317 318 platform_set_drvdata(pdev, imxpd); 319 320 return component_add(dev, &imx_pd_ops); 321 } 322 323 static void imx_pd_remove(struct platform_device *pdev) 324 { 325 component_del(&pdev->dev, &imx_pd_ops); 326 } 327 328 static const struct of_device_id imx_pd_dt_ids[] = { 329 { .compatible = "fsl,imx-parallel-display", }, 330 { /* sentinel */ } 331 }; 332 MODULE_DEVICE_TABLE(of, imx_pd_dt_ids); 333 334 static struct platform_driver imx_pd_driver = { 335 .probe = imx_pd_probe, 336 .remove_new = imx_pd_remove, 337 .driver = { 338 .of_match_table = imx_pd_dt_ids, 339 .name = "imx-parallel-display", 340 }, 341 }; 342 343 module_platform_driver(imx_pd_driver); 344 345 MODULE_DESCRIPTION("i.MX parallel display driver"); 346 MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 347 MODULE_LICENSE("GPL"); 348 MODULE_ALIAS("platform:imx-parallel-display"); 349