drivers/gpu/drm/exynos/exynos_dp_core.c

   1 /*
   2  * Samsung SoC DP (Display Port) interface driver.
   3  *
   4  * Copyright (C) 2012 Samsung Electronics Co., Ltd.
   5  * Author: Jingoo Han <jg1.han@samsung.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/err.h>
  16 #include <linux/clk.h>
  17 #include <linux/of_graph.h>
  18 #include <linux/component.h>
  19 #include <video/of_display_timing.h>
  20 #include <video/of_videomode.h>
  21 #include <video/videomode.h>
  22
  23 #include <drm/drmP.h>
  24 #include <drm/drm_crtc.h>
  25 #include <drm/drm_crtc_helper.h>
  26 #include <drm/drm_panel.h>
  27
  28 #include <drm/bridge/analogix_dp.h>
  29 #include <drm/exynos_drm.h>
  30
  31 #include "exynos_drm_crtc.h"
  32
  33 #define to_dp(nm)       container_of(nm, struct exynos_dp_device, nm)
  34
  35 struct exynos_dp_device {
  36         struct drm_encoder         encoder;
  37         struct drm_connector       connector;
  38         struct drm_bridge          *ptn_bridge;
  39         struct drm_device          *drm_dev;
  40         struct device              *dev;
  41
  42         struct videomode           vm;
  43         struct analogix_dp_plat_data plat_data;
  44 };
  45
  46 int exynos_dp_crtc_clock_enable(struct analogix_dp_plat_data *plat_data,
  47                                 bool enable)
  48 {
  49         struct exynos_dp_device *dp = to_dp(plat_data);
  50         struct drm_encoder *encoder = &dp->encoder;
  51         struct exynos_drm_crtc *crtc;
  52
  53         if (!encoder)
  54                 return -1;
  55
  56         crtc = to_exynos_crtc(encoder->crtc);
  57         if (crtc && crtc->ops && crtc->ops->clock_enable)
  58                 crtc->ops->clock_enable(crtc, enable);
  59
  60         return 0;
  61 }
  62
  63 static int exynos_dp_poweron(struct analogix_dp_plat_data *plat_data)
  64 {
  65         return exynos_dp_crtc_clock_enable(plat_data, true);
  66 }
  67
  68 static int exynos_dp_poweroff(struct analogix_dp_plat_data *plat_data)
  69 {
  70         return exynos_dp_crtc_clock_enable(plat_data, false);
  71 }
  72
  73 static int exynos_dp_get_modes(struct analogix_dp_plat_data *plat_data)
  74 {
  75         struct exynos_dp_device *dp = to_dp(plat_data);
  76         struct drm_connector *connector = &dp->connector;
  77         struct drm_display_mode *mode;
  78         int num_modes = 0;
  79
  80         if (dp->plat_data.panel)
  81                 return num_modes;
  82
  83         mode = drm_mode_create(connector->dev);
  84         if (!mode) {
  85                 DRM_ERROR("failed to create a new display mode.\n");
  86                 return num_modes;
  87         }
  88
  89         drm_display_mode_from_videomode(&dp->priv.vm, mode);
  90         mode->width_mm = dp->priv.width_mm;
  91         mode->height_mm = dp->priv.height_mm;
  92         connector->display_info.width_mm = mode->width_mm;
  93         connector->display_info.height_mm = mode->height_mm;
  94
  95         mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
  96         drm_mode_set_name(mode);
  97         drm_mode_probed_add(connector, mode);
  98
  99         return num_modes + 1;
 100 }
 101
 102 static int exynos_dp_bridge_attach(struct analogix_dp_plat_data *plat_data,
 103                                    struct drm_bridge *bridge,
 104                                    struct drm_connector *connector)
 105 {
 106         struct exynos_dp_device *dp = to_dp(plat_data);
 107         struct drm_encoder *encoder = &dp->encoder;
 108         int ret;
 109
 110         drm_connector_register(connector);
 111
 112         /* Pre-empt DP connector creation if there's a bridge */
 113         if (dp->ptn_bridge) {
 114                 bridge->next = dp->ptn_bridge;
 115                 dp->ptn_bridge->encoder = encoder;
 116                 ret = drm_bridge_attach(encoder->dev, dp->ptn_bridge);
 117                 if (ret) {
 118                         DRM_ERROR("Failed to attach bridge to drm\n");
 119                         bridge->next = NULL;
 120                         return ret;
 121                 }
 122         }
 123
 124         return 0;
 125 }
 126
 127 static void exynos_dp_mode_set(struct drm_encoder *encoder,
 128                                struct drm_display_mode *mode,
 129                                struct drm_display_mode *adjusted_mode)
 130 {
 131 }
 132
 133 static void exynos_dp_nop(struct drm_encoder *encoder)
 134 {
 135         /* do nothing */
 136 }
 137
 138 static const struct drm_encoder_helper_funcs exynos_dp_encoder_helper_funcs = {
 139         .mode_set = exynos_dp_mode_set,
 140         .enable = exynos_dp_nop,
 141         .disable = exynos_dp_nop,
 142 };
 143
 144 static const struct drm_encoder_funcs exynos_dp_encoder_funcs = {
 145         .destroy = drm_encoder_cleanup,
 146 };
 147
 148 static int exynos_dp_dt_parse_panel(struct exynos_dp_device *dp)
 149 {
 150         int ret;
 151
 152         ret = of_get_videomode(dp->dev->of_node, &dp->priv.vm,
 153                         OF_USE_NATIVE_MODE);
 154         if (ret) {
 155                 DRM_ERROR("failed: of_get_videomode() : %d\n", ret);
 156                 return ret;
 157         }
 158         return 0;
 159 }
 160
 161 static int exynos_dp_bind(struct device *dev, struct device *master, void *data)
 162 {
 163         struct exynos_dp_device *dp = dev_get_drvdata(dev);
 164         struct drm_encoder *encoder = &dp->encoder;
 165         struct drm_device *drm_dev = data;
 166         int pipe, ret;
 167
 168         /*
 169          * Just like the probe function said, we don't need the
 170          * device drvrate anymore, we should leave the charge to
 171          * analogix dp driver, set the device drvdata to NULL.
 172          */
 173         dev_set_drvdata(dev, NULL);
 174
 175         dp->dev = dev;
 176         dp->drm_dev = drm_dev;
 177
 178         dp->plat_data.dev_type = EXYNOS_DP;
 179         dp->plat_data.power_on = exynos_dp_poweron;
 180         dp->plat_data.power_off = exynos_dp_poweroff;
 181         dp->plat_data.attach = exynos_dp_bridge_attach;
 182         dp->plat_data.get_modes = exynos_dp_get_modes;
 183
 184         if (!dp->plat_data.panel && !dp->ptn_bridge) {
 185                 ret = exynos_dp_dt_parse_panel(dp);
 186                 if (ret)
 187                         return ret;
 188         }
 189
 190         pipe = exynos_drm_crtc_get_pipe_from_type(drm_dev,
 191                                                   EXYNOS_DISPLAY_TYPE_LCD);
 192         if (pipe < 0)
 193                 return pipe;
 194
 195         encoder->possible_crtcs = 1 << pipe;
 196
 197         DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 198
 199         drm_encoder_init(drm_dev, encoder, &exynos_dp_encoder_funcs,
 200                          DRM_MODE_ENCODER_TMDS, NULL);
 201
 202         drm_encoder_helper_add(encoder, &exynos_dp_encoder_helper_funcs);
 203
 204         dp->plat_data.encoder = encoder;
 205
 206         return analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data);
 207 }
 208
 209 static void exynos_dp_unbind(struct device *dev, struct device *master,
 210                              void *data)
 211 {
 212         return analogix_dp_unbind(dev, master, data);
 213 }
 214
 215 static const struct component_ops exynos_dp_ops = {
 216         .bind   = exynos_dp_bind,
 217         .unbind = exynos_dp_unbind,
 218 };
 219
 220 static int exynos_dp_probe(struct platform_device *pdev)
 221 {
 222         struct device *dev = &pdev->dev;
 223         struct device_node *np = NULL, *endpoint = NULL;
 224         struct exynos_dp_device *dp;
 225
 226         dp = devm_kzalloc(&pdev->dev, sizeof(struct exynos_dp_device),
 227                           GFP_KERNEL);
 228         if (!dp)
 229                 return -ENOMEM;
 230
 231         /*
 232          * We just use the drvdata until driver run into component
 233          * add function, and then we would set drvdata to null, so
 234          * that analogix dp driver would take charge of the drvdata.
 235          */
 236         platform_set_drvdata(pdev, dp);
 237
 238         /* This is for the backward compatibility. */
 239         np = of_parse_phandle(dev->of_node, "panel", 0);
 240         if (np) {
 241                 dp->plat_data.panel = of_drm_find_panel(np);
 242                 of_node_put(np);
 243                 if (!dp->plat_data.panel)
 244                         return -EPROBE_DEFER;
 245                 goto out;
 246         }
 247
 248         endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);
 249         if (endpoint) {
 250                 np = of_graph_get_remote_port_parent(endpoint);
 251                 if (np) {
 252                         /* The remote port can be either a panel or a bridge */
 253                         dp->plat_data.panel = of_drm_find_panel(np);
 254                         if (!dp->plat_data.panel) {
 255                                 dp->ptn_bridge = of_drm_find_bridge(np);
 256                                 if (!dp->ptn_bridge) {
 257                                         of_node_put(np);
 258                                         return -EPROBE_DEFER;
 259                                 }
 260                         }
 261                         of_node_put(np);
 262                 } else {
 263                         DRM_ERROR("no remote endpoint device node found.\n");
 264                         return -EINVAL;
 265                 }
 266         } else {
 267                 DRM_ERROR("no port endpoint subnode found.\n");
 268                 return -EINVAL;
 269         }
 270
 271 out:
 272         return component_add(&pdev->dev, &exynos_dp_ops);
 273 }
 274
 275 static int exynos_dp_remove(struct platform_device *pdev)
 276 {
 277         component_del(&pdev->dev, &exynos_dp_ops);
 278
 279         return 0;
 280 }
 281
 282 #ifdef CONFIG_PM
 283 static int exynos_dp_suspend(struct device *dev)
 284 {
 285         return analogix_dp_suspend(dev);
 286 }
 287
 288 static int exynos_dp_resume(struct device *dev)
 289 {
 290         return analogix_dp_resume(dev);
 291 }
 292 #endif
 293
 294 static const struct dev_pm_ops exynos_dp_pm_ops = {
 295         SET_RUNTIME_PM_OPS(exynos_dp_suspend, exynos_dp_resume, NULL)
 296 };
 297
 298 static const struct of_device_id exynos_dp_match[] = {
 299         { .compatible = "samsung,exynos5-dp" },
 300         {},
 301 };
 302 MODULE_DEVICE_TABLE(of, exynos_dp_match);
 303
 304 struct platform_driver dp_driver = {
 305         .probe          = exynos_dp_probe,
 306         .remove         = exynos_dp_remove,
 307         .driver         = {
 308                 .name   = "exynos-dp",
 309                 .owner  = THIS_MODULE,
 310                 .pm     = &exynos_dp_pm_ops,
 311                 .of_match_table = exynos_dp_match,
 312         },
 313 };
 314
 315 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
 316 MODULE_DESCRIPTION("Samsung Specific Analogix-DP Driver Extension");
 317 MODULE_LICENSE("GPL v2");