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