drivers/gpu/drm/exynos/exynos_drm_connector.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
   3  * Authors:
   4  *      Inki Dae <inki.dae@samsung.com>
   5  *      Joonyoung Shim <jy0922.shim@samsung.com>
   6  *      Seung-Woo Kim <sw0312.kim@samsung.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the next
  16  * paragraph) shall be included in all copies or substantial portions of the
  17  * Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25  * OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include "drmP.h"
  29 #include "drm_crtc_helper.h"
  30
  31 #include "exynos_drm_drv.h"
  32 #include "exynos_drm_encoder.h"
  33
  34 #define MAX_EDID 256
  35 #define to_exynos_connector(x)  container_of(x, struct exynos_drm_connector,\
  36                                 drm_connector)
  37
  38 struct exynos_drm_connector {
  39         struct drm_connector    drm_connector;
  40 };
  41
  42 /* convert exynos_video_timings to drm_display_mode */
  43 static inline void
  44 convert_to_display_mode(struct drm_display_mode *mode,
  45                         struct fb_videomode *timing)
  46 {
  47         DRM_DEBUG_KMS("%s\n", __FILE__);
  48
  49         mode->clock = timing->pixclock / 1000;
  50         mode->vrefresh = timing->refresh;
  51
  52         mode->hdisplay = timing->xres;
  53         mode->hsync_start = mode->hdisplay + timing->left_margin;
  54         mode->hsync_end = mode->hsync_start + timing->hsync_len;
  55         mode->htotal = mode->hsync_end + timing->right_margin;
  56
  57         mode->vdisplay = timing->yres;
  58         mode->vsync_start = mode->vdisplay + timing->upper_margin;
  59         mode->vsync_end = mode->vsync_start + timing->vsync_len;
  60         mode->vtotal = mode->vsync_end + timing->lower_margin;
  61
  62         if (timing->vmode & FB_VMODE_INTERLACED)
  63                 mode->flags |= DRM_MODE_FLAG_INTERLACE;
  64
  65         if (timing->vmode & FB_VMODE_DOUBLE)
  66                 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
  67 }
  68
  69 /* convert drm_display_mode to exynos_video_timings */
  70 static inline void
  71 convert_to_video_timing(struct fb_videomode *timing,
  72                         struct drm_display_mode *mode)
  73 {
  74         DRM_DEBUG_KMS("%s\n", __FILE__);
  75
  76         memset(timing, 0, sizeof(*timing));
  77
  78         timing->pixclock = mode->clock * 1000;
  79         timing->refresh = drm_mode_vrefresh(mode);
  80
  81         timing->xres = mode->hdisplay;
  82         timing->left_margin = mode->hsync_start - mode->hdisplay;
  83         timing->hsync_len = mode->hsync_end - mode->hsync_start;
  84         timing->right_margin = mode->htotal - mode->hsync_end;
  85
  86         timing->yres = mode->vdisplay;
  87         timing->upper_margin = mode->vsync_start - mode->vdisplay;
  88         timing->vsync_len = mode->vsync_end - mode->vsync_start;
  89         timing->lower_margin = mode->vtotal - mode->vsync_end;
  90
  91         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
  92                 timing->vmode = FB_VMODE_INTERLACED;
  93         else
  94                 timing->vmode = FB_VMODE_NONINTERLACED;
  95
  96         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
  97                 timing->vmode |= FB_VMODE_DOUBLE;
  98 }
  99
 100 static int exynos_drm_connector_get_modes(struct drm_connector *connector)
 101 {
 102         struct exynos_drm_manager *manager =
 103                                 exynos_drm_get_manager(connector->encoder);
 104         struct exynos_drm_display *display = manager->display;
 105         unsigned int count;
 106
 107         DRM_DEBUG_KMS("%s\n", __FILE__);
 108
 109         if (!display) {
 110                 DRM_DEBUG_KMS("display is null.\n");
 111                 return 0;
 112         }
 113
 114         /*
 115          * if get_edid() exists then get_edid() callback of hdmi side
 116          * is called to get edid data through i2c interface else
 117          * get timing from the FIMD driver(display controller).
 118          *
 119          * P.S. in case of lcd panel, count is always 1 if success
 120          * because lcd panel has only one mode.
 121          */
 122         if (display->get_edid) {
 123                 int ret;
 124                 void *edid;
 125
 126                 edid = kzalloc(MAX_EDID, GFP_KERNEL);
 127                 if (!edid) {
 128                         DRM_ERROR("failed to allocate edid\n");
 129                         return 0;
 130                 }
 131
 132                 ret = display->get_edid(manager->dev, connector,
 133                                                 edid, MAX_EDID);
 134                 if (ret < 0) {
 135                         DRM_ERROR("failed to get edid data.\n");
 136                         kfree(edid);
 137                         edid = NULL;
 138                         return 0;
 139                 }
 140
 141                 drm_mode_connector_update_edid_property(connector, edid);
 142                 count = drm_add_edid_modes(connector, edid);
 143
 144                 kfree(connector->display_info.raw_edid);
 145                 connector->display_info.raw_edid = edid;
 146         } else {
 147                 struct drm_display_mode *mode = drm_mode_create(connector->dev);
 148                 struct fb_videomode *timing;
 149
 150                 if (display->get_timing)
 151                         timing = display->get_timing(manager->dev);
 152                 else {
 153                         drm_mode_destroy(connector->dev, mode);
 154                         return 0;
 155                 }
 156
 157                 convert_to_display_mode(mode, timing);
 158
 159                 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 160                 drm_mode_set_name(mode);
 161                 drm_mode_probed_add(connector, mode);
 162
 163                 count = 1;
 164         }
 165
 166         return count;
 167 }
 168
 169 static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
 170                                             struct drm_display_mode *mode)
 171 {
 172         struct exynos_drm_manager *manager =
 173                                 exynos_drm_get_manager(connector->encoder);
 174         struct exynos_drm_display *display = manager->display;
 175         struct fb_videomode timing;
 176         int ret = MODE_BAD;
 177
 178         DRM_DEBUG_KMS("%s\n", __FILE__);
 179
 180         convert_to_video_timing(&timing, mode);
 181
 182         if (display && display->check_timing)
 183                 if (!display->check_timing(manager->dev, (void *)&timing))
 184                         ret = MODE_OK;
 185
 186         return ret;
 187 }
 188
 189 struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
 190 {
 191         DRM_DEBUG_KMS("%s\n", __FILE__);
 192
 193         return connector->encoder;
 194 }
 195
 196 static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
 197         .get_modes      = exynos_drm_connector_get_modes,
 198         .mode_valid     = exynos_drm_connector_mode_valid,
 199         .best_encoder   = exynos_drm_best_encoder,
 200 };
 201
 202 /* get detection status of display device. */
 203 static enum drm_connector_status
 204 exynos_drm_connector_detect(struct drm_connector *connector, bool force)
 205 {
 206         struct exynos_drm_manager *manager =
 207                                 exynos_drm_get_manager(connector->encoder);
 208         struct exynos_drm_display *display = manager->display;
 209         enum drm_connector_status status = connector_status_disconnected;
 210
 211         DRM_DEBUG_KMS("%s\n", __FILE__);
 212
 213         if (display && display->is_connected) {
 214                 if (display->is_connected(manager->dev))
 215                         status = connector_status_connected;
 216                 else
 217                         status = connector_status_disconnected;
 218         }
 219
 220         return status;
 221 }
 222
 223 static void exynos_drm_connector_destroy(struct drm_connector *connector)
 224 {
 225         struct exynos_drm_connector *exynos_connector =
 226                 to_exynos_connector(connector);
 227
 228         DRM_DEBUG_KMS("%s\n", __FILE__);
 229
 230         drm_sysfs_connector_remove(connector);
 231         drm_connector_cleanup(connector);
 232         kfree(exynos_connector);
 233 }
 234
 235 static struct drm_connector_funcs exynos_connector_funcs = {
 236         .dpms           = drm_helper_connector_dpms,
 237         .fill_modes     = drm_helper_probe_single_connector_modes,
 238         .detect         = exynos_drm_connector_detect,
 239         .destroy        = exynos_drm_connector_destroy,
 240 };
 241
 242 struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
 243                                                    struct drm_encoder *encoder)
 244 {
 245         struct exynos_drm_connector *exynos_connector;
 246         struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
 247         struct drm_connector *connector;
 248         int type;
 249         int err;
 250
 251         DRM_DEBUG_KMS("%s\n", __FILE__);
 252
 253         exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL);
 254         if (!exynos_connector) {
 255                 DRM_ERROR("failed to allocate connector\n");
 256                 return NULL;
 257         }
 258
 259         connector = &exynos_connector->drm_connector;
 260
 261         switch (manager->display->type) {
 262         case EXYNOS_DISPLAY_TYPE_HDMI:
 263                 type = DRM_MODE_CONNECTOR_HDMIA;
 264                 connector->interlace_allowed = true;
 265                 connector->polled = DRM_CONNECTOR_POLL_HPD;
 266                 break;
 267         default:
 268                 type = DRM_MODE_CONNECTOR_Unknown;
 269                 break;
 270         }
 271
 272         drm_connector_init(dev, connector, &exynos_connector_funcs, type);
 273         drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
 274
 275         err = drm_sysfs_connector_add(connector);
 276         if (err)
 277                 goto err_connector;
 278
 279         connector->encoder = encoder;
 280         err = drm_mode_connector_attach_encoder(connector, encoder);
 281         if (err) {
 282                 DRM_ERROR("failed to attach a connector to a encoder\n");
 283                 goto err_sysfs;
 284         }
 285
 286         DRM_DEBUG_KMS("connector has been created\n");
 287
 288         return connector;
 289
 290 err_sysfs:
 291         drm_sysfs_connector_remove(connector);
 292 err_connector:
 293         drm_connector_cleanup(connector);
 294         kfree(exynos_connector);
 295         return NULL;
 296 }
 297
 298 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
 299 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 300 MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
 301 MODULE_DESCRIPTION("Samsung SoC DRM Connector Driver");
 302 MODULE_LICENSE("GPL");