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 struct drm_bridge bridge; 29 struct imx_parallel_display *pd; 30 }; 31 32 struct imx_parallel_display { 33 struct device *dev; 34 u32 bus_format; 35 struct drm_bridge *next_bridge; 36 }; 37 38 static inline struct imx_parallel_display *bridge_to_imxpd(struct drm_bridge *b) 39 { 40 return container_of(b, struct imx_parallel_display_encoder, bridge)->pd; 41 } 42 43 static const u32 imx_pd_bus_fmts[] = { 44 MEDIA_BUS_FMT_RGB888_1X24, 45 MEDIA_BUS_FMT_BGR888_1X24, 46 MEDIA_BUS_FMT_GBR888_1X24, 47 MEDIA_BUS_FMT_RGB666_1X18, 48 MEDIA_BUS_FMT_RGB666_1X24_CPADHI, 49 MEDIA_BUS_FMT_RGB565_1X16, 50 }; 51 52 static u32 * 53 imx_pd_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge, 54 struct drm_bridge_state *bridge_state, 55 struct drm_crtc_state *crtc_state, 56 struct drm_connector_state *conn_state, 57 unsigned int *num_output_fmts) 58 { 59 struct drm_display_info *di = &conn_state->connector->display_info; 60 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 61 u32 *output_fmts; 62 63 if (!imxpd->bus_format && !di->num_bus_formats) { 64 *num_output_fmts = ARRAY_SIZE(imx_pd_bus_fmts); 65 return kmemdup(imx_pd_bus_fmts, sizeof(imx_pd_bus_fmts), 66 GFP_KERNEL); 67 } 68 69 *num_output_fmts = 1; 70 output_fmts = kmalloc(sizeof(*output_fmts), GFP_KERNEL); 71 if (!output_fmts) 72 return NULL; 73 74 if (!imxpd->bus_format && di->num_bus_formats) 75 output_fmts[0] = di->bus_formats[0]; 76 else 77 output_fmts[0] = imxpd->bus_format; 78 79 return output_fmts; 80 } 81 82 static bool imx_pd_format_supported(u32 output_fmt) 83 { 84 unsigned int i; 85 86 for (i = 0; i < ARRAY_SIZE(imx_pd_bus_fmts); i++) { 87 if (imx_pd_bus_fmts[i] == output_fmt) 88 return true; 89 } 90 91 return false; 92 } 93 94 static u32 * 95 imx_pd_bridge_atomic_get_input_bus_fmts(struct drm_bridge *bridge, 96 struct drm_bridge_state *bridge_state, 97 struct drm_crtc_state *crtc_state, 98 struct drm_connector_state *conn_state, 99 u32 output_fmt, 100 unsigned int *num_input_fmts) 101 { 102 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 103 u32 *input_fmts; 104 105 /* 106 * If the next bridge does not support bus format negotiation, let's 107 * use the static bus format definition (imxpd->bus_format) if it's 108 * specified, RGB888 when it's not. 109 */ 110 if (output_fmt == MEDIA_BUS_FMT_FIXED) 111 output_fmt = imxpd->bus_format ? : MEDIA_BUS_FMT_RGB888_1X24; 112 113 /* Now make sure the requested output format is supported. */ 114 if ((imxpd->bus_format && imxpd->bus_format != output_fmt) || 115 !imx_pd_format_supported(output_fmt)) { 116 *num_input_fmts = 0; 117 return NULL; 118 } 119 120 *num_input_fmts = 1; 121 input_fmts = kmalloc(sizeof(*input_fmts), GFP_KERNEL); 122 if (!input_fmts) 123 return NULL; 124 125 input_fmts[0] = output_fmt; 126 return input_fmts; 127 } 128 129 static int imx_pd_bridge_atomic_check(struct drm_bridge *bridge, 130 struct drm_bridge_state *bridge_state, 131 struct drm_crtc_state *crtc_state, 132 struct drm_connector_state *conn_state) 133 { 134 struct imx_crtc_state *imx_crtc_state = to_imx_crtc_state(crtc_state); 135 struct drm_display_info *di = &conn_state->connector->display_info; 136 struct drm_bridge_state *next_bridge_state = NULL; 137 struct drm_bridge *next_bridge; 138 u32 bus_flags, bus_fmt; 139 140 next_bridge = drm_bridge_get_next_bridge(bridge); 141 if (next_bridge) 142 next_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, 143 next_bridge); 144 145 if (next_bridge_state) 146 bus_flags = next_bridge_state->input_bus_cfg.flags; 147 else 148 bus_flags = di->bus_flags; 149 150 bus_fmt = bridge_state->input_bus_cfg.format; 151 if (!imx_pd_format_supported(bus_fmt)) 152 return -EINVAL; 153 154 bridge_state->output_bus_cfg.flags = bus_flags; 155 bridge_state->input_bus_cfg.flags = bus_flags; 156 imx_crtc_state->bus_flags = bus_flags; 157 imx_crtc_state->bus_format = bridge_state->input_bus_cfg.format; 158 imx_crtc_state->di_hsync_pin = 2; 159 imx_crtc_state->di_vsync_pin = 3; 160 161 return 0; 162 } 163 164 static int imx_pd_bridge_attach(struct drm_bridge *bridge, 165 struct drm_encoder *encoder, 166 enum drm_bridge_attach_flags flags) 167 { 168 struct imx_parallel_display *imxpd = bridge_to_imxpd(bridge); 169 170 return drm_bridge_attach(encoder, imxpd->next_bridge, bridge, flags); 171 } 172 173 static const struct drm_bridge_funcs imx_pd_bridge_funcs = { 174 .attach = imx_pd_bridge_attach, 175 .atomic_reset = drm_atomic_helper_bridge_reset, 176 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 177 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 178 .atomic_check = imx_pd_bridge_atomic_check, 179 .atomic_get_input_bus_fmts = imx_pd_bridge_atomic_get_input_bus_fmts, 180 .atomic_get_output_bus_fmts = imx_pd_bridge_atomic_get_output_bus_fmts, 181 }; 182 183 static int imx_pd_bind(struct device *dev, struct device *master, void *data) 184 { 185 struct drm_device *drm = data; 186 struct imx_parallel_display *imxpd = dev_get_drvdata(dev); 187 struct imx_parallel_display_encoder *imxpd_encoder; 188 struct drm_connector *connector; 189 struct drm_encoder *encoder; 190 struct drm_bridge *bridge; 191 int ret; 192 193 imxpd_encoder = drmm_simple_encoder_alloc(drm, struct imx_parallel_display_encoder, 194 encoder, DRM_MODE_ENCODER_NONE); 195 if (IS_ERR(imxpd_encoder)) 196 return PTR_ERR(imxpd_encoder); 197 198 imxpd_encoder->pd = imxpd; 199 encoder = &imxpd_encoder->encoder; 200 bridge = &imxpd_encoder->bridge; 201 202 ret = imx_drm_encoder_parse_of(drm, encoder, imxpd->dev->of_node); 203 if (ret) 204 return ret; 205 206 bridge->funcs = &imx_pd_bridge_funcs; 207 drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR); 208 209 connector = drm_bridge_connector_init(drm, encoder); 210 if (IS_ERR(connector)) 211 return PTR_ERR(connector); 212 213 drm_connector_attach_encoder(connector, encoder); 214 215 return 0; 216 } 217 218 static const struct component_ops imx_pd_ops = { 219 .bind = imx_pd_bind, 220 }; 221 222 static int imx_pd_probe(struct platform_device *pdev) 223 { 224 struct device *dev = &pdev->dev; 225 struct device_node *np = dev->of_node; 226 struct imx_parallel_display *imxpd; 227 int ret; 228 u32 bus_format = 0; 229 const char *fmt; 230 231 imxpd = devm_kzalloc(dev, sizeof(*imxpd), GFP_KERNEL); 232 if (!imxpd) 233 return -ENOMEM; 234 235 /* port@1 is the output port */ 236 imxpd->next_bridge = devm_drm_of_get_bridge(dev, np, 1, 0); 237 if (imxpd->next_bridge == ERR_PTR(-ENODEV)) 238 imxpd->next_bridge = devm_imx_drm_legacy_bridge(dev, np, DRM_MODE_CONNECTOR_DPI); 239 if (IS_ERR(imxpd->next_bridge)) { 240 ret = PTR_ERR(imxpd->next_bridge); 241 return ret; 242 } 243 244 ret = of_property_read_string(np, "interface-pix-fmt", &fmt); 245 if (!ret) { 246 if (!strcmp(fmt, "rgb24")) 247 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 248 else if (!strcmp(fmt, "rgb565")) 249 bus_format = MEDIA_BUS_FMT_RGB565_1X16; 250 else if (!strcmp(fmt, "bgr666")) 251 bus_format = MEDIA_BUS_FMT_RGB666_1X18; 252 else if (!strcmp(fmt, "lvds666")) 253 bus_format = MEDIA_BUS_FMT_RGB666_1X24_CPADHI; 254 } 255 imxpd->bus_format = bus_format; 256 257 imxpd->dev = dev; 258 259 platform_set_drvdata(pdev, imxpd); 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