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