drm/tilcdc/tilcdc_panel.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2012 Texas Instruments
0004  * Author: Rob Clark <robdclark@gmail.com>
0005  */
0006
0007 #include <linux/backlight.h>
0008 #include <linux/gpio/consumer.h>
0009 #include <linux/pinctrl/consumer.h>
0010 #include <linux/platform_device.h>
0011
0012 #include <video/display_timing.h>
0013 #include <video/of_display_timing.h>
0014 #include <video/videomode.h>
0015
0016 #include <drm/drm_atomic_state_helper.h>
0017 #include <drm/drm_connector.h>
0018 #include <drm/drm_modeset_helper_vtables.h>
0019 #include <drm/drm_probe_helper.h>
0020 #include <drm/drm_simple_kms_helper.h>
0021
0022 #include "tilcdc_drv.h"
0023 #include "tilcdc_panel.h"
0024
0025 struct panel_module {
0026     struct tilcdc_module base;
0027     struct tilcdc_panel_info *info;
0028     struct display_timings *timings;
0029     struct backlight_device *backlight;
0030     struct gpio_desc *enable_gpio;
0031 };
0032 #define to_panel_module(x) container_of(x, struct panel_module, base)
0033
0034
0035 /*
0036  * Encoder:
0037  */
0038
0039 struct panel_encoder {
0040     struct drm_encoder base;
0041     struct panel_module *mod;
0042 };
0043 #define to_panel_encoder(x) container_of(x, struct panel_encoder, base)
0044
0045 static void panel_encoder_dpms(struct drm_encoder *encoder, int mode)
0046 {
0047     struct panel_encoder *panel_encoder = to_panel_encoder(encoder);
0048     struct backlight_device *backlight = panel_encoder->mod->backlight;
0049     struct gpio_desc *gpio = panel_encoder->mod->enable_gpio;
0050
0051     if (backlight) {
0052         backlight->props.power = mode == DRM_MODE_DPMS_ON ?
0053                      FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
0054         backlight_update_status(backlight);
0055     }
0056
0057     if (gpio)
0058         gpiod_set_value_cansleep(gpio,
0059                      mode == DRM_MODE_DPMS_ON ? 1 : 0);
0060 }
0061
0062 static void panel_encoder_prepare(struct drm_encoder *encoder)
0063 {
0064     panel_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
0065 }
0066
0067 static void panel_encoder_commit(struct drm_encoder *encoder)
0068 {
0069     panel_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
0070 }
0071
0072 static void panel_encoder_mode_set(struct drm_encoder *encoder,
0073         struct drm_display_mode *mode,
0074         struct drm_display_mode *adjusted_mode)
0075 {
0076     /* nothing needed */
0077 }
0078
0079 static const struct drm_encoder_helper_funcs panel_encoder_helper_funcs = {
0080         .dpms           = panel_encoder_dpms,
0081         .prepare        = panel_encoder_prepare,
0082         .commit         = panel_encoder_commit,
0083         .mode_set       = panel_encoder_mode_set,
0084 };
0085
0086 static struct drm_encoder *panel_encoder_create(struct drm_device *dev,
0087         struct panel_module *mod)
0088 {
0089     struct panel_encoder *panel_encoder;
0090     struct drm_encoder *encoder;
0091     int ret;
0092
0093     panel_encoder = devm_kzalloc(dev->dev, sizeof(*panel_encoder),
0094                      GFP_KERNEL);
0095     if (!panel_encoder)
0096         return NULL;
0097
0098     panel_encoder->mod = mod;
0099
0100     encoder = &panel_encoder->base;
0101     encoder->possible_crtcs = 1;
0102
0103     ret = drm_simple_encoder_init(dev, encoder, DRM_MODE_ENCODER_LVDS);
0104     if (ret < 0)
0105         goto fail;
0106
0107     drm_encoder_helper_add(encoder, &panel_encoder_helper_funcs);
0108
0109     return encoder;
0110
0111 fail:
0112     drm_encoder_cleanup(encoder);
0113     return NULL;
0114 }
0115
0116 /*
0117  * Connector:
0118  */
0119
0120 struct panel_connector {
0121     struct drm_connector base;
0122
0123     struct drm_encoder *encoder;  /* our connected encoder */
0124     struct panel_module *mod;
0125 };
0126 #define to_panel_connector(x) container_of(x, struct panel_connector, base)
0127
0128
0129 static void panel_connector_destroy(struct drm_connector *connector)
0130 {
0131     drm_connector_unregister(connector);
0132     drm_connector_cleanup(connector);
0133 }
0134
0135 static int panel_connector_get_modes(struct drm_connector *connector)
0136 {
0137     struct drm_device *dev = connector->dev;
0138     struct panel_connector *panel_connector = to_panel_connector(connector);
0139     struct display_timings *timings = panel_connector->mod->timings;
0140     int i;
0141
0142     for (i = 0; i < timings->num_timings; i++) {
0143         struct drm_display_mode *mode;
0144         struct videomode vm;
0145
0146         if (videomode_from_timings(timings, &vm, i))
0147             break;
0148
0149         mode = drm_mode_create(dev);
0150         if (!mode)
0151             break;
0152
0153         drm_display_mode_from_videomode(&vm, mode);
0154
0155         mode->type = DRM_MODE_TYPE_DRIVER;
0156
0157         if (timings->native_mode == i)
0158             mode->type |= DRM_MODE_TYPE_PREFERRED;
0159
0160         drm_mode_set_name(mode);
0161         drm_mode_probed_add(connector, mode);
0162     }
0163
0164     return i;
0165 }
0166
0167 static struct drm_encoder *panel_connector_best_encoder(
0168         struct drm_connector *connector)
0169 {
0170     struct panel_connector *panel_connector = to_panel_connector(connector);
0171     return panel_connector->encoder;
0172 }
0173
0174 static const struct drm_connector_funcs panel_connector_funcs = {
0175     .destroy            = panel_connector_destroy,
0176     .fill_modes         = drm_helper_probe_single_connector_modes,
0177     .reset              = drm_atomic_helper_connector_reset,
0178     .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
0179     .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
0180 };
0181
0182 static const struct drm_connector_helper_funcs panel_connector_helper_funcs = {
0183     .get_modes          = panel_connector_get_modes,
0184     .best_encoder       = panel_connector_best_encoder,
0185 };
0186
0187 static struct drm_connector *panel_connector_create(struct drm_device *dev,
0188         struct panel_module *mod, struct drm_encoder *encoder)
0189 {
0190     struct panel_connector *panel_connector;
0191     struct drm_connector *connector;
0192     int ret;
0193
0194     panel_connector = devm_kzalloc(dev->dev, sizeof(*panel_connector),
0195                        GFP_KERNEL);
0196     if (!panel_connector)
0197         return NULL;
0198
0199     panel_connector->encoder = encoder;
0200     panel_connector->mod = mod;
0201
0202     connector = &panel_connector->base;
0203
0204     drm_connector_init(dev, connector, &panel_connector_funcs,
0205             DRM_MODE_CONNECTOR_LVDS);
0206     drm_connector_helper_add(connector, &panel_connector_helper_funcs);
0207
0208     connector->interlace_allowed = 0;
0209     connector->doublescan_allowed = 0;
0210
0211     ret = drm_connector_attach_encoder(connector, encoder);
0212     if (ret)
0213         goto fail;
0214
0215     return connector;
0216
0217 fail:
0218     panel_connector_destroy(connector);
0219     return NULL;
0220 }
0221
0222 /*
0223  * Module:
0224  */
0225
0226 static int panel_modeset_init(struct tilcdc_module *mod, struct drm_device *dev)
0227 {
0228     struct panel_module *panel_mod = to_panel_module(mod);
0229     struct tilcdc_drm_private *priv = dev->dev_private;
0230     struct drm_encoder *encoder;
0231     struct drm_connector *connector;
0232
0233     encoder = panel_encoder_create(dev, panel_mod);
0234     if (!encoder)
0235         return -ENOMEM;
0236
0237     connector = panel_connector_create(dev, panel_mod, encoder);
0238     if (!connector)
0239         return -ENOMEM;
0240
0241     priv->encoders[priv->num_encoders++] = encoder;
0242     priv->connectors[priv->num_connectors++] = connector;
0243
0244     tilcdc_crtc_set_panel_info(priv->crtc,
0245                    to_panel_encoder(encoder)->mod->info);
0246
0247     return 0;
0248 }
0249
0250 static const struct tilcdc_module_ops panel_module_ops = {
0251         .modeset_init = panel_modeset_init,
0252 };
0253
0254 /*
0255  * Device:
0256  */
0257
0258 /* maybe move this somewhere common if it is needed by other outputs? */
0259 static struct tilcdc_panel_info *of_get_panel_info(struct device_node *np)
0260 {
0261     struct device_node *info_np;
0262     struct tilcdc_panel_info *info;
0263     int ret = 0;
0264
0265     if (!np) {
0266         pr_err("%s: no devicenode given\n", __func__);
0267         return NULL;
0268     }
0269
0270     info_np = of_get_child_by_name(np, "panel-info");
0271     if (!info_np) {
0272         pr_err("%s: could not find panel-info node\n", __func__);
0273         return NULL;
0274     }
0275
0276     info = kzalloc(sizeof(*info), GFP_KERNEL);
0277     if (!info)
0278         goto put_node;
0279
0280     ret |= of_property_read_u32(info_np, "ac-bias", &info->ac_bias);
0281     ret |= of_property_read_u32(info_np, "ac-bias-intrpt", &info->ac_bias_intrpt);
0282     ret |= of_property_read_u32(info_np, "dma-burst-sz", &info->dma_burst_sz);
0283     ret |= of_property_read_u32(info_np, "bpp", &info->bpp);
0284     ret |= of_property_read_u32(info_np, "fdd", &info->fdd);
0285     ret |= of_property_read_u32(info_np, "sync-edge", &info->sync_edge);
0286     ret |= of_property_read_u32(info_np, "sync-ctrl", &info->sync_ctrl);
0287     ret |= of_property_read_u32(info_np, "raster-order", &info->raster_order);
0288     ret |= of_property_read_u32(info_np, "fifo-th", &info->fifo_th);
0289
0290     /* optional: */
0291     info->tft_alt_mode      = of_property_read_bool(info_np, "tft-alt-mode");
0292     info->invert_pxl_clk    = of_property_read_bool(info_np, "invert-pxl-clk");
0293
0294     if (ret) {
0295         pr_err("%s: error reading panel-info properties\n", __func__);
0296         kfree(info);
0297         info = NULL;
0298     }
0299
0300 put_node:
0301     of_node_put(info_np);
0302     return info;
0303 }
0304
0305 static int panel_probe(struct platform_device *pdev)
0306 {
0307     struct device_node *node = pdev->dev.of_node;
0308     struct backlight_device *backlight;
0309     struct panel_module *panel_mod;
0310     struct tilcdc_module *mod;
0311     struct pinctrl *pinctrl;
0312     int ret;
0313
0314     /* bail out early if no DT data: */
0315     if (!node) {
0316         dev_err(&pdev->dev, "device-tree data is missing\n");
0317         return -ENXIO;
0318     }
0319
0320     panel_mod = devm_kzalloc(&pdev->dev, sizeof(*panel_mod), GFP_KERNEL);
0321     if (!panel_mod)
0322         return -ENOMEM;
0323
0324     backlight = devm_of_find_backlight(&pdev->dev);
0325     if (IS_ERR(backlight))
0326         return PTR_ERR(backlight);
0327     panel_mod->backlight = backlight;
0328
0329     panel_mod->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
0330                              GPIOD_OUT_LOW);
0331     if (IS_ERR(panel_mod->enable_gpio)) {
0332         ret = PTR_ERR(panel_mod->enable_gpio);
0333         dev_err(&pdev->dev, "failed to request enable GPIO\n");
0334         goto fail_backlight;
0335     }
0336
0337     if (panel_mod->enable_gpio)
0338         dev_info(&pdev->dev, "found enable GPIO\n");
0339
0340     mod = &panel_mod->base;
0341     pdev->dev.platform_data = mod;
0342
0343     tilcdc_module_init(mod, "panel", &panel_module_ops);
0344
0345     pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
0346     if (IS_ERR(pinctrl))
0347         dev_warn(&pdev->dev, "pins are not configured\n");
0348
0349     panel_mod->timings = of_get_display_timings(node);
0350     if (!panel_mod->timings) {
0351         dev_err(&pdev->dev, "could not get panel timings\n");
0352         ret = -EINVAL;
0353         goto fail_free;
0354     }
0355
0356     panel_mod->info = of_get_panel_info(node);
0357     if (!panel_mod->info) {
0358         dev_err(&pdev->dev, "could not get panel info\n");
0359         ret = -EINVAL;
0360         goto fail_timings;
0361     }
0362
0363     return 0;
0364
0365 fail_timings:
0366     display_timings_release(panel_mod->timings);
0367
0368 fail_free:
0369     tilcdc_module_cleanup(mod);
0370
0371 fail_backlight:
0372     if (panel_mod->backlight)
0373         put_device(&panel_mod->backlight->dev);
0374     return ret;
0375 }
0376
0377 static int panel_remove(struct platform_device *pdev)
0378 {
0379     struct tilcdc_module *mod = dev_get_platdata(&pdev->dev);
0380     struct panel_module *panel_mod = to_panel_module(mod);
0381     struct backlight_device *backlight = panel_mod->backlight;
0382
0383     if (backlight)
0384         put_device(&backlight->dev);
0385
0386     display_timings_release(panel_mod->timings);
0387
0388     tilcdc_module_cleanup(mod);
0389     kfree(panel_mod->info);
0390
0391     return 0;
0392 }
0393
0394 static const struct of_device_id panel_of_match[] = {
0395         { .compatible = "ti,tilcdc,panel", },
0396         { },
0397 };
0398
0399 static struct platform_driver panel_driver = {
0400     .probe = panel_probe,
0401     .remove = panel_remove,
0402     .driver = {
0403         .name = "tilcdc-panel",
0404         .of_match_table = panel_of_match,
0405     },
0406 };
0407
0408 int __init tilcdc_panel_init(void)
0409 {
0410     return platform_driver_register(&panel_driver);
0411 }
0412
0413 void __exit tilcdc_panel_fini(void)
0414 {
0415     platform_driver_unregister(&panel_driver);
0416 }