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