1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2012 Texas Instruments 4 * Author: Rob Clark <robdclark@gmail.com> 5 */ 6 7 #include <linux/pinctrl/pinmux.h> 8 #include <linux/pinctrl/consumer.h> 9 #include <linux/backlight.h> 10 #include <linux/gpio/consumer.h> 11 #include <video/display_timing.h> 12 #include <video/of_display_timing.h> 13 #include <video/videomode.h> 14 #include <drm/drm_atomic_helper.h> 15 #include <drm/drm_probe_helper.h> 16 17 #include "tilcdc_drv.h" 18 #include "tilcdc_panel.h" 19 20 struct panel_module { 21 struct tilcdc_module base; 22 struct tilcdc_panel_info *info; 23 struct display_timings *timings; 24 struct backlight_device *backlight; 25 struct gpio_desc *enable_gpio; 26 }; 27 #define to_panel_module(x) container_of(x, struct panel_module, base) 28 29 30 /* 31 * Encoder: 32 */ 33 34 struct panel_encoder { 35 struct drm_encoder base; 36 struct panel_module *mod; 37 }; 38 #define to_panel_encoder(x) container_of(x, struct panel_encoder, base) 39 40 static void panel_encoder_dpms(struct drm_encoder *encoder, int mode) 41 { 42 struct panel_encoder *panel_encoder = to_panel_encoder(encoder); 43 struct backlight_device *backlight = panel_encoder->mod->backlight; 44 struct gpio_desc *gpio = panel_encoder->mod->enable_gpio; 45 46 if (backlight) { 47 backlight->props.power = mode == DRM_MODE_DPMS_ON ? 48 FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; 49 backlight_update_status(backlight); 50 } 51 52 if (gpio) 53 gpiod_set_value_cansleep(gpio, 54 mode == DRM_MODE_DPMS_ON ? 1 : 0); 55 } 56 57 static void panel_encoder_prepare(struct drm_encoder *encoder) 58 { 59 panel_encoder_dpms(encoder, DRM_MODE_DPMS_OFF); 60 } 61 62 static void panel_encoder_commit(struct drm_encoder *encoder) 63 { 64 panel_encoder_dpms(encoder, DRM_MODE_DPMS_ON); 65 } 66 67 static void panel_encoder_mode_set(struct drm_encoder *encoder, 68 struct drm_display_mode *mode, 69 struct drm_display_mode *adjusted_mode) 70 { 71 /* nothing needed */ 72 } 73 74 static const struct drm_encoder_funcs panel_encoder_funcs = { 75 .destroy = drm_encoder_cleanup, 76 }; 77 78 static const struct drm_encoder_helper_funcs panel_encoder_helper_funcs = { 79 .dpms = panel_encoder_dpms, 80 .prepare = panel_encoder_prepare, 81 .commit = panel_encoder_commit, 82 .mode_set = panel_encoder_mode_set, 83 }; 84 85 static struct drm_encoder *panel_encoder_create(struct drm_device *dev, 86 struct panel_module *mod) 87 { 88 struct panel_encoder *panel_encoder; 89 struct drm_encoder *encoder; 90 int ret; 91 92 panel_encoder = devm_kzalloc(dev->dev, sizeof(*panel_encoder), 93 GFP_KERNEL); 94 if (!panel_encoder) 95 return NULL; 96 97 panel_encoder->mod = mod; 98 99 encoder = &panel_encoder->base; 100 encoder->possible_crtcs = 1; 101 102 ret = drm_encoder_init(dev, encoder, &panel_encoder_funcs, 103 DRM_MODE_ENCODER_LVDS, NULL); 104 if (ret < 0) 105 goto fail; 106 107 drm_encoder_helper_add(encoder, &panel_encoder_helper_funcs); 108 109 return encoder; 110 111 fail: 112 drm_encoder_cleanup(encoder); 113 return NULL; 114 } 115 116 /* 117 * Connector: 118 */ 119 120 struct panel_connector { 121 struct drm_connector base; 122 123 struct drm_encoder *encoder; /* our connected encoder */ 124 struct panel_module *mod; 125 }; 126 #define to_panel_connector(x) container_of(x, struct panel_connector, base) 127 128 129 static void panel_connector_destroy(struct drm_connector *connector) 130 { 131 drm_connector_unregister(connector); 132 drm_connector_cleanup(connector); 133 } 134 135 static int panel_connector_get_modes(struct drm_connector *connector) 136 { 137 struct drm_device *dev = connector->dev; 138 struct panel_connector *panel_connector = to_panel_connector(connector); 139 struct display_timings *timings = panel_connector->mod->timings; 140 int i; 141 142 for (i = 0; i < timings->num_timings; i++) { 143 struct drm_display_mode *mode = drm_mode_create(dev); 144 struct videomode vm; 145 146 if (videomode_from_timings(timings, &vm, i)) 147 break; 148 149 drm_display_mode_from_videomode(&vm, mode); 150 151 mode->type = DRM_MODE_TYPE_DRIVER; 152 153 if (timings->native_mode == i) 154 mode->type |= DRM_MODE_TYPE_PREFERRED; 155 156 drm_mode_set_name(mode); 157 drm_mode_probed_add(connector, mode); 158 } 159 160 return i; 161 } 162 163 static int panel_connector_mode_valid(struct drm_connector *connector, 164 struct drm_display_mode *mode) 165 { 166 struct tilcdc_drm_private *priv = connector->dev->dev_private; 167 /* our only constraints are what the crtc can generate: */ 168 return tilcdc_crtc_mode_valid(priv->crtc, mode); 169 } 170 171 static struct drm_encoder *panel_connector_best_encoder( 172 struct drm_connector *connector) 173 { 174 struct panel_connector *panel_connector = to_panel_connector(connector); 175 return panel_connector->encoder; 176 } 177 178 static const struct drm_connector_funcs panel_connector_funcs = { 179 .destroy = panel_connector_destroy, 180 .fill_modes = drm_helper_probe_single_connector_modes, 181 .reset = drm_atomic_helper_connector_reset, 182 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 183 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 184 }; 185 186 static const struct drm_connector_helper_funcs panel_connector_helper_funcs = { 187 .get_modes = panel_connector_get_modes, 188 .mode_valid = panel_connector_mode_valid, 189 .best_encoder = panel_connector_best_encoder, 190 }; 191 192 static struct drm_connector *panel_connector_create(struct drm_device *dev, 193 struct panel_module *mod, struct drm_encoder *encoder) 194 { 195 struct panel_connector *panel_connector; 196 struct drm_connector *connector; 197 int ret; 198 199 panel_connector = devm_kzalloc(dev->dev, sizeof(*panel_connector), 200 GFP_KERNEL); 201 if (!panel_connector) 202 return NULL; 203 204 panel_connector->encoder = encoder; 205 panel_connector->mod = mod; 206 207 connector = &panel_connector->base; 208 209 drm_connector_init(dev, connector, &panel_connector_funcs, 210 DRM_MODE_CONNECTOR_LVDS); 211 drm_connector_helper_add(connector, &panel_connector_helper_funcs); 212 213 connector->interlace_allowed = 0; 214 connector->doublescan_allowed = 0; 215 216 ret = drm_connector_attach_encoder(connector, encoder); 217 if (ret) 218 goto fail; 219 220 return connector; 221 222 fail: 223 panel_connector_destroy(connector); 224 return NULL; 225 } 226 227 /* 228 * Module: 229 */ 230 231 static int panel_modeset_init(struct tilcdc_module *mod, struct drm_device *dev) 232 { 233 struct panel_module *panel_mod = to_panel_module(mod); 234 struct tilcdc_drm_private *priv = dev->dev_private; 235 struct drm_encoder *encoder; 236 struct drm_connector *connector; 237 238 encoder = panel_encoder_create(dev, panel_mod); 239 if (!encoder) 240 return -ENOMEM; 241 242 connector = panel_connector_create(dev, panel_mod, encoder); 243 if (!connector) 244 return -ENOMEM; 245 246 priv->encoders[priv->num_encoders++] = encoder; 247 priv->connectors[priv->num_connectors++] = connector; 248 249 tilcdc_crtc_set_panel_info(priv->crtc, 250 to_panel_encoder(encoder)->mod->info); 251 252 return 0; 253 } 254 255 static const struct tilcdc_module_ops panel_module_ops = { 256 .modeset_init = panel_modeset_init, 257 }; 258 259 /* 260 * Device: 261 */ 262 263 /* maybe move this somewhere common if it is needed by other outputs? */ 264 static struct tilcdc_panel_info *of_get_panel_info(struct device_node *np) 265 { 266 struct device_node *info_np; 267 struct tilcdc_panel_info *info; 268 int ret = 0; 269 270 if (!np) { 271 pr_err("%s: no devicenode given\n", __func__); 272 return NULL; 273 } 274 275 info_np = of_get_child_by_name(np, "panel-info"); 276 if (!info_np) { 277 pr_err("%s: could not find panel-info node\n", __func__); 278 return NULL; 279 } 280 281 info = kzalloc(sizeof(*info), GFP_KERNEL); 282 if (!info) 283 goto put_node; 284 285 ret |= of_property_read_u32(info_np, "ac-bias", &info->ac_bias); 286 ret |= of_property_read_u32(info_np, "ac-bias-intrpt", &info->ac_bias_intrpt); 287 ret |= of_property_read_u32(info_np, "dma-burst-sz", &info->dma_burst_sz); 288 ret |= of_property_read_u32(info_np, "bpp", &info->bpp); 289 ret |= of_property_read_u32(info_np, "fdd", &info->fdd); 290 ret |= of_property_read_u32(info_np, "sync-edge", &info->sync_edge); 291 ret |= of_property_read_u32(info_np, "sync-ctrl", &info->sync_ctrl); 292 ret |= of_property_read_u32(info_np, "raster-order", &info->raster_order); 293 ret |= of_property_read_u32(info_np, "fifo-th", &info->fifo_th); 294 295 /* optional: */ 296 info->tft_alt_mode = of_property_read_bool(info_np, "tft-alt-mode"); 297 info->invert_pxl_clk = of_property_read_bool(info_np, "invert-pxl-clk"); 298 299 if (ret) { 300 pr_err("%s: error reading panel-info properties\n", __func__); 301 kfree(info); 302 info = NULL; 303 } 304 305 put_node: 306 of_node_put(info_np); 307 return info; 308 } 309 310 static int panel_probe(struct platform_device *pdev) 311 { 312 struct device_node *bl_node, *node = pdev->dev.of_node; 313 struct panel_module *panel_mod; 314 struct tilcdc_module *mod; 315 struct pinctrl *pinctrl; 316 int ret; 317 318 /* bail out early if no DT data: */ 319 if (!node) { 320 dev_err(&pdev->dev, "device-tree data is missing\n"); 321 return -ENXIO; 322 } 323 324 panel_mod = devm_kzalloc(&pdev->dev, sizeof(*panel_mod), GFP_KERNEL); 325 if (!panel_mod) 326 return -ENOMEM; 327 328 bl_node = of_parse_phandle(node, "backlight", 0); 329 if (bl_node) { 330 panel_mod->backlight = of_find_backlight_by_node(bl_node); 331 of_node_put(bl_node); 332 333 if (!panel_mod->backlight) 334 return -EPROBE_DEFER; 335 336 dev_info(&pdev->dev, "found backlight\n"); 337 } 338 339 panel_mod->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable", 340 GPIOD_OUT_LOW); 341 if (IS_ERR(panel_mod->enable_gpio)) { 342 ret = PTR_ERR(panel_mod->enable_gpio); 343 dev_err(&pdev->dev, "failed to request enable GPIO\n"); 344 goto fail_backlight; 345 } 346 347 if (panel_mod->enable_gpio) 348 dev_info(&pdev->dev, "found enable GPIO\n"); 349 350 mod = &panel_mod->base; 351 pdev->dev.platform_data = mod; 352 353 tilcdc_module_init(mod, "panel", &panel_module_ops); 354 355 pinctrl = devm_pinctrl_get_select_default(&pdev->dev); 356 if (IS_ERR(pinctrl)) 357 dev_warn(&pdev->dev, "pins are not configured\n"); 358 359 panel_mod->timings = of_get_display_timings(node); 360 if (!panel_mod->timings) { 361 dev_err(&pdev->dev, "could not get panel timings\n"); 362 ret = -EINVAL; 363 goto fail_free; 364 } 365 366 panel_mod->info = of_get_panel_info(node); 367 if (!panel_mod->info) { 368 dev_err(&pdev->dev, "could not get panel info\n"); 369 ret = -EINVAL; 370 goto fail_timings; 371 } 372 373 return 0; 374 375 fail_timings: 376 display_timings_release(panel_mod->timings); 377 378 fail_free: 379 tilcdc_module_cleanup(mod); 380 381 fail_backlight: 382 if (panel_mod->backlight) 383 put_device(&panel_mod->backlight->dev); 384 return ret; 385 } 386 387 static int panel_remove(struct platform_device *pdev) 388 { 389 struct tilcdc_module *mod = dev_get_platdata(&pdev->dev); 390 struct panel_module *panel_mod = to_panel_module(mod); 391 struct backlight_device *backlight = panel_mod->backlight; 392 393 if (backlight) 394 put_device(&backlight->dev); 395 396 display_timings_release(panel_mod->timings); 397 398 tilcdc_module_cleanup(mod); 399 kfree(panel_mod->info); 400 401 return 0; 402 } 403 404 static const struct of_device_id panel_of_match[] = { 405 { .compatible = "ti,tilcdc,panel", }, 406 { }, 407 }; 408 409 struct platform_driver panel_driver = { 410 .probe = panel_probe, 411 .remove = panel_remove, 412 .driver = { 413 .owner = THIS_MODULE, 414 .name = "tilcdc-panel", 415 .of_match_table = panel_of_match, 416 }, 417 }; 418 419 int __init tilcdc_panel_init(void) 420 { 421 return platform_driver_register(&panel_driver); 422 } 423 424 void __exit tilcdc_panel_fini(void) 425 { 426 platform_driver_unregister(&panel_driver); 427 } 428